Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

838 files changed, 141083 insertions, 0 deletions

diff --git a/include/linux/8250_pci.h b/include/linux/8250_pci.h
new file mode 100644
index 000000000000..5f3ab21b339b
--- /dev/null
+++ b/include/linux/8250_pci.h
@@ -0,0 +1,2 @@
+int pci_siig10x_fn(struct pci_dev *dev, int enable);
+int pci_siig20x_fn(struct pci_dev *dev, int enable);
diff --git a/include/linux/a.out.h b/include/linux/a.out.h
new file mode 100644
index 000000000000..af8a1dfa5c32
--- /dev/null
+++ b/include/linux/a.out.h
@@ -0,0 +1,268 @@
+#ifndef __A_OUT_GNU_H__
+#define __A_OUT_GNU_H__
+
+#define __GNU_EXEC_MACROS__
+
+#ifndef __STRUCT_EXEC_OVERRIDE__
+
+#include <asm/a.out.h>
+
+#endif /* __STRUCT_EXEC_OVERRIDE__ */
+
+/* these go in the N_MACHTYPE field */
+enum machine_type {
+#if defined (M_OLDSUN2)
+  M__OLDSUN2 = M_OLDSUN2,
+#else
+  M_OLDSUN2 = 0,
+#endif
+#if defined (M_68010)
+  M__68010 = M_68010,
+#else
+  M_68010 = 1,
+#endif
+#if defined (M_68020)
+  M__68020 = M_68020,
+#else
+  M_68020 = 2,
+#endif
+#if defined (M_SPARC)
+  M__SPARC = M_SPARC,
+#else
+  M_SPARC = 3,
+#endif
+  /* skip a bunch so we don't run into any of sun's numbers */
+  M_386 = 100,
+  M_MIPS1 = 151,        /* MIPS R3000/R3000 binary */
+  M_MIPS2 = 152         /* MIPS R6000/R4000 binary */
+};
+
+#if !defined (N_MAGIC)
+#define N_MAGIC(exec) ((exec).a_info & 0xffff)
+#endif
+#define N_MACHTYPE(exec) ((enum machine_type)(((exec).a_info >> 16) & 0xff))
+#define N_FLAGS(exec) (((exec).a_info >> 24) & 0xff)
+#define N_SET_INFO(exec, magic, type, flags) \
+        ((exec).a_info = ((magic) & 0xffff) \
+         | (((int)(type) & 0xff) << 16) \
+         | (((flags) & 0xff) << 24))
+#define N_SET_MAGIC(exec, magic) \
+        ((exec).a_info = (((exec).a_info & 0xffff0000) | ((magic) & 0xffff)))
+
+#define N_SET_MACHTYPE(exec, machtype) \
+        ((exec).a_info = \
+         ((exec).a_info&0xff00ffff) | ((((int)(machtype))&0xff) << 16))
+
+#define N_SET_FLAGS(exec, flags) \
+        ((exec).a_info = \
+         ((exec).a_info&0x00ffffff) | (((flags) & 0xff) << 24))
+
+/* Code indicating object file or impure executable.  */
+#define OMAGIC 0407
+/* Code indicating pure executable.  */
+#define NMAGIC 0410
+/* Code indicating demand-paged executable.  */
+#define ZMAGIC 0413
+/* This indicates a demand-paged executable with the header in the text. 
+   The first page is unmapped to help trap NULL pointer references */
+#define QMAGIC 0314
+
+/* Code indicating core file.  */
+#define CMAGIC 0421
+
+#if !defined (N_BADMAG)
+#define N_BADMAG(x)       (N_MAGIC(x) != OMAGIC         \
+                        && N_MAGIC(x) != NMAGIC         \
+                        && N_MAGIC(x) != ZMAGIC \
+                        && N_MAGIC(x) != QMAGIC)
+#endif
+
+#define _N_HDROFF(x) (1024 - sizeof (struct exec))
+
+#if !defined (N_TXTOFF)
+#define N_TXTOFF(x) \
+ (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \
+  (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
+#endif
+
+#if !defined (N_DATOFF)
+#define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text)
+#endif
+
+#if !defined (N_TRELOFF)
+#define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data)
+#endif
+
+#if !defined (N_DRELOFF)
+#define N_DRELOFF(x) (N_TRELOFF(x) + N_TRSIZE(x))
+#endif
+
+#if !defined (N_SYMOFF)
+#define N_SYMOFF(x) (N_DRELOFF(x) + N_DRSIZE(x))
+#endif
+
+#if !defined (N_STROFF)
+#define N_STROFF(x) (N_SYMOFF(x) + N_SYMSIZE(x))
+#endif
+
+/* Address of text segment in memory after it is loaded.  */
+#if !defined (N_TXTADDR)
+#define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? PAGE_SIZE : 0)
+#endif
+
+/* Address of data segment in memory after it is loaded.
+   Note that it is up to you to define SEGMENT_SIZE
+   on machines not listed here.  */
+#if defined(vax) || defined(hp300) || defined(pyr)
+#define SEGMENT_SIZE page_size
+#endif
+#ifdef  sony
+#define SEGMENT_SIZE    0x2000
+#endif  /* Sony.  */
+#ifdef is68k
+#define SEGMENT_SIZE 0x20000
+#endif
+#if defined(m68k) && defined(PORTAR)
+#define PAGE_SIZE 0x400
+#define SEGMENT_SIZE PAGE_SIZE
+#endif
+
+#ifdef linux
+#include <asm/page.h>
+#if defined(__i386__) || defined(__mc68000__)
+#define SEGMENT_SIZE    1024
+#else
+#ifndef SEGMENT_SIZE
+#define SEGMENT_SIZE    PAGE_SIZE
+#endif
+#endif
+#endif
+
+#define _N_SEGMENT_ROUND(x) (((x) + SEGMENT_SIZE - 1) & ~(SEGMENT_SIZE - 1))
+
+#define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text)
+
+#ifndef N_DATADDR
+#define N_DATADDR(x) \
+    (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \
+     : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
+#endif
+
+/* Address of bss segment in memory after it is loaded.  */
+#if !defined (N_BSSADDR)
+#define N_BSSADDR(x) (N_DATADDR(x) + (x).a_data)
+#endif
+
+#if !defined (N_NLIST_DECLARED)
+struct nlist {
+  union {
+    char *n_name;
+    struct nlist *n_next;
+    long n_strx;
+  } n_un;
+  unsigned char n_type;
+  char n_other;
+  short n_desc;
+  unsigned long n_value;
+};
+#endif /* no N_NLIST_DECLARED.  */
+
+#if !defined (N_UNDF)
+#define N_UNDF 0
+#endif
+#if !defined (N_ABS)
+#define N_ABS 2
+#endif
+#if !defined (N_TEXT)
+#define N_TEXT 4
+#endif
+#if !defined (N_DATA)
+#define N_DATA 6
+#endif
+#if !defined (N_BSS)
+#define N_BSS 8
+#endif
+#if !defined (N_FN)
+#define N_FN 15
+#endif
+
+#if !defined (N_EXT)
+#define N_EXT 1
+#endif
+#if !defined (N_TYPE)
+#define N_TYPE 036
+#endif
+#if !defined (N_STAB)
+#define N_STAB 0340
+#endif
+
+/* The following type indicates the definition of a symbol as being
+   an indirect reference to another symbol.  The other symbol
+   appears as an undefined reference, immediately following this symbol.
+
+   Indirection is asymmetrical.  The other symbol's value will be used
+   to satisfy requests for the indirect symbol, but not vice versa.
+   If the other symbol does not have a definition, libraries will
+   be searched to find a definition.  */
+#define N_INDR 0xa
+
+/* The following symbols refer to set elements.
+   All the N_SET[ATDB] symbols with the same name form one set.
+   Space is allocated for the set in the text section, and each set
+   element's value is stored into one word of the space.
+   The first word of the space is the length of the set (number of elements).
+
+   The address of the set is made into an N_SETV symbol
+   whose name is the same as the name of the set.
+   This symbol acts like a N_DATA global symbol
+   in that it can satisfy undefined external references.  */
+
+/* These appear as input to LD, in a .o file.  */
+#define N_SETA  0x14            /* Absolute set element symbol */
+#define N_SETT  0x16            /* Text set element symbol */
+#define N_SETD  0x18            /* Data set element symbol */
+#define N_SETB  0x1A            /* Bss set element symbol */
+
+/* This is output from LD.  */
+#define N_SETV  0x1C            /* Pointer to set vector in data area.  */
+
+#if !defined (N_RELOCATION_INFO_DECLARED)
+/* This structure describes a single relocation to be performed.
+   The text-relocation section of the file is a vector of these structures,
+   all of which apply to the text section.
+   Likewise, the data-relocation section applies to the data section.  */
+
+struct relocation_info
+{
+  /* Address (within segment) to be relocated.  */
+  int r_address;
+  /* The meaning of r_symbolnum depends on r_extern.  */
+  unsigned int r_symbolnum:24;
+  /* Nonzero means value is a pc-relative offset
+     and it should be relocated for changes in its own address
+     as well as for changes in the symbol or section specified.  */
+  unsigned int r_pcrel:1;
+  /* Length (as exponent of 2) of the field to be relocated.
+     Thus, a value of 2 indicates 1<<2 bytes.  */
+  unsigned int r_length:2;
+  /* 1 => relocate with value of symbol.
+          r_symbolnum is the index of the symbol
+          in file's the symbol table.
+     0 => relocate with the address of a segment.
+          r_symbolnum is N_TEXT, N_DATA, N_BSS or N_ABS
+          (the N_EXT bit may be set also, but signifies nothing).  */
+  unsigned int r_extern:1;
+  /* Four bits that aren't used, but when writing an object file
+     it is desirable to clear them.  */
+#ifdef NS32K
+  unsigned r_bsr:1;
+  unsigned r_disp:1;
+  unsigned r_pad:2;
+#else
+  unsigned int r_pad:4;
+#endif
+};
+#endif /* no N_RELOCATION_INFO_DECLARED.  */
+
+
+#endif /* __A_OUT_GNU_H__ */
diff --git a/include/linux/ac97_codec.h b/include/linux/ac97_codec.h
new file mode 100644
index 000000000000..c35833824e11
--- /dev/null
+++ b/include/linux/ac97_codec.h
@@ -0,0 +1,374 @@
+#ifndef _AC97_CODEC_H_
+#define _AC97_CODEC_H_
+
+#include <linux/types.h>
+#include <linux/soundcard.h>
+
+/* AC97 1.0 */
+#define  AC97_RESET               0x0000      //
+#define  AC97_MASTER_VOL_STEREO   0x0002      // Line Out
+#define  AC97_HEADPHONE_VOL       0x0004      // 
+#define  AC97_MASTER_VOL_MONO     0x0006      // TAD Output
+#define  AC97_MASTER_TONE         0x0008      //
+#define  AC97_PCBEEP_VOL          0x000a      // none
+#define  AC97_PHONE_VOL           0x000c      // TAD Input (mono)
+#define  AC97_MIC_VOL             0x000e      // MIC Input (mono)
+#define  AC97_LINEIN_VOL          0x0010      // Line Input (stereo)
+#define  AC97_CD_VOL              0x0012      // CD Input (stereo)
+#define  AC97_VIDEO_VOL           0x0014      // none
+#define  AC97_AUX_VOL             0x0016      // Aux Input (stereo)
+#define  AC97_PCMOUT_VOL          0x0018      // Wave Output (stereo)
+#define  AC97_RECORD_SELECT       0x001a      //
+#define  AC97_RECORD_GAIN         0x001c
+#define  AC97_RECORD_GAIN_MIC     0x001e
+#define  AC97_GENERAL_PURPOSE     0x0020
+#define  AC97_3D_CONTROL          0x0022
+#define  AC97_MODEM_RATE          0x0024
+#define  AC97_POWER_CONTROL       0x0026
+
+/* AC'97 2.0 */
+#define AC97_EXTENDED_ID          0x0028       /* Extended Audio ID */
+#define AC97_EXTENDED_STATUS      0x002A       /* Extended Audio Status */
+#define AC97_PCM_FRONT_DAC_RATE   0x002C       /* PCM Front DAC Rate */
+#define AC97_PCM_SURR_DAC_RATE    0x002E       /* PCM Surround DAC Rate */
+#define AC97_PCM_LFE_DAC_RATE     0x0030       /* PCM LFE DAC Rate */
+#define AC97_PCM_LR_ADC_RATE      0x0032       /* PCM LR ADC Rate */
+#define AC97_PCM_MIC_ADC_RATE     0x0034       /* PCM MIC ADC Rate */
+#define AC97_CENTER_LFE_MASTER    0x0036       /* Center + LFE Master Volume */
+#define AC97_SURROUND_MASTER      0x0038       /* Surround (Rear) Master Volume */
+#define AC97_RESERVED_3A          0x003A       /* Reserved in AC '97 < 2.2 */
+
+/* AC'97 2.2 */
+#define AC97_SPDIF_CONTROL        0x003A       /* S/PDIF Control */
+
+/* range 0x3c-0x58 - MODEM */
+#define AC97_EXTENDED_MODEM_ID    0x003C
+#define AC97_EXTEND_MODEM_STAT    0x003E
+#define AC97_LINE1_RATE           0x0040
+#define AC97_LINE2_RATE           0x0042
+#define AC97_HANDSET_RATE         0x0044
+#define AC97_LINE1_LEVEL          0x0046
+#define AC97_LINE2_LEVEL          0x0048
+#define AC97_HANDSET_LEVEL        0x004A
+#define AC97_GPIO_CONFIG          0x004C
+#define AC97_GPIO_POLARITY        0x004E
+#define AC97_GPIO_STICKY          0x0050
+#define AC97_GPIO_WAKE_UP         0x0052
+#define AC97_GPIO_STATUS          0x0054
+#define AC97_MISC_MODEM_STAT      0x0056
+#define AC97_RESERVED_58          0x0058
+
+/* registers 0x005a - 0x007a are vendor reserved */
+
+#define AC97_VENDOR_ID1           0x007c
+#define AC97_VENDOR_ID2           0x007e
+
+/* volume control bit defines */
+#define AC97_MUTE                 0x8000
+#define AC97_MICBOOST             0x0040
+#define AC97_LEFTVOL              0x3f00
+#define AC97_RIGHTVOL             0x003f
+
+/* record mux defines */
+#define AC97_RECMUX_MIC           0x0000
+#define AC97_RECMUX_CD            0x0101
+#define AC97_RECMUX_VIDEO         0x0202
+#define AC97_RECMUX_AUX           0x0303
+#define AC97_RECMUX_LINE          0x0404
+#define AC97_RECMUX_STEREO_MIX    0x0505
+#define AC97_RECMUX_MONO_MIX      0x0606
+#define AC97_RECMUX_PHONE         0x0707
+
+/* general purpose register bit defines */
+#define AC97_GP_LPBK              0x0080       /* Loopback mode */
+#define AC97_GP_MS                0x0100       /* Mic Select 0=Mic1, 1=Mic2 */
+#define AC97_GP_MIX               0x0200       /* Mono output select 0=Mix, 1=Mic */
+#define AC97_GP_RLBK              0x0400       /* Remote Loopback - Modem line codec */
+#define AC97_GP_LLBK              0x0800       /* Local Loopback - Modem Line codec */
+#define AC97_GP_LD                0x1000       /* Loudness 1=on */
+#define AC97_GP_3D                0x2000       /* 3D Enhancement 1=on */
+#define AC97_GP_ST                0x4000       /* Stereo Enhancement 1=on */
+#define AC97_GP_POP               0x8000       /* Pcm Out Path, 0=pre 3D, 1=post 3D */
+
+/* extended audio status and control bit defines */
+#define AC97_EA_VRA               0x0001       /* Variable bit rate enable bit */
+#define AC97_EA_DRA               0x0002       /* Double-rate audio enable bit */
+#define AC97_EA_SPDIF             0x0004       /* S/PDIF Enable bit */
+#define AC97_EA_VRM               0x0008       /* Variable bit rate for MIC enable bit */
+#define AC97_EA_CDAC              0x0040       /* PCM Center DAC is ready (Read only) */
+#define AC97_EA_SDAC              0x0040       /* PCM Surround DACs are ready (Read only) */
+#define AC97_EA_LDAC              0x0080       /* PCM LFE DAC is ready (Read only) */
+#define AC97_EA_MDAC              0x0100       /* MIC ADC is ready (Read only) */
+#define AC97_EA_SPCV              0x0400       /* S/PDIF configuration valid (Read only) */
+#define AC97_EA_PRI               0x0800       /* Turns the PCM Center DAC off */
+#define AC97_EA_PRJ               0x1000       /* Turns the PCM Surround DACs off */
+#define AC97_EA_PRK               0x2000       /* Turns the PCM LFE DAC off */
+#define AC97_EA_PRL               0x4000       /* Turns the MIC ADC off */
+#define AC97_EA_SLOT_MASK         0xffcf       /* Mask for slot assignment bits */
+#define AC97_EA_SPSA_3_4          0x0000       /* Slot assigned to 3 & 4 */
+#define AC97_EA_SPSA_7_8          0x0010       /* Slot assigned to 7 & 8 */
+#define AC97_EA_SPSA_6_9          0x0020       /* Slot assigned to 6 & 9 */
+#define AC97_EA_SPSA_10_11        0x0030       /* Slot assigned to 10 & 11 */
+
+/* S/PDIF control bit defines */
+#define AC97_SC_PRO               0x0001       /* Professional status */
+#define AC97_SC_NAUDIO            0x0002       /* Non audio stream */
+#define AC97_SC_COPY              0x0004       /* Copyright status */
+#define AC97_SC_PRE               0x0008       /* Preemphasis status */
+#define AC97_SC_CC_MASK           0x07f0       /* Category Code mask */
+#define AC97_SC_L                 0x0800       /* Generation Level status */
+#define AC97_SC_SPSR_MASK         0xcfff       /* S/PDIF Sample Rate bits */
+#define AC97_SC_SPSR_44K          0x0000       /* Use 44.1kHz Sample rate */
+#define AC97_SC_SPSR_48K          0x2000       /* Use 48kHz Sample rate */
+#define AC97_SC_SPSR_32K          0x3000       /* Use 32kHz Sample rate */
+#define AC97_SC_DRS               0x4000       /* Double Rate S/PDIF */
+#define AC97_SC_V                 0x8000       /* Validity status */
+
+/* powerdown control and status bit defines */
+
+/* status */
+#define AC97_PWR_MDM              0x0010       /* Modem section ready */
+#define AC97_PWR_REF              0x0008       /* Vref nominal */
+#define AC97_PWR_ANL              0x0004       /* Analog section ready */
+#define AC97_PWR_DAC              0x0002       /* DAC section ready */
+#define AC97_PWR_ADC              0x0001       /* ADC section ready */
+
+/* control */
+#define AC97_PWR_PR0              0x0100       /* ADC and Mux powerdown */
+#define AC97_PWR_PR1              0x0200       /* DAC powerdown */
+#define AC97_PWR_PR2              0x0400       /* Output mixer powerdown (Vref on) */
+#define AC97_PWR_PR3              0x0800       /* Output mixer powerdown (Vref off) */
+#define AC97_PWR_PR4              0x1000       /* AC-link powerdown */
+#define AC97_PWR_PR5              0x2000       /* Internal Clk disable */
+#define AC97_PWR_PR6              0x4000       /* HP amp powerdown */
+#define AC97_PWR_PR7              0x8000       /* Modem off - if supported */
+
+/* extended audio ID register bit defines */
+#define AC97_EXTID_VRA            0x0001
+#define AC97_EXTID_DRA            0x0002
+#define AC97_EXTID_SPDIF          0x0004
+#define AC97_EXTID_VRM            0x0008
+#define AC97_EXTID_DSA0           0x0010
+#define AC97_EXTID_DSA1           0x0020
+#define AC97_EXTID_CDAC           0x0040
+#define AC97_EXTID_SDAC           0x0080
+#define AC97_EXTID_LDAC           0x0100
+#define AC97_EXTID_AMAP           0x0200
+#define AC97_EXTID_REV0           0x0400
+#define AC97_EXTID_REV1           0x0800
+#define AC97_EXTID_ID0            0x4000
+#define AC97_EXTID_ID1            0x8000
+
+/* extended status register bit defines */
+#define AC97_EXTSTAT_VRA          0x0001
+#define AC97_EXTSTAT_DRA          0x0002
+#define AC97_EXTSTAT_SPDIF        0x0004
+#define AC97_EXTSTAT_VRM          0x0008
+#define AC97_EXTSTAT_SPSA0        0x0010
+#define AC97_EXTSTAT_SPSA1        0x0020
+#define AC97_EXTSTAT_CDAC         0x0040
+#define AC97_EXTSTAT_SDAC         0x0080
+#define AC97_EXTSTAT_LDAC         0x0100
+#define AC97_EXTSTAT_MADC         0x0200
+#define AC97_EXTSTAT_SPCV         0x0400
+#define AC97_EXTSTAT_PRI          0x0800
+#define AC97_EXTSTAT_PRJ          0x1000
+#define AC97_EXTSTAT_PRK          0x2000
+#define AC97_EXTSTAT_PRL          0x4000
+
+/* extended audio ID register bit defines */
+#define AC97_EXTID_VRA            0x0001
+#define AC97_EXTID_DRA            0x0002
+#define AC97_EXTID_SPDIF          0x0004
+#define AC97_EXTID_VRM            0x0008
+#define AC97_EXTID_DSA0           0x0010
+#define AC97_EXTID_DSA1           0x0020
+#define AC97_EXTID_CDAC           0x0040
+#define AC97_EXTID_SDAC           0x0080
+#define AC97_EXTID_LDAC           0x0100
+#define AC97_EXTID_AMAP           0x0200
+#define AC97_EXTID_REV0           0x0400
+#define AC97_EXTID_REV1           0x0800
+#define AC97_EXTID_ID0            0x4000
+#define AC97_EXTID_ID1            0x8000
+
+/* extended status register bit defines */
+#define AC97_EXTSTAT_VRA          0x0001
+#define AC97_EXTSTAT_DRA          0x0002
+#define AC97_EXTSTAT_SPDIF        0x0004
+#define AC97_EXTSTAT_VRM          0x0008
+#define AC97_EXTSTAT_SPSA0        0x0010
+#define AC97_EXTSTAT_SPSA1        0x0020
+#define AC97_EXTSTAT_CDAC         0x0040
+#define AC97_EXTSTAT_SDAC         0x0080
+#define AC97_EXTSTAT_LDAC         0x0100
+#define AC97_EXTSTAT_MADC         0x0200
+#define AC97_EXTSTAT_SPCV         0x0400
+#define AC97_EXTSTAT_PRI          0x0800
+#define AC97_EXTSTAT_PRJ          0x1000
+#define AC97_EXTSTAT_PRK          0x2000
+#define AC97_EXTSTAT_PRL          0x4000
+
+/* useful power states */
+#define AC97_PWR_D0               0x0000      /* everything on */
+#define AC97_PWR_D1              AC97_PWR_PR0|AC97_PWR_PR1|AC97_PWR_PR4
+#define AC97_PWR_D2              AC97_PWR_PR0|AC97_PWR_PR1|AC97_PWR_PR2|AC97_PWR_PR3|AC97_PWR_PR4
+#define AC97_PWR_D3              AC97_PWR_PR0|AC97_PWR_PR1|AC97_PWR_PR2|AC97_PWR_PR3|AC97_PWR_PR4
+#define AC97_PWR_ANLOFF          AC97_PWR_PR2|AC97_PWR_PR3  /* analog section off */
+
+/* Total number of defined registers.  */
+#define AC97_REG_CNT 64
+
+
+/* OSS interface to the ac97s.. */
+#define AC97_STEREO_MASK (SOUND_MASK_VOLUME|SOUND_MASK_PCM|\
+        SOUND_MASK_LINE|SOUND_MASK_CD|\
+        SOUND_MASK_ALTPCM|SOUND_MASK_IGAIN|\
+        SOUND_MASK_LINE1|SOUND_MASK_VIDEO)
+
+#define AC97_SUPPORTED_MASK (AC97_STEREO_MASK | \
+        SOUND_MASK_BASS|SOUND_MASK_TREBLE|\
+        SOUND_MASK_SPEAKER|SOUND_MASK_MIC|\
+        SOUND_MASK_PHONEIN|SOUND_MASK_PHONEOUT)
+
+#define AC97_RECORD_MASK (SOUND_MASK_MIC|\
+        SOUND_MASK_CD|SOUND_MASK_IGAIN|SOUND_MASK_VIDEO|\
+        SOUND_MASK_LINE1| SOUND_MASK_LINE|\
+        SOUND_MASK_PHONEIN)
+
+/* original check is not good enough in case FOO is greater than
+ * SOUND_MIXER_NRDEVICES because the supported_mixers has exactly
+ * SOUND_MIXER_NRDEVICES elements.
+ * before matching the given mixer against the bitmask in supported_mixers we
+ * check if mixer number exceeds maximum allowed size which is as mentioned
+ * above SOUND_MIXER_NRDEVICES */
+#define supported_mixer(CODEC,FOO) ((FOO >= 0) && \
+                                    (FOO < SOUND_MIXER_NRDEVICES) && \
+                                    (CODEC)->supported_mixers & (1<<FOO) )
+
+struct ac97_codec {
+        /* Linked list of codecs */
+        struct list_head list;
+
+        /* AC97 controller connected with */
+        void *private_data;
+
+        char *name;
+        int id;
+        int dev_mixer; 
+        int type;
+        u32 model;
+
+        int modem:1;
+
+        struct ac97_ops *codec_ops;
+
+        /* controller specific lower leverl ac97 accessing routines.
+           must be re-entrant safe */
+        u16  (*codec_read)  (struct ac97_codec *codec, u8 reg);
+        void (*codec_write) (struct ac97_codec *codec, u8 reg, u16 val);
+
+        /* Wait for codec-ready.  Ok to sleep here.  */
+        void  (*codec_wait)  (struct ac97_codec *codec);
+
+        /* callback used by helper drivers for interesting ac97 setups */
+        void  (*codec_unregister) (struct ac97_codec *codec);
+        
+        struct ac97_driver *driver;
+        void *driver_private;   /* Private data for the driver */
+        
+        spinlock_t lock;
+        
+        /* OSS mixer masks */
+        int modcnt;
+        int supported_mixers;
+        int stereo_mixers;
+        int record_sources;
+
+        /* Property flags */
+        int flags;
+
+        int bit_resolution;
+
+        /* OSS mixer interface */
+        int  (*read_mixer) (struct ac97_codec *codec, int oss_channel);
+        void (*write_mixer)(struct ac97_codec *codec, int oss_channel,
+                            unsigned int left, unsigned int right);
+        int  (*recmask_io) (struct ac97_codec *codec, int rw, int mask);
+        int  (*mixer_ioctl)(struct ac97_codec *codec, unsigned int cmd, unsigned long arg);
+
+        /* saved OSS mixer states */
+        unsigned int mixer_state[SOUND_MIXER_NRDEVICES];
+
+        /* Software Modem interface */
+        int  (*modem_ioctl)(struct ac97_codec *codec, unsigned int cmd, unsigned long arg);
+};
+
+/*
+ *      Operation structures for each known AC97 chip
+ */
+ 
+struct ac97_ops
+{
+        /* Initialise */
+        int (*init)(struct ac97_codec *c);
+        /* Amplifier control */
+        int (*amplifier)(struct ac97_codec *codec, int on);
+        /* Digital mode control */
+        int (*digital)(struct ac97_codec *codec, int slots, int rate, int mode);
+#define AUDIO_DIGITAL           0x8000
+#define AUDIO_PRO               0x4000
+#define AUDIO_DRS               0x2000
+#define AUDIO_CCMASK            0x003F
+        
+#define AC97_DELUDED_MODEM      1       /* Audio codec reports its a modem */
+#define AC97_NO_PCM_VOLUME      2       /* Volume control is missing       */
+#define AC97_DEFAULT_POWER_OFF 4 /* Needs warm reset to power up */
+};
+
+extern int ac97_read_proc (char *page_out, char **start, off_t off,
+                           int count, int *eof, void *data);
+extern int ac97_probe_codec(struct ac97_codec *);
+extern unsigned int ac97_set_adc_rate(struct ac97_codec *codec, unsigned int rate);
+extern unsigned int ac97_set_dac_rate(struct ac97_codec *codec, unsigned int rate);
+extern int ac97_save_state(struct ac97_codec *codec);
+extern int ac97_restore_state(struct ac97_codec *codec);
+
+extern struct ac97_codec *ac97_alloc_codec(void);
+extern void ac97_release_codec(struct ac97_codec *codec);
+
+struct ac97_driver {
+        struct list_head list;
+        char *name;
+        u32 codec_id;
+        u32 codec_mask;
+        int (*probe) (struct ac97_codec *codec, struct ac97_driver *driver);
+        void (*remove) (struct ac97_codec *codec, struct ac97_driver *driver);
+};
+
+extern int ac97_register_driver(struct ac97_driver *driver);
+extern void ac97_unregister_driver(struct ac97_driver *driver);
+
+/* quirk types */
+enum {
+        AC97_TUNE_DEFAULT = -1, /* use default from quirk list (not valid in list) */
+        AC97_TUNE_NONE = 0,     /* nothing extra to do */
+        AC97_TUNE_HP_ONLY,      /* headphone (true line-out) control as master only */
+        AC97_TUNE_SWAP_HP,      /* swap headphone and master controls */
+        AC97_TUNE_SWAP_SURROUND, /* swap master and surround controls */
+        AC97_TUNE_AD_SHARING,   /* for AD1985, turn on OMS bit and use headphone */
+        AC97_TUNE_ALC_JACK,     /* for Realtek, enable JACK detection */
+};
+
+struct ac97_quirk {
+        unsigned short vendor;  /* PCI vendor id */
+        unsigned short device;  /* PCI device id */
+        unsigned short mask;    /* device id bit mask, 0 = accept all */
+        const char *name;       /* name shown as info */
+        int type;               /* quirk type above */
+};
+
+struct pci_dev;
+extern int ac97_tune_hardware(struct pci_dev *pdev, struct ac97_quirk *quirk, int override);
+
+#endif /* _AC97_CODEC_H_ */
diff --git a/include/linux/acct.h b/include/linux/acct.h
new file mode 100644
index 000000000000..1993a3691768
--- /dev/null
+++ b/include/linux/acct.h
@@ -0,0 +1,201 @@
+/*
+ *  BSD Process Accounting for Linux - Definitions
+ *
+ *  Author: Marco van Wieringen (mvw@planets.elm.net)
+ *
+ *  This header file contains the definitions needed to implement
+ *  BSD-style process accounting. The kernel accounting code and all
+ *  user-level programs that try to do something useful with the
+ *  process accounting log must include this file.
+ *
+ *  Copyright (C) 1995 - 1997 Marco van Wieringen - ELM Consultancy B.V.
+ *
+ */
+
+#ifndef _LINUX_ACCT_H
+#define _LINUX_ACCT_H
+
+#include <linux/types.h>
+#include <asm/param.h>
+#include <asm/byteorder.h>
+
+/* 
+ *  comp_t is a 16-bit "floating" point number with a 3-bit base 8
+ *  exponent and a 13-bit fraction.
+ *  comp2_t is 24-bit with 5-bit base 2 exponent and 20 bit fraction
+ *  (leading 1 not stored).
+ *  See linux/kernel/acct.c for the specific encoding systems used.
+ */
+
+typedef __u16   comp_t;
+typedef __u32   comp2_t;
+
+/*
+ *   accounting file record
+ *
+ *   This structure contains all of the information written out to the
+ *   process accounting file whenever a process exits.
+ */
+
+#define ACCT_COMM       16
+
+struct acct
+{
+        char            ac_flag;                /* Flags */
+        char            ac_version;             /* Always set to ACCT_VERSION */
+        /* for binary compatibility back until 2.0 */
+        __u16           ac_uid16;               /* LSB of Real User ID */
+        __u16           ac_gid16;               /* LSB of Real Group ID */
+        __u16           ac_tty;                 /* Control Terminal */
+        __u32           ac_btime;               /* Process Creation Time */
+        comp_t          ac_utime;               /* User Time */
+        comp_t          ac_stime;               /* System Time */
+        comp_t          ac_etime;               /* Elapsed Time */
+        comp_t          ac_mem;                 /* Average Memory Usage */
+        comp_t          ac_io;                  /* Chars Transferred */
+        comp_t          ac_rw;                  /* Blocks Read or Written */
+        comp_t          ac_minflt;              /* Minor Pagefaults */
+        comp_t          ac_majflt;              /* Major Pagefaults */
+        comp_t          ac_swaps;               /* Number of Swaps */
+/* m68k had no padding here. */
+#if !defined(CONFIG_M68K) || !defined(__KERNEL__)
+        __u16           ac_ahz;                 /* AHZ */
+#endif
+        __u32           ac_exitcode;            /* Exitcode */
+        char            ac_comm[ACCT_COMM + 1]; /* Command Name */
+        __u8            ac_etime_hi;            /* Elapsed Time MSB */
+        __u16           ac_etime_lo;            /* Elapsed Time LSB */
+        __u32           ac_uid;                 /* Real User ID */
+        __u32           ac_gid;                 /* Real Group ID */
+};
+
+struct acct_v3
+{
+        char            ac_flag;                /* Flags */
+        char            ac_version;             /* Always set to ACCT_VERSION */
+        __u16           ac_tty;                 /* Control Terminal */
+        __u32           ac_exitcode;            /* Exitcode */
+        __u32           ac_uid;                 /* Real User ID */
+        __u32           ac_gid;                 /* Real Group ID */
+        __u32           ac_pid;                 /* Process ID */
+        __u32           ac_ppid;                /* Parent Process ID */
+        __u32           ac_btime;               /* Process Creation Time */
+#ifdef __KERNEL__
+        __u32           ac_etime;               /* Elapsed Time */
+#else
+        float           ac_etime;               /* Elapsed Time */
+#endif
+        comp_t          ac_utime;               /* User Time */
+        comp_t          ac_stime;               /* System Time */
+        comp_t          ac_mem;                 /* Average Memory Usage */
+        comp_t          ac_io;                  /* Chars Transferred */
+        comp_t          ac_rw;                  /* Blocks Read or Written */
+        comp_t          ac_minflt;              /* Minor Pagefaults */
+        comp_t          ac_majflt;              /* Major Pagefaults */
+        comp_t          ac_swaps;               /* Number of Swaps */
+        char            ac_comm[ACCT_COMM];     /* Command Name */
+};
+
+/*
+ *  accounting flags
+ */
+                                /* bit set when the process ... */
+#define AFORK           0x01    /* ... executed fork, but did not exec */
+#define ASU             0x02    /* ... used super-user privileges */
+#define ACOMPAT         0x04    /* ... used compatibility mode (VAX only not used) */
+#define ACORE           0x08    /* ... dumped core */
+#define AXSIG           0x10    /* ... was killed by a signal */
+
+#ifdef __BIG_ENDIAN
+#define ACCT_BYTEORDER  0x80    /* accounting file is big endian */
+#else
+#define ACCT_BYTEORDER  0x00    /* accounting file is little endian */
+#endif
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+
+#ifdef CONFIG_BSD_PROCESS_ACCT
+struct super_block;
+extern void acct_auto_close(struct super_block *sb);
+extern void acct_process(long exitcode);
+extern void acct_update_integrals(struct task_struct *tsk);
+extern void acct_clear_integrals(struct task_struct *tsk);
+#else
+#define acct_auto_close(x)      do { } while (0)
+#define acct_process(x)         do { } while (0)
+#define acct_update_integrals(x)                do { } while (0)
+#define acct_clear_integrals(task)      do { } while (0)
+#endif
+
+/*
+ * ACCT_VERSION numbers as yet defined:
+ * 0: old format (until 2.6.7) with 16 bit uid/gid
+ * 1: extended variant (binary compatible on M68K)
+ * 2: extended variant (binary compatible on everything except M68K)
+ * 3: new binary incompatible format (64 bytes)
+ * 4: new binary incompatible format (128 bytes)
+ * 5: new binary incompatible format (128 bytes, second half)
+ *
+ */
+
+#ifdef CONFIG_BSD_PROCESS_ACCT_V3
+#define ACCT_VERSION    3
+#define AHZ             100
+typedef struct acct_v3 acct_t;
+#else
+#ifdef CONFIG_M68K
+#define ACCT_VERSION    1
+#else
+#define ACCT_VERSION    2
+#endif
+#define AHZ             (USER_HZ)
+typedef struct acct acct_t;
+#endif
+
+#else
+#define ACCT_VERSION    2
+#define AHZ             (HZ)
+#endif  /* __KERNEL */
+
+#ifdef __KERNEL__
+/*
+ * Yet another set of HZ to *HZ helper functions.
+ * See <linux/times.h> for the original.
+ */
+
+static inline u32 jiffies_to_AHZ(unsigned long x)
+{
+#if (TICK_NSEC % (NSEC_PER_SEC / AHZ)) == 0
+        return x / (HZ / USER_HZ);
+#else
+        u64 tmp = (u64)x * TICK_NSEC;
+        do_div(tmp, (NSEC_PER_SEC / AHZ));
+        return (long)tmp;
+#endif
+}
+
+static inline u64 nsec_to_AHZ(u64 x)
+{
+#if (NSEC_PER_SEC % AHZ) == 0
+        do_div(x, (NSEC_PER_SEC / AHZ));
+#elif (AHZ % 512) == 0
+        x *= AHZ/512;
+        do_div(x, (NSEC_PER_SEC / 512));
+#else
+        /*
+         * max relative error 5.7e-8 (1.8s per year) for AHZ <= 1024,
+         * overflow after 64.99 years.
+         * exact for AHZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
+         */
+        x *= 9;
+        do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (AHZ/2))
+                                  / AHZ));
+#endif
+        return x;
+}
+
+#endif  /* __KERNEL */
+
+#endif  /* _LINUX_ACCT_H */
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
new file mode 100644
index 000000000000..aefe6d051ace
--- /dev/null
+++ b/include/linux/acpi.h
@@ -0,0 +1,536 @@
+/*
+ * acpi.h - ACPI Interface
+ *
+ * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#ifndef _LINUX_ACPI_H
+#define _LINUX_ACPI_H
+
+#ifndef _LINUX
+#define _LINUX
+#endif
+
+#include <linux/list.h>
+
+#include <acpi/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+#include <asm/acpi.h>
+
+
+#ifdef CONFIG_ACPI_BOOT
+
+enum acpi_irq_model_id {
+        ACPI_IRQ_MODEL_PIC = 0,
+        ACPI_IRQ_MODEL_IOAPIC,
+        ACPI_IRQ_MODEL_IOSAPIC,
+        ACPI_IRQ_MODEL_COUNT
+};
+
+extern enum acpi_irq_model_id   acpi_irq_model;
+
+
+/* Root System Description Pointer (RSDP) */
+
+struct acpi_table_rsdp {
+        char                    signature[8];
+        u8                      checksum;
+        char                    oem_id[6];
+        u8                      revision;
+        u32                     rsdt_address;
+} __attribute__ ((packed));
+
+struct acpi20_table_rsdp {
+        char                    signature[8];
+        u8                      checksum;
+        char                    oem_id[6];
+        u8                      revision;
+        u32                     rsdt_address;
+        u32                     length;
+        u64                     xsdt_address;
+        u8                      ext_checksum;
+        u8                      reserved[3];
+} __attribute__ ((packed));
+
+typedef struct {
+        u8                      type;
+        u8                      length;
+} __attribute__ ((packed)) acpi_table_entry_header;
+
+/* Root System Description Table (RSDT) */
+
+struct acpi_table_rsdt {
+        struct acpi_table_header header;
+        u32                     entry[8];
+} __attribute__ ((packed));
+
+/* Extended System Description Table (XSDT) */
+
+struct acpi_table_xsdt {
+        struct acpi_table_header header;
+        u64                     entry[1];
+} __attribute__ ((packed));
+
+/* Fixed ACPI Description Table (FADT) */
+
+struct acpi_table_fadt {
+        struct acpi_table_header header;
+        u32 facs_addr;
+        u32 dsdt_addr;
+        /* ... */
+} __attribute__ ((packed));
+
+/* Multiple APIC Description Table (MADT) */
+
+struct acpi_table_madt {
+        struct acpi_table_header header;
+        u32                     lapic_address;
+        struct {
+                u32                     pcat_compat:1;
+                u32                     reserved:31;
+        }                       flags;
+} __attribute__ ((packed));
+
+enum acpi_madt_entry_id {
+        ACPI_MADT_LAPIC = 0,
+        ACPI_MADT_IOAPIC,
+        ACPI_MADT_INT_SRC_OVR,
+        ACPI_MADT_NMI_SRC,
+        ACPI_MADT_LAPIC_NMI,
+        ACPI_MADT_LAPIC_ADDR_OVR,
+        ACPI_MADT_IOSAPIC,
+        ACPI_MADT_LSAPIC,
+        ACPI_MADT_PLAT_INT_SRC,
+        ACPI_MADT_ENTRY_COUNT
+};
+
+typedef struct {
+        u16                     polarity:2;
+        u16                     trigger:2;
+        u16                     reserved:12;
+} __attribute__ ((packed)) acpi_interrupt_flags;
+
+struct acpi_table_lapic {
+        acpi_table_entry_header header;
+        u8                      acpi_id;
+        u8                      id;
+        struct {
+                u32                     enabled:1;
+                u32                     reserved:31;
+        }                       flags;
+} __attribute__ ((packed));
+
+struct acpi_table_ioapic {
+        acpi_table_entry_header header;
+        u8                      id;
+        u8                      reserved;
+        u32                     address;
+        u32                     global_irq_base;
+} __attribute__ ((packed));
+
+struct acpi_table_int_src_ovr {
+        acpi_table_entry_header header;
+        u8                      bus;
+        u8                      bus_irq;
+        u32                     global_irq;
+        acpi_interrupt_flags    flags;
+} __attribute__ ((packed));
+
+struct acpi_table_nmi_src {
+        acpi_table_entry_header header;
+        acpi_interrupt_flags    flags;
+        u32                     global_irq;
+} __attribute__ ((packed));
+
+struct acpi_table_lapic_nmi {
+        acpi_table_entry_header header;
+        u8                      acpi_id;
+        acpi_interrupt_flags    flags;
+        u8                      lint;
+} __attribute__ ((packed));
+
+struct acpi_table_lapic_addr_ovr {
+        acpi_table_entry_header header;
+        u8                      reserved[2];
+        u64                     address;
+} __attribute__ ((packed));
+
+struct acpi_table_iosapic {
+        acpi_table_entry_header header;
+        u8                      id;
+        u8                      reserved;
+        u32                     global_irq_base;
+        u64                     address;
+} __attribute__ ((packed));
+
+struct acpi_table_lsapic {
+        acpi_table_entry_header header;
+        u8                      acpi_id;
+        u8                      id;
+        u8                      eid;
+        u8                      reserved[3];
+        struct {
+                u32                     enabled:1;
+                u32                     reserved:31;
+        }                       flags;
+} __attribute__ ((packed));
+
+struct acpi_table_plat_int_src {
+        acpi_table_entry_header header;
+        acpi_interrupt_flags    flags;
+        u8                      type;   /* See acpi_interrupt_type */
+        u8                      id;
+        u8                      eid;
+        u8                      iosapic_vector;
+        u32                     global_irq;
+        u32                     reserved;
+} __attribute__ ((packed));
+
+enum acpi_interrupt_id {
+        ACPI_INTERRUPT_PMI      = 1,
+        ACPI_INTERRUPT_INIT,
+        ACPI_INTERRUPT_CPEI,
+        ACPI_INTERRUPT_COUNT
+};
+
+#define ACPI_SPACE_MEM          0
+
+struct acpi_gen_regaddr {
+        u8  space_id;
+        u8  bit_width;
+        u8  bit_offset;
+        u8  resv;
+        u32 addrl;
+        u32 addrh;
+} __attribute__ ((packed));
+
+struct acpi_table_hpet {
+        struct acpi_table_header header;
+        u32 id;
+        struct acpi_gen_regaddr addr;
+        u8 number;
+        u16 min_tick;
+        u8 page_protect;
+} __attribute__ ((packed));
+
+/*
+ * Simple Boot Flags
+ * http://www.microsoft.com/whdc/hwdev/resources/specs/simp_bios.mspx
+ */
+struct acpi_table_sbf
+{
+        u8 sbf_signature[4];
+        u32 sbf_len;
+        u8 sbf_revision;
+        u8 sbf_csum;
+        u8 sbf_oemid[6];
+        u8 sbf_oemtable[8];
+        u8 sbf_revdata[4];
+        u8 sbf_creator[4];
+        u8 sbf_crearev[4];
+        u8 sbf_cmos;
+        u8 sbf_spare[3];
+} __attribute__ ((packed));
+
+/*
+ * System Resource Affinity Table (SRAT)
+ * http://www.microsoft.com/whdc/hwdev/platform/proc/SRAT.mspx
+ */
+
+struct acpi_table_srat {
+        struct acpi_table_header header;
+        u32                     table_revision;
+        u64                     reserved;
+} __attribute__ ((packed));
+
+enum acpi_srat_entry_id {
+        ACPI_SRAT_PROCESSOR_AFFINITY = 0,
+        ACPI_SRAT_MEMORY_AFFINITY,
+        ACPI_SRAT_ENTRY_COUNT
+};
+
+struct acpi_table_processor_affinity {
+        acpi_table_entry_header header;
+        u8                      proximity_domain;
+        u8                      apic_id;
+        struct {
+                u32                     enabled:1;
+                u32                     reserved:31;
+        }                       flags;
+        u8                      lsapic_eid;
+        u8                      reserved[7];
+} __attribute__ ((packed));
+
+struct acpi_table_memory_affinity {
+        acpi_table_entry_header header;
+        u8                      proximity_domain;
+        u8                      reserved1[5];
+        u32                     base_addr_lo;
+        u32                     base_addr_hi;
+        u32                     length_lo;
+        u32                     length_hi;
+        u32                     memory_type;    /* See acpi_address_range_id */
+        struct {
+                u32                     enabled:1;
+                u32                     hot_pluggable:1;
+                u32                     reserved:30;
+        }                       flags;
+        u64                     reserved2;
+} __attribute__ ((packed));
+
+enum acpi_address_range_id {
+        ACPI_ADDRESS_RANGE_MEMORY = 1,
+        ACPI_ADDRESS_RANGE_RESERVED = 2,
+        ACPI_ADDRESS_RANGE_ACPI = 3,
+        ACPI_ADDRESS_RANGE_NVS  = 4,
+        ACPI_ADDRESS_RANGE_COUNT
+};
+
+/*
+ * System Locality Information Table (SLIT)
+ *   see http://devresource.hp.com/devresource/docs/techpapers/ia64/slit.pdf
+ */
+
+struct acpi_table_slit {
+        struct acpi_table_header header;
+        u64                     localities;
+        u8                      entry[1];       /* real size = localities^2 */
+} __attribute__ ((packed));
+
+/* Smart Battery Description Table (SBST) */
+
+struct acpi_table_sbst {
+        struct acpi_table_header header;
+        u32                     warning;        /* Warn user */
+        u32                     low;            /* Critical sleep */
+        u32                     critical;       /* Critical shutdown */
+} __attribute__ ((packed));
+
+/* Embedded Controller Boot Resources Table (ECDT) */
+
+struct acpi_table_ecdt {
+        struct acpi_table_header        header;
+        struct acpi_generic_address     ec_control;
+        struct acpi_generic_address     ec_data;
+        u32                             uid;
+        u8                              gpe_bit;
+        char                            ec_id[0];
+} __attribute__ ((packed));
+
+/* PCI MMCONFIG */
+
+struct acpi_table_mcfg {
+        struct acpi_table_header        header;
+        u8                              reserved[8];
+        u32                             base_address;
+        u32                             base_reserved;
+} __attribute__ ((packed));
+
+/* Table Handlers */
+
+enum acpi_table_id {
+        ACPI_TABLE_UNKNOWN = 0,
+        ACPI_APIC,
+        ACPI_BOOT,
+        ACPI_DBGP,
+        ACPI_DSDT,
+        ACPI_ECDT,
+        ACPI_ETDT,
+        ACPI_FADT,
+        ACPI_FACS,
+        ACPI_OEMX,
+        ACPI_PSDT,
+        ACPI_SBST,
+        ACPI_SLIT,
+        ACPI_SPCR,
+        ACPI_SRAT,
+        ACPI_SSDT,
+        ACPI_SPMI,
+        ACPI_HPET,
+        ACPI_MCFG,
+        ACPI_TABLE_COUNT
+};
+
+typedef int (*acpi_table_handler) (unsigned long phys_addr, unsigned long size);
+
+extern acpi_table_handler acpi_table_ops[ACPI_TABLE_COUNT];
+
+typedef int (*acpi_madt_entry_handler) (acpi_table_entry_header *header, const unsigned long end);
+
+char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
+unsigned long acpi_find_rsdp (void);
+int acpi_boot_init (void);
+int acpi_boot_table_init (void);
+int acpi_numa_init (void);
+
+int acpi_table_init (void);
+int acpi_table_parse (enum acpi_table_id id, acpi_table_handler handler);
+int acpi_get_table_header_early (enum acpi_table_id id, struct acpi_table_header **header);
+int acpi_table_parse_madt (enum acpi_madt_entry_id id, acpi_madt_entry_handler handler, unsigned int max_entries);
+int acpi_table_parse_srat (enum acpi_srat_entry_id id, acpi_madt_entry_handler handler, unsigned int max_entries);
+void acpi_table_print (struct acpi_table_header *header, unsigned long phys_addr);
+void acpi_table_print_madt_entry (acpi_table_entry_header *madt);
+void acpi_table_print_srat_entry (acpi_table_entry_header *srat);
+
+/* the following four functions are architecture-dependent */
+void acpi_numa_slit_init (struct acpi_table_slit *slit);
+void acpi_numa_processor_affinity_init (struct acpi_table_processor_affinity *pa);
+void acpi_numa_memory_affinity_init (struct acpi_table_memory_affinity *ma);
+void acpi_numa_arch_fixup(void);
+
+#ifdef CONFIG_ACPI_HOTPLUG_CPU
+/* Arch dependent functions for cpu hotplug support */
+int acpi_map_lsapic(acpi_handle handle, int *pcpu);
+int acpi_unmap_lsapic(int cpu);
+#endif /* CONFIG_ACPI_HOTPLUG_CPU */
+
+extern int acpi_mp_config;
+
+extern u32 pci_mmcfg_base_addr;
+
+extern int sbf_port ;
+
+#else   /*!CONFIG_ACPI_BOOT*/
+
+#define acpi_mp_config  0
+
+static inline int acpi_boot_init(void)
+{
+        return 0;
+}
+
+static inline int acpi_boot_table_init(void)
+{
+        return 0;
+}
+
+#endif  /*!CONFIG_ACPI_BOOT*/
+
+unsigned int acpi_register_gsi (u32 gsi, int edge_level, int active_high_low);
+int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
+
+/*
+ * This function undoes the effect of one call to acpi_register_gsi().
+ * If this matches the last registration, any IRQ resources for gsi
+ * are freed.
+ */
+#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
+void acpi_unregister_gsi (u32 gsi);
+#endif
+
+#ifdef CONFIG_ACPI_PCI
+
+struct acpi_prt_entry {
+        struct list_head        node;
+        struct acpi_pci_id      id;
+        u8                      pin;
+        struct {
+                acpi_handle             handle;
+                u32                     index;
+        }                       link;
+        u32                     irq;
+};
+
+struct acpi_prt_list {
+        int                     count;
+        struct list_head        entries;
+};
+
+struct pci_dev;
+
+int acpi_pci_irq_enable (struct pci_dev *dev);
+void acpi_penalize_isa_irq(int irq);
+
+#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
+void acpi_pci_irq_disable (struct pci_dev *dev);
+#endif
+
+struct acpi_pci_driver {
+        struct acpi_pci_driver *next;
+        int (*add)(acpi_handle handle);
+        void (*remove)(acpi_handle handle);
+};
+
+int acpi_pci_register_driver(struct acpi_pci_driver *driver);
+void acpi_pci_unregister_driver(struct acpi_pci_driver *driver);
+
+#endif /*CONFIG_ACPI_PCI*/
+
+#ifdef CONFIG_ACPI_EC
+
+extern int ec_read(u8 addr, u8 *val);
+extern int ec_write(u8 addr, u8 val);
+
+#endif /*CONFIG_ACPI_EC*/
+
+#ifdef CONFIG_ACPI_INTERPRETER
+
+extern int acpi_blacklisted(void);
+extern void acpi_bios_year(char *s);
+
+#else /*!CONFIG_ACPI_INTERPRETER*/
+
+static inline int acpi_blacklisted(void)
+{
+        return 0;
+}
+
+#endif /*!CONFIG_ACPI_INTERPRETER*/
+
+#define ACPI_CSTATE_LIMIT_DEFINED       /* for driver builds */
+#ifdef  CONFIG_ACPI
+
+/*
+ * Set highest legal C-state
+ * 0: C0 okay, but not C1
+ * 1: C1 okay, but not C2
+ * 2: C2 okay, but not C3 etc.
+ */
+
+extern unsigned int max_cstate;
+
+static inline unsigned int acpi_get_cstate_limit(void)
+{
+        return max_cstate;
+}
+static inline void acpi_set_cstate_limit(unsigned int new_limit)
+{
+        max_cstate = new_limit;
+        return;
+}
+#else
+static inline unsigned int acpi_get_cstate_limit(void) { return 0; }
+static inline void acpi_set_cstate_limit(unsigned int new_limit) { return; }
+#endif
+
+#ifdef CONFIG_ACPI_NUMA
+int acpi_get_pxm(acpi_handle handle);
+#else
+static inline int acpi_get_pxm(acpi_handle handle)
+{
+        return 0;
+}
+#endif
+
+extern int pnpacpi_disabled;
+
+#endif /*_LINUX_ACPI_H*/
diff --git a/include/linux/adb.h b/include/linux/adb.h
new file mode 100644
index 000000000000..e9fdc63483c7
--- /dev/null
+++ b/include/linux/adb.h
@@ -0,0 +1,104 @@
+/*
+ * Definitions for ADB (Apple Desktop Bus) support.
+ */
+#ifndef __ADB_H
+#define __ADB_H
+
+/* ADB commands */
+#define ADB_BUSRESET            0
+#define ADB_FLUSH(id)           (0x01 | ((id) << 4))
+#define ADB_WRITEREG(id, reg)   (0x08 | (reg) | ((id) << 4))
+#define ADB_READREG(id, reg)    (0x0C | (reg) | ((id) << 4))
+
+/* ADB default device IDs (upper 4 bits of ADB command byte) */
+#define ADB_DONGLE      1       /* "software execution control" devices */
+#define ADB_KEYBOARD    2
+#define ADB_MOUSE       3
+#define ADB_TABLET      4
+#define ADB_MODEM       5
+#define ADB_MISC        7       /* maybe a monitor */
+
+#define ADB_RET_OK      0
+#define ADB_RET_TIMEOUT 3
+
+/* The kind of ADB request. The controller may emulate some
+   or all of those CUDA/PMU packet kinds */
+#define ADB_PACKET      0
+#define CUDA_PACKET     1
+#define ERROR_PACKET    2
+#define TIMER_PACKET    3
+#define POWER_PACKET    4
+#define MACIIC_PACKET   5
+#define PMU_PACKET      6
+#define ADB_QUERY       7
+
+/* ADB queries */
+
+/* ADB_QUERY_GETDEVINFO
+ * Query ADB slot for device presence
+ * data[2] = id, rep[0] = orig addr, rep[1] = handler_id
+ */
+#define ADB_QUERY_GETDEVINFO    1
+
+#ifdef __KERNEL__
+
+struct adb_request {
+        unsigned char data[32];
+        int nbytes;
+        unsigned char reply[32];
+        int reply_len;
+        unsigned char reply_expected;
+        unsigned char sent;
+        unsigned char complete;
+        void (*done)(struct adb_request *);
+        void *arg;
+        struct adb_request *next;
+};
+
+struct adb_ids {
+        int nids;
+        unsigned char id[16];
+};
+
+/* Structure which encapsulates a low-level ADB driver */
+
+struct adb_driver {
+        char name[16];
+        int (*probe)(void);
+        int (*init)(void);
+        int (*send_request)(struct adb_request *req, int sync);
+        int (*autopoll)(int devs);
+        void (*poll)(void);
+        int (*reset_bus)(void);
+};
+
+/* Values for adb_request flags */
+#define ADBREQ_REPLY    1       /* expect reply */
+#define ADBREQ_SYNC     2       /* poll until done */
+#define ADBREQ_NOSEND   4       /* build the request, but don't send it */
+
+/* Messages sent thru the client_list notifier. You should NOT stop
+   the operation, at least not with this version */
+enum adb_message {
+    ADB_MSG_POWERDOWN,  /* Currently called before sleep only */
+    ADB_MSG_PRE_RESET,  /* Called before resetting the bus */
+    ADB_MSG_POST_RESET  /* Called after resetting the bus (re-do init & register) */
+};
+extern struct adb_driver *adb_controller;
+extern struct notifier_block *adb_client_list;
+
+int adb_request(struct adb_request *req, void (*done)(struct adb_request *),
+                int flags, int nbytes, ...);
+int adb_register(int default_id,int handler_id,struct adb_ids *ids,
+                 void (*handler)(unsigned char *, int, struct pt_regs *, int));
+int adb_unregister(int index);
+void adb_poll(void);
+void adb_input(unsigned char *, int, struct pt_regs *, int);
+int adb_reset_bus(void);
+
+int adb_try_handler_change(int address, int new_id);
+int adb_get_infos(int address, int *original_address, int *handler_id);
+
+#endif /* __KERNEL__ */
+
+#endif /* __ADB_H */
diff --git a/include/linux/adfs_fs.h b/include/linux/adfs_fs.h
new file mode 100644
index 000000000000..4a5d50c2bdbf
--- /dev/null
+++ b/include/linux/adfs_fs.h
@@ -0,0 +1,76 @@
+#ifndef _ADFS_FS_H
+#define _ADFS_FS_H
+
+#include <linux/types.h>
+
+/*
+ * Disc Record at disc address 0xc00
+ */
+struct adfs_discrecord {
+    __u8  log2secsize;
+    __u8  secspertrack;
+    __u8  heads;
+    __u8  density;
+    __u8  idlen;
+    __u8  log2bpmb;
+    __u8  skew;
+    __u8  bootoption;
+    __u8  lowsector;
+    __u8  nzones;
+    __le16 zone_spare;
+    __le32 root;
+    __le32 disc_size;
+    __le16 disc_id;
+    __u8  disc_name[10];
+    __le32 disc_type;
+    __le32 disc_size_high;
+    __u8  log2sharesize:4;
+    __u8  unused40:4;
+    __u8  big_flag:1;
+    __u8  unused41:1;
+    __u8  nzones_high;
+    __le32 format_version;
+    __le32 root_size;
+    __u8  unused52[60 - 52];
+};
+
+#define ADFS_DISCRECORD         (0xc00)
+#define ADFS_DR_OFFSET          (0x1c0)
+#define ADFS_DR_SIZE             60
+#define ADFS_DR_SIZE_BITS       (ADFS_DR_SIZE << 3)
+#define ADFS_SUPER_MAGIC         0xadf5
+
+#ifdef __KERNEL__
+#include <linux/adfs_fs_i.h>
+#include <linux/adfs_fs_sb.h>
+/*
+ * Calculate the boot block checksum on an ADFS drive.  Note that this will
+ * appear to be correct if the sector contains all zeros, so also check that
+ * the disk size is non-zero!!!
+ */
+static inline int adfs_checkbblk(unsigned char *ptr)
+{
+        unsigned int result = 0;
+        unsigned char *p = ptr + 511;
+
+        do {
+                result = (result & 0xff) + (result >> 8);
+                result = result + *--p;
+        } while (p != ptr);
+
+        return (result & 0xff) != ptr[511];
+}
+
+static inline struct adfs_sb_info *ADFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct adfs_inode_info *ADFS_I(struct inode *inode)
+{
+        return container_of(inode, struct adfs_inode_info, vfs_inode);
+}
+
+#endif
+
+#endif
diff --git a/include/linux/adfs_fs_i.h b/include/linux/adfs_fs_i.h
new file mode 100644
index 000000000000..cb543034e54f
--- /dev/null
+++ b/include/linux/adfs_fs_i.h
@@ -0,0 +1,24 @@
+/*
+ *  linux/include/linux/adfs_fs_i.h
+ *
+ * Copyright (C) 1997 Russell King
+ */
+
+#ifndef _ADFS_FS_I
+#define _ADFS_FS_I
+
+/*
+ * adfs file system inode data in memory
+ */
+struct adfs_inode_info {
+        loff_t          mmu_private;
+        unsigned long   parent_id;      /* object id of parent          */
+        __u32           loadaddr;       /* RISC OS load address         */
+        __u32           execaddr;       /* RISC OS exec address         */
+        unsigned int    filetype;       /* RISC OS file type            */
+        unsigned int    attr;           /* RISC OS permissions          */
+        unsigned int    stamped:1;      /* RISC OS file has date/time   */
+        struct inode vfs_inode;
+};
+
+#endif
diff --git a/include/linux/adfs_fs_sb.h b/include/linux/adfs_fs_sb.h
new file mode 100644
index 000000000000..d9bf05c02ccc
--- /dev/null
+++ b/include/linux/adfs_fs_sb.h
@@ -0,0 +1,38 @@
+/*
+ *  linux/include/linux/adfs_fs_sb.h
+ *
+ * Copyright (C) 1997-1999 Russell King
+ */
+
+#ifndef _ADFS_FS_SB
+#define _ADFS_FS_SB
+
+/*
+ * Forward-declare this
+ */
+struct adfs_discmap;
+struct adfs_dir_ops;
+
+/*
+ * ADFS file system superblock data in memory
+ */
+struct adfs_sb_info {
+        struct adfs_discmap *s_map;     /* bh list containing map                */
+        struct adfs_dir_ops *s_dir;     /* directory operations                  */
+
+        uid_t           s_uid;          /* owner uid                             */
+        gid_t           s_gid;          /* owner gid                             */
+        umode_t         s_owner_mask;   /* ADFS owner perm -> unix perm          */
+        umode_t         s_other_mask;   /* ADFS other perm -> unix perm          */
+
+        __u32           s_ids_per_zone; /* max. no ids in one zone               */
+        __u32           s_idlen;        /* length of ID in map                   */
+        __u32           s_map_size;     /* sector size of a map                  */
+        unsigned long   s_size;         /* total size (in blocks) of this fs     */
+        signed int      s_map2blk;      /* shift left by this for map->sector    */
+        unsigned int    s_log2sharesize;/* log2 share size                       */
+        __le32          s_version;      /* disc format version                   */
+        unsigned int    s_namelen;      /* maximum number of characters in name  */
+};
+
+#endif
diff --git a/include/linux/affs_fs.h b/include/linux/affs_fs.h
new file mode 100644
index 000000000000..c57b5ee87d55
--- /dev/null
+++ b/include/linux/affs_fs.h
@@ -0,0 +1,7 @@
+#ifndef _AFFS_FS_H
+#define _AFFS_FS_H
+/*
+ * The affs filesystem constants/structures
+ */
+#define AFFS_SUPER_MAGIC 0xadff
+#endif
diff --git a/include/linux/affs_hardblocks.h b/include/linux/affs_hardblocks.h
new file mode 100644
index 000000000000..3fb869939d82
--- /dev/null
+++ b/include/linux/affs_hardblocks.h
@@ -0,0 +1,66 @@
+#ifndef AFFS_HARDBLOCKS_H
+#define AFFS_HARDBLOCKS_H
+
+/* Just the needed definitions for the RDB of an Amiga HD. */
+
+struct RigidDiskBlock {
+        u32     rdb_ID;
+        __be32  rdb_SummedLongs;
+        s32     rdb_ChkSum;
+        u32     rdb_HostID;
+        __be32  rdb_BlockBytes;
+        u32     rdb_Flags;
+        u32     rdb_BadBlockList;
+        __be32  rdb_PartitionList;
+        u32     rdb_FileSysHeaderList;
+        u32     rdb_DriveInit;
+        u32     rdb_Reserved1[6];
+        u32     rdb_Cylinders;
+        u32     rdb_Sectors;
+        u32     rdb_Heads;
+        u32     rdb_Interleave;
+        u32     rdb_Park;
+        u32     rdb_Reserved2[3];
+        u32     rdb_WritePreComp;
+        u32     rdb_ReducedWrite;
+        u32     rdb_StepRate;
+        u32     rdb_Reserved3[5];
+        u32     rdb_RDBBlocksLo;
+        u32     rdb_RDBBlocksHi;
+        u32     rdb_LoCylinder;
+        u32     rdb_HiCylinder;
+        u32     rdb_CylBlocks;
+        u32     rdb_AutoParkSeconds;
+        u32     rdb_HighRDSKBlock;
+        u32     rdb_Reserved4;
+        char    rdb_DiskVendor[8];
+        char    rdb_DiskProduct[16];
+        char    rdb_DiskRevision[4];
+        char    rdb_ControllerVendor[8];
+        char    rdb_ControllerProduct[16];
+        char    rdb_ControllerRevision[4];
+        u32     rdb_Reserved5[10];
+};
+
+#define IDNAME_RIGIDDISK        0x5244534B      /* "RDSK" */
+
+struct PartitionBlock {
+        __be32  pb_ID;
+        __be32  pb_SummedLongs;
+        s32     pb_ChkSum;
+        u32     pb_HostID;
+        __be32  pb_Next;
+        u32     pb_Flags;
+        u32     pb_Reserved1[2];
+        u32     pb_DevFlags;
+        u8      pb_DriveName[32];
+        u32     pb_Reserved2[15];
+        __be32  pb_Environment[17];
+        u32     pb_EReserved[15];
+};
+
+#define IDNAME_PARTITION        0x50415254      /* "PART" */
+
+#define RDB_ALLOCATION_LIMIT    16
+
+#endif  /* AFFS_HARDBLOCKS_H */
diff --git a/include/linux/agp_backend.h b/include/linux/agp_backend.h
new file mode 100644
index 000000000000..a5c8bb5d80ba
--- /dev/null
+++ b/include/linux/agp_backend.h
@@ -0,0 +1,109 @@
+/*
+ * AGPGART backend specific includes. Not for userspace consumption.
+ *
+ * Copyright (C) 2004 Silicon Graphics, Inc.
+ * Copyright (C) 2002-2003 Dave Jones
+ * Copyright (C) 1999 Jeff Hartmann
+ * Copyright (C) 1999 Precision Insight, Inc.
+ * Copyright (C) 1999 Xi Graphics, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * JEFF HARTMANN, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef _AGP_BACKEND_H
+#define _AGP_BACKEND_H 1
+
+#ifdef __KERNEL__
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+enum chipset_type {
+        NOT_SUPPORTED,
+        SUPPORTED,
+};
+
+struct agp_version {
+        u16 major;
+        u16 minor;
+};
+
+struct agp_kern_info {
+        struct agp_version version;
+        struct pci_dev *device;
+        enum chipset_type chipset;
+        unsigned long mode;
+        unsigned long aper_base;
+        size_t aper_size;
+        int max_memory;         /* In pages */
+        int current_memory;
+        int cant_use_aperture;
+        unsigned long page_mask;
+        struct vm_operations_struct *vm_ops;
+};
+
+/*
+ * The agp_memory structure has information about the block of agp memory
+ * allocated.  A caller may manipulate the next and prev pointers to link
+ * each allocated item into a list.  These pointers are ignored by the backend.
+ * Everything else should never be written to, but the caller may read any of
+ * the items to determine the status of this block of agp memory.
+ */
+
+struct agp_bridge_data;
+
+struct agp_memory {
+        struct agp_memory *next;
+        struct agp_memory *prev;
+        struct agp_bridge_data *bridge;
+        unsigned long *memory;
+        size_t page_count;
+        int key;
+        int num_scratch_pages;
+        off_t pg_start;
+        u32 type;
+        u32 physical;
+        u8 is_bound;
+        u8 is_flushed;
+};
+
+#define AGP_NORMAL_MEMORY 0
+
+extern struct agp_bridge_data *agp_bridge;
+extern struct list_head agp_bridges;
+
+extern struct agp_bridge_data *(*agp_find_bridge)(struct pci_dev *);
+
+extern void agp_free_memory(struct agp_memory *);
+extern struct agp_memory *agp_allocate_memory(struct agp_bridge_data *, size_t, u32);
+extern int agp_copy_info(struct agp_bridge_data *, struct agp_kern_info *);
+extern int agp_bind_memory(struct agp_memory *, off_t);
+extern int agp_unbind_memory(struct agp_memory *);
+extern void agp_enable(struct agp_bridge_data *, u32);
+extern struct agp_bridge_data *agp_backend_acquire(struct pci_dev *);
+extern void agp_backend_release(struct agp_bridge_data *);
+
+#endif                          /* __KERNEL__ */
+#endif                          /* _AGP_BACKEND_H */
diff --git a/include/linux/agpgart.h b/include/linux/agpgart.h
new file mode 100644
index 000000000000..17a17c55a17f
--- /dev/null
+++ b/include/linux/agpgart.h
@@ -0,0 +1,214 @@
+/*
+ * AGPGART module version 0.99
+ * Copyright (C) 1999 Jeff Hartmann
+ * Copyright (C) 1999 Precision Insight, Inc.
+ * Copyright (C) 1999 Xi Graphics, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * JEFF HARTMANN, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef _AGP_H
+#define _AGP_H 1
+
+#include <linux/agp_backend.h>
+
+#define AGPIOC_BASE       'A'
+#define AGPIOC_INFO       _IOR (AGPIOC_BASE, 0, struct agp_info*)
+#define AGPIOC_ACQUIRE    _IO  (AGPIOC_BASE, 1)
+#define AGPIOC_RELEASE    _IO  (AGPIOC_BASE, 2)
+#define AGPIOC_SETUP      _IOW (AGPIOC_BASE, 3, struct agp_setup*)
+#define AGPIOC_RESERVE    _IOW (AGPIOC_BASE, 4, struct agp_region*)
+#define AGPIOC_PROTECT    _IOW (AGPIOC_BASE, 5, struct agp_region*)
+#define AGPIOC_ALLOCATE   _IOWR(AGPIOC_BASE, 6, struct agp_allocate*)
+#define AGPIOC_DEALLOCATE _IOW (AGPIOC_BASE, 7, int)
+#define AGPIOC_BIND       _IOW (AGPIOC_BASE, 8, struct agp_bind*)
+#define AGPIOC_UNBIND     _IOW (AGPIOC_BASE, 9, struct agp_unbind*)
+
+#define AGP_DEVICE      "/dev/agpgart"
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef __KERNEL__
+#include <linux/types.h>
+#include <asm/types.h>
+
+struct agp_version {
+        __u16 major;
+        __u16 minor;
+};
+
+typedef struct _agp_info {
+        struct agp_version version;     /* version of the driver        */
+        __u32 bridge_id;        /* bridge vendor/device         */
+        __u32 agp_mode;         /* mode info of bridge          */
+        unsigned long aper_base;/* base of aperture             */
+        size_t aper_size;       /* size of aperture             */
+        size_t pg_total;        /* max pages (swap + system)    */
+        size_t pg_system;       /* max pages (system)           */
+        size_t pg_used;         /* current pages used           */
+} agp_info;
+
+typedef struct _agp_setup {
+        __u32 agp_mode;         /* mode info of bridge          */
+} agp_setup;
+
+/*
+ * The "prot" down below needs still a "sleep" flag somehow ...
+ */
+typedef struct _agp_segment {
+        off_t pg_start;         /* starting page to populate    */
+        size_t pg_count;        /* number of pages              */
+        int prot;               /* prot flags for mmap          */
+} agp_segment;
+
+typedef struct _agp_region {
+        pid_t pid;              /* pid of process               */
+        size_t seg_count;       /* number of segments           */
+        struct _agp_segment *seg_list;
+} agp_region;
+
+typedef struct _agp_allocate {
+        int key;                /* tag of allocation            */
+        size_t pg_count;        /* number of pages              */
+        __u32 type;             /* 0 == normal, other devspec   */
+        __u32 physical;         /* device specific (some devices  
+                                 * need a phys address of the     
+                                 * actual page behind the gatt    
+                                 * table)                        */
+} agp_allocate;
+
+typedef struct _agp_bind {
+        int key;                /* tag of allocation            */
+        off_t pg_start;         /* starting page to populate    */
+} agp_bind;
+
+typedef struct _agp_unbind {
+        int key;                /* tag of allocation            */
+        __u32 priority;         /* priority for paging out      */
+} agp_unbind;
+
+#else                           /* __KERNEL__ */
+
+#define AGPGART_MINOR 175
+
+struct agp_info {
+        struct agp_version version;     /* version of the driver        */
+        u32 bridge_id;          /* bridge vendor/device         */
+        u32 agp_mode;           /* mode info of bridge          */
+        unsigned long aper_base;/* base of aperture             */
+        size_t aper_size;       /* size of aperture             */
+        size_t pg_total;        /* max pages (swap + system)    */
+        size_t pg_system;       /* max pages (system)           */
+        size_t pg_used;         /* current pages used           */
+};
+
+struct agp_setup {
+        u32 agp_mode;           /* mode info of bridge          */
+};
+
+/*
+ * The "prot" down below needs still a "sleep" flag somehow ...
+ */
+struct agp_segment {
+        off_t pg_start;         /* starting page to populate    */
+        size_t pg_count;        /* number of pages              */
+        int prot;               /* prot flags for mmap          */
+};
+
+struct agp_segment_priv {
+        off_t pg_start;
+        size_t pg_count;
+        pgprot_t prot;
+};
+
+struct agp_region {
+        pid_t pid;              /* pid of process               */
+        size_t seg_count;       /* number of segments           */
+        struct agp_segment *seg_list;
+};
+
+struct agp_allocate {
+        int key;                /* tag of allocation            */
+        size_t pg_count;        /* number of pages              */
+        u32 type;               /* 0 == normal, other devspec   */
+        u32 physical;           /* device specific (some devices  
+                                 * need a phys address of the     
+                                 * actual page behind the gatt    
+                                 * table)                        */
+};
+
+struct agp_bind {
+        int key;                /* tag of allocation            */
+        off_t pg_start;         /* starting page to populate    */
+};
+
+struct agp_unbind {
+        int key;                /* tag of allocation            */
+        u32 priority;           /* priority for paging out      */
+};
+
+struct agp_client {
+        struct agp_client *next;
+        struct agp_client *prev;
+        pid_t pid;
+        int num_segments;
+        struct agp_segment_priv **segments;
+};
+
+struct agp_controller {
+        struct agp_controller *next;
+        struct agp_controller *prev;
+        pid_t pid;
+        int num_clients;
+        struct agp_memory *pool;
+        struct agp_client *clients;
+};
+
+#define AGP_FF_ALLOW_CLIENT             0
+#define AGP_FF_ALLOW_CONTROLLER         1
+#define AGP_FF_IS_CLIENT                2
+#define AGP_FF_IS_CONTROLLER            3
+#define AGP_FF_IS_VALID                 4
+
+struct agp_file_private {
+        struct agp_file_private *next;
+        struct agp_file_private *prev;
+        pid_t my_pid;
+        long access_flags;      /* long req'd for set_bit --RR */
+};
+
+struct agp_front_data {
+        struct semaphore agp_mutex;
+        struct agp_controller *current_controller;
+        struct agp_controller *controllers;
+        struct agp_file_private *file_priv_list;
+        u8 used_by_controller;
+        u8 backend_acquired;
+};
+
+#endif                          /* __KERNEL__ */
+
+#endif                          /* _AGP_H */
diff --git a/include/linux/aio.h b/include/linux/aio.h
new file mode 100644
index 000000000000..a4d5af907f90
--- /dev/null
+++ b/include/linux/aio.h
@@ -0,0 +1,201 @@
+#ifndef __LINUX__AIO_H
+#define __LINUX__AIO_H
+
+#include <linux/list.h>
+#include <linux/workqueue.h>
+#include <linux/aio_abi.h>
+
+#include <asm/atomic.h>
+
+#define AIO_MAXSEGS             4
+#define AIO_KIOGRP_NR_ATOMIC    8
+
+struct kioctx;
+
+/* Notes on cancelling a kiocb:
+ *      If a kiocb is cancelled, aio_complete may return 0 to indicate 
+ *      that cancel has not yet disposed of the kiocb.  All cancel 
+ *      operations *must* call aio_put_req to dispose of the kiocb 
+ *      to guard against races with the completion code.
+ */
+#define KIOCB_C_CANCELLED       0x01
+#define KIOCB_C_COMPLETE        0x02
+
+#define KIOCB_SYNC_KEY          (~0U)
+
+/* ki_flags bits */
+#define KIF_LOCKED              0
+#define KIF_KICKED              1
+#define KIF_CANCELLED           2
+
+#define kiocbTryLock(iocb)      test_and_set_bit(KIF_LOCKED, &(iocb)->ki_flags)
+#define kiocbTryKick(iocb)      test_and_set_bit(KIF_KICKED, &(iocb)->ki_flags)
+
+#define kiocbSetLocked(iocb)    set_bit(KIF_LOCKED, &(iocb)->ki_flags)
+#define kiocbSetKicked(iocb)    set_bit(KIF_KICKED, &(iocb)->ki_flags)
+#define kiocbSetCancelled(iocb) set_bit(KIF_CANCELLED, &(iocb)->ki_flags)
+
+#define kiocbClearLocked(iocb)  clear_bit(KIF_LOCKED, &(iocb)->ki_flags)
+#define kiocbClearKicked(iocb)  clear_bit(KIF_KICKED, &(iocb)->ki_flags)
+#define kiocbClearCancelled(iocb)       clear_bit(KIF_CANCELLED, &(iocb)->ki_flags)
+
+#define kiocbIsLocked(iocb)     test_bit(KIF_LOCKED, &(iocb)->ki_flags)
+#define kiocbIsKicked(iocb)     test_bit(KIF_KICKED, &(iocb)->ki_flags)
+#define kiocbIsCancelled(iocb)  test_bit(KIF_CANCELLED, &(iocb)->ki_flags)
+
+struct kiocb {
+        struct list_head        ki_run_list;
+        long                    ki_flags;
+        int                     ki_users;
+        unsigned                ki_key;         /* id of this request */
+
+        struct file             *ki_filp;
+        struct kioctx           *ki_ctx;        /* may be NULL for sync ops */
+        int                     (*ki_cancel)(struct kiocb *, struct io_event *);
+        ssize_t                 (*ki_retry)(struct kiocb *);
+        void                    (*ki_dtor)(struct kiocb *);
+
+        struct list_head        ki_list;        /* the aio core uses this
+                                                 * for cancellation */
+
+        union {
+                void __user             *user;
+                struct task_struct      *tsk;
+        } ki_obj;
+        __u64                   ki_user_data;   /* user's data for completion */
+        loff_t                  ki_pos;
+        /* State that we remember to be able to restart/retry  */
+        unsigned short          ki_opcode;
+        size_t                  ki_nbytes;      /* copy of iocb->aio_nbytes */
+        char                    __user *ki_buf; /* remaining iocb->aio_buf */
+        size_t                  ki_left;        /* remaining bytes */
+        wait_queue_t            ki_wait;
+        long                    ki_retried;     /* just for testing */
+        long                    ki_kicked;      /* just for testing */
+        long                    ki_queued;      /* just for testing */
+
+        void                    *private;
+};
+
+#define is_sync_kiocb(iocb)     ((iocb)->ki_key == KIOCB_SYNC_KEY)
+#define init_sync_kiocb(x, filp)                        \
+        do {                                            \
+                struct task_struct *tsk = current;      \
+                (x)->ki_flags = 0;                      \
+                (x)->ki_users = 1;                      \
+                (x)->ki_key = KIOCB_SYNC_KEY;           \
+                (x)->ki_filp = (filp);                  \
+                (x)->ki_ctx = &tsk->active_mm->default_kioctx;  \
+                (x)->ki_cancel = NULL;                  \
+                (x)->ki_dtor = NULL;                    \
+                (x)->ki_obj.tsk = tsk;                  \
+                (x)->ki_user_data = 0;                  \
+                init_wait((&(x)->ki_wait));             \
+        } while (0)
+
+#define AIO_RING_MAGIC                  0xa10a10a1
+#define AIO_RING_COMPAT_FEATURES        1
+#define AIO_RING_INCOMPAT_FEATURES      0
+struct aio_ring {
+        unsigned        id;     /* kernel internal index number */
+        unsigned        nr;     /* number of io_events */
+        unsigned        head;
+        unsigned        tail;
+
+        unsigned        magic;
+        unsigned        compat_features;
+        unsigned        incompat_features;
+        unsigned        header_length;  /* size of aio_ring */
+
+
+        struct io_event         io_events[0];
+}; /* 128 bytes + ring size */
+
+#define aio_ring_avail(info, ring)      (((ring)->head + (info)->nr - 1 - (ring)->tail) % (info)->nr)
+
+#define AIO_RING_PAGES  8
+struct aio_ring_info {
+        unsigned long           mmap_base;
+        unsigned long           mmap_size;
+
+        struct page             **ring_pages;
+        spinlock_t              ring_lock;
+        long                    nr_pages;
+
+        unsigned                nr, tail;
+
+        struct page             *internal_pages[AIO_RING_PAGES];
+};
+
+struct kioctx {
+        atomic_t                users;
+        int                     dead;
+        struct mm_struct        *mm;
+
+        /* This needs improving */
+        unsigned long           user_id;
+        struct kioctx           *next;
+
+        wait_queue_head_t       wait;
+
+        spinlock_t              ctx_lock;
+
+        int                     reqs_active;
+        struct list_head        active_reqs;    /* used for cancellation */
+        struct list_head        run_list;       /* used for kicked reqs */
+
+        unsigned                max_reqs;
+
+        struct aio_ring_info    ring_info;
+
+        struct work_struct      wq;
+};
+
+/* prototypes */
+extern unsigned aio_max_size;
+
+extern ssize_t FASTCALL(wait_on_sync_kiocb(struct kiocb *iocb));
+extern int FASTCALL(aio_put_req(struct kiocb *iocb));
+extern void FASTCALL(kick_iocb(struct kiocb *iocb));
+extern int FASTCALL(aio_complete(struct kiocb *iocb, long res, long res2));
+extern void FASTCALL(__put_ioctx(struct kioctx *ctx));
+struct mm_struct;
+extern void FASTCALL(exit_aio(struct mm_struct *mm));
+extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
+extern int FASTCALL(io_submit_one(struct kioctx *ctx,
+                        struct iocb __user *user_iocb, struct iocb *iocb));
+
+/* semi private, but used by the 32bit emulations: */
+struct kioctx *lookup_ioctx(unsigned long ctx_id);
+int FASTCALL(io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
+                                  struct iocb *iocb));
+
+#define get_ioctx(kioctx)       do { if (unlikely(atomic_read(&(kioctx)->users) <= 0)) BUG(); atomic_inc(&(kioctx)->users); } while (0)
+#define put_ioctx(kioctx)       do { if (unlikely(atomic_dec_and_test(&(kioctx)->users))) __put_ioctx(kioctx); else if (unlikely(atomic_read(&(kioctx)->users) < 0)) BUG(); } while (0)
+
+#define in_aio() !is_sync_wait(current->io_wait)
+/* may be used for debugging */
+#define warn_if_async()                                                 \
+do {                                                                    \
+        if (in_aio()) {                                                 \
+                printk(KERN_ERR "%s(%s:%d) called in async context!\n", \
+                        __FUNCTION__, __FILE__, __LINE__);              \
+                dump_stack();                                           \
+        }                                                               \
+} while (0)
+
+#define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)
+#define is_retried_kiocb(iocb) ((iocb)->ki_retried > 1)
+
+#include <linux/aio_abi.h>
+
+static inline struct kiocb *list_kiocb(struct list_head *h)
+{
+        return list_entry(h, struct kiocb, ki_list);
+}
+
+/* for sysctl: */
+extern atomic_t aio_nr;
+extern unsigned aio_max_nr;
+
+#endif /* __LINUX__AIO_H */
diff --git a/include/linux/aio_abi.h b/include/linux/aio_abi.h
new file mode 100644
index 000000000000..30fdcc89d142
--- /dev/null
+++ b/include/linux/aio_abi.h
@@ -0,0 +1,92 @@
+/* linux/aio_abi.h
+ *
+ * Copyright 2000,2001,2002 Red Hat.
+ *
+ * Written by Benjamin LaHaise <bcrl@kvack.org>
+ *
+ * Distribute under the terms of the GPLv2 (see ../../COPYING) or under 
+ * the following terms.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation is hereby granted, provided that the above copyright
+ * notice appears in all copies.  This software is provided without any
+ * warranty, express or implied.  Red Hat makes no representations about
+ * the suitability of this software for any purpose.
+ *
+ * IN NO EVENT SHALL RED HAT BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
+ * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
+ * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RED HAT HAS BEEN ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * RED HAT DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
+ * RED HAT HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
+ * ENHANCEMENTS, OR MODIFICATIONS.
+ */
+#ifndef __LINUX__AIO_ABI_H
+#define __LINUX__AIO_ABI_H
+
+#include <asm/byteorder.h>
+
+typedef unsigned long   aio_context_t;
+
+enum {
+        IOCB_CMD_PREAD = 0,
+        IOCB_CMD_PWRITE = 1,
+        IOCB_CMD_FSYNC = 2,
+        IOCB_CMD_FDSYNC = 3,
+        /* These two are experimental.
+         * IOCB_CMD_PREADX = 4,
+         * IOCB_CMD_POLL = 5,
+         */
+        IOCB_CMD_NOOP = 6,
+};
+
+/* read() from /dev/aio returns these structures. */
+struct io_event {
+        __u64           data;           /* the data field from the iocb */
+        __u64           obj;            /* what iocb this event came from */
+        __s64           res;            /* result code for this event */
+        __s64           res2;           /* secondary result */
+};
+
+#if defined(__LITTLE_ENDIAN)
+#define PADDED(x,y)     x, y
+#elif defined(__BIG_ENDIAN)
+#define PADDED(x,y)     y, x
+#else
+#error edit for your odd byteorder.
+#endif
+
+/*
+ * we always use a 64bit off_t when communicating
+ * with userland.  its up to libraries to do the
+ * proper padding and aio_error abstraction
+ */
+
+struct iocb {
+        /* these are internal to the kernel/libc. */
+        __u64   aio_data;       /* data to be returned in event's data */
+        __u32   PADDED(aio_key, aio_reserved1);
+                                /* the kernel sets aio_key to the req # */
+
+        /* common fields */
+        __u16   aio_lio_opcode; /* see IOCB_CMD_ above */
+        __s16   aio_reqprio;
+        __u32   aio_fildes;
+
+        __u64   aio_buf;
+        __u64   aio_nbytes;
+        __s64   aio_offset;
+
+        /* extra parameters */
+        __u64   aio_reserved2;  /* TODO: use this for a (struct sigevent *) */
+        __u64   aio_reserved3;
+}; /* 64 bytes */
+
+#undef IFBIG
+#undef IFLITTLE
+
+#endif /* __LINUX__AIO_ABI_H */
+
diff --git a/include/linux/amifd.h b/include/linux/amifd.h
new file mode 100644
index 000000000000..346993268b45
--- /dev/null
+++ b/include/linux/amifd.h
@@ -0,0 +1,62 @@
+#ifndef _AMIFD_H
+#define _AMIFD_H
+
+/* Definitions for the Amiga floppy driver */
+
+#include <linux/fd.h>
+
+#define FD_MAX_UNITS    4       /* Max. Number of drives */
+#define FLOPPY_MAX_SECTORS      22      /* Max. Number of sectors per track */
+
+#ifndef ASSEMBLER
+
+struct fd_data_type {
+    char *name;                 /* description of data type */
+    int sects;                  /* sectors per track */
+#ifdef __STDC__
+    int (*read_fkt)(int);
+    void (*write_fkt)(int);
+#else
+    int (*read_fkt)();          /* read whole track */
+    void (*write_fkt)();                /* write whole track */
+#endif
+};
+
+/*
+** Floppy type descriptions
+*/
+
+struct fd_drive_type {
+    unsigned long code;         /* code returned from drive */
+    char *name;                 /* description of drive */
+    unsigned int tracks;        /* number of tracks */
+    unsigned int heads;         /* number of heads */
+    unsigned int read_size;     /* raw read size for one track */
+    unsigned int write_size;    /* raw write size for one track */
+    unsigned int sect_mult;     /* sectors and gap multiplier (HD = 2) */
+    unsigned int precomp1;      /* start track for precomp 1 */
+    unsigned int precomp2;      /* start track for precomp 2 */
+    unsigned int step_delay;    /* time (in ms) for delay after step */
+    unsigned int settle_time;   /* time to settle after dir change */
+    unsigned int side_time;     /* time needed to change sides */
+};
+
+struct amiga_floppy_struct {
+    struct fd_drive_type *type; /* type of floppy for this unit */
+    struct fd_data_type *dtype; /* type of floppy for this unit */
+    int track;                  /* current track (-1 == unknown) */
+    unsigned char *trackbuf;    /* current track (kmaloc()'d */
+
+    int blocks;                 /* total # blocks on disk */
+
+    int changed;                /* true when not known */
+    int disk;                   /* disk in drive (-1 == unknown) */
+    int motor;                  /* true when motor is at speed */
+    int busy;                   /* true when drive is active */
+    int dirty;                  /* true when trackbuf is not on disk */
+    int status;                 /* current error code for unit */
+    struct gendisk *gendisk;
+};
+#endif
+
+#endif
diff --git a/include/linux/amifdreg.h b/include/linux/amifdreg.h
new file mode 100644
index 000000000000..76188bf48d3b
--- /dev/null
+++ b/include/linux/amifdreg.h
@@ -0,0 +1,81 @@
+#ifndef _LINUX_AMIFDREG_H
+#define _LINUX_AMIFDREG_H
+
+/*
+** CIAAPRA bits (read only)
+*/
+
+#define DSKRDY      (0x1<<5)        /* disk ready when low */
+#define DSKTRACK0   (0x1<<4)        /* head at track zero when low */
+#define DSKPROT     (0x1<<3)        /* disk protected when low */
+#define DSKCHANGE   (0x1<<2)        /* low when disk removed */
+
+/*
+** CIAAPRB bits (read/write)
+*/
+
+#define DSKMOTOR    (0x1<<7)        /* motor on when low */
+#define DSKSEL3     (0x1<<6)        /* select drive 3 when low */
+#define DSKSEL2     (0x1<<5)        /* select drive 2 when low */
+#define DSKSEL1     (0x1<<4)        /* select drive 1 when low */
+#define DSKSEL0     (0x1<<3)        /* select drive 0 when low */
+#define DSKSIDE     (0x1<<2)        /* side selection: 0 = upper, 1 = lower */
+#define DSKDIREC    (0x1<<1)        /* step direction: 0=in, 1=out (to trk 0) */
+#define DSKSTEP     (0x1)           /* pulse low to step head 1 track */
+
+/*
+** DSKBYTR bits (read only)
+*/
+
+#define DSKBYT      (1<<15)         /* register contains valid byte when set */
+#define DMAON       (1<<14)         /* disk DMA enabled */
+#define DISKWRITE   (1<<13)         /* disk write bit in DSKLEN enabled */
+#define WORDEQUAL   (1<<12)         /* DSKSYNC register match when true */
+/* bits 7-0 are data */
+
+/*
+** ADKCON/ADKCONR bits
+*/
+
+#ifndef SETCLR
+#define ADK_SETCLR      (1<<15)     /* control bit */
+#endif
+#define ADK_PRECOMP1    (1<<14)     /* precompensation selection */
+#define ADK_PRECOMP0    (1<<13)     /* 00=none, 01=140ns, 10=280ns, 11=500ns */
+#define ADK_MFMPREC     (1<<12)     /* 0=GCR precomp., 1=MFM precomp. */
+#define ADK_WORDSYNC    (1<<10)     /* enable DSKSYNC auto DMA */
+#define ADK_MSBSYNC     (1<<9)      /* when 1, enable sync on MSbit (for GCR) */
+#define ADK_FAST        (1<<8)      /* bit cell: 0=2us (GCR), 1=1us (MFM) */
+ 
+/*
+** DSKLEN bits
+*/
+
+#define DSKLEN_DMAEN    (1<<15)
+#define DSKLEN_WRITE    (1<<14)
+
+/*
+** INTENA/INTREQ bits
+*/
+
+#define DSKINDEX    (0x1<<4)        /* DSKINDEX bit */
+
+/*
+** Misc
+*/
+ 
+#define MFM_SYNC    0x4489          /* standard MFM sync value */
+
+/* Values for FD_COMMAND */
+#define FD_RECALIBRATE          0x07    /* move to track 0 */
+#define FD_SEEK                 0x0F    /* seek track */
+#define FD_READ                 0xE6    /* read with MT, MFM, SKip deleted */
+#define FD_WRITE                0xC5    /* write with MT, MFM */
+#define FD_SENSEI               0x08    /* Sense Interrupt Status */
+#define FD_SPECIFY              0x03    /* specify HUT etc */
+#define FD_FORMAT               0x4D    /* format one track */
+#define FD_VERSION              0x10    /* get version code */
+#define FD_CONFIGURE            0x13    /* configure FIFO operation */
+#define FD_PERPENDICULAR        0x12    /* perpendicular r/w mode */
+
+#endif /* _LINUX_AMIFDREG_H */
diff --git a/include/linux/amigaffs.h b/include/linux/amigaffs.h
new file mode 100644
index 000000000000..43b41c06aa37
--- /dev/null
+++ b/include/linux/amigaffs.h
@@ -0,0 +1,144 @@
+#ifndef AMIGAFFS_H
+#define AMIGAFFS_H
+
+#include <linux/types.h>
+#include <asm/byteorder.h>
+
+#define FS_OFS          0x444F5300
+#define FS_FFS          0x444F5301
+#define FS_INTLOFS      0x444F5302
+#define FS_INTLFFS      0x444F5303
+#define FS_DCOFS        0x444F5304
+#define FS_DCFFS        0x444F5305
+#define MUFS_FS         0x6d754653   /* 'muFS' */
+#define MUFS_OFS        0x6d754600   /* 'muF\0' */
+#define MUFS_FFS        0x6d754601   /* 'muF\1' */
+#define MUFS_INTLOFS    0x6d754602   /* 'muF\2' */
+#define MUFS_INTLFFS    0x6d754603   /* 'muF\3' */
+#define MUFS_DCOFS      0x6d754604   /* 'muF\4' */
+#define MUFS_DCFFS      0x6d754605   /* 'muF\5' */
+
+#define T_SHORT         2
+#define T_LIST          16
+#define T_DATA          8
+
+#define ST_LINKFILE     -4
+#define ST_FILE         -3
+#define ST_ROOT         1
+#define ST_USERDIR      2
+#define ST_SOFTLINK     3
+#define ST_LINKDIR      4
+
+#define AFFS_ROOT_BMAPS         25
+
+struct affs_date {
+        __be32 days;
+        __be32 mins;
+        __be32 ticks;
+};
+
+struct affs_short_date {
+        __be16 days;
+        __be16 mins;
+        __be16 ticks;
+};
+
+struct affs_root_head {
+        __be32 ptype;
+        __be32 spare1;
+        __be32 spare2;
+        __be32 hash_size;
+        __be32 spare3;
+        __be32 checksum;
+        __be32 hashtable[1];
+};
+
+struct affs_root_tail {
+        __be32 bm_flag;
+        __be32 bm_blk[AFFS_ROOT_BMAPS];
+        __be32 bm_ext;
+        struct affs_date root_change;
+        u8 disk_name[32];
+        __be32 spare1;
+        __be32 spare2;
+        struct affs_date disk_change;
+        struct affs_date disk_create;
+        __be32 spare3;
+        __be32 spare4;
+        __be32 dcache;
+        __be32 stype;
+};
+
+struct affs_head {
+        __be32 ptype;
+        __be32 key;
+        __be32 block_count;
+        __be32 spare1;
+        __be32 first_data;
+        __be32 checksum;
+        __be32 table[1];
+};
+
+struct affs_tail {
+        __be32 spare1;
+        __be16 uid;
+        __be16 gid;
+        __be32 protect;
+        __be32 size;
+        u8 comment[92];
+        struct affs_date change;
+        u8 name[32];
+        __be32 spare2;
+        __be32 original;
+        __be32 link_chain;
+        __be32 spare[5];
+        __be32 hash_chain;
+        __be32 parent;
+        __be32 extension;
+        __be32 stype;
+};
+
+struct slink_front
+{
+        __be32 ptype;
+        __be32 key;
+        __be32 spare1[3];
+        __be32 checksum;
+        u8 symname[1];  /* depends on block size */
+};
+
+struct affs_data_head
+{
+        __be32 ptype;
+        __be32 key;
+        __be32 sequence;
+        __be32 size;
+        __be32 next;
+        __be32 checksum;
+        u8 data[1];     /* depends on block size */
+};
+
+/* Permission bits */
+
+#define FIBF_OTR_READ           0x8000
+#define FIBF_OTR_WRITE          0x4000
+#define FIBF_OTR_EXECUTE        0x2000
+#define FIBF_OTR_DELETE         0x1000
+#define FIBF_GRP_READ           0x0800
+#define FIBF_GRP_WRITE          0x0400
+#define FIBF_GRP_EXECUTE        0x0200
+#define FIBF_GRP_DELETE         0x0100
+
+#define FIBF_HIDDEN             0x0080
+#define FIBF_SCRIPT             0x0040
+#define FIBF_PURE               0x0020          /* no use under linux */
+#define FIBF_ARCHIVED           0x0010          /* never set, always cleared on write */
+#define FIBF_NOREAD             0x0008          /* 0 means allowed */
+#define FIBF_NOWRITE            0x0004          /* 0 means allowed */
+#define FIBF_NOEXECUTE          0x0002          /* 0 means allowed, ignored under linux */
+#define FIBF_NODELETE           0x0001          /* 0 means allowed */
+
+#define FIBF_OWNER              0x000F          /* Bits pertaining to owner */
+#define FIBF_MASK               0xEE0E          /* Bits modified by Linux */
+
+#endif
diff --git a/include/linux/apm_bios.h b/include/linux/apm_bios.h
new file mode 100644
index 000000000000..290aef326812
--- /dev/null
+++ b/include/linux/apm_bios.h
@@ -0,0 +1,218 @@
+#ifndef _LINUX_APM_H
+#define _LINUX_APM_H
+
+/*
+ * Include file for the interface to an APM BIOS
+ * Copyright 1994-2001 Stephen Rothwell (sfr@canb.auug.org.au)
+ *
+ * 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; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+typedef unsigned short  apm_event_t;
+typedef unsigned short  apm_eventinfo_t;
+
+#ifdef __KERNEL__
+
+#define APM_CS          (GDT_ENTRY_APMBIOS_BASE * 8)
+#define APM_CS_16       (APM_CS + 8)
+#define APM_DS          (APM_CS_16 + 8)
+
+struct apm_bios_info {
+        unsigned short  version;
+        unsigned short  cseg;
+        unsigned long   offset;
+        unsigned short  cseg_16;
+        unsigned short  dseg;
+        unsigned short  flags;
+        unsigned short  cseg_len;
+        unsigned short  cseg_16_len;
+        unsigned short  dseg_len;
+};
+
+/* Results of APM Installation Check */
+#define APM_16_BIT_SUPPORT      0x0001
+#define APM_32_BIT_SUPPORT      0x0002
+#define APM_IDLE_SLOWS_CLOCK    0x0004
+#define APM_BIOS_DISABLED       0x0008
+#define APM_BIOS_DISENGAGED     0x0010
+
+/*
+ * Data for APM that is persistent across module unload/load
+ */
+struct apm_info {
+        struct apm_bios_info    bios;
+        unsigned short          connection_version;
+        int                     get_power_status_broken;
+        int                     get_power_status_swabinminutes;
+        int                     allow_ints;
+        int                     forbid_idle;
+        int                     realmode_power_off;
+        int                     disabled;
+};
+
+/*
+ * The APM function codes
+ */
+#define APM_FUNC_INST_CHECK     0x5300
+#define APM_FUNC_REAL_CONN      0x5301
+#define APM_FUNC_16BIT_CONN     0x5302
+#define APM_FUNC_32BIT_CONN     0x5303
+#define APM_FUNC_DISCONN        0x5304
+#define APM_FUNC_IDLE           0x5305
+#define APM_FUNC_BUSY           0x5306
+#define APM_FUNC_SET_STATE      0x5307
+#define APM_FUNC_ENABLE_PM      0x5308
+#define APM_FUNC_RESTORE_BIOS   0x5309
+#define APM_FUNC_GET_STATUS     0x530a
+#define APM_FUNC_GET_EVENT      0x530b
+#define APM_FUNC_GET_STATE      0x530c
+#define APM_FUNC_ENABLE_DEV_PM  0x530d
+#define APM_FUNC_VERSION        0x530e
+#define APM_FUNC_ENGAGE_PM      0x530f
+#define APM_FUNC_GET_CAP        0x5310
+#define APM_FUNC_RESUME_TIMER   0x5311
+#define APM_FUNC_RESUME_ON_RING 0x5312
+#define APM_FUNC_TIMER          0x5313
+
+/*
+ * Function code for APM_FUNC_RESUME_TIMER
+ */
+#define APM_FUNC_DISABLE_TIMER  0
+#define APM_FUNC_GET_TIMER      1
+#define APM_FUNC_SET_TIMER      2
+
+/*
+ * Function code for APM_FUNC_RESUME_ON_RING
+ */
+#define APM_FUNC_DISABLE_RING   0
+#define APM_FUNC_ENABLE_RING    1
+#define APM_FUNC_GET_RING       2
+
+/*
+ * Function code for APM_FUNC_TIMER_STATUS
+ */
+#define APM_FUNC_TIMER_DISABLE  0
+#define APM_FUNC_TIMER_ENABLE   1
+#define APM_FUNC_TIMER_GET      2
+
+/*
+ * in arch/i386/kernel/setup.c
+ */
+extern struct apm_info  apm_info;
+
+#endif  /* __KERNEL__ */
+
+/*
+ * Power states
+ */
+#define APM_STATE_READY         0x0000
+#define APM_STATE_STANDBY       0x0001
+#define APM_STATE_SUSPEND       0x0002
+#define APM_STATE_OFF           0x0003
+#define APM_STATE_BUSY          0x0004
+#define APM_STATE_REJECT        0x0005
+#define APM_STATE_OEM_SYS       0x0020
+#define APM_STATE_OEM_DEV       0x0040
+
+#define APM_STATE_DISABLE       0x0000
+#define APM_STATE_ENABLE        0x0001
+
+#define APM_STATE_DISENGAGE     0x0000
+#define APM_STATE_ENGAGE        0x0001
+
+/*
+ * Events (results of Get PM Event)
+ */
+#define APM_SYS_STANDBY         0x0001
+#define APM_SYS_SUSPEND         0x0002
+#define APM_NORMAL_RESUME       0x0003
+#define APM_CRITICAL_RESUME     0x0004
+#define APM_LOW_BATTERY         0x0005
+#define APM_POWER_STATUS_CHANGE 0x0006
+#define APM_UPDATE_TIME         0x0007
+#define APM_CRITICAL_SUSPEND    0x0008
+#define APM_USER_STANDBY        0x0009
+#define APM_USER_SUSPEND        0x000a
+#define APM_STANDBY_RESUME      0x000b
+#define APM_CAPABILITY_CHANGE   0x000c
+
+/*
+ * Error codes
+ */
+#define APM_SUCCESS             0x00
+#define APM_DISABLED            0x01
+#define APM_CONNECTED           0x02
+#define APM_NOT_CONNECTED       0x03
+#define APM_16_CONNECTED        0x05
+#define APM_16_UNSUPPORTED      0x06
+#define APM_32_CONNECTED        0x07
+#define APM_32_UNSUPPORTED      0x08
+#define APM_BAD_DEVICE          0x09
+#define APM_BAD_PARAM           0x0a
+#define APM_NOT_ENGAGED         0x0b
+#define APM_BAD_FUNCTION        0x0c
+#define APM_RESUME_DISABLED     0x0d
+#define APM_NO_ERROR            0x53
+#define APM_BAD_STATE           0x60
+#define APM_NO_EVENTS           0x80
+#define APM_NOT_PRESENT         0x86
+
+/*
+ * APM Device IDs
+ */
+#define APM_DEVICE_BIOS         0x0000
+#define APM_DEVICE_ALL          0x0001
+#define APM_DEVICE_DISPLAY      0x0100
+#define APM_DEVICE_STORAGE      0x0200
+#define APM_DEVICE_PARALLEL     0x0300
+#define APM_DEVICE_SERIAL       0x0400
+#define APM_DEVICE_NETWORK      0x0500
+#define APM_DEVICE_PCMCIA       0x0600
+#define APM_DEVICE_BATTERY      0x8000
+#define APM_DEVICE_OEM          0xe000
+#define APM_DEVICE_OLD_ALL      0xffff
+#define APM_DEVICE_CLASS        0x00ff
+#define APM_DEVICE_MASK         0xff00
+
+#ifdef __KERNEL__
+/*
+ * This is the "All Devices" ID communicated to the BIOS
+ */
+#define APM_DEVICE_BALL         ((apm_info.connection_version > 0x0100) ? \
+                                 APM_DEVICE_ALL : APM_DEVICE_OLD_ALL)
+#endif
+
+/*
+ * Battery status
+ */
+#define APM_MAX_BATTERIES       2
+
+/*
+ * APM defined capability bit flags
+ */
+#define APM_CAP_GLOBAL_STANDBY          0x0001
+#define APM_CAP_GLOBAL_SUSPEND          0x0002
+#define APM_CAP_RESUME_STANDBY_TIMER    0x0004 /* Timer resume from standby */
+#define APM_CAP_RESUME_SUSPEND_TIMER    0x0008 /* Timer resume from suspend */
+#define APM_CAP_RESUME_STANDBY_RING     0x0010 /* Resume on Ring fr standby */
+#define APM_CAP_RESUME_SUSPEND_RING     0x0020 /* Resume on Ring fr suspend */
+#define APM_CAP_RESUME_STANDBY_PCMCIA   0x0040 /* Resume on PCMCIA Ring */
+#define APM_CAP_RESUME_SUSPEND_PCMCIA   0x0080 /* Resume on PCMCIA Ring */
+
+/*
+ * ioctl operations
+ */
+#include <linux/ioctl.h>
+
+#define APM_IOC_STANDBY         _IO('A', 1)
+#define APM_IOC_SUSPEND         _IO('A', 2)
+
+#endif  /* LINUX_APM_H */
diff --git a/include/linux/arcdevice.h b/include/linux/arcdevice.h
new file mode 100644
index 000000000000..7198f129e135
--- /dev/null
+++ b/include/linux/arcdevice.h
@@ -0,0 +1,350 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  NET  is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions used by the ARCnet driver.
+ *
+ * Authors:     Avery Pennarun and David Woodhouse
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ */
+#ifndef _LINUX_ARCDEVICE_H
+#define _LINUX_ARCDEVICE_H
+
+#include <asm/timex.h>
+#include <linux/if_arcnet.h>
+
+#ifdef __KERNEL__
+
+#ifndef bool
+#define bool int
+#endif
+
+/*
+ * RECON_THRESHOLD is the maximum number of RECON messages to receive
+ * within one minute before printing a "cabling problem" warning. The
+ * default value should be fine.
+ *
+ * After that, a "cabling restored" message will be printed on the next IRQ
+ * if no RECON messages have been received for 10 seconds.
+ *
+ * Do not define RECON_THRESHOLD at all if you want to disable this feature.
+ */
+#define RECON_THRESHOLD 30
+
+
+/*
+ * Define this to the minimum "timeout" value.  If a transmit takes longer
+ * than TX_TIMEOUT jiffies, Linux will abort the TX and retry.  On a large
+ * network, or one with heavy network traffic, this timeout may need to be
+ * increased.  The larger it is, though, the longer it will be between
+ * necessary transmits - don't set this too high.
+ */
+#define TX_TIMEOUT (HZ * 200 / 1000)
+
+
+/* Display warnings about the driver being an ALPHA version. */
+#undef ALPHA_WARNING
+
+
+/*
+ * Debugging bitflags: each option can be enabled individually.
+ * 
+ * Note: only debug flags included in the ARCNET_DEBUG_MAX define will
+ *   actually be available.  GCC will (at least, GCC 2.7.0 will) notice
+ *   lines using a BUGLVL not in ARCNET_DEBUG_MAX and automatically optimize
+ *   them out.
+ */
+#define D_NORMAL        1       /* important operational info             */
+#define D_EXTRA         2       /* useful, but non-vital information      */
+#define D_INIT          4       /* show init/probe messages               */
+#define D_INIT_REASONS  8       /* show reasons for discarding probes     */
+#define D_RECON         32      /* print a message whenever token is lost */
+#define D_PROTO         64      /* debug auto-protocol support            */
+/* debug levels below give LOTS of output during normal operation! */
+#define D_DURING        128     /* trace operations (including irq's)     */
+#define D_TX            256     /* show tx packets                        */
+#define D_RX            512     /* show rx packets                        */
+#define D_SKB           1024    /* show skb's                             */
+#define D_SKB_SIZE      2048    /* show skb sizes                         */
+#define D_TIMING        4096    /* show time needed to copy buffers to card */
+#define D_DEBUG         8192    /* Very detailed debug line for line */
+
+#ifndef ARCNET_DEBUG_MAX
+#define ARCNET_DEBUG_MAX (127)  /* change to ~0 if you want detailed debugging */
+#endif
+
+#ifndef ARCNET_DEBUG
+#define ARCNET_DEBUG (D_NORMAL|D_EXTRA)
+#endif
+extern int arcnet_debug;
+
+/* macros to simplify debug checking */
+#define BUGLVL(x) if ((ARCNET_DEBUG_MAX)&arcnet_debug&(x))
+#define BUGMSG2(x,msg,args...) do { BUGLVL(x) printk(msg, ## args); } while (0)
+#define BUGMSG(x,msg,args...) \
+        BUGMSG2(x, "%s%6s: " msg, \
+            x==D_NORMAL ? KERN_WARNING \
+                        : x < D_DURING ? KERN_INFO : KERN_DEBUG, \
+            dev->name , ## args)
+
+/* see how long a function call takes to run, expressed in CPU cycles */
+#define TIME(name, bytes, call) BUGLVL(D_TIMING) { \
+            unsigned long _x, _y; \
+            _x = get_cycles(); \
+            call; \
+            _y = get_cycles(); \
+            BUGMSG(D_TIMING, \
+               "%s: %d bytes in %lu cycles == " \
+               "%lu Kbytes/100Mcycle\n",\
+                   name, bytes, _y - _x, \
+                   100000000 / 1024 * bytes / (_y - _x + 1));\
+        } \
+        else { \
+                    call;\
+        }
+
+
+/*
+ * Time needed to reset the card - in ms (milliseconds).  This works on my
+ * SMC PC100.  I can't find a reference that tells me just how long I
+ * should wait.
+ */
+#define RESETtime (300)
+
+/*
+ * These are the max/min lengths of packet payload, not including the
+ * arc_hardware header, but definitely including the soft header.
+ *
+ * Note: packet sizes 254, 255, 256 are impossible because of the way
+ * ARCnet registers work  That's why RFC1201 defines "exception" packets.
+ * In non-RFC1201 protocols, we have to just tack some extra bytes on the
+ * end.
+ */
+#define MTU     253             /* normal packet max size */
+#define MinTU   257             /* extended packet min size */
+#define XMTU    508             /* extended packet max size */
+
+/* status/interrupt mask bit fields */
+#define TXFREEflag      0x01    /* transmitter available */
+#define TXACKflag       0x02    /* transmitted msg. ackd */
+#define RECONflag       0x04    /* network reconfigured */
+#define TESTflag        0x08    /* test flag */
+#define EXCNAKflag      0x08    /* excesive nak flag */
+#define RESETflag       0x10    /* power-on-reset */
+#define RES1flag        0x20    /* reserved - usually set by jumper */
+#define RES2flag        0x40    /* reserved - usually set by jumper */
+#define NORXflag        0x80    /* receiver inhibited */
+
+/* Flags used for IO-mapped memory operations */
+#define AUTOINCflag     0x40    /* Increase location with each access */
+#define IOMAPflag       0x02    /* (for 90xx) Use IO mapped memory, not mmap */
+#define ENABLE16flag    0x80    /* (for 90xx) Enable 16-bit mode */
+
+/* in the command register, the following bits have these meanings:
+ *                0-2     command
+ *                3-4     page number (for enable rcv/xmt command)
+ *                 7      receive broadcasts
+ */
+#define NOTXcmd         0x01    /* disable transmitter */
+#define NORXcmd         0x02    /* disable receiver */
+#define TXcmd           0x03    /* enable transmitter */
+#define RXcmd           0x04    /* enable receiver */
+#define CONFIGcmd       0x05    /* define configuration */
+#define CFLAGScmd       0x06    /* clear flags */
+#define TESTcmd         0x07    /* load test flags */
+
+/* flags for "clear flags" command */
+#define RESETclear      0x08    /* power-on-reset */
+#define CONFIGclear     0x10    /* system reconfigured */
+
+#define EXCNAKclear     0x0E    /* Clear and acknowledge the excive nak bit */
+
+/* flags for "load test flags" command */
+#define TESTload        0x08    /* test flag (diagnostic) */
+
+/* byte deposited into first address of buffers on reset */
+#define TESTvalue       0321    /* that's octal for 0xD1 :) */
+
+/* for "enable receiver" command */
+#define RXbcasts        0x80    /* receive broadcasts */
+
+/* flags for "define configuration" command */
+#define NORMALconf      0x00    /* 1-249 byte packets */
+#define EXTconf         0x08    /* 250-504 byte packets */
+
+/* card feature flags, set during auto-detection.
+ * (currently only used by com20020pci)
+ */
+#define ARC_IS_5MBIT    1   /* card default speed is 5MBit */
+#define ARC_CAN_10MBIT  2   /* card uses COM20022, supporting 10MBit,
+                                 but default is 2.5MBit. */
+
+
+/* information needed to define an encapsulation driver */
+struct ArcProto {
+        char suffix;            /* a for RFC1201, e for ether-encap, etc. */
+        int mtu;                /* largest possible packet */
+        int is_ip;              /* This is a ip plugin - not a raw thing */
+
+        void (*rx) (struct net_device * dev, int bufnum,
+                    struct archdr * pkthdr, int length);
+        int (*build_header) (struct sk_buff * skb, struct net_device *dev,
+                             unsigned short ethproto, uint8_t daddr);
+
+        /* these functions return '1' if the skb can now be freed */
+        int (*prepare_tx) (struct net_device * dev, struct archdr * pkt, int length,
+                           int bufnum);
+        int (*continue_tx) (struct net_device * dev, int bufnum);
+        int (*ack_tx) (struct net_device * dev, int acked);
+};
+
+extern struct ArcProto *arc_proto_map[256], *arc_proto_default,
+        *arc_bcast_proto, *arc_raw_proto;
+extern struct ArcProto arc_proto_null;
+
+
+/*
+ * "Incoming" is information needed for each address that could be sending
+ * to us.  Mostly for partially-received split packets.
+ */
+struct Incoming {
+        struct sk_buff *skb;    /* packet data buffer             */
+        uint16_t sequence;      /* sequence number of assembly    */
+        uint8_t lastpacket,     /* number of last packet (from 1) */
+                numpackets;     /* number of packets in split     */
+};
+
+
+/* only needed for RFC1201 */
+struct Outgoing {
+        struct ArcProto *proto; /* protocol driver that owns this:
+                                 *   if NULL, no packet is pending.
+                                 */
+        struct sk_buff *skb;    /* buffer from upper levels */
+        struct archdr *pkt;     /* a pointer into the skb */
+        uint16_t length,        /* bytes total */
+                dataleft,       /* bytes left */
+                segnum,         /* segment being sent */
+                numsegs;        /* number of segments */
+};
+
+
+struct arcnet_local {
+        struct net_device_stats stats;
+
+        uint8_t config,         /* current value of CONFIG register */
+                timeout,        /* Extended timeout for COM20020 */
+                backplane,      /* Backplane flag for COM20020 */
+                clockp,         /* COM20020 clock divider */
+                clockm,         /* COM20020 clock multiplier flag */
+                setup,          /* Contents of setup1 register */
+                setup2,         /* Contents of setup2 register */
+                intmask;        /* current value of INTMASK register */
+        uint8_t default_proto[256];     /* default encap to use for each host */
+        int     cur_tx,         /* buffer used by current transmit, or -1 */
+                next_tx,        /* buffer where a packet is ready to send */
+                cur_rx;         /* current receive buffer */
+        int     lastload_dest,  /* can last loaded packet be acked? */
+                lasttrans_dest; /* can last TX'd packet be acked? */
+        int     timed_out;      /* need to process TX timeout and drop packet */
+        unsigned long last_timeout;     /* time of last reported timeout */
+        char *card_name;        /* card ident string */
+        int card_flags;         /* special card features */
+
+
+        /* On preemtive and SMB a lock is needed */
+        spinlock_t lock;
+
+        /*
+         * Buffer management: an ARCnet card has 4 x 512-byte buffers, each of
+         * which can be used for either sending or receiving.  The new dynamic
+         * buffer management routines use a simple circular queue of available
+         * buffers, and take them as they're needed.  This way, we simplify
+         * situations in which we (for example) want to pre-load a transmit
+         * buffer, or start receiving while we copy a received packet to
+         * memory.
+         * 
+         * The rules: only the interrupt handler is allowed to _add_ buffers to
+         * the queue; thus, this doesn't require a lock.  Both the interrupt
+         * handler and the transmit function will want to _remove_ buffers, so
+         * we need to handle the situation where they try to do it at the same
+         * time.
+         * 
+         * If next_buf == first_free_buf, the queue is empty.  Since there are
+         * only four possible buffers, the queue should never be full.
+         */
+        atomic_t buf_lock;
+        int buf_queue[5];
+        int next_buf, first_free_buf;
+
+        /* network "reconfiguration" handling */
+        time_t first_recon,     /* time of "first" RECON message to count */
+                last_recon;     /* time of most recent RECON */
+        int num_recons;         /* number of RECONs between first and last. */
+        bool network_down;      /* do we think the network is down? */
+
+        bool excnak_pending;    /* We just got an excesive nak interrupt */
+
+        struct {
+                uint16_t sequence;      /* sequence number (incs with each packet) */
+                uint16_t aborted_seq;
+
+                struct Incoming incoming[256];  /* one from each address */
+        } rfc1201;
+
+        /* really only used by rfc1201, but we'll pretend it's not */
+        struct Outgoing outgoing;       /* packet currently being sent */
+
+        /* hardware-specific functions */
+        struct {
+                struct module *owner;
+                void (*command) (struct net_device * dev, int cmd);
+                int (*status) (struct net_device * dev);
+                void (*intmask) (struct net_device * dev, int mask);
+                bool (*reset) (struct net_device * dev, bool really_reset);
+                void (*open) (struct net_device * dev);
+                void (*close) (struct net_device * dev);
+
+                void (*copy_to_card) (struct net_device * dev, int bufnum, int offset,
+                                      void *buf, int count);
+                void (*copy_from_card) (struct net_device * dev, int bufnum, int offset,
+                                        void *buf, int count);
+        } hw;
+
+        void __iomem *mem_start;        /* pointer to ioremap'ed MMIO */
+};
+
+
+#define ARCRESET(x)  (lp->hw.reset(dev, (x)))
+#define ACOMMAND(x)  (lp->hw.command(dev, (x)))
+#define ASTATUS()    (lp->hw.status(dev))
+#define AINTMASK(x)  (lp->hw.intmask(dev, (x)))
+
+
+
+#if ARCNET_DEBUG_MAX & D_SKB
+void arcnet_dump_skb(struct net_device *dev, struct sk_buff *skb, char *desc);
+#else
+#define arcnet_dump_skb(dev,skb,desc) ;
+#endif
+
+#if (ARCNET_DEBUG_MAX & D_RX) || (ARCNET_DEBUG_MAX & D_TX)
+void arcnet_dump_packet(struct net_device *dev, int bufnum, char *desc,
+                        int take_arcnet_lock);
+#else
+#define arcnet_dump_packet(dev, bufnum, desc,take_arcnet_lock) ;
+#endif
+
+void arcnet_unregister_proto(struct ArcProto *proto);
+irqreturn_t arcnet_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+struct net_device *alloc_arcdev(char *name);
+void arcnet_rx(struct net_device *dev, int bufnum);
+
+#endif                          /* __KERNEL__ */
+#endif                          /* _LINUX_ARCDEVICE_H */
diff --git a/include/linux/ata.h b/include/linux/ata.h
new file mode 100644
index 000000000000..f178894edd04
--- /dev/null
+++ b/include/linux/ata.h
@@ -0,0 +1,268 @@
+
+/*
+   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+   Copyright 2003-2004 Jeff Garzik
+
+   The contents of this file are subject to the Open
+   Software License version 1.1 that can be found at
+   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
+   by reference.
+
+   Alternatively, the contents of this file may be used under the terms
+   of the GNU General Public License version 2 (the "GPL") as distributed
+   in the kernel source COPYING file, in which case the provisions of
+   the GPL are applicable instead of the above.  If you wish to allow
+   the use of your version of this file only under the terms of the
+   GPL and not to allow others to use your version of this file under
+   the OSL, indicate your decision by deleting the provisions above and
+   replace them with the notice and other provisions required by the GPL.
+   If you do not delete the provisions above, a recipient may use your
+   version of this file under either the OSL or the GPL.
+
+ */
+
+#ifndef __LINUX_ATA_H__
+#define __LINUX_ATA_H__
+
+#include <linux/types.h>
+
+/* defines only for the constants which don't work well as enums */
+#define ATA_DMA_BOUNDARY        0xffffUL
+#define ATA_DMA_MASK            0xffffffffULL
+
+enum {
+        /* various global constants */
+        ATA_MAX_DEVICES         = 2,    /* per bus/port */
+        ATA_MAX_PRD             = 256,  /* we could make these 256/256 */
+        ATA_SECT_SIZE           = 512,
+
+        ATA_ID_WORDS            = 256,
+        ATA_ID_PROD_OFS         = 27,
+        ATA_ID_FW_REV_OFS       = 23,
+        ATA_ID_SERNO_OFS        = 10,
+        ATA_ID_MAJOR_VER        = 80,
+        ATA_ID_PIO_MODES        = 64,
+        ATA_ID_MWDMA_MODES      = 63,
+        ATA_ID_UDMA_MODES       = 88,
+        ATA_ID_PIO4             = (1 << 1),
+
+        ATA_PCI_CTL_OFS         = 2,
+        ATA_SERNO_LEN           = 20,
+        ATA_UDMA0               = (1 << 0),
+        ATA_UDMA1               = ATA_UDMA0 | (1 << 1),
+        ATA_UDMA2               = ATA_UDMA1 | (1 << 2),
+        ATA_UDMA3               = ATA_UDMA2 | (1 << 3),
+        ATA_UDMA4               = ATA_UDMA3 | (1 << 4),
+        ATA_UDMA5               = ATA_UDMA4 | (1 << 5),
+        ATA_UDMA6               = ATA_UDMA5 | (1 << 6),
+        ATA_UDMA7               = ATA_UDMA6 | (1 << 7),
+        /* ATA_UDMA7 is just for completeness... doesn't exist (yet?).  */
+
+        ATA_UDMA_MASK_40C       = ATA_UDMA2,    /* udma0-2 */
+
+        /* DMA-related */
+        ATA_PRD_SZ              = 8,
+        ATA_PRD_TBL_SZ          = (ATA_MAX_PRD * ATA_PRD_SZ),
+        ATA_PRD_EOT             = (1 << 31),    /* end-of-table flag */
+
+        ATA_DMA_TABLE_OFS       = 4,
+        ATA_DMA_STATUS          = 2,
+        ATA_DMA_CMD             = 0,
+        ATA_DMA_WR              = (1 << 3),
+        ATA_DMA_START           = (1 << 0),
+        ATA_DMA_INTR            = (1 << 2),
+        ATA_DMA_ERR             = (1 << 1),
+        ATA_DMA_ACTIVE          = (1 << 0),
+
+        /* bits in ATA command block registers */
+        ATA_HOB                 = (1 << 7),     /* LBA48 selector */
+        ATA_NIEN                = (1 << 1),     /* disable-irq flag */
+        ATA_LBA                 = (1 << 6),     /* LBA28 selector */
+        ATA_DEV1                = (1 << 4),     /* Select Device 1 (slave) */
+        ATA_DEVICE_OBS          = (1 << 7) | (1 << 5), /* obs bits in dev reg */
+        ATA_DEVCTL_OBS          = (1 << 3),     /* obsolete bit in devctl reg */
+        ATA_BUSY                = (1 << 7),     /* BSY status bit */
+        ATA_DRDY                = (1 << 6),     /* device ready */
+        ATA_DF                  = (1 << 5),     /* device fault */
+        ATA_DRQ                 = (1 << 3),     /* data request i/o */
+        ATA_ERR                 = (1 << 0),     /* have an error */
+        ATA_SRST                = (1 << 2),     /* software reset */
+        ATA_ABORTED             = (1 << 2),     /* command aborted */
+
+        /* ATA command block registers */
+        ATA_REG_DATA            = 0x00,
+        ATA_REG_ERR             = 0x01,
+        ATA_REG_NSECT           = 0x02,
+        ATA_REG_LBAL            = 0x03,
+        ATA_REG_LBAM            = 0x04,
+        ATA_REG_LBAH            = 0x05,
+        ATA_REG_DEVICE          = 0x06,
+        ATA_REG_STATUS          = 0x07,
+
+        ATA_REG_FEATURE         = ATA_REG_ERR, /* and their aliases */
+        ATA_REG_CMD             = ATA_REG_STATUS,
+        ATA_REG_BYTEL           = ATA_REG_LBAM,
+        ATA_REG_BYTEH           = ATA_REG_LBAH,
+        ATA_REG_DEVSEL          = ATA_REG_DEVICE,
+        ATA_REG_IRQ             = ATA_REG_NSECT,
+
+        /* ATA device commands */
+        ATA_CMD_CHK_POWER       = 0xE5, /* check power mode */
+        ATA_CMD_EDD             = 0x90, /* execute device diagnostic */
+        ATA_CMD_FLUSH           = 0xE7,
+        ATA_CMD_FLUSH_EXT       = 0xEA,
+        ATA_CMD_ID_ATA          = 0xEC,
+        ATA_CMD_ID_ATAPI        = 0xA1,
+        ATA_CMD_READ            = 0xC8,
+        ATA_CMD_READ_EXT        = 0x25,
+        ATA_CMD_WRITE           = 0xCA,
+        ATA_CMD_WRITE_EXT       = 0x35,
+        ATA_CMD_PIO_READ        = 0x20,
+        ATA_CMD_PIO_READ_EXT    = 0x24,
+        ATA_CMD_PIO_WRITE       = 0x30,
+        ATA_CMD_PIO_WRITE_EXT   = 0x34,
+        ATA_CMD_SET_FEATURES    = 0xEF,
+        ATA_CMD_PACKET          = 0xA0,
+        ATA_CMD_VERIFY          = 0x40,
+        ATA_CMD_VERIFY_EXT      = 0x42,
+
+        /* SETFEATURES stuff */
+        SETFEATURES_XFER        = 0x03,
+        XFER_UDMA_7             = 0x47,
+        XFER_UDMA_6             = 0x46,
+        XFER_UDMA_5             = 0x45,
+        XFER_UDMA_4             = 0x44,
+        XFER_UDMA_3             = 0x43,
+        XFER_UDMA_2             = 0x42,
+        XFER_UDMA_1             = 0x41,
+        XFER_UDMA_0             = 0x40,
+        XFER_MW_DMA_2           = 0x22,
+        XFER_MW_DMA_1           = 0x21,
+        XFER_MW_DMA_0           = 0x20,
+        XFER_PIO_4              = 0x0C,
+        XFER_PIO_3              = 0x0B,
+        XFER_PIO_2              = 0x0A,
+        XFER_PIO_1              = 0x09,
+        XFER_PIO_0              = 0x08,
+        XFER_SW_DMA_2           = 0x12,
+        XFER_SW_DMA_1           = 0x11,
+        XFER_SW_DMA_0           = 0x10,
+        XFER_PIO_SLOW           = 0x00,
+
+        /* ATAPI stuff */
+        ATAPI_PKT_DMA           = (1 << 0),
+        ATAPI_DMADIR            = (1 << 2),     /* ATAPI data dir:
+                                                   0=to device, 1=to host */
+        ATAPI_CDB_LEN           = 16,
+
+        /* cable types */
+        ATA_CBL_NONE            = 0,
+        ATA_CBL_PATA40          = 1,
+        ATA_CBL_PATA80          = 2,
+        ATA_CBL_PATA_UNK        = 3,
+        ATA_CBL_SATA            = 4,
+
+        /* SATA Status and Control Registers */
+        SCR_STATUS              = 0,
+        SCR_ERROR               = 1,
+        SCR_CONTROL             = 2,
+        SCR_ACTIVE              = 3,
+        SCR_NOTIFICATION        = 4,
+
+        /* struct ata_taskfile flags */
+        ATA_TFLAG_LBA48         = (1 << 0), /* enable 48-bit LBA and "HOB" */
+        ATA_TFLAG_ISADDR        = (1 << 1), /* enable r/w to nsect/lba regs */
+        ATA_TFLAG_DEVICE        = (1 << 2), /* enable r/w to device reg */
+        ATA_TFLAG_WRITE         = (1 << 3), /* data dir: host->dev==1 (write) */
+};
+
+enum ata_tf_protocols {
+        /* ATA taskfile protocols */
+        ATA_PROT_UNKNOWN,       /* unknown/invalid */
+        ATA_PROT_NODATA,        /* no data */
+        ATA_PROT_PIO,           /* PIO single sector */
+        ATA_PROT_PIO_MULT,      /* PIO multiple sector */
+        ATA_PROT_DMA,           /* DMA */
+        ATA_PROT_ATAPI,         /* packet command, PIO data xfer*/
+        ATA_PROT_ATAPI_NODATA,  /* packet command, no data */
+        ATA_PROT_ATAPI_DMA,     /* packet command with special DMA sauce */
+};
+
+enum ata_ioctls {
+        ATA_IOC_GET_IO32        = 0x309,
+        ATA_IOC_SET_IO32        = 0x324,
+};
+
+/* core structures */
+
+struct ata_prd {
+        u32                     addr;
+        u32                     flags_len;
+};
+
+struct ata_taskfile {
+        unsigned long           flags;          /* ATA_TFLAG_xxx */
+        u8                      protocol;       /* ATA_PROT_xxx */
+
+        u8                      ctl;            /* control reg */
+
+        u8                      hob_feature;    /* additional data */
+        u8                      hob_nsect;      /* to support LBA48 */
+        u8                      hob_lbal;
+        u8                      hob_lbam;
+        u8                      hob_lbah;
+
+        u8                      feature;
+        u8                      nsect;
+        u8                      lbal;
+        u8                      lbam;
+        u8                      lbah;
+
+        u8                      device;
+
+        u8                      command;        /* IO operation */
+};
+
+#define ata_id_is_ata(id)       (((id)[0] & (1 << 15)) == 0)
+#define ata_id_rahead_enabled(id) ((id)[85] & (1 << 6))
+#define ata_id_wcache_enabled(id) ((id)[85] & (1 << 5))
+#define ata_id_has_flush(id) ((id)[83] & (1 << 12))
+#define ata_id_has_flush_ext(id) ((id)[83] & (1 << 13))
+#define ata_id_has_lba48(id)    ((id)[83] & (1 << 10))
+#define ata_id_has_wcache(id)   ((id)[82] & (1 << 5))
+#define ata_id_has_pm(id)       ((id)[82] & (1 << 3))
+#define ata_id_has_lba(id)      ((id)[49] & (1 << 9))
+#define ata_id_has_dma(id)      ((id)[49] & (1 << 8))
+#define ata_id_removeable(id)   ((id)[0] & (1 << 7))
+#define ata_id_u32(id,n)        \
+        (((u32) (id)[(n) + 1] << 16) | ((u32) (id)[(n)]))
+#define ata_id_u64(id,n)        \
+        ( ((u64) (id)[(n) + 3] << 48) | \
+          ((u64) (id)[(n) + 2] << 32) | \
+          ((u64) (id)[(n) + 1] << 16) | \
+          ((u64) (id)[(n) + 0]) )
+
+static inline int atapi_cdb_len(u16 *dev_id)
+{
+        u16 tmp = dev_id[0] & 0x3;
+        switch (tmp) {
+        case 0:         return 12;
+        case 1:         return 16;
+        default:        return -1;
+        }
+}
+
+static inline int is_atapi_taskfile(struct ata_taskfile *tf)
+{
+        return (tf->protocol == ATA_PROT_ATAPI) ||
+               (tf->protocol == ATA_PROT_ATAPI_NODATA) ||
+               (tf->protocol == ATA_PROT_ATAPI_DMA);
+}
+
+static inline int ata_ok(u8 status)
+{
+        return ((status & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | ATA_ERR))
+                        == ATA_DRDY);
+}
+
+#endif /* __LINUX_ATA_H__ */
diff --git a/include/linux/atalk.h b/include/linux/atalk.h
new file mode 100644
index 000000000000..55fcfc11fdc7
--- /dev/null
+++ b/include/linux/atalk.h
@@ -0,0 +1,245 @@
+#ifndef __LINUX_ATALK_H__
+#define __LINUX_ATALK_H__
+
+#include <net/sock.h>
+
+/*
+ * AppleTalk networking structures
+ *
+ * The following are directly referenced from the University Of Michigan
+ * netatalk for compatibility reasons.
+ */
+#define ATPORT_FIRST    1
+#define ATPORT_RESERVED 128
+#define ATPORT_LAST     254             /* 254 is only legal on localtalk */ 
+#define ATADDR_ANYNET   (__u16)0
+#define ATADDR_ANYNODE  (__u8)0
+#define ATADDR_ANYPORT  (__u8)0
+#define ATADDR_BCAST    (__u8)255
+#define DDP_MAXSZ       587
+#define DDP_MAXHOPS     15              /* 4 bits of hop counter */
+
+#define SIOCATALKDIFADDR       (SIOCPROTOPRIVATE + 0)
+
+struct atalk_addr {
+        __u16   s_net;
+        __u8    s_node;
+};
+
+struct sockaddr_at {
+        sa_family_t       sat_family;
+        __u8              sat_port;
+        struct atalk_addr sat_addr;
+        char              sat_zero[8];
+};
+
+struct atalk_netrange {
+        __u8    nr_phase;
+        __u16   nr_firstnet;
+        __u16   nr_lastnet;
+};
+
+struct atalk_route {
+        struct net_device  *dev;
+        struct atalk_addr  target;
+        struct atalk_addr  gateway;
+        int                flags;
+        struct atalk_route *next;
+};
+
+/**
+ *      struct atalk_iface - AppleTalk Interface
+ *      @dev - Network device associated with this interface
+ *      @address - Our address
+ *      @status - What are we doing?
+ *      @nets - Associated direct netrange
+ *      @next - next element in the list of interfaces
+ */
+struct atalk_iface {
+        struct net_device       *dev;
+        struct atalk_addr       address;
+        int                     status;
+#define ATIF_PROBE      1               /* Probing for an address */
+#define ATIF_PROBE_FAIL 2               /* Probe collided */
+        struct atalk_netrange   nets;
+        struct atalk_iface      *next;
+};
+        
+struct atalk_sock {
+        /* struct sock has to be the first member of atalk_sock */
+        struct sock     sk;
+        unsigned short  dest_net;
+        unsigned short  src_net;
+        unsigned char   dest_node;
+        unsigned char   src_node;
+        unsigned char   dest_port;
+        unsigned char   src_port;
+};
+
+static inline struct atalk_sock *at_sk(struct sock *sk)
+{
+        return (struct atalk_sock *)sk;
+}
+
+#ifdef __KERNEL__
+
+#include <asm/byteorder.h>
+
+struct ddpehdr {
+#ifdef __LITTLE_ENDIAN_BITFIELD
+        __u16   deh_len:10,
+                deh_hops:4,
+                deh_pad:2;
+#else
+        __u16   deh_pad:2,
+                deh_hops:4,
+                deh_len:10;
+#endif
+        __u16   deh_sum;
+        __u16   deh_dnet;
+        __u16   deh_snet;
+        __u8    deh_dnode;
+        __u8    deh_snode;
+        __u8    deh_dport;
+        __u8    deh_sport;
+        /* And netatalk apps expect to stick the type in themselves */
+};
+
+static __inline__ struct ddpehdr *ddp_hdr(struct sk_buff *skb)
+{
+        return (struct ddpehdr *)skb->h.raw;
+}
+
+/*
+ *      Don't drop the struct into the struct above.  You'll get some
+ *      surprise padding.
+ */
+struct ddpebits {
+#ifdef __LITTLE_ENDIAN_BITFIELD
+        __u16   deh_len:10,
+                deh_hops:4,
+                deh_pad:2;
+#else
+        __u16   deh_pad:2,
+                deh_hops:4,
+                deh_len:10;
+#endif
+};
+
+/* Short form header */
+struct ddpshdr {
+#ifdef __LITTLE_ENDIAN_BITFIELD
+        __u16   dsh_len:10,
+                dsh_pad:6;
+#else
+        __u16   dsh_pad:6,
+                dsh_len:10;
+#endif
+        __u8    dsh_dport;
+        __u8    dsh_sport;
+        /* And netatalk apps expect to stick the type in themselves */
+};
+
+/* AppleTalk AARP headers */
+struct elapaarp {
+        __u16   hw_type;
+#define AARP_HW_TYPE_ETHERNET           1
+#define AARP_HW_TYPE_TOKENRING          2
+        __u16   pa_type;
+        __u8    hw_len;
+        __u8    pa_len;
+#define AARP_PA_ALEN                    4
+        __u16   function;
+#define AARP_REQUEST                    1
+#define AARP_REPLY                      2
+#define AARP_PROBE                      3
+        __u8    hw_src[ETH_ALEN]        __attribute__ ((packed));
+        __u8    pa_src_zero             __attribute__ ((packed));
+        __u16   pa_src_net              __attribute__ ((packed));
+        __u8    pa_src_node             __attribute__ ((packed));
+        __u8    hw_dst[ETH_ALEN]        __attribute__ ((packed));
+        __u8    pa_dst_zero             __attribute__ ((packed));
+        __u16   pa_dst_net              __attribute__ ((packed));
+        __u8    pa_dst_node             __attribute__ ((packed));       
+};
+
+static __inline__ struct elapaarp *aarp_hdr(struct sk_buff *skb)
+{
+        return (struct elapaarp *)skb->h.raw;
+}
+
+/* Not specified - how long till we drop a resolved entry */
+#define AARP_EXPIRY_TIME        (5 * 60 * HZ)
+/* Size of hash table */
+#define AARP_HASH_SIZE          16
+/* Fast retransmission timer when resolving */
+#define AARP_TICK_TIME          (HZ / 5)
+/* Send 10 requests then give up (2 seconds) */
+#define AARP_RETRANSMIT_LIMIT   10
+/*
+ * Some value bigger than total retransmit time + a bit for last reply to
+ * appear and to stop continual requests
+ */
+#define AARP_RESOLVE_TIME       (10 * HZ)
+
+extern struct datalink_proto *ddp_dl, *aarp_dl;
+extern void aarp_proto_init(void);
+
+/* Inter module exports */
+
+/* Give a device find its atif control structure */
+static inline struct atalk_iface *atalk_find_dev(struct net_device *dev)
+{
+        return dev->atalk_ptr;
+}
+
+extern struct atalk_addr *atalk_find_dev_addr(struct net_device *dev);
+extern struct net_device *atrtr_get_dev(struct atalk_addr *sa);
+extern int               aarp_send_ddp(struct net_device *dev,
+                                       struct sk_buff *skb,
+                                       struct atalk_addr *sa, void *hwaddr);
+extern void              aarp_device_down(struct net_device *dev);
+extern void              aarp_probe_network(struct atalk_iface *atif);
+extern int               aarp_proxy_probe_network(struct atalk_iface *atif,
+                                     struct atalk_addr *sa);
+extern void              aarp_proxy_remove(struct net_device *dev,
+                                           struct atalk_addr *sa);
+
+extern void             aarp_cleanup_module(void);
+
+extern struct hlist_head atalk_sockets;
+extern rwlock_t atalk_sockets_lock;
+
+extern struct atalk_route *atalk_routes;
+extern rwlock_t atalk_routes_lock;
+
+extern struct atalk_iface *atalk_interfaces;
+extern rwlock_t atalk_interfaces_lock;
+
+extern struct atalk_route atrtr_default;
+
+extern struct file_operations atalk_seq_arp_fops;
+
+extern int sysctl_aarp_expiry_time;
+extern int sysctl_aarp_tick_time;
+extern int sysctl_aarp_retransmit_limit;
+extern int sysctl_aarp_resolve_time;
+
+#ifdef CONFIG_SYSCTL
+extern void atalk_register_sysctl(void);
+extern void atalk_unregister_sysctl(void);
+#else
+#define atalk_register_sysctl()         do { } while(0)
+#define atalk_unregister_sysctl()       do { } while(0)
+#endif
+
+#ifdef CONFIG_PROC_FS
+extern int atalk_proc_init(void);
+extern void atalk_proc_exit(void);
+#else
+#define atalk_proc_init()       ({ 0; })
+#define atalk_proc_exit()       do { } while(0)
+#endif /* CONFIG_PROC_FS */
+
+#endif /* __KERNEL__ */
+#endif /* __LINUX_ATALK_H__ */
diff --git a/include/linux/atm.h b/include/linux/atm.h
new file mode 100644
index 000000000000..60136684e0af
--- /dev/null
+++ b/include/linux/atm.h
@@ -0,0 +1,243 @@
+/* atm.h - general ATM declarations */
+ 
+/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+/*
+ * WARNING: User-space programs should not #include <linux/atm.h> directly.
+ *          Instead, #include <atm.h>
+ */
+
+#ifndef _LINUX_ATM_H
+#define _LINUX_ATM_H
+
+/*
+ * BEGIN_xx and END_xx markers are used for automatic generation of
+ * documentation. Do not change them.
+ */
+
+#ifdef __KERNEL__
+#include <linux/socket.h>
+#include <linux/types.h>
+#endif
+#include <linux/compiler.h>
+#include <linux/atmapi.h>
+#include <linux/atmsap.h>
+#include <linux/atmioc.h>
+
+
+/* general ATM constants */
+#define ATM_CELL_SIZE               53  /* ATM cell size incl. header */
+#define ATM_CELL_PAYLOAD            48  /* ATM payload size */
+#define ATM_AAL0_SDU                52  /* AAL0 SDU size */
+#define ATM_MAX_AAL34_PDU        65535  /* maximum AAL3/4 PDU payload */
+#define ATM_AAL5_TRAILER             8  /* AAL5 trailer size */
+#define ATM_MAX_AAL5_PDU         65535  /* maximum AAL5 PDU payload */
+#define ATM_MAX_CDV               9999  /* maximum (default) CDV */
+#define ATM_NOT_RSV_VCI             32  /* first non-reserved VCI value */
+
+#define ATM_MAX_VPI                255  /* maximum VPI at the UNI */
+#define ATM_MAX_VPI_NNI           4096  /* maximum VPI at the NNI */
+#define ATM_MAX_VCI              65535  /* maximum VCI */
+
+
+/* "protcol" values for the socket system call */
+#define ATM_NO_AAL      0               /* AAL not specified */
+#define ATM_AAL0        13              /* "raw" ATM cells */
+#define ATM_AAL1        1               /* AAL1 (CBR) */
+#define ATM_AAL2        2               /* AAL2 (VBR) */
+#define ATM_AAL34       3               /* AAL3/4 (data) */
+#define ATM_AAL5        5               /* AAL5 (data) */
+
+/*
+ * socket option name coding functions
+ *
+ * Note that __SO_ENCODE and __SO_LEVEL are somewhat a hack since the
+ * << 22 only reserves 9 bits for the level.  On some architectures
+ * SOL_SOCKET is 0xFFFF, so that's a bit of a problem
+ */
+
+#define __SO_ENCODE(l,n,t)      ((((l) & 0x1FF) << 22) | ((n) << 16) | \
+                                sizeof(t))
+#define __SO_LEVEL_MATCH(c,m)   (((c) >> 22) == ((m) & 0x1FF))
+#define __SO_NUMBER(c)          (((c) >> 16) & 0x3f)
+#define __SO_SIZE(c)            ((c) & 0x3fff)
+
+/*
+ * ATM layer
+ */
+
+#define SO_SETCLP       __SO_ENCODE(SOL_ATM,0,int)
+                            /* set CLP bit value - TODO */
+#define SO_CIRANGE      __SO_ENCODE(SOL_ATM,1,struct atm_cirange)
+                            /* connection identifier range; socket must be
+                               bound or connected */
+#define SO_ATMQOS       __SO_ENCODE(SOL_ATM,2,struct atm_qos)
+                            /* Quality of Service setting */
+#define SO_ATMSAP       __SO_ENCODE(SOL_ATM,3,struct atm_sap)
+                            /* Service Access Point */
+#define SO_ATMPVC       __SO_ENCODE(SOL_ATM,4,struct sockaddr_atmpvc)
+                            /* "PVC" address (also for SVCs); get only */
+#define SO_MULTIPOINT   __SO_ENCODE(SOL_ATM, 5, int)
+                            /* make this vc a p2mp */
+
+
+/*
+ * Note @@@: since the socket layers don't really distinguish the control and
+ * the data plane but generally seems to be data plane-centric, any layer is
+ * about equally wrong for the SAP. If you have a better idea about this,
+ * please speak up ...
+ */
+
+
+/* ATM cell header (for AAL0) */
+
+/* BEGIN_CH */
+#define ATM_HDR_GFC_MASK        0xf0000000
+#define ATM_HDR_GFC_SHIFT       28
+#define ATM_HDR_VPI_MASK        0x0ff00000
+#define ATM_HDR_VPI_SHIFT       20
+#define ATM_HDR_VCI_MASK        0x000ffff0
+#define ATM_HDR_VCI_SHIFT       4
+#define ATM_HDR_PTI_MASK        0x0000000e
+#define ATM_HDR_PTI_SHIFT       1
+#define ATM_HDR_CLP             0x00000001
+/* END_CH */
+
+
+/* PTI codings */
+
+/* BEGIN_PTI */
+#define ATM_PTI_US0     0  /* user data cell, congestion not exp, SDU-type 0 */
+#define ATM_PTI_US1     1  /* user data cell, congestion not exp, SDU-type 1 */
+#define ATM_PTI_UCES0   2  /* user data cell, cong. experienced, SDU-type 0 */
+#define ATM_PTI_UCES1   3  /* user data cell, cong. experienced, SDU-type 1 */
+#define ATM_PTI_SEGF5   4  /* segment OAM F5 flow related cell */
+#define ATM_PTI_E2EF5   5  /* end-to-end OAM F5 flow related cell */
+#define ATM_PTI_RSV_RM  6  /* reserved for traffic control/resource mgmt */
+#define ATM_PTI_RSV     7  /* reserved */
+/* END_PTI */
+
+
+/*
+ * The following items should stay in linux/atm.h, which should be linked to
+ * netatm/atm.h
+ */
+
+/* Traffic description */
+
+#define ATM_NONE        0               /* no traffic */
+#define ATM_UBR         1
+#define ATM_CBR         2
+#define ATM_VBR         3
+#define ATM_ABR         4
+#define ATM_ANYCLASS    5               /* compatible with everything */
+
+#define ATM_MAX_PCR     -1              /* maximum available PCR */
+
+struct atm_trafprm {
+        unsigned char   traffic_class;  /* traffic class (ATM_UBR, ...) */
+        int             max_pcr;        /* maximum PCR in cells per second */
+        int             pcr;            /* desired PCR in cells per second */
+        int             min_pcr;        /* minimum PCR in cells per second */
+        int             max_cdv;        /* maximum CDV in microseconds */
+        int             max_sdu;        /* maximum SDU in bytes */
+        /* extra params for ABR */
+        unsigned int    icr;            /* Initial Cell Rate (24-bit) */
+        unsigned int    tbe;            /* Transient Buffer Exposure (24-bit) */ 
+        unsigned int    frtt : 24;      /* Fixed Round Trip Time (24-bit) */
+        unsigned int    rif  : 4;       /* Rate Increment Factor (4-bit) */
+        unsigned int    rdf  : 4;       /* Rate Decrease Factor (4-bit) */
+        unsigned int nrm_pres  :1;      /* nrm present bit */
+        unsigned int trm_pres  :1;      /* rm present bit */
+        unsigned int adtf_pres :1;      /* adtf present bit */
+        unsigned int cdf_pres  :1;      /* cdf present bit*/
+        unsigned int nrm       :3;      /* Max # of Cells for each forward RM cell (3-bit) */
+        unsigned int trm       :3;      /* Time between forward RM cells (3-bit) */    
+        unsigned int adtf      :10;     /* ACR Decrease Time Factor (10-bit) */
+        unsigned int cdf       :3;      /* Cutoff Decrease Factor (3-bit) */
+        unsigned int spare     :9;      /* spare bits */ 
+};
+
+struct atm_qos {
+        struct atm_trafprm txtp;        /* parameters in TX direction */
+        struct atm_trafprm rxtp __ATM_API_ALIGN;
+                                        /* parameters in RX direction */
+        unsigned char aal __ATM_API_ALIGN;
+};
+
+/* PVC addressing */
+
+#define ATM_ITF_ANY     -1              /* "magic" PVC address values */
+#define ATM_VPI_ANY     -1
+#define ATM_VCI_ANY     -1
+#define ATM_VPI_UNSPEC  -2
+#define ATM_VCI_UNSPEC  -2
+
+
+struct sockaddr_atmpvc {
+        unsigned short  sap_family;     /* address family, AF_ATMPVC  */
+        struct {                        /* PVC address */
+                short   itf;            /* ATM interface */
+                short   vpi;            /* VPI (only 8 bits at UNI) */
+                int     vci;            /* VCI (only 16 bits at UNI) */
+        } sap_addr __ATM_API_ALIGN;     /* PVC address */
+};
+
+/* SVC addressing */
+
+#define ATM_ESA_LEN     20              /* ATM End System Address length */
+#define ATM_E164_LEN    12              /* maximum E.164 number length */
+
+#define ATM_AFI_DCC     0x39            /* DCC ATM Format */
+#define ATM_AFI_ICD     0x47            /* ICD ATM Format */
+#define ATM_AFI_E164    0x45            /* E.164 ATM Format */
+#define ATM_AFI_LOCAL   0x49            /* Local ATM Format */ 
+
+#define ATM_AFI_DCC_GROUP       0xBD    /* DCC ATM Group Format */
+#define ATM_AFI_ICD_GROUP       0xC5    /* ICD ATM Group Format */
+#define ATM_AFI_E164_GROUP      0xC3    /* E.164 ATM Group Format */
+#define ATM_AFI_LOCAL_GROUP     0xC7    /* Local ATM Group Format */
+
+#define ATM_LIJ_NONE    0               /* no leaf-initiated join */
+#define ATM_LIJ         1               /* request joining */
+#define ATM_LIJ_RPJ     2               /* set to root-prompted join */
+#define ATM_LIJ_NJ      3               /* set to network join */
+
+
+struct sockaddr_atmsvc {
+    unsigned short      sas_family;     /* address family, AF_ATMSVC */
+    struct {                            /* SVC address */
+        unsigned char   prv[ATM_ESA_LEN];/* private ATM address */
+        char            pub[ATM_E164_LEN+1]; /* public address (E.164) */
+                                        /* unused addresses must be bzero'ed */
+        char            lij_type;       /* role in LIJ call; one of ATM_LIJ* */
+        uint32_t        lij_id;         /* LIJ call identifier */
+    } sas_addr __ATM_API_ALIGN;         /* SVC address */
+};
+
+
+static __inline__ int atmsvc_addr_in_use(struct sockaddr_atmsvc addr)
+{
+        return *addr.sas_addr.prv || *addr.sas_addr.pub;
+}
+
+
+static __inline__ int atmpvc_addr_in_use(struct sockaddr_atmpvc addr)
+{
+        return addr.sap_addr.itf || addr.sap_addr.vpi || addr.sap_addr.vci;
+}
+
+
+/*
+ * Some stuff for linux/sockios.h
+ */
+
+struct atmif_sioc {
+    int number;
+    int length;
+    void __user *arg;
+};
+
+typedef unsigned short atm_backend_t;
+#endif
diff --git a/include/linux/atm_eni.h b/include/linux/atm_eni.h
new file mode 100644
index 000000000000..34f317972551
--- /dev/null
+++ b/include/linux/atm_eni.h
@@ -0,0 +1,23 @@
+/* atm_eni.h - Driver-specific declarations of the ENI driver (for use by
+               driver-specific utilities) */
+
+/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
+
+
+#ifndef LINUX_ATM_ENI_H
+#define LINUX_ATM_ENI_H
+
+#include <linux/atmioc.h>
+
+
+struct eni_multipliers {
+        int tx,rx;      /* values are in percent and must be > 100 */
+};
+
+
+#define ENI_MEMDUMP     _IOW('a',ATMIOC_SARPRV,struct atmif_sioc)
+                                                /* printk memory map */
+#define ENI_SETMULT     _IOW('a',ATMIOC_SARPRV+7,struct atmif_sioc)
+                                                /* set buffer multipliers */
+
+#endif
diff --git a/include/linux/atm_he.h b/include/linux/atm_he.h
new file mode 100644
index 000000000000..2a7713b597cf
--- /dev/null
+++ b/include/linux/atm_he.h
@@ -0,0 +1,20 @@
+/* atm_he.h */
+
+#ifndef LINUX_ATM_HE_H
+#define LINUX_ATM_HE_H
+
+#include <linux/atmioc.h>
+
+#define HE_GET_REG      _IOW('a', ATMIOC_SARPRV, struct atmif_sioc)
+
+#define HE_REGTYPE_PCI  1
+#define HE_REGTYPE_RCM  2
+#define HE_REGTYPE_TCM  3
+#define HE_REGTYPE_MBOX 4
+
+struct he_ioctl_reg {
+        unsigned addr, val;
+        char type;
+};
+
+#endif /* LINUX_ATM_HE_H */
diff --git a/include/linux/atm_idt77105.h b/include/linux/atm_idt77105.h
new file mode 100644
index 000000000000..05621cf20709
--- /dev/null
+++ b/include/linux/atm_idt77105.h
@@ -0,0 +1,28 @@
+/* atm_idt77105.h - Driver-specific declarations of the IDT77105 driver (for
+ * use by driver-specific utilities) */
+
+/* Written 1999 by Greg Banks <gnb@linuxfan.com>. Copied from atm_suni.h. */
+
+
+#ifndef LINUX_ATM_IDT77105_H
+#define LINUX_ATM_IDT77105_H
+
+#include <asm/types.h>
+#include <linux/atmioc.h>
+#include <linux/atmdev.h>
+
+/*
+ * Structure for IDT77105_GETSTAT and IDT77105_GETSTATZ ioctls.
+ * Pointed to by `arg' in atmif_sioc.
+ */
+struct idt77105_stats {
+        __u32 symbol_errors;  /* wire symbol errors */
+        __u32 tx_cells;       /* cells transmitted */
+        __u32 rx_cells;       /* cells received */
+        __u32 rx_hec_errors;  /* Header Error Check errors on receive */
+};
+
+#define IDT77105_GETSTAT        _IOW('a',ATMIOC_PHYPRV+2,struct atmif_sioc)     /* get stats */
+#define IDT77105_GETSTATZ       _IOW('a',ATMIOC_PHYPRV+3,struct atmif_sioc)     /* get stats and zero */
+
+#endif
diff --git a/include/linux/atm_nicstar.h b/include/linux/atm_nicstar.h
new file mode 100644
index 000000000000..577b79f33e8d
--- /dev/null
+++ b/include/linux/atm_nicstar.h
@@ -0,0 +1,53 @@
+/******************************************************************************
+ *
+ * atm_nicstar.h
+ *
+ * Driver-specific declarations for use by NICSTAR driver specific utils.
+ *
+ * Author: Rui Prior
+ *
+ * (C) INESC 1998
+ *
+ ******************************************************************************/
+
+
+#ifndef LINUX_ATM_NICSTAR_H
+#define LINUX_ATM_NICSTAR_H
+
+/* Note: non-kernel programs including this file must also include
+ * sys/types.h for struct timeval
+ */
+
+#include <linux/atmapi.h>
+#include <linux/atmioc.h>
+
+#define NS_GETPSTAT     _IOWR('a',ATMIOC_SARPRV+1,struct atmif_sioc)
+                                                /* get pool statistics */
+#define NS_SETBUFLEV    _IOW('a',ATMIOC_SARPRV+2,struct atmif_sioc)
+                                                /* set buffer level markers */
+#define NS_ADJBUFLEV    _IO('a',ATMIOC_SARPRV+3)
+                                                /* adjust buffer level */
+
+typedef struct buf_nr
+{
+   unsigned min;
+   unsigned init;
+   unsigned max;
+}buf_nr;
+
+
+typedef struct pool_levels
+{
+   int buftype;
+   int count;           /* (At least for now) only used in NS_GETPSTAT */
+   buf_nr level;
+} pool_levels;
+
+/* type must be one of the following: */
+#define NS_BUFTYPE_SMALL 1
+#define NS_BUFTYPE_LARGE 2
+#define NS_BUFTYPE_HUGE 3
+#define NS_BUFTYPE_IOVEC 4
+
+
+#endif /* LINUX_ATM_NICSTAR_H */
diff --git a/include/linux/atm_suni.h b/include/linux/atm_suni.h
new file mode 100644
index 000000000000..84f3aab54468
--- /dev/null
+++ b/include/linux/atm_suni.h
@@ -0,0 +1,12 @@
+/* atm_suni.h - Driver-specific declarations of the SUNI driver (for use by
+                driver-specific utilities) */
+
+/* Written 1998,2000 by Werner Almesberger, EPFL ICA */
+
+
+#ifndef LINUX_ATM_SUNI_H
+#define LINUX_ATM_SUNI_H
+
+/* everything obsoleted */
+
+#endif
diff --git a/include/linux/atm_tcp.h b/include/linux/atm_tcp.h
new file mode 100644
index 000000000000..18787f9b2f19
--- /dev/null
+++ b/include/linux/atm_tcp.h
@@ -0,0 +1,75 @@
+/* atm_tcp.h - Driver-specific declarations of the ATMTCP driver (for use by
+               driver-specific utilities) */
+
+/* Written 1997-2000 by Werner Almesberger, EPFL LRC/ICA */
+
+
+#ifndef LINUX_ATM_TCP_H
+#define LINUX_ATM_TCP_H
+
+#include <linux/atmapi.h>
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#endif
+#include <linux/atmioc.h>
+
+
+/*
+ * All values in struct atmtcp_hdr are in network byte order
+ */
+
+struct atmtcp_hdr {
+        uint16_t        vpi;
+        uint16_t        vci;
+        uint32_t        length;         /* ... of data part */
+};
+
+/*
+ * All values in struct atmtcp_command are in host byte order
+ */
+
+#define ATMTCP_HDR_MAGIC        (~0)    /* this length indicates a command */
+#define ATMTCP_CTRL_OPEN        1       /* request/reply */
+#define ATMTCP_CTRL_CLOSE       2       /* request/reply */
+
+struct atmtcp_control {
+        struct atmtcp_hdr hdr;  /* must be first */
+        int type;               /* message type; both directions */
+        atm_kptr_t vcc;         /* both directions */
+        struct sockaddr_atmpvc addr; /* suggested value from kernel */
+        struct atm_qos  qos;    /* both directions */
+        int result;             /* to kernel only */
+} __ATM_API_ALIGN;
+
+/*
+ * Field usage:
+ * Messge type  dir.    hdr.v?i type    addr    qos     vcc     result
+ * -----------  ----    ------- ----    ----    ---     ---     ------
+ * OPEN         K->D    Y       Y       Y       Y       Y       0
+ * OPEN         D->K    -       Y       Y       Y       Y       Y
+ * CLOSE        K->D    -       -       Y       -       Y       0
+ * CLOSE        D->K    -       -       -       -       Y       Y
+ */
+
+#define SIOCSIFATMTCP   _IO('a',ATMIOC_ITF)     /* set ATMTCP mode */
+#define ATMTCP_CREATE   _IO('a',ATMIOC_ITF+14)  /* create persistent ATMTCP
+                                                   interface */
+#define ATMTCP_REMOVE   _IO('a',ATMIOC_ITF+15)  /* destroy persistent ATMTCP
+                                                   interface */
+
+
+#ifdef __KERNEL__
+
+struct atm_tcp_ops {
+        int (*attach)(struct atm_vcc *vcc,int itf);
+        int (*create_persistent)(int itf);
+        int (*remove_persistent)(int itf);
+        struct module *owner;
+};
+
+extern struct atm_tcp_ops atm_tcp_ops;
+
+#endif
+
+#endif
diff --git a/include/linux/atm_zatm.h b/include/linux/atm_zatm.h
new file mode 100644
index 000000000000..10f0fa29454f
--- /dev/null
+++ b/include/linux/atm_zatm.h
@@ -0,0 +1,52 @@
+/* atm_zatm.h - Driver-specific declarations of the ZATM driver (for use by
+                driver-specific utilities) */
+
+/* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
+
+
+#ifndef LINUX_ATM_ZATM_H
+#define LINUX_ATM_ZATM_H
+
+/*
+ * Note: non-kernel programs including this file must also include
+ * sys/types.h for struct timeval
+ */
+
+#include <linux/atmapi.h>
+#include <linux/atmioc.h>
+
+#define ZATM_GETPOOL    _IOW('a',ATMIOC_SARPRV+1,struct atmif_sioc)
+                                                /* get pool statistics */
+#define ZATM_GETPOOLZ   _IOW('a',ATMIOC_SARPRV+2,struct atmif_sioc)
+                                                /* get statistics and zero */
+#define ZATM_SETPOOL    _IOW('a',ATMIOC_SARPRV+3,struct atmif_sioc)
+                                                /* set pool parameters */
+
+struct zatm_pool_info {
+        int ref_count;                  /* free buffer pool usage counters */
+        int low_water,high_water;       /* refill parameters */
+        int rqa_count,rqu_count;        /* queue condition counters */
+        int offset,next_off;            /* alignment optimizations: offset */
+        int next_cnt,next_thres;        /* repetition counter and threshold */
+};
+
+struct zatm_pool_req {
+        int pool_num;                   /* pool number */
+        struct zatm_pool_info info;     /* actual information */
+};
+
+struct zatm_t_hist {
+        struct timeval real;            /* real (wall-clock) time */
+        struct timeval expected;        /* expected real time */
+};
+
+
+#define ZATM_OAM_POOL           0       /* free buffer pool for OAM cells */
+#define ZATM_AAL0_POOL          1       /* free buffer pool for AAL0 cells */
+#define ZATM_AAL5_POOL_BASE     2       /* first AAL5 free buffer pool */
+#define ZATM_LAST_POOL  ZATM_AAL5_POOL_BASE+10 /* max. 64 kB */
+
+#define ZATM_TIMER_HISTORY_SIZE 16      /* number of timer adjustments to
+                                           record; must be 2^n */
+
+#endif
diff --git a/include/linux/atmapi.h b/include/linux/atmapi.h
new file mode 100644
index 000000000000..8fe54d90d95b
--- /dev/null
+++ b/include/linux/atmapi.h
@@ -0,0 +1,29 @@
+/* atmapi.h - ATM API user space/kernel compatibility */
+ 
+/* Written 1999,2000 by Werner Almesberger, EPFL ICA */
+ 
+
+#ifndef _LINUX_ATMAPI_H
+#define _LINUX_ATMAPI_H
+
+#if defined(__sparc__) || defined(__ia64__)
+/* such alignment is not required on 32 bit sparcs, but we can't
+   figure that we are on a sparc64 while compiling user-space programs. */
+#define __ATM_API_ALIGN __attribute__((aligned(8)))
+#else
+#define __ATM_API_ALIGN
+#endif
+
+
+/*
+ * Opaque type for kernel pointers. Note that _ is never accessed. We need
+ * the struct in order hide the array, so that we can make simple assignments
+ * instead of being forced to use memcpy. It also improves error reporting for
+ * code that still assumes that we're passing unsigned longs.
+ *
+ * Convention: NULL pointers are passed as a field of all zeroes.
+ */
+ 
+typedef struct { unsigned char _[8]; } __ATM_API_ALIGN atm_kptr_t;
+
+#endif
diff --git a/include/linux/atmarp.h b/include/linux/atmarp.h
new file mode 100644
index 000000000000..24f82338f59a
--- /dev/null
+++ b/include/linux/atmarp.h
@@ -0,0 +1,43 @@
+/* atmarp.h - ATM ARP protocol and kernel-demon interface definitions */
+ 
+/* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+#ifndef _LINUX_ATMARP_H
+#define _LINUX_ATMARP_H
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#endif
+#include <linux/atmapi.h>
+#include <linux/atmioc.h>
+
+
+#define ATMARP_RETRY_DELAY 30           /* request next resolution or forget
+                                           NAK after 30 sec - should go into
+                                           atmclip.h */
+#define ATMARP_MAX_UNRES_PACKETS 5      /* queue that many packets while
+                                           waiting for the resolver */
+
+
+#define ATMARPD_CTRL    _IO('a',ATMIOC_CLIP+1)  /* become atmarpd ctrl sock */
+#define ATMARP_MKIP     _IO('a',ATMIOC_CLIP+2)  /* attach socket to IP */
+#define ATMARP_SETENTRY _IO('a',ATMIOC_CLIP+3)  /* fill or hide ARP entry */
+#define ATMARP_ENCAP    _IO('a',ATMIOC_CLIP+5)  /* change encapsulation */
+
+
+enum atmarp_ctrl_type {
+        act_invalid,            /* catch uninitialized structures */
+        act_need,               /* need address resolution */
+        act_up,                 /* interface is coming up */
+        act_down,               /* interface is going down */
+        act_change              /* interface configuration has changed */
+};
+
+struct atmarp_ctrl {
+        enum atmarp_ctrl_type   type;   /* message type */
+        int                     itf_num;/* interface number (if present) */
+        uint32_t                ip;     /* IP address (act_need only) */
+};
+
+#endif
diff --git a/include/linux/atmbr2684.h b/include/linux/atmbr2684.h
new file mode 100644
index 000000000000..7981b733f1ef
--- /dev/null
+++ b/include/linux/atmbr2684.h
@@ -0,0 +1,101 @@
+#ifndef _LINUX_ATMBR2684_H
+#define _LINUX_ATMBR2684_H
+
+#include <linux/atm.h>
+#include <linux/if.h>           /* For IFNAMSIZ */
+
+/*
+ * Type of media we're bridging (ethernet, token ring, etc)  Currently only
+ * ethernet is supported
+ */
+#define BR2684_MEDIA_ETHERNET   (0)     /* 802.3 */
+#define BR2684_MEDIA_802_4      (1)     /* 802.4 */
+#define BR2684_MEDIA_TR         (2)     /* 802.5 - token ring */
+#define BR2684_MEDIA_FDDI       (3)
+#define BR2684_MEDIA_802_6      (4)     /* 802.6 */
+
+/*
+ * Is there FCS inbound on this VC?  This currently isn't supported.
+ */
+#define BR2684_FCSIN_NO         (0)
+#define BR2684_FCSIN_IGNORE     (1)
+#define BR2684_FCSIN_VERIFY     (2)
+
+/*
+ * Is there FCS outbound on this VC?  This currently isn't supported.
+ */
+#define BR2684_FCSOUT_NO        (0)
+#define BR2684_FCSOUT_SENDZERO  (1)
+#define BR2684_FCSOUT_GENERATE  (2)
+
+/*
+ * Does this VC include LLC encapsulation?
+ */
+#define BR2684_ENCAPS_VC        (0)     /* VC-mux */
+#define BR2684_ENCAPS_LLC       (1)
+#define BR2684_ENCAPS_AUTODETECT (2)    /* Unsuported */
+
+/*
+ * This is for the ATM_NEWBACKENDIF call - these are like socket families:
+ * the first element of the structure is the backend number and the rest
+ * is per-backend specific
+ */
+struct atm_newif_br2684 {
+        atm_backend_t   backend_num;    /* ATM_BACKEND_BR2684 */
+        int             media;          /* BR2684_MEDIA_* */
+        char            ifname[IFNAMSIZ];
+        int             mtu;
+};
+
+/*
+ * This structure is used to specify a br2684 interface - either by a
+ * positive integer (returned by ATM_NEWBACKENDIF) or the interfaces name
+ */
+#define BR2684_FIND_BYNOTHING   (0)
+#define BR2684_FIND_BYNUM       (1)
+#define BR2684_FIND_BYIFNAME    (2)
+struct br2684_if_spec {
+        int method;                     /* BR2684_FIND_* */
+        union {
+                char            ifname[IFNAMSIZ];
+                int             devnum;
+        } spec;
+};
+
+/*
+ * This is for the ATM_SETBACKEND call - these are like socket families:
+ * the first element of the structure is the backend number and the rest
+ * is per-backend specific
+ */
+struct atm_backend_br2684 {
+        atm_backend_t   backend_num;    /* ATM_BACKEND_BR2684 */
+        struct br2684_if_spec ifspec;
+        int     fcs_in;         /* BR2684_FCSIN_* */
+        int     fcs_out;        /* BR2684_FCSOUT_* */
+        int     fcs_auto;       /* 1: fcs_{in,out} disabled if no FCS rx'ed */
+        int     encaps;         /* BR2684_ENCAPS_* */
+        int     has_vpiid;      /* 1: use vpn_id - Unsupported */
+        __u8    vpn_id[7];
+        int     send_padding;   /* unsupported */
+        int     min_size;       /* we will pad smaller packets than this */
+};
+
+/*
+ * The BR2684_SETFILT ioctl is an experimental mechanism for folks
+ * terminating a large number of IP-only vcc's.  When netfilter allows
+ * efficient per-if in/out filters, this support will be removed
+ */
+struct br2684_filter {
+        __u32   prefix;         /* network byte order */
+        __u32   netmask;        /* 0 = disable filter */
+};
+
+struct br2684_filter_set {
+        struct br2684_if_spec ifspec;
+        struct br2684_filter filter;
+};
+
+#define BR2684_SETFILT  _IOW( 'a', ATMIOC_BACKEND + 0, \
+                                struct br2684_filter_set)
+
+#endif /* _LINUX_ATMBR2684_H */
diff --git a/include/linux/atmclip.h b/include/linux/atmclip.h
new file mode 100644
index 000000000000..02c94c448dd6
--- /dev/null
+++ b/include/linux/atmclip.h
@@ -0,0 +1,21 @@
+/* atmclip.h - Classical IP over ATM */
+ 
+/* Written 1995-1998 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+#ifndef LINUX_ATMCLIP_H
+#define LINUX_ATMCLIP_H
+
+#include <linux/sockios.h>
+#include <linux/atmioc.h>
+
+
+#define RFC1483LLC_LEN  8               /* LLC+OUI+PID = 8 */
+#define RFC1626_MTU     9180            /* RFC1626 default MTU */
+
+#define CLIP_DEFAULT_IDLETIMER 1200     /* 20 minutes, see RFC1755 */
+#define CLIP_CHECK_INTERVAL      10     /* check every ten seconds */
+
+#define SIOCMKCLIP      _IO('a',ATMIOC_CLIP)    /* create IP interface */
+
+#endif
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
new file mode 100644
index 000000000000..9f374cfa1b05
--- /dev/null
+++ b/include/linux/atmdev.h
@@ -0,0 +1,489 @@
+/* atmdev.h - ATM device driver declarations and various related items */
+ 
+/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+#ifndef LINUX_ATMDEV_H
+#define LINUX_ATMDEV_H
+
+
+#include <linux/config.h>
+#include <linux/atmapi.h>
+#include <linux/atm.h>
+#include <linux/atmioc.h>
+
+
+#define ESI_LEN         6
+
+#define ATM_OC3_PCR     (155520000/270*260/8/53)
+                        /* OC3 link rate:  155520000 bps
+                           SONET overhead: /270*260 (9 section, 1 path)
+                           bits per cell:  /8/53
+                           max cell rate:  353207.547 cells/sec */
+#define ATM_25_PCR      ((25600000/8-8000)/54)
+                        /* 25 Mbps ATM cell rate (59111) */
+#define ATM_OC12_PCR    (622080000/1080*1040/8/53)
+                        /* OC12 link rate: 622080000 bps
+                           SONET overhead: /1080*1040
+                           bits per cell:  /8/53
+                           max cell rate:  1412830.188 cells/sec */
+#define ATM_DS3_PCR     (8000*12)
+                        /* DS3: 12 cells in a 125 usec time slot */
+
+
+#define __AAL_STAT_ITEMS \
+    __HANDLE_ITEM(tx);                  /* TX okay */ \
+    __HANDLE_ITEM(tx_err);              /* TX errors */ \
+    __HANDLE_ITEM(rx);                  /* RX okay */ \
+    __HANDLE_ITEM(rx_err);              /* RX errors */ \
+    __HANDLE_ITEM(rx_drop);             /* RX out of memory */
+
+struct atm_aal_stats {
+#define __HANDLE_ITEM(i) int i
+        __AAL_STAT_ITEMS
+#undef __HANDLE_ITEM
+};
+
+
+struct atm_dev_stats {
+        struct atm_aal_stats aal0;
+        struct atm_aal_stats aal34;
+        struct atm_aal_stats aal5;
+} __ATM_API_ALIGN;
+
+
+#define ATM_GETLINKRATE _IOW('a',ATMIOC_ITF+1,struct atmif_sioc)
+                                        /* get link rate */
+#define ATM_GETNAMES    _IOW('a',ATMIOC_ITF+3,struct atm_iobuf)
+                                        /* get interface names (numbers) */
+#define ATM_GETTYPE     _IOW('a',ATMIOC_ITF+4,struct atmif_sioc)
+                                        /* get interface type name */
+#define ATM_GETESI      _IOW('a',ATMIOC_ITF+5,struct atmif_sioc)
+                                        /* get interface ESI */
+#define ATM_GETADDR     _IOW('a',ATMIOC_ITF+6,struct atmif_sioc)
+                                        /* get itf's local ATM addr. list */
+#define ATM_RSTADDR     _IOW('a',ATMIOC_ITF+7,struct atmif_sioc)
+                                        /* reset itf's ATM address list */
+#define ATM_ADDADDR     _IOW('a',ATMIOC_ITF+8,struct atmif_sioc)
+                                        /* add a local ATM address */
+#define ATM_DELADDR     _IOW('a',ATMIOC_ITF+9,struct atmif_sioc)
+                                        /* remove a local ATM address */
+#define ATM_GETCIRANGE  _IOW('a',ATMIOC_ITF+10,struct atmif_sioc)
+                                        /* get connection identifier range */
+#define ATM_SETCIRANGE  _IOW('a',ATMIOC_ITF+11,struct atmif_sioc)
+                                        /* set connection identifier range */
+#define ATM_SETESI      _IOW('a',ATMIOC_ITF+12,struct atmif_sioc)
+                                        /* set interface ESI */
+#define ATM_SETESIF     _IOW('a',ATMIOC_ITF+13,struct atmif_sioc)
+                                        /* force interface ESI */
+#define ATM_GETSTAT     _IOW('a',ATMIOC_SARCOM+0,struct atmif_sioc)
+                                        /* get AAL layer statistics */
+#define ATM_GETSTATZ    _IOW('a',ATMIOC_SARCOM+1,struct atmif_sioc)
+                                        /* get AAL layer statistics and zero */
+#define ATM_GETLOOP     _IOW('a',ATMIOC_SARCOM+2,struct atmif_sioc)
+                                        /* get loopback mode */
+#define ATM_SETLOOP     _IOW('a',ATMIOC_SARCOM+3,struct atmif_sioc)
+                                        /* set loopback mode */
+#define ATM_QUERYLOOP   _IOW('a',ATMIOC_SARCOM+4,struct atmif_sioc)
+                                        /* query supported loopback modes */
+#define ATM_SETSC       _IOW('a',ATMIOC_SPECIAL+1,int)
+                                        /* enable or disable single-copy */
+#define ATM_SETBACKEND  _IOW('a',ATMIOC_SPECIAL+2,atm_backend_t)
+                                        /* set backend handler */
+#define ATM_NEWBACKENDIF _IOW('a',ATMIOC_SPECIAL+3,atm_backend_t)
+                                        /* use backend to make new if */
+#define ATM_ADDPARTY    _IOW('a', ATMIOC_SPECIAL+4,struct atm_iobuf)
+                                        /* add party to p2mp call */
+#define ATM_DROPPARTY   _IOW('a', ATMIOC_SPECIAL+5,int)
+                                        /* drop party from p2mp call */
+
+/*
+ * These are backend handkers that can be set via the ATM_SETBACKEND call
+ * above.  In the future we may support dynamic loading of these - for now,
+ * they're just being used to share the ATMIOC_BACKEND ioctls
+ */
+#define ATM_BACKEND_RAW         0       
+#define ATM_BACKEND_PPP         1       /* PPPoATM - RFC2364 */
+#define ATM_BACKEND_BR2684      2       /* Bridged RFC1483/2684 */
+
+/* for ATM_GETTYPE */
+#define ATM_ITFTYP_LEN  8       /* maximum length of interface type name */
+
+/*
+ * Loopback modes for ATM_{PHY,SAR}_{GET,SET}LOOP
+ */
+
+/* Point of loopback                            CPU-->SAR-->PHY-->line--> ... */
+#define __ATM_LM_NONE   0       /* no loop back     ^     ^     ^      ^      */
+#define __ATM_LM_AAL    1       /* loop back PDUs --'     |     |      |      */
+#define __ATM_LM_ATM    2       /* loop back ATM cells ---'     |      |      */
+/* RESERVED             4       loop back on PHY side  ---'                   */
+#define __ATM_LM_PHY    8       /* loop back bits (digital) ----'      |      */
+#define __ATM_LM_ANALOG 16      /* loop back the analog signal --------'      */
+
+/* Direction of loopback */
+#define __ATM_LM_MKLOC(n)       ((n))       /* Local (i.e. loop TX to RX) */
+#define __ATM_LM_MKRMT(n)       ((n) << 8)  /* Remote (i.e. loop RX to TX) */
+
+#define __ATM_LM_XTLOC(n)       ((n) & 0xff)
+#define __ATM_LM_XTRMT(n)       (((n) >> 8) & 0xff)
+
+#define ATM_LM_NONE     0       /* no loopback */
+
+#define ATM_LM_LOC_AAL  __ATM_LM_MKLOC(__ATM_LM_AAL)
+#define ATM_LM_LOC_ATM  __ATM_LM_MKLOC(__ATM_LM_ATM)
+#define ATM_LM_LOC_PHY  __ATM_LM_MKLOC(__ATM_LM_PHY)
+#define ATM_LM_LOC_ANALOG __ATM_LM_MKLOC(__ATM_LM_ANALOG)
+
+#define ATM_LM_RMT_AAL  __ATM_LM_MKRMT(__ATM_LM_AAL)
+#define ATM_LM_RMT_ATM  __ATM_LM_MKRMT(__ATM_LM_ATM)
+#define ATM_LM_RMT_PHY  __ATM_LM_MKRMT(__ATM_LM_PHY)
+#define ATM_LM_RMT_ANALOG __ATM_LM_MKRMT(__ATM_LM_ANALOG)
+
+/*
+ * Note: ATM_LM_LOC_* and ATM_LM_RMT_* can be combined, provided that
+ * __ATM_LM_XTLOC(x) <= __ATM_LM_XTRMT(x)
+ */
+
+
+struct atm_iobuf {
+        int length;
+        void __user *buffer;
+};
+
+/* for ATM_GETCIRANGE / ATM_SETCIRANGE */
+
+#define ATM_CI_MAX      -1              /* use maximum range of VPI/VCI */
+ 
+struct atm_cirange {
+        signed char     vpi_bits;       /* 1..8, ATM_CI_MAX (-1) for maximum */
+        signed char     vci_bits;       /* 1..16, ATM_CI_MAX (-1) for maximum */
+};
+
+/* for ATM_SETSC; actually taken from the ATM_VF number space */
+
+#define ATM_SC_RX       1024            /* enable RX single-copy */
+#define ATM_SC_TX       2048            /* enable TX single-copy */
+
+#define ATM_BACKLOG_DEFAULT 32 /* if we get more, we're likely to time out
+                                  anyway */
+
+/* MF: change_qos (Modify) flags */
+
+#define ATM_MF_IMMED     1      /* Block until change is effective */
+#define ATM_MF_INC_RSV   2      /* Change reservation on increase */
+#define ATM_MF_INC_SHP   4      /* Change shaping on increase */
+#define ATM_MF_DEC_RSV   8      /* Change reservation on decrease */
+#define ATM_MF_DEC_SHP  16      /* Change shaping on decrease */
+#define ATM_MF_BWD      32      /* Set the backward direction parameters */
+
+#define ATM_MF_SET      (ATM_MF_INC_RSV | ATM_MF_INC_SHP | ATM_MF_DEC_RSV | \
+                          ATM_MF_DEC_SHP | ATM_MF_BWD)
+
+/*
+ * ATM_VS_* are used to express VC state in a human-friendly way.
+ */
+
+#define ATM_VS_IDLE     0       /* VC is not used */
+#define ATM_VS_CONNECTED 1      /* VC is connected */
+#define ATM_VS_CLOSING  2       /* VC is closing */
+#define ATM_VS_LISTEN   3       /* VC is listening for incoming setups */
+#define ATM_VS_INUSE    4       /* VC is in use (registered with atmsigd) */
+#define ATM_VS_BOUND    5       /* VC is bound */
+
+#define ATM_VS2TXT_MAP \
+    "IDLE", "CONNECTED", "CLOSING", "LISTEN", "INUSE", "BOUND"
+
+#define ATM_VF2TXT_MAP \
+    "ADDR",     "READY",        "PARTIAL",      "REGIS", \
+    "RELEASED", "HASQOS",       "LISTEN",       "META", \
+    "256",      "512",          "1024",         "2048", \
+    "SESSION",  "HASSAP",       "BOUND",        "CLOSE"
+
+
+#ifdef __KERNEL__
+
+#include <linux/wait.h> /* wait_queue_head_t */
+#include <linux/time.h> /* struct timeval */
+#include <linux/net.h>
+#include <linux/skbuff.h> /* struct sk_buff */
+#include <linux/uio.h>
+#include <net/sock.h>
+#include <asm/atomic.h>
+
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+
+extern struct proc_dir_entry *atm_proc_root;
+#endif
+
+
+struct k_atm_aal_stats {
+#define __HANDLE_ITEM(i) atomic_t i
+        __AAL_STAT_ITEMS
+#undef __HANDLE_ITEM
+};
+
+
+struct k_atm_dev_stats {
+        struct k_atm_aal_stats aal0;
+        struct k_atm_aal_stats aal34;
+        struct k_atm_aal_stats aal5;
+};
+
+
+enum {
+        ATM_VF_ADDR,            /* Address is in use. Set by anybody, cleared
+                                   by device driver. */
+        ATM_VF_READY,           /* VC is ready to transfer data. Set by device
+                                   driver, cleared by anybody. */
+        ATM_VF_PARTIAL,         /* resources are bound to PVC (partial PVC
+                                   setup), controlled by socket layer */
+        ATM_VF_REGIS,           /* registered with demon, controlled by SVC
+                                   socket layer */
+        ATM_VF_BOUND,           /* local SAP is set, controlled by SVC socket
+                                   layer */
+        ATM_VF_RELEASED,        /* demon has indicated/requested release,
+                                   controlled by SVC socket layer */
+        ATM_VF_HASQOS,          /* QOS parameters have been set */
+        ATM_VF_LISTEN,          /* socket is used for listening */
+        ATM_VF_META,            /* SVC socket isn't used for normal data
+                                   traffic and doesn't depend on signaling
+                                   to be available */
+        ATM_VF_SESSION,         /* VCC is p2mp session control descriptor */
+        ATM_VF_HASSAP,          /* SAP has been set */
+        ATM_VF_CLOSE,           /* asynchronous close - treat like VF_RELEASED*/
+        ATM_VF_WAITING,         /* waiting for reply from sigd */
+        ATM_VF_IS_CLIP,         /* in use by CLIP protocol */
+};
+
+
+#define ATM_VF2VS(flags) \
+    (test_bit(ATM_VF_READY,&(flags)) ? ATM_VS_CONNECTED : \
+     test_bit(ATM_VF_RELEASED,&(flags)) ? ATM_VS_CLOSING : \
+     test_bit(ATM_VF_LISTEN,&(flags)) ? ATM_VS_LISTEN : \
+     test_bit(ATM_VF_REGIS,&(flags)) ? ATM_VS_INUSE : \
+     test_bit(ATM_VF_BOUND,&(flags)) ? ATM_VS_BOUND : ATM_VS_IDLE)
+
+
+enum {
+        ATM_DF_CLOSE,           /* close device when last VCC is closed */
+};
+
+
+#define ATM_PHY_SIG_LOST    0   /* no carrier/light */
+#define ATM_PHY_SIG_UNKNOWN 1   /* carrier/light status is unknown */
+#define ATM_PHY_SIG_FOUND   2   /* carrier/light okay */
+
+#define ATM_ATMOPT_CLP  1       /* set CLP bit */
+
+struct atm_vcc {
+        /* struct sock has to be the first member of atm_vcc */
+        struct sock     sk;
+        unsigned long   flags;          /* VCC flags (ATM_VF_*) */
+        short           vpi;            /* VPI and VCI (types must be equal */
+                                        /* with sockaddr) */
+        int             vci;
+        unsigned long   aal_options;    /* AAL layer options */
+        unsigned long   atm_options;    /* ATM layer options */
+        struct atm_dev  *dev;           /* device back pointer */
+        struct atm_qos  qos;            /* QOS */
+        struct atm_sap  sap;            /* SAP */
+        void (*push)(struct atm_vcc *vcc,struct sk_buff *skb);
+        void (*pop)(struct atm_vcc *vcc,struct sk_buff *skb); /* optional */
+        int (*push_oam)(struct atm_vcc *vcc,void *cell);
+        int (*send)(struct atm_vcc *vcc,struct sk_buff *skb);
+        void            *dev_data;      /* per-device data */
+        void            *proto_data;    /* per-protocol data */
+        struct k_atm_aal_stats *stats;  /* pointer to AAL stats group */
+        /* SVC part --- may move later ------------------------------------- */
+        short           itf;            /* interface number */
+        struct sockaddr_atmsvc local;
+        struct sockaddr_atmsvc remote;
+        /* Multipoint part ------------------------------------------------- */
+        struct atm_vcc  *session;       /* session VCC descriptor */
+        /* Other stuff ----------------------------------------------------- */
+        void            *user_back;     /* user backlink - not touched by */
+                                        /* native ATM stack. Currently used */
+                                        /* by CLIP and sch_atm. */
+};
+
+static inline struct atm_vcc *atm_sk(struct sock *sk)
+{
+        return (struct atm_vcc *)sk;
+}
+
+static inline struct atm_vcc *ATM_SD(struct socket *sock)
+{
+        return atm_sk(sock->sk);
+}
+
+static inline struct sock *sk_atm(struct atm_vcc *vcc)
+{
+        return (struct sock *)vcc;
+}
+
+struct atm_dev_addr {
+        struct sockaddr_atmsvc addr;    /* ATM address */
+        struct list_head entry;         /* next address */
+};
+
+struct atm_dev {
+        const struct atmdev_ops *ops;   /* device operations; NULL if unused */
+        const struct atmphy_ops *phy;   /* PHY operations, may be undefined */
+                                        /* (NULL) */
+        const char      *type;          /* device type name */
+        int             number;         /* device index */
+        void            *dev_data;      /* per-device data */
+        void            *phy_data;      /* private PHY date */
+        unsigned long   flags;          /* device flags (ATM_DF_*) */
+        struct list_head local;         /* local ATM addresses */
+        unsigned char   esi[ESI_LEN];   /* ESI ("MAC" addr) */
+        struct atm_cirange ci_range;    /* VPI/VCI range */
+        struct k_atm_dev_stats stats;   /* statistics */
+        char            signal;         /* signal status (ATM_PHY_SIG_*) */
+        int             link_rate;      /* link rate (default: OC3) */
+        atomic_t        refcnt;         /* reference count */
+        spinlock_t      lock;           /* protect internal members */
+#ifdef CONFIG_PROC_FS
+        struct proc_dir_entry *proc_entry; /* proc entry */
+        char *proc_name;                /* proc entry name */
+#endif
+        struct list_head dev_list;      /* linkage */
+};
+
+ 
+/* OF: send_Oam Flags */
+
+#define ATM_OF_IMMED  1         /* Attempt immediate delivery */
+#define ATM_OF_INRATE 2         /* Attempt in-rate delivery */
+
+
+/*
+ * ioctl, getsockopt, and setsockopt are optional and can be set to NULL.
+ */
+
+struct atmdev_ops { /* only send is required */
+        void (*dev_close)(struct atm_dev *dev);
+        int (*open)(struct atm_vcc *vcc);
+        void (*close)(struct atm_vcc *vcc);
+        int (*ioctl)(struct atm_dev *dev,unsigned int cmd,void __user *arg);
+        int (*getsockopt)(struct atm_vcc *vcc,int level,int optname,
+            void __user *optval,int optlen);
+        int (*setsockopt)(struct atm_vcc *vcc,int level,int optname,
+            void __user *optval,int optlen);
+        int (*send)(struct atm_vcc *vcc,struct sk_buff *skb);
+        int (*send_oam)(struct atm_vcc *vcc,void *cell,int flags);
+        void (*phy_put)(struct atm_dev *dev,unsigned char value,
+            unsigned long addr);
+        unsigned char (*phy_get)(struct atm_dev *dev,unsigned long addr);
+        int (*change_qos)(struct atm_vcc *vcc,struct atm_qos *qos,int flags);
+        int (*proc_read)(struct atm_dev *dev,loff_t *pos,char *page);
+        struct module *owner;
+};
+
+struct atmphy_ops {
+        int (*start)(struct atm_dev *dev);
+        int (*ioctl)(struct atm_dev *dev,unsigned int cmd,void __user *arg);
+        void (*interrupt)(struct atm_dev *dev);
+        int (*stop)(struct atm_dev *dev);
+};
+
+struct atm_skb_data {
+        struct atm_vcc  *vcc;           /* ATM VCC */
+        unsigned long   atm_options;    /* ATM layer options */
+};
+
+#define VCC_HTABLE_SIZE 32
+
+extern struct hlist_head vcc_hash[VCC_HTABLE_SIZE];
+extern rwlock_t vcc_sklist_lock;
+
+#define ATM_SKB(skb) (((struct atm_skb_data *) (skb)->cb))
+
+struct atm_dev *atm_dev_register(const char *type,const struct atmdev_ops *ops,
+    int number,unsigned long *flags); /* number == -1: pick first available */
+struct atm_dev *atm_dev_lookup(int number);
+void atm_dev_deregister(struct atm_dev *dev);
+void shutdown_atm_dev(struct atm_dev *dev);
+void vcc_insert_socket(struct sock *sk);
+
+
+/*
+ * This is approximately the algorithm used by alloc_skb.
+ *
+ */
+
+static inline int atm_guess_pdu2truesize(int size)
+{
+        return (SKB_DATA_ALIGN(size) + sizeof(struct skb_shared_info));
+}
+
+
+static inline void atm_force_charge(struct atm_vcc *vcc,int truesize)
+{
+        atomic_add(truesize, &sk_atm(vcc)->sk_rmem_alloc);
+}
+
+
+static inline void atm_return(struct atm_vcc *vcc,int truesize)
+{
+        atomic_sub(truesize, &sk_atm(vcc)->sk_rmem_alloc);
+}
+
+
+static inline int atm_may_send(struct atm_vcc *vcc,unsigned int size)
+{
+        return (size + atomic_read(&sk_atm(vcc)->sk_wmem_alloc)) <
+               sk_atm(vcc)->sk_sndbuf;
+}
+
+
+static inline void atm_dev_hold(struct atm_dev *dev)
+{
+        atomic_inc(&dev->refcnt);
+}
+
+
+static inline void atm_dev_put(struct atm_dev *dev)
+{
+        atomic_dec(&dev->refcnt);
+
+        if ((atomic_read(&dev->refcnt) == 1) &&
+            test_bit(ATM_DF_CLOSE,&dev->flags))
+                shutdown_atm_dev(dev);
+}
+
+
+int atm_charge(struct atm_vcc *vcc,int truesize);
+struct sk_buff *atm_alloc_charge(struct atm_vcc *vcc,int pdu_size,
+    int gfp_flags);
+int atm_pcr_goal(struct atm_trafprm *tp);
+
+void vcc_release_async(struct atm_vcc *vcc, int reply);
+
+struct atm_ioctl {
+        struct module *owner;
+        /* A module reference is kept if appropriate over this call.
+         * Return -ENOIOCTLCMD if you don't handle it. */
+        int (*ioctl)(struct socket *, unsigned int cmd, unsigned long arg);
+        struct list_head list;
+};
+
+/**
+ * register_atm_ioctl - register handler for ioctl operations
+ *
+ * Special (non-device) handlers of ioctl's should
+ * register here. If you're a normal device, you should
+ * set .ioctl in your atmdev_ops instead.
+ */
+void register_atm_ioctl(struct atm_ioctl *);
+
+/**
+ * deregister_atm_ioctl - remove the ioctl handler
+ */
+void deregister_atm_ioctl(struct atm_ioctl *);
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/atmioc.h b/include/linux/atmioc.h
new file mode 100644
index 000000000000..37f67aa8f1c1
--- /dev/null
+++ b/include/linux/atmioc.h
@@ -0,0 +1,41 @@
+/* atmioc.h - ranges for ATM-related ioctl numbers */
+ 
+/* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
+
+
+/*
+ * See http://icawww1.epfl.ch/linux-atm/magic.html for the complete list of
+ * "magic" ioctl numbers.
+ */
+
+
+#ifndef _LINUX_ATMIOC_H
+#define _LINUX_ATMIOC_H
+
+#include <asm/ioctl.h>
+                /* everybody including atmioc.h will also need _IO{,R,W,WR} */
+
+#define ATMIOC_PHYCOM     0x00 /* PHY device common ioctls, globally unique */
+#define ATMIOC_PHYCOM_END 0x0f
+#define ATMIOC_PHYTYP     0x10 /* PHY dev type ioctls, unique per PHY type */
+#define ATMIOC_PHYTYP_END 0x2f
+#define ATMIOC_PHYPRV     0x30 /* PHY dev private ioctls, unique per driver */
+#define ATMIOC_PHYPRV_END 0x4f
+#define ATMIOC_SARCOM     0x50 /* SAR device common ioctls, globally unique */
+#define ATMIOC_SARCOM_END 0x50
+#define ATMIOC_SARPRV     0x60 /* SAR dev private ioctls, unique per driver */
+#define ATMIOC_SARPRV_END 0x7f
+#define ATMIOC_ITF        0x80 /* Interface ioctls, globally unique */
+#define ATMIOC_ITF_END    0x8f
+#define ATMIOC_BACKEND    0x90 /* ATM generic backend ioctls, u. per backend */
+#define ATMIOC_BACKEND_END 0xaf
+/* 0xb0-0xbf: Reserved for future use */
+#define ATMIOC_AREQUIPA   0xc0 /* Application requested IP over ATM, glob. u. */
+#define ATMIOC_LANE       0xd0 /* LAN Emulation, globally unique */
+#define ATMIOC_MPOA       0xd8 /* MPOA, globally unique */
+#define ATMIOC_CLIP       0xe0 /* Classical IP over ATM control, globally u. */
+#define ATMIOC_CLIP_END   0xef
+#define ATMIOC_SPECIAL    0xf0 /* Special-purpose controls, globally unique */
+#define ATMIOC_SPECIAL_END 0xff
+
+#endif
diff --git a/include/linux/atmlec.h b/include/linux/atmlec.h
new file mode 100644
index 000000000000..f267f2442766
--- /dev/null
+++ b/include/linux/atmlec.h
@@ -0,0 +1,88 @@
+/*
+ * 
+ * ATM Lan Emulation Daemon vs. driver interface
+ *
+ * mkiiskila@yahoo.com
+ *
+ */
+
+#ifndef _ATMLEC_H_
+#define _ATMLEC_H_
+
+#include <linux/atmapi.h>
+#include <linux/atmioc.h>
+#include <linux/atm.h>
+#include <linux/if_ether.h>
+/* ATM lec daemon control socket */
+#define ATMLEC_CTRL _IO('a',ATMIOC_LANE)
+#define ATMLEC_DATA _IO('a',ATMIOC_LANE+1)
+#define ATMLEC_MCAST _IO('a',ATMIOC_LANE+2)
+
+/* Maximum number of LEC interfaces (tweakable) */
+#define MAX_LEC_ITF 48
+
+/* From the total of MAX_LEC_ITF, last NUM_TR_DEVS are reserved for Token Ring.
+ * E.g. if MAX_LEC_ITF = 48 and NUM_TR_DEVS = 8, then lec0-lec39 are for
+ * Ethernet ELANs and lec40-lec47 are for Token Ring ELANS.
+ */
+#define NUM_TR_DEVS 8
+
+typedef enum { 
+        l_set_mac_addr,   l_del_mac_addr, 
+        l_svc_setup, 
+        l_addr_delete,    l_topology_change, 
+        l_flush_complete, l_arp_update,
+        l_narp_req, /* LANE2 mandates the use of this */
+        l_config,         l_flush_tran_id, 
+        l_set_lecid,      l_arp_xmt,
+        l_rdesc_arp_xmt,
+        l_associate_req,
+        l_should_bridge   /* should we bridge this MAC? */
+} atmlec_msg_type;
+
+#define ATMLEC_MSG_TYPE_MAX l_should_bridge
+
+struct atmlec_config_msg {
+        unsigned int maximum_unknown_frame_count;
+        unsigned int max_unknown_frame_time;
+        unsigned short max_retry_count;
+        unsigned int aging_time;
+        unsigned int forward_delay_time;
+        unsigned int arp_response_time;
+        unsigned int flush_timeout;
+        unsigned int path_switching_delay;
+        unsigned int  lane_version; /* LANE2: 1 for LANEv1, 2 for LANEv2 */
+        int mtu;
+        int is_proxy;
+};
+ 
+struct atmlec_msg {
+        atmlec_msg_type type;
+        int             sizeoftlvs;        /* LANE2: if != 0, tlvs follow */ 
+        union {
+                struct {
+                        unsigned char mac_addr[ETH_ALEN];
+                        unsigned char atm_addr[ATM_ESA_LEN];
+                        unsigned int flag;/* Topology_change flag, 
+                                              remoteflag, permanent flag,
+                                              lecid, transaction id */
+                        unsigned int targetless_le_arp; /* LANE2 */
+                        unsigned int no_source_le_narp; /* LANE2 */
+                } normal;
+                struct atmlec_config_msg config;
+                struct {
+                        uint16_t lec_id;                     /* requestor lec_id  */
+                        uint32_t tran_id;                    /* transaction id    */
+                        unsigned char mac_addr[ETH_ALEN];    /* dst mac addr      */
+                        unsigned char atm_addr[ATM_ESA_LEN]; /* reqestor ATM addr */
+                } proxy;
+                     /* For mapping LE_ARP requests to responses. Filled by */
+        } content;       /* zeppelin, returned by kernel. Used only when proxying */ 
+} __ATM_API_ALIGN;
+
+struct atmlec_ioc {
+        int dev_num;
+        unsigned char atm_addr[ATM_ESA_LEN];
+        unsigned char receive;    /* 1= receive vcc, 0 = send vcc */
+};
+#endif /* _ATMLEC_H_ */
diff --git a/include/linux/atmmpc.h b/include/linux/atmmpc.h
new file mode 100644
index 000000000000..5fbfa68136d3
--- /dev/null
+++ b/include/linux/atmmpc.h
@@ -0,0 +1,125 @@
+#ifndef _ATMMPC_H_
+#define _ATMMPC_H_
+
+#include <linux/atmapi.h>
+#include <linux/atmioc.h>
+#include <linux/atm.h>
+
+#define ATMMPC_CTRL _IO('a', ATMIOC_MPOA)
+#define ATMMPC_DATA _IO('a', ATMIOC_MPOA+1)
+
+#define MPC_SOCKET_INGRESS 1
+#define MPC_SOCKET_EGRESS  2
+
+struct atmmpc_ioc {
+        int dev_num;
+        uint32_t ipaddr;              /* the IP address of the shortcut    */
+        int type;                     /* ingress or egress                 */
+};
+
+typedef struct in_ctrl_info {
+        uint8_t   Last_NHRP_CIE_code;
+        uint8_t   Last_Q2931_cause_value;     
+        uint8_t   eg_MPC_ATM_addr[ATM_ESA_LEN];
+        uint32_t  tag;
+        uint32_t  in_dst_ip;      /* IP address this ingress MPC sends packets to */
+        uint16_t  holding_time;
+        uint32_t  request_id;
+} in_ctrl_info;
+
+typedef struct eg_ctrl_info {
+        uint8_t   DLL_header[256];
+        uint8_t   DH_length;
+        uint32_t  cache_id;
+        uint32_t  tag;
+        uint32_t  mps_ip;
+        uint32_t  eg_dst_ip;      /* IP address to which ingress MPC sends packets */
+        uint8_t   in_MPC_data_ATM_addr[ATM_ESA_LEN];
+        uint16_t  holding_time;
+} eg_ctrl_info;
+
+struct mpc_parameters {
+        uint16_t mpc_p1;   /* Shortcut-Setup Frame Count    */
+        uint16_t mpc_p2;   /* Shortcut-Setup Frame Time     */
+        uint8_t mpc_p3[8]; /* Flow-detection Protocols      */
+        uint16_t mpc_p4;   /* MPC Initial Retry Time        */
+        uint16_t mpc_p5;   /* MPC Retry Time Maximum        */
+        uint16_t mpc_p6;   /* Hold Down Time                */      
+} ;
+
+struct k_message {
+        uint16_t type;
+        uint32_t ip_mask;
+        uint8_t  MPS_ctrl[ATM_ESA_LEN];
+        union {
+                in_ctrl_info in_info;
+                eg_ctrl_info eg_info;
+                struct mpc_parameters params;
+        } content;
+        struct atm_qos qos;       
+} __ATM_API_ALIGN;
+
+struct llc_snap_hdr {
+        /* RFC 1483 LLC/SNAP encapsulation for routed IP PDUs */
+        uint8_t  dsap;    /* Destination Service Access Point (0xAA)     */
+        uint8_t  ssap;    /* Source Service Access Point      (0xAA)     */
+        uint8_t  ui;      /* Unnumbered Information           (0x03)     */
+        uint8_t  org[3];  /* Organizational identification    (0x000000) */
+        uint8_t  type[2]; /* Ether type (for IP)              (0x0800)   */
+};
+
+/* TLVs this MPC recognizes */
+#define TLV_MPOA_DEVICE_TYPE         0x00a03e2a  
+
+/* MPOA device types in MPOA Device Type TLV */
+#define NON_MPOA    0
+#define MPS         1
+#define MPC         2
+#define MPS_AND_MPC 3
+
+
+/* MPC parameter defaults */
+
+#define MPC_P1 10  /* Shortcut-Setup Frame Count  */ 
+#define MPC_P2 1   /* Shortcut-Setup Frame Time   */
+#define MPC_P3 0   /* Flow-detection Protocols    */
+#define MPC_P4 5   /* MPC Initial Retry Time      */
+#define MPC_P5 40  /* MPC Retry Time Maximum      */
+#define MPC_P6 160 /* Hold Down Time              */
+#define HOLDING_TIME_DEFAULT 1200 /* same as MPS-p7 */
+
+/* MPC constants */
+
+#define MPC_C1 2   /* Retry Time Multiplier       */
+#define MPC_C2 60  /* Initial Keep-Alive Lifetime */
+
+/* Message types - to MPOA daemon */
+
+#define SND_MPOA_RES_RQST    201
+#define SET_MPS_CTRL_ADDR    202
+#define SND_MPOA_RES_RTRY    203 /* Different type in a retry due to req id         */
+#define STOP_KEEP_ALIVE_SM   204
+#define EGRESS_ENTRY_REMOVED 205
+#define SND_EGRESS_PURGE     206
+#define DIE                  207 /* tell the daemon to exit()                       */
+#define DATA_PLANE_PURGE     208 /* Data plane purge because of egress cache hit miss or dead MPS */
+#define OPEN_INGRESS_SVC     209
+
+/* Message types - from MPOA daemon */
+
+#define MPOA_TRIGGER_RCVD     101
+#define MPOA_RES_REPLY_RCVD   102
+#define INGRESS_PURGE_RCVD    103
+#define EGRESS_PURGE_RCVD     104
+#define MPS_DEATH             105
+#define CACHE_IMPOS_RCVD      106
+#define SET_MPC_CTRL_ADDR     107 /* Our MPC's control ATM address   */
+#define SET_MPS_MAC_ADDR      108
+#define CLEAN_UP_AND_EXIT     109
+#define SET_MPC_PARAMS        110 /* MPC configuration parameters    */
+
+/* Message types - bidirectional */       
+
+#define RELOAD                301 /* kill -HUP the daemon for reload */
+
+#endif /* _ATMMPC_H_ */
diff --git a/include/linux/atmppp.h b/include/linux/atmppp.h
new file mode 100644
index 000000000000..300dcce0c83f
--- /dev/null
+++ b/include/linux/atmppp.h
@@ -0,0 +1,24 @@
+/* atmppp.h - RFC2364 PPPoATM */
+
+/* Written 2000 by Mitchell Blank Jr */
+
+#ifndef _LINUX_ATMPPP_H
+#define _LINUX_ATMPPP_H
+
+#include <linux/atm.h>
+
+#define PPPOATM_ENCAPS_AUTODETECT       (0)
+#define PPPOATM_ENCAPS_VC               (1)
+#define PPPOATM_ENCAPS_LLC              (2)
+
+/*
+ * This is for the ATM_SETBACKEND call - these are like socket families:
+ * the first element of the structure is the backend number and the rest
+ * is per-backend specific
+ */
+struct atm_backend_ppp {
+        atm_backend_t   backend_num;    /* ATM_BACKEND_PPP */
+        int             encaps;         /* PPPOATM_ENCAPS_* */
+};
+
+#endif  /* _LINUX_ATMPPP_H */
diff --git a/include/linux/atmsap.h b/include/linux/atmsap.h
new file mode 100644
index 000000000000..799b104515d7
--- /dev/null
+++ b/include/linux/atmsap.h
@@ -0,0 +1,162 @@
+/* atmsap.h - ATM Service Access Point addressing definitions */
+
+/* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
+
+
+#ifndef _LINUX_ATMSAP_H
+#define _LINUX_ATMSAP_H
+
+#include <linux/atmapi.h>
+
+/*
+ * BEGIN_xx and END_xx markers are used for automatic generation of
+ * documentation. Do not change them.
+ */
+
+
+/*
+ * Layer 2 protocol identifiers
+ */
+
+/* BEGIN_L2 */
+#define ATM_L2_NONE     0       /* L2 not specified */
+#define ATM_L2_ISO1745  0x01    /* Basic mode ISO 1745 */
+#define ATM_L2_Q291     0x02    /* ITU-T Q.291 (Rec. I.441) */
+#define ATM_L2_X25_LL   0x06    /* ITU-T X.25, link layer */
+#define ATM_L2_X25_ML   0x07    /* ITU-T X.25, multilink */
+#define ATM_L2_LAPB     0x08    /* Extended LAPB, half-duplex (Rec. T.71) */
+#define ATM_L2_HDLC_ARM 0x09    /* HDLC ARM (ISO/IEC 4335) */
+#define ATM_L2_HDLC_NRM 0x0a    /* HDLC NRM (ISO/IEC 4335) */
+#define ATM_L2_HDLC_ABM 0x0b    /* HDLC ABM (ISO/IEC 4335) */
+#define ATM_L2_ISO8802  0x0c    /* LAN LLC (ISO/IEC 8802/2) */
+#define ATM_L2_X75      0x0d    /* ITU-T X.75, SLP */
+#define ATM_L2_Q922     0x0e    /* ITU-T Q.922 */
+#define ATM_L2_USER     0x10    /* user-specified */
+#define ATM_L2_ISO7776  0x11    /* ISO 7776 DTE-DTE */
+/* END_L2 */
+
+
+/*
+ * Layer 3 protocol identifiers
+ */
+
+/* BEGIN_L3 */
+#define ATM_L3_NONE     0       /* L3 not specified */
+#define ATM_L3_X25      0x06    /* ITU-T X.25, packet layer */
+#define ATM_L3_ISO8208  0x07    /* ISO/IEC 8208 */
+#define ATM_L3_X223     0x08    /* ITU-T X.223 | ISO/IEC 8878 */
+#define ATM_L3_ISO8473  0x09    /* ITU-T X.233 | ISO/IEC 8473 */
+#define ATM_L3_T70      0x0a    /* ITU-T T.70 minimum network layer */
+#define ATM_L3_TR9577   0x0b    /* ISO/IEC TR 9577 */
+#define ATM_L3_H310     0x0c    /* ITU-T Recommendation H.310 */
+#define ATM_L3_H321     0x0d    /* ITU-T Recommendation H.321 */
+#define ATM_L3_USER     0x10    /* user-specified */
+/* END_L3 */
+
+
+/*
+ * High layer identifiers
+ */
+
+/* BEGIN_HL */
+#define ATM_HL_NONE     0       /* HL not specified */
+#define ATM_HL_ISO      0x01    /* ISO */
+#define ATM_HL_USER     0x02    /* user-specific */
+#define ATM_HL_HLP      0x03    /* high layer profile - UNI 3.0 only */
+#define ATM_HL_VENDOR   0x04    /* vendor-specific application identifier */
+/* END_HL */
+
+
+/*
+ * ITU-T coded mode of operation
+ */
+
+/* BEGIN_IMD */
+#define ATM_IMD_NONE     0      /* mode not specified */
+#define ATM_IMD_NORMAL   1      /* normal mode of operation */
+#define ATM_IMD_EXTENDED 2      /* extended mode of operation */
+/* END_IMD */
+
+/*
+ * H.310 code points
+ */
+
+#define ATM_TT_NONE     0       /* terminal type not specified */
+#define ATM_TT_RX       1       /* receive only */
+#define ATM_TT_TX       2       /* send only */
+#define ATM_TT_RXTX     3       /* receive and send */
+
+#define ATM_MC_NONE     0       /* no multiplexing */
+#define ATM_MC_TS       1       /* transport stream (TS) */
+#define ATM_MC_TS_FEC   2       /* transport stream with forward error corr. */
+#define ATM_MC_PS       3       /* program stream (PS) */
+#define ATM_MC_PS_FEC   4       /* program stream with forward error corr. */
+#define ATM_MC_H221     5       /* ITU-T Rec. H.221 */
+
+/*
+ * SAP structures
+ */
+
+#define ATM_MAX_HLI     8       /* maximum high-layer information length */
+
+
+struct atm_blli {
+    unsigned char l2_proto;     /* layer 2 protocol */
+    union {
+        struct {
+            unsigned char mode; /* mode of operation (ATM_IMD_xxx), 0 if */
+                                /* absent */
+            unsigned char window; /* window size (k), 1-127 (0 to omit) */
+        } itu;                  /* ITU-T encoding */
+        unsigned char user;     /* user-specified l2 information */
+    } l2;
+    unsigned char l3_proto;     /* layer 3 protocol */
+    union {
+        struct {
+            unsigned char mode; /* mode of operation (ATM_IMD_xxx), 0 if */
+                                /* absent */
+            unsigned char def_size; /* default packet size (log2), 4-12 (0 to */
+                                    /* omit) */
+            unsigned char window;/* packet window size, 1-127 (0 to omit) */
+        } itu;                  /* ITU-T encoding */
+        unsigned char user;     /* user specified l3 information */
+        struct {                      /* if l3_proto = ATM_L3_H310 */
+            unsigned char term_type;  /* terminal type */
+            unsigned char fw_mpx_cap; /* forward multiplexing capability */
+                                      /* only if term_type != ATM_TT_NONE */
+            unsigned char bw_mpx_cap; /* backward multiplexing capability */
+                                      /* only if term_type != ATM_TT_NONE */
+        } h310;
+        struct {                  /* if l3_proto = ATM_L3_TR9577 */
+            unsigned char ipi;    /* initial protocol id */
+            unsigned char snap[5];/* IEEE 802.1 SNAP identifier */
+                                  /* (only if ipi == NLPID_IEEE802_1_SNAP) */
+        } tr9577;
+    } l3;
+} __ATM_API_ALIGN;
+
+
+struct atm_bhli {
+    unsigned char hl_type;      /* high layer information type */
+    unsigned char hl_length;    /* length (only if hl_type == ATM_HL_USER || */
+                                /* hl_type == ATM_HL_ISO) */
+    unsigned char hl_info[ATM_MAX_HLI];/* high layer information */
+};
+
+
+#define ATM_MAX_BLLI    3               /* maximum number of BLLI elements */
+
+
+struct atm_sap {
+        struct atm_bhli bhli;           /* local SAP, high-layer information */
+        struct atm_blli blli[ATM_MAX_BLLI] __ATM_API_ALIGN;
+                                        /* local SAP, low-layer info */
+};
+
+
+static __inline__ int blli_in_use(struct atm_blli blli)
+{
+        return blli.l2_proto || blli.l3_proto;
+}
+
+#endif
diff --git a/include/linux/atmsvc.h b/include/linux/atmsvc.h
new file mode 100644
index 000000000000..aa71583b8da7
--- /dev/null
+++ b/include/linux/atmsvc.h
@@ -0,0 +1,55 @@
+/* atmsvc.h - ATM signaling kernel-demon interface definitions */
+ 
+/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+#ifndef _LINUX_ATMSVC_H
+#define _LINUX_ATMSVC_H
+
+#include <linux/atmapi.h>
+#include <linux/atm.h>
+#include <linux/atmioc.h>
+
+
+#define ATMSIGD_CTRL _IO('a',ATMIOC_SPECIAL)
+                                /* become ATM signaling demon control socket */
+
+enum atmsvc_msg_type { as_catch_null, as_bind, as_connect, as_accept, as_reject,
+                       as_listen, as_okay, as_error, as_indicate, as_close,
+                       as_itf_notify, as_modify, as_identify, as_terminate,
+                       as_addparty, as_dropparty };
+
+struct atmsvc_msg {
+        enum atmsvc_msg_type type;
+        atm_kptr_t vcc;
+        atm_kptr_t listen_vcc;          /* indicate */
+        int reply;                      /* for okay and close:             */
+                                        /*   < 0: error before active      */
+                                        /*        (sigd has discarded ctx) */
+                                        /*   ==0: success                  */
+                                        /*   > 0: error when active (still */
+                                        /*        need to close)           */
+        struct sockaddr_atmpvc pvc;     /* indicate, okay (connect) */
+        struct sockaddr_atmsvc local;   /* local SVC address */
+        struct atm_qos qos;             /* QOS parameters */
+        struct atm_sap sap;             /* SAP */
+        unsigned int session;           /* for p2pm */
+        struct sockaddr_atmsvc svc;     /* SVC address */
+} __ATM_API_ALIGN;
+
+/*
+ * Message contents: see ftp://icaftp.epfl.ch/pub/linux/atm/docs/isp-*.tar.gz
+ */
+
+/*
+ * Some policy stuff for atmsigd and for net/atm/svc.c. Both have to agree on
+ * what PCR is used to request bandwidth from the device driver. net/atm/svc.c
+ * tries to do better than that, but only if there's no routing decision (i.e.
+ * if signaling only uses one ATM interface).
+ */
+
+#define SELECT_TOP_PCR(tp) ((tp).pcr ? (tp).pcr : \
+  (tp).max_pcr && (tp).max_pcr != ATM_MAX_PCR ? (tp).max_pcr : \
+  (tp).min_pcr ? (tp).min_pcr : ATM_MAX_PCR)
+
+#endif
diff --git a/include/linux/attribute_container.h b/include/linux/attribute_container.h
new file mode 100644
index 000000000000..af1010b6dab7
--- /dev/null
+++ b/include/linux/attribute_container.h
@@ -0,0 +1,73 @@
+/*
+ * class_container.h - a generic container for all classes
+ *
+ * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
+ *
+ * This file is licensed under GPLv2
+ */
+
+#ifndef _ATTRIBUTE_CONTAINER_H_
+#define _ATTRIBUTE_CONTAINER_H_
+
+#include <linux/device.h>
+#include <linux/list.h>
+
+struct attribute_container {
+        struct list_head        node;
+        struct list_head        containers;
+        struct class            *class;
+        struct class_device_attribute **attrs;
+        int (*match)(struct attribute_container *, struct device *);
+#define ATTRIBUTE_CONTAINER_NO_CLASSDEVS        0x01
+        unsigned long           flags;
+};
+
+static inline int
+attribute_container_no_classdevs(struct attribute_container *atc)
+{
+        return atc->flags & ATTRIBUTE_CONTAINER_NO_CLASSDEVS;
+}
+
+static inline void
+attribute_container_set_no_classdevs(struct attribute_container *atc)
+{
+        atc->flags |= ATTRIBUTE_CONTAINER_NO_CLASSDEVS;
+}
+
+int attribute_container_register(struct attribute_container *cont);
+int attribute_container_unregister(struct attribute_container *cont);
+void attribute_container_create_device(struct device *dev,
+                                       int (*fn)(struct attribute_container *,
+                                                 struct device *,
+                                                 struct class_device *));
+void attribute_container_add_device(struct device *dev,
+                                    int (*fn)(struct attribute_container *,
+                                              struct device *,
+                                              struct class_device *));
+void attribute_container_remove_device(struct device *dev,
+                                       void (*fn)(struct attribute_container *,
+                                                  struct device *,
+                                                  struct class_device *));
+void attribute_container_device_trigger(struct device *dev, 
+                                        int (*fn)(struct attribute_container *,
+                                                  struct device *,
+                                                  struct class_device *));
+void attribute_container_trigger(struct device *dev, 
+                                 int (*fn)(struct attribute_container *,
+                                           struct device *));
+int attribute_container_add_attrs(struct class_device *classdev);
+int attribute_container_add_class_device(struct class_device *classdev);
+int attribute_container_add_class_device_adapter(struct attribute_container *cont,
+                                                 struct device *dev,
+                                                 struct class_device *classdev);
+void attribute_container_remove_attrs(struct class_device *classdev);
+void attribute_container_class_device_del(struct class_device *classdev);
+
+
+
+
+
+
+struct class_device_attribute **attribute_container_classdev_to_attrs(const struct class_device *classdev);
+
+#endif
diff --git a/include/linux/audit.h b/include/linux/audit.h
new file mode 100644
index 000000000000..3628f7cfb178
--- /dev/null
+++ b/include/linux/audit.h
@@ -0,0 +1,196 @@
+/* audit.h -- Auditing support -*- linux-c -*-
+ *
+ * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Written by Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+#ifndef _LINUX_AUDIT_H_
+#define _LINUX_AUDIT_H_
+
+/* Request and reply types */
+#define AUDIT_GET      1000     /* Get status */
+#define AUDIT_SET      1001     /* Set status (enable/disable/auditd) */
+#define AUDIT_LIST     1002     /* List filtering rules */
+#define AUDIT_ADD      1003     /* Add filtering rule */
+#define AUDIT_DEL      1004     /* Delete filtering rule */
+#define AUDIT_USER     1005     /* Send a message from user-space */
+#define AUDIT_LOGIN    1006     /* Define the login id and informaiton */
+#define AUDIT_KERNEL   2000     /* Asynchronous audit record. NOT A REQUEST. */
+
+/* Rule flags */
+#define AUDIT_PER_TASK 0x01     /* Apply rule at task creation (not syscall) */
+#define AUDIT_AT_ENTRY 0x02     /* Apply rule at syscall entry */
+#define AUDIT_AT_EXIT  0x04     /* Apply rule at syscall exit */
+#define AUDIT_PREPEND  0x10     /* Prepend to front of list */
+
+/* Rule actions */
+#define AUDIT_NEVER    0        /* Do not build context if rule matches */
+#define AUDIT_POSSIBLE 1        /* Build context if rule matches  */
+#define AUDIT_ALWAYS   2        /* Generate audit record if rule matches */
+
+/* Rule structure sizes -- if these change, different AUDIT_ADD and
+ * AUDIT_LIST commands must be implemented. */
+#define AUDIT_MAX_FIELDS   64
+#define AUDIT_BITMASK_SIZE 64
+#define AUDIT_WORD(nr) ((__u32)((nr)/32))
+#define AUDIT_BIT(nr)  (1 << ((nr) - AUDIT_WORD(nr)*32))
+
+/* Rule fields */
+                                /* These are useful when checking the
+                                 * task structure at task creation time
+                                 * (AUDIT_PER_TASK).  */
+#define AUDIT_PID       0
+#define AUDIT_UID       1
+#define AUDIT_EUID      2
+#define AUDIT_SUID      3
+#define AUDIT_FSUID     4
+#define AUDIT_GID       5
+#define AUDIT_EGID      6
+#define AUDIT_SGID      7
+#define AUDIT_FSGID     8
+#define AUDIT_LOGINUID  9
+#define AUDIT_PERS      10
+
+                                /* These are ONLY useful when checking
+                                 * at syscall exit time (AUDIT_AT_EXIT). */
+#define AUDIT_DEVMAJOR  100
+#define AUDIT_DEVMINOR  101
+#define AUDIT_INODE     102
+#define AUDIT_EXIT      103
+#define AUDIT_SUCCESS   104     /* exit >= 0; value ignored */
+
+#define AUDIT_ARG0      200
+#define AUDIT_ARG1      (AUDIT_ARG0+1)
+#define AUDIT_ARG2      (AUDIT_ARG0+2)
+#define AUDIT_ARG3      (AUDIT_ARG0+3)
+
+#define AUDIT_NEGATE    0x80000000
+
+
+/* Status symbols */
+                                /* Mask values */
+#define AUDIT_STATUS_ENABLED            0x0001
+#define AUDIT_STATUS_FAILURE            0x0002
+#define AUDIT_STATUS_PID                0x0004
+#define AUDIT_STATUS_RATE_LIMIT         0x0008
+#define AUDIT_STATUS_BACKLOG_LIMIT      0x0010
+                                /* Failure-to-log actions */
+#define AUDIT_FAIL_SILENT       0
+#define AUDIT_FAIL_PRINTK       1
+#define AUDIT_FAIL_PANIC        2
+
+#ifndef __KERNEL__
+struct audit_message {
+        struct nlmsghdr nlh;
+        char            data[1200];
+};
+#endif
+
+struct audit_status {
+        __u32           mask;           /* Bit mask for valid entries */
+        __u32           enabled;        /* 1 = enabled, 0 = disbaled */
+        __u32           failure;        /* Failure-to-log action */
+        __u32           pid;            /* pid of auditd process */
+        __u32           rate_limit;     /* messages rate limit (per second) */
+        __u32           backlog_limit;  /* waiting messages limit */
+        __u32           lost;           /* messages lost */
+        __u32           backlog;        /* messages waiting in queue */
+};
+
+struct audit_rule {             /* for AUDIT_LIST, AUDIT_ADD, and AUDIT_DEL */
+        __u32           flags;  /* AUDIT_PER_{TASK,CALL}, AUDIT_PREPEND */
+        __u32           action; /* AUDIT_NEVER, AUDIT_POSSIBLE, AUDIT_ALWAYS */
+        __u32           field_count;
+        __u32           mask[AUDIT_BITMASK_SIZE];
+        __u32           fields[AUDIT_MAX_FIELDS];
+        __u32           values[AUDIT_MAX_FIELDS];
+};
+
+#ifdef __KERNEL__
+
+struct audit_buffer;
+struct audit_context;
+struct inode;
+
+#ifdef CONFIG_AUDITSYSCALL
+/* These are defined in auditsc.c */
+                                /* Public API */
+extern int  audit_alloc(struct task_struct *task);
+extern void audit_free(struct task_struct *task);
+extern void audit_syscall_entry(struct task_struct *task,
+                                int major, unsigned long a0, unsigned long a1,
+                                unsigned long a2, unsigned long a3);
+extern void audit_syscall_exit(struct task_struct *task, int return_code);
+extern void audit_getname(const char *name);
+extern void audit_putname(const char *name);
+extern void audit_inode(const char *name, const struct inode *inode);
+
+                                /* Private API (for audit.c only) */
+extern int  audit_receive_filter(int type, int pid, int uid, int seq,
+                                 void *data);
+extern void audit_get_stamp(struct audit_context *ctx,
+                            struct timespec *t, int *serial);
+extern int  audit_set_loginuid(struct audit_context *ctx, uid_t loginuid);
+extern uid_t audit_get_loginuid(struct audit_context *ctx);
+extern int audit_ipc_perms(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode);
+#else
+#define audit_alloc(t) ({ 0; })
+#define audit_free(t) do { ; } while (0)
+#define audit_syscall_entry(t,a,b,c,d,e) do { ; } while (0)
+#define audit_syscall_exit(t,r) do { ; } while (0)
+#define audit_getname(n) do { ; } while (0)
+#define audit_putname(n) do { ; } while (0)
+#define audit_inode(n,i) do { ; } while (0)
+#define audit_get_loginuid(c) ({ -1; })
+#define audit_ipc_perms(q,u,g,m) ({ 0; })
+#endif
+
+#ifdef CONFIG_AUDIT
+/* These are defined in audit.c */
+                                /* Public API */
+extern void                 audit_log(struct audit_context *ctx,
+                                      const char *fmt, ...)
+                            __attribute__((format(printf,2,3)));
+
+extern struct audit_buffer *audit_log_start(struct audit_context *ctx);
+extern void                 audit_log_format(struct audit_buffer *ab,
+                                             const char *fmt, ...)
+                            __attribute__((format(printf,2,3)));
+extern void                 audit_log_end(struct audit_buffer *ab);
+extern void                 audit_log_d_path(struct audit_buffer *ab,
+                                             const char *prefix,
+                                             struct dentry *dentry,
+                                             struct vfsmount *vfsmnt);
+
+                                /* Private API (for auditsc.c only) */
+extern void                 audit_send_reply(int pid, int seq, int type,
+                                             int done, int multi,
+                                             void *payload, int size);
+extern void                 audit_log_lost(const char *message);
+#else
+#define audit_log(t,f,...) do { ; } while (0)
+#define audit_log_start(t) ({ NULL; })
+#define audit_log_vformat(b,f,a) do { ; } while (0)
+#define audit_log_format(b,f,...) do { ; } while (0)
+#define audit_log_end(b) do { ; } while (0)
+#define audit_log_d_path(b,p,d,v) do { ; } while (0)
+#endif
+#endif
+#endif
diff --git a/include/linux/auto_fs.h b/include/linux/auto_fs.h
new file mode 100644
index 000000000000..c21e5972a3e8
--- /dev/null
+++ b/include/linux/auto_fs.h
@@ -0,0 +1,84 @@
+/* -*- linux-c -*- ------------------------------------------------------- *
+ *   
+ * linux/include/linux/auto_fs.h
+ *
+ *   Copyright 1997 Transmeta Corporation - All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+
+#ifndef _LINUX_AUTO_FS_H
+#define _LINUX_AUTO_FS_H
+
+#ifdef __KERNEL__
+#include <linux/fs.h>
+#include <linux/limits.h>
+#include <asm/types.h>
+#endif /* __KERNEL__ */
+
+#include <linux/ioctl.h>
+
+/* This file describes autofs v3 */
+#define AUTOFS_PROTO_VERSION    3
+
+/* Range of protocol versions defined */
+#define AUTOFS_MAX_PROTO_VERSION        AUTOFS_PROTO_VERSION
+#define AUTOFS_MIN_PROTO_VERSION        AUTOFS_PROTO_VERSION
+
+/*
+ * Architectures where both 32- and 64-bit binaries can be executed
+ * on 64-bit kernels need this.  This keeps the structure format
+ * uniform, and makes sure the wait_queue_token isn't too big to be
+ * passed back down to the kernel.
+ *
+ * This assumes that on these architectures:
+ * mode     32 bit    64 bit
+ * -------------------------
+ * int      32 bit    32 bit
+ * long     32 bit    64 bit
+ *
+ * If so, 32-bit user-space code should be backwards compatible.
+ */
+
+#if defined(__sparc__) || defined(__mips__) || defined(__x86_64__) \
+ || defined(__powerpc__) || defined(__s390__)
+typedef unsigned int autofs_wqt_t;
+#else
+typedef unsigned long autofs_wqt_t;
+#endif
+
+/* Packet types */
+#define autofs_ptype_missing    0       /* Missing entry (mount request) */
+#define autofs_ptype_expire     1       /* Expire entry (umount request) */
+
+struct autofs_packet_hdr {
+        int proto_version;              /* Protocol version */
+        int type;                       /* Type of packet */
+};
+
+struct autofs_packet_missing {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        int len;
+        char name[NAME_MAX+1];
+};      
+
+/* v3 expire (via ioctl) */
+struct autofs_packet_expire {
+        struct autofs_packet_hdr hdr;
+        int len;
+        char name[NAME_MAX+1];
+};
+
+#define AUTOFS_IOC_READY      _IO(0x93,0x60)
+#define AUTOFS_IOC_FAIL       _IO(0x93,0x61)
+#define AUTOFS_IOC_CATATONIC  _IO(0x93,0x62)
+#define AUTOFS_IOC_PROTOVER   _IOR(0x93,0x63,int)
+#define AUTOFS_IOC_SETTIMEOUT _IOWR(0x93,0x64,unsigned long)
+#define AUTOFS_IOC_EXPIRE     _IOR(0x93,0x65,struct autofs_packet_expire)
+
+#endif /* _LINUX_AUTO_FS_H */
diff --git a/include/linux/auto_fs4.h b/include/linux/auto_fs4.h
new file mode 100644
index 000000000000..d1c7b0ec7c22
--- /dev/null
+++ b/include/linux/auto_fs4.h
@@ -0,0 +1,57 @@
+/* -*- c -*-
+ * linux/include/linux/auto_fs4.h
+ *
+ * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ */
+
+#ifndef _LINUX_AUTO_FS4_H
+#define _LINUX_AUTO_FS4_H
+
+/* Include common v3 definitions */
+#include <linux/auto_fs.h>
+
+/* autofs v4 definitions */
+#undef AUTOFS_PROTO_VERSION
+#undef AUTOFS_MIN_PROTO_VERSION
+#undef AUTOFS_MAX_PROTO_VERSION
+
+#define AUTOFS_PROTO_VERSION            4
+#define AUTOFS_MIN_PROTO_VERSION        3
+#define AUTOFS_MAX_PROTO_VERSION        4
+
+#define AUTOFS_PROTO_SUBVERSION         5
+
+/* Mask for expire behaviour */
+#define AUTOFS_EXP_IMMEDIATE            1
+#define AUTOFS_EXP_LEAVES               2
+
+/* New message type */
+#define autofs_ptype_expire_multi       2       /* Expire entry (umount request) */
+
+/* v4 multi expire (via pipe) */
+struct autofs_packet_expire_multi {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        int len;
+        char name[NAME_MAX+1];
+};
+
+union autofs_packet_union {
+        struct autofs_packet_hdr hdr;
+        struct autofs_packet_missing missing;
+        struct autofs_packet_expire expire;
+        struct autofs_packet_expire_multi expire_multi;
+};
+
+#define AUTOFS_IOC_EXPIRE_MULTI         _IOW(0x93,0x66,int)
+#define AUTOFS_IOC_PROTOSUBVER          _IOR(0x93,0x67,int)
+#define AUTOFS_IOC_ASKREGHOST           _IOR(0x93,0x68,int)
+#define AUTOFS_IOC_TOGGLEREGHOST        _IOR(0x93,0x69,int)
+#define AUTOFS_IOC_ASKUMOUNT            _IOR(0x93,0x70,int)
+
+
+#endif /* _LINUX_AUTO_FS4_H */
diff --git a/include/linux/awe_voice.h b/include/linux/awe_voice.h
new file mode 100644
index 000000000000..da0e27de752c
--- /dev/null
+++ b/include/linux/awe_voice.h
@@ -0,0 +1,525 @@
+/*
+ * sound/awe_voice.h
+ *
+ * Voice information definitions for the low level driver for the 
+ * AWE32/SB32/AWE64 wave table synth.
+ *   version 0.4.4; Jan. 4, 2000
+ *
+ * Copyright (C) 1996-2000 Takashi Iwai
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef AWE_VOICE_H
+#define AWE_VOICE_H
+
+#ifndef SAMPLE_TYPE_AWE32
+#define SAMPLE_TYPE_AWE32       0x20
+#endif
+
+#ifndef _PATCHKEY
+#define _PATCHKEY(id) ((id<<8)|0xfd)
+#endif
+
+/*----------------------------------------------------------------
+ * patch information record
+ *----------------------------------------------------------------*/
+
+/* patch interface header: 16 bytes */
+typedef struct awe_patch_info {
+        short key;                      /* use AWE_PATCH here */
+#define AWE_PATCH       _PATCHKEY(0x07)
+
+        short device_no;                /* synthesizer number */
+        unsigned short sf_id;           /* file id (should be zero) */
+        short optarg;                   /* optional argument */
+        int len;                        /* data length (without this header) */
+
+        short type;                     /* patch operation type */
+#define AWE_LOAD_INFO           0       /* awe_voice_rec */
+#define AWE_LOAD_DATA           1       /* awe_sample_info */
+#define AWE_OPEN_PATCH          2       /* awe_open_parm */
+#define AWE_CLOSE_PATCH         3       /* none */
+#define AWE_UNLOAD_PATCH        4       /* none */
+#define AWE_REPLACE_DATA        5       /* awe_sample_info (optarg=#channels)*/
+#define AWE_MAP_PRESET          6       /* awe_voice_map */
+/*#define AWE_PROBE_INFO        7*/     /* awe_voice_map (pat only) */
+#define AWE_PROBE_DATA          8       /* optarg=sample */
+#define AWE_REMOVE_INFO         9       /* optarg=(bank<<8)|instr */
+#define AWE_LOAD_CHORUS_FX      0x10    /* awe_chorus_fx_rec (optarg=mode) */
+#define AWE_LOAD_REVERB_FX      0x11    /* awe_reverb_fx_rec (optarg=mode) */
+
+        short reserved;                 /* word alignment data */
+
+        /* the actual patch data begins after this */
+#if defined(AWE_COMPAT_030) && AWE_COMPAT_030
+        char data[0];
+#endif
+} awe_patch_info;
+
+/*#define AWE_PATCH_INFO_SIZE   16*/
+#define AWE_PATCH_INFO_SIZE     sizeof(awe_patch_info)
+
+
+/*----------------------------------------------------------------
+ * open patch
+ *----------------------------------------------------------------*/
+
+#define AWE_PATCH_NAME_LEN      32
+
+typedef struct _awe_open_parm {
+        unsigned short type;            /* sample type */
+#define AWE_PAT_TYPE_MISC       0
+#define AWE_PAT_TYPE_GM         1
+#define AWE_PAT_TYPE_GS         2
+#define AWE_PAT_TYPE_MT32       3
+#define AWE_PAT_TYPE_XG         4
+#define AWE_PAT_TYPE_SFX        5
+#define AWE_PAT_TYPE_GUS        6
+#define AWE_PAT_TYPE_MAP        7
+
+#define AWE_PAT_LOCKED          0x100   /* lock the samples */
+#define AWE_PAT_SHARED          0x200   /* sample is shared */
+
+        short reserved;
+        char name[AWE_PATCH_NAME_LEN];
+} awe_open_parm;
+
+/*#define AWE_OPEN_PARM_SIZE    28*/
+#define AWE_OPEN_PARM_SIZE      sizeof(awe_open_parm)
+
+
+/*----------------------------------------------------------------
+ * raw voice information record
+ *----------------------------------------------------------------*/
+
+/* wave table envelope & effect parameters to control EMU8000 */
+typedef struct _awe_voice_parm {
+        unsigned short moddelay;        /* modulation delay (0x8000) */
+        unsigned short modatkhld;       /* modulation attack & hold time (0x7f7f) */
+        unsigned short moddcysus;       /* modulation decay & sustain (0x7f7f) */
+        unsigned short modrelease;      /* modulation release time (0x807f) */
+        short modkeyhold, modkeydecay;  /* envelope change per key (not used) */
+        unsigned short voldelay;        /* volume delay (0x8000) */
+        unsigned short volatkhld;       /* volume attack & hold time (0x7f7f) */
+        unsigned short voldcysus;       /* volume decay & sustain (0x7f7f) */
+        unsigned short volrelease;      /* volume release time (0x807f) */
+        short volkeyhold, volkeydecay;  /* envelope change per key (not used) */
+        unsigned short lfo1delay;       /* LFO1 delay (0x8000) */
+        unsigned short lfo2delay;       /* LFO2 delay (0x8000) */
+        unsigned short pefe;            /* modulation pitch & cutoff (0x0000) */
+        unsigned short fmmod;           /* LFO1 pitch & cutoff (0x0000) */
+        unsigned short tremfrq;         /* LFO1 volume & freq (0x0000) */
+        unsigned short fm2frq2;         /* LFO2 pitch & freq (0x0000) */
+        unsigned char cutoff;           /* initial cutoff (0xff) */
+        unsigned char filterQ;          /* initial filter Q [0-15] (0x0) */
+        unsigned char chorus;           /* chorus send (0x00) */
+        unsigned char reverb;           /* reverb send (0x00) */
+        unsigned short reserved[4];     /* not used */
+} awe_voice_parm;
+
+typedef struct _awe_voice_parm_block {
+        unsigned short moddelay;        /* modulation delay (0x8000) */
+        unsigned char modatk, modhld;
+        unsigned char moddcy, modsus;
+        unsigned char modrel, moddummy;
+        short modkeyhold, modkeydecay;  /* envelope change per key (not used) */
+        unsigned short voldelay;        /* volume delay (0x8000) */
+        unsigned char volatk, volhld;
+        unsigned char voldcy, volsus;
+        unsigned char volrel, voldummy;
+        short volkeyhold, volkeydecay;  /* envelope change per key (not used) */
+        unsigned short lfo1delay;       /* LFO1 delay (0x8000) */
+        unsigned short lfo2delay;       /* LFO2 delay (0x8000) */
+        unsigned char env1fc, env1pit;
+        unsigned char lfo1fc, lfo1pit;
+        unsigned char lfo1freq, lfo1vol;
+        unsigned char lfo2freq, lfo2pit;
+        unsigned char cutoff;           /* initial cutoff (0xff) */
+        unsigned char filterQ;          /* initial filter Q [0-15] (0x0) */
+        unsigned char chorus;           /* chorus send (0x00) */
+        unsigned char reverb;           /* reverb send (0x00) */
+        unsigned short reserved[4];     /* not used */
+} awe_voice_parm_block;
+
+#define AWE_VOICE_PARM_SIZE     48
+
+
+/* wave table parameters: 92 bytes */
+typedef struct _awe_voice_info {
+        unsigned short sf_id;           /* file id (should be zero) */
+        unsigned short sample;          /* sample id */
+        int start, end;                 /* sample offset correction */
+        int loopstart, loopend;         /* loop offset correction */
+        short rate_offset;              /* sample rate pitch offset */
+        unsigned short mode;            /* sample mode */
+#define AWE_MODE_ROMSOUND               0x8000
+#define AWE_MODE_STEREO                 1
+#define AWE_MODE_LOOPING                2
+#define AWE_MODE_NORELEASE              4       /* obsolete */
+#define AWE_MODE_INIT_PARM              8
+
+        short root;                     /* midi root key */
+        short tune;                     /* pitch tuning (in cents) */
+        signed char low, high;          /* key note range */
+        signed char vellow, velhigh;    /* velocity range */
+        signed char fixkey, fixvel;     /* fixed key, velocity */
+        signed char pan, fixpan;        /* panning, fixed panning */
+        short exclusiveClass;           /* exclusive class (0 = none) */
+        unsigned char amplitude;        /* sample volume (127 max) */
+        unsigned char attenuation;      /* attenuation (0.375dB) */
+        short scaleTuning;              /* pitch scale tuning(%), normally 100 */
+        awe_voice_parm parm;            /* voice envelope parameters */
+        short index;                    /* internal index (set by driver) */
+} awe_voice_info;
+
+/*#define AWE_VOICE_INFO_SIZE   92*/
+#define AWE_VOICE_INFO_SIZE     sizeof(awe_voice_info)
+
+/*----------------------------------------------------------------*/
+
+/* The info entry of awe_voice_rec is changed from 0 to 1
+ * for some compilers refusing zero size array.
+ * Due to this change, sizeof(awe_voice_rec) becomes different
+ * from older versions.
+ * Use AWE_VOICE_REC_SIZE instead.
+ */
+
+/* instrument info header: 4 bytes */
+typedef struct _awe_voice_rec_hdr {
+        unsigned char bank;             /* midi bank number */
+        unsigned char instr;            /* midi preset number */
+        char nvoices;                   /* number of voices */
+        char write_mode;                /* write mode; normally 0 */
+#define AWE_WR_APPEND           0       /* append anyway */
+#define AWE_WR_EXCLUSIVE        1       /* skip if already exists */
+#define AWE_WR_REPLACE          2       /* replace if already exists */
+} awe_voice_rec_hdr;
+
+/*#define AWE_VOICE_REC_SIZE    4*/
+#define AWE_VOICE_REC_SIZE      sizeof(awe_voice_rec_hdr)
+
+/* the standard patch structure for one sample */
+typedef struct _awe_voice_rec_patch {
+        awe_patch_info          patch;
+        awe_voice_rec_hdr       hdr;
+        awe_voice_info          info;
+} awe_voice_rec_patch;
+
+
+/* obsolete data type */
+#if defined(AWE_COMPAT_030) && AWE_COMPAT_030
+#define AWE_INFOARRAY_SIZE      0
+#else
+#define AWE_INFOARRAY_SIZE      1
+#endif
+
+typedef struct _awe_voice_rec {
+        unsigned char bank;             /* midi bank number */
+        unsigned char instr;            /* midi preset number */
+        short nvoices;                  /* number of voices */
+        /* voice information follows here */
+        awe_voice_info info[AWE_INFOARRAY_SIZE];
+} awe_voice_rec;
+
+
+/*----------------------------------------------------------------
+ * sample wave information
+ *----------------------------------------------------------------*/
+
+/* wave table sample header: 32 bytes */
+typedef struct awe_sample_info {
+        unsigned short sf_id;           /* file id (should be zero) */
+        unsigned short sample;          /* sample id */
+        int start, end;                 /* start & end offset */
+        int loopstart, loopend;         /* loop start & end offset */
+        int size;                       /* size (0 = ROM) */
+        short checksum_flag;            /* use check sum = 1 */
+        unsigned short mode_flags;      /* mode flags */
+#define AWE_SAMPLE_8BITS        1       /* wave data is 8bits */
+#define AWE_SAMPLE_UNSIGNED     2       /* wave data is unsigned */
+#define AWE_SAMPLE_NO_BLANK     4       /* no blank loop is attached */
+#define AWE_SAMPLE_SINGLESHOT   8       /* single-shot w/o loop */
+#define AWE_SAMPLE_BIDIR_LOOP   16      /* bidirectional looping */
+#define AWE_SAMPLE_STEREO_LEFT  32      /* stereo left sound */
+#define AWE_SAMPLE_STEREO_RIGHT 64      /* stereo right sound */
+#define AWE_SAMPLE_REVERSE_LOOP 128     /* reverse looping */
+        unsigned int checksum;          /* check sum */
+#if defined(AWE_COMPAT_030) && AWE_COMPAT_030
+        unsigned short data[0];         /* sample data follows here */
+#endif
+} awe_sample_info;
+
+/*#define AWE_SAMPLE_INFO_SIZE  32*/
+#define AWE_SAMPLE_INFO_SIZE    sizeof(awe_sample_info)
+
+
+/*----------------------------------------------------------------
+ * voice preset mapping
+ *----------------------------------------------------------------*/
+
+typedef struct awe_voice_map {
+        int map_bank, map_instr, map_key;       /* key = -1 means all keys */
+        int src_bank, src_instr, src_key;
+} awe_voice_map;
+
+#define AWE_VOICE_MAP_SIZE      sizeof(awe_voice_map)
+
+
+/*----------------------------------------------------------------
+ * awe hardware controls
+ *----------------------------------------------------------------*/
+
+#define _AWE_DEBUG_MODE                 0x00
+#define _AWE_REVERB_MODE                0x01
+#define _AWE_CHORUS_MODE                0x02
+#define _AWE_REMOVE_LAST_SAMPLES        0x03
+#define _AWE_INITIALIZE_CHIP            0x04
+#define _AWE_SEND_EFFECT                0x05
+#define _AWE_TERMINATE_CHANNEL          0x06
+#define _AWE_TERMINATE_ALL              0x07
+#define _AWE_INITIAL_VOLUME             0x08
+#define _AWE_INITIAL_ATTEN      _AWE_INITIAL_VOLUME
+#define _AWE_RESET_CHANNEL              0x09
+#define _AWE_CHANNEL_MODE               0x0a
+#define _AWE_DRUM_CHANNELS              0x0b
+#define _AWE_MISC_MODE                  0x0c
+#define _AWE_RELEASE_ALL                0x0d
+#define _AWE_NOTEOFF_ALL                0x0e
+#define _AWE_CHN_PRESSURE               0x0f
+/*#define _AWE_GET_CURRENT_MODE         0x10*/
+#define _AWE_EQUALIZER                  0x11
+/*#define _AWE_GET_MISC_MODE            0x12*/
+/*#define _AWE_GET_FONTINFO             0x13*/
+
+#define _AWE_MODE_FLAG                  0x80
+#define _AWE_COOKED_FLAG                0x40    /* not supported */
+#define _AWE_MODE_VALUE_MASK            0x3F
+
+/*----------------------------------------------------------------*/
+
+#define _AWE_SET_CMD(p,dev,voice,cmd,p1,p2) \
+{((char*)(p))[0] = SEQ_PRIVATE;\
+ ((char*)(p))[1] = dev;\
+ ((char*)(p))[2] = _AWE_MODE_FLAG|(cmd);\
+ ((char*)(p))[3] = voice;\
+ ((unsigned short*)(p))[2] = p1;\
+ ((unsigned short*)(p))[3] = p2;}
+
+/* buffered access */
+#define _AWE_CMD(dev, voice, cmd, p1, p2) \
+{_SEQ_NEEDBUF(8);\
+ _AWE_SET_CMD(_seqbuf + _seqbufptr, dev, voice, cmd, p1, p2);\
+ _SEQ_ADVBUF(8);}
+
+/* direct access */
+#define _AWE_CMD_NOW(seqfd,dev,voice,cmd,p1,p2) \
+{struct seq_event_rec tmp;\
+ _AWE_SET_CMD(&tmp, dev, voice, cmd, p1, p2);\
+ ioctl(seqfd, SNDCTL_SEQ_OUTOFBAND, &tmp);}
+
+/*----------------------------------------------------------------*/
+
+/* set debugging mode */
+#define AWE_DEBUG_MODE(dev,p1)  _AWE_CMD(dev, 0, _AWE_DEBUG_MODE, p1, 0)
+/* set reverb mode; from 0 to 7 */
+#define AWE_REVERB_MODE(dev,p1) _AWE_CMD(dev, 0, _AWE_REVERB_MODE, p1, 0)
+/* set chorus mode; from 0 to 7 */
+#define AWE_CHORUS_MODE(dev,p1) _AWE_CMD(dev, 0, _AWE_CHORUS_MODE, p1, 0)
+
+/* reset channel */
+#define AWE_RESET_CHANNEL(dev,ch) _AWE_CMD(dev, ch, _AWE_RESET_CHANNEL, 0, 0)
+#define AWE_RESET_CONTROL(dev,ch) _AWE_CMD(dev, ch, _AWE_RESET_CHANNEL, 1, 0)
+
+/* send an effect to all layers */
+#define AWE_SEND_EFFECT(dev,voice,type,value) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,type,value)
+#define AWE_ADD_EFFECT(dev,voice,type,value) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,((type)|0x80),value)
+#define AWE_UNSET_EFFECT(dev,voice,type) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,((type)|0x40),0)
+/* send an effect to a layer */
+#define AWE_SEND_LAYER_EFFECT(dev,voice,layer,type,value) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,((layer+1)<<8|(type)),value)
+#define AWE_ADD_LAYER_EFFECT(dev,voice,layer,type,value) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,((layer+1)<<8|(type)|0x80),value)
+#define AWE_UNSET_LAYER_EFFECT(dev,voice,layer,type) _AWE_CMD(dev,voice,_AWE_SEND_EFFECT,((layer+1)<<8|(type)|0x40),0)
+
+/* terminate sound on the channel/voice */
+#define AWE_TERMINATE_CHANNEL(dev,voice) _AWE_CMD(dev,voice,_AWE_TERMINATE_CHANNEL,0,0)
+/* terminate all sounds */
+#define AWE_TERMINATE_ALL(dev) _AWE_CMD(dev, 0, _AWE_TERMINATE_ALL, 0, 0)
+/* release all sounds (w/o sustain effect) */
+#define AWE_RELEASE_ALL(dev) _AWE_CMD(dev, 0, _AWE_RELEASE_ALL, 0, 0)
+/* note off all sounds (w sustain effect) */
+#define AWE_NOTEOFF_ALL(dev) _AWE_CMD(dev, 0, _AWE_NOTEOFF_ALL, 0, 0)
+
+/* set initial attenuation */
+#define AWE_INITIAL_VOLUME(dev,atten) _AWE_CMD(dev, 0, _AWE_INITIAL_VOLUME, atten, 0)
+#define AWE_INITIAL_ATTEN  AWE_INITIAL_VOLUME
+/* relative attenuation */
+#define AWE_SET_ATTEN(dev,atten)  _AWE_CMD(dev, 0, _AWE_INITIAL_VOLUME, atten, 1)
+
+/* set channel playing mode; mode=0/1/2 */
+#define AWE_SET_CHANNEL_MODE(dev,mode) _AWE_CMD(dev, 0, _AWE_CHANNEL_MODE, mode, 0)
+#define AWE_PLAY_INDIRECT       0       /* indirect voice mode (default) */
+#define AWE_PLAY_MULTI          1       /* multi note voice mode */
+#define AWE_PLAY_DIRECT         2       /* direct single voice mode */
+#define AWE_PLAY_MULTI2         3       /* sequencer2 mode; used internally */
+
+/* set drum channel mask; channels is 32bit long value */
+#define AWE_DRUM_CHANNELS(dev,channels) _AWE_CMD(dev, 0, _AWE_DRUM_CHANNELS, ((channels) & 0xffff), ((channels) >> 16))
+
+/* set bass and treble control; values are from 0 to 11 */
+#define AWE_EQUALIZER(dev,bass,treble) _AWE_CMD(dev, 0, _AWE_EQUALIZER, bass, treble)
+
+/* remove last loaded samples */
+#define AWE_REMOVE_LAST_SAMPLES(seqfd,dev) _AWE_CMD_NOW(seqfd, dev, 0, _AWE_REMOVE_LAST_SAMPLES, 0, 0)
+/* initialize emu8000 chip */
+#define AWE_INITIALIZE_CHIP(seqfd,dev) _AWE_CMD_NOW(seqfd, dev, 0, _AWE_INITIALIZE_CHIP, 0, 0)
+
+/* set miscellaneous modes; meta command */
+#define AWE_MISC_MODE(dev,mode,value) _AWE_CMD(dev, 0, _AWE_MISC_MODE, mode, value)
+/* exclusive sound off; 1=off */
+#define AWE_EXCLUSIVE_SOUND(dev,mode) AWE_MISC_MODE(dev,AWE_MD_EXCLUSIVE_SOUND,mode)
+/* default GUS bank number */
+#define AWE_SET_GUS_BANK(dev,bank) AWE_MISC_MODE(dev,AWE_MD_GUS_BANK,bank)
+/* change panning position in realtime; 0=don't 1=do */
+#define AWE_REALTIME_PAN(dev,mode) AWE_MISC_MODE(dev,AWE_MD_REALTIME_PAN,mode)
+
+/* extended pressure controls; not portable with other sound drivers */
+#define AWE_KEY_PRESSURE(dev,ch,note,vel) SEQ_START_NOTE(dev,ch,(note)+128,vel)
+#define AWE_CHN_PRESSURE(dev,ch,vel) _AWE_CMD(dev,ch,_AWE_CHN_PRESSURE,vel,0)
+
+/*----------------------------------------------------------------*/
+
+/* reverb mode parameters */
+#define AWE_REVERB_ROOM1        0
+#define AWE_REVERB_ROOM2        1
+#define AWE_REVERB_ROOM3        2
+#define AWE_REVERB_HALL1        3
+#define AWE_REVERB_HALL2        4
+#define AWE_REVERB_PLATE        5
+#define AWE_REVERB_DELAY        6
+#define AWE_REVERB_PANNINGDELAY 7
+#define AWE_REVERB_PREDEFINED   8
+/* user can define reverb modes up to 32 */
+#define AWE_REVERB_NUMBERS      32
+
+typedef struct awe_reverb_fx_rec {
+        unsigned short parms[28];
+} awe_reverb_fx_rec;
+
+/*----------------------------------------------------------------*/
+
+/* chorus mode parameters */
+#define AWE_CHORUS_1            0
+#define AWE_CHORUS_2            1
+#define AWE_CHORUS_3            2
+#define AWE_CHORUS_4            3
+#define AWE_CHORUS_FEEDBACK     4
+#define AWE_CHORUS_FLANGER      5
+#define AWE_CHORUS_SHORTDELAY   6
+#define AWE_CHORUS_SHORTDELAY2  7
+#define AWE_CHORUS_PREDEFINED   8
+/* user can define chorus modes up to 32 */
+#define AWE_CHORUS_NUMBERS      32
+
+typedef struct awe_chorus_fx_rec {
+        unsigned short feedback;        /* feedback level (0xE600-0xE6FF) */
+        unsigned short delay_offset;    /* delay (0-0x0DA3) [1/44100 sec] */
+        unsigned short lfo_depth;       /* LFO depth (0xBC00-0xBCFF) */
+        unsigned int delay;     /* right delay (0-0xFFFFFFFF) [1/256/44100 sec] */
+        unsigned int lfo_freq;          /* LFO freq LFO freq (0-0xFFFFFFFF) */
+} awe_chorus_fx_rec;
+
+/*----------------------------------------------------------------*/
+
+/* misc mode types */
+enum {
+/* 0*/  AWE_MD_EXCLUSIVE_OFF,   /* obsolete */
+/* 1*/  AWE_MD_EXCLUSIVE_ON,    /* obsolete */
+/* 2*/  AWE_MD_VERSION,         /* read only */
+/* 3*/  AWE_MD_EXCLUSIVE_SOUND, /* 0/1: exclusive note on (default=1) */
+/* 4*/  AWE_MD_REALTIME_PAN,    /* 0/1: do realtime pan change (default=1) */
+/* 5*/  AWE_MD_GUS_BANK,        /* bank number for GUS patches (default=0) */
+/* 6*/  AWE_MD_KEEP_EFFECT,     /* 0/1: keep effect values, (default=0) */
+/* 7*/  AWE_MD_ZERO_ATTEN,      /* attenuation of max volume (default=32) */
+/* 8*/  AWE_MD_CHN_PRIOR,       /* 0/1: set MIDI channel priority mode (default=1) */
+/* 9*/  AWE_MD_MOD_SENSE,       /* integer: modwheel sensitivity (def=18) */
+/*10*/  AWE_MD_DEF_PRESET,      /* integer: default preset number (def=0) */
+/*11*/  AWE_MD_DEF_BANK,        /* integer: default bank number (def=0) */
+/*12*/  AWE_MD_DEF_DRUM,        /* integer: default drumset number (def=0) */
+/*13*/  AWE_MD_TOGGLE_DRUM_BANK, /* 0/1: toggle drum flag with bank# (def=0) */
+/*14*/  AWE_MD_NEW_VOLUME_CALC, /* 0/1: volume calculation mode (def=1) */
+/*15*/  AWE_MD_CHORUS_MODE,     /* integer: chorus mode (def=2) */
+/*16*/  AWE_MD_REVERB_MODE,     /* integer: chorus mode (def=4) */
+/*17*/  AWE_MD_BASS_LEVEL,      /* integer: bass level (def=5) */
+/*18*/  AWE_MD_TREBLE_LEVEL,    /* integer: treble level (def=9) */
+/*19*/  AWE_MD_DEBUG_MODE,      /* integer: debug level (def=0) */
+/*20*/  AWE_MD_PAN_EXCHANGE,    /* 0/1: exchange panning direction (def=0) */
+        AWE_MD_END,
+};
+
+/*----------------------------------------------------------------*/
+
+/* effect parameters */
+enum {
+
+/* modulation envelope parameters */
+/* 0*/  AWE_FX_ENV1_DELAY,      /* WORD: ENVVAL */
+/* 1*/  AWE_FX_ENV1_ATTACK,     /* BYTE: up ATKHLD */
+/* 2*/  AWE_FX_ENV1_HOLD,       /* BYTE: lw ATKHLD */
+/* 3*/  AWE_FX_ENV1_DECAY,      /* BYTE: lw DCYSUS */
+/* 4*/  AWE_FX_ENV1_RELEASE,    /* BYTE: lw DCYSUS */
+/* 5*/  AWE_FX_ENV1_SUSTAIN,    /* BYTE: up DCYSUS */
+/* 6*/  AWE_FX_ENV1_PITCH,      /* BYTE: up PEFE */
+/* 7*/  AWE_FX_ENV1_CUTOFF,     /* BYTE: lw PEFE */
+
+/* volume envelope parameters */
+/* 8*/  AWE_FX_ENV2_DELAY,      /* WORD: ENVVOL */
+/* 9*/  AWE_FX_ENV2_ATTACK,     /* BYTE: up ATKHLDV */
+/*10*/  AWE_FX_ENV2_HOLD,       /* BYTE: lw ATKHLDV */
+/*11*/  AWE_FX_ENV2_DECAY,      /* BYTE: lw DCYSUSV */
+/*12*/  AWE_FX_ENV2_RELEASE,    /* BYTE: lw DCYSUSV */
+/*13*/  AWE_FX_ENV2_SUSTAIN,    /* BYTE: up DCYSUSV */
+        
+/* LFO1 (tremolo & vibrato) parameters */
+/*14*/  AWE_FX_LFO1_DELAY,      /* WORD: LFO1VAL */
+/*15*/  AWE_FX_LFO1_FREQ,       /* BYTE: lo TREMFRQ */
+/*16*/  AWE_FX_LFO1_VOLUME,     /* BYTE: up TREMFRQ */
+/*17*/  AWE_FX_LFO1_PITCH,      /* BYTE: up FMMOD */
+/*18*/  AWE_FX_LFO1_CUTOFF,     /* BYTE: lo FMMOD */
+
+/* LFO2 (vibrato) parameters */
+/*19*/  AWE_FX_LFO2_DELAY,      /* WORD: LFO2VAL */
+/*20*/  AWE_FX_LFO2_FREQ,       /* BYTE: lo FM2FRQ2 */
+/*21*/  AWE_FX_LFO2_PITCH,      /* BYTE: up FM2FRQ2 */
+
+/* Other overall effect parameters */
+/*22*/  AWE_FX_INIT_PITCH,      /* SHORT: pitch offset */
+/*23*/  AWE_FX_CHORUS,          /* BYTE: chorus effects send (0-255) */
+/*24*/  AWE_FX_REVERB,          /* BYTE: reverb effects send (0-255) */
+/*25*/  AWE_FX_CUTOFF,          /* BYTE: up IFATN */
+/*26*/  AWE_FX_FILTERQ,         /* BYTE: up CCCA */
+
+/* Sample / loop offset changes */
+/*27*/  AWE_FX_SAMPLE_START,    /* SHORT: offset */
+/*28*/  AWE_FX_LOOP_START,      /* SHORT: offset */
+/*29*/  AWE_FX_LOOP_END,        /* SHORT: offset */
+/*30*/  AWE_FX_COARSE_SAMPLE_START,     /* SHORT: upper word offset */
+/*31*/  AWE_FX_COARSE_LOOP_START,       /* SHORT: upper word offset */
+/*32*/  AWE_FX_COARSE_LOOP_END,         /* SHORT: upper word offset */
+/*33*/  AWE_FX_ATTEN,           /* BYTE: lo IFATN */
+
+        AWE_FX_END,
+};
+
+#endif /* AWE_VOICE_H */
diff --git a/include/linux/ax25.h b/include/linux/ax25.h
new file mode 100644
index 000000000000..56c11f0dbd80
--- /dev/null
+++ b/include/linux/ax25.h
@@ -0,0 +1,116 @@
+/*
+ * These are the public elements of the Linux kernel AX.25 code. A similar
+ * file netrom.h exists for the NET/ROM protocol.
+ */
+
+#ifndef AX25_KERNEL_H
+#define AX25_KERNEL_H
+
+#include <linux/socket.h>
+
+#define AX25_MTU        256
+#define AX25_MAX_DIGIS  8
+
+#define AX25_WINDOW     1
+#define AX25_T1         2
+#define AX25_N2         3
+#define AX25_T3         4
+#define AX25_T2         5
+#define AX25_BACKOFF    6
+#define AX25_EXTSEQ     7
+#define AX25_PIDINCL    8
+#define AX25_IDLE       9
+#define AX25_PACLEN     10
+#define AX25_IAMDIGI    12
+
+#define AX25_KILL       99
+
+#define SIOCAX25GETUID          (SIOCPROTOPRIVATE+0)
+#define SIOCAX25ADDUID          (SIOCPROTOPRIVATE+1)
+#define SIOCAX25DELUID          (SIOCPROTOPRIVATE+2)
+#define SIOCAX25NOUID           (SIOCPROTOPRIVATE+3)
+#define SIOCAX25OPTRT           (SIOCPROTOPRIVATE+7)
+#define SIOCAX25CTLCON          (SIOCPROTOPRIVATE+8)
+#define SIOCAX25GETINFOOLD      (SIOCPROTOPRIVATE+9)
+#define SIOCAX25ADDFWD          (SIOCPROTOPRIVATE+10)
+#define SIOCAX25DELFWD          (SIOCPROTOPRIVATE+11)
+#define SIOCAX25DEVCTL          (SIOCPROTOPRIVATE+12)
+#define SIOCAX25GETINFO         (SIOCPROTOPRIVATE+13)
+
+#define AX25_SET_RT_IPMODE      2
+
+#define AX25_NOUID_DEFAULT      0
+#define AX25_NOUID_BLOCK        1
+
+typedef struct {
+        char            ax25_call[7];   /* 6 call + SSID (shifted ascii!) */
+} ax25_address;
+
+struct sockaddr_ax25 {
+        sa_family_t     sax25_family;
+        ax25_address    sax25_call;
+        int             sax25_ndigis;
+        /* Digipeater ax25_address sets follow */
+};
+
+#define sax25_uid       sax25_ndigis
+
+struct full_sockaddr_ax25 {
+        struct sockaddr_ax25 fsa_ax25;
+        ax25_address    fsa_digipeater[AX25_MAX_DIGIS];
+};
+
+struct ax25_routes_struct {
+        ax25_address    port_addr;
+        ax25_address    dest_addr;
+        unsigned char   digi_count;
+        ax25_address    digi_addr[AX25_MAX_DIGIS];
+};
+
+struct ax25_route_opt_struct {
+        ax25_address    port_addr;
+        ax25_address    dest_addr;
+        int             cmd;
+        int             arg;
+};
+
+struct ax25_ctl_struct {
+        ax25_address            port_addr;
+        ax25_address            source_addr;
+        ax25_address            dest_addr;
+        unsigned int            cmd;
+        unsigned long           arg;
+        unsigned char           digi_count;
+        ax25_address            digi_addr[AX25_MAX_DIGIS];
+};
+
+/* this will go away. Please do not export to user land */
+struct ax25_info_struct_deprecated {
+        unsigned int    n2, n2count;
+        unsigned int    t1, t1timer;
+        unsigned int    t2, t2timer;
+        unsigned int    t3, t3timer;
+        unsigned int    idle, idletimer;
+        unsigned int    state;
+        unsigned int    rcv_q, snd_q;
+};
+
+struct ax25_info_struct {
+        unsigned int    n2, n2count;
+        unsigned int    t1, t1timer;
+        unsigned int    t2, t2timer;
+        unsigned int    t3, t3timer;
+        unsigned int    idle, idletimer;
+        unsigned int    state;
+        unsigned int    rcv_q, snd_q;
+        unsigned int    vs, vr, va, vs_max;
+        unsigned int    paclen;
+        unsigned int    window;
+};
+
+struct ax25_fwd_struct {
+        ax25_address    port_from;
+        ax25_address    port_to;
+};
+
+#endif
diff --git a/include/linux/b1lli.h b/include/linux/b1lli.h
new file mode 100644
index 000000000000..713f712685d3
--- /dev/null
+++ b/include/linux/b1lli.h
@@ -0,0 +1,73 @@
+/* $Id: b1lli.h,v 1.8.8.3 2001/09/23 22:25:05 kai Exp $
+ *
+ * ISDN lowlevel-module for AVM B1-card.
+ *
+ * Copyright 1996 by Carsten Paeth (calle@calle.in-berlin.de)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef _B1LLI_H_
+#define _B1LLI_H_
+/*
+ * struct for loading t4 file 
+ */
+typedef struct avmb1_t4file {
+        int len;
+        unsigned char *data;
+} avmb1_t4file;
+
+typedef struct avmb1_loaddef {
+        int contr;
+        avmb1_t4file t4file;
+} avmb1_loaddef;
+
+typedef struct avmb1_loadandconfigdef {
+        int contr;
+        avmb1_t4file t4file;
+        avmb1_t4file t4config; 
+} avmb1_loadandconfigdef;
+
+typedef struct avmb1_resetdef {
+        int contr;
+} avmb1_resetdef;
+
+typedef struct avmb1_getdef {
+        int contr;
+        int cardtype;
+        int cardstate;
+} avmb1_getdef;
+
+/*
+ * struct for adding new cards 
+ */
+typedef struct avmb1_carddef {
+        int port;
+        int irq;
+} avmb1_carddef;
+
+#define AVM_CARDTYPE_B1         0
+#define AVM_CARDTYPE_T1         1
+#define AVM_CARDTYPE_M1         2
+#define AVM_CARDTYPE_M2         3
+
+typedef struct avmb1_extcarddef {
+        int port;
+        int irq;
+        int cardtype;
+        int cardnr;  /* for HEMA/T1 */
+} avmb1_extcarddef;
+
+#define AVMB1_LOAD              0       /* load image to card */
+#define AVMB1_ADDCARD           1       /* add a new card - OBSOLETE */
+#define AVMB1_RESETCARD         2       /* reset a card */
+#define AVMB1_LOAD_AND_CONFIG   3       /* load image and config to card */
+#define AVMB1_ADDCARD_WITH_TYPE 4       /* add a new card, with cardtype */
+#define AVMB1_GET_CARDINFO      5       /* get cardtype */
+#define AVMB1_REMOVECARD        6       /* remove a card - OBSOLETE */
+
+#define AVMB1_REGISTERCARD_IS_OBSOLETE
+
+#endif                          /* _B1LLI_H_ */
diff --git a/include/linux/b1pcmcia.h b/include/linux/b1pcmcia.h
new file mode 100644
index 000000000000..12a867c6061e
--- /dev/null
+++ b/include/linux/b1pcmcia.h
@@ -0,0 +1,21 @@
+/* $Id: b1pcmcia.h,v 1.1.8.2 2001/09/23 22:25:05 kai Exp $
+ *
+ * Exported functions of module b1pcmcia to be called by
+ * avm_cs card services module.
+ *
+ * Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef _B1PCMCIA_H_
+#define _B1PCMCIA_H_
+
+int b1pcmcia_addcard_b1(unsigned int port, unsigned irq);
+int b1pcmcia_addcard_m1(unsigned int port, unsigned irq);
+int b1pcmcia_addcard_m2(unsigned int port, unsigned irq);
+int b1pcmcia_delcard(unsigned int port, unsigned irq);
+
+#endif  /* _B1PCMCIA_H_ */
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
new file mode 100644
index 000000000000..f7a1390d67f5
--- /dev/null
+++ b/include/linux/backing-dev.h
@@ -0,0 +1,104 @@
+/*
+ * include/linux/backing-dev.h
+ *
+ * low-level device information and state which is propagated up through
+ * to high-level code.
+ */
+
+#ifndef _LINUX_BACKING_DEV_H
+#define _LINUX_BACKING_DEV_H
+
+#include <asm/atomic.h>
+
+/*
+ * Bits in backing_dev_info.state
+ */
+enum bdi_state {
+        BDI_pdflush,            /* A pdflush thread is working this device */
+        BDI_write_congested,    /* The write queue is getting full */
+        BDI_read_congested,     /* The read queue is getting full */
+        BDI_unused,             /* Available bits start here */
+};
+
+typedef int (congested_fn)(void *, int);
+
+struct backing_dev_info {
+        unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
+        unsigned long state;    /* Always use atomic bitops on this */
+        unsigned int capabilities; /* Device capabilities */
+        congested_fn *congested_fn; /* Function pointer if device is md/dm */
+        void *congested_data;   /* Pointer to aux data for congested func */
+        void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
+        void *unplug_io_data;
+};
+
+
+/*
+ * Flags in backing_dev_info::capability
+ * - The first two flags control whether dirty pages will contribute to the
+ *   VM's accounting and whether writepages() should be called for dirty pages
+ *   (something that would not, for example, be appropriate for ramfs)
+ * - These flags let !MMU mmap() govern direct device mapping vs immediate
+ *   copying more easily for MAP_PRIVATE, especially for ROM filesystems
+ */
+#define BDI_CAP_NO_ACCT_DIRTY   0x00000001      /* Dirty pages shouldn't contribute to accounting */
+#define BDI_CAP_NO_WRITEBACK    0x00000002      /* Don't write pages back */
+#define BDI_CAP_MAP_COPY        0x00000004      /* Copy can be mapped (MAP_PRIVATE) */
+#define BDI_CAP_MAP_DIRECT      0x00000008      /* Can be mapped directly (MAP_SHARED) */
+#define BDI_CAP_READ_MAP        0x00000010      /* Can be mapped for reading */
+#define BDI_CAP_WRITE_MAP       0x00000020      /* Can be mapped for writing */
+#define BDI_CAP_EXEC_MAP        0x00000040      /* Can be mapped for execution */
+#define BDI_CAP_VMFLAGS \
+        (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
+
+#if defined(VM_MAYREAD) && \
+        (BDI_CAP_READ_MAP != VM_MAYREAD || \
+         BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
+         BDI_CAP_EXEC_MAP != VM_MAYEXEC)
+#error please change backing_dev_info::capabilities flags
+#endif
+
+extern struct backing_dev_info default_backing_dev_info;
+void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
+
+int writeback_acquire(struct backing_dev_info *bdi);
+int writeback_in_progress(struct backing_dev_info *bdi);
+void writeback_release(struct backing_dev_info *bdi);
+
+static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
+{
+        if (bdi->congested_fn)
+                return bdi->congested_fn(bdi->congested_data, bdi_bits);
+        return (bdi->state & bdi_bits);
+}
+
+static inline int bdi_read_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << BDI_read_congested);
+}
+
+static inline int bdi_write_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << BDI_write_congested);
+}
+
+static inline int bdi_rw_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, (1 << BDI_read_congested)|
+                                  (1 << BDI_write_congested));
+}
+
+#define bdi_cap_writeback_dirty(bdi) \
+        (!((bdi)->capabilities & BDI_CAP_NO_WRITEBACK))
+
+#define bdi_cap_account_dirty(bdi) \
+        (!((bdi)->capabilities & BDI_CAP_NO_ACCT_DIRTY))
+
+#define mapping_cap_writeback_dirty(mapping) \
+        bdi_cap_writeback_dirty((mapping)->backing_dev_info)
+
+#define mapping_cap_account_dirty(mapping) \
+        bdi_cap_account_dirty((mapping)->backing_dev_info)
+
+
+#endif          /* _LINUX_BACKING_DEV_H */
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
new file mode 100644
index 000000000000..bb9e54322322
--- /dev/null
+++ b/include/linux/backlight.h
@@ -0,0 +1,57 @@
+/*
+ * Backlight Lowlevel Control Abstraction
+ *
+ * Copyright (C) 2003,2004 Hewlett-Packard Company
+ *
+ */
+
+#ifndef _LINUX_BACKLIGHT_H
+#define _LINUX_BACKLIGHT_H
+
+#include <linux/device.h>
+#include <linux/notifier.h>
+
+struct backlight_device;
+struct fb_info;
+
+/* This structure defines all the properties of a backlight
+   (usually attached to a LCD). */
+struct backlight_properties {
+        /* Owner module */
+        struct module *owner;
+        /* Get the backlight power status (0: full on, 1..3: power saving
+           modes; 4: full off), see FB_BLANK_XXX */
+        int (*get_power)(struct backlight_device *);
+        /* Enable or disable power to the LCD (0: on; 4: off, see FB_BLANK_XXX) */
+        int (*set_power)(struct backlight_device *, int power);
+        /* Maximal value for brightness (read-only) */
+        int max_brightness;
+        /* Get current backlight brightness */
+        int (*get_brightness)(struct backlight_device *);
+        /* Set backlight brightness (0..max_brightness) */
+        int (*set_brightness)(struct backlight_device *, int brightness);
+        /* Check if given framebuffer device is the one bound to this backlight;
+           return 0 if not, !=0 if it is. If NULL, backlight always matches the fb. */
+        int (*check_fb)(struct fb_info *);
+};
+
+struct backlight_device {
+        /* This protects the 'props' field. If 'props' is NULL, the driver that
+           registered this device has been unloaded, and if class_get_devdata()
+           points to something in the body of that driver, it is also invalid. */
+        struct semaphore sem;
+        /* If this is NULL, the backing module is unloaded */
+        struct backlight_properties *props;
+        /* The framebuffer notifier block */
+        struct notifier_block fb_notif;
+        /* The class device structure */
+        struct class_device class_dev;
+};
+
+extern struct backlight_device *backlight_device_register(const char *name,
+        void *devdata, struct backlight_properties *bp);
+extern void backlight_device_unregister(struct backlight_device *bd);
+
+#define to_backlight_device(obj) container_of(obj, struct backlight_device, class_dev)
+
+#endif
diff --git a/include/linux/baycom.h b/include/linux/baycom.h
new file mode 100644
index 000000000000..81249e029dad
--- /dev/null
+++ b/include/linux/baycom.h
@@ -0,0 +1,39 @@
+/*
+ * The Linux BAYCOM driver for the Baycom serial 1200 baud modem
+ * and the parallel 9600 baud modem
+ * (C) 1997-1998 by Thomas Sailer, HB9JNX/AE4WA
+ */
+
+#ifndef _BAYCOM_H
+#define _BAYCOM_H
+
+/* -------------------------------------------------------------------- */
+/*
+ * structs for the IOCTL commands
+ */
+
+struct baycom_debug_data {
+        unsigned long debug1;
+        unsigned long debug2;
+        long debug3;
+};
+
+struct baycom_ioctl {
+        int cmd;
+        union {
+                struct baycom_debug_data dbg;
+        } data;
+};
+
+/* -------------------------------------------------------------------- */
+
+/*
+ * ioctl values change for baycom
+ */
+#define BAYCOMCTL_GETDEBUG       0x92
+
+/* -------------------------------------------------------------------- */
+
+#endif /* _BAYCOM_H */
+
+/* --------------------------------------------------------------------- */
diff --git a/include/linux/bcd.h b/include/linux/bcd.h
new file mode 100644
index 000000000000..c545308125b0
--- /dev/null
+++ b/include/linux/bcd.h
@@ -0,0 +1,20 @@
+/* Permission is hereby granted to copy, modify and redistribute this code
+ * in terms of the GNU Library General Public License, Version 2 or later,
+ * at your option.
+ */
+
+/* macros to translate to/from binary and binary-coded decimal (frequently
+ * found in RTC chips).
+ */
+
+#ifndef _BCD_H
+#define _BCD_H
+
+#define BCD2BIN(val)    (((val) & 0x0f) + ((val)>>4)*10)
+#define BIN2BCD(val)    ((((val)/10)<<4) + (val)%10)
+
+/* backwards compat */
+#define BCD_TO_BIN(val) ((val)=BCD2BIN(val))
+#define BIN_TO_BCD(val) ((val)=BIN2BCD(val))
+
+#endif /* _BCD_H */
diff --git a/include/linux/bfs_fs.h b/include/linux/bfs_fs.h
new file mode 100644
index 000000000000..f7f0913cd110
--- /dev/null
+++ b/include/linux/bfs_fs.h
@@ -0,0 +1,79 @@
+/*
+ *      include/linux/bfs_fs.h - BFS data structures on disk.
+ *      Copyright (C) 1999 Tigran Aivazian <tigran@veritas.com>
+ */
+
+#ifndef _LINUX_BFS_FS_H
+#define _LINUX_BFS_FS_H
+
+#define BFS_BSIZE_BITS          9
+#define BFS_BSIZE               (1<<BFS_BSIZE_BITS)
+
+#define BFS_MAGIC               0x1BADFACE
+#define BFS_ROOT_INO            2
+#define BFS_INODES_PER_BLOCK    8
+
+/* SVR4 vnode type values (bfs_inode->i_vtype) */
+#define BFS_VDIR                2
+#define BFS_VREG                1
+
+/* BFS inode layout on disk */
+struct bfs_inode {
+        __u16 i_ino;
+        __u16 i_unused;
+        __u32 i_sblock;
+        __u32 i_eblock;
+        __u32 i_eoffset;
+        __u32 i_vtype;
+        __u32 i_mode;
+        __s32 i_uid;
+        __s32 i_gid;
+        __u32 i_nlink;
+        __u32 i_atime;
+        __u32 i_mtime;
+        __u32 i_ctime;
+        __u32 i_padding[4];
+};
+
+#define BFS_NAMELEN             14      
+#define BFS_DIRENT_SIZE         16
+#define BFS_DIRS_PER_BLOCK      32
+
+struct bfs_dirent {
+        __u16 ino;
+        char name[BFS_NAMELEN];
+};
+
+/* BFS superblock layout on disk */
+struct bfs_super_block {
+        __u32 s_magic;
+        __u32 s_start;
+        __u32 s_end;
+        __s32 s_from;
+        __s32 s_to;
+        __s32 s_bfrom;
+        __s32 s_bto;
+        char  s_fsname[6];
+        char  s_volume[6];
+        __u32 s_padding[118];
+};
+
+#define BFS_NZFILESIZE(ip) \
+        (((ip)->i_eoffset + 1) - (ip)->i_sblock * BFS_BSIZE)
+
+#define BFS_FILESIZE(ip) \
+        ((ip)->i_sblock == 0 ? 0 : BFS_NZFILESIZE(ip))
+
+#define BFS_FILEBLOCKS(ip) \
+        ((ip)->i_sblock == 0 ? 0 : ((ip)->i_eblock + 1) - (ip)->i_sblock)
+
+#define BFS_OFF2INO(offset) \
+        ((((offset) - BFS_BSIZE) / sizeof(struct bfs_inode)) + BFS_ROOT_INO)
+
+#define BFS_INO2OFF(ino) \
+        ((__u32)(((ino) - BFS_ROOT_INO) * sizeof(struct bfs_inode)) + BFS_BSIZE)
+
+#define BFS_UNCLEAN(bfs_sb, sb) \
+        ((bfs_sb->s_from != -1) && (bfs_sb->s_to != -1) && !(sb->s_flags & MS_RDONLY))
+
+#endif  /* _LINUX_BFS_FS_H */
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
new file mode 100644
index 000000000000..54f820832c73
--- /dev/null
+++ b/include/linux/binfmts.h
@@ -0,0 +1,87 @@
+#ifndef _LINUX_BINFMTS_H
+#define _LINUX_BINFMTS_H
+
+#include <linux/capability.h>
+
+struct pt_regs;
+
+/*
+ * MAX_ARG_PAGES defines the number of pages allocated for arguments
+ * and envelope for the new program. 32 should suffice, this gives
+ * a maximum env+arg of 128kB w/4KB pages!
+ */
+#define MAX_ARG_PAGES 32
+
+/* sizeof(linux_binprm->buf) */
+#define BINPRM_BUF_SIZE 128
+
+#ifdef __KERNEL__
+
+/*
+ * This structure is used to hold the arguments that are used when loading binaries.
+ */
+struct linux_binprm{
+        char buf[BINPRM_BUF_SIZE];
+        struct page *page[MAX_ARG_PAGES];
+        struct mm_struct *mm;
+        unsigned long p; /* current top of mem */
+        int sh_bang;
+        struct file * file;
+        int e_uid, e_gid;
+        kernel_cap_t cap_inheritable, cap_permitted, cap_effective;
+        void *security;
+        int argc, envc;
+        char * filename;        /* Name of binary as seen by procps */
+        char * interp;          /* Name of the binary really executed. Most
+                                   of the time same as filename, but could be
+                                   different for binfmt_{misc,script} */
+        unsigned interp_flags;
+        unsigned interp_data;
+        unsigned long loader, exec;
+};
+
+#define BINPRM_FLAGS_ENFORCE_NONDUMP_BIT 0
+#define BINPRM_FLAGS_ENFORCE_NONDUMP (1 << BINPRM_FLAGS_ENFORCE_NONDUMP_BIT)
+
+/* fd of the binary should be passed to the interpreter */
+#define BINPRM_FLAGS_EXECFD_BIT 1
+#define BINPRM_FLAGS_EXECFD (1 << BINPRM_FLAGS_EXECFD_BIT)
+
+
+/*
+ * This structure defines the functions that are used to load the binary formats that
+ * linux accepts.
+ */
+struct linux_binfmt {
+        struct linux_binfmt * next;
+        struct module *module;
+        int (*load_binary)(struct linux_binprm *, struct  pt_regs * regs);
+        int (*load_shlib)(struct file *);
+        int (*core_dump)(long signr, struct pt_regs * regs, struct file * file);
+        unsigned long min_coredump;     /* minimal dump size */
+};
+
+extern int register_binfmt(struct linux_binfmt *);
+extern int unregister_binfmt(struct linux_binfmt *);
+
+extern int prepare_binprm(struct linux_binprm *);
+extern void remove_arg_zero(struct linux_binprm *);
+extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
+extern int flush_old_exec(struct linux_binprm * bprm);
+
+/* Stack area protections */
+#define EXSTACK_DEFAULT   0     /* Whatever the arch defaults to */
+#define EXSTACK_DISABLE_X 1     /* Disable executable stacks */
+#define EXSTACK_ENABLE_X  2     /* Enable executable stacks */
+
+extern int setup_arg_pages(struct linux_binprm * bprm,
+                           unsigned long stack_top,
+                           int executable_stack);
+extern int copy_strings(int argc,char __user * __user * argv,struct linux_binprm *bprm); 
+extern int copy_strings_kernel(int argc,char ** argv,struct linux_binprm *bprm);
+extern void compute_creds(struct linux_binprm *binprm);
+extern int do_coredump(long signr, int exit_code, struct pt_regs * regs);
+extern int set_binfmt(struct linux_binfmt *new);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_BINFMTS_H */
diff --git a/include/linux/bio.h b/include/linux/bio.h
new file mode 100644
index 000000000000..038022763f09
--- /dev/null
+++ b/include/linux/bio.h
@@ -0,0 +1,339 @@
+/*
+ * 2.5 block I/O model
+ *
+ * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public Licens
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
+ */
+#ifndef __LINUX_BIO_H
+#define __LINUX_BIO_H
+
+#include <linux/highmem.h>
+#include <linux/mempool.h>
+
+/* Platforms may set this to teach the BIO layer about IOMMU hardware. */
+#include <asm/io.h>
+
+#if defined(BIO_VMERGE_MAX_SIZE) && defined(BIO_VMERGE_BOUNDARY)
+#define BIOVEC_VIRT_START_SIZE(x) (bvec_to_phys(x) & (BIO_VMERGE_BOUNDARY - 1))
+#define BIOVEC_VIRT_OVERSIZE(x) ((x) > BIO_VMERGE_MAX_SIZE)
+#else
+#define BIOVEC_VIRT_START_SIZE(x)       0
+#define BIOVEC_VIRT_OVERSIZE(x)         0
+#endif
+
+#ifndef BIO_VMERGE_BOUNDARY
+#define BIO_VMERGE_BOUNDARY     0
+#endif
+
+#define BIO_DEBUG
+
+#ifdef BIO_DEBUG
+#define BIO_BUG_ON      BUG_ON
+#else
+#define BIO_BUG_ON
+#endif
+
+#define BIO_MAX_PAGES           (256)
+#define BIO_MAX_SIZE            (BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
+#define BIO_MAX_SECTORS         (BIO_MAX_SIZE >> 9)
+
+/*
+ * was unsigned short, but we might as well be ready for > 64kB I/O pages
+ */
+struct bio_vec {
+        struct page     *bv_page;
+        unsigned int    bv_len;
+        unsigned int    bv_offset;
+};
+
+struct bio_set;
+struct bio;
+typedef int (bio_end_io_t) (struct bio *, unsigned int, int);
+typedef void (bio_destructor_t) (struct bio *);
+
+/*
+ * main unit of I/O for the block layer and lower layers (ie drivers and
+ * stacking drivers)
+ */
+struct bio {
+        sector_t                bi_sector;
+        struct bio              *bi_next;       /* request queue link */
+        struct block_device     *bi_bdev;
+        unsigned long           bi_flags;       /* status, command, etc */
+        unsigned long           bi_rw;          /* bottom bits READ/WRITE,
+                                                 * top bits priority
+                                                 */
+
+        unsigned short          bi_vcnt;        /* how many bio_vec's */
+        unsigned short          bi_idx;         /* current index into bvl_vec */
+
+        /* Number of segments in this BIO after
+         * physical address coalescing is performed.
+         */
+        unsigned short          bi_phys_segments;
+
+        /* Number of segments after physical and DMA remapping
+         * hardware coalescing is performed.
+         */
+        unsigned short          bi_hw_segments;
+
+        unsigned int            bi_size;        /* residual I/O count */
+
+        /*
+         * To keep track of the max hw size, we account for the
+         * sizes of the first and last virtually mergeable segments
+         * in this bio
+         */
+        unsigned int            bi_hw_front_size;
+        unsigned int            bi_hw_back_size;
+
+        unsigned int            bi_max_vecs;    /* max bvl_vecs we can hold */
+
+        struct bio_vec          *bi_io_vec;     /* the actual vec list */
+
+        bio_end_io_t            *bi_end_io;
+        atomic_t                bi_cnt;         /* pin count */
+
+        void                    *bi_private;
+
+        bio_destructor_t        *bi_destructor; /* destructor */
+        struct bio_set          *bi_set;        /* memory pools set */
+};
+
+/*
+ * bio flags
+ */
+#define BIO_UPTODATE    0       /* ok after I/O completion */
+#define BIO_RW_BLOCK    1       /* RW_AHEAD set, and read/write would block */
+#define BIO_EOF         2       /* out-out-bounds error */
+#define BIO_SEG_VALID   3       /* nr_hw_seg valid */
+#define BIO_CLONED      4       /* doesn't own data */
+#define BIO_BOUNCED     5       /* bio is a bounce bio */
+#define BIO_USER_MAPPED 6       /* contains user pages */
+#define BIO_EOPNOTSUPP  7       /* not supported */
+#define bio_flagged(bio, flag)  ((bio)->bi_flags & (1 << (flag)))
+
+/*
+ * top 4 bits of bio flags indicate the pool this bio came from
+ */
+#define BIO_POOL_BITS           (4)
+#define BIO_POOL_OFFSET         (BITS_PER_LONG - BIO_POOL_BITS)
+#define BIO_POOL_MASK           (1UL << BIO_POOL_OFFSET)
+#define BIO_POOL_IDX(bio)       ((bio)->bi_flags >> BIO_POOL_OFFSET)    
+
+/*
+ * bio bi_rw flags
+ *
+ * bit 0 -- read (not set) or write (set)
+ * bit 1 -- rw-ahead when set
+ * bit 2 -- barrier
+ * bit 3 -- fail fast, don't want low level driver retries
+ * bit 4 -- synchronous I/O hint: the block layer will unplug immediately
+ */
+#define BIO_RW          0
+#define BIO_RW_AHEAD    1
+#define BIO_RW_BARRIER  2
+#define BIO_RW_FAILFAST 3
+#define BIO_RW_SYNC     4
+
+/*
+ * various member access, note that bio_data should of course not be used
+ * on highmem page vectors
+ */
+#define bio_iovec_idx(bio, idx) (&((bio)->bi_io_vec[(idx)]))
+#define bio_iovec(bio)          bio_iovec_idx((bio), (bio)->bi_idx)
+#define bio_page(bio)           bio_iovec((bio))->bv_page
+#define bio_offset(bio)         bio_iovec((bio))->bv_offset
+#define bio_segments(bio)       ((bio)->bi_vcnt - (bio)->bi_idx)
+#define bio_sectors(bio)        ((bio)->bi_size >> 9)
+#define bio_cur_sectors(bio)    (bio_iovec(bio)->bv_len >> 9)
+#define bio_data(bio)           (page_address(bio_page((bio))) + bio_offset((bio)))
+#define bio_barrier(bio)        ((bio)->bi_rw & (1 << BIO_RW_BARRIER))
+#define bio_sync(bio)           ((bio)->bi_rw & (1 << BIO_RW_SYNC))
+#define bio_failfast(bio)       ((bio)->bi_rw & (1 << BIO_RW_FAILFAST))
+#define bio_rw_ahead(bio)       ((bio)->bi_rw & (1 << BIO_RW_AHEAD))
+
+/*
+ * will die
+ */
+#define bio_to_phys(bio)        (page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio)))
+#define bvec_to_phys(bv)        (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
+
+/*
+ * queues that have highmem support enabled may still need to revert to
+ * PIO transfers occasionally and thus map high pages temporarily. For
+ * permanent PIO fall back, user is probably better off disabling highmem
+ * I/O completely on that queue (see ide-dma for example)
+ */
+#define __bio_kmap_atomic(bio, idx, kmtype)                             \
+        (kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page, kmtype) +    \
+                bio_iovec_idx((bio), (idx))->bv_offset)
+
+#define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr, kmtype)
+
+/*
+ * merge helpers etc
+ */
+
+#define __BVEC_END(bio)         bio_iovec_idx((bio), (bio)->bi_vcnt - 1)
+#define __BVEC_START(bio)       bio_iovec_idx((bio), (bio)->bi_idx)
+
+/*
+ * allow arch override, for eg virtualized architectures (put in asm/io.h)
+ */
+#ifndef BIOVEC_PHYS_MERGEABLE
+#define BIOVEC_PHYS_MERGEABLE(vec1, vec2)       \
+        ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
+#endif
+
+#define BIOVEC_VIRT_MERGEABLE(vec1, vec2)       \
+        ((((bvec_to_phys((vec1)) + (vec1)->bv_len) | bvec_to_phys((vec2))) & (BIO_VMERGE_BOUNDARY - 1)) == 0)
+#define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
+        (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
+#define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
+        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, (q)->seg_boundary_mask)
+#define BIO_SEG_BOUNDARY(q, b1, b2) \
+        BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2)))
+
+#define bio_io_error(bio, bytes) bio_endio((bio), (bytes), -EIO)
+
+/*
+ * drivers should not use the __ version unless they _really_ want to
+ * run through the entire bio and not just pending pieces
+ */
+#define __bio_for_each_segment(bvl, bio, i, start_idx)                  \
+        for (bvl = bio_iovec_idx((bio), (start_idx)), i = (start_idx);  \
+             i < (bio)->bi_vcnt;                                        \
+             bvl++, i++)
+
+#define bio_for_each_segment(bvl, bio, i)                               \
+        __bio_for_each_segment(bvl, bio, i, (bio)->bi_idx)
+
+/*
+ * get a reference to a bio, so it won't disappear. the intended use is
+ * something like:
+ *
+ * bio_get(bio);
+ * submit_bio(rw, bio);
+ * if (bio->bi_flags ...)
+ *      do_something
+ * bio_put(bio);
+ *
+ * without the bio_get(), it could potentially complete I/O before submit_bio
+ * returns. and then bio would be freed memory when if (bio->bi_flags ...)
+ * runs
+ */
+#define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
+
+
+/*
+ * A bio_pair is used when we need to split a bio.
+ * This can only happen for a bio that refers to just one
+ * page of data, and in the unusual situation when the
+ * page crosses a chunk/device boundary
+ *
+ * The address of the master bio is stored in bio1.bi_private
+ * The address of the pool the pair was allocated from is stored
+ *   in bio2.bi_private
+ */
+struct bio_pair {
+        struct bio      bio1, bio2;
+        struct bio_vec  bv1, bv2;
+        atomic_t        cnt;
+        int             error;
+};
+extern struct bio_pair *bio_split(struct bio *bi, mempool_t *pool,
+                                  int first_sectors);
+extern mempool_t *bio_split_pool;
+extern void bio_pair_release(struct bio_pair *dbio);
+
+extern struct bio_set *bioset_create(int, int, int);
+extern void bioset_free(struct bio_set *);
+
+extern struct bio *bio_alloc(unsigned int __nocast, int);
+extern struct bio *bio_alloc_bioset(unsigned int __nocast, int, struct bio_set *);
+extern void bio_put(struct bio *);
+
+extern void bio_endio(struct bio *, unsigned int, int);
+struct request_queue;
+extern int bio_phys_segments(struct request_queue *, struct bio *);
+extern int bio_hw_segments(struct request_queue *, struct bio *);
+
+extern void __bio_clone(struct bio *, struct bio *);
+extern struct bio *bio_clone(struct bio *, unsigned int __nocast);
+
+extern void bio_init(struct bio *);
+
+extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
+extern int bio_get_nr_vecs(struct block_device *);
+extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
+                                unsigned long, unsigned int, int);
+extern void bio_unmap_user(struct bio *);
+extern void bio_set_pages_dirty(struct bio *bio);
+extern void bio_check_pages_dirty(struct bio *bio);
+extern struct bio *bio_copy_user(struct request_queue *, unsigned long, unsigned int, int);
+extern int bio_uncopy_user(struct bio *);
+void zero_fill_bio(struct bio *bio);
+
+#ifdef CONFIG_HIGHMEM
+/*
+ * remember to add offset! and never ever reenable interrupts between a
+ * bvec_kmap_irq and bvec_kunmap_irq!!
+ *
+ * This function MUST be inlined - it plays with the CPU interrupt flags.
+ * Hence the `extern inline'.
+ */
+extern inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
+{
+        unsigned long addr;
+
+        /*
+         * might not be a highmem page, but the preempt/irq count
+         * balancing is a lot nicer this way
+         */
+        local_irq_save(*flags);
+        addr = (unsigned long) kmap_atomic(bvec->bv_page, KM_BIO_SRC_IRQ);
+
+        BUG_ON(addr & ~PAGE_MASK);
+
+        return (char *) addr + bvec->bv_offset;
+}
+
+extern inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
+{
+        unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
+
+        kunmap_atomic((void *) ptr, KM_BIO_SRC_IRQ);
+        local_irq_restore(*flags);
+}
+
+#else
+#define bvec_kmap_irq(bvec, flags)      (page_address((bvec)->bv_page) + (bvec)->bv_offset)
+#define bvec_kunmap_irq(buf, flags)     do { *(flags) = 0; } while (0)
+#endif
+
+extern inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
+                                   unsigned long *flags)
+{
+        return bvec_kmap_irq(bio_iovec_idx(bio, idx), flags);
+}
+#define __bio_kunmap_irq(buf, flags)    bvec_kunmap_irq(buf, flags)
+
+#define bio_kmap_irq(bio, flags) \
+        __bio_kmap_irq((bio), (bio)->bi_idx, (flags))
+#define bio_kunmap_irq(buf,flags)       __bio_kunmap_irq(buf, flags)
+
+#endif /* __LINUX_BIO_H */
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
new file mode 100644
index 000000000000..86dd5502b05c
--- /dev/null
+++ b/include/linux/bitmap.h
@@ -0,0 +1,261 @@
+#ifndef __LINUX_BITMAP_H
+#define __LINUX_BITMAP_H
+
+#ifndef __ASSEMBLY__
+
+#include <linux/types.h>
+#include <linux/bitops.h>
+#include <linux/string.h>
+
+/*
+ * bitmaps provide bit arrays that consume one or more unsigned
+ * longs.  The bitmap interface and available operations are listed
+ * here, in bitmap.h
+ *
+ * Function implementations generic to all architectures are in
+ * lib/bitmap.c.  Functions implementations that are architecture
+ * specific are in various include/asm-<arch>/bitops.h headers
+ * and other arch/<arch> specific files.
+ *
+ * See lib/bitmap.c for more details.
+ */
+
+/*
+ * The available bitmap operations and their rough meaning in the
+ * case that the bitmap is a single unsigned long are thus:
+ *
+ * bitmap_zero(dst, nbits)                      *dst = 0UL
+ * bitmap_fill(dst, nbits)                      *dst = ~0UL
+ * bitmap_copy(dst, src, nbits)                 *dst = *src
+ * bitmap_and(dst, src1, src2, nbits)           *dst = *src1 & *src2
+ * bitmap_or(dst, src1, src2, nbits)            *dst = *src1 | *src2
+ * bitmap_xor(dst, src1, src2, nbits)           *dst = *src1 ^ *src2
+ * bitmap_andnot(dst, src1, src2, nbits)        *dst = *src1 & ~(*src2)
+ * bitmap_complement(dst, src, nbits)           *dst = ~(*src)
+ * bitmap_equal(src1, src2, nbits)              Are *src1 and *src2 equal?
+ * bitmap_intersects(src1, src2, nbits)         Do *src1 and *src2 overlap?
+ * bitmap_subset(src1, src2, nbits)             Is *src1 a subset of *src2?
+ * bitmap_empty(src, nbits)                     Are all bits zero in *src?
+ * bitmap_full(src, nbits)                      Are all bits set in *src?
+ * bitmap_weight(src, nbits)                    Hamming Weight: number set bits
+ * bitmap_shift_right(dst, src, n, nbits)       *dst = *src >> n
+ * bitmap_shift_left(dst, src, n, nbits)        *dst = *src << n
+ * bitmap_scnprintf(buf, len, src, nbits)       Print bitmap src to buf
+ * bitmap_parse(ubuf, ulen, dst, nbits)         Parse bitmap dst from user buf
+ * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
+ * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from list
+ */
+
+/*
+ * Also the following operations in asm/bitops.h apply to bitmaps.
+ *
+ * set_bit(bit, addr)                   *addr |= bit
+ * clear_bit(bit, addr)                 *addr &= ~bit
+ * change_bit(bit, addr)                *addr ^= bit
+ * test_bit(bit, addr)                  Is bit set in *addr?
+ * test_and_set_bit(bit, addr)          Set bit and return old value
+ * test_and_clear_bit(bit, addr)        Clear bit and return old value
+ * test_and_change_bit(bit, addr)       Change bit and return old value
+ * find_first_zero_bit(addr, nbits)     Position first zero bit in *addr
+ * find_first_bit(addr, nbits)          Position first set bit in *addr
+ * find_next_zero_bit(addr, nbits, bit) Position next zero bit in *addr >= bit
+ * find_next_bit(addr, nbits, bit)      Position next set bit in *addr >= bit
+ */
+
+/*
+ * The DECLARE_BITMAP(name,bits) macro, in linux/types.h, can be used
+ * to declare an array named 'name' of just enough unsigned longs to
+ * contain all bit positions from 0 to 'bits' - 1.
+ */
+
+/*
+ * lib/bitmap.c provides these functions:
+ */
+
+extern int __bitmap_empty(const unsigned long *bitmap, int bits);
+extern int __bitmap_full(const unsigned long *bitmap, int bits);
+extern int __bitmap_equal(const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
+                        int bits);
+extern void __bitmap_shift_right(unsigned long *dst,
+                        const unsigned long *src, int shift, int bits);
+extern void __bitmap_shift_left(unsigned long *dst,
+                        const unsigned long *src, int shift, int bits);
+extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern int __bitmap_intersects(const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern int __bitmap_subset(const unsigned long *bitmap1,
+                        const unsigned long *bitmap2, int bits);
+extern int __bitmap_weight(const unsigned long *bitmap, int bits);
+
+extern int bitmap_scnprintf(char *buf, unsigned int len,
+                        const unsigned long *src, int nbits);
+extern int bitmap_parse(const char __user *ubuf, unsigned int ulen,
+                        unsigned long *dst, int nbits);
+extern int bitmap_scnlistprintf(char *buf, unsigned int len,
+                        const unsigned long *src, int nbits);
+extern int bitmap_parselist(const char *buf, unsigned long *maskp,
+                        int nmaskbits);
+extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
+extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
+extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
+
+#define BITMAP_LAST_WORD_MASK(nbits)                                    \
+(                                                                       \
+        ((nbits) % BITS_PER_LONG) ?                                     \
+                (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL               \
+)
+
+static inline void bitmap_zero(unsigned long *dst, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = 0UL;
+        else {
+                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                memset(dst, 0, len);
+        }
+}
+
+static inline void bitmap_fill(unsigned long *dst, int nbits)
+{
+        size_t nlongs = BITS_TO_LONGS(nbits);
+        if (nlongs > 1) {
+                int len = (nlongs - 1) * sizeof(unsigned long);
+                memset(dst, 0xff,  len);
+        }
+        dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
+}
+
+static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
+                        int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src;
+        else {
+                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                memcpy(dst, src, len);
+        }
+}
+
+static inline void bitmap_and(unsigned long *dst, const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src1 & *src2;
+        else
+                __bitmap_and(dst, src1, src2, nbits);
+}
+
+static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src1 | *src2;
+        else
+                __bitmap_or(dst, src1, src2, nbits);
+}
+
+static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src1 ^ *src2;
+        else
+                __bitmap_xor(dst, src1, src2, nbits);
+}
+
+static inline void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src1 & ~(*src2);
+        else
+                __bitmap_andnot(dst, src1, src2, nbits);
+}
+
+static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
+                        int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = ~(*src) & BITMAP_LAST_WORD_MASK(nbits);
+        else
+                __bitmap_complement(dst, src, nbits);
+}
+
+static inline int bitmap_equal(const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                return ! ((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
+        else
+                return __bitmap_equal(src1, src2, nbits);
+}
+
+static inline int bitmap_intersects(const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
+        else
+                return __bitmap_intersects(src1, src2, nbits);
+}
+
+static inline int bitmap_subset(const unsigned long *src1,
+                        const unsigned long *src2, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));
+        else
+                return __bitmap_subset(src1, src2, nbits);
+}
+
+static inline int bitmap_empty(const unsigned long *src, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
+        else
+                return __bitmap_empty(src, nbits);
+}
+
+static inline int bitmap_full(const unsigned long *src, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
+        else
+                return __bitmap_full(src, nbits);
+}
+
+static inline int bitmap_weight(const unsigned long *src, int nbits)
+{
+        return __bitmap_weight(src, nbits);
+}
+
+static inline void bitmap_shift_right(unsigned long *dst,
+                        const unsigned long *src, int n, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = *src >> n;
+        else
+                __bitmap_shift_right(dst, src, n, nbits);
+}
+
+static inline void bitmap_shift_left(unsigned long *dst,
+                        const unsigned long *src, int n, int nbits)
+{
+        if (nbits <= BITS_PER_LONG)
+                *dst = (*src << n) & BITMAP_LAST_WORD_MASK(nbits);
+        else
+                __bitmap_shift_left(dst, src, n, nbits);
+}
+
+#endif /* __ASSEMBLY__ */
+
+#endif /* __LINUX_BITMAP_H */
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
new file mode 100644
index 000000000000..cb3c3ef50f50
--- /dev/null
+++ b/include/linux/bitops.h
@@ -0,0 +1,159 @@
+#ifndef _LINUX_BITOPS_H
+#define _LINUX_BITOPS_H
+#include <asm/types.h>
+
+/*
+ * ffs: find first bit set. This is defined the same way as
+ * the libc and compiler builtin ffs routines, therefore
+ * differs in spirit from the above ffz (man ffs).
+ */
+
+static inline int generic_ffs(int x)
+{
+        int r = 1;
+
+        if (!x)
+                return 0;
+        if (!(x & 0xffff)) {
+                x >>= 16;
+                r += 16;
+        }
+        if (!(x & 0xff)) {
+                x >>= 8;
+                r += 8;
+        }
+        if (!(x & 0xf)) {
+                x >>= 4;
+                r += 4;
+        }
+        if (!(x & 3)) {
+                x >>= 2;
+                r += 2;
+        }
+        if (!(x & 1)) {
+                x >>= 1;
+                r += 1;
+        }
+        return r;
+}
+
+/*
+ * fls: find last bit set.
+ */
+
+static __inline__ int generic_fls(int x)
+{
+        int r = 32;
+
+        if (!x)
+                return 0;
+        if (!(x & 0xffff0000u)) {
+                x <<= 16;
+                r -= 16;
+        }
+        if (!(x & 0xff000000u)) {
+                x <<= 8;
+                r -= 8;
+        }
+        if (!(x & 0xf0000000u)) {
+                x <<= 4;
+                r -= 4;
+        }
+        if (!(x & 0xc0000000u)) {
+                x <<= 2;
+                r -= 2;
+        }
+        if (!(x & 0x80000000u)) {
+                x <<= 1;
+                r -= 1;
+        }
+        return r;
+}
+
+/*
+ * Include this here because some architectures need generic_ffs/fls in
+ * scope
+ */
+#include <asm/bitops.h>
+
+static __inline__ int get_bitmask_order(unsigned int count)
+{
+        int order;
+        
+        order = fls(count);
+        return order;   /* We could be slightly more clever with -1 here... */
+}
+
+/*
+ * hweightN: returns the hamming weight (i.e. the number
+ * of bits set) of a N-bit word
+ */
+
+static inline unsigned int generic_hweight32(unsigned int w)
+{
+        unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
+        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
+        res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
+        res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
+        return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
+}
+
+static inline unsigned int generic_hweight16(unsigned int w)
+{
+        unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
+        res = (res & 0x3333) + ((res >> 2) & 0x3333);
+        res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
+        return (res & 0x00FF) + ((res >> 8) & 0x00FF);
+}
+
+static inline unsigned int generic_hweight8(unsigned int w)
+{
+        unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
+        res = (res & 0x33) + ((res >> 2) & 0x33);
+        return (res & 0x0F) + ((res >> 4) & 0x0F);
+}
+
+static inline unsigned long generic_hweight64(__u64 w)
+{
+#if BITS_PER_LONG < 64
+        return generic_hweight32((unsigned int)(w >> 32)) +
+                                generic_hweight32((unsigned int)w);
+#else
+        u64 res;
+        res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
+        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
+        res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
+        res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
+        res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
+        return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
+#endif
+}
+
+static inline unsigned long hweight_long(unsigned long w)
+{
+        return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
+}
+
+/*
+ * rol32 - rotate a 32-bit value left
+ *
+ * @word: value to rotate
+ * @shift: bits to roll
+ */
+static inline __u32 rol32(__u32 word, unsigned int shift)
+{
+        return (word << shift) | (word >> (32 - shift));
+}
+
+/*
+ * ror32 - rotate a 32-bit value right
+ *
+ * @word: value to rotate
+ * @shift: bits to roll
+ */
+static inline __u32 ror32(__u32 word, unsigned int shift)
+{
+        return (word >> shift) | (word << (32 - shift));
+}
+
+#endif
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
new file mode 100644
index 000000000000..70ac2860a605
--- /dev/null
+++ b/include/linux/blkdev.h
@@ -0,0 +1,759 @@
+#ifndef _LINUX_BLKDEV_H
+#define _LINUX_BLKDEV_H
+
+#include <linux/config.h>
+#include <linux/major.h>
+#include <linux/genhd.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+#include <linux/pagemap.h>
+#include <linux/backing-dev.h>
+#include <linux/wait.h>
+#include <linux/mempool.h>
+#include <linux/bio.h>
+#include <linux/module.h>
+#include <linux/stringify.h>
+
+#include <asm/scatterlist.h>
+
+struct request_queue;
+typedef struct request_queue request_queue_t;
+struct elevator_queue;
+typedef struct elevator_queue elevator_t;
+struct request_pm_state;
+
+#define BLKDEV_MIN_RQ   4
+#define BLKDEV_MAX_RQ   128     /* Default maximum */
+
+/*
+ * This is the per-process anticipatory I/O scheduler state.
+ */
+struct as_io_context {
+        spinlock_t lock;
+
+        void (*dtor)(struct as_io_context *aic); /* destructor */
+        void (*exit)(struct as_io_context *aic); /* called on task exit */
+
+        unsigned long state;
+        atomic_t nr_queued; /* queued reads & sync writes */
+        atomic_t nr_dispatched; /* number of requests gone to the drivers */
+
+        /* IO History tracking */
+        /* Thinktime */
+        unsigned long last_end_request;
+        unsigned long ttime_total;
+        unsigned long ttime_samples;
+        unsigned long ttime_mean;
+        /* Layout pattern */
+        unsigned int seek_samples;
+        sector_t last_request_pos;
+        u64 seek_total;
+        sector_t seek_mean;
+};
+
+struct cfq_queue;
+struct cfq_io_context {
+        void (*dtor)(struct cfq_io_context *);
+        void (*exit)(struct cfq_io_context *);
+
+        struct io_context *ioc;
+
+        /*
+         * circular list of cfq_io_contexts belonging to a process io context
+         */
+        struct list_head list;
+        struct cfq_queue *cfqq;
+};
+
+/*
+ * This is the per-process I/O subsystem state.  It is refcounted and
+ * kmalloc'ed. Currently all fields are modified in process io context
+ * (apart from the atomic refcount), so require no locking.
+ */
+struct io_context {
+        atomic_t refcount;
+        pid_t pid;
+
+        /*
+         * For request batching
+         */
+        unsigned long last_waited; /* Time last woken after wait for request */
+        int nr_batch_requests;     /* Number of requests left in the batch */
+
+        spinlock_t lock;
+
+        struct as_io_context *aic;
+        struct cfq_io_context *cic;
+};
+
+void put_io_context(struct io_context *ioc);
+void exit_io_context(void);
+struct io_context *get_io_context(int gfp_flags);
+void copy_io_context(struct io_context **pdst, struct io_context **psrc);
+void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
+
+struct request;
+typedef void (rq_end_io_fn)(struct request *);
+
+struct request_list {
+        int count[2];
+        int starved[2];
+        mempool_t *rq_pool;
+        wait_queue_head_t wait[2];
+        wait_queue_head_t drain;
+};
+
+#define BLK_MAX_CDB     16
+
+/*
+ * try to put the fields that are referenced together in the same cacheline
+ */
+struct request {
+        struct list_head queuelist; /* looking for ->queue? you must _not_
+                                     * access it directly, use
+                                     * blkdev_dequeue_request! */
+        unsigned long flags;            /* see REQ_ bits below */
+
+        /* Maintain bio traversal state for part by part I/O submission.
+         * hard_* are block layer internals, no driver should touch them!
+         */
+
+        sector_t sector;                /* next sector to submit */
+        unsigned long nr_sectors;       /* no. of sectors left to submit */
+        /* no. of sectors left to submit in the current segment */
+        unsigned int current_nr_sectors;
+
+        sector_t hard_sector;           /* next sector to complete */
+        unsigned long hard_nr_sectors;  /* no. of sectors left to complete */
+        /* no. of sectors left to complete in the current segment */
+        unsigned int hard_cur_sectors;
+
+        struct bio *bio;
+        struct bio *biotail;
+
+        void *elevator_private;
+
+        int rq_status;  /* should split this into a few status bits */
+        struct gendisk *rq_disk;
+        int errors;
+        unsigned long start_time;
+
+        /* Number of scatter-gather DMA addr+len pairs after
+         * physical address coalescing is performed.
+         */
+        unsigned short nr_phys_segments;
+
+        /* Number of scatter-gather addr+len pairs after
+         * physical and DMA remapping hardware coalescing is performed.
+         * This is the number of scatter-gather entries the driver
+         * will actually have to deal with after DMA mapping is done.
+         */
+        unsigned short nr_hw_segments;
+
+        int tag;
+        char *buffer;
+
+        int ref_count;
+        request_queue_t *q;
+        struct request_list *rl;
+
+        struct completion *waiting;
+        void *special;
+
+        /*
+         * when request is used as a packet command carrier
+         */
+        unsigned int cmd_len;
+        unsigned char cmd[BLK_MAX_CDB];
+
+        unsigned int data_len;
+        void *data;
+
+        unsigned int sense_len;
+        void *sense;
+
+        unsigned int timeout;
+
+        /*
+         * For Power Management requests
+         */
+        struct request_pm_state *pm;
+
+        /*
+         * completion callback. end_io_data should be folded in with waiting
+         */
+        rq_end_io_fn *end_io;
+        void *end_io_data;
+};
+
+/*
+ * first three bits match BIO_RW* bits, important
+ */
+enum rq_flag_bits {
+        __REQ_RW,               /* not set, read. set, write */
+        __REQ_FAILFAST,         /* no low level driver retries */
+        __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
+        __REQ_HARDBARRIER,      /* may not be passed by drive either */
+        __REQ_CMD,              /* is a regular fs rw request */
+        __REQ_NOMERGE,          /* don't touch this for merging */
+        __REQ_STARTED,          /* drive already may have started this one */
+        __REQ_DONTPREP,         /* don't call prep for this one */
+        __REQ_QUEUED,           /* uses queueing */
+        /*
+         * for ATA/ATAPI devices
+         */
+        __REQ_PC,               /* packet command (special) */
+        __REQ_BLOCK_PC,         /* queued down pc from block layer */
+        __REQ_SENSE,            /* sense retrival */
+
+        __REQ_FAILED,           /* set if the request failed */
+        __REQ_QUIET,            /* don't worry about errors */
+        __REQ_SPECIAL,          /* driver suplied command */
+        __REQ_DRIVE_CMD,
+        __REQ_DRIVE_TASK,
+        __REQ_DRIVE_TASKFILE,
+        __REQ_PREEMPT,          /* set for "ide_preempt" requests */
+        __REQ_PM_SUSPEND,       /* suspend request */
+        __REQ_PM_RESUME,        /* resume request */
+        __REQ_PM_SHUTDOWN,      /* shutdown request */
+        __REQ_BAR_PREFLUSH,     /* barrier pre-flush done */
+        __REQ_BAR_POSTFLUSH,    /* barrier post-flush */
+        __REQ_BAR_FLUSH,        /* rq is the flush request */
+        __REQ_NR_BITS,          /* stops here */
+};
+
+#define REQ_RW          (1 << __REQ_RW)
+#define REQ_FAILFAST    (1 << __REQ_FAILFAST)
+#define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
+#define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
+#define REQ_CMD         (1 << __REQ_CMD)
+#define REQ_NOMERGE     (1 << __REQ_NOMERGE)
+#define REQ_STARTED     (1 << __REQ_STARTED)
+#define REQ_DONTPREP    (1 << __REQ_DONTPREP)
+#define REQ_QUEUED      (1 << __REQ_QUEUED)
+#define REQ_PC          (1 << __REQ_PC)
+#define REQ_BLOCK_PC    (1 << __REQ_BLOCK_PC)
+#define REQ_SENSE       (1 << __REQ_SENSE)
+#define REQ_FAILED      (1 << __REQ_FAILED)
+#define REQ_QUIET       (1 << __REQ_QUIET)
+#define REQ_SPECIAL     (1 << __REQ_SPECIAL)
+#define REQ_DRIVE_CMD   (1 << __REQ_DRIVE_CMD)
+#define REQ_DRIVE_TASK  (1 << __REQ_DRIVE_TASK)
+#define REQ_DRIVE_TASKFILE      (1 << __REQ_DRIVE_TASKFILE)
+#define REQ_PREEMPT     (1 << __REQ_PREEMPT)
+#define REQ_PM_SUSPEND  (1 << __REQ_PM_SUSPEND)
+#define REQ_PM_RESUME   (1 << __REQ_PM_RESUME)
+#define REQ_PM_SHUTDOWN (1 << __REQ_PM_SHUTDOWN)
+#define REQ_BAR_PREFLUSH        (1 << __REQ_BAR_PREFLUSH)
+#define REQ_BAR_POSTFLUSH       (1 << __REQ_BAR_POSTFLUSH)
+#define REQ_BAR_FLUSH   (1 << __REQ_BAR_FLUSH)
+
+/*
+ * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME
+ * requests. Some step values could eventually be made generic.
+ */
+struct request_pm_state
+{
+        /* PM state machine step value, currently driver specific */
+        int     pm_step;
+        /* requested PM state value (S1, S2, S3, S4, ...) */
+        u32     pm_state;
+        void*   data;           /* for driver use */
+};
+
+#include <linux/elevator.h>
+
+typedef int (merge_request_fn) (request_queue_t *, struct request *,
+                                struct bio *);
+typedef int (merge_requests_fn) (request_queue_t *, struct request *,
+                                 struct request *);
+typedef void (request_fn_proc) (request_queue_t *q);
+typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);
+typedef int (prep_rq_fn) (request_queue_t *, struct request *);
+typedef void (unplug_fn) (request_queue_t *);
+
+struct bio_vec;
+typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
+typedef void (activity_fn) (void *data, int rw);
+typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
+typedef int (prepare_flush_fn) (request_queue_t *, struct request *);
+typedef void (end_flush_fn) (request_queue_t *, struct request *);
+
+enum blk_queue_state {
+        Queue_down,
+        Queue_up,
+};
+
+#define BLK_TAGS_PER_LONG       (sizeof(unsigned long) * 8)
+#define BLK_TAGS_MASK           (BLK_TAGS_PER_LONG - 1)
+
+struct blk_queue_tag {
+        struct request **tag_index;     /* map of busy tags */
+        unsigned long *tag_map;         /* bit map of free/busy tags */
+        struct list_head busy_list;     /* fifo list of busy tags */
+        int busy;                       /* current depth */
+        int max_depth;                  /* what we will send to device */
+        int real_max_depth;             /* what the array can hold */
+        atomic_t refcnt;                /* map can be shared */
+};
+
+struct request_queue
+{
+        /*
+         * Together with queue_head for cacheline sharing
+         */
+        struct list_head        queue_head;
+        struct request          *last_merge;
+        elevator_t              *elevator;
+
+        /*
+         * the queue request freelist, one for reads and one for writes
+         */
+        struct request_list     rq;
+
+        request_fn_proc         *request_fn;
+        merge_request_fn        *back_merge_fn;
+        merge_request_fn        *front_merge_fn;
+        merge_requests_fn       *merge_requests_fn;
+        make_request_fn         *make_request_fn;
+        prep_rq_fn              *prep_rq_fn;
+        unplug_fn               *unplug_fn;
+        merge_bvec_fn           *merge_bvec_fn;
+        activity_fn             *activity_fn;
+        issue_flush_fn          *issue_flush_fn;
+        prepare_flush_fn        *prepare_flush_fn;
+        end_flush_fn            *end_flush_fn;
+
+        /*
+         * Auto-unplugging state
+         */
+        struct timer_list       unplug_timer;
+        int                     unplug_thresh;  /* After this many requests */
+        unsigned long           unplug_delay;   /* After this many jiffies */
+        struct work_struct      unplug_work;
+
+        struct backing_dev_info backing_dev_info;
+
+        /*
+         * The queue owner gets to use this for whatever they like.
+         * ll_rw_blk doesn't touch it.
+         */
+        void                    *queuedata;
+
+        void                    *activity_data;
+
+        /*
+         * queue needs bounce pages for pages above this limit
+         */
+        unsigned long           bounce_pfn;
+        unsigned int            bounce_gfp;
+
+        /*
+         * various queue flags, see QUEUE_* below
+         */
+        unsigned long           queue_flags;
+
+        /*
+         * protects queue structures from reentrancy
+         */
+        spinlock_t              *queue_lock;
+
+        /*
+         * queue kobject
+         */
+        struct kobject kobj;
+
+        /*
+         * queue settings
+         */
+        unsigned long           nr_requests;    /* Max # of requests */
+        unsigned int            nr_congestion_on;
+        unsigned int            nr_congestion_off;
+        unsigned int            nr_batching;
+
+        unsigned short          max_sectors;
+        unsigned short          max_hw_sectors;
+        unsigned short          max_phys_segments;
+        unsigned short          max_hw_segments;
+        unsigned short          hardsect_size;
+        unsigned int            max_segment_size;
+
+        unsigned long           seg_boundary_mask;
+        unsigned int            dma_alignment;
+
+        struct blk_queue_tag    *queue_tags;
+
+        atomic_t                refcnt;
+
+        unsigned int            in_flight;
+
+        /*
+         * sg stuff
+         */
+        unsigned int            sg_timeout;
+        unsigned int            sg_reserved_size;
+
+        struct list_head        drain_list;
+
+        /*
+         * reserved for flush operations
+         */
+        struct request          *flush_rq;
+        unsigned char           ordered;
+};
+
+enum {
+        QUEUE_ORDERED_NONE,
+        QUEUE_ORDERED_TAG,
+        QUEUE_ORDERED_FLUSH,
+};
+
+#define RQ_INACTIVE             (-1)
+#define RQ_ACTIVE               1
+#define RQ_SCSI_BUSY            0xffff
+#define RQ_SCSI_DONE            0xfffe
+#define RQ_SCSI_DISCONNECTING   0xffe0
+
+#define QUEUE_FLAG_CLUSTER      0       /* cluster several segments into 1 */
+#define QUEUE_FLAG_QUEUED       1       /* uses generic tag queueing */
+#define QUEUE_FLAG_STOPPED      2       /* queue is stopped */
+#define QUEUE_FLAG_READFULL     3       /* write queue has been filled */
+#define QUEUE_FLAG_WRITEFULL    4       /* read queue has been filled */
+#define QUEUE_FLAG_DEAD         5       /* queue being torn down */
+#define QUEUE_FLAG_REENTER      6       /* Re-entrancy avoidance */
+#define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
+#define QUEUE_FLAG_DRAIN        8       /* draining queue for sched switch */
+#define QUEUE_FLAG_FLUSH        9       /* doing barrier flush sequence */
+
+#define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
+#define blk_queue_tagged(q)     test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
+#define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
+#define blk_queue_flushing(q)   test_bit(QUEUE_FLAG_FLUSH, &(q)->queue_flags)
+
+#define blk_fs_request(rq)      ((rq)->flags & REQ_CMD)
+#define blk_pc_request(rq)      ((rq)->flags & REQ_BLOCK_PC)
+#define blk_noretry_request(rq) ((rq)->flags & REQ_FAILFAST)
+#define blk_rq_started(rq)      ((rq)->flags & REQ_STARTED)
+
+#define blk_account_rq(rq)      (blk_rq_started(rq) && blk_fs_request(rq))
+
+#define blk_pm_suspend_request(rq)      ((rq)->flags & REQ_PM_SUSPEND)
+#define blk_pm_resume_request(rq)       ((rq)->flags & REQ_PM_RESUME)
+#define blk_pm_request(rq)      \
+        ((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME))
+
+#define blk_barrier_rq(rq)      ((rq)->flags & REQ_HARDBARRIER)
+#define blk_barrier_preflush(rq)        ((rq)->flags & REQ_BAR_PREFLUSH)
+#define blk_barrier_postflush(rq)       ((rq)->flags & REQ_BAR_POSTFLUSH)
+
+#define list_entry_rq(ptr)      list_entry((ptr), struct request, queuelist)
+
+#define rq_data_dir(rq)         ((rq)->flags & 1)
+
+static inline int blk_queue_full(struct request_queue *q, int rw)
+{
+        if (rw == READ)
+                return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
+        return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+}
+
+static inline void blk_set_queue_full(struct request_queue *q, int rw)
+{
+        if (rw == READ)
+                set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
+        else
+                set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+}
+
+static inline void blk_clear_queue_full(struct request_queue *q, int rw)
+{
+        if (rw == READ)
+                clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
+        else
+                clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+}
+
+
+/*
+ * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
+ * it already be started by driver.
+ */
+#define RQ_NOMERGE_FLAGS        \
+        (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
+#define rq_mergeable(rq)        \
+        (!((rq)->flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
+
+/*
+ * noop, requests are automagically marked as active/inactive by I/O
+ * scheduler -- see elv_next_request
+ */
+#define blk_queue_headactive(q, head_active)
+
+/*
+ * q->prep_rq_fn return values
+ */
+#define BLKPREP_OK              0       /* serve it */
+#define BLKPREP_KILL            1       /* fatal error, kill */
+#define BLKPREP_DEFER           2       /* leave on queue */
+
+extern unsigned long blk_max_low_pfn, blk_max_pfn;
+
+/*
+ * standard bounce addresses:
+ *
+ * BLK_BOUNCE_HIGH      : bounce all highmem pages
+ * BLK_BOUNCE_ANY       : don't bounce anything
+ * BLK_BOUNCE_ISA       : bounce pages above ISA DMA boundary
+ */
+#define BLK_BOUNCE_HIGH         ((u64)blk_max_low_pfn << PAGE_SHIFT)
+#define BLK_BOUNCE_ANY          ((u64)blk_max_pfn << PAGE_SHIFT)
+#define BLK_BOUNCE_ISA          (ISA_DMA_THRESHOLD)
+
+#ifdef CONFIG_MMU
+extern int init_emergency_isa_pool(void);
+extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
+#else
+static inline int init_emergency_isa_pool(void)
+{
+        return 0;
+}
+static inline void blk_queue_bounce(request_queue_t *q, struct bio **bio)
+{
+}
+#endif /* CONFIG_MMU */
+
+#define rq_for_each_bio(_bio, rq)       \
+        if ((rq->bio))                  \
+                for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
+
+struct sec_size {
+        unsigned block_size;
+        unsigned block_size_bits;
+};
+
+extern int blk_register_queue(struct gendisk *disk);
+extern void blk_unregister_queue(struct gendisk *disk);
+extern void register_disk(struct gendisk *dev);
+extern void generic_make_request(struct bio *bio);
+extern void blk_put_request(struct request *);
+extern void blk_end_sync_rq(struct request *rq);
+extern void blk_attempt_remerge(request_queue_t *, struct request *);
+extern void __blk_attempt_remerge(request_queue_t *, struct request *);
+extern struct request *blk_get_request(request_queue_t *, int, int);
+extern void blk_insert_request(request_queue_t *, struct request *, int, void *, int);
+extern void blk_requeue_request(request_queue_t *, struct request *);
+extern void blk_plug_device(request_queue_t *);
+extern int blk_remove_plug(request_queue_t *);
+extern void blk_recount_segments(request_queue_t *, struct bio *);
+extern int blk_phys_contig_segment(request_queue_t *q, struct bio *, struct bio *);
+extern int blk_hw_contig_segment(request_queue_t *q, struct bio *, struct bio *);
+extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
+extern void blk_start_queue(request_queue_t *q);
+extern void blk_stop_queue(request_queue_t *q);
+extern void blk_sync_queue(struct request_queue *q);
+extern void __blk_stop_queue(request_queue_t *q);
+extern void blk_run_queue(request_queue_t *);
+extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
+extern struct request *blk_rq_map_user(request_queue_t *, int, void __user *, unsigned int);
+extern int blk_rq_unmap_user(struct request *, struct bio *, unsigned int);
+extern int blk_execute_rq(request_queue_t *, struct gendisk *, struct request *);
+
+static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
+{
+        return bdev->bd_disk->queue;
+}
+
+static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
+                                       struct page *page)
+{
+        if (bdi && bdi->unplug_io_fn)
+                bdi->unplug_io_fn(bdi, page);
+}
+
+static inline void blk_run_address_space(struct address_space *mapping)
+{
+        if (mapping)
+                blk_run_backing_dev(mapping->backing_dev_info, NULL);
+}
+
+/*
+ * end_request() and friends. Must be called with the request queue spinlock
+ * acquired. All functions called within end_request() _must_be_ atomic.
+ *
+ * Several drivers define their own end_request and call
+ * end_that_request_first() and end_that_request_last()
+ * for parts of the original function. This prevents
+ * code duplication in drivers.
+ */
+extern int end_that_request_first(struct request *, int, int);
+extern int end_that_request_chunk(struct request *, int, int);
+extern void end_that_request_last(struct request *);
+extern void end_request(struct request *req, int uptodate);
+
+/*
+ * end_that_request_first/chunk() takes an uptodate argument. we account
+ * any value <= as an io error. 0 means -EIO for compatability reasons,
+ * any other < 0 value is the direct error type. An uptodate value of
+ * 1 indicates successful io completion
+ */
+#define end_io_error(uptodate)  (unlikely((uptodate) <= 0))
+
+static inline void blkdev_dequeue_request(struct request *req)
+{
+        BUG_ON(list_empty(&req->queuelist));
+
+        list_del_init(&req->queuelist);
+
+        if (req->rl)
+                elv_remove_request(req->q, req);
+}
+
+/*
+ * Access functions for manipulating queue properties
+ */
+extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
+extern void blk_cleanup_queue(request_queue_t *);
+extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
+extern void blk_queue_bounce_limit(request_queue_t *, u64);
+extern void blk_queue_max_sectors(request_queue_t *, unsigned short);
+extern void blk_queue_max_phys_segments(request_queue_t *, unsigned short);
+extern void blk_queue_max_hw_segments(request_queue_t *, unsigned short);
+extern void blk_queue_max_segment_size(request_queue_t *, unsigned int);
+extern void blk_queue_hardsect_size(request_queue_t *, unsigned short);
+extern void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b);
+extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
+extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
+extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
+extern void blk_queue_dma_alignment(request_queue_t *, int);
+extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
+extern void blk_queue_ordered(request_queue_t *, int);
+extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
+extern int blkdev_scsi_issue_flush_fn(request_queue_t *, struct gendisk *, sector_t *);
+extern struct request *blk_start_pre_flush(request_queue_t *,struct request *);
+extern int blk_complete_barrier_rq(request_queue_t *, struct request *, int);
+extern int blk_complete_barrier_rq_locked(request_queue_t *, struct request *, int);
+
+extern int blk_rq_map_sg(request_queue_t *, struct request *, struct scatterlist *);
+extern void blk_dump_rq_flags(struct request *, char *);
+extern void generic_unplug_device(request_queue_t *);
+extern void __generic_unplug_device(request_queue_t *);
+extern long nr_blockdev_pages(void);
+extern void blk_wait_queue_drained(request_queue_t *, int);
+extern void blk_finish_queue_drain(request_queue_t *);
+
+int blk_get_queue(request_queue_t *);
+request_queue_t *blk_alloc_queue(int);
+#define blk_put_queue(q) blk_cleanup_queue((q))
+
+/*
+ * tag stuff
+ */
+#define blk_queue_tag_depth(q)          ((q)->queue_tags->busy)
+#define blk_queue_tag_queue(q)          ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
+#define blk_rq_tagged(rq)               ((rq)->flags & REQ_QUEUED)
+extern int blk_queue_start_tag(request_queue_t *, struct request *);
+extern struct request *blk_queue_find_tag(request_queue_t *, int);
+extern void blk_queue_end_tag(request_queue_t *, struct request *);
+extern int blk_queue_init_tags(request_queue_t *, int, struct blk_queue_tag *);
+extern void blk_queue_free_tags(request_queue_t *);
+extern int blk_queue_resize_tags(request_queue_t *, int);
+extern void blk_queue_invalidate_tags(request_queue_t *);
+extern long blk_congestion_wait(int rw, long timeout);
+
+extern void blk_rq_bio_prep(request_queue_t *, struct request *, struct bio *);
+extern int blkdev_issue_flush(struct block_device *, sector_t *);
+
+#define MAX_PHYS_SEGMENTS 128
+#define MAX_HW_SEGMENTS 128
+#define MAX_SECTORS 255
+
+#define MAX_SEGMENT_SIZE        65536
+
+#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
+
+extern void drive_stat_acct(struct request *, int, int);
+
+static inline int queue_hardsect_size(request_queue_t *q)
+{
+        int retval = 512;
+
+        if (q && q->hardsect_size)
+                retval = q->hardsect_size;
+
+        return retval;
+}
+
+static inline int bdev_hardsect_size(struct block_device *bdev)
+{
+        return queue_hardsect_size(bdev_get_queue(bdev));
+}
+
+static inline int queue_dma_alignment(request_queue_t *q)
+{
+        int retval = 511;
+
+        if (q && q->dma_alignment)
+                retval = q->dma_alignment;
+
+        return retval;
+}
+
+static inline int bdev_dma_aligment(struct block_device *bdev)
+{
+        return queue_dma_alignment(bdev_get_queue(bdev));
+}
+
+#define blk_finished_io(nsects) do { } while (0)
+#define blk_started_io(nsects)  do { } while (0)
+
+/* assumes size > 256 */
+static inline unsigned int blksize_bits(unsigned int size)
+{
+        unsigned int bits = 8;
+        do {
+                bits++;
+                size >>= 1;
+        } while (size > 256);
+        return bits;
+}
+
+extern inline unsigned int block_size(struct block_device *bdev)
+{
+        return bdev->bd_block_size;
+}
+
+typedef struct {struct page *v;} Sector;
+
+unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
+
+static inline void put_dev_sector(Sector p)
+{
+        page_cache_release(p.v);
+}
+
+struct work_struct;
+int kblockd_schedule_work(struct work_struct *work);
+void kblockd_flush(void);
+
+#ifdef CONFIG_LBD
+# include <asm/div64.h>
+# define sector_div(a, b) do_div(a, b)
+#else
+# define sector_div(n, b)( \
+{ \
+        int _res; \
+        _res = (n) % (b); \
+        (n) /= (b); \
+        _res; \
+} \
+)
+#endif 
+
+#define MODULE_ALIAS_BLOCKDEV(major,minor) \
+        MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
+#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
+        MODULE_ALIAS("block-major-" __stringify(major) "-*")
+
+
+#endif
diff --git a/include/linux/blkpg.h b/include/linux/blkpg.h
new file mode 100644
index 000000000000..be5d0f4ad24c
--- /dev/null
+++ b/include/linux/blkpg.h
@@ -0,0 +1,57 @@
+#ifndef _LINUX_BLKPG_H
+#define _LINUX_BLKPG_H
+
+/*
+ * Partition table and disk geometry handling
+ *
+ * A single ioctl with lots of subfunctions:
+ *
+ * Device number stuff:
+ *    get_whole_disk()          (given the device number of a partition,
+ *                               find the device number of the encompassing disk)
+ *    get_all_partitions()      (given the device number of a disk, return the
+ *                               device numbers of all its known partitions)
+ *
+ * Partition stuff:
+ *    add_partition()
+ *    delete_partition()
+ *    test_partition_in_use()   (also for test_disk_in_use)
+ *
+ * Geometry stuff:
+ *    get_geometry()
+ *    set_geometry()
+ *    get_bios_drivedata()
+ *
+ * For today, only the partition stuff - aeb, 990515
+ */
+#include <linux/ioctl.h>
+
+#define BLKPG      _IO(0x12,105)
+
+/* The argument structure */
+struct blkpg_ioctl_arg {
+        int op;
+        int flags;
+        int datalen;
+        void __user *data;
+};
+
+/* The subfunctions (for the op field) */
+#define BLKPG_ADD_PARTITION     1
+#define BLKPG_DEL_PARTITION     2
+
+/* Sizes of name fields. Unused at present. */
+#define BLKPG_DEVNAMELTH        64
+#define BLKPG_VOLNAMELTH        64
+
+/* The data structure for ADD_PARTITION and DEL_PARTITION */
+struct blkpg_partition {
+        long long start;                /* starting offset in bytes */
+        long long length;               /* length in bytes */
+        int pno;                        /* partition number */
+        char devname[BLKPG_DEVNAMELTH]; /* partition name, like sda5 or c0d1p2,
+                                           to be used in kernel messages */
+        char volname[BLKPG_VOLNAMELTH]; /* volume label */
+};
+
+#endif /* _LINUX_BLKPG_H */
diff --git a/include/linux/blockgroup_lock.h b/include/linux/blockgroup_lock.h
new file mode 100644
index 000000000000..0137ee5dd43c
--- /dev/null
+++ b/include/linux/blockgroup_lock.h
@@ -0,0 +1,60 @@
+#ifndef _LINUX_BLOCKGROUP_LOCK_H
+#define _LINUX_BLOCKGROUP_LOCK_H
+/*
+ * Per-blockgroup locking for ext2 and ext3.
+ *
+ * Simple hashed spinlocking.
+ */
+
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/cache.h>
+
+#ifdef CONFIG_SMP
+
+/*
+ * We want a power-of-two.  Is there a better way than this?
+ */
+
+#if NR_CPUS >= 32
+#define NR_BG_LOCKS     128
+#elif NR_CPUS >= 16
+#define NR_BG_LOCKS     64
+#elif NR_CPUS >= 8
+#define NR_BG_LOCKS     32
+#elif NR_CPUS >= 4
+#define NR_BG_LOCKS     16
+#elif NR_CPUS >= 2
+#define NR_BG_LOCKS     8
+#else
+#define NR_BG_LOCKS     4
+#endif
+
+#else   /* CONFIG_SMP */
+#define NR_BG_LOCKS     1
+#endif  /* CONFIG_SMP */
+
+struct bgl_lock {
+        spinlock_t lock;
+} ____cacheline_aligned_in_smp;
+
+struct blockgroup_lock {
+        struct bgl_lock locks[NR_BG_LOCKS];
+};
+
+static inline void bgl_lock_init(struct blockgroup_lock *bgl)
+{
+        int i;
+
+        for (i = 0; i < NR_BG_LOCKS; i++)
+                spin_lock_init(&bgl->locks[i].lock);
+}
+
+/*
+ * The accessor is a macro so we can embed a blockgroup_lock into different
+ * superblock types
+ */
+#define sb_bgl_lock(sb, block_group) \
+        (&(sb)->s_blockgroup_lock.locks[(block_group) & (NR_BG_LOCKS-1)].lock)
+
+#endif
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
new file mode 100644
index 000000000000..0dd8ca1a3d5a
--- /dev/null
+++ b/include/linux/bootmem.h
@@ -0,0 +1,96 @@
+/*
+ * Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
+ */
+#ifndef _LINUX_BOOTMEM_H
+#define _LINUX_BOOTMEM_H
+
+#include <asm/pgtable.h>
+#include <asm/dma.h>
+#include <linux/cache.h>
+#include <linux/init.h>
+#include <linux/mmzone.h>
+
+/*
+ *  simple boot-time physical memory area allocator.
+ */
+
+extern unsigned long max_low_pfn;
+extern unsigned long min_low_pfn;
+
+/*
+ * highest page
+ */
+extern unsigned long max_pfn;
+
+/*
+ * node_bootmem_map is a map pointer - the bits represent all physical 
+ * memory pages (including holes) on the node.
+ */
+typedef struct bootmem_data {
+        unsigned long node_boot_start;
+        unsigned long node_low_pfn;
+        void *node_bootmem_map;
+        unsigned long last_offset;
+        unsigned long last_pos;
+        unsigned long last_success;     /* Previous allocation point.  To speed
+                                         * up searching */
+} bootmem_data_t;
+
+extern unsigned long __init bootmem_bootmap_pages (unsigned long);
+extern unsigned long __init init_bootmem (unsigned long addr, unsigned long memend);
+extern void __init free_bootmem (unsigned long addr, unsigned long size);
+extern void * __init __alloc_bootmem (unsigned long size, unsigned long align, unsigned long goal);
+#ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
+extern void __init reserve_bootmem (unsigned long addr, unsigned long size);
+#define alloc_bootmem(x) \
+        __alloc_bootmem((x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_low(x) \
+        __alloc_bootmem((x), SMP_CACHE_BYTES, 0)
+#define alloc_bootmem_pages(x) \
+        __alloc_bootmem((x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_low_pages(x) \
+        __alloc_bootmem((x), PAGE_SIZE, 0)
+#endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
+extern unsigned long __init free_all_bootmem (void);
+
+extern unsigned long __init init_bootmem_node (pg_data_t *pgdat, unsigned long freepfn, unsigned long startpfn, unsigned long endpfn);
+extern void __init reserve_bootmem_node (pg_data_t *pgdat, unsigned long physaddr, unsigned long size);
+extern void __init free_bootmem_node (pg_data_t *pgdat, unsigned long addr, unsigned long size);
+extern unsigned long __init free_all_bootmem_node (pg_data_t *pgdat);
+extern void * __init __alloc_bootmem_node (pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal);
+#ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
+#define alloc_bootmem_node(pgdat, x) \
+        __alloc_bootmem_node((pgdat), (x), SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_pages_node(pgdat, x) \
+        __alloc_bootmem_node((pgdat), (x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_low_pages_node(pgdat, x) \
+        __alloc_bootmem_node((pgdat), (x), PAGE_SIZE, 0)
+#endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
+
+extern unsigned long __initdata nr_kernel_pages;
+extern unsigned long __initdata nr_all_pages;
+
+extern void *__init alloc_large_system_hash(const char *tablename,
+                                            unsigned long bucketsize,
+                                            unsigned long numentries,
+                                            int scale,
+                                            int flags,
+                                            unsigned int *_hash_shift,
+                                            unsigned int *_hash_mask,
+                                            unsigned long limit);
+
+#define HASH_HIGHMEM    0x00000001      /* Consider highmem? */
+#define HASH_EARLY      0x00000002      /* Allocating during early boot? */
+
+/* Only NUMA needs hash distribution.
+ * IA64 is known to have sufficient vmalloc space.
+ */
+#if defined(CONFIG_NUMA) && defined(CONFIG_IA64)
+#define HASHDIST_DEFAULT 1
+#else
+#define HASHDIST_DEFAULT 0
+#endif
+extern int __initdata hashdist;         /* Distribute hashes across NUMA nodes? */
+
+
+#endif /* _LINUX_BOOTMEM_H */
diff --git a/include/linux/bpqether.h b/include/linux/bpqether.h
new file mode 100644
index 000000000000..a6c35e1a89ad
--- /dev/null
+++ b/include/linux/bpqether.h
@@ -0,0 +1,41 @@
+#ifndef __BPQETHER_H
+#define __BPQETHER_H
+
+/*
+ *      Defines for the BPQETHER pseudo device driver
+ */
+
+#ifndef __LINUX_IF_ETHER_H
+#include <linux/if_ether.h>
+#endif
+
+#define SIOCSBPQETHOPT          (SIOCDEVPRIVATE+0)      /* reserved */
+#define SIOCSBPQETHADDR         (SIOCDEVPRIVATE+1)
+ 
+struct bpq_ethaddr {
+        unsigned char destination[ETH_ALEN];
+        unsigned char accept[ETH_ALEN];
+};
+
+/* 
+ * For SIOCSBPQETHOPT - this is compatible with PI2/PacketTwin card drivers,
+ * currently not implemented, though. If someone wants to hook a radio
+ * to his Ethernet card he may find this useful. ;-)
+ */
+
+#define SIOCGBPQETHPARAM        0x5000  /* get Level 1 parameters */
+#define SIOCSBPQETHPARAM        0x5001  /* set */
+
+struct bpq_req  {
+    int cmd;
+    int speed;                  /* unused */
+    int clockmode;              /* unused */
+    int txdelay;
+    unsigned char persist;      /* unused */
+    int slotime;                /* unused */
+    int squeldelay;
+    int dmachan;                /* unused */
+    int irq;                    /* unused */
+};
+
+#endif
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
new file mode 100644
index 000000000000..802c91e9b3da
--- /dev/null
+++ b/include/linux/buffer_head.h
@@ -0,0 +1,296 @@
+/*
+ * include/linux/buffer_head.h
+ *
+ * Everything to do with buffer_heads.
+ */
+
+#ifndef _LINUX_BUFFER_HEAD_H
+#define _LINUX_BUFFER_HEAD_H
+
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/linkage.h>
+#include <linux/pagemap.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+
+enum bh_state_bits {
+        BH_Uptodate,    /* Contains valid data */
+        BH_Dirty,       /* Is dirty */
+        BH_Lock,        /* Is locked */
+        BH_Req,         /* Has been submitted for I/O */
+
+        BH_Mapped,      /* Has a disk mapping */
+        BH_New,         /* Disk mapping was newly created by get_block */
+        BH_Async_Read,  /* Is under end_buffer_async_read I/O */
+        BH_Async_Write, /* Is under end_buffer_async_write I/O */
+        BH_Delay,       /* Buffer is not yet allocated on disk */
+        BH_Boundary,    /* Block is followed by a discontiguity */
+        BH_Write_EIO,   /* I/O error on write */
+        BH_Ordered,     /* ordered write */
+        BH_Eopnotsupp,  /* operation not supported (barrier) */
+
+        BH_PrivateStart,/* not a state bit, but the first bit available
+                         * for private allocation by other entities
+                         */
+};
+
+#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
+
+struct page;
+struct buffer_head;
+struct address_space;
+typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
+
+/*
+ * Keep related fields in common cachelines.  The most commonly accessed
+ * field (b_state) goes at the start so the compiler does not generate
+ * indexed addressing for it.
+ */
+struct buffer_head {
+        /* First cache line: */
+        unsigned long b_state;          /* buffer state bitmap (see above) */
+        struct buffer_head *b_this_page;/* circular list of page's buffers */
+        struct page *b_page;            /* the page this bh is mapped to */
+        atomic_t b_count;               /* users using this block */
+        u32 b_size;                     /* block size */
+
+        sector_t b_blocknr;             /* block number */
+        char *b_data;                   /* pointer to data block */
+
+        struct block_device *b_bdev;
+        bh_end_io_t *b_end_io;          /* I/O completion */
+        void *b_private;                /* reserved for b_end_io */
+        struct list_head b_assoc_buffers; /* associated with another mapping */
+};
+
+/*
+ * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
+ * and buffer_foo() functions.
+ */
+#define BUFFER_FNS(bit, name)                                           \
+static inline void set_buffer_##name(struct buffer_head *bh)            \
+{                                                                       \
+        set_bit(BH_##bit, &(bh)->b_state);                              \
+}                                                                       \
+static inline void clear_buffer_##name(struct buffer_head *bh)          \
+{                                                                       \
+        clear_bit(BH_##bit, &(bh)->b_state);                            \
+}                                                                       \
+static inline int buffer_##name(const struct buffer_head *bh)           \
+{                                                                       \
+        return test_bit(BH_##bit, &(bh)->b_state);                      \
+}
+
+/*
+ * test_set_buffer_foo() and test_clear_buffer_foo()
+ */
+#define TAS_BUFFER_FNS(bit, name)                                       \
+static inline int test_set_buffer_##name(struct buffer_head *bh)        \
+{                                                                       \
+        return test_and_set_bit(BH_##bit, &(bh)->b_state);              \
+}                                                                       \
+static inline int test_clear_buffer_##name(struct buffer_head *bh)      \
+{                                                                       \
+        return test_and_clear_bit(BH_##bit, &(bh)->b_state);            \
+}                                                                       \
+
+/*
+ * Emit the buffer bitops functions.   Note that there are also functions
+ * of the form "mark_buffer_foo()".  These are higher-level functions which
+ * do something in addition to setting a b_state bit.
+ */
+BUFFER_FNS(Uptodate, uptodate)
+BUFFER_FNS(Dirty, dirty)
+TAS_BUFFER_FNS(Dirty, dirty)
+BUFFER_FNS(Lock, locked)
+TAS_BUFFER_FNS(Lock, locked)
+BUFFER_FNS(Req, req)
+TAS_BUFFER_FNS(Req, req)
+BUFFER_FNS(Mapped, mapped)
+BUFFER_FNS(New, new)
+BUFFER_FNS(Async_Read, async_read)
+BUFFER_FNS(Async_Write, async_write)
+BUFFER_FNS(Delay, delay)
+BUFFER_FNS(Boundary, boundary)
+BUFFER_FNS(Write_EIO, write_io_error)
+BUFFER_FNS(Ordered, ordered)
+BUFFER_FNS(Eopnotsupp, eopnotsupp)
+
+#define bh_offset(bh)           ((unsigned long)(bh)->b_data & ~PAGE_MASK)
+#define touch_buffer(bh)        mark_page_accessed(bh->b_page)
+
+/* If we *know* page->private refers to buffer_heads */
+#define page_buffers(page)                                      \
+        ({                                                      \
+                BUG_ON(!PagePrivate(page));             \
+                ((struct buffer_head *)(page)->private);        \
+        })
+#define page_has_buffers(page)  PagePrivate(page)
+
+/*
+ * Declarations
+ */
+
+void FASTCALL(mark_buffer_dirty(struct buffer_head *bh));
+void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
+void set_bh_page(struct buffer_head *bh,
+                struct page *page, unsigned long offset);
+int try_to_free_buffers(struct page *);
+struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
+                int retry);
+void create_empty_buffers(struct page *, unsigned long,
+                        unsigned long b_state);
+void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
+void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
+void end_buffer_async_write(struct buffer_head *bh, int uptodate);
+
+/* Things to do with buffers at mapping->private_list */
+void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
+int inode_has_buffers(struct inode *);
+void invalidate_inode_buffers(struct inode *);
+int remove_inode_buffers(struct inode *inode);
+int sync_mapping_buffers(struct address_space *mapping);
+void unmap_underlying_metadata(struct block_device *bdev, sector_t block);
+
+void mark_buffer_async_write(struct buffer_head *bh);
+void invalidate_bdev(struct block_device *, int);
+int sync_blockdev(struct block_device *bdev);
+void __wait_on_buffer(struct buffer_head *);
+wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
+int fsync_bdev(struct block_device *);
+struct super_block *freeze_bdev(struct block_device *);
+void thaw_bdev(struct block_device *, struct super_block *);
+int fsync_super(struct super_block *);
+int fsync_no_super(struct block_device *);
+struct buffer_head *__find_get_block(struct block_device *, sector_t, int);
+struct buffer_head * __getblk(struct block_device *, sector_t, int);
+void __brelse(struct buffer_head *);
+void __bforget(struct buffer_head *);
+void __breadahead(struct block_device *, sector_t block, int size);
+struct buffer_head *__bread(struct block_device *, sector_t block, int size);
+struct buffer_head *alloc_buffer_head(unsigned int __nocast gfp_flags);
+void free_buffer_head(struct buffer_head * bh);
+void FASTCALL(unlock_buffer(struct buffer_head *bh));
+void FASTCALL(__lock_buffer(struct buffer_head *bh));
+void ll_rw_block(int, int, struct buffer_head * bh[]);
+int sync_dirty_buffer(struct buffer_head *bh);
+int submit_bh(int, struct buffer_head *);
+void write_boundary_block(struct block_device *bdev,
+                        sector_t bblock, unsigned blocksize);
+
+extern int buffer_heads_over_limit;
+
+/*
+ * Generic address_space_operations implementations for buffer_head-backed
+ * address_spaces.
+ */
+int try_to_release_page(struct page * page, int gfp_mask);
+int block_invalidatepage(struct page *page, unsigned long offset);
+int block_write_full_page(struct page *page, get_block_t *get_block,
+                                struct writeback_control *wbc);
+int block_read_full_page(struct page*, get_block_t*);
+int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
+int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
+                                loff_t *);
+int generic_cont_expand(struct inode *inode, loff_t size) ;
+int block_commit_write(struct page *page, unsigned from, unsigned to);
+int block_sync_page(struct page *);
+sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
+int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
+int block_truncate_page(struct address_space *, loff_t, get_block_t *);
+int file_fsync(struct file *, struct dentry *, int);
+int nobh_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
+int nobh_commit_write(struct file *, struct page *, unsigned, unsigned);
+int nobh_truncate_page(struct address_space *, loff_t);
+int nobh_writepage(struct page *page, get_block_t *get_block,
+                        struct writeback_control *wbc);
+
+
+/*
+ * inline definitions
+ */
+
+static inline void attach_page_buffers(struct page *page,
+                struct buffer_head *head)
+{
+        page_cache_get(page);
+        SetPagePrivate(page);
+        page->private = (unsigned long)head;
+}
+
+static inline void get_bh(struct buffer_head *bh)
+{
+        atomic_inc(&bh->b_count);
+}
+
+static inline void put_bh(struct buffer_head *bh)
+{
+        smp_mb__before_atomic_dec();
+        atomic_dec(&bh->b_count);
+}
+
+static inline void brelse(struct buffer_head *bh)
+{
+        if (bh)
+                __brelse(bh);
+}
+
+static inline void bforget(struct buffer_head *bh)
+{
+        if (bh)
+                __bforget(bh);
+}
+
+static inline struct buffer_head *
+sb_bread(struct super_block *sb, sector_t block)
+{
+        return __bread(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline void
+sb_breadahead(struct super_block *sb, sector_t block)
+{
+        __breadahead(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline struct buffer_head *
+sb_getblk(struct super_block *sb, sector_t block)
+{
+        return __getblk(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline struct buffer_head *
+sb_find_get_block(struct super_block *sb, sector_t block)
+{
+        return __find_get_block(sb->s_bdev, block, sb->s_blocksize);
+}
+
+static inline void
+map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
+{
+        set_buffer_mapped(bh);
+        bh->b_bdev = sb->s_bdev;
+        bh->b_blocknr = block;
+}
+
+/*
+ * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
+ * __wait_on_buffer() just to trip a debug check.  Because debug code in inline
+ * functions is bloaty.
+ */
+static inline void wait_on_buffer(struct buffer_head *bh)
+{
+        might_sleep();
+        if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
+                __wait_on_buffer(bh);
+}
+
+static inline void lock_buffer(struct buffer_head *bh)
+{
+        might_sleep();
+        if (test_set_buffer_locked(bh))
+                __lock_buffer(bh);
+}
+
+#endif /* _LINUX_BUFFER_HEAD_H */
diff --git a/include/linux/byteorder/big_endian.h b/include/linux/byteorder/big_endian.h
new file mode 100644
index 000000000000..bef87891cb24
--- /dev/null
+++ b/include/linux/byteorder/big_endian.h
@@ -0,0 +1,106 @@
+#ifndef _LINUX_BYTEORDER_BIG_ENDIAN_H
+#define _LINUX_BYTEORDER_BIG_ENDIAN_H
+
+#ifndef __BIG_ENDIAN
+#define __BIG_ENDIAN 4321
+#endif
+#ifndef __BIG_ENDIAN_BITFIELD
+#define __BIG_ENDIAN_BITFIELD
+#endif
+
+#include <linux/types.h>
+#include <linux/byteorder/swab.h>
+
+#define __constant_htonl(x) ((__force __be32)(__u32)(x))
+#define __constant_ntohl(x) ((__force __u32)(__be32)(x))
+#define __constant_htons(x) ((__force __be16)(__u16)(x))
+#define __constant_ntohs(x) ((__force __u16)(__be16)(x))
+#define __constant_cpu_to_le64(x) ((__force __le64)___constant_swab64((x)))
+#define __constant_le64_to_cpu(x) ___constant_swab64((__force __u64)(__le64)(x))
+#define __constant_cpu_to_le32(x) ((__force __le32)___constant_swab32((x)))
+#define __constant_le32_to_cpu(x) ___constant_swab32((__force __u32)(__le32)(x))
+#define __constant_cpu_to_le16(x) ((__force __le16)___constant_swab16((x)))
+#define __constant_le16_to_cpu(x) ___constant_swab16((__force __u16)(__le16)(x))
+#define __constant_cpu_to_be64(x) ((__force __be64)(__u64)(x))
+#define __constant_be64_to_cpu(x) ((__force __u64)(__be64)(x))
+#define __constant_cpu_to_be32(x) ((__force __be32)(__u32)(x))
+#define __constant_be32_to_cpu(x) ((__force __u32)(__be32)(x))
+#define __constant_cpu_to_be16(x) ((__force __be16)(__u16)(x))
+#define __constant_be16_to_cpu(x) ((__force __u16)(__be16)(x))
+#define __cpu_to_le64(x) ((__force __le64)__swab64((x)))
+#define __le64_to_cpu(x) __swab64((__force __u64)(__le64)(x))
+#define __cpu_to_le32(x) ((__force __le32)__swab32((x)))
+#define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
+#define __cpu_to_le16(x) ((__force __le16)__swab16((x)))
+#define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x))
+#define __cpu_to_be64(x) ((__force __be64)(__u64)(x))
+#define __be64_to_cpu(x) ((__force __u64)(__be64)(x))
+#define __cpu_to_be32(x) ((__force __be32)(__u32)(x))
+#define __be32_to_cpu(x) ((__force __u32)(__be32)(x))
+#define __cpu_to_be16(x) ((__force __be16)(__u16)(x))
+#define __be16_to_cpu(x) ((__force __u16)(__be16)(x))
+
+static inline __le64 __cpu_to_le64p(const __u64 *p)
+{
+        return (__force __le64)__swab64p(p);
+}
+static inline __u64 __le64_to_cpup(const __le64 *p)
+{
+        return __swab64p((__u64 *)p);
+}
+static inline __le32 __cpu_to_le32p(const __u32 *p)
+{
+        return (__force __le32)__swab32p(p);
+}
+static inline __u32 __le32_to_cpup(const __le32 *p)
+{
+        return __swab32p((__u32 *)p);
+}
+static inline __le16 __cpu_to_le16p(const __u16 *p)
+{
+        return (__force __le16)__swab16p(p);
+}
+static inline __u16 __le16_to_cpup(const __le16 *p)
+{
+        return __swab16p((__u16 *)p);
+}
+static inline __be64 __cpu_to_be64p(const __u64 *p)
+{
+        return (__force __be64)*p;
+}
+static inline __u64 __be64_to_cpup(const __be64 *p)
+{
+        return (__force __u64)*p;
+}
+static inline __be32 __cpu_to_be32p(const __u32 *p)
+{
+        return (__force __be32)*p;
+}
+static inline __u32 __be32_to_cpup(const __be32 *p)
+{
+        return (__force __u32)*p;
+}
+static inline __be16 __cpu_to_be16p(const __u16 *p)
+{
+        return (__force __be16)*p;
+}
+static inline __u16 __be16_to_cpup(const __be16 *p)
+{
+        return (__force __u16)*p;
+}
+#define __cpu_to_le64s(x) __swab64s((x))
+#define __le64_to_cpus(x) __swab64s((x))
+#define __cpu_to_le32s(x) __swab32s((x))
+#define __le32_to_cpus(x) __swab32s((x))
+#define __cpu_to_le16s(x) __swab16s((x))
+#define __le16_to_cpus(x) __swab16s((x))
+#define __cpu_to_be64s(x) do {} while (0)
+#define __be64_to_cpus(x) do {} while (0)
+#define __cpu_to_be32s(x) do {} while (0)
+#define __be32_to_cpus(x) do {} while (0)
+#define __cpu_to_be16s(x) do {} while (0)
+#define __be16_to_cpus(x) do {} while (0)
+
+#include <linux/byteorder/generic.h>
+
+#endif /* _LINUX_BYTEORDER_BIG_ENDIAN_H */
diff --git a/include/linux/byteorder/generic.h b/include/linux/byteorder/generic.h
new file mode 100644
index 000000000000..5fde6f4d6c1e
--- /dev/null
+++ b/include/linux/byteorder/generic.h
@@ -0,0 +1,172 @@
+#ifndef _LINUX_BYTEORDER_GENERIC_H
+#define _LINUX_BYTEORDER_GENERIC_H
+
+/*
+ * linux/byteorder_generic.h
+ * Generic Byte-reordering support
+ *
+ * Francois-Rene Rideau <fare@tunes.org> 19970707
+ *    gathered all the good ideas from all asm-foo/byteorder.h into one file,
+ *    cleaned them up.
+ *    I hope it is compliant with non-GCC compilers.
+ *    I decided to put __BYTEORDER_HAS_U64__ in byteorder.h,
+ *    because I wasn't sure it would be ok to put it in types.h
+ *    Upgraded it to 2.1.43
+ * Francois-Rene Rideau <fare@tunes.org> 19971012
+ *    Upgraded it to 2.1.57
+ *    to please Linus T., replaced huge #ifdef's between little/big endian
+ *    by nestedly #include'd files.
+ * Francois-Rene Rideau <fare@tunes.org> 19971205
+ *    Made it to 2.1.71; now a facelift:
+ *    Put files under include/linux/byteorder/
+ *    Split swab from generic support.
+ *
+ * TODO:
+ *   = Regular kernel maintainers could also replace all these manual
+ *    byteswap macros that remain, disseminated among drivers,
+ *    after some grep or the sources...
+ *   = Linus might want to rename all these macros and files to fit his taste,
+ *    to fit his personal naming scheme.
+ *   = it seems that a few drivers would also appreciate
+ *    nybble swapping support...
+ *   = every architecture could add their byteswap macro in asm/byteorder.h
+ *    see how some architectures already do (i386, alpha, ppc, etc)
+ *   = cpu_to_beXX and beXX_to_cpu might some day need to be well
+ *    distinguished throughout the kernel. This is not the case currently,
+ *    since little endian, big endian, and pdp endian machines needn't it.
+ *    But this might be the case for, say, a port of Linux to 20/21 bit
+ *    architectures (and F21 Linux addict around?).
+ */
+
+/*
+ * The following macros are to be defined by <asm/byteorder.h>:
+ *
+ * Conversion of long and short int between network and host format
+ *      ntohl(__u32 x)
+ *      ntohs(__u16 x)
+ *      htonl(__u32 x)
+ *      htons(__u16 x)
+ * It seems that some programs (which? where? or perhaps a standard? POSIX?)
+ * might like the above to be functions, not macros (why?).
+ * if that's true, then detect them, and take measures.
+ * Anyway, the measure is: define only ___ntohl as a macro instead,
+ * and in a separate file, have
+ * unsigned long inline ntohl(x){return ___ntohl(x);}
+ *
+ * The same for constant arguments
+ *      __constant_ntohl(__u32 x)
+ *      __constant_ntohs(__u16 x)
+ *      __constant_htonl(__u32 x)
+ *      __constant_htons(__u16 x)
+ *
+ * Conversion of XX-bit integers (16- 32- or 64-)
+ * between native CPU format and little/big endian format
+ * 64-bit stuff only defined for proper architectures
+ *      cpu_to_[bl]eXX(__uXX x)
+ *      [bl]eXX_to_cpu(__uXX x)
+ *
+ * The same, but takes a pointer to the value to convert
+ *      cpu_to_[bl]eXXp(__uXX x)
+ *      [bl]eXX_to_cpup(__uXX x)
+ *
+ * The same, but change in situ
+ *      cpu_to_[bl]eXXs(__uXX x)
+ *      [bl]eXX_to_cpus(__uXX x)
+ *
+ * See asm-foo/byteorder.h for examples of how to provide
+ * architecture-optimized versions
+ *
+ */
+
+
+#if defined(__KERNEL__)
+/*
+ * inside the kernel, we can use nicknames;
+ * outside of it, we must avoid POSIX namespace pollution...
+ */
+#define cpu_to_le64 __cpu_to_le64
+#define le64_to_cpu __le64_to_cpu
+#define cpu_to_le32 __cpu_to_le32
+#define le32_to_cpu __le32_to_cpu
+#define cpu_to_le16 __cpu_to_le16
+#define le16_to_cpu __le16_to_cpu
+#define cpu_to_be64 __cpu_to_be64
+#define be64_to_cpu __be64_to_cpu
+#define cpu_to_be32 __cpu_to_be32
+#define be32_to_cpu __be32_to_cpu
+#define cpu_to_be16 __cpu_to_be16
+#define be16_to_cpu __be16_to_cpu
+#define cpu_to_le64p __cpu_to_le64p
+#define le64_to_cpup __le64_to_cpup
+#define cpu_to_le32p __cpu_to_le32p
+#define le32_to_cpup __le32_to_cpup
+#define cpu_to_le16p __cpu_to_le16p
+#define le16_to_cpup __le16_to_cpup
+#define cpu_to_be64p __cpu_to_be64p
+#define be64_to_cpup __be64_to_cpup
+#define cpu_to_be32p __cpu_to_be32p
+#define be32_to_cpup __be32_to_cpup
+#define cpu_to_be16p __cpu_to_be16p
+#define be16_to_cpup __be16_to_cpup
+#define cpu_to_le64s __cpu_to_le64s
+#define le64_to_cpus __le64_to_cpus
+#define cpu_to_le32s __cpu_to_le32s
+#define le32_to_cpus __le32_to_cpus
+#define cpu_to_le16s __cpu_to_le16s
+#define le16_to_cpus __le16_to_cpus
+#define cpu_to_be64s __cpu_to_be64s
+#define be64_to_cpus __be64_to_cpus
+#define cpu_to_be32s __cpu_to_be32s
+#define be32_to_cpus __be32_to_cpus
+#define cpu_to_be16s __cpu_to_be16s
+#define be16_to_cpus __be16_to_cpus
+#endif
+
+
+#if defined(__KERNEL__)
+/*
+ * Handle ntohl and suches. These have various compatibility
+ * issues - like we want to give the prototype even though we
+ * also have a macro for them in case some strange program
+ * wants to take the address of the thing or something..
+ *
+ * Note that these used to return a "long" in libc5, even though
+ * long is often 64-bit these days.. Thus the casts.
+ *
+ * They have to be macros in order to do the constant folding
+ * correctly - if the argument passed into a inline function
+ * it is no longer constant according to gcc..
+ */
+
+#undef ntohl
+#undef ntohs
+#undef htonl
+#undef htons
+
+/*
+ * Do the prototypes. Somebody might want to take the
+ * address or some such sick thing..
+ */
+extern __u32                    ntohl(__be32);
+extern __be32                   htonl(__u32);
+extern __u16                    ntohs(__be16);
+extern __be16                   htons(__u16);
+
+#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+
+#define ___htonl(x) __cpu_to_be32(x)
+#define ___htons(x) __cpu_to_be16(x)
+#define ___ntohl(x) __be32_to_cpu(x)
+#define ___ntohs(x) __be16_to_cpu(x)
+
+#define htonl(x) ___htonl(x)
+#define ntohl(x) ___ntohl(x)
+#define htons(x) ___htons(x)
+#define ntohs(x) ___ntohs(x)
+
+#endif /* OPTIMIZE */
+
+#endif /* KERNEL */
+
+
+#endif /* _LINUX_BYTEORDER_GENERIC_H */
diff --git a/include/linux/byteorder/little_endian.h b/include/linux/byteorder/little_endian.h
new file mode 100644
index 000000000000..86e62b750176
--- /dev/null
+++ b/include/linux/byteorder/little_endian.h
@@ -0,0 +1,106 @@
+#ifndef _LINUX_BYTEORDER_LITTLE_ENDIAN_H
+#define _LINUX_BYTEORDER_LITTLE_ENDIAN_H
+
+#ifndef __LITTLE_ENDIAN
+#define __LITTLE_ENDIAN 1234
+#endif
+#ifndef __LITTLE_ENDIAN_BITFIELD
+#define __LITTLE_ENDIAN_BITFIELD
+#endif
+
+#include <linux/types.h>
+#include <linux/byteorder/swab.h>
+
+#define __constant_htonl(x) ((__force __be32)___constant_swab32((x)))
+#define __constant_ntohl(x) ___constant_swab32((__force __be32)(x))
+#define __constant_htons(x) ((__force __be16)___constant_swab16((x)))
+#define __constant_ntohs(x) ___constant_swab16((__force __be16)(x))
+#define __constant_cpu_to_le64(x) ((__force __le64)(__u64)(x))
+#define __constant_le64_to_cpu(x) ((__force __u64)(__le64)(x))
+#define __constant_cpu_to_le32(x) ((__force __le32)(__u32)(x))
+#define __constant_le32_to_cpu(x) ((__force __u32)(__le32)(x))
+#define __constant_cpu_to_le16(x) ((__force __le16)(__u16)(x))
+#define __constant_le16_to_cpu(x) ((__force __u16)(__le16)(x))
+#define __constant_cpu_to_be64(x) ((__force __be64)___constant_swab64((x)))
+#define __constant_be64_to_cpu(x) ___constant_swab64((__force __u64)(__be64)(x))
+#define __constant_cpu_to_be32(x) ((__force __be32)___constant_swab32((x)))
+#define __constant_be32_to_cpu(x) ___constant_swab32((__force __u32)(__be32)(x))
+#define __constant_cpu_to_be16(x) ((__force __be16)___constant_swab16((x)))
+#define __constant_be16_to_cpu(x) ___constant_swab16((__force __u16)(__be16)(x))
+#define __cpu_to_le64(x) ((__force __le64)(__u64)(x))
+#define __le64_to_cpu(x) ((__force __u64)(__le64)(x))
+#define __cpu_to_le32(x) ((__force __le32)(__u32)(x))
+#define __le32_to_cpu(x) ((__force __u32)(__le32)(x))
+#define __cpu_to_le16(x) ((__force __le16)(__u16)(x))
+#define __le16_to_cpu(x) ((__force __u16)(__le16)(x))
+#define __cpu_to_be64(x) ((__force __be64)__swab64((x)))
+#define __be64_to_cpu(x) __swab64((__force __u64)(__be64)(x))
+#define __cpu_to_be32(x) ((__force __be32)__swab32((x)))
+#define __be32_to_cpu(x) __swab32((__force __u32)(__be32)(x))
+#define __cpu_to_be16(x) ((__force __be16)__swab16((x)))
+#define __be16_to_cpu(x) __swab16((__force __u16)(__be16)(x))
+
+static inline __le64 __cpu_to_le64p(const __u64 *p)
+{
+        return (__force __le64)*p;
+}
+static inline __u64 __le64_to_cpup(const __le64 *p)
+{
+        return (__force __u64)*p;
+}
+static inline __le32 __cpu_to_le32p(const __u32 *p)
+{
+        return (__force __le32)*p;
+}
+static inline __u32 __le32_to_cpup(const __le32 *p)
+{
+        return (__force __u32)*p;
+}
+static inline __le16 __cpu_to_le16p(const __u16 *p)
+{
+        return (__force __le16)*p;
+}
+static inline __u16 __le16_to_cpup(const __le16 *p)
+{
+        return (__force __u16)*p;
+}
+static inline __be64 __cpu_to_be64p(const __u64 *p)
+{
+        return (__force __be64)__swab64p(p);
+}
+static inline __u64 __be64_to_cpup(const __be64 *p)
+{
+        return __swab64p((__u64 *)p);
+}
+static inline __be32 __cpu_to_be32p(const __u32 *p)
+{
+        return (__force __be32)__swab32p(p);
+}
+static inline __u32 __be32_to_cpup(const __be32 *p)
+{
+        return __swab32p((__u32 *)p);
+}
+static inline __be16 __cpu_to_be16p(const __u16 *p)
+{
+        return (__force __be16)__swab16p(p);
+}
+static inline __u16 __be16_to_cpup(const __be16 *p)
+{
+        return __swab16p((__u16 *)p);
+}
+#define __cpu_to_le64s(x) do {} while (0)
+#define __le64_to_cpus(x) do {} while (0)
+#define __cpu_to_le32s(x) do {} while (0)
+#define __le32_to_cpus(x) do {} while (0)
+#define __cpu_to_le16s(x) do {} while (0)
+#define __le16_to_cpus(x) do {} while (0)
+#define __cpu_to_be64s(x) __swab64s((x))
+#define __be64_to_cpus(x) __swab64s((x))
+#define __cpu_to_be32s(x) __swab32s((x))
+#define __be32_to_cpus(x) __swab32s((x))
+#define __cpu_to_be16s(x) __swab16s((x))
+#define __be16_to_cpus(x) __swab16s((x))
+
+#include <linux/byteorder/generic.h>
+
+#endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */
diff --git a/include/linux/byteorder/pdp_endian.h b/include/linux/byteorder/pdp_endian.h
new file mode 100644
index 000000000000..618631cbc6e3
--- /dev/null
+++ b/include/linux/byteorder/pdp_endian.h
@@ -0,0 +1,88 @@
+#ifndef _LINUX_BYTEORDER_PDP_ENDIAN_H
+#define _LINUX_BYTEORDER_PDP_ENDIAN_H
+
+/*
+ * Could have been named NUXI-endian, but we use the same name as in glibc.
+ * hopefully only the PDP and its evolutions (old VAXen in compatibility mode)
+ * should ever use this braindead byteorder.
+ * This file *should* work, but has not been tested.
+ *
+ * little-endian is 1234; big-endian is 4321; nuxi/pdp-endian is 3412
+ *
+ * I thought vaxen were NUXI-endian, but was told they were correct-endian
+ * (little-endian), though indeed there existed NUXI-endian machines
+ * (DEC PDP-11 and old VAXen in compatibility mode).
+ * This makes this file a bit useless, but as a proof-of-concept.
+ *
+ * But what does a __u64 look like: is it 34127856 or 78563412 ???
+ * I don't dare imagine! Hence, no 64-bit byteorder support yet.
+ * Hopefully, there 64-bit pdp-endian support shouldn't ever be required.
+ *
+ */
+
+#ifndef __PDP_ENDIAN
+#define __PDP_ENDIAN 3412
+#endif
+#ifndef __PDP_ENDIAN_BITFIELD
+#define __PDP_ENDIAN_BITFIELD
+#endif
+
+#include <linux/byteorder/swab.h>
+#include <linux/byteorder/swabb.h>
+
+#define __constant_htonl(x) ___constant_swahb32((x))
+#define __constant_ntohl(x) ___constant_swahb32((x))
+#define __constant_htons(x) ___constant_swab16((x))
+#define __constant_ntohs(x) ___constant_swab16((x))
+#define __constant_cpu_to_le64(x) I DON'T KNOW
+#define __constant_le64_to_cpu(x) I DON'T KNOW
+#define __constant_cpu_to_le32(x) ___constant_swahw32((x))
+#define __constant_le32_to_cpu(x) ___constant_swahw32((x))
+#define __constant_cpu_to_le16(x) ((__u16)(x)
+#define __constant_le16_to_cpu(x) ((__u16)(x)
+#define __constant_cpu_to_be64(x) I DON'T KNOW
+#define __constant_be64_to_cpu(x) I DON'T KNOW
+#define __constant_cpu_to_be32(x) ___constant_swahb32((x))
+#define __constant_be32_to_cpu(x) ___constant_swahb32((x))
+#define __constant_cpu_to_be16(x) ___constant_swab16((x))
+#define __constant_be16_to_cpu(x) ___constant_swab16((x))
+#define __cpu_to_le64(x) I DON'T KNOW
+#define __le64_to_cpu(x) I DON'T KNOW
+#define __cpu_to_le32(x) ___swahw32((x))
+#define __le32_to_cpu(x) ___swahw32((x))
+#define __cpu_to_le16(x) ((__u16)(x)
+#define __le16_to_cpu(x) ((__u16)(x)
+#define __cpu_to_be64(x) I DON'T KNOW
+#define __be64_to_cpu(x) I DON'T KNOW
+#define __cpu_to_be32(x) __swahb32((x))
+#define __be32_to_cpu(x) __swahb32((x))
+#define __cpu_to_be16(x) __swab16((x))
+#define __be16_to_cpu(x) __swab16((x))
+#define __cpu_to_le64p(x) I DON'T KNOW
+#define __le64_to_cpup(x) I DON'T KNOW
+#define __cpu_to_le32p(x) ___swahw32p((x))
+#define __le32_to_cpup(x) ___swahw32p((x))
+#define __cpu_to_le16p(x) (*(__u16*)(x))
+#define __le16_to_cpup(x) (*(__u16*)(x))
+#define __cpu_to_be64p(x) I DON'T KNOW
+#define __be64_to_cpup(x) I DON'T KNOW
+#define __cpu_to_be32p(x) __swahb32p((x))
+#define __be32_to_cpup(x) __swahb32p((x))
+#define __cpu_to_be16p(x) __swab16p((x))
+#define __be16_to_cpup(x) __swab16p((x))
+#define __cpu_to_le64s(x) I DON'T KNOW
+#define __le64_to_cpus(x) I DON'T KNOW
+#define __cpu_to_le32s(x) ___swahw32s((x))
+#define __le32_to_cpus(x) ___swahw32s((x))
+#define __cpu_to_le16s(x) do {} while (0)
+#define __le16_to_cpus(x) do {} while (0)
+#define __cpu_to_be64s(x) I DON'T KNOW
+#define __be64_to_cpus(x) I DON'T KNOW
+#define __cpu_to_be32s(x) __swahb32s((x))
+#define __be32_to_cpus(x) __swahb32s((x))
+#define __cpu_to_be16s(x) __swab16s((x))
+#define __be16_to_cpus(x) __swab16s((x))
+
+#include <linux/byteorder/generic.h>
+
+#endif /* _LINUX_BYTEORDER_PDP_ENDIAN_H */
diff --git a/include/linux/byteorder/swab.h b/include/linux/byteorder/swab.h
new file mode 100644
index 000000000000..2f1cb775125a
--- /dev/null
+++ b/include/linux/byteorder/swab.h
@@ -0,0 +1,192 @@
+#ifndef _LINUX_BYTEORDER_SWAB_H
+#define _LINUX_BYTEORDER_SWAB_H
+
+/*
+ * linux/byteorder/swab.h
+ * Byte-swapping, independently from CPU endianness
+ *      swabXX[ps]?(foo)
+ *
+ * Francois-Rene Rideau <fare@tunes.org> 19971205
+ *    separated swab functions from cpu_to_XX,
+ *    to clean up support for bizarre-endian architectures.
+ *
+ * See asm-i386/byteorder.h and suches for examples of how to provide
+ * architecture-dependent optimized versions
+ *
+ */
+
+#include <linux/compiler.h>
+
+/* casts are necessary for constants, because we never know how for sure
+ * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
+ */
+#define ___swab16(x) \
+({ \
+        __u16 __x = (x); \
+        ((__u16)( \
+                (((__u16)(__x) & (__u16)0x00ffU) << 8) | \
+                (((__u16)(__x) & (__u16)0xff00U) >> 8) )); \
+})
+
+#define ___swab32(x) \
+({ \
+        __u32 __x = (x); \
+        ((__u32)( \
+                (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | \
+                (((__u32)(__x) & (__u32)0x0000ff00UL) <<  8) | \
+                (((__u32)(__x) & (__u32)0x00ff0000UL) >>  8) | \
+                (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); \
+})
+
+#define ___swab64(x) \
+({ \
+        __u64 __x = (x); \
+        ((__u64)( \
+                (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | \
+                (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | \
+                (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | \
+                (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) <<  8) | \
+                (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >>  8) | \
+                (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | \
+                (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | \
+                (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); \
+})
+
+#define ___constant_swab16(x) \
+        ((__u16)( \
+                (((__u16)(x) & (__u16)0x00ffU) << 8) | \
+                (((__u16)(x) & (__u16)0xff00U) >> 8) ))
+#define ___constant_swab32(x) \
+        ((__u32)( \
+                (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
+                (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) | \
+                (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) | \
+                (((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
+#define ___constant_swab64(x) \
+        ((__u64)( \
+                (__u64)(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \
+                (__u64)(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \
+                (__u64)(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \
+                (__u64)(((__u64)(x) & (__u64)0x00000000ff000000ULL) <<  8) | \
+                (__u64)(((__u64)(x) & (__u64)0x000000ff00000000ULL) >>  8) | \
+                (__u64)(((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) | \
+                (__u64)(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \
+                (__u64)(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56) ))
+
+/*
+ * provide defaults when no architecture-specific optimization is detected
+ */
+#ifndef __arch__swab16
+#  define __arch__swab16(x) ({ __u16 __tmp = (x) ; ___swab16(__tmp); })
+#endif
+#ifndef __arch__swab32
+#  define __arch__swab32(x) ({ __u32 __tmp = (x) ; ___swab32(__tmp); })
+#endif
+#ifndef __arch__swab64
+#  define __arch__swab64(x) ({ __u64 __tmp = (x) ; ___swab64(__tmp); })
+#endif
+
+#ifndef __arch__swab16p
+#  define __arch__swab16p(x) __arch__swab16(*(x))
+#endif
+#ifndef __arch__swab32p
+#  define __arch__swab32p(x) __arch__swab32(*(x))
+#endif
+#ifndef __arch__swab64p
+#  define __arch__swab64p(x) __arch__swab64(*(x))
+#endif
+
+#ifndef __arch__swab16s
+#  define __arch__swab16s(x) do { *(x) = __arch__swab16p((x)); } while (0)
+#endif
+#ifndef __arch__swab32s
+#  define __arch__swab32s(x) do { *(x) = __arch__swab32p((x)); } while (0)
+#endif
+#ifndef __arch__swab64s
+#  define __arch__swab64s(x) do { *(x) = __arch__swab64p((x)); } while (0)
+#endif
+
+
+/*
+ * Allow constant folding
+ */
+#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+#  define __swab16(x) \
+(__builtin_constant_p((__u16)(x)) ? \
+ ___swab16((x)) : \
+ __fswab16((x)))
+#  define __swab32(x) \
+(__builtin_constant_p((__u32)(x)) ? \
+ ___swab32((x)) : \
+ __fswab32((x)))
+#  define __swab64(x) \
+(__builtin_constant_p((__u64)(x)) ? \
+ ___swab64((x)) : \
+ __fswab64((x)))
+#else
+#  define __swab16(x) __fswab16(x)
+#  define __swab32(x) __fswab32(x)
+#  define __swab64(x) __fswab64(x)
+#endif /* OPTIMIZE */
+
+
+static __inline__ __attribute_const__ __u16 __fswab16(__u16 x)
+{
+        return __arch__swab16(x);
+}
+static __inline__ __u16 __swab16p(const __u16 *x)
+{
+        return __arch__swab16p(x);
+}
+static __inline__ void __swab16s(__u16 *addr)
+{
+        __arch__swab16s(addr);
+}
+
+static __inline__ __attribute_const__ __u32 __fswab32(__u32 x)
+{
+        return __arch__swab32(x);
+}
+static __inline__ __u32 __swab32p(const __u32 *x)
+{
+        return __arch__swab32p(x);
+}
+static __inline__ void __swab32s(__u32 *addr)
+{
+        __arch__swab32s(addr);
+}
+
+#ifdef __BYTEORDER_HAS_U64__
+static __inline__ __attribute_const__ __u64 __fswab64(__u64 x)
+{
+#  ifdef __SWAB_64_THRU_32__
+        __u32 h = x >> 32;
+        __u32 l = x & ((1ULL<<32)-1);
+        return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
+#  else
+        return __arch__swab64(x);
+#  endif
+}
+static __inline__ __u64 __swab64p(const __u64 *x)
+{
+        return __arch__swab64p(x);
+}
+static __inline__ void __swab64s(__u64 *addr)
+{
+        __arch__swab64s(addr);
+}
+#endif /* __BYTEORDER_HAS_U64__ */
+
+#if defined(__KERNEL__)
+#define swab16 __swab16
+#define swab32 __swab32
+#define swab64 __swab64
+#define swab16p __swab16p
+#define swab32p __swab32p
+#define swab64p __swab64p
+#define swab16s __swab16s
+#define swab32s __swab32s
+#define swab64s __swab64s
+#endif
+
+#endif /* _LINUX_BYTEORDER_SWAB_H */
diff --git a/include/linux/byteorder/swabb.h b/include/linux/byteorder/swabb.h
new file mode 100644
index 000000000000..d28d9a804d3b
--- /dev/null
+++ b/include/linux/byteorder/swabb.h
@@ -0,0 +1,137 @@
+#ifndef _LINUX_BYTEORDER_SWABB_H
+#define _LINUX_BYTEORDER_SWABB_H
+
+/*
+ * linux/byteorder/swabb.h
+ * SWAp Bytes Bizarrely
+ *      swaHHXX[ps]?(foo)
+ *
+ * Support for obNUXIous pdp-endian and other bizarre architectures.
+ * Will Linux ever run on such ancient beasts? if not, this file
+ * will be but a programming pearl. Still, it's a reminder that we
+ * shouldn't be making too many assumptions when trying to be portable.
+ *
+ */
+
+/*
+ * Meaning of the names I chose (vaxlinux people feel free to correct them):
+ * swahw32      swap 16-bit half-words in a 32-bit word
+ * swahb32      swap 8-bit halves of each 16-bit half-word in a 32-bit word
+ *
+ * No 64-bit support yet. I don't know NUXI conventions for long longs.
+ * I guarantee it will be a mess when it's there, though :->
+ * It will be even worse if there are conflicting 64-bit conventions.
+ * Hopefully, no one ever used 64-bit objects on NUXI machines.
+ *
+ */
+
+#define ___swahw32(x) \
+({ \
+        __u32 __x = (x); \
+        ((__u32)( \
+                (((__u32)(__x) & (__u32)0x0000ffffUL) << 16) | \
+                (((__u32)(__x) & (__u32)0xffff0000UL) >> 16) )); \
+})
+#define ___swahb32(x) \
+({ \
+        __u32 __x = (x); \
+        ((__u32)( \
+                (((__u32)(__x) & (__u32)0x00ff00ffUL) << 8) | \
+                (((__u32)(__x) & (__u32)0xff00ff00UL) >> 8) )); \
+})
+
+#define ___constant_swahw32(x) \
+        ((__u32)( \
+                (((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \
+                (((__u32)(x) & (__u32)0xffff0000UL) >> 16) ))
+#define ___constant_swahb32(x) \
+        ((__u32)( \
+                (((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \
+                (((__u32)(x) & (__u32)0xff00ff00UL) >> 8) ))
+
+/*
+ * provide defaults when no architecture-specific optimization is detected
+ */
+#ifndef __arch__swahw32
+#  define __arch__swahw32(x) ___swahw32(x)
+#endif
+#ifndef __arch__swahb32
+#  define __arch__swahb32(x) ___swahb32(x)
+#endif
+
+#ifndef __arch__swahw32p
+#  define __arch__swahw32p(x) __swahw32(*(x))
+#endif
+#ifndef __arch__swahb32p
+#  define __arch__swahb32p(x) __swahb32(*(x))
+#endif
+
+#ifndef __arch__swahw32s
+#  define __arch__swahw32s(x) do { *(x) = __swahw32p((x)); } while (0)
+#endif
+#ifndef __arch__swahb32s
+#  define __arch__swahb32s(x) do { *(x) = __swahb32p((x)); } while (0)
+#endif
+
+
+/*
+ * Allow constant folding
+ */
+#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+#  define __swahw32(x) \
+(__builtin_constant_p((__u32)(x)) ? \
+ ___swahw32((x)) : \
+ __fswahw32((x)))
+#  define __swahb32(x) \
+(__builtin_constant_p((__u32)(x)) ? \
+ ___swahb32((x)) : \
+ __fswahb32((x)))
+#else
+#  define __swahw32(x) __fswahw32(x)
+#  define __swahb32(x) __fswahb32(x)
+#endif /* OPTIMIZE */
+
+
+static __inline__ __const__ __u32 __fswahw32(__u32 x)
+{
+        return __arch__swahw32(x);
+}
+static __inline__ __u32 __swahw32p(__u32 *x)
+{
+        return __arch__swahw32p(x);
+}
+static __inline__ void __swahw32s(__u32 *addr)
+{
+        __arch__swahw32s(addr);
+}
+
+
+static __inline__ __const__ __u32 __fswahb32(__u32 x)
+{
+        return __arch__swahb32(x);
+}
+static __inline__ __u32 __swahb32p(__u32 *x)
+{
+        return __arch__swahb32p(x);
+}
+static __inline__ void __swahb32s(__u32 *addr)
+{
+        __arch__swahb32s(addr);
+}
+
+#ifdef __BYTEORDER_HAS_U64__
+/*
+ * Not supported yet
+ */
+#endif /* __BYTEORDER_HAS_U64__ */
+
+#if defined(__KERNEL__)
+#define swahw32 __swahw32
+#define swahb32 __swahb32
+#define swahw32p __swahw32p
+#define swahb32p __swahb32p
+#define swahw32s __swahw32s
+#define swahb32s __swahb32s
+#endif
+
+#endif /* _LINUX_BYTEORDER_SWABB_H */
diff --git a/include/linux/cache.h b/include/linux/cache.h
new file mode 100644
index 000000000000..4d767b93738a
--- /dev/null
+++ b/include/linux/cache.h
@@ -0,0 +1,51 @@
+#ifndef __LINUX_CACHE_H
+#define __LINUX_CACHE_H
+
+#include <linux/kernel.h>
+#include <linux/config.h>
+#include <asm/cache.h>
+
+#ifndef L1_CACHE_ALIGN
+#define L1_CACHE_ALIGN(x) ALIGN(x, L1_CACHE_BYTES)
+#endif
+
+#ifndef SMP_CACHE_BYTES
+#define SMP_CACHE_BYTES L1_CACHE_BYTES
+#endif
+
+#ifndef ____cacheline_aligned
+#define ____cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES)))
+#endif
+
+#ifndef ____cacheline_aligned_in_smp
+#ifdef CONFIG_SMP
+#define ____cacheline_aligned_in_smp ____cacheline_aligned
+#else
+#define ____cacheline_aligned_in_smp
+#endif /* CONFIG_SMP */
+#endif
+
+#ifndef __cacheline_aligned
+#define __cacheline_aligned                                     \
+  __attribute__((__aligned__(SMP_CACHE_BYTES),                  \
+                 __section__(".data.cacheline_aligned")))
+#endif /* __cacheline_aligned */
+
+#ifndef __cacheline_aligned_in_smp
+#ifdef CONFIG_SMP
+#define __cacheline_aligned_in_smp __cacheline_aligned
+#else
+#define __cacheline_aligned_in_smp
+#endif /* CONFIG_SMP */
+#endif
+
+#if !defined(____cacheline_maxaligned_in_smp)
+#if defined(CONFIG_SMP)
+#define ____cacheline_maxaligned_in_smp \
+        __attribute__((__aligned__(1 << (L1_CACHE_SHIFT_MAX))))
+#else
+#define ____cacheline_maxaligned_in_smp
+#endif
+#endif
+
+#endif /* __LINUX_CACHE_H */
diff --git a/include/linux/capability.h b/include/linux/capability.h
new file mode 100644
index 000000000000..8d139f4acf23
--- /dev/null
+++ b/include/linux/capability.h
@@ -0,0 +1,360 @@
+/*
+ * This is <linux/capability.h>
+ *
+ * Andrew G. Morgan <morgan@transmeta.com>
+ * Alexander Kjeldaas <astor@guardian.no>
+ * with help from Aleph1, Roland Buresund and Andrew Main.
+ *
+ * See here for the libcap library ("POSIX draft" compliance):
+ *
+ * ftp://linux.kernel.org/pub/linux/libs/security/linux-privs/kernel-2.2/
+ */ 
+
+#ifndef _LINUX_CAPABILITY_H
+#define _LINUX_CAPABILITY_H
+
+#include <linux/types.h>
+#include <linux/compiler.h>
+
+/* User-level do most of the mapping between kernel and user
+   capabilities based on the version tag given by the kernel. The
+   kernel might be somewhat backwards compatible, but don't bet on
+   it. */
+
+/* XXX - Note, cap_t, is defined by POSIX to be an "opaque" pointer to
+   a set of three capability sets.  The transposition of 3*the
+   following structure to such a composite is better handled in a user
+   library since the draft standard requires the use of malloc/free
+   etc.. */
+ 
+#define _LINUX_CAPABILITY_VERSION  0x19980330
+
+typedef struct __user_cap_header_struct {
+        __u32 version;
+        int pid;
+} __user *cap_user_header_t;
+ 
+typedef struct __user_cap_data_struct {
+        __u32 effective;
+        __u32 permitted;
+        __u32 inheritable;
+} __user *cap_user_data_t;
+  
+#ifdef __KERNEL__
+
+#include <linux/spinlock.h>
+
+/* #define STRICT_CAP_T_TYPECHECKS */
+
+#ifdef STRICT_CAP_T_TYPECHECKS
+
+typedef struct kernel_cap_struct {
+        __u32 cap;
+} kernel_cap_t;
+
+#else
+
+typedef __u32 kernel_cap_t;
+
+#endif
+  
+#define _USER_CAP_HEADER_SIZE  (2*sizeof(__u32))
+#define _KERNEL_CAP_T_SIZE     (sizeof(kernel_cap_t))
+
+#endif
+
+
+/**
+ ** POSIX-draft defined capabilities. 
+ **/
+
+/* In a system with the [_POSIX_CHOWN_RESTRICTED] option defined, this
+   overrides the restriction of changing file ownership and group
+   ownership. */
+
+#define CAP_CHOWN            0
+
+/* Override all DAC access, including ACL execute access if
+   [_POSIX_ACL] is defined. Excluding DAC access covered by
+   CAP_LINUX_IMMUTABLE. */
+
+#define CAP_DAC_OVERRIDE     1
+
+/* Overrides all DAC restrictions regarding read and search on files
+   and directories, including ACL restrictions if [_POSIX_ACL] is
+   defined. Excluding DAC access covered by CAP_LINUX_IMMUTABLE. */
+
+#define CAP_DAC_READ_SEARCH  2
+    
+/* Overrides all restrictions about allowed operations on files, where
+   file owner ID must be equal to the user ID, except where CAP_FSETID
+   is applicable. It doesn't override MAC and DAC restrictions. */
+
+#define CAP_FOWNER           3
+
+/* Overrides the following restrictions that the effective user ID
+   shall match the file owner ID when setting the S_ISUID and S_ISGID
+   bits on that file; that the effective group ID (or one of the
+   supplementary group IDs) shall match the file owner ID when setting
+   the S_ISGID bit on that file; that the S_ISUID and S_ISGID bits are
+   cleared on successful return from chown(2) (not implemented). */
+
+#define CAP_FSETID           4
+
+/* Used to decide between falling back on the old suser() or fsuser(). */
+
+#define CAP_FS_MASK          0x1f
+
+/* Overrides the restriction that the real or effective user ID of a
+   process sending a signal must match the real or effective user ID
+   of the process receiving the signal. */
+
+#define CAP_KILL             5
+
+/* Allows setgid(2) manipulation */
+/* Allows setgroups(2) */
+/* Allows forged gids on socket credentials passing. */
+
+#define CAP_SETGID           6
+
+/* Allows set*uid(2) manipulation (including fsuid). */
+/* Allows forged pids on socket credentials passing. */
+
+#define CAP_SETUID           7
+
+
+/**
+ ** Linux-specific capabilities
+ **/
+
+/* Transfer any capability in your permitted set to any pid,
+   remove any capability in your permitted set from any pid */
+
+#define CAP_SETPCAP          8
+
+/* Allow modification of S_IMMUTABLE and S_APPEND file attributes */
+
+#define CAP_LINUX_IMMUTABLE  9
+
+/* Allows binding to TCP/UDP sockets below 1024 */
+/* Allows binding to ATM VCIs below 32 */
+
+#define CAP_NET_BIND_SERVICE 10
+
+/* Allow broadcasting, listen to multicast */
+
+#define CAP_NET_BROADCAST    11
+
+/* Allow interface configuration */
+/* Allow administration of IP firewall, masquerading and accounting */
+/* Allow setting debug option on sockets */
+/* Allow modification of routing tables */
+/* Allow setting arbitrary process / process group ownership on
+   sockets */
+/* Allow binding to any address for transparent proxying */
+/* Allow setting TOS (type of service) */
+/* Allow setting promiscuous mode */
+/* Allow clearing driver statistics */
+/* Allow multicasting */
+/* Allow read/write of device-specific registers */
+/* Allow activation of ATM control sockets */
+
+#define CAP_NET_ADMIN        12
+
+/* Allow use of RAW sockets */
+/* Allow use of PACKET sockets */
+
+#define CAP_NET_RAW          13
+
+/* Allow locking of shared memory segments */
+/* Allow mlock and mlockall (which doesn't really have anything to do
+   with IPC) */
+
+#define CAP_IPC_LOCK         14
+
+/* Override IPC ownership checks */
+
+#define CAP_IPC_OWNER        15
+
+/* Insert and remove kernel modules - modify kernel without limit */
+/* Modify cap_bset */
+#define CAP_SYS_MODULE       16
+
+/* Allow ioperm/iopl access */
+/* Allow sending USB messages to any device via /proc/bus/usb */
+
+#define CAP_SYS_RAWIO        17
+
+/* Allow use of chroot() */
+
+#define CAP_SYS_CHROOT       18
+
+/* Allow ptrace() of any process */
+
+#define CAP_SYS_PTRACE       19
+
+/* Allow configuration of process accounting */
+
+#define CAP_SYS_PACCT        20
+
+/* Allow configuration of the secure attention key */
+/* Allow administration of the random device */
+/* Allow examination and configuration of disk quotas */
+/* Allow configuring the kernel's syslog (printk behaviour) */
+/* Allow setting the domainname */
+/* Allow setting the hostname */
+/* Allow calling bdflush() */
+/* Allow mount() and umount(), setting up new smb connection */
+/* Allow some autofs root ioctls */
+/* Allow nfsservctl */
+/* Allow VM86_REQUEST_IRQ */
+/* Allow to read/write pci config on alpha */
+/* Allow irix_prctl on mips (setstacksize) */
+/* Allow flushing all cache on m68k (sys_cacheflush) */
+/* Allow removing semaphores */
+/* Used instead of CAP_CHOWN to "chown" IPC message queues, semaphores
+   and shared memory */
+/* Allow locking/unlocking of shared memory segment */
+/* Allow turning swap on/off */
+/* Allow forged pids on socket credentials passing */
+/* Allow setting readahead and flushing buffers on block devices */
+/* Allow setting geometry in floppy driver */
+/* Allow turning DMA on/off in xd driver */
+/* Allow administration of md devices (mostly the above, but some
+   extra ioctls) */
+/* Allow tuning the ide driver */
+/* Allow access to the nvram device */
+/* Allow administration of apm_bios, serial and bttv (TV) device */
+/* Allow manufacturer commands in isdn CAPI support driver */
+/* Allow reading non-standardized portions of pci configuration space */
+/* Allow DDI debug ioctl on sbpcd driver */
+/* Allow setting up serial ports */
+/* Allow sending raw qic-117 commands */
+/* Allow enabling/disabling tagged queuing on SCSI controllers and sending
+   arbitrary SCSI commands */
+/* Allow setting encryption key on loopback filesystem */
+
+#define CAP_SYS_ADMIN        21
+
+/* Allow use of reboot() */
+
+#define CAP_SYS_BOOT         22
+
+/* Allow raising priority and setting priority on other (different
+   UID) processes */
+/* Allow use of FIFO and round-robin (realtime) scheduling on own
+   processes and setting the scheduling algorithm used by another
+   process. */
+/* Allow setting cpu affinity on other processes */
+
+#define CAP_SYS_NICE         23
+
+/* Override resource limits. Set resource limits. */
+/* Override quota limits. */
+/* Override reserved space on ext2 filesystem */
+/* Modify data journaling mode on ext3 filesystem (uses journaling
+   resources) */
+/* NOTE: ext2 honors fsuid when checking for resource overrides, so 
+   you can override using fsuid too */
+/* Override size restrictions on IPC message queues */
+/* Allow more than 64hz interrupts from the real-time clock */
+/* Override max number of consoles on console allocation */
+/* Override max number of keymaps */
+
+#define CAP_SYS_RESOURCE     24
+
+/* Allow manipulation of system clock */
+/* Allow irix_stime on mips */
+/* Allow setting the real-time clock */
+
+#define CAP_SYS_TIME         25
+
+/* Allow configuration of tty devices */
+/* Allow vhangup() of tty */
+
+#define CAP_SYS_TTY_CONFIG   26
+
+/* Allow the privileged aspects of mknod() */
+
+#define CAP_MKNOD            27
+
+/* Allow taking of leases on files */
+
+#define CAP_LEASE            28
+
+#define CAP_AUDIT_WRITE      29
+
+#define CAP_AUDIT_CONTROL    30
+
+#ifdef __KERNEL__
+/* 
+ * Bounding set
+ */
+extern kernel_cap_t cap_bset;
+
+/*
+ * Internal kernel functions only
+ */
+ 
+#ifdef STRICT_CAP_T_TYPECHECKS
+
+#define to_cap_t(x) { x }
+#define cap_t(x) (x).cap
+
+#else
+
+#define to_cap_t(x) (x)
+#define cap_t(x) (x)
+
+#endif
+
+#define CAP_EMPTY_SET       to_cap_t(0)
+#define CAP_FULL_SET        to_cap_t(~0)
+#define CAP_INIT_EFF_SET    to_cap_t(~0 & ~CAP_TO_MASK(CAP_SETPCAP))
+#define CAP_INIT_INH_SET    to_cap_t(0)
+
+#define CAP_TO_MASK(x) (1 << (x))
+#define cap_raise(c, flag)   (cap_t(c) |=  CAP_TO_MASK(flag))
+#define cap_lower(c, flag)   (cap_t(c) &= ~CAP_TO_MASK(flag))
+#define cap_raised(c, flag)  (cap_t(c) & CAP_TO_MASK(flag))
+
+static inline kernel_cap_t cap_combine(kernel_cap_t a, kernel_cap_t b)
+{
+     kernel_cap_t dest;
+     cap_t(dest) = cap_t(a) | cap_t(b);
+     return dest;
+}
+
+static inline kernel_cap_t cap_intersect(kernel_cap_t a, kernel_cap_t b)
+{
+     kernel_cap_t dest;
+     cap_t(dest) = cap_t(a) & cap_t(b);
+     return dest;
+}
+
+static inline kernel_cap_t cap_drop(kernel_cap_t a, kernel_cap_t drop)
+{
+     kernel_cap_t dest;
+     cap_t(dest) = cap_t(a) & ~cap_t(drop);
+     return dest;
+}
+
+static inline kernel_cap_t cap_invert(kernel_cap_t c)
+{
+     kernel_cap_t dest;
+     cap_t(dest) = ~cap_t(c);
+     return dest;
+}
+
+#define cap_isclear(c)       (!cap_t(c))
+#define cap_issubset(a,set)  (!(cap_t(a) & ~cap_t(set)))
+
+#define cap_clear(c)         do { cap_t(c) =  0; } while(0)
+#define cap_set_full(c)      do { cap_t(c) = ~0; } while(0)
+#define cap_mask(c,mask)     do { cap_t(c) &= cap_t(mask); } while(0)
+
+#define cap_is_fs_cap(c)     (CAP_TO_MASK(c) & CAP_FS_MASK)
+
+#endif /* __KERNEL__ */
+
+#endif /* !_LINUX_CAPABILITY_H */
diff --git a/include/linux/capi.h b/include/linux/capi.h
new file mode 100644
index 000000000000..fdebaaa9f66e
--- /dev/null
+++ b/include/linux/capi.h
@@ -0,0 +1,133 @@
+/* $Id: capi.h,v 1.4.6.1 2001/09/23 22:25:05 kai Exp $
+ * 
+ * CAPI 2.0 Interface for Linux
+ * 
+ * Copyright 1997 by Carsten Paeth (calle@calle.in-berlin.de)
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __LINUX_CAPI_H__
+#define __LINUX_CAPI_H__
+
+#include <asm/types.h>
+#include <linux/ioctl.h>
+#ifndef __KERNEL__
+#include <linux/kernelcapi.h>
+#endif
+
+/*
+ * CAPI_REGISTER
+ */
+
+typedef struct capi_register_params {   /* CAPI_REGISTER */
+        __u32 level3cnt;        /* No. of simulatneous user data connections */
+        __u32 datablkcnt;       /* No. of buffered data messages */
+        __u32 datablklen;       /* Size of buffered data messages */
+} capi_register_params;
+
+#define CAPI_REGISTER   _IOW('C',0x01,struct capi_register_params)
+
+/*
+ * CAPI_GET_MANUFACTURER
+ */
+
+#define CAPI_MANUFACTURER_LEN           64
+
+#define CAPI_GET_MANUFACTURER   _IOWR('C',0x06,int)     /* broken: wanted size 64 (CAPI_MANUFACTURER_LEN) */
+
+/*
+ * CAPI_GET_VERSION
+ */
+
+typedef struct capi_version {
+        __u32 majorversion;
+        __u32 minorversion;
+        __u32 majormanuversion;
+        __u32 minormanuversion;
+} capi_version;
+
+#define CAPI_GET_VERSION        _IOWR('C',0x07,struct capi_version)
+
+/*
+ * CAPI_GET_SERIAL
+ */
+
+#define CAPI_SERIAL_LEN         8
+#define CAPI_GET_SERIAL         _IOWR('C',0x08,int)     /* broken: wanted size 8 (CAPI_SERIAL_LEN) */
+
+/*
+ * CAPI_GET_PROFILE
+ */
+
+typedef struct capi_profile {
+        __u16 ncontroller;      /* number of installed controller */
+        __u16 nbchannel;        /* number of B-Channels */
+        __u32 goptions;         /* global options */
+        __u32 support1;         /* B1 protocols support */
+        __u32 support2;         /* B2 protocols support */
+        __u32 support3;         /* B3 protocols support */
+        __u32 reserved[6];      /* reserved */
+        __u32 manu[5];          /* manufacturer specific information */
+} capi_profile;
+
+#define CAPI_GET_PROFILE        _IOWR('C',0x09,struct capi_profile)
+
+typedef struct capi_manufacturer_cmd {
+        unsigned long cmd;
+        void __user *data;
+} capi_manufacturer_cmd;
+
+/*
+ * CAPI_MANUFACTURER_CMD
+ */
+
+#define CAPI_MANUFACTURER_CMD   _IOWR('C',0x20, struct capi_manufacturer_cmd)
+
+/*
+ * CAPI_GET_ERRCODE
+ * capi errcode is set, * if read, write, or ioctl returns EIO,
+ * ioctl returns errcode directly, and in arg, if != 0
+ */
+
+#define CAPI_GET_ERRCODE        _IOR('C',0x21, __u16)
+
+/*
+ * CAPI_INSTALLED
+ */
+#define CAPI_INSTALLED          _IOR('C',0x22, __u16)
+
+
+/*
+ * member contr is input for
+ * CAPI_GET_MANUFACTURER, CAPI_VERSION, CAPI_GET_SERIAL
+ * and CAPI_GET_PROFILE
+ */
+typedef union capi_ioctl_struct {
+        __u32 contr;
+        capi_register_params rparams;
+        __u8 manufacturer[CAPI_MANUFACTURER_LEN];
+        capi_version version;
+        __u8 serial[CAPI_SERIAL_LEN];
+        capi_profile profile;
+        capi_manufacturer_cmd cmd;
+        __u16 errcode;
+} capi_ioctl_struct;
+
+/*
+ * Middleware extension
+ */
+
+#define CAPIFLAG_HIGHJACKING    0x0001
+
+#define CAPI_GET_FLAGS          _IOR('C',0x23, unsigned)
+#define CAPI_SET_FLAGS          _IOR('C',0x24, unsigned)
+#define CAPI_CLR_FLAGS          _IOR('C',0x25, unsigned)
+
+#define CAPI_NCCI_OPENCOUNT     _IOR('C',0x26, unsigned)
+
+#define CAPI_NCCI_GETUNIT       _IOR('C',0x27, unsigned)
+
+#endif                          /* __LINUX_CAPI_H__ */
diff --git a/include/linux/cciss_ioctl.h b/include/linux/cciss_ioctl.h
new file mode 100644
index 000000000000..ee0c6e8995da
--- /dev/null
+++ b/include/linux/cciss_ioctl.h
@@ -0,0 +1,240 @@
+#ifndef CCISS_IOCTLH
+#define CCISS_IOCTLH
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+#define CCISS_IOC_MAGIC 'B'
+
+
+typedef struct _cciss_pci_info_struct
+{
+        unsigned char   bus;
+        unsigned char   dev_fn;
+        __u32           board_id;
+} cciss_pci_info_struct; 
+
+typedef struct _cciss_coalint_struct
+{
+        __u32  delay;
+        __u32  count;
+} cciss_coalint_struct;
+
+typedef char NodeName_type[16];
+
+typedef __u32 Heartbeat_type;
+
+#define CISS_PARSCSIU2  0x0001
+#define CISS_PARCSCIU3  0x0002
+#define CISS_FIBRE1G    0x0100
+#define CISS_FIBRE2G    0x0200
+typedef __u32 BusTypes_type;
+
+typedef char FirmwareVer_type[4];
+typedef __u32 DriverVer_type;
+
+#define MAX_KMALLOC_SIZE 128000
+
+#ifndef CCISS_CMD_H
+// This defines are duplicated in cciss_cmd.h in the driver directory 
+
+//general boundary defintions
+#define SENSEINFOBYTES          32//note that this value may vary between host implementations
+
+//Command Status value
+#define CMD_SUCCESS             0x0000
+#define CMD_TARGET_STATUS       0x0001
+#define CMD_DATA_UNDERRUN       0x0002
+#define CMD_DATA_OVERRUN        0x0003
+#define CMD_INVALID             0x0004
+#define CMD_PROTOCOL_ERR        0x0005
+#define CMD_HARDWARE_ERR        0x0006
+#define CMD_CONNECTION_LOST     0x0007
+#define CMD_ABORTED             0x0008
+#define CMD_ABORT_FAILED        0x0009
+#define CMD_UNSOLICITED_ABORT   0x000A
+#define CMD_TIMEOUT             0x000B
+#define CMD_UNABORTABLE         0x000C
+
+//transfer direction
+#define XFER_NONE               0x00
+#define XFER_WRITE              0x01
+#define XFER_READ               0x02
+#define XFER_RSVD               0x03
+
+//task attribute
+#define ATTR_UNTAGGED           0x00
+#define ATTR_SIMPLE             0x04
+#define ATTR_HEADOFQUEUE        0x05
+#define ATTR_ORDERED            0x06
+#define ATTR_ACA                0x07
+
+//cdb type
+#define TYPE_CMD                                0x00
+#define TYPE_MSG                                0x01
+
+// Type defs used in the following structs
+#define BYTE __u8
+#define WORD __u16
+#define HWORD __u16
+#define DWORD __u32
+
+#define CISS_MAX_LUN    16      
+
+#define LEVEL2LUN   1   // index into Target(x) structure, due to byte swapping
+#define LEVEL3LUN   0
+
+#pragma pack(1)
+
+//Command List Structure
+typedef union _SCSI3Addr_struct {
+   struct {
+    BYTE Dev;
+    BYTE Bus:6;
+    BYTE Mode:2;        // b00
+  } PeripDev;
+   struct {
+    BYTE DevLSB;
+    BYTE DevMSB:6;
+    BYTE Mode:2;        // b01
+  } LogDev;
+   struct {
+    BYTE Dev:5;
+    BYTE Bus:3;
+    BYTE Targ:6;
+    BYTE Mode:2;        // b10
+  } LogUnit;
+} SCSI3Addr_struct;
+
+typedef struct _PhysDevAddr_struct {
+  DWORD             TargetId:24;
+  DWORD             Bus:6;
+  DWORD             Mode:2;
+  SCSI3Addr_struct  Target[2]; //2 level target device addr
+} PhysDevAddr_struct;
+  
+typedef struct _LogDevAddr_struct {
+  DWORD            VolId:30;
+  DWORD            Mode:2;
+  BYTE             reserved[4];
+} LogDevAddr_struct;
+
+typedef union _LUNAddr_struct {
+  BYTE               LunAddrBytes[8];
+  SCSI3Addr_struct   SCSI3Lun[4];
+  PhysDevAddr_struct PhysDev;
+  LogDevAddr_struct  LogDev;
+} LUNAddr_struct;
+
+typedef struct _RequestBlock_struct {
+  BYTE   CDBLen;
+  struct {
+    BYTE Type:3;
+    BYTE Attribute:3;
+    BYTE Direction:2;
+  } Type;
+  HWORD  Timeout;
+  BYTE   CDB[16];
+} RequestBlock_struct;
+
+typedef union _MoreErrInfo_struct{
+  struct {
+    BYTE  Reserved[3];
+    BYTE  Type;
+    DWORD ErrorInfo;
+  }Common_Info;
+  struct{
+    BYTE  Reserved[2];
+    BYTE  offense_size;//size of offending entry
+    BYTE  offense_num; //byte # of offense 0-base
+    DWORD offense_value;
+  }Invalid_Cmd;
+}MoreErrInfo_struct;
+typedef struct _ErrorInfo_struct {
+  BYTE               ScsiStatus;
+  BYTE               SenseLen;
+  HWORD              CommandStatus;
+  DWORD              ResidualCnt;
+  MoreErrInfo_struct MoreErrInfo;
+  BYTE               SenseInfo[SENSEINFOBYTES];
+} ErrorInfo_struct;
+
+#pragma pack()
+#endif /* CCISS_CMD_H */ 
+
+typedef struct _IOCTL_Command_struct {
+  LUNAddr_struct           LUN_info;
+  RequestBlock_struct      Request;
+  ErrorInfo_struct         error_info; 
+  WORD                     buf_size;  /* size in bytes of the buf */
+  BYTE                     __user *buf;
+} IOCTL_Command_struct;
+
+typedef struct _BIG_IOCTL_Command_struct {
+  LUNAddr_struct           LUN_info;
+  RequestBlock_struct      Request;
+  ErrorInfo_struct         error_info;
+  DWORD                    malloc_size; /* < MAX_KMALLOC_SIZE in cciss.c */
+  DWORD                    buf_size;    /* size in bytes of the buf */
+                                        /* < malloc_size * MAXSGENTRIES */
+  BYTE                     __user *buf;
+} BIG_IOCTL_Command_struct;
+
+typedef struct _LogvolInfo_struct{
+        __u32   LunID;
+        int     num_opens;  /* number of opens on the logical volume */
+        int     num_parts;  /* number of partitions configured on logvol */
+} LogvolInfo_struct;
+
+#define CCISS_GETPCIINFO _IOR(CCISS_IOC_MAGIC, 1, cciss_pci_info_struct)
+
+#define CCISS_GETINTINFO _IOR(CCISS_IOC_MAGIC, 2, cciss_coalint_struct)
+#define CCISS_SETINTINFO _IOW(CCISS_IOC_MAGIC, 3, cciss_coalint_struct)
+
+#define CCISS_GETNODENAME _IOR(CCISS_IOC_MAGIC, 4, NodeName_type)
+#define CCISS_SETNODENAME _IOW(CCISS_IOC_MAGIC, 5, NodeName_type)
+
+#define CCISS_GETHEARTBEAT _IOR(CCISS_IOC_MAGIC, 6, Heartbeat_type)
+#define CCISS_GETBUSTYPES  _IOR(CCISS_IOC_MAGIC, 7, BusTypes_type)
+#define CCISS_GETFIRMVER   _IOR(CCISS_IOC_MAGIC, 8, FirmwareVer_type)
+#define CCISS_GETDRIVVER   _IOR(CCISS_IOC_MAGIC, 9, DriverVer_type)
+#define CCISS_REVALIDVOLS  _IO(CCISS_IOC_MAGIC, 10)
+#define CCISS_PASSTHRU     _IOWR(CCISS_IOC_MAGIC, 11, IOCTL_Command_struct)
+#define CCISS_DEREGDISK    _IO(CCISS_IOC_MAGIC, 12)
+
+/* no longer used... use REGNEWD instead */ 
+#define CCISS_REGNEWDISK  _IOW(CCISS_IOC_MAGIC, 13, int)
+
+#define CCISS_REGNEWD      _IO(CCISS_IOC_MAGIC, 14)
+#define CCISS_RESCANDISK   _IO(CCISS_IOC_MAGIC, 16)
+#define CCISS_GETLUNINFO   _IOR(CCISS_IOC_MAGIC, 17, LogvolInfo_struct)
+#define CCISS_BIG_PASSTHRU _IOWR(CCISS_IOC_MAGIC, 18, BIG_IOCTL_Command_struct)
+
+#ifdef __KERNEL__
+#ifdef CONFIG_COMPAT
+
+/* 32 bit compatible ioctl structs */
+typedef struct _IOCTL32_Command_struct {
+  LUNAddr_struct           LUN_info;
+  RequestBlock_struct      Request;
+  ErrorInfo_struct         error_info;
+  WORD                     buf_size;  /* size in bytes of the buf */
+  __u32                    buf; /* 32 bit pointer to data buffer */
+} IOCTL32_Command_struct;
+
+typedef struct _BIG_IOCTL32_Command_struct {
+  LUNAddr_struct           LUN_info;
+  RequestBlock_struct      Request;
+  ErrorInfo_struct         error_info;
+  DWORD                    malloc_size; /* < MAX_KMALLOC_SIZE in cciss.c */
+  DWORD                    buf_size;    /* size in bytes of the buf */
+                                        /* < malloc_size * MAXSGENTRIES */
+  __u32                 buf;    /* 32 bit pointer to data buffer */
+} BIG_IOCTL32_Command_struct;
+
+#define CCISS_PASSTHRU32   _IOWR(CCISS_IOC_MAGIC, 11, IOCTL32_Command_struct)
+#define CCISS_BIG_PASSTHRU32 _IOWR(CCISS_IOC_MAGIC, 18, BIG_IOCTL32_Command_struct)
+
+#endif /* CONFIG_COMPAT */
+#endif /* __KERNEL__ */
+#endif  
diff --git a/include/linux/cd1400.h b/include/linux/cd1400.h
new file mode 100644
index 000000000000..1dc3ab0523fd
--- /dev/null
+++ b/include/linux/cd1400.h
@@ -0,0 +1,292 @@
+/*****************************************************************************/
+
+/*
+ *      cd1400.h  -- cd1400 UART hardware info.
+ *
+ *      Copyright (C) 1996-1998  Stallion Technologies
+ *      Copyright (C) 1994-1996  Greg Ungerer.
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*****************************************************************************/
+#ifndef _CD1400_H
+#define _CD1400_H
+/*****************************************************************************/
+
+/*
+ *      Define the number of async ports per cd1400 uart chip.
+ */
+#define CD1400_PORTS            4
+
+/*
+ *      Define the cd1400 uarts internal FIFO sizes.
+ */
+#define CD1400_TXFIFOSIZE       12
+#define CD1400_RXFIFOSIZE       12
+
+/*
+ *      Local RX FIFO thresh hold level. Also define the RTS thresh hold
+ *      based on the RX thresh hold.
+ */
+#define FIFO_RXTHRESHOLD        6
+#define FIFO_RTSTHRESHOLD       7
+
+/*****************************************************************************/
+
+/*
+ *      Define the cd1400 register addresses. These are all the valid
+ *      registers with the cd1400. Some are global, some virtual, some
+ *      per port.
+ */
+#define GFRCR           0x40
+#define CAR             0x68
+#define GCR             0x4b
+#define SVRR            0x67
+#define RICR            0x44
+#define TICR            0x45
+#define MICR            0x46
+#define RIR             0x6b
+#define TIR             0x6a
+#define MIR             0x69
+#define PPR             0x7e
+
+#define RIVR            0x43
+#define TIVR            0x42
+#define MIVR            0x41
+#define TDR             0x63
+#define RDSR            0x62
+#define MISR            0x4c
+#define EOSRR           0x60
+
+#define LIVR            0x18
+#define CCR             0x05
+#define SRER            0x06
+#define COR1            0x08
+#define COR2            0x09
+#define COR3            0x0a
+#define COR4            0x1e
+#define COR5            0x1f
+#define CCSR            0x0b
+#define RDCR            0x0e
+#define SCHR1           0x1a
+#define SCHR2           0x1b
+#define SCHR3           0x1c
+#define SCHR4           0x1d
+#define SCRL            0x22
+#define SCRH            0x23
+#define LNC             0x24
+#define MCOR1           0x15
+#define MCOR2           0x16
+#define RTPR            0x21
+#define MSVR1           0x6c
+#define MSVR2           0x6d
+#define PSVR            0x6f
+#define RBPR            0x78
+#define RCOR            0x7c
+#define TBPR            0x72
+#define TCOR            0x76
+
+/*****************************************************************************/
+
+/*
+ *      Define the set of baud rate clock divisors.
+ */
+#define CD1400_CLK0     8
+#define CD1400_CLK1     32
+#define CD1400_CLK2     128
+#define CD1400_CLK3     512
+#define CD1400_CLK4     2048
+
+#define CD1400_NUMCLKS  5
+
+/*****************************************************************************/
+
+/*
+ *      Define the clock pre-scalar value to be a 5 ms clock. This should be
+ *      OK for now. It would probably be better to make it 10 ms, but we
+ *      can't fit that divisor into 8 bits!
+ */
+#define PPR_SCALAR      244
+
+/*****************************************************************************/
+
+/*
+ *      Define values used to set character size options.
+ */
+#define COR1_CHL5       0x00
+#define COR1_CHL6       0x01
+#define COR1_CHL7       0x02
+#define COR1_CHL8       0x03
+
+/*
+ *      Define values used to set the number of stop bits.
+ */
+#define COR1_STOP1      0x00
+#define COR1_STOP15     0x04
+#define COR1_STOP2      0x08
+
+/*
+ *      Define values used to set the parity scheme in use.
+ */
+#define COR1_PARNONE    0x00
+#define COR1_PARFORCE   0x20
+#define COR1_PARENB     0x40
+#define COR1_PARIGNORE  0x10
+
+#define COR1_PARODD     0x80
+#define COR1_PAREVEN    0x00
+
+#define COR2_IXM        0x80
+#define COR2_TXIBE      0x40
+#define COR2_ETC        0x20
+#define COR2_LLM        0x10
+#define COR2_RLM        0x08
+#define COR2_RTSAO      0x04
+#define COR2_CTSAE      0x02
+
+#define COR3_SCDRNG     0x80
+#define COR3_SCD34      0x40
+#define COR3_FCT        0x20
+#define COR3_SCD12      0x10
+
+/*
+ *      Define values used by COR4.
+ */
+#define COR4_BRKINT     0x08
+#define COR4_IGNBRK     0x18
+
+/*****************************************************************************/
+
+/*
+ *      Define the modem control register values.
+ *      Note that the actual hardware is a little different to the conventional
+ *      pin names on the cd1400.
+ */
+#define MSVR1_DTR       0x01
+#define MSVR1_DSR       0x10
+#define MSVR1_RI        0x20
+#define MSVR1_CTS       0x40
+#define MSVR1_DCD       0x80
+
+#define MSVR2_RTS       0x02
+#define MSVR2_DSR       0x10
+#define MSVR2_RI        0x20
+#define MSVR2_CTS       0x40
+#define MSVR2_DCD       0x80
+
+#define MCOR1_DCD       0x80
+#define MCOR1_CTS       0x40
+#define MCOR1_RI        0x20
+#define MCOR1_DSR       0x10
+
+#define MCOR2_DCD       0x80
+#define MCOR2_CTS       0x40
+#define MCOR2_RI        0x20
+#define MCOR2_DSR       0x10
+
+/*****************************************************************************/
+
+/*
+ *      Define the bits used with the service (interrupt) enable register.
+ */
+#define SRER_NNDT       0x01
+#define SRER_TXEMPTY    0x02
+#define SRER_TXDATA     0x04
+#define SRER_RXDATA     0x10
+#define SRER_MODEM      0x80
+
+/*****************************************************************************/
+
+/*
+ *      Define operational commands for the command register.
+ */
+#define CCR_RESET       0x80
+#define CCR_CORCHANGE   0x4e
+#define CCR_SENDCH      0x20
+#define CCR_CHANCTRL    0x10
+
+#define CCR_TXENABLE    (CCR_CHANCTRL | 0x08)
+#define CCR_TXDISABLE   (CCR_CHANCTRL | 0x04)
+#define CCR_RXENABLE    (CCR_CHANCTRL | 0x02)
+#define CCR_RXDISABLE   (CCR_CHANCTRL | 0x01)
+
+#define CCR_SENDSCHR1   (CCR_SENDCH | 0x01)
+#define CCR_SENDSCHR2   (CCR_SENDCH | 0x02)
+#define CCR_SENDSCHR3   (CCR_SENDCH | 0x03)
+#define CCR_SENDSCHR4   (CCR_SENDCH | 0x04)
+
+#define CCR_RESETCHAN   (CCR_RESET | 0x00)
+#define CCR_RESETFULL   (CCR_RESET | 0x01)
+#define CCR_TXFLUSHFIFO (CCR_RESET | 0x02)
+
+#define CCR_MAXWAIT     10000
+
+/*****************************************************************************/
+
+/*
+ *      Define the valid acknowledgement types (for hw ack cycle).
+ */
+#define ACK_TYPMASK     0x07
+#define ACK_TYPTX       0x02
+#define ACK_TYPMDM      0x01
+#define ACK_TYPRXGOOD   0x03
+#define ACK_TYPRXBAD    0x07
+
+#define SVRR_RX         0x01
+#define SVRR_TX         0x02
+#define SVRR_MDM        0x04
+
+#define ST_OVERRUN      0x01
+#define ST_FRAMING      0x02
+#define ST_PARITY       0x04
+#define ST_BREAK        0x08
+#define ST_SCHAR1       0x10
+#define ST_SCHAR2       0x20
+#define ST_SCHAR3       0x30
+#define ST_SCHAR4       0x40
+#define ST_RANGE        0x70
+#define ST_SCHARMASK    0x70
+#define ST_TIMEOUT      0x80
+
+#define MISR_DCD        0x80
+#define MISR_CTS        0x40
+#define MISR_RI         0x20
+#define MISR_DSR        0x10
+
+/*****************************************************************************/
+
+/*
+ *      Defines for the CCSR status register.
+ */
+#define CCSR_RXENABLED  0x80
+#define CCSR_RXFLOWON   0x40
+#define CCSR_RXFLOWOFF  0x20
+#define CCSR_TXENABLED  0x08
+#define CCSR_TXFLOWON   0x04
+#define CCSR_TXFLOWOFF  0x02
+
+/*****************************************************************************/
+
+/*
+ *      Define the embedded commands.
+ */
+#define ETC_CMD         0x00
+#define ETC_STARTBREAK  0x81
+#define ETC_DELAY       0x82
+#define ETC_STOPBREAK   0x83
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/cdev.h b/include/linux/cdev.h
new file mode 100644
index 000000000000..8da37e29cb87
--- /dev/null
+++ b/include/linux/cdev.h
@@ -0,0 +1,27 @@
+#ifndef _LINUX_CDEV_H
+#define _LINUX_CDEV_H
+#ifdef __KERNEL__
+
+struct cdev {
+        struct kobject kobj;
+        struct module *owner;
+        struct file_operations *ops;
+        struct list_head list;
+        dev_t dev;
+        unsigned int count;
+};
+
+void cdev_init(struct cdev *, struct file_operations *);
+
+struct cdev *cdev_alloc(void);
+
+void cdev_put(struct cdev *p);
+
+int cdev_add(struct cdev *, dev_t, unsigned);
+
+void cdev_del(struct cdev *);
+
+void cd_forget(struct inode *);
+
+#endif
+#endif
diff --git a/include/linux/cdk.h b/include/linux/cdk.h
new file mode 100644
index 000000000000..0908daf7bf56
--- /dev/null
+++ b/include/linux/cdk.h
@@ -0,0 +1,486 @@
+/*****************************************************************************/
+
+/*
+ *      cdk.h  -- CDK interface definitions.
+ *
+ *      Copyright (C) 1996-1998  Stallion Technologies
+ *      Copyright (C) 1994-1996  Greg Ungerer.
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*****************************************************************************/
+#ifndef _CDK_H
+#define _CDK_H
+/*****************************************************************************/
+
+#pragma pack(2)
+
+/*
+ *      The following set of definitions is used to communicate with the
+ *      shared memory interface of the Stallion intelligent multiport serial
+ *      boards. The definitions in this file are taken directly from the
+ *      document titled "Generic Stackable Interface, Downloader and
+ *      Communications Development Kit".
+ */
+
+/*
+ *      Define the set of important shared memory addresses. These are
+ *      required to initialize the board and get things started. All of these
+ *      addresses are relative to the start of the shared memory.
+ */
+#define CDK_SIGADDR     0x200
+#define CDK_FEATADDR    0x280
+#define CDK_CDKADDR     0x300
+#define CDK_RDYADDR     0x262
+
+#define CDK_ALIVEMARKER 13
+
+/*
+ *      On hardware power up the ROMs located on the EasyConnection 8/64 will
+ *      fill out the following signature information into shared memory. This
+ *      way the host system can quickly determine that the board is present
+ *      and is operational.
+ */
+typedef struct cdkecpsig {
+        unsigned long   magic;
+        unsigned short  romver;
+        unsigned short  cputype;
+        unsigned char   panelid[8];
+} cdkecpsig_t;
+
+#define ECP_MAGIC       0x21504345
+
+/*
+ *      On hardware power up the ROMs located on the ONboard, Stallion and
+ *      Brumbys will fill out the following signature information into shared
+ *      memory. This way the host system can quickly determine that the board
+ *      is present and is operational.
+ */
+typedef struct cdkonbsig {
+        unsigned short  magic0;
+        unsigned short  magic1;
+        unsigned short  magic2;
+        unsigned short  magic3;
+        unsigned short  romver;
+        unsigned short  memoff;
+        unsigned short  memseg;
+        unsigned short  amask0;
+        unsigned short  pic;
+        unsigned short  status;
+        unsigned short  btype;
+        unsigned short  clkticks;
+        unsigned short  clkspeed;
+        unsigned short  amask1;
+        unsigned short  amask2;
+} cdkonbsig_t;
+
+#define ONB_MAGIC0      0xf2a7
+#define ONB_MAGIC1      0xa149
+#define ONB_MAGIC2      0x6352
+#define ONB_MAGIC3      0xf121
+
+/*
+ *      Define the feature area structure. The feature area is the set of
+ *      startup parameters used by the slave image when it starts executing.
+ *      They allow for the specification of buffer sizes, debug trace, etc.
+ */
+typedef struct cdkfeature {
+        unsigned long   debug;
+        unsigned long   banner;
+        unsigned long   etype;
+        unsigned long   nrdevs;
+        unsigned long   brdspec;
+        unsigned long   txrqsize;
+        unsigned long   rxrqsize;
+        unsigned long   flags;
+} cdkfeature_t;
+
+#define ETYP_DDK        0
+#define ETYP_CDK        1
+
+/*
+ *      Define the CDK header structure. This is the info that the slave
+ *      environment sets up after it has been downloaded and started. It
+ *      essentially provides a memory map for the shared memory interface.
+ */
+typedef struct cdkhdr {
+        unsigned short  command;
+        unsigned short  status;
+        unsigned short  port;
+        unsigned short  mode;
+        unsigned long   cmd_buf[14];
+        unsigned short  alive_cnt;
+        unsigned short  intrpt_mode;
+        unsigned char   intrpt_id[8];
+        unsigned char   ver_release;
+        unsigned char   ver_modification;
+        unsigned char   ver_fix;
+        unsigned char   deadman_restart;
+        unsigned short  deadman;
+        unsigned short  nrdevs;
+        unsigned long   memp;
+        unsigned long   hostp;
+        unsigned long   slavep;
+        unsigned char   hostreq;
+        unsigned char   slavereq;
+        unsigned char   cmd_reserved[30];
+} cdkhdr_t;
+
+#define MODE_DDK        0
+#define MODE_CDK        1
+
+#define IMD_INTR        0x0
+#define IMD_PPINTR      0x1
+#define IMD_POLL        0xff
+
+/*
+ *      Define the memory mapping structure. This structure is pointed to by
+ *      the memp field in the stlcdkhdr struct. As many as these structures
+ *      as required are layed out in shared memory to define how the rest of
+ *      shared memory is divided up. There will be one for each port.
+ */
+typedef struct cdkmem {
+        unsigned short  dtype;
+        unsigned long   offset;
+} cdkmem_t;
+
+#define TYP_UNDEFINED   0x0
+#define TYP_ASYNCTRL    0x1
+#define TYP_ASYNC       0x20
+#define TYP_PARALLEL    0x40
+#define TYP_SYNCX21     0x60
+
+/*****************************************************************************/
+
+/*
+ *      Following is a set of defines and structures used to actually deal
+ *      with the serial ports on the board. Firstly is the set of commands
+ *      that can be applied to ports.
+ */
+#define ASYCMD          (((unsigned long) 'a') << 8)
+
+#define A_NULL          (ASYCMD | 0)
+#define A_FLUSH         (ASYCMD | 1)
+#define A_BREAK         (ASYCMD | 2)
+#define A_GETPORT       (ASYCMD | 3)
+#define A_SETPORT       (ASYCMD | 4)
+#define A_SETPORTF      (ASYCMD | 5)
+#define A_SETPORTFTX    (ASYCMD | 6)
+#define A_SETPORTFRX    (ASYCMD | 7)
+#define A_GETSIGNALS    (ASYCMD | 8)
+#define A_SETSIGNALS    (ASYCMD | 9)
+#define A_SETSIGNALSF   (ASYCMD | 10)
+#define A_SETSIGNALSFTX (ASYCMD | 11)
+#define A_SETSIGNALSFRX (ASYCMD | 12)
+#define A_GETNOTIFY     (ASYCMD | 13)
+#define A_SETNOTIFY     (ASYCMD | 14)
+#define A_NOTIFY        (ASYCMD | 15)
+#define A_PORTCTRL      (ASYCMD | 16)
+#define A_GETSTATS      (ASYCMD | 17)
+#define A_RQSTATE       (ASYCMD | 18)
+#define A_FLOWSTATE     (ASYCMD | 19)
+#define A_CLEARSTATS    (ASYCMD | 20)
+
+/*
+ *      Define those arguments used for simple commands.
+ */
+#define FLUSHRX         0x1
+#define FLUSHTX         0x2
+
+#define BREAKON         -1
+#define BREAKOFF        -2
+
+/*
+ *      Define the port setting structure, and all those defines that go along
+ *      with it. Basically this structure defines the characteristics of this
+ *      port: baud rate, chars, parity, input/output char cooking etc.
+ */
+typedef struct asyport {
+        unsigned long   baudout;
+        unsigned long   baudin;
+        unsigned long   iflag;
+        unsigned long   oflag;
+        unsigned long   lflag;
+        unsigned long   pflag;
+        unsigned long   flow;
+        unsigned long   spare1;
+        unsigned short  vtime;
+        unsigned short  vmin;
+        unsigned short  txlo;
+        unsigned short  txhi;
+        unsigned short  rxlo;
+        unsigned short  rxhi;
+        unsigned short  rxhog;
+        unsigned short  spare2;
+        unsigned char   csize;
+        unsigned char   stopbs;
+        unsigned char   parity;
+        unsigned char   stopin;
+        unsigned char   startin;
+        unsigned char   stopout;
+        unsigned char   startout;
+        unsigned char   parmark;
+        unsigned char   brkmark;
+        unsigned char   cc[11];
+} asyport_t;
+
+#define PT_STOP1        0x0
+#define PT_STOP15       0x1
+#define PT_STOP2        0x2
+
+#define PT_NOPARITY     0x0
+#define PT_ODDPARITY    0x1
+#define PT_EVENPARITY   0x2
+#define PT_MARKPARITY   0x3
+#define PT_SPACEPARITY  0x4
+
+#define F_NONE          0x0
+#define F_IXON          0x1
+#define F_IXOFF         0x2
+#define F_IXANY         0x4
+#define F_IOXANY        0x8
+#define F_RTSFLOW       0x10
+#define F_CTSFLOW       0x20
+#define F_DTRFLOW       0x40
+#define F_DCDFLOW       0x80
+#define F_DSROFLOW      0x100
+#define F_DSRIFLOW      0x200
+
+#define FI_NORX         0x1
+#define FI_RAW          0x2
+#define FI_ISTRIP       0x4
+#define FI_UCLC         0x8
+#define FI_INLCR        0x10
+#define FI_ICRNL        0x20
+#define FI_IGNCR        0x40
+#define FI_IGNBREAK     0x80
+#define FI_DSCRDBREAK   0x100
+#define FI_1MARKBREAK   0x200
+#define FI_2MARKBREAK   0x400
+#define FI_XCHNGBREAK   0x800
+#define FI_IGNRXERRS    0x1000
+#define FI_DSCDRXERRS   0x2000
+#define FI_1MARKRXERRS  0x4000
+#define FI_2MARKRXERRS  0x8000
+#define FI_XCHNGRXERRS  0x10000
+#define FI_DSCRDNULL    0x20000
+
+#define FO_OLCUC        0x1
+#define FO_ONLCR        0x2
+#define FO_OOCRNL       0x4
+#define FO_ONOCR        0x8
+#define FO_ONLRET       0x10
+#define FO_ONL          0x20
+#define FO_OBS          0x40
+#define FO_OVT          0x80
+#define FO_OFF          0x100
+#define FO_OTAB1        0x200
+#define FO_OTAB2        0x400
+#define FO_OTAB3        0x800
+#define FO_OCR1         0x1000
+#define FO_OCR2         0x2000
+#define FO_OCR3         0x4000
+#define FO_OFILL        0x8000
+#define FO_ODELL        0x10000
+
+#define P_RTSLOCK       0x1
+#define P_CTSLOCK       0x2
+#define P_MAPRTS        0x4
+#define P_MAPCTS        0x8
+#define P_LOOPBACK      0x10
+#define P_DTRFOLLOW     0x20
+#define P_FAKEDCD       0x40
+
+#define P_RXIMIN        0x10000
+#define P_RXITIME       0x20000
+#define P_RXTHOLD       0x40000
+
+/*
+ *      Define a structure to communicate serial port signal and data state
+ *      information.
+ */
+typedef struct asysigs {
+        unsigned long   data;
+        unsigned long   signal;
+        unsigned long   sigvalue;
+} asysigs_t;
+
+#define DT_TXBUSY       0x1
+#define DT_TXEMPTY      0x2
+#define DT_TXLOW        0x4
+#define DT_TXHIGH       0x8
+#define DT_TXFULL       0x10
+#define DT_TXHOG        0x20
+#define DT_TXFLOWED     0x40
+#define DT_TXBREAK      0x80
+
+#define DT_RXBUSY       0x100
+#define DT_RXEMPTY      0x200
+#define DT_RXLOW        0x400
+#define DT_RXHIGH       0x800
+#define DT_RXFULL       0x1000
+#define DT_RXHOG        0x2000
+#define DT_RXFLOWED     0x4000
+#define DT_RXBREAK      0x8000
+
+#define SG_DTR          0x1
+#define SG_DCD          0x2
+#define SG_RTS          0x4
+#define SG_CTS          0x8
+#define SG_DSR          0x10
+#define SG_RI           0x20
+
+/*
+ *      Define the notification setting structure. This is used to tell the
+ *      port what events we want to be informed about. Fields here use the
+ *      same defines as for the asysigs structure above.
+ */
+typedef struct asynotify {
+        unsigned long   ctrl;
+        unsigned long   data;
+        unsigned long   signal;
+        unsigned long   sigvalue;
+} asynotify_t;
+
+/*
+ *      Define the port control structure. It is used to do fine grain
+ *      control operations on the port.
+ */
+typedef struct {
+        unsigned long   rxctrl;
+        unsigned long   txctrl;
+        char            rximdch;
+        char            tximdch;
+        char            spare1;
+        char            spare2;
+} asyctrl_t;
+
+#define CT_ENABLE       0x1
+#define CT_DISABLE      0x2
+#define CT_STOP         0x4
+#define CT_START        0x8
+#define CT_STARTFLOW    0x10
+#define CT_STOPFLOW     0x20
+#define CT_SENDCHR      0x40
+
+/*
+ *      Define the stats structure kept for each port. This is a useful set
+ *      of data collected for each port on the slave. The A_GETSTATS command
+ *      is used to retrieve this data from the slave.
+ */
+typedef struct asystats {
+        unsigned long   opens;
+        unsigned long   txchars;
+        unsigned long   rxchars;
+        unsigned long   txringq;
+        unsigned long   rxringq;
+        unsigned long   txmsgs;
+        unsigned long   rxmsgs;
+        unsigned long   txflushes;
+        unsigned long   rxflushes;
+        unsigned long   overruns;
+        unsigned long   framing;
+        unsigned long   parity;
+        unsigned long   ringover;
+        unsigned long   lost;
+        unsigned long   rxstart;
+        unsigned long   rxstop;
+        unsigned long   txstart;
+        unsigned long   txstop;
+        unsigned long   dcdcnt;
+        unsigned long   dtrcnt;
+        unsigned long   ctscnt;
+        unsigned long   rtscnt;
+        unsigned long   dsrcnt;
+        unsigned long   ricnt;
+        unsigned long   txbreaks;
+        unsigned long   rxbreaks;
+        unsigned long   signals;
+        unsigned long   state;
+        unsigned long   hwid;
+} asystats_t;
+
+/*****************************************************************************/
+
+/*
+ *      All command and control communication with a device on the slave is
+ *      via a control block in shared memory. Each device has its own control
+ *      block, defined by the following structure. The control block allows
+ *      the host to open, close and control the device on the slave.
+ */
+typedef struct cdkctrl {
+        unsigned char   open;
+        unsigned char   close;
+        unsigned long   openarg;
+        unsigned long   closearg;
+        unsigned long   cmd;
+        unsigned long   status;
+        unsigned long   args[32];
+} cdkctrl_t;
+
+/*
+ *      Each device on the slave passes data to and from the host via a ring
+ *      queue in shared memory. Define a ring queue structure to hold the
+ *      vital information about each ring queue. Two ring queues will be
+ *      allocated for each port, one for receive data and one for transmit
+ *      data.
+ */
+typedef struct cdkasyrq {
+        unsigned long   offset;
+        unsigned short  size;
+        unsigned short  head;
+        unsigned short  tail;
+} cdkasyrq_t;
+
+/*
+ *      Each asynchronous port is defined in shared memory by the following
+ *      structure. It contains a control block to command a device, and also
+ *      the necessary data channel information as well.
+ */
+typedef struct cdkasy {
+        cdkctrl_t       ctrl;
+        unsigned short  notify;
+        asynotify_t     changed;
+        unsigned short  receive;
+        cdkasyrq_t      rxq;
+        unsigned short  transmit;
+        cdkasyrq_t      txq;
+} cdkasy_t;
+
+#pragma pack()
+
+/*****************************************************************************/
+
+/*
+ *      Define the set of ioctls used by the driver to do special things
+ *      to the board. These include interrupting it, and initializing
+ *      the driver after board startup and shutdown.
+ */
+#include <linux/ioctl.h>
+
+#define STL_BINTR       _IO('s',20)
+#define STL_BSTART      _IO('s',21)
+#define STL_BSTOP       _IO('s',22)
+#define STL_BRESET      _IO('s',23)
+
+/*
+ *      Define a set of ioctl extensions, used to get at special stuff.
+ */
+#define STL_GETPFLAG    _IO('s',80)
+#define STL_SETPFLAG    _IO('s',81)
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
new file mode 100644
index 000000000000..b68fdf1f3156
--- /dev/null
+++ b/include/linux/cdrom.h
@@ -0,0 +1,1192 @@
+/*
+ * -- <linux/cdrom.h>
+ * General header file for linux CD-ROM drivers 
+ * Copyright (C) 1992         David Giller, rafetmad@oxy.edu
+ *               1994, 1995   Eberhard Moenkeberg, emoenke@gwdg.de
+ *               1996         David van Leeuwen, david@tm.tno.nl
+ *               1997, 1998   Erik Andersen, andersee@debian.org
+ *               1998-2002    Jens Axboe, axboe@suse.de
+ */
+ 
+#ifndef _LINUX_CDROM_H
+#define _LINUX_CDROM_H
+
+#include <asm/byteorder.h>
+
+/*******************************************************
+ * As of Linux 2.1.x, all Linux CD-ROM application programs will use this 
+ * (and only this) include file.  It is my hope to provide Linux with
+ * a uniform interface between software accessing CD-ROMs and the various 
+ * device drivers that actually talk to the drives.  There may still be
+ * 23 different kinds of strange CD-ROM drives, but at least there will 
+ * now be one, and only one, Linux CD-ROM interface.
+ *
+ * Additionally, as of Linux 2.1.x, all Linux application programs 
+ * should use the O_NONBLOCK option when opening a CD-ROM device 
+ * for subsequent ioctl commands.  This allows for neat system errors 
+ * like "No medium found" or "Wrong medium type" upon attempting to 
+ * mount or play an empty slot, mount an audio disc, or play a data disc.
+ * Generally, changing an application program to support O_NONBLOCK
+ * is as easy as the following:
+ *       -    drive = open("/dev/cdrom", O_RDONLY);
+ *       +    drive = open("/dev/cdrom", O_RDONLY | O_NONBLOCK);
+ * It is worth the small change.
+ *
+ *  Patches for many common CD programs (provided by David A. van Leeuwen)
+ *  can be found at:  ftp://ftp.gwdg.de/pub/linux/cdrom/drivers/cm206/
+ * 
+ *******************************************************/
+
+/* When a driver supports a certain function, but the cdrom drive we are 
+ * using doesn't, we will return the error EDRIVE_CANT_DO_THIS.  We will 
+ * borrow the "Operation not supported" error from the network folks to 
+ * accomplish this.  Maybe someday we will get a more targeted error code, 
+ * but this will do for now... */
+#define EDRIVE_CANT_DO_THIS  EOPNOTSUPP
+
+/*******************************************************
+ * The CD-ROM IOCTL commands  -- these should be supported by 
+ * all the various cdrom drivers.  For the CD-ROM ioctls, we 
+ * will commandeer byte 0x53, or 'S'.
+ *******************************************************/
+#define CDROMPAUSE              0x5301 /* Pause Audio Operation */ 
+#define CDROMRESUME             0x5302 /* Resume paused Audio Operation */
+#define CDROMPLAYMSF            0x5303 /* Play Audio MSF (struct cdrom_msf) */
+#define CDROMPLAYTRKIND         0x5304 /* Play Audio Track/index 
+                                           (struct cdrom_ti) */
+#define CDROMREADTOCHDR         0x5305 /* Read TOC header 
+                                           (struct cdrom_tochdr) */
+#define CDROMREADTOCENTRY       0x5306 /* Read TOC entry 
+                                           (struct cdrom_tocentry) */
+#define CDROMSTOP               0x5307 /* Stop the cdrom drive */
+#define CDROMSTART              0x5308 /* Start the cdrom drive */
+#define CDROMEJECT              0x5309 /* Ejects the cdrom media */
+#define CDROMVOLCTRL            0x530a /* Control output volume 
+                                           (struct cdrom_volctrl) */
+#define CDROMSUBCHNL            0x530b /* Read subchannel data 
+                                           (struct cdrom_subchnl) */
+#define CDROMREADMODE2          0x530c /* Read CDROM mode 2 data (2336 Bytes) 
+                                           (struct cdrom_read) */
+#define CDROMREADMODE1          0x530d /* Read CDROM mode 1 data (2048 Bytes)
+                                           (struct cdrom_read) */
+#define CDROMREADAUDIO          0x530e /* (struct cdrom_read_audio) */
+#define CDROMEJECT_SW           0x530f /* enable(1)/disable(0) auto-ejecting */
+#define CDROMMULTISESSION       0x5310 /* Obtain the start-of-last-session 
+                                           address of multi session disks 
+                                           (struct cdrom_multisession) */
+#define CDROM_GET_MCN           0x5311 /* Obtain the "Universal Product Code" 
+                                           if available (struct cdrom_mcn) */
+#define CDROM_GET_UPC           CDROM_GET_MCN  /* This one is depricated, 
+                                          but here anyway for compatibility */
+#define CDROMRESET              0x5312 /* hard-reset the drive */
+#define CDROMVOLREAD            0x5313 /* Get the drive's volume setting 
+                                          (struct cdrom_volctrl) */
+#define CDROMREADRAW            0x5314  /* read data in raw mode (2352 Bytes)
+                                           (struct cdrom_read) */
+/* 
+ * These ioctls are used only used in aztcd.c and optcd.c
+ */
+#define CDROMREADCOOKED         0x5315  /* read data in cooked mode */
+#define CDROMSEEK               0x5316  /* seek msf address */
+  
+/*
+ * This ioctl is only used by the scsi-cd driver.  
+   It is for playing audio in logical block addressing mode.
+ */
+#define CDROMPLAYBLK            0x5317  /* (struct cdrom_blk) */
+
+/* 
+ * These ioctls are only used in optcd.c
+ */
+#define CDROMREADALL            0x5318  /* read all 2646 bytes */
+
+/* 
+ * These ioctls are (now) only in ide-cd.c for controlling 
+ * drive spindown time.  They should be implemented in the
+ * Uniform driver, via generic packet commands, GPCMD_MODE_SELECT_10,
+ * GPCMD_MODE_SENSE_10 and the GPMODE_POWER_PAGE...
+ *  -Erik
+ */
+#define CDROMGETSPINDOWN        0x531d
+#define CDROMSETSPINDOWN        0x531e
+
+/* 
+ * These ioctls are implemented through the uniform CD-ROM driver
+ * They _will_ be adopted by all CD-ROM drivers, when all the CD-ROM
+ * drivers are eventually ported to the uniform CD-ROM driver interface.
+ */
+#define CDROMCLOSETRAY          0x5319  /* pendant of CDROMEJECT */
+#define CDROM_SET_OPTIONS       0x5320  /* Set behavior options */
+#define CDROM_CLEAR_OPTIONS     0x5321  /* Clear behavior options */
+#define CDROM_SELECT_SPEED      0x5322  /* Set the CD-ROM speed */
+#define CDROM_SELECT_DISC       0x5323  /* Select disc (for juke-boxes) */
+#define CDROM_MEDIA_CHANGED     0x5325  /* Check is media changed  */
+#define CDROM_DRIVE_STATUS      0x5326  /* Get tray position, etc. */
+#define CDROM_DISC_STATUS       0x5327  /* Get disc type, etc. */
+#define CDROM_CHANGER_NSLOTS    0x5328  /* Get number of slots */
+#define CDROM_LOCKDOOR          0x5329  /* lock or unlock door */
+#define CDROM_DEBUG             0x5330  /* Turn debug messages on/off */
+#define CDROM_GET_CAPABILITY    0x5331  /* get capabilities */
+
+/* Note that scsi/scsi_ioctl.h also uses 0x5382 - 0x5386.
+ * Future CDROM ioctls should be kept below 0x537F
+ */
+
+/* This ioctl is only used by sbpcd at the moment */
+#define CDROMAUDIOBUFSIZ        0x5382  /* set the audio buffer size */
+                                        /* conflict with SCSI_IOCTL_GET_IDLUN */
+
+/* DVD-ROM Specific ioctls */
+#define DVD_READ_STRUCT         0x5390  /* Read structure */
+#define DVD_WRITE_STRUCT        0x5391  /* Write structure */
+#define DVD_AUTH                0x5392  /* Authentication */
+
+#define CDROM_SEND_PACKET       0x5393  /* send a packet to the drive */
+#define CDROM_NEXT_WRITABLE     0x5394  /* get next writable block */
+#define CDROM_LAST_WRITTEN      0x5395  /* get last block written on disc */
+
+/*******************************************************
+ * CDROM IOCTL structures
+ *******************************************************/
+
+/* Address in MSF format */
+struct cdrom_msf0               
+{
+        __u8    minute;
+        __u8    second;
+        __u8    frame;
+};
+
+/* Address in either MSF or logical format */
+union cdrom_addr                
+{
+        struct cdrom_msf0       msf;
+        int                     lba;
+};
+
+/* This struct is used by the CDROMPLAYMSF ioctl */ 
+struct cdrom_msf 
+{
+        __u8    cdmsf_min0;     /* start minute */
+        __u8    cdmsf_sec0;     /* start second */
+        __u8    cdmsf_frame0;   /* start frame */
+        __u8    cdmsf_min1;     /* end minute */
+        __u8    cdmsf_sec1;     /* end second */
+        __u8    cdmsf_frame1;   /* end frame */
+};
+
+/* This struct is used by the CDROMPLAYTRKIND ioctl */
+struct cdrom_ti 
+{
+        __u8    cdti_trk0;      /* start track */
+        __u8    cdti_ind0;      /* start index */
+        __u8    cdti_trk1;      /* end track */
+        __u8    cdti_ind1;      /* end index */
+};
+
+/* This struct is used by the CDROMREADTOCHDR ioctl */
+struct cdrom_tochdr     
+{
+        __u8    cdth_trk0;      /* start track */
+        __u8    cdth_trk1;      /* end track */
+};
+
+/* This struct is used by the CDROMVOLCTRL and CDROMVOLREAD ioctls */
+struct cdrom_volctrl
+{
+        __u8    channel0;
+        __u8    channel1;
+        __u8    channel2;
+        __u8    channel3;
+};
+
+/* This struct is used by the CDROMSUBCHNL ioctl */
+struct cdrom_subchnl 
+{
+        __u8    cdsc_format;
+        __u8    cdsc_audiostatus;
+        __u8    cdsc_adr:       4;
+        __u8    cdsc_ctrl:      4;
+        __u8    cdsc_trk;
+        __u8    cdsc_ind;
+        union cdrom_addr cdsc_absaddr;
+        union cdrom_addr cdsc_reladdr;
+};
+
+
+/* This struct is used by the CDROMREADTOCENTRY ioctl */
+struct cdrom_tocentry 
+{
+        __u8    cdte_track;
+        __u8    cdte_adr        :4;
+        __u8    cdte_ctrl       :4;
+        __u8    cdte_format;
+        union cdrom_addr cdte_addr;
+        __u8    cdte_datamode;
+};
+
+/* This struct is used by the CDROMREADMODE1, and CDROMREADMODE2 ioctls */
+struct cdrom_read      
+{
+        int     cdread_lba;
+        char    *cdread_bufaddr;
+        int     cdread_buflen;
+};
+
+/* This struct is used by the CDROMREADAUDIO ioctl */
+struct cdrom_read_audio
+{
+        union cdrom_addr addr; /* frame address */
+        __u8 addr_format;      /* CDROM_LBA or CDROM_MSF */
+        int nframes;           /* number of 2352-byte-frames to read at once */
+        __u8 __user *buf;      /* frame buffer (size: nframes*2352 bytes) */
+};
+
+/* This struct is used with the CDROMMULTISESSION ioctl */
+struct cdrom_multisession
+{
+        union cdrom_addr addr; /* frame address: start-of-last-session 
+                                   (not the new "frame 16"!).  Only valid
+                                   if the "xa_flag" is true. */
+        __u8 xa_flag;        /* 1: "is XA disk" */
+        __u8 addr_format;    /* CDROM_LBA or CDROM_MSF */
+};
+
+/* This struct is used with the CDROM_GET_MCN ioctl.  
+ * Very few audio discs actually have Universal Product Code information, 
+ * which should just be the Medium Catalog Number on the box.  Also note 
+ * that the way the codeis written on CD is _not_ uniform across all discs!
+ */  
+struct cdrom_mcn 
+{
+  __u8 medium_catalog_number[14]; /* 13 ASCII digits, null-terminated */
+};
+
+/* This is used by the CDROMPLAYBLK ioctl */
+struct cdrom_blk 
+{
+        unsigned from;
+        unsigned short len;
+};
+
+#define CDROM_PACKET_SIZE       12
+
+#define CGC_DATA_UNKNOWN        0
+#define CGC_DATA_WRITE          1
+#define CGC_DATA_READ           2
+#define CGC_DATA_NONE           3
+
+/* for CDROM_PACKET_COMMAND ioctl */
+struct cdrom_generic_command
+{
+        unsigned char           cmd[CDROM_PACKET_SIZE];
+        unsigned char           __user *buffer;
+        unsigned int            buflen;
+        int                     stat;
+        struct request_sense    __user *sense;
+        unsigned char           data_direction;
+        int                     quiet;
+        int                     timeout;
+        void                    __user *reserved[1];    /* unused, actually */
+};
+
+/*
+ * A CD-ROM physical sector size is 2048, 2052, 2056, 2324, 2332, 2336, 
+ * 2340, or 2352 bytes long.  
+
+*         Sector types of the standard CD-ROM data formats:
+ *
+ * format   sector type               user data size (bytes)
+ * -----------------------------------------------------------------------------
+ *   1     (Red Book)    CD-DA          2352    (CD_FRAMESIZE_RAW)
+ *   2     (Yellow Book) Mode1 Form1    2048    (CD_FRAMESIZE)
+ *   3     (Yellow Book) Mode1 Form2    2336    (CD_FRAMESIZE_RAW0)
+ *   4     (Green Book)  Mode2 Form1    2048    (CD_FRAMESIZE)
+ *   5     (Green Book)  Mode2 Form2    2328    (2324+4 spare bytes)
+ *
+ *
+ *       The layout of the standard CD-ROM data formats:
+ * -----------------------------------------------------------------------------
+ * - audio (red):                  | audio_sample_bytes |
+ *                                 |        2352        |
+ *
+ * - data (yellow, mode1):         | sync - head - data - EDC - zero - ECC |
+ *                                 |  12  -   4  - 2048 -  4  -   8  - 276 |
+ *
+ * - data (yellow, mode2):         | sync - head - data |
+ *                                 |  12  -   4  - 2336 |
+ *
+ * - XA data (green, mode2 form1): | sync - head - sub - data - EDC - ECC |
+ *                                 |  12  -   4  -  8  - 2048 -  4  - 276 |
+ *
+ * - XA data (green, mode2 form2): | sync - head - sub - data - Spare |
+ *                                 |  12  -   4  -  8  - 2324 -  4    |
+ *
+ */
+
+/* Some generally useful CD-ROM information -- mostly based on the above */
+#define CD_MINS              74 /* max. minutes per CD, not really a limit */
+#define CD_SECS              60 /* seconds per minute */
+#define CD_FRAMES            75 /* frames per second */
+#define CD_SYNC_SIZE         12 /* 12 sync bytes per raw data frame */
+#define CD_MSF_OFFSET       150 /* MSF numbering offset of first frame */
+#define CD_CHUNK_SIZE        24 /* lowest-level "data bytes piece" */
+#define CD_NUM_OF_CHUNKS     98 /* chunks per frame */
+#define CD_FRAMESIZE_SUB     96 /* subchannel data "frame" size */
+#define CD_HEAD_SIZE          4 /* header (address) bytes per raw data frame */
+#define CD_SUBHEAD_SIZE       8 /* subheader bytes per raw XA data frame */
+#define CD_EDC_SIZE           4 /* bytes EDC per most raw data frame types */
+#define CD_ZERO_SIZE          8 /* bytes zero per yellow book mode 1 frame */
+#define CD_ECC_SIZE         276 /* bytes ECC per most raw data frame types */
+#define CD_FRAMESIZE       2048 /* bytes per frame, "cooked" mode */
+#define CD_FRAMESIZE_RAW   2352 /* bytes per frame, "raw" mode */
+#define CD_FRAMESIZE_RAWER 2646 /* The maximum possible returned bytes */ 
+/* most drives don't deliver everything: */
+#define CD_FRAMESIZE_RAW1 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE) /*2340*/
+#define CD_FRAMESIZE_RAW0 (CD_FRAMESIZE_RAW-CD_SYNC_SIZE-CD_HEAD_SIZE) /*2336*/
+
+#define CD_XA_HEAD        (CD_HEAD_SIZE+CD_SUBHEAD_SIZE) /* "before data" part of raw XA frame */
+#define CD_XA_TAIL        (CD_EDC_SIZE+CD_ECC_SIZE) /* "after data" part of raw XA frame */
+#define CD_XA_SYNC_HEAD   (CD_SYNC_SIZE+CD_XA_HEAD) /* sync bytes + header of XA frame */
+
+/* CD-ROM address types (cdrom_tocentry.cdte_format) */
+#define CDROM_LBA 0x01 /* "logical block": first frame is #0 */
+#define CDROM_MSF 0x02 /* "minute-second-frame": binary, not bcd here! */
+
+/* bit to tell whether track is data or audio (cdrom_tocentry.cdte_ctrl) */
+#define CDROM_DATA_TRACK        0x04
+
+/* The leadout track is always 0xAA, regardless of # of tracks on disc */
+#define CDROM_LEADOUT           0xAA
+
+/* audio states (from SCSI-2, but seen with other drives, too) */
+#define CDROM_AUDIO_INVALID     0x00    /* audio status not supported */
+#define CDROM_AUDIO_PLAY        0x11    /* audio play operation in progress */
+#define CDROM_AUDIO_PAUSED      0x12    /* audio play operation paused */
+#define CDROM_AUDIO_COMPLETED   0x13    /* audio play successfully completed */
+#define CDROM_AUDIO_ERROR       0x14    /* audio play stopped due to error */
+#define CDROM_AUDIO_NO_STATUS   0x15    /* no current audio status to return */
+
+/* capability flags used with the uniform CD-ROM driver */ 
+#define CDC_CLOSE_TRAY          0x1     /* caddy systems _can't_ close */
+#define CDC_OPEN_TRAY           0x2     /* but _can_ eject.  */
+#define CDC_LOCK                0x4     /* disable manual eject */
+#define CDC_SELECT_SPEED        0x8     /* programmable speed */
+#define CDC_SELECT_DISC         0x10    /* select disc from juke-box */
+#define CDC_MULTI_SESSION       0x20    /* read sessions>1 */
+#define CDC_MCN                 0x40    /* Medium Catalog Number */
+#define CDC_MEDIA_CHANGED       0x80    /* media changed */
+#define CDC_PLAY_AUDIO          0x100   /* audio functions */
+#define CDC_RESET               0x200   /* hard reset device */
+#define CDC_IOCTLS              0x400   /* driver has non-standard ioctls */
+#define CDC_DRIVE_STATUS        0x800   /* driver implements drive status */
+#define CDC_GENERIC_PACKET      0x1000  /* driver implements generic packets */
+#define CDC_CD_R                0x2000  /* drive is a CD-R */
+#define CDC_CD_RW               0x4000  /* drive is a CD-RW */
+#define CDC_DVD                 0x8000  /* drive is a DVD */
+#define CDC_DVD_R               0x10000 /* drive can write DVD-R */
+#define CDC_DVD_RAM             0x20000 /* drive can write DVD-RAM */
+#define CDC_MO_DRIVE            0x40000 /* drive is an MO device */
+#define CDC_MRW                 0x80000 /* drive can read MRW */
+#define CDC_MRW_W               0x100000 /* drive can write MRW */
+#define CDC_RAM                 0x200000 /* ok to open for WRITE */
+
+/* drive status possibilities returned by CDROM_DRIVE_STATUS ioctl */
+#define CDS_NO_INFO             0       /* if not implemented */
+#define CDS_NO_DISC             1
+#define CDS_TRAY_OPEN           2
+#define CDS_DRIVE_NOT_READY     3
+#define CDS_DISC_OK             4
+
+/* return values for the CDROM_DISC_STATUS ioctl */
+/* can also return CDS_NO_[INFO|DISC], from above */
+#define CDS_AUDIO               100
+#define CDS_DATA_1              101
+#define CDS_DATA_2              102
+#define CDS_XA_2_1              103
+#define CDS_XA_2_2              104
+#define CDS_MIXED               105
+
+/* User-configurable behavior options for the uniform CD-ROM driver */
+#define CDO_AUTO_CLOSE          0x1     /* close tray on first open() */
+#define CDO_AUTO_EJECT          0x2     /* open tray on last release() */
+#define CDO_USE_FFLAGS          0x4     /* use O_NONBLOCK information on open */
+#define CDO_LOCK                0x8     /* lock tray on open files */
+#define CDO_CHECK_TYPE          0x10    /* check type on open for data */
+
+/* Special codes used when specifying changer slots. */
+#define CDSL_NONE               ((int) (~0U>>1)-1)
+#define CDSL_CURRENT            ((int) (~0U>>1))
+
+/* For partition based multisession access. IDE can handle 64 partitions
+ * per drive - SCSI CD-ROM's use minors to differentiate between the
+ * various drives, so we can't do multisessions the same way there.
+ * Use the -o session=x option to mount on them.
+ */
+#define CD_PART_MAX             64
+#define CD_PART_MASK            (CD_PART_MAX - 1)
+
+/*********************************************************************
+ * Generic Packet commands, MMC commands, and such
+ *********************************************************************/
+
+ /* The generic packet command opcodes for CD/DVD Logical Units,
+ * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
+#define GPCMD_BLANK                         0xa1
+#define GPCMD_CLOSE_TRACK                   0x5b
+#define GPCMD_FLUSH_CACHE                   0x35
+#define GPCMD_FORMAT_UNIT                   0x04
+#define GPCMD_GET_CONFIGURATION             0x46
+#define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
+#define GPCMD_GET_PERFORMANCE               0xac
+#define GPCMD_INQUIRY                       0x12
+#define GPCMD_LOAD_UNLOAD                   0xa6
+#define GPCMD_MECHANISM_STATUS              0xbd
+#define GPCMD_MODE_SELECT_10                0x55
+#define GPCMD_MODE_SENSE_10                 0x5a
+#define GPCMD_PAUSE_RESUME                  0x4b
+#define GPCMD_PLAY_AUDIO_10                 0x45
+#define GPCMD_PLAY_AUDIO_MSF                0x47
+#define GPCMD_PLAY_AUDIO_TI                 0x48
+#define GPCMD_PLAY_CD                       0xbc
+#define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL  0x1e
+#define GPCMD_READ_10                       0x28
+#define GPCMD_READ_12                       0xa8
+#define GPCMD_READ_BUFFER_CAPACITY          0x5c
+#define GPCMD_READ_CDVD_CAPACITY            0x25
+#define GPCMD_READ_CD                       0xbe
+#define GPCMD_READ_CD_MSF                   0xb9
+#define GPCMD_READ_DISC_INFO                0x51
+#define GPCMD_READ_DVD_STRUCTURE            0xad
+#define GPCMD_READ_FORMAT_CAPACITIES        0x23
+#define GPCMD_READ_HEADER                   0x44
+#define GPCMD_READ_TRACK_RZONE_INFO         0x52
+#define GPCMD_READ_SUBCHANNEL               0x42
+#define GPCMD_READ_TOC_PMA_ATIP             0x43
+#define GPCMD_REPAIR_RZONE_TRACK            0x58
+#define GPCMD_REPORT_KEY                    0xa4
+#define GPCMD_REQUEST_SENSE                 0x03
+#define GPCMD_RESERVE_RZONE_TRACK           0x53
+#define GPCMD_SEND_CUE_SHEET                0x5d
+#define GPCMD_SCAN                          0xba
+#define GPCMD_SEEK                          0x2b
+#define GPCMD_SEND_DVD_STRUCTURE            0xbf
+#define GPCMD_SEND_EVENT                    0xa2
+#define GPCMD_SEND_KEY                      0xa3
+#define GPCMD_SEND_OPC                      0x54
+#define GPCMD_SET_READ_AHEAD                0xa7
+#define GPCMD_SET_STREAMING                 0xb6
+#define GPCMD_START_STOP_UNIT               0x1b
+#define GPCMD_STOP_PLAY_SCAN                0x4e
+#define GPCMD_TEST_UNIT_READY               0x00
+#define GPCMD_VERIFY_10                     0x2f
+#define GPCMD_WRITE_10                      0x2a
+#define GPCMD_WRITE_AND_VERIFY_10           0x2e
+/* This is listed as optional in ATAPI 2.6, but is (curiously) 
+ * missing from Mt. Fuji, Table 57.  It _is_ mentioned in Mt. Fuji
+ * Table 377 as an MMC command for SCSi devices though...  Most ATAPI
+ * drives support it. */
+#define GPCMD_SET_SPEED                     0xbb
+/* This seems to be a SCSI specific CD-ROM opcode 
+ * to play data at track/index */
+#define GPCMD_PLAYAUDIO_TI                  0x48
+/*
+ * From MS Media Status Notification Support Specification. For
+ * older drives only.
+ */
+#define GPCMD_GET_MEDIA_STATUS              0xda
+
+/* Mode page codes for mode sense/set */
+#define GPMODE_VENDOR_PAGE              0x00
+#define GPMODE_R_W_ERROR_PAGE           0x01
+#define GPMODE_WRITE_PARMS_PAGE         0x05
+#define GPMODE_WCACHING_PAGE            0x08
+#define GPMODE_AUDIO_CTL_PAGE           0x0e
+#define GPMODE_POWER_PAGE               0x1a
+#define GPMODE_FAULT_FAIL_PAGE          0x1c
+#define GPMODE_TO_PROTECT_PAGE          0x1d
+#define GPMODE_CAPABILITIES_PAGE        0x2a
+#define GPMODE_ALL_PAGES                0x3f
+/* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
+ * of MODE_SENSE_POWER_PAGE */
+#define GPMODE_CDROM_PAGE               0x0d
+
+
+
+/* DVD struct types */
+#define DVD_STRUCT_PHYSICAL     0x00
+#define DVD_STRUCT_COPYRIGHT    0x01
+#define DVD_STRUCT_DISCKEY      0x02
+#define DVD_STRUCT_BCA          0x03
+#define DVD_STRUCT_MANUFACT     0x04
+
+struct dvd_layer {
+        __u8 book_version       : 4;
+        __u8 book_type          : 4;
+        __u8 min_rate           : 4;
+        __u8 disc_size          : 4;
+        __u8 layer_type         : 4;
+        __u8 track_path         : 1;
+        __u8 nlayers            : 2;
+        __u8 track_density      : 4;
+        __u8 linear_density     : 4;
+        __u8 bca                : 1;
+        __u32 start_sector;
+        __u32 end_sector;
+        __u32 end_sector_l0;
+};
+
+#define DVD_LAYERS      4
+
+struct dvd_physical {
+        __u8 type;
+        __u8 layer_num;
+        struct dvd_layer layer[DVD_LAYERS];
+};
+
+struct dvd_copyright {
+        __u8 type;
+
+        __u8 layer_num;
+        __u8 cpst;
+        __u8 rmi;
+};
+
+struct dvd_disckey {
+        __u8 type;
+
+        unsigned agid           : 2;
+        __u8 value[2048];
+};
+
+struct dvd_bca {
+        __u8 type;
+
+        int len;
+        __u8 value[188];
+};
+
+struct dvd_manufact {
+        __u8 type;
+
+        __u8 layer_num;
+        int len;
+        __u8 value[2048];
+};
+
+typedef union {
+        __u8 type;
+
+        struct dvd_physical     physical;
+        struct dvd_copyright    copyright;
+        struct dvd_disckey      disckey;
+        struct dvd_bca          bca;
+        struct dvd_manufact     manufact;
+} dvd_struct;
+
+/*
+ * DVD authentication ioctl
+ */
+
+/* Authentication states */
+#define DVD_LU_SEND_AGID        0
+#define DVD_HOST_SEND_CHALLENGE 1
+#define DVD_LU_SEND_KEY1        2
+#define DVD_LU_SEND_CHALLENGE   3
+#define DVD_HOST_SEND_KEY2      4
+
+/* Termination states */
+#define DVD_AUTH_ESTABLISHED    5
+#define DVD_AUTH_FAILURE        6
+
+/* Other functions */
+#define DVD_LU_SEND_TITLE_KEY   7
+#define DVD_LU_SEND_ASF         8
+#define DVD_INVALIDATE_AGID     9
+#define DVD_LU_SEND_RPC_STATE   10
+#define DVD_HOST_SEND_RPC_STATE 11
+
+/* State data */
+typedef __u8 dvd_key[5];                /* 40-bit value, MSB is first elem. */
+typedef __u8 dvd_challenge[10]; /* 80-bit value, MSB is first elem. */
+
+struct dvd_lu_send_agid {
+        __u8 type;
+        unsigned agid           : 2;
+};
+
+struct dvd_host_send_challenge {
+        __u8 type;
+        unsigned agid           : 2;
+
+        dvd_challenge chal;
+};
+
+struct dvd_send_key {
+        __u8 type;
+        unsigned agid           : 2;
+
+        dvd_key key;
+};
+
+struct dvd_lu_send_challenge {
+        __u8 type;
+        unsigned agid           : 2;
+
+        dvd_challenge chal;
+};
+
+#define DVD_CPM_NO_COPYRIGHT    0
+#define DVD_CPM_COPYRIGHTED     1
+
+#define DVD_CP_SEC_NONE         0
+#define DVD_CP_SEC_EXIST        1
+
+#define DVD_CGMS_UNRESTRICTED   0
+#define DVD_CGMS_SINGLE         2
+#define DVD_CGMS_RESTRICTED     3
+
+struct dvd_lu_send_title_key {
+        __u8 type;
+        unsigned agid           : 2;
+
+        dvd_key title_key;
+        int lba;
+        unsigned cpm            : 1;
+        unsigned cp_sec         : 1;
+        unsigned cgms           : 2;
+};
+
+struct dvd_lu_send_asf {
+        __u8 type;
+        unsigned agid           : 2;
+
+        unsigned asf            : 1;
+};
+
+struct dvd_host_send_rpcstate {
+        __u8 type;
+        __u8 pdrc;
+};
+
+struct dvd_lu_send_rpcstate {
+        __u8 type               : 2;
+        __u8 vra                : 3;
+        __u8 ucca               : 3;
+        __u8 region_mask;
+        __u8 rpc_scheme;
+};
+
+typedef union {
+        __u8 type;
+
+        struct dvd_lu_send_agid         lsa;
+        struct dvd_host_send_challenge  hsc;
+        struct dvd_send_key             lsk;
+        struct dvd_lu_send_challenge    lsc;
+        struct dvd_send_key             hsk;
+        struct dvd_lu_send_title_key    lstk;
+        struct dvd_lu_send_asf          lsasf;
+        struct dvd_host_send_rpcstate   hrpcs;
+        struct dvd_lu_send_rpcstate     lrpcs;
+} dvd_authinfo;
+
+struct request_sense {
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 valid              : 1;
+        __u8 error_code         : 7;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 error_code         : 7;
+        __u8 valid              : 1;
+#endif
+        __u8 segment_number;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved1          : 2;
+        __u8 ili                : 1;
+        __u8 reserved2          : 1;
+        __u8 sense_key          : 4;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 sense_key          : 4;
+        __u8 reserved2          : 1;
+        __u8 ili                : 1;
+        __u8 reserved1          : 2;
+#endif
+        __u8 information[4];
+        __u8 add_sense_len;
+        __u8 command_info[4];
+        __u8 asc;
+        __u8 ascq;
+        __u8 fruc;
+        __u8 sks[3];
+        __u8 asb[46];
+};
+
+/*
+ * feature profile
+ */
+#define CDF_RWRT        0x0020  /* "Random Writable" */
+#define CDF_HWDM        0x0024  /* "Hardware Defect Management" */
+#define CDF_MRW         0x0028
+
+/*
+ * media status bits
+ */
+#define CDM_MRW_NOTMRW                  0
+#define CDM_MRW_BGFORMAT_INACTIVE       1
+#define CDM_MRW_BGFORMAT_ACTIVE         2
+#define CDM_MRW_BGFORMAT_COMPLETE       3
+
+/*
+ * mrw address spaces
+ */
+#define MRW_LBA_DMA                     0
+#define MRW_LBA_GAA                     1
+
+/*
+ * mrw mode pages (first is deprecated) -- probed at init time and
+ * cdi->mrw_mode_page is set
+ */
+#define MRW_MODE_PC_PRE1                0x2c
+#define MRW_MODE_PC                     0x03
+
+struct mrw_feature_desc {
+        __u16 feature_code;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved1          : 2;
+        __u8 feature_version    : 4;
+        __u8 persistent         : 1;
+        __u8 curr               : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 curr               : 1;
+        __u8 persistent         : 1;
+        __u8 feature_version    : 4;
+        __u8 reserved1          : 2;
+#endif
+        __u8 add_len;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved2          : 7;
+        __u8 write              : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 write              : 1;
+        __u8 reserved2          : 7;
+#endif
+        __u8 reserved3;
+        __u8 reserved4;
+        __u8 reserved5;
+};
+
+/* cf. mmc4r02g.pdf 5.3.10 Random Writable Feature (0020h) pg 197 of 635 */
+struct rwrt_feature_desc {
+        __u16 feature_code;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved1          : 2;
+        __u8 feature_version    : 4;
+        __u8 persistent         : 1;
+        __u8 curr               : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 curr               : 1;
+        __u8 persistent         : 1;
+        __u8 feature_version    : 4;
+        __u8 reserved1          : 2;
+#endif
+        __u8 add_len;
+        __u32 last_lba;
+        __u32 block_size;
+        __u16 blocking;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved2          : 7;
+        __u8 page_present       : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 page_present       : 1;
+        __u8 reserved2          : 7;
+#endif
+        __u8 reserved3;
+};
+
+typedef struct {
+        __u16 disc_information_length;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved1                  : 3;
+        __u8 erasable                   : 1;
+        __u8 border_status              : 2;
+        __u8 disc_status                : 2;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 disc_status                : 2;
+        __u8 border_status              : 2;
+        __u8 erasable                   : 1;
+        __u8 reserved1                  : 3;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        __u8 n_first_track;
+        __u8 n_sessions_lsb;
+        __u8 first_track_lsb;
+        __u8 last_track_lsb;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 did_v                      : 1;
+        __u8 dbc_v                      : 1;
+        __u8 uru                        : 1;
+        __u8 reserved2                  : 2;
+        __u8 dbit                       : 1;
+        __u8 mrw_status                 : 2;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 mrw_status                 : 2;
+        __u8 dbit                       : 1;
+        __u8 reserved2                  : 2;
+        __u8 uru                        : 1;
+        __u8 dbc_v                      : 1;
+        __u8 did_v                      : 1;
+#endif
+        __u8 disc_type;
+        __u8 n_sessions_msb;
+        __u8 first_track_msb;
+        __u8 last_track_msb;
+        __u32 disc_id;
+        __u32 lead_in;
+        __u32 lead_out;
+        __u8 disc_bar_code[8];
+        __u8 reserved3;
+        __u8 n_opc;
+} disc_information;
+
+typedef struct {
+        __u16 track_information_length;
+        __u8 track_lsb;
+        __u8 session_lsb;
+        __u8 reserved1;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved2                  : 2;
+        __u8 damage                     : 1;
+        __u8 copy                       : 1;
+        __u8 track_mode                 : 4;
+        __u8 rt                         : 1;
+        __u8 blank                      : 1;
+        __u8 packet                     : 1;
+        __u8 fp                         : 1;
+        __u8 data_mode                  : 4;
+        __u8 reserved3                  : 6;
+        __u8 lra_v                      : 1;
+        __u8 nwa_v                      : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 track_mode                 : 4;
+        __u8 copy                       : 1;
+        __u8 damage                     : 1;
+        __u8 reserved2                  : 2;
+        __u8 data_mode                  : 4;
+        __u8 fp                         : 1;
+        __u8 packet                     : 1;
+        __u8 blank                      : 1;
+        __u8 rt                         : 1;
+        __u8 nwa_v                      : 1;
+        __u8 lra_v                      : 1;
+        __u8 reserved3                  : 6;
+#endif
+        __u32 track_start;
+        __u32 next_writable;
+        __u32 free_blocks;
+        __u32 fixed_packet_size;
+        __u32 track_size;
+        __u32 last_rec_address;
+} track_information;
+
+struct feature_header {
+        __u32 data_len;
+        __u8 reserved1;
+        __u8 reserved2;
+        __u16 curr_profile;
+};
+
+struct mode_page_header {
+        __u16 mode_data_length;
+        __u8 medium_type;
+        __u8 reserved1;
+        __u8 reserved2;
+        __u8 reserved3;
+        __u16 desc_length;
+};
+
+#ifdef __KERNEL__
+#include <linux/fs.h>           /* not really needed, later.. */
+#include <linux/device.h>
+
+struct packet_command
+{
+        unsigned char           cmd[CDROM_PACKET_SIZE];
+        unsigned char           *buffer;
+        unsigned int            buflen;
+        int                     stat;
+        struct request_sense    *sense;
+        unsigned char           data_direction;
+        int                     quiet;
+        int                     timeout;
+        void                    *reserved[1];
+};
+
+/*
+ * _OLD will use PIO transfer on atapi devices, _BPC_* will use DMA
+ */
+#define CDDA_OLD                0       /* old style */
+#define CDDA_BPC_SINGLE         1       /* single frame block pc */
+#define CDDA_BPC_FULL           2       /* multi frame block pc */
+
+/* Uniform cdrom data structures for cdrom.c */
+struct cdrom_device_info {
+        struct cdrom_device_ops  *ops;  /* link to device_ops */
+        struct cdrom_device_info *next; /* next device_info for this major */
+        struct gendisk *disk;           /* matching block layer disk */
+        void *handle;                   /* driver-dependent data */
+/* specifications */
+        int mask;                       /* mask of capability: disables them */
+        int speed;                      /* maximum speed for reading data */
+        int capacity;                   /* number of discs in jukebox */
+/* device-related storage */
+        int options             : 30;   /* options flags */
+        unsigned mc_flags       : 2;    /* media change buffer flags */
+        int use_count;                  /* number of times device opened */
+        char name[20];                  /* name of the device type */
+/* per-device flags */
+        __u8 sanyo_slot         : 2;    /* Sanyo 3 CD changer support */
+        __u8 reserved           : 6;    /* not used yet */
+        int cdda_method;                /* see flags */
+        __u8 last_sense;
+        __u8 media_written;             /* dirty flag, DVD+RW bookkeeping */
+        unsigned short mmc3_profile;    /* current MMC3 profile */
+        int for_data;
+        int (*exit)(struct cdrom_device_info *);
+        int mrw_mode_page;
+};
+
+struct cdrom_device_ops {
+/* routines */
+        int (*open) (struct cdrom_device_info *, int);
+        void (*release) (struct cdrom_device_info *);
+        int (*drive_status) (struct cdrom_device_info *, int);
+        int (*media_changed) (struct cdrom_device_info *, int);
+        int (*tray_move) (struct cdrom_device_info *, int);
+        int (*lock_door) (struct cdrom_device_info *, int);
+        int (*select_speed) (struct cdrom_device_info *, int);
+        int (*select_disc) (struct cdrom_device_info *, int);
+        int (*get_last_session) (struct cdrom_device_info *,
+                                 struct cdrom_multisession *);
+        int (*get_mcn) (struct cdrom_device_info *,
+                        struct cdrom_mcn *);
+        /* hard reset device */
+        int (*reset) (struct cdrom_device_info *);
+        /* play stuff */
+        int (*audio_ioctl) (struct cdrom_device_info *,unsigned int, void *);
+        /* dev-specific */
+        int (*dev_ioctl) (struct cdrom_device_info *,
+                          unsigned int, unsigned long);
+/* driver specifications */
+        const int capability;   /* capability flags */
+        int n_minors;           /* number of active minor devices */
+        /* handle uniform packets for scsi type devices (scsi,atapi) */
+        int (*generic_packet) (struct cdrom_device_info *,
+                               struct packet_command *);
+};
+
+/* the general block_device operations structure: */
+extern int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip,
+                        struct file *fp);
+extern int cdrom_release(struct cdrom_device_info *cdi, struct file *fp);
+extern int cdrom_ioctl(struct file *file, struct cdrom_device_info *cdi,
+                struct inode *ip, unsigned int cmd, unsigned long arg);
+extern int cdrom_media_changed(struct cdrom_device_info *);
+
+extern int register_cdrom(struct cdrom_device_info *cdi);
+extern int unregister_cdrom(struct cdrom_device_info *cdi);
+
+typedef struct {
+    int data;
+    int audio;
+    int cdi;
+    int xa;
+    long error;
+} tracktype;
+
+extern int cdrom_get_last_written(struct cdrom_device_info *cdi, long *last_written);
+extern int cdrom_number_of_slots(struct cdrom_device_info *cdi);
+extern int cdrom_mode_select(struct cdrom_device_info *cdi,
+                             struct packet_command *cgc);
+extern int cdrom_mode_sense(struct cdrom_device_info *cdi,
+                            struct packet_command *cgc,
+                            int page_code, int page_control);
+extern void init_cdrom_command(struct packet_command *cgc,
+                               void *buffer, int len, int type);
+
+/* The SCSI spec says there could be 256 slots. */
+#define CDROM_MAX_SLOTS 256
+
+struct cdrom_mechstat_header {
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 fault         : 1;
+        __u8 changer_state : 2;
+        __u8 curslot       : 5;
+        __u8 mech_state    : 3;
+        __u8 door_open     : 1;
+        __u8 reserved1     : 4;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 curslot       : 5;
+        __u8 changer_state : 2;
+        __u8 fault         : 1;
+        __u8 reserved1     : 4;
+        __u8 door_open     : 1;
+        __u8 mech_state    : 3;
+#endif
+        __u8     curlba[3];
+        __u8     nslots;
+        __u16 slot_tablelen;
+};
+
+struct cdrom_slot {
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 disc_present : 1;
+        __u8 reserved1    : 6;
+        __u8 change       : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 change       : 1;
+        __u8 reserved1    : 6;
+        __u8 disc_present : 1;
+#endif
+        __u8 reserved2[3];
+};
+
+struct cdrom_changer_info {
+        struct cdrom_mechstat_header hdr;
+        struct cdrom_slot slots[CDROM_MAX_SLOTS];
+};
+
+typedef enum {
+        mechtype_caddy = 0,
+        mechtype_tray  = 1,
+        mechtype_popup = 2,
+        mechtype_individual_changer = 4,
+        mechtype_cartridge_changer  = 5
+} mechtype_t;
+
+typedef struct {
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 ps                 : 1;
+        __u8 reserved1          : 1;
+        __u8 page_code          : 6;
+        __u8 page_length;
+        __u8 reserved2          : 1;
+        __u8 bufe               : 1;
+        __u8 ls_v               : 1;
+        __u8 test_write         : 1;
+        __u8 write_type         : 4;
+        __u8 multi_session      : 2; /* or border, DVD */
+        __u8 fp                 : 1;
+        __u8 copy               : 1;
+        __u8 track_mode         : 4;
+        __u8 reserved3          : 4;
+        __u8 data_block_type    : 4;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 page_code          : 6;
+        __u8 reserved1          : 1;
+        __u8 ps                 : 1;
+        __u8 page_length;
+        __u8 write_type         : 4;
+        __u8 test_write         : 1;
+        __u8 ls_v               : 1;
+        __u8 bufe               : 1;
+        __u8 reserved2          : 1;
+        __u8 track_mode         : 4;
+        __u8 copy               : 1;
+        __u8 fp                 : 1;
+        __u8 multi_session      : 2; /* or border, DVD */
+        __u8 data_block_type    : 4;
+        __u8 reserved3          : 4;
+#endif
+        __u8 link_size;
+        __u8 reserved4;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved5          : 2;
+        __u8 app_code           : 6;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 app_code           : 6;
+        __u8 reserved5          : 2;
+#endif
+        __u8 session_format;
+        __u8 reserved6;
+        __u32 packet_size;
+        __u16 audio_pause;
+        __u8 mcn[16];
+        __u8 isrc[16];
+        __u8 subhdr0;
+        __u8 subhdr1;
+        __u8 subhdr2;
+        __u8 subhdr3;
+} __attribute__((packed)) write_param_page;
+
+struct modesel_head
+{
+        __u8    reserved1;
+        __u8    medium;
+        __u8    reserved2;
+        __u8    block_desc_length;
+        __u8    density;
+        __u8    number_of_blocks_hi;
+        __u8    number_of_blocks_med;
+        __u8    number_of_blocks_lo;
+        __u8    reserved3;
+        __u8    block_length_hi;
+        __u8    block_length_med;
+        __u8    block_length_lo;
+};
+
+typedef struct {
+        __u16 report_key_length;
+        __u8 reserved1;
+        __u8 reserved2;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 type_code                  : 2;
+        __u8 vra                        : 3;
+        __u8 ucca                       : 3;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 ucca                       : 3;
+        __u8 vra                        : 3;
+        __u8 type_code                  : 2;
+#endif
+        __u8 region_mask;
+        __u8 rpc_scheme;
+        __u8 reserved3;
+} rpc_state_t;
+
+struct event_header {
+        __u16 data_len;
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 nea                : 1;
+        __u8 reserved1          : 4;
+        __u8 notification_class : 3;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 notification_class : 3;
+        __u8 reserved1          : 4;
+        __u8 nea                : 1;
+#endif
+        __u8 supp_event_class;
+};
+
+struct media_event_desc {
+#if defined(__BIG_ENDIAN_BITFIELD)
+        __u8 reserved1          : 4;
+        __u8 media_event_code   : 4;
+        __u8 reserved2          : 6;
+        __u8 media_present      : 1;
+        __u8 door_open          : 1;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 media_event_code   : 4;
+        __u8 reserved1          : 4;
+        __u8 door_open          : 1;
+        __u8 media_present      : 1;
+        __u8 reserved2          : 6;
+#endif
+        __u8 start_slot;
+        __u8 end_slot;
+};
+
+extern int cdrom_get_media_event(struct cdrom_device_info *cdi, struct media_event_desc *med);
+
+#endif  /* End of kernel only stuff */ 
+
+#endif  /* _LINUX_CDROM_H */
diff --git a/include/linux/circ_buf.h b/include/linux/circ_buf.h
new file mode 100644
index 000000000000..a2ed0591fb19
--- /dev/null
+++ b/include/linux/circ_buf.h
@@ -0,0 +1,32 @@
+#ifndef _LINUX_CIRC_BUF_H
+#define _LINUX_CIRC_BUF_H 1
+
+struct circ_buf {
+        char *buf;
+        int head;
+        int tail;
+};
+
+/* Return count in buffer.  */
+#define CIRC_CNT(head,tail,size) (((head) - (tail)) & ((size)-1))
+
+/* Return space available, 0..size-1.  We always leave one free char
+   as a completely full buffer has head == tail, which is the same as
+   empty.  */
+#define CIRC_SPACE(head,tail,size) CIRC_CNT((tail),((head)+1),(size))
+
+/* Return count up to the end of the buffer.  Carefully avoid
+   accessing head and tail more than once, so they can change
+   underneath us without returning inconsistent results.  */
+#define CIRC_CNT_TO_END(head,tail,size) \
+        ({int end = (size) - (tail); \
+          int n = ((head) + end) & ((size)-1); \
+          n < end ? n : end;})
+
+/* Return space available up to the end of the buffer.  */
+#define CIRC_SPACE_TO_END(head,tail,size) \
+        ({int end = (size) - 1 - (head); \
+          int n = (end + (tail)) & ((size)-1); \
+          n <= end ? n : end+1;})
+
+#endif /* _LINUX_CIRC_BUF_H  */
diff --git a/include/linux/cobalt-nvram.h b/include/linux/cobalt-nvram.h
new file mode 100644
index 000000000000..ea429562ff36
--- /dev/null
+++ b/include/linux/cobalt-nvram.h
@@ -0,0 +1,109 @@
+/*
+ * $Id: cobalt-nvram.h,v 1.20 2001/10/17 23:16:55 thockin Exp $
+ * cobalt-nvram.h : defines for the various fields in the cobalt NVRAM
+ *
+ * Copyright 2001,2002 Sun Microsystems, Inc.
+ */
+
+#ifndef COBALT_NVRAM_H
+#define COBALT_NVRAM_H
+
+#include <linux/nvram.h>
+
+#define COBT_CMOS_INFO_MAX              0x7f    /* top address allowed */
+#define COBT_CMOS_BIOS_DRIVE_INFO       0x12    /* drive info would go here */
+
+#define COBT_CMOS_CKS_START             NVRAM_OFFSET(0x0e)
+#define COBT_CMOS_CKS_END               NVRAM_OFFSET(0x7f)
+
+/* flag bytes - 16 flags for now, leave room for more */
+#define COBT_CMOS_FLAG_BYTE_0           NVRAM_OFFSET(0x10)
+#define COBT_CMOS_FLAG_BYTE_1           NVRAM_OFFSET(0x11)
+
+/* flags in flag bytes - up to 16 */
+#define COBT_CMOS_FLAG_MIN              0x0001
+#define COBT_CMOS_CONSOLE_FLAG          0x0001 /* console on/off */
+#define COBT_CMOS_DEBUG_FLAG            0x0002 /* ROM debug messages */
+#define COBT_CMOS_AUTO_PROMPT_FLAG      0x0004 /* boot to ROM prompt? */
+#define COBT_CMOS_CLEAN_BOOT_FLAG       0x0008 /* set by a clean shutdown */
+#define COBT_CMOS_HW_NOPROBE_FLAG       0x0010 /* go easy on the probing */
+#define COBT_CMOS_SYSFAULT_FLAG         0x0020 /* system fault detected */
+#define COBT_CMOS_OOPSPANIC_FLAG        0x0040 /* panic on oops */
+#define COBT_CMOS_DELAY_CACHE_FLAG      0x0080 /* delay cache initialization */
+#define COBT_CMOS_NOLOGO_FLAG           0x0100 /* hide "C" logo @ boot */
+#define COBT_CMOS_VERSION_FLAG          0x0200 /* the version field is valid */
+#define COBT_CMOS_FLAG_MAX              0x0200
+
+/* leave byte 0x12 blank - Linux looks for drive info here */
+
+/* CMOS structure version, valid if COBT_CMOS_VERSION_FLAG is true */
+#define COBT_CMOS_VERSION               NVRAM_OFFSET(0x13)
+#define COBT_CMOS_VER_BTOCODE           1 /* min. version needed for btocode */
+
+/* index of default boot method */
+#define COBT_CMOS_BOOT_METHOD           NVRAM_OFFSET(0x20)
+#define COBT_CMOS_BOOT_METHOD_DISK      0
+#define COBT_CMOS_BOOT_METHOD_ROM       1
+#define COBT_CMOS_BOOT_METHOD_NET       2
+
+#define COBT_CMOS_BOOT_DEV_MIN          NVRAM_OFFSET(0x21)
+/* major #, minor # of first through fourth boot device */
+#define COBT_CMOS_BOOT_DEV0_MAJ         NVRAM_OFFSET(0x21)
+#define COBT_CMOS_BOOT_DEV0_MIN         NVRAM_OFFSET(0x22)
+#define COBT_CMOS_BOOT_DEV1_MAJ         NVRAM_OFFSET(0x23)
+#define COBT_CMOS_BOOT_DEV1_MIN         NVRAM_OFFSET(0x24)
+#define COBT_CMOS_BOOT_DEV2_MAJ         NVRAM_OFFSET(0x25)
+#define COBT_CMOS_BOOT_DEV2_MIN         NVRAM_OFFSET(0x26)
+#define COBT_CMOS_BOOT_DEV3_MAJ         NVRAM_OFFSET(0x27)
+#define COBT_CMOS_BOOT_DEV3_MIN         NVRAM_OFFSET(0x28)
+#define COBT_CMOS_BOOT_DEV_MAX          NVRAM_OFFSET(0x28)
+
+/* checksum of bytes 0xe-0x7f */
+#define COBT_CMOS_CHECKSUM              NVRAM_OFFSET(0x2e)
+
+/* running uptime counter, units of 5 minutes (32 bits =~ 41000 years) */
+#define COBT_CMOS_UPTIME_0              NVRAM_OFFSET(0x30)
+#define COBT_CMOS_UPTIME_1              NVRAM_OFFSET(0x31)
+#define COBT_CMOS_UPTIME_2              NVRAM_OFFSET(0x32)
+#define COBT_CMOS_UPTIME_3              NVRAM_OFFSET(0x33)
+
+/* count of successful boots (32 bits) */
+#define COBT_CMOS_BOOTCOUNT_0           NVRAM_OFFSET(0x38)
+#define COBT_CMOS_BOOTCOUNT_1           NVRAM_OFFSET(0x39)
+#define COBT_CMOS_BOOTCOUNT_2           NVRAM_OFFSET(0x3a)
+#define COBT_CMOS_BOOTCOUNT_3           NVRAM_OFFSET(0x3b)
+
+/* 13 bytes: system serial number, same as on the back of the system */
+#define COBT_CMOS_SYS_SERNUM_LEN        13
+#define COBT_CMOS_SYS_SERNUM_0          NVRAM_OFFSET(0x40)
+#define COBT_CMOS_SYS_SERNUM_1          NVRAM_OFFSET(0x41)
+#define COBT_CMOS_SYS_SERNUM_2          NVRAM_OFFSET(0x42)
+#define COBT_CMOS_SYS_SERNUM_3          NVRAM_OFFSET(0x43)
+#define COBT_CMOS_SYS_SERNUM_4          NVRAM_OFFSET(0x44)
+#define COBT_CMOS_SYS_SERNUM_5          NVRAM_OFFSET(0x45)
+#define COBT_CMOS_SYS_SERNUM_6          NVRAM_OFFSET(0x46)
+#define COBT_CMOS_SYS_SERNUM_7          NVRAM_OFFSET(0x47)
+#define COBT_CMOS_SYS_SERNUM_8          NVRAM_OFFSET(0x48)
+#define COBT_CMOS_SYS_SERNUM_9          NVRAM_OFFSET(0x49)
+#define COBT_CMOS_SYS_SERNUM_10         NVRAM_OFFSET(0x4a)
+#define COBT_CMOS_SYS_SERNUM_11         NVRAM_OFFSET(0x4b)
+#define COBT_CMOS_SYS_SERNUM_12         NVRAM_OFFSET(0x4c)
+/* checksum for serial num - 1 byte */
+#define COBT_CMOS_SYS_SERNUM_CSUM       NVRAM_OFFSET(0x4f)
+
+#define COBT_CMOS_ROM_REV_MAJ           NVRAM_OFFSET(0x50)
+#define COBT_CMOS_ROM_REV_MIN           NVRAM_OFFSET(0x51)
+#define COBT_CMOS_ROM_REV_REV           NVRAM_OFFSET(0x52)
+
+#define COBT_CMOS_BTO_CODE_0            NVRAM_OFFSET(0x53)
+#define COBT_CMOS_BTO_CODE_1            NVRAM_OFFSET(0x54)
+#define COBT_CMOS_BTO_CODE_2            NVRAM_OFFSET(0x55)
+#define COBT_CMOS_BTO_CODE_3            NVRAM_OFFSET(0x56)
+
+#define COBT_CMOS_BTO_IP_CSUM           NVRAM_OFFSET(0x57)
+#define COBT_CMOS_BTO_IP_0              NVRAM_OFFSET(0x58)
+#define COBT_CMOS_BTO_IP_1              NVRAM_OFFSET(0x59)
+#define COBT_CMOS_BTO_IP_2              NVRAM_OFFSET(0x5a)
+#define COBT_CMOS_BTO_IP_3              NVRAM_OFFSET(0x5b)
+
+#endif /* COBALT_NVRAM_H */
diff --git a/include/linux/coda.h b/include/linux/coda.h
new file mode 100644
index 000000000000..bbc5afcd7db6
--- /dev/null
+++ b/include/linux/coda.h
@@ -0,0 +1,788 @@
+/* 
+   You may distribute this file under either of the two licenses that
+   follow at your discretion.
+*/
+
+/* BLURB lgpl
+
+                           Coda File System
+                              Release 5
+
+          Copyright (c) 1987-1999 Carnegie Mellon University
+                  Additional copyrights listed below
+
+This code is distributed "AS IS" without warranty of any kind under
+the terms of the GNU Library General Public Licence Version 2, as
+shown in the file LICENSE, or under the license shown below. The
+technical and financial contributors to Coda are listed in the file
+CREDITS.
+
+                        Additional copyrights 
+*/
+
+/*
+
+            Coda: an Experimental Distributed File System
+                             Release 4.0
+
+          Copyright (c) 1987-1999 Carnegie Mellon University
+                         All Rights Reserved
+
+Permission  to  use, copy, modify and distribute this software and its
+documentation is hereby granted,  provided  that  both  the  copyright
+notice  and  this  permission  notice  appear  in  all  copies  of the
+software, derivative works or  modified  versions,  and  any  portions
+thereof, and that both notices appear in supporting documentation, and
+that credit is given to Carnegie Mellon University  in  all  documents
+and publicity pertaining to direct or indirect use of this code or its
+derivatives.
+
+CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS  KNOWN  TO  HAVE  BUGS,
+SOME  OF  WHICH MAY HAVE SERIOUS CONSEQUENCES.  CARNEGIE MELLON ALLOWS
+FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.   CARNEGIE  MELLON
+DISCLAIMS  ANY  LIABILITY  OF  ANY  KIND  FOR  ANY  DAMAGES WHATSOEVER
+RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE  OR  OF
+ANY DERIVATIVE WORK.
+
+Carnegie  Mellon  encourages  users  of  this  software  to return any
+improvements or extensions that  they  make,  and  to  grant  Carnegie
+Mellon the rights to redistribute these changes without encumbrance.
+*/
+
+/*
+ *
+ * Based on cfs.h from Mach, but revamped for increased simplicity.
+ * Linux modifications by 
+ * Peter Braam, Aug 1996
+ */
+
+#ifndef _CODA_HEADER_
+#define _CODA_HEADER_
+
+#include <linux/config.h>
+
+/* Catch new _KERNEL defn for NetBSD and DJGPP/__CYGWIN32__ */
+#if defined(__NetBSD__) || \
+  ((defined(DJGPP) || defined(__CYGWIN32__)) && !defined(KERNEL))
+#include <sys/types.h>
+#endif 
+
+#ifndef CODA_MAXSYMLINKS
+#define CODA_MAXSYMLINKS 10
+#endif
+
+#if defined(DJGPP) || defined(__CYGWIN32__)
+#ifdef KERNEL
+typedef unsigned long u_long;
+typedef unsigned int u_int;
+typedef unsigned short u_short;
+typedef u_long ino_t;
+typedef u_long dev_t;
+typedef void * caddr_t;
+#ifdef DOS
+typedef unsigned __int64 u_quad_t;
+#else 
+typedef unsigned long long u_quad_t;
+#endif
+
+#define inline
+
+struct timespec {
+        long       ts_sec;
+        long       ts_nsec;
+};
+#else  /* DJGPP but not KERNEL */
+#include <sys/time.h>
+typedef unsigned long long u_quad_t;
+#endif /* !KERNEL */
+#endif /* !DJGPP */
+
+
+#if defined(__linux__)
+#include <linux/time.h>
+#define cdev_t u_quad_t
+#ifndef __KERNEL__
+#if !defined(_UQUAD_T_) && (!defined(__GLIBC__) || __GLIBC__ < 2)
+#define _UQUAD_T_ 1
+typedef unsigned long long u_quad_t;
+#endif
+#else /*__KERNEL__ */
+typedef unsigned long long u_quad_t;
+#endif /* __KERNEL__ */
+#else
+#define cdev_t dev_t
+#endif
+
+#ifdef __CYGWIN32__
+struct timespec {
+        time_t  tv_sec;         /* seconds */
+        long    tv_nsec;        /* nanoseconds */
+};
+#endif
+
+#ifndef __BIT_TYPES_DEFINED__
+#define __BIT_TYPES_DEFINED__
+typedef signed char           int8_t;
+typedef unsigned char       u_int8_t;
+typedef short                int16_t;
+typedef unsigned short     u_int16_t;
+typedef int                  int32_t;
+typedef unsigned int       u_int32_t;
+#endif
+
+
+/*
+ * Cfs constants
+ */
+#define CODA_MAXNAMLEN   255
+#define CODA_MAXPATHLEN  1024
+#define CODA_MAXSYMLINK  10
+
+/* these are Coda's version of O_RDONLY etc combinations
+ * to deal with VFS open modes
+ */
+#define C_O_READ        0x001
+#define C_O_WRITE       0x002
+#define C_O_TRUNC       0x010
+#define C_O_EXCL        0x100
+#define C_O_CREAT       0x200
+
+/* these are to find mode bits in Venus */ 
+#define C_M_READ  00400
+#define C_M_WRITE 00200
+
+/* for access Venus will use */
+#define C_A_C_OK    8               /* Test for writing upon create.  */
+#define C_A_R_OK    4               /* Test for read permission.  */
+#define C_A_W_OK    2               /* Test for write permission.  */
+#define C_A_X_OK    1               /* Test for execute permission.  */
+#define C_A_F_OK    0               /* Test for existence.  */
+
+
+
+#ifndef _VENUS_DIRENT_T_
+#define _VENUS_DIRENT_T_ 1
+struct venus_dirent {
+        u_int32_t d_fileno;             /* file number of entry */
+        u_int16_t d_reclen;             /* length of this record */
+        u_int8_t  d_type;                       /* file type, see below */
+        u_int8_t  d_namlen;             /* length of string in d_name */
+        char      d_name[CODA_MAXNAMLEN + 1];/* name must be no longer than this */
+};
+#undef DIRSIZ
+#define DIRSIZ(dp)      ((sizeof (struct venus_dirent) - (CODA_MAXNAMLEN+1)) + \
+                         (((dp)->d_namlen+1 + 3) &~ 3))
+
+/*
+ * File types
+ */
+#define CDT_UNKNOWN      0
+#define CDT_FIFO         1
+#define CDT_CHR          2
+#define CDT_DIR          4
+#define CDT_BLK          6
+#define CDT_REG          8
+#define CDT_LNK         10
+#define CDT_SOCK        12
+#define CDT_WHT         14
+
+/*
+ * Convert between stat structure types and directory types.
+ */
+#define IFTOCDT(mode)   (((mode) & 0170000) >> 12)
+#define CDTTOIF(dirtype)        ((dirtype) << 12)
+
+#endif
+
+#ifndef _VUID_T_
+#define _VUID_T_
+typedef u_int32_t vuid_t;
+typedef u_int32_t vgid_t;
+#endif /*_VUID_T_ */
+
+#ifdef CONFIG_CODA_FS_OLD_API
+struct CodaFid {
+        u_int32_t opaque[3];
+};
+
+static __inline__ ino_t  coda_f2i(struct CodaFid *fid)
+{
+        if ( ! fid ) 
+                return 0; 
+        if (fid->opaque[1] == 0xfffffffe || fid->opaque[1] == 0xffffffff)
+                return ((fid->opaque[0] << 20) | (fid->opaque[2] & 0xfffff));
+        else
+                return (fid->opaque[2] + (fid->opaque[1]<<10) + (fid->opaque[0]<<20));
+}
+
+struct coda_cred {
+    vuid_t cr_uid, cr_euid, cr_suid, cr_fsuid; /* Real, efftve, set, fs uid*/
+    vgid_t cr_groupid, cr_egid, cr_sgid, cr_fsgid; /* same for groups */
+};
+
+#else /* not defined(CONFIG_CODA_FS_OLD_API) */
+
+struct CodaFid {
+        u_int32_t opaque[4];
+};
+
+#define coda_f2i(fid)\
+        (fid ? (fid->opaque[3] ^ (fid->opaque[2]<<10) ^ (fid->opaque[1]<<20) ^ fid->opaque[0]) : 0)
+
+#endif
+
+#ifndef _VENUS_VATTR_T_
+#define _VENUS_VATTR_T_
+/*
+ * Vnode types.  VNON means no type.
+ */
+enum coda_vtype { C_VNON, C_VREG, C_VDIR, C_VBLK, C_VCHR, C_VLNK, C_VSOCK, C_VFIFO, C_VBAD };
+
+struct coda_vattr {
+        long            va_type;        /* vnode type (for create) */
+        u_short         va_mode;        /* files access mode and type */
+        short           va_nlink;       /* number of references to file */
+        vuid_t          va_uid;         /* owner user id */
+        vgid_t          va_gid;         /* owner group id */
+        long            va_fileid;      /* file id */
+        u_quad_t        va_size;        /* file size in bytes */
+        long            va_blocksize;   /* blocksize preferred for i/o */
+        struct timespec va_atime;       /* time of last access */
+        struct timespec va_mtime;       /* time of last modification */
+        struct timespec va_ctime;       /* time file changed */
+        u_long          va_gen;         /* generation number of file */
+        u_long          va_flags;       /* flags defined for file */
+        cdev_t          va_rdev;        /* device special file represents */
+        u_quad_t        va_bytes;       /* bytes of disk space held by file */
+        u_quad_t        va_filerev;     /* file modification number */
+};
+
+#endif 
+
+/* structure used by CODA_STATFS for getting cache information from venus */
+struct coda_statfs {
+    int32_t f_blocks;
+    int32_t f_bfree;
+    int32_t f_bavail;
+    int32_t f_files;
+    int32_t f_ffree;
+};
+
+/*
+ * Kernel <--> Venus communications.
+ */
+
+#define CODA_ROOT       2
+#define CODA_OPEN_BY_FD 3
+#define CODA_OPEN       4
+#define CODA_CLOSE      5
+#define CODA_IOCTL      6
+#define CODA_GETATTR    7
+#define CODA_SETATTR    8
+#define CODA_ACCESS     9
+#define CODA_LOOKUP     10
+#define CODA_CREATE     11
+#define CODA_REMOVE     12
+#define CODA_LINK       13
+#define CODA_RENAME     14
+#define CODA_MKDIR      15
+#define CODA_RMDIR      16
+#define CODA_SYMLINK    18
+#define CODA_READLINK   19
+#define CODA_FSYNC      20
+#define CODA_VGET       22
+#define CODA_SIGNAL     23
+#define CODA_REPLACE     24 /* DOWNCALL */
+#define CODA_FLUSH       25 /* DOWNCALL */
+#define CODA_PURGEUSER   26 /* DOWNCALL */
+#define CODA_ZAPFILE     27 /* DOWNCALL */
+#define CODA_ZAPDIR      28 /* DOWNCALL */
+#define CODA_PURGEFID    30 /* DOWNCALL */
+#define CODA_OPEN_BY_PATH 31
+#define CODA_RESOLVE     32
+#define CODA_REINTEGRATE 33
+#define CODA_STATFS      34
+#define CODA_STORE       35
+#define CODA_RELEASE     36
+#define CODA_NCALLS 37
+
+#define DOWNCALL(opcode) (opcode >= CODA_REPLACE && opcode <= CODA_PURGEFID)
+
+#define VC_MAXDATASIZE      8192
+#define VC_MAXMSGSIZE      sizeof(union inputArgs)+sizeof(union outputArgs) +\
+                            VC_MAXDATASIZE  
+
+#define CIOC_KERNEL_VERSION _IOWR('c', 10, size_t)
+
+#if 0
+#define CODA_KERNEL_VERSION 0 /* don't care about kernel version number */
+#define CODA_KERNEL_VERSION 1 /* The old venus 4.6 compatible interface */
+#endif
+#ifdef CONFIG_CODA_FS_OLD_API
+#define CODA_KERNEL_VERSION 2 /* venus_lookup got an extra parameter */
+#else
+#define CODA_KERNEL_VERSION 3 /* 128-bit file identifiers */
+#endif
+
+/*
+ *        Venus <-> Coda  RPC arguments
+ */
+struct coda_in_hdr {
+    u_int32_t opcode;
+    u_int32_t unique;       /* Keep multiple outstanding msgs distinct */
+#ifdef CONFIG_CODA_FS_OLD_API
+    u_int16_t pid;          /* Common to all */
+    u_int16_t pgid;         /* Common to all */
+    u_int16_t sid;          /* Common to all */
+    struct coda_cred cred;  /* Common to all */
+#else
+    pid_t pid;
+    pid_t pgid;
+    vuid_t uid;
+#endif
+};
+
+/* Really important that opcode and unique are 1st two fields! */
+struct coda_out_hdr {
+    u_int32_t opcode;
+    u_int32_t unique;   
+    u_int32_t result;
+};
+
+/* coda_root: NO_IN */
+struct coda_root_out {
+    struct coda_out_hdr oh;
+    struct CodaFid VFid;
+};
+
+struct coda_root_in {
+    struct coda_in_hdr in;
+};
+
+/* coda_open: */
+struct coda_open_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_open_out {
+    struct coda_out_hdr oh;
+    cdev_t      dev;
+    ino_t       inode;
+};
+
+
+/* coda_store: */
+struct coda_store_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_store_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_release: */
+struct coda_release_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_release_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_close: */
+struct coda_close_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_close_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_ioctl: */
+struct coda_ioctl_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int cmd;
+    int len;
+    int rwflag;
+    char *data;                 /* Place holder for data. */
+};
+
+struct coda_ioctl_out {
+    struct coda_out_hdr oh;
+    int len;
+    caddr_t     data;           /* Place holder for data. */
+};
+
+
+/* coda_getattr: */
+struct coda_getattr_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+};
+
+struct coda_getattr_out {
+    struct coda_out_hdr oh;
+    struct coda_vattr attr;
+};
+
+
+/* coda_setattr: NO_OUT */
+struct coda_setattr_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    struct coda_vattr attr;
+};
+
+struct coda_setattr_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_access: NO_OUT */
+struct coda_access_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_access_out {
+    struct coda_out_hdr out;
+};
+
+
+/* lookup flags */
+#define CLU_CASE_SENSITIVE     0x01
+#define CLU_CASE_INSENSITIVE   0x02
+
+/* coda_lookup: */
+struct  coda_lookup_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int         name;           /* Place holder for data. */
+    int         flags;  
+};
+
+struct coda_lookup_out {
+    struct coda_out_hdr oh;
+    struct CodaFid VFid;
+    int vtype;
+};
+
+
+/* coda_create: */
+struct coda_create_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    struct coda_vattr attr;
+    int excl;
+    int mode;
+    int         name;           /* Place holder for data. */
+};
+
+struct coda_create_out {
+    struct coda_out_hdr oh;
+    struct CodaFid VFid;
+    struct coda_vattr attr;
+};
+
+
+/* coda_remove: NO_OUT */
+struct coda_remove_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int name;           /* Place holder for data. */
+};
+
+struct coda_remove_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_link: NO_OUT */
+struct coda_link_in {
+    struct coda_in_hdr ih;
+    struct CodaFid sourceFid;   /* cnode to link *to* */
+    struct CodaFid destFid;     /* Directory in which to place link */
+    int tname;          /* Place holder for data. */
+};
+
+struct coda_link_out {
+    struct coda_out_hdr out;
+};
+
+
+/* coda_rename: NO_OUT */
+struct coda_rename_in {
+    struct coda_in_hdr ih;
+    struct CodaFid sourceFid;
+    int         srcname;
+    struct CodaFid destFid;
+    int         destname;
+};
+
+struct coda_rename_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_mkdir: */
+struct coda_mkdir_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    struct coda_vattr attr;
+    int    name;                /* Place holder for data. */
+};
+
+struct coda_mkdir_out {
+    struct coda_out_hdr oh;
+    struct CodaFid VFid;
+    struct coda_vattr attr;
+};
+
+
+/* coda_rmdir: NO_OUT */
+struct coda_rmdir_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int name;           /* Place holder for data. */
+};
+
+struct coda_rmdir_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_symlink: NO_OUT */
+struct coda_symlink_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;        /* Directory to put symlink in */
+    int srcname;
+    struct coda_vattr attr;
+    int tname;
+};
+
+struct coda_symlink_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_readlink: */
+struct coda_readlink_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+};
+
+struct coda_readlink_out {
+    struct coda_out_hdr oh;
+    int count;
+    caddr_t     data;           /* Place holder for data. */
+};
+
+
+/* coda_fsync: NO_OUT */
+struct coda_fsync_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+};
+
+struct coda_fsync_out {
+    struct coda_out_hdr out;
+};
+
+/* coda_vget: */
+struct coda_vget_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+};
+
+struct coda_vget_out {
+    struct coda_out_hdr oh;
+    struct CodaFid VFid;
+    int vtype;
+};
+
+
+/* CODA_SIGNAL is out-of-band, doesn't need data. */
+/* CODA_INVALIDATE is a venus->kernel call */
+/* CODA_FLUSH is a venus->kernel call */
+
+/* coda_purgeuser: */
+/* CODA_PURGEUSER is a venus->kernel call */
+struct coda_purgeuser_out {
+    struct coda_out_hdr oh;
+#ifdef CONFIG_CODA_FS_OLD_API
+    struct coda_cred cred;
+#else
+    vuid_t uid;
+#endif
+};
+
+/* coda_zapfile: */
+/* CODA_ZAPFILE is a venus->kernel call */
+struct coda_zapfile_out {  
+    struct coda_out_hdr oh;
+    struct CodaFid CodaFid;
+};
+
+/* coda_zapdir: */
+/* CODA_ZAPDIR is a venus->kernel call */       
+struct coda_zapdir_out {          
+    struct coda_out_hdr oh;
+    struct CodaFid CodaFid;
+};
+
+/* coda_purgefid: */
+/* CODA_PURGEFID is a venus->kernel call */     
+struct coda_purgefid_out { 
+    struct coda_out_hdr oh;
+    struct CodaFid CodaFid;
+};
+
+/* coda_replace: */
+/* CODA_REPLACE is a venus->kernel call */      
+struct coda_replace_out { /* coda_replace is a venus->kernel call */
+    struct coda_out_hdr oh;
+    struct CodaFid NewFid;
+    struct CodaFid OldFid;
+};
+
+/* coda_open_by_fd: */
+struct coda_open_by_fd_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int        flags;
+};
+
+struct coda_open_by_fd_out {
+    struct coda_out_hdr oh;
+    int fd;
+
+#ifdef __KERNEL__
+    struct file *fh; /* not passed from userspace but used in-kernel only */
+#endif
+};
+
+/* coda_open_by_path: */
+struct coda_open_by_path_in {
+    struct coda_in_hdr ih;
+    struct CodaFid VFid;
+    int flags;
+};
+
+struct coda_open_by_path_out {
+    struct coda_out_hdr oh;
+        int path;
+};
+
+/* coda_statfs: NO_IN */
+struct coda_statfs_in {
+    struct coda_in_hdr in;
+};
+
+struct coda_statfs_out {
+    struct coda_out_hdr oh;
+    struct coda_statfs stat;
+};
+
+/* 
+ * Occasionally, we don't cache the fid returned by CODA_LOOKUP. 
+ * For instance, if the fid is inconsistent. 
+ * This case is handled by setting the top bit of the type result parameter.
+ */
+#define CODA_NOCACHE          0x80000000
+
+union inputArgs {
+    struct coda_in_hdr ih;              /* NB: every struct below begins with an ih */
+    struct coda_open_in coda_open;
+    struct coda_store_in coda_store;
+    struct coda_release_in coda_release;
+    struct coda_close_in coda_close;
+    struct coda_ioctl_in coda_ioctl;
+    struct coda_getattr_in coda_getattr;
+    struct coda_setattr_in coda_setattr;
+    struct coda_access_in coda_access;
+    struct coda_lookup_in coda_lookup;
+    struct coda_create_in coda_create;
+    struct coda_remove_in coda_remove;
+    struct coda_link_in coda_link;
+    struct coda_rename_in coda_rename;
+    struct coda_mkdir_in coda_mkdir;
+    struct coda_rmdir_in coda_rmdir;
+    struct coda_symlink_in coda_symlink;
+    struct coda_readlink_in coda_readlink;
+    struct coda_fsync_in coda_fsync;
+    struct coda_vget_in coda_vget;
+    struct coda_open_by_fd_in coda_open_by_fd;
+    struct coda_open_by_path_in coda_open_by_path;
+    struct coda_statfs_in coda_statfs;
+};
+
+union outputArgs {
+    struct coda_out_hdr oh;             /* NB: every struct below begins with an oh */
+    struct coda_root_out coda_root;
+    struct coda_open_out coda_open;
+    struct coda_ioctl_out coda_ioctl;
+    struct coda_getattr_out coda_getattr;
+    struct coda_lookup_out coda_lookup;
+    struct coda_create_out coda_create;
+    struct coda_mkdir_out coda_mkdir;
+    struct coda_readlink_out coda_readlink;
+    struct coda_vget_out coda_vget;
+    struct coda_purgeuser_out coda_purgeuser;
+    struct coda_zapfile_out coda_zapfile;
+    struct coda_zapdir_out coda_zapdir;
+    struct coda_purgefid_out coda_purgefid;
+    struct coda_replace_out coda_replace;
+    struct coda_open_by_fd_out coda_open_by_fd;
+    struct coda_open_by_path_out coda_open_by_path;
+    struct coda_statfs_out coda_statfs;
+};    
+
+union coda_downcalls {
+    /* CODA_INVALIDATE is a venus->kernel call */
+    /* CODA_FLUSH is a venus->kernel call */
+    struct coda_purgeuser_out purgeuser;
+    struct coda_zapfile_out zapfile;
+    struct coda_zapdir_out zapdir;
+    struct coda_purgefid_out purgefid;
+    struct coda_replace_out replace;
+};
+
+
+/*
+ * Used for identifying usage of "Control" and pioctls
+ */
+
+#define PIOCPARM_MASK 0x0000ffff
+struct ViceIoctl {
+        void __user *in;        /* Data to be transferred in */
+        void __user *out;       /* Data to be transferred out */
+        u_short in_size;        /* Size of input buffer <= 2K */
+        u_short out_size;       /* Maximum size of output buffer, <= 2K */
+};
+
+struct PioctlData {
+        const char __user *path;
+        int follow;
+        struct ViceIoctl vi;
+};
+
+#define CODA_CONTROL            ".CONTROL"
+#define CODA_CONTROLLEN         8
+#define CTL_INO                 -1
+
+/* Data passed to mount */
+
+#define CODA_MOUNT_VERSION 1
+
+struct coda_mount_data {
+        int             version;
+        int             fd;       /* Opened device */
+};
+
+#endif 
+
diff --git a/include/linux/coda_cache.h b/include/linux/coda_cache.h
new file mode 100644
index 000000000000..c910b5eb1ceb
--- /dev/null
+++ b/include/linux/coda_cache.h
@@ -0,0 +1,22 @@
+/* Coda filesystem -- Linux Minicache
+ *
+ * Copyright (C) 1989 - 1997 Carnegie Mellon University
+ *
+ * Carnegie Mellon University encourages users of this software to
+ * contribute improvements to the Coda project. Contact Peter Braam
+ * <coda@cs.cmu.edu>
+ */
+
+#ifndef _CFSNC_HEADER_
+#define _CFSNC_HEADER_
+
+/* credential cache */
+void coda_cache_enter(struct inode *inode, int mask);
+void coda_cache_clear_inode(struct inode *);
+void coda_cache_clear_all(struct super_block *sb);
+int coda_cache_check(struct inode *inode, int mask);
+
+/* for downcalls and attributes and lookups */
+void coda_flag_inode_children(struct inode *inode, int flag);
+
+#endif /* _CFSNC_HEADER_ */
diff --git a/include/linux/coda_fs_i.h b/include/linux/coda_fs_i.h
new file mode 100644
index 000000000000..424fe9cf02c4
--- /dev/null
+++ b/include/linux/coda_fs_i.h
@@ -0,0 +1,55 @@
+/*
+ *  coda_fs_i.h
+ *
+ *  Copyright (C) 1998 Carnegie Mellon University
+ *
+ */
+
+#ifndef _LINUX_CODA_FS_I
+#define _LINUX_CODA_FS_I
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/coda.h>
+
+/*
+ * coda fs inode data
+ */
+struct coda_inode_info {
+        struct CodaFid     c_fid;       /* Coda identifier */
+        u_short            c_flags;     /* flags (see below) */
+        struct list_head   c_cilist;    /* list of all coda inodes */
+        unsigned int       c_mapcount;  /* nr of times this inode is mapped */
+        unsigned int       c_cached_epoch; /* epoch for cached permissions */
+        vuid_t             c_uid;       /* fsuid for cached permissions */
+        unsigned int       c_cached_perm; /* cached access permissions */
+        struct inode       vfs_inode;
+};
+
+/*
+ * coda fs file private data
+ */
+#define CODA_MAGIC 0xC0DAC0DA
+struct coda_file_info {
+        int                cfi_magic;     /* magic number */
+        struct file       *cfi_container; /* container file for this cnode */
+        unsigned int       cfi_mapcount;  /* nr of times this file is mapped */
+};
+
+#define CODA_FTOC(file) ((struct coda_file_info *)((file)->private_data))
+
+/* flags */
+#define C_VATTR       0x1   /* Validity of vattr in inode */
+#define C_FLUSH       0x2   /* used after a flush */
+#define C_DYING       0x4   /* from venus (which died) */
+#define C_PURGE       0x8
+
+int coda_cnode_make(struct inode **, struct CodaFid *, struct super_block *);
+struct inode *coda_iget(struct super_block *sb, struct CodaFid *fid, struct coda_vattr *attr);
+int coda_cnode_makectl(struct inode **inode, struct super_block *sb);
+struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb);
+void coda_replace_fid(struct inode *, struct CodaFid *, struct CodaFid *);
+
+#endif
+#endif
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
new file mode 100644
index 000000000000..cc621ec409d8
--- /dev/null
+++ b/include/linux/coda_linux.h
@@ -0,0 +1,102 @@
+/* 
+ * Coda File System, Linux Kernel module
+ * 
+ * Original version, adapted from cfs_mach.c, (C) Carnegie Mellon University
+ * Linux modifications (C) 1996, Peter J. Braam
+ * Rewritten for Linux 2.1 (C) 1997 Carnegie Mellon University
+ *
+ * Carnegie Mellon University encourages users of this software to
+ * contribute improvements to the Coda project.
+ */
+
+#ifndef _LINUX_CODA_FS
+#define _LINUX_CODA_FS
+
+#include <linux/kernel.h>
+#include <linux/param.h>
+#include <linux/mm.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/wait.h>         
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/coda_fs_i.h>
+
+/* operations */
+extern struct inode_operations coda_dir_inode_operations;
+extern struct inode_operations coda_file_inode_operations;
+extern struct inode_operations coda_ioctl_inode_operations;
+
+extern struct address_space_operations coda_file_aops;
+extern struct address_space_operations coda_symlink_aops;
+
+extern struct file_operations coda_dir_operations;
+extern struct file_operations coda_file_operations;
+extern struct file_operations coda_ioctl_operations;
+
+/* operations shared over more than one file */
+int coda_open(struct inode *i, struct file *f);
+int coda_flush(struct file *f);
+int coda_release(struct inode *i, struct file *f);
+int coda_permission(struct inode *inode, int mask, struct nameidata *nd);
+int coda_revalidate_inode(struct dentry *);
+int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+int coda_setattr(struct dentry *, struct iattr *);
+
+/* global variables */
+extern int coda_fake_statfs;
+
+/* this file:  heloers */
+static __inline__ struct CodaFid *coda_i2f(struct inode *);
+static __inline__ char *coda_i2s(struct inode *);
+static __inline__ void coda_flag_inode(struct inode *, int flag);
+char *coda_f2s(struct CodaFid *f);
+int coda_isroot(struct inode *i);
+int coda_iscontrol(const char *name, size_t length);
+
+void coda_vattr_to_iattr(struct inode *, struct coda_vattr *);
+void coda_iattr_to_vattr(struct iattr *, struct coda_vattr *);
+unsigned short coda_flags_to_cflags(unsigned short);
+
+/* sysctl.h */
+void coda_sysctl_init(void);
+void coda_sysctl_clean(void);
+
+#define CODA_ALLOC(ptr, cast, size) do { \
+    if (size < PAGE_SIZE) \
+        ptr = (cast)kmalloc((unsigned long) size, GFP_KERNEL); \
+    else \
+        ptr = (cast)vmalloc((unsigned long) size); \
+    if (!ptr) \
+        printk("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
+    else memset( ptr, 0, size ); \
+} while (0)
+
+
+#define CODA_FREE(ptr,size) \
+    do { if (size < PAGE_SIZE) kfree((ptr)); else vfree((ptr)); } while (0)
+
+/* inode to cnode access functions */
+
+static inline struct coda_inode_info *ITOC(struct inode *inode)
+{
+        return list_entry(inode, struct coda_inode_info, vfs_inode);
+}
+
+static __inline__ struct CodaFid *coda_i2f(struct inode *inode)
+{
+        return &(ITOC(inode)->c_fid);
+}
+
+static __inline__ char *coda_i2s(struct inode *inode)
+{
+        return coda_f2s(&(ITOC(inode)->c_fid));
+}
+
+/* this will not zap the inode away */
+static __inline__ void coda_flag_inode(struct inode *inode, int flag)
+{
+        ITOC(inode)->c_flags |= flag;
+}               
+
+#endif
diff --git a/include/linux/coda_proc.h b/include/linux/coda_proc.h
new file mode 100644
index 000000000000..0dc1b0458e75
--- /dev/null
+++ b/include/linux/coda_proc.h
@@ -0,0 +1,76 @@
+/*
+ * coda_statis.h
+ * 
+ * CODA operation statistics
+ *
+ * (c) March, 1998
+ * by Michihiro Kuramochi, Zhenyu Xia and Zhanyong Wan
+ * zhanyong.wan@yale.edu
+ *
+ */
+
+#ifndef _CODA_PROC_H
+#define _CODA_PROC_H
+
+void coda_sysctl_init(void);
+void coda_sysctl_clean(void);
+
+#include <linux/sysctl.h>
+#include <linux/coda_fs_i.h>
+#include <linux/coda.h>
+
+/* these four files are presented to show the result of the statistics:
+ *
+ *      /proc/fs/coda/vfs_stats
+ *                    cache_inv_stats
+ *
+ * these four files are presented to reset the statistics to 0:
+ *
+ *      /proc/sys/coda/vfs_stats
+ *                     cache_inv_stats
+ */
+
+/* VFS operation statistics */
+struct coda_vfs_stats 
+{
+        /* file operations */
+        int open;
+        int flush;
+        int release;
+        int fsync;
+
+        /* dir operations */
+        int readdir;
+  
+        /* inode operations */
+        int create;
+        int lookup;
+        int link;
+        int unlink;
+        int symlink;
+        int mkdir;
+        int rmdir;
+        int rename;
+        int permission;
+
+        /* symlink operatoins*/
+        int follow_link;
+        int readlink;
+};
+
+/* cache invalidation statistics */
+struct coda_cache_inv_stats
+{
+        int flush;
+        int purge_user;
+        int zap_dir;
+        int zap_file;
+        int zap_vnode;
+        int purge_fid;
+        int replace;
+};
+
+/* these global variables hold the actual statistics data */
+extern struct coda_vfs_stats            coda_vfs_stat;
+
+#endif /* _CODA_PROC_H */
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
new file mode 100644
index 000000000000..d539262a8f89
--- /dev/null
+++ b/include/linux/coda_psdev.h
@@ -0,0 +1,103 @@
+#ifndef __CODA_PSDEV_H
+#define __CODA_PSDEV_H
+
+#define CODA_PSDEV_MAJOR 67
+#define MAX_CODADEVS  5    /* how many do we allow */
+
+#define CODA_SUPER_MAGIC        0x73757245
+
+struct kstatfs;
+
+struct coda_sb_info
+{
+        struct venus_comm *sbi_vcomm;
+};
+
+/* communication pending/processing queues */
+struct venus_comm {
+        u_long              vc_seq;
+        wait_queue_head_t   vc_waitq; /* Venus wait queue */
+        struct list_head    vc_pending;
+        struct list_head    vc_processing;
+        int                 vc_inuse;
+        struct super_block *vc_sb;
+};
+
+
+static inline struct coda_sb_info *coda_sbp(struct super_block *sb)
+{
+    return ((struct coda_sb_info *)((sb)->s_fs_info));
+}
+
+
+/* upcalls */
+int venus_rootfid(struct super_block *sb, struct CodaFid *fidp);
+int venus_getattr(struct super_block *sb, struct CodaFid *fid,
+                  struct coda_vattr *attr);
+int venus_setattr(struct super_block *, struct CodaFid *, struct coda_vattr *);
+int venus_lookup(struct super_block *sb, struct CodaFid *fid, 
+                 const char *name, int length, int *type, 
+                 struct CodaFid *resfid);
+int venus_store(struct super_block *sb, struct CodaFid *fid, int flags,
+                vuid_t uid);
+int venus_release(struct super_block *sb, struct CodaFid *fid, int flags);
+int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
+                vuid_t uid);
+int venus_open(struct super_block *sb, struct CodaFid *fid, int flags,
+               struct file **f);
+int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid, 
+                const char *name, int length, 
+                struct CodaFid *newfid, struct coda_vattr *attrs);
+int venus_create(struct super_block *sb, struct CodaFid *dirfid, 
+                 const char *name, int length, int excl, int mode,
+                 struct CodaFid *newfid, struct coda_vattr *attrs) ;
+int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid, 
+                const char *name, int length);
+int venus_remove(struct super_block *sb, struct CodaFid *dirfid, 
+                 const char *name, int length);
+int venus_readlink(struct super_block *sb, struct CodaFid *fid, 
+                   char *buffer, int *length);
+int venus_rename(struct super_block *, struct CodaFid *new_fid, 
+                 struct CodaFid *old_fid, size_t old_length, 
+                 size_t new_length, const char *old_name, 
+                 const char *new_name);
+int venus_link(struct super_block *sb, struct CodaFid *fid, 
+                  struct CodaFid *dirfid, const char *name, int len );
+int venus_symlink(struct super_block *sb, struct CodaFid *fid,
+                  const char *name, int len, const char *symname, int symlen);
+int venus_access(struct super_block *sb, struct CodaFid *fid, int mask);
+int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
+                 unsigned int cmd, struct PioctlData *data);
+int coda_downcall(int opcode, union outputArgs *out, struct super_block *sb);
+int venus_fsync(struct super_block *sb, struct CodaFid *fid);
+int venus_statfs(struct super_block *sb, struct kstatfs *sfs);
+
+
+/* messages between coda filesystem in kernel and Venus */
+extern int coda_hard;
+extern unsigned long coda_timeout;
+struct upc_req {
+        struct list_head    uc_chain;
+        caddr_t             uc_data;
+        u_short             uc_flags;
+        u_short             uc_inSize;  /* Size is at most 5000 bytes */
+        u_short             uc_outSize;
+        u_short             uc_opcode;  /* copied from data to save lookup */
+        int                 uc_unique;
+        wait_queue_head_t   uc_sleep;   /* process' wait queue */
+        unsigned long       uc_posttime;
+};
+
+#define REQ_ASYNC  0x1
+#define REQ_READ   0x2
+#define REQ_WRITE  0x4
+#define REQ_ABORT  0x8
+
+
+/*
+ * Statistics
+ */
+
+extern struct venus_comm coda_comms[];
+
+#endif
diff --git a/include/linux/coff.h b/include/linux/coff.h
new file mode 100644
index 000000000000..6354a7fe22b2
--- /dev/null
+++ b/include/linux/coff.h
@@ -0,0 +1,351 @@
+/* This file is derived from the GAS 2.1.4 assembler control file.
+   The GAS product is under the GNU General Public License, version 2 or later.
+   As such, this file is also under that license.
+
+   If the file format changes in the COFF object, this file should be
+   subsequently updated to reflect the changes.
+
+   The actual loader module only uses a few of these structures. The full
+   set is documented here because I received the full set. If you wish
+   more information about COFF, then O'Reilly has a very excellent book.
+*/
+
+#define  E_SYMNMLEN  8   /* Number of characters in a symbol name         */
+#define  E_FILNMLEN 14   /* Number of characters in a file name           */
+#define  E_DIMNUM    4   /* Number of array dimensions in auxiliary entry */
+
+/*
+ * These defines are byte order independent. There is no alignment of fields
+ * permitted in the structures. Therefore they are declared as characters
+ * and the values loaded from the character positions. It also makes it
+ * nice to have it "endian" independent.
+ */
+ 
+/* Load a short int from the following tables with little-endian formats */
+#define COFF_SHORT_L(ps) ((short)(((unsigned short)((unsigned char)ps[1])<<8)|\
+                                  ((unsigned short)((unsigned char)ps[0]))))
+
+/* Load a long int from the following tables with little-endian formats */
+#define COFF_LONG_L(ps) (((long)(((unsigned long)((unsigned char)ps[3])<<24) |\
+                                 ((unsigned long)((unsigned char)ps[2])<<16) |\
+                                 ((unsigned long)((unsigned char)ps[1])<<8)  |\
+                                 ((unsigned long)((unsigned char)ps[0])))))
+ 
+/* Load a short int from the following tables with big-endian formats */
+#define COFF_SHORT_H(ps) ((short)(((unsigned short)((unsigned char)ps[0])<<8)|\
+                                  ((unsigned short)((unsigned char)ps[1]))))
+
+/* Load a long int from the following tables with big-endian formats */
+#define COFF_LONG_H(ps) (((long)(((unsigned long)((unsigned char)ps[0])<<24) |\
+                                 ((unsigned long)((unsigned char)ps[1])<<16) |\
+                                 ((unsigned long)((unsigned char)ps[2])<<8)  |\
+                                 ((unsigned long)((unsigned char)ps[3])))))
+
+/* These may be overridden later by brain dead implementations which generate
+   a big-endian header with little-endian data. In that case, generate a
+   replacement macro which tests a flag and uses either of the two above
+   as appropriate. */
+
+#define COFF_LONG(v)   COFF_LONG_L(v)
+#define COFF_SHORT(v)  COFF_SHORT_L(v)
+
+/*** coff information for Intel 386/486.  */
+
+/********************** FILE HEADER **********************/
+
+struct COFF_filehdr {
+        char f_magic[2];        /* magic number                 */
+        char f_nscns[2];        /* number of sections           */
+        char f_timdat[4];       /* time & date stamp            */
+        char f_symptr[4];       /* file pointer to symtab       */
+        char f_nsyms[4];        /* number of symtab entries     */
+        char f_opthdr[2];       /* sizeof(optional hdr)         */
+        char f_flags[2];        /* flags                        */
+};
+
+/*
+ *   Bits for f_flags:
+ *
+ *      F_RELFLG        relocation info stripped from file
+ *      F_EXEC          file is executable  (i.e. no unresolved external
+ *                      references)
+ *      F_LNNO          line numbers stripped from file
+ *      F_LSYMS         local symbols stripped from file
+ *      F_MINMAL        this is a minimal object file (".m") output of fextract
+ *      F_UPDATE        this is a fully bound update file, output of ogen
+ *      F_SWABD         this file has had its bytes swabbed (in names)
+ *      F_AR16WR        this file has the byte ordering of an AR16WR
+ *                      (e.g. 11/70) machine
+ *      F_AR32WR        this file has the byte ordering of an AR32WR machine
+ *                      (e.g. vax and iNTEL 386)
+ *      F_AR32W         this file has the byte ordering of an AR32W machine
+ *                      (e.g. 3b,maxi)
+ *      F_PATCH         file contains "patch" list in optional header
+ *      F_NODF          (minimal file only) no decision functions for
+ *                      replaced functions
+ */
+
+#define  COFF_F_RELFLG          0000001
+#define  COFF_F_EXEC            0000002
+#define  COFF_F_LNNO            0000004
+#define  COFF_F_LSYMS           0000010
+#define  COFF_F_MINMAL          0000020
+#define  COFF_F_UPDATE          0000040
+#define  COFF_F_SWABD           0000100
+#define  COFF_F_AR16WR          0000200
+#define  COFF_F_AR32WR          0000400
+#define  COFF_F_AR32W           0001000
+#define  COFF_F_PATCH           0002000
+#define  COFF_F_NODF            0002000
+
+#define COFF_I386MAGIC          0x14c   /* Linux's system    */
+
+#if 0   /* Perhaps, someday, these formats may be used.      */
+#define COFF_I386PTXMAGIC       0x154
+#define COFF_I386AIXMAGIC       0x175   /* IBM's AIX system  */
+#define COFF_I386BADMAG(x) ((COFF_SHORT((x).f_magic) != COFF_I386MAGIC) \
+                          && COFF_SHORT((x).f_magic) != COFF_I386PTXMAGIC \
+                          && COFF_SHORT((x).f_magic) != COFF_I386AIXMAGIC)
+#else
+#define COFF_I386BADMAG(x) (COFF_SHORT((x).f_magic) != COFF_I386MAGIC)
+#endif
+
+#define COFF_FILHDR     struct COFF_filehdr
+#define COFF_FILHSZ     sizeof(COFF_FILHDR)
+
+/********************** AOUT "OPTIONAL HEADER" **********************/
+
+/* Linux COFF must have this "optional" header. Standard COFF has no entry
+   location for the "entry" point. They normally would start with the first
+   location of the .text section. This is not a good idea for linux. So,
+   the use of this "optional" header is not optional. It is required.
+
+   Do not be tempted to assume that the size of the optional header is
+   a constant and simply index the next byte by the size of this structure.
+   Use the 'f_opthdr' field in the main coff header for the size of the
+   structure actually written to the file!!
+*/
+
+typedef struct 
+{
+  char  magic[2];               /* type of file                          */
+  char  vstamp[2];              /* version stamp                         */
+  char  tsize[4];               /* text size in bytes, padded to FW bdry */
+  char  dsize[4];               /* initialized   data "   "              */
+  char  bsize[4];               /* uninitialized data "   "              */
+  char  entry[4];               /* entry pt.                             */
+  char  text_start[4];          /* base of text used for this file       */
+  char  data_start[4];          /* base of data used for this file       */
+}
+COFF_AOUTHDR;
+
+#define COFF_AOUTSZ (sizeof(COFF_AOUTHDR))
+
+#define COFF_STMAGIC    0401
+#define COFF_OMAGIC     0404
+#define COFF_JMAGIC     0407    /* dirty text and data image, can't share  */
+#define COFF_DMAGIC     0410    /* dirty text segment, data aligned        */
+#define COFF_ZMAGIC     0413    /* The proper magic number for executables  */
+#define COFF_SHMAGIC    0443    /* shared library header                   */
+
+/********************** SECTION HEADER **********************/
+
+struct COFF_scnhdr {
+  char          s_name[8];      /* section name                     */
+  char          s_paddr[4];     /* physical address, aliased s_nlib */
+  char          s_vaddr[4];     /* virtual address                  */
+  char          s_size[4];      /* section size                     */
+  char          s_scnptr[4];    /* file ptr to raw data for section */
+  char          s_relptr[4];    /* file ptr to relocation           */
+  char          s_lnnoptr[4];   /* file ptr to line numbers         */
+  char          s_nreloc[2];    /* number of relocation entries     */
+  char          s_nlnno[2];     /* number of line number entries    */
+  char          s_flags[4];     /* flags                            */
+};
+
+#define COFF_SCNHDR     struct COFF_scnhdr
+#define COFF_SCNHSZ     sizeof(COFF_SCNHDR)
+
+/*
+ * names of "special" sections
+ */
+
+#define COFF_TEXT       ".text"
+#define COFF_DATA       ".data"
+#define COFF_BSS        ".bss"
+#define COFF_COMMENT    ".comment"
+#define COFF_LIB        ".lib"
+
+#define COFF_SECT_TEXT  0      /* Section for instruction code             */
+#define COFF_SECT_DATA  1      /* Section for initialized globals          */
+#define COFF_SECT_BSS   2      /* Section for un-initialized globals       */
+#define COFF_SECT_REQD  3      /* Minimum number of sections for good file */
+
+#define COFF_STYP_REG     0x00 /* regular segment                          */
+#define COFF_STYP_DSECT   0x01 /* dummy segment                            */
+#define COFF_STYP_NOLOAD  0x02 /* no-load segment                          */
+#define COFF_STYP_GROUP   0x04 /* group segment                            */
+#define COFF_STYP_PAD     0x08 /* .pad segment                             */
+#define COFF_STYP_COPY    0x10 /* copy section                             */
+#define COFF_STYP_TEXT    0x20 /* .text segment                            */
+#define COFF_STYP_DATA    0x40 /* .data segment                            */
+#define COFF_STYP_BSS     0x80 /* .bss segment                             */
+#define COFF_STYP_INFO   0x200 /* .comment section                         */
+#define COFF_STYP_OVER   0x400 /* overlay section                          */
+#define COFF_STYP_LIB    0x800 /* library section                          */
+
+/*
+ * Shared libraries have the following section header in the data field for
+ * each library.
+ */
+
+struct COFF_slib {
+  char          sl_entsz[4];    /* Size of this entry               */
+  char          sl_pathndx[4];  /* size of the header field         */
+};
+
+#define COFF_SLIBHD     struct COFF_slib
+#define COFF_SLIBSZ     sizeof(COFF_SLIBHD)
+
+/********************** LINE NUMBERS **********************/
+
+/* 1 line number entry for every "breakpointable" source line in a section.
+ * Line numbers are grouped on a per function basis; first entry in a function
+ * grouping will have l_lnno = 0 and in place of physical address will be the
+ * symbol table index of the function name.
+ */
+
+struct COFF_lineno {
+  union {
+    char l_symndx[4];   /* function name symbol index, iff l_lnno == 0*/
+    char l_paddr[4];    /* (physical) address of line number    */
+  } l_addr;
+  char l_lnno[2];       /* line number          */
+};
+
+#define COFF_LINENO     struct COFF_lineno
+#define COFF_LINESZ     6
+
+/********************** SYMBOLS **********************/
+
+#define COFF_E_SYMNMLEN  8      /* # characters in a short symbol name  */
+#define COFF_E_FILNMLEN 14      /* # characters in a file name          */
+#define COFF_E_DIMNUM    4      /* # array dimensions in auxiliary entry */
+
+/*
+ *  All symbols and sections have the following definition
+ */
+
+struct COFF_syment 
+{
+  union {
+    char e_name[E_SYMNMLEN];    /* Symbol name (first 8 characters) */
+    struct {
+      char e_zeroes[4];         /* Leading zeros */
+      char e_offset[4];         /* Offset if this is a header section */
+    } e;
+  } e;
+
+  char e_value[4];              /* Value (address) of the segment */
+  char e_scnum[2];              /* Section number */
+  char e_type[2];               /* Type of section */
+  char e_sclass[1];             /* Loader class */
+  char e_numaux[1];             /* Number of auxiliary entries which follow */
+};
+
+#define COFF_N_BTMASK   (0xf)   /* Mask for important class bits */
+#define COFF_N_TMASK    (0x30)  /* Mask for important type bits  */
+#define COFF_N_BTSHFT   (4)     /* # bits to shift class field   */
+#define COFF_N_TSHIFT   (2)     /* # bits to shift type field    */
+
+/*
+ *  Auxiliary entries because the main table is too limiting.
+ */
+  
+union COFF_auxent {
+
+/*
+ *  Debugger information
+ */
+
+  struct {
+    char x_tagndx[4];           /* str, un, or enum tag indx */
+    union {
+      struct {
+        char  x_lnno[2];        /* declaration line number */
+        char  x_size[2];        /* str/union/array size */
+      } x_lnsz;
+      char x_fsize[4];          /* size of function */
+    } x_misc;
+
+    union {
+      struct {                  /* if ISFCN, tag, or .bb */
+        char x_lnnoptr[4];      /* ptr to fcn line # */
+        char x_endndx[4];       /* entry ndx past block end */
+      } x_fcn;
+
+      struct {                  /* if ISARY, up to 4 dimen. */
+        char x_dimen[E_DIMNUM][2];
+      } x_ary;
+    } x_fcnary;
+
+    char x_tvndx[2];    /* tv index */
+  } x_sym;
+
+/*
+ *   Source file names (debugger information)
+ */
+
+  union {
+    char x_fname[E_FILNMLEN];
+    struct {
+      char x_zeroes[4];
+      char x_offset[4];
+    } x_n;
+  } x_file;
+
+/*
+ *   Section information
+ */
+
+  struct {
+    char x_scnlen[4];   /* section length */
+    char x_nreloc[2];   /* # relocation entries */
+    char x_nlinno[2];   /* # line numbers */
+  } x_scn;
+
+/*
+ *   Transfer vector (branch table)
+ */
+  
+  struct {
+    char x_tvfill[4];   /* tv fill value */
+    char x_tvlen[2];    /* length of .tv */
+    char x_tvran[2][2]; /* tv range */
+  } x_tv;               /* info about .tv section (in auxent of symbol .tv)) */
+};
+
+#define COFF_SYMENT     struct COFF_syment
+#define COFF_SYMESZ     18      
+#define COFF_AUXENT     union COFF_auxent
+#define COFF_AUXESZ     18
+
+#define COFF_ETEXT      "etext"
+
+/********************** RELOCATION DIRECTIVES **********************/
+
+struct COFF_reloc {
+  char r_vaddr[4];        /* Virtual address of item    */
+  char r_symndx[4];       /* Symbol index in the symtab */
+  char r_type[2];         /* Relocation type            */
+};
+
+#define COFF_RELOC struct COFF_reloc
+#define COFF_RELSZ 10
+
+#define COFF_DEF_DATA_SECTION_ALIGNMENT  4
+#define COFF_DEF_BSS_SECTION_ALIGNMENT   4
+#define COFF_DEF_TEXT_SECTION_ALIGNMENT  4
+
+/* For new sections we haven't heard of before */
+#define COFF_DEF_SECTION_ALIGNMENT       4
diff --git a/include/linux/com20020.h b/include/linux/com20020.h
new file mode 100644
index 000000000000..ac6d9a43e085
--- /dev/null
+++ b/include/linux/com20020.h
@@ -0,0 +1,115 @@
+/*
+ * Linux ARCnet driver - COM20020 chipset support - function declarations
+ * 
+ * Written 1997 by David Woodhouse.
+ * Written 1994-1999 by Avery Pennarun.
+ * Derived from skeleton.c by Donald Becker.
+ *
+ * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
+ *  for sponsoring the further development of this driver.
+ *
+ * **********************
+ *
+ * The original copyright of skeleton.c was as follows:
+ *
+ * skeleton.c Written 1993 by Donald Becker.
+ * Copyright 1993 United States Government as represented by the
+ * Director, National Security Agency.  This software may only be used
+ * and distributed according to the terms of the GNU General Public License as
+ * modified by SRC, incorporated herein by reference.
+ *
+ * **********************
+ *
+ * For more details, see drivers/net/arcnet.c
+ *
+ * **********************
+ */
+#ifndef __COM20020_H
+#define __COM20020_H
+
+int com20020_check(struct net_device *dev);
+int com20020_found(struct net_device *dev, int shared);
+
+/* The number of low I/O ports used by the card. */
+#define ARCNET_TOTAL_SIZE 8
+
+/* various register addresses */
+#ifdef CONFIG_SA1100_CT6001
+#define BUS_ALIGN  2  /* 8 bit device on a 16 bit bus - needs padding */
+#else
+#define BUS_ALIGN  1
+#endif
+
+
+#define _INTMASK  (ioaddr+BUS_ALIGN*0)  /* writable */
+#define _STATUS   (ioaddr+BUS_ALIGN*0)  /* readable */
+#define _COMMAND  (ioaddr+BUS_ALIGN*1)  /* standard arcnet commands */
+#define _DIAGSTAT (ioaddr+BUS_ALIGN*1)  /* diagnostic status register */
+#define _ADDR_HI  (ioaddr+BUS_ALIGN*2)  /* control registers for IO-mapped memory */
+#define _ADDR_LO  (ioaddr+BUS_ALIGN*3)
+#define _MEMDATA  (ioaddr+BUS_ALIGN*4)  /* data port for IO-mapped memory */
+#define _SUBADR   (ioaddr+BUS_ALIGN*5)  /* the extended port _XREG refers to */
+#define _CONFIG   (ioaddr+BUS_ALIGN*6)  /* configuration register */
+#define _XREG     (ioaddr+BUS_ALIGN*7)  /* extra registers (indexed by _CONFIG
+                                        or _SUBADR) */
+
+/* in the ADDR_HI register */
+#define RDDATAflag      0x80    /* next access is a read (not a write) */
+
+/* in the DIAGSTAT register */
+#define NEWNXTIDflag    0x02    /* ID to which token is passed has changed */
+
+/* in the CONFIG register */
+#define RESETcfg        0x80    /* put card in reset state */
+#define TXENcfg         0x20    /* enable TX */
+
+/* in SETUP register */
+#define PROMISCset      0x10    /* enable RCV_ALL */
+#define P1MODE          0x80    /* enable P1-MODE for Backplane */
+#define SLOWARB         0x01    /* enable Slow Arbitration for >=5Mbps */
+
+/* COM2002x */
+#define SUB_TENTATIVE   0       /* tentative node ID */
+#define SUB_NODE        1       /* node ID */
+#define SUB_SETUP1      2       /* various options */
+#define SUB_TEST        3       /* test/diag register */
+
+/* COM20022 only */
+#define SUB_SETUP2      4       /* sundry options */
+#define SUB_BUSCTL      5       /* bus control options */
+#define SUB_DMACOUNT    6       /* DMA count options */
+
+#define SET_SUBADR(x) do { \
+        if ((x) < 4) \
+        { \
+                lp->config = (lp->config & ~0x03) | (x); \
+                SETCONF; \
+        } \
+        else \
+        { \
+                outb(x, _SUBADR); \
+        } \
+} while (0)
+
+#undef ARCRESET
+#undef ASTATUS
+#undef ACOMMAND
+#undef AINTMASK
+
+#define ARCRESET { outb(lp->config | 0x80, _CONFIG); \
+                    udelay(5);                        \
+                    outb(lp->config , _CONFIG);       \
+                  }
+#define ARCRESET0 { outb(0x18 | 0x80, _CONFIG);   \
+                    udelay(5);                       \
+                    outb(0x18 , _CONFIG);            \
+                  }
+
+#define ASTATUS()       inb(_STATUS)
+#define ADIAGSTATUS()   inb(_DIAGSTAT)
+#define ACOMMAND(cmd)   outb((cmd),_COMMAND)
+#define AINTMASK(msk)   outb((msk),_INTMASK)
+
+#define SETCONF         outb(lp->config, _CONFIG)
+
+#endif /* __COM20020_H */
diff --git a/include/linux/compat.h b/include/linux/compat.h
new file mode 100644
index 000000000000..b58b7d6f2fdb
--- /dev/null
+++ b/include/linux/compat.h
@@ -0,0 +1,162 @@
+#ifndef _LINUX_COMPAT_H
+#define _LINUX_COMPAT_H
+/*
+ * These are the type definitions for the architecture specific
+ * syscall compatibility layer.
+ */
+#include <linux/config.h>
+
+#ifdef CONFIG_COMPAT
+
+#include <linux/stat.h>
+#include <linux/param.h>        /* for HZ */
+#include <linux/sem.h>
+
+#include <asm/compat.h>
+#include <asm/siginfo.h>
+
+#define compat_jiffies_to_clock_t(x)    \
+                (((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
+
+struct rusage;
+
+struct compat_itimerspec { 
+        struct compat_timespec it_interval;
+        struct compat_timespec it_value;
+};
+
+struct compat_utimbuf {
+        compat_time_t           actime;
+        compat_time_t           modtime;
+};
+
+struct compat_itimerval {
+        struct compat_timeval   it_interval;
+        struct compat_timeval   it_value;
+};
+
+struct compat_tms {
+        compat_clock_t          tms_utime;
+        compat_clock_t          tms_stime;
+        compat_clock_t          tms_cutime;
+        compat_clock_t          tms_cstime;
+};
+
+#define _COMPAT_NSIG_WORDS      (_COMPAT_NSIG / _COMPAT_NSIG_BPW)
+
+typedef struct {
+        compat_sigset_word      sig[_COMPAT_NSIG_WORDS];
+} compat_sigset_t;
+
+extern int cp_compat_stat(struct kstat *, struct compat_stat __user *);
+extern int get_compat_timespec(struct timespec *, const struct compat_timespec __user *);
+extern int put_compat_timespec(const struct timespec *, struct compat_timespec __user *);
+
+struct compat_iovec {
+        compat_uptr_t   iov_base;
+        compat_size_t   iov_len;
+};
+
+struct compat_rlimit {
+        compat_ulong_t  rlim_cur;
+        compat_ulong_t  rlim_max;
+};
+
+struct compat_rusage {
+        struct compat_timeval ru_utime;
+        struct compat_timeval ru_stime;
+        compat_long_t   ru_maxrss;
+        compat_long_t   ru_ixrss;
+        compat_long_t   ru_idrss;
+        compat_long_t   ru_isrss;
+        compat_long_t   ru_minflt;
+        compat_long_t   ru_majflt;
+        compat_long_t   ru_nswap;
+        compat_long_t   ru_inblock;
+        compat_long_t   ru_oublock;
+        compat_long_t   ru_msgsnd;
+        compat_long_t   ru_msgrcv;
+        compat_long_t   ru_nsignals;
+        compat_long_t   ru_nvcsw;
+        compat_long_t   ru_nivcsw;
+};
+
+extern int put_compat_rusage(const struct rusage *, struct compat_rusage __user *);
+
+struct compat_siginfo;
+
+extern asmlinkage long compat_sys_waitid(int, compat_pid_t,
+                struct compat_siginfo __user *, int,
+                struct compat_rusage __user *);
+
+struct compat_dirent {
+        u32             d_ino;
+        compat_off_t    d_off;
+        u16             d_reclen;
+        char            d_name[256];
+};
+
+typedef union compat_sigval {
+        compat_int_t    sival_int;
+        compat_uptr_t   sival_ptr;
+} compat_sigval_t;
+
+#define COMPAT_SIGEV_PAD_SIZE   ((SIGEV_MAX_SIZE/sizeof(int)) - 3)
+
+typedef struct compat_sigevent {
+        compat_sigval_t sigev_value;
+        compat_int_t sigev_signo;
+        compat_int_t sigev_notify;
+        union {
+                compat_int_t _pad[COMPAT_SIGEV_PAD_SIZE];
+                compat_int_t _tid;
+
+                struct {
+                        compat_uptr_t _function;
+                        compat_uptr_t _attribute;
+                } _sigev_thread;
+        } _sigev_un;
+} compat_sigevent_t;
+
+
+long compat_sys_semctl(int first, int second, int third, void __user *uptr);
+long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
+long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
+                int version, void __user *uptr);
+long compat_sys_msgctl(int first, int second, void __user *uptr);
+long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
+                void __user *uptr);
+long compat_sys_shmctl(int first, int second, void __user *uptr);
+long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
+                unsigned nsems, const struct compat_timespec __user *timeout);
+asmlinkage long compat_sys_keyctl(u32 option,
+                              u32 arg2, u32 arg3, u32 arg4, u32 arg5);
+
+asmlinkage ssize_t compat_sys_readv(unsigned long fd,
+                const struct compat_iovec __user *vec, unsigned long vlen);
+asmlinkage ssize_t compat_sys_writev(unsigned long fd,
+                const struct compat_iovec __user *vec, unsigned long vlen);
+
+int compat_do_execve(char * filename, compat_uptr_t __user *argv,
+                compat_uptr_t __user *envp, struct pt_regs * regs);
+
+asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
+                compat_ulong_t __user *outp, compat_ulong_t __user *exp,
+                struct compat_timeval __user *tvp);
+
+#define BITS_PER_COMPAT_LONG    (8*sizeof(compat_long_t))
+
+#define BITS_TO_COMPAT_LONGS(bits) \
+        (((bits)+BITS_PER_COMPAT_LONG-1)/BITS_PER_COMPAT_LONG)
+
+long compat_get_bitmap(unsigned long *mask, compat_ulong_t __user *umask,
+                       unsigned long bitmap_size);
+long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
+                       unsigned long bitmap_size);
+int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
+int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from);
+int get_compat_sigevent(struct sigevent *event,
+                const struct compat_sigevent __user *u_event);
+
+#endif /* CONFIG_COMPAT */
+#endif /* _LINUX_COMPAT_H */
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
new file mode 100644
index 000000000000..70a4ebb5d964
--- /dev/null
+++ b/include/linux/compat_ioctl.h
@@ -0,0 +1,771 @@
+/* List here explicitly which ioctl's are known to have
+ * compatible types passed or none at all... Please include
+ * only stuff that is compatible on *all architectures*.
+ */
+#ifndef COMPATIBLE_IOCTL /* pointer to compatible structure or no argument */
+#define COMPATIBLE_IOCTL(cmd)  HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)sys_ioctl)
+#endif
+
+#ifndef ULONG_IOCTL /* argument is an unsigned long integer, not a pointer */
+#define ULONG_IOCTL(cmd)  HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)sys_ioctl)
+#endif
+
+/* Big T */
+COMPATIBLE_IOCTL(TCGETA)
+COMPATIBLE_IOCTL(TCSETA)
+COMPATIBLE_IOCTL(TCSETAW)
+COMPATIBLE_IOCTL(TCSETAF)
+COMPATIBLE_IOCTL(TCSBRK)
+ULONG_IOCTL(TCSBRKP)
+COMPATIBLE_IOCTL(TCXONC)
+COMPATIBLE_IOCTL(TCFLSH)
+COMPATIBLE_IOCTL(TCGETS)
+COMPATIBLE_IOCTL(TCSETS)
+COMPATIBLE_IOCTL(TCSETSW)
+COMPATIBLE_IOCTL(TCSETSF)
+COMPATIBLE_IOCTL(TIOCLINUX)
+COMPATIBLE_IOCTL(TIOCSBRK)
+COMPATIBLE_IOCTL(TIOCCBRK)
+ULONG_IOCTL(TIOCMIWAIT)
+COMPATIBLE_IOCTL(TIOCGICOUNT)
+/* Little t */
+COMPATIBLE_IOCTL(TIOCGETD)
+COMPATIBLE_IOCTL(TIOCSETD)
+COMPATIBLE_IOCTL(TIOCEXCL)
+COMPATIBLE_IOCTL(TIOCNXCL)
+COMPATIBLE_IOCTL(TIOCCONS)
+COMPATIBLE_IOCTL(TIOCGSOFTCAR)
+COMPATIBLE_IOCTL(TIOCSSOFTCAR)
+COMPATIBLE_IOCTL(TIOCSWINSZ)
+COMPATIBLE_IOCTL(TIOCGWINSZ)
+COMPATIBLE_IOCTL(TIOCMGET)
+COMPATIBLE_IOCTL(TIOCMBIC)
+COMPATIBLE_IOCTL(TIOCMBIS)
+COMPATIBLE_IOCTL(TIOCMSET)
+COMPATIBLE_IOCTL(TIOCPKT)
+COMPATIBLE_IOCTL(TIOCNOTTY)
+COMPATIBLE_IOCTL(TIOCSTI)
+COMPATIBLE_IOCTL(TIOCOUTQ)
+COMPATIBLE_IOCTL(TIOCSPGRP)
+COMPATIBLE_IOCTL(TIOCGPGRP)
+ULONG_IOCTL(TIOCSCTTY)
+COMPATIBLE_IOCTL(TIOCGPTN)
+COMPATIBLE_IOCTL(TIOCSPTLCK)
+COMPATIBLE_IOCTL(TIOCSERGETLSR)
+/* Big F */
+COMPATIBLE_IOCTL(FBIOBLANK)
+COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO)
+COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO)
+COMPATIBLE_IOCTL(FBIOPAN_DISPLAY)
+COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP)
+COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP)
+/* Little f */
+COMPATIBLE_IOCTL(FIOCLEX)
+COMPATIBLE_IOCTL(FIONCLEX)
+COMPATIBLE_IOCTL(FIOASYNC)
+COMPATIBLE_IOCTL(FIONBIO)
+COMPATIBLE_IOCTL(FIONREAD)  /* This is also TIOCINQ */
+/* 0x00 */
+COMPATIBLE_IOCTL(FIBMAP)
+COMPATIBLE_IOCTL(FIGETBSZ)
+/* 0x03 -- HD/IDE ioctl's used by hdparm and friends.
+ *         Some need translations, these do not.
+ */
+COMPATIBLE_IOCTL(HDIO_GET_IDENTITY)
+COMPATIBLE_IOCTL(HDIO_SET_DMA)
+COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR)
+COMPATIBLE_IOCTL(HDIO_SET_NOWERR)
+COMPATIBLE_IOCTL(HDIO_SET_32BIT)
+COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT)
+COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
+COMPATIBLE_IOCTL(HDIO_DRIVE_TASK)
+COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE)
+COMPATIBLE_IOCTL(HDIO_SET_NICE)
+/* 0x02 -- Floppy ioctls */
+COMPATIBLE_IOCTL(FDMSGON)
+COMPATIBLE_IOCTL(FDMSGOFF)
+COMPATIBLE_IOCTL(FDSETEMSGTRESH)
+COMPATIBLE_IOCTL(FDFLUSH)
+COMPATIBLE_IOCTL(FDWERRORCLR)
+COMPATIBLE_IOCTL(FDSETMAXERRS)
+COMPATIBLE_IOCTL(FDGETMAXERRS)
+COMPATIBLE_IOCTL(FDGETDRVTYP)
+COMPATIBLE_IOCTL(FDEJECT)
+COMPATIBLE_IOCTL(FDCLRPRM)
+COMPATIBLE_IOCTL(FDFMTBEG)
+COMPATIBLE_IOCTL(FDFMTEND)
+COMPATIBLE_IOCTL(FDRESET)
+COMPATIBLE_IOCTL(FDTWADDLE)
+COMPATIBLE_IOCTL(FDFMTTRK)
+COMPATIBLE_IOCTL(FDRAWCMD)
+/* 0x12 */
+COMPATIBLE_IOCTL(BLKROSET)
+COMPATIBLE_IOCTL(BLKROGET)
+COMPATIBLE_IOCTL(BLKRRPART)
+COMPATIBLE_IOCTL(BLKFLSBUF)
+COMPATIBLE_IOCTL(BLKSECTSET)
+COMPATIBLE_IOCTL(BLKSSZGET)
+ULONG_IOCTL(BLKRASET)
+ULONG_IOCTL(BLKFRASET)
+/* RAID */
+COMPATIBLE_IOCTL(RAID_VERSION)
+COMPATIBLE_IOCTL(GET_ARRAY_INFO)
+COMPATIBLE_IOCTL(GET_DISK_INFO)
+COMPATIBLE_IOCTL(PRINT_RAID_DEBUG)
+COMPATIBLE_IOCTL(RAID_AUTORUN)
+COMPATIBLE_IOCTL(CLEAR_ARRAY)
+COMPATIBLE_IOCTL(ADD_NEW_DISK)
+ULONG_IOCTL(HOT_REMOVE_DISK)
+COMPATIBLE_IOCTL(SET_ARRAY_INFO)
+COMPATIBLE_IOCTL(SET_DISK_INFO)
+COMPATIBLE_IOCTL(WRITE_RAID_INFO)
+COMPATIBLE_IOCTL(UNPROTECT_ARRAY)
+COMPATIBLE_IOCTL(PROTECT_ARRAY)
+ULONG_IOCTL(HOT_ADD_DISK)
+ULONG_IOCTL(SET_DISK_FAULTY)
+COMPATIBLE_IOCTL(RUN_ARRAY)
+ULONG_IOCTL(START_ARRAY)
+COMPATIBLE_IOCTL(STOP_ARRAY)
+COMPATIBLE_IOCTL(STOP_ARRAY_RO)
+COMPATIBLE_IOCTL(RESTART_ARRAY_RW)
+/* DM */
+COMPATIBLE_IOCTL(DM_VERSION_32)
+COMPATIBLE_IOCTL(DM_REMOVE_ALL_32)
+COMPATIBLE_IOCTL(DM_LIST_DEVICES_32)
+COMPATIBLE_IOCTL(DM_DEV_CREATE_32)
+COMPATIBLE_IOCTL(DM_DEV_REMOVE_32)
+COMPATIBLE_IOCTL(DM_DEV_RENAME_32)
+COMPATIBLE_IOCTL(DM_DEV_SUSPEND_32)
+COMPATIBLE_IOCTL(DM_DEV_STATUS_32)
+COMPATIBLE_IOCTL(DM_DEV_WAIT_32)
+COMPATIBLE_IOCTL(DM_TABLE_LOAD_32)
+COMPATIBLE_IOCTL(DM_TABLE_CLEAR_32)
+COMPATIBLE_IOCTL(DM_TABLE_DEPS_32)
+COMPATIBLE_IOCTL(DM_TABLE_STATUS_32)
+COMPATIBLE_IOCTL(DM_LIST_VERSIONS_32)
+COMPATIBLE_IOCTL(DM_TARGET_MSG_32)
+COMPATIBLE_IOCTL(DM_VERSION)
+COMPATIBLE_IOCTL(DM_REMOVE_ALL)
+COMPATIBLE_IOCTL(DM_LIST_DEVICES)
+COMPATIBLE_IOCTL(DM_DEV_CREATE)
+COMPATIBLE_IOCTL(DM_DEV_REMOVE)
+COMPATIBLE_IOCTL(DM_DEV_RENAME)
+COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
+COMPATIBLE_IOCTL(DM_DEV_STATUS)
+COMPATIBLE_IOCTL(DM_DEV_WAIT)
+COMPATIBLE_IOCTL(DM_TABLE_LOAD)
+COMPATIBLE_IOCTL(DM_TABLE_CLEAR)
+COMPATIBLE_IOCTL(DM_TABLE_DEPS)
+COMPATIBLE_IOCTL(DM_TABLE_STATUS)
+COMPATIBLE_IOCTL(DM_LIST_VERSIONS)
+COMPATIBLE_IOCTL(DM_TARGET_MSG)
+/* Big K */
+COMPATIBLE_IOCTL(PIO_FONT)
+COMPATIBLE_IOCTL(GIO_FONT)
+ULONG_IOCTL(KDSIGACCEPT)
+COMPATIBLE_IOCTL(KDGETKEYCODE)
+COMPATIBLE_IOCTL(KDSETKEYCODE)
+ULONG_IOCTL(KIOCSOUND)
+ULONG_IOCTL(KDMKTONE)
+COMPATIBLE_IOCTL(KDGKBTYPE)
+ULONG_IOCTL(KDSETMODE)
+COMPATIBLE_IOCTL(KDGETMODE)
+ULONG_IOCTL(KDSKBMODE)
+COMPATIBLE_IOCTL(KDGKBMODE)
+ULONG_IOCTL(KDSKBMETA)
+COMPATIBLE_IOCTL(KDGKBMETA)
+COMPATIBLE_IOCTL(KDGKBENT)
+COMPATIBLE_IOCTL(KDSKBENT)
+COMPATIBLE_IOCTL(KDGKBSENT)
+COMPATIBLE_IOCTL(KDSKBSENT)
+COMPATIBLE_IOCTL(KDGKBDIACR)
+COMPATIBLE_IOCTL(KDSKBDIACR)
+COMPATIBLE_IOCTL(KDKBDREP)
+COMPATIBLE_IOCTL(KDGKBLED)
+ULONG_IOCTL(KDSKBLED)
+COMPATIBLE_IOCTL(KDGETLED)
+ULONG_IOCTL(KDSETLED)
+COMPATIBLE_IOCTL(GIO_SCRNMAP)
+COMPATIBLE_IOCTL(PIO_SCRNMAP)
+COMPATIBLE_IOCTL(GIO_UNISCRNMAP)
+COMPATIBLE_IOCTL(PIO_UNISCRNMAP)
+COMPATIBLE_IOCTL(PIO_FONTRESET)
+COMPATIBLE_IOCTL(PIO_UNIMAPCLR)
+/* Big S */
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
+COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
+COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
+COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
+COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
+COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST)
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI)
+/* Big T */
+COMPATIBLE_IOCTL(TUNSETNOCSUM)
+COMPATIBLE_IOCTL(TUNSETDEBUG)
+COMPATIBLE_IOCTL(TUNSETPERSIST)
+COMPATIBLE_IOCTL(TUNSETOWNER)
+/* Big V */
+COMPATIBLE_IOCTL(VT_SETMODE)
+COMPATIBLE_IOCTL(VT_GETMODE)
+COMPATIBLE_IOCTL(VT_GETSTATE)
+COMPATIBLE_IOCTL(VT_OPENQRY)
+ULONG_IOCTL(VT_ACTIVATE)
+ULONG_IOCTL(VT_WAITACTIVE)
+ULONG_IOCTL(VT_RELDISP)
+ULONG_IOCTL(VT_DISALLOCATE)
+COMPATIBLE_IOCTL(VT_RESIZE)
+COMPATIBLE_IOCTL(VT_RESIZEX)
+COMPATIBLE_IOCTL(VT_LOCKSWITCH)
+COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
+/* Little v */
+/* Little v, the video4linux ioctls (conflict?) */
+COMPATIBLE_IOCTL(VIDIOCGCAP)
+COMPATIBLE_IOCTL(VIDIOCGCHAN)
+COMPATIBLE_IOCTL(VIDIOCSCHAN)
+COMPATIBLE_IOCTL(VIDIOCGPICT)
+COMPATIBLE_IOCTL(VIDIOCSPICT)
+COMPATIBLE_IOCTL(VIDIOCCAPTURE)
+COMPATIBLE_IOCTL(VIDIOCKEY)
+COMPATIBLE_IOCTL(VIDIOCGAUDIO)
+COMPATIBLE_IOCTL(VIDIOCSAUDIO)
+COMPATIBLE_IOCTL(VIDIOCSYNC)
+COMPATIBLE_IOCTL(VIDIOCMCAPTURE)
+COMPATIBLE_IOCTL(VIDIOCGMBUF)
+COMPATIBLE_IOCTL(VIDIOCGUNIT)
+COMPATIBLE_IOCTL(VIDIOCGCAPTURE)
+COMPATIBLE_IOCTL(VIDIOCSCAPTURE)
+/* BTTV specific... */
+COMPATIBLE_IOCTL(_IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]))
+COMPATIBLE_IOCTL(_IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]))
+COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int))
+COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])) /* struct bttv_pll_info */
+COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int))
+COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int))
+COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int))
+COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int))
+/* Little p (/dev/rtc, /dev/envctrl, etc.) */
+COMPATIBLE_IOCTL(RTC_AIE_ON)
+COMPATIBLE_IOCTL(RTC_AIE_OFF)
+COMPATIBLE_IOCTL(RTC_UIE_ON)
+COMPATIBLE_IOCTL(RTC_UIE_OFF)
+COMPATIBLE_IOCTL(RTC_PIE_ON)
+COMPATIBLE_IOCTL(RTC_PIE_OFF)
+COMPATIBLE_IOCTL(RTC_WIE_ON)
+COMPATIBLE_IOCTL(RTC_WIE_OFF)
+COMPATIBLE_IOCTL(RTC_ALM_SET)
+COMPATIBLE_IOCTL(RTC_ALM_READ)
+COMPATIBLE_IOCTL(RTC_RD_TIME)
+COMPATIBLE_IOCTL(RTC_SET_TIME)
+COMPATIBLE_IOCTL(RTC_WKALM_SET)
+COMPATIBLE_IOCTL(RTC_WKALM_RD)
+/* Little m */
+COMPATIBLE_IOCTL(MTIOCTOP)
+/* Socket level stuff */
+COMPATIBLE_IOCTL(FIOSETOWN)
+COMPATIBLE_IOCTL(SIOCSPGRP)
+COMPATIBLE_IOCTL(FIOGETOWN)
+COMPATIBLE_IOCTL(SIOCGPGRP)
+COMPATIBLE_IOCTL(SIOCATMARK)
+COMPATIBLE_IOCTL(SIOCSIFLINK)
+COMPATIBLE_IOCTL(SIOCSIFENCAP)
+COMPATIBLE_IOCTL(SIOCGIFENCAP)
+COMPATIBLE_IOCTL(SIOCSIFNAME)
+COMPATIBLE_IOCTL(SIOCSARP)
+COMPATIBLE_IOCTL(SIOCGARP)
+COMPATIBLE_IOCTL(SIOCDARP)
+COMPATIBLE_IOCTL(SIOCSRARP)
+COMPATIBLE_IOCTL(SIOCGRARP)
+COMPATIBLE_IOCTL(SIOCDRARP)
+COMPATIBLE_IOCTL(SIOCADDDLCI)
+COMPATIBLE_IOCTL(SIOCDELDLCI)
+COMPATIBLE_IOCTL(SIOCGMIIPHY)
+COMPATIBLE_IOCTL(SIOCGMIIREG)
+COMPATIBLE_IOCTL(SIOCSMIIREG)
+COMPATIBLE_IOCTL(SIOCGIFVLAN)
+COMPATIBLE_IOCTL(SIOCSIFVLAN)
+COMPATIBLE_IOCTL(SIOCBRADDBR)
+COMPATIBLE_IOCTL(SIOCBRDELBR)
+/* SG stuff */
+COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
+COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
+COMPATIBLE_IOCTL(SG_EMULATED_HOST)
+ULONG_IOCTL(SG_SET_TRANSFORM)
+COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
+COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
+COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
+COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
+COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
+COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
+COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
+COMPATIBLE_IOCTL(SG_GET_PACK_ID)
+COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
+COMPATIBLE_IOCTL(SG_SET_DEBUG)
+COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
+COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
+COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
+COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
+COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
+COMPATIBLE_IOCTL(SG_SCSI_RESET)
+COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
+COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
+COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
+/* PPP stuff */
+COMPATIBLE_IOCTL(PPPIOCGFLAGS)
+COMPATIBLE_IOCTL(PPPIOCSFLAGS)
+COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCGUNIT)
+COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCGMRU)
+COMPATIBLE_IOCTL(PPPIOCSMRU)
+COMPATIBLE_IOCTL(PPPIOCSMAXCID)
+COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
+/* PPPIOCSCOMPRESS is translated */
+COMPATIBLE_IOCTL(PPPIOCGNPMODE)
+COMPATIBLE_IOCTL(PPPIOCSNPMODE)
+COMPATIBLE_IOCTL(PPPIOCGDEBUG)
+COMPATIBLE_IOCTL(PPPIOCSDEBUG)
+/* PPPIOCSPASS is translated */
+/* PPPIOCSACTIVE is translated */
+/* PPPIOCGIDLE is translated */
+COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
+COMPATIBLE_IOCTL(PPPIOCATTACH)
+COMPATIBLE_IOCTL(PPPIOCDETACH)
+COMPATIBLE_IOCTL(PPPIOCSMRRU)
+COMPATIBLE_IOCTL(PPPIOCCONNECT)
+COMPATIBLE_IOCTL(PPPIOCDISCONN)
+COMPATIBLE_IOCTL(PPPIOCATTCHAN)
+COMPATIBLE_IOCTL(PPPIOCGCHAN)
+/* PPPOX */
+COMPATIBLE_IOCTL(PPPOEIOCSFWD)
+COMPATIBLE_IOCTL(PPPOEIOCDFWD)
+/* LP */
+COMPATIBLE_IOCTL(LPGETSTATUS)
+/* ppdev */
+COMPATIBLE_IOCTL(PPCLAIM)
+COMPATIBLE_IOCTL(PPRELEASE)
+COMPATIBLE_IOCTL(PPEXCL)
+COMPATIBLE_IOCTL(PPYIELD)
+/* CDROM stuff */
+COMPATIBLE_IOCTL(CDROMPAUSE)
+COMPATIBLE_IOCTL(CDROMRESUME)
+COMPATIBLE_IOCTL(CDROMPLAYMSF)
+COMPATIBLE_IOCTL(CDROMPLAYTRKIND)
+COMPATIBLE_IOCTL(CDROMREADTOCHDR)
+COMPATIBLE_IOCTL(CDROMREADTOCENTRY)
+COMPATIBLE_IOCTL(CDROMSTOP)
+COMPATIBLE_IOCTL(CDROMSTART)
+COMPATIBLE_IOCTL(CDROMEJECT)
+COMPATIBLE_IOCTL(CDROMVOLCTRL)
+COMPATIBLE_IOCTL(CDROMSUBCHNL)
+ULONG_IOCTL(CDROMEJECT_SW)
+COMPATIBLE_IOCTL(CDROMMULTISESSION)
+COMPATIBLE_IOCTL(CDROM_GET_MCN)
+COMPATIBLE_IOCTL(CDROMRESET)
+COMPATIBLE_IOCTL(CDROMVOLREAD)
+COMPATIBLE_IOCTL(CDROMSEEK)
+COMPATIBLE_IOCTL(CDROMPLAYBLK)
+COMPATIBLE_IOCTL(CDROMCLOSETRAY)
+ULONG_IOCTL(CDROM_SET_OPTIONS)
+ULONG_IOCTL(CDROM_CLEAR_OPTIONS)
+ULONG_IOCTL(CDROM_SELECT_SPEED)
+ULONG_IOCTL(CDROM_SELECT_DISC)
+ULONG_IOCTL(CDROM_MEDIA_CHANGED)
+ULONG_IOCTL(CDROM_DRIVE_STATUS)
+COMPATIBLE_IOCTL(CDROM_DISC_STATUS)
+COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS)
+ULONG_IOCTL(CDROM_LOCKDOOR)
+ULONG_IOCTL(CDROM_DEBUG)
+COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY)
+/* Ignore cdrom.h about these next 5 ioctls, they absolutely do
+ * not take a struct cdrom_read, instead they take a struct cdrom_msf
+ * which is compatible.
+ */
+COMPATIBLE_IOCTL(CDROMREADMODE2)
+COMPATIBLE_IOCTL(CDROMREADMODE1)
+COMPATIBLE_IOCTL(CDROMREADRAW)
+COMPATIBLE_IOCTL(CDROMREADCOOKED)
+COMPATIBLE_IOCTL(CDROMREADALL)
+/* DVD ioctls */
+COMPATIBLE_IOCTL(DVD_READ_STRUCT)
+COMPATIBLE_IOCTL(DVD_WRITE_STRUCT)
+COMPATIBLE_IOCTL(DVD_AUTH)
+/* pktcdvd */
+COMPATIBLE_IOCTL(PACKET_CTRL_CMD)
+/* Big L */
+ULONG_IOCTL(LOOP_SET_FD)
+ULONG_IOCTL(LOOP_CHANGE_FD)
+COMPATIBLE_IOCTL(LOOP_CLR_FD)
+COMPATIBLE_IOCTL(LOOP_GET_STATUS64)
+COMPATIBLE_IOCTL(LOOP_SET_STATUS64)
+/* Big A */
+/* sparc only */
+/* Big Q for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
+COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
+COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
+/* Big T for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_START)
+COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
+COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
+COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
+COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
+/* Little m for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
+/* Big P for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
+COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
+COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
+/* SNDCTL_DSP_MAPINBUF,  XXX needs translation */
+/* SNDCTL_DSP_MAPOUTBUF,  XXX needs translation */
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
+COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
+/* Big C for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
+COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
+COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
+COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
+COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
+COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
+/* Big M for sound/OSS */
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE)
+/* SOUND_MIXER_READ_ENHANCE,  same value as READ_MUTE */
+/* SOUND_MIXER_READ_LOUD,  same value as READ_MUTE */
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
+/* SOUND_MIXER_WRITE_ENHANCE,  same value as WRITE_MUTE */
+/* SOUND_MIXER_WRITE_LOUD,  same value as WRITE_MUTE */
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
+COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
+COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
+COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
+COMPATIBLE_IOCTL(SOUND_MIXER_AGC)
+COMPATIBLE_IOCTL(SOUND_MIXER_3DSE)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
+COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
+COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
+COMPATIBLE_IOCTL(OSS_GETVERSION)
+/* AUTOFS */
+ULONG_IOCTL(AUTOFS_IOC_READY)
+ULONG_IOCTL(AUTOFS_IOC_FAIL)
+COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC)
+COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER)
+COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE)
+COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
+COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOSUBVER)
+COMPATIBLE_IOCTL(AUTOFS_IOC_ASKREGHOST)
+COMPATIBLE_IOCTL(AUTOFS_IOC_TOGGLEREGHOST)
+COMPATIBLE_IOCTL(AUTOFS_IOC_ASKUMOUNT)
+/* DEVFS */
+COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV)
+COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK)
+COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE)
+COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK)
+/* Raw devices */
+COMPATIBLE_IOCTL(RAW_SETBIND)
+COMPATIBLE_IOCTL(RAW_GETBIND)
+/* SMB ioctls which do not need any translations */
+COMPATIBLE_IOCTL(SMB_IOC_NEWCONN)
+/* NCP ioctls which do not need any translations */
+COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN)
+COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT)
+COMPATIBLE_IOCTL(NCP_IOC_SIGN_WANTED)
+COMPATIBLE_IOCTL(NCP_IOC_SET_SIGN_WANTED)
+COMPATIBLE_IOCTL(NCP_IOC_LOCKUNLOCK)
+COMPATIBLE_IOCTL(NCP_IOC_GETROOT)
+COMPATIBLE_IOCTL(NCP_IOC_SETROOT)
+COMPATIBLE_IOCTL(NCP_IOC_GETCHARSETS)
+COMPATIBLE_IOCTL(NCP_IOC_SETCHARSETS)
+COMPATIBLE_IOCTL(NCP_IOC_GETDENTRYTTL)
+COMPATIBLE_IOCTL(NCP_IOC_SETDENTRYTTL)
+/* Little a */
+COMPATIBLE_IOCTL(ATMSIGD_CTRL)
+COMPATIBLE_IOCTL(ATMARPD_CTRL)
+COMPATIBLE_IOCTL(ATMLEC_CTRL)
+COMPATIBLE_IOCTL(ATMLEC_MCAST)
+COMPATIBLE_IOCTL(ATMLEC_DATA)
+COMPATIBLE_IOCTL(ATM_SETSC)
+COMPATIBLE_IOCTL(SIOCSIFATMTCP)
+COMPATIBLE_IOCTL(SIOCMKCLIP)
+COMPATIBLE_IOCTL(ATMARP_MKIP)
+COMPATIBLE_IOCTL(ATMARP_SETENTRY)
+COMPATIBLE_IOCTL(ATMARP_ENCAP)
+COMPATIBLE_IOCTL(ATMTCP_CREATE)
+COMPATIBLE_IOCTL(ATMTCP_REMOVE)
+COMPATIBLE_IOCTL(ATMMPC_CTRL)
+COMPATIBLE_IOCTL(ATMMPC_DATA)
+/* Watchdog */
+COMPATIBLE_IOCTL(WDIOC_GETSUPPORT)
+COMPATIBLE_IOCTL(WDIOC_GETSTATUS)
+COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS)
+COMPATIBLE_IOCTL(WDIOC_GETTEMP)
+COMPATIBLE_IOCTL(WDIOC_SETOPTIONS)
+COMPATIBLE_IOCTL(WDIOC_KEEPALIVE)
+COMPATIBLE_IOCTL(WDIOC_SETTIMEOUT)
+COMPATIBLE_IOCTL(WDIOC_GETTIMEOUT)
+/* Big R */
+COMPATIBLE_IOCTL(RNDGETENTCNT)
+COMPATIBLE_IOCTL(RNDADDTOENTCNT)
+COMPATIBLE_IOCTL(RNDGETPOOL)
+COMPATIBLE_IOCTL(RNDADDENTROPY)
+COMPATIBLE_IOCTL(RNDZAPENTCNT)
+COMPATIBLE_IOCTL(RNDCLEARPOOL)
+/* Bluetooth */
+COMPATIBLE_IOCTL(HCIDEVUP)
+COMPATIBLE_IOCTL(HCIDEVDOWN)
+COMPATIBLE_IOCTL(HCIDEVRESET)
+COMPATIBLE_IOCTL(HCIDEVRESTAT)
+COMPATIBLE_IOCTL(HCIGETDEVLIST)
+COMPATIBLE_IOCTL(HCIGETDEVINFO)
+COMPATIBLE_IOCTL(HCIGETCONNLIST)
+COMPATIBLE_IOCTL(HCIGETCONNINFO)
+COMPATIBLE_IOCTL(HCISETRAW)
+COMPATIBLE_IOCTL(HCISETSCAN)
+COMPATIBLE_IOCTL(HCISETAUTH)
+COMPATIBLE_IOCTL(HCISETENCRYPT)
+COMPATIBLE_IOCTL(HCISETPTYPE)
+COMPATIBLE_IOCTL(HCISETLINKPOL)
+COMPATIBLE_IOCTL(HCISETLINKMODE)
+COMPATIBLE_IOCTL(HCISETACLMTU)
+COMPATIBLE_IOCTL(HCISETSCOMTU)
+COMPATIBLE_IOCTL(HCIINQUIRY)
+COMPATIBLE_IOCTL(HCIUARTSETPROTO)
+COMPATIBLE_IOCTL(HCIUARTGETPROTO)
+COMPATIBLE_IOCTL(RFCOMMCREATEDEV)
+COMPATIBLE_IOCTL(RFCOMMRELEASEDEV)
+COMPATIBLE_IOCTL(RFCOMMGETDEVLIST)
+COMPATIBLE_IOCTL(RFCOMMGETDEVINFO)
+COMPATIBLE_IOCTL(RFCOMMSTEALDLC)
+COMPATIBLE_IOCTL(BNEPCONNADD)
+COMPATIBLE_IOCTL(BNEPCONNDEL)
+COMPATIBLE_IOCTL(BNEPGETCONNLIST)
+COMPATIBLE_IOCTL(BNEPGETCONNINFO)
+COMPATIBLE_IOCTL(CMTPCONNADD)
+COMPATIBLE_IOCTL(CMTPCONNDEL)
+COMPATIBLE_IOCTL(CMTPGETCONNLIST)
+COMPATIBLE_IOCTL(CMTPGETCONNINFO)
+COMPATIBLE_IOCTL(HIDPCONNADD)
+COMPATIBLE_IOCTL(HIDPCONNDEL)
+COMPATIBLE_IOCTL(HIDPGETCONNLIST)
+COMPATIBLE_IOCTL(HIDPGETCONNINFO)
+/* CAPI */
+COMPATIBLE_IOCTL(CAPI_REGISTER)
+COMPATIBLE_IOCTL(CAPI_GET_MANUFACTURER)
+COMPATIBLE_IOCTL(CAPI_GET_VERSION)
+COMPATIBLE_IOCTL(CAPI_GET_SERIAL)
+COMPATIBLE_IOCTL(CAPI_GET_PROFILE)
+COMPATIBLE_IOCTL(CAPI_MANUFACTURER_CMD)
+COMPATIBLE_IOCTL(CAPI_GET_ERRCODE)
+COMPATIBLE_IOCTL(CAPI_INSTALLED)
+COMPATIBLE_IOCTL(CAPI_GET_FLAGS)
+COMPATIBLE_IOCTL(CAPI_SET_FLAGS)
+COMPATIBLE_IOCTL(CAPI_CLR_FLAGS)
+COMPATIBLE_IOCTL(CAPI_NCCI_OPENCOUNT)
+COMPATIBLE_IOCTL(CAPI_NCCI_GETUNIT)
+/* Misc. */
+COMPATIBLE_IOCTL(0x41545900)            /* ATYIO_CLKR */
+COMPATIBLE_IOCTL(0x41545901)            /* ATYIO_CLKW */
+COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
+COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
+COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
+COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
+/* USB */
+COMPATIBLE_IOCTL(USBDEVFS_RESETEP)
+COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION)
+COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER)
+COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB)
+COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO)
+COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO)
+COMPATIBLE_IOCTL(USBDEVFS_RESET)
+COMPATIBLE_IOCTL(USBDEVFS_SUBMITURB32)
+COMPATIBLE_IOCTL(USBDEVFS_REAPURB32)
+COMPATIBLE_IOCTL(USBDEVFS_REAPURBNDELAY32)
+COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT)
+/* MTD */
+COMPATIBLE_IOCTL(MEMGETINFO)
+COMPATIBLE_IOCTL(MEMERASE)
+COMPATIBLE_IOCTL(MEMLOCK)
+COMPATIBLE_IOCTL(MEMUNLOCK)
+COMPATIBLE_IOCTL(MEMGETREGIONCOUNT)
+COMPATIBLE_IOCTL(MEMGETREGIONINFO)
+/* NBD */
+ULONG_IOCTL(NBD_SET_SOCK)
+ULONG_IOCTL(NBD_SET_BLKSIZE)
+ULONG_IOCTL(NBD_SET_SIZE)
+COMPATIBLE_IOCTL(NBD_DO_IT)
+COMPATIBLE_IOCTL(NBD_CLEAR_SOCK)
+COMPATIBLE_IOCTL(NBD_CLEAR_QUE)
+COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)
+ULONG_IOCTL(NBD_SET_SIZE_BLOCKS)
+COMPATIBLE_IOCTL(NBD_DISCONNECT)
+/* i2c */
+COMPATIBLE_IOCTL(I2C_SLAVE)
+COMPATIBLE_IOCTL(I2C_SLAVE_FORCE)
+COMPATIBLE_IOCTL(I2C_TENBIT)
+COMPATIBLE_IOCTL(I2C_PEC)
+COMPATIBLE_IOCTL(I2C_RETRIES)
+COMPATIBLE_IOCTL(I2C_TIMEOUT)
+/* wireless */
+COMPATIBLE_IOCTL(SIOCSIWCOMMIT)
+COMPATIBLE_IOCTL(SIOCGIWNAME)
+COMPATIBLE_IOCTL(SIOCSIWNWID)
+COMPATIBLE_IOCTL(SIOCGIWNWID)
+COMPATIBLE_IOCTL(SIOCSIWFREQ)
+COMPATIBLE_IOCTL(SIOCGIWFREQ)
+COMPATIBLE_IOCTL(SIOCSIWMODE)
+COMPATIBLE_IOCTL(SIOCGIWMODE)
+COMPATIBLE_IOCTL(SIOCSIWSENS)
+COMPATIBLE_IOCTL(SIOCGIWSENS)
+COMPATIBLE_IOCTL(SIOCSIWRANGE)
+COMPATIBLE_IOCTL(SIOCSIWPRIV)
+COMPATIBLE_IOCTL(SIOCGIWPRIV)
+COMPATIBLE_IOCTL(SIOCSIWSTATS)
+COMPATIBLE_IOCTL(SIOCGIWSTATS)
+COMPATIBLE_IOCTL(SIOCSIWAP)
+COMPATIBLE_IOCTL(SIOCGIWAP)
+COMPATIBLE_IOCTL(SIOCSIWSCAN)
+COMPATIBLE_IOCTL(SIOCSIWRATE)
+COMPATIBLE_IOCTL(SIOCGIWRATE)
+COMPATIBLE_IOCTL(SIOCSIWRTS)
+COMPATIBLE_IOCTL(SIOCGIWRTS)
+COMPATIBLE_IOCTL(SIOCSIWFRAG)
+COMPATIBLE_IOCTL(SIOCGIWFRAG)
+COMPATIBLE_IOCTL(SIOCSIWTXPOW)
+COMPATIBLE_IOCTL(SIOCGIWTXPOW)
+COMPATIBLE_IOCTL(SIOCSIWRETRY)
+COMPATIBLE_IOCTL(SIOCGIWRETRY)
+COMPATIBLE_IOCTL(SIOCSIWPOWER)
+COMPATIBLE_IOCTL(SIOCGIWPOWER)
+/* hiddev */
+COMPATIBLE_IOCTL(HIDIOCGVERSION)
+COMPATIBLE_IOCTL(HIDIOCAPPLICATION)
+COMPATIBLE_IOCTL(HIDIOCGDEVINFO)
+COMPATIBLE_IOCTL(HIDIOCGSTRING)
+COMPATIBLE_IOCTL(HIDIOCINITREPORT)
+COMPATIBLE_IOCTL(HIDIOCGREPORT)
+COMPATIBLE_IOCTL(HIDIOCSREPORT)
+COMPATIBLE_IOCTL(HIDIOCGREPORTINFO)
+COMPATIBLE_IOCTL(HIDIOCGFIELDINFO)
+COMPATIBLE_IOCTL(HIDIOCGUSAGE)
+COMPATIBLE_IOCTL(HIDIOCSUSAGE)
+COMPATIBLE_IOCTL(HIDIOCGUCODE)
+COMPATIBLE_IOCTL(HIDIOCGFLAG)
+COMPATIBLE_IOCTL(HIDIOCSFLAG)
+COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINDEX)
+COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINFO)
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
new file mode 100644
index 000000000000..152734055403
--- /dev/null
+++ b/include/linux/compiler-gcc.h
@@ -0,0 +1,17 @@
+/* Never include this file directly.  Include <linux/compiler.h> instead.  */
+
+/*
+ * Common definitions for all gcc versions go here.
+ */
+
+
+/* Optimization barrier */
+/* The "volatile" is due to gcc bugs */
+#define barrier() __asm__ __volatile__("": : :"memory")
+
+/* This macro obfuscates arithmetic on a variable address so that gcc
+   shouldn't recognize the original var, and make assumptions about it */
+#define RELOC_HIDE(ptr, off)                                    \
+  ({ unsigned long __ptr;                                       \
+    __asm__ ("" : "=g"(__ptr) : "0"(ptr));              \
+    (typeof(ptr)) (__ptr + (off)); })
diff --git a/include/linux/compiler-gcc2.h b/include/linux/compiler-gcc2.h
new file mode 100644
index 000000000000..5a359153ffd9
--- /dev/null
+++ b/include/linux/compiler-gcc2.h
@@ -0,0 +1,24 @@
+/* Never include this file directly.  Include <linux/compiler.h> instead.  */
+
+/* These definitions are for GCC v2.x.  */
+
+/* Somewhere in the middle of the GCC 2.96 development cycle, we implemented
+   a mechanism by which the user can annotate likely branch directions and
+   expect the blocks to be reordered appropriately.  Define __builtin_expect
+   to nothing for earlier compilers.  */
+#include <linux/compiler-gcc.h>
+
+#if __GNUC_MINOR__ < 96
+# define __builtin_expect(x, expected_value) (x)
+#endif
+
+#define __attribute_used__      __attribute__((__unused__))
+
+/*
+ * The attribute `pure' is not implemented in GCC versions earlier
+ * than 2.96.
+ */
+#if __GNUC_MINOR__ >= 96
+# define __attribute_pure__     __attribute__((pure))
+# define __attribute_const__    __attribute__((__const__))
+#endif
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
new file mode 100644
index 000000000000..a6fa615afab5
--- /dev/null
+++ b/include/linux/compiler-gcc3.h
@@ -0,0 +1,32 @@
+/* Never include this file directly.  Include <linux/compiler.h> instead.  */
+
+/* These definitions are for GCC v3.x.  */
+#include <linux/compiler-gcc.h>
+
+#if __GNUC_MINOR__ >= 1
+# define inline         inline          __attribute__((always_inline))
+# define __inline__     __inline__      __attribute__((always_inline))
+# define __inline       __inline        __attribute__((always_inline))
+#endif
+
+#if __GNUC_MINOR__ > 0
+# define __deprecated           __attribute__((deprecated))
+#endif
+
+#if __GNUC_MINOR__ >= 3
+# define __attribute_used__     __attribute__((__used__))
+#else
+# define __attribute_used__     __attribute__((__unused__))
+#endif
+
+#define __attribute_pure__      __attribute__((pure))
+#define __attribute_const__     __attribute__((__const__))
+
+#if __GNUC_MINOR__ >= 1
+#define  noinline               __attribute__((noinline))
+#endif
+
+#if __GNUC_MINOR__ >= 4
+#define __must_check            __attribute__((warn_unused_result))
+#endif
+
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
new file mode 100644
index 000000000000..53686c037a06
--- /dev/null
+++ b/include/linux/compiler-gcc4.h
@@ -0,0 +1,16 @@
+/* Never include this file directly.  Include <linux/compiler.h> instead.  */
+
+/* These definitions are for GCC v4.x.  */
+#include <linux/compiler-gcc.h>
+
+#define inline                  inline          __attribute__((always_inline))
+#define __inline__              __inline__      __attribute__((always_inline))
+#define __inline                __inline        __attribute__((always_inline))
+#define __deprecated            __attribute__((deprecated))
+#define __attribute_used__      __attribute__((__used__))
+#define __attribute_pure__      __attribute__((pure))
+#define __attribute_const__     __attribute__((__const__))
+#define  noinline               __attribute__((noinline))
+#define __must_check            __attribute__((warn_unused_result))
+#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
+
diff --git a/include/linux/compiler-intel.h b/include/linux/compiler-intel.h
new file mode 100644
index 000000000000..1d1c3ceaff4e
--- /dev/null
+++ b/include/linux/compiler-intel.h
@@ -0,0 +1,24 @@
+/* Never include this file directly.  Include <linux/compiler.h> instead.  */
+
+#ifdef __ECC
+
+/* Some compiler specific definitions are overwritten here
+ * for Intel ECC compiler
+ */
+
+#include <asm/intrinsics.h>
+
+/* Intel ECC compiler doesn't support gcc specific asm stmts.
+ * It uses intrinsics to do the equivalent things.
+ */
+#undef barrier
+#undef RELOC_HIDE
+
+#define barrier() __memory_barrier()
+
+#define RELOC_HIDE(ptr, off)                                    \
+  ({ unsigned long __ptr;                                       \
+     __ptr = (unsigned long) (ptr);                             \
+    (typeof(ptr)) (__ptr + (off)); })
+
+#endif
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
new file mode 100644
index 000000000000..487725cf0d0d
--- /dev/null
+++ b/include/linux/compiler.h
@@ -0,0 +1,152 @@
+#ifndef __LINUX_COMPILER_H
+#define __LINUX_COMPILER_H
+
+#ifndef __ASSEMBLY__
+
+#ifdef __CHECKER__
+# define __user         __attribute__((noderef, address_space(1)))
+# define __kernel       /* default address space */
+# define __safe         __attribute__((safe))
+# define __force        __attribute__((force))
+# define __nocast       __attribute__((nocast))
+# define __iomem        __attribute__((noderef, address_space(2)))
+# define __acquires(x)  __attribute__((context(0,1)))
+# define __releases(x)  __attribute__((context(1,0)))
+# define __acquire(x)   __context__(1)
+# define __release(x)   __context__(-1)
+# define __cond_lock(x) ((x) ? ({ __context__(1); 1; }) : 0)
+extern void __chk_user_ptr(void __user *);
+extern void __chk_io_ptr(void __iomem *);
+#else
+# define __user
+# define __kernel
+# define __safe
+# define __force
+# define __nocast
+# define __iomem
+# define __chk_user_ptr(x) (void)0
+# define __chk_io_ptr(x) (void)0
+# define __builtin_warning(x, y...) (1)
+# define __acquires(x)
+# define __releases(x)
+# define __acquire(x) (void)0
+# define __release(x) (void)0
+# define __cond_lock(x) (x)
+#endif
+
+#ifdef __KERNEL__
+
+#if __GNUC__ > 4
+#error no compiler-gcc.h file for this gcc version
+#elif __GNUC__ == 4
+# include <linux/compiler-gcc4.h>
+#elif __GNUC__ == 3
+# include <linux/compiler-gcc3.h>
+#elif __GNUC__ == 2
+# include <linux/compiler-gcc2.h>
+#else
+# error Sorry, your compiler is too old/not recognized.
+#endif
+
+/* Intel compiler defines __GNUC__. So we will overwrite implementations
+ * coming from above header files here
+ */
+#ifdef __INTEL_COMPILER
+# include <linux/compiler-intel.h>
+#endif
+
+/*
+ * Generic compiler-dependent macros required for kernel
+ * build go below this comment. Actual compiler/compiler version
+ * specific implementations come from the above header files
+ */
+
+#define likely(x)       __builtin_expect(!!(x), 1)
+#define unlikely(x)     __builtin_expect(!!(x), 0)
+
+/* Optimization barrier */
+#ifndef barrier
+# define barrier() __memory_barrier()
+#endif
+
+#ifndef RELOC_HIDE
+# define RELOC_HIDE(ptr, off)                                   \
+  ({ unsigned long __ptr;                                       \
+     __ptr = (unsigned long) (ptr);                             \
+    (typeof(ptr)) (__ptr + (off)); })
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASSEMBLY__ */
+
+/*
+ * Allow us to mark functions as 'deprecated' and have gcc emit a nice
+ * warning for each use, in hopes of speeding the functions removal.
+ * Usage is:
+ *              int __deprecated foo(void)
+ */
+#ifndef __deprecated
+# define __deprecated           /* unimplemented */
+#endif
+
+#ifndef __must_check
+#define __must_check
+#endif
+
+/*
+ * Allow us to avoid 'defined but not used' warnings on functions and data,
+ * as well as force them to be emitted to the assembly file.
+ *
+ * As of gcc 3.3, static functions that are not marked with attribute((used))
+ * may be elided from the assembly file.  As of gcc 3.3, static data not so
+ * marked will not be elided, but this may change in a future gcc version.
+ *
+ * In prior versions of gcc, such functions and data would be emitted, but
+ * would be warned about except with attribute((unused)).
+ */
+#ifndef __attribute_used__
+# define __attribute_used__     /* unimplemented */
+#endif
+
+/*
+ * From the GCC manual:
+ *
+ * Many functions have no effects except the return value and their
+ * return value depends only on the parameters and/or global
+ * variables.  Such a function can be subject to common subexpression
+ * elimination and loop optimization just as an arithmetic operator
+ * would be.
+ * [...]
+ */
+#ifndef __attribute_pure__
+# define __attribute_pure__     /* unimplemented */
+#endif
+
+/*
+ * From the GCC manual:
+ *
+ * Many functions do not examine any values except their arguments,
+ * and have no effects except the return value.  Basically this is
+ * just slightly more strict class than the `pure' attribute above,
+ * since function is not allowed to read global memory.
+ *
+ * Note that a function that has pointer arguments and examines the
+ * data pointed to must _not_ be declared `const'.  Likewise, a
+ * function that calls a non-`const' function usually must not be
+ * `const'.  It does not make sense for a `const' function to return
+ * `void'.
+ */
+#ifndef __attribute_const__
+# define __attribute_const__    /* unimplemented */
+#endif
+
+#ifndef noinline
+#define noinline
+#endif
+
+#ifndef __always_inline
+#define __always_inline inline
+#endif
+
+#endif /* __LINUX_COMPILER_H */
diff --git a/include/linux/completion.h b/include/linux/completion.h
new file mode 100644
index 000000000000..90663ad217f9
--- /dev/null
+++ b/include/linux/completion.h
@@ -0,0 +1,42 @@
+#ifndef __LINUX_COMPLETION_H
+#define __LINUX_COMPLETION_H
+
+/*
+ * (C) Copyright 2001 Linus Torvalds
+ *
+ * Atomic wait-for-completion handler data structures.
+ * See kernel/sched.c for details.
+ */
+
+#include <linux/wait.h>
+
+struct completion {
+        unsigned int done;
+        wait_queue_head_t wait;
+};
+
+#define COMPLETION_INITIALIZER(work) \
+        { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
+
+#define DECLARE_COMPLETION(work) \
+        struct completion work = COMPLETION_INITIALIZER(work)
+
+static inline void init_completion(struct completion *x)
+{
+        x->done = 0;
+        init_waitqueue_head(&x->wait);
+}
+
+extern void FASTCALL(wait_for_completion(struct completion *));
+extern int FASTCALL(wait_for_completion_interruptible(struct completion *x));
+extern unsigned long FASTCALL(wait_for_completion_timeout(struct completion *x,
+                                                   unsigned long timeout));
+extern unsigned long FASTCALL(wait_for_completion_interruptible_timeout(
+                        struct completion *x, unsigned long timeout));
+
+extern void FASTCALL(complete(struct completion *));
+extern void FASTCALL(complete_all(struct completion *));
+
+#define INIT_COMPLETION(x)      ((x).done = 0)
+
+#endif
diff --git a/include/linux/comstats.h b/include/linux/comstats.h
new file mode 100644
index 000000000000..3f5ea8e8026d
--- /dev/null
+++ b/include/linux/comstats.h
@@ -0,0 +1,119 @@
+/*****************************************************************************/
+
+/*
+ *      comstats.h  -- Serial Port Stats.
+ *
+ *      Copyright (C) 1996-1998  Stallion Technologies
+ *      Copyright (C) 1994-1996  Greg Ungerer.
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*****************************************************************************/
+#ifndef _COMSTATS_H
+#define _COMSTATS_H
+/*****************************************************************************/
+
+/*
+ *      Serial port stats structure. The structure itself is UART
+ *      independent, but some fields may be UART/driver specific (for
+ *      example state).
+ */
+
+typedef struct {
+        unsigned long   brd;
+        unsigned long   panel;
+        unsigned long   port;
+        unsigned long   hwid;
+        unsigned long   type;
+        unsigned long   txtotal;
+        unsigned long   rxtotal;
+        unsigned long   txbuffered;
+        unsigned long   rxbuffered;
+        unsigned long   rxoverrun;
+        unsigned long   rxparity;
+        unsigned long   rxframing;
+        unsigned long   rxlost;
+        unsigned long   txbreaks;
+        unsigned long   rxbreaks;
+        unsigned long   txxon;
+        unsigned long   txxoff;
+        unsigned long   rxxon;
+        unsigned long   rxxoff;
+        unsigned long   txctson;
+        unsigned long   txctsoff;
+        unsigned long   rxrtson;
+        unsigned long   rxrtsoff;
+        unsigned long   modem;
+        unsigned long   state;
+        unsigned long   flags;
+        unsigned long   ttystate;
+        unsigned long   cflags;
+        unsigned long   iflags;
+        unsigned long   oflags;
+        unsigned long   lflags;
+        unsigned long   signals;
+} comstats_t;
+
+
+/*
+ *      Board stats structure. Returns useful info about the board.
+ */
+
+#define COM_MAXPANELS   8
+
+typedef struct {
+        unsigned long   panel;
+        unsigned long   type;
+        unsigned long   hwid;
+        unsigned long   nrports;
+} companel_t;
+
+typedef struct {
+        unsigned long   brd;
+        unsigned long   type;
+        unsigned long   hwid;
+        unsigned long   state;
+        unsigned long   ioaddr;
+        unsigned long   ioaddr2;
+        unsigned long   memaddr;
+        unsigned long   irq;
+        unsigned long   nrpanels;
+        unsigned long   nrports;
+        companel_t      panels[COM_MAXPANELS];
+} combrd_t;
+
+
+/*
+ *      Define the ioctl operations for stats stuff.
+ */
+#include <linux/ioctl.h>
+
+#define COM_GETPORTSTATS        _IO('c',30)
+#define COM_CLRPORTSTATS        _IO('c',31)
+#define COM_GETBRDSTATS         _IO('c',32)
+
+
+/*
+ *      Define the set of ioctls that give user level access to the
+ *      private port, panel and board structures. The argument required
+ *      will be driver dependent!  
+ */
+#define COM_READPORT            _IO('c',40)
+#define COM_READBOARD           _IO('c',41)
+#define COM_READPANEL           _IO('c',42)
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/concap.h b/include/linux/concap.h
new file mode 100644
index 000000000000..27304651d700
--- /dev/null
+++ b/include/linux/concap.h
@@ -0,0 +1,113 @@
+/* $Id: concap.h,v 1.3.2.2 2004/01/12 23:08:35 keil Exp $
+ *
+ * Copyright 1997 by Henner Eisen <eis@baty.hanse.de>
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ */
+
+#ifndef _LINUX_CONCAP_H
+#define _LINUX_CONCAP_H
+#ifdef __KERNEL__
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+
+/* Stuff to support encapsulation protocols genericly. The encapsulation
+   protocol is processed at the uppermost layer of the network interface.
+
+   Based on a ideas developed in a 'synchronous device' thread in the
+   linux-x25 mailing list contributed by Alan Cox, Thomasz Motylewski
+   and Jonathan Naylor.
+
+   For more documetation on this refer to Documentation/isdn/README.concap
+*/
+
+struct concap_proto_ops;
+struct concap_device_ops;
+
+/* this manages all data needed by the encapsulation protocol
+ */
+struct concap_proto{
+        struct net_device *net_dev;     /* net device using our service  */
+        struct concap_device_ops *dops; /* callbacks provided by device */
+        struct concap_proto_ops  *pops; /* callbacks provided by us */
+        spinlock_t lock;
+        int flags;
+        void *proto_data;               /* protocol specific private data, to
+                                           be accessed via *pops methods only*/
+        /*
+          :
+          whatever 
+          :
+          */
+};
+
+/* Operations to be supported by the net device. Called by the encapsulation
+ * protocol entity. No receive method is offered because the encapsulation
+ * protocol directly calls netif_rx().
+ */
+struct concap_device_ops{
+
+        /* to request data is submitted by device*/ 
+        int (*data_req)(struct concap_proto *, struct sk_buff *);
+
+        /* Control methods must be set to NULL by devices which do not
+           support connection control.*/
+        /* to request a connection is set up */ 
+        int (*connect_req)(struct concap_proto *);
+
+        /* to request a connection is released */
+        int (*disconn_req)(struct concap_proto *);      
+};
+
+/* Operations to be supported by the encapsulation protocol. Called by
+ * device driver.
+ */
+struct concap_proto_ops{
+
+        /* create a new encapsulation protocol instance of same type */
+        struct concap_proto *  (*proto_new) (void);
+
+        /* delete encapsulation protocol instance and free all its resources.
+           cprot may no loger be referenced after calling this */
+        void (*proto_del)(struct concap_proto *cprot);
+
+        /* initialize the protocol's data. To be called at interface startup
+           or when the device driver resets the interface. All services of the
+           encapsulation protocol may be used after this*/
+        int (*restart)(struct concap_proto *cprot, 
+                       struct net_device *ndev,
+                       struct concap_device_ops *dops);
+
+        /* inactivate an encapsulation protocol instance. The encapsulation
+           protocol may not call any *dops methods after this. */
+        int (*close)(struct concap_proto *cprot);
+
+        /* process a frame handed down to us by upper layer */
+        int (*encap_and_xmit)(struct concap_proto *cprot, struct sk_buff *skb);
+
+        /* to be called for each data entity received from lower layer*/ 
+        int (*data_ind)(struct concap_proto *cprot, struct sk_buff *skb);
+
+        /* to be called when a connection was set up/down.
+           Protocols that don't process these primitives might fill in
+           dummy methods here */
+        int (*connect_ind)(struct concap_proto *cprot);
+        int (*disconn_ind)(struct concap_proto *cprot);
+  /*
+    Some network device support functions, like net_header(), rebuild_header(),
+    and others, that depend solely on the encapsulation protocol, might
+    be provided here, too. The net device would just fill them in its
+    corresponding fields when it is opened.
+    */
+};
+
+/* dummy restart/close/connect/reset/disconn methods
+ */
+extern int concap_nop(struct concap_proto *cprot); 
+
+/* dummy submit method
+ */
+extern int concap_drop_skb(struct concap_proto *cprot, struct sk_buff *skb);
+#endif
+#endif
diff --git a/include/linux/config.h b/include/linux/config.h
new file mode 100644
index 000000000000..9d1c14f7ad6d
--- /dev/null
+++ b/include/linux/config.h
@@ -0,0 +1,6 @@
+#ifndef _LINUX_CONFIG_H
+#define _LINUX_CONFIG_H
+
+#include <linux/autoconf.h>
+
+#endif
diff --git a/include/linux/console.h b/include/linux/console.h
new file mode 100644
index 000000000000..721371382ae5
--- /dev/null
+++ b/include/linux/console.h
@@ -0,0 +1,133 @@
+/*
+ *  linux/include/linux/console.h
+ *
+ *  Copyright (C) 1993        Hamish Macdonald
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive
+ * for more details.
+ *
+ * Changed:
+ * 10-Mar-94: Arno Griffioen: Conversion for vt100 emulator port from PC LINUX
+ */
+
+#ifndef _LINUX_CONSOLE_H_
+#define _LINUX_CONSOLE_H_ 1
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+
+struct vc_data;
+struct console_font_op;
+struct console_font;
+struct module;
+
+/*
+ * this is what the terminal answers to a ESC-Z or csi0c query.
+ */
+#define VT100ID "\033[?1;2c"
+#define VT102ID "\033[?6c"
+
+struct consw {
+        struct module *owner;
+        const char *(*con_startup)(void);
+        void    (*con_init)(struct vc_data *, int);
+        void    (*con_deinit)(struct vc_data *);
+        void    (*con_clear)(struct vc_data *, int, int, int, int);
+        void    (*con_putc)(struct vc_data *, int, int, int);
+        void    (*con_putcs)(struct vc_data *, const unsigned short *, int, int, int);
+        void    (*con_cursor)(struct vc_data *, int);
+        int     (*con_scroll)(struct vc_data *, int, int, int, int);
+        void    (*con_bmove)(struct vc_data *, int, int, int, int, int, int);
+        int     (*con_switch)(struct vc_data *);
+        int     (*con_blank)(struct vc_data *, int, int);
+        int     (*con_font_set)(struct vc_data *, struct console_font *, unsigned);
+        int     (*con_font_get)(struct vc_data *, struct console_font *);
+        int     (*con_font_default)(struct vc_data *, struct console_font *, char *);
+        int     (*con_font_copy)(struct vc_data *, int);
+        int     (*con_resize)(struct vc_data *, unsigned int, unsigned int);
+        int     (*con_set_palette)(struct vc_data *, unsigned char *);
+        int     (*con_scrolldelta)(struct vc_data *, int);
+        int     (*con_set_origin)(struct vc_data *);
+        void    (*con_save_screen)(struct vc_data *);
+        u8      (*con_build_attr)(struct vc_data *, u8, u8, u8, u8, u8);
+        void    (*con_invert_region)(struct vc_data *, u16 *, int);
+        u16    *(*con_screen_pos)(struct vc_data *, int);
+        unsigned long (*con_getxy)(struct vc_data *, unsigned long, int *, int *);
+};
+
+extern const struct consw *conswitchp;
+
+extern const struct consw dummy_con;    /* dummy console buffer */
+extern const struct consw vga_con;      /* VGA text console */
+extern const struct consw newport_con;  /* SGI Newport console  */
+extern const struct consw prom_con;     /* SPARC PROM console */
+
+int take_over_console(const struct consw *sw, int first, int last, int deflt);
+void give_up_console(const struct consw *sw);
+
+/* scroll */
+#define SM_UP       (1)
+#define SM_DOWN     (2)
+
+/* cursor */
+#define CM_DRAW     (1)
+#define CM_ERASE    (2)
+#define CM_MOVE     (3)
+
+/*
+ * The interface for a console, or any other device that wants to capture
+ * console messages (printer driver?)
+ *
+ * If a console driver is marked CON_BOOT then it will be auto-unregistered
+ * when the first real console is registered.  This is for early-printk drivers.
+ */
+
+#define CON_PRINTBUFFER (1)
+#define CON_CONSDEV     (2) /* Last on the command line */
+#define CON_ENABLED     (4)
+#define CON_BOOT        (8)
+
+struct console
+{
+        char    name[8];
+        void    (*write)(struct console *, const char *, unsigned);
+        int     (*read)(struct console *, char *, unsigned);
+        struct tty_driver *(*device)(struct console *, int *);
+        void    (*unblank)(void);
+        int     (*setup)(struct console *, char *);
+        short   flags;
+        short   index;
+        int     cflag;
+        void    *data;
+        struct   console *next;
+};
+
+extern int add_preferred_console(char *name, int idx, char *options);
+extern void register_console(struct console *);
+extern int unregister_console(struct console *);
+extern struct console *console_drivers;
+extern void acquire_console_sem(void);
+extern int try_acquire_console_sem(void);
+extern void release_console_sem(void);
+extern void console_conditional_schedule(void);
+extern void console_unblank(void);
+extern struct tty_driver *console_device(int *);
+extern void console_stop(struct console *);
+extern void console_start(struct console *);
+extern int is_console_locked(void);
+
+/* Some debug stub to catch some of the obvious races in the VT code */
+#if 1
+#define WARN_CONSOLE_UNLOCKED() WARN_ON(!is_console_locked() && !oops_in_progress)
+#else
+#define WARN_CONSOLE_UNLOCKED()
+#endif
+
+/* VESA Blanking Levels */
+#define VESA_NO_BLANKING        0
+#define VESA_VSYNC_SUSPEND      1
+#define VESA_HSYNC_SUSPEND      2
+#define VESA_POWERDOWN          3
+
+#endif /* _LINUX_CONSOLE_H */
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
new file mode 100644
index 000000000000..725be90ef55e
--- /dev/null
+++ b/include/linux/console_struct.h
@@ -0,0 +1,123 @@
+/*
+ * console_struct.h
+ *
+ * Data structure describing single virtual console except for data
+ * used by vt.c.
+ *
+ * Fields marked with [#] must be set by the low-level driver.
+ * Fields marked with [!] can be changed by the low-level driver
+ * to achieve effects such as fast scrolling by changing the origin.
+ */
+
+struct vt_struct;
+
+#define NPAR 16
+
+struct vc_data {
+        unsigned short  vc_num;                 /* Console number */
+        unsigned int    vc_cols;                /* [#] Console size */
+        unsigned int    vc_rows;
+        unsigned int    vc_size_row;            /* Bytes per row */
+        unsigned int    vc_scan_lines;          /* # of scan lines */
+        unsigned long   vc_origin;              /* [!] Start of real screen */
+        unsigned long   vc_scr_end;             /* [!] End of real screen */
+        unsigned long   vc_visible_origin;      /* [!] Top of visible window */
+        unsigned int    vc_top, vc_bottom;      /* Scrolling region */
+        const struct consw *vc_sw;
+        unsigned short  *vc_screenbuf;          /* In-memory character/attribute buffer */
+        unsigned int    vc_screenbuf_size;
+        unsigned char   vc_mode;                /* KD_TEXT, ... */
+        /* attributes for all characters on screen */
+        unsigned char   vc_attr;                /* Current attributes */
+        unsigned char   vc_def_color;           /* Default colors */
+        unsigned char   vc_color;               /* Foreground & background */
+        unsigned char   vc_s_color;             /* Saved foreground & background */
+        unsigned char   vc_ulcolor;             /* Color for underline mode */
+        unsigned char   vc_halfcolor;           /* Color for half intensity mode */
+        /* cursor */
+        unsigned int    vc_cursor_type;
+        unsigned short  vc_complement_mask;     /* [#] Xor mask for mouse pointer */
+        unsigned short  vc_s_complement_mask;   /* Saved mouse pointer mask */
+        unsigned int    vc_x, vc_y;             /* Cursor position */
+        unsigned int    vc_saved_x, vc_saved_y;
+        unsigned long   vc_pos;                 /* Cursor address */
+        /* fonts */     
+        unsigned short  vc_hi_font_mask;        /* [#] Attribute set for upper 256 chars of font or 0 if not supported */
+        struct console_font vc_font;            /* Current VC font set */
+        unsigned short  vc_video_erase_char;    /* Background erase character */
+        /* VT terminal data */
+        unsigned int    vc_state;               /* Escape sequence parser state */
+        unsigned int    vc_npar,vc_par[NPAR];   /* Parameters of current escape sequence */
+        struct tty_struct *vc_tty;              /* TTY we are attached to */
+        /* data for manual vt switching */
+        struct vt_mode  vt_mode;
+        int             vt_pid;
+        int             vt_newvt;
+        wait_queue_head_t paste_wait;
+        /* mode flags */
+        unsigned int    vc_charset      : 1;    /* Character set G0 / G1 */
+        unsigned int    vc_s_charset    : 1;    /* Saved character set */
+        unsigned int    vc_disp_ctrl    : 1;    /* Display chars < 32? */
+        unsigned int    vc_toggle_meta  : 1;    /* Toggle high bit? */
+        unsigned int    vc_decscnm      : 1;    /* Screen Mode */
+        unsigned int    vc_decom        : 1;    /* Origin Mode */
+        unsigned int    vc_decawm       : 1;    /* Autowrap Mode */
+        unsigned int    vc_deccm        : 1;    /* Cursor Visible */
+        unsigned int    vc_decim        : 1;    /* Insert Mode */
+        unsigned int    vc_deccolm      : 1;    /* 80/132 Column Mode */
+        /* attribute flags */
+        unsigned int    vc_intensity    : 2;    /* 0=half-bright, 1=normal, 2=bold */
+        unsigned int    vc_underline    : 1;
+        unsigned int    vc_blink        : 1;
+        unsigned int    vc_reverse      : 1;
+        unsigned int    vc_s_intensity  : 2;    /* saved rendition */
+        unsigned int    vc_s_underline  : 1;
+        unsigned int    vc_s_blink      : 1;
+        unsigned int    vc_s_reverse    : 1;
+        /* misc */
+        unsigned int    vc_ques         : 1;
+        unsigned int    vc_need_wrap    : 1;
+        unsigned int    vc_can_do_color : 1;
+        unsigned int    vc_report_mouse : 2;
+        unsigned int    vc_kmalloced    : 1;
+        unsigned char   vc_utf          : 1;    /* Unicode UTF-8 encoding */
+        unsigned char   vc_utf_count;
+                 int    vc_utf_char;
+        unsigned int    vc_tab_stop[8];         /* Tab stops. 256 columns. */
+        unsigned char   vc_palette[16*3];       /* Colour palette for VGA+ */
+        unsigned short * vc_translate;
+        unsigned char   vc_G0_charset;
+        unsigned char   vc_G1_charset;
+        unsigned char   vc_saved_G0;
+        unsigned char   vc_saved_G1;
+        unsigned int    vc_bell_pitch;          /* Console bell pitch */
+        unsigned int    vc_bell_duration;       /* Console bell duration */
+        struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
+        unsigned long   vc_uni_pagedir;
+        unsigned long   *vc_uni_pagedir_loc;  /* [!] Location of uni_pagedir variable for this console */
+        /* additional information is in vt_kern.h */
+};
+
+struct vc {
+        struct vc_data *d;
+
+        /* might add  scrmem, vt_struct, kbd  at some time,
+           to have everything in one place - the disadvantage
+           would be that vc_cons etc can no longer be static */
+};
+
+extern struct vc vc_cons [MAX_NR_CONSOLES];
+
+#define CUR_DEF         0
+#define CUR_NONE        1
+#define CUR_UNDERLINE   2
+#define CUR_LOWER_THIRD 3
+#define CUR_LOWER_HALF  4
+#define CUR_TWO_THIRDS  5
+#define CUR_BLOCK       6
+#define CUR_HWMASK      0x0f
+#define CUR_SWMASK      0xfff0
+
+#define CUR_DEFAULT CUR_UNDERLINE
+
+#define CON_IS_VISIBLE(conp) (*conp->vc_display_fg == conp)
diff --git a/include/linux/consolemap.h b/include/linux/consolemap.h
new file mode 100644
index 000000000000..65842efc1b70
--- /dev/null
+++ b/include/linux/consolemap.h
@@ -0,0 +1,15 @@
+/*
+ * consolemap.h
+ *
+ * Interface between console.c, selection.c  and consolemap.c
+ */
+#define LAT1_MAP 0
+#define GRAF_MAP 1
+#define IBMPC_MAP 2
+#define USER_MAP 3
+
+struct vc_data;
+
+extern unsigned char inverse_translate(struct vc_data *conp, int glyph);
+extern unsigned short *set_translate(int m, struct vc_data *vc);
+extern int conv_uni_to_pc(struct vc_data *conp, long ucs);
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
new file mode 100644
index 000000000000..fe0298e5dae1
--- /dev/null
+++ b/include/linux/cpu.h
@@ -0,0 +1,83 @@
+/*
+ * include/linux/cpu.h - generic cpu definition
+ *
+ * This is mainly for topological representation. We define the 
+ * basic 'struct cpu' here, which can be embedded in per-arch 
+ * definitions of processors.
+ *
+ * Basic handling of the devices is done in drivers/base/cpu.c
+ * and system devices are handled in drivers/base/sys.c. 
+ *
+ * CPUs are exported via driverfs in the class/cpu/devices/
+ * directory. 
+ *
+ * Per-cpu interfaces can be implemented using a struct device_interface. 
+ * See the following for how to do this: 
+ * - drivers/base/intf.c 
+ * - Documentation/driver-model/interface.txt
+ */
+#ifndef _LINUX_CPU_H_
+#define _LINUX_CPU_H_
+
+#include <linux/sysdev.h>
+#include <linux/node.h>
+#include <linux/compiler.h>
+#include <linux/cpumask.h>
+#include <asm/semaphore.h>
+
+struct cpu {
+        int node_id;            /* The node which contains the CPU */
+        int no_control;         /* Should the sysfs control file be created? */
+        struct sys_device sysdev;
+};
+
+extern int register_cpu(struct cpu *, int, struct node *);
+#ifdef CONFIG_HOTPLUG_CPU
+extern void unregister_cpu(struct cpu *, struct node *);
+#endif
+struct notifier_block;
+
+#ifdef CONFIG_SMP
+/* Need to know about CPUs going up/down? */
+extern int register_cpu_notifier(struct notifier_block *nb);
+extern void unregister_cpu_notifier(struct notifier_block *nb);
+
+int cpu_up(unsigned int cpu);
+
+#else
+
+static inline int register_cpu_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
+static inline void unregister_cpu_notifier(struct notifier_block *nb)
+{
+}
+
+#endif /* CONFIG_SMP */
+extern struct sysdev_class cpu_sysdev_class;
+
+#ifdef CONFIG_HOTPLUG_CPU
+/* Stop CPUs going up and down. */
+extern struct semaphore cpucontrol;
+#define lock_cpu_hotplug()      down(&cpucontrol)
+#define unlock_cpu_hotplug()    up(&cpucontrol)
+#define lock_cpu_hotplug_interruptible() down_interruptible(&cpucontrol)
+#define hotcpu_notifier(fn, pri) {                              \
+        static struct notifier_block fn##_nb =                  \
+                { .notifier_call = fn, .priority = pri };       \
+        register_cpu_notifier(&fn##_nb);                        \
+}
+int cpu_down(unsigned int cpu);
+#define cpu_is_offline(cpu) unlikely(!cpu_online(cpu))
+#else
+#define lock_cpu_hotplug()      do { } while (0)
+#define unlock_cpu_hotplug()    do { } while (0)
+#define lock_cpu_hotplug_interruptible() 0
+#define hotcpu_notifier(fn, pri)
+
+/* CPUs don't go offline once they're online w/o CONFIG_HOTPLUG_CPU */
+static inline int cpu_is_offline(int cpu) { return 0; }
+#endif
+
+#endif /* _LINUX_CPU_H_ */
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
new file mode 100644
index 000000000000..910eca35583d
--- /dev/null
+++ b/include/linux/cpufreq.h
@@ -0,0 +1,328 @@
+/*
+ *  linux/include/linux/cpufreq.h
+ *
+ *  Copyright (C) 2001 Russell King
+ *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
+ *            
+ *
+ * $Id: cpufreq.h,v 1.36 2003/01/20 17:31:48 db Exp $
+ *
+ * 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 _LINUX_CPUFREQ_H
+#define _LINUX_CPUFREQ_H
+
+#include <linux/config.h>
+#include <linux/notifier.h>
+#include <linux/threads.h>
+#include <linux/device.h>
+#include <linux/kobject.h>
+#include <linux/sysfs.h>
+#include <linux/completion.h>
+#include <linux/workqueue.h>
+#include <linux/cpumask.h>
+
+#define CPUFREQ_NAME_LEN 16
+
+
+/*********************************************************************
+ *                     CPUFREQ NOTIFIER INTERFACE                    *
+ *********************************************************************/
+
+int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
+int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
+
+#define CPUFREQ_TRANSITION_NOTIFIER     (0)
+#define CPUFREQ_POLICY_NOTIFIER         (1)
+
+
+/* if (cpufreq_driver->target) exists, the ->governor decides what frequency
+ * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
+ * two generic policies are available:
+ */
+
+#define CPUFREQ_POLICY_POWERSAVE        (1)
+#define CPUFREQ_POLICY_PERFORMANCE      (2)
+
+/* Frequency values here are CPU kHz so that hardware which doesn't run 
+ * with some frequencies can complain without having to guess what per 
+ * cent / per mille means. 
+ * Maximum transition latency is in microseconds - if it's unknown,
+ * CPUFREQ_ETERNAL shall be used.
+ */
+
+struct cpufreq_governor;
+
+#define CPUFREQ_ETERNAL                 (-1)
+struct cpufreq_cpuinfo {
+        unsigned int            max_freq;
+        unsigned int            min_freq;
+        unsigned int            transition_latency; /* in 10^(-9) s = nanoseconds */
+};
+
+struct cpufreq_real_policy {
+        unsigned int            min;    /* in kHz */
+        unsigned int            max;    /* in kHz */
+        unsigned int            policy; /* see above */
+        struct cpufreq_governor *governor; /* see below */
+};
+
+struct cpufreq_policy {
+        cpumask_t               cpus;   /* affected CPUs */
+        unsigned int            cpu;    /* cpu nr of registered CPU */
+        struct cpufreq_cpuinfo  cpuinfo;/* see above */
+
+        unsigned int            min;    /* in kHz */
+        unsigned int            max;    /* in kHz */
+        unsigned int            cur;    /* in kHz, only needed if cpufreq
+                                         * governors are used */
+        unsigned int            policy; /* see above */
+        struct cpufreq_governor *governor; /* see below */
+
+        struct semaphore        lock;   /* CPU ->setpolicy or ->target may
+                                           only be called once a time */
+
+        struct work_struct      update; /* if update_policy() needs to be
+                                         * called, but you're in IRQ context */
+
+        struct cpufreq_real_policy      user_policy;
+
+        struct kobject          kobj;
+        struct completion       kobj_unregister;
+};
+
+#define CPUFREQ_ADJUST          (0)
+#define CPUFREQ_INCOMPATIBLE    (1)
+#define CPUFREQ_NOTIFY          (2)
+
+
+/******************** cpufreq transition notifiers *******************/
+
+#define CPUFREQ_PRECHANGE       (0)
+#define CPUFREQ_POSTCHANGE      (1)
+#define CPUFREQ_RESUMECHANGE    (8)
+
+struct cpufreq_freqs {
+        unsigned int cpu;       /* cpu nr */
+        unsigned int old;
+        unsigned int new;
+        u8 flags;               /* flags of cpufreq_driver, see below. */
+};
+
+
+/**
+ * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe)
+ * @old:   old value
+ * @div:   divisor
+ * @mult:  multiplier
+ *
+ *
+ *    new = old * mult / div
+ */
+static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult)
+{
+#if BITS_PER_LONG == 32
+
+        u64 result = ((u64) old) * ((u64) mult);
+        do_div(result, div);
+        return (unsigned long) result;
+
+#elif BITS_PER_LONG == 64
+
+        unsigned long result = old * ((u64) mult);
+        result /= div;
+        return result;
+
+#endif
+};
+
+/*********************************************************************
+ *                          CPUFREQ GOVERNORS                        *
+ *********************************************************************/
+
+#define CPUFREQ_GOV_START  1
+#define CPUFREQ_GOV_STOP   2
+#define CPUFREQ_GOV_LIMITS 3
+
+struct cpufreq_governor {
+        char    name[CPUFREQ_NAME_LEN];
+        int     (*governor)     (struct cpufreq_policy *policy,
+                                 unsigned int event);
+        struct list_head        governor_list;
+        struct module           *owner;
+};
+
+/* pass a target to the cpufreq driver 
+ */
+extern int cpufreq_driver_target(struct cpufreq_policy *policy,
+                                 unsigned int target_freq,
+                                 unsigned int relation);
+extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
+                                   unsigned int target_freq,
+                                   unsigned int relation);
+
+
+/* pass an event to the cpufreq governor */
+int cpufreq_governor(unsigned int cpu, unsigned int event);
+
+int cpufreq_register_governor(struct cpufreq_governor *governor);
+void cpufreq_unregister_governor(struct cpufreq_governor *governor);
+
+
+/*********************************************************************
+ *                      CPUFREQ DRIVER INTERFACE                     *
+ *********************************************************************/
+
+#define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
+#define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
+
+struct freq_attr;
+
+struct cpufreq_driver {
+        struct module           *owner;
+        char                    name[CPUFREQ_NAME_LEN];
+        u8                      flags;
+
+        /* needed by all drivers */
+        int     (*init)         (struct cpufreq_policy *policy);
+        int     (*verify)       (struct cpufreq_policy *policy);
+
+        /* define one out of two */
+        int     (*setpolicy)    (struct cpufreq_policy *policy);
+        int     (*target)       (struct cpufreq_policy *policy,
+                                 unsigned int target_freq,
+                                 unsigned int relation);
+
+        /* should be defined, if possible */
+        unsigned int    (*get)  (unsigned int cpu);
+
+        /* optional */
+        int     (*exit)         (struct cpufreq_policy *policy);
+        int     (*resume)       (struct cpufreq_policy *policy);
+        struct freq_attr        **attr;
+};
+
+/* flags */
+
+#define CPUFREQ_STICKY          0x01    /* the driver isn't removed even if 
+                                         * all ->init() calls failed */
+#define CPUFREQ_CONST_LOOPS     0x02    /* loops_per_jiffy or other kernel
+                                         * "constants" aren't affected by
+                                         * frequency transitions */
+
+
+int cpufreq_register_driver(struct cpufreq_driver *driver_data);
+int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
+
+
+void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state);
+
+
+static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 
+{
+        if (policy->min < min)
+                policy->min = min;
+        if (policy->max < min)
+                policy->max = min;
+        if (policy->min > max)
+                policy->min = max;
+        if (policy->max > max)
+                policy->max = max;
+        if (policy->min > policy->max)
+                policy->min = policy->max;
+        return;
+}
+
+struct freq_attr {
+        struct attribute attr;
+        ssize_t (*show)(struct cpufreq_policy *, char *);
+        ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
+};
+
+
+/*********************************************************************
+ *                        CPUFREQ 2.6. INTERFACE                     *
+ *********************************************************************/
+int cpufreq_set_policy(struct cpufreq_policy *policy);
+int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
+int cpufreq_update_policy(unsigned int cpu);
+
+/* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */
+unsigned int cpufreq_get(unsigned int cpu);
+
+
+/*********************************************************************
+ *                       CPUFREQ DEFAULT GOVERNOR                    *
+ *********************************************************************/
+
+
+#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
+extern struct cpufreq_governor cpufreq_gov_performance;
+#define CPUFREQ_DEFAULT_GOVERNOR        &cpufreq_gov_performance
+#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
+extern struct cpufreq_governor cpufreq_gov_userspace;
+#define CPUFREQ_DEFAULT_GOVERNOR        &cpufreq_gov_userspace
+#endif
+
+
+/*********************************************************************
+ *                     FREQUENCY TABLE HELPERS                       *
+ *********************************************************************/
+
+#define CPUFREQ_ENTRY_INVALID ~0
+#define CPUFREQ_TABLE_END     ~1
+
+struct cpufreq_frequency_table {
+        unsigned int    index;     /* any */
+        unsigned int    frequency; /* kHz - doesn't need to be in ascending
+                                    * order */
+};
+
+int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
+                                    struct cpufreq_frequency_table *table);
+
+int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
+                                   struct cpufreq_frequency_table *table);
+
+int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
+                                   struct cpufreq_frequency_table *table,
+                                   unsigned int target_freq,
+                                   unsigned int relation,
+                                   unsigned int *index);
+
+/* the following 3 funtions are for cpufreq core use only */
+struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
+struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
+void   cpufreq_cpu_put (struct cpufreq_policy *data);
+
+/* the following are really really optional */
+extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
+
+void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 
+                                      unsigned int cpu);
+
+void cpufreq_frequency_table_put_attr(unsigned int cpu);
+
+
+/*********************************************************************
+ *                     UNIFIED DEBUG HELPERS                         *
+ *********************************************************************/
+
+#define CPUFREQ_DEBUG_CORE      1
+#define CPUFREQ_DEBUG_DRIVER    2
+#define CPUFREQ_DEBUG_GOVERNOR  4
+
+#ifdef CONFIG_CPU_FREQ_DEBUG
+
+extern void cpufreq_debug_printk(unsigned int type, const char *prefix, 
+                                 const char *fmt, ...);
+
+#else
+
+#define cpufreq_debug_printk(msg...) do { } while(0)
+
+#endif /* CONFIG_CPU_FREQ_DEBUG */
+
+#endif /* _LINUX_CPUFREQ_H */
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
new file mode 100644
index 000000000000..b15826f6e3a2
--- /dev/null
+++ b/include/linux/cpumask.h
@@ -0,0 +1,395 @@
+#ifndef __LINUX_CPUMASK_H
+#define __LINUX_CPUMASK_H
+
+/*
+ * Cpumasks provide a bitmap suitable for representing the
+ * set of CPU's in a system, one bit position per CPU number.
+ *
+ * See detailed comments in the file linux/bitmap.h describing the
+ * data type on which these cpumasks are based.
+ *
+ * For details of cpumask_scnprintf() and cpumask_parse(),
+ * see bitmap_scnprintf() and bitmap_parse() in lib/bitmap.c.
+ * For details of cpulist_scnprintf() and cpulist_parse(), see
+ * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
+ *
+ * The available cpumask operations are:
+ *
+ * void cpu_set(cpu, mask)              turn on bit 'cpu' in mask
+ * void cpu_clear(cpu, mask)            turn off bit 'cpu' in mask
+ * void cpus_setall(mask)               set all bits
+ * void cpus_clear(mask)                clear all bits
+ * int cpu_isset(cpu, mask)             true iff bit 'cpu' set in mask
+ * int cpu_test_and_set(cpu, mask)      test and set bit 'cpu' in mask
+ *
+ * void cpus_and(dst, src1, src2)       dst = src1 & src2  [intersection]
+ * void cpus_or(dst, src1, src2)        dst = src1 | src2  [union]
+ * void cpus_xor(dst, src1, src2)       dst = src1 ^ src2
+ * void cpus_andnot(dst, src1, src2)    dst = src1 & ~src2
+ * void cpus_complement(dst, src)       dst = ~src
+ *
+ * int cpus_equal(mask1, mask2)         Does mask1 == mask2?
+ * int cpus_intersects(mask1, mask2)    Do mask1 and mask2 intersect?
+ * int cpus_subset(mask1, mask2)        Is mask1 a subset of mask2?
+ * int cpus_empty(mask)                 Is mask empty (no bits sets)?
+ * int cpus_full(mask)                  Is mask full (all bits sets)?
+ * int cpus_weight(mask)                Hamming weigh - number of set bits
+ *
+ * void cpus_shift_right(dst, src, n)   Shift right
+ * void cpus_shift_left(dst, src, n)    Shift left
+ *
+ * int first_cpu(mask)                  Number lowest set bit, or NR_CPUS
+ * int next_cpu(cpu, mask)              Next cpu past 'cpu', or NR_CPUS
+ *
+ * cpumask_t cpumask_of_cpu(cpu)        Return cpumask with bit 'cpu' set
+ * CPU_MASK_ALL                         Initializer - all bits set
+ * CPU_MASK_NONE                        Initializer - no bits set
+ * unsigned long *cpus_addr(mask)       Array of unsigned long's in mask
+ *
+ * int cpumask_scnprintf(buf, len, mask) Format cpumask for printing
+ * int cpumask_parse(ubuf, ulen, mask)  Parse ascii string as cpumask
+ * int cpulist_scnprintf(buf, len, mask) Format cpumask as list for printing
+ * int cpulist_parse(buf, map)          Parse ascii string as cpulist
+ *
+ * for_each_cpu_mask(cpu, mask)         for-loop cpu over mask
+ *
+ * int num_online_cpus()                Number of online CPUs
+ * int num_possible_cpus()              Number of all possible CPUs
+ * int num_present_cpus()               Number of present CPUs
+ *
+ * int cpu_online(cpu)                  Is some cpu online?
+ * int cpu_possible(cpu)                Is some cpu possible?
+ * int cpu_present(cpu)                 Is some cpu present (can schedule)?
+ *
+ * int any_online_cpu(mask)             First online cpu in mask
+ *
+ * for_each_cpu(cpu)                    for-loop cpu over cpu_possible_map
+ * for_each_online_cpu(cpu)             for-loop cpu over cpu_online_map
+ * for_each_present_cpu(cpu)            for-loop cpu over cpu_present_map
+ *
+ * Subtlety:
+ * 1) The 'type-checked' form of cpu_isset() causes gcc (3.3.2, anyway)
+ *    to generate slightly worse code.  Note for example the additional
+ *    40 lines of assembly code compiling the "for each possible cpu"
+ *    loops buried in the disk_stat_read() macros calls when compiling
+ *    drivers/block/genhd.c (arch i386, CONFIG_SMP=y).  So use a simple
+ *    one-line #define for cpu_isset(), instead of wrapping an inline
+ *    inside a macro, the way we do the other calls.
+ */
+
+#include <linux/kernel.h>
+#include <linux/threads.h>
+#include <linux/bitmap.h>
+#include <asm/bug.h>
+
+typedef struct { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
+extern cpumask_t _unused_cpumask_arg_;
+
+#define cpu_set(cpu, dst) __cpu_set((cpu), &(dst))
+static inline void __cpu_set(int cpu, volatile cpumask_t *dstp)
+{
+        set_bit(cpu, dstp->bits);
+}
+
+#define cpu_clear(cpu, dst) __cpu_clear((cpu), &(dst))
+static inline void __cpu_clear(int cpu, volatile cpumask_t *dstp)
+{
+        clear_bit(cpu, dstp->bits);
+}
+
+#define cpus_setall(dst) __cpus_setall(&(dst), NR_CPUS)
+static inline void __cpus_setall(cpumask_t *dstp, int nbits)
+{
+        bitmap_fill(dstp->bits, nbits);
+}
+
+#define cpus_clear(dst) __cpus_clear(&(dst), NR_CPUS)
+static inline void __cpus_clear(cpumask_t *dstp, int nbits)
+{
+        bitmap_zero(dstp->bits, nbits);
+}
+
+/* No static inline type checking - see Subtlety (1) above. */
+#define cpu_isset(cpu, cpumask) test_bit((cpu), (cpumask).bits)
+
+#define cpu_test_and_set(cpu, cpumask) __cpu_test_and_set((cpu), &(cpumask))
+static inline int __cpu_test_and_set(int cpu, cpumask_t *addr)
+{
+        return test_and_set_bit(cpu, addr->bits);
+}
+
+#define cpus_and(dst, src1, src2) __cpus_and(&(dst), &(src1), &(src2), NR_CPUS)
+static inline void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_or(dst, src1, src2) __cpus_or(&(dst), &(src1), &(src2), NR_CPUS)
+static inline void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_xor(dst, src1, src2) __cpus_xor(&(dst), &(src1), &(src2), NR_CPUS)
+static inline void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_andnot(dst, src1, src2) \
+                                __cpus_andnot(&(dst), &(src1), &(src2), NR_CPUS)
+static inline void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_complement(dst, src) __cpus_complement(&(dst), &(src), NR_CPUS)
+static inline void __cpus_complement(cpumask_t *dstp,
+                                        const cpumask_t *srcp, int nbits)
+{
+        bitmap_complement(dstp->bits, srcp->bits, nbits);
+}
+
+#define cpus_equal(src1, src2) __cpus_equal(&(src1), &(src2), NR_CPUS)
+static inline int __cpus_equal(const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        return bitmap_equal(src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_intersects(src1, src2) __cpus_intersects(&(src1), &(src2), NR_CPUS)
+static inline int __cpus_intersects(const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        return bitmap_intersects(src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_subset(src1, src2) __cpus_subset(&(src1), &(src2), NR_CPUS)
+static inline int __cpus_subset(const cpumask_t *src1p,
+                                        const cpumask_t *src2p, int nbits)
+{
+        return bitmap_subset(src1p->bits, src2p->bits, nbits);
+}
+
+#define cpus_empty(src) __cpus_empty(&(src), NR_CPUS)
+static inline int __cpus_empty(const cpumask_t *srcp, int nbits)
+{
+        return bitmap_empty(srcp->bits, nbits);
+}
+
+#define cpus_full(cpumask) __cpus_full(&(cpumask), NR_CPUS)
+static inline int __cpus_full(const cpumask_t *srcp, int nbits)
+{
+        return bitmap_full(srcp->bits, nbits);
+}
+
+#define cpus_weight(cpumask) __cpus_weight(&(cpumask), NR_CPUS)
+static inline int __cpus_weight(const cpumask_t *srcp, int nbits)
+{
+        return bitmap_weight(srcp->bits, nbits);
+}
+
+#define cpus_shift_right(dst, src, n) \
+                        __cpus_shift_right(&(dst), &(src), (n), NR_CPUS)
+static inline void __cpus_shift_right(cpumask_t *dstp,
+                                        const cpumask_t *srcp, int n, int nbits)
+{
+        bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
+}
+
+#define cpus_shift_left(dst, src, n) \
+                        __cpus_shift_left(&(dst), &(src), (n), NR_CPUS)
+static inline void __cpus_shift_left(cpumask_t *dstp,
+                                        const cpumask_t *srcp, int n, int nbits)
+{
+        bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
+}
+
+#define first_cpu(src) __first_cpu(&(src), NR_CPUS)
+static inline int __first_cpu(const cpumask_t *srcp, int nbits)
+{
+        return min_t(int, nbits, find_first_bit(srcp->bits, nbits));
+}
+
+#define next_cpu(n, src) __next_cpu((n), &(src), NR_CPUS)
+static inline int __next_cpu(int n, const cpumask_t *srcp, int nbits)
+{
+        return min_t(int, nbits, find_next_bit(srcp->bits, nbits, n+1));
+}
+
+#define cpumask_of_cpu(cpu)                                             \
+({                                                                      \
+        typeof(_unused_cpumask_arg_) m;                                 \
+        if (sizeof(m) == sizeof(unsigned long)) {                       \
+                m.bits[0] = 1UL<<(cpu);                                 \
+        } else {                                                        \
+                cpus_clear(m);                                          \
+                cpu_set((cpu), m);                                      \
+        }                                                               \
+        m;                                                              \
+})
+
+#define CPU_MASK_LAST_WORD BITMAP_LAST_WORD_MASK(NR_CPUS)
+
+#if NR_CPUS <= BITS_PER_LONG
+
+#define CPU_MASK_ALL                                                    \
+(cpumask_t) { {                                                         \
+        [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD                 \
+} }
+
+#else
+
+#define CPU_MASK_ALL                                                    \
+(cpumask_t) { {                                                         \
+        [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL,                        \
+        [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD                 \
+} }
+
+#endif
+
+#define CPU_MASK_NONE                                                   \
+(cpumask_t) { {                                                         \
+        [0 ... BITS_TO_LONGS(NR_CPUS)-1] =  0UL                         \
+} }
+
+#define CPU_MASK_CPU0                                                   \
+(cpumask_t) { {                                                         \
+        [0] =  1UL                                                      \
+} }
+
+#define cpus_addr(src) ((src).bits)
+
+#define cpumask_scnprintf(buf, len, src) \
+                        __cpumask_scnprintf((buf), (len), &(src), NR_CPUS)
+static inline int __cpumask_scnprintf(char *buf, int len,
+                                        const cpumask_t *srcp, int nbits)
+{
+        return bitmap_scnprintf(buf, len, srcp->bits, nbits);
+}
+
+#define cpumask_parse(ubuf, ulen, dst) \
+                        __cpumask_parse((ubuf), (ulen), &(dst), NR_CPUS)
+static inline int __cpumask_parse(const char __user *buf, int len,
+                                        cpumask_t *dstp, int nbits)
+{
+        return bitmap_parse(buf, len, dstp->bits, nbits);
+}
+
+#define cpulist_scnprintf(buf, len, src) \
+                        __cpulist_scnprintf((buf), (len), &(src), NR_CPUS)
+static inline int __cpulist_scnprintf(char *buf, int len,
+                                        const cpumask_t *srcp, int nbits)
+{
+        return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
+}
+
+#define cpulist_parse(buf, dst) __cpulist_parse((buf), &(dst), NR_CPUS)
+static inline int __cpulist_parse(const char *buf, cpumask_t *dstp, int nbits)
+{
+        return bitmap_parselist(buf, dstp->bits, nbits);
+}
+
+#if NR_CPUS > 1
+#define for_each_cpu_mask(cpu, mask)            \
+        for ((cpu) = first_cpu(mask);           \
+                (cpu) < NR_CPUS;                \
+                (cpu) = next_cpu((cpu), (mask)))
+#else /* NR_CPUS == 1 */
+#define for_each_cpu_mask(cpu, mask) for ((cpu) = 0; (cpu) < 1; (cpu)++)
+#endif /* NR_CPUS */
+
+/*
+ * The following particular system cpumasks and operations manage
+ * possible, present and online cpus.  Each of them is a fixed size
+ * bitmap of size NR_CPUS.
+ *
+ *  #ifdef CONFIG_HOTPLUG_CPU
+ *     cpu_possible_map - all NR_CPUS bits set
+ *     cpu_present_map  - has bit 'cpu' set iff cpu is populated
+ *     cpu_online_map   - has bit 'cpu' set iff cpu available to scheduler
+ *  #else
+ *     cpu_possible_map - has bit 'cpu' set iff cpu is populated
+ *     cpu_present_map  - copy of cpu_possible_map
+ *     cpu_online_map   - has bit 'cpu' set iff cpu available to scheduler
+ *  #endif
+ *
+ *  In either case, NR_CPUS is fixed at compile time, as the static
+ *  size of these bitmaps.  The cpu_possible_map is fixed at boot
+ *  time, as the set of CPU id's that it is possible might ever
+ *  be plugged in at anytime during the life of that system boot.
+ *  The cpu_present_map is dynamic(*), representing which CPUs
+ *  are currently plugged in.  And cpu_online_map is the dynamic
+ *  subset of cpu_present_map, indicating those CPUs available
+ *  for scheduling.
+ *
+ *  If HOTPLUG is enabled, then cpu_possible_map is forced to have
+ *  all NR_CPUS bits set, otherwise it is just the set of CPUs that
+ *  ACPI reports present at boot.
+ *
+ *  If HOTPLUG is enabled, then cpu_present_map varies dynamically,
+ *  depending on what ACPI reports as currently plugged in, otherwise
+ *  cpu_present_map is just a copy of cpu_possible_map.
+ *
+ *  (*) Well, cpu_present_map is dynamic in the hotplug case.  If not
+ *      hotplug, it's a copy of cpu_possible_map, hence fixed at boot.
+ *
+ * Subtleties:
+ * 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode
+ *    assumption that their single CPU is online.  The UP
+ *    cpu_{online,possible,present}_maps are placebos.  Changing them
+ *    will have no useful affect on the following num_*_cpus()
+ *    and cpu_*() macros in the UP case.  This ugliness is a UP
+ *    optimization - don't waste any instructions or memory references
+ *    asking if you're online or how many CPUs there are if there is
+ *    only one CPU.
+ * 2) Most SMP arch's #define some of these maps to be some
+ *    other map specific to that arch.  Therefore, the following
+ *    must be #define macros, not inlines.  To see why, examine
+ *    the assembly code produced by the following.  Note that
+ *    set1() writes phys_x_map, but set2() writes x_map:
+ *        int x_map, phys_x_map;
+ *        #define set1(a) x_map = a
+ *        inline void set2(int a) { x_map = a; }
+ *        #define x_map phys_x_map
+ *        main(){ set1(3); set2(5); }
+ */
+
+extern cpumask_t cpu_possible_map;
+extern cpumask_t cpu_online_map;
+extern cpumask_t cpu_present_map;
+
+#if NR_CPUS > 1
+#define num_online_cpus()       cpus_weight(cpu_online_map)
+#define num_possible_cpus()     cpus_weight(cpu_possible_map)
+#define num_present_cpus()      cpus_weight(cpu_present_map)
+#define cpu_online(cpu)         cpu_isset((cpu), cpu_online_map)
+#define cpu_possible(cpu)       cpu_isset((cpu), cpu_possible_map)
+#define cpu_present(cpu)        cpu_isset((cpu), cpu_present_map)
+#else
+#define num_online_cpus()       1
+#define num_possible_cpus()     1
+#define num_present_cpus()      1
+#define cpu_online(cpu)         ((cpu) == 0)
+#define cpu_possible(cpu)       ((cpu) == 0)
+#define cpu_present(cpu)        ((cpu) == 0)
+#endif
+
+#define any_online_cpu(mask)                    \
+({                                              \
+        int cpu;                                \
+        for_each_cpu_mask(cpu, (mask))          \
+                if (cpu_online(cpu))            \
+                        break;                  \
+        cpu;                                    \
+})
+
+#define for_each_cpu(cpu)         for_each_cpu_mask((cpu), cpu_possible_map)
+#define for_each_online_cpu(cpu)  for_each_cpu_mask((cpu), cpu_online_map)
+#define for_each_present_cpu(cpu) for_each_cpu_mask((cpu), cpu_present_map)
+
+#endif /* __LINUX_CPUMASK_H */
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
new file mode 100644
index 000000000000..2d9a500d994d
--- /dev/null
+++ b/include/linux/cpuset.h
@@ -0,0 +1,64 @@
+#ifndef _LINUX_CPUSET_H
+#define _LINUX_CPUSET_H
+/*
+ *  cpuset interface
+ *
+ *  Copyright (C) 2003 BULL SA
+ *  Copyright (C) 2004 Silicon Graphics, Inc.
+ *
+ */
+
+#include <linux/sched.h>
+#include <linux/cpumask.h>
+#include <linux/nodemask.h>
+
+#ifdef CONFIG_CPUSETS
+
+extern int cpuset_init(void);
+extern void cpuset_init_smp(void);
+extern void cpuset_fork(struct task_struct *p);
+extern void cpuset_exit(struct task_struct *p);
+extern const cpumask_t cpuset_cpus_allowed(const struct task_struct *p);
+void cpuset_init_current_mems_allowed(void);
+void cpuset_update_current_mems_allowed(void);
+void cpuset_restrict_to_mems_allowed(unsigned long *nodes);
+int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl);
+int cpuset_zone_allowed(struct zone *z);
+extern struct file_operations proc_cpuset_operations;
+extern char *cpuset_task_status_allowed(struct task_struct *task, char *buffer);
+
+#else /* !CONFIG_CPUSETS */
+
+static inline int cpuset_init(void) { return 0; }
+static inline void cpuset_init_smp(void) {}
+static inline void cpuset_fork(struct task_struct *p) {}
+static inline void cpuset_exit(struct task_struct *p) {}
+
+static inline cpumask_t cpuset_cpus_allowed(struct task_struct *p)
+{
+        return cpu_possible_map;
+}
+
+static inline void cpuset_init_current_mems_allowed(void) {}
+static inline void cpuset_update_current_mems_allowed(void) {}
+static inline void cpuset_restrict_to_mems_allowed(unsigned long *nodes) {}
+
+static inline int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
+{
+        return 1;
+}
+
+static inline int cpuset_zone_allowed(struct zone *z)
+{
+        return 1;
+}
+
+static inline char *cpuset_task_status_allowed(struct task_struct *task,
+                                                        char *buffer)
+{
+        return buffer;
+}
+
+#endif /* !CONFIG_CPUSETS */
+
+#endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/cramfs_fs.h b/include/linux/cramfs_fs.h
new file mode 100644
index 000000000000..a8948f34b776
--- /dev/null
+++ b/include/linux/cramfs_fs.h
@@ -0,0 +1,98 @@
+#ifndef __CRAMFS_H
+#define __CRAMFS_H
+
+#ifndef __KERNEL__
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+
+#endif
+
+#define CRAMFS_MAGIC            0x28cd3d45      /* some random number */
+#define CRAMFS_SIGNATURE        "Compressed ROMFS"
+
+/*
+ * Width of various bitfields in struct cramfs_inode.
+ * Primarily used to generate warnings in mkcramfs.
+ */
+#define CRAMFS_MODE_WIDTH 16
+#define CRAMFS_UID_WIDTH 16
+#define CRAMFS_SIZE_WIDTH 24
+#define CRAMFS_GID_WIDTH 8
+#define CRAMFS_NAMELEN_WIDTH 6
+#define CRAMFS_OFFSET_WIDTH 26
+
+/*
+ * Since inode.namelen is a unsigned 6-bit number, the maximum cramfs
+ * path length is 63 << 2 = 252.
+ */
+#define CRAMFS_MAXPATHLEN (((1 << CRAMFS_NAMELEN_WIDTH) - 1) << 2)
+
+/*
+ * Reasonably terse representation of the inode data.
+ */
+struct cramfs_inode {
+        u32 mode:CRAMFS_MODE_WIDTH, uid:CRAMFS_UID_WIDTH;
+        /* SIZE for device files is i_rdev */
+        u32 size:CRAMFS_SIZE_WIDTH, gid:CRAMFS_GID_WIDTH;
+        /* NAMELEN is the length of the file name, divided by 4 and
+           rounded up.  (cramfs doesn't support hard links.) */
+        /* OFFSET: For symlinks and non-empty regular files, this
+           contains the offset (divided by 4) of the file data in
+           compressed form (starting with an array of block pointers;
+           see README).  For non-empty directories it is the offset
+           (divided by 4) of the inode of the first file in that
+           directory.  For anything else, offset is zero. */
+        u32 namelen:CRAMFS_NAMELEN_WIDTH, offset:CRAMFS_OFFSET_WIDTH;
+};
+
+struct cramfs_info {
+        u32 crc;
+        u32 edition;
+        u32 blocks;
+        u32 files;
+};
+
+/*
+ * Superblock information at the beginning of the FS.
+ */
+struct cramfs_super {
+        u32 magic;                      /* 0x28cd3d45 - random number */
+        u32 size;                       /* length in bytes */
+        u32 flags;                      /* feature flags */
+        u32 future;                     /* reserved for future use */
+        u8 signature[16];               /* "Compressed ROMFS" */
+        struct cramfs_info fsid;        /* unique filesystem info */
+        u8 name[16];                    /* user-defined name */
+        struct cramfs_inode root;       /* root inode data */
+};
+
+/*
+ * Feature flags
+ *
+ * 0x00000000 - 0x000000ff: features that work for all past kernels
+ * 0x00000100 - 0xffffffff: features that don't work for past kernels
+ */
+#define CRAMFS_FLAG_FSID_VERSION_2      0x00000001      /* fsid version #2 */
+#define CRAMFS_FLAG_SORTED_DIRS         0x00000002      /* sorted dirs */
+#define CRAMFS_FLAG_HOLES               0x00000100      /* support for holes */
+#define CRAMFS_FLAG_WRONG_SIGNATURE     0x00000200      /* reserved */
+#define CRAMFS_FLAG_SHIFTED_ROOT_OFFSET 0x00000400      /* shifted root fs */
+
+/*
+ * Valid values in super.flags.  Currently we refuse to mount
+ * if (flags & ~CRAMFS_SUPPORTED_FLAGS).  Maybe that should be
+ * changed to test super.future instead.
+ */
+#define CRAMFS_SUPPORTED_FLAGS  ( 0x000000ff \
+                                | CRAMFS_FLAG_HOLES \
+                                | CRAMFS_FLAG_WRONG_SIGNATURE \
+                                | CRAMFS_FLAG_SHIFTED_ROOT_OFFSET )
+
+/* Uncompression interfaces to the underlying zlib */
+int cramfs_uncompress_block(void *dst, int dstlen, void *src, int srclen);
+int cramfs_uncompress_init(void);
+int cramfs_uncompress_exit(void);
+
+#endif
diff --git a/include/linux/cramfs_fs_sb.h b/include/linux/cramfs_fs_sb.h
new file mode 100644
index 000000000000..8390693568fd
--- /dev/null
+++ b/include/linux/cramfs_fs_sb.h
@@ -0,0 +1,20 @@
+#ifndef _CRAMFS_FS_SB
+#define _CRAMFS_FS_SB
+
+/*
+ * cramfs super-block data in memory
+ */
+struct cramfs_sb_info {
+                        unsigned long magic;
+                        unsigned long size;
+                        unsigned long blocks;
+                        unsigned long files;
+                        unsigned long flags;
+};
+
+static inline struct cramfs_sb_info *CRAMFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+#endif
diff --git a/include/linux/crc-ccitt.h b/include/linux/crc-ccitt.h
new file mode 100644
index 000000000000..90037617da8f
--- /dev/null
+++ b/include/linux/crc-ccitt.h
@@ -0,0 +1,17 @@
+#ifndef _LINUX_CRC_CCITT_H
+#define _LINUX_CRC_CCITT_H
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+
+extern u16 const crc_ccitt_table[256];
+
+extern u16 crc_ccitt(u16 crc, const u8 *buffer, size_t len);
+
+static inline u16 crc_ccitt_byte(u16 crc, const u8 c)
+{
+        return (crc >> 8) ^ crc_ccitt_table[(crc ^ c) & 0xff];
+}
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_CRC_CCITT_H */
diff --git a/include/linux/crc32.h b/include/linux/crc32.h
new file mode 100644
index 000000000000..56c0645789a9
--- /dev/null
+++ b/include/linux/crc32.h
@@ -0,0 +1,27 @@
+/*
+ * crc32.h
+ * See linux/lib/crc32.c for license and changes
+ */
+#ifndef _LINUX_CRC32_H
+#define _LINUX_CRC32_H
+
+#include <linux/types.h>
+
+extern u32  crc32_le(u32 crc, unsigned char const *p, size_t len);
+extern u32  crc32_be(u32 crc, unsigned char const *p, size_t len);
+extern u32  bitreverse(u32 in);
+
+#define crc32(seed, data, length)  crc32_le(seed, (unsigned char const *)data, length)
+
+/*
+ * Helpers for hash table generation of ethernet nics:
+ *
+ * Ethernet sends the least significant bit of a byte first, thus crc32_le
+ * is used. The output of crc32_le is bit reversed [most significant bit
+ * is in bit nr 0], thus it must be reversed before use. Except for
+ * nics that bit swap the result internally...
+ */
+#define ether_crc(length, data)    bitreverse(crc32_le(~0, data, length))
+#define ether_crc_le(length, data) crc32_le(~0, data, length)
+
+#endif /* _LINUX_CRC32_H */
diff --git a/include/linux/crc32c.h b/include/linux/crc32c.h
new file mode 100644
index 000000000000..508f512e5a2f
--- /dev/null
+++ b/include/linux/crc32c.h
@@ -0,0 +1,11 @@
+#ifndef _LINUX_CRC32C_H
+#define _LINUX_CRC32C_H
+
+#include <linux/types.h>
+
+extern u32 crc32c_le(u32 crc, unsigned char const *address, size_t length);
+extern u32 crc32c_be(u32 crc, unsigned char const *address, size_t length);
+
+#define crc32c(seed, data, length)  crc32c_le(seed, (unsigned char const *)data, length)
+
+#endif  /* _LINUX_CRC32C_H */
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
new file mode 100644
index 000000000000..387da6a3e58c
--- /dev/null
+++ b/include/linux/crypto.h
@@ -0,0 +1,398 @@
+/*
+ * Scatterlist Cryptographic API.
+ *
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ * Copyright (c) 2002 David S. Miller (davem@redhat.com)
+ *
+ * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
+ * and Nettle, by Niels Möller.
+ * 
+ * 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; either version 2 of the License, or (at your option) 
+ * any later version.
+ *
+ */
+#ifndef _LINUX_CRYPTO_H
+#define _LINUX_CRYPTO_H
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/string.h>
+#include <asm/page.h>
+
+/*
+ * Algorithm masks and types.
+ */
+#define CRYPTO_ALG_TYPE_MASK            0x000000ff
+#define CRYPTO_ALG_TYPE_CIPHER          0x00000001
+#define CRYPTO_ALG_TYPE_DIGEST          0x00000002
+#define CRYPTO_ALG_TYPE_COMPRESS        0x00000004
+
+/*
+ * Transform masks and values (for crt_flags).
+ */
+#define CRYPTO_TFM_MODE_MASK            0x000000ff
+#define CRYPTO_TFM_REQ_MASK             0x000fff00
+#define CRYPTO_TFM_RES_MASK             0xfff00000
+
+#define CRYPTO_TFM_MODE_ECB             0x00000001
+#define CRYPTO_TFM_MODE_CBC             0x00000002
+#define CRYPTO_TFM_MODE_CFB             0x00000004
+#define CRYPTO_TFM_MODE_CTR             0x00000008
+
+#define CRYPTO_TFM_REQ_WEAK_KEY         0x00000100
+#define CRYPTO_TFM_RES_WEAK_KEY         0x00100000
+#define CRYPTO_TFM_RES_BAD_KEY_LEN      0x00200000
+#define CRYPTO_TFM_RES_BAD_KEY_SCHED    0x00400000
+#define CRYPTO_TFM_RES_BAD_BLOCK_LEN    0x00800000
+#define CRYPTO_TFM_RES_BAD_FLAGS        0x01000000
+
+/*
+ * Miscellaneous stuff.
+ */
+#define CRYPTO_UNSPEC                   0
+#define CRYPTO_MAX_ALG_NAME             64
+
+#define CRYPTO_DIR_ENCRYPT              1
+#define CRYPTO_DIR_DECRYPT              0
+
+struct scatterlist;
+
+/*
+ * Algorithms: modular crypto algorithm implementations, managed
+ * via crypto_register_alg() and crypto_unregister_alg().
+ */
+struct cipher_alg {
+        unsigned int cia_min_keysize;
+        unsigned int cia_max_keysize;
+        int (*cia_setkey)(void *ctx, const u8 *key,
+                          unsigned int keylen, u32 *flags);
+        void (*cia_encrypt)(void *ctx, u8 *dst, const u8 *src);
+        void (*cia_decrypt)(void *ctx, u8 *dst, const u8 *src);
+};
+
+struct digest_alg {
+        unsigned int dia_digestsize;
+        void (*dia_init)(void *ctx);
+        void (*dia_update)(void *ctx, const u8 *data, unsigned int len);
+        void (*dia_final)(void *ctx, u8 *out);
+        int (*dia_setkey)(void *ctx, const u8 *key,
+                          unsigned int keylen, u32 *flags);
+};
+
+struct compress_alg {
+        int (*coa_init)(void *ctx);
+        void (*coa_exit)(void *ctx);
+        int (*coa_compress)(void *ctx, const u8 *src, unsigned int slen,
+                            u8 *dst, unsigned int *dlen);
+        int (*coa_decompress)(void *ctx, const u8 *src, unsigned int slen,
+                              u8 *dst, unsigned int *dlen);
+};
+
+#define cra_cipher      cra_u.cipher
+#define cra_digest      cra_u.digest
+#define cra_compress    cra_u.compress
+
+struct crypto_alg {
+        struct list_head cra_list;
+        u32 cra_flags;
+        unsigned int cra_blocksize;
+        unsigned int cra_ctxsize;
+        const char cra_name[CRYPTO_MAX_ALG_NAME];
+
+        union {
+                struct cipher_alg cipher;
+                struct digest_alg digest;
+                struct compress_alg compress;
+        } cra_u;
+        
+        struct module *cra_module;
+};
+
+/*
+ * Algorithm registration interface.
+ */
+int crypto_register_alg(struct crypto_alg *alg);
+int crypto_unregister_alg(struct crypto_alg *alg);
+
+/*
+ * Algorithm query interface.
+ */
+#ifdef CONFIG_CRYPTO
+int crypto_alg_available(const char *name, u32 flags);
+#else
+static inline int crypto_alg_available(const char *name, u32 flags)
+{
+        return 0;
+}
+#endif
+
+/*
+ * Transforms: user-instantiated objects which encapsulate algorithms
+ * and core processing logic.  Managed via crypto_alloc_tfm() and
+ * crypto_free_tfm(), as well as the various helpers below.
+ */
+struct crypto_tfm;
+
+struct cipher_tfm {
+        void *cit_iv;
+        unsigned int cit_ivsize;
+        u32 cit_mode;
+        int (*cit_setkey)(struct crypto_tfm *tfm,
+                          const u8 *key, unsigned int keylen);
+        int (*cit_encrypt)(struct crypto_tfm *tfm,
+                           struct scatterlist *dst,
+                           struct scatterlist *src,
+                           unsigned int nbytes);
+        int (*cit_encrypt_iv)(struct crypto_tfm *tfm,
+                              struct scatterlist *dst,
+                              struct scatterlist *src,
+                              unsigned int nbytes, u8 *iv);
+        int (*cit_decrypt)(struct crypto_tfm *tfm,
+                           struct scatterlist *dst,
+                           struct scatterlist *src,
+                           unsigned int nbytes);
+        int (*cit_decrypt_iv)(struct crypto_tfm *tfm,
+                           struct scatterlist *dst,
+                           struct scatterlist *src,
+                           unsigned int nbytes, u8 *iv);
+        void (*cit_xor_block)(u8 *dst, const u8 *src);
+};
+
+struct digest_tfm {
+        void (*dit_init)(struct crypto_tfm *tfm);
+        void (*dit_update)(struct crypto_tfm *tfm,
+                           struct scatterlist *sg, unsigned int nsg);
+        void (*dit_final)(struct crypto_tfm *tfm, u8 *out);
+        void (*dit_digest)(struct crypto_tfm *tfm, struct scatterlist *sg,
+                           unsigned int nsg, u8 *out);
+        int (*dit_setkey)(struct crypto_tfm *tfm,
+                          const u8 *key, unsigned int keylen);
+#ifdef CONFIG_CRYPTO_HMAC
+        void *dit_hmac_block;
+#endif
+};
+
+struct compress_tfm {
+        int (*cot_compress)(struct crypto_tfm *tfm,
+                            const u8 *src, unsigned int slen,
+                            u8 *dst, unsigned int *dlen);
+        int (*cot_decompress)(struct crypto_tfm *tfm,
+                              const u8 *src, unsigned int slen,
+                              u8 *dst, unsigned int *dlen);
+};
+
+#define crt_cipher      crt_u.cipher
+#define crt_digest      crt_u.digest
+#define crt_compress    crt_u.compress
+
+struct crypto_tfm {
+
+        u32 crt_flags;
+        
+        union {
+                struct cipher_tfm cipher;
+                struct digest_tfm digest;
+                struct compress_tfm compress;
+        } crt_u;
+        
+        struct crypto_alg *__crt_alg;
+};
+
+/* 
+ * Transform user interface.
+ */
+ 
+/*
+ * crypto_alloc_tfm() will first attempt to locate an already loaded algorithm.
+ * If that fails and the kernel supports dynamically loadable modules, it
+ * will then attempt to load a module of the same name or alias.  A refcount
+ * is grabbed on the algorithm which is then associated with the new transform.
+ *
+ * crypto_free_tfm() frees up the transform and any associated resources,
+ * then drops the refcount on the associated algorithm.
+ */
+struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
+void crypto_free_tfm(struct crypto_tfm *tfm);
+
+/*
+ * Transform helpers which query the underlying algorithm.
+ */
+static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
+{
+        return tfm->__crt_alg->cra_name;
+}
+
+static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
+{
+        return module_name(tfm->__crt_alg->cra_module);
+}
+
+static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
+{
+        return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
+}
+
+static inline unsigned int crypto_tfm_alg_min_keysize(struct crypto_tfm *tfm)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->__crt_alg->cra_cipher.cia_min_keysize;
+}
+
+static inline unsigned int crypto_tfm_alg_max_keysize(struct crypto_tfm *tfm)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->__crt_alg->cra_cipher.cia_max_keysize;
+}
+
+static inline unsigned int crypto_tfm_alg_ivsize(struct crypto_tfm *tfm)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->crt_cipher.cit_ivsize;
+}
+
+static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
+{
+        return tfm->__crt_alg->cra_blocksize;
+}
+
+static inline unsigned int crypto_tfm_alg_digestsize(struct crypto_tfm *tfm)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        return tfm->__crt_alg->cra_digest.dia_digestsize;
+}
+
+/*
+ * API wrappers.
+ */
+static inline void crypto_digest_init(struct crypto_tfm *tfm)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        tfm->crt_digest.dit_init(tfm);
+}
+
+static inline void crypto_digest_update(struct crypto_tfm *tfm,
+                                        struct scatterlist *sg,
+                                        unsigned int nsg)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        tfm->crt_digest.dit_update(tfm, sg, nsg);
+}
+
+static inline void crypto_digest_final(struct crypto_tfm *tfm, u8 *out)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        tfm->crt_digest.dit_final(tfm, out);
+}
+
+static inline void crypto_digest_digest(struct crypto_tfm *tfm,
+                                        struct scatterlist *sg,
+                                        unsigned int nsg, u8 *out)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        tfm->crt_digest.dit_digest(tfm, sg, nsg, out);
+}
+
+static inline int crypto_digest_setkey(struct crypto_tfm *tfm,
+                                       const u8 *key, unsigned int keylen)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
+        if (tfm->crt_digest.dit_setkey == NULL)
+                return -ENOSYS;
+        return tfm->crt_digest.dit_setkey(tfm, key, keylen);
+}
+
+static inline int crypto_cipher_setkey(struct crypto_tfm *tfm,
+                                       const u8 *key, unsigned int keylen)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->crt_cipher.cit_setkey(tfm, key, keylen);
+}
+
+static inline int crypto_cipher_encrypt(struct crypto_tfm *tfm,
+                                        struct scatterlist *dst,
+                                        struct scatterlist *src,
+                                        unsigned int nbytes)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->crt_cipher.cit_encrypt(tfm, dst, src, nbytes);
+}                                        
+
+static inline int crypto_cipher_encrypt_iv(struct crypto_tfm *tfm,
+                                           struct scatterlist *dst,
+                                           struct scatterlist *src,
+                                           unsigned int nbytes, u8 *iv)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        BUG_ON(tfm->crt_cipher.cit_mode == CRYPTO_TFM_MODE_ECB);
+        return tfm->crt_cipher.cit_encrypt_iv(tfm, dst, src, nbytes, iv);
+}                                        
+
+static inline int crypto_cipher_decrypt(struct crypto_tfm *tfm,
+                                        struct scatterlist *dst,
+                                        struct scatterlist *src,
+                                        unsigned int nbytes)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        return tfm->crt_cipher.cit_decrypt(tfm, dst, src, nbytes);
+}
+
+static inline int crypto_cipher_decrypt_iv(struct crypto_tfm *tfm,
+                                           struct scatterlist *dst,
+                                           struct scatterlist *src,
+                                           unsigned int nbytes, u8 *iv)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        BUG_ON(tfm->crt_cipher.cit_mode == CRYPTO_TFM_MODE_ECB);
+        return tfm->crt_cipher.cit_decrypt_iv(tfm, dst, src, nbytes, iv);
+}
+
+static inline void crypto_cipher_set_iv(struct crypto_tfm *tfm,
+                                        const u8 *src, unsigned int len)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        memcpy(tfm->crt_cipher.cit_iv, src, len);
+}
+
+static inline void crypto_cipher_get_iv(struct crypto_tfm *tfm,
+                                        u8 *dst, unsigned int len)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
+        memcpy(dst, tfm->crt_cipher.cit_iv, len);
+}
+
+static inline int crypto_comp_compress(struct crypto_tfm *tfm,
+                                       const u8 *src, unsigned int slen,
+                                       u8 *dst, unsigned int *dlen)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
+        return tfm->crt_compress.cot_compress(tfm, src, slen, dst, dlen);
+}
+
+static inline int crypto_comp_decompress(struct crypto_tfm *tfm,
+                                         const u8 *src, unsigned int slen,
+                                         u8 *dst, unsigned int *dlen)
+{
+        BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
+        return tfm->crt_compress.cot_decompress(tfm, src, slen, dst, dlen);
+}
+
+/*
+ * HMAC support.
+ */
+#ifdef CONFIG_CRYPTO_HMAC
+void crypto_hmac_init(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen);
+void crypto_hmac_update(struct crypto_tfm *tfm,
+                        struct scatterlist *sg, unsigned int nsg);
+void crypto_hmac_final(struct crypto_tfm *tfm, u8 *key,
+                       unsigned int *keylen, u8 *out);
+void crypto_hmac(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen,
+                 struct scatterlist *sg, unsigned int nsg, u8 *out);
+#endif  /* CONFIG_CRYPTO_HMAC */
+
+#endif  /* _LINUX_CRYPTO_H */
+
diff --git a/include/linux/cryptohash.h b/include/linux/cryptohash.h
new file mode 100644
index 000000000000..c118b2ad9807
--- /dev/null
+++ b/include/linux/cryptohash.h
@@ -0,0 +1,12 @@
+#ifndef __CRYPTOHASH_H
+#define __CRYPTOHASH_H
+
+#define SHA_DIGEST_WORDS 5
+#define SHA_WORKSPACE_WORDS 80
+
+void sha_init(__u32 *buf);
+void sha_transform(__u32 *digest, const char *data, __u32 *W);
+
+__u32 half_md4_transform(__u32 buf[4], __u32 const in[8]);
+
+#endif
diff --git a/include/linux/ctype.h b/include/linux/ctype.h
new file mode 100644
index 000000000000..afa36392297a
--- /dev/null
+++ b/include/linux/ctype.h
@@ -0,0 +1,54 @@
+#ifndef _LINUX_CTYPE_H
+#define _LINUX_CTYPE_H
+
+/*
+ * NOTE! This ctype does not handle EOF like the standard C
+ * library is required to.
+ */
+
+#define _U      0x01    /* upper */
+#define _L      0x02    /* lower */
+#define _D      0x04    /* digit */
+#define _C      0x08    /* cntrl */
+#define _P      0x10    /* punct */
+#define _S      0x20    /* white space (space/lf/tab) */
+#define _X      0x40    /* hex digit */
+#define _SP     0x80    /* hard space (0x20) */
+
+extern unsigned char _ctype[];
+
+#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
+
+#define isalnum(c)      ((__ismask(c)&(_U|_L|_D)) != 0)
+#define isalpha(c)      ((__ismask(c)&(_U|_L)) != 0)
+#define iscntrl(c)      ((__ismask(c)&(_C)) != 0)
+#define isdigit(c)      ((__ismask(c)&(_D)) != 0)
+#define isgraph(c)      ((__ismask(c)&(_P|_U|_L|_D)) != 0)
+#define islower(c)      ((__ismask(c)&(_L)) != 0)
+#define isprint(c)      ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
+#define ispunct(c)      ((__ismask(c)&(_P)) != 0)
+#define isspace(c)      ((__ismask(c)&(_S)) != 0)
+#define isupper(c)      ((__ismask(c)&(_U)) != 0)
+#define isxdigit(c)     ((__ismask(c)&(_D|_X)) != 0)
+
+#define isascii(c) (((unsigned char)(c))<=0x7f)
+#define toascii(c) (((unsigned char)(c))&0x7f)
+
+static inline unsigned char __tolower(unsigned char c)
+{
+        if (isupper(c))
+                c -= 'A'-'a';
+        return c;
+}
+
+static inline unsigned char __toupper(unsigned char c)
+{
+        if (islower(c))
+                c -= 'a'-'A';
+        return c;
+}
+
+#define tolower(c) __tolower(c)
+#define toupper(c) __toupper(c)
+
+#endif
diff --git a/include/linux/cuda.h b/include/linux/cuda.h
new file mode 100644
index 000000000000..6a3e6385d3f3
--- /dev/null
+++ b/include/linux/cuda.h
@@ -0,0 +1,36 @@
+/*
+ * Definitions for talking to the CUDA.  The CUDA is a microcontroller
+ * which controls the ADB, system power, RTC, and various other things.
+ *
+ * Copyright (C) 1996 Paul Mackerras.
+ */
+
+/* CUDA commands (2nd byte) */
+#define CUDA_WARM_START         0
+#define CUDA_AUTOPOLL           1
+#define CUDA_GET_6805_ADDR      2
+#define CUDA_GET_TIME           3
+#define CUDA_GET_PRAM           7
+#define CUDA_SET_6805_ADDR      8
+#define CUDA_SET_TIME           9
+#define CUDA_POWERDOWN          0xa
+#define CUDA_POWERUP_TIME       0xb
+#define CUDA_SET_PRAM           0xc
+#define CUDA_MS_RESET           0xd
+#define CUDA_SEND_DFAC          0xe
+#define CUDA_RESET_SYSTEM       0x11
+#define CUDA_SET_IPL            0x12
+#define CUDA_SET_AUTO_RATE      0x14
+#define CUDA_GET_AUTO_RATE      0x16
+#define CUDA_SET_DEVICE_LIST    0x19
+#define CUDA_GET_DEVICE_LIST    0x1a
+#define CUDA_GET_SET_IIC        0x22
+
+#ifdef __KERNEL__
+
+extern int find_via_cuda(void);
+extern int cuda_request(struct adb_request *req,
+                        void (*done)(struct adb_request *), int nbytes, ...);
+extern void cuda_poll(void);
+
+#endif  /* __KERNEL */
diff --git a/include/linux/cyclades.h b/include/linux/cyclades.h
new file mode 100644
index 000000000000..46d8254c1a79
--- /dev/null
+++ b/include/linux/cyclades.h
@@ -0,0 +1,827 @@
+/* $Revision: 3.0 $$Date: 1998/11/02 14:20:59 $
+ * linux/include/linux/cyclades.h
+ *
+ * This file was initially written by
+ * Randolph Bentson <bentson@grieg.seaslug.org> and is maintained by
+ * Ivan Passos <ivan@cyclades.com>.
+ *
+ * This file contains the general definitions for the cyclades.c driver
+ *$Log: cyclades.h,v $
+ *Revision 3.1  2002/01/29 11:36:16  henrique
+ *added throttle field on struct cyclades_port to indicate whether the
+ *port is throttled or not
+ *
+ *Revision 3.1  2000/04/19 18:52:52  ivan
+ *converted address fields to unsigned long and added fields for physical
+ *addresses on cyclades_card structure;
+ *
+ *Revision 3.0  1998/11/02 14:20:59  ivan
+ *added nports field on cyclades_card structure;
+ *
+ *Revision 2.5  1998/08/03 16:57:01  ivan
+ *added cyclades_idle_stats structure;
+ * 
+ *Revision 2.4  1998/06/01 12:09:53  ivan
+ *removed closing_wait2 from cyclades_port structure;
+ *
+ *Revision 2.3  1998/03/16 18:01:12  ivan
+ *changes in the cyclades_port structure to get it closer to the 
+ *standard serial port structure;
+ *added constants for new ioctls;
+ *
+ *Revision 2.2  1998/02/17 16:50:00  ivan
+ *changes in the cyclades_port structure (addition of shutdown_wait and 
+ *chip_rev variables);
+ *added constants for new ioctls and for CD1400 rev. numbers.
+ *
+ *Revision 2.1  1997/10/24 16:03:00  ivan
+ *added rflow (which allows enabling the CD1400 special flow control 
+ *feature) and rtsdtr_inv (which allows DTR/RTS pin inversion) to 
+ *cyclades_port structure;
+ *added Alpha support
+ *
+ *Revision 2.0  1997/06/30 10:30:00  ivan
+ *added some new doorbell command constants related to IOCTLW and
+ *UART error signaling
+ *
+ *Revision 1.8  1997/06/03 15:30:00  ivan
+ *added constant ZFIRM_HLT
+ *added constant CyPCI_Ze_win ( = 2 * Cy_PCI_Zwin)
+ *
+ *Revision 1.7  1997/03/26 10:30:00  daniel
+ *new entries at the end of cyclades_port struct to reallocate
+ *variables illegally allocated within card memory.
+ *
+ *Revision 1.6  1996/09/09 18:35:30  bentson
+ *fold in changes for Cyclom-Z -- including structures for
+ *communicating with board as well modest changes to original
+ *structures to support new features.
+ *
+ *Revision 1.5  1995/11/13 21:13:31  bentson
+ *changes suggested by Michael Chastain <mec@duracef.shout.net>
+ *to support use of this file in non-kernel applications
+ *
+ *
+ */
+
+#ifndef _LINUX_CYCLADES_H
+#define _LINUX_CYCLADES_H
+
+struct cyclades_monitor {
+        unsigned long           int_count;
+        unsigned long           char_count;
+        unsigned long           char_max;
+        unsigned long           char_last;
+};
+
+/*
+ * These stats all reflect activity since the device was last initialized.
+ * (i.e., since the port was opened with no other processes already having it
+ * open)
+ */
+struct cyclades_idle_stats {
+    time_t         in_use;      /* Time device has been in use (secs) */
+    time_t         recv_idle;   /* Time since last char received (secs) */
+    time_t         xmit_idle;   /* Time since last char transmitted (secs) */
+    unsigned long  recv_bytes;  /* Bytes received */
+    unsigned long  xmit_bytes;  /* Bytes transmitted */
+    unsigned long  overruns;    /* Input overruns */
+    unsigned long  frame_errs;  /* Input framing errors */
+    unsigned long  parity_errs; /* Input parity errors */
+};
+
+#define CYCLADES_MAGIC  0x4359
+
+#define CYGETMON                0x435901
+#define CYGETTHRESH             0x435902
+#define CYSETTHRESH             0x435903
+#define CYGETDEFTHRESH          0x435904
+#define CYSETDEFTHRESH          0x435905
+#define CYGETTIMEOUT            0x435906
+#define CYSETTIMEOUT            0x435907
+#define CYGETDEFTIMEOUT         0x435908
+#define CYSETDEFTIMEOUT         0x435909
+#define CYSETRFLOW              0x43590a
+#define CYGETRFLOW              0x43590b
+#define CYSETRTSDTR_INV         0x43590c
+#define CYGETRTSDTR_INV         0x43590d
+#define CYZSETPOLLCYCLE         0x43590e
+#define CYZGETPOLLCYCLE         0x43590f
+#define CYGETCD1400VER          0x435910
+#define CYGETCARDINFO           0x435911
+#define CYSETWAIT               0x435912
+#define CYGETWAIT               0x435913
+
+/*************** CYCLOM-Z ADDITIONS ***************/
+
+#define CZIOC           ('M' << 8)
+#define CZ_NBOARDS      (CZIOC|0xfa)
+#define CZ_BOOT_START   (CZIOC|0xfb)
+#define CZ_BOOT_DATA    (CZIOC|0xfc)
+#define CZ_BOOT_END     (CZIOC|0xfd)
+#define CZ_TEST         (CZIOC|0xfe)
+
+#define CZ_DEF_POLL     (HZ/25)
+
+#define MAX_BOARD       4       /* Max number of boards */
+#define MAX_DEV         256     /* Max number of ports total */
+#define CYZ_MAX_SPEED   921600
+
+#define CYZ_FIFO_SIZE   16
+
+#define CYZ_BOOT_NWORDS 0x100
+struct CYZ_BOOT_CTRL {
+        unsigned short  nboard;
+        int             status[MAX_BOARD];
+        int             nchannel[MAX_BOARD];
+        int             fw_rev[MAX_BOARD];
+        unsigned long   offset;
+        unsigned long   data[CYZ_BOOT_NWORDS];
+};
+
+
+#ifndef DP_WINDOW_SIZE
+/* #include "cyclomz.h" */
+/****************** ****************** *******************/
+/*
+ *      The data types defined below are used in all ZFIRM interface
+ *      data structures. They accomodate differences between HW
+ *      architectures and compilers.
+ */
+
+#if defined(__alpha__)
+typedef unsigned long   ucdouble;       /* 64 bits, unsigned */
+typedef unsigned int    uclong;         /* 32 bits, unsigned */
+#else
+typedef unsigned long   uclong;         /* 32 bits, unsigned */
+#endif
+typedef unsigned short  ucshort;        /* 16 bits, unsigned */
+typedef unsigned char   ucchar;         /* 8 bits, unsigned */
+
+/*
+ *      Memory Window Sizes
+ */
+
+#define DP_WINDOW_SIZE          (0x00080000)    /* window size 512 Kb */
+#define ZE_DP_WINDOW_SIZE       (0x00100000)    /* window size 1 Mb (Ze and
+                                                  8Zo V.2 */
+#define CTRL_WINDOW_SIZE        (0x00000080)    /* runtime regs 128 bytes */
+
+/*
+ *      CUSTOM_REG - Cyclom-Z/PCI Custom Registers Set. The driver
+ *      normally will access only interested on the fpga_id, fpga_version,
+ *      start_cpu and stop_cpu.
+ */
+
+struct  CUSTOM_REG {
+        uclong  fpga_id;                /* FPGA Identification Register */
+        uclong  fpga_version;           /* FPGA Version Number Register */
+        uclong  cpu_start;              /* CPU start Register (write) */
+        uclong  cpu_stop;               /* CPU stop Register (write) */
+        uclong  misc_reg;               /* Miscelaneous Register */
+        uclong  idt_mode;               /* IDT mode Register */
+        uclong  uart_irq_status;        /* UART IRQ status Register */
+        uclong  clear_timer0_irq;       /* Clear timer interrupt Register */
+        uclong  clear_timer1_irq;       /* Clear timer interrupt Register */
+        uclong  clear_timer2_irq;       /* Clear timer interrupt Register */
+        uclong  test_register;          /* Test Register */
+        uclong  test_count;             /* Test Count Register */
+        uclong  timer_select;           /* Timer select register */
+        uclong  pr_uart_irq_status;     /* Prioritized UART IRQ stat Reg */
+        uclong  ram_wait_state;         /* RAM wait-state Register */
+        uclong  uart_wait_state;        /* UART wait-state Register */
+        uclong  timer_wait_state;       /* timer wait-state Register */
+        uclong  ack_wait_state;         /* ACK wait State Register */
+};
+
+/*
+ *      RUNTIME_9060 - PLX PCI9060ES local configuration and shared runtime
+ *      registers. This structure can be used to access the 9060 registers
+ *      (memory mapped).
+ */
+
+struct RUNTIME_9060 {
+        uclong  loc_addr_range; /* 00h - Local Address Range */
+        uclong  loc_addr_base;  /* 04h - Local Address Base */
+        uclong  loc_arbitr;     /* 08h - Local Arbitration */
+        uclong  endian_descr;   /* 0Ch - Big/Little Endian Descriptor */
+        uclong  loc_rom_range;  /* 10h - Local ROM Range */
+        uclong  loc_rom_base;   /* 14h - Local ROM Base */
+        uclong  loc_bus_descr;  /* 18h - Local Bus descriptor */
+        uclong  loc_range_mst;  /* 1Ch - Local Range for Master to PCI */
+        uclong  loc_base_mst;   /* 20h - Local Base for Master PCI */
+        uclong  loc_range_io;   /* 24h - Local Range for Master IO */
+        uclong  pci_base_mst;   /* 28h - PCI Base for Master PCI */
+        uclong  pci_conf_io;    /* 2Ch - PCI configuration for Master IO */
+        uclong  filler1;        /* 30h */
+        uclong  filler2;        /* 34h */
+        uclong  filler3;        /* 38h */
+        uclong  filler4;        /* 3Ch */
+        uclong  mail_box_0;     /* 40h - Mail Box 0 */
+        uclong  mail_box_1;     /* 44h - Mail Box 1 */
+        uclong  mail_box_2;     /* 48h - Mail Box 2 */
+        uclong  mail_box_3;     /* 4Ch - Mail Box 3 */
+        uclong  filler5;        /* 50h */
+        uclong  filler6;        /* 54h */
+        uclong  filler7;        /* 58h */
+        uclong  filler8;        /* 5Ch */
+        uclong  pci_doorbell;   /* 60h - PCI to Local Doorbell */
+        uclong  loc_doorbell;   /* 64h - Local to PCI Doorbell */
+        uclong  intr_ctrl_stat; /* 68h - Interrupt Control/Status */
+        uclong  init_ctrl;      /* 6Ch - EEPROM control, Init Control, etc */
+};
+
+/* Values for the Local Base Address re-map register */
+
+#define WIN_RAM         0x00000001L     /* set the sliding window to RAM */
+#define WIN_CREG        0x14000001L     /* set the window to custom Registers */
+
+/* Values timer select registers */
+
+#define TIMER_BY_1M     0x00            /* clock divided by 1M */
+#define TIMER_BY_256K   0x01            /* clock divided by 256k */
+#define TIMER_BY_128K   0x02            /* clock divided by 128k */
+#define TIMER_BY_32K    0x03            /* clock divided by 32k */
+
+/****************** ****************** *******************/
+#endif
+
+#ifndef ZFIRM_ID
+/* #include "zfwint.h" */
+/****************** ****************** *******************/
+/*
+ *      This file contains the definitions for interfacing with the
+ *      Cyclom-Z ZFIRM Firmware.
+ */
+
+/* General Constant definitions */
+
+#define MAX_CHAN        64              /* max number of channels per board */
+
+/* firmware id structure (set after boot) */
+
+#define ID_ADDRESS      0x00000180L     /* signature/pointer address */
+#define ZFIRM_ID        0x5557465AL     /* ZFIRM/U signature */
+#define ZFIRM_HLT       0x59505B5CL     /* ZFIRM needs external power supply */
+#define ZFIRM_RST       0x56040674L     /* RST signal (due to FW reset) */
+
+#define ZF_TINACT_DEF   1000            /* default inactivity timeout 
+                                           (1000 ms) */
+#define ZF_TINACT       ZF_TINACT_DEF
+
+struct  FIRM_ID {
+        uclong  signature;              /* ZFIRM/U signature */
+        uclong  zfwctrl_addr;           /* pointer to ZFW_CTRL structure */
+};
+
+/* Op. System id */
+
+#define C_OS_LINUX      0x00000030      /* generic Linux system */
+
+/* channel op_mode */
+
+#define C_CH_DISABLE    0x00000000      /* channel is disabled */
+#define C_CH_TXENABLE   0x00000001      /* channel Tx enabled */
+#define C_CH_RXENABLE   0x00000002      /* channel Rx enabled */
+#define C_CH_ENABLE     0x00000003      /* channel Tx/Rx enabled */
+#define C_CH_LOOPBACK   0x00000004      /* Loopback mode */
+
+/* comm_parity - parity */
+
+#define C_PR_NONE       0x00000000      /* None */
+#define C_PR_ODD        0x00000001      /* Odd */
+#define C_PR_EVEN       0x00000002      /* Even */
+#define C_PR_MARK       0x00000004      /* Mark */
+#define C_PR_SPACE      0x00000008      /* Space */
+#define C_PR_PARITY     0x000000ff
+
+#define C_PR_DISCARD    0x00000100      /* discard char with frame/par error */
+#define C_PR_IGNORE     0x00000200      /* ignore frame/par error */
+
+/* comm_data_l - data length and stop bits */
+
+#define C_DL_CS5        0x00000001
+#define C_DL_CS6        0x00000002
+#define C_DL_CS7        0x00000004
+#define C_DL_CS8        0x00000008
+#define C_DL_CS         0x0000000f
+#define C_DL_1STOP      0x00000010
+#define C_DL_15STOP     0x00000020
+#define C_DL_2STOP      0x00000040
+#define C_DL_STOP       0x000000f0
+
+/* interrupt enabling/status */
+
+#define C_IN_DISABLE    0x00000000      /* zero, disable interrupts */
+#define C_IN_TXBEMPTY   0x00000001      /* tx buffer empty */
+#define C_IN_TXLOWWM    0x00000002      /* tx buffer below LWM */
+#define C_IN_RXHIWM     0x00000010      /* rx buffer above HWM */
+#define C_IN_RXNNDT     0x00000020      /* rx no new data timeout */
+#define C_IN_MDCD       0x00000100      /* modem DCD change */
+#define C_IN_MDSR       0x00000200      /* modem DSR change */
+#define C_IN_MRI        0x00000400      /* modem RI change */
+#define C_IN_MCTS       0x00000800      /* modem CTS change */
+#define C_IN_RXBRK      0x00001000      /* Break received */
+#define C_IN_PR_ERROR   0x00002000      /* parity error */
+#define C_IN_FR_ERROR   0x00004000      /* frame error */
+#define C_IN_OVR_ERROR  0x00008000      /* overrun error */
+#define C_IN_RXOFL      0x00010000      /* RX buffer overflow */
+#define C_IN_IOCTLW     0x00020000      /* I/O control w/ wait */
+#define C_IN_MRTS       0x00040000      /* modem RTS drop */
+#define C_IN_ICHAR      0x00080000
+ 
+/* flow control */
+
+#define C_FL_OXX        0x00000001      /* output Xon/Xoff flow control */
+#define C_FL_IXX        0x00000002      /* output Xon/Xoff flow control */
+#define C_FL_OIXANY     0x00000004      /* output Xon/Xoff (any xon) */
+#define C_FL_SWFLOW     0x0000000f
+
+/* flow status */
+
+#define C_FS_TXIDLE     0x00000000      /* no Tx data in the buffer or UART */
+#define C_FS_SENDING    0x00000001      /* UART is sending data */
+#define C_FS_SWFLOW     0x00000002      /* Tx is stopped by received Xoff */
+
+/* rs_control/rs_status RS-232 signals */
+
+#define C_RS_PARAM      0x80000000      /* Indicates presence of parameter in 
+                                           IOCTLM command */
+#define C_RS_RTS        0x00000001      /* RTS */
+#define C_RS_DTR        0x00000004      /* DTR */
+#define C_RS_DCD        0x00000100      /* CD */
+#define C_RS_DSR        0x00000200      /* DSR */
+#define C_RS_RI         0x00000400      /* RI */
+#define C_RS_CTS        0x00000800      /* CTS */
+
+/* commands Host <-> Board */
+
+#define C_CM_RESET      0x01            /* reset/flush buffers */
+#define C_CM_IOCTL      0x02            /* re-read CH_CTRL */
+#define C_CM_IOCTLW     0x03            /* re-read CH_CTRL, intr when done */
+#define C_CM_IOCTLM     0x04            /* RS-232 outputs change */
+#define C_CM_SENDXOFF   0x10            /* send Xoff */
+#define C_CM_SENDXON    0x11            /* send Xon */
+#define C_CM_CLFLOW     0x12            /* Clear flow control (resume) */
+#define C_CM_SENDBRK    0x41            /* send break */
+#define C_CM_INTBACK    0x42            /* Interrupt back */
+#define C_CM_SET_BREAK  0x43            /* Tx break on */
+#define C_CM_CLR_BREAK  0x44            /* Tx break off */
+#define C_CM_CMD_DONE   0x45            /* Previous command done */
+#define C_CM_INTBACK2   0x46            /* Alternate Interrupt back */
+#define C_CM_TINACT     0x51            /* set inactivity detection */
+#define C_CM_IRQ_ENBL   0x52            /* enable generation of interrupts */
+#define C_CM_IRQ_DSBL   0x53            /* disable generation of interrupts */
+#define C_CM_ACK_ENBL   0x54            /* enable acknowledged interrupt mode */
+#define C_CM_ACK_DSBL   0x55            /* disable acknowledged intr mode */
+#define C_CM_FLUSH_RX   0x56            /* flushes Rx buffer */
+#define C_CM_FLUSH_TX   0x57            /* flushes Tx buffer */
+#define C_CM_Q_ENABLE   0x58            /* enables queue access from the 
+                                           driver */
+#define C_CM_Q_DISABLE  0x59            /* disables queue access from the 
+                                           driver */
+
+#define C_CM_TXBEMPTY   0x60            /* Tx buffer is empty */
+#define C_CM_TXLOWWM    0x61            /* Tx buffer low water mark */
+#define C_CM_RXHIWM     0x62            /* Rx buffer high water mark */
+#define C_CM_RXNNDT     0x63            /* rx no new data timeout */
+#define C_CM_TXFEMPTY   0x64
+#define C_CM_ICHAR      0x65
+#define C_CM_MDCD       0x70            /* modem DCD change */
+#define C_CM_MDSR       0x71            /* modem DSR change */
+#define C_CM_MRI        0x72            /* modem RI change */
+#define C_CM_MCTS       0x73            /* modem CTS change */
+#define C_CM_MRTS       0x74            /* modem RTS drop */
+#define C_CM_RXBRK      0x84            /* Break received */
+#define C_CM_PR_ERROR   0x85            /* Parity error */
+#define C_CM_FR_ERROR   0x86            /* Frame error */
+#define C_CM_OVR_ERROR  0x87            /* Overrun error */
+#define C_CM_RXOFL      0x88            /* RX buffer overflow */
+#define C_CM_CMDERROR   0x90            /* command error */
+#define C_CM_FATAL      0x91            /* fatal error */
+#define C_CM_HW_RESET   0x92            /* reset board */
+
+/*
+ *      CH_CTRL - This per port structure contains all parameters
+ *      that control an specific port. It can be seen as the
+ *      configuration registers of a "super-serial-controller".
+ */
+
+struct CH_CTRL {
+        uclong  op_mode;        /* operation mode */
+        uclong  intr_enable;    /* interrupt masking */
+        uclong  sw_flow;        /* SW flow control */
+        uclong  flow_status;    /* output flow status */
+        uclong  comm_baud;      /* baud rate  - numerically specified */
+        uclong  comm_parity;    /* parity */
+        uclong  comm_data_l;    /* data length/stop */
+        uclong  comm_flags;     /* other flags */
+        uclong  hw_flow;        /* HW flow control */
+        uclong  rs_control;     /* RS-232 outputs */
+        uclong  rs_status;      /* RS-232 inputs */
+        uclong  flow_xon;       /* xon char */
+        uclong  flow_xoff;      /* xoff char */
+        uclong  hw_overflow;    /* hw overflow counter */
+        uclong  sw_overflow;    /* sw overflow counter */
+        uclong  comm_error;     /* frame/parity error counter */
+        uclong ichar;
+        uclong filler[7];
+};
+
+
+/*
+ *      BUF_CTRL - This per channel structure contains
+ *      all Tx and Rx buffer control for a given channel.
+ */
+
+struct  BUF_CTRL        {
+        uclong  flag_dma;       /* buffers are in Host memory */
+        uclong  tx_bufaddr;     /* address of the tx buffer */
+        uclong  tx_bufsize;     /* tx buffer size */
+        uclong  tx_threshold;   /* tx low water mark */
+        uclong  tx_get;         /* tail index tx buf */
+        uclong  tx_put;         /* head index tx buf */
+        uclong  rx_bufaddr;     /* address of the rx buffer */
+        uclong  rx_bufsize;     /* rx buffer size */
+        uclong  rx_threshold;   /* rx high water mark */
+        uclong  rx_get;         /* tail index rx buf */
+        uclong  rx_put;         /* head index rx buf */
+        uclong  filler[5];      /* filler to align structures */
+};
+
+/*
+ *      BOARD_CTRL - This per board structure contains all global 
+ *      control fields related to the board.
+ */
+
+struct BOARD_CTRL {
+
+        /* static info provided by the on-board CPU */
+        uclong  n_channel;      /* number of channels */
+        uclong  fw_version;     /* firmware version */
+
+        /* static info provided by the driver */
+        uclong  op_system;      /* op_system id */
+        uclong  dr_version;     /* driver version */
+
+        /* board control area */
+        uclong  inactivity;     /* inactivity control */
+
+        /* host to FW commands */
+        uclong  hcmd_channel;   /* channel number */
+        uclong  hcmd_param;     /* pointer to parameters */
+
+        /* FW to Host commands */
+        uclong  fwcmd_channel;  /* channel number */
+        uclong  fwcmd_param;    /* pointer to parameters */
+        uclong  zf_int_queue_addr; /* offset for INT_QUEUE structure */
+
+        /* filler so the structures are aligned */
+        uclong  filler[6];
+};
+
+/* Host Interrupt Queue */
+
+#define QUEUE_SIZE      (10*MAX_CHAN)
+
+struct  INT_QUEUE {
+        unsigned char   intr_code[QUEUE_SIZE];
+        unsigned long   channel[QUEUE_SIZE];
+        unsigned long   param[QUEUE_SIZE];
+        unsigned long   put;
+        unsigned long   get;
+};
+
+/*
+ *      ZFW_CTRL - This is the data structure that includes all other
+ *      data structures used by the Firmware.
+ */
+ 
+struct ZFW_CTRL {
+        struct BOARD_CTRL       board_ctrl;
+        struct CH_CTRL          ch_ctrl[MAX_CHAN];
+        struct BUF_CTRL         buf_ctrl[MAX_CHAN];
+};
+
+/****************** ****************** *******************/
+#endif
+
+/* Per card data structure */
+struct resource;
+struct cyclades_card {
+    unsigned long base_phys;
+    unsigned long ctl_phys;
+    void __iomem *base_addr;
+    void __iomem *ctl_addr;
+    int irq;
+    int num_chips;      /* 0 if card absent, -1 if Z/PCI, else Y */
+    int first_line;     /* minor number of first channel on card */
+    int nports;         /* Number of ports in the card */
+    int bus_index;      /* address shift - 0 for ISA, 1 for PCI */
+    int intr_enabled;   /* FW Interrupt flag - 0 disabled, 1 enabled */
+    struct pci_dev *pdev;
+#ifdef __KERNEL__
+    spinlock_t card_lock;
+#else
+    unsigned long filler;
+#endif
+};
+
+struct cyclades_chip {
+  int filler;
+};
+
+
+#ifdef __KERNEL__
+
+/***************************************
+ * Memory access functions/macros      *
+ * (required to support Alpha systems) *
+ ***************************************/
+
+#define cy_writeb(port,val)     {writeb((val),(port)); mb();}
+#define cy_writew(port,val)     {writew((val),(port)); mb();}
+#define cy_writel(port,val)     {writel((val),(port)); mb();}
+
+#define cy_readb(port)  readb(port)
+#define cy_readw(port)  readw(port)
+#define cy_readl(port)  readl(port)
+
+/*
+ * Statistics counters
+ */
+struct cyclades_icount {
+        __u32   cts, dsr, rng, dcd, tx, rx;
+        __u32   frame, parity, overrun, brk;
+        __u32   buf_overrun;
+};
+
+/*
+ * This is our internal structure for each serial port's state.
+ * 
+ * Many fields are paralleled by the structure used by the serial_struct
+ * structure.
+ *
+ * For definitions of the flags field, see tty.h
+ */
+
+struct cyclades_port {
+        int                     magic;
+        int                     card;
+        int                     line;
+        int                     flags;          /* defined in tty.h */
+        int                     type;           /* UART type */
+        struct tty_struct       *tty;
+        int                     read_status_mask;
+        int                     ignore_status_mask;
+        int                     timeout;
+        int                     xmit_fifo_size;
+        int                     cor1,cor2,cor3,cor4,cor5;
+        int                     tbpr,tco,rbpr,rco;
+        int                     baud;
+        int                     rflow;
+        int                     rtsdtr_inv;
+        int                     chip_rev;
+        int                     custom_divisor;
+        int                     x_char; /* to be pushed out ASAP */
+        int                     close_delay;
+        unsigned short          closing_wait;
+        unsigned long           event;
+        unsigned long           last_active;
+        int                     count;  /* # of fd on device */
+        int                     breakon;
+        int                     breakoff;
+        int                     blocked_open; /* # of blocked opens */
+        unsigned char           *xmit_buf;
+        int                     xmit_head;
+        int                     xmit_tail;
+        int                     xmit_cnt;
+        int                     default_threshold;
+        int                     default_timeout;
+        unsigned long           jiffies[3];
+        unsigned long           rflush_count;
+        struct cyclades_monitor mon;
+        struct cyclades_idle_stats      idle_stats;
+        struct cyclades_icount  icount;
+        struct work_struct      tqueue;
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        wait_queue_head_t       shutdown_wait;
+        wait_queue_head_t       delta_msr_wait;
+        int throttle;
+};
+
+/*
+ * Events are used to schedule things to happen at timer-interrupt
+ * time, instead of at cy interrupt time.
+ */
+#define Cy_EVENT_READ_PROCESS           0
+#define Cy_EVENT_WRITE_WAKEUP           1
+#define Cy_EVENT_HANGUP                 2
+#define Cy_EVENT_BREAK                  3
+#define Cy_EVENT_OPEN_WAKEUP            4
+#define Cy_EVENT_SHUTDOWN_WAKEUP        5
+#define Cy_EVENT_DELTA_WAKEUP           6
+#define Cy_EVENT_Z_RX_FULL              7
+
+#define CLOSING_WAIT_DELAY      30*HZ
+#define CY_CLOSING_WAIT_NONE    65535
+#define CY_CLOSING_WAIT_INF     0
+
+
+#define CyMAX_CHIPS_PER_CARD    8
+#define CyMAX_CHAR_FIFO         12
+#define CyPORTS_PER_CHIP        4
+#define CD1400_MAX_SPEED        115200
+
+#define CyISA_Ywin      0x2000
+
+#define CyPCI_Ywin      0x4000
+#define CyPCI_Yctl      0x80
+#define CyPCI_Zctl      CTRL_WINDOW_SIZE
+#define CyPCI_Zwin      0x80000
+#define CyPCI_Ze_win    (2 * CyPCI_Zwin)
+
+#define PCI_DEVICE_ID_MASK      0x06
+
+/**** CD1400 registers ****/
+
+#define CD1400_REV_G    0x46
+#define CD1400_REV_J    0x48
+
+#define CyRegSize       0x0400
+#define Cy_HwReset      0x1400
+#define Cy_ClrIntr      0x1800
+#define Cy_EpldRev      0x1e00
+
+/* Global Registers */
+
+#define CyGFRCR         (0x40*2)
+#define      CyRevE             (44)
+#define CyCAR           (0x68*2)
+#define      CyCHAN_0           (0x00)
+#define      CyCHAN_1           (0x01)
+#define      CyCHAN_2           (0x02)
+#define      CyCHAN_3           (0x03)
+#define CyGCR           (0x4B*2)
+#define      CyCH0_SERIAL       (0x00)
+#define      CyCH0_PARALLEL     (0x80)
+#define CySVRR          (0x67*2)
+#define      CySRModem          (0x04)
+#define      CySRTransmit       (0x02)
+#define      CySRReceive        (0x01)
+#define CyRICR          (0x44*2)
+#define CyTICR          (0x45*2)
+#define CyMICR          (0x46*2)
+#define      CyICR0             (0x00)
+#define      CyICR1             (0x01)
+#define      CyICR2             (0x02)
+#define      CyICR3             (0x03)
+#define CyRIR           (0x6B*2)
+#define CyTIR           (0x6A*2)
+#define CyMIR           (0x69*2)
+#define      CyIRDirEq          (0x80)
+#define      CyIRBusy           (0x40)
+#define      CyIRUnfair         (0x20)
+#define      CyIRContext        (0x1C)
+#define      CyIRChannel        (0x03)
+#define CyPPR           (0x7E*2)
+#define      CyCLOCK_20_1MS     (0x27)
+#define      CyCLOCK_25_1MS     (0x31)
+#define      CyCLOCK_25_5MS     (0xf4)
+#define      CyCLOCK_60_1MS     (0x75)
+#define      CyCLOCK_60_2MS     (0xea)
+
+/* Virtual Registers */
+
+#define CyRIVR          (0x43*2)
+#define CyTIVR          (0x42*2)
+#define CyMIVR          (0x41*2)
+#define      CyIVRMask (0x07)
+#define      CyIVRRxEx (0x07)
+#define      CyIVRRxOK (0x03)
+#define      CyIVRTxOK (0x02)
+#define      CyIVRMdmOK (0x01)
+#define CyTDR           (0x63*2)
+#define CyRDSR          (0x62*2)
+#define      CyTIMEOUT          (0x80)
+#define      CySPECHAR          (0x70)
+#define      CyBREAK            (0x08)
+#define      CyPARITY           (0x04)
+#define      CyFRAME            (0x02)
+#define      CyOVERRUN          (0x01)
+#define CyMISR          (0x4C*2)
+/* see CyMCOR_ and CyMSVR_ for bits*/
+#define CyEOSRR         (0x60*2)
+
+/* Channel Registers */
+
+#define CyLIVR          (0x18*2)
+#define      CyMscsr            (0x01)
+#define      CyTdsr             (0x02)
+#define      CyRgdsr            (0x03)
+#define      CyRedsr            (0x07)
+#define CyCCR           (0x05*2)
+/* Format 1 */
+#define      CyCHAN_RESET       (0x80)
+#define      CyCHIP_RESET       (0x81)
+#define      CyFlushTransFIFO   (0x82)
+/* Format 2 */
+#define      CyCOR_CHANGE       (0x40)
+#define      CyCOR1ch           (0x02)
+#define      CyCOR2ch           (0x04)
+#define      CyCOR3ch           (0x08)
+/* Format 3 */
+#define      CySEND_SPEC_1      (0x21)
+#define      CySEND_SPEC_2      (0x22)
+#define      CySEND_SPEC_3      (0x23)
+#define      CySEND_SPEC_4      (0x24)
+/* Format 4 */
+#define      CyCHAN_CTL         (0x10)
+#define      CyDIS_RCVR         (0x01)
+#define      CyENB_RCVR         (0x02)
+#define      CyDIS_XMTR         (0x04)
+#define      CyENB_XMTR         (0x08)
+#define CySRER          (0x06*2)
+#define      CyMdmCh            (0x80)
+#define      CyRxData           (0x10)
+#define      CyTxRdy            (0x04)
+#define      CyTxMpty           (0x02)
+#define      CyNNDT             (0x01)
+#define CyCOR1          (0x08*2)
+#define      CyPARITY_NONE      (0x00)
+#define      CyPARITY_0         (0x20)
+#define      CyPARITY_1         (0xA0)
+#define      CyPARITY_E         (0x40)
+#define      CyPARITY_O         (0xC0)
+#define      Cy_1_STOP          (0x00)
+#define      Cy_1_5_STOP        (0x04)
+#define      Cy_2_STOP          (0x08)
+#define      Cy_5_BITS          (0x00)
+#define      Cy_6_BITS          (0x01)
+#define      Cy_7_BITS          (0x02)
+#define      Cy_8_BITS          (0x03)
+#define CyCOR2          (0x09*2)
+#define      CyIXM              (0x80)
+#define      CyTxIBE            (0x40)
+#define      CyETC              (0x20)
+#define      CyAUTO_TXFL        (0x60)
+#define      CyLLM              (0x10)
+#define      CyRLM              (0x08)
+#define      CyRtsAO            (0x04)
+#define      CyCtsAE            (0x02)
+#define      CyDsrAE            (0x01)
+#define CyCOR3          (0x0A*2)
+#define      CySPL_CH_DRANGE    (0x80)  /* special character detect range */
+#define      CySPL_CH_DET1      (0x40)  /* enable special character detection
+                                                               on SCHR4-SCHR3 */
+#define      CyFL_CTRL_TRNSP    (0x20)  /* Flow Control Transparency */
+#define      CySPL_CH_DET2      (0x10)  /* Enable special character detection
+                                                               on SCHR2-SCHR1 */
+#define      CyREC_FIFO         (0x0F)  /* Receive FIFO threshold */
+#define CyCOR4          (0x1E*2)
+#define CyCOR5          (0x1F*2)
+#define CyCCSR          (0x0B*2)
+#define      CyRxEN             (0x80)
+#define      CyRxFloff          (0x40)
+#define      CyRxFlon           (0x20)
+#define      CyTxEN             (0x08)
+#define      CyTxFloff          (0x04)
+#define      CyTxFlon           (0x02)
+#define CyRDCR          (0x0E*2)
+#define CySCHR1         (0x1A*2)
+#define CySCHR2         (0x1B*2)
+#define CySCHR3         (0x1C*2)
+#define CySCHR4         (0x1D*2)
+#define CySCRL          (0x22*2)
+#define CySCRH          (0x23*2)
+#define CyLNC           (0x24*2)
+#define CyMCOR1         (0x15*2)
+#define CyMCOR2         (0x16*2)
+#define CyRTPR          (0x21*2)
+#define CyMSVR1         (0x6C*2)
+#define CyMSVR2         (0x6D*2)
+#define      CyANY_DELTA        (0xF0)
+#define      CyDSR              (0x80)
+#define      CyCTS              (0x40)
+#define      CyRI               (0x20)
+#define      CyDCD              (0x10)
+#define      CyDTR              (0x02)
+#define      CyRTS              (0x01)
+#define CyPVSR          (0x6F*2)
+#define CyRBPR          (0x78*2)
+#define CyRCOR          (0x7C*2)
+#define CyTBPR          (0x72*2)
+#define CyTCOR          (0x76*2)
+
+/* Custom Registers */
+
+#define CyPLX_VER       (0x3400)
+#define PLX_9050        0x0b
+#define PLX_9060        0x0c
+#define PLX_9080        0x0d
+
+/***************************************************************************/
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_CYCLADES_H */
diff --git a/include/linux/cyclomx.h b/include/linux/cyclomx.h
new file mode 100644
index 000000000000..04fa7dff079c
--- /dev/null
+++ b/include/linux/cyclomx.h
@@ -0,0 +1,80 @@
+#ifndef _CYCLOMX_H
+#define _CYCLOMX_H
+/*
+* cyclomx.h     Cyclom 2X WAN Link Driver.
+*               User-level API definitions.
+*
+* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+*
+* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
+*
+* Based on wanpipe.h by Gene Kozin <genek@compuserve.com>
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* 2000/07/13    acme            remove crap #if KERNEL_VERSION > blah
+* 2000/01/21    acme            rename cyclomx_open to cyclomx_mod_inc_use_count
+*                               and cyclomx_close to cyclomx_mod_dec_use_count
+* 1999/05/19    acme            wait_queue_head_t wait_stats(support for 2.3.*)
+* 1999/01/03    acme            judicious use of data types
+* 1998/12/27    acme            cleanup: PACKED not needed
+* 1998/08/08    acme            Version 0.0.1
+*/
+
+#include <linux/config.h>
+#include <linux/wanrouter.h>
+#include <linux/spinlock.h>
+
+#ifdef  __KERNEL__
+/* Kernel Interface */
+
+#include <linux/cycx_drv.h>     /* Cyclom 2X support module API definitions */
+#include <linux/cycx_cfm.h>     /* Cyclom 2X firmware module definitions */
+#ifdef CONFIG_CYCLOMX_X25
+#include <linux/cycx_x25.h>
+#endif
+
+#define is_digit(ch) (((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')?1:0)
+
+/* Adapter Data Space.
+ * This structure is needed because we handle multiple cards, otherwise
+ * static data would do it.
+ */
+struct cycx_device {
+        char devname[WAN_DRVNAME_SZ + 1];/* card name */
+        struct cycx_hw hw;              /* hardware configuration */
+        struct wan_device wandev;       /* WAN device data space */
+        u32 state_tick;                 /* link state timestamp */
+        spinlock_t lock;
+        char in_isr;                    /* interrupt-in-service flag */
+        char buff_int_mode_unbusy;      /* flag for carrying out dev_tint */
+        wait_queue_head_t wait_stats;  /* to wait for the STATS indication */
+        void __iomem *mbox;                     /* -> mailbox */
+        void (*isr)(struct cycx_device* card);  /* interrupt service routine */
+        int (*exec)(struct cycx_device* card, void* u_cmd, void* u_data);
+        union {
+#ifdef CONFIG_CYCLOMX_X25
+                struct { /* X.25 specific data */
+                        u32 lo_pvc;
+                        u32 hi_pvc;
+                        u32 lo_svc;
+                        u32 hi_svc;
+                        struct cycx_x25_stats stats;
+                        spinlock_t lock;
+                        u32 connection_keys;
+                } x;
+#endif
+        } u;
+};
+
+/* Public Functions */
+void cycx_set_state(struct cycx_device *card, int state);
+
+#ifdef CONFIG_CYCLOMX_X25
+int cycx_x25_wan_init(struct cycx_device *card, wandev_conf_t *conf);
+#endif
+#endif  /* __KERNEL__ */
+#endif  /* _CYCLOMX_H */
diff --git a/include/linux/cycx_cfm.h b/include/linux/cycx_cfm.h
new file mode 100644
index 000000000000..032d26ed8384
--- /dev/null
+++ b/include/linux/cycx_cfm.h
@@ -0,0 +1,101 @@
+/*
+* cycx_cfm.h    Cyclom 2X WAN Link Driver.
+*               Definitions for the Cyclom 2X Firmware Module (CFM).
+*
+* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+*
+* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
+*
+* Based on sdlasfm.h by Gene Kozin <74604.152@compuserve.com>
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* 1998/08/08    acme            Initial version.
+*/
+#ifndef _CYCX_CFM_H
+#define _CYCX_CFM_H
+
+/* Defines */
+
+#define CFM_VERSION     2
+#define CFM_SIGNATURE   "CFM - Cyclades CYCX Firmware Module"
+
+/* min/max */
+#define CFM_IMAGE_SIZE  0x20000 /* max size of CYCX code image file */
+#define CFM_DESCR_LEN   256     /* max length of description string */
+#define CFM_MAX_CYCX    1       /* max number of compatible adapters */
+#define CFM_LOAD_BUFSZ  0x400   /* buffer size for reset code (buffer_load) */
+
+/* Firmware Commands */
+#define GEN_POWER_ON    0x1280
+
+#define GEN_SET_SEG     0x1401  /* boot segment setting. */
+#define GEN_BOOT_DAT    0x1402  /* boot data. */
+#define GEN_START       0x1403  /* board start. */
+#define GEN_DEFPAR      0x1404  /* buffer length for boot. */
+
+/* Adapter Types */
+#define CYCX_2X         2
+/* for now only the 2X is supported, no plans to support 8X or 16X */
+#define CYCX_8X         8
+#define CYCX_16X        16
+
+#define CFID_X25_2X     5200
+
+/**
+ *      struct cycx_fw_info - firmware module information.
+ *      @codeid - firmware ID
+ *      @version - firmware version number
+ *      @adapter - compatible adapter types
+ *      @memsize - minimum memory size
+ *      @reserved - reserved
+ *      @startoffs - entry point offset
+ *      @winoffs - dual-port memory window offset
+ *      @codeoffs - code load offset
+ *      @codesize - code size
+ *      @dataoffs - configuration data load offset
+ *      @datasize - configuration data size
+ */
+struct cycx_fw_info {
+        unsigned short  codeid;
+        unsigned short  version;
+        unsigned short  adapter[CFM_MAX_CYCX];
+        unsigned long   memsize;
+        unsigned short  reserved[2];
+        unsigned short  startoffs;
+        unsigned short  winoffs;
+        unsigned short  codeoffs;
+        unsigned long   codesize;
+        unsigned short  dataoffs;
+        unsigned long   datasize;
+};
+
+/**
+ *      struct cycx_firmware - CYCX firmware file structure
+ *      @signature - CFM file signature
+ *      @version - file format version
+ *      @checksum - info + image
+ *      @reserved - reserved
+ *      @descr - description string
+ *      @info - firmware module info
+ *      @image - code image (variable size)
+ */
+struct cycx_firmware {
+        char                signature[80];
+        unsigned short      version;
+        unsigned short      checksum;
+        unsigned short      reserved[6];
+        char                descr[CFM_DESCR_LEN];
+        struct cycx_fw_info info;
+        unsigned char       image[0];
+};
+
+struct cycx_fw_header {
+        unsigned long  reset_size;
+        unsigned long  data_size;
+        unsigned long  code_size;
+};
+#endif  /* _CYCX_CFM_H */
diff --git a/include/linux/cycx_drv.h b/include/linux/cycx_drv.h
new file mode 100644
index 000000000000..6621df86a748
--- /dev/null
+++ b/include/linux/cycx_drv.h
@@ -0,0 +1,65 @@
+/*
+* cycx_drv.h    CYCX Support Module.  Kernel API Definitions.
+*
+* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+*
+* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
+*
+* Based on sdladrv.h by Gene Kozin <genek@compuserve.com>
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* 1999/10/23    acme            cycxhw_t cleanup
+* 1999/01/03    acme            more judicious use of data types...
+*                               uclong, ucchar, etc deleted, the u8, u16, u32
+*                               types are the portable way to go.
+* 1999/01/03    acme            judicious use of data types... u16, u32, etc
+* 1998/12/26    acme            FIXED_BUFFERS, CONF_OFFSET,
+*                               removal of cy_read{bwl}
+* 1998/08/08    acme            Initial version.
+*/
+#ifndef _CYCX_DRV_H
+#define _CYCX_DRV_H
+
+#define CYCX_WINDOWSIZE 0x4000  /* default dual-port memory window size */
+#define GEN_CYCX_INTR   0x02
+#define RST_ENABLE      0x04
+#define START_CPU       0x06
+#define RST_DISABLE     0x08
+#define FIXED_BUFFERS   0x08
+#define TEST_PATTERN    0xaa55
+#define CMD_OFFSET      0x20
+#define CONF_OFFSET     0x0380
+#define RESET_OFFSET    0x3c00  /* For reset file load */
+#define DATA_OFFSET     0x0100  /* For code and data files load */
+#define START_OFFSET    0x3ff0  /* 80186 starts here */
+
+/**
+ *      struct cycx_hw - Adapter hardware configuration
+ *      @fwid - firmware ID
+ *      @irq - interrupt request level
+ *      @dpmbase - dual-port memory base
+ *      @dpmsize - dual-port memory size
+ *      @reserved - reserved for future use
+ */
+struct cycx_hw {
+        u32 fwid;
+        int irq;
+        void __iomem *dpmbase;
+        u32 dpmsize;
+        u32 reserved[5];
+};
+
+/* Function Prototypes */
+extern int cycx_setup(struct cycx_hw *hw, void *sfm, u32 len, unsigned long base);
+extern int cycx_down(struct cycx_hw *hw);
+extern int cycx_peek(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
+extern int cycx_poke(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
+extern int cycx_exec(void __iomem *addr);
+
+extern void cycx_inten(struct cycx_hw *hw);
+extern void cycx_intr(struct cycx_hw *hw);
+#endif  /* _CYCX_DRV_H */
diff --git a/include/linux/cycx_x25.h b/include/linux/cycx_x25.h
new file mode 100644
index 000000000000..b10a7f3a8cac
--- /dev/null
+++ b/include/linux/cycx_x25.h
@@ -0,0 +1,125 @@
+#ifndef _CYCX_X25_H
+#define _CYCX_X25_H
+/*
+* cycx_x25.h    Cyclom X.25 firmware API definitions.
+*
+* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+*
+* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
+*
+* Based on sdla_x25.h by Gene Kozin <74604.152@compuserve.com>
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* 2000/04/02    acme            dprintk and cycx_debug
+* 1999/01/03    acme            judicious use of data types
+* 1999/01/02    acme            #define X25_ACK_N3      0x4411
+* 1998/12/28    acme            cleanup: lot'o'things removed
+*                                        commands listed,
+*                                        TX25Cmd & TX25Config structs
+*                                        typedef'ed
+*/
+#ifndef PACKED
+#define PACKED __attribute__((packed))
+#endif 
+
+/* X.25 shared memory layout. */
+#define X25_MBOX_OFFS   0x300   /* general mailbox block */
+#define X25_RXMBOX_OFFS 0x340   /* receive mailbox */
+
+/* Debug */
+#define dprintk(level, format, a...) if (cycx_debug >= level) printk(format, ##a)
+
+extern unsigned int cycx_debug;
+
+/* Data Structures */
+/* X.25 Command Block. */
+struct cycx_x25_cmd {
+        u16 command PACKED;
+        u16 link    PACKED; /* values: 0 or 1 */
+        u16 len     PACKED; /* values: 0 thru 0x205 (517) */
+        u32 buf     PACKED;
+};
+
+/* Defines for the 'command' field. */
+#define X25_CONNECT_REQUEST             0x4401
+#define X25_CONNECT_RESPONSE            0x4402
+#define X25_DISCONNECT_REQUEST          0x4403
+#define X25_DISCONNECT_RESPONSE         0x4404
+#define X25_DATA_REQUEST                0x4405
+#define X25_ACK_TO_VC                   0x4406
+#define X25_INTERRUPT_RESPONSE          0x4407
+#define X25_CONFIG                      0x4408
+#define X25_CONNECT_INDICATION          0x4409
+#define X25_CONNECT_CONFIRM             0x440A
+#define X25_DISCONNECT_INDICATION       0x440B
+#define X25_DISCONNECT_CONFIRM          0x440C
+#define X25_DATA_INDICATION             0x440E
+#define X25_INTERRUPT_INDICATION        0x440F
+#define X25_ACK_FROM_VC                 0x4410
+#define X25_ACK_N3                      0x4411
+#define X25_CONNECT_COLLISION           0x4413
+#define X25_N3WIN                       0x4414
+#define X25_LINE_ON                     0x4415
+#define X25_LINE_OFF                    0x4416
+#define X25_RESET_REQUEST               0x4417
+#define X25_LOG                         0x4500
+#define X25_STATISTIC                   0x4600
+#define X25_TRACE                       0x4700
+#define X25_N2TRACEXC                   0x4702
+#define X25_N3TRACEXC                   0x4703
+
+/**
+ *      struct cycx_x25_config - cyclom2x x25 firmware configuration
+ *      @link - link number
+ *      @speed - line speed
+ *      @clock - internal/external
+ *      @n2 - # of level 2 retransm.(values: 1 thru FF)
+ *      @n2win - level 2 window (values: 1 thru 7)
+ *      @n3win - level 3 window (values: 1 thru 7)
+ *      @nvc - # of logical channels (values: 1 thru 64)
+ *      @pktlen - level 3 packet lenght - log base 2 of size
+ *      @locaddr - my address
+ *      @remaddr - remote address
+ *      @t1 - time, in seconds
+ *      @t2 - time, in seconds
+ *      @t21 - time, in seconds
+ *      @npvc - # of permanent virt. circuits (1 thru nvc)
+ *      @t23 - time, in seconds
+ *      @flags - see dosx25.doc, in portuguese, for details
+ */
+struct cycx_x25_config {
+        u8  link        PACKED;
+        u8  speed       PACKED;
+        u8  clock       PACKED;
+        u8  n2          PACKED;
+        u8  n2win       PACKED;
+        u8  n3win       PACKED;
+        u8  nvc         PACKED;
+        u8  pktlen      PACKED;
+        u8  locaddr     PACKED;
+        u8  remaddr     PACKED;
+        u16 t1          PACKED;
+        u16 t2          PACKED;
+        u8  t21         PACKED;
+        u8  npvc        PACKED;
+        u8  t23         PACKED;
+        u8  flags       PACKED;
+};
+
+struct cycx_x25_stats {
+        u16 rx_crc_errors       PACKED;
+        u16 rx_over_errors      PACKED;
+        u16 n2_tx_frames        PACKED;
+        u16 n2_rx_frames        PACKED;
+        u16 tx_timeouts         PACKED;
+        u16 rx_timeouts         PACKED;
+        u16 n3_tx_packets       PACKED;
+        u16 n3_rx_packets       PACKED;
+        u16 tx_aborts           PACKED;
+        u16 rx_aborts           PACKED;
+};
+#endif  /* _CYCX_X25_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
new file mode 100644
index 000000000000..50be290d24d2
--- /dev/null
+++ b/include/linux/dcache.h
@@ -0,0 +1,338 @@
+#ifndef __LINUX_DCACHE_H
+#define __LINUX_DCACHE_H
+
+#ifdef __KERNEL__
+
+#include <asm/atomic.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/cache.h>
+#include <linux/rcupdate.h>
+#include <asm/bug.h>
+
+struct nameidata;
+struct vfsmount;
+
+/*
+ * linux/include/linux/dcache.h
+ *
+ * Dirent cache data structures
+ *
+ * (C) Copyright 1997 Thomas Schoebel-Theuer,
+ * with heavy changes by Linus Torvalds
+ */
+
+#define IS_ROOT(x) ((x) == (x)->d_parent)
+
+/*
+ * "quick string" -- eases parameter passing, but more importantly
+ * saves "metadata" about the string (ie length and the hash).
+ *
+ * hash comes first so it snuggles against d_parent in the
+ * dentry.
+ */
+struct qstr {
+        unsigned int hash;
+        unsigned int len;
+        const unsigned char *name;
+};
+
+struct dentry_stat_t {
+        int nr_dentry;
+        int nr_unused;
+        int age_limit;          /* age in seconds */
+        int want_pages;         /* pages requested by system */
+        int dummy[2];
+};
+extern struct dentry_stat_t dentry_stat;
+
+/* Name hashing routines. Initial hash value */
+/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
+#define init_name_hash()                0
+
+/* partial hash update function. Assume roughly 4 bits per character */
+static inline unsigned long
+partial_name_hash(unsigned long c, unsigned long prevhash)
+{
+        return (prevhash + (c << 4) + (c >> 4)) * 11;
+}
+
+/*
+ * Finally: cut down the number of bits to a int value (and try to avoid
+ * losing bits)
+ */
+static inline unsigned long end_name_hash(unsigned long hash)
+{
+        return (unsigned int) hash;
+}
+
+/* Compute the hash for a name string. */
+static inline unsigned int
+full_name_hash(const unsigned char *name, unsigned int len)
+{
+        unsigned long hash = init_name_hash();
+        while (len--)
+                hash = partial_name_hash(*name++, hash);
+        return end_name_hash(hash);
+}
+
+struct dcookie_struct;
+
+#define DNAME_INLINE_LEN_MIN 36
+
+struct dentry {
+        atomic_t d_count;
+        unsigned int d_flags;           /* protected by d_lock */
+        spinlock_t d_lock;              /* per dentry lock */
+        struct inode *d_inode;          /* Where the name belongs to - NULL is
+                                         * negative */
+        /*
+         * The next three fields are touched by __d_lookup.  Place them here
+         * so they all fit in a 16-byte range, with 16-byte alignment.
+         */
+        struct dentry *d_parent;        /* parent directory */
+        struct qstr d_name;
+
+        struct list_head d_lru;         /* LRU list */
+        struct list_head d_child;       /* child of parent list */
+        struct list_head d_subdirs;     /* our children */
+        struct list_head d_alias;       /* inode alias list */
+        unsigned long d_time;           /* used by d_revalidate */
+        struct dentry_operations *d_op;
+        struct super_block *d_sb;       /* The root of the dentry tree */
+        void *d_fsdata;                 /* fs-specific data */
+        struct rcu_head d_rcu;
+        struct dcookie_struct *d_cookie; /* cookie, if any */
+        struct hlist_node d_hash;       /* lookup hash list */  
+        int d_mounted;
+        unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
+};
+
+struct dentry_operations {
+        int (*d_revalidate)(struct dentry *, struct nameidata *);
+        int (*d_hash) (struct dentry *, struct qstr *);
+        int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
+        int (*d_delete)(struct dentry *);
+        void (*d_release)(struct dentry *);
+        void (*d_iput)(struct dentry *, struct inode *);
+};
+
+/* the dentry parameter passed to d_hash and d_compare is the parent
+ * directory of the entries to be compared. It is used in case these
+ * functions need any directory specific information for determining
+ * equivalency classes.  Using the dentry itself might not work, as it
+ * might be a negative dentry which has no information associated with
+ * it */
+
+/*
+locking rules:
+                big lock        dcache_lock     d_lock   may block
+d_revalidate:   no              no              no       yes
+d_hash          no              no              no       yes
+d_compare:      no              yes             yes      no
+d_delete:       no              yes             no       no
+d_release:      no              no              no       yes
+d_iput:         no              no              no       yes
+ */
+
+/* d_flags entries */
+#define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
+#define DCACHE_NFSFS_RENAMED  0x0002    /* this dentry has been "silly
+                                         * renamed" and has to be
+                                         * deleted on the last dput()
+                                         */
+#define DCACHE_DISCONNECTED 0x0004
+     /* This dentry is possibly not currently connected to the dcache tree,
+      * in which case its parent will either be itself, or will have this
+      * flag as well.  nfsd will not use a dentry with this bit set, but will
+      * first endeavour to clear the bit either by discovering that it is
+      * connected, or by performing lookup operations.   Any filesystem which
+      * supports nfsd_operations MUST have a lookup function which, if it finds
+      * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
+      * that dentry into place and return that dentry rather than the passed one,
+      * typically using d_splice_alias.
+      */
+
+#define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
+#define DCACHE_UNHASHED         0x0010  
+
+extern spinlock_t dcache_lock;
+
+/**
+ * d_drop - drop a dentry
+ * @dentry: dentry to drop
+ *
+ * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
+ * be found through a VFS lookup any more. Note that this is different from
+ * deleting the dentry - d_delete will try to mark the dentry negative if
+ * possible, giving a successful _negative_ lookup, while d_drop will
+ * just make the cache lookup fail.
+ *
+ * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
+ * reason (NFS timeouts or autofs deletes).
+ *
+ * __d_drop requires dentry->d_lock.
+ */
+
+static inline void __d_drop(struct dentry *dentry)
+{
+        if (!(dentry->d_flags & DCACHE_UNHASHED)) {
+                dentry->d_flags |= DCACHE_UNHASHED;
+                hlist_del_rcu(&dentry->d_hash);
+        }
+}
+
+static inline void d_drop(struct dentry *dentry)
+{
+        spin_lock(&dcache_lock);
+        spin_lock(&dentry->d_lock);
+        __d_drop(dentry);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&dcache_lock);
+}
+
+static inline int dname_external(struct dentry *dentry)
+{
+        return dentry->d_name.name != dentry->d_iname;
+}
+
+/*
+ * These are the low-level FS interfaces to the dcache..
+ */
+extern void d_instantiate(struct dentry *, struct inode *);
+extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
+extern void d_delete(struct dentry *);
+
+/* allocate/de-allocate */
+extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
+extern struct dentry * d_alloc_anon(struct inode *);
+extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
+extern void shrink_dcache_sb(struct super_block *);
+extern void shrink_dcache_parent(struct dentry *);
+extern void shrink_dcache_anon(struct hlist_head *);
+extern int d_invalidate(struct dentry *);
+
+/* only used at mount-time */
+extern struct dentry * d_alloc_root(struct inode *);
+
+/* <clickety>-<click> the ramfs-type tree */
+extern void d_genocide(struct dentry *);
+
+extern struct dentry *d_find_alias(struct inode *);
+extern void d_prune_aliases(struct inode *);
+
+/* test whether we have any submounts in a subdir tree */
+extern int have_submounts(struct dentry *);
+
+/*
+ * This adds the entry to the hash queues.
+ */
+extern void d_rehash(struct dentry *);
+
+/**
+ * d_add - add dentry to hash queues
+ * @entry: dentry to add
+ * @inode: The inode to attach to this dentry
+ *
+ * This adds the entry to the hash queues and initializes @inode.
+ * The entry was actually filled in earlier during d_alloc().
+ */
+ 
+static inline void d_add(struct dentry *entry, struct inode *inode)
+{
+        d_instantiate(entry, inode);
+        d_rehash(entry);
+}
+
+/**
+ * d_add_unique - add dentry to hash queues without aliasing
+ * @entry: dentry to add
+ * @inode: The inode to attach to this dentry
+ *
+ * This adds the entry to the hash queues and initializes @inode.
+ * The entry was actually filled in earlier during d_alloc().
+ */
+static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
+{
+        struct dentry *res;
+
+        res = d_instantiate_unique(entry, inode);
+        d_rehash(res != NULL ? res : entry);
+        return res;
+}
+
+/* used for rename() and baskets */
+extern void d_move(struct dentry *, struct dentry *);
+
+/* appendix may either be NULL or be used for transname suffixes */
+extern struct dentry * d_lookup(struct dentry *, struct qstr *);
+extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
+
+/* validate "insecure" dentry pointer */
+extern int d_validate(struct dentry *, struct dentry *);
+
+extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
+  
+/* Allocation counts.. */
+
+/**
+ *      dget, dget_locked       -       get a reference to a dentry
+ *      @dentry: dentry to get a reference to
+ *
+ *      Given a dentry or %NULL pointer increment the reference count
+ *      if appropriate and return the dentry. A dentry will not be 
+ *      destroyed when it has references. dget() should never be
+ *      called for dentries with zero reference counter. For these cases
+ *      (preferably none, functions in dcache.c are sufficient for normal
+ *      needs and they take necessary precautions) you should hold dcache_lock
+ *      and call dget_locked() instead of dget().
+ */
+ 
+static inline struct dentry *dget(struct dentry *dentry)
+{
+        if (dentry) {
+                BUG_ON(!atomic_read(&dentry->d_count));
+                atomic_inc(&dentry->d_count);
+        }
+        return dentry;
+}
+
+extern struct dentry * dget_locked(struct dentry *);
+
+/**
+ *      d_unhashed -    is dentry hashed
+ *      @dentry: entry to check
+ *
+ *      Returns true if the dentry passed is not currently hashed.
+ */
+ 
+static inline int d_unhashed(struct dentry *dentry)
+{
+        return (dentry->d_flags & DCACHE_UNHASHED);
+}
+
+static inline struct dentry *dget_parent(struct dentry *dentry)
+{
+        struct dentry *ret;
+
+        spin_lock(&dentry->d_lock);
+        ret = dget(dentry->d_parent);
+        spin_unlock(&dentry->d_lock);
+        return ret;
+}
+
+extern void dput(struct dentry *);
+
+static inline int d_mountpoint(struct dentry *dentry)
+{
+        return dentry->d_mounted;
+}
+
+extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
+extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
+
+extern int sysctl_vfs_cache_pressure;
+
+#endif /* __KERNEL__ */
+
+#endif  /* __LINUX_DCACHE_H */
diff --git a/include/linux/dcookies.h b/include/linux/dcookies.h
new file mode 100644
index 000000000000..c28050136164
--- /dev/null
+++ b/include/linux/dcookies.h
@@ -0,0 +1,69 @@
+/*
+ * dcookies.h
+ *
+ * Persistent cookie-path mappings
+ *
+ * Copyright 2002 John Levon <levon@movementarian.org>
+ */
+
+#ifndef DCOOKIES_H
+#define DCOOKIES_H
+ 
+#include <linux/config.h>
+
+#ifdef CONFIG_PROFILING
+ 
+#include <linux/types.h>
+ 
+struct dcookie_user;
+ 
+/**
+ * dcookie_register - register a user of dcookies
+ *
+ * Register as a dcookie user. Returns %NULL on failure.
+ */
+struct dcookie_user * dcookie_register(void);
+
+/**
+ * dcookie_unregister - unregister a user of dcookies
+ *
+ * Unregister as a dcookie user. This may invalidate
+ * any dcookie values returned from get_dcookie().
+ */
+void dcookie_unregister(struct dcookie_user * user);
+  
+/**
+ * get_dcookie - acquire a dcookie
+ *
+ * Convert the given dentry/vfsmount pair into
+ * a cookie value.
+ *
+ * Returns -EINVAL if no living task has registered as a
+ * dcookie user.
+ *
+ * Returns 0 on success, with *cookie filled in
+ */
+int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
+        unsigned long * cookie);
+
+#else
+
+struct dcookie_user * dcookie_register(void)
+{
+        return NULL;
+}
+
+void dcookie_unregister(struct dcookie_user * user)
+{
+        return;
+}
+ 
+static inline int get_dcookie(struct dentry * dentry,
+        struct vfsmount * vfsmnt, unsigned long * cookie)
+{
+        return -ENOSYS;
+} 
+ 
+#endif /* CONFIG_PROFILING */
+ 
+#endif /* DCOOKIES_H */
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
new file mode 100644
index 000000000000..f7a7b86f6eef
--- /dev/null
+++ b/include/linux/debugfs.h
@@ -0,0 +1,92 @@
+/*
+ *  debugfs.h - a tiny little debug file system
+ *
+ *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
+ *  Copyright (C) 2004 IBM Inc.
+ *
+ *      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.
+ *
+ *  debugfs is for people to use instead of /proc or /sys.
+ *  See Documentation/DocBook/kernel-api for more details.
+ */
+
+#ifndef _DEBUGFS_H_
+#define _DEBUGFS_H_
+
+#include <linux/fs.h>
+
+#if defined(CONFIG_DEBUG_FS)
+struct dentry *debugfs_create_file(const char *name, mode_t mode,
+                                   struct dentry *parent, void *data,
+                                   struct file_operations *fops);
+
+struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
+
+void debugfs_remove(struct dentry *dentry);
+
+struct dentry *debugfs_create_u8(const char *name, mode_t mode,
+                                 struct dentry *parent, u8 *value);
+struct dentry *debugfs_create_u16(const char *name, mode_t mode,
+                                  struct dentry *parent, u16 *value);
+struct dentry *debugfs_create_u32(const char *name, mode_t mode,
+                                  struct dentry *parent, u32 *value);
+struct dentry *debugfs_create_bool(const char *name, mode_t mode,
+                                  struct dentry *parent, u32 *value);
+
+#else
+/* 
+ * We do not return NULL from these functions if CONFIG_DEBUG_FS is not enabled
+ * so users have a chance to detect if there was a real error or not.  We don't
+ * want to duplicate the design decision mistakes of procfs and devfs again.
+ */
+
+static inline struct dentry *debugfs_create_file(const char *name, mode_t mode,
+                                                 struct dentry *parent,
+                                                 void *data,
+                                                 struct file_operations *fops)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline struct dentry *debugfs_create_dir(const char *name,
+                                                struct dentry *parent)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline void debugfs_remove(struct dentry *dentry)
+{ }
+
+static inline struct dentry *debugfs_create_u8(const char *name, mode_t mode,
+                                               struct dentry *parent,
+                                               u8 *value)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline struct dentry *debugfs_create_u16(const char *name, mode_t mode,
+                                                struct dentry *parent,
+                                                u8 *value)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline struct dentry *debugfs_create_u32(const char *name, mode_t mode,
+                                                struct dentry *parent,
+                                                u8 *value)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline struct dentry *debugfs_create_bool(const char *name, mode_t mode,
+                                                 struct dentry *parent,
+                                                 u8 *value)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+#endif
+
+#endif
diff --git a/include/linux/delay.h b/include/linux/delay.h
new file mode 100644
index 000000000000..acb74865b973
--- /dev/null
+++ b/include/linux/delay.h
@@ -0,0 +1,50 @@
+#ifndef _LINUX_DELAY_H
+#define _LINUX_DELAY_H
+
+/*
+ * Copyright (C) 1993 Linus Torvalds
+ *
+ * Delay routines, using a pre-computed "loops_per_jiffy" value.
+ */
+
+extern unsigned long loops_per_jiffy;
+
+#include <asm/delay.h>
+
+/*
+ * Using udelay() for intervals greater than a few milliseconds can
+ * risk overflow for high loops_per_jiffy (high bogomips) machines. The
+ * mdelay() provides a wrapper to prevent this.  For delays greater
+ * than MAX_UDELAY_MS milliseconds, the wrapper is used.  Architecture
+ * specific values can be defined in asm-???/delay.h as an override.
+ * The 2nd mdelay() definition ensures GCC will optimize away the 
+ * while loop for the common cases where n <= MAX_UDELAY_MS  --  Paul G.
+ */
+
+#ifndef MAX_UDELAY_MS
+#define MAX_UDELAY_MS   5
+#endif
+
+#ifdef notdef
+#define mdelay(n) (\
+        {unsigned long __ms=(n); while (__ms--) udelay(1000);})
+#else
+#define mdelay(n) (\
+        (__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : \
+        ({unsigned long __ms=(n); while (__ms--) udelay(1000);}))
+#endif
+
+#ifndef ndelay
+#define ndelay(x)       udelay(((x)+999)/1000)
+#endif
+
+void calibrate_delay(void);
+void msleep(unsigned int msecs);
+unsigned long msleep_interruptible(unsigned int msecs);
+
+static inline void ssleep(unsigned int seconds)
+{
+        msleep(seconds * 1000);
+}
+
+#endif /* defined(_LINUX_DELAY_H) */
diff --git a/include/linux/devfs_fs.h b/include/linux/devfs_fs.h
new file mode 100644
index 000000000000..de236f431877
--- /dev/null
+++ b/include/linux/devfs_fs.h
@@ -0,0 +1,41 @@
+#ifndef _LINUX_DEVFS_FS_H
+#define _LINUX_DEVFS_FS_H
+
+#include <linux/ioctl.h>
+
+#define DEVFSD_PROTOCOL_REVISION_KERNEL  5
+
+#define DEVFSD_IOCTL_BASE       'd'
+
+/*  These are the various ioctls  */
+#define DEVFSDIOC_GET_PROTO_REV         _IOR(DEVFSD_IOCTL_BASE, 0, int)
+#define DEVFSDIOC_SET_EVENT_MASK        _IOW(DEVFSD_IOCTL_BASE, 2, int)
+#define DEVFSDIOC_RELEASE_EVENT_QUEUE   _IOW(DEVFSD_IOCTL_BASE, 3, int)
+#define DEVFSDIOC_SET_DEBUG_MASK        _IOW(DEVFSD_IOCTL_BASE, 4, int)
+
+#define DEVFSD_NOTIFY_REGISTERED    0
+#define DEVFSD_NOTIFY_UNREGISTERED  1
+#define DEVFSD_NOTIFY_ASYNC_OPEN    2
+#define DEVFSD_NOTIFY_CLOSE         3
+#define DEVFSD_NOTIFY_LOOKUP        4
+#define DEVFSD_NOTIFY_CHANGE        5
+#define DEVFSD_NOTIFY_CREATE        6
+#define DEVFSD_NOTIFY_DELETE        7
+
+#define DEVFS_PATHLEN               1024        /*  Never change this otherwise the
+                                                   binary interface will change   */
+
+struct devfsd_notify_struct {   /*  Use native C types to ensure same types in kernel and user space     */
+        unsigned int type;      /*  DEVFSD_NOTIFY_* value                   */
+        unsigned int mode;      /*  Mode of the inode or device entry       */
+        unsigned int major;     /*  Major number of device entry            */
+        unsigned int minor;     /*  Minor number of device entry            */
+        unsigned int uid;       /*  Uid of process, inode or device entry   */
+        unsigned int gid;       /*  Gid of process, inode or device entry   */
+        unsigned int overrun_count;     /*  Number of lost events                   */
+        unsigned int namelen;   /*  Number of characters not including '\0' */
+        /*  The device name MUST come last                                       */
+        char devname[DEVFS_PATHLEN];    /*  This will be '\0' terminated            */
+};
+
+#endif                          /*  _LINUX_DEVFS_FS_H  */
diff --git a/include/linux/devfs_fs_kernel.h b/include/linux/devfs_fs_kernel.h
new file mode 100644
index 000000000000..89810e73d256
--- /dev/null
+++ b/include/linux/devfs_fs_kernel.h
@@ -0,0 +1,58 @@
+#ifndef _LINUX_DEVFS_FS_KERNEL_H
+#define _LINUX_DEVFS_FS_KERNEL_H
+
+#include <linux/fs.h>
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <asm/semaphore.h>
+
+#define DEVFS_SUPER_MAGIC                0x1373
+
+#ifdef CONFIG_DEVFS_FS
+extern int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...)
+    __attribute__ ((format(printf, 3, 4)));
+extern int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...)
+    __attribute__ ((format(printf, 3, 4)));
+extern int devfs_mk_symlink(const char *name, const char *link);
+extern int devfs_mk_dir(const char *fmt, ...)
+    __attribute__ ((format(printf, 1, 2)));
+extern void devfs_remove(const char *fmt, ...)
+    __attribute__ ((format(printf, 1, 2)));
+extern int devfs_register_tape(const char *name);
+extern void devfs_unregister_tape(int num);
+extern void mount_devfs_fs(void);
+#else                           /*  CONFIG_DEVFS_FS  */
+static inline int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...)
+{
+        return 0;
+}
+static inline int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...)
+{
+        return 0;
+}
+static inline int devfs_mk_symlink(const char *name, const char *link)
+{
+        return 0;
+}
+static inline int devfs_mk_dir(const char *fmt, ...)
+{
+        return 0;
+}
+static inline void devfs_remove(const char *fmt, ...)
+{
+}
+static inline int devfs_register_tape(const char *name)
+{
+        return -1;
+}
+static inline void devfs_unregister_tape(int num)
+{
+}
+static inline void mount_devfs_fs(void)
+{
+        return;
+}
+#endif                          /*  CONFIG_DEVFS_FS  */
+#endif                          /*  _LINUX_DEVFS_FS_KERNEL_H  */
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
new file mode 100644
index 000000000000..83c7d207b80e
--- /dev/null
+++ b/include/linux/device-mapper.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is released under the LGPL.
+ */
+
+#ifndef _LINUX_DEVICE_MAPPER_H
+#define _LINUX_DEVICE_MAPPER_H
+
+struct dm_target;
+struct dm_table;
+struct dm_dev;
+
+typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
+
+union map_info {
+        void *ptr;
+        unsigned long long ll;
+};
+
+/*
+ * In the constructor the target parameter will already have the
+ * table, type, begin and len fields filled in.
+ */
+typedef int (*dm_ctr_fn) (struct dm_target *target,
+                          unsigned int argc, char **argv);
+
+/*
+ * The destructor doesn't need to free the dm_target, just
+ * anything hidden ti->private.
+ */
+typedef void (*dm_dtr_fn) (struct dm_target *ti);
+
+/*
+ * The map function must return:
+ * < 0: error
+ * = 0: The target will handle the io by resubmitting it later
+ * > 0: simple remap complete
+ */
+typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio,
+                          union map_info *map_context);
+
+/*
+ * Returns:
+ * < 0 : error (currently ignored)
+ * 0   : ended successfully
+ * 1   : for some reason the io has still not completed (eg,
+ *       multipath target might want to requeue a failed io).
+ */
+typedef int (*dm_endio_fn) (struct dm_target *ti,
+                            struct bio *bio, int error,
+                            union map_info *map_context);
+
+typedef void (*dm_presuspend_fn) (struct dm_target *ti);
+typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
+typedef void (*dm_resume_fn) (struct dm_target *ti);
+
+typedef int (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
+                             char *result, unsigned int maxlen);
+
+typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
+
+void dm_error(const char *message);
+
+/*
+ * Constructors should call these functions to ensure destination devices
+ * are opened/closed correctly.
+ * FIXME: too many arguments.
+ */
+int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
+                  sector_t len, int mode, struct dm_dev **result);
+void dm_put_device(struct dm_target *ti, struct dm_dev *d);
+
+/*
+ * Information about a target type
+ */
+struct target_type {
+        const char *name;
+        struct module *module;
+        unsigned version[3];
+        dm_ctr_fn ctr;
+        dm_dtr_fn dtr;
+        dm_map_fn map;
+        dm_endio_fn end_io;
+        dm_presuspend_fn presuspend;
+        dm_postsuspend_fn postsuspend;
+        dm_resume_fn resume;
+        dm_status_fn status;
+        dm_message_fn message;
+};
+
+struct io_restrictions {
+        unsigned short          max_sectors;
+        unsigned short          max_phys_segments;
+        unsigned short          max_hw_segments;
+        unsigned short          hardsect_size;
+        unsigned int            max_segment_size;
+        unsigned long           seg_boundary_mask;
+};
+
+struct dm_target {
+        struct dm_table *table;
+        struct target_type *type;
+
+        /* target limits */
+        sector_t begin;
+        sector_t len;
+
+        /* FIXME: turn this into a mask, and merge with io_restrictions */
+        /* Always a power of 2 */
+        sector_t split_io;
+
+        /*
+         * These are automatically filled in by
+         * dm_table_get_device.
+         */
+        struct io_restrictions limits;
+
+        /* target specific data */
+        void *private;
+
+        /* Used to provide an error string from the ctr */
+        char *error;
+};
+
+int dm_register_target(struct target_type *t);
+int dm_unregister_target(struct target_type *t);
+
+#endif                          /* _LINUX_DEVICE_MAPPER_H */
diff --git a/include/linux/device.h b/include/linux/device.h
new file mode 100644
index 000000000000..cf470459fa69
--- /dev/null
+++ b/include/linux/device.h
@@ -0,0 +1,426 @@
+/*
+ * device.h - generic, centralized driver model
+ *
+ * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
+ *
+ * This file is released under the GPLv2
+ *
+ * See Documentation/driver-model/ for more information.
+ */
+
+#ifndef _DEVICE_H_
+#define _DEVICE_H_
+
+#include <linux/config.h>
+#include <linux/ioport.h>
+#include <linux/kobject.h>
+#include <linux/list.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/pm.h>
+#include <asm/semaphore.h>
+#include <asm/atomic.h>
+
+#define DEVICE_NAME_SIZE        50
+#define DEVICE_NAME_HALF        __stringify(20) /* Less than half to accommodate slop */
+#define DEVICE_ID_SIZE          32
+#define BUS_ID_SIZE             KOBJ_NAME_LEN
+
+
+enum {
+        SUSPEND_NOTIFY,
+        SUSPEND_SAVE_STATE,
+        SUSPEND_DISABLE,
+        SUSPEND_POWER_DOWN,
+};
+
+enum {
+        RESUME_POWER_ON,
+        RESUME_RESTORE_STATE,
+        RESUME_ENABLE,
+};
+
+struct device;
+struct device_driver;
+struct class;
+struct class_device;
+struct class_simple;
+
+struct bus_type {
+        char                    * name;
+
+        struct subsystem        subsys;
+        struct kset             drivers;
+        struct kset             devices;
+
+        struct bus_attribute    * bus_attrs;
+        struct device_attribute * dev_attrs;
+        struct driver_attribute * drv_attrs;
+
+        int             (*match)(struct device * dev, struct device_driver * drv);
+        int             (*hotplug) (struct device *dev, char **envp, 
+                                    int num_envp, char *buffer, int buffer_size);
+        int             (*suspend)(struct device * dev, pm_message_t state);
+        int             (*resume)(struct device * dev);
+};
+
+extern int bus_register(struct bus_type * bus);
+extern void bus_unregister(struct bus_type * bus);
+
+extern int bus_rescan_devices(struct bus_type * bus);
+
+extern struct bus_type * get_bus(struct bus_type * bus);
+extern void put_bus(struct bus_type * bus);
+
+extern struct bus_type * find_bus(char * name);
+
+/* iterator helpers for buses */
+
+int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
+                     int (*fn)(struct device *, void *));
+
+int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, 
+                     void * data, int (*fn)(struct device_driver *, void *));
+
+
+/* driverfs interface for exporting bus attributes */
+
+struct bus_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct bus_type *, char * buf);
+        ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
+};
+
+#define BUS_ATTR(_name,_mode,_show,_store)      \
+struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+extern int bus_create_file(struct bus_type *, struct bus_attribute *);
+extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
+
+struct device_driver {
+        char                    * name;
+        struct bus_type         * bus;
+
+        struct completion       unloaded;
+        struct kobject          kobj;
+        struct list_head        devices;
+
+        struct module           * owner;
+
+        int     (*probe)        (struct device * dev);
+        int     (*remove)       (struct device * dev);
+        void    (*shutdown)     (struct device * dev);
+        int     (*suspend)      (struct device * dev, pm_message_t state, u32 level);
+        int     (*resume)       (struct device * dev, u32 level);
+};
+
+
+extern int driver_register(struct device_driver * drv);
+extern void driver_unregister(struct device_driver * drv);
+
+extern struct device_driver * get_driver(struct device_driver * drv);
+extern void put_driver(struct device_driver * drv);
+extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
+
+
+/* driverfs interface for exporting driver attributes */
+
+struct driver_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct device_driver *, char * buf);
+        ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
+};
+
+#define DRIVER_ATTR(_name,_mode,_show,_store)   \
+struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+extern int driver_create_file(struct device_driver *, struct driver_attribute *);
+extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
+
+
+/*
+ * device classes
+ */
+struct class {
+        char                    * name;
+
+        struct subsystem        subsys;
+        struct list_head        children;
+        struct list_head        interfaces;
+        struct semaphore        sem;    /* locks both the children and interfaces lists */
+
+        struct class_attribute          * class_attrs;
+        struct class_device_attribute   * class_dev_attrs;
+
+        int     (*hotplug)(struct class_device *dev, char **envp, 
+                           int num_envp, char *buffer, int buffer_size);
+
+        void    (*release)(struct class_device *dev);
+        void    (*class_release)(struct class *class);
+};
+
+extern int class_register(struct class *);
+extern void class_unregister(struct class *);
+
+extern struct class * class_get(struct class *);
+extern void class_put(struct class *);
+
+
+struct class_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct class *, char * buf);
+        ssize_t (*store)(struct class *, const char * buf, size_t count);
+};
+
+#define CLASS_ATTR(_name,_mode,_show,_store)                    \
+struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store) 
+
+extern int class_create_file(struct class *, const struct class_attribute *);
+extern void class_remove_file(struct class *, const struct class_attribute *);
+
+
+struct class_device {
+        struct list_head        node;
+
+        struct kobject          kobj;
+        struct class            * class;        /* required */
+        dev_t                   devt;           /* dev_t, creates the sysfs "dev" */
+        struct device           * dev;          /* not necessary, but nice to have */
+        void                    * class_data;   /* class-specific data */
+
+        char    class_id[BUS_ID_SIZE];  /* unique to this class */
+};
+
+static inline void *
+class_get_devdata (struct class_device *dev)
+{
+        return dev->class_data;
+}
+
+static inline void
+class_set_devdata (struct class_device *dev, void *data)
+{
+        dev->class_data = data;
+}
+
+
+extern int class_device_register(struct class_device *);
+extern void class_device_unregister(struct class_device *);
+extern void class_device_initialize(struct class_device *);
+extern int class_device_add(struct class_device *);
+extern void class_device_del(struct class_device *);
+
+extern int class_device_rename(struct class_device *, char *);
+
+extern struct class_device * class_device_get(struct class_device *);
+extern void class_device_put(struct class_device *);
+
+struct class_device_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct class_device *, char * buf);
+        ssize_t (*store)(struct class_device *, const char * buf, size_t count);
+};
+
+#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store)             \
+struct class_device_attribute class_device_attr_##_name =       \
+        __ATTR(_name,_mode,_show,_store)
+
+extern int class_device_create_file(struct class_device *, 
+                                    const struct class_device_attribute *);
+extern void class_device_remove_file(struct class_device *, 
+                                     const struct class_device_attribute *);
+extern int class_device_create_bin_file(struct class_device *,
+                                        struct bin_attribute *);
+extern void class_device_remove_bin_file(struct class_device *,
+                                         struct bin_attribute *);
+
+struct class_interface {
+        struct list_head        node;
+        struct class            *class;
+
+        int (*add)      (struct class_device *);
+        void (*remove)  (struct class_device *);
+};
+
+extern int class_interface_register(struct class_interface *);
+extern void class_interface_unregister(struct class_interface *);
+
+/* interface for class simple stuff */
+extern struct class_simple *class_simple_create(struct module *owner, char *name);
+extern void class_simple_destroy(struct class_simple *cs);
+extern struct class_device *class_simple_device_add(struct class_simple *cs, dev_t dev, struct device *device, const char *fmt, ...)
+        __attribute__((format(printf,4,5)));
+extern int class_simple_set_hotplug(struct class_simple *, 
+        int (*hotplug)(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size));
+extern void class_simple_device_remove(dev_t dev);
+
+
+struct device {
+        struct list_head node;          /* node in sibling list */
+        struct list_head bus_list;      /* node in bus's list */
+        struct list_head driver_list;
+        struct list_head children;
+        struct device   * parent;
+
+        struct kobject kobj;
+        char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
+
+        struct bus_type * bus;          /* type of bus device is on */
+        struct device_driver *driver;   /* which driver has allocated this
+                                           device */
+        void            *driver_data;   /* data private to the driver */
+        void            *platform_data; /* Platform specific data (e.g. ACPI,
+                                           BIOS data relevant to device) */
+        struct dev_pm_info      power;
+
+        u32             detach_state;   /* State to enter when device is
+                                           detached from its driver. */
+
+        u64             *dma_mask;      /* dma mask (if dma'able device) */
+        u64             coherent_dma_mask;/* Like dma_mask, but for
+                                             alloc_coherent mappings as
+                                             not all hardware supports
+                                             64 bit addresses for consistent
+                                             allocations such descriptors. */
+
+        struct list_head        dma_pools;      /* dma pools (if dma'ble) */
+
+        struct dma_coherent_mem *dma_mem; /* internal for coherent mem
+                                             override */
+
+        void    (*release)(struct device * dev);
+};
+
+static inline struct device *
+list_to_dev(struct list_head *node)
+{
+        return list_entry(node, struct device, node);
+}
+
+static inline void *
+dev_get_drvdata (struct device *dev)
+{
+        return dev->driver_data;
+}
+
+static inline void
+dev_set_drvdata (struct device *dev, void *data)
+{
+        dev->driver_data = data;
+}
+
+/*
+ * High level routines for use by the bus drivers
+ */
+extern int device_register(struct device * dev);
+extern void device_unregister(struct device * dev);
+extern void device_initialize(struct device * dev);
+extern int device_add(struct device * dev);
+extern void device_del(struct device * dev);
+extern int device_for_each_child(struct device *, void *,
+                     int (*fn)(struct device *, void *));
+
+/*
+ * Manual binding of a device to driver. See drivers/base/bus.c
+ * for information on use.
+ */
+extern int  driver_probe_device(struct device_driver * drv, struct device * dev);
+extern void device_bind_driver(struct device * dev);
+extern void device_release_driver(struct device * dev);
+extern int  device_attach(struct device * dev);
+extern void driver_attach(struct device_driver * drv);
+
+
+/* driverfs interface for exporting device attributes */
+
+struct device_attribute {
+        struct attribute        attr;
+        ssize_t (*show)(struct device * dev, char * buf);
+        ssize_t (*store)(struct device * dev, const char * buf, size_t count);
+};
+
+#define DEVICE_ATTR(_name,_mode,_show,_store) \
+struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+
+extern int device_create_file(struct device *device, struct device_attribute * entry);
+extern void device_remove_file(struct device * dev, struct device_attribute * attr);
+
+/*
+ * Platform "fixup" functions - allow the platform to have their say
+ * about devices and actions that the general device layer doesn't
+ * know about.
+ */
+/* Notify platform of device discovery */
+extern int (*platform_notify)(struct device * dev);
+
+extern int (*platform_notify_remove)(struct device * dev);
+
+
+/**
+ * get_device - atomically increment the reference count for the device.
+ *
+ */
+extern struct device * get_device(struct device * dev);
+extern void put_device(struct device * dev);
+extern struct device *device_find(const char *name, struct bus_type *bus);
+
+
+/* drivers/base/platform.c */
+
+struct platform_device {
+        char            * name;
+        u32             id;
+        struct device   dev;
+        u32             num_resources;
+        struct resource * resource;
+};
+
+#define to_platform_device(x) container_of((x), struct platform_device, dev)
+
+extern int platform_device_register(struct platform_device *);
+extern void platform_device_unregister(struct platform_device *);
+
+extern struct bus_type platform_bus_type;
+extern struct device platform_bus;
+
+extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
+extern int platform_get_irq(struct platform_device *, unsigned int);
+extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
+extern int platform_get_irq_byname(struct platform_device *, char *);
+extern int platform_add_devices(struct platform_device **, int);
+
+extern struct platform_device *platform_device_register_simple(char *, unsigned int, struct resource *, unsigned int);
+
+/* drivers/base/power.c */
+extern void device_shutdown(void);
+
+
+/* drivers/base/firmware.c */
+extern int firmware_register(struct subsystem *);
+extern void firmware_unregister(struct subsystem *);
+
+/* debugging and troubleshooting/diagnostic helpers. */
+#define dev_printk(level, dev, format, arg...)  \
+        printk(level "%s %s: " format , (dev)->driver ? (dev)->driver->name : "" , (dev)->bus_id , ## arg)
+
+#ifdef DEBUG
+#define dev_dbg(dev, format, arg...)            \
+        dev_printk(KERN_DEBUG , dev , format , ## arg)
+#else
+#define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0)
+#endif
+
+#define dev_err(dev, format, arg...)            \
+        dev_printk(KERN_ERR , dev , format , ## arg)
+#define dev_info(dev, format, arg...)           \
+        dev_printk(KERN_INFO , dev , format , ## arg)
+#define dev_warn(dev, format, arg...)           \
+        dev_printk(KERN_WARNING , dev , format , ## arg)
+
+/* Create alias, so I can be autoloaded. */
+#define MODULE_ALIAS_CHARDEV(major,minor) \
+        MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
+#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
+        MODULE_ALIAS("char-major-" __stringify(major) "-*")
+#endif /* _DEVICE_H_ */
diff --git a/include/linux/devpts_fs.h b/include/linux/devpts_fs.h
new file mode 100644
index 000000000000..b672ddc00735
--- /dev/null
+++ b/include/linux/devpts_fs.h
@@ -0,0 +1,34 @@
+/* -*- linux-c -*- --------------------------------------------------------- *
+ *
+ * linux/include/linux/devpts_fs.h
+ *
+ *  Copyright 1998-2004 H. Peter Anvin -- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * ------------------------------------------------------------------------- */
+
+#ifndef _LINUX_DEVPTS_FS_H
+#define _LINUX_DEVPTS_FS_H
+
+#include <linux/errno.h>
+
+#ifdef CONFIG_UNIX98_PTYS
+
+int devpts_pty_new(struct tty_struct *tty);      /* mknod in devpts */
+struct tty_struct *devpts_get_tty(int number);   /* get tty structure */
+void devpts_pty_kill(int number);                /* unlink */
+
+#else
+
+/* Dummy stubs in the no-pty case */
+static inline int devpts_pty_new(struct tty_struct *tty) { return -EINVAL; }
+static inline struct tty_struct *devpts_get_tty(int number) { return NULL; }
+static inline void devpts_pty_kill(int number) { }
+
+#endif
+
+
+#endif /* _LINUX_DEVPTS_FS_H */
diff --git a/include/linux/dio.h b/include/linux/dio.h
new file mode 100644
index 000000000000..fae9395fcf4f
--- /dev/null
+++ b/include/linux/dio.h
@@ -0,0 +1,312 @@
+/* header file for DIO boards for the HP300 architecture.
+ * Maybe this should handle DIO-II later?
+ * The general structure of this is vaguely based on how
+ * the Amiga port handles Zorro boards.
+ * Copyright (C) Peter Maydell 05/1998 <pmaydell@chiark.greenend.org.uk>
+ * Converted to driver model Jochen Friedrich <jochen@scram.de>
+ *
+ * The board IDs are from the NetBSD kernel, which for once provided
+ * helpful comments...
+ *
+ * This goes with drivers/dio/dio.c
+ */
+
+#ifndef _LINUX_DIO_H
+#define _LINUX_DIO_H
+
+/* The DIO boards in a system are distinguished by 'select codes' which 
+ * range from 0-63 (DIO) and 132-255 (DIO-II). 
+ * The DIO board with select code sc is located at physical address 
+ *     0x600000 + sc * 0x10000
+ * So DIO cards cover [0x600000-0x800000); the areas [0x200000-0x400000) and
+ * [0x800000-0x1000000) are for additional space required by things
+ * like framebuffers. [0x400000-0x600000) is for miscellaneous internal I/O.
+ * On Linux, this is currently all mapped into the virtual address space
+ * at 0xf0000000 on bootup.
+ * DIO-II boards are at 0x1000000 + (sc - 132) * 0x400000
+ * which is address range [0x1000000-0x20000000) -- too big to map completely,
+ * so currently we just don't handle DIO-II boards.  It wouldn't be hard to 
+ * do with ioremap() though.
+ */
+
+#include <linux/device.h>
+
+#ifdef __KERNEL__
+
+#include <asm/hp300hw.h>
+
+typedef __u16 dio_id;
+
+    /*
+     *  DIO devices
+     */
+
+struct dio_dev {
+        struct dio_bus *bus;
+        dio_id id;
+        int scode;
+        struct dio_driver *driver;      /* which driver has allocated this device */
+        struct device dev;              /* Generic device interface */
+        u8 ipl;
+        char name[64];
+        struct resource resource;
+};
+
+#define to_dio_dev(n) container_of(n, struct dio_dev, dev)
+
+    /*
+     *  DIO bus
+     */
+
+struct dio_bus {
+        struct list_head devices;           /* list of devices on this bus */
+        unsigned int num_resources;         /* number of resources */
+        struct resource resources[2];       /* address space routed to this bus */
+        struct device dev;
+        char name[10];
+};
+
+extern struct dio_bus dio_bus;      /* Single DIO bus */
+extern struct bus_type dio_bus_type;
+
+    /*
+     *  DIO device IDs
+     */
+
+struct dio_device_id {
+        dio_id id;                    /* Device ID or DIO_WILDCARD */
+        unsigned long driver_data;    /* Data private to the driver */
+};
+
+    /*
+     *  DIO device drivers
+     */
+
+struct dio_driver {
+        struct list_head node;
+        char *name;
+        const struct dio_device_id *id_table;     /* NULL if wants all devices */
+        int (*probe)(struct dio_dev *z, const struct dio_device_id *id);
+/* New device inserted */
+        void (*remove)(struct dio_dev *z);        /* Device removed (NULL if not a hot-plug capable driver) */
+        struct device_driver driver;
+};
+
+#define to_dio_driver(drv)    container_of(drv, struct dio_driver, driver)
+
+/* DIO/DIO-II boards all have the following 8bit registers.
+ * These are offsets from the base of the device.
+ */
+#define DIO_IDOFF     0x01             /* primary device ID */
+#define DIO_IPLOFF    0x03             /* interrupt priority level */
+#define DIO_SECIDOFF  0x15             /* secondary device ID */
+#define DIOII_SIZEOFF 0x101            /* device size, DIO-II only */
+#define DIO_VIRADDRBASE 0xf0000000UL   /* vir addr where IOspace is mapped */
+
+#define DIO_BASE                0x600000        /* start of DIO space */
+#define DIO_END                 0x1000000       /* end of DIO space */
+#define DIO_DEVSIZE             0x10000         /* size of a DIO device */
+
+#define DIOII_BASE              0x01000000      /* start of DIO-II space */
+#define DIOII_END               0x20000000      /* end of DIO-II space */
+#define DIOII_DEVSIZE           0x00400000      /* size of a DIO-II device */
+
+/* Highest valid select code. If we add DIO-II support this should become
+ * 256 for everything except HP320, which only has DIO.
+ */
+#define DIO_SCMAX (hp300_model == HP_320 ? 32 : 256)
+#define DIOII_SCBASE 132 /* lowest DIO-II select code */
+#define DIO_SCINHOLE(scode) (((scode) >= 32) && ((scode) < DIOII_SCBASE))
+#define DIO_ISDIOII(scode) ((scode) >= 132 && (scode) < 256)
+
+/* macros to read device IDs, given base address */
+#define DIO_ID(baseaddr) in_8((baseaddr) + DIO_IDOFF)
+#define DIO_SECID(baseaddr) in_8((baseaddr) + DIO_SECIDOFF)
+
+/* extract the interrupt level */
+#define DIO_IPL(baseaddr) (((in_8((baseaddr) + DIO_IPLOFF) >> 4) & 0x03) + 3)
+
+/* find the size of a DIO-II board's address space.
+ * DIO boards are all fixed length.
+ */
+#define DIOII_SIZE(baseaddr) ((in_8((baseaddr) + DIOII_SIZEOFF) + 1) * 0x100000)
+
+/* general purpose macro for both DIO and DIO-II */
+#define DIO_SIZE(scode, base) (DIO_ISDIOII((scode)) ? DIOII_SIZE((base)) : DIO_DEVSIZE)
+
+/* The hardware has primary and secondary IDs; we encode these in a single
+ * int as PRIMARY ID & (SECONDARY ID << 8).
+ * In practice this is only important for framebuffers,
+ * and everybody else just sets ID fields equal to the DIO_ID_FOO value.
+ */
+#define DIO_ENCODE_ID(pr,sec) ((((int)sec & 0xff) << 8) | ((int)pr & 0xff))
+/* macro to determine whether a given primary ID requires a secondary ID byte */
+#define DIO_NEEDSSECID(id) ((id) == DIO_ID_FBUFFER)
+#define DIO_WILDCARD 0xff
+
+/* Now a whole slew of macros giving device IDs and descriptive strings: */
+#define DIO_ID_DCA0     0x02 /* 98644A serial */
+#define DIO_DESC_DCA0 "98644A DCA0 serial"
+#define DIO_ID_DCA0REM  0x82 /* 98644A serial */
+#define DIO_DESC_DCA0REM "98644A DCA0REM serial"
+#define DIO_ID_DCA1     0x42 /* 98644A serial */
+#define DIO_DESC_DCA1 "98644A DCA1 serial"
+#define DIO_ID_DCA1REM  0xc2 /* 98644A serial */
+#define DIO_DESC_DCA1REM "98644A DCA1REM serial"
+#define DIO_ID_DCM      0x05 /* 98642A serial MUX */
+#define DIO_DESC_DCM "98642A DCM serial MUX"
+#define DIO_ID_DCMREM   0x85 /* 98642A serial MUX */
+#define DIO_DESC_DCMREM "98642A DCMREM serial MUX"
+#define DIO_ID_LAN      0x15 /* 98643A LAN */
+#define DIO_DESC_LAN "98643A LANCE ethernet"
+#define DIO_ID_FHPIB    0x08 /* 98625A/98625B fast HP-IB */
+#define DIO_DESC_FHPIB "98625A/98625B fast HPIB"
+#define DIO_ID_NHPIB    0x01 /* 98624A HP-IB (normal ie slow) */
+#define DIO_DESC_NHPIB "98624A HPIB"
+#define DIO_ID_SCSI0    0x07 /* 98265A SCSI */
+#define DIO_DESC_SCSI0 "98265A SCSI0"
+#define DIO_ID_SCSI1    0x27 /* ditto */
+#define DIO_DESC_SCSI1 "98265A SCSI1"
+#define DIO_ID_SCSI2    0x47 /* ditto */
+#define DIO_DESC_SCSI2 "98265A SCSI2"
+#define DIO_ID_SCSI3    0x67 /* ditto */
+#define DIO_DESC_SCSI3 "98265A SCSI3"
+#define DIO_ID_FBUFFER  0x39 /* framebuffer: flavour is distinguished by secondary ID */
+#define DIO_DESC_FBUFFER "bitmapped display"
+/* the NetBSD kernel source is a bit unsure as to what these next IDs actually do :-> */
+#define DIO_ID_MISC0    0x03 /* 98622A */
+#define DIO_DESC_MISC0 "98622A"
+#define DIO_ID_MISC1    0x04 /* 98623A */
+#define DIO_DESC_MISC1 "98623A"
+#define DIO_ID_PARALLEL 0x06 /* internal parallel */
+#define DIO_DESC_PARALLEL "internal parallel"
+#define DIO_ID_MISC2    0x09 /* 98287A keyboard */
+#define DIO_DESC_MISC2 "98287A keyboard"
+#define DIO_ID_MISC3    0x0a /* HP98635A FP accelerator */
+#define DIO_DESC_MISC3 "HP98635A FP accelerator"
+#define DIO_ID_MISC4    0x0b /* timer */
+#define DIO_DESC_MISC4 "timer"
+#define DIO_ID_MISC5    0x12 /* 98640A */
+#define DIO_DESC_MISC5 "98640A"
+#define DIO_ID_MISC6    0x16 /* 98659A */
+#define DIO_DESC_MISC6 "98659A"
+#define DIO_ID_MISC7    0x19 /* 237 display */
+#define DIO_DESC_MISC7 "237 display"
+#define DIO_ID_MISC8    0x1a /* quad-wide card */
+#define DIO_DESC_MISC8 "quad-wide card"
+#define DIO_ID_MISC9    0x1b /* 98253A */
+#define DIO_DESC_MISC9 "98253A"
+#define DIO_ID_MISC10   0x1c /* 98627A */
+#define DIO_DESC_MISC10 "98253A"
+#define DIO_ID_MISC11   0x1d /* 98633A */
+#define DIO_DESC_MISC11 "98633A"
+#define DIO_ID_MISC12   0x1e /* 98259A */
+#define DIO_DESC_MISC12 "98259A"
+#define DIO_ID_MISC13   0x1f /* 8741 */
+#define DIO_DESC_MISC13 "8741"
+#define DIO_ID_VME      0x31 /* 98577A VME adapter */
+#define DIO_DESC_VME "98577A VME adapter"
+#define DIO_ID_DCL      0x34 /* 98628A serial */
+#define DIO_DESC_DCL "98628A DCL serial"
+#define DIO_ID_DCLREM   0xb4 /* 98628A serial */
+#define DIO_DESC_DCLREM "98628A DCLREM serial"
+/* These are the secondary IDs for the framebuffers */
+#define DIO_ID2_GATORBOX    0x01 /* 98700/98710 "gatorbox" */
+#define DIO_DESC2_GATORBOX       "98700/98710 \"gatorbox\" display"
+#define DIO_ID2_TOPCAT      0x02 /* 98544/98545/98547 "topcat" */
+#define DIO_DESC2_TOPCAT         "98544/98545/98547 \"topcat\" display"
+#define DIO_ID2_RENAISSANCE 0x04 /* 98720/98721 "renaissance" */
+#define DIO_DESC2_RENAISSANCE    "98720/98721 \"renaissance\" display"
+#define DIO_ID2_LRCATSEYE   0x05 /* lowres "catseye" */
+#define DIO_DESC2_LRCATSEYE      "low-res catseye display"
+#define DIO_ID2_HRCCATSEYE  0x06 /* highres colour "catseye" */
+#define DIO_DESC2_HRCCATSEYE     "high-res color catseye display"
+#define DIO_ID2_HRMCATSEYE  0x07 /* highres mono "catseye" */
+#define DIO_DESC2_HRMCATSEYE     "high-res mono catseye display"
+#define DIO_ID2_DAVINCI     0x08 /* 98730/98731 "davinci" */
+#define DIO_DESC2_DAVINCI        "98730/98731 \"davinci\" display"
+#define DIO_ID2_XXXCATSEYE  0x09 /* "catseye" */
+#define DIO_DESC2_XXXCATSEYE     "catseye display"
+#define DIO_ID2_HYPERION    0x0e /* A1096A "hyperion" */
+#define DIO_DESC2_HYPERION       "A1096A \"hyperion\" display"
+#define DIO_ID2_XGENESIS    0x0b /* "x-genesis"; no NetBSD support */
+#define DIO_DESC2_XGENESIS       "\"x-genesis\" display"
+#define DIO_ID2_TIGER       0x0c /* "tiger"; no NetBSD support */
+#define DIO_DESC2_TIGER          "\"tiger\" display"
+#define DIO_ID2_YGENESIS    0x0d /* "y-genesis"; no NetBSD support */
+#define DIO_DESC2_YGENESIS       "\"y-genesis\" display"
+/* if you add new IDs then you should tell dio.c about them so it can
+ * identify them...
+ */
+
+extern int dio_find(int deviceid);
+extern unsigned long dio_scodetophysaddr(int scode);
+extern void dio_create_sysfs_dev_files(struct dio_dev *);
+
+/* New-style probing */
+extern int dio_register_driver(struct dio_driver *);
+extern void dio_unregister_driver(struct dio_driver *);
+extern const struct dio_device_id *dio_match_device(const struct dio_device_id *ids, const struct dio_dev *z);
+static inline struct dio_driver *dio_dev_driver(const struct dio_dev *d)
+{
+    return d->driver;
+}
+
+#define dio_resource_start(d) ((d)->resource.start)
+#define dio_resource_end(d)   ((d)->resource.end)
+#define dio_resource_len(d)   ((d)->resource.end-(d)->resource.start+1)
+#define dio_resource_flags(d) ((d)->resource.flags)
+
+#define dio_request_device(d, name) \
+    request_mem_region(dio_resource_start(d), dio_resource_len(d), name)
+#define dio_release_device(d) \
+    release_mem_region(dio_resource_start(d), dio_resource_len(d))
+
+/* Similar to the helpers above, these manipulate per-dio_dev
+ * driver-specific data.  They are really just a wrapper around
+ * the generic device structure functions of these calls.
+ */
+static inline void *dio_get_drvdata (struct dio_dev *d)
+{
+        return dev_get_drvdata(&d->dev);
+}
+
+static inline void dio_set_drvdata (struct dio_dev *d, void *data)
+{
+        dev_set_drvdata(&d->dev, data);
+}
+
+/*
+ * A helper function which helps ensure correct dio_driver
+ * setup and cleanup for commonly-encountered hotplug/modular cases
+ *
+ * This MUST stay in a header, as it checks for -DMODULE
+ */
+static inline int dio_module_init(struct dio_driver *drv)
+{
+        int rc = dio_register_driver(drv);
+
+        if (rc > 0)
+                return 0;
+
+        /* iff CONFIG_HOTPLUG and built into kernel, we should
+         * leave the driver around for future hotplug events.
+         * For the module case, a hotplug daemon of some sort
+         * should load a module in response to an insert event. */
+#if defined(CONFIG_HOTPLUG) && !defined(MODULE)
+        if (rc == 0)
+                return 0;
+#else
+        if (rc == 0)
+                rc = -ENODEV;
+#endif
+
+        /* if we get here, we need to clean up DIO driver instance
+         * and return some sort of error */
+        dio_unregister_driver(drv);
+
+        return rc;
+}
+
+#endif /* __KERNEL__ */
+#endif /* ndef _LINUX_DIO_H */
diff --git a/include/linux/dirent.h b/include/linux/dirent.h
new file mode 100644
index 000000000000..5d6023b87800
--- /dev/null
+++ b/include/linux/dirent.h
@@ -0,0 +1,32 @@
+#ifndef _LINUX_DIRENT_H
+#define _LINUX_DIRENT_H
+
+struct dirent {
+        long            d_ino;
+        __kernel_off_t  d_off;
+        unsigned short  d_reclen;
+        char            d_name[256]; /* We must not include limits.h! */
+};
+
+struct dirent64 {
+        __u64           d_ino;
+        __s64           d_off;
+        unsigned short  d_reclen;
+        unsigned char   d_type;
+        char            d_name[256];
+};
+
+#ifdef __KERNEL__
+
+struct linux_dirent64 {
+        u64             d_ino;
+        s64             d_off;
+        unsigned short  d_reclen;
+        unsigned char   d_type;
+        char            d_name[0];
+};
+
+#endif  /* __KERNEL__ */
+
+
+#endif
diff --git a/include/linux/divert.h b/include/linux/divert.h
new file mode 100644
index 000000000000..6919b09133d4
--- /dev/null
+++ b/include/linux/divert.h
@@ -0,0 +1,132 @@
+/*
+ * Frame Diversion, Benoit Locher <Benoit.Locher@skf.com>
+ *
+ * Changes:
+ *              06/09/2000      BL:     initial version
+ * 
+ */
+ 
+#ifndef _LINUX_DIVERT_H
+#define _LINUX_DIVERT_H
+
+#include <asm/types.h>
+
+#define MAX_DIVERT_PORTS        8       /* Max number of ports to divert (tcp, udp) */
+
+/* Divertable protocols */
+#define DIVERT_PROTO_NONE       0x0000
+#define DIVERT_PROTO_IP         0x0001
+#define DIVERT_PROTO_ICMP       0x0002
+#define DIVERT_PROTO_TCP        0x0004
+#define DIVERT_PROTO_UDP        0x0008
+
+/*
+ *      This is an Ethernet Frame Diverter option block
+ */
+struct divert_blk
+{
+        int             divert;  /* are we active */
+        unsigned int protos;    /* protocols */
+        u16             tcp_dst[MAX_DIVERT_PORTS]; /* specific tcp dst ports to divert */
+        u16             tcp_src[MAX_DIVERT_PORTS]; /* specific tcp src ports to divert */
+        u16             udp_dst[MAX_DIVERT_PORTS]; /* specific udp dst ports to divert */
+        u16             udp_src[MAX_DIVERT_PORTS]; /* specific udp src ports to divert */
+};
+
+/*
+ * Diversion control block, for configuration with the userspace tool
+ * divert
+ */
+
+typedef union _divert_cf_arg
+{
+        s16             int16;
+        u16             uint16;
+        s32             int32;
+        u32             uint32;
+        s64             int64;
+        u64             uint64;
+        void    __user *ptr;
+} divert_cf_arg;
+
+
+struct divert_cf
+{
+        int     cmd;                            /* Command */
+        divert_cf_arg   arg1,
+                                        arg2,
+                                        arg3;
+        int     dev_index;      /* device index (eth0=0, etc...) */
+};
+
+
+/* Diversion commands */
+#define DIVCMD_DIVERT                   1 /* ENABLE/DISABLE diversion */
+#define DIVCMD_IP                               2 /* ENABLE/DISABLE whold IP diversion */
+#define DIVCMD_TCP                              3 /* ENABLE/DISABLE whold TCP diversion */
+#define DIVCMD_TCPDST                   4 /* ADD/REMOVE TCP DST port for diversion */
+#define DIVCMD_TCPSRC                   5 /* ADD/REMOVE TCP SRC port for diversion */
+#define DIVCMD_UDP                              6 /* ENABLE/DISABLE whole UDP diversion */
+#define DIVCMD_UDPDST                   7 /* ADD/REMOVE UDP DST port for diversion */
+#define DIVCMD_UDPSRC                   8 /* ADD/REMOVE UDP SRC port for diversion */
+#define DIVCMD_ICMP                             9 /* ENABLE/DISABLE whole ICMP diversion */
+#define DIVCMD_GETSTATUS                10 /* GET the status of the diverter */
+#define DIVCMD_RESET                    11 /* Reset the diverter on the specified dev */
+#define DIVCMD_GETVERSION               12 /* Retrieve the diverter code version (char[32]) */
+
+/* General syntax of the commands:
+ * 
+ * DIVCMD_xxxxxx(arg1, arg2, arg3, dev_index)
+ * 
+ * SIOCSIFDIVERT:
+ *   DIVCMD_DIVERT(DIVARG1_ENABLE|DIVARG1_DISABLE, , ,ifindex)
+ *   DIVCMD_IP(DIVARG1_ENABLE|DIVARG1_DISABLE, , , ifindex)
+ *   DIVCMD_TCP(DIVARG1_ENABLE|DIVARG1_DISABLE, , , ifindex)
+ *   DIVCMD_TCPDST(DIVARG1_ADD|DIVARG1_REMOVE, port, , ifindex)
+ *   DIVCMD_TCPSRC(DIVARG1_ADD|DIVARG1_REMOVE, port, , ifindex)
+ *   DIVCMD_UDP(DIVARG1_ENABLE|DIVARG1_DISABLE, , , ifindex)
+ *   DIVCMD_UDPDST(DIVARG1_ADD|DIVARG1_REMOVE, port, , ifindex)
+ *   DIVCMD_UDPSRC(DIVARG1_ADD|DIVARG1_REMOVE, port, , ifindex)
+ *   DIVCMD_ICMP(DIVARG1_ENABLE|DIVARG1_DISABLE, , , ifindex)
+ *   DIVCMD_RESET(, , , ifindex)
+ *   
+ * SIOGIFDIVERT:
+ *   DIVCMD_GETSTATUS(divert_blk, , , ifindex)
+ *   DIVCMD_GETVERSION(string[3])
+ */
+
+
+/* Possible values for arg1 */
+#define DIVARG1_ENABLE                  0 /* ENABLE something */
+#define DIVARG1_DISABLE                 1 /* DISABLE something */
+#define DIVARG1_ADD                             2 /* ADD something */
+#define DIVARG1_REMOVE                  3 /* REMOVE something */
+
+
+#ifdef __KERNEL__
+
+/* diverter functions */
+#include <linux/skbuff.h>
+
+#ifdef CONFIG_NET_DIVERT
+#include <linux/netdevice.h>
+
+int alloc_divert_blk(struct net_device *);
+void free_divert_blk(struct net_device *);
+int divert_ioctl(unsigned int cmd, struct divert_cf __user *arg);
+void divert_frame(struct sk_buff *skb);
+static inline void handle_diverter(struct sk_buff *skb)
+{
+        /* if diversion is supported on device, then divert */
+        if (skb->dev->divert && skb->dev->divert->divert)
+                divert_frame(skb);
+}
+
+#else
+# define alloc_divert_blk(dev)          (0)
+# define free_divert_blk(dev)           do {} while (0)
+# define divert_ioctl(cmd, arg)         (-ENOPKG)
+# define handle_diverter(skb)           do {} while (0)
+#endif
+#endif 
+#endif  /* _LINUX_DIVERT_H */
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
new file mode 100644
index 000000000000..f5eb6b6cd109
--- /dev/null
+++ b/include/linux/dm-ioctl.h
@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 2001 - 2003 Sistina Software (UK) Limited.
+ * Copyright (C) 2004 - 2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is released under the LGPL.
+ */
+
+#ifndef _LINUX_DM_IOCTL_V4_H
+#define _LINUX_DM_IOCTL_V4_H
+
+#include <linux/types.h>
+
+#define DM_DIR "mapper"         /* Slashes not supported */
+#define DM_MAX_TYPE_NAME 16
+#define DM_NAME_LEN 128
+#define DM_UUID_LEN 129
+
+/*
+ * A traditional ioctl interface for the device mapper.
+ *
+ * Each device can have two tables associated with it, an
+ * 'active' table which is the one currently used by io passing
+ * through the device, and an 'inactive' one which is a table
+ * that is being prepared as a replacement for the 'active' one.
+ *
+ * DM_VERSION:
+ * Just get the version information for the ioctl interface.
+ *
+ * DM_REMOVE_ALL:
+ * Remove all dm devices, destroy all tables.  Only really used
+ * for debug.
+ *
+ * DM_LIST_DEVICES:
+ * Get a list of all the dm device names.
+ *
+ * DM_DEV_CREATE:
+ * Create a new device, neither the 'active' or 'inactive' table
+ * slots will be filled.  The device will be in suspended state
+ * after creation, however any io to the device will get errored
+ * since it will be out-of-bounds.
+ *
+ * DM_DEV_REMOVE:
+ * Remove a device, destroy any tables.
+ *
+ * DM_DEV_RENAME:
+ * Rename a device.
+ *
+ * DM_SUSPEND:
+ * This performs both suspend and resume, depending which flag is
+ * passed in.
+ * Suspend: This command will not return until all pending io to
+ * the device has completed.  Further io will be deferred until
+ * the device is resumed.
+ * Resume: It is no longer an error to issue this command on an
+ * unsuspended device.  If a table is present in the 'inactive'
+ * slot, it will be moved to the active slot, then the old table
+ * from the active slot will be _destroyed_.  Finally the device
+ * is resumed.
+ *
+ * DM_DEV_STATUS:
+ * Retrieves the status for the table in the 'active' slot.
+ *
+ * DM_DEV_WAIT:
+ * Wait for a significant event to occur to the device.  This
+ * could either be caused by an event triggered by one of the
+ * targets of the table in the 'active' slot, or a table change.
+ *
+ * DM_TABLE_LOAD:
+ * Load a table into the 'inactive' slot for the device.  The
+ * device does _not_ need to be suspended prior to this command.
+ *
+ * DM_TABLE_CLEAR:
+ * Destroy any table in the 'inactive' slot (ie. abort).
+ *
+ * DM_TABLE_DEPS:
+ * Return a set of device dependencies for the 'active' table.
+ *
+ * DM_TABLE_STATUS:
+ * Return the targets status for the 'active' table.
+ *
+ * DM_TARGET_MSG:
+ * Pass a message string to the target at a specific offset of a device.
+ */
+
+/*
+ * All ioctl arguments consist of a single chunk of memory, with
+ * this structure at the start.  If a uuid is specified any
+ * lookup (eg. for a DM_INFO) will be done on that, *not* the
+ * name.
+ */
+struct dm_ioctl {
+        /*
+         * The version number is made up of three parts:
+         * major - no backward or forward compatibility,
+         * minor - only backwards compatible,
+         * patch - both backwards and forwards compatible.
+         *
+         * All clients of the ioctl interface should fill in the
+         * version number of the interface that they were
+         * compiled with.
+         *
+         * All recognised ioctl commands (ie. those that don't
+         * return -ENOTTY) fill out this field, even if the
+         * command failed.
+         */
+        uint32_t version[3];    /* in/out */
+        uint32_t data_size;     /* total size of data passed in
+                                 * including this struct */
+
+        uint32_t data_start;    /* offset to start of data
+                                 * relative to start of this struct */
+
+        uint32_t target_count;  /* in/out */
+        int32_t open_count;     /* out */
+        uint32_t flags;         /* in/out */
+        uint32_t event_nr;              /* in/out */
+        uint32_t padding;
+
+        uint64_t dev;           /* in/out */
+
+        char name[DM_NAME_LEN]; /* device name */
+        char uuid[DM_UUID_LEN]; /* unique identifier for
+                                 * the block device */
+};
+
+/*
+ * Used to specify tables.  These structures appear after the
+ * dm_ioctl.
+ */
+struct dm_target_spec {
+        uint64_t sector_start;
+        uint64_t length;
+        int32_t status;         /* used when reading from kernel only */
+
+        /*
+         * Location of the next dm_target_spec.
+         * - When specifying targets on a DM_TABLE_LOAD command, this value is
+         *   the number of bytes from the start of the "current" dm_target_spec
+         *   to the start of the "next" dm_target_spec.
+         * - When retrieving targets on a DM_TABLE_STATUS command, this value
+         *   is the number of bytes from the start of the first dm_target_spec
+         *   (that follows the dm_ioctl struct) to the start of the "next"
+         *   dm_target_spec.
+         */
+        uint32_t next;
+
+        char target_type[DM_MAX_TYPE_NAME];
+
+        /*
+         * Parameter string starts immediately after this object.
+         * Be careful to add padding after string to ensure correct
+         * alignment of subsequent dm_target_spec.
+         */
+};
+
+/*
+ * Used to retrieve the target dependencies.
+ */
+struct dm_target_deps {
+        uint32_t count; /* Array size */
+        uint32_t padding;       /* unused */
+        uint64_t dev[0];        /* out */
+};
+
+/*
+ * Used to get a list of all dm devices.
+ */
+struct dm_name_list {
+        uint64_t dev;
+        uint32_t next;          /* offset to the next record from
+                                   the _start_ of this */
+        char name[0];
+};
+
+/*
+ * Used to retrieve the target versions
+ */
+struct dm_target_versions {
+        uint32_t next;
+        uint32_t version[3];
+
+        char name[0];
+};
+
+/*
+ * Used to pass message to a target
+ */
+struct dm_target_msg {
+        uint64_t sector;        /* Device sector */
+
+        char message[0];
+};
+
+/*
+ * If you change this make sure you make the corresponding change
+ * to dm-ioctl.c:lookup_ioctl()
+ */
+enum {
+        /* Top level cmds */
+        DM_VERSION_CMD = 0,
+        DM_REMOVE_ALL_CMD,
+        DM_LIST_DEVICES_CMD,
+
+        /* device level cmds */
+        DM_DEV_CREATE_CMD,
+        DM_DEV_REMOVE_CMD,
+        DM_DEV_RENAME_CMD,
+        DM_DEV_SUSPEND_CMD,
+        DM_DEV_STATUS_CMD,
+        DM_DEV_WAIT_CMD,
+
+        /* Table level cmds */
+        DM_TABLE_LOAD_CMD,
+        DM_TABLE_CLEAR_CMD,
+        DM_TABLE_DEPS_CMD,
+        DM_TABLE_STATUS_CMD,
+
+        /* Added later */
+        DM_LIST_VERSIONS_CMD,
+        DM_TARGET_MSG_CMD,
+};
+
+/*
+ * The dm_ioctl struct passed into the ioctl is just the header
+ * on a larger chunk of memory.  On x86-64 and other
+ * architectures the dm-ioctl struct will be padded to an 8 byte
+ * boundary so the size will be different, which would change the
+ * ioctl code - yes I really messed up.  This hack forces these
+ * architectures to have the correct ioctl code.
+ */
+#ifdef CONFIG_COMPAT
+typedef char ioctl_struct[308];
+#define DM_VERSION_32       _IOWR(DM_IOCTL, DM_VERSION_CMD, ioctl_struct)
+#define DM_REMOVE_ALL_32    _IOWR(DM_IOCTL, DM_REMOVE_ALL_CMD, ioctl_struct)
+#define DM_LIST_DEVICES_32  _IOWR(DM_IOCTL, DM_LIST_DEVICES_CMD, ioctl_struct)
+
+#define DM_DEV_CREATE_32    _IOWR(DM_IOCTL, DM_DEV_CREATE_CMD, ioctl_struct)
+#define DM_DEV_REMOVE_32    _IOWR(DM_IOCTL, DM_DEV_REMOVE_CMD, ioctl_struct)
+#define DM_DEV_RENAME_32    _IOWR(DM_IOCTL, DM_DEV_RENAME_CMD, ioctl_struct)
+#define DM_DEV_SUSPEND_32   _IOWR(DM_IOCTL, DM_DEV_SUSPEND_CMD, ioctl_struct)
+#define DM_DEV_STATUS_32    _IOWR(DM_IOCTL, DM_DEV_STATUS_CMD, ioctl_struct)
+#define DM_DEV_WAIT_32      _IOWR(DM_IOCTL, DM_DEV_WAIT_CMD, ioctl_struct)
+
+#define DM_TABLE_LOAD_32    _IOWR(DM_IOCTL, DM_TABLE_LOAD_CMD, ioctl_struct)
+#define DM_TABLE_CLEAR_32   _IOWR(DM_IOCTL, DM_TABLE_CLEAR_CMD, ioctl_struct)
+#define DM_TABLE_DEPS_32    _IOWR(DM_IOCTL, DM_TABLE_DEPS_CMD, ioctl_struct)
+#define DM_TABLE_STATUS_32  _IOWR(DM_IOCTL, DM_TABLE_STATUS_CMD, ioctl_struct)
+#define DM_LIST_VERSIONS_32 _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, ioctl_struct)
+#define DM_TARGET_MSG_32    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, ioctl_struct)
+#endif
+
+#define DM_IOCTL 0xfd
+
+#define DM_VERSION       _IOWR(DM_IOCTL, DM_VERSION_CMD, struct dm_ioctl)
+#define DM_REMOVE_ALL    _IOWR(DM_IOCTL, DM_REMOVE_ALL_CMD, struct dm_ioctl)
+#define DM_LIST_DEVICES  _IOWR(DM_IOCTL, DM_LIST_DEVICES_CMD, struct dm_ioctl)
+
+#define DM_DEV_CREATE    _IOWR(DM_IOCTL, DM_DEV_CREATE_CMD, struct dm_ioctl)
+#define DM_DEV_REMOVE    _IOWR(DM_IOCTL, DM_DEV_REMOVE_CMD, struct dm_ioctl)
+#define DM_DEV_RENAME    _IOWR(DM_IOCTL, DM_DEV_RENAME_CMD, struct dm_ioctl)
+#define DM_DEV_SUSPEND   _IOWR(DM_IOCTL, DM_DEV_SUSPEND_CMD, struct dm_ioctl)
+#define DM_DEV_STATUS    _IOWR(DM_IOCTL, DM_DEV_STATUS_CMD, struct dm_ioctl)
+#define DM_DEV_WAIT      _IOWR(DM_IOCTL, DM_DEV_WAIT_CMD, struct dm_ioctl)
+
+#define DM_TABLE_LOAD    _IOWR(DM_IOCTL, DM_TABLE_LOAD_CMD, struct dm_ioctl)
+#define DM_TABLE_CLEAR   _IOWR(DM_IOCTL, DM_TABLE_CLEAR_CMD, struct dm_ioctl)
+#define DM_TABLE_DEPS    _IOWR(DM_IOCTL, DM_TABLE_DEPS_CMD, struct dm_ioctl)
+#define DM_TABLE_STATUS  _IOWR(DM_IOCTL, DM_TABLE_STATUS_CMD, struct dm_ioctl)
+
+#define DM_LIST_VERSIONS _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, struct dm_ioctl)
+
+#define DM_TARGET_MSG    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, struct dm_ioctl)
+
+#define DM_VERSION_MAJOR        4
+#define DM_VERSION_MINOR        4
+#define DM_VERSION_PATCHLEVEL   0
+#define DM_VERSION_EXTRA        "-ioctl (2005-01-12)"
+
+/* Status bits */
+#define DM_READONLY_FLAG        (1 << 0) /* In/Out */
+#define DM_SUSPEND_FLAG         (1 << 1) /* In/Out */
+#define DM_PERSISTENT_DEV_FLAG  (1 << 3) /* In */
+
+/*
+ * Flag passed into ioctl STATUS command to get table information
+ * rather than current status.
+ */
+#define DM_STATUS_TABLE_FLAG    (1 << 4) /* In */
+
+/*
+ * Flags that indicate whether a table is present in either of
+ * the two table slots that a device has.
+ */
+#define DM_ACTIVE_PRESENT_FLAG   (1 << 5) /* Out */
+#define DM_INACTIVE_PRESENT_FLAG (1 << 6) /* Out */
+
+/*
+ * Indicates that the buffer passed in wasn't big enough for the
+ * results.
+ */
+#define DM_BUFFER_FULL_FLAG     (1 << 8) /* Out */
+
+/*
+ * Set this to improve performance when you aren't going to use open_count
+ */
+#define DM_SKIP_BDGET_FLAG      (1 << 9) /* In */
+
+#endif                          /* _LINUX_DM_IOCTL_H */
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
new file mode 100644
index 000000000000..806c305332c1
--- /dev/null
+++ b/include/linux/dma-mapping.h
@@ -0,0 +1,56 @@
+#ifndef _ASM_LINUX_DMA_MAPPING_H
+#define _ASM_LINUX_DMA_MAPPING_H
+
+#include <linux/device.h>
+#include <linux/err.h>
+
+/* These definitions mirror those in pci.h, so they can be used
+ * interchangeably with their PCI_ counterparts */
+enum dma_data_direction {
+        DMA_BIDIRECTIONAL = 0,
+        DMA_TO_DEVICE = 1,
+        DMA_FROM_DEVICE = 2,
+        DMA_NONE = 3,
+};
+
+#define DMA_64BIT_MASK  0xffffffffffffffffULL
+#define DMA_32BIT_MASK  0x00000000ffffffffULL
+
+#include <asm/dma-mapping.h>
+
+/* Backwards compat, remove in 2.7.x */
+#define dma_sync_single         dma_sync_single_for_cpu
+#define dma_sync_sg             dma_sync_sg_for_cpu
+
+extern u64 dma_get_required_mask(struct device *dev);
+
+/* flags for the coherent memory api */
+#define DMA_MEMORY_MAP                  0x01
+#define DMA_MEMORY_IO                   0x02
+#define DMA_MEMORY_INCLUDES_CHILDREN    0x04
+#define DMA_MEMORY_EXCLUSIVE            0x08
+
+#ifndef ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
+static inline int
+dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
+                            dma_addr_t device_addr, size_t size, int flags)
+{
+        return 0;
+}
+
+static inline void
+dma_release_declared_memory(struct device *dev)
+{
+}
+
+static inline void *
+dma_mark_declared_memory_occupied(struct device *dev,
+                                  dma_addr_t device_addr, size_t size)
+{
+        return ERR_PTR(-EBUSY);
+}
+#endif
+
+#endif
+
+
diff --git a/include/linux/dmapool.h b/include/linux/dmapool.h
new file mode 100644
index 000000000000..e60bfdac348d
--- /dev/null
+++ b/include/linux/dmapool.h
@@ -0,0 +1,27 @@
+/*
+ * include/linux/dmapool.h
+ *
+ * Allocation pools for DMAable (coherent) memory.
+ *
+ * This file is licensed under  the terms of the GNU General Public 
+ * License version 2. This program is licensed "as is" without any 
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef LINUX_DMAPOOL_H
+#define LINUX_DMAPOOL_H
+
+#include <asm/io.h>
+#include <asm/scatterlist.h>
+
+struct dma_pool *dma_pool_create(const char *name, struct device *dev, 
+                        size_t size, size_t align, size_t allocation);
+
+void dma_pool_destroy(struct dma_pool *pool);
+
+void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
+
+void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
+
+#endif
+
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
new file mode 100644
index 000000000000..d2bcf556088b
--- /dev/null
+++ b/include/linux/dmi.h
@@ -0,0 +1,47 @@
+#ifndef __DMI_H__
+#define __DMI_H__
+
+enum dmi_field {
+        DMI_NONE,
+        DMI_BIOS_VENDOR,
+        DMI_BIOS_VERSION,
+        DMI_BIOS_DATE,
+        DMI_SYS_VENDOR,
+        DMI_PRODUCT_NAME,
+        DMI_PRODUCT_VERSION,
+        DMI_BOARD_VENDOR,
+        DMI_BOARD_NAME,
+        DMI_BOARD_VERSION,
+        DMI_STRING_MAX,
+};
+
+/*
+ *      DMI callbacks for problem boards
+ */
+struct dmi_strmatch {
+        u8 slot;
+        char *substr;
+};
+
+struct dmi_system_id {
+        int (*callback)(struct dmi_system_id *);
+        char *ident;
+        struct dmi_strmatch matches[4];
+        void *driver_data;
+};
+
+#define DMI_MATCH(a,b)  { a, b }
+
+#if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
+
+extern int dmi_check_system(struct dmi_system_id *list);
+extern char * dmi_get_system_info(int field);
+
+#else
+
+static inline int dmi_check_system(struct dmi_system_id *list) { return 0; }
+static inline char * dmi_get_system_info(int field) { return NULL; }
+
+#endif
+
+#endif  /* __DMI_H__ */
diff --git a/include/linux/dn.h b/include/linux/dn.h
new file mode 100644
index 000000000000..782cae49e64c
--- /dev/null
+++ b/include/linux/dn.h
@@ -0,0 +1,147 @@
+#ifndef _LINUX_DN_H
+#define _LINUX_DN_H
+
+/*
+
+        DECnet Data Structures and Constants
+
+*/
+
+/* 
+ * DNPROTO_NSP can't be the same as SOL_SOCKET, 
+ * so increment each by one (compared to ULTRIX)
+ */
+#define DNPROTO_NSP     2                       /* NSP protocol number       */
+#define DNPROTO_ROU     3                       /* Routing protocol number   */
+#define DNPROTO_NML     4                       /* Net mgt protocol number   */
+#define DNPROTO_EVL     5                       /* Evl protocol number (usr) */
+#define DNPROTO_EVR     6                       /* Evl protocol number (evl) */
+#define DNPROTO_NSPT    7                       /* NSP trace protocol number */
+
+
+#define DN_ADDL         2
+#define DN_MAXADDL      2 /* ULTRIX headers have 20 here, but pathworks has 2 */
+#define DN_MAXOPTL      16
+#define DN_MAXOBJL      16
+#define DN_MAXACCL      40
+#define DN_MAXALIASL    128
+#define DN_MAXNODEL     256
+#define DNBUFSIZE       65023
+
+/* 
+ * SET/GET Socket options  - must match the DSO_ numbers below
+ */
+#define SO_CONDATA      1
+#define SO_CONACCESS    2
+#define SO_PROXYUSR     3
+#define SO_LINKINFO     7
+
+#define DSO_CONDATA     1        /* Set/Get connect data                */
+#define DSO_DISDATA     10       /* Set/Get disconnect data             */
+#define DSO_CONACCESS   2        /* Set/Get connect access data         */
+#define DSO_ACCEPTMODE  4        /* Set/Get accept mode                 */
+#define DSO_CONACCEPT   5        /* Accept deferred connection          */
+#define DSO_CONREJECT   6        /* Reject deferred connection          */
+#define DSO_LINKINFO    7        /* Set/Get link information            */
+#define DSO_STREAM      8        /* Set socket type to stream           */
+#define DSO_SEQPACKET   9        /* Set socket type to sequenced packet */
+#define DSO_MAXWINDOW   11       /* Maximum window size allowed         */
+#define DSO_NODELAY     12       /* Turn off nagle                      */
+#define DSO_CORK        13       /* Wait for more data!                 */
+#define DSO_SERVICES    14       /* NSP Services field                  */
+#define DSO_INFO        15       /* NSP Info field                      */
+#define DSO_MAX         15       /* Maximum option number               */
+
+
+/* LINK States */
+#define LL_INACTIVE     0
+#define LL_CONNECTING   1
+#define LL_RUNNING      2
+#define LL_DISCONNECTING 3
+
+#define ACC_IMMED 0
+#define ACC_DEFER 1
+
+#define SDF_WILD        1                  /* Wild card object          */
+#define SDF_PROXY       2                  /* Addr eligible for proxy   */
+#define SDF_UICPROXY    4                  /* Use uic-based proxy       */
+
+/* Structures */
+
+
+struct dn_naddr 
+{
+        unsigned short          a_len;
+        unsigned char a_addr[DN_MAXADDL];
+};
+
+struct sockaddr_dn
+{
+        unsigned short          sdn_family;
+        unsigned char           sdn_flags;
+        unsigned char           sdn_objnum;
+        unsigned short          sdn_objnamel;
+        unsigned char           sdn_objname[DN_MAXOBJL];
+        struct   dn_naddr       sdn_add;
+};
+#define sdn_nodeaddrl   sdn_add.a_len   /* Node address length  */
+#define sdn_nodeaddr    sdn_add.a_addr  /* Node address         */
+
+
+
+/*
+ * DECnet set/get DSO_CONDATA, DSO_DISDATA (optional data) structure
+ */
+struct optdata_dn {
+        unsigned short  opt_status;     /* Extended status return */
+#define opt_sts opt_status
+        unsigned short  opt_optl;       /* Length of user data    */
+        unsigned char   opt_data[16];   /* User data              */
+};
+
+struct accessdata_dn
+{
+        unsigned char           acc_accl;
+        unsigned char           acc_acc[DN_MAXACCL];
+        unsigned char           acc_passl;
+        unsigned char           acc_pass[DN_MAXACCL];
+        unsigned char           acc_userl;
+        unsigned char           acc_user[DN_MAXACCL];
+};
+
+/*
+ * DECnet logical link information structure
+ */
+struct linkinfo_dn {
+        unsigned short  idn_segsize;    /* Segment size for link */
+        unsigned char   idn_linkstate;  /* Logical link state    */
+};
+
+/*
+ * Ethernet address format (for DECnet)
+ */
+union etheraddress {
+        unsigned char dne_addr[6];             /* Full ethernet address */
+  struct {
+                unsigned char dne_hiord[4];    /* DECnet HIORD prefix   */
+                unsigned char dne_nodeaddr[2]; /* DECnet node address   */
+  } dne_remote;
+};
+
+
+/*
+ * DECnet physical socket address format
+ */
+struct dn_addr {
+        unsigned short dna_family;      /* AF_DECnet               */
+        union etheraddress dna_netaddr; /* DECnet ethernet address */
+};
+
+#define DECNET_IOCTL_BASE 0x89 /* PROTOPRIVATE range */
+
+#define SIOCSNETADDR  _IOW(DECNET_IOCTL_BASE, 0xe0, struct dn_naddr)
+#define SIOCGNETADDR  _IOR(DECNET_IOCTL_BASE, 0xe1, struct dn_naddr)
+#define OSIOCSNETADDR _IOW(DECNET_IOCTL_BASE, 0xe0, int)
+#define OSIOCGNETADDR _IOR(DECNET_IOCTL_BASE, 0xe1, int)
+
+#endif /* _LINUX_DN_H */
diff --git a/include/linux/dnotify.h b/include/linux/dnotify.h
new file mode 100644
index 000000000000..f134a01975c7
--- /dev/null
+++ b/include/linux/dnotify.h
@@ -0,0 +1,63 @@
+#ifndef _LINUX_DNOTIFY_H
+#define _LINUX_DNOTIFY_H
+/*
+ * Directory notification for Linux
+ *
+ * Copyright (C) 2000,2002 Stephen Rothwell
+ */
+
+#include <linux/fs.h>
+
+struct dnotify_struct {
+        struct dnotify_struct * dn_next;
+        unsigned long           dn_mask;
+        int                     dn_fd;
+        struct file *           dn_filp;
+        fl_owner_t              dn_owner;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+
+#ifdef CONFIG_DNOTIFY
+
+extern void __inode_dir_notify(struct inode *, unsigned long);
+extern void dnotify_flush(struct file *, fl_owner_t);
+extern int fcntl_dirnotify(int, struct file *, unsigned long);
+extern void dnotify_parent(struct dentry *, unsigned long);
+
+static inline void inode_dir_notify(struct inode *inode, unsigned long event)
+{
+        if (inode->i_dnotify_mask & (event))
+                __inode_dir_notify(inode, event);
+}
+
+#else
+
+static inline void __inode_dir_notify(struct inode *inode, unsigned long event)
+{
+}
+
+static inline void dnotify_flush(struct file *filp, fl_owner_t id)
+{
+}
+
+static inline int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
+{
+        return -EINVAL;
+}
+
+static inline void dnotify_parent(struct dentry *dentry, unsigned long event)
+{
+}
+
+static inline void inode_dir_notify(struct inode *inode, unsigned long event)
+{
+}
+
+#endif /* CONFIG_DNOTIFY */
+
+#endif /* __KERNEL __ */
+
+#endif /* _LINUX_DNOTIFY_H */
diff --git a/include/linux/dqblk_v1.h b/include/linux/dqblk_v1.h
new file mode 100644
index 000000000000..42fbf4797156
--- /dev/null
+++ b/include/linux/dqblk_v1.h
@@ -0,0 +1,18 @@
+/*
+ *      File with in-memory structures of old quota format
+ */
+
+#ifndef _LINUX_DQBLK_V1_H
+#define _LINUX_DQBLK_V1_H
+
+/* Id of quota format */
+#define QFMT_VFS_OLD 1
+
+/* Root squash turned on */
+#define V1_DQF_RSQUASH 1
+
+/* Special information about quotafile */
+struct v1_mem_dqinfo {
+};
+
+#endif  /* _LINUX_DQBLK_V1_H */
diff --git a/include/linux/dqblk_v2.h b/include/linux/dqblk_v2.h
new file mode 100644
index 000000000000..4a6c5f6867bb
--- /dev/null
+++ b/include/linux/dqblk_v2.h
@@ -0,0 +1,20 @@
+/*
+ *      Definitions of structures for vfsv0 quota format
+ */
+
+#ifndef _LINUX_DQBLK_V2_H
+#define _LINUX_DQBLK_V2_H
+
+#include <linux/types.h>
+
+/* id numbers of quota format */
+#define QFMT_VFS_V0 2
+
+/* Inmemory copy of version specific information */
+struct v2_mem_dqinfo {
+        unsigned int dqi_blocks;
+        unsigned int dqi_free_blk;
+        unsigned int dqi_free_entry;
+};
+
+#endif /* _LINUX_DQBLK_V2_H */
diff --git a/include/linux/dqblk_xfs.h b/include/linux/dqblk_xfs.h
new file mode 100644
index 000000000000..cb31719ee192
--- /dev/null
+++ b/include/linux/dqblk_xfs.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 1995-2001,2004 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
+ * USA
+ *
+ * Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
+ * Mountain View, CA 94043, USA, or: http://www.sgi.com
+ */
+#ifndef _LINUX_DQBLK_XFS_H
+#define _LINUX_DQBLK_XFS_H
+
+#include <linux/types.h>
+
+/*
+ * Disk quota - quotactl(2) commands for the XFS Quota Manager (XQM).
+ */
+
+#define XQM_CMD(x)      (('X'<<8)+(x))  /* note: forms first QCMD argument */
+#define XQM_COMMAND(x)  (((x) & (0xff<<8)) == ('X'<<8)) /* test if for XFS */
+
+#define XQM_USRQUOTA    0       /* system call user quota type */
+#define XQM_GRPQUOTA    1       /* system call group quota type */
+#define XQM_MAXQUOTAS   2
+
+#define Q_XQUOTAON      XQM_CMD(1)      /* enable accounting/enforcement */
+#define Q_XQUOTAOFF     XQM_CMD(2)      /* disable accounting/enforcement */
+#define Q_XGETQUOTA     XQM_CMD(3)      /* get disk limits and usage */
+#define Q_XSETQLIM      XQM_CMD(4)      /* set disk limits */
+#define Q_XGETQSTAT     XQM_CMD(5)      /* get quota subsystem status */
+#define Q_XQUOTARM      XQM_CMD(6)      /* free disk space used by dquots */
+
+/*
+ * fs_disk_quota structure:
+ *
+ * This contains the current quota information regarding a user/proj/group.
+ * It is 64-bit aligned, and all the blk units are in BBs (Basic Blocks) of
+ * 512 bytes.
+ */
+#define FS_DQUOT_VERSION        1       /* fs_disk_quota.d_version */
+typedef struct fs_disk_quota {
+        __s8            d_version;      /* version of this structure */
+        __s8            d_flags;        /* XFS_{USER,PROJ,GROUP}_QUOTA */
+        __u16           d_fieldmask;    /* field specifier */
+        __u32           d_id;           /* user, project, or group ID */
+        __u64           d_blk_hardlimit;/* absolute limit on disk blks */
+        __u64           d_blk_softlimit;/* preferred limit on disk blks */
+        __u64           d_ino_hardlimit;/* maximum # allocated inodes */
+        __u64           d_ino_softlimit;/* preferred inode limit */
+        __u64           d_bcount;       /* # disk blocks owned by the user */
+        __u64           d_icount;       /* # inodes owned by the user */
+        __s32           d_itimer;       /* zero if within inode limits */
+                                        /* if not, we refuse service */
+        __s32           d_btimer;       /* similar to above; for disk blocks */
+        __u16           d_iwarns;       /* # warnings issued wrt num inodes */
+        __u16           d_bwarns;       /* # warnings issued wrt disk blocks */
+        __s32           d_padding2;     /* padding2 - for future use */
+        __u64           d_rtb_hardlimit;/* absolute limit on realtime blks */
+        __u64           d_rtb_softlimit;/* preferred limit on RT disk blks */
+        __u64           d_rtbcount;     /* # realtime blocks owned */
+        __s32           d_rtbtimer;     /* similar to above; for RT disk blks */
+        __u16           d_rtbwarns;     /* # warnings issued wrt RT disk blks */
+        __s16           d_padding3;     /* padding3 - for future use */ 
+        char            d_padding4[8];  /* yet more padding */
+} fs_disk_quota_t;
+
+/*
+ * These fields are sent to Q_XSETQLIM to specify fields that need to change.
+ */
+#define FS_DQ_ISOFT     (1<<0)
+#define FS_DQ_IHARD     (1<<1)
+#define FS_DQ_BSOFT     (1<<2)
+#define FS_DQ_BHARD     (1<<3)
+#define FS_DQ_RTBSOFT   (1<<4)
+#define FS_DQ_RTBHARD   (1<<5)
+#define FS_DQ_LIMIT_MASK        (FS_DQ_ISOFT | FS_DQ_IHARD | FS_DQ_BSOFT | \
+                                 FS_DQ_BHARD | FS_DQ_RTBSOFT | FS_DQ_RTBHARD)
+/*
+ * These timers can only be set in super user's dquot. For others, timers are
+ * automatically started and stopped. Superusers timer values set the limits
+ * for the rest.  In case these values are zero, the DQ_{F,B}TIMELIMIT values
+ * defined below are used. 
+ * These values also apply only to the d_fieldmask field for Q_XSETQLIM.
+ */
+#define FS_DQ_BTIMER    (1<<6)
+#define FS_DQ_ITIMER    (1<<7)
+#define FS_DQ_RTBTIMER  (1<<8)
+#define FS_DQ_TIMER_MASK        (FS_DQ_BTIMER | FS_DQ_ITIMER | FS_DQ_RTBTIMER)
+
+/*
+ * Warning counts are set in both super user's dquot and others. For others,
+ * warnings are set/cleared by the administrators (or automatically by going
+ * below the soft limit).  Superusers warning values set the warning limits
+ * for the rest.  In case these values are zero, the DQ_{F,B}WARNLIMIT values
+ * defined below are used. 
+ * These values also apply only to the d_fieldmask field for Q_XSETQLIM.
+ */
+#define FS_DQ_BWARNS    (1<<9)
+#define FS_DQ_IWARNS    (1<<10)
+#define FS_DQ_RTBWARNS  (1<<11)
+#define FS_DQ_WARNS_MASK        (FS_DQ_BWARNS | FS_DQ_IWARNS | FS_DQ_RTBWARNS)
+
+/*
+ * Various flags related to quotactl(2).  Only relevant to XFS filesystems.
+ */
+#define XFS_QUOTA_UDQ_ACCT      (1<<0)  /* user quota accounting */
+#define XFS_QUOTA_UDQ_ENFD      (1<<1)  /* user quota limits enforcement */
+#define XFS_QUOTA_GDQ_ACCT      (1<<2)  /* group quota accounting */
+#define XFS_QUOTA_GDQ_ENFD      (1<<3)  /* group quota limits enforcement */
+#define XFS_QUOTA_PDQ_ACCT      (1<<4)  /* project quota accounting */
+#define XFS_QUOTA_PDQ_ENFD      (1<<5)  /* project quota limits enforcement */
+
+#define XFS_USER_QUOTA          (1<<0)  /* user quota type */
+#define XFS_PROJ_QUOTA          (1<<1)  /* project quota type */
+#define XFS_GROUP_QUOTA         (1<<2)  /* group quota type */
+
+/*
+ * fs_quota_stat is the struct returned in Q_XGETQSTAT for a given file system.
+ * Provides a centralized way to get meta infomation about the quota subsystem.
+ * eg. space taken up for user and group quotas, number of dquots currently
+ * incore.
+ */
+#define FS_QSTAT_VERSION        1       /* fs_quota_stat.qs_version */
+
+/*
+ * Some basic infomation about 'quota files'.
+ */
+typedef struct fs_qfilestat {
+        __u64           qfs_ino;        /* inode number */
+        __u64           qfs_nblks;      /* number of BBs 512-byte-blks */
+        __u32           qfs_nextents;   /* number of extents */
+} fs_qfilestat_t;
+
+typedef struct fs_quota_stat {
+        __s8            qs_version;     /* version number for future changes */
+        __u16           qs_flags;       /* XFS_QUOTA_{U,P,G}DQ_{ACCT,ENFD} */
+        __s8            qs_pad;         /* unused */
+        fs_qfilestat_t  qs_uquota;      /* user quota storage information */
+        fs_qfilestat_t  qs_gquota;      /* group quota storage information */
+        __u32           qs_incoredqs;   /* number of dquots incore */
+        __s32           qs_btimelimit;  /* limit for blks timer */      
+        __s32           qs_itimelimit;  /* limit for inodes timer */    
+        __s32           qs_rtbtimelimit;/* limit for rt blks timer */   
+        __u16           qs_bwarnlimit;  /* limit for num warnings */
+        __u16           qs_iwarnlimit;  /* limit for num warnings */
+} fs_quota_stat_t;
+
+#endif  /* _LINUX_DQBLK_XFS_H */
diff --git a/include/linux/ds1286.h b/include/linux/ds1286.h
new file mode 100644
index 000000000000..d8989860e4ce
--- /dev/null
+++ b/include/linux/ds1286.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 1998, 1999, 2003 Ralf Baechle
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#ifndef __LINUX_DS1286_H
+#define __LINUX_DS1286_H
+
+#include <asm/ds1286.h>
+
+/**********************************************************************
+ * register summary
+ **********************************************************************/
+#define RTC_HUNDREDTH_SECOND    0
+#define RTC_SECONDS             1
+#define RTC_MINUTES             2
+#define RTC_MINUTES_ALARM       3
+#define RTC_HOURS               4
+#define RTC_HOURS_ALARM         5
+#define RTC_DAY                 6
+#define RTC_DAY_ALARM           7
+#define RTC_DATE                8
+#define RTC_MONTH               9
+#define RTC_YEAR                10
+#define RTC_CMD                 11
+#define RTC_WHSEC               12
+#define RTC_WSEC                13
+#define RTC_UNUSED              14
+
+/* RTC_*_alarm is always true if 2 MSBs are set */
+# define RTC_ALARM_DONT_CARE    0xC0
+
+
+/*
+ * Bits in the month register
+ */
+#define RTC_EOSC                0x80
+#define RTC_ESQW                0x40
+
+/*
+ * Bits in the Command register
+ */
+#define RTC_TDF                 0x01
+#define RTC_WAF                 0x02
+#define RTC_TDM                 0x04
+#define RTC_WAM                 0x08
+#define RTC_PU_LVL              0x10
+#define RTC_IBH_LO              0x20
+#define RTC_IPSW                0x40
+#define RTC_TE                  0x80
+
+#endif /* __LINUX_DS1286_H */
diff --git a/include/linux/dtlk.h b/include/linux/dtlk.h
new file mode 100644
index 000000000000..2896d90118a9
--- /dev/null
+++ b/include/linux/dtlk.h
@@ -0,0 +1,104 @@
+#if 0
+
+#define TRACE_TXT(text) \
+        { \
+          if(dtlk_trace) \
+          { \
+            console_print(text); \
+            console_print("\n"); \
+          } \
+        }
+
+#define TRACE_CHR(chr) \
+        { \
+          if(dtlk_trace) \
+            console_print(chr); \
+        } \
+
+#endif
+
+#define DTLK_MINOR      0
+#define DTLK_IO_EXTENT  0x02
+
+        /* ioctl's use magic number of 0xa3 */
+#define DTLK_INTERROGATE 0xa390 /* get settings from the DoubleTalk */
+#define DTLK_STATUS 0xa391      /* get status from the DoubleTalk */
+
+
+#define DTLK_CLEAR 0x18         /* stops speech */
+
+#define DTLK_MAX_RETRIES (loops_per_jiffy/(10000/HZ))
+
+        /* TTS Port Status Flags */
+#define TTS_READABLE     0x80   /* mask for bit which is nonzero if a
+                                   byte can be read from the TTS port */
+#define TTS_SPEAKING     0x40   /* mask for SYNC bit, which is nonzero
+                                   while DoubleTalk is producing
+                                   output with TTS, PCM or CVSD
+                                   synthesizers or tone generators
+                                   (that is, all but LPC) */
+#define TTS_SPEAKING2    0x20   /* mask for SYNC2 bit,
+                                   which falls to zero up to 0.4 sec
+                                   before speech stops */
+#define TTS_WRITABLE     0x10   /* mask for RDY bit, which when set to
+                                   1, indicates the TTS port is ready
+                                   to accept a byte of data.  The RDY
+                                   bit goes zero 2-3 usec after
+                                   writing, and goes 1 again 180-190
+                                   usec later. */
+#define TTS_ALMOST_FULL  0x08   /* mask for AF bit: When set to 1,
+                                   indicates that less than 300 free
+                                   bytes are available in the TTS
+                                   input buffer. AF is always 0 in the
+                                   PCM, TGN and CVSD modes. */
+#define TTS_ALMOST_EMPTY 0x04   /* mask for AE bit: When set to 1,
+                                   indicates that less than 300 bytes
+                                   of data remain in DoubleTalk's
+                                   input (TTS or PCM) buffer. AE is
+                                   always 1 in the TGN and CVSD
+                                   modes. */
+
+        /* LPC speak commands */
+#define LPC_5220_NORMAL 0x60    /* 5220 format decoding table, normal rate */
+#define LPC_5220_FAST 0x64      /* 5220 format decoding table, fast rate */
+#define LPC_D6_NORMAL 0x20      /* D6 format decoding table, normal rate */
+#define LPC_D6_FAST 0x24        /* D6 format decoding table, fast rate */
+
+        /* LPC Port Status Flags (valid only after one of the LPC
+           speak commands) */
+#define LPC_SPEAKING     0x80   /* mask for TS bit: When set to 1,
+                                   indicates the LPC synthesizer is
+                                   producing speech.*/
+#define LPC_BUFFER_LOW   0x40   /* mask for BL bit: When set to 1,
+                                   indicates that the hardware LPC
+                                   data buffer has less than 30 bytes
+                                   remaining. (Total internal buffer
+                                   size = 4096 bytes.) */
+#define LPC_BUFFER_EMPTY 0x20   /* mask for BE bit: When set to 1,
+                                   indicates that the LPC data buffer
+                                   ran out of data (error condition if
+                                   TS is also 1).  */
+
+                                /* data returned by Interrogate command */
+struct dtlk_settings
+{
+  unsigned short serial_number; /* 0-7Fh:0-7Fh */
+  unsigned char rom_version[24]; /* null terminated string */
+  unsigned char mode;           /* 0=Character; 1=Phoneme; 2=Text */
+  unsigned char punc_level;     /* nB; 0-7 */
+  unsigned char formant_freq;   /* nF; 0-9 */
+  unsigned char pitch;          /* nP; 0-99 */
+  unsigned char speed;          /* nS; 0-9 */
+  unsigned char volume;         /* nV; 0-9 */
+  unsigned char tone;           /* nX; 0-2 */
+  unsigned char expression;     /* nE; 0-9 */
+  unsigned char ext_dict_loaded; /* 1=exception dictionary loaded */
+  unsigned char ext_dict_status; /* 1=exception dictionary enabled */
+  unsigned char free_ram;       /* # pages (truncated) remaining for
+                                   text buffer */
+  unsigned char articulation;   /* nA; 0-9 */
+  unsigned char reverb;         /* nR; 0-9 */
+  unsigned char eob;            /* 7Fh value indicating end of
+                                   parameter block */
+  unsigned char has_indexing;   /* nonzero if indexing is implemented */
+};
diff --git a/include/linux/dvb/audio.h b/include/linux/dvb/audio.h
new file mode 100644
index 000000000000..cc314443f1c4
--- /dev/null
+++ b/include/linux/dvb/audio.h
@@ -0,0 +1,124 @@
+/*
+ * audio.h
+ *
+ * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
+ *                  & Marcus Metzler <marcus@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Lesser Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBAUDIO_H_
+#define _DVBAUDIO_H_
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#endif
+
+
+typedef enum {
+        AUDIO_SOURCE_DEMUX, /* Select the demux as the main source */
+        AUDIO_SOURCE_MEMORY /* Select internal memory as the main source */
+} audio_stream_source_t;
+
+
+typedef enum {
+        AUDIO_STOPPED,      /* Device is stopped */
+        AUDIO_PLAYING,      /* Device is currently playing */
+        AUDIO_PAUSED        /* Device is paused */
+} audio_play_state_t;
+
+
+typedef enum {
+        AUDIO_STEREO,
+        AUDIO_MONO_LEFT,
+        AUDIO_MONO_RIGHT
+} audio_channel_select_t;
+
+
+typedef struct audio_mixer {
+        unsigned int volume_left;
+        unsigned int volume_right;
+  // what else do we need? bass, pass-through, ...
+} audio_mixer_t;
+
+
+typedef struct audio_status {
+        int                    AV_sync_state;  /* sync audio and video? */
+        int                    mute_state;     /* audio is muted */
+        audio_play_state_t     play_state;     /* current playback state */
+        audio_stream_source_t  stream_source;  /* current stream source */
+        audio_channel_select_t channel_select; /* currently selected channel */
+        int                    bypass_mode;    /* pass on audio data to */
+        audio_mixer_t          mixer_state;    /* current mixer state */
+} audio_status_t;                              /* separate decoder hardware */
+
+
+typedef
+struct audio_karaoke{  /* if Vocal1 or Vocal2 are non-zero, they get mixed  */
+        int vocal1;    /* into left and right t at 70% each */
+        int vocal2;    /* if both, Vocal1 and Vocal2 are non-zero, Vocal1 gets*/
+        int melody;    /* mixed into the left channel and */
+                       /* Vocal2 into the right channel at 100% each. */
+                       /* if Melody is non-zero, the melody channel gets mixed*/
+} audio_karaoke_t;     /* into left and right  */
+
+
+typedef uint16_t audio_attributes_t;
+/*   bits: descr. */
+/*   15-13 audio coding mode (0=ac3, 2=mpeg1, 3=mpeg2ext, 4=LPCM, 6=DTS, */
+/*   12    multichannel extension */
+/*   11-10 audio type (0=not spec, 1=language included) */
+/*    9- 8 audio application mode (0=not spec, 1=karaoke, 2=surround) */
+/*    7- 6 Quantization / DRC (mpeg audio: 1=DRC exists)(lpcm: 0=16bit,  */
+/*    5- 4 Sample frequency fs (0=48kHz, 1=96kHz) */
+/*    2- 0 number of audio channels (n+1 channels) */
+
+
+/* for GET_CAPABILITIES and SET_FORMAT, the latter should only set one bit */
+#define AUDIO_CAP_DTS    1
+#define AUDIO_CAP_LPCM   2
+#define AUDIO_CAP_MP1    4
+#define AUDIO_CAP_MP2    8
+#define AUDIO_CAP_MP3   16
+#define AUDIO_CAP_AAC   32
+#define AUDIO_CAP_OGG   64
+#define AUDIO_CAP_SDDS 128
+#define AUDIO_CAP_AC3  256
+
+#define AUDIO_STOP                 _IO('o', 1)
+#define AUDIO_PLAY                 _IO('o', 2)
+#define AUDIO_PAUSE                _IO('o', 3)
+#define AUDIO_CONTINUE             _IO('o', 4)
+#define AUDIO_SELECT_SOURCE        _IO('o', 5)
+#define AUDIO_SET_MUTE             _IO('o', 6)
+#define AUDIO_SET_AV_SYNC          _IO('o', 7)
+#define AUDIO_SET_BYPASS_MODE      _IO('o', 8)
+#define AUDIO_CHANNEL_SELECT       _IO('o', 9)
+#define AUDIO_GET_STATUS           _IOR('o', 10, audio_status_t)
+
+#define AUDIO_GET_CAPABILITIES     _IOR('o', 11, unsigned int)
+#define AUDIO_CLEAR_BUFFER         _IO('o',  12)
+#define AUDIO_SET_ID               _IO('o', 13)
+#define AUDIO_SET_MIXER            _IOW('o', 14, audio_mixer_t)
+#define AUDIO_SET_STREAMTYPE       _IO('o', 15)
+#define AUDIO_SET_EXT_ID           _IO('o', 16)
+#define AUDIO_SET_ATTRIBUTES       _IOW('o', 17, audio_attributes_t)
+#define AUDIO_SET_KARAOKE          _IOW('o', 18, audio_karaoke_t)
+
+#endif /* _DVBAUDIO_H_ */
diff --git a/include/linux/dvb/ca.h b/include/linux/dvb/ca.h
new file mode 100644
index 000000000000..558af0cc7692
--- /dev/null
+++ b/include/linux/dvb/ca.h
@@ -0,0 +1,90 @@
+/*
+ * ca.h
+ *
+ * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
+ *                  & Marcus Metzler <marcus@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Lesser Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBCA_H_
+#define _DVBCA_H_
+
+/* slot interface types and info */
+
+typedef struct ca_slot_info {
+        int num;               /* slot number */
+
+        int type;              /* CA interface this slot supports */
+#define CA_CI            1     /* CI high level interface */
+#define CA_CI_LINK       2     /* CI link layer level interface */
+#define CA_CI_PHYS       4     /* CI physical layer level interface */
+#define CA_DESCR         8     /* built-in descrambler */
+#define CA_SC          128     /* simple smart card interface */
+
+        unsigned int flags;
+#define CA_CI_MODULE_PRESENT 1 /* module (or card) inserted */
+#define CA_CI_MODULE_READY   2
+} ca_slot_info_t;
+
+
+/* descrambler types and info */
+
+typedef struct ca_descr_info {
+        unsigned int num;          /* number of available descramblers (keys) */
+        unsigned int type;         /* type of supported scrambling system */
+#define CA_ECD           1
+#define CA_NDS           2
+#define CA_DSS           4
+} ca_descr_info_t;
+
+typedef struct ca_caps {
+        unsigned int slot_num;     /* total number of CA card and module slots */
+        unsigned int slot_type;    /* OR of all supported types */
+        unsigned int descr_num;    /* total number of descrambler slots (keys) */
+        unsigned int descr_type;   /* OR of all supported types */
+} ca_caps_t;
+
+/* a message to/from a CI-CAM */
+typedef struct ca_msg {
+        unsigned int index;
+        unsigned int type;
+        unsigned int length;
+        unsigned char msg[256];
+} ca_msg_t;
+
+typedef struct ca_descr {
+        unsigned int index;
+        unsigned int parity;    /* 0 == even, 1 == odd */
+        unsigned char cw[8];
+} ca_descr_t;
+
+typedef struct ca_pid {
+        unsigned int pid;
+        int index;              /* -1 == disable*/
+} ca_pid_t;
+
+#define CA_RESET          _IO('o', 128)
+#define CA_GET_CAP        _IOR('o', 129, ca_caps_t)
+#define CA_GET_SLOT_INFO  _IOR('o', 130, ca_slot_info_t)
+#define CA_GET_DESCR_INFO _IOR('o', 131, ca_descr_info_t)
+#define CA_GET_MSG        _IOR('o', 132, ca_msg_t)
+#define CA_SEND_MSG       _IOW('o', 133, ca_msg_t)
+#define CA_SET_DESCR      _IOW('o', 134, ca_descr_t)
+#define CA_SET_PID        _IOW('o', 135, ca_pid_t)
+
+#endif
diff --git a/include/linux/dvb/dmx.h b/include/linux/dvb/dmx.h
new file mode 100644
index 000000000000..ce3f829da82c
--- /dev/null
+++ b/include/linux/dvb/dmx.h
@@ -0,0 +1,180 @@
+/* 
+ * dmx.h
+ *
+ * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de>
+ *                  & Ralph  Metzler <ralph@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBDMX_H_
+#define _DVBDMX_H_
+
+#include <asm/types.h>
+#ifdef __KERNEL__
+#include <linux/time.h>
+#else
+#include <time.h>
+#endif
+
+
+#define DMX_FILTER_SIZE 16
+
+typedef enum
+{
+        DMX_OUT_DECODER, /* Streaming directly to decoder. */
+        DMX_OUT_TAP,     /* Output going to a memory buffer */
+                         /* (to be retrieved via the read command).*/
+        DMX_OUT_TS_TAP   /* Output multiplexed into a new TS  */
+                         /* (to be retrieved by reading from the */
+                         /* logical DVR device).                 */
+} dmx_output_t;
+
+
+typedef enum
+{
+        DMX_IN_FRONTEND, /* Input from a front-end device.  */
+        DMX_IN_DVR       /* Input from the logical DVR device.  */
+} dmx_input_t;
+
+
+typedef enum
+{
+        DMX_PES_AUDIO0,
+        DMX_PES_VIDEO0,
+        DMX_PES_TELETEXT0,
+        DMX_PES_SUBTITLE0,
+        DMX_PES_PCR0,
+
+        DMX_PES_AUDIO1,
+        DMX_PES_VIDEO1,
+        DMX_PES_TELETEXT1,
+        DMX_PES_SUBTITLE1,
+        DMX_PES_PCR1,
+
+        DMX_PES_AUDIO2,
+        DMX_PES_VIDEO2,
+        DMX_PES_TELETEXT2,
+        DMX_PES_SUBTITLE2,
+        DMX_PES_PCR2,
+
+        DMX_PES_AUDIO3,
+        DMX_PES_VIDEO3,
+        DMX_PES_TELETEXT3,
+        DMX_PES_SUBTITLE3,
+        DMX_PES_PCR3,
+
+        DMX_PES_OTHER
+} dmx_pes_type_t;
+
+#define DMX_PES_AUDIO    DMX_PES_AUDIO0
+#define DMX_PES_VIDEO    DMX_PES_VIDEO0
+#define DMX_PES_TELETEXT DMX_PES_TELETEXT0
+#define DMX_PES_SUBTITLE DMX_PES_SUBTITLE0
+#define DMX_PES_PCR      DMX_PES_PCR0
+
+
+typedef enum
+{
+        DMX_SCRAMBLING_EV,
+        DMX_FRONTEND_EV
+} dmx_event_t;
+
+
+typedef enum
+{
+        DMX_SCRAMBLING_OFF,
+        DMX_SCRAMBLING_ON
+} dmx_scrambling_status_t;
+
+
+typedef struct dmx_filter
+{
+        __u8  filter[DMX_FILTER_SIZE];
+        __u8  mask[DMX_FILTER_SIZE];
+        __u8  mode[DMX_FILTER_SIZE];
+} dmx_filter_t;
+
+
+struct dmx_sct_filter_params
+{
+        __u16          pid;
+        dmx_filter_t   filter;
+        __u32          timeout;
+        __u32          flags;
+#define DMX_CHECK_CRC       1
+#define DMX_ONESHOT         2
+#define DMX_IMMEDIATE_START 4
+#define DMX_KERNEL_CLIENT   0x8000
+};
+
+
+struct dmx_pes_filter_params
+{
+        __u16          pid;
+        dmx_input_t    input;
+        dmx_output_t   output;
+        dmx_pes_type_t pes_type;
+        __u32          flags;
+};
+
+
+struct dmx_event
+{
+        dmx_event_t         event;
+        time_t              timeStamp;
+        union
+        {
+                dmx_scrambling_status_t scrambling;
+        } u;
+};
+
+typedef struct dmx_caps {
+        __u32 caps;
+        int num_decoders;
+} dmx_caps_t;
+
+typedef enum {
+        DMX_SOURCE_FRONT0 = 0,
+        DMX_SOURCE_FRONT1,
+        DMX_SOURCE_FRONT2,
+        DMX_SOURCE_FRONT3,
+        DMX_SOURCE_DVR0   = 16,
+        DMX_SOURCE_DVR1,
+        DMX_SOURCE_DVR2,
+        DMX_SOURCE_DVR3
+} dmx_source_t;
+
+struct dmx_stc {
+        unsigned int num;       /* input : which STC? 0..N */
+        unsigned int base;      /* output: divisor for stc to get 90 kHz clock */
+        __u64 stc;              /* output: stc in 'base'*90 kHz units */
+};
+
+
+#define DMX_START                _IO('o', 41)
+#define DMX_STOP                 _IO('o', 42)
+#define DMX_SET_FILTER           _IOW('o', 43, struct dmx_sct_filter_params)
+#define DMX_SET_PES_FILTER       _IOW('o', 44, struct dmx_pes_filter_params)
+#define DMX_SET_BUFFER_SIZE      _IO('o', 45)
+#define DMX_GET_EVENT            _IOR('o', 46, struct dmx_event)
+#define DMX_GET_PES_PIDS         _IOR('o', 47, __u16[5])
+#define DMX_GET_CAPS             _IOR('o', 48, dmx_caps_t)
+#define DMX_SET_SOURCE           _IOW('o', 49, dmx_source_t)
+#define DMX_GET_STC              _IOWR('o', 50, struct dmx_stc)
+
+#endif /*_DVBDMX_H_*/
diff --git a/include/linux/dvb/frontend.h b/include/linux/dvb/frontend.h
new file mode 100644
index 000000000000..d41df7047ed7
--- /dev/null
+++ b/include/linux/dvb/frontend.h
@@ -0,0 +1,267 @@
+/*
+ * frontend.h
+ *
+ * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de>
+ *                  Ralph  Metzler <ralph@convergence.de>
+ *                  Holger Waechtler <holger@convergence.de>
+ *                  Andre Draszik <ad@convergence.de>
+ *                  for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBFRONTEND_H_
+#define _DVBFRONTEND_H_
+
+#include <asm/types.h>
+
+
+typedef enum fe_type {
+        FE_QPSK,
+        FE_QAM,
+        FE_OFDM,
+        FE_ATSC
+} fe_type_t;
+
+
+typedef enum fe_caps {
+        FE_IS_STUPID                    = 0,
+        FE_CAN_INVERSION_AUTO           = 0x1,
+        FE_CAN_FEC_1_2                  = 0x2,
+        FE_CAN_FEC_2_3                  = 0x4,
+        FE_CAN_FEC_3_4                  = 0x8,
+        FE_CAN_FEC_4_5                  = 0x10,
+        FE_CAN_FEC_5_6                  = 0x20,
+        FE_CAN_FEC_6_7                  = 0x40,
+        FE_CAN_FEC_7_8                  = 0x80,
+        FE_CAN_FEC_8_9                  = 0x100,
+        FE_CAN_FEC_AUTO                 = 0x200,
+        FE_CAN_QPSK                     = 0x400,
+        FE_CAN_QAM_16                   = 0x800,
+        FE_CAN_QAM_32                   = 0x1000,
+        FE_CAN_QAM_64                   = 0x2000,
+        FE_CAN_QAM_128                  = 0x4000,
+        FE_CAN_QAM_256                  = 0x8000,
+        FE_CAN_QAM_AUTO                 = 0x10000,
+        FE_CAN_TRANSMISSION_MODE_AUTO   = 0x20000,
+        FE_CAN_BANDWIDTH_AUTO           = 0x40000,
+        FE_CAN_GUARD_INTERVAL_AUTO      = 0x80000,
+        FE_CAN_HIERARCHY_AUTO           = 0x100000,
+        FE_CAN_8VSB                     = 0x200000,
+        FE_CAN_16VSB                    = 0x400000,
+        FE_NEEDS_BENDING                = 0x20000000, // not supported anymore, don't use (frontend requires frequency bending)
+        FE_CAN_RECOVER                  = 0x40000000, // frontend can recover from a cable unplug automatically
+        FE_CAN_MUTE_TS                  = 0x80000000  // frontend can stop spurious TS data output
+} fe_caps_t;
+
+
+struct dvb_frontend_info {
+        char       name[128];
+        fe_type_t  type;
+        __u32      frequency_min;
+        __u32      frequency_max;
+        __u32      frequency_stepsize;
+        __u32      frequency_tolerance;
+        __u32      symbol_rate_min;
+        __u32      symbol_rate_max;
+        __u32      symbol_rate_tolerance;       /* ppm */
+        __u32      notifier_delay;              /* DEPRECATED */
+        fe_caps_t  caps;
+};
+
+
+/**
+ *  Check out the DiSEqC bus spec available on http://www.eutelsat.org/ for
+ *  the meaning of this struct...
+ */
+struct dvb_diseqc_master_cmd {
+        __u8 msg [6];   /*  { framing, address, command, data [3] } */
+        __u8 msg_len;   /*  valid values are 3...6  */
+};
+
+
+struct dvb_diseqc_slave_reply {
+        __u8 msg [4];   /*  { framing, data [3] } */
+        __u8 msg_len;   /*  valid values are 0...4, 0 means no msg  */
+        int  timeout;   /*  return from ioctl after timeout ms with */
+};                      /*  errorcode when no message was received  */
+
+
+typedef enum fe_sec_voltage {
+        SEC_VOLTAGE_13,
+        SEC_VOLTAGE_18,
+        SEC_VOLTAGE_OFF
+} fe_sec_voltage_t;
+
+
+typedef enum fe_sec_tone_mode {
+        SEC_TONE_ON,
+        SEC_TONE_OFF
+} fe_sec_tone_mode_t;
+
+
+typedef enum fe_sec_mini_cmd {
+        SEC_MINI_A,
+        SEC_MINI_B
+} fe_sec_mini_cmd_t;
+
+
+typedef enum fe_status {
+        FE_HAS_SIGNAL   = 0x01,   /*  found something above the noise level */
+        FE_HAS_CARRIER  = 0x02,   /*  found a DVB signal  */
+        FE_HAS_VITERBI  = 0x04,   /*  FEC is stable  */
+        FE_HAS_SYNC     = 0x08,   /*  found sync bytes  */
+        FE_HAS_LOCK     = 0x10,   /*  everything's working... */
+        FE_TIMEDOUT     = 0x20,   /*  no lock within the last ~2 seconds */
+        FE_REINIT       = 0x40    /*  frontend was reinitialized,  */
+} fe_status_t;                    /*  application is recommended to reset */
+                                  /*  DiSEqC, tone and parameters */
+
+typedef enum fe_spectral_inversion {
+        INVERSION_OFF,
+        INVERSION_ON,
+        INVERSION_AUTO
+} fe_spectral_inversion_t;
+
+
+typedef enum fe_code_rate {
+        FEC_NONE = 0,
+        FEC_1_2,
+        FEC_2_3,
+        FEC_3_4,
+        FEC_4_5,
+        FEC_5_6,
+        FEC_6_7,
+        FEC_7_8,
+        FEC_8_9,
+        FEC_AUTO
+} fe_code_rate_t;
+
+
+typedef enum fe_modulation {
+        QPSK,
+        QAM_16,
+        QAM_32,
+        QAM_64,
+        QAM_128,
+        QAM_256,
+        QAM_AUTO,
+        VSB_8,
+        VSB_16
+} fe_modulation_t;
+
+typedef enum fe_transmit_mode {
+        TRANSMISSION_MODE_2K,
+        TRANSMISSION_MODE_8K,
+        TRANSMISSION_MODE_AUTO
+} fe_transmit_mode_t;
+
+typedef enum fe_bandwidth {
+        BANDWIDTH_8_MHZ,
+        BANDWIDTH_7_MHZ,
+        BANDWIDTH_6_MHZ,
+        BANDWIDTH_AUTO
+} fe_bandwidth_t;
+
+
+typedef enum fe_guard_interval {
+        GUARD_INTERVAL_1_32,
+        GUARD_INTERVAL_1_16,
+        GUARD_INTERVAL_1_8,
+        GUARD_INTERVAL_1_4,
+        GUARD_INTERVAL_AUTO
+} fe_guard_interval_t;
+
+
+typedef enum fe_hierarchy {
+        HIERARCHY_NONE,
+        HIERARCHY_1,
+        HIERARCHY_2,
+        HIERARCHY_4,
+        HIERARCHY_AUTO
+} fe_hierarchy_t;
+
+
+struct dvb_qpsk_parameters {
+        __u32           symbol_rate;  /* symbol rate in Symbols per second */
+        fe_code_rate_t  fec_inner;    /* forward error correction (see above) */
+};
+
+struct dvb_qam_parameters {
+        __u32           symbol_rate; /* symbol rate in Symbols per second */
+        fe_code_rate_t  fec_inner;   /* forward error correction (see above) */
+        fe_modulation_t modulation;  /* modulation type (see above) */
+};
+
+struct dvb_vsb_parameters {
+        fe_modulation_t modulation;  /* modulation type (see above) */
+};
+
+struct dvb_ofdm_parameters {
+        fe_bandwidth_t      bandwidth;
+        fe_code_rate_t      code_rate_HP;  /* high priority stream code rate */
+        fe_code_rate_t      code_rate_LP;  /* low priority stream code rate */
+        fe_modulation_t     constellation; /* modulation type (see above) */
+        fe_transmit_mode_t  transmission_mode;
+        fe_guard_interval_t guard_interval;
+        fe_hierarchy_t      hierarchy_information;
+};
+
+
+struct dvb_frontend_parameters {
+        __u32 frequency;     /* (absolute) frequency in Hz for QAM/OFDM/ATSC */
+                             /* intermediate frequency in kHz for QPSK */
+        fe_spectral_inversion_t inversion;
+        union {
+                struct dvb_qpsk_parameters qpsk;
+                struct dvb_qam_parameters  qam;
+                struct dvb_ofdm_parameters ofdm;
+                struct dvb_vsb_parameters vsb;
+        } u;
+};
+
+
+struct dvb_frontend_event {
+        fe_status_t status;
+        struct dvb_frontend_parameters parameters;
+};
+
+
+
+#define FE_GET_INFO                _IOR('o', 61, struct dvb_frontend_info)
+
+#define FE_DISEQC_RESET_OVERLOAD   _IO('o', 62)
+#define FE_DISEQC_SEND_MASTER_CMD  _IOW('o', 63, struct dvb_diseqc_master_cmd)
+#define FE_DISEQC_RECV_SLAVE_REPLY _IOR('o', 64, struct dvb_diseqc_slave_reply)
+#define FE_DISEQC_SEND_BURST       _IO('o', 65)  /* fe_sec_mini_cmd_t */
+
+#define FE_SET_TONE                _IO('o', 66)  /* fe_sec_tone_mode_t */
+#define FE_SET_VOLTAGE             _IO('o', 67)  /* fe_sec_voltage_t */
+#define FE_ENABLE_HIGH_LNB_VOLTAGE _IO('o', 68)  /* int */
+
+#define FE_READ_STATUS             _IOR('o', 69, fe_status_t)
+#define FE_READ_BER                _IOR('o', 70, __u32)
+#define FE_READ_SIGNAL_STRENGTH    _IOR('o', 71, __u16)
+#define FE_READ_SNR                _IOR('o', 72, __u16)
+#define FE_READ_UNCORRECTED_BLOCKS _IOR('o', 73, __u32)
+
+#define FE_SET_FRONTEND            _IOW('o', 76, struct dvb_frontend_parameters)
+#define FE_GET_FRONTEND            _IOR('o', 77, struct dvb_frontend_parameters)
+#define FE_GET_EVENT               _IOR('o', 78, struct dvb_frontend_event)
+
+#define FE_DISHNETWORK_SEND_LEGACY_CMD _IO('o', 80) /* unsigned int */
+
+#endif /*_DVBFRONTEND_H_*/
diff --git a/include/linux/dvb/net.h b/include/linux/dvb/net.h
new file mode 100644
index 000000000000..5be474bf0d2b
--- /dev/null
+++ b/include/linux/dvb/net.h
@@ -0,0 +1,53 @@
+/*
+ * net.h
+ *
+ * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de>
+ *                  & Ralph  Metzler <ralph@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBNET_H_
+#define _DVBNET_H_
+
+#include <asm/types.h>
+
+
+struct dvb_net_if {
+        __u16 pid;
+        __u16 if_num;
+        __u8  feedtype;
+#define DVB_NET_FEEDTYPE_MPE 0  /* multi protocol encapsulation */
+#define DVB_NET_FEEDTYPE_ULE 1  /* ultra lightweight encapsulation */
+};
+
+
+#define NET_ADD_IF    _IOWR('o', 52, struct dvb_net_if)
+#define NET_REMOVE_IF _IO('o', 53)
+#define NET_GET_IF    _IOWR('o', 54, struct dvb_net_if)
+
+
+/* binary compatibility cruft: */
+struct __dvb_net_if_old {
+        __u16 pid;
+        __u16 if_num;
+};
+#define __NET_ADD_IF_OLD _IOWR('o', 52, struct __dvb_net_if_old)
+#define __NET_GET_IF_OLD _IOWR('o', 54, struct __dvb_net_if_old)
+
+
+#endif /*_DVBNET_H_*/
diff --git a/include/linux/dvb/osd.h b/include/linux/dvb/osd.h
new file mode 100644
index 000000000000..0e1973d54a6b
--- /dev/null
+++ b/include/linux/dvb/osd.h
@@ -0,0 +1,144 @@
+/*
+ * osd.h
+ *
+ * Copyright (C) 2001 Ralph  Metzler <ralph@convergence.de>
+ *                  & Marcus Metzler <marcus@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Lesser Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBOSD_H_
+#define _DVBOSD_H_
+
+#include <linux/compiler.h>
+
+typedef enum {
+  // All functions return -2 on "not open"
+  OSD_Close=1,    // ()
+  // Disables OSD and releases the buffers
+  // returns 0 on success
+  OSD_Open,       // (x0,y0,x1,y1,BitPerPixel[2/4/8](color&0x0F),mix[0..15](color&0xF0))
+  // Opens OSD with this size and bit depth
+  // returns 0 on success, -1 on DRAM allocation error, -2 on "already open"
+  OSD_Show,       // ()
+  // enables OSD mode
+  // returns 0 on success
+  OSD_Hide,       // ()
+  // disables OSD mode
+  // returns 0 on success
+  OSD_Clear,      // ()
+  // Sets all pixel to color 0
+  // returns 0 on success
+  OSD_Fill,       // (color)
+  // Sets all pixel to color <col>
+  // returns 0 on success
+  OSD_SetColor,   // (color,R{x0},G{y0},B{x1},opacity{y1})
+  // set palette entry <num> to <r,g,b>, <mix> and <trans> apply
+  // R,G,B: 0..255
+  // R=Red, G=Green, B=Blue
+  // opacity=0:      pixel opacity 0% (only video pixel shows)
+  // opacity=1..254: pixel opacity as specified in header
+  // opacity=255:    pixel opacity 100% (only OSD pixel shows)
+  // returns 0 on success, -1 on error
+  OSD_SetPalette, // (firstcolor{color},lastcolor{x0},data)
+  // Set a number of entries in the palette
+  // sets the entries "firstcolor" through "lastcolor" from the array "data"
+  // data has 4 byte for each color:
+  // R,G,B, and a opacity value: 0->transparent, 1..254->mix, 255->pixel
+  OSD_SetTrans,   // (transparency{color})
+  // Sets transparency of mixed pixel (0..15)
+  // returns 0 on success
+  OSD_SetPixel,   // (x0,y0,color)
+  // sets pixel <x>,<y> to color number <col>
+  // returns 0 on success, -1 on error
+  OSD_GetPixel,   // (x0,y0)
+  // returns color number of pixel <x>,<y>,  or -1
+  OSD_SetRow,     // (x0,y0,x1,data)
+  // fills pixels x0,y through  x1,y with the content of data[]
+  // returns 0 on success, -1 on clipping all pixel (no pixel drawn)
+  OSD_SetBlock,   // (x0,y0,x1,y1,increment{color},data)
+  // fills pixels x0,y0 through  x1,y1 with the content of data[]
+  // inc contains the width of one line in the data block,
+  // inc<=0 uses blockwidth as linewidth
+  // returns 0 on success, -1 on clipping all pixel
+  OSD_FillRow,    // (x0,y0,x1,color)
+  // fills pixels x0,y through  x1,y with the color <col>
+  // returns 0 on success, -1 on clipping all pixel
+  OSD_FillBlock,  // (x0,y0,x1,y1,color)
+  // fills pixels x0,y0 through  x1,y1 with the color <col>
+  // returns 0 on success, -1 on clipping all pixel
+  OSD_Line,       // (x0,y0,x1,y1,color)
+  // draw a line from x0,y0 to x1,y1 with the color <col>
+  // returns 0 on success
+  OSD_Query,      // (x0,y0,x1,y1,xasp{color}}), yasp=11
+  // fills parameters with the picture dimensions and the pixel aspect ratio
+  // returns 0 on success
+  OSD_Test,       // ()
+  // draws a test picture. for debugging purposes only
+  // returns 0 on success
+// TODO: remove "test" in final version
+  OSD_Text,       // (x0,y0,size,color,text)
+  OSD_SetWindow, //  (x0) set window with number 0<x0<8 as current
+  OSD_MoveWindow, //  move current window to (x0, y0)
+  OSD_OpenRaw,  // Open other types of OSD windows
+} OSD_Command;
+
+typedef struct osd_cmd_s {
+        OSD_Command cmd;
+        int x0;
+        int y0;
+        int x1;
+        int y1;
+        int color;
+        void __user *data;
+} osd_cmd_t;
+
+/* OSD_OpenRaw: set 'color' to desired window type */
+typedef enum {
+        OSD_BITMAP1,           /* 1 bit bitmap */
+        OSD_BITMAP2,           /* 2 bit bitmap */
+        OSD_BITMAP4,           /* 4 bit bitmap */
+        OSD_BITMAP8,           /* 8 bit bitmap */
+        OSD_BITMAP1HR,         /* 1 Bit bitmap half resolution */
+        OSD_BITMAP2HR,         /* 2 bit bitmap half resolution */
+        OSD_BITMAP4HR,         /* 4 bit bitmap half resolution */
+        OSD_BITMAP8HR,         /* 8 bit bitmap half resolution */
+        OSD_YCRCB422,          /* 4:2:2 YCRCB Graphic Display */
+        OSD_YCRCB444,          /* 4:4:4 YCRCB Graphic Display */
+        OSD_YCRCB444HR,        /* 4:4:4 YCRCB graphic half resolution */
+        OSD_VIDEOTSIZE,        /* True Size Normal MPEG Video Display */
+        OSD_VIDEOHSIZE,        /* MPEG Video Display Half Resolution */
+        OSD_VIDEOQSIZE,        /* MPEG Video Display Quarter Resolution */
+        OSD_VIDEODSIZE,        /* MPEG Video Display Double Resolution */
+        OSD_VIDEOTHSIZE,       /* True Size MPEG Video Display Half Resolution */
+        OSD_VIDEOTQSIZE,       /* True Size MPEG Video Display Quarter Resolution*/
+        OSD_VIDEOTDSIZE,       /* True Size MPEG Video Display Double Resolution */
+        OSD_VIDEONSIZE,        /* Full Size MPEG Video Display */
+        OSD_CURSOR             /* Cursor */
+} osd_raw_window_t;
+
+typedef struct osd_cap_s {
+        int  cmd;
+#define OSD_CAP_MEMSIZE         1  /* memory size */
+        long val;
+} osd_cap_t;
+
+
+#define OSD_SEND_CMD            _IOW('o', 160, osd_cmd_t)
+#define OSD_GET_CAPABILITY      _IOR('o', 161, osd_cap_t)
+
+#endif
diff --git a/include/linux/dvb/version.h b/include/linux/dvb/version.h
new file mode 100644
index 000000000000..6183c9c4849e
--- /dev/null
+++ b/include/linux/dvb/version.h
@@ -0,0 +1,29 @@
+/*
+ * version.h
+ *
+ * Copyright (C) 2000 Holger Waechtler <holger@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBVERSION_H_
+#define _DVBVERSION_H_
+
+#define DVB_API_VERSION 3
+#define DVB_API_VERSION_MINOR 1
+
+#endif /*_DVBVERSION_H_*/
diff --git a/include/linux/dvb/video.h b/include/linux/dvb/video.h
new file mode 100644
index 000000000000..941045e9ab89
--- /dev/null
+++ b/include/linux/dvb/video.h
@@ -0,0 +1,203 @@
+/*
+ * video.h
+ *
+ * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de>
+ *                  & Ralph  Metzler <ralph@convergence.de>
+ *                    for convergence integrated media GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#ifndef _DVBVIDEO_H_
+#define _DVBVIDEO_H_
+
+#include <linux/compiler.h>
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#include <time.h>
+#endif
+
+
+typedef enum {
+        VIDEO_FORMAT_4_3,     /* Select 4:3 format */
+        VIDEO_FORMAT_16_9,    /* Select 16:9 format. */
+        VIDEO_FORMAT_221_1    /* 2.21:1 */
+} video_format_t;
+
+
+typedef enum {
+         VIDEO_SYSTEM_PAL,
+         VIDEO_SYSTEM_NTSC,
+         VIDEO_SYSTEM_PALN,
+         VIDEO_SYSTEM_PALNc,
+         VIDEO_SYSTEM_PALM,
+         VIDEO_SYSTEM_NTSC60,
+         VIDEO_SYSTEM_PAL60,
+         VIDEO_SYSTEM_PALM60
+} video_system_t;
+
+
+typedef enum {
+        VIDEO_PAN_SCAN,       /* use pan and scan format */
+        VIDEO_LETTER_BOX,     /* use letterbox format */
+        VIDEO_CENTER_CUT_OUT  /* use center cut out format */
+} video_displayformat_t;
+
+typedef struct {
+        int w;
+        int h;
+        video_format_t aspect_ratio;
+} video_size_t;
+
+typedef enum {
+        VIDEO_SOURCE_DEMUX, /* Select the demux as the main source */
+        VIDEO_SOURCE_MEMORY /* If this source is selected, the stream
+                               comes from the user through the write
+                               system call */
+} video_stream_source_t;
+
+
+typedef enum {
+        VIDEO_STOPPED, /* Video is stopped */
+        VIDEO_PLAYING, /* Video is currently playing */
+        VIDEO_FREEZED  /* Video is freezed */
+} video_play_state_t;
+
+
+struct video_event {
+        int32_t type;
+#define VIDEO_EVENT_SIZE_CHANGED        1
+#define VIDEO_EVENT_FRAME_RATE_CHANGED  2
+        time_t timestamp;
+        union {
+                video_size_t size;
+                unsigned int frame_rate;        /* in frames per 1000sec */
+        } u;
+};
+
+
+struct video_status {
+        int                   video_blank;   /* blank video on freeze? */
+        video_play_state_t    play_state;    /* current state of playback */
+        video_stream_source_t stream_source; /* current source (demux/memory) */
+        video_format_t        video_format;  /* current aspect ratio of stream*/
+        video_displayformat_t display_format;/* selected cropping mode */
+};
+
+
+struct video_still_picture {
+        char __user *iFrame;        /* pointer to a single iframe in memory */
+        int32_t size;
+};
+
+
+typedef
+struct video_highlight {
+        int     active;      /*    1=show highlight, 0=hide highlight */
+        uint8_t contrast1;   /*    7- 4  Pattern pixel contrast */
+                             /*    3- 0  Background pixel contrast */
+        uint8_t contrast2;   /*    7- 4  Emphasis pixel-2 contrast */
+                             /*    3- 0  Emphasis pixel-1 contrast */
+        uint8_t color1;      /*    7- 4  Pattern pixel color */
+                             /*    3- 0  Background pixel color */
+        uint8_t color2;      /*    7- 4  Emphasis pixel-2 color */
+                             /*    3- 0  Emphasis pixel-1 color */
+        uint32_t ypos;       /*   23-22  auto action mode */
+                             /*   21-12  start y */
+                             /*    9- 0  end y */
+        uint32_t xpos;       /*   23-22  button color number */
+                             /*   21-12  start x */
+                             /*    9- 0  end x */
+} video_highlight_t;
+
+
+typedef struct video_spu {
+        int active;
+        int stream_id;
+} video_spu_t;
+
+
+typedef struct video_spu_palette {      /* SPU Palette information */
+        int length;
+        uint8_t *palette;
+} video_spu_palette_t;
+
+
+typedef struct video_navi_pack {
+        int length;          /* 0 ... 1024 */
+        uint8_t data[1024];
+} video_navi_pack_t;
+
+
+typedef uint16_t video_attributes_t;
+/*   bits: descr. */
+/*   15-14 Video compression mode (0=MPEG-1, 1=MPEG-2) */
+/*   13-12 TV system (0=525/60, 1=625/50) */
+/*   11-10 Aspect ratio (0=4:3, 3=16:9) */
+/*    9- 8 permitted display mode on 4:3 monitor (0=both, 1=only pan-sca */
+/*    7    line 21-1 data present in GOP (1=yes, 0=no) */
+/*    6    line 21-2 data present in GOP (1=yes, 0=no) */
+/*    5- 3 source resolution (0=720x480/576, 1=704x480/576, 2=352x480/57 */
+/*    2    source letterboxed (1=yes, 0=no) */
+/*    0    film/camera mode (0=camera, 1=film (625/50 only)) */
+
+
+/* bit definitions for capabilities: */
+/* can the hardware decode MPEG1 and/or MPEG2? */
+#define VIDEO_CAP_MPEG1   1
+#define VIDEO_CAP_MPEG2   2
+/* can you send a system and/or program stream to video device?
+   (you still have to open the video and the audio device but only
+    send the stream to the video device) */
+#define VIDEO_CAP_SYS     4
+#define VIDEO_CAP_PROG    8
+/* can the driver also handle SPU, NAVI and CSS encoded data?
+   (CSS API is not present yet) */
+#define VIDEO_CAP_SPU    16
+#define VIDEO_CAP_NAVI   32
+#define VIDEO_CAP_CSS    64
+
+
+#define VIDEO_STOP                 _IO('o', 21)
+#define VIDEO_PLAY                 _IO('o', 22)
+#define VIDEO_FREEZE               _IO('o', 23)
+#define VIDEO_CONTINUE             _IO('o', 24)
+#define VIDEO_SELECT_SOURCE        _IO('o', 25)
+#define VIDEO_SET_BLANK            _IO('o', 26)
+#define VIDEO_GET_STATUS           _IOR('o', 27, struct video_status)
+#define VIDEO_GET_EVENT            _IOR('o', 28, struct video_event)
+#define VIDEO_SET_DISPLAY_FORMAT   _IO('o', 29)
+#define VIDEO_STILLPICTURE         _IOW('o', 30, struct video_still_picture)
+#define VIDEO_FAST_FORWARD         _IO('o', 31)
+#define VIDEO_SLOWMOTION           _IO('o', 32)
+#define VIDEO_GET_CAPABILITIES     _IOR('o', 33, unsigned int)
+#define VIDEO_CLEAR_BUFFER         _IO('o',  34)
+#define VIDEO_SET_ID               _IO('o', 35)
+#define VIDEO_SET_STREAMTYPE       _IO('o', 36)
+#define VIDEO_SET_FORMAT           _IO('o', 37)
+#define VIDEO_SET_SYSTEM           _IO('o', 38)
+#define VIDEO_SET_HIGHLIGHT        _IOW('o', 39, video_highlight_t)
+#define VIDEO_SET_SPU              _IOW('o', 50, video_spu_t)
+#define VIDEO_SET_SPU_PALETTE      _IOW('o', 51, video_spu_palette_t)
+#define VIDEO_GET_NAVI             _IOR('o', 52, video_navi_pack_t)
+#define VIDEO_SET_ATTRIBUTES       _IO('o', 53)
+#define VIDEO_GET_SIZE             _IOR('o', 55, video_size_t)
+#define VIDEO_GET_FRAME_RATE       _IOR('o', 56, unsigned int)
+
+#endif /*_DVBVIDEO_H_*/
diff --git a/include/linux/edd.h b/include/linux/edd.h
new file mode 100644
index 000000000000..c6e6747a401d
--- /dev/null
+++ b/include/linux/edd.h
@@ -0,0 +1,194 @@
+/*
+ * linux/include/linux/edd.h
+ *  Copyright (C) 2002, 2003, 2004 Dell Inc.
+ *  by Matt Domsch <Matt_Domsch@dell.com>
+ *
+ * structures and definitions for the int 13h, ax={41,48}h
+ * BIOS Enhanced Disk Drive Services
+ * This is based on the T13 group document D1572 Revision 0 (August 14 2002)
+ * available at http://www.t13.org/docs2002/d1572r0.pdf.  It is
+ * very similar to D1484 Revision 3 http://www.t13.org/docs2002/d1484r3.pdf
+ *
+ * In a nutshell, arch/{i386,x86_64}/boot/setup.S populates a scratch
+ * table in the boot_params that contains a list of BIOS-enumerated
+ * boot devices.
+ * In arch/{i386,x86_64}/kernel/setup.c, this information is
+ * transferred into the edd structure, and in drivers/firmware/edd.c, that
+ * information is used to identify BIOS boot disk.  The code in setup.S
+ * is very sensitive to the size of these structures.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License v2.0 as published by
+ * the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#ifndef _LINUX_EDD_H
+#define _LINUX_EDD_H
+
+#define EDDNR 0x1e9             /* addr of number of edd_info structs at EDDBUF
+                                   in boot_params - treat this as 1 byte  */
+#define EDDBUF  0x600           /* addr of edd_info structs in boot_params */
+#define EDDMAXNR 6              /* number of edd_info structs starting at EDDBUF  */
+#define EDDEXTSIZE 8            /* change these if you muck with the structures */
+#define EDDPARMSIZE 74
+#define CHECKEXTENSIONSPRESENT 0x41
+#define GETDEVICEPARAMETERS 0x48
+#define LEGACYGETDEVICEPARAMETERS 0x08
+#define EDDMAGIC1 0x55AA
+#define EDDMAGIC2 0xAA55
+
+
+#define READ_SECTORS 0x02         /* int13 AH=0x02 is READ_SECTORS command */
+#define EDD_MBR_SIG_OFFSET 0x1B8  /* offset of signature in the MBR */
+#define EDD_MBR_SIG_BUF    0x290  /* addr in boot params */
+#define EDD_MBR_SIG_MAX 16        /* max number of signatures to store */
+#define EDD_MBR_SIG_NR_BUF 0x1ea  /* addr of number of MBR signtaures at EDD_MBR_SIG_BUF
+                                     in boot_params - treat this as 1 byte  */
+#define EDD_CL_EQUALS   0x3d646465     /* "edd=" */
+#define EDD_CL_OFF      0x666f         /* "of" for off  */
+#define EDD_CL_SKIP     0x6b73         /* "sk" for skipmbr */
+
+#ifndef __ASSEMBLY__
+
+#define EDD_EXT_FIXED_DISK_ACCESS           (1 << 0)
+#define EDD_EXT_DEVICE_LOCKING_AND_EJECTING (1 << 1)
+#define EDD_EXT_ENHANCED_DISK_DRIVE_SUPPORT (1 << 2)
+#define EDD_EXT_64BIT_EXTENSIONS            (1 << 3)
+
+#define EDD_INFO_DMA_BOUNDARY_ERROR_TRANSPARENT (1 << 0)
+#define EDD_INFO_GEOMETRY_VALID                (1 << 1)
+#define EDD_INFO_REMOVABLE                     (1 << 2)
+#define EDD_INFO_WRITE_VERIFY                  (1 << 3)
+#define EDD_INFO_MEDIA_CHANGE_NOTIFICATION     (1 << 4)
+#define EDD_INFO_LOCKABLE                      (1 << 5)
+#define EDD_INFO_NO_MEDIA_PRESENT              (1 << 6)
+#define EDD_INFO_USE_INT13_FN50                (1 << 7)
+
+struct edd_device_params {
+        u16 length;
+        u16 info_flags;
+        u32 num_default_cylinders;
+        u32 num_default_heads;
+        u32 sectors_per_track;
+        u64 number_of_sectors;
+        u16 bytes_per_sector;
+        u32 dpte_ptr;           /* 0xFFFFFFFF for our purposes */
+        u16 key;                /* = 0xBEDD */
+        u8 device_path_info_length;     /* = 44 */
+        u8 reserved2;
+        u16 reserved3;
+        u8 host_bus_type[4];
+        u8 interface_type[8];
+        union {
+                struct {
+                        u16 base_address;
+                        u16 reserved1;
+                        u32 reserved2;
+                } __attribute__ ((packed)) isa;
+                struct {
+                        u8 bus;
+                        u8 slot;
+                        u8 function;
+                        u8 channel;
+                        u32 reserved;
+                } __attribute__ ((packed)) pci;
+                /* pcix is same as pci */
+                struct {
+                        u64 reserved;
+                } __attribute__ ((packed)) ibnd;
+                struct {
+                        u64 reserved;
+                } __attribute__ ((packed)) xprs;
+                struct {
+                        u64 reserved;
+                } __attribute__ ((packed)) htpt;
+                struct {
+                        u64 reserved;
+                } __attribute__ ((packed)) unknown;
+        } interface_path;
+        union {
+                struct {
+                        u8 device;
+                        u8 reserved1;
+                        u16 reserved2;
+                        u32 reserved3;
+                        u64 reserved4;
+                } __attribute__ ((packed)) ata;
+                struct {
+                        u8 device;
+                        u8 lun;
+                        u8 reserved1;
+                        u8 reserved2;
+                        u32 reserved3;
+                        u64 reserved4;
+                } __attribute__ ((packed)) atapi;
+                struct {
+                        u16 id;
+                        u64 lun;
+                        u16 reserved1;
+                        u32 reserved2;
+                } __attribute__ ((packed)) scsi;
+                struct {
+                        u64 serial_number;
+                        u64 reserved;
+                } __attribute__ ((packed)) usb;
+                struct {
+                        u64 eui;
+                        u64 reserved;
+                } __attribute__ ((packed)) i1394;
+                struct {
+                        u64 wwid;
+                        u64 lun;
+                } __attribute__ ((packed)) fibre;
+                struct {
+                        u64 identity_tag;
+                        u64 reserved;
+                } __attribute__ ((packed)) i2o;
+                struct {
+                        u32 array_number;
+                        u32 reserved1;
+                        u64 reserved2;
+                } __attribute__ ((packed)) raid;
+                struct {
+                        u8 device;
+                        u8 reserved1;
+                        u16 reserved2;
+                        u32 reserved3;
+                        u64 reserved4;
+                } __attribute__ ((packed)) sata;
+                struct {
+                        u64 reserved1;
+                        u64 reserved2;
+                } __attribute__ ((packed)) unknown;
+        } device_path;
+        u8 reserved4;
+        u8 checksum;
+} __attribute__ ((packed));
+
+struct edd_info {
+        u8 device;
+        u8 version;
+        u16 interface_support;
+        u16 legacy_max_cylinder;
+        u8 legacy_max_head;
+        u8 legacy_sectors_per_track;
+        struct edd_device_params params;
+} __attribute__ ((packed));
+
+struct edd {
+        unsigned int mbr_signature[EDD_MBR_SIG_MAX];
+        struct edd_info edd_info[EDDMAXNR];
+        unsigned char mbr_signature_nr;
+        unsigned char edd_info_nr;
+};
+
+extern struct edd edd;
+
+#endif                          /*!__ASSEMBLY__ */
+
+#endif                          /* _LINUX_EDD_H */
diff --git a/include/linux/eeprom.h b/include/linux/eeprom.h
new file mode 100644
index 000000000000..38afd9da1dfe
--- /dev/null
+++ b/include/linux/eeprom.h
@@ -0,0 +1,136 @@
+/* credit winbond-840.c
+ */
+#include <asm/io.h>
+struct eeprom_ops {
+        void    (*set_cs)(void *ee);
+        void    (*clear_cs)(void *ee);
+};
+
+#define EEPOL_EEDI      0x01
+#define EEPOL_EEDO      0x02
+#define EEPOL_EECLK     0x04
+#define EEPOL_EESEL     0x08
+
+struct eeprom {
+        void *dev;
+        struct eeprom_ops *ops;
+
+        void __iomem *  addr;
+
+        unsigned        ee_addr_bits;
+
+        unsigned        eesel;
+        unsigned        eeclk;
+        unsigned        eedo;
+        unsigned        eedi;
+        unsigned        polarity;
+        unsigned        ee_state;
+
+        spinlock_t      *lock;
+        u32             *cache;
+};
+
+
+u8   eeprom_readb(struct eeprom *ee, unsigned address);
+void eeprom_read(struct eeprom *ee, unsigned address, u8 *bytes,
+                unsigned count);
+void eeprom_writeb(struct eeprom *ee, unsigned address, u8 data);
+void eeprom_write(struct eeprom *ee, unsigned address, u8 *bytes,
+                unsigned count);
+
+/* The EEPROM commands include the alway-set leading bit. */
+enum EEPROM_Cmds {
+        EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
+};
+
+void setup_ee_mem_bitbanger(struct eeprom *ee, void __iomem *memaddr, int eesel_bit, int eeclk_bit, int eedo_bit, int eedi_bit, unsigned polarity)
+{
+        ee->addr = memaddr;
+        ee->eesel = 1 << eesel_bit;
+        ee->eeclk = 1 << eeclk_bit;
+        ee->eedo = 1 << eedo_bit;
+        ee->eedi = 1 << eedi_bit;
+
+        ee->polarity = polarity;
+
+        *ee->cache = readl(ee->addr);
+}
+
+/* foo. put this in a .c file */
+static inline void eeprom_update(struct eeprom *ee, u32 mask, int pol)
+{
+        unsigned long flags;
+        u32 data;
+
+        spin_lock_irqsave(ee->lock, flags);
+        data = *ee->cache;
+
+        data &= ~mask;
+        if (pol)
+                data |= mask;
+
+        *ee->cache = data;
+//printk("update: %08x\n", data);
+        writel(data, ee->addr);
+        spin_unlock_irqrestore(ee->lock, flags);
+}
+
+void eeprom_clk_lo(struct eeprom *ee)
+{
+        int pol = !!(ee->polarity & EEPOL_EECLK);
+
+        eeprom_update(ee, ee->eeclk, pol);
+        udelay(2);
+}
+
+void eeprom_clk_hi(struct eeprom *ee)
+{
+        int pol = !!(ee->polarity & EEPOL_EECLK);
+
+        eeprom_update(ee, ee->eeclk, !pol);
+        udelay(2);
+}
+
+void eeprom_send_addr(struct eeprom *ee, unsigned address)
+{
+        int pol = !!(ee->polarity & EEPOL_EEDI);
+        unsigned i;
+        address |= 6 << 6;
+
+        /* Shift the read command bits out. */
+        for (i=0; i<11; i++) {
+                eeprom_update(ee, ee->eedi, ((address >> 10) & 1) ^ pol);
+                address <<= 1;
+                eeprom_clk_hi(ee);
+                eeprom_clk_lo(ee);
+        }
+        eeprom_update(ee, ee->eedi, pol);
+}
+
+u16   eeprom_readw(struct eeprom *ee, unsigned address)
+{
+        unsigned i;
+        u16     res = 0;
+
+        eeprom_clk_lo(ee);
+        eeprom_update(ee, ee->eesel, 1 ^ !!(ee->polarity & EEPOL_EESEL));
+        eeprom_send_addr(ee, address);
+
+        for (i=0; i<16; i++) {
+                u32 data;
+                eeprom_clk_hi(ee);
+                res <<= 1;
+                data = readl(ee->addr);
+//printk("eeprom_readw: %08x\n", data);
+                res |= !!(data & ee->eedo) ^ !!(ee->polarity & EEPOL_EEDO);
+                eeprom_clk_lo(ee);
+        }
+        eeprom_update(ee, ee->eesel, 0 ^ !!(ee->polarity & EEPOL_EESEL));
+
+        return res;
+}
+
+
+void eeprom_writeb(struct eeprom *ee, unsigned address, u8 data)
+{
+}
diff --git a/include/linux/efi.h b/include/linux/efi.h
new file mode 100644
index 000000000000..047e7222df7a
--- /dev/null
+++ b/include/linux/efi.h
@@ -0,0 +1,398 @@
+#ifndef _LINUX_EFI_H
+#define _LINUX_EFI_H
+
+/*
+ * Extensible Firmware Interface
+ * Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999
+ *
+ * Copyright (C) 1999 VA Linux Systems
+ * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
+ * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
+ *      David Mosberger-Tang <davidm@hpl.hp.com>
+ *      Stephane Eranian <eranian@hpl.hp.com>
+ */
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/time.h>
+#include <linux/types.h>
+#include <linux/proc_fs.h>
+#include <linux/rtc.h>
+#include <linux/ioport.h>
+
+#include <asm/page.h>
+#include <asm/system.h>
+
+#define EFI_SUCCESS             0
+#define EFI_LOAD_ERROR          ( 1 | (1UL << (BITS_PER_LONG-1)))
+#define EFI_INVALID_PARAMETER   ( 2 | (1UL << (BITS_PER_LONG-1)))
+#define EFI_UNSUPPORTED         ( 3 | (1UL << (BITS_PER_LONG-1)))
+#define EFI_BAD_BUFFER_SIZE     ( 4 | (1UL << (BITS_PER_LONG-1)))
+#define EFI_BUFFER_TOO_SMALL    ( 5 | (1UL << (BITS_PER_LONG-1)))
+#define EFI_NOT_FOUND           (14 | (1UL << (BITS_PER_LONG-1)))
+
+typedef unsigned long efi_status_t;
+typedef u8 efi_bool_t;
+typedef u16 efi_char16_t;               /* UNICODE character */
+
+
+typedef struct {
+        u8 b[16];
+} efi_guid_t;
+
+#define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
+((efi_guid_t) \
+{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
+  (b) & 0xff, ((b) >> 8) & 0xff, \
+  (c) & 0xff, ((c) >> 8) & 0xff, \
+  (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
+
+/*
+ * Generic EFI table header
+ */
+typedef struct {
+        u64 signature;
+        u32 revision;
+        u32 headersize;
+        u32 crc32;
+        u32 reserved;
+} efi_table_hdr_t;
+
+/*
+ * Memory map descriptor:
+ */
+
+/* Memory types: */
+#define EFI_RESERVED_TYPE                0
+#define EFI_LOADER_CODE                  1
+#define EFI_LOADER_DATA                  2
+#define EFI_BOOT_SERVICES_CODE           3
+#define EFI_BOOT_SERVICES_DATA           4
+#define EFI_RUNTIME_SERVICES_CODE        5
+#define EFI_RUNTIME_SERVICES_DATA        6
+#define EFI_CONVENTIONAL_MEMORY          7
+#define EFI_UNUSABLE_MEMORY              8
+#define EFI_ACPI_RECLAIM_MEMORY          9
+#define EFI_ACPI_MEMORY_NVS             10
+#define EFI_MEMORY_MAPPED_IO            11
+#define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
+#define EFI_PAL_CODE                    13
+#define EFI_MAX_MEMORY_TYPE             14
+
+/* Attribute values: */
+#define EFI_MEMORY_UC           ((u64)0x0000000000000001ULL)    /* uncached */
+#define EFI_MEMORY_WC           ((u64)0x0000000000000002ULL)    /* write-coalescing */
+#define EFI_MEMORY_WT           ((u64)0x0000000000000004ULL)    /* write-through */
+#define EFI_MEMORY_WB           ((u64)0x0000000000000008ULL)    /* write-back */
+#define EFI_MEMORY_WP           ((u64)0x0000000000001000ULL)    /* write-protect */
+#define EFI_MEMORY_RP           ((u64)0x0000000000002000ULL)    /* read-protect */
+#define EFI_MEMORY_XP           ((u64)0x0000000000004000ULL)    /* execute-protect */
+#define EFI_MEMORY_RUNTIME      ((u64)0x8000000000000000ULL)    /* range requires runtime mapping */
+#define EFI_MEMORY_DESCRIPTOR_VERSION   1
+
+#define EFI_PAGE_SHIFT          12
+
+/*
+ * For current x86 implementations of EFI, there is
+ * additional padding in the mem descriptors.  This is not
+ * the case in ia64.  Need to have this fixed in the f/w.
+ */
+typedef struct {
+        u32 type;
+        u32 pad;
+        u64 phys_addr;
+        u64 virt_addr;
+        u64 num_pages;
+        u64 attribute;
+#if defined (__i386__)
+        u64 pad1;
+#endif
+} efi_memory_desc_t;
+
+typedef int (*efi_freemem_callback_t) (unsigned long start, unsigned long end, void *arg);
+
+/*
+ * Types and defines for Time Services
+ */
+#define EFI_TIME_ADJUST_DAYLIGHT 0x1
+#define EFI_TIME_IN_DAYLIGHT     0x2
+#define EFI_UNSPECIFIED_TIMEZONE 0x07ff
+
+typedef struct {
+        u16 year;
+        u8 month;
+        u8 day;
+        u8 hour;
+        u8 minute;
+        u8 second;
+        u8 pad1;
+        u32 nanosecond;
+        s16 timezone;
+        u8 daylight;
+        u8 pad2;
+} efi_time_t;
+
+typedef struct {
+        u32 resolution;
+        u32 accuracy;
+        u8 sets_to_zero;
+} efi_time_cap_t;
+
+/*
+ * Types and defines for EFI ResetSystem
+ */
+#define EFI_RESET_COLD 0
+#define EFI_RESET_WARM 1
+#define EFI_RESET_SHUTDOWN 2
+
+/*
+ * EFI Runtime Services table
+ */
+#define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)
+#define EFI_RUNTIME_SERVICES_REVISION  0x00010000
+
+typedef struct {
+        efi_table_hdr_t hdr;
+        unsigned long get_time;
+        unsigned long set_time;
+        unsigned long get_wakeup_time;
+        unsigned long set_wakeup_time;
+        unsigned long set_virtual_address_map;
+        unsigned long convert_pointer;
+        unsigned long get_variable;
+        unsigned long get_next_variable;
+        unsigned long set_variable;
+        unsigned long get_next_high_mono_count;
+        unsigned long reset_system;
+} efi_runtime_services_t;
+
+typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
+typedef efi_status_t efi_set_time_t (efi_time_t *tm);
+typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
+                                            efi_time_t *tm);
+typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
+typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
+                                         unsigned long *data_size, void *data);
+typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
+                                              efi_guid_t *vendor);
+typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 
+                                         unsigned long attr, unsigned long data_size, 
+                                         void *data);
+typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
+typedef void efi_reset_system_t (int reset_type, efi_status_t status,
+                                 unsigned long data_size, efi_char16_t *data);
+typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
+                                                unsigned long descriptor_size,
+                                                u32 descriptor_version,
+                                                efi_memory_desc_t *virtual_map);
+
+/*
+ *  EFI Configuration Table and GUID definitions
+ */
+#define NULL_GUID \
+    EFI_GUID(  0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 )
+
+#define MPS_TABLE_GUID    \
+    EFI_GUID(  0xeb9d2d2f, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
+
+#define ACPI_TABLE_GUID    \
+    EFI_GUID(  0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
+
+#define ACPI_20_TABLE_GUID    \
+    EFI_GUID(  0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 )
+
+#define SMBIOS_TABLE_GUID    \
+    EFI_GUID(  0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
+
+#define SAL_SYSTEM_TABLE_GUID    \
+    EFI_GUID(  0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
+
+#define HCDP_TABLE_GUID \
+    EFI_GUID(  0xf951938d, 0x620b, 0x42ef, 0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98 )
+
+#define UGA_IO_PROTOCOL_GUID \
+    EFI_GUID(  0x61a4d49e, 0x6f68, 0x4f1b, 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0xb, 0x7, 0xa2 )
+
+#define EFI_GLOBAL_VARIABLE_GUID \
+    EFI_GUID(  0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c )
+
+typedef struct {
+        efi_guid_t guid;
+        unsigned long table;
+} efi_config_table_t;
+
+#define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
+#define EFI_SYSTEM_TABLE_REVISION  ((1 << 16) | 00)
+
+typedef struct {
+        efi_table_hdr_t hdr;
+        unsigned long fw_vendor;        /* physical addr of CHAR16 vendor string */
+        u32 fw_revision;
+        unsigned long con_in_handle;
+        unsigned long con_in;
+        unsigned long con_out_handle;
+        unsigned long con_out;
+        unsigned long stderr_handle;
+        unsigned long stderr;
+        efi_runtime_services_t *runtime;
+        unsigned long boottime;
+        unsigned long nr_tables;
+        unsigned long tables;
+} efi_system_table_t;
+
+struct efi_memory_map {
+        efi_memory_desc_t *phys_map;
+        efi_memory_desc_t *map;
+        int nr_map;
+        unsigned long desc_version;
+};
+
+/*
+ * All runtime access to EFI goes through this structure:
+ */
+extern struct efi {
+        efi_system_table_t *systab;     /* EFI system table */
+        void *mps;                      /* MPS table */
+        void *acpi;                     /* ACPI table  (IA64 ext 0.71) */
+        void *acpi20;                   /* ACPI table  (ACPI 2.0) */
+        void *smbios;                   /* SM BIOS table */
+        void *sal_systab;               /* SAL system table */
+        void *boot_info;                /* boot info table */
+        void *hcdp;                     /* HCDP table */
+        void *uga;                      /* UGA table */
+        efi_get_time_t *get_time;
+        efi_set_time_t *set_time;
+        efi_get_wakeup_time_t *get_wakeup_time;
+        efi_set_wakeup_time_t *set_wakeup_time;
+        efi_get_variable_t *get_variable;
+        efi_get_next_variable_t *get_next_variable;
+        efi_set_variable_t *set_variable;
+        efi_get_next_high_mono_count_t *get_next_high_mono_count;
+        efi_reset_system_t *reset_system;
+        efi_set_virtual_address_map_t *set_virtual_address_map;
+} efi;
+
+static inline int
+efi_guidcmp (efi_guid_t left, efi_guid_t right)
+{
+        return memcmp(&left, &right, sizeof (efi_guid_t));
+}
+
+static inline char *
+efi_guid_unparse(efi_guid_t *guid, char *out)
+{
+        sprintf(out, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                guid->b[3], guid->b[2], guid->b[1], guid->b[0],
+                guid->b[5], guid->b[4], guid->b[7], guid->b[6],
+                guid->b[8], guid->b[9], guid->b[10], guid->b[11],
+                guid->b[12], guid->b[13], guid->b[14], guid->b[15]);
+        return out;
+}
+
+extern void efi_init (void);
+extern void *efi_get_pal_addr (void);
+extern void efi_map_pal_code (void);
+extern void efi_map_memmap(void);
+extern void efi_memmap_walk (efi_freemem_callback_t callback, void *arg);
+extern void efi_gettimeofday (struct timespec *ts);
+extern void efi_enter_virtual_mode (void);      /* switch EFI to virtual mode, if possible */
+extern u64 efi_get_iobase (void);
+extern u32 efi_mem_type (unsigned long phys_addr);
+extern u64 efi_mem_attributes (unsigned long phys_addr);
+extern int __init efi_uart_console_only (void);
+extern void efi_initialize_iomem_resources(struct resource *code_resource,
+                                        struct resource *data_resource);
+extern unsigned long __init efi_get_time(void);
+extern int __init efi_set_rtc_mmss(unsigned long nowtime);
+extern struct efi_memory_map memmap;
+
+/**
+ * efi_range_is_wc - check the WC bit on an address range
+ * @start: starting kvirt address
+ * @len: length of range
+ *
+ * Consult the EFI memory map and make sure it's ok to set this range WC.
+ * Returns true or false.
+ */
+static inline int efi_range_is_wc(unsigned long start, unsigned long len)
+{
+        int i;
+
+        for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
+                unsigned long paddr = __pa(start + i);
+                if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))
+                        return 0;
+        }
+        /* The range checked out */
+        return 1;
+}
+
+#ifdef CONFIG_EFI_PCDP
+extern int __init efi_setup_pcdp_console(char *);
+#endif
+
+/*
+ * We play games with efi_enabled so that the compiler will, if possible, remove
+ * EFI-related code altogether.
+ */
+#ifdef CONFIG_EFI
+# ifdef CONFIG_X86
+   extern int efi_enabled;
+# else
+#  define efi_enabled 1
+# endif
+#else
+# define efi_enabled 0
+#endif
+
+/*
+ * Variable Attributes
+ */
+#define EFI_VARIABLE_NON_VOLATILE       0x0000000000000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002
+#define EFI_VARIABLE_RUNTIME_ACCESS     0x0000000000000004
+
+/*
+ * EFI Device Path information
+ */
+#define EFI_DEV_HW                      0x01
+#define  EFI_DEV_PCI                             1
+#define  EFI_DEV_PCCARD                          2
+#define  EFI_DEV_MEM_MAPPED                      3
+#define  EFI_DEV_VENDOR                          4
+#define  EFI_DEV_CONTROLLER                      5
+#define EFI_DEV_ACPI                    0x02
+#define   EFI_DEV_BASIC_ACPI                     1
+#define   EFI_DEV_EXPANDED_ACPI                  2
+#define EFI_DEV_MSG                     0x03
+#define   EFI_DEV_MSG_ATAPI                      1
+#define   EFI_DEV_MSG_SCSI                       2
+#define   EFI_DEV_MSG_FC                         3
+#define   EFI_DEV_MSG_1394                       4
+#define   EFI_DEV_MSG_USB                        5
+#define   EFI_DEV_MSG_USB_CLASS                 15
+#define   EFI_DEV_MSG_I20                        6
+#define   EFI_DEV_MSG_MAC                       11
+#define   EFI_DEV_MSG_IPV4                      12
+#define   EFI_DEV_MSG_IPV6                      13
+#define   EFI_DEV_MSG_INFINIBAND                 9
+#define   EFI_DEV_MSG_UART                      14
+#define   EFI_DEV_MSG_VENDOR                    10
+#define EFI_DEV_MEDIA                   0x04
+#define   EFI_DEV_MEDIA_HARD_DRIVE               1
+#define   EFI_DEV_MEDIA_CDROM                    2
+#define   EFI_DEV_MEDIA_VENDOR                   3
+#define   EFI_DEV_MEDIA_FILE                     4
+#define   EFI_DEV_MEDIA_PROTOCOL                 5
+#define EFI_DEV_BIOS_BOOT               0x05
+#define EFI_DEV_END_PATH                0x7F
+#define EFI_DEV_END_PATH2               0xFF
+#define   EFI_DEV_END_INSTANCE                  0x01
+#define   EFI_DEV_END_ENTIRE                    0xFF
+
+struct efi_generic_dev_path {
+        u8 type;
+        u8 sub_type;
+        u16 length;
+} __attribute ((packed));
+
+#endif /* _LINUX_EFI_H */
diff --git a/include/linux/efs_dir.h b/include/linux/efs_dir.h
new file mode 100644
index 000000000000..a09ec010569c
--- /dev/null
+++ b/include/linux/efs_dir.h
@@ -0,0 +1,42 @@
+/*
+ * efs_dir.h
+ *
+ * Copyright (c) 1999 Al Smith
+ */
+
+#ifndef __EFS_DIR_H__
+#define __EFS_DIR_H__
+
+#define EFS_DIRBSIZE_BITS       EFS_BLOCKSIZE_BITS
+#define EFS_DIRBSIZE            (1 << EFS_DIRBSIZE_BITS)
+
+struct efs_dentry {
+        __be32          inode;
+        unsigned char   namelen;
+        char            name[3];
+};
+
+#define EFS_DENTSIZE    (sizeof(struct efs_dentry) - 3 + 1)
+#define EFS_MAXNAMELEN  ((1 << (sizeof(char) * 8)) - 1)
+
+#define EFS_DIRBLK_HEADERSIZE   4
+#define EFS_DIRBLK_MAGIC        0xbeef  /* moo */
+
+struct efs_dir {
+        __be16  magic;
+        unsigned char   firstused;
+        unsigned char   slots;
+
+        unsigned char   space[EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE];
+};
+
+#define EFS_MAXENTS \
+        ((EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE) / \
+         (EFS_DENTSIZE + sizeof(char)))
+
+#define EFS_SLOTAT(dir, slot) EFS_REALOFF((dir)->space[slot])
+
+#define EFS_REALOFF(offset) ((offset << 1))
+
+#endif /* __EFS_DIR_H__ */
+
diff --git a/include/linux/efs_fs.h b/include/linux/efs_fs.h
new file mode 100644
index 000000000000..28f368c526fb
--- /dev/null
+++ b/include/linux/efs_fs.h
@@ -0,0 +1,51 @@
+/*
+ * efs_fs.h
+ *
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from work (c) 1995,1996 Christian Vogelgsang.
+ */
+
+#ifndef __EFS_FS_H__
+#define __EFS_FS_H__
+
+#define EFS_VERSION "1.0a"
+
+static const char cprt[] = "EFS: "EFS_VERSION" - (c) 1999 Al Smith <Al.Smith@aeschi.ch.eu.org>";
+
+#include <asm/uaccess.h>
+
+/* 1 block is 512 bytes */
+#define EFS_BLOCKSIZE_BITS      9
+#define EFS_BLOCKSIZE           (1 << EFS_BLOCKSIZE_BITS)
+
+#include <linux/fs.h>
+#include <linux/efs_fs_i.h>
+#include <linux/efs_fs_sb.h>
+#include <linux/efs_dir.h>
+
+static inline struct efs_inode_info *INODE_INFO(struct inode *inode)
+{
+        return container_of(inode, struct efs_inode_info, vfs_inode);
+}
+
+static inline struct efs_sb_info *SUPER_INFO(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+struct statfs;
+
+extern struct inode_operations efs_dir_inode_operations;
+extern struct file_operations efs_dir_operations;
+extern struct address_space_operations efs_symlink_aops;
+
+extern void efs_read_inode(struct inode *);
+extern efs_block_t efs_map_block(struct inode *, efs_block_t);
+extern int efs_get_block(struct inode *, sector_t, struct buffer_head *, int);
+
+extern struct dentry *efs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *efs_get_parent(struct dentry *);
+extern int efs_bmap(struct inode *, int);
+
+#endif /* __EFS_FS_H__ */
diff --git a/include/linux/efs_fs_i.h b/include/linux/efs_fs_i.h
new file mode 100644
index 000000000000..617c474ca659
--- /dev/null
+++ b/include/linux/efs_fs_i.h
@@ -0,0 +1,68 @@
+/*
+ * efs_fs_i.h
+ *
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from IRIX header files (c) 1988 Silicon Graphics
+ */
+
+#ifndef __EFS_FS_I_H__
+#define __EFS_FS_I_H__
+
+typedef int32_t         efs_block_t;
+typedef uint32_t        efs_ino_t;
+
+#define EFS_DIRECTEXTENTS       12
+
+/*
+ * layout of an extent, in memory and on disk. 8 bytes exactly.
+ */
+typedef union extent_u {
+        unsigned char raw[8];
+        struct extent_s {
+                unsigned int    ex_magic:8;     /* magic # (zero) */
+                unsigned int    ex_bn:24;       /* basic block */
+                unsigned int    ex_length:8;    /* numblocks in this extent */
+                unsigned int    ex_offset:24;   /* logical offset into file */
+        } cooked;
+} efs_extent;
+
+typedef struct edevs {
+        __be16          odev;
+        __be32          ndev;
+} efs_devs;
+
+/*
+ * extent based filesystem inode as it appears on disk.  The efs inode
+ * is exactly 128 bytes long.
+ */
+struct  efs_dinode {
+        __be16          di_mode;        /* mode and type of file */
+        __be16          di_nlink;       /* number of links to file */
+        __be16          di_uid;         /* owner's user id */
+        __be16          di_gid;         /* owner's group id */
+        __be32          di_size;        /* number of bytes in file */
+        __be32          di_atime;       /* time last accessed */
+        __be32          di_mtime;       /* time last modified */
+        __be32          di_ctime;       /* time created */
+        __be32          di_gen;         /* generation number */
+        __be16          di_numextents;  /* # of extents */
+        u_char          di_version;     /* version of inode */
+        u_char          di_spare;       /* spare - used by AFS */
+        union di_addr {
+                efs_extent      di_extents[EFS_DIRECTEXTENTS];
+                efs_devs        di_dev; /* device for IFCHR/IFBLK */
+        } di_u;
+};
+
+/* efs inode storage in memory */
+struct efs_inode_info {
+        int             numextents;
+        int             lastextent;
+
+        efs_extent      extents[EFS_DIRECTEXTENTS];
+        struct inode    vfs_inode;
+};
+
+#endif  /* __EFS_FS_I_H__ */
+
diff --git a/include/linux/efs_fs_sb.h b/include/linux/efs_fs_sb.h
new file mode 100644
index 000000000000..c76088baef28
--- /dev/null
+++ b/include/linux/efs_fs_sb.h
@@ -0,0 +1,62 @@
+/*
+ * efs_fs_sb.h
+ *
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from IRIX header files (c) 1988 Silicon Graphics
+ */
+
+#ifndef __EFS_FS_SB_H__
+#define __EFS_FS_SB_H__
+
+/* statfs() magic number for EFS */
+#define EFS_SUPER_MAGIC 0x414A53
+
+/* EFS superblock magic numbers */
+#define EFS_MAGIC       0x072959
+#define EFS_NEWMAGIC    0x07295a
+
+#define IS_EFS_MAGIC(x) ((x == EFS_MAGIC) || (x == EFS_NEWMAGIC))
+
+#define EFS_SUPER               1
+#define EFS_ROOTINODE           2
+
+/* efs superblock on disk */
+struct efs_super {
+        __be32          fs_size;        /* size of filesystem, in sectors */
+        __be32          fs_firstcg;     /* bb offset to first cg */
+        __be32          fs_cgfsize;     /* size of cylinder group in bb's */
+        __be16          fs_cgisize;     /* bb's of inodes per cylinder group */
+        __be16          fs_sectors;     /* sectors per track */
+        __be16          fs_heads;       /* heads per cylinder */
+        __be16          fs_ncg;         /* # of cylinder groups in filesystem */
+        __be16          fs_dirty;       /* fs needs to be fsck'd */
+        __be32          fs_time;        /* last super-block update */
+        __be32          fs_magic;       /* magic number */
+        char            fs_fname[6];    /* file system name */
+        char            fs_fpack[6];    /* file system pack name */
+        __be32          fs_bmsize;      /* size of bitmap in bytes */
+        __be32          fs_tfree;       /* total free data blocks */
+        __be32          fs_tinode;      /* total free inodes */
+        __be32          fs_bmblock;     /* bitmap location. */
+        __be32          fs_replsb;      /* Location of replicated superblock. */
+        __be32          fs_lastialloc;  /* last allocated inode */
+        char            fs_spare[20];   /* space for expansion - MUST BE ZERO */
+        __be32          fs_checksum;    /* checksum of volume portion of fs */
+};
+
+/* efs superblock information in memory */
+struct efs_sb_info {
+        __u32   fs_magic;       /* superblock magic number */
+        __u32   fs_start;       /* first block of filesystem */
+        __u32   first_block;    /* first data block in filesystem */
+        __u32   total_blocks;   /* total number of blocks in filesystem */
+        __u32   group_size;     /* # of blocks a group consists of */ 
+        __u32   data_free;      /* # of free data blocks */
+        __u32   inode_free;     /* # of free inodes */
+        __u16   inode_blocks;   /* # of blocks used for inodes in every grp */
+        __u16   total_groups;   /* # of groups */
+};
+
+#endif /* __EFS_FS_SB_H__ */
+
diff --git a/include/linux/efs_vh.h b/include/linux/efs_vh.h
new file mode 100644
index 000000000000..8a11150c61fe
--- /dev/null
+++ b/include/linux/efs_vh.h
@@ -0,0 +1,53 @@
+/*
+ * efs_vh.h
+ *
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from IRIX header files (c) 1985 MIPS Computer Systems, Inc.
+ */
+
+#ifndef __EFS_VH_H__
+#define __EFS_VH_H__
+
+#define VHMAGIC         0xbe5a941       /* volume header magic number */
+#define NPARTAB         16              /* 16 unix partitions */
+#define NVDIR           15              /* max of 15 directory entries */
+#define BFNAMESIZE      16              /* max 16 chars in boot file name */
+#define VDNAMESIZE      8
+
+struct volume_directory {
+        char    vd_name[VDNAMESIZE];    /* name */
+        __be32  vd_lbn;                 /* logical block number */
+        __be32  vd_nbytes;              /* file length in bytes */
+};
+
+struct partition_table {        /* one per logical partition */
+        __be32  pt_nblks;       /* # of logical blks in partition */
+        __be32  pt_firstlbn;    /* first lbn of partition */
+        __be32  pt_type;        /* use of partition */
+};
+
+struct volume_header {
+        __be32  vh_magic;                       /* identifies volume header */
+        __be16  vh_rootpt;                      /* root partition number */
+        __be16  vh_swappt;                      /* swap partition number */
+        char    vh_bootfile[BFNAMESIZE];        /* name of file to boot */
+        char    pad[48];                        /* device param space */
+        struct volume_directory vh_vd[NVDIR];   /* other vol hdr contents */
+        struct partition_table  vh_pt[NPARTAB]; /* device partition layout */
+        __be32  vh_csum;                        /* volume header checksum */
+        __be32  vh_fill;                        /* fill out to 512 bytes */
+};
+
+/* partition type sysv is used for EFS format CD-ROM partitions */
+#define SGI_SYSV        0x05
+#define SGI_EFS         0x07
+#define IS_EFS(x)       (((x) == SGI_EFS) || ((x) == SGI_SYSV))
+
+struct pt_types {
+        int     pt_type;
+        char    *pt_name;
+};
+
+#endif /* __EFS_VH_H__ */
+
diff --git a/include/linux/eisa.h b/include/linux/eisa.h
new file mode 100644
index 000000000000..4079242dced8
--- /dev/null
+++ b/include/linux/eisa.h
@@ -0,0 +1,107 @@
+#ifndef _LINUX_EISA_H
+#define _LINUX_EISA_H
+
+#include <linux/ioport.h>
+#include <linux/device.h>
+
+#define EISA_SIG_LEN   8
+#define EISA_MAX_SLOTS 8
+
+#define EISA_MAX_RESOURCES 4
+
+/* A few EISA constants/offsets... */
+
+#define EISA_DMA1_STATUS            8
+#define EISA_INT1_CTRL           0x20
+#define EISA_INT1_MASK           0x21
+#define EISA_INT2_CTRL           0xA0
+#define EISA_INT2_MASK           0xA1
+#define EISA_DMA2_STATUS         0xD0
+#define EISA_DMA2_WRITE_SINGLE   0xD4
+#define EISA_EXT_NMI_RESET_CTRL 0x461
+#define EISA_INT1_EDGE_LEVEL    0x4D0
+#define EISA_INT2_EDGE_LEVEL    0x4D1
+#define EISA_VENDOR_ID_OFFSET   0xC80
+#define EISA_CONFIG_OFFSET      0xC84
+
+#define EISA_CONFIG_ENABLED         1
+#define EISA_CONFIG_FORCED          2
+
+/* The EISA signature, in ASCII form, null terminated */
+struct eisa_device_id {
+        char          sig[EISA_SIG_LEN];
+        unsigned long driver_data;
+};
+
+/* There is not much we can say about an EISA device, apart from
+ * signature, slot number, and base address. dma_mask is set by
+ * default to parent device mask..*/
+
+struct eisa_device {
+        struct eisa_device_id id;
+        int                   slot;
+        int                   state;
+        unsigned long         base_addr;
+        struct resource       res[EISA_MAX_RESOURCES];
+        u64                   dma_mask;
+        struct device         dev; /* generic device */
+#ifdef CONFIG_EISA_NAMES
+        char                  pretty_name[DEVICE_NAME_SIZE];
+#endif
+};
+
+#define to_eisa_device(n) container_of(n, struct eisa_device, dev)
+
+static inline int eisa_get_region_index (void *addr)
+{
+        unsigned long x = (unsigned long) addr;
+
+        x &= 0xc00;
+        return (x >> 12);
+}
+
+struct eisa_driver {
+        const struct eisa_device_id *id_table;
+        struct device_driver         driver;
+};
+
+#define to_eisa_driver(drv) container_of(drv,struct eisa_driver, driver)
+
+extern struct bus_type eisa_bus_type;
+int eisa_driver_register (struct eisa_driver *edrv);
+void eisa_driver_unregister (struct eisa_driver *edrv);
+
+/* Mimics pci.h... */
+static inline void *eisa_get_drvdata (struct eisa_device *edev)
+{
+        return edev->dev.driver_data;
+}
+
+static inline void eisa_set_drvdata (struct eisa_device *edev, void *data)
+{
+        edev->dev.driver_data = data;
+}
+
+/* The EISA root device. There's rumours about machines with multiple
+ * busses (PA-RISC ?), so we try to handle that. */
+
+struct eisa_root_device {
+        struct device   *dev;    /* Pointer to bridge device */
+        struct resource *res;
+        unsigned long    bus_base_addr;
+        int              slots;  /* Max slot number */
+        int              force_probe; /* Probe even when no slot 0 */
+        u64              dma_mask; /* from bridge device */
+        int              bus_nr; /* Set by eisa_root_register */
+        struct resource  eisa_root_res; /* ditto */
+};
+
+int eisa_root_register (struct eisa_root_device *root);
+
+#ifdef CONFIG_EISA
+extern int EISA_bus;
+#else
+# define EISA_bus 0
+#endif
+
+#endif
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
new file mode 100644
index 000000000000..ee54f81faad5
--- /dev/null
+++ b/include/linux/elevator.h
@@ -0,0 +1,145 @@
+#ifndef _LINUX_ELEVATOR_H
+#define _LINUX_ELEVATOR_H
+
+typedef int (elevator_merge_fn) (request_queue_t *, struct request **,
+                                 struct bio *);
+
+typedef void (elevator_merge_req_fn) (request_queue_t *, struct request *, struct request *);
+
+typedef void (elevator_merged_fn) (request_queue_t *, struct request *);
+
+typedef struct request *(elevator_next_req_fn) (request_queue_t *);
+
+typedef void (elevator_add_req_fn) (request_queue_t *, struct request *, int);
+typedef int (elevator_queue_empty_fn) (request_queue_t *);
+typedef void (elevator_remove_req_fn) (request_queue_t *, struct request *);
+typedef void (elevator_requeue_req_fn) (request_queue_t *, struct request *);
+typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *);
+typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *);
+typedef int (elevator_may_queue_fn) (request_queue_t *, int);
+
+typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, int);
+typedef void (elevator_put_req_fn) (request_queue_t *, struct request *);
+typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *);
+
+typedef int (elevator_init_fn) (request_queue_t *, elevator_t *);
+typedef void (elevator_exit_fn) (elevator_t *);
+
+struct elevator_ops
+{
+        elevator_merge_fn *elevator_merge_fn;
+        elevator_merged_fn *elevator_merged_fn;
+        elevator_merge_req_fn *elevator_merge_req_fn;
+
+        elevator_next_req_fn *elevator_next_req_fn;
+        elevator_add_req_fn *elevator_add_req_fn;
+        elevator_remove_req_fn *elevator_remove_req_fn;
+        elevator_requeue_req_fn *elevator_requeue_req_fn;
+        elevator_deactivate_req_fn *elevator_deactivate_req_fn;
+
+        elevator_queue_empty_fn *elevator_queue_empty_fn;
+        elevator_completed_req_fn *elevator_completed_req_fn;
+
+        elevator_request_list_fn *elevator_former_req_fn;
+        elevator_request_list_fn *elevator_latter_req_fn;
+
+        elevator_set_req_fn *elevator_set_req_fn;
+        elevator_put_req_fn *elevator_put_req_fn;
+
+        elevator_may_queue_fn *elevator_may_queue_fn;
+
+        elevator_init_fn *elevator_init_fn;
+        elevator_exit_fn *elevator_exit_fn;
+};
+
+#define ELV_NAME_MAX    (16)
+
+/*
+ * identifies an elevator type, such as AS or deadline
+ */
+struct elevator_type
+{
+        struct list_head list;
+        struct elevator_ops ops;
+        struct elevator_type *elevator_type;
+        struct kobj_type *elevator_ktype;
+        char elevator_name[ELV_NAME_MAX];
+        struct module *elevator_owner;
+};
+
+/*
+ * each queue has an elevator_queue assoicated with it
+ */
+struct elevator_queue
+{
+        struct elevator_ops *ops;
+        void *elevator_data;
+        struct kobject kobj;
+        struct elevator_type *elevator_type;
+};
+
+/*
+ * block elevator interface
+ */
+extern void elv_add_request(request_queue_t *, struct request *, int, int);
+extern void __elv_add_request(request_queue_t *, struct request *, int, int);
+extern int elv_merge(request_queue_t *, struct request **, struct bio *);
+extern void elv_merge_requests(request_queue_t *, struct request *,
+                               struct request *);
+extern void elv_merged_request(request_queue_t *, struct request *);
+extern void elv_remove_request(request_queue_t *, struct request *);
+extern void elv_requeue_request(request_queue_t *, struct request *);
+extern void elv_deactivate_request(request_queue_t *, struct request *);
+extern int elv_queue_empty(request_queue_t *);
+extern struct request *elv_next_request(struct request_queue *q);
+extern struct request *elv_former_request(request_queue_t *, struct request *);
+extern struct request *elv_latter_request(request_queue_t *, struct request *);
+extern int elv_register_queue(request_queue_t *q);
+extern void elv_unregister_queue(request_queue_t *q);
+extern int elv_may_queue(request_queue_t *, int);
+extern void elv_completed_request(request_queue_t *, struct request *);
+extern int elv_set_request(request_queue_t *, struct request *, int);
+extern void elv_put_request(request_queue_t *, struct request *);
+
+/*
+ * io scheduler registration
+ */
+extern int elv_register(struct elevator_type *);
+extern void elv_unregister(struct elevator_type *);
+
+/*
+ * io scheduler sysfs switching
+ */
+extern ssize_t elv_iosched_show(request_queue_t *, char *);
+extern ssize_t elv_iosched_store(request_queue_t *, const char *, size_t);
+
+extern int elevator_init(request_queue_t *, char *);
+extern void elevator_exit(elevator_t *);
+extern int elv_rq_merge_ok(struct request *, struct bio *);
+extern int elv_try_merge(struct request *, struct bio *);
+extern int elv_try_last_merge(request_queue_t *, struct bio *);
+
+/*
+ * Return values from elevator merger
+ */
+#define ELEVATOR_NO_MERGE       0
+#define ELEVATOR_FRONT_MERGE    1
+#define ELEVATOR_BACK_MERGE     2
+
+/*
+ * Insertion selection
+ */
+#define ELEVATOR_INSERT_FRONT   1
+#define ELEVATOR_INSERT_BACK    2
+#define ELEVATOR_INSERT_SORT    3
+
+/*
+ * return values from elevator_may_queue_fn
+ */
+enum {
+        ELV_MQUEUE_MAY,
+        ELV_MQUEUE_NO,
+        ELV_MQUEUE_MUST,
+};
+
+#endif
diff --git a/include/linux/elf-fdpic.h b/include/linux/elf-fdpic.h
new file mode 100644
index 000000000000..9f5b7456bff3
--- /dev/null
+++ b/include/linux/elf-fdpic.h
@@ -0,0 +1,68 @@
+/* elf-fdpic.h: FDPIC ELF load map
+ *
+ * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_ELF_FDPIC_H
+#define _LINUX_ELF_FDPIC_H
+
+#include <linux/elf.h>
+
+#define PT_GNU_STACK    (PT_LOOS + 0x474e551)
+
+/* segment mappings for ELF FDPIC libraries/executables/interpreters */
+struct elf32_fdpic_loadseg {
+        Elf32_Addr      addr;           /* core address to which mapped */
+        Elf32_Addr      p_vaddr;        /* VMA recorded in file */
+        Elf32_Word      p_memsz;        /* allocation size recorded in file */
+};
+
+struct elf32_fdpic_loadmap {
+        Elf32_Half      version;        /* version of these structures, just in case... */
+        Elf32_Half      nsegs;          /* number of segments */
+        struct elf32_fdpic_loadseg segs[];
+};
+
+#define ELF32_FDPIC_LOADMAP_VERSION     0x0000
+
+/*
+ * binfmt binary parameters structure
+ */
+struct elf_fdpic_params {
+        struct elfhdr                   hdr;            /* ref copy of ELF header */
+        struct elf_phdr                 *phdrs;         /* ref copy of PT_PHDR table */
+        struct elf32_fdpic_loadmap      *loadmap;       /* loadmap to be passed to userspace */
+        unsigned long                   elfhdr_addr;    /* mapped ELF header user address */
+        unsigned long                   ph_addr;        /* mapped PT_PHDR user address */
+        unsigned long                   map_addr;       /* mapped loadmap user address */
+        unsigned long                   entry_addr;     /* mapped entry user address */
+        unsigned long                   stack_size;     /* stack size requested (PT_GNU_STACK) */
+        unsigned long                   dynamic_addr;   /* mapped PT_DYNAMIC user address */
+        unsigned long                   load_addr;      /* user address at which to map binary */
+        unsigned long                   flags;
+#define ELF_FDPIC_FLAG_ARRANGEMENT      0x0000000f      /* PT_LOAD arrangement flags */
+#define ELF_FDPIC_FLAG_INDEPENDENT      0x00000000      /* PT_LOADs can be put anywhere */
+#define ELF_FDPIC_FLAG_HONOURVADDR      0x00000001      /* PT_LOAD.vaddr must be honoured */
+#define ELF_FDPIC_FLAG_CONSTDISP        0x00000002      /* PT_LOADs require constant
+                                                         * displacement */
+#define ELF_FDPIC_FLAG_CONTIGUOUS       0x00000003      /* PT_LOADs should be contiguous */
+#define ELF_FDPIC_FLAG_EXEC_STACK       0x00000010      /* T if stack to be executable */
+#define ELF_FDPIC_FLAG_NOEXEC_STACK     0x00000020      /* T if stack not to be executable */
+#define ELF_FDPIC_FLAG_EXECUTABLE       0x00000040      /* T if this object is the executable */
+#define ELF_FDPIC_FLAG_PRESENT          0x80000000      /* T if this object is present */
+};
+
+#ifdef CONFIG_MMU
+extern void elf_fdpic_arch_lay_out_mm(struct elf_fdpic_params *exec_params,
+                                      struct elf_fdpic_params *interp_params,
+                                      unsigned long *start_stack,
+                                      unsigned long *start_brk);
+#endif
+
+#endif /* _LINUX_ELF_FDPIC_H */
diff --git a/include/linux/elf.h b/include/linux/elf.h
new file mode 100644
index 000000000000..f5b3ba5a317d
--- /dev/null
+++ b/include/linux/elf.h
@@ -0,0 +1,449 @@
+#ifndef _LINUX_ELF_H
+#define _LINUX_ELF_H
+
+#include <linux/types.h>
+#include <asm/elf.h>
+
+#ifndef elf_read_implies_exec
+  /* Executables for which elf_read_implies_exec() returns TRUE will
+     have the READ_IMPLIES_EXEC personality flag set automatically.
+     Override in asm/elf.h as needed.  */
+# define elf_read_implies_exec(ex, have_pt_gnu_stack)   0
+#endif
+
+/* 32-bit ELF base types. */
+typedef __u32   Elf32_Addr;
+typedef __u16   Elf32_Half;
+typedef __u32   Elf32_Off;
+typedef __s32   Elf32_Sword;
+typedef __u32   Elf32_Word;
+
+/* 64-bit ELF base types. */
+typedef __u64   Elf64_Addr;
+typedef __u16   Elf64_Half;
+typedef __s16   Elf64_SHalf;
+typedef __u64   Elf64_Off;
+typedef __s32   Elf64_Sword;
+typedef __u32   Elf64_Word;
+typedef __u64   Elf64_Xword;
+typedef __s64   Elf64_Sxword;
+
+/* These constants are for the segment types stored in the image headers */
+#define PT_NULL    0
+#define PT_LOAD    1
+#define PT_DYNAMIC 2
+#define PT_INTERP  3
+#define PT_NOTE    4
+#define PT_SHLIB   5
+#define PT_PHDR    6
+#define PT_TLS     7               /* Thread local storage segment */
+#define PT_LOOS    0x60000000      /* OS-specific */
+#define PT_HIOS    0x6fffffff      /* OS-specific */
+#define PT_LOPROC  0x70000000
+#define PT_HIPROC  0x7fffffff
+#define PT_GNU_EH_FRAME         0x6474e550
+
+#define PT_GNU_STACK    (PT_LOOS + 0x474e551)
+
+/* These constants define the different elf file types */
+#define ET_NONE   0
+#define ET_REL    1
+#define ET_EXEC   2
+#define ET_DYN    3
+#define ET_CORE   4
+#define ET_LOPROC 0xff00
+#define ET_HIPROC 0xffff
+
+/* These constants define the various ELF target machines */
+#define EM_NONE  0
+#define EM_M32   1
+#define EM_SPARC 2
+#define EM_386   3
+#define EM_68K   4
+#define EM_88K   5
+#define EM_486   6   /* Perhaps disused */
+#define EM_860   7
+
+#define EM_MIPS         8       /* MIPS R3000 (officially, big-endian only) */
+
+#define EM_MIPS_RS4_BE 10       /* MIPS R4000 big-endian */
+
+#define EM_PARISC      15       /* HPPA */
+
+#define EM_SPARC32PLUS 18       /* Sun's "v8plus" */
+
+#define EM_PPC         20       /* PowerPC */
+#define EM_PPC64       21       /* PowerPC64 */
+
+#define EM_SH          42       /* SuperH */
+
+#define EM_SPARCV9     43       /* SPARC v9 64-bit */
+
+#define EM_IA_64        50      /* HP/Intel IA-64 */
+
+#define EM_X86_64       62      /* AMD x86-64 */
+
+#define EM_S390         22      /* IBM S/390 */
+
+#define EM_CRIS         76      /* Axis Communications 32-bit embedded processor */
+
+#define EM_V850         87      /* NEC v850 */
+
+#define EM_M32R         88      /* Renesas M32R */
+
+#define EM_H8_300       46      /* Renesas H8/300,300H,H8S */
+
+/*
+ * This is an interim value that we will use until the committee comes
+ * up with a final number.
+ */
+#define EM_ALPHA        0x9026
+
+/* Bogus old v850 magic number, used by old tools.  */
+#define EM_CYGNUS_V850  0x9080
+
+/* Bogus old m32r magic number, used by old tools.  */
+#define EM_CYGNUS_M32R  0x9041
+
+/*
+ * This is the old interim value for S/390 architecture
+ */
+#define EM_S390_OLD     0xA390
+
+#define EM_FRV          0x5441          /* Fujitsu FR-V */
+
+/* This is the info that is needed to parse the dynamic section of the file */
+#define DT_NULL         0
+#define DT_NEEDED       1
+#define DT_PLTRELSZ     2
+#define DT_PLTGOT       3
+#define DT_HASH         4
+#define DT_STRTAB       5
+#define DT_SYMTAB       6
+#define DT_RELA         7
+#define DT_RELASZ       8
+#define DT_RELAENT      9
+#define DT_STRSZ        10
+#define DT_SYMENT       11
+#define DT_INIT         12
+#define DT_FINI         13
+#define DT_SONAME       14
+#define DT_RPATH        15
+#define DT_SYMBOLIC     16
+#define DT_REL          17
+#define DT_RELSZ        18
+#define DT_RELENT       19
+#define DT_PLTREL       20
+#define DT_DEBUG        21
+#define DT_TEXTREL      22
+#define DT_JMPREL       23
+#define DT_LOPROC       0x70000000
+#define DT_HIPROC       0x7fffffff
+
+/* This info is needed when parsing the symbol table */
+#define STB_LOCAL  0
+#define STB_GLOBAL 1
+#define STB_WEAK   2
+
+#define STT_NOTYPE  0
+#define STT_OBJECT  1
+#define STT_FUNC    2
+#define STT_SECTION 3
+#define STT_FILE    4
+
+#define ELF_ST_BIND(x)          ((x) >> 4)
+#define ELF_ST_TYPE(x)          (((unsigned int) x) & 0xf)
+#define ELF32_ST_BIND(x)        ELF_ST_BIND(x)
+#define ELF32_ST_TYPE(x)        ELF_ST_TYPE(x)
+#define ELF64_ST_BIND(x)        ELF_ST_BIND(x)
+#define ELF64_ST_TYPE(x)        ELF_ST_TYPE(x)
+
+/* Symbolic values for the entries in the auxiliary table
+   put on the initial stack */
+#define AT_NULL   0     /* end of vector */
+#define AT_IGNORE 1     /* entry should be ignored */
+#define AT_EXECFD 2     /* file descriptor of program */
+#define AT_PHDR   3     /* program headers for program */
+#define AT_PHENT  4     /* size of program header entry */
+#define AT_PHNUM  5     /* number of program headers */
+#define AT_PAGESZ 6     /* system page size */
+#define AT_BASE   7     /* base address of interpreter */
+#define AT_FLAGS  8     /* flags */
+#define AT_ENTRY  9     /* entry point of program */
+#define AT_NOTELF 10    /* program is not ELF */
+#define AT_UID    11    /* real uid */
+#define AT_EUID   12    /* effective uid */
+#define AT_GID    13    /* real gid */
+#define AT_EGID   14    /* effective gid */
+#define AT_PLATFORM 15  /* string identifying CPU for optimizations */
+#define AT_HWCAP  16    /* arch dependent hints at CPU capabilities */
+#define AT_CLKTCK 17    /* frequency at which times() increments */
+
+#define AT_SECURE 23   /* secure mode boolean */
+
+typedef struct dynamic{
+  Elf32_Sword d_tag;
+  union{
+    Elf32_Sword d_val;
+    Elf32_Addr  d_ptr;
+  } d_un;
+} Elf32_Dyn;
+
+typedef struct {
+  Elf64_Sxword d_tag;           /* entry tag value */
+  union {
+    Elf64_Xword d_val;
+    Elf64_Addr d_ptr;
+  } d_un;
+} Elf64_Dyn;
+
+/* The following are used with relocations */
+#define ELF32_R_SYM(x) ((x) >> 8)
+#define ELF32_R_TYPE(x) ((x) & 0xff)
+
+#define ELF64_R_SYM(i)                  ((i) >> 32)
+#define ELF64_R_TYPE(i)                 ((i) & 0xffffffff)
+
+typedef struct elf32_rel {
+  Elf32_Addr    r_offset;
+  Elf32_Word    r_info;
+} Elf32_Rel;
+
+typedef struct elf64_rel {
+  Elf64_Addr r_offset;  /* Location at which to apply the action */
+  Elf64_Xword r_info;   /* index and type of relocation */
+} Elf64_Rel;
+
+typedef struct elf32_rela{
+  Elf32_Addr    r_offset;
+  Elf32_Word    r_info;
+  Elf32_Sword   r_addend;
+} Elf32_Rela;
+
+typedef struct elf64_rela {
+  Elf64_Addr r_offset;  /* Location at which to apply the action */
+  Elf64_Xword r_info;   /* index and type of relocation */
+  Elf64_Sxword r_addend;        /* Constant addend used to compute value */
+} Elf64_Rela;
+
+typedef struct elf32_sym{
+  Elf32_Word    st_name;
+  Elf32_Addr    st_value;
+  Elf32_Word    st_size;
+  unsigned char st_info;
+  unsigned char st_other;
+  Elf32_Half    st_shndx;
+} Elf32_Sym;
+
+typedef struct elf64_sym {
+  Elf64_Word st_name;           /* Symbol name, index in string tbl */
+  unsigned char st_info;        /* Type and binding attributes */
+  unsigned char st_other;       /* No defined meaning, 0 */
+  Elf64_Half st_shndx;          /* Associated section index */
+  Elf64_Addr st_value;          /* Value of the symbol */
+  Elf64_Xword st_size;          /* Associated symbol size */
+} Elf64_Sym;
+
+
+#define EI_NIDENT       16
+
+typedef struct elf32_hdr{
+  unsigned char e_ident[EI_NIDENT];
+  Elf32_Half    e_type;
+  Elf32_Half    e_machine;
+  Elf32_Word    e_version;
+  Elf32_Addr    e_entry;  /* Entry point */
+  Elf32_Off     e_phoff;
+  Elf32_Off     e_shoff;
+  Elf32_Word    e_flags;
+  Elf32_Half    e_ehsize;
+  Elf32_Half    e_phentsize;
+  Elf32_Half    e_phnum;
+  Elf32_Half    e_shentsize;
+  Elf32_Half    e_shnum;
+  Elf32_Half    e_shstrndx;
+} Elf32_Ehdr;
+
+typedef struct elf64_hdr {
+  unsigned char e_ident[16];            /* ELF "magic number" */
+  Elf64_Half e_type;
+  Elf64_Half e_machine;
+  Elf64_Word e_version;
+  Elf64_Addr e_entry;           /* Entry point virtual address */
+  Elf64_Off e_phoff;            /* Program header table file offset */
+  Elf64_Off e_shoff;            /* Section header table file offset */
+  Elf64_Word e_flags;
+  Elf64_Half e_ehsize;
+  Elf64_Half e_phentsize;
+  Elf64_Half e_phnum;
+  Elf64_Half e_shentsize;
+  Elf64_Half e_shnum;
+  Elf64_Half e_shstrndx;
+} Elf64_Ehdr;
+
+/* These constants define the permissions on sections in the program
+   header, p_flags. */
+#define PF_R            0x4
+#define PF_W            0x2
+#define PF_X            0x1
+
+typedef struct elf32_phdr{
+  Elf32_Word    p_type;
+  Elf32_Off     p_offset;
+  Elf32_Addr    p_vaddr;
+  Elf32_Addr    p_paddr;
+  Elf32_Word    p_filesz;
+  Elf32_Word    p_memsz;
+  Elf32_Word    p_flags;
+  Elf32_Word    p_align;
+} Elf32_Phdr;
+
+typedef struct elf64_phdr {
+  Elf64_Word p_type;
+  Elf64_Word p_flags;
+  Elf64_Off p_offset;           /* Segment file offset */
+  Elf64_Addr p_vaddr;           /* Segment virtual address */
+  Elf64_Addr p_paddr;           /* Segment physical address */
+  Elf64_Xword p_filesz;         /* Segment size in file */
+  Elf64_Xword p_memsz;          /* Segment size in memory */
+  Elf64_Xword p_align;          /* Segment alignment, file & memory */
+} Elf64_Phdr;
+
+/* sh_type */
+#define SHT_NULL        0
+#define SHT_PROGBITS    1
+#define SHT_SYMTAB      2
+#define SHT_STRTAB      3
+#define SHT_RELA        4
+#define SHT_HASH        5
+#define SHT_DYNAMIC     6
+#define SHT_NOTE        7
+#define SHT_NOBITS      8
+#define SHT_REL         9
+#define SHT_SHLIB       10
+#define SHT_DYNSYM      11
+#define SHT_NUM         12
+#define SHT_LOPROC      0x70000000
+#define SHT_HIPROC      0x7fffffff
+#define SHT_LOUSER      0x80000000
+#define SHT_HIUSER      0xffffffff
+
+/* sh_flags */
+#define SHF_WRITE       0x1
+#define SHF_ALLOC       0x2
+#define SHF_EXECINSTR   0x4
+#define SHF_MASKPROC    0xf0000000
+
+/* special section indexes */
+#define SHN_UNDEF       0
+#define SHN_LORESERVE   0xff00
+#define SHN_LOPROC      0xff00
+#define SHN_HIPROC      0xff1f
+#define SHN_ABS         0xfff1
+#define SHN_COMMON      0xfff2
+#define SHN_HIRESERVE   0xffff
+ 
+typedef struct {
+  Elf32_Word    sh_name;
+  Elf32_Word    sh_type;
+  Elf32_Word    sh_flags;
+  Elf32_Addr    sh_addr;
+  Elf32_Off     sh_offset;
+  Elf32_Word    sh_size;
+  Elf32_Word    sh_link;
+  Elf32_Word    sh_info;
+  Elf32_Word    sh_addralign;
+  Elf32_Word    sh_entsize;
+} Elf32_Shdr;
+
+typedef struct elf64_shdr {
+  Elf64_Word sh_name;           /* Section name, index in string tbl */
+  Elf64_Word sh_type;           /* Type of section */
+  Elf64_Xword sh_flags;         /* Miscellaneous section attributes */
+  Elf64_Addr sh_addr;           /* Section virtual addr at execution */
+  Elf64_Off sh_offset;          /* Section file offset */
+  Elf64_Xword sh_size;          /* Size of section in bytes */
+  Elf64_Word sh_link;           /* Index of another section */
+  Elf64_Word sh_info;           /* Additional section information */
+  Elf64_Xword sh_addralign;     /* Section alignment */
+  Elf64_Xword sh_entsize;       /* Entry size if section holds table */
+} Elf64_Shdr;
+
+#define EI_MAG0         0               /* e_ident[] indexes */
+#define EI_MAG1         1
+#define EI_MAG2         2
+#define EI_MAG3         3
+#define EI_CLASS        4
+#define EI_DATA         5
+#define EI_VERSION      6
+#define EI_OSABI        7
+#define EI_PAD          8
+
+#define ELFMAG0         0x7f            /* EI_MAG */
+#define ELFMAG1         'E'
+#define ELFMAG2         'L'
+#define ELFMAG3         'F'
+#define ELFMAG          "\177ELF"
+#define SELFMAG         4
+
+#define ELFCLASSNONE    0               /* EI_CLASS */
+#define ELFCLASS32      1
+#define ELFCLASS64      2
+#define ELFCLASSNUM     3
+
+#define ELFDATANONE     0               /* e_ident[EI_DATA] */
+#define ELFDATA2LSB     1
+#define ELFDATA2MSB     2
+
+#define EV_NONE         0               /* e_version, EI_VERSION */
+#define EV_CURRENT      1
+#define EV_NUM          2
+
+#define ELFOSABI_NONE   0
+#define ELFOSABI_LINUX  3
+
+#ifndef ELF_OSABI
+#define ELF_OSABI ELFOSABI_NONE
+#endif
+
+/* Notes used in ET_CORE */
+#define NT_PRSTATUS     1
+#define NT_PRFPREG      2
+#define NT_PRPSINFO     3
+#define NT_TASKSTRUCT   4
+#define NT_AUXV         6
+#define NT_PRXFPREG     0x46e62b7f      /* copied from gdb5.1/include/elf/common.h */
+
+
+/* Note header in a PT_NOTE section */
+typedef struct elf32_note {
+  Elf32_Word    n_namesz;       /* Name size */
+  Elf32_Word    n_descsz;       /* Content size */
+  Elf32_Word    n_type;         /* Content type */
+} Elf32_Nhdr;
+
+/* Note header in a PT_NOTE section */
+typedef struct elf64_note {
+  Elf64_Word n_namesz;  /* Name size */
+  Elf64_Word n_descsz;  /* Content size */
+  Elf64_Word n_type;    /* Content type */
+} Elf64_Nhdr;
+
+#if ELF_CLASS == ELFCLASS32
+
+extern Elf32_Dyn _DYNAMIC [];
+#define elfhdr          elf32_hdr
+#define elf_phdr        elf32_phdr
+#define elf_note        elf32_note
+
+#else
+
+extern Elf64_Dyn _DYNAMIC [];
+#define elfhdr          elf64_hdr
+#define elf_phdr        elf64_phdr
+#define elf_note        elf64_note
+
+#endif
+
+
+#endif /* _LINUX_ELF_H */
diff --git a/include/linux/elfcore.h b/include/linux/elfcore.h
new file mode 100644
index 000000000000..dbd7bb4a33b7
--- /dev/null
+++ b/include/linux/elfcore.h
@@ -0,0 +1,129 @@
+#ifndef _LINUX_ELFCORE_H
+#define _LINUX_ELFCORE_H
+
+#include <linux/types.h>
+#include <linux/signal.h>
+#include <linux/time.h>
+#include <linux/user.h>
+
+struct elf_siginfo
+{
+        int     si_signo;                       /* signal number */
+        int     si_code;                        /* extra code */
+        int     si_errno;                       /* errno */
+};
+
+#include <asm/elf.h>
+
+#ifndef __KERNEL__
+typedef elf_greg_t greg_t;
+typedef elf_gregset_t gregset_t;
+typedef elf_fpregset_t fpregset_t;
+typedef elf_fpxregset_t fpxregset_t;
+#define NGREG ELF_NGREG
+#endif
+
+/*
+ * Definitions to generate Intel SVR4-like core files.
+ * These mostly have the same names as the SVR4 types with "elf_"
+ * tacked on the front to prevent clashes with linux definitions,
+ * and the typedef forms have been avoided.  This is mostly like
+ * the SVR4 structure, but more Linuxy, with things that Linux does
+ * not support and which gdb doesn't really use excluded.
+ * Fields present but not used are marked with "XXX".
+ */
+struct elf_prstatus
+{
+#if 0
+        long    pr_flags;       /* XXX Process flags */
+        short   pr_why;         /* XXX Reason for process halt */
+        short   pr_what;        /* XXX More detailed reason */
+#endif
+        struct elf_siginfo pr_info;     /* Info associated with signal */
+        short   pr_cursig;              /* Current signal */
+        unsigned long pr_sigpend;       /* Set of pending signals */
+        unsigned long pr_sighold;       /* Set of held signals */
+#if 0
+        struct sigaltstack pr_altstack; /* Alternate stack info */
+        struct sigaction pr_action;     /* Signal action for current sig */
+#endif
+        pid_t   pr_pid;
+        pid_t   pr_ppid;
+        pid_t   pr_pgrp;
+        pid_t   pr_sid;
+        struct timeval pr_utime;        /* User time */
+        struct timeval pr_stime;        /* System time */
+        struct timeval pr_cutime;       /* Cumulative user time */
+        struct timeval pr_cstime;       /* Cumulative system time */
+#if 0
+        long    pr_instr;               /* Current instruction */
+#endif
+        elf_gregset_t pr_reg;   /* GP registers */
+        int pr_fpvalid;         /* True if math co-processor being used.  */
+};
+
+#define ELF_PRARGSZ     (80)    /* Number of chars for args */
+
+struct elf_prpsinfo
+{
+        char    pr_state;       /* numeric process state */
+        char    pr_sname;       /* char for pr_state */
+        char    pr_zomb;        /* zombie */
+        char    pr_nice;        /* nice val */
+        unsigned long pr_flag;  /* flags */
+        __kernel_uid_t  pr_uid;
+        __kernel_gid_t  pr_gid;
+        pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
+        /* Lots missing */
+        char    pr_fname[16];   /* filename of executable */
+        char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
+};
+
+#ifndef __KERNEL__
+typedef struct elf_prstatus prstatus_t;
+typedef struct elf_prpsinfo prpsinfo_t;
+#define PRARGSZ ELF_PRARGSZ 
+#endif
+
+#ifdef __KERNEL__
+static inline void elf_core_copy_regs(elf_gregset_t *elfregs, struct pt_regs *regs)
+{
+#ifdef ELF_CORE_COPY_REGS
+        ELF_CORE_COPY_REGS((*elfregs), regs)
+#else
+        BUG_ON(sizeof(*elfregs) != sizeof(*regs));
+        *(struct pt_regs *)elfregs = *regs;
+#endif
+}
+
+static inline int elf_core_copy_task_regs(struct task_struct *t, elf_gregset_t* elfregs)
+{
+#ifdef ELF_CORE_COPY_TASK_REGS
+        
+        return ELF_CORE_COPY_TASK_REGS(t, elfregs);
+#endif
+        return 0;
+}
+
+extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
+
+static inline int elf_core_copy_task_fpregs(struct task_struct *t, struct pt_regs *regs, elf_fpregset_t *fpu)
+{
+#ifdef ELF_CORE_COPY_FPREGS
+        return ELF_CORE_COPY_FPREGS(t, fpu);
+#else
+        return dump_fpu(regs, fpu);
+#endif
+}
+
+#ifdef ELF_CORE_COPY_XFPREGS
+static inline int elf_core_copy_task_xfpregs(struct task_struct *t, elf_fpxregset_t *xfpu)
+{
+        return ELF_CORE_COPY_XFPREGS(t, xfpu);
+}
+#endif
+
+#endif /* __KERNEL__ */
+
+
+#endif /* _LINUX_ELFCORE_H */
diff --git a/include/linux/err.h b/include/linux/err.h
new file mode 100644
index 000000000000..17c55df13615
--- /dev/null
+++ b/include/linux/err.h
@@ -0,0 +1,31 @@
+#ifndef _LINUX_ERR_H
+#define _LINUX_ERR_H
+
+#include <linux/compiler.h>
+
+#include <asm/errno.h>
+
+/*
+ * Kernel pointers have redundant information, so we can use a
+ * scheme where we can return either an error code or a dentry
+ * pointer with the same return value.
+ *
+ * This should be a per-architecture thing, to allow different
+ * error and pointer decisions.
+ */
+static inline void *ERR_PTR(long error)
+{
+        return (void *) error;
+}
+
+static inline long PTR_ERR(const void *ptr)
+{
+        return (long) ptr;
+}
+
+static inline long IS_ERR(const void *ptr)
+{
+        return unlikely((unsigned long)ptr > (unsigned long)-1000L);
+}
+
+#endif /* _LINUX_ERR_H */
diff --git a/include/linux/errno.h b/include/linux/errno.h
new file mode 100644
index 000000000000..d90b80f9b28c
--- /dev/null
+++ b/include/linux/errno.h
@@ -0,0 +1,29 @@
+#ifndef _LINUX_ERRNO_H
+#define _LINUX_ERRNO_H
+
+#include <asm/errno.h>
+
+#ifdef __KERNEL__
+
+/* Should never be seen by user programs */
+#define ERESTARTSYS     512
+#define ERESTARTNOINTR  513
+#define ERESTARTNOHAND  514     /* restart if no handler.. */
+#define ENOIOCTLCMD     515     /* No ioctl command */
+#define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
+
+/* Defined for the NFSv3 protocol */
+#define EBADHANDLE      521     /* Illegal NFS file handle */
+#define ENOTSYNC        522     /* Update synchronization mismatch */
+#define EBADCOOKIE      523     /* Cookie is stale */
+#define ENOTSUPP        524     /* Operation is not supported */
+#define ETOOSMALL       525     /* Buffer or request is too small */
+#define ESERVERFAULT    526     /* An untranslatable error occurred */
+#define EBADTYPE        527     /* Type not supported by server */
+#define EJUKEBOX        528     /* Request initiated, but will not complete before timeout */
+#define EIOCBQUEUED     529     /* iocb queued, will get completion event */
+#define EIOCBRETRY      530     /* iocb queued, will trigger a retry */
+
+#endif
+
+#endif
diff --git a/include/linux/errqueue.h b/include/linux/errqueue.h
new file mode 100644
index 000000000000..174582fedb8b
--- /dev/null
+++ b/include/linux/errqueue.h
@@ -0,0 +1,47 @@
+#ifndef _LINUX_ERRQUEUE_H
+#define _LINUX_ERRQUEUE_H 1
+
+struct sock_extended_err
+{
+        __u32   ee_errno;       
+        __u8    ee_origin;
+        __u8    ee_type;
+        __u8    ee_code;
+        __u8    ee_pad;
+        __u32   ee_info;
+        __u32   ee_data;
+};
+
+#define SO_EE_ORIGIN_NONE       0
+#define SO_EE_ORIGIN_LOCAL      1
+#define SO_EE_ORIGIN_ICMP       2
+#define SO_EE_ORIGIN_ICMP6      3
+
+#define SO_EE_OFFENDER(ee)      ((struct sockaddr*)((ee)+1))
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <net/ip.h>
+#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
+#include <linux/ipv6.h>
+#endif
+
+#define SKB_EXT_ERR(skb) ((struct sock_exterr_skb *) ((skb)->cb))
+
+struct sock_exterr_skb
+{
+        union {
+                struct inet_skb_parm    h4;
+#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
+                struct inet6_skb_parm   h6;
+#endif
+        } header;
+        struct sock_extended_err        ee;
+        u16                             addr_offset;
+        u16                             port;
+};
+
+#endif
+
+#endif
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
new file mode 100644
index 000000000000..396c48cbaeb1
--- /dev/null
+++ b/include/linux/etherdevice.h
@@ -0,0 +1,88 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  NET  is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the Ethernet handlers.
+ *
+ * Version:     @(#)eth.h       1.0.4   05/13/93
+ *
+ * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              Relocated to include/linux where it belongs by Alan Cox 
+ *                                                      <gw4pts@gw4pts.ampr.org>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ *      WARNING: This move may well be temporary. This file will get merged with others RSN.
+ *
+ */
+#ifndef _LINUX_ETHERDEVICE_H
+#define _LINUX_ETHERDEVICE_H
+
+#include <linux/if_ether.h>
+#include <linux/random.h>
+
+#ifdef __KERNEL__
+extern int              eth_header(struct sk_buff *skb, struct net_device *dev,
+                                   unsigned short type, void *daddr,
+                                   void *saddr, unsigned len);
+extern int              eth_rebuild_header(struct sk_buff *skb);
+extern unsigned short   eth_type_trans(struct sk_buff *skb, struct net_device *dev);
+extern void             eth_header_cache_update(struct hh_cache *hh, struct net_device *dev,
+                                                unsigned char * haddr);
+extern int              eth_header_cache(struct neighbour *neigh,
+                                         struct hh_cache *hh);
+
+extern struct net_device *alloc_etherdev(int sizeof_priv);
+static inline void eth_copy_and_sum (struct sk_buff *dest, 
+                                     const unsigned char *src, 
+                                     int len, int base)
+{
+        memcpy (dest->data, src, len);
+}
+
+/**
+ * is_zero_ether_addr - Determine if give Ethernet address is all
+ * zeros.
+ */
+static inline int is_zero_ether_addr(const u8 *addr)
+{
+        return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
+}
+
+/**
+ * is_valid_ether_addr - Determine if the given Ethernet address is valid
+ * @addr: Pointer to a six-byte array containing the Ethernet address
+ *
+ * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
+ * a multicast address, and is not FF:FF:FF:FF:FF:FF.  The multicast
+ * and FF:FF:... tests are combined into the single test "!(addr[0]&1)".
+ *
+ * Return true if the address is valid.
+ */
+static inline int is_valid_ether_addr(const u8 *addr)
+{
+        return !(addr[0]&1) && !is_zero_ether_addr(addr);
+}
+
+/**
+ * random_ether_addr - Generate software assigned random Ethernet address
+ * @addr: Pointer to a six-byte array containing the Ethernet address
+ *
+ * Generate a random Ethernet address (MAC) that is not multicast
+ * and has the local assigned bit set.
+ */
+static inline void random_ether_addr(u8 *addr)
+{
+        get_random_bytes (addr, ETH_ALEN);
+        addr [0] &= 0xfe;       /* clear multicast bit */
+        addr [0] |= 0x02;       /* set local assignment bit (IEEE802) */
+}
+#endif
+
+#endif  /* _LINUX_ETHERDEVICE_H */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
new file mode 100644
index 000000000000..c85b210490ea
--- /dev/null
+++ b/include/linux/ethtool.h
@@ -0,0 +1,471 @@
+/*
+ * ethtool.h: Defines for Linux ethtool.
+ *
+ * Copyright (C) 1998 David S. Miller (davem@redhat.com)
+ * Copyright 2001 Jeff Garzik <jgarzik@pobox.com>
+ * Portions Copyright 2001 Sun Microsystems (thockin@sun.com)
+ * Portions Copyright 2002 Intel (eli.kupermann@intel.com,
+ *                                christopher.leech@intel.com,
+ *                                scott.feldman@intel.com)
+ */
+
+#ifndef _LINUX_ETHTOOL_H
+#define _LINUX_ETHTOOL_H
+
+
+/* This should work for both 32 and 64 bit userland. */
+struct ethtool_cmd {
+        u32     cmd;
+        u32     supported;      /* Features this interface supports */
+        u32     advertising;    /* Features this interface advertises */
+        u16     speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
+        u8      duplex;         /* Duplex, half or full */
+        u8      port;           /* Which connector port */
+        u8      phy_address;
+        u8      transceiver;    /* Which transceiver to use */
+        u8      autoneg;        /* Enable or disable autonegotiation */
+        u32     maxtxpkt;       /* Tx pkts before generating tx int */
+        u32     maxrxpkt;       /* Rx pkts before generating rx int */
+        u32     reserved[4];
+};
+
+#define ETHTOOL_BUSINFO_LEN     32
+/* these strings are set to whatever the driver author decides... */
+struct ethtool_drvinfo {
+        u32     cmd;
+        char    driver[32];     /* driver short name, "tulip", "eepro100" */
+        char    version[32];    /* driver version string */
+        char    fw_version[32]; /* firmware version string, if applicable */
+        char    bus_info[ETHTOOL_BUSINFO_LEN];  /* Bus info for this IF. */
+                                /* For PCI devices, use pci_name(pci_dev). */
+        char    reserved1[32];
+        char    reserved2[16];
+        u32     n_stats;        /* number of u64's from ETHTOOL_GSTATS */
+        u32     testinfo_len;
+        u32     eedump_len;     /* Size of data from ETHTOOL_GEEPROM (bytes) */
+        u32     regdump_len;    /* Size of data from ETHTOOL_GREGS (bytes) */
+};
+
+#define SOPASS_MAX      6
+/* wake-on-lan settings */
+struct ethtool_wolinfo {
+        u32     cmd;
+        u32     supported;
+        u32     wolopts;
+        u8      sopass[SOPASS_MAX]; /* SecureOn(tm) password */
+};
+
+/* for passing single values */
+struct ethtool_value {
+        u32     cmd;
+        u32     data;
+};
+
+/* for passing big chunks of data */
+struct ethtool_regs {
+        u32     cmd;
+        u32     version; /* driver-specific, indicates different chips/revs */
+        u32     len; /* bytes */
+        u8      data[0];
+};
+
+/* for passing EEPROM chunks */
+struct ethtool_eeprom {
+        u32     cmd;
+        u32     magic;
+        u32     offset; /* in bytes */
+        u32     len; /* in bytes */
+        u8      data[0];
+};
+
+/* for configuring coalescing parameters of chip */
+struct ethtool_coalesce {
+        u32     cmd;    /* ETHTOOL_{G,S}COALESCE */
+
+        /* How many usecs to delay an RX interrupt after
+         * a packet arrives.  If 0, only rx_max_coalesced_frames
+         * is used.
+         */
+        u32     rx_coalesce_usecs;
+
+        /* How many packets to delay an RX interrupt after
+         * a packet arrives.  If 0, only rx_coalesce_usecs is
+         * used.  It is illegal to set both usecs and max frames
+         * to zero as this would cause RX interrupts to never be
+         * generated.
+         */
+        u32     rx_max_coalesced_frames;
+
+        /* Same as above two parameters, except that these values
+         * apply while an IRQ is being serviced by the host.  Not
+         * all cards support this feature and the values are ignored
+         * in that case.
+         */
+        u32     rx_coalesce_usecs_irq;
+        u32     rx_max_coalesced_frames_irq;
+
+        /* How many usecs to delay a TX interrupt after
+         * a packet is sent.  If 0, only tx_max_coalesced_frames
+         * is used.
+         */
+        u32     tx_coalesce_usecs;
+
+        /* How many packets to delay a TX interrupt after
+         * a packet is sent.  If 0, only tx_coalesce_usecs is
+         * used.  It is illegal to set both usecs and max frames
+         * to zero as this would cause TX interrupts to never be
+         * generated.
+         */
+        u32     tx_max_coalesced_frames;
+
+        /* Same as above two parameters, except that these values
+         * apply while an IRQ is being serviced by the host.  Not
+         * all cards support this feature and the values are ignored
+         * in that case.
+         */
+        u32     tx_coalesce_usecs_irq;
+        u32     tx_max_coalesced_frames_irq;
+
+        /* How many usecs to delay in-memory statistics
+         * block updates.  Some drivers do not have an in-memory
+         * statistic block, and in such cases this value is ignored.
+         * This value must not be zero.
+         */
+        u32     stats_block_coalesce_usecs;
+
+        /* Adaptive RX/TX coalescing is an algorithm implemented by
+         * some drivers to improve latency under low packet rates and
+         * improve throughput under high packet rates.  Some drivers
+         * only implement one of RX or TX adaptive coalescing.  Anything
+         * not implemented by the driver causes these values to be
+         * silently ignored.
+         */
+        u32     use_adaptive_rx_coalesce;
+        u32     use_adaptive_tx_coalesce;
+
+        /* When the packet rate (measured in packets per second)
+         * is below pkt_rate_low, the {rx,tx}_*_low parameters are
+         * used.
+         */
+        u32     pkt_rate_low;
+        u32     rx_coalesce_usecs_low;
+        u32     rx_max_coalesced_frames_low;
+        u32     tx_coalesce_usecs_low;
+        u32     tx_max_coalesced_frames_low;
+
+        /* When the packet rate is below pkt_rate_high but above
+         * pkt_rate_low (both measured in packets per second) the
+         * normal {rx,tx}_* coalescing parameters are used.
+         */
+
+        /* When the packet rate is (measured in packets per second)
+         * is above pkt_rate_high, the {rx,tx}_*_high parameters are
+         * used.
+         */
+        u32     pkt_rate_high;
+        u32     rx_coalesce_usecs_high;
+        u32     rx_max_coalesced_frames_high;
+        u32     tx_coalesce_usecs_high;
+        u32     tx_max_coalesced_frames_high;
+
+        /* How often to do adaptive coalescing packet rate sampling,
+         * measured in seconds.  Must not be zero.
+         */
+        u32     rate_sample_interval;
+};
+
+/* for configuring RX/TX ring parameters */
+struct ethtool_ringparam {
+        u32     cmd;    /* ETHTOOL_{G,S}RINGPARAM */
+
+        /* Read only attributes.  These indicate the maximum number
+         * of pending RX/TX ring entries the driver will allow the
+         * user to set.
+         */
+        u32     rx_max_pending;
+        u32     rx_mini_max_pending;
+        u32     rx_jumbo_max_pending;
+        u32     tx_max_pending;
+
+        /* Values changeable by the user.  The valid values are
+         * in the range 1 to the "*_max_pending" counterpart above.
+         */
+        u32     rx_pending;
+        u32     rx_mini_pending;
+        u32     rx_jumbo_pending;
+        u32     tx_pending;
+};
+
+/* for configuring link flow control parameters */
+struct ethtool_pauseparam {
+        u32     cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
+
+        /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
+         * being true) the user may set 'autonet' here non-zero to have the
+         * pause parameters be auto-negotiated too.  In such a case, the
+         * {rx,tx}_pause values below determine what capabilities are
+         * advertised.
+         *
+         * If 'autoneg' is zero or the link is not being auto-negotiated,
+         * then {rx,tx}_pause force the driver to use/not-use pause
+         * flow control.
+         */
+        u32     autoneg;
+        u32     rx_pause;
+        u32     tx_pause;
+};
+
+#define ETH_GSTRING_LEN         32
+enum ethtool_stringset {
+        ETH_SS_TEST             = 0,
+        ETH_SS_STATS,
+};
+
+/* for passing string sets for data tagging */
+struct ethtool_gstrings {
+        u32     cmd;            /* ETHTOOL_GSTRINGS */
+        u32     string_set;     /* string set id e.c. ETH_SS_TEST, etc*/
+        u32     len;            /* number of strings in the string set */
+        u8      data[0];
+};
+
+enum ethtool_test_flags {
+        ETH_TEST_FL_OFFLINE     = (1 << 0),     /* online / offline */
+        ETH_TEST_FL_FAILED      = (1 << 1),     /* test passed / failed */
+};
+
+/* for requesting NIC test and getting results*/
+struct ethtool_test {
+        u32     cmd;            /* ETHTOOL_TEST */
+        u32     flags;          /* ETH_TEST_FL_xxx */
+        u32     reserved;
+        u32     len;            /* result length, in number of u64 elements */
+        u64     data[0];
+};
+
+/* for dumping NIC-specific statistics */
+struct ethtool_stats {
+        u32     cmd;            /* ETHTOOL_GSTATS */
+        u32     n_stats;        /* number of u64's being returned */
+        u64     data[0];
+};
+
+struct net_device;
+
+/* Some generic methods drivers may use in their ethtool_ops */
+u32 ethtool_op_get_link(struct net_device *dev);
+u32 ethtool_op_get_tx_csum(struct net_device *dev);
+int ethtool_op_set_tx_csum(struct net_device *dev, u32 data);
+u32 ethtool_op_get_sg(struct net_device *dev);
+int ethtool_op_set_sg(struct net_device *dev, u32 data);
+u32 ethtool_op_get_tso(struct net_device *dev);
+int ethtool_op_set_tso(struct net_device *dev, u32 data);
+
+/**
+ * &ethtool_ops - Alter and report network device settings
+ * get_settings: Get device-specific settings
+ * set_settings: Set device-specific settings
+ * get_drvinfo: Report driver information
+ * get_regs: Get device registers
+ * get_wol: Report whether Wake-on-Lan is enabled
+ * set_wol: Turn Wake-on-Lan on or off
+ * get_msglevel: Report driver message level
+ * set_msglevel: Set driver message level
+ * nway_reset: Restart autonegotiation
+ * get_link: Get link status
+ * get_eeprom: Read data from the device EEPROM
+ * set_eeprom: Write data to the device EEPROM
+ * get_coalesce: Get interrupt coalescing parameters
+ * set_coalesce: Set interrupt coalescing parameters
+ * get_ringparam: Report ring sizes
+ * set_ringparam: Set ring sizes
+ * get_pauseparam: Report pause parameters
+ * set_pauseparam: Set pause paramters
+ * get_rx_csum: Report whether receive checksums are turned on or off
+ * set_rx_csum: Turn receive checksum on or off
+ * get_tx_csum: Report whether transmit checksums are turned on or off
+ * set_tx_csum: Turn transmit checksums on or off
+ * get_sg: Report whether scatter-gather is enabled
+ * set_sg: Turn scatter-gather on or off
+ * get_tso: Report whether TCP segmentation offload is enabled
+ * set_tso: Turn TCP segmentation offload on or off
+ * self_test: Run specified self-tests
+ * get_strings: Return a set of strings that describe the requested objects 
+ * phys_id: Identify the device
+ * get_stats: Return statistics about the device
+ *
+ * Description:
+ *
+ * get_settings:
+ *      @get_settings is passed an &ethtool_cmd to fill in.  It returns
+ *      an negative errno or zero.
+ *
+ * set_settings:
+ *      @set_settings is passed an &ethtool_cmd and should attempt to set
+ *      all the settings this device supports.  It may return an error value
+ *      if something goes wrong (otherwise 0).
+ *
+ * get_eeprom:
+ *      Should fill in the magic field.  Don't need to check len for zero
+ *      or wraparound.  Fill in the data argument with the eeprom values
+ *      from offset to offset + len.  Update len to the amount read.
+ *      Returns an error or zero.
+ *
+ * set_eeprom:
+ *      Should validate the magic field.  Don't need to check len for zero
+ *      or wraparound.  Update len to the amount written.  Returns an error
+ *      or zero.
+ */
+struct ethtool_ops {
+        int     (*get_settings)(struct net_device *, struct ethtool_cmd *);
+        int     (*set_settings)(struct net_device *, struct ethtool_cmd *);
+        void    (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *);
+        int     (*get_regs_len)(struct net_device *);
+        void    (*get_regs)(struct net_device *, struct ethtool_regs *, void *);
+        void    (*get_wol)(struct net_device *, struct ethtool_wolinfo *);
+        int     (*set_wol)(struct net_device *, struct ethtool_wolinfo *);
+        u32     (*get_msglevel)(struct net_device *);
+        void    (*set_msglevel)(struct net_device *, u32);
+        int     (*nway_reset)(struct net_device *);
+        u32     (*get_link)(struct net_device *);
+        int     (*get_eeprom_len)(struct net_device *);
+        int     (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
+        int     (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
+        int     (*get_coalesce)(struct net_device *, struct ethtool_coalesce *);
+        int     (*set_coalesce)(struct net_device *, struct ethtool_coalesce *);
+        void    (*get_ringparam)(struct net_device *, struct ethtool_ringparam *);
+        int     (*set_ringparam)(struct net_device *, struct ethtool_ringparam *);
+        void    (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam*);
+        int     (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam*);
+        u32     (*get_rx_csum)(struct net_device *);
+        int     (*set_rx_csum)(struct net_device *, u32);
+        u32     (*get_tx_csum)(struct net_device *);
+        int     (*set_tx_csum)(struct net_device *, u32);
+        u32     (*get_sg)(struct net_device *);
+        int     (*set_sg)(struct net_device *, u32);
+        u32     (*get_tso)(struct net_device *);
+        int     (*set_tso)(struct net_device *, u32);
+        int     (*self_test_count)(struct net_device *);
+        void    (*self_test)(struct net_device *, struct ethtool_test *, u64 *);
+        void    (*get_strings)(struct net_device *, u32 stringset, u8 *);
+        int     (*phys_id)(struct net_device *, u32);
+        int     (*get_stats_count)(struct net_device *);
+        void    (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *);
+        int     (*begin)(struct net_device *);
+        void    (*complete)(struct net_device *);
+};
+
+/* CMDs currently supported */
+#define ETHTOOL_GSET            0x00000001 /* Get settings. */
+#define ETHTOOL_SSET            0x00000002 /* Set settings. */
+#define ETHTOOL_GDRVINFO        0x00000003 /* Get driver info. */
+#define ETHTOOL_GREGS           0x00000004 /* Get NIC registers. */
+#define ETHTOOL_GWOL            0x00000005 /* Get wake-on-lan options. */
+#define ETHTOOL_SWOL            0x00000006 /* Set wake-on-lan options. */
+#define ETHTOOL_GMSGLVL         0x00000007 /* Get driver message level */
+#define ETHTOOL_SMSGLVL         0x00000008 /* Set driver msg level. */
+#define ETHTOOL_NWAY_RST        0x00000009 /* Restart autonegotiation. */
+#define ETHTOOL_GLINK           0x0000000a /* Get link status (ethtool_value) */
+#define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
+#define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data. */
+#define ETHTOOL_GCOALESCE       0x0000000e /* Get coalesce config */
+#define ETHTOOL_SCOALESCE       0x0000000f /* Set coalesce config. */
+#define ETHTOOL_GRINGPARAM      0x00000010 /* Get ring parameters */
+#define ETHTOOL_SRINGPARAM      0x00000011 /* Set ring parameters. */
+#define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
+#define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
+#define ETHTOOL_GRXCSUM         0x00000014 /* Get RX hw csum enable (ethtool_value) */
+#define ETHTOOL_SRXCSUM         0x00000015 /* Set RX hw csum enable (ethtool_value) */
+#define ETHTOOL_GTXCSUM         0x00000016 /* Get TX hw csum enable (ethtool_value) */
+#define ETHTOOL_STXCSUM         0x00000017 /* Set TX hw csum enable (ethtool_value) */
+#define ETHTOOL_GSG             0x00000018 /* Get scatter-gather enable
+                                            * (ethtool_value) */
+#define ETHTOOL_SSG             0x00000019 /* Set scatter-gather enable
+                                            * (ethtool_value). */
+#define ETHTOOL_TEST            0x0000001a /* execute NIC self-test. */
+#define ETHTOOL_GSTRINGS        0x0000001b /* get specified string set */
+#define ETHTOOL_PHYS_ID         0x0000001c /* identify the NIC */
+#define ETHTOOL_GSTATS          0x0000001d /* get NIC-specific statistics */
+#define ETHTOOL_GTSO            0x0000001e /* Get TSO enable (ethtool_value) */
+#define ETHTOOL_STSO            0x0000001f /* Set TSO enable (ethtool_value) */
+
+/* compatibility with older code */
+#define SPARC_ETH_GSET          ETHTOOL_GSET
+#define SPARC_ETH_SSET          ETHTOOL_SSET
+
+/* Indicates what features are supported by the interface. */
+#define SUPPORTED_10baseT_Half          (1 << 0)
+#define SUPPORTED_10baseT_Full          (1 << 1)
+#define SUPPORTED_100baseT_Half         (1 << 2)
+#define SUPPORTED_100baseT_Full         (1 << 3)
+#define SUPPORTED_1000baseT_Half        (1 << 4)
+#define SUPPORTED_1000baseT_Full        (1 << 5)
+#define SUPPORTED_Autoneg               (1 << 6)
+#define SUPPORTED_TP                    (1 << 7)
+#define SUPPORTED_AUI                   (1 << 8)
+#define SUPPORTED_MII                   (1 << 9)
+#define SUPPORTED_FIBRE                 (1 << 10)
+#define SUPPORTED_BNC                   (1 << 11)
+#define SUPPORTED_10000baseT_Full       (1 << 12)
+
+/* Indicates what features are advertised by the interface. */
+#define ADVERTISED_10baseT_Half         (1 << 0)
+#define ADVERTISED_10baseT_Full         (1 << 1)
+#define ADVERTISED_100baseT_Half        (1 << 2)
+#define ADVERTISED_100baseT_Full        (1 << 3)
+#define ADVERTISED_1000baseT_Half       (1 << 4)
+#define ADVERTISED_1000baseT_Full       (1 << 5)
+#define ADVERTISED_Autoneg              (1 << 6)
+#define ADVERTISED_TP                   (1 << 7)
+#define ADVERTISED_AUI                  (1 << 8)
+#define ADVERTISED_MII                  (1 << 9)
+#define ADVERTISED_FIBRE                (1 << 10)
+#define ADVERTISED_BNC                  (1 << 11)
+#define ADVERTISED_10000baseT_Full      (1 << 12)
+
+/* The following are all involved in forcing a particular link
+ * mode for the device for setting things.  When getting the
+ * devices settings, these indicate the current mode and whether
+ * it was foced up into this mode or autonegotiated.
+ */
+
+/* The forced speed, 10Mb, 100Mb, gigabit, 10GbE. */
+#define SPEED_10                10
+#define SPEED_100               100
+#define SPEED_1000              1000
+#define SPEED_10000             10000
+
+/* Duplex, half or full. */
+#define DUPLEX_HALF             0x00
+#define DUPLEX_FULL             0x01
+
+/* Which connector port. */
+#define PORT_TP                 0x00
+#define PORT_AUI                0x01
+#define PORT_MII                0x02
+#define PORT_FIBRE              0x03
+#define PORT_BNC                0x04
+
+/* Which transceiver to use. */
+#define XCVR_INTERNAL           0x00
+#define XCVR_EXTERNAL           0x01
+#define XCVR_DUMMY1             0x02
+#define XCVR_DUMMY2             0x03
+#define XCVR_DUMMY3             0x04
+
+/* Enable or disable autonegotiation.  If this is set to enable,
+ * the forced link modes above are completely ignored.
+ */
+#define AUTONEG_DISABLE         0x00
+#define AUTONEG_ENABLE          0x01
+
+/* Wake-On-Lan options. */
+#define WAKE_PHY                (1 << 0)
+#define WAKE_UCAST              (1 << 1)
+#define WAKE_MCAST              (1 << 2)
+#define WAKE_BCAST              (1 << 3)
+#define WAKE_ARP                (1 << 4)
+#define WAKE_MAGIC              (1 << 5)
+#define WAKE_MAGICSECURE        (1 << 6) /* only meaningful if WAKE_MAGIC */
+
+#endif /* _LINUX_ETHTOOL_H */
diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h
new file mode 100644
index 000000000000..1289f0ec4c00
--- /dev/null
+++ b/include/linux/eventpoll.h
@@ -0,0 +1,99 @@
+/*
+ *  include/linux/eventpoll.h ( Efficent event polling implementation )
+ *  Copyright (C) 2001,...,2003  Davide Libenzi
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Davide Libenzi <davidel@xmailserver.org>
+ *
+ */
+
+#ifndef _LINUX_EVENTPOLL_H
+#define _LINUX_EVENTPOLL_H
+
+#include <linux/types.h>
+
+
+/* Valid opcodes to issue to sys_epoll_ctl() */
+#define EPOLL_CTL_ADD 1
+#define EPOLL_CTL_DEL 2
+#define EPOLL_CTL_MOD 3
+
+/* Set the One Shot behaviour for the target file descriptor */
+#define EPOLLONESHOT (1 << 30)
+
+/* Set the Edge Triggered behaviour for the target file descriptor */
+#define EPOLLET (1 << 31)
+
+/* 
+ * On x86-64 make the 64bit structure have the same alignment as the
+ * 32bit structure. This makes 32bit emulation easier.
+ */
+#ifdef __x86_64__
+#define EPOLL_PACKED __attribute__((packed))
+#else
+#define EPOLL_PACKED
+#endif
+
+struct epoll_event {
+        __u32 events;
+        __u64 data;
+} EPOLL_PACKED;
+
+#ifdef __KERNEL__
+
+/* Forward declarations to avoid compiler errors */
+struct file;
+
+
+#ifdef CONFIG_EPOLL
+
+/* Used to initialize the epoll bits inside the "struct file" */
+void eventpoll_init_file(struct file *file);
+
+/* Used to release the epoll bits inside the "struct file" */
+void eventpoll_release_file(struct file *file);
+
+/*
+ * This is called from inside fs/file_table.c:__fput() to unlink files
+ * from the eventpoll interface. We need to have this facility to cleanup
+ * correctly files that are closed without being removed from the eventpoll
+ * interface.
+ */
+static inline void eventpoll_release(struct file *file)
+{
+
+        /*
+         * Fast check to avoid the get/release of the semaphore. Since
+         * we're doing this outside the semaphore lock, it might return
+         * false negatives, but we don't care. It'll help in 99.99% of cases
+         * to avoid the semaphore lock. False positives simply cannot happen
+         * because the file in on the way to be removed and nobody ( but
+         * eventpoll ) has still a reference to this file.
+         */
+        if (likely(list_empty(&file->f_ep_links)))
+                return;
+
+        /*
+         * The file is being closed while it is still linked to an epoll
+         * descriptor. We need to handle this by correctly unlinking it
+         * from its containers.
+         */
+        eventpoll_release_file(file);
+}
+
+
+#else
+
+static inline void eventpoll_init_file(struct file *file) {}
+static inline void eventpoll_release(struct file *file) {}
+
+#endif
+
+#endif /* #ifdef __KERNEL__ */
+
+#endif /* #ifndef _LINUX_EVENTPOLL_H */
+
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
new file mode 100644
index 000000000000..fab43527e597
--- /dev/null
+++ b/include/linux/ext2_fs.h
@@ -0,0 +1,553 @@
+/*
+ *  linux/include/linux/ext2_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT2_FS_H
+#define _LINUX_EXT2_FS_H
+
+#include <linux/types.h>
+#include <linux/ext2_fs_sb.h>
+
+/*
+ * The second extended filesystem constants/structures
+ */
+
+/*
+ * Define EXT2FS_DEBUG to produce debug messages
+ */
+#undef EXT2FS_DEBUG
+
+/*
+ * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
+ */
+#define EXT2_PREALLOCATE
+#define EXT2_DEFAULT_PREALLOC_BLOCKS    8
+
+/*
+ * The second extended file system version
+ */
+#define EXT2FS_DATE             "95/08/09"
+#define EXT2FS_VERSION          "0.5b"
+
+/*
+ * Debug code
+ */
+#ifdef EXT2FS_DEBUG
+#       define ext2_debug(f, a...)      { \
+                                        printk ("EXT2-fs DEBUG (%s, %d): %s:", \
+                                                __FILE__, __LINE__, __FUNCTION__); \
+                                        printk (f, ## a); \
+                                        }
+#else
+#       define ext2_debug(f, a...)      /**/
+#endif
+
+/*
+ * Special inode numbers
+ */
+#define EXT2_BAD_INO             1      /* Bad blocks inode */
+#define EXT2_ROOT_INO            2      /* Root inode */
+#define EXT2_BOOT_LOADER_INO     5      /* Boot loader inode */
+#define EXT2_UNDEL_DIR_INO       6      /* Undelete directory inode */
+
+/* First non-reserved inode for old ext2 filesystems */
+#define EXT2_GOOD_OLD_FIRST_INO 11
+
+/*
+ * The second extended file system magic number
+ */
+#define EXT2_SUPER_MAGIC        0xEF53
+
+#ifdef __KERNEL__
+static inline struct ext2_sb_info *EXT2_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+#else
+/* Assume that user mode programs are passing in an ext2fs superblock, not
+ * a kernel struct super_block.  This will allow us to call the feature-test
+ * macros from user land. */
+#define EXT2_SB(sb)     (sb)
+#endif
+
+/*
+ * Maximal count of links to a file
+ */
+#define EXT2_LINK_MAX           32000
+
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT2_MIN_BLOCK_SIZE             1024
+#define EXT2_MAX_BLOCK_SIZE             4096
+#define EXT2_MIN_BLOCK_LOG_SIZE           10
+#ifdef __KERNEL__
+# define EXT2_BLOCK_SIZE(s)             ((s)->s_blocksize)
+#else
+# define EXT2_BLOCK_SIZE(s)             (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
+#endif
+#define EXT2_ADDR_PER_BLOCK(s)          (EXT2_BLOCK_SIZE(s) / sizeof (__u32))
+#ifdef __KERNEL__
+# define EXT2_BLOCK_SIZE_BITS(s)        ((s)->s_blocksize_bits)
+#else
+# define EXT2_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
+#endif
+#ifdef __KERNEL__
+#define EXT2_ADDR_PER_BLOCK_BITS(s)     (EXT2_SB(s)->s_addr_per_block_bits)
+#define EXT2_INODE_SIZE(s)              (EXT2_SB(s)->s_inode_size)
+#define EXT2_FIRST_INO(s)               (EXT2_SB(s)->s_first_ino)
+#else
+#define EXT2_INODE_SIZE(s)      (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+                                 EXT2_GOOD_OLD_INODE_SIZE : \
+                                 (s)->s_inode_size)
+#define EXT2_FIRST_INO(s)       (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+                                 EXT2_GOOD_OLD_FIRST_INO : \
+                                 (s)->s_first_ino)
+#endif
+
+/*
+ * Macro-instructions used to manage fragments
+ */
+#define EXT2_MIN_FRAG_SIZE              1024
+#define EXT2_MAX_FRAG_SIZE              4096
+#define EXT2_MIN_FRAG_LOG_SIZE            10
+#ifdef __KERNEL__
+# define EXT2_FRAG_SIZE(s)              (EXT2_SB(s)->s_frag_size)
+# define EXT2_FRAGS_PER_BLOCK(s)        (EXT2_SB(s)->s_frags_per_block)
+#else
+# define EXT2_FRAG_SIZE(s)              (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
+# define EXT2_FRAGS_PER_BLOCK(s)        (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
+#endif
+
+/*
+ * Structure of a blocks group descriptor
+ */
+struct ext2_group_desc
+{
+        __le32  bg_block_bitmap;                /* Blocks bitmap block */
+        __le32  bg_inode_bitmap;                /* Inodes bitmap block */
+        __le32  bg_inode_table;         /* Inodes table block */
+        __le16  bg_free_blocks_count;   /* Free blocks count */
+        __le16  bg_free_inodes_count;   /* Free inodes count */
+        __le16  bg_used_dirs_count;     /* Directories count */
+        __le16  bg_pad;
+        __le32  bg_reserved[3];
+};
+
+/*
+ * Macro-instructions used to manage group descriptors
+ */
+#ifdef __KERNEL__
+# define EXT2_BLOCKS_PER_GROUP(s)       (EXT2_SB(s)->s_blocks_per_group)
+# define EXT2_DESC_PER_BLOCK(s)         (EXT2_SB(s)->s_desc_per_block)
+# define EXT2_INODES_PER_GROUP(s)       (EXT2_SB(s)->s_inodes_per_group)
+# define EXT2_DESC_PER_BLOCK_BITS(s)    (EXT2_SB(s)->s_desc_per_block_bits)
+#else
+# define EXT2_BLOCKS_PER_GROUP(s)       ((s)->s_blocks_per_group)
+# define EXT2_DESC_PER_BLOCK(s)         (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
+# define EXT2_INODES_PER_GROUP(s)       ((s)->s_inodes_per_group)
+#endif
+
+/*
+ * Constants relative to the data blocks
+ */
+#define EXT2_NDIR_BLOCKS                12
+#define EXT2_IND_BLOCK                  EXT2_NDIR_BLOCKS
+#define EXT2_DIND_BLOCK                 (EXT2_IND_BLOCK + 1)
+#define EXT2_TIND_BLOCK                 (EXT2_DIND_BLOCK + 1)
+#define EXT2_N_BLOCKS                   (EXT2_TIND_BLOCK + 1)
+
+/*
+ * Inode flags
+ */
+#define EXT2_SECRM_FL                   0x00000001 /* Secure deletion */
+#define EXT2_UNRM_FL                    0x00000002 /* Undelete */
+#define EXT2_COMPR_FL                   0x00000004 /* Compress file */
+#define EXT2_SYNC_FL                    0x00000008 /* Synchronous updates */
+#define EXT2_IMMUTABLE_FL               0x00000010 /* Immutable file */
+#define EXT2_APPEND_FL                  0x00000020 /* writes to file may only append */
+#define EXT2_NODUMP_FL                  0x00000040 /* do not dump file */
+#define EXT2_NOATIME_FL                 0x00000080 /* do not update atime */
+/* Reserved for compression usage... */
+#define EXT2_DIRTY_FL                   0x00000100
+#define EXT2_COMPRBLK_FL                0x00000200 /* One or more compressed clusters */
+#define EXT2_NOCOMP_FL                  0x00000400 /* Don't compress */
+#define EXT2_ECOMPR_FL                  0x00000800 /* Compression error */
+/* End compression flags --- maybe not all used */      
+#define EXT2_BTREE_FL                   0x00001000 /* btree format dir */
+#define EXT2_INDEX_FL                   0x00001000 /* hash-indexed directory */
+#define EXT2_IMAGIC_FL                  0x00002000 /* AFS directory */
+#define EXT2_JOURNAL_DATA_FL            0x00004000 /* Reserved for ext3 */
+#define EXT2_NOTAIL_FL                  0x00008000 /* file tail should not be merged */
+#define EXT2_DIRSYNC_FL                 0x00010000 /* dirsync behaviour (directories only) */
+#define EXT2_TOPDIR_FL                  0x00020000 /* Top of directory hierarchies*/
+#define EXT2_RESERVED_FL                0x80000000 /* reserved for ext2 lib */
+
+#define EXT2_FL_USER_VISIBLE            0x0003DFFF /* User visible flags */
+#define EXT2_FL_USER_MODIFIABLE         0x000380FF /* User modifiable flags */
+
+/*
+ * ioctl commands
+ */
+#define EXT2_IOC_GETFLAGS               _IOR('f', 1, long)
+#define EXT2_IOC_SETFLAGS               _IOW('f', 2, long)
+#define EXT2_IOC_GETVERSION             _IOR('v', 1, long)
+#define EXT2_IOC_SETVERSION             _IOW('v', 2, long)
+
+/*
+ * Structure of an inode on the disk
+ */
+struct ext2_inode {
+        __le16  i_mode;         /* File mode */
+        __le16  i_uid;          /* Low 16 bits of Owner Uid */
+        __le32  i_size;         /* Size in bytes */
+        __le32  i_atime;        /* Access time */
+        __le32  i_ctime;        /* Creation time */
+        __le32  i_mtime;        /* Modification time */
+        __le32  i_dtime;        /* Deletion Time */
+        __le16  i_gid;          /* Low 16 bits of Group Id */
+        __le16  i_links_count;  /* Links count */
+        __le32  i_blocks;       /* Blocks count */
+        __le32  i_flags;        /* File flags */
+        union {
+                struct {
+                        __le32  l_i_reserved1;
+                } linux1;
+                struct {
+                        __le32  h_i_translator;
+                } hurd1;
+                struct {
+                        __le32  m_i_reserved1;
+                } masix1;
+        } osd1;                         /* OS dependent 1 */
+        __le32  i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
+        __le32  i_generation;   /* File version (for NFS) */
+        __le32  i_file_acl;     /* File ACL */
+        __le32  i_dir_acl;      /* Directory ACL */
+        __le32  i_faddr;        /* Fragment address */
+        union {
+                struct {
+                        __u8    l_i_frag;       /* Fragment number */
+                        __u8    l_i_fsize;      /* Fragment size */
+                        __u16   i_pad1;
+                        __le16  l_i_uid_high;   /* these 2 fields    */
+                        __le16  l_i_gid_high;   /* were reserved2[0] */
+                        __u32   l_i_reserved2;
+                } linux2;
+                struct {
+                        __u8    h_i_frag;       /* Fragment number */
+                        __u8    h_i_fsize;      /* Fragment size */
+                        __le16  h_i_mode_high;
+                        __le16  h_i_uid_high;
+                        __le16  h_i_gid_high;
+                        __le32  h_i_author;
+                } hurd2;
+                struct {
+                        __u8    m_i_frag;       /* Fragment number */
+                        __u8    m_i_fsize;      /* Fragment size */
+                        __u16   m_pad1;
+                        __u32   m_i_reserved2[2];
+                } masix2;
+        } osd2;                         /* OS dependent 2 */
+};
+
+#define i_size_high     i_dir_acl
+
+#if defined(__KERNEL__) || defined(__linux__)
+#define i_reserved1     osd1.linux1.l_i_reserved1
+#define i_frag          osd2.linux2.l_i_frag
+#define i_fsize         osd2.linux2.l_i_fsize
+#define i_uid_low       i_uid
+#define i_gid_low       i_gid
+#define i_uid_high      osd2.linux2.l_i_uid_high
+#define i_gid_high      osd2.linux2.l_i_gid_high
+#define i_reserved2     osd2.linux2.l_i_reserved2
+#endif
+
+#ifdef  __hurd__
+#define i_translator    osd1.hurd1.h_i_translator
+#define i_frag          osd2.hurd2.h_i_frag;
+#define i_fsize         osd2.hurd2.h_i_fsize;
+#define i_uid_high      osd2.hurd2.h_i_uid_high
+#define i_gid_high      osd2.hurd2.h_i_gid_high
+#define i_author        osd2.hurd2.h_i_author
+#endif
+
+#ifdef  __masix__
+#define i_reserved1     osd1.masix1.m_i_reserved1
+#define i_frag          osd2.masix2.m_i_frag
+#define i_fsize         osd2.masix2.m_i_fsize
+#define i_reserved2     osd2.masix2.m_i_reserved2
+#endif
+
+/*
+ * File system states
+ */
+#define EXT2_VALID_FS                   0x0001  /* Unmounted cleanly */
+#define EXT2_ERROR_FS                   0x0002  /* Errors detected */
+
+/*
+ * Mount flags
+ */
+#define EXT2_MOUNT_CHECK                0x0001  /* Do mount-time checks */
+#define EXT2_MOUNT_OLDALLOC             0x0002  /* Don't use the new Orlov allocator */
+#define EXT2_MOUNT_GRPID                0x0004  /* Create files with directory's group */
+#define EXT2_MOUNT_DEBUG                0x0008  /* Some debugging messages */
+#define EXT2_MOUNT_ERRORS_CONT          0x0010  /* Continue on errors */
+#define EXT2_MOUNT_ERRORS_RO            0x0020  /* Remount fs ro on errors */
+#define EXT2_MOUNT_ERRORS_PANIC         0x0040  /* Panic on errors */
+#define EXT2_MOUNT_MINIX_DF             0x0080  /* Mimics the Minix statfs */
+#define EXT2_MOUNT_NOBH                 0x0100  /* No buffer_heads */
+#define EXT2_MOUNT_NO_UID32             0x0200  /* Disable 32-bit UIDs */
+#define EXT2_MOUNT_XATTR_USER           0x4000  /* Extended user attributes */
+#define EXT2_MOUNT_POSIX_ACL            0x8000  /* POSIX Access Control Lists */
+
+#define clear_opt(o, opt)               o &= ~EXT2_MOUNT_##opt
+#define set_opt(o, opt)                 o |= EXT2_MOUNT_##opt
+#define test_opt(sb, opt)               (EXT2_SB(sb)->s_mount_opt & \
+                                         EXT2_MOUNT_##opt)
+/*
+ * Maximal mount counts between two filesystem checks
+ */
+#define EXT2_DFL_MAX_MNT_COUNT          20      /* Allow 20 mounts */
+#define EXT2_DFL_CHECKINTERVAL          0       /* Don't use interval check */
+
+/*
+ * Behaviour when detecting errors
+ */
+#define EXT2_ERRORS_CONTINUE            1       /* Continue execution */
+#define EXT2_ERRORS_RO                  2       /* Remount fs read-only */
+#define EXT2_ERRORS_PANIC               3       /* Panic */
+#define EXT2_ERRORS_DEFAULT             EXT2_ERRORS_CONTINUE
+
+/*
+ * Structure of the super block
+ */
+struct ext2_super_block {
+        __le32  s_inodes_count;         /* Inodes count */
+        __le32  s_blocks_count;         /* Blocks count */
+        __le32  s_r_blocks_count;       /* Reserved blocks count */
+        __le32  s_free_blocks_count;    /* Free blocks count */
+        __le32  s_free_inodes_count;    /* Free inodes count */
+        __le32  s_first_data_block;     /* First Data Block */
+        __le32  s_log_block_size;       /* Block size */
+        __le32  s_log_frag_size;        /* Fragment size */
+        __le32  s_blocks_per_group;     /* # Blocks per group */
+        __le32  s_frags_per_group;      /* # Fragments per group */
+        __le32  s_inodes_per_group;     /* # Inodes per group */
+        __le32  s_mtime;                /* Mount time */
+        __le32  s_wtime;                /* Write time */
+        __le16  s_mnt_count;            /* Mount count */
+        __le16  s_max_mnt_count;        /* Maximal mount count */
+        __le16  s_magic;                /* Magic signature */
+        __le16  s_state;                /* File system state */
+        __le16  s_errors;               /* Behaviour when detecting errors */
+        __le16  s_minor_rev_level;      /* minor revision level */
+        __le32  s_lastcheck;            /* time of last check */
+        __le32  s_checkinterval;        /* max. time between checks */
+        __le32  s_creator_os;           /* OS */
+        __le32  s_rev_level;            /* Revision level */
+        __le16  s_def_resuid;           /* Default uid for reserved blocks */
+        __le16  s_def_resgid;           /* Default gid for reserved blocks */
+        /*
+         * These fields are for EXT2_DYNAMIC_REV superblocks only.
+         *
+         * Note: the difference between the compatible feature set and
+         * the incompatible feature set is that if there is a bit set
+         * in the incompatible feature set that the kernel doesn't
+         * know about, it should refuse to mount the filesystem.
+         * 
+         * e2fsck's requirements are more strict; if it doesn't know
+         * about a feature in either the compatible or incompatible
+         * feature set, it must abort and not try to meddle with
+         * things it doesn't understand...
+         */
+        __le32  s_first_ino;            /* First non-reserved inode */
+        __le16   s_inode_size;          /* size of inode structure */
+        __le16  s_block_group_nr;       /* block group # of this superblock */
+        __le32  s_feature_compat;       /* compatible feature set */
+        __le32  s_feature_incompat;     /* incompatible feature set */
+        __le32  s_feature_ro_compat;    /* readonly-compatible feature set */
+        __u8    s_uuid[16];             /* 128-bit uuid for volume */
+        char    s_volume_name[16];      /* volume name */
+        char    s_last_mounted[64];     /* directory where last mounted */
+        __le32  s_algorithm_usage_bitmap; /* For compression */
+        /*
+         * Performance hints.  Directory preallocation should only
+         * happen if the EXT2_COMPAT_PREALLOC flag is on.
+         */
+        __u8    s_prealloc_blocks;      /* Nr of blocks to try to preallocate*/
+        __u8    s_prealloc_dir_blocks;  /* Nr to preallocate for dirs */
+        __u16   s_padding1;
+        /*
+         * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
+         */
+        __u8    s_journal_uuid[16];     /* uuid of journal superblock */
+        __u32   s_journal_inum;         /* inode number of journal file */
+        __u32   s_journal_dev;          /* device number of journal file */
+        __u32   s_last_orphan;          /* start of list of inodes to delete */
+        __u32   s_hash_seed[4];         /* HTREE hash seed */
+        __u8    s_def_hash_version;     /* Default hash version to use */
+        __u8    s_reserved_char_pad;
+        __u16   s_reserved_word_pad;
+        __le32  s_default_mount_opts;
+        __le32  s_first_meta_bg;        /* First metablock block group */
+        __u32   s_reserved[190];        /* Padding to the end of the block */
+};
+
+/*
+ * Codes for operating systems
+ */
+#define EXT2_OS_LINUX           0
+#define EXT2_OS_HURD            1
+#define EXT2_OS_MASIX           2
+#define EXT2_OS_FREEBSD         3
+#define EXT2_OS_LITES           4
+
+/*
+ * Revision levels
+ */
+#define EXT2_GOOD_OLD_REV       0       /* The good old (original) format */
+#define EXT2_DYNAMIC_REV        1       /* V2 format w/ dynamic inode sizes */
+
+#define EXT2_CURRENT_REV        EXT2_GOOD_OLD_REV
+#define EXT2_MAX_SUPP_REV       EXT2_DYNAMIC_REV
+
+#define EXT2_GOOD_OLD_INODE_SIZE 128
+
+/*
+ * Feature set definitions
+ */
+
+#define EXT2_HAS_COMPAT_FEATURE(sb,mask)                        \
+        ( EXT2_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
+#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask)                     \
+        ( EXT2_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
+#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask)                      \
+        ( EXT2_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
+#define EXT2_SET_COMPAT_FEATURE(sb,mask)                        \
+        EXT2_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
+#define EXT2_SET_RO_COMPAT_FEATURE(sb,mask)                     \
+        EXT2_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
+#define EXT2_SET_INCOMPAT_FEATURE(sb,mask)                      \
+        EXT2_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
+#define EXT2_CLEAR_COMPAT_FEATURE(sb,mask)                      \
+        EXT2_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
+#define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask)                   \
+        EXT2_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
+#define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask)                    \
+        EXT2_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
+
+#define EXT2_FEATURE_COMPAT_DIR_PREALLOC        0x0001
+#define EXT2_FEATURE_COMPAT_IMAGIC_INODES       0x0002
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL         0x0004
+#define EXT2_FEATURE_COMPAT_EXT_ATTR            0x0008
+#define EXT2_FEATURE_COMPAT_RESIZE_INO          0x0010
+#define EXT2_FEATURE_COMPAT_DIR_INDEX           0x0020
+#define EXT2_FEATURE_COMPAT_ANY                 0xffffffff
+
+#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER     0x0001
+#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE       0x0002
+#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR        0x0004
+#define EXT2_FEATURE_RO_COMPAT_ANY              0xffffffff
+
+#define EXT2_FEATURE_INCOMPAT_COMPRESSION       0x0001
+#define EXT2_FEATURE_INCOMPAT_FILETYPE          0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER           0x0004
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV       0x0008
+#define EXT2_FEATURE_INCOMPAT_META_BG           0x0010
+#define EXT2_FEATURE_INCOMPAT_ANY               0xffffffff
+
+#define EXT2_FEATURE_COMPAT_SUPP        EXT2_FEATURE_COMPAT_EXT_ATTR
+#define EXT2_FEATURE_INCOMPAT_SUPP      (EXT2_FEATURE_INCOMPAT_FILETYPE| \
+                                         EXT2_FEATURE_INCOMPAT_META_BG)
+#define EXT2_FEATURE_RO_COMPAT_SUPP     (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
+                                         EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
+                                         EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
+#define EXT2_FEATURE_RO_COMPAT_UNSUPPORTED      ~EXT2_FEATURE_RO_COMPAT_SUPP
+#define EXT2_FEATURE_INCOMPAT_UNSUPPORTED       ~EXT2_FEATURE_INCOMPAT_SUPP
+
+/*
+ * Default values for user and/or group using reserved blocks
+ */
+#define EXT2_DEF_RESUID         0
+#define EXT2_DEF_RESGID         0
+
+/*
+ * Default mount options
+ */
+#define EXT2_DEFM_DEBUG         0x0001
+#define EXT2_DEFM_BSDGROUPS     0x0002
+#define EXT2_DEFM_XATTR_USER    0x0004
+#define EXT2_DEFM_ACL           0x0008
+#define EXT2_DEFM_UID16         0x0010
+    /* Not used by ext2, but reserved for use by ext3 */
+#define EXT3_DEFM_JMODE         0x0060 
+#define EXT3_DEFM_JMODE_DATA    0x0020
+#define EXT3_DEFM_JMODE_ORDERED 0x0040
+#define EXT3_DEFM_JMODE_WBACK   0x0060
+
+/*
+ * Structure of a directory entry
+ */
+#define EXT2_NAME_LEN 255
+
+struct ext2_dir_entry {
+        __le32  inode;                  /* Inode number */
+        __le16  rec_len;                /* Directory entry length */
+        __le16  name_len;               /* Name length */
+        char    name[EXT2_NAME_LEN];    /* File name */
+};
+
+/*
+ * The new version of the directory entry.  Since EXT2 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct ext2_dir_entry_2 {
+        __le32  inode;                  /* Inode number */
+        __le16  rec_len;                /* Directory entry length */
+        __u8    name_len;               /* Name length */
+        __u8    file_type;
+        char    name[EXT2_NAME_LEN];    /* File name */
+};
+
+/*
+ * Ext2 directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+enum {
+        EXT2_FT_UNKNOWN,
+        EXT2_FT_REG_FILE,
+        EXT2_FT_DIR,
+        EXT2_FT_CHRDEV,
+        EXT2_FT_BLKDEV,
+        EXT2_FT_FIFO,
+        EXT2_FT_SOCK,
+        EXT2_FT_SYMLINK,
+        EXT2_FT_MAX
+};
+
+/*
+ * EXT2_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 4
+ */
+#define EXT2_DIR_PAD                    4
+#define EXT2_DIR_ROUND                  (EXT2_DIR_PAD - 1)
+#define EXT2_DIR_REC_LEN(name_len)      (((name_len) + 8 + EXT2_DIR_ROUND) & \
+                                         ~EXT2_DIR_ROUND)
+
+#endif  /* _LINUX_EXT2_FS_H */
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
new file mode 100644
index 000000000000..4eda0ed76a48
--- /dev/null
+++ b/include/linux/ext2_fs_sb.h
@@ -0,0 +1,58 @@
+/*
+ *  linux/include/linux/ext2_fs_sb.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs_sb.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT2_FS_SB
+#define _LINUX_EXT2_FS_SB
+
+#include <linux/blockgroup_lock.h>
+#include <linux/percpu_counter.h>
+
+/*
+ * second extended-fs super-block data in memory
+ */
+struct ext2_sb_info {
+        unsigned long s_frag_size;      /* Size of a fragment in bytes */
+        unsigned long s_frags_per_block;/* Number of fragments per block */
+        unsigned long s_inodes_per_block;/* Number of inodes per block */
+        unsigned long s_frags_per_group;/* Number of fragments in a group */
+        unsigned long s_blocks_per_group;/* Number of blocks in a group */
+        unsigned long s_inodes_per_group;/* Number of inodes in a group */
+        unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
+        unsigned long s_gdb_count;      /* Number of group descriptor blocks */
+        unsigned long s_desc_per_block; /* Number of group descriptors per block */
+        unsigned long s_groups_count;   /* Number of groups in the fs */
+        struct buffer_head * s_sbh;     /* Buffer containing the super block */
+        struct ext2_super_block * s_es; /* Pointer to the super block in the buffer */
+        struct buffer_head ** s_group_desc;
+        unsigned long  s_mount_opt;
+        uid_t s_resuid;
+        gid_t s_resgid;
+        unsigned short s_mount_state;
+        unsigned short s_pad;
+        int s_addr_per_block_bits;
+        int s_desc_per_block_bits;
+        int s_inode_size;
+        int s_first_ino;
+        spinlock_t s_next_gen_lock;
+        u32 s_next_generation;
+        unsigned long s_dir_count;
+        u8 *s_debts;
+        struct percpu_counter s_freeblocks_counter;
+        struct percpu_counter s_freeinodes_counter;
+        struct percpu_counter s_dirs_counter;
+        struct blockgroup_lock s_blockgroup_lock;
+};
+
+#endif  /* _LINUX_EXT2_FS_SB */
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
new file mode 100644
index 000000000000..74ad31781e3e
--- /dev/null
+++ b/include/linux/ext3_fs.h
@@ -0,0 +1,830 @@
+/*
+ *  linux/include/linux/ext3_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT3_FS_H
+#define _LINUX_EXT3_FS_H
+
+#include <linux/types.h>
+#include <linux/ext3_fs_i.h>
+#include <linux/ext3_fs_sb.h>
+
+
+struct statfs;
+
+/*
+ * The second extended filesystem constants/structures
+ */
+
+/*
+ * Define EXT3FS_DEBUG to produce debug messages
+ */
+#undef EXT3FS_DEBUG
+
+/*
+ * Define EXT3_RESERVATION to reserve data blocks for expanding files
+ */
+#define EXT3_DEFAULT_RESERVE_BLOCKS     8
+#define EXT3_MAX_RESERVE_BLOCKS         1024
+#define EXT3_RESERVE_WINDOW_NOT_ALLOCATED 0
+/*
+ * Always enable hashed directories
+ */
+#define CONFIG_EXT3_INDEX
+
+/*
+ * Debug code
+ */
+#ifdef EXT3FS_DEBUG
+#define ext3_debug(f, a...)                                             \
+        do {                                                            \
+                printk (KERN_DEBUG "EXT3-fs DEBUG (%s, %d): %s:",       \
+                        __FILE__, __LINE__, __FUNCTION__);              \
+                printk (KERN_DEBUG f, ## a);                            \
+        } while (0)
+#else
+#define ext3_debug(f, a...)     do {} while (0)
+#endif
+
+/*
+ * Special inodes numbers
+ */
+#define EXT3_BAD_INO             1      /* Bad blocks inode */
+#define EXT3_ROOT_INO            2      /* Root inode */
+#define EXT3_BOOT_LOADER_INO     5      /* Boot loader inode */
+#define EXT3_UNDEL_DIR_INO       6      /* Undelete directory inode */
+#define EXT3_RESIZE_INO          7      /* Reserved group descriptors inode */
+#define EXT3_JOURNAL_INO         8      /* Journal inode */
+
+/* First non-reserved inode for old ext3 filesystems */
+#define EXT3_GOOD_OLD_FIRST_INO 11
+
+/*
+ * The second extended file system magic number
+ */
+#define EXT3_SUPER_MAGIC        0xEF53
+
+/*
+ * Maximal count of links to a file
+ */
+#define EXT3_LINK_MAX           32000
+
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT3_MIN_BLOCK_SIZE             1024
+#define EXT3_MAX_BLOCK_SIZE             4096
+#define EXT3_MIN_BLOCK_LOG_SIZE           10
+#ifdef __KERNEL__
+# define EXT3_BLOCK_SIZE(s)             ((s)->s_blocksize)
+#else
+# define EXT3_BLOCK_SIZE(s)             (EXT3_MIN_BLOCK_SIZE << (s)->s_log_block_size)
+#endif
+#define EXT3_ADDR_PER_BLOCK(s)          (EXT3_BLOCK_SIZE(s) / sizeof (__u32))
+#ifdef __KERNEL__
+# define EXT3_BLOCK_SIZE_BITS(s)        ((s)->s_blocksize_bits)
+#else
+# define EXT3_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
+#endif
+#ifdef __KERNEL__
+#define EXT3_ADDR_PER_BLOCK_BITS(s)     (EXT3_SB(s)->s_addr_per_block_bits)
+#define EXT3_INODE_SIZE(s)              (EXT3_SB(s)->s_inode_size)
+#define EXT3_FIRST_INO(s)               (EXT3_SB(s)->s_first_ino)
+#else
+#define EXT3_INODE_SIZE(s)      (((s)->s_rev_level == EXT3_GOOD_OLD_REV) ? \
+                                 EXT3_GOOD_OLD_INODE_SIZE : \
+                                 (s)->s_inode_size)
+#define EXT3_FIRST_INO(s)       (((s)->s_rev_level == EXT3_GOOD_OLD_REV) ? \
+                                 EXT3_GOOD_OLD_FIRST_INO : \
+                                 (s)->s_first_ino)
+#endif
+
+/*
+ * Macro-instructions used to manage fragments
+ */
+#define EXT3_MIN_FRAG_SIZE              1024
+#define EXT3_MAX_FRAG_SIZE              4096
+#define EXT3_MIN_FRAG_LOG_SIZE            10
+#ifdef __KERNEL__
+# define EXT3_FRAG_SIZE(s)              (EXT3_SB(s)->s_frag_size)
+# define EXT3_FRAGS_PER_BLOCK(s)        (EXT3_SB(s)->s_frags_per_block)
+#else
+# define EXT3_FRAG_SIZE(s)              (EXT3_MIN_FRAG_SIZE << (s)->s_log_frag_size)
+# define EXT3_FRAGS_PER_BLOCK(s)        (EXT3_BLOCK_SIZE(s) / EXT3_FRAG_SIZE(s))
+#endif
+
+/*
+ * Structure of a blocks group descriptor
+ */
+struct ext3_group_desc
+{
+        __le32  bg_block_bitmap;                /* Blocks bitmap block */
+        __le32  bg_inode_bitmap;                /* Inodes bitmap block */
+        __le32  bg_inode_table;         /* Inodes table block */
+        __le16  bg_free_blocks_count;   /* Free blocks count */
+        __le16  bg_free_inodes_count;   /* Free inodes count */
+        __le16  bg_used_dirs_count;     /* Directories count */
+        __u16   bg_pad;
+        __le32  bg_reserved[3];
+};
+
+/*
+ * Macro-instructions used to manage group descriptors
+ */
+#ifdef __KERNEL__
+# define EXT3_BLOCKS_PER_GROUP(s)       (EXT3_SB(s)->s_blocks_per_group)
+# define EXT3_DESC_PER_BLOCK(s)         (EXT3_SB(s)->s_desc_per_block)
+# define EXT3_INODES_PER_GROUP(s)       (EXT3_SB(s)->s_inodes_per_group)
+# define EXT3_DESC_PER_BLOCK_BITS(s)    (EXT3_SB(s)->s_desc_per_block_bits)
+#else
+# define EXT3_BLOCKS_PER_GROUP(s)       ((s)->s_blocks_per_group)
+# define EXT3_DESC_PER_BLOCK(s)         (EXT3_BLOCK_SIZE(s) / sizeof (struct ext3_group_desc))
+# define EXT3_INODES_PER_GROUP(s)       ((s)->s_inodes_per_group)
+#endif
+
+/*
+ * Constants relative to the data blocks
+ */
+#define EXT3_NDIR_BLOCKS                12
+#define EXT3_IND_BLOCK                  EXT3_NDIR_BLOCKS
+#define EXT3_DIND_BLOCK                 (EXT3_IND_BLOCK + 1)
+#define EXT3_TIND_BLOCK                 (EXT3_DIND_BLOCK + 1)
+#define EXT3_N_BLOCKS                   (EXT3_TIND_BLOCK + 1)
+
+/*
+ * Inode flags
+ */
+#define EXT3_SECRM_FL                   0x00000001 /* Secure deletion */
+#define EXT3_UNRM_FL                    0x00000002 /* Undelete */
+#define EXT3_COMPR_FL                   0x00000004 /* Compress file */
+#define EXT3_SYNC_FL                    0x00000008 /* Synchronous updates */
+#define EXT3_IMMUTABLE_FL               0x00000010 /* Immutable file */
+#define EXT3_APPEND_FL                  0x00000020 /* writes to file may only append */
+#define EXT3_NODUMP_FL                  0x00000040 /* do not dump file */
+#define EXT3_NOATIME_FL                 0x00000080 /* do not update atime */
+/* Reserved for compression usage... */
+#define EXT3_DIRTY_FL                   0x00000100
+#define EXT3_COMPRBLK_FL                0x00000200 /* One or more compressed clusters */
+#define EXT3_NOCOMPR_FL                 0x00000400 /* Don't compress */
+#define EXT3_ECOMPR_FL                  0x00000800 /* Compression error */
+/* End compression flags --- maybe not all used */
+#define EXT3_INDEX_FL                   0x00001000 /* hash-indexed directory */
+#define EXT3_IMAGIC_FL                  0x00002000 /* AFS directory */
+#define EXT3_JOURNAL_DATA_FL            0x00004000 /* file data should be journaled */
+#define EXT3_NOTAIL_FL                  0x00008000 /* file tail should not be merged */
+#define EXT3_DIRSYNC_FL                 0x00010000 /* dirsync behaviour (directories only) */
+#define EXT3_TOPDIR_FL                  0x00020000 /* Top of directory hierarchies*/
+#define EXT3_RESERVED_FL                0x80000000 /* reserved for ext3 lib */
+
+#define EXT3_FL_USER_VISIBLE            0x0003DFFF /* User visible flags */
+#define EXT3_FL_USER_MODIFIABLE         0x000380FF /* User modifiable flags */
+
+/*
+ * Inode dynamic state flags
+ */
+#define EXT3_STATE_JDATA                0x00000001 /* journaled data exists */
+#define EXT3_STATE_NEW                  0x00000002 /* inode is newly created */
+#define EXT3_STATE_XATTR                0x00000004 /* has in-inode xattrs */
+
+/* Used to pass group descriptor data when online resize is done */
+struct ext3_new_group_input {
+        __u32 group;            /* Group number for this data */
+        __u32 block_bitmap;     /* Absolute block number of block bitmap */
+        __u32 inode_bitmap;     /* Absolute block number of inode bitmap */
+        __u32 inode_table;      /* Absolute block number of inode table start */
+        __u32 blocks_count;     /* Total number of blocks in this group */
+        __u16 reserved_blocks;  /* Number of reserved blocks in this group */
+        __u16 unused;
+};
+
+/* The struct ext3_new_group_input in kernel space, with free_blocks_count */
+struct ext3_new_group_data {
+        __u32 group;
+        __u32 block_bitmap;
+        __u32 inode_bitmap;
+        __u32 inode_table;
+        __u32 blocks_count;
+        __u16 reserved_blocks;
+        __u16 unused;
+        __u32 free_blocks_count;
+};
+
+
+/*
+ * ioctl commands
+ */
+#define EXT3_IOC_GETFLAGS               _IOR('f', 1, long)
+#define EXT3_IOC_SETFLAGS               _IOW('f', 2, long)
+#define EXT3_IOC_GETVERSION             _IOR('f', 3, long)
+#define EXT3_IOC_SETVERSION             _IOW('f', 4, long)
+#define EXT3_IOC_GROUP_EXTEND           _IOW('f', 7, unsigned long)
+#define EXT3_IOC_GROUP_ADD              _IOW('f', 8,struct ext3_new_group_input)
+#define EXT3_IOC_GETVERSION_OLD         _IOR('v', 1, long)
+#define EXT3_IOC_SETVERSION_OLD         _IOW('v', 2, long)
+#ifdef CONFIG_JBD_DEBUG
+#define EXT3_IOC_WAIT_FOR_READONLY      _IOR('f', 99, long)
+#endif
+#define EXT3_IOC_GETRSVSZ               _IOR('f', 5, long)
+#define EXT3_IOC_SETRSVSZ               _IOW('f', 6, long)
+
+/*
+ * Structure of an inode on the disk
+ */
+struct ext3_inode {
+        __le16  i_mode;         /* File mode */
+        __le16  i_uid;          /* Low 16 bits of Owner Uid */
+        __le32  i_size;         /* Size in bytes */
+        __le32  i_atime;        /* Access time */
+        __le32  i_ctime;        /* Creation time */
+        __le32  i_mtime;        /* Modification time */
+        __le32  i_dtime;        /* Deletion Time */
+        __le16  i_gid;          /* Low 16 bits of Group Id */
+        __le16  i_links_count;  /* Links count */
+        __le32  i_blocks;       /* Blocks count */
+        __le32  i_flags;        /* File flags */
+        union {
+                struct {
+                        __u32  l_i_reserved1;
+                } linux1;
+                struct {
+                        __u32  h_i_translator;
+                } hurd1;
+                struct {
+                        __u32  m_i_reserved1;
+                } masix1;
+        } osd1;                         /* OS dependent 1 */
+        __le32  i_block[EXT3_N_BLOCKS];/* Pointers to blocks */
+        __le32  i_generation;   /* File version (for NFS) */
+        __le32  i_file_acl;     /* File ACL */
+        __le32  i_dir_acl;      /* Directory ACL */
+        __le32  i_faddr;        /* Fragment address */
+        union {
+                struct {
+                        __u8    l_i_frag;       /* Fragment number */
+                        __u8    l_i_fsize;      /* Fragment size */
+                        __u16   i_pad1;
+                        __le16  l_i_uid_high;   /* these 2 fields    */
+                        __le16  l_i_gid_high;   /* were reserved2[0] */
+                        __u32   l_i_reserved2;
+                } linux2;
+                struct {
+                        __u8    h_i_frag;       /* Fragment number */
+                        __u8    h_i_fsize;      /* Fragment size */
+                        __u16   h_i_mode_high;
+                        __u16   h_i_uid_high;
+                        __u16   h_i_gid_high;
+                        __u32   h_i_author;
+                } hurd2;
+                struct {
+                        __u8    m_i_frag;       /* Fragment number */
+                        __u8    m_i_fsize;      /* Fragment size */
+                        __u16   m_pad1;
+                        __u32   m_i_reserved2[2];
+                } masix2;
+        } osd2;                         /* OS dependent 2 */
+        __le16  i_extra_isize;
+        __le16  i_pad1;
+};
+
+#define i_size_high     i_dir_acl
+
+#if defined(__KERNEL__) || defined(__linux__)
+#define i_reserved1     osd1.linux1.l_i_reserved1
+#define i_frag          osd2.linux2.l_i_frag
+#define i_fsize         osd2.linux2.l_i_fsize
+#define i_uid_low       i_uid
+#define i_gid_low       i_gid
+#define i_uid_high      osd2.linux2.l_i_uid_high
+#define i_gid_high      osd2.linux2.l_i_gid_high
+#define i_reserved2     osd2.linux2.l_i_reserved2
+
+#elif defined(__GNU__)
+
+#define i_translator    osd1.hurd1.h_i_translator
+#define i_frag          osd2.hurd2.h_i_frag;
+#define i_fsize         osd2.hurd2.h_i_fsize;
+#define i_uid_high      osd2.hurd2.h_i_uid_high
+#define i_gid_high      osd2.hurd2.h_i_gid_high
+#define i_author        osd2.hurd2.h_i_author
+
+#elif defined(__masix__)
+
+#define i_reserved1     osd1.masix1.m_i_reserved1
+#define i_frag          osd2.masix2.m_i_frag
+#define i_fsize         osd2.masix2.m_i_fsize
+#define i_reserved2     osd2.masix2.m_i_reserved2
+
+#endif /* defined(__KERNEL__) || defined(__linux__) */
+
+/*
+ * File system states
+ */
+#define EXT3_VALID_FS                   0x0001  /* Unmounted cleanly */
+#define EXT3_ERROR_FS                   0x0002  /* Errors detected */
+#define EXT3_ORPHAN_FS                  0x0004  /* Orphans being recovered */
+
+/*
+ * Mount flags
+ */
+#define EXT3_MOUNT_CHECK                0x00001 /* Do mount-time checks */
+#define EXT3_MOUNT_OLDALLOC             0x00002  /* Don't use the new Orlov allocator */
+#define EXT3_MOUNT_GRPID                0x00004 /* Create files with directory's group */
+#define EXT3_MOUNT_DEBUG                0x00008 /* Some debugging messages */
+#define EXT3_MOUNT_ERRORS_CONT          0x00010 /* Continue on errors */
+#define EXT3_MOUNT_ERRORS_RO            0x00020 /* Remount fs ro on errors */
+#define EXT3_MOUNT_ERRORS_PANIC         0x00040 /* Panic on errors */
+#define EXT3_MOUNT_MINIX_DF             0x00080 /* Mimics the Minix statfs */
+#define EXT3_MOUNT_NOLOAD               0x00100 /* Don't use existing journal*/
+#define EXT3_MOUNT_ABORT                0x00200 /* Fatal error detected */
+#define EXT3_MOUNT_DATA_FLAGS           0x00C00 /* Mode for data writes: */
+#define EXT3_MOUNT_JOURNAL_DATA         0x00400 /* Write data to journal */
+#define EXT3_MOUNT_ORDERED_DATA         0x00800 /* Flush data before commit */
+#define EXT3_MOUNT_WRITEBACK_DATA       0x00C00 /* No data ordering */
+#define EXT3_MOUNT_UPDATE_JOURNAL       0x01000 /* Update the journal format */
+#define EXT3_MOUNT_NO_UID32             0x02000  /* Disable 32-bit UIDs */
+#define EXT3_MOUNT_XATTR_USER           0x04000 /* Extended user attributes */
+#define EXT3_MOUNT_POSIX_ACL            0x08000 /* POSIX Access Control Lists */
+#define EXT3_MOUNT_RESERVATION          0x10000 /* Preallocation */
+#define EXT3_MOUNT_BARRIER              0x20000 /* Use block barriers */
+#define EXT3_MOUNT_NOBH                 0x40000 /* No bufferheads */
+
+/* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
+#ifndef _LINUX_EXT2_FS_H
+#define clear_opt(o, opt)               o &= ~EXT3_MOUNT_##opt
+#define set_opt(o, opt)                 o |= EXT3_MOUNT_##opt
+#define test_opt(sb, opt)               (EXT3_SB(sb)->s_mount_opt & \
+                                         EXT3_MOUNT_##opt)
+#else
+#define EXT2_MOUNT_NOLOAD               EXT3_MOUNT_NOLOAD
+#define EXT2_MOUNT_ABORT                EXT3_MOUNT_ABORT
+#define EXT2_MOUNT_DATA_FLAGS           EXT3_MOUNT_DATA_FLAGS
+#endif
+
+#define ext3_set_bit                    ext2_set_bit
+#define ext3_set_bit_atomic             ext2_set_bit_atomic
+#define ext3_clear_bit                  ext2_clear_bit
+#define ext3_clear_bit_atomic           ext2_clear_bit_atomic
+#define ext3_test_bit                   ext2_test_bit
+#define ext3_find_first_zero_bit        ext2_find_first_zero_bit
+#define ext3_find_next_zero_bit         ext2_find_next_zero_bit
+
+/*
+ * Maximal mount counts between two filesystem checks
+ */
+#define EXT3_DFL_MAX_MNT_COUNT          20      /* Allow 20 mounts */
+#define EXT3_DFL_CHECKINTERVAL          0       /* Don't use interval check */
+
+/*
+ * Behaviour when detecting errors
+ */
+#define EXT3_ERRORS_CONTINUE            1       /* Continue execution */
+#define EXT3_ERRORS_RO                  2       /* Remount fs read-only */
+#define EXT3_ERRORS_PANIC               3       /* Panic */
+#define EXT3_ERRORS_DEFAULT             EXT3_ERRORS_CONTINUE
+
+/*
+ * Structure of the super block
+ */
+struct ext3_super_block {
+/*00*/  __le32  s_inodes_count;         /* Inodes count */
+        __le32  s_blocks_count;         /* Blocks count */
+        __le32  s_r_blocks_count;       /* Reserved blocks count */
+        __le32  s_free_blocks_count;    /* Free blocks count */
+/*10*/  __le32  s_free_inodes_count;    /* Free inodes count */
+        __le32  s_first_data_block;     /* First Data Block */
+        __le32  s_log_block_size;       /* Block size */
+        __le32  s_log_frag_size;        /* Fragment size */
+/*20*/  __le32  s_blocks_per_group;     /* # Blocks per group */
+        __le32  s_frags_per_group;      /* # Fragments per group */
+        __le32  s_inodes_per_group;     /* # Inodes per group */
+        __le32  s_mtime;                /* Mount time */
+/*30*/  __le32  s_wtime;                /* Write time */
+        __le16  s_mnt_count;            /* Mount count */
+        __le16  s_max_mnt_count;        /* Maximal mount count */
+        __le16  s_magic;                /* Magic signature */
+        __le16  s_state;                /* File system state */
+        __le16  s_errors;               /* Behaviour when detecting errors */
+        __le16  s_minor_rev_level;      /* minor revision level */
+/*40*/  __le32  s_lastcheck;            /* time of last check */
+        __le32  s_checkinterval;        /* max. time between checks */
+        __le32  s_creator_os;           /* OS */
+        __le32  s_rev_level;            /* Revision level */
+/*50*/  __le16  s_def_resuid;           /* Default uid for reserved blocks */
+        __le16  s_def_resgid;           /* Default gid for reserved blocks */
+        /*
+         * These fields are for EXT3_DYNAMIC_REV superblocks only.
+         *
+         * Note: the difference between the compatible feature set and
+         * the incompatible feature set is that if there is a bit set
+         * in the incompatible feature set that the kernel doesn't
+         * know about, it should refuse to mount the filesystem.
+         *
+         * e2fsck's requirements are more strict; if it doesn't know
+         * about a feature in either the compatible or incompatible
+         * feature set, it must abort and not try to meddle with
+         * things it doesn't understand...
+         */
+        __le32  s_first_ino;            /* First non-reserved inode */
+        __le16   s_inode_size;          /* size of inode structure */
+        __le16  s_block_group_nr;       /* block group # of this superblock */
+        __le32  s_feature_compat;       /* compatible feature set */
+/*60*/  __le32  s_feature_incompat;     /* incompatible feature set */
+        __le32  s_feature_ro_compat;    /* readonly-compatible feature set */
+/*68*/  __u8    s_uuid[16];             /* 128-bit uuid for volume */
+/*78*/  char    s_volume_name[16];      /* volume name */
+/*88*/  char    s_last_mounted[64];     /* directory where last mounted */
+/*C8*/  __le32  s_algorithm_usage_bitmap; /* For compression */
+        /*
+         * Performance hints.  Directory preallocation should only
+         * happen if the EXT3_FEATURE_COMPAT_DIR_PREALLOC flag is on.
+         */
+        __u8    s_prealloc_blocks;      /* Nr of blocks to try to preallocate*/
+        __u8    s_prealloc_dir_blocks;  /* Nr to preallocate for dirs */
+        __u16   s_reserved_gdt_blocks;  /* Per group desc for online growth */
+        /*
+         * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
+         */
+/*D0*/  __u8    s_journal_uuid[16];     /* uuid of journal superblock */
+/*E0*/  __le32  s_journal_inum;         /* inode number of journal file */
+        __le32  s_journal_dev;          /* device number of journal file */
+        __le32  s_last_orphan;          /* start of list of inodes to delete */
+        __le32  s_hash_seed[4];         /* HTREE hash seed */
+        __u8    s_def_hash_version;     /* Default hash version to use */
+        __u8    s_reserved_char_pad;
+        __u16   s_reserved_word_pad;
+        __le32  s_default_mount_opts;
+        __le32  s_first_meta_bg;        /* First metablock block group */
+        __u32   s_reserved[190];        /* Padding to the end of the block */
+};
+
+#ifdef __KERNEL__
+static inline struct ext3_sb_info * EXT3_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+static inline struct ext3_inode_info *EXT3_I(struct inode *inode)
+{
+        return container_of(inode, struct ext3_inode_info, vfs_inode);
+}
+#else
+/* Assume that user mode programs are passing in an ext3fs superblock, not
+ * a kernel struct super_block.  This will allow us to call the feature-test
+ * macros from user land. */
+#define EXT3_SB(sb)     (sb)
+#endif
+
+#define NEXT_ORPHAN(inode) EXT3_I(inode)->i_dtime
+
+/*
+ * Codes for operating systems
+ */
+#define EXT3_OS_LINUX           0
+#define EXT3_OS_HURD            1
+#define EXT3_OS_MASIX           2
+#define EXT3_OS_FREEBSD         3
+#define EXT3_OS_LITES           4
+
+/*
+ * Revision levels
+ */
+#define EXT3_GOOD_OLD_REV       0       /* The good old (original) format */
+#define EXT3_DYNAMIC_REV        1       /* V2 format w/ dynamic inode sizes */
+
+#define EXT3_CURRENT_REV        EXT3_GOOD_OLD_REV
+#define EXT3_MAX_SUPP_REV       EXT3_DYNAMIC_REV
+
+#define EXT3_GOOD_OLD_INODE_SIZE 128
+
+/*
+ * Feature set definitions
+ */
+
+#define EXT3_HAS_COMPAT_FEATURE(sb,mask)                        \
+        ( EXT3_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
+#define EXT3_HAS_RO_COMPAT_FEATURE(sb,mask)                     \
+        ( EXT3_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
+#define EXT3_HAS_INCOMPAT_FEATURE(sb,mask)                      \
+        ( EXT3_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
+#define EXT3_SET_COMPAT_FEATURE(sb,mask)                        \
+        EXT3_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
+#define EXT3_SET_RO_COMPAT_FEATURE(sb,mask)                     \
+        EXT3_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
+#define EXT3_SET_INCOMPAT_FEATURE(sb,mask)                      \
+        EXT3_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
+#define EXT3_CLEAR_COMPAT_FEATURE(sb,mask)                      \
+        EXT3_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
+#define EXT3_CLEAR_RO_COMPAT_FEATURE(sb,mask)                   \
+        EXT3_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
+#define EXT3_CLEAR_INCOMPAT_FEATURE(sb,mask)                    \
+        EXT3_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
+
+#define EXT3_FEATURE_COMPAT_DIR_PREALLOC        0x0001
+#define EXT3_FEATURE_COMPAT_IMAGIC_INODES       0x0002
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL         0x0004
+#define EXT3_FEATURE_COMPAT_EXT_ATTR            0x0008
+#define EXT3_FEATURE_COMPAT_RESIZE_INODE        0x0010
+#define EXT3_FEATURE_COMPAT_DIR_INDEX           0x0020
+
+#define EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER     0x0001
+#define EXT3_FEATURE_RO_COMPAT_LARGE_FILE       0x0002
+#define EXT3_FEATURE_RO_COMPAT_BTREE_DIR        0x0004
+
+#define EXT3_FEATURE_INCOMPAT_COMPRESSION       0x0001
+#define EXT3_FEATURE_INCOMPAT_FILETYPE          0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER           0x0004 /* Needs recovery */
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV       0x0008 /* Journal device */
+#define EXT3_FEATURE_INCOMPAT_META_BG           0x0010
+
+#define EXT3_FEATURE_COMPAT_SUPP        EXT2_FEATURE_COMPAT_EXT_ATTR
+#define EXT3_FEATURE_INCOMPAT_SUPP      (EXT3_FEATURE_INCOMPAT_FILETYPE| \
+                                         EXT3_FEATURE_INCOMPAT_RECOVER| \
+                                         EXT3_FEATURE_INCOMPAT_META_BG)
+#define EXT3_FEATURE_RO_COMPAT_SUPP     (EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \
+                                         EXT3_FEATURE_RO_COMPAT_LARGE_FILE| \
+                                         EXT3_FEATURE_RO_COMPAT_BTREE_DIR)
+
+/*
+ * Default values for user and/or group using reserved blocks
+ */
+#define EXT3_DEF_RESUID         0
+#define EXT3_DEF_RESGID         0
+
+/*
+ * Default mount options
+ */
+#define EXT3_DEFM_DEBUG         0x0001
+#define EXT3_DEFM_BSDGROUPS     0x0002
+#define EXT3_DEFM_XATTR_USER    0x0004
+#define EXT3_DEFM_ACL           0x0008
+#define EXT3_DEFM_UID16         0x0010
+#define EXT3_DEFM_JMODE         0x0060
+#define EXT3_DEFM_JMODE_DATA    0x0020
+#define EXT3_DEFM_JMODE_ORDERED 0x0040
+#define EXT3_DEFM_JMODE_WBACK   0x0060
+
+/*
+ * Structure of a directory entry
+ */
+#define EXT3_NAME_LEN 255
+
+struct ext3_dir_entry {
+        __le32  inode;                  /* Inode number */
+        __le16  rec_len;                /* Directory entry length */
+        __le16  name_len;               /* Name length */
+        char    name[EXT3_NAME_LEN];    /* File name */
+};
+
+/*
+ * The new version of the directory entry.  Since EXT3 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct ext3_dir_entry_2 {
+        __le32  inode;                  /* Inode number */
+        __le16  rec_len;                /* Directory entry length */
+        __u8    name_len;               /* Name length */
+        __u8    file_type;
+        char    name[EXT3_NAME_LEN];    /* File name */
+};
+
+/*
+ * Ext3 directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+#define EXT3_FT_UNKNOWN         0
+#define EXT3_FT_REG_FILE        1
+#define EXT3_FT_DIR             2
+#define EXT3_FT_CHRDEV          3
+#define EXT3_FT_BLKDEV          4
+#define EXT3_FT_FIFO            5
+#define EXT3_FT_SOCK            6
+#define EXT3_FT_SYMLINK         7
+
+#define EXT3_FT_MAX             8
+
+/*
+ * EXT3_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 4
+ */
+#define EXT3_DIR_PAD                    4
+#define EXT3_DIR_ROUND                  (EXT3_DIR_PAD - 1)
+#define EXT3_DIR_REC_LEN(name_len)      (((name_len) + 8 + EXT3_DIR_ROUND) & \
+                                         ~EXT3_DIR_ROUND)
+/*
+ * Hash Tree Directory indexing
+ * (c) Daniel Phillips, 2001
+ */
+
+#ifdef CONFIG_EXT3_INDEX
+  #define is_dx(dir) (EXT3_HAS_COMPAT_FEATURE(dir->i_sb, \
+                                              EXT3_FEATURE_COMPAT_DIR_INDEX) && \
+                      (EXT3_I(dir)->i_flags & EXT3_INDEX_FL))
+#define EXT3_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT3_LINK_MAX)
+#define EXT3_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
+#else
+  #define is_dx(dir) 0
+#define EXT3_DIR_LINK_MAX(dir) ((dir)->i_nlink >= EXT3_LINK_MAX)
+#define EXT3_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2)
+#endif
+
+/* Legal values for the dx_root hash_version field: */
+
+#define DX_HASH_LEGACY          0
+#define DX_HASH_HALF_MD4        1
+#define DX_HASH_TEA             2
+
+/* hash info structure used by the directory hash */
+struct dx_hash_info
+{
+        u32             hash;
+        u32             minor_hash;
+        int             hash_version;
+        u32             *seed;
+};
+
+#define EXT3_HTREE_EOF  0x7fffffff
+
+#ifdef __KERNEL__
+/*
+ * Control parameters used by ext3_htree_next_block
+ */
+#define HASH_NB_ALWAYS          1
+
+
+/*
+ * Describe an inode's exact location on disk and in memory
+ */
+struct ext3_iloc
+{
+        struct buffer_head *bh;
+        unsigned long offset;
+        unsigned long block_group;
+};
+
+static inline struct ext3_inode *ext3_raw_inode(struct ext3_iloc *iloc)
+{
+        return (struct ext3_inode *) (iloc->bh->b_data + iloc->offset);
+}
+
+/*
+ * This structure is stuffed into the struct file's private_data field
+ * for directories.  It is where we put information so that we can do
+ * readdir operations in hash tree order.
+ */
+struct dir_private_info {
+        struct rb_root  root;
+        struct rb_node  *curr_node;
+        struct fname    *extra_fname;
+        loff_t          last_pos;
+        __u32           curr_hash;
+        __u32           curr_minor_hash;
+        __u32           next_hash;
+};
+
+/*
+ * Special error return code only used by dx_probe() and its callers.
+ */
+#define ERR_BAD_DX_DIR  -75000
+
+/*
+ * Function prototypes
+ */
+
+/*
+ * Ok, these declarations are also in <linux/kernel.h> but none of the
+ * ext3 source programs needs to include it so they are duplicated here.
+ */
+# define NORET_TYPE    /**/
+# define ATTRIB_NORET  __attribute__((noreturn))
+# define NORET_AND     noreturn,
+
+/* balloc.c */
+extern int ext3_bg_has_super(struct super_block *sb, int group);
+extern unsigned long ext3_bg_num_gdb(struct super_block *sb, int group);
+extern int ext3_new_block (handle_t *, struct inode *, unsigned long, int *);
+extern void ext3_free_blocks (handle_t *, struct inode *, unsigned long,
+                              unsigned long);
+extern void ext3_free_blocks_sb (handle_t *, struct super_block *,
+                                 unsigned long, unsigned long, int *);
+extern unsigned long ext3_count_free_blocks (struct super_block *);
+extern void ext3_check_blocks_bitmap (struct super_block *);
+extern struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb,
+                                                    unsigned int block_group,
+                                                    struct buffer_head ** bh);
+extern int ext3_should_retry_alloc(struct super_block *sb, int *retries);
+extern void ext3_init_block_alloc_info(struct inode *);
+extern void ext3_rsv_window_add(struct super_block *sb, struct ext3_reserve_window_node *rsv);
+
+/* dir.c */
+extern int ext3_check_dir_entry(const char *, struct inode *,
+                                struct ext3_dir_entry_2 *,
+                                struct buffer_head *, unsigned long);
+extern int ext3_htree_store_dirent(struct file *dir_file, __u32 hash,
+                                    __u32 minor_hash,
+                                    struct ext3_dir_entry_2 *dirent);
+extern void ext3_htree_free_dir_info(struct dir_private_info *p);
+
+/* fsync.c */
+extern int ext3_sync_file (struct file *, struct dentry *, int);
+
+/* hash.c */
+extern int ext3fs_dirhash(const char *name, int len, struct
+                          dx_hash_info *hinfo);
+
+/* ialloc.c */
+extern struct inode * ext3_new_inode (handle_t *, struct inode *, int);
+extern void ext3_free_inode (handle_t *, struct inode *);
+extern struct inode * ext3_orphan_get (struct super_block *, unsigned long);
+extern unsigned long ext3_count_free_inodes (struct super_block *);
+extern unsigned long ext3_count_dirs (struct super_block *);
+extern void ext3_check_inodes_bitmap (struct super_block *);
+extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
+
+
+/* inode.c */
+extern int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int);
+extern struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
+extern struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
+
+extern void ext3_read_inode (struct inode *);
+extern int  ext3_write_inode (struct inode *, int);
+extern int  ext3_setattr (struct dentry *, struct iattr *);
+extern void ext3_delete_inode (struct inode *);
+extern int  ext3_sync_inode (handle_t *, struct inode *);
+extern void ext3_discard_reservation (struct inode *);
+extern void ext3_dirty_inode(struct inode *);
+extern int ext3_change_inode_journal_flag(struct inode *, int);
+extern int ext3_get_inode_loc(struct inode *, struct ext3_iloc *);
+extern void ext3_truncate (struct inode *);
+extern void ext3_set_inode_flags(struct inode *);
+extern void ext3_set_aops(struct inode *inode);
+
+/* ioctl.c */
+extern int ext3_ioctl (struct inode *, struct file *, unsigned int,
+                       unsigned long);
+
+/* namei.c */
+extern int ext3_orphan_add(handle_t *, struct inode *);
+extern int ext3_orphan_del(handle_t *, struct inode *);
+extern int ext3_htree_fill_tree(struct file *dir_file, __u32 start_hash,
+                                __u32 start_minor_hash, __u32 *next_hash);
+
+/* resize.c */
+extern int ext3_group_add(struct super_block *sb,
+                                struct ext3_new_group_data *input);
+extern int ext3_group_extend(struct super_block *sb,
+                                struct ext3_super_block *es,
+                                unsigned long n_blocks_count);
+
+/* super.c */
+extern void ext3_error (struct super_block *, const char *, const char *, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern void __ext3_std_error (struct super_block *, const char *, int);
+extern void ext3_abort (struct super_block *, const char *, const char *, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern void ext3_warning (struct super_block *, const char *, const char *, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern void ext3_update_dynamic_rev (struct super_block *sb);
+
+#define ext3_std_error(sb, errno)                               \
+do {                                                            \
+        if ((errno))                                            \
+                __ext3_std_error((sb), __FUNCTION__, (errno));  \
+} while (0)
+
+/*
+ * Inodes and files operations
+ */
+
+/* dir.c */
+extern struct file_operations ext3_dir_operations;
+
+/* file.c */
+extern struct inode_operations ext3_file_inode_operations;
+extern struct file_operations ext3_file_operations;
+
+/* namei.c */
+extern struct inode_operations ext3_dir_inode_operations;
+extern struct inode_operations ext3_special_inode_operations;
+
+/* symlink.c */
+extern struct inode_operations ext3_symlink_inode_operations;
+extern struct inode_operations ext3_fast_symlink_inode_operations;
+
+
+#endif  /* __KERNEL__ */
+
+#endif  /* _LINUX_EXT3_FS_H */
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
new file mode 100644
index 000000000000..2914f7b07156
--- /dev/null
+++ b/include/linux/ext3_fs_i.h
@@ -0,0 +1,138 @@
+/*
+ *  linux/include/linux/ext3_fs_i.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs_i.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT3_FS_I
+#define _LINUX_EXT3_FS_I
+
+#include <linux/rwsem.h>
+#include <linux/rbtree.h>
+#include <linux/seqlock.h>
+
+struct ext3_reserve_window {
+        __u32                   _rsv_start;     /* First byte reserved */
+        __u32                   _rsv_end;       /* Last byte reserved or 0 */
+};
+
+struct ext3_reserve_window_node {
+        struct rb_node          rsv_node;
+        __u32                   rsv_goal_size;
+        __u32                   rsv_alloc_hit;
+        struct ext3_reserve_window      rsv_window;
+};
+
+struct ext3_block_alloc_info {
+        /* information about reservation window */
+        struct ext3_reserve_window_node rsv_window_node;
+        /*
+         * was i_next_alloc_block in ext3_inode_info
+         * is the logical (file-relative) number of the
+         * most-recently-allocated block in this file.
+         * We use this for detecting linearly ascending allocation requests.
+         */
+        __u32                   last_alloc_logical_block;
+        /*
+         * Was i_next_alloc_goal in ext3_inode_info
+         * is the *physical* companion to i_next_alloc_block.
+         * it the the physical block number of the block which was most-recentl
+         * allocated to this file.  This give us the goal (target) for the next
+         * allocation when we detect linearly ascending requests.
+         */
+        __u32                   last_alloc_physical_block;
+};
+
+#define rsv_start rsv_window._rsv_start
+#define rsv_end rsv_window._rsv_end
+
+/*
+ * third extended file system inode data in memory
+ */
+struct ext3_inode_info {
+        __le32  i_data[15];     /* unconverted */
+        __u32   i_flags;
+#ifdef EXT3_FRAGMENTS
+        __u32   i_faddr;
+        __u8    i_frag_no;
+        __u8    i_frag_size;
+#endif
+        __u32   i_file_acl;
+        __u32   i_dir_acl;
+        __u32   i_dtime;
+
+        /*
+         * i_block_group is the number of the block group which contains
+         * this file's inode.  Constant across the lifetime of the inode,
+         * it is ued for making block allocation decisions - we try to
+         * place a file's data blocks near its inode block, and new inodes
+         * near to their parent directory's inode.
+         */
+        __u32   i_block_group;
+        __u32   i_state;                /* Dynamic state flags for ext3 */
+
+        /* block reservation info */
+        struct ext3_block_alloc_info *i_block_alloc_info;
+
+        __u32   i_dir_start_lookup;
+#ifdef CONFIG_EXT3_FS_XATTR
+        /*
+         * Extended attributes can be read independently of the main file
+         * data. Taking i_sem even when reading would cause contention
+         * between readers of EAs and writers of regular file data, so
+         * instead we synchronize on xattr_sem when reading or changing
+         * EAs.
+         */
+        struct rw_semaphore xattr_sem;
+#endif
+#ifdef CONFIG_EXT3_FS_POSIX_ACL
+        struct posix_acl        *i_acl;
+        struct posix_acl        *i_default_acl;
+#endif
+
+        struct list_head i_orphan;      /* unlinked but open inodes */
+
+        /*
+         * i_disksize keeps track of what the inode size is ON DISK, not
+         * in memory.  During truncate, i_size is set to the new size by
+         * the VFS prior to calling ext3_truncate(), but the filesystem won't
+         * set i_disksize to 0 until the truncate is actually under way.
+         *
+         * The intent is that i_disksize always represents the blocks which
+         * are used by this file.  This allows recovery to restart truncate
+         * on orphans if we crash during truncate.  We actually write i_disksize
+         * into the on-disk inode when writing inodes out, instead of i_size.
+         *
+         * The only time when i_disksize and i_size may be different is when
+         * a truncate is in progress.  The only things which change i_disksize
+         * are ext3_get_block (growth) and ext3_truncate (shrinkth).
+         */
+        loff_t  i_disksize;
+
+        /* on-disk additional length */
+        __u16 i_extra_isize;
+
+        /*
+         * truncate_sem is for serialising ext3_truncate() against
+         * ext3_getblock().  In the 2.4 ext2 design, great chunks of inode's
+         * data tree are chopped off during truncate. We can't do that in
+         * ext3 because whenever we perform intermediate commits during
+         * truncate, the inode and all the metadata blocks *must* be in a
+         * consistent state which allows truncation of the orphans to restart
+         * during recovery.  Hence we must fix the get_block-vs-truncate race
+         * by other means, so we have truncate_sem.
+         */
+        struct semaphore truncate_sem;
+        struct inode vfs_inode;
+};
+
+#endif  /* _LINUX_EXT3_FS_I */
diff --git a/include/linux/ext3_fs_sb.h b/include/linux/ext3_fs_sb.h
new file mode 100644
index 000000000000..f61309c81cc4
--- /dev/null
+++ b/include/linux/ext3_fs_sb.h
@@ -0,0 +1,83 @@
+/*
+ *  linux/include/linux/ext3_fs_sb.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs_sb.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_EXT3_FS_SB
+#define _LINUX_EXT3_FS_SB
+
+#ifdef __KERNEL__
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/blockgroup_lock.h>
+#include <linux/percpu_counter.h>
+#endif
+#include <linux/rbtree.h>
+
+/*
+ * third extended-fs super-block data in memory
+ */
+struct ext3_sb_info {
+        unsigned long s_frag_size;      /* Size of a fragment in bytes */
+        unsigned long s_frags_per_block;/* Number of fragments per block */
+        unsigned long s_inodes_per_block;/* Number of inodes per block */
+        unsigned long s_frags_per_group;/* Number of fragments in a group */
+        unsigned long s_blocks_per_group;/* Number of blocks in a group */
+        unsigned long s_inodes_per_group;/* Number of inodes in a group */
+        unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
+        unsigned long s_gdb_count;      /* Number of group descriptor blocks */
+        unsigned long s_desc_per_block; /* Number of group descriptors per block */
+        unsigned long s_groups_count;   /* Number of groups in the fs */
+        struct buffer_head * s_sbh;     /* Buffer containing the super block */
+        struct ext3_super_block * s_es; /* Pointer to the super block in the buffer */
+        struct buffer_head ** s_group_desc;
+        unsigned long  s_mount_opt;
+        uid_t s_resuid;
+        gid_t s_resgid;
+        unsigned short s_mount_state;
+        unsigned short s_pad;
+        int s_addr_per_block_bits;
+        int s_desc_per_block_bits;
+        int s_inode_size;
+        int s_first_ino;
+        spinlock_t s_next_gen_lock;
+        u32 s_next_generation;
+        u32 s_hash_seed[4];
+        int s_def_hash_version;
+        struct percpu_counter s_freeblocks_counter;
+        struct percpu_counter s_freeinodes_counter;
+        struct percpu_counter s_dirs_counter;
+        struct blockgroup_lock s_blockgroup_lock;
+
+        /* root of the per fs reservation window tree */
+        spinlock_t s_rsv_window_lock;
+        struct rb_root s_rsv_window_root;
+        struct ext3_reserve_window_node s_rsv_window_head;
+
+        /* Journaling */
+        struct inode * s_journal_inode;
+        struct journal_s * s_journal;
+        struct list_head s_orphan;
+        unsigned long s_commit_interval;
+        struct block_device *journal_bdev;
+#ifdef CONFIG_JBD_DEBUG
+        struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
+        wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
+#endif
+#ifdef CONFIG_QUOTA
+        char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
+        int s_jquota_fmt;                       /* Format of quota to use */
+#endif
+};
+
+#endif  /* _LINUX_EXT3_FS_SB */
diff --git a/include/linux/ext3_jbd.h b/include/linux/ext3_jbd.h
new file mode 100644
index 000000000000..e8292af9033b
--- /dev/null
+++ b/include/linux/ext3_jbd.h
@@ -0,0 +1,265 @@
+/*
+ * linux/include/linux/ext3_jbd.h
+ *
+ * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
+ *
+ * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * Ext3-specific journaling extensions.
+ */
+
+#ifndef _LINUX_EXT3_JBD_H
+#define _LINUX_EXT3_JBD_H
+
+#include <linux/fs.h>
+#include <linux/jbd.h>
+#include <linux/ext3_fs.h>
+
+#define EXT3_JOURNAL(inode)     (EXT3_SB((inode)->i_sb)->s_journal)
+
+/* Define the number of blocks we need to account to a transaction to
+ * modify one block of data.
+ * 
+ * We may have to touch one inode, one bitmap buffer, up to three
+ * indirection blocks, the group and superblock summaries, and the data
+ * block to complete the transaction.  */
+
+#define EXT3_SINGLEDATA_TRANS_BLOCKS    8U
+
+/* Extended attribute operations touch at most two data buffers,
+ * two bitmap buffers, and two group summaries, in addition to the inode
+ * and the superblock, which are already accounted for. */
+
+#define EXT3_XATTR_TRANS_BLOCKS         6U
+
+/* Define the minimum size for a transaction which modifies data.  This
+ * needs to take into account the fact that we may end up modifying two
+ * quota files too (one for the group, one for the user quota).  The
+ * superblock only gets updated once, of course, so don't bother
+ * counting that again for the quota updates. */
+
+#define EXT3_DATA_TRANS_BLOCKS          (EXT3_SINGLEDATA_TRANS_BLOCKS + \
+                                         EXT3_XATTR_TRANS_BLOCKS - 2 + \
+                                         2*EXT3_QUOTA_TRANS_BLOCKS)
+
+/* Delete operations potentially hit one directory's namespace plus an
+ * entire inode, plus arbitrary amounts of bitmap/indirection data.  Be
+ * generous.  We can grow the delete transaction later if necessary. */
+
+#define EXT3_DELETE_TRANS_BLOCKS        (2 * EXT3_DATA_TRANS_BLOCKS + 64)
+
+/* Define an arbitrary limit for the amount of data we will anticipate
+ * writing to any given transaction.  For unbounded transactions such as
+ * write(2) and truncate(2) we can write more than this, but we always
+ * start off at the maximum transaction size and grow the transaction
+ * optimistically as we go. */
+
+#define EXT3_MAX_TRANS_DATA             64U
+
+/* We break up a large truncate or write transaction once the handle's
+ * buffer credits gets this low, we need either to extend the
+ * transaction or to start a new one.  Reserve enough space here for
+ * inode, bitmap, superblock, group and indirection updates for at least
+ * one block, plus two quota updates.  Quota allocations are not
+ * needed. */
+
+#define EXT3_RESERVE_TRANS_BLOCKS       12U
+
+#define EXT3_INDEX_EXTRA_TRANS_BLOCKS   8
+
+#ifdef CONFIG_QUOTA
+/* Amount of blocks needed for quota update - we know that the structure was
+ * allocated so we need to update only inode+data */
+#define EXT3_QUOTA_TRANS_BLOCKS 2
+/* Amount of blocks needed for quota insert/delete - we do some block writes
+ * but inode, sb and group updates are done only once */
+#define EXT3_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*\
+                                (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3)
+#else
+#define EXT3_QUOTA_TRANS_BLOCKS 0
+#define EXT3_QUOTA_INIT_BLOCKS 0
+#endif
+
+int
+ext3_mark_iloc_dirty(handle_t *handle, 
+                     struct inode *inode,
+                     struct ext3_iloc *iloc);
+
+/* 
+ * On success, We end up with an outstanding reference count against
+ * iloc->bh.  This _must_ be cleaned up later. 
+ */
+
+int ext3_reserve_inode_write(handle_t *handle, struct inode *inode, 
+                        struct ext3_iloc *iloc);
+
+int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode);
+
+/*
+ * Wrapper functions with which ext3 calls into JBD.  The intent here is
+ * to allow these to be turned into appropriate stubs so ext3 can control
+ * ext2 filesystems, so ext2+ext3 systems only nee one fs.  This work hasn't
+ * been done yet.
+ */
+
+void ext3_journal_abort_handle(const char *caller, const char *err_fn,
+                struct buffer_head *bh, handle_t *handle, int err);
+
+static inline int
+__ext3_journal_get_undo_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = journal_get_undo_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+static inline int
+__ext3_journal_get_write_access(const char *where, handle_t *handle,
+                                struct buffer_head *bh)
+{
+        int err = journal_get_write_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+static inline void
+ext3_journal_release_buffer(handle_t *handle, struct buffer_head *bh)
+{
+        journal_release_buffer(handle, bh);
+}
+
+static inline int
+__ext3_journal_forget(const char *where, handle_t *handle, struct buffer_head *bh)
+{
+        int err = journal_forget(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+static inline int
+__ext3_journal_revoke(const char *where, handle_t *handle,
+                      unsigned long blocknr, struct buffer_head *bh)
+{
+        int err = journal_revoke(handle, blocknr, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+static inline int
+__ext3_journal_get_create_access(const char *where,
+                                 handle_t *handle, struct buffer_head *bh)
+{
+        int err = journal_get_create_access(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+static inline int
+__ext3_journal_dirty_metadata(const char *where,
+                              handle_t *handle, struct buffer_head *bh)
+{
+        int err = journal_dirty_metadata(handle, bh);
+        if (err)
+                ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
+        return err;
+}
+
+
+#define ext3_journal_get_undo_access(handle, bh) \
+        __ext3_journal_get_undo_access(__FUNCTION__, (handle), (bh))
+#define ext3_journal_get_write_access(handle, bh) \
+        __ext3_journal_get_write_access(__FUNCTION__, (handle), (bh))
+#define ext3_journal_revoke(handle, blocknr, bh) \
+        __ext3_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh))
+#define ext3_journal_get_create_access(handle, bh) \
+        __ext3_journal_get_create_access(__FUNCTION__, (handle), (bh))
+#define ext3_journal_dirty_metadata(handle, bh) \
+        __ext3_journal_dirty_metadata(__FUNCTION__, (handle), (bh))
+#define ext3_journal_forget(handle, bh) \
+        __ext3_journal_forget(__FUNCTION__, (handle), (bh))
+
+int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh);
+
+handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks);
+int __ext3_journal_stop(const char *where, handle_t *handle);
+
+static inline handle_t *ext3_journal_start(struct inode *inode, int nblocks)
+{
+        return ext3_journal_start_sb(inode->i_sb, nblocks);
+}
+
+#define ext3_journal_stop(handle) \
+        __ext3_journal_stop(__FUNCTION__, (handle))
+
+static inline handle_t *ext3_journal_current_handle(void)
+{
+        return journal_current_handle();
+}
+
+static inline int ext3_journal_extend(handle_t *handle, int nblocks)
+{
+        return journal_extend(handle, nblocks);
+}
+
+static inline int ext3_journal_restart(handle_t *handle, int nblocks)
+{
+        return journal_restart(handle, nblocks);
+}
+
+static inline int ext3_journal_blocks_per_page(struct inode *inode)
+{
+        return journal_blocks_per_page(inode);
+}
+
+static inline int ext3_journal_force_commit(journal_t *journal)
+{
+        return journal_force_commit(journal);
+}
+
+/* super.c */
+int ext3_force_commit(struct super_block *sb);
+
+static inline int ext3_should_journal_data(struct inode *inode)
+{
+        if (!S_ISREG(inode->i_mode))
+                return 1;
+        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA)
+                return 1;
+        if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
+                return 1;
+        return 0;
+}
+
+static inline int ext3_should_order_data(struct inode *inode)
+{
+        if (!S_ISREG(inode->i_mode))
+                return 0;
+        if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
+                return 0;
+        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA)
+                return 1;
+        return 0;
+}
+
+static inline int ext3_should_writeback_data(struct inode *inode)
+{
+        if (!S_ISREG(inode->i_mode))
+                return 0;
+        if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
+                return 0;
+        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)
+                return 1;
+        return 0;
+}
+
+#endif  /* _LINUX_EXT3_JBD_H */
diff --git a/include/linux/fadvise.h b/include/linux/fadvise.h
new file mode 100644
index 000000000000..6fc656dfb93d
--- /dev/null
+++ b/include/linux/fadvise.h
@@ -0,0 +1,11 @@
+#ifndef FADVISE_H_INCLUDED
+#define FADVISE_H_INCLUDED
+
+#define POSIX_FADV_NORMAL       0 /* No further special treatment.  */
+#define POSIX_FADV_RANDOM       1 /* Expect random page references.  */
+#define POSIX_FADV_SEQUENTIAL   2 /* Expect sequential page references.  */
+#define POSIX_FADV_WILLNEED     3 /* Will need these pages.  */
+#define POSIX_FADV_DONTNEED     4 /* Don't need these pages.  */
+#define POSIX_FADV_NOREUSE      5 /* Data will be accessed once.  */
+
+#endif  /* FADVISE_H_INCLUDED */
diff --git a/include/linux/fb.h b/include/linux/fb.h
new file mode 100644
index 000000000000..b45d3e2d711a
--- /dev/null
+++ b/include/linux/fb.h
@@ -0,0 +1,932 @@
+#ifndef _LINUX_FB_H
+#define _LINUX_FB_H
+
+#include <asm/types.h>
+
+/* Definitions of frame buffers                                         */
+
+#define FB_MAJOR                29
+#define FB_MAX                  32      /* sufficient for now */
+
+/* ioctls
+   0x46 is 'F'                                                          */
+#define FBIOGET_VSCREENINFO     0x4600
+#define FBIOPUT_VSCREENINFO     0x4601
+#define FBIOGET_FSCREENINFO     0x4602
+#define FBIOGETCMAP             0x4604
+#define FBIOPUTCMAP             0x4605
+#define FBIOPAN_DISPLAY         0x4606
+#ifdef __KERNEL__
+#define FBIO_CURSOR            _IOWR('F', 0x08, struct fb_cursor_user)
+#else
+#define FBIO_CURSOR            _IOWR('F', 0x08, struct fb_cursor)
+#endif
+/* 0x4607-0x460B are defined below */
+/* #define FBIOGET_MONITORSPEC  0x460C */
+/* #define FBIOPUT_MONITORSPEC  0x460D */
+/* #define FBIOSWITCH_MONIBIT   0x460E */
+#define FBIOGET_CON2FBMAP       0x460F
+#define FBIOPUT_CON2FBMAP       0x4610
+#define FBIOBLANK               0x4611          /* arg: 0 or vesa level + 1 */
+#define FBIOGET_VBLANK          _IOR('F', 0x12, struct fb_vblank)
+#define FBIO_ALLOC              0x4613
+#define FBIO_FREE               0x4614
+#define FBIOGET_GLYPH           0x4615
+#define FBIOGET_HWCINFO         0x4616
+#define FBIOPUT_MODEINFO        0x4617
+#define FBIOGET_DISPINFO        0x4618
+
+
+#define FB_TYPE_PACKED_PIXELS           0       /* Packed Pixels        */
+#define FB_TYPE_PLANES                  1       /* Non interleaved planes */
+#define FB_TYPE_INTERLEAVED_PLANES      2       /* Interleaved planes   */
+#define FB_TYPE_TEXT                    3       /* Text/attributes      */
+#define FB_TYPE_VGA_PLANES              4       /* EGA/VGA planes       */
+
+#define FB_AUX_TEXT_MDA         0       /* Monochrome text */
+#define FB_AUX_TEXT_CGA         1       /* CGA/EGA/VGA Color text */
+#define FB_AUX_TEXT_S3_MMIO     2       /* S3 MMIO fasttext */
+#define FB_AUX_TEXT_MGA_STEP16  3       /* MGA Millenium I: text, attr, 14 reserved bytes */
+#define FB_AUX_TEXT_MGA_STEP8   4       /* other MGAs:      text, attr,  6 reserved bytes */
+
+#define FB_AUX_VGA_PLANES_VGA4          0       /* 16 color planes (EGA/VGA) */
+#define FB_AUX_VGA_PLANES_CFB4          1       /* CFB4 in planes (VGA) */
+#define FB_AUX_VGA_PLANES_CFB8          2       /* CFB8 in planes (VGA) */
+
+#define FB_VISUAL_MONO01                0       /* Monochr. 1=Black 0=White */
+#define FB_VISUAL_MONO10                1       /* Monochr. 1=White 0=Black */
+#define FB_VISUAL_TRUECOLOR             2       /* True color   */
+#define FB_VISUAL_PSEUDOCOLOR           3       /* Pseudo color (like atari) */
+#define FB_VISUAL_DIRECTCOLOR           4       /* Direct color */
+#define FB_VISUAL_STATIC_PSEUDOCOLOR    5       /* Pseudo color readonly */
+
+#define FB_ACCEL_NONE           0       /* no hardware accelerator      */
+#define FB_ACCEL_ATARIBLITT     1       /* Atari Blitter                */
+#define FB_ACCEL_AMIGABLITT     2       /* Amiga Blitter                */
+#define FB_ACCEL_S3_TRIO64      3       /* Cybervision64 (S3 Trio64)    */
+#define FB_ACCEL_NCR_77C32BLT   4       /* RetinaZ3 (NCR 77C32BLT)      */
+#define FB_ACCEL_S3_VIRGE       5       /* Cybervision64/3D (S3 ViRGE)  */
+#define FB_ACCEL_ATI_MACH64GX   6       /* ATI Mach 64GX family         */
+#define FB_ACCEL_DEC_TGA        7       /* DEC 21030 TGA                */
+#define FB_ACCEL_ATI_MACH64CT   8       /* ATI Mach 64CT family         */
+#define FB_ACCEL_ATI_MACH64VT   9       /* ATI Mach 64CT family VT class */
+#define FB_ACCEL_ATI_MACH64GT   10      /* ATI Mach 64CT family GT class */
+#define FB_ACCEL_SUN_CREATOR    11      /* Sun Creator/Creator3D        */
+#define FB_ACCEL_SUN_CGSIX      12      /* Sun cg6                      */
+#define FB_ACCEL_SUN_LEO        13      /* Sun leo/zx                   */
+#define FB_ACCEL_IMS_TWINTURBO  14      /* IMS Twin Turbo               */
+#define FB_ACCEL_3DLABS_PERMEDIA2 15    /* 3Dlabs Permedia 2            */
+#define FB_ACCEL_MATROX_MGA2064W 16     /* Matrox MGA2064W (Millenium)  */
+#define FB_ACCEL_MATROX_MGA1064SG 17    /* Matrox MGA1064SG (Mystique)  */
+#define FB_ACCEL_MATROX_MGA2164W 18     /* Matrox MGA2164W (Millenium II) */
+#define FB_ACCEL_MATROX_MGA2164W_AGP 19 /* Matrox MGA2164W (Millenium II) */
+#define FB_ACCEL_MATROX_MGAG100 20      /* Matrox G100 (Productiva G100) */
+#define FB_ACCEL_MATROX_MGAG200 21      /* Matrox G200 (Myst, Mill, ...) */
+#define FB_ACCEL_SUN_CG14       22      /* Sun cgfourteen                */
+#define FB_ACCEL_SUN_BWTWO      23      /* Sun bwtwo                    */
+#define FB_ACCEL_SUN_CGTHREE    24      /* Sun cgthree                  */
+#define FB_ACCEL_SUN_TCX        25      /* Sun tcx                      */
+#define FB_ACCEL_MATROX_MGAG400 26      /* Matrox G400                  */
+#define FB_ACCEL_NV3            27      /* nVidia RIVA 128              */
+#define FB_ACCEL_NV4            28      /* nVidia RIVA TNT              */
+#define FB_ACCEL_NV5            29      /* nVidia RIVA TNT2             */
+#define FB_ACCEL_CT_6555x       30      /* C&T 6555x                    */
+#define FB_ACCEL_3DFX_BANSHEE   31      /* 3Dfx Banshee                 */
+#define FB_ACCEL_ATI_RAGE128    32      /* ATI Rage128 family           */
+#define FB_ACCEL_IGS_CYBER2000  33      /* CyberPro 2000                */
+#define FB_ACCEL_IGS_CYBER2010  34      /* CyberPro 2010                */
+#define FB_ACCEL_IGS_CYBER5000  35      /* CyberPro 5000                */
+#define FB_ACCEL_SIS_GLAMOUR    36      /* SiS 300/630/540              */
+#define FB_ACCEL_3DLABS_PERMEDIA3 37    /* 3Dlabs Permedia 3            */
+#define FB_ACCEL_ATI_RADEON     38      /* ATI Radeon family            */
+#define FB_ACCEL_I810           39      /* Intel 810/815                */
+#define FB_ACCEL_SIS_GLAMOUR_2  40      /* SiS 315, 650, 740            */
+#define FB_ACCEL_SIS_XABRE      41      /* SiS 330 ("Xabre")            */
+#define FB_ACCEL_I830           42      /* Intel 830M/845G/85x/865G     */
+#define FB_ACCEL_NV_10          43      /* nVidia Arch 10               */
+#define FB_ACCEL_NV_20          44      /* nVidia Arch 20               */
+#define FB_ACCEL_NV_30          45      /* nVidia Arch 30               */
+#define FB_ACCEL_NV_40          46      /* nVidia Arch 40               */
+#define FB_ACCEL_NEOMAGIC_NM2070 90     /* NeoMagic NM2070              */
+#define FB_ACCEL_NEOMAGIC_NM2090 91     /* NeoMagic NM2090              */
+#define FB_ACCEL_NEOMAGIC_NM2093 92     /* NeoMagic NM2093              */
+#define FB_ACCEL_NEOMAGIC_NM2097 93     /* NeoMagic NM2097              */
+#define FB_ACCEL_NEOMAGIC_NM2160 94     /* NeoMagic NM2160              */
+#define FB_ACCEL_NEOMAGIC_NM2200 95     /* NeoMagic NM2200              */
+#define FB_ACCEL_NEOMAGIC_NM2230 96     /* NeoMagic NM2230              */
+#define FB_ACCEL_NEOMAGIC_NM2360 97     /* NeoMagic NM2360              */
+#define FB_ACCEL_NEOMAGIC_NM2380 98     /* NeoMagic NM2380              */
+
+#define FB_ACCEL_SAVAGE4        0x80    /* S3 Savage4                   */
+#define FB_ACCEL_SAVAGE3D       0x81    /* S3 Savage3D                  */
+#define FB_ACCEL_SAVAGE3D_MV    0x82    /* S3 Savage3D-MV               */
+#define FB_ACCEL_SAVAGE2000     0x83    /* S3 Savage2000                */
+#define FB_ACCEL_SAVAGE_MX_MV   0x84    /* S3 Savage/MX-MV              */
+#define FB_ACCEL_SAVAGE_MX      0x85    /* S3 Savage/MX                 */
+#define FB_ACCEL_SAVAGE_IX_MV   0x86    /* S3 Savage/IX-MV              */
+#define FB_ACCEL_SAVAGE_IX      0x87    /* S3 Savage/IX                 */
+#define FB_ACCEL_PROSAVAGE_PM   0x88    /* S3 ProSavage PM133           */
+#define FB_ACCEL_PROSAVAGE_KM   0x89    /* S3 ProSavage KM133           */
+#define FB_ACCEL_S3TWISTER_P    0x8a    /* S3 Twister                   */
+#define FB_ACCEL_S3TWISTER_K    0x8b    /* S3 TwisterK                  */
+#define FB_ACCEL_SUPERSAVAGE    0x8c    /* S3 Supersavage               */
+#define FB_ACCEL_PROSAVAGE_DDR  0x8d    /* S3 ProSavage DDR             */
+#define FB_ACCEL_PROSAVAGE_DDRK 0x8e    /* S3 ProSavage DDR-K           */
+
+struct fb_fix_screeninfo {
+        char id[16];                    /* identification string eg "TT Builtin" */
+        unsigned long smem_start;       /* Start of frame buffer mem */
+                                        /* (physical address) */
+        __u32 smem_len;                 /* Length of frame buffer mem */
+        __u32 type;                     /* see FB_TYPE_*                */
+        __u32 type_aux;                 /* Interleave for interleaved Planes */
+        __u32 visual;                   /* see FB_VISUAL_*              */ 
+        __u16 xpanstep;                 /* zero if no hardware panning  */
+        __u16 ypanstep;                 /* zero if no hardware panning  */
+        __u16 ywrapstep;                /* zero if no hardware ywrap    */
+        __u32 line_length;              /* length of a line in bytes    */
+        unsigned long mmio_start;       /* Start of Memory Mapped I/O   */
+                                        /* (physical address) */
+        __u32 mmio_len;                 /* Length of Memory Mapped I/O  */
+        __u32 accel;                    /* Indicate to driver which     */
+                                        /*  specific chip/card we have  */
+        __u16 reserved[3];              /* Reserved for future compatibility */
+};
+
+/* Interpretation of offset for color fields: All offsets are from the right,
+ * inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
+ * can use the offset as right argument to <<). A pixel afterwards is a bit
+ * stream and is written to video memory as that unmodified. This implies
+ * big-endian byte order if bits_per_pixel is greater than 8.
+ */
+struct fb_bitfield {
+        __u32 offset;                   /* beginning of bitfield        */
+        __u32 length;                   /* length of bitfield           */
+        __u32 msb_right;                /* != 0 : Most significant bit is */ 
+                                        /* right */ 
+};
+
+#define FB_NONSTD_HAM           1       /* Hold-And-Modify (HAM)        */
+
+#define FB_ACTIVATE_NOW         0       /* set values immediately (or vbl)*/
+#define FB_ACTIVATE_NXTOPEN     1       /* activate on next open        */
+#define FB_ACTIVATE_TEST        2       /* don't set, round up impossible */
+#define FB_ACTIVATE_MASK       15
+                                        /* values                       */
+#define FB_ACTIVATE_VBL        16       /* activate values on next vbl  */
+#define FB_CHANGE_CMAP_VBL     32       /* change colormap on vbl       */
+#define FB_ACTIVATE_ALL        64       /* change all VCs on this fb    */
+#define FB_ACTIVATE_FORCE     128       /* force apply even when no change*/
+#define FB_ACTIVATE_INV_MODE  256       /* invalidate videomode */
+
+#define FB_ACCELF_TEXT          1       /* (OBSOLETE) see fb_info.flags and vc_mode */
+
+#define FB_SYNC_HOR_HIGH_ACT    1       /* horizontal sync high active  */
+#define FB_SYNC_VERT_HIGH_ACT   2       /* vertical sync high active    */
+#define FB_SYNC_EXT             4       /* external sync                */
+#define FB_SYNC_COMP_HIGH_ACT   8       /* composite sync high active   */
+#define FB_SYNC_BROADCAST       16      /* broadcast video timings      */
+                                        /* vtotal = 144d/288n/576i => PAL  */
+                                        /* vtotal = 121d/242n/484i => NTSC */
+#define FB_SYNC_ON_GREEN        32      /* sync on green */
+
+#define FB_VMODE_NONINTERLACED  0       /* non interlaced */
+#define FB_VMODE_INTERLACED     1       /* interlaced   */
+#define FB_VMODE_DOUBLE         2       /* double scan */
+#define FB_VMODE_MASK           255
+
+#define FB_VMODE_YWRAP          256     /* ywrap instead of panning     */
+#define FB_VMODE_SMOOTH_XPAN    512     /* smooth xpan possible (internally used) */
+#define FB_VMODE_CONUPDATE      512     /* don't update x/yoffset       */
+
+#define PICOS2KHZ(a) (1000000000UL/(a))
+#define KHZ2PICOS(a) (1000000000UL/(a))
+
+struct fb_var_screeninfo {
+        __u32 xres;                     /* visible resolution           */
+        __u32 yres;
+        __u32 xres_virtual;             /* virtual resolution           */
+        __u32 yres_virtual;
+        __u32 xoffset;                  /* offset from virtual to visible */
+        __u32 yoffset;                  /* resolution                   */
+
+        __u32 bits_per_pixel;           /* guess what                   */
+        __u32 grayscale;                /* != 0 Graylevels instead of colors */
+
+        struct fb_bitfield red;         /* bitfield in fb mem if true color, */
+        struct fb_bitfield green;       /* else only length is significant */
+        struct fb_bitfield blue;
+        struct fb_bitfield transp;      /* transparency                 */      
+
+        __u32 nonstd;                   /* != 0 Non standard pixel format */
+
+        __u32 activate;                 /* see FB_ACTIVATE_*            */
+
+        __u32 height;                   /* height of picture in mm    */
+        __u32 width;                    /* width of picture in mm     */
+
+        __u32 accel_flags;              /* (OBSOLETE) see fb_info.flags */
+
+        /* Timing: All values in pixclocks, except pixclock (of course) */
+        __u32 pixclock;                 /* pixel clock in ps (pico seconds) */
+        __u32 left_margin;              /* time from sync to picture    */
+        __u32 right_margin;             /* time from picture to sync    */
+        __u32 upper_margin;             /* time from sync to picture    */
+        __u32 lower_margin;
+        __u32 hsync_len;                /* length of horizontal sync    */
+        __u32 vsync_len;                /* length of vertical sync      */
+        __u32 sync;                     /* see FB_SYNC_*                */
+        __u32 vmode;                    /* see FB_VMODE_*               */
+        __u32 rotate;                   /* angle we rotate counter clockwise */
+        __u32 reserved[5];              /* Reserved for future compatibility */
+};
+
+struct fb_cmap {
+        __u32 start;                    /* First entry  */
+        __u32 len;                      /* Number of entries */
+        __u16 *red;                     /* Red values   */
+        __u16 *green;
+        __u16 *blue;
+        __u16 *transp;                  /* transparency, can be NULL */
+};
+
+struct fb_con2fbmap {
+        __u32 console;
+        __u32 framebuffer;
+};
+
+/* VESA Blanking Levels */
+#define VESA_NO_BLANKING        0
+#define VESA_VSYNC_SUSPEND      1
+#define VESA_HSYNC_SUSPEND      2
+#define VESA_POWERDOWN          3
+
+
+enum {
+        /* screen: unblanked, hsync: on,  vsync: on */
+        FB_BLANK_UNBLANK       = VESA_NO_BLANKING,
+
+        /* screen: blanked,   hsync: on,  vsync: on */
+        FB_BLANK_NORMAL        = VESA_NO_BLANKING + 1,
+
+        /* screen: blanked,   hsync: on,  vsync: off */
+        FB_BLANK_VSYNC_SUSPEND = VESA_VSYNC_SUSPEND + 1,
+
+        /* screen: blanked,   hsync: off, vsync: on */
+        FB_BLANK_HSYNC_SUSPEND = VESA_HSYNC_SUSPEND + 1,
+
+        /* screen: blanked,   hsync: off, vsync: off */
+        FB_BLANK_POWERDOWN     = VESA_POWERDOWN + 1
+};
+
+#define FB_VBLANK_VBLANKING     0x001   /* currently in a vertical blank */
+#define FB_VBLANK_HBLANKING     0x002   /* currently in a horizontal blank */
+#define FB_VBLANK_HAVE_VBLANK   0x004   /* vertical blanks can be detected */
+#define FB_VBLANK_HAVE_HBLANK   0x008   /* horizontal blanks can be detected */
+#define FB_VBLANK_HAVE_COUNT    0x010   /* global retrace counter is available */
+#define FB_VBLANK_HAVE_VCOUNT   0x020   /* the vcount field is valid */
+#define FB_VBLANK_HAVE_HCOUNT   0x040   /* the hcount field is valid */
+#define FB_VBLANK_VSYNCING      0x080   /* currently in a vsync */
+#define FB_VBLANK_HAVE_VSYNC    0x100   /* verical syncs can be detected */
+
+struct fb_vblank {
+        __u32 flags;                    /* FB_VBLANK flags */
+        __u32 count;                    /* counter of retraces since boot */
+        __u32 vcount;                   /* current scanline position */
+        __u32 hcount;                   /* current scandot position */
+        __u32 reserved[4];              /* reserved for future compatibility */
+};
+
+/* Internal HW accel */
+#define ROP_COPY 0
+#define ROP_XOR  1
+
+struct fb_copyarea {
+        __u32 dx;
+        __u32 dy;
+        __u32 width;
+        __u32 height;
+        __u32 sx;
+        __u32 sy;
+};
+
+struct fb_fillrect {
+        __u32 dx;       /* screen-relative */
+        __u32 dy;
+        __u32 width;
+        __u32 height;
+        __u32 color;
+        __u32 rop;
+};
+
+struct fb_image {
+        __u32 dx;               /* Where to place image */
+        __u32 dy;
+        __u32 width;            /* Size of image */
+        __u32 height;
+        __u32 fg_color;         /* Only used when a mono bitmap */
+        __u32 bg_color;
+        __u8  depth;            /* Depth of the image */
+        const char *data;       /* Pointer to image data */
+        struct fb_cmap cmap;    /* color map info */
+};
+
+/*
+ * hardware cursor control
+ */
+
+#define FB_CUR_SETIMAGE 0x01
+#define FB_CUR_SETPOS   0x02
+#define FB_CUR_SETHOT   0x04
+#define FB_CUR_SETCMAP  0x08
+#define FB_CUR_SETSHAPE 0x10
+#define FB_CUR_SETSIZE  0x20
+#define FB_CUR_SETALL   0xFF
+
+struct fbcurpos {
+        __u16 x, y;
+};
+
+struct fb_cursor {
+        __u16 set;              /* what to set */
+        __u16 enable;           /* cursor on/off */
+        __u16 rop;              /* bitop operation */
+        const char *mask;       /* cursor mask bits */
+        struct fbcurpos hot;    /* cursor hot spot */
+        struct fb_image image;  /* Cursor image */
+};
+
+#ifdef __KERNEL__
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/device.h>
+#include <linux/workqueue.h>
+#include <linux/devfs_fs_kernel.h>
+#include <linux/notifier.h>
+#include <linux/list.h>
+#include <asm/io.h>
+
+struct vm_area_struct;
+struct fb_info;
+struct device;
+struct file;
+
+/* Definitions below are used in the parsed monitor specs */
+#define FB_DPMS_ACTIVE_OFF      1
+#define FB_DPMS_SUSPEND         2
+#define FB_DPMS_STANDBY         4
+
+#define FB_DISP_DDI             1
+#define FB_DISP_ANA_700_300     2
+#define FB_DISP_ANA_714_286     4
+#define FB_DISP_ANA_1000_400    8
+#define FB_DISP_ANA_700_000     16
+
+#define FB_DISP_MONO            32
+#define FB_DISP_RGB             64
+#define FB_DISP_MULTI           128
+#define FB_DISP_UNKNOWN         256
+
+#define FB_SIGNAL_NONE          0
+#define FB_SIGNAL_BLANK_BLANK   1
+#define FB_SIGNAL_SEPARATE      2
+#define FB_SIGNAL_COMPOSITE     4
+#define FB_SIGNAL_SYNC_ON_GREEN 8
+#define FB_SIGNAL_SERRATION_ON  16
+
+#define FB_MISC_PRIM_COLOR      1
+#define FB_MISC_1ST_DETAIL      2       /* First Detailed Timing is preferred */
+struct fb_chroma {
+        __u32 redx;     /* in fraction of 1024 */
+        __u32 greenx;
+        __u32 bluex;
+        __u32 whitex;
+        __u32 redy;
+        __u32 greeny;
+        __u32 bluey;
+        __u32 whitey;
+};
+
+struct fb_monspecs {
+        struct fb_chroma chroma;
+        struct fb_videomode *modedb;    /* mode database */
+        __u8  manufacturer[4];          /* Manufacturer */
+        __u8  monitor[14];              /* Monitor String */
+        __u8  serial_no[14];            /* Serial Number */
+        __u8  ascii[14];                /* ? */
+        __u32 modedb_len;               /* mode database length */
+        __u32 model;                    /* Monitor Model */
+        __u32 serial;                   /* Serial Number - Integer */
+        __u32 year;                     /* Year manufactured */
+        __u32 week;                     /* Week Manufactured */
+        __u32 hfmin;                    /* hfreq lower limit (Hz) */
+        __u32 hfmax;                    /* hfreq upper limit (Hz) */
+        __u32 dclkmin;                  /* pixelclock lower limit (Hz) */
+        __u32 dclkmax;                  /* pixelclock upper limit (Hz) */
+        __u16 input;                    /* display type - see FB_DISP_* */
+        __u16 dpms;                     /* DPMS support - see FB_DPMS_ */
+        __u16 signal;                   /* Signal Type - see FB_SIGNAL_* */
+        __u16 vfmin;                    /* vfreq lower limit (Hz) */
+        __u16 vfmax;                    /* vfreq upper limit (Hz) */
+        __u16 gamma;                    /* Gamma - in fractions of 100 */
+        __u16 gtf       : 1;            /* supports GTF */
+        __u16 misc;                     /* Misc flags - see FB_MISC_* */
+        __u8  version;                  /* EDID version... */
+        __u8  revision;                 /* ...and revision */
+        __u8  max_x;                    /* Maximum horizontal size (cm) */
+        __u8  max_y;                    /* Maximum vertical size (cm) */
+};
+
+struct fb_cmap_user {
+        __u32 start;                    /* First entry  */
+        __u32 len;                      /* Number of entries */
+        __u16 __user *red;              /* Red values   */
+        __u16 __user *green;
+        __u16 __user *blue;
+        __u16 __user *transp;           /* transparency, can be NULL */
+};
+
+struct fb_image_user {
+        __u32 dx;                       /* Where to place image */
+        __u32 dy;
+        __u32 width;                    /* Size of image */
+        __u32 height;
+        __u32 fg_color;                 /* Only used when a mono bitmap */
+        __u32 bg_color;
+        __u8  depth;                    /* Depth of the image */
+        const char __user *data;        /* Pointer to image data */
+        struct fb_cmap_user cmap;       /* color map info */
+};
+
+struct fb_cursor_user {
+        __u16 set;                      /* what to set */
+        __u16 enable;                   /* cursor on/off */
+        __u16 rop;                      /* bitop operation */
+        const char __user *mask;        /* cursor mask bits */
+        struct fbcurpos hot;            /* cursor hot spot */
+        struct fb_image_user image;     /* Cursor image */
+};
+
+/*
+ * Register/unregister for framebuffer events
+ */
+
+/*      The resolution of the passed in fb_info about to change */ 
+#define FB_EVENT_MODE_CHANGE            0x01
+/*      The display on this fb_info is beeing suspended, no access to the
+ *      framebuffer is allowed any more after that call returns
+ */
+#define FB_EVENT_SUSPEND                0x02
+/*      The display on this fb_info was resumed, you can restore the display
+ *      if you own it
+ */
+#define FB_EVENT_RESUME                 0x03
+/*      An entry from the modelist was removed */
+#define FB_EVENT_MODE_DELETE            0x04
+/*      A driver registered itself */
+#define FB_EVENT_FB_REGISTERED          0x05
+/*      get console to framebuffer mapping */
+#define FB_EVENT_GET_CONSOLE_MAP        0x06
+/*      set console to framebuffer mapping */
+#define FB_EVENT_SET_CONSOLE_MAP        0x07
+/*      A display blank is requested       */
+#define FB_EVENT_BLANK                  0x08
+/*      Private modelist is to be replaced */
+#define FB_EVENT_NEW_MODELIST           0x09
+
+struct fb_event {
+        struct fb_info *info;
+        void *data;
+};
+
+
+extern int fb_register_client(struct notifier_block *nb);
+extern int fb_unregister_client(struct notifier_block *nb);
+
+/*
+ * Pixmap structure definition
+ *
+ * The purpose of this structure is to translate data
+ * from the hardware independent format of fbdev to what
+ * format the hardware needs.
+ */
+
+#define FB_PIXMAP_DEFAULT 1     /* used internally by fbcon */
+#define FB_PIXMAP_SYSTEM  2     /* memory is in system RAM  */
+#define FB_PIXMAP_IO      4     /* memory is iomapped       */
+#define FB_PIXMAP_SYNC    256   /* set if GPU can DMA       */
+
+struct fb_pixmap {
+        u8  *addr;              /* pointer to memory                    */
+        u32 size;               /* size of buffer in bytes              */
+        u32 offset;             /* current offset to buffer             */
+        u32 buf_align;          /* byte alignment of each bitmap        */
+        u32 scan_align;         /* alignment per scanline               */
+        u32 access_align;       /* alignment per read/write             */
+        u32 flags;              /* see FB_PIXMAP_*                      */
+        /* access methods */
+        void (*outbuf)(struct fb_info *info, u8 *addr, u8 *src, unsigned int size);
+        u8   (*inbuf) (struct fb_info *info, u8 *addr);
+};
+
+
+/*
+ * Frame buffer operations
+ *
+ * LOCKING NOTE: those functions must _ALL_ be called with the console
+ * semaphore held, this is the only suitable locking mecanism we have
+ * in 2.6. Some may be called at interrupt time at this point though.
+ */
+
+struct fb_ops {
+        /* open/release and usage marking */
+        struct module *owner;
+        int (*fb_open)(struct fb_info *info, int user);
+        int (*fb_release)(struct fb_info *info, int user);
+
+        /* For framebuffers with strange non linear layouts or that do not
+         * work with normal memory mapped access
+         */
+        ssize_t (*fb_read)(struct file *file, char __user *buf, size_t count, loff_t *ppos);
+        ssize_t (*fb_write)(struct file *file, const char __user *buf, size_t count, loff_t *ppos);
+
+        /* checks var and eventually tweaks it to something supported,
+         * DO NOT MODIFY PAR */
+        int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
+
+        /* set the video mode according to info->var */
+        int (*fb_set_par)(struct fb_info *info);
+
+        /* set color register */
+        int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
+                            unsigned blue, unsigned transp, struct fb_info *info);
+
+        /* blank display */
+        int (*fb_blank)(int blank, struct fb_info *info);
+
+        /* pan display */
+        int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
+
+        /* Draws a rectangle */
+        void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
+        /* Copy data from area to another */
+        void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
+        /* Draws a image to the display */
+        void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
+
+        /* Draws cursor */
+        int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
+
+        /* Rotates the display */
+        void (*fb_rotate)(struct fb_info *info, int angle);
+
+        /* wait for blit idle, optional */
+        int (*fb_sync)(struct fb_info *info);
+
+        /* perform fb specific ioctl (optional) */
+        int (*fb_ioctl)(struct inode *inode, struct file *file, unsigned int cmd,
+                        unsigned long arg, struct fb_info *info);
+
+        /* Handle 32bit compat ioctl (optional) */
+        long (*fb_compat_ioctl)(struct file *f, unsigned cmd, unsigned long arg,
+                               struct fb_info *info);
+
+        /* perform fb specific mmap */
+        int (*fb_mmap)(struct fb_info *info, struct file *file, struct vm_area_struct *vma);
+};
+
+#ifdef CONFIG_FB_TILEBLITTING
+
+#define FB_TILE_CURSOR_NONE        0
+#define FB_TILE_CURSOR_UNDERLINE   1
+#define FB_TILE_CURSOR_LOWER_THIRD 2
+#define FB_TILE_CURSOR_LOWER_HALF  3
+#define FB_TILE_CURSOR_TWO_THIRDS  4
+#define FB_TILE_CURSOR_BLOCK       5
+
+struct fb_tilemap {
+        __u32 width;                /* width of each tile in pixels */
+        __u32 height;               /* height of each tile in scanlines */
+        __u32 depth;                /* color depth of each tile */
+        __u32 length;               /* number of tiles in the map */
+        __u8  *data;                /* actual tile map: a bitmap array, packed
+                                       to the nearest byte */
+};
+
+struct fb_tilerect {
+        __u32 sx;                   /* origin in the x-axis */
+        __u32 sy;                   /* origin in the y-axis */
+        __u32 width;                /* number of tiles in the x-axis */
+        __u32 height;               /* number of tiles in the y-axis */
+        __u32 index;                /* what tile to use: index to tile map */
+        __u32 fg;                   /* foreground color */
+        __u32 bg;                   /* background color */
+        __u32 rop;                  /* raster operation */
+};
+
+struct fb_tilearea {
+        __u32 sx;                   /* source origin in the x-axis */
+        __u32 sy;                   /* source origin in the y-axis */
+        __u32 dx;                   /* destination origin in the x-axis */
+        __u32 dy;                   /* destination origin in the y-axis */
+        __u32 width;                /* number of tiles in the x-axis */
+        __u32 height;               /* number of tiles in the y-axis */
+};
+
+struct fb_tileblit {
+        __u32 sx;                   /* origin in the x-axis */
+        __u32 sy;                   /* origin in the y-axis */
+        __u32 width;                /* number of tiles in the x-axis */
+        __u32 height;               /* number of tiles in the y-axis */
+        __u32 fg;                   /* foreground color */
+        __u32 bg;                   /* background color */
+        __u32 length;               /* number of tiles to draw */
+        __u32 *indices;             /* array of indices to tile map */
+};
+
+struct fb_tilecursor {
+        __u32 sx;                   /* cursor position in the x-axis */
+        __u32 sy;                   /* cursor position in the y-axis */
+        __u32 mode;                 /* 0 = erase, 1 = draw */
+        __u32 shape;                /* see FB_TILE_CURSOR_* */
+        __u32 fg;                   /* foreground color */
+        __u32 bg;                   /* background color */
+};
+
+struct fb_tile_ops {
+        /* set tile characteristics */
+        void (*fb_settile)(struct fb_info *info, struct fb_tilemap *map);
+
+        /* all dimensions from hereon are in terms of tiles */
+
+        /* move a rectangular region of tiles from one area to another*/
+        void (*fb_tilecopy)(struct fb_info *info, struct fb_tilearea *area);
+        /* fill a rectangular region with a tile */
+        void (*fb_tilefill)(struct fb_info *info, struct fb_tilerect *rect);
+        /* copy an array of tiles */
+        void (*fb_tileblit)(struct fb_info *info, struct fb_tileblit *blit);
+        /* cursor */
+        void (*fb_tilecursor)(struct fb_info *info,
+                              struct fb_tilecursor *cursor);
+};
+#endif /* CONFIG_FB_TILEBLITTING */
+
+/* FBINFO_* = fb_info.flags bit flags */
+#define FBINFO_MODULE           0x0001  /* Low-level driver is a module */
+#define FBINFO_HWACCEL_DISABLED 0x0002
+        /* When FBINFO_HWACCEL_DISABLED is set:
+         *  Hardware acceleration is turned off.  Software implementations
+         *  of required functions (copyarea(), fillrect(), and imageblit())
+         *  takes over; acceleration engine should be in a quiescent state */
+
+/* hints */
+#define FBINFO_PARTIAL_PAN_OK   0x0040 /* otw use pan only for double-buffering */
+#define FBINFO_READS_FAST       0x0080 /* soft-copy faster than rendering */
+
+/* hardware supported ops */
+/*  semantics: when a bit is set, it indicates that the operation is
+ *   accelerated by hardware.
+ *  required functions will still work even if the bit is not set.
+ *  optional functions may not even exist if the flag bit is not set.
+ */
+#define FBINFO_HWACCEL_NONE             0x0000
+#define FBINFO_HWACCEL_COPYAREA         0x0100 /* required */
+#define FBINFO_HWACCEL_FILLRECT         0x0200 /* required */
+#define FBINFO_HWACCEL_IMAGEBLIT        0x0400 /* required */
+#define FBINFO_HWACCEL_ROTATE           0x0800 /* optional */
+#define FBINFO_HWACCEL_XPAN             0x1000 /* optional */
+#define FBINFO_HWACCEL_YPAN             0x2000 /* optional */
+#define FBINFO_HWACCEL_YWRAP            0x4000 /* optional */
+
+#define FBINFO_MISC_USEREVENT          0x10000 /* event request
+                                                  from userspace */
+#define FBINFO_MISC_TILEBLITTING       0x20000 /* use tile blitting */
+
+struct fb_info {
+        int node;
+        int flags;
+        struct fb_var_screeninfo var;   /* Current var */
+        struct fb_fix_screeninfo fix;   /* Current fix */
+        struct fb_monspecs monspecs;    /* Current Monitor specs */
+        struct work_struct queue;       /* Framebuffer event queue */
+        struct fb_pixmap pixmap;        /* Image hardware mapper */
+        struct fb_pixmap sprite;        /* Cursor hardware mapper */
+        struct fb_cmap cmap;            /* Current cmap */
+        struct list_head modelist;      /* mode list */
+        struct fb_videomode *mode;      /* current mode */
+        struct fb_ops *fbops;
+        struct device *device;
+        struct class_device *class_device; /* sysfs per device attrs */
+#ifdef CONFIG_FB_TILEBLITTING
+        struct fb_tile_ops *tileops;    /* Tile Blitting */
+#endif
+        char __iomem *screen_base;      /* Virtual address */
+        unsigned long screen_size;      /* Amount of ioremapped VRAM or 0 */ 
+        void *pseudo_palette;           /* Fake palette of 16 colors */ 
+#define FBINFO_STATE_RUNNING    0
+#define FBINFO_STATE_SUSPENDED  1
+        u32 state;                      /* Hardware state i.e suspend */
+        void *fbcon_par;                /* fbcon use-only private area */
+        /* From here on everything is device dependent */
+        void *par;      
+};
+
+#ifdef MODULE
+#define FBINFO_DEFAULT  FBINFO_MODULE
+#else
+#define FBINFO_DEFAULT  0
+#endif
+
+// This will go away
+#define FBINFO_FLAG_MODULE      FBINFO_MODULE
+#define FBINFO_FLAG_DEFAULT     FBINFO_DEFAULT
+
+/* This will go away
+ * fbset currently hacks in FB_ACCELF_TEXT into var.accel_flags
+ * when it wants to turn the acceleration engine on.  This is
+ * really a separate operation, and should be modified via sysfs.
+ *  But for now, we leave it broken with the following define
+ */
+#define STUPID_ACCELF_TEXT_SHIT
+
+// This will go away
+#if defined(__sparc__)
+
+/* We map all of our framebuffers such that big-endian accesses
+ * are what we want, so the following is sufficient.
+ */
+
+// This will go away
+#define fb_readb sbus_readb
+#define fb_readw sbus_readw
+#define fb_readl sbus_readl
+#define fb_readq sbus_readq
+#define fb_writeb sbus_writeb
+#define fb_writew sbus_writew
+#define fb_writel sbus_writel
+#define fb_writeq sbus_writeq
+#define fb_memset sbus_memset_io
+
+#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || (defined(__sh__) && !defined(__SH5__)) || defined(__powerpc__)
+
+#define fb_readb __raw_readb
+#define fb_readw __raw_readw
+#define fb_readl __raw_readl
+#define fb_readq __raw_readq
+#define fb_writeb __raw_writeb
+#define fb_writew __raw_writew
+#define fb_writel __raw_writel
+#define fb_writeq __raw_writeq
+#define fb_memset memset_io
+
+#else
+
+#define fb_readb(addr) (*(volatile u8 *) (addr))
+#define fb_readw(addr) (*(volatile u16 *) (addr))
+#define fb_readl(addr) (*(volatile u32 *) (addr))
+#define fb_readq(addr) (*(volatile u64 *) (addr))
+#define fb_writeb(b,addr) (*(volatile u8 *) (addr) = (b))
+#define fb_writew(b,addr) (*(volatile u16 *) (addr) = (b))
+#define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b))
+#define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b))
+#define fb_memset memset
+
+#endif
+
+    /*
+     *  `Generic' versions of the frame buffer device operations
+     */
+
+extern int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var); 
+extern int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var); 
+extern int fb_blank(struct fb_info *info, int blank);
+extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
+extern void cfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect); 
+extern void cfb_copyarea(struct fb_info *info, const struct fb_copyarea *area); 
+extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
+
+/* drivers/video/fbmem.c */
+extern int register_framebuffer(struct fb_info *fb_info);
+extern int unregister_framebuffer(struct fb_info *fb_info);
+extern int fb_prepare_logo(struct fb_info *fb_info);
+extern int fb_show_logo(struct fb_info *fb_info);
+extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
+extern void fb_iomove_buf_unaligned(struct fb_info *info, struct fb_pixmap *buf,
+                                u8 *dst, u32 d_pitch, u8 *src, u32 idx,
+                                u32 height, u32 shift_high, u32 shift_low, u32 mod);
+extern void fb_iomove_buf_aligned(struct fb_info *info, struct fb_pixmap *buf,
+                                u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch,
+                                u32 height);
+extern void fb_sysmove_buf_unaligned(struct fb_info *info, struct fb_pixmap *buf,
+                                u8 *dst, u32 d_pitch, u8 *src, u32 idx,
+                                u32 height, u32 shift_high, u32 shift_low, u32 mod);
+extern void fb_sysmove_buf_aligned(struct fb_info *info, struct fb_pixmap *buf,
+                                u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch,
+                                u32 height);
+extern void fb_set_suspend(struct fb_info *info, int state);
+extern int fb_get_color_depth(struct fb_var_screeninfo *var);
+extern int fb_get_options(char *name, char **option);
+extern int fb_new_modelist(struct fb_info *info);
+
+extern struct fb_info *registered_fb[FB_MAX];
+extern int num_registered_fb;
+
+/* drivers/video/fbsysfs.c */
+extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
+extern void framebuffer_release(struct fb_info *info);
+extern int fb_init_class_device(struct fb_info *fb_info);
+extern void fb_cleanup_class_device(struct fb_info *head);
+
+/* drivers/video/fbmon.c */
+#define FB_MAXTIMINGS           0
+#define FB_VSYNCTIMINGS         1
+#define FB_HSYNCTIMINGS         2
+#define FB_DCLKTIMINGS          3
+#define FB_IGNOREMON            0x100
+
+#define FB_MODE_IS_UNKNOWN      0
+#define FB_MODE_IS_DETAILED     1
+#define FB_MODE_IS_STANDARD     2
+#define FB_MODE_IS_VESA         4
+#define FB_MODE_IS_CALCULATED   8
+#define FB_MODE_IS_FIRST        16
+#define FB_MODE_IS_FROM_VAR     32
+
+extern int fbmon_valid_timings(u_int pixclock, u_int htotal, u_int vtotal,
+                               const struct fb_info *fb_info);
+extern int fbmon_dpms(const struct fb_info *fb_info);
+extern int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var,
+                       struct fb_info *info);
+extern int fb_validate_mode(const struct fb_var_screeninfo *var,
+                            struct fb_info *info);
+extern int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var);
+extern void fb_edid_to_monspecs(unsigned char *edid, struct fb_monspecs *specs);
+extern void fb_destroy_modedb(struct fb_videomode *modedb);
+
+/* drivers/video/modedb.c */
+#define VESA_MODEDB_SIZE 34
+extern void fb_var_to_videomode(struct fb_videomode *mode,
+                                struct fb_var_screeninfo *var);
+extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
+                                struct fb_videomode *mode);
+extern int fb_mode_is_equal(struct fb_videomode *mode1,
+                            struct fb_videomode *mode2);
+extern int fb_add_videomode(struct fb_videomode *mode, struct list_head *head);
+extern void fb_delete_videomode(struct fb_videomode *mode,
+                                struct list_head *head);
+extern struct fb_videomode *fb_match_mode(struct fb_var_screeninfo *var,
+                                          struct list_head *head);
+extern struct fb_videomode *fb_find_best_mode(struct fb_var_screeninfo *var,
+                                              struct list_head *head);
+extern struct fb_videomode *fb_find_nearest_mode(struct fb_var_screeninfo *var,
+                                                 struct list_head *head);
+extern void fb_destroy_modelist(struct list_head *head);
+extern void fb_videomode_to_modelist(struct fb_videomode *modedb, int num,
+                                     struct list_head *head);
+
+/* drivers/video/fbcmap.c */
+extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
+extern void fb_dealloc_cmap(struct fb_cmap *cmap);
+extern int fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to);
+extern int fb_cmap_to_user(struct fb_cmap *from, struct fb_cmap_user *to);
+extern int fb_set_cmap(struct fb_cmap *cmap, struct fb_info *fb_info);
+extern int fb_set_user_cmap(struct fb_cmap_user *cmap, struct fb_info *fb_info);
+extern struct fb_cmap *fb_default_cmap(int len);
+extern void fb_invert_cmaps(void);
+
+struct fb_videomode {
+        const char *name;       /* optional */
+        u32 refresh;            /* optional */
+        u32 xres;
+        u32 yres;
+        u32 pixclock;
+        u32 left_margin;
+        u32 right_margin;
+        u32 upper_margin;
+        u32 lower_margin;
+        u32 hsync_len;
+        u32 vsync_len;
+        u32 sync;
+        u32 vmode;
+        u32 flag;
+};
+
+extern const struct fb_videomode vesa_modes[];
+
+struct fb_modelist {
+        struct list_head list;
+        struct fb_videomode mode;
+};
+
+extern int fb_find_mode(struct fb_var_screeninfo *var,
+                        struct fb_info *info, const char *mode_option,
+                        const struct fb_videomode *db,
+                        unsigned int dbsize,
+                        const struct fb_videomode *default_mode,
+                        unsigned int default_bpp);
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_FB_H */
diff --git a/include/linux/fcdevice.h b/include/linux/fcdevice.h
new file mode 100644
index 000000000000..e460ef831984
--- /dev/null
+++ b/include/linux/fcdevice.h
@@ -0,0 +1,33 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  NET  is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the Fibre Channel handlers.
+ *
+ * Version:     @(#)fcdevice.h  1.0.0   09/26/98
+ *
+ * Authors:     Vineet Abraham <vma@iol.unh.edu>
+ *
+ *              Relocated to include/linux where it belongs by Alan Cox 
+ *                                                      <gw4pts@gw4pts.ampr.org>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ *      WARNING: This move may well be temporary. This file will get merged with others RSN.
+ *
+ */
+#ifndef _LINUX_FCDEVICE_H
+#define _LINUX_FCDEVICE_H
+
+
+#include <linux/if_fc.h>
+
+#ifdef __KERNEL__
+extern struct net_device *alloc_fcdev(int sizeof_priv);
+#endif
+
+#endif  /* _LINUX_FCDEVICE_H */
diff --git a/include/linux/fcntl.h b/include/linux/fcntl.h
new file mode 100644
index 000000000000..704fb76b6334
--- /dev/null
+++ b/include/linux/fcntl.h
@@ -0,0 +1,50 @@
+#ifndef _LINUX_FCNTL_H
+#define _LINUX_FCNTL_H
+
+#include <asm/fcntl.h>
+
+#define F_SETLEASE      (F_LINUX_SPECIFIC_BASE+0)
+#define F_GETLEASE      (F_LINUX_SPECIFIC_BASE+1)
+
+/*
+ * Request nofications on a directory.
+ * See below for events that may be notified.
+ */
+#define F_NOTIFY        (F_LINUX_SPECIFIC_BASE+2)
+
+/*
+ * Types of directory notifications that may be requested.
+ */
+#define DN_ACCESS       0x00000001      /* File accessed */
+#define DN_MODIFY       0x00000002      /* File modified */
+#define DN_CREATE       0x00000004      /* File created */
+#define DN_DELETE       0x00000008      /* File removed */
+#define DN_RENAME       0x00000010      /* File renamed */
+#define DN_ATTRIB       0x00000020      /* File changed attibutes */
+#define DN_MULTISHOT    0x80000000      /* Don't remove notifier */
+
+#ifdef __KERNEL__
+
+#if BITS_PER_LONG == 32
+#define IS_GETLK32(cmd)         ((cmd) == F_GETLK)
+#define IS_SETLK32(cmd)         ((cmd) == F_SETLK)
+#define IS_SETLKW32(cmd)        ((cmd) == F_SETLKW)
+#define IS_GETLK64(cmd)         ((cmd) == F_GETLK64)
+#define IS_SETLK64(cmd)         ((cmd) == F_SETLK64)
+#define IS_SETLKW64(cmd)        ((cmd) == F_SETLKW64)
+#else
+#define IS_GETLK32(cmd)         (0)
+#define IS_SETLK32(cmd)         (0)
+#define IS_SETLKW32(cmd)        (0)
+#define IS_GETLK64(cmd)         ((cmd) == F_GETLK)
+#define IS_SETLK64(cmd)         ((cmd) == F_SETLK)
+#define IS_SETLKW64(cmd)        ((cmd) == F_SETLKW)
+#endif /* BITS_PER_LONG == 32 */
+
+#define IS_GETLK(cmd)   (IS_GETLK32(cmd)  || IS_GETLK64(cmd))
+#define IS_SETLK(cmd)   (IS_SETLK32(cmd)  || IS_SETLK64(cmd))
+#define IS_SETLKW(cmd)  (IS_SETLKW32(cmd) || IS_SETLKW64(cmd))
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/fd.h b/include/linux/fd.h
new file mode 100644
index 000000000000..b6bd41d2b460
--- /dev/null
+++ b/include/linux/fd.h
@@ -0,0 +1,374 @@
+#ifndef _LINUX_FD_H
+#define _LINUX_FD_H
+
+#include <linux/ioctl.h>
+#include <linux/compiler.h>
+
+/* New file layout: Now the ioctl definitions immediately follow the
+ * definitions of the structures that they use */
+
+/*
+ * Geometry
+ */
+struct floppy_struct {
+        unsigned int    size,           /* nr of sectors total */
+                        sect,           /* sectors per track */
+                        head,           /* nr of heads */
+                        track,          /* nr of tracks */
+                        stretch;        /* !=0 means double track steps */
+#define FD_STRETCH 1
+#define FD_SWAPSIDES 2
+#define FD_ZEROBASED 4
+
+        unsigned char   gap,            /* gap1 size */
+
+                        rate,           /* data rate. |= 0x40 for perpendicular */
+#define FD_2M 0x4
+#define FD_SIZECODEMASK 0x38
+#define FD_SIZECODE(floppy) (((((floppy)->rate&FD_SIZECODEMASK)>> 3)+ 2) %8)
+#define FD_SECTSIZE(floppy) ( (floppy)->rate & FD_2M ? \
+                             512 : 128 << FD_SIZECODE(floppy) )
+#define FD_PERP 0x40
+
+                        spec1,          /* stepping rate, head unload time */
+                        fmt_gap;        /* gap2 size */
+        const char      * name; /* used only for predefined formats */
+};
+
+
+/* commands needing write access have 0x40 set */
+/* commands needing super user access have 0x80 set */
+
+#define FDCLRPRM _IO(2, 0x41)
+/* clear user-defined parameters */
+
+#define FDSETPRM _IOW(2, 0x42, struct floppy_struct) 
+#define FDSETMEDIAPRM FDSETPRM
+/* set user-defined parameters for current media */
+
+#define FDDEFPRM _IOW(2, 0x43, struct floppy_struct) 
+#define FDGETPRM _IOR(2, 0x04, struct floppy_struct)
+#define FDDEFMEDIAPRM FDDEFPRM
+#define FDGETMEDIAPRM FDGETPRM
+/* set/get disk parameters */
+
+
+#define FDMSGON  _IO(2,0x45)
+#define FDMSGOFF _IO(2,0x46)
+/* issue/don't issue kernel messages on media type change */
+
+
+/* 
+ * Formatting (obsolete)
+ */
+#define FD_FILL_BYTE 0xF6 /* format fill byte. */
+
+struct format_descr {
+        unsigned int device,head,track;
+};
+
+#define FDFMTBEG _IO(2,0x47)
+/* begin formatting a disk */
+#define FDFMTTRK _IOW(2,0x48, struct format_descr)
+/* format the specified track */
+#define FDFMTEND _IO(2,0x49)
+/* end formatting a disk */
+
+
+/*
+ * Error thresholds
+ */
+struct floppy_max_errors {
+        unsigned int
+          abort,      /* number of errors to be reached before aborting */
+          read_track, /* maximal number of errors permitted to read an
+                       * entire track at once */
+          reset,      /* maximal number of errors before a reset is tried */
+          recal,      /* maximal number of errors before a recalibrate is
+                       * tried */
+
+          /*
+           * Threshold for reporting FDC errors to the console.
+           * Setting this to zero may flood your screen when using
+           * ultra cheap floppies ;-)
+           */
+          reporting;
+
+};
+
+#define FDSETEMSGTRESH  _IO(2,0x4a)
+/* set fdc error reporting threshold */
+
+#define FDFLUSH  _IO(2,0x4b)
+/* flush buffers for media; either for verifying media, or for
+ * handling a media change without closing the file descriptor */
+
+#define FDSETMAXERRS _IOW(2, 0x4c, struct floppy_max_errors)
+#define FDGETMAXERRS _IOR(2, 0x0e, struct floppy_max_errors)
+/* set/get abortion and read_track threshold. See also floppy_drive_params
+ * structure */
+
+
+typedef char floppy_drive_name[16];
+#define FDGETDRVTYP _IOR(2, 0x0f, floppy_drive_name)
+/* get drive type: 5 1/4 or 3 1/2 */
+
+
+/*
+ * Drive parameters (user modifiable)
+ */
+struct floppy_drive_params {
+        signed char cmos;               /* CMOS type */
+        
+        /* Spec2 is (HLD<<1 | ND), where HLD is head load time (1=2ms, 2=4 ms 
+         * etc) and ND is set means no DMA. Hardcoded to 6 (HLD=6ms, use DMA).
+         */
+        unsigned long max_dtr;          /* Step rate, usec */
+        unsigned long hlt;              /* Head load/settle time, msec */
+        unsigned long hut;              /* Head unload time (remnant of 
+                                         * 8" drives) */
+        unsigned long srt;              /* Step rate, usec */
+
+        unsigned long spinup;           /* time needed for spinup (expressed
+                                         * in jiffies) */
+        unsigned long spindown;         /* timeout needed for spindown */
+        unsigned char spindown_offset;  /* decides in which position the disk
+                                         * will stop */
+        unsigned char select_delay;     /* delay to wait after select */
+        unsigned char rps;              /* rotations per second */
+        unsigned char tracks;           /* maximum number of tracks */
+        unsigned long timeout;          /* timeout for interrupt requests */
+        
+        unsigned char interleave_sect;  /* if there are more sectors, use 
+                                         * interleave */
+        
+        struct floppy_max_errors max_errors;
+        
+        char flags;                     /* various flags, including ftd_msg */
+/*
+ * Announce successful media type detection and media information loss after
+ * disk changes.
+ * Also used to enable/disable printing of overrun warnings.
+ */
+
+#define FTD_MSG 0x10
+#define FD_BROKEN_DCL 0x20
+#define FD_DEBUG 0x02
+#define FD_SILENT_DCL_CLEAR 0x4
+#define FD_INVERTED_DCL 0x80 /* must be 0x80, because of hardware 
+                                considerations */
+
+        char read_track;                /* use readtrack during probing? */
+
+/*
+ * Auto-detection. Each drive type has eight formats which are
+ * used in succession to try to read the disk. If the FDC cannot lock onto
+ * the disk, the next format is tried. This uses the variable 'probing'.
+ */
+        short autodetect[8];            /* autodetected formats */
+        
+        int checkfreq; /* how often should the drive be checked for disk 
+                        * changes */
+        int native_format; /* native format of this drive */
+};
+
+enum {
+        FD_NEED_TWADDLE_BIT,    /* more magic */
+        FD_VERIFY_BIT,          /* inquire for write protection */
+        FD_DISK_NEWCHANGE_BIT,  /* change detected, and no action undertaken yet
+                                 * to clear media change status */
+        FD_UNUSED_BIT,
+        FD_DISK_CHANGED_BIT,    /* disk has been changed since last i/o */
+        FD_DISK_WRITABLE_BIT    /* disk is writable */
+};
+
+#define FDSETDRVPRM _IOW(2, 0x90, struct floppy_drive_params)
+#define FDGETDRVPRM _IOR(2, 0x11, struct floppy_drive_params)
+/* set/get drive parameters */
+
+
+/*
+ * Current drive state (not directly modifiable by user, readonly)
+ */
+struct floppy_drive_struct {
+        unsigned long flags;
+/* values for these flags */
+#define FD_NEED_TWADDLE (1 << FD_NEED_TWADDLE_BIT)
+#define FD_VERIFY (1 << FD_VERIFY_BIT)
+#define FD_DISK_NEWCHANGE (1 << FD_DISK_NEWCHANGE_BIT)
+#define FD_DISK_CHANGED (1 << FD_DISK_CHANGED_BIT)
+#define FD_DISK_WRITABLE (1 << FD_DISK_WRITABLE_BIT)
+
+        unsigned long spinup_date;
+        unsigned long select_date;
+        unsigned long first_read_date;
+        short probed_format;
+        short track; /* current track */
+        short maxblock; /* id of highest block read */
+        short maxtrack; /* id of highest half track read */
+        int generation; /* how many diskchanges? */
+
+/*
+ * (User-provided) media information is _not_ discarded after a media change
+ * if the corresponding keep_data flag is non-zero. Positive values are
+ * decremented after each probe.
+ */
+        int keep_data;
+        
+        /* Prevent "aliased" accesses. */
+        int fd_ref;
+        int fd_device;
+        unsigned long last_checked; /* when was the drive last checked for a disk 
+                           * change? */
+        
+        char *dmabuf;
+        int bufblocks;
+};
+
+#define FDGETDRVSTAT _IOR(2, 0x12, struct floppy_drive_struct)
+#define FDPOLLDRVSTAT _IOR(2, 0x13, struct floppy_drive_struct)
+/* get drive state: GET returns the cached state, POLL polls for new state */
+
+
+/*
+ * reset FDC
+ */
+enum reset_mode {
+        FD_RESET_IF_NEEDED,     /* reset only if the reset flags is set */
+        FD_RESET_IF_RAWCMD,     /* obsolete */
+        FD_RESET_ALWAYS         /* reset always */
+};
+#define FDRESET _IO(2, 0x54)
+
+
+/*
+ * FDC state
+ */
+struct floppy_fdc_state {       
+        int spec1;              /* spec1 value last used */
+        int spec2;              /* spec2 value last used */
+        int dtr;
+        unsigned char version;  /* FDC version code */
+        unsigned char dor;
+        unsigned long address;  /* io address */
+        unsigned int rawcmd:2;
+        unsigned int reset:1;
+        unsigned int need_configure:1;
+        unsigned int perp_mode:2;
+        unsigned int has_fifo:1;
+        unsigned int driver_version;    /* version code for floppy driver */
+#define FD_DRIVER_VERSION 0x100
+/* user programs using the floppy API should use floppy_fdc_state to
+ * get the version number of the floppy driver that they are running
+ * on. If this version number is bigger than the one compiled into the
+ * user program (the FD_DRIVER_VERSION define), it should be prepared
+ * to bigger structures
+ */
+
+        unsigned char track[4];
+        /* Position of the heads of the 4 units attached to this FDC,
+         * as stored on the FDC. In the future, the position as stored
+         * on the FDC might not agree with the actual physical
+         * position of these drive heads. By allowing such
+         * disagreement, it will be possible to reset the FDC without
+         * incurring the expensive cost of repositioning all heads.
+         * Right now, these positions are hard wired to 0. */
+
+};
+
+#define FDGETFDCSTAT _IOR(2, 0x15, struct floppy_fdc_state)
+
+
+/*
+ * Asynchronous Write error tracking
+ */
+struct floppy_write_errors {
+        /* Write error logging.
+         *
+         * These fields can be cleared with the FDWERRORCLR ioctl.
+         * Only writes that were attempted but failed due to a physical media
+         * error are logged.  write(2) calls that fail and return an error code
+         * to the user process are not counted.
+         */
+
+        unsigned int write_errors;  /* number of physical write errors 
+                                     * encountered */
+        
+        /* position of first and last write errors */
+        unsigned long first_error_sector;
+        int           first_error_generation;
+        unsigned long last_error_sector;
+        int           last_error_generation;
+        
+        unsigned int badness; /* highest retry count for a read or write 
+                               * operation */
+};
+
+#define FDWERRORCLR  _IO(2, 0x56)
+/* clear write error and badness information */
+#define FDWERRORGET  _IOR(2, 0x17, struct floppy_write_errors)
+/* get write error and badness information */
+
+
+/*
+ * Raw commands
+ */
+/* new interface flag: now we can do them in batches */
+#define FDHAVEBATCHEDRAWCMD
+
+struct floppy_raw_cmd {
+        unsigned int flags;
+#define FD_RAW_READ 1
+#define FD_RAW_WRITE 2
+#define FD_RAW_NO_MOTOR 4
+#define FD_RAW_DISK_CHANGE 4 /* out: disk change flag was set */
+#define FD_RAW_INTR 8    /* wait for an interrupt */
+#define FD_RAW_SPIN 0x10 /* spin up the disk for this command */
+#define FD_RAW_NO_MOTOR_AFTER 0x20 /* switch the motor off after command 
+                                    * completion */
+#define FD_RAW_NEED_DISK 0x40  /* this command needs a disk to be present */
+#define FD_RAW_NEED_SEEK 0x80  /* this command uses an implied seek (soft) */
+
+/* more "in" flags */
+#define FD_RAW_MORE 0x100  /* more records follow */
+#define FD_RAW_STOP_IF_FAILURE 0x200 /* stop if we encounter a failure */
+#define FD_RAW_STOP_IF_SUCCESS 0x400 /* stop if command successful */
+#define FD_RAW_SOFTFAILURE 0x800 /* consider the return value for failure
+                                  * detection too */
+
+/* more "out" flags */
+#define FD_RAW_FAILURE 0x10000 /* command sent to fdc, fdc returned error */
+#define FD_RAW_HARDFAILURE 0x20000 /* fdc had to be reset, or timed out */
+
+        void __user *data;
+        char *kernel_data; /* location of data buffer in the kernel */
+        struct floppy_raw_cmd *next; /* used for chaining of raw cmd's 
+                                      * within the kernel */
+        long length; /* in: length of dma transfer. out: remaining bytes */
+        long phys_length; /* physical length, if different from dma length */
+        int buffer_length; /* length of allocated buffer */
+
+        unsigned char rate;
+        unsigned char cmd_count;
+        unsigned char cmd[16];
+        unsigned char reply_count;
+        unsigned char reply[16];
+        int track;
+        int resultcode;
+
+        int reserved1;
+        int reserved2;
+};
+
+#define FDRAWCMD _IO(2, 0x58)
+/* send a raw command to the fdc. Structure size not included, because of
+ * batches */
+
+#define FDTWADDLE _IO(2, 0x59)
+/* flicker motor-on bit before reading a sector. Experimental */
+
+
+#define FDEJECT _IO(2, 0x5a)
+/* eject the disk */
+
+#endif
diff --git a/include/linux/fd1772.h b/include/linux/fd1772.h
new file mode 100644
index 000000000000..871d6e4c677e
--- /dev/null
+++ b/include/linux/fd1772.h
@@ -0,0 +1,80 @@
+#ifndef _LINUX_FD1772REG_H
+#define _LINUX_FD1772REG_H
+
+/*
+** WD1772 stuff - originally from the M68K Linux
+ * Modified for Archimedes by Dave Gilbert (gilbertd@cs.man.ac.uk)
+ */
+
+/* register codes */
+
+#define FDC1772SELREG_STP   (0x80)   /* command/status register */
+#define FDC1772SELREG_TRA   (0x82)   /* track register */
+#define FDC1772SELREG_SEC   (0x84)   /* sector register */
+#define FDC1772SELREG_DTA   (0x86)   /* data register */
+
+/* register names for FDC1772_READ/WRITE macros */
+
+#define FDC1772REG_CMD         0
+#define FDC1772REG_STATUS      0
+#define FDC1772REG_TRACK       2
+#define FDC1772REG_SECTOR      4
+#define FDC1772REG_DATA                6
+
+/* command opcodes */
+
+#define FDC1772CMD_RESTORE  (0x00)   /*  -                   */
+#define FDC1772CMD_SEEK     (0x10)   /*   |                  */
+#define FDC1772CMD_STEP     (0x20)   /*   |  TYP 1 Commands  */
+#define FDC1772CMD_STIN     (0x40)   /*   |                  */
+#define FDC1772CMD_STOT     (0x60)   /*  -                   */
+#define FDC1772CMD_RDSEC    (0x80)   /*  -   TYP 2 Commands  */
+#define FDC1772CMD_WRSEC    (0xa0)   /*  -          "        */
+#define FDC1772CMD_RDADR    (0xc0)   /*  -                   */
+#define FDC1772CMD_RDTRA    (0xe0)   /*   |  TYP 3 Commands  */
+#define FDC1772CMD_WRTRA    (0xf0)   /*  -                   */
+#define FDC1772CMD_FORCI    (0xd0)   /*  -   TYP 4 Command   */
+
+/* command modifier bits */
+
+#define FDC1772CMDADD_SR6   (0x00)   /* step rate settings */
+#define FDC1772CMDADD_SR12  (0x01)
+#define FDC1772CMDADD_SR2   (0x02)
+#define FDC1772CMDADD_SR3   (0x03)
+#define FDC1772CMDADD_V     (0x04)   /* verify */
+#define FDC1772CMDADD_H     (0x08)   /* wait for spin-up */
+#define FDC1772CMDADD_U     (0x10)   /* update track register */
+#define FDC1772CMDADD_M     (0x10)   /* multiple sector access */
+#define FDC1772CMDADD_E     (0x04)   /* head settling flag */
+#define FDC1772CMDADD_P     (0x02)   /* precompensation */
+#define FDC1772CMDADD_A0    (0x01)   /* DAM flag */
+
+/* status register bits */
+
+#define        FDC1772STAT_MOTORON     (0x80)   /* motor on */
+#define        FDC1772STAT_WPROT       (0x40)   /* write protected (FDC1772CMD_WR*) */
+#define        FDC1772STAT_SPINUP      (0x20)   /* motor speed stable (Type I) */
+#define        FDC1772STAT_DELDAM      (0x20)   /* sector has deleted DAM (Type II+III) */
+#define        FDC1772STAT_RECNF       (0x10)   /* record not found */
+#define        FDC1772STAT_CRC         (0x08)   /* CRC error */
+#define        FDC1772STAT_TR00        (0x04)   /* Track 00 flag (Type I) */
+#define        FDC1772STAT_LOST        (0x04)   /* Lost Data (Type II+III) */
+#define        FDC1772STAT_IDX         (0x02)   /* Index status (Type I) */
+#define        FDC1772STAT_DRQ         (0x02)   /* DRQ status (Type II+III) */
+#define        FDC1772STAT_BUSY        (0x01)   /* FDC1772 is busy */
+
+
+/* PSG Port A Bit Nr 0 .. Side Sel .. 0 -> Side 1  1 -> Side 2 */
+#define DSKSIDE     (0x01)
+        
+#define DSKDRVNONE  (0x06)
+#define DSKDRV0     (0x02)
+#define DSKDRV1     (0x04)
+
+/* step rates */
+#define        FDC1772STEP_6   0x00
+#define        FDC1772STEP_12  0x01
+#define        FDC1772STEP_2   0x02
+#define        FDC1772STEP_3   0x03
+
+#endif
diff --git a/include/linux/fddidevice.h b/include/linux/fddidevice.h
new file mode 100644
index 000000000000..2e5ee47f3e1e
--- /dev/null
+++ b/include/linux/fddidevice.h
@@ -0,0 +1,33 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the FDDI handlers.
+ *
+ * Version:     @(#)fddidevice.h        1.0.0   08/12/96
+ *
+ * Author:      Lawrence V. Stefani, <stefani@lkg.dec.com>
+ *
+ *              fddidevice.h is based on previous trdevice.h work by
+ *                      Ross Biro, <bir7@leland.Stanford.Edu>
+ *                      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *                      Alan Cox, <gw4pts@gw4pts.ampr.org>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_FDDIDEVICE_H
+#define _LINUX_FDDIDEVICE_H
+
+#include <linux/if_fddi.h>
+
+#ifdef __KERNEL__
+extern unsigned short   fddi_type_trans(struct sk_buff *skb,
+                                struct net_device *dev);
+extern struct net_device *alloc_fddidev(int sizeof_priv);
+#endif
+
+#endif  /* _LINUX_FDDIDEVICE_H */
diff --git a/include/linux/fdreg.h b/include/linux/fdreg.h
new file mode 100644
index 000000000000..c2eeb63b72db
--- /dev/null
+++ b/include/linux/fdreg.h
@@ -0,0 +1,137 @@
+#ifndef _LINUX_FDREG_H
+#define _LINUX_FDREG_H
+/*
+ * This file contains some defines for the floppy disk controller.
+ * Various sources. Mostly "IBM Microcomputers: A Programmers
+ * Handbook", Sanches and Canton.
+ */
+
+#ifdef FDPATCHES
+#define FD_IOPORT fdc_state[fdc].address
+#else
+/* It would be a lot saner just to force fdc_state[fdc].address to always
+   be set ! FIXME */
+#define FD_IOPORT 0x3f0
+#endif
+
+/* Fd controller regs. S&C, about page 340 */
+#define FD_STATUS       (4 + FD_IOPORT )
+#define FD_DATA         (5 + FD_IOPORT )
+
+/* Digital Output Register */
+#define FD_DOR          (2 + FD_IOPORT )
+
+/* Digital Input Register (read) */
+#define FD_DIR          (7 + FD_IOPORT )
+
+/* Diskette Control Register (write)*/
+#define FD_DCR          (7 + FD_IOPORT )
+
+/* Bits of main status register */
+#define STATUS_BUSYMASK 0x0F            /* drive busy mask */
+#define STATUS_BUSY     0x10            /* FDC busy */
+#define STATUS_DMA      0x20            /* 0- DMA mode */
+#define STATUS_DIR      0x40            /* 0- cpu->fdc */
+#define STATUS_READY    0x80            /* Data reg ready */
+
+/* Bits of FD_ST0 */
+#define ST0_DS          0x03            /* drive select mask */
+#define ST0_HA          0x04            /* Head (Address) */
+#define ST0_NR          0x08            /* Not Ready */
+#define ST0_ECE         0x10            /* Equipment check error */
+#define ST0_SE          0x20            /* Seek end */
+#define ST0_INTR        0xC0            /* Interrupt code mask */
+
+/* Bits of FD_ST1 */
+#define ST1_MAM         0x01            /* Missing Address Mark */
+#define ST1_WP          0x02            /* Write Protect */
+#define ST1_ND          0x04            /* No Data - unreadable */
+#define ST1_OR          0x10            /* OverRun */
+#define ST1_CRC         0x20            /* CRC error in data or addr */
+#define ST1_EOC         0x80            /* End Of Cylinder */
+
+/* Bits of FD_ST2 */
+#define ST2_MAM         0x01            /* Missing Address Mark (again) */
+#define ST2_BC          0x02            /* Bad Cylinder */
+#define ST2_SNS         0x04            /* Scan Not Satisfied */
+#define ST2_SEH         0x08            /* Scan Equal Hit */
+#define ST2_WC          0x10            /* Wrong Cylinder */
+#define ST2_CRC         0x20            /* CRC error in data field */
+#define ST2_CM          0x40            /* Control Mark = deleted */
+
+/* Bits of FD_ST3 */
+#define ST3_HA          0x04            /* Head (Address) */
+#define ST3_DS          0x08            /* drive is double-sided */
+#define ST3_TZ          0x10            /* Track Zero signal (1=track 0) */
+#define ST3_RY          0x20            /* drive is ready */
+#define ST3_WP          0x40            /* Write Protect */
+#define ST3_FT          0x80            /* Drive Fault */
+
+/* Values for FD_COMMAND */
+#define FD_RECALIBRATE          0x07    /* move to track 0 */
+#define FD_SEEK                 0x0F    /* seek track */
+#define FD_READ                 0xE6    /* read with MT, MFM, SKip deleted */
+#define FD_WRITE                0xC5    /* write with MT, MFM */
+#define FD_SENSEI               0x08    /* Sense Interrupt Status */
+#define FD_SPECIFY              0x03    /* specify HUT etc */
+#define FD_FORMAT               0x4D    /* format one track */
+#define FD_VERSION              0x10    /* get version code */
+#define FD_CONFIGURE            0x13    /* configure FIFO operation */
+#define FD_PERPENDICULAR        0x12    /* perpendicular r/w mode */
+#define FD_GETSTATUS            0x04    /* read ST3 */
+#define FD_DUMPREGS             0x0E    /* dump the contents of the fdc regs */
+#define FD_READID               0xEA    /* prints the header of a sector */
+#define FD_UNLOCK               0x14    /* Fifo config unlock */
+#define FD_LOCK                 0x94    /* Fifo config lock */
+#define FD_RSEEK_OUT            0x8f    /* seek out (i.e. to lower tracks) */
+#define FD_RSEEK_IN             0xcf    /* seek in (i.e. to higher tracks) */
+
+/* the following commands are new in the 82078. They are not used in the
+ * floppy driver, except the first three. These commands may be useful for apps
+ * which use the FDRAWCMD interface. For doc, get the 82078 spec sheets at
+ * http://www-techdoc.intel.com/docs/periph/fd_contr/datasheets/ */
+
+#define FD_PARTID               0x18    /* part id ("extended" version cmd) */
+#define FD_SAVE                 0x2e    /* save fdc regs for later restore */
+#define FD_DRIVESPEC            0x8e    /* drive specification: Access to the
+                                         * 2 Mbps data transfer rate for tape
+                                         * drives */
+
+#define FD_RESTORE              0x4e    /* later restore */
+#define FD_POWERDOWN            0x27    /* configure FDC's powersave features */
+#define FD_FORMAT_N_WRITE       0xef    /* format and write in one go. */
+#define FD_OPTION               0x33    /* ISO format (which is a clean way to
+                                         * pack more sectors on a track) */
+
+/* DMA commands */
+#define DMA_READ        0x46
+#define DMA_WRITE       0x4A
+
+/* FDC version return types */
+#define FDC_NONE        0x00
+#define FDC_UNKNOWN     0x10    /* DO NOT USE THIS TYPE EXCEPT IF IDENTIFICATION
+                                   FAILS EARLY */
+#define FDC_8272A       0x20    /* Intel 8272a, NEC 765 */
+#define FDC_765ED       0x30    /* Non-Intel 1MB-compatible FDC, can't detect */
+#define FDC_82072       0x40    /* Intel 82072; 8272a + FIFO + DUMPREGS */
+#define FDC_82072A      0x45    /* 82072A (on Sparcs) */
+#define FDC_82077_ORIG  0x51    /* Original version of 82077AA, sans LOCK */
+#define FDC_82077       0x52    /* 82077AA-1 */
+#define FDC_82078_UNKN  0x5f    /* Unknown 82078 variant */
+#define FDC_82078       0x60    /* 44pin 82078 or 64pin 82078SL */
+#define FDC_82078_1     0x61    /* 82078-1 (2Mbps fdc) */
+#define FDC_S82078B     0x62    /* S82078B (first seen on Adaptec AVA-2825 VLB
+                                 * SCSI/EIDE/Floppy controller) */
+#define FDC_87306       0x63    /* National Semiconductor PC 87306 */
+
+/*
+ * Beware: the fdc type list is roughly sorted by increasing features.
+ * Presence of features is tested by comparing the FDC version id with the
+ * "oldest" version that has the needed feature.
+ * If during FDC detection, an obscure test fails late in the sequence, don't
+ * assign FDC_UNKNOWN. Else the FDC will be treated as a dumb 8272a, or worse.
+ * This is especially true if the tests are unneeded.
+ */
+
+#define FD_RESET_DELAY 20
+#endif
diff --git a/include/linux/file.h b/include/linux/file.h
new file mode 100644
index 000000000000..5206beb9a80e
--- /dev/null
+++ b/include/linux/file.h
@@ -0,0 +1,84 @@
+/*
+ * Wrapper functions for accessing the file_struct fd array.
+ */
+
+#ifndef __LINUX_FILE_H
+#define __LINUX_FILE_H
+
+#include <asm/atomic.h>
+#include <linux/posix_types.h>
+#include <linux/compiler.h>
+#include <linux/spinlock.h>
+
+/*
+ * The default fd array needs to be at least BITS_PER_LONG,
+ * as this is the granularity returned by copy_fdset().
+ */
+#define NR_OPEN_DEFAULT BITS_PER_LONG
+
+/*
+ * Open file table structure
+ */
+struct files_struct {
+        atomic_t count;
+        spinlock_t file_lock;     /* Protects all the below members.  Nests inside tsk->alloc_lock */
+        int max_fds;
+        int max_fdset;
+        int next_fd;
+        struct file ** fd;      /* current fd array */
+        fd_set *close_on_exec;
+        fd_set *open_fds;
+        fd_set close_on_exec_init;
+        fd_set open_fds_init;
+        struct file * fd_array[NR_OPEN_DEFAULT];
+};
+
+extern void FASTCALL(__fput(struct file *));
+extern void FASTCALL(fput(struct file *));
+
+static inline void fput_light(struct file *file, int fput_needed)
+{
+        if (unlikely(fput_needed))
+                fput(file);
+}
+
+extern struct file * FASTCALL(fget(unsigned int fd));
+extern struct file * FASTCALL(fget_light(unsigned int fd, int *fput_needed));
+extern void FASTCALL(set_close_on_exec(unsigned int fd, int flag));
+extern void put_filp(struct file *);
+extern int get_unused_fd(void);
+extern void FASTCALL(put_unused_fd(unsigned int fd));
+struct kmem_cache_s;
+extern void filp_ctor(void * objp, struct kmem_cache_s *cachep, unsigned long cflags);
+extern void filp_dtor(void * objp, struct kmem_cache_s *cachep, unsigned long dflags);
+
+extern struct file ** alloc_fd_array(int);
+extern void free_fd_array(struct file **, int);
+
+extern fd_set *alloc_fdset(int);
+extern void free_fdset(fd_set *, int);
+
+extern int expand_files(struct files_struct *, int nr);
+
+static inline struct file * fcheck_files(struct files_struct *files, unsigned int fd)
+{
+        struct file * file = NULL;
+
+        if (fd < files->max_fds)
+                file = files->fd[fd];
+        return file;
+}
+
+/*
+ * Check whether the specified fd has an open file.
+ */
+#define fcheck(fd)      fcheck_files(current->files, fd)
+
+extern void FASTCALL(fd_install(unsigned int fd, struct file * file));
+
+struct task_struct;
+
+struct files_struct *get_files_struct(struct task_struct *);
+void FASTCALL(put_files_struct(struct files_struct *fs));
+
+#endif /* __LINUX_FILE_H */
diff --git a/include/linux/filter.h b/include/linux/filter.h
new file mode 100644
index 000000000000..3ba843c46382
--- /dev/null
+++ b/include/linux/filter.h
@@ -0,0 +1,151 @@
+/*
+ * Linux Socket Filter Data Structures
+ */
+
+#ifndef __LINUX_FILTER_H__
+#define __LINUX_FILTER_H__
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+#ifdef __KERNEL__
+#include <asm/atomic.h>
+#endif
+
+/*
+ * Current version of the filter code architecture.
+ */
+#define BPF_MAJOR_VERSION 1
+#define BPF_MINOR_VERSION 1
+
+/*
+ *      Try and keep these values and structures similar to BSD, especially
+ *      the BPF code definitions which need to match so you can share filters
+ */
+ 
+struct sock_filter      /* Filter block */
+{
+        __u16   code;   /* Actual filter code */
+        __u8    jt;     /* Jump true */
+        __u8    jf;     /* Jump false */
+        __u32   k;      /* Generic multiuse field */
+};
+
+struct sock_fprog       /* Required for SO_ATTACH_FILTER. */
+{
+        unsigned short          len;    /* Number of filter blocks */
+        struct sock_filter __user *filter;
+};
+
+#ifdef __KERNEL__
+struct sk_filter
+{
+        atomic_t                refcnt;
+        unsigned int            len;    /* Number of filter blocks */
+        struct sock_filter      insns[0];
+};
+
+static inline unsigned int sk_filter_len(struct sk_filter *fp)
+{
+        return fp->len*sizeof(struct sock_filter) + sizeof(*fp);
+}
+#endif
+
+/*
+ * Instruction classes
+ */
+
+#define BPF_CLASS(code) ((code) & 0x07)
+#define         BPF_LD          0x00
+#define         BPF_LDX         0x01
+#define         BPF_ST          0x02
+#define         BPF_STX         0x03
+#define         BPF_ALU         0x04
+#define         BPF_JMP         0x05
+#define         BPF_RET         0x06
+#define         BPF_MISC        0x07
+
+/* ld/ldx fields */
+#define BPF_SIZE(code)  ((code) & 0x18)
+#define         BPF_W           0x00
+#define         BPF_H           0x08
+#define         BPF_B           0x10
+#define BPF_MODE(code)  ((code) & 0xe0)
+#define         BPF_IMM         0x00
+#define         BPF_ABS         0x20
+#define         BPF_IND         0x40
+#define         BPF_MEM         0x60
+#define         BPF_LEN         0x80
+#define         BPF_MSH         0xa0
+
+/* alu/jmp fields */
+#define BPF_OP(code)    ((code) & 0xf0)
+#define         BPF_ADD         0x00
+#define         BPF_SUB         0x10
+#define         BPF_MUL         0x20
+#define         BPF_DIV         0x30
+#define         BPF_OR          0x40
+#define         BPF_AND         0x50
+#define         BPF_LSH         0x60
+#define         BPF_RSH         0x70
+#define         BPF_NEG         0x80
+#define         BPF_JA          0x00
+#define         BPF_JEQ         0x10
+#define         BPF_JGT         0x20
+#define         BPF_JGE         0x30
+#define         BPF_JSET        0x40
+#define BPF_SRC(code)   ((code) & 0x08)
+#define         BPF_K           0x00
+#define         BPF_X           0x08
+
+/* ret - BPF_K and BPF_X also apply */
+#define BPF_RVAL(code)  ((code) & 0x18)
+#define         BPF_A           0x10
+
+/* misc */
+#define BPF_MISCOP(code) ((code) & 0xf8)
+#define         BPF_TAX         0x00
+#define         BPF_TXA         0x80
+
+#ifndef BPF_MAXINSNS
+#define BPF_MAXINSNS 4096
+#endif
+
+/*
+ * Macros for filter block array initializers.
+ */
+#ifndef BPF_STMT
+#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
+#endif
+#ifndef BPF_JUMP
+#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
+#endif
+
+/*
+ * Number of scratch memory words for: BPF_ST and BPF_STX
+ */
+#define BPF_MEMWORDS 16
+
+/* RATIONALE. Negative offsets are invalid in BPF.
+   We use them to reference ancillary data.
+   Unlike introduction new instructions, it does not break
+   existing compilers/optimizers.
+ */
+#define SKF_AD_OFF    (-0x1000)
+#define SKF_AD_PROTOCOL 0
+#define SKF_AD_PKTTYPE  4
+#define SKF_AD_IFINDEX  8
+#define SKF_AD_MAX      12
+#define SKF_NET_OFF   (-0x100000)
+#define SKF_LL_OFF    (-0x200000)
+
+#ifdef __KERNEL__
+struct sk_buff;
+struct sock;
+
+extern int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen);
+extern int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
+extern int sk_chk_filter(struct sock_filter *filter, int flen);
+#endif /* __KERNEL__ */
+
+#endif /* __LINUX_FILTER_H__ */
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
new file mode 100644
index 000000000000..886255b69bb9
--- /dev/null
+++ b/include/linux/firmware.h
@@ -0,0 +1,20 @@
+#ifndef _LINUX_FIRMWARE_H
+#define _LINUX_FIRMWARE_H
+#include <linux/module.h>
+#include <linux/types.h>
+#define FIRMWARE_NAME_MAX 30 
+struct firmware {
+        size_t size;
+        u8 *data;
+};
+struct device;
+int request_firmware(const struct firmware **fw, const char *name,
+                     struct device *device);
+int request_firmware_nowait(
+        struct module *module,
+        const char *name, struct device *device, void *context,
+        void (*cont)(const struct firmware *fw, void *context));
+
+void release_firmware(const struct firmware *fw);
+void register_firmware(const char *name, const u8 *data, size_t size);
+#endif
diff --git a/include/linux/flat.h b/include/linux/flat.h
new file mode 100644
index 000000000000..ec56852e2659
--- /dev/null
+++ b/include/linux/flat.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2002-2003  David McCullough <davidm@snapgear.com>
+ * Copyright (C) 1998       Kenneth Albanowski <kjahds@kjahds.com>
+ *                          The Silver Hammer Group, Ltd.
+ *
+ * This file provides the definitions and structures needed to
+ * support uClinux flat-format executables.
+ */
+
+#ifndef _LINUX_FLAT_H
+#define _LINUX_FLAT_H
+
+#ifdef __KERNEL__
+#include <asm/flat.h>
+#endif
+
+#define FLAT_VERSION                    0x00000004L
+
+#ifdef CONFIG_BINFMT_SHARED_FLAT
+#define MAX_SHARED_LIBS                 (4)
+#else
+#define MAX_SHARED_LIBS                 (1)
+#endif
+
+/*
+ * To make everything easier to port and manage cross platform
+ * development,  all fields are in network byte order.
+ */
+
+struct flat_hdr {
+        char magic[4];
+        unsigned long rev;          /* version (as above) */
+        unsigned long entry;        /* Offset of first executable instruction
+                                       with text segment from beginning of file */
+        unsigned long data_start;   /* Offset of data segment from beginning of
+                                       file */
+        unsigned long data_end;     /* Offset of end of data segment
+                                       from beginning of file */
+        unsigned long bss_end;      /* Offset of end of bss segment from beginning
+                                       of file */
+
+        /* (It is assumed that data_end through bss_end forms the bss segment.) */
+
+        unsigned long stack_size;   /* Size of stack, in bytes */
+        unsigned long reloc_start;  /* Offset of relocation records from
+                                       beginning of file */
+        unsigned long reloc_count;  /* Number of relocation records */
+        unsigned long flags;       
+        unsigned long build_date;   /* When the program/library was built */
+        unsigned long filler[5];    /* Reservered, set to zero */
+};
+
+#define FLAT_FLAG_RAM    0x0001 /* load program entirely into RAM */
+#define FLAT_FLAG_GOTPIC 0x0002 /* program is PIC with GOT */
+#define FLAT_FLAG_GZIP   0x0004 /* all but the header is compressed */
+#define FLAT_FLAG_GZDATA 0x0008 /* only data/relocs are compressed (for XIP) */
+#define FLAT_FLAG_KTRACE 0x0010 /* output useful kernel trace for debugging */
+
+
+#ifdef __KERNEL__ /* so systems without linux headers can compile the apps */
+/*
+ * While it would be nice to keep this header clean,  users of older
+ * tools still need this support in the kernel.  So this section is
+ * purely for compatibility with old tool chains.
+ *
+ * DO NOT make changes or enhancements to the old format please,  just work
+ *        with the format above,  except to fix bugs with old format support.
+ */
+
+#include <asm/byteorder.h>
+
+#define OLD_FLAT_VERSION                        0x00000002L
+#define OLD_FLAT_RELOC_TYPE_TEXT        0
+#define OLD_FLAT_RELOC_TYPE_DATA        1
+#define OLD_FLAT_RELOC_TYPE_BSS         2
+
+typedef union {
+        unsigned long   value;
+        struct {
+# if defined(mc68000) && !defined(CONFIG_COLDFIRE)
+                signed long offset : 30;
+                unsigned long type : 2;
+#       define OLD_FLAT_FLAG_RAM    0x1 /* load program entirely into RAM */
+# elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned long type : 2;
+                signed long offset : 30;
+#       define OLD_FLAT_FLAG_RAM    0x1 /* load program entirely into RAM */
+# elif defined(__LITTLE_ENDIAN_BITFIELD)
+                signed long offset : 30;
+                unsigned long type : 2;
+#       define OLD_FLAT_FLAG_RAM    0x1 /* load program entirely into RAM */
+# else
+#       error "Unknown bitfield order for flat files."
+# endif
+        } reloc;
+} flat_v2_reloc_t;
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_FLAT_H */
diff --git a/include/linux/font.h b/include/linux/font.h
new file mode 100644
index 000000000000..fc2d690c9d5f
--- /dev/null
+++ b/include/linux/font.h
@@ -0,0 +1,53 @@
+/*
+ *  font.h -- `Soft' font definitions
+ *
+ *  Created 1995 by Geert Uytterhoeven
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive
+ *  for more details.
+ */
+
+#ifndef _VIDEO_FONT_H
+#define _VIDEO_FONT_H
+
+#include <linux/types.h>
+
+struct font_desc {
+    int idx;
+    char *name;
+    int width, height;
+    void *data;
+    int pref;
+};
+
+#define VGA8x8_IDX      0
+#define VGA8x16_IDX     1
+#define PEARL8x8_IDX    2
+#define VGA6x11_IDX     3
+#define SUN8x16_IDX     4
+#define SUN12x22_IDX    5
+#define ACORN8x8_IDX    6
+#define MINI4x6_IDX     7
+
+extern struct font_desc font_vga_8x8,
+                                font_vga_8x16,
+                                font_pearl_8x8,
+                                font_vga_6x11,
+                                font_sun_8x16,
+                                font_sun_12x22,
+                                font_acorn_8x8,
+                                font_mini_4x6;
+
+/* Find a font with a specific name */
+
+extern struct font_desc *find_font(char *name);
+
+/* Get the default font for a specific screen size */
+
+extern struct font_desc *get_default_font(int xres, int yres);
+
+/* Max. length for the name of a predefined font */
+#define MAX_FONT_NAME   32
+
+#endif /* _VIDEO_FONT_H */
diff --git a/include/linux/fs.h b/include/linux/fs.h
new file mode 100644
index 000000000000..5df687d940fa
--- /dev/null
+++ b/include/linux/fs.h
@@ -0,0 +1,1677 @@
+#ifndef _LINUX_FS_H
+#define _LINUX_FS_H
+
+/*
+ * This file has definitions for some important file table
+ * structures etc.
+ */
+
+#include <linux/config.h>
+#include <linux/limits.h>
+#include <linux/ioctl.h>
+
+/*
+ * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
+ * the file limit at runtime and only root can increase the per-process
+ * nr_file rlimit, so it's safe to set up a ridiculously high absolute
+ * upper limit on files-per-process.
+ *
+ * Some programs (notably those using select()) may have to be 
+ * recompiled to take full advantage of the new limits..  
+ */
+
+/* Fixed constants first: */
+#undef NR_OPEN
+#define NR_OPEN (1024*1024)     /* Absolute upper limit on fd num */
+#define INR_OPEN 1024           /* Initial setting for nfile rlimits */
+
+#define BLOCK_SIZE_BITS 10
+#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
+
+/* And dynamically-tunable limits and defaults: */
+struct files_stat_struct {
+        int nr_files;           /* read only */
+        int nr_free_files;      /* read only */
+        int max_files;          /* tunable */
+};
+extern struct files_stat_struct files_stat;
+
+struct inodes_stat_t {
+        int nr_inodes;
+        int nr_unused;
+        int dummy[5];
+};
+extern struct inodes_stat_t inodes_stat;
+
+extern int leases_enable, lease_break_time;
+
+#ifdef CONFIG_DNOTIFY
+extern int dir_notify_enable;
+#endif
+
+#define NR_FILE  8192   /* this can well be larger on a larger system */
+
+#define MAY_EXEC 1
+#define MAY_WRITE 2
+#define MAY_READ 4
+#define MAY_APPEND 8
+
+#define FMODE_READ 1
+#define FMODE_WRITE 2
+
+/* Internal kernel extensions */
+#define FMODE_LSEEK     4
+#define FMODE_PREAD     8
+#define FMODE_PWRITE    FMODE_PREAD     /* These go hand in hand */
+
+#define RW_MASK         1
+#define RWA_MASK        2
+#define READ 0
+#define WRITE 1
+#define READA 2         /* read-ahead  - don't block if no resources */
+#define SPECIAL 4       /* For non-blockdevice requests in request queue */
+#define READ_SYNC       (READ | (1 << BIO_RW_SYNC))
+#define WRITE_SYNC      (WRITE | (1 << BIO_RW_SYNC))
+#define WRITE_BARRIER   ((1 << BIO_RW) | (1 << BIO_RW_BARRIER))
+
+#define SEL_IN          1
+#define SEL_OUT         2
+#define SEL_EX          4
+
+/* public flags for file_system_type */
+#define FS_REQUIRES_DEV 1 
+#define FS_BINARY_MOUNTDATA 2
+#define FS_REVAL_DOT    16384   /* Check the paths ".", ".." for staleness */
+#define FS_ODD_RENAME   32768   /* Temporary stuff; will go away as soon
+                                  * as nfs_rename() will be cleaned up
+                                  */
+/*
+ * These are the fs-independent mount-flags: up to 32 flags are supported
+ */
+#define MS_RDONLY        1      /* Mount read-only */
+#define MS_NOSUID        2      /* Ignore suid and sgid bits */
+#define MS_NODEV         4      /* Disallow access to device special files */
+#define MS_NOEXEC        8      /* Disallow program execution */
+#define MS_SYNCHRONOUS  16      /* Writes are synced at once */
+#define MS_REMOUNT      32      /* Alter flags of a mounted FS */
+#define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */
+#define MS_DIRSYNC      128     /* Directory modifications are synchronous */
+#define MS_NOATIME      1024    /* Do not update access times. */
+#define MS_NODIRATIME   2048    /* Do not update directory access times */
+#define MS_BIND         4096
+#define MS_MOVE         8192
+#define MS_REC          16384
+#define MS_VERBOSE      32768
+#define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
+#define MS_ACTIVE       (1<<30)
+#define MS_NOUSER       (1<<31)
+
+/*
+ * Superblock flags that can be altered by MS_REMOUNT
+ */
+#define MS_RMT_MASK     (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_NOATIME|\
+                         MS_NODIRATIME)
+
+/*
+ * Old magic mount flag and mask
+ */
+#define MS_MGC_VAL 0xC0ED0000
+#define MS_MGC_MSK 0xffff0000
+
+/* Inode flags - they have nothing to superblock flags now */
+
+#define S_SYNC          1       /* Writes are synced at once */
+#define S_NOATIME       2       /* Do not update access times */
+#define S_APPEND        4       /* Append-only file */
+#define S_IMMUTABLE     8       /* Immutable file */
+#define S_DEAD          16      /* removed, but still open directory */
+#define S_NOQUOTA       32      /* Inode is not counted to quota */
+#define S_DIRSYNC       64      /* Directory modifications are synchronous */
+#define S_NOCMTIME      128     /* Do not update file c/mtime */
+#define S_SWAPFILE      256     /* Do not truncate: swapon got its bmaps */
+#define S_PRIVATE       512     /* Inode is fs-internal */
+
+/*
+ * Note that nosuid etc flags are inode-specific: setting some file-system
+ * flags just means all the inodes inherit those flags by default. It might be
+ * possible to override it selectively if you really wanted to with some
+ * ioctl() that is not currently implemented.
+ *
+ * Exception: MS_RDONLY is always applied to the entire file system.
+ *
+ * Unfortunately, it is possible to change a filesystems flags with it mounted
+ * with files in use.  This means that all of the inodes will not have their
+ * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
+ * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
+ */
+#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
+
+#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
+#define IS_SYNC(inode)          (__IS_FLG(inode, MS_SYNCHRONOUS) || \
+                                        ((inode)->i_flags & S_SYNC))
+#define IS_DIRSYNC(inode)       (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
+                                        ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
+#define IS_MANDLOCK(inode)      __IS_FLG(inode, MS_MANDLOCK)
+
+#define IS_NOQUOTA(inode)       ((inode)->i_flags & S_NOQUOTA)
+#define IS_APPEND(inode)        ((inode)->i_flags & S_APPEND)
+#define IS_IMMUTABLE(inode)     ((inode)->i_flags & S_IMMUTABLE)
+#define IS_NOATIME(inode)       (__IS_FLG(inode, MS_NOATIME) || ((inode)->i_flags & S_NOATIME))
+#define IS_NODIRATIME(inode)    __IS_FLG(inode, MS_NODIRATIME)
+#define IS_POSIXACL(inode)      __IS_FLG(inode, MS_POSIXACL)
+
+#define IS_DEADDIR(inode)       ((inode)->i_flags & S_DEAD)
+#define IS_NOCMTIME(inode)      ((inode)->i_flags & S_NOCMTIME)
+#define IS_SWAPFILE(inode)      ((inode)->i_flags & S_SWAPFILE)
+#define IS_PRIVATE(inode)       ((inode)->i_flags & S_PRIVATE)
+
+/* the read-only stuff doesn't really belong here, but any other place is
+   probably as bad and I don't want to create yet another include file. */
+
+#define BLKROSET   _IO(0x12,93) /* set device read-only (0 = read-write) */
+#define BLKROGET   _IO(0x12,94) /* get read-only status (0 = read_write) */
+#define BLKRRPART  _IO(0x12,95) /* re-read partition table */
+#define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
+#define BLKFLSBUF  _IO(0x12,97) /* flush buffer cache */
+#define BLKRASET   _IO(0x12,98) /* set read ahead for block device */
+#define BLKRAGET   _IO(0x12,99) /* get current read ahead setting */
+#define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
+#define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
+#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
+#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
+#define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
+#if 0
+#define BLKPG      _IO(0x12,105)/* See blkpg.h */
+
+/* Some people are morons.  Do not use sizeof! */
+
+#define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
+#define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
+/* This was here just to show that the number is taken -
+   probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
+#endif
+/* A jump here: 108-111 have been used for various private purposes. */
+#define BLKBSZGET  _IOR(0x12,112,size_t)
+#define BLKBSZSET  _IOW(0x12,113,size_t)
+#define BLKGETSIZE64 _IOR(0x12,114,size_t)      /* return device size in bytes (u64 *arg) */
+
+#define BMAP_IOCTL 1            /* obsolete - kept for compatibility */
+#define FIBMAP     _IO(0x00,1)  /* bmap access */
+#define FIGETBSZ   _IO(0x00,2)  /* get the block size used for bmap */
+
+#ifdef __KERNEL__
+
+#include <linux/linkage.h>
+#include <linux/wait.h>
+#include <linux/types.h>
+#include <linux/kdev_t.h>
+#include <linux/dcache.h>
+#include <linux/stat.h>
+#include <linux/cache.h>
+#include <linux/kobject.h>
+#include <linux/list.h>
+#include <linux/radix-tree.h>
+#include <linux/prio_tree.h>
+#include <linux/init.h>
+
+#include <asm/atomic.h>
+#include <asm/semaphore.h>
+#include <asm/byteorder.h>
+
+struct iovec;
+struct nameidata;
+struct pipe_inode_info;
+struct poll_table_struct;
+struct kstatfs;
+struct vm_area_struct;
+struct vfsmount;
+
+/* Used to be a macro which just called the function, now just a function */
+extern void update_atime (struct inode *);
+
+extern void __init inode_init(unsigned long);
+extern void __init inode_init_early(void);
+extern void __init mnt_init(unsigned long);
+extern void __init files_init(unsigned long);
+
+struct buffer_head;
+typedef int (get_block_t)(struct inode *inode, sector_t iblock,
+                        struct buffer_head *bh_result, int create);
+typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
+                        unsigned long max_blocks,
+                        struct buffer_head *bh_result, int create);
+typedef void (dio_iodone_t)(struct inode *inode, loff_t offset,
+                        ssize_t bytes, void *private);
+
+/*
+ * Attribute flags.  These should be or-ed together to figure out what
+ * has been changed!
+ */
+#define ATTR_MODE       1
+#define ATTR_UID        2
+#define ATTR_GID        4
+#define ATTR_SIZE       8
+#define ATTR_ATIME      16
+#define ATTR_MTIME      32
+#define ATTR_CTIME      64
+#define ATTR_ATIME_SET  128
+#define ATTR_MTIME_SET  256
+#define ATTR_FORCE      512     /* Not a change, but a change it */
+#define ATTR_ATTR_FLAG  1024
+#define ATTR_KILL_SUID  2048
+#define ATTR_KILL_SGID  4096
+
+/*
+ * This is the Inode Attributes structure, used for notify_change().  It
+ * uses the above definitions as flags, to know which values have changed.
+ * Also, in this manner, a Filesystem can look at only the values it cares
+ * about.  Basically, these are the attributes that the VFS layer can
+ * request to change from the FS layer.
+ *
+ * Derek Atkins <warlord@MIT.EDU> 94-10-20
+ */
+struct iattr {
+        unsigned int    ia_valid;
+        umode_t         ia_mode;
+        uid_t           ia_uid;
+        gid_t           ia_gid;
+        loff_t          ia_size;
+        struct timespec ia_atime;
+        struct timespec ia_mtime;
+        struct timespec ia_ctime;
+        unsigned int    ia_attr_flags;
+};
+
+/*
+ * This is the inode attributes flag definitions
+ */
+#define ATTR_FLAG_SYNCRONOUS    1       /* Syncronous write */
+#define ATTR_FLAG_NOATIME       2       /* Don't update atime */
+#define ATTR_FLAG_APPEND        4       /* Append-only file */
+#define ATTR_FLAG_IMMUTABLE     8       /* Immutable file */
+#define ATTR_FLAG_NODIRATIME    16      /* Don't update atime for directory */
+
+/*
+ * Includes for diskquotas.
+ */
+#include <linux/quota.h>
+
+/*
+ * oh the beauties of C type declarations.
+ */
+struct page;
+struct address_space;
+struct writeback_control;
+struct kiocb;
+
+struct address_space_operations {
+        int (*writepage)(struct page *page, struct writeback_control *wbc);
+        int (*readpage)(struct file *, struct page *);
+        int (*sync_page)(struct page *);
+
+        /* Write back some dirty pages from this mapping. */
+        int (*writepages)(struct address_space *, struct writeback_control *);
+
+        /* Set a page dirty */
+        int (*set_page_dirty)(struct page *page);
+
+        int (*readpages)(struct file *filp, struct address_space *mapping,
+                        struct list_head *pages, unsigned nr_pages);
+
+        /*
+         * ext3 requires that a successful prepare_write() call be followed
+         * by a commit_write() call - they must be balanced
+         */
+        int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
+        int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
+        /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
+        sector_t (*bmap)(struct address_space *, sector_t);
+        int (*invalidatepage) (struct page *, unsigned long);
+        int (*releasepage) (struct page *, int);
+        ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
+                        loff_t offset, unsigned long nr_segs);
+};
+
+struct backing_dev_info;
+struct address_space {
+        struct inode            *host;          /* owner: inode, block_device */
+        struct radix_tree_root  page_tree;      /* radix tree of all pages */
+        rwlock_t                tree_lock;      /* and rwlock protecting it */
+        unsigned int            i_mmap_writable;/* count VM_SHARED mappings */
+        struct prio_tree_root   i_mmap;         /* tree of private and shared mappings */
+        struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
+        spinlock_t              i_mmap_lock;    /* protect tree, count, list */
+        unsigned int            truncate_count; /* Cover race condition with truncate */
+        unsigned long           nrpages;        /* number of total pages */
+        pgoff_t                 writeback_index;/* writeback starts here */
+        struct address_space_operations *a_ops; /* methods */
+        unsigned long           flags;          /* error bits/gfp mask */
+        struct backing_dev_info *backing_dev_info; /* device readahead, etc */
+        spinlock_t              private_lock;   /* for use by the address_space */
+        struct list_head        private_list;   /* ditto */
+        struct address_space    *assoc_mapping; /* ditto */
+} __attribute__((aligned(sizeof(long))));
+        /*
+         * On most architectures that alignment is already the case; but
+         * must be enforced here for CRIS, to let the least signficant bit
+         * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
+         */
+
+struct block_device {
+        dev_t                   bd_dev;  /* not a kdev_t - it's a search key */
+        struct inode *          bd_inode;       /* will die */
+        int                     bd_openers;
+        struct semaphore        bd_sem; /* open/close mutex */
+        struct semaphore        bd_mount_sem;   /* mount mutex */
+        struct list_head        bd_inodes;
+        void *                  bd_holder;
+        int                     bd_holders;
+        struct block_device *   bd_contains;
+        unsigned                bd_block_size;
+        struct hd_struct *      bd_part;
+        /* number of times partitions within this device have been opened. */
+        unsigned                bd_part_count;
+        int                     bd_invalidated;
+        struct gendisk *        bd_disk;
+        struct list_head        bd_list;
+        struct backing_dev_info *bd_inode_backing_dev_info;
+        /*
+         * Private data.  You must have bd_claim'ed the block_device
+         * to use this.  NOTE:  bd_claim allows an owner to claim
+         * the same device multiple times, the owner must take special
+         * care to not mess up bd_private for that case.
+         */
+        unsigned long           bd_private;
+};
+
+/*
+ * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
+ * radix trees
+ */
+#define PAGECACHE_TAG_DIRTY     0
+#define PAGECACHE_TAG_WRITEBACK 1
+
+int mapping_tagged(struct address_space *mapping, int tag);
+
+/*
+ * Might pages of this file be mapped into userspace?
+ */
+static inline int mapping_mapped(struct address_space *mapping)
+{
+        return  !prio_tree_empty(&mapping->i_mmap) ||
+                !list_empty(&mapping->i_mmap_nonlinear);
+}
+
+/*
+ * Might pages of this file have been modified in userspace?
+ * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
+ * marks vma as VM_SHARED if it is shared, and the file was opened for
+ * writing i.e. vma may be mprotected writable even if now readonly.
+ */
+static inline int mapping_writably_mapped(struct address_space *mapping)
+{
+        return mapping->i_mmap_writable != 0;
+}
+
+/*
+ * Use sequence counter to get consistent i_size on 32-bit processors.
+ */
+#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
+#include <linux/seqlock.h>
+#define __NEED_I_SIZE_ORDERED
+#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
+#else
+#define i_size_ordered_init(inode) do { } while (0)
+#endif
+
+struct inode {
+        struct hlist_node       i_hash;
+        struct list_head        i_list;
+        struct list_head        i_sb_list;
+        struct list_head        i_dentry;
+        unsigned long           i_ino;
+        atomic_t                i_count;
+        umode_t                 i_mode;
+        unsigned int            i_nlink;
+        uid_t                   i_uid;
+        gid_t                   i_gid;
+        dev_t                   i_rdev;
+        loff_t                  i_size;
+        struct timespec         i_atime;
+        struct timespec         i_mtime;
+        struct timespec         i_ctime;
+        unsigned int            i_blkbits;
+        unsigned long           i_blksize;
+        unsigned long           i_version;
+        unsigned long           i_blocks;
+        unsigned short          i_bytes;
+        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
+        struct semaphore        i_sem;
+        struct rw_semaphore     i_alloc_sem;
+        struct inode_operations *i_op;
+        struct file_operations  *i_fop; /* former ->i_op->default_file_ops */
+        struct super_block      *i_sb;
+        struct file_lock        *i_flock;
+        struct address_space    *i_mapping;
+        struct address_space    i_data;
+#ifdef CONFIG_QUOTA
+        struct dquot            *i_dquot[MAXQUOTAS];
+#endif
+        /* These three should probably be a union */
+        struct list_head        i_devices;
+        struct pipe_inode_info  *i_pipe;
+        struct block_device     *i_bdev;
+        struct cdev             *i_cdev;
+        int                     i_cindex;
+
+        __u32                   i_generation;
+
+#ifdef CONFIG_DNOTIFY
+        unsigned long           i_dnotify_mask; /* Directory notify events */
+        struct dnotify_struct   *i_dnotify; /* for directory notifications */
+#endif
+
+        unsigned long           i_state;
+        unsigned long           dirtied_when;   /* jiffies of first dirtying */
+
+        unsigned int            i_flags;
+
+        atomic_t                i_writecount;
+        void                    *i_security;
+        union {
+                void            *generic_ip;
+        } u;
+#ifdef __NEED_I_SIZE_ORDERED
+        seqcount_t              i_size_seqcount;
+#endif
+};
+
+/*
+ * NOTE: in a 32bit arch with a preemptable kernel and
+ * an UP compile the i_size_read/write must be atomic
+ * with respect to the local cpu (unlike with preempt disabled),
+ * but they don't need to be atomic with respect to other cpus like in
+ * true SMP (so they need either to either locally disable irq around
+ * the read or for example on x86 they can be still implemented as a
+ * cmpxchg8b without the need of the lock prefix). For SMP compiles
+ * and 64bit archs it makes no difference if preempt is enabled or not.
+ */
+static inline loff_t i_size_read(struct inode *inode)
+{
+#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
+        loff_t i_size;
+        unsigned int seq;
+
+        do {
+                seq = read_seqcount_begin(&inode->i_size_seqcount);
+                i_size = inode->i_size;
+        } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
+        return i_size;
+#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
+        loff_t i_size;
+
+        preempt_disable();
+        i_size = inode->i_size;
+        preempt_enable();
+        return i_size;
+#else
+        return inode->i_size;
+#endif
+}
+
+
+static inline void i_size_write(struct inode *inode, loff_t i_size)
+{
+#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
+        write_seqcount_begin(&inode->i_size_seqcount);
+        inode->i_size = i_size;
+        write_seqcount_end(&inode->i_size_seqcount);
+#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
+        preempt_disable();
+        inode->i_size = i_size;
+        preempt_enable();
+#else
+        inode->i_size = i_size;
+#endif
+}
+
+static inline unsigned iminor(struct inode *inode)
+{
+        return MINOR(inode->i_rdev);
+}
+
+static inline unsigned imajor(struct inode *inode)
+{
+        return MAJOR(inode->i_rdev);
+}
+
+extern struct block_device *I_BDEV(struct inode *inode);
+
+struct fown_struct {
+        rwlock_t lock;          /* protects pid, uid, euid fields */
+        int pid;                /* pid or -pgrp where SIGIO should be sent */
+        uid_t uid, euid;        /* uid/euid of process setting the owner */
+        void *security;
+        int signum;             /* posix.1b rt signal to be delivered on IO */
+};
+
+/*
+ * Track a single file's readahead state
+ */
+struct file_ra_state {
+        unsigned long start;            /* Current window */
+        unsigned long size;
+        unsigned long flags;            /* ra flags RA_FLAG_xxx*/
+        unsigned long cache_hit;        /* cache hit count*/
+        unsigned long prev_page;        /* Cache last read() position */
+        unsigned long ahead_start;      /* Ahead window */
+        unsigned long ahead_size;
+        unsigned long ra_pages;         /* Maximum readahead window */
+        unsigned long mmap_hit;         /* Cache hit stat for mmap accesses */
+        unsigned long mmap_miss;        /* Cache miss stat for mmap accesses */
+};
+#define RA_FLAG_MISS 0x01       /* a cache miss occured against this file */
+#define RA_FLAG_INCACHE 0x02    /* file is already in cache */
+
+struct file {
+        struct list_head        f_list;
+        struct dentry           *f_dentry;
+        struct vfsmount         *f_vfsmnt;
+        struct file_operations  *f_op;
+        atomic_t                f_count;
+        unsigned int            f_flags;
+        mode_t                  f_mode;
+        int                     f_error;
+        loff_t                  f_pos;
+        struct fown_struct      f_owner;
+        unsigned int            f_uid, f_gid;
+        struct file_ra_state    f_ra;
+
+        size_t                  f_maxcount;
+        unsigned long           f_version;
+        void                    *f_security;
+
+        /* needed for tty driver, and maybe others */
+        void                    *private_data;
+
+#ifdef CONFIG_EPOLL
+        /* Used by fs/eventpoll.c to link all the hooks to this file */
+        struct list_head        f_ep_links;
+        spinlock_t              f_ep_lock;
+#endif /* #ifdef CONFIG_EPOLL */
+        struct address_space    *f_mapping;
+};
+extern spinlock_t files_lock;
+#define file_list_lock() spin_lock(&files_lock);
+#define file_list_unlock() spin_unlock(&files_lock);
+
+#define get_file(x)     atomic_inc(&(x)->f_count)
+#define file_count(x)   atomic_read(&(x)->f_count)
+
+#define MAX_NON_LFS     ((1UL<<31) - 1)
+
+/* Page cache limit. The filesystems should put that into their s_maxbytes 
+   limits, otherwise bad things can happen in VM. */ 
+#if BITS_PER_LONG==32
+#define MAX_LFS_FILESIZE        (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1) 
+#elif BITS_PER_LONG==64
+#define MAX_LFS_FILESIZE        0x7fffffffffffffffUL
+#endif
+
+#define FL_POSIX        1
+#define FL_FLOCK        2
+#define FL_ACCESS       8       /* not trying to lock, just looking */
+#define FL_LOCKD        16      /* lock held by rpc.lockd */
+#define FL_LEASE        32      /* lease held on this file */
+#define FL_SLEEP        128     /* A blocking lock */
+
+/*
+ * The POSIX file lock owner is determined by
+ * the "struct files_struct" in the thread group
+ * (or NULL for no owner - BSD locks).
+ *
+ * Lockd stuffs a "host" pointer into this.
+ */
+typedef struct files_struct *fl_owner_t;
+
+struct file_lock_operations {
+        void (*fl_insert)(struct file_lock *);  /* lock insertion callback */
+        void (*fl_remove)(struct file_lock *);  /* lock removal callback */
+        void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
+        void (*fl_release_private)(struct file_lock *);
+};
+
+struct lock_manager_operations {
+        int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
+        void (*fl_notify)(struct file_lock *);  /* unblock callback */
+        void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
+        void (*fl_release_private)(struct file_lock *);
+        void (*fl_break)(struct file_lock *);
+        int (*fl_mylease)(struct file_lock *, struct file_lock *);
+        int (*fl_change)(struct file_lock **, int);
+};
+
+/* that will die - we need it for nfs_lock_info */
+#include <linux/nfs_fs_i.h>
+
+struct file_lock {
+        struct file_lock *fl_next;      /* singly linked list for this inode  */
+        struct list_head fl_link;       /* doubly linked list of all locks */
+        struct list_head fl_block;      /* circular list of blocked processes */
+        fl_owner_t fl_owner;
+        unsigned int fl_pid;
+        wait_queue_head_t fl_wait;
+        struct file *fl_file;
+        unsigned char fl_flags;
+        unsigned char fl_type;
+        loff_t fl_start;
+        loff_t fl_end;
+
+        struct fasync_struct *  fl_fasync; /* for lease break notifications */
+        unsigned long fl_break_time;    /* for nonblocking lease breaks */
+
+        struct file_lock_operations *fl_ops;    /* Callbacks for filesystems */
+        struct lock_manager_operations *fl_lmops;       /* Callbacks for lockmanagers */
+        union {
+                struct nfs_lock_info    nfs_fl;
+        } fl_u;
+};
+
+/* The following constant reflects the upper bound of the file/locking space */
+#ifndef OFFSET_MAX
+#define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))
+#define OFFSET_MAX      INT_LIMIT(loff_t)
+#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
+#endif
+
+extern struct list_head file_lock_list;
+
+#include <linux/fcntl.h>
+
+extern int fcntl_getlk(struct file *, struct flock __user *);
+extern int fcntl_setlk(struct file *, unsigned int, struct flock __user *);
+
+#if BITS_PER_LONG == 32
+extern int fcntl_getlk64(struct file *, struct flock64 __user *);
+extern int fcntl_setlk64(struct file *, unsigned int, struct flock64 __user *);
+#endif
+
+extern void send_sigio(struct fown_struct *fown, int fd, int band);
+extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
+extern int fcntl_getlease(struct file *filp);
+
+/* fs/locks.c */
+extern void locks_init_lock(struct file_lock *);
+extern void locks_copy_lock(struct file_lock *, struct file_lock *);
+extern void locks_remove_posix(struct file *, fl_owner_t);
+extern void locks_remove_flock(struct file *);
+extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
+extern int posix_lock_file(struct file *, struct file_lock *);
+extern int posix_lock_file_wait(struct file *, struct file_lock *);
+extern void posix_block_lock(struct file_lock *, struct file_lock *);
+extern void posix_unblock_lock(struct file *, struct file_lock *);
+extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
+extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
+extern int __break_lease(struct inode *inode, unsigned int flags);
+extern void lease_get_mtime(struct inode *, struct timespec *time);
+extern int setlease(struct file *, long, struct file_lock **);
+extern int lease_modify(struct file_lock **, int);
+extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
+extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
+extern void steal_locks(fl_owner_t from);
+
+struct fasync_struct {
+        int     magic;
+        int     fa_fd;
+        struct  fasync_struct   *fa_next; /* singly linked list */
+        struct  file            *fa_file;
+};
+
+#define FASYNC_MAGIC 0x4601
+
+/* SMP safe fasync helpers: */
+extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
+/* can be called from interrupts */
+extern void kill_fasync(struct fasync_struct **, int, int);
+/* only for net: no internal synchronization */
+extern void __kill_fasync(struct fasync_struct *, int, int);
+
+extern int f_setown(struct file *filp, unsigned long arg, int force);
+extern void f_delown(struct file *filp);
+extern int send_sigurg(struct fown_struct *fown);
+
+/*
+ *      Umount options
+ */
+
+#define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
+#define MNT_DETACH      0x00000002      /* Just detach from the tree */
+#define MNT_EXPIRE      0x00000004      /* Mark for expiry */
+
+extern struct list_head super_blocks;
+extern spinlock_t sb_lock;
+
+#define sb_entry(list)  list_entry((list), struct super_block, s_list)
+#define S_BIAS (1<<30)
+struct super_block {
+        struct list_head        s_list;         /* Keep this first */
+        dev_t                   s_dev;          /* search index; _not_ kdev_t */
+        unsigned long           s_blocksize;
+        unsigned long           s_old_blocksize;
+        unsigned char           s_blocksize_bits;
+        unsigned char           s_dirt;
+        unsigned long long      s_maxbytes;     /* Max file size */
+        struct file_system_type *s_type;
+        struct super_operations *s_op;
+        struct dquot_operations *dq_op;
+        struct quotactl_ops     *s_qcop;
+        struct export_operations *s_export_op;
+        unsigned long           s_flags;
+        unsigned long           s_magic;
+        struct dentry           *s_root;
+        struct rw_semaphore     s_umount;
+        struct semaphore        s_lock;
+        int                     s_count;
+        int                     s_syncing;
+        int                     s_need_sync_fs;
+        atomic_t                s_active;
+        void                    *s_security;
+        struct xattr_handler    **s_xattr;
+
+        struct list_head        s_inodes;       /* all inodes */
+        struct list_head        s_dirty;        /* dirty inodes */
+        struct list_head        s_io;           /* parked for writeback */
+        struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */
+        struct list_head        s_files;
+
+        struct block_device     *s_bdev;
+        struct list_head        s_instances;
+        struct quota_info       s_dquot;        /* Diskquota specific options */
+
+        int                     s_frozen;
+        wait_queue_head_t       s_wait_unfrozen;
+
+        char s_id[32];                          /* Informational name */
+
+        void                    *s_fs_info;     /* Filesystem private info */
+
+        /*
+         * The next field is for VFS *only*. No filesystems have any business
+         * even looking at it. You had been warned.
+         */
+        struct semaphore s_vfs_rename_sem;      /* Kludge */
+
+        /* Granuality of c/m/atime in ns.
+           Cannot be worse than a second */
+        u32                s_time_gran;
+};
+
+extern struct timespec current_fs_time(struct super_block *sb);
+
+/*
+ * Snapshotting support.
+ */
+enum {
+        SB_UNFROZEN = 0,
+        SB_FREEZE_WRITE = 1,
+        SB_FREEZE_TRANS = 2,
+};
+
+#define vfs_check_frozen(sb, level) \
+        wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
+
+/*
+ * Superblock locking.
+ */
+static inline void lock_super(struct super_block * sb)
+{
+        down(&sb->s_lock);
+}
+
+static inline void unlock_super(struct super_block * sb)
+{
+        up(&sb->s_lock);
+}
+
+/*
+ * VFS helper functions..
+ */
+extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
+extern int vfs_mkdir(struct inode *, struct dentry *, int);
+extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
+extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
+extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
+extern int vfs_rmdir(struct inode *, struct dentry *);
+extern int vfs_unlink(struct inode *, struct dentry *);
+extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
+
+/*
+ * VFS dentry helper functions.
+ */
+extern void dentry_unhash(struct dentry *dentry);
+
+/*
+ * File types
+ *
+ * NOTE! These match bits 12..15 of stat.st_mode
+ * (ie "(i_mode >> 12) & 15").
+ */
+#define DT_UNKNOWN      0
+#define DT_FIFO         1
+#define DT_CHR          2
+#define DT_DIR          4
+#define DT_BLK          6
+#define DT_REG          8
+#define DT_LNK          10
+#define DT_SOCK         12
+#define DT_WHT          14
+
+#define OSYNC_METADATA  (1<<0)
+#define OSYNC_DATA      (1<<1)
+#define OSYNC_INODE     (1<<2)
+int generic_osync_inode(struct inode *, struct address_space *, int);
+
+/*
+ * This is the "filldir" function type, used by readdir() to let
+ * the kernel specify what kind of dirent layout it wants to have.
+ * This allows the kernel to read directories into kernel space or
+ * to have different dirent layouts depending on the binary type.
+ */
+typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
+
+struct block_device_operations {
+        int (*open) (struct inode *, struct file *);
+        int (*release) (struct inode *, struct file *);
+        int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
+        long (*compat_ioctl) (struct file *, unsigned, unsigned long);
+        int (*media_changed) (struct gendisk *);
+        int (*revalidate_disk) (struct gendisk *);
+        struct module *owner;
+};
+
+/*
+ * "descriptor" for what we're up to with a read for sendfile().
+ * This allows us to use the same read code yet
+ * have multiple different users of the data that
+ * we read from a file.
+ *
+ * The simplest case just copies the data to user
+ * mode.
+ */
+typedef struct {
+        size_t written;
+        size_t count;
+        union {
+                char __user * buf;
+                void *data;
+        } arg;
+        int error;
+} read_descriptor_t;
+
+typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
+
+/* These macros are for out of kernel modules to test that
+ * the kernel supports the unlocked_ioctl and compat_ioctl
+ * fields in struct file_operations. */
+#define HAVE_COMPAT_IOCTL 1
+#define HAVE_UNLOCKED_IOCTL 1
+
+/*
+ * NOTE:
+ * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
+ * can be called without the big kernel lock held in all filesystems.
+ */
+struct file_operations {
+        struct module *owner;
+        loff_t (*llseek) (struct file *, loff_t, int);
+        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
+        ssize_t (*aio_read) (struct kiocb *, char __user *, size_t, loff_t);
+        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
+        ssize_t (*aio_write) (struct kiocb *, const char __user *, size_t, loff_t);
+        int (*readdir) (struct file *, void *, filldir_t);
+        unsigned int (*poll) (struct file *, struct poll_table_struct *);
+        int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
+        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
+        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
+        int (*mmap) (struct file *, struct vm_area_struct *);
+        int (*open) (struct inode *, struct file *);
+        int (*flush) (struct file *);
+        int (*release) (struct inode *, struct file *);
+        int (*fsync) (struct file *, struct dentry *, int datasync);
+        int (*aio_fsync) (struct kiocb *, int datasync);
+        int (*fasync) (int, struct file *, int);
+        int (*lock) (struct file *, int, struct file_lock *);
+        ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
+        ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
+        ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
+        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
+        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
+        int (*check_flags)(int);
+        int (*dir_notify)(struct file *filp, unsigned long arg);
+        int (*flock) (struct file *, int, struct file_lock *);
+};
+
+struct inode_operations {
+        int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
+        struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
+        int (*link) (struct dentry *,struct inode *,struct dentry *);
+        int (*unlink) (struct inode *,struct dentry *);
+        int (*symlink) (struct inode *,struct dentry *,const char *);
+        int (*mkdir) (struct inode *,struct dentry *,int);
+        int (*rmdir) (struct inode *,struct dentry *);
+        int (*mknod) (struct inode *,struct dentry *,int,dev_t);
+        int (*rename) (struct inode *, struct dentry *,
+                        struct inode *, struct dentry *);
+        int (*readlink) (struct dentry *, char __user *,int);
+        int (*follow_link) (struct dentry *, struct nameidata *);
+        void (*put_link) (struct dentry *, struct nameidata *);
+        void (*truncate) (struct inode *);
+        int (*permission) (struct inode *, int, struct nameidata *);
+        int (*setattr) (struct dentry *, struct iattr *);
+        int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
+        int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
+        ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
+        ssize_t (*listxattr) (struct dentry *, char *, size_t);
+        int (*removexattr) (struct dentry *, const char *);
+};
+
+struct seq_file;
+
+extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
+extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
+extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
+                unsigned long, loff_t *);
+extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
+                unsigned long, loff_t *);
+
+/*
+ * NOTE: write_inode, delete_inode, clear_inode, put_inode can be called
+ * without the big kernel lock held in all filesystems.
+ */
+struct super_operations {
+        struct inode *(*alloc_inode)(struct super_block *sb);
+        void (*destroy_inode)(struct inode *);
+
+        void (*read_inode) (struct inode *);
+  
+        void (*dirty_inode) (struct inode *);
+        int (*write_inode) (struct inode *, int);
+        void (*put_inode) (struct inode *);
+        void (*drop_inode) (struct inode *);
+        void (*delete_inode) (struct inode *);
+        void (*put_super) (struct super_block *);
+        void (*write_super) (struct super_block *);
+        int (*sync_fs)(struct super_block *sb, int wait);
+        void (*write_super_lockfs) (struct super_block *);
+        void (*unlockfs) (struct super_block *);
+        int (*statfs) (struct super_block *, struct kstatfs *);
+        int (*remount_fs) (struct super_block *, int *, char *);
+        void (*clear_inode) (struct inode *);
+        void (*umount_begin) (struct super_block *);
+
+        int (*show_options)(struct seq_file *, struct vfsmount *);
+
+        ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
+        ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
+};
+
+/* Inode state bits.  Protected by inode_lock. */
+#define I_DIRTY_SYNC            1 /* Not dirty enough for O_DATASYNC */
+#define I_DIRTY_DATASYNC        2 /* Data-related inode changes pending */
+#define I_DIRTY_PAGES           4 /* Data-related inode changes pending */
+#define __I_LOCK                3
+#define I_LOCK                  (1 << __I_LOCK)
+#define I_FREEING               16
+#define I_CLEAR                 32
+#define I_NEW                   64
+
+#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
+
+extern void __mark_inode_dirty(struct inode *, int);
+static inline void mark_inode_dirty(struct inode *inode)
+{
+        __mark_inode_dirty(inode, I_DIRTY);
+}
+
+static inline void mark_inode_dirty_sync(struct inode *inode)
+{
+        __mark_inode_dirty(inode, I_DIRTY_SYNC);
+}
+
+static inline void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
+{
+        /* per-mountpoint checks will go here */
+        update_atime(dentry->d_inode);
+}
+
+static inline void file_accessed(struct file *file)
+{
+        if (!(file->f_flags & O_NOATIME))
+                touch_atime(file->f_vfsmnt, file->f_dentry);
+}
+
+int sync_inode(struct inode *inode, struct writeback_control *wbc);
+
+/**
+ * &export_operations - for nfsd to communicate with file systems
+ * decode_fh:      decode a file handle fragment and return a &struct dentry
+ * encode_fh:      encode a file handle fragment from a dentry
+ * get_name:       find the name for a given inode in a given directory
+ * get_parent:     find the parent of a given directory
+ * get_dentry:     find a dentry for the inode given a file handle sub-fragment
+ *
+ * Description:
+ *    The export_operations structure provides a means for nfsd to communicate
+ *    with a particular exported file system  - particularly enabling nfsd and
+ *    the filesystem to co-operate when dealing with file handles.
+ *
+ *    export_operations contains two basic operation for dealing with file handles,
+ *    decode_fh() and encode_fh(), and allows for some other operations to be defined
+ *    which standard helper routines use to get specific information from the
+ *    filesystem.
+ *
+ *    nfsd encodes information use to determine which filesystem a filehandle
+ *    applies to in the initial part of the file handle.  The remainder, termed a
+ *    file handle fragment, is controlled completely by the filesystem.
+ *    The standard helper routines assume that this fragment will contain one or two
+ *    sub-fragments, one which identifies the file, and one which may be used to
+ *    identify the (a) directory containing the file.
+ *
+ *    In some situations, nfsd needs to get a dentry which is connected into a
+ *    specific part of the file tree.  To allow for this, it passes the function
+ *    acceptable() together with a @context which can be used to see if the dentry
+ *    is acceptable.  As there can be multiple dentrys for a given file, the filesystem
+ *    should check each one for acceptability before looking for the next.  As soon
+ *    as an acceptable one is found, it should be returned.
+ *
+ * decode_fh:
+ *    @decode_fh is given a &struct super_block (@sb), a file handle fragment (@fh, @fh_len)
+ *    and an acceptability testing function (@acceptable, @context).  It should return
+ *    a &struct dentry which refers to the same file that the file handle fragment refers
+ *    to,  and which passes the acceptability test.  If it cannot, it should return
+ *    a %NULL pointer if the file was found but no acceptable &dentries were available, or
+ *    a %ERR_PTR error code indicating why it couldn't be found (e.g. %ENOENT or %ENOMEM).
+ *
+ * encode_fh:
+ *    @encode_fh should store in the file handle fragment @fh (using at most @max_len bytes)
+ *    information that can be used by @decode_fh to recover the file refered to by the
+ *    &struct dentry @de.  If the @connectable flag is set, the encode_fh() should store
+ *    sufficient information so that a good attempt can be made to find not only
+ *    the file but also it's place in the filesystem.   This typically means storing
+ *    a reference to de->d_parent in the filehandle fragment.
+ *    encode_fh() should return the number of bytes stored or a negative error code
+ *    such as %-ENOSPC
+ *
+ * get_name:
+ *    @get_name should find a name for the given @child in the given @parent directory.
+ *    The name should be stored in the @name (with the understanding that it is already
+ *    pointing to a a %NAME_MAX+1 sized buffer.   get_name() should return %0 on success,
+ *    a negative error code or error.
+ *    @get_name will be called without @parent->i_sem held.
+ *
+ * get_parent:
+ *    @get_parent should find the parent directory for the given @child which is also
+ *    a directory.  In the event that it cannot be found, or storage space cannot be
+ *    allocated, a %ERR_PTR should be returned.
+ *
+ * get_dentry:
+ *    Given a &super_block (@sb) and a pointer to a file-system specific inode identifier,
+ *    possibly an inode number, (@inump) get_dentry() should find the identified inode and
+ *    return a dentry for that inode.
+ *    Any suitable dentry can be returned including, if necessary, a new dentry created
+ *    with d_alloc_root.  The caller can then find any other extant dentrys by following the
+ *    d_alias links.  If a new dentry was created using d_alloc_root, DCACHE_NFSD_DISCONNECTED
+ *    should be set, and the dentry should be d_rehash()ed.
+ *
+ *    If the inode cannot be found, either a %NULL pointer or an %ERR_PTR code can be returned.
+ *    The @inump will be whatever was passed to nfsd_find_fh_dentry() in either the
+ *    @obj or @parent parameters.
+ *
+ * Locking rules:
+ *  get_parent is called with child->d_inode->i_sem down
+ *  get_name is not (which is possibly inconsistent)
+ */
+
+struct export_operations {
+        struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
+                         int (*acceptable)(void *context, struct dentry *de),
+                         void *context);
+        int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
+                         int connectable);
+
+        /* the following are only called from the filesystem itself */
+        int (*get_name)(struct dentry *parent, char *name,
+                        struct dentry *child);
+        struct dentry * (*get_parent)(struct dentry *child);
+        struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
+
+        /* This is set by the exporting module to a standard helper */
+        struct dentry * (*find_exported_dentry)(
+                struct super_block *sb, void *obj, void *parent,
+                int (*acceptable)(void *context, struct dentry *de),
+                void *context);
+
+
+};
+
+extern struct dentry *
+find_exported_dentry(struct super_block *sb, void *obj, void *parent,
+                     int (*acceptable)(void *context, struct dentry *de),
+                     void *context);
+
+struct file_system_type {
+        const char *name;
+        int fs_flags;
+        struct super_block *(*get_sb) (struct file_system_type *, int,
+                                       const char *, void *);
+        void (*kill_sb) (struct super_block *);
+        struct module *owner;
+        struct file_system_type * next;
+        struct list_head fs_supers;
+};
+
+struct super_block *get_sb_bdev(struct file_system_type *fs_type,
+        int flags, const char *dev_name, void *data,
+        int (*fill_super)(struct super_block *, void *, int));
+struct super_block *get_sb_single(struct file_system_type *fs_type,
+        int flags, void *data,
+        int (*fill_super)(struct super_block *, void *, int));
+struct super_block *get_sb_nodev(struct file_system_type *fs_type,
+        int flags, void *data,
+        int (*fill_super)(struct super_block *, void *, int));
+void generic_shutdown_super(struct super_block *sb);
+void kill_block_super(struct super_block *sb);
+void kill_anon_super(struct super_block *sb);
+void kill_litter_super(struct super_block *sb);
+void deactivate_super(struct super_block *sb);
+int set_anon_super(struct super_block *s, void *data);
+struct super_block *sget(struct file_system_type *type,
+                        int (*test)(struct super_block *,void *),
+                        int (*set)(struct super_block *,void *),
+                        void *data);
+struct super_block *get_sb_pseudo(struct file_system_type *, char *,
+                        struct super_operations *ops, unsigned long);
+int __put_super(struct super_block *sb);
+int __put_super_and_need_restart(struct super_block *sb);
+void unnamed_dev_init(void);
+
+/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
+#define fops_get(fops) \
+        (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
+#define fops_put(fops) \
+        do { if (fops) module_put((fops)->owner); } while(0)
+
+extern int register_filesystem(struct file_system_type *);
+extern int unregister_filesystem(struct file_system_type *);
+extern struct vfsmount *kern_mount(struct file_system_type *);
+extern int may_umount_tree(struct vfsmount *);
+extern int may_umount(struct vfsmount *);
+extern long do_mount(char *, char *, char *, unsigned long, void *);
+
+extern int vfs_statfs(struct super_block *, struct kstatfs *);
+
+#define FLOCK_VERIFY_READ  1
+#define FLOCK_VERIFY_WRITE 2
+
+extern int locks_mandatory_locked(struct inode *);
+extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
+
+/*
+ * Candidates for mandatory locking have the setgid bit set
+ * but no group execute bit -  an otherwise meaningless combination.
+ */
+#define MANDATORY_LOCK(inode) \
+        (IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
+
+static inline int locks_verify_locked(struct inode *inode)
+{
+        if (MANDATORY_LOCK(inode))
+                return locks_mandatory_locked(inode);
+        return 0;
+}
+
+extern int rw_verify_area(int, struct file *, loff_t *, size_t);
+
+static inline int locks_verify_truncate(struct inode *inode,
+                                    struct file *filp,
+                                    loff_t size)
+{
+        if (inode->i_flock && MANDATORY_LOCK(inode))
+                return locks_mandatory_area(
+                        FLOCK_VERIFY_WRITE, inode, filp,
+                        size < inode->i_size ? size : inode->i_size,
+                        (size < inode->i_size ? inode->i_size - size
+                         : size - inode->i_size)
+                );
+        return 0;
+}
+
+static inline int break_lease(struct inode *inode, unsigned int mode)
+{
+        if (inode->i_flock)
+                return __break_lease(inode, mode);
+        return 0;
+}
+
+/* fs/open.c */
+
+extern int do_truncate(struct dentry *, loff_t start);
+extern struct file *filp_open(const char *, int, int);
+extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
+extern int filp_close(struct file *, fl_owner_t id);
+extern char * getname(const char __user *);
+
+/* fs/dcache.c */
+extern void __init vfs_caches_init_early(void);
+extern void __init vfs_caches_init(unsigned long);
+
+#define __getname()     kmem_cache_alloc(names_cachep, SLAB_KERNEL)
+#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
+#ifndef CONFIG_AUDITSYSCALL
+#define putname(name)   __putname(name)
+#else
+extern void putname(const char *name);
+#endif
+
+extern int register_blkdev(unsigned int, const char *);
+extern int unregister_blkdev(unsigned int, const char *);
+extern struct block_device *bdget(dev_t);
+extern void bd_set_size(struct block_device *, loff_t size);
+extern void bd_forget(struct inode *inode);
+extern void bdput(struct block_device *);
+extern struct block_device *open_by_devnum(dev_t, unsigned);
+extern struct file_operations def_blk_fops;
+extern struct address_space_operations def_blk_aops;
+extern struct file_operations def_chr_fops;
+extern struct file_operations bad_sock_fops;
+extern struct file_operations def_fifo_fops;
+extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
+extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
+extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
+extern int blkdev_get(struct block_device *, mode_t, unsigned);
+extern int blkdev_put(struct block_device *);
+extern int bd_claim(struct block_device *, void *);
+extern void bd_release(struct block_device *);
+
+/* fs/char_dev.c */
+extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
+extern int register_chrdev_region(dev_t, unsigned, const char *);
+extern int register_chrdev(unsigned int, const char *,
+                           struct file_operations *);
+extern int unregister_chrdev(unsigned int, const char *);
+extern void unregister_chrdev_region(dev_t, unsigned);
+extern int chrdev_open(struct inode *, struct file *);
+
+/* fs/block_dev.c */
+#define BDEVNAME_SIZE   32      /* Largest string for a blockdev identifier */
+extern const char *__bdevname(dev_t, char *buffer);
+extern const char *bdevname(struct block_device *bdev, char *buffer);
+extern struct block_device *lookup_bdev(const char *);
+extern struct block_device *open_bdev_excl(const char *, int, void *);
+extern void close_bdev_excl(struct block_device *);
+
+extern void init_special_inode(struct inode *, umode_t, dev_t);
+
+/* Invalid inode operations -- fs/bad_inode.c */
+extern void make_bad_inode(struct inode *);
+extern int is_bad_inode(struct inode *);
+
+extern struct file_operations read_fifo_fops;
+extern struct file_operations write_fifo_fops;
+extern struct file_operations rdwr_fifo_fops;
+extern struct file_operations read_pipe_fops;
+extern struct file_operations write_pipe_fops;
+extern struct file_operations rdwr_pipe_fops;
+
+extern int fs_may_remount_ro(struct super_block *);
+
+/*
+ * return READ, READA, or WRITE
+ */
+#define bio_rw(bio)             ((bio)->bi_rw & (RW_MASK | RWA_MASK))
+
+/*
+ * return data direction, READ or WRITE
+ */
+#define bio_data_dir(bio)       ((bio)->bi_rw & 1)
+
+extern int check_disk_change(struct block_device *);
+extern int invalidate_inodes(struct super_block *);
+extern int __invalidate_device(struct block_device *, int);
+extern int invalidate_partition(struct gendisk *, int);
+unsigned long invalidate_mapping_pages(struct address_space *mapping,
+                                        pgoff_t start, pgoff_t end);
+unsigned long invalidate_inode_pages(struct address_space *mapping);
+static inline void invalidate_remote_inode(struct inode *inode)
+{
+        if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
+            S_ISLNK(inode->i_mode))
+                invalidate_inode_pages(inode->i_mapping);
+}
+extern int invalidate_inode_pages2(struct address_space *mapping);
+extern int invalidate_inode_pages2_range(struct address_space *mapping,
+                                         pgoff_t start, pgoff_t end);
+extern int write_inode_now(struct inode *, int);
+extern int filemap_fdatawrite(struct address_space *);
+extern int filemap_flush(struct address_space *);
+extern int filemap_fdatawait(struct address_space *);
+extern int filemap_write_and_wait(struct address_space *mapping);
+extern int filemap_write_and_wait_range(struct address_space *mapping,
+                                        loff_t lstart, loff_t lend);
+extern void sync_supers(void);
+extern void sync_filesystems(int wait);
+extern void emergency_sync(void);
+extern void emergency_remount(void);
+extern int do_remount_sb(struct super_block *sb, int flags,
+                         void *data, int force);
+extern sector_t bmap(struct inode *, sector_t);
+extern int setattr_mask(unsigned int);
+extern int notify_change(struct dentry *, struct iattr *);
+extern int permission(struct inode *, int, struct nameidata *);
+extern int generic_permission(struct inode *, int,
+                int (*check_acl)(struct inode *, int));
+
+extern int get_write_access(struct inode *);
+extern int deny_write_access(struct file *);
+static inline void put_write_access(struct inode * inode)
+{
+        atomic_dec(&inode->i_writecount);
+}
+static inline void allow_write_access(struct file *file)
+{
+        if (file)
+                atomic_inc(&file->f_dentry->d_inode->i_writecount);
+}
+extern int do_pipe(int *);
+
+extern int open_namei(const char *, int, int, struct nameidata *);
+extern int may_open(struct nameidata *, int, int);
+
+extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
+extern struct file * open_exec(const char *);
+ 
+/* fs/dcache.c -- generic fs support functions */
+extern int is_subdir(struct dentry *, struct dentry *);
+extern ino_t find_inode_number(struct dentry *, struct qstr *);
+
+#include <linux/err.h>
+
+/* needed for stackable file system support */
+extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
+
+extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
+
+extern void inode_init_once(struct inode *);
+extern void iput(struct inode *);
+extern struct inode * igrab(struct inode *);
+extern ino_t iunique(struct super_block *, ino_t);
+extern int inode_needs_sync(struct inode *inode);
+extern void generic_delete_inode(struct inode *inode);
+
+extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
+                int (*test)(struct inode *, void *), void *data);
+extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
+
+extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
+extern struct inode * iget_locked(struct super_block *, unsigned long);
+extern void unlock_new_inode(struct inode *);
+
+static inline struct inode *iget(struct super_block *sb, unsigned long ino)
+{
+        struct inode *inode = iget_locked(sb, ino);
+        
+        if (inode && (inode->i_state & I_NEW)) {
+                sb->s_op->read_inode(inode);
+                unlock_new_inode(inode);
+        }
+
+        return inode;
+}
+
+extern void __iget(struct inode * inode);
+extern void clear_inode(struct inode *);
+extern void destroy_inode(struct inode *);
+extern struct inode *new_inode(struct super_block *);
+extern int remove_suid(struct dentry *);
+extern void remove_dquot_ref(struct super_block *, int, struct list_head *);
+extern struct semaphore iprune_sem;
+
+extern void __insert_inode_hash(struct inode *, unsigned long hashval);
+extern void remove_inode_hash(struct inode *);
+static inline void insert_inode_hash(struct inode *inode) {
+        __insert_inode_hash(inode, inode->i_ino);
+}
+
+extern struct file * get_empty_filp(void);
+extern void file_move(struct file *f, struct list_head *list);
+extern void file_kill(struct file *f);
+struct bio;
+extern void submit_bio(int, struct bio *);
+extern int bdev_read_only(struct block_device *);
+extern int set_blocksize(struct block_device *, int);
+extern int sb_set_blocksize(struct super_block *, int);
+extern int sb_min_blocksize(struct super_block *, int);
+
+extern int generic_file_mmap(struct file *, struct vm_area_struct *);
+extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
+extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
+extern int file_send_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
+extern ssize_t generic_file_read(struct file *, char __user *, size_t, loff_t *);
+int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
+extern ssize_t generic_file_write(struct file *, const char __user *, size_t, loff_t *);
+extern ssize_t generic_file_aio_read(struct kiocb *, char __user *, size_t, loff_t);
+extern ssize_t __generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t *);
+extern ssize_t generic_file_aio_write(struct kiocb *, const char __user *, size_t, loff_t);
+extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
+                unsigned long, loff_t *);
+extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
+                unsigned long *, loff_t, loff_t *, size_t, size_t);
+extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
+                unsigned long, loff_t, loff_t *, size_t, ssize_t);
+extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
+extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
+ssize_t generic_file_write_nolock(struct file *file, const struct iovec *iov,
+                                unsigned long nr_segs, loff_t *ppos);
+extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
+extern void do_generic_mapping_read(struct address_space *mapping,
+                                    struct file_ra_state *, struct file *,
+                                    loff_t *, read_descriptor_t *, read_actor_t);
+extern void
+file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
+extern ssize_t generic_file_direct_IO(int rw, struct kiocb *iocb,
+        const struct iovec *iov, loff_t offset, unsigned long nr_segs);
+extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov, 
+        unsigned long nr_segs, loff_t *ppos);
+ssize_t generic_file_writev(struct file *filp, const struct iovec *iov, 
+                        unsigned long nr_segs, loff_t *ppos);
+extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
+extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
+extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
+extern int generic_file_open(struct inode * inode, struct file * filp);
+extern int nonseekable_open(struct inode * inode, struct file * filp);
+
+static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
+                                        read_descriptor_t * desc,
+                                        read_actor_t actor)
+{
+        do_generic_mapping_read(filp->f_mapping,
+                                &filp->f_ra,
+                                filp,
+                                ppos,
+                                desc,
+                                actor);
+}
+
+ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
+        struct block_device *bdev, const struct iovec *iov, loff_t offset,
+        unsigned long nr_segs, get_blocks_t get_blocks, dio_iodone_t end_io,
+        int lock_type);
+
+enum {
+        DIO_LOCKING = 1, /* need locking between buffered and direct access */
+        DIO_NO_LOCKING,  /* bdev; no locking at all between buffered/direct */
+        DIO_OWN_LOCKING, /* filesystem locks buffered and direct internally */
+};
+
+static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
+        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
+        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        dio_iodone_t end_io)
+{
+        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
+                                nr_segs, get_blocks, end_io, DIO_LOCKING);
+}
+
+static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
+        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
+        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        dio_iodone_t end_io)
+{
+        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
+                                nr_segs, get_blocks, end_io, DIO_NO_LOCKING);
+}
+
+static inline ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
+        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
+        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        dio_iodone_t end_io)
+{
+        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
+                                nr_segs, get_blocks, end_io, DIO_OWN_LOCKING);
+}
+
+extern struct file_operations generic_ro_fops;
+
+#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
+
+extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
+extern int vfs_follow_link(struct nameidata *, const char *);
+extern int page_readlink(struct dentry *, char __user *, int);
+extern int page_follow_link_light(struct dentry *, struct nameidata *);
+extern void page_put_link(struct dentry *, struct nameidata *);
+extern int page_symlink(struct inode *inode, const char *symname, int len);
+extern struct inode_operations page_symlink_inode_operations;
+extern int generic_readlink(struct dentry *, char __user *, int);
+extern void generic_fillattr(struct inode *, struct kstat *);
+extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+void inode_add_bytes(struct inode *inode, loff_t bytes);
+void inode_sub_bytes(struct inode *inode, loff_t bytes);
+loff_t inode_get_bytes(struct inode *inode);
+void inode_set_bytes(struct inode *inode, loff_t bytes);
+
+extern int vfs_readdir(struct file *, filldir_t, void *);
+
+extern int vfs_stat(char __user *, struct kstat *);
+extern int vfs_lstat(char __user *, struct kstat *);
+extern int vfs_fstat(unsigned int, struct kstat *);
+
+extern int vfs_ioctl(struct file *, unsigned int, unsigned int, unsigned long);
+
+extern struct file_system_type *get_fs_type(const char *name);
+extern struct super_block *get_super(struct block_device *);
+extern struct super_block *user_get_super(dev_t);
+extern void drop_super(struct super_block *sb);
+
+extern int dcache_dir_open(struct inode *, struct file *);
+extern int dcache_dir_close(struct inode *, struct file *);
+extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
+extern int dcache_readdir(struct file *, void *, filldir_t);
+extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+extern int simple_statfs(struct super_block *, struct kstatfs *);
+extern int simple_link(struct dentry *, struct inode *, struct dentry *);
+extern int simple_unlink(struct inode *, struct dentry *);
+extern int simple_rmdir(struct inode *, struct dentry *);
+extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
+extern int simple_sync_file(struct file *, struct dentry *, int);
+extern int simple_empty(struct dentry *);
+extern int simple_readpage(struct file *file, struct page *page);
+extern int simple_prepare_write(struct file *file, struct page *page,
+                        unsigned offset, unsigned to);
+extern int simple_commit_write(struct file *file, struct page *page,
+                                unsigned offset, unsigned to);
+
+extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
+extern struct file_operations simple_dir_operations;
+extern struct inode_operations simple_dir_inode_operations;
+struct tree_descr { char *name; struct file_operations *ops; int mode; };
+struct dentry *d_alloc_name(struct dentry *, const char *);
+extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
+extern int simple_pin_fs(char *name, struct vfsmount **mount, int *count);
+extern void simple_release_fs(struct vfsmount **mount, int *count);
+
+extern ssize_t simple_read_from_buffer(void __user *, size_t, loff_t *, const void *, size_t);
+
+extern int inode_change_ok(struct inode *, struct iattr *);
+extern int __must_check inode_setattr(struct inode *, struct iattr *);
+
+extern void inode_update_time(struct inode *inode, int ctime_too);
+
+static inline ino_t parent_ino(struct dentry *dentry)
+{
+        ino_t res;
+
+        spin_lock(&dentry->d_lock);
+        res = dentry->d_parent->d_inode->i_ino;
+        spin_unlock(&dentry->d_lock);
+        return res;
+}
+
+/* kernel/fork.c */
+extern int unshare_files(void);
+
+/* Transaction based IO helpers */
+
+/*
+ * An argresp is stored in an allocated page and holds the
+ * size of the argument or response, along with its content
+ */
+struct simple_transaction_argresp {
+        ssize_t size;
+        char data[0];
+};
+
+#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
+
+char *simple_transaction_get(struct file *file, const char __user *buf,
+                                size_t size);
+ssize_t simple_transaction_read(struct file *file, char __user *buf,
+                                size_t size, loff_t *pos);
+int simple_transaction_release(struct inode *inode, struct file *file);
+
+static inline void simple_transaction_set(struct file *file, size_t n)
+{
+        struct simple_transaction_argresp *ar = file->private_data;
+
+        BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
+
+        /*
+         * The barrier ensures that ar->size will really remain zero until
+         * ar->data is ready for reading.
+         */
+        smp_mb();
+        ar->size = n;
+}
+
+#ifdef CONFIG_SECURITY
+static inline char *alloc_secdata(void)
+{
+        return (char *)get_zeroed_page(GFP_KERNEL);
+}
+
+static inline void free_secdata(void *secdata)
+{
+        free_page((unsigned long)secdata);
+}
+#else
+static inline char *alloc_secdata(void)
+{
+        return (char *)1;
+}
+
+static inline void free_secdata(void *secdata)
+{ }
+#endif  /* CONFIG_SECURITY */
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_FS_H */
diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
new file mode 100644
index 000000000000..c623d12a486e
--- /dev/null
+++ b/include/linux/fs_struct.h
@@ -0,0 +1,28 @@
+#ifndef _LINUX_FS_STRUCT_H
+#define _LINUX_FS_STRUCT_H
+
+struct dentry;
+struct vfsmount;
+
+struct fs_struct {
+        atomic_t count;
+        rwlock_t lock;
+        int umask;
+        struct dentry * root, * pwd, * altroot;
+        struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
+};
+
+#define INIT_FS {                               \
+        .count          = ATOMIC_INIT(1),       \
+        .lock           = RW_LOCK_UNLOCKED,     \
+        .umask          = 0022, \
+}
+
+extern void exit_fs(struct task_struct *);
+extern void set_fs_altroot(void);
+extern void set_fs_root(struct fs_struct *, struct vfsmount *, struct dentry *);
+extern void set_fs_pwd(struct fs_struct *, struct vfsmount *, struct dentry *);
+extern struct fs_struct *copy_fs_struct(struct fs_struct *);
+extern void put_fs_struct(struct fs_struct *);
+
+#endif /* _LINUX_FS_STRUCT_H */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
new file mode 100644
index 000000000000..faaff4c64559
--- /dev/null
+++ b/include/linux/fsl_devices.h
@@ -0,0 +1,78 @@
+/*
+ * include/linux/fsl_devices.h
+ *
+ * Definitions for any platform device related flags or structures for
+ * Freescale processor devices
+ *
+ * Maintainer: Kumar Gala (kumar.gala@freescale.com)
+ *
+ * Copyright 2004 Freescale Semiconductor, Inc
+ *
+ * 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;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#ifdef __KERNEL__
+#ifndef _FSL_DEVICE_H_
+#define _FSL_DEVICE_H_
+
+#include <linux/types.h>
+
+/*
+ * Some conventions on how we handle peripherals on Freescale chips
+ *
+ * unique device: a platform_device entry in fsl_plat_devs[] plus
+ * associated device information in its platform_data structure.
+ *
+ * A chip is described by a set of unique devices.
+ *
+ * Each sub-arch has its own master list of unique devices and
+ * enumerates them by enum fsl_devices in a sub-arch specific header
+ *
+ * The platform data structure is broken into two parts.  The
+ * first is device specific information that help identify any
+ * unique features of a peripheral.  The second is any
+ * information that may be defined by the board or how the device
+ * is connected externally of the chip.
+ *
+ * naming conventions:
+ * - platform data structures: <driver>_platform_data
+ * - platform data device flags: FSL_<driver>_DEV_<FLAG>
+ * - platform data board flags: FSL_<driver>_BRD_<FLAG>
+ *
+ */
+
+struct gianfar_platform_data {
+        /* device specific information */
+        u32 device_flags;
+        u32 phy_reg_addr;
+
+        /* board specific information */
+        u32 board_flags;
+        u32 phyid;
+        u32 interruptPHY;
+        u8 mac_addr[6];
+};
+
+/* Flags related to gianfar device features */
+#define FSL_GIANFAR_DEV_HAS_GIGABIT             0x00000001
+#define FSL_GIANFAR_DEV_HAS_COALESCE            0x00000002
+#define FSL_GIANFAR_DEV_HAS_RMON                0x00000004
+#define FSL_GIANFAR_DEV_HAS_MULTI_INTR          0x00000008
+
+/* Flags in gianfar_platform_data */
+#define FSL_GIANFAR_BRD_HAS_PHY_INTR    0x00000001      /* if not set use a timer */
+
+struct fsl_i2c_platform_data {
+        /* device specific information */
+        u32 device_flags;
+};
+
+/* Flags related to I2C device features */
+#define FSL_I2C_DEV_SEPARATE_DFSRR      0x00000001
+#define FSL_I2C_DEV_CLOCK_5200          0x00000002
+
+#endif                          /* _FSL_DEVICE_H_ */
+#endif                          /* __KERNEL__ */
diff --git a/include/linux/ftape-header-segment.h b/include/linux/ftape-header-segment.h
new file mode 100644
index 000000000000..4732218f0708
--- /dev/null
+++ b/include/linux/ftape-header-segment.h
@@ -0,0 +1,122 @@
+#ifndef _FTAPE_HEADER_SEGMENT_H
+#define _FTAPE_HEADER_SEGMENT_H
+
+/*
+ * Copyright (C) 1996-1997 Claus-Justus Heine.
+
+ 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; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ *
+ * $Source: /homes/cvs/ftape-stacked/include/linux/ftape-header-segment.h,v $
+ * $Revision: 1.2 $
+ * $Date: 1997/10/05 19:19:28 $
+ *
+ *      This file defines some offsets into the header segment of a
+ *      floppy tape cartridge.  For use with the QIC-40/80/3010/3020
+ *      floppy-tape driver "ftape" for Linux.
+ */
+
+#define FT_SIGNATURE   0  /* must be 0xaa55aa55 */
+#define FT_FMT_CODE    4
+#define FT_REV_LEVEL   5  /* only for QIC-80 since. Rev. L (== 0x0c)         */
+#define FT_HSEG_1      6  /* first header segment, except for format code  6 */
+#define FT_HSEG_2      8  /* second header segment, except for format code 6 */
+#define FT_FRST_SEG   10  /* first data segment, except for format code 6    */
+#define FT_LAST_SEG   12  /* last data segment, except for format code 6     */
+#define FT_FMT_DATE   14  /* date and time of most recent format, see below  */
+#define FT_WR_DATE    18  /* date and time of most recent write or format    */
+#define FT_SPT        24  /* segments per track                              */
+#define FT_TPC        26  /* tracks per cartridge                            */
+#define FT_FHM        27  /* floppy drive head (maximum of it)               */
+#define FT_FTM        28  /* floppy track max.                               */
+#define FT_FSM        29  /* floppy sector max. (128)                        */
+#define FT_LABEL      30  /* floppy tape label                               */
+#define FT_LABEL_DATE 74  /* date and time the tape label was written        */
+#define FT_LABEL_SZ   (FT_LABEL_DATE - FT_LABEL)
+#define FT_CMAP_START 78  /* starting segment of compression map             */
+#define FT_FMT_ERROR 128  /* must be set to 0xff if remainder gets lost during
+                           * tape format
+                           */
+#define FT_SEG_CNT   130  /* number of seg. written, formatted or verified
+                           * through lifetime of tape (why not read?)
+                           */
+#define FT_INIT_DATE 138  /* date and time of initial tape format    */
+#define FT_FMT_CNT   142  /* number of times tape has been formatted */
+#define FT_FSL_CNT   144  /* number of segments in failed sector log */
+#define FT_MK_CODE   146  /* id string of tape manufacturer          */
+#define FT_LOT_CODE  190  /* tape manufacturer lot code              */
+#define FT_6_HSEG_1  234  /* first header segment for format code  6 */
+#define FT_6_HSEG_2  238  /* second header segment for format code 6 */
+#define FT_6_FRST_SEG 242 /* first data segment for format code 6    */
+#define FT_6_LAST_SEG 246 /* last data segment for format code 6     */
+
+#define FT_FSL        256
+#define FT_HEADER_END 256 /* space beyond this point:
+                           * format codes 2, 3 and 5: 
+                           * -  failed sector log until byte 2047
+                           * -  bad sector map in the reamining part of segment
+                           * format codes 4 and 6:
+                           * -  bad sector map  starts hear
+                           */
+
+
+/*  value to be stored at the FT_SIGNATURE offset 
+ */
+#define FT_HSEG_MAGIC 0xaa55aa55
+#define FT_D2G_MAGIC  0x82288228 /* Ditto 2GB */
+
+/* data and time encoding: */
+#define FT_YEAR_SHIFT 25
+#define FT_YEAR_MASK  0xfe000000
+#define FT_YEAR_0     1970
+#define FT_YEAR_MAX   127
+#define FT_YEAR(year) ((((year)-FT_YEAR_0)<<FT_YEAR_SHIFT)&FT_YEAR_MASK)
+
+#define FT_TIME_SHIFT   0
+#define FT_TIME_MASK    0x01FFFFFF
+#define FT_TIME_MAX     0x01ea6dff /* last second of a year */
+#define FT_TIME(mo,d,h,m,s) \
+        ((((s)+60*((m)+60*((h)+24*((d)+31*(mo))))) & FT_TIME_MASK))
+
+#define FT_TIME_STAMP(y,mo,d,h,m,s) (FT_YEAR(y) | FT_TIME(mo,d,h,m,s))
+
+/* values for the format code field */
+typedef enum {
+        fmt_normal = 2, /*  QIC-80 post Rev. B 205Ft or 307Ft tape    */
+        fmt_1100ft = 3, /*  QIC-80 post Rev. B 1100Ft tape            */
+        fmt_var    = 4, /*  QIC-80 post Rev. B variabel length format */
+        fmt_425ft  = 5, /*  QIC-80 post Rev. B 425Ft tape             */
+        fmt_big    = 6  /*  QIC-3010/3020 variable length tape with more 
+                         *  than 2^16 segments per tape
+                         */
+} ft_format_type;
+
+/* definitions for the failed sector log */
+#define FT_FSL_SIZE        (2 * FT_SECTOR_SIZE - FT_HEADER_END)
+#define FT_FSL_MAX_ENTRIES (FT_FSL_SIZE/sizeof(__u32))
+
+typedef struct ft_fsl_entry {
+        __u16 segment;
+        __u16 date;
+} __attribute__ ((packed)) ft_fsl_entry;
+
+
+/*  date encoding for the failed sector log 
+ *  month: 1..12, day: 1..31, year: 1970..2097
+ */
+#define FT_FSL_TIME_STAMP(y,m,d) \
+        (((((y) - FT_YEAR_0)<<9)&0xfe00) | (((m)<<5)&0x01e0) | ((d)&0x001f))
+
+#endif /* _FTAPE_HEADER_SEGMENT_H */
diff --git a/include/linux/ftape-vendors.h b/include/linux/ftape-vendors.h
new file mode 100644
index 000000000000..ec1a81f059e5
--- /dev/null
+++ b/include/linux/ftape-vendors.h
@@ -0,0 +1,137 @@
+#ifndef _FTAPE_VENDORS_H
+#define _FTAPE_VENDORS_H
+
+/*
+ *      Copyright (C) 1993-1996 Bas Laarhoven,
+ *                (C) 1996-1997 Claus-Justus Heine.
+
+ 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; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ *
+ * $Source: /homes/cvs/ftape-stacked/include/linux/ftape-vendors.h,v $
+ * $Revision: 1.6 $
+ * $Date: 1997/10/09 15:38:11 $
+ *
+ *      This file contains the supported drive types with their
+ *      QIC-117 spec. vendor code and drive dependent configuration
+ *      information.
+ */
+
+typedef enum {
+        unknown_wake_up = 0,
+        no_wake_up,
+        wake_up_colorado,
+        wake_up_mountain,
+        wake_up_insight,
+} wake_up_types;
+
+typedef struct {
+        wake_up_types wake_up;  /* see wake_up_types */
+        char *name;             /* Text describing the drive */
+} wakeup_method;
+
+/*  Note: order of entries in WAKEUP_METHODS must be so that a variable
+ *        of type wake_up_types can be used as an index in the array.
+ */
+#define WAKEUP_METHODS { \
+  { unknown_wake_up,    "Unknown" }, \
+  { no_wake_up,         "None" }, \
+  { wake_up_colorado,   "Colorado" }, \
+  { wake_up_mountain,   "Mountain" }, \
+  { wake_up_insight,    "Motor-on" }, \
+}
+
+typedef struct {
+        unsigned int vendor_id; /* vendor id from drive */
+        int speed;              /* maximum tape transport speed (ips) */
+        wake_up_types wake_up;  /* see wake_up_types */
+        char *name;             /* Text describing the drive */
+} vendor_struct;
+
+#define UNKNOWN_VENDOR (-1)
+
+#define QIC117_VENDORS {                                                    \
+/* see _vendor_struct */                                                    \
+  { 0x00000,  82, wake_up_colorado,  "Colorado DJ-10 (old)" },              \
+  { 0x00047,  90, wake_up_colorado,  "Colorado DJ-10/DJ-20" },              \
+  { 0x011c2,  84, wake_up_colorado,  "Colorado 700" },                      \
+  { 0x011c3,  90, wake_up_colorado,  "Colorado 1400" },                     \
+  { 0x011c4,  84, wake_up_colorado,  "Colorado DJ-10/DJ-20 (new)" },        \
+  { 0x011c5,  84, wake_up_colorado,  "HP Colorado T1000" },                 \
+  { 0x011c6,  90, wake_up_colorado,  "HP Colorado T3000" },                 \
+  { 0x00005,  45, wake_up_mountain,  "Archive 5580i" },                     \
+  { 0x10005,  50, wake_up_insight,   "Insight 80Mb, Irwin 80SX" },          \
+  { 0x00140,  74, wake_up_mountain,  "Archive S.Hornet [Identity/Escom]" }, \
+  { 0x00146,  72, wake_up_mountain,  "Archive 31250Q [Escom]" },            \
+  { 0x0014a, 100, wake_up_mountain,  "Archive XL9250i [Conner/Escom]" },    \
+  { 0x0014c,  98, wake_up_mountain,  "Conner C250MQT" },                    \
+  { 0x0014e,  80, wake_up_mountain,  "Conner C250MQ" },                     \
+  { 0x00150,  80, wake_up_mountain,  "Conner TSM420R/TST800R" },            \
+  { 0x00152,  80, wake_up_mountain,  "Conner TSM850R" },                    \
+  { 0x00156,  80, wake_up_mountain,  "Conner TSM850R/1700R/TST3200R" },     \
+  { 0x00180,   0, wake_up_mountain,  "Summit SE 150" },                     \
+  { 0x00181,  85, wake_up_mountain,  "Summit SE 250, Mountain FS8000" },    \
+  { 0x001c1,  82, no_wake_up,        "Wangtek 3040F" },                     \
+  { 0x001c8,  64, no_wake_up,        "Wangtek 3080F" },                     \
+  { 0x001c8,  64, wake_up_colorado,  "Wangtek 3080F" },                     \
+  { 0x001ca,  67, no_wake_up,        "Wangtek 3080F (new)" },               \
+  { 0x001cc,  77, wake_up_colorado,  "Wangtek 3200 / Teac 700" },           \
+  { 0x001cd,  75, wake_up_colorado,  "Reveal TB1400" },                     \
+  { 0x00380,  85, wake_up_colorado,  "Exabyte Eagle-96" },                  \
+  { 0x00381,  85, wake_up_colorado,  "Exabyte Eagle TR-3" },                \
+  { 0x00382,  85, wake_up_colorado,  "Exabyte Eagle TR-3" },                \
+  { 0x003ce,  77, wake_up_colorado,  "Teac 800" },                          \
+  { 0x003cf,   0, wake_up_colorado,  "Teac FT3010TR" },                     \
+  { 0x08880,  64, no_wake_up,        "Iomega 250, Ditto 800" },             \
+  { 0x08880,  64, wake_up_colorado,  "Iomega 250, Ditto 800" },             \
+  { 0x08880,  64, wake_up_insight,   "Iomega 250, Ditto 800" },             \
+  { 0x08881,  80, wake_up_colorado,  "Iomega 700" },                        \
+  { 0x08882,  80, wake_up_colorado,  "Iomega 3200" },                       \
+  { 0x08883,  80, wake_up_colorado,  "Iomega DITTO 2GB" },                  \
+  { 0x00021,  70, no_wake_up,        "AIWA CT-803" },                       \
+  { 0x004c0,  80, no_wake_up,        "AIWA TD-S1600" },                     \
+  { 0x00021,   0, wake_up_mountain,  "COREtape QIC80" },                    \
+  { 0x00441,   0, wake_up_mountain,  "ComByte DoublePlay" },                \
+  { 0x00481, 127, wake_up_mountain,  "PERTEC MyTape 800" },                 \
+  { 0x00483, 130, wake_up_mountain,  "PERTEC MyTape 3200" },                \
+  { UNKNOWN_VENDOR, 0, no_wake_up, "unknown" }                              \
+}
+
+#define QIC117_MAKE_CODES {                     \
+  { 0, "Unassigned" },                          \
+  { 1, "Alloy Computer Products" },             \
+  { 2, "3M" },                                  \
+  { 3, "Tandberg Data" },                       \
+  { 4, "Colorado" },                            \
+  { 5, "Archive/Conner" },                      \
+  { 6, "Mountain/Summit Memory Systems" },      \
+  { 7, "Wangtek/Rexon/Tecmar" },                \
+  { 8, "Sony" },                                \
+  { 9, "Cipher Data Products" },                \
+  { 10, "Irwin Magnetic Systems" },             \
+  { 11, "Braemar" },                            \
+  { 12, "Verbatim" },                           \
+  { 13, "Core International" },                 \
+  { 14, "Exabyte" },                            \
+  { 15, "Teac" },                               \
+  { 16, "Gigatek" },                            \
+  { 17, "ComByte" },                            \
+  { 18, "PERTEC Memories" },                    \
+  { 19, "Aiwa" },                               \
+  { 71, "Colorado" },                           \
+  { 546, "Iomega Inc" },                        \
+}
+
+#endif /* _FTAPE_VENDORS_H */
diff --git a/include/linux/ftape.h b/include/linux/ftape.h
new file mode 100644
index 000000000000..c6b38d5b9186
--- /dev/null
+++ b/include/linux/ftape.h
@@ -0,0 +1,202 @@
+#ifndef _FTAPE_H
+#define _FTAPE_H
+
+/*
+ * Copyright (C) 1994-1996 Bas Laarhoven,
+ *           (C) 1996-1997 Claus-Justus Heine.
+
+ 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; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ *
+ * $Source: /homes/cvs/ftape-stacked/include/linux/ftape.h,v $
+ * $Revision: 1.17.6.4 $
+ * $Date: 1997/11/25 01:52:54 $
+ *
+ *      This file contains global definitions, typedefs and macro's
+ *      for the QIC-40/80/3010/3020 floppy-tape driver for Linux.
+ */
+
+#define FTAPE_VERSION "ftape v3.04d 25/11/97"
+
+#ifdef __KERNEL__
+#include <linux/interrupt.h>
+#include <linux/mm.h>
+#endif
+#include <linux/types.h>
+#include <linux/config.h>
+#include <linux/mtio.h>
+
+#define FT_SECTOR(x)            (x+1)   /* sector offset into real sector */
+#define FT_SECTOR_SIZE          1024
+#define FT_SECTORS_PER_SEGMENT    32
+#define FT_ECC_SECTORS             3
+#define FT_SEGMENT_SIZE         ((FT_SECTORS_PER_SEGMENT - FT_ECC_SECTORS) * FT_SECTOR_SIZE)
+#define FT_BUFF_SIZE    (FT_SECTORS_PER_SEGMENT * FT_SECTOR_SIZE)
+
+/*
+ *   bits of the minor device number that define drive selection
+ *   methods. Could be used one day to access multiple tape
+ *   drives on the same controller.
+ */
+#define FTAPE_SEL_A     0
+#define FTAPE_SEL_B     1
+#define FTAPE_SEL_C     2
+#define FTAPE_SEL_D     3
+#define FTAPE_SEL_MASK     3
+#define FTAPE_SEL(unit) ((unit) & FTAPE_SEL_MASK)
+#define FTAPE_NO_REWIND 4       /* mask for minor nr */
+
+/* the following two may be reported when MTIOCGET is requested ... */
+typedef union {
+        struct {
+                __u8 error;
+                __u8 command;
+        } error;
+        long space;
+} ft_drive_error;
+typedef union {
+        struct {
+                __u8 drive_status;
+                __u8 drive_config;
+                __u8 tape_status;
+        } status;
+        long space;
+} ft_drive_status;
+
+#ifdef __KERNEL__
+
+#define FT_RQM_DELAY    12
+#define FT_MILLISECOND  1
+#define FT_SECOND       1000
+#define FT_FOREVER      -1
+#ifndef HZ
+#error "HZ undefined."
+#endif
+#define FT_USPT         (1000000/HZ) /* microseconds per tick */
+
+/* This defines the number of retries that the driver will allow
+ * before giving up (and letting a higher level handle the error).
+ */
+#ifdef TESTING
+#define FT_SOFT_RETRIES 1          /* number of low level retries */
+#define FT_RETRIES_ON_ECC_ERROR 3  /* ecc error when correcting segment */
+#else
+#define FT_SOFT_RETRIES 6          /* number of low level retries (triple) */
+#define FT_RETRIES_ON_ECC_ERROR 3  /* ecc error when correcting segment */
+#endif
+
+#ifndef THE_FTAPE_MAINTAINER
+#define THE_FTAPE_MAINTAINER "the ftape maintainer"
+#endif
+
+/* Initialize missing configuration parameters.
+ */
+#ifndef CONFIG_FT_NR_BUFFERS
+# define CONFIG_FT_NR_BUFFERS 3
+#endif
+#ifndef CONFIG_FT_FDC_THR
+# define CONFIG_FT_FDC_THR 8
+#endif
+#ifndef CONFIG_FT_FDC_MAX_RATE
+# define CONFIG_FT_FDC_MAX_RATE 2000
+#endif
+#ifndef CONFIG_FT_FDC_BASE
+# define CONFIG_FT_FDC_BASE 0
+#endif
+#ifndef CONFIG_FT_FDC_IRQ
+# define CONFIG_FT_FDC_IRQ  0
+#endif
+#ifndef CONFIG_FT_FDC_DMA
+# define CONFIG_FT_FDC_DMA  0
+#endif
+
+/* Turn some booleans into numbers.
+ */
+#ifdef CONFIG_FT_PROBE_FC10
+# undef CONFIG_FT_PROBE_FC10
+# define CONFIG_FT_PROBE_FC10 1
+#else
+# define CONFIG_FT_PROBE_FC10 0
+#endif
+#ifdef CONFIG_FT_MACH2
+# undef CONFIG_FT_MACH2
+# define CONFIG_FT_MACH2 1
+#else
+# define CONFIG_FT_MACH2 0
+#endif
+
+/* Insert default settings
+ */
+#if CONFIG_FT_PROBE_FC10 == 1
+# if CONFIG_FT_FDC_BASE == 0
+#  undef  CONFIG_FT_FDC_BASE
+#  define CONFIG_FT_FDC_BASE 0x180
+# endif
+# if CONFIG_FT_FDC_IRQ == 0
+#  undef  CONFIG_FT_FDC_IRQ
+#  define CONFIG_FT_FDC_IRQ 9
+# endif
+# if CONFIG_FT_FDC_DMA == 0
+#  undef  CONFIG_FT_FDC_DMA
+#  define CONFIG_FT_FDC_DMA 3
+# endif
+#elif CONFIG_FT_MACH2 == 1    /* CONFIG_FT_PROBE_FC10 == 1 */
+# if CONFIG_FT_FDC_BASE == 0
+#  undef  CONFIG_FT_FDC_BASE
+#  define CONFIG_FT_FDC_BASE 0x1E0
+# endif
+# if CONFIG_FT_FDC_IRQ == 0
+#  undef  CONFIG_FT_FDC_IRQ
+#  define CONFIG_FT_FDC_IRQ 6
+# endif
+# if CONFIG_FT_FDC_DMA == 0
+#  undef  CONFIG_FT_FDC_DMA
+#  define CONFIG_FT_FDC_DMA 2
+# endif
+#elif CONFIG_FT_ALT_FDC == 1  /* CONFIG_FT_MACH2 */
+# if CONFIG_FT_FDC_BASE == 0
+#  undef  CONFIG_FT_FDC_BASE
+#  define CONFIG_FT_FDC_BASE 0x370
+# endif
+# if CONFIG_FT_FDC_IRQ == 0
+#  undef  CONFIG_FT_FDC_IRQ
+#  define CONFIG_FT_FDC_IRQ 6
+# endif
+# if CONFIG_FT_FDC_DMA == 0
+#  undef  CONFIG_FT_FDC_DMA
+#  define CONFIG_FT_FDC_DMA 2
+# endif
+#else                          /* CONFIG_FT_ALT_FDC */
+# if CONFIG_FT_FDC_BASE == 0
+#  undef  CONFIG_FT_FDC_BASE
+#  define CONFIG_FT_FDC_BASE 0x3f0
+# endif
+# if CONFIG_FT_FDC_IRQ == 0
+#  undef  CONFIG_FT_FDC_IRQ
+#  define CONFIG_FT_FDC_IRQ 6
+# endif
+# if CONFIG_FT_FDC_DMA == 0
+#  undef  CONFIG_FT_FDC_DMA
+#  define CONFIG_FT_FDC_DMA 2
+# endif
+#endif                         /* standard FDC */
+
+/*      some useful macro's
+ */
+#define NR_ITEMS(x)     (int)(sizeof(x)/ sizeof(*x))
+
+#endif  /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/futex.h b/include/linux/futex.h
new file mode 100644
index 000000000000..65d6cfdb6d39
--- /dev/null
+++ b/include/linux/futex.h
@@ -0,0 +1,17 @@
+#ifndef _LINUX_FUTEX_H
+#define _LINUX_FUTEX_H
+
+/* Second argument to futex syscall */
+
+
+#define FUTEX_WAIT (0)
+#define FUTEX_WAKE (1)
+#define FUTEX_FD (2)
+#define FUTEX_REQUEUE (3)
+#define FUTEX_CMP_REQUEUE (4)
+
+long do_futex(unsigned long uaddr, int op, int val,
+                unsigned long timeout, unsigned long uaddr2, int val2,
+                int val3);
+
+#endif
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
new file mode 100644
index 000000000000..b1272f822cfa
--- /dev/null
+++ b/include/linux/gameport.h
@@ -0,0 +1,198 @@
+#ifndef _GAMEPORT_H
+#define _GAMEPORT_H
+
+/*
+ *  Copyright (c) 1999-2002 Vojtech Pavlik
+ *
+ * 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.
+ */
+
+#include <asm/io.h>
+#include <linux/list.h>
+#include <linux/device.h>
+
+struct gameport {
+
+        void *port_data;        /* Private pointer for gameport drivers */
+        char name[32];
+        char phys[32];
+
+        int io;
+        int speed;
+        int fuzz;
+
+        void (*trigger)(struct gameport *);
+        unsigned char (*read)(struct gameport *);
+        int (*cooked_read)(struct gameport *, int *, int *);
+        int (*calibrate)(struct gameport *, int *, int *);
+        int (*open)(struct gameport *, int);
+        void (*close)(struct gameport *);
+
+        struct timer_list poll_timer;
+        unsigned int poll_interval;     /* in msecs */
+        spinlock_t timer_lock;
+        unsigned int poll_cnt;
+        void (*poll_handler)(struct gameport *);
+
+        struct gameport *parent, *child;
+
+        struct gameport_driver *drv;
+        struct semaphore drv_sem;       /* protects serio->drv so attributes can pin driver */
+
+        struct device dev;
+        unsigned int registered;        /* port has been fully registered with driver core */
+
+        struct list_head node;
+};
+#define to_gameport_port(d)     container_of(d, struct gameport, dev)
+
+struct gameport_driver {
+
+        void *private;
+        char *description;
+
+        int (*connect)(struct gameport *, struct gameport_driver *drv);
+        int (*reconnect)(struct gameport *);
+        void (*disconnect)(struct gameport *);
+
+        struct device_driver driver;
+
+        unsigned int ignore;
+};
+#define to_gameport_driver(d)   container_of(d, struct gameport_driver, driver)
+
+int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode);
+void gameport_close(struct gameport *gameport);
+void gameport_rescan(struct gameport *gameport);
+
+void __gameport_register_port(struct gameport *gameport, struct module *owner);
+static inline void gameport_register_port(struct gameport *gameport)
+{
+        __gameport_register_port(gameport, THIS_MODULE);
+}
+
+void gameport_unregister_port(struct gameport *gameport);
+
+static inline struct gameport *gameport_allocate_port(void)
+{
+        struct gameport *gameport = kcalloc(1, sizeof(struct gameport), GFP_KERNEL);
+
+        return gameport;
+}
+
+static inline void gameport_free_port(struct gameport *gameport)
+{
+        kfree(gameport);
+}
+
+static inline void gameport_set_name(struct gameport *gameport, const char *name)
+{
+        strlcpy(gameport->name, name, sizeof(gameport->name));
+}
+
+void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+
+/*
+ * Use the following fucntions to manipulate gameport's per-port
+ * driver-specific data.
+ */
+static inline void *gameport_get_drvdata(struct gameport *gameport)
+{
+        return dev_get_drvdata(&gameport->dev);
+}
+
+static inline void gameport_set_drvdata(struct gameport *gameport, void *data)
+{
+        dev_set_drvdata(&gameport->dev, data);
+}
+
+/*
+ * Use the following fucntions to pin gameport's driver in process context
+ */
+static inline int gameport_pin_driver(struct gameport *gameport)
+{
+        return down_interruptible(&gameport->drv_sem);
+}
+
+static inline void gameport_unpin_driver(struct gameport *gameport)
+{
+        up(&gameport->drv_sem);
+}
+
+void __gameport_register_driver(struct gameport_driver *drv, struct module *owner);
+static inline void gameport_register_driver(struct gameport_driver *drv)
+{
+        __gameport_register_driver(drv, THIS_MODULE);
+}
+
+void gameport_unregister_driver(struct gameport_driver *drv);
+
+#define GAMEPORT_MODE_DISABLED          0
+#define GAMEPORT_MODE_RAW               1
+#define GAMEPORT_MODE_COOKED            2
+
+#define GAMEPORT_ID_VENDOR_ANALOG       0x0001
+#define GAMEPORT_ID_VENDOR_MADCATZ      0x0002
+#define GAMEPORT_ID_VENDOR_LOGITECH     0x0003
+#define GAMEPORT_ID_VENDOR_CREATIVE     0x0004
+#define GAMEPORT_ID_VENDOR_GENIUS       0x0005
+#define GAMEPORT_ID_VENDOR_INTERACT     0x0006
+#define GAMEPORT_ID_VENDOR_MICROSOFT    0x0007
+#define GAMEPORT_ID_VENDOR_THRUSTMASTER 0x0008
+#define GAMEPORT_ID_VENDOR_GRAVIS       0x0009
+#define GAMEPORT_ID_VENDOR_GUILLEMOT    0x000a
+
+static inline void gameport_trigger(struct gameport *gameport)
+{
+        if (gameport->trigger)
+                gameport->trigger(gameport);
+        else
+                outb(0xff, gameport->io);
+}
+
+static inline unsigned char gameport_read(struct gameport *gameport)
+{
+        if (gameport->read)
+                return gameport->read(gameport);
+        else
+                return inb(gameport->io);
+}
+
+static inline int gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
+{
+        if (gameport->cooked_read)
+                return gameport->cooked_read(gameport, axes, buttons);
+        else
+                return -1;
+}
+
+static inline int gameport_calibrate(struct gameport *gameport, int *axes, int *max)
+{
+        if (gameport->calibrate)
+                return gameport->calibrate(gameport, axes, max);
+        else
+                return -1;
+}
+
+static inline int gameport_time(struct gameport *gameport, int time)
+{
+        return (time * gameport->speed) / 1000;
+}
+
+static inline void gameport_set_poll_handler(struct gameport *gameport, void (*handler)(struct gameport *))
+{
+        gameport->poll_handler = handler;
+}
+
+static inline void gameport_set_poll_interval(struct gameport *gameport, unsigned int msecs)
+{
+        gameport->poll_interval = msecs;
+}
+
+void gameport_start_polling(struct gameport *gameport);
+void gameport_stop_polling(struct gameport *gameport);
+
+#endif
diff --git a/include/linux/gen_stats.h b/include/linux/gen_stats.h
new file mode 100644
index 000000000000..13f4e74609ac
--- /dev/null
+++ b/include/linux/gen_stats.h
@@ -0,0 +1,67 @@
+#ifndef __LINUX_GEN_STATS_H
+#define __LINUX_GEN_STATS_H
+
+#include <linux/types.h>
+
+enum {
+        TCA_STATS_UNSPEC,
+        TCA_STATS_BASIC,
+        TCA_STATS_RATE_EST,
+        TCA_STATS_QUEUE,
+        TCA_STATS_APP,
+        __TCA_STATS_MAX,
+};
+#define TCA_STATS_MAX (__TCA_STATS_MAX - 1)
+
+/**
+ * struct gnet_stats_basic - byte/packet throughput statistics
+ * @bytes: number of seen bytes
+ * @packets: number of seen packets
+ */
+struct gnet_stats_basic
+{
+        __u64   bytes;
+        __u32   packets;
+};
+
+/**
+ * struct gnet_stats_rate_est - rate estimator
+ * @bps: current byte rate
+ * @pps: current packet rate
+ */
+struct gnet_stats_rate_est
+{
+        __u32   bps;
+        __u32   pps;
+};
+
+/**
+ * struct gnet_stats_queue - queuing statistics
+ * @qlen: queue length
+ * @backlog: backlog size of queue
+ * @drops: number of dropped packets
+ * @requeues: number of requeues
+ * @overlimits: number of enqueues over the limit
+ */
+struct gnet_stats_queue
+{
+        __u32   qlen;
+        __u32   backlog;
+        __u32   drops;
+        __u32   requeues;
+        __u32   overlimits;
+};
+
+/**
+ * struct gnet_estimator - rate estimator configuration
+ * @interval: sampling period
+ * @ewma_log: the log of measurement window weight
+ */
+struct gnet_estimator
+{
+        signed char     interval;
+        unsigned char   ewma_log;
+};
+
+
+#endif /* __LINUX_GEN_STATS_H */
diff --git a/include/linux/generic_serial.h b/include/linux/generic_serial.h
new file mode 100644
index 000000000000..0abe9d9a0069
--- /dev/null
+++ b/include/linux/generic_serial.h
@@ -0,0 +1,96 @@
+/*
+ *  generic_serial.h
+ *
+ *  Copyright (C) 1998 R.E.Wolff@BitWizard.nl
+ *
+ *  written for the SX serial driver.
+ *     Contains the code that should be shared over all the serial drivers.
+ *
+ *  Version 0.1 -- December, 1998.
+ */
+
+#ifndef GENERIC_SERIAL_H
+#define GENERIC_SERIAL_H
+
+struct real_driver {
+  void                    (*disable_tx_interrupts) (void *);
+  void                    (*enable_tx_interrupts) (void *);
+  void                    (*disable_rx_interrupts) (void *);
+  void                    (*enable_rx_interrupts) (void *);
+  int                     (*get_CD) (void *);
+  void                    (*shutdown_port) (void*);
+  int                     (*set_real_termios) (void*);
+  int                     (*chars_in_buffer) (void*);
+  void                    (*close) (void*);
+  void                    (*hungup) (void*);
+  void                    (*getserial) (void*, struct serial_struct *sp);
+};
+
+
+
+struct gs_port {
+  int                     magic;
+  unsigned char           *xmit_buf; 
+  int                     xmit_head;
+  int                     xmit_tail;
+  int                     xmit_cnt;
+  struct semaphore        port_write_sem;
+  int                     flags;
+  wait_queue_head_t       open_wait;
+  wait_queue_head_t       close_wait;
+  int                     count;
+  int                     blocked_open;
+  struct tty_struct       *tty;
+  unsigned long           event;
+  unsigned short          closing_wait;
+  int                     close_delay;
+  struct real_driver      *rd;
+  int                     wakeup_chars;
+  int                     baud_base;
+  int                     baud;
+  int                     custom_divisor;
+  spinlock_t              driver_lock;
+};
+
+
+/* Flags */
+/* Warning: serial.h defines some ASYNC_ flags, they say they are "only"
+   used in serial.c, but they are also used in all other serial drivers. 
+   Make sure they don't clash with these here... */
+#define GS_TX_INTEN      0x00800000
+#define GS_RX_INTEN      0x00400000
+#define GS_ACTIVE        0x00200000
+
+
+
+#define GS_TYPE_NORMAL   1
+
+#define GS_DEBUG_FLUSH   0x00000001
+#define GS_DEBUG_BTR     0x00000002
+#define GS_DEBUG_TERMIOS 0x00000004
+#define GS_DEBUG_STUFF   0x00000008
+#define GS_DEBUG_CLOSE   0x00000010
+#define GS_DEBUG_FLOW    0x00000020
+#define GS_DEBUG_WRITE   0x00000040
+
+
+void gs_put_char(struct tty_struct *tty, unsigned char ch);
+int  gs_write(struct tty_struct *tty, 
+             const unsigned char *buf, int count);
+int  gs_write_room(struct tty_struct *tty);
+int  gs_chars_in_buffer(struct tty_struct *tty);
+void gs_flush_buffer(struct tty_struct *tty);
+void gs_flush_chars(struct tty_struct *tty);
+void gs_stop(struct tty_struct *tty);
+void gs_start(struct tty_struct *tty);
+void gs_hangup(struct tty_struct *tty);
+int  gs_block_til_ready(void *port, struct file *filp);
+void gs_close(struct tty_struct *tty, struct file *filp);
+void gs_set_termios (struct tty_struct * tty, 
+                     struct termios * old_termios);
+int  gs_init_port(struct gs_port *port);
+int  gs_setserial(struct gs_port *port, struct serial_struct __user *sp);
+int  gs_getserial(struct gs_port *port, struct serial_struct __user *sp);
+void gs_got_break(struct gs_port *port);
+
+#endif
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
new file mode 100644
index 000000000000..47dedaf971d6
--- /dev/null
+++ b/include/linux/genhd.h
@@ -0,0 +1,424 @@
+#ifndef _LINUX_GENHD_H
+#define _LINUX_GENHD_H
+
+/*
+ *      genhd.h Copyright (C) 1992 Drew Eckhardt
+ *      Generic hard disk header file by  
+ *              Drew Eckhardt
+ *
+ *              <drew@colorado.edu>
+ */
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/major.h>
+#include <linux/device.h>
+#include <linux/smp.h>
+#include <linux/string.h>
+#include <linux/fs.h>
+
+enum {
+/* These three have identical behaviour; use the second one if DOS FDISK gets
+   confused about extended/logical partitions starting past cylinder 1023. */
+        DOS_EXTENDED_PARTITION = 5,
+        LINUX_EXTENDED_PARTITION = 0x85,
+        WIN98_EXTENDED_PARTITION = 0x0f,
+
+        LINUX_SWAP_PARTITION = 0x82,
+        LINUX_RAID_PARTITION = 0xfd,    /* autodetect RAID partition */
+
+        SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
+        NEW_SOLARIS_X86_PARTITION = 0xbf,
+
+        DM6_AUX1PARTITION = 0x51,       /* no DDO:  use xlated geom */
+        DM6_AUX3PARTITION = 0x53,       /* no DDO:  use xlated geom */
+        DM6_PARTITION = 0x54,           /* has DDO: use xlated geom & offset */
+        EZD_PARTITION = 0x55,           /* EZ-DRIVE */
+
+        FREEBSD_PARTITION = 0xa5,       /* FreeBSD Partition ID */
+        OPENBSD_PARTITION = 0xa6,       /* OpenBSD Partition ID */
+        NETBSD_PARTITION = 0xa9,        /* NetBSD Partition ID */
+        BSDI_PARTITION = 0xb7,          /* BSDI Partition ID */
+        MINIX_PARTITION = 0x81,         /* Minix Partition ID */
+        UNIXWARE_PARTITION = 0x63,      /* Same as GNU_HURD and SCO Unix */
+};
+
+#ifndef __KERNEL__
+
+struct partition {
+        unsigned char boot_ind;         /* 0x80 - active */
+        unsigned char head;             /* starting head */
+        unsigned char sector;           /* starting sector */
+        unsigned char cyl;              /* starting cylinder */
+        unsigned char sys_ind;          /* What partition type */
+        unsigned char end_head;         /* end head */
+        unsigned char end_sector;       /* end sector */
+        unsigned char end_cyl;          /* end cylinder */
+        unsigned int start_sect;        /* starting sector counting from 0 */
+        unsigned int nr_sects;          /* nr of sectors in partition */
+} __attribute__((packed));
+
+#endif
+
+#ifdef __KERNEL__
+struct partition {
+        unsigned char boot_ind;         /* 0x80 - active */
+        unsigned char head;             /* starting head */
+        unsigned char sector;           /* starting sector */
+        unsigned char cyl;              /* starting cylinder */
+        unsigned char sys_ind;          /* What partition type */
+        unsigned char end_head;         /* end head */
+        unsigned char end_sector;       /* end sector */
+        unsigned char end_cyl;          /* end cylinder */
+        __le32 start_sect;      /* starting sector counting from 0 */
+        __le32 nr_sects;                /* nr of sectors in partition */
+} __attribute__((packed));
+
+struct hd_struct {
+        sector_t start_sect;
+        sector_t nr_sects;
+        struct kobject kobj;
+        unsigned reads, read_sectors, writes, write_sectors;
+        int policy, partno;
+};
+
+#define GENHD_FL_REMOVABLE                      1
+#define GENHD_FL_DRIVERFS                       2
+#define GENHD_FL_CD                             8
+#define GENHD_FL_UP                             16
+#define GENHD_FL_SUPPRESS_PARTITION_INFO        32
+
+struct disk_stats {
+        unsigned read_sectors, write_sectors;
+        unsigned reads, writes;
+        unsigned read_merges, write_merges;
+        unsigned read_ticks, write_ticks;
+        unsigned io_ticks;
+        unsigned time_in_queue;
+};
+        
+struct gendisk {
+        int major;                      /* major number of driver */
+        int first_minor;
+        int minors;                     /* maximum number of minors, =1 for
+                                         * disks that can't be partitioned. */
+        char disk_name[32];             /* name of major driver */
+        struct hd_struct **part;        /* [indexed by minor] */
+        struct block_device_operations *fops;
+        struct request_queue *queue;
+        void *private_data;
+        sector_t capacity;
+
+        int flags;
+        char devfs_name[64];            /* devfs crap */
+        int number;                     /* more of the same */
+        struct device *driverfs_dev;
+        struct kobject kobj;
+
+        struct timer_rand_state *random;
+        int policy;
+
+        atomic_t sync_io;               /* RAID */
+        unsigned long stamp, stamp_idle;
+        int in_flight;
+#ifdef  CONFIG_SMP
+        struct disk_stats *dkstats;
+#else
+        struct disk_stats dkstats;
+#endif
+};
+
+/* Structure for sysfs attributes on block devices */
+struct disk_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct gendisk *, char *);
+};
+
+/* 
+ * Macros to operate on percpu disk statistics:
+ *
+ * The __ variants should only be called in critical sections. The full
+ * variants disable/enable preemption.
+ */
+#ifdef  CONFIG_SMP
+#define __disk_stat_add(gendiskp, field, addnd)         \
+        (per_cpu_ptr(gendiskp->dkstats, smp_processor_id())->field += addnd)
+
+#define disk_stat_read(gendiskp, field)                                 \
+({                                                                      \
+        typeof(gendiskp->dkstats->field) res = 0;                       \
+        int i;                                                          \
+        for (i=0; i < NR_CPUS; i++) {                                   \
+                if (!cpu_possible(i))                                   \
+                        continue;                                       \
+                res += per_cpu_ptr(gendiskp->dkstats, i)->field;        \
+        }                                                               \
+        res;                                                            \
+})
+
+static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)       {
+        int i;
+        for (i=0; i < NR_CPUS; i++) {
+                if (cpu_possible(i)) {
+                        memset(per_cpu_ptr(gendiskp->dkstats, i), value,        
+                                        sizeof (struct disk_stats));
+                }
+        }
+}               
+                                
+#else
+#define __disk_stat_add(gendiskp, field, addnd) \
+                                (gendiskp->dkstats.field += addnd)
+#define disk_stat_read(gendiskp, field) (gendiskp->dkstats.field)
+
+static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)       {
+        memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
+}
+#endif
+
+#define disk_stat_add(gendiskp, field, addnd)                   \
+        do {                                                    \
+                preempt_disable();                              \
+                __disk_stat_add(gendiskp, field, addnd);        \
+                preempt_enable();                               \
+        } while (0)
+
+#define __disk_stat_dec(gendiskp, field) __disk_stat_add(gendiskp, field, -1)
+#define disk_stat_dec(gendiskp, field) disk_stat_add(gendiskp, field, -1)
+
+#define __disk_stat_inc(gendiskp, field) __disk_stat_add(gendiskp, field, 1)
+#define disk_stat_inc(gendiskp, field) disk_stat_add(gendiskp, field, 1)
+
+#define __disk_stat_sub(gendiskp, field, subnd) \
+                __disk_stat_add(gendiskp, field, -subnd)
+#define disk_stat_sub(gendiskp, field, subnd) \
+                disk_stat_add(gendiskp, field, -subnd)
+
+
+/* Inlines to alloc and free disk stats in struct gendisk */
+#ifdef  CONFIG_SMP
+static inline int init_disk_stats(struct gendisk *disk)
+{
+        disk->dkstats = alloc_percpu(struct disk_stats);
+        if (!disk->dkstats)
+                return 0;
+        return 1;
+}
+
+static inline void free_disk_stats(struct gendisk *disk)
+{
+        free_percpu(disk->dkstats);
+}
+#else   /* CONFIG_SMP */
+static inline int init_disk_stats(struct gendisk *disk)
+{
+        return 1;
+}
+
+static inline void free_disk_stats(struct gendisk *disk)
+{
+}
+#endif  /* CONFIG_SMP */
+
+/* drivers/block/ll_rw_blk.c */
+extern void disk_round_stats(struct gendisk *disk);
+
+/* drivers/block/genhd.c */
+extern int get_blkdev_list(char *);
+extern void add_disk(struct gendisk *disk);
+extern void del_gendisk(struct gendisk *gp);
+extern void unlink_gendisk(struct gendisk *gp);
+extern struct gendisk *get_gendisk(dev_t dev, int *part);
+
+extern void set_device_ro(struct block_device *bdev, int flag);
+extern void set_disk_ro(struct gendisk *disk, int flag);
+
+/* drivers/char/random.c */
+extern void add_disk_randomness(struct gendisk *disk);
+extern void rand_initialize_disk(struct gendisk *disk);
+
+static inline sector_t get_start_sect(struct block_device *bdev)
+{
+        return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
+}
+static inline sector_t get_capacity(struct gendisk *disk)
+{
+        return disk->capacity;
+}
+static inline void set_capacity(struct gendisk *disk, sector_t size)
+{
+        disk->capacity = size;
+}
+
+#endif  /*  __KERNEL__  */
+
+#ifdef CONFIG_SOLARIS_X86_PARTITION
+
+#define SOLARIS_X86_NUMSLICE    8
+#define SOLARIS_X86_VTOC_SANE   (0x600DDEEEUL)
+
+struct solaris_x86_slice {
+        __le16 s_tag;           /* ID tag of partition */
+        __le16 s_flag;          /* permission flags */
+        __le32 s_start;         /* start sector no of partition */
+        __le32 s_size;          /* # of blocks in partition */
+};
+
+struct solaris_x86_vtoc {
+        unsigned int v_bootinfo[3];     /* info needed by mboot (unsupported) */
+        __le32 v_sanity;                /* to verify vtoc sanity */
+        __le32 v_version;               /* layout version */
+        char    v_volume[8];            /* volume name */
+        __le16  v_sectorsz;             /* sector size in bytes */
+        __le16  v_nparts;               /* number of partitions */
+        unsigned int v_reserved[10];    /* free space */
+        struct solaris_x86_slice
+                v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
+        unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
+        char    v_asciilabel[128];      /* for compatibility */
+};
+
+#endif /* CONFIG_SOLARIS_X86_PARTITION */
+
+#ifdef CONFIG_BSD_DISKLABEL
+/*
+ * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
+ * updated by Marc Espie <Marc.Espie@openbsd.org>
+ */
+
+/* check against BSD src/sys/sys/disklabel.h for consistency */
+
+#define BSD_DISKMAGIC   (0x82564557UL)  /* The disk magic number */
+#define BSD_MAXPARTITIONS       16
+#define OPENBSD_MAXPARTITIONS   16
+#define BSD_FS_UNUSED           0       /* disklabel unused partition entry ID */
+struct bsd_disklabel {
+        __le32  d_magic;                /* the magic number */
+        __s16   d_type;                 /* drive type */
+        __s16   d_subtype;              /* controller/d_type specific */
+        char    d_typename[16];         /* type name, e.g. "eagle" */
+        char    d_packname[16];                 /* pack identifier */ 
+        __u32   d_secsize;              /* # of bytes per sector */
+        __u32   d_nsectors;             /* # of data sectors per track */
+        __u32   d_ntracks;              /* # of tracks per cylinder */
+        __u32   d_ncylinders;           /* # of data cylinders per unit */
+        __u32   d_secpercyl;            /* # of data sectors per cylinder */
+        __u32   d_secperunit;           /* # of data sectors per unit */
+        __u16   d_sparespertrack;       /* # of spare sectors per track */
+        __u16   d_sparespercyl;         /* # of spare sectors per cylinder */
+        __u32   d_acylinders;           /* # of alt. cylinders per unit */
+        __u16   d_rpm;                  /* rotational speed */
+        __u16   d_interleave;           /* hardware sector interleave */
+        __u16   d_trackskew;            /* sector 0 skew, per track */
+        __u16   d_cylskew;              /* sector 0 skew, per cylinder */
+        __u32   d_headswitch;           /* head switch time, usec */
+        __u32   d_trkseek;              /* track-to-track seek, usec */
+        __u32   d_flags;                /* generic flags */
+#define NDDATA 5
+        __u32   d_drivedata[NDDATA];    /* drive-type specific information */
+#define NSPARE 5
+        __u32   d_spare[NSPARE];        /* reserved for future use */
+        __le32  d_magic2;               /* the magic number (again) */
+        __le16  d_checksum;             /* xor of data incl. partitions */
+
+                        /* filesystem and partition information: */
+        __le16  d_npartitions;          /* number of partitions in following */
+        __le32  d_bbsize;               /* size of boot area at sn0, bytes */
+        __le32  d_sbsize;               /* max size of fs superblock, bytes */
+        struct  bsd_partition {         /* the partition table */
+                __le32  p_size;         /* number of sectors in partition */
+                __le32  p_offset;       /* starting sector */
+                __le32  p_fsize;        /* filesystem basic fragment size */
+                __u8    p_fstype;       /* filesystem type, see below */
+                __u8    p_frag;         /* filesystem fragments per block */
+                __le16  p_cpg;          /* filesystem cylinders per group */
+        } d_partitions[BSD_MAXPARTITIONS];      /* actually may be more */
+};
+
+#endif  /* CONFIG_BSD_DISKLABEL */
+
+#ifdef CONFIG_UNIXWARE_DISKLABEL
+/*
+ * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
+ * and Krzysztof G. Baranowski <kgb@knm.org.pl>
+ */
+
+#define UNIXWARE_DISKMAGIC     (0xCA5E600DUL)   /* The disk magic number */
+#define UNIXWARE_DISKMAGIC2    (0x600DDEEEUL)   /* The slice table magic nr */
+#define UNIXWARE_NUMSLICE      16
+#define UNIXWARE_FS_UNUSED     0                /* Unused slice entry ID */
+
+struct unixware_slice {
+        __le16   s_label;       /* label */
+        __le16   s_flags;       /* permission flags */
+        __le32   start_sect;    /* starting sector */
+        __le32   nr_sects;      /* number of sectors in slice */
+};
+
+struct unixware_disklabel {
+        __le32   d_type;                /* drive type */
+        __le32   d_magic;                /* the magic number */
+        __le32   d_version;              /* version number */
+        char    d_serial[12];           /* serial number of the device */
+        __le32   d_ncylinders;           /* # of data cylinders per device */
+        __le32   d_ntracks;              /* # of tracks per cylinder */
+        __le32   d_nsectors;             /* # of data sectors per track */
+        __le32   d_secsize;              /* # of bytes per sector */
+        __le32   d_part_start;           /* # of first sector of this partition */
+        __le32   d_unknown1[12];         /* ? */
+        __le32  d_alt_tbl;              /* byte offset of alternate table */
+        __le32  d_alt_len;              /* byte length of alternate table */
+        __le32  d_phys_cyl;             /* # of physical cylinders per device */
+        __le32  d_phys_trk;             /* # of physical tracks per cylinder */
+        __le32  d_phys_sec;             /* # of physical sectors per track */
+        __le32  d_phys_bytes;           /* # of physical bytes per sector */
+        __le32  d_unknown2;             /* ? */
+        __le32   d_unknown3;             /* ? */
+        __le32  d_pad[8];               /* pad */
+
+        struct unixware_vtoc {
+                __le32  v_magic;                /* the magic number */
+                __le32  v_version;              /* version number */
+                char    v_name[8];              /* volume name */
+                __le16  v_nslices;              /* # of slices */
+                __le16  v_unknown1;             /* ? */
+                __le32  v_reserved[10];         /* reserved */
+                struct unixware_slice
+                        v_slice[UNIXWARE_NUMSLICE];     /* slice headers */
+        } vtoc;
+
+};  /* 408 */
+
+#endif /* CONFIG_UNIXWARE_DISKLABEL */
+
+#ifdef CONFIG_MINIX_SUBPARTITION
+#   define MINIX_NR_SUBPARTITIONS  4
+#endif /* CONFIG_MINIX_SUBPARTITION */
+
+#ifdef __KERNEL__
+
+char *disk_name (struct gendisk *hd, int part, char *buf);
+
+extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
+extern void add_partition(struct gendisk *, int, sector_t, sector_t);
+extern void delete_partition(struct gendisk *, int);
+
+extern struct gendisk *alloc_disk(int minors);
+extern struct kobject *get_disk(struct gendisk *disk);
+extern void put_disk(struct gendisk *disk);
+
+extern void blk_register_region(dev_t dev, unsigned long range,
+                        struct module *module,
+                        struct kobject *(*probe)(dev_t, int *, void *),
+                        int (*lock)(dev_t, void *),
+                        void *data);
+extern void blk_unregister_region(dev_t dev, unsigned long range);
+
+static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
+{
+        return bdget(MKDEV(disk->major, disk->first_minor) + index);
+}
+
+#endif
+
+#endif
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
new file mode 100644
index 000000000000..848a1baac079
--- /dev/null
+++ b/include/linux/gfp.h
@@ -0,0 +1,134 @@
+#ifndef __LINUX_GFP_H
+#define __LINUX_GFP_H
+
+#include <linux/mmzone.h>
+#include <linux/stddef.h>
+#include <linux/linkage.h>
+#include <linux/config.h>
+
+struct vm_area_struct;
+
+/*
+ * GFP bitmasks..
+ */
+/* Zone modifiers in GFP_ZONEMASK (see linux/mmzone.h - low two bits) */
+#define __GFP_DMA       0x01
+#define __GFP_HIGHMEM   0x02
+
+/*
+ * Action modifiers - doesn't change the zoning
+ *
+ * __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
+ * _might_ fail.  This depends upon the particular VM implementation.
+ *
+ * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
+ * cannot handle allocation failures.
+ *
+ * __GFP_NORETRY: The VM implementation must not retry indefinitely.
+ */
+#define __GFP_WAIT      0x10u   /* Can wait and reschedule? */
+#define __GFP_HIGH      0x20u   /* Should access emergency pools? */
+#define __GFP_IO        0x40u   /* Can start physical IO? */
+#define __GFP_FS        0x80u   /* Can call down to low-level FS? */
+#define __GFP_COLD      0x100u  /* Cache-cold page required */
+#define __GFP_NOWARN    0x200u  /* Suppress page allocation failure warning */
+#define __GFP_REPEAT    0x400u  /* Retry the allocation.  Might fail */
+#define __GFP_NOFAIL    0x800u  /* Retry for ever.  Cannot fail */
+#define __GFP_NORETRY   0x1000u /* Do not retry.  Might fail */
+#define __GFP_NO_GROW   0x2000u /* Slab internal usage */
+#define __GFP_COMP      0x4000u /* Add compound page metadata */
+#define __GFP_ZERO      0x8000u /* Return zeroed page on success */
+
+#define __GFP_BITS_SHIFT 16     /* Room for 16 __GFP_FOO bits */
+#define __GFP_BITS_MASK ((1 << __GFP_BITS_SHIFT) - 1)
+
+/* if you forget to add the bitmask here kernel will crash, period */
+#define GFP_LEVEL_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS| \
+                        __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \
+                        __GFP_NOFAIL|__GFP_NORETRY|__GFP_NO_GROW|__GFP_COMP)
+
+#define GFP_ATOMIC      (__GFP_HIGH)
+#define GFP_NOIO        (__GFP_WAIT)
+#define GFP_NOFS        (__GFP_WAIT | __GFP_IO)
+#define GFP_KERNEL      (__GFP_WAIT | __GFP_IO | __GFP_FS)
+#define GFP_USER        (__GFP_WAIT | __GFP_IO | __GFP_FS)
+#define GFP_HIGHUSER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HIGHMEM)
+
+/* Flag - indicates that the buffer will be suitable for DMA.  Ignored on some
+   platforms, used as appropriate on others */
+
+#define GFP_DMA         __GFP_DMA
+
+
+/*
+ * There is only one page-allocator function, and two main namespaces to
+ * it. The alloc_page*() variants return 'struct page *' and as such
+ * can allocate highmem pages, the *get*page*() variants return
+ * virtual kernel addresses to the allocated page(s).
+ */
+
+/*
+ * We get the zone list from the current node and the gfp_mask.
+ * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones.
+ *
+ * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets
+ * optimized to &contig_page_data at compile-time.
+ */
+
+#ifndef HAVE_ARCH_FREE_PAGE
+static inline void arch_free_page(struct page *page, int order) { }
+#endif
+
+extern struct page *
+FASTCALL(__alloc_pages(unsigned int, unsigned int, struct zonelist *));
+
+static inline struct page *alloc_pages_node(int nid, unsigned int __nocast gfp_mask,
+                                                unsigned int order)
+{
+        if (unlikely(order >= MAX_ORDER))
+                return NULL;
+
+        return __alloc_pages(gfp_mask, order,
+                NODE_DATA(nid)->node_zonelists + (gfp_mask & GFP_ZONEMASK));
+}
+
+#ifdef CONFIG_NUMA
+extern struct page *alloc_pages_current(unsigned int __nocast gfp_mask, unsigned order);
+
+static inline struct page *
+alloc_pages(unsigned int __nocast gfp_mask, unsigned int order)
+{
+        if (unlikely(order >= MAX_ORDER))
+                return NULL;
+
+        return alloc_pages_current(gfp_mask, order);
+}
+extern struct page *alloc_page_vma(unsigned __nocast gfp_mask,
+                        struct vm_area_struct *vma, unsigned long addr);
+#else
+#define alloc_pages(gfp_mask, order) \
+                alloc_pages_node(numa_node_id(), gfp_mask, order)
+#define alloc_page_vma(gfp_mask, vma, addr) alloc_pages(gfp_mask, 0)
+#endif
+#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
+
+extern unsigned long FASTCALL(__get_free_pages(unsigned int __nocast gfp_mask, unsigned int order));
+extern unsigned long FASTCALL(get_zeroed_page(unsigned int __nocast gfp_mask));
+
+#define __get_free_page(gfp_mask) \
+                __get_free_pages((gfp_mask),0)
+
+#define __get_dma_pages(gfp_mask, order) \
+                __get_free_pages((gfp_mask) | GFP_DMA,(order))
+
+extern void FASTCALL(__free_pages(struct page *page, unsigned int order));
+extern void FASTCALL(free_pages(unsigned long addr, unsigned int order));
+extern void FASTCALL(free_hot_page(struct page *page));
+extern void FASTCALL(free_cold_page(struct page *page));
+
+#define __free_page(page) __free_pages((page), 0)
+#define free_page(addr) free_pages((addr),0)
+
+void page_alloc_init(void);
+
+#endif /* __LINUX_GFP_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
new file mode 100644
index 000000000000..ebc712e91066
--- /dev/null
+++ b/include/linux/hardirq.h
@@ -0,0 +1,106 @@
+#ifndef LINUX_HARDIRQ_H
+#define LINUX_HARDIRQ_H
+
+#include <linux/config.h>
+#include <linux/smp_lock.h>
+#include <asm/hardirq.h>
+#include <asm/system.h>
+
+/*
+ * We put the hardirq and softirq counter into the preemption
+ * counter. The bitmask has the following meaning:
+ *
+ * - bits 0-7 are the preemption count (max preemption depth: 256)
+ * - bits 8-15 are the softirq count (max # of softirqs: 256)
+ *
+ * The hardirq count can be overridden per architecture, the default is:
+ *
+ * - bits 16-27 are the hardirq count (max # of hardirqs: 4096)
+ * - ( bit 28 is the PREEMPT_ACTIVE flag. )
+ *
+ * PREEMPT_MASK: 0x000000ff
+ * SOFTIRQ_MASK: 0x0000ff00
+ * HARDIRQ_MASK: 0x0fff0000
+ */
+#define PREEMPT_BITS    8
+#define SOFTIRQ_BITS    8
+
+#ifndef HARDIRQ_BITS
+#define HARDIRQ_BITS    12
+/*
+ * The hardirq mask has to be large enough to have space for potentially
+ * all IRQ sources in the system nesting on a single CPU.
+ */
+#if (1 << HARDIRQ_BITS) < NR_IRQS
+# error HARDIRQ_BITS is too low!
+#endif
+#endif
+
+#define PREEMPT_SHIFT   0
+#define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
+#define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
+
+#define __IRQ_MASK(x)   ((1UL << (x))-1)
+
+#define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
+#define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
+#define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
+
+#define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
+#define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
+#define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
+
+#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
+#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
+#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK))
+
+/*
+ * Are we doing bottom half or hardware interrupt processing?
+ * Are we in a softirq context? Interrupt context?
+ */
+#define in_irq()                (hardirq_count())
+#define in_softirq()            (softirq_count())
+#define in_interrupt()          (irq_count())
+
+#if defined(CONFIG_PREEMPT) && !defined(CONFIG_PREEMPT_BKL)
+# define in_atomic()    ((preempt_count() & ~PREEMPT_ACTIVE) != kernel_locked())
+#else
+# define in_atomic()    ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
+#endif
+
+#ifdef CONFIG_PREEMPT
+# define preemptible()  (preempt_count() == 0 && !irqs_disabled())
+# define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
+#else
+# define preemptible()  0
+# define IRQ_EXIT_OFFSET HARDIRQ_OFFSET
+#endif
+
+#ifdef CONFIG_SMP
+extern void synchronize_irq(unsigned int irq);
+#else
+# define synchronize_irq(irq)   barrier()
+#endif
+
+#define nmi_enter()             irq_enter()
+#define nmi_exit()              sub_preempt_count(HARDIRQ_OFFSET)
+
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
+static inline void account_user_vtime(struct task_struct *tsk)
+{
+}
+
+static inline void account_system_vtime(struct task_struct *tsk)
+{
+}
+#endif
+
+#define irq_enter()                                     \
+        do {                                            \
+                account_system_vtime(current);          \
+                add_preempt_count(HARDIRQ_OFFSET);      \
+        } while (0)
+
+extern void irq_exit(void);
+
+#endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/harrier_defs.h b/include/linux/harrier_defs.h
new file mode 100644
index 000000000000..685b252e16cc
--- /dev/null
+++ b/include/linux/harrier_defs.h
@@ -0,0 +1,212 @@
+/*
+ * asm-ppc/harrier_defs.h
+ *
+ * Definitions for Motorola MCG Harrier North Bridge & Memory controller
+ *
+ * Author: Dale Farnsworth
+ *         dale.farnsworth@mvista.com
+ *
+ * Extracted from asm-ppc/harrier.h by:
+ *         Randy Vinson
+ *         rvinson@mvista.com
+ *
+ * Copyright 2001-2002 MontaVista Software Inc.
+ *
+ * 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;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#ifndef __ASMPPC_HARRIER_DEFS_H
+#define __ASMPPC_HARRIER_DEFS_H
+
+#define HARRIER_DEFAULT_XCSR_BASE       0xfeff0000
+
+#define HARRIER_VEND_DEV_ID             0x1057480b
+
+#define HARRIER_VENI_OFF                0x00
+
+#define HARRIER_REVI_OFF                0x05
+#define HARRIER_UCTL_OFF                0xd0
+#define HARRIER_XTAL64_MASK             0x02
+
+#define HARRIER_MISC_CSR_OFF            0x1c
+#define HARRIER_RSTOUT                  0x01000000
+#define HARRIER_SYSCON                  0x08000000
+#define HARRIER_EREADY                  0x10000000
+#define HARRIER_ERDYS                   0x20000000
+
+/* Function exception registers */
+#define HARRIER_FEEN_OFF                0x40    /* enable */
+#define HARRIER_FEST_OFF                0x44    /* status */
+#define HARRIER_FEMA_OFF                0x48    /* mask */
+#define HARRIER_FECL_OFF                0x4c    /* clear */
+
+#define HARRIER_FE_DMA                  0x80
+#define HARRIER_FE_MIDB                 0x40
+#define HARRIER_FE_MIM0                 0x20
+#define HARRIER_FE_MIM1                 0x10
+#define HARRIER_FE_MIP                  0x08
+#define HARRIER_FE_UA0                  0x04
+#define HARRIER_FE_UA1                  0x02
+#define HARRIER_FE_ABT                  0x01
+
+#define HARRIER_SERIAL_0_OFF            0xc0
+
+#define HARRIER_MBAR_OFF                0xe0
+#define HARRIER_MBAR_MSK                0xfffc0000
+#define HARRIER_MPIC_CSR_OFF            0xe4
+#define HARRIER_MPIC_OPI_ENABLE         0x40
+#define HARRIER_MPIC_IFEVP_OFF          0x10200
+#define HARRIER_MPIC_IFEVP_VECT_MSK     0xff
+#define HARRIER_MPIC_IFEDE_OFF          0x10210
+
+/*
+ * Define the Memory Controller register offsets.
+ */
+#define HARRIER_SDBA_OFF                0x110
+#define HARRIER_SDBB_OFF                0x114
+#define HARRIER_SDBC_OFF                0x118
+#define HARRIER_SDBD_OFF                0x11c
+#define HARRIER_SDBE_OFF                0x120
+#define HARRIER_SDBF_OFF                0x124
+#define HARRIER_SDBG_OFF                0x128
+#define HARRIER_SDBH_OFF                0x12c
+
+#define HARRIER_SDB_ENABLE              0x00000100
+#define HARRIER_SDB_SIZE_MASK           0xf
+#define HARRIER_SDB_SIZE_SHIFT          16
+#define HARRIER_SDB_BASE_MASK           0xff
+#define HARRIER_SDB_BASE_SHIFT          24
+
+/*
+ * Define outbound register offsets.
+ */
+#define HARRIER_OTAD0_OFF               0x220
+#define HARRIER_OTOF0_OFF               0x224
+#define HARRIER_OTAD1_OFF               0x228
+#define HARRIER_OTOF1_OFF               0x22c
+#define HARRIER_OTAD2_OFF               0x230
+#define HARRIER_OTOF2_OFF               0x234
+#define HARRIER_OTAD3_OFF               0x238
+#define HARRIER_OTOF3_OFF               0x23c
+
+#define HARRIER_OTADX_START_MSK         0xffff0000UL
+#define HARRIER_OTADX_END_MSK           0x0000ffffUL
+
+#define HARRIER_OTOFX_OFF_MSK           0xffff0000UL
+#define HARRIER_OTOFX_ENA               0x80UL
+#define HARRIER_OTOFX_WPE               0x10UL
+#define HARRIER_OTOFX_SGE               0x08UL
+#define HARRIER_OTOFX_RAE               0x04UL
+#define HARRIER_OTOFX_MEM               0x02UL
+#define HARRIER_OTOFX_IOM               0x01UL
+
+/*
+ * Define generic message passing register offsets
+ */
+/* Mirrored registers (visible from both PowerPC and PCI space) */
+#define HARRIER_XCSR_MP_BASE_OFF        0x290   /* base offset in XCSR space */
+#define HARRIER_PMEP_MP_BASE_OFF        0x100   /* base offset in PMEM space */
+#define HARRIER_MGOM0_OFF               0x00    /* outbound msg 0 */
+#define HARRIER_MGOM1_OFF               0x04    /* outbound msg 1 */
+#define HARRIER_MGOD_OFF                0x08    /* outbound doorbells */
+
+#define HARRIER_MGIM0_OFF               0x10    /* inbound msg 0 */
+#define HARRIER_MGIM1_OFF               0x14    /* inbound msg 1 */
+#define HARRIER_MGID_OFF                0x18    /* inbound doorbells */
+
+/* PowerPC-only registers */
+#define HARRIER_MGIDM_OFF               0x20    /* inbound doorbell mask */
+
+/* PCI-only registers */
+#define HARRIER_PMEP_MGST_OFF           0x20    /* (outbound) interrupt status */
+#define HARRIER_PMEP_MGMS_OFF           0x24    /* (outbound) interrupt mask */
+#define HARRIER_MG_OMI0                 (1<<4)
+#define HARRIER_MG_OMI1                 (1<<5)
+
+#define HARRIER_PMEP_MGODM_OFF          0x28    /* outbound doorbell mask */
+
+/*
+ * Define PCI configuration space register offsets
+ */
+#define HARRIER_XCSR_TO_PCFS_OFF        0x300
+
+/*
+ * Define message passing attribute register offset
+ */
+#define HARRIER_MPAT_OFF                0x44
+
+/*
+ * Define inbound attribute register offsets.
+ */
+#define HARRIER_ITSZ0_OFF               0x48
+#define HARRIER_ITAT0_OFF               0x4c
+
+#define HARRIER_ITSZ1_OFF               0x50
+#define HARRIER_ITAT1_OFF               0x54
+
+#define HARRIER_ITSZ2_OFF               0x58
+#define HARRIER_ITAT2_OFF               0x5c
+
+#define HARRIER_ITSZ3_OFF               0x60
+#define HARRIER_ITAT3_OFF               0x64
+
+/* inbound translation size constants */
+#define HARRIER_ITSZ_MSK                0xff
+#define HARRIER_ITSZ_4KB                0x00
+#define HARRIER_ITSZ_8KB                0x01
+#define HARRIER_ITSZ_16KB               0x02
+#define HARRIER_ITSZ_32KB               0x03
+#define HARRIER_ITSZ_64KB               0x04
+#define HARRIER_ITSZ_128KB              0x05
+#define HARRIER_ITSZ_256KB              0x06
+#define HARRIER_ITSZ_512KB              0x07
+#define HARRIER_ITSZ_1MB                0x08
+#define HARRIER_ITSZ_2MB                0x09
+#define HARRIER_ITSZ_4MB                0x0A
+#define HARRIER_ITSZ_8MB                0x0B
+#define HARRIER_ITSZ_16MB               0x0C
+#define HARRIER_ITSZ_32MB               0x0D
+#define HARRIER_ITSZ_64MB               0x0E
+#define HARRIER_ITSZ_128MB              0x0F
+#define HARRIER_ITSZ_256MB              0x10
+#define HARRIER_ITSZ_512MB              0x11
+#define HARRIER_ITSZ_1GB                0x12
+#define HARRIER_ITSZ_2GB                0x13
+
+/* inbound translation offset */
+#define HARRIER_ITOF_SHIFT              0x10
+#define HARRIER_ITOF_MSK                0xffff
+
+/* inbound translation atttributes */
+#define HARRIER_ITAT_PRE                (1<<3)
+#define HARRIER_ITAT_RAE                (1<<4)
+#define HARRIER_ITAT_WPE                (1<<5)
+#define HARRIER_ITAT_MEM                (1<<6)
+#define HARRIER_ITAT_ENA                (1<<7)
+#define HARRIER_ITAT_GBL                (1<<16)
+
+#define HARRIER_LBA_OFF                 0x80
+#define HARRIER_LBA_MSK                 (1<<31)
+
+#define HARRIER_XCSR_SIZE               1024
+
+/* macros to calculate message passing register offsets */
+#define HARRIER_MP_XCSR(x) ((u32)HARRIER_XCSR_MP_BASE_OFF + (u32)x)
+
+#define HARRIER_MP_PMEP(x) ((u32)HARRIER_PMEP_MP_BASE_OFF + (u32)x)
+
+/*
+ * Define PCI configuration space register offsets
+ */
+#define HARRIER_MPBAR_OFF               PCI_BASE_ADDRESS_0
+#define HARRIER_ITBAR0_OFF              PCI_BASE_ADDRESS_1
+#define HARRIER_ITBAR1_OFF              PCI_BASE_ADDRESS_2
+#define HARRIER_ITBAR2_OFF              PCI_BASE_ADDRESS_3
+#define HARRIER_ITBAR3_OFF              PCI_BASE_ADDRESS_4
+
+#define HARRIER_XCSR_CONFIG(x) ((u32)HARRIER_XCSR_TO_PCFS_OFF + (u32)x)
+
+#endif                          /* __ASMPPC_HARRIER_DEFS_H */
diff --git a/include/linux/hash.h b/include/linux/hash.h
new file mode 100644
index 000000000000..acf17bb8e7f9
--- /dev/null
+++ b/include/linux/hash.h
@@ -0,0 +1,58 @@
+#ifndef _LINUX_HASH_H
+#define _LINUX_HASH_H
+/* Fast hashing routine for a long.
+   (C) 2002 William Lee Irwin III, IBM */
+
+/*
+ * Knuth recommends primes in approximately golden ratio to the maximum
+ * integer representable by a machine word for multiplicative hashing.
+ * Chuck Lever verified the effectiveness of this technique:
+ * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf
+ *
+ * These primes are chosen to be bit-sparse, that is operations on
+ * them can use shifts and additions instead of multiplications for
+ * machines where multiplications are slow.
+ */
+#if BITS_PER_LONG == 32
+/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
+#define GOLDEN_RATIO_PRIME 0x9e370001UL
+#elif BITS_PER_LONG == 64
+/*  2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */
+#define GOLDEN_RATIO_PRIME 0x9e37fffffffc0001UL
+#else
+#error Define GOLDEN_RATIO_PRIME for your wordsize.
+#endif
+
+static inline unsigned long hash_long(unsigned long val, unsigned int bits)
+{
+        unsigned long hash = val;
+
+#if BITS_PER_LONG == 64
+        /*  Sigh, gcc can't optimise this alone like it does for 32 bits. */
+        unsigned long n = hash;
+        n <<= 18;
+        hash -= n;
+        n <<= 33;
+        hash -= n;
+        n <<= 3;
+        hash += n;
+        n <<= 3;
+        hash -= n;
+        n <<= 4;
+        hash += n;
+        n <<= 2;
+        hash += n;
+#else
+        /* On some cpus multiply is faster, on others gcc will do shifts */
+        hash *= GOLDEN_RATIO_PRIME;
+#endif
+
+        /* High bits are more random, so use them. */
+        return hash >> (BITS_PER_LONG - bits);
+}
+        
+static inline unsigned long hash_ptr(void *ptr, unsigned int bits)
+{
+        return hash_long((unsigned long)ptr, bits);
+}
+#endif /* _LINUX_HASH_H */
diff --git a/include/linux/hayesesp.h b/include/linux/hayesesp.h
new file mode 100644
index 000000000000..b436be7a7fff
--- /dev/null
+++ b/include/linux/hayesesp.h
@@ -0,0 +1,124 @@
+#ifndef HAYESESP_H
+#define HAYESESP_H
+
+struct hayes_esp_config {
+        short flow_on;
+        short flow_off;
+        short rx_trigger;
+        short tx_trigger;
+        short pio_threshold;
+        unsigned char rx_timeout;
+        char dma_channel;
+};
+
+#ifdef __KERNEL__
+
+#define ESP_DMA_CHANNEL   0
+#define ESP_RX_TRIGGER    768
+#define ESP_TX_TRIGGER    768
+#define ESP_FLOW_OFF      1016
+#define ESP_FLOW_ON       944
+#define ESP_RX_TMOUT      128
+#define ESP_PIO_THRESHOLD 32
+
+#define ESP_IN_MAJOR    57      /* major dev # for dial in */
+#define ESP_OUT_MAJOR   58      /* major dev # for dial out */
+#define ESPC_SCALE      3
+#define UART_ESI_BASE   0x00
+#define UART_ESI_SID    0x01
+#define UART_ESI_RX     0x02
+#define UART_ESI_TX     0x02
+#define UART_ESI_CMD1   0x04
+#define UART_ESI_CMD2   0x05
+#define UART_ESI_STAT1  0x04
+#define UART_ESI_STAT2  0x05
+#define UART_ESI_RWS    0x07
+
+#define UART_IER_DMA_TMOUT      0x80
+#define UART_IER_DMA_TC         0x08
+
+#define ESI_SET_IRQ             0x04
+#define ESI_SET_DMA_TMOUT       0x05
+#define ESI_SET_SRV_MASK        0x06
+#define ESI_SET_ERR_MASK        0x07
+#define ESI_SET_FLOW_CNTL       0x08
+#define ESI_SET_FLOW_CHARS      0x09
+#define ESI_SET_FLOW_LVL        0x0a
+#define ESI_SET_TRIGGER         0x0b
+#define ESI_SET_RX_TIMEOUT      0x0c
+#define ESI_SET_FLOW_TMOUT      0x0d
+#define ESI_WRITE_UART          0x0e
+#define ESI_READ_UART           0x0f
+#define ESI_SET_MODE            0x10
+#define ESI_GET_ERR_STAT        0x12
+#define ESI_GET_UART_STAT       0x13
+#define ESI_GET_RX_AVAIL        0x14
+#define ESI_GET_TX_AVAIL        0x15
+#define ESI_START_DMA_RX        0x16
+#define ESI_START_DMA_TX        0x17
+#define ESI_ISSUE_BREAK         0x1a
+#define ESI_FLUSH_RX            0x1b
+#define ESI_FLUSH_TX            0x1c
+#define ESI_SET_BAUD            0x1d
+#define ESI_SET_ENH_IRQ         0x1f
+#define ESI_SET_REINTR          0x20
+#define ESI_SET_PRESCALAR       0x23
+#define ESI_NO_COMMAND          0xff
+
+#define ESP_STAT_RX_TIMEOUT     0x01
+#define ESP_STAT_DMA_RX         0x02
+#define ESP_STAT_DMA_TX         0x04
+#define ESP_STAT_NEVER_DMA      0x08
+#define ESP_STAT_USE_PIO        0x10
+
+#define ESP_EVENT_WRITE_WAKEUP  0
+#define ESP_MAGIC               0x53ee
+#define ESP_XMIT_SIZE           4096
+
+struct esp_struct {
+        int                     magic;
+        spinlock_t              lock;
+        int                     port;
+        int                     irq;
+        int                     flags;          /* defined in tty.h */
+        struct tty_struct       *tty;
+        int                     read_status_mask;
+        int                     ignore_status_mask;
+        int                     timeout;
+        int                     stat_flags;
+        int                     custom_divisor;
+        int                     close_delay;
+        unsigned short          closing_wait;
+        unsigned short          closing_wait2;
+        int                     IER;    /* Interrupt Enable Register */
+        int                     MCR;    /* Modem control register */
+        unsigned long           event;
+        unsigned long           last_active;
+        int                     line;
+        int                     count;      /* # of fd on device */
+        int                     blocked_open; /* # of blocked opens */
+        unsigned char           *xmit_buf;
+        int                     xmit_head;
+        int                     xmit_tail;
+        int                     xmit_cnt;
+        struct work_struct      tqueue;
+        struct work_struct      tqueue_hangup;
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        wait_queue_head_t       delta_msr_wait;
+        wait_queue_head_t       break_wait;
+        struct async_icount     icount; /* kernel counters for the 4 input interrupts */
+        struct hayes_esp_config config; /* port configuration */
+        struct esp_struct       *next_port; /* For the linked list */
+};
+
+struct esp_pio_buffer {
+        unsigned char data[1024];
+        struct esp_pio_buffer *next;
+};
+
+#endif /* __KERNEL__ */
+
+
+#endif /* ESP_H */
+
diff --git a/include/linux/hdlc.h b/include/linux/hdlc.h
new file mode 100644
index 000000000000..503194e62fe1
--- /dev/null
+++ b/include/linux/hdlc.h
@@ -0,0 +1,258 @@
+/*
+ * Generic HDLC support routines for Linux
+ *
+ * Copyright (C) 1999-2003 Krzysztof Halasa <khc@pm.waw.pl>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License
+ * as published by the Free Software Foundation.
+ */
+
+#ifndef __HDLC_H
+#define __HDLC_H
+
+#define GENERIC_HDLC_VERSION 4  /* For synchronization with sethdlc utility */
+
+#define CLOCK_DEFAULT   0       /* Default setting */
+#define CLOCK_EXT       1       /* External TX and RX clock - DTE */
+#define CLOCK_INT       2       /* Internal TX and RX clock - DCE */
+#define CLOCK_TXINT     3       /* Internal TX and external RX clock */
+#define CLOCK_TXFROMRX  4       /* TX clock derived from external RX clock */
+
+
+#define ENCODING_DEFAULT        0 /* Default setting */
+#define ENCODING_NRZ            1
+#define ENCODING_NRZI           2
+#define ENCODING_FM_MARK        3
+#define ENCODING_FM_SPACE       4
+#define ENCODING_MANCHESTER     5
+
+
+#define PARITY_DEFAULT          0 /* Default setting */
+#define PARITY_NONE             1 /* No parity */
+#define PARITY_CRC16_PR0        2 /* CRC16, initial value 0x0000 */
+#define PARITY_CRC16_PR1        3 /* CRC16, initial value 0xFFFF */
+#define PARITY_CRC16_PR0_CCITT  4 /* CRC16, initial 0x0000, ITU-T version */
+#define PARITY_CRC16_PR1_CCITT  5 /* CRC16, initial 0xFFFF, ITU-T version */
+#define PARITY_CRC32_PR0_CCITT  6 /* CRC32, initial value 0x00000000 */
+#define PARITY_CRC32_PR1_CCITT  7 /* CRC32, initial value 0xFFFFFFFF */
+
+#define LMI_DEFAULT             0 /* Default setting */
+#define LMI_NONE                1 /* No LMI, all PVCs are static */
+#define LMI_ANSI                2 /* ANSI Annex D */
+#define LMI_CCITT               3 /* ITU-T Annex A */
+
+#define HDLC_MAX_MTU 1500       /* Ethernet 1500 bytes */
+#define HDLC_MAX_MRU (HDLC_MAX_MTU + 10 + 14 + 4) /* for ETH+VLAN over FR */
+
+
+#ifdef __KERNEL__
+
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <net/syncppp.h>
+#include <linux/hdlc/ioctl.h>
+
+
+typedef struct {                /* Used in Cisco and PPP mode */
+        u8 address;
+        u8 control;
+        u16 protocol;
+}__attribute__ ((packed)) hdlc_header;
+
+
+
+typedef struct {
+        u32 type;               /* code */
+        u32 par1;
+        u32 par2;
+        u16 rel;                /* reliability */
+        u32 time;
+}__attribute__ ((packed)) cisco_packet;
+#define CISCO_PACKET_LEN        18
+#define CISCO_BIG_PACKET_LEN    20
+
+
+
+typedef struct pvc_device_struct {
+        struct net_device *master;
+        struct net_device *main;
+        struct net_device *ether; /* bridged Ethernet interface */
+        struct pvc_device_struct *next; /* Sorted in ascending DLCI order */
+        int dlci;
+        int open_count;
+
+        struct {
+                unsigned int new: 1;
+                unsigned int active: 1;
+                unsigned int exist: 1;
+                unsigned int deleted: 1;
+                unsigned int fecn: 1;
+                unsigned int becn: 1;
+        }state;
+}pvc_device;
+
+
+
+typedef struct hdlc_device_struct {
+        /* To be initialized by hardware driver */
+        struct net_device_stats stats;
+
+        /* used by HDLC layer to take control over HDLC device from hw driver*/
+        int (*attach)(struct net_device *dev,
+                      unsigned short encoding, unsigned short parity);
+
+        /* hardware driver must handle this instead of dev->hard_start_xmit */
+        int (*xmit)(struct sk_buff *skb, struct net_device *dev);
+
+
+        /* Things below are for HDLC layer internal use only */
+        struct {
+                int (*open)(struct net_device *dev);
+                void (*close)(struct net_device *dev);
+
+                /* if open & DCD */
+                void (*start)(struct net_device *dev);
+                /* if open & !DCD */
+                void (*stop)(struct net_device *dev);
+
+                void (*detach)(struct hdlc_device_struct *hdlc);
+                int (*netif_rx)(struct sk_buff *skb);
+                unsigned short (*type_trans)(struct sk_buff *skb,
+                                             struct net_device *dev);
+                int id;         /* IF_PROTO_HDLC/CISCO/FR/etc. */
+        }proto;
+
+        int carrier;
+        int open;
+        spinlock_t state_lock;
+
+        union {
+                struct {
+                        fr_proto settings;
+                        pvc_device *first_pvc;
+                        int dce_pvc_count;
+
+                        struct timer_list timer;
+                        unsigned long last_poll;
+                        int reliable;
+                        int dce_changed;
+                        int request;
+                        int fullrep_sent;
+                        u32 last_errors; /* last errors bit list */
+                        u8 n391cnt;
+                        u8 txseq; /* TX sequence number */
+                        u8 rxseq; /* RX sequence number */
+                }fr;
+
+                struct {
+                        cisco_proto settings;
+
+                        struct timer_list timer;
+                        unsigned long last_poll;
+                        int up;
+                        int request_sent;
+                        u32 txseq; /* TX sequence number */
+                        u32 rxseq; /* RX sequence number */
+                }cisco;
+
+                struct {
+                        raw_hdlc_proto settings;
+                }raw_hdlc;
+
+                struct {
+                        struct ppp_device pppdev;
+                        struct ppp_device *syncppp_ptr;
+                        int (*old_change_mtu)(struct net_device *dev,
+                                              int new_mtu);
+                }ppp;
+        }state;
+        void *priv;
+}hdlc_device;
+
+
+
+int hdlc_raw_ioctl(struct net_device *dev, struct ifreq *ifr);
+int hdlc_raw_eth_ioctl(struct net_device *dev, struct ifreq *ifr);
+int hdlc_cisco_ioctl(struct net_device *dev, struct ifreq *ifr);
+int hdlc_ppp_ioctl(struct net_device *dev, struct ifreq *ifr);
+int hdlc_fr_ioctl(struct net_device *dev, struct ifreq *ifr);
+int hdlc_x25_ioctl(struct net_device *dev, struct ifreq *ifr);
+
+
+/* Exported from hdlc.o */
+
+/* Called by hardware driver when a user requests HDLC service */
+int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
+
+/* Must be used by hardware driver on module startup/exit */
+int register_hdlc_device(struct net_device *dev);
+void unregister_hdlc_device(struct net_device *dev);
+
+struct net_device *alloc_hdlcdev(void *priv);
+
+static __inline__ hdlc_device* dev_to_hdlc(struct net_device *dev)
+{
+        return netdev_priv(dev);
+}
+
+
+static __inline__ pvc_device* dev_to_pvc(struct net_device *dev)
+{
+        return (pvc_device*)dev->priv;
+}
+
+
+static __inline__ void debug_frame(const struct sk_buff *skb)
+{
+        int i;
+
+        for (i=0; i < skb->len; i++) {
+                if (i == 100) {
+                        printk("...\n");
+                        return;
+                }
+                printk(" %02X", skb->data[i]);
+        }
+        printk("\n");
+}
+
+
+/* Must be called by hardware driver when HDLC device is being opened */
+int hdlc_open(struct net_device *dev);
+/* Must be called by hardware driver when HDLC device is being closed */
+void hdlc_close(struct net_device *dev);
+/* Called by hardware driver when DCD line level changes */
+void hdlc_set_carrier(int on, struct net_device *dev);
+
+/* May be used by hardware driver to gain control over HDLC device */
+static __inline__ void hdlc_proto_detach(hdlc_device *hdlc)
+{
+        if (hdlc->proto.detach)
+                hdlc->proto.detach(hdlc);
+        hdlc->proto.detach = NULL;
+}
+
+
+static __inline__ struct net_device_stats *hdlc_stats(struct net_device *dev)
+{
+        return &dev_to_hdlc(dev)->stats;
+}
+
+
+static __inline__ unsigned short hdlc_type_trans(struct sk_buff *skb,
+                                                 struct net_device *dev)
+{
+        hdlc_device *hdlc = dev_to_hdlc(dev);
+
+        skb->mac.raw  = skb->data;
+        skb->dev      = dev;
+
+        if (hdlc->proto.type_trans)
+                return hdlc->proto.type_trans(skb, dev);
+        else
+                return htons(ETH_P_HDLC);
+}
+
+#endif /* __KERNEL */
+#endif /* __HDLC_H */
diff --git a/include/linux/hdlc/ioctl.h b/include/linux/hdlc/ioctl.h
new file mode 100644
index 000000000000..78430ba3ea69
--- /dev/null
+++ b/include/linux/hdlc/ioctl.h
@@ -0,0 +1,48 @@
+#ifndef __HDLC_IOCTL_H__
+#define __HDLC_IOCTL_H__
+
+typedef struct { 
+        unsigned int clock_rate; /* bits per second */
+        unsigned int clock_type; /* internal, external, TX-internal etc. */
+        unsigned short loopback;
+} sync_serial_settings;          /* V.35, V.24, X.21 */
+
+typedef struct { 
+        unsigned int clock_rate; /* bits per second */
+        unsigned int clock_type; /* internal, external, TX-internal etc. */
+        unsigned short loopback;
+        unsigned int slot_map;
+} te1_settings;                  /* T1, E1 */
+
+typedef struct {
+        unsigned short encoding;
+        unsigned short parity;
+} raw_hdlc_proto;
+
+typedef struct {
+        unsigned int t391;
+        unsigned int t392;
+        unsigned int n391;
+        unsigned int n392;
+        unsigned int n393;
+        unsigned short lmi;
+        unsigned short dce; /* 1 for DCE (network side) operation */
+} fr_proto;
+
+typedef struct {
+        unsigned int dlci;
+} fr_proto_pvc;          /* for creating/deleting FR PVCs */
+
+typedef struct {
+        unsigned int dlci;
+        char master[IFNAMSIZ];  /* Name of master FRAD device */
+}fr_proto_pvc_info;             /* for returning PVC information only */
+
+typedef struct {
+    unsigned int interval;
+    unsigned int timeout;
+} cisco_proto;
+
+/* PPP doesn't need any info now - supply length = 0 to ioctl */
+
+#endif /* __HDLC_IOCTL_H__ */
diff --git a/include/linux/hdlcdrv.h b/include/linux/hdlcdrv.h
new file mode 100644
index 000000000000..4f6ee3b267fa
--- /dev/null
+++ b/include/linux/hdlcdrv.h
@@ -0,0 +1,378 @@
+/*
+ * hdlcdrv.h  -- HDLC packet radio network driver.
+ * The Linux soundcard driver for 1200 baud and 9600 baud packet radio
+ * (C) 1996-1998 by Thomas Sailer, HB9JNX/AE4WA
+ */
+
+#ifndef _HDLCDRV_H
+#define _HDLCDRV_H
+
+/* -------------------------------------------------------------------- */
+/*
+ * structs for the IOCTL commands
+ */
+
+struct hdlcdrv_params {
+        int iobase;
+        int irq;
+        int dma;
+        int dma2;
+        int seriobase;
+        int pariobase;
+        int midiiobase;
+};      
+
+struct hdlcdrv_channel_params {
+        int tx_delay;  /* the transmitter keyup delay in 10ms units */
+        int tx_tail;   /* the transmitter keyoff delay in 10ms units */
+        int slottime;  /* the slottime in 10ms; usually 10 = 100ms */
+        int ppersist;  /* the p-persistence 0..255 */
+        int fulldup;   /* some driver do not support full duplex, setting */
+                       /* this just makes them send even if DCD is on */
+};      
+
+struct hdlcdrv_old_channel_state {
+        int ptt;
+        int dcd;
+        int ptt_keyed;
+};
+
+struct hdlcdrv_channel_state {
+        int ptt;
+        int dcd;
+        int ptt_keyed;
+        unsigned long tx_packets;
+        unsigned long tx_errors;
+        unsigned long rx_packets;
+        unsigned long rx_errors;
+};
+
+struct hdlcdrv_ioctl {
+        int cmd;
+        union {
+                struct hdlcdrv_params mp;
+                struct hdlcdrv_channel_params cp;
+                struct hdlcdrv_channel_state cs;
+                struct hdlcdrv_old_channel_state ocs;
+                unsigned int calibrate;
+                unsigned char bits;
+                char modename[128];
+                char drivername[32];
+        } data;
+};
+
+/* -------------------------------------------------------------------- */
+
+/*
+ * ioctl values
+ */
+#define HDLCDRVCTL_GETMODEMPAR       0
+#define HDLCDRVCTL_SETMODEMPAR       1
+#define HDLCDRVCTL_MODEMPARMASK      2  /* not handled by hdlcdrv */
+#define HDLCDRVCTL_GETCHANNELPAR    10
+#define HDLCDRVCTL_SETCHANNELPAR    11
+#define HDLCDRVCTL_OLDGETSTAT       20
+#define HDLCDRVCTL_CALIBRATE        21
+#define HDLCDRVCTL_GETSTAT          22
+
+/*
+ * these are mainly for debugging purposes
+ */
+#define HDLCDRVCTL_GETSAMPLES       30
+#define HDLCDRVCTL_GETBITS          31
+
+/*
+ * not handled by hdlcdrv, but by its depending drivers
+ */
+#define HDLCDRVCTL_GETMODE          40
+#define HDLCDRVCTL_SETMODE          41
+#define HDLCDRVCTL_MODELIST         42
+#define HDLCDRVCTL_DRIVERNAME       43
+
+/*
+ * mask of needed modem parameters, returned by HDLCDRVCTL_MODEMPARMASK
+ */
+#define HDLCDRV_PARMASK_IOBASE      (1<<0)
+#define HDLCDRV_PARMASK_IRQ         (1<<1)
+#define HDLCDRV_PARMASK_DMA         (1<<2)
+#define HDLCDRV_PARMASK_DMA2        (1<<3)
+#define HDLCDRV_PARMASK_SERIOBASE   (1<<4)
+#define HDLCDRV_PARMASK_PARIOBASE   (1<<5)
+#define HDLCDRV_PARMASK_MIDIIOBASE  (1<<6)
+
+/* -------------------------------------------------------------------- */
+
+#ifdef __KERNEL__
+
+#include <linux/netdevice.h>
+#include <linux/if.h>
+#include <linux/spinlock.h>
+
+#define HDLCDRV_MAGIC      0x5ac6e778
+#define HDLCDRV_HDLCBUFFER  32 /* should be a power of 2 for speed reasons */
+#define HDLCDRV_BITBUFFER  256 /* should be a power of 2 for speed reasons */
+#undef HDLCDRV_LOOPBACK  /* define for HDLC debugging purposes */
+#define HDLCDRV_DEBUG
+
+/* maximum packet length, excluding CRC */
+#define HDLCDRV_MAXFLEN             400 
+
+
+struct hdlcdrv_hdlcbuffer {
+        spinlock_t lock;
+        unsigned rd, wr;
+        unsigned short buf[HDLCDRV_HDLCBUFFER];
+};
+
+#ifdef HDLCDRV_DEBUG
+struct hdlcdrv_bitbuffer {
+        unsigned int rd;
+        unsigned int wr;
+        unsigned int shreg;
+        unsigned char buffer[HDLCDRV_BITBUFFER];
+};
+
+static inline void hdlcdrv_add_bitbuffer(struct hdlcdrv_bitbuffer *buf, 
+                                         unsigned int bit)
+{
+        unsigned char new;
+
+        new = buf->shreg & 1;
+        buf->shreg >>= 1;
+        buf->shreg |= (!!bit) << 7;
+        if (new) {
+                buf->buffer[buf->wr] = buf->shreg;
+                buf->wr = (buf->wr+1) % sizeof(buf->buffer);
+                buf->shreg = 0x80;
+        }
+}
+
+static inline void hdlcdrv_add_bitbuffer_word(struct hdlcdrv_bitbuffer *buf, 
+                                              unsigned int bits)
+{
+        buf->buffer[buf->wr] = bits & 0xff;
+        buf->wr = (buf->wr+1) % sizeof(buf->buffer);
+        buf->buffer[buf->wr] = (bits >> 8) & 0xff;
+        buf->wr = (buf->wr+1) % sizeof(buf->buffer);
+
+}
+#endif /* HDLCDRV_DEBUG */
+
+/* -------------------------------------------------------------------- */
+/*
+ * Information that need to be kept for each driver. 
+ */
+
+struct hdlcdrv_ops {
+        /*
+         * first some informations needed by the hdlcdrv routines
+         */
+        const char *drvname;
+        const char *drvinfo;
+        /*
+         * the routines called by the hdlcdrv routines
+         */
+        int (*open)(struct net_device *);
+        int (*close)(struct net_device *);
+        int (*ioctl)(struct net_device *, struct ifreq *, 
+                     struct hdlcdrv_ioctl *, int);
+};
+
+struct hdlcdrv_state {
+        int magic;
+        int opened;
+
+        const struct hdlcdrv_ops *ops;
+
+        struct {
+                int bitrate;
+        } par;
+
+        struct hdlcdrv_pttoutput {
+                int dma2;
+                int seriobase;
+                int pariobase;
+                int midiiobase;
+                unsigned int flags;
+        } ptt_out;
+
+        struct hdlcdrv_channel_params ch_params;
+
+        struct hdlcdrv_hdlcrx {
+                struct hdlcdrv_hdlcbuffer hbuf;
+                long in_hdlc_rx;
+                /* 0 = sync hunt, != 0 receiving */
+                int rx_state;   
+                unsigned int bitstream;
+                unsigned int bitbuf;
+                int numbits;
+                unsigned char dcd;
+                
+                int len;
+                unsigned char *bp;
+                unsigned char buffer[HDLCDRV_MAXFLEN+2];
+        } hdlcrx;
+
+        struct hdlcdrv_hdlctx {
+                struct hdlcdrv_hdlcbuffer hbuf;
+                long in_hdlc_tx;
+                /*
+                 * 0 = send flags
+                 * 1 = send txtail (flags)
+                 * 2 = send packet
+                 */
+                int tx_state;   
+                int numflags;
+                unsigned int bitstream;
+                unsigned char ptt;
+                int calibrate;
+                int slotcnt;
+
+                unsigned int bitbuf;
+                int numbits;
+                
+                int len;
+                unsigned char *bp;
+                unsigned char buffer[HDLCDRV_MAXFLEN+2];
+        } hdlctx;
+
+#ifdef HDLCDRV_DEBUG
+        struct hdlcdrv_bitbuffer bitbuf_channel;
+        struct hdlcdrv_bitbuffer bitbuf_hdlc;
+#endif /* HDLCDRV_DEBUG */
+
+        struct net_device_stats stats;
+        int ptt_keyed;
+
+        /* queued skb for transmission */
+        struct sk_buff *skb;
+};
+
+
+/* -------------------------------------------------------------------- */
+
+static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb) 
+{
+        unsigned long flags;
+        int ret;
+        
+        spin_lock_irqsave(&hb->lock, flags);
+        ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
+        spin_unlock_irqrestore(&hb->lock, flags);
+        return ret;
+}
+
+/* -------------------------------------------------------------------- */
+
+static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
+{
+        unsigned long flags;
+        int ret;
+        
+        spin_lock_irqsave(&hb->lock, flags);
+        ret = (hb->rd == hb->wr);
+        spin_unlock_irqrestore(&hb->lock, flags);
+        return ret;
+}
+
+/* -------------------------------------------------------------------- */
+
+static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
+{
+        unsigned long flags;
+        unsigned short val;
+        unsigned newr;
+
+        spin_lock_irqsave(&hb->lock, flags);
+        if (hb->rd == hb->wr)
+                val = 0;
+        else {
+                newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
+                val = hb->buf[hb->rd];
+                hb->rd = newr;
+        }
+        spin_unlock_irqrestore(&hb->lock, flags);
+        return val;
+}
+
+/* -------------------------------------------------------------------- */
+
+static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb, 
+                                    unsigned short val)
+{
+        unsigned newp;
+        unsigned long flags;
+        
+        spin_lock_irqsave(&hb->lock, flags);
+        newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
+        if (newp != hb->rd) { 
+                hb->buf[hb->wr] = val & 0xffff;
+                hb->wr = newp;
+        }
+        spin_unlock_irqrestore(&hb->lock, flags);
+}
+
+/* -------------------------------------------------------------------- */
+
+static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
+{
+        hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
+}
+
+static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
+{
+        unsigned int ret;
+
+        if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
+                if (s->hdlctx.calibrate > 0)
+                        s->hdlctx.calibrate--;
+                else
+                        s->hdlctx.ptt = 0;
+                ret = 0;
+        } else 
+                ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
+#ifdef HDLCDRV_LOOPBACK
+        hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
+#endif /* HDLCDRV_LOOPBACK */
+        return ret;
+}
+
+static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
+{
+#ifdef HDLCDRV_DEBUG
+        hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
+#endif /* HDLCDRV_DEBUG */
+}
+
+static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
+{
+        s->hdlcrx.dcd = !!dcd;
+}
+
+static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
+{
+        return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
+}
+
+/* -------------------------------------------------------------------- */
+
+void hdlcdrv_receiver(struct net_device *, struct hdlcdrv_state *);
+void hdlcdrv_transmitter(struct net_device *, struct hdlcdrv_state *);
+void hdlcdrv_arbitrate(struct net_device *, struct hdlcdrv_state *);
+struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
+                                    unsigned int privsize, const char *ifname,
+                                    unsigned int baseaddr, unsigned int irq, 
+                                    unsigned int dma);
+void hdlcdrv_unregister(struct net_device *dev);
+
+/* -------------------------------------------------------------------- */
+
+
+
+#endif /* __KERNEL__ */
+
+/* -------------------------------------------------------------------- */
+
+#endif /* _HDLCDRV_H */
+
+/* -------------------------------------------------------------------- */
diff --git a/include/linux/hdpu_features.h b/include/linux/hdpu_features.h
new file mode 100644
index 000000000000..6a8715431ae4
--- /dev/null
+++ b/include/linux/hdpu_features.h
@@ -0,0 +1,26 @@
+#include <linux/spinlock.h>
+
+struct cpustate_t {
+        spinlock_t lock;
+        int excl;
+        int open_count;
+        unsigned char cached_val;
+        int inited;
+        unsigned long *set_addr;
+        unsigned long *clr_addr;
+};
+
+
+#define HDPU_CPUSTATE_NAME "hdpu cpustate"
+#define HDPU_NEXUS_NAME "hdpu nexus"
+
+#define CPUSTATE_KERNEL_MAJOR  0x10
+
+#define CPUSTATE_KERNEL_INIT_DRV   0 /* CPU State Driver Initialized */
+#define CPUSTATE_KERNEL_INIT_PCI   1 /* 64360 PCI Busses Init */
+#define CPUSTATE_KERNEL_INIT_REG   2 /* 64360 Bridge Init */
+#define CPUSTATE_KERNEL_CPU1_KICK  3 /* Boot cpu 1 */
+#define CPUSTATE_KERNEL_CPU1_OK    4  /* Cpu 1 has checked in */
+#define CPUSTATE_KERNEL_OK         5 /* Terminal state */
+#define CPUSTATE_KERNEL_RESET   14 /* Board reset via SW*/
+#define CPUSTATE_KERNEL_HALT   15 /* Board halted via SW*/
diff --git a/include/linux/hdreg.h b/include/linux/hdreg.h
new file mode 100644
index 000000000000..b5d660089de4
--- /dev/null
+++ b/include/linux/hdreg.h
@@ -0,0 +1,703 @@
+#ifndef _LINUX_HDREG_H
+#define _LINUX_HDREG_H
+
+#ifdef __KERNEL__
+#include <linux/ata.h>
+
+/*
+ * This file contains some defines for the AT-hd-controller.
+ * Various sources.
+ */
+
+/* ide.c has its own port definitions in "ide.h" */
+
+#define HD_IRQ          14
+
+/* Hd controller regs. Ref: IBM AT Bios-listing */
+#define HD_DATA         0x1f0           /* _CTL when writing */
+#define HD_ERROR        0x1f1           /* see err-bits */
+#define HD_NSECTOR      0x1f2           /* nr of sectors to read/write */
+#define HD_SECTOR       0x1f3           /* starting sector */
+#define HD_LCYL         0x1f4           /* starting cylinder */
+#define HD_HCYL         0x1f5           /* high byte of starting cyl */
+#define HD_CURRENT      0x1f6           /* 101dhhhh , d=drive, hhhh=head */
+#define HD_STATUS       0x1f7           /* see status-bits */
+#define HD_FEATURE      HD_ERROR        /* same io address, read=error, write=feature */
+#define HD_PRECOMP      HD_FEATURE      /* obsolete use of this port - predates IDE */
+#define HD_COMMAND      HD_STATUS       /* same io address, read=status, write=cmd */
+
+#define HD_CMD          0x3f6           /* used for resets */
+#define HD_ALTSTATUS    0x3f6           /* same as HD_STATUS but doesn't clear irq */
+
+/* remainder is shared between hd.c, ide.c, ide-cd.c, and the hdparm utility */
+
+/* Bits of HD_STATUS */
+#define ERR_STAT                0x01
+#define INDEX_STAT              0x02
+#define ECC_STAT                0x04    /* Corrected error */
+#define DRQ_STAT                0x08
+#define SEEK_STAT               0x10
+#define SRV_STAT                0x10
+#define WRERR_STAT              0x20
+#define READY_STAT              0x40
+#define BUSY_STAT               0x80
+
+/* Bits for HD_ERROR */
+#define MARK_ERR                0x01    /* Bad address mark */
+#define TRK0_ERR                0x02    /* couldn't find track 0 */
+#define ABRT_ERR                0x04    /* Command aborted */
+#define MCR_ERR                 0x08    /* media change request */
+#define ID_ERR                  0x10    /* ID field not found */
+#define MC_ERR                  0x20    /* media changed */
+#define ECC_ERR                 0x40    /* Uncorrectable ECC error */
+#define BBD_ERR                 0x80    /* pre-EIDE meaning:  block marked bad */
+#define ICRC_ERR                0x80    /* new meaning:  CRC error during transfer */
+
+/* Bits of HD_NSECTOR */
+#define CD                      0x01
+#define IO                      0x02
+#define REL                     0x04
+#define TAG_MASK                0xf8
+#endif /* __KERNEL__ */
+
+/*
+ * Command Header sizes for IOCTL commands
+ */
+
+#define HDIO_DRIVE_CMD_HDR_SIZE         (4 * sizeof(u8))
+#define HDIO_DRIVE_HOB_HDR_SIZE         (8 * sizeof(u8))
+#define HDIO_DRIVE_TASK_HDR_SIZE        (8 * sizeof(u8))
+
+#define IDE_DRIVE_TASK_INVALID          -1
+#define IDE_DRIVE_TASK_NO_DATA          0
+#define IDE_DRIVE_TASK_SET_XFER         1
+
+#define IDE_DRIVE_TASK_IN               2
+
+#define IDE_DRIVE_TASK_OUT              3
+#define IDE_DRIVE_TASK_RAW_WRITE        4
+
+/*
+ * Define standard taskfile in/out register
+ */
+#define IDE_TASKFILE_STD_OUT_FLAGS      0xFE
+#define IDE_TASKFILE_STD_IN_FLAGS       0xFE
+#define IDE_HOB_STD_OUT_FLAGS           0x3C
+#define IDE_HOB_STD_IN_FLAGS            0x3C
+
+typedef unsigned char task_ioreg_t;
+typedef unsigned long sata_ioreg_t;
+
+typedef union ide_reg_valid_s {
+        unsigned all                            : 16;
+        struct {
+                unsigned data                   : 1;
+                unsigned error_feature          : 1;
+                unsigned sector                 : 1;
+                unsigned nsector                : 1;
+                unsigned lcyl                   : 1;
+                unsigned hcyl                   : 1;
+                unsigned select                 : 1;
+                unsigned status_command         : 1;
+
+                unsigned data_hob               : 1;
+                unsigned error_feature_hob      : 1;
+                unsigned sector_hob             : 1;
+                unsigned nsector_hob            : 1;
+                unsigned lcyl_hob               : 1;
+                unsigned hcyl_hob               : 1;
+                unsigned select_hob             : 1;
+                unsigned control_hob            : 1;
+        } b;
+} ide_reg_valid_t;
+
+typedef struct ide_task_request_s {
+        task_ioreg_t    io_ports[8];
+        task_ioreg_t    hob_ports[8];
+        ide_reg_valid_t out_flags;
+        ide_reg_valid_t in_flags;
+        int             data_phase;
+        int             req_cmd;
+        unsigned long   out_size;
+        unsigned long   in_size;
+} ide_task_request_t;
+
+typedef struct ide_ioctl_request_s {
+        ide_task_request_t      *task_request;
+        unsigned char           *out_buffer;
+        unsigned char           *in_buffer;
+} ide_ioctl_request_t;
+
+struct hd_drive_cmd_hdr {
+        task_ioreg_t command;
+        task_ioreg_t sector_number;
+        task_ioreg_t feature;
+        task_ioreg_t sector_count;
+};
+
+typedef struct hd_drive_task_hdr {
+        task_ioreg_t data;
+        task_ioreg_t feature;
+        task_ioreg_t sector_count;
+        task_ioreg_t sector_number;
+        task_ioreg_t low_cylinder;
+        task_ioreg_t high_cylinder;
+        task_ioreg_t device_head;
+        task_ioreg_t command;
+} task_struct_t;
+
+typedef struct hd_drive_hob_hdr {
+        task_ioreg_t data;
+        task_ioreg_t feature;
+        task_ioreg_t sector_count;
+        task_ioreg_t sector_number;
+        task_ioreg_t low_cylinder;
+        task_ioreg_t high_cylinder;
+        task_ioreg_t device_head;
+        task_ioreg_t control;
+} hob_struct_t;
+
+#define TASKFILE_INVALID                0x7fff
+#define TASKFILE_48                     0x8000
+
+#define TASKFILE_NO_DATA                0x0000
+
+#define TASKFILE_IN                     0x0001
+#define TASKFILE_MULTI_IN               0x0002
+
+#define TASKFILE_OUT                    0x0004
+#define TASKFILE_MULTI_OUT              0x0008
+#define TASKFILE_IN_OUT                 0x0010
+
+#define TASKFILE_IN_DMA                 0x0020
+#define TASKFILE_OUT_DMA                0x0040
+#define TASKFILE_IN_DMAQ                0x0080
+#define TASKFILE_OUT_DMAQ               0x0100
+
+#define TASKFILE_P_IN                   0x0200
+#define TASKFILE_P_OUT                  0x0400
+#define TASKFILE_P_IN_DMA               0x0800
+#define TASKFILE_P_OUT_DMA              0x1000
+#define TASKFILE_P_IN_DMAQ              0x2000
+#define TASKFILE_P_OUT_DMAQ             0x4000
+
+/* ATA/ATAPI Commands pre T13 Spec */
+#define WIN_NOP                         0x00
+/*
+ *      0x01->0x02 Reserved
+ */
+#define CFA_REQ_EXT_ERROR_CODE          0x03 /* CFA Request Extended Error Code */
+/*
+ *      0x04->0x07 Reserved
+ */
+#define WIN_SRST                        0x08 /* ATAPI soft reset command */
+#define WIN_DEVICE_RESET                0x08
+/*
+ *      0x09->0x0F Reserved
+ */
+#define WIN_RECAL                       0x10
+#define WIN_RESTORE                     WIN_RECAL
+/*
+ *      0x10->0x1F Reserved
+ */
+#define WIN_READ                        0x20 /* 28-Bit */
+#define WIN_READ_ONCE                   0x21 /* 28-Bit without retries */
+#define WIN_READ_LONG                   0x22 /* 28-Bit */
+#define WIN_READ_LONG_ONCE              0x23 /* 28-Bit without retries */
+#define WIN_READ_EXT                    0x24 /* 48-Bit */
+#define WIN_READDMA_EXT                 0x25 /* 48-Bit */
+#define WIN_READDMA_QUEUED_EXT          0x26 /* 48-Bit */
+#define WIN_READ_NATIVE_MAX_EXT         0x27 /* 48-Bit */
+/*
+ *      0x28
+ */
+#define WIN_MULTREAD_EXT                0x29 /* 48-Bit */
+/*
+ *      0x2A->0x2F Reserved
+ */
+#define WIN_WRITE                       0x30 /* 28-Bit */
+#define WIN_WRITE_ONCE                  0x31 /* 28-Bit without retries */
+#define WIN_WRITE_LONG                  0x32 /* 28-Bit */
+#define WIN_WRITE_LONG_ONCE             0x33 /* 28-Bit without retries */
+#define WIN_WRITE_EXT                   0x34 /* 48-Bit */
+#define WIN_WRITEDMA_EXT                0x35 /* 48-Bit */
+#define WIN_WRITEDMA_QUEUED_EXT         0x36 /* 48-Bit */
+#define WIN_SET_MAX_EXT                 0x37 /* 48-Bit */
+#define CFA_WRITE_SECT_WO_ERASE         0x38 /* CFA Write Sectors without erase */
+#define WIN_MULTWRITE_EXT               0x39 /* 48-Bit */
+/*
+ *      0x3A->0x3B Reserved
+ */
+#define WIN_WRITE_VERIFY                0x3C /* 28-Bit */
+/*
+ *      0x3D->0x3F Reserved
+ */
+#define WIN_VERIFY                      0x40 /* 28-Bit - Read Verify Sectors */
+#define WIN_VERIFY_ONCE                 0x41 /* 28-Bit - without retries */
+#define WIN_VERIFY_EXT                  0x42 /* 48-Bit */
+/*
+ *      0x43->0x4F Reserved
+ */
+#define WIN_FORMAT                      0x50
+/*
+ *      0x51->0x5F Reserved
+ */
+#define WIN_INIT                        0x60
+/*
+ *      0x61->0x5F Reserved
+ */
+#define WIN_SEEK                        0x70 /* 0x70-0x7F Reserved */
+
+#define CFA_TRANSLATE_SECTOR            0x87 /* CFA Translate Sector */
+#define WIN_DIAGNOSE                    0x90
+#define WIN_SPECIFY                     0x91 /* set drive geometry translation */
+#define WIN_DOWNLOAD_MICROCODE          0x92
+#define WIN_STANDBYNOW2                 0x94
+#define WIN_STANDBY2                    0x96
+#define WIN_SETIDLE2                    0x97
+#define WIN_CHECKPOWERMODE2             0x98
+#define WIN_SLEEPNOW2                   0x99
+/*
+ *      0x9A VENDOR
+ */
+#define WIN_PACKETCMD                   0xA0 /* Send a packet command. */
+#define WIN_PIDENTIFY                   0xA1 /* identify ATAPI device   */
+#define WIN_QUEUED_SERVICE              0xA2
+#define WIN_SMART                       0xB0 /* self-monitoring and reporting */
+#define CFA_ERASE_SECTORS               0xC0
+#define WIN_MULTREAD                    0xC4 /* read sectors using multiple mode*/
+#define WIN_MULTWRITE                   0xC5 /* write sectors using multiple mode */
+#define WIN_SETMULT                     0xC6 /* enable/disable multiple mode */
+#define WIN_READDMA_QUEUED              0xC7 /* read sectors using Queued DMA transfers */
+#define WIN_READDMA                     0xC8 /* read sectors using DMA transfers */
+#define WIN_READDMA_ONCE                0xC9 /* 28-Bit - without retries */
+#define WIN_WRITEDMA                    0xCA /* write sectors using DMA transfers */
+#define WIN_WRITEDMA_ONCE               0xCB /* 28-Bit - without retries */
+#define WIN_WRITEDMA_QUEUED             0xCC /* write sectors using Queued DMA transfers */
+#define CFA_WRITE_MULTI_WO_ERASE        0xCD /* CFA Write multiple without erase */
+#define WIN_GETMEDIASTATUS              0xDA
+#define WIN_ACKMEDIACHANGE              0xDB /* ATA-1, ATA-2 vendor */
+#define WIN_POSTBOOT                    0xDC
+#define WIN_PREBOOT                     0xDD
+#define WIN_DOORLOCK                    0xDE /* lock door on removable drives */
+#define WIN_DOORUNLOCK                  0xDF /* unlock door on removable drives */
+#define WIN_STANDBYNOW1                 0xE0
+#define WIN_IDLEIMMEDIATE               0xE1 /* force drive to become "ready" */
+#define WIN_STANDBY                     0xE2 /* Set device in Standby Mode */
+#define WIN_SETIDLE1                    0xE3
+#define WIN_READ_BUFFER                 0xE4 /* force read only 1 sector */
+#define WIN_CHECKPOWERMODE1             0xE5
+#define WIN_SLEEPNOW1                   0xE6
+#define WIN_FLUSH_CACHE                 0xE7
+#define WIN_WRITE_BUFFER                0xE8 /* force write only 1 sector */
+#define WIN_WRITE_SAME                  0xE9 /* read ata-2 to use */
+        /* SET_FEATURES 0x22 or 0xDD */
+#define WIN_FLUSH_CACHE_EXT             0xEA /* 48-Bit */
+#define WIN_IDENTIFY                    0xEC /* ask drive to identify itself    */
+#define WIN_MEDIAEJECT                  0xED
+#define WIN_IDENTIFY_DMA                0xEE /* same as WIN_IDENTIFY, but DMA */
+#define WIN_SETFEATURES                 0xEF /* set special drive features */
+#define EXABYTE_ENABLE_NEST             0xF0
+#define WIN_SECURITY_SET_PASS           0xF1
+#define WIN_SECURITY_UNLOCK             0xF2
+#define WIN_SECURITY_ERASE_PREPARE      0xF3
+#define WIN_SECURITY_ERASE_UNIT         0xF4
+#define WIN_SECURITY_FREEZE_LOCK        0xF5
+#define WIN_SECURITY_DISABLE            0xF6
+#define WIN_READ_NATIVE_MAX             0xF8 /* return the native maximum address */
+#define WIN_SET_MAX                     0xF9
+#define DISABLE_SEAGATE                 0xFB
+
+/* WIN_SMART sub-commands */
+
+#define SMART_READ_VALUES               0xD0
+#define SMART_READ_THRESHOLDS           0xD1
+#define SMART_AUTOSAVE                  0xD2
+#define SMART_SAVE                      0xD3
+#define SMART_IMMEDIATE_OFFLINE         0xD4
+#define SMART_READ_LOG_SECTOR           0xD5
+#define SMART_WRITE_LOG_SECTOR          0xD6
+#define SMART_WRITE_THRESHOLDS          0xD7
+#define SMART_ENABLE                    0xD8
+#define SMART_DISABLE                   0xD9
+#define SMART_STATUS                    0xDA
+#define SMART_AUTO_OFFLINE              0xDB
+
+/* Password used in TF4 & TF5 executing SMART commands */
+
+#define SMART_LCYL_PASS                 0x4F
+#define SMART_HCYL_PASS                 0xC2
+
+/* WIN_SETFEATURES sub-commands */
+#define SETFEATURES_EN_8BIT     0x01    /* Enable 8-Bit Transfers */
+#define SETFEATURES_EN_WCACHE   0x02    /* Enable write cache */
+#define SETFEATURES_DIS_DEFECT  0x04    /* Disable Defect Management */
+#define SETFEATURES_EN_APM      0x05    /* Enable advanced power management */
+#define SETFEATURES_EN_SAME_R   0x22    /* for a region ATA-1 */
+#define SETFEATURES_DIS_MSN     0x31    /* Disable Media Status Notification */
+#define SETFEATURES_DIS_RETRY   0x33    /* Disable Retry */
+#define SETFEATURES_EN_AAM      0x42    /* Enable Automatic Acoustic Management */
+#define SETFEATURES_RW_LONG     0x44    /* Set Length of VS bytes */
+#define SETFEATURES_SET_CACHE   0x54    /* Set Cache segments to SC Reg. Val */
+#define SETFEATURES_DIS_RLA     0x55    /* Disable read look-ahead feature */
+#define SETFEATURES_EN_RI       0x5D    /* Enable release interrupt */
+#define SETFEATURES_EN_SI       0x5E    /* Enable SERVICE interrupt */
+#define SETFEATURES_DIS_RPOD    0x66    /* Disable reverting to power on defaults */
+#define SETFEATURES_DIS_ECC     0x77    /* Disable ECC byte count */
+#define SETFEATURES_DIS_8BIT    0x81    /* Disable 8-Bit Transfers */
+#define SETFEATURES_DIS_WCACHE  0x82    /* Disable write cache */
+#define SETFEATURES_EN_DEFECT   0x84    /* Enable Defect Management */
+#define SETFEATURES_DIS_APM     0x85    /* Disable advanced power management */
+#define SETFEATURES_EN_ECC      0x88    /* Enable ECC byte count */
+#define SETFEATURES_EN_MSN      0x95    /* Enable Media Status Notification */
+#define SETFEATURES_EN_RETRY    0x99    /* Enable Retry */
+#define SETFEATURES_EN_RLA      0xAA    /* Enable read look-ahead feature */
+#define SETFEATURES_PREFETCH    0xAB    /* Sets drive prefetch value */
+#define SETFEATURES_EN_REST     0xAC    /* ATA-1 */
+#define SETFEATURES_4B_RW_LONG  0xBB    /* Set Lenght of 4 bytes */
+#define SETFEATURES_DIS_AAM     0xC2    /* Disable Automatic Acoustic Management */
+#define SETFEATURES_EN_RPOD     0xCC    /* Enable reverting to power on defaults */
+#define SETFEATURES_DIS_RI      0xDD    /* Disable release interrupt ATAPI */
+#define SETFEATURES_EN_SAME_M   0xDD    /* for a entire device ATA-1 */
+#define SETFEATURES_DIS_SI      0xDE    /* Disable SERVICE interrupt ATAPI */
+
+/* WIN_SECURITY sub-commands */
+
+#define SECURITY_SET_PASSWORD           0xBA
+#define SECURITY_UNLOCK                 0xBB
+#define SECURITY_ERASE_PREPARE          0xBC
+#define SECURITY_ERASE_UNIT             0xBD
+#define SECURITY_FREEZE_LOCK            0xBE
+#define SECURITY_DISABLE_PASSWORD       0xBF
+
+struct hd_geometry {
+      unsigned char heads;
+      unsigned char sectors;
+      unsigned short cylinders;
+      unsigned long start;
+};
+
+/* hd/ide ctl's that pass (arg) ptrs to user space are numbered 0x030n/0x031n */
+#define HDIO_GETGEO             0x0301  /* get device geometry */
+#define HDIO_GET_UNMASKINTR     0x0302  /* get current unmask setting */
+#define HDIO_GET_MULTCOUNT      0x0304  /* get current IDE blockmode setting */
+#define HDIO_GET_QDMA           0x0305  /* get use-qdma flag */
+
+#define HDIO_SET_XFER           0x0306  /* set transfer rate via proc */
+
+#define HDIO_OBSOLETE_IDENTITY  0x0307  /* OBSOLETE, DO NOT USE: returns 142 bytes */
+#define HDIO_GET_KEEPSETTINGS   0x0308  /* get keep-settings-on-reset flag */
+#define HDIO_GET_32BIT          0x0309  /* get current io_32bit setting */
+#define HDIO_GET_NOWERR         0x030a  /* get ignore-write-error flag */
+#define HDIO_GET_DMA            0x030b  /* get use-dma flag */
+#define HDIO_GET_NICE           0x030c  /* get nice flags */
+#define HDIO_GET_IDENTITY       0x030d  /* get IDE identification info */
+#define HDIO_GET_WCACHE         0x030e  /* get write cache mode on|off */
+#define HDIO_GET_ACOUSTIC       0x030f  /* get acoustic value */
+#define HDIO_GET_ADDRESS        0x0310  /* */
+
+#define HDIO_GET_BUSSTATE       0x031a  /* get the bus state of the hwif */
+#define HDIO_TRISTATE_HWIF      0x031b  /* execute a channel tristate */
+#define HDIO_DRIVE_RESET        0x031c  /* execute a device reset */
+#define HDIO_DRIVE_TASKFILE     0x031d  /* execute raw taskfile */
+#define HDIO_DRIVE_TASK         0x031e  /* execute task and special drive command */
+#define HDIO_DRIVE_CMD          0x031f  /* execute a special drive command */
+#define HDIO_DRIVE_CMD_AEB      HDIO_DRIVE_TASK
+
+/* hd/ide ctl's that pass (arg) non-ptr values are numbered 0x032n/0x033n */
+#define HDIO_SET_MULTCOUNT      0x0321  /* change IDE blockmode */
+#define HDIO_SET_UNMASKINTR     0x0322  /* permit other irqs during I/O */
+#define HDIO_SET_KEEPSETTINGS   0x0323  /* keep ioctl settings on reset */
+#define HDIO_SET_32BIT          0x0324  /* change io_32bit flags */
+#define HDIO_SET_NOWERR         0x0325  /* change ignore-write-error flag */
+#define HDIO_SET_DMA            0x0326  /* change use-dma flag */
+#define HDIO_SET_PIO_MODE       0x0327  /* reconfig interface to new speed */
+#define HDIO_SCAN_HWIF          0x0328  /* register and (re)scan interface */
+#define HDIO_SET_NICE           0x0329  /* set nice flags */
+#define HDIO_UNREGISTER_HWIF    0x032a  /* unregister interface */
+#define HDIO_SET_WCACHE         0x032b  /* change write cache enable-disable */
+#define HDIO_SET_ACOUSTIC       0x032c  /* change acoustic behavior */
+#define HDIO_SET_BUSSTATE       0x032d  /* set the bus state of the hwif */
+#define HDIO_SET_QDMA           0x032e  /* change use-qdma flag */
+#define HDIO_SET_ADDRESS        0x032f  /* change lba addressing modes */
+
+/* bus states */
+enum {
+        BUSSTATE_OFF = 0,
+        BUSSTATE_ON,
+        BUSSTATE_TRISTATE
+};
+
+/* hd/ide ctl's that pass (arg) ptrs to user space are numbered 0x033n/0x033n */
+/* 0x330 is reserved - used to be HDIO_GETGEO_BIG */
+/* 0x331 is reserved - used to be HDIO_GETGEO_BIG_RAW */
+/* 0x338 is reserved - used to be HDIO_SET_IDE_SCSI */
+/* 0x339 is reserved - used to be HDIO_SET_SCSI_IDE */
+
+#define __NEW_HD_DRIVE_ID
+
+/*
+ * Structure returned by HDIO_GET_IDENTITY, as per ANSI NCITS ATA6 rev.1b spec.
+ *
+ * If you change something here, please remember to update fix_driveid() in
+ * ide/probe.c.
+ */
+struct hd_driveid {
+        unsigned short  config;         /* lots of obsolete bit flags */
+        unsigned short  cyls;           /* Obsolete, "physical" cyls */
+        unsigned short  reserved2;      /* reserved (word 2) */
+        unsigned short  heads;          /* Obsolete, "physical" heads */
+        unsigned short  track_bytes;    /* unformatted bytes per track */
+        unsigned short  sector_bytes;   /* unformatted bytes per sector */
+        unsigned short  sectors;        /* Obsolete, "physical" sectors per track */
+        unsigned short  vendor0;        /* vendor unique */
+        unsigned short  vendor1;        /* vendor unique */
+        unsigned short  vendor2;        /* Retired vendor unique */
+        unsigned char   serial_no[20];  /* 0 = not_specified */
+        unsigned short  buf_type;       /* Retired */
+        unsigned short  buf_size;       /* Retired, 512 byte increments
+                                         * 0 = not_specified
+                                         */
+        unsigned short  ecc_bytes;      /* for r/w long cmds; 0 = not_specified */
+        unsigned char   fw_rev[8];      /* 0 = not_specified */
+        unsigned char   model[40];      /* 0 = not_specified */
+        unsigned char   max_multsect;   /* 0=not_implemented */
+        unsigned char   vendor3;        /* vendor unique */
+        unsigned short  dword_io;       /* 0=not_implemented; 1=implemented */
+        unsigned char   vendor4;        /* vendor unique */
+        unsigned char   capability;     /* (upper byte of word 49)
+                                         *  3:  IORDYsup
+                                         *  2:  IORDYsw
+                                         *  1:  LBA
+                                         *  0:  DMA
+                                         */
+        unsigned short  reserved50;     /* reserved (word 50) */
+        unsigned char   vendor5;        /* Obsolete, vendor unique */
+        unsigned char   tPIO;           /* Obsolete, 0=slow, 1=medium, 2=fast */
+        unsigned char   vendor6;        /* Obsolete, vendor unique */
+        unsigned char   tDMA;           /* Obsolete, 0=slow, 1=medium, 2=fast */
+        unsigned short  field_valid;    /* (word 53)
+                                         *  2:  ultra_ok        word  88
+                                         *  1:  eide_ok         words 64-70
+                                         *  0:  cur_ok          words 54-58
+                                         */
+        unsigned short  cur_cyls;       /* Obsolete, logical cylinders */
+        unsigned short  cur_heads;      /* Obsolete, l heads */
+        unsigned short  cur_sectors;    /* Obsolete, l sectors per track */
+        unsigned short  cur_capacity0;  /* Obsolete, l total sectors on drive */
+        unsigned short  cur_capacity1;  /* Obsolete, (2 words, misaligned int)     */
+        unsigned char   multsect;       /* current multiple sector count */
+        unsigned char   multsect_valid; /* when (bit0==1) multsect is ok */
+        unsigned int    lba_capacity;   /* Obsolete, total number of sectors */
+        unsigned short  dma_1word;      /* Obsolete, single-word dma info */
+        unsigned short  dma_mword;      /* multiple-word dma info */
+        unsigned short  eide_pio_modes; /* bits 0:mode3 1:mode4 */
+        unsigned short  eide_dma_min;   /* min mword dma cycle time (ns) */
+        unsigned short  eide_dma_time;  /* recommended mword dma cycle time (ns) */
+        unsigned short  eide_pio;       /* min cycle time (ns), no IORDY  */
+        unsigned short  eide_pio_iordy; /* min cycle time (ns), with IORDY */
+        unsigned short  words69_70[2];  /* reserved words 69-70
+                                         * future command overlap and queuing
+                                         */
+        /* HDIO_GET_IDENTITY currently returns only words 0 through 70 */
+        unsigned short  words71_74[4];  /* reserved words 71-74
+                                         * for IDENTIFY PACKET DEVICE command
+                                         */
+        unsigned short  queue_depth;    /* (word 75)
+                                         * 15:5 reserved
+                                         *  4:0 Maximum queue depth -1
+                                         */
+        unsigned short  words76_79[4];  /* reserved words 76-79 */
+        unsigned short  major_rev_num;  /* (word 80) */
+        unsigned short  minor_rev_num;  /* (word 81) */
+        unsigned short  command_set_1;  /* (word 82) supported
+                                         * 15:  Obsolete
+                                         * 14:  NOP command
+                                         * 13:  READ_BUFFER
+                                         * 12:  WRITE_BUFFER
+                                         * 11:  Obsolete
+                                         * 10:  Host Protected Area
+                                         *  9:  DEVICE Reset
+                                         *  8:  SERVICE Interrupt
+                                         *  7:  Release Interrupt
+                                         *  6:  look-ahead
+                                         *  5:  write cache
+                                         *  4:  PACKET Command
+                                         *  3:  Power Management Feature Set
+                                         *  2:  Removable Feature Set
+                                         *  1:  Security Feature Set
+                                         *  0:  SMART Feature Set
+                                         */
+        unsigned short  command_set_2;  /* (word 83)
+                                         * 15:  Shall be ZERO
+                                         * 14:  Shall be ONE
+                                         * 13:  FLUSH CACHE EXT
+                                         * 12:  FLUSH CACHE
+                                         * 11:  Device Configuration Overlay
+                                         * 10:  48-bit Address Feature Set
+                                         *  9:  Automatic Acoustic Management
+                                         *  8:  SET MAX security
+                                         *  7:  reserved 1407DT PARTIES
+                                         *  6:  SetF sub-command Power-Up
+                                         *  5:  Power-Up in Standby Feature Set
+                                         *  4:  Removable Media Notification
+                                         *  3:  APM Feature Set
+                                         *  2:  CFA Feature Set
+                                         *  1:  READ/WRITE DMA QUEUED
+                                         *  0:  Download MicroCode
+                                         */
+        unsigned short  cfsse;          /* (word 84)
+                                         * cmd set-feature supported extensions
+                                         * 15:  Shall be ZERO
+                                         * 14:  Shall be ONE
+                                         * 13:6 reserved
+                                         *  5:  General Purpose Logging
+                                         *  4:  Streaming Feature Set
+                                         *  3:  Media Card Pass Through
+                                         *  2:  Media Serial Number Valid
+                                         *  1:  SMART selt-test supported
+                                         *  0:  SMART error logging
+                                         */
+        unsigned short  cfs_enable_1;   /* (word 85)
+                                         * command set-feature enabled
+                                         * 15:  Obsolete
+                                         * 14:  NOP command
+                                         * 13:  READ_BUFFER
+                                         * 12:  WRITE_BUFFER
+                                         * 11:  Obsolete
+                                         * 10:  Host Protected Area
+                                         *  9:  DEVICE Reset
+                                         *  8:  SERVICE Interrupt
+                                         *  7:  Release Interrupt
+                                         *  6:  look-ahead
+                                         *  5:  write cache
+                                         *  4:  PACKET Command
+                                         *  3:  Power Management Feature Set
+                                         *  2:  Removable Feature Set
+                                         *  1:  Security Feature Set
+                                         *  0:  SMART Feature Set
+                                         */
+        unsigned short  cfs_enable_2;   /* (word 86)
+                                         * command set-feature enabled
+                                         * 15:  Shall be ZERO
+                                         * 14:  Shall be ONE
+                                         * 13:  FLUSH CACHE EXT
+                                         * 12:  FLUSH CACHE
+                                         * 11:  Device Configuration Overlay
+                                         * 10:  48-bit Address Feature Set
+                                         *  9:  Automatic Acoustic Management
+                                         *  8:  SET MAX security
+                                         *  7:  reserved 1407DT PARTIES
+                                         *  6:  SetF sub-command Power-Up
+                                         *  5:  Power-Up in Standby Feature Set
+                                         *  4:  Removable Media Notification
+                                         *  3:  APM Feature Set
+                                         *  2:  CFA Feature Set
+                                         *  1:  READ/WRITE DMA QUEUED
+                                         *  0:  Download MicroCode
+                                         */
+        unsigned short  csf_default;    /* (word 87)
+                                         * command set-feature default
+                                         * 15:  Shall be ZERO
+                                         * 14:  Shall be ONE
+                                         * 13:6 reserved
+                                         *  5:  General Purpose Logging enabled
+                                         *  4:  Valid CONFIGURE STREAM executed
+                                         *  3:  Media Card Pass Through enabled
+                                         *  2:  Media Serial Number Valid
+                                         *  1:  SMART selt-test supported
+                                         *  0:  SMART error logging
+                                         */
+        unsigned short  dma_ultra;      /* (word 88) */
+        unsigned short  trseuc;         /* time required for security erase */
+        unsigned short  trsEuc;         /* time required for enhanced erase */
+        unsigned short  CurAPMvalues;   /* current APM values */
+        unsigned short  mprc;           /* master password revision code */
+        unsigned short  hw_config;      /* hardware config (word 93)
+                                         * 15:  Shall be ZERO
+                                         * 14:  Shall be ONE
+                                         * 13:
+                                         * 12:
+                                         * 11:
+                                         * 10:
+                                         *  9:
+                                         *  8:
+                                         *  7:
+                                         *  6:
+                                         *  5:
+                                         *  4:
+                                         *  3:
+                                         *  2:
+                                         *  1:
+                                         *  0:  Shall be ONE
+                                         */
+        unsigned short  acoustic;       /* (word 94)
+                                         * 15:8 Vendor's recommended value
+                                         *  7:0 current value
+                                         */
+        unsigned short  msrqs;          /* min stream request size */
+        unsigned short  sxfert;         /* stream transfer time */
+        unsigned short  sal;            /* stream access latency */
+        unsigned int    spg;            /* stream performance granularity */
+        unsigned long long lba_capacity_2;/* 48-bit total number of sectors */
+        unsigned short  words104_125[22];/* reserved words 104-125 */
+        unsigned short  last_lun;       /* (word 126) */
+        unsigned short  word127;        /* (word 127) Feature Set
+                                         * Removable Media Notification
+                                         * 15:2 reserved
+                                         *  1:0 00 = not supported
+                                         *      01 = supported
+                                         *      10 = reserved
+                                         *      11 = reserved
+                                         */
+        unsigned short  dlf;            /* (word 128)
+                                         * device lock function
+                                         * 15:9 reserved
+                                         *  8   security level 1:max 0:high
+                                         *  7:6 reserved
+                                         *  5   enhanced erase
+                                         *  4   expire
+                                         *  3   frozen
+                                         *  2   locked
+                                         *  1   en/disabled
+                                         *  0   capability
+                                         */
+        unsigned short  csfo;           /*  (word 129)
+                                         * current set features options
+                                         * 15:4 reserved
+                                         *  3:  auto reassign
+                                         *  2:  reverting
+                                         *  1:  read-look-ahead
+                                         *  0:  write cache
+                                         */
+        unsigned short  words130_155[26];/* reserved vendor words 130-155 */
+        unsigned short  word156;        /* reserved vendor word 156 */
+        unsigned short  words157_159[3];/* reserved vendor words 157-159 */
+        unsigned short  cfa_power;      /* (word 160) CFA Power Mode
+                                         * 15 word 160 supported
+                                         * 14 reserved
+                                         * 13
+                                         * 12
+                                         * 11:0
+                                         */
+        unsigned short  words161_175[15];/* Reserved for CFA */
+        unsigned short  words176_205[30];/* Current Media Serial Number */
+        unsigned short  words206_254[49];/* reserved words 206-254 */
+        unsigned short  integrity_word; /* (word 255)
+                                         * 15:8 Checksum
+                                         *  7:0 Signature
+                                         */
+};
+
+/*
+ * IDE "nice" flags. These are used on a per drive basis to determine
+ * when to be nice and give more bandwidth to the other devices which
+ * share the same IDE bus.
+ */
+#define IDE_NICE_DSC_OVERLAP    (0)     /* per the DSC overlap protocol */
+#define IDE_NICE_ATAPI_OVERLAP  (1)     /* not supported yet */
+#define IDE_NICE_0              (2)     /* when sure that it won't affect us */
+#define IDE_NICE_1              (3)     /* when probably won't affect us much */
+#define IDE_NICE_2              (4)     /* when we know it's on our expense */
+
+#endif  /* _LINUX_HDREG_H */
diff --git a/include/linux/hdsmart.h b/include/linux/hdsmart.h
new file mode 100644
index 000000000000..7974a47fe582
--- /dev/null
+++ b/include/linux/hdsmart.h
@@ -0,0 +1,124 @@
+/*
+ * linux/include/linux/hdsmart.h
+ *
+ * Copyright (C) 1999-2000      Michael Cornwell <cornwell@acm.org>
+ * Copyright (C) 2000           Andre Hedrick <andre@linux-ide.org>
+ *
+ * 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; either version 2, or (at your option)
+ * any later version.
+ *
+ * You should have received a copy of the GNU General Public License
+ * (for example /usr/src/linux/COPYING); if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _LINUX_HDSMART_H
+#define _LINUX_HDSMART_H
+
+#define OFFLINE_FULL_SCAN               0
+#define SHORT_SELF_TEST                 1
+#define EXTEND_SELF_TEST                2
+#define SHORT_CAPTIVE_SELF_TEST         129
+#define EXTEND_CAPTIVE_SELF_TEST        130
+
+/* smart_attribute is the vendor specific in SFF-8035 spec */
+typedef struct ata_smart_attribute_s {
+        unsigned char                   id;
+        unsigned short                  status_flag;
+        unsigned char                   normalized;
+        unsigned char                   worse_normal;
+        unsigned char                   raw[6];
+        unsigned char                   reserv;
+} __attribute__ ((packed)) ata_smart_attribute_t;
+
+/* smart_values is format of the read drive Atrribute command */
+typedef struct ata_smart_values_s {
+        unsigned short                  revnumber;
+        ata_smart_attribute_t           vendor_attributes [30];
+        unsigned char                   offline_data_collection_status;
+        unsigned char                   self_test_exec_status;
+        unsigned short                  total_time_to_complete_off_line;
+        unsigned char                   vendor_specific_366;
+        unsigned char                   offline_data_collection_capability;
+        unsigned short                  smart_capability;
+        unsigned char                   errorlog_capability;
+        unsigned char                   vendor_specific_371;
+        unsigned char                   short_test_completion_time;
+        unsigned char                   extend_test_completion_time;
+        unsigned char                   reserved_374_385 [12];
+        unsigned char                   vendor_specific_386_509 [125];
+        unsigned char                   chksum;
+} __attribute__ ((packed)) ata_smart_values_t;
+
+/* Smart Threshold data structures */
+/* Vendor attribute of SMART Threshold */
+typedef struct ata_smart_threshold_entry_s {
+        unsigned char                   id;
+        unsigned char                   normalized_threshold;
+        unsigned char                   reserved[10];
+} __attribute__ ((packed)) ata_smart_threshold_entry_t;
+
+/* Format of Read SMART THreshold Command */
+typedef struct ata_smart_thresholds_s {
+        unsigned short                  revnumber;
+        ata_smart_threshold_entry_t     thres_entries[30];
+        unsigned char                   reserved[149];
+        unsigned char                   chksum;
+} __attribute__ ((packed)) ata_smart_thresholds_t;
+
+typedef struct ata_smart_errorlog_command_struct_s {
+        unsigned char                   devicecontrolreg;
+        unsigned char                   featuresreg;
+        unsigned char                   sector_count;
+        unsigned char                   sector_number;
+        unsigned char                   cylinder_low;
+        unsigned char                   cylinder_high;
+        unsigned char                   drive_head;
+        unsigned char                   commandreg;
+        unsigned int                    timestamp;
+} __attribute__ ((packed)) ata_smart_errorlog_command_struct_t;
+
+typedef struct ata_smart_errorlog_error_struct_s {
+        unsigned char                   error_condition;
+        unsigned char                   extended_error[14];
+        unsigned char                   state;
+        unsigned short                  timestamp;
+} __attribute__ ((packed)) ata_smart_errorlog_error_struct_t;
+
+typedef struct ata_smart_errorlog_struct_s {
+        ata_smart_errorlog_command_struct_t     commands[6];
+        ata_smart_errorlog_error_struct_t       error_struct;
+} __attribute__ ((packed)) ata_smart_errorlog_struct_t;
+
+typedef struct ata_smart_errorlog_s {
+        unsigned char                   revnumber;
+        unsigned char                   error_log_pointer;
+        ata_smart_errorlog_struct_t     errorlog_struct[5];
+        unsigned short                  ata_error_count;
+        unsigned short                  non_fatal_count;
+        unsigned short                  drive_timeout_count;
+        unsigned char                   reserved[53];
+        unsigned char                   chksum;
+} __attribute__ ((packed)) ata_smart_errorlog_t;
+
+typedef struct ata_smart_selftestlog_struct_s {
+        unsigned char                   selftestnumber;
+        unsigned char                   selfteststatus;
+        unsigned short                  timestamp;
+        unsigned char                   selftestfailurecheckpoint;
+        unsigned int                    lbafirstfailure;
+        unsigned char                   vendorspecific[15];
+} __attribute__ ((packed)) ata_smart_selftestlog_struct_t;
+
+typedef struct ata_smart_selftestlog_s {
+        unsigned short                  revnumber;
+        ata_smart_selftestlog_struct_t  selftest_struct[21];
+        unsigned char                   vendorspecific[2];
+        unsigned char                   mostrecenttest;
+        unsigned char                   resevered[2];
+        unsigned char                   chksum;
+} __attribute__ ((packed)) ata_smart_selftestlog_t;
+
+#endif  /* _LINUX_HDSMART_H */
diff --git a/include/linux/hiddev.h b/include/linux/hiddev.h
new file mode 100644
index 000000000000..945ba1ad14ac
--- /dev/null
+++ b/include/linux/hiddev.h
@@ -0,0 +1,240 @@
+#ifndef _HIDDEV_H
+#define _HIDDEV_H
+
+/*
+ * $Id: hiddev.h,v 1.2 2001/04/26 11:26:09 vojtech Exp $
+ *
+ *  Copyright (c) 1999-2000 Vojtech Pavlik
+ *
+ *  Sponsored by SuSE
+ */
+
+/*
+ * 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; either version 2 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * 
+ * Should you need to contact me, the author, you can do so either by
+ * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
+ * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
+ */
+
+/*
+ * The event structure itself
+ */
+
+struct hiddev_event {
+        unsigned hid;
+        signed int value;
+};
+
+struct hiddev_devinfo {
+        __u32 bustype;
+        __u32 busnum;
+        __u32 devnum;
+        __u32 ifnum;
+        __s16 vendor;
+        __s16 product;
+        __s16 version;
+        __u32 num_applications;
+};
+
+struct hiddev_collection_info {
+        __u32 index;
+        __u32 type;
+        __u32 usage;
+        __u32 level;
+};
+
+#define HID_STRING_SIZE 256
+struct hiddev_string_descriptor {
+        __s32 index;
+        char value[HID_STRING_SIZE];
+};
+
+struct hiddev_report_info {
+        __u32 report_type;
+        __u32 report_id;
+        __u32 num_fields;
+};
+
+/* To do a GUSAGE/SUSAGE, fill in at least usage_code,  report_type and 
+ * report_id.  Set report_id to REPORT_ID_UNKNOWN if the rest of the fields 
+ * are unknown.  Otherwise use a usage_ref struct filled in from a previous 
+ * successful GUSAGE call to save time.  To actually send a value to the
+ * device, perform a SUSAGE first, followed by a SREPORT.  An INITREPORT or a
+ * GREPORT isn't necessary for a GUSAGE to return valid data.
+ */
+#define HID_REPORT_ID_UNKNOWN 0xffffffff
+#define HID_REPORT_ID_FIRST   0x00000100
+#define HID_REPORT_ID_NEXT    0x00000200
+#define HID_REPORT_ID_MASK    0x000000ff
+#define HID_REPORT_ID_MAX     0x000000ff
+
+#define HID_REPORT_TYPE_INPUT   1
+#define HID_REPORT_TYPE_OUTPUT  2
+#define HID_REPORT_TYPE_FEATURE 3
+#define HID_REPORT_TYPE_MIN     1
+#define HID_REPORT_TYPE_MAX     3
+
+struct hiddev_field_info {
+        __u32 report_type;
+        __u32 report_id;
+        __u32 field_index;
+        __u32 maxusage;
+        __u32 flags;
+        __u32 physical;         /* physical usage for this field */
+        __u32 logical;          /* logical usage for this field */
+        __u32 application;              /* application usage for this field */
+        __s32 logical_minimum;
+        __s32 logical_maximum;
+        __s32 physical_minimum;
+        __s32 physical_maximum;
+        __u32 unit_exponent;
+        __u32 unit;
+};
+
+/* Fill in report_type, report_id and field_index to get the information on a
+ * field.
+ */
+#define HID_FIELD_CONSTANT              0x001
+#define HID_FIELD_VARIABLE              0x002
+#define HID_FIELD_RELATIVE              0x004
+#define HID_FIELD_WRAP                  0x008   
+#define HID_FIELD_NONLINEAR             0x010
+#define HID_FIELD_NO_PREFERRED          0x020
+#define HID_FIELD_NULL_STATE            0x040
+#define HID_FIELD_VOLATILE              0x080
+#define HID_FIELD_BUFFERED_BYTE         0x100
+
+struct hiddev_usage_ref {
+        __u32 report_type;
+        __u32 report_id;
+        __u32 field_index;
+        __u32 usage_index;
+        __u32 usage_code;
+        __s32 value;
+};
+
+/* hiddev_usage_ref_multi is used for sending multiple bytes to a control.
+ * It really manifests itself as setting the value of consecutive usages */
+#define HID_MAX_MULTI_USAGES 1024
+struct hiddev_usage_ref_multi {
+        struct hiddev_usage_ref uref;
+        __u32 num_values;
+        __s32 values[HID_MAX_MULTI_USAGES];
+};
+
+/* FIELD_INDEX_NONE is returned in read() data from the kernel when flags
+ * is set to (HIDDEV_FLAG_UREF | HIDDEV_FLAG_REPORT) and a new report has
+ * been sent by the device 
+ */
+#define HID_FIELD_INDEX_NONE 0xffffffff
+
+/*
+ * Protocol version.
+ */
+
+#define HID_VERSION             0x010004
+
+/*
+ * IOCTLs (0x00 - 0x7f)
+ */
+
+#define HIDIOCGVERSION          _IOR('H', 0x01, int)
+#define HIDIOCAPPLICATION       _IO('H', 0x02)
+#define HIDIOCGDEVINFO          _IOR('H', 0x03, struct hiddev_devinfo)
+#define HIDIOCGSTRING           _IOR('H', 0x04, struct hiddev_string_descriptor)
+#define HIDIOCINITREPORT        _IO('H', 0x05)
+#define HIDIOCGNAME(len)        _IOC(_IOC_READ, 'H', 0x06, len)
+#define HIDIOCGREPORT           _IOW('H', 0x07, struct hiddev_report_info)
+#define HIDIOCSREPORT           _IOW('H', 0x08, struct hiddev_report_info)
+#define HIDIOCGREPORTINFO       _IOWR('H', 0x09, struct hiddev_report_info)
+#define HIDIOCGFIELDINFO        _IOWR('H', 0x0A, struct hiddev_field_info)
+#define HIDIOCGUSAGE            _IOWR('H', 0x0B, struct hiddev_usage_ref)
+#define HIDIOCSUSAGE            _IOW('H', 0x0C, struct hiddev_usage_ref)
+#define HIDIOCGUCODE            _IOWR('H', 0x0D, struct hiddev_usage_ref)
+#define HIDIOCGFLAG             _IOR('H', 0x0E, int)
+#define HIDIOCSFLAG             _IOW('H', 0x0F, int)
+#define HIDIOCGCOLLECTIONINDEX  _IOW('H', 0x10, struct hiddev_usage_ref)
+#define HIDIOCGCOLLECTIONINFO   _IOWR('H', 0x11, struct hiddev_collection_info)
+#define HIDIOCGPHYS(len)        _IOC(_IOC_READ, 'H', 0x12, len)
+
+/* For writing/reading to multiple/consecutive usages */
+#define HIDIOCGUSAGES           _IOWR('H', 0x13, struct hiddev_usage_ref_multi)
+#define HIDIOCSUSAGES           _IOW('H', 0x14, struct hiddev_usage_ref_multi)
+
+/* 
+ * Flags to be used in HIDIOCSFLAG
+ */
+#define HIDDEV_FLAG_UREF        0x1
+#define HIDDEV_FLAG_REPORT      0x2
+#define HIDDEV_FLAGS            0x3
+
+/* To traverse the input report descriptor info for a HID device, perform the 
+ * following:
+ *
+ *  rinfo.report_type = HID_REPORT_TYPE_INPUT;
+ *  rinfo.report_id = HID_REPORT_ID_FIRST;
+ *  ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ *
+ *  while (ret >= 0) {
+ *      for (i = 0; i < rinfo.num_fields; i++) { 
+ *          finfo.report_type = rinfo.report_type;
+ *          finfo.report_id = rinfo.report_id;
+ *          finfo.field_index = i;
+ *          ioctl(fd, HIDIOCGFIELDINFO, &finfo);
+ *          for (j = 0; j < finfo.maxusage; j++) {
+ *              uref.field_index = i;
+ *              uref.usage_index = j;
+ *              ioctl(fd, HIDIOCGUCODE, &uref);
+ *              ioctl(fd, HIDIOCGUSAGE, &uref);
+ *          }
+ *      }
+ *      rinfo.report_id |= HID_REPORT_ID_NEXT;
+ *      ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ *  }
+ */
+
+
+#ifdef __KERNEL__
+
+/*
+ * In-kernel definitions.
+ */
+
+struct hid_device;
+struct hid_usage;
+struct hid_field;
+struct hid_report;
+
+#ifdef CONFIG_USB_HIDDEV
+int hiddev_connect(struct hid_device *);
+void hiddev_disconnect(struct hid_device *);
+void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
+                      struct hid_usage *usage, __s32 value, struct pt_regs *regs);
+void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
+int __init hiddev_init(void);
+void hiddev_exit(void);
+#else
+static inline int hiddev_connect(struct hid_device *hid) { return -1; }
+static inline void hiddev_disconnect(struct hid_device *hid) { }
+static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
+                      struct hid_usage *usage, __s32 value, struct pt_regs *regs) { }
+static inline void hiddev_report_event(struct hid_device *hid, struct hid_report *report) { }
+static inline int hiddev_init(void) { return 0; }
+static inline void hiddev_exit(void) { }
+#endif
+
+#endif
+#endif
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
new file mode 100644
index 000000000000..2a7e6c65c882
--- /dev/null
+++ b/include/linux/highmem.h
@@ -0,0 +1,104 @@
+#ifndef _LINUX_HIGHMEM_H
+#define _LINUX_HIGHMEM_H
+
+#include <linux/config.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+
+#include <asm/cacheflush.h>
+
+#ifdef CONFIG_HIGHMEM
+
+#include <asm/highmem.h>
+
+/* declarations for linux/mm/highmem.c */
+unsigned int nr_free_highpages(void);
+
+#else /* CONFIG_HIGHMEM */
+
+static inline unsigned int nr_free_highpages(void) { return 0; }
+
+static inline void *kmap(struct page *page)
+{
+        might_sleep();
+        return page_address(page);
+}
+
+#define kunmap(page) do { (void) (page); } while (0)
+
+#define kmap_atomic(page, idx)          page_address(page)
+#define kunmap_atomic(addr, idx)        do { } while (0)
+#define kmap_atomic_to_page(ptr)        virt_to_page(ptr)
+
+#endif /* CONFIG_HIGHMEM */
+
+/* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */
+static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
+{
+        void *addr = kmap_atomic(page, KM_USER0);
+        clear_user_page(addr, vaddr, page);
+        kunmap_atomic(addr, KM_USER0);
+        /* Make sure this page is cleared on other CPU's too before using it */
+        smp_wmb();
+}
+
+#ifndef __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE
+static inline struct page *
+alloc_zeroed_user_highpage(struct vm_area_struct *vma, unsigned long vaddr)
+{
+        struct page *page = alloc_page_vma(GFP_HIGHUSER, vma, vaddr);
+
+        if (page)
+                clear_user_highpage(page, vaddr);
+
+        return page;
+}
+#endif
+
+static inline void clear_highpage(struct page *page)
+{
+        void *kaddr = kmap_atomic(page, KM_USER0);
+        clear_page(kaddr);
+        kunmap_atomic(kaddr, KM_USER0);
+}
+
+/*
+ * Same but also flushes aliased cache contents to RAM.
+ */
+static inline void memclear_highpage_flush(struct page *page, unsigned int offset, unsigned int size)
+{
+        void *kaddr;
+
+        BUG_ON(offset + size > PAGE_SIZE);
+
+        kaddr = kmap_atomic(page, KM_USER0);
+        memset((char *)kaddr + offset, 0, size);
+        flush_dcache_page(page);
+        kunmap_atomic(kaddr, KM_USER0);
+}
+
+static inline void copy_user_highpage(struct page *to, struct page *from, unsigned long vaddr)
+{
+        char *vfrom, *vto;
+
+        vfrom = kmap_atomic(from, KM_USER0);
+        vto = kmap_atomic(to, KM_USER1);
+        copy_user_page(vto, vfrom, vaddr, to);
+        kunmap_atomic(vfrom, KM_USER0);
+        kunmap_atomic(vto, KM_USER1);
+        /* Make sure this page is cleared on other CPU's too before using it */
+        smp_wmb();
+}
+
+static inline void copy_highpage(struct page *to, struct page *from)
+{
+        char *vfrom, *vto;
+
+        vfrom = kmap_atomic(from, KM_USER0);
+        vto = kmap_atomic(to, KM_USER1);
+        copy_page(vto, vfrom);
+        kunmap_atomic(vfrom, KM_USER0);
+        kunmap_atomic(vto, KM_USER1);
+}
+
+#endif /* _LINUX_HIGHMEM_H */
diff --git a/include/linux/highuid.h b/include/linux/highuid.h
new file mode 100644
index 000000000000..53ecac3905e8
--- /dev/null
+++ b/include/linux/highuid.h
@@ -0,0 +1,98 @@
+#ifndef _LINUX_HIGHUID_H
+#define _LINUX_HIGHUID_H
+
+#include <linux/config.h>
+#include <linux/types.h>
+
+/*
+ * general notes:
+ *
+ * CONFIG_UID16 is defined if the given architecture needs to
+ * support backwards compatibility for old system calls.
+ *
+ * kernel code should use uid_t and gid_t at all times when dealing with
+ * kernel-private data.
+ *
+ * old_uid_t and old_gid_t should only be different if CONFIG_UID16 is
+ * defined, else the platform should provide dummy typedefs for them
+ * such that they are equivalent to __kernel_{u,g}id_t.
+ *
+ * uid16_t and gid16_t are used on all architectures. (when dealing
+ * with structures hard coded to 16 bits, such as in filesystems)
+ */
+
+
+/*
+ * This is the "overflow" UID and GID. They are used to signify uid/gid
+ * overflow to old programs when they request uid/gid information but are
+ * using the old 16 bit interfaces.
+ * When you run a libc5 program, it will think that all highuid files or
+ * processes are owned by this uid/gid.
+ * The idea is that it's better to do so than possibly return 0 in lieu of
+ * 65536, etc.
+ */
+
+extern int overflowuid;
+extern int overflowgid;
+
+extern void __bad_uid(void);
+extern void __bad_gid(void);
+
+#define DEFAULT_OVERFLOWUID     65534
+#define DEFAULT_OVERFLOWGID     65534
+
+#ifdef CONFIG_UID16
+
+/* prevent uid mod 65536 effect by returning a default value for high UIDs */
+#define high2lowuid(uid) ((uid) & ~0xFFFF ? (old_uid_t)overflowuid : (old_uid_t)(uid))
+#define high2lowgid(gid) ((gid) & ~0xFFFF ? (old_gid_t)overflowgid : (old_gid_t)(gid))
+/*
+ * -1 is different in 16 bits than it is in 32 bits
+ * these macros are used by chown(), setreuid(), ...,
+ */
+#define low2highuid(uid) ((uid) == (old_uid_t)-1 ? (uid_t)-1 : (uid_t)(uid))
+#define low2highgid(gid) ((gid) == (old_gid_t)-1 ? (gid_t)-1 : (gid_t)(gid))
+
+#define __convert_uid(size, uid) \
+        (size >= sizeof(uid) ? (uid) : high2lowuid(uid))
+#define __convert_gid(size, gid) \
+        (size >= sizeof(gid) ? (gid) : high2lowgid(gid))
+        
+
+#else
+
+#define __convert_uid(size, uid) (uid)
+#define __convert_gid(size, gid) (gid)
+
+#endif /* !CONFIG_UID16 */
+
+/* uid/gid input should be always 32bit uid_t */
+#define SET_UID(var, uid) do { (var) = __convert_uid(sizeof(var), (uid)); } while (0)
+#define SET_GID(var, gid) do { (var) = __convert_gid(sizeof(var), (gid)); } while (0)
+
+/*
+ * Everything below this line is needed on all architectures, to deal with
+ * filesystems that only store 16 bits of the UID/GID, etc.
+ */
+
+/*
+ * This is the UID and GID that will get written to disk if a filesystem
+ * only supports 16-bit UIDs and the kernel has a high UID/GID to write
+ */
+extern int fs_overflowuid;
+extern int fs_overflowgid;
+
+#define DEFAULT_FS_OVERFLOWUID  65534
+#define DEFAULT_FS_OVERFLOWGID  65534
+
+/*
+ * Since these macros are used in architectures that only need limited
+ * 16-bit UID back compatibility, we won't use old_uid_t and old_gid_t
+ */
+#define fs_high2lowuid(uid) ((uid) & ~0xFFFF ? (uid16_t)fs_overflowuid : (uid16_t)(uid))
+#define fs_high2lowgid(gid) ((gid) & ~0xFFFF ? (gid16_t)fs_overflowgid : (gid16_t)(gid))
+
+#define low_16_bits(x)  ((x) & 0xFFFF)
+#define high_16_bits(x) (((x) & 0xFFFF0000) >> 16)
+
+#endif /* _LINUX_HIGHUID_H */
diff --git a/include/linux/hippidevice.h b/include/linux/hippidevice.h
new file mode 100644
index 000000000000..89b3a4a5b761
--- /dev/null
+++ b/include/linux/hippidevice.h
@@ -0,0 +1,35 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the HIPPI handlers.
+ *
+ * Version:     @(#)hippidevice.h       1.0.0   05/26/97
+ *
+ * Author:      Jes Sorensen, <Jes.Sorensen@cern.ch>
+ *
+ *              hippidevice.h is based on previous fddidevice.h work by
+ *                      Ross Biro, <bir7@leland.Stanford.Edu>
+ *                      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *                      Alan Cox, <gw4pts@gw4pts.ampr.org>
+ *                      Lawrence V. Stefani, <stefani@lkg.dec.com>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_HIPPIDEVICE_H
+#define _LINUX_HIPPIDEVICE_H
+
+#include <linux/if_hippi.h>
+
+#ifdef __KERNEL__
+extern unsigned short hippi_type_trans(struct sk_buff *skb,
+                                       struct net_device *dev);
+
+extern struct net_device *alloc_hippi_dev(int sizeof_priv);
+#endif
+
+#endif  /* _LINUX_HIPPIDEVICE_H */
diff --git a/include/linux/hpet.h b/include/linux/hpet.h
new file mode 100644
index 000000000000..27238194b212
--- /dev/null
+++ b/include/linux/hpet.h
@@ -0,0 +1,136 @@
+#ifndef __HPET__
+#define __HPET__ 1
+
+#include <linux/compiler.h>
+
+/*
+ * Offsets into HPET Registers
+ */
+
+struct hpet {
+        u64 hpet_cap;           /* capabilities */
+        u64 res0;               /* reserved */
+        u64 hpet_config;        /* configuration */
+        u64 res1;               /* reserved */
+        u64 hpet_isr;           /* interrupt status reg */
+        u64 res2[25];           /* reserved */
+        union {                 /* main counter */
+                u64 _hpet_mc64;
+                u32 _hpet_mc32;
+                unsigned long _hpet_mc;
+        } _u0;
+        u64 res3;               /* reserved */
+        struct hpet_timer {
+                u64 hpet_config;        /* configuration/cap */
+                union {         /* timer compare register */
+                        u64 _hpet_hc64;
+                        u32 _hpet_hc32;
+                        unsigned long _hpet_compare;
+                } _u1;
+                u64 hpet_fsb[2];        /* FSB route */
+        } hpet_timers[1];
+};
+
+#define hpet_mc         _u0._hpet_mc
+#define hpet_compare    _u1._hpet_compare
+
+#define HPET_MAX_TIMERS (32)
+
+/*
+ * HPET general capabilities register
+ */
+
+#define HPET_COUNTER_CLK_PERIOD_MASK    (0xffffffff00000000ULL)
+#define HPET_COUNTER_CLK_PERIOD_SHIFT   (32UL)
+#define HPET_VENDOR_ID_MASK             (0x00000000ffff0000ULL)
+#define HPET_VENDOR_ID_SHIFT            (16ULL)
+#define HPET_LEG_RT_CAP_MASK            (0x8000)
+#define HPET_COUNTER_SIZE_MASK          (0x2000)
+#define HPET_NUM_TIM_CAP_MASK           (0x1f00)
+#define HPET_NUM_TIM_CAP_SHIFT          (8ULL)
+
+/*
+ * HPET general configuration register
+ */
+
+#define HPET_LEG_RT_CNF_MASK            (2UL)
+#define HPET_ENABLE_CNF_MASK            (1UL)
+
+
+/*
+ * Timer configuration register
+ */
+
+#define Tn_INT_ROUTE_CAP_MASK           (0xffffffff00000000ULL)
+#define Tn_INI_ROUTE_CAP_SHIFT          (32UL)
+#define Tn_FSB_INT_DELCAP_MASK          (0x8000UL)
+#define Tn_FSB_INT_DELCAP_SHIFT         (15)
+#define Tn_FSB_EN_CNF_MASK              (0x4000UL)
+#define Tn_FSB_EN_CNF_SHIFT             (14)
+#define Tn_INT_ROUTE_CNF_MASK           (0x3e00UL)
+#define Tn_INT_ROUTE_CNF_SHIFT          (9)
+#define Tn_32MODE_CNF_MASK              (0x0100UL)
+#define Tn_VAL_SET_CNF_MASK             (0x0040UL)
+#define Tn_SIZE_CAP_MASK                (0x0020UL)
+#define Tn_PER_INT_CAP_MASK             (0x0010UL)
+#define Tn_TYPE_CNF_MASK                (0x0008UL)
+#define Tn_INT_ENB_CNF_MASK             (0x0004UL)
+#define Tn_INT_TYPE_CNF_MASK            (0x0002UL)
+
+/*
+ * Timer FSB Interrupt Route Register
+ */
+
+#define Tn_FSB_INT_ADDR_MASK            (0xffffffff00000000ULL)
+#define Tn_FSB_INT_ADDR_SHIFT           (32UL)
+#define Tn_FSB_INT_VAL_MASK             (0x00000000ffffffffULL)
+
+struct hpet_info {
+        unsigned long hi_ireqfreq;      /* Hz */
+        unsigned long hi_flags; /* information */
+        unsigned short hi_hpet;
+        unsigned short hi_timer;
+};
+
+#define HPET_INFO_PERIODIC      0x0001  /* timer is periodic */
+
+#define HPET_IE_ON      _IO('h', 0x01)  /* interrupt on */
+#define HPET_IE_OFF     _IO('h', 0x02)  /* interrupt off */
+#define HPET_INFO       _IOR('h', 0x03, struct hpet_info)
+#define HPET_EPI        _IO('h', 0x04)  /* enable periodic */
+#define HPET_DPI        _IO('h', 0x05)  /* disable periodic */
+#define HPET_IRQFREQ    _IOW('h', 0x6, unsigned long)   /* IRQFREQ usec */
+
+/*
+ * exported interfaces
+ */
+
+struct hpet_task {
+        void (*ht_func) (void *);
+        void *ht_data;
+        void *ht_opaque;
+};
+
+struct hpet_data {
+        unsigned long hd_phys_address;
+        void __iomem *hd_address;
+        unsigned short hd_nirqs;
+        unsigned short hd_flags;
+        unsigned int hd_state;  /* timer allocated */
+        unsigned int hd_irq[HPET_MAX_TIMERS];
+};
+
+#define HPET_DATA_PLATFORM      0x0001  /* platform call to hpet_alloc */
+
+static inline void hpet_reserve_timer(struct hpet_data *hd, int timer)
+{
+        hd->hd_state |= (1 << timer);
+        return;
+}
+
+int hpet_alloc(struct hpet_data *);
+int hpet_register(struct hpet_task *, int);
+int hpet_unregister(struct hpet_task *);
+int hpet_control(struct hpet_task *, unsigned int, unsigned long);
+
+#endif                          /* !__HPET__ */
diff --git a/include/linux/hpfs_fs.h b/include/linux/hpfs_fs.h
new file mode 100644
index 000000000000..a5028dd94d31
--- /dev/null
+++ b/include/linux/hpfs_fs.h
@@ -0,0 +1,8 @@
+#ifndef _LINUX_HPFS_FS_H
+#define _LINUX_HPFS_FS_H
+
+/* HPFS magic number (word 0 of block 16) */
+
+#define HPFS_SUPER_MAGIC 0xf995e849
+
+#endif
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
new file mode 100644
index 000000000000..ae45676d27ba
--- /dev/null
+++ b/include/linux/hugetlb.h
@@ -0,0 +1,142 @@
+#ifndef _LINUX_HUGETLB_H
+#define _LINUX_HUGETLB_H
+
+#ifdef CONFIG_HUGETLB_PAGE
+
+#include <linux/mempolicy.h>
+
+struct ctl_table;
+
+static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
+{
+        return vma->vm_flags & VM_HUGETLB;
+}
+
+int hugetlb_sysctl_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *);
+int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
+int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *, struct page **, struct vm_area_struct **, unsigned long *, int *, int);
+void zap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
+void unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
+int hugetlb_prefault(struct address_space *, struct vm_area_struct *);
+int hugetlb_report_meminfo(char *);
+int hugetlb_report_node_meminfo(int, char *);
+int is_hugepage_mem_enough(size_t);
+unsigned long hugetlb_total_pages(void);
+struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
+                              int write);
+struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
+                                pmd_t *pmd, int write);
+int is_aligned_hugepage_range(unsigned long addr, unsigned long len);
+int pmd_huge(pmd_t pmd);
+struct page *alloc_huge_page(void);
+void free_huge_page(struct page *);
+
+extern unsigned long max_huge_pages;
+extern const unsigned long hugetlb_zero, hugetlb_infinity;
+extern int sysctl_hugetlb_shm_group;
+
+#ifndef ARCH_HAS_HUGEPAGE_ONLY_RANGE
+#define is_hugepage_only_range(mm, addr, len)   0
+#define hugetlb_free_pgtables(tlb, prev, start, end) do { } while (0)
+#endif
+
+#ifndef ARCH_HAS_PREPARE_HUGEPAGE_RANGE
+#define prepare_hugepage_range(addr, len)       \
+        is_aligned_hugepage_range(addr, len)
+#else
+int prepare_hugepage_range(unsigned long addr, unsigned long len);
+#endif
+
+#else /* !CONFIG_HUGETLB_PAGE */
+
+static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
+{
+        return 0;
+}
+static inline unsigned long hugetlb_total_pages(void)
+{
+        return 0;
+}
+
+#define follow_hugetlb_page(m,v,p,vs,a,b,i)     ({ BUG(); 0; })
+#define follow_huge_addr(mm, addr, write)       ERR_PTR(-EINVAL)
+#define copy_hugetlb_page_range(src, dst, vma)  ({ BUG(); 0; })
+#define hugetlb_prefault(mapping, vma)          ({ BUG(); 0; })
+#define zap_hugepage_range(vma, start, len)     BUG()
+#define unmap_hugepage_range(vma, start, end)   BUG()
+#define is_hugepage_mem_enough(size)            0
+#define hugetlb_report_meminfo(buf)             0
+#define hugetlb_report_node_meminfo(n, buf)     0
+#define follow_huge_pmd(mm, addr, pmd, write)   NULL
+#define is_aligned_hugepage_range(addr, len)    0
+#define prepare_hugepage_range(addr, len)       (-EINVAL)
+#define pmd_huge(x)     0
+#define is_hugepage_only_range(mm, addr, len)   0
+#define hugetlb_free_pgtables(tlb, prev, start, end) do { } while (0)
+#define alloc_huge_page()                       ({ NULL; })
+#define free_huge_page(p)                       ({ (void)(p); BUG(); })
+
+#ifndef HPAGE_MASK
+#define HPAGE_MASK      0               /* Keep the compiler happy */
+#define HPAGE_SIZE      0
+#endif
+
+#endif /* !CONFIG_HUGETLB_PAGE */
+
+#ifdef CONFIG_HUGETLBFS
+struct hugetlbfs_config {
+        uid_t   uid;
+        gid_t   gid;
+        umode_t mode;
+        long    nr_blocks;
+        long    nr_inodes;
+};
+
+struct hugetlbfs_sb_info {
+        long    max_blocks;   /* blocks allowed */
+        long    free_blocks;  /* blocks free */
+        long    max_inodes;   /* inodes allowed */
+        long    free_inodes;  /* inodes free */
+        spinlock_t      stat_lock;
+};
+
+
+struct hugetlbfs_inode_info {
+        struct shared_policy policy;
+        struct inode vfs_inode;
+};
+
+static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)
+{
+        return container_of(inode, struct hugetlbfs_inode_info, vfs_inode);
+}
+
+static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+extern struct file_operations hugetlbfs_file_operations;
+extern struct vm_operations_struct hugetlb_vm_ops;
+struct file *hugetlb_zero_setup(size_t);
+int hugetlb_get_quota(struct address_space *mapping);
+void hugetlb_put_quota(struct address_space *mapping);
+
+static inline int is_file_hugepages(struct file *file)
+{
+        return file->f_op == &hugetlbfs_file_operations;
+}
+
+static inline void set_file_hugepages(struct file *file)
+{
+        file->f_op = &hugetlbfs_file_operations;
+}
+#else /* !CONFIG_HUGETLBFS */
+
+#define is_file_hugepages(file)         0
+#define set_file_hugepages(file)        BUG()
+#define hugetlb_zero_setup(size)        ERR_PTR(-ENOSYS)
+
+#endif /* !CONFIG_HUGETLBFS */
+
+#endif /* _LINUX_HUGETLB_H */
diff --git a/include/linux/hysdn_if.h b/include/linux/hysdn_if.h
new file mode 100644
index 000000000000..00236ae3b04e
--- /dev/null
+++ b/include/linux/hysdn_if.h
@@ -0,0 +1,33 @@
+/* $Id: hysdn_if.h,v 1.1.8.3 2001/09/23 22:25:05 kai Exp $
+ *
+ * Linux driver for HYSDN cards
+ * ioctl definitions shared by hynetmgr and driver.
+ *
+ * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
+ * Copyright 1999 by Werner Cornelius (werner@titro.de)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+/****************/
+/* error values */
+/****************/
+#define ERR_NONE             0 /* no error occurred */
+#define ERR_ALREADY_BOOT  1000 /* we are already booting */
+#define EPOF_BAD_MAGIC    1001 /* bad magic in POF header */
+#define ERR_BOARD_DPRAM   1002 /* board DPRAM failed */
+#define EPOF_INTERNAL     1003 /* internal POF handler error */
+#define EPOF_BAD_IMG_SIZE 1004 /* POF boot image size invalid */
+#define ERR_BOOTIMG_FAIL  1005 /* 1. stage boot image did not start */
+#define ERR_BOOTSEQ_FAIL  1006 /* 2. stage boot seq handshake timeout */
+#define ERR_POF_TIMEOUT   1007 /* timeout waiting for card pof ready */
+#define ERR_NOT_BOOTED    1008 /* operation only allowed when booted */
+#define ERR_CONF_LONG     1009 /* conf line is too long */ 
+#define ERR_INV_CHAN      1010 /* invalid channel number */ 
+#define ERR_ASYNC_TIME    1011 /* timeout sending async data */ 
+
+
+
+
diff --git a/include/linux/i2c-algo-bit.h b/include/linux/i2c-algo-bit.h
new file mode 100644
index 000000000000..110904481238
--- /dev/null
+++ b/include/linux/i2c-algo-bit.h
@@ -0,0 +1,54 @@
+/* ------------------------------------------------------------------------- */
+/* i2c-algo-bit.h i2c driver algorithms for bit-shift adapters               */
+/* ------------------------------------------------------------------------- */
+/*   Copyright (C) 1995-99 Simon G. Vogl
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+/* ------------------------------------------------------------------------- */
+
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+   Frodo Looijaard <frodol@dds.nl> */
+
+/* $Id: i2c-algo-bit.h,v 1.10 2003/01/21 08:08:16 kmalkki Exp $ */
+
+#ifndef _LINUX_I2C_ALGO_BIT_H
+#define _LINUX_I2C_ALGO_BIT_H
+
+/* --- Defines for bit-adapters --------------------------------------- */
+/*
+ * This struct contains the hw-dependent functions of bit-style adapters to 
+ * manipulate the line states, and to init any hw-specific features. This is
+ * only used if you have more than one hw-type of adapter running. 
+ */
+struct i2c_algo_bit_data {
+        void *data;             /* private data for lowlevel routines */
+        void (*setsda) (void *data, int state);
+        void (*setscl) (void *data, int state);
+        int  (*getsda) (void *data);
+        int  (*getscl) (void *data);
+
+        /* local settings */
+        int udelay;             /* half-clock-cycle time in microsecs */
+                                /* i.e. clock is (500 / udelay) KHz */
+        int mdelay;             /* in millisecs, unused */
+        int timeout;            /* in jiffies */
+};
+
+#define I2C_BIT_ADAP_MAX        16
+
+int i2c_bit_add_bus(struct i2c_adapter *);
+int i2c_bit_del_bus(struct i2c_adapter *);
+
+#endif /* _LINUX_I2C_ALGO_BIT_H */
diff --git a/include/linux/i2c-algo-ite.h b/include/linux/i2c-algo-ite.h
new file mode 100644
index 000000000000..26a8b89855f1
--- /dev/null
+++ b/include/linux/i2c-algo-ite.h
@@ -0,0 +1,69 @@
+/* ------------------------------------------------------------------------- */
+/* i2c-algo-ite.h i2c driver algorithms for ITE IIC adapters                 */
+/* ------------------------------------------------------------------------- */
+/*   Copyright (C) 1995-97 Simon G. Vogl
+                   1998-99 Hans Berglund
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+/* ------------------------------------------------------------------------- */
+
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+   Frodo Looijaard <frodol@dds.nl> */
+
+/* Modifications by MontaVista Software, 2001
+   Changes made to support the ITE IIC peripheral */
+
+
+#ifndef I2C_ALGO_ITE_H
+#define I2C_ALGO_ITE_H 1
+
+#include <linux/i2c.h>
+
+/* Example of a sequential read request:
+        struct i2c_iic_msg s_msg; 
+
+        s_msg.addr=device_address;
+        s_msg.len=length;
+        s_msg.buf=buffer;
+        s_msg.waddr=word_address;
+        ioctl(file,I2C_SREAD, &s_msg);
+ */
+#define I2C_SREAD       0x780   /* SREAD ioctl command */
+
+struct i2c_iic_msg {
+        __u16 addr;     /* device address */
+        __u16 waddr;    /* word address */
+        short len;      /* msg length */
+        char *buf;      /* pointer to msg data */
+};
+
+struct i2c_algo_iic_data {
+        void *data;             /* private data for lolevel routines    */
+        void (*setiic) (void *data, int ctl, int val);
+        int  (*getiic) (void *data, int ctl);
+        int  (*getown) (void *data);
+        int  (*getclock) (void *data);
+        void (*waitforpin) (void);     
+
+        /* local settings */
+        int udelay;
+        int mdelay;
+        int timeout;
+};
+
+int i2c_iic_add_bus(struct i2c_adapter *);
+int i2c_iic_del_bus(struct i2c_adapter *);
+
+#endif /* I2C_ALGO_ITE_H */
diff --git a/include/linux/i2c-algo-pca.h b/include/linux/i2c-algo-pca.h
new file mode 100644
index 000000000000..941b786c5732
--- /dev/null
+++ b/include/linux/i2c-algo-pca.h
@@ -0,0 +1,17 @@
+#ifndef _LINUX_I2C_ALGO_PCA_H
+#define _LINUX_I2C_ALGO_PCA_H
+
+struct i2c_algo_pca_data {
+        int  (*get_own)                 (struct i2c_algo_pca_data *adap); /* Obtain own address */
+        int  (*get_clock)               (struct i2c_algo_pca_data *adap);
+        void (*write_byte)              (struct i2c_algo_pca_data *adap, int reg, int val);
+        int  (*read_byte)               (struct i2c_algo_pca_data *adap, int reg);
+        int  (*wait_for_interrupt)      (struct i2c_algo_pca_data *adap);
+};
+
+#define I2C_PCA_ADAP_MAX        16
+
+int i2c_pca_add_bus(struct i2c_adapter *);
+int i2c_pca_del_bus(struct i2c_adapter *);
+
+#endif /* _LINUX_I2C_ALGO_PCA_H */
diff --git a/include/linux/i2c-algo-pcf.h b/include/linux/i2c-algo-pcf.h
new file mode 100644
index 000000000000..2a508562255f
--- /dev/null
+++ b/include/linux/i2c-algo-pcf.h
@@ -0,0 +1,49 @@
+/* ------------------------------------------------------------------------- */
+/* adap-pcf.h i2c driver algorithms for PCF8584 adapters                     */
+/* ------------------------------------------------------------------------- */
+/*   Copyright (C) 1995-97 Simon G. Vogl
+                   1998-99 Hans Berglund
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+/* ------------------------------------------------------------------------- */
+
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+   Frodo Looijaard <frodol@dds.nl> */
+
+/* $Id: i2c-algo-pcf.h,v 1.8 2003/01/21 08:08:16 kmalkki Exp $ */
+
+#ifndef _LINUX_I2C_ALGO_PCF_H
+#define _LINUX_I2C_ALGO_PCF_H
+
+struct i2c_algo_pcf_data {
+        void *data;             /* private data for lolevel routines    */
+        void (*setpcf) (void *data, int ctl, int val);
+        int  (*getpcf) (void *data, int ctl);
+        int  (*getown) (void *data);
+        int  (*getclock) (void *data);
+        void (*waitforpin) (void);     
+
+        /* local settings */
+        int udelay;
+        int mdelay;
+        int timeout;
+};
+
+#define I2C_PCF_ADAP_MAX        16
+
+int i2c_pcf_add_bus(struct i2c_adapter *);
+int i2c_pcf_del_bus(struct i2c_adapter *);
+
+#endif /* _LINUX_I2C_ALGO_PCF_H */
diff --git a/include/linux/i2c-algo-sgi.h b/include/linux/i2c-algo-sgi.h
new file mode 100644
index 000000000000..4a0113d64064
--- /dev/null
+++ b/include/linux/i2c-algo-sgi.h
@@ -0,0 +1,27 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
+ */
+
+#ifndef I2C_ALGO_SGI_H
+#define I2C_ALGO_SGI_H 1
+
+#include <linux/i2c.h>
+
+struct i2c_algo_sgi_data {
+        void *data;     /* private data for lowlevel routines */
+        unsigned (*getctrl)(void *data);
+        void (*setctrl)(void *data, unsigned val);
+        unsigned (*rdata)(void *data);
+        void (*wdata)(void *data, unsigned val);
+
+        int xfer_timeout;
+        int ack_timeout;
+};
+
+int i2c_sgi_add_bus(struct i2c_adapter *);
+int i2c_sgi_del_bus(struct i2c_adapter *);
+
+#endif /* I2C_ALGO_SGI_H */
diff --git a/include/linux/i2c-algo-sibyte.h b/include/linux/i2c-algo-sibyte.h
new file mode 100644
index 000000000000..03914ded8614
--- /dev/null
+++ b/include/linux/i2c-algo-sibyte.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2001,2002,2003 Broadcom Corporation
+ *
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef I2C_ALGO_SIBYTE_H
+#define I2C_ALGO_SIBYTE_H 1
+
+#include <linux/i2c.h>
+
+struct i2c_algo_sibyte_data {
+        void *data;             /* private data */
+        int   bus;              /* which bus */
+        void *reg_base;         /* CSR base */
+};
+
+int i2c_sibyte_add_bus(struct i2c_adapter *, int speed);
+int i2c_sibyte_del_bus(struct i2c_adapter *);
+
+#endif /* I2C_ALGO_SIBYTE_H */
diff --git a/include/linux/i2c-dev.h b/include/linux/i2c-dev.h
new file mode 100644
index 000000000000..d228230ffe5d
--- /dev/null
+++ b/include/linux/i2c-dev.h
@@ -0,0 +1,48 @@
+/*
+    i2c-dev.h - i2c-bus driver, char device interface
+
+    Copyright (C) 1995-97 Simon G. Vogl
+    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* $Id: i2c-dev.h,v 1.13 2003/01/21 08:08:16 kmalkki Exp $ */
+
+#ifndef _LINUX_I2C_DEV_H
+#define _LINUX_I2C_DEV_H
+
+#include <linux/types.h>
+
+/* Some IOCTL commands are defined in <linux/i2c.h> */
+/* Note: 10-bit addresses are NOT supported! */
+
+/* This is the structure as used in the I2C_SMBUS ioctl call */
+struct i2c_smbus_ioctl_data {
+        __u8 read_write;
+        __u8 command;
+        __u32 size;
+        union i2c_smbus_data __user *data;
+};
+
+/* This is the structure as used in the I2C_RDWR ioctl call */
+struct i2c_rdwr_ioctl_data {
+        struct i2c_msg __user *msgs;    /* pointers to i2c_msgs */
+        __u32 nmsgs;                    /* number of i2c_msgs */
+};
+
+#define  I2C_RDRW_IOCTL_MAX_MSGS        42
+
+#endif /* _LINUX_I2C_DEV_H */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
new file mode 100644
index 000000000000..89270ce51470
--- /dev/null
+++ b/include/linux/i2c-id.h
@@ -0,0 +1,319 @@
+/* ------------------------------------------------------------------------- */
+/*                                                                           */
+/* i2c.h - definitions for the i2c-bus interface                             */
+/*                                                                           */
+/* ------------------------------------------------------------------------- */
+/*   Copyright (C) 1995-1999 Simon G. Vogl
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+/* ------------------------------------------------------------------------- */
+
+#ifndef LINUX_I2C_ID_H
+#define LINUX_I2C_ID_H
+
+/*
+ * This file is part of the i2c-bus package and contains the identifier
+ * values for drivers, adapters and other folk populating these serial
+ * worlds. 
+ *
+ * These will change often (i.e. additions) , therefore this has been 
+ * separated from the functional interface definitions of the i2c api.
+ *
+ */
+
+/*
+ * ---- Driver types -----------------------------------------------------
+ *       device id name + number        function description, i2c address(es)
+ *
+ *  Range 1000-1999 range is defined in sensors/sensors.h 
+ *  Range 0x100 - 0x1ff is for V4L2 Common Components 
+ *  Range 0xf000 - 0xffff is reserved for local experimentation, and should
+ *        never be used in official drivers 
+ */
+
+#define I2C_DRIVERID_MSP3400     1
+#define I2C_DRIVERID_TUNER       2
+#define I2C_DRIVERID_VIDEOTEX    3      /* please rename                */
+#define I2C_DRIVERID_TDA8425     4      /* stereo sound processor       */
+#define I2C_DRIVERID_TEA6420     5      /* audio matrix switch          */
+#define I2C_DRIVERID_TEA6415C    6      /* video matrix switch          */
+#define I2C_DRIVERID_TDA9840     7      /* stereo sound processor       */
+#define I2C_DRIVERID_SAA7111A    8      /* video input processor        */
+#define I2C_DRIVERID_SAA5281     9      /* videotext decoder            */
+#define I2C_DRIVERID_SAA7112    10      /* video decoder, image scaler  */
+#define I2C_DRIVERID_SAA7120    11      /* video encoder                */
+#define I2C_DRIVERID_SAA7121    12      /* video encoder                */
+#define I2C_DRIVERID_SAA7185B   13      /* video encoder                */
+#define I2C_DRIVERID_CH7003     14      /* digital pc to tv encoder     */
+#define I2C_DRIVERID_PCF8574A   15      /* i2c expander - 8 bit in/out  */
+#define I2C_DRIVERID_PCF8582C   16      /* eeprom                       */
+#define I2C_DRIVERID_AT24Cxx    17      /* eeprom 1/2/4/8/16 K          */
+#define I2C_DRIVERID_TEA6300    18      /* audio mixer                  */
+#define I2C_DRIVERID_BT829      19      /* pc to tv encoder             */
+#define I2C_DRIVERID_TDA9850    20      /* audio mixer                  */
+#define I2C_DRIVERID_TDA9855    21      /* audio mixer                  */
+#define I2C_DRIVERID_SAA7110    22      /* video decoder                */
+#define I2C_DRIVERID_MGATVO     23      /* Matrox TVOut                 */
+#define I2C_DRIVERID_SAA5249    24      /* SAA5249 and compatibles      */
+#define I2C_DRIVERID_PCF8583    25      /* real time clock              */
+#define I2C_DRIVERID_SAB3036    26      /* SAB3036 tuner                */
+#define I2C_DRIVERID_TDA7432    27      /* Stereo sound processor       */
+#define I2C_DRIVERID_TVMIXER    28      /* Mixer driver for tv cards    */
+#define I2C_DRIVERID_TVAUDIO    29      /* Generic TV sound driver      */
+#define I2C_DRIVERID_DPL3518    30      /* Dolby decoder chip           */
+#define I2C_DRIVERID_TDA9873    31      /* TV sound decoder chip        */
+#define I2C_DRIVERID_TDA9875    32      /* TV sound decoder chip        */
+#define I2C_DRIVERID_PIC16C54_PV9 33    /* Audio mux/ir receiver        */
+
+#define I2C_DRIVERID_SBATT      34     /* Smart Battery Device          */
+#define I2C_DRIVERID_SBS        35     /* SB System Manager             */
+#define I2C_DRIVERID_VES1893    36     /* VLSI DVB-S decoder            */
+#define I2C_DRIVERID_VES1820    37     /* VLSI DVB-C decoder            */
+#define I2C_DRIVERID_SAA7113    38     /* video decoder                 */
+#define I2C_DRIVERID_TDA8444    39     /* octuple 6-bit DAC             */
+#define I2C_DRIVERID_BT819      40     /* video decoder                 */
+#define I2C_DRIVERID_BT856      41     /* video encoder                 */
+#define I2C_DRIVERID_VPX3220    42     /* video decoder+vbi/vtxt        */
+#define I2C_DRIVERID_DRP3510    43     /* ADR decoder (Astra Radio)     */
+#define I2C_DRIVERID_SP5055     44     /* Satellite tuner               */
+#define I2C_DRIVERID_STV0030    45     /* Multipurpose switch           */
+#define I2C_DRIVERID_SAA7108    46     /* video decoder, image scaler   */
+#define I2C_DRIVERID_DS1307     47     /* DS1307 real time clock        */
+#define I2C_DRIVERID_ADV7175    48     /* ADV 7175/7176 video encoder   */
+#define I2C_DRIVERID_SAA7114    49      /* video decoder                */
+#define I2C_DRIVERID_ZR36120    50     /* Zoran 36120 video encoder     */
+#define I2C_DRIVERID_24LC32A    51      /* Microchip 24LC32A 32k EEPROM */
+#define I2C_DRIVERID_STM41T00   52      /* real time clock              */
+#define I2C_DRIVERID_UDA1342    53      /* UDA1342 audio codec          */
+#define I2C_DRIVERID_ADV7170    54      /* video encoder                */
+#define I2C_DRIVERID_RADEON     55      /* I2C bus on Radeon boards     */
+#define I2C_DRIVERID_MAX1617    56      /* temp sensor                  */
+#define I2C_DRIVERID_SAA7191    57      /* video encoder                */
+#define I2C_DRIVERID_INDYCAM    58      /* SGI IndyCam                  */
+#define I2C_DRIVERID_BT832      59      /* CMOS camera video processor  */
+#define I2C_DRIVERID_TDA9887    60      /* TDA988x IF-PLL demodulator   */
+#define I2C_DRIVERID_OVCAMCHIP  61      /* OmniVision CMOS image sens.  */
+#define I2C_DRIVERID_TDA7313    62      /* TDA7313 audio processor      */
+#define I2C_DRIVERID_MAX6900    63      /* MAX6900 real-time clock      */
+#define I2C_DRIVERID_SAA7114H   64      /* video decoder                */
+
+
+#define I2C_DRIVERID_EXP0       0xF0    /* experimental use id's        */
+#define I2C_DRIVERID_EXP1       0xF1
+#define I2C_DRIVERID_EXP2       0xF2
+#define I2C_DRIVERID_EXP3       0xF3
+
+#define I2C_DRIVERID_I2CDEV     900
+#define I2C_DRIVERID_I2CPROC    901
+#define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
+#define I2C_DRIVERID_ALERT      903    /* SMBus Alert Responder Client  */
+
+/* IDs --   Use DRIVERIDs 1000-1999 for sensors. 
+   These were originally in sensors.h in the lm_sensors package */
+#define I2C_DRIVERID_LM78 1002
+#define I2C_DRIVERID_LM75 1003
+#define I2C_DRIVERID_GL518 1004
+#define I2C_DRIVERID_EEPROM 1005
+#define I2C_DRIVERID_W83781D 1006
+#define I2C_DRIVERID_LM80 1007
+#define I2C_DRIVERID_ADM1021 1008
+#define I2C_DRIVERID_ADM9240 1009
+#define I2C_DRIVERID_LTC1710 1010
+#define I2C_DRIVERID_SIS5595 1011
+#define I2C_DRIVERID_ICSPLL 1012
+#define I2C_DRIVERID_BT869 1013
+#define I2C_DRIVERID_MAXILIFE 1014
+#define I2C_DRIVERID_MATORB 1015
+#define I2C_DRIVERID_GL520 1016
+#define I2C_DRIVERID_THMC50 1017
+#define I2C_DRIVERID_DDCMON 1018
+#define I2C_DRIVERID_VIA686A 1019
+#define I2C_DRIVERID_ADM1025 1020
+#define I2C_DRIVERID_LM87 1021
+#define I2C_DRIVERID_PCF8574 1022
+#define I2C_DRIVERID_MTP008 1023
+#define I2C_DRIVERID_DS1621 1024
+#define I2C_DRIVERID_ADM1024 1025
+#define I2C_DRIVERID_IT87 1026
+#define I2C_DRIVERID_CH700X 1027 /* single driver for CH7003-7009 digital pc to tv encoders */
+#define I2C_DRIVERID_FSCPOS 1028
+#define I2C_DRIVERID_FSCSCY 1029
+#define I2C_DRIVERID_PCF8591 1030
+#define I2C_DRIVERID_SMSC47M1 1031
+#define I2C_DRIVERID_VT1211 1032
+#define I2C_DRIVERID_LM92 1033
+#define I2C_DRIVERID_VT8231 1034
+#define I2C_DRIVERID_SMARTBATT 1035
+#define I2C_DRIVERID_BMCSENSORS 1036
+#define I2C_DRIVERID_FS451 1037
+#define I2C_DRIVERID_W83627HF 1038
+#define I2C_DRIVERID_LM85 1039
+#define I2C_DRIVERID_LM83 1040
+#define I2C_DRIVERID_LM90 1042
+#define I2C_DRIVERID_ASB100 1043
+#define I2C_DRIVERID_FSCHER 1046
+#define I2C_DRIVERID_W83L785TS 1047
+#define I2C_DRIVERID_SMSC47B397 1050
+
+/*
+ * ---- Adapter types ----------------------------------------------------
+ *
+ * First, we distinguish between several algorithms to access the hardware
+ * interface types, as a PCF 8584 needs other care than a bit adapter.
+ */
+
+#define I2C_ALGO_NONE   0x000000
+#define I2C_ALGO_BIT    0x010000        /* bit style adapters           */
+#define I2C_ALGO_PCF    0x020000        /* PCF 8584 style adapters      */
+#define I2C_ALGO_ATI    0x030000        /* ATI video card               */
+#define I2C_ALGO_SMBUS  0x040000
+#define I2C_ALGO_ISA    0x050000        /* lm_sensors ISA pseudo-adapter */
+#define I2C_ALGO_SAA7146 0x060000       /* SAA 7146 video decoder bus   */
+#define I2C_ALGO_ACB    0x070000        /* ACCESS.bus algorithm         */
+#define I2C_ALGO_IIC    0x080000        /* ITE IIC bus */
+#define I2C_ALGO_SAA7134 0x090000
+#define I2C_ALGO_MPC824X 0x0a0000       /* Motorola 8240 / 8245         */
+#define I2C_ALGO_IPMI   0x0b0000        /* IPMI dummy adapter */
+#define I2C_ALGO_IPMB   0x0c0000        /* IPMB adapter */
+#define I2C_ALGO_MPC107 0x0d0000
+#define I2C_ALGO_EC     0x100000        /* ACPI embedded controller     */
+
+#define I2C_ALGO_MPC8XX 0x110000        /* MPC8xx PowerPC I2C algorithm */
+#define I2C_ALGO_OCP    0x120000        /* IBM or otherwise On-chip I2C algorithm */
+#define I2C_ALGO_BITHS  0x130000        /* enhanced bit style adapters  */
+#define I2C_ALGO_IOP3XX 0x140000        /* XSCALE IOP3XX On-chip I2C alg */
+#define I2C_ALGO_SIBYTE 0x150000        /* Broadcom SiByte SOCs         */
+#define I2C_ALGO_SGI    0x160000        /* SGI algorithm                */
+
+#define I2C_ALGO_USB    0x170000        /* USB algorithm                */
+#define I2C_ALGO_VIRT   0x180000        /* Virtual bus adapter          */
+
+#define I2C_ALGO_MV64XXX 0x190000       /* Marvell mv64xxx i2c ctlr     */
+#define I2C_ALGO_PCA    0x1a0000        /* PCA 9564 style adapters      */
+#define I2C_ALGO_AU1550 0x1b0000        /* Au1550 PSC algorithm         */
+
+#define I2C_ALGO_EXP    0x800000        /* experimental                 */
+
+#define I2C_ALGO_MASK   0xff0000        /* Mask for algorithms          */
+#define I2C_ALGO_SHIFT  0x10    /* right shift to get index values      */
+
+#define I2C_HW_ADAPS    0x10000         /* # adapter types              */
+#define I2C_HW_MASK     0xffff          
+
+
+/* hw specific modules that are defined per algorithm layer
+ */
+
+/* --- Bit algorithm adapters                                           */
+#define I2C_HW_B_LP     0x00    /* Parallel port Philips style adapter  */
+#define I2C_HW_B_LPC    0x01    /* Parallel port, over control reg.     */
+#define I2C_HW_B_SER    0x02    /* Serial line interface                */
+#define I2C_HW_B_ELV    0x03    /* ELV Card                             */
+#define I2C_HW_B_VELLE  0x04    /* Vellemann K8000                      */
+#define I2C_HW_B_BT848  0x05    /* BT848 video boards                   */
+#define I2C_HW_B_WNV    0x06    /* Winnov Videums                       */
+#define I2C_HW_B_VIA    0x07    /* Via vt82c586b                        */
+#define I2C_HW_B_HYDRA  0x08    /* Apple Hydra Mac I/O                  */
+#define I2C_HW_B_G400   0x09    /* Matrox G400                          */
+#define I2C_HW_B_I810   0x0a    /* Intel I810                           */
+#define I2C_HW_B_VOO    0x0b    /* 3dfx Voodoo 3 / Banshee              */
+#define I2C_HW_B_PPORT  0x0c    /* Primitive parallel port adapter      */
+#define I2C_HW_B_SAVG   0x0d    /* Savage 4                             */
+#define I2C_HW_B_SCX200 0x0e    /* Nat'l Semi SCx200 I2C                */
+#define I2C_HW_B_RIVA   0x10    /* Riva based graphics cards            */
+#define I2C_HW_B_IOC    0x11    /* IOC bit-wiggling                     */
+#define I2C_HW_B_TSUNA  0x12    /* DEC Tsunami chipset                  */
+#define I2C_HW_B_FRODO  0x13    /* 2d3D, Inc. SA-1110 Development Board */
+#define I2C_HW_B_OMAHA  0x14    /* Omaha I2C interface (ARM)            */
+#define I2C_HW_B_GUIDE  0x15    /* Guide bit-basher                     */
+#define I2C_HW_B_IXP2000 0x16   /* GPIO on IXP2000 systems              */
+#define I2C_HW_B_IXP4XX 0x17    /* GPIO on IXP4XX systems               */
+#define I2C_HW_B_S3VIA  0x18    /* S3Via ProSavage adapter              */
+#define I2C_HW_B_ZR36067 0x19   /* Zoran-36057/36067 based boards       */
+#define I2C_HW_B_PCILYNX 0x1a   /* TI PCILynx I2C adapter               */
+#define I2C_HW_B_CX2388x 0x1b   /* connexant 2388x based tv cards       */
+
+/* --- PCF 8584 based algorithms                                        */
+#define I2C_HW_P_LP     0x00    /* Parallel port interface              */
+#define I2C_HW_P_ISA    0x01    /* generic ISA Bus inteface card        */
+#define I2C_HW_P_ELEK   0x02    /* Elektor ISA Bus inteface card        */
+
+/* --- PCA 9564 based algorithms */
+#define I2C_HW_A_ISA    0x00    /* generic ISA Bus interface card       */
+
+/* --- ACPI Embedded controller algorithms                              */
+#define I2C_HW_ACPI_EC          0x00
+
+/* --- MPC824x PowerPC adapters                                         */
+#define I2C_HW_MPC824X 0x00     /* Motorola 8240 / 8245                 */
+
+/* --- MPC8xx PowerPC adapters                                          */
+#define I2C_HW_MPC8XX_EPON 0x00 /* Eponymous MPC8xx I2C adapter         */
+
+/* --- ITE based algorithms                                             */
+#define I2C_HW_I_IIC    0x00    /* controller on the ITE */
+
+/* --- PowerPC on-chip adapters                                         */
+#define I2C_HW_OCP 0x00 /* IBM on-chip I2C adapter      */
+
+/* --- Broadcom SiByte adapters                                         */
+#define I2C_HW_SIBYTE   0x00
+
+/* --- SGI adapters                                                     */
+#define I2C_HW_SGI_VINO 0x00
+#define I2C_HW_SGI_MACE 0x01
+
+/* --- XSCALE on-chip adapters                          */
+#define I2C_HW_IOP3XX 0x00
+
+/* --- Au1550 PSC adapters adapters                                     */
+#define I2C_HW_AU1550_PSC       0x00
+
+/* --- SMBus only adapters                                              */
+#define I2C_HW_SMBUS_PIIX4      0x00
+#define I2C_HW_SMBUS_ALI15X3    0x01
+#define I2C_HW_SMBUS_VIA2       0x02
+#define I2C_HW_SMBUS_VOODOO3    0x03
+#define I2C_HW_SMBUS_I801       0x04
+#define I2C_HW_SMBUS_AMD756     0x05
+#define I2C_HW_SMBUS_SIS5595    0x06
+#define I2C_HW_SMBUS_ALI1535    0x07
+#define I2C_HW_SMBUS_SIS630     0x08
+#define I2C_HW_SMBUS_SIS96X     0x09
+#define I2C_HW_SMBUS_AMD8111    0x0a
+#define I2C_HW_SMBUS_SCX200     0x0b
+#define I2C_HW_SMBUS_NFORCE2    0x0c
+#define I2C_HW_SMBUS_W9968CF    0x0d
+#define I2C_HW_SMBUS_OV511      0x0e    /* OV511(+) USB 1.1 webcam ICs  */
+#define I2C_HW_SMBUS_OV518      0x0f    /* OV518(+) USB 1.1 webcam ICs  */
+#define I2C_HW_SMBUS_OV519      0x10    /* OV519 USB 1.1 webcam IC      */
+#define I2C_HW_SMBUS_OVFX2      0x11    /* Cypress/OmniVision FX2 webcam */
+
+/* --- ISA pseudo-adapter                                               */
+#define I2C_HW_ISA 0x00
+
+/* --- IPMI pseudo-adapter                                              */
+#define I2C_HW_IPMI 0x00
+
+/* --- IPMB adapter                                             */
+#define I2C_HW_IPMB 0x00
+
+/* --- MCP107 adapter */
+#define I2C_HW_MPC107 0x00
+
+/* --- Marvell mv64xxx i2c adapter */
+#define I2C_HW_MV64XXX 0x00
+
+#endif /* LINUX_I2C_ID_H */
diff --git a/include/linux/i2c-sensor.h b/include/linux/i2c-sensor.h
new file mode 100644
index 000000000000..21b625204956
--- /dev/null
+++ b/include/linux/i2c-sensor.h
@@ -0,0 +1,263 @@
+/*
+    i2c-sensor.h - Part of the i2c package
+    was originally sensors.h - Part of lm_sensors, Linux kernel modules
+                               for hardware monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef _LINUX_I2C_SENSOR_H
+#define _LINUX_I2C_SENSOR_H
+
+/* A structure containing detect information.
+   Force variables overrule all other variables; they force a detection on
+   that place. If a specific chip is given, the module blindly assumes this
+   chip type is present; if a general force (kind == 0) is given, the module
+   will still try to figure out what type of chip is present. This is useful
+   if for some reasons the detect for SMBus or ISA address space filled
+   fails.
+   probe: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
+     A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
+     the ISA bus, -1 for any I2C bus), the second is the address. 
+   kind: The kind of chip. 0 equals any chip.
+*/
+struct i2c_force_data {
+        unsigned short *force;
+        unsigned short kind;
+};
+
+/* A structure containing the detect information.
+   normal_i2c: filled in by the module writer. Terminated by I2C_CLIENT_ISA_END.
+     A list of I2C addresses which should normally be examined.
+   normal_isa: filled in by the module writer. Terminated by SENSORS_ISA_END.
+     A list of ISA addresses which should normally be examined.
+   probe: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
+     A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
+     the ISA bus, -1 for any I2C bus), the second is the address. These
+     addresses are also probed, as if they were in the 'normal' list.
+   ignore: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
+     A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
+     the ISA bus, -1 for any I2C bus), the second is the I2C address. These
+     addresses are never probed. This parameter overrules 'normal' and 
+     'probe', but not the 'force' lists.
+   force_data: insmod parameters. A list, ending with an element of which
+     the force field is NULL.
+*/
+struct i2c_address_data {
+        unsigned short *normal_i2c;
+        unsigned int *normal_isa;
+        unsigned short *probe;
+        unsigned short *ignore;
+        struct i2c_force_data *forces;
+};
+
+#define SENSORS_MODULE_PARM_FORCE(name) \
+  I2C_CLIENT_MODULE_PARM(force_ ## name, \
+                      "List of adapter,address pairs which are unquestionably" \
+                      " assumed to contain a `" # name "' chip")
+
+
+/* This defines several insmod variables, and the addr_data structure */
+#define SENSORS_INSMOD \
+  I2C_CLIENT_MODULE_PARM(probe, \
+                      "List of adapter,address pairs to scan additionally"); \
+  I2C_CLIENT_MODULE_PARM(ignore, \
+                      "List of adapter,address pairs not to scan"); \
+        static struct i2c_address_data addr_data = {                    \
+                        .normal_i2c =           normal_i2c,             \
+                        .normal_isa =           normal_isa,             \
+                        .probe =                probe,                  \
+                        .ignore =               ignore,                 \
+                        .forces =               forces,                 \
+                }
+
+/* The following functions create an enum with the chip names as elements. 
+   The first element of the enum is any_chip. These are the only macros
+   a module will want to use. */
+
+#define SENSORS_INSMOD_0 \
+  enum chips { any_chip }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  static struct i2c_force_data forces[] = {{force,any_chip},{NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_1(chip1) \
+  enum chips { any_chip, chip1 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  static struct i2c_force_data forces[] = {{force,any_chip},\
+                                                 {force_ ## chip1,chip1}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_2(chip1,chip2) \
+  enum chips { any_chip, chip1, chip2 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_3(chip1,chip2,chip3) \
+  enum chips { any_chip, chip1, chip2, chip3 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_4(chip1,chip2,chip3,chip4) \
+  enum chips { any_chip, chip1, chip2, chip3, chip4 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  SENSORS_MODULE_PARM_FORCE(chip4); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {force_ ## chip4,chip4}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_5(chip1,chip2,chip3,chip4,chip5) \
+  enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  SENSORS_MODULE_PARM_FORCE(chip4); \
+  SENSORS_MODULE_PARM_FORCE(chip5); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {force_ ## chip4,chip4}, \
+                                                 {force_ ## chip5,chip5}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_6(chip1,chip2,chip3,chip4,chip5,chip6) \
+  enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  SENSORS_MODULE_PARM_FORCE(chip4); \
+  SENSORS_MODULE_PARM_FORCE(chip5); \
+  SENSORS_MODULE_PARM_FORCE(chip6); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {force_ ## chip4,chip4}, \
+                                                 {force_ ## chip5,chip5}, \
+                                                 {force_ ## chip6,chip6}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_7(chip1,chip2,chip3,chip4,chip5,chip6,chip7) \
+  enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, chip7 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  SENSORS_MODULE_PARM_FORCE(chip4); \
+  SENSORS_MODULE_PARM_FORCE(chip5); \
+  SENSORS_MODULE_PARM_FORCE(chip6); \
+  SENSORS_MODULE_PARM_FORCE(chip7); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {force_ ## chip4,chip4}, \
+                                                 {force_ ## chip5,chip5}, \
+                                                 {force_ ## chip6,chip6}, \
+                                                 {force_ ## chip7,chip7}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+#define SENSORS_INSMOD_8(chip1,chip2,chip3,chip4,chip5,chip6,chip7,chip8) \
+  enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8 }; \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+  SENSORS_MODULE_PARM_FORCE(chip1); \
+  SENSORS_MODULE_PARM_FORCE(chip2); \
+  SENSORS_MODULE_PARM_FORCE(chip3); \
+  SENSORS_MODULE_PARM_FORCE(chip4); \
+  SENSORS_MODULE_PARM_FORCE(chip5); \
+  SENSORS_MODULE_PARM_FORCE(chip6); \
+  SENSORS_MODULE_PARM_FORCE(chip7); \
+  SENSORS_MODULE_PARM_FORCE(chip8); \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
+                                                 {force_ ## chip1,chip1}, \
+                                                 {force_ ## chip2,chip2}, \
+                                                 {force_ ## chip3,chip3}, \
+                                                 {force_ ## chip4,chip4}, \
+                                                 {force_ ## chip5,chip5}, \
+                                                 {force_ ## chip6,chip6}, \
+                                                 {force_ ## chip7,chip7}, \
+                                                 {force_ ## chip8,chip8}, \
+                                                 {NULL}}; \
+  SENSORS_INSMOD
+
+/* Detect function. It iterates over all possible addresses itself. For
+   SMBus addresses, it will only call found_proc if some client is connected
+   to the SMBus (unless a 'force' matched); for ISA detections, this is not
+   done. */
+extern int i2c_detect(struct i2c_adapter *adapter,
+                      struct i2c_address_data *address_data,
+                      int (*found_proc) (struct i2c_adapter *, int, int));
+
+
+/* This macro is used to scale user-input to sensible values in almost all
+   chip drivers. */
+static inline int SENSORS_LIMIT(long value, long low, long high)
+{
+        if (value < low)
+                return low;
+        else if (value > high)
+                return high;
+        else
+                return value;
+}
+#endif                          /* def _LINUX_I2C_SENSOR_H */
diff --git a/include/linux/i2c-vid.h b/include/linux/i2c-vid.h
new file mode 100644
index 000000000000..974835e3530f
--- /dev/null
+++ b/include/linux/i2c-vid.h
@@ -0,0 +1,99 @@
+/*
+    i2c-vid.h - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+    With assistance from Trent Piepho <xyzzy@speakeasy.org>
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This file contains common code for decoding VID pins.
+    This file is #included in various chip drivers in this directory.
+    As the user is unlikely to load more than one driver which
+    includes this code we don't worry about the wasted space.
+    Reference: VRM x.y DC-DC Converter Design Guidelines,
+    available at http://developer.intel.com
+*/
+
+/*
+    AMD Opteron processors don't follow the Intel VRM spec.
+    I'm going to "make up" 2.4 as the VRM spec for the Opterons.
+    No good reason just a mnemonic for the 24x Opteron processor
+    series
+
+    Opteron VID encoding is:
+
+       00000  =  1.550 V
+       00001  =  1.525 V
+        . . . .
+       11110  =  0.800 V
+       11111  =  0.000 V (off)
+ */
+
+/*
+    Legal val values 0x00 - 0x1f; except for VRD 10.0, 0x00 - 0x3f.
+    vrm is the Intel VRM document version.
+    Note: vrm version is scaled by 10 and the return value is scaled by 1000
+    to avoid floating point in the kernel.
+*/
+
+int i2c_which_vrm(void);
+
+#define DEFAULT_VRM     82
+
+static inline int vid_from_reg(int val, int vrm)
+{
+        int vid;
+
+        switch(vrm) {
+
+        case  0:
+                return 0;
+
+        case 100:               /* VRD 10.0 */
+                if((val & 0x1f) == 0x1f)
+                        return 0;
+                if((val & 0x1f) <= 0x09 || val == 0x0a)
+                        vid = 10875 - (val & 0x1f) * 250;
+                else
+                        vid = 18625 - (val & 0x1f) * 250;
+                if(val & 0x20)
+                        vid -= 125;
+                vid /= 10;      /* only return 3 dec. places for now */
+                return vid;
+
+        case 24:                /* Opteron processor */
+                return(val == 0x1f ? 0 : 1550 - val * 25);
+
+        case 91:                /* VRM 9.1 */
+        case 90:                /* VRM 9.0 */
+                return(val == 0x1f ? 0 :
+                                       1850 - val * 25);
+
+        case 85:                /* VRM 8.5 */
+                return((val & 0x10  ? 25 : 0) +
+                       ((val & 0x0f) > 0x04 ? 2050 : 1250) -
+                       ((val & 0x0f) * 50));
+
+        case 84:                /* VRM 8.4 */
+                val &= 0x0f;
+                                /* fall through */
+        default:                /* VRM 8.2 */
+                return(val == 0x1f ? 0 :
+                       val & 0x10  ? 5100 - (val) * 100 :
+                                     2050 - (val) * 50);
+        }
+}
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
new file mode 100644
index 000000000000..ebcd745f4cd6
--- /dev/null
+++ b/include/linux/i2c.h
@@ -0,0 +1,594 @@
+/* ------------------------------------------------------------------------- */
+/*                                                                           */
+/* i2c.h - definitions for the i2c-bus interface                             */
+/*                                                                           */
+/* ------------------------------------------------------------------------- */
+/*   Copyright (C) 1995-2000 Simon G. Vogl
+
+    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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+/* ------------------------------------------------------------------------- */
+
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
+   Frodo Looijaard <frodol@dds.nl> */
+
+/* $Id: i2c.h,v 1.68 2003/01/21 08:08:16 kmalkki Exp $ */
+
+#ifndef _LINUX_I2C_H
+#define _LINUX_I2C_H
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/i2c-id.h>
+#include <linux/device.h>       /* for struct device */
+#include <asm/semaphore.h>
+
+/* --- General options ------------------------------------------------ */
+
+struct i2c_msg;
+struct i2c_algorithm;
+struct i2c_adapter;
+struct i2c_client;
+struct i2c_driver;
+struct i2c_client_address_data;
+union i2c_smbus_data;
+
+/*
+ * The master routines are the ones normally used to transmit data to devices
+ * on a bus (or read from them). Apart from two basic transfer functions to 
+ * transmit one message at a time, a more complex version can be used to 
+ * transmit an arbitrary number of messages without interruption.
+ */
+extern int i2c_master_send(struct i2c_client *,const char* ,int);
+extern int i2c_master_recv(struct i2c_client *,char* ,int);
+
+/* Transfer num messages.
+ */
+extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
+
+/*
+ * Some adapter types (i.e. PCF 8584 based ones) may support slave behaviuor. 
+ * This is not tested/implemented yet and will change in the future.
+ */
+extern int i2c_slave_send(struct i2c_client *,char*,int);
+extern int i2c_slave_recv(struct i2c_client *,char*,int);
+
+
+
+/* This is the very generalized SMBus access routine. You probably do not
+   want to use this, though; one of the functions below may be much easier,
+   and probably just as fast. 
+   Note that we use i2c_adapter here, because you do not need a specific
+   smbus adapter to call this function. */
+extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr, 
+                           unsigned short flags,
+                           char read_write, u8 command, int size,
+                           union i2c_smbus_data * data);
+
+/* Now follow the 'nice' access routines. These also document the calling
+   conventions of smbus_access. */
+
+extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
+extern s32 i2c_smbus_read_byte(struct i2c_client * client);
+extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
+extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
+extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
+                                     u8 command, u8 value);
+extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
+extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
+                                     u8 command, u16 value);
+/* Returns the number of bytes transferred */
+extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
+                                      u8 command, u8 length,
+                                      u8 *values);
+extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
+                                         u8 command, u8 *values);
+
+/*
+ * A driver is capable of handling one or more physical devices present on
+ * I2C adapters. This information is used to inform the driver of adapter
+ * events.
+ */
+
+struct i2c_driver {
+        struct module *owner;
+        char name[32];
+        int id;
+        unsigned int class;
+        unsigned int flags;             /* div., see below              */
+
+        /* Notifies the driver that a new bus has appeared. This routine
+         * can be used by the driver to test if the bus meets its conditions
+         * & seek for the presence of the chip(s) it supports. If found, it 
+         * registers the client(s) that are on the bus to the i2c admin. via
+         * i2c_attach_client.
+         */
+        int (*attach_adapter)(struct i2c_adapter *);
+        int (*detach_adapter)(struct i2c_adapter *);
+
+        /* tells the driver that a client is about to be deleted & gives it 
+         * the chance to remove its private data. Also, if the client struct
+         * has been dynamically allocated by the driver in the function above,
+         * it must be freed here.
+         */
+        int (*detach_client)(struct i2c_client *);
+        
+        /* a ioctl like command that can be used to perform specific functions
+         * with the device.
+         */
+        int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
+
+        struct device_driver driver;
+        struct list_head list;
+};
+#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
+
+#define I2C_NAME_SIZE   50
+
+/*
+ * i2c_client identifies a single device (i.e. chip) that is connected to an 
+ * i2c bus. The behaviour is defined by the routines of the driver. This
+ * function is mainly used for lookup & other admin. functions.
+ */
+struct i2c_client {
+        unsigned int flags;             /* div., see below              */
+        unsigned int addr;              /* chip address - NOTE: 7bit    */
+                                        /* addresses are stored in the  */
+                                        /* _LOWER_ 7 bits of this char  */
+        /* addr: unsigned int to make lm_sensors i2c-isa adapter work
+          more cleanly. It does not take any more memory space, due to
+          alignment considerations */
+        struct i2c_adapter *adapter;    /* the adapter we sit on        */
+        struct i2c_driver *driver;      /* and our access routines      */
+        int usage_count;                /* How many accesses currently  */
+                                        /* to the client                */
+        struct device dev;              /* the device structure         */
+        struct list_head list;
+        char name[I2C_NAME_SIZE];
+        struct completion released;
+};
+#define to_i2c_client(d) container_of(d, struct i2c_client, dev)
+
+static inline void *i2c_get_clientdata (struct i2c_client *dev)
+{
+        return dev_get_drvdata (&dev->dev);
+}
+
+static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
+{
+        dev_set_drvdata (&dev->dev, data);
+}
+
+#define I2C_DEVNAME(str)        .name = str
+
+static inline char *i2c_clientname(struct i2c_client *c)
+{
+        return &c->name[0];
+}
+
+/*
+ * The following structs are for those who like to implement new bus drivers:
+ * i2c_algorithm is the interface to a class of hardware solutions which can
+ * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
+ * to name two of the most common.
+ */
+struct i2c_algorithm {
+        char name[32];                          /* textual description  */
+        unsigned int id;
+
+        /* If an adapter algorithm can't do I2C-level access, set master_xfer
+           to NULL. If an adapter algorithm can do SMBus access, set 
+           smbus_xfer. If set to NULL, the SMBus protocol is simulated
+           using common I2C messages */
+        int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs, 
+                           int num);
+        int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, 
+                           unsigned short flags, char read_write,
+                           u8 command, int size, union i2c_smbus_data * data);
+
+        /* --- these optional/future use for some adapter types.*/
+        int (*slave_send)(struct i2c_adapter *,char*,int);
+        int (*slave_recv)(struct i2c_adapter *,char*,int);
+
+        /* --- ioctl like call to set div. parameters. */
+        int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long);
+
+        /* To determine what the adapter supports */
+        u32 (*functionality) (struct i2c_adapter *);
+};
+
+/*
+ * i2c_adapter is the structure used to identify a physical i2c bus along
+ * with the access algorithms necessary to access it.
+ */
+struct i2c_adapter {
+        struct module *owner;
+        unsigned int id;/* == is algo->id | hwdep.struct->id,           */
+                        /* for registered values see below              */
+        unsigned int class;
+        struct i2c_algorithm *algo;/* the algorithm to access the bus   */
+        void *algo_data;
+
+        /* --- administration stuff. */
+        int (*client_register)(struct i2c_client *);
+        int (*client_unregister)(struct i2c_client *);
+
+        /* data fields that are valid for all devices   */
+        struct semaphore bus_lock;
+        struct semaphore clist_lock;
+
+        int timeout;
+        int retries;
+        struct device dev;              /* the adapter device */
+        struct class_device class_dev;  /* the class device */
+
+#ifdef CONFIG_PROC_FS 
+        /* No need to set this when you initialize the adapter          */
+        int inode;
+#endif /* def CONFIG_PROC_FS */
+
+        int nr;
+        struct list_head clients;
+        struct list_head list;
+        char name[I2C_NAME_SIZE];
+        struct completion dev_released;
+        struct completion class_dev_released;
+};
+#define dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
+#define class_dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, class_dev)
+
+static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
+{
+        return dev_get_drvdata (&dev->dev);
+}
+
+static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
+{
+        dev_set_drvdata (&dev->dev, data);
+}
+
+/*flags for the driver struct: */
+#define I2C_DF_NOTIFY   0x01            /* notify on bus (de/a)ttaches  */
+#if 0
+/* this flag is gone -- there is a (optional) driver->detach_adapter
+ * callback now which can be used instead */
+# define I2C_DF_DUMMY   0x02
+#endif
+
+/*flags for the client struct: */
+#define I2C_CLIENT_ALLOW_USE            0x01    /* Client allows access */
+#define I2C_CLIENT_ALLOW_MULTIPLE_USE   0x02    /* Allow multiple access-locks */
+                                                /* on an i2c_client */
+#define I2C_CLIENT_PEC  0x04                    /* Use Packet Error Checking */
+#define I2C_CLIENT_TEN  0x10                    /* we have a ten bit chip address       */
+                                                /* Must equal I2C_M_TEN below */
+
+/* i2c adapter classes (bitmask) */
+#define I2C_CLASS_HWMON         (1<<0)  /* lm_sensors, ... */
+#define I2C_CLASS_TV_ANALOG     (1<<1)  /* bttv + friends */
+#define I2C_CLASS_TV_DIGITAL    (1<<2)  /* dvb cards */
+#define I2C_CLASS_DDC           (1<<3)  /* i2c-matroxfb ? */
+#define I2C_CLASS_CAM_ANALOG    (1<<4)  /* camera with analog CCD */
+#define I2C_CLASS_CAM_DIGITAL   (1<<5)  /* most webcams */
+#define I2C_CLASS_SOUND         (1<<6)  /* sound devices */
+#define I2C_CLASS_ALL           (UINT_MAX) /* all of the above */
+
+/* i2c_client_address_data is the struct for holding default client
+ * addresses for a driver and for the parameters supplied on the
+ * command line
+ */
+struct i2c_client_address_data {
+        unsigned short *normal_i2c;
+        unsigned short *normal_i2c_range;
+        unsigned short *probe;
+        unsigned short *probe_range;
+        unsigned short *ignore;
+        unsigned short *ignore_range;
+        unsigned short *force;
+};
+
+/* Internal numbers to terminate lists */
+#define I2C_CLIENT_END          0xfffeU
+#define I2C_CLIENT_ISA_END      0xfffefffeU
+
+/* The numbers to use to set I2C bus address */
+#define ANY_I2C_BUS             0xffff
+#define ANY_I2C_ISA_BUS         9191
+
+
+/* ----- functions exported by i2c.o */
+
+/* administration...
+ */
+extern int i2c_add_adapter(struct i2c_adapter *);
+extern int i2c_del_adapter(struct i2c_adapter *);
+
+extern int i2c_add_driver(struct i2c_driver *);
+extern int i2c_del_driver(struct i2c_driver *);
+
+extern int i2c_attach_client(struct i2c_client *);
+extern int i2c_detach_client(struct i2c_client *);
+
+/* New function: This is to get an i2c_client-struct for controlling the 
+   client either by using i2c_control-function or having the 
+   client-module export functions that can be used with the i2c_client
+   -struct. */
+extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
+                                        struct i2c_client *prev);
+
+/* Should be used with new function
+   extern struct i2c_client *i2c_get_client(int,int,struct i2c_client *);
+   to make sure that client-struct is valid and that it is okay to access
+   the i2c-client. 
+   returns -EACCES if client doesn't allow use (default)
+   returns -EBUSY if client doesn't allow multiple use (default) and 
+   usage_count >0 */
+extern int i2c_use_client(struct i2c_client *);
+extern int i2c_release_client(struct i2c_client *);
+
+/* call the i2c_client->command() of all attached clients with
+ * the given arguments */
+extern void i2c_clients_command(struct i2c_adapter *adap,
+                                unsigned int cmd, void *arg);
+
+/* returns -EBUSY if address has been taken, 0 if not. Note that the only
+   other place at which this is called is within i2c_attach_client; so
+   you can cheat by simply not registering. Not recommended, of course! */
+extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
+
+/* Detect function. It iterates over all possible addresses itself.
+ * It will only call found_proc if some client is connected at the
+ * specific address (unless a 'force' matched);
+ */
+extern int i2c_probe(struct i2c_adapter *adapter, 
+                struct i2c_client_address_data *address_data,
+                int (*found_proc) (struct i2c_adapter *, int, int));
+
+/* An ioctl like call to set div. parameters of the adapter.
+ */
+extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
+
+/* This call returns a unique low identifier for each registered adapter,
+ * or -1 if the adapter was not registered. 
+ */
+extern int i2c_adapter_id(struct i2c_adapter *adap);
+extern struct i2c_adapter* i2c_get_adapter(int id);
+extern void i2c_put_adapter(struct i2c_adapter *adap);
+
+
+/* Return the functionality mask */
+static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
+{
+        return adap->algo->functionality(adap);
+}
+
+/* Return 1 if adapter supports everything we need, 0 if not. */
+static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
+{
+        return (func & i2c_get_functionality(adap)) == func;
+}
+
+/*
+ * I2C Message - used for pure i2c transaction, also from /dev interface
+ */
+struct i2c_msg {
+        __u16 addr;     /* slave address                        */
+        __u16 flags;            
+#define I2C_M_TEN       0x10    /* we have a ten bit chip address       */
+#define I2C_M_RD        0x01
+#define I2C_M_NOSTART   0x4000
+#define I2C_M_REV_DIR_ADDR      0x2000
+#define I2C_M_IGNORE_NAK        0x1000
+#define I2C_M_NO_RD_ACK         0x0800
+        __u16 len;              /* msg length                           */
+        __u8 *buf;              /* pointer to msg data                  */
+};
+
+/* To determine what functionality is present */
+
+#define I2C_FUNC_I2C                    0x00000001
+#define I2C_FUNC_10BIT_ADDR             0x00000002
+#define I2C_FUNC_PROTOCOL_MANGLING      0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
+#define I2C_FUNC_SMBUS_HWPEC_CALC       0x00000008 /* SMBus 2.0 */
+#define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC  0x00000800 /* SMBus 2.0 */ 
+#define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ 
+#define I2C_FUNC_SMBUS_PROC_CALL_PEC    0x00002000 /* SMBus 2.0 */
+#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
+#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL  0x00008000 /* SMBus 2.0 */
+#define I2C_FUNC_SMBUS_QUICK            0x00010000 
+#define I2C_FUNC_SMBUS_READ_BYTE        0x00020000 
+#define I2C_FUNC_SMBUS_WRITE_BYTE       0x00040000 
+#define I2C_FUNC_SMBUS_READ_BYTE_DATA   0x00080000 
+#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA  0x00100000 
+#define I2C_FUNC_SMBUS_READ_WORD_DATA   0x00200000 
+#define I2C_FUNC_SMBUS_WRITE_WORD_DATA  0x00400000 
+#define I2C_FUNC_SMBUS_PROC_CALL        0x00800000 
+#define I2C_FUNC_SMBUS_READ_BLOCK_DATA  0x01000000 
+#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 
+#define I2C_FUNC_SMBUS_READ_I2C_BLOCK   0x04000000 /* I2C-like block xfer  */
+#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK  0x08000000 /* w/ 1-byte reg. addr. */
+#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2  0x10000000 /* I2C-like block xfer  */
+#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
+#define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC  0x40000000 /* SMBus 2.0 */
+#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
+
+#define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
+                             I2C_FUNC_SMBUS_WRITE_BYTE)
+#define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
+                                  I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
+#define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
+                                  I2C_FUNC_SMBUS_WRITE_WORD_DATA)
+#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
+                                   I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
+#define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
+                                  I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
+#define I2C_FUNC_SMBUS_I2C_BLOCK_2 (I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
+                                    I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2)
+#define I2C_FUNC_SMBUS_BLOCK_DATA_PEC (I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | \
+                                       I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC)
+#define I2C_FUNC_SMBUS_WORD_DATA_PEC  (I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | \
+                                       I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC)
+
+#define I2C_FUNC_SMBUS_READ_BYTE_PEC            I2C_FUNC_SMBUS_READ_BYTE_DATA
+#define I2C_FUNC_SMBUS_WRITE_BYTE_PEC           I2C_FUNC_SMBUS_WRITE_BYTE_DATA
+#define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC       I2C_FUNC_SMBUS_READ_WORD_DATA
+#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC      I2C_FUNC_SMBUS_WRITE_WORD_DATA
+#define I2C_FUNC_SMBUS_BYTE_PEC                 I2C_FUNC_SMBUS_BYTE_DATA
+#define I2C_FUNC_SMBUS_BYTE_DATA_PEC            I2C_FUNC_SMBUS_WORD_DATA
+
+#define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
+                             I2C_FUNC_SMBUS_BYTE | \
+                             I2C_FUNC_SMBUS_BYTE_DATA | \
+                             I2C_FUNC_SMBUS_WORD_DATA | \
+                             I2C_FUNC_SMBUS_PROC_CALL | \
+                             I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
+                             I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | \
+                             I2C_FUNC_SMBUS_I2C_BLOCK)
+
+/* 
+ * Data for SMBus Messages 
+ */
+#define I2C_SMBUS_BLOCK_MAX     32      /* As specified in SMBus standard */    
+#define I2C_SMBUS_I2C_BLOCK_MAX 32      /* Not specified but we use same structure */
+union i2c_smbus_data {
+        __u8 byte;
+        __u16 word;
+        __u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
+                          /* one more for read length in block process call */
+                                                    /* and one more for PEC */
+};
+
+/* smbus_access read or write markers */
+#define I2C_SMBUS_READ  1
+#define I2C_SMBUS_WRITE 0
+
+/* SMBus transaction types (size parameter in the above functions) 
+   Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
+#define I2C_SMBUS_QUICK             0
+#define I2C_SMBUS_BYTE              1
+#define I2C_SMBUS_BYTE_DATA         2 
+#define I2C_SMBUS_WORD_DATA         3
+#define I2C_SMBUS_PROC_CALL         4
+#define I2C_SMBUS_BLOCK_DATA        5
+#define I2C_SMBUS_I2C_BLOCK_DATA    6
+#define I2C_SMBUS_BLOCK_PROC_CALL   7           /* SMBus 2.0 */
+#define I2C_SMBUS_BLOCK_DATA_PEC    8           /* SMBus 2.0 */
+#define I2C_SMBUS_PROC_CALL_PEC     9           /* SMBus 2.0 */
+#define I2C_SMBUS_BLOCK_PROC_CALL_PEC  10       /* SMBus 2.0 */
+#define I2C_SMBUS_WORD_DATA_PEC    11           /* SMBus 2.0 */
+
+
+/* ----- commands for the ioctl like i2c_command call:
+ * note that additional calls are defined in the algorithm and hw 
+ *      dependent layers - these can be listed here, or see the 
+ *      corresponding header files.
+ */
+                                /* -> bit-adapter specific ioctls       */
+#define I2C_RETRIES     0x0701  /* number of times a device address      */
+                                /* should be polled when not            */
+                                /* acknowledging                        */
+#define I2C_TIMEOUT     0x0702  /* set timeout - call with int          */
+
+
+/* this is for i2c-dev.c        */
+#define I2C_SLAVE       0x0703  /* Change slave address                 */
+                                /* Attn.: Slave address is 7 or 10 bits */
+#define I2C_SLAVE_FORCE 0x0706  /* Change slave address                 */
+                                /* Attn.: Slave address is 7 or 10 bits */
+                                /* This changes the address, even if it */
+                                /* is already taken!                    */
+#define I2C_TENBIT      0x0704  /* 0 for 7 bit addrs, != 0 for 10 bit   */
+
+#define I2C_FUNCS       0x0705  /* Get the adapter functionality */
+#define I2C_RDWR        0x0707  /* Combined R/W transfer (one stop only)*/
+#define I2C_PEC         0x0708  /* != 0 for SMBus PEC                   */
+#if 0
+#define I2C_ACK_TEST    0x0710  /* See if a slave is at a specific address */
+#endif
+
+#define I2C_SMBUS       0x0720  /* SMBus-level access */
+
+/* ... algo-bit.c recognizes */
+#define I2C_UDELAY      0x0705  /* set delay in microsecs between each  */
+                                /* written byte (except address)        */
+#define I2C_MDELAY      0x0706  /* millisec delay between written bytes */
+
+/* ----- I2C-DEV: char device interface stuff ------------------------- */
+
+#define I2C_MAJOR       89              /* Device major number          */
+
+/* These defines are used for probing i2c client addresses */
+/* The length of the option lists */
+#define I2C_CLIENT_MAX_OPTS 48
+
+/* Default fill of many variables */
+#define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+                          I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
+
+/* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
+   module header */
+
+#define I2C_CLIENT_MODULE_PARM(var,desc) \
+  static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
+  static unsigned int var##_num; \
+  module_param_array(var, short, &var##_num, 0); \
+  MODULE_PARM_DESC(var,desc)
+
+/* This is the one you want to use in your own modules */
+#define I2C_CLIENT_INSMOD \
+  I2C_CLIENT_MODULE_PARM(probe, \
+                      "List of adapter,address pairs to scan additionally"); \
+  I2C_CLIENT_MODULE_PARM(probe_range, \
+                      "List of adapter,start-addr,end-addr triples to scan " \
+                      "additionally"); \
+  I2C_CLIENT_MODULE_PARM(ignore, \
+                      "List of adapter,address pairs not to scan"); \
+  I2C_CLIENT_MODULE_PARM(ignore_range, \
+                      "List of adapter,start-addr,end-addr triples not to " \
+                      "scan"); \
+  I2C_CLIENT_MODULE_PARM(force, \
+                      "List of adapter,address pairs to boldly assume " \
+                      "to be present"); \
+        static struct i2c_client_address_data addr_data = {             \
+                        .normal_i2c =           normal_i2c,             \
+                        .normal_i2c_range =     normal_i2c_range,       \
+                        .probe =                probe,                  \
+                        .probe_range =          probe_range,            \
+                        .ignore =               ignore,                 \
+                        .ignore_range =         ignore_range,           \
+                        .force =                force,                  \
+                }
+
+/* Detect whether we are on the isa bus. If this returns true, all i2c
+   access will fail! */
+#define i2c_is_isa_client(clientptr) \
+        ((clientptr)->adapter->algo->id == I2C_ALGO_ISA)
+#define i2c_is_isa_adapter(adapptr) \
+        ((adapptr)->algo->id == I2C_ALGO_ISA)
+
+#endif /* _LINUX_I2C_H */
diff --git a/include/linux/i2o-dev.h b/include/linux/i2o-dev.h
new file mode 100644
index 000000000000..ef7f644dd873
--- /dev/null
+++ b/include/linux/i2o-dev.h
@@ -0,0 +1,402 @@
+/*
+ * I2O user space accessible structures/APIs
+ *
+ * (c) Copyright 1999, 2000 Red Hat Software
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *************************************************************************
+ *
+ * This header file defines the I2O APIs that are available to both
+ * the kernel and user level applications.  Kernel specific structures
+ * are defined in i2o_osm. OSMs should include _only_ i2o_osm.h which
+ * automatically includs this file.
+ *
+ */
+
+#ifndef _I2O_DEV_H
+#define _I2O_DEV_H
+
+/* How many controllers are we allowing */
+#define MAX_I2O_CONTROLLERS     32
+
+//#include <linux/ioctl.h>
+
+/*
+ * I2O Control IOCTLs and structures
+ */
+#define I2O_MAGIC_NUMBER        'i'
+#define I2OGETIOPS              _IOR(I2O_MAGIC_NUMBER,0,u8[MAX_I2O_CONTROLLERS])
+#define I2OHRTGET               _IOWR(I2O_MAGIC_NUMBER,1,struct i2o_cmd_hrtlct)
+#define I2OLCTGET               _IOWR(I2O_MAGIC_NUMBER,2,struct i2o_cmd_hrtlct)
+#define I2OPARMSET              _IOWR(I2O_MAGIC_NUMBER,3,struct i2o_cmd_psetget)
+#define I2OPARMGET              _IOWR(I2O_MAGIC_NUMBER,4,struct i2o_cmd_psetget)
+#define I2OSWDL                 _IOWR(I2O_MAGIC_NUMBER,5,struct i2o_sw_xfer)
+#define I2OSWUL                 _IOWR(I2O_MAGIC_NUMBER,6,struct i2o_sw_xfer)
+#define I2OSWDEL                _IOWR(I2O_MAGIC_NUMBER,7,struct i2o_sw_xfer)
+#define I2OVALIDATE             _IOR(I2O_MAGIC_NUMBER,8,u32)
+#define I2OHTML                 _IOWR(I2O_MAGIC_NUMBER,9,struct i2o_html)
+#define I2OEVTREG               _IOW(I2O_MAGIC_NUMBER,10,struct i2o_evt_id)
+#define I2OEVTGET               _IOR(I2O_MAGIC_NUMBER,11,struct i2o_evt_info)
+#define I2OPASSTHRU             _IOR(I2O_MAGIC_NUMBER,12,struct i2o_cmd_passthru)
+#define I2OPASSTHRU32           _IOR(I2O_MAGIC_NUMBER,12,struct i2o_cmd_passthru32)
+
+struct i2o_cmd_passthru32 {
+        unsigned int iop;       /* IOP unit number */
+        u32 msg;                /* message */
+};
+
+struct i2o_cmd_passthru {
+        unsigned int iop;       /* IOP unit number */
+        void __user *msg;       /* message */
+};
+
+struct i2o_cmd_hrtlct {
+        unsigned int iop;       /* IOP unit number */
+        void __user *resbuf;    /* Buffer for result */
+        unsigned int __user *reslen;    /* Buffer length in bytes */
+};
+
+struct i2o_cmd_psetget {
+        unsigned int iop;       /* IOP unit number */
+        unsigned int tid;       /* Target device TID */
+        void __user *opbuf;     /* Operation List buffer */
+        unsigned int oplen;     /* Operation List buffer length in bytes */
+        void __user *resbuf;    /* Result List buffer */
+        unsigned int __user *reslen;    /* Result List buffer length in bytes */
+};
+
+struct i2o_sw_xfer {
+        unsigned int iop;       /* IOP unit number */
+        unsigned char flags;    /* Flags field */
+        unsigned char sw_type;  /* Software type */
+        unsigned int sw_id;     /* Software ID */
+        void __user *buf;       /* Pointer to software buffer */
+        unsigned int __user *swlen;     /* Length of software data */
+        unsigned int __user *maxfrag;   /* Maximum fragment count */
+        unsigned int __user *curfrag;   /* Current fragment count */
+};
+
+struct i2o_html {
+        unsigned int iop;       /* IOP unit number */
+        unsigned int tid;       /* Target device ID */
+        unsigned int page;      /* HTML page */
+        void __user *resbuf;    /* Buffer for reply HTML page */
+        unsigned int __user *reslen;    /* Length in bytes of reply buffer */
+        void __user *qbuf;      /* Pointer to HTTP query string */
+        unsigned int qlen;      /* Length in bytes of query string buffer */
+};
+
+#define I2O_EVT_Q_LEN 32
+
+struct i2o_evt_id {
+        unsigned int iop;
+        unsigned int tid;
+        unsigned int evt_mask;
+};
+
+/* Event data size = frame size - message header + evt indicator */
+#define I2O_EVT_DATA_SIZE 88
+
+struct i2o_evt_info {
+        struct i2o_evt_id id;
+        unsigned char evt_data[I2O_EVT_DATA_SIZE];
+        unsigned int data_size;
+};
+
+struct i2o_evt_get {
+        struct i2o_evt_info info;
+        int pending;
+        int lost;
+};
+
+/**************************************************************************
+ * HRT related constants and structures
+ **************************************************************************/
+#define I2O_BUS_LOCAL   0
+#define I2O_BUS_ISA     1
+#define I2O_BUS_EISA    2
+#define I2O_BUS_MCA     3
+#define I2O_BUS_PCI     4
+#define I2O_BUS_PCMCIA  5
+#define I2O_BUS_NUBUS   6
+#define I2O_BUS_CARDBUS 7
+#define I2O_BUS_UNKNOWN 0x80
+
+#ifndef __KERNEL__
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+
+#endif                          /* __KERNEL__ */
+
+typedef struct _i2o_pci_bus {
+        u8 PciFunctionNumber;
+        u8 PciDeviceNumber;
+        u8 PciBusNumber;
+        u8 reserved;
+        u16 PciVendorID;
+        u16 PciDeviceID;
+} i2o_pci_bus;
+
+typedef struct _i2o_local_bus {
+        u16 LbBaseIOPort;
+        u16 reserved;
+        u32 LbBaseMemoryAddress;
+} i2o_local_bus;
+
+typedef struct _i2o_isa_bus {
+        u16 IsaBaseIOPort;
+        u8 CSN;
+        u8 reserved;
+        u32 IsaBaseMemoryAddress;
+} i2o_isa_bus;
+
+typedef struct _i2o_eisa_bus_info {
+        u16 EisaBaseIOPort;
+        u8 reserved;
+        u8 EisaSlotNumber;
+        u32 EisaBaseMemoryAddress;
+} i2o_eisa_bus;
+
+typedef struct _i2o_mca_bus {
+        u16 McaBaseIOPort;
+        u8 reserved;
+        u8 McaSlotNumber;
+        u32 McaBaseMemoryAddress;
+} i2o_mca_bus;
+
+typedef struct _i2o_other_bus {
+        u16 BaseIOPort;
+        u16 reserved;
+        u32 BaseMemoryAddress;
+} i2o_other_bus;
+
+typedef struct _i2o_hrt_entry {
+        u32 adapter_id;
+        u32 parent_tid:12;
+        u32 state:4;
+        u32 bus_num:8;
+        u32 bus_type:8;
+        union {
+                i2o_pci_bus pci_bus;
+                i2o_local_bus local_bus;
+                i2o_isa_bus isa_bus;
+                i2o_eisa_bus eisa_bus;
+                i2o_mca_bus mca_bus;
+                i2o_other_bus other_bus;
+        } bus;
+} i2o_hrt_entry;
+
+typedef struct _i2o_hrt {
+        u16 num_entries;
+        u8 entry_len;
+        u8 hrt_version;
+        u32 change_ind;
+        i2o_hrt_entry hrt_entry[1];
+} i2o_hrt;
+
+typedef struct _i2o_lct_entry {
+        u32 entry_size:16;
+        u32 tid:12;
+        u32 reserved:4;
+        u32 change_ind;
+        u32 device_flags;
+        u32 class_id:12;
+        u32 version:4;
+        u32 vendor_id:16;
+        u32 sub_class;
+        u32 user_tid:12;
+        u32 parent_tid:12;
+        u32 bios_info:8;
+        u8 identity_tag[8];
+        u32 event_capabilities;
+} i2o_lct_entry;
+
+typedef struct _i2o_lct {
+        u32 table_size:16;
+        u32 boot_tid:12;
+        u32 lct_ver:4;
+        u32 iop_flags;
+        u32 change_ind;
+        i2o_lct_entry lct_entry[1];
+} i2o_lct;
+
+typedef struct _i2o_status_block {
+        u16 org_id;
+        u16 reserved;
+        u16 iop_id:12;
+        u16 reserved1:4;
+        u16 host_unit_id;
+        u16 segment_number:12;
+        u16 i2o_version:4;
+        u8 iop_state;
+        u8 msg_type;
+        u16 inbound_frame_size;
+        u8 init_code;
+        u8 reserved2;
+        u32 max_inbound_frames;
+        u32 cur_inbound_frames;
+        u32 max_outbound_frames;
+        char product_id[24];
+        u32 expected_lct_size;
+        u32 iop_capabilities;
+        u32 desired_mem_size;
+        u32 current_mem_size;
+        u32 current_mem_base;
+        u32 desired_io_size;
+        u32 current_io_size;
+        u32 current_io_base;
+        u32 reserved3:24;
+        u32 cmd_status:8;
+} i2o_status_block;
+
+/* Event indicator mask flags */
+#define I2O_EVT_IND_STATE_CHANGE                0x80000000
+#define I2O_EVT_IND_GENERAL_WARNING             0x40000000
+#define I2O_EVT_IND_CONFIGURATION_FLAG          0x20000000
+#define I2O_EVT_IND_LOCK_RELEASE                0x10000000
+#define I2O_EVT_IND_CAPABILITY_CHANGE           0x08000000
+#define I2O_EVT_IND_DEVICE_RESET                0x04000000
+#define I2O_EVT_IND_EVT_MASK_MODIFIED           0x02000000
+#define I2O_EVT_IND_FIELD_MODIFIED              0x01000000
+#define I2O_EVT_IND_VENDOR_EVT                  0x00800000
+#define I2O_EVT_IND_DEVICE_STATE                0x00400000
+
+/* Executive event indicitors */
+#define I2O_EVT_IND_EXEC_RESOURCE_LIMITS        0x00000001
+#define I2O_EVT_IND_EXEC_CONNECTION_FAIL        0x00000002
+#define I2O_EVT_IND_EXEC_ADAPTER_FAULT          0x00000004
+#define I2O_EVT_IND_EXEC_POWER_FAIL             0x00000008
+#define I2O_EVT_IND_EXEC_RESET_PENDING          0x00000010
+#define I2O_EVT_IND_EXEC_RESET_IMMINENT         0x00000020
+#define I2O_EVT_IND_EXEC_HW_FAIL                0x00000040
+#define I2O_EVT_IND_EXEC_XCT_CHANGE             0x00000080
+#define I2O_EVT_IND_EXEC_NEW_LCT_ENTRY          0x00000100
+#define I2O_EVT_IND_EXEC_MODIFIED_LCT           0x00000200
+#define I2O_EVT_IND_EXEC_DDM_AVAILABILITY       0x00000400
+
+/* Random Block Storage Event Indicators */
+#define I2O_EVT_IND_BSA_VOLUME_LOAD             0x00000001
+#define I2O_EVT_IND_BSA_VOLUME_UNLOAD           0x00000002
+#define I2O_EVT_IND_BSA_VOLUME_UNLOAD_REQ       0x00000004
+#define I2O_EVT_IND_BSA_CAPACITY_CHANGE         0x00000008
+#define I2O_EVT_IND_BSA_SCSI_SMART              0x00000010
+
+/* Event data for generic events */
+#define I2O_EVT_STATE_CHANGE_NORMAL             0x00
+#define I2O_EVT_STATE_CHANGE_SUSPENDED          0x01
+#define I2O_EVT_STATE_CHANGE_RESTART            0x02
+#define I2O_EVT_STATE_CHANGE_NA_RECOVER         0x03
+#define I2O_EVT_STATE_CHANGE_NA_NO_RECOVER      0x04
+#define I2O_EVT_STATE_CHANGE_QUIESCE_REQUEST    0x05
+#define I2O_EVT_STATE_CHANGE_FAILED             0x10
+#define I2O_EVT_STATE_CHANGE_FAULTED            0x11
+
+#define I2O_EVT_GEN_WARNING_NORMAL              0x00
+#define I2O_EVT_GEN_WARNING_ERROR_THRESHOLD     0x01
+#define I2O_EVT_GEN_WARNING_MEDIA_FAULT         0x02
+
+#define I2O_EVT_CAPABILITY_OTHER                0x01
+#define I2O_EVT_CAPABILITY_CHANGED              0x02
+
+#define I2O_EVT_SENSOR_STATE_CHANGED            0x01
+
+/*
+ *      I2O classes / subclasses
+ */
+
+/*  Class ID and Code Assignments
+ *  (LCT.ClassID.Version field)
+ */
+#define I2O_CLASS_VERSION_10                    0x00
+#define I2O_CLASS_VERSION_11                    0x01
+
+/*  Class code names
+ *  (from v1.5 Table 6-1 Class Code Assignments.)
+ */
+
+#define I2O_CLASS_EXECUTIVE                     0x000
+#define I2O_CLASS_DDM                           0x001
+#define I2O_CLASS_RANDOM_BLOCK_STORAGE          0x010
+#define I2O_CLASS_SEQUENTIAL_STORAGE            0x011
+#define I2O_CLASS_LAN                           0x020
+#define I2O_CLASS_WAN                           0x030
+#define I2O_CLASS_FIBRE_CHANNEL_PORT            0x040
+#define I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL      0x041
+#define I2O_CLASS_SCSI_PERIPHERAL               0x051
+#define I2O_CLASS_ATE_PORT                      0x060
+#define I2O_CLASS_ATE_PERIPHERAL                0x061
+#define I2O_CLASS_FLOPPY_CONTROLLER             0x070
+#define I2O_CLASS_FLOPPY_DEVICE                 0x071
+#define I2O_CLASS_BUS_ADAPTER_PORT              0x080
+#define I2O_CLASS_PEER_TRANSPORT_AGENT          0x090
+#define I2O_CLASS_PEER_TRANSPORT                0x091
+#define I2O_CLASS_END                           0xfff
+
+/*
+ *  Rest of 0x092 - 0x09f reserved for peer-to-peer classes
+ */
+
+#define I2O_CLASS_MATCH_ANYCLASS                0xffffffff
+
+/*
+ *  Subclasses
+ */
+
+#define I2O_SUBCLASS_i960                       0x001
+#define I2O_SUBCLASS_HDM                        0x020
+#define I2O_SUBCLASS_ISM                        0x021
+
+/* Operation functions */
+
+#define I2O_PARAMS_FIELD_GET                    0x0001
+#define I2O_PARAMS_LIST_GET                     0x0002
+#define I2O_PARAMS_MORE_GET                     0x0003
+#define I2O_PARAMS_SIZE_GET                     0x0004
+#define I2O_PARAMS_TABLE_GET                    0x0005
+#define I2O_PARAMS_FIELD_SET                    0x0006
+#define I2O_PARAMS_LIST_SET                     0x0007
+#define I2O_PARAMS_ROW_ADD                      0x0008
+#define I2O_PARAMS_ROW_DELETE                   0x0009
+#define I2O_PARAMS_TABLE_CLEAR                  0x000A
+
+/*
+ * I2O serial number conventions / formats
+ * (circa v1.5)
+ */
+
+#define I2O_SNFORMAT_UNKNOWN                    0
+#define I2O_SNFORMAT_BINARY                     1
+#define I2O_SNFORMAT_ASCII                      2
+#define I2O_SNFORMAT_UNICODE                    3
+#define I2O_SNFORMAT_LAN48_MAC                  4
+#define I2O_SNFORMAT_WAN                        5
+
+/*
+ * Plus new in v2.0 (Yellowstone pdf doc)
+ */
+
+#define I2O_SNFORMAT_LAN64_MAC                  6
+#define I2O_SNFORMAT_DDM                        7
+#define I2O_SNFORMAT_IEEE_REG64                 8
+#define I2O_SNFORMAT_IEEE_REG128                9
+#define I2O_SNFORMAT_UNKNOWN2                   0xff
+
+/*
+ *      I2O Get Status State values
+ */
+
+#define ADAPTER_STATE_INITIALIZING              0x01
+#define ADAPTER_STATE_RESET                     0x02
+#define ADAPTER_STATE_HOLD                      0x04
+#define ADAPTER_STATE_READY                     0x05
+#define ADAPTER_STATE_OPERATIONAL               0x08
+#define ADAPTER_STATE_FAILED                    0x10
+#define ADAPTER_STATE_FAULTED                   0x11
+
+#endif                          /* _I2O_DEV_H */
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
new file mode 100644
index 000000000000..ea9a3ad4b67f
--- /dev/null
+++ b/include/linux/i2o.h
@@ -0,0 +1,1003 @@
+/*
+ * I2O kernel space accessible structures/APIs
+ *
+ * (c) Copyright 1999, 2000 Red Hat Software
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *************************************************************************
+ *
+ * This header file defined the I2O APIs/structures for use by
+ * the I2O kernel modules.
+ *
+ */
+
+#ifndef _I2O_H
+#define _I2O_H
+
+#ifdef __KERNEL__               /* This file to be included by kernel only */
+
+#include <linux/i2o-dev.h>
+
+/* How many different OSM's are we allowing */
+#define I2O_MAX_DRIVERS         8
+
+#include <asm/io.h>
+#include <asm/semaphore.h>      /* Needed for MUTEX init macros */
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+
+/* message queue empty */
+#define I2O_QUEUE_EMPTY         0xffffffff
+
+/*
+ *      Message structures
+ */
+struct i2o_message {
+        union {
+                struct {
+                        u8 version_offset;
+                        u8 flags;
+                        u16 size;
+                        u32 target_tid:12;
+                        u32 init_tid:12;
+                        u32 function:8;
+                        u32 icntxt;     /* initiator context */
+                        u32 tcntxt;     /* transaction context */
+                } s;
+                u32 head[4];
+        } u;
+        /* List follows */
+        u32 body[0];
+};
+
+/*
+ *      Each I2O device entity has one of these. There is one per device.
+ */
+struct i2o_device {
+        i2o_lct_entry lct_data; /* Device LCT information */
+
+        struct i2o_controller *iop;     /* Controlling IOP */
+        struct list_head list;  /* node in IOP devices list */
+
+        struct device device;
+
+        struct semaphore lock;  /* device lock */
+
+        struct class_device classdev;   /* i2o device class */
+};
+
+/*
+ *      Event structure provided to the event handling function
+ */
+struct i2o_event {
+        struct work_struct work;
+        struct i2o_device *i2o_dev;     /* I2O device pointer from which the
+                                           event reply was initiated */
+        u16 size;               /* Size of data in 32-bit words */
+        u32 tcntxt;             /* Transaction context used at
+                                   registration */
+        u32 event_indicator;    /* Event indicator from reply */
+        u32 data[0];            /* Event data from reply */
+};
+
+/*
+ *      I2O classes which could be handled by the OSM
+ */
+struct i2o_class_id {
+        u16 class_id:12;
+};
+
+/*
+ *      I2O driver structure for OSMs
+ */
+struct i2o_driver {
+        char *name;             /* OSM name */
+        int context;            /* Low 8 bits of the transaction info */
+        struct i2o_class_id *classes;   /* I2O classes that this OSM handles */
+
+        /* Message reply handler */
+        int (*reply) (struct i2o_controller *, u32, struct i2o_message *);
+
+        /* Event handler */
+        void (*event) (struct i2o_event *);
+
+        struct workqueue_struct *event_queue;   /* Event queue */
+
+        struct device_driver driver;
+
+        /* notification of changes */
+        void (*notify_controller_add) (struct i2o_controller *);
+        void (*notify_controller_remove) (struct i2o_controller *);
+        void (*notify_device_add) (struct i2o_device *);
+        void (*notify_device_remove) (struct i2o_device *);
+
+        struct semaphore lock;
+};
+
+/*
+ *      Contains all information which are necessary for DMA operations
+ */
+struct i2o_dma {
+        void *virt;
+        dma_addr_t phys;
+        u32 len;
+};
+
+/*
+ *      Context queue entry, used for 32-bit context on 64-bit systems
+ */
+struct i2o_context_list_element {
+        struct list_head list;
+        u32 context;
+        void *ptr;
+        unsigned long timestamp;
+};
+
+/*
+ * Each I2O controller has one of these objects
+ */
+struct i2o_controller {
+        char name[16];
+        int unit;
+        int type;
+
+        struct pci_dev *pdev;   /* PCI device */
+
+        unsigned int short_req:1;       /* use small block sizes */
+        unsigned int no_quiesce:1;      /* dont quiesce before reset */
+        unsigned int raptor:1;          /* split bar */
+        unsigned int promise:1;         /* Promise controller */
+
+#ifdef CONFIG_MTRR
+        int mtrr_reg0;
+        int mtrr_reg1;
+#endif
+
+        struct list_head devices;       /* list of I2O devices */
+
+        struct notifier_block *event_notifer;   /* Events */
+        atomic_t users;
+        struct list_head list;  /* Controller list */
+        void __iomem *post_port;        /* Inbout port address */
+        void __iomem *reply_port;       /* Outbound port address */
+        void __iomem *irq_mask;         /* Interrupt register address */
+
+        /* Dynamic LCT related data */
+
+        struct i2o_dma status;  /* status of IOP */
+
+        struct i2o_dma hrt;     /* HW Resource Table */
+        i2o_lct *lct;           /* Logical Config Table */
+        struct i2o_dma dlct;    /* Temp LCT */
+        struct semaphore lct_lock;      /* Lock for LCT updates */
+        struct i2o_dma status_block;    /* IOP status block */
+
+        struct i2o_dma base;    /* controller messaging unit */
+        struct i2o_dma in_queue;        /* inbound message queue Host->IOP */
+        struct i2o_dma out_queue;       /* outbound message queue IOP->Host */
+
+        unsigned int battery:1;         /* Has a battery backup */
+        unsigned int io_alloc:1;        /* An I/O resource was allocated */
+        unsigned int mem_alloc:1;       /* A memory resource was allocated */
+
+        struct resource io_resource;    /* I/O resource allocated to the IOP */
+        struct resource mem_resource;   /* Mem resource allocated to the IOP */
+
+        struct proc_dir_entry *proc_entry;      /* /proc dir */
+
+        struct list_head bus_list;      /* list of busses on IOP */
+        struct device device;
+        struct i2o_device *exec;        /* Executive */
+#if BITS_PER_LONG == 64
+        spinlock_t context_list_lock;   /* lock for context_list */
+        atomic_t context_list_counter;  /* needed for unique contexts */
+        struct list_head context_list;  /* list of context id's
+                                           and pointers */
+#endif
+        spinlock_t lock;        /* lock for controller
+                                   configuration */
+
+        void *driver_data[I2O_MAX_DRIVERS];     /* storage for drivers */
+};
+
+/*
+ * I2O System table entry
+ *
+ * The system table contains information about all the IOPs in the
+ * system.  It is sent to all IOPs so that they can create peer2peer
+ * connections between them.
+ */
+struct i2o_sys_tbl_entry {
+        u16 org_id;
+        u16 reserved1;
+        u32 iop_id:12;
+        u32 reserved2:20;
+        u16 seg_num:12;
+        u16 i2o_version:4;
+        u8 iop_state;
+        u8 msg_type;
+        u16 frame_size;
+        u16 reserved3;
+        u32 last_changed;
+        u32 iop_capabilities;
+        u32 inbound_low;
+        u32 inbound_high;
+};
+
+struct i2o_sys_tbl {
+        u8 num_entries;
+        u8 version;
+        u16 reserved1;
+        u32 change_ind;
+        u32 reserved2;
+        u32 reserved3;
+        struct i2o_sys_tbl_entry iops[0];
+};
+
+extern struct list_head i2o_controllers;
+
+/* Message functions */
+static inline u32 i2o_msg_get(struct i2o_controller *, struct i2o_message __iomem **);
+extern u32 i2o_msg_get_wait(struct i2o_controller *, struct i2o_message __iomem **,
+                            int);
+static inline void i2o_msg_post(struct i2o_controller *, u32);
+static inline int i2o_msg_post_wait(struct i2o_controller *, u32,
+                                    unsigned long);
+extern int i2o_msg_post_wait_mem(struct i2o_controller *, u32, unsigned long,
+                                 struct i2o_dma *);
+extern void i2o_msg_nop(struct i2o_controller *, u32);
+static inline void i2o_flush_reply(struct i2o_controller *, u32);
+
+/* DMA handling functions */
+static inline int i2o_dma_alloc(struct device *, struct i2o_dma *, size_t,
+                                unsigned int);
+static inline void i2o_dma_free(struct device *, struct i2o_dma *);
+int i2o_dma_realloc(struct device *, struct i2o_dma *, size_t, unsigned int);
+
+static inline int i2o_dma_map(struct device *, struct i2o_dma *);
+static inline void i2o_dma_unmap(struct device *, struct i2o_dma *);
+
+/* IOP functions */
+extern int i2o_status_get(struct i2o_controller *);
+
+extern int i2o_event_register(struct i2o_device *, struct i2o_driver *, int,
+                              u32);
+extern struct i2o_device *i2o_iop_find_device(struct i2o_controller *, u16);
+extern struct i2o_controller *i2o_find_iop(int);
+
+/* Functions needed for handling 64-bit pointers in 32-bit context */
+#if BITS_PER_LONG == 64
+extern u32 i2o_cntxt_list_add(struct i2o_controller *, void *);
+extern void *i2o_cntxt_list_get(struct i2o_controller *, u32);
+extern u32 i2o_cntxt_list_remove(struct i2o_controller *, void *);
+extern u32 i2o_cntxt_list_get_ptr(struct i2o_controller *, void *);
+
+static inline u32 i2o_ptr_low(void *ptr)
+{
+        return (u32) (u64) ptr;
+};
+
+static inline u32 i2o_ptr_high(void *ptr)
+{
+        return (u32) ((u64) ptr >> 32);
+};
+#else
+static inline u32 i2o_cntxt_list_add(struct i2o_controller *c, void *ptr)
+{
+        return (u32) ptr;
+};
+
+static inline void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
+{
+        return (void *)context;
+};
+
+static inline u32 i2o_cntxt_list_remove(struct i2o_controller *c, void *ptr)
+{
+        return (u32) ptr;
+};
+
+static inline u32 i2o_cntxt_list_get_ptr(struct i2o_controller *c, void *ptr)
+{
+        return (u32) ptr;
+};
+
+static inline u32 i2o_ptr_low(void *ptr)
+{
+        return (u32) ptr;
+};
+
+static inline u32 i2o_ptr_high(void *ptr)
+{
+        return 0;
+};
+#endif
+
+/* I2O driver (OSM) functions */
+extern int i2o_driver_register(struct i2o_driver *);
+extern void i2o_driver_unregister(struct i2o_driver *);
+
+/**
+ *      i2o_driver_notify_controller_add - Send notification of added controller
+ *                                         to a single I2O driver
+ *
+ *      Send notification of added controller to a single registered driver.
+ */
+static inline void i2o_driver_notify_controller_add(struct i2o_driver *drv,
+                                                    struct i2o_controller *c)
+{
+        if (drv->notify_controller_add)
+                drv->notify_controller_add(c);
+};
+
+/**
+ *      i2o_driver_notify_controller_remove - Send notification of removed
+ *                                            controller to a single I2O driver
+ *
+ *      Send notification of removed controller to a single registered driver.
+ */
+static inline void i2o_driver_notify_controller_remove(struct i2o_driver *drv,
+                                                       struct i2o_controller *c)
+{
+        if (drv->notify_controller_remove)
+                drv->notify_controller_remove(c);
+};
+
+/**
+ *      i2o_driver_notify_device_add - Send notification of added device to a
+ *                                     single I2O driver
+ *
+ *      Send notification of added device to a single registered driver.
+ */
+static inline void i2o_driver_notify_device_add(struct i2o_driver *drv,
+                                                struct i2o_device *i2o_dev)
+{
+        if (drv->notify_device_add)
+                drv->notify_device_add(i2o_dev);
+};
+
+/**
+ *      i2o_driver_notify_device_remove - Send notification of removed device
+ *                                        to a single I2O driver
+ *
+ *      Send notification of removed device to a single registered driver.
+ */
+static inline void i2o_driver_notify_device_remove(struct i2o_driver *drv,
+                                                   struct i2o_device *i2o_dev)
+{
+        if (drv->notify_device_remove)
+                drv->notify_device_remove(i2o_dev);
+};
+
+extern void i2o_driver_notify_controller_add_all(struct i2o_controller *);
+extern void i2o_driver_notify_controller_remove_all(struct i2o_controller *);
+extern void i2o_driver_notify_device_add_all(struct i2o_device *);
+extern void i2o_driver_notify_device_remove_all(struct i2o_device *);
+
+/* I2O device functions */
+extern int i2o_device_claim(struct i2o_device *);
+extern int i2o_device_claim_release(struct i2o_device *);
+
+/* Exec OSM functions */
+extern int i2o_exec_lct_get(struct i2o_controller *);
+
+/* device to i2o_device and driver to i2o_driver convertion functions */
+#define to_i2o_driver(drv) container_of(drv,struct i2o_driver, driver)
+#define to_i2o_device(dev) container_of(dev, struct i2o_device, device)
+
+/*
+ *      Messenger inlines
+ */
+static inline u32 I2O_POST_READ32(struct i2o_controller *c)
+{
+        rmb();
+        return readl(c->post_port);
+};
+
+static inline void I2O_POST_WRITE32(struct i2o_controller *c, u32 val)
+{
+        wmb();
+        writel(val, c->post_port);
+};
+
+static inline u32 I2O_REPLY_READ32(struct i2o_controller *c)
+{
+        rmb();
+        return readl(c->reply_port);
+};
+
+static inline void I2O_REPLY_WRITE32(struct i2o_controller *c, u32 val)
+{
+        wmb();
+        writel(val, c->reply_port);
+};
+
+static inline u32 I2O_IRQ_READ32(struct i2o_controller *c)
+{
+        rmb();
+        return readl(c->irq_mask);
+};
+
+static inline void I2O_IRQ_WRITE32(struct i2o_controller *c, u32 val)
+{
+        wmb();
+        writel(val, c->irq_mask);
+        wmb();
+};
+
+/**
+ *      i2o_msg_get - obtain an I2O message from the IOP
+ *      @c: I2O controller
+ *      @msg: pointer to a I2O message pointer
+ *
+ *      This function tries to get a message slot. If no message slot is
+ *      available do not wait until one is availabe (see also i2o_msg_get_wait).
+ *
+ *      On a success the message is returned and the pointer to the message is
+ *      set in msg. The returned message is the physical page frame offset
+ *      address from the read port (see the i2o spec). If no message is
+ *      available returns I2O_QUEUE_EMPTY and msg is leaved untouched.
+ */
+static inline u32 i2o_msg_get(struct i2o_controller *c,
+                              struct i2o_message __iomem **msg)
+{
+        u32 m;
+
+        if ((m = I2O_POST_READ32(c)) != I2O_QUEUE_EMPTY)
+                *msg = c->in_queue.virt + m;
+
+        return m;
+};
+
+/**
+ *      i2o_msg_post - Post I2O message to I2O controller
+ *      @c: I2O controller to which the message should be send
+ *      @m: the message identifier
+ *
+ *      Post the message to the I2O controller.
+ */
+static inline void i2o_msg_post(struct i2o_controller *c, u32 m)
+{
+        I2O_POST_WRITE32(c, m);
+};
+
+/**
+ *      i2o_msg_post_wait - Post and wait a message and wait until return
+ *      @c: controller
+ *      @m: message to post
+ *      @timeout: time in seconds to wait
+ *
+ *      This API allows an OSM to post a message and then be told whether or
+ *      not the system received a successful reply. If the message times out
+ *      then the value '-ETIMEDOUT' is returned.
+ *
+ *      Returns 0 on success or negative error code on failure.
+ */
+static inline int i2o_msg_post_wait(struct i2o_controller *c, u32 m,
+                                    unsigned long timeout)
+{
+        return i2o_msg_post_wait_mem(c, m, timeout, NULL);
+};
+
+/**
+ *      i2o_flush_reply - Flush reply from I2O controller
+ *      @c: I2O controller
+ *      @m: the message identifier
+ *
+ *      The I2O controller must be informed that the reply message is not needed
+ *      anymore. If you forget to flush the reply, the message frame can't be
+ *      used by the controller anymore and is therefore lost.
+ *
+ *      FIXME: is there a timeout after which the controller reuse the message?
+ */
+static inline void i2o_flush_reply(struct i2o_controller *c, u32 m)
+{
+        I2O_REPLY_WRITE32(c, m);
+};
+
+/**
+ *      i2o_out_to_virt - Turn an I2O message to a virtual address
+ *      @c: controller
+ *      @m: message engine value
+ *
+ *      Turn a receive message from an I2O controller bus address into
+ *      a Linux virtual address. The shared page frame is a linear block
+ *      so we simply have to shift the offset. This function does not
+ *      work for sender side messages as they are ioremap objects
+ *      provided by the I2O controller.
+ */
+static inline struct i2o_message *i2o_msg_out_to_virt(struct i2o_controller *c,
+                                                      u32 m)
+{
+        BUG_ON(m < c->out_queue.phys
+               || m >= c->out_queue.phys + c->out_queue.len);
+
+        return c->out_queue.virt + (m - c->out_queue.phys);
+};
+
+/**
+ *      i2o_msg_in_to_virt - Turn an I2O message to a virtual address
+ *      @c: controller
+ *      @m: message engine value
+ *
+ *      Turn a send message from an I2O controller bus address into
+ *      a Linux virtual address. The shared page frame is a linear block
+ *      so we simply have to shift the offset. This function does not
+ *      work for receive side messages as they are kmalloc objects
+ *      in a different pool.
+ */
+static inline struct i2o_message __iomem *i2o_msg_in_to_virt(struct i2o_controller *c,
+                                                     u32 m)
+{
+        return c->in_queue.virt + m;
+};
+
+/**
+ *      i2o_dma_alloc - Allocate DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which should get the DMA buffer
+ *      @len: length of the new DMA memory
+ *      @gfp_mask: GFP mask
+ *
+ *      Allocate a coherent DMA memory and write the pointers into addr.
+ *
+ *      Returns 0 on success or -ENOMEM on failure.
+ */
+static inline int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr,
+                                size_t len, unsigned int gfp_mask)
+{
+        addr->virt = dma_alloc_coherent(dev, len, &addr->phys, gfp_mask);
+        if (!addr->virt)
+                return -ENOMEM;
+
+        memset(addr->virt, 0, len);
+        addr->len = len;
+
+        return 0;
+};
+
+/**
+ *      i2o_dma_free - Free DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which contains the DMA buffer
+ *
+ *      Free a coherent DMA memory and set virtual address of addr to NULL.
+ */
+static inline void i2o_dma_free(struct device *dev, struct i2o_dma *addr)
+{
+        if (addr->virt) {
+                if (addr->phys)
+                        dma_free_coherent(dev, addr->len, addr->virt,
+                                          addr->phys);
+                else
+                        kfree(addr->virt);
+                addr->virt = NULL;
+        }
+};
+
+/**
+ *      i2o_dma_map - Map the memory to DMA
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which should be mapped
+ *
+ *      Map the memory in addr->virt to coherent DMA memory and write the
+ *      physical address into addr->phys.
+ *
+ *      Returns 0 on success or -ENOMEM on failure.
+ */
+static inline int i2o_dma_map(struct device *dev, struct i2o_dma *addr)
+{
+        if (!addr->virt)
+                return -EFAULT;
+
+        if (!addr->phys)
+                addr->phys = dma_map_single(dev, addr->virt, addr->len,
+                                            DMA_BIDIRECTIONAL);
+        if (!addr->phys)
+                return -ENOMEM;
+
+        return 0;
+};
+
+/**
+ *      i2o_dma_unmap - Unmap the DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which should be unmapped
+ *
+ *      Unmap the memory in addr->virt from DMA memory.
+ */
+static inline void i2o_dma_unmap(struct device *dev, struct i2o_dma *addr)
+{
+        if (!addr->virt)
+                return;
+
+        if (addr->phys) {
+                dma_unmap_single(dev, addr->phys, addr->len, DMA_BIDIRECTIONAL);
+                addr->phys = 0;
+        }
+};
+
+/*
+ *      Endian handling wrapped into the macro - keeps the core code
+ *      cleaner.
+ */
+
+#define i2o_raw_writel(val, mem)        __raw_writel(cpu_to_le32(val), mem)
+
+extern int i2o_parm_field_get(struct i2o_device *, int, int, void *, int);
+extern int i2o_parm_table_get(struct i2o_device *, int, int, int, void *, int,
+                              void *, int);
+
+/* debugging and troubleshooting/diagnostic helpers. */
+#define osm_printk(level, format, arg...)  \
+        printk(level "%s: " format, OSM_NAME , ## arg)
+
+#ifdef DEBUG
+#define osm_debug(format, arg...) \
+        osm_printk(KERN_DEBUG, format , ## arg)
+#else
+#define osm_debug(format, arg...) \
+        do { } while (0)
+#endif
+
+#define osm_err(format, arg...)         \
+        osm_printk(KERN_ERR, format , ## arg)
+#define osm_info(format, arg...)                \
+        osm_printk(KERN_INFO, format , ## arg)
+#define osm_warn(format, arg...)                \
+        osm_printk(KERN_WARNING, format , ## arg)
+
+/* debugging functions */
+extern void i2o_report_status(const char *, const char *, struct i2o_message *);
+extern void i2o_dump_message(struct i2o_message *);
+extern void i2o_dump_hrt(struct i2o_controller *c);
+extern void i2o_debug_state(struct i2o_controller *c);
+
+/*
+ *      Cache strategies
+ */
+
+/*      The NULL strategy leaves everything up to the controller. This tends to be a
+ *      pessimal but functional choice.
+ */
+#define CACHE_NULL              0
+/*      Prefetch data when reading. We continually attempt to load the next 32 sectors
+ *      into the controller cache.
+ */
+#define CACHE_PREFETCH          1
+/*      Prefetch data when reading. We sometimes attempt to load the next 32 sectors
+ *      into the controller cache. When an I/O is less <= 8K we assume its probably
+ *      not sequential and don't prefetch (default)
+ */
+#define CACHE_SMARTFETCH        2
+/*      Data is written to the cache and then out on to the disk. The I/O must be
+ *      physically on the medium before the write is acknowledged (default without
+ *      NVRAM)
+ */
+#define CACHE_WRITETHROUGH      17
+/*      Data is written to the cache and then out on to the disk. The controller
+ *      is permitted to write back the cache any way it wants. (default if battery
+ *      backed NVRAM is present). It can be useful to set this for swap regardless of
+ *      battery state.
+ */
+#define CACHE_WRITEBACK         18
+/*      Optimise for under powered controllers, especially on RAID1 and RAID0. We
+ *      write large I/O's directly to disk bypassing the cache to avoid the extra
+ *      memory copy hits. Small writes are writeback cached
+ */
+#define CACHE_SMARTBACK         19
+/*      Optimise for under powered controllers, especially on RAID1 and RAID0. We
+ *      write large I/O's directly to disk bypassing the cache to avoid the extra
+ *      memory copy hits. Small writes are writethrough cached. Suitable for devices
+ *      lacking battery backup
+ */
+#define CACHE_SMARTTHROUGH      20
+
+/*
+ *      Ioctl structures
+ */
+
+#define         BLKI2OGRSTRAT   _IOR('2', 1, int)
+#define         BLKI2OGWSTRAT   _IOR('2', 2, int)
+#define         BLKI2OSRSTRAT   _IOW('2', 3, int)
+#define         BLKI2OSWSTRAT   _IOW('2', 4, int)
+
+/*
+ *      I2O Function codes
+ */
+
+/*
+ *      Executive Class
+ */
+#define I2O_CMD_ADAPTER_ASSIGN          0xB3
+#define I2O_CMD_ADAPTER_READ            0xB2
+#define I2O_CMD_ADAPTER_RELEASE         0xB5
+#define I2O_CMD_BIOS_INFO_SET           0xA5
+#define I2O_CMD_BOOT_DEVICE_SET         0xA7
+#define I2O_CMD_CONFIG_VALIDATE         0xBB
+#define I2O_CMD_CONN_SETUP              0xCA
+#define I2O_CMD_DDM_DESTROY             0xB1
+#define I2O_CMD_DDM_ENABLE              0xD5
+#define I2O_CMD_DDM_QUIESCE             0xC7
+#define I2O_CMD_DDM_RESET               0xD9
+#define I2O_CMD_DDM_SUSPEND             0xAF
+#define I2O_CMD_DEVICE_ASSIGN           0xB7
+#define I2O_CMD_DEVICE_RELEASE          0xB9
+#define I2O_CMD_HRT_GET                 0xA8
+#define I2O_CMD_ADAPTER_CLEAR           0xBE
+#define I2O_CMD_ADAPTER_CONNECT         0xC9
+#define I2O_CMD_ADAPTER_RESET           0xBD
+#define I2O_CMD_LCT_NOTIFY              0xA2
+#define I2O_CMD_OUTBOUND_INIT           0xA1
+#define I2O_CMD_PATH_ENABLE             0xD3
+#define I2O_CMD_PATH_QUIESCE            0xC5
+#define I2O_CMD_PATH_RESET              0xD7
+#define I2O_CMD_STATIC_MF_CREATE        0xDD
+#define I2O_CMD_STATIC_MF_RELEASE       0xDF
+#define I2O_CMD_STATUS_GET              0xA0
+#define I2O_CMD_SW_DOWNLOAD             0xA9
+#define I2O_CMD_SW_UPLOAD               0xAB
+#define I2O_CMD_SW_REMOVE               0xAD
+#define I2O_CMD_SYS_ENABLE              0xD1
+#define I2O_CMD_SYS_MODIFY              0xC1
+#define I2O_CMD_SYS_QUIESCE             0xC3
+#define I2O_CMD_SYS_TAB_SET             0xA3
+
+/*
+ * Utility Class
+ */
+#define I2O_CMD_UTIL_NOP                0x00
+#define I2O_CMD_UTIL_ABORT              0x01
+#define I2O_CMD_UTIL_CLAIM              0x09
+#define I2O_CMD_UTIL_RELEASE            0x0B
+#define I2O_CMD_UTIL_PARAMS_GET         0x06
+#define I2O_CMD_UTIL_PARAMS_SET         0x05
+#define I2O_CMD_UTIL_EVT_REGISTER       0x13
+#define I2O_CMD_UTIL_EVT_ACK            0x14
+#define I2O_CMD_UTIL_CONFIG_DIALOG      0x10
+#define I2O_CMD_UTIL_DEVICE_RESERVE     0x0D
+#define I2O_CMD_UTIL_DEVICE_RELEASE     0x0F
+#define I2O_CMD_UTIL_LOCK               0x17
+#define I2O_CMD_UTIL_LOCK_RELEASE       0x19
+#define I2O_CMD_UTIL_REPLY_FAULT_NOTIFY 0x15
+
+/*
+ * SCSI Host Bus Adapter Class
+ */
+#define I2O_CMD_SCSI_EXEC               0x81
+#define I2O_CMD_SCSI_ABORT              0x83
+#define I2O_CMD_SCSI_BUSRESET           0x27
+
+/*
+ * Random Block Storage Class
+ */
+#define I2O_CMD_BLOCK_READ              0x30
+#define I2O_CMD_BLOCK_WRITE             0x31
+#define I2O_CMD_BLOCK_CFLUSH            0x37
+#define I2O_CMD_BLOCK_MLOCK             0x49
+#define I2O_CMD_BLOCK_MUNLOCK           0x4B
+#define I2O_CMD_BLOCK_MMOUNT            0x41
+#define I2O_CMD_BLOCK_MEJECT            0x43
+#define I2O_CMD_BLOCK_POWER             0x70
+
+#define I2O_PRIVATE_MSG                 0xFF
+
+/* Command status values  */
+
+#define I2O_CMD_IN_PROGRESS     0x01
+#define I2O_CMD_REJECTED        0x02
+#define I2O_CMD_FAILED          0x03
+#define I2O_CMD_COMPLETED       0x04
+
+/* I2O API function return values */
+
+#define I2O_RTN_NO_ERROR                        0
+#define I2O_RTN_NOT_INIT                        1
+#define I2O_RTN_FREE_Q_EMPTY                    2
+#define I2O_RTN_TCB_ERROR                       3
+#define I2O_RTN_TRANSACTION_ERROR               4
+#define I2O_RTN_ADAPTER_ALREADY_INIT            5
+#define I2O_RTN_MALLOC_ERROR                    6
+#define I2O_RTN_ADPTR_NOT_REGISTERED            7
+#define I2O_RTN_MSG_REPLY_TIMEOUT               8
+#define I2O_RTN_NO_STATUS                       9
+#define I2O_RTN_NO_FIRM_VER                     10
+#define I2O_RTN_NO_LINK_SPEED                   11
+
+/* Reply message status defines for all messages */
+
+#define I2O_REPLY_STATUS_SUCCESS                        0x00
+#define I2O_REPLY_STATUS_ABORT_DIRTY                    0x01
+#define I2O_REPLY_STATUS_ABORT_NO_DATA_TRANSFER         0x02
+#define I2O_REPLY_STATUS_ABORT_PARTIAL_TRANSFER         0x03
+#define I2O_REPLY_STATUS_ERROR_DIRTY                    0x04
+#define I2O_REPLY_STATUS_ERROR_NO_DATA_TRANSFER         0x05
+#define I2O_REPLY_STATUS_ERROR_PARTIAL_TRANSFER         0x06
+#define I2O_REPLY_STATUS_PROCESS_ABORT_DIRTY            0x08
+#define I2O_REPLY_STATUS_PROCESS_ABORT_NO_DATA_TRANSFER 0x09
+#define I2O_REPLY_STATUS_PROCESS_ABORT_PARTIAL_TRANSFER 0x0A
+#define I2O_REPLY_STATUS_TRANSACTION_ERROR              0x0B
+#define I2O_REPLY_STATUS_PROGRESS_REPORT                0x80
+
+/* Status codes and Error Information for Parameter functions */
+
+#define I2O_PARAMS_STATUS_SUCCESS               0x00
+#define I2O_PARAMS_STATUS_BAD_KEY_ABORT         0x01
+#define I2O_PARAMS_STATUS_BAD_KEY_CONTINUE      0x02
+#define I2O_PARAMS_STATUS_BUFFER_FULL           0x03
+#define I2O_PARAMS_STATUS_BUFFER_TOO_SMALL      0x04
+#define I2O_PARAMS_STATUS_FIELD_UNREADABLE      0x05
+#define I2O_PARAMS_STATUS_FIELD_UNWRITEABLE     0x06
+#define I2O_PARAMS_STATUS_INSUFFICIENT_FIELDS   0x07
+#define I2O_PARAMS_STATUS_INVALID_GROUP_ID      0x08
+#define I2O_PARAMS_STATUS_INVALID_OPERATION     0x09
+#define I2O_PARAMS_STATUS_NO_KEY_FIELD          0x0A
+#define I2O_PARAMS_STATUS_NO_SUCH_FIELD         0x0B
+#define I2O_PARAMS_STATUS_NON_DYNAMIC_GROUP     0x0C
+#define I2O_PARAMS_STATUS_OPERATION_ERROR       0x0D
+#define I2O_PARAMS_STATUS_SCALAR_ERROR          0x0E
+#define I2O_PARAMS_STATUS_TABLE_ERROR           0x0F
+#define I2O_PARAMS_STATUS_WRONG_GROUP_TYPE      0x10
+
+/* DetailedStatusCode defines for Executive, DDM, Util and Transaction error
+ * messages: Table 3-2 Detailed Status Codes.*/
+
+#define I2O_DSC_SUCCESS                        0x0000
+#define I2O_DSC_BAD_KEY                        0x0002
+#define I2O_DSC_TCL_ERROR                      0x0003
+#define I2O_DSC_REPLY_BUFFER_FULL              0x0004
+#define I2O_DSC_NO_SUCH_PAGE                   0x0005
+#define I2O_DSC_INSUFFICIENT_RESOURCE_SOFT     0x0006
+#define I2O_DSC_INSUFFICIENT_RESOURCE_HARD     0x0007
+#define I2O_DSC_CHAIN_BUFFER_TOO_LARGE         0x0009
+#define I2O_DSC_UNSUPPORTED_FUNCTION           0x000A
+#define I2O_DSC_DEVICE_LOCKED                  0x000B
+#define I2O_DSC_DEVICE_RESET                   0x000C
+#define I2O_DSC_INAPPROPRIATE_FUNCTION         0x000D
+#define I2O_DSC_INVALID_INITIATOR_ADDRESS      0x000E
+#define I2O_DSC_INVALID_MESSAGE_FLAGS          0x000F
+#define I2O_DSC_INVALID_OFFSET                 0x0010
+#define I2O_DSC_INVALID_PARAMETER              0x0011
+#define I2O_DSC_INVALID_REQUEST                0x0012
+#define I2O_DSC_INVALID_TARGET_ADDRESS         0x0013
+#define I2O_DSC_MESSAGE_TOO_LARGE              0x0014
+#define I2O_DSC_MESSAGE_TOO_SMALL              0x0015
+#define I2O_DSC_MISSING_PARAMETER              0x0016
+#define I2O_DSC_TIMEOUT                        0x0017
+#define I2O_DSC_UNKNOWN_ERROR                  0x0018
+#define I2O_DSC_UNKNOWN_FUNCTION               0x0019
+#define I2O_DSC_UNSUPPORTED_VERSION            0x001A
+#define I2O_DSC_DEVICE_BUSY                    0x001B
+#define I2O_DSC_DEVICE_NOT_AVAILABLE           0x001C
+
+/* DetailedStatusCode defines for Block Storage Operation: Table 6-7 Detailed
+   Status Codes.*/
+
+#define I2O_BSA_DSC_SUCCESS               0x0000
+#define I2O_BSA_DSC_MEDIA_ERROR           0x0001
+#define I2O_BSA_DSC_ACCESS_ERROR          0x0002
+#define I2O_BSA_DSC_DEVICE_FAILURE        0x0003
+#define I2O_BSA_DSC_DEVICE_NOT_READY      0x0004
+#define I2O_BSA_DSC_MEDIA_NOT_PRESENT     0x0005
+#define I2O_BSA_DSC_MEDIA_LOCKED          0x0006
+#define I2O_BSA_DSC_MEDIA_FAILURE         0x0007
+#define I2O_BSA_DSC_PROTOCOL_FAILURE      0x0008
+#define I2O_BSA_DSC_BUS_FAILURE           0x0009
+#define I2O_BSA_DSC_ACCESS_VIOLATION      0x000A
+#define I2O_BSA_DSC_WRITE_PROTECTED       0x000B
+#define I2O_BSA_DSC_DEVICE_RESET          0x000C
+#define I2O_BSA_DSC_VOLUME_CHANGED        0x000D
+#define I2O_BSA_DSC_TIMEOUT               0x000E
+
+/* FailureStatusCodes, Table 3-3 Message Failure Codes */
+
+#define I2O_FSC_TRANSPORT_SERVICE_SUSPENDED             0x81
+#define I2O_FSC_TRANSPORT_SERVICE_TERMINATED            0x82
+#define I2O_FSC_TRANSPORT_CONGESTION                    0x83
+#define I2O_FSC_TRANSPORT_FAILURE                       0x84
+#define I2O_FSC_TRANSPORT_STATE_ERROR                   0x85
+#define I2O_FSC_TRANSPORT_TIME_OUT                      0x86
+#define I2O_FSC_TRANSPORT_ROUTING_FAILURE               0x87
+#define I2O_FSC_TRANSPORT_INVALID_VERSION               0x88
+#define I2O_FSC_TRANSPORT_INVALID_OFFSET                0x89
+#define I2O_FSC_TRANSPORT_INVALID_MSG_FLAGS             0x8A
+#define I2O_FSC_TRANSPORT_FRAME_TOO_SMALL               0x8B
+#define I2O_FSC_TRANSPORT_FRAME_TOO_LARGE               0x8C
+#define I2O_FSC_TRANSPORT_INVALID_TARGET_ID             0x8D
+#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_ID          0x8E
+#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_CONTEXT     0x8F
+#define I2O_FSC_TRANSPORT_UNKNOWN_FAILURE               0xFF
+
+/* Device Claim Types */
+#define I2O_CLAIM_PRIMARY                                       0x01000000
+#define I2O_CLAIM_MANAGEMENT                                    0x02000000
+#define I2O_CLAIM_AUTHORIZED                                    0x03000000
+#define I2O_CLAIM_SECONDARY                                     0x04000000
+
+/* Message header defines for VersionOffset */
+#define I2OVER15        0x0001
+#define I2OVER20        0x0002
+
+/* Default is 1.5, FIXME: Need support for both 1.5 and 2.0 */
+#define I2OVERSION      I2OVER15
+
+#define SGL_OFFSET_0    I2OVERSION
+#define SGL_OFFSET_4    (0x0040 | I2OVERSION)
+#define SGL_OFFSET_5    (0x0050 | I2OVERSION)
+#define SGL_OFFSET_6    (0x0060 | I2OVERSION)
+#define SGL_OFFSET_7    (0x0070 | I2OVERSION)
+#define SGL_OFFSET_8    (0x0080 | I2OVERSION)
+#define SGL_OFFSET_9    (0x0090 | I2OVERSION)
+#define SGL_OFFSET_10   (0x00A0 | I2OVERSION)
+
+#define TRL_OFFSET_5    (0x0050 | I2OVERSION)
+#define TRL_OFFSET_6    (0x0060 | I2OVERSION)
+
+/* Transaction Reply Lists (TRL) Control Word structure */
+#define TRL_SINGLE_FIXED_LENGTH         0x00
+#define TRL_SINGLE_VARIABLE_LENGTH      0x40
+#define TRL_MULTIPLE_FIXED_LENGTH       0x80
+
+ /* msg header defines for MsgFlags */
+#define MSG_STATIC      0x0100
+#define MSG_64BIT_CNTXT 0x0200
+#define MSG_MULTI_TRANS 0x1000
+#define MSG_FAIL        0x2000
+#define MSG_FINAL       0x4000
+#define MSG_REPLY       0x8000
+
+ /* minimum size msg */
+#define THREE_WORD_MSG_SIZE     0x00030000
+#define FOUR_WORD_MSG_SIZE      0x00040000
+#define FIVE_WORD_MSG_SIZE      0x00050000
+#define SIX_WORD_MSG_SIZE       0x00060000
+#define SEVEN_WORD_MSG_SIZE     0x00070000
+#define EIGHT_WORD_MSG_SIZE     0x00080000
+#define NINE_WORD_MSG_SIZE      0x00090000
+#define TEN_WORD_MSG_SIZE       0x000A0000
+#define ELEVEN_WORD_MSG_SIZE    0x000B0000
+#define I2O_MESSAGE_SIZE(x)     ((x)<<16)
+
+/* Special TID Assignments */
+
+#define ADAPTER_TID             0
+#define HOST_TID                1
+
+#define MSG_FRAME_SIZE          128     /* i2o_scsi assumes >= 32 */
+#define REPLY_FRAME_SIZE        17
+#define SG_TABLESIZE            30
+#define NMBR_MSG_FRAMES         128
+
+#define MSG_POOL_SIZE           (MSG_FRAME_SIZE*NMBR_MSG_FRAMES*sizeof(u32))
+
+#define I2O_POST_WAIT_OK        0
+#define I2O_POST_WAIT_TIMEOUT   -ETIMEDOUT
+
+#define I2O_CONTEXT_LIST_MIN_LENGTH     15
+#define I2O_CONTEXT_LIST_USED           0x01
+#define I2O_CONTEXT_LIST_DELETED        0x02
+
+/* timeouts */
+#define I2O_TIMEOUT_INIT_OUTBOUND_QUEUE 15
+#define I2O_TIMEOUT_MESSAGE_GET         5
+#define I2O_TIMEOUT_RESET               30
+#define I2O_TIMEOUT_STATUS_GET          5
+#define I2O_TIMEOUT_LCT_GET             360
+#define I2O_TIMEOUT_SCSI_SCB_ABORT      240
+
+/* retries */
+#define I2O_HRT_GET_TRIES               3
+#define I2O_LCT_GET_TRIES               3
+
+/* request queue sizes */
+#define I2O_MAX_SECTORS                 1024
+#define I2O_MAX_SEGMENTS                128
+
+#define I2O_REQ_MEMPOOL_SIZE            32
+
+#endif                          /* __KERNEL__ */
+#endif                          /* _I2O_H */
diff --git a/include/linux/i8k.h b/include/linux/i8k.h
new file mode 100644
index 000000000000..1c45ba505115
--- /dev/null
+++ b/include/linux/i8k.h
@@ -0,0 +1,46 @@
+/*
+ * i8k.h -- Linux driver for accessing the SMM BIOS on Dell laptops
+ *
+ * Copyright (C) 2001  Massimo Dal Zotto <dz@debian.org>
+ *
+ * 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; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#ifndef _LINUX_I8K_H
+#define _LINUX_I8K_H
+
+#define I8K_PROC                "/proc/i8k"
+#define I8K_PROC_FMT            "1.0"
+
+#define I8K_BIOS_VERSION        _IOR ('i', 0x80, int)   /* broken: meant 4 bytes */
+#define I8K_MACHINE_ID          _IOR ('i', 0x81, int)   /* broken: meant 16 bytes */
+#define I8K_POWER_STATUS        _IOR ('i', 0x82, size_t)
+#define I8K_FN_STATUS           _IOR ('i', 0x83, size_t)
+#define I8K_GET_TEMP            _IOR ('i', 0x84, size_t)
+#define I8K_GET_SPEED           _IOWR('i', 0x85, size_t)
+#define I8K_GET_FAN             _IOWR('i', 0x86, size_t)
+#define I8K_SET_FAN             _IOWR('i', 0x87, size_t)
+
+#define I8K_FAN_LEFT            1
+#define I8K_FAN_RIGHT           0
+#define I8K_FAN_OFF             0
+#define I8K_FAN_LOW             1
+#define I8K_FAN_HIGH            2
+#define I8K_FAN_MAX             I8K_FAN_HIGH
+
+#define I8K_VOL_UP              1
+#define I8K_VOL_DOWN            2
+#define I8K_VOL_MUTE            4
+
+#define I8K_AC                  1
+#define I8K_BATTERY             0
+
+#endif
diff --git a/include/linux/ibmtr.h b/include/linux/ibmtr.h
new file mode 100644
index 000000000000..2ef0b21517fb
--- /dev/null
+++ b/include/linux/ibmtr.h
@@ -0,0 +1,373 @@
+#ifndef __LINUX_IBMTR_H__
+#define __LINUX_IBMTR_H__
+
+/* Definitions for an IBM Token Ring card. */
+/* This file is distributed under the GNU GPL   */
+
+/* ported to the Alpha architecture 02/20/96 (just used the HZ macro) */
+
+#define TR_RETRY_INTERVAL       (30*HZ) /* 500 on PC = 5 s */
+#define TR_RST_TIME             (HZ/20) /* 5 on PC = 50 ms */
+#define TR_BUSY_INTERVAL        (HZ/5)  /* 5 on PC = 200 ms */
+#define TR_SPIN_INTERVAL        (3*HZ)  /* 3 seconds before init timeout */
+
+#define TR_ISA 1
+#define TR_MCA 2
+#define TR_ISAPNP 3
+#define NOTOK 0
+
+#define IBMTR_SHARED_RAM_SIZE 0x10000
+#define IBMTR_IO_EXTENT 4
+#define IBMTR_MAX_ADAPTERS 4
+
+#define CHANNEL_ID      0X1F30
+#define AIP             0X1F00
+#define AIPADAPTYPE     0X1FA0
+#define AIPDATARATE     0X1FA2
+#define AIPEARLYTOKEN   0X1FA4
+#define AIPAVAILSHRAM   0X1FA6
+#define AIPSHRAMPAGE    0X1FA8
+#define AIP4MBDHB       0X1FAA
+#define AIP16MBDHB      0X1FAC
+#define AIPFID          0X1FBA
+
+#define ADAPTRESET      0x1     /* Control Adapter reset (add to base) */
+#define ADAPTRESETREL   0x2     /* Release Adapter from reset ( """)  */
+#define ADAPTINTREL     0x3     /* Adapter interrupt release */
+
+#define GLOBAL_INT_ENABLE 0x02f0
+
+/* MMIO bits 0-4 select register */
+#define RRR_EVEN       0x00 /* Shared RAM relocation registers - even and odd */
+/* Used to set the starting address of shared RAM  */
+/* Bits 1 through 7 of this register map to bits 13 through 19 of the shared
+   RAM address.*/
+/* ie: 0x02 sets RAM address to ...ato!  issy su wazzoo !! GODZILLA!!! */
+#define RRR_ODD         0x01
+/* Bits 2 and 3 of this register can be read to determine shared RAM size */
+/* 00 for 8k, 01 for 16k, 10 for 32k, 11 for 64k  */
+#define WRBR_EVEN       0x02    /* Write region base registers - even and odd */
+#define WRBR_ODD        0x03
+#define WWOR_EVEN       0x04    /* Write window open registers - even and odd */
+#define WWOR_ODD        0x05
+#define WWCR_EVEN       0x06   /* Write window close registers - even and odd */
+#define WWCR_ODD        0x07
+
+/* Interrupt status registers - PC system  - even and odd */
+#define ISRP_EVEN       0x08
+
+#define TCR_INT    0x10    /* Bit 4 - Timer interrupt.  The TVR_EVEN timer has
+                                                                   expired. */
+#define ERR_INT    0x08    /* Bit 3 - Error interrupt.  The adapter has had an
+                                                            internal error. */
+#define ACCESS_INT 0x04    /* Bit 2 - Access interrupt.  You have attempted to
+                                      write to an invalid area of shared RAM
+                                      or an invalid register within the MMIO. */
+/* In addition, the following bits within ISRP_EVEN can be turned on or off   */
+/* by you to control the interrupt processing:   */
+#define INT_ENABLE 0x40 /* Bit 6 - Interrupt enable.  If 0, no interrupts will
+                                   occur.  If 1, interrupts will occur normally.
+                                                         Normally set to 1.  */
+/* Bit 0 - Primary or alternate adapter.  Set to zero if this adapter is the
+                primary adapter, 1 if this adapter is the alternate adapter. */
+
+
+#define ISRP_ODD        0x09
+
+#define ADAP_CHK_INT 0x40 /* Bit 6 - Adapter check.  the adapter has
+                             encountered a serious problem and has closed
+                             itself.  Whoa.  */
+#define SRB_RESP_INT 0x20 /* Bit 5 - SRB response.  The adapter has accepted
+                             an SRB request and set the return code within
+                             the SRB. */
+#define ASB_FREE_INT 0x10 /* Bit 4 - ASB free.  The adapter has read the ASB
+                             and this area can be safely reused. This interrupt
+                             is only used if your application has set the ASB
+                             free request bit in ISRA_ODD or if an error was
+                             detected in your response. */
+#define ARB_CMD_INT  0x08 /* Bit 3 - ARB command.  The adapter has given you a
+                             command for action.  The command is located in the
+                             ARB area of shared memory. */
+#define SSB_RESP_INT 0x04 /* Bit 2 - SSB response.  The adapter has posted a
+                             response to your SRB (the response is located in
+                             the SSB area of shared memory). */
+/* Bit 1 - Bridge frame forward complete. */
+
+
+
+#define ISRA_EVEN 0x0A /*Interrupt status registers - adapter  - even and odd */
+/* Bit 7 - Internal parity error (on adapter's internal bus) */
+/* Bit 6 - Timer interrupt pending */
+/* Bit 5 - Access interrupt (attempt by adapter to access illegal address) */
+/* Bit 4 - Adapter microcode problem (microcode dead-man timer expired) */
+/* Bit 3 - Adapter processor check status */
+/* Bit 2 - Reserved */
+/* Bit 1 - Adapter hardware interrupt mask (prevents internal interrupts) */
+/* Bit 0 - Adapter software interrupt mask (prevents internal software ints) */
+
+#define ISRA_ODD        0x0B
+#define CMD_IN_SRB  0x20 /* Bit 5  - Indicates that you have placed a new
+                           command in the SRB and are ready for the adapter to
+                           process the command. */
+#define RESP_IN_ASB 0x10 /* Bit 4 - Indicates that you have placed a response
+                            (an ASB) in the shared RAM which is available for
+                            the adapter's use. */
+/* Bit 3 - Indicates that you are ready to put an SRB in the shared RAM, but
+        that a previous command is still pending.  The adapter will then
+        interrupt you when the previous command is completed */
+/* Bit 2 - Indicates that you are ready to put an ASB in the shared RAM, but
+        that a previous ASB is still pending.  The adapter will then interrupt
+        you when the previous ASB is copied.  */
+#define ARB_FREE 0x2
+#define SSB_FREE 0x1
+
+#define TCR_EVEN        0x0C    /* Timer control registers - even and odd */
+#define TCR_ODD         0x0D
+#define TVR_EVEN        0x0E    /* Timer value registers - even and odd */
+#define TVR_ODD         0x0F
+#define SRPR_EVEN       0x18    /* Shared RAM paging registers - even and odd */
+#define SRPR_ENABLE_PAGING 0xc0
+#define SRPR_ODD        0x19    /* Not used. */
+#define TOKREAD         0x60
+#define TOKOR           0x40
+#define TOKAND          0x20
+#define TOKWRITE        0x00
+
+/* MMIO bits 5-6 select operation */
+/* 00 is used to write to a register */
+/* 01 is used to bitwise AND a byte with a register */
+/* 10 is used to bitwise OR a byte with a register  */
+/* 11 is used to read from a register */
+
+/* MMIO bits 7-8 select area of interest.. see below */
+/* 00 selects attachment control area. */
+/* 01 is reserved. */
+/* 10 selects adapter identification area A containing the adapter encoded
+        address. */
+/* 11 selects the adapter identification area B containing test patterns. */
+
+#define PCCHANNELID 5049434F3631313039393020
+#define MCCHANNELID 4D4152533633583435313820
+
+#define ACA_OFFSET 0x1e00
+#define ACA_SET 0x40
+#define ACA_RESET 0x20
+#define ACA_RW 0x00
+
+#ifdef ENABLE_PAGING
+#define SET_PAGE(x) (writeb((x), ti->mmio + ACA_OFFSET+ ACA_RW + SRPR_EVEN))
+#else
+#define SET_PAGE(x)
+#endif
+
+/* do_tok_int possible values */
+#define FIRST_INT 1
+#define NOT_FIRST 2
+
+typedef enum {  CLOSED, OPEN } open_state;
+//staic const char *printstate[] = { "CLOSED","OPEN"};
+
+struct tok_info {
+        unsigned char irq;
+        void __iomem *mmio;
+        unsigned char hw_address[32];
+        unsigned char adapter_type;
+        unsigned char data_rate;
+        unsigned char token_release;
+        unsigned char avail_shared_ram;
+        unsigned char shared_ram_paging;
+        unsigned char turbo;
+        unsigned short dhb_size4mb;
+        unsigned short rbuf_len4;
+        unsigned short rbuf_cnt4;
+        unsigned short maxmtu4;
+        unsigned short dhb_size16mb;
+        unsigned short rbuf_len16;
+        unsigned short rbuf_cnt16;
+        unsigned short maxmtu16;
+        /* Additions by David Morris       */
+        unsigned char do_tok_int;
+        wait_queue_head_t wait_for_reset;
+        unsigned char sram_base;
+        /* Additions by Peter De Schrijver */
+        unsigned char page_mask;          /* mask to select RAM page to Map*/
+        unsigned char mapped_ram_size;    /* size of RAM page */
+        __u32 sram_phys;          /* Shared memory base address */
+        void __iomem *sram_virt;          /* Shared memory base address */
+        void __iomem *init_srb;   /* Initial System Request Block address */
+        void __iomem *srb;                /* System Request Block address */
+        void __iomem *ssb;                /* System Status Block address */
+        void __iomem *arb;                /* Adapter Request Block address */
+        void __iomem *asb;                /* Adapter Status Block address */
+        __u8  init_srb_page;
+        __u8  srb_page;
+        __u8  ssb_page;
+        __u8  arb_page;
+        __u8  asb_page;
+        unsigned short exsap_station_id;
+        unsigned short global_int_enable;
+        struct sk_buff *current_skb;
+        struct net_device_stats tr_stats;
+        unsigned char auto_speedsave;
+        open_state                      open_status, sap_status;
+        enum {MANUAL, AUTOMATIC}        open_mode;
+        enum {FAIL, RESTART, REOPEN}    open_action;
+        enum {NO, YES}                  open_failure;
+        unsigned char readlog_pending;
+        unsigned short adapter_int_enable; /* Adapter-specific int enable */
+        struct timer_list tr_timer;
+        unsigned char ring_speed;
+        spinlock_t lock;                /* SMP protection */
+};
+
+/* token ring adapter commands */
+#define DIR_INTERRUPT           0x00 /* struct srb_interrupt */
+#define DIR_MOD_OPEN_PARAMS     0x01
+#define DIR_OPEN_ADAPTER        0x03 /* struct dir_open_adapter */
+#define DIR_CLOSE_ADAPTER       0x04
+#define DIR_SET_GRP_ADDR        0x06
+#define DIR_SET_FUNC_ADDR       0x07 /* struct srb_set_funct_addr */
+#define DIR_READ_LOG            0x08 /* struct srb_read_log */
+#define DLC_OPEN_SAP            0x15 /* struct dlc_open_sap */
+#define DLC_CLOSE_SAP           0x16
+#define DATA_LOST               0x20 /* struct asb_rec */
+#define REC_DATA                0x81 /* struct arb_rec_req */
+#define XMIT_DATA_REQ           0x82 /* struct arb_xmit_req */
+#define DLC_STATUS              0x83 /* struct arb_dlc_status */
+#define RING_STAT_CHANGE        0x84 /* struct dlc_open_sap ??? */
+
+/* DIR_OPEN_ADAPTER options */
+#define OPEN_PASS_BCON_MAC 0x0100
+#define NUM_RCV_BUF 2
+#define RCV_BUF_LEN 1024
+#define DHB_LENGTH 2048
+#define NUM_DHB 2
+#define DLC_MAX_SAP 2
+#define DLC_MAX_STA 1
+
+/* DLC_OPEN_SAP options */
+#define MAX_I_FIELD 0x0088
+#define SAP_OPEN_IND_SAP 0x04
+#define SAP_OPEN_PRIORITY 0x20
+#define SAP_OPEN_STATION_CNT 0x1
+#define XMIT_DIR_FRAME 0x0A
+#define XMIT_UI_FRAME  0x0d
+#define XMIT_XID_CMD   0x0e
+#define XMIT_TEST_CMD  0x11
+
+/* srb close return code */
+#define SIGNAL_LOSS  0x8000
+#define HARD_ERROR   0x4000
+#define XMIT_BEACON  0x1000
+#define LOBE_FAULT   0x0800
+#define AUTO_REMOVAL 0x0400
+#define REMOVE_RECV  0x0100
+#define LOG_OVERFLOW 0x0080
+#define RING_RECOVER 0x0020
+
+struct srb_init_response {
+        unsigned char command;
+        unsigned char init_status;
+        unsigned char init_status_2;
+        unsigned char reserved[3];
+        __u16 bring_up_code;
+        __u16 encoded_address;
+        __u16 level_address;
+        __u16 adapter_address;
+        __u16 parms_address;
+        __u16 mac_address;
+};
+
+struct dir_open_adapter {
+        unsigned char command;
+        char reserved[7];
+        __u16 open_options;
+        unsigned char node_address[6];
+        unsigned char group_address[4];
+        unsigned char funct_address[4];
+        __u16 num_rcv_buf;
+        __u16 rcv_buf_len;
+        __u16 dhb_length;
+        unsigned char num_dhb;
+        char reserved2;
+        unsigned char dlc_max_sap;
+        unsigned char dlc_max_sta;
+        unsigned char dlc_max_gsap;
+        unsigned char dlc_max_gmem;
+        unsigned char dlc_t1_tick_1;
+        unsigned char dlc_t2_tick_1;
+        unsigned char dlc_ti_tick_1;
+        unsigned char dlc_t1_tick_2;
+        unsigned char dlc_t2_tick_2;
+        unsigned char dlc_ti_tick_2;
+        unsigned char product_id[18];
+};
+
+struct dlc_open_sap {
+        unsigned char command;
+        unsigned char reserved1;
+        unsigned char ret_code;
+        unsigned char reserved2;
+        __u16 station_id;
+        unsigned char timer_t1;
+        unsigned char timer_t2;
+        unsigned char timer_ti;
+        unsigned char maxout;
+        unsigned char maxin;
+        unsigned char maxout_incr;
+        unsigned char max_retry_count;
+        unsigned char gsap_max_mem;
+        __u16 max_i_field;
+        unsigned char sap_value;
+        unsigned char sap_options;
+        unsigned char station_count;
+        unsigned char sap_gsap_mem;
+        unsigned char gsap[0];
+};
+
+struct srb_xmit {
+        unsigned char command;
+        unsigned char cmd_corr;
+        unsigned char ret_code;
+        unsigned char reserved1;
+        __u16 station_id;
+};
+
+struct arb_rec_req {
+        unsigned char command;
+        unsigned char reserved1[3];
+        __u16 station_id;
+        __u16 rec_buf_addr;
+        unsigned char lan_hdr_len;
+        unsigned char dlc_hdr_len;
+        __u16 frame_len;
+        unsigned char msg_type;
+};
+
+struct asb_rec {
+        unsigned char command;
+        unsigned char reserved1;
+        unsigned char ret_code;
+        unsigned char reserved2;
+        __u16 station_id;
+        __u16 rec_buf_addr;
+};
+
+struct rec_buf {
+        unsigned char reserved1[2];
+        __u16 buf_ptr;
+        unsigned char reserved2;
+        unsigned char receive_fs;
+        __u16 buf_len;
+        unsigned char data[0];
+};
+
+struct srb_set_funct_addr {
+        unsigned char command;
+        unsigned char reserved1;
+        unsigned char ret_code;
+        unsigned char reserved2[3];
+        unsigned char funct_address[4];
+};
+
+#endif
diff --git a/include/linux/icmp.h b/include/linux/icmp.h
new file mode 100644
index 000000000000..f0b571f1060b
--- /dev/null
+++ b/include/linux/icmp.h
@@ -0,0 +1,96 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the ICMP protocol.
+ *
+ * Version:     @(#)icmp.h      1.0.3   04/28/93
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_ICMP_H
+#define _LINUX_ICMP_H
+
+#include <linux/types.h>
+
+#define ICMP_ECHOREPLY          0       /* Echo Reply                   */
+#define ICMP_DEST_UNREACH       3       /* Destination Unreachable      */
+#define ICMP_SOURCE_QUENCH      4       /* Source Quench                */
+#define ICMP_REDIRECT           5       /* Redirect (change route)      */
+#define ICMP_ECHO               8       /* Echo Request                 */
+#define ICMP_TIME_EXCEEDED      11      /* Time Exceeded                */
+#define ICMP_PARAMETERPROB      12      /* Parameter Problem            */
+#define ICMP_TIMESTAMP          13      /* Timestamp Request            */
+#define ICMP_TIMESTAMPREPLY     14      /* Timestamp Reply              */
+#define ICMP_INFO_REQUEST       15      /* Information Request          */
+#define ICMP_INFO_REPLY         16      /* Information Reply            */
+#define ICMP_ADDRESS            17      /* Address Mask Request         */
+#define ICMP_ADDRESSREPLY       18      /* Address Mask Reply           */
+#define NR_ICMP_TYPES           18
+
+
+/* Codes for UNREACH. */
+#define ICMP_NET_UNREACH        0       /* Network Unreachable          */
+#define ICMP_HOST_UNREACH       1       /* Host Unreachable             */
+#define ICMP_PROT_UNREACH       2       /* Protocol Unreachable         */
+#define ICMP_PORT_UNREACH       3       /* Port Unreachable             */
+#define ICMP_FRAG_NEEDED        4       /* Fragmentation Needed/DF set  */
+#define ICMP_SR_FAILED          5       /* Source Route failed          */
+#define ICMP_NET_UNKNOWN        6
+#define ICMP_HOST_UNKNOWN       7
+#define ICMP_HOST_ISOLATED      8
+#define ICMP_NET_ANO            9
+#define ICMP_HOST_ANO           10
+#define ICMP_NET_UNR_TOS        11
+#define ICMP_HOST_UNR_TOS       12
+#define ICMP_PKT_FILTERED       13      /* Packet filtered */
+#define ICMP_PREC_VIOLATION     14      /* Precedence violation */
+#define ICMP_PREC_CUTOFF        15      /* Precedence cut off */
+#define NR_ICMP_UNREACH         15      /* instead of hardcoding immediate value */
+
+/* Codes for REDIRECT. */
+#define ICMP_REDIR_NET          0       /* Redirect Net                 */
+#define ICMP_REDIR_HOST         1       /* Redirect Host                */
+#define ICMP_REDIR_NETTOS       2       /* Redirect Net for TOS         */
+#define ICMP_REDIR_HOSTTOS      3       /* Redirect Host for TOS        */
+
+/* Codes for TIME_EXCEEDED. */
+#define ICMP_EXC_TTL            0       /* TTL count exceeded           */
+#define ICMP_EXC_FRAGTIME       1       /* Fragment Reass time exceeded */
+
+
+struct icmphdr {
+  __u8          type;
+  __u8          code;
+  __u16         checksum;
+  union {
+        struct {
+                __u16   id;
+                __u16   sequence;
+        } echo;
+        __u32   gateway;
+        struct {
+                __u16   __unused;
+                __u16   mtu;
+        } frag;
+  } un;
+};
+
+/*
+ *      constants for (set|get)sockopt
+ */
+
+#define ICMP_FILTER                     1
+
+struct icmp_filter {
+        __u32           data;
+};
+
+
+#endif  /* _LINUX_ICMP_H */
diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h
new file mode 100644
index 000000000000..0cf6c8b12caf
--- /dev/null
+++ b/include/linux/icmpv6.h
@@ -0,0 +1,171 @@
+#ifndef _LINUX_ICMPV6_H
+#define _LINUX_ICMPV6_H
+
+#include <asm/byteorder.h>
+
+struct icmp6hdr {
+
+        __u8            icmp6_type;
+        __u8            icmp6_code;
+        __u16           icmp6_cksum;
+
+
+        union {
+                __u32                   un_data32[1];
+                __u16                   un_data16[2];
+                __u8                    un_data8[4];
+
+                struct icmpv6_echo {
+                        __u16           identifier;
+                        __u16           sequence;
+                } u_echo;
+
+                struct icmpv6_nd_advt {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                        __u32           reserved:5,
+                                        override:1,
+                                        solicited:1,
+                                        router:1,
+                                        reserved2:24;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                        __u32           router:1,
+                                        solicited:1,
+                                        override:1,
+                                        reserved:29;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif                                          
+                } u_nd_advt;
+
+                struct icmpv6_nd_ra {
+                        __u8            hop_limit;
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                        __u8            reserved:6,
+                                        other:1,
+                                        managed:1;
+
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                        __u8            managed:1,
+                                        other:1,
+                                        reserved:6;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+                        __u16           rt_lifetime;
+                } u_nd_ra;
+
+        } icmp6_dataun;
+
+#define icmp6_identifier        icmp6_dataun.u_echo.identifier
+#define icmp6_sequence          icmp6_dataun.u_echo.sequence
+#define icmp6_pointer           icmp6_dataun.un_data32[0]
+#define icmp6_mtu               icmp6_dataun.un_data32[0]
+#define icmp6_unused            icmp6_dataun.un_data32[0]
+#define icmp6_maxdelay          icmp6_dataun.un_data16[0]
+#define icmp6_router            icmp6_dataun.u_nd_advt.router
+#define icmp6_solicited         icmp6_dataun.u_nd_advt.solicited
+#define icmp6_override          icmp6_dataun.u_nd_advt.override
+#define icmp6_ndiscreserved     icmp6_dataun.u_nd_advt.reserved
+#define icmp6_hop_limit         icmp6_dataun.u_nd_ra.hop_limit
+#define icmp6_addrconf_managed  icmp6_dataun.u_nd_ra.managed
+#define icmp6_addrconf_other    icmp6_dataun.u_nd_ra.other
+#define icmp6_rt_lifetime       icmp6_dataun.u_nd_ra.rt_lifetime
+};
+
+
+#define ICMPV6_DEST_UNREACH             1
+#define ICMPV6_PKT_TOOBIG               2
+#define ICMPV6_TIME_EXCEED              3
+#define ICMPV6_PARAMPROB                4
+
+#define ICMPV6_INFOMSG_MASK             0x80
+
+#define ICMPV6_ECHO_REQUEST             128
+#define ICMPV6_ECHO_REPLY               129
+#define ICMPV6_MGM_QUERY                130
+#define ICMPV6_MGM_REPORT               131
+#define ICMPV6_MGM_REDUCTION            132
+
+#define ICMPV6_NI_QUERY                 139
+#define ICMPV6_NI_REPLY                 140
+
+#define ICMPV6_MLD2_REPORT              143
+
+#define ICMPV6_DHAAD_REQUEST            144
+#define ICMPV6_DHAAD_REPLY              145
+#define ICMPV6_MOBILE_PREFIX_SOL        146
+#define ICMPV6_MOBILE_PREFIX_ADV        147
+
+/*
+ *      Codes for Destination Unreachable
+ */
+#define ICMPV6_NOROUTE                  0
+#define ICMPV6_ADM_PROHIBITED           1
+#define ICMPV6_NOT_NEIGHBOUR            2
+#define ICMPV6_ADDR_UNREACH             3
+#define ICMPV6_PORT_UNREACH             4
+
+/*
+ *      Codes for Time Exceeded
+ */
+#define ICMPV6_EXC_HOPLIMIT             0
+#define ICMPV6_EXC_FRAGTIME             1
+
+/*
+ *      Codes for Parameter Problem
+ */
+#define ICMPV6_HDR_FIELD                0
+#define ICMPV6_UNK_NEXTHDR              1
+#define ICMPV6_UNK_OPTION               2
+
+/*
+ *      constants for (set|get)sockopt
+ */
+
+#define ICMPV6_FILTER                   1
+
+/*
+ *      ICMPV6 filter
+ */
+
+#define ICMPV6_FILTER_BLOCK             1
+#define ICMPV6_FILTER_PASS              2
+#define ICMPV6_FILTER_BLOCKOTHERS       3
+#define ICMPV6_FILTER_PASSONLY          4
+
+struct icmp6_filter {
+        __u32           data[8];
+};
+
+/*
+ *      Definitions for MLDv2
+ */
+#define MLD2_MODE_IS_INCLUDE    1
+#define MLD2_MODE_IS_EXCLUDE    2
+#define MLD2_CHANGE_TO_INCLUDE  3
+#define MLD2_CHANGE_TO_EXCLUDE  4
+#define MLD2_ALLOW_NEW_SOURCES  5
+#define MLD2_BLOCK_OLD_SOURCES  6
+
+#define MLD2_ALL_MCR_INIT { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x16 } } }
+
+#ifdef __KERNEL__
+
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+
+
+extern void                             icmpv6_send(struct sk_buff *skb,
+                                                    int type, int code,
+                                                    __u32 info, 
+                                                    struct net_device *dev);
+
+extern int                              icmpv6_init(struct net_proto_family *ops);
+extern int                              icmpv6_err_convert(int type, int code,
+                                                           int *err);
+extern void                             icmpv6_cleanup(void);
+extern void                             icmpv6_param_prob(struct sk_buff *skb,
+                                                          int code, int pos);
+#endif
+
+#endif
diff --git a/include/linux/ide.h b/include/linux/ide.h
new file mode 100644
index 000000000000..9cfc0999becb
--- /dev/null
+++ b/include/linux/ide.h
@@ -0,0 +1,1516 @@
+#ifndef _IDE_H
+#define _IDE_H
+/*
+ *  linux/include/linux/ide.h
+ *
+ *  Copyright (C) 1994-2002  Linus Torvalds & authors
+ */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/hdreg.h>
+#include <linux/hdsmart.h>
+#include <linux/blkdev.h>
+#include <linux/proc_fs.h>
+#include <linux/interrupt.h>
+#include <linux/bitops.h>
+#include <linux/bio.h>
+#include <linux/device.h>
+#include <linux/pci.h>
+#include <asm/byteorder.h>
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/semaphore.h>
+
+/*
+ * This is the multiple IDE interface driver, as evolved from hd.c.
+ * It supports up to four IDE interfaces, on one or more IRQs (usually 14 & 15).
+ * There can be up to two drives per interface, as per the ATA-2 spec.
+ *
+ * Primary i/f:    ide0: major=3;  (hda)         minor=0; (hdb)         minor=64
+ * Secondary i/f:  ide1: major=22; (hdc or hd1a) minor=0; (hdd or hd1b) minor=64
+ * Tertiary i/f:   ide2: major=33; (hde)         minor=0; (hdf)         minor=64
+ * Quaternary i/f: ide3: major=34; (hdg)         minor=0; (hdh)         minor=64
+ */
+
+/******************************************************************************
+ * IDE driver configuration options (play with these as desired):
+ *
+ * REALLY_SLOW_IO can be defined in ide.c and ide-cd.c, if necessary
+ */
+#define INITIAL_MULT_COUNT      0       /* off=0; on=2,4,8,16,32, etc.. */
+
+#ifndef SUPPORT_SLOW_DATA_PORTS         /* 1 to support slow data ports */
+#define SUPPORT_SLOW_DATA_PORTS 1       /* 0 to reduce kernel size */
+#endif
+#ifndef SUPPORT_VLB_SYNC                /* 1 to support weird 32-bit chips */
+#define SUPPORT_VLB_SYNC        1       /* 0 to reduce kernel size */
+#endif
+#ifndef OK_TO_RESET_CONTROLLER          /* 1 needed for good error recovery */
+#define OK_TO_RESET_CONTROLLER  1       /* 0 for use with AH2372A/B interface */
+#endif
+
+#ifndef DISABLE_IRQ_NOSYNC
+#define DISABLE_IRQ_NOSYNC      0
+#endif
+
+/*
+ * Used to indicate "no IRQ", should be a value that cannot be an IRQ
+ * number.
+ */
+ 
+#define IDE_NO_IRQ              (-1)
+
+/*
+ *  "No user-serviceable parts" beyond this point  :)
+ *****************************************************************************/
+
+typedef unsigned char   byte;   /* used everywhere */
+
+/*
+ * Probably not wise to fiddle with these
+ */
+#define ERROR_MAX       8       /* Max read/write errors per sector */
+#define ERROR_RESET     3       /* Reset controller every 4th retry */
+#define ERROR_RECAL     1       /* Recalibrate every 2nd retry */
+
+/*
+ * Tune flags
+ */
+#define IDE_TUNE_NOAUTO         2
+#define IDE_TUNE_AUTO           1
+#define IDE_TUNE_DEFAULT        0
+
+/*
+ * state flags
+ */
+
+#define DMA_PIO_RETRY   1       /* retrying in PIO */
+
+#define HWIF(drive)             ((ide_hwif_t *)((drive)->hwif))
+#define HWGROUP(drive)          ((ide_hwgroup_t *)(HWIF(drive)->hwgroup))
+
+/*
+ * Definitions for accessing IDE controller registers
+ */
+#define IDE_NR_PORTS            (10)
+
+#define IDE_DATA_OFFSET         (0)
+#define IDE_ERROR_OFFSET        (1)
+#define IDE_NSECTOR_OFFSET      (2)
+#define IDE_SECTOR_OFFSET       (3)
+#define IDE_LCYL_OFFSET         (4)
+#define IDE_HCYL_OFFSET         (5)
+#define IDE_SELECT_OFFSET       (6)
+#define IDE_STATUS_OFFSET       (7)
+#define IDE_CONTROL_OFFSET      (8)
+#define IDE_IRQ_OFFSET          (9)
+
+#define IDE_FEATURE_OFFSET      IDE_ERROR_OFFSET
+#define IDE_COMMAND_OFFSET      IDE_STATUS_OFFSET
+
+#define IDE_CONTROL_OFFSET_HOB  (7)
+
+#define IDE_DATA_REG            (HWIF(drive)->io_ports[IDE_DATA_OFFSET])
+#define IDE_ERROR_REG           (HWIF(drive)->io_ports[IDE_ERROR_OFFSET])
+#define IDE_NSECTOR_REG         (HWIF(drive)->io_ports[IDE_NSECTOR_OFFSET])
+#define IDE_SECTOR_REG          (HWIF(drive)->io_ports[IDE_SECTOR_OFFSET])
+#define IDE_LCYL_REG            (HWIF(drive)->io_ports[IDE_LCYL_OFFSET])
+#define IDE_HCYL_REG            (HWIF(drive)->io_ports[IDE_HCYL_OFFSET])
+#define IDE_SELECT_REG          (HWIF(drive)->io_ports[IDE_SELECT_OFFSET])
+#define IDE_STATUS_REG          (HWIF(drive)->io_ports[IDE_STATUS_OFFSET])
+#define IDE_CONTROL_REG         (HWIF(drive)->io_ports[IDE_CONTROL_OFFSET])
+#define IDE_IRQ_REG             (HWIF(drive)->io_ports[IDE_IRQ_OFFSET])
+
+#define IDE_FEATURE_REG         IDE_ERROR_REG
+#define IDE_COMMAND_REG         IDE_STATUS_REG
+#define IDE_ALTSTATUS_REG       IDE_CONTROL_REG
+#define IDE_IREASON_REG         IDE_NSECTOR_REG
+#define IDE_BCOUNTL_REG         IDE_LCYL_REG
+#define IDE_BCOUNTH_REG         IDE_HCYL_REG
+
+#define OK_STAT(stat,good,bad)  (((stat)&((good)|(bad)))==(good))
+#define BAD_R_STAT              (BUSY_STAT   | ERR_STAT)
+#define BAD_W_STAT              (BAD_R_STAT  | WRERR_STAT)
+#define BAD_STAT                (BAD_R_STAT  | DRQ_STAT)
+#define DRIVE_READY             (READY_STAT  | SEEK_STAT)
+#define DATA_READY              (DRQ_STAT)
+
+#define BAD_CRC                 (ABRT_ERR    | ICRC_ERR)
+
+#define SATA_NR_PORTS           (3)     /* 16 possible ?? */
+
+#define SATA_STATUS_OFFSET      (0)
+#define SATA_STATUS_REG         (HWIF(drive)->sata_scr[SATA_STATUS_OFFSET])
+#define SATA_ERROR_OFFSET       (1)
+#define SATA_ERROR_REG          (HWIF(drive)->sata_scr[SATA_ERROR_OFFSET])
+#define SATA_CONTROL_OFFSET     (2)
+#define SATA_CONTROL_REG        (HWIF(drive)->sata_scr[SATA_CONTROL_OFFSET])
+
+#define SATA_MISC_OFFSET        (0)
+#define SATA_MISC_REG           (HWIF(drive)->sata_misc[SATA_MISC_OFFSET])
+#define SATA_PHY_OFFSET         (1)
+#define SATA_PHY_REG            (HWIF(drive)->sata_misc[SATA_PHY_OFFSET])
+#define SATA_IEN_OFFSET         (2)
+#define SATA_IEN_REG            (HWIF(drive)->sata_misc[SATA_IEN_OFFSET])
+
+/*
+ * Our Physical Region Descriptor (PRD) table should be large enough
+ * to handle the biggest I/O request we are likely to see.  Since requests
+ * can have no more than 256 sectors, and since the typical blocksize is
+ * two or more sectors, we could get by with a limit of 128 entries here for
+ * the usual worst case.  Most requests seem to include some contiguous blocks,
+ * further reducing the number of table entries required.
+ *
+ * The driver reverts to PIO mode for individual requests that exceed
+ * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling
+ * 100% of all crazy scenarios here is not necessary.
+ *
+ * As it turns out though, we must allocate a full 4KB page for this,
+ * so the two PRD tables (ide0 & ide1) will each get half of that,
+ * allowing each to have about 256 entries (8 bytes each) from this.
+ */
+#define PRD_BYTES       8
+#define PRD_ENTRIES     256
+
+/*
+ * Some more useful definitions
+ */
+#define PARTN_BITS      6       /* number of minor dev bits for partitions */
+#define MAX_DRIVES      2       /* per interface; 2 assumed by lots of code */
+#define SECTOR_SIZE     512
+#define SECTOR_WORDS    (SECTOR_SIZE / 4)       /* number of 32bit words per sector */
+#define IDE_LARGE_SEEK(b1,b2,t) (((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))
+
+/*
+ * Timeouts for various operations:
+ */
+#define WAIT_DRQ        (HZ/10)         /* 100msec - spec allows up to 20ms */
+#define WAIT_READY      (5*HZ)          /* 5sec - some laptops are very slow */
+#define WAIT_PIDENTIFY  (10*HZ) /* 10sec  - should be less than 3ms (?), if all ATAPI CD is closed at boot */
+#define WAIT_WORSTCASE  (30*HZ) /* 30sec  - worst case when spinning up */
+#define WAIT_CMD        (10*HZ) /* 10sec  - maximum wait for an IRQ to happen */
+#define WAIT_MIN_SLEEP  (2*HZ/100)      /* 20msec - minimum sleep time */
+
+#define HOST(hwif,chipset)                                      \
+{                                                               \
+        return ((hwif)->chipset == chipset) ? 1 : 0;            \
+}
+
+/*
+ * Check for an interrupt and acknowledge the interrupt status
+ */
+struct hwif_s;
+typedef int (ide_ack_intr_t)(struct hwif_s *);
+
+#ifndef NO_DMA
+#define NO_DMA  255
+#endif
+
+/*
+ * hwif_chipset_t is used to keep track of the specific hardware
+ * chipset used by each IDE interface, if known.
+ */
+typedef enum {  ide_unknown,    ide_generic,    ide_pci,
+                ide_cmd640,     ide_dtc2278,    ide_ali14xx,
+                ide_qd65xx,     ide_umc8672,    ide_ht6560b,
+                ide_rz1000,     ide_trm290,
+                ide_cmd646,     ide_cy82c693,   ide_4drives,
+                ide_pmac,       ide_etrax100,   ide_acorn,
+                ide_forced
+} hwif_chipset_t;
+
+/*
+ * Structure to hold all information about the location of this port
+ */
+typedef struct hw_regs_s {
+        unsigned long   io_ports[IDE_NR_PORTS]; /* task file registers */
+        int             irq;                    /* our irq number */
+        int             dma;                    /* our dma entry */
+        ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
+        hwif_chipset_t  chipset;
+} hw_regs_t;
+
+/*
+ * Register new hardware with ide
+ */
+int ide_register_hw(hw_regs_t *hw, struct hwif_s **hwifp);
+int ide_register_hw_with_fixup(hw_regs_t *, struct hwif_s **, void (*)(struct hwif_s *));
+
+/*
+ * Set up hw_regs_t structure before calling ide_register_hw (optional)
+ */
+void ide_setup_ports(   hw_regs_t *hw,
+                        unsigned long base,
+                        int *offsets,
+                        unsigned long ctrl,
+                        unsigned long intr,
+                        ide_ack_intr_t *ack_intr,
+#if 0
+                        ide_io_ops_t *iops,
+#endif
+                        int irq);
+
+static inline void ide_std_init_ports(hw_regs_t *hw,
+                                      unsigned long io_addr,
+                                      unsigned long ctl_addr)
+{
+        unsigned int i;
+
+        for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
+                hw->io_ports[i] = io_addr++;
+
+        hw->io_ports[IDE_CONTROL_OFFSET] = ctl_addr;
+}
+
+#include <asm/ide.h>
+
+/* needed on alpha, x86/x86_64, ia64, mips, ppc32 and sh */
+#ifndef IDE_ARCH_OBSOLETE_DEFAULTS
+# define ide_default_io_base(index)     (0)
+# define ide_default_irq(base)          (0)
+# define ide_init_default_irq(base)     (0)
+#endif
+
+/*
+ * ide_init_hwif_ports() is OBSOLETE and will be removed in 2.7 series.
+ * New ports shouldn't define IDE_ARCH_OBSOLETE_INIT in <asm/ide.h>.
+ */
+#ifdef IDE_ARCH_OBSOLETE_INIT
+static inline void ide_init_hwif_ports(hw_regs_t *hw,
+                                       unsigned long io_addr,
+                                       unsigned long ctl_addr,
+                                       int *irq)
+{
+        if (!ctl_addr)
+                ide_std_init_ports(hw, io_addr, ide_default_io_ctl(io_addr));
+        else
+                ide_std_init_ports(hw, io_addr, ctl_addr);
+
+        if (irq)
+                *irq = 0;
+
+        hw->io_ports[IDE_IRQ_OFFSET] = 0;
+
+#ifdef CONFIG_PPC32
+        if (ppc_ide_md.ide_init_hwif)
+                ppc_ide_md.ide_init_hwif(hw, io_addr, ctl_addr, irq);
+#endif
+}
+#else
+static inline void ide_init_hwif_ports(hw_regs_t *hw,
+                                       unsigned long io_addr,
+                                       unsigned long ctl_addr,
+                                       int *irq)
+{
+        if (io_addr || ctl_addr)
+                printk(KERN_WARNING "%s: must not be called\n", __FUNCTION__);
+}
+#endif /* IDE_ARCH_OBSOLETE_INIT */
+
+/* Currently only m68k, apus and m8xx need it */
+#ifndef IDE_ARCH_ACK_INTR
+# define ide_ack_intr(hwif) (1)
+#endif
+
+/* Currently only Atari needs it */
+#ifndef IDE_ARCH_LOCK
+# define ide_release_lock()                     do {} while (0)
+# define ide_get_lock(hdlr, data)               do {} while (0)
+#endif /* IDE_ARCH_LOCK */
+
+/*
+ * Now for the data we need to maintain per-drive:  ide_drive_t
+ */
+
+#define ide_scsi        0x21
+#define ide_disk        0x20
+#define ide_optical     0x7
+#define ide_cdrom       0x5
+#define ide_tape        0x1
+#define ide_floppy      0x0
+
+/*
+ * Special Driver Flags
+ *
+ * set_geometry : respecify drive geometry
+ * recalibrate  : seek to cyl 0
+ * set_multmode : set multmode count
+ * set_tune     : tune interface for drive
+ * serviced     : service command
+ * reserved     : unused
+ */
+typedef union {
+        unsigned all                    : 8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned set_geometry   : 1;
+                unsigned recalibrate    : 1;
+                unsigned set_multmode   : 1;
+                unsigned set_tune       : 1;
+                unsigned serviced       : 1;
+                unsigned reserved       : 3;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned reserved       : 3;
+                unsigned serviced       : 1;
+                unsigned set_tune       : 1;
+                unsigned set_multmode   : 1;
+                unsigned recalibrate    : 1;
+                unsigned set_geometry   : 1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} special_t;
+
+/*
+ * ATA DATA Register Special.
+ * ATA NSECTOR Count Register().
+ * ATAPI Byte Count Register.
+ * Channel index ordering pairs.
+ */
+typedef union {
+        unsigned all                    :16;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned low            :8;     /* LSB */
+                unsigned high           :8;     /* MSB */
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned high           :8;     /* MSB */
+                unsigned low            :8;     /* LSB */
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} ata_nsector_t, ata_data_t, atapi_bcount_t, ata_index_t;
+
+/*
+ * ATA-IDE Error Register
+ *
+ * mark         : Bad address mark
+ * tzero        : Couldn't find track 0
+ * abrt         : Aborted Command
+ * mcr          : Media Change Request
+ * id           : ID field not found
+ * mce          : Media Change Event
+ * ecc          : Uncorrectable ECC error
+ * bdd          : dual meaing
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned mark           :1;
+                unsigned tzero          :1;
+                unsigned abrt           :1;
+                unsigned mcr            :1;
+                unsigned id             :1;
+                unsigned mce            :1;
+                unsigned ecc            :1;
+                unsigned bdd            :1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned bdd            :1;
+                unsigned ecc            :1;
+                unsigned mce            :1;
+                unsigned id             :1;
+                unsigned mcr            :1;
+                unsigned abrt           :1;
+                unsigned tzero          :1;
+                unsigned mark           :1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} ata_error_t;
+
+/*
+ * ATA-IDE Select Register, aka Device-Head
+ *
+ * head         : always zeros here
+ * unit         : drive select number: 0/1
+ * bit5         : always 1
+ * lba          : using LBA instead of CHS
+ * bit7         : always 1
+ */
+typedef union {
+        unsigned all                    : 8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned head           : 4;
+                unsigned unit           : 1;
+                unsigned bit5           : 1;
+                unsigned lba            : 1;
+                unsigned bit7           : 1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned bit7           : 1;
+                unsigned lba            : 1;
+                unsigned bit5           : 1;
+                unsigned unit           : 1;
+                unsigned head           : 4;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} select_t, ata_select_t;
+
+/*
+ * The ATA-IDE Status Register.
+ * The ATAPI Status Register.
+ *
+ * check        : Error occurred
+ * idx          : Index Error
+ * corr         : Correctable error occurred
+ * drq          : Data is request by the device
+ * dsc          : Disk Seek Complete                    : ata
+ *              : Media access command finished         : atapi
+ * df           : Device Fault                          : ata
+ *              : Reserved                              : atapi
+ * drdy         : Ready, Command Mode Capable           : ata
+ *              : Ignored for ATAPI commands            : atapi
+ * bsy          : Disk is Busy
+ *              : The device has access to the command block
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned check          :1;
+                unsigned idx            :1;
+                unsigned corr           :1;
+                unsigned drq            :1;
+                unsigned dsc            :1;
+                unsigned df             :1;
+                unsigned drdy           :1;
+                unsigned bsy            :1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned bsy            :1;
+                unsigned drdy           :1;
+                unsigned df             :1;
+                unsigned dsc            :1;
+                unsigned drq            :1;
+                unsigned corr           :1;
+                unsigned idx            :1;
+                unsigned check          :1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} ata_status_t, atapi_status_t;
+
+/*
+ * ATA-IDE Control Register
+ *
+ * bit0         : Should be set to zero
+ * nIEN         : device INTRQ to host
+ * SRST         : host soft reset bit
+ * bit3         : ATA-2 thingy, Should be set to 1
+ * reserved456  : Reserved
+ * HOB          : 48-bit address ordering, High Ordered Bit
+ */
+typedef union {
+        unsigned all                    : 8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned bit0           : 1;
+                unsigned nIEN           : 1;
+                unsigned SRST           : 1;
+                unsigned bit3           : 1;
+                unsigned reserved456    : 3;
+                unsigned HOB            : 1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned HOB            : 1;
+                unsigned reserved456    : 3;
+                unsigned bit3           : 1;
+                unsigned SRST           : 1;
+                unsigned nIEN           : 1;
+                unsigned bit0           : 1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} ata_control_t;
+
+/*
+ * ATAPI Feature Register
+ *
+ * dma          : Using DMA or PIO
+ * reserved321  : Reserved
+ * reserved654  : Reserved (Tag Type)
+ * reserved7    : Reserved
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned dma            :1;
+                unsigned reserved321    :3;
+                unsigned reserved654    :3;
+                unsigned reserved7      :1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned reserved7      :1;
+                unsigned reserved654    :3;
+                unsigned reserved321    :3;
+                unsigned dma            :1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} atapi_feature_t;
+
+/*
+ * ATAPI Interrupt Reason Register.
+ *
+ * cod          : Information transferred is command (1) or data (0)
+ * io           : The device requests us to read (1) or write (0)
+ * reserved     : Reserved
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned cod            :1;
+                unsigned io             :1;
+                unsigned reserved       :6;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned reserved       :6;
+                unsigned io             :1;
+                unsigned cod            :1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} atapi_ireason_t;
+
+/*
+ * The ATAPI error register.
+ *
+ * ili          : Illegal Length Indication
+ * eom          : End Of Media Detected
+ * abrt         : Aborted command - As defined by ATA
+ * mcr          : Media Change Requested - As defined by ATA
+ * sense_key    : Sense key of the last failed packet command
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned ili            :1;
+                unsigned eom            :1;
+                unsigned abrt           :1;
+                unsigned mcr            :1;
+                unsigned sense_key      :4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned sense_key      :4;
+                unsigned mcr            :1;
+                unsigned abrt           :1;
+                unsigned eom            :1;
+                unsigned ili            :1;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} atapi_error_t;
+
+/*
+ * ATAPI floppy Drive Select Register
+ *
+ * sam_lun      : Logical unit number
+ * reserved3    : Reserved
+ * drv          : The responding drive will be drive 0 (0) or drive 1 (1)
+ * one5         : Should be set to 1
+ * reserved6    : Reserved
+ * one7         : Should be set to 1
+ */
+typedef union {
+        unsigned all                    :8;
+        struct {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+                unsigned sam_lun        :3;
+                unsigned reserved3      :1;
+                unsigned drv            :1;
+                unsigned one5           :1;
+                unsigned reserved6      :1;
+                unsigned one7           :1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+                unsigned one7           :1;
+                unsigned reserved6      :1;
+                unsigned one5           :1;
+                unsigned drv            :1;
+                unsigned reserved3      :1;
+                unsigned sam_lun        :3;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        } b;
+} atapi_select_t;
+
+/*
+ * Status returned from various ide_ functions
+ */
+typedef enum {
+        ide_stopped,    /* no drive operation was started */
+        ide_started,    /* a drive operation was started, handler was set */
+} ide_startstop_t;
+
+struct ide_driver_s;
+struct ide_settings_s;
+
+typedef struct ide_drive_s {
+        char            name[4];        /* drive name, such as "hda" */
+        char            driver_req[10]; /* requests specific driver */
+
+        request_queue_t         *queue; /* request queue */
+
+        struct request          *rq;    /* current request */
+        struct ide_drive_s      *next;  /* circular list of hwgroup drives */
+        struct ide_driver_s     *driver;/* (ide_driver_t *) */
+        void            *driver_data;   /* extra driver data */
+        struct hd_driveid       *id;    /* drive model identification info */
+        struct proc_dir_entry *proc;    /* /proc/ide/ directory entry */
+        struct ide_settings_s *settings;/* /proc/ide/ drive settings */
+        char            devfs_name[64]; /* devfs crap */
+
+        struct hwif_s           *hwif;  /* actually (ide_hwif_t *) */
+
+        unsigned long sleep;            /* sleep until this time */
+        unsigned long service_start;    /* time we started last request */
+        unsigned long service_time;     /* service time of last request */
+        unsigned long timeout;          /* max time to wait for irq */
+
+        special_t       special;        /* special action flags */
+        select_t        select;         /* basic drive/head select reg value */
+
+        u8      keep_settings;          /* restore settings after drive reset */
+        u8      autodma;                /* device can safely use dma on host */
+        u8      using_dma;              /* disk is using dma for read/write */
+        u8      retry_pio;              /* retrying dma capable host in pio */
+        u8      state;                  /* retry state */
+        u8      waiting_for_dma;        /* dma currently in progress */
+        u8      unmask;                 /* okay to unmask other irqs */
+        u8      bswap;                  /* byte swap data */
+        u8      dsc_overlap;            /* DSC overlap */
+        u8      nice1;                  /* give potential excess bandwidth */
+
+        unsigned present        : 1;    /* drive is physically present */
+        unsigned dead           : 1;    /* device ejected hint */
+        unsigned id_read        : 1;    /* 1=id read from disk 0 = synthetic */
+        unsigned noprobe        : 1;    /* from:  hdx=noprobe */
+        unsigned removable      : 1;    /* 1 if need to do check_media_change */
+        unsigned attach         : 1;    /* needed for removable devices */
+        unsigned is_flash       : 1;    /* 1 if probed as flash */
+        unsigned forced_geom    : 1;    /* 1 if hdx=c,h,s was given at boot */
+        unsigned no_unmask      : 1;    /* disallow setting unmask bit */
+        unsigned no_io_32bit    : 1;    /* disallow enabling 32bit I/O */
+        unsigned atapi_overlap  : 1;    /* ATAPI overlap (not supported) */
+        unsigned nice0          : 1;    /* give obvious excess bandwidth */
+        unsigned nice2          : 1;    /* give a share in our own bandwidth */
+        unsigned doorlocking    : 1;    /* for removable only: door lock/unlock works */
+        unsigned autotune       : 2;    /* 0=default, 1=autotune, 2=noautotune */
+        unsigned remap_0_to_1   : 1;    /* 0=noremap, 1=remap 0->1 (for EZDrive) */
+        unsigned blocked        : 1;    /* 1=powermanagment told us not to do anything, so sleep nicely */
+        unsigned vdma           : 1;    /* 1=doing PIO over DMA 0=doing normal DMA */
+        unsigned addressing;            /*      : 3;
+                                         *  0=28-bit
+                                         *  1=48-bit
+                                         *  2=48-bit doing 28-bit
+                                         *  3=64-bit
+                                         */
+        unsigned scsi           : 1;    /* 0=default, 1=ide-scsi emulation */
+        unsigned sleeping       : 1;    /* 1=sleeping & sleep field valid */
+        unsigned post_reset     : 1;
+
+        u8      quirk_list;     /* considered quirky, set for a specific host */
+        u8      init_speed;     /* transfer rate set at boot */
+        u8      pio_speed;      /* unused by core, used by some drivers for fallback from DMA */
+        u8      current_speed;  /* current transfer rate set */
+        u8      dn;             /* now wide spread use */
+        u8      wcache;         /* status of write cache */
+        u8      acoustic;       /* acoustic management */
+        u8      media;          /* disk, cdrom, tape, floppy, ... */
+        u8      ctl;            /* "normal" value for IDE_CONTROL_REG */
+        u8      ready_stat;     /* min status value for drive ready */
+        u8      mult_count;     /* current multiple sector setting */
+        u8      mult_req;       /* requested multiple sector setting */
+        u8      tune_req;       /* requested drive tuning setting */
+        u8      io_32bit;       /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
+        u8      bad_wstat;      /* used for ignoring WRERR_STAT */
+        u8      nowerr;         /* used for ignoring WRERR_STAT */
+        u8      sect0;          /* offset of first sector for DM6:DDO */
+        u8      head;           /* "real" number of heads */
+        u8      sect;           /* "real" sectors per track */
+        u8      bios_head;      /* BIOS/fdisk/LILO number of heads */
+        u8      bios_sect;      /* BIOS/fdisk/LILO sectors per track */
+
+        unsigned int    bios_cyl;       /* BIOS/fdisk/LILO number of cyls */
+        unsigned int    cyl;            /* "real" number of cyls */
+        unsigned int    drive_data;     /* use by tuneproc/selectproc */
+        unsigned int    usage;          /* current "open()" count for drive */
+        unsigned int    failures;       /* current failure count */
+        unsigned int    max_failures;   /* maximum allowed failure count */
+
+        u64             capacity64;     /* total number of sectors */
+
+        int             lun;            /* logical unit */
+        int             crc_count;      /* crc counter to reduce drive speed */
+        struct list_head list;
+        struct device   gendev;
+        struct semaphore gendev_rel_sem;        /* to deal with device release() */
+} ide_drive_t;
+
+#define IDE_CHIPSET_PCI_MASK    \
+    ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx))
+#define IDE_CHIPSET_IS_PCI(c)   ((IDE_CHIPSET_PCI_MASK >> (c)) & 1)
+
+struct ide_pci_device_s;
+
+typedef struct hwif_s {
+        struct hwif_s *next;            /* for linked-list in ide_hwgroup_t */
+        struct hwif_s *mate;            /* other hwif from same PCI chip */
+        struct hwgroup_s *hwgroup;      /* actually (ide_hwgroup_t *) */
+        struct proc_dir_entry *proc;    /* /proc/ide/ directory entry */
+
+        char name[6];                   /* name of interface, eg. "ide0" */
+
+                /* task file registers for pata and sata */
+        unsigned long   io_ports[IDE_NR_PORTS];
+        unsigned long   sata_scr[SATA_NR_PORTS];
+        unsigned long   sata_misc[SATA_NR_PORTS];
+
+        hw_regs_t       hw;             /* Hardware info */
+        ide_drive_t     drives[MAX_DRIVES];     /* drive info */
+
+        u8 major;       /* our major number */
+        u8 index;       /* 0 for ide0; 1 for ide1; ... */
+        u8 channel;     /* for dual-port chips: 0=primary, 1=secondary */
+        u8 straight8;   /* Alan's straight 8 check */
+        u8 bus_state;   /* power state of the IDE bus */
+
+        u8 atapi_dma;   /* host supports atapi_dma */
+        u8 ultra_mask;
+        u8 mwdma_mask;
+        u8 swdma_mask;
+
+        hwif_chipset_t chipset; /* sub-module for tuning.. */
+
+        struct pci_dev  *pci_dev;       /* for pci chipsets */
+        struct ide_pci_device_s *cds;   /* chipset device struct */
+
+        void (*rw_disk)(ide_drive_t *, struct request *);
+
+#if 0
+        ide_hwif_ops_t  *hwifops;
+#else
+        /* routine to tune PIO mode for drives */
+        void    (*tuneproc)(ide_drive_t *, u8);
+        /* routine to retune DMA modes for drives */
+        int     (*speedproc)(ide_drive_t *, u8);
+        /* tweaks hardware to select drive */
+        void    (*selectproc)(ide_drive_t *);
+        /* chipset polling based on hba specifics */
+        int     (*reset_poll)(ide_drive_t *);
+        /* chipset specific changes to default for device-hba resets */
+        void    (*pre_reset)(ide_drive_t *);
+        /* routine to reset controller after a disk reset */
+        void    (*resetproc)(ide_drive_t *);
+        /* special interrupt handling for shared pci interrupts */
+        void    (*intrproc)(ide_drive_t *);
+        /* special host masking for drive selection */
+        void    (*maskproc)(ide_drive_t *, int);
+        /* check host's drive quirk list */
+        int     (*quirkproc)(ide_drive_t *);
+        /* driver soft-power interface */
+        int     (*busproc)(ide_drive_t *, int);
+//      /* host rate limiter */
+//      u8      (*ratemask)(ide_drive_t *);
+//      /* device rate limiter */
+//      u8      (*ratefilter)(ide_drive_t *, u8);
+#endif
+
+        void (*ata_input_data)(ide_drive_t *, void *, u32);
+        void (*ata_output_data)(ide_drive_t *, void *, u32);
+
+        void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
+        void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
+
+        int (*dma_setup)(ide_drive_t *);
+        void (*dma_exec_cmd)(ide_drive_t *, u8);
+        void (*dma_start)(ide_drive_t *);
+        int (*ide_dma_end)(ide_drive_t *drive);
+        int (*ide_dma_check)(ide_drive_t *drive);
+        int (*ide_dma_on)(ide_drive_t *drive);
+        int (*ide_dma_off_quietly)(ide_drive_t *drive);
+        int (*ide_dma_test_irq)(ide_drive_t *drive);
+        int (*ide_dma_host_on)(ide_drive_t *drive);
+        int (*ide_dma_host_off)(ide_drive_t *drive);
+        int (*ide_dma_lostirq)(ide_drive_t *drive);
+        int (*ide_dma_timeout)(ide_drive_t *drive);
+
+        void (*OUTB)(u8 addr, unsigned long port);
+        void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port);
+        void (*OUTW)(u16 addr, unsigned long port);
+        void (*OUTL)(u32 addr, unsigned long port);
+        void (*OUTSW)(unsigned long port, void *addr, u32 count);
+        void (*OUTSL)(unsigned long port, void *addr, u32 count);
+
+        u8  (*INB)(unsigned long port);
+        u16 (*INW)(unsigned long port);
+        u32 (*INL)(unsigned long port);
+        void (*INSW)(unsigned long port, void *addr, u32 count);
+        void (*INSL)(unsigned long port, void *addr, u32 count);
+
+        /* dma physical region descriptor table (cpu view) */
+        unsigned int    *dmatable_cpu;
+        /* dma physical region descriptor table (dma view) */
+        dma_addr_t      dmatable_dma;
+        /* Scatter-gather list used to build the above */
+        struct scatterlist *sg_table;
+        int sg_max_nents;               /* Maximum number of entries in it */
+        int sg_nents;                   /* Current number of entries in it */
+        int sg_dma_direction;           /* dma transfer direction */
+
+        /* data phase of the active command (currently only valid for PIO/DMA) */
+        int             data_phase;
+
+        unsigned int nsect;
+        unsigned int nleft;
+        unsigned int cursg;
+        unsigned int cursg_ofs;
+
+        int             mmio;           /* hosts iomio (0) or custom (2) select */
+        int             rqsize;         /* max sectors per request */
+        int             irq;            /* our irq number */
+
+        unsigned long   dma_master;     /* reference base addr dmabase */
+        unsigned long   dma_base;       /* base addr for dma ports */
+        unsigned long   dma_command;    /* dma command register */
+        unsigned long   dma_vendor1;    /* dma vendor 1 register */
+        unsigned long   dma_status;     /* dma status register */
+        unsigned long   dma_vendor3;    /* dma vendor 3 register */
+        unsigned long   dma_prdtable;   /* actual prd table address */
+        unsigned long   dma_base2;      /* extended base addr for dma ports */
+
+        unsigned        dma_extra;      /* extra addr for dma ports */
+        unsigned long   config_data;    /* for use by chipset-specific code */
+        unsigned long   select_data;    /* for use by chipset-specific code */
+
+        unsigned        noprobe    : 1; /* don't probe for this interface */
+        unsigned        present    : 1; /* this interface exists */
+        unsigned        hold       : 1; /* this interface is always present */
+        unsigned        serialized : 1; /* serialized all channel operation */
+        unsigned        sharing_irq: 1; /* 1 = sharing irq with another hwif */
+        unsigned        reset      : 1; /* reset after probe */
+        unsigned        autodma    : 1; /* auto-attempt using DMA at boot */
+        unsigned        udma_four  : 1; /* 1=ATA-66 capable, 0=default */
+        unsigned        no_lba48   : 1; /* 1 = cannot do LBA48 */
+        unsigned        no_lba48_dma : 1; /* 1 = cannot do LBA48 DMA */
+        unsigned        no_dsc     : 1; /* 0 default, 1 dsc_overlap disabled */
+        unsigned        auto_poll  : 1; /* supports nop auto-poll */
+        unsigned        sg_mapped  : 1; /* sg_table and sg_nents are ready */
+
+        struct device   gendev;
+        struct semaphore gendev_rel_sem; /* To deal with device release() */
+
+        void            *hwif_data;     /* extra hwif data */
+
+        unsigned dma;
+
+        void (*led_act)(void *data, int rw);
+} ide_hwif_t;
+
+/*
+ *  internal ide interrupt handler type
+ */
+typedef ide_startstop_t (ide_pre_handler_t)(ide_drive_t *, struct request *);
+typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
+typedef int (ide_expiry_t)(ide_drive_t *);
+
+typedef struct hwgroup_s {
+                /* irq handler, if active */
+        ide_startstop_t (*handler)(ide_drive_t *);
+                /* irq handler, suspended if active */
+        ide_startstop_t (*handler_save)(ide_drive_t *);
+                /* BOOL: protects all fields below */
+        volatile int busy;
+                /* BOOL: wake us up on timer expiry */
+        unsigned int sleeping   : 1;
+                /* BOOL: polling active & poll_timeout field valid */
+        unsigned int polling    : 1;
+                /* current drive */
+        ide_drive_t *drive;
+                /* ptr to current hwif in linked-list */
+        ide_hwif_t *hwif;
+
+                /* for pci chipsets */
+        struct pci_dev *pci_dev;
+                /* chipset device struct */
+        struct ide_pci_device_s *cds;
+
+                /* current request */
+        struct request *rq;
+                /* failsafe timer */
+        struct timer_list timer;
+                /* local copy of current write rq */
+        struct request wrq;
+                /* timeout value during long polls */
+        unsigned long poll_timeout;
+                /* queried upon timeouts */
+        int (*expiry)(ide_drive_t *);
+                /* ide_system_bus_speed */
+        int pio_clock;
+
+        unsigned char cmd_buf[4];
+} ide_hwgroup_t;
+
+/* structure attached to the request for IDE_TASK_CMDS */
+
+/*
+ * configurable drive settings
+ */
+
+#define TYPE_INT        0
+#define TYPE_INTA       1
+#define TYPE_BYTE       2
+#define TYPE_SHORT      3
+
+#define SETTING_READ    (1 << 0)
+#define SETTING_WRITE   (1 << 1)
+#define SETTING_RW      (SETTING_READ | SETTING_WRITE)
+
+typedef int (ide_procset_t)(ide_drive_t *, int);
+typedef struct ide_settings_s {
+        char                    *name;
+        int                     rw;
+        int                     read_ioctl;
+        int                     write_ioctl;
+        int                     data_type;
+        int                     min;
+        int                     max;
+        int                     mul_factor;
+        int                     div_factor;
+        void                    *data;
+        ide_procset_t           *set;
+        int                     auto_remove;
+        struct ide_settings_s   *next;
+} ide_settings_t;
+
+extern struct semaphore ide_setting_sem;
+extern int ide_add_setting(ide_drive_t *drive, const char *name, int rw, int read_ioctl, int write_ioctl, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set);
+extern ide_settings_t *ide_find_setting_by_name(ide_drive_t *drive, char *name);
+extern int ide_read_setting(ide_drive_t *t, ide_settings_t *setting);
+extern int ide_write_setting(ide_drive_t *drive, ide_settings_t *setting, int val);
+extern void ide_add_generic_settings(ide_drive_t *drive);
+
+/*
+ * /proc/ide interface
+ */
+typedef struct {
+        const char      *name;
+        mode_t          mode;
+        read_proc_t     *read_proc;
+        write_proc_t    *write_proc;
+} ide_proc_entry_t;
+
+#ifdef CONFIG_PROC_FS
+extern struct proc_dir_entry *proc_ide_root;
+
+extern void proc_ide_create(void);
+extern void proc_ide_destroy(void);
+extern void create_proc_ide_interfaces(void);
+void destroy_proc_ide_interface(ide_hwif_t *);
+extern void ide_add_proc_entries(struct proc_dir_entry *, ide_proc_entry_t *, void *);
+extern void ide_remove_proc_entries(struct proc_dir_entry *, ide_proc_entry_t *);
+read_proc_t proc_ide_read_capacity;
+read_proc_t proc_ide_read_geometry;
+
+#ifdef CONFIG_BLK_DEV_IDEPCI
+void ide_pci_create_host_proc(const char *, get_info_t *);
+#endif
+
+/*
+ * Standard exit stuff:
+ */
+#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) \
+{                                       \
+        len -= off;                     \
+        if (len < count) {              \
+                *eof = 1;               \
+                if (len <= 0)           \
+                        return 0;       \
+        } else                          \
+                len = count;            \
+        *start = page + off;            \
+        return len;                     \
+}
+#else
+static inline void create_proc_ide_interfaces(void) { ; }
+static inline void destroy_proc_ide_interface(ide_hwif_t *hwif) { ; }
+#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
+#endif
+
+/*
+ * Power Management step value (rq->pm->pm_step).
+ *
+ * The step value starts at 0 (ide_pm_state_start_suspend) for a
+ * suspend operation or 1000 (ide_pm_state_start_resume) for a
+ * resume operation.
+ *
+ * For each step, the core calls the subdriver start_power_step() first.
+ * This can return:
+ *      - ide_stopped : In this case, the core calls us back again unless
+ *                      step have been set to ide_power_state_completed.
+ *      - ide_started : In this case, the channel is left busy until an
+ *                      async event (interrupt) occurs.
+ * Typically, start_power_step() will issue a taskfile request with
+ * do_rw_taskfile().
+ *
+ * Upon reception of the interrupt, the core will call complete_power_step()
+ * with the error code if any. This routine should update the step value
+ * and return. It should not start a new request. The core will call
+ * start_power_step for the new step value, unless step have been set to
+ * ide_power_state_completed.
+ *
+ * Subdrivers are expected to define their own additional power
+ * steps from 1..999 for suspend and from 1001..1999 for resume,
+ * other values are reserved for future use.
+ */
+
+enum {
+        ide_pm_state_completed          = -1,
+        ide_pm_state_start_suspend      = 0,
+        ide_pm_state_start_resume       = 1000,
+};
+
+/*
+ * Subdrivers support.
+ */
+typedef struct ide_driver_s {
+        struct module                   *owner;
+        const char                      *name;
+        const char                      *version;
+        u8                              media;
+        unsigned busy                   : 1;
+        unsigned supports_dsc_overlap   : 1;
+        int             (*cleanup)(ide_drive_t *);
+        ide_startstop_t (*do_request)(ide_drive_t *, struct request *, sector_t);
+        int             (*end_request)(ide_drive_t *, int, int);
+        ide_startstop_t (*error)(ide_drive_t *, struct request *rq, u8, u8);
+        ide_startstop_t (*abort)(ide_drive_t *, struct request *rq);
+        int             (*ioctl)(ide_drive_t *, struct inode *, struct file *, unsigned int, unsigned long);
+        ide_proc_entry_t        *proc;
+        int             (*attach)(ide_drive_t *);
+        void            (*ata_prebuilder)(ide_drive_t *);
+        void            (*atapi_prebuilder)(ide_drive_t *);
+        struct device_driver    gen_driver;
+        struct list_head drives;
+        struct list_head drivers;
+} ide_driver_t;
+
+#define DRIVER(drive)           ((drive)->driver)
+
+int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
+
+/*
+ * ide_hwifs[] is the master data structure used to keep track
+ * of just about everything in ide.c.  Whenever possible, routines
+ * should be using pointers to a drive (ide_drive_t *) or
+ * pointers to a hwif (ide_hwif_t *), rather than indexing this
+ * structure directly (the allocation/layout may change!).
+ *
+ */
+#ifndef _IDE_C
+extern  ide_hwif_t      ide_hwifs[];            /* master data repository */
+#endif
+extern int noautodma;
+
+extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
+extern int __ide_end_request (ide_drive_t *drive, struct request *rq, int uptodate, int nrsecs);
+
+/*
+ * This is used on exit from the driver to designate the next irq handler
+ * and also to start the safety timer.
+ */
+extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry);
+
+/*
+ * This is used on exit from the driver to designate the next irq handler
+ * and start the safety time safely and atomically from the IRQ handler
+ * with respect to the command issue (which it also does)
+ */
+extern void ide_execute_command(ide_drive_t *, task_ioreg_t cmd, ide_handler_t *, unsigned int, ide_expiry_t *);
+
+ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);
+
+/*
+ * ide_error() takes action based on the error returned by the controller.
+ * The caller should return immediately after invoking this.
+ *
+ * (drive, msg, status)
+ */
+ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
+
+ide_startstop_t __ide_abort(ide_drive_t *, struct request *);
+
+/*
+ * Abort a running command on the controller triggering the abort
+ * from a host side, non error situation
+ * (drive, msg)
+ */
+extern ide_startstop_t ide_abort(ide_drive_t *, const char *);
+
+extern void ide_fix_driveid(struct hd_driveid *);
+/*
+ * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
+ * removing leading/trailing blanks and compressing internal blanks.
+ * It is primarily used to tidy up the model name/number fields as
+ * returned by the WIN_[P]IDENTIFY commands.
+ *
+ * (s, bytecount, byteswap)
+ */
+extern void ide_fixstring(u8 *, const int, const int);
+
+/*
+ * This routine busy-waits for the drive status to be not "busy".
+ * It then checks the status for all of the "good" bits and none
+ * of the "bad" bits, and if all is okay it returns 0.  All other
+ * cases return 1 after doing "*startstop = ide_error()", and the
+ * caller should return the updated value of "startstop" in this case.
+ * "startstop" is unchanged when the function returns 0;
+ * (startstop, drive, good, bad, timeout)
+ */
+extern int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long);
+
+/*
+ * Start a reset operation for an IDE interface.
+ * The caller should return immediately after invoking this.
+ */
+extern ide_startstop_t ide_do_reset (ide_drive_t *);
+
+/*
+ * This function is intended to be used prior to invoking ide_do_drive_cmd().
+ */
+extern void ide_init_drive_cmd (struct request *rq);
+
+/*
+ * this function returns error location sector offset in case of a write error
+ */
+extern u64 ide_get_error_location(ide_drive_t *, char *);
+
+/*
+ * "action" parameter type for ide_do_drive_cmd() below.
+ */
+typedef enum {
+        ide_wait,       /* insert rq at end of list, and wait for it */
+        ide_next,       /* insert rq immediately after current request */
+        ide_preempt,    /* insert rq in front of current request */
+        ide_head_wait,  /* insert rq in front of current request and wait for it */
+        ide_end         /* insert rq at end of list, but don't wait for it */
+} ide_action_t;
+
+/*
+ * This function issues a special IDE device request
+ * onto the request queue.
+ *
+ * If action is ide_wait, then the rq is queued at the end of the
+ * request queue, and the function sleeps until it has been processed.
+ * This is for use when invoked from an ioctl handler.
+ *
+ * If action is ide_preempt, then the rq is queued at the head of
+ * the request queue, displacing the currently-being-processed
+ * request and this function returns immediately without waiting
+ * for the new rq to be completed.  This is VERY DANGEROUS, and is
+ * intended for careful use by the ATAPI tape/cdrom driver code.
+ *
+ * If action is ide_next, then the rq is queued immediately after
+ * the currently-being-processed-request (if any), and the function
+ * returns without waiting for the new rq to be completed.  As above,
+ * This is VERY DANGEROUS, and is intended for careful use by the
+ * ATAPI tape/cdrom driver code.
+ *
+ * If action is ide_end, then the rq is queued at the end of the
+ * request queue, and the function returns immediately without waiting
+ * for the new rq to be completed. This is again intended for careful
+ * use by the ATAPI tape/cdrom driver code.
+ */
+extern int ide_do_drive_cmd(ide_drive_t *, struct request *, ide_action_t);
+
+/*
+ * Clean up after success/failure of an explicit drive cmd.
+ * stat/err are used only when (HWGROUP(drive)->rq->cmd == IDE_DRIVE_CMD).
+ * stat/err are used only when (HWGROUP(drive)->rq->cmd == IDE_DRIVE_TASK_MASK).
+ *
+ * (ide_drive_t *drive, u8 stat, u8 err)
+ */
+extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);
+
+/*
+ * Issue ATA command and wait for completion.
+ * Use for implementing commands in kernel
+ *
+ *  (ide_drive_t *drive, u8 cmd, u8 nsect, u8 feature, u8 sectors, u8 *buf)
+ */
+extern int ide_wait_cmd(ide_drive_t *, u8, u8, u8, u8, u8 *);
+
+typedef struct ide_task_s {
+/*
+ *      struct hd_drive_task_hdr        tf;
+ *      task_struct_t           tf;
+ *      struct hd_drive_hob_hdr         hobf;
+ *      hob_struct_t            hobf;
+ */
+        task_ioreg_t            tfRegister[8];
+        task_ioreg_t            hobRegister[8];
+        ide_reg_valid_t         tf_out_flags;
+        ide_reg_valid_t         tf_in_flags;
+        int                     data_phase;
+        int                     command_type;
+        ide_pre_handler_t       *prehandler;
+        ide_handler_t           *handler;
+        struct request          *rq;            /* copy of request */
+        void                    *special;       /* valid_t generally */
+} ide_task_t;
+
+extern u32 ide_read_24(ide_drive_t *);
+
+extern void SELECT_DRIVE(ide_drive_t *);
+extern void SELECT_INTERRUPT(ide_drive_t *);
+extern void SELECT_MASK(ide_drive_t *, int);
+extern void QUIRK_LIST(ide_drive_t *);
+
+extern int drive_is_ready(ide_drive_t *);
+extern int wait_for_ready(ide_drive_t *, int /* timeout */);
+
+/*
+ * taskfile io for disks for now...and builds request from ide_ioctl
+ */
+extern ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
+
+/*
+ * Special Flagged Register Validation Caller
+ */
+extern ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *);
+
+extern ide_startstop_t set_multmode_intr(ide_drive_t *);
+extern ide_startstop_t set_geometry_intr(ide_drive_t *);
+extern ide_startstop_t recal_intr(ide_drive_t *);
+extern ide_startstop_t task_no_data_intr(ide_drive_t *);
+extern ide_startstop_t task_in_intr(ide_drive_t *);
+extern ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *);
+
+extern int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *);
+
+int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
+int ide_cmd_ioctl(ide_drive_t *, unsigned int, unsigned long);
+int ide_task_ioctl(ide_drive_t *, unsigned int, unsigned long);
+
+extern int system_bus_clock(void);
+
+extern int ide_driveid_update(ide_drive_t *);
+extern int ide_ata66_check(ide_drive_t *, ide_task_t *);
+extern int ide_config_drive_speed(ide_drive_t *, u8);
+extern u8 eighty_ninty_three (ide_drive_t *);
+extern int set_transfer(ide_drive_t *, ide_task_t *);
+extern int taskfile_lib_get_identify(ide_drive_t *drive, u8 *);
+
+extern int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout);
+
+/*
+ * ide_stall_queue() can be used by a drive to give excess bandwidth back
+ * to the hwgroup by sleeping for timeout jiffies.
+ */
+extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);
+
+extern int ide_spin_wait_hwgroup(ide_drive_t *);
+extern void ide_timer_expiry(unsigned long);
+extern irqreturn_t ide_intr(int irq, void *dev_id, struct pt_regs *regs);
+extern void do_ide_request(request_queue_t *);
+extern void ide_init_subdrivers(void);
+
+void ide_init_disk(struct gendisk *, ide_drive_t *);
+
+extern int ata_attach(ide_drive_t *);
+
+extern int ideprobe_init(void);
+
+extern void ide_scan_pcibus(int scan_direction) __init;
+extern int ide_pci_register_driver(struct pci_driver *driver);
+extern void ide_pci_unregister_driver(struct pci_driver *driver);
+void ide_pci_setup_ports(struct pci_dev *, struct ide_pci_device_s *, int, ata_index_t *);
+extern void ide_setup_pci_noise (struct pci_dev *dev, struct ide_pci_device_s *d);
+
+extern void default_hwif_iops(ide_hwif_t *);
+extern void default_hwif_mmiops(ide_hwif_t *);
+extern void default_hwif_transport(ide_hwif_t *);
+
+int ide_register_driver(ide_driver_t *driver);
+void ide_unregister_driver(ide_driver_t *driver);
+int ide_register_subdriver(ide_drive_t *, ide_driver_t *);
+int ide_unregister_subdriver (ide_drive_t *drive);
+int ide_replace_subdriver(ide_drive_t *drive, const char *driver);
+
+#define ON_BOARD                1
+#define NEVER_BOARD             0
+
+#ifdef CONFIG_BLK_DEV_OFFBOARD
+#  define OFF_BOARD             ON_BOARD
+#else /* CONFIG_BLK_DEV_OFFBOARD */
+#  define OFF_BOARD             NEVER_BOARD
+#endif /* CONFIG_BLK_DEV_OFFBOARD */
+
+#define NODMA 0
+#define NOAUTODMA 1
+#define AUTODMA 2
+
+typedef struct ide_pci_enablebit_s {
+        u8      reg;    /* byte pci reg holding the enable-bit */
+        u8      mask;   /* mask to isolate the enable-bit */
+        u8      val;    /* value of masked reg when "enabled" */
+} ide_pci_enablebit_t;
+
+enum {
+        /* Uses ISA control ports not PCI ones. */
+        IDEPCI_FLAG_ISA_PORTS           = (1 << 0),
+        IDEPCI_FLAG_FORCE_PDC           = (1 << 1),
+};
+
+typedef struct ide_pci_device_s {
+        char                    *name;
+        int                     (*init_setup)(struct pci_dev *, struct ide_pci_device_s *);
+        void                    (*init_setup_dma)(struct pci_dev *, struct ide_pci_device_s *, ide_hwif_t *);
+        unsigned int            (*init_chipset)(struct pci_dev *, const char *);
+        void                    (*init_iops)(ide_hwif_t *);
+        void                    (*init_hwif)(ide_hwif_t *);
+        void                    (*init_dma)(ide_hwif_t *, unsigned long);
+        void                    (*fixup)(ide_hwif_t *);
+        u8                      channels;
+        u8                      autodma;
+        ide_pci_enablebit_t     enablebits[2];
+        u8                      bootable;
+        unsigned int            extra;
+        struct ide_pci_device_s *next;
+        u8                      flags;
+} ide_pci_device_t;
+
+extern int ide_setup_pci_device(struct pci_dev *, ide_pci_device_t *);
+extern int ide_setup_pci_devices(struct pci_dev *, struct pci_dev *, ide_pci_device_t *);
+
+void ide_map_sg(ide_drive_t *, struct request *);
+void ide_init_sg_cmd(ide_drive_t *, struct request *);
+
+#define BAD_DMA_DRIVE           0
+#define GOOD_DMA_DRIVE          1
+
+#ifdef CONFIG_BLK_DEV_IDEDMA
+int __ide_dma_bad_drive(ide_drive_t *);
+int __ide_dma_good_drive(ide_drive_t *);
+int ide_use_dma(ide_drive_t *);
+int __ide_dma_off(ide_drive_t *);
+void ide_dma_verbose(ide_drive_t *);
+ide_startstop_t ide_dma_intr(ide_drive_t *);
+
+#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
+extern int ide_build_sglist(ide_drive_t *, struct request *);
+extern int ide_build_dmatable(ide_drive_t *, struct request *);
+extern void ide_destroy_dmatable(ide_drive_t *);
+extern int ide_release_dma(ide_hwif_t *);
+extern void ide_setup_dma(ide_hwif_t *, unsigned long, unsigned int);
+
+extern int __ide_dma_host_off(ide_drive_t *);
+extern int __ide_dma_off_quietly(ide_drive_t *);
+extern int __ide_dma_host_on(ide_drive_t *);
+extern int __ide_dma_on(ide_drive_t *);
+extern int __ide_dma_check(ide_drive_t *);
+extern int ide_dma_setup(ide_drive_t *);
+extern void ide_dma_start(ide_drive_t *);
+extern int __ide_dma_end(ide_drive_t *);
+extern int __ide_dma_lostirq(ide_drive_t *);
+extern int __ide_dma_timeout(ide_drive_t *);
+#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
+
+#else
+static inline int ide_use_dma(ide_drive_t *drive) { return 0; }
+static inline int __ide_dma_off(ide_drive_t *drive) { return 0; }
+static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
+#endif /* CONFIG_BLK_DEV_IDEDMA */
+
+#ifndef CONFIG_BLK_DEV_IDEDMA_PCI
+static inline void ide_release_dma(ide_hwif_t *drive) {;}
+#endif
+
+extern int ide_hwif_request_regions(ide_hwif_t *hwif);
+extern void ide_hwif_release_regions(ide_hwif_t* hwif);
+extern void ide_unregister (unsigned int index);
+
+void ide_register_region(struct gendisk *);
+void ide_unregister_region(struct gendisk *);
+
+void ide_undecoded_slave(ide_hwif_t *);
+
+int probe_hwif_init_with_fixup(ide_hwif_t *, void (*)(ide_hwif_t *));
+extern int probe_hwif_init(ide_hwif_t *);
+
+static inline void *ide_get_hwifdata (ide_hwif_t * hwif)
+{
+        return hwif->hwif_data;
+}
+
+static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data)
+{
+        hwif->hwif_data = data;
+}
+
+/* ide-lib.c */
+extern u8 ide_dma_speed(ide_drive_t *drive, u8 mode);
+extern u8 ide_rate_filter(u8 mode, u8 speed); 
+extern int ide_dma_enable(ide_drive_t *drive);
+extern char *ide_xfer_verbose(u8 xfer_rate);
+extern void ide_toggle_bounce(ide_drive_t *drive, int on);
+extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);
+
+u8 ide_dump_status(ide_drive_t *, const char *, u8);
+
+typedef struct ide_pio_timings_s {
+        int     setup_time;     /* Address setup (ns) minimum */
+        int     active_time;    /* Active pulse (ns) minimum */
+        int     cycle_time;     /* Cycle time (ns) minimum = (setup + active + recovery) */
+} ide_pio_timings_t;
+
+typedef struct ide_pio_data_s {
+        u8 pio_mode;
+        u8 use_iordy;
+        u8 overridden;
+        u8 blacklisted;
+        unsigned int cycle_time;
+} ide_pio_data_t;
+
+extern u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d);
+extern const ide_pio_timings_t ide_pio_timings[6];
+
+
+extern spinlock_t ide_lock;
+extern struct semaphore ide_cfg_sem;
+/*
+ * Structure locking:
+ *
+ * ide_cfg_sem and ide_lock together protect changes to
+ * ide_hwif_t->{next,hwgroup}
+ * ide_drive_t->next
+ *
+ * ide_hwgroup_t->busy: ide_lock
+ * ide_hwgroup_t->hwif: ide_lock
+ * ide_hwif_t->mate: constant, no locking
+ * ide_drive_t->hwif: constant, no locking
+ */
+
+#define local_irq_set(flags)    do { local_save_flags((flags)); local_irq_enable(); } while (0)
+
+extern struct bus_type ide_bus_type;
+
+/* check if CACHE FLUSH (EXT) command is supported (bits defined in ATA-6) */
+#define ide_id_has_flush_cache(id)      ((id)->cfs_enable_2 & 0x3000)
+
+/* some Maxtor disks have bit 13 defined incorrectly so check bit 10 too */
+#define ide_id_has_flush_cache_ext(id)  \
+        (((id)->cfs_enable_2 & 0x2400) == 0x2400)
+
+#endif /* _IDE_H */
diff --git a/include/linux/idr.h b/include/linux/idr.h
new file mode 100644
index 000000000000..ca3b7e462576
--- /dev/null
+++ b/include/linux/idr.h
@@ -0,0 +1,78 @@
+/*
+ * include/linux/idr.h
+ * 
+ * 2002-10-18  written by Jim Houston jim.houston@ccur.com
+ *      Copyright (C) 2002 by Concurrent Computer Corporation
+ *      Distributed under the GNU GPL license version 2.
+ *
+ * Small id to pointer translation service avoiding fixed sized
+ * tables.
+ */
+#include <linux/types.h>
+#include <linux/bitops.h>
+
+#if BITS_PER_LONG == 32
+# define IDR_BITS 5
+# define IDR_FULL 0xfffffffful
+/* We can only use two of the bits in the top level because there is
+   only one possible bit in the top level (5 bits * 7 levels = 35
+   bits, but you only use 31 bits in the id). */
+# define TOP_LEVEL_FULL (IDR_FULL >> 30)
+#elif BITS_PER_LONG == 64
+# define IDR_BITS 6
+# define IDR_FULL 0xfffffffffffffffful
+/* We can only use two of the bits in the top level because there is
+   only one possible bit in the top level (6 bits * 6 levels = 36
+   bits, but you only use 31 bits in the id). */
+# define TOP_LEVEL_FULL (IDR_FULL >> 62)
+#else
+# error "BITS_PER_LONG is not 32 or 64"
+#endif
+
+#define IDR_SIZE (1 << IDR_BITS)
+#define IDR_MASK ((1 << IDR_BITS)-1)
+
+#define MAX_ID_SHIFT (sizeof(int)*8 - 1)
+#define MAX_ID_BIT (1U << MAX_ID_SHIFT)
+#define MAX_ID_MASK (MAX_ID_BIT - 1)
+
+/* Leave the possibility of an incomplete final layer */
+#define MAX_LEVEL (MAX_ID_SHIFT + IDR_BITS - 1) / IDR_BITS
+
+/* Number of id_layer structs to leave in free list */
+#define IDR_FREE_MAX MAX_LEVEL + MAX_LEVEL
+
+struct idr_layer {
+        unsigned long            bitmap; /* A zero bit means "space here" */
+        struct idr_layer        *ary[1<<IDR_BITS];
+        int                      count;  /* When zero, we can release it */
+};
+
+struct idr {
+        struct idr_layer *top;
+        struct idr_layer *id_free;
+        int               layers;
+        int               id_free_cnt;
+        spinlock_t        lock;
+};
+
+#define IDR_INIT(name)                                          \
+{                                                               \
+        .top            = NULL,                                 \
+        .id_free        = NULL,                                 \
+        .layers         = 0,                                    \
+        .id_free_cnt    = 0,                                    \
+        .lock           = SPIN_LOCK_UNLOCKED,                   \
+}
+#define DEFINE_IDR(name)        struct idr name = IDR_INIT(name)
+
+/*
+ * This is what we export.
+ */
+
+void *idr_find(struct idr *idp, int id);
+int idr_pre_get(struct idr *idp, unsigned gfp_mask);
+int idr_get_new(struct idr *idp, void *ptr, int *id);
+int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id);
+void idr_remove(struct idr *idp, int id);
+void idr_init(struct idr *idp);
diff --git a/include/linux/if.h b/include/linux/if.h
new file mode 100644
index 000000000000..110282dbd3e0
--- /dev/null
+++ b/include/linux/if.h
@@ -0,0 +1,193 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the INET interface module.
+ *
+ * Version:     @(#)if.h        1.0.2   04/18/93
+ *
+ * Authors:     Original taken from Berkeley UNIX 4.3, (c) UCB 1982-1988
+ *              Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_H
+#define _LINUX_IF_H
+
+#include <linux/types.h>                /* for "__kernel_caddr_t" et al */
+#include <linux/socket.h>               /* for "struct sockaddr" et al  */
+#include <linux/compiler.h>             /* for "__user" et al           */
+
+#define IFNAMSIZ        16
+#include <linux/hdlc/ioctl.h>
+
+/* Standard interface flags (netdevice->flags). */
+#define IFF_UP          0x1             /* interface is up              */
+#define IFF_BROADCAST   0x2             /* broadcast address valid      */
+#define IFF_DEBUG       0x4             /* turn on debugging            */
+#define IFF_LOOPBACK    0x8             /* is a loopback net            */
+#define IFF_POINTOPOINT 0x10            /* interface is has p-p link    */
+#define IFF_NOTRAILERS  0x20            /* avoid use of trailers        */
+#define IFF_RUNNING     0x40            /* resources allocated          */
+#define IFF_NOARP       0x80            /* no ARP protocol              */
+#define IFF_PROMISC     0x100           /* receive all packets          */
+#define IFF_ALLMULTI    0x200           /* receive all multicast packets*/
+
+#define IFF_MASTER      0x400           /* master of a load balancer    */
+#define IFF_SLAVE       0x800           /* slave of a load balancer     */
+
+#define IFF_MULTICAST   0x1000          /* Supports multicast           */
+
+#define IFF_VOLATILE    (IFF_LOOPBACK|IFF_POINTOPOINT|IFF_BROADCAST|IFF_MASTER|IFF_SLAVE|IFF_RUNNING)
+
+#define IFF_PORTSEL     0x2000          /* can set media type           */
+#define IFF_AUTOMEDIA   0x4000          /* auto media select active     */
+#define IFF_DYNAMIC     0x8000          /* dialup device with changing addresses*/
+
+/* Private (from user) interface flags (netdevice->priv_flags). */
+#define IFF_802_1Q_VLAN 0x1             /* 802.1Q VLAN device.          */
+#define IFF_EBRIDGE     0x2             /* Ethernet bridging device.    */
+
+#define IF_GET_IFACE    0x0001          /* for querying only */
+#define IF_GET_PROTO    0x0002
+
+/* For definitions see hdlc.h */
+#define IF_IFACE_V35    0x1000          /* V.35 serial interface        */
+#define IF_IFACE_V24    0x1001          /* V.24 serial interface        */
+#define IF_IFACE_X21    0x1002          /* X.21 serial interface        */
+#define IF_IFACE_T1     0x1003          /* T1 telco serial interface    */
+#define IF_IFACE_E1     0x1004          /* E1 telco serial interface    */
+#define IF_IFACE_SYNC_SERIAL 0x1005     /* can't be set by software     */
+#define IF_IFACE_X21D   0x1006          /* X.21 Dual Clocking (FarSite) */
+
+/* For definitions see hdlc.h */
+#define IF_PROTO_HDLC   0x2000          /* raw HDLC protocol            */
+#define IF_PROTO_PPP    0x2001          /* PPP protocol                 */
+#define IF_PROTO_CISCO  0x2002          /* Cisco HDLC protocol          */
+#define IF_PROTO_FR     0x2003          /* Frame Relay protocol         */
+#define IF_PROTO_FR_ADD_PVC 0x2004      /*    Create FR PVC             */
+#define IF_PROTO_FR_DEL_PVC 0x2005      /*    Delete FR PVC             */
+#define IF_PROTO_X25    0x2006          /* X.25                         */
+#define IF_PROTO_HDLC_ETH 0x2007        /* raw HDLC, Ethernet emulation */
+#define IF_PROTO_FR_ADD_ETH_PVC 0x2008  /*  Create FR Ethernet-bridged PVC */
+#define IF_PROTO_FR_DEL_ETH_PVC 0x2009  /*  Delete FR Ethernet-bridged PVC */
+#define IF_PROTO_FR_PVC 0x200A          /* for reading PVC status       */
+#define IF_PROTO_FR_ETH_PVC 0x200B
+#define IF_PROTO_RAW    0x200C          /* RAW Socket                   */
+
+
+/*
+ *      Device mapping structure. I'd just gone off and designed a 
+ *      beautiful scheme using only loadable modules with arguments
+ *      for driver options and along come the PCMCIA people 8)
+ *
+ *      Ah well. The get() side of this is good for WDSETUP, and it'll
+ *      be handy for debugging things. The set side is fine for now and
+ *      being very small might be worth keeping for clean configuration.
+ */
+
+struct ifmap 
+{
+        unsigned long mem_start;
+        unsigned long mem_end;
+        unsigned short base_addr; 
+        unsigned char irq;
+        unsigned char dma;
+        unsigned char port;
+        /* 3 bytes spare */
+};
+
+struct if_settings
+{
+        unsigned int type;      /* Type of physical device or protocol */
+        unsigned int size;      /* Size of the data allocated by the caller */
+        union {
+                /* {atm/eth/dsl}_settings anyone ? */
+                raw_hdlc_proto          __user *raw_hdlc;
+                cisco_proto             __user *cisco;
+                fr_proto                __user *fr;
+                fr_proto_pvc            __user *fr_pvc;
+                fr_proto_pvc_info       __user *fr_pvc_info;
+
+                /* interface settings */
+                sync_serial_settings    __user *sync;
+                te1_settings            __user *te1;
+        } ifs_ifsu;
+};
+
+/*
+ * Interface request structure used for socket
+ * ioctl's.  All interface ioctl's must have parameter
+ * definitions which begin with ifr_name.  The
+ * remainder may be interface specific.
+ */
+
+struct ifreq 
+{
+#define IFHWADDRLEN     6
+        union
+        {
+                char    ifrn_name[IFNAMSIZ];            /* if name, e.g. "en0" */
+        } ifr_ifrn;
+        
+        union {
+                struct  sockaddr ifru_addr;
+                struct  sockaddr ifru_dstaddr;
+                struct  sockaddr ifru_broadaddr;
+                struct  sockaddr ifru_netmask;
+                struct  sockaddr ifru_hwaddr;
+                short   ifru_flags;
+                int     ifru_ivalue;
+                int     ifru_mtu;
+                struct  ifmap ifru_map;
+                char    ifru_slave[IFNAMSIZ];   /* Just fits the size */
+                char    ifru_newname[IFNAMSIZ];
+                void __user *   ifru_data;
+                struct  if_settings ifru_settings;
+        } ifr_ifru;
+};
+
+#define ifr_name        ifr_ifrn.ifrn_name      /* interface name       */
+#define ifr_hwaddr      ifr_ifru.ifru_hwaddr    /* MAC address          */
+#define ifr_addr        ifr_ifru.ifru_addr      /* address              */
+#define ifr_dstaddr     ifr_ifru.ifru_dstaddr   /* other end of p-p lnk */
+#define ifr_broadaddr   ifr_ifru.ifru_broadaddr /* broadcast address    */
+#define ifr_netmask     ifr_ifru.ifru_netmask   /* interface net mask   */
+#define ifr_flags       ifr_ifru.ifru_flags     /* flags                */
+#define ifr_metric      ifr_ifru.ifru_ivalue    /* metric               */
+#define ifr_mtu         ifr_ifru.ifru_mtu       /* mtu                  */
+#define ifr_map         ifr_ifru.ifru_map       /* device map           */
+#define ifr_slave       ifr_ifru.ifru_slave     /* slave device         */
+#define ifr_data        ifr_ifru.ifru_data      /* for use by interface */
+#define ifr_ifindex     ifr_ifru.ifru_ivalue    /* interface index      */
+#define ifr_bandwidth   ifr_ifru.ifru_ivalue    /* link bandwidth       */
+#define ifr_qlen        ifr_ifru.ifru_ivalue    /* Queue length         */
+#define ifr_newname     ifr_ifru.ifru_newname   /* New name             */
+#define ifr_settings    ifr_ifru.ifru_settings  /* Device/proto settings*/
+
+/*
+ * Structure used in SIOCGIFCONF request.
+ * Used to retrieve interface configuration
+ * for machine (useful for programs which
+ * must know all networks accessible).
+ */
+
+struct ifconf 
+{
+        int     ifc_len;                        /* size of buffer       */
+        union 
+        {
+                char __user *ifcu_buf;
+                struct ifreq __user *ifcu_req;
+        } ifc_ifcu;
+};
+#define ifc_buf ifc_ifcu.ifcu_buf               /* buffer address       */
+#define ifc_req ifc_ifcu.ifcu_req               /* array of structures  */
+
+
+#endif /* _LINUX_IF_H */
diff --git a/include/linux/if_arcnet.h b/include/linux/if_arcnet.h
new file mode 100644
index 000000000000..af380cb876a0
--- /dev/null
+++ b/include/linux/if_arcnet.h
@@ -0,0 +1,137 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the ARCnet interface.
+ *
+ * Authors:     David Woodhouse and Avery Pennarun
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_IF_ARCNET_H
+#define _LINUX_IF_ARCNET_H
+
+#include <linux/if_ether.h>
+
+
+/*
+ *    These are the defined ARCnet Protocol ID's.
+ */
+
+/* CAP mode */
+/* No macro but uses 1-8 */
+
+/* RFC1201 Protocol ID's */
+#define ARC_P_IP                212     /* 0xD4 */
+#define ARC_P_IPV6              196     /* 0xC4: RFC2497 */
+#define ARC_P_ARP               213     /* 0xD5 */
+#define ARC_P_RARP              214     /* 0xD6 */
+#define ARC_P_IPX               250     /* 0xFA */
+#define ARC_P_NOVELL_EC         236     /* 0xEC */
+
+/* Old RFC1051 Protocol ID's */
+#define ARC_P_IP_RFC1051        240     /* 0xF0 */
+#define ARC_P_ARP_RFC1051       241     /* 0xF1 */
+
+/* MS LanMan/WfWg "NDIS" encapsulation */
+#define ARC_P_ETHER             232     /* 0xE8 */
+
+/* Unsupported/indirectly supported protocols */
+#define ARC_P_DATAPOINT_BOOT    0       /* very old Datapoint equipment */
+#define ARC_P_DATAPOINT_MOUNT   1
+#define ARC_P_POWERLAN_BEACON   8       /* Probably ATA-Netbios related */
+#define ARC_P_POWERLAN_BEACON2  243     /* 0xF3 */
+#define ARC_P_LANSOFT           251     /* 0xFB - what is this? */
+#define ARC_P_ATALK             0xDD
+
+/* Hardware address length */
+#define ARCNET_ALEN     1
+
+/*
+ * The RFC1201-specific components of an arcnet packet header.
+ */
+struct arc_rfc1201
+{
+    uint8_t  proto;             /* protocol ID field - varies           */
+    uint8_t  split_flag;        /* for use with split packets           */
+    uint16_t sequence;          /* sequence number                      */
+    uint8_t  payload[0];        /* space remaining in packet (504 bytes)*/
+};
+#define RFC1201_HDR_SIZE 4
+
+
+/*
+ * The RFC1051-specific components.
+ */
+struct arc_rfc1051
+{
+    uint8_t proto;              /* ARC_P_RFC1051_ARP/RFC1051_IP */
+    uint8_t payload[0];         /* 507 bytes                    */
+};
+#define RFC1051_HDR_SIZE 1
+
+
+/*
+ * The ethernet-encap-specific components.  We have a real ethernet header
+ * and some data.
+ */
+struct arc_eth_encap
+{
+    uint8_t proto;              /* Always ARC_P_ETHER                   */
+    struct ethhdr eth;          /* standard ethernet header (yuck!)     */
+    uint8_t payload[0];         /* 493 bytes                            */
+};
+#define ETH_ENCAP_HDR_SIZE 14
+
+
+struct arc_cap
+{
+        uint8_t proto;
+        uint8_t cookie[sizeof(int)];   /* Actually NOT sent over the network */
+        union {
+                uint8_t ack;
+                uint8_t raw[0];         /* 507 bytes */
+        } mes;
+};
+
+/*
+ * The data needed by the actual arcnet hardware.
+ *
+ * Now, in the real arcnet hardware, the third and fourth bytes are the
+ * 'offset' specification instead of the length, and the soft data is at
+ * the _end_ of the 512-byte buffer.  We hide this complexity inside the
+ * driver.
+ */
+struct arc_hardware
+{
+    uint8_t  source,            /* source ARCnet - filled in automagically */
+             dest,              /* destination ARCnet - 0 for broadcast    */
+             offset[2];         /* offset bytes (some weird semantics)     */
+};
+#define ARC_HDR_SIZE 4
+
+/*
+ * This is an ARCnet frame header, as seen by the kernel (and userspace,
+ * when you do a raw packet capture).
+ */
+struct archdr
+{
+    /* hardware requirements */
+    struct arc_hardware hard;
+     
+    /* arcnet encapsulation-specific bits */
+    union {
+        struct arc_rfc1201   rfc1201;
+        struct arc_rfc1051   rfc1051;
+        struct arc_eth_encap eth_encap;
+        struct arc_cap       cap;
+        uint8_t raw[0];         /* 508 bytes                            */
+    } soft;
+};
+
+#endif                          /* _LINUX_IF_ARCNET_H */
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
new file mode 100644
index 000000000000..bbf49bcd7705
--- /dev/null
+++ b/include/linux/if_arp.h
@@ -0,0 +1,150 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the ARP (RFC 826) protocol.
+ *
+ * Version:     @(#)if_arp.h    1.0.1   04/16/93
+ *
+ * Authors:     Original taken from Berkeley UNIX 4.3, (c) UCB 1986-1988
+ *              Portions taken from the KA9Q/NOS (v2.00m PA0GRI) source.
+ *              Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Florian La Roche,
+ *              Jonathan Layes <layes@loran.com>
+ *              Arnaldo Carvalho de Melo <acme@conectiva.com.br> ARPHRD_HWX25
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_ARP_H
+#define _LINUX_IF_ARP_H
+
+#include <linux/netdevice.h>
+
+/* ARP protocol HARDWARE identifiers. */
+#define ARPHRD_NETROM   0               /* from KA9Q: NET/ROM pseudo    */
+#define ARPHRD_ETHER    1               /* Ethernet 10Mbps              */
+#define ARPHRD_EETHER   2               /* Experimental Ethernet        */
+#define ARPHRD_AX25     3               /* AX.25 Level 2                */
+#define ARPHRD_PRONET   4               /* PROnet token ring            */
+#define ARPHRD_CHAOS    5               /* Chaosnet                     */
+#define ARPHRD_IEEE802  6               /* IEEE 802.2 Ethernet/TR/TB    */
+#define ARPHRD_ARCNET   7               /* ARCnet                       */
+#define ARPHRD_APPLETLK 8               /* APPLEtalk                    */
+#define ARPHRD_DLCI     15              /* Frame Relay DLCI             */
+#define ARPHRD_ATM      19              /* ATM                          */
+#define ARPHRD_METRICOM 23              /* Metricom STRIP (new IANA id) */
+#define ARPHRD_IEEE1394 24              /* IEEE 1394 IPv4 - RFC 2734    */
+#define ARPHRD_EUI64    27              /* EUI-64                       */
+#define ARPHRD_INFINIBAND 32            /* InfiniBand                   */
+
+/* Dummy types for non ARP hardware */
+#define ARPHRD_SLIP     256
+#define ARPHRD_CSLIP    257
+#define ARPHRD_SLIP6    258
+#define ARPHRD_CSLIP6   259
+#define ARPHRD_RSRVD    260             /* Notional KISS type           */
+#define ARPHRD_ADAPT    264
+#define ARPHRD_ROSE     270
+#define ARPHRD_X25      271             /* CCITT X.25                   */
+#define ARPHRD_HWX25    272             /* Boards with X.25 in firmware */
+#define ARPHRD_PPP      512
+#define ARPHRD_CISCO    513             /* Cisco HDLC                   */
+#define ARPHRD_HDLC     ARPHRD_CISCO
+#define ARPHRD_LAPB     516             /* LAPB                         */
+#define ARPHRD_DDCMP    517             /* Digital's DDCMP protocol     */
+#define ARPHRD_RAWHDLC  518             /* Raw HDLC                     */
+
+#define ARPHRD_TUNNEL   768             /* IPIP tunnel                  */
+#define ARPHRD_TUNNEL6  769             /* IP6IP6 tunnel                */
+#define ARPHRD_FRAD     770             /* Frame Relay Access Device    */
+#define ARPHRD_SKIP     771             /* SKIP vif                     */
+#define ARPHRD_LOOPBACK 772             /* Loopback device              */
+#define ARPHRD_LOCALTLK 773             /* Localtalk device             */
+#define ARPHRD_FDDI     774             /* Fiber Distributed Data Interface */
+#define ARPHRD_BIF      775             /* AP1000 BIF                   */
+#define ARPHRD_SIT      776             /* sit0 device - IPv6-in-IPv4   */
+#define ARPHRD_IPDDP    777             /* IP over DDP tunneller        */
+#define ARPHRD_IPGRE    778             /* GRE over IP                  */
+#define ARPHRD_PIMREG   779             /* PIMSM register interface     */
+#define ARPHRD_HIPPI    780             /* High Performance Parallel Interface */
+#define ARPHRD_ASH      781             /* Nexus 64Mbps Ash             */
+#define ARPHRD_ECONET   782             /* Acorn Econet                 */
+#define ARPHRD_IRDA     783             /* Linux-IrDA                   */
+/* ARP works differently on different FC media .. so  */
+#define ARPHRD_FCPP     784             /* Point to point fibrechannel  */
+#define ARPHRD_FCAL     785             /* Fibrechannel arbitrated loop */
+#define ARPHRD_FCPL     786             /* Fibrechannel public loop     */
+#define ARPHRD_FCFABRIC 787             /* Fibrechannel fabric          */
+        /* 787->799 reserved for fibrechannel media types */
+#define ARPHRD_IEEE802_TR 800           /* Magic type ident for TR      */
+#define ARPHRD_IEEE80211 801            /* IEEE 802.11                  */
+#define ARPHRD_IEEE80211_PRISM 802      /* IEEE 802.11 + Prism2 header  */
+
+#define ARPHRD_VOID       0xFFFF        /* Void type, nothing is known */
+#define ARPHRD_NONE       0xFFFE        /* zero header length */
+
+/* ARP protocol opcodes. */
+#define ARPOP_REQUEST   1               /* ARP request                  */
+#define ARPOP_REPLY     2               /* ARP reply                    */
+#define ARPOP_RREQUEST  3               /* RARP request                 */
+#define ARPOP_RREPLY    4               /* RARP reply                   */
+#define ARPOP_InREQUEST 8               /* InARP request                */
+#define ARPOP_InREPLY   9               /* InARP reply                  */
+#define ARPOP_NAK       10              /* (ATM)ARP NAK                 */
+
+
+/* ARP ioctl request. */
+struct arpreq {
+  struct sockaddr       arp_pa;         /* protocol address             */
+  struct sockaddr       arp_ha;         /* hardware address             */
+  int                   arp_flags;      /* flags                        */
+  struct sockaddr       arp_netmask;    /* netmask (only for proxy arps) */
+  char                  arp_dev[16];
+};
+
+struct arpreq_old {
+  struct sockaddr       arp_pa;         /* protocol address             */
+  struct sockaddr       arp_ha;         /* hardware address             */
+  int                   arp_flags;      /* flags                        */
+  struct sockaddr       arp_netmask;    /* netmask (only for proxy arps) */
+};
+
+/* ARP Flag values. */
+#define ATF_COM         0x02            /* completed entry (ha valid)   */
+#define ATF_PERM        0x04            /* permanent entry              */
+#define ATF_PUBL        0x08            /* publish entry                */
+#define ATF_USETRAILERS 0x10            /* has requested trailers       */
+#define ATF_NETMASK     0x20            /* want to use a netmask (only
+                                           for proxy entries) */
+#define ATF_DONTPUB     0x40            /* don't answer this addresses  */
+
+/*
+ *      This structure defines an ethernet arp header.
+ */
+
+struct arphdr
+{
+        unsigned short  ar_hrd;         /* format of hardware address   */
+        unsigned short  ar_pro;         /* format of protocol address   */
+        unsigned char   ar_hln;         /* length of hardware address   */
+        unsigned char   ar_pln;         /* length of protocol address   */
+        unsigned short  ar_op;          /* ARP opcode (command)         */
+
+#if 0
+         /*
+          *      Ethernet looks like this : This bit is variable sized however...
+          */
+        unsigned char           ar_sha[ETH_ALEN];       /* sender hardware address      */
+        unsigned char           ar_sip[4];              /* sender IP address            */
+        unsigned char           ar_tha[ETH_ALEN];       /* target hardware address      */
+        unsigned char           ar_tip[4];              /* target IP address            */
+#endif
+
+};
+
+#endif  /* _LINUX_IF_ARP_H */
diff --git a/include/linux/if_bonding.h b/include/linux/if_bonding.h
new file mode 100644
index 000000000000..57024ce2c74f
--- /dev/null
+++ b/include/linux/if_bonding.h
@@ -0,0 +1,117 @@
+/*
+ * Bond several ethernet interfaces into a Cisco, running 'Etherchannel'.
+ *
+ *
+ * Portions are (c) Copyright 1995 Simon "Guru Aleph-Null" Janes
+ * NCM: Network and Communications Management, Inc.
+ *
+ * BUT, I'm the one who modified it for ethernet, so:
+ * (c) Copyright 1999, Thomas Davis, tadavis@lbl.gov
+ *
+ *      This software may be used and distributed according to the terms
+ *      of the GNU Public License, incorporated herein by reference.
+ *
+ * 2003/03/18 - Amir Noam <amir.noam at intel dot com>
+ *      - Added support for getting slave's speed and duplex via ethtool.
+ *        Needed for 802.3ad and other future modes.
+ *
+ * 2003/03/18 - Tsippy Mendelson <tsippy.mendelson at intel dot com> and
+ *              Shmulik Hen <shmulik.hen at intel dot com>
+ *      - Enable support of modes that need to use the unique mac address of
+ *        each slave.
+ *
+ * 2003/03/18 - Tsippy Mendelson <tsippy.mendelson at intel dot com> and
+ *              Amir Noam <amir.noam at intel dot com>
+ *      - Moved driver's private data types to bonding.h
+ *
+ * 2003/03/18 - Amir Noam <amir.noam at intel dot com>,
+ *              Tsippy Mendelson <tsippy.mendelson at intel dot com> and
+ *              Shmulik Hen <shmulik.hen at intel dot com>
+ *      - Added support for IEEE 802.3ad Dynamic link aggregation mode.
+ *
+ * 2003/05/01 - Amir Noam <amir.noam at intel dot com>
+ *      - Added ABI version control to restore compatibility between
+ *        new/old ifenslave and new/old bonding.
+ *
+ * 2003/12/01 - Shmulik Hen <shmulik.hen at intel dot com>
+ *      - Code cleanup and style changes
+ */
+
+#ifndef _LINUX_IF_BONDING_H
+#define _LINUX_IF_BONDING_H
+
+#include <linux/if.h>
+#include <linux/types.h>
+#include <linux/if_ether.h>
+
+/* userland - kernel ABI version (2003/05/08) */
+#define BOND_ABI_VERSION 2
+
+/*
+ * We can remove these ioctl definitions in 2.5.  People should use the
+ * SIOC*** versions of them instead
+ */
+#define BOND_ENSLAVE_OLD                (SIOCDEVPRIVATE)
+#define BOND_RELEASE_OLD                (SIOCDEVPRIVATE + 1)
+#define BOND_SETHWADDR_OLD              (SIOCDEVPRIVATE + 2)
+#define BOND_SLAVE_INFO_QUERY_OLD       (SIOCDEVPRIVATE + 11)
+#define BOND_INFO_QUERY_OLD             (SIOCDEVPRIVATE + 12)
+#define BOND_CHANGE_ACTIVE_OLD          (SIOCDEVPRIVATE + 13)
+
+#define BOND_CHECK_MII_STATUS   (SIOCGMIIPHY)
+
+#define BOND_MODE_ROUNDROBIN    0
+#define BOND_MODE_ACTIVEBACKUP  1
+#define BOND_MODE_XOR           2
+#define BOND_MODE_BROADCAST     3
+#define BOND_MODE_8023AD        4
+#define BOND_MODE_TLB           5
+#define BOND_MODE_ALB           6 /* TLB + RLB (receive load balancing) */
+
+/* each slave's link has 4 states */
+#define BOND_LINK_UP    0           /* link is up and running */
+#define BOND_LINK_FAIL  1           /* link has just gone down */
+#define BOND_LINK_DOWN  2           /* link has been down for too long time */
+#define BOND_LINK_BACK  3           /* link is going back */
+
+/* each slave has several states */
+#define BOND_STATE_ACTIVE       0   /* link is active */
+#define BOND_STATE_BACKUP       1   /* link is backup */
+
+#define BOND_DEFAULT_MAX_BONDS  1   /* Default maximum number of devices to support */
+
+typedef struct ifbond {
+        __s32 bond_mode;
+        __s32 num_slaves;
+        __s32 miimon;
+} ifbond;
+
+typedef struct ifslave
+{
+        __s32 slave_id; /* Used as an IN param to the BOND_SLAVE_INFO_QUERY ioctl */
+        char slave_name[IFNAMSIZ];
+        __s8 link;
+        __s8 state;
+        __u32  link_failure_count;
+} ifslave;
+
+struct ad_info {
+        __u16 aggregator_id;
+        __u16 ports;
+        __u16 actor_key;
+        __u16 partner_key;
+        __u8 partner_system[ETH_ALEN];
+};
+
+#endif /* _LINUX_IF_BONDING_H */
+
+/*
+ * Local variables:
+ *  version-control: t
+ *  kept-new-versions: 5
+ *  c-indent-level: 8
+ *  c-basic-offset: 8
+ *  tab-width: 8
+ * End:
+ */
+
diff --git a/include/linux/if_bridge.h b/include/linux/if_bridge.h
new file mode 100644
index 000000000000..fd1b6eb94a5f
--- /dev/null
+++ b/include/linux/if_bridge.h
@@ -0,0 +1,113 @@
+/*
+ *      Linux ethernet bridge
+ *
+ *      Authors:
+ *      Lennert Buytenhek               <buytenh@gnu.org>
+ *
+ *      $Id: if_bridge.h,v 1.1 2000/02/18 16:47:01 davem Exp $
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_IF_BRIDGE_H
+#define _LINUX_IF_BRIDGE_H
+
+#include <linux/types.h>
+
+#define SYSFS_BRIDGE_ATTR       "bridge"
+#define SYSFS_BRIDGE_FDB        "brforward"
+#define SYSFS_BRIDGE_PORT_SUBDIR "brif"
+#define SYSFS_BRIDGE_PORT_ATTR  "brport"
+#define SYSFS_BRIDGE_PORT_LINK  "bridge"
+
+#define BRCTL_VERSION 1
+
+#define BRCTL_GET_VERSION 0
+#define BRCTL_GET_BRIDGES 1
+#define BRCTL_ADD_BRIDGE 2
+#define BRCTL_DEL_BRIDGE 3
+#define BRCTL_ADD_IF 4
+#define BRCTL_DEL_IF 5
+#define BRCTL_GET_BRIDGE_INFO 6
+#define BRCTL_GET_PORT_LIST 7
+#define BRCTL_SET_BRIDGE_FORWARD_DELAY 8
+#define BRCTL_SET_BRIDGE_HELLO_TIME 9
+#define BRCTL_SET_BRIDGE_MAX_AGE 10
+#define BRCTL_SET_AGEING_TIME 11
+#define BRCTL_SET_GC_INTERVAL 12
+#define BRCTL_GET_PORT_INFO 13
+#define BRCTL_SET_BRIDGE_STP_STATE 14
+#define BRCTL_SET_BRIDGE_PRIORITY 15
+#define BRCTL_SET_PORT_PRIORITY 16
+#define BRCTL_SET_PATH_COST 17
+#define BRCTL_GET_FDB_ENTRIES 18
+
+#define BR_STATE_DISABLED 0
+#define BR_STATE_LISTENING 1
+#define BR_STATE_LEARNING 2
+#define BR_STATE_FORWARDING 3
+#define BR_STATE_BLOCKING 4
+
+struct __bridge_info
+{
+        __u64 designated_root;
+        __u64 bridge_id;
+        __u32 root_path_cost;
+        __u32 max_age;
+        __u32 hello_time;
+        __u32 forward_delay;
+        __u32 bridge_max_age;
+        __u32 bridge_hello_time;
+        __u32 bridge_forward_delay;
+        __u8 topology_change;
+        __u8 topology_change_detected;
+        __u8 root_port;
+        __u8 stp_enabled;
+        __u32 ageing_time;
+        __u32 gc_interval;
+        __u32 hello_timer_value;
+        __u32 tcn_timer_value;
+        __u32 topology_change_timer_value;
+        __u32 gc_timer_value;
+};
+
+struct __port_info
+{
+        __u64 designated_root;
+        __u64 designated_bridge;
+        __u16 port_id;
+        __u16 designated_port;
+        __u32 path_cost;
+        __u32 designated_cost;
+        __u8 state;
+        __u8 top_change_ack;
+        __u8 config_pending;
+        __u8 unused0;
+        __u32 message_age_timer_value;
+        __u32 forward_delay_timer_value;
+        __u32 hold_timer_value;
+};
+
+struct __fdb_entry
+{
+        __u8 mac_addr[6];
+        __u8 port_no;
+        __u8 is_local;
+        __u32 ageing_timer_value;
+        __u32 unused;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/netdevice.h>
+
+extern void brioctl_set(int (*ioctl_hook)(unsigned int, void __user *));
+extern int (*br_handle_frame_hook)(struct net_bridge_port *p, struct sk_buff **pskb);
+extern int (*br_should_route_hook)(struct sk_buff **pskb);
+
+#endif
+
+#endif
diff --git a/include/linux/if_cablemodem.h b/include/linux/if_cablemodem.h
new file mode 100644
index 000000000000..9ca1007edd93
--- /dev/null
+++ b/include/linux/if_cablemodem.h
@@ -0,0 +1,22 @@
+#ifndef _LINUX_CABLEMODEM_H_
+#define _LINUX_CABLEMODEM_H_
+/*
+ *              Author: Franco Venturi <fventuri@mediaone.net>
+ *              Copyright 1998 Franco Venturi
+ *
+ *              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;  either  version 2 of the License, or  (at
+ *              your option) any later version.
+ */
+
+/* some useful defines for sb1000.c e cmconfig.c - fv */
+#define SIOCGCMSTATS            SIOCDEVPRIVATE+0        /* get cable modem stats */
+#define SIOCGCMFIRMWARE         SIOCDEVPRIVATE+1        /* get cm firmware version */
+#define SIOCGCMFREQUENCY        SIOCDEVPRIVATE+2        /* get cable modem frequency */
+#define SIOCSCMFREQUENCY        SIOCDEVPRIVATE+3        /* set cable modem frequency */
+#define SIOCGCMPIDS                     SIOCDEVPRIVATE+4        /* get cable modem PIDs */
+#define SIOCSCMPIDS                     SIOCDEVPRIVATE+5        /* set cable modem PIDs */
+
+#endif
diff --git a/include/linux/if_ec.h b/include/linux/if_ec.h
new file mode 100644
index 000000000000..e7499aa79783
--- /dev/null
+++ b/include/linux/if_ec.h
@@ -0,0 +1,72 @@
+/* Definitions for Econet sockets. */
+
+#ifndef __LINUX_IF_EC
+#define __LINUX_IF_EC
+
+/* User visible stuff. Glibc provides its own but libc5 folk will use these */
+
+struct ec_addr
+{
+  unsigned char station;                /* Station number.  */
+  unsigned char net;                    /* Network number.  */
+};
+
+struct sockaddr_ec
+{
+  unsigned short sec_family;
+  unsigned char port;                   /* Port number.  */
+  unsigned char cb;                     /* Control/flag byte.  */
+  unsigned char type;                   /* Type of message.  */
+  struct ec_addr addr;
+  unsigned long cookie;
+};
+
+#define ECTYPE_PACKET_RECEIVED          0       /* Packet received */
+#define ECTYPE_TRANSMIT_STATUS          0x10    /* Transmit completed, 
+                                                   low nibble holds status */
+
+#define ECTYPE_TRANSMIT_OK              1
+#define ECTYPE_TRANSMIT_NOT_LISTENING   2
+#define ECTYPE_TRANSMIT_NET_ERROR       3
+#define ECTYPE_TRANSMIT_NO_CLOCK        4
+#define ECTYPE_TRANSMIT_LINE_JAMMED     5
+#define ECTYPE_TRANSMIT_NOT_PRESENT     6
+
+#ifdef __KERNEL__
+
+#define EC_HLEN                         6
+
+/* This is what an Econet frame looks like on the wire. */
+struct ec_framehdr 
+{
+  unsigned char dst_stn;
+  unsigned char dst_net;
+  unsigned char src_stn;
+  unsigned char src_net;
+  unsigned char cb;
+  unsigned char port;
+};
+
+struct econet_sock {
+  /* struct sock has to be the first member of econet_sock */
+  struct sock   sk;
+  unsigned char cb;
+  unsigned char port;
+  unsigned char station;
+  unsigned char net;
+  unsigned short num;
+};
+
+static inline struct econet_sock *ec_sk(const struct sock *sk)
+{
+        return (struct econet_sock *)sk;
+}
+
+struct ec_device
+{
+  unsigned char station, net;           /* Econet protocol address */
+};
+
+#endif
+
+#endif
diff --git a/include/linux/if_eql.h b/include/linux/if_eql.h
new file mode 100644
index 000000000000..b68752fdc5c4
--- /dev/null
+++ b/include/linux/if_eql.h
@@ -0,0 +1,84 @@
+/*
+ * Equalizer Load-balancer for serial network interfaces.
+ *
+ * (c) Copyright 1995 Simon "Guru Aleph-Null" Janes
+ * NCM: Network and Communications Management, Inc.
+ *
+ *
+ *      This software may be used and distributed according to the terms
+ *      of the GNU General Public License, incorporated herein by reference.
+ * 
+ * The author may be reached as simon@ncm.com, or C/O
+ *    NCM
+ *    Attn: Simon Janes
+ *    6803 Whittier Ave
+ *    McLean VA 22101
+ *    Phone: 1-703-847-0040 ext 103
+ */
+
+#ifndef _LINUX_IF_EQL_H
+#define _LINUX_IF_EQL_H
+
+#define EQL_DEFAULT_SLAVE_PRIORITY 28800
+#define EQL_DEFAULT_MAX_SLAVES     4
+#define EQL_DEFAULT_MTU            576
+#define EQL_DEFAULT_RESCHED_IVAL   100
+
+#define EQL_ENSLAVE     (SIOCDEVPRIVATE)
+#define EQL_EMANCIPATE  (SIOCDEVPRIVATE + 1)
+
+#define EQL_GETSLAVECFG (SIOCDEVPRIVATE + 2)
+#define EQL_SETSLAVECFG (SIOCDEVPRIVATE + 3)
+
+#define EQL_GETMASTRCFG (SIOCDEVPRIVATE + 4)
+#define EQL_SETMASTRCFG (SIOCDEVPRIVATE + 5)
+
+#ifdef __KERNEL__
+
+#include <linux/timer.h>
+#include <linux/spinlock.h>
+
+typedef struct slave {
+        struct list_head        list;
+        struct net_device       *dev;
+        long                    priority;
+        long                    priority_bps;
+        long                    priority_Bps;
+        long                    bytes_queued;
+} slave_t;
+
+typedef struct slave_queue {
+        spinlock_t              lock;
+        struct list_head        all_slaves;
+        int                     num_slaves;
+        struct net_device       *master_dev;
+} slave_queue_t;
+
+typedef struct equalizer {
+        slave_queue_t           queue;
+        int                     min_slaves;
+        int                     max_slaves;
+        struct net_device_stats stats;
+        struct timer_list       timer;
+} equalizer_t;  
+
+#endif /* __KERNEL__ */
+
+typedef struct master_config {
+        char    master_name[16];
+        int     max_slaves;
+        int     min_slaves;
+} master_config_t;
+
+typedef struct slave_config {
+        char    slave_name[16];
+        long    priority;
+} slave_config_t;
+
+typedef struct slaving_request {
+        char    slave_name[16];
+        long    priority;
+} slaving_request_t;
+
+
+#endif /* _LINUX_EQL_H */
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
new file mode 100644
index 000000000000..b5b58e9c054c
--- /dev/null
+++ b/include/linux/if_ether.h
@@ -0,0 +1,115 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the Ethernet IEEE 802.3 interface.
+ *
+ * Version:     @(#)if_ether.h  1.0.1a  02/08/94
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Donald Becker, <becker@super.org>
+ *              Alan Cox, <alan@redhat.com>
+ *              Steve Whitehouse, <gw7rrm@eeshack3.swan.ac.uk>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+ 
+#ifndef _LINUX_IF_ETHER_H
+#define _LINUX_IF_ETHER_H
+
+/*
+ *      IEEE 802.3 Ethernet magic constants.  The frame sizes omit the preamble
+ *      and FCS/CRC (frame check sequence). 
+ */
+
+#define ETH_ALEN        6               /* Octets in one ethernet addr   */
+#define ETH_HLEN        14              /* Total octets in header.       */
+#define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
+#define ETH_DATA_LEN    1500            /* Max. octets in payload        */
+#define ETH_FRAME_LEN   1514            /* Max. octets in frame sans FCS */
+
+/*
+ *      These are the defined Ethernet Protocol ID's.
+ */
+
+#define ETH_P_LOOP      0x0060          /* Ethernet Loopback packet     */
+#define ETH_P_PUP       0x0200          /* Xerox PUP packet             */
+#define ETH_P_PUPAT     0x0201          /* Xerox PUP Addr Trans packet  */
+#define ETH_P_IP        0x0800          /* Internet Protocol packet     */
+#define ETH_P_X25       0x0805          /* CCITT X.25                   */
+#define ETH_P_ARP       0x0806          /* Address Resolution packet    */
+#define ETH_P_BPQ       0x08FF          /* G8BPQ AX.25 Ethernet Packet  [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_IEEEPUP   0x0a00          /* Xerox IEEE802.3 PUP packet */
+#define ETH_P_IEEEPUPAT 0x0a01          /* Xerox IEEE802.3 PUP Addr Trans packet */
+#define ETH_P_DEC       0x6000          /* DEC Assigned proto           */
+#define ETH_P_DNA_DL    0x6001          /* DEC DNA Dump/Load            */
+#define ETH_P_DNA_RC    0x6002          /* DEC DNA Remote Console       */
+#define ETH_P_DNA_RT    0x6003          /* DEC DNA Routing              */
+#define ETH_P_LAT       0x6004          /* DEC LAT                      */
+#define ETH_P_DIAG      0x6005          /* DEC Diagnostics              */
+#define ETH_P_CUST      0x6006          /* DEC Customer use             */
+#define ETH_P_SCA       0x6007          /* DEC Systems Comms Arch       */
+#define ETH_P_RARP      0x8035          /* Reverse Addr Res packet      */
+#define ETH_P_ATALK     0x809B          /* Appletalk DDP                */
+#define ETH_P_AARP      0x80F3          /* Appletalk AARP               */
+#define ETH_P_8021Q     0x8100          /* 802.1Q VLAN Extended Header  */
+#define ETH_P_IPX       0x8137          /* IPX over DIX                 */
+#define ETH_P_IPV6      0x86DD          /* IPv6 over bluebook           */
+#define ETH_P_WCCP      0x883E          /* Web-cache coordination protocol
+                                         * defined in draft-wilson-wrec-wccp-v2-00.txt */
+#define ETH_P_PPP_DISC  0x8863          /* PPPoE discovery messages     */
+#define ETH_P_PPP_SES   0x8864          /* PPPoE session messages       */
+#define ETH_P_MPLS_UC   0x8847          /* MPLS Unicast traffic         */
+#define ETH_P_MPLS_MC   0x8848          /* MPLS Multicast traffic       */
+#define ETH_P_ATMMPOA   0x884c          /* MultiProtocol Over ATM       */
+#define ETH_P_ATMFATE   0x8884          /* Frame-based ATM Transport
+                                         * over Ethernet
+                                         */
+#define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
+
+/*
+ *      Non DIX types. Won't clash for 1500 types.
+ */
+ 
+#define ETH_P_802_3     0x0001          /* Dummy type for 802.3 frames  */
+#define ETH_P_AX25      0x0002          /* Dummy protocol id for AX.25  */
+#define ETH_P_ALL       0x0003          /* Every packet (be careful!!!) */
+#define ETH_P_802_2     0x0004          /* 802.2 frames                 */
+#define ETH_P_SNAP      0x0005          /* Internal only                */
+#define ETH_P_DDCMP     0x0006          /* DEC DDCMP: Internal only     */
+#define ETH_P_WAN_PPP   0x0007          /* Dummy type for WAN PPP frames*/
+#define ETH_P_PPP_MP    0x0008          /* Dummy type for PPP MP frames */
+#define ETH_P_LOCALTALK 0x0009          /* Localtalk pseudo type        */
+#define ETH_P_PPPTALK   0x0010          /* Dummy type for Atalk over PPP*/
+#define ETH_P_TR_802_2  0x0011          /* 802.2 frames                 */
+#define ETH_P_MOBITEX   0x0015          /* Mobitex (kaz@cafe.net)       */
+#define ETH_P_CONTROL   0x0016          /* Card specific control frames */
+#define ETH_P_IRDA      0x0017          /* Linux-IrDA                   */
+#define ETH_P_ECONET    0x0018          /* Acorn Econet                 */
+#define ETH_P_HDLC      0x0019          /* HDLC frames                  */
+#define ETH_P_ARCNET    0x001A          /* 1A for ArcNet :-)            */
+
+/*
+ *      This is an Ethernet frame header.
+ */
+ 
+struct ethhdr {
+        unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
+        unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
+        unsigned short  h_proto;                /* packet type ID field */
+} __attribute__((packed));
+
+#ifdef __KERNEL__
+#include <linux/skbuff.h>
+
+static inline struct ethhdr *eth_hdr(const struct sk_buff *skb)
+{
+        return (struct ethhdr *)skb->mac.raw;
+}
+#endif
+
+#endif  /* _LINUX_IF_ETHER_H */
diff --git a/include/linux/if_fc.h b/include/linux/if_fc.h
new file mode 100644
index 000000000000..33330b458b95
--- /dev/null
+++ b/include/linux/if_fc.h
@@ -0,0 +1,50 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for Fibre Channel.
+ *
+ * Version:     @(#)if_fc.h     0.0     11/20/98
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Donald Becker, <becker@super.org>
+ *    Peter De Schrijver, <stud11@cc4.kuleuven.ac.be>
+ *        Vineet Abraham, <vma@iol.unh.edu>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_FC_H
+#define _LINUX_IF_FC_H
+
+
+#define FC_ALEN 6               /* Octets in one ethernet addr   */
+#define FC_HLEN   (sizeof(struct fch_hdr)+sizeof(struct fcllc))
+#define FC_ID_LEN 3             /* Octets in a Fibre Channel Address */
+
+/* LLC and SNAP constants */
+#define EXTENDED_SAP 0xAA
+#define UI_CMD       0x03
+
+/* This is NOT the Fibre Channel frame header. The FC frame header is
+ *  constructed in the driver as the Tachyon needs certain fields in
+ *  certains positions. So, it can't be generalized here.*/
+
+struct fch_hdr {
+        __u8  daddr[FC_ALEN];           /* destination address */
+        __u8  saddr[FC_ALEN];           /* source address */
+};
+
+/* This is a Fibre Channel LLC structure */
+struct fcllc {
+        __u8  dsap;                     /* destination SAP */
+        __u8  ssap;                     /* source SAP */
+        __u8  llc;                      /* LLC control field */
+        __u8  protid[3];                /* protocol id */
+        __u16 ethertype;                /* ether type field */
+};
+
+#endif  /* _LINUX_IF_FC_H */
diff --git a/include/linux/if_fddi.h b/include/linux/if_fddi.h
new file mode 100644
index 000000000000..a912818e6361
--- /dev/null
+++ b/include/linux/if_fddi.h
@@ -0,0 +1,197 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the ANSI FDDI interface.
+ *
+ * Version:     @(#)if_fddi.h   1.0.2   Sep 29 2004
+ *
+ * Author:      Lawrence V. Stefani, <stefani@lkg.dec.com>
+ *
+ *              if_fddi.h is based on previous if_ether.h and if_tr.h work by
+ *                      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *                      Donald Becker, <becker@super.org>
+ *                      Alan Cox, <alan@redhat.com>
+ *                      Steve Whitehouse, <gw7rrm@eeshack3.swan.ac.uk>
+ *                      Peter De Schrijver, <stud11@cc4.kuleuven.ac.be>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_FDDI_H
+#define _LINUX_IF_FDDI_H
+
+/*
+ *  Define max and min legal sizes.  The frame sizes do not include
+ *  4 byte FCS/CRC (frame check sequence).
+ */
+#define FDDI_K_ALEN                     6               /* Octets in one FDDI address */
+#define FDDI_K_8022_HLEN        16              /* Total octets in 802.2 header */
+#define FDDI_K_SNAP_HLEN        21              /* Total octets in 802.2 SNAP header */
+#define FDDI_K_8022_ZLEN        16              /* Min octets in 802.2 frame sans FCS */
+#define FDDI_K_SNAP_ZLEN        21              /* Min octets in 802.2 SNAP frame sans FCS */
+#define FDDI_K_8022_DLEN        4475    /* Max octets in 802.2 payload */
+#define FDDI_K_SNAP_DLEN        4470    /* Max octets in 802.2 SNAP payload */
+#define FDDI_K_LLC_ZLEN         13              /* Min octets in LLC frame sans FCS */
+#define FDDI_K_LLC_LEN          4491    /* Max octets in LLC frame sans FCS */
+
+/* Define FDDI Frame Control (FC) Byte values */
+#define FDDI_FC_K_VOID                                  0x00    
+#define FDDI_FC_K_NON_RESTRICTED_TOKEN  0x80    
+#define FDDI_FC_K_RESTRICTED_TOKEN              0xC0    
+#define FDDI_FC_K_SMT_MIN                               0x41
+#define FDDI_FC_K_SMT_MAX                               0x4F
+#define FDDI_FC_K_MAC_MIN                               0xC1
+#define FDDI_FC_K_MAC_MAX                               0xCF    
+#define FDDI_FC_K_ASYNC_LLC_MIN                 0x50
+#define FDDI_FC_K_ASYNC_LLC_DEF                 0x54
+#define FDDI_FC_K_ASYNC_LLC_MAX                 0x5F
+#define FDDI_FC_K_SYNC_LLC_MIN                  0xD0
+#define FDDI_FC_K_SYNC_LLC_MAX                  0xD7
+#define FDDI_FC_K_IMPLEMENTOR_MIN               0x60
+#define FDDI_FC_K_IMPLEMENTOR_MAX               0x6F
+#define FDDI_FC_K_RESERVED_MIN                  0x70
+#define FDDI_FC_K_RESERVED_MAX                  0x7F
+
+/* Define LLC and SNAP constants */
+#define FDDI_EXTENDED_SAP       0xAA
+#define FDDI_UI_CMD                     0x03
+
+/* Define 802.2 Type 1 header */
+struct fddi_8022_1_hdr
+        {
+        __u8    dsap;                                   /* destination service access point */
+        __u8    ssap;                                   /* source service access point */
+        __u8    ctrl;                                   /* control byte #1 */
+        } __attribute__ ((packed));
+
+/* Define 802.2 Type 2 header */
+struct fddi_8022_2_hdr
+        {
+        __u8    dsap;                                   /* destination service access point */
+        __u8    ssap;                                   /* source service access point */
+        __u8    ctrl_1;                                 /* control byte #1 */
+        __u8    ctrl_2;                                 /* control byte #2 */
+        } __attribute__ ((packed));
+
+/* Define 802.2 SNAP header */
+#define FDDI_K_OUI_LEN  3
+struct fddi_snap_hdr
+        {
+        __u8    dsap;                                   /* always 0xAA */
+        __u8    ssap;                                   /* always 0xAA */
+        __u8    ctrl;                                   /* always 0x03 */
+        __u8    oui[FDDI_K_OUI_LEN];    /* organizational universal id */
+        __u16   ethertype;                              /* packet type ID field */
+        } __attribute__ ((packed));
+
+/* Define FDDI LLC frame header */
+struct fddihdr
+        {
+        __u8    fc;                                             /* frame control */
+        __u8    daddr[FDDI_K_ALEN];             /* destination address */
+        __u8    saddr[FDDI_K_ALEN];             /* source address */
+        union
+                {
+                struct fddi_8022_1_hdr          llc_8022_1;
+                struct fddi_8022_2_hdr          llc_8022_2;
+                struct fddi_snap_hdr            llc_snap;
+                } hdr;
+        } __attribute__ ((packed));
+
+/* Define FDDI statistics structure */
+struct fddi_statistics {
+
+        /* Generic statistics. */
+
+        struct net_device_stats gen;
+
+        /* Detailed FDDI statistics.  Adopted from RFC 1512 */
+
+        __u8    smt_station_id[8];
+        __u32   smt_op_version_id;
+        __u32   smt_hi_version_id;
+        __u32   smt_lo_version_id;
+        __u8    smt_user_data[32];
+        __u32   smt_mib_version_id;
+        __u32   smt_mac_cts;
+        __u32   smt_non_master_cts;
+        __u32   smt_master_cts;
+        __u32   smt_available_paths;
+        __u32   smt_config_capabilities;
+        __u32   smt_config_policy;
+        __u32   smt_connection_policy;
+        __u32   smt_t_notify;
+        __u32   smt_stat_rpt_policy;
+        __u32   smt_trace_max_expiration;
+        __u32   smt_bypass_present;
+        __u32   smt_ecm_state;
+        __u32   smt_cf_state;
+        __u32   smt_remote_disconnect_flag;
+        __u32   smt_station_status;
+        __u32   smt_peer_wrap_flag;
+        __u32   smt_time_stamp;
+        __u32   smt_transition_time_stamp;
+        __u32   mac_frame_status_functions;
+        __u32   mac_t_max_capability;
+        __u32   mac_tvx_capability;
+        __u32   mac_available_paths;
+        __u32   mac_current_path;
+        __u8    mac_upstream_nbr[FDDI_K_ALEN];
+        __u8    mac_downstream_nbr[FDDI_K_ALEN];
+        __u8    mac_old_upstream_nbr[FDDI_K_ALEN];
+        __u8    mac_old_downstream_nbr[FDDI_K_ALEN];
+        __u32   mac_dup_address_test;
+        __u32   mac_requested_paths;
+        __u32   mac_downstream_port_type;
+        __u8    mac_smt_address[FDDI_K_ALEN];
+        __u32   mac_t_req;
+        __u32   mac_t_neg;
+        __u32   mac_t_max;
+        __u32   mac_tvx_value;
+        __u32   mac_frame_cts;
+        __u32   mac_copied_cts;
+        __u32   mac_transmit_cts;
+        __u32   mac_error_cts;
+        __u32   mac_lost_cts;
+        __u32   mac_frame_error_threshold;
+        __u32   mac_frame_error_ratio;
+        __u32   mac_rmt_state;
+        __u32   mac_da_flag;
+        __u32   mac_una_da_flag;
+        __u32   mac_frame_error_flag;
+        __u32   mac_ma_unitdata_available;
+        __u32   mac_hardware_present;
+        __u32   mac_ma_unitdata_enable;
+        __u32   path_tvx_lower_bound;
+        __u32   path_t_max_lower_bound;
+        __u32   path_max_t_req;
+        __u32   path_configuration[8];
+        __u32   port_my_type[2];
+        __u32   port_neighbor_type[2];
+        __u32   port_connection_policies[2];
+        __u32   port_mac_indicated[2];
+        __u32   port_current_path[2];
+        __u8    port_requested_paths[3*2];
+        __u32   port_mac_placement[2];
+        __u32   port_available_paths[2];
+        __u32   port_pmd_class[2];
+        __u32   port_connection_capabilities[2];
+        __u32   port_bs_flag[2];
+        __u32   port_lct_fail_cts[2];
+        __u32   port_ler_estimate[2];
+        __u32   port_lem_reject_cts[2];
+        __u32   port_lem_cts[2];
+        __u32   port_ler_cutoff[2];
+        __u32   port_ler_alarm[2];
+        __u32   port_connect_state[2];
+        __u32   port_pcm_state[2];
+        __u32   port_pc_withhold[2];
+        __u32   port_ler_flag[2];
+        __u32   port_hardware_present[2];
+        };
+
+#endif  /* _LINUX_IF_FDDI_H */
diff --git a/include/linux/if_frad.h b/include/linux/if_frad.h
new file mode 100644
index 000000000000..3c94b1736570
--- /dev/null
+++ b/include/linux/if_frad.h
@@ -0,0 +1,200 @@
+/*
+ * DLCI/FRAD    Definitions for Frame Relay Access Devices.  DLCI devices are
+ *              created for each DLCI associated with a FRAD.  The FRAD driver
+ *              is not truly a network device, but the lower level device
+ *              handler.  This allows other FRAD manufacturers to use the DLCI
+ *              code, including its RFC1490 encapsulation alongside the current
+ *              implementation for the Sangoma cards.
+ *
+ * Version:     @(#)if_ifrad.h  0.15    31 Mar 96
+ *
+ * Author:      Mike McLagan <mike.mclagan@linux.org>
+ *
+ * Changes:
+ *              0.15    Mike McLagan    changed structure defs (packed)
+ *                                      re-arranged flags
+ *                                      added DLCI_RET vars
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _FRAD_H_
+#define _FRAD_H_
+
+#include <linux/config.h>
+#include <linux/if.h>
+
+#if defined(CONFIG_DLCI) || defined(CONFIG_DLCI_MODULE)
+
+/* Structures and constants associated with the DLCI device driver */
+
+struct dlci_add
+{
+   char  devname[IFNAMSIZ];
+   short dlci;
+};
+
+#define DLCI_GET_CONF   (SIOCDEVPRIVATE + 2)
+#define DLCI_SET_CONF   (SIOCDEVPRIVATE + 3)
+
+/* 
+ * These are related to the Sangoma SDLA and should remain in order. 
+ * Code within the SDLA module is based on the specifics of this 
+ * structure.  Change at your own peril.
+ */
+struct dlci_conf {
+   short flags;
+   short CIR_fwd;
+   short Bc_fwd;
+   short Be_fwd;
+   short CIR_bwd;
+   short Bc_bwd;
+   short Be_bwd; 
+
+/* these are part of the status read */
+   short Tc_fwd;
+   short Tc_bwd;
+   short Tf_max;
+   short Tb_max;
+
+/* add any new fields here above is a mirror of sdla_dlci_conf */
+};
+
+#define DLCI_GET_SLAVE  (SIOCDEVPRIVATE + 4)
+
+/* configuration flags for DLCI */
+#define DLCI_IGNORE_CIR_OUT     0x0001
+#define DLCI_ACCOUNT_CIR_IN     0x0002
+#define DLCI_BUFFER_IF          0x0008
+
+#define DLCI_VALID_FLAGS        0x000B
+
+/* FRAD driver uses these to indicate what it did with packet */
+#define DLCI_RET_OK             0x00
+#define DLCI_RET_ERR            0x01
+#define DLCI_RET_DROP           0x02
+
+/* defines for the actual Frame Relay hardware */
+#define FRAD_GET_CONF   (SIOCDEVPRIVATE)
+#define FRAD_SET_CONF   (SIOCDEVPRIVATE + 1)
+
+#define FRAD_LAST_IOCTL FRAD_SET_CONF
+
+/*
+ * Based on the setup for the Sangoma SDLA.  If changes are 
+ * necessary to this structure, a routine will need to be 
+ * added to that module to copy fields.
+ */
+struct frad_conf 
+{
+   short station;
+   short flags;
+   short kbaud;
+   short clocking;
+   short mtu;
+   short T391;
+   short T392;
+   short N391;
+   short N392;
+   short N393;
+   short CIR_fwd;
+   short Bc_fwd;
+   short Be_fwd;
+   short CIR_bwd;
+   short Bc_bwd;
+   short Be_bwd;
+
+/* Add new fields here, above is a mirror of the sdla_conf */
+
+};
+
+#define FRAD_STATION_CPE        0x0000
+#define FRAD_STATION_NODE       0x0001
+
+#define FRAD_TX_IGNORE_CIR      0x0001
+#define FRAD_RX_ACCOUNT_CIR     0x0002
+#define FRAD_DROP_ABORTED       0x0004
+#define FRAD_BUFFERIF           0x0008
+#define FRAD_STATS              0x0010
+#define FRAD_MCI                0x0100
+#define FRAD_AUTODLCI           0x8000
+#define FRAD_VALID_FLAGS        0x811F
+
+#define FRAD_CLOCK_INT          0x0001
+#define FRAD_CLOCK_EXT          0x0000
+
+#ifdef __KERNEL__
+
+/* these are the fields of an RFC 1490 header */
+struct frhdr
+{
+   unsigned char  control       __attribute__((packed));
+
+   /* for IP packets, this can be the NLPID */
+   unsigned char  pad           __attribute__((packed)); 
+
+   unsigned char  NLPID         __attribute__((packed));
+   unsigned char  OUI[3]        __attribute__((packed));
+   unsigned short PID           __attribute__((packed));
+
+#define IP_NLPID pad 
+};
+
+/* see RFC 1490 for the definition of the following */
+#define FRAD_I_UI               0x03
+
+#define FRAD_P_PADDING          0x00
+#define FRAD_P_Q933             0x08
+#define FRAD_P_SNAP             0x80
+#define FRAD_P_CLNP             0x81
+#define FRAD_P_IP               0xCC
+
+struct dlci_local
+{
+   struct net_device_stats stats;
+   struct net_device      *master;
+   struct net_device      *slave;
+   struct dlci_conf       config;
+   int                    configured;
+   struct list_head       list;
+
+   /* callback function */
+   void              (*receive)(struct sk_buff *skb, struct net_device *);
+};
+
+struct frad_local
+{
+   struct net_device_stats stats;
+
+   /* devices which this FRAD is slaved to */
+   struct net_device     *master[CONFIG_DLCI_MAX];
+   short             dlci[CONFIG_DLCI_MAX];
+
+   struct frad_conf  config;
+   int               configured;        /* has this device been configured */
+   int               initialized;       /* mem_start, port, irq set ? */
+
+   /* callback functions */
+   int               (*activate)(struct net_device *, struct net_device *);
+   int               (*deactivate)(struct net_device *, struct net_device *);
+   int               (*assoc)(struct net_device *, struct net_device *);
+   int               (*deassoc)(struct net_device *, struct net_device *);
+   int               (*dlci_conf)(struct net_device *, struct net_device *, int get);
+
+   /* fields that are used by the Sangoma SDLA cards */
+   struct timer_list timer;
+   int               type;              /* adapter type */
+   int               state;             /* state of the S502/8 control latch */
+   int               buffer;            /* current buffer for S508 firmware */
+};
+
+extern void dlci_ioctl_set(int (*hook)(unsigned int, void __user *));
+
+#endif /* __KERNEL__ */
+
+#endif /* CONFIG_DLCI || CONFIG_DLCI_MODULE */
+
+#endif
diff --git a/include/linux/if_hippi.h b/include/linux/if_hippi.h
new file mode 100644
index 000000000000..c8ca72c46f76
--- /dev/null
+++ b/include/linux/if_hippi.h
@@ -0,0 +1,157 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the HIPPI interface.
+ *
+ * Version:     @(#)if_hippi.h  1.0.0   05/26/97
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Donald Becker, <becker@super.org>
+ *              Alan Cox, <alan@redhat.com>
+ *              Steve Whitehouse, <gw7rrm@eeshack3.swan.ac.uk>
+ *              Jes Sorensen, <Jes.Sorensen@cern.ch>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+ 
+#ifndef _LINUX_IF_HIPPI_H
+#define _LINUX_IF_HIPPI_H
+
+#include <asm/byteorder.h>
+
+/*
+ *      HIPPI magic constants.
+ */
+
+#define HIPPI_ALEN      6               /* Bytes in one HIPPI hw-addr      */
+#define HIPPI_HLEN      sizeof(struct hippi_hdr)
+#define HIPPI_ZLEN      0               /* Min. bytes in frame without FCS */
+#define HIPPI_DATA_LEN  65280           /* Max. bytes in payload           */
+#define HIPPI_FRAME_LEN (HIPPI_DATA_LEN + HIPPI_HLEN)
+                                        /* Max. bytes in frame without FCS */
+
+/*
+ * Define LLC and SNAP constants.
+ */
+#define HIPPI_EXTENDED_SAP      0xAA
+#define HIPPI_UI_CMD            0x03
+
+
+/*
+ *      Do we need to list some sort of ID's here?
+ */
+
+/*
+ *      HIPPI statistics collection data. 
+ */
+ 
+struct hipnet_statistics
+{
+        int     rx_packets;             /* total packets received       */
+        int     tx_packets;             /* total packets transmitted    */
+        int     rx_errors;              /* bad packets received         */
+        int     tx_errors;              /* packet transmit problems     */
+        int     rx_dropped;             /* no space in linux buffers    */
+        int     tx_dropped;             /* no space available in linux  */
+
+        /* detailed rx_errors: */
+        int     rx_length_errors;
+        int     rx_over_errors;         /* receiver ring buff overflow  */
+        int     rx_crc_errors;          /* recved pkt with crc error    */
+        int     rx_frame_errors;        /* recv'd frame alignment error */
+        int     rx_fifo_errors;         /* recv'r fifo overrun          */
+        int     rx_missed_errors;       /* receiver missed packet       */
+
+        /* detailed tx_errors */
+        int     tx_aborted_errors;
+        int     tx_carrier_errors;
+        int     tx_fifo_errors;
+        int     tx_heartbeat_errors;
+        int     tx_window_errors;
+};
+
+
+struct hippi_fp_hdr
+{
+#if 0
+        __u8            ulp;                            /* must contain 4 */
+#if defined (__BIG_ENDIAN_BITFIELD)
+        __u8            d1_data_present:1;              /* must be 1 */
+        __u8            start_d2_burst_boundary:1;      /* must be zero */
+        __u8            reserved:6;                     /* must be zero */
+#if 0
+        __u16           reserved1:5;
+        __u16           d1_area_size:8;                 /* must be 3 */
+        __u16           d2_offset:3;                    /* must be zero */
+#endif
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8            reserved:6;                     /* must be zero */
+        __u8            start_d2_burst_boundary:1;      /* must be zero */
+        __u8            d1_data_present:1;              /* must be 1 */
+#if 0
+        __u16           d2_offset:3;                    /* must be zero */
+        __u16           d1_area_size:8;                 /* must be 3 */
+        __u16           reserved1:5;                    /* must be zero */
+#endif
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+#else
+        __u32           fixed;
+#endif
+        __u32           d2_size;
+} __attribute__ ((packed));
+
+struct hippi_le_hdr
+{
+#if defined (__BIG_ENDIAN_BITFIELD)
+        __u8            fc:3;
+        __u8            double_wide:1;
+        __u8            message_type:4;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8            message_type:4;
+        __u8            double_wide:1;
+        __u8            fc:3;
+#endif
+        __u8            dest_switch_addr[3];
+#if defined (__BIG_ENDIAN_BITFIELD)
+        __u8            dest_addr_type:4,
+                        src_addr_type:4;
+#elif defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8            src_addr_type:4,
+                        dest_addr_type:4;
+#endif
+        __u8            src_switch_addr[3];
+        __u16           reserved;
+        __u8            daddr[HIPPI_ALEN];
+        __u16           locally_administered;
+        __u8            saddr[HIPPI_ALEN];
+} __attribute__ ((packed));
+
+#define HIPPI_OUI_LEN   3
+/*
+ * Looks like the dsap and ssap fields have been swapped by mistake in
+ * RFC 2067 "IP over HIPPI".
+ */
+struct hippi_snap_hdr
+{
+        __u8    dsap;                   /* always 0xAA */
+        __u8    ssap;                   /* always 0xAA */
+        __u8    ctrl;                   /* always 0x03 */
+        __u8    oui[HIPPI_OUI_LEN];     /* organizational universal id (zero)*/
+        __u16   ethertype;              /* packet type ID field */
+} __attribute__ ((packed));
+
+struct hippi_hdr
+{
+        struct hippi_fp_hdr     fp;
+        struct hippi_le_hdr     le;
+        struct hippi_snap_hdr   snap;
+} __attribute__ ((packed));
+
+#endif  /* _LINUX_IF_HIPPI_H */
diff --git a/include/linux/if_infiniband.h b/include/linux/if_infiniband.h
new file mode 100644
index 000000000000..3e659ec7dfdd
--- /dev/null
+++ b/include/linux/if_infiniband.h
@@ -0,0 +1,29 @@
+/*
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available at
+ * <http://www.fsf.org/copyleft/gpl.html>, or the OpenIB.org BSD
+ * license, available in the LICENSE.TXT file accompanying this
+ * software.  These details are also available at
+ * <http://openib.org/license.html>.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Copyright (c) 2004 Topspin Communications.  All rights reserved.
+ *
+ * $Id$
+ */
+
+#ifndef _LINUX_IF_INFINIBAND_H
+#define _LINUX_IF_INFINIBAND_H
+
+#define INFINIBAND_ALEN         20      /* Octets in IPoIB HW addr      */
+
+#endif /* _LINUX_IF_INFINIBAND_H */
diff --git a/include/linux/if_ltalk.h b/include/linux/if_ltalk.h
new file mode 100644
index 000000000000..e75e832b7ff0
--- /dev/null
+++ b/include/linux/if_ltalk.h
@@ -0,0 +1,12 @@
+#ifndef __LINUX_LTALK_H
+#define __LINUX_LTALK_H
+
+#define LTALK_HLEN              1
+#define LTALK_MTU               600
+#define LTALK_ALEN              1
+
+#ifdef __KERNEL__
+extern void ltalk_setup(struct net_device *);
+#endif
+
+#endif
diff --git a/include/linux/if_packet.h b/include/linux/if_packet.h
new file mode 100644
index 000000000000..b92558549d27
--- /dev/null
+++ b/include/linux/if_packet.h
@@ -0,0 +1,102 @@
+#ifndef __LINUX_IF_PACKET_H
+#define __LINUX_IF_PACKET_H
+
+struct sockaddr_pkt
+{
+        unsigned short spkt_family;
+        unsigned char spkt_device[14];
+        unsigned short spkt_protocol;
+};
+
+struct sockaddr_ll
+{
+        unsigned short  sll_family;
+        unsigned short  sll_protocol;
+        int             sll_ifindex;
+        unsigned short  sll_hatype;
+        unsigned char   sll_pkttype;
+        unsigned char   sll_halen;
+        unsigned char   sll_addr[8];
+};
+
+/* Packet types */
+
+#define PACKET_HOST             0               /* To us                */
+#define PACKET_BROADCAST        1               /* To all               */
+#define PACKET_MULTICAST        2               /* To group             */
+#define PACKET_OTHERHOST        3               /* To someone else      */
+#define PACKET_OUTGOING         4               /* Outgoing of any type */
+/* These ones are invisible by user level */
+#define PACKET_LOOPBACK         5               /* MC/BRD frame looped back */
+#define PACKET_FASTROUTE        6               /* Fastrouted frame     */
+
+/* Packet socket options */
+
+#define PACKET_ADD_MEMBERSHIP           1
+#define PACKET_DROP_MEMBERSHIP          2
+#define PACKET_RECV_OUTPUT              3
+/* Value 4 is still used by obsolete turbo-packet. */
+#define PACKET_RX_RING                  5
+#define PACKET_STATISTICS               6
+#define PACKET_COPY_THRESH              7
+
+struct tpacket_stats
+{
+        unsigned int    tp_packets;
+        unsigned int    tp_drops;
+};
+
+struct tpacket_hdr
+{
+        unsigned long   tp_status;
+#define TP_STATUS_KERNEL        0
+#define TP_STATUS_USER          1
+#define TP_STATUS_COPY          2
+#define TP_STATUS_LOSING        4
+#define TP_STATUS_CSUMNOTREADY  8
+        unsigned int    tp_len;
+        unsigned int    tp_snaplen;
+        unsigned short  tp_mac;
+        unsigned short  tp_net;
+        unsigned int    tp_sec;
+        unsigned int    tp_usec;
+};
+
+#define TPACKET_ALIGNMENT       16
+#define TPACKET_ALIGN(x)        (((x)+TPACKET_ALIGNMENT-1)&~(TPACKET_ALIGNMENT-1))
+#define TPACKET_HDRLEN          (TPACKET_ALIGN(sizeof(struct tpacket_hdr)) + sizeof(struct sockaddr_ll))
+
+/*
+   Frame structure:
+
+   - Start. Frame must be aligned to TPACKET_ALIGNMENT=16
+   - struct tpacket_hdr
+   - pad to TPACKET_ALIGNMENT=16
+   - struct sockaddr_ll
+   - Gap, chosen so that packet data (Start+tp_net) alignes to TPACKET_ALIGNMENT=16
+   - Start+tp_mac: [ Optional MAC header ]
+   - Start+tp_net: Packet data, aligned to TPACKET_ALIGNMENT=16.
+   - Pad to align to TPACKET_ALIGNMENT=16
+ */
+
+struct tpacket_req
+{
+        unsigned int    tp_block_size;  /* Minimal size of contiguous block */
+        unsigned int    tp_block_nr;    /* Number of blocks */
+        unsigned int    tp_frame_size;  /* Size of frame */
+        unsigned int    tp_frame_nr;    /* Total number of frames */
+};
+
+struct packet_mreq
+{
+        int             mr_ifindex;
+        unsigned short  mr_type;
+        unsigned short  mr_alen;
+        unsigned char   mr_address[8];
+};
+
+#define PACKET_MR_MULTICAST     0
+#define PACKET_MR_PROMISC       1
+#define PACKET_MR_ALLMULTI      2
+
+#endif
diff --git a/include/linux/if_plip.h b/include/linux/if_plip.h
new file mode 100644
index 000000000000..153a649915a2
--- /dev/null
+++ b/include/linux/if_plip.h
@@ -0,0 +1,28 @@
+/*
+ *      NET3    PLIP tuning facilities for the new Niibe PLIP.
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ */
+ 
+#ifndef _LINUX_IF_PLIP_H
+#define _LINUX_IF_PLIP_H
+
+#include <linux/sockios.h>
+
+#define SIOCDEVPLIP     SIOCDEVPRIVATE
+
+struct plipconf
+{
+        unsigned short pcmd;
+        unsigned long  nibble;
+        unsigned long  trigger;
+};
+
+#define PLIP_GET_TIMEOUT        0x1
+#define PLIP_SET_TIMEOUT        0x2
+
+#endif
diff --git a/include/linux/if_ppp.h b/include/linux/if_ppp.h
new file mode 100644
index 000000000000..572aff7daa21
--- /dev/null
+++ b/include/linux/if_ppp.h
@@ -0,0 +1,155 @@
+/*      $Id: if_ppp.h,v 1.21 2000/03/27 06:03:36 paulus Exp $   */
+
+/*
+ * if_ppp.h - Point-to-Point Protocol definitions.
+ *
+ * Copyright (c) 1989 Carnegie Mellon University.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Carnegie Mellon University.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+/*
+ *  ==FILEVERSION 20000724==
+ *
+ *  NOTE TO MAINTAINERS:
+ *     If you modify this file at all, please set the above date.
+ *     if_ppp.h is shipped with a PPP distribution as well as with the kernel;
+ *     if everyone increases the FILEVERSION number above, then scripts
+ *     can do the right thing when deciding whether to install a new if_ppp.h
+ *     file.  Don't change the format of that line otherwise, so the
+ *     installation script can recognize it.
+ */
+
+#ifndef _IF_PPP_H_
+#define _IF_PPP_H_
+
+/*
+ * Packet sizes
+ */
+
+#define PPP_MTU         1500    /* Default MTU (size of Info field) */
+#define PPP_MAXMRU      65000   /* Largest MRU we allow */
+#define PROTO_IPX       0x002b  /* protocol numbers */
+#define PROTO_DNA_RT    0x0027  /* DNA Routing */
+
+
+/*
+ * Bit definitions for flags.
+ */
+
+#define SC_COMP_PROT    0x00000001      /* protocol compression (output) */
+#define SC_COMP_AC      0x00000002      /* header compression (output) */
+#define SC_COMP_TCP     0x00000004      /* TCP (VJ) compression (output) */
+#define SC_NO_TCP_CCID  0x00000008      /* disable VJ connection-id comp. */
+#define SC_REJ_COMP_AC  0x00000010      /* reject adrs/ctrl comp. on input */
+#define SC_REJ_COMP_TCP 0x00000020      /* reject TCP (VJ) comp. on input */
+#define SC_CCP_OPEN     0x00000040      /* Look at CCP packets */
+#define SC_CCP_UP       0x00000080      /* May send/recv compressed packets */
+#define SC_ENABLE_IP    0x00000100      /* IP packets may be exchanged */
+#define SC_LOOP_TRAFFIC 0x00000200      /* send traffic to pppd */
+#define SC_MULTILINK    0x00000400      /* do multilink encapsulation */
+#define SC_MP_SHORTSEQ  0x00000800      /* use short MP sequence numbers */
+#define SC_COMP_RUN     0x00001000      /* compressor has been inited */
+#define SC_DECOMP_RUN   0x00002000      /* decompressor has been inited */
+#define SC_MP_XSHORTSEQ 0x00004000      /* transmit short MP seq numbers */
+#define SC_DEBUG        0x00010000      /* enable debug messages */
+#define SC_LOG_INPKT    0x00020000      /* log contents of good pkts recvd */
+#define SC_LOG_OUTPKT   0x00040000      /* log contents of pkts sent */
+#define SC_LOG_RAWIN    0x00080000      /* log all chars received */
+#define SC_LOG_FLUSH    0x00100000      /* log all chars flushed */
+#define SC_SYNC         0x00200000      /* synchronous serial mode */
+#define SC_MASK         0x0f200fff      /* bits that user can change */
+
+/* state bits */
+#define SC_XMIT_BUSY    0x10000000      /* (used by isdn_ppp?) */
+#define SC_RCV_ODDP     0x08000000      /* have rcvd char with odd parity */
+#define SC_RCV_EVNP     0x04000000      /* have rcvd char with even parity */
+#define SC_RCV_B7_1     0x02000000      /* have rcvd char with bit 7 = 1 */
+#define SC_RCV_B7_0     0x01000000      /* have rcvd char with bit 7 = 0 */
+#define SC_DC_FERROR    0x00800000      /* fatal decomp error detected */
+#define SC_DC_ERROR     0x00400000      /* non-fatal decomp error detected */
+
+/*
+ * Ioctl definitions.
+ */
+
+struct npioctl {
+        int             protocol;       /* PPP protocol, e.g. PPP_IP */
+        enum NPmode     mode;
+};
+
+/* Structure describing a CCP configuration option, for PPPIOCSCOMPRESS */
+struct ppp_option_data {
+        __u8    __user *ptr;
+        __u32   length;
+        int     transmit;
+};
+
+struct ifpppstatsreq {
+        struct ifreq     b;
+        struct ppp_stats stats;                 /* statistic information */
+};
+
+struct ifpppcstatsreq {
+        struct ifreq          b;
+        struct ppp_comp_stats stats;
+};
+
+#define ifr__name       b.ifr_ifrn.ifrn_name
+#define stats_ptr       b.ifr_ifru.ifru_data
+
+/*
+ * Ioctl definitions.
+ */
+
+#define PPPIOCGFLAGS    _IOR('t', 90, int)      /* get configuration flags */
+#define PPPIOCSFLAGS    _IOW('t', 89, int)      /* set configuration flags */
+#define PPPIOCGASYNCMAP _IOR('t', 88, int)      /* get async map */
+#define PPPIOCSASYNCMAP _IOW('t', 87, int)      /* set async map */
+#define PPPIOCGUNIT     _IOR('t', 86, int)      /* get ppp unit number */
+#define PPPIOCGRASYNCMAP _IOR('t', 85, int)     /* get receive async map */
+#define PPPIOCSRASYNCMAP _IOW('t', 84, int)     /* set receive async map */
+#define PPPIOCGMRU      _IOR('t', 83, int)      /* get max receive unit */
+#define PPPIOCSMRU      _IOW('t', 82, int)      /* set max receive unit */
+#define PPPIOCSMAXCID   _IOW('t', 81, int)      /* set VJ max slot ID */
+#define PPPIOCGXASYNCMAP _IOR('t', 80, ext_accm) /* get extended ACCM */
+#define PPPIOCSXASYNCMAP _IOW('t', 79, ext_accm) /* set extended ACCM */
+#define PPPIOCXFERUNIT  _IO('t', 78)            /* transfer PPP unit */
+#define PPPIOCSCOMPRESS _IOW('t', 77, struct ppp_option_data)
+#define PPPIOCGNPMODE   _IOWR('t', 76, struct npioctl) /* get NP mode */
+#define PPPIOCSNPMODE   _IOW('t', 75, struct npioctl)  /* set NP mode */
+#define PPPIOCSPASS     _IOW('t', 71, struct sock_fprog) /* set pass filter */
+#define PPPIOCSACTIVE   _IOW('t', 70, struct sock_fprog) /* set active filt */
+#define PPPIOCGDEBUG    _IOR('t', 65, int)      /* Read debug level */
+#define PPPIOCSDEBUG    _IOW('t', 64, int)      /* Set debug level */
+#define PPPIOCGIDLE     _IOR('t', 63, struct ppp_idle) /* get idle time */
+#define PPPIOCNEWUNIT   _IOWR('t', 62, int)     /* create new ppp unit */
+#define PPPIOCATTACH    _IOW('t', 61, int)      /* attach to ppp unit */
+#define PPPIOCDETACH    _IOW('t', 60, int)      /* detach from ppp unit/chan */
+#define PPPIOCSMRRU     _IOW('t', 59, int)      /* set multilink MRU */
+#define PPPIOCCONNECT   _IOW('t', 58, int)      /* connect channel to unit */
+#define PPPIOCDISCONN   _IO('t', 57)            /* disconnect channel */
+#define PPPIOCATTCHAN   _IOW('t', 56, int)      /* attach to ppp channel */
+#define PPPIOCGCHAN     _IOR('t', 55, int)      /* get ppp channel number */
+
+#define SIOCGPPPSTATS   (SIOCDEVPRIVATE + 0)
+#define SIOCGPPPVER     (SIOCDEVPRIVATE + 1)    /* NEVER change this!! */
+#define SIOCGPPPCSTATS  (SIOCDEVPRIVATE + 2)
+
+#if !defined(ifr_mtu)
+#define ifr_mtu ifr_ifru.ifru_metric
+#endif
+
+#endif /* _IF_PPP_H_ */
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
new file mode 100644
index 000000000000..e677f73f13dd
--- /dev/null
+++ b/include/linux/if_pppox.h
@@ -0,0 +1,175 @@
+/***************************************************************************
+ * Linux PPP over X - Generic PPP transport layer sockets
+ * Linux PPP over Ethernet (PPPoE) Socket Implementation (RFC 2516) 
+ *
+ * This file supplies definitions required by the PPP over Ethernet driver
+ * (pppox.c).  All version information wrt this file is located in pppox.c
+ *
+ * License:
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __LINUX_IF_PPPOX_H
+#define __LINUX_IF_PPPOX_H
+
+
+#include <asm/types.h>
+#include <asm/byteorder.h>
+
+#ifdef  __KERNEL__
+#include <linux/if_ether.h>
+#include <linux/if.h>
+#include <linux/netdevice.h>
+#include <asm/semaphore.h>
+#include <linux/ppp_channel.h>
+#endif /* __KERNEL__ */
+
+/* For user-space programs to pick up these definitions
+ * which they wouldn't get otherwise without defining __KERNEL__
+ */
+#ifndef AF_PPPOX
+#define AF_PPPOX        24
+#define PF_PPPOX        AF_PPPOX
+#endif /* !(AF_PPPOX) */
+
+/************************************************************************ 
+ * PPPoE addressing definition 
+ */ 
+typedef __u16 sid_t; 
+struct pppoe_addr{ 
+       sid_t           sid;                    /* Session identifier */ 
+       unsigned char   remote[ETH_ALEN];       /* Remote address */ 
+       char            dev[IFNAMSIZ];          /* Local device to use */ 
+}; 
+ 
+/************************************************************************ 
+ * Protocols supported by AF_PPPOX 
+ */ 
+#define PX_PROTO_OE    0 /* Currently just PPPoE */
+#define PX_MAX_PROTO   1        
+ 
+struct sockaddr_pppox { 
+       sa_family_t     sa_family;            /* address family, AF_PPPOX */ 
+       unsigned int    sa_protocol;          /* protocol identifier */ 
+       union{ 
+               struct pppoe_addr       pppoe; 
+       }sa_addr; 
+}__attribute__ ((packed)); 
+
+
+/*********************************************************************
+ *
+ * ioctl interface for defining forwarding of connections
+ *
+ ********************************************************************/
+
+#define PPPOEIOCSFWD    _IOW(0xB1 ,0, size_t)
+#define PPPOEIOCDFWD    _IO(0xB1 ,1)
+/*#define PPPOEIOCGFWD  _IOWR(0xB1,2, size_t)*/
+
+/* Codes to identify message types */
+#define PADI_CODE       0x09
+#define PADO_CODE       0x07
+#define PADR_CODE       0x19
+#define PADS_CODE       0x65
+#define PADT_CODE       0xa7
+struct pppoe_tag {
+        __u16 tag_type;
+        __u16 tag_len;
+        char tag_data[0];
+} __attribute ((packed));
+
+/* Tag identifiers */
+#define PTT_EOL         __constant_htons(0x0000)
+#define PTT_SRV_NAME    __constant_htons(0x0101)
+#define PTT_AC_NAME     __constant_htons(0x0102)
+#define PTT_HOST_UNIQ   __constant_htons(0x0103)
+#define PTT_AC_COOKIE   __constant_htons(0x0104)
+#define PTT_VENDOR      __constant_htons(0x0105)
+#define PTT_RELAY_SID   __constant_htons(0x0110)
+#define PTT_SRV_ERR     __constant_htons(0x0201)
+#define PTT_SYS_ERR     __constant_htons(0x0202)
+#define PTT_GEN_ERR     __constant_htons(0x0203)
+
+struct pppoe_hdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 ver : 4;
+        __u8 type : 4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+        __u8 type : 4;
+        __u8 ver : 4;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+        __u8 code;
+        __u16 sid;
+        __u16 length;
+        struct pppoe_tag tag[0];
+} __attribute__ ((packed));
+
+#ifdef __KERNEL__
+struct pppoe_opt {
+        struct net_device      *dev;      /* device associated with socket*/
+        struct pppoe_addr       pa;       /* what this socket is bound to*/
+        struct sockaddr_pppox   relay;    /* what socket data will be
+                                             relayed to (PPPoE relaying) */
+};
+
+#include <net/sock.h>
+
+struct pppox_sock {
+        /* struct sock must be the first member of pppox_sock */
+        struct sock             sk;
+        struct ppp_channel      chan;
+        struct pppox_sock       *next;    /* for hash table */
+        union {
+                struct pppoe_opt pppoe;
+        } proto;
+        unsigned short          num;
+};
+#define pppoe_dev       proto.pppoe.dev
+#define pppoe_pa        proto.pppoe.pa
+#define pppoe_relay     proto.pppoe.relay
+
+static inline struct pppox_sock *pppox_sk(struct sock *sk)
+{
+        return (struct pppox_sock *)sk;
+}
+
+static inline struct sock *sk_pppox(struct pppox_sock *po)
+{
+        return (struct sock *)po;
+}
+
+struct module;
+
+struct pppox_proto {
+        int             (*create)(struct socket *sock);
+        int             (*ioctl)(struct socket *sock, unsigned int cmd,
+                                 unsigned long arg);
+        struct module   *owner;
+};
+
+extern int register_pppox_proto(int proto_num, struct pppox_proto *pp);
+extern void unregister_pppox_proto(int proto_num);
+extern void pppox_unbind_sock(struct sock *sk);/* delete ppp-channel binding */
+extern int pppox_channel_ioctl(struct ppp_channel *pc, unsigned int cmd,
+                               unsigned long arg);
+
+/* PPPoX socket states */
+enum {
+    PPPOX_NONE          = 0,  /* initial state */
+    PPPOX_CONNECTED     = 1,  /* connection established ==TCP_ESTABLISHED */
+    PPPOX_BOUND         = 2,  /* bound to ppp device */
+    PPPOX_RELAY         = 4,  /* forwarding is enabled */
+    PPPOX_ZOMBIE        = 8,  /* dead, but still bound to ppp device */
+    PPPOX_DEAD          = 16  /* dead, useless, please clean me up!*/
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* !(__LINUX_IF_PPPOX_H) */
diff --git a/include/linux/if_shaper.h b/include/linux/if_shaper.h
new file mode 100644
index 000000000000..0485b256d043
--- /dev/null
+++ b/include/linux/if_shaper.h
@@ -0,0 +1,64 @@
+#ifndef __LINUX_SHAPER_H
+#define __LINUX_SHAPER_H
+
+#ifdef __KERNEL__
+
+#define SHAPER_QLEN     10
+/*
+ *      This is a bit speed dependent (read it shouldn't be a constant!)
+ *
+ *      5 is about right for 28.8 upwards. Below that double for every
+ *      halving of speed or so. - ie about 20 for 9600 baud.
+ */
+#define SHAPER_LATENCY  (5*HZ)
+#define SHAPER_MAXSLIP  2
+#define SHAPER_BURST    (HZ/50)         /* Good for >128K then */
+
+struct shaper
+{
+        struct sk_buff_head sendq;
+        __u32 bytespertick;
+        __u32 bitspersec;
+        __u32 shapelatency;
+        __u32 shapeclock;
+        unsigned long recovery; /* Time we can next clock a packet out on
+                                   an empty queue */
+        unsigned long locked;
+        struct net_device_stats stats;
+        struct net_device *dev;
+        int  (*hard_start_xmit) (struct sk_buff *skb,
+                struct net_device *dev);
+        int  (*hard_header) (struct sk_buff *skb,
+                struct net_device *dev,
+                unsigned short type,
+                void *daddr,
+                void *saddr,
+                unsigned len);
+        int  (*rebuild_header)(struct sk_buff *skb);
+        int (*hard_header_cache)(struct neighbour *neigh, struct hh_cache *hh);
+        void (*header_cache_update)(struct hh_cache *hh, struct net_device *dev, unsigned char *  haddr);
+        struct net_device_stats* (*get_stats)(struct net_device *dev);
+        wait_queue_head_t  wait_queue;
+        struct timer_list timer;
+};
+
+#endif
+
+#define SHAPER_SET_DEV          0x0001
+#define SHAPER_SET_SPEED        0x0002
+#define SHAPER_GET_DEV          0x0003
+#define SHAPER_GET_SPEED        0x0004
+
+struct shaperconf
+{
+        __u16   ss_cmd;
+        union
+        {
+                char    ssu_name[14];
+                __u32   ssu_speed;
+        } ss_u;
+#define ss_speed ss_u.ssu_speed
+#define ss_name ss_u.ssu_name
+};
+
+#endif
diff --git a/include/linux/if_slip.h b/include/linux/if_slip.h
new file mode 100644
index 000000000000..1eb4e3a8397a
--- /dev/null
+++ b/include/linux/if_slip.h
@@ -0,0 +1,30 @@
+/*
+ *      Swansea University Computer Society     NET3
+ *      
+ *      This file declares the constants of special use with the SLIP/CSLIP/
+ *      KISS TNC driver.
+ */
+ 
+#ifndef __LINUX_SLIP_H
+#define __LINUX_SLIP_H
+
+#define         SL_MODE_SLIP            0
+#define         SL_MODE_CSLIP           1
+#define         SL_MODE_KISS            4
+
+#define         SL_OPT_SIXBIT           2
+#define         SL_OPT_ADAPTIVE         8
+
+/*
+ *      VSV = ioctl for keepalive & outfill in SLIP driver 
+ */
+ 
+#define SIOCSKEEPALIVE  (SIOCDEVPRIVATE)                /* Set keepalive timeout in sec */
+#define SIOCGKEEPALIVE  (SIOCDEVPRIVATE+1)              /* Get keepalive timeout */
+#define SIOCSOUTFILL    (SIOCDEVPRIVATE+2)              /* Set outfill timeout */
+#define SIOCGOUTFILL    (SIOCDEVPRIVATE+3)              /* Get outfill timeout */
+#define SIOCSLEASE      (SIOCDEVPRIVATE+4)              /* Set "leased" line type */
+#define SIOCGLEASE      (SIOCDEVPRIVATE+5)              /* Get line type */
+
+
+#endif
diff --git a/include/linux/if_strip.h b/include/linux/if_strip.h
new file mode 100644
index 000000000000..fb5c5c98442f
--- /dev/null
+++ b/include/linux/if_strip.h
@@ -0,0 +1,25 @@
+/*
+ * if_strip.h --
+ *
+ *      Definitions for the STRIP interface
+ *
+ * Copyright 1996 The Board of Trustees of The Leland Stanford
+ * Junior University. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies.  Stanford University
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ */
+
+#ifndef __LINUX_STRIP_H
+#define __LINUX_STRIP_H
+
+typedef struct {
+    __u8 c[6];
+} MetricomAddress;
+
+#endif
diff --git a/include/linux/if_tr.h b/include/linux/if_tr.h
new file mode 100644
index 000000000000..4fd451f81ccb
--- /dev/null
+++ b/include/linux/if_tr.h
@@ -0,0 +1,109 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the Token-Ring IEEE 802.5 interface.
+ *
+ * Version:     @(#)if_tr.h     0.0     07/11/94
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Donald Becker, <becker@super.org>
+ *    Peter De Schrijver, <stud11@cc4.kuleuven.ac.be>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IF_TR_H
+#define _LINUX_IF_TR_H
+
+
+/* IEEE 802.5 Token-Ring magic constants.  The frame sizes omit the preamble
+   and FCS/CRC (frame check sequence). */
+#define TR_ALEN 6               /* Octets in one ethernet addr   */
+#define TR_HLEN   (sizeof(struct trh_hdr)+sizeof(struct trllc))
+#define AC                      0x10
+#define LLC_FRAME 0x40
+#if 0
+#define ETH_HLEN        14              /* Total octets in header.       */
+#define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
+#define ETH_DATA_LEN    1500            /* Max. octets in payload        */
+#define ETH_FRAME_LEN   1514            /* Max. octets in frame sans FCS */
+#endif
+
+
+/* LLC and SNAP constants */
+#define EXTENDED_SAP 0xAA
+#define UI_CMD       0x03
+
+/* This is an Token-Ring frame header. */
+struct trh_hdr {
+        __u8  ac;                       /* access control field */
+        __u8  fc;                       /* frame control field */
+        __u8  daddr[TR_ALEN];           /* destination address */
+        __u8  saddr[TR_ALEN];           /* source address */
+        __u16 rcf;                      /* route control field */
+        __u16 rseg[8];                  /* routing registers */
+};
+
+#ifdef __KERNEL__
+#include <linux/skbuff.h>
+
+static inline struct trh_hdr *tr_hdr(const struct sk_buff *skb)
+{
+        return (struct trh_hdr *)skb->mac.raw;
+}
+#endif
+
+/* This is an Token-Ring LLC structure */
+struct trllc {
+        __u8  dsap;                     /* destination SAP */
+        __u8  ssap;                     /* source SAP */
+        __u8  llc;                      /* LLC control field */
+        __u8  protid[3];                /* protocol id */
+        __u16 ethertype;                /* ether type field */
+};
+
+/* Token-Ring statistics collection data. */
+struct tr_statistics {
+        unsigned long rx_packets;       /* total packets received       */
+        unsigned long tx_packets;       /* total packets transmitted    */
+        unsigned long rx_bytes;         /* total bytes received         */
+        unsigned long tx_bytes;         /* total bytes transmitted      */
+        unsigned long rx_errors;        /* bad packets received         */
+        unsigned long tx_errors;        /* packet transmit problems     */
+        unsigned long rx_dropped;       /* no space in linux buffers    */
+        unsigned long tx_dropped;       /* no space available in linux  */
+        unsigned long multicast;        /* multicast packets received   */
+        unsigned long transmit_collision;
+
+        /* detailed Token-Ring errors. See IBM Token-Ring Network
+           Architecture for more info */
+
+        unsigned long line_errors;
+        unsigned long internal_errors;
+        unsigned long burst_errors;
+        unsigned long A_C_errors;
+        unsigned long abort_delimiters;
+        unsigned long lost_frames;
+        unsigned long recv_congest_count;
+        unsigned long frame_copied_errors;
+        unsigned long frequency_errors;
+        unsigned long token_errors;
+        unsigned long dummy1;
+};
+
+/* source routing stuff */
+
+#define TR_RII 0x80
+#define TR_RCF_DIR_BIT 0x80
+#define TR_RCF_LEN_MASK 0x1f00
+#define TR_RCF_BROADCAST 0x8000         /* all-routes broadcast */
+#define TR_RCF_LIMITED_BROADCAST 0xC000 /* single-route broadcast */
+#define TR_RCF_FRAME2K 0x20
+#define TR_RCF_BROADCAST_MASK 0xC000
+#define TR_MAXRIFLEN 18
+
+#endif  /* _LINUX_IF_TR_H */
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
new file mode 100644
index 000000000000..096a85a58ae5
--- /dev/null
+++ b/include/linux/if_tun.h
@@ -0,0 +1,93 @@
+/*
+ *  Universal TUN/TAP device driver.
+ *  Copyright (C) 1999-2000 Maxim Krasnyansky <max_mk@yahoo.com>
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  $Id: if_tun.h,v 1.2 2001/06/01 18:39:47 davem Exp $
+ */
+
+#ifndef __IF_TUN_H
+#define __IF_TUN_H
+
+/* Uncomment to enable debugging */
+/* #define TUN_DEBUG 1 */
+
+#ifdef __KERNEL__
+
+#ifdef TUN_DEBUG
+#define DBG  if(tun->debug)printk
+#define DBG1 if(debug==2)printk
+#else
+#define DBG( a... )
+#define DBG1( a... )
+#endif
+
+struct tun_struct {
+        struct list_head        list;
+        unsigned long           flags;
+        int                     attached;
+        uid_t                   owner;
+
+        wait_queue_head_t       read_wait;
+        struct sk_buff_head     readq;
+
+        struct net_device       *dev;
+        struct net_device_stats stats;
+
+        struct fasync_struct    *fasync;
+
+        unsigned long if_flags;
+        u8 dev_addr[ETH_ALEN];
+        u32 chr_filter[2];
+        u32 net_filter[2];
+
+#ifdef TUN_DEBUG        
+        int debug;
+#endif  
+};
+
+#endif /* __KERNEL__ */
+
+/* Read queue size */
+#define TUN_READQ_SIZE  500
+
+/* TUN device flags */
+#define TUN_TUN_DEV     0x0001  
+#define TUN_TAP_DEV     0x0002
+#define TUN_TYPE_MASK   0x000f
+
+#define TUN_FASYNC      0x0010
+#define TUN_NOCHECKSUM  0x0020
+#define TUN_NO_PI       0x0040
+#define TUN_ONE_QUEUE   0x0080
+#define TUN_PERSIST     0x0100  
+
+/* Ioctl defines */
+#define TUNSETNOCSUM  _IOW('T', 200, int) 
+#define TUNSETDEBUG   _IOW('T', 201, int) 
+#define TUNSETIFF     _IOW('T', 202, int) 
+#define TUNSETPERSIST _IOW('T', 203, int) 
+#define TUNSETOWNER   _IOW('T', 204, int)
+
+/* TUNSETIFF ifr flags */
+#define IFF_TUN         0x0001
+#define IFF_TAP         0x0002
+#define IFF_NO_PI       0x1000
+#define IFF_ONE_QUEUE   0x2000
+
+struct tun_pi {
+        unsigned short flags;
+        unsigned short proto;
+};
+#define TUN_PKT_STRIP   0x0001
+
+#endif /* __IF_TUN_H */
diff --git a/include/linux/if_tunnel.h b/include/linux/if_tunnel.h
new file mode 100644
index 000000000000..bef9f8fd93b3
--- /dev/null
+++ b/include/linux/if_tunnel.h
@@ -0,0 +1,29 @@
+#ifndef _IF_TUNNEL_H_
+#define _IF_TUNNEL_H_
+
+#define SIOCGETTUNNEL   (SIOCDEVPRIVATE + 0)
+#define SIOCADDTUNNEL   (SIOCDEVPRIVATE + 1)
+#define SIOCDELTUNNEL   (SIOCDEVPRIVATE + 2)
+#define SIOCCHGTUNNEL   (SIOCDEVPRIVATE + 3)
+
+#define GRE_CSUM        __constant_htons(0x8000)
+#define GRE_ROUTING     __constant_htons(0x4000)
+#define GRE_KEY         __constant_htons(0x2000)
+#define GRE_SEQ         __constant_htons(0x1000)
+#define GRE_STRICT      __constant_htons(0x0800)
+#define GRE_REC         __constant_htons(0x0700)
+#define GRE_FLAGS       __constant_htons(0x00F8)
+#define GRE_VERSION     __constant_htons(0x0007)
+
+struct ip_tunnel_parm
+{
+        char                    name[IFNAMSIZ];
+        int                     link;
+        __u16                   i_flags;
+        __u16                   o_flags;
+        __u32                   i_key;
+        __u32                   o_key;
+        struct iphdr            iph;
+};
+
+#endif /* _IF_TUNNEL_H_ */
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
new file mode 100644
index 000000000000..62a9d89dfbe2
--- /dev/null
+++ b/include/linux/if_vlan.h
@@ -0,0 +1,398 @@
+/*
+ * VLAN         An implementation of 802.1Q VLAN tagging.
+ *
+ * Authors:     Ben Greear <greearb@candelatech.com>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ */
+
+#ifndef _LINUX_IF_VLAN_H_
+#define _LINUX_IF_VLAN_H_
+
+#ifdef __KERNEL__
+
+/* externally defined structs */
+struct vlan_group;
+struct net_device;
+struct packet_type;
+struct vlan_collection;
+struct vlan_dev_info;
+struct hlist_node;
+
+#include <linux/proc_fs.h> /* for proc_dir_entry */
+#include <linux/netdevice.h>
+
+#define VLAN_HLEN       4               /* The additional bytes (on top of the Ethernet header)
+                                         * that VLAN requires.
+                                         */
+#define VLAN_ETH_ALEN   6               /* Octets in one ethernet addr   */
+#define VLAN_ETH_HLEN   18              /* Total octets in header.       */
+#define VLAN_ETH_ZLEN   64              /* Min. octets in frame sans FCS */
+
+/*
+ * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan
+ */
+#define VLAN_ETH_DATA_LEN       1500    /* Max. octets in payload        */
+#define VLAN_ETH_FRAME_LEN      1518    /* Max. octets in frame sans FCS */
+
+struct vlan_ethhdr {
+   unsigned char        h_dest[ETH_ALEN];          /* destination eth addr      */
+   unsigned char        h_source[ETH_ALEN];        /* source ether addr */
+   unsigned short       h_vlan_proto;              /* Should always be 0x8100 */
+   unsigned short       h_vlan_TCI;                /* Encapsulates priority and VLAN ID */
+   unsigned short       h_vlan_encapsulated_proto; /* packet type ID field (or len) */
+};
+
+#include <linux/skbuff.h>
+
+static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
+{
+        return (struct vlan_ethhdr *)skb->mac.raw;
+}
+
+struct vlan_hdr {
+   unsigned short       h_vlan_TCI;                /* Encapsulates priority and VLAN ID */
+   unsigned short       h_vlan_encapsulated_proto; /* packet type ID field (or len) */
+};
+
+#define VLAN_VID_MASK   0xfff
+
+/* found in socket.c */
+extern void vlan_ioctl_set(int (*hook)(void __user *));
+
+#define VLAN_NAME "vlan"
+
+/* if this changes, algorithm will have to be reworked because this
+ * depends on completely exhausting the VLAN identifier space.  Thus
+ * it gives constant time look-up, but in many cases it wastes memory.
+ */
+#define VLAN_GROUP_ARRAY_LEN 4096
+
+struct vlan_group {
+        int real_dev_ifindex; /* The ifindex of the ethernet(like) device the vlan is attached to. */
+        struct hlist_node       hlist;  /* linked list */
+        struct net_device *vlan_devices[VLAN_GROUP_ARRAY_LEN];
+        struct rcu_head         rcu;
+};
+
+struct vlan_priority_tci_mapping {
+        unsigned long priority;
+        unsigned short vlan_qos; /* This should be shifted when first set, so we only do it
+                                  * at provisioning time.
+                                  * ((skb->priority << 13) & 0xE000)
+                                  */
+        struct vlan_priority_tci_mapping *next;
+};
+
+/* Holds information that makes sense if this device is a VLAN device. */
+struct vlan_dev_info {
+        /** This will be the mapping that correlates skb->priority to
+         * 3 bits of VLAN QOS tags...
+         */
+        unsigned long ingress_priority_map[8];
+        struct vlan_priority_tci_mapping *egress_priority_map[16]; /* hash table */
+
+        unsigned short vlan_id;        /*  The VLAN Identifier for this interface. */
+        unsigned short flags;          /* (1 << 0) re_order_header   This option will cause the
+                                        *   VLAN code to move around the ethernet header on
+                                        *   ingress to make the skb look **exactly** like it
+                                        *   came in from an ethernet port.  This destroys some of
+                                        *   the VLAN information in the skb, but it fixes programs
+                                        *   like DHCP that use packet-filtering and don't understand
+                                        *   802.1Q
+                                        */
+        struct dev_mc_list *old_mc_list;  /* old multi-cast list for the VLAN interface..
+                                           * we save this so we can tell what changes were
+                                           * made, in order to feed the right changes down
+                                           * to the real hardware...
+                                           */
+        int old_allmulti;               /* similar to above. */
+        int old_promiscuity;            /* similar to above. */
+        struct net_device *real_dev;    /* the underlying device/interface */
+        struct proc_dir_entry *dent;    /* Holds the proc data */
+        unsigned long cnt_inc_headroom_on_tx; /* How many times did we have to grow the skb on TX. */
+        unsigned long cnt_encap_on_xmit;      /* How many times did we have to encapsulate the skb on TX. */
+        struct net_device_stats dev_stats; /* Device stats (rx-bytes, tx-pkts, etc...) */
+};
+
+#define VLAN_DEV_INFO(x) ((struct vlan_dev_info *)(x->priv))
+
+/* inline functions */
+
+static inline struct net_device_stats *vlan_dev_get_stats(struct net_device *dev)
+{
+        return &(VLAN_DEV_INFO(dev)->dev_stats);
+}
+
+static inline __u32 vlan_get_ingress_priority(struct net_device *dev,
+                                              unsigned short vlan_tag)
+{
+        struct vlan_dev_info *vip = VLAN_DEV_INFO(dev);
+
+        return vip->ingress_priority_map[(vlan_tag >> 13) & 0x7];
+}
+
+/* VLAN tx hw acceleration helpers. */
+struct vlan_skb_tx_cookie {
+        u32     magic;
+        u32     vlan_tag;
+};
+
+#define VLAN_TX_COOKIE_MAGIC    0x564c414e      /* "VLAN" in ascii. */
+#define VLAN_TX_SKB_CB(__skb)   ((struct vlan_skb_tx_cookie *)&((__skb)->cb[0]))
+#define vlan_tx_tag_present(__skb) \
+        (VLAN_TX_SKB_CB(__skb)->magic == VLAN_TX_COOKIE_MAGIC)
+#define vlan_tx_tag_get(__skb)  (VLAN_TX_SKB_CB(__skb)->vlan_tag)
+
+/* VLAN rx hw acceleration helper.  This acts like netif_{rx,receive_skb}(). */
+static inline int __vlan_hwaccel_rx(struct sk_buff *skb,
+                                    struct vlan_group *grp,
+                                    unsigned short vlan_tag, int polling)
+{
+        struct net_device_stats *stats;
+
+        skb->real_dev = skb->dev;
+        skb->dev = grp->vlan_devices[vlan_tag & VLAN_VID_MASK];
+        if (skb->dev == NULL) {
+                dev_kfree_skb_any(skb);
+
+                /* Not NET_RX_DROP, this is not being dropped
+                 * due to congestion.
+                 */
+                return 0;
+        }
+
+        skb->dev->last_rx = jiffies;
+
+        stats = vlan_dev_get_stats(skb->dev);
+        stats->rx_packets++;
+        stats->rx_bytes += skb->len;
+
+        skb->priority = vlan_get_ingress_priority(skb->dev, vlan_tag);
+        switch (skb->pkt_type) {
+        case PACKET_BROADCAST:
+                break;
+
+        case PACKET_MULTICAST:
+                stats->multicast++;
+                break;
+
+        case PACKET_OTHERHOST:
+                /* Our lower layer thinks this is not local, let's make sure.
+                 * This allows the VLAN to have a different MAC than the underlying
+                 * device, and still route correctly.
+                 */
+                if (!memcmp(eth_hdr(skb)->h_dest, skb->dev->dev_addr, ETH_ALEN))
+                        skb->pkt_type = PACKET_HOST;
+                break;
+        };
+
+        return (polling ? netif_receive_skb(skb) : netif_rx(skb));
+}
+
+static inline int vlan_hwaccel_rx(struct sk_buff *skb,
+                                  struct vlan_group *grp,
+                                  unsigned short vlan_tag)
+{
+        return __vlan_hwaccel_rx(skb, grp, vlan_tag, 0);
+}
+
+static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
+                                           struct vlan_group *grp,
+                                           unsigned short vlan_tag)
+{
+        return __vlan_hwaccel_rx(skb, grp, vlan_tag, 1);
+}
+
+/**
+ * __vlan_put_tag - regular VLAN tag inserting
+ * @skb: skbuff to tag
+ * @tag: VLAN tag to insert
+ *
+ * Inserts the VLAN tag into @skb as part of the payload
+ * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
+ * 
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
+ */
+static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, unsigned short tag)
+{
+        struct vlan_ethhdr *veth;
+
+        if (skb_headroom(skb) < VLAN_HLEN) {
+                struct sk_buff *sk_tmp = skb;
+                skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
+                kfree_skb(sk_tmp);
+                if (!skb) {
+                        printk(KERN_ERR "vlan: failed to realloc headroom\n");
+                        return NULL;
+                }
+        } else {
+                skb = skb_unshare(skb, GFP_ATOMIC);
+                if (!skb) {
+                        printk(KERN_ERR "vlan: failed to unshare skbuff\n");
+                        return NULL;
+                }
+        }
+
+        veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
+
+        /* Move the mac addresses to the beginning of the new header. */
+        memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
+
+        /* first, the ethernet type */
+        veth->h_vlan_proto = __constant_htons(ETH_P_8021Q);
+
+        /* now, the tag */
+        veth->h_vlan_TCI = htons(tag);
+
+        skb->protocol = __constant_htons(ETH_P_8021Q);
+        skb->mac.raw -= VLAN_HLEN;
+        skb->nh.raw -= VLAN_HLEN;
+
+        return skb;
+}
+
+/**
+ * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
+ * @skb: skbuff to tag
+ * @tag: VLAN tag to insert
+ *
+ * Puts the VLAN tag in @skb->cb[] and lets the device do the rest
+ */
+static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, unsigned short tag)
+{
+        struct vlan_skb_tx_cookie *cookie;
+
+        cookie = VLAN_TX_SKB_CB(skb);
+        cookie->magic = VLAN_TX_COOKIE_MAGIC;
+        cookie->vlan_tag = tag;
+
+        return skb;
+}
+
+#define HAVE_VLAN_PUT_TAG
+
+/**
+ * vlan_put_tag - inserts VLAN tag according to device features
+ * @skb: skbuff to tag
+ * @tag: VLAN tag to insert
+ *
+ * Assumes skb->dev is the target that will xmit this frame.
+ * Returns a VLAN tagged skb.
+ */
+static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, unsigned short tag)
+{
+        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
+                return __vlan_hwaccel_put_tag(skb, tag);
+        } else {
+                return __vlan_put_tag(skb, tag);
+        }
+}
+
+/**
+ * __vlan_get_tag - get the VLAN ID that is part of the payload
+ * @skb: skbuff to query
+ * @tag: buffer to store vlaue
+ * 
+ * Returns error if the skb is not of VLAN type
+ */
+static inline int __vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
+{
+        struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
+
+        if (veth->h_vlan_proto != __constant_htons(ETH_P_8021Q)) {
+                return -EINVAL;
+        }
+
+        *tag = ntohs(veth->h_vlan_TCI);
+
+        return 0;
+}
+
+/**
+ * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
+ * @skb: skbuff to query
+ * @tag: buffer to store vlaue
+ * 
+ * Returns error if @skb->cb[] is not set correctly
+ */
+static inline int __vlan_hwaccel_get_tag(struct sk_buff *skb, unsigned short *tag)
+{
+        struct vlan_skb_tx_cookie *cookie;
+
+        cookie = VLAN_TX_SKB_CB(skb);
+        if (cookie->magic == VLAN_TX_COOKIE_MAGIC) {
+                *tag = cookie->vlan_tag;
+                return 0;
+        } else {
+                *tag = 0;
+                return -EINVAL;
+        }
+}
+
+#define HAVE_VLAN_GET_TAG
+
+/**
+ * vlan_get_tag - get the VLAN ID from the skb
+ * @skb: skbuff to query
+ * @tag: buffer to store vlaue
+ * 
+ * Returns error if the skb is not VLAN tagged
+ */
+static inline int vlan_get_tag(struct sk_buff *skb, unsigned short *tag)
+{
+        if (skb->dev->features & NETIF_F_HW_VLAN_TX) {
+                return __vlan_hwaccel_get_tag(skb, tag);
+        } else {
+                return __vlan_get_tag(skb, tag);
+        }
+}
+
+#endif /* __KERNEL__ */
+
+/* VLAN IOCTLs are found in sockios.h */
+
+/* Passed in vlan_ioctl_args structure to determine behaviour. */
+enum vlan_ioctl_cmds {
+        ADD_VLAN_CMD,
+        DEL_VLAN_CMD,
+        SET_VLAN_INGRESS_PRIORITY_CMD,
+        SET_VLAN_EGRESS_PRIORITY_CMD,
+        GET_VLAN_INGRESS_PRIORITY_CMD,
+        GET_VLAN_EGRESS_PRIORITY_CMD,
+        SET_VLAN_NAME_TYPE_CMD,
+        SET_VLAN_FLAG_CMD,
+        GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */
+        GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
+};
+
+enum vlan_name_types {
+        VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
+        VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
+        VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like:  vlan5 */
+        VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like:  eth0.5 */
+        VLAN_NAME_TYPE_HIGHEST
+};
+
+struct vlan_ioctl_args {
+        int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */
+        char device1[24];
+
+        union {
+                char device2[24];
+                int VID;
+                unsigned int skb_priority;
+                unsigned int name_type;
+                unsigned int bind_type;
+                unsigned int flag; /* Matches vlan_dev_info flags */
+        } u;
+
+        short vlan_qos;   
+};
+
+#endif /* !(_LINUX_IF_VLAN_H_) */
diff --git a/include/linux/if_wanpipe.h b/include/linux/if_wanpipe.h
new file mode 100644
index 000000000000..e594ca6069e5
--- /dev/null
+++ b/include/linux/if_wanpipe.h
@@ -0,0 +1,124 @@
+/*****************************************************************************
+* if_wanpipe.h  Header file for the Sangoma AF_WANPIPE Socket   
+*
+* Author:       Nenad Corbic    
+*
+* Copyright:    (c) 2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+*
+* Jan 28, 2000  Nenad Corbic    Initial Version
+*
+*****************************************************************************/
+
+#ifndef __LINUX_IF_WAN_PACKET_H
+#define __LINUX_IF_WAN_PACKET_H
+
+struct wan_sockaddr_ll
+{
+        unsigned short  sll_family;
+        unsigned short  sll_protocol;
+        int             sll_ifindex;
+        unsigned short  sll_hatype;
+        unsigned char   sll_pkttype;
+        unsigned char   sll_halen;
+        unsigned char   sll_addr[8];
+        unsigned char   sll_device[14];
+        unsigned char   sll_card[14];
+};
+
+typedef struct 
+{
+        unsigned char free;
+        unsigned char state_sk;
+        int rcvbuf;
+        int sndbuf;
+        int rmem;
+        int wmem;
+        int sk_count;
+        unsigned char bound;
+        char name[14];
+        unsigned char d_state;
+        unsigned char svc;
+        unsigned short lcn;
+        unsigned char mbox;
+        unsigned char cmd_busy;
+        unsigned char command;
+        unsigned poll;
+        unsigned poll_cnt;
+        int rblock;     
+} wan_debug_hdr_t;
+
+#define MAX_NUM_DEBUG  10
+#define X25_PROT       0x16
+#define PVC_PROT       0x17     
+
+typedef struct
+{
+        wan_debug_hdr_t debug[MAX_NUM_DEBUG];
+}wan_debug_t;
+
+#define SIOC_WANPIPE_GET_CALL_DATA      (SIOCPROTOPRIVATE + 0)
+#define SIOC_WANPIPE_SET_CALL_DATA      (SIOCPROTOPRIVATE + 1)
+#define SIOC_WANPIPE_ACCEPT_CALL        (SIOCPROTOPRIVATE + 2)
+#define SIOC_WANPIPE_CLEAR_CALL         (SIOCPROTOPRIVATE + 3)
+#define SIOC_WANPIPE_RESET_CALL         (SIOCPROTOPRIVATE + 4)
+#define SIOC_WANPIPE_DEBUG              (SIOCPROTOPRIVATE + 5)
+#define SIOC_WANPIPE_SET_NONBLOCK       (SIOCPROTOPRIVATE + 6)
+#define SIOC_WANPIPE_CHECK_TX           (SIOCPROTOPRIVATE + 7)
+#define SIOC_WANPIPE_SOCK_STATE         (SIOCPROTOPRIVATE + 8)
+
+/* Packet types */
+
+#define WAN_PACKET_HOST         0               /* To us                */
+#define WAN_PACKET_BROADCAST    1               /* To all               */
+#define WAN_PACKET_MULTICAST    2               /* To group             */
+#define WAN_PACKET_OTHERHOST    3               /* To someone else      */
+#define WAN_PACKET_OUTGOING             4               /* Outgoing of any type */
+/* These ones are invisible by user level */
+#define WAN_PACKET_LOOPBACK             5               /* MC/BRD frame looped back */
+#define WAN_PACKET_FASTROUTE    6               /* Fastrouted frame     */
+
+
+/* X25 specific */
+#define WAN_PACKET_DATA         7
+#define WAN_PACKET_CMD          8
+#define WAN_PACKET_ASYNC        9
+#define WAN_PACKET_ERR         10
+
+/* Packet socket options */
+
+#define WAN_PACKET_ADD_MEMBERSHIP               1
+#define WAN_PACKET_DROP_MEMBERSHIP              2
+
+#define WAN_PACKET_MR_MULTICAST 0
+#define WAN_PACKET_MR_PROMISC   1
+#define WAN_PACKET_MR_ALLMULTI  2
+
+#ifdef __KERNEL__
+
+/* Private wanpipe socket structures. */
+struct wanpipe_opt
+{
+        void   *mbox;           /* Mail box  */
+        void   *card;           /* Card bouded to */
+        struct net_device *dev; /* Bounded device */
+        unsigned short lcn;     /* Binded LCN */
+        unsigned char  svc;     /* 0=pvc, 1=svc */
+        unsigned char  timer;   /* flag for delayed transmit*/  
+        struct timer_list tx_timer;
+        unsigned poll_cnt;
+        unsigned char force;    /* Used to force sock release */
+        atomic_t packet_sent;   
+        unsigned short num; 
+};
+
+#define wp_sk(__sk) ((struct wanpipe_opt *)(__sk)->sk_protinfo)
+
+#endif
+
+#endif
diff --git a/include/linux/if_wanpipe_common.h b/include/linux/if_wanpipe_common.h
new file mode 100644
index 000000000000..f25fec8ee2ca
--- /dev/null
+++ b/include/linux/if_wanpipe_common.h
@@ -0,0 +1,60 @@
+/*****************************************************************************
+* if_wanipe_common.h   Sangoma Driver/Socket common area definitions.
+*
+* Author:       Nenad Corbic <ncorbic@sangoma.com>
+*
+* Copyright:    (c) 2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Jan 13, 2000  Nenad Corbic      Initial version
+*****************************************************************************/
+
+
+#ifndef _WANPIPE_SOCK_DRIVER_COMMON_H
+#define _WANPIPE_SOCK_DRIVER_COMMON_H
+
+#include <linux/version.h>
+
+typedef struct {
+        struct net_device *slave;
+        atomic_t packet_sent;
+        atomic_t receive_block;
+        atomic_t command;
+        atomic_t disconnect;
+        atomic_t driver_busy;
+        long common_critical;
+        struct timer_list *tx_timer;
+        struct sock *sk;                /* Wanpipe Sock bind's here */ 
+        int (*func)(struct sk_buff *skb, struct net_device *dev, 
+                    struct sock *sk);
+
+        struct work_struct wanpipe_work;    /* deferred keventd work */
+        unsigned char rw_bind;                    /* Sock bind state */
+        unsigned char usedby;
+        unsigned char state;
+        unsigned char svc;
+        unsigned short lcn;
+        void *mbox;
+} wanpipe_common_t;
+
+
+enum {
+        WANSOCK_UNCONFIGURED,   /* link/channel is not configured */
+        WANSOCK_DISCONNECTED,   /* link/channel is disconnected */
+        WANSOCK_CONNECTING,             /* connection is in progress */
+        WANSOCK_CONNECTED,              /* link/channel is operational */
+        WANSOCK_LIMIT,          /* for verification only */
+        WANSOCK_DUALPORT,               /* for Dual Port cards */
+        WANSOCK_DISCONNECTING,
+        WANSOCK_BINDED,
+        WANSOCK_BIND_LISTEN,
+        WANSOCK_LISTEN
+};
+
+#endif
+
+
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
new file mode 100644
index 000000000000..390e760a96d3
--- /dev/null
+++ b/include/linux/igmp.h
@@ -0,0 +1,219 @@
+/*
+ *      Linux NET3:     Internet Group Management Protocol  [IGMP]
+ *
+ *      Authors:
+ *              Alan Cox <Alan.Cox@linux.org>
+ *
+ *      Extended to talk the BSD extended IGMP protocol of mrouted 3.6
+ *
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_IGMP_H
+#define _LINUX_IGMP_H
+
+#include <asm/byteorder.h>
+
+/*
+ *      IGMP protocol structures
+ */
+
+/*
+ *      Header in on cable format
+ */
+
+struct igmphdr
+{
+        __u8 type;
+        __u8 code;              /* For newer IGMP */
+        __u16 csum;
+        __u32 group;
+};
+
+/* V3 group record types [grec_type] */
+#define IGMPV3_MODE_IS_INCLUDE          1
+#define IGMPV3_MODE_IS_EXCLUDE          2
+#define IGMPV3_CHANGE_TO_INCLUDE        3
+#define IGMPV3_CHANGE_TO_EXCLUDE        4
+#define IGMPV3_ALLOW_NEW_SOURCES        5
+#define IGMPV3_BLOCK_OLD_SOURCES        6
+
+struct igmpv3_grec {
+        __u8    grec_type;
+        __u8    grec_auxwords;
+        __u16   grec_nsrcs;
+        __u32   grec_mca;
+        __u32   grec_src[0];
+};
+
+struct igmpv3_report {
+        __u8 type;
+        __u8 resv1;
+        __u16 csum;
+        __u16 resv2;
+        __u16 ngrec;
+        struct igmpv3_grec grec[0];
+};
+
+struct igmpv3_query {
+        __u8 type;
+        __u8 code;
+        __u16 csum;
+        __u32 group;
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8 qrv:3,
+             suppress:1,
+             resv:4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+        __u8 resv:4,
+             suppress:1,
+             qrv:3;
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+        __u8 qqic;
+        __u16 nsrcs;
+        __u32 srcs[0];
+};
+
+#define IGMP_HOST_MEMBERSHIP_QUERY      0x11    /* From RFC1112 */
+#define IGMP_HOST_MEMBERSHIP_REPORT     0x12    /* Ditto */
+#define IGMP_DVMRP                      0x13    /* DVMRP routing */
+#define IGMP_PIM                        0x14    /* PIM routing */
+#define IGMP_TRACE                      0x15
+#define IGMPV2_HOST_MEMBERSHIP_REPORT   0x16    /* V2 version of 0x11 */
+#define IGMP_HOST_LEAVE_MESSAGE         0x17
+#define IGMPV3_HOST_MEMBERSHIP_REPORT   0x22    /* V3 version of 0x11 */
+
+#define IGMP_MTRACE_RESP                0x1e
+#define IGMP_MTRACE                     0x1f
+
+
+/*
+ *      Use the BSD names for these for compatibility
+ */
+
+#define IGMP_DELAYING_MEMBER            0x01
+#define IGMP_IDLE_MEMBER                0x02
+#define IGMP_LAZY_MEMBER                0x03
+#define IGMP_SLEEPING_MEMBER            0x04
+#define IGMP_AWAKENING_MEMBER           0x05
+
+#define IGMP_MINLEN                     8
+
+#define IGMP_MAX_HOST_REPORT_DELAY      10      /* max delay for response to */
+                                                /* query (in seconds)   */
+
+#define IGMP_TIMER_SCALE                10      /* denotes that the igmphdr->timer field */
+                                                /* specifies time in 10th of seconds     */
+
+#define IGMP_AGE_THRESHOLD              400     /* If this host don't hear any IGMP V1  */
+                                                /* message in this period of time,      */
+                                                /* revert to IGMP v2 router.            */
+
+#define IGMP_ALL_HOSTS          htonl(0xE0000001L)
+#define IGMP_ALL_ROUTER         htonl(0xE0000002L)
+#define IGMPV3_ALL_MCR          htonl(0xE0000016L)
+#define IGMP_LOCAL_GROUP        htonl(0xE0000000L)
+#define IGMP_LOCAL_GROUP_MASK   htonl(0xFFFFFF00L)
+
+/*
+ * struct for keeping the multicast list in
+ */
+
+#ifdef __KERNEL__
+#include <linux/skbuff.h>
+#include <linux/in.h>
+
+struct ip_sf_socklist
+{
+        unsigned int            sl_max;
+        unsigned int            sl_count;
+        __u32                   sl_addr[0];
+};
+
+#define IP_SFLSIZE(count)       (sizeof(struct ip_sf_socklist) + \
+        (count) * sizeof(__u32))
+
+#define IP_SFBLOCK      10      /* allocate this many at once */
+
+/* ip_mc_socklist is real list now. Speed is not argument;
+   this list never used in fast path code
+ */
+
+struct ip_mc_socklist
+{
+        struct ip_mc_socklist   *next;
+        int                     count;
+        struct ip_mreqn         multi;
+        unsigned int            sfmode;         /* MCAST_{INCLUDE,EXCLUDE} */
+        struct ip_sf_socklist   *sflist;
+};
+
+struct ip_sf_list
+{
+        struct ip_sf_list       *sf_next;
+        __u32                   sf_inaddr;
+        unsigned long           sf_count[2];    /* include/exclude counts */
+        unsigned char           sf_gsresp;      /* include in g & s response? */
+        unsigned char           sf_oldin;       /* change state */
+        unsigned char           sf_crcount;     /* retrans. left to send */
+};
+
+struct ip_mc_list
+{
+        struct in_device        *interface;
+        unsigned long           multiaddr;
+        struct ip_sf_list       *sources;
+        struct ip_sf_list       *tomb;
+        unsigned int            sfmode;
+        unsigned long           sfcount[2];
+        struct ip_mc_list       *next;
+        struct timer_list       timer;
+        int                     users;
+        atomic_t                refcnt;
+        spinlock_t              lock;
+        char                    tm_running;
+        char                    reporter;
+        char                    unsolicit_count;
+        char                    loaded;
+        unsigned char           gsquery;        /* check source marks? */
+        unsigned char           crcount;
+};
+
+/* V3 exponential field decoding */
+#define IGMPV3_MASK(value, nb) ((nb)>=32 ? (value) : ((1<<(nb))-1) & (value))
+#define IGMPV3_EXP(thresh, nbmant, nbexp, value) \
+        ((value) < (thresh) ? (value) : \
+        ((IGMPV3_MASK(value, nbmant) | (1<<(nbmant+nbexp))) << \
+         (IGMPV3_MASK((value) >> (nbmant), nbexp) + (nbexp))))
+
+#define IGMPV3_QQIC(value) IGMPV3_EXP(0x80, 4, 3, value)
+#define IGMPV3_MRC(value) IGMPV3_EXP(0x80, 4, 3, value)
+
+extern int ip_check_mc(struct in_device *dev, u32 mc_addr, u32 src_addr, u16 proto);
+extern int igmp_rcv(struct sk_buff *);
+extern int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
+extern int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
+extern void ip_mc_drop_socket(struct sock *sk);
+extern int ip_mc_source(int add, int omode, struct sock *sk,
+                struct ip_mreq_source *mreqs, int ifindex);
+extern int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf,int ifindex);
+extern int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
+                struct ip_msfilter __user *optval, int __user *optlen);
+extern int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
+                struct group_filter __user *optval, int __user *optlen);
+extern int ip_mc_sf_allow(struct sock *sk, u32 local, u32 rmt, int dif);
+extern void ip_mr_init(void);
+extern void ip_mc_init_dev(struct in_device *);
+extern void ip_mc_destroy_dev(struct in_device *);
+extern void ip_mc_up(struct in_device *);
+extern void ip_mc_down(struct in_device *);
+extern void ip_mc_dec_group(struct in_device *in_dev, u32 addr);
+extern void ip_mc_inc_group(struct in_device *in_dev, u32 addr);
+#endif
+#endif
diff --git a/include/linux/in.h b/include/linux/in.h
new file mode 100644
index 000000000000..fb88c66d748d
--- /dev/null
+++ b/include/linux/in.h
@@ -0,0 +1,253 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions of the Internet Protocol.
+ *
+ * Version:     @(#)in.h        1.0.1   04/21/93
+ *
+ * Authors:     Original taken from the GNU Project <netinet/in.h> file.
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IN_H
+#define _LINUX_IN_H
+
+#include <linux/types.h>
+#include <linux/socket.h>
+
+/* Standard well-defined IP protocols.  */
+enum {
+  IPPROTO_IP = 0,               /* Dummy protocol for TCP               */
+  IPPROTO_ICMP = 1,             /* Internet Control Message Protocol    */
+  IPPROTO_IGMP = 2,             /* Internet Group Management Protocol   */
+  IPPROTO_IPIP = 4,             /* IPIP tunnels (older KA9Q tunnels use 94) */
+  IPPROTO_TCP = 6,              /* Transmission Control Protocol        */
+  IPPROTO_EGP = 8,              /* Exterior Gateway Protocol            */
+  IPPROTO_PUP = 12,             /* PUP protocol                         */
+  IPPROTO_UDP = 17,             /* User Datagram Protocol               */
+  IPPROTO_IDP = 22,             /* XNS IDP protocol                     */
+  IPPROTO_RSVP = 46,            /* RSVP protocol                        */
+  IPPROTO_GRE = 47,             /* Cisco GRE tunnels (rfc 1701,1702)    */
+
+  IPPROTO_IPV6   = 41,          /* IPv6-in-IPv4 tunnelling              */
+
+  IPPROTO_ESP = 50,            /* Encapsulation Security Payload protocol */
+  IPPROTO_AH = 51,             /* Authentication Header protocol       */
+  IPPROTO_PIM    = 103,         /* Protocol Independent Multicast       */
+
+  IPPROTO_COMP   = 108,                /* Compression Header protocol */
+  IPPROTO_SCTP   = 132,         /* Stream Control Transport Protocol    */
+
+  IPPROTO_RAW    = 255,         /* Raw IP packets                       */
+  IPPROTO_MAX
+};
+
+
+/* Internet address. */
+struct in_addr {
+        __u32   s_addr;
+};
+
+#define IP_TOS          1
+#define IP_TTL          2
+#define IP_HDRINCL      3
+#define IP_OPTIONS      4
+#define IP_ROUTER_ALERT 5
+#define IP_RECVOPTS     6
+#define IP_RETOPTS      7
+#define IP_PKTINFO      8
+#define IP_PKTOPTIONS   9
+#define IP_MTU_DISCOVER 10
+#define IP_RECVERR      11
+#define IP_RECVTTL      12
+#define IP_RECVTOS      13
+#define IP_MTU          14
+#define IP_FREEBIND     15
+#define IP_IPSEC_POLICY 16
+#define IP_XFRM_POLICY  17
+
+/* BSD compatibility */
+#define IP_RECVRETOPTS  IP_RETOPTS
+
+/* IP_MTU_DISCOVER values */
+#define IP_PMTUDISC_DONT                0       /* Never send DF frames */
+#define IP_PMTUDISC_WANT                1       /* Use per route hints  */
+#define IP_PMTUDISC_DO                  2       /* Always DF            */
+
+#define IP_MULTICAST_IF                 32
+#define IP_MULTICAST_TTL                33
+#define IP_MULTICAST_LOOP               34
+#define IP_ADD_MEMBERSHIP               35
+#define IP_DROP_MEMBERSHIP              36
+#define IP_UNBLOCK_SOURCE               37
+#define IP_BLOCK_SOURCE                 38
+#define IP_ADD_SOURCE_MEMBERSHIP        39
+#define IP_DROP_SOURCE_MEMBERSHIP       40
+#define IP_MSFILTER                     41
+#define MCAST_JOIN_GROUP                42
+#define MCAST_BLOCK_SOURCE              43
+#define MCAST_UNBLOCK_SOURCE            44
+#define MCAST_LEAVE_GROUP               45
+#define MCAST_JOIN_SOURCE_GROUP         46
+#define MCAST_LEAVE_SOURCE_GROUP        47
+#define MCAST_MSFILTER                  48
+
+#define MCAST_EXCLUDE   0
+#define MCAST_INCLUDE   1
+
+/* These need to appear somewhere around here */
+#define IP_DEFAULT_MULTICAST_TTL        1
+#define IP_DEFAULT_MULTICAST_LOOP       1
+
+/* Request struct for multicast socket ops */
+
+struct ip_mreq 
+{
+        struct in_addr imr_multiaddr;   /* IP multicast address of group */
+        struct in_addr imr_interface;   /* local IP address of interface */
+};
+
+struct ip_mreqn
+{
+        struct in_addr  imr_multiaddr;          /* IP multicast address of group */
+        struct in_addr  imr_address;            /* local IP address of interface */
+        int             imr_ifindex;            /* Interface index */
+};
+
+struct ip_mreq_source {
+        __u32           imr_multiaddr;
+        __u32           imr_interface;
+        __u32           imr_sourceaddr;
+};
+
+struct ip_msfilter {
+        __u32           imsf_multiaddr;
+        __u32           imsf_interface;
+        __u32           imsf_fmode;
+        __u32           imsf_numsrc;
+        __u32           imsf_slist[1];
+};
+
+#define IP_MSFILTER_SIZE(numsrc) \
+        (sizeof(struct ip_msfilter) - sizeof(__u32) \
+        + (numsrc) * sizeof(__u32))
+
+struct group_req
+{
+        __u32                            gr_interface;  /* interface index */
+        struct __kernel_sockaddr_storage gr_group;      /* group address */
+};
+
+struct group_source_req
+{
+        __u32                            gsr_interface; /* interface index */
+        struct __kernel_sockaddr_storage gsr_group;     /* group address */
+        struct __kernel_sockaddr_storage gsr_source;    /* source address */
+};
+
+struct group_filter
+{
+        __u32                            gf_interface;  /* interface index */
+        struct __kernel_sockaddr_storage gf_group;      /* multicast address */
+        __u32                            gf_fmode;      /* filter mode */
+        __u32                            gf_numsrc;     /* number of sources */
+        struct __kernel_sockaddr_storage gf_slist[1];   /* interface index */
+};
+
+#define GROUP_FILTER_SIZE(numsrc) \
+        (sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) \
+        + (numsrc) * sizeof(struct __kernel_sockaddr_storage))
+
+struct in_pktinfo
+{
+        int             ipi_ifindex;
+        struct in_addr  ipi_spec_dst;
+        struct in_addr  ipi_addr;
+};
+
+/* Structure describing an Internet (IP) socket address. */
+#define __SOCK_SIZE__   16              /* sizeof(struct sockaddr)      */
+struct sockaddr_in {
+  sa_family_t           sin_family;     /* Address family               */
+  unsigned short int    sin_port;       /* Port number                  */
+  struct in_addr        sin_addr;       /* Internet address             */
+
+  /* Pad to size of `struct sockaddr'. */
+  unsigned char         __pad[__SOCK_SIZE__ - sizeof(short int) -
+                        sizeof(unsigned short int) - sizeof(struct in_addr)];
+};
+#define sin_zero        __pad           /* for BSD UNIX comp. -FvK      */
+
+
+/*
+ * Definitions of the bits in an Internet address integer.
+ * On subnets, host and network parts are found according
+ * to the subnet mask, not these masks.
+ */
+#define IN_CLASSA(a)            ((((long int) (a)) & 0x80000000) == 0)
+#define IN_CLASSA_NET           0xff000000
+#define IN_CLASSA_NSHIFT        24
+#define IN_CLASSA_HOST          (0xffffffff & ~IN_CLASSA_NET)
+#define IN_CLASSA_MAX           128
+
+#define IN_CLASSB(a)            ((((long int) (a)) & 0xc0000000) == 0x80000000)
+#define IN_CLASSB_NET           0xffff0000
+#define IN_CLASSB_NSHIFT        16
+#define IN_CLASSB_HOST          (0xffffffff & ~IN_CLASSB_NET)
+#define IN_CLASSB_MAX           65536
+
+#define IN_CLASSC(a)            ((((long int) (a)) & 0xe0000000) == 0xc0000000)
+#define IN_CLASSC_NET           0xffffff00
+#define IN_CLASSC_NSHIFT        8
+#define IN_CLASSC_HOST          (0xffffffff & ~IN_CLASSC_NET)
+
+#define IN_CLASSD(a)            ((((long int) (a)) & 0xf0000000) == 0xe0000000)
+#define IN_MULTICAST(a)         IN_CLASSD(a)
+#define IN_MULTICAST_NET        0xF0000000
+
+#define IN_EXPERIMENTAL(a)      ((((long int) (a)) & 0xf0000000) == 0xf0000000)
+#define IN_BADCLASS(a)          IN_EXPERIMENTAL((a))
+
+/* Address to accept any incoming messages. */
+#define INADDR_ANY              ((unsigned long int) 0x00000000)
+
+/* Address to send to all hosts. */
+#define INADDR_BROADCAST        ((unsigned long int) 0xffffffff)
+
+/* Address indicating an error return. */
+#define INADDR_NONE             ((unsigned long int) 0xffffffff)
+
+/* Network number for local host loopback. */
+#define IN_LOOPBACKNET          127
+
+/* Address to loopback in software to local host.  */
+#define INADDR_LOOPBACK         0x7f000001      /* 127.0.0.1   */
+#define IN_LOOPBACK(a)          ((((long int) (a)) & 0xff000000) == 0x7f000000)
+
+/* Defines for Multicast INADDR */
+#define INADDR_UNSPEC_GROUP     0xe0000000U     /* 224.0.0.0   */
+#define INADDR_ALLHOSTS_GROUP   0xe0000001U     /* 224.0.0.1   */
+#define INADDR_ALLRTRS_GROUP    0xe0000002U     /* 224.0.0.2 */
+#define INADDR_MAX_LOCAL_GROUP  0xe00000ffU     /* 224.0.0.255 */
+
+
+/* <asm/byteorder.h> contains the htonl type stuff.. */
+#include <asm/byteorder.h> 
+
+#ifdef __KERNEL__
+/* Some random defines to make it easier in the kernel.. */
+#define LOOPBACK(x)     (((x) & htonl(0xff000000)) == htonl(0x7f000000))
+#define MULTICAST(x)    (((x) & htonl(0xf0000000)) == htonl(0xe0000000))
+#define BADCLASS(x)     (((x) & htonl(0xf0000000)) == htonl(0xf0000000))
+#define ZERONET(x)      (((x) & htonl(0xff000000)) == htonl(0x00000000))
+#define LOCAL_MCAST(x)  (((x) & htonl(0xFFFFFF00)) == htonl(0xE0000000))
+
+#endif
+
+#endif  /* _LINUX_IN_H */
diff --git a/include/linux/in6.h b/include/linux/in6.h
new file mode 100644
index 000000000000..f8256c582845
--- /dev/null
+++ b/include/linux/in6.h
@@ -0,0 +1,201 @@
+/*
+ *      Types and definitions for AF_INET6 
+ *      Linux INET6 implementation 
+ *
+ *      Authors:
+ *      Pedro Roque             <roque@di.fc.ul.pt>     
+ *
+ *      Sources:
+ *      IPv6 Program Interfaces for BSD Systems
+ *      <draft-ietf-ipngwg-bsd-api-05.txt>
+ *
+ *      Advanced Sockets API for IPv6
+ *      <draft-stevens-advanced-api-00.txt>
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_IN6_H
+#define _LINUX_IN6_H
+
+#include <linux/types.h>
+
+/*
+ *      IPv6 address structure
+ */
+
+struct in6_addr
+{
+        union 
+        {
+                __u8            u6_addr8[16];
+                __u16           u6_addr16[8];
+                __u32           u6_addr32[4];
+        } in6_u;
+#define s6_addr                 in6_u.u6_addr8
+#define s6_addr16               in6_u.u6_addr16
+#define s6_addr32               in6_u.u6_addr32
+};
+
+/* IPv6 Wildcard Address (::) and Loopback Address (::1) defined in RFC2553
+ * NOTE: Be aware the IN6ADDR_* constants and in6addr_* externals are defined
+ * in network byte order, not in host byte order as are the IPv4 equivalents
+ */
+#if 0
+extern const struct in6_addr in6addr_any;
+#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
+#endif
+extern const struct in6_addr in6addr_loopback;
+#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
+
+struct sockaddr_in6 {
+        unsigned short int      sin6_family;    /* AF_INET6 */
+        __u16                   sin6_port;      /* Transport layer port # */
+        __u32                   sin6_flowinfo;  /* IPv6 flow information */
+        struct in6_addr         sin6_addr;      /* IPv6 address */
+        __u32                   sin6_scope_id;  /* scope id (new in RFC2553) */
+};
+
+struct ipv6_mreq {
+        /* IPv6 multicast address of group */
+        struct in6_addr ipv6mr_multiaddr;
+
+        /* local IPv6 address of interface */
+        int             ipv6mr_ifindex;
+};
+
+#define ipv6mr_acaddr   ipv6mr_multiaddr
+
+struct in6_flowlabel_req
+{
+        struct in6_addr flr_dst;
+        __u32   flr_label;
+        __u8    flr_action;
+        __u8    flr_share;
+        __u16   flr_flags;
+        __u16   flr_expires;
+        __u16   flr_linger;
+        __u32   __flr_pad;
+        /* Options in format of IPV6_PKTOPTIONS */
+};
+
+#define IPV6_FL_A_GET   0
+#define IPV6_FL_A_PUT   1
+#define IPV6_FL_A_RENEW 2
+
+#define IPV6_FL_F_CREATE        1
+#define IPV6_FL_F_EXCL          2
+
+#define IPV6_FL_S_NONE          0
+#define IPV6_FL_S_EXCL          1
+#define IPV6_FL_S_PROCESS       2
+#define IPV6_FL_S_USER          3
+#define IPV6_FL_S_ANY           255
+
+
+/*
+ *      Bitmask constant declarations to help applications select out the 
+ *      flow label and priority fields.
+ *
+ *      Note that this are in host byte order while the flowinfo field of
+ *      sockaddr_in6 is in network byte order.
+ */
+
+#define IPV6_FLOWINFO_FLOWLABEL         0x000fffff
+#define IPV6_FLOWINFO_PRIORITY          0x0ff00000
+
+/* These defintions are obsolete */
+#define IPV6_PRIORITY_UNCHARACTERIZED   0x0000
+#define IPV6_PRIORITY_FILLER            0x0100
+#define IPV6_PRIORITY_UNATTENDED        0x0200
+#define IPV6_PRIORITY_RESERVED1         0x0300
+#define IPV6_PRIORITY_BULK              0x0400
+#define IPV6_PRIORITY_RESERVED2         0x0500
+#define IPV6_PRIORITY_INTERACTIVE       0x0600
+#define IPV6_PRIORITY_CONTROL           0x0700
+#define IPV6_PRIORITY_8                 0x0800
+#define IPV6_PRIORITY_9                 0x0900
+#define IPV6_PRIORITY_10                0x0a00
+#define IPV6_PRIORITY_11                0x0b00
+#define IPV6_PRIORITY_12                0x0c00
+#define IPV6_PRIORITY_13                0x0d00
+#define IPV6_PRIORITY_14                0x0e00
+#define IPV6_PRIORITY_15                0x0f00
+
+/*
+ *      IPV6 extension headers
+ */
+#define IPPROTO_HOPOPTS         0       /* IPv6 hop-by-hop options      */
+#define IPPROTO_ROUTING         43      /* IPv6 routing header          */
+#define IPPROTO_FRAGMENT        44      /* IPv6 fragmentation header    */
+#define IPPROTO_ICMPV6          58      /* ICMPv6                       */
+#define IPPROTO_NONE            59      /* IPv6 no next header          */
+#define IPPROTO_DSTOPTS         60      /* IPv6 destination options     */
+
+/*
+ *      IPv6 TLV options.
+ */
+#define IPV6_TLV_PAD0           0
+#define IPV6_TLV_PADN           1
+#define IPV6_TLV_ROUTERALERT    5
+#define IPV6_TLV_JUMBO          194
+
+/*
+ *      IPV6 socket options
+ */
+
+#define IPV6_ADDRFORM           1
+#define IPV6_PKTINFO            2
+#define IPV6_HOPOPTS            3
+#define IPV6_DSTOPTS            4
+#define IPV6_RTHDR              5
+#define IPV6_PKTOPTIONS         6
+#define IPV6_CHECKSUM           7
+#define IPV6_HOPLIMIT           8
+#define IPV6_NEXTHOP            9
+#define IPV6_AUTHHDR            10
+#define IPV6_FLOWINFO           11
+
+#define IPV6_UNICAST_HOPS       16
+#define IPV6_MULTICAST_IF       17
+#define IPV6_MULTICAST_HOPS     18
+#define IPV6_MULTICAST_LOOP     19
+#define IPV6_ADD_MEMBERSHIP     20
+#define IPV6_DROP_MEMBERSHIP    21
+#define IPV6_ROUTER_ALERT       22
+#define IPV6_MTU_DISCOVER       23
+#define IPV6_MTU                24
+#define IPV6_RECVERR            25
+#define IPV6_V6ONLY             26
+#define IPV6_JOIN_ANYCAST       27
+#define IPV6_LEAVE_ANYCAST      28
+
+/* IPV6_MTU_DISCOVER values */
+#define IPV6_PMTUDISC_DONT              0
+#define IPV6_PMTUDISC_WANT              1
+#define IPV6_PMTUDISC_DO                2
+
+/* Flowlabel */
+#define IPV6_FLOWLABEL_MGR      32
+#define IPV6_FLOWINFO_SEND      33
+
+#define IPV6_IPSEC_POLICY       34
+#define IPV6_XFRM_POLICY        35
+
+/*
+ * Multicast:
+ * Following socket options are shared between IPv4 and IPv6.
+ *
+ * MCAST_JOIN_GROUP             42
+ * MCAST_BLOCK_SOURCE           43
+ * MCAST_UNBLOCK_SOURCE         44
+ * MCAST_LEAVE_GROUP            45
+ * MCAST_JOIN_SOURCE_GROUP      46
+ * MCAST_LEAVE_SOURCE_GROUP     47
+ * MCAST_MSFILTER               48
+ */
+
+#endif
diff --git a/include/linux/in_route.h b/include/linux/in_route.h
new file mode 100644
index 000000000000..61f25c30a2a0
--- /dev/null
+++ b/include/linux/in_route.h
@@ -0,0 +1,32 @@
+#ifndef _LINUX_IN_ROUTE_H
+#define _LINUX_IN_ROUTE_H
+
+/* IPv4 routing cache flags */
+
+#define RTCF_DEAD       RTNH_F_DEAD
+#define RTCF_ONLINK     RTNH_F_ONLINK
+
+/* Obsolete flag. About to be deleted */
+#define RTCF_NOPMTUDISC RTM_F_NOPMTUDISC
+
+#define RTCF_NOTIFY     0x00010000
+#define RTCF_DIRECTDST  0x00020000
+#define RTCF_REDIRECTED 0x00040000
+#define RTCF_TPROXY     0x00080000
+
+#define RTCF_FAST       0x00200000
+#define RTCF_MASQ       0x00400000
+#define RTCF_SNAT       0x00800000
+#define RTCF_DOREDIRECT 0x01000000
+#define RTCF_DIRECTSRC  0x04000000
+#define RTCF_DNAT       0x08000000
+#define RTCF_BROADCAST  0x10000000
+#define RTCF_MULTICAST  0x20000000
+#define RTCF_REJECT     0x40000000
+#define RTCF_LOCAL      0x80000000
+
+#define RTCF_NAT        (RTCF_DNAT|RTCF_SNAT)
+
+#define RT_TOS(tos)     ((tos)&IPTOS_TOS_MASK)
+
+#endif /* _LINUX_IN_ROUTE_H */
diff --git a/include/linux/inet.h b/include/linux/inet.h
new file mode 100644
index 000000000000..3b5e9fdff872
--- /dev/null
+++ b/include/linux/inet.h
@@ -0,0 +1,50 @@
+/*
+ *              Swansea University Computer Society NET3
+ *
+ *      This work is derived from NET2Debugged, which is in turn derived
+ *      from NET2D which was written by:
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              This work was derived from Ross Biro's inspirational work
+ *              for the LINUX operating system.  His version numbers were:
+ *
+ *              $Id: Space.c,v     0.8.4.5  1992/12/12 19:25:04 bir7 Exp $
+ *              $Id: arp.c,v       0.8.4.6  1993/01/28 22:30:00 bir7 Exp $
+ *              $Id: arp.h,v       0.8.4.6  1993/01/28 22:30:00 bir7 Exp $
+ *              $Id: dev.c,v       0.8.4.13 1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: dev.h,v       0.8.4.7  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: eth.c,v       0.8.4.4  1993/01/22 23:21:38 bir7 Exp $
+ *              $Id: eth.h,v       0.8.4.1  1992/11/10 00:17:18 bir7 Exp $
+ *              $Id: icmp.c,v      0.8.4.9  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: icmp.h,v      0.8.4.2  1992/11/15 14:55:30 bir7 Exp $
+ *              $Id: ip.c,v        0.8.4.8  1992/12/12 19:25:04 bir7 Exp $
+ *              $Id: ip.h,v        0.8.4.2  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: loopback.c,v  0.8.4.8  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: packet.c,v    0.8.4.7  1993/01/26 22:04:00 bir7 Exp $
+ *              $Id: protocols.c,v 0.8.4.3  1992/11/15 14:55:30 bir7 Exp $
+ *              $Id: raw.c,v       0.8.4.12 1993/01/26 22:04:00 bir7 Exp $
+ *              $Id: sock.c,v      0.8.4.6  1993/01/28 22:30:00 bir7 Exp $
+ *              $Id: sock.h,v      0.8.4.7  1993/01/26 22:04:00 bir7 Exp $
+ *              $Id: tcp.c,v       0.8.4.16 1993/01/26 22:04:00 bir7 Exp $
+ *              $Id: tcp.h,v       0.8.4.7  1993/01/22 22:58:08 bir7 Exp $
+ *              $Id: timer.c,v     0.8.4.8  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: timer.h,v     0.8.4.2  1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: udp.c,v       0.8.4.12 1993/01/26 22:04:00 bir7 Exp $
+ *              $Id: udp.h,v       0.8.4.1  1992/11/10 00:17:18 bir7 Exp $
+ *              $Id: we.c,v        0.8.4.10 1993/01/23 18:00:11 bir7 Exp $
+ *              $Id: wereg.h,v     0.8.4.1  1992/11/10 00:17:18 bir7 Exp $
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_INET_H
+#define _LINUX_INET_H
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+
+extern __u32 in_aton(const char *str);
+#endif
+#endif  /* _LINUX_INET_H */
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
new file mode 100644
index 000000000000..6fafb27877a7
--- /dev/null
+++ b/include/linux/inetdevice.h
@@ -0,0 +1,190 @@
+#ifndef _LINUX_INETDEVICE_H
+#define _LINUX_INETDEVICE_H
+
+#ifdef __KERNEL__
+
+#include <linux/if.h>
+#include <linux/netdevice.h>
+#include <linux/rcupdate.h>
+#include <linux/timer.h>
+
+struct ipv4_devconf
+{
+        int     accept_redirects;
+        int     send_redirects;
+        int     secure_redirects;
+        int     shared_media;
+        int     accept_source_route;
+        int     rp_filter;
+        int     proxy_arp;
+        int     bootp_relay;
+        int     log_martians;
+        int     forwarding;
+        int     mc_forwarding;
+        int     tag;
+        int     arp_filter;
+        int     arp_announce;
+        int     arp_ignore;
+        int     medium_id;
+        int     no_xfrm;
+        int     no_policy;
+        int     force_igmp_version;
+        void    *sysctl;
+};
+
+extern struct ipv4_devconf ipv4_devconf;
+
+struct in_device
+{
+        struct net_device       *dev;
+        atomic_t                refcnt;
+        int                     dead;
+        struct in_ifaddr        *ifa_list;      /* IP ifaddr chain              */
+        rwlock_t                mc_list_lock;
+        struct ip_mc_list       *mc_list;       /* IP multicast filter chain    */
+        spinlock_t              mc_tomb_lock;
+        struct ip_mc_list       *mc_tomb;
+        unsigned long           mr_v1_seen;
+        unsigned long           mr_v2_seen;
+        unsigned long           mr_maxdelay;
+        unsigned char           mr_qrv;
+        unsigned char           mr_gq_running;
+        unsigned char           mr_ifc_count;
+        struct timer_list       mr_gq_timer;    /* general query timer */
+        struct timer_list       mr_ifc_timer;   /* interface change timer */
+
+        struct neigh_parms      *arp_parms;
+        struct ipv4_devconf     cnf;
+        struct rcu_head         rcu_head;
+};
+
+#define IN_DEV_FORWARD(in_dev)          ((in_dev)->cnf.forwarding)
+#define IN_DEV_MFORWARD(in_dev)         (ipv4_devconf.mc_forwarding && (in_dev)->cnf.mc_forwarding)
+#define IN_DEV_RPFILTER(in_dev)         (ipv4_devconf.rp_filter && (in_dev)->cnf.rp_filter)
+#define IN_DEV_SOURCE_ROUTE(in_dev)     (ipv4_devconf.accept_source_route && (in_dev)->cnf.accept_source_route)
+#define IN_DEV_BOOTP_RELAY(in_dev)      (ipv4_devconf.bootp_relay && (in_dev)->cnf.bootp_relay)
+
+#define IN_DEV_LOG_MARTIANS(in_dev)     (ipv4_devconf.log_martians || (in_dev)->cnf.log_martians)
+#define IN_DEV_PROXY_ARP(in_dev)        (ipv4_devconf.proxy_arp || (in_dev)->cnf.proxy_arp)
+#define IN_DEV_SHARED_MEDIA(in_dev)     (ipv4_devconf.shared_media || (in_dev)->cnf.shared_media)
+#define IN_DEV_TX_REDIRECTS(in_dev)     (ipv4_devconf.send_redirects || (in_dev)->cnf.send_redirects)
+#define IN_DEV_SEC_REDIRECTS(in_dev)    (ipv4_devconf.secure_redirects || (in_dev)->cnf.secure_redirects)
+#define IN_DEV_IDTAG(in_dev)            ((in_dev)->cnf.tag)
+#define IN_DEV_MEDIUM_ID(in_dev)        ((in_dev)->cnf.medium_id)
+
+#define IN_DEV_RX_REDIRECTS(in_dev) \
+        ((IN_DEV_FORWARD(in_dev) && \
+          (ipv4_devconf.accept_redirects && (in_dev)->cnf.accept_redirects)) \
+         || (!IN_DEV_FORWARD(in_dev) && \
+          (ipv4_devconf.accept_redirects || (in_dev)->cnf.accept_redirects)))
+
+#define IN_DEV_ARPFILTER(in_dev)        (ipv4_devconf.arp_filter || (in_dev)->cnf.arp_filter)
+#define IN_DEV_ARP_ANNOUNCE(in_dev)     (max(ipv4_devconf.arp_announce, (in_dev)->cnf.arp_announce))
+#define IN_DEV_ARP_IGNORE(in_dev)       (max(ipv4_devconf.arp_ignore, (in_dev)->cnf.arp_ignore))
+
+struct in_ifaddr
+{
+        struct in_ifaddr        *ifa_next;
+        struct in_device        *ifa_dev;
+        struct rcu_head         rcu_head;
+        u32                     ifa_local;
+        u32                     ifa_address;
+        u32                     ifa_mask;
+        u32                     ifa_broadcast;
+        u32                     ifa_anycast;
+        unsigned char           ifa_scope;
+        unsigned char           ifa_flags;
+        unsigned char           ifa_prefixlen;
+        char                    ifa_label[IFNAMSIZ];
+};
+
+extern int register_inetaddr_notifier(struct notifier_block *nb);
+extern int unregister_inetaddr_notifier(struct notifier_block *nb);
+
+extern struct net_device        *ip_dev_find(u32 addr);
+extern int              inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b);
+extern int              devinet_ioctl(unsigned int cmd, void __user *);
+extern void             devinet_init(void);
+extern struct in_device *inetdev_init(struct net_device *dev);
+extern struct in_device *inetdev_by_index(int);
+extern u32              inet_select_addr(const struct net_device *dev, u32 dst, int scope);
+extern u32              inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope);
+extern struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix, u32 mask);
+extern void             inet_forward_change(void);
+
+static __inline__ int inet_ifa_match(u32 addr, struct in_ifaddr *ifa)
+{
+        return !((addr^ifa->ifa_address)&ifa->ifa_mask);
+}
+
+/*
+ *      Check if a mask is acceptable.
+ */
+ 
+static __inline__ int bad_mask(u32 mask, u32 addr)
+{
+        if (addr & (mask = ~mask))
+                return 1;
+        mask = ntohl(mask);
+        if (mask & (mask+1))
+                return 1;
+        return 0;
+}
+
+#define for_primary_ifa(in_dev) { struct in_ifaddr *ifa; \
+  for (ifa = (in_dev)->ifa_list; ifa && !(ifa->ifa_flags&IFA_F_SECONDARY); ifa = ifa->ifa_next)
+
+#define for_ifa(in_dev) { struct in_ifaddr *ifa; \
+  for (ifa = (in_dev)->ifa_list; ifa; ifa = ifa->ifa_next)
+
+
+#define endfor_ifa(in_dev) }
+
+static __inline__ struct in_device *
+in_dev_get(const struct net_device *dev)
+{
+        struct in_device *in_dev;
+
+        rcu_read_lock();
+        in_dev = dev->ip_ptr;
+        if (in_dev)
+                atomic_inc(&in_dev->refcnt);
+        rcu_read_unlock();
+        return in_dev;
+}
+
+static __inline__ struct in_device *
+__in_dev_get(const struct net_device *dev)
+{
+        return (struct in_device*)dev->ip_ptr;
+}
+
+extern void in_dev_finish_destroy(struct in_device *idev);
+
+static inline void in_dev_put(struct in_device *idev)
+{
+        if (atomic_dec_and_test(&idev->refcnt))
+                in_dev_finish_destroy(idev);
+}
+
+#define __in_dev_put(idev)  atomic_dec(&(idev)->refcnt)
+#define in_dev_hold(idev)   atomic_inc(&(idev)->refcnt)
+
+#endif /* __KERNEL__ */
+
+static __inline__ __u32 inet_make_mask(int logmask)
+{
+        if (logmask)
+                return htonl(~((1<<(32-logmask))-1));
+        return 0;
+}
+
+static __inline__ int inet_mask_len(__u32 mask)
+{
+        if (!(mask = ntohl(mask)))
+                return 0;
+        return 32 - ffz(~mask);
+}
+
+
+#endif /* _LINUX_INETDEVICE_H */
diff --git a/include/linux/init.h b/include/linux/init.h
new file mode 100644
index 000000000000..05c83e0521ca
--- /dev/null
+++ b/include/linux/init.h
@@ -0,0 +1,250 @@
+#ifndef _LINUX_INIT_H
+#define _LINUX_INIT_H
+
+#include <linux/config.h>
+#include <linux/compiler.h>
+
+/* These macros are used to mark some functions or 
+ * initialized data (doesn't apply to uninitialized data)
+ * as `initialization' functions. The kernel can take this
+ * as hint that the function is used only during the initialization
+ * phase and free up used memory resources after
+ *
+ * Usage:
+ * For functions:
+ * 
+ * You should add __init immediately before the function name, like:
+ *
+ * static void __init initme(int x, int y)
+ * {
+ *    extern int z; z = x * y;
+ * }
+ *
+ * If the function has a prototype somewhere, you can also add
+ * __init between closing brace of the prototype and semicolon:
+ *
+ * extern int initialize_foobar_device(int, int, int) __init;
+ *
+ * For initialized data:
+ * You should insert __initdata between the variable name and equal
+ * sign followed by value, e.g.:
+ *
+ * static int init_variable __initdata = 0;
+ * static char linux_logo[] __initdata = { 0x32, 0x36, ... };
+ *
+ * Don't forget to initialize data not at file scope, i.e. within a function,
+ * as gcc otherwise puts the data into the bss section and not into the init
+ * section.
+ * 
+ * Also note, that this data cannot be "const".
+ */
+
+/* These are for everybody (although not all archs will actually
+   discard it in modules) */
+#define __init          __attribute__ ((__section__ (".init.text")))
+#define __initdata      __attribute__ ((__section__ (".init.data")))
+#define __exitdata      __attribute__ ((__section__(".exit.data")))
+#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
+
+#ifdef MODULE
+#define __exit          __attribute__ ((__section__(".exit.text")))
+#else
+#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text")))
+#endif
+
+/* For assembly routines */
+#define __INIT          .section        ".init.text","ax"
+#define __FINIT         .previous
+#define __INITDATA      .section        ".init.data","aw"
+
+#ifndef __ASSEMBLY__
+/*
+ * Used for initialization calls..
+ */
+typedef int (*initcall_t)(void);
+typedef void (*exitcall_t)(void);
+
+extern initcall_t __con_initcall_start[], __con_initcall_end[];
+extern initcall_t __security_initcall_start[], __security_initcall_end[];
+
+/* Defined in init/main.c */
+extern char saved_command_line[];
+#endif
+  
+#ifndef MODULE
+
+#ifndef __ASSEMBLY__
+
+/* initcalls are now grouped by functionality into separate 
+ * subsections. Ordering inside the subsections is determined
+ * by link order. 
+ * For backwards compatibility, initcall() puts the call in 
+ * the device init subsection.
+ */
+
+#define __define_initcall(level,fn) \
+        static initcall_t __initcall_##fn __attribute_used__ \
+        __attribute__((__section__(".initcall" level ".init"))) = fn
+
+#define core_initcall(fn)               __define_initcall("1",fn)
+#define postcore_initcall(fn)           __define_initcall("2",fn)
+#define arch_initcall(fn)               __define_initcall("3",fn)
+#define subsys_initcall(fn)             __define_initcall("4",fn)
+#define fs_initcall(fn)                 __define_initcall("5",fn)
+#define device_initcall(fn)             __define_initcall("6",fn)
+#define late_initcall(fn)               __define_initcall("7",fn)
+
+#define __initcall(fn) device_initcall(fn)
+
+#define __exitcall(fn) \
+        static exitcall_t __exitcall_##fn __exit_call = fn
+
+#define console_initcall(fn) \
+        static initcall_t __initcall_##fn \
+        __attribute_used__ __attribute__((__section__(".con_initcall.init")))=fn
+
+#define security_initcall(fn) \
+        static initcall_t __initcall_##fn \
+        __attribute_used__ __attribute__((__section__(".security_initcall.init"))) = fn
+
+struct obs_kernel_param {
+        const char *str;
+        int (*setup_func)(char *);
+        int early;
+};
+
+/*
+ * Only for really core code.  See moduleparam.h for the normal way.
+ *
+ * Force the alignment so the compiler doesn't space elements of the
+ * obs_kernel_param "array" too far apart in .init.setup.
+ */
+#define __setup_param(str, unique_id, fn, early)                        \
+        static char __setup_str_##unique_id[] __initdata = str; \
+        static struct obs_kernel_param __setup_##unique_id      \
+                __attribute_used__                              \
+                __attribute__((__section__(".init.setup")))     \
+                __attribute__((aligned((sizeof(long)))))        \
+                = { __setup_str_##unique_id, fn, early }
+
+#define __setup_null_param(str, unique_id)                      \
+        __setup_param(str, unique_id, NULL, 0)
+
+#define __setup(str, fn)                                        \
+        __setup_param(str, fn, fn, 0)
+
+#define __obsolete_setup(str)                                   \
+        __setup_null_param(str, __LINE__)
+
+/* NOTE: fn is as per module_param, not __setup!  Emits warning if fn
+ * returns non-zero. */
+#define early_param(str, fn)                                    \
+        __setup_param(str, fn, fn, 1)
+
+/* Relies on saved_command_line being set */
+void __init parse_early_param(void);
+#endif /* __ASSEMBLY__ */
+
+/**
+ * module_init() - driver initialization entry point
+ * @x: function to be run at kernel boot time or module insertion
+ * 
+ * module_init() will either be called during do_initcalls (if
+ * builtin) or at module insertion time (if a module).  There can only
+ * be one per module.
+ */
+#define module_init(x)  __initcall(x);
+
+/**
+ * module_exit() - driver exit entry point
+ * @x: function to be run when driver is removed
+ * 
+ * module_exit() will wrap the driver clean-up code
+ * with cleanup_module() when used with rmmod when
+ * the driver is a module.  If the driver is statically
+ * compiled into the kernel, module_exit() has no effect.
+ * There can only be one per module.
+ */
+#define module_exit(x)  __exitcall(x);
+
+#else /* MODULE */
+
+/* Don't use these in modules, but some people do... */
+#define core_initcall(fn)               module_init(fn)
+#define postcore_initcall(fn)           module_init(fn)
+#define arch_initcall(fn)               module_init(fn)
+#define subsys_initcall(fn)             module_init(fn)
+#define fs_initcall(fn)                 module_init(fn)
+#define device_initcall(fn)             module_init(fn)
+#define late_initcall(fn)               module_init(fn)
+
+#define security_initcall(fn)           module_init(fn)
+
+/* These macros create a dummy inline: gcc 2.9x does not count alias
+ as usage, hence the `unused function' warning when __init functions
+ are declared static. We use the dummy __*_module_inline functions
+ both to kill the warning and check the type of the init/cleanup
+ function. */
+
+/* Each module must use one module_init(), or one no_module_init */
+#define module_init(initfn)                                     \
+        static inline initcall_t __inittest(void)               \
+        { return initfn; }                                      \
+        int init_module(void) __attribute__((alias(#initfn)));
+
+/* This is only required if you want to be unloadable. */
+#define module_exit(exitfn)                                     \
+        static inline exitcall_t __exittest(void)               \
+        { return exitfn; }                                      \
+        void cleanup_module(void) __attribute__((alias(#exitfn)));
+
+#define __setup_param(str, unique_id, fn)       /* nothing */
+#define __setup_null_param(str, unique_id)      /* nothing */
+#define __setup(str, func)                      /* nothing */
+#define __obsolete_setup(str)                   /* nothing */
+#endif
+
+/* Data marked not to be saved by software_suspend() */
+#define __nosavedata __attribute__ ((__section__ (".data.nosave")))
+
+/* This means "can be init if no module support, otherwise module load
+   may call it." */
+#ifdef CONFIG_MODULES
+#define __init_or_module
+#define __initdata_or_module
+#else
+#define __init_or_module __init
+#define __initdata_or_module __initdata
+#endif /*CONFIG_MODULES*/
+
+#ifdef CONFIG_HOTPLUG
+#define __devinit
+#define __devinitdata
+#define __devexit
+#define __devexitdata
+#else
+#define __devinit __init
+#define __devinitdata __initdata
+#define __devexit __exit
+#define __devexitdata __exitdata
+#endif
+
+/* Functions marked as __devexit may be discarded at kernel link time, depending
+   on config options.  Newer versions of binutils detect references from
+   retained sections to discarded sections and flag an error.  Pointers to
+   __devexit functions must use __devexit_p(function_name), the wrapper will
+   insert either the function_name or NULL, depending on the config options.
+ */
+#if defined(MODULE) || defined(CONFIG_HOTPLUG)
+#define __devexit_p(x) x
+#else
+#define __devexit_p(x) NULL
+#endif
+
+#ifdef MODULE
+#define __exit_p(x) x
+#else
+#define __exit_p(x) NULL
+#endif
+
+#endif /* _LINUX_INIT_H */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
new file mode 100644
index 000000000000..a6a8c1a38d5e
--- /dev/null
+++ b/include/linux/init_task.h
@@ -0,0 +1,125 @@
+#ifndef _LINUX__INIT_TASK_H
+#define _LINUX__INIT_TASK_H
+
+#include <linux/file.h>
+
+#define INIT_FILES \
+{                                                       \
+        .count          = ATOMIC_INIT(1),               \
+        .file_lock      = SPIN_LOCK_UNLOCKED,           \
+        .max_fds        = NR_OPEN_DEFAULT,              \
+        .max_fdset      = __FD_SETSIZE,                 \
+        .next_fd        = 0,                            \
+        .fd             = &init_files.fd_array[0],      \
+        .close_on_exec  = &init_files.close_on_exec_init, \
+        .open_fds       = &init_files.open_fds_init,    \
+        .close_on_exec_init = { { 0, } },               \
+        .open_fds_init  = { { 0, } },                   \
+        .fd_array       = { NULL, }                     \
+}
+
+#define INIT_KIOCTX(name, which_mm) \
+{                                                       \
+        .users          = ATOMIC_INIT(1),               \
+        .dead           = 0,                            \
+        .mm             = &which_mm,                    \
+        .user_id        = 0,                            \
+        .next           = NULL,                         \
+        .wait           = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait), \
+        .ctx_lock       = SPIN_LOCK_UNLOCKED,           \
+        .reqs_active    = 0U,                           \
+        .max_reqs       = ~0U,                          \
+}
+
+#define INIT_MM(name) \
+{                                                               \
+        .mm_rb          = RB_ROOT,                              \
+        .pgd            = swapper_pg_dir,                       \
+        .mm_users       = ATOMIC_INIT(2),                       \
+        .mm_count       = ATOMIC_INIT(1),                       \
+        .mmap_sem       = __RWSEM_INITIALIZER(name.mmap_sem),   \
+        .page_table_lock =  SPIN_LOCK_UNLOCKED,                 \
+        .mmlist         = LIST_HEAD_INIT(name.mmlist),          \
+        .cpu_vm_mask    = CPU_MASK_ALL,                         \
+        .default_kioctx = INIT_KIOCTX(name.default_kioctx, name),       \
+}
+
+#define INIT_SIGNALS(sig) {     \
+        .count          = ATOMIC_INIT(1),               \
+        .wait_chldexit  = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
+        .shared_pending = {                             \
+                .list = LIST_HEAD_INIT(sig.shared_pending.list),        \
+                .signal =  {{0}}}, \
+        .posix_timers    = LIST_HEAD_INIT(sig.posix_timers),            \
+        .cpu_timers     = INIT_CPU_TIMERS(sig.cpu_timers),              \
+        .rlim           = INIT_RLIMITS,                                 \
+}
+
+#define INIT_SIGHAND(sighand) {                                         \
+        .count          = ATOMIC_INIT(1),                               \
+        .action         = { { { .sa_handler = NULL, } }, },             \
+        .siglock        = SPIN_LOCK_UNLOCKED,                           \
+}
+
+extern struct group_info init_groups;
+
+/*
+ *  INIT_TASK is used to set up the first task table, touch at
+ * your own risk!. Base=0, limit=0x1fffff (=2MB)
+ */
+#define INIT_TASK(tsk)  \
+{                                                                       \
+        .state          = 0,                                            \
+        .thread_info    = &init_thread_info,                            \
+        .usage          = ATOMIC_INIT(2),                               \
+        .flags          = 0,                                            \
+        .lock_depth     = -1,                                           \
+        .prio           = MAX_PRIO-20,                                  \
+        .static_prio    = MAX_PRIO-20,                                  \
+        .policy         = SCHED_NORMAL,                                 \
+        .cpus_allowed   = CPU_MASK_ALL,                                 \
+        .mm             = NULL,                                         \
+        .active_mm      = &init_mm,                                     \
+        .run_list       = LIST_HEAD_INIT(tsk.run_list),                 \
+        .time_slice     = HZ,                                           \
+        .tasks          = LIST_HEAD_INIT(tsk.tasks),                    \
+        .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children),          \
+        .ptrace_list    = LIST_HEAD_INIT(tsk.ptrace_list),              \
+        .real_parent    = &tsk,                                         \
+        .parent         = &tsk,                                         \
+        .children       = LIST_HEAD_INIT(tsk.children),                 \
+        .sibling        = LIST_HEAD_INIT(tsk.sibling),                  \
+        .group_leader   = &tsk,                                         \
+        .group_info     = &init_groups,                                 \
+        .cap_effective  = CAP_INIT_EFF_SET,                             \
+        .cap_inheritable = CAP_INIT_INH_SET,                            \
+        .cap_permitted  = CAP_FULL_SET,                                 \
+        .keep_capabilities = 0,                                         \
+        .user           = INIT_USER,                                    \
+        .comm           = "swapper",                                    \
+        .thread         = INIT_THREAD,                                  \
+        .fs             = &init_fs,                                     \
+        .files          = &init_files,                                  \
+        .signal         = &init_signals,                                \
+        .sighand        = &init_sighand,                                \
+        .pending        = {                                             \
+                .list = LIST_HEAD_INIT(tsk.pending.list),               \
+                .signal = {{0}}},                                       \
+        .blocked        = {{0}},                                        \
+        .alloc_lock     = SPIN_LOCK_UNLOCKED,                           \
+        .proc_lock      = SPIN_LOCK_UNLOCKED,                           \
+        .switch_lock    = SPIN_LOCK_UNLOCKED,                           \
+        .journal_info   = NULL,                                         \
+        .cpu_timers     = INIT_CPU_TIMERS(tsk.cpu_timers),              \
+}
+
+
+#define INIT_CPU_TIMERS(cpu_timers)                                     \
+{                                                                       \
+        LIST_HEAD_INIT(cpu_timers[0]),                                  \
+        LIST_HEAD_INIT(cpu_timers[1]),                                  \
+        LIST_HEAD_INIT(cpu_timers[2]),                                  \
+}
+
+
+#endif
diff --git a/include/linux/initrd.h b/include/linux/initrd.h
new file mode 100644
index 000000000000..55289d261b4f
--- /dev/null
+++ b/include/linux/initrd.h
@@ -0,0 +1,20 @@
+
+#define INITRD_MINOR 250 /* shouldn't collide with /dev/ram* too soon ... */
+
+/* 1 = load ramdisk, 0 = don't load */
+extern int rd_doload;
+
+/* 1 = prompt for ramdisk, 0 = don't prompt */
+extern int rd_prompt;
+
+/* starting block # of image */
+extern int rd_image_start;
+
+/* 1 if it is not an error if initrd_start < memory_start */
+extern int initrd_below_start_ok;
+
+/* free_initrd_mem always gets called with the next two as arguments.. */
+extern unsigned long initrd_start, initrd_end;
+extern void free_initrd_mem(unsigned long, unsigned long);
+
+extern unsigned int real_root_dev;
diff --git a/include/linux/input.h b/include/linux/input.h
new file mode 100644
index 000000000000..b70df8fe60e6
--- /dev/null
+++ b/include/linux/input.h
@@ -0,0 +1,1016 @@
+#ifndef _INPUT_H
+#define _INPUT_H
+
+/*
+ * Copyright (c) 1999-2002 Vojtech Pavlik
+ *
+ * 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.
+ */
+
+#ifdef __KERNEL__
+#include <linux/time.h>
+#include <linux/list.h>
+#else
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <asm/types.h>
+#endif
+
+/*
+ * The event structure itself
+ */
+
+struct input_event {
+        struct timeval time;
+        __u16 type;
+        __u16 code;
+        __s32 value;
+};
+
+/*
+ * Protocol version.
+ */
+
+#define EV_VERSION              0x010000
+
+/*
+ * IOCTLs (0x00 - 0x7f)
+ */
+
+struct input_id {
+        __u16 bustype;
+        __u16 vendor;
+        __u16 product;
+        __u16 version;
+};
+
+struct input_absinfo {
+        __s32 value;
+        __s32 minimum;
+        __s32 maximum;
+        __s32 fuzz;
+        __s32 flat;
+};
+
+#define EVIOCGVERSION           _IOR('E', 0x01, int)                    /* get driver version */
+#define EVIOCGID                _IOR('E', 0x02, struct input_id)        /* get device ID */
+#define EVIOCGKEYCODE           _IOR('E', 0x04, int[2])                 /* get keycode */
+#define EVIOCSKEYCODE           _IOW('E', 0x04, int[2])                 /* set keycode */
+
+#define EVIOCGNAME(len)         _IOC(_IOC_READ, 'E', 0x06, len)         /* get device name */
+#define EVIOCGPHYS(len)         _IOC(_IOC_READ, 'E', 0x07, len)         /* get physical location */
+#define EVIOCGUNIQ(len)         _IOC(_IOC_READ, 'E', 0x08, len)         /* get unique identifier */
+
+#define EVIOCGKEY(len)          _IOC(_IOC_READ, 'E', 0x18, len)         /* get global keystate */
+#define EVIOCGLED(len)          _IOC(_IOC_READ, 'E', 0x19, len)         /* get all LEDs */
+#define EVIOCGSND(len)          _IOC(_IOC_READ, 'E', 0x1a, len)         /* get all sounds status */
+
+#define EVIOCGBIT(ev,len)       _IOC(_IOC_READ, 'E', 0x20 + ev, len)    /* get event bits */
+#define EVIOCGABS(abs)          _IOR('E', 0x40 + abs, struct input_absinfo)             /* get abs value/limits */
+#define EVIOCSABS(abs)          _IOW('E', 0xc0 + abs, struct input_absinfo)             /* set abs value/limits */
+
+#define EVIOCSFF                _IOC(_IOC_WRITE, 'E', 0x80, sizeof(struct ff_effect))   /* send a force effect to a force feedback device */
+#define EVIOCRMFF               _IOW('E', 0x81, int)                    /* Erase a force effect */
+#define EVIOCGEFFECTS           _IOR('E', 0x84, int)                    /* Report number of effects playable at the same time */
+
+#define EVIOCGRAB               _IOW('E', 0x90, int)                    /* Grab/Release device */
+
+/*
+ * Event types
+ */
+
+#define EV_SYN                  0x00
+#define EV_KEY                  0x01
+#define EV_REL                  0x02
+#define EV_ABS                  0x03
+#define EV_MSC                  0x04
+#define EV_LED                  0x11
+#define EV_SND                  0x12
+#define EV_REP                  0x14
+#define EV_FF                   0x15
+#define EV_PWR                  0x16
+#define EV_FF_STATUS            0x17
+#define EV_MAX                  0x1f
+
+/*
+ * Synchronization events.
+ */
+
+#define SYN_REPORT              0
+#define SYN_CONFIG              1
+
+/*
+ * Keys and buttons
+ */
+
+#define KEY_RESERVED            0
+#define KEY_ESC                 1
+#define KEY_1                   2
+#define KEY_2                   3
+#define KEY_3                   4
+#define KEY_4                   5
+#define KEY_5                   6
+#define KEY_6                   7
+#define KEY_7                   8
+#define KEY_8                   9
+#define KEY_9                   10
+#define KEY_0                   11
+#define KEY_MINUS               12
+#define KEY_EQUAL               13
+#define KEY_BACKSPACE           14
+#define KEY_TAB                 15
+#define KEY_Q                   16
+#define KEY_W                   17
+#define KEY_E                   18
+#define KEY_R                   19
+#define KEY_T                   20
+#define KEY_Y                   21
+#define KEY_U                   22
+#define KEY_I                   23
+#define KEY_O                   24
+#define KEY_P                   25
+#define KEY_LEFTBRACE           26
+#define KEY_RIGHTBRACE          27
+#define KEY_ENTER               28
+#define KEY_LEFTCTRL            29
+#define KEY_A                   30
+#define KEY_S                   31
+#define KEY_D                   32
+#define KEY_F                   33
+#define KEY_G                   34
+#define KEY_H                   35
+#define KEY_J                   36
+#define KEY_K                   37
+#define KEY_L                   38
+#define KEY_SEMICOLON           39
+#define KEY_APOSTROPHE          40
+#define KEY_GRAVE               41
+#define KEY_LEFTSHIFT           42
+#define KEY_BACKSLASH           43
+#define KEY_Z                   44
+#define KEY_X                   45
+#define KEY_C                   46
+#define KEY_V                   47
+#define KEY_B                   48
+#define KEY_N                   49
+#define KEY_M                   50
+#define KEY_COMMA               51
+#define KEY_DOT                 52
+#define KEY_SLASH               53
+#define KEY_RIGHTSHIFT          54
+#define KEY_KPASTERISK          55
+#define KEY_LEFTALT             56
+#define KEY_SPACE               57
+#define KEY_CAPSLOCK            58
+#define KEY_F1                  59
+#define KEY_F2                  60
+#define KEY_F3                  61
+#define KEY_F4                  62
+#define KEY_F5                  63
+#define KEY_F6                  64
+#define KEY_F7                  65
+#define KEY_F8                  66
+#define KEY_F9                  67
+#define KEY_F10                 68
+#define KEY_NUMLOCK             69
+#define KEY_SCROLLLOCK          70
+#define KEY_KP7                 71
+#define KEY_KP8                 72
+#define KEY_KP9                 73
+#define KEY_KPMINUS             74
+#define KEY_KP4                 75
+#define KEY_KP5                 76
+#define KEY_KP6                 77
+#define KEY_KPPLUS              78
+#define KEY_KP1                 79
+#define KEY_KP2                 80
+#define KEY_KP3                 81
+#define KEY_KP0                 82
+#define KEY_KPDOT               83
+
+#define KEY_ZENKAKUHANKAKU      85
+#define KEY_102ND               86
+#define KEY_F11                 87
+#define KEY_F12                 88
+#define KEY_RO                  89
+#define KEY_KATAKANA            90
+#define KEY_HIRAGANA            91
+#define KEY_HENKAN              92
+#define KEY_KATAKANAHIRAGANA    93
+#define KEY_MUHENKAN            94
+#define KEY_KPJPCOMMA           95
+#define KEY_KPENTER             96
+#define KEY_RIGHTCTRL           97
+#define KEY_KPSLASH             98
+#define KEY_SYSRQ               99
+#define KEY_RIGHTALT            100
+#define KEY_LINEFEED            101
+#define KEY_HOME                102
+#define KEY_UP                  103
+#define KEY_PAGEUP              104
+#define KEY_LEFT                105
+#define KEY_RIGHT               106
+#define KEY_END                 107
+#define KEY_DOWN                108
+#define KEY_PAGEDOWN            109
+#define KEY_INSERT              110
+#define KEY_DELETE              111
+#define KEY_MACRO               112
+#define KEY_MUTE                113
+#define KEY_VOLUMEDOWN          114
+#define KEY_VOLUMEUP            115
+#define KEY_POWER               116
+#define KEY_KPEQUAL             117
+#define KEY_KPPLUSMINUS         118
+#define KEY_PAUSE               119
+
+#define KEY_KPCOMMA             121
+#define KEY_HANGUEL             122
+#define KEY_HANJA               123
+#define KEY_YEN                 124
+#define KEY_LEFTMETA            125
+#define KEY_RIGHTMETA           126
+#define KEY_COMPOSE             127
+
+#define KEY_STOP                128
+#define KEY_AGAIN               129
+#define KEY_PROPS               130
+#define KEY_UNDO                131
+#define KEY_FRONT               132
+#define KEY_COPY                133
+#define KEY_OPEN                134
+#define KEY_PASTE               135
+#define KEY_FIND                136
+#define KEY_CUT                 137
+#define KEY_HELP                138
+#define KEY_MENU                139
+#define KEY_CALC                140
+#define KEY_SETUP               141
+#define KEY_SLEEP               142
+#define KEY_WAKEUP              143
+#define KEY_FILE                144
+#define KEY_SENDFILE            145
+#define KEY_DELETEFILE          146
+#define KEY_XFER                147
+#define KEY_PROG1               148
+#define KEY_PROG2               149
+#define KEY_WWW                 150
+#define KEY_MSDOS               151
+#define KEY_COFFEE              152
+#define KEY_DIRECTION           153
+#define KEY_CYCLEWINDOWS        154
+#define KEY_MAIL                155
+#define KEY_BOOKMARKS           156
+#define KEY_COMPUTER            157
+#define KEY_BACK                158
+#define KEY_FORWARD             159
+#define KEY_CLOSECD             160
+#define KEY_EJECTCD             161
+#define KEY_EJECTCLOSECD        162
+#define KEY_NEXTSONG            163
+#define KEY_PLAYPAUSE           164
+#define KEY_PREVIOUSSONG        165
+#define KEY_STOPCD              166
+#define KEY_RECORD              167
+#define KEY_REWIND              168
+#define KEY_PHONE               169
+#define KEY_ISO                 170
+#define KEY_CONFIG              171
+#define KEY_HOMEPAGE            172
+#define KEY_REFRESH             173
+#define KEY_EXIT                174
+#define KEY_MOVE                175
+#define KEY_EDIT                176
+#define KEY_SCROLLUP            177
+#define KEY_SCROLLDOWN          178
+#define KEY_KPLEFTPAREN         179
+#define KEY_KPRIGHTPAREN        180
+
+#define KEY_F13                 183
+#define KEY_F14                 184
+#define KEY_F15                 185
+#define KEY_F16                 186
+#define KEY_F17                 187
+#define KEY_F18                 188
+#define KEY_F19                 189
+#define KEY_F20                 190
+#define KEY_F21                 191
+#define KEY_F22                 192
+#define KEY_F23                 193
+#define KEY_F24                 194
+
+#define KEY_PLAYCD              200
+#define KEY_PAUSECD             201
+#define KEY_PROG3               202
+#define KEY_PROG4               203
+#define KEY_SUSPEND             205
+#define KEY_CLOSE               206
+#define KEY_PLAY                207
+#define KEY_FASTFORWARD         208
+#define KEY_BASSBOOST           209
+#define KEY_PRINT               210
+#define KEY_HP                  211
+#define KEY_CAMERA              212
+#define KEY_SOUND               213
+#define KEY_QUESTION            214
+#define KEY_EMAIL               215
+#define KEY_CHAT                216
+#define KEY_SEARCH              217
+#define KEY_CONNECT             218
+#define KEY_FINANCE             219
+#define KEY_SPORT               220
+#define KEY_SHOP                221
+#define KEY_ALTERASE            222
+#define KEY_CANCEL              223
+#define KEY_BRIGHTNESSDOWN      224
+#define KEY_BRIGHTNESSUP        225
+#define KEY_MEDIA               226
+
+#define KEY_UNKNOWN             240
+
+#define BTN_MISC                0x100
+#define BTN_0                   0x100
+#define BTN_1                   0x101
+#define BTN_2                   0x102
+#define BTN_3                   0x103
+#define BTN_4                   0x104
+#define BTN_5                   0x105
+#define BTN_6                   0x106
+#define BTN_7                   0x107
+#define BTN_8                   0x108
+#define BTN_9                   0x109
+
+#define BTN_MOUSE               0x110
+#define BTN_LEFT                0x110
+#define BTN_RIGHT               0x111
+#define BTN_MIDDLE              0x112
+#define BTN_SIDE                0x113
+#define BTN_EXTRA               0x114
+#define BTN_FORWARD             0x115
+#define BTN_BACK                0x116
+#define BTN_TASK                0x117
+
+#define BTN_JOYSTICK            0x120
+#define BTN_TRIGGER             0x120
+#define BTN_THUMB               0x121
+#define BTN_THUMB2              0x122
+#define BTN_TOP                 0x123
+#define BTN_TOP2                0x124
+#define BTN_PINKIE              0x125
+#define BTN_BASE                0x126
+#define BTN_BASE2               0x127
+#define BTN_BASE3               0x128
+#define BTN_BASE4               0x129
+#define BTN_BASE5               0x12a
+#define BTN_BASE6               0x12b
+#define BTN_DEAD                0x12f
+
+#define BTN_GAMEPAD             0x130
+#define BTN_A                   0x130
+#define BTN_B                   0x131
+#define BTN_C                   0x132
+#define BTN_X                   0x133
+#define BTN_Y                   0x134
+#define BTN_Z                   0x135
+#define BTN_TL                  0x136
+#define BTN_TR                  0x137
+#define BTN_TL2                 0x138
+#define BTN_TR2                 0x139
+#define BTN_SELECT              0x13a
+#define BTN_START               0x13b
+#define BTN_MODE                0x13c
+#define BTN_THUMBL              0x13d
+#define BTN_THUMBR              0x13e
+
+#define BTN_DIGI                0x140
+#define BTN_TOOL_PEN            0x140
+#define BTN_TOOL_RUBBER         0x141
+#define BTN_TOOL_BRUSH          0x142
+#define BTN_TOOL_PENCIL         0x143
+#define BTN_TOOL_AIRBRUSH       0x144
+#define BTN_TOOL_FINGER         0x145
+#define BTN_TOOL_MOUSE          0x146
+#define BTN_TOOL_LENS           0x147
+#define BTN_TOUCH               0x14a
+#define BTN_STYLUS              0x14b
+#define BTN_STYLUS2             0x14c
+#define BTN_TOOL_DOUBLETAP      0x14d
+#define BTN_TOOL_TRIPLETAP      0x14e
+
+#define BTN_WHEEL               0x150
+#define BTN_GEAR_DOWN           0x150
+#define BTN_GEAR_UP             0x151
+
+#define KEY_OK                  0x160
+#define KEY_SELECT              0x161
+#define KEY_GOTO                0x162
+#define KEY_CLEAR               0x163
+#define KEY_POWER2              0x164
+#define KEY_OPTION              0x165
+#define KEY_INFO                0x166
+#define KEY_TIME                0x167
+#define KEY_VENDOR              0x168
+#define KEY_ARCHIVE             0x169
+#define KEY_PROGRAM             0x16a
+#define KEY_CHANNEL             0x16b
+#define KEY_FAVORITES           0x16c
+#define KEY_EPG                 0x16d
+#define KEY_PVR                 0x16e
+#define KEY_MHP                 0x16f
+#define KEY_LANGUAGE            0x170
+#define KEY_TITLE               0x171
+#define KEY_SUBTITLE            0x172
+#define KEY_ANGLE               0x173
+#define KEY_ZOOM                0x174
+#define KEY_MODE                0x175
+#define KEY_KEYBOARD            0x176
+#define KEY_SCREEN              0x177
+#define KEY_PC                  0x178
+#define KEY_TV                  0x179
+#define KEY_TV2                 0x17a
+#define KEY_VCR                 0x17b
+#define KEY_VCR2                0x17c
+#define KEY_SAT                 0x17d
+#define KEY_SAT2                0x17e
+#define KEY_CD                  0x17f
+#define KEY_TAPE                0x180
+#define KEY_RADIO               0x181
+#define KEY_TUNER               0x182
+#define KEY_PLAYER              0x183
+#define KEY_TEXT                0x184
+#define KEY_DVD                 0x185
+#define KEY_AUX                 0x186
+#define KEY_MP3                 0x187
+#define KEY_AUDIO               0x188
+#define KEY_VIDEO               0x189
+#define KEY_DIRECTORY           0x18a
+#define KEY_LIST                0x18b
+#define KEY_MEMO                0x18c
+#define KEY_CALENDAR            0x18d
+#define KEY_RED                 0x18e
+#define KEY_GREEN               0x18f
+#define KEY_YELLOW              0x190
+#define KEY_BLUE                0x191
+#define KEY_CHANNELUP           0x192
+#define KEY_CHANNELDOWN         0x193
+#define KEY_FIRST               0x194
+#define KEY_LAST                0x195
+#define KEY_AB                  0x196
+#define KEY_NEXT                0x197
+#define KEY_RESTART             0x198
+#define KEY_SLOW                0x199
+#define KEY_SHUFFLE             0x19a
+#define KEY_BREAK               0x19b
+#define KEY_PREVIOUS            0x19c
+#define KEY_DIGITS              0x19d
+#define KEY_TEEN                0x19e
+#define KEY_TWEN                0x19f
+
+#define KEY_DEL_EOL             0x1c0
+#define KEY_DEL_EOS             0x1c1
+#define KEY_INS_LINE            0x1c2
+#define KEY_DEL_LINE            0x1c3
+
+#define KEY_FN                  0x1d0
+#define KEY_FN_ESC              0x1d1
+#define KEY_FN_F1               0x1d2
+#define KEY_FN_F2               0x1d3
+#define KEY_FN_F3               0x1d4
+#define KEY_FN_F4               0x1d5
+#define KEY_FN_F5               0x1d6
+#define KEY_FN_F6               0x1d7
+#define KEY_FN_F7               0x1d8
+#define KEY_FN_F8               0x1d9
+#define KEY_FN_F9               0x1da
+#define KEY_FN_F10              0x1db
+#define KEY_FN_F11              0x1dc
+#define KEY_FN_F12              0x1dd
+#define KEY_FN_1                0x1de
+#define KEY_FN_2                0x1df
+#define KEY_FN_D                0x1e0
+#define KEY_FN_E                0x1e1
+#define KEY_FN_F                0x1e2
+#define KEY_FN_S                0x1e3
+#define KEY_FN_B                0x1e4
+
+#define KEY_MAX                 0x1ff
+
+/*
+ * Relative axes
+ */
+
+#define REL_X                   0x00
+#define REL_Y                   0x01
+#define REL_Z                   0x02
+#define REL_RX                  0x03
+#define REL_RY                  0x04
+#define REL_RZ                  0x05
+#define REL_HWHEEL              0x06
+#define REL_DIAL                0x07
+#define REL_WHEEL               0x08
+#define REL_MISC                0x09
+#define REL_MAX                 0x0f
+
+/*
+ * Absolute axes
+ */
+
+#define ABS_X                   0x00
+#define ABS_Y                   0x01
+#define ABS_Z                   0x02
+#define ABS_RX                  0x03
+#define ABS_RY                  0x04
+#define ABS_RZ                  0x05
+#define ABS_THROTTLE            0x06
+#define ABS_RUDDER              0x07
+#define ABS_WHEEL               0x08
+#define ABS_GAS                 0x09
+#define ABS_BRAKE               0x0a
+#define ABS_HAT0X               0x10
+#define ABS_HAT0Y               0x11
+#define ABS_HAT1X               0x12
+#define ABS_HAT1Y               0x13
+#define ABS_HAT2X               0x14
+#define ABS_HAT2Y               0x15
+#define ABS_HAT3X               0x16
+#define ABS_HAT3Y               0x17
+#define ABS_PRESSURE            0x18
+#define ABS_DISTANCE            0x19
+#define ABS_TILT_X              0x1a
+#define ABS_TILT_Y              0x1b
+#define ABS_TOOL_WIDTH          0x1c
+#define ABS_VOLUME              0x20
+#define ABS_MISC                0x28
+#define ABS_MAX                 0x3f
+
+/*
+ * Misc events
+ */
+
+#define MSC_SERIAL              0x00
+#define MSC_PULSELED            0x01
+#define MSC_GESTURE             0x02
+#define MSC_RAW                 0x03
+#define MSC_SCAN                0x04
+#define MSC_MAX                 0x07
+
+/*
+ * LEDs
+ */
+
+#define LED_NUML                0x00
+#define LED_CAPSL               0x01
+#define LED_SCROLLL             0x02
+#define LED_COMPOSE             0x03
+#define LED_KANA                0x04
+#define LED_SLEEP               0x05
+#define LED_SUSPEND             0x06
+#define LED_MUTE                0x07
+#define LED_MISC                0x08
+#define LED_MAIL                0x09
+#define LED_CHARGING            0x0a
+#define LED_MAX                 0x0f
+
+/*
+ * Autorepeat values
+ */
+
+#define REP_DELAY               0x00
+#define REP_PERIOD              0x01
+#define REP_MAX                 0x01
+
+/*
+ * Sounds
+ */
+
+#define SND_CLICK               0x00
+#define SND_BELL                0x01
+#define SND_TONE                0x02
+#define SND_MAX                 0x07
+
+/*
+ * IDs.
+ */
+
+#define ID_BUS                  0
+#define ID_VENDOR               1
+#define ID_PRODUCT              2
+#define ID_VERSION              3
+
+#define BUS_PCI                 0x01
+#define BUS_ISAPNP              0x02
+#define BUS_USB                 0x03
+#define BUS_HIL                 0x04
+#define BUS_BLUETOOTH           0x05
+
+#define BUS_ISA                 0x10
+#define BUS_I8042               0x11
+#define BUS_XTKBD               0x12
+#define BUS_RS232               0x13
+#define BUS_GAMEPORT            0x14
+#define BUS_PARPORT             0x15
+#define BUS_AMIGA               0x16
+#define BUS_ADB                 0x17
+#define BUS_I2C                 0x18
+#define BUS_HOST                0x19
+
+/*
+ * Values describing the status of an effect
+ */
+#define FF_STATUS_STOPPED       0x00
+#define FF_STATUS_PLAYING       0x01
+#define FF_STATUS_MAX           0x01
+
+/*
+ * Structures used in ioctls to upload effects to a device
+ * The first structures are not passed directly by using ioctls.
+ * They are sub-structures of the actually sent structure (called ff_effect)
+ */
+
+struct ff_replay {
+        __u16 length; /* Duration of an effect in ms. All other times are also expressed in ms */
+        __u16 delay;  /* Time to wait before to start playing an effect */
+};
+
+struct ff_trigger {
+        __u16 button;   /* Number of button triggering an effect */
+        __u16 interval; /* Time to wait before an effect can be re-triggered (ms) */
+};
+
+struct ff_envelope {
+        __u16 attack_length;    /* Duration of attack (ms) */
+        __u16 attack_level;     /* Level at beginning of attack */
+        __u16 fade_length;      /* Duration of fade (ms) */
+        __u16 fade_level;       /* Level at end of fade */
+};
+
+/* FF_CONSTANT */
+struct ff_constant_effect {
+        __s16 level;        /* Strength of effect. Negative values are OK */
+        struct ff_envelope envelope;
+};
+
+/* FF_RAMP */
+struct ff_ramp_effect {
+        __s16 start_level;
+        __s16 end_level;
+        struct ff_envelope envelope;
+};
+
+/* FF_SPRING of FF_FRICTION */
+struct ff_condition_effect {
+        __u16 right_saturation; /* Max level when joystick is on the right */
+        __u16 left_saturation;  /* Max level when joystick in on the left */
+
+        __s16 right_coeff;      /* Indicates how fast the force grows when the
+                                   joystick moves to the right */
+        __s16 left_coeff;       /* Same for left side */
+
+        __u16 deadband; /* Size of area where no force is produced */
+        __s16 center;   /* Position of dead zone */
+
+};
+
+/* FF_PERIODIC */
+struct ff_periodic_effect {
+        __u16 waveform; /* Kind of wave (sine, square...) */
+        __u16 period;   /* in ms */
+        __s16 magnitude;        /* Peak value */
+        __s16 offset;   /* Mean value of wave (roughly) */
+        __u16 phase;            /* 'Horizontal' shift */
+
+        struct ff_envelope envelope;
+
+/* Only used if waveform == FF_CUSTOM */
+        __u32 custom_len;       /* Number of samples */
+        __s16 *custom_data;     /* Buffer of samples */
+/* Note: the data pointed by custom_data is copied by the driver. You can
+ * therefore dispose of the memory after the upload/update */
+};
+
+/* FF_RUMBLE */
+/* Some rumble pads have two motors of different weight.
+   strong_magnitude represents the magnitude of the vibration generated
+   by the heavy motor.
+*/
+struct ff_rumble_effect {
+        __u16 strong_magnitude;  /* Magnitude of the heavy motor */
+        __u16 weak_magnitude;    /* Magnitude of the light one */
+};
+
+/*
+ * Structure sent through ioctl from the application to the driver
+ */
+struct ff_effect {
+        __u16 type;
+/* Following field denotes the unique id assigned to an effect.
+ * If user sets if to -1, a new effect is created, and its id is returned in the same field
+ * Else, the user sets it to the effect id it wants to update.
+ */
+        __s16 id;
+
+        __u16 direction;        /* Direction. 0 deg -> 0x0000 (down)
+                                             90 deg -> 0x4000 (left)
+                                            180 deg -> 0x8000 (up)
+                                            270 deg -> 0xC000 (right)
+                                */
+
+        struct ff_trigger trigger;
+        struct ff_replay replay;
+
+        union {
+                struct ff_constant_effect constant;
+                struct ff_ramp_effect ramp;
+                struct ff_periodic_effect periodic;
+                struct ff_condition_effect condition[2]; /* One for each axis */
+                struct ff_rumble_effect rumble;
+        } u;
+};
+
+/*
+ * Force feedback effect types
+ */
+
+#define FF_RUMBLE       0x50
+#define FF_PERIODIC     0x51
+#define FF_CONSTANT     0x52
+#define FF_SPRING       0x53
+#define FF_FRICTION     0x54
+#define FF_DAMPER       0x55
+#define FF_INERTIA      0x56
+#define FF_RAMP         0x57
+
+/*
+ * Force feedback periodic effect types
+ */
+
+#define FF_SQUARE       0x58
+#define FF_TRIANGLE     0x59
+#define FF_SINE         0x5a
+#define FF_SAW_UP       0x5b
+#define FF_SAW_DOWN     0x5c
+#define FF_CUSTOM       0x5d
+
+/*
+ * Set ff device properties
+ */
+
+#define FF_GAIN         0x60
+#define FF_AUTOCENTER   0x61
+
+#define FF_MAX          0x7f
+
+#ifdef __KERNEL__
+
+/*
+ * In-kernel definitions.
+ */
+
+#include <linux/fs.h>
+#include <linux/timer.h>
+
+#define NBITS(x) (((x)/BITS_PER_LONG)+1)
+#define BIT(x)  (1UL<<((x)%BITS_PER_LONG))
+#define LONG(x) ((x)/BITS_PER_LONG)
+
+#define INPUT_KEYCODE(dev, scancode) ((dev->keycodesize == 1) ? ((u8*)dev->keycode)[scancode] : \
+        ((dev->keycodesize == 2) ? ((u16*)dev->keycode)[scancode] : (((u32*)dev->keycode)[scancode])))
+
+#define SET_INPUT_KEYCODE(dev, scancode, val)                   \
+                ({      unsigned __old;                         \
+                switch (dev->keycodesize) {                     \
+                        case 1: {                               \
+                                u8 *k = (u8 *)dev->keycode;     \
+                                __old = k[scancode];            \
+                                k[scancode] = val;              \
+                                break;                          \
+                        }                                       \
+                        case 2: {                               \
+                                u16 *k = (u16 *)dev->keycode;   \
+                                __old = k[scancode];            \
+                                k[scancode] = val;              \
+                                break;                          \
+                        }                                       \
+                        default: {                              \
+                                u32 *k = (u32 *)dev->keycode;   \
+                                __old = k[scancode];            \
+                                k[scancode] = val;              \
+                                break;                          \
+                        }                                       \
+                }                                               \
+                __old; })
+
+struct input_dev {
+
+        void *private;
+
+        char *name;
+        char *phys;
+        char *uniq;
+        struct input_id id;
+
+        unsigned long evbit[NBITS(EV_MAX)];
+        unsigned long keybit[NBITS(KEY_MAX)];
+        unsigned long relbit[NBITS(REL_MAX)];
+        unsigned long absbit[NBITS(ABS_MAX)];
+        unsigned long mscbit[NBITS(MSC_MAX)];
+        unsigned long ledbit[NBITS(LED_MAX)];
+        unsigned long sndbit[NBITS(SND_MAX)];
+        unsigned long ffbit[NBITS(FF_MAX)];
+        int ff_effects_max;
+
+        unsigned int keycodemax;
+        unsigned int keycodesize;
+        void *keycode;
+
+        unsigned int repeat_key;
+        struct timer_list timer;
+
+        struct pt_regs *regs;
+        int state;
+
+        int sync;
+
+        int abs[ABS_MAX + 1];
+        int rep[REP_MAX + 1];
+
+        unsigned long key[NBITS(KEY_MAX)];
+        unsigned long led[NBITS(LED_MAX)];
+        unsigned long snd[NBITS(SND_MAX)];
+
+        int absmax[ABS_MAX + 1];
+        int absmin[ABS_MAX + 1];
+        int absfuzz[ABS_MAX + 1];
+        int absflat[ABS_MAX + 1];
+
+        int (*open)(struct input_dev *dev);
+        void (*close)(struct input_dev *dev);
+        int (*accept)(struct input_dev *dev, struct file *file);
+        int (*flush)(struct input_dev *dev, struct file *file);
+        int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
+        int (*upload_effect)(struct input_dev *dev, struct ff_effect *effect);
+        int (*erase_effect)(struct input_dev *dev, int effect_id);
+
+        struct input_handle *grab;
+        struct device *dev;
+
+        struct list_head        h_list;
+        struct list_head        node;
+};
+
+/*
+ * Structure for hotplug & device<->driver matching.
+ */
+
+#define INPUT_DEVICE_ID_MATCH_BUS       1
+#define INPUT_DEVICE_ID_MATCH_VENDOR    2
+#define INPUT_DEVICE_ID_MATCH_PRODUCT   4
+#define INPUT_DEVICE_ID_MATCH_VERSION   8
+
+#define INPUT_DEVICE_ID_MATCH_EVBIT     0x010
+#define INPUT_DEVICE_ID_MATCH_KEYBIT    0x020
+#define INPUT_DEVICE_ID_MATCH_RELBIT    0x040
+#define INPUT_DEVICE_ID_MATCH_ABSBIT    0x080
+#define INPUT_DEVICE_ID_MATCH_MSCIT     0x100
+#define INPUT_DEVICE_ID_MATCH_LEDBIT    0x200
+#define INPUT_DEVICE_ID_MATCH_SNDBIT    0x400
+#define INPUT_DEVICE_ID_MATCH_FFBIT     0x800
+
+#define INPUT_DEVICE_ID_MATCH_DEVICE\
+        (INPUT_DEVICE_ID_MATCH_BUS | INPUT_DEVICE_ID_MATCH_VENDOR | INPUT_DEVICE_ID_MATCH_PRODUCT)
+#define INPUT_DEVICE_ID_MATCH_DEVICE_AND_VERSION\
+        (INPUT_DEVICE_ID_MATCH_DEVICE | INPUT_DEVICE_ID_MATCH_VERSION)
+
+struct input_device_id {
+
+        unsigned long flags;
+
+        struct input_id id;
+
+        unsigned long evbit[NBITS(EV_MAX)];
+        unsigned long keybit[NBITS(KEY_MAX)];
+        unsigned long relbit[NBITS(REL_MAX)];
+        unsigned long absbit[NBITS(ABS_MAX)];
+        unsigned long mscbit[NBITS(MSC_MAX)];
+        unsigned long ledbit[NBITS(LED_MAX)];
+        unsigned long sndbit[NBITS(SND_MAX)];
+        unsigned long ffbit[NBITS(FF_MAX)];
+
+        unsigned long driver_info;
+};
+
+struct input_handle;
+
+struct input_handler {
+
+        void *private;
+
+        void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
+        struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, struct input_device_id *id);
+        void (*disconnect)(struct input_handle *handle);
+
+        struct file_operations *fops;
+        int minor;
+        char *name;
+
+        struct input_device_id *id_table;
+        struct input_device_id *blacklist;
+
+        struct list_head        h_list;
+        struct list_head        node;
+};
+
+struct input_handle {
+
+        void *private;
+
+        int open;
+        char *name;
+
+        struct input_dev *dev;
+        struct input_handler *handler;
+
+        struct list_head        d_node;
+        struct list_head        h_node;
+};
+
+#define to_dev(n) container_of(n,struct input_dev,node)
+#define to_handler(n) container_of(n,struct input_handler,node);
+#define to_handle(n) container_of(n,struct input_handle,d_node)
+#define to_handle_h(n) container_of(n,struct input_handle,h_node)
+
+static inline void init_input_dev(struct input_dev *dev)
+{
+        INIT_LIST_HEAD(&dev->h_list);
+        INIT_LIST_HEAD(&dev->node);
+}
+
+void input_register_device(struct input_dev *);
+void input_unregister_device(struct input_dev *);
+
+void input_register_handler(struct input_handler *);
+void input_unregister_handler(struct input_handler *);
+
+int input_grab_device(struct input_handle *);
+void input_release_device(struct input_handle *);
+
+int input_open_device(struct input_handle *);
+void input_close_device(struct input_handle *);
+
+int input_accept_process(struct input_handle *handle, struct file *file);
+int input_flush_device(struct input_handle* handle, struct file* file);
+
+void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);
+
+static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
+{
+        input_event(dev, EV_KEY, code, !!value);
+}
+
+static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
+{
+        input_event(dev, EV_REL, code, value);
+}
+
+static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
+{
+        input_event(dev, EV_ABS, code, value);
+}
+
+static inline void input_report_ff(struct input_dev *dev, unsigned int code, int value)
+{
+        input_event(dev, EV_FF, code, value);
+}
+
+static inline void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)
+{
+        input_event(dev, EV_FF_STATUS, code, value);
+}
+
+static inline void input_regs(struct input_dev *dev, struct pt_regs *regs)
+{
+        dev->regs = regs;
+}
+
+static inline void input_sync(struct input_dev *dev)
+{
+        input_event(dev, EV_SYN, SYN_REPORT, 0);
+        dev->regs = NULL;
+}
+
+static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
+{
+        dev->absmin[axis] = min;
+        dev->absmax[axis] = max;
+        dev->absfuzz[axis] = fuzz;
+        dev->absflat[axis] = flat;
+
+        dev->absbit[LONG(axis)] |= BIT(axis);
+}
+
+extern struct class_simple *input_class;
+
+#endif
+#endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
new file mode 100644
index 000000000000..d99e7aeb7d33
--- /dev/null
+++ b/include/linux/interrupt.h
@@ -0,0 +1,289 @@
+/* interrupt.h */
+#ifndef _LINUX_INTERRUPT_H
+#define _LINUX_INTERRUPT_H
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/linkage.h>
+#include <linux/bitops.h>
+#include <linux/preempt.h>
+#include <linux/cpumask.h>
+#include <linux/hardirq.h>
+#include <asm/atomic.h>
+#include <asm/ptrace.h>
+#include <asm/system.h>
+
+/*
+ * For 2.4.x compatibility, 2.4.x can use
+ *
+ *      typedef void irqreturn_t;
+ *      #define IRQ_NONE
+ *      #define IRQ_HANDLED
+ *      #define IRQ_RETVAL(x)
+ *
+ * To mix old-style and new-style irq handler returns.
+ *
+ * IRQ_NONE means we didn't handle it.
+ * IRQ_HANDLED means that we did have a valid interrupt and handled it.
+ * IRQ_RETVAL(x) selects on the two depending on x being non-zero (for handled)
+ */
+typedef int irqreturn_t;
+
+#define IRQ_NONE        (0)
+#define IRQ_HANDLED     (1)
+#define IRQ_RETVAL(x)   ((x) != 0)
+
+struct irqaction {
+        irqreturn_t (*handler)(int, void *, struct pt_regs *);
+        unsigned long flags;
+        cpumask_t mask;
+        const char *name;
+        void *dev_id;
+        struct irqaction *next;
+        int irq;
+        struct proc_dir_entry *dir;
+};
+
+extern irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs);
+extern int request_irq(unsigned int,
+                       irqreturn_t (*handler)(int, void *, struct pt_regs *),
+                       unsigned long, const char *, void *);
+extern void free_irq(unsigned int, void *);
+
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+extern void disable_irq_nosync(unsigned int irq);
+extern void disable_irq(unsigned int irq);
+extern void enable_irq(unsigned int irq);
+#endif
+
+/*
+ * Temporary defines for UP kernels, until all code gets fixed.
+ */
+#ifndef CONFIG_SMP
+static inline void __deprecated cli(void)
+{
+        local_irq_disable();
+}
+static inline void __deprecated sti(void)
+{
+        local_irq_enable();
+}
+static inline void __deprecated save_flags(unsigned long *x)
+{
+        local_save_flags(*x);
+}
+#define save_flags(x) save_flags(&x);
+static inline void __deprecated restore_flags(unsigned long x)
+{
+        local_irq_restore(x);
+}
+
+static inline void __deprecated save_and_cli(unsigned long *x)
+{
+        local_irq_save(*x);
+}
+#define save_and_cli(x) save_and_cli(&x)
+#endif /* CONFIG_SMP */
+
+/* SoftIRQ primitives.  */
+#define local_bh_disable() \
+                do { add_preempt_count(SOFTIRQ_OFFSET); barrier(); } while (0)
+#define __local_bh_enable() \
+                do { barrier(); sub_preempt_count(SOFTIRQ_OFFSET); } while (0)
+
+extern void local_bh_enable(void);
+
+/* PLEASE, avoid to allocate new softirqs, if you need not _really_ high
+   frequency threaded job scheduling. For almost all the purposes
+   tasklets are more than enough. F.e. all serial device BHs et
+   al. should be converted to tasklets, not to softirqs.
+ */
+
+enum
+{
+        HI_SOFTIRQ=0,
+        TIMER_SOFTIRQ,
+        NET_TX_SOFTIRQ,
+        NET_RX_SOFTIRQ,
+        SCSI_SOFTIRQ,
+        TASKLET_SOFTIRQ
+};
+
+/* softirq mask and active fields moved to irq_cpustat_t in
+ * asm/hardirq.h to get better cache usage.  KAO
+ */
+
+struct softirq_action
+{
+        void    (*action)(struct softirq_action *);
+        void    *data;
+};
+
+asmlinkage void do_softirq(void);
+extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
+extern void softirq_init(void);
+#define __raise_softirq_irqoff(nr) do { local_softirq_pending() |= 1UL << (nr); } while (0)
+extern void FASTCALL(raise_softirq_irqoff(unsigned int nr));
+extern void FASTCALL(raise_softirq(unsigned int nr));
+
+
+/* Tasklets --- multithreaded analogue of BHs.
+
+   Main feature differing them of generic softirqs: tasklet
+   is running only on one CPU simultaneously.
+
+   Main feature differing them of BHs: different tasklets
+   may be run simultaneously on different CPUs.
+
+   Properties:
+   * If tasklet_schedule() is called, then tasklet is guaranteed
+     to be executed on some cpu at least once after this.
+   * If the tasklet is already scheduled, but its excecution is still not
+     started, it will be executed only once.
+   * If this tasklet is already running on another CPU (or schedule is called
+     from tasklet itself), it is rescheduled for later.
+   * Tasklet is strictly serialized wrt itself, but not
+     wrt another tasklets. If client needs some intertask synchronization,
+     he makes it with spinlocks.
+ */
+
+struct tasklet_struct
+{
+        struct tasklet_struct *next;
+        unsigned long state;
+        atomic_t count;
+        void (*func)(unsigned long);
+        unsigned long data;
+};
+
+#define DECLARE_TASKLET(name, func, data) \
+struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
+
+#define DECLARE_TASKLET_DISABLED(name, func, data) \
+struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }
+
+
+enum
+{
+        TASKLET_STATE_SCHED,    /* Tasklet is scheduled for execution */
+        TASKLET_STATE_RUN       /* Tasklet is running (SMP only) */
+};
+
+#ifdef CONFIG_SMP
+static inline int tasklet_trylock(struct tasklet_struct *t)
+{
+        return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
+}
+
+static inline void tasklet_unlock(struct tasklet_struct *t)
+{
+        smp_mb__before_clear_bit(); 
+        clear_bit(TASKLET_STATE_RUN, &(t)->state);
+}
+
+static inline void tasklet_unlock_wait(struct tasklet_struct *t)
+{
+        while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
+}
+#else
+#define tasklet_trylock(t) 1
+#define tasklet_unlock_wait(t) do { } while (0)
+#define tasklet_unlock(t) do { } while (0)
+#endif
+
+extern void FASTCALL(__tasklet_schedule(struct tasklet_struct *t));
+
+static inline void tasklet_schedule(struct tasklet_struct *t)
+{
+        if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
+                __tasklet_schedule(t);
+}
+
+extern void FASTCALL(__tasklet_hi_schedule(struct tasklet_struct *t));
+
+static inline void tasklet_hi_schedule(struct tasklet_struct *t)
+{
+        if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
+                __tasklet_hi_schedule(t);
+}
+
+
+static inline void tasklet_disable_nosync(struct tasklet_struct *t)
+{
+        atomic_inc(&t->count);
+        smp_mb__after_atomic_inc();
+}
+
+static inline void tasklet_disable(struct tasklet_struct *t)
+{
+        tasklet_disable_nosync(t);
+        tasklet_unlock_wait(t);
+        smp_mb();
+}
+
+static inline void tasklet_enable(struct tasklet_struct *t)
+{
+        smp_mb__before_atomic_dec();
+        atomic_dec(&t->count);
+}
+
+static inline void tasklet_hi_enable(struct tasklet_struct *t)
+{
+        smp_mb__before_atomic_dec();
+        atomic_dec(&t->count);
+}
+
+extern void tasklet_kill(struct tasklet_struct *t);
+extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
+extern void tasklet_init(struct tasklet_struct *t,
+                         void (*func)(unsigned long), unsigned long data);
+
+/*
+ * Autoprobing for irqs:
+ *
+ * probe_irq_on() and probe_irq_off() provide robust primitives
+ * for accurate IRQ probing during kernel initialization.  They are
+ * reasonably simple to use, are not "fooled" by spurious interrupts,
+ * and, unlike other attempts at IRQ probing, they do not get hung on
+ * stuck interrupts (such as unused PS2 mouse interfaces on ASUS boards).
+ *
+ * For reasonably foolproof probing, use them as follows:
+ *
+ * 1. clear and/or mask the device's internal interrupt.
+ * 2. sti();
+ * 3. irqs = probe_irq_on();      // "take over" all unassigned idle IRQs
+ * 4. enable the device and cause it to trigger an interrupt.
+ * 5. wait for the device to interrupt, using non-intrusive polling or a delay.
+ * 6. irq = probe_irq_off(irqs);  // get IRQ number, 0=none, negative=multiple
+ * 7. service the device to clear its pending interrupt.
+ * 8. loop again if paranoia is required.
+ *
+ * probe_irq_on() returns a mask of allocated irq's.
+ *
+ * probe_irq_off() takes the mask as a parameter,
+ * and returns the irq number which occurred,
+ * or zero if none occurred, or a negative irq number
+ * if more than one irq occurred.
+ */
+
+#if defined(CONFIG_GENERIC_HARDIRQS) && !defined(CONFIG_GENERIC_IRQ_PROBE) 
+static inline unsigned long probe_irq_on(void)
+{
+        return 0;
+}
+static inline int probe_irq_off(unsigned long val)
+{
+        return 0;
+}
+static inline unsigned int probe_irq_mask(unsigned long val)
+{
+        return 0;
+}
+#else
+extern unsigned long probe_irq_on(void);        /* returns 0 on failure */
+extern int probe_irq_off(unsigned long);        /* returns 0 or negative on failure */
+extern unsigned int probe_irq_mask(unsigned long);      /* returns mask of ISA interrupts */
+#endif
+
+#endif
diff --git a/include/linux/ioc4_common.h b/include/linux/ioc4_common.h
new file mode 100644
index 000000000000..b03bcc46df55
--- /dev/null
+++ b/include/linux/ioc4_common.h
@@ -0,0 +1,21 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2005 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+#ifndef _LINUX_IOC4_COMMON_H
+#define _LINUX_IOC4_COMMON_H
+
+/* prototypes */
+
+int ioc4_serial_init(void);
+
+int ioc4_serial_attach_one(struct pci_dev *pdev, const struct
+                                pci_device_id *pci_id);
+int ioc4_ide_attach_one(struct pci_dev *pdev, const struct
+                                pci_device_id *pci_id);
+
+#endif  /* _LINUX_IOC4_COMMON_H */
diff --git a/include/linux/ioctl.h b/include/linux/ioctl.h
new file mode 100644
index 000000000000..aa91eb3951ef
--- /dev/null
+++ b/include/linux/ioctl.h
@@ -0,0 +1,7 @@
+#ifndef _LINUX_IOCTL_H
+#define _LINUX_IOCTL_H
+
+#include <asm/ioctl.h>
+
+#endif /* _LINUX_IOCTL_H */
+
diff --git a/include/linux/ioctl32.h b/include/linux/ioctl32.h
new file mode 100644
index 000000000000..e1a641819428
--- /dev/null
+++ b/include/linux/ioctl32.h
@@ -0,0 +1,37 @@
+#ifndef IOCTL32_H
+#define IOCTL32_H 1
+
+struct file;
+
+typedef int (*ioctl_trans_handler_t)(unsigned int, unsigned int,
+                                        unsigned long, struct file *);
+
+struct ioctl_trans {
+        unsigned long cmd;
+        ioctl_trans_handler_t handler;
+        struct ioctl_trans *next;
+};
+
+/* 
+ * Register an 32bit ioctl translation handler for ioctl cmd.
+ *
+ * handler == NULL: use 64bit ioctl handler.
+ * arguments to handler:  fd: file descriptor
+ *                        cmd: ioctl command.
+ *                        arg: ioctl argument
+ *                        struct file *file: file descriptor pointer.
+ */ 
+
+#ifdef CONFIG_COMPAT
+extern int register_ioctl32_conversion(unsigned int cmd,
+                                ioctl_trans_handler_t handler);
+extern int unregister_ioctl32_conversion(unsigned int cmd);
+
+#else
+
+#define register_ioctl32_conversion(cmd, handler)       ({ 0; })
+#define unregister_ioctl32_conversion(cmd)              ({ 0; })
+
+#endif
+
+#endif
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
new file mode 100644
index 000000000000..18d010bee635
--- /dev/null
+++ b/include/linux/ioport.h
@@ -0,0 +1,127 @@
+/*
+ * ioport.h     Definitions of routines for detecting, reserving and
+ *              allocating system resources.
+ *
+ * Authors:     Linus Torvalds
+ */
+
+#ifndef _LINUX_IOPORT_H
+#define _LINUX_IOPORT_H
+
+#include <linux/compiler.h>
+/*
+ * Resources are tree-like, allowing
+ * nesting etc..
+ */
+struct resource {
+        const char *name;
+        unsigned long start, end;
+        unsigned long flags;
+        struct resource *parent, *sibling, *child;
+};
+
+struct resource_list {
+        struct resource_list *next;
+        struct resource *res;
+        struct pci_dev *dev;
+};
+
+/*
+ * IO resources have these defined flags.
+ */
+#define IORESOURCE_BITS         0x000000ff      /* Bus-specific bits */
+
+#define IORESOURCE_IO           0x00000100      /* Resource type */
+#define IORESOURCE_MEM          0x00000200
+#define IORESOURCE_IRQ          0x00000400
+#define IORESOURCE_DMA          0x00000800
+
+#define IORESOURCE_PREFETCH     0x00001000      /* No side effects */
+#define IORESOURCE_READONLY     0x00002000
+#define IORESOURCE_CACHEABLE    0x00004000
+#define IORESOURCE_RANGELENGTH  0x00008000
+#define IORESOURCE_SHADOWABLE   0x00010000
+#define IORESOURCE_BUS_HAS_VGA  0x00080000
+
+#define IORESOURCE_DISABLED     0x10000000
+#define IORESOURCE_UNSET        0x20000000
+#define IORESOURCE_AUTO         0x40000000
+#define IORESOURCE_BUSY         0x80000000      /* Driver has marked this resource busy */
+
+/* ISA PnP IRQ specific bits (IORESOURCE_BITS) */
+#define IORESOURCE_IRQ_HIGHEDGE         (1<<0)
+#define IORESOURCE_IRQ_LOWEDGE          (1<<1)
+#define IORESOURCE_IRQ_HIGHLEVEL        (1<<2)
+#define IORESOURCE_IRQ_LOWLEVEL         (1<<3)
+
+/* ISA PnP DMA specific bits (IORESOURCE_BITS) */
+#define IORESOURCE_DMA_TYPE_MASK        (3<<0)
+#define IORESOURCE_DMA_8BIT             (0<<0)
+#define IORESOURCE_DMA_8AND16BIT        (1<<0)
+#define IORESOURCE_DMA_16BIT            (2<<0)
+
+#define IORESOURCE_DMA_MASTER           (1<<2)
+#define IORESOURCE_DMA_BYTE             (1<<3)
+#define IORESOURCE_DMA_WORD             (1<<4)
+
+#define IORESOURCE_DMA_SPEED_MASK       (3<<6)
+#define IORESOURCE_DMA_COMPATIBLE       (0<<6)
+#define IORESOURCE_DMA_TYPEA            (1<<6)
+#define IORESOURCE_DMA_TYPEB            (2<<6)
+#define IORESOURCE_DMA_TYPEF            (3<<6)
+
+/* ISA PnP memory I/O specific bits (IORESOURCE_BITS) */
+#define IORESOURCE_MEM_WRITEABLE        (1<<0)  /* dup: IORESOURCE_READONLY */
+#define IORESOURCE_MEM_CACHEABLE        (1<<1)  /* dup: IORESOURCE_CACHEABLE */
+#define IORESOURCE_MEM_RANGELENGTH      (1<<2)  /* dup: IORESOURCE_RANGELENGTH */
+#define IORESOURCE_MEM_TYPE_MASK        (3<<3)
+#define IORESOURCE_MEM_8BIT             (0<<3)
+#define IORESOURCE_MEM_16BIT            (1<<3)
+#define IORESOURCE_MEM_8AND16BIT        (2<<3)
+#define IORESOURCE_MEM_32BIT            (3<<3)
+#define IORESOURCE_MEM_SHADOWABLE       (1<<5)  /* dup: IORESOURCE_SHADOWABLE */
+#define IORESOURCE_MEM_EXPANSIONROM     (1<<6)
+
+/* PCI ROM control bits (IORESOURCE_BITS) */
+#define IORESOURCE_ROM_ENABLE           (1<<0)  /* ROM is enabled, same as PCI_ROM_ADDRESS_ENABLE */
+#define IORESOURCE_ROM_SHADOW           (1<<1)  /* ROM is copy at C000:0 */
+#define IORESOURCE_ROM_COPY             (1<<2)  /* ROM is alloc'd copy, resource field overlaid */
+
+/* PC/ISA/whatever - the normal PC address spaces: IO and memory */
+extern struct resource ioport_resource;
+extern struct resource iomem_resource;
+
+extern int request_resource(struct resource *root, struct resource *new);
+extern struct resource * ____request_resource(struct resource *root, struct resource *new);
+extern int release_resource(struct resource *new);
+extern int insert_resource(struct resource *parent, struct resource *new);
+extern int allocate_resource(struct resource *root, struct resource *new,
+                             unsigned long size,
+                             unsigned long min, unsigned long max,
+                             unsigned long align,
+                             void (*alignf)(void *, struct resource *,
+                                            unsigned long, unsigned long),
+                             void *alignf_data);
+int adjust_resource(struct resource *res, unsigned long start,
+                    unsigned long size);
+
+/* Convenience shorthand with allocation */
+#define request_region(start,n,name)    __request_region(&ioport_resource, (start), (n), (name))
+#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name))
+#define rename_region(region, newname) do { (region)->name = (newname); } while (0)
+
+extern struct resource * __request_region(struct resource *, unsigned long start, unsigned long n, const char *name);
+
+/* Compatibility cruft */
+#define release_region(start,n) __release_region(&ioport_resource, (start), (n))
+#define check_mem_region(start,n)       __check_region(&iomem_resource, (start), (n))
+#define release_mem_region(start,n)     __release_region(&iomem_resource, (start), (n))
+
+extern int __check_region(struct resource *, unsigned long, unsigned long);
+extern void __release_region(struct resource *, unsigned long, unsigned long);
+
+static inline int __deprecated check_region(unsigned long s, unsigned long n)
+{
+        return __check_region(&ioport_resource, s, n);
+}
+#endif  /* _LINUX_IOPORT_H */
diff --git a/include/linux/ip.h b/include/linux/ip.h
new file mode 100644
index 000000000000..8438c68591f9
--- /dev/null
+++ b/include/linux/ip.h
@@ -0,0 +1,221 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the IP protocol.
+ *
+ * Version:     @(#)ip.h        1.0.2   04/28/93
+ *
+ * Authors:     Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_IP_H
+#define _LINUX_IP_H
+#include <asm/byteorder.h>
+
+#define IPTOS_TOS_MASK          0x1E
+#define IPTOS_TOS(tos)          ((tos)&IPTOS_TOS_MASK)
+#define IPTOS_LOWDELAY          0x10
+#define IPTOS_THROUGHPUT        0x08
+#define IPTOS_RELIABILITY       0x04
+#define IPTOS_MINCOST           0x02
+
+#define IPTOS_PREC_MASK         0xE0
+#define IPTOS_PREC(tos)         ((tos)&IPTOS_PREC_MASK)
+#define IPTOS_PREC_NETCONTROL           0xe0
+#define IPTOS_PREC_INTERNETCONTROL      0xc0
+#define IPTOS_PREC_CRITIC_ECP           0xa0
+#define IPTOS_PREC_FLASHOVERRIDE        0x80
+#define IPTOS_PREC_FLASH                0x60
+#define IPTOS_PREC_IMMEDIATE            0x40
+#define IPTOS_PREC_PRIORITY             0x20
+#define IPTOS_PREC_ROUTINE              0x00
+
+
+/* IP options */
+#define IPOPT_COPY              0x80
+#define IPOPT_CLASS_MASK        0x60
+#define IPOPT_NUMBER_MASK       0x1f
+
+#define IPOPT_COPIED(o)         ((o)&IPOPT_COPY)
+#define IPOPT_CLASS(o)          ((o)&IPOPT_CLASS_MASK)
+#define IPOPT_NUMBER(o)         ((o)&IPOPT_NUMBER_MASK)
+
+#define IPOPT_CONTROL           0x00
+#define IPOPT_RESERVED1         0x20
+#define IPOPT_MEASUREMENT       0x40
+#define IPOPT_RESERVED2         0x60
+
+#define IPOPT_END       (0 |IPOPT_CONTROL)
+#define IPOPT_NOOP      (1 |IPOPT_CONTROL)
+#define IPOPT_SEC       (2 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_LSRR      (3 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_TIMESTAMP (4 |IPOPT_MEASUREMENT)
+#define IPOPT_RR        (7 |IPOPT_CONTROL)
+#define IPOPT_SID       (8 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_SSRR      (9 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_RA        (20|IPOPT_CONTROL|IPOPT_COPY)
+
+#define IPVERSION       4
+#define MAXTTL          255
+#define IPDEFTTL        64
+
+#define IPOPT_OPTVAL 0
+#define IPOPT_OLEN   1
+#define IPOPT_OFFSET 2
+#define IPOPT_MINOFF 4
+#define MAX_IPOPTLEN 40
+#define IPOPT_NOP IPOPT_NOOP
+#define IPOPT_EOL IPOPT_END
+#define IPOPT_TS  IPOPT_TIMESTAMP
+
+#define IPOPT_TS_TSONLY         0               /* timestamps only */
+#define IPOPT_TS_TSANDADDR      1               /* timestamps and addresses */
+#define IPOPT_TS_PRESPEC        3               /* specified modules only */
+
+#ifdef __KERNEL__
+#include <linux/config.h>
+#include <linux/types.h>
+#include <net/sock.h>
+#include <linux/igmp.h>
+#include <net/flow.h>
+
+struct ip_options {
+  __u32         faddr;                          /* Saved first hop address */
+  unsigned char optlen;
+  unsigned char srr;
+  unsigned char rr;
+  unsigned char ts;
+  unsigned char is_setbyuser:1,                 /* Set by setsockopt?                   */
+                is_data:1,                      /* Options in __data, rather than skb   */
+                is_strictroute:1,               /* Strict source route                  */
+                srr_is_hit:1,                   /* Packet destination addr was our one  */
+                is_changed:1,                   /* IP checksum more not valid           */      
+                rr_needaddr:1,                  /* Need to record addr of outgoing dev  */
+                ts_needtime:1,                  /* Need to record timestamp             */
+                ts_needaddr:1;                  /* Need to record addr of outgoing dev  */
+  unsigned char router_alert;
+  unsigned char __pad1;
+  unsigned char __pad2;
+  unsigned char __data[0];
+};
+
+#define optlength(opt) (sizeof(struct ip_options) + opt->optlen)
+
+struct ipv6_pinfo;
+
+struct inet_sock {
+        /* sk and pinet6 has to be the first two members of inet_sock */
+        struct sock             sk;
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+        struct ipv6_pinfo       *pinet6;
+#endif
+        /* Socket demultiplex comparisons on incoming packets. */
+        __u32                   daddr;          /* Foreign IPv4 addr */
+        __u32                   rcv_saddr;      /* Bound local IPv4 addr */
+        __u16                   dport;          /* Destination port */
+        __u16                   num;            /* Local port */
+        __u32                   saddr;          /* Sending source */
+        __s16                   uc_ttl;         /* Unicast TTL */
+        __u16                   cmsg_flags;
+        struct ip_options       *opt;
+        __u16                   sport;          /* Source port */
+        __u16                   id;             /* ID counter for DF pkts */
+        __u8                    tos;            /* TOS */
+        __u8                    mc_ttl;         /* Multicasting TTL */
+        __u8                    pmtudisc;
+        unsigned                recverr : 1,
+                                freebind : 1,
+                                hdrincl : 1,
+                                mc_loop : 1;
+        int                     mc_index;       /* Multicast device index */
+        __u32                   mc_addr;
+        struct ip_mc_socklist   *mc_list;       /* Group array */
+        /*
+         * Following members are used to retain the infomation to build
+         * an ip header on each ip fragmentation while the socket is corked.
+         */
+        struct {
+                unsigned int            flags;
+                unsigned int            fragsize;
+                struct ip_options       *opt;
+                struct rtable           *rt;
+                int                     length; /* Total length of all frames */
+                u32                     addr;
+                struct flowi            fl;
+        } cork;
+};
+
+#define IPCORK_OPT      1       /* ip-options has been held in ipcork.opt */
+#define IPCORK_ALLFRAG  2       /* always fragment (for ipv6 for now) */
+
+static inline struct inet_sock *inet_sk(const struct sock *sk)
+{
+        return (struct inet_sock *)sk;
+}
+
+static inline void __inet_sk_copy_descendant(struct sock *sk_to,
+                                             const struct sock *sk_from,
+                                             const int ancestor_size)
+{
+        memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1,
+               sk_from->sk_prot->obj_size - ancestor_size);
+}
+#if !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE))
+static inline void inet_sk_copy_descendant(struct sock *sk_to,
+                                           const struct sock *sk_from)
+{
+        __inet_sk_copy_descendant(sk_to, sk_from, sizeof(struct inet_sock));
+}
+#endif
+#endif
+
+struct iphdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8    ihl:4,
+                version:4;
+#elif defined (__BIG_ENDIAN_BITFIELD)
+        __u8    version:4,
+                ihl:4;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+        __u8    tos;
+        __u16   tot_len;
+        __u16   id;
+        __u16   frag_off;
+        __u8    ttl;
+        __u8    protocol;
+        __u16   check;
+        __u32   saddr;
+        __u32   daddr;
+        /*The options start here. */
+};
+
+struct ip_auth_hdr {
+        __u8  nexthdr;
+        __u8  hdrlen;           /* This one is measured in 32 bit units! */
+        __u16 reserved;
+        __u32 spi;
+        __u32 seq_no;           /* Sequence number */
+        __u8  auth_data[0];     /* Variable len but >=4. Mind the 64 bit alignment! */
+};
+
+struct ip_esp_hdr {
+        __u32 spi;
+        __u32 seq_no;           /* Sequence number */
+        __u8  enc_data[0];      /* Variable len but >=8. Mind the 64 bit alignment! */
+};
+
+struct ip_comp_hdr {
+        __u8 nexthdr;
+        __u8 flags;
+        __u16 cpi;
+};
+
+#endif  /* _LINUX_IP_H */
diff --git a/include/linux/ip6_tunnel.h b/include/linux/ip6_tunnel.h
new file mode 100644
index 000000000000..5c23aeb104ca
--- /dev/null
+++ b/include/linux/ip6_tunnel.h
@@ -0,0 +1,34 @@
+/*
+ * $Id$
+ */
+
+#ifndef _IP6_TUNNEL_H
+#define _IP6_TUNNEL_H
+
+#define IPV6_TLV_TNL_ENCAP_LIMIT 4
+#define IPV6_DEFAULT_TNL_ENCAP_LIMIT 4
+
+/* don't add encapsulation limit if one isn't present in inner packet */
+#define IP6_TNL_F_IGN_ENCAP_LIMIT 0x1
+/* copy the traffic class field from the inner packet */
+#define IP6_TNL_F_USE_ORIG_TCLASS 0x2
+/* copy the flowlabel from the inner packet */
+#define IP6_TNL_F_USE_ORIG_FLOWLABEL 0x4
+/* being used for Mobile IPv6 */
+#define IP6_TNL_F_MIP6_DEV 0x8
+/* copy DSCP from the outer packet */
+#define IP6_TNL_F_RCV_DSCP_COPY 0x10
+
+struct ip6_tnl_parm {
+        char name[IFNAMSIZ];    /* name of tunnel device */
+        int link;               /* ifindex of underlying L2 interface */
+        __u8 proto;             /* tunnel protocol */
+        __u8 encap_limit;       /* encapsulation limit for tunnel */
+        __u8 hop_limit;         /* hop limit for tunnel */
+        __u32 flowinfo;         /* traffic class and flowlabel for tunnel */
+        __u32 flags;            /* tunnel flags */
+        struct in6_addr laddr;  /* local tunnel end-point address */
+        struct in6_addr raddr;  /* remote tunnel end-point address */
+};
+
+#endif
diff --git a/include/linux/ip_mp_alg.h b/include/linux/ip_mp_alg.h
new file mode 100644
index 000000000000..e234e2008f5d
--- /dev/null
+++ b/include/linux/ip_mp_alg.h
@@ -0,0 +1,22 @@
+/* ip_mp_alg.h: IPV4 multipath algorithm support, user-visible values.
+ *
+ * Copyright (C) 2004, 2005 Einar Lueck <elueck@de.ibm.com>
+ * Copyright (C) 2005 David S. Miller <davem@davemloft.net>
+ */
+
+#ifndef _LINUX_IP_MP_ALG_H
+#define _LINUX_IP_MP_ALG_H
+
+enum ip_mp_alg {
+        IP_MP_ALG_NONE,
+        IP_MP_ALG_RR,
+        IP_MP_ALG_DRR,
+        IP_MP_ALG_RANDOM,
+        IP_MP_ALG_WRANDOM,
+        __IP_MP_ALG_MAX
+};
+
+#define IP_MP_ALG_MAX (__IP_MP_ALG_MAX - 1)
+
+#endif /* _LINUX_IP_MP_ALG_H */
+
diff --git a/include/linux/ipc.h b/include/linux/ipc.h
new file mode 100644
index 000000000000..b291189737e7
--- /dev/null
+++ b/include/linux/ipc.h
@@ -0,0 +1,75 @@
+#ifndef _LINUX_IPC_H
+#define _LINUX_IPC_H
+
+#include <linux/types.h>
+
+#define IPC_PRIVATE ((__kernel_key_t) 0)  
+
+/* Obsolete, used only for backwards compatibility and libc5 compiles */
+struct ipc_perm
+{
+        __kernel_key_t  key;
+        __kernel_uid_t  uid;
+        __kernel_gid_t  gid;
+        __kernel_uid_t  cuid;
+        __kernel_gid_t  cgid;
+        __kernel_mode_t mode; 
+        unsigned short  seq;
+};
+
+/* Include the definition of ipc64_perm */
+#include <asm/ipcbuf.h>
+
+/* resource get request flags */
+#define IPC_CREAT  00001000   /* create if key is nonexistent */
+#define IPC_EXCL   00002000   /* fail if key exists */
+#define IPC_NOWAIT 00004000   /* return error on wait */
+
+/* these fields are used by the DIPC package so the kernel as standard
+   should avoid using them if possible */
+   
+#define IPC_DIPC 00010000  /* make it distributed */
+#define IPC_OWN  00020000  /* this machine is the DIPC owner */
+
+/* 
+ * Control commands used with semctl, msgctl and shmctl 
+ * see also specific commands in sem.h, msg.h and shm.h
+ */
+#define IPC_RMID 0     /* remove resource */
+#define IPC_SET  1     /* set ipc_perm options */
+#define IPC_STAT 2     /* get ipc_perm options */
+#define IPC_INFO 3     /* see ipcs */
+
+/*
+ * Version flags for semctl, msgctl, and shmctl commands
+ * These are passed as bitflags or-ed with the actual command
+ */
+#define IPC_OLD 0       /* Old version (no 32-bit UID support on many
+                           architectures) */
+#define IPC_64  0x0100  /* New version (support 32-bit UIDs, bigger
+                           message sizes, etc. */
+
+#ifdef __KERNEL__
+
+#define IPCMNI 32768  /* <= MAX_INT limit for ipc arrays (including sysctl changes) */
+
+/* used by in-kernel data structures */
+struct kern_ipc_perm
+{
+        spinlock_t      lock;
+        int             deleted;
+        key_t           key;
+        uid_t           uid;
+        gid_t           gid;
+        uid_t           cuid;
+        gid_t           cgid;
+        mode_t          mode; 
+        unsigned long   seq;
+        void            *security;
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_IPC_H */
+
+
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
new file mode 100644
index 000000000000..2ec265e1045f
--- /dev/null
+++ b/include/linux/ipmi.h
@@ -0,0 +1,602 @@
+/*
+ * ipmi.h
+ *
+ * MontaVista IPMI interface
+ *
+ * Author: MontaVista Software, Inc.
+ *         Corey Minyard <minyard@mvista.com>
+ *         source@mvista.com
+ *
+ * Copyright 2002 MontaVista Software Inc.
+ *
+ *  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; either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_IPMI_H
+#define __LINUX_IPMI_H
+
+#include <linux/ipmi_msgdefs.h>
+
+/*
+ * This file describes an interface to an IPMI driver.  You have to
+ * have a fairly good understanding of IPMI to use this, so go read
+ * the specs first before actually trying to do anything.
+ *
+ * With that said, this driver provides a multi-user interface to the
+ * IPMI driver, and it allows multiple IPMI physical interfaces below
+ * the driver.  The physical interfaces bind as a lower layer on the
+ * driver.  They appear as interfaces to the application using this
+ * interface.
+ *
+ * Multi-user means that multiple applications may use the driver,
+ * send commands, receive responses, etc.  The driver keeps track of
+ * commands the user sends and tracks the responses.  The responses
+ * will go back to the application that send the command.  If the
+ * response doesn't come back in time, the driver will return a
+ * timeout error response to the application.  Asynchronous events
+ * from the BMC event queue will go to all users bound to the driver.
+ * The incoming event queue in the BMC will automatically be flushed
+ * if it becomes full and it is queried once a second to see if
+ * anything is in it.  Incoming commands to the driver will get
+ * delivered as commands.
+ *
+ * This driver provides two main interfaces: one for in-kernel
+ * applications and another for userland applications.  The
+ * capabilities are basically the same for both interface, although
+ * the interfaces are somewhat different.  The stuff in the
+ * #ifdef KERNEL below is the in-kernel interface.  The userland
+ * interface is defined later in the file.  */
+
+
+
+/*
+ * This is an overlay for all the address types, so it's easy to
+ * determine the actual address type.  This is kind of like addresses
+ * work for sockets.
+ */
+#define IPMI_MAX_ADDR_SIZE 32
+struct ipmi_addr
+{
+         /* Try to take these from the "Channel Medium Type" table
+            in section 6.5 of the IPMI 1.5 manual. */
+        int   addr_type;
+        short channel;
+        char  data[IPMI_MAX_ADDR_SIZE];
+};
+
+/*
+ * When the address is not used, the type will be set to this value.
+ * The channel is the BMC's channel number for the channel (usually
+ * 0), or IPMC_BMC_CHANNEL if communicating directly with the BMC.
+ */
+#define IPMI_SYSTEM_INTERFACE_ADDR_TYPE 0x0c
+struct ipmi_system_interface_addr
+{
+        int           addr_type;
+        short         channel;
+        unsigned char lun;
+};
+
+/* An IPMB Address. */
+#define IPMI_IPMB_ADDR_TYPE             0x01
+/* Used for broadcast get device id as described in section 17.9 of the
+   IPMI 1.5 manual. */ 
+#define IPMI_IPMB_BROADCAST_ADDR_TYPE   0x41
+struct ipmi_ipmb_addr
+{
+        int           addr_type;
+        short         channel;
+        unsigned char slave_addr;
+        unsigned char lun;
+};
+
+/*
+ * A LAN Address.  This is an address to/from a LAN interface bridged
+ * by the BMC, not an address actually out on the LAN.
+ *
+ * A concious decision was made here to deviate slightly from the IPMI
+ * spec.  We do not use rqSWID and rsSWID like it shows in the
+ * message.  Instead, we use remote_SWID and local_SWID.  This means
+ * that any message (a request or response) from another device will
+ * always have exactly the same address.  If you didn't do this,
+ * requests and responses from the same device would have different
+ * addresses, and that's not too cool.
+ *
+ * In this address, the remote_SWID is always the SWID the remote
+ * message came from, or the SWID we are sending the message to.
+ * local_SWID is always our SWID.  Note that having our SWID in the
+ * message is a little weird, but this is required.
+ */
+#define IPMI_LAN_ADDR_TYPE              0x04
+struct ipmi_lan_addr
+{
+        int           addr_type;
+        short         channel;
+        unsigned char privilege;
+        unsigned char session_handle;
+        unsigned char remote_SWID;
+        unsigned char local_SWID;
+        unsigned char lun;
+};
+
+
+/*
+ * Channel for talking directly with the BMC.  When using this
+ * channel, This is for the system interface address type only.  FIXME
+ * - is this right, or should we use -1?
+ */
+#define IPMI_BMC_CHANNEL  0xf
+#define IPMI_NUM_CHANNELS 0x10
+
+
+/*
+ * A raw IPMI message without any addressing.  This covers both
+ * commands and responses.  The completion code is always the first
+ * byte of data in the response (as the spec shows the messages laid
+ * out).
+ */
+struct ipmi_msg
+{
+        unsigned char  netfn;
+        unsigned char  cmd;
+        unsigned short data_len;
+        unsigned char  __user *data;
+};
+
+struct kernel_ipmi_msg
+{
+        unsigned char  netfn;
+        unsigned char  cmd;
+        unsigned short data_len;
+        unsigned char  *data;
+};
+
+/*
+ * Various defines that are useful for IPMI applications.
+ */
+#define IPMI_INVALID_CMD_COMPLETION_CODE        0xC1
+#define IPMI_TIMEOUT_COMPLETION_CODE            0xC3
+#define IPMI_UNKNOWN_ERR_COMPLETION_CODE        0xff
+
+
+/*
+ * Receive types for messages coming from the receive interface.  This
+ * is used for the receive in-kernel interface and in the receive
+ * IOCTL.
+ *
+ * The "IPMI_RESPONSE_RESPNOSE_TYPE" is a little strange sounding, but
+ * it allows you to get the message results when you send a response
+ * message.
+ */
+#define IPMI_RESPONSE_RECV_TYPE         1 /* A response to a command */
+#define IPMI_ASYNC_EVENT_RECV_TYPE      2 /* Something from the event queue */
+#define IPMI_CMD_RECV_TYPE              3 /* A command from somewhere else */
+#define IPMI_RESPONSE_RESPONSE_TYPE     4 /* The response for
+                                              a sent response, giving any
+                                              error status for sending the
+                                              response.  When you send a
+                                              response message, this will
+                                              be returned. */
+/* Note that async events and received commands do not have a completion
+   code as the first byte of the incoming data, unlike a response. */
+
+
+
+#ifdef __KERNEL__
+
+/*
+ * The in-kernel interface.
+ */
+#include <linux/list.h>
+#include <linux/module.h>
+
+/* Opaque type for a IPMI message user.  One of these is needed to
+   send and receive messages. */
+typedef struct ipmi_user *ipmi_user_t;
+
+/*
+ * Stuff coming from the receive interface comes as one of these.
+ * They are allocated, the receiver must free them with
+ * ipmi_free_recv_msg() when done with the message.  The link is not
+ * used after the message is delivered, so the upper layer may use the
+ * link to build a linked list, if it likes.
+ */
+struct ipmi_recv_msg
+{
+        struct list_head link;
+
+        /* The type of message as defined in the "Receive Types"
+           defines above. */
+        int              recv_type;
+
+        ipmi_user_t      user;
+        struct ipmi_addr addr;
+        long             msgid;
+        struct kernel_ipmi_msg  msg;
+
+        /* The user_msg_data is the data supplied when a message was
+           sent, if this is a response to a sent message.  If this is
+           not a response to a sent message, then user_msg_data will
+           be NULL. */
+        void             *user_msg_data;
+
+        /* Call this when done with the message.  It will presumably free
+           the message and do any other necessary cleanup. */
+        void (*done)(struct ipmi_recv_msg *msg);
+
+        /* Place-holder for the data, don't make any assumptions about
+           the size or existance of this, since it may change. */
+        unsigned char   msg_data[IPMI_MAX_MSG_LENGTH];
+};
+
+/* Allocate and free the receive message. */
+static inline void ipmi_free_recv_msg(struct ipmi_recv_msg *msg)
+{
+        msg->done(msg);
+}
+
+struct ipmi_user_hndl
+{
+        /* Routine type to call when a message needs to be routed to
+           the upper layer.  This will be called with some locks held,
+           the only IPMI routines that can be called are ipmi_request
+           and the alloc/free operations.  The handler_data is the
+           variable supplied when the receive handler was registered. */
+        void (*ipmi_recv_hndl)(struct ipmi_recv_msg *msg,
+                               void                 *user_msg_data);
+
+        /* Called when the interface detects a watchdog pre-timeout.  If
+           this is NULL, it will be ignored for the user. */
+        void (*ipmi_watchdog_pretimeout)(void *handler_data);
+};
+
+/* Create a new user of the IPMI layer on the given interface number. */
+int ipmi_create_user(unsigned int          if_num,
+                     struct ipmi_user_hndl *handler,
+                     void                  *handler_data,
+                     ipmi_user_t           *user);
+
+/* Destroy the given user of the IPMI layer.  Note that after this
+   function returns, the system is guaranteed to not call any
+   callbacks for the user.  Thus as long as you destroy all the users
+   before you unload a module, you will be safe.  And if you destroy
+   the users before you destroy the callback structures, it should be
+   safe, too. */
+int ipmi_destroy_user(ipmi_user_t user);
+
+/* Get the IPMI version of the BMC we are talking to. */
+void ipmi_get_version(ipmi_user_t   user,
+                      unsigned char *major,
+                      unsigned char *minor);
+
+/* Set and get the slave address and LUN that we will use for our
+   source messages.  Note that this affects the interface, not just
+   this user, so it will affect all users of this interface.  This is
+   so some initialization code can come in and do the OEM-specific
+   things it takes to determine your address (if not the BMC) and set
+   it for everyone else. */
+void ipmi_set_my_address(ipmi_user_t   user,
+                         unsigned char address);
+unsigned char ipmi_get_my_address(ipmi_user_t user);
+void ipmi_set_my_LUN(ipmi_user_t   user,
+                     unsigned char LUN);
+unsigned char ipmi_get_my_LUN(ipmi_user_t user);
+
+/*
+ * Like ipmi_request, but lets you specify the number of retries and
+ * the retry time.  The retries is the number of times the message
+ * will be resent if no reply is received.  If set to -1, the default
+ * value will be used.  The retry time is the time in milliseconds
+ * between retries.  If set to zero, the default value will be
+ * used.
+ *
+ * Don't use this unless you *really* have to.  It's primarily for the
+ * IPMI over LAN converter; since the LAN stuff does its own retries,
+ * it makes no sense to do it here.  However, this can be used if you
+ * have unusual requirements.
+ */
+int ipmi_request_settime(ipmi_user_t      user,
+                         struct ipmi_addr *addr,
+                         long             msgid,
+                         struct kernel_ipmi_msg  *msg,
+                         void             *user_msg_data,
+                         int              priority,
+                         int              max_retries,
+                         unsigned int     retry_time_ms);
+
+/*
+ * Like ipmi_request, but with messages supplied.  This will not
+ * allocate any memory, and the messages may be statically allocated
+ * (just make sure to do the "done" handling on them).  Note that this
+ * is primarily for the watchdog timer, since it should be able to
+ * send messages even if no memory is available.  This is subject to
+ * change as the system changes, so don't use it unless you REALLY
+ * have to.
+ */
+int ipmi_request_supply_msgs(ipmi_user_t          user,
+                             struct ipmi_addr     *addr,
+                             long                 msgid,
+                             struct kernel_ipmi_msg *msg,
+                             void                 *user_msg_data,
+                             void                 *supplied_smi,
+                             struct ipmi_recv_msg *supplied_recv,
+                             int                  priority);
+
+/*
+ * When commands come in to the SMS, the user can register to receive
+ * them.  Only one user can be listening on a specific netfn/cmd pair
+ * at a time, you will get an EBUSY error if the command is already
+ * registered.  If a command is received that does not have a user
+ * registered, the driver will automatically return the proper
+ * error.
+ */
+int ipmi_register_for_cmd(ipmi_user_t   user,
+                          unsigned char netfn,
+                          unsigned char cmd);
+int ipmi_unregister_for_cmd(ipmi_user_t   user,
+                            unsigned char netfn,
+                            unsigned char cmd);
+
+/*
+ * Allow run-to-completion mode to be set for the interface of
+ * a specific user.
+ */
+void ipmi_user_set_run_to_completion(ipmi_user_t user, int val);
+
+/*
+ * When the user is created, it will not receive IPMI events by
+ * default.  The user must set this to TRUE to get incoming events.
+ * The first user that sets this to TRUE will receive all events that
+ * have been queued while no one was waiting for events.
+ */
+int ipmi_set_gets_events(ipmi_user_t user, int val);
+
+/*
+ * Called when a new SMI is registered.  This will also be called on
+ * every existing interface when a new watcher is registered with
+ * ipmi_smi_watcher_register().
+ */
+struct ipmi_smi_watcher
+{
+        struct list_head link;
+
+        /* You must set the owner to the current module, if you are in
+           a module (generally just set it to "THIS_MODULE"). */
+        struct module *owner;
+
+        /* These two are called with read locks held for the interface
+           the watcher list.  So you can add and remove users from the
+           IPMI interface, send messages, etc., but you cannot add
+           or remove SMI watchers or SMI interfaces. */
+        void (*new_smi)(int if_num);
+        void (*smi_gone)(int if_num);
+};
+
+int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher);
+int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher);
+
+/* The following are various helper functions for dealing with IPMI
+   addresses. */
+
+/* Return the maximum length of an IPMI address given it's type. */
+unsigned int ipmi_addr_length(int addr_type);
+
+/* Validate that the given IPMI address is valid. */
+int ipmi_validate_addr(struct ipmi_addr *addr, int len);
+
+#endif /* __KERNEL__ */
+
+
+/*
+ * The userland interface
+ */
+
+/*
+ * The userland interface for the IPMI driver is a standard character
+ * device, with each instance of an interface registered as a minor
+ * number under the major character device.
+ *
+ * The read and write calls do not work, to get messages in and out
+ * requires ioctl calls because of the complexity of the data.  select
+ * and poll do work, so you can wait for input using the file
+ * descriptor, you just can use read to get it.
+ *
+ * In general, you send a command down to the interface and receive
+ * responses back.  You can use the msgid value to correlate commands
+ * and responses, the driver will take care of figuring out which
+ * incoming messages are for which command and find the proper msgid
+ * value to report.  You will only receive reponses for commands you
+ * send.  Asynchronous events, however, go to all open users, so you
+ * must be ready to handle these (or ignore them if you don't care).
+ *
+ * The address type depends upon the channel type.  When talking
+ * directly to the BMC (IPMC_BMC_CHANNEL), the address is ignored
+ * (IPMI_UNUSED_ADDR_TYPE).  When talking to an IPMB channel, you must
+ * supply a valid IPMB address with the addr_type set properly.
+ *
+ * When talking to normal channels, the driver takes care of the
+ * details of formatting and sending messages on that channel.  You do
+ * not, for instance, have to format a send command, you just send
+ * whatever command you want to the channel, the driver will create
+ * the send command, automatically issue receive command and get even
+ * commands, and pass those up to the proper user.
+ */
+
+
+/* The magic IOCTL value for this interface. */
+#define IPMI_IOC_MAGIC 'i'
+
+
+/* Messages sent to the interface are this format. */
+struct ipmi_req
+{
+        unsigned char __user *addr; /* Address to send the message to. */
+        unsigned int  addr_len;
+
+        long    msgid; /* The sequence number for the message.  This
+                          exact value will be reported back in the
+                          response to this request if it is a command.
+                          If it is a response, this will be used as
+                          the sequence value for the response.  */
+
+        struct ipmi_msg msg;
+};
+/*
+ * Send a message to the interfaces.  error values are:
+ *   - EFAULT - an address supplied was invalid.
+ *   - EINVAL - The address supplied was not valid, or the command
+ *              was not allowed.
+ *   - EMSGSIZE - The message to was too large.
+ *   - ENOMEM - Buffers could not be allocated for the command.
+ */
+#define IPMICTL_SEND_COMMAND            _IOR(IPMI_IOC_MAGIC, 13,        \
+                                             struct ipmi_req)
+
+/* Messages sent to the interface with timing parameters are this
+   format. */
+struct ipmi_req_settime
+{
+        struct ipmi_req req;
+
+        /* See ipmi_request_settime() above for details on these
+           values. */
+        int          retries;
+        unsigned int retry_time_ms;
+};
+/*
+ * Send a message to the interfaces with timing parameters.  error values
+ * are:
+ *   - EFAULT - an address supplied was invalid.
+ *   - EINVAL - The address supplied was not valid, or the command
+ *              was not allowed.
+ *   - EMSGSIZE - The message to was too large.
+ *   - ENOMEM - Buffers could not be allocated for the command.
+ */
+#define IPMICTL_SEND_COMMAND_SETTIME    _IOR(IPMI_IOC_MAGIC, 21,        \
+                                             struct ipmi_req_settime)
+
+/* Messages received from the interface are this format. */
+struct ipmi_recv
+{
+        int     recv_type; /* Is this a command, response or an
+                              asyncronous event. */
+
+        unsigned char __user *addr;    /* Address the message was from is put
+                                   here.  The caller must supply the
+                                   memory. */
+        unsigned int  addr_len; /* The size of the address buffer.
+                                   The caller supplies the full buffer
+                                   length, this value is updated to
+                                   the actual message length when the
+                                   message is received. */
+
+        long    msgid; /* The sequence number specified in the request
+                          if this is a response.  If this is a command,
+                          this will be the sequence number from the
+                          command. */
+
+        struct ipmi_msg msg; /* The data field must point to a buffer.
+                                The data_size field must be set to the
+                                size of the message buffer.  The
+                                caller supplies the full buffer
+                                length, this value is updated to the
+                                actual message length when the message
+                                is received. */
+};
+
+/*
+ * Receive a message.  error values:
+ *  - EAGAIN - no messages in the queue.
+ *  - EFAULT - an address supplied was invalid.
+ *  - EINVAL - The address supplied was not valid.
+ *  - EMSGSIZE - The message to was too large to fit into the message buffer,
+ *               the message will be left in the buffer. */
+#define IPMICTL_RECEIVE_MSG             _IOWR(IPMI_IOC_MAGIC, 12,       \
+                                              struct ipmi_recv)
+
+/*
+ * Like RECEIVE_MSG, but if the message won't fit in the buffer, it
+ * will truncate the contents instead of leaving the data in the
+ * buffer.
+ */
+#define IPMICTL_RECEIVE_MSG_TRUNC       _IOWR(IPMI_IOC_MAGIC, 11,       \
+                                              struct ipmi_recv)
+
+/* Register to get commands from other entities on this interface. */
+struct ipmi_cmdspec
+{
+        unsigned char netfn;
+        unsigned char cmd;
+};
+
+/* 
+ * Register to receive a specific command.  error values:
+ *   - EFAULT - an address supplied was invalid.
+ *   - EBUSY - The netfn/cmd supplied was already in use.
+ *   - ENOMEM - could not allocate memory for the entry.
+ */
+#define IPMICTL_REGISTER_FOR_CMD        _IOR(IPMI_IOC_MAGIC, 14,        \
+                                             struct ipmi_cmdspec)
+/*
+ * Unregister a regsitered command.  error values:
+ *  - EFAULT - an address supplied was invalid.
+ *  - ENOENT - The netfn/cmd was not found registered for this user.
+ */
+#define IPMICTL_UNREGISTER_FOR_CMD      _IOR(IPMI_IOC_MAGIC, 15,        \
+                                             struct ipmi_cmdspec)
+
+/* 
+ * Set whether this interface receives events.  Note that the first
+ * user registered for events will get all pending events for the
+ * interface.  error values:
+ *  - EFAULT - an address supplied was invalid.
+ */
+#define IPMICTL_SET_GETS_EVENTS_CMD     _IOR(IPMI_IOC_MAGIC, 16, int)
+
+/*
+ * Set and get the slave address and LUN that we will use for our
+ * source messages.  Note that this affects the interface, not just
+ * this user, so it will affect all users of this interface.  This is
+ * so some initialization code can come in and do the OEM-specific
+ * things it takes to determine your address (if not the BMC) and set
+ * it for everyone else.  You should probably leave the LUN alone.
+ */
+#define IPMICTL_SET_MY_ADDRESS_CMD      _IOR(IPMI_IOC_MAGIC, 17, unsigned int)
+#define IPMICTL_GET_MY_ADDRESS_CMD      _IOR(IPMI_IOC_MAGIC, 18, unsigned int)
+#define IPMICTL_SET_MY_LUN_CMD          _IOR(IPMI_IOC_MAGIC, 19, unsigned int)
+#define IPMICTL_GET_MY_LUN_CMD          _IOR(IPMI_IOC_MAGIC, 20, unsigned int)
+
+/*
+ * Get/set the default timing values for an interface.  You shouldn't
+ * generally mess with these.
+ */
+struct ipmi_timing_parms
+{
+        int          retries;
+        unsigned int retry_time_ms;
+};
+#define IPMICTL_SET_TIMING_PARMS_CMD    _IOR(IPMI_IOC_MAGIC, 22, \
+                                             struct ipmi_timing_parms)
+#define IPMICTL_GET_TIMING_PARMS_CMD    _IOR(IPMI_IOC_MAGIC, 23, \
+                                             struct ipmi_timing_parms)
+
+#endif /* __LINUX_IPMI_H */
diff --git a/include/linux/ipmi_msgdefs.h b/include/linux/ipmi_msgdefs.h
new file mode 100644
index 000000000000..03bc64dc2ec1
--- /dev/null
+++ b/include/linux/ipmi_msgdefs.h
@@ -0,0 +1,101 @@
+/*
+ * ipmi_smi.h
+ *
+ * MontaVista IPMI system management interface
+ *
+ * Author: MontaVista Software, Inc.
+ *         Corey Minyard <minyard@mvista.com>
+ *         source@mvista.com
+ *
+ * Copyright 2002 MontaVista Software Inc.
+ *
+ *  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; either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_IPMI_MSGDEFS_H
+#define __LINUX_IPMI_MSGDEFS_H
+
+/* Various definitions for IPMI messages used by almost everything in
+   the IPMI stack. */
+
+/* NetFNs and commands used inside the IPMI stack. */
+
+#define IPMI_NETFN_SENSOR_EVENT_REQUEST         0x04
+#define IPMI_NETFN_SENSOR_EVENT_RESPONSE        0x05
+#define IPMI_GET_EVENT_RECEIVER_CMD     0x01
+
+#define IPMI_NETFN_APP_REQUEST                  0x06
+#define IPMI_NETFN_APP_RESPONSE                 0x07
+#define IPMI_GET_DEVICE_ID_CMD          0x01
+#define IPMI_CLEAR_MSG_FLAGS_CMD        0x30
+#define IPMI_GET_MSG_FLAGS_CMD          0x31
+#define IPMI_SEND_MSG_CMD               0x34
+#define IPMI_GET_MSG_CMD                0x33
+#define IPMI_SET_BMC_GLOBAL_ENABLES_CMD 0x2e
+#define IPMI_GET_BMC_GLOBAL_ENABLES_CMD 0x2f
+#define IPMI_READ_EVENT_MSG_BUFFER_CMD  0x35
+#define IPMI_GET_CHANNEL_INFO_CMD       0x42
+
+#define IPMI_NETFN_STORAGE_REQUEST              0x0a
+#define IPMI_NETFN_STORAGE_RESPONSE             0x0b
+#define IPMI_ADD_SEL_ENTRY_CMD          0x44
+
+/* The default slave address */
+#define IPMI_BMC_SLAVE_ADDR     0x20
+
+/* The BT interface on high-end HP systems supports up to 255 bytes in
+ * one transfer.  Its "virtual" BMC supports some commands that are longer
+ * than 128 bytes.  Use the full 256, plus NetFn/LUN, Cmd, cCode, plus
+ * some overhead.  It would be nice to base this on the "BT Capabilities"
+ * but that's too hard to propagate to the rest of the driver. */
+#define IPMI_MAX_MSG_LENGTH     272     /* multiple of 16 */
+
+#define IPMI_CC_NO_ERROR                0x00
+#define IPMI_NODE_BUSY_ERR              0xc0
+#define IPMI_INVALID_COMMAND_ERR        0xc1
+#define IPMI_ERR_MSG_TRUNCATED          0xc6
+#define IPMI_LOST_ARBITRATION_ERR       0x81
+#define IPMI_ERR_UNSPECIFIED            0xff
+
+#define IPMI_CHANNEL_PROTOCOL_IPMB      1
+#define IPMI_CHANNEL_PROTOCOL_ICMB      2
+#define IPMI_CHANNEL_PROTOCOL_SMBUS     4
+#define IPMI_CHANNEL_PROTOCOL_KCS       5
+#define IPMI_CHANNEL_PROTOCOL_SMIC      6
+#define IPMI_CHANNEL_PROTOCOL_BT10      7
+#define IPMI_CHANNEL_PROTOCOL_BT15      8
+#define IPMI_CHANNEL_PROTOCOL_TMODE     9
+
+#define IPMI_CHANNEL_MEDIUM_IPMB        1
+#define IPMI_CHANNEL_MEDIUM_ICMB10      2
+#define IPMI_CHANNEL_MEDIUM_ICMB09      3
+#define IPMI_CHANNEL_MEDIUM_8023LAN     4
+#define IPMI_CHANNEL_MEDIUM_ASYNC       5
+#define IPMI_CHANNEL_MEDIUM_OTHER_LAN   6
+#define IPMI_CHANNEL_MEDIUM_PCI_SMBUS   7
+#define IPMI_CHANNEL_MEDIUM_SMBUS1      8
+#define IPMI_CHANNEL_MEDIUM_SMBUS2      9
+#define IPMI_CHANNEL_MEDIUM_USB1        10
+#define IPMI_CHANNEL_MEDIUM_USB2        11
+#define IPMI_CHANNEL_MEDIUM_SYSINTF     12
+
+#endif /* __LINUX_IPMI_MSGDEFS_H */
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
new file mode 100644
index 000000000000..e36ee157ad67
--- /dev/null
+++ b/include/linux/ipmi_smi.h
@@ -0,0 +1,156 @@
+/*
+ * ipmi_smi.h
+ *
+ * MontaVista IPMI system management interface
+ *
+ * Author: MontaVista Software, Inc.
+ *         Corey Minyard <minyard@mvista.com>
+ *         source@mvista.com
+ *
+ * Copyright 2002 MontaVista Software Inc.
+ *
+ *  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; either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_IPMI_SMI_H
+#define __LINUX_IPMI_SMI_H
+
+#include <linux/ipmi_msgdefs.h>
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+
+/* This files describes the interface for IPMI system management interface
+   drivers to bind into the IPMI message handler. */
+
+/* Structure for the low-level drivers. */
+typedef struct ipmi_smi *ipmi_smi_t;
+
+/*
+ * Messages to/from the lower layer.  The smi interface will take one
+ * of these to send. After the send has occurred and a response has
+ * been received, it will report this same data structure back up to
+ * the upper layer.  If an error occurs, it should fill in the
+ * response with an error code in the completion code location. When
+ * asynchronous data is received, one of these is allocated, the
+ * data_size is set to zero and the response holds the data from the
+ * get message or get event command that the interface initiated.
+ * Note that it is the interfaces responsibility to detect
+ * asynchronous data and messages and request them from the
+ * interface.
+ */
+struct ipmi_smi_msg
+{
+        struct list_head link;
+
+        long    msgid;
+        void    *user_data;
+
+        int           data_size;
+        unsigned char data[IPMI_MAX_MSG_LENGTH];
+
+        int           rsp_size;
+        unsigned char rsp[IPMI_MAX_MSG_LENGTH];
+
+        /* Will be called when the system is done with the message
+           (presumably to free it). */
+        void (*done)(struct ipmi_smi_msg *msg);
+};
+
+struct ipmi_smi_handlers
+{
+        struct module *owner;
+
+        /* Called to enqueue an SMI message to be sent.  This
+           operation is not allowed to fail.  If an error occurs, it
+           should report back the error in a received message.  It may
+           do this in the current call context, since no write locks
+           are held when this is run.  If the priority is > 0, the
+           message will go into a high-priority queue and be sent
+           first.  Otherwise, it goes into a normal-priority queue. */
+        void (*sender)(void                *send_info,
+                       struct ipmi_smi_msg *msg,
+                       int                 priority);
+
+        /* Called by the upper layer to request that we try to get
+           events from the BMC we are attached to. */
+        void (*request_events)(void *send_info);
+
+        /* Called when the interface should go into "run to
+           completion" mode.  If this call sets the value to true, the
+           interface should make sure that all messages are flushed
+           out and that none are pending, and any new requests are run
+           to completion immediately. */
+        void (*set_run_to_completion)(void *send_info, int run_to_completion);
+
+        /* Called to poll for work to do.  This is so upper layers can
+           poll for operations during things like crash dumps. */
+        void (*poll)(void *send_info);
+
+        /* Tell the handler that we are using it/not using it.  The
+           message handler get the modules that this handler belongs
+           to; this function lets the SMI claim any modules that it
+           uses.  These may be NULL if this is not required. */
+        int (*inc_usecount)(void *send_info);
+        void (*dec_usecount)(void *send_info);
+};
+
+/* Add a low-level interface to the IPMI driver.  Note that if the
+   interface doesn't know its slave address, it should pass in zero. */
+int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
+                      void                     *send_info,
+                      unsigned char            version_major,
+                      unsigned char            version_minor,
+                      unsigned char            slave_addr,
+                      ipmi_smi_t               *intf);
+
+/*
+ * Remove a low-level interface from the IPMI driver.  This will
+ * return an error if the interface is still in use by a user.
+ */
+int ipmi_unregister_smi(ipmi_smi_t intf);
+
+/*
+ * The lower layer reports received messages through this interface.
+ * The data_size should be zero if this is an asyncronous message.  If
+ * the lower layer gets an error sending a message, it should format
+ * an error response in the message response.
+ */
+void ipmi_smi_msg_received(ipmi_smi_t          intf,
+                           struct ipmi_smi_msg *msg);
+
+/* The lower layer received a watchdog pre-timeout on interface. */
+void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf);
+
+struct ipmi_smi_msg *ipmi_alloc_smi_msg(void);
+static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
+{
+        msg->done(msg);
+}
+
+/* Allow the lower layer to add things to the proc filesystem
+   directory for this interface.  Note that the entry will
+   automatically be dstroyed when the interface is destroyed. */
+int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
+                            read_proc_t *read_proc, write_proc_t *write_proc,
+                            void *data, struct module *owner);
+
+#endif /* __LINUX_IPMI_SMI_H */
diff --git a/include/linux/ipsec.h b/include/linux/ipsec.h
new file mode 100644
index 000000000000..d3c527616b5e
--- /dev/null
+++ b/include/linux/ipsec.h
@@ -0,0 +1,46 @@
+#ifndef _LINUX_IPSEC_H
+#define _LINUX_IPSEC_H
+
+/* The definitions, required to talk to KAME racoon IKE. */
+
+#include <linux/pfkeyv2.h>
+
+#define IPSEC_PORT_ANY          0
+#define IPSEC_ULPROTO_ANY       255
+#define IPSEC_PROTO_ANY         255
+
+enum {
+        IPSEC_MODE_ANY          = 0,    /* We do not support this for SA */
+        IPSEC_MODE_TRANSPORT    = 1,
+        IPSEC_MODE_TUNNEL       = 2
+};
+
+enum {
+        IPSEC_DIR_ANY           = 0,
+        IPSEC_DIR_INBOUND       = 1,
+        IPSEC_DIR_OUTBOUND      = 2,
+        IPSEC_DIR_FWD           = 3,    /* It is our own */
+        IPSEC_DIR_MAX           = 4,
+        IPSEC_DIR_INVALID       = 5
+};
+
+enum {
+        IPSEC_POLICY_DISCARD    = 0,
+        IPSEC_POLICY_NONE       = 1,
+        IPSEC_POLICY_IPSEC      = 2,
+        IPSEC_POLICY_ENTRUST    = 3,
+        IPSEC_POLICY_BYPASS     = 4
+};
+
+enum {
+        IPSEC_LEVEL_DEFAULT     = 0,
+        IPSEC_LEVEL_USE         = 1,
+        IPSEC_LEVEL_REQUIRE     = 2,
+        IPSEC_LEVEL_UNIQUE      = 3
+};
+
+#define IPSEC_MANUAL_REQID_MAX  0x3fff
+
+#define IPSEC_REPLAYWSIZE  32
+
+#endif  /* _LINUX_IPSEC_H */
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
new file mode 100644
index 000000000000..ab0d0efbf240
--- /dev/null
+++ b/include/linux/ipv6.h
@@ -0,0 +1,316 @@
+#ifndef _IPV6_H
+#define _IPV6_H
+
+#include <linux/config.h>
+#include <linux/in6.h>
+#include <asm/byteorder.h>
+
+/* The latest drafts declared increase in minimal mtu up to 1280. */
+
+#define IPV6_MIN_MTU    1280
+
+/*
+ *      Advanced API
+ *      source interface/address selection, source routing, etc...
+ *      *under construction*
+ */
+
+
+struct in6_pktinfo {
+        struct in6_addr ipi6_addr;
+        int             ipi6_ifindex;
+};
+
+
+struct in6_ifreq {
+        struct in6_addr ifr6_addr;
+        __u32           ifr6_prefixlen;
+        int             ifr6_ifindex; 
+};
+
+#define IPV6_SRCRT_STRICT       0x01    /* this hop must be a neighbor  */
+#define IPV6_SRCRT_TYPE_0       0       /* IPv6 type 0 Routing Header   */
+
+/*
+ *      routing header
+ */
+struct ipv6_rt_hdr {
+        __u8            nexthdr;
+        __u8            hdrlen;
+        __u8            type;
+        __u8            segments_left;
+
+        /*
+         *      type specific data
+         *      variable length field
+         */
+};
+
+
+struct ipv6_opt_hdr {
+        __u8            nexthdr;
+        __u8            hdrlen;
+        /* 
+         * TLV encoded option data follows.
+         */
+};
+
+#define ipv6_destopt_hdr ipv6_opt_hdr
+#define ipv6_hopopt_hdr  ipv6_opt_hdr
+
+#ifdef __KERNEL__
+#define ipv6_optlen(p)  (((p)->hdrlen+1) << 3)
+#endif
+
+/*
+ *      routing header type 0 (used in cmsghdr struct)
+ */
+
+struct rt0_hdr {
+        struct ipv6_rt_hdr      rt_hdr;
+        __u32                   bitmap;         /* strict/loose bit map */
+        struct in6_addr         addr[0];
+
+#define rt0_type                rt_hdr.type
+};
+
+struct ipv6_auth_hdr {
+        __u8  nexthdr;
+        __u8  hdrlen;           /* This one is measured in 32 bit units! */
+        __u16 reserved;
+        __u32 spi;
+        __u32 seq_no;           /* Sequence number */
+        __u8  auth_data[0];     /* Length variable but >=4. Mind the 64 bit alignment! */
+};
+
+struct ipv6_esp_hdr {
+        __u32 spi;
+        __u32 seq_no;           /* Sequence number */
+        __u8  enc_data[0];      /* Length variable but >=8. Mind the 64 bit alignment! */
+};
+
+struct ipv6_comp_hdr {
+        __u8 nexthdr;
+        __u8 flags;
+        __u16 cpi;
+};
+
+/*
+ *      IPv6 fixed header
+ *
+ *      BEWARE, it is incorrect. The first 4 bits of flow_lbl
+ *      are glued to priority now, forming "class".
+ */
+
+struct ipv6hdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8                    priority:4,
+                                version:4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+        __u8                    version:4,
+                                priority:4;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+        __u8                    flow_lbl[3];
+
+        __u16                   payload_len;
+        __u8                    nexthdr;
+        __u8                    hop_limit;
+
+        struct  in6_addr        saddr;
+        struct  in6_addr        daddr;
+};
+
+/*
+ * This structure contains configuration options per IPv6 link.
+ */
+struct ipv6_devconf {
+        __s32           forwarding;
+        __s32           hop_limit;
+        __s32           mtu6;
+        __s32           accept_ra;
+        __s32           accept_redirects;
+        __s32           autoconf;
+        __s32           dad_transmits;
+        __s32           rtr_solicits;
+        __s32           rtr_solicit_interval;
+        __s32           rtr_solicit_delay;
+        __s32           force_mld_version;
+#ifdef CONFIG_IPV6_PRIVACY
+        __s32           use_tempaddr;
+        __s32           temp_valid_lft;
+        __s32           temp_prefered_lft;
+        __s32           regen_max_retry;
+        __s32           max_desync_factor;
+#endif
+        __s32           max_addresses;
+        void            *sysctl;
+};
+
+/* index values for the variables in ipv6_devconf */
+enum {
+        DEVCONF_FORWARDING = 0,
+        DEVCONF_HOPLIMIT,
+        DEVCONF_MTU6,
+        DEVCONF_ACCEPT_RA,
+        DEVCONF_ACCEPT_REDIRECTS,
+        DEVCONF_AUTOCONF,
+        DEVCONF_DAD_TRANSMITS,
+        DEVCONF_RTR_SOLICITS,
+        DEVCONF_RTR_SOLICIT_INTERVAL,
+        DEVCONF_RTR_SOLICIT_DELAY,
+        DEVCONF_USE_TEMPADDR,
+        DEVCONF_TEMP_VALID_LFT,
+        DEVCONF_TEMP_PREFERED_LFT,
+        DEVCONF_REGEN_MAX_RETRY,
+        DEVCONF_MAX_DESYNC_FACTOR,
+        DEVCONF_MAX_ADDRESSES,
+        DEVCONF_FORCE_MLD_VERSION,
+        DEVCONF_MAX
+};
+
+#ifdef __KERNEL__
+#include <linux/in6.h>          /* struct sockaddr_in6 */
+#include <linux/icmpv6.h>
+#include <net/if_inet6.h>       /* struct ipv6_mc_socklist */
+#include <linux/tcp.h>
+#include <linux/udp.h>
+
+/* 
+   This structure contains results of exthdrs parsing
+   as offsets from skb->nh.
+ */
+
+struct inet6_skb_parm {
+        int                     iif;
+        __u16                   ra;
+        __u16                   hop;
+        __u16                   dst0;
+        __u16                   srcrt;
+        __u16                   dst1;
+};
+
+#define IP6CB(skb)      ((struct inet6_skb_parm*)((skb)->cb))
+
+/**
+ * struct ipv6_pinfo - ipv6 private area
+ *
+ * In the struct sock hierarchy (tcp6_sock, upd6_sock, etc)
+ * this _must_ be the last member, so that inet6_sk_generic
+ * is able to calculate its offset from the base struct sock
+ * by using the struct proto->slab_obj_size member. -acme
+ */
+struct ipv6_pinfo {
+        struct in6_addr         saddr;
+        struct in6_addr         rcv_saddr;
+        struct in6_addr         daddr;
+        struct in6_addr         *daddr_cache;
+
+        __u32                   flow_label;
+        __u32                   frag_size;
+        __s16                   hop_limit;
+        __s16                   mcast_hops;
+        int                     mcast_oif;
+
+        /* pktoption flags */
+        union {
+                struct {
+                        __u8    srcrt:2,
+                                rxinfo:1,
+                                rxhlim:1,
+                                hopopts:1,
+                                dstopts:1,
+                                rxflow:1;
+                } bits;
+                __u8            all;
+        } rxopt;
+
+        /* sockopt flags */
+        __u8                    mc_loop:1,
+                                recverr:1,
+                                sndflow:1,
+                                pmtudisc:2,
+                                ipv6only:1;
+
+        __u32                   dst_cookie;
+
+        struct ipv6_mc_socklist *ipv6_mc_list;
+        struct ipv6_ac_socklist *ipv6_ac_list;
+        struct ipv6_fl_socklist *ipv6_fl_list;
+
+        struct ipv6_txoptions   *opt;
+        struct sk_buff          *pktoptions;
+        struct {
+                struct ipv6_txoptions *opt;
+                struct rt6_info *rt;
+                int hop_limit;
+        } cork;
+};
+
+/* WARNING: don't change the layout of the members in {raw,udp,tcp}6_sock! */
+struct raw6_sock {
+        /* inet_sock has to be the first member of raw6_sock */
+        struct inet_sock        inet;
+        __u32                   checksum;       /* perform checksum */
+        __u32                   offset;         /* checksum offset  */
+        struct icmp6_filter     filter;
+        /* ipv6_pinfo has to be the last member of raw6_sock, see inet6_sk_generic */
+        struct ipv6_pinfo       inet6;
+};
+
+struct udp6_sock {
+        struct udp_sock   udp;
+        /* ipv6_pinfo has to be the last member of udp6_sock, see inet6_sk_generic */
+        struct ipv6_pinfo inet6;
+};
+
+struct tcp6_sock {
+        struct tcp_sock   tcp;
+        /* ipv6_pinfo has to be the last member of tcp6_sock, see inet6_sk_generic */
+        struct ipv6_pinfo inet6;
+};
+
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
+{
+        return inet_sk(__sk)->pinet6;
+}
+
+static inline struct raw6_sock *raw6_sk(const struct sock *sk)
+{
+        return (struct raw6_sock *)sk;
+}
+
+static inline void inet_sk_copy_descendant(struct sock *sk_to,
+                                           const struct sock *sk_from)
+{
+        int ancestor_size = sizeof(struct inet_sock);
+
+        if (sk_from->sk_family == PF_INET6)
+                ancestor_size += sizeof(struct ipv6_pinfo);
+
+        __inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
+}
+
+#define __ipv6_only_sock(sk)    (inet6_sk(sk)->ipv6only)
+#define ipv6_only_sock(sk)      ((sk)->sk_family == PF_INET6 && __ipv6_only_sock(sk))
+#else
+#define __ipv6_only_sock(sk)    0
+#define ipv6_only_sock(sk)      0
+
+static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
+{
+        return NULL;
+}
+
+static inline struct raw6_sock *raw6_sk(const struct sock *sk)
+{
+        return NULL;
+}
+
+#endif
+
+#endif
+
+#endif
diff --git a/include/linux/ipv6_route.h b/include/linux/ipv6_route.h
new file mode 100644
index 000000000000..e2f935038013
--- /dev/null
+++ b/include/linux/ipv6_route.h
@@ -0,0 +1,49 @@
+/*
+ *      Linux INET6 implementation 
+ *
+ *      Authors:
+ *      Pedro Roque             <roque@di.fc.ul.pt>     
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_IPV6_ROUTE_H
+#define _LINUX_IPV6_ROUTE_H
+
+#define RTF_DEFAULT     0x00010000      /* default - learned via ND     */
+#define RTF_ALLONLINK   0x00020000      /* (deprecated and will be removed)
+                                           fallback, no routers on link */
+#define RTF_ADDRCONF    0x00040000      /* addrconf route - RA          */
+#define RTF_PREFIX_RT   0x00080000      /* A prefix only route - RA     */
+
+#define RTF_NONEXTHOP   0x00200000      /* route with no nexthop        */
+#define RTF_EXPIRES     0x00400000
+
+#define RTF_CACHE       0x01000000      /* cache entry                  */
+#define RTF_FLOW        0x02000000      /* flow significant route       */
+#define RTF_POLICY      0x04000000      /* policy route                 */
+
+#define RTF_LOCAL       0x80000000
+
+struct in6_rtmsg {
+        struct in6_addr         rtmsg_dst;
+        struct in6_addr         rtmsg_src;
+        struct in6_addr         rtmsg_gateway;
+        __u32                   rtmsg_type;
+        __u16                   rtmsg_dst_len;
+        __u16                   rtmsg_src_len;
+        __u32                   rtmsg_metric;
+        unsigned long           rtmsg_info;
+        __u32                   rtmsg_flags;
+        int                     rtmsg_ifindex;
+};
+
+#define RTMSG_NEWDEVICE         0x11
+#define RTMSG_DELDEVICE         0x12
+#define RTMSG_NEWROUTE          0x21
+#define RTMSG_DELROUTE          0x22
+
+#endif
diff --git a/include/linux/ipx.h b/include/linux/ipx.h
new file mode 100644
index 000000000000..4f29c60964c4
--- /dev/null
+++ b/include/linux/ipx.h
@@ -0,0 +1,74 @@
+#ifndef _IPX_H_
+#define _IPX_H_
+#include <linux/sockios.h>
+#include <linux/socket.h>
+#define IPX_NODE_LEN    6
+#define IPX_MTU         576
+
+struct sockaddr_ipx {
+        sa_family_t     sipx_family;
+        __u16           sipx_port;
+        __u32           sipx_network;
+        unsigned char   sipx_node[IPX_NODE_LEN];
+        __u8            sipx_type;
+        unsigned char   sipx_zero;      /* 16 byte fill */
+};
+
+/*
+ * So we can fit the extra info for SIOCSIFADDR into the address nicely
+ */
+#define sipx_special    sipx_port
+#define sipx_action     sipx_zero
+#define IPX_DLTITF      0
+#define IPX_CRTITF      1
+
+struct ipx_route_definition {
+        __u32         ipx_network;
+        __u32         ipx_router_network;
+        unsigned char ipx_router_node[IPX_NODE_LEN];
+};
+
+struct ipx_interface_definition {
+        __u32         ipx_network;
+        unsigned char ipx_device[16];
+        unsigned char ipx_dlink_type;
+#define IPX_FRAME_NONE          0
+#define IPX_FRAME_SNAP          1
+#define IPX_FRAME_8022          2
+#define IPX_FRAME_ETHERII       3
+#define IPX_FRAME_8023          4
+#define IPX_FRAME_TR_8022       5 /* obsolete */
+        unsigned char ipx_special;
+#define IPX_SPECIAL_NONE        0
+#define IPX_PRIMARY             1
+#define IPX_INTERNAL            2
+        unsigned char ipx_node[IPX_NODE_LEN];
+};
+        
+struct ipx_config_data {
+        unsigned char   ipxcfg_auto_select_primary;
+        unsigned char   ipxcfg_auto_create_interfaces;
+};
+
+/*
+ * OLD Route Definition for backward compatibility.
+ */
+
+struct ipx_route_def {
+        __u32           ipx_network;
+        __u32           ipx_router_network;
+#define IPX_ROUTE_NO_ROUTER     0
+        unsigned char   ipx_router_node[IPX_NODE_LEN];
+        unsigned char   ipx_device[16];
+        unsigned short  ipx_flags;
+#define IPX_RT_SNAP             8
+#define IPX_RT_8022             4
+#define IPX_RT_BLUEBOOK         2
+#define IPX_RT_ROUTED           1
+};
+
+#define SIOCAIPXITFCRT          (SIOCPROTOPRIVATE)
+#define SIOCAIPXPRISLT          (SIOCPROTOPRIVATE + 1)
+#define SIOCIPXCFGDATA          (SIOCPROTOPRIVATE + 2)
+#define SIOCIPXNCPCONN          (SIOCPROTOPRIVATE + 3)
+#endif /* _IPX_H_ */
diff --git a/include/linux/irda.h b/include/linux/irda.h
new file mode 100644
index 000000000000..95dee174cdc5
--- /dev/null
+++ b/include/linux/irda.h
@@ -0,0 +1,222 @@
+/*********************************************************************
+ *                
+ * Filename:      irda.h
+ * Version:       
+ * Description:   
+ * Status:        Experimental.
+ * Author:        Dag Brattli <dagb@cs.uit.no>
+ * Created at:    Mon Mar  8 14:06:12 1999
+ * Modified at:   Sat Dec 25 16:06:42 1999
+ * Modified by:   Dag Brattli <dagb@cs.uit.no>
+ * 
+ *     Copyright (c) 1999 Dag Brattli, 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; either version 2 of 
+ *     the License, or (at your option) any later version.
+ *  
+ *     Neither Dag Brattli nor University of Tromsø admit liability nor
+ *     provide warranty for any of this software. This material is 
+ *     provided "AS-IS" and at no charge.
+ *
+ ********************************************************************/
+
+#ifndef KERNEL_IRDA_H
+#define KERNEL_IRDA_H
+
+/* Please do *not* add any #include in this file, this file is
+ * included as-is in user space.
+ * Please fix the calling file to properly included needed files before
+ * this one, or preferably to include <net/irda/irda.h> instead.
+ * Jean II */
+
+/* Hint bit positions for first hint byte */
+#define HINT_PNP         0x01
+#define HINT_PDA         0x02
+#define HINT_COMPUTER    0x04
+#define HINT_PRINTER     0x08
+#define HINT_MODEM       0x10
+#define HINT_FAX         0x20
+#define HINT_LAN         0x40
+#define HINT_EXTENSION   0x80
+
+/* Hint bit positions for second hint byte (first extension byte) */
+#define HINT_TELEPHONY   0x01
+#define HINT_FILE_SERVER 0x02
+#define HINT_COMM        0x04
+#define HINT_MESSAGE     0x08
+#define HINT_HTTP        0x10
+#define HINT_OBEX        0x20
+
+/* IrLMP character code values */
+#define CS_ASCII         0x00
+#define CS_ISO_8859_1    0x01
+#define CS_ISO_8859_2    0x02
+#define CS_ISO_8859_3    0x03
+#define CS_ISO_8859_4    0x04
+#define CS_ISO_8859_5    0x05
+#define CS_ISO_8859_6    0x06
+#define CS_ISO_8859_7    0x07
+#define CS_ISO_8859_8    0x08
+#define CS_ISO_8859_9    0x09
+#define CS_UNICODE       0xff
+
+/* These are the currently known dongles */
+typedef enum {
+        IRDA_TEKRAM_DONGLE       = 0,
+        IRDA_ESI_DONGLE          = 1,
+        IRDA_ACTISYS_DONGLE      = 2,
+        IRDA_ACTISYS_PLUS_DONGLE = 3,
+        IRDA_GIRBIL_DONGLE       = 4,
+        IRDA_LITELINK_DONGLE     = 5,
+        IRDA_AIRPORT_DONGLE      = 6,
+        IRDA_OLD_BELKIN_DONGLE   = 7,
+        IRDA_EP7211_IR           = 8,
+        IRDA_MCP2120_DONGLE      = 9,
+        IRDA_ACT200L_DONGLE      = 10,
+        IRDA_MA600_DONGLE        = 11,
+} IRDA_DONGLE;
+
+/* Protocol types to be used for SOCK_DGRAM */
+enum {
+        IRDAPROTO_UNITDATA = 0,
+        IRDAPROTO_ULTRA    = 1,
+        IRDAPROTO_MAX
+};
+
+#define SOL_IRLMP      266 /* Same as SOL_IRDA for now */
+#define SOL_IRTTP      266 /* Same as SOL_IRDA for now */
+
+#define IRLMP_ENUMDEVICES        1      /* Return discovery log */
+#define IRLMP_IAS_SET            2      /* Set an attribute in local IAS */
+#define IRLMP_IAS_QUERY          3      /* Query remote IAS for attribute */
+#define IRLMP_HINTS_SET          4      /* Set hint bits advertised */
+#define IRLMP_QOS_SET            5
+#define IRLMP_QOS_GET            6
+#define IRLMP_MAX_SDU_SIZE       7
+#define IRLMP_IAS_GET            8      /* Get an attribute from local IAS */
+#define IRLMP_IAS_DEL            9      /* Remove attribute from local IAS */
+#define IRLMP_HINT_MASK_SET     10      /* Set discovery filter */
+#define IRLMP_WAITDEVICE        11      /* Wait for a new discovery */
+
+#define IRTTP_MAX_SDU_SIZE IRLMP_MAX_SDU_SIZE /* Compatibility */
+
+#define IAS_MAX_STRING         256      /* See IrLMP 1.1, 4.3.3.2 */
+#define IAS_MAX_OCTET_STRING  1024      /* See IrLMP 1.1, 4.3.3.2 */
+#define IAS_MAX_CLASSNAME       60      /* See IrLMP 1.1, 4.3.1 */
+#define IAS_MAX_ATTRIBNAME      60      /* See IrLMP 1.1, 4.3.3.1 */
+#define IAS_MAX_ATTRIBNUMBER   256      /* See IrLMP 1.1, 4.3.3.1 */
+/* For user space backward compatibility - may be fixed in kernel 2.5.X
+ * Note : need 60+1 ('\0'), make it 64 for alignement - Jean II */
+#define IAS_EXPORT_CLASSNAME       64
+#define IAS_EXPORT_ATTRIBNAME     256
+
+/* Attribute type needed for struct irda_ias_set */
+#define IAS_MISSING 0
+#define IAS_INTEGER 1
+#define IAS_OCT_SEQ 2
+#define IAS_STRING  3
+
+#define LSAP_ANY              0xff
+
+struct sockaddr_irda {
+        sa_family_t sir_family;   /* AF_IRDA */
+        __u8        sir_lsap_sel; /* LSAP selector */
+        __u32       sir_addr;     /* Device address */
+        char        sir_name[25]; /* Usually <service>:IrDA:TinyTP */
+};
+
+struct irda_device_info {
+        __u32       saddr;    /* Address of local interface */
+        __u32       daddr;    /* Address of remote device */
+        char        info[22]; /* Description */
+        __u8        charset;  /* Charset used for description */
+        __u8        hints[2]; /* Hint bits */
+};
+
+struct irda_device_list {
+       __u32 len;
+       struct irda_device_info dev[1];
+};
+
+struct irda_ias_set {
+        char irda_class_name[IAS_EXPORT_CLASSNAME];
+        char irda_attrib_name[IAS_EXPORT_ATTRIBNAME];
+        unsigned int irda_attrib_type;
+        union {
+                unsigned int irda_attrib_int;
+                struct {
+                        unsigned short len;
+                        __u8 octet_seq[IAS_MAX_OCTET_STRING];
+                } irda_attrib_octet_seq;
+                struct {
+                        __u8 len;
+                        __u8 charset;
+                        __u8 string[IAS_MAX_STRING];
+                } irda_attrib_string;
+        } attribute;
+        __u32       daddr;    /* Address of device (for some queries only) */
+};
+
+/* Some private IOCTL's (max 16) */
+#define SIOCSDONGLE    (SIOCDEVPRIVATE + 0)
+#define SIOCGDONGLE    (SIOCDEVPRIVATE + 1)
+#define SIOCSBANDWIDTH (SIOCDEVPRIVATE + 2)
+#define SIOCSMEDIABUSY (SIOCDEVPRIVATE + 3)
+#define SIOCGMEDIABUSY (SIOCDEVPRIVATE + 4)
+#define SIOCGRECEIVING (SIOCDEVPRIVATE + 5)
+#define SIOCSMODE      (SIOCDEVPRIVATE + 6)
+#define SIOCGMODE      (SIOCDEVPRIVATE + 7)
+#define SIOCSDTRRTS    (SIOCDEVPRIVATE + 8)
+#define SIOCGQOS       (SIOCDEVPRIVATE + 9)
+
+/* No reason to include <linux/if.h> just because of this one ;-) */
+#define IRNAMSIZ 16 
+
+/* IrDA quality of service information (must not exceed 16 bytes) */
+struct if_irda_qos {
+        unsigned long  baudrate;
+        unsigned short data_size;
+        unsigned short window_size;
+        unsigned short min_turn_time;
+        unsigned short max_turn_time;
+        unsigned char  add_bofs;
+        unsigned char  link_disc;
+};
+
+/* For setting RTS and DTR lines of a dongle */
+struct if_irda_line {
+        __u8 dtr;
+        __u8 rts;
+};
+
+/* IrDA interface configuration (data part must not exceed 16 bytes) */
+struct if_irda_req {
+        union {
+                char ifrn_name[IRNAMSIZ];  /* if name, e.g. "irda0" */
+        } ifr_ifrn;
+        
+        /* Data part */
+        union {
+                struct if_irda_line ifru_line;
+                struct if_irda_qos  ifru_qos;
+                unsigned short      ifru_flags;
+                unsigned int        ifru_receiving;
+                unsigned int        ifru_mode;
+                unsigned int        ifru_dongle;
+        } ifr_ifru;
+};
+
+#define ifr_baudrate  ifr_ifru.ifru_qos.baudrate
+#define ifr_receiving ifr_ifru.ifru_receiving 
+#define ifr_dongle    ifr_ifru.ifru_dongle
+#define ifr_mode      ifr_ifru.ifru_mode
+#define ifr_dtr       ifr_ifru.ifru_line.dtr
+#define ifr_rts       ifr_ifru.ifru_line.rts
+
+#endif /* KERNEL_IRDA_H */
+
+
+
+
diff --git a/include/linux/irq.h b/include/linux/irq.h
new file mode 100644
index 000000000000..c3ff4d101667
--- /dev/null
+++ b/include/linux/irq.h
@@ -0,0 +1,97 @@
+#ifndef __irq_h
+#define __irq_h
+
+/*
+ * Please do not include this file in generic code.  There is currently
+ * no requirement for any architecture to implement anything held
+ * within this file.
+ *
+ * Thanks. --rmk
+ */
+
+#include <linux/config.h>
+
+#if !defined(CONFIG_ARCH_S390)
+
+#include <linux/linkage.h>
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/cpumask.h>
+
+#include <asm/irq.h>
+#include <asm/ptrace.h>
+
+/*
+ * IRQ line status.
+ */
+#define IRQ_INPROGRESS  1       /* IRQ handler active - do not enter! */
+#define IRQ_DISABLED    2       /* IRQ disabled - do not enter! */
+#define IRQ_PENDING     4       /* IRQ pending - replay on enable */
+#define IRQ_REPLAY      8       /* IRQ has been replayed but not acked yet */
+#define IRQ_AUTODETECT  16      /* IRQ is being autodetected */
+#define IRQ_WAITING     32      /* IRQ not yet seen - for autodetection */
+#define IRQ_LEVEL       64      /* IRQ level triggered */
+#define IRQ_MASKED      128     /* IRQ masked - shouldn't be seen again */
+#define IRQ_PER_CPU     256     /* IRQ is per CPU */
+
+/*
+ * Interrupt controller descriptor. This is all we need
+ * to describe about the low-level hardware. 
+ */
+struct hw_interrupt_type {
+        const char * typename;
+        unsigned int (*startup)(unsigned int irq);
+        void (*shutdown)(unsigned int irq);
+        void (*enable)(unsigned int irq);
+        void (*disable)(unsigned int irq);
+        void (*ack)(unsigned int irq);
+        void (*end)(unsigned int irq);
+        void (*set_affinity)(unsigned int irq, cpumask_t dest);
+};
+
+typedef struct hw_interrupt_type  hw_irq_controller;
+
+/*
+ * This is the "IRQ descriptor", which contains various information
+ * about the irq, including what kind of hardware handling it has,
+ * whether it is disabled etc etc.
+ *
+ * Pad this out to 32 bytes for cache and indexing reasons.
+ */
+typedef struct irq_desc {
+        hw_irq_controller *handler;
+        void *handler_data;
+        struct irqaction *action;       /* IRQ action list */
+        unsigned int status;            /* IRQ status */
+        unsigned int depth;             /* nested irq disables */
+        unsigned int irq_count;         /* For detecting broken interrupts */
+        unsigned int irqs_unhandled;
+        spinlock_t lock;
+} ____cacheline_aligned irq_desc_t;
+
+extern irq_desc_t irq_desc [NR_IRQS];
+
+#include <asm/hw_irq.h> /* the arch dependent stuff */
+
+extern int setup_irq(unsigned int irq, struct irqaction * new);
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+extern cpumask_t irq_affinity[NR_IRQS];
+extern int no_irq_affinity;
+extern int noirqdebug_setup(char *str);
+
+extern fastcall int handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+                                       struct irqaction *action);
+extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);
+extern void note_interrupt(unsigned int irq, irq_desc_t *desc, int action_ret);
+extern void report_bad_irq(unsigned int irq, irq_desc_t *desc, int action_ret);
+extern int can_request_irq(unsigned int irq, unsigned long irqflags);
+
+extern void init_irq_proc(void);
+#endif
+
+extern hw_irq_controller no_irq_type;  /* needed in every arch ? */
+
+#endif
+
+#endif /* __irq_h */
diff --git a/include/linux/irq_cpustat.h b/include/linux/irq_cpustat.h
new file mode 100644
index 000000000000..af93505ec2ec
--- /dev/null
+++ b/include/linux/irq_cpustat.h
@@ -0,0 +1,32 @@
+#ifndef __irq_cpustat_h
+#define __irq_cpustat_h
+
+/*
+ * Contains default mappings for irq_cpustat_t, used by almost every
+ * architecture.  Some arch (like s390) have per cpu hardware pages and
+ * they define their own mappings for irq_stat.
+ *
+ * Keith Owens <kaos@ocs.com.au> July 2000.
+ */
+
+#include <linux/config.h>
+
+/*
+ * Simple wrappers reducing source bloat.  Define all irq_stat fields
+ * here, even ones that are arch dependent.  That way we get common
+ * definitions instead of differing sets for each arch.
+ */
+
+#ifndef __ARCH_IRQ_STAT
+extern irq_cpustat_t irq_stat[];                /* defined in asm/hardirq.h */
+#define __IRQ_STAT(cpu, member) (irq_stat[cpu].member)
+#endif
+
+  /* arch independent irq_stat fields */
+#define local_softirq_pending() \
+        __IRQ_STAT(smp_processor_id(), __softirq_pending)
+
+  /* arch dependent irq_stat fields */
+#define nmi_count(cpu)          __IRQ_STAT((cpu), __nmi_count)  /* i386 */
+
+#endif  /* __irq_cpustat_h */
diff --git a/include/linux/isapnp.h b/include/linux/isapnp.h
new file mode 100644
index 000000000000..26c64c286f42
--- /dev/null
+++ b/include/linux/isapnp.h
@@ -0,0 +1,142 @@
+/*
+ *  ISA Plug & Play support
+ *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
+ *
+ *
+ *   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; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef LINUX_ISAPNP_H
+#define LINUX_ISAPNP_H
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/pnp.h>
+
+/*
+ *  Configuration registers (TODO: change by specification)
+ */ 
+
+#define ISAPNP_CFG_ACTIVATE             0x30    /* byte */
+#define ISAPNP_CFG_MEM                  0x40    /* 4 * dword */
+#define ISAPNP_CFG_PORT                 0x60    /* 8 * word */
+#define ISAPNP_CFG_IRQ                  0x70    /* 2 * word */
+#define ISAPNP_CFG_DMA                  0x74    /* 2 * byte */
+
+/*
+ *
+ */
+
+#define ISAPNP_VENDOR(a,b,c)    (((((a)-'A'+1)&0x3f)<<2)|\
+                                ((((b)-'A'+1)&0x18)>>3)|((((b)-'A'+1)&7)<<13)|\
+                                ((((c)-'A'+1)&0x1f)<<8))
+#define ISAPNP_DEVICE(x)        ((((x)&0xf000)>>8)|\
+                                 (((x)&0x0f00)>>8)|\
+                                 (((x)&0x00f0)<<8)|\
+                                 (((x)&0x000f)<<8))
+#define ISAPNP_FUNCTION(x)      ISAPNP_DEVICE(x)
+
+/*
+ *
+ */
+
+#ifdef __KERNEL__
+
+#define DEVICE_COUNT_COMPATIBLE 4
+
+#define ISAPNP_ANY_ID           0xffff
+#define ISAPNP_CARD_DEVS        8
+
+#define ISAPNP_CARD_ID(_va, _vb, _vc, _device) \
+                .card_vendor = ISAPNP_VENDOR(_va, _vb, _vc), .card_device = ISAPNP_DEVICE(_device)
+#define ISAPNP_CARD_END \
+                .card_vendor = 0, .card_device = 0
+#define ISAPNP_DEVICE_ID(_va, _vb, _vc, _function) \
+                { .vendor = ISAPNP_VENDOR(_va, _vb, _vc), .function = ISAPNP_FUNCTION(_function) }
+
+/* export used IDs outside module */
+#define ISAPNP_CARD_TABLE(name) \
+                MODULE_GENERIC_TABLE(isapnp_card, name)
+
+struct isapnp_card_id {
+        unsigned long driver_data;      /* data private to the driver */
+        unsigned short card_vendor, card_device;
+        struct {
+                unsigned short vendor, function;
+        } devs[ISAPNP_CARD_DEVS];       /* logical devices */
+};
+
+#define ISAPNP_DEVICE_SINGLE(_cva, _cvb, _cvc, _cdevice, _dva, _dvb, _dvc, _dfunction) \
+                .card_vendor = ISAPNP_VENDOR(_cva, _cvb, _cvc), .card_device =  ISAPNP_DEVICE(_cdevice), \
+                .vendor = ISAPNP_VENDOR(_dva, _dvb, _dvc), .function = ISAPNP_FUNCTION(_dfunction)
+#define ISAPNP_DEVICE_SINGLE_END \
+                .card_vendor = 0, .card_device = 0
+
+struct isapnp_device_id {
+        unsigned short card_vendor, card_device;
+        unsigned short vendor, function;
+        unsigned long driver_data;      /* data private to the driver */
+};
+
+#if defined(CONFIG_ISAPNP) || (defined(CONFIG_ISAPNP_MODULE) && defined(MODULE))
+
+#define __ISAPNP__
+
+/* lowlevel configuration */
+int isapnp_present(void);
+int isapnp_cfg_begin(int csn, int device);
+int isapnp_cfg_end(void);
+unsigned char isapnp_read_byte(unsigned char idx);
+void isapnp_write_byte(unsigned char idx, unsigned char val);
+
+#ifdef CONFIG_PROC_FS
+int isapnp_proc_init(void);
+int isapnp_proc_done(void);
+#else
+static inline int isapnp_proc_init(void) { return 0; }
+static inline int isapnp_proc_done(void) { return 0; }
+#endif
+
+/* compat */
+struct pnp_card *pnp_find_card(unsigned short vendor,
+                               unsigned short device,
+                               struct pnp_card *from);
+struct pnp_dev *pnp_find_dev(struct pnp_card *card,
+                             unsigned short vendor,
+                             unsigned short function,
+                             struct pnp_dev *from);
+
+#else /* !CONFIG_ISAPNP */
+
+/* lowlevel configuration */
+static inline int isapnp_present(void) { return 0; }
+static inline int isapnp_cfg_begin(int csn, int device) { return -ENODEV; }
+static inline int isapnp_cfg_end(void) { return -ENODEV; }
+static inline unsigned char isapnp_read_byte(unsigned char idx) { return 0xff; }
+static inline void isapnp_write_byte(unsigned char idx, unsigned char val) { ; }
+
+static inline struct pnp_card *pnp_find_card(unsigned short vendor,
+                                             unsigned short device,
+                                             struct pnp_card *from) { return NULL; }
+static inline struct pnp_dev *pnp_find_dev(struct pnp_card *card,
+                                           unsigned short vendor,
+                                           unsigned short function,
+                                           struct pnp_dev *from) { return NULL; }
+
+#endif /* CONFIG_ISAPNP */
+
+#endif /* __KERNEL__ */
+#endif /* LINUX_ISAPNP_H */
diff --git a/include/linux/isdn.h b/include/linux/isdn.h
new file mode 100644
index 000000000000..862083eb58ab
--- /dev/null
+++ b/include/linux/isdn.h
@@ -0,0 +1,638 @@
+/* $Id: isdn.h,v 1.125.2.3 2004/02/10 01:07:14 keil Exp $
+ *
+ * Main header for the Linux ISDN subsystem (linklevel).
+ *
+ * Copyright 1994,95,96 by Fritz Elfert (fritz@isdn4linux.de)
+ * Copyright 1995,96    by Thinking Objects Software GmbH Wuerzburg
+ * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __ISDN_H__
+#define __ISDN_H__
+
+#include <linux/ioctl.h>
+
+#ifdef CONFIG_COBALT_MICRO_SERVER
+/* Save memory */
+#define ISDN_MAX_DRIVERS    2
+#define ISDN_MAX_CHANNELS   8
+#else
+#define ISDN_MAX_DRIVERS    32
+#define ISDN_MAX_CHANNELS   64
+#endif
+
+/* New ioctl-codes */
+#define IIOCNETAIF  _IO('I',1)
+#define IIOCNETDIF  _IO('I',2)
+#define IIOCNETSCF  _IO('I',3)
+#define IIOCNETGCF  _IO('I',4)
+#define IIOCNETANM  _IO('I',5)
+#define IIOCNETDNM  _IO('I',6)
+#define IIOCNETGNM  _IO('I',7)
+#define IIOCGETSET  _IO('I',8) /* no longer supported */
+#define IIOCSETSET  _IO('I',9) /* no longer supported */
+#define IIOCSETVER  _IO('I',10)
+#define IIOCNETHUP  _IO('I',11)
+#define IIOCSETGST  _IO('I',12)
+#define IIOCSETBRJ  _IO('I',13)
+#define IIOCSIGPRF  _IO('I',14)
+#define IIOCGETPRF  _IO('I',15)
+#define IIOCSETPRF  _IO('I',16)
+#define IIOCGETMAP  _IO('I',17)
+#define IIOCSETMAP  _IO('I',18)
+#define IIOCNETASL  _IO('I',19)
+#define IIOCNETDIL  _IO('I',20)
+#define IIOCGETCPS  _IO('I',21)
+#define IIOCGETDVR  _IO('I',22)
+#define IIOCNETLCR  _IO('I',23) /* dwabc ioctl for LCR from isdnlog */
+#define IIOCNETDWRSET  _IO('I',24) /* dwabc ioctl to reset abc-values to default on a net-interface */
+
+#define IIOCNETALN  _IO('I',32)
+#define IIOCNETDLN  _IO('I',33)
+
+#define IIOCNETGPN  _IO('I',34)
+
+#define IIOCDBGVAR  _IO('I',127)
+
+#define IIOCDRVCTL  _IO('I',128)
+
+/* cisco hdlck device private ioctls */
+#define SIOCGKEEPPERIOD (SIOCDEVPRIVATE + 0)
+#define SIOCSKEEPPERIOD (SIOCDEVPRIVATE + 1)
+#define SIOCGDEBSERINT  (SIOCDEVPRIVATE + 2)
+#define SIOCSDEBSERINT  (SIOCDEVPRIVATE + 3)
+
+/* Packet encapsulations for net-interfaces */
+#define ISDN_NET_ENCAP_ETHER      0
+#define ISDN_NET_ENCAP_RAWIP      1
+#define ISDN_NET_ENCAP_IPTYP      2
+#define ISDN_NET_ENCAP_CISCOHDLC  3 /* Without SLARP and keepalive */
+#define ISDN_NET_ENCAP_SYNCPPP    4
+#define ISDN_NET_ENCAP_UIHDLC     5
+#define ISDN_NET_ENCAP_CISCOHDLCK 6 /* With SLARP and keepalive    */
+#define ISDN_NET_ENCAP_X25IFACE   7 /* Documentation/networking/x25-iface.txt*/
+#define ISDN_NET_ENCAP_MAX_ENCAP  ISDN_NET_ENCAP_X25IFACE
+
+/* Facility which currently uses an ISDN-channel */
+#define ISDN_USAGE_NONE       0
+#define ISDN_USAGE_RAW        1
+#define ISDN_USAGE_MODEM      2
+#define ISDN_USAGE_NET        3
+#define ISDN_USAGE_VOICE      4
+#define ISDN_USAGE_FAX        5
+#define ISDN_USAGE_MASK       7 /* Mask to get plain usage */
+#define ISDN_USAGE_DISABLED  32 /* This bit is set, if channel is disabled */
+#define ISDN_USAGE_EXCLUSIVE 64 /* This bit is set, if channel is exclusive */
+#define ISDN_USAGE_OUTGOING 128 /* This bit is set, if channel is outgoing  */
+
+#define ISDN_MODEM_NUMREG    24        /* Number of Modem-Registers        */
+#define ISDN_LMSNLEN         255 /* Length of tty's Listen-MSN string */
+#define ISDN_CMSGLEN         50  /* Length of CONNECT-Message to add for Modem */
+
+#define ISDN_MSNLEN          32
+#define NET_DV 0x06  /* Data version for isdn_net_ioctl_cfg   */
+#define TTY_DV 0x06  /* Data version for iprofd etc.          */
+
+#define INF_DV 0x01  /* Data version for /dev/isdninfo        */
+
+typedef struct {
+  char drvid[25];
+  unsigned long arg;
+} isdn_ioctl_struct;
+
+typedef struct {
+  char name[10];
+  char phone[ISDN_MSNLEN];
+  int  outgoing;
+} isdn_net_ioctl_phone;
+
+typedef struct {
+  char name[10];     /* Name of interface                     */
+  char master[10];   /* Name of Master for Bundling           */
+  char slave[10];    /* Name of Slave for Bundling            */
+  char eaz[256];     /* EAZ/MSN                               */
+  char drvid[25];    /* DriverId for Bindings                 */
+  int  onhtime;      /* Hangup-Timeout                        */
+  int  charge;       /* Charge-Units                          */
+  int  l2_proto;     /* Layer-2 protocol                      */
+  int  l3_proto;     /* Layer-3 protocol                      */
+  int  p_encap;      /* Encapsulation                         */
+  int  exclusive;    /* Channel, if bound exclusive           */
+  int  dialmax;      /* Dial Retry-Counter                    */
+  int  slavedelay;   /* Delay until slave starts up           */
+  int  cbdelay;      /* Delay before Callback                 */
+  int  chargehup;    /* Flag: Charge-Hangup                   */
+  int  ihup;         /* Flag: Hangup-Timeout on incoming line */
+  int  secure;       /* Flag: Secure                          */
+  int  callback;     /* Flag: Callback                        */
+  int  cbhup;        /* Flag: Reject Call before Callback     */
+  int  pppbind;      /* ippp device for bindings              */
+  int  chargeint;    /* Use fixed charge interval length      */
+  int  triggercps;   /* BogoCPS needed for triggering slave   */
+  int  dialtimeout;  /* Dial-Timeout                          */
+  int  dialwait;     /* Time to wait after failed dial        */
+  int  dialmode;     /* Flag: off / on / auto                 */
+} isdn_net_ioctl_cfg;
+
+#define ISDN_NET_DIALMODE_MASK  0xC0    /* bits for status                */
+#define ISDN_NET_DM_OFF         0x00    /* this interface is stopped      */
+#define ISDN_NET_DM_MANUAL      0x40    /* this interface is on (manual)  */
+#define ISDN_NET_DM_AUTO        0x80    /* this interface is autodial     */
+#define ISDN_NET_DIALMODE(x) ((&(x))->flags & ISDN_NET_DIALMODE_MASK)
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/major.h>
+#include <asm/segment.h>
+#include <asm/io.h>
+#include <linux/kernel.h>
+#include <linux/signal.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial_reg.h>
+#include <linux/fcntl.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/ip.h>
+#include <linux/in.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/tcp.h>
+
+#define ISDN_TTY_MAJOR    43
+#define ISDN_TTYAUX_MAJOR 44
+#define ISDN_MAJOR        45
+
+/* The minor-devicenumbers for Channel 0 and 1 are used as arguments for
+ * physical Channel-Mapping, so they MUST NOT be changed without changing
+ * the correspondent code in isdn.c
+ */
+
+#define ISDN_MINOR_B        0
+#define ISDN_MINOR_BMAX     (ISDN_MAX_CHANNELS-1)
+#define ISDN_MINOR_CTRL     64
+#define ISDN_MINOR_CTRLMAX  (64 + (ISDN_MAX_CHANNELS-1))
+#define ISDN_MINOR_PPP      128
+#define ISDN_MINOR_PPPMAX   (128 + (ISDN_MAX_CHANNELS-1))
+#define ISDN_MINOR_STATUS   255
+
+#ifdef CONFIG_ISDN_PPP
+
+#ifdef CONFIG_ISDN_PPP_VJ
+#  include <net/slhc_vj.h>
+#endif
+
+#include <linux/ppp_defs.h>
+#include <linux/if_ppp.h>
+
+#include <linux/isdn_ppp.h>
+#endif
+
+#ifdef CONFIG_ISDN_X25
+#  include <linux/concap.h>
+#endif
+
+#include <linux/isdnif.h>
+
+#define ISDN_DRVIOCTL_MASK       0x7f  /* Mask for Device-ioctl */
+
+/* Until now unused */
+#define ISDN_SERVICE_VOICE 1
+#define ISDN_SERVICE_AB    1<<1 
+#define ISDN_SERVICE_X21   1<<2
+#define ISDN_SERVICE_G4    1<<3
+#define ISDN_SERVICE_BTX   1<<4
+#define ISDN_SERVICE_DFUE  1<<5
+#define ISDN_SERVICE_X25   1<<6
+#define ISDN_SERVICE_TTX   1<<7
+#define ISDN_SERVICE_MIXED 1<<8
+#define ISDN_SERVICE_FW    1<<9
+#define ISDN_SERVICE_GTEL  1<<10
+#define ISDN_SERVICE_BTXN  1<<11
+#define ISDN_SERVICE_BTEL  1<<12
+
+/* Macros checking plain usage */
+#define USG_NONE(x)         ((x & ISDN_USAGE_MASK)==ISDN_USAGE_NONE)
+#define USG_RAW(x)          ((x & ISDN_USAGE_MASK)==ISDN_USAGE_RAW)
+#define USG_MODEM(x)        ((x & ISDN_USAGE_MASK)==ISDN_USAGE_MODEM)
+#define USG_VOICE(x)        ((x & ISDN_USAGE_MASK)==ISDN_USAGE_VOICE)
+#define USG_NET(x)          ((x & ISDN_USAGE_MASK)==ISDN_USAGE_NET)
+#define USG_FAX(x)          ((x & ISDN_USAGE_MASK)==ISDN_USAGE_FAX)
+#define USG_OUTGOING(x)     ((x & ISDN_USAGE_OUTGOING)==ISDN_USAGE_OUTGOING)
+#define USG_MODEMORVOICE(x) (((x & ISDN_USAGE_MASK)==ISDN_USAGE_MODEM) || \
+                             ((x & ISDN_USAGE_MASK)==ISDN_USAGE_VOICE)     )
+
+/* Timer-delays and scheduling-flags */
+#define ISDN_TIMER_RES         4                         /* Main Timer-Resolution   */
+#define ISDN_TIMER_02SEC       (HZ/ISDN_TIMER_RES/5)     /* Slow-Timer1 .2 sec      */
+#define ISDN_TIMER_1SEC        (HZ/ISDN_TIMER_RES)       /* Slow-Timer2 1 sec       */
+#define ISDN_TIMER_RINGING     5 /* tty RINGs = ISDN_TIMER_1SEC * this factor       */
+#define ISDN_TIMER_KEEPINT    10 /* Cisco-Keepalive = ISDN_TIMER_1SEC * this factor */
+#define ISDN_TIMER_MODEMREAD   1
+#define ISDN_TIMER_MODEMPLUS   2
+#define ISDN_TIMER_MODEMRING   4
+#define ISDN_TIMER_MODEMXMIT   8
+#define ISDN_TIMER_NETDIAL    16 
+#define ISDN_TIMER_NETHANGUP  32
+#define ISDN_TIMER_CARRIER   256 /* Wait for Carrier */
+#define ISDN_TIMER_FAST      (ISDN_TIMER_MODEMREAD | ISDN_TIMER_MODEMPLUS | \
+                              ISDN_TIMER_MODEMXMIT)
+#define ISDN_TIMER_SLOW      (ISDN_TIMER_MODEMRING | ISDN_TIMER_NETHANGUP | \
+                              ISDN_TIMER_NETDIAL | ISDN_TIMER_CARRIER)
+
+/* Timeout-Values for isdn_net_dial() */
+#define ISDN_TIMER_DTIMEOUT10 (10*HZ/(ISDN_TIMER_02SEC*(ISDN_TIMER_RES+1)))
+#define ISDN_TIMER_DTIMEOUT15 (15*HZ/(ISDN_TIMER_02SEC*(ISDN_TIMER_RES+1)))
+#define ISDN_TIMER_DTIMEOUT60 (60*HZ/(ISDN_TIMER_02SEC*(ISDN_TIMER_RES+1)))
+
+/* GLOBAL_FLAGS */
+#define ISDN_GLOBAL_STOPPED 1
+
+/*=================== Start of ip-over-ISDN stuff =========================*/
+
+/* Feature- and status-flags for a net-interface */
+#define ISDN_NET_CONNECTED  0x01       /* Bound to ISDN-Channel             */
+#define ISDN_NET_SECURE     0x02       /* Accept calls from phonelist only  */
+#define ISDN_NET_CALLBACK   0x04       /* activate callback                 */
+#define ISDN_NET_CBHUP      0x08       /* hangup before callback            */
+#define ISDN_NET_CBOUT      0x10       /* remote machine does callback      */
+
+#define ISDN_NET_MAGIC      0x49344C02 /* for paranoia-checking             */
+
+/* Phone-list-element */
+typedef struct {
+  void *next;
+  char num[ISDN_MSNLEN];
+} isdn_net_phone;
+
+/*
+   Principles when extending structures for generic encapsulation protocol
+   ("concap") support:
+   - Stuff which is hardware specific (here i4l-specific) goes in 
+     the netdev -> local structure (here: isdn_net_local)
+   - Stuff which is encapsulation protocol specific goes in the structure
+     which holds the linux device structure (here: isdn_net_device)
+*/
+
+/* Local interface-data */
+typedef struct isdn_net_local_s {
+  ulong                  magic;
+  char                   name[10];     /* Name of device                   */
+  struct net_device_stats stats;       /* Ethernet Statistics              */
+  int                    isdn_device;  /* Index to isdn-device             */
+  int                    isdn_channel; /* Index to isdn-channel            */
+  int                    ppp_slot;     /* PPPD device slot number          */
+  int                    pre_device;   /* Preselected isdn-device          */
+  int                    pre_channel;  /* Preselected isdn-channel         */
+  int                    exclusive;    /* If non-zero idx to reserved chan.*/
+  int                    flags;        /* Connection-flags                 */
+  int                    dialretry;    /* Counter for Dialout-retries      */
+  int                    dialmax;      /* Max. Number of Dial-retries      */
+  int                    cbdelay;      /* Delay before Callback starts     */
+  int                    dtimer;       /* Timeout-counter for dialing      */
+  char                   msn[ISDN_MSNLEN]; /* MSNs/EAZs for this interface */
+  u_char                 cbhup;        /* Flag: Reject Call before Callback*/
+  u_char                 dialstate;    /* State for dialing                */
+  u_char                 p_encap;      /* Packet encapsulation             */
+                                       /*   0 = Ethernet over ISDN         */
+                                       /*   1 = RAW-IP                     */
+                                       /*   2 = IP with type field         */
+  u_char                 l2_proto;     /* Layer-2-protocol                 */
+                                       /* See ISDN_PROTO_L2..-constants in */
+                                       /* isdnif.h                         */
+                                       /*   0 = X75/LAPB with I-Frames     */
+                                       /*   1 = X75/LAPB with UI-Frames    */
+                                       /*   2 = X75/LAPB with BUI-Frames   */
+                                       /*   3 = HDLC                       */
+  u_char                 l3_proto;     /* Layer-3-protocol                 */
+                                       /* See ISDN_PROTO_L3..-constants in */
+                                       /* isdnif.h                         */
+                                       /*   0 = Transparent                */
+  int                    huptimer;     /* Timeout-counter for auto-hangup  */
+  int                    charge;       /* Counter for charging units       */
+  ulong                  chargetime;   /* Timer for Charging info          */
+  int                    hupflags;     /* Flags for charge-unit-hangup:    */
+                                       /* bit0: chargeint is invalid       */
+                                       /* bit1: Getting charge-interval    */
+                                       /* bit2: Do charge-unit-hangup      */
+                                       /* bit3: Do hangup even on incoming */
+  int                    outgoing;     /* Flag: outgoing call              */
+  int                    onhtime;      /* Time to keep link up             */
+  int                    chargeint;    /* Interval between charge-infos    */
+  int                    onum;         /* Flag: at least 1 outgoing number */
+  int                    cps;          /* current speed of this interface  */
+  int                    transcount;   /* byte-counter for cps-calculation */
+  int                    sqfull;       /* Flag: netdev-queue overloaded    */
+  ulong                  sqfull_stamp; /* Start-Time of overload           */
+  ulong                  slavedelay;   /* Dynamic bundling delaytime       */
+  int                    triggercps;   /* BogoCPS needed for trigger slave */
+  isdn_net_phone         *phone[2];    /* List of remote-phonenumbers      */
+                                       /* phone[0] = Incoming Numbers      */
+                                       /* phone[1] = Outgoing Numbers      */
+  isdn_net_phone         *dial;        /* Pointer to dialed number         */
+  struct net_device      *master;      /* Ptr to Master device for slaves  */
+  struct net_device      *slave;       /* Ptr to Slave device for masters  */
+  struct isdn_net_local_s *next;       /* Ptr to next link in bundle       */
+  struct isdn_net_local_s *last;       /* Ptr to last link in bundle       */
+  struct isdn_net_dev_s  *netdev;      /* Ptr to netdev                    */
+  struct sk_buff_head    super_tx_queue; /* List of supervisory frames to  */
+                                       /* be transmitted asap              */
+  atomic_t frame_cnt;                  /* number of frames currently       */
+                                       /* queued in HL driver              */    
+                                       /* Ptr to orig. hard_header_cache   */
+  spinlock_t             xmit_lock;    /* used to protect the xmit path of */
+                                       /* a particular channel (including  */
+                                       /* the frame_cnt                    */
+
+  int                    (*org_hhc)(
+                                    struct neighbour *neigh,
+                                    struct hh_cache *hh);
+                                       /* Ptr to orig. header_cache_update */
+  void                   (*org_hcu)(struct hh_cache *,
+                                    struct net_device *,
+                                    unsigned char *);
+  int  pppbind;                        /* ippp device for bindings         */
+  int                                   dialtimeout;    /* How long shall we try on dialing? (jiffies) */
+  int                                   dialwait;               /* How long shall we wait after failed attempt? (jiffies) */
+  ulong                                 dialstarted;    /* jiffies of first dialing-attempt */
+  ulong                                 dialwait_timer; /* jiffies of earliest next dialing-attempt */
+  int                                   huptimeout;             /* How long will the connection be up? (seconds) */
+#ifdef CONFIG_ISDN_X25
+  struct concap_device_ops *dops;      /* callbacks used by encapsulator   */
+#endif
+  /* use an own struct for that in later versions */
+  ulong cisco_myseq;                   /* Local keepalive seq. for Cisco   */
+  ulong cisco_mineseen;                /* returned keepalive seq. from remote */
+  ulong cisco_yourseq;                 /* Remote keepalive seq. for Cisco  */
+  int cisco_keepalive_period;           /* keepalive period */
+  ulong cisco_last_slarp_in;            /* jiffie of last keepalive packet we received */
+  char cisco_line_state;                /* state of line according to keepalive packets */
+  char cisco_debserint;                 /* debugging flag of cisco hdlc with slarp */
+  struct timer_list cisco_timer;
+  struct work_struct tqueue;
+} isdn_net_local;
+
+/* the interface itself */
+typedef struct isdn_net_dev_s {
+  isdn_net_local *local;
+  isdn_net_local *queue;               /* circular list of all bundled
+                                          channels, which are currently
+                                          online                           */
+  spinlock_t queue_lock;               /* lock to protect queue            */
+  void *next;                          /* Pointer to next isdn-interface   */
+  struct net_device dev;               /* interface to upper levels        */
+#ifdef CONFIG_ISDN_PPP
+  ippp_bundle * pb;             /* pointer to the common bundle structure
+                                 * with the per-bundle data */
+#endif
+#ifdef CONFIG_ISDN_X25
+  struct concap_proto  *cprot; /* connection oriented encapsulation protocol */
+#endif
+
+} isdn_net_dev;
+
+/*===================== End of ip-over-ISDN stuff ===========================*/
+
+/*======================= Start of ISDN-tty stuff ===========================*/
+
+#define ISDN_ASYNC_MAGIC          0x49344C01 /* for paranoia-checking        */
+#define ISDN_ASYNC_INITIALIZED    0x80000000 /* port was initialized         */
+#define ISDN_ASYNC_CALLOUT_ACTIVE 0x40000000 /* Call out device active       */
+#define ISDN_ASYNC_NORMAL_ACTIVE  0x20000000 /* Normal device active         */
+#define ISDN_ASYNC_CLOSING        0x08000000 /* Serial port is closing       */
+#define ISDN_ASYNC_CTS_FLOW       0x04000000 /* Do CTS flow control          */
+#define ISDN_ASYNC_CHECK_CD       0x02000000 /* i.e., CLOCAL                 */
+#define ISDN_ASYNC_HUP_NOTIFY         0x0001 /* Notify tty on hangups/closes */
+#define ISDN_ASYNC_SESSION_LOCKOUT    0x0100 /* Lock cua opens on session    */
+#define ISDN_ASYNC_PGRP_LOCKOUT       0x0200 /* Lock cua opens on pgrp       */
+#define ISDN_ASYNC_CALLOUT_NOHUP      0x0400 /* No hangup for cui            */
+#define ISDN_ASYNC_SPLIT_TERMIOS      0x0008 /* Sep. termios for dialin/out  */
+#define ISDN_SERIAL_XMIT_SIZE           1024 /* Default bufsize for write    */
+#define ISDN_SERIAL_XMIT_MAX            4000 /* Maximum bufsize for write    */
+#define ISDN_SERIAL_TYPE_NORMAL            1
+#define ISDN_SERIAL_TYPE_CALLOUT           2
+
+#ifdef CONFIG_ISDN_AUDIO
+/* For using sk_buffs with audio we need some private variables
+ * within each sk_buff. For this purpose, we declare a struct here,
+ * and put it always at the private skb->cb data array. A few macros help
+ * accessing the variables.
+ */
+typedef struct _isdn_audio_data {
+  unsigned short dle_count;
+  unsigned char  lock;
+} isdn_audio_data_t;
+
+#define ISDN_AUDIO_SKB_DLECOUNT(skb)    (((isdn_audio_data_t *)&skb->cb[0])->dle_count)
+#define ISDN_AUDIO_SKB_LOCK(skb)        (((isdn_audio_data_t *)&skb->cb[0])->lock)
+#endif
+
+/* Private data of AT-command-interpreter */
+typedef struct atemu {
+        u_char       profile[ISDN_MODEM_NUMREG]; /* Modem-Regs. Profile 0              */
+        u_char       mdmreg[ISDN_MODEM_NUMREG];  /* Modem-Registers                    */
+        char         pmsn[ISDN_MSNLEN];          /* EAZ/MSNs Profile 0                 */
+        char         msn[ISDN_MSNLEN];           /* EAZ/MSN                            */
+        char         plmsn[ISDN_LMSNLEN];        /* Listening MSNs Profile 0           */
+        char         lmsn[ISDN_LMSNLEN];         /* Listening MSNs                     */
+        char         cpn[ISDN_MSNLEN];           /* CalledPartyNumber on incoming call */
+        char         connmsg[ISDN_CMSGLEN];      /* CONNECT-Msg from HL-Driver         */
+#ifdef CONFIG_ISDN_AUDIO
+        u_char       vpar[10];                   /* Voice-parameters                   */
+        int          lastDLE;                    /* Flag for voice-coding: DLE seen    */
+#endif
+        int          mdmcmdl;                    /* Length of Modem-Commandbuffer      */
+        int          pluscount;                  /* Counter for +++ sequence           */
+        u_long       lastplus;                   /* Timestamp of last +                */
+        int          carrierwait;                /* Seconds of carrier waiting         */
+        char         mdmcmd[255];                /* Modem-Commandbuffer                */
+        unsigned int charge;                     /* Charge units of current connection */
+} atemu;
+
+/* Private data (similar to async_struct in <linux/serial.h>) */
+typedef struct modem_info {
+  int                   magic;
+  struct module         *owner;
+  int                   flags;           /* defined in tty.h               */
+  int                   x_char;          /* xon/xoff character             */
+  int                   mcr;             /* Modem control register         */
+  int                   msr;             /* Modem status register          */
+  int                   lsr;             /* Line status register           */
+  int                   line;
+  int                   count;           /* # of fd on device              */
+  int                   blocked_open;    /* # of blocked opens             */
+  long                  session;         /* Session of opening process     */
+  long                  pgrp;            /* pgrp of opening process        */
+  int                   online;          /* 1 = B-Channel is up, drop data */
+                                         /* 2 = B-Channel is up, deliver d.*/
+  int                   dialing;         /* Dial in progress or ATA        */
+  int                   rcvsched;        /* Receive needs schedule         */
+  int                   isdn_driver;     /* Index to isdn-driver           */
+  int                   isdn_channel;    /* Index to isdn-channel          */
+  int                   drv_index;       /* Index to dev->usage            */
+  int                   ncarrier;        /* Flag: schedule NO CARRIER      */
+  unsigned char         last_cause[8];   /* Last cause message             */
+  unsigned char         last_num[ISDN_MSNLEN];
+                                         /* Last phone-number              */
+  unsigned char         last_l2;         /* Last layer-2 protocol          */
+  unsigned char         last_si;         /* Last service                   */
+  unsigned char         last_lhup;       /* Last hangup local?             */
+  unsigned char         last_dir;        /* Last direction (in or out)     */
+  struct timer_list     nc_timer;        /* Timer for delayed NO CARRIER   */
+  int                   send_outstanding;/* # of outstanding send-requests */
+  int                   xmit_size;       /* max. # of chars in xmit_buf    */
+  int                   xmit_count;      /* # of chars in xmit_buf         */
+  unsigned char         *xmit_buf;       /* transmit buffer                */
+  struct sk_buff_head   xmit_queue;      /* transmit queue                 */
+  atomic_t              xmit_lock;       /* Semaphore for isdn_tty_write   */
+#ifdef CONFIG_ISDN_AUDIO
+  int                   vonline;         /* Voice-channel status           */
+                                         /* Bit 0 = recording              */
+                                         /* Bit 1 = playback               */
+                                         /* Bit 2 = playback, DLE-ETX seen */
+  struct sk_buff_head   dtmf_queue;      /* queue for dtmf results         */
+  void                  *adpcms;         /* state for adpcm decompression  */
+  void                  *adpcmr;         /* state for adpcm compression    */
+  void                  *dtmf_state;     /* state for dtmf decoder         */
+  void                  *silence_state;  /* state for silence detection    */
+#endif
+#ifdef CONFIG_ISDN_TTY_FAX
+  struct T30_s          *fax;            /* T30 Fax Group 3 data/interface */
+  int                   faxonline;       /* Fax-channel status             */
+#endif
+  struct tty_struct     *tty;            /* Pointer to corresponding tty   */
+  atemu                 emu;             /* AT-emulator data               */
+  struct termios        normal_termios;  /* For saving termios structs     */
+  struct termios        callout_termios;
+  wait_queue_head_t     open_wait, close_wait;
+  struct semaphore      write_sem;
+  spinlock_t            readlock;
+} modem_info;
+
+#define ISDN_MODEM_WINSIZE 8
+
+/* Description of one ISDN-tty */
+typedef struct _isdn_modem {
+  int                refcount;                          /* Number of opens        */
+  struct tty_driver  *tty_modem;                        /* tty-device             */
+  struct tty_struct  *modem_table[ISDN_MAX_CHANNELS];   /* ?? copied from Orig    */
+  struct termios     *modem_termios[ISDN_MAX_CHANNELS];
+  struct termios     *modem_termios_locked[ISDN_MAX_CHANNELS];
+  modem_info         info[ISDN_MAX_CHANNELS];      /* Private data           */
+} isdn_modem_t;
+
+/*======================= End of ISDN-tty stuff ============================*/
+
+/*======================== Start of V.110 stuff ============================*/
+#define V110_BUFSIZE 1024
+
+typedef struct {
+        int nbytes;                    /* 1 Matrixbyte -> nbytes in stream     */
+        int nbits;                     /* Number of used bits in streambyte    */
+        unsigned char key;             /* Bitmask in stream eg. 11 (nbits=2)   */
+        int decodelen;                 /* Amount of data in decodebuf          */
+        int SyncInit;                  /* Number of sync frames to send        */
+        unsigned char *OnlineFrame;    /* Precalculated V110 idle frame        */
+        unsigned char *OfflineFrame;   /* Precalculated V110 sync Frame        */
+        int framelen;                  /* Length of frames                     */
+        int skbuser;                   /* Number of unacked userdata skbs      */
+        int skbidle;                   /* Number of unacked idle/sync skbs     */
+        int introducer;                /* Local vars for decoder               */
+        int dbit;
+        unsigned char b;
+        int skbres;                    /* space to reserve in outgoing skb     */
+        int maxsize;                   /* maxbufsize of lowlevel driver        */
+        unsigned char *encodebuf;      /* temporary buffer for encoding        */
+        unsigned char decodebuf[V110_BUFSIZE]; /* incomplete V110 matrices     */
+} isdn_v110_stream;
+
+/*========================= End of V.110 stuff =============================*/
+
+/*======================= Start of general stuff ===========================*/
+
+typedef struct {
+        char *next;
+        char *private;
+} infostruct;
+
+#define DRV_FLAG_RUNNING 1
+#define DRV_FLAG_REJBUS  2
+#define DRV_FLAG_LOADED  4
+
+/* Description of hardware-level-driver */
+typedef struct _isdn_driver {
+        ulong               online;           /* Channel-Online flags             */
+        ulong               flags;            /* Misc driver Flags                */
+        int                 locks;            /* Number of locks for this driver  */
+        int                 channels;         /* Number of channels               */
+        wait_queue_head_t   st_waitq;         /* Wait-Queue for status-read's     */
+        int                 maxbufsize;       /* Maximum Buffersize supported     */
+        unsigned long       pktcount;         /* Until now: unused                */
+        int                 stavail;          /* Chars avail on Status-device     */
+        isdn_if            *interface;        /* Interface to driver              */
+        int                *rcverr;           /* Error-counters for B-Ch.-receive */
+        int                *rcvcount;         /* Byte-counters for B-Ch.-receive  */
+#ifdef CONFIG_ISDN_AUDIO
+        unsigned long      DLEflag;           /* Flags: Insert DLE at next read   */
+#endif
+        struct sk_buff_head *rpqueue;         /* Pointers to start of Rcv-Queue   */
+        wait_queue_head_t  *rcv_waitq;       /* Wait-Queues for B-Channel-Reads  */
+        wait_queue_head_t  *snd_waitq;       /* Wait-Queue for B-Channel-Send's  */
+        char               msn2eaz[10][ISDN_MSNLEN];  /* Mapping-Table MSN->EAZ   */
+} isdn_driver_t;
+
+/* Main driver-data */
+typedef struct isdn_devt {
+        struct module     *owner;
+        spinlock_t        lock;
+        unsigned short    flags;                      /* Bitmapped Flags:           */
+        int               drivers;                    /* Current number of drivers  */
+        int               channels;                   /* Current number of channels */
+        int               net_verbose;                /* Verbose-Flag               */
+        int               modempoll;                  /* Flag: tty-read active      */
+        spinlock_t        timerlock;
+        int               tflags;                     /* Timer-Flags:               */
+        /*  see ISDN_TIMER_..defines  */
+        int               global_flags;
+        infostruct        *infochain;                 /* List of open info-devs.    */
+        wait_queue_head_t info_waitq;                 /* Wait-Queue for isdninfo    */
+        struct timer_list timer;                      /* Misc.-function Timer       */
+        int               chanmap[ISDN_MAX_CHANNELS]; /* Map minor->device-channel  */
+        int               drvmap[ISDN_MAX_CHANNELS];  /* Map minor->driver-index    */
+        int               usage[ISDN_MAX_CHANNELS];   /* Used by tty/ip/voice       */
+        char              num[ISDN_MAX_CHANNELS][ISDN_MSNLEN];
+        /* Remote number of active ch.*/
+        int               m_idx[ISDN_MAX_CHANNELS];   /* Index for mdm....          */
+        isdn_driver_t     *drv[ISDN_MAX_DRIVERS];     /* Array of drivers           */
+        isdn_net_dev      *netdev;                    /* Linked list of net-if's    */
+        char              drvid[ISDN_MAX_DRIVERS][20];/* Driver-ID                 */
+        struct task_struct *profd;                    /* For iprofd                 */
+        isdn_modem_t      mdm;                        /* tty-driver-data            */
+        isdn_net_dev      *rx_netdev[ISDN_MAX_CHANNELS]; /* rx netdev-pointers     */
+        isdn_net_dev      *st_netdev[ISDN_MAX_CHANNELS]; /* stat netdev-pointers   */
+        ulong             ibytes[ISDN_MAX_CHANNELS];  /* Statistics incoming bytes  */
+        ulong             obytes[ISDN_MAX_CHANNELS];  /* Statistics outgoing bytes  */
+        int               v110emu[ISDN_MAX_CHANNELS]; /* V.110 emulator-mode 0=none */
+        atomic_t          v110use[ISDN_MAX_CHANNELS]; /* Usage-Semaphore for stream */
+        isdn_v110_stream  *v110[ISDN_MAX_CHANNELS];   /* V.110 private data         */
+        struct semaphore  sem;                        /* serialize list access*/
+        unsigned long     global_features;
+} isdn_dev;
+
+extern isdn_dev *dev;
+
+
+#endif /* __KERNEL__ */
+
+#endif /* __ISDN_H__ */
diff --git a/include/linux/isdn/capicmd.h b/include/linux/isdn/capicmd.h
new file mode 100644
index 000000000000..b58635f722da
--- /dev/null
+++ b/include/linux/isdn/capicmd.h
@@ -0,0 +1,115 @@
+/* $Id: capicmd.h,v 1.2.6.2 2001/09/23 22:24:33 kai Exp $
+ * 
+ * CAPI 2.0 Interface for Linux
+ * 
+ * Copyright 1997 by Carsten Paeth <calle@calle.de>
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __CAPICMD_H__
+#define __CAPICMD_H__
+
+#define CAPI_MSG_BASELEN                8
+#define CAPI_DATA_B3_REQ_LEN            (CAPI_MSG_BASELEN+4+4+2+2+2)
+#define CAPI_DATA_B3_RESP_LEN           (CAPI_MSG_BASELEN+4+2)
+
+/*----- CAPI commands -----*/
+#define CAPI_ALERT                  0x01
+#define CAPI_CONNECT                0x02
+#define CAPI_CONNECT_ACTIVE         0x03
+#define CAPI_CONNECT_B3_ACTIVE      0x83
+#define CAPI_CONNECT_B3             0x82
+#define CAPI_CONNECT_B3_T90_ACTIVE  0x88
+#define CAPI_DATA_B3                0x86
+#define CAPI_DISCONNECT_B3          0x84
+#define CAPI_DISCONNECT             0x04
+#define CAPI_FACILITY               0x80
+#define CAPI_INFO                   0x08
+#define CAPI_LISTEN                 0x05
+#define CAPI_MANUFACTURER           0xff
+#define CAPI_RESET_B3               0x87
+#define CAPI_SELECT_B_PROTOCOL      0x41
+
+/*----- CAPI subcommands -----*/
+
+#define CAPI_REQ    0x80
+#define CAPI_CONF   0x81
+#define CAPI_IND    0x82
+#define CAPI_RESP   0x83
+
+/*----- CAPI combined commands -----*/
+
+#define CAPICMD(cmd,subcmd)     (((cmd)<<8)|(subcmd))
+
+#define CAPI_DISCONNECT_REQ             CAPICMD(CAPI_DISCONNECT,CAPI_REQ)
+#define CAPI_DISCONNECT_CONF            CAPICMD(CAPI_DISCONNECT,CAPI_CONF)
+#define CAPI_DISCONNECT_IND             CAPICMD(CAPI_DISCONNECT,CAPI_IND)
+#define CAPI_DISCONNECT_RESP            CAPICMD(CAPI_DISCONNECT,CAPI_RESP)
+
+#define CAPI_ALERT_REQ                  CAPICMD(CAPI_ALERT,CAPI_REQ)
+#define CAPI_ALERT_CONF                 CAPICMD(CAPI_ALERT,CAPI_CONF)
+
+#define CAPI_CONNECT_REQ                CAPICMD(CAPI_CONNECT,CAPI_REQ)
+#define CAPI_CONNECT_CONF               CAPICMD(CAPI_CONNECT,CAPI_CONF)
+#define CAPI_CONNECT_IND                CAPICMD(CAPI_CONNECT,CAPI_IND)
+#define CAPI_CONNECT_RESP               CAPICMD(CAPI_CONNECT,CAPI_RESP)
+
+#define CAPI_CONNECT_ACTIVE_REQ         CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_REQ)
+#define CAPI_CONNECT_ACTIVE_CONF        CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_CONF)
+#define CAPI_CONNECT_ACTIVE_IND         CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_IND)
+#define CAPI_CONNECT_ACTIVE_RESP        CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_RESP)
+
+#define CAPI_SELECT_B_PROTOCOL_REQ      CAPICMD(CAPI_SELECT_B_PROTOCOL,CAPI_REQ)
+#define CAPI_SELECT_B_PROTOCOL_CONF     CAPICMD(CAPI_SELECT_B_PROTOCOL,CAPI_CONF)
+
+#define CAPI_CONNECT_B3_ACTIVE_REQ      CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_REQ)
+#define CAPI_CONNECT_B3_ACTIVE_CONF     CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_CONF)
+#define CAPI_CONNECT_B3_ACTIVE_IND      CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_IND)
+#define CAPI_CONNECT_B3_ACTIVE_RESP     CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_RESP)
+
+#define CAPI_CONNECT_B3_REQ             CAPICMD(CAPI_CONNECT_B3,CAPI_REQ)
+#define CAPI_CONNECT_B3_CONF            CAPICMD(CAPI_CONNECT_B3,CAPI_CONF)
+#define CAPI_CONNECT_B3_IND             CAPICMD(CAPI_CONNECT_B3,CAPI_IND)
+#define CAPI_CONNECT_B3_RESP            CAPICMD(CAPI_CONNECT_B3,CAPI_RESP)
+
+
+#define CAPI_CONNECT_B3_T90_ACTIVE_IND  CAPICMD(CAPI_CONNECT_B3_T90_ACTIVE,CAPI_IND)
+#define CAPI_CONNECT_B3_T90_ACTIVE_RESP CAPICMD(CAPI_CONNECT_B3_T90_ACTIVE,CAPI_RESP)
+
+#define CAPI_DATA_B3_REQ                CAPICMD(CAPI_DATA_B3,CAPI_REQ)
+#define CAPI_DATA_B3_CONF               CAPICMD(CAPI_DATA_B3,CAPI_CONF)
+#define CAPI_DATA_B3_IND                CAPICMD(CAPI_DATA_B3,CAPI_IND)
+#define CAPI_DATA_B3_RESP               CAPICMD(CAPI_DATA_B3,CAPI_RESP)
+
+#define CAPI_DISCONNECT_B3_REQ          CAPICMD(CAPI_DISCONNECT_B3,CAPI_REQ)
+#define CAPI_DISCONNECT_B3_CONF         CAPICMD(CAPI_DISCONNECT_B3,CAPI_CONF)
+#define CAPI_DISCONNECT_B3_IND          CAPICMD(CAPI_DISCONNECT_B3,CAPI_IND)
+#define CAPI_DISCONNECT_B3_RESP         CAPICMD(CAPI_DISCONNECT_B3,CAPI_RESP)
+
+#define CAPI_RESET_B3_REQ               CAPICMD(CAPI_RESET_B3,CAPI_REQ)
+#define CAPI_RESET_B3_CONF              CAPICMD(CAPI_RESET_B3,CAPI_CONF)
+#define CAPI_RESET_B3_IND               CAPICMD(CAPI_RESET_B3,CAPI_IND)
+#define CAPI_RESET_B3_RESP              CAPICMD(CAPI_RESET_B3,CAPI_RESP)
+
+#define CAPI_LISTEN_REQ                 CAPICMD(CAPI_LISTEN,CAPI_REQ)
+#define CAPI_LISTEN_CONF                CAPICMD(CAPI_LISTEN,CAPI_CONF)
+
+#define CAPI_MANUFACTURER_REQ           CAPICMD(CAPI_MANUFACTURER,CAPI_REQ)
+#define CAPI_MANUFACTURER_CONF          CAPICMD(CAPI_MANUFACTURER,CAPI_CONF)
+#define CAPI_MANUFACTURER_IND           CAPICMD(CAPI_MANUFACTURER,CAPI_IND)
+#define CAPI_MANUFACTURER_RESP          CAPICMD(CAPI_MANUFACTURER,CAPI_RESP)
+
+#define CAPI_FACILITY_REQ               CAPICMD(CAPI_FACILITY,CAPI_REQ)
+#define CAPI_FACILITY_CONF              CAPICMD(CAPI_FACILITY,CAPI_CONF)
+#define CAPI_FACILITY_IND               CAPICMD(CAPI_FACILITY,CAPI_IND)
+#define CAPI_FACILITY_RESP              CAPICMD(CAPI_FACILITY,CAPI_RESP)
+
+#define CAPI_INFO_REQ                   CAPICMD(CAPI_INFO,CAPI_REQ)
+#define CAPI_INFO_CONF                  CAPICMD(CAPI_INFO,CAPI_CONF)
+#define CAPI_INFO_IND                   CAPICMD(CAPI_INFO,CAPI_IND)
+#define CAPI_INFO_RESP                  CAPICMD(CAPI_INFO,CAPI_RESP)
+
+#endif                          /* __CAPICMD_H__ */
diff --git a/include/linux/isdn/capilli.h b/include/linux/isdn/capilli.h
new file mode 100644
index 000000000000..35e9b0fd014b
--- /dev/null
+++ b/include/linux/isdn/capilli.h
@@ -0,0 +1,113 @@
+/* $Id: capilli.h,v 1.1.2.2 2004/01/16 21:09:27 keil Exp $
+ * 
+ * Kernel CAPI 2.0 Driver Interface for Linux
+ * 
+ * Copyright 1999 by Carsten Paeth <calle@calle.de>
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __CAPILLI_H__
+#define __CAPILLI_H__
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/capi.h>
+#include <linux/kernelcapi.h>
+
+typedef struct capiloaddatapart {
+        int user;               /* data in userspace ? */
+        int len;
+        unsigned char *data;
+} capiloaddatapart;
+
+typedef struct capiloaddata {
+        capiloaddatapart firmware;
+        capiloaddatapart configuration;
+} capiloaddata;
+
+typedef struct capicardparams {
+        unsigned int port;
+        unsigned irq;
+        int cardtype;
+        int cardnr;
+        unsigned int membase;
+} capicardparams;
+
+struct capi_ctr {
+        /* filled in before calling attach_capi_ctr */
+        struct module *owner;
+        void *driverdata;                       /* driver specific */
+        char name[32];                          /* name of controller */
+        char *driver_name;                      /* name of driver */
+        int (*load_firmware)(struct capi_ctr *, capiloaddata *);
+        void (*reset_ctr)(struct capi_ctr *);
+        void (*register_appl)(struct capi_ctr *, u16 appl,
+                              capi_register_params *);
+        void (*release_appl)(struct capi_ctr *, u16 appl);
+        u16  (*send_message)(struct capi_ctr *, struct sk_buff *skb);
+        
+        char *(*procinfo)(struct capi_ctr *);
+        int (*ctr_read_proc)(char *page, char **start, off_t off,
+                             int count, int *eof, struct capi_ctr *card);
+
+        /* filled in before calling ready callback */
+        u8 manu[CAPI_MANUFACTURER_LEN];         /* CAPI_GET_MANUFACTURER */
+        capi_version version;                   /* CAPI_GET_VERSION */
+        capi_profile profile;                   /* CAPI_GET_PROFILE */
+        u8 serial[CAPI_SERIAL_LEN];             /* CAPI_GET_SERIAL */
+
+        /* management information for kcapi */
+
+        unsigned long nrecvctlpkt;
+        unsigned long nrecvdatapkt;
+        unsigned long nsentctlpkt;
+        unsigned long nsentdatapkt;
+
+        int cnr;                                /* controller number */
+        volatile unsigned short cardstate;      /* controller state */
+        volatile int blocked;                   /* output blocked */
+        int traceflag;                          /* capi trace */
+
+        struct proc_dir_entry *procent;
+        char procfn[128];
+};
+
+int attach_capi_ctr(struct capi_ctr *);
+int detach_capi_ctr(struct capi_ctr *);
+
+void capi_ctr_ready(struct capi_ctr * card);
+void capi_ctr_reseted(struct capi_ctr * card);
+void capi_ctr_suspend_output(struct capi_ctr * card);
+void capi_ctr_resume_output(struct capi_ctr * card);
+void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb);
+
+// ---------------------------------------------------------------------------
+// needed for AVM capi drivers
+
+struct capi_driver {
+        char name[32];                          /* driver name */
+        char revision[32];
+
+        int (*add_card)(struct capi_driver *driver, capicardparams *data);
+
+        /* management information for kcapi */
+        struct list_head list; 
+};
+
+void register_capi_driver(struct capi_driver *driver);
+void unregister_capi_driver(struct capi_driver *driver);
+
+// ---------------------------------------------------------------------------
+// library functions for use by hardware controller drivers
+
+void capilib_new_ncci(struct list_head *head, u16 applid, u32 ncci, u32 winsize);
+void capilib_free_ncci(struct list_head *head, u16 applid, u32 ncci);
+void capilib_release_appl(struct list_head *head, u16 applid);
+void capilib_release(struct list_head *head);
+void capilib_data_b3_conf(struct list_head *head, u16 applid, u32 ncci, u16 msgid);
+u16  capilib_data_b3_req(struct list_head *head, u16 applid, u32 ncci, u16 msgid);
+
+#endif                          /* __CAPILLI_H__ */
diff --git a/include/linux/isdn/capiutil.h b/include/linux/isdn/capiutil.h
new file mode 100644
index 000000000000..2e79f816703b
--- /dev/null
+++ b/include/linux/isdn/capiutil.h
@@ -0,0 +1,505 @@
+/* $Id: capiutil.h,v 1.5.6.2 2001/09/23 22:24:33 kai Exp $
+ *
+ * CAPI 2.0 defines & types
+ *
+ * From CAPI 2.0 Development Kit AVM 1995 (msg.c)
+ * Rewritten for Linux 1996 by Carsten Paeth <calle@calle.de>
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __CAPIUTIL_H__
+#define __CAPIUTIL_H__
+
+#include <asm/types.h>
+
+#define CAPIMSG_BASELEN         8
+#define CAPIMSG_U8(m, off)      (m[off])
+#define CAPIMSG_U16(m, off)     (m[off]|(m[(off)+1]<<8))
+#define CAPIMSG_U32(m, off)     (m[off]|(m[(off)+1]<<8)|(m[(off)+2]<<16)|(m[(off)+3]<<24))
+#define CAPIMSG_LEN(m)          CAPIMSG_U16(m,0)
+#define CAPIMSG_APPID(m)        CAPIMSG_U16(m,2)
+#define CAPIMSG_COMMAND(m)      CAPIMSG_U8(m,4)
+#define CAPIMSG_SUBCOMMAND(m)   CAPIMSG_U8(m,5)
+#define CAPIMSG_CMD(m)          (((m[4])<<8)|(m[5]))
+#define CAPIMSG_MSGID(m)        CAPIMSG_U16(m,6)
+#define CAPIMSG_CONTROLLER(m)   (m[8] & 0x7f)
+#define CAPIMSG_CONTROL(m)      CAPIMSG_U32(m, 8)
+#define CAPIMSG_NCCI(m)         CAPIMSG_CONTROL(m)
+#define CAPIMSG_DATALEN(m)      CAPIMSG_U16(m,16) /* DATA_B3_REQ */
+
+static inline void capimsg_setu8(void *m, int off, __u8 val)
+{
+        ((__u8 *)m)[off] = val;
+}
+
+static inline void capimsg_setu16(void *m, int off, __u16 val)
+{
+        ((__u8 *)m)[off] = val & 0xff;
+        ((__u8 *)m)[off+1] = (val >> 8) & 0xff;
+}
+
+static inline void capimsg_setu32(void *m, int off, __u32 val)
+{
+        ((__u8 *)m)[off] = val & 0xff;
+        ((__u8 *)m)[off+1] = (val >> 8) & 0xff;
+        ((__u8 *)m)[off+2] = (val >> 16) & 0xff;
+        ((__u8 *)m)[off+3] = (val >> 24) & 0xff;
+}
+
+#define CAPIMSG_SETLEN(m, len)          capimsg_setu16(m, 0, len)
+#define CAPIMSG_SETAPPID(m, applid)     capimsg_setu16(m, 2, applid)
+#define CAPIMSG_SETCOMMAND(m,cmd)       capimsg_setu8(m, 4, cmd)
+#define CAPIMSG_SETSUBCOMMAND(m, cmd)   capimsg_setu8(m, 5, cmd)
+#define CAPIMSG_SETMSGID(m, msgid)      capimsg_setu16(m, 6, msgid)
+#define CAPIMSG_SETCONTROL(m, contr)    capimsg_setu32(m, 8, contr)
+#define CAPIMSG_SETDATALEN(m, len)      capimsg_setu16(m, 16, len)
+
+/*----- basic-type definitions -----*/
+
+typedef __u8 *_cstruct;
+
+typedef enum {
+        CAPI_COMPOSE,
+        CAPI_DEFAULT
+} _cmstruct;
+
+/*
+   The _cmsg structure contains all possible CAPI 2.0 parameter.
+   All parameters are stored here first. The function CAPI_CMSG_2_MESSAGE
+   assembles the parameter and builds CAPI2.0 conform messages.
+   CAPI_MESSAGE_2_CMSG disassembles CAPI 2.0 messages and stores the
+   parameter in the _cmsg structure
+ */
+
+typedef struct {
+        /* Header */
+        __u16 ApplId;
+        __u8 Command;
+        __u8 Subcommand;
+        __u16 Messagenumber;
+
+        /* Parameter */
+        union {
+                __u32 adrController;
+                __u32 adrPLCI;
+                __u32 adrNCCI;
+        } adr;
+
+        _cmstruct AdditionalInfo;
+        _cstruct B1configuration;
+        __u16 B1protocol;
+        _cstruct B2configuration;
+        __u16 B2protocol;
+        _cstruct B3configuration;
+        __u16 B3protocol;
+        _cstruct BC;
+        _cstruct BChannelinformation;
+        _cmstruct BProtocol;
+        _cstruct CalledPartyNumber;
+        _cstruct CalledPartySubaddress;
+        _cstruct CallingPartyNumber;
+        _cstruct CallingPartySubaddress;
+        __u32 CIPmask;
+        __u32 CIPmask2;
+        __u16 CIPValue;
+        __u32 Class;
+        _cstruct ConnectedNumber;
+        _cstruct ConnectedSubaddress;
+        __u32 Data;
+        __u16 DataHandle;
+        __u16 DataLength;
+        _cstruct FacilityConfirmationParameter;
+        _cstruct Facilitydataarray;
+        _cstruct FacilityIndicationParameter;
+        _cstruct FacilityRequestParameter;
+        __u16 FacilitySelector;
+        __u16 Flags;
+        __u32 Function;
+        _cstruct HLC;
+        __u16 Info;
+        _cstruct InfoElement;
+        __u32 InfoMask;
+        __u16 InfoNumber;
+        _cstruct Keypadfacility;
+        _cstruct LLC;
+        _cstruct ManuData;
+        __u32 ManuID;
+        _cstruct NCPI;
+        __u16 Reason;
+        __u16 Reason_B3;
+        __u16 Reject;
+        _cstruct Useruserdata;
+
+        /* intern */
+        unsigned l, p;
+        unsigned char *par;
+        __u8 *m;
+
+        /* buffer to construct message */
+        __u8 buf[180];
+
+} _cmsg;
+
+/*
+ * capi_cmsg2message() assembles the parameter from _cmsg to a CAPI 2.0
+ * conform message
+ */
+unsigned capi_cmsg2message(_cmsg * cmsg, __u8 * msg);
+
+/*
+ *  capi_message2cmsg disassembles a CAPI message an writes the parameter
+ *  into _cmsg for easy access
+ */
+unsigned capi_message2cmsg(_cmsg * cmsg, __u8 * msg);
+
+/*
+ * capi_cmsg_header() fills the _cmsg structure with default values, so only
+ * parameter with non default values must be changed before sending the
+ * message.
+ */
+unsigned capi_cmsg_header(_cmsg * cmsg, __u16 _ApplId,
+                          __u8 _Command, __u8 _Subcommand,
+                          __u16 _Messagenumber, __u32 _Controller);
+
+/*
+ * capi_info2str generated a readable string for Capi2.0 reasons.
+ */
+char *capi_info2str(__u16 reason);
+
+/*-----------------------------------------------------------------------*/
+
+/*
+ * Debugging / Tracing functions
+ */
+char *capi_cmd2str(__u8 cmd, __u8 subcmd);
+char *capi_cmsg2str(_cmsg * cmsg);
+char *capi_message2str(__u8 * msg);
+
+/*-----------------------------------------------------------------------*/
+
+static inline void capi_cmsg_answer(_cmsg * cmsg)
+{
+        cmsg->Subcommand |= 0x01;
+}
+
+/*-----------------------------------------------------------------------*/
+
+static inline void capi_fill_CONNECT_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                            __u32 adr,
+                                            _cstruct NCPI)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x82, 0x80, Messagenumber, adr);
+        cmsg->NCPI = NCPI;
+}
+
+static inline void capi_fill_FACILITY_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                          __u32 adr,
+                                          __u16 FacilitySelector,
+                                       _cstruct FacilityRequestParameter)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x80, 0x80, Messagenumber, adr);
+        cmsg->FacilitySelector = FacilitySelector;
+        cmsg->FacilityRequestParameter = FacilityRequestParameter;
+}
+
+static inline void capi_fill_INFO_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                      __u32 adr,
+                                      _cstruct CalledPartyNumber,
+                                      _cstruct BChannelinformation,
+                                      _cstruct Keypadfacility,
+                                      _cstruct Useruserdata,
+                                      _cstruct Facilitydataarray)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x08, 0x80, Messagenumber, adr);
+        cmsg->CalledPartyNumber = CalledPartyNumber;
+        cmsg->BChannelinformation = BChannelinformation;
+        cmsg->Keypadfacility = Keypadfacility;
+        cmsg->Useruserdata = Useruserdata;
+        cmsg->Facilitydataarray = Facilitydataarray;
+}
+
+static inline void capi_fill_LISTEN_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                        __u32 adr,
+                                        __u32 InfoMask,
+                                        __u32 CIPmask,
+                                        __u32 CIPmask2,
+                                        _cstruct CallingPartyNumber,
+                                        _cstruct CallingPartySubaddress)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x05, 0x80, Messagenumber, adr);
+        cmsg->InfoMask = InfoMask;
+        cmsg->CIPmask = CIPmask;
+        cmsg->CIPmask2 = CIPmask2;
+        cmsg->CallingPartyNumber = CallingPartyNumber;
+        cmsg->CallingPartySubaddress = CallingPartySubaddress;
+}
+
+static inline void capi_fill_ALERT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                       __u32 adr,
+                                       _cstruct BChannelinformation,
+                                       _cstruct Keypadfacility,
+                                       _cstruct Useruserdata,
+                                       _cstruct Facilitydataarray)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x01, 0x80, Messagenumber, adr);
+        cmsg->BChannelinformation = BChannelinformation;
+        cmsg->Keypadfacility = Keypadfacility;
+        cmsg->Useruserdata = Useruserdata;
+        cmsg->Facilitydataarray = Facilitydataarray;
+}
+
+static inline void capi_fill_CONNECT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                         __u32 adr,
+                                         __u16 CIPValue,
+                                         _cstruct CalledPartyNumber,
+                                         _cstruct CallingPartyNumber,
+                                         _cstruct CalledPartySubaddress,
+                                         _cstruct CallingPartySubaddress,
+                                         __u16 B1protocol,
+                                         __u16 B2protocol,
+                                         __u16 B3protocol,
+                                         _cstruct B1configuration,
+                                         _cstruct B2configuration,
+                                         _cstruct B3configuration,
+                                         _cstruct BC,
+                                         _cstruct LLC,
+                                         _cstruct HLC,
+                                         _cstruct BChannelinformation,
+                                         _cstruct Keypadfacility,
+                                         _cstruct Useruserdata,
+                                         _cstruct Facilitydataarray)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x02, 0x80, Messagenumber, adr);
+        cmsg->CIPValue = CIPValue;
+        cmsg->CalledPartyNumber = CalledPartyNumber;
+        cmsg->CallingPartyNumber = CallingPartyNumber;
+        cmsg->CalledPartySubaddress = CalledPartySubaddress;
+        cmsg->CallingPartySubaddress = CallingPartySubaddress;
+        cmsg->B1protocol = B1protocol;
+        cmsg->B2protocol = B2protocol;
+        cmsg->B3protocol = B3protocol;
+        cmsg->B1configuration = B1configuration;
+        cmsg->B2configuration = B2configuration;
+        cmsg->B3configuration = B3configuration;
+        cmsg->BC = BC;
+        cmsg->LLC = LLC;
+        cmsg->HLC = HLC;
+        cmsg->BChannelinformation = BChannelinformation;
+        cmsg->Keypadfacility = Keypadfacility;
+        cmsg->Useruserdata = Useruserdata;
+        cmsg->Facilitydataarray = Facilitydataarray;
+}
+
+static inline void capi_fill_DATA_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                         __u32 adr,
+                                         __u32 Data,
+                                         __u16 DataLength,
+                                         __u16 DataHandle,
+                                         __u16 Flags)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x86, 0x80, Messagenumber, adr);
+        cmsg->Data = Data;
+        cmsg->DataLength = DataLength;
+        cmsg->DataHandle = DataHandle;
+        cmsg->Flags = Flags;
+}
+
+static inline void capi_fill_DISCONNECT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                            __u32 adr,
+                                            _cstruct BChannelinformation,
+                                            _cstruct Keypadfacility,
+                                            _cstruct Useruserdata,
+                                            _cstruct Facilitydataarray)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x04, 0x80, Messagenumber, adr);
+        cmsg->BChannelinformation = BChannelinformation;
+        cmsg->Keypadfacility = Keypadfacility;
+        cmsg->Useruserdata = Useruserdata;
+        cmsg->Facilitydataarray = Facilitydataarray;
+}
+
+static inline void capi_fill_DISCONNECT_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                               __u32 adr,
+                                               _cstruct NCPI)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x84, 0x80, Messagenumber, adr);
+        cmsg->NCPI = NCPI;
+}
+
+static inline void capi_fill_MANUFACTURER_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                              __u32 adr,
+                                              __u32 ManuID,
+                                              __u32 Class,
+                                              __u32 Function,
+                                              _cstruct ManuData)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0xff, 0x80, Messagenumber, adr);
+        cmsg->ManuID = ManuID;
+        cmsg->Class = Class;
+        cmsg->Function = Function;
+        cmsg->ManuData = ManuData;
+}
+
+static inline void capi_fill_RESET_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                          __u32 adr,
+                                          _cstruct NCPI)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x87, 0x80, Messagenumber, adr);
+        cmsg->NCPI = NCPI;
+}
+
+static inline void capi_fill_SELECT_B_PROTOCOL_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                                   __u32 adr,
+                                                   __u16 B1protocol,
+                                                   __u16 B2protocol,
+                                                   __u16 B3protocol,
+                                                _cstruct B1configuration,
+                                                _cstruct B2configuration,
+                                                _cstruct B3configuration)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x41, 0x80, Messagenumber, adr);
+        cmsg->B1protocol = B1protocol;
+        cmsg->B2protocol = B2protocol;
+        cmsg->B3protocol = B3protocol;
+        cmsg->B1configuration = B1configuration;
+        cmsg->B2configuration = B2configuration;
+        cmsg->B3configuration = B3configuration;
+}
+
+static inline void capi_fill_CONNECT_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                          __u32 adr,
+                                          __u16 Reject,
+                                          __u16 B1protocol,
+                                          __u16 B2protocol,
+                                          __u16 B3protocol,
+                                          _cstruct B1configuration,
+                                          _cstruct B2configuration,
+                                          _cstruct B3configuration,
+                                          _cstruct ConnectedNumber,
+                                          _cstruct ConnectedSubaddress,
+                                          _cstruct LLC,
+                                          _cstruct BChannelinformation,
+                                          _cstruct Keypadfacility,
+                                          _cstruct Useruserdata,
+                                          _cstruct Facilitydataarray)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x02, 0x83, Messagenumber, adr);
+        cmsg->Reject = Reject;
+        cmsg->B1protocol = B1protocol;
+        cmsg->B2protocol = B2protocol;
+        cmsg->B3protocol = B3protocol;
+        cmsg->B1configuration = B1configuration;
+        cmsg->B2configuration = B2configuration;
+        cmsg->B3configuration = B3configuration;
+        cmsg->ConnectedNumber = ConnectedNumber;
+        cmsg->ConnectedSubaddress = ConnectedSubaddress;
+        cmsg->LLC = LLC;
+        cmsg->BChannelinformation = BChannelinformation;
+        cmsg->Keypadfacility = Keypadfacility;
+        cmsg->Useruserdata = Useruserdata;
+        cmsg->Facilitydataarray = Facilitydataarray;
+}
+
+static inline void capi_fill_CONNECT_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                                 __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x03, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_CONNECT_B3_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                                    __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x83, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_CONNECT_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                             __u32 adr,
+                                             __u16 Reject,
+                                             _cstruct NCPI)
+{
+        capi_cmsg_header(cmsg, ApplId, 0x82, 0x83, Messagenumber, adr);
+        cmsg->Reject = Reject;
+        cmsg->NCPI = NCPI;
+}
+
+static inline void capi_fill_CONNECT_B3_T90_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                                        __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x88, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_DATA_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                          __u32 adr,
+                                          __u16 DataHandle)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x86, 0x83, Messagenumber, adr);
+        cmsg->DataHandle = DataHandle;
+}
+
+static inline void capi_fill_DISCONNECT_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                                __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x84, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_DISCONNECT_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                             __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x04, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_FACILITY_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                           __u32 adr,
+                                           __u16 FacilitySelector)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x80, 0x83, Messagenumber, adr);
+        cmsg->FacilitySelector = FacilitySelector;
+}
+
+static inline void capi_fill_INFO_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                       __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x08, 0x83, Messagenumber, adr);
+}
+
+static inline void capi_fill_MANUFACTURER_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                               __u32 adr,
+                                               __u32 ManuID,
+                                               __u32 Class,
+                                               __u32 Function,
+                                               _cstruct ManuData)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0xff, 0x83, Messagenumber, adr);
+        cmsg->ManuID = ManuID;
+        cmsg->Class = Class;
+        cmsg->Function = Function;
+        cmsg->ManuData = ManuData;
+}
+
+static inline void capi_fill_RESET_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber,
+                                           __u32 adr)
+{
+
+        capi_cmsg_header(cmsg, ApplId, 0x87, 0x83, Messagenumber, adr);
+}
+
+#endif                          /* __CAPIUTIL_H__ */
diff --git a/include/linux/isdn/tpam.h b/include/linux/isdn/tpam.h
new file mode 100644
index 000000000000..9f65bea49d11
--- /dev/null
+++ b/include/linux/isdn/tpam.h
@@ -0,0 +1,56 @@
+/* $Id: tpam.h,v 1.1.2.1 2001/06/08 08:23:46 kai Exp $
+ *
+ * Turbo PAM ISDN driver for Linux. (Kernel Driver)
+ *
+ * Copyright 2001 Stelian Pop <stelian.pop@fr.alcove.com>, Alcôve
+ *
+ * For all support questions please contact: <support@auvertech.fr>
+ *
+ * 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; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef _TPAM_H_
+#define _TPAM_H_
+
+#include <linux/types.h>
+#include <linux/pci.h>
+
+/* IOCTL commands */
+#define TPAM_CMD_DSPLOAD        0x0001
+#define TPAM_CMD_DSPSAVE        0x0002
+#define TPAM_CMD_DSPRUN         0x0003
+#define TPAM_CMD_LOOPMODEON     0x0004
+#define TPAM_CMD_LOOPMODEOFF    0x0005
+
+/* addresses of debug information zones on board */
+#define TPAM_TRAPAUDIT_REGISTER         0x005493e4
+#define TPAM_NCOAUDIT_REGISTER          0x00500000
+#define TPAM_MSGAUDIT_REGISTER          0x008E30F0
+
+/* length of debug information zones on board */
+#define TPAM_TRAPAUDIT_LENGTH           10000
+#define TPAM_NCOAUDIT_LENGTH            300000
+#define TPAM_NCOAUDIT_COUNT             30
+#define TPAM_MSGAUDIT_LENGTH            60000
+
+/* IOCTL load/save parameter */
+typedef struct tpam_dsp_ioctl {
+        __u32 address;  /* address to load/save data */
+        __u32 data_len; /* size of data to be loaded/saved */
+        __u8 data[0];   /* data */
+} tpam_dsp_ioctl;
+
+#endif /* _TPAM_H_ */
diff --git a/include/linux/isdn_divertif.h b/include/linux/isdn_divertif.h
new file mode 100644
index 000000000000..0e7e44ce8301
--- /dev/null
+++ b/include/linux/isdn_divertif.h
@@ -0,0 +1,42 @@
+/* $Id: isdn_divertif.h,v 1.4.6.1 2001/09/23 22:25:05 kai Exp $
+ *
+ * Header for the diversion supplementary interface for i4l.
+ *
+ * Author    Werner Cornelius (werner@titro.de)
+ * Copyright by Werner Cornelius (werner@titro.de)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+
+/***********************************************************/
+/* magic value is also used to control version information */
+/***********************************************************/
+#define DIVERT_IF_MAGIC 0x25873401
+#define DIVERT_CMD_REG  0x00  /* register command */
+#define DIVERT_CMD_REL  0x01  /* release command */
+#define DIVERT_NO_ERR   0x00  /* return value no error */
+#define DIVERT_CMD_ERR  0x01  /* invalid cmd */
+#define DIVERT_VER_ERR  0x02  /* magic/version invalid */
+#define DIVERT_REG_ERR  0x03  /* module already registered */
+#define DIVERT_REL_ERR  0x04  /* module not registered */
+#define DIVERT_REG_NAME isdn_register_divert
+
+/***************************************************************/
+/* structure exchanging data between isdn hl and divert module */
+/***************************************************************/ 
+typedef struct
+  { ulong if_magic; /* magic info and version */
+    int cmd; /* command */
+    int (*stat_callback)(isdn_ctrl *); /* supplied by divert module when calling */
+    int (*ll_cmd)(isdn_ctrl *); /* supplied by hl on return */
+    char * (*drv_to_name)(int); /* map a driver id to name, supplied by hl */
+    int (*name_to_drv)(char *); /* map a driver id to name, supplied by hl */
+  } isdn_divert_if;
+
+/*********************/
+/* function register */
+/*********************/
+extern int DIVERT_REG_NAME(isdn_divert_if *);
diff --git a/include/linux/isdn_ppp.h b/include/linux/isdn_ppp.h
new file mode 100644
index 000000000000..26b00a76e135
--- /dev/null
+++ b/include/linux/isdn_ppp.h
@@ -0,0 +1,249 @@
+/* Linux ISDN subsystem, sync PPP, interface to ipppd
+ *
+ * Copyright 1994-1999  by Fritz Elfert (fritz@isdn4linux.de)
+ * Copyright 1995,96    Thinking Objects Software GmbH Wuerzburg
+ * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
+ * Copyright 2000-2002  by Kai Germaschewski (kai@germaschewski.name)
+ *
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef _LINUX_ISDN_PPP_H
+#define _LINUX_ISDN_PPP_H
+
+#define CALLTYPE_INCOMING 0x1
+#define CALLTYPE_OUTGOING 0x2
+#define CALLTYPE_CALLBACK 0x4
+
+#define IPPP_VERSION    "2.2.0"
+
+struct pppcallinfo
+{
+  int calltype;
+  unsigned char local_num[64];
+  unsigned char remote_num[64];
+  int charge_units;
+};
+
+#define PPPIOCGCALLINFO _IOWR('t',128,struct pppcallinfo)
+#define PPPIOCBUNDLE   _IOW('t',129,int)
+#define PPPIOCGMPFLAGS _IOR('t',130,int)
+#define PPPIOCSMPFLAGS _IOW('t',131,int)
+#define PPPIOCSMPMTU   _IOW('t',132,int)
+#define PPPIOCSMPMRU   _IOW('t',133,int)
+#define PPPIOCGCOMPRESSORS _IOR('t',134,unsigned long [8])
+#define PPPIOCSCOMPRESSOR _IOW('t',135,int)
+#define PPPIOCGIFNAME      _IOR('t',136, char [IFNAMSIZ] )
+
+
+#define SC_MP_PROT       0x00000200
+#define SC_REJ_MP_PROT   0x00000400
+#define SC_OUT_SHORT_SEQ 0x00000800
+#define SC_IN_SHORT_SEQ  0x00004000
+
+#define SC_DECOMP_ON            0x01
+#define SC_COMP_ON              0x02
+#define SC_DECOMP_DISCARD       0x04
+#define SC_COMP_DISCARD         0x08
+#define SC_LINK_DECOMP_ON       0x10
+#define SC_LINK_COMP_ON         0x20
+#define SC_LINK_DECOMP_DISCARD  0x40
+#define SC_LINK_COMP_DISCARD    0x80
+
+#define ISDN_PPP_COMP_MAX_OPTIONS 16
+
+#define IPPP_COMP_FLAG_XMIT 0x1
+#define IPPP_COMP_FLAG_LINK 0x2
+
+struct isdn_ppp_comp_data {
+  int num;
+  unsigned char options[ISDN_PPP_COMP_MAX_OPTIONS];
+  int optlen;
+  int flags;
+};
+
+#ifdef __KERNEL__
+
+
+#include <linux/config.h>
+
+#ifdef CONFIG_IPPP_FILTER
+#include <linux/filter.h>
+#endif
+
+#define DECOMP_ERR_NOMEM        (-10)
+
+#define MP_END_FRAG    0x40
+#define MP_BEGIN_FRAG  0x80
+
+#define MP_MAX_QUEUE_LEN        16
+
+/*
+ * We need a way for the decompressor to influence the generation of CCP
+ * Reset-Requests in a variety of ways. The decompressor is already returning
+ * a lot of information (generated skb length, error conditions) so we use
+ * another parameter. This parameter is a pointer to a structure which is
+ * to be marked valid by the decompressor and only in this case is ever used.
+ * Furthermore, the only case where this data is used is when the decom-
+ * pressor returns DECOMP_ERROR.
+ *
+ * We use this same struct for the reset entry of the compressor to commu-
+ * nicate to its caller how to deal with sending of a Reset Ack. In this
+ * case, expra is not used, but other options still apply (suppressing
+ * sending with rsend, appending arbitrary data, etc).
+ */
+
+#define IPPP_RESET_MAXDATABYTES 32
+
+struct isdn_ppp_resetparams {
+  unsigned char valid:1;        /* rw Is this structure filled at all ? */
+  unsigned char rsend:1;        /* rw Should we send one at all ? */
+  unsigned char idval:1;        /* rw Is the id field valid ? */
+  unsigned char dtval:1;        /* rw Is the data field valid ? */
+  unsigned char expra:1;        /* rw Is an Ack expected for this Req ? */
+  unsigned char id;             /* wo Send CCP ResetReq with this id */
+  unsigned short maxdlen;       /* ro Max bytes to be stored in data field */
+  unsigned short dlen;          /* rw Bytes stored in data field */
+  unsigned char *data;          /* wo Data for ResetReq info field */
+};
+
+/*
+ * this is an 'old friend' from ppp-comp.h under a new name 
+ * check the original include for more information
+ */
+struct isdn_ppp_compressor {
+  struct isdn_ppp_compressor *next, *prev;
+  struct module *owner;
+  int num; /* CCP compression protocol number */
+  
+  void *(*alloc) (struct isdn_ppp_comp_data *);
+  void (*free) (void *state);
+  int  (*init) (void *state, struct isdn_ppp_comp_data *,
+                int unit,int debug);
+  
+  /* The reset entry needs to get more exact information about the
+     ResetReq or ResetAck it was called with. The parameters are
+     obvious. If reset is called without a Req or Ack frame which
+     could be handed into it, code MUST be set to 0. Using rsparm,
+     the reset entry can control if and how a ResetAck is returned. */
+  
+  void (*reset) (void *state, unsigned char code, unsigned char id,
+                 unsigned char *data, unsigned len,
+                 struct isdn_ppp_resetparams *rsparm);
+  
+  int  (*compress) (void *state, struct sk_buff *in,
+                    struct sk_buff *skb_out, int proto);
+  
+        int  (*decompress) (void *state,struct sk_buff *in,
+                            struct sk_buff *skb_out,
+                            struct isdn_ppp_resetparams *rsparm);
+  
+  void (*incomp) (void *state, struct sk_buff *in,int proto);
+  void (*stat) (void *state, struct compstat *stats);
+};
+
+extern int isdn_ppp_register_compressor(struct isdn_ppp_compressor *);
+extern int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *);
+extern int isdn_ppp_dial_slave(char *);
+extern int isdn_ppp_hangup_slave(char *);
+
+typedef struct {
+  unsigned long seqerrs;
+  unsigned long frame_drops;
+  unsigned long overflows;
+  unsigned long max_queue_len;
+} isdn_mppp_stats;
+
+typedef struct {
+  int mp_mrru;                        /* unused                             */
+  struct sk_buff * frags;       /* fragments sl list -- use skb->next */
+  long frames;                  /* number of frames in the frame list */
+  unsigned int seq;             /* last processed packet seq #: any packets
+                                 * with smaller seq # will be dropped
+                                 * unconditionally */
+  spinlock_t lock;
+  int ref_ct;                            
+  /* statistics */
+  isdn_mppp_stats stats;
+} ippp_bundle;
+
+#define NUM_RCV_BUFFS     64
+
+struct ippp_buf_queue {
+  struct ippp_buf_queue *next;
+  struct ippp_buf_queue *last;
+  char *buf;                 /* NULL here indicates end of queue */
+  int len;
+};
+
+/* The data structure for one CCP reset transaction */
+enum ippp_ccp_reset_states {
+  CCPResetIdle,
+  CCPResetSentReq,
+  CCPResetRcvdReq,
+  CCPResetSentAck,
+  CCPResetRcvdAck
+};
+
+struct ippp_ccp_reset_state {
+  enum ippp_ccp_reset_states state;     /* State of this transaction */
+  struct ippp_struct *is;               /* Backlink to device stuff */
+  unsigned char id;                     /* Backlink id index */
+  unsigned char ta:1;                   /* The timer is active (flag) */
+  unsigned char expra:1;                /* We expect a ResetAck at all */
+  int dlen;                             /* Databytes stored in data */
+  struct timer_list timer;              /* For timeouts/retries */
+  /* This is a hack but seems sufficient for the moment. We do not want
+     to have this be yet another allocation for some bytes, it is more
+     memory management overhead than the whole mess is worth. */
+  unsigned char data[IPPP_RESET_MAXDATABYTES];
+};
+
+/* The data structure keeping track of the currently outstanding CCP Reset
+   transactions. */
+struct ippp_ccp_reset {
+  struct ippp_ccp_reset_state *rs[256]; /* One per possible id */
+  unsigned char lastid;                 /* Last id allocated by the engine */
+};
+
+struct ippp_struct {
+  struct ippp_struct *next_link;
+  int state;
+  spinlock_t buflock;
+  struct ippp_buf_queue rq[NUM_RCV_BUFFS]; /* packet queue for isdn_ppp_read() */
+  struct ippp_buf_queue *first;  /* pointer to (current) first packet */
+  struct ippp_buf_queue *last;   /* pointer to (current) last used packet in queue */
+  wait_queue_head_t wq;
+  struct task_struct *tk;
+  unsigned int mpppcfg;
+  unsigned int pppcfg;
+  unsigned int mru;
+  unsigned int mpmru;
+  unsigned int mpmtu;
+  unsigned int maxcid;
+  struct isdn_net_local_s *lp;
+  int unit;
+  int minor;
+  unsigned int last_link_seqno;
+  long mp_seqno;
+#ifdef CONFIG_ISDN_PPP_VJ
+  unsigned char *cbuf;
+  struct slcompress *slcomp;
+#endif
+#ifdef CONFIG_IPPP_FILTER
+  struct sock_filter *pass_filter;      /* filter for packets to pass */
+  struct sock_filter *active_filter;    /* filter for pkts to reset idle */
+  unsigned pass_len, active_len;
+#endif
+  unsigned long debug;
+  struct isdn_ppp_compressor *compressor,*decompressor;
+  struct isdn_ppp_compressor *link_compressor,*link_decompressor;
+  void *decomp_stat,*comp_stat,*link_decomp_stat,*link_comp_stat;
+  struct ippp_ccp_reset *reset; /* Allocated on demand, may never be needed */
+  unsigned long compflags;
+};
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_ISDN_PPP_H */
diff --git a/include/linux/isdnif.h b/include/linux/isdnif.h
new file mode 100644
index 000000000000..7a4eacd77cb2
--- /dev/null
+++ b/include/linux/isdnif.h
@@ -0,0 +1,547 @@
+/* $Id: isdnif.h,v 1.43.2.2 2004/01/12 23:08:35 keil Exp $
+ *
+ * Linux ISDN subsystem
+ * Definition of the interface between the subsystem and its low-level drivers.
+ *
+ * Copyright 1994,95,96 by Fritz Elfert (fritz@isdn4linux.de)
+ * Copyright 1995,96    Thinking Objects Software GmbH Wuerzburg
+ * 
+ * This software may be used and distributed according to the terms
+ * of the GNU General Public License, incorporated herein by reference.
+ *
+ */
+
+#ifndef __ISDNIF_H__
+#define __ISDNIF_H__
+
+
+/*
+ * Values for general protocol-selection
+ */
+#define ISDN_PTYPE_UNKNOWN   0   /* Protocol undefined   */
+#define ISDN_PTYPE_1TR6      1   /* german 1TR6-protocol */
+#define ISDN_PTYPE_EURO      2   /* EDSS1-protocol       */
+#define ISDN_PTYPE_LEASED    3   /* for leased lines     */
+#define ISDN_PTYPE_NI1       4   /* US NI-1 protocol     */
+#define ISDN_PTYPE_MAX       7   /* Max. 8 Protocols     */
+
+/*
+ * Values for Layer-2-protocol-selection
+ */
+#define ISDN_PROTO_L2_X75I   0   /* X75/LAPB with I-Frames            */
+#define ISDN_PROTO_L2_X75UI  1   /* X75/LAPB with UI-Frames           */
+#define ISDN_PROTO_L2_X75BUI 2   /* X75/LAPB with UI-Frames           */
+#define ISDN_PROTO_L2_HDLC   3   /* HDLC                              */
+#define ISDN_PROTO_L2_TRANS  4   /* Transparent (Voice)               */
+#define ISDN_PROTO_L2_X25DTE 5   /* X25/LAPB DTE mode                 */
+#define ISDN_PROTO_L2_X25DCE 6   /* X25/LAPB DCE mode                 */
+#define ISDN_PROTO_L2_V11096 7   /* V.110 bitrate adaption 9600 Baud  */
+#define ISDN_PROTO_L2_V11019 8   /* V.110 bitrate adaption 19200 Baud */
+#define ISDN_PROTO_L2_V11038 9   /* V.110 bitrate adaption 38400 Baud */
+#define ISDN_PROTO_L2_MODEM  10  /* Analog Modem on Board */
+#define ISDN_PROTO_L2_FAX    11  /* Fax Group 2/3         */
+#define ISDN_PROTO_L2_HDLC_56K 12   /* HDLC 56k                          */
+#define ISDN_PROTO_L2_MAX    15  /* Max. 16 Protocols                 */
+
+/*
+ * Values for Layer-3-protocol-selection
+ */
+#define ISDN_PROTO_L3_TRANS     0       /* Transparent */
+#define ISDN_PROTO_L3_TRANSDSP  1       /* Transparent with DSP */
+#define ISDN_PROTO_L3_FCLASS2   2       /* Fax Group 2/3 CLASS 2 */
+#define ISDN_PROTO_L3_FCLASS1   3       /* Fax Group 2/3 CLASS 1 */
+#define ISDN_PROTO_L3_MAX       7       /* Max. 8 Protocols */
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/skbuff.h>
+
+/***************************************************************************/
+/* Extensions made by Werner Cornelius (werner@ikt.de)                     */
+/*                                                                         */ 
+/* The proceed command holds a incoming call in a state to leave processes */
+/* enough time to check whether ist should be accepted.                    */
+/* The PROT_IO Command extends the interface to make protocol dependent    */
+/* features available (call diversion, call waiting...).                   */
+/*                                                                         */ 
+/* The PROT_IO Command is executed with the desired driver id and the arg  */
+/* parameter coded as follows:                                             */
+/* The lower 8 bits of arg contain the desired protocol from ISDN_PTYPE    */
+/* definitions. The upper 24 bits represent the protocol specific cmd/stat.*/
+/* Any additional data is protocol and command specific.                   */
+/* This mechanism also applies to the statcallb callback STAT_PROT.        */    
+/*                                                                         */
+/* This suggested extension permits an easy expansion of protocol specific */
+/* handling. Extensions may be added at any time without changing the HL   */
+/* driver code and not getting conflicts without certifications.           */
+/* The well known CAPI 2.0 interface handles such extensions in a similar  */
+/* way. Perhaps a protocol specific module may be added and separately     */
+/* loaded and linked to the basic isdn module for handling.                */                    
+/***************************************************************************/
+
+/*****************/
+/* DSS1 commands */ 
+/*****************/
+#define DSS1_CMD_INVOKE       ((0x00 << 8) | ISDN_PTYPE_EURO)   /* invoke a supplementary service */
+#define DSS1_CMD_INVOKE_ABORT ((0x01 << 8) | ISDN_PTYPE_EURO)   /* abort a invoke cmd */
+
+/*******************************/
+/* DSS1 Status callback values */
+/*******************************/
+#define DSS1_STAT_INVOKE_RES  ((0x80 << 8) | ISDN_PTYPE_EURO)   /* Result for invocation */
+#define DSS1_STAT_INVOKE_ERR  ((0x81 << 8) | ISDN_PTYPE_EURO)   /* Error Return for invocation */
+#define DSS1_STAT_INVOKE_BRD  ((0x82 << 8) | ISDN_PTYPE_EURO)   /* Deliver invoke broadcast info */
+
+
+/*********************************************************************/
+/* structures for DSS1 commands and callback                         */
+/*                                                                   */
+/* An action is invoked by sending a DSS1_CMD_INVOKE. The ll_id, proc*/
+/* timeout, datalen and data fields must be set before calling.      */
+/*                                                                   */
+/* The return value is a positive hl_id value also delivered in the  */
+/* hl_id field. A value of zero signals no more left hl_id capacitys.*/
+/* A negative return value signals errors in LL. So if the return    */
+/* value is <= 0 no action in LL will be taken -> request ignored    */
+/*                                                                   */
+/* The timeout field must be filled with a positive value specifying */
+/* the amount of time the INVOKED process waits for a reaction from  */
+/* the network.                                                      */
+/* If a response (either error or result) is received during this    */
+/* intervall, a reporting callback is initiated and the process will */
+/* be deleted, the hl identifier will be freed.                      */
+/* If no response is received during the specified intervall, a error*/
+/* callback is initiated with timeout set to -1 and a datalen set    */
+/* to 0.                                                             */
+/* If timeout is set to a value <= 0 during INVOCATION the process is*/
+/* immediately deleted after sending the data. No callback occurs !  */
+/*                                                                   */
+/* A currently waiting process may be aborted with INVOKE_ABORT. No  */
+/* callback will occur when a process has been aborted.              */
+/*                                                                   */
+/* Broadcast invoke frames from the network are reported via the     */
+/* STAT_INVOKE_BRD callback. The ll_id is set to 0, the other fields */
+/* are supplied by the network and not by the HL.                    */   
+/*********************************************************************/
+
+/*****************/
+/* NI1 commands */ 
+/*****************/
+#define NI1_CMD_INVOKE       ((0x00 << 8) | ISDN_PTYPE_NI1)   /* invoke a supplementary service */
+#define NI1_CMD_INVOKE_ABORT ((0x01 << 8) | ISDN_PTYPE_NI1)   /* abort a invoke cmd */
+
+/*******************************/
+/* NI1 Status callback values */
+/*******************************/
+#define NI1_STAT_INVOKE_RES  ((0x80 << 8) | ISDN_PTYPE_NI1)   /* Result for invocation */
+#define NI1_STAT_INVOKE_ERR  ((0x81 << 8) | ISDN_PTYPE_NI1)   /* Error Return for invocation */
+#define NI1_STAT_INVOKE_BRD  ((0x82 << 8) | ISDN_PTYPE_NI1)   /* Deliver invoke broadcast info */
+
+typedef struct
+  { ulong ll_id; /* ID supplied by LL when executing    */
+                 /* a command and returned by HL for    */
+                 /* INVOKE_RES and INVOKE_ERR           */
+    int hl_id;   /* ID supplied by HL when called       */
+                 /* for executing a cmd and delivered   */
+                 /* for results and errors              */
+                 /* must be supplied by LL when aborting*/  
+    int proc;    /* invoke procedure used by CMD_INVOKE */
+                 /* returned by callback and broadcast  */ 
+    int timeout; /* timeout for INVOKE CMD in ms        */
+                 /* -1  in stat callback when timed out */
+                 /* error value when error callback     */
+    int datalen; /* length of cmd or stat data          */
+    u_char *data;/* pointer to data delivered or send   */
+  } isdn_cmd_stat;
+
+/*
+ * Commands from linklevel to lowlevel
+ *
+ */
+#define ISDN_CMD_IOCTL    0       /* Perform ioctl                         */
+#define ISDN_CMD_DIAL     1       /* Dial out                              */
+#define ISDN_CMD_ACCEPTD  2       /* Accept an incoming call on D-Chan.    */
+#define ISDN_CMD_ACCEPTB  3       /* Request B-Channel connect.            */
+#define ISDN_CMD_HANGUP   4       /* Hangup                                */
+#define ISDN_CMD_CLREAZ   5       /* Clear EAZ(s) of channel               */
+#define ISDN_CMD_SETEAZ   6       /* Set EAZ(s) of channel                 */
+#define ISDN_CMD_GETEAZ   7       /* Get EAZ(s) of channel                 */
+#define ISDN_CMD_SETSIL   8       /* Set Service-Indicator-List of channel */
+#define ISDN_CMD_GETSIL   9       /* Get Service-Indicator-List of channel */
+#define ISDN_CMD_SETL2   10       /* Set B-Chan. Layer2-Parameter          */
+#define ISDN_CMD_GETL2   11       /* Get B-Chan. Layer2-Parameter          */
+#define ISDN_CMD_SETL3   12       /* Set B-Chan. Layer3-Parameter          */
+#define ISDN_CMD_GETL3   13       /* Get B-Chan. Layer3-Parameter          */
+// #define ISDN_CMD_LOCK    14       /* Signal usage by upper levels          */
+// #define ISDN_CMD_UNLOCK  15       /* Release usage-lock                    */
+#define ISDN_CMD_SUSPEND 16       /* Suspend connection                    */
+#define ISDN_CMD_RESUME  17       /* Resume connection                     */
+#define ISDN_CMD_PROCEED 18       /* Proceed with call establishment       */
+#define ISDN_CMD_ALERT   19       /* Alert after Proceeding                */
+#define ISDN_CMD_REDIR   20       /* Redir a incoming call                 */
+#define ISDN_CMD_PROT_IO 21       /* Protocol specific commands            */
+#define CAPI_PUT_MESSAGE 22       /* CAPI message send down or up          */
+#define ISDN_CMD_FAXCMD  23       /* FAX commands to HL-driver             */
+#define ISDN_CMD_AUDIO   24       /* DSP, DTMF, ... settings               */
+
+/*
+ * Status-Values delivered from lowlevel to linklevel via
+ * statcallb().
+ *
+ */
+#define ISDN_STAT_STAVAIL 256    /* Raw status-data available             */
+#define ISDN_STAT_ICALL   257    /* Incoming call detected                */
+#define ISDN_STAT_RUN     258    /* Signal protocol-code is running       */
+#define ISDN_STAT_STOP    259    /* Signal halt of protocol-code          */
+#define ISDN_STAT_DCONN   260    /* Signal D-Channel connect              */
+#define ISDN_STAT_BCONN   261    /* Signal B-Channel connect              */
+#define ISDN_STAT_DHUP    262    /* Signal D-Channel disconnect           */
+#define ISDN_STAT_BHUP    263    /* Signal B-Channel disconnect           */
+#define ISDN_STAT_CINF    264    /* Charge-Info                           */
+#define ISDN_STAT_LOAD    265    /* Signal new lowlevel-driver is loaded  */
+#define ISDN_STAT_UNLOAD  266    /* Signal unload of lowlevel-driver      */
+#define ISDN_STAT_BSENT   267    /* Signal packet sent                    */
+#define ISDN_STAT_NODCH   268    /* Signal no D-Channel                   */
+#define ISDN_STAT_ADDCH   269    /* Add more Channels                     */
+#define ISDN_STAT_CAUSE   270    /* Cause-Message                         */
+#define ISDN_STAT_ICALLW  271    /* Incoming call without B-chan waiting  */
+#define ISDN_STAT_REDIR   272    /* Redir result                          */
+#define ISDN_STAT_PROT    273    /* protocol IO specific callback         */
+#define ISDN_STAT_DISPLAY 274    /* deliver a received display message    */
+#define ISDN_STAT_L1ERR   275    /* Signal Layer-1 Error                  */
+#define ISDN_STAT_FAXIND  276    /* FAX indications from HL-driver        */
+#define ISDN_STAT_AUDIO   277    /* DTMF, DSP indications                 */
+#define ISDN_STAT_DISCH   278    /* Disable/Enable channel usage          */
+
+/*
+ * Audio commands
+ */
+#define ISDN_AUDIO_SETDD        0       /* Set DTMF detection           */
+#define ISDN_AUDIO_DTMF         1       /* Rx/Tx DTMF                   */
+
+/*
+ * Values for errcode field
+ */
+#define ISDN_STAT_L1ERR_SEND 1
+#define ISDN_STAT_L1ERR_RECV 2
+
+/*
+ * Values for feature-field of interface-struct.
+ */
+/* Layer 2 */
+#define ISDN_FEATURE_L2_X75I    (0x0001 << ISDN_PROTO_L2_X75I)
+#define ISDN_FEATURE_L2_X75UI   (0x0001 << ISDN_PROTO_L2_X75UI)
+#define ISDN_FEATURE_L2_X75BUI  (0x0001 << ISDN_PROTO_L2_X75BUI)
+#define ISDN_FEATURE_L2_HDLC    (0x0001 << ISDN_PROTO_L2_HDLC)
+#define ISDN_FEATURE_L2_TRANS   (0x0001 << ISDN_PROTO_L2_TRANS)
+#define ISDN_FEATURE_L2_X25DTE  (0x0001 << ISDN_PROTO_L2_X25DTE)
+#define ISDN_FEATURE_L2_X25DCE  (0x0001 << ISDN_PROTO_L2_X25DCE)
+#define ISDN_FEATURE_L2_V11096  (0x0001 << ISDN_PROTO_L2_V11096)
+#define ISDN_FEATURE_L2_V11019  (0x0001 << ISDN_PROTO_L2_V11019)
+#define ISDN_FEATURE_L2_V11038  (0x0001 << ISDN_PROTO_L2_V11038)
+#define ISDN_FEATURE_L2_MODEM   (0x0001 << ISDN_PROTO_L2_MODEM)
+#define ISDN_FEATURE_L2_FAX     (0x0001 << ISDN_PROTO_L2_FAX)
+#define ISDN_FEATURE_L2_HDLC_56K (0x0001 << ISDN_PROTO_L2_HDLC_56K)
+
+#define ISDN_FEATURE_L2_MASK    (0x0FFFF) /* Max. 16 protocols */
+#define ISDN_FEATURE_L2_SHIFT   (0)
+
+/* Layer 3 */
+#define ISDN_FEATURE_L3_TRANS   (0x10000 << ISDN_PROTO_L3_TRANS)
+#define ISDN_FEATURE_L3_TRANSDSP (0x10000 << ISDN_PROTO_L3_TRANSDSP)
+#define ISDN_FEATURE_L3_FCLASS2 (0x10000 << ISDN_PROTO_L3_FCLASS2)
+#define ISDN_FEATURE_L3_FCLASS1 (0x10000 << ISDN_PROTO_L3_FCLASS1)
+
+#define ISDN_FEATURE_L3_MASK    (0x0FF0000) /* Max. 8 Protocols */
+#define ISDN_FEATURE_L3_SHIFT   (16)
+
+/* Signaling */
+#define ISDN_FEATURE_P_UNKNOWN  (0x1000000 << ISDN_PTYPE_UNKNOWN)
+#define ISDN_FEATURE_P_1TR6     (0x1000000 << ISDN_PTYPE_1TR6)
+#define ISDN_FEATURE_P_EURO     (0x1000000 << ISDN_PTYPE_EURO)
+#define ISDN_FEATURE_P_NI1      (0x1000000 << ISDN_PTYPE_NI1)
+
+#define ISDN_FEATURE_P_MASK     (0x0FF000000) /* Max. 8 Protocols */
+#define ISDN_FEATURE_P_SHIFT    (24)
+
+typedef struct setup_parm {
+    unsigned char phone[32];    /* Remote Phone-Number */
+    unsigned char eazmsn[32];   /* Local EAZ or MSN    */
+    unsigned char si1;      /* Service Indicator 1 */
+    unsigned char si2;      /* Service Indicator 2 */
+    unsigned char plan;     /* Numbering plan      */
+    unsigned char screen;   /* Screening info      */
+} setup_parm;
+
+
+#ifdef CONFIG_ISDN_TTY_FAX
+/* T.30 Fax G3 */
+
+#define FAXIDLEN 21
+
+typedef struct T30_s {
+        /* session parameters */
+        __u8 resolution         __attribute__ ((packed));
+        __u8 rate               __attribute__ ((packed));
+        __u8 width              __attribute__ ((packed));
+        __u8 length             __attribute__ ((packed));
+        __u8 compression        __attribute__ ((packed));
+        __u8 ecm                __attribute__ ((packed));
+        __u8 binary             __attribute__ ((packed));
+        __u8 scantime           __attribute__ ((packed));
+        __u8 id[FAXIDLEN]       __attribute__ ((packed));
+        /* additional parameters */
+        __u8 phase              __attribute__ ((packed));
+        __u8 direction          __attribute__ ((packed));
+        __u8 code               __attribute__ ((packed));
+        __u8 badlin             __attribute__ ((packed));
+        __u8 badmul             __attribute__ ((packed));
+        __u8 bor                __attribute__ ((packed));
+        __u8 fet                __attribute__ ((packed));
+        __u8 pollid[FAXIDLEN]   __attribute__ ((packed));
+        __u8 cq                 __attribute__ ((packed));
+        __u8 cr                 __attribute__ ((packed));
+        __u8 ctcrty             __attribute__ ((packed));
+        __u8 minsp              __attribute__ ((packed));
+        __u8 phcto              __attribute__ ((packed));
+        __u8 rel                __attribute__ ((packed));
+        __u8 nbc                __attribute__ ((packed));
+        /* remote station parameters */
+        __u8 r_resolution       __attribute__ ((packed));
+        __u8 r_rate             __attribute__ ((packed));
+        __u8 r_width            __attribute__ ((packed));
+        __u8 r_length           __attribute__ ((packed));
+        __u8 r_compression      __attribute__ ((packed));
+        __u8 r_ecm              __attribute__ ((packed));
+        __u8 r_binary           __attribute__ ((packed));
+        __u8 r_scantime         __attribute__ ((packed));
+        __u8 r_id[FAXIDLEN]     __attribute__ ((packed));
+        __u8 r_code             __attribute__ ((packed));
+} T30_s;
+
+#define ISDN_TTY_FAX_CONN_IN    0
+#define ISDN_TTY_FAX_CONN_OUT   1
+
+#define ISDN_TTY_FAX_FCON       0
+#define ISDN_TTY_FAX_DIS        1
+#define ISDN_TTY_FAX_FTT        2
+#define ISDN_TTY_FAX_MCF        3
+#define ISDN_TTY_FAX_DCS        4
+#define ISDN_TTY_FAX_TRAIN_OK   5
+#define ISDN_TTY_FAX_EOP        6
+#define ISDN_TTY_FAX_EOM        7
+#define ISDN_TTY_FAX_MPS        8
+#define ISDN_TTY_FAX_DTC        9
+#define ISDN_TTY_FAX_RID        10
+#define ISDN_TTY_FAX_HNG        11
+#define ISDN_TTY_FAX_DT         12
+#define ISDN_TTY_FAX_FCON_I     13
+#define ISDN_TTY_FAX_DR         14
+#define ISDN_TTY_FAX_ET         15
+#define ISDN_TTY_FAX_CFR        16
+#define ISDN_TTY_FAX_PTS        17
+#define ISDN_TTY_FAX_SENT       18
+
+#define ISDN_FAX_PHASE_IDLE     0
+#define ISDN_FAX_PHASE_A        1
+#define ISDN_FAX_PHASE_B        2
+#define ISDN_FAX_PHASE_C        3
+#define ISDN_FAX_PHASE_D        4
+#define ISDN_FAX_PHASE_E        5
+
+#endif /* TTY_FAX */
+
+#define ISDN_FAX_CLASS1_FAE     0
+#define ISDN_FAX_CLASS1_FTS     1
+#define ISDN_FAX_CLASS1_FRS     2
+#define ISDN_FAX_CLASS1_FTM     3
+#define ISDN_FAX_CLASS1_FRM     4
+#define ISDN_FAX_CLASS1_FTH     5
+#define ISDN_FAX_CLASS1_FRH     6
+#define ISDN_FAX_CLASS1_CTRL    7
+
+#define ISDN_FAX_CLASS1_OK      0
+#define ISDN_FAX_CLASS1_CONNECT 1
+#define ISDN_FAX_CLASS1_NOCARR  2
+#define ISDN_FAX_CLASS1_ERROR   3
+#define ISDN_FAX_CLASS1_FCERROR 4
+#define ISDN_FAX_CLASS1_QUERY   5
+
+typedef struct {
+        __u8    cmd;
+        __u8    subcmd;
+        __u8    para[50];
+} aux_s;
+
+#define AT_COMMAND      0
+#define AT_EQ_VALUE     1
+#define AT_QUERY        2
+#define AT_EQ_QUERY     3
+
+/* CAPI structs */
+
+/* this is compatible to the old union size */
+#define MAX_CAPI_PARA_LEN 50
+
+typedef struct {
+        /* Header */
+        __u16 Length;
+        __u16 ApplId;
+        __u8 Command;
+        __u8 Subcommand;
+        __u16 Messagenumber;
+
+        /* Parameter */
+        union {
+                __u32 Controller;
+                __u32 PLCI;
+                __u32 NCCI;
+        } adr;
+        __u8 para[MAX_CAPI_PARA_LEN];
+} capi_msg;
+
+/*
+ * Structure for exchanging above infos
+ *
+ */
+typedef struct {
+        int   driver;           /* Lowlevel-Driver-ID            */
+        int   command;          /* Command or Status (see above) */
+        ulong arg;              /* Additional Data               */
+        union {
+                ulong errcode;  /* Type of error with STAT_L1ERR        */
+                int length;     /* Amount of bytes sent with STAT_BSENT */
+                u_char num[50]; /* Additional Data                      */
+                setup_parm setup;/* For SETUP msg                       */
+                capi_msg cmsg;  /* For CAPI like messages               */
+                char display[85];/* display message data                */ 
+                isdn_cmd_stat isdn_io; /* ISDN IO-parameter/result      */
+                aux_s aux;      /* for modem commands/indications       */
+#ifdef CONFIG_ISDN_TTY_FAX
+                T30_s   *fax;   /* Pointer to ttys fax struct           */
+#endif
+                ulong userdata; /* User Data */
+        } parm;
+} isdn_ctrl;
+
+#define dss1_io    isdn_io
+#define ni1_io     isdn_io
+
+/*
+ * The interface-struct itself (initialized at load-time of lowlevel-driver)
+ *
+ * See Documentation/isdn/INTERFACE for a description, how the communication
+ * between the ISDN subsystem and its drivers is done.
+ *
+ */
+typedef struct {
+  struct module *owner;
+
+  /* Number of channels supported by this driver
+   */
+  int channels;
+
+  /* 
+   * Maximum Size of transmit/receive-buffer this driver supports.
+   */
+  int maxbufsize;
+
+  /* Feature-Flags for this driver.
+   * See defines ISDN_FEATURE_... for Values
+   */
+  unsigned long features;
+
+  /*
+   * Needed for calculating
+   * dev->hard_header_len = linklayer header + hl_hdrlen;
+   * Drivers, not supporting sk_buff's should set this to 0.
+   */
+  unsigned short hl_hdrlen;
+
+  /*
+   * Receive-Callback using sk_buff's
+   * Parameters:
+   *             int                    Driver-ID
+   *             int                    local channel-number (0 ...)
+   *             struct sk_buff *skb    received Data
+   */
+  void (*rcvcallb_skb)(int, int, struct sk_buff *);
+
+  /* Status-Callback
+   * Parameters:
+   *             isdn_ctrl*
+   *                   driver  = Driver ID.
+   *                   command = One of above ISDN_STAT_... constants.
+   *                   arg     = depending on status-type.
+   *                   num     = depending on status-type.
+   */
+  int (*statcallb)(isdn_ctrl*);
+
+  /* Send command
+   * Parameters:
+   *             isdn_ctrl*
+   *                   driver  = Driver ID.
+   *                   command = One of above ISDN_CMD_... constants.
+   *                   arg     = depending on command.
+   *                   num     = depending on command.
+   */
+  int (*command)(isdn_ctrl*);
+
+  /*
+   * Send data using sk_buff's
+   * Parameters:
+   *             int                    driverId
+   *             int                    local channel-number (0...)
+   *             int                    Flag: Need ACK for this packet.
+   *             struct sk_buff *skb    Data to send
+   */
+  int (*writebuf_skb) (int, int, int, struct sk_buff *);
+
+  /* Send raw D-Channel-Commands
+   * Parameters:
+   *             u_char pointer data
+   *             int    length of data
+   *             int    driverId
+   *             int    local channel-number (0 ...)
+   */
+  int (*writecmd)(const u_char __user *, int, int, int);
+
+  /* Read raw Status replies
+   *             u_char pointer data (volatile)
+   *             int    length of buffer
+   *             int    driverId
+   *             int    local channel-number (0 ...)
+   */
+  int (*readstat)(u_char __user *, int, int, int);
+
+  char id[20];
+} isdn_if;
+
+/*
+ * Function which must be called by lowlevel-driver at loadtime with
+ * the following fields of above struct set:
+ *
+ * channels     Number of channels that will be supported.
+ * hl_hdrlen    Space to preserve in sk_buff's when sending. Drivers, not
+ *              supporting sk_buff's should set this to 0.
+ * command      Address of Command-Handler.
+ * features     Bitwise coded Features of this driver. (use ISDN_FEATURE_...)
+ * writebuf_skb Address of Skbuff-Send-Handler.
+ * writecmd        "    "  D-Channel  " which accepts raw D-Ch-Commands.
+ * readstat        "    "  D-Channel  " which delivers raw Status-Data.
+ *
+ * The linklevel-driver fills the following fields:
+ *
+ * channels      Driver-ID assigned to this driver. (Must be used on all
+ *               subsequent callbacks.
+ * rcvcallb_skb  Address of handler for received Skbuff's.
+ * statcallb        "    "     "    for status-changes.
+ *
+ */
+extern int register_isdn(isdn_if*);
+#include <asm/uaccess.h>
+
+#endif /* __KERNEL__ */
+
+#endif /* __ISDNIF_H__ */
diff --git a/include/linux/isicom.h b/include/linux/isicom.h
new file mode 100644
index 000000000000..7c6eae7f6ed7
--- /dev/null
+++ b/include/linux/isicom.h
@@ -0,0 +1,131 @@
+#ifndef _LINUX_ISICOM_H
+#define _LINUX_ISICOM_H
+
+/*#define               ISICOM_DEBUG*/
+/*#define               ISICOM_DEBUG_DTR_RTS*/
+
+
+/*
+ *      Firmware Loader definitions ...
+ */
+ 
+#define         __MultiTech             ('M'<<8)
+#define         MIOCTL_LOAD_FIRMWARE    (__MultiTech | 0x01)
+#define         MIOCTL_READ_FIRMWARE    (__MultiTech | 0x02)
+#define         MIOCTL_XFER_CTRL        (__MultiTech | 0x03)
+#define         MIOCTL_RESET_CARD       (__MultiTech | 0x04)
+
+#define         DATA_SIZE       16
+
+typedef struct  {
+                unsigned short  exec_segment;
+                unsigned short  exec_addr;
+}       exec_record;
+
+typedef struct  {
+                int             board;          /* Board to load */
+                unsigned short  addr;
+                unsigned short  count;
+}       bin_header;
+
+typedef struct  {
+                int             board;          /* Board to load */
+                unsigned short  addr;
+                unsigned short  count;
+                unsigned short  segment;
+                unsigned char   bin_data[DATA_SIZE];
+}       bin_frame;
+
+#ifdef __KERNEL__
+
+#define         YES     1
+#define         NO      0
+
+#define         ISILOAD_MISC_MINOR      155     /* /dev/isctl */
+#define         ISILOAD_NAME            "ISILoad"
+
+/*      
+ *  ISICOM Driver definitions ...
+ *
+ */
+
+#define         ISICOM_NAME     "ISICom"
+
+/*
+ *      PCI definitions
+ */
+
+ #define        DEVID_COUNT     9
+ #define        VENDOR_ID       0x10b5
+
+/*
+ *      These are now officially allocated numbers
+ */
+
+#define         ISICOM_NMAJOR   112     /* normal  */
+#define         ISICOM_CMAJOR   113     /* callout */
+#define         ISICOM_MAGIC    (('M' << 8) | 'T')
+
+#define         WAKEUP_CHARS    256     /* hard coded for now   */ 
+#define         TX_SIZE         254 
+ 
+#define         BOARD_COUNT     4
+#define         PORT_COUNT      (BOARD_COUNT*16)
+
+#define         SERIAL_TYPE_NORMAL      1
+
+/*   character sizes  */
+
+#define         ISICOM_CS5              0x0000
+#define         ISICOM_CS6              0x0001
+#define         ISICOM_CS7              0x0002
+#define         ISICOM_CS8              0x0003
+
+/* stop bits */
+
+#define         ISICOM_1SB              0x0000
+#define         ISICOM_2SB              0x0004
+
+/* parity */
+
+#define         ISICOM_NOPAR            0x0000
+#define         ISICOM_ODPAR            0x0008
+#define         ISICOM_EVPAR            0x0018
+
+/* flow control */
+
+#define         ISICOM_CTSRTS           0x03
+#define         ISICOM_INITIATE_XONXOFF 0x04
+#define         ISICOM_RESPOND_XONXOFF  0x08
+
+#define InterruptTheCard(base) (outw(0,(base)+0xc)) 
+#define ClearInterrupt(base) (inw((base)+0x0a)) 
+
+#define BOARD(line)  (((line) >> 4) & 0x3)
+
+        /*      isi kill queue bitmap   */
+        
+#define         ISICOM_KILLTX           0x01
+#define         ISICOM_KILLRX           0x02
+
+        /* isi_board status bitmap */
+        
+#define         FIRMWARE_LOADED         0x0001
+#define         BOARD_ACTIVE            0x0002
+
+        /* isi_port status bitmap  */
+
+#define         ISI_CTS                 0x1000
+#define         ISI_DSR                 0x2000
+#define         ISI_RI                  0x4000
+#define         ISI_DCD                 0x8000
+#define         ISI_DTR                 0x0100
+#define         ISI_RTS                 0x0200
+
+
+#define         ISI_TXOK                0x0001 
+ 
+#endif  /*      __KERNEL__      */
+
+#endif  /*      ISICOM_H        */
+
diff --git a/include/linux/iso_fs.h b/include/linux/iso_fs.h
new file mode 100644
index 000000000000..099039d4b10d
--- /dev/null
+++ b/include/linux/iso_fs.h
@@ -0,0 +1,312 @@
+
+#ifndef _ISOFS_FS_H
+#define _ISOFS_FS_H
+
+#include <linux/types.h>
+/*
+ * The isofs filesystem constants/structures
+ */
+
+/* This part borrowed from the bsd386 isofs */
+#define ISODCL(from, to) (to - from + 1)
+
+struct iso_volume_descriptor {
+        char type[ISODCL(1,1)]; /* 711 */
+        char id[ISODCL(2,6)];
+        char version[ISODCL(7,7)];
+        char data[ISODCL(8,2048)];
+};
+
+/* volume descriptor types */
+#define ISO_VD_PRIMARY 1
+#define ISO_VD_SUPPLEMENTARY 2
+#define ISO_VD_END 255
+
+#define ISO_STANDARD_ID "CD001"
+
+struct iso_primary_descriptor {
+        char type                       [ISODCL (  1,   1)]; /* 711 */
+        char id                         [ISODCL (  2,   6)];
+        char version                    [ISODCL (  7,   7)]; /* 711 */
+        char unused1                    [ISODCL (  8,   8)];
+        char system_id                  [ISODCL (  9,  40)]; /* achars */
+        char volume_id                  [ISODCL ( 41,  72)]; /* dchars */
+        char unused2                    [ISODCL ( 73,  80)];
+        char volume_space_size          [ISODCL ( 81,  88)]; /* 733 */
+        char unused3                    [ISODCL ( 89, 120)];
+        char volume_set_size            [ISODCL (121, 124)]; /* 723 */
+        char volume_sequence_number     [ISODCL (125, 128)]; /* 723 */
+        char logical_block_size         [ISODCL (129, 132)]; /* 723 */
+        char path_table_size            [ISODCL (133, 140)]; /* 733 */
+        char type_l_path_table          [ISODCL (141, 144)]; /* 731 */
+        char opt_type_l_path_table      [ISODCL (145, 148)]; /* 731 */
+        char type_m_path_table          [ISODCL (149, 152)]; /* 732 */
+        char opt_type_m_path_table      [ISODCL (153, 156)]; /* 732 */
+        char root_directory_record      [ISODCL (157, 190)]; /* 9.1 */
+        char volume_set_id              [ISODCL (191, 318)]; /* dchars */
+        char publisher_id               [ISODCL (319, 446)]; /* achars */
+        char preparer_id                [ISODCL (447, 574)]; /* achars */
+        char application_id             [ISODCL (575, 702)]; /* achars */
+        char copyright_file_id          [ISODCL (703, 739)]; /* 7.5 dchars */
+        char abstract_file_id           [ISODCL (740, 776)]; /* 7.5 dchars */
+        char bibliographic_file_id      [ISODCL (777, 813)]; /* 7.5 dchars */
+        char creation_date              [ISODCL (814, 830)]; /* 8.4.26.1 */
+        char modification_date          [ISODCL (831, 847)]; /* 8.4.26.1 */
+        char expiration_date            [ISODCL (848, 864)]; /* 8.4.26.1 */
+        char effective_date             [ISODCL (865, 881)]; /* 8.4.26.1 */
+        char file_structure_version     [ISODCL (882, 882)]; /* 711 */
+        char unused4                    [ISODCL (883, 883)];
+        char application_data           [ISODCL (884, 1395)];
+        char unused5                    [ISODCL (1396, 2048)];
+};
+
+/* Almost the same as the primary descriptor but two fields are specified */
+struct iso_supplementary_descriptor {
+        char type                       [ISODCL (  1,   1)]; /* 711 */
+        char id                         [ISODCL (  2,   6)];
+        char version                    [ISODCL (  7,   7)]; /* 711 */
+        char flags                      [ISODCL (  8,   8)]; /* 853 */
+        char system_id                  [ISODCL (  9,  40)]; /* achars */
+        char volume_id                  [ISODCL ( 41,  72)]; /* dchars */
+        char unused2                    [ISODCL ( 73,  80)];
+        char volume_space_size          [ISODCL ( 81,  88)]; /* 733 */
+        char escape                     [ISODCL ( 89, 120)]; /* 856 */
+        char volume_set_size            [ISODCL (121, 124)]; /* 723 */
+        char volume_sequence_number     [ISODCL (125, 128)]; /* 723 */
+        char logical_block_size         [ISODCL (129, 132)]; /* 723 */
+        char path_table_size            [ISODCL (133, 140)]; /* 733 */
+        char type_l_path_table          [ISODCL (141, 144)]; /* 731 */
+        char opt_type_l_path_table      [ISODCL (145, 148)]; /* 731 */
+        char type_m_path_table          [ISODCL (149, 152)]; /* 732 */
+        char opt_type_m_path_table      [ISODCL (153, 156)]; /* 732 */
+        char root_directory_record      [ISODCL (157, 190)]; /* 9.1 */
+        char volume_set_id              [ISODCL (191, 318)]; /* dchars */
+        char publisher_id               [ISODCL (319, 446)]; /* achars */
+        char preparer_id                [ISODCL (447, 574)]; /* achars */
+        char application_id             [ISODCL (575, 702)]; /* achars */
+        char copyright_file_id          [ISODCL (703, 739)]; /* 7.5 dchars */
+        char abstract_file_id           [ISODCL (740, 776)]; /* 7.5 dchars */
+        char bibliographic_file_id      [ISODCL (777, 813)]; /* 7.5 dchars */
+        char creation_date              [ISODCL (814, 830)]; /* 8.4.26.1 */
+        char modification_date          [ISODCL (831, 847)]; /* 8.4.26.1 */
+        char expiration_date            [ISODCL (848, 864)]; /* 8.4.26.1 */
+        char effective_date             [ISODCL (865, 881)]; /* 8.4.26.1 */
+        char file_structure_version     [ISODCL (882, 882)]; /* 711 */
+        char unused4                    [ISODCL (883, 883)];
+        char application_data           [ISODCL (884, 1395)];
+        char unused5                    [ISODCL (1396, 2048)];
+};
+
+
+#define HS_STANDARD_ID "CDROM"
+
+struct  hs_volume_descriptor {
+        char foo                        [ISODCL (  1,   8)]; /* 733 */
+        char type                       [ISODCL (  9,   9)]; /* 711 */
+        char id                         [ISODCL ( 10,  14)];
+        char version                    [ISODCL ( 15,  15)]; /* 711 */
+        char data[ISODCL(16,2048)];
+};
+
+
+struct hs_primary_descriptor {
+        char foo                        [ISODCL (  1,   8)]; /* 733 */
+        char type                       [ISODCL (  9,   9)]; /* 711 */
+        char id                         [ISODCL ( 10,  14)];
+        char version                    [ISODCL ( 15,  15)]; /* 711 */
+        char unused1                    [ISODCL ( 16,  16)]; /* 711 */
+        char system_id                  [ISODCL ( 17,  48)]; /* achars */
+        char volume_id                  [ISODCL ( 49,  80)]; /* dchars */
+        char unused2                    [ISODCL ( 81,  88)]; /* 733 */
+        char volume_space_size          [ISODCL ( 89,  96)]; /* 733 */
+        char unused3                    [ISODCL ( 97, 128)]; /* 733 */
+        char volume_set_size            [ISODCL (129, 132)]; /* 723 */
+        char volume_sequence_number     [ISODCL (133, 136)]; /* 723 */
+        char logical_block_size         [ISODCL (137, 140)]; /* 723 */
+        char path_table_size            [ISODCL (141, 148)]; /* 733 */
+        char type_l_path_table          [ISODCL (149, 152)]; /* 731 */
+        char unused4                    [ISODCL (153, 180)]; /* 733 */
+        char root_directory_record      [ISODCL (181, 214)]; /* 9.1 */
+};
+
+/* We use this to help us look up the parent inode numbers. */
+
+struct iso_path_table{
+        unsigned char  name_len[2];     /* 721 */
+        char extent[4];         /* 731 */
+        char  parent[2];        /* 721 */
+        char name[0];
+} __attribute__((packed));
+
+/* high sierra is identical to iso, except that the date is only 6 bytes, and
+   there is an extra reserved byte after the flags */
+
+struct iso_directory_record {
+        char length                     [ISODCL (1, 1)]; /* 711 */
+        char ext_attr_length            [ISODCL (2, 2)]; /* 711 */
+        char extent                     [ISODCL (3, 10)]; /* 733 */
+        char size                       [ISODCL (11, 18)]; /* 733 */
+        char date                       [ISODCL (19, 25)]; /* 7 by 711 */
+        char flags                      [ISODCL (26, 26)];
+        char file_unit_size             [ISODCL (27, 27)]; /* 711 */
+        char interleave                 [ISODCL (28, 28)]; /* 711 */
+        char volume_sequence_number     [ISODCL (29, 32)]; /* 723 */
+        unsigned char name_len          [ISODCL (33, 33)]; /* 711 */
+        char name                       [0];
+} __attribute__((packed));
+
+#define ISOFS_BLOCK_BITS 11
+#define ISOFS_BLOCK_SIZE 2048
+
+#define ISOFS_BUFFER_SIZE(INODE) ((INODE)->i_sb->s_blocksize)
+#define ISOFS_BUFFER_BITS(INODE) ((INODE)->i_sb->s_blocksize_bits)
+
+#define ISOFS_SUPER_MAGIC 0x9660
+
+#ifdef __KERNEL__
+/* Number conversion inlines, named after the section in ISO 9660
+   they correspond to. */
+
+#include <asm/byteorder.h>
+#include <asm/unaligned.h>
+#include <linux/iso_fs_i.h>
+#include <linux/iso_fs_sb.h>
+
+static inline struct isofs_sb_info *ISOFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct iso_inode_info *ISOFS_I(struct inode *inode)
+{
+        return container_of(inode, struct iso_inode_info, vfs_inode);
+}
+
+static inline int isonum_711(char *p)
+{
+        return *(u8 *)p;
+}
+static inline int isonum_712(char *p)
+{
+        return *(s8 *)p;
+}
+static inline unsigned int isonum_721(char *p)
+{
+        return le16_to_cpu(get_unaligned((__le16 *)p));
+}
+static inline unsigned int isonum_722(char *p)
+{
+        return be16_to_cpu(get_unaligned((__le16 *)p));
+}
+static inline unsigned int isonum_723(char *p)
+{
+        /* Ignore bigendian datum due to broken mastering programs */
+        return le16_to_cpu(get_unaligned((__le16 *)p));
+}
+static inline unsigned int isonum_731(char *p)
+{
+        return le32_to_cpu(get_unaligned((__le32 *)p));
+}
+static inline unsigned int isonum_732(char *p)
+{
+        return be32_to_cpu(get_unaligned((__le32 *)p));
+}
+static inline unsigned int isonum_733(char *p)
+{
+        /* Ignore bigendian datum due to broken mastering programs */
+        return le32_to_cpu(get_unaligned((__le32 *)p));
+}
+extern int iso_date(char *, int);
+
+struct inode;           /* To make gcc happy */
+
+extern int parse_rock_ridge_inode(struct iso_directory_record *, struct inode *);
+extern int get_rock_ridge_filename(struct iso_directory_record *, char *, struct inode *);
+extern int isofs_name_translate(struct iso_directory_record *, char *, struct inode *);
+
+int get_joliet_filename(struct iso_directory_record *, unsigned char *, struct inode *);
+int get_acorn_filename(struct iso_directory_record *, char *, struct inode *);
+
+extern struct dentry *isofs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct buffer_head *isofs_bread(struct inode *, sector_t);
+extern int isofs_get_blocks(struct inode *, sector_t, struct buffer_head **, unsigned long);
+
+extern struct inode *isofs_iget(struct super_block *sb,
+                                unsigned long block,
+                                unsigned long offset);
+
+/* Because the inode number is no longer relevant to finding the
+ * underlying meta-data for an inode, we are free to choose a more
+ * convenient 32-bit number as the inode number.  The inode numbering
+ * scheme was recommended by Sergey Vlasov and Eric Lammerts. */
+static inline unsigned long isofs_get_ino(unsigned long block,
+                                          unsigned long offset,
+                                          unsigned long bufbits)
+{
+        return (block << (bufbits - 5)) | (offset >> 5);
+}
+
+/* Every directory can have many redundant directory entries scattered
+ * throughout the directory tree.  First there is the directory entry
+ * with the name of the directory stored in the parent directory.
+ * Then, there is the "." directory entry stored in the directory
+ * itself.  Finally, there are possibly many ".." directory entries
+ * stored in all the subdirectories.
+ *
+ * In order for the NFS get_parent() method to work and for the
+ * general consistency of the dcache, we need to make sure the
+ * "i_iget5_block" and "i_iget5_offset" all point to exactly one of
+ * the many redundant entries for each directory.  We normalize the
+ * block and offset by always making them point to the "."  directory.
+ *
+ * Notice that we do not use the entry for the directory with the name
+ * that is located in the parent directory.  Even though choosing this
+ * first directory is more natural, it is much easier to find the "."
+ * entry in the NFS get_parent() method because it is implicitly
+ * encoded in the "extent + ext_attr_length" fields of _all_ the
+ * redundant entries for the directory.  Thus, it can always be
+ * reached regardless of which directory entry you have in hand.
+ *
+ * This works because the "." entry is simply the first directory
+ * record when you start reading the file that holds all the directory
+ * records, and this file starts at "extent + ext_attr_length" blocks.
+ * Because the "." entry is always the first entry listed in the
+ * directories file, the normalized "offset" value is always 0.
+ *
+ * You should pass the directory entry in "de".  On return, "block"
+ * and "offset" will hold normalized values.  Only directories are
+ * affected making it safe to call even for non-directory file
+ * types. */
+static inline void
+isofs_normalize_block_and_offset(struct iso_directory_record* de,
+                                 unsigned long *block,
+                                 unsigned long *offset)
+{
+        /* Only directories are normalized. */
+        if (de->flags[0] & 2) {
+                *offset = 0;
+                *block = (unsigned long)isonum_733(de->extent)
+                        + (unsigned long)isonum_711(de->ext_attr_length);
+        }
+}
+
+extern struct inode_operations isofs_dir_inode_operations;
+extern struct file_operations isofs_dir_operations;
+extern struct address_space_operations isofs_symlink_aops;
+extern struct export_operations isofs_export_ops;
+
+/* The following macros are used to check for memory leaks. */
+#ifdef LEAK_CHECK
+#define free_s leak_check_free_s
+#define malloc leak_check_malloc
+#define sb_bread leak_check_bread
+#define brelse leak_check_brelse
+extern void * leak_check_malloc(unsigned int size);
+extern void leak_check_free_s(void * obj, int size);
+extern struct buffer_head * leak_check_bread(struct super_block *sb, int block);
+extern void leak_check_brelse(struct buffer_head * bh);
+#endif /* LEAK_CHECK */
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/iso_fs_i.h b/include/linux/iso_fs_i.h
new file mode 100644
index 000000000000..59065e939eaa
--- /dev/null
+++ b/include/linux/iso_fs_i.h
@@ -0,0 +1,27 @@
+#ifndef _ISO_FS_I
+#define _ISO_FS_I
+
+#include <linux/fs.h>
+
+enum isofs_file_format {
+        isofs_file_normal = 0,
+        isofs_file_sparse = 1,
+        isofs_file_compressed = 2,
+};
+        
+/*
+ * iso fs inode data in memory
+ */
+struct iso_inode_info {
+        unsigned long i_iget5_block;
+        unsigned long i_iget5_offset;
+        unsigned int i_first_extent;
+        unsigned char i_file_format;
+        unsigned char i_format_parm[3];
+        unsigned long i_next_section_block;
+        unsigned long i_next_section_offset;
+        off_t i_section_size;
+        struct inode vfs_inode;
+};
+
+#endif
diff --git a/include/linux/iso_fs_sb.h b/include/linux/iso_fs_sb.h
new file mode 100644
index 000000000000..043b97b55b8d
--- /dev/null
+++ b/include/linux/iso_fs_sb.h
@@ -0,0 +1,34 @@
+#ifndef _ISOFS_FS_SB
+#define _ISOFS_FS_SB
+
+/*
+ * iso9660 super-block data in memory
+ */
+struct isofs_sb_info {
+        unsigned long s_ninodes;
+        unsigned long s_nzones;
+        unsigned long s_firstdatazone;
+        unsigned long s_log_zone_size;
+        unsigned long s_max_size;
+        
+        unsigned char s_high_sierra; /* A simple flag */
+        unsigned char s_mapping;
+        int           s_rock_offset; /* offset of SUSP fields within SU area */
+        unsigned char s_rock;
+        unsigned char s_joliet_level;
+        unsigned char s_utf8;
+        unsigned char s_cruft; /* Broken disks with high
+                                  byte of length containing
+                                  junk */
+        unsigned char s_unhide;
+        unsigned char s_nosuid;
+        unsigned char s_nodev;
+        unsigned char s_nocompress;
+
+        mode_t s_mode;
+        gid_t s_gid;
+        uid_t s_uid;
+        struct nls_table *s_nls_iocharset; /* Native language support table */
+};
+
+#endif
diff --git a/include/linux/istallion.h b/include/linux/istallion.h
new file mode 100644
index 000000000000..5f4ee646c119
--- /dev/null
+++ b/include/linux/istallion.h
@@ -0,0 +1,132 @@
+/*****************************************************************************/
+
+/*
+ *      istallion.h  -- stallion intelligent multiport serial driver.
+ *
+ *      Copyright (C) 1996-1998  Stallion Technologies
+ *      Copyright (C) 1994-1996  Greg Ungerer.
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/version.h>
+
+/*****************************************************************************/
+#ifndef _ISTALLION_H
+#define _ISTALLION_H
+/*****************************************************************************/
+
+/*
+ *      Define important driver constants here.
+ */
+#define STL_MAXBRDS             4
+#define STL_MAXPANELS           4
+#define STL_MAXPORTS            64
+#define STL_MAXCHANS            (STL_MAXPORTS + 1)
+#define STL_MAXDEVS             (STL_MAXBRDS * STL_MAXPORTS)
+
+
+/*
+ *      Define a set of structures to hold all the board/panel/port info
+ *      for our ports. These will be dynamically allocated as required at
+ *      driver initialization time.
+ */
+
+/*
+ *      Port and board structures to hold status info about each object.
+ *      The board structure contains pointers to structures for each port
+ *      connected to it. Panels are not distinguished here, since
+ *      communication with the slave board will always be on a per port
+ *      basis.
+ */
+typedef struct {
+        unsigned long           magic;
+        int                     portnr;
+        int                     panelnr;
+        int                     brdnr;
+        unsigned long           state;
+        int                     devnr;
+        int                     flags;
+        int                     baud_base;
+        int                     custom_divisor;
+        int                     close_delay;
+        int                     closing_wait;
+        int                     refcount;
+        int                     openwaitcnt;
+        int                     rc;
+        int                     argsize;
+        void                    *argp;
+        unsigned int            rxmarkmsk;
+        struct tty_struct       *tty;
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        wait_queue_head_t       raw_wait;
+        struct work_struct      tqhangup;
+        asysigs_t               asig;
+        unsigned long           addr;
+        unsigned long           rxoffset;
+        unsigned long           txoffset;
+        unsigned long           sigs;
+        unsigned long           pflag;
+        unsigned int            rxsize;
+        unsigned int            txsize;
+        unsigned char           reqbit;
+        unsigned char           portidx;
+        unsigned char           portbit;
+} stliport_t;
+
+/*
+ *      Use a structure of function pointers to do board level operations.
+ *      These include, enable/disable, paging shared memory, interrupting, etc.
+ */
+typedef struct stlibrd {
+        unsigned long   magic;
+        int             brdnr;
+        int             brdtype;
+        int             state;
+        int             nrpanels;
+        int             nrports;
+        int             nrdevs;
+        unsigned int    iobase;
+        int             iosize;
+        unsigned long   memaddr;
+        void            *membase;
+        int             memsize;
+        int             pagesize;
+        int             hostoffset;
+        int             slaveoffset;
+        int             bitsize;
+        int             enabval;
+        int             panels[STL_MAXPANELS];
+        int             panelids[STL_MAXPANELS];
+        void            (*init)(struct stlibrd *brdp);
+        void            (*enable)(struct stlibrd *brdp);
+        void            (*reenable)(struct stlibrd *brdp);
+        void            (*disable)(struct stlibrd *brdp);
+        char            *(*getmemptr)(struct stlibrd *brdp, unsigned long offset, int line);
+        void            (*intr)(struct stlibrd *brdp);
+        void            (*reset)(struct stlibrd *brdp);
+        stliport_t      *ports[STL_MAXPORTS];
+} stlibrd_t;
+
+
+/*
+ *      Define MAGIC numbers used for above structures.
+ */
+#define STLI_PORTMAGIC  0xe671c7a1
+#define STLI_BOARDMAGIC 0x4bc6c825
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/ite_gpio.h b/include/linux/ite_gpio.h
new file mode 100644
index 000000000000..b123a14292d3
--- /dev/null
+++ b/include/linux/ite_gpio.h
@@ -0,0 +1,66 @@
+/*
+ * FILE NAME ite_gpio.h
+ *
+ * BRIEF MODULE DESCRIPTION
+ *      Generic gpio.
+ *
+ *  Author: MontaVista Software, Inc.  <source@mvista.com>
+ *          Hai-Pao Fan <haipao@mvista.com>
+ *
+ * Copyright 2001 MontaVista Software Inc.
+ *
+ *  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;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __ITE_GPIO_H
+#define __ITE_GPIO_H
+
+#include <linux/ioctl.h>
+
+struct ite_gpio_ioctl_data {
+        __u32 device;
+        __u32 mask;
+        __u32 data;
+};
+
+#define ITE_GPIO_IOCTL_BASE     'Z'
+
+#define ITE_GPIO_IN             _IOWR(ITE_GPIO_IOCTL_BASE, 0, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_OUT            _IOW (ITE_GPIO_IOCTL_BASE, 1, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_INT_CTRL       _IOW (ITE_GPIO_IOCTL_BASE, 2, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_IN_STATUS      _IOW (ITE_GPIO_IOCTL_BASE, 3, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_OUT_STATUS     _IOW (ITE_GPIO_IOCTL_BASE, 4, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_GEN_CTRL       _IOW (ITE_GPIO_IOCTL_BASE, 5, struct ite_gpio_ioctl_data)
+#define ITE_GPIO_INT_WAIT       _IOW (ITE_GPIO_IOCTL_BASE, 6, struct ite_gpio_ioctl_data)
+
+#define ITE_GPIO_PORTA  0x01
+#define ITE_GPIO_PORTB  0x02
+#define ITE_GPIO_PORTC  0x04
+
+extern int ite_gpio_in(__u32 device, __u32 mask, volatile __u32 *data);
+extern int ite_gpio_out(__u32 device, __u32 mask, __u32 data);
+extern int ite_gpio_int_ctrl(__u32 device, __u32 mask, __u32 data);
+extern int ite_gpio_in_status(__u32 device, __u32 mask, volatile __u32 *data);
+extern int ite_gpio_out_status(__u32 device, __u32 mask, __u32 data);
+extern int ite_gpio_gen_ctrl(__u32 device, __u32 mask, __u32 data);
+extern int ite_gpio_int_wait(__u32 device, __u32 mask, __u32 data);
+
+#endif
diff --git a/include/linux/ixjuser.h b/include/linux/ixjuser.h
new file mode 100644
index 000000000000..88121166d715
--- /dev/null
+++ b/include/linux/ixjuser.h
@@ -0,0 +1,722 @@
+#ifndef __LINUX_IXJUSER_H
+#define __LINUX_IXJUSER_H
+
+/******************************************************************************
+ *
+ *    ixjuser.h
+ *
+ * Device Driver for Quicknet Technologies, Inc.'s Telephony cards
+ * including the Internet PhoneJACK, Internet PhoneJACK Lite,
+ * Internet PhoneJACK PCI, Internet LineJACK, Internet PhoneCARD and
+ * SmartCABLE
+ *
+ *    (c) Copyright 1999-2001  Quicknet Technologies, Inc.
+ *
+ *    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; either version
+ *    2 of the License, or (at your option) any later version.
+ *
+ * Author:          Ed Okerson, <eokerson@quicknet.net>
+ *    
+ * Contributors:    Greg Herlein, <gherlein@quicknet.net>
+ *                  David W. Erhart, <derhart@quicknet.net>
+ *                  John Sellers, <jsellers@quicknet.net>
+ *                  Mike Preston, <mpreston@quicknet.net>
+ *
+ * More information about the hardware related to this driver can be found
+ * at our website:    http://www.quicknet.net
+ *
+ * Fixes:
+ *
+ * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
+ * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
+ * TECHNOLOGIES, INC.HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION 
+ * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ *****************************************************************************/
+
+static char ixjuser_h_rcsid[] = "$Id: ixjuser.h,v 4.1 2001/08/05 00:17:37 craigs Exp $";
+
+#include <linux/telephony.h>
+
+
+/******************************************************************************
+*
+* IOCTL's used for the Quicknet Telephony Cards
+*
+* If you use the IXJCTL_TESTRAM command, the card must be power cycled to
+* reset the SRAM values before futher use.
+*
+******************************************************************************/
+
+#define IXJCTL_DSP_RESET                _IO  ('q', 0xC0)
+
+#define IXJCTL_RING                     PHONE_RING
+#define IXJCTL_HOOKSTATE                PHONE_HOOKSTATE
+#define IXJCTL_MAXRINGS                 PHONE_MAXRINGS
+#define IXJCTL_RING_CADENCE             PHONE_RING_CADENCE
+#define IXJCTL_RING_START               PHONE_RING_START
+#define IXJCTL_RING_STOP                PHONE_RING_STOP
+
+#define IXJCTL_CARDTYPE                 _IOR ('q', 0xC1, int)
+#define IXJCTL_SERIAL                   _IOR ('q', 0xC2, int)
+#define IXJCTL_DSP_TYPE                 _IOR ('q', 0xC3, int)
+#define IXJCTL_DSP_VERSION              _IOR ('q', 0xC4, int)
+#define IXJCTL_VERSION                  _IOR ('q', 0xDA, char *)
+#define IXJCTL_DSP_IDLE                 _IO  ('q', 0xC5)
+#define IXJCTL_TESTRAM                  _IO  ('q', 0xC6)
+
+/******************************************************************************
+*
+* This group of IOCTLs deal with the record settings of the DSP
+*
+* The IXJCTL_REC_DEPTH command sets the internal buffer depth of the DSP.
+* Setting a lower depth reduces latency, but increases the demand of the
+* application to service the driver without frame loss.  The DSP has 480
+* bytes of physical buffer memory for the record channel so the true
+* maximum limit is determined by how many frames will fit in the buffer.
+*
+* 1 uncompressed (480 byte) 16-bit linear frame.
+* 2 uncompressed (240 byte) 8-bit A-law/mu-law frames.
+* 15 TrueSpeech 8.5 frames.
+* 20 TrueSpeech 6.3,5.3,4.8 or 4.1 frames.
+*
+* The default in the driver is currently set to 2 frames.
+*
+* The IXJCTL_REC_VOLUME and IXJCTL_PLAY_VOLUME commands both use a Q8
+* number as a parameter, 0x100 scales the signal by 1.0, 0x200 scales the
+* signal by 2.0, 0x80 scales the signal by 0.5.  No protection is given
+* against over-scaling, if the multiplication factor times the input
+* signal exceeds 16 bits, overflow distortion will occur.  The default
+* setting is 0x100 (1.0).
+*
+* The IXJCTL_REC_LEVEL returns the average signal level (not r.m.s.) on
+* the most recently recorded frame as a 16 bit value.
+******************************************************************************/
+
+#define IXJCTL_REC_CODEC                PHONE_REC_CODEC
+#define IXJCTL_REC_START                PHONE_REC_START
+#define IXJCTL_REC_STOP                 PHONE_REC_STOP
+#define IXJCTL_REC_DEPTH                PHONE_REC_DEPTH
+#define IXJCTL_FRAME                    PHONE_FRAME
+#define IXJCTL_REC_VOLUME               PHONE_REC_VOLUME
+#define IXJCTL_REC_LEVEL                PHONE_REC_LEVEL
+
+typedef enum {
+        f300_640 = 4, f300_500, f1100, f350, f400, f480, f440, f620, f20_50,
+        f133_200, f300, f300_420, f330, f300_425, f330_440, f340, f350_400,
+        f350_440, f350_450, f360, f380_420, f392, f400_425, f400_440, f400_450,
+        f420, f425, f425_450, f425_475, f435, f440_450, f440_480, f445, f450,
+        f452, f475, f480_620, f494, f500, f520, f523, f525, f540_660, f587,
+        f590, f600, f660, f700, f740, f750, f750_1450, f770, f800, f816, f850,
+        f857_1645, f900, f900_1300, f935_1215, f941_1477, f942, f950, f950_1400,
+        f975, f1000, f1020, f1050, f1100_1750, f1140, f1200, f1209, f1330, f1336,
+        lf1366, f1380, f1400, f1477, f1600, f1633_1638, f1800, f1860
+} IXJ_FILTER_FREQ;
+
+typedef struct {
+        unsigned int filter;
+        IXJ_FILTER_FREQ freq;
+        char enable;
+} IXJ_FILTER;
+
+typedef struct {
+        char enable;
+        char en_filter;
+        unsigned int filter;
+        unsigned int on1;
+        unsigned int off1;
+        unsigned int on2;
+        unsigned int off2;
+        unsigned int on3;
+        unsigned int off3;
+} IXJ_FILTER_CADENCE;
+
+#define IXJCTL_SET_FILTER               _IOW ('q', 0xC7, IXJ_FILTER *)
+#define IXJCTL_SET_FILTER_RAW           _IOW ('q', 0xDD, IXJ_FILTER_RAW *)
+#define IXJCTL_GET_FILTER_HIST          _IOW ('q', 0xC8, int)
+#define IXJCTL_FILTER_CADENCE           _IOW ('q', 0xD6, IXJ_FILTER_CADENCE *)
+#define IXJCTL_PLAY_CID                 _IO  ('q', 0xD7)
+/******************************************************************************
+*
+* This IOCTL allows you to reassign values in the tone index table.  The
+* tone table has 32 entries (0 - 31), but the driver only allows entries
+* 13 - 27 to be modified, entry 0 is reserved for silence and 1 - 12 are
+* the standard DTMF digits and 28 - 31 are the DTMF tones for A, B, C & D.
+* The positions used internally for Call Progress Tones are as follows:
+*    Dial Tone   - 25
+*    Ring Back   - 26
+*    Busy Signal - 27
+*
+* The freq values are calculated as:
+* freq = cos(2 * PI * frequency / 8000)
+*
+* The most commonly needed values are already calculated and listed in the
+* enum IXJ_TONE_FREQ.  Each tone index can have two frequencies with
+* different gains, if you are only using a single frequency set the unused
+* one to 0.
+*
+* The gain values range from 0 to 15 indicating +6dB to -24dB in 2dB
+* increments.
+*
+******************************************************************************/
+
+typedef enum {
+        hz20 = 0x7ffa,
+        hz50 = 0x7fe5,
+        hz133 = 0x7f4c,
+        hz200 = 0x7e6b,
+        hz261 = 0x7d50,         /* .63 C1  */
+        hz277 = 0x7cfa,         /* .18 CS1 */
+        hz293 = 0x7c9f,         /* .66 D1  */
+        hz300 = 0x7c75,
+        hz311 = 0x7c32,         /* .13 DS1 */
+        hz329 = 0x7bbf,         /* .63 E1  */
+        hz330 = 0x7bb8,
+        hz340 = 0x7b75,
+        hz349 = 0x7b37,         /* .23 F1  */
+        hz350 = 0x7b30,
+        hz360 = 0x7ae9,
+        hz369 = 0x7aa8,         /* .99 FS1 */
+        hz380 = 0x7a56,
+        hz392 = 0x79fa,         /* .00 G1  */
+        hz400 = 0x79bb,
+        hz415 = 0x7941,         /* .30 GS1 */
+        hz420 = 0x7918,
+        hz425 = 0x78ee,
+        hz435 = 0x7899,
+        hz440 = 0x786d,         /* .00 A1  */
+        hz445 = 0x7842,
+        hz450 = 0x7815,
+        hz452 = 0x7803,
+        hz466 = 0x7784,         /* .16 AS1 */
+        hz475 = 0x7731,
+        hz480 = 0x7701,
+        hz493 = 0x7685,         /* .88 B1  */
+        hz494 = 0x767b,
+        hz500 = 0x7640,
+        hz520 = 0x7578,
+        hz523 = 0x7559,         /* .25 C2  */
+        hz525 = 0x7544,
+        hz540 = 0x74a7,
+        hz554 = 0x7411,         /* .37 CS2 */
+        hz587 = 0x72a1,         /* .33 D2  */
+        hz590 = 0x727f,
+        hz600 = 0x720b,
+        hz620 = 0x711e,
+        hz622 = 0x7106,         /* .25 DS2 */
+        hz659 = 0x6f3b,         /* .26 E2  */
+        hz660 = 0x6f2e,
+        hz698 = 0x6d3d,         /* .46 F2  */
+        hz700 = 0x6d22,
+        hz739 = 0x6b09,         /* .99 FS2 */
+        hz740 = 0x6afa,
+        hz750 = 0x6a6c,
+        hz770 = 0x694b,
+        hz783 = 0x688b,         /* .99 G2  */
+        hz800 = 0x678d,
+        hz816 = 0x6698,
+        hz830 = 0x65bf,         /* .61 GS2 */
+        hz850 = 0x6484,
+        hz857 = 0x6414,
+        hz880 = 0x629f,         /* .00 A2  */
+        hz900 = 0x6154,
+        hz932 = 0x5f35,         /* .33 AS2 */
+        hz935 = 0x5f01,
+        hz941 = 0x5e9a,
+        hz942 = 0x5e88,
+        hz950 = 0x5dfd,
+        hz975 = 0x5c44,
+        hz1000 = 0x5a81,
+        hz1020 = 0x5912,
+        hz1050 = 0x56e2,
+        hz1100 = 0x5320,
+        hz1140 = 0x5007,
+        hz1200 = 0x4b3b,
+        hz1209 = 0x4a80,
+        hz1215 = 0x4a02,
+        hz1250 = 0x471c,
+        hz1300 = 0x42e0,
+        hz1330 = 0x4049,
+        hz1336 = 0x3fc4,
+        hz1366 = 0x3d22,
+        hz1380 = 0x3be4,
+        hz1400 = 0x3a1b,
+        hz1450 = 0x3596,
+        hz1477 = 0x331c,
+        hz1500 = 0x30fb,
+        hz1600 = 0x278d,
+        hz1633 = 0x2462,
+        hz1638 = 0x23e7,
+        hz1645 = 0x233a,
+        hz1750 = 0x18f8,
+        hz1800 = 0x1405,
+        hz1860 = 0xe0b,
+        hz2100 = 0xf5f6,
+        hz2130 = 0xf2f5,
+        hz2450 = 0xd3b3,
+        hz2750 = 0xb8e4
+} IXJ_FREQ;
+
+typedef enum {
+        C1 = hz261,
+        CS1 = hz277,
+        D1 = hz293,
+        DS1 = hz311,
+        E1 = hz329,
+        F1 = hz349,
+        FS1 = hz369,
+        G1 = hz392,
+        GS1 = hz415,
+        A1 = hz440,
+        AS1 = hz466,
+        B1 = hz493,
+        C2 = hz523,
+        CS2 = hz554,
+        D2 = hz587,
+        DS2 = hz622,
+        E2 = hz659,
+        F2 = hz698,
+        FS2 = hz739,
+        G2 = hz783,
+        GS2 = hz830,
+        A2 = hz880,
+        AS2 = hz932,
+} IXJ_NOTE;
+
+typedef struct {
+        int tone_index;
+        int freq0;
+        int gain0;
+        int freq1;
+        int gain1;
+} IXJ_TONE;
+
+#define IXJCTL_INIT_TONE                _IOW ('q', 0xC9, IXJ_TONE *)
+
+/******************************************************************************
+*
+* The IXJCTL_TONE_CADENCE ioctl defines tone sequences used for various
+* Call Progress Tones (CPT).  This is accomplished by setting up an array of
+* IXJ_CADENCE_ELEMENT structures that sequentially define the states of
+* the tone sequence.  The tone_on_time and tone_off time are in
+* 250 microsecond intervals.  A pointer to this array is passed to the
+* driver as the ce element of an IXJ_CADENCE structure.  The elements_used
+* must be set to the number of IXJ_CADENCE_ELEMENTS in the array.  The
+* termination variable defines what to do at the end of a cadence, the
+* options are to play the cadence once and stop, to repeat the last
+* element of the cadence indefinitely, or to repeat the entire cadence
+* indefinitely.  The ce variable is a pointer to the array of IXJ_TONE
+* structures.  If the freq0 variable is non-zero, the tone table contents
+* for the tone_index are updated to the frequencies and gains defined.  It
+* should be noted that DTMF tones cannot be reassigned, so if DTMF tone
+* table indexs are used in a cadence the frequency and gain variables will
+* be ignored.
+*
+* If the array elements contain frequency parameters the driver will
+* initialize the needed tone table elements and begin playing the tone,
+* there is no preset limit on the number of elements in the cadence.  If
+* there is more than one frequency used in the cadence, sequential elements
+* of different frequencies MUST use different tone table indexes.  Only one
+* cadence can be played at a time.  It is possible to build complex
+* cadences with multiple frequencies using 2 tone table indexes by
+* alternating between them.
+*
+******************************************************************************/
+
+typedef struct {
+        int index;
+        int tone_on_time;
+        int tone_off_time;
+        int freq0;
+        int gain0;
+        int freq1;
+        int gain1;
+} IXJ_CADENCE_ELEMENT;
+
+typedef enum {
+        PLAY_ONCE,
+        REPEAT_LAST_ELEMENT,
+        REPEAT_ALL
+} IXJ_CADENCE_TERM;
+
+typedef struct {
+        int elements_used;
+        IXJ_CADENCE_TERM termination;
+        IXJ_CADENCE_ELEMENT __user *ce;
+} IXJ_CADENCE;
+
+#define IXJCTL_TONE_CADENCE             _IOW ('q', 0xCA, IXJ_CADENCE *)
+/******************************************************************************
+*
+* This group of IOCTLs deal with the playback settings of the DSP
+*
+******************************************************************************/
+
+#define IXJCTL_PLAY_CODEC               PHONE_PLAY_CODEC
+#define IXJCTL_PLAY_START               PHONE_PLAY_START
+#define IXJCTL_PLAY_STOP                PHONE_PLAY_STOP
+#define IXJCTL_PLAY_DEPTH               PHONE_PLAY_DEPTH
+#define IXJCTL_PLAY_VOLUME              PHONE_PLAY_VOLUME
+#define IXJCTL_PLAY_LEVEL               PHONE_PLAY_LEVEL
+
+/******************************************************************************
+*
+* This group of IOCTLs deal with the Acoustic Echo Cancellation settings
+* of the DSP
+*
+* Issuing the IXJCTL_AEC_START command with a value of AEC_OFF has the
+* same effect as IXJCTL_AEC_STOP.  This is to simplify slider bar
+* controls.  IXJCTL_AEC_GET_LEVEL returns the current setting of the AEC.
+******************************************************************************/
+#define IXJCTL_AEC_START                _IOW ('q', 0xCB, int)
+#define IXJCTL_AEC_STOP                 _IO  ('q', 0xCC)
+#define IXJCTL_AEC_GET_LEVEL            _IO  ('q', 0xCD)
+
+#define AEC_OFF   0
+#define AEC_LOW   1
+#define AEC_MED   2
+#define AEC_HIGH  3
+#define AEC_AUTO  4
+#define AEC_AGC   5
+/******************************************************************************
+*
+* Call Progress Tones, DTMF, etc.
+* IXJCTL_DTMF_OOB determines if DTMF signaling is sent as Out-Of-Band
+* only.  If you pass a 1, DTMF is suppressed from the audio stream.
+* Tone on and off times are in 250 microsecond intervals so
+* ioctl(ixj1, IXJCTL_SET_TONE_ON_TIME, 360);
+* will set the tone on time of board ixj1 to 360 * 250us = 90ms
+* the default values of tone on and off times is 840 or 210ms
+******************************************************************************/
+
+#define IXJCTL_DTMF_READY               PHONE_DTMF_READY
+#define IXJCTL_GET_DTMF                 PHONE_GET_DTMF
+#define IXJCTL_GET_DTMF_ASCII           PHONE_GET_DTMF_ASCII
+#define IXJCTL_DTMF_OOB                 PHONE_DTMF_OOB
+#define IXJCTL_EXCEPTION                PHONE_EXCEPTION
+#define IXJCTL_PLAY_TONE                PHONE_PLAY_TONE
+#define IXJCTL_SET_TONE_ON_TIME         PHONE_SET_TONE_ON_TIME
+#define IXJCTL_SET_TONE_OFF_TIME        PHONE_SET_TONE_OFF_TIME
+#define IXJCTL_GET_TONE_ON_TIME         PHONE_GET_TONE_ON_TIME
+#define IXJCTL_GET_TONE_OFF_TIME        PHONE_GET_TONE_OFF_TIME
+#define IXJCTL_GET_TONE_STATE           PHONE_GET_TONE_STATE
+#define IXJCTL_BUSY                     PHONE_BUSY
+#define IXJCTL_RINGBACK                 PHONE_RINGBACK
+#define IXJCTL_DIALTONE                 PHONE_DIALTONE
+#define IXJCTL_CPT_STOP                 PHONE_CPT_STOP
+
+/******************************************************************************
+* LineJACK specific IOCTLs
+*
+* The lsb 4 bits of the LED argument represent the state of each of the 4
+* LED's on the LineJACK
+******************************************************************************/
+
+#define IXJCTL_SET_LED                  _IOW ('q', 0xCE, int)
+#define IXJCTL_MIXER                    _IOW ('q', 0xCF, int)
+
+/******************************************************************************
+* 
+* The master volume controls use attenuation with 32 levels from 0 to -62dB
+* with steps of 2dB each, the defines should be OR'ed together then sent
+* as the parameter to the mixer command to change the mixer settings.
+* 
+******************************************************************************/
+#define MIXER_MASTER_L          0x0000
+#define MIXER_MASTER_R          0x0100
+#define ATT00DB                 0x00
+#define ATT02DB                 0x01
+#define ATT04DB                 0x02
+#define ATT06DB                 0x03
+#define ATT08DB                 0x04
+#define ATT10DB                 0x05
+#define ATT12DB                 0x06
+#define ATT14DB                 0x07
+#define ATT16DB                 0x08
+#define ATT18DB                 0x09
+#define ATT20DB                 0x0A
+#define ATT22DB                 0x0B
+#define ATT24DB                 0x0C
+#define ATT26DB                 0x0D
+#define ATT28DB                 0x0E
+#define ATT30DB                 0x0F
+#define ATT32DB                 0x10
+#define ATT34DB                 0x11
+#define ATT36DB                 0x12
+#define ATT38DB                 0x13
+#define ATT40DB                 0x14
+#define ATT42DB                 0x15
+#define ATT44DB                 0x16
+#define ATT46DB                 0x17
+#define ATT48DB                 0x18
+#define ATT50DB                 0x19
+#define ATT52DB                 0x1A
+#define ATT54DB                 0x1B
+#define ATT56DB                 0x1C
+#define ATT58DB                 0x1D
+#define ATT60DB                 0x1E
+#define ATT62DB                 0x1F
+#define MASTER_MUTE             0x80
+
+/******************************************************************************
+* 
+* The input volume controls use gain with 32 levels from +12dB to -50dB
+* with steps of 2dB each, the defines should be OR'ed together then sent
+* as the parameter to the mixer command to change the mixer settings.
+* 
+******************************************************************************/
+#define MIXER_PORT_CD_L         0x0600
+#define MIXER_PORT_CD_R         0x0700
+#define MIXER_PORT_LINE_IN_L    0x0800
+#define MIXER_PORT_LINE_IN_R    0x0900
+#define MIXER_PORT_POTS_REC     0x0C00
+#define MIXER_PORT_MIC          0x0E00
+
+#define GAIN12DB                0x00
+#define GAIN10DB                0x01
+#define GAIN08DB                0x02
+#define GAIN06DB                0x03
+#define GAIN04DB                0x04
+#define GAIN02DB                0x05
+#define GAIN00DB                0x06
+#define GAIN_02DB               0x07
+#define GAIN_04DB               0x08
+#define GAIN_06DB               0x09
+#define GAIN_08DB               0x0A
+#define GAIN_10DB               0x0B
+#define GAIN_12DB               0x0C
+#define GAIN_14DB               0x0D
+#define GAIN_16DB               0x0E
+#define GAIN_18DB               0x0F
+#define GAIN_20DB               0x10
+#define GAIN_22DB               0x11
+#define GAIN_24DB               0x12
+#define GAIN_26DB               0x13
+#define GAIN_28DB               0x14
+#define GAIN_30DB               0x15
+#define GAIN_32DB               0x16
+#define GAIN_34DB               0x17
+#define GAIN_36DB               0x18
+#define GAIN_38DB               0x19
+#define GAIN_40DB               0x1A
+#define GAIN_42DB               0x1B
+#define GAIN_44DB               0x1C
+#define GAIN_46DB               0x1D
+#define GAIN_48DB               0x1E
+#define GAIN_50DB               0x1F
+#define INPUT_MUTE              0x80
+
+/******************************************************************************
+* 
+* The POTS volume control use attenuation with 8 levels from 0dB to -28dB
+* with steps of 4dB each, the defines should be OR'ed together then sent
+* as the parameter to the mixer command to change the mixer settings.
+* 
+******************************************************************************/
+#define MIXER_PORT_POTS_PLAY    0x0F00
+
+#define POTS_ATT_00DB           0x00
+#define POTS_ATT_04DB           0x01
+#define POTS_ATT_08DB           0x02
+#define POTS_ATT_12DB           0x03
+#define POTS_ATT_16DB           0x04
+#define POTS_ATT_20DB           0x05
+#define POTS_ATT_24DB           0x06
+#define POTS_ATT_28DB           0x07
+#define POTS_MUTE               0x80
+
+/******************************************************************************
+* 
+* The DAA controls the interface to the PSTN port.  The driver loads the
+* US coefficients by default, so if you live in a different country you
+* need to load the set for your countries phone system.
+* 
+******************************************************************************/
+#define IXJCTL_DAA_COEFF_SET            _IOW ('q', 0xD0, int)
+
+#define DAA_US          1       /*PITA 8kHz */
+#define DAA_UK          2       /*ISAR34 8kHz */
+#define DAA_FRANCE      3       /* */
+#define DAA_GERMANY     4
+#define DAA_AUSTRALIA   5
+#define DAA_JAPAN       6
+
+/******************************************************************************
+* 
+* Use IXJCTL_PORT to set or query the port the card is set to.  If the
+* argument is set to PORT_QUERY, the return value of the ioctl will
+* indicate which port is currently in use, otherwise it will change the
+* port.
+* 
+******************************************************************************/
+#define IXJCTL_PORT                     _IOW ('q', 0xD1, int)
+
+#define PORT_QUERY      0
+#define PORT_POTS       1
+#define PORT_PSTN       2
+#define PORT_SPEAKER    3
+#define PORT_HANDSET    4
+
+#define IXJCTL_PSTN_SET_STATE           PHONE_PSTN_SET_STATE
+#define IXJCTL_PSTN_GET_STATE           PHONE_PSTN_GET_STATE
+
+#define PSTN_ON_HOOK    0
+#define PSTN_RINGING    1
+#define PSTN_OFF_HOOK   2
+#define PSTN_PULSE_DIAL 3
+
+/******************************************************************************
+* 
+* The DAA Analog GAIN sets 2 parameters at one time, the receive gain (AGRR), 
+* and the transmit gain (AGX).  OR together the components and pass them
+* as the parameter to IXJCTL_DAA_AGAIN.  The default setting is both at 0dB.
+* 
+******************************************************************************/
+#define IXJCTL_DAA_AGAIN                _IOW ('q', 0xD2, int)
+
+#define AGRR00DB        0x00    /* Analog gain in receive direction 0dB */
+#define AGRR3_5DB       0x10    /* Analog gain in receive direction 3.5dB */
+#define AGRR06DB        0x30    /* Analog gain in receive direction 6dB */
+
+#define AGX00DB         0x00    /* Analog gain in transmit direction 0dB */
+#define AGX_6DB         0x04    /* Analog gain in transmit direction -6dB */
+#define AGX3_5DB        0x08    /* Analog gain in transmit direction 3.5dB */
+#define AGX_2_5B        0x0C    /* Analog gain in transmit direction -2.5dB */
+
+#define IXJCTL_PSTN_LINETEST            _IO  ('q', 0xD3)
+
+#define IXJCTL_CID                      _IOR ('q', 0xD4, PHONE_CID *)
+#define IXJCTL_VMWI                     _IOR ('q', 0xD8, int)
+#define IXJCTL_CIDCW                    _IOW ('q', 0xD9, PHONE_CID *)
+/******************************************************************************
+* 
+* The wink duration is tunable with this ioctl.  The default wink duration  
+* is 320ms.  You do not need to use this ioctl if you do not require a
+* different wink duration.
+* 
+******************************************************************************/
+#define IXJCTL_WINK_DURATION            PHONE_WINK_DURATION
+
+/******************************************************************************
+* 
+* This ioctl will connect the POTS port to the PSTN port on the LineJACK
+* In order for this to work properly the port selection should be set to
+* the PSTN port with IXJCTL_PORT prior to calling this ioctl.  This will
+* enable conference calls between PSTN callers and network callers.
+* Passing a 1 to this ioctl enables the POTS<->PSTN connection while
+* passing a 0 turns it back off.
+* 
+******************************************************************************/
+#define IXJCTL_POTS_PSTN                _IOW ('q', 0xD5, int)
+
+/******************************************************************************
+*
+* IOCTLs added by request.
+*
+* IXJCTL_HZ sets the value your Linux kernel uses for HZ as defined in
+*           /usr/include/asm/param.h, this determines the fundamental
+*           frequency of the clock ticks on your Linux system.  The kernel
+*           must be rebuilt if you change this value, also all modules you
+*           use (except this one) must be recompiled.  The default value
+*           is 100, and you only need to use this IOCTL if you use some
+*           other value.
+*
+*
+* IXJCTL_RATE sets the number of times per second that the driver polls
+*             the DSP.  This value cannot be larger than HZ.  By
+*             increasing both of these values, you may be able to reduce
+*             latency because the max hang time that can exist between the
+*             driver and the DSP will be reduced.
+*
+******************************************************************************/
+
+#define IXJCTL_HZ                       _IOW ('q', 0xE0, int)
+#define IXJCTL_RATE                     _IOW ('q', 0xE1, int)
+#define IXJCTL_FRAMES_READ              _IOR ('q', 0xE2, unsigned long)
+#define IXJCTL_FRAMES_WRITTEN           _IOR ('q', 0xE3, unsigned long)
+#define IXJCTL_READ_WAIT                _IOR ('q', 0xE4, unsigned long)
+#define IXJCTL_WRITE_WAIT               _IOR ('q', 0xE5, unsigned long)
+#define IXJCTL_DRYBUFFER_READ           _IOR ('q', 0xE6, unsigned long)
+#define IXJCTL_DRYBUFFER_CLEAR          _IO  ('q', 0xE7)
+#define IXJCTL_DTMF_PRESCALE            _IOW ('q', 0xE8, int)
+
+/******************************************************************************
+*
+* This ioctl allows the user application to control what events the driver
+* will send signals for, and what signals it will send for which event.
+* By default, if signaling is enabled, all events will send SIGIO when
+* they occur.  To disable signals for an event set the signal to 0.
+*
+******************************************************************************/
+typedef enum {
+        SIG_DTMF_READY,
+        SIG_HOOKSTATE,
+        SIG_FLASH,
+        SIG_PSTN_RING,
+        SIG_CALLER_ID,
+        SIG_PSTN_WINK,
+        SIG_F0, SIG_F1, SIG_F2, SIG_F3,
+        SIG_FC0, SIG_FC1, SIG_FC2, SIG_FC3,
+        SIG_READ_READY = 33,
+        SIG_WRITE_READY = 34
+} IXJ_SIGEVENT;
+
+typedef struct {
+        unsigned int event;
+        int signal;
+} IXJ_SIGDEF;
+
+#define IXJCTL_SIGCTL                   _IOW ('q', 0xE9, IXJ_SIGDEF *)
+
+/******************************************************************************
+*
+* These ioctls allow the user application to change the gain in the 
+* Smart Cable of the Internet Phone Card.  Sending -1 as a value will cause
+* return value to be the current setting.  Valid values to set are 0x00 - 0x1F
+*
+* 11111 = +12 dB
+* 10111 =   0 dB
+* 00000 = -34.5 dB
+*
+* IXJCTL_SC_RXG sets the Receive gain
+* IXJCTL_SC_TXG sets the Transmit gain
+*
+******************************************************************************/
+#define IXJCTL_SC_RXG                   _IOW ('q', 0xEA, int)
+#define IXJCTL_SC_TXG                   _IOW ('q', 0xEB, int)
+
+/******************************************************************************
+*
+* The intercom IOCTL's short the output from one card to the input of the
+* other and vice versa (actually done in the DSP read function).  It is only
+* necessary to execute the IOCTL on one card, but it is necessary to have
+* both devices open to be able to detect hook switch changes.  The record
+* codec and rate of each card must match the playback codec and rate of
+* the other card for this to work properly.
+*
+******************************************************************************/
+
+#define IXJCTL_INTERCOM_START           _IOW ('q', 0xFD, int)
+#define IXJCTL_INTERCOM_STOP            _IOW ('q', 0xFE, int)
+
+/******************************************************************************
+ *
+ * new structure for accessing raw filter information
+ *
+ ******************************************************************************/
+
+typedef struct {
+        unsigned int filter;
+        char enable;
+        unsigned int coeff[19];
+} IXJ_FILTER_RAW;
+
+#endif
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
new file mode 100644
index 000000000000..593407e865b1
--- /dev/null
+++ b/include/linux/jbd.h
@@ -0,0 +1,1098 @@
+/*
+ * linux/include/linux/jbd.h
+ * 
+ * Written by Stephen C. Tweedie <sct@redhat.com>
+ *
+ * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * Definitions for transaction data structures for the buffer cache
+ * filesystem journaling support.
+ */
+
+#ifndef _LINUX_JBD_H
+#define _LINUX_JBD_H
+
+#if defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE) || !defined(__KERNEL__)
+
+/* Allow this file to be included directly into e2fsprogs */
+#ifndef __KERNEL__
+#include "jfs_compat.h"
+#define JFS_DEBUG
+#define jfs_debug jbd_debug
+#else
+
+#include <linux/buffer_head.h>
+#include <linux/journal-head.h>
+#include <linux/stddef.h>
+#include <asm/semaphore.h>
+#endif
+
+#define journal_oom_retry 1
+
+/*
+ * Define JBD_PARANIOD_IOFAIL to cause a kernel BUG() if ext3 finds
+ * certain classes of error which can occur due to failed IOs.  Under
+ * normal use we want ext3 to continue after such errors, because
+ * hardware _can_ fail, but for debugging purposes when running tests on
+ * known-good hardware we may want to trap these errors.
+ */
+#undef JBD_PARANOID_IOFAIL
+
+/*
+ * The default maximum commit age, in seconds.
+ */
+#define JBD_DEFAULT_MAX_COMMIT_AGE 5
+
+#ifdef CONFIG_JBD_DEBUG
+/*
+ * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal
+ * consistency checks.  By default we don't do this unless
+ * CONFIG_JBD_DEBUG is on.
+ */
+#define JBD_EXPENSIVE_CHECKING
+extern int journal_enable_debug;
+
+#define jbd_debug(n, f, a...)                                           \
+        do {                                                            \
+                if ((n) <= journal_enable_debug) {                      \
+                        printk (KERN_DEBUG "(%s, %d): %s: ",            \
+                                __FILE__, __LINE__, __FUNCTION__);      \
+                        printk (f, ## a);                               \
+                }                                                       \
+        } while (0)
+#else
+#define jbd_debug(f, a...)      /**/
+#endif
+
+extern void * __jbd_kmalloc (const char *where, size_t size, int flags, int retry);
+#define jbd_kmalloc(size, flags) \
+        __jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
+#define jbd_rep_kmalloc(size, flags) \
+        __jbd_kmalloc(__FUNCTION__, (size), (flags), 1)
+
+#define JFS_MIN_JOURNAL_BLOCKS 1024
+
+#ifdef __KERNEL__
+
+/**
+ * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
+ *
+ * All filesystem modifications made by the process go
+ * through this handle.  Recursive operations (such as quota operations)
+ * are gathered into a single update.
+ *
+ * The buffer credits field is used to account for journaled buffers
+ * being modified by the running process.  To ensure that there is
+ * enough log space for all outstanding operations, we need to limit the
+ * number of outstanding buffers possible at any time.  When the
+ * operation completes, any buffer credits not used are credited back to
+ * the transaction, so that at all times we know how many buffers the
+ * outstanding updates on a transaction might possibly touch. 
+ * 
+ * This is an opaque datatype.
+ **/
+typedef struct handle_s         handle_t;       /* Atomic operation type */
+
+
+/**
+ * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
+ *
+ * journal_t is linked to from the fs superblock structure.
+ * 
+ * We use the journal_t to keep track of all outstanding transaction
+ * activity on the filesystem, and to manage the state of the log
+ * writing process.
+ *
+ * This is an opaque datatype.
+ **/
+typedef struct journal_s        journal_t;      /* Journal control structure */
+#endif
+
+/*
+ * Internal structures used by the logging mechanism:
+ */
+
+#define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
+
+/*
+ * On-disk structures
+ */
+
+/* 
+ * Descriptor block types:
+ */
+
+#define JFS_DESCRIPTOR_BLOCK    1
+#define JFS_COMMIT_BLOCK        2
+#define JFS_SUPERBLOCK_V1       3
+#define JFS_SUPERBLOCK_V2       4
+#define JFS_REVOKE_BLOCK        5
+
+/*
+ * Standard header for all descriptor blocks:
+ */
+typedef struct journal_header_s
+{
+        __be32          h_magic;
+        __be32          h_blocktype;
+        __be32          h_sequence;
+} journal_header_t;
+
+
+/* 
+ * The block tag: used to describe a single buffer in the journal 
+ */
+typedef struct journal_block_tag_s
+{
+        __be32          t_blocknr;      /* The on-disk block number */
+        __be32          t_flags;        /* See below */
+} journal_block_tag_t;
+
+/* 
+ * The revoke descriptor: used on disk to describe a series of blocks to
+ * be revoked from the log 
+ */
+typedef struct journal_revoke_header_s
+{
+        journal_header_t r_header;
+        __be32           r_count;       /* Count of bytes used in the block */
+} journal_revoke_header_t;
+
+
+/* Definitions for the journal tag flags word: */
+#define JFS_FLAG_ESCAPE         1       /* on-disk block is escaped */
+#define JFS_FLAG_SAME_UUID      2       /* block has same uuid as previous */
+#define JFS_FLAG_DELETED        4       /* block deleted by this transaction */
+#define JFS_FLAG_LAST_TAG       8       /* last tag in this descriptor block */
+
+
+/*
+ * The journal superblock.  All fields are in big-endian byte order.
+ */
+typedef struct journal_superblock_s
+{
+/* 0x0000 */
+        journal_header_t s_header;
+
+/* 0x000C */
+        /* Static information describing the journal */
+        __be32  s_blocksize;            /* journal device blocksize */
+        __be32  s_maxlen;               /* total blocks in journal file */
+        __be32  s_first;                /* first block of log information */
+
+/* 0x0018 */
+        /* Dynamic information describing the current state of the log */
+        __be32  s_sequence;             /* first commit ID expected in log */
+        __be32  s_start;                /* blocknr of start of log */
+
+/* 0x0020 */
+        /* Error value, as set by journal_abort(). */
+        __be32  s_errno;
+
+/* 0x0024 */
+        /* Remaining fields are only valid in a version-2 superblock */
+        __be32  s_feature_compat;       /* compatible feature set */
+        __be32  s_feature_incompat;     /* incompatible feature set */
+        __be32  s_feature_ro_compat;    /* readonly-compatible feature set */
+/* 0x0030 */
+        __u8    s_uuid[16];             /* 128-bit uuid for journal */
+
+/* 0x0040 */
+        __be32  s_nr_users;             /* Nr of filesystems sharing log */
+
+        __be32  s_dynsuper;             /* Blocknr of dynamic superblock copy*/
+
+/* 0x0048 */
+        __be32  s_max_transaction;      /* Limit of journal blocks per trans.*/
+        __be32  s_max_trans_data;       /* Limit of data blocks per trans. */
+
+/* 0x0050 */
+        __u32   s_padding[44];
+
+/* 0x0100 */
+        __u8    s_users[16*48];         /* ids of all fs'es sharing the log */
+/* 0x0400 */
+} journal_superblock_t;
+
+#define JFS_HAS_COMPAT_FEATURE(j,mask)                                  \
+        ((j)->j_format_version >= 2 &&                                  \
+         ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
+#define JFS_HAS_RO_COMPAT_FEATURE(j,mask)                               \
+        ((j)->j_format_version >= 2 &&                                  \
+         ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
+#define JFS_HAS_INCOMPAT_FEATURE(j,mask)                                \
+        ((j)->j_format_version >= 2 &&                                  \
+         ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
+
+#define JFS_FEATURE_INCOMPAT_REVOKE     0x00000001
+
+/* Features known to this kernel version: */
+#define JFS_KNOWN_COMPAT_FEATURES       0
+#define JFS_KNOWN_ROCOMPAT_FEATURES     0
+#define JFS_KNOWN_INCOMPAT_FEATURES     JFS_FEATURE_INCOMPAT_REVOKE
+
+#ifdef __KERNEL__
+
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <asm/bug.h>
+
+#define JBD_ASSERTIONS
+#ifdef JBD_ASSERTIONS
+#define J_ASSERT(assert)                                                \
+do {                                                                    \
+        if (!(assert)) {                                                \
+                printk (KERN_EMERG                                      \
+                        "Assertion failure in %s() at %s:%d: \"%s\"\n", \
+                        __FUNCTION__, __FILE__, __LINE__, # assert);    \
+                BUG();                                                  \
+        }                                                               \
+} while (0)
+
+#if defined(CONFIG_BUFFER_DEBUG)
+void buffer_assertion_failure(struct buffer_head *bh);
+#define J_ASSERT_BH(bh, expr)                                           \
+        do {                                                            \
+                if (!(expr))                                            \
+                        buffer_assertion_failure(bh);                   \
+                J_ASSERT(expr);                                         \
+        } while (0)
+#define J_ASSERT_JH(jh, expr)   J_ASSERT_BH(jh2bh(jh), expr)
+#else
+#define J_ASSERT_BH(bh, expr)   J_ASSERT(expr)
+#define J_ASSERT_JH(jh, expr)   J_ASSERT(expr)
+#endif
+
+#else
+#define J_ASSERT(assert)        do { } while (0)
+#endif          /* JBD_ASSERTIONS */
+
+#if defined(JBD_PARANOID_IOFAIL)
+#define J_EXPECT(expr, why...)          J_ASSERT(expr)
+#define J_EXPECT_BH(bh, expr, why...)   J_ASSERT_BH(bh, expr)
+#define J_EXPECT_JH(jh, expr, why...)   J_ASSERT_JH(jh, expr)
+#else
+#define __journal_expect(expr, why...)                                       \
+        ({                                                                   \
+                int val = (expr);                                            \
+                if (!val) {                                                  \
+                        printk(KERN_ERR                                      \
+                                "EXT3-fs unexpected failure: %s;\n",# expr); \
+                        printk(KERN_ERR why "\n");                           \
+                }                                                            \
+                val;                                                         \
+        })
+#define J_EXPECT(expr, why...)          __journal_expect(expr, ## why)
+#define J_EXPECT_BH(bh, expr, why...)   __journal_expect(expr, ## why)
+#define J_EXPECT_JH(jh, expr, why...)   __journal_expect(expr, ## why)
+#endif
+
+enum jbd_state_bits {
+        BH_JBD                  /* Has an attached ext3 journal_head */
+          = BH_PrivateStart,
+        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
+        BH_Freed,               /* Has been freed (truncated) */
+        BH_Revoked,             /* Has been revoked from the log */
+        BH_RevokeValid,         /* Revoked flag is valid */
+        BH_JBDDirty,            /* Is dirty but journaled */
+        BH_State,               /* Pins most journal_head state */
+        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
+        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
+};
+
+BUFFER_FNS(JBD, jbd)
+BUFFER_FNS(JWrite, jwrite)
+BUFFER_FNS(JBDDirty, jbddirty)
+TAS_BUFFER_FNS(JBDDirty, jbddirty)
+BUFFER_FNS(Revoked, revoked)
+TAS_BUFFER_FNS(Revoked, revoked)
+BUFFER_FNS(RevokeValid, revokevalid)
+TAS_BUFFER_FNS(RevokeValid, revokevalid)
+BUFFER_FNS(Freed, freed)
+
+static inline struct buffer_head *jh2bh(struct journal_head *jh)
+{
+        return jh->b_bh;
+}
+
+static inline struct journal_head *bh2jh(struct buffer_head *bh)
+{
+        return bh->b_private;
+}
+
+static inline void jbd_lock_bh_state(struct buffer_head *bh)
+{
+        bit_spin_lock(BH_State, &bh->b_state);
+}
+
+static inline int jbd_trylock_bh_state(struct buffer_head *bh)
+{
+        return bit_spin_trylock(BH_State, &bh->b_state);
+}
+
+static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
+{
+        return bit_spin_is_locked(BH_State, &bh->b_state);
+}
+
+static inline void jbd_unlock_bh_state(struct buffer_head *bh)
+{
+        bit_spin_unlock(BH_State, &bh->b_state);
+}
+
+static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
+{
+        bit_spin_lock(BH_JournalHead, &bh->b_state);
+}
+
+static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
+{
+        bit_spin_unlock(BH_JournalHead, &bh->b_state);
+}
+
+struct jbd_revoke_table_s;
+
+/**
+ * struct handle_s - The handle_s type is the concrete type associated with
+ *     handle_t.
+ * @h_transaction: Which compound transaction is this update a part of?
+ * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
+ * @h_ref: Reference count on this handle
+ * @h_err: Field for caller's use to track errors through large fs operations
+ * @h_sync: flag for sync-on-close
+ * @h_jdata: flag to force data journaling
+ * @h_aborted: flag indicating fatal error on handle
+ **/
+
+/* Docbook can't yet cope with the bit fields, but will leave the documentation
+ * in so it can be fixed later. 
+ */
+
+struct handle_s 
+{
+        /* Which compound transaction is this update a part of? */
+        transaction_t           *h_transaction;
+
+        /* Number of remaining buffers we are allowed to dirty: */
+        int                     h_buffer_credits;
+
+        /* Reference count on this handle */
+        int                     h_ref;
+
+        /* Field for caller's use to track errors through large fs */
+        /* operations */
+        int                     h_err;
+
+        /* Flags [no locking] */
+        unsigned int    h_sync:         1;      /* sync-on-close */
+        unsigned int    h_jdata:        1;      /* force data journaling */
+        unsigned int    h_aborted:      1;      /* fatal error on handle */
+};
+
+
+/* The transaction_t type is the guts of the journaling mechanism.  It
+ * tracks a compound transaction through its various states:
+ *
+ * RUNNING:     accepting new updates
+ * LOCKED:      Updates still running but we don't accept new ones
+ * RUNDOWN:     Updates are tidying up but have finished requesting
+ *              new buffers to modify (state not used for now)
+ * FLUSH:       All updates complete, but we are still writing to disk
+ * COMMIT:      All data on disk, writing commit record
+ * FINISHED:    We still have to keep the transaction for checkpointing.
+ *
+ * The transaction keeps track of all of the buffers modified by a
+ * running transaction, and all of the buffers committed but not yet
+ * flushed to home for finished transactions.
+ */
+
+/*
+ * Lock ranking:
+ *
+ *    j_list_lock
+ *      ->jbd_lock_bh_journal_head()    (This is "innermost")
+ *
+ *    j_state_lock
+ *    ->jbd_lock_bh_state()
+ *
+ *    jbd_lock_bh_state()
+ *    ->j_list_lock
+ *
+ *    j_state_lock
+ *    ->t_handle_lock
+ *
+ *    j_state_lock
+ *    ->j_list_lock                     (journal_unmap_buffer)
+ *
+ */
+
+struct transaction_s 
+{
+        /* Pointer to the journal for this transaction. [no locking] */
+        journal_t               *t_journal;
+
+        /* Sequence number for this transaction [no locking] */
+        tid_t                   t_tid;
+
+        /*
+         * Transaction's current state
+         * [no locking - only kjournald alters this]
+         * FIXME: needs barriers
+         * KLUDGE: [use j_state_lock]
+         */
+        enum {
+                T_RUNNING,
+                T_LOCKED,
+                T_RUNDOWN,
+                T_FLUSH,
+                T_COMMIT,
+                T_FINISHED 
+        }                       t_state;
+
+        /*
+         * Where in the log does this transaction's commit start? [no locking]
+         */
+        unsigned long           t_log_start;
+
+        /* Number of buffers on the t_buffers list [j_list_lock] */
+        int                     t_nr_buffers;
+
+        /*
+         * Doubly-linked circular list of all buffers reserved but not yet
+         * modified by this transaction [j_list_lock]
+         */
+        struct journal_head     *t_reserved_list;
+
+        /*
+         * Doubly-linked circular list of all buffers under writeout during
+         * commit [j_list_lock]
+         */
+        struct journal_head     *t_locked_list;
+
+        /*
+         * Doubly-linked circular list of all metadata buffers owned by this
+         * transaction [j_list_lock]
+         */
+        struct journal_head     *t_buffers;
+
+        /*
+         * Doubly-linked circular list of all data buffers still to be
+         * flushed before this transaction can be committed [j_list_lock]
+         */
+        struct journal_head     *t_sync_datalist;
+
+        /*
+         * Doubly-linked circular list of all forget buffers (superseded
+         * buffers which we can un-checkpoint once this transaction commits)
+         * [j_list_lock]
+         */
+        struct journal_head     *t_forget;
+
+        /*
+         * Doubly-linked circular list of all buffers still to be flushed before
+         * this transaction can be checkpointed. [j_list_lock]
+         */
+        struct journal_head     *t_checkpoint_list;
+
+        /*
+         * Doubly-linked circular list of temporary buffers currently undergoing
+         * IO in the log [j_list_lock]
+         */
+        struct journal_head     *t_iobuf_list;
+
+        /*
+         * Doubly-linked circular list of metadata buffers being shadowed by log
+         * IO.  The IO buffers on the iobuf list and the shadow buffers on this
+         * list match each other one for one at all times. [j_list_lock]
+         */
+        struct journal_head     *t_shadow_list;
+
+        /*
+         * Doubly-linked circular list of control buffers being written to the
+         * log. [j_list_lock]
+         */
+        struct journal_head     *t_log_list;
+
+        /*
+         * Protects info related to handles
+         */
+        spinlock_t              t_handle_lock;
+
+        /*
+         * Number of outstanding updates running on this transaction
+         * [t_handle_lock]
+         */
+        int                     t_updates;
+
+        /*
+         * Number of buffers reserved for use by all handles in this transaction
+         * handle but not yet modified. [t_handle_lock]
+         */
+        int                     t_outstanding_credits;
+
+        /*
+         * Forward and backward links for the circular list of all transactions
+         * awaiting checkpoint. [j_list_lock]
+         */
+        transaction_t           *t_cpnext, *t_cpprev;
+
+        /*
+         * When will the transaction expire (become due for commit), in jiffies?
+         * [no locking]
+         */
+        unsigned long           t_expires;
+
+        /*
+         * How many handles used this transaction? [t_handle_lock]
+         */
+        int t_handle_count;
+
+};
+
+/**
+ * struct journal_s - The journal_s type is the concrete type associated with
+ *     journal_t.
+ * @j_flags:  General journaling state flags
+ * @j_errno:  Is there an outstanding uncleared error on the journal (from a
+ *     prior abort)? 
+ * @j_sb_buffer: First part of superblock buffer
+ * @j_superblock: Second part of superblock buffer
+ * @j_format_version: Version of the superblock format
+ * @j_state_lock: Protect the various scalars in the journal
+ * @j_barrier_count:  Number of processes waiting to create a barrier lock
+ * @j_barrier: The barrier lock itself
+ * @j_running_transaction: The current running transaction..
+ * @j_committing_transaction: the transaction we are pushing to disk
+ * @j_checkpoint_transactions: a linked circular list of all transactions
+ *  waiting for checkpointing
+ * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
+ *  to start committing, or for a barrier lock to be released
+ * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
+ * @j_wait_done_commit: Wait queue for waiting for commit to complete 
+ * @j_wait_checkpoint:  Wait queue to trigger checkpointing
+ * @j_wait_commit: Wait queue to trigger commit
+ * @j_wait_updates: Wait queue to wait for updates to complete
+ * @j_checkpoint_sem: Semaphore for locking against concurrent checkpoints
+ * @j_head: Journal head - identifies the first unused block in the journal
+ * @j_tail: Journal tail - identifies the oldest still-used block in the
+ *  journal.
+ * @j_free: Journal free - how many free blocks are there in the journal?
+ * @j_first: The block number of the first usable block 
+ * @j_last: The block number one beyond the last usable block
+ * @j_dev: Device where we store the journal
+ * @j_blocksize: blocksize for the location where we store the journal.
+ * @j_blk_offset: starting block offset for into the device where we store the
+ *     journal
+ * @j_fs_dev: Device which holds the client fs.  For internal journal this will
+ *     be equal to j_dev
+ * @j_maxlen: Total maximum capacity of the journal region on disk.
+ * @j_list_lock: Protects the buffer lists and internal buffer state.
+ * @j_inode: Optional inode where we store the journal.  If present, all journal
+ *     block numbers are mapped into this inode via bmap().
+ * @j_tail_sequence:  Sequence number of the oldest transaction in the log 
+ * @j_transaction_sequence: Sequence number of the next transaction to grant
+ * @j_commit_sequence: Sequence number of the most recently committed
+ *  transaction
+ * @j_commit_request: Sequence number of the most recent transaction wanting
+ *     commit 
+ * @j_uuid: Uuid of client object.
+ * @j_task: Pointer to the current commit thread for this journal
+ * @j_max_transaction_buffers:  Maximum number of metadata buffers to allow in a
+ *     single compound commit transaction
+ * @j_commit_interval: What is the maximum transaction lifetime before we begin
+ *  a commit?
+ * @j_commit_timer:  The timer used to wakeup the commit thread
+ * @j_revoke_lock: Protect the revoke table
+ * @j_revoke: The revoke table - maintains the list of revoked blocks in the
+ *     current transaction.
+ * @j_revoke_table: alternate revoke tables for j_revoke
+ * @j_private: An opaque pointer to fs-private information.
+ */
+
+struct journal_s
+{
+        /* General journaling state flags [j_state_lock] */
+        unsigned long           j_flags;
+
+        /*
+         * Is there an outstanding uncleared error on the journal (from a prior
+         * abort)? [j_state_lock]
+         */
+        int                     j_errno;
+
+        /* The superblock buffer */
+        struct buffer_head      *j_sb_buffer;
+        journal_superblock_t    *j_superblock;
+
+        /* Version of the superblock format */
+        int                     j_format_version;
+
+        /*
+         * Protect the various scalars in the journal
+         */
+        spinlock_t              j_state_lock;
+
+        /*
+         * Number of processes waiting to create a barrier lock [j_state_lock]
+         */
+        int                     j_barrier_count;
+
+        /* The barrier lock itself */
+        struct semaphore        j_barrier;
+
+        /*
+         * Transactions: The current running transaction...
+         * [j_state_lock] [caller holding open handle]
+         */
+        transaction_t           *j_running_transaction;
+
+        /*
+         * the transaction we are pushing to disk
+         * [j_state_lock] [caller holding open handle]
+         */
+        transaction_t           *j_committing_transaction;
+
+        /*
+         * ... and a linked circular list of all transactions waiting for
+         * checkpointing. [j_list_lock]
+         */
+        transaction_t           *j_checkpoint_transactions;
+
+        /*
+         * Wait queue for waiting for a locked transaction to start committing,
+         * or for a barrier lock to be released
+         */
+        wait_queue_head_t       j_wait_transaction_locked;
+
+        /* Wait queue for waiting for checkpointing to complete */
+        wait_queue_head_t       j_wait_logspace;
+
+        /* Wait queue for waiting for commit to complete */
+        wait_queue_head_t       j_wait_done_commit;
+
+        /* Wait queue to trigger checkpointing */
+        wait_queue_head_t       j_wait_checkpoint;
+
+        /* Wait queue to trigger commit */
+        wait_queue_head_t       j_wait_commit;
+
+        /* Wait queue to wait for updates to complete */
+        wait_queue_head_t       j_wait_updates;
+
+        /* Semaphore for locking against concurrent checkpoints */
+        struct semaphore        j_checkpoint_sem;
+
+        /*
+         * Journal head: identifies the first unused block in the journal.
+         * [j_state_lock]
+         */
+        unsigned long           j_head;
+
+        /*
+         * Journal tail: identifies the oldest still-used block in the journal.
+         * [j_state_lock]
+         */
+        unsigned long           j_tail;
+
+        /*
+         * Journal free: how many free blocks are there in the journal?
+         * [j_state_lock]
+         */
+        unsigned long           j_free;
+
+        /*
+         * Journal start and end: the block numbers of the first usable block
+         * and one beyond the last usable block in the journal. [j_state_lock]
+         */
+        unsigned long           j_first;
+        unsigned long           j_last;
+
+        /*
+         * Device, blocksize and starting block offset for the location where we
+         * store the journal.
+         */
+        struct block_device     *j_dev;
+        int                     j_blocksize;
+        unsigned int            j_blk_offset;
+
+        /*
+         * Device which holds the client fs.  For internal journal this will be
+         * equal to j_dev.
+         */
+        struct block_device     *j_fs_dev;
+
+        /* Total maximum capacity of the journal region on disk. */
+        unsigned int            j_maxlen;
+
+        /*
+         * Protects the buffer lists and internal buffer state.
+         */
+        spinlock_t              j_list_lock;
+
+        /* Optional inode where we store the journal.  If present, all */
+        /* journal block numbers are mapped into this inode via */
+        /* bmap(). */
+        struct inode            *j_inode;
+
+        /*
+         * Sequence number of the oldest transaction in the log [j_state_lock]
+         */
+        tid_t                   j_tail_sequence;
+
+        /*
+         * Sequence number of the next transaction to grant [j_state_lock]
+         */
+        tid_t                   j_transaction_sequence;
+
+        /*
+         * Sequence number of the most recently committed transaction
+         * [j_state_lock].
+         */
+        tid_t                   j_commit_sequence;
+
+        /*
+         * Sequence number of the most recent transaction wanting commit
+         * [j_state_lock]
+         */
+        tid_t                   j_commit_request;
+
+        /*
+         * Journal uuid: identifies the object (filesystem, LVM volume etc)
+         * backed by this journal.  This will eventually be replaced by an array
+         * of uuids, allowing us to index multiple devices within a single
+         * journal and to perform atomic updates across them.
+         */
+        __u8                    j_uuid[16];
+
+        /* Pointer to the current commit thread for this journal */
+        struct task_struct      *j_task;
+
+        /*
+         * Maximum number of metadata buffers to allow in a single compound
+         * commit transaction
+         */
+        int                     j_max_transaction_buffers;
+
+        /*
+         * What is the maximum transaction lifetime before we begin a commit?
+         */
+        unsigned long           j_commit_interval;
+
+        /* The timer used to wakeup the commit thread: */
+        struct timer_list       *j_commit_timer;
+
+        /*
+         * The revoke table: maintains the list of revoked blocks in the
+         * current transaction.  [j_revoke_lock]
+         */
+        spinlock_t              j_revoke_lock;
+        struct jbd_revoke_table_s *j_revoke;
+        struct jbd_revoke_table_s *j_revoke_table[2];
+
+        /*
+         * array of bhs for journal_commit_transaction
+         */
+        struct buffer_head      **j_wbuf;
+        int                     j_wbufsize;
+
+        /*
+         * An opaque pointer to fs-private information.  ext3 puts its
+         * superblock pointer here
+         */
+        void *j_private;
+};
+
+/* 
+ * Journal flag definitions 
+ */
+#define JFS_UNMOUNT     0x001   /* Journal thread is being destroyed */
+#define JFS_ABORT       0x002   /* Journaling has been aborted for errors. */
+#define JFS_ACK_ERR     0x004   /* The errno in the sb has been acked */
+#define JFS_FLUSHED     0x008   /* The journal superblock has been flushed */
+#define JFS_LOADED      0x010   /* The journal superblock has been loaded */
+#define JFS_BARRIER     0x020   /* Use IDE barriers */
+
+/* 
+ * Function declarations for the journaling transaction and buffer
+ * management
+ */
+
+/* Filing buffers */
+extern void __journal_temp_unlink_buffer(struct journal_head *jh);
+extern void journal_unfile_buffer(journal_t *, struct journal_head *);
+extern void __journal_unfile_buffer(struct journal_head *);
+extern void __journal_refile_buffer(struct journal_head *);
+extern void journal_refile_buffer(journal_t *, struct journal_head *);
+extern void __journal_file_buffer(struct journal_head *, transaction_t *, int);
+extern void __journal_free_buffer(struct journal_head *bh);
+extern void journal_file_buffer(struct journal_head *, transaction_t *, int);
+extern void __journal_clean_data_list(transaction_t *transaction);
+
+/* Log buffer allocation */
+extern struct journal_head * journal_get_descriptor_buffer(journal_t *);
+int journal_next_log_block(journal_t *, unsigned long *);
+
+/* Commit management */
+extern void journal_commit_transaction(journal_t *);
+
+/* Checkpoint list management */
+int __journal_clean_checkpoint_list(journal_t *journal);
+void __journal_remove_checkpoint(struct journal_head *);
+void __journal_insert_checkpoint(struct journal_head *, transaction_t *);
+
+/* Buffer IO */
+extern int 
+journal_write_metadata_buffer(transaction_t       *transaction,
+                              struct journal_head  *jh_in,
+                              struct journal_head **jh_out,
+                              int                  blocknr);
+
+/* Transaction locking */
+extern void             __wait_on_journal (journal_t *);
+
+/*
+ * Journal locking.
+ *
+ * We need to lock the journal during transaction state changes so that nobody
+ * ever tries to take a handle on the running transaction while we are in the
+ * middle of moving it to the commit phase.  j_state_lock does this.
+ *
+ * Note that the locking is completely interrupt unsafe.  We never touch
+ * journal structures from interrupts.
+ */
+
+static inline handle_t *journal_current_handle(void)
+{
+        return current->journal_info;
+}
+
+/* The journaling code user interface:
+ *
+ * Create and destroy handles
+ * Register buffer modifications against the current transaction. 
+ */
+
+extern handle_t *journal_start(journal_t *, int nblocks);
+extern int       journal_restart (handle_t *, int nblocks);
+extern int       journal_extend (handle_t *, int nblocks);
+extern int       journal_get_write_access(handle_t *, struct buffer_head *);
+extern int       journal_get_create_access (handle_t *, struct buffer_head *);
+extern int       journal_get_undo_access(handle_t *, struct buffer_head *);
+extern int       journal_dirty_data (handle_t *, struct buffer_head *);
+extern int       journal_dirty_metadata (handle_t *, struct buffer_head *);
+extern void      journal_release_buffer (handle_t *, struct buffer_head *);
+extern int       journal_forget (handle_t *, struct buffer_head *);
+extern void      journal_sync_buffer (struct buffer_head *);
+extern int       journal_invalidatepage(journal_t *,
+                                struct page *, unsigned long);
+extern int       journal_try_to_free_buffers(journal_t *, struct page *, int);
+extern int       journal_stop(handle_t *);
+extern int       journal_flush (journal_t *);
+extern void      journal_lock_updates (journal_t *);
+extern void      journal_unlock_updates (journal_t *);
+
+extern journal_t * journal_init_dev(struct block_device *bdev,
+                                struct block_device *fs_dev,
+                                int start, int len, int bsize);
+extern journal_t * journal_init_inode (struct inode *);
+extern int         journal_update_format (journal_t *);
+extern int         journal_check_used_features 
+                   (journal_t *, unsigned long, unsigned long, unsigned long);
+extern int         journal_check_available_features 
+                   (journal_t *, unsigned long, unsigned long, unsigned long);
+extern int         journal_set_features 
+                   (journal_t *, unsigned long, unsigned long, unsigned long);
+extern int         journal_create     (journal_t *);
+extern int         journal_load       (journal_t *journal);
+extern void        journal_destroy    (journal_t *);
+extern int         journal_recover    (journal_t *journal);
+extern int         journal_wipe       (journal_t *, int);
+extern int         journal_skip_recovery        (journal_t *);
+extern void        journal_update_superblock    (journal_t *, int);
+extern void        __journal_abort_hard (journal_t *);
+extern void        __journal_abort_soft (journal_t *, int);
+extern void        journal_abort      (journal_t *, int);
+extern int         journal_errno      (journal_t *);
+extern void        journal_ack_err    (journal_t *);
+extern int         journal_clear_err  (journal_t *);
+extern int         journal_bmap(journal_t *, unsigned long, unsigned long *);
+extern int         journal_force_commit(journal_t *);
+
+/*
+ * journal_head management
+ */
+struct journal_head *journal_add_journal_head(struct buffer_head *bh);
+struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
+void journal_remove_journal_head(struct buffer_head *bh);
+void journal_put_journal_head(struct journal_head *jh);
+
+/*
+ * handle management
+ */
+extern kmem_cache_t *jbd_handle_cache;
+
+static inline handle_t *jbd_alloc_handle(unsigned int __nocast gfp_flags)
+{
+        return kmem_cache_alloc(jbd_handle_cache, gfp_flags);
+}
+
+static inline void jbd_free_handle(handle_t *handle)
+{
+        kmem_cache_free(jbd_handle_cache, handle);
+}
+
+/* Primary revoke support */
+#define JOURNAL_REVOKE_DEFAULT_HASH 256
+extern int         journal_init_revoke(journal_t *, int);
+extern void        journal_destroy_revoke_caches(void);
+extern int         journal_init_revoke_caches(void);
+
+extern void        journal_destroy_revoke(journal_t *);
+extern int         journal_revoke (handle_t *,
+                                unsigned long, struct buffer_head *);
+extern int         journal_cancel_revoke(handle_t *, struct journal_head *);
+extern void        journal_write_revoke_records(journal_t *, transaction_t *);
+
+/* Recovery revoke support */
+extern int      journal_set_revoke(journal_t *, unsigned long, tid_t);
+extern int      journal_test_revoke(journal_t *, unsigned long, tid_t);
+extern void     journal_clear_revoke(journal_t *);
+extern void     journal_brelse_array(struct buffer_head *b[], int n);
+extern void     journal_switch_revoke_table(journal_t *journal);
+
+/*
+ * The log thread user interface:
+ *
+ * Request space in the current transaction, and force transaction commit
+ * transitions on demand.
+ */
+
+int __log_space_left(journal_t *); /* Called with journal locked */
+int log_start_commit(journal_t *journal, tid_t tid);
+int __log_start_commit(journal_t *journal, tid_t tid);
+int journal_start_commit(journal_t *journal, tid_t *tid);
+int journal_force_commit_nested(journal_t *journal);
+int log_wait_commit(journal_t *journal, tid_t tid);
+int log_do_checkpoint(journal_t *journal);
+
+void __log_wait_for_space(journal_t *journal);
+extern void     __journal_drop_transaction(journal_t *, transaction_t *);
+extern int      cleanup_journal_tail(journal_t *);
+
+/* Debugging code only: */
+
+#define jbd_ENOSYS() \
+do {                                                                       \
+        printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \
+        current->state = TASK_UNINTERRUPTIBLE;                             \
+        schedule();                                                        \
+} while (1)
+
+/*
+ * is_journal_abort
+ *
+ * Simple test wrapper function to test the JFS_ABORT state flag.  This
+ * bit, when set, indicates that we have had a fatal error somewhere,
+ * either inside the journaling layer or indicated to us by the client
+ * (eg. ext3), and that we and should not commit any further
+ * transactions.  
+ */
+
+static inline int is_journal_aborted(journal_t *journal)
+{
+        return journal->j_flags & JFS_ABORT;
+}
+
+static inline int is_handle_aborted(handle_t *handle)
+{
+        if (handle->h_aborted)
+                return 1;
+        return is_journal_aborted(handle->h_transaction->t_journal);
+}
+
+static inline void journal_abort_handle(handle_t *handle)
+{
+        handle->h_aborted = 1;
+}
+
+#endif /* __KERNEL__   */
+
+/* Comparison functions for transaction IDs: perform comparisons using
+ * modulo arithmetic so that they work over sequence number wraps. */
+
+static inline int tid_gt(tid_t x, tid_t y)
+{
+        int difference = (x - y);
+        return (difference > 0);
+}
+
+static inline int tid_geq(tid_t x, tid_t y)
+{
+        int difference = (x - y);
+        return (difference >= 0);
+}
+
+extern int journal_blocks_per_page(struct inode *inode);
+
+/*
+ * Return the minimum number of blocks which must be free in the journal
+ * before a new transaction may be started.  Must be called under j_state_lock.
+ */
+static inline int jbd_space_needed(journal_t *journal)
+{
+        int nblocks = journal->j_max_transaction_buffers;
+        if (journal->j_committing_transaction)
+                nblocks += journal->j_committing_transaction->
+                                        t_outstanding_credits;
+        return nblocks;
+}
+
+/*
+ * Definitions which augment the buffer_head layer
+ */
+
+/* journaling buffer types */
+#define BJ_None         0       /* Not journaled */
+#define BJ_SyncData     1       /* Normal data: flush before commit */
+#define BJ_Metadata     2       /* Normal journaled metadata */
+#define BJ_Forget       3       /* Buffer superseded by this transaction */
+#define BJ_IO           4       /* Buffer is for temporary IO use */
+#define BJ_Shadow       5       /* Buffer contents being shadowed to the log */
+#define BJ_LogCtl       6       /* Buffer contains log descriptors */
+#define BJ_Reserved     7       /* Buffer is reserved for access by journal */
+#define BJ_Locked       8       /* Locked for I/O during commit */
+#define BJ_Types        9
+ 
+extern int jbd_blocks_per_page(struct inode *inode);
+
+#ifdef __KERNEL__
+
+#define buffer_trace_init(bh)   do {} while (0)
+#define print_buffer_fields(bh) do {} while (0)
+#define print_buffer_trace(bh)  do {} while (0)
+#define BUFFER_TRACE(bh, info)  do {} while (0)
+#define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
+#define JBUFFER_TRACE(jh, info) do {} while (0)
+
+#endif  /* __KERNEL__ */
+
+#endif  /* CONFIG_JBD || CONFIG_JBD_MODULE || !__KERNEL__ */
+
+/*
+ * Compatibility no-ops which allow the kernel to compile without CONFIG_JBD
+ * go here.
+ */
+
+#if defined(__KERNEL__) && !(defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE))
+
+#define J_ASSERT(expr)                  do {} while (0)
+#define J_ASSERT_BH(bh, expr)           do {} while (0)
+#define buffer_jbd(bh)                  0
+#define journal_buffer_journal_lru(bh)  0
+
+#endif  /* defined(__KERNEL__) && !defined(CONFIG_JBD) */
+#endif  /* _LINUX_JBD_H */
diff --git a/include/linux/jffs.h b/include/linux/jffs.h
new file mode 100644
index 000000000000..92213215277f
--- /dev/null
+++ b/include/linux/jffs.h
@@ -0,0 +1,224 @@
+/*
+ * JFFS -- Journalling Flash File System, Linux implementation.
+ *
+ * Copyright (C) 1999, 2000  Axis Communications AB.
+ *
+ * Created by Finn Hakansson <finn@axis.com>.
+ *
+ * This 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * $Id: jffs.h,v 1.20 2001/09/18 21:33:37 dwmw2 Exp $
+ *
+ * Ported to Linux 2.3.x and MTD:
+ * Copyright (C) 2000  Alexander Larsson (alex@cendio.se), Cendio Systems AB
+ *
+ */
+
+#ifndef __LINUX_JFFS_H__
+#define __LINUX_JFFS_H__
+
+#include <linux/types.h>
+#include <linux/completion.h>
+
+#define JFFS_VERSION_STRING "1.0"
+
+/* This is a magic number that is used as an identification number for
+   this file system.  It is written to the super_block structure.  */
+#define JFFS_MAGIC_SB_BITMASK 0x07c0  /* 1984 */
+
+/* This is a magic number that every on-flash raw inode begins with.  */
+#define JFFS_MAGIC_BITMASK 0x34383931 /* "1984" */
+
+/* These two bitmasks are the valid ones for the flash memories we have
+   for the moment.  */
+#define JFFS_EMPTY_BITMASK 0xffffffff
+#define JFFS_DIRTY_BITMASK 0x00000000
+
+/* This is the inode number of the root node.  */
+#define JFFS_MIN_INO 1
+
+/* How many slots in the file hash table should we have?  */
+#define JFFS_HASH_SIZE 40
+
+/* Don't use more than 254 bytes as the maximum allowed length of a file's
+   name due to errors that could occur during the scanning of the flash
+   memory. In fact, a name length of 255 or 0xff, could be the result of
+   an uncompleted write.  For instance, if a raw inode is written to the
+   flash memory and there is a power lossage just before the length of
+   the name is written, the length 255 would be interpreted as an illegal
+   value.  */
+#define JFFS_MAX_NAME_LEN 254
+
+/* Commands for ioctl().  */
+#define JFFS_IOCTL_MAGIC 't'
+#define JFFS_PRINT_HASH _IO(JFFS_IOCTL_MAGIC, 90)
+#define JFFS_PRINT_TREE _IO(JFFS_IOCTL_MAGIC, 91)
+#define JFFS_GET_STATUS _IO(JFFS_IOCTL_MAGIC, 92)
+
+/* XXX: This is something that we should try to get rid of in the future.  */
+#define JFFS_MODIFY_INODE 0x01
+#define JFFS_MODIFY_NAME  0x02
+#define JFFS_MODIFY_DATA  0x04
+#define JFFS_MODIFY_EXIST 0x08
+
+struct jffs_control;
+
+/* The JFFS raw inode structure: Used for storage on physical media.  */
+/* Perhaps the uid, gid, atime, mtime and ctime members should have
+   more space due to future changes in the Linux kernel. Anyhow, since
+   a user of this filesystem probably have to fix a large number of
+   other things, we have decided to not be forward compatible.  */
+struct jffs_raw_inode
+{
+        __u32 magic;      /* A constant magic number.  */
+        __u32 ino;        /* Inode number.  */
+        __u32 pino;       /* Parent's inode number.  */
+        __u32 version;    /* Version number.  */
+        __u32 mode;       /* The file's type or mode.  */
+        __u16 uid;        /* The file's owner.  */
+        __u16 gid;        /* The file's group.  */
+        __u32 atime;      /* Last access time.  */
+        __u32 mtime;      /* Last modification time.  */
+        __u32 ctime;      /* Creation time.  */
+        __u32 offset;     /* Where to begin to write.  */
+        __u32 dsize;      /* Size of the node's data.  */
+        __u32 rsize;      /* How much are going to be replaced?  */
+        __u8 nsize;       /* Name length.  */
+        __u8 nlink;       /* Number of links.  */
+        __u8 spare : 6;   /* For future use.  */
+        __u8 rename : 1;  /* Rename to a name of an already existing file?  */
+        __u8 deleted : 1; /* Has this file been deleted?  */
+        __u8 accurate;    /* The inode is obsolete if accurate == 0.  */
+        __u32 dchksum;    /* Checksum for the data.  */
+        __u16 nchksum;    /* Checksum for the name.  */
+        __u16 chksum;     /* Checksum for the raw inode.  */
+};
+
+/* Define the offset of the accurate byte in struct jffs_raw_inode.  */
+#define JFFS_RAW_INODE_ACCURATE_OFFSET (sizeof(struct jffs_raw_inode) \
+                                        - 2 * sizeof(__u32) - sizeof(__u8))
+
+/* Define the offset of the chksum member in struct jffs_raw_inode.  */
+#define JFFS_RAW_INODE_CHKSUM_OFFSET (sizeof(struct jffs_raw_inode) \
+                                      - sizeof(__u16))
+
+/* Define the offset of the dchksum member in struct jffs_raw_inode.  */
+#define JFFS_RAW_INODE_DCHKSUM_OFFSET (sizeof(struct jffs_raw_inode)   \
+                                       - sizeof(__u16) - sizeof(__u16) \
+                                       - sizeof(__u32))
+
+
+/* The RAM representation of the node.  The names of pointers to
+   jffs_nodes are very often just called `n' in the source code.  */
+struct jffs_node
+{
+        __u32 ino;          /* Inode number.  */
+        __u32 version;      /* Version number.  */
+        __u32 data_offset;  /* Logic location of the data to insert.  */
+        __u32 data_size;    /* The amount of data this node inserts.  */
+        __u32 removed_size; /* The amount of data that this node removes.  */
+        __u32 fm_offset;    /* Physical location of the data in the actual
+                               flash memory data chunk.  */
+        __u8 name_size;     /* Size of the name.  */
+        struct jffs_fm *fm; /* Physical memory information.  */
+        struct jffs_node *version_prev;
+        struct jffs_node *version_next;
+        struct jffs_node *range_prev;
+        struct jffs_node *range_next;
+};
+
+
+/* The RAM representation of a file (plain files, directories,
+   links, etc.).  Pointers to jffs_files are normally named `f'
+   in the JFFS source code.  */
+struct jffs_file
+{
+        __u32 ino;    /* Inode number.  */
+        __u32 pino;   /* Parent's inode number.  */
+        __u32 mode;   /* file_type, mode  */
+        __u16 uid;    /* owner  */
+        __u16 gid;    /* group  */
+        __u32 atime;  /* Last access time.  */
+        __u32 mtime;  /* Last modification time.  */
+        __u32 ctime;  /* Creation time.  */
+        __u8 nsize;   /* Name length.  */
+        __u8 nlink;   /* Number of links.  */
+        __u8 deleted; /* Has this file been deleted?  */
+        char *name;   /* The name of this file; NULL-terminated.  */
+        __u32 size;   /* The total size of the file's data.  */
+        __u32 highest_version; /* The highest version number of this file.  */
+        struct jffs_control *c;
+        struct jffs_file *parent;   /* Reference to the parent directory.  */
+        struct jffs_file *children; /* Always NULL for plain files.  */
+        struct jffs_file *sibling_prev; /* Siblings in the same directory.  */
+        struct jffs_file *sibling_next;
+        struct list_head hash;    /* hash list.  */
+        struct jffs_node *range_head;   /* The final data.  */
+        struct jffs_node *range_tail;   /* The first data.  */
+        struct jffs_node *version_head; /* The youngest node.  */
+        struct jffs_node *version_tail; /* The oldest node.  */
+};
+
+
+/* This is just a definition of a simple list used for keeping track of
+   files deleted due to a rename.  This list is only used during the
+   mounting of the file system and only if there have been rename operations
+   earlier.  */
+struct jffs_delete_list
+{
+        __u32 ino;
+        struct jffs_delete_list *next;
+};
+
+
+/* A struct for the overall file system control.  Pointers to
+   jffs_control structs are named `c' in the source code.  */
+struct jffs_control
+{
+        struct super_block *sb;         /* Reference to the VFS super block.  */
+        struct jffs_file *root;         /* The root directory file.  */
+        struct list_head *hash;         /* Hash table for finding files by ino.  */
+        struct jffs_fmcontrol *fmc;     /* Flash memory control structure.  */
+        __u32 hash_len;                 /* The size of the hash table.  */
+        __u32 next_ino;                 /* Next inode number to use for new files.  */
+        __u16 building_fs;              /* Is the file system being built right now?  */
+        struct jffs_delete_list *delete_list; /* Track deleted files.  */
+        pid_t thread_pid;               /* GC thread's PID */
+        struct task_struct *gc_task;    /* GC task struct */
+        struct completion gc_thread_comp; /* GC thread exit mutex */
+        __u32 gc_minfree_threshold;     /* GC trigger thresholds */
+        __u32 gc_maxdirty_threshold;
+};
+
+
+/* Used to inform about flash status.  */
+struct jffs_flash_status
+{
+        __u32 size;
+        __u32 used;
+        __u32 dirty;
+        __u32 begin;
+        __u32 end;
+};
+
+/* This stuff could be used for finding memory leaks.  */
+#define JFFS_MEMORY_DEBUG 0
+
+extern long no_jffs_node;
+#if defined(JFFS_MEMORY_DEBUG) && JFFS_MEMORY_DEBUG
+extern long no_jffs_control;
+extern long no_jffs_raw_inode;
+extern long no_jffs_node_ref;
+extern long no_jffs_fm;
+extern long no_jffs_fmcontrol;
+extern long no_hash;
+extern long no_name;
+#define DJM(x) x
+#else
+#define DJM(x)
+#endif
+
+#endif /* __LINUX_JFFS_H__ */
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
new file mode 100644
index 000000000000..419fc953ac16
--- /dev/null
+++ b/include/linux/jffs2.h
@@ -0,0 +1,157 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2001-2003 Red Hat, Inc.
+ *
+ * Created by David Woodhouse <dwmw2@infradead.org>
+ *
+ * For licensing information, see the file 'LICENCE' in the 
+ * jffs2 directory.
+ *
+ * $Id: jffs2.h,v 1.34 2004/11/16 20:36:14 dwmw2 Exp $
+ *
+ */
+
+#ifndef __LINUX_JFFS2_H__
+#define __LINUX_JFFS2_H__
+
+/* You must include something which defines the C99 uintXX_t types. 
+   We don't do it from here because this file is used in too many
+   different environments. */
+
+#define JFFS2_SUPER_MAGIC 0x72b6
+
+/* Values we may expect to find in the 'magic' field */
+#define JFFS2_OLD_MAGIC_BITMASK 0x1984
+#define JFFS2_MAGIC_BITMASK 0x1985
+#define KSAMTIB_CIGAM_2SFFJ 0x8519 /* For detecting wrong-endian fs */
+#define JFFS2_EMPTY_BITMASK 0xffff
+#define JFFS2_DIRTY_BITMASK 0x0000
+
+/* We only allow a single char for length, and 0xFF is empty flash so
+   we don't want it confused with a real length. Hence max 254.
+*/
+#define JFFS2_MAX_NAME_LEN 254
+
+/* How small can we sensibly write nodes? */
+#define JFFS2_MIN_DATA_LEN 128
+
+#define JFFS2_COMPR_NONE        0x00
+#define JFFS2_COMPR_ZERO        0x01
+#define JFFS2_COMPR_RTIME       0x02
+#define JFFS2_COMPR_RUBINMIPS   0x03
+#define JFFS2_COMPR_COPY        0x04
+#define JFFS2_COMPR_DYNRUBIN    0x05
+#define JFFS2_COMPR_ZLIB        0x06
+#define JFFS2_COMPR_LZO         0x07
+#define JFFS2_COMPR_LZARI       0x08
+/* Compatibility flags. */
+#define JFFS2_COMPAT_MASK 0xc000      /* What do to if an unknown nodetype is found */
+#define JFFS2_NODE_ACCURATE 0x2000
+/* INCOMPAT: Fail to mount the filesystem */
+#define JFFS2_FEATURE_INCOMPAT 0xc000
+/* ROCOMPAT: Mount read-only */
+#define JFFS2_FEATURE_ROCOMPAT 0x8000
+/* RWCOMPAT_COPY: Mount read/write, and copy the node when it's GC'd */
+#define JFFS2_FEATURE_RWCOMPAT_COPY 0x4000
+/* RWCOMPAT_DELETE: Mount read/write, and delete the node when it's GC'd */
+#define JFFS2_FEATURE_RWCOMPAT_DELETE 0x0000
+
+#define JFFS2_NODETYPE_DIRENT (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 1)
+#define JFFS2_NODETYPE_INODE (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 2)
+#define JFFS2_NODETYPE_CLEANMARKER (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
+#define JFFS2_NODETYPE_PADDING (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 4)
+
+// Maybe later...
+//#define JFFS2_NODETYPE_CHECKPOINT (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
+//#define JFFS2_NODETYPE_OPTIONS (JFFS2_FEATURE_RWCOMPAT_COPY | JFFS2_NODE_ACCURATE | 4)
+
+
+#define JFFS2_INO_FLAG_PREREAD    1     /* Do read_inode() for this one at 
+                                           mount time, don't wait for it to 
+                                           happen later */
+#define JFFS2_INO_FLAG_USERCOMPR  2     /* User has requested a specific 
+                                           compression type */
+
+
+/* These can go once we've made sure we've caught all uses without
+   byteswapping */
+
+typedef struct {
+        uint32_t v32;
+} __attribute__((packed))  jint32_t;
+
+typedef struct {
+        uint32_t m;
+} __attribute__((packed))  jmode_t;
+
+typedef struct {
+        uint16_t v16;
+} __attribute__((packed)) jint16_t;
+
+struct jffs2_unknown_node
+{
+        /* All start like this */
+        jint16_t magic;
+        jint16_t nodetype;
+        jint32_t totlen; /* So we can skip over nodes we don't grok */
+        jint32_t hdr_crc;
+} __attribute__((packed));
+
+struct jffs2_raw_dirent
+{
+        jint16_t magic;
+        jint16_t nodetype;      /* == JFFS_NODETYPE_DIRENT */
+        jint32_t totlen;
+        jint32_t hdr_crc;
+        jint32_t pino;
+        jint32_t version;
+        jint32_t ino; /* == zero for unlink */
+        jint32_t mctime;
+        uint8_t nsize;
+        uint8_t type;
+        uint8_t unused[2];
+        jint32_t node_crc;
+        jint32_t name_crc;
+        uint8_t name[0];
+} __attribute__((packed));
+
+/* The JFFS2 raw inode structure: Used for storage on physical media.  */
+/* The uid, gid, atime, mtime and ctime members could be longer, but 
+   are left like this for space efficiency. If and when people decide
+   they really need them extended, it's simple enough to add support for
+   a new type of raw node.
+*/
+struct jffs2_raw_inode
+{
+        jint16_t magic;      /* A constant magic number.  */
+        jint16_t nodetype;   /* == JFFS_NODETYPE_INODE */
+        jint32_t totlen;     /* Total length of this node (inc data, etc.) */
+        jint32_t hdr_crc;
+        jint32_t ino;        /* Inode number.  */
+        jint32_t version;    /* Version number.  */
+        jmode_t mode;       /* The file's type or mode.  */
+        jint16_t uid;        /* The file's owner.  */
+        jint16_t gid;        /* The file's group.  */
+        jint32_t isize;      /* Total resultant size of this inode (used for truncations)  */
+        jint32_t atime;      /* Last access time.  */
+        jint32_t mtime;      /* Last modification time.  */
+        jint32_t ctime;      /* Change time.  */
+        jint32_t offset;     /* Where to begin to write.  */
+        jint32_t csize;      /* (Compressed) data size */
+        jint32_t dsize;      /* Size of the node's data. (after decompression) */
+        uint8_t compr;       /* Compression algorithm used */
+        uint8_t usercompr;   /* Compression algorithm requested by the user */
+        jint16_t flags;      /* See JFFS2_INO_FLAG_* */
+        jint32_t data_crc;   /* CRC for the (compressed) data.  */
+        jint32_t node_crc;   /* CRC for the raw inode (excluding data)  */
+        uint8_t data[0];
+} __attribute__((packed));
+
+union jffs2_node_union {
+        struct jffs2_raw_inode i;
+        struct jffs2_raw_dirent d;
+        struct jffs2_unknown_node u;
+};
+
+#endif /* __LINUX_JFFS2_H__ */
diff --git a/include/linux/jffs2_fs_i.h b/include/linux/jffs2_fs_i.h
new file mode 100644
index 000000000000..6dbb1cce6646
--- /dev/null
+++ b/include/linux/jffs2_fs_i.h
@@ -0,0 +1,47 @@
+/* $Id: jffs2_fs_i.h,v 1.17 2004/11/11 23:51:27 dwmw2 Exp $ */
+
+#ifndef _JFFS2_FS_I
+#define _JFFS2_FS_I
+
+#include <linux/version.h>
+#include <linux/rbtree.h>
+#include <asm/semaphore.h>
+
+struct jffs2_inode_info {
+        /* We need an internal semaphore similar to inode->i_sem.
+           Unfortunately, we can't used the existing one, because
+           either the GC would deadlock, or we'd have to release it
+           before letting GC proceed. Or we'd have to put ugliness
+           into the GC code so it didn't attempt to obtain the i_sem
+           for the inode(s) which are already locked */
+        struct semaphore sem;
+
+        /* The highest (datanode) version number used for this ino */
+        uint32_t highest_version;
+
+        /* List of data fragments which make up the file */
+        struct rb_root fragtree;
+
+        /* There may be one datanode which isn't referenced by any of the
+           above fragments, if it contains a metadata update but no actual
+           data - or if this is a directory inode */
+        /* This also holds the _only_ dnode for symlinks/device nodes, 
+           etc. */
+        struct jffs2_full_dnode *metadata;
+
+        /* Directory entries */
+        struct jffs2_full_dirent *dents;
+
+        /* Some stuff we just have to keep in-core at all times, for each inode. */
+        struct jffs2_inode_cache *inocache;
+
+        uint16_t flags;
+        uint8_t usercompr;
+#if !defined (__ECOS)
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,2)
+        struct inode vfs_inode;
+#endif
+#endif
+};
+
+#endif /* _JFFS2_FS_I */
diff --git a/include/linux/jffs2_fs_sb.h b/include/linux/jffs2_fs_sb.h
new file mode 100644
index 000000000000..4afc8d8c2e9e
--- /dev/null
+++ b/include/linux/jffs2_fs_sb.h
@@ -0,0 +1,118 @@
+/* $Id: jffs2_fs_sb.h,v 1.48 2004/11/20 10:41:12 dwmw2 Exp $ */
+
+#ifndef _JFFS2_FS_SB
+#define _JFFS2_FS_SB
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/completion.h>
+#include <asm/semaphore.h>
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/rwsem.h>
+
+#define JFFS2_SB_FLAG_RO 1
+#define JFFS2_SB_FLAG_MOUNTING 2
+
+struct jffs2_inodirty;
+
+/* A struct for the overall file system control.  Pointers to
+   jffs2_sb_info structs are named `c' in the source code.  
+   Nee jffs_control
+*/
+struct jffs2_sb_info {
+        struct mtd_info *mtd;
+
+        uint32_t highest_ino;
+        uint32_t checked_ino;
+
+        unsigned int flags;
+
+        struct task_struct *gc_task;    /* GC task struct */
+        struct semaphore gc_thread_start; /* GC thread start mutex */
+        struct completion gc_thread_exit; /* GC thread exit completion port */
+
+        struct semaphore alloc_sem;     /* Used to protect all the following 
+                                           fields, and also to protect against
+                                           out-of-order writing of nodes. And GC. */
+        uint32_t cleanmarker_size;      /* Size of an _inline_ CLEANMARKER
+                                         (i.e. zero for OOB CLEANMARKER */
+
+        uint32_t flash_size;
+        uint32_t used_size;
+        uint32_t dirty_size;
+        uint32_t wasted_size;
+        uint32_t free_size;
+        uint32_t erasing_size;
+        uint32_t bad_size;
+        uint32_t sector_size;
+        uint32_t unchecked_size;
+
+        uint32_t nr_free_blocks;
+        uint32_t nr_erasing_blocks;
+
+        /* Number of free blocks there must be before we... */
+        uint8_t resv_blocks_write;      /* ... allow a normal filesystem write */
+        uint8_t resv_blocks_deletion;   /* ... allow a normal filesystem deletion */
+        uint8_t resv_blocks_gctrigger;  /* ... wake up the GC thread */
+        uint8_t resv_blocks_gcbad;      /* ... pick a block from the bad_list to GC */
+        uint8_t resv_blocks_gcmerge;    /* ... merge pages when garbage collecting */
+
+        uint32_t nospc_dirty_size;
+
+        uint32_t nr_blocks;
+        struct jffs2_eraseblock *blocks;        /* The whole array of blocks. Used for getting blocks 
+                                                 * from the offset (blocks[ofs / sector_size]) */
+        struct jffs2_eraseblock *nextblock;     /* The block we're currently filling */
+
+        struct jffs2_eraseblock *gcblock;       /* The block we're currently garbage-collecting */
+
+        struct list_head clean_list;            /* Blocks 100% full of clean data */
+        struct list_head very_dirty_list;       /* Blocks with lots of dirty space */
+        struct list_head dirty_list;            /* Blocks with some dirty space */
+        struct list_head erasable_list;         /* Blocks which are completely dirty, and need erasing */
+        struct list_head erasable_pending_wbuf_list;    /* Blocks which need erasing but only after the current wbuf is flushed */
+        struct list_head erasing_list;          /* Blocks which are currently erasing */
+        struct list_head erase_pending_list;    /* Blocks which need erasing now */
+        struct list_head erase_complete_list;   /* Blocks which are erased and need the clean marker written to them */
+        struct list_head free_list;             /* Blocks which are free and ready to be used */
+        struct list_head bad_list;              /* Bad blocks. */
+        struct list_head bad_used_list;         /* Bad blocks with valid data in. */
+
+        spinlock_t erase_completion_lock;       /* Protect free_list and erasing_list 
+                                                   against erase completion handler */
+        wait_queue_head_t erase_wait;           /* For waiting for erases to complete */
+
+        wait_queue_head_t inocache_wq;
+        struct jffs2_inode_cache **inocache_list;
+        spinlock_t inocache_lock;
+        
+        /* Sem to allow jffs2_garbage_collect_deletion_dirent to
+           drop the erase_completion_lock while it's holding a pointer 
+           to an obsoleted node. I don't like this. Alternatives welcomed. */
+        struct semaphore erase_free_sem;
+
+#if defined CONFIG_JFFS2_FS_NAND || defined CONFIG_JFFS2_FS_NOR_ECC
+        /* Write-behind buffer for NAND flash */
+        unsigned char *wbuf;
+        uint32_t wbuf_ofs;
+        uint32_t wbuf_len;
+        uint32_t wbuf_pagesize;
+        struct jffs2_inodirty *wbuf_inodes;
+
+        struct rw_semaphore wbuf_sem;   /* Protects the write buffer */
+
+        /* Information about out-of-band area usage... */
+        struct nand_oobinfo *oobinfo;
+        uint32_t badblock_pos;
+        uint32_t fsdata_pos;
+        uint32_t fsdata_len;
+#endif
+
+        /* OS-private pointer for getting back to master superblock info */
+        void *os_priv;
+};
+
+#endif /* _JFFS2_FB_SB */
diff --git a/include/linux/jhash.h b/include/linux/jhash.h
new file mode 100644
index 000000000000..82c7ae412eec
--- /dev/null
+++ b/include/linux/jhash.h
@@ -0,0 +1,143 @@
+#ifndef _LINUX_JHASH_H
+#define _LINUX_JHASH_H
+
+/* jhash.h: Jenkins hash support.
+ *
+ * Copyright (C) 1996 Bob Jenkins (bob_jenkins@burtleburtle.net)
+ *
+ * http://burtleburtle.net/bob/hash/
+ *
+ * These are the credits from Bob's sources:
+ *
+ * lookup2.c, by Bob Jenkins, December 1996, Public Domain.
+ * hash(), hash2(), hash3, and mix() are externally useful functions.
+ * Routines to test the hash are included if SELF_TEST is defined.
+ * You can use this free for any purpose.  It has no warranty.
+ *
+ * Copyright (C) 2003 David S. Miller (davem@redhat.com)
+ *
+ * I've modified Bob's hash to be useful in the Linux kernel, and
+ * any bugs present are surely my fault.  -DaveM
+ */
+
+/* NOTE: Arguments are modified. */
+#define __jhash_mix(a, b, c) \
+{ \
+  a -= b; a -= c; a ^= (c>>13); \
+  b -= c; b -= a; b ^= (a<<8); \
+  c -= a; c -= b; c ^= (b>>13); \
+  a -= b; a -= c; a ^= (c>>12);  \
+  b -= c; b -= a; b ^= (a<<16); \
+  c -= a; c -= b; c ^= (b>>5); \
+  a -= b; a -= c; a ^= (c>>3);  \
+  b -= c; b -= a; b ^= (a<<10); \
+  c -= a; c -= b; c ^= (b>>15); \
+}
+
+/* The golden ration: an arbitrary value */
+#define JHASH_GOLDEN_RATIO      0x9e3779b9
+
+/* The most generic version, hashes an arbitrary sequence
+ * of bytes.  No alignment or length assumptions are made about
+ * the input key.
+ */
+static inline u32 jhash(const void *key, u32 length, u32 initval)
+{
+        u32 a, b, c, len;
+        const u8 *k = key;
+
+        len = length;
+        a = b = JHASH_GOLDEN_RATIO;
+        c = initval;
+
+        while (len >= 12) {
+                a += (k[0] +((u32)k[1]<<8) +((u32)k[2]<<16) +((u32)k[3]<<24));
+                b += (k[4] +((u32)k[5]<<8) +((u32)k[6]<<16) +((u32)k[7]<<24));
+                c += (k[8] +((u32)k[9]<<8) +((u32)k[10]<<16)+((u32)k[11]<<24));
+
+                __jhash_mix(a,b,c);
+
+                k += 12;
+                len -= 12;
+        }
+
+        c += length;
+        switch (len) {
+        case 11: c += ((u32)k[10]<<24);
+        case 10: c += ((u32)k[9]<<16);
+        case 9 : c += ((u32)k[8]<<8);
+        case 8 : b += ((u32)k[7]<<24);
+        case 7 : b += ((u32)k[6]<<16);
+        case 6 : b += ((u32)k[5]<<8);
+        case 5 : b += k[4];
+        case 4 : a += ((u32)k[3]<<24);
+        case 3 : a += ((u32)k[2]<<16);
+        case 2 : a += ((u32)k[1]<<8);
+        case 1 : a += k[0];
+        };
+
+        __jhash_mix(a,b,c);
+
+        return c;
+}
+
+/* A special optimized version that handles 1 or more of u32s.
+ * The length parameter here is the number of u32s in the key.
+ */
+static inline u32 jhash2(u32 *k, u32 length, u32 initval)
+{
+        u32 a, b, c, len;
+
+        a = b = JHASH_GOLDEN_RATIO;
+        c = initval;
+        len = length;
+
+        while (len >= 3) {
+                a += k[0];
+                b += k[1];
+                c += k[2];
+                __jhash_mix(a, b, c);
+                k += 3; len -= 3;
+        }
+
+        c += length * 4;
+
+        switch (len) {
+        case 2 : b += k[1];
+        case 1 : a += k[0];
+        };
+
+        __jhash_mix(a,b,c);
+
+        return c;
+}
+
+
+/* A special ultra-optimized versions that knows they are hashing exactly
+ * 3, 2 or 1 word(s).
+ *
+ * NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally
+ *       done at the end is not done here.
+ */
+static inline u32 jhash_3words(u32 a, u32 b, u32 c, u32 initval)
+{
+        a += JHASH_GOLDEN_RATIO;
+        b += JHASH_GOLDEN_RATIO;
+        c += initval;
+
+        __jhash_mix(a, b, c);
+
+        return c;
+}
+
+static inline u32 jhash_2words(u32 a, u32 b, u32 initval)
+{
+        return jhash_3words(a, b, 0, initval);
+}
+
+static inline u32 jhash_1word(u32 a, u32 initval)
+{
+        return jhash_3words(a, 0, 0, initval);
+}
+
+#endif /* _LINUX_JHASH_H */
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
new file mode 100644
index 000000000000..d7a2555a886c
--- /dev/null
+++ b/include/linux/jiffies.h
@@ -0,0 +1,450 @@
+#ifndef _LINUX_JIFFIES_H
+#define _LINUX_JIFFIES_H
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/time.h>
+#include <linux/timex.h>
+#include <asm/param.h>                  /* for HZ */
+#include <asm/div64.h>
+
+#ifndef div_long_long_rem
+#define div_long_long_rem(dividend,divisor,remainder) \
+({                                                      \
+        u64 result = dividend;                          \
+        *remainder = do_div(result,divisor);            \
+        result;                                         \
+})
+#endif
+
+/*
+ * The following defines establish the engineering parameters of the PLL
+ * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
+ * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
+ * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
+ * nearest power of two in order to avoid hardware multiply operations.
+ */
+#if HZ >= 12 && HZ < 24
+# define SHIFT_HZ       4
+#elif HZ >= 24 && HZ < 48
+# define SHIFT_HZ       5
+#elif HZ >= 48 && HZ < 96
+# define SHIFT_HZ       6
+#elif HZ >= 96 && HZ < 192
+# define SHIFT_HZ       7
+#elif HZ >= 192 && HZ < 384
+# define SHIFT_HZ       8
+#elif HZ >= 384 && HZ < 768
+# define SHIFT_HZ       9
+#elif HZ >= 768 && HZ < 1536
+# define SHIFT_HZ       10
+#else
+# error You lose.
+#endif
+
+/* LATCH is used in the interval timer and ftape setup. */
+#define LATCH  ((CLOCK_TICK_RATE + HZ/2) / HZ)  /* For divider */
+
+/* Suppose we want to devide two numbers NOM and DEN: NOM/DEN, the we can
+ * improve accuracy by shifting LSH bits, hence calculating:
+ *     (NOM << LSH) / DEN
+ * This however means trouble for large NOM, because (NOM << LSH) may no
+ * longer fit in 32 bits. The following way of calculating this gives us
+ * some slack, under the following conditions:
+ *   - (NOM / DEN) fits in (32 - LSH) bits.
+ *   - (NOM % DEN) fits in (32 - LSH) bits.
+ */
+#define SH_DIV(NOM,DEN,LSH) (   ((NOM / DEN) << LSH)                    \
+                             + (((NOM % DEN) << LSH) + DEN / 2) / DEN)
+
+/* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */
+#define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8))
+
+/* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */
+#define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8))
+
+/* TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
+#define TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
+
+/* TICK_USEC_TO_NSEC is the time between ticks in nsec assuming real ACTHZ and  */
+/* a value TUSEC for TICK_USEC (can be set bij adjtimex)                */
+#define TICK_USEC_TO_NSEC(TUSEC) (SH_DIV (TUSEC * USER_HZ * 1000, ACTHZ, 8))
+
+/* some arch's have a small-data section that can be accessed register-relative
+ * but that can only take up to, say, 4-byte variables. jiffies being part of
+ * an 8-byte variable may not be correctly accessed unless we force the issue
+ */
+#define __jiffy_data  __attribute__((section(".data")))
+
+/*
+ * The 64-bit value is not volatile - you MUST NOT read it
+ * without sampling the sequence number in xtime_lock.
+ * get_jiffies_64() will do this for you as appropriate.
+ */
+extern u64 __jiffy_data jiffies_64;
+extern unsigned long volatile __jiffy_data jiffies;
+
+#if (BITS_PER_LONG < 64)
+u64 get_jiffies_64(void);
+#else
+static inline u64 get_jiffies_64(void)
+{
+        return (u64)jiffies;
+}
+#endif
+
+/*
+ *      These inlines deal with timer wrapping correctly. You are 
+ *      strongly encouraged to use them
+ *      1. Because people otherwise forget
+ *      2. Because if the timer wrap changes in future you won't have to
+ *         alter your driver code.
+ *
+ * time_after(a,b) returns true if the time a is after time b.
+ *
+ * Do this with "<0" and ">=0" to only test the sign of the result. A
+ * good compiler would generate better code (and a really good compiler
+ * wouldn't care). Gcc is currently neither.
+ */
+#define time_after(a,b)         \
+        (typecheck(unsigned long, a) && \
+         typecheck(unsigned long, b) && \
+         ((long)(b) - (long)(a) < 0))
+#define time_before(a,b)        time_after(b,a)
+
+#define time_after_eq(a,b)      \
+        (typecheck(unsigned long, a) && \
+         typecheck(unsigned long, b) && \
+         ((long)(a) - (long)(b) >= 0))
+#define time_before_eq(a,b)     time_after_eq(b,a)
+
+/*
+ * Have the 32 bit jiffies value wrap 5 minutes after boot
+ * so jiffies wrap bugs show up earlier.
+ */
+#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
+
+/*
+ * Change timeval to jiffies, trying to avoid the
+ * most obvious overflows..
+ *
+ * And some not so obvious.
+ *
+ * Note that we don't want to return MAX_LONG, because
+ * for various timeout reasons we often end up having
+ * to wait "jiffies+1" in order to guarantee that we wait
+ * at _least_ "jiffies" - so "jiffies+1" had better still
+ * be positive.
+ */
+#define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
+
+/*
+ * We want to do realistic conversions of time so we need to use the same
+ * values the update wall clock code uses as the jiffies size.  This value
+ * is: TICK_NSEC (which is defined in timex.h).  This
+ * is a constant and is in nanoseconds.  We will used scaled math
+ * with a set of scales defined here as SEC_JIFFIE_SC,  USEC_JIFFIE_SC and
+ * NSEC_JIFFIE_SC.  Note that these defines contain nothing but
+ * constants and so are computed at compile time.  SHIFT_HZ (computed in
+ * timex.h) adjusts the scaling for different HZ values.
+
+ * Scaled math???  What is that?
+ *
+ * Scaled math is a way to do integer math on values that would,
+ * otherwise, either overflow, underflow, or cause undesired div
+ * instructions to appear in the execution path.  In short, we "scale"
+ * up the operands so they take more bits (more precision, less
+ * underflow), do the desired operation and then "scale" the result back
+ * by the same amount.  If we do the scaling by shifting we avoid the
+ * costly mpy and the dastardly div instructions.
+
+ * Suppose, for example, we want to convert from seconds to jiffies
+ * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE.  The
+ * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
+ * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
+ * might calculate at compile time, however, the result will only have
+ * about 3-4 bits of precision (less for smaller values of HZ).
+ *
+ * So, we scale as follows:
+ * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
+ * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
+ * Then we make SCALE a power of two so:
+ * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
+ * Now we define:
+ * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
+ * jiff = (sec * SEC_CONV) >> SCALE;
+ *
+ * Often the math we use will expand beyond 32-bits so we tell C how to
+ * do this and pass the 64-bit result of the mpy through the ">> SCALE"
+ * which should take the result back to 32-bits.  We want this expansion
+ * to capture as much precision as possible.  At the same time we don't
+ * want to overflow so we pick the SCALE to avoid this.  In this file,
+ * that means using a different scale for each range of HZ values (as
+ * defined in timex.h).
+ *
+ * For those who want to know, gcc will give a 64-bit result from a "*"
+ * operator if the result is a long long AND at least one of the
+ * operands is cast to long long (usually just prior to the "*" so as
+ * not to confuse it into thinking it really has a 64-bit operand,
+ * which, buy the way, it can do, but it take more code and at least 2
+ * mpys).
+
+ * We also need to be aware that one second in nanoseconds is only a
+ * couple of bits away from overflowing a 32-bit word, so we MUST use
+ * 64-bits to get the full range time in nanoseconds.
+
+ */
+
+/*
+ * Here are the scales we will use.  One for seconds, nanoseconds and
+ * microseconds.
+ *
+ * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
+ * check if the sign bit is set.  If not, we bump the shift count by 1.
+ * (Gets an extra bit of precision where we can use it.)
+ * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
+ * Haven't tested others.
+
+ * Limits of cpp (for #if expressions) only long (no long long), but
+ * then we only need the most signicant bit.
+ */
+
+#define SEC_JIFFIE_SC (31 - SHIFT_HZ)
+#if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
+#undef SEC_JIFFIE_SC
+#define SEC_JIFFIE_SC (32 - SHIFT_HZ)
+#endif
+#define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
+#define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19)
+#define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
+                                TICK_NSEC -1) / (u64)TICK_NSEC))
+
+#define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\
+                                        TICK_NSEC -1) / (u64)TICK_NSEC))
+#define USEC_CONVERSION  \
+                    ((unsigned long)((((u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\
+                                        TICK_NSEC -1) / (u64)TICK_NSEC))
+/*
+ * USEC_ROUND is used in the timeval to jiffie conversion.  See there
+ * for more details.  It is the scaled resolution rounding value.  Note
+ * that it is a 64-bit value.  Since, when it is applied, we are already
+ * in jiffies (albit scaled), it is nothing but the bits we will shift
+ * off.
+ */
+#define USEC_ROUND (u64)(((u64)1 << USEC_JIFFIE_SC) - 1)
+/*
+ * The maximum jiffie value is (MAX_INT >> 1).  Here we translate that
+ * into seconds.  The 64-bit case will overflow if we are not careful,
+ * so use the messy SH_DIV macro to do it.  Still all constants.
+ */
+#if BITS_PER_LONG < 64
+# define MAX_SEC_IN_JIFFIES \
+        (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
+#else   /* take care of overflow on 64 bits machines */
+# define MAX_SEC_IN_JIFFIES \
+        (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
+
+#endif
+
+/*
+ * Convert jiffies to milliseconds and back.
+ *
+ * Avoid unnecessary multiplications/divisions in the
+ * two most common HZ cases:
+ */
+static inline unsigned int jiffies_to_msecs(const unsigned long j)
+{
+#if HZ <= 1000 && !(1000 % HZ)
+        return (1000 / HZ) * j;
+#elif HZ > 1000 && !(HZ % 1000)
+        return (j + (HZ / 1000) - 1)/(HZ / 1000);
+#else
+        return (j * 1000) / HZ;
+#endif
+}
+
+static inline unsigned int jiffies_to_usecs(const unsigned long j)
+{
+#if HZ <= 1000000 && !(1000000 % HZ)
+        return (1000000 / HZ) * j;
+#elif HZ > 1000000 && !(HZ % 1000000)
+        return (j + (HZ / 1000000) - 1)/(HZ / 1000000);
+#else
+        return (j * 1000000) / HZ;
+#endif
+}
+
+static inline unsigned long msecs_to_jiffies(const unsigned int m)
+{
+        if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
+                return MAX_JIFFY_OFFSET;
+#if HZ <= 1000 && !(1000 % HZ)
+        return (m + (1000 / HZ) - 1) / (1000 / HZ);
+#elif HZ > 1000 && !(HZ % 1000)
+        return m * (HZ / 1000);
+#else
+        return (m * HZ + 999) / 1000;
+#endif
+}
+
+static inline unsigned long usecs_to_jiffies(const unsigned int u)
+{
+        if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
+                return MAX_JIFFY_OFFSET;
+#if HZ <= 1000000 && !(1000000 % HZ)
+        return (u + (1000000 / HZ) - 1) / (1000000 / HZ);
+#elif HZ > 1000000 && !(HZ % 1000000)
+        return u * (HZ / 1000000);
+#else
+        return (u * HZ + 999999) / 1000000;
+#endif
+}
+
+/*
+ * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
+ * that a remainder subtract here would not do the right thing as the
+ * resolution values don't fall on second boundries.  I.e. the line:
+ * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
+ *
+ * Rather, we just shift the bits off the right.
+ *
+ * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
+ * value to a scaled second value.
+ */
+static __inline__ unsigned long
+timespec_to_jiffies(const struct timespec *value)
+{
+        unsigned long sec = value->tv_sec;
+        long nsec = value->tv_nsec + TICK_NSEC - 1;
+
+        if (sec >= MAX_SEC_IN_JIFFIES){
+                sec = MAX_SEC_IN_JIFFIES;
+                nsec = 0;
+        }
+        return (((u64)sec * SEC_CONVERSION) +
+                (((u64)nsec * NSEC_CONVERSION) >>
+                 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
+
+}
+
+static __inline__ void
+jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
+{
+        /*
+         * Convert jiffies to nanoseconds and separate with
+         * one divide.
+         */
+        u64 nsec = (u64)jiffies * TICK_NSEC;
+        value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
+}
+
+/* Same for "timeval"
+ *
+ * Well, almost.  The problem here is that the real system resolution is
+ * in nanoseconds and the value being converted is in micro seconds.
+ * Also for some machines (those that use HZ = 1024, in-particular),
+ * there is a LARGE error in the tick size in microseconds.
+
+ * The solution we use is to do the rounding AFTER we convert the
+ * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
+ * Instruction wise, this should cost only an additional add with carry
+ * instruction above the way it was done above.
+ */
+static __inline__ unsigned long
+timeval_to_jiffies(const struct timeval *value)
+{
+        unsigned long sec = value->tv_sec;
+        long usec = value->tv_usec;
+
+        if (sec >= MAX_SEC_IN_JIFFIES){
+                sec = MAX_SEC_IN_JIFFIES;
+                usec = 0;
+        }
+        return (((u64)sec * SEC_CONVERSION) +
+                (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
+                 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
+}
+
+static __inline__ void
+jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
+{
+        /*
+         * Convert jiffies to nanoseconds and separate with
+         * one divide.
+         */
+        u64 nsec = (u64)jiffies * TICK_NSEC;
+        value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_usec);
+        value->tv_usec /= NSEC_PER_USEC;
+}
+
+/*
+ * Convert jiffies/jiffies_64 to clock_t and back.
+ */
+static inline clock_t jiffies_to_clock_t(long x)
+{
+#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
+        return x / (HZ / USER_HZ);
+#else
+        u64 tmp = (u64)x * TICK_NSEC;
+        do_div(tmp, (NSEC_PER_SEC / USER_HZ));
+        return (long)tmp;
+#endif
+}
+
+static inline unsigned long clock_t_to_jiffies(unsigned long x)
+{
+#if (HZ % USER_HZ)==0
+        if (x >= ~0UL / (HZ / USER_HZ))
+                return ~0UL;
+        return x * (HZ / USER_HZ);
+#else
+        u64 jif;
+
+        /* Don't worry about loss of precision here .. */
+        if (x >= ~0UL / HZ * USER_HZ)
+                return ~0UL;
+
+        /* .. but do try to contain it here */
+        jif = x * (u64) HZ;
+        do_div(jif, USER_HZ);
+        return jif;
+#endif
+}
+
+static inline u64 jiffies_64_to_clock_t(u64 x)
+{
+#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
+        do_div(x, HZ / USER_HZ);
+#else
+        /*
+         * There are better ways that don't overflow early,
+         * but even this doesn't overflow in hundreds of years
+         * in 64 bits, so..
+         */
+        x *= TICK_NSEC;
+        do_div(x, (NSEC_PER_SEC / USER_HZ));
+#endif
+        return x;
+}
+
+static inline u64 nsec_to_clock_t(u64 x)
+{
+#if (NSEC_PER_SEC % USER_HZ) == 0
+        do_div(x, (NSEC_PER_SEC / USER_HZ));
+#elif (USER_HZ % 512) == 0
+        x *= USER_HZ/512;
+        do_div(x, (NSEC_PER_SEC / 512));
+#else
+        /*
+         * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
+         * overflow after 64.99 years.
+         * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
+         */
+        x *= 9;
+        do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2))
+                                  / USER_HZ));
+#endif
+        return x;
+}
+
+#endif
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h
new file mode 100644
index 000000000000..8a62d1e84b9b
--- /dev/null
+++ b/include/linux/journal-head.h
@@ -0,0 +1,92 @@
+/*
+ * include/linux/journal-head.h
+ *
+ * buffer_head fields for JBD
+ *
+ * 27 May 2001 Andrew Morton <akpm@digeo.com>
+ *      Created - pulled out of fs.h
+ */
+
+#ifndef JOURNAL_HEAD_H_INCLUDED
+#define JOURNAL_HEAD_H_INCLUDED
+
+typedef unsigned int            tid_t;          /* Unique transaction ID */
+typedef struct transaction_s    transaction_t;  /* Compound transaction type */
+struct buffer_head;
+
+struct journal_head {
+        /*
+         * Points back to our buffer_head. [jbd_lock_bh_journal_head()]
+         */
+        struct buffer_head *b_bh;
+
+        /*
+         * Reference count - see description in journal.c
+         * [jbd_lock_bh_journal_head()]
+         */
+        int b_jcount;
+
+        /*
+         * Journalling list for this buffer [jbd_lock_bh_state()]
+         */
+        unsigned b_jlist;
+
+        /*
+         * This flag signals the buffer has been modified by
+         * the currently running transaction
+         * [jbd_lock_bh_state()]
+         */
+        unsigned b_modified;
+
+        /*
+         * Copy of the buffer data frozen for writing to the log.
+         * [jbd_lock_bh_state()]
+         */
+        char *b_frozen_data;
+
+        /*
+         * Pointer to a saved copy of the buffer containing no uncommitted
+         * deallocation references, so that allocations can avoid overwriting
+         * uncommitted deletes. [jbd_lock_bh_state()]
+         */
+        char *b_committed_data;
+
+        /*
+         * Pointer to the compound transaction which owns this buffer's
+         * metadata: either the running transaction or the committing
+         * transaction (if there is one).  Only applies to buffers on a
+         * transaction's data or metadata journaling list.
+         * [j_list_lock] [jbd_lock_bh_state()]
+         */
+        transaction_t *b_transaction;
+
+        /*
+         * Pointer to the running compound transaction which is currently
+         * modifying the buffer's metadata, if there was already a transaction
+         * committing it when the new transaction touched it.
+         * [t_list_lock] [jbd_lock_bh_state()]
+         */
+        transaction_t *b_next_transaction;
+
+        /*
+         * Doubly-linked list of buffers on a transaction's data, metadata or
+         * forget queue. [t_list_lock] [jbd_lock_bh_state()]
+         */
+        struct journal_head *b_tnext, *b_tprev;
+
+        /*
+         * Pointer to the compound transaction against which this buffer
+         * is checkpointed.  Only dirty buffers can be checkpointed.
+         * [j_list_lock]
+         */
+        transaction_t *b_cp_transaction;
+
+        /*
+         * Doubly-linked list of buffers still remaining to be flushed
+         * before an old transaction can be checkpointed.
+         * [j_list_lock]
+         */
+        struct journal_head *b_cpnext, *b_cpprev;
+};
+
+#endif          /* JOURNAL_HEAD_H_INCLUDED */
diff --git a/include/linux/joystick.h b/include/linux/joystick.h
new file mode 100644
index 000000000000..b7e0ab622cd7
--- /dev/null
+++ b/include/linux/joystick.h
@@ -0,0 +1,128 @@
+#ifndef _LINUX_JOYSTICK_H
+#define _LINUX_JOYSTICK_H
+
+/*
+ * $Id: joystick.h,v 1.3 2000/11/30 11:07:05 vojtech Exp $
+ *
+ *  Copyright (C) 1996-2000 Vojtech Pavlik
+ *
+ *  Sponsored by SuSE
+ */
+
+/*
+ * 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; either version 2 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * 
+ * Should you need to contact me, the author, you can do so either by
+ * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
+ * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
+ */
+
+#include <asm/types.h>
+#include <linux/input.h>
+
+/*
+ * Version
+ */
+
+#define JS_VERSION              0x020100
+
+/*
+ * Types and constants for reading from /dev/js
+ */
+
+#define JS_EVENT_BUTTON         0x01    /* button pressed/released */
+#define JS_EVENT_AXIS           0x02    /* joystick moved */
+#define JS_EVENT_INIT           0x80    /* initial state of device */
+
+struct js_event {
+        __u32 time;     /* event timestamp in milliseconds */
+        __s16 value;    /* value */
+        __u8 type;      /* event type */
+        __u8 number;    /* axis/button number */
+};
+
+/*
+ * IOCTL commands for joystick driver
+ */
+
+#define JSIOCGVERSION           _IOR('j', 0x01, __u32)                          /* get driver version */
+
+#define JSIOCGAXES              _IOR('j', 0x11, __u8)                           /* get number of axes */
+#define JSIOCGBUTTONS           _IOR('j', 0x12, __u8)                           /* get number of buttons */
+#define JSIOCGNAME(len)         _IOC(_IOC_READ, 'j', 0x13, len)                 /* get identifier string */
+
+#define JSIOCSCORR              _IOW('j', 0x21, struct js_corr)                 /* set correction values */
+#define JSIOCGCORR              _IOR('j', 0x22, struct js_corr)                 /* get correction values */
+
+#define JSIOCSAXMAP             _IOW('j', 0x31, __u8[ABS_MAX + 1])              /* set axis mapping */
+#define JSIOCGAXMAP             _IOR('j', 0x32, __u8[ABS_MAX + 1])              /* get axis mapping */
+#define JSIOCSBTNMAP            _IOW('j', 0x33, __u16[KEY_MAX - BTN_MISC + 1])  /* set button mapping */
+#define JSIOCGBTNMAP            _IOR('j', 0x34, __u16[KEY_MAX - BTN_MISC + 1])  /* get button mapping */
+
+/*
+ * Types and constants for get/set correction
+ */
+
+#define JS_CORR_NONE            0x00    /* returns raw values */
+#define JS_CORR_BROKEN          0x01    /* broken line */
+
+struct js_corr {
+        __s32 coef[8];
+        __s16 prec;
+        __u16 type;
+};
+
+/*
+ * v0.x compatibility definitions
+ */
+
+#define JS_RETURN               sizeof(struct JS_DATA_TYPE)
+#define JS_TRUE                 1
+#define JS_FALSE                0
+#define JS_X_0                  0x01
+#define JS_Y_0                  0x02
+#define JS_X_1                  0x04
+#define JS_Y_1                  0x08
+#define JS_MAX                  2
+
+#define JS_DEF_TIMEOUT          0x1300
+#define JS_DEF_CORR             0
+#define JS_DEF_TIMELIMIT        10L
+
+#define JS_SET_CAL              1
+#define JS_GET_CAL              2
+#define JS_SET_TIMEOUT          3
+#define JS_GET_TIMEOUT          4
+#define JS_SET_TIMELIMIT        5
+#define JS_GET_TIMELIMIT        6
+#define JS_GET_ALL              7
+#define JS_SET_ALL              8
+
+struct JS_DATA_TYPE {
+        int buttons;
+        int x;
+        int y;
+};
+
+struct JS_DATA_SAVE_TYPE {
+        int JS_TIMEOUT;
+        int BUSY;
+        long JS_EXPIRETIME;
+        long JS_TIMELIMIT;
+        struct JS_DATA_TYPE JS_SAVE;
+        struct JS_DATA_TYPE JS_CORR;
+};
+
+#endif /* _LINUX_JOYSTICK_H */
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
new file mode 100644
index 000000000000..9bbd04092365
--- /dev/null
+++ b/include/linux/kallsyms.h
@@ -0,0 +1,67 @@
+/* Rewritten and vastly simplified by Rusty Russell for in-kernel
+ * module loader:
+ *   Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
+ */
+#ifndef _LINUX_KALLSYMS_H
+#define _LINUX_KALLSYMS_H
+
+#include <linux/config.h>
+
+#define KSYM_NAME_LEN 127
+
+#ifdef CONFIG_KALLSYMS
+/* Lookup the address for a symbol. Returns 0 if not found. */
+unsigned long kallsyms_lookup_name(const char *name);
+
+/* Lookup an address.  modname is set to NULL if it's in the kernel. */
+const char *kallsyms_lookup(unsigned long addr,
+                            unsigned long *symbolsize,
+                            unsigned long *offset,
+                            char **modname, char *namebuf);
+
+/* Replace "%s" in format with address, if found */
+extern void __print_symbol(const char *fmt, unsigned long address);
+
+#else /* !CONFIG_KALLSYMS */
+
+static inline unsigned long kallsyms_lookup_name(const char *name)
+{
+        return 0;
+}
+
+static inline const char *kallsyms_lookup(unsigned long addr,
+                                          unsigned long *symbolsize,
+                                          unsigned long *offset,
+                                          char **modname, char *namebuf)
+{
+        return NULL;
+}
+
+/* Stupid that this does nothing, but I didn't create this mess. */
+#define __print_symbol(fmt, addr)
+#endif /*CONFIG_KALLSYMS*/
+
+/* This macro allows us to keep printk typechecking */
+static void __check_printsym_format(const char *fmt, ...)
+__attribute__((format(printf,1,2)));
+static inline void __check_printsym_format(const char *fmt, ...)
+{
+}
+/* ia64 and ppc64 use function descriptors, which contain the real address */
+#if defined(CONFIG_IA64) || defined(CONFIG_PPC64)
+#define print_fn_descriptor_symbol(fmt, addr)           \
+do {                                            \
+        unsigned long *__faddr = (unsigned long*) addr;         \
+        print_symbol(fmt, __faddr[0]);          \
+} while (0)
+#else
+#define print_fn_descriptor_symbol(fmt, addr) print_symbol(fmt, addr)
+#endif
+
+#define print_symbol(fmt, addr)                 \
+do {                                            \
+        __check_printsym_format(fmt, "");       \
+        __print_symbol(fmt, addr);              \
+} while(0)
+
+#endif /*_LINUX_KALLSYMS_H*/
diff --git a/include/linux/kbd_diacr.h b/include/linux/kbd_diacr.h
new file mode 100644
index 000000000000..1c1a3ff0535b
--- /dev/null
+++ b/include/linux/kbd_diacr.h
@@ -0,0 +1,8 @@
+#ifndef _DIACR_H
+#define _DIACR_H
+#include <linux/kd.h>
+
+extern struct kbdiacr accent_table[];
+extern unsigned int accent_table_size;
+
+#endif /* _DIACR_H */
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
new file mode 100644
index 000000000000..7428198111eb
--- /dev/null
+++ b/include/linux/kbd_kern.h
@@ -0,0 +1,157 @@
+#ifndef _KBD_KERN_H
+#define _KBD_KERN_H
+
+#include <linux/tty.h>
+#include <linux/interrupt.h>
+#include <linux/keyboard.h>
+
+extern struct tasklet_struct keyboard_tasklet;
+
+extern int shift_state;
+
+extern char *func_table[MAX_NR_FUNC];
+extern char func_buf[];
+extern char *funcbufptr;
+extern int funcbufsize, funcbufleft;
+
+/*
+ * kbd->xxx contains the VC-local things (flag settings etc..)
+ *
+ * Note: externally visible are LED_SCR, LED_NUM, LED_CAP defined in kd.h
+ *       The code in KDGETLED / KDSETLED depends on the internal and
+ *       external order being the same.
+ *
+ * Note: lockstate is used as index in the array key_map.
+ */
+struct kbd_struct {
+
+        unsigned char lockstate;
+/* 8 modifiers - the names do not have any meaning at all;
+   they can be associated to arbitrarily chosen keys */
+#define VC_SHIFTLOCK    KG_SHIFT        /* shift lock mode */
+#define VC_ALTGRLOCK    KG_ALTGR        /* altgr lock mode */
+#define VC_CTRLLOCK     KG_CTRL         /* control lock mode */
+#define VC_ALTLOCK      KG_ALT          /* alt lock mode */
+#define VC_SHIFTLLOCK   KG_SHIFTL       /* shiftl lock mode */
+#define VC_SHIFTRLOCK   KG_SHIFTR       /* shiftr lock mode */
+#define VC_CTRLLLOCK    KG_CTRLL        /* ctrll lock mode */
+#define VC_CTRLRLOCK    KG_CTRLR        /* ctrlr lock mode */
+        unsigned char slockstate;       /* for `sticky' Shift, Ctrl, etc. */
+
+        unsigned char ledmode:2;        /* one 2-bit value */
+#define LED_SHOW_FLAGS 0        /* traditional state */
+#define LED_SHOW_IOCTL 1        /* only change leds upon ioctl */
+#define LED_SHOW_MEM 2          /* `heartbeat': peek into memory */
+
+        unsigned char ledflagstate:4;   /* flags, not lights */
+        unsigned char default_ledflagstate:4;
+#define VC_SCROLLOCK    0       /* scroll-lock mode */
+#define VC_NUMLOCK      1       /* numeric lock mode */
+#define VC_CAPSLOCK     2       /* capslock mode */
+#define VC_KANALOCK     3       /* kanalock mode */
+
+        unsigned char kbdmode:2;        /* one 2-bit value */
+#define VC_XLATE        0       /* translate keycodes using keymap */
+#define VC_MEDIUMRAW    1       /* medium raw (keycode) mode */
+#define VC_RAW          2       /* raw (scancode) mode */
+#define VC_UNICODE      3       /* Unicode mode */
+
+        unsigned char modeflags:5;
+#define VC_APPLIC       0       /* application key mode */
+#define VC_CKMODE       1       /* cursor key mode */
+#define VC_REPEAT       2       /* keyboard repeat */
+#define VC_CRLF         3       /* 0 - enter sends CR, 1 - enter sends CRLF */
+#define VC_META         4       /* 0 - meta, 1 - meta=prefix with ESC */
+};
+
+extern struct kbd_struct kbd_table[];
+
+extern int kbd_init(void);
+
+extern unsigned char getledstate(void);
+extern void setledstate(struct kbd_struct *kbd, unsigned int led);
+
+extern int do_poke_blanked_console;
+
+extern void (*kbd_ledfunc)(unsigned int led);
+
+extern void set_console(int nr);
+extern void schedule_console_callback(void);
+
+static inline void set_leds(void)
+{
+        tasklet_schedule(&keyboard_tasklet);
+}
+
+static inline int vc_kbd_mode(struct kbd_struct * kbd, int flag)
+{
+        return ((kbd->modeflags >> flag) & 1);
+}
+
+static inline int vc_kbd_led(struct kbd_struct * kbd, int flag)
+{
+        return ((kbd->ledflagstate >> flag) & 1);
+}
+
+static inline void set_vc_kbd_mode(struct kbd_struct * kbd, int flag)
+{
+        kbd->modeflags |= 1 << flag;
+}
+
+static inline void set_vc_kbd_led(struct kbd_struct * kbd, int flag)
+{
+        kbd->ledflagstate |= 1 << flag;
+}
+
+static inline void clr_vc_kbd_mode(struct kbd_struct * kbd, int flag)
+{
+        kbd->modeflags &= ~(1 << flag);
+}
+
+static inline void clr_vc_kbd_led(struct kbd_struct * kbd, int flag)
+{
+        kbd->ledflagstate &= ~(1 << flag);
+}
+
+static inline void chg_vc_kbd_lock(struct kbd_struct * kbd, int flag)
+{
+        kbd->lockstate ^= 1 << flag;
+}
+
+static inline void chg_vc_kbd_slock(struct kbd_struct * kbd, int flag)
+{
+        kbd->slockstate ^= 1 << flag;
+}
+
+static inline void chg_vc_kbd_mode(struct kbd_struct * kbd, int flag)
+{
+        kbd->modeflags ^= 1 << flag;
+}
+
+static inline void chg_vc_kbd_led(struct kbd_struct * kbd, int flag)
+{
+        kbd->ledflagstate ^= 1 << flag;
+}
+
+#define U(x) ((x) ^ 0xf000)
+
+/* keyboard.c */
+
+struct console;
+
+int getkeycode(unsigned int scancode);
+int setkeycode(unsigned int scancode, unsigned int keycode);
+void compute_shiftstate(void);
+
+/* defkeymap.c */
+
+extern unsigned int keymap_count;
+
+/* console.c */
+
+static inline void con_schedule_flip(struct tty_struct *t)
+{
+        schedule_work(&t->flip.work);
+}
+
+#endif
diff --git a/include/linux/kd.h b/include/linux/kd.h
new file mode 100644
index 000000000000..28be4fbe9044
--- /dev/null
+++ b/include/linux/kd.h
@@ -0,0 +1,175 @@
+#ifndef _LINUX_KD_H
+#define _LINUX_KD_H
+#include <linux/types.h>
+#include <linux/compiler.h>
+
+/* 0x4B is 'K', to avoid collision with termios and vt */
+
+#define GIO_FONT        0x4B60  /* gets font in expanded form */
+#define PIO_FONT        0x4B61  /* use font in expanded form */
+
+#define GIO_FONTX       0x4B6B  /* get font using struct consolefontdesc */
+#define PIO_FONTX       0x4B6C  /* set font using struct consolefontdesc */
+struct consolefontdesc {
+        unsigned short charcount;       /* characters in font (256 or 512) */
+        unsigned short charheight;      /* scan lines per character (1-32) */
+        char __user *chardata;          /* font data in expanded form */
+};
+
+#define PIO_FONTRESET   0x4B6D  /* reset to default font */
+
+#define GIO_CMAP        0x4B70  /* gets colour palette on VGA+ */
+#define PIO_CMAP        0x4B71  /* sets colour palette on VGA+ */
+
+#define KIOCSOUND       0x4B2F  /* start sound generation (0 for off) */
+#define KDMKTONE        0x4B30  /* generate tone */
+
+#define KDGETLED        0x4B31  /* return current led state */
+#define KDSETLED        0x4B32  /* set led state [lights, not flags] */
+#define         LED_SCR         0x01    /* scroll lock led */
+#define         LED_NUM         0x02    /* num lock led */
+#define         LED_CAP         0x04    /* caps lock led */
+
+#define KDGKBTYPE       0x4B33  /* get keyboard type */
+#define         KB_84           0x01
+#define         KB_101          0x02    /* this is what we always answer */
+#define         KB_OTHER        0x03
+
+#define KDADDIO         0x4B34  /* add i/o port as valid */
+#define KDDELIO         0x4B35  /* del i/o port as valid */
+#define KDENABIO        0x4B36  /* enable i/o to video board */
+#define KDDISABIO       0x4B37  /* disable i/o to video board */
+
+#define KDSETMODE       0x4B3A  /* set text/graphics mode */
+#define         KD_TEXT         0x00
+#define         KD_GRAPHICS     0x01
+#define         KD_TEXT0        0x02    /* obsolete */
+#define         KD_TEXT1        0x03    /* obsolete */
+#define KDGETMODE       0x4B3B  /* get current mode */
+
+#define KDMAPDISP       0x4B3C  /* map display into address space */
+#define KDUNMAPDISP     0x4B3D  /* unmap display from address space */
+
+typedef char scrnmap_t;
+#define         E_TABSZ         256
+#define GIO_SCRNMAP     0x4B40  /* get screen mapping from kernel */
+#define PIO_SCRNMAP     0x4B41  /* put screen mapping table in kernel */
+#define GIO_UNISCRNMAP  0x4B69  /* get full Unicode screen mapping */
+#define PIO_UNISCRNMAP  0x4B6A  /* set full Unicode screen mapping */
+
+#define GIO_UNIMAP      0x4B66  /* get unicode-to-font mapping from kernel */
+struct unipair {
+        unsigned short unicode;
+        unsigned short fontpos;
+};
+struct unimapdesc {
+        unsigned short entry_ct;
+        struct unipair __user *entries;
+};
+#define PIO_UNIMAP      0x4B67  /* put unicode-to-font mapping in kernel */
+#define PIO_UNIMAPCLR   0x4B68  /* clear table, possibly advise hash algorithm */
+struct unimapinit {
+        unsigned short advised_hashsize;  /* 0 if no opinion */
+        unsigned short advised_hashstep;  /* 0 if no opinion */
+        unsigned short advised_hashlevel; /* 0 if no opinion */
+};
+
+#define UNI_DIRECT_BASE 0xF000  /* start of Direct Font Region */
+#define UNI_DIRECT_MASK 0x01FF  /* Direct Font Region bitmask */
+
+#define         K_RAW           0x00
+#define         K_XLATE         0x01
+#define         K_MEDIUMRAW     0x02
+#define         K_UNICODE       0x03
+#define KDGKBMODE       0x4B44  /* gets current keyboard mode */
+#define KDSKBMODE       0x4B45  /* sets current keyboard mode */
+
+#define         K_METABIT       0x03
+#define         K_ESCPREFIX     0x04
+#define KDGKBMETA       0x4B62  /* gets meta key handling mode */
+#define KDSKBMETA       0x4B63  /* sets meta key handling mode */
+
+#define         K_SCROLLLOCK    0x01
+#define         K_NUMLOCK       0x02
+#define         K_CAPSLOCK      0x04
+#define KDGKBLED        0x4B64  /* get led flags (not lights) */
+#define KDSKBLED        0x4B65  /* set led flags (not lights) */
+
+struct kbentry {
+        unsigned char kb_table;
+        unsigned char kb_index;
+        unsigned short kb_value;
+};
+#define         K_NORMTAB       0x00
+#define         K_SHIFTTAB      0x01
+#define         K_ALTTAB        0x02
+#define         K_ALTSHIFTTAB   0x03
+
+#define KDGKBENT        0x4B46  /* gets one entry in translation table */
+#define KDSKBENT        0x4B47  /* sets one entry in translation table */
+
+struct kbsentry {
+        unsigned char kb_func;
+        unsigned char kb_string[512];
+};
+#define KDGKBSENT       0x4B48  /* gets one function key string entry */
+#define KDSKBSENT       0x4B49  /* sets one function key string entry */
+
+struct kbdiacr {
+        unsigned char diacr, base, result;
+};
+struct kbdiacrs {
+        unsigned int kb_cnt;    /* number of entries in following array */
+        struct kbdiacr kbdiacr[256];    /* MAX_DIACR from keyboard.h */
+};
+#define KDGKBDIACR      0x4B4A  /* read kernel accent table */
+#define KDSKBDIACR      0x4B4B  /* write kernel accent table */
+
+struct kbkeycode {
+        unsigned int scancode, keycode;
+};
+#define KDGETKEYCODE    0x4B4C  /* read kernel keycode table entry */
+#define KDSETKEYCODE    0x4B4D  /* write kernel keycode table entry */
+
+#define KDSIGACCEPT     0x4B4E  /* accept kbd generated signals */
+
+struct kbd_repeat {
+        int delay;      /* in msec; <= 0: don't change */
+        int period;     /* in msec; <= 0: don't change */
+                        /* earlier this field was misnamed "rate" */
+};
+
+#define KDKBDREP        0x4B52  /* set keyboard delay/repeat rate;
+                                 * actually used values are returned */
+
+#define KDFONTOP        0x4B72  /* font operations */
+
+struct console_font_op {
+        unsigned int op;        /* operation code KD_FONT_OP_* */
+        unsigned int flags;     /* KD_FONT_FLAG_* */
+        unsigned int width, height;     /* font size */
+        unsigned int charcount;
+        unsigned char __user *data;     /* font data with height fixed to 32 */
+};
+
+struct console_font {
+        unsigned int width, height;     /* font size */
+        unsigned int charcount;
+        unsigned char *data;    /* font data with height fixed to 32 */
+};
+
+#define KD_FONT_OP_SET          0       /* Set font */
+#define KD_FONT_OP_GET          1       /* Get font */
+#define KD_FONT_OP_SET_DEFAULT  2       /* Set font to default, data points to name / NULL */
+#define KD_FONT_OP_COPY         3       /* Copy from another console */
+
+#define KD_FONT_FLAG_DONT_RECALC        1       /* Don't recalculate hw charcell size [compat] */
+#ifdef __KERNEL__
+#define KD_FONT_FLAG_OLD                0x80000000      /* Invoked via old interface [compat] */
+#endif
+
+/* note: 0x4B00-0x4B4E all have had a value at some time;
+   don't reuse for the time being */
+/* note: 0x4B60-0x4B6D, 0x4B70-0x4B72 used above */
+
+#endif /* _LINUX_KD_H */
diff --git a/include/linux/kdev_t.h b/include/linux/kdev_t.h
new file mode 100644
index 000000000000..bceea527dd37
--- /dev/null
+++ b/include/linux/kdev_t.h
@@ -0,0 +1,101 @@
+#ifndef _LINUX_KDEV_T_H
+#define _LINUX_KDEV_T_H
+#ifdef __KERNEL__
+#define MINORBITS       20
+#define MINORMASK       ((1U << MINORBITS) - 1)
+
+#define MAJOR(dev)      ((unsigned int) ((dev) >> MINORBITS))
+#define MINOR(dev)      ((unsigned int) ((dev) & MINORMASK))
+#define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))
+
+#define print_dev_t(buffer, dev)                                        \
+        sprintf((buffer), "%u:%u\n", MAJOR(dev), MINOR(dev))
+
+#define format_dev_t(buffer, dev)                                       \
+        ({                                                              \
+                sprintf(buffer, "%u:%u", MAJOR(dev), MINOR(dev));       \
+                buffer;                                                 \
+        })
+
+/* acceptable for old filesystems */
+static inline int old_valid_dev(dev_t dev)
+{
+        return MAJOR(dev) < 256 && MINOR(dev) < 256;
+}
+
+static inline u16 old_encode_dev(dev_t dev)
+{
+        return (MAJOR(dev) << 8) | MINOR(dev);
+}
+
+static inline dev_t old_decode_dev(u16 val)
+{
+        return MKDEV((val >> 8) & 255, val & 255);
+}
+
+static inline int new_valid_dev(dev_t dev)
+{
+        return 1;
+}
+
+static inline u32 new_encode_dev(dev_t dev)
+{
+        unsigned major = MAJOR(dev);
+        unsigned minor = MINOR(dev);
+        return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
+}
+
+static inline dev_t new_decode_dev(u32 dev)
+{
+        unsigned major = (dev & 0xfff00) >> 8;
+        unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
+        return MKDEV(major, minor);
+}
+
+static inline int huge_valid_dev(dev_t dev)
+{
+        return 1;
+}
+
+static inline u64 huge_encode_dev(dev_t dev)
+{
+        return new_encode_dev(dev);
+}
+
+static inline dev_t huge_decode_dev(u64 dev)
+{
+        return new_decode_dev(dev);
+}
+
+static inline int sysv_valid_dev(dev_t dev)
+{
+        return MAJOR(dev) < (1<<14) && MINOR(dev) < (1<<18);
+}
+
+static inline u32 sysv_encode_dev(dev_t dev)
+{
+        return MINOR(dev) | (MAJOR(dev) << 18);
+}
+
+static inline unsigned sysv_major(u32 dev)
+{
+        return (dev >> 18) & 0x3fff;
+}
+
+static inline unsigned sysv_minor(u32 dev)
+{
+        return dev & 0x3ffff;
+}
+
+
+#else /* __KERNEL__ */
+
+/*
+Some programs want their definitions of MAJOR and MINOR and MKDEV
+from the kernel sources. These must be the externally visible ones.
+*/
+#define MAJOR(dev)      ((dev)>>8)
+#define MINOR(dev)      ((dev) & 0xff)
+#define MKDEV(ma,mi)    ((ma)<<8 | (mi))
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
new file mode 100644
index 000000000000..7c1cba4a5278
--- /dev/null
+++ b/include/linux/kernel.h
@@ -0,0 +1,307 @@
+#ifndef _LINUX_KERNEL_H
+#define _LINUX_KERNEL_H
+
+/*
+ * 'kernel.h' contains some often-used function prototypes etc
+ */
+
+#ifdef __KERNEL__
+
+#include <stdarg.h>
+#include <linux/linkage.h>
+#include <linux/stddef.h>
+#include <linux/types.h>
+#include <linux/compiler.h>
+#include <linux/bitops.h>
+#include <asm/byteorder.h>
+#include <asm/bug.h>
+
+extern const char linux_banner[];
+
+#define INT_MAX         ((int)(~0U>>1))
+#define INT_MIN         (-INT_MAX - 1)
+#define UINT_MAX        (~0U)
+#define LONG_MAX        ((long)(~0UL>>1))
+#define LONG_MIN        (-LONG_MAX - 1)
+#define ULONG_MAX       (~0UL)
+
+#define STACK_MAGIC     0xdeadbeef
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#define ALIGN(x,a) (((x)+(a)-1)&~((a)-1))
+
+#define KERN_EMERG      "<0>"   /* system is unusable                   */
+#define KERN_ALERT      "<1>"   /* action must be taken immediately     */
+#define KERN_CRIT       "<2>"   /* critical conditions                  */
+#define KERN_ERR        "<3>"   /* error conditions                     */
+#define KERN_WARNING    "<4>"   /* warning conditions                   */
+#define KERN_NOTICE     "<5>"   /* normal but significant condition     */
+#define KERN_INFO       "<6>"   /* informational                        */
+#define KERN_DEBUG      "<7>"   /* debug-level messages                 */
+
+extern int console_printk[];
+
+#define console_loglevel (console_printk[0])
+#define default_message_loglevel (console_printk[1])
+#define minimum_console_loglevel (console_printk[2])
+#define default_console_loglevel (console_printk[3])
+
+struct completion;
+
+/**
+ * might_sleep - annotation for functions that can sleep
+ *
+ * this macro will print a stack trace if it is executed in an atomic
+ * context (spinlock, irq-handler, ...).
+ *
+ * This is a useful debugging help to be able to catch problems early and not
+ * be biten later when the calling function happens to sleep when it is not
+ * supposed to.
+ */
+#ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
+#define might_sleep() __might_sleep(__FILE__, __LINE__)
+#define might_sleep_if(cond) do { if (unlikely(cond)) might_sleep(); } while (0)
+void __might_sleep(char *file, int line);
+#else
+#define might_sleep() do {} while(0)
+#define might_sleep_if(cond) do {} while (0)
+#endif
+
+#define abs(x) ({                               \
+                int __x = (x);                  \
+                (__x < 0) ? -__x : __x;         \
+        })
+
+#define labs(x) ({                              \
+                long __x = (x);                 \
+                (__x < 0) ? -__x : __x;         \
+        })
+
+extern struct notifier_block *panic_notifier_list;
+extern long (*panic_blink)(long time);
+NORET_TYPE void panic(const char * fmt, ...)
+        __attribute__ ((NORET_AND format (printf, 1, 2)));
+fastcall NORET_TYPE void do_exit(long error_code)
+        ATTRIB_NORET;
+NORET_TYPE void complete_and_exit(struct completion *, long)
+        ATTRIB_NORET;
+extern unsigned long simple_strtoul(const char *,char **,unsigned int);
+extern long simple_strtol(const char *,char **,unsigned int);
+extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
+extern long long simple_strtoll(const char *,char **,unsigned int);
+extern int sprintf(char * buf, const char * fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int vsprintf(char *buf, const char *, va_list)
+        __attribute__ ((format (printf, 2, 0)));
+extern int snprintf(char * buf, size_t size, const char * fmt, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 3, 0)));
+extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
+        __attribute__ ((format (printf, 3, 4)));
+extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 3, 0)));
+
+extern int sscanf(const char *, const char *, ...)
+        __attribute__ ((format (scanf, 2, 3)));
+extern int vsscanf(const char *, const char *, va_list)
+        __attribute__ ((format (scanf, 2, 0)));
+
+extern int get_option(char **str, int *pint);
+extern char *get_options(const char *str, int nints, int *ints);
+extern unsigned long long memparse(char *ptr, char **retptr);
+
+extern int __kernel_text_address(unsigned long addr);
+extern int kernel_text_address(unsigned long addr);
+extern int session_of_pgrp(int pgrp);
+
+asmlinkage int vprintk(const char *fmt, va_list args)
+        __attribute__ ((format (printf, 1, 0)));
+asmlinkage int printk(const char * fmt, ...)
+        __attribute__ ((format (printf, 1, 2)));
+
+unsigned long int_sqrt(unsigned long);
+
+static inline int __attribute_pure__ long_log2(unsigned long x)
+{
+        int r = 0;
+        for (x >>= 1; x > 0; x >>= 1)
+                r++;
+        return r;
+}
+
+static inline unsigned long __attribute_const__ roundup_pow_of_two(unsigned long x)
+{
+        return (1UL << fls(x - 1));
+}
+
+extern int printk_ratelimit(void);
+extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
+
+static inline void console_silent(void)
+{
+        console_loglevel = 0;
+}
+
+static inline void console_verbose(void)
+{
+        if (console_loglevel)
+                console_loglevel = 15;
+}
+
+extern void bust_spinlocks(int yes);
+extern int oops_in_progress;            /* If set, an oops, panic(), BUG() or die() is in progress */
+extern int panic_timeout;
+extern int panic_on_oops;
+extern int tainted;
+extern const char *print_tainted(void);
+extern void add_taint(unsigned);
+
+/* Values used for system_state */
+extern enum system_states {
+        SYSTEM_BOOTING,
+        SYSTEM_RUNNING,
+        SYSTEM_HALT,
+        SYSTEM_POWER_OFF,
+        SYSTEM_RESTART,
+} system_state;
+
+#define TAINT_PROPRIETARY_MODULE        (1<<0)
+#define TAINT_FORCED_MODULE             (1<<1)
+#define TAINT_UNSAFE_SMP                (1<<2)
+#define TAINT_FORCED_RMMOD              (1<<3)
+#define TAINT_MACHINE_CHECK             (1<<4)
+#define TAINT_BAD_PAGE                  (1<<5)
+
+extern void dump_stack(void);
+
+#ifdef DEBUG
+#define pr_debug(fmt,arg...) \
+        printk(KERN_DEBUG fmt,##arg)
+#else
+#define pr_debug(fmt,arg...) \
+        do { } while (0)
+#endif
+
+#define pr_info(fmt,arg...) \
+        printk(KERN_INFO fmt,##arg)
+
+/*
+ *      Display an IP address in readable format.
+ */
+
+#define NIPQUAD(addr) \
+        ((unsigned char *)&addr)[0], \
+        ((unsigned char *)&addr)[1], \
+        ((unsigned char *)&addr)[2], \
+        ((unsigned char *)&addr)[3]
+
+#define NIP6(addr) \
+        ntohs((addr).s6_addr16[0]), \
+        ntohs((addr).s6_addr16[1]), \
+        ntohs((addr).s6_addr16[2]), \
+        ntohs((addr).s6_addr16[3]), \
+        ntohs((addr).s6_addr16[4]), \
+        ntohs((addr).s6_addr16[5]), \
+        ntohs((addr).s6_addr16[6]), \
+        ntohs((addr).s6_addr16[7])
+
+#if defined(__LITTLE_ENDIAN)
+#define HIPQUAD(addr) \
+        ((unsigned char *)&addr)[3], \
+        ((unsigned char *)&addr)[2], \
+        ((unsigned char *)&addr)[1], \
+        ((unsigned char *)&addr)[0]
+#elif defined(__BIG_ENDIAN)
+#define HIPQUAD NIPQUAD
+#else
+#error "Please fix asm/byteorder.h"
+#endif /* __LITTLE_ENDIAN */
+
+/*
+ * min()/max() macros that also do
+ * strict type-checking.. See the
+ * "unnecessary" pointer comparison.
+ */
+#define min(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);            \
+        _x < _y ? _x : _y; })
+
+#define max(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);            \
+        _x > _y ? _x : _y; })
+
+/*
+ * ..and if you can't take the strict
+ * types, you can specify one yourself.
+ *
+ * Or not use min/max at all, of course.
+ */
+#define min_t(type,x,y) \
+        ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
+#define max_t(type,x,y) \
+        ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
+
+
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ *
+ * @ptr:        the pointer to the member.
+ * @type:       the type of the container struct this is embedded in.
+ * @member:     the name of the member within the struct.
+ *
+ */
+#define container_of(ptr, type, member) ({                      \
+        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
+        (type *)( (char *)__mptr - offsetof(type,member) );})
+
+/*
+ * Check at compile time that something is of a particular type.
+ * Always evaluates to 1 so you may use it easily in comparisons.
+ */
+#define typecheck(type,x) \
+({      type __dummy; \
+        typeof(x) __dummy2; \
+        (void)(&__dummy == &__dummy2); \
+        1; \
+})
+
+#endif /* __KERNEL__ */
+
+#define SI_LOAD_SHIFT   16
+struct sysinfo {
+        long uptime;                    /* Seconds since boot */
+        unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
+        unsigned long totalram;         /* Total usable main memory size */
+        unsigned long freeram;          /* Available memory size */
+        unsigned long sharedram;        /* Amount of shared memory */
+        unsigned long bufferram;        /* Memory used by buffers */
+        unsigned long totalswap;        /* Total swap space size */
+        unsigned long freeswap;         /* swap space still available */
+        unsigned short procs;           /* Number of current processes */
+        unsigned short pad;             /* explicit padding for m68k */
+        unsigned long totalhigh;        /* Total high memory size */
+        unsigned long freehigh;         /* Available high memory size */
+        unsigned int mem_unit;          /* Memory unit size in bytes */
+        char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
+};
+
+extern void BUILD_BUG(void);
+#define BUILD_BUG_ON(condition) do { if (condition) BUILD_BUG(); } while(0)
+
+#ifdef CONFIG_SYSCTL
+extern int randomize_va_space;
+#else
+#define randomize_va_space 1
+#endif
+
+/* Trap pasters of __FUNCTION__ at compile-time */
+#if __GNUC__ > 2 || __GNUC_MINOR__ >= 95
+#define __FUNCTION__ (__func__)
+#endif
+
+#endif
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
new file mode 100644
index 000000000000..dba27749b428
--- /dev/null
+++ b/include/linux/kernel_stat.h
@@ -0,0 +1,59 @@
+#ifndef _LINUX_KERNEL_STAT_H
+#define _LINUX_KERNEL_STAT_H
+
+#include <linux/config.h>
+#include <asm/irq.h>
+#include <linux/smp.h>
+#include <linux/threads.h>
+#include <linux/percpu.h>
+#include <asm/cputime.h>
+
+/*
+ * 'kernel_stat.h' contains the definitions needed for doing
+ * some kernel statistics (CPU usage, context switches ...),
+ * used by rstatd/perfmeter
+ */
+
+struct cpu_usage_stat {
+        cputime64_t user;
+        cputime64_t nice;
+        cputime64_t system;
+        cputime64_t softirq;
+        cputime64_t irq;
+        cputime64_t idle;
+        cputime64_t iowait;
+        cputime64_t steal;
+};
+
+struct kernel_stat {
+        struct cpu_usage_stat   cpustat;
+        unsigned int irqs[NR_IRQS];
+};
+
+DECLARE_PER_CPU(struct kernel_stat, kstat);
+
+#define kstat_cpu(cpu)  per_cpu(kstat, cpu)
+/* Must have preemption disabled for this to be meaningful. */
+#define kstat_this_cpu  __get_cpu_var(kstat)
+
+extern unsigned long long nr_context_switches(void);
+
+/*
+ * Number of interrupts per specific IRQ source, since bootup
+ */
+static inline int kstat_irqs(int irq)
+{
+        int i, sum=0;
+
+        for (i = 0; i < NR_CPUS; i++)
+                if (cpu_possible(i))
+                        sum += kstat_cpu(i).irqs[irq];
+
+        return sum;
+}
+
+extern void account_user_time(struct task_struct *, cputime_t);
+extern void account_system_time(struct task_struct *, int, cputime_t);
+extern void account_steal_time(struct task_struct *, cputime_t);
+
+#endif /* _LINUX_KERNEL_STAT_H */
diff --git a/include/linux/kernelcapi.h b/include/linux/kernelcapi.h
new file mode 100644
index 000000000000..891bb2cf0aa8
--- /dev/null
+++ b/include/linux/kernelcapi.h
@@ -0,0 +1,161 @@
+/*
+ * $Id: kernelcapi.h,v 1.8.6.2 2001/02/07 11:31:31 kai Exp $
+ * 
+ * Kernel CAPI 2.0 Interface for Linux
+ * 
+ * (c) Copyright 1997 by Carsten Paeth (calle@calle.in-berlin.de)
+ * 
+ */
+
+#ifndef __KERNELCAPI_H__
+#define __KERNELCAPI_H__
+
+#define CAPI_MAXAPPL    240     /* maximum number of applications  */
+#define CAPI_MAXCONTR   32      /* maximum number of controller    */
+#define CAPI_MAXDATAWINDOW      8
+
+
+typedef struct kcapi_flagdef {
+        int contr;
+        int flag;
+} kcapi_flagdef;
+
+typedef struct kcapi_carddef {
+        char            driver[32];
+        unsigned int    port;
+        unsigned        irq;
+        unsigned int    membase;
+        int             cardnr;
+} kcapi_carddef;
+
+/* new ioctls >= 10 */
+#define KCAPI_CMD_TRACE         10
+#define KCAPI_CMD_ADDCARD       11      /* OBSOLETE */
+
+/* 
+ * flag > 2 => trace also data
+ * flag & 1 => show trace
+ */
+#define KCAPI_TRACE_OFF                 0
+#define KCAPI_TRACE_SHORT_NO_DATA       1
+#define KCAPI_TRACE_FULL_NO_DATA        2
+#define KCAPI_TRACE_SHORT               3
+#define KCAPI_TRACE_FULL                4
+
+
+#ifdef __KERNEL__
+
+#include <linux/list.h>
+#include <linux/skbuff.h>
+
+#define KCI_CONTRUP     0       /* arg: struct capi_profile */
+#define KCI_CONTRDOWN   1       /* arg: NULL */
+
+struct capi20_appl {
+        u16 applid;
+        capi_register_params rparam;
+        void (*recv_message)(struct capi20_appl *ap, struct sk_buff *skb);
+        void *private;
+
+        /* internal to kernelcapi.o */
+        unsigned long nrecvctlpkt;
+        unsigned long nrecvdatapkt;
+        unsigned long nsentctlpkt;
+        unsigned long nsentdatapkt;
+        struct semaphore recv_sem;
+        struct sk_buff_head recv_queue;
+        struct work_struct recv_work;
+        int release_in_progress;
+
+        /* ugly hack to allow for notification of added/removed
+         * controllers. The Right Way (tm) is known. XXX
+         */
+        void (*callback) (unsigned int cmd, __u32 contr, void *data);
+};
+
+u16 capi20_isinstalled(void);
+u16 capi20_register(struct capi20_appl *ap);
+u16 capi20_release(struct capi20_appl *ap);
+u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb);
+u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN]);
+u16 capi20_get_version(u32 contr, struct capi_version *verp);
+u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN]);
+u16 capi20_get_profile(u32 contr, struct capi_profile *profp);
+int capi20_manufacturer(unsigned int cmd, void __user *data);
+
+/* temporary hack XXX */
+void capi20_set_callback(struct capi20_appl *ap, 
+                         void (*callback) (unsigned int cmd, __u32 contr, void *data));
+
+
+
+#define CAPI_NOERROR                      0x0000
+
+#define CAPI_TOOMANYAPPLS                 0x1001
+#define CAPI_LOGBLKSIZETOSMALL            0x1002
+#define CAPI_BUFFEXECEEDS64K              0x1003
+#define CAPI_MSGBUFSIZETOOSMALL           0x1004
+#define CAPI_ANZLOGCONNNOTSUPPORTED       0x1005
+#define CAPI_REGRESERVED                  0x1006
+#define CAPI_REGBUSY                      0x1007
+#define CAPI_REGOSRESOURCEERR             0x1008
+#define CAPI_REGNOTINSTALLED              0x1009
+#define CAPI_REGCTRLERNOTSUPPORTEXTEQUIP  0x100a
+#define CAPI_REGCTRLERONLYSUPPORTEXTEQUIP 0x100b
+
+#define CAPI_ILLAPPNR                     0x1101
+#define CAPI_ILLCMDORSUBCMDORMSGTOSMALL   0x1102
+#define CAPI_SENDQUEUEFULL                0x1103
+#define CAPI_RECEIVEQUEUEEMPTY            0x1104
+#define CAPI_RECEIVEOVERFLOW              0x1105
+#define CAPI_UNKNOWNNOTPAR                0x1106
+#define CAPI_MSGBUSY                      0x1107
+#define CAPI_MSGOSRESOURCEERR             0x1108
+#define CAPI_MSGNOTINSTALLED              0x1109
+#define CAPI_MSGCTRLERNOTSUPPORTEXTEQUIP  0x110a
+#define CAPI_MSGCTRLERONLYSUPPORTEXTEQUIP 0x110b
+
+typedef enum {
+        CapiMessageNotSupportedInCurrentState = 0x2001,
+        CapiIllContrPlciNcci                  = 0x2002,
+        CapiNoPlciAvailable                   = 0x2003,
+        CapiNoNcciAvailable                   = 0x2004,
+        CapiNoListenResourcesAvailable        = 0x2005,
+        CapiNoFaxResourcesAvailable           = 0x2006,
+        CapiIllMessageParmCoding              = 0x2007,
+} RESOURCE_CODING_PROBLEM;
+
+typedef enum {
+        CapiB1ProtocolNotSupported                      = 0x3001,
+        CapiB2ProtocolNotSupported                      = 0x3002,
+        CapiB3ProtocolNotSupported                      = 0x3003,
+        CapiB1ProtocolParameterNotSupported             = 0x3004,
+        CapiB2ProtocolParameterNotSupported             = 0x3005,
+        CapiB3ProtocolParameterNotSupported             = 0x3006,
+        CapiBProtocolCombinationNotSupported            = 0x3007,
+        CapiNcpiNotSupported                            = 0x3008,
+        CapiCipValueUnknown                             = 0x3009,
+        CapiFlagsNotSupported                           = 0x300a,
+        CapiFacilityNotSupported                        = 0x300b,
+        CapiDataLengthNotSupportedByCurrentProtocol     = 0x300c,
+        CapiResetProcedureNotSupportedByCurrentProtocol = 0x300d,
+        CapiTeiAssignmentFailed                         = 0x300e,
+} REQUESTED_SERVICES_PROBLEM;
+
+typedef enum {
+        CapiSuccess                                     = 0x0000,
+        CapiSupplementaryServiceNotSupported            = 0x300e,
+        CapiRequestNotAllowedInThisState                = 0x3010,
+} SUPPLEMENTARY_SERVICE_INFO;
+
+typedef enum {
+        CapiProtocolErrorLayer1                         = 0x3301,
+        CapiProtocolErrorLayer2                         = 0x3302,
+        CapiProtocolErrorLayer3                         = 0x3303,
+        CapiTimeOut                                     = 0x3303, // SuppServiceReason
+        CapiCallGivenToOtherApplication                 = 0x3304,
+} CAPI_REASON;
+
+#endif                          /* __KERNEL__ */
+
+#endif                          /* __KERNELCAPI_H__ */
diff --git a/include/linux/key-ui.h b/include/linux/key-ui.h
new file mode 100644
index 000000000000..60cc7b762e78
--- /dev/null
+++ b/include/linux/key-ui.h
@@ -0,0 +1,97 @@
+/* key-ui.h: key userspace interface stuff for use by keyfs
+ *
+ * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_KEY_UI_H
+#define _LINUX_KEY_UI_H
+
+#include <linux/key.h>
+
+/* the key tree */
+extern struct rb_root key_serial_tree;
+extern spinlock_t key_serial_lock;
+
+/* required permissions */
+#define KEY_VIEW        0x01    /* require permission to view attributes */
+#define KEY_READ        0x02    /* require permission to read content */
+#define KEY_WRITE       0x04    /* require permission to update / modify */
+#define KEY_SEARCH      0x08    /* require permission to search (keyring) or find (key) */
+#define KEY_LINK        0x10    /* require permission to link */
+#define KEY_ALL         0x1f    /* all the above permissions */
+
+/*
+ * the keyring payload contains a list of the keys to which the keyring is
+ * subscribed
+ */
+struct keyring_list {
+        unsigned        maxkeys;        /* max keys this list can hold */
+        unsigned        nkeys;          /* number of keys currently held */
+        struct key      *keys[0];
+};
+
+
+/*
+ * check to see whether permission is granted to use a key in the desired way
+ */
+static inline int key_permission(const struct key *key, key_perm_t perm)
+{
+        key_perm_t kperm;
+
+        if (key->uid == current->fsuid)
+                kperm = key->perm >> 16;
+        else if (key->gid != -1 &&
+                 key->perm & KEY_GRP_ALL &&
+                 in_group_p(key->gid)
+                 )
+                kperm = key->perm >> 8;
+        else
+                kperm = key->perm;
+
+        kperm = kperm & perm & KEY_ALL;
+
+        return kperm == perm;
+}
+
+/*
+ * check to see whether permission is granted to use a key in at least one of
+ * the desired ways
+ */
+static inline int key_any_permission(const struct key *key, key_perm_t perm)
+{
+        key_perm_t kperm;
+
+        if (key->uid == current->fsuid)
+                kperm = key->perm >> 16;
+        else if (key->gid != -1 &&
+                 key->perm & KEY_GRP_ALL &&
+                 in_group_p(key->gid)
+                 )
+                kperm = key->perm >> 8;
+        else
+                kperm = key->perm;
+
+        kperm = kperm & perm & KEY_ALL;
+
+        return kperm != 0;
+}
+
+
+extern struct key *lookup_user_key(key_serial_t id, int create, int part,
+                                   key_perm_t perm);
+
+extern long join_session_keyring(const char *name);
+
+extern struct key_type *key_type_lookup(const char *type);
+extern void key_type_put(struct key_type *ktype);
+
+#define key_negative_timeout    60      /* default timeout on a negative key's existence */
+
+
+#endif /* _LINUX_KEY_UI_H */
diff --git a/include/linux/key.h b/include/linux/key.h
new file mode 100644
index 000000000000..6aa46d0e812f
--- /dev/null
+++ b/include/linux/key.h
@@ -0,0 +1,291 @@
+/* key.h: authentication token and access key management
+ *
+ * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *
+ * See Documentation/keys.txt for information on keys/keyrings.
+ */
+
+#ifndef _LINUX_KEY_H
+#define _LINUX_KEY_H
+
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <linux/spinlock.h>
+#include <asm/atomic.h>
+
+#ifdef __KERNEL__
+
+/* key handle serial number */
+typedef int32_t key_serial_t;
+
+/* key handle permissions mask */
+typedef uint32_t key_perm_t;
+
+struct key;
+
+#ifdef CONFIG_KEYS
+
+#undef KEY_DEBUGGING
+
+#define KEY_USR_VIEW    0x00010000      /* user can view a key's attributes */
+#define KEY_USR_READ    0x00020000      /* user can read key payload / view keyring */
+#define KEY_USR_WRITE   0x00040000      /* user can update key payload / add link to keyring */
+#define KEY_USR_SEARCH  0x00080000      /* user can find a key in search / search a keyring */
+#define KEY_USR_LINK    0x00100000      /* user can create a link to a key/keyring */
+#define KEY_USR_ALL     0x001f0000
+
+#define KEY_GRP_VIEW    0x00000100      /* group permissions... */
+#define KEY_GRP_READ    0x00000200
+#define KEY_GRP_WRITE   0x00000400
+#define KEY_GRP_SEARCH  0x00000800
+#define KEY_GRP_LINK    0x00001000
+#define KEY_GRP_ALL     0x00001f00
+
+#define KEY_OTH_VIEW    0x00000001      /* third party permissions... */
+#define KEY_OTH_READ    0x00000002
+#define KEY_OTH_WRITE   0x00000004
+#define KEY_OTH_SEARCH  0x00000008
+#define KEY_OTH_LINK    0x00000010
+#define KEY_OTH_ALL     0x0000001f
+
+struct seq_file;
+struct user_struct;
+struct signal_struct;
+
+struct key_type;
+struct key_owner;
+struct keyring_list;
+struct keyring_name;
+
+/*****************************************************************************/
+/*
+ * authentication token / access credential / keyring
+ * - types of key include:
+ *   - keyrings
+ *   - disk encryption IDs
+ *   - Kerberos TGTs and tickets
+ */
+struct key {
+        atomic_t                usage;          /* number of references */
+        key_serial_t            serial;         /* key serial number */
+        struct rb_node          serial_node;
+        struct key_type         *type;          /* type of key */
+        rwlock_t                lock;           /* examination vs change lock */
+        struct rw_semaphore     sem;            /* change vs change sem */
+        struct key_user         *user;          /* owner of this key */
+        time_t                  expiry;         /* time at which key expires (or 0) */
+        uid_t                   uid;
+        gid_t                   gid;
+        key_perm_t              perm;           /* access permissions */
+        unsigned short          quotalen;       /* length added to quota */
+        unsigned short          datalen;        /* payload data length */
+        unsigned short          flags;          /* status flags (change with lock writelocked) */
+#define KEY_FLAG_INSTANTIATED   0x00000001      /* set if key has been instantiated */
+#define KEY_FLAG_DEAD           0x00000002      /* set if key type has been deleted */
+#define KEY_FLAG_REVOKED        0x00000004      /* set if key had been revoked */
+#define KEY_FLAG_IN_QUOTA       0x00000008      /* set if key consumes quota */
+#define KEY_FLAG_USER_CONSTRUCT 0x00000010      /* set if key is being constructed in userspace */
+#define KEY_FLAG_NEGATIVE       0x00000020      /* set if key is negative */
+
+#ifdef KEY_DEBUGGING
+        unsigned                magic;
+#define KEY_DEBUG_MAGIC         0x18273645u
+#define KEY_DEBUG_MAGIC_X       0xf8e9dacbu
+#endif
+
+        /* the description string
+         * - this is used to match a key against search criteria
+         * - this should be a printable string
+         * - eg: for krb5 AFS, this might be "afs@REDHAT.COM"
+         */
+        char                    *description;
+
+        /* type specific data
+         * - this is used by the keyring type to index the name
+         */
+        union {
+                struct list_head        link;
+        } type_data;
+
+        /* key data
+         * - this is used to hold the data actually used in cryptography or
+         *   whatever
+         */
+        union {
+                unsigned long           value;
+                void                    *data;
+                struct keyring_list     *subscriptions;
+        } payload;
+};
+
+/*****************************************************************************/
+/*
+ * kernel managed key type definition
+ */
+struct key_type {
+        /* name of the type */
+        const char *name;
+
+        /* default payload length for quota precalculation (optional)
+         * - this can be used instead of calling key_payload_reserve(), that
+         *   function only needs to be called if the real datalen is different
+         */
+        size_t def_datalen;
+
+        /* instantiate a key of this type
+         * - this method should call key_payload_reserve() to determine if the
+         *   user's quota will hold the payload
+         */
+        int (*instantiate)(struct key *key, const void *data, size_t datalen);
+
+        /* duplicate a key of this type (optional)
+         * - the source key will be locked against change
+         * - the new description will be attached
+         * - the quota will have been adjusted automatically from
+         *   source->quotalen
+         */
+        int (*duplicate)(struct key *key, const struct key *source);
+
+        /* update a key of this type (optional)
+         * - this method should call key_payload_reserve() to recalculate the
+         *   quota consumption
+         * - the key must be locked against read when modifying
+         */
+        int (*update)(struct key *key, const void *data, size_t datalen);
+
+        /* match a key against a description */
+        int (*match)(const struct key *key, const void *desc);
+
+        /* clear the data from a key (optional) */
+        void (*destroy)(struct key *key);
+
+        /* describe a key */
+        void (*describe)(const struct key *key, struct seq_file *p);
+
+        /* read a key's data (optional)
+         * - permission checks will be done by the caller
+         * - the key's semaphore will be readlocked by the caller
+         * - should return the amount of data that could be read, no matter how
+         *   much is copied into the buffer
+         * - shouldn't do the copy if the buffer is NULL
+         */
+        long (*read)(const struct key *key, char __user *buffer, size_t buflen);
+
+        /* internal fields */
+        struct list_head        link;           /* link in types list */
+};
+
+extern struct key_type key_type_keyring;
+
+extern int register_key_type(struct key_type *ktype);
+extern void unregister_key_type(struct key_type *ktype);
+
+extern struct key *key_alloc(struct key_type *type,
+                             const char *desc,
+                             uid_t uid, gid_t gid, key_perm_t perm,
+                             int not_in_quota);
+extern int key_payload_reserve(struct key *key, size_t datalen);
+extern int key_instantiate_and_link(struct key *key,
+                                    const void *data,
+                                    size_t datalen,
+                                    struct key *keyring);
+extern int key_negate_and_link(struct key *key,
+                               unsigned timeout,
+                               struct key *keyring);
+extern void key_revoke(struct key *key);
+extern void key_put(struct key *key);
+
+static inline struct key *key_get(struct key *key)
+{
+        if (key)
+                atomic_inc(&key->usage);
+        return key;
+}
+
+extern struct key *request_key(struct key_type *type,
+                               const char *description,
+                               const char *callout_info);
+
+extern int key_validate(struct key *key);
+
+extern struct key *key_create_or_update(struct key *keyring,
+                                        const char *type,
+                                        const char *description,
+                                        const void *payload,
+                                        size_t plen,
+                                        int not_in_quota);
+
+extern int key_update(struct key *key,
+                      const void *payload,
+                      size_t plen);
+
+extern int key_link(struct key *keyring,
+                    struct key *key);
+
+extern int key_unlink(struct key *keyring,
+                      struct key *key);
+
+extern struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
+                                 int not_in_quota, struct key *dest);
+
+extern int keyring_clear(struct key *keyring);
+
+extern struct key *keyring_search(struct key *keyring,
+                                  struct key_type *type,
+                                  const char *description);
+
+extern struct key *search_process_keyrings(struct key_type *type,
+                                           const char *description);
+
+extern int keyring_add_key(struct key *keyring,
+                           struct key *key);
+
+extern struct key *key_lookup(key_serial_t id);
+
+#define key_serial(key) ((key) ? (key)->serial : 0)
+
+/*
+ * the userspace interface
+ */
+extern struct key root_user_keyring, root_session_keyring;
+extern int alloc_uid_keyring(struct user_struct *user);
+extern void switch_uid_keyring(struct user_struct *new_user);
+extern int copy_keys(unsigned long clone_flags, struct task_struct *tsk);
+extern int copy_thread_group_keys(struct task_struct *tsk);
+extern void exit_keys(struct task_struct *tsk);
+extern void exit_thread_group_keys(struct signal_struct *tg);
+extern int suid_keys(struct task_struct *tsk);
+extern int exec_keys(struct task_struct *tsk);
+extern void key_fsuid_changed(struct task_struct *tsk);
+extern void key_fsgid_changed(struct task_struct *tsk);
+extern void key_init(void);
+
+#else /* CONFIG_KEYS */
+
+#define key_validate(k)                 0
+#define key_serial(k)                   0
+#define key_get(k)                      NULL
+#define key_put(k)                      do { } while(0)
+#define alloc_uid_keyring(u)            0
+#define switch_uid_keyring(u)           do { } while(0)
+#define copy_keys(f,t)                  0
+#define copy_thread_group_keys(t)       0
+#define exit_keys(t)                    do { } while(0)
+#define exit_thread_group_keys(tg)      do { } while(0)
+#define suid_keys(t)                    do { } while(0)
+#define exec_keys(t)                    do { } while(0)
+#define key_fsuid_changed(t)            do { } while(0)
+#define key_fsgid_changed(t)            do { } while(0)
+#define key_init()                      do { } while(0)
+
+#endif /* CONFIG_KEYS */
+#endif /* __KERNEL__ */
+#endif /* _LINUX_KEY_H */
diff --git a/include/linux/keyboard.h b/include/linux/keyboard.h
new file mode 100644
index 000000000000..08488042d74a
--- /dev/null
+++ b/include/linux/keyboard.h
@@ -0,0 +1,431 @@
+#ifndef __LINUX_KEYBOARD_H
+#define __LINUX_KEYBOARD_H
+
+#include <linux/wait.h>
+
+#define KG_SHIFT        0
+#define KG_CTRL         2
+#define KG_ALT          3
+#define KG_ALTGR        1
+#define KG_SHIFTL       4
+#define KG_KANASHIFT    4
+#define KG_SHIFTR       5
+#define KG_CTRLL        6
+#define KG_CTRLR        7
+#define KG_CAPSSHIFT    8
+
+#define NR_SHIFT        9
+
+#define NR_KEYS         256
+#define MAX_NR_KEYMAPS  256
+/* This means 128Kb if all keymaps are allocated. Only the superuser
+        may increase the number of keymaps beyond MAX_NR_OF_USER_KEYMAPS. */
+#define MAX_NR_OF_USER_KEYMAPS 256      /* should be at least 7 */
+
+#ifdef __KERNEL__
+extern const int NR_TYPES;
+extern const int max_vals[];
+extern unsigned short *key_maps[MAX_NR_KEYMAPS];
+extern unsigned short plain_map[NR_KEYS];
+#endif
+
+#define MAX_NR_FUNC     256     /* max nr of strings assigned to keys */
+
+#define KT_LATIN        0       /* we depend on this being zero */
+#define KT_LETTER       11      /* symbol that can be acted upon by CapsLock */
+#define KT_FN           1
+#define KT_SPEC         2
+#define KT_PAD          3
+#define KT_DEAD         4
+#define KT_CONS         5
+#define KT_CUR          6
+#define KT_SHIFT        7
+#define KT_META         8
+#define KT_ASCII        9
+#define KT_LOCK         10
+#define KT_SLOCK        12
+
+#define K(t,v)          (((t)<<8)|(v))
+#define KTYP(x)         ((x) >> 8)
+#define KVAL(x)         ((x) & 0xff)
+
+#define K_F1            K(KT_FN,0)
+#define K_F2            K(KT_FN,1)
+#define K_F3            K(KT_FN,2)
+#define K_F4            K(KT_FN,3)
+#define K_F5            K(KT_FN,4)
+#define K_F6            K(KT_FN,5)
+#define K_F7            K(KT_FN,6)
+#define K_F8            K(KT_FN,7)
+#define K_F9            K(KT_FN,8)
+#define K_F10           K(KT_FN,9)
+#define K_F11           K(KT_FN,10)
+#define K_F12           K(KT_FN,11)
+#define K_F13           K(KT_FN,12)
+#define K_F14           K(KT_FN,13)
+#define K_F15           K(KT_FN,14)
+#define K_F16           K(KT_FN,15)
+#define K_F17           K(KT_FN,16)
+#define K_F18           K(KT_FN,17)
+#define K_F19           K(KT_FN,18)
+#define K_F20           K(KT_FN,19)
+#define K_FIND          K(KT_FN,20)
+#define K_INSERT        K(KT_FN,21)
+#define K_REMOVE        K(KT_FN,22)
+#define K_SELECT        K(KT_FN,23)
+#define K_PGUP          K(KT_FN,24) /* PGUP is a synonym for PRIOR */
+#define K_PGDN          K(KT_FN,25) /* PGDN is a synonym for NEXT */
+#define K_MACRO         K(KT_FN,26)
+#define K_HELP          K(KT_FN,27)
+#define K_DO            K(KT_FN,28)
+#define K_PAUSE         K(KT_FN,29)
+#define K_F21           K(KT_FN,30)
+#define K_F22           K(KT_FN,31)
+#define K_F23           K(KT_FN,32)
+#define K_F24           K(KT_FN,33)
+#define K_F25           K(KT_FN,34)
+#define K_F26           K(KT_FN,35)
+#define K_F27           K(KT_FN,36)
+#define K_F28           K(KT_FN,37)
+#define K_F29           K(KT_FN,38)
+#define K_F30           K(KT_FN,39)
+#define K_F31           K(KT_FN,40)
+#define K_F32           K(KT_FN,41)
+#define K_F33           K(KT_FN,42)
+#define K_F34           K(KT_FN,43)
+#define K_F35           K(KT_FN,44)
+#define K_F36           K(KT_FN,45)
+#define K_F37           K(KT_FN,46)
+#define K_F38           K(KT_FN,47)
+#define K_F39           K(KT_FN,48)
+#define K_F40           K(KT_FN,49)
+#define K_F41           K(KT_FN,50)
+#define K_F42           K(KT_FN,51)
+#define K_F43           K(KT_FN,52)
+#define K_F44           K(KT_FN,53)
+#define K_F45           K(KT_FN,54)
+#define K_F46           K(KT_FN,55)
+#define K_F47           K(KT_FN,56)
+#define K_F48           K(KT_FN,57)
+#define K_F49           K(KT_FN,58)
+#define K_F50           K(KT_FN,59)
+#define K_F51           K(KT_FN,60)
+#define K_F52           K(KT_FN,61)
+#define K_F53           K(KT_FN,62)
+#define K_F54           K(KT_FN,63)
+#define K_F55           K(KT_FN,64)
+#define K_F56           K(KT_FN,65)
+#define K_F57           K(KT_FN,66)
+#define K_F58           K(KT_FN,67)
+#define K_F59           K(KT_FN,68)
+#define K_F60           K(KT_FN,69)
+#define K_F61           K(KT_FN,70)
+#define K_F62           K(KT_FN,71)
+#define K_F63           K(KT_FN,72)
+#define K_F64           K(KT_FN,73)
+#define K_F65           K(KT_FN,74)
+#define K_F66           K(KT_FN,75)
+#define K_F67           K(KT_FN,76)
+#define K_F68           K(KT_FN,77)
+#define K_F69           K(KT_FN,78)
+#define K_F70           K(KT_FN,79)
+#define K_F71           K(KT_FN,80)
+#define K_F72           K(KT_FN,81)
+#define K_F73           K(KT_FN,82)
+#define K_F74           K(KT_FN,83)
+#define K_F75           K(KT_FN,84)
+#define K_F76           K(KT_FN,85)
+#define K_F77           K(KT_FN,86)
+#define K_F78           K(KT_FN,87)
+#define K_F79           K(KT_FN,88)
+#define K_F80           K(KT_FN,89)
+#define K_F81           K(KT_FN,90)
+#define K_F82           K(KT_FN,91)
+#define K_F83           K(KT_FN,92)
+#define K_F84           K(KT_FN,93)
+#define K_F85           K(KT_FN,94)
+#define K_F86           K(KT_FN,95)
+#define K_F87           K(KT_FN,96)
+#define K_F88           K(KT_FN,97)
+#define K_F89           K(KT_FN,98)
+#define K_F90           K(KT_FN,99)
+#define K_F91           K(KT_FN,100)
+#define K_F92           K(KT_FN,101)
+#define K_F93           K(KT_FN,102)
+#define K_F94           K(KT_FN,103)
+#define K_F95           K(KT_FN,104)
+#define K_F96           K(KT_FN,105)
+#define K_F97           K(KT_FN,106)
+#define K_F98           K(KT_FN,107)
+#define K_F99           K(KT_FN,108)
+#define K_F100          K(KT_FN,109)
+#define K_F101          K(KT_FN,110)
+#define K_F102          K(KT_FN,111)
+#define K_F103          K(KT_FN,112)
+#define K_F104          K(KT_FN,113)
+#define K_F105          K(KT_FN,114)
+#define K_F106          K(KT_FN,115)
+#define K_F107          K(KT_FN,116)
+#define K_F108          K(KT_FN,117)
+#define K_F109          K(KT_FN,118)
+#define K_F110          K(KT_FN,119)
+#define K_F111          K(KT_FN,120)
+#define K_F112          K(KT_FN,121)
+#define K_F113          K(KT_FN,122)
+#define K_F114          K(KT_FN,123)
+#define K_F115          K(KT_FN,124)
+#define K_F116          K(KT_FN,125)
+#define K_F117          K(KT_FN,126)
+#define K_F118          K(KT_FN,127)
+#define K_F119          K(KT_FN,128)
+#define K_F120          K(KT_FN,129)
+#define K_F121          K(KT_FN,130)
+#define K_F122          K(KT_FN,131)
+#define K_F123          K(KT_FN,132)
+#define K_F124          K(KT_FN,133)
+#define K_F125          K(KT_FN,134)
+#define K_F126          K(KT_FN,135)
+#define K_F127          K(KT_FN,136)
+#define K_F128          K(KT_FN,137)
+#define K_F129          K(KT_FN,138)
+#define K_F130          K(KT_FN,139)
+#define K_F131          K(KT_FN,140)
+#define K_F132          K(KT_FN,141)
+#define K_F133          K(KT_FN,142)
+#define K_F134          K(KT_FN,143)
+#define K_F135          K(KT_FN,144)
+#define K_F136          K(KT_FN,145)
+#define K_F137          K(KT_FN,146)
+#define K_F138          K(KT_FN,147)
+#define K_F139          K(KT_FN,148)
+#define K_F140          K(KT_FN,149)
+#define K_F141          K(KT_FN,150)
+#define K_F142          K(KT_FN,151)
+#define K_F143          K(KT_FN,152)
+#define K_F144          K(KT_FN,153)
+#define K_F145          K(KT_FN,154)
+#define K_F146          K(KT_FN,155)
+#define K_F147          K(KT_FN,156)
+#define K_F148          K(KT_FN,157)
+#define K_F149          K(KT_FN,158)
+#define K_F150          K(KT_FN,159)
+#define K_F151          K(KT_FN,160)
+#define K_F152          K(KT_FN,161)
+#define K_F153          K(KT_FN,162)
+#define K_F154          K(KT_FN,163)
+#define K_F155          K(KT_FN,164)
+#define K_F156          K(KT_FN,165)
+#define K_F157          K(KT_FN,166)
+#define K_F158          K(KT_FN,167)
+#define K_F159          K(KT_FN,168)
+#define K_F160          K(KT_FN,169)
+#define K_F161          K(KT_FN,170)
+#define K_F162          K(KT_FN,171)
+#define K_F163          K(KT_FN,172)
+#define K_F164          K(KT_FN,173)
+#define K_F165          K(KT_FN,174)
+#define K_F166          K(KT_FN,175)
+#define K_F167          K(KT_FN,176)
+#define K_F168          K(KT_FN,177)
+#define K_F169          K(KT_FN,178)
+#define K_F170          K(KT_FN,179)
+#define K_F171          K(KT_FN,180)
+#define K_F172          K(KT_FN,181)
+#define K_F173          K(KT_FN,182)
+#define K_F174          K(KT_FN,183)
+#define K_F175          K(KT_FN,184)
+#define K_F176          K(KT_FN,185)
+#define K_F177          K(KT_FN,186)
+#define K_F178          K(KT_FN,187)
+#define K_F179          K(KT_FN,188)
+#define K_F180          K(KT_FN,189)
+#define K_F181          K(KT_FN,190)
+#define K_F182          K(KT_FN,191)
+#define K_F183          K(KT_FN,192)
+#define K_F184          K(KT_FN,193)
+#define K_F185          K(KT_FN,194)
+#define K_F186          K(KT_FN,195)
+#define K_F187          K(KT_FN,196)
+#define K_F188          K(KT_FN,197)
+#define K_F189          K(KT_FN,198)
+#define K_F190          K(KT_FN,199)
+#define K_F191          K(KT_FN,200)
+#define K_F192          K(KT_FN,201)
+#define K_F193          K(KT_FN,202)
+#define K_F194          K(KT_FN,203)
+#define K_F195          K(KT_FN,204)
+#define K_F196          K(KT_FN,205)
+#define K_F197          K(KT_FN,206)
+#define K_F198          K(KT_FN,207)
+#define K_F199          K(KT_FN,208)
+#define K_F200          K(KT_FN,209)
+#define K_F201          K(KT_FN,210)
+#define K_F202          K(KT_FN,211)
+#define K_F203          K(KT_FN,212)
+#define K_F204          K(KT_FN,213)
+#define K_F205          K(KT_FN,214)
+#define K_F206          K(KT_FN,215)
+#define K_F207          K(KT_FN,216)
+#define K_F208          K(KT_FN,217)
+#define K_F209          K(KT_FN,218)
+#define K_F210          K(KT_FN,219)
+#define K_F211          K(KT_FN,220)
+#define K_F212          K(KT_FN,221)
+#define K_F213          K(KT_FN,222)
+#define K_F214          K(KT_FN,223)
+#define K_F215          K(KT_FN,224)
+#define K_F216          K(KT_FN,225)
+#define K_F217          K(KT_FN,226)
+#define K_F218          K(KT_FN,227)
+#define K_F219          K(KT_FN,228)
+#define K_F220          K(KT_FN,229)
+#define K_F221          K(KT_FN,230)
+#define K_F222          K(KT_FN,231)
+#define K_F223          K(KT_FN,232)
+#define K_F224          K(KT_FN,233)
+#define K_F225          K(KT_FN,234)
+#define K_F226          K(KT_FN,235)
+#define K_F227          K(KT_FN,236)
+#define K_F228          K(KT_FN,237)
+#define K_F229          K(KT_FN,238)
+#define K_F230          K(KT_FN,239)
+#define K_F231          K(KT_FN,240)
+#define K_F232          K(KT_FN,241)
+#define K_F233          K(KT_FN,242)
+#define K_F234          K(KT_FN,243)
+#define K_F235          K(KT_FN,244)
+#define K_F236          K(KT_FN,245)
+#define K_F237          K(KT_FN,246)
+#define K_F238          K(KT_FN,247)
+#define K_F239          K(KT_FN,248)
+#define K_F240          K(KT_FN,249)
+#define K_F241          K(KT_FN,250)
+#define K_F242          K(KT_FN,251)
+#define K_F243          K(KT_FN,252)
+#define K_F244          K(KT_FN,253)
+#define K_F245          K(KT_FN,254)
+#define K_UNDO          K(KT_FN,255)
+
+
+#define K_HOLE          K(KT_SPEC,0)
+#define K_ENTER         K(KT_SPEC,1)
+#define K_SH_REGS       K(KT_SPEC,2)
+#define K_SH_MEM        K(KT_SPEC,3)
+#define K_SH_STAT       K(KT_SPEC,4)
+#define K_BREAK         K(KT_SPEC,5)
+#define K_CONS          K(KT_SPEC,6)
+#define K_CAPS          K(KT_SPEC,7)
+#define K_NUM           K(KT_SPEC,8)
+#define K_HOLD          K(KT_SPEC,9)
+#define K_SCROLLFORW    K(KT_SPEC,10)
+#define K_SCROLLBACK    K(KT_SPEC,11)
+#define K_BOOT          K(KT_SPEC,12)
+#define K_CAPSON        K(KT_SPEC,13)
+#define K_COMPOSE       K(KT_SPEC,14)
+#define K_SAK           K(KT_SPEC,15)
+#define K_DECRCONSOLE   K(KT_SPEC,16)
+#define K_INCRCONSOLE   K(KT_SPEC,17)
+#define K_SPAWNCONSOLE  K(KT_SPEC,18)
+#define K_BARENUMLOCK   K(KT_SPEC,19)
+
+#define K_ALLOCATED     K(KT_SPEC,126) /* dynamically allocated keymap */
+#define K_NOSUCHMAP     K(KT_SPEC,127) /* returned by KDGKBENT */
+
+#define K_P0            K(KT_PAD,0)
+#define K_P1            K(KT_PAD,1)
+#define K_P2            K(KT_PAD,2)
+#define K_P3            K(KT_PAD,3)
+#define K_P4            K(KT_PAD,4)
+#define K_P5            K(KT_PAD,5)
+#define K_P6            K(KT_PAD,6)
+#define K_P7            K(KT_PAD,7)
+#define K_P8            K(KT_PAD,8)
+#define K_P9            K(KT_PAD,9)
+#define K_PPLUS         K(KT_PAD,10)    /* key-pad plus */
+#define K_PMINUS        K(KT_PAD,11)    /* key-pad minus */
+#define K_PSTAR         K(KT_PAD,12)    /* key-pad asterisk (star) */
+#define K_PSLASH        K(KT_PAD,13)    /* key-pad slash */
+#define K_PENTER        K(KT_PAD,14)    /* key-pad enter */
+#define K_PCOMMA        K(KT_PAD,15)    /* key-pad comma: kludge... */
+#define K_PDOT          K(KT_PAD,16)    /* key-pad dot (period): kludge... */
+#define K_PPLUSMINUS    K(KT_PAD,17)    /* key-pad plus/minus */
+#define K_PPARENL       K(KT_PAD,18)    /* key-pad left parenthesis */
+#define K_PPARENR       K(KT_PAD,19)    /* key-pad right parenthesis */
+
+#define NR_PAD          20
+
+#define K_DGRAVE        K(KT_DEAD,0)
+#define K_DACUTE        K(KT_DEAD,1)
+#define K_DCIRCM        K(KT_DEAD,2)
+#define K_DTILDE        K(KT_DEAD,3)
+#define K_DDIERE        K(KT_DEAD,4)
+#define K_DCEDIL        K(KT_DEAD,5)
+
+#define NR_DEAD         6
+
+#define K_DOWN          K(KT_CUR,0)
+#define K_LEFT          K(KT_CUR,1)
+#define K_RIGHT         K(KT_CUR,2)
+#define K_UP            K(KT_CUR,3)
+
+#define K_SHIFT         K(KT_SHIFT,KG_SHIFT)
+#define K_CTRL          K(KT_SHIFT,KG_CTRL)
+#define K_ALT           K(KT_SHIFT,KG_ALT)
+#define K_ALTGR         K(KT_SHIFT,KG_ALTGR)
+#define K_SHIFTL        K(KT_SHIFT,KG_SHIFTL)
+#define K_SHIFTR        K(KT_SHIFT,KG_SHIFTR)
+#define K_CTRLL         K(KT_SHIFT,KG_CTRLL)
+#define K_CTRLR         K(KT_SHIFT,KG_CTRLR)
+#define K_CAPSSHIFT     K(KT_SHIFT,KG_CAPSSHIFT)
+
+#define K_ASC0          K(KT_ASCII,0)
+#define K_ASC1          K(KT_ASCII,1)
+#define K_ASC2          K(KT_ASCII,2)
+#define K_ASC3          K(KT_ASCII,3)
+#define K_ASC4          K(KT_ASCII,4)
+#define K_ASC5          K(KT_ASCII,5)
+#define K_ASC6          K(KT_ASCII,6)
+#define K_ASC7          K(KT_ASCII,7)
+#define K_ASC8          K(KT_ASCII,8)
+#define K_ASC9          K(KT_ASCII,9)
+#define K_HEX0          K(KT_ASCII,10)
+#define K_HEX1          K(KT_ASCII,11)
+#define K_HEX2          K(KT_ASCII,12)
+#define K_HEX3          K(KT_ASCII,13)
+#define K_HEX4          K(KT_ASCII,14)
+#define K_HEX5          K(KT_ASCII,15)
+#define K_HEX6          K(KT_ASCII,16)
+#define K_HEX7          K(KT_ASCII,17)
+#define K_HEX8          K(KT_ASCII,18)
+#define K_HEX9          K(KT_ASCII,19)
+#define K_HEXa          K(KT_ASCII,20)
+#define K_HEXb          K(KT_ASCII,21)
+#define K_HEXc          K(KT_ASCII,22)
+#define K_HEXd          K(KT_ASCII,23)
+#define K_HEXe          K(KT_ASCII,24)
+#define K_HEXf          K(KT_ASCII,25)
+
+#define NR_ASCII        26
+
+#define K_SHIFTLOCK     K(KT_LOCK,KG_SHIFT)
+#define K_CTRLLOCK      K(KT_LOCK,KG_CTRL)
+#define K_ALTLOCK       K(KT_LOCK,KG_ALT)
+#define K_ALTGRLOCK     K(KT_LOCK,KG_ALTGR)
+#define K_SHIFTLLOCK    K(KT_LOCK,KG_SHIFTL)
+#define K_SHIFTRLOCK    K(KT_LOCK,KG_SHIFTR)
+#define K_CTRLLLOCK     K(KT_LOCK,KG_CTRLL)
+#define K_CTRLRLOCK     K(KT_LOCK,KG_CTRLR)
+
+#define K_SHIFT_SLOCK   K(KT_SLOCK,KG_SHIFT)
+#define K_CTRL_SLOCK    K(KT_SLOCK,KG_CTRL)
+#define K_ALT_SLOCK     K(KT_SLOCK,KG_ALT)
+#define K_ALTGR_SLOCK   K(KT_SLOCK,KG_ALTGR)
+#define K_SHIFTL_SLOCK  K(KT_SLOCK,KG_SHIFTL)
+#define K_SHIFTR_SLOCK  K(KT_SLOCK,KG_SHIFTR)
+#define K_CTRLL_SLOCK   K(KT_SLOCK,KG_CTRLL)
+#define K_CTRLR_SLOCK   K(KT_SLOCK,KG_CTRLR)
+
+#define NR_LOCK         8
+
+#define MAX_DIACR       256
+#endif
diff --git a/include/linux/keyctl.h b/include/linux/keyctl.h
new file mode 100644
index 000000000000..381dedc370a3
--- /dev/null
+++ b/include/linux/keyctl.h
@@ -0,0 +1,39 @@
+/* keyctl.h: keyctl command IDs
+ *
+ * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_KEYCTL_H
+#define _LINUX_KEYCTL_H
+
+/* special process keyring shortcut IDs */
+#define KEY_SPEC_THREAD_KEYRING         -1      /* - key ID for thread-specific keyring */
+#define KEY_SPEC_PROCESS_KEYRING        -2      /* - key ID for process-specific keyring */
+#define KEY_SPEC_SESSION_KEYRING        -3      /* - key ID for session-specific keyring */
+#define KEY_SPEC_USER_KEYRING           -4      /* - key ID for UID-specific keyring */
+#define KEY_SPEC_USER_SESSION_KEYRING   -5      /* - key ID for UID-session keyring */
+#define KEY_SPEC_GROUP_KEYRING          -6      /* - key ID for GID-specific keyring */
+
+/* keyctl commands */
+#define KEYCTL_GET_KEYRING_ID           0       /* ask for a keyring's ID */
+#define KEYCTL_JOIN_SESSION_KEYRING     1       /* join or start named session keyring */
+#define KEYCTL_UPDATE                   2       /* update a key */
+#define KEYCTL_REVOKE                   3       /* revoke a key */
+#define KEYCTL_CHOWN                    4       /* set ownership of a key */
+#define KEYCTL_SETPERM                  5       /* set perms on a key */
+#define KEYCTL_DESCRIBE                 6       /* describe a key */
+#define KEYCTL_CLEAR                    7       /* clear contents of a keyring */
+#define KEYCTL_LINK                     8       /* link a key into a keyring */
+#define KEYCTL_UNLINK                   9       /* unlink a key from a keyring */
+#define KEYCTL_SEARCH                   10      /* search for a key in a keyring */
+#define KEYCTL_READ                     11      /* read a key or keyring's contents */
+#define KEYCTL_INSTANTIATE              12      /* instantiate a partially constructed key */
+#define KEYCTL_NEGATE                   13      /* negate a partially constructed key */
+
+#endif /*  _LINUX_KEYCTL_H */
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
new file mode 100644
index 000000000000..c27cd428d269
--- /dev/null
+++ b/include/linux/kfifo.h
@@ -0,0 +1,157 @@
+/*
+ * A simple kernel FIFO implementation.
+ *
+ * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef _LINUX_KFIFO_H
+#define _LINUX_KFIFO_H
+
+#ifdef __KERNEL__
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+
+struct kfifo {
+        unsigned char *buffer;  /* the buffer holding the data */
+        unsigned int size;      /* the size of the allocated buffer */
+        unsigned int in;        /* data is added at offset (in % size) */
+        unsigned int out;       /* data is extracted from off. (out % size) */
+        spinlock_t *lock;       /* protects concurrent modifications */
+};
+
+extern struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
+                                unsigned int __nocast gfp_mask, spinlock_t *lock);
+extern struct kfifo *kfifo_alloc(unsigned int size, unsigned int __nocast gfp_mask,
+                                 spinlock_t *lock);
+extern void kfifo_free(struct kfifo *fifo);
+extern unsigned int __kfifo_put(struct kfifo *fifo,
+                                unsigned char *buffer, unsigned int len);
+extern unsigned int __kfifo_get(struct kfifo *fifo,
+                                unsigned char *buffer, unsigned int len);
+
+/**
+ * __kfifo_reset - removes the entire FIFO contents, no locking version
+ * @fifo: the fifo to be emptied.
+ */
+static inline void __kfifo_reset(struct kfifo *fifo)
+{
+        fifo->in = fifo->out = 0;
+}
+
+/**
+ * kfifo_reset - removes the entire FIFO contents
+ * @fifo: the fifo to be emptied.
+ */
+static inline void kfifo_reset(struct kfifo *fifo)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(fifo->lock, flags);
+
+        __kfifo_reset(fifo);
+
+        spin_unlock_irqrestore(fifo->lock, flags);
+}
+
+/**
+ * kfifo_put - puts some data into the FIFO
+ * @fifo: the fifo to be used.
+ * @buffer: the data to be added.
+ * @len: the length of the data to be added.
+ *
+ * This function copies at most 'len' bytes from the 'buffer' into
+ * the FIFO depending on the free space, and returns the number of
+ * bytes copied.
+ */
+static inline unsigned int kfifo_put(struct kfifo *fifo,
+                                     unsigned char *buffer, unsigned int len)
+{
+        unsigned long flags;
+        unsigned int ret;
+
+        spin_lock_irqsave(fifo->lock, flags);
+
+        ret = __kfifo_put(fifo, buffer, len);
+
+        spin_unlock_irqrestore(fifo->lock, flags);
+
+        return ret;
+}
+
+/**
+ * kfifo_get - gets some data from the FIFO
+ * @fifo: the fifo to be used.
+ * @buffer: where the data must be copied.
+ * @len: the size of the destination buffer.
+ *
+ * This function copies at most 'len' bytes from the FIFO into the
+ * 'buffer' and returns the number of copied bytes.
+ */
+static inline unsigned int kfifo_get(struct kfifo *fifo,
+                                     unsigned char *buffer, unsigned int len)
+{
+        unsigned long flags;
+        unsigned int ret;
+
+        spin_lock_irqsave(fifo->lock, flags);
+
+        ret = __kfifo_get(fifo, buffer, len);
+
+        /*
+         * optimization: if the FIFO is empty, set the indices to 0
+         * so we don't wrap the next time
+         */
+        if (fifo->in == fifo->out)
+                fifo->in = fifo->out = 0;
+
+        spin_unlock_irqrestore(fifo->lock, flags);
+
+        return ret;
+}
+
+/**
+ * __kfifo_len - returns the number of bytes available in the FIFO, no locking version
+ * @fifo: the fifo to be used.
+ */
+static inline unsigned int __kfifo_len(struct kfifo *fifo)
+{
+        return fifo->in - fifo->out;
+}
+
+/**
+ * kfifo_len - returns the number of bytes available in the FIFO
+ * @fifo: the fifo to be used.
+ */
+static inline unsigned int kfifo_len(struct kfifo *fifo)
+{
+        unsigned long flags;
+        unsigned int ret;
+
+        spin_lock_irqsave(fifo->lock, flags);
+
+        ret = __kfifo_len(fifo);
+
+        spin_unlock_irqrestore(fifo->lock, flags);
+
+        return ret;
+}
+
+#else
+#warning "don't include kernel headers in userspace"
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/kmalloc_sizes.h b/include/linux/kmalloc_sizes.h
new file mode 100644
index 000000000000..d82d4c05c12d
--- /dev/null
+++ b/include/linux/kmalloc_sizes.h
@@ -0,0 +1,33 @@
+#if (PAGE_SIZE == 4096)
+        CACHE(32)
+#endif
+        CACHE(64)
+#if L1_CACHE_BYTES < 64
+        CACHE(96)
+#endif
+        CACHE(128)
+#if L1_CACHE_BYTES < 128
+        CACHE(192)
+#endif
+        CACHE(256)
+        CACHE(512)
+        CACHE(1024)
+        CACHE(2048)
+        CACHE(4096)
+        CACHE(8192)
+        CACHE(16384)
+        CACHE(32768)
+        CACHE(65536)
+        CACHE(131072)
+#ifndef CONFIG_MMU
+        CACHE(262144)
+        CACHE(524288)
+        CACHE(1048576)
+#ifdef CONFIG_LARGE_ALLOCS
+        CACHE(2097152)
+        CACHE(4194304)
+        CACHE(8388608)
+        CACHE(16777216)
+        CACHE(33554432)
+#endif /* CONFIG_LARGE_ALLOCS */
+#endif /* CONFIG_MMU */
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
new file mode 100644
index 000000000000..95d0e4b0814d
--- /dev/null
+++ b/include/linux/kmod.h
@@ -0,0 +1,40 @@
+#ifndef __LINUX_KMOD_H__
+#define __LINUX_KMOD_H__
+
+/*
+ *      include/linux/kmod.h
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/compiler.h>
+
+#define KMOD_PATH_LEN 256
+
+#ifdef CONFIG_KMOD
+/* modprobe exit status on success, -ve on error.  Return value
+ * usually useless though. */
+extern int request_module(const char * name, ...) __attribute__ ((format (printf, 1, 2)));
+#else
+static inline int request_module(const char * name, ...) { return -ENOSYS; }
+#endif
+
+#define try_then_request_module(x, mod...) ((x) ?: (request_module(mod), (x)))
+extern int call_usermodehelper(char *path, char *argv[], char *envp[], int wait);
+extern void usermodehelper_init(void);
+
+#endif /* __LINUX_KMOD_H__ */
diff --git a/include/linux/kobj_map.h b/include/linux/kobj_map.h
new file mode 100644
index 000000000000..b6cc10bf8dfc
--- /dev/null
+++ b/include/linux/kobj_map.h
@@ -0,0 +1,12 @@
+#ifdef __KERNEL__
+
+typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
+struct kobj_map;
+
+int kobj_map(struct kobj_map *, dev_t, unsigned long, struct module *,
+             kobj_probe_t *, int (*)(dev_t, void *), void *);
+void kobj_unmap(struct kobj_map *, dev_t, unsigned long);
+struct kobject *kobj_lookup(struct kobj_map *, dev_t, int *);
+struct kobj_map *kobj_map_init(kobj_probe_t *, struct semaphore *);
+
+#endif
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
new file mode 100644
index 000000000000..765d660d3bea
--- /dev/null
+++ b/include/linux/kobject.h
@@ -0,0 +1,259 @@
+/*
+ * kobject.h - generic kernel object infrastructure.
+ *
+ * Copyright (c) 2002-2003      Patrick Mochel
+ * Copyright (c) 2002-2003      Open Source Development Labs
+ *
+ * This file is released under the GPLv2.
+ *
+ * 
+ * Please read Documentation/kobject.txt before using the kobject
+ * interface, ESPECIALLY the parts about reference counts and object
+ * destructors. 
+ */
+
+#ifndef _KOBJECT_H_
+#define _KOBJECT_H_
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/sysfs.h>
+#include <linux/spinlock.h>
+#include <linux/rwsem.h>
+#include <linux/kref.h>
+#include <linux/kobject_uevent.h>
+#include <linux/kernel.h>
+#include <asm/atomic.h>
+
+#define KOBJ_NAME_LEN   20
+
+/* counter to tag the hotplug event, read only except for the kobject core */
+extern u64 hotplug_seqnum;
+
+struct kobject {
+        char                    * k_name;
+        char                    name[KOBJ_NAME_LEN];
+        struct kref             kref;
+        struct list_head        entry;
+        struct kobject          * parent;
+        struct kset             * kset;
+        struct kobj_type        * ktype;
+        struct dentry           * dentry;
+};
+
+extern int kobject_set_name(struct kobject *, const char *, ...)
+        __attribute__((format(printf,2,3)));
+
+static inline char * kobject_name(struct kobject * kobj)
+{
+        return kobj->k_name;
+}
+
+extern void kobject_init(struct kobject *);
+extern void kobject_cleanup(struct kobject *);
+
+extern int kobject_add(struct kobject *);
+extern void kobject_del(struct kobject *);
+
+extern int kobject_rename(struct kobject *, char *new_name);
+
+extern int kobject_register(struct kobject *);
+extern void kobject_unregister(struct kobject *);
+
+extern struct kobject * kobject_get(struct kobject *);
+extern void kobject_put(struct kobject *);
+
+extern char * kobject_get_path(struct kobject *, int);
+
+struct kobj_type {
+        void (*release)(struct kobject *);
+        struct sysfs_ops        * sysfs_ops;
+        struct attribute        ** default_attrs;
+};
+
+
+/**
+ *      kset - a set of kobjects of a specific type, belonging
+ *      to a specific subsystem.
+ *
+ *      All kobjects of a kset should be embedded in an identical 
+ *      type. This type may have a descriptor, which the kset points
+ *      to. This allows there to exist sets of objects of the same
+ *      type in different subsystems.
+ *
+ *      A subsystem does not have to be a list of only one type 
+ *      of object; multiple ksets can belong to one subsystem. All 
+ *      ksets of a subsystem share the subsystem's lock.
+ *
+ *      Each kset can support hotplugging; if it does, it will be given
+ *      the opportunity to filter out specific kobjects from being
+ *      reported, as well as to add its own "data" elements to the
+ *      environment being passed to the hotplug helper.
+ */
+struct kset_hotplug_ops {
+        int (*filter)(struct kset *kset, struct kobject *kobj);
+        char *(*name)(struct kset *kset, struct kobject *kobj);
+        int (*hotplug)(struct kset *kset, struct kobject *kobj, char **envp,
+                        int num_envp, char *buffer, int buffer_size);
+};
+
+struct kset {
+        struct subsystem        * subsys;
+        struct kobj_type        * ktype;
+        struct list_head        list;
+        spinlock_t              list_lock;
+        struct kobject          kobj;
+        struct kset_hotplug_ops * hotplug_ops;
+};
+
+
+extern void kset_init(struct kset * k);
+extern int kset_add(struct kset * k);
+extern int kset_register(struct kset * k);
+extern void kset_unregister(struct kset * k);
+
+static inline struct kset * to_kset(struct kobject * kobj)
+{
+        return kobj ? container_of(kobj,struct kset,kobj) : NULL;
+}
+
+static inline struct kset * kset_get(struct kset * k)
+{
+        return k ? to_kset(kobject_get(&k->kobj)) : NULL;
+}
+
+static inline void kset_put(struct kset * k)
+{
+        kobject_put(&k->kobj);
+}
+
+static inline struct kobj_type * get_ktype(struct kobject * k)
+{
+        if (k->kset && k->kset->ktype)
+                return k->kset->ktype;
+        else 
+                return k->ktype;
+}
+
+extern struct kobject * kset_find_obj(struct kset *, const char *);
+
+
+/**
+ * Use this when initializing an embedded kset with no other 
+ * fields to initialize.
+ */
+#define set_kset_name(str)      .kset = { .kobj = { .name = str } }
+
+
+
+struct subsystem {
+        struct kset             kset;
+        struct rw_semaphore     rwsem;
+};
+
+#define decl_subsys(_name,_type,_hotplug_ops) \
+struct subsystem _name##_subsys = { \
+        .kset = { \
+                .kobj = { .name = __stringify(_name) }, \
+                .ktype = _type, \
+                .hotplug_ops =_hotplug_ops, \
+        } \
+}
+#define decl_subsys_name(_varname,_name,_type,_hotplug_ops) \
+struct subsystem _varname##_subsys = { \
+        .kset = { \
+                .kobj = { .name = __stringify(_name) }, \
+                .ktype = _type, \
+                .hotplug_ops =_hotplug_ops, \
+        } \
+}
+
+/* The global /sys/kernel/ subsystem for people to chain off of */
+extern struct subsystem kernel_subsys;
+
+/**
+ * Helpers for setting the kset of registered objects.
+ * Often, a registered object belongs to a kset embedded in a 
+ * subsystem. These do no magic, just make the resulting code
+ * easier to follow. 
+ */
+
+/**
+ *      kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
+ *      @obj:           ptr to some object type.
+ *      @subsys:        a subsystem object (not a ptr).
+ *
+ *      Can be used for any object type with an embedded ->kobj.
+ */
+
+#define kobj_set_kset_s(obj,subsys) \
+        (obj)->kobj.kset = &(subsys).kset
+
+/**
+ *      kset_set_kset_s(obj,subsys) - set kset for embedded kset.
+ *      @obj:           ptr to some object type.
+ *      @subsys:        a subsystem object (not a ptr).
+ *
+ *      Can be used for any object type with an embedded ->kset.
+ *      Sets the kset of @obj's  embedded kobject (via its embedded
+ *      kset) to @subsys.kset. This makes @obj a member of that 
+ *      kset.
+ */
+
+#define kset_set_kset_s(obj,subsys) \
+        (obj)->kset.kobj.kset = &(subsys).kset
+
+/**
+ *      subsys_set_kset(obj,subsys) - set kset for subsystem
+ *      @obj:           ptr to some object type.
+ *      @subsys:        a subsystem object (not a ptr).
+ *
+ *      Can be used for any object type with an embedded ->subsys.
+ *      Sets the kset of @obj's kobject to @subsys.kset. This makes
+ *      the object a member of that kset.
+ */
+
+#define subsys_set_kset(obj,_subsys) \
+        (obj)->subsys.kset.kobj.kset = &(_subsys).kset
+
+extern void subsystem_init(struct subsystem *);
+extern int subsystem_register(struct subsystem *);
+extern void subsystem_unregister(struct subsystem *);
+
+static inline struct subsystem * subsys_get(struct subsystem * s)
+{
+        return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
+}
+
+static inline void subsys_put(struct subsystem * s)
+{
+        kset_put(&s->kset);
+}
+
+struct subsys_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct subsystem *, char *);
+        ssize_t (*store)(struct subsystem *, const char *, size_t); 
+};
+
+extern int subsys_create_file(struct subsystem * , struct subsys_attribute *);
+extern void subsys_remove_file(struct subsystem * , struct subsys_attribute *);
+
+#ifdef CONFIG_HOTPLUG
+void kobject_hotplug(struct kobject *kobj, enum kobject_action action);
+int add_hotplug_env_var(char **envp, int num_envp, int *cur_index,
+                        char *buffer, int buffer_size, int *cur_len,
+                        const char *format, ...)
+        __attribute__((format (printf, 7, 8)));
+#else
+static inline void kobject_hotplug(struct kobject *kobj, enum kobject_action action) { }
+static inline int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, 
+                                      char *buffer, int buffer_size, int *cur_len, 
+                                      const char *format, ...)
+{ return 0; }
+#endif
+
+#endif /* __KERNEL__ */
+#endif /* _KOBJECT_H_ */
diff --git a/include/linux/kobject_uevent.h b/include/linux/kobject_uevent.h
new file mode 100644
index 000000000000..aa664fe7e561
--- /dev/null
+++ b/include/linux/kobject_uevent.h
@@ -0,0 +1,57 @@
+/*
+ * kobject_uevent.h - list of kobject user events that can be generated
+ *
+ * Copyright (C) 2004 IBM Corp.
+ * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
+ *
+ * This file is released under the GPLv2.
+ *
+ */
+
+#ifndef _KOBJECT_EVENT_H_
+#define _KOBJECT_EVENT_H_
+
+#define HOTPLUG_PATH_LEN        256
+
+/* path to the hotplug userspace helper executed on an event */
+extern char hotplug_path[];
+
+/*
+ * If you add an action here, you must also add the proper string to the
+ * lib/kobject_uevent.c file.
+ */
+typedef int __bitwise kobject_action_t;
+enum kobject_action {
+        KOBJ_ADD        = (__force kobject_action_t) 0x01,      /* add event, for hotplug */
+        KOBJ_REMOVE     = (__force kobject_action_t) 0x02,      /* remove event, for hotplug */
+        KOBJ_CHANGE     = (__force kobject_action_t) 0x03,      /* a sysfs attribute file has changed */
+        KOBJ_MOUNT      = (__force kobject_action_t) 0x04,      /* mount event for block devices */
+        KOBJ_UMOUNT     = (__force kobject_action_t) 0x05,      /* umount event for block devices */
+        KOBJ_OFFLINE    = (__force kobject_action_t) 0x06,      /* offline event for hotplug devices */
+        KOBJ_ONLINE     = (__force kobject_action_t) 0x07,      /* online event for hotplug devices */
+};
+
+
+#ifdef CONFIG_KOBJECT_UEVENT
+int kobject_uevent(struct kobject *kobj,
+                   enum kobject_action action,
+                   struct attribute *attr);
+int kobject_uevent_atomic(struct kobject *kobj,
+                          enum kobject_action action,
+                          struct attribute *attr);
+#else
+static inline int kobject_uevent(struct kobject *kobj,
+                                 enum kobject_action action,
+                                 struct attribute *attr)
+{
+        return 0;
+}
+static inline int kobject_uevent_atomic(struct kobject *kobj,
+                                        enum kobject_action action,
+                                        struct attribute *attr)
+{
+        return 0;
+}
+#endif
+
+#endif
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
new file mode 100644
index 000000000000..f20c163de4f5
--- /dev/null
+++ b/include/linux/kprobes.h
@@ -0,0 +1,136 @@
+#ifndef _LINUX_KPROBES_H
+#define _LINUX_KPROBES_H
+/*
+ *  Kernel Probes (KProbes)
+ *  include/linux/kprobes.h
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright (C) IBM Corporation, 2002, 2004
+ *
+ * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
+ *              Probes initial implementation ( includes suggestions from
+ *              Rusty Russell).
+ * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
+ *              interface to access function arguments.
+ */
+#include <linux/config.h>
+#include <linux/list.h>
+#include <linux/notifier.h>
+#include <linux/smp.h>
+#include <asm/kprobes.h>
+
+struct kprobe;
+struct pt_regs;
+typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
+typedef int (*kprobe_break_handler_t) (struct kprobe *, struct pt_regs *);
+typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
+                                       unsigned long flags);
+typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
+                                       int trapnr);
+struct kprobe {
+        struct hlist_node hlist;
+
+        /* location of the probe point */
+        kprobe_opcode_t *addr;
+
+        /* Called before addr is executed. */
+        kprobe_pre_handler_t pre_handler;
+
+        /* Called after addr is executed, unless... */
+        kprobe_post_handler_t post_handler;
+
+        /* ... called if executing addr causes a fault (eg. page fault).
+         * Return 1 if it handled fault, otherwise kernel will see it. */
+        kprobe_fault_handler_t fault_handler;
+
+        /* ... called if breakpoint trap occurs in probe handler.
+         * Return 1 if it handled break, otherwise kernel will see it. */
+        kprobe_break_handler_t break_handler;
+
+        /* Saved opcode (which has been replaced with breakpoint) */
+        kprobe_opcode_t opcode;
+
+        /* copy of the original instruction */
+        struct arch_specific_insn ainsn;
+};
+
+/*
+ * Special probe type that uses setjmp-longjmp type tricks to resume
+ * execution at a specified entry with a matching prototype corresponding
+ * to the probed function - a trick to enable arguments to become
+ * accessible seamlessly by probe handling logic.
+ * Note:
+ * Because of the way compilers allocate stack space for local variables
+ * etc upfront, regardless of sub-scopes within a function, this mirroring
+ * principle currently works only for probes placed on function entry points.
+ */
+struct jprobe {
+        struct kprobe kp;
+        kprobe_opcode_t *entry; /* probe handling code to jump to */
+};
+
+#ifdef CONFIG_KPROBES
+/* Locks kprobe: irq must be disabled */
+void lock_kprobes(void);
+void unlock_kprobes(void);
+
+/* kprobe running now on this CPU? */
+static inline int kprobe_running(void)
+{
+        extern unsigned int kprobe_cpu;
+        return kprobe_cpu == smp_processor_id();
+}
+
+extern int arch_prepare_kprobe(struct kprobe *p);
+extern void arch_copy_kprobe(struct kprobe *p);
+extern void arch_remove_kprobe(struct kprobe *p);
+extern void show_registers(struct pt_regs *regs);
+
+/* Get the kprobe at this addr (if any).  Must have called lock_kprobes */
+struct kprobe *get_kprobe(void *addr);
+
+int register_kprobe(struct kprobe *p);
+void unregister_kprobe(struct kprobe *p);
+int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
+int longjmp_break_handler(struct kprobe *, struct pt_regs *);
+int register_jprobe(struct jprobe *p);
+void unregister_jprobe(struct jprobe *p);
+void jprobe_return(void);
+
+#else
+static inline int kprobe_running(void)
+{
+        return 0;
+}
+static inline int register_kprobe(struct kprobe *p)
+{
+        return -ENOSYS;
+}
+static inline void unregister_kprobe(struct kprobe *p)
+{
+}
+static inline int register_jprobe(struct jprobe *p)
+{
+        return -ENOSYS;
+}
+static inline void unregister_jprobe(struct jprobe *p)
+{
+}
+static inline void jprobe_return(void)
+{
+}
+#endif
+#endif                          /* _LINUX_KPROBES_H */
diff --git a/include/linux/kref.h b/include/linux/kref.h
new file mode 100644
index 000000000000..6fee3539893f
--- /dev/null
+++ b/include/linux/kref.h
@@ -0,0 +1,32 @@
+/*
+ * kref.c - library routines for handling generic reference counted objects
+ *
+ * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2004 IBM Corp.
+ *
+ * based on kobject.h which was:
+ * Copyright (C) 2002-2003 Patrick Mochel <mochel@osdl.org>
+ * Copyright (C) 2002-2003 Open Source Development Labs
+ *
+ * This file is released under the GPLv2.
+ *
+ */
+
+#ifndef _KREF_H_
+#define _KREF_H_
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <asm/atomic.h>
+
+struct kref {
+        atomic_t refcount;
+};
+
+void kref_init(struct kref *kref);
+void kref_get(struct kref *kref);
+int kref_put(struct kref *kref, void (*release) (struct kref *kref));
+
+#endif /* __KERNEL__ */
+#endif /* _KREF_H_ */
diff --git a/include/linux/kthread.h b/include/linux/kthread.h
new file mode 100644
index 000000000000..3fa786448db3
--- /dev/null
+++ b/include/linux/kthread.h
@@ -0,0 +1,81 @@
+#ifndef _LINUX_KTHREAD_H
+#define _LINUX_KTHREAD_H
+/* Simple interface for creating and stopping kernel threads without mess. */
+#include <linux/err.h>
+#include <linux/sched.h>
+
+/**
+ * kthread_create: create a kthread.
+ * @threadfn: the function to run until signal_pending(current).
+ * @data: data ptr for @threadfn.
+ * @namefmt: printf-style name for the thread.
+ *
+ * Description: This helper function creates and names a kernel
+ * thread.  The thread will be stopped: use wake_up_process() to start
+ * it.  See also kthread_run(), kthread_create_on_cpu().
+ *
+ * When woken, the thread will run @threadfn() with @data as its
+ * argument. @threadfn can either call do_exit() directly if it is a
+ * standalone thread for which noone will call kthread_stop(), or
+ * return when 'kthread_should_stop()' is true (which means
+ * kthread_stop() has been called).  The return value should be zero
+ * or a negative error number: it will be passed to kthread_stop().
+ *
+ * Returns a task_struct or ERR_PTR(-ENOMEM).
+ */
+struct task_struct *kthread_create(int (*threadfn)(void *data),
+                                   void *data,
+                                   const char namefmt[], ...);
+
+/**
+ * kthread_run: create and wake a thread.
+ * @threadfn: the function to run until signal_pending(current).
+ * @data: data ptr for @threadfn.
+ * @namefmt: printf-style name for the thread.
+ *
+ * Description: Convenient wrapper for kthread_create() followed by
+ * wake_up_process().  Returns the kthread, or ERR_PTR(-ENOMEM). */
+#define kthread_run(threadfn, data, namefmt, ...)                          \
+({                                                                         \
+        struct task_struct *__k                                            \
+                = kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \
+        if (!IS_ERR(__k))                                                  \
+                wake_up_process(__k);                                      \
+        __k;                                                               \
+})
+
+/**
+ * kthread_bind: bind a just-created kthread to a cpu.
+ * @k: thread created by kthread_create().
+ * @cpu: cpu (might not be online, must be possible) for @k to run on.
+ *
+ * Description: This function is equivalent to set_cpus_allowed(),
+ * except that @cpu doesn't need to be online, and the thread must be
+ * stopped (ie. just returned from kthread_create().
+ */
+void kthread_bind(struct task_struct *k, unsigned int cpu);
+
+/**
+ * kthread_stop: stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ *
+ * Sets kthread_should_stop() for @k to return true, wakes it, and
+ * waits for it to exit.  Your threadfn() must not call do_exit()
+ * itself if you use this function!  This can also be called after
+ * kthread_create() instead of calling wake_up_process(): the thread
+ * will exit without calling threadfn().
+ *
+ * Returns the result of threadfn(), or -EINTR if wake_up_process()
+ * was never called. */
+int kthread_stop(struct task_struct *k);
+
+/**
+ * kthread_should_stop: should this kthread return now?
+ *
+ * When someone calls kthread_stop on your kthread, it will be woken
+ * and this will return true.  You should then return, and your return
+ * value will be passed through to kthread_stop().
+ */
+int kthread_should_stop(void);
+
+#endif /* _LINUX_KTHREAD_H */
diff --git a/include/linux/lapb.h b/include/linux/lapb.h
new file mode 100644
index 000000000000..ce709e1885cc
--- /dev/null
+++ b/include/linux/lapb.h
@@ -0,0 +1,56 @@
+/*
+ * These are the public elements of the Linux LAPB module.
+ */
+
+#ifndef LAPB_KERNEL_H
+#define LAPB_KERNEL_H
+
+#define LAPB_OK                 0
+#define LAPB_BADTOKEN           1
+#define LAPB_INVALUE            2
+#define LAPB_CONNECTED          3
+#define LAPB_NOTCONNECTED       4
+#define LAPB_REFUSED            5
+#define LAPB_TIMEDOUT           6
+#define LAPB_NOMEM              7
+
+#define LAPB_STANDARD           0x00
+#define LAPB_EXTENDED           0x01
+
+#define LAPB_SLP                0x00
+#define LAPB_MLP                0x02
+
+#define LAPB_DTE                0x00
+#define LAPB_DCE                0x04
+
+struct lapb_register_struct {
+        void (*connect_confirmation)(struct net_device *dev, int reason);
+        void (*connect_indication)(struct net_device *dev, int reason);
+        void (*disconnect_confirmation)(struct net_device *dev, int reason);
+        void (*disconnect_indication)(struct net_device *dev, int reason);
+        int  (*data_indication)(struct net_device *dev, struct sk_buff *skb);
+        void (*data_transmit)(struct net_device *dev, struct sk_buff *skb);
+};
+
+struct lapb_parms_struct {
+        unsigned int t1;
+        unsigned int t1timer;
+        unsigned int t2;
+        unsigned int t2timer;
+        unsigned int n2;
+        unsigned int n2count;
+        unsigned int window;
+        unsigned int state;
+        unsigned int mode;
+};
+
+extern int lapb_register(struct net_device *dev, struct lapb_register_struct *callbacks);
+extern int lapb_unregister(struct net_device *dev);
+extern int lapb_getparms(struct net_device *dev, struct lapb_parms_struct *parms);
+extern int lapb_setparms(struct net_device *dev, struct lapb_parms_struct *parms);
+extern int lapb_connect_request(struct net_device *dev);
+extern int lapb_disconnect_request(struct net_device *dev);
+extern int lapb_data_request(struct net_device *dev, struct sk_buff *skb);
+extern int lapb_data_received(struct net_device *dev, struct sk_buff *skb);
+
+#endif
diff --git a/include/linux/lcd.h b/include/linux/lcd.h
new file mode 100644
index 000000000000..d739b2e7eac2
--- /dev/null
+++ b/include/linux/lcd.h
@@ -0,0 +1,56 @@
+/*
+ * LCD Lowlevel Control Abstraction
+ *
+ * Copyright (C) 2003,2004 Hewlett-Packard Company
+ *
+ */
+
+#ifndef _LINUX_LCD_H
+#define _LINUX_LCD_H
+
+#include <linux/device.h>
+#include <linux/notifier.h>
+
+struct lcd_device;
+struct fb_info;
+
+/* This structure defines all the properties of a LCD flat panel. */
+struct lcd_properties {
+        /* Owner module */
+        struct module *owner;
+        /* Get the LCD panel power status (0: full on, 1..3: controller
+           power on, flat panel power off, 4: full off), see FB_BLANK_XXX */
+        int (*get_power)(struct lcd_device *);
+        /* Enable or disable power to the LCD (0: on; 4: off, see FB_BLANK_XXX) */
+        int (*set_power)(struct lcd_device *, int power);
+        /* The maximum value for contrast (read-only) */
+        int max_contrast;
+        /* Get the current contrast setting (0-max_contrast) */
+        int (*get_contrast)(struct lcd_device *);
+        /* Set LCD panel contrast */
+        int (*set_contrast)(struct lcd_device *, int contrast);
+        /* Check if given framebuffer device is the one LCD is bound to;
+           return 0 if not, !=0 if it is. If NULL, lcd always matches the fb. */
+        int (*check_fb)(struct fb_info *);
+};
+
+struct lcd_device {
+        /* This protects the 'props' field. If 'props' is NULL, the driver that
+           registered this device has been unloaded, and if class_get_devdata()
+           points to something in the body of that driver, it is also invalid. */
+        struct semaphore sem;
+        /* If this is NULL, the backing module is unloaded */
+        struct lcd_properties *props;
+        /* The framebuffer notifier block */
+        struct notifier_block fb_notif;
+        /* The class device structure */
+        struct class_device class_dev;
+};
+
+extern struct lcd_device *lcd_device_register(const char *name,
+        void *devdata, struct lcd_properties *lp);
+extern void lcd_device_unregister(struct lcd_device *ld);
+
+#define to_lcd_device(obj) container_of(obj, struct lcd_device, class_dev)
+
+#endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
new file mode 100644
index 000000000000..505160ab472b
--- /dev/null
+++ b/include/linux/libata.h
@@ -0,0 +1,599 @@
+/*
+   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
+   Copyright 2003-2004 Jeff Garzik
+
+   The contents of this file are subject to the Open
+   Software License version 1.1 that can be found at
+   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
+   by reference.
+
+   Alternatively, the contents of this file may be used under the terms
+   of the GNU General Public License version 2 (the "GPL") as distributed
+   in the kernel source COPYING file, in which case the provisions of
+   the GPL are applicable instead of the above.  If you wish to allow
+   the use of your version of this file only under the terms of the
+   GPL and not to allow others to use your version of this file under
+   the OSL, indicate your decision by deleting the provisions above and
+   replace them with the notice and other provisions required by the GPL.
+   If you do not delete the provisions above, a recipient may use your
+   version of this file under either the OSL or the GPL.
+
+ */
+
+#ifndef __LINUX_LIBATA_H__
+#define __LINUX_LIBATA_H__
+
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <asm/io.h>
+#include <linux/ata.h>
+#include <linux/workqueue.h>
+
+/*
+ * compile-time options
+ */
+#undef ATA_DEBUG                /* debugging output */
+#undef ATA_VERBOSE_DEBUG        /* yet more debugging output */
+#undef ATA_IRQ_TRAP             /* define to ack screaming irqs */
+#undef ATA_NDEBUG               /* define to disable quick runtime checks */
+#undef ATA_ENABLE_ATAPI         /* define to enable ATAPI support */
+#undef ATA_ENABLE_PATA          /* define to enable PATA support in some
+                                 * low-level drivers */
+#undef ATAPI_ENABLE_DMADIR      /* enables ATAPI DMADIR bridge support */
+
+
+/* note: prints function name for you */
+#ifdef ATA_DEBUG
+#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#ifdef ATA_VERBOSE_DEBUG
+#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#else
+#define VPRINTK(fmt, args...)
+#endif  /* ATA_VERBOSE_DEBUG */
+#else
+#define DPRINTK(fmt, args...)
+#define VPRINTK(fmt, args...)
+#endif  /* ATA_DEBUG */
+
+#ifdef ATA_NDEBUG
+#define assert(expr)
+#else
+#define assert(expr) \
+        if(unlikely(!(expr))) {                                   \
+        printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
+        #expr,__FILE__,__FUNCTION__,__LINE__);          \
+        }
+#endif
+
+/* defines only for the constants which don't work well as enums */
+#define ATA_TAG_POISON          0xfafbfcfdU
+
+/* move to PCI layer? */
+static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
+{
+        return &pdev->dev;
+}
+
+enum {
+        /* various global constants */
+        LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
+        ATA_MAX_PORTS           = 8,
+        ATA_DEF_QUEUE           = 1,
+        ATA_MAX_QUEUE           = 1,
+        ATA_MAX_SECTORS         = 200,  /* FIXME */
+        ATA_MAX_BUS             = 2,
+        ATA_DEF_BUSY_WAIT       = 10000,
+        ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
+
+        ATA_SHT_EMULATED        = 1,
+        ATA_SHT_CMD_PER_LUN     = 1,
+        ATA_SHT_THIS_ID         = -1,
+        ATA_SHT_USE_CLUSTERING  = 0,
+
+        /* struct ata_device stuff */
+        ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
+        ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
+        ATA_DFLAG_LOCK_SECTORS  = (1 << 2), /* don't adjust max_sectors */
+
+        ATA_DEV_UNKNOWN         = 0,    /* unknown device */
+        ATA_DEV_ATA             = 1,    /* ATA device */
+        ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
+        ATA_DEV_ATAPI           = 3,    /* ATAPI device */
+        ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
+        ATA_DEV_NONE            = 5,    /* no device */
+
+        /* struct ata_port flags */
+        ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
+                                            /* (doesn't imply presence) */
+        ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
+        ATA_FLAG_SATA           = (1 << 3),
+        ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
+        ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
+        ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
+        ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
+        ATA_FLAG_PIO_DMA        = (1 << 8), /* PIO cmds via DMA */
+
+        ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
+        ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
+        ATA_QCFLAG_SINGLE       = (1 << 4), /* no s/g, just a single buffer */
+        ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
+
+        /* various lengths of time */
+        ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
+        ATA_TMOUT_PIO           = 30 * HZ,
+        ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
+        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
+        ATA_TMOUT_CDB           = 30 * HZ,
+        ATA_TMOUT_CDB_QUICK     = 5 * HZ,
+
+        /* ATA bus states */
+        BUS_UNKNOWN             = 0,
+        BUS_DMA                 = 1,
+        BUS_IDLE                = 2,
+        BUS_NOINTR              = 3,
+        BUS_NODATA              = 4,
+        BUS_TIMER               = 5,
+        BUS_PIO                 = 6,
+        BUS_EDD                 = 7,
+        BUS_IDENTIFY            = 8,
+        BUS_PACKET              = 9,
+
+        /* SATA port states */
+        PORT_UNKNOWN            = 0,
+        PORT_ENABLED            = 1,
+        PORT_DISABLED           = 2,
+
+        /* encoding various smaller bitmaps into a single
+         * unsigned long bitmap
+         */
+        ATA_SHIFT_UDMA          = 0,
+        ATA_SHIFT_MWDMA         = 8,
+        ATA_SHIFT_PIO           = 11,
+};
+
+enum pio_task_states {
+        PIO_ST_UNKNOWN,
+        PIO_ST_IDLE,
+        PIO_ST_POLL,
+        PIO_ST_TMOUT,
+        PIO_ST,
+        PIO_ST_LAST,
+        PIO_ST_LAST_POLL,
+        PIO_ST_ERR,
+};
+
+/* forward declarations */
+struct scsi_device;
+struct ata_port_operations;
+struct ata_port;
+struct ata_queued_cmd;
+
+/* typedefs */
+typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
+
+struct ata_ioports {
+        unsigned long           cmd_addr;
+        unsigned long           data_addr;
+        unsigned long           error_addr;
+        unsigned long           feature_addr;
+        unsigned long           nsect_addr;
+        unsigned long           lbal_addr;
+        unsigned long           lbam_addr;
+        unsigned long           lbah_addr;
+        unsigned long           device_addr;
+        unsigned long           status_addr;
+        unsigned long           command_addr;
+        unsigned long           altstatus_addr;
+        unsigned long           ctl_addr;
+        unsigned long           bmdma_addr;
+        unsigned long           scr_addr;
+};
+
+struct ata_probe_ent {
+        struct list_head        node;
+        struct device           *dev;
+        struct ata_port_operations      *port_ops;
+        Scsi_Host_Template      *sht;
+        struct ata_ioports      port[ATA_MAX_PORTS];
+        unsigned int            n_ports;
+        unsigned int            hard_port_no;
+        unsigned int            pio_mask;
+        unsigned int            mwdma_mask;
+        unsigned int            udma_mask;
+        unsigned int            legacy_mode;
+        unsigned long           irq;
+        unsigned int            irq_flags;
+        unsigned long           host_flags;
+        void __iomem            *mmio_base;
+        void                    *private_data;
+};
+
+struct ata_host_set {
+        spinlock_t              lock;
+        struct device           *dev;
+        unsigned long           irq;
+        void __iomem            *mmio_base;
+        unsigned int            n_ports;
+        void                    *private_data;
+        struct ata_port_operations *ops;
+        struct ata_port *       ports[0];
+};
+
+struct ata_queued_cmd {
+        struct ata_port         *ap;
+        struct ata_device       *dev;
+
+        struct scsi_cmnd        *scsicmd;
+        void                    (*scsidone)(struct scsi_cmnd *);
+
+        struct ata_taskfile     tf;
+        u8                      cdb[ATAPI_CDB_LEN];
+
+        unsigned long           flags;          /* ATA_QCFLAG_xxx */
+        unsigned int            tag;
+        unsigned int            n_elem;
+
+        int                     dma_dir;
+
+        unsigned int            nsect;
+        unsigned int            cursect;
+
+        unsigned int            nbytes;
+        unsigned int            curbytes;
+
+        unsigned int            cursg;
+        unsigned int            cursg_ofs;
+
+        struct scatterlist      sgent;
+        void                    *buf_virt;
+
+        struct scatterlist      *sg;
+
+        ata_qc_cb_t             complete_fn;
+
+        struct completion       *waiting;
+
+        void                    *private_data;
+};
+
+struct ata_host_stats {
+        unsigned long           unhandled_irq;
+        unsigned long           idle_irq;
+        unsigned long           rw_reqbuf;
+};
+
+struct ata_device {
+        u64                     n_sectors;      /* size of device, if ATA */
+        unsigned long           flags;          /* ATA_DFLAG_xxx */
+        unsigned int            class;          /* ATA_DEV_xxx */
+        unsigned int            devno;          /* 0 or 1 */
+        u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
+        u8                      pio_mode;
+        u8                      dma_mode;
+        u8                      xfer_mode;
+        unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
+
+        /* cache info about current transfer mode */
+        u8                      xfer_protocol;  /* taskfile xfer protocol */
+        u8                      read_cmd;       /* opcode to use on read */
+        u8                      write_cmd;      /* opcode to use on write */
+};
+
+struct ata_port {
+        struct Scsi_Host        *host;  /* our co-allocated scsi host */
+        struct ata_port_operations      *ops;
+        unsigned long           flags;  /* ATA_FLAG_xxx */
+        unsigned int            id;     /* unique id req'd by scsi midlyr */
+        unsigned int            port_no; /* unique port #; from zero */
+        unsigned int            hard_port_no;   /* hardware port #; from zero */
+
+        struct ata_prd          *prd;    /* our SG list */
+        dma_addr_t              prd_dma; /* and its DMA mapping */
+
+        struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
+
+        u8                      ctl;    /* cache of ATA control register */
+        u8                      last_ctl;       /* Cache last written value */
+        unsigned int            bus_state;
+        unsigned int            port_state;
+        unsigned int            pio_mask;
+        unsigned int            mwdma_mask;
+        unsigned int            udma_mask;
+        unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
+        unsigned int            cdb_len;
+
+        struct ata_device       device[ATA_MAX_DEVICES];
+
+        struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
+        unsigned long           qactive;
+        unsigned int            active_tag;
+
+        struct ata_host_stats   stats;
+        struct ata_host_set     *host_set;
+
+        struct work_struct      packet_task;
+
+        struct work_struct      pio_task;
+        unsigned int            pio_task_state;
+        unsigned long           pio_task_timeout;
+
+        void                    *private_data;
+};
+
+struct ata_port_operations {
+        void (*port_disable) (struct ata_port *);
+
+        void (*dev_config) (struct ata_port *, struct ata_device *);
+
+        void (*set_piomode) (struct ata_port *, struct ata_device *);
+        void (*set_dmamode) (struct ata_port *, struct ata_device *);
+
+        void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
+        void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
+
+        void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
+        u8   (*check_status)(struct ata_port *ap);
+        u8   (*check_altstatus)(struct ata_port *ap);
+        u8   (*check_err)(struct ata_port *ap);
+        void (*dev_select)(struct ata_port *ap, unsigned int device);
+
+        void (*phy_reset) (struct ata_port *ap);
+        void (*post_set_mode) (struct ata_port *ap);
+
+        int (*check_atapi_dma) (struct ata_queued_cmd *qc);
+
+        void (*bmdma_setup) (struct ata_queued_cmd *qc);
+        void (*bmdma_start) (struct ata_queued_cmd *qc);
+
+        void (*qc_prep) (struct ata_queued_cmd *qc);
+        int (*qc_issue) (struct ata_queued_cmd *qc);
+
+        void (*eng_timeout) (struct ata_port *ap);
+
+        irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
+        void (*irq_clear) (struct ata_port *);
+
+        u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
+        void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
+                           u32 val);
+
+        int (*port_start) (struct ata_port *ap);
+        void (*port_stop) (struct ata_port *ap);
+
+        void (*host_stop) (struct ata_host_set *host_set);
+
+        void (*bmdma_stop) (struct ata_port *ap);
+        u8   (*bmdma_status) (struct ata_port *ap);
+};
+
+struct ata_port_info {
+        Scsi_Host_Template      *sht;
+        unsigned long           host_flags;
+        unsigned long           pio_mask;
+        unsigned long           mwdma_mask;
+        unsigned long           udma_mask;
+        struct ata_port_operations      *port_ops;
+};
+
+
+extern void ata_port_probe(struct ata_port *);
+extern void __sata_phy_reset(struct ata_port *ap);
+extern void sata_phy_reset(struct ata_port *ap);
+extern void ata_bus_reset(struct ata_port *ap);
+extern void ata_port_disable(struct ata_port *);
+extern void ata_std_ports(struct ata_ioports *ioaddr);
+#ifdef CONFIG_PCI
+extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
+                             unsigned int n_ports);
+extern void ata_pci_remove_one (struct pci_dev *pdev);
+#endif /* CONFIG_PCI */
+extern int ata_device_add(struct ata_probe_ent *ent);
+extern int ata_scsi_detect(Scsi_Host_Template *sht);
+extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
+extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
+extern int ata_scsi_error(struct Scsi_Host *host);
+extern int ata_scsi_release(struct Scsi_Host *host);
+extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
+/*
+ * Default driver ops implementations
+ */
+extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
+extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
+extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
+extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
+extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
+extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
+extern u8 ata_check_status(struct ata_port *ap);
+extern u8 ata_altstatus(struct ata_port *ap);
+extern u8 ata_chk_err(struct ata_port *ap);
+extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
+extern int ata_port_start (struct ata_port *ap);
+extern void ata_port_stop (struct ata_port *ap);
+extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
+extern void ata_qc_prep(struct ata_queued_cmd *qc);
+extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
+extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
+                unsigned int buflen);
+extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
+                 unsigned int n_elem);
+extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
+extern void ata_dev_id_string(u16 *id, unsigned char *s,
+                              unsigned int ofs, unsigned int len);
+extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
+extern void ata_bmdma_start (struct ata_queued_cmd *qc);
+extern void ata_bmdma_stop(struct ata_port *ap);
+extern u8   ata_bmdma_status(struct ata_port *ap);
+extern void ata_bmdma_irq_clear(struct ata_port *ap);
+extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
+extern void ata_eng_timeout(struct ata_port *ap);
+extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
+                              void (*done)(struct scsi_cmnd *));
+extern int ata_std_bios_param(struct scsi_device *sdev,
+                              struct block_device *bdev,
+                              sector_t capacity, int geom[]);
+extern int ata_scsi_slave_config(struct scsi_device *sdev);
+
+
+#ifdef CONFIG_PCI
+struct pci_bits {
+        unsigned int            reg;    /* PCI config register to read */
+        unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
+        unsigned long           mask;
+        unsigned long           val;
+};
+
+extern struct ata_probe_ent *
+ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
+extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
+
+#endif /* CONFIG_PCI */
+
+
+static inline unsigned int ata_tag_valid(unsigned int tag)
+{
+        return (tag < ATA_MAX_QUEUE) ? 1 : 0;
+}
+
+static inline unsigned int ata_dev_present(struct ata_device *dev)
+{
+        return ((dev->class == ATA_DEV_ATA) ||
+                (dev->class == ATA_DEV_ATAPI));
+}
+
+static inline u8 ata_chk_status(struct ata_port *ap)
+{
+        return ap->ops->check_status(ap);
+}
+
+static inline void ata_pause(struct ata_port *ap)
+{
+        ata_altstatus(ap);
+        ndelay(400);
+}
+
+static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
+                               unsigned int max)
+{
+        u8 status;
+
+        do {
+                udelay(10);
+                status = ata_chk_status(ap);
+                max--;
+        } while ((status & bits) && (max > 0));
+
+        return status;
+}
+
+static inline u8 ata_wait_idle(struct ata_port *ap)
+{
+        u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
+
+        if (status & (ATA_BUSY | ATA_DRQ)) {
+                unsigned long l = ap->ioaddr.status_addr;
+                printk(KERN_WARNING
+                       "ATA: abnormal status 0x%X on port 0x%lX\n",
+                       status, l);
+        }
+
+        return status;
+}
+
+static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
+{
+        qc->tf.ctl |= ATA_NIEN;
+}
+
+static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
+                                                      unsigned int tag)
+{
+        if (likely(ata_tag_valid(tag)))
+                return &ap->qcmd[tag];
+        return NULL;
+}
+
+static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
+{
+        memset(tf, 0, sizeof(*tf));
+
+        tf->ctl = ap->ctl;
+        if (device == 0)
+                tf->device = ATA_DEVICE_OBS;
+        else
+                tf->device = ATA_DEVICE_OBS | ATA_DEV1;
+}
+
+static inline u8 ata_irq_on(struct ata_port *ap)
+{
+        struct ata_ioports *ioaddr = &ap->ioaddr;
+        u8 tmp;
+
+        ap->ctl &= ~ATA_NIEN;
+        ap->last_ctl = ap->ctl;
+
+        if (ap->flags & ATA_FLAG_MMIO)
+                writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
+        else
+                outb(ap->ctl, ioaddr->ctl_addr);
+        tmp = ata_wait_idle(ap);
+
+        ap->ops->irq_clear(ap);
+
+        return tmp;
+}
+
+static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
+{
+        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
+        u8 host_stat, post_stat, status;
+
+        status = ata_busy_wait(ap, bits, 1000);
+        if (status & bits)
+                DPRINTK("abnormal status 0x%X\n", status);
+
+        /* get controller status; clear intr, err bits */
+        if (ap->flags & ATA_FLAG_MMIO) {
+                void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
+                host_stat = readb(mmio + ATA_DMA_STATUS);
+                writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
+                       mmio + ATA_DMA_STATUS);
+
+                post_stat = readb(mmio + ATA_DMA_STATUS);
+        } else {
+                host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+                outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
+                     ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+
+                post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+        }
+
+        VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
+                host_stat, post_stat, status);
+
+        return status;
+}
+
+static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
+{
+        return ap->ops->scr_read(ap, reg);
+}
+
+static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
+{
+        ap->ops->scr_write(ap, reg, val);
+}
+
+static inline unsigned int sata_dev_present(struct ata_port *ap)
+{
+        return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
+}
+
+static inline int ata_try_flush_cache(struct ata_device *dev)
+{
+        return ata_id_wcache_enabled(dev->id) ||
+               ata_id_has_flush(dev->id) ||
+               ata_id_has_flush_ext(dev->id);
+}
+
+#endif /* __LINUX_LIBATA_H__ */
diff --git a/include/linux/libps2.h b/include/linux/libps2.h
new file mode 100644
index 000000000000..923bdbc6d9e4
--- /dev/null
+++ b/include/linux/libps2.h
@@ -0,0 +1,50 @@
+#ifndef _LIBPS2_H
+#define _LIBPS2_H
+
+/*
+ * Copyright (C) 1999-2002 Vojtech Pavlik
+ * Copyright (C) 2004 Dmitry Torokhov
+ *
+ * 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.
+ */
+
+
+#define PS2_CMD_GETID           0x02f2
+#define PS2_CMD_RESET_BAT       0x02ff
+
+#define PS2_RET_BAT             0xaa
+#define PS2_RET_ID              0x00
+#define PS2_RET_ACK             0xfa
+#define PS2_RET_NAK             0xfe
+
+#define PS2_FLAG_ACK            1       /* Waiting for ACK/NAK */
+#define PS2_FLAG_CMD            2       /* Waiting for command to finish */
+#define PS2_FLAG_CMD1           4       /* Waiting for the first byte of command response */
+#define PS2_FLAG_WAITID         8       /* Command execiting is GET ID */
+
+struct ps2dev {
+        struct serio *serio;
+
+        /* Ensures that only one command is executing at a time */
+        struct semaphore cmd_sem;
+
+        /* Used to signal completion from interrupt handler */
+        wait_queue_head_t wait;
+
+        unsigned long flags;
+        unsigned char cmdbuf[6];
+        unsigned char cmdcnt;
+        unsigned char nak;
+};
+
+void ps2_init(struct ps2dev *ps2dev, struct serio *serio);
+int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout);
+int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command);
+int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command);
+int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data);
+int ps2_handle_response(struct ps2dev *ps2dev, unsigned char data);
+void ps2_cmd_aborted(struct ps2dev *ps2dev);
+
+#endif /* _LIBPS2_H */
diff --git a/include/linux/limits.h b/include/linux/limits.h
new file mode 100644
index 000000000000..eaf2e099f125
--- /dev/null
+++ b/include/linux/limits.h
@@ -0,0 +1,22 @@
+#ifndef _LINUX_LIMITS_H
+#define _LINUX_LIMITS_H
+
+#define NR_OPEN         1024
+
+#define NGROUPS_MAX    65536    /* supplemental group IDs are available */
+#define ARG_MAX       131072    /* # bytes of args + environ for exec() */
+#define CHILD_MAX        999    /* no limit :-) */
+#define OPEN_MAX         256    /* # open files a process may have */
+#define LINK_MAX         127    /* # links a file may have */
+#define MAX_CANON        255    /* size of the canonical input queue */
+#define MAX_INPUT        255    /* size of the type-ahead buffer */
+#define NAME_MAX         255    /* # chars in a file name */
+#define PATH_MAX        4096    /* # chars in a path name including nul */
+#define PIPE_BUF        4096    /* # bytes in atomic write to a pipe */
+#define XATTR_NAME_MAX   255    /* # chars in an extended attribute name */
+#define XATTR_SIZE_MAX 65536    /* size of an extended attribute value (64k) */
+#define XATTR_LIST_MAX 65536    /* size of extended attribute namelist (64k) */
+
+#define RTSIG_MAX         32
+
+#endif
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
new file mode 100644
index 000000000000..338f7795d8a0
--- /dev/null
+++ b/include/linux/linkage.h
@@ -0,0 +1,47 @@
+#ifndef _LINUX_LINKAGE_H
+#define _LINUX_LINKAGE_H
+
+#include <linux/config.h>
+#include <asm/linkage.h>
+
+#ifdef __cplusplus
+#define CPP_ASMLINKAGE extern "C"
+#else
+#define CPP_ASMLINKAGE
+#endif
+
+#ifndef asmlinkage
+#define asmlinkage CPP_ASMLINKAGE
+#endif
+
+#ifndef prevent_tail_call
+# define prevent_tail_call(ret) do { } while (0)
+#endif
+
+#ifndef __ALIGN
+#define __ALIGN         .align 4,0x90
+#define __ALIGN_STR     ".align 4,0x90"
+#endif
+
+#ifdef __ASSEMBLY__
+
+#define ALIGN __ALIGN
+#define ALIGN_STR __ALIGN_STR
+
+#define ENTRY(name) \
+  .globl name; \
+  ALIGN; \
+  name:
+
+#endif
+
+#define NORET_TYPE    /**/
+#define ATTRIB_NORET  __attribute__((noreturn))
+#define NORET_AND     noreturn,
+
+#ifndef FASTCALL
+#define FASTCALL(x)     x
+#define fastcall
+#endif
+
+#endif
diff --git a/include/linux/linux_logo.h b/include/linux/linux_logo.h
new file mode 100644
index 000000000000..9c01bde5bf1b
--- /dev/null
+++ b/include/linux/linux_logo.h
@@ -0,0 +1,37 @@
+#ifndef _LINUX_LINUX_LOGO_H
+#define _LINUX_LINUX_LOGO_H
+
+/*
+ *  Linux logo to be displayed on boot
+ *
+ *  Copyright (C) 1996 Larry Ewing (lewing@isc.tamu.edu)
+ *  Copyright (C) 1996,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ *  Copyright (C) 2001 Greg Banks <gnb@alphalink.com.au>
+ *  Copyright (C) 2001 Jan-Benedict Glaw <jbglaw@lug-owl.de>
+ *  Copyright (C) 2003 Geert Uytterhoeven <geert@linux-m68k.org>
+ *
+ *  Serial_console ascii image can be any size,
+ *  but should contain %s to display the version
+ */
+
+#include <linux/init.h>
+
+
+#define LINUX_LOGO_MONO         1       /* monochrome black/white */
+#define LINUX_LOGO_VGA16        2       /* 16 colors VGA text palette */
+#define LINUX_LOGO_CLUT224      3       /* 224 colors */
+#define LINUX_LOGO_GRAY256      4       /* 256 levels grayscale */
+
+
+struct linux_logo {
+        int type;                       /* one of LINUX_LOGO_* */
+        unsigned int width;
+        unsigned int height;
+        unsigned int clutsize;          /* LINUX_LOGO_CLUT224 only */
+        const unsigned char *clut;      /* LINUX_LOGO_CLUT224 only */
+        const unsigned char *data;
+};
+
+extern const struct linux_logo *fb_find_logo(int depth);
+
+#endif /* _LINUX_LINUX_LOGO_H */
diff --git a/include/linux/list.h b/include/linux/list.h
new file mode 100644
index 000000000000..dd7cd54fa831
--- /dev/null
+++ b/include/linux/list.h
@@ -0,0 +1,707 @@
+#ifndef _LINUX_LIST_H
+#define _LINUX_LIST_H
+
+#ifdef __KERNEL__
+
+#include <linux/stddef.h>
+#include <linux/prefetch.h>
+#include <asm/system.h>
+
+/*
+ * These are non-NULL pointers that will result in page faults
+ * under normal circumstances, used to verify that nobody uses
+ * non-initialized list entries.
+ */
+#define LIST_POISON1  ((void *) 0x00100100)
+#define LIST_POISON2  ((void *) 0x00200200)
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+struct list_head {
+        struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+        struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+        (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new,
+                              struct list_head *prev,
+                              struct list_head *next)
+{
+        next->prev = new;
+        new->next = next;
+        new->prev = prev;
+        prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+        __list_add(new, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+        __list_add(new, head->prev, head);
+}
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add_rcu(struct list_head * new,
+                struct list_head * prev, struct list_head * next)
+{
+        new->next = next;
+        new->prev = prev;
+        smp_wmb();
+        next->prev = new;
+        prev->next = new;
+}
+
+/**
+ * list_add_rcu - add a new entry to rcu-protected list
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as list_add_rcu()
+ * or list_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * list_for_each_entry_rcu().
+ */
+static inline void list_add_rcu(struct list_head *new, struct list_head *head)
+{
+        __list_add_rcu(new, head, head->next);
+}
+
+/**
+ * list_add_tail_rcu - add a new entry to rcu-protected list
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as list_add_tail_rcu()
+ * or list_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * list_for_each_entry_rcu().
+ */
+static inline void list_add_tail_rcu(struct list_head *new,
+                                        struct list_head *head)
+{
+        __list_add_rcu(new, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+        next->prev = prev;
+        prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+        __list_del(entry->prev, entry->next);
+        entry->next = LIST_POISON1;
+        entry->prev = LIST_POISON2;
+}
+
+/**
+ * list_del_rcu - deletes entry from list without re-initialization
+ * @entry: the element to delete from the list.
+ *
+ * Note: list_empty on entry does not return true after this,
+ * the entry is in an undefined state. It is useful for RCU based
+ * lockfree traversal.
+ *
+ * In particular, it means that we can not poison the forward
+ * pointers that may still be used for walking the list.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as list_del_rcu()
+ * or list_add_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * list_for_each_entry_rcu().
+ *
+ * Note that the caller is not permitted to immediately free
+ * the newly deleted entry.  Instead, either synchronize_kernel()
+ * or call_rcu() must be used to defer freeing until an RCU
+ * grace period has elapsed.
+ */
+static inline void list_del_rcu(struct list_head *entry)
+{
+        __list_del(entry->prev, entry->next);
+        entry->prev = LIST_POISON2;
+}
+
+/*
+ * list_replace_rcu - replace old entry by new one
+ * @old : the element to be replaced
+ * @new : the new element to insert
+ *
+ * The old entry will be replaced with the new entry atomically.
+ */
+static inline void list_replace_rcu(struct list_head *old, struct list_head *new){
+        new->next = old->next;
+        new->prev = old->prev;
+        smp_wmb();
+        new->next->prev = new;
+        new->prev->next = new;
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+        __list_del(entry->prev, entry->next);
+        INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_move - delete from one list and add as another's head
+ * @list: the entry to move
+ * @head: the head that will precede our entry
+ */
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add(list, head);
+}
+
+/**
+ * list_move_tail - delete from one list and add as another's tail
+ * @list: the entry to move
+ * @head: the head that will follow our entry
+ */
+static inline void list_move_tail(struct list_head *list,
+                                  struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add_tail(list, head);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(const struct list_head *head)
+{
+        return head->next == head;
+}
+
+/**
+ * list_empty_careful - tests whether a list is
+ * empty _and_ checks that no other CPU might be
+ * in the process of still modifying either member
+ *
+ * NOTE: using list_empty_careful() without synchronization
+ * can only be safe if the only activity that can happen
+ * to the list entry is list_del_init(). Eg. it cannot be used
+ * if another CPU could re-list_add() it.
+ *
+ * @head: the list to test.
+ */
+static inline int list_empty_careful(const struct list_head *head)
+{
+        struct list_head *next = head->next;
+        return (next == head) && (next == head->prev);
+}
+
+static inline void __list_splice(struct list_head *list,
+                                 struct list_head *head)
+{
+        struct list_head *first = list->next;
+        struct list_head *last = list->prev;
+        struct list_head *at = head->next;
+
+        first->prev = head;
+        head->next = first;
+
+        last->next = at;
+        at->prev = last;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+        if (!list_empty(list))
+                __list_splice(list, head);
+}
+
+/**
+ * list_splice_init - join two lists and reinitialise the emptied list.
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_init(struct list_head *list,
+                                    struct list_head *head)
+{
+        if (!list_empty(list)) {
+                __list_splice(list, head);
+                INIT_LIST_HEAD(list);
+        }
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:        the &struct list_head pointer.
+ * @type:       the type of the struct this is embedded in.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+        container_of(ptr, type, member)
+
+/**
+ * list_for_each        -       iterate over a list
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @head:       the head for your list.
+ */
+#define list_for_each(pos, head) \
+        for (pos = (head)->next; prefetch(pos->next), pos != (head); \
+                pos = pos->next)
+
+/**
+ * __list_for_each      -       iterate over a list
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @head:       the head for your list.
+ *
+ * This variant differs from list_for_each() in that it's the
+ * simplest possible list iteration code, no prefetching is done.
+ * Use this for code that knows the list to be very short (empty
+ * or 1 entry) most of the time.
+ */
+#define __list_for_each(pos, head) \
+        for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_prev   -       iterate over a list backwards
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @head:       the head for your list.
+ */
+#define list_for_each_prev(pos, head) \
+        for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
+                pos = pos->prev)
+
+/**
+ * list_for_each_safe   -       iterate over a list safe against removal of list entry
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @n:          another &struct list_head to use as temporary storage
+ * @head:       the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+        for (pos = (head)->next, n = pos->next; pos != (head); \
+                pos = n, n = pos->next)
+
+/**
+ * list_for_each_entry  -       iterate over list of given type
+ * @pos:        the type * to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_for_each_entry(pos, head, member)                          \
+        for (pos = list_entry((head)->next, typeof(*pos), member);      \
+             prefetch(pos->member.next), &pos->member != (head);        \
+             pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * @pos:        the type * to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_reverse(pos, head, member)                  \
+        for (pos = list_entry((head)->prev, typeof(*pos), member);      \
+             prefetch(pos->member.prev), &pos->member != (head);        \
+             pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+/**
+ * list_prepare_entry - prepare a pos entry for use as a start point in
+ *                      list_for_each_entry_continue
+ * @pos:        the type * to use as a start point
+ * @head:       the head of the list
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_prepare_entry(pos, head, member) \
+        ((pos) ? : list_entry(head, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_continue -       iterate over list of given type
+ *                      continuing after existing point
+ * @pos:        the type * to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_continue(pos, head, member)                 \
+        for (pos = list_entry(pos->member.next, typeof(*pos), member);  \
+             prefetch(pos->member.next), &pos->member != (head);        \
+             pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @pos:        the type * to use as a loop counter.
+ * @n:          another type * to use as temporary storage
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member)                  \
+        for (pos = list_entry((head)->next, typeof(*pos), member),      \
+                n = list_entry(pos->member.next, typeof(*pos), member); \
+             &pos->member != (head);                                    \
+             pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/**
+ * list_for_each_rcu    -       iterate over an rcu-protected list
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @head:       the head for your list.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as list_add_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define list_for_each_rcu(pos, head) \
+        for (pos = (head)->next; prefetch(pos->next), pos != (head); \
+                pos = rcu_dereference(pos->next))
+
+#define __list_for_each_rcu(pos, head) \
+        for (pos = (head)->next; pos != (head); \
+                pos = rcu_dereference(pos->next))
+
+/**
+ * list_for_each_safe_rcu       -       iterate over an rcu-protected list safe
+ *                                      against removal of list entry
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @n:          another &struct list_head to use as temporary storage
+ * @head:       the head for your list.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as list_add_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define list_for_each_safe_rcu(pos, n, head) \
+        for (pos = (head)->next, n = pos->next; pos != (head); \
+                pos = rcu_dereference(n), n = pos->next)
+
+/**
+ * list_for_each_entry_rcu      -       iterate over rcu list of given type
+ * @pos:        the type * to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as list_add_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define list_for_each_entry_rcu(pos, head, member)                      \
+        for (pos = list_entry((head)->next, typeof(*pos), member);      \
+             prefetch(pos->member.next), &pos->member != (head);        \
+             pos = rcu_dereference(list_entry(pos->member.next,         \
+                                        typeof(*pos), member)))
+
+
+/**
+ * list_for_each_continue_rcu   -       iterate over an rcu-protected list
+ *                      continuing after existing point.
+ * @pos:        the &struct list_head to use as a loop counter.
+ * @head:       the head for your list.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as list_add_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define list_for_each_continue_rcu(pos, head) \
+        for ((pos) = (pos)->next; prefetch((pos)->next), (pos) != (head); \
+                (pos) = rcu_dereference((pos)->next))
+
+/*
+ * Double linked lists with a single pointer list head.
+ * Mostly useful for hash tables where the two pointer list head is
+ * too wasteful.
+ * You lose the ability to access the tail in O(1).
+ */
+
+struct hlist_head {
+        struct hlist_node *first;
+};
+
+struct hlist_node {
+        struct hlist_node *next, **pprev;
+};
+
+#define HLIST_HEAD_INIT { .first = NULL }
+#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
+#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)
+
+static inline int hlist_unhashed(const struct hlist_node *h)
+{
+        return !h->pprev;
+}
+
+static inline int hlist_empty(const struct hlist_head *h)
+{
+        return !h->first;
+}
+
+static inline void __hlist_del(struct hlist_node *n)
+{
+        struct hlist_node *next = n->next;
+        struct hlist_node **pprev = n->pprev;
+        *pprev = next;
+        if (next)
+                next->pprev = pprev;
+}
+
+static inline void hlist_del(struct hlist_node *n)
+{
+        __hlist_del(n);
+        n->next = LIST_POISON1;
+        n->pprev = LIST_POISON2;
+}
+
+/**
+ * hlist_del_rcu - deletes entry from hash list without re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: list_unhashed() on entry does not return true after this,
+ * the entry is in an undefined state. It is useful for RCU based
+ * lockfree traversal.
+ *
+ * In particular, it means that we can not poison the forward
+ * pointers that may still be used for walking the hash list.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_add_head_rcu()
+ * or hlist_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_for_each_entry().
+ */
+static inline void hlist_del_rcu(struct hlist_node *n)
+{
+        __hlist_del(n);
+        n->pprev = LIST_POISON2;
+}
+
+static inline void hlist_del_init(struct hlist_node *n)
+{
+        if (n->pprev)  {
+                __hlist_del(n);
+                INIT_HLIST_NODE(n);
+        }
+}
+
+static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+{
+        struct hlist_node *first = h->first;
+        n->next = first;
+        if (first)
+                first->pprev = &n->next;
+        h->first = n;
+        n->pprev = &h->first;
+}
+
+
+/**
+ * hlist_add_head_rcu - adds the specified element to the specified hlist,
+ * while permitting racing traversals.
+ * @n: the element to add to the hash list.
+ * @h: the list to add to.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_add_head_rcu()
+ * or hlist_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_for_each_rcu(), used to prevent memory-consistency
+ * problems on Alpha CPUs.  Regardless of the type of CPU, the
+ * list-traversal primitive must be guarded by rcu_read_lock().
+ */
+static inline void hlist_add_head_rcu(struct hlist_node *n,
+                                        struct hlist_head *h)
+{
+        struct hlist_node *first = h->first;
+        n->next = first;
+        n->pprev = &h->first;
+        smp_wmb();
+        if (first)
+                first->pprev = &n->next;
+        h->first = n;
+}
+
+/* next must be != NULL */
+static inline void hlist_add_before(struct hlist_node *n,
+                                        struct hlist_node *next)
+{
+        n->pprev = next->pprev;
+        n->next = next;
+        next->pprev = &n->next;
+        *(n->pprev) = n;
+}
+
+static inline void hlist_add_after(struct hlist_node *n,
+                                        struct hlist_node *next)
+{
+        next->next = n->next;
+        n->next = next;
+        next->pprev = &n->next;
+
+        if(next->next)
+                next->next->pprev  = &next->next;
+}
+
+#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
+
+#define hlist_for_each(pos, head) \
+        for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
+             pos = pos->next)
+
+#define hlist_for_each_safe(pos, n, head) \
+        for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
+             pos = n)
+
+#define hlist_for_each_rcu(pos, head) \
+        for ((pos) = (head)->first; pos && ({ prefetch((pos)->next); 1; }); \
+                (pos) = rcu_dereference((pos)->next))
+
+/**
+ * hlist_for_each_entry - iterate over list of given type
+ * @tpos:       the type * to use as a loop counter.
+ * @pos:        the &struct hlist_node to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry(tpos, pos, head, member)                    \
+        for (pos = (head)->first;                                        \
+             pos && ({ prefetch(pos->next); 1;}) &&                      \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+/**
+ * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
+ * @tpos:       the type * to use as a loop counter.
+ * @pos:        the &struct hlist_node to use as a loop counter.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_continue(tpos, pos, member)                 \
+        for (pos = (pos)->next;                                          \
+             pos && ({ prefetch(pos->next); 1;}) &&                      \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+/**
+ * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
+ * @tpos:       the type * to use as a loop counter.
+ * @pos:        the &struct hlist_node to use as a loop counter.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_from(tpos, pos, member)                     \
+        for (; pos && ({ prefetch(pos->next); 1;}) &&                    \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+/**
+ * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @tpos:       the type * to use as a loop counter.
+ * @pos:        the &struct hlist_node to use as a loop counter.
+ * @n:          another &struct hlist_node to use as temporary storage
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_safe(tpos, pos, n, head, member)            \
+        for (pos = (head)->first;                                        \
+             pos && ({ n = pos->next; 1; }) &&                           \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = n)
+
+/**
+ * hlist_for_each_entry_rcu - iterate over rcu list of given type
+ * @pos:        the type * to use as a loop counter.
+ * @pos:        the &struct hlist_node to use as a loop counter.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ */
+#define hlist_for_each_entry_rcu(tpos, pos, head, member)                \
+        for (pos = (head)->first;                                        \
+             pos && ({ prefetch(pos->next); 1;}) &&                      \
+                ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = rcu_dereference(pos->next))
+
+#else
+#warning "don't include kernel headers in userspace"
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/llc.h b/include/linux/llc.h
new file mode 100644
index 000000000000..09f2e6d0e9eb
--- /dev/null
+++ b/include/linux/llc.h
@@ -0,0 +1,80 @@
+#ifndef __LINUX_LLC_H
+#define __LINUX_LLC_H
+/*
+ * IEEE 802.2 User Interface SAPs for Linux, data structures and indicators.
+ *
+ * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
+ *
+ * This program can be redistributed or modified under the terms of the
+ * GNU General Public License as published by the Free Software Foundation.
+ * This program is distributed without any warranty or implied warranty
+ * of merchantability or fitness for a particular purpose.
+ *
+ * See the GNU General Public License for more details.
+ */
+#define __LLC_SOCK_SIZE__ 16    /* sizeof(sockaddr_llc), word align. */
+struct sockaddr_llc {
+        sa_family_t     sllc_family;    /* AF_LLC */
+        sa_family_t     sllc_arphrd;    /* ARPHRD_ETHER */
+        unsigned char   sllc_test;
+        unsigned char   sllc_xid;
+        unsigned char   sllc_ua;        /* UA data, only for SOCK_STREAM. */
+        unsigned char   sllc_sap;
+        unsigned char   sllc_mac[IFHWADDRLEN];
+        unsigned char   __pad[__LLC_SOCK_SIZE__ - sizeof(sa_family_t) * 2 -
+                              sizeof(unsigned char) * 4 - IFHWADDRLEN];
+};
+
+/* sockopt definitions. */
+enum llc_sockopts {
+        LLC_OPT_UNKNOWN = 0,
+        LLC_OPT_RETRY,          /* max retrans attempts. */
+        LLC_OPT_SIZE,           /* max PDU size (octets). */
+        LLC_OPT_ACK_TMR_EXP,    /* ack expire time (secs). */
+        LLC_OPT_P_TMR_EXP,      /* pf cycle expire time (secs). */
+        LLC_OPT_REJ_TMR_EXP,    /* rej sent expire time (secs). */
+        LLC_OPT_BUSY_TMR_EXP,   /* busy state expire time (secs). */
+        LLC_OPT_TX_WIN,         /* tx window size. */
+        LLC_OPT_RX_WIN,         /* rx window size. */
+        LLC_OPT_MAX
+};
+
+#define LLC_OPT_MAX_RETRY        100
+#define LLC_OPT_MAX_SIZE        4196
+#define LLC_OPT_MAX_WIN          127
+#define LLC_OPT_MAX_ACK_TMR_EXP   60
+#define LLC_OPT_MAX_P_TMR_EXP     60
+#define LLC_OPT_MAX_REJ_TMR_EXP   60
+#define LLC_OPT_MAX_BUSY_TMR_EXP  60
+
+/* LLC SAP types. */
+#define LLC_SAP_NULL    0x00            /* NULL SAP.                    */
+#define LLC_SAP_LLC     0x02            /* LLC Sublayer Managment.      */
+#define LLC_SAP_SNA     0x04            /* SNA Path Control.            */
+#define LLC_SAP_PNM     0x0E            /* Proway Network Managment.    */      
+#define LLC_SAP_IP      0x06            /* TCP/IP.                      */
+#define LLC_SAP_BSPAN   0x42            /* Bridge Spanning Tree Proto   */
+#define LLC_SAP_MMS     0x4E            /* Manufacturing Message Srv.   */
+#define LLC_SAP_8208    0x7E            /* ISO 8208                     */
+#define LLC_SAP_3COM    0x80            /* 3COM.                        */
+#define LLC_SAP_PRO     0x8E            /* Proway Active Station List   */
+#define LLC_SAP_SNAP    0xAA            /* SNAP.                        */
+#define LLC_SAP_BANYAN  0xBC            /* Banyan.                      */
+#define LLC_SAP_IPX     0xE0            /* IPX/SPX.                     */
+#define LLC_SAP_NETBEUI 0xF0            /* NetBEUI.                     */
+#define LLC_SAP_LANMGR  0xF4            /* LanManager.                  */
+#define LLC_SAP_IMPL    0xF8            /* IMPL                         */
+#define LLC_SAP_DISC    0xFC            /* Discovery                    */
+#define LLC_SAP_OSI     0xFE            /* OSI Network Layers.          */
+#define LLC_SAP_LAR     0xDC            /* LAN Address Resolution       */
+#define LLC_SAP_RM      0xD4            /* Resource Management          */
+#define LLC_SAP_GLOBAL  0xFF            /* Global SAP.                  */
+
+#ifdef __KERNEL__
+#define LLC_SAP_DYN_START       0xC0
+#define LLC_SAP_DYN_STOP        0xDE
+#define LLC_SAP_DYN_TRIES       4
+
+#define llc_ui_skb_cb(__skb) ((struct sockaddr_llc *)&((__skb)->cb[0]))
+#endif /* __KERNEL__ */
+#endif /* __LINUX_LLC_H */
diff --git a/include/linux/lockd/bind.h b/include/linux/lockd/bind.h
new file mode 100644
index 000000000000..b054debef2e0
--- /dev/null
+++ b/include/linux/lockd/bind.h
@@ -0,0 +1,36 @@
+/*
+ * linux/include/linux/lockd/bind.h
+ *
+ * This is the part of lockd visible to nfsd and the nfs client.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_BIND_H
+#define LINUX_LOCKD_BIND_H
+
+#include <linux/lockd/nlm.h>
+
+/* Dummy declarations */
+struct svc_rqst;
+
+/*
+ * This is the set of functions for lockd->nfsd communication
+ */
+struct nlmsvc_binding {
+        u32                     (*fopen)(struct svc_rqst *,
+                                                struct nfs_fh *,
+                                                struct file **);
+        void                    (*fclose)(struct file *);
+};
+
+extern struct nlmsvc_binding *  nlmsvc_ops;
+
+/*
+ * Functions exported by the lockd module
+ */
+extern int      nlmclnt_proc(struct inode *, int, struct file_lock *);
+extern int      lockd_up(void);
+extern void     lockd_down(void);
+
+#endif /* LINUX_LOCKD_BIND_H */
diff --git a/include/linux/lockd/debug.h b/include/linux/lockd/debug.h
new file mode 100644
index 000000000000..34b2b7f33c3b
--- /dev/null
+++ b/include/linux/lockd/debug.h
@@ -0,0 +1,57 @@
+/*
+ * linux/include/linux/lockd/debug.h
+ *
+ * Debugging stuff.
+ *
+ * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_DEBUG_H
+#define LINUX_LOCKD_DEBUG_H
+
+#ifdef __KERNEL__
+
+#include <linux/sunrpc/debug.h>
+
+/*
+ * Enable lockd debugging.
+ * Requires RPC_DEBUG.
+ */
+#ifdef RPC_DEBUG
+# define LOCKD_DEBUG            1
+#endif
+
+#undef ifdebug
+#if defined(RPC_DEBUG) && defined(LOCKD_DEBUG)
+# define ifdebug(flag)          if (unlikely(nlm_debug & NLMDBG_##flag))
+#else
+# define ifdebug(flag)          if (0)
+#endif
+
+#endif /* __KERNEL__ */
+
+/*
+ * Debug flags
+ */
+#define NLMDBG_SVC              0x0001
+#define NLMDBG_CLIENT           0x0002
+#define NLMDBG_CLNTLOCK         0x0004
+#define NLMDBG_SVCLOCK          0x0008
+#define NLMDBG_MONITOR          0x0010
+#define NLMDBG_CLNTSUBS         0x0020
+#define NLMDBG_SVCSUBS          0x0040
+#define NLMDBG_HOSTCACHE        0x0080
+#define NLMDBG_XDR              0x0100
+#define NLMDBG_ALL              0x7fff
+
+
+/*
+ * Support for printing NLM cookies in dprintk()
+ */
+#ifdef RPC_DEBUG
+struct nlm_cookie;
+/* Call this function with the BKL held (it uses a static buffer) */
+extern const char *nlmdbg_cookie2a(const struct nlm_cookie *);
+#endif
+
+#endif /* LINUX_LOCKD_DEBUG_H */
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
new file mode 100644
index 000000000000..0d9d22578212
--- /dev/null
+++ b/include/linux/lockd/lockd.h
@@ -0,0 +1,224 @@
+/*
+ * linux/include/linux/lockd/lockd.h
+ *
+ * General-purpose lockd include file.
+ *
+ * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_LOCKD_H
+#define LINUX_LOCKD_LOCKD_H
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/in.h>
+#include <linux/fs.h>
+#include <linux/utsname.h>
+#include <linux/nfsd/nfsfh.h>
+#include <linux/lockd/bind.h>
+#include <linux/lockd/xdr.h>
+#ifdef CONFIG_LOCKD_V4
+#include <linux/lockd/xdr4.h>
+#endif
+#include <linux/lockd/debug.h>
+
+/*
+ * Version string
+ */
+#define LOCKD_VERSION           "0.5"
+
+/*
+ * Default timeout for RPC calls (seconds)
+ */
+#define LOCKD_DFLT_TIMEO        10
+
+/*
+ * Lockd host handle (used both by the client and server personality).
+ */
+struct nlm_host {
+        struct nlm_host *       h_next;         /* linked list (hash table) */
+        struct sockaddr_in      h_addr;         /* peer address */
+        struct rpc_clnt *       h_rpcclnt;      /* RPC client to talk to peer */
+        char                    h_name[20];     /* remote hostname */
+        u32                     h_version;      /* interface version */
+        unsigned short          h_proto;        /* transport proto */
+        unsigned short          h_reclaiming : 1,
+                                h_server     : 1, /* server side, not client side */
+                                h_inuse      : 1,
+                                h_killed     : 1,
+                                h_monitored  : 1;
+        wait_queue_head_t       h_gracewait;    /* wait while reclaiming */
+        u32                     h_state;        /* pseudo-state counter */
+        u32                     h_nsmstate;     /* true remote NSM state */
+        u32                     h_pidcount;     /* Pseudopids */
+        atomic_t                h_count;        /* reference count */
+        struct semaphore        h_sema;         /* mutex for pmap binding */
+        unsigned long           h_nextrebind;   /* next portmap call */
+        unsigned long           h_expires;      /* eligible for GC */
+        struct list_head        h_lockowners;   /* Lockowners for the client */
+        spinlock_t              h_lock;
+};
+
+/*
+ * Map an fl_owner_t into a unique 32-bit "pid"
+ */
+struct nlm_lockowner {
+        struct list_head list;
+        atomic_t count;
+
+        struct nlm_host *host;
+        fl_owner_t owner;
+        uint32_t pid;
+};
+
+/*
+ * Memory chunk for NLM client RPC request.
+ */
+#define NLMCLNT_OHSIZE          (sizeof(system_utsname.nodename)+10)
+struct nlm_rqst {
+        unsigned int            a_flags;        /* initial RPC task flags */
+        struct nlm_host *       a_host;         /* host handle */
+        struct nlm_args         a_args;         /* arguments */
+        struct nlm_res          a_res;          /* result */
+        char                    a_owner[NLMCLNT_OHSIZE];
+};
+
+/*
+ * This struct describes a file held open by lockd on behalf of
+ * an NFS client.
+ */
+struct nlm_file {
+        struct nlm_file *       f_next;         /* linked list */
+        struct nfs_fh           f_handle;       /* NFS file handle */
+        struct file *           f_file;         /* VFS file pointer */
+        struct nlm_share *      f_shares;       /* DOS shares */
+        struct nlm_block *      f_blocks;       /* blocked locks */
+        unsigned int            f_locks;        /* guesstimate # of locks */
+        unsigned int            f_count;        /* reference count */
+        struct semaphore        f_sema;         /* avoid concurrent access */
+        int                     f_hash;         /* hash of f_handle */
+};
+
+/*
+ * This is a server block (i.e. a lock requested by some client which
+ * couldn't be granted because of a conflicting lock).
+ */
+#define NLM_NEVER               (~(unsigned long) 0)
+struct nlm_block {
+        struct nlm_block *      b_next;         /* linked list (all blocks) */
+        struct nlm_block *      b_fnext;        /* linked list (per file) */
+        struct nlm_rqst         b_call;         /* RPC args & callback info */
+        struct svc_serv *       b_daemon;       /* NLM service */
+        struct nlm_host *       b_host;         /* host handle for RPC clnt */
+        unsigned long           b_when;         /* next re-xmit */
+        unsigned int            b_id;           /* block id */
+        unsigned char           b_queued;       /* re-queued */
+        unsigned char           b_granted;      /* VFS granted lock */
+        unsigned char           b_incall;       /* doing callback */
+        unsigned char           b_done;         /* callback complete */
+        struct nlm_file *       b_file;         /* file in question */
+};
+
+/*
+ * Valid actions for nlmsvc_traverse_files
+ */
+#define NLM_ACT_CHECK           0               /* check for locks */
+#define NLM_ACT_MARK            1               /* mark & sweep */
+#define NLM_ACT_UNLOCK          2               /* release all locks */
+
+/*
+ * Global variables
+ */
+extern struct rpc_program       nlm_program;
+extern struct svc_procedure     nlmsvc_procedures[];
+#ifdef CONFIG_LOCKD_V4
+extern struct svc_procedure     nlmsvc_procedures4[];
+#endif
+extern int                      nlmsvc_grace_period;
+extern unsigned long            nlmsvc_timeout;
+
+/*
+ * Lockd client functions
+ */
+struct nlm_rqst * nlmclnt_alloc_call(void);
+int               nlmclnt_block(struct nlm_host *, struct file_lock *, u32 *);
+int               nlmclnt_cancel(struct nlm_host *, struct file_lock *);
+u32               nlmclnt_grant(struct nlm_lock *);
+void              nlmclnt_recovery(struct nlm_host *, u32);
+int               nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
+int               nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *);
+void              nlmclnt_freegrantargs(struct nlm_rqst *);
+
+/*
+ * Host cache
+ */
+struct nlm_host * nlmclnt_lookup_host(struct sockaddr_in *, int, int);
+struct nlm_host * nlmsvc_lookup_host(struct svc_rqst *);
+struct nlm_host * nlm_lookup_host(int server, struct sockaddr_in *, int, int);
+struct rpc_clnt * nlm_bind_host(struct nlm_host *);
+void              nlm_rebind_host(struct nlm_host *);
+struct nlm_host * nlm_get_host(struct nlm_host *);
+void              nlm_release_host(struct nlm_host *);
+void              nlm_shutdown_hosts(void);
+extern struct nlm_host *nlm_find_client(void);
+
+
+/*
+ * Server-side lock handling
+ */
+int               nlmsvc_async_call(struct nlm_rqst *, u32, rpc_action);
+u32               nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
+                                        struct nlm_lock *, int, struct nlm_cookie *);
+u32               nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
+u32               nlmsvc_testlock(struct nlm_file *, struct nlm_lock *,
+                                        struct nlm_lock *);
+u32               nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
+unsigned long     nlmsvc_retry_blocked(void);
+int               nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
+                                        int action);
+void      nlmsvc_grant_reply(struct svc_rqst *, struct nlm_cookie *, u32);
+
+/*
+ * File handling for the server personality
+ */
+u32               nlm_lookup_file(struct svc_rqst *, struct nlm_file **,
+                                        struct nfs_fh *);
+void              nlm_release_file(struct nlm_file *);
+void              nlmsvc_mark_resources(void);
+void              nlmsvc_free_host_resources(struct nlm_host *);
+void              nlmsvc_invalidate_all(void);
+
+static __inline__ struct inode *
+nlmsvc_file_inode(struct nlm_file *file)
+{
+        return file->f_file->f_dentry->d_inode;
+}
+
+/*
+ * Compare two host addresses (needs modifying for ipv6)
+ */
+static __inline__ int
+nlm_cmp_addr(struct sockaddr_in *sin1, struct sockaddr_in *sin2)
+{
+        return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
+}
+
+/*
+ * Compare two NLM locks.
+ * When the second lock is of type F_UNLCK, this acts like a wildcard.
+ */
+static __inline__ int
+nlm_compare_locks(struct file_lock *fl1, struct file_lock *fl2)
+{
+        return  fl1->fl_pid   == fl2->fl_pid
+             && fl1->fl_start == fl2->fl_start
+             && fl1->fl_end   == fl2->fl_end
+             &&(fl1->fl_type  == fl2->fl_type || fl2->fl_type == F_UNLCK);
+}
+
+extern struct lock_manager_operations nlmsvc_lock_operations;
+
+#endif /* __KERNEL__ */
+
+#endif /* LINUX_LOCKD_LOCKD_H */
diff --git a/include/linux/lockd/nlm.h b/include/linux/lockd/nlm.h
new file mode 100644
index 000000000000..869b630cba24
--- /dev/null
+++ b/include/linux/lockd/nlm.h
@@ -0,0 +1,58 @@
+/*
+ * linux/include/linux/lockd/nlm.h
+ *
+ * Declarations for the Network Lock Manager protocol.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_NLM_H
+#define LINUX_LOCKD_NLM_H
+
+#include <linux/config.h>
+
+/* Maximum file offset in file_lock.fl_end */
+# define NLM_OFFSET_MAX         ((s32) 0x7fffffff)
+# define NLM4_OFFSET_MAX        ((s64) ((~(u64)0) >> 1))
+
+/* Return states for NLM */
+enum {
+        NLM_LCK_GRANTED                 = 0,
+        NLM_LCK_DENIED                  = 1,
+        NLM_LCK_DENIED_NOLOCKS          = 2,
+        NLM_LCK_BLOCKED                 = 3,
+        NLM_LCK_DENIED_GRACE_PERIOD     = 4,
+#ifdef CONFIG_LOCKD_V4
+        NLM_DEADLCK                     = 5,
+        NLM_ROFS                        = 6,
+        NLM_STALE_FH                    = 7,
+        NLM_FBIG                        = 8,
+        NLM_FAILED                      = 9,
+#endif
+};
+
+#define NLM_PROGRAM             100021
+
+#define NLMPROC_NULL            0
+#define NLMPROC_TEST            1
+#define NLMPROC_LOCK            2
+#define NLMPROC_CANCEL          3
+#define NLMPROC_UNLOCK          4
+#define NLMPROC_GRANTED         5
+#define NLMPROC_TEST_MSG        6
+#define NLMPROC_LOCK_MSG        7
+#define NLMPROC_CANCEL_MSG      8
+#define NLMPROC_UNLOCK_MSG      9
+#define NLMPROC_GRANTED_MSG     10
+#define NLMPROC_TEST_RES        11
+#define NLMPROC_LOCK_RES        12
+#define NLMPROC_CANCEL_RES      13
+#define NLMPROC_UNLOCK_RES      14
+#define NLMPROC_GRANTED_RES     15
+#define NLMPROC_NSM_NOTIFY      16              /* statd callback */
+#define NLMPROC_SHARE           20
+#define NLMPROC_UNSHARE         21
+#define NLMPROC_NM_LOCK         22
+#define NLMPROC_FREE_ALL        23
+
+#endif /* LINUX_LOCKD_NLM_H */
diff --git a/include/linux/lockd/share.h b/include/linux/lockd/share.h
new file mode 100644
index 000000000000..5d8aa325f140
--- /dev/null
+++ b/include/linux/lockd/share.h
@@ -0,0 +1,30 @@
+/*
+ * linux/include/linux/lockd/share.h
+ *
+ * DOS share management for lockd.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_SHARE_H
+#define LINUX_LOCKD_SHARE_H
+
+/*
+ * DOS share for a specific file
+ */
+struct nlm_share {
+        struct nlm_share *      s_next;         /* linked list */
+        struct nlm_host *       s_host;         /* client host */
+        struct nlm_file *       s_file;         /* shared file */
+        struct xdr_netobj       s_owner;        /* owner handle */
+        u32                     s_access;       /* access mode */
+        u32                     s_mode;         /* deny mode */
+};
+
+u32     nlmsvc_share_file(struct nlm_host *, struct nlm_file *,
+                                               struct nlm_args *);
+u32     nlmsvc_unshare_file(struct nlm_host *, struct nlm_file *,
+                                               struct nlm_args *);
+int     nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int);
+
+#endif /* LINUX_LOCKD_SHARE_H */
diff --git a/include/linux/lockd/sm_inter.h b/include/linux/lockd/sm_inter.h
new file mode 100644
index 000000000000..1080bb6ae315
--- /dev/null
+++ b/include/linux/lockd/sm_inter.h
@@ -0,0 +1,46 @@
+/*
+ * linux/include/linux/lockd/sm_inter.h
+ *
+ * Declarations for the kernel statd client.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_LOCKD_SM_INTER_H
+#define LINUX_LOCKD_SM_INTER_H
+
+#define SM_PROGRAM      100024
+#define SM_VERSION      1
+#define SM_STAT         1
+#define SM_MON          2
+#define SM_UNMON        3
+#define SM_UNMON_ALL    4
+#define SM_SIMU_CRASH   5
+#define SM_NOTIFY       6
+
+#define SM_MAXSTRLEN    1024
+
+/*
+ * Arguments for all calls to statd
+ */
+struct nsm_args {
+        u32             addr;           /* remote address */
+        u32             prog;           /* RPC callback info */
+        u32             vers;
+        u32             proc;
+        u32             proto;          /* protocol (udp/tcp) plus server/client flag */
+};
+
+/*
+ * Result returned by statd
+ */
+struct nsm_res {
+        u32             status;
+        u32             state;
+};
+
+int             nsm_monitor(struct nlm_host *);
+int             nsm_unmonitor(struct nlm_host *);
+extern u32      nsm_local_state;
+
+#endif /* LINUX_LOCKD_SM_INTER_H */
diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h
new file mode 100644
index 000000000000..d7a5cc4cfa97
--- /dev/null
+++ b/include/linux/lockd/xdr.h
@@ -0,0 +1,108 @@
+/*
+ * linux/include/linux/lockd/xdr.h
+ *
+ * XDR types for the NLM protocol
+ *
+ * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LOCKD_XDR_H
+#define LOCKD_XDR_H
+
+#include <linux/fs.h>
+#include <linux/nfs.h>
+#include <linux/sunrpc/xdr.h>
+
+#define NLM_MAXCOOKIELEN        32
+#define NLM_MAXSTRLEN           1024
+
+#define nlm_granted             __constant_htonl(NLM_LCK_GRANTED)
+#define nlm_lck_denied          __constant_htonl(NLM_LCK_DENIED)
+#define nlm_lck_denied_nolocks  __constant_htonl(NLM_LCK_DENIED_NOLOCKS)
+#define nlm_lck_blocked         __constant_htonl(NLM_LCK_BLOCKED)
+#define nlm_lck_denied_grace_period     __constant_htonl(NLM_LCK_DENIED_GRACE_PERIOD)
+
+/* Lock info passed via NLM */
+struct nlm_lock {
+        char *                  caller;
+        int                     len;    /* length of "caller" */
+        struct nfs_fh           fh;
+        struct xdr_netobj       oh;
+        struct file_lock        fl;
+};
+
+/*
+ *      NLM cookies. Technically they can be 1K, but Linux only uses 8 bytes.
+ *      FreeBSD uses 16, Apple Mac OS X 10.3 uses 20. Therefore we set it to
+ *      32 bytes.
+ */
+ 
+struct nlm_cookie
+{
+        unsigned char data[NLM_MAXCOOKIELEN];
+        unsigned int len;
+};
+
+/*
+ * Generic lockd arguments for all but sm_notify
+ */
+struct nlm_args {
+        struct nlm_cookie       cookie;
+        struct nlm_lock         lock;
+        u32                     block;
+        u32                     reclaim;
+        u32                     state;
+        u32                     monitor;
+        u32                     fsm_access;
+        u32                     fsm_mode;
+};
+
+typedef struct nlm_args nlm_args;
+
+/*
+ * Generic lockd result
+ */
+struct nlm_res {
+        struct nlm_cookie       cookie;
+        u32                     status;
+        struct nlm_lock         lock;
+};
+
+/*
+ * statd callback when client has rebooted
+ */
+struct nlm_reboot {
+        char *          mon;
+        int             len;
+        u32             state;
+        u32             addr;
+        u32             vers;
+        u32             proto;
+};
+
+/*
+ * Contents of statd callback when monitored host rebooted
+ */
+#define NLMSVC_XDRSIZE          sizeof(struct nlm_args)
+
+int     nlmsvc_decode_testargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_encode_testres(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlmsvc_decode_lockargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_decode_cancargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_decode_unlockargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_encode_res(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlmsvc_decode_res(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlmsvc_encode_void(struct svc_rqst *, u32 *, void *);
+int     nlmsvc_decode_void(struct svc_rqst *, u32 *, void *);
+int     nlmsvc_decode_shareargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_encode_shareres(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlmsvc_decode_notify(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlmsvc_decode_reboot(struct svc_rqst *, u32 *, struct nlm_reboot *);
+/*
+int     nlmclt_encode_testargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+ */
+
+#endif /* LOCKD_XDR_H */
diff --git a/include/linux/lockd/xdr4.h b/include/linux/lockd/xdr4.h
new file mode 100644
index 000000000000..cee36e7c0548
--- /dev/null
+++ b/include/linux/lockd/xdr4.h
@@ -0,0 +1,46 @@
+/*
+ * linux/include/linux/lockd/xdr.h
+ *
+ * XDR types for the NLM protocol
+ *
+ * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LOCKD_XDR4_H
+#define LOCKD_XDR4_H
+
+#include <linux/fs.h>
+#include <linux/nfs.h>
+#include <linux/sunrpc/xdr.h>
+#include <linux/lockd/xdr.h>
+
+/* error codes new to NLMv4 */
+#define nlm4_deadlock           __constant_htonl(NLM_DEADLCK)
+#define nlm4_rofs               __constant_htonl(NLM_ROFS)
+#define nlm4_stale_fh           __constant_htonl(NLM_STALE_FH)
+#define nlm4_fbig               __constant_htonl(NLM_FBIG)
+#define nlm4_failed             __constant_htonl(NLM_FAILED)
+
+
+
+int     nlm4svc_decode_testargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_encode_testres(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlm4svc_decode_lockargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_decode_cancargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_decode_unlockargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_encode_res(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlm4svc_decode_res(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlm4svc_encode_void(struct svc_rqst *, u32 *, void *);
+int     nlm4svc_decode_void(struct svc_rqst *, u32 *, void *);
+int     nlm4svc_decode_shareargs(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_encode_shareres(struct svc_rqst *, u32 *, struct nlm_res *);
+int     nlm4svc_decode_notify(struct svc_rqst *, u32 *, struct nlm_args *);
+int     nlm4svc_decode_reboot(struct svc_rqst *, u32 *, struct nlm_reboot *);
+/*
+int     nlmclt_encode_testargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+int     nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
+ */
+
+#endif /* LOCKD_XDR4_H */
diff --git a/include/linux/loop.h b/include/linux/loop.h
new file mode 100644
index 000000000000..8220d9c9da00
--- /dev/null
+++ b/include/linux/loop.h
@@ -0,0 +1,161 @@
+#ifndef _LINUX_LOOP_H
+#define _LINUX_LOOP_H
+
+/*
+ * include/linux/loop.h
+ *
+ * Written by Theodore Ts'o, 3/29/93.
+ *
+ * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
+ * permitted under the GNU General Public License.
+ */
+
+#define LO_NAME_SIZE    64
+#define LO_KEY_SIZE     32
+
+#ifdef __KERNEL__
+#include <linux/bio.h>
+#include <linux/blkdev.h>
+#include <linux/spinlock.h>
+
+/* Possible states of device */
+enum {
+        Lo_unbound,
+        Lo_bound,
+        Lo_rundown,
+};
+
+struct loop_func_table;
+
+struct loop_device {
+        int             lo_number;
+        int             lo_refcnt;
+        loff_t          lo_offset;
+        loff_t          lo_sizelimit;
+        int             lo_flags;
+        int             (*transfer)(struct loop_device *, int cmd,
+                                    struct page *raw_page, unsigned raw_off,
+                                    struct page *loop_page, unsigned loop_off,
+                                    int size, sector_t real_block);
+        char            lo_file_name[LO_NAME_SIZE];
+        char            lo_crypt_name[LO_NAME_SIZE];
+        char            lo_encrypt_key[LO_KEY_SIZE];
+        int             lo_encrypt_key_size;
+        struct loop_func_table *lo_encryption;
+        __u32           lo_init[2];
+        uid_t           lo_key_owner;   /* Who set the key */
+        int             (*ioctl)(struct loop_device *, int cmd, 
+                                 unsigned long arg); 
+
+        struct file *   lo_backing_file;
+        struct block_device *lo_device;
+        unsigned        lo_blocksize;
+        void            *key_data; 
+
+        int             old_gfp_mask;
+
+        spinlock_t              lo_lock;
+        struct bio              *lo_bio;
+        struct bio              *lo_biotail;
+        int                     lo_state;
+        struct semaphore        lo_sem;
+        struct semaphore        lo_ctl_mutex;
+        struct semaphore        lo_bh_mutex;
+        atomic_t                lo_pending;
+
+        request_queue_t         *lo_queue;
+};
+
+#endif /* __KERNEL__ */
+
+/*
+ * Loop flags
+ */
+enum {
+        LO_FLAGS_READ_ONLY      = 1,
+        LO_FLAGS_USE_AOPS       = 2,
+};
+
+#include <asm/posix_types.h>    /* for __kernel_old_dev_t */
+#include <asm/types.h>          /* for __u64 */
+
+/* Backwards compatibility version */
+struct loop_info {
+        int                lo_number;           /* ioctl r/o */
+        __kernel_old_dev_t lo_device;           /* ioctl r/o */
+        unsigned long      lo_inode;            /* ioctl r/o */
+        __kernel_old_dev_t lo_rdevice;          /* ioctl r/o */
+        int                lo_offset;
+        int                lo_encrypt_type;
+        int                lo_encrypt_key_size;         /* ioctl w/o */
+        int                lo_flags;                    /* ioctl r/o */
+        char               lo_name[LO_NAME_SIZE];
+        unsigned char      lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
+        unsigned long      lo_init[2];
+        char               reserved[4];
+};
+
+struct loop_info64 {
+        __u64              lo_device;                   /* ioctl r/o */
+        __u64              lo_inode;                    /* ioctl r/o */
+        __u64              lo_rdevice;                  /* ioctl r/o */
+        __u64              lo_offset;
+        __u64              lo_sizelimit;/* bytes, 0 == max available */
+        __u32              lo_number;                   /* ioctl r/o */
+        __u32              lo_encrypt_type;
+        __u32              lo_encrypt_key_size;         /* ioctl w/o */
+        __u32              lo_flags;                    /* ioctl r/o */
+        __u8               lo_file_name[LO_NAME_SIZE];
+        __u8               lo_crypt_name[LO_NAME_SIZE];
+        __u8               lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
+        __u64              lo_init[2];
+};
+
+/*
+ * Loop filter types
+ */
+
+#define LO_CRYPT_NONE           0
+#define LO_CRYPT_XOR            1
+#define LO_CRYPT_DES            2
+#define LO_CRYPT_FISH2          3    /* Twofish encryption */
+#define LO_CRYPT_BLOW           4
+#define LO_CRYPT_CAST128        5
+#define LO_CRYPT_IDEA           6
+#define LO_CRYPT_DUMMY          9
+#define LO_CRYPT_SKIPJACK       10
+#define LO_CRYPT_CRYPTOAPI      18
+#define MAX_LO_CRYPT            20
+
+#ifdef __KERNEL__
+/* Support for loadable transfer modules */
+struct loop_func_table {
+        int number;     /* filter type */ 
+        int (*transfer)(struct loop_device *lo, int cmd,
+                        struct page *raw_page, unsigned raw_off,
+                        struct page *loop_page, unsigned loop_off,
+                        int size, sector_t real_block);
+        int (*init)(struct loop_device *, const struct loop_info64 *); 
+        /* release is called from loop_unregister_transfer or clr_fd */
+        int (*release)(struct loop_device *); 
+        int (*ioctl)(struct loop_device *, int cmd, unsigned long arg);
+        struct module *owner;
+}; 
+
+int loop_register_transfer(struct loop_func_table *funcs);
+int loop_unregister_transfer(int number); 
+
+#endif
+/*
+ * IOCTL commands --- we will commandeer 0x4C ('L')
+ */
+
+#define LOOP_SET_FD             0x4C00
+#define LOOP_CLR_FD             0x4C01
+#define LOOP_SET_STATUS         0x4C02
+#define LOOP_GET_STATUS         0x4C03
+#define LOOP_SET_STATUS64       0x4C04
+#define LOOP_GET_STATUS64       0x4C05
+#define LOOP_CHANGE_FD          0x4C06
+
+#endif
diff --git a/include/linux/lp.h b/include/linux/lp.h
new file mode 100644
index 000000000000..7059b6b9878a
--- /dev/null
+++ b/include/linux/lp.h
@@ -0,0 +1,191 @@
+#ifndef _LINUX_LP_H
+#define _LINUX_LP_H
+
+/*
+ * usr/include/linux/lp.h c.1991-1992 James Wiegand
+ * many modifications copyright (C) 1992 Michael K. Johnson
+ * Interrupt support added 1993 Nigel Gamble
+ * Removed 8255 status defines from inside __KERNEL__ Marcelo Tosatti 
+ */
+
+/*
+ * Per POSIX guidelines, this module reserves the LP and lp prefixes
+ * These are the lp_table[minor].flags flags...
+ */
+#define LP_EXIST 0x0001
+#define LP_SELEC 0x0002
+#define LP_BUSY  0x0004
+#define LP_BUSY_BIT_POS 2
+#define LP_OFFL  0x0008
+#define LP_NOPA  0x0010
+#define LP_ERR   0x0020
+#define LP_ABORT 0x0040
+#define LP_CAREFUL 0x0080 /* obsoleted -arca */
+#define LP_ABORTOPEN 0x0100
+
+#define LP_TRUST_IRQ_  0x0200 /* obsolete */
+#define LP_NO_REVERSE  0x0400 /* No reverse mode available. */
+#define LP_DATA_AVAIL  0x0800 /* Data is available. */
+
+/* 
+ * bit defines for 8255 status port
+ * base + 1
+ * accessed with LP_S(minor), which gets the byte...
+ */
+#define LP_PBUSY        0x80  /* inverted input, active high */
+#define LP_PACK         0x40  /* unchanged input, active low */
+#define LP_POUTPA       0x20  /* unchanged input, active high */
+#define LP_PSELECD      0x10  /* unchanged input, active high */
+#define LP_PERRORP      0x08  /* unchanged input, active low */
+
+/* timeout for each character.  This is relative to bus cycles -- it
+ * is the count in a busy loop.  THIS IS THE VALUE TO CHANGE if you
+ * have extremely slow printing, or if the machine seems to slow down
+ * a lot when you print.  If you have slow printing, increase this
+ * number and recompile, and if your system gets bogged down, decrease
+ * this number.  This can be changed with the tunelp(8) command as well.
+ */
+
+#define LP_INIT_CHAR 1000
+
+/* The parallel port specs apparently say that there needs to be
+ * a .5usec wait before and after the strobe.
+ */
+
+#define LP_INIT_WAIT 1
+
+/* This is the amount of time that the driver waits for the printer to
+ * catch up when the printer's buffer appears to be filled.  If you
+ * want to tune this and have a fast printer (i.e. HPIIIP), decrease
+ * this number, and if you have a slow printer, increase this number.
+ * This is in hundredths of a second, the default 2 being .05 second.
+ * Or use the tunelp(8) command, which is especially nice if you want
+ * change back and forth between character and graphics printing, which
+ * are wildly different...
+ */
+
+#define LP_INIT_TIME 2
+
+/* IOCTL numbers */
+#define LPCHAR   0x0601  /* corresponds to LP_INIT_CHAR */
+#define LPTIME   0x0602  /* corresponds to LP_INIT_TIME */
+#define LPABORT  0x0604  /* call with TRUE arg to abort on error,
+                            FALSE to retry.  Default is retry.  */
+#define LPSETIRQ 0x0605  /* call with new IRQ number,
+                            or 0 for polling (no IRQ) */
+#define LPGETIRQ 0x0606  /* get the current IRQ number */
+#define LPWAIT   0x0608  /* corresponds to LP_INIT_WAIT */
+/* NOTE: LPCAREFUL is obsoleted and it' s always the default right now -arca */
+#define LPCAREFUL   0x0609  /* call with TRUE arg to require out-of-paper, off-
+                            line, and error indicators good on all writes,
+                            FALSE to ignore them.  Default is ignore. */
+#define LPABORTOPEN 0x060a  /* call with TRUE arg to abort open() on error,
+                            FALSE to ignore error.  Default is ignore.  */
+#define LPGETSTATUS 0x060b  /* return LP_S(minor) */
+#define LPRESET     0x060c  /* reset printer */
+#ifdef LP_STATS
+#define LPGETSTATS  0x060d  /* get statistics (struct lp_stats) */
+#endif
+#define LPGETFLAGS  0x060e  /* get status flags */
+#define LPSETTIMEOUT 0x060f /* set parport timeout */
+
+/* timeout for printk'ing a timeout, in jiffies (100ths of a second).
+   This is also used for re-checking error conditions if LP_ABORT is
+   not set.  This is the default behavior. */
+
+#define LP_TIMEOUT_INTERRUPT    (60 * HZ)
+#define LP_TIMEOUT_POLLED       (10 * HZ)
+
+#ifdef __KERNEL__
+
+#include <linux/wait.h>
+#include <asm/semaphore.h>
+
+/* Magic numbers for defining port-device mappings */
+#define LP_PARPORT_UNSPEC -4
+#define LP_PARPORT_AUTO -3
+#define LP_PARPORT_OFF -2
+#define LP_PARPORT_NONE -1
+
+#define LP_F(minor)     lp_table[(minor)].flags         /* flags for busy, etc. */
+#define LP_CHAR(minor)  lp_table[(minor)].chars         /* busy timeout */
+#define LP_TIME(minor)  lp_table[(minor)].time          /* wait time */
+#define LP_WAIT(minor)  lp_table[(minor)].wait          /* strobe wait */
+#define LP_IRQ(minor)   lp_table[(minor)].dev->port->irq /* interrupt # */
+                                        /* PARPORT_IRQ_NONE means polled */
+#ifdef LP_STATS
+#define LP_STAT(minor)  lp_table[(minor)].stats         /* statistics area */
+#endif
+#define LP_BUFFER_SIZE PAGE_SIZE
+
+#define LP_BASE(x)      lp_table[(x)].dev->port->base
+
+#ifdef LP_STATS
+struct lp_stats {
+        unsigned long chars;
+        unsigned long sleeps;
+        unsigned int maxrun;
+        unsigned int maxwait;
+        unsigned int meanwait;
+        unsigned int mdev;
+};
+#endif
+
+struct lp_struct {
+        struct pardevice *dev;
+        unsigned long flags;
+        unsigned int chars;
+        unsigned int time;
+        unsigned int wait;
+        char *lp_buffer;
+#ifdef LP_STATS
+        unsigned int lastcall;
+        unsigned int runchars;
+        struct lp_stats stats;
+#endif
+        wait_queue_head_t waitq;
+        unsigned int last_error;
+        struct semaphore port_mutex;
+        wait_queue_head_t dataq;
+        long timeout;
+        unsigned int best_mode;
+        unsigned int current_mode;
+        unsigned long bits;
+};
+
+/*
+ * The following constants describe the various signals of the printer port
+ * hardware.  Note that the hardware inverts some signals and that some
+ * signals are active low.  An example is LP_STROBE, which must be programmed
+ * with 1 for being active and 0 for being inactive, because the strobe signal
+ * gets inverted, but it is also active low.
+ */
+
+
+/* 
+ * defines for 8255 control port
+ * base + 2 
+ * accessed with LP_C(minor)
+ */
+#define LP_PINTEN       0x10  /* high to read data in or-ed with data out */
+#define LP_PSELECP      0x08  /* inverted output, active low */
+#define LP_PINITP       0x04  /* unchanged output, active low */
+#define LP_PAUTOLF      0x02  /* inverted output, active low */
+#define LP_PSTROBE      0x01  /* short high output on raising edge */
+
+/* 
+ * the value written to ports to test existence. PC-style ports will 
+ * return the value written. AT-style ports will return 0. so why not
+ * make them the same ? 
+ */
+#define LP_DUMMY        0x00
+
+/*
+ * This is the port delay time, in microseconds.
+ * It is used only in the lp_init() and lp_reset() routine.
+ */
+#define LP_DELAY        50
+
+#endif
+
+#endif
diff --git a/include/linux/major.h b/include/linux/major.h
new file mode 100644
index 000000000000..4b62c42b842c
--- /dev/null
+++ b/include/linux/major.h
@@ -0,0 +1,167 @@
+#ifndef _LINUX_MAJOR_H
+#define _LINUX_MAJOR_H
+
+/*
+ * This file has definitions for major device numbers.
+ * For the device number assignments, see Documentation/devices.txt.
+ */
+
+#define UNNAMED_MAJOR           0
+#define MEM_MAJOR               1
+#define RAMDISK_MAJOR           1
+#define FLOPPY_MAJOR            2
+#define PTY_MASTER_MAJOR        2
+#define IDE0_MAJOR              3
+#define HD_MAJOR                IDE0_MAJOR
+#define PTY_SLAVE_MAJOR         3
+#define TTY_MAJOR               4
+#define TTYAUX_MAJOR            5
+#define LP_MAJOR                6
+#define VCS_MAJOR               7
+#define LOOP_MAJOR              7
+#define SCSI_DISK0_MAJOR        8
+#define SCSI_TAPE_MAJOR         9
+#define MD_MAJOR                9
+#define MISC_MAJOR              10
+#define SCSI_CDROM_MAJOR        11
+#define MUX_MAJOR               11      /* PA-RISC only */
+#define XT_DISK_MAJOR           13
+#define INPUT_MAJOR             13
+#define SOUND_MAJOR             14
+#define CDU31A_CDROM_MAJOR      15
+#define JOYSTICK_MAJOR          15
+#define GOLDSTAR_CDROM_MAJOR    16
+#define OPTICS_CDROM_MAJOR      17
+#define SANYO_CDROM_MAJOR       18
+#define CYCLADES_MAJOR          19
+#define CYCLADESAUX_MAJOR       20
+#define MITSUMI_X_CDROM_MAJOR   20
+#define MFM_ACORN_MAJOR         21      /* ARM Linux /dev/mfm */
+#define SCSI_GENERIC_MAJOR      21
+#define IDE1_MAJOR              22
+#define DIGICU_MAJOR            22
+#define DIGI_MAJOR              23
+#define MITSUMI_CDROM_MAJOR     23
+#define CDU535_CDROM_MAJOR      24
+#define STL_SERIALMAJOR         24
+#define MATSUSHITA_CDROM_MAJOR  25
+#define STL_CALLOUTMAJOR        25
+#define MATSUSHITA_CDROM2_MAJOR 26
+#define QIC117_TAPE_MAJOR       27
+#define MATSUSHITA_CDROM3_MAJOR 27
+#define MATSUSHITA_CDROM4_MAJOR 28
+#define STL_SIOMEMMAJOR         28
+#define ACSI_MAJOR              28
+#define AZTECH_CDROM_MAJOR      29
+#define GRAPHDEV_MAJOR          29   /* SparcLinux & Linux/68k /dev/fb */
+#define CM206_CDROM_MAJOR       32
+#define IDE2_MAJOR              33
+#define IDE3_MAJOR              34
+#define Z8530_MAJOR             34
+#define XPRAM_MAJOR             35   /* Expanded storage on S/390: "slow ram"*/
+#define NETLINK_MAJOR           36
+#define PS2ESDI_MAJOR           36
+#define IDETAPE_MAJOR           37
+#define Z2RAM_MAJOR             37
+#define APBLOCK_MAJOR           38   /* AP1000 Block device */
+#define DDV_MAJOR               39   /* AP1000 DDV block device */
+#define NBD_MAJOR               43   /* Network block device    */
+#define RISCOM8_NORMAL_MAJOR    48
+#define DAC960_MAJOR            48   /* 48..55 */
+#define RISCOM8_CALLOUT_MAJOR   49
+#define MKISS_MAJOR             55
+#define DSP56K_MAJOR            55   /* DSP56001 processor device */
+
+#define IDE4_MAJOR              56
+#define IDE5_MAJOR              57
+
+#define SCSI_DISK1_MAJOR        65
+#define SCSI_DISK2_MAJOR        66
+#define SCSI_DISK3_MAJOR        67
+#define SCSI_DISK4_MAJOR        68
+#define SCSI_DISK5_MAJOR        69
+#define SCSI_DISK6_MAJOR        70
+#define SCSI_DISK7_MAJOR        71
+
+#define COMPAQ_SMART2_MAJOR     72
+#define COMPAQ_SMART2_MAJOR1    73
+#define COMPAQ_SMART2_MAJOR2    74
+#define COMPAQ_SMART2_MAJOR3    75
+#define COMPAQ_SMART2_MAJOR4    76
+#define COMPAQ_SMART2_MAJOR5    77
+#define COMPAQ_SMART2_MAJOR6    78
+#define COMPAQ_SMART2_MAJOR7    79
+
+#define SPECIALIX_NORMAL_MAJOR  75
+#define SPECIALIX_CALLOUT_MAJOR 76
+
+#define AURORA_MAJOR            79
+
+#define I2O_MAJOR               80      /* 80->87 */
+
+#define SHMIQ_MAJOR             85   /* Linux/mips, SGI /dev/shmiq */
+
+#define IDE6_MAJOR              88
+#define IDE7_MAJOR              89
+#define IDE8_MAJOR              90
+#define IDE9_MAJOR              91
+
+#define DASD_MAJOR              94
+
+#define MDISK_MAJOR             95
+
+#define UBD_MAJOR               98
+
+#define JSFD_MAJOR              99
+
+#define PHONE_MAJOR             100
+
+#define COMPAQ_CISS_MAJOR       104
+#define COMPAQ_CISS_MAJOR1      105
+#define COMPAQ_CISS_MAJOR2      106
+#define COMPAQ_CISS_MAJOR3      107
+#define COMPAQ_CISS_MAJOR4      108
+#define COMPAQ_CISS_MAJOR5      109
+#define COMPAQ_CISS_MAJOR6      110
+#define COMPAQ_CISS_MAJOR7      111
+
+#define VIODASD_MAJOR           112
+#define VIOCD_MAJOR             113
+
+#define ATARAID_MAJOR           114
+
+#define SCSI_DISK8_MAJOR        128
+#define SCSI_DISK9_MAJOR        129
+#define SCSI_DISK10_MAJOR       130
+#define SCSI_DISK11_MAJOR       131
+#define SCSI_DISK12_MAJOR       132
+#define SCSI_DISK13_MAJOR       133
+#define SCSI_DISK14_MAJOR       134
+#define SCSI_DISK15_MAJOR       135
+
+#define UNIX98_PTY_MASTER_MAJOR 128
+#define UNIX98_PTY_MAJOR_COUNT  8
+#define UNIX98_PTY_SLAVE_MAJOR  (UNIX98_PTY_MASTER_MAJOR+UNIX98_PTY_MAJOR_COUNT)
+
+#define RTF_MAJOR               150
+#define RAW_MAJOR               162
+
+#define USB_ACM_MAJOR           166
+#define USB_ACM_AUX_MAJOR       167
+#define USB_CHAR_MAJOR          180
+
+#define VXVM_MAJOR              199     /* VERITAS volume i/o driver    */
+#define VXSPEC_MAJOR            200     /* VERITAS volume config driver */
+#define VXDMP_MAJOR             201     /* VERITAS volume multipath driver */
+
+#define MSR_MAJOR               202
+#define CPUID_MAJOR             203
+
+#define OSST_MAJOR              206     /* OnStream-SCx0 SCSI tape */
+
+#define IBM_TTY3270_MAJOR       227
+#define IBM_FS3270_MAJOR        228
+
+#define VIOTAPE_MAJOR           230
+
+#endif
diff --git a/include/linux/matroxfb.h b/include/linux/matroxfb.h
new file mode 100644
index 000000000000..ae5b09493062
--- /dev/null
+++ b/include/linux/matroxfb.h
@@ -0,0 +1,43 @@
+#ifndef __LINUX_MATROXFB_H__
+#define __LINUX_MATROXFB_H__
+
+#include <asm/ioctl.h>
+#include <asm/types.h>
+#include <linux/videodev2.h>
+
+struct matroxioc_output_mode {
+        __u32   output;         /* which output */
+#define MATROXFB_OUTPUT_PRIMARY         0x0000
+#define MATROXFB_OUTPUT_SECONDARY       0x0001
+#define MATROXFB_OUTPUT_DFP             0x0002
+        __u32   mode;           /* which mode */
+#define MATROXFB_OUTPUT_MODE_PAL        0x0001
+#define MATROXFB_OUTPUT_MODE_NTSC       0x0002
+#define MATROXFB_OUTPUT_MODE_MONITOR    0x0080
+};
+#define MATROXFB_SET_OUTPUT_MODE        _IOW('n',0xFA,size_t)
+#define MATROXFB_GET_OUTPUT_MODE        _IOWR('n',0xFA,size_t)
+
+/* bitfield */
+#define MATROXFB_OUTPUT_CONN_PRIMARY    (1 << MATROXFB_OUTPUT_PRIMARY)
+#define MATROXFB_OUTPUT_CONN_SECONDARY  (1 << MATROXFB_OUTPUT_SECONDARY)
+#define MATROXFB_OUTPUT_CONN_DFP        (1 << MATROXFB_OUTPUT_DFP)
+/* connect these outputs to this framebuffer */
+#define MATROXFB_SET_OUTPUT_CONNECTION  _IOW('n',0xF8,size_t)
+/* which outputs are connected to this framebuffer */
+#define MATROXFB_GET_OUTPUT_CONNECTION  _IOR('n',0xF8,size_t)
+/* which outputs are available for this framebuffer */
+#define MATROXFB_GET_AVAILABLE_OUTPUTS  _IOR('n',0xF9,size_t)
+/* which outputs exist on this framebuffer */
+#define MATROXFB_GET_ALL_OUTPUTS        _IOR('n',0xFB,size_t)
+
+enum matroxfb_ctrl_id {
+  MATROXFB_CID_TESTOUT   = V4L2_CID_PRIVATE_BASE,
+  MATROXFB_CID_DEFLICKER,
+  MATROXFB_CID_LAST
+};
+
+#define FBIO_WAITFORVSYNC       _IOW('F', 0x20, u_int32_t)
+
+#endif
+
diff --git a/include/linux/mbcache.h b/include/linux/mbcache.h
new file mode 100644
index 000000000000..8e5a10410a30
--- /dev/null
+++ b/include/linux/mbcache.h
@@ -0,0 +1,52 @@
+/*
+  File: linux/mbcache.h
+
+  (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
+*/
+
+/* Hardwire the number of additional indexes */
+#define MB_CACHE_INDEXES_COUNT 1
+
+struct mb_cache_entry {
+        struct list_head                e_lru_list;
+        struct mb_cache                 *e_cache;
+        unsigned short                  e_used;
+        unsigned short                  e_queued;
+        struct block_device             *e_bdev;
+        sector_t                        e_block;
+        struct list_head                e_block_list;
+        struct {
+                struct list_head        o_list;
+                unsigned int            o_key;
+        } e_indexes[0];
+};
+
+struct mb_cache_op {
+        int (*free)(struct mb_cache_entry *, int);
+};
+
+/* Functions on caches */
+
+struct mb_cache * mb_cache_create(const char *, struct mb_cache_op *, size_t,
+                                  int, int);
+void mb_cache_shrink(struct mb_cache *, struct block_device *);
+void mb_cache_destroy(struct mb_cache *);
+
+/* Functions on cache entries */
+
+struct mb_cache_entry *mb_cache_entry_alloc(struct mb_cache *);
+int mb_cache_entry_insert(struct mb_cache_entry *, struct block_device *,
+                          sector_t, unsigned int[]);
+void mb_cache_entry_release(struct mb_cache_entry *);
+void mb_cache_entry_free(struct mb_cache_entry *);
+struct mb_cache_entry *mb_cache_entry_get(struct mb_cache *,
+                                          struct block_device *,
+                                          sector_t);
+#if !defined(MB_CACHE_INDEXES_COUNT) || (MB_CACHE_INDEXES_COUNT > 0)
+struct mb_cache_entry *mb_cache_entry_find_first(struct mb_cache *cache, int,
+                                                 struct block_device *, 
+                                                 unsigned int);
+struct mb_cache_entry *mb_cache_entry_find_next(struct mb_cache_entry *, int,
+                                                struct block_device *, 
+                                                unsigned int);
+#endif
diff --git a/include/linux/mc146818rtc.h b/include/linux/mc146818rtc.h
new file mode 100644
index 000000000000..bbc93ae217e1
--- /dev/null
+++ b/include/linux/mc146818rtc.h
@@ -0,0 +1,92 @@
+/* mc146818rtc.h - register definitions for the Real-Time-Clock / CMOS RAM
+ * Copyright Torsten Duwe <duwe@informatik.uni-erlangen.de> 1993
+ * derived from Data Sheet, Copyright Motorola 1984 (!).
+ * It was written to be part of the Linux operating system.
+ */
+/* permission is hereby granted to copy, modify and redistribute this code
+ * in terms of the GNU Library General Public License, Version 2 or later,
+ * at your option.
+ */
+
+#ifndef _MC146818RTC_H
+#define _MC146818RTC_H
+
+#include <asm/io.h>
+#include <linux/rtc.h>                  /* get the user-level API */
+#include <asm/mc146818rtc.h>            /* register access macros */
+
+#ifdef __KERNEL__
+#include <linux/spinlock.h>             /* spinlock_t */
+extern spinlock_t rtc_lock;             /* serialize CMOS RAM access */
+#endif
+
+/**********************************************************************
+ * register summary
+ **********************************************************************/
+#define RTC_SECONDS             0
+#define RTC_SECONDS_ALARM       1
+#define RTC_MINUTES             2
+#define RTC_MINUTES_ALARM       3
+#define RTC_HOURS               4
+#define RTC_HOURS_ALARM         5
+/* RTC_*_alarm is always true if 2 MSBs are set */
+# define RTC_ALARM_DONT_CARE    0xC0
+
+#define RTC_DAY_OF_WEEK         6
+#define RTC_DAY_OF_MONTH        7
+#define RTC_MONTH               8
+#define RTC_YEAR                9
+
+/* control registers - Moto names
+ */
+#define RTC_REG_A               10
+#define RTC_REG_B               11
+#define RTC_REG_C               12
+#define RTC_REG_D               13
+
+/**********************************************************************
+ * register details
+ **********************************************************************/
+#define RTC_FREQ_SELECT RTC_REG_A
+
+/* update-in-progress  - set to "1" 244 microsecs before RTC goes off the bus,
+ * reset after update (may take 1.984ms @ 32768Hz RefClock) is complete,
+ * totalling to a max high interval of 2.228 ms.
+ */
+# define RTC_UIP                0x80
+# define RTC_DIV_CTL            0x70
+   /* divider control: refclock values 4.194 / 1.049 MHz / 32.768 kHz */
+#  define RTC_REF_CLCK_4MHZ     0x00
+#  define RTC_REF_CLCK_1MHZ     0x10
+#  define RTC_REF_CLCK_32KHZ    0x20
+   /* 2 values for divider stage reset, others for "testing purposes only" */
+#  define RTC_DIV_RESET1        0x60
+#  define RTC_DIV_RESET2        0x70
+  /* Periodic intr. / Square wave rate select. 0=none, 1=32.8kHz,... 15=2Hz */
+# define RTC_RATE_SELECT        0x0F
+
+/**********************************************************************/
+#define RTC_CONTROL     RTC_REG_B
+# define RTC_SET 0x80           /* disable updates for clock setting */
+# define RTC_PIE 0x40           /* periodic interrupt enable */
+# define RTC_AIE 0x20           /* alarm interrupt enable */
+# define RTC_UIE 0x10           /* update-finished interrupt enable */
+# define RTC_SQWE 0x08          /* enable square-wave output */
+# define RTC_DM_BINARY 0x04     /* all time/date values are BCD if clear */
+# define RTC_24H 0x02           /* 24 hour mode - else hours bit 7 means pm */
+# define RTC_DST_EN 0x01        /* auto switch DST - works f. USA only */
+
+/**********************************************************************/
+#define RTC_INTR_FLAGS  RTC_REG_C
+/* caution - cleared by read */
+# define RTC_IRQF 0x80          /* any of the following 3 is active */
+# define RTC_PF 0x40
+# define RTC_AF 0x20
+# define RTC_UF 0x10
+
+/**********************************************************************/
+#define RTC_VALID       RTC_REG_D
+# define RTC_VRT 0x80           /* valid RAM and time */
+/**********************************************************************/
+
+#endif /* _MC146818RTC_H */
diff --git a/include/linux/mc6821.h b/include/linux/mc6821.h
new file mode 100644
index 000000000000..28e301e295da
--- /dev/null
+++ b/include/linux/mc6821.h
@@ -0,0 +1,51 @@
+#ifndef _MC6821_H_
+#define _MC6821_H_
+
+/*
+ * This file describes the memery mapping of the MC6821 PIA.
+ * The unions describe overlayed registers. Which of them is used is
+ * determined by bit 2 of the corresponding control register.
+ * this files expects the PIA_REG_PADWIDTH to be defined the numeric
+ * value of the register spacing.
+ *
+ * Data came from MFC-31-Developer Kit (from Ralph Seidel,
+ * zodiac@darkness.gun.de) and Motorola Data Sheet (from 
+ * Richard Hirst, srh@gpt.co.uk)
+ *
+ * 6.11.95 copyright Joerg Dorchain (dorchain@mpi-sb.mpg.de)
+ *
+ */
+
+#ifndef PIA_REG_PADWIDTH
+#define PIA_REG_PADWIDTH 255
+#endif
+
+struct pia {
+        union {
+                volatile u_char pra;
+                volatile u_char ddra;
+        } ua;
+        u_char pad1[PIA_REG_PADWIDTH];
+        volatile u_char cra;
+        u_char pad2[PIA_REG_PADWIDTH];
+        union {
+                volatile u_char prb;
+                volatile u_char ddrb;
+        } ub;
+        u_char pad3[PIA_REG_PADWIDTH];
+        volatile u_char crb;
+        u_char pad4[PIA_REG_PADWIDTH];
+};
+
+#define ppra ua.pra
+#define pddra ua.ddra
+#define pprb ub.prb
+#define pddrb ub.ddrb
+
+#define PIA_C1_ENABLE_IRQ (1<<0)
+#define PIA_C1_LOW_TO_HIGH (1<<1)
+#define PIA_DDR (1<<2)
+#define PIA_IRQ2 (1<<6)
+#define PIA_IRQ1 (1<<7)
+
+#endif
diff --git a/include/linux/mca-legacy.h b/include/linux/mca-legacy.h
new file mode 100644
index 000000000000..f2bb770e530a
--- /dev/null
+++ b/include/linux/mca-legacy.h
@@ -0,0 +1,67 @@
+/* -*- mode: c; c-basic-offset: 8 -*- */
+
+/* This is the function prototypes for the old legacy MCA interface
+ *
+ * Please move your driver to the new sysfs based one instead */
+
+#ifndef _LINUX_MCA_LEGACY_H
+#define _LINUX_MCA_LEGACY_H
+
+#include <linux/mca.h>
+
+#warning "MCA legacy - please move your driver to the new sysfs api"
+
+/* MCA_NOTFOUND is an error condition.  The other two indicate
+ * motherboard POS registers contain the adapter.  They might be
+ * returned by the mca_find_adapter() function, and can be used as
+ * arguments to mca_read_stored_pos().  I'm not going to allow direct
+ * access to the motherboard registers until we run across an adapter
+ * that requires it.  We don't know enough about them to know if it's
+ * safe.
+ *
+ * See Documentation/mca.txt or one of the existing drivers for
+ * more information.
+ */
+#define MCA_NOTFOUND    (-1)
+
+
+
+/* Returns the slot of the first enabled adapter matching id.  User can
+ * specify a starting slot beyond zero, to deal with detecting multiple
+ * devices.  Returns MCA_NOTFOUND if id not found.  Also checks the
+ * integrated adapters.
+ */
+extern int mca_find_adapter(int id, int start);
+extern int mca_find_unused_adapter(int id, int start);
+
+extern int mca_is_adapter_used(int slot);
+extern int mca_mark_as_used(int slot);
+extern void mca_mark_as_unused(int slot);
+
+/* gets a byte out of POS register (stored in memory) */
+extern unsigned char mca_read_stored_pos(int slot, int reg);
+
+/* This can be expanded later.  Right now, it gives us a way of
+ * getting meaningful information into the MCA_info structure,
+ * so we can have a more interesting /proc/mca.
+ */
+extern void mca_set_adapter_name(int slot, char* name);
+
+/* These routines actually mess with the hardware POS registers.  They
+ * temporarily disable the device (and interrupts), so make sure you know
+ * what you're doing if you use them.  Furthermore, writing to a POS may
+ * result in two devices trying to share a resource, which in turn can
+ * result in multiple devices sharing memory spaces, IRQs, or even trashing
+ * hardware.  YOU HAVE BEEN WARNED.
+ *
+ * You can only access slots with this.  Motherboard registers are off
+ * limits.
+ */
+
+/* read a byte from the specified POS register. */
+extern unsigned char mca_read_pos(int slot, int reg);
+
+/* write a byte to the specified POS register. */
+extern void mca_write_pos(int slot, int reg, unsigned char byte);
+
+#endif
diff --git a/include/linux/mca.h b/include/linux/mca.h
new file mode 100644
index 000000000000..5cff2923092b
--- /dev/null
+++ b/include/linux/mca.h
@@ -0,0 +1,146 @@
+/*
+ * Header for Microchannel Architecture Bus
+ * Written by Martin Kolinek, February 1996
+ */
+
+#ifndef _LINUX_MCA_H
+#define _LINUX_MCA_H
+
+#include <linux/device.h>
+
+#ifdef CONFIG_MCA
+#include <asm/mca.h>
+
+extern int MCA_bus;
+#else
+#define MCA_bus 0
+#endif
+
+/* This sets up an information callback for /proc/mca/slot?.  The
+ * function is called with the buffer, slot, and device pointer (or
+ * some equally informative context information, or nothing, if you
+ * prefer), and is expected to put useful information into the
+ * buffer.  The adapter name, id, and POS registers get printed
+ * before this is called though, so don't do it again.
+ *
+ * This should be called with a NULL procfn when a module
+ * unregisters, thus preventing kernel crashes and other such
+ * nastiness.
+ */
+typedef int (*MCA_ProcFn)(char* buf, int slot, void* dev);
+
+/* Should only be called by the NMI interrupt handler, this will do some
+ * fancy stuff to figure out what might have generated a NMI.
+ */
+extern void mca_handle_nmi(void);
+
+enum MCA_AdapterStatus {
+        MCA_ADAPTER_NORMAL = 0,
+        MCA_ADAPTER_NONE = 1,
+        MCA_ADAPTER_DISABLED = 2,
+        MCA_ADAPTER_ERROR = 3
+};
+
+struct mca_device {
+        u64                     dma_mask;
+        int                     pos_id;
+        int                     slot;
+
+        /* index into id_table, set by the bus match routine */
+        int                     index;
+
+        /* is there a driver installed? 0 - No, 1 - Yes */
+        int                     driver_loaded;
+        /* POS registers */
+        unsigned char           pos[8];
+        /* if a pseudo adapter of the motherboard, this is the motherboard
+         * register value to use for setup cycles */
+        short                   pos_register;
+        
+        enum MCA_AdapterStatus  status;
+#ifdef CONFIG_MCA_PROC_FS
+        /* name of the proc/mca file */
+        char                    procname[8];
+        /* /proc info callback */
+        MCA_ProcFn              procfn;
+        /* device/context info for proc callback */
+        void                    *proc_dev;
+#endif
+        struct device           dev;
+        char                    name[32];
+};
+#define to_mca_device(mdev) container_of(mdev, struct mca_device, dev)
+
+struct mca_bus_accessor_functions {
+        unsigned char   (*mca_read_pos)(struct mca_device *, int reg);
+        void            (*mca_write_pos)(struct mca_device *, int reg,
+                                         unsigned char byte);
+        int             (*mca_transform_irq)(struct mca_device *, int irq);
+        int             (*mca_transform_ioport)(struct mca_device *,
+                                                  int region);
+        void *          (*mca_transform_memory)(struct mca_device *,
+                                                void *memory);
+};
+
+struct mca_bus {
+        u64                     default_dma_mask;
+        int                     number;
+        struct mca_bus_accessor_functions f;
+        struct device           dev;
+        char                    name[32];
+};
+#define to_mca_bus(mdev) container_of(mdev, struct mca_bus, dev)
+
+struct mca_driver {
+        const short             *id_table;
+        void                    *driver_data;
+        struct device_driver    driver;
+};
+#define to_mca_driver(mdriver) container_of(mdriver, struct mca_driver, driver)
+
+/* Ongoing supported API functions */
+extern struct mca_device *mca_find_device_by_slot(int slot);
+extern int mca_system_init(void);
+extern struct mca_bus *mca_attach_bus(int);
+
+extern unsigned char mca_device_read_stored_pos(struct mca_device *mca_dev,
+                                                int reg);
+extern unsigned char mca_device_read_pos(struct mca_device *mca_dev, int reg);
+extern void mca_device_write_pos(struct mca_device *mca_dev, int reg,
+                                 unsigned char byte);
+extern int mca_device_transform_irq(struct mca_device *mca_dev, int irq);
+extern int mca_device_transform_ioport(struct mca_device *mca_dev, int port);
+extern void *mca_device_transform_memory(struct mca_device *mca_dev,
+                                         void *mem);
+extern int mca_device_claimed(struct mca_device *mca_dev);
+extern void mca_device_set_claim(struct mca_device *mca_dev, int val);
+extern void mca_device_set_name(struct mca_device *mca_dev, const char *name);
+static inline char *mca_device_get_name(struct mca_device *mca_dev)
+{
+        return mca_dev ? mca_dev->name : NULL;
+}
+
+extern enum MCA_AdapterStatus mca_device_status(struct mca_device *mca_dev);
+
+extern struct bus_type mca_bus_type;
+
+extern int mca_register_driver(struct mca_driver *drv);
+extern void mca_unregister_driver(struct mca_driver *drv);
+
+/* WARNING: only called by the boot time device setup */
+extern int mca_register_device(int bus, struct mca_device *mca_dev);
+
+#ifdef CONFIG_MCA_PROC_FS
+extern void mca_do_proc_init(void);
+extern void mca_set_adapter_procfn(int slot, MCA_ProcFn, void* dev);
+#else
+static inline void mca_do_proc_init(void)
+{
+}
+
+static inline void mca_set_adapter_procfn(int slot, MCA_ProcFn fn, void* dev)
+{
+}
+#endif
+
+#endif /* _LINUX_MCA_H */
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
new file mode 100644
index 000000000000..8480aef10e62
--- /dev/null
+++ b/include/linux/mempolicy.h
@@ -0,0 +1,229 @@
+#ifndef _LINUX_MEMPOLICY_H
+#define _LINUX_MEMPOLICY_H 1
+
+#include <linux/errno.h>
+
+/*
+ * NUMA memory policies for Linux.
+ * Copyright 2003,2004 Andi Kleen SuSE Labs
+ */
+
+/* Policies */
+#define MPOL_DEFAULT    0
+#define MPOL_PREFERRED  1
+#define MPOL_BIND       2
+#define MPOL_INTERLEAVE 3
+
+#define MPOL_MAX MPOL_INTERLEAVE
+
+/* Flags for get_mem_policy */
+#define MPOL_F_NODE     (1<<0)  /* return next IL mode instead of node mask */
+#define MPOL_F_ADDR     (1<<1)  /* look up vma using address */
+
+/* Flags for mbind */
+#define MPOL_MF_STRICT  (1<<0)  /* Verify existing pages in the mapping */
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/mmzone.h>
+#include <linux/bitmap.h>
+#include <linux/slab.h>
+#include <linux/rbtree.h>
+#include <linux/spinlock.h>
+
+struct vm_area_struct;
+
+#ifdef CONFIG_NUMA
+
+/*
+ * Describe a memory policy.
+ *
+ * A mempolicy can be either associated with a process or with a VMA.
+ * For VMA related allocations the VMA policy is preferred, otherwise
+ * the process policy is used. Interrupts ignore the memory policy
+ * of the current process.
+ *
+ * Locking policy for interlave:
+ * In process context there is no locking because only the process accesses
+ * its own state. All vma manipulation is somewhat protected by a down_read on
+ * mmap_sem. For allocating in the interleave policy the page_table_lock
+ * must be also aquired to protect il_next.
+ *
+ * Freeing policy:
+ * When policy is MPOL_BIND v.zonelist is kmalloc'ed and must be kfree'd.
+ * All other policies don't have any external state. mpol_free() handles this.
+ *
+ * Copying policy objects:
+ * For MPOL_BIND the zonelist must be always duplicated. mpol_clone() does this.
+ */
+struct mempolicy {
+        atomic_t refcnt;
+        short policy;   /* See MPOL_* above */
+        union {
+                struct zonelist  *zonelist;     /* bind */
+                short            preferred_node; /* preferred */
+                DECLARE_BITMAP(nodes, MAX_NUMNODES); /* interleave */
+                /* undefined for default */
+        } v;
+};
+
+/*
+ * Support for managing mempolicy data objects (clone, copy, destroy)
+ * The default fast path of a NULL MPOL_DEFAULT policy is always inlined.
+ */
+
+extern void __mpol_free(struct mempolicy *pol);
+static inline void mpol_free(struct mempolicy *pol)
+{
+        if (pol)
+                __mpol_free(pol);
+}
+
+extern struct mempolicy *__mpol_copy(struct mempolicy *pol);
+static inline struct mempolicy *mpol_copy(struct mempolicy *pol)
+{
+        if (pol)
+                pol = __mpol_copy(pol);
+        return pol;
+}
+
+#define vma_policy(vma) ((vma)->vm_policy)
+#define vma_set_policy(vma, pol) ((vma)->vm_policy = (pol))
+
+static inline void mpol_get(struct mempolicy *pol)
+{
+        if (pol)
+                atomic_inc(&pol->refcnt);
+}
+
+extern int __mpol_equal(struct mempolicy *a, struct mempolicy *b);
+static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
+{
+        if (a == b)
+                return 1;
+        return __mpol_equal(a, b);
+}
+#define vma_mpol_equal(a,b) mpol_equal(vma_policy(a), vma_policy(b))
+
+/* Could later add inheritance of the process policy here. */
+
+#define mpol_set_vma_default(vma) ((vma)->vm_policy = NULL)
+
+/*
+ * Hugetlb policy. i386 hugetlb so far works with node numbers
+ * instead of zone lists, so give it special interfaces for now.
+ */
+extern int mpol_first_node(struct vm_area_struct *vma, unsigned long addr);
+extern int mpol_node_valid(int nid, struct vm_area_struct *vma,
+                        unsigned long addr);
+
+/*
+ * Tree of shared policies for a shared memory region.
+ * Maintain the policies in a pseudo mm that contains vmas. The vmas
+ * carry the policy. As a special twist the pseudo mm is indexed in pages, not
+ * bytes, so that we can work with shared memory segments bigger than
+ * unsigned long.
+ */
+
+struct sp_node {
+        struct rb_node nd;
+        unsigned long start, end;
+        struct mempolicy *policy;
+};
+
+struct shared_policy {
+        struct rb_root root;
+        spinlock_t lock;
+};
+
+static inline void mpol_shared_policy_init(struct shared_policy *info)
+{
+        info->root = RB_ROOT;
+        spin_lock_init(&info->lock);
+}
+
+int mpol_set_shared_policy(struct shared_policy *info,
+                                struct vm_area_struct *vma,
+                                struct mempolicy *new);
+void mpol_free_shared_policy(struct shared_policy *p);
+struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
+                                            unsigned long idx);
+
+extern void numa_default_policy(void);
+extern void numa_policy_init(void);
+
+#else
+
+struct mempolicy {};
+
+static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
+{
+        return 1;
+}
+#define vma_mpol_equal(a,b) 1
+
+#define mpol_set_vma_default(vma) do {} while(0)
+
+static inline void mpol_free(struct mempolicy *p)
+{
+}
+
+static inline void mpol_get(struct mempolicy *pol)
+{
+}
+
+static inline struct mempolicy *mpol_copy(struct mempolicy *old)
+{
+        return NULL;
+}
+
+static inline int mpol_first_node(struct vm_area_struct *vma, unsigned long a)
+{
+        return numa_node_id();
+}
+
+static inline int
+mpol_node_valid(int nid, struct vm_area_struct *vma, unsigned long a)
+{
+        return 1;
+}
+
+struct shared_policy {};
+
+static inline int mpol_set_shared_policy(struct shared_policy *info,
+                                        struct vm_area_struct *vma,
+                                        struct mempolicy *new)
+{
+        return -EINVAL;
+}
+
+static inline void mpol_shared_policy_init(struct shared_policy *info)
+{
+}
+
+static inline void mpol_free_shared_policy(struct shared_policy *p)
+{
+}
+
+static inline struct mempolicy *
+mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
+{
+        return NULL;
+}
+
+#define vma_policy(vma) NULL
+#define vma_set_policy(vma, pol) do {} while(0)
+
+static inline void numa_policy_init(void)
+{
+}
+
+static inline void numa_default_policy(void)
+{
+}
+
+#endif /* CONFIG_NUMA */
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/mempool.h b/include/linux/mempool.h
new file mode 100644
index 000000000000..4a36edf1c974
--- /dev/null
+++ b/include/linux/mempool.h
@@ -0,0 +1,37 @@
+/*
+ * memory buffer pool support
+ */
+#ifndef _LINUX_MEMPOOL_H
+#define _LINUX_MEMPOOL_H
+
+#include <linux/wait.h>
+
+typedef void * (mempool_alloc_t)(unsigned int __nocast gfp_mask, void *pool_data);
+typedef void (mempool_free_t)(void *element, void *pool_data);
+
+typedef struct mempool_s {
+        spinlock_t lock;
+        int min_nr;             /* nr of elements at *elements */
+        int curr_nr;            /* Current nr of elements at *elements */
+        void **elements;
+
+        void *pool_data;
+        mempool_alloc_t *alloc;
+        mempool_free_t *free;
+        wait_queue_head_t wait;
+} mempool_t;
+extern mempool_t * mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
+                                 mempool_free_t *free_fn, void *pool_data);
+extern int mempool_resize(mempool_t *pool, int new_min_nr, unsigned int __nocast gfp_mask);
+extern void mempool_destroy(mempool_t *pool);
+extern void * mempool_alloc(mempool_t *pool, unsigned int __nocast gfp_mask);
+extern void mempool_free(void *element, mempool_t *pool);
+
+/*
+ * A mempool_alloc_t and mempool_free_t that get the memory from
+ * a slab that is passed in through pool_data.
+ */
+void *mempool_alloc_slab(unsigned int __nocast gfp_mask, void *pool_data);
+void mempool_free_slab(void *element, void *pool_data);
+
+#endif /* _LINUX_MEMPOOL_H */
diff --git a/include/linux/meye.h b/include/linux/meye.h
new file mode 100644
index 000000000000..11ec45e9a132
--- /dev/null
+++ b/include/linux/meye.h
@@ -0,0 +1,66 @@
+/*
+ * Motion Eye video4linux driver for Sony Vaio PictureBook
+ *
+ * Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net>
+ *
+ * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
+ *
+ * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
+ *
+ * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
+ *
+ * Some parts borrowed from various video4linux drivers, especially
+ * bttv-driver.c and zoran.c, see original files for credits.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _MEYE_H_
+#define _MEYE_H_
+
+/****************************************************************************/
+/* Private API for handling mjpeg capture / playback.                       */
+/****************************************************************************/
+
+struct meye_params {
+        unsigned char subsample;
+        unsigned char quality;
+        unsigned char sharpness;
+        unsigned char agc;
+        unsigned char picture;
+        unsigned char framerate;
+};
+
+/* query the extended parameters */
+#define MEYEIOC_G_PARAMS        _IOR ('v', BASE_VIDIOCPRIVATE+0, struct meye_params)
+/* set the extended parameters */
+#define MEYEIOC_S_PARAMS        _IOW ('v', BASE_VIDIOCPRIVATE+1, struct meye_params)
+/* queue a buffer for mjpeg capture */
+#define MEYEIOC_QBUF_CAPT       _IOW ('v', BASE_VIDIOCPRIVATE+2, int)
+/* sync a previously queued mjpeg buffer */
+#define MEYEIOC_SYNC            _IOWR('v', BASE_VIDIOCPRIVATE+3, int)
+/* get a still uncompressed snapshot */
+#define MEYEIOC_STILLCAPT       _IO  ('v', BASE_VIDIOCPRIVATE+4)
+/* get a jpeg compressed snapshot */
+#define MEYEIOC_STILLJCAPT      _IOR ('v', BASE_VIDIOCPRIVATE+5, int)
+
+/* V4L2 private controls */
+#define V4L2_CID_AGC            V4L2_CID_PRIVATE_BASE
+#define V4L2_CID_SHARPNESS      (V4L2_CID_PRIVATE_BASE + 1)
+#define V4L2_CID_PICTURE        (V4L2_CID_PRIVATE_BASE + 2)
+#define V4L2_CID_JPEGQUAL       (V4L2_CID_PRIVATE_BASE + 3)
+#define V4L2_CID_FRAMERATE      (V4L2_CID_PRIVATE_BASE + 4)
+
+#endif
diff --git a/include/linux/mii.h b/include/linux/mii.h
new file mode 100644
index 000000000000..20971fe78a8d
--- /dev/null
+++ b/include/linux/mii.h
@@ -0,0 +1,223 @@
+/*
+ * linux/mii.h: definitions for MII-compatible transceivers
+ * Originally drivers/net/sunhme.h.
+ *
+ * Copyright (C) 1996, 1999, 2001 David S. Miller (davem@redhat.com)
+ */
+
+#ifndef __LINUX_MII_H__
+#define __LINUX_MII_H__
+
+#include <linux/types.h>
+#include <linux/if.h>
+
+/* Generic MII registers. */
+
+#define MII_BMCR            0x00        /* Basic mode control register */
+#define MII_BMSR            0x01        /* Basic mode status register  */
+#define MII_PHYSID1         0x02        /* PHYS ID 1                   */
+#define MII_PHYSID2         0x03        /* PHYS ID 2                   */
+#define MII_ADVERTISE       0x04        /* Advertisement control reg   */
+#define MII_LPA             0x05        /* Link partner ability reg    */
+#define MII_EXPANSION       0x06        /* Expansion register          */
+#define MII_CTRL1000        0x09        /* 1000BASE-T control          */
+#define MII_STAT1000        0x0a        /* 1000BASE-T status           */
+#define MII_DCOUNTER        0x12        /* Disconnect counter          */
+#define MII_FCSCOUNTER      0x13        /* False carrier counter       */
+#define MII_NWAYTEST        0x14        /* N-way auto-neg test reg     */
+#define MII_RERRCOUNTER     0x15        /* Receive error counter       */
+#define MII_SREVISION       0x16        /* Silicon revision            */
+#define MII_RESV1           0x17        /* Reserved...                 */
+#define MII_LBRERROR        0x18        /* Lpback, rx, bypass error    */
+#define MII_PHYADDR         0x19        /* PHY address                 */
+#define MII_RESV2           0x1a        /* Reserved...                 */
+#define MII_TPISTATUS       0x1b        /* TPI status for 10mbps       */
+#define MII_NCONFIG         0x1c        /* Network interface config    */
+
+/* Basic mode control register. */
+#define BMCR_RESV               0x003f  /* Unused...                   */
+#define BMCR_SPEED1000          0x0040  /* MSB of Speed (1000)         */
+#define BMCR_CTST               0x0080  /* Collision test              */
+#define BMCR_FULLDPLX           0x0100  /* Full duplex                 */
+#define BMCR_ANRESTART          0x0200  /* Auto negotiation restart    */
+#define BMCR_ISOLATE            0x0400  /* Disconnect DP83840 from MII */
+#define BMCR_PDOWN              0x0800  /* Powerdown the DP83840       */
+#define BMCR_ANENABLE           0x1000  /* Enable auto negotiation     */
+#define BMCR_SPEED100           0x2000  /* Select 100Mbps              */
+#define BMCR_LOOPBACK           0x4000  /* TXD loopback bits           */
+#define BMCR_RESET              0x8000  /* Reset the DP83840           */
+
+/* Basic mode status register. */
+#define BMSR_ERCAP              0x0001  /* Ext-reg capability          */
+#define BMSR_JCD                0x0002  /* Jabber detected             */
+#define BMSR_LSTATUS            0x0004  /* Link status                 */
+#define BMSR_ANEGCAPABLE        0x0008  /* Able to do auto-negotiation */
+#define BMSR_RFAULT             0x0010  /* Remote fault detected       */
+#define BMSR_ANEGCOMPLETE       0x0020  /* Auto-negotiation complete   */
+#define BMSR_RESV               0x07c0  /* Unused...                   */
+#define BMSR_10HALF             0x0800  /* Can do 10mbps, half-duplex  */
+#define BMSR_10FULL             0x1000  /* Can do 10mbps, full-duplex  */
+#define BMSR_100HALF            0x2000  /* Can do 100mbps, half-duplex */
+#define BMSR_100FULL            0x4000  /* Can do 100mbps, full-duplex */
+#define BMSR_100BASE4           0x8000  /* Can do 100mbps, 4k packets  */
+
+/* Advertisement control register. */
+#define ADVERTISE_SLCT          0x001f  /* Selector bits               */
+#define ADVERTISE_CSMA          0x0001  /* Only selector supported     */
+#define ADVERTISE_10HALF        0x0020  /* Try for 10mbps half-duplex  */
+#define ADVERTISE_10FULL        0x0040  /* Try for 10mbps full-duplex  */
+#define ADVERTISE_100HALF       0x0080  /* Try for 100mbps half-duplex */
+#define ADVERTISE_100FULL       0x0100  /* Try for 100mbps full-duplex */
+#define ADVERTISE_100BASE4      0x0200  /* Try for 100mbps 4k packets  */
+#define ADVERTISE_PAUSE_CAP     0x0400  /* Try for pause               */
+#define ADVERTISE_PAUSE_ASYM    0x0800  /* Try for asymetric pause     */
+#define ADVERTISE_RESV          0x1000  /* Unused...                   */
+#define ADVERTISE_RFAULT        0x2000  /* Say we can detect faults    */
+#define ADVERTISE_LPACK         0x4000  /* Ack link partners response  */
+#define ADVERTISE_NPAGE         0x8000  /* Next page bit               */
+
+#define ADVERTISE_FULL (ADVERTISE_100FULL | ADVERTISE_10FULL | \
+                        ADVERTISE_CSMA)
+#define ADVERTISE_ALL (ADVERTISE_10HALF | ADVERTISE_10FULL | \
+                       ADVERTISE_100HALF | ADVERTISE_100FULL)
+
+/* Link partner ability register. */
+#define LPA_SLCT                0x001f  /* Same as advertise selector  */
+#define LPA_10HALF              0x0020  /* Can do 10mbps half-duplex   */
+#define LPA_10FULL              0x0040  /* Can do 10mbps full-duplex   */
+#define LPA_100HALF             0x0080  /* Can do 100mbps half-duplex  */
+#define LPA_100FULL             0x0100  /* Can do 100mbps full-duplex  */
+#define LPA_100BASE4            0x0200  /* Can do 100mbps 4k packets   */
+#define LPA_PAUSE_CAP           0x0400  /* Can pause                   */
+#define LPA_PAUSE_ASYM          0x0800  /* Can pause asymetrically     */
+#define LPA_RESV                0x1000  /* Unused...                   */
+#define LPA_RFAULT              0x2000  /* Link partner faulted        */
+#define LPA_LPACK               0x4000  /* Link partner acked us       */
+#define LPA_NPAGE               0x8000  /* Next page bit               */
+
+#define LPA_DUPLEX              (LPA_10FULL | LPA_100FULL)
+#define LPA_100                 (LPA_100FULL | LPA_100HALF | LPA_100BASE4)
+
+/* Expansion register for auto-negotiation. */
+#define EXPANSION_NWAY          0x0001  /* Can do N-way auto-nego      */
+#define EXPANSION_LCWP          0x0002  /* Got new RX page code word   */
+#define EXPANSION_ENABLENPAGE   0x0004  /* This enables npage words    */
+#define EXPANSION_NPCAPABLE     0x0008  /* Link partner supports npage */
+#define EXPANSION_MFAULTS       0x0010  /* Multiple faults detected    */
+#define EXPANSION_RESV          0xffe0  /* Unused...                   */
+
+/* N-way test register. */
+#define NWAYTEST_RESV1          0x00ff  /* Unused...                   */
+#define NWAYTEST_LOOPBACK       0x0100  /* Enable loopback for N-way   */
+#define NWAYTEST_RESV2          0xfe00  /* Unused...                   */
+
+/* 1000BASE-T Control register */
+#define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
+#define ADVERTISE_1000HALF      0x0100  /* Advertise 1000BASE-T half duplex */
+
+/* 1000BASE-T Status register */
+#define LPA_1000LOCALRXOK       0x2000  /* Link partner local receiver status */
+#define LPA_1000REMRXOK         0x1000  /* Link partner remote receiver status */
+#define LPA_1000FULL            0x0800  /* Link partner 1000BASE-T full duplex */
+#define LPA_1000HALF            0x0400  /* Link partner 1000BASE-T half duplex */
+
+struct mii_if_info {
+        int phy_id;
+        int advertising;
+        int phy_id_mask;
+        int reg_num_mask;
+
+        unsigned int full_duplex : 1;   /* is full duplex? */
+        unsigned int force_media : 1;   /* is autoneg. disabled? */
+        unsigned int supports_gmii : 1; /* are GMII registers supported? */
+
+        struct net_device *dev;
+        int (*mdio_read) (struct net_device *dev, int phy_id, int location);
+        void (*mdio_write) (struct net_device *dev, int phy_id, int location, int val);
+};
+
+struct ethtool_cmd;
+struct mii_ioctl_data;
+
+extern int mii_link_ok (struct mii_if_info *mii);
+extern int mii_nway_restart (struct mii_if_info *mii);
+extern int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
+extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
+extern void mii_check_link (struct mii_if_info *mii);
+extern unsigned int mii_check_media (struct mii_if_info *mii,
+                                     unsigned int ok_to_print,
+                                     unsigned int init_media);
+extern int generic_mii_ioctl(struct mii_if_info *mii_if,
+                             struct mii_ioctl_data *mii_data, int cmd,
+                             unsigned int *duplex_changed);
+
+
+
+/* This structure is used in all SIOCxMIIxxx ioctl calls */
+struct mii_ioctl_data {
+        u16             phy_id;
+        u16             reg_num;
+        u16             val_in;
+        u16             val_out;
+};
+
+
+static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
+{
+        return (struct mii_ioctl_data *) &rq->ifr_ifru;
+}
+
+
+/**
+ * mii_nway_result
+ * @negotiated: value of MII ANAR and'd with ANLPAR
+ *
+ * Given a set of MII abilities, check each bit and returns the
+ * currently supported media, in the priority order defined by
+ * IEEE 802.3u.  We use LPA_xxx constants but note this is not the
+ * value of LPA solely, as described above.
+ *
+ * The one exception to IEEE 802.3u is that 100baseT4 is placed
+ * between 100T-full and 100T-half.  If your phy does not support
+ * 100T4 this is fine.  If your phy places 100T4 elsewhere in the
+ * priority order, you will need to roll your own function.
+ */
+static inline unsigned int mii_nway_result (unsigned int negotiated)
+{
+        unsigned int ret;
+
+        if (negotiated & LPA_100FULL)
+                ret = LPA_100FULL;
+        else if (negotiated & LPA_100BASE4)
+                ret = LPA_100BASE4;
+        else if (negotiated & LPA_100HALF)
+                ret = LPA_100HALF;
+        else if (negotiated & LPA_10FULL)
+                ret = LPA_10FULL;
+        else
+                ret = LPA_10HALF;
+
+        return ret;
+}
+
+/**
+ * mii_duplex
+ * @duplex_lock: Non-zero if duplex is locked at full
+ * @negotiated: value of MII ANAR and'd with ANLPAR
+ *
+ * A small helper function for a common case.  Returns one
+ * if the media is operating or locked at full duplex, and
+ * returns zero otherwise.
+ */
+static inline unsigned int mii_duplex (unsigned int duplex_lock,
+                                       unsigned int negotiated)
+{
+        if (duplex_lock)
+                return 1;
+        if (mii_nway_result(negotiated) & LPA_DUPLEX)
+                return 1;
+        return 0;
+}
+
+
+#endif /* __LINUX_MII_H__ */
diff --git a/include/linux/minix_fs.h b/include/linux/minix_fs.h
new file mode 100644
index 000000000000..1ecc3cc8cef5
--- /dev/null
+++ b/include/linux/minix_fs.h
@@ -0,0 +1,85 @@
+#ifndef _LINUX_MINIX_FS_H
+#define _LINUX_MINIX_FS_H
+
+/*
+ * The minix filesystem constants/structures
+ */
+
+/*
+ * Thanks to Kees J Bot for sending me the definitions of the new
+ * minix filesystem (aka V2) with bigger inodes and 32-bit block
+ * pointers.
+ */
+
+#define MINIX_ROOT_INO 1
+
+/* Not the same as the bogus LINK_MAX in <linux/limits.h>. Oh well. */
+#define MINIX_LINK_MAX  250
+#define MINIX2_LINK_MAX 65530
+
+#define MINIX_I_MAP_SLOTS       8
+#define MINIX_Z_MAP_SLOTS       64
+#define MINIX_SUPER_MAGIC       0x137F          /* original minix fs */
+#define MINIX_SUPER_MAGIC2      0x138F          /* minix fs, 30 char names */
+#define MINIX2_SUPER_MAGIC      0x2468          /* minix V2 fs */
+#define MINIX2_SUPER_MAGIC2     0x2478          /* minix V2 fs, 30 char names */
+#define MINIX_VALID_FS          0x0001          /* Clean fs. */
+#define MINIX_ERROR_FS          0x0002          /* fs has errors. */
+
+#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
+#define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
+
+/*
+ * This is the original minix inode layout on disk.
+ * Note the 8-bit gid and atime and ctime.
+ */
+struct minix_inode {
+        __u16 i_mode;
+        __u16 i_uid;
+        __u32 i_size;
+        __u32 i_time;
+        __u8  i_gid;
+        __u8  i_nlinks;
+        __u16 i_zone[9];
+};
+
+/*
+ * The new minix inode has all the time entries, as well as
+ * long block numbers and a third indirect block (7+1+1+1
+ * instead of 7+1+1). Also, some previously 8-bit values are
+ * now 16-bit. The inode is now 64 bytes instead of 32.
+ */
+struct minix2_inode {
+        __u16 i_mode;
+        __u16 i_nlinks;
+        __u16 i_uid;
+        __u16 i_gid;
+        __u32 i_size;
+        __u32 i_atime;
+        __u32 i_mtime;
+        __u32 i_ctime;
+        __u32 i_zone[10];
+};
+
+/*
+ * minix super-block data on disk
+ */
+struct minix_super_block {
+        __u16 s_ninodes;
+        __u16 s_nzones;
+        __u16 s_imap_blocks;
+        __u16 s_zmap_blocks;
+        __u16 s_firstdatazone;
+        __u16 s_log_zone_size;
+        __u32 s_max_size;
+        __u16 s_magic;
+        __u16 s_state;
+        __u32 s_zones;
+};
+
+struct minix_dir_entry {
+        __u16 inode;
+        char name[0];
+};
+
+#endif
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
new file mode 100644
index 000000000000..14ceebfc1efa
--- /dev/null
+++ b/include/linux/miscdevice.h
@@ -0,0 +1,52 @@
+#ifndef _LINUX_MISCDEVICE_H
+#define _LINUX_MISCDEVICE_H
+#include <linux/module.h>
+#include <linux/major.h>
+
+#define PSMOUSE_MINOR  1
+#define MS_BUSMOUSE_MINOR 2
+#define ATIXL_BUSMOUSE_MINOR 3
+/*#define AMIGAMOUSE_MINOR 4    FIXME OBSOLETE */
+#define ATARIMOUSE_MINOR 5
+#define SUN_MOUSE_MINOR 6
+#define APOLLO_MOUSE_MINOR 7
+#define PC110PAD_MINOR 9
+/*#define ADB_MOUSE_MINOR 10    FIXME OBSOLETE */
+#define WATCHDOG_MINOR          130     /* Watchdog timer     */
+#define TEMP_MINOR              131     /* Temperature Sensor */
+#define RTC_MINOR 135
+#define EFI_RTC_MINOR           136     /* EFI Time services */
+#define SUN_OPENPROM_MINOR 139
+#define DMAPI_MINOR             140     /* DMAPI */
+#define NVRAM_MINOR 144
+#define SGI_MMTIMER        153
+#define STORE_QUEUE_MINOR       155
+#define I2O_MINOR 166
+#define MICROCODE_MINOR         184
+#define MWAVE_MINOR     219             /* ACP/Mwave Modem */
+#define MPT_MINOR       220
+#define MISC_DYNAMIC_MINOR 255
+
+#define TUN_MINOR            200
+#define HPET_MINOR           228
+
+struct device;
+struct class_device;
+
+struct miscdevice  {
+        int minor;
+        const char *name;
+        struct file_operations *fops;
+        struct list_head list;
+        struct device *dev;
+        struct class_device *class;
+        char devfs_name[64];
+};
+
+extern int misc_register(struct miscdevice * misc);
+extern int misc_deregister(struct miscdevice * misc);
+
+#define MODULE_ALIAS_MISCDEV(minor)                             \
+        MODULE_ALIAS("char-major-" __stringify(MISC_MAJOR)      \
+        "-" __stringify(minor))
+#endif
diff --git a/include/linux/mm.h b/include/linux/mm.h
new file mode 100644
index 000000000000..6a931374d6c4
--- /dev/null
+++ b/include/linux/mm.h
@@ -0,0 +1,861 @@
+#ifndef _LINUX_MM_H
+#define _LINUX_MM_H
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/gfp.h>
+#include <linux/list.h>
+#include <linux/mmzone.h>
+#include <linux/rbtree.h>
+#include <linux/prio_tree.h>
+#include <linux/fs.h>
+
+struct mempolicy;
+struct anon_vma;
+
+#ifndef CONFIG_DISCONTIGMEM          /* Don't use mapnrs, do it properly */
+extern unsigned long max_mapnr;
+#endif
+
+extern unsigned long num_physpages;
+extern void * high_memory;
+extern unsigned long vmalloc_earlyreserve;
+extern int page_cluster;
+
+#ifdef CONFIG_SYSCTL
+extern int sysctl_legacy_va_layout;
+#else
+#define sysctl_legacy_va_layout 0
+#endif
+
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/processor.h>
+#include <asm/atomic.h>
+
+#ifndef MM_VM_SIZE
+#define MM_VM_SIZE(mm)  ((TASK_SIZE + PGDIR_SIZE - 1) & PGDIR_MASK)
+#endif
+
+#define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n))
+
+/*
+ * Linux kernel virtual memory manager primitives.
+ * The idea being to have a "virtual" mm in the same way
+ * we have a virtual fs - giving a cleaner interface to the
+ * mm details, and allowing different kinds of memory mappings
+ * (from shared memory to executable loading to arbitrary
+ * mmap() functions).
+ */
+
+/*
+ * This struct defines a memory VMM memory area. There is one of these
+ * per VM-area/task.  A VM area is any part of the process virtual memory
+ * space that has a special rule for the page-fault handlers (ie a shared
+ * library, the executable area etc).
+ */
+struct vm_area_struct {
+        struct mm_struct * vm_mm;       /* The address space we belong to. */
+        unsigned long vm_start;         /* Our start address within vm_mm. */
+        unsigned long vm_end;           /* The first byte after our end address
+                                           within vm_mm. */
+
+        /* linked list of VM areas per task, sorted by address */
+        struct vm_area_struct *vm_next;
+
+        pgprot_t vm_page_prot;          /* Access permissions of this VMA. */
+        unsigned long vm_flags;         /* Flags, listed below. */
+
+        struct rb_node vm_rb;
+
+        /*
+         * For areas with an address space and backing store,
+         * linkage into the address_space->i_mmap prio tree, or
+         * linkage to the list of like vmas hanging off its node, or
+         * linkage of vma in the address_space->i_mmap_nonlinear list.
+         */
+        union {
+                struct {
+                        struct list_head list;
+                        void *parent;   /* aligns with prio_tree_node parent */
+                        struct vm_area_struct *head;
+                } vm_set;
+
+                struct raw_prio_tree_node prio_tree_node;
+        } shared;
+
+        /*
+         * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
+         * list, after a COW of one of the file pages.  A MAP_SHARED vma
+         * can only be in the i_mmap tree.  An anonymous MAP_PRIVATE, stack
+         * or brk vma (with NULL file) can only be in an anon_vma list.
+         */
+        struct list_head anon_vma_node; /* Serialized by anon_vma->lock */
+        struct anon_vma *anon_vma;      /* Serialized by page_table_lock */
+
+        /* Function pointers to deal with this struct. */
+        struct vm_operations_struct * vm_ops;
+
+        /* Information about our backing store: */
+        unsigned long vm_pgoff;         /* Offset (within vm_file) in PAGE_SIZE
+                                           units, *not* PAGE_CACHE_SIZE */
+        struct file * vm_file;          /* File we map to (can be NULL). */
+        void * vm_private_data;         /* was vm_pte (shared mem) */
+        unsigned long vm_truncate_count;/* truncate_count or restart_addr */
+
+#ifndef CONFIG_MMU
+        atomic_t vm_usage;              /* refcount (VMAs shared if !MMU) */
+#endif
+#ifdef CONFIG_NUMA
+        struct mempolicy *vm_policy;    /* NUMA policy for the VMA */
+#endif
+};
+
+/*
+ * This struct defines the per-mm list of VMAs for uClinux. If CONFIG_MMU is
+ * disabled, then there's a single shared list of VMAs maintained by the
+ * system, and mm's subscribe to these individually
+ */
+struct vm_list_struct {
+        struct vm_list_struct   *next;
+        struct vm_area_struct   *vma;
+};
+
+#ifndef CONFIG_MMU
+extern struct rb_root nommu_vma_tree;
+extern struct rw_semaphore nommu_vma_sem;
+
+extern unsigned int kobjsize(const void *objp);
+#endif
+
+/*
+ * vm_flags..
+ */
+#define VM_READ         0x00000001      /* currently active flags */
+#define VM_WRITE        0x00000002
+#define VM_EXEC         0x00000004
+#define VM_SHARED       0x00000008
+
+#define VM_MAYREAD      0x00000010      /* limits for mprotect() etc */
+#define VM_MAYWRITE     0x00000020
+#define VM_MAYEXEC      0x00000040
+#define VM_MAYSHARE     0x00000080
+
+#define VM_GROWSDOWN    0x00000100      /* general info on the segment */
+#define VM_GROWSUP      0x00000200
+#define VM_SHM          0x00000400      /* shared memory area, don't swap out */
+#define VM_DENYWRITE    0x00000800      /* ETXTBSY on write attempts.. */
+
+#define VM_EXECUTABLE   0x00001000
+#define VM_LOCKED       0x00002000
+#define VM_IO           0x00004000      /* Memory mapped I/O or similar */
+
+                                        /* Used by sys_madvise() */
+#define VM_SEQ_READ     0x00008000      /* App will access data sequentially */
+#define VM_RAND_READ    0x00010000      /* App will not benefit from clustered reads */
+
+#define VM_DONTCOPY     0x00020000      /* Do not copy this vma on fork */
+#define VM_DONTEXPAND   0x00040000      /* Cannot expand with mremap() */
+#define VM_RESERVED     0x00080000      /* Don't unmap it from swap_out */
+#define VM_ACCOUNT      0x00100000      /* Is a VM accounted object */
+#define VM_HUGETLB      0x00400000      /* Huge TLB Page VM */
+#define VM_NONLINEAR    0x00800000      /* Is non-linear (remap_file_pages) */
+#define VM_MAPPED_COPY  0x01000000      /* T if mapped copy of data (nommu mmap) */
+
+#ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
+#define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
+#endif
+
+#ifdef CONFIG_STACK_GROWSUP
+#define VM_STACK_FLAGS  (VM_GROWSUP | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
+#else
+#define VM_STACK_FLAGS  (VM_GROWSDOWN | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT)
+#endif
+
+#define VM_READHINTMASK                 (VM_SEQ_READ | VM_RAND_READ)
+#define VM_ClearReadHint(v)             (v)->vm_flags &= ~VM_READHINTMASK
+#define VM_NormalReadHint(v)            (!((v)->vm_flags & VM_READHINTMASK))
+#define VM_SequentialReadHint(v)        ((v)->vm_flags & VM_SEQ_READ)
+#define VM_RandomReadHint(v)            ((v)->vm_flags & VM_RAND_READ)
+
+/*
+ * mapping from the currently active vm_flags protection bits (the
+ * low four bits) to a page protection mask..
+ */
+extern pgprot_t protection_map[16];
+
+
+/*
+ * These are the virtual MM functions - opening of an area, closing and
+ * unmapping it (needed to keep files on disk up-to-date etc), pointer
+ * to the functions called when a no-page or a wp-page exception occurs. 
+ */
+struct vm_operations_struct {
+        void (*open)(struct vm_area_struct * area);
+        void (*close)(struct vm_area_struct * area);
+        struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
+        int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
+#ifdef CONFIG_NUMA
+        int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
+        struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
+                                        unsigned long addr);
+#endif
+};
+
+struct mmu_gather;
+struct inode;
+
+#ifdef ARCH_HAS_ATOMIC_UNSIGNED
+typedef unsigned page_flags_t;
+#else
+typedef unsigned long page_flags_t;
+#endif
+
+/*
+ * Each physical page in the system has a struct page associated with
+ * it to keep track of whatever it is we are using the page for at the
+ * moment. Note that we have no way to track which tasks are using
+ * a page.
+ */
+struct page {
+        page_flags_t flags;             /* Atomic flags, some possibly
+                                         * updated asynchronously */
+        atomic_t _count;                /* Usage count, see below. */
+        atomic_t _mapcount;             /* Count of ptes mapped in mms,
+                                         * to show when page is mapped
+                                         * & limit reverse map searches.
+                                         */
+        unsigned long private;          /* Mapping-private opaque data:
+                                         * usually used for buffer_heads
+                                         * if PagePrivate set; used for
+                                         * swp_entry_t if PageSwapCache
+                                         * When page is free, this indicates
+                                         * order in the buddy system.
+                                         */
+        struct address_space *mapping;  /* If low bit clear, points to
+                                         * inode address_space, or NULL.
+                                         * If page mapped as anonymous
+                                         * memory, low bit is set, and
+                                         * it points to anon_vma object:
+                                         * see PAGE_MAPPING_ANON below.
+                                         */
+        pgoff_t index;                  /* Our offset within mapping. */
+        struct list_head lru;           /* Pageout list, eg. active_list
+                                         * protected by zone->lru_lock !
+                                         */
+        /*
+         * On machines where all RAM is mapped into kernel address space,
+         * we can simply calculate the virtual address. On machines with
+         * highmem some memory is mapped into kernel virtual memory
+         * dynamically, so we need a place to store that address.
+         * Note that this field could be 16 bits on x86 ... ;)
+         *
+         * Architectures with slow multiplication can define
+         * WANT_PAGE_VIRTUAL in asm/page.h
+         */
+#if defined(WANT_PAGE_VIRTUAL)
+        void *virtual;                  /* Kernel virtual address (NULL if
+                                           not kmapped, ie. highmem) */
+#endif /* WANT_PAGE_VIRTUAL */
+};
+
+/*
+ * FIXME: take this include out, include page-flags.h in
+ * files which need it (119 of them)
+ */
+#include <linux/page-flags.h>
+
+/*
+ * Methods to modify the page usage count.
+ *
+ * What counts for a page usage:
+ * - cache mapping   (page->mapping)
+ * - private data    (page->private)
+ * - page mapped in a task's page tables, each mapping
+ *   is counted separately
+ *
+ * Also, many kernel routines increase the page count before a critical
+ * routine so they can be sure the page doesn't go away from under them.
+ *
+ * Since 2.6.6 (approx), a free page has ->_count = -1.  This is so that we
+ * can use atomic_add_negative(-1, page->_count) to detect when the page
+ * becomes free and so that we can also use atomic_inc_and_test to atomically
+ * detect when we just tried to grab a ref on a page which some other CPU has
+ * already deemed to be freeable.
+ *
+ * NO code should make assumptions about this internal detail!  Use the provided
+ * macros which retain the old rules: page_count(page) == 0 is a free page.
+ */
+
+/*
+ * Drop a ref, return true if the logical refcount fell to zero (the page has
+ * no users)
+ */
+#define put_page_testzero(p)                            \
+        ({                                              \
+                BUG_ON(page_count(p) == 0);             \
+                atomic_add_negative(-1, &(p)->_count);  \
+        })
+
+/*
+ * Grab a ref, return true if the page previously had a logical refcount of
+ * zero.  ie: returns true if we just grabbed an already-deemed-to-be-free page
+ */
+#define get_page_testone(p)     atomic_inc_and_test(&(p)->_count)
+
+#define set_page_count(p,v)     atomic_set(&(p)->_count, v - 1)
+#define __put_page(p)           atomic_dec(&(p)->_count)
+
+extern void FASTCALL(__page_cache_release(struct page *));
+
+#ifdef CONFIG_HUGETLB_PAGE
+
+static inline int page_count(struct page *p)
+{
+        if (PageCompound(p))
+                p = (struct page *)p->private;
+        return atomic_read(&(p)->_count) + 1;
+}
+
+static inline void get_page(struct page *page)
+{
+        if (unlikely(PageCompound(page)))
+                page = (struct page *)page->private;
+        atomic_inc(&page->_count);
+}
+
+void put_page(struct page *page);
+
+#else           /* CONFIG_HUGETLB_PAGE */
+
+#define page_count(p)           (atomic_read(&(p)->_count) + 1)
+
+static inline void get_page(struct page *page)
+{
+        atomic_inc(&page->_count);
+}
+
+static inline void put_page(struct page *page)
+{
+        if (!PageReserved(page) && put_page_testzero(page))
+                __page_cache_release(page);
+}
+
+#endif          /* CONFIG_HUGETLB_PAGE */
+
+/*
+ * Multiple processes may "see" the same page. E.g. for untouched
+ * mappings of /dev/null, all processes see the same page full of
+ * zeroes, and text pages of executables and shared libraries have
+ * only one copy in memory, at most, normally.
+ *
+ * For the non-reserved pages, page_count(page) denotes a reference count.
+ *   page_count() == 0 means the page is free.
+ *   page_count() == 1 means the page is used for exactly one purpose
+ *   (e.g. a private data page of one process).
+ *
+ * A page may be used for kmalloc() or anyone else who does a
+ * __get_free_page(). In this case the page_count() is at least 1, and
+ * all other fields are unused but should be 0 or NULL. The
+ * management of this page is the responsibility of the one who uses
+ * it.
+ *
+ * The other pages (we may call them "process pages") are completely
+ * managed by the Linux memory manager: I/O, buffers, swapping etc.
+ * The following discussion applies only to them.
+ *
+ * A page may belong to an inode's memory mapping. In this case,
+ * page->mapping is the pointer to the inode, and page->index is the
+ * file offset of the page, in units of PAGE_CACHE_SIZE.
+ *
+ * A page contains an opaque `private' member, which belongs to the
+ * page's address_space.  Usually, this is the address of a circular
+ * list of the page's disk buffers.
+ *
+ * For pages belonging to inodes, the page_count() is the number of
+ * attaches, plus 1 if `private' contains something, plus one for
+ * the page cache itself.
+ *
+ * All pages belonging to an inode are in these doubly linked lists:
+ * mapping->clean_pages, mapping->dirty_pages and mapping->locked_pages;
+ * using the page->list list_head. These fields are also used for
+ * freelist managemet (when page_count()==0).
+ *
+ * There is also a per-mapping radix tree mapping index to the page
+ * in memory if present. The tree is rooted at mapping->root.  
+ *
+ * All process pages can do I/O:
+ * - inode pages may need to be read from disk,
+ * - inode pages which have been modified and are MAP_SHARED may need
+ *   to be written to disk,
+ * - private pages which have been modified may need to be swapped out
+ *   to swap space and (later) to be read back into memory.
+ */
+
+/*
+ * The zone field is never updated after free_area_init_core()
+ * sets it, so none of the operations on it need to be atomic.
+ * We'll have up to (MAX_NUMNODES * MAX_NR_ZONES) zones total,
+ * so we use (MAX_NODES_SHIFT + MAX_ZONES_SHIFT) here to get enough bits.
+ */
+#define NODEZONE_SHIFT (sizeof(page_flags_t)*8 - MAX_NODES_SHIFT - MAX_ZONES_SHIFT)
+#define NODEZONE(node, zone)    ((node << ZONES_SHIFT) | zone)
+
+static inline unsigned long page_zonenum(struct page *page)
+{
+        return (page->flags >> NODEZONE_SHIFT) & (~(~0UL << ZONES_SHIFT));
+}
+static inline unsigned long page_to_nid(struct page *page)
+{
+        return (page->flags >> (NODEZONE_SHIFT + ZONES_SHIFT));
+}
+
+struct zone;
+extern struct zone *zone_table[];
+
+static inline struct zone *page_zone(struct page *page)
+{
+        return zone_table[page->flags >> NODEZONE_SHIFT];
+}
+
+static inline void set_page_zone(struct page *page, unsigned long nodezone_num)
+{
+        page->flags &= ~(~0UL << NODEZONE_SHIFT);
+        page->flags |= nodezone_num << NODEZONE_SHIFT;
+}
+
+#ifndef CONFIG_DISCONTIGMEM
+/* The array of struct pages - for discontigmem use pgdat->lmem_map */
+extern struct page *mem_map;
+#endif
+
+static inline void *lowmem_page_address(struct page *page)
+{
+        return __va(page_to_pfn(page) << PAGE_SHIFT);
+}
+
+#if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
+#define HASHED_PAGE_VIRTUAL
+#endif
+
+#if defined(WANT_PAGE_VIRTUAL)
+#define page_address(page) ((page)->virtual)
+#define set_page_address(page, address)                 \
+        do {                                            \
+                (page)->virtual = (address);            \
+        } while(0)
+#define page_address_init()  do { } while(0)
+#endif
+
+#if defined(HASHED_PAGE_VIRTUAL)
+void *page_address(struct page *page);
+void set_page_address(struct page *page, void *virtual);
+void page_address_init(void);
+#endif
+
+#if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL)
+#define page_address(page) lowmem_page_address(page)
+#define set_page_address(page, address)  do { } while(0)
+#define page_address_init()  do { } while(0)
+#endif
+
+/*
+ * On an anonymous page mapped into a user virtual memory area,
+ * page->mapping points to its anon_vma, not to a struct address_space;
+ * with the PAGE_MAPPING_ANON bit set to distinguish it.
+ *
+ * Please note that, confusingly, "page_mapping" refers to the inode
+ * address_space which maps the page from disk; whereas "page_mapped"
+ * refers to user virtual address space into which the page is mapped.
+ */
+#define PAGE_MAPPING_ANON       1
+
+extern struct address_space swapper_space;
+static inline struct address_space *page_mapping(struct page *page)
+{
+        struct address_space *mapping = page->mapping;
+
+        if (unlikely(PageSwapCache(page)))
+                mapping = &swapper_space;
+        else if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
+                mapping = NULL;
+        return mapping;
+}
+
+static inline int PageAnon(struct page *page)
+{
+        return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
+}
+
+/*
+ * Return the pagecache index of the passed page.  Regular pagecache pages
+ * use ->index whereas swapcache pages use ->private
+ */
+static inline pgoff_t page_index(struct page *page)
+{
+        if (unlikely(PageSwapCache(page)))
+                return page->private;
+        return page->index;
+}
+
+/*
+ * The atomic page->_mapcount, like _count, starts from -1:
+ * so that transitions both from it and to it can be tracked,
+ * using atomic_inc_and_test and atomic_add_negative(-1).
+ */
+static inline void reset_page_mapcount(struct page *page)
+{
+        atomic_set(&(page)->_mapcount, -1);
+}
+
+static inline int page_mapcount(struct page *page)
+{
+        return atomic_read(&(page)->_mapcount) + 1;
+}
+
+/*
+ * Return true if this page is mapped into pagetables.
+ */
+static inline int page_mapped(struct page *page)
+{
+        return atomic_read(&(page)->_mapcount) >= 0;
+}
+
+/*
+ * Error return values for the *_nopage functions
+ */
+#define NOPAGE_SIGBUS   (NULL)
+#define NOPAGE_OOM      ((struct page *) (-1))
+
+/*
+ * Different kinds of faults, as returned by handle_mm_fault().
+ * Used to decide whether a process gets delivered SIGBUS or
+ * just gets major/minor fault counters bumped up.
+ */
+#define VM_FAULT_OOM    (-1)
+#define VM_FAULT_SIGBUS 0
+#define VM_FAULT_MINOR  1
+#define VM_FAULT_MAJOR  2
+
+#define offset_in_page(p)       ((unsigned long)(p) & ~PAGE_MASK)
+
+extern void show_free_areas(void);
+
+#ifdef CONFIG_SHMEM
+struct page *shmem_nopage(struct vm_area_struct *vma,
+                        unsigned long address, int *type);
+int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *new);
+struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
+                                        unsigned long addr);
+int shmem_lock(struct file *file, int lock, struct user_struct *user);
+#else
+#define shmem_nopage filemap_nopage
+#define shmem_lock(a, b, c)     ({0;})  /* always in memory, no need to lock */
+#define shmem_set_policy(a, b)  (0)
+#define shmem_get_policy(a, b)  (NULL)
+#endif
+struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
+
+int shmem_zero_setup(struct vm_area_struct *);
+
+static inline int can_do_mlock(void)
+{
+        if (capable(CAP_IPC_LOCK))
+                return 1;
+        if (current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur != 0)
+                return 1;
+        return 0;
+}
+extern int user_shm_lock(size_t, struct user_struct *);
+extern void user_shm_unlock(size_t, struct user_struct *);
+
+/*
+ * Parameter block passed down to zap_pte_range in exceptional cases.
+ */
+struct zap_details {
+        struct vm_area_struct *nonlinear_vma;   /* Check page->index if set */
+        struct address_space *check_mapping;    /* Check page->mapping if set */
+        pgoff_t first_index;                    /* Lowest page->index to unmap */
+        pgoff_t last_index;                     /* Highest page->index to unmap */
+        spinlock_t *i_mmap_lock;                /* For unmap_mapping_range: */
+        unsigned long break_addr;               /* Where unmap_vmas stopped */
+        unsigned long truncate_count;           /* Compare vm_truncate_count */
+};
+
+void zap_page_range(struct vm_area_struct *vma, unsigned long address,
+                unsigned long size, struct zap_details *);
+int unmap_vmas(struct mmu_gather **tlbp, struct mm_struct *mm,
+                struct vm_area_struct *start_vma, unsigned long start_addr,
+                unsigned long end_addr, unsigned long *nr_accounted,
+                struct zap_details *);
+void clear_page_range(struct mmu_gather *tlb, unsigned long addr, unsigned long end);
+int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
+                        struct vm_area_struct *vma);
+int zeromap_page_range(struct vm_area_struct *vma, unsigned long from,
+                        unsigned long size, pgprot_t prot);
+void unmap_mapping_range(struct address_space *mapping,
+                loff_t const holebegin, loff_t const holelen, int even_cows);
+
+static inline void unmap_shared_mapping_range(struct address_space *mapping,
+                loff_t const holebegin, loff_t const holelen)
+{
+        unmap_mapping_range(mapping, holebegin, holelen, 0);
+}
+
+extern int vmtruncate(struct inode * inode, loff_t offset);
+extern pud_t *FASTCALL(__pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address));
+extern pmd_t *FASTCALL(__pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address));
+extern pte_t *FASTCALL(pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
+extern pte_t *FASTCALL(pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
+extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
+extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
+extern int handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
+extern int make_pages_present(unsigned long addr, unsigned long end);
+extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
+void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
+
+int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
+                int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
+
+int __set_page_dirty_buffers(struct page *page);
+int __set_page_dirty_nobuffers(struct page *page);
+int redirty_page_for_writepage(struct writeback_control *wbc,
+                                struct page *page);
+int FASTCALL(set_page_dirty(struct page *page));
+int set_page_dirty_lock(struct page *page);
+int clear_page_dirty_for_io(struct page *page);
+
+extern unsigned long do_mremap(unsigned long addr,
+                               unsigned long old_len, unsigned long new_len,
+                               unsigned long flags, unsigned long new_addr);
+
+/*
+ * Prototype to add a shrinker callback for ageable caches.
+ * 
+ * These functions are passed a count `nr_to_scan' and a gfpmask.  They should
+ * scan `nr_to_scan' objects, attempting to free them.
+ *
+ * The callback must the number of objects which remain in the cache.
+ *
+ * The callback will be passes nr_to_scan == 0 when the VM is querying the
+ * cache size, so a fastpath for that case is appropriate.
+ */
+typedef int (*shrinker_t)(int nr_to_scan, unsigned int gfp_mask);
+
+/*
+ * Add an aging callback.  The int is the number of 'seeks' it takes
+ * to recreate one of the objects that these functions age.
+ */
+
+#define DEFAULT_SEEKS 2
+struct shrinker;
+extern struct shrinker *set_shrinker(int, shrinker_t);
+extern void remove_shrinker(struct shrinker *shrinker);
+
+/*
+ * On a two-level or three-level page table, this ends up being trivial. Thus
+ * the inlining and the symmetry break with pte_alloc_map() that does all
+ * of this out-of-line.
+ */
+/*
+ * The following ifdef needed to get the 4level-fixup.h header to work.
+ * Remove it when 4level-fixup.h has been removed.
+ */
+#ifdef CONFIG_MMU
+#ifndef __ARCH_HAS_4LEVEL_HACK 
+static inline pud_t *pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address)
+{
+        if (pgd_none(*pgd))
+                return __pud_alloc(mm, pgd, address);
+        return pud_offset(pgd, address);
+}
+
+static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
+{
+        if (pud_none(*pud))
+                return __pmd_alloc(mm, pud, address);
+        return pmd_offset(pud, address);
+}
+#endif
+#endif /* CONFIG_MMU */
+
+extern void free_area_init(unsigned long * zones_size);
+extern void free_area_init_node(int nid, pg_data_t *pgdat,
+        unsigned long * zones_size, unsigned long zone_start_pfn, 
+        unsigned long *zholes_size);
+extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long);
+extern void mem_init(void);
+extern void show_mem(void);
+extern void si_meminfo(struct sysinfo * val);
+extern void si_meminfo_node(struct sysinfo *val, int nid);
+
+/* prio_tree.c */
+void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
+void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
+void vma_prio_tree_remove(struct vm_area_struct *, struct prio_tree_root *);
+struct vm_area_struct *vma_prio_tree_next(struct vm_area_struct *vma,
+        struct prio_tree_iter *iter);
+
+#define vma_prio_tree_foreach(vma, iter, root, begin, end)      \
+        for (prio_tree_iter_init(iter, root, begin, end), vma = NULL;   \
+                (vma = vma_prio_tree_next(vma, iter)); )
+
+static inline void vma_nonlinear_insert(struct vm_area_struct *vma,
+                                        struct list_head *list)
+{
+        vma->shared.vm_set.parent = NULL;
+        list_add_tail(&vma->shared.vm_set.list, list);
+}
+
+/* mmap.c */
+extern int __vm_enough_memory(long pages, int cap_sys_admin);
+extern void vma_adjust(struct vm_area_struct *vma, unsigned long start,
+        unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert);
+extern struct vm_area_struct *vma_merge(struct mm_struct *,
+        struct vm_area_struct *prev, unsigned long addr, unsigned long end,
+        unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t,
+        struct mempolicy *);
+extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
+extern int split_vma(struct mm_struct *,
+        struct vm_area_struct *, unsigned long addr, int new_below);
+extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
+extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
+        struct rb_node **, struct rb_node *);
+extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
+        unsigned long addr, unsigned long len, pgoff_t pgoff);
+extern void exit_mmap(struct mm_struct *);
+
+extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
+
+extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
+        unsigned long len, unsigned long prot,
+        unsigned long flag, unsigned long pgoff);
+
+static inline unsigned long do_mmap(struct file *file, unsigned long addr,
+        unsigned long len, unsigned long prot,
+        unsigned long flag, unsigned long offset)
+{
+        unsigned long ret = -EINVAL;
+        if ((offset + PAGE_ALIGN(len)) < offset)
+                goto out;
+        if (!(offset & ~PAGE_MASK))
+                ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
+out:
+        return ret;
+}
+
+extern int do_munmap(struct mm_struct *, unsigned long, size_t);
+
+extern unsigned long do_brk(unsigned long, unsigned long);
+
+/* filemap.c */
+extern unsigned long page_unuse(struct page *);
+extern void truncate_inode_pages(struct address_space *, loff_t);
+
+/* generic vm_area_ops exported for stackable file systems */
+extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
+extern int filemap_populate(struct vm_area_struct *, unsigned long,
+                unsigned long, pgprot_t, unsigned long, int);
+
+/* mm/page-writeback.c */
+int write_one_page(struct page *page, int wait);
+
+/* readahead.c */
+#define VM_MAX_READAHEAD        128     /* kbytes */
+#define VM_MIN_READAHEAD        16      /* kbytes (includes current page) */
+#define VM_MAX_CACHE_HIT        256     /* max pages in a row in cache before
+                                         * turning readahead off */
+
+int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
+                        unsigned long offset, unsigned long nr_to_read);
+int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
+                        unsigned long offset, unsigned long nr_to_read);
+unsigned long  page_cache_readahead(struct address_space *mapping,
+                          struct file_ra_state *ra,
+                          struct file *filp,
+                          unsigned long offset,
+                          unsigned long size);
+void handle_ra_miss(struct address_space *mapping, 
+                    struct file_ra_state *ra, pgoff_t offset);
+unsigned long max_sane_readahead(unsigned long nr);
+
+/* Do stack extension */
+extern int expand_stack(struct vm_area_struct * vma, unsigned long address);
+
+/* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
+extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
+extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
+                                             struct vm_area_struct **pprev);
+
+/* Look up the first VMA which intersects the interval start_addr..end_addr-1,
+   NULL if none.  Assume start_addr < end_addr. */
+static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
+{
+        struct vm_area_struct * vma = find_vma(mm,start_addr);
+
+        if (vma && end_addr <= vma->vm_start)
+                vma = NULL;
+        return vma;
+}
+
+static inline unsigned long vma_pages(struct vm_area_struct *vma)
+{
+        return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
+}
+
+extern struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr);
+
+extern struct page * vmalloc_to_page(void *addr);
+extern unsigned long vmalloc_to_pfn(void *addr);
+extern struct page * follow_page(struct mm_struct *mm, unsigned long address,
+                int write);
+extern int check_user_page_readable(struct mm_struct *mm, unsigned long address);
+int remap_pfn_range(struct vm_area_struct *, unsigned long,
+                unsigned long, unsigned long, pgprot_t);
+
+#ifdef CONFIG_PROC_FS
+void __vm_stat_account(struct mm_struct *, unsigned long, struct file *, long);
+#else
+static inline void __vm_stat_account(struct mm_struct *mm,
+                        unsigned long flags, struct file *file, long pages)
+{
+}
+#endif /* CONFIG_PROC_FS */
+
+static inline void vm_stat_account(struct vm_area_struct *vma)
+{
+        __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
+                                                        vma_pages(vma));
+}
+
+static inline void vm_stat_unaccount(struct vm_area_struct *vma)
+{
+        __vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
+                                                        -vma_pages(vma));
+}
+
+/* update per process rss and vm hiwater data */
+extern void update_mem_hiwater(struct task_struct *tsk);
+
+#ifndef CONFIG_DEBUG_PAGEALLOC
+static inline void
+kernel_map_pages(struct page *page, int numpages, int enable)
+{
+}
+#endif
+
+extern struct vm_area_struct *get_gate_vma(struct task_struct *tsk);
+#ifdef  __HAVE_ARCH_GATE_AREA
+int in_gate_area_no_task(unsigned long addr);
+int in_gate_area(struct task_struct *task, unsigned long addr);
+#else
+int in_gate_area_no_task(unsigned long addr);
+#define in_gate_area(task, addr) ({(void)task; in_gate_area_no_task(addr);})
+#endif  /* __HAVE_ARCH_GATE_AREA */
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_MM_H */
diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h
new file mode 100644
index 000000000000..47762ca695a5
--- /dev/null
+++ b/include/linux/mm_inline.h
@@ -0,0 +1,40 @@
+
+static inline void
+add_page_to_active_list(struct zone *zone, struct page *page)
+{
+        list_add(&page->lru, &zone->active_list);
+        zone->nr_active++;
+}
+
+static inline void
+add_page_to_inactive_list(struct zone *zone, struct page *page)
+{
+        list_add(&page->lru, &zone->inactive_list);
+        zone->nr_inactive++;
+}
+
+static inline void
+del_page_from_active_list(struct zone *zone, struct page *page)
+{
+        list_del(&page->lru);
+        zone->nr_active--;
+}
+
+static inline void
+del_page_from_inactive_list(struct zone *zone, struct page *page)
+{
+        list_del(&page->lru);
+        zone->nr_inactive--;
+}
+
+static inline void
+del_page_from_lru(struct zone *zone, struct page *page)
+{
+        list_del(&page->lru);
+        if (PageActive(page)) {
+                ClearPageActive(page);
+                zone->nr_active--;
+        } else {
+                zone->nr_inactive--;
+        }
+}
diff --git a/include/linux/mman.h b/include/linux/mman.h
new file mode 100644
index 000000000000..18a5689ef748
--- /dev/null
+++ b/include/linux/mman.h
@@ -0,0 +1,67 @@
+#ifndef _LINUX_MMAN_H
+#define _LINUX_MMAN_H
+
+#include <linux/config.h>
+#include <linux/mm.h>
+
+#include <asm/atomic.h>
+#include <asm/mman.h>
+
+#define MREMAP_MAYMOVE  1
+#define MREMAP_FIXED    2
+
+#define OVERCOMMIT_GUESS                0
+#define OVERCOMMIT_ALWAYS               1
+#define OVERCOMMIT_NEVER                2
+extern int sysctl_overcommit_memory;
+extern int sysctl_overcommit_ratio;
+extern atomic_t vm_committed_space;
+
+#ifdef CONFIG_SMP
+extern void vm_acct_memory(long pages);
+#else
+static inline void vm_acct_memory(long pages)
+{
+        atomic_add(pages, &vm_committed_space);
+}
+#endif
+
+static inline void vm_unacct_memory(long pages)
+{
+        vm_acct_memory(-pages);
+}
+
+/*
+ * Optimisation macro.  It is equivalent to:
+ *      (x & bit1) ? bit2 : 0
+ * but this version is faster.
+ * ("bit1" and "bit2" must be single bits)
+ */
+#define _calc_vm_trans(x, bit1, bit2) \
+  ((bit1) <= (bit2) ? ((x) & (bit1)) * ((bit2) / (bit1)) \
+   : ((x) & (bit1)) / ((bit1) / (bit2)))
+
+/*
+ * Combine the mmap "prot" argument into "vm_flags" used internally.
+ */
+static inline unsigned long
+calc_vm_prot_bits(unsigned long prot)
+{
+        return _calc_vm_trans(prot, PROT_READ,  VM_READ ) |
+               _calc_vm_trans(prot, PROT_WRITE, VM_WRITE) |
+               _calc_vm_trans(prot, PROT_EXEC,  VM_EXEC );
+}
+
+/*
+ * Combine the mmap "flags" argument into "vm_flags" used internally.
+ */
+static inline unsigned long
+calc_vm_flag_bits(unsigned long flags)
+{
+        return _calc_vm_trans(flags, MAP_GROWSDOWN,  VM_GROWSDOWN ) |
+               _calc_vm_trans(flags, MAP_DENYWRITE,  VM_DENYWRITE ) |
+               _calc_vm_trans(flags, MAP_EXECUTABLE, VM_EXECUTABLE) |
+               _calc_vm_trans(flags, MAP_LOCKED,     VM_LOCKED    );
+}
+
+#endif /* _LINUX_MMAN_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
new file mode 100644
index 000000000000..aefedf04b9bb
--- /dev/null
+++ b/include/linux/mmc/card.h
@@ -0,0 +1,92 @@
+/*
+ *  linux/include/linux/mmc/card.h
+ *
+ * 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.
+ *
+ *  Card driver specific definitions.
+ */
+#ifndef LINUX_MMC_CARD_H
+#define LINUX_MMC_CARD_H
+
+#include <linux/mmc/mmc.h>
+
+struct mmc_cid {
+        unsigned int            manfid;
+        char                    prod_name[8];
+        unsigned int            serial;
+        unsigned short          oemid;
+        unsigned short          year;
+        unsigned char           hwrev;
+        unsigned char           fwrev;
+        unsigned char           month;
+};
+
+struct mmc_csd {
+        unsigned char           mmca_vsn;
+        unsigned short          cmdclass;
+        unsigned short          tacc_clks;
+        unsigned int            tacc_ns;
+        unsigned int            max_dtr;
+        unsigned int            read_blkbits;
+        unsigned int            capacity;
+};
+
+struct mmc_host;
+
+/*
+ * MMC device
+ */
+struct mmc_card {
+        struct list_head        node;           /* node in hosts devices list */
+        struct mmc_host         *host;          /* the host this device belongs to */
+        struct device           dev;            /* the device */
+        unsigned int            rca;            /* relative card address of device */
+        unsigned int            state;          /* (our) card state */
+#define MMC_STATE_PRESENT       (1<<0)          /* present in sysfs */
+#define MMC_STATE_DEAD          (1<<1)          /* device no longer in stack */
+#define MMC_STATE_BAD           (1<<2)          /* unrecognised device */
+        u32                     raw_cid[4];     /* raw card CID */
+        u32                     raw_csd[4];     /* raw card CSD */
+        struct mmc_cid          cid;            /* card identification */
+        struct mmc_csd          csd;            /* card specific */
+};
+
+#define mmc_card_present(c)     ((c)->state & MMC_STATE_PRESENT)
+#define mmc_card_dead(c)        ((c)->state & MMC_STATE_DEAD)
+#define mmc_card_bad(c)         ((c)->state & MMC_STATE_BAD)
+
+#define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT)
+#define mmc_card_set_dead(c)    ((c)->state |= MMC_STATE_DEAD)
+#define mmc_card_set_bad(c)     ((c)->state |= MMC_STATE_BAD)
+
+#define mmc_card_name(c)        ((c)->cid.prod_name)
+#define mmc_card_id(c)          ((c)->dev.bus_id)
+
+#define mmc_list_to_card(l)     container_of(l, struct mmc_card, node)
+#define mmc_get_drvdata(c)      dev_get_drvdata(&(c)->dev)
+#define mmc_set_drvdata(c,d)    dev_set_drvdata(&(c)->dev, d)
+
+/*
+ * MMC device driver (e.g., Flash card, I/O card...)
+ */
+struct mmc_driver {
+        struct device_driver drv;
+        int (*probe)(struct mmc_card *);
+        void (*remove)(struct mmc_card *);
+        int (*suspend)(struct mmc_card *, pm_message_t);
+        int (*resume)(struct mmc_card *);
+};
+
+extern int mmc_register_driver(struct mmc_driver *);
+extern void mmc_unregister_driver(struct mmc_driver *);
+
+static inline int mmc_card_claim_host(struct mmc_card *card)
+{
+        return __mmc_claim_host(card->host, card);
+}
+
+#define mmc_card_release_host(c)        mmc_release_host((c)->host)
+
+#endif
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
new file mode 100644
index 000000000000..f67686cef62a
--- /dev/null
+++ b/include/linux/mmc/host.h
@@ -0,0 +1,108 @@
+/*
+ *  linux/include/linux/mmc/host.h
+ *
+ * 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.
+ *
+ *  Host driver specific definitions.
+ */
+#ifndef LINUX_MMC_HOST_H
+#define LINUX_MMC_HOST_H
+
+#include <linux/mmc/mmc.h>
+
+struct mmc_ios {
+        unsigned int    clock;                  /* clock rate */
+        unsigned short  vdd;
+
+#define MMC_VDD_150     0
+#define MMC_VDD_155     1
+#define MMC_VDD_160     2
+#define MMC_VDD_165     3
+#define MMC_VDD_170     4
+#define MMC_VDD_180     5
+#define MMC_VDD_190     6
+#define MMC_VDD_200     7
+#define MMC_VDD_210     8
+#define MMC_VDD_220     9
+#define MMC_VDD_230     10
+#define MMC_VDD_240     11
+#define MMC_VDD_250     12
+#define MMC_VDD_260     13
+#define MMC_VDD_270     14
+#define MMC_VDD_280     15
+#define MMC_VDD_290     16
+#define MMC_VDD_300     17
+#define MMC_VDD_310     18
+#define MMC_VDD_320     19
+#define MMC_VDD_330     20
+#define MMC_VDD_340     21
+#define MMC_VDD_350     22
+#define MMC_VDD_360     23
+
+        unsigned char   bus_mode;               /* command output mode */
+
+#define MMC_BUSMODE_OPENDRAIN   1
+#define MMC_BUSMODE_PUSHPULL    2
+
+        unsigned char   power_mode;             /* power supply mode */
+
+#define MMC_POWER_OFF           0
+#define MMC_POWER_UP            1
+#define MMC_POWER_ON            2
+};
+
+struct mmc_host_ops {
+        void    (*request)(struct mmc_host *host, struct mmc_request *req);
+        void    (*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
+};
+
+struct mmc_card;
+struct device;
+
+struct mmc_host {
+        struct device           *dev;
+        struct mmc_host_ops     *ops;
+        unsigned int            f_min;
+        unsigned int            f_max;
+        u32                     ocr_avail;
+        char                    host_name[8];
+
+        /* host specific block data */
+        unsigned int            max_seg_size;   /* see blk_queue_max_segment_size */
+        unsigned short          max_hw_segs;    /* see blk_queue_max_hw_segments */
+        unsigned short          max_phys_segs;  /* see blk_queue_max_phys_segments */
+        unsigned short          max_sectors;    /* see blk_queue_max_sectors */
+        unsigned short          unused;
+
+        /* private data */
+        struct mmc_ios          ios;            /* current io bus settings */
+        u32                     ocr;            /* the current OCR setting */
+
+        struct list_head        cards;          /* devices attached to this host */
+
+        wait_queue_head_t       wq;
+        spinlock_t              lock;           /* card_busy lock */
+        struct mmc_card         *card_busy;     /* the MMC card claiming host */
+        struct mmc_card         *card_selected; /* the selected MMC card */
+
+        struct work_struct      detect;
+};
+
+extern struct mmc_host *mmc_alloc_host(int extra, struct device *);
+extern int mmc_add_host(struct mmc_host *);
+extern void mmc_remove_host(struct mmc_host *);
+extern void mmc_free_host(struct mmc_host *);
+
+#define mmc_priv(x)     ((void *)((x) + 1))
+#define mmc_dev(x)      ((x)->dev)
+
+extern int mmc_suspend_host(struct mmc_host *, u32);
+extern int mmc_resume_host(struct mmc_host *);
+
+extern void mmc_detect_change(struct mmc_host *);
+extern void mmc_request_done(struct mmc_host *, struct mmc_request *);
+
+#endif
+
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
new file mode 100644
index 000000000000..0d35d4ffb360
--- /dev/null
+++ b/include/linux/mmc/mmc.h
@@ -0,0 +1,101 @@
+/*
+ *  linux/include/linux/mmc/mmc.h
+ *
+ * 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_H
+#define MMC_H
+
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+
+struct request;
+struct mmc_data;
+struct mmc_request;
+
+struct mmc_command {
+        u32                     opcode;
+        u32                     arg;
+        u32                     resp[4];
+        unsigned int            flags;          /* expected response type */
+#define MMC_RSP_NONE    (0 << 0)
+#define MMC_RSP_SHORT   (1 << 0)
+#define MMC_RSP_LONG    (2 << 0)
+#define MMC_RSP_MASK    (3 << 0)
+#define MMC_RSP_CRC     (1 << 3)                /* expect valid crc */
+#define MMC_RSP_BUSY    (1 << 4)                /* card may send busy */
+
+/*
+ * These are the response types, and correspond to valid bit
+ * patterns of the above flags.  One additional valid pattern
+ * is all zeros, which means we don't expect a response.
+ */
+#define MMC_RSP_R1      (MMC_RSP_SHORT|MMC_RSP_CRC)
+#define MMC_RSP_R1B     (MMC_RSP_SHORT|MMC_RSP_CRC|MMC_RSP_BUSY)
+#define MMC_RSP_R2      (MMC_RSP_LONG|MMC_RSP_CRC)
+#define MMC_RSP_R3      (MMC_RSP_SHORT)
+#define MMC_RSP_R6      (MMC_RSP_SHORT|MMC_RSP_CRC)
+
+        unsigned int            retries;        /* max number of retries */
+        unsigned int            error;          /* command error */
+
+#define MMC_ERR_NONE    0
+#define MMC_ERR_TIMEOUT 1
+#define MMC_ERR_BADCRC  2
+#define MMC_ERR_FIFO    3
+#define MMC_ERR_FAILED  4
+#define MMC_ERR_INVALID 5
+
+        struct mmc_data         *data;          /* data segment associated with cmd */
+        struct mmc_request      *mrq;           /* assoicated request */
+};
+
+struct mmc_data {
+        unsigned int            timeout_ns;     /* data timeout (in ns, max 80ms) */
+        unsigned int            timeout_clks;   /* data timeout (in clocks) */
+        unsigned int            blksz_bits;     /* data block size */
+        unsigned int            blocks;         /* number of blocks */
+        unsigned int            error;          /* data error */
+        unsigned int            flags;
+
+#define MMC_DATA_WRITE  (1 << 8)
+#define MMC_DATA_READ   (1 << 9)
+#define MMC_DATA_STREAM (1 << 10)
+
+        unsigned int            bytes_xfered;
+
+        struct mmc_command      *stop;          /* stop command */
+        struct mmc_request      *mrq;           /* assoicated request */
+
+        unsigned int            sg_len;         /* size of scatter list */
+        struct scatterlist      *sg;            /* I/O scatter list */
+};
+
+struct mmc_request {
+        struct mmc_command      *cmd;
+        struct mmc_data         *data;
+        struct mmc_command      *stop;
+
+        void                    *done_data;     /* completion data */
+        void                    (*done)(struct mmc_request *);/* completion function */
+};
+
+struct mmc_host;
+struct mmc_card;
+
+extern int mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
+extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
+
+extern int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card);
+
+static inline void mmc_claim_host(struct mmc_host *host)
+{
+        __mmc_claim_host(host, (struct mmc_card *)-1);
+}
+
+extern void mmc_release_host(struct mmc_host *host);
+
+#endif
diff --git a/include/linux/mmc/protocol.h b/include/linux/mmc/protocol.h
new file mode 100644
index 000000000000..7b904c5102f6
--- /dev/null
+++ b/include/linux/mmc/protocol.h
@@ -0,0 +1,213 @@
+/*
+ * Header for MultiMediaCard (MMC)
+ *
+ * Copyright 2002 Hewlett-Packard Company
+ *
+ * Use consistent with the GNU GPL is permitted,
+ * provided that this copyright notice is
+ * preserved in its entirety in all copies and derived works.
+ *
+ * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
+ * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
+ * FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * Many thanks to Alessandro Rubini and Jonathan Corbet!
+ *
+ * Based strongly on code by:
+ *
+ * Author: Yong-iL Joh <tolkien@mizi.com>
+ * Date  : $Date: 2002/06/18 12:37:30 $
+ *
+ * Author:  Andrew Christian
+ *          15 May 2002
+ */
+
+#ifndef MMC_MMC_PROTOCOL_H
+#define MMC_MMC_PROTOCOL_H
+
+/* Standard MMC commands (3.1)           type  argument     response */
+   /* class 1 */
+#define MMC_GO_IDLE_STATE         0   /* bc                          */
+#define MMC_SEND_OP_COND          1   /* bcr  [31:0] OCR         R3  */
+#define MMC_ALL_SEND_CID          2   /* bcr                     R2  */
+#define MMC_SET_RELATIVE_ADDR     3   /* ac   [31:16] RCA        R1  */
+#define MMC_SET_DSR               4   /* bc   [31:16] RCA            */
+#define MMC_SELECT_CARD           7   /* ac   [31:16] RCA        R1  */
+#define MMC_SEND_CSD              9   /* ac   [31:16] RCA        R2  */
+#define MMC_SEND_CID             10   /* ac   [31:16] RCA        R2  */
+#define MMC_READ_DAT_UNTIL_STOP  11   /* adtc [31:0] dadr        R1  */
+#define MMC_STOP_TRANSMISSION    12   /* ac                      R1b */
+#define MMC_SEND_STATUS          13   /* ac   [31:16] RCA        R1  */
+#define MMC_GO_INACTIVE_STATE    15   /* ac   [31:16] RCA            */
+
+  /* class 2 */
+#define MMC_SET_BLOCKLEN         16   /* ac   [31:0] block len   R1  */
+#define MMC_READ_SINGLE_BLOCK    17   /* adtc [31:0] data addr   R1  */
+#define MMC_READ_MULTIPLE_BLOCK  18   /* adtc [31:0] data addr   R1  */
+
+  /* class 3 */
+#define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
+
+  /* class 4 */
+#define MMC_SET_BLOCK_COUNT      23   /* adtc [31:0] data addr   R1  */
+#define MMC_WRITE_BLOCK          24   /* adtc [31:0] data addr   R1  */
+#define MMC_WRITE_MULTIPLE_BLOCK 25   /* adtc                    R1  */
+#define MMC_PROGRAM_CID          26   /* adtc                    R1  */
+#define MMC_PROGRAM_CSD          27   /* adtc                    R1  */
+
+  /* class 6 */
+#define MMC_SET_WRITE_PROT       28   /* ac   [31:0] data addr   R1b */
+#define MMC_CLR_WRITE_PROT       29   /* ac   [31:0] data addr   R1b */
+#define MMC_SEND_WRITE_PROT      30   /* adtc [31:0] wpdata addr R1  */
+
+  /* class 5 */
+#define MMC_ERASE_GROUP_START    35   /* ac   [31:0] data addr   R1  */
+#define MMC_ERASE_GROUP_END      36   /* ac   [31:0] data addr   R1  */
+#define MMC_ERASE                37   /* ac                      R1b */
+
+  /* class 9 */
+#define MMC_FAST_IO              39   /* ac   <Complex>          R4  */
+#define MMC_GO_IRQ_STATE         40   /* bcr                     R5  */
+
+  /* class 7 */
+#define MMC_LOCK_UNLOCK          42   /* adtc                    R1b */
+
+  /* class 8 */
+#define MMC_APP_CMD              55   /* ac   [31:16] RCA        R1  */
+#define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1b */
+
+/* SD commands                           type  argument     response */
+  /* class 8 */
+/* This is basically the same command as for MMC with some quirks. */
+#define SD_SEND_RELATIVE_ADDR     3   /* ac                      R6  */
+
+  /* Application commands */
+#define SD_APP_SET_BUS_WIDTH      6   /* ac   [1:0] bus width    R1  */
+#define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
+#define SD_APP_SEND_SCR          51   /* adtc                    R1  */
+
+/*
+  MMC status in R1
+  Type
+        e : error bit
+        s : status bit
+        r : detected and set for the actual command response
+        x : detected and set during command execution. the host must poll
+            the card by sending status command in order to read these bits.
+  Clear condition
+        a : according to the card state
+        b : always related to the previous command. Reception of
+            a valid command will clear it (with a delay of one command)
+        c : clear by read
+ */
+
+#define R1_OUT_OF_RANGE         (1 << 31)       /* er, c */
+#define R1_ADDRESS_ERROR        (1 << 30)       /* erx, c */
+#define R1_BLOCK_LEN_ERROR      (1 << 29)       /* er, c */
+#define R1_ERASE_SEQ_ERROR      (1 << 28)       /* er, c */
+#define R1_ERASE_PARAM          (1 << 27)       /* ex, c */
+#define R1_WP_VIOLATION         (1 << 26)       /* erx, c */
+#define R1_CARD_IS_LOCKED       (1 << 25)       /* sx, a */
+#define R1_LOCK_UNLOCK_FAILED   (1 << 24)       /* erx, c */
+#define R1_COM_CRC_ERROR        (1 << 23)       /* er, b */
+#define R1_ILLEGAL_COMMAND      (1 << 22)       /* er, b */
+#define R1_CARD_ECC_FAILED      (1 << 21)       /* ex, c */
+#define R1_CC_ERROR             (1 << 20)       /* erx, c */
+#define R1_ERROR                (1 << 19)       /* erx, c */
+#define R1_UNDERRUN             (1 << 18)       /* ex, c */
+#define R1_OVERRUN              (1 << 17)       /* ex, c */
+#define R1_CID_CSD_OVERWRITE    (1 << 16)       /* erx, c, CID/CSD overwrite */
+#define R1_WP_ERASE_SKIP        (1 << 15)       /* sx, c */
+#define R1_CARD_ECC_DISABLED    (1 << 14)       /* sx, a */
+#define R1_ERASE_RESET          (1 << 13)       /* sr, c */
+#define R1_STATUS(x)            (x & 0xFFFFE000)
+#define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
+#define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
+#define R1_APP_CMD              (1 << 5)        /* sr, c */
+
+/* These are unpacked versions of the actual responses */
+
+struct _mmc_csd {
+        u8  csd_structure;
+        u8  spec_vers;
+        u8  taac;
+        u8  nsac;
+        u8  tran_speed;
+        u16 ccc;
+        u8  read_bl_len;
+        u8  read_bl_partial;
+        u8  write_blk_misalign;
+        u8  read_blk_misalign;
+        u8  dsr_imp;
+        u16 c_size;
+        u8  vdd_r_curr_min;
+        u8  vdd_r_curr_max;
+        u8  vdd_w_curr_min;
+        u8  vdd_w_curr_max;
+        u8  c_size_mult;
+        union {
+                struct { /* MMC system specification version 3.1 */
+                        u8  erase_grp_size;
+                        u8  erase_grp_mult;
+                } v31;
+                struct { /* MMC system specification version 2.2 */
+                        u8  sector_size;
+                        u8  erase_grp_size;
+                } v22;
+        } erase;
+        u8  wp_grp_size;
+        u8  wp_grp_enable;
+        u8  default_ecc;
+        u8  r2w_factor;
+        u8  write_bl_len;
+        u8  write_bl_partial;
+        u8  file_format_grp;
+        u8  copy;
+        u8  perm_write_protect;
+        u8  tmp_write_protect;
+        u8  file_format;
+        u8  ecc;
+};
+
+#define MMC_VDD_145_150 0x00000001      /* VDD voltage 1.45 - 1.50 */
+#define MMC_VDD_150_155 0x00000002      /* VDD voltage 1.50 - 1.55 */
+#define MMC_VDD_155_160 0x00000004      /* VDD voltage 1.55 - 1.60 */
+#define MMC_VDD_160_165 0x00000008      /* VDD voltage 1.60 - 1.65 */
+#define MMC_VDD_165_170 0x00000010      /* VDD voltage 1.65 - 1.70 */
+#define MMC_VDD_17_18   0x00000020      /* VDD voltage 1.7 - 1.8 */
+#define MMC_VDD_18_19   0x00000040      /* VDD voltage 1.8 - 1.9 */
+#define MMC_VDD_19_20   0x00000080      /* VDD voltage 1.9 - 2.0 */
+#define MMC_VDD_20_21   0x00000100      /* VDD voltage 2.0 ~ 2.1 */
+#define MMC_VDD_21_22   0x00000200      /* VDD voltage 2.1 ~ 2.2 */
+#define MMC_VDD_22_23   0x00000400      /* VDD voltage 2.2 ~ 2.3 */
+#define MMC_VDD_23_24   0x00000800      /* VDD voltage 2.3 ~ 2.4 */
+#define MMC_VDD_24_25   0x00001000      /* VDD voltage 2.4 ~ 2.5 */
+#define MMC_VDD_25_26   0x00002000      /* VDD voltage 2.5 ~ 2.6 */
+#define MMC_VDD_26_27   0x00004000      /* VDD voltage 2.6 ~ 2.7 */
+#define MMC_VDD_27_28   0x00008000      /* VDD voltage 2.7 ~ 2.8 */
+#define MMC_VDD_28_29   0x00010000      /* VDD voltage 2.8 ~ 2.9 */
+#define MMC_VDD_29_30   0x00020000      /* VDD voltage 2.9 ~ 3.0 */
+#define MMC_VDD_30_31   0x00040000      /* VDD voltage 3.0 ~ 3.1 */
+#define MMC_VDD_31_32   0x00080000      /* VDD voltage 3.1 ~ 3.2 */
+#define MMC_VDD_32_33   0x00100000      /* VDD voltage 3.2 ~ 3.3 */
+#define MMC_VDD_33_34   0x00200000      /* VDD voltage 3.3 ~ 3.4 */
+#define MMC_VDD_34_35   0x00400000      /* VDD voltage 3.4 ~ 3.5 */
+#define MMC_VDD_35_36   0x00800000      /* VDD voltage 3.5 ~ 3.6 */
+#define MMC_CARD_BUSY   0x80000000      /* Card Power up status bit */
+
+
+/*
+ * CSD field definitions
+ */
+
+#define CSD_STRUCT_VER_1_0  0           /* Valid for system specification 1.0 - 1.2 */
+#define CSD_STRUCT_VER_1_1  1           /* Valid for system specification 1.4 - 2.2 */
+#define CSD_STRUCT_VER_1_2  2           /* Valid for system specification 3.1       */
+
+#define CSD_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.2 */
+#define CSD_SPEC_VER_1      1           /* Implements system specification 1.4 */
+#define CSD_SPEC_VER_2      2           /* Implements system specification 2.0 - 2.2 */
+#define CSD_SPEC_VER_3      3           /* Implements system specification 3.1 */
+
+#endif  /* MMC_MMC_PROTOCOL_H */
+
diff --git a/include/linux/mmtimer.h b/include/linux/mmtimer.h
new file mode 100644
index 000000000000..884cabf16088
--- /dev/null
+++ b/include/linux/mmtimer.h
@@ -0,0 +1,56 @@
+/*
+ * Intel Multimedia Timer device interface
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2001-2004 Silicon Graphics, Inc.  All rights reserved.
+ *
+ * This file should define an interface compatible with the IA-PC Multimedia
+ * Timers Draft Specification (rev. 0.97) from Intel.  Note that some
+ * hardware may not be able to safely export its registers to userspace,
+ * so the ioctl interface should support all necessary functionality.
+ *
+ * 11/01/01 - jbarnes - initial revision
+ * 9/10/04 - Christoph Lameter - remove interrupt support
+ * 9/17/04 - jbarnes - remove test program, move some #defines to the driver
+ */
+
+#ifndef _LINUX_MMTIMER_H
+#define _LINUX_MMTIMER_H
+
+/*
+ * Breakdown of the ioctl's available.  An 'optional' next to the command
+ * indicates that supporting this command is optional, while 'required'
+ * commands must be implemented if conformance is desired.
+ *
+ * MMTIMER_GETOFFSET - optional
+ *   Should return the offset (relative to the start of the page where the
+ *   registers are mapped) for the counter in question.
+ *
+ * MMTIMER_GETRES - required
+ *   The resolution of the clock in femto (10^-15) seconds
+ *
+ * MMTIMER_GETFREQ - required
+ *   Frequency of the clock in Hz
+ *
+ * MMTIMER_GETBITS - required
+ *   Number of bits in the clock's counter
+ *
+ * MMTIMER_MMAPAVAIL - required
+ *   Returns nonzero if the registers can be mmap'd into userspace, 0 otherwise
+ *
+ * MMTIMER_GETCOUNTER - required
+ *   Gets the current value in the counter
+ */
+#define MMTIMER_IOCTL_BASE 'm'
+
+#define MMTIMER_GETOFFSET _IO(MMTIMER_IOCTL_BASE, 0)
+#define MMTIMER_GETRES _IOR(MMTIMER_IOCTL_BASE, 1, unsigned long)
+#define MMTIMER_GETFREQ _IOR(MMTIMER_IOCTL_BASE, 2, unsigned long)
+#define MMTIMER_GETBITS _IO(MMTIMER_IOCTL_BASE, 4)
+#define MMTIMER_MMAPAVAIL _IO(MMTIMER_IOCTL_BASE, 6)
+#define MMTIMER_GETCOUNTER _IOR(MMTIMER_IOCTL_BASE, 9, unsigned long)
+
+#endif /* _LINUX_MMTIMER_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
new file mode 100644
index 000000000000..e530c6c092f1
--- /dev/null
+++ b/include/linux/mmzone.h
@@ -0,0 +1,426 @@
+#ifndef _LINUX_MMZONE_H
+#define _LINUX_MMZONE_H
+
+#ifdef __KERNEL__
+#ifndef __ASSEMBLY__
+
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/wait.h>
+#include <linux/cache.h>
+#include <linux/threads.h>
+#include <linux/numa.h>
+#include <linux/init.h>
+#include <asm/atomic.h>
+
+/* Free memory management - zoned buddy allocator.  */
+#ifndef CONFIG_FORCE_MAX_ZONEORDER
+#define MAX_ORDER 11
+#else
+#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
+#endif
+
+struct free_area {
+        struct list_head        free_list;
+        unsigned long           nr_free;
+};
+
+struct pglist_data;
+
+/*
+ * zone->lock and zone->lru_lock are two of the hottest locks in the kernel.
+ * So add a wild amount of padding here to ensure that they fall into separate
+ * cachelines.  There are very few zone structures in the machine, so space
+ * consumption is not a concern here.
+ */
+#if defined(CONFIG_SMP)
+struct zone_padding {
+        char x[0];
+} ____cacheline_maxaligned_in_smp;
+#define ZONE_PADDING(name)      struct zone_padding name;
+#else
+#define ZONE_PADDING(name)
+#endif
+
+struct per_cpu_pages {
+        int count;              /* number of pages in the list */
+        int low;                /* low watermark, refill needed */
+        int high;               /* high watermark, emptying needed */
+        int batch;              /* chunk size for buddy add/remove */
+        struct list_head list;  /* the list of pages */
+};
+
+struct per_cpu_pageset {
+        struct per_cpu_pages pcp[2];    /* 0: hot.  1: cold */
+#ifdef CONFIG_NUMA
+        unsigned long numa_hit;         /* allocated in intended node */
+        unsigned long numa_miss;        /* allocated in non intended node */
+        unsigned long numa_foreign;     /* was intended here, hit elsewhere */
+        unsigned long interleave_hit;   /* interleaver prefered this zone */
+        unsigned long local_node;       /* allocation from local node */
+        unsigned long other_node;       /* allocation from other node */
+#endif
+} ____cacheline_aligned_in_smp;
+
+#define ZONE_DMA                0
+#define ZONE_NORMAL             1
+#define ZONE_HIGHMEM            2
+
+#define MAX_NR_ZONES            3       /* Sync this with ZONES_SHIFT */
+#define ZONES_SHIFT             2       /* ceil(log2(MAX_NR_ZONES)) */
+
+
+/*
+ * When a memory allocation must conform to specific limitations (such
+ * as being suitable for DMA) the caller will pass in hints to the
+ * allocator in the gfp_mask, in the zone modifier bits.  These bits
+ * are used to select a priority ordered list of memory zones which
+ * match the requested limits.  GFP_ZONEMASK defines which bits within
+ * the gfp_mask should be considered as zone modifiers.  Each valid
+ * combination of the zone modifier bits has a corresponding list
+ * of zones (in node_zonelists).  Thus for two zone modifiers there
+ * will be a maximum of 4 (2 ** 2) zonelists, for 3 modifiers there will
+ * be 8 (2 ** 3) zonelists.  GFP_ZONETYPES defines the number of possible
+ * combinations of zone modifiers in "zone modifier space".
+ */
+#define GFP_ZONEMASK    0x03
+/*
+ * As an optimisation any zone modifier bits which are only valid when
+ * no other zone modifier bits are set (loners) should be placed in
+ * the highest order bits of this field.  This allows us to reduce the
+ * extent of the zonelists thus saving space.  For example in the case
+ * of three zone modifier bits, we could require up to eight zonelists.
+ * If the left most zone modifier is a "loner" then the highest valid
+ * zonelist would be four allowing us to allocate only five zonelists.
+ * Use the first form when the left most bit is not a "loner", otherwise
+ * use the second.
+ */
+/* #define GFP_ZONETYPES        (GFP_ZONEMASK + 1) */           /* Non-loner */
+#define GFP_ZONETYPES   ((GFP_ZONEMASK + 1) / 2 + 1)            /* Loner */
+
+/*
+ * On machines where it is needed (eg PCs) we divide physical memory
+ * into multiple physical zones. On a PC we have 3 zones:
+ *
+ * ZONE_DMA       < 16 MB       ISA DMA capable memory
+ * ZONE_NORMAL  16-896 MB       direct mapped by the kernel
+ * ZONE_HIGHMEM  > 896 MB       only page cache and user processes
+ */
+
+struct zone {
+        /* Fields commonly accessed by the page allocator */
+        unsigned long           free_pages;
+        unsigned long           pages_min, pages_low, pages_high;
+        /*
+         * We don't know if the memory that we're going to allocate will be freeable
+         * or/and it will be released eventually, so to avoid totally wasting several
+         * GB of ram we must reserve some of the lower zone memory (otherwise we risk
+         * to run OOM on the lower zones despite there's tons of freeable ram
+         * on the higher zones). This array is recalculated at runtime if the
+         * sysctl_lowmem_reserve_ratio sysctl changes.
+         */
+        unsigned long           lowmem_reserve[MAX_NR_ZONES];
+
+        struct per_cpu_pageset  pageset[NR_CPUS];
+
+        /*
+         * free areas of different sizes
+         */
+        spinlock_t              lock;
+        struct free_area        free_area[MAX_ORDER];
+
+
+        ZONE_PADDING(_pad1_)
+
+        /* Fields commonly accessed by the page reclaim scanner */
+        spinlock_t              lru_lock;       
+        struct list_head        active_list;
+        struct list_head        inactive_list;
+        unsigned long           nr_scan_active;
+        unsigned long           nr_scan_inactive;
+        unsigned long           nr_active;
+        unsigned long           nr_inactive;
+        unsigned long           pages_scanned;     /* since last reclaim */
+        int                     all_unreclaimable; /* All pages pinned */
+
+        /*
+         * prev_priority holds the scanning priority for this zone.  It is
+         * defined as the scanning priority at which we achieved our reclaim
+         * target at the previous try_to_free_pages() or balance_pgdat()
+         * invokation.
+         *
+         * We use prev_priority as a measure of how much stress page reclaim is
+         * under - it drives the swappiness decision: whether to unmap mapped
+         * pages.
+         *
+         * temp_priority is used to remember the scanning priority at which
+         * this zone was successfully refilled to free_pages == pages_high.
+         *
+         * Access to both these fields is quite racy even on uniprocessor.  But
+         * it is expected to average out OK.
+         */
+        int temp_priority;
+        int prev_priority;
+
+
+        ZONE_PADDING(_pad2_)
+        /* Rarely used or read-mostly fields */
+
+        /*
+         * wait_table           -- the array holding the hash table
+         * wait_table_size      -- the size of the hash table array
+         * wait_table_bits      -- wait_table_size == (1 << wait_table_bits)
+         *
+         * The purpose of all these is to keep track of the people
+         * waiting for a page to become available and make them
+         * runnable again when possible. The trouble is that this
+         * consumes a lot of space, especially when so few things
+         * wait on pages at a given time. So instead of using
+         * per-page waitqueues, we use a waitqueue hash table.
+         *
+         * The bucket discipline is to sleep on the same queue when
+         * colliding and wake all in that wait queue when removing.
+         * When something wakes, it must check to be sure its page is
+         * truly available, a la thundering herd. The cost of a
+         * collision is great, but given the expected load of the
+         * table, they should be so rare as to be outweighed by the
+         * benefits from the saved space.
+         *
+         * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
+         * primary users of these fields, and in mm/page_alloc.c
+         * free_area_init_core() performs the initialization of them.
+         */
+        wait_queue_head_t       * wait_table;
+        unsigned long           wait_table_size;
+        unsigned long           wait_table_bits;
+
+        /*
+         * Discontig memory support fields.
+         */
+        struct pglist_data      *zone_pgdat;
+        struct page             *zone_mem_map;
+        /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
+        unsigned long           zone_start_pfn;
+
+        unsigned long           spanned_pages;  /* total size, including holes */
+        unsigned long           present_pages;  /* amount of memory (excluding holes) */
+
+        /*
+         * rarely used fields:
+         */
+        char                    *name;
+} ____cacheline_maxaligned_in_smp;
+
+
+/*
+ * The "priority" of VM scanning is how much of the queues we will scan in one
+ * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
+ * queues ("queue_length >> 12") during an aging round.
+ */
+#define DEF_PRIORITY 12
+
+/*
+ * One allocation request operates on a zonelist. A zonelist
+ * is a list of zones, the first one is the 'goal' of the
+ * allocation, the other zones are fallback zones, in decreasing
+ * priority.
+ *
+ * Right now a zonelist takes up less than a cacheline. We never
+ * modify it apart from boot-up, and only a few indices are used,
+ * so despite the zonelist table being relatively big, the cache
+ * footprint of this construct is very small.
+ */
+struct zonelist {
+        struct zone *zones[MAX_NUMNODES * MAX_NR_ZONES + 1]; // NULL delimited
+};
+
+
+/*
+ * The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
+ * (mostly NUMA machines?) to denote a higher-level memory zone than the
+ * zone denotes.
+ *
+ * On NUMA machines, each NUMA node would have a pg_data_t to describe
+ * it's memory layout.
+ *
+ * Memory statistics and page replacement data structures are maintained on a
+ * per-zone basis.
+ */
+struct bootmem_data;
+typedef struct pglist_data {
+        struct zone node_zones[MAX_NR_ZONES];
+        struct zonelist node_zonelists[GFP_ZONETYPES];
+        int nr_zones;
+        struct page *node_mem_map;
+        struct bootmem_data *bdata;
+        unsigned long node_start_pfn;
+        unsigned long node_present_pages; /* total number of physical pages */
+        unsigned long node_spanned_pages; /* total size of physical page
+                                             range, including holes */
+        int node_id;
+        struct pglist_data *pgdat_next;
+        wait_queue_head_t kswapd_wait;
+        struct task_struct *kswapd;
+        int kswapd_max_order;
+} pg_data_t;
+
+#define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
+#define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
+
+extern struct pglist_data *pgdat_list;
+
+void __get_zone_counts(unsigned long *active, unsigned long *inactive,
+                        unsigned long *free, struct pglist_data *pgdat);
+void get_zone_counts(unsigned long *active, unsigned long *inactive,
+                        unsigned long *free);
+void build_all_zonelists(void);
+void wakeup_kswapd(struct zone *zone, int order);
+int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
+                int alloc_type, int can_try_harder, int gfp_high);
+
+#ifdef CONFIG_HAVE_MEMORY_PRESENT
+void memory_present(int nid, unsigned long start, unsigned long end);
+#else
+static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
+#endif
+
+#ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
+unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
+#endif
+
+/*
+ * zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
+ */
+#define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
+
+/**
+ * for_each_pgdat - helper macro to iterate over all nodes
+ * @pgdat - pointer to a pg_data_t variable
+ *
+ * Meant to help with common loops of the form
+ * pgdat = pgdat_list;
+ * while(pgdat) {
+ *      ...
+ *      pgdat = pgdat->pgdat_next;
+ * }
+ */
+#define for_each_pgdat(pgdat) \
+        for (pgdat = pgdat_list; pgdat; pgdat = pgdat->pgdat_next)
+
+/*
+ * next_zone - helper magic for for_each_zone()
+ * Thanks to William Lee Irwin III for this piece of ingenuity.
+ */
+static inline struct zone *next_zone(struct zone *zone)
+{
+        pg_data_t *pgdat = zone->zone_pgdat;
+
+        if (zone < pgdat->node_zones + MAX_NR_ZONES - 1)
+                zone++;
+        else if (pgdat->pgdat_next) {
+                pgdat = pgdat->pgdat_next;
+                zone = pgdat->node_zones;
+        } else
+                zone = NULL;
+
+        return zone;
+}
+
+/**
+ * for_each_zone - helper macro to iterate over all memory zones
+ * @zone - pointer to struct zone variable
+ *
+ * The user only needs to declare the zone variable, for_each_zone
+ * fills it in. This basically means for_each_zone() is an
+ * easier to read version of this piece of code:
+ *
+ * for (pgdat = pgdat_list; pgdat; pgdat = pgdat->node_next)
+ *      for (i = 0; i < MAX_NR_ZONES; ++i) {
+ *              struct zone * z = pgdat->node_zones + i;
+ *              ...
+ *      }
+ * }
+ */
+#define for_each_zone(zone) \
+        for (zone = pgdat_list->node_zones; zone; zone = next_zone(zone))
+
+static inline int is_highmem_idx(int idx)
+{
+        return (idx == ZONE_HIGHMEM);
+}
+
+static inline int is_normal_idx(int idx)
+{
+        return (idx == ZONE_NORMAL);
+}
+/**
+ * is_highmem - helper function to quickly check if a struct zone is a 
+ *              highmem zone or not.  This is an attempt to keep references
+ *              to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
+ * @zone - pointer to struct zone variable
+ */
+static inline int is_highmem(struct zone *zone)
+{
+        return zone == zone->zone_pgdat->node_zones + ZONE_HIGHMEM;
+}
+
+static inline int is_normal(struct zone *zone)
+{
+        return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
+}
+
+/* These two functions are used to setup the per zone pages min values */
+struct ctl_table;
+struct file;
+int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *, 
+                                        void __user *, size_t *, loff_t *);
+extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
+int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
+                                        void __user *, size_t *, loff_t *);
+
+#include <linux/topology.h>
+/* Returns the number of the current Node. */
+#define numa_node_id()          (cpu_to_node(_smp_processor_id()))
+
+#ifndef CONFIG_DISCONTIGMEM
+
+extern struct pglist_data contig_page_data;
+#define NODE_DATA(nid)          (&contig_page_data)
+#define NODE_MEM_MAP(nid)       mem_map
+#define MAX_NODES_SHIFT         1
+#define pfn_to_nid(pfn)         (0)
+
+#else /* CONFIG_DISCONTIGMEM */
+
+#include <asm/mmzone.h>
+
+#if BITS_PER_LONG == 32 || defined(ARCH_HAS_ATOMIC_UNSIGNED)
+/*
+ * with 32 bit page->flags field, we reserve 8 bits for node/zone info.
+ * there are 3 zones (2 bits) and this leaves 8-2=6 bits for nodes.
+ */
+#define MAX_NODES_SHIFT         6
+#elif BITS_PER_LONG == 64
+/*
+ * with 64 bit flags field, there's plenty of room.
+ */
+#define MAX_NODES_SHIFT         10
+#endif
+
+#endif /* !CONFIG_DISCONTIGMEM */
+
+#if NODES_SHIFT > MAX_NODES_SHIFT
+#error NODES_SHIFT > MAX_NODES_SHIFT
+#endif
+
+/* There are currently 3 zones: DMA, Normal & Highmem, thus we need 2 bits */
+#define MAX_ZONES_SHIFT         2
+
+#if ZONES_SHIFT > MAX_ZONES_SHIFT
+#error ZONES_SHIFT > MAX_ZONES_SHIFT
+#endif
+
+#endif /* !__ASSEMBLY__ */
+#endif /* __KERNEL__ */
+#endif /* _LINUX_MMZONE_H */
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
new file mode 100644
index 000000000000..d6eb7b2efc04
--- /dev/null
+++ b/include/linux/mod_devicetable.h
@@ -0,0 +1,178 @@
+/*
+ * Device tables which are exported to userspace via
+ * scripts/table2alias.c.  You must keep that file in sync with this
+ * header.
+ */
+
+#ifndef LINUX_MOD_DEVICETABLE_H
+#define LINUX_MOD_DEVICETABLE_H
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+typedef unsigned long kernel_ulong_t;
+#endif
+
+#define PCI_ANY_ID (~0)
+
+struct pci_device_id {
+        __u32 vendor, device;           /* Vendor and device ID or PCI_ANY_ID*/
+        __u32 subvendor, subdevice;     /* Subsystem ID's or PCI_ANY_ID */
+        __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
+        kernel_ulong_t driver_data;     /* Data private to the driver */
+};
+
+
+#define IEEE1394_MATCH_VENDOR_ID        0x0001
+#define IEEE1394_MATCH_MODEL_ID         0x0002
+#define IEEE1394_MATCH_SPECIFIER_ID     0x0004
+#define IEEE1394_MATCH_VERSION          0x0008
+
+struct ieee1394_device_id {
+        __u32 match_flags;
+        __u32 vendor_id;
+        __u32 model_id;
+        __u32 specifier_id;
+        __u32 version;
+        kernel_ulong_t driver_data;
+};
+
+
+/*
+ * Device table entry for "new style" table-driven USB drivers.
+ * User mode code can read these tables to choose which modules to load.
+ * Declare the table as a MODULE_DEVICE_TABLE.
+ *
+ * A probe() parameter will point to a matching entry from this table.
+ * Use the driver_info field for each match to hold information tied
+ * to that match:  device quirks, etc.
+ *
+ * Terminate the driver's table with an all-zeroes entry.
+ * Use the flag values to control which fields are compared.
+ */
+
+/**
+ * struct usb_device_id - identifies USB devices for probing and hotplugging
+ * @match_flags: Bit mask controlling of the other fields are used to match
+ *      against new devices.  Any field except for driver_info may be used,
+ *      although some only make sense in conjunction with other fields.
+ *      This is usually set by a USB_DEVICE_*() macro, which sets all
+ *      other fields in this structure except for driver_info.
+ * @idVendor: USB vendor ID for a device; numbers are assigned
+ *      by the USB forum to its members.
+ * @idProduct: Vendor-assigned product ID.
+ * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
+ *      This is also used to identify individual product versions, for
+ *      a range consisting of a single device.
+ * @bcdDevice_hi: High end of version number range.  The range of product
+ *      versions is inclusive.
+ * @bDeviceClass: Class of device; numbers are assigned
+ *      by the USB forum.  Products may choose to implement classes,
+ *      or be vendor-specific.  Device classes specify behavior of all
+ *      the interfaces on a devices.
+ * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
+ * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
+ * @bInterfaceClass: Class of interface; numbers are assigned
+ *      by the USB forum.  Products may choose to implement classes,
+ *      or be vendor-specific.  Interface classes specify behavior only
+ *      of a given interface; other interfaces may support other classes.
+ * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
+ * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
+ * @driver_info: Holds information used by the driver.  Usually it holds
+ *      a pointer to a descriptor understood by the driver, or perhaps
+ *      device flags.
+ *
+ * In most cases, drivers will create a table of device IDs by using
+ * USB_DEVICE(), or similar macros designed for that purpose.
+ * They will then export it to userspace using MODULE_DEVICE_TABLE(),
+ * and provide it to the USB core through their usb_driver structure.
+ *
+ * See the usb_match_id() function for information about how matches are
+ * performed.  Briefly, you will normally use one of several macros to help
+ * construct these entries.  Each entry you provide will either identify
+ * one or more specific products, or will identify a class of products
+ * which have agreed to behave the same.  You should put the more specific
+ * matches towards the beginning of your table, so that driver_info can
+ * record quirks of specific products.
+ */
+struct usb_device_id {
+        /* which fields to match against? */
+        __u16           match_flags;
+
+        /* Used for product specific matches; range is inclusive */
+        __u16           idVendor;
+        __u16           idProduct;
+        __u16           bcdDevice_lo;
+        __u16           bcdDevice_hi;
+
+        /* Used for device class matches */
+        __u8            bDeviceClass;
+        __u8            bDeviceSubClass;
+        __u8            bDeviceProtocol;
+
+        /* Used for interface class matches */
+        __u8            bInterfaceClass;
+        __u8            bInterfaceSubClass;
+        __u8            bInterfaceProtocol;
+
+        /* not matched against */
+        kernel_ulong_t  driver_info;
+};
+
+/* Some useful macros to use to create struct usb_device_id */
+#define USB_DEVICE_ID_MATCH_VENDOR              0x0001
+#define USB_DEVICE_ID_MATCH_PRODUCT             0x0002
+#define USB_DEVICE_ID_MATCH_DEV_LO              0x0004
+#define USB_DEVICE_ID_MATCH_DEV_HI              0x0008
+#define USB_DEVICE_ID_MATCH_DEV_CLASS           0x0010
+#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS        0x0020
+#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL        0x0040
+#define USB_DEVICE_ID_MATCH_INT_CLASS           0x0080
+#define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
+#define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
+
+/* s390 CCW devices */
+struct ccw_device_id {
+        __u16   match_flags;    /* which fields to match against */
+
+        __u16   cu_type;        /* control unit type     */
+        __u16   dev_type;       /* device type           */
+        __u8    cu_model;       /* control unit model    */
+        __u8    dev_model;      /* device model          */
+
+        kernel_ulong_t driver_info;
+};
+
+#define CCW_DEVICE_ID_MATCH_CU_TYPE             0x01
+#define CCW_DEVICE_ID_MATCH_CU_MODEL            0x02
+#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE         0x04
+#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL        0x08
+
+
+#define PNP_ID_LEN      8
+#define PNP_MAX_DEVICES 8
+
+struct pnp_device_id {
+        __u8 id[PNP_ID_LEN];
+        kernel_ulong_t driver_data;
+};
+
+struct pnp_card_device_id {
+        __u8 id[PNP_ID_LEN];
+        kernel_ulong_t driver_data;
+        struct {
+                __u8 id[PNP_ID_LEN];
+        } devs[PNP_MAX_DEVICES];
+};
+
+
+#define SERIO_ANY       0xff
+
+struct serio_device_id {
+        __u8 type;
+        __u8 extra;
+        __u8 id;
+        __u8 proto;
+};
+
+
+#endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
new file mode 100644
index 000000000000..0e432a0f4aee
--- /dev/null
+++ b/include/linux/module.h
@@ -0,0 +1,570 @@
+#ifndef _LINUX_MODULE_H
+#define _LINUX_MODULE_H
+/*
+ * Dynamic loading of modules into the kernel.
+ *
+ * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
+ * Rewritten again by Rusty Russell, 2002
+ */
+#include <linux/config.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/stat.h>
+#include <linux/compiler.h>
+#include <linux/cache.h>
+#include <linux/kmod.h>
+#include <linux/elf.h>
+#include <linux/stringify.h>
+#include <linux/kobject.h>
+#include <linux/moduleparam.h>
+#include <asm/local.h>
+
+#include <asm/module.h>
+
+/* Not Yet Implemented */
+#define MODULE_SUPPORTED_DEVICE(name)
+
+/* v850 toolchain uses a `_' prefix for all user symbols */
+#ifndef MODULE_SYMBOL_PREFIX
+#define MODULE_SYMBOL_PREFIX ""
+#endif
+
+#define MODULE_NAME_LEN (64 - sizeof(unsigned long))
+
+struct kernel_symbol
+{
+        unsigned long value;
+        const char *name;
+};
+
+struct modversion_info
+{
+        unsigned long crc;
+        char name[MODULE_NAME_LEN];
+};
+
+struct module;
+
+struct module_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct module_attribute *, struct module *, char *);
+        ssize_t (*store)(struct module_attribute *, struct module *,
+                         const char *, size_t count);
+};
+
+struct module_kobject
+{
+        struct kobject kobj;
+        struct module *mod;
+};
+
+/* These are either module local, or the kernel's dummy ones. */
+extern int init_module(void);
+extern void cleanup_module(void);
+
+/* Archs provide a method of finding the correct exception table. */
+struct exception_table_entry;
+
+const struct exception_table_entry *
+search_extable(const struct exception_table_entry *first,
+               const struct exception_table_entry *last,
+               unsigned long value);
+void sort_extable(struct exception_table_entry *start,
+                  struct exception_table_entry *finish);
+void sort_main_extable(void);
+
+extern struct subsystem module_subsys;
+
+#ifdef MODULE
+#define MODULE_GENERIC_TABLE(gtype,name)                        \
+extern const struct gtype##_id __mod_##gtype##_table            \
+  __attribute__ ((unused, alias(__stringify(name))))
+
+extern struct module __this_module;
+#define THIS_MODULE (&__this_module)
+#else  /* !MODULE */
+#define MODULE_GENERIC_TABLE(gtype,name)
+#define THIS_MODULE ((struct module *)0)
+#endif
+
+/* Generic info of form tag = "info" */
+#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
+
+/* For userspace: you can also call me... */
+#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
+
+/*
+ * The following license idents are currently accepted as indicating free
+ * software modules
+ *
+ *      "GPL"                           [GNU Public License v2 or later]
+ *      "GPL v2"                        [GNU Public License v2]
+ *      "GPL and additional rights"     [GNU Public License v2 rights and more]
+ *      "Dual BSD/GPL"                  [GNU Public License v2
+ *                                       or BSD license choice]
+ *      "Dual MPL/GPL"                  [GNU Public License v2
+ *                                       or Mozilla license choice]
+ *
+ * The following other idents are available
+ *
+ *      "Proprietary"                   [Non free products]
+ *
+ * There are dual licensed components, but when running with Linux it is the
+ * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
+ * is a GPL combined work.
+ *
+ * This exists for several reasons
+ * 1.   So modinfo can show license info for users wanting to vet their setup 
+ *      is free
+ * 2.   So the community can ignore bug reports including proprietary modules
+ * 3.   So vendors can do likewise based on their own policies
+ */
+#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
+
+/* Author, ideally of form NAME <EMAIL>[, NAME <EMAIL>]*[ and NAME <EMAIL>] */
+#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
+  
+/* What your module does. */
+#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
+
+/* One for each parameter, describing how to use it.  Some files do
+   multiple of these per line, so can't just use MODULE_INFO. */
+#define MODULE_PARM_DESC(_parm, desc) \
+        __MODULE_INFO(parm, _parm, #_parm ":" desc)
+
+#define MODULE_DEVICE_TABLE(type,name)          \
+  MODULE_GENERIC_TABLE(type##_device,name)
+
+/* Version of form [<epoch>:]<version>[-<extra-version>].
+   Or for CVS/RCS ID version, everything but the number is stripped.
+  <epoch>: A (small) unsigned integer which allows you to start versions
+           anew. If not mentioned, it's zero.  eg. "2:1.0" is after
+           "1:2.0".
+  <version>: The <version> may contain only alphanumerics and the
+           character `.'.  Ordered by numeric sort for numeric parts,
+           ascii sort for ascii parts (as per RPM or DEB algorithm).
+  <extraversion>: Like <version>, but inserted for local
+           customizations, eg "rh3" or "rusty1".
+
+  Using this automatically adds a checksum of the .c files and the
+  local headers in "srcversion".
+*/
+#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
+
+/* Given an address, look for it in the exception tables */
+const struct exception_table_entry *search_exception_tables(unsigned long add);
+
+struct notifier_block;
+
+#ifdef CONFIG_MODULES
+
+/* Get/put a kernel symbol (calls must be symmetric) */
+void *__symbol_get(const char *symbol);
+void *__symbol_get_gpl(const char *symbol);
+#define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
+
+#ifndef __GENKSYMS__
+#ifdef CONFIG_MODVERSIONS
+/* Mark the CRC weak since genksyms apparently decides not to
+ * generate a checksums for some symbols */
+#define __CRC_SYMBOL(sym, sec)                                  \
+        extern void *__crc_##sym __attribute__((weak));         \
+        static const unsigned long __kcrctab_##sym              \
+        __attribute_used__                                      \
+        __attribute__((section("__kcrctab" sec), unused))       \
+        = (unsigned long) &__crc_##sym;
+#else
+#define __CRC_SYMBOL(sym, sec)
+#endif
+
+/* For every exported symbol, place a struct in the __ksymtab section */
+#define __EXPORT_SYMBOL(sym, sec)                               \
+        __CRC_SYMBOL(sym, sec)                                  \
+        static const char __kstrtab_##sym[]                     \
+        __attribute__((section("__ksymtab_strings")))           \
+        = MODULE_SYMBOL_PREFIX #sym;                            \
+        static const struct kernel_symbol __ksymtab_##sym       \
+        __attribute_used__                                      \
+        __attribute__((section("__ksymtab" sec), unused))       \
+        = { (unsigned long)&sym, __kstrtab_##sym }
+
+#define EXPORT_SYMBOL(sym)                                      \
+        __EXPORT_SYMBOL(sym, "")
+
+#define EXPORT_SYMBOL_GPL(sym)                                  \
+        __EXPORT_SYMBOL(sym, "_gpl")
+
+#endif
+
+struct module_ref
+{
+        local_t count;
+} ____cacheline_aligned;
+
+enum module_state
+{
+        MODULE_STATE_LIVE,
+        MODULE_STATE_COMING,
+        MODULE_STATE_GOING,
+};
+
+/* Similar stuff for section attributes. */
+#define MODULE_SECT_NAME_LEN 32
+struct module_sect_attr
+{
+        struct module_attribute mattr;
+        char name[MODULE_SECT_NAME_LEN];
+        unsigned long address;
+};
+
+struct module_sect_attrs
+{
+        struct attribute_group grp;
+        struct module_sect_attr attrs[0];
+};
+
+struct module_param_attrs;
+
+struct module
+{
+        enum module_state state;
+
+        /* Member of list of modules */
+        struct list_head list;
+
+        /* Unique handle for this module */
+        char name[MODULE_NAME_LEN];
+
+        /* Sysfs stuff. */
+        struct module_kobject mkobj;
+        struct module_param_attrs *param_attrs;
+
+        /* Exported symbols */
+        const struct kernel_symbol *syms;
+        unsigned int num_syms;
+        const unsigned long *crcs;
+
+        /* GPL-only exported symbols. */
+        const struct kernel_symbol *gpl_syms;
+        unsigned int num_gpl_syms;
+        const unsigned long *gpl_crcs;
+
+        /* Exception table */
+        unsigned int num_exentries;
+        const struct exception_table_entry *extable;
+
+        /* Startup function. */
+        int (*init)(void);
+
+        /* If this is non-NULL, vfree after init() returns */
+        void *module_init;
+
+        /* Here is the actual code + data, vfree'd on unload. */
+        void *module_core;
+
+        /* Here are the sizes of the init and core sections */
+        unsigned long init_size, core_size;
+
+        /* The size of the executable code in each section.  */
+        unsigned long init_text_size, core_text_size;
+
+        /* Arch-specific module values */
+        struct mod_arch_specific arch;
+
+        /* Am I unsafe to unload? */
+        int unsafe;
+
+        /* Am I GPL-compatible */
+        int license_gplok;
+
+#ifdef CONFIG_MODULE_UNLOAD
+        /* Reference counts */
+        struct module_ref ref[NR_CPUS];
+
+        /* What modules depend on me? */
+        struct list_head modules_which_use_me;
+
+        /* Who is waiting for us to be unloaded */
+        struct task_struct *waiter;
+
+        /* Destruction function. */
+        void (*exit)(void);
+#endif
+
+#ifdef CONFIG_KALLSYMS
+        /* We keep the symbol and string tables for kallsyms. */
+        Elf_Sym *symtab;
+        unsigned long num_symtab;
+        char *strtab;
+
+        /* Section attributes */
+        struct module_sect_attrs *sect_attrs;
+#endif
+
+        /* Per-cpu data. */
+        void *percpu;
+
+        /* The command line arguments (may be mangled).  People like
+           keeping pointers to this stuff */
+        char *args;
+};
+
+/* FIXME: It'd be nice to isolate modules during init, too, so they
+   aren't used before they (may) fail.  But presently too much code
+   (IDE & SCSI) require entry into the module during init.*/
+static inline int module_is_live(struct module *mod)
+{
+        return mod->state != MODULE_STATE_GOING;
+}
+
+/* Is this address in a module? (second is with no locks, for oops) */
+struct module *module_text_address(unsigned long addr);
+struct module *__module_text_address(unsigned long addr);
+
+/* Returns module and fills in value, defined and namebuf, or NULL if
+   symnum out of range. */
+struct module *module_get_kallsym(unsigned int symnum,
+                                  unsigned long *value,
+                                  char *type,
+                                  char namebuf[128]);
+
+/* Look for this name: can be of form module:name. */
+unsigned long module_kallsyms_lookup_name(const char *name);
+
+int is_exported(const char *name, const struct module *mod);
+
+extern void __module_put_and_exit(struct module *mod, long code)
+        __attribute__((noreturn));
+#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
+
+#ifdef CONFIG_MODULE_UNLOAD
+unsigned int module_refcount(struct module *mod);
+void __symbol_put(const char *symbol);
+#define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
+void symbol_put_addr(void *addr);
+
+/* Sometimes we know we already have a refcount, and it's easier not
+   to handle the error case (which only happens with rmmod --wait). */
+static inline void __module_get(struct module *module)
+{
+        if (module) {
+                BUG_ON(module_refcount(module) == 0);
+                local_inc(&module->ref[get_cpu()].count);
+                put_cpu();
+        }
+}
+
+static inline int try_module_get(struct module *module)
+{
+        int ret = 1;
+
+        if (module) {
+                unsigned int cpu = get_cpu();
+                if (likely(module_is_live(module)))
+                        local_inc(&module->ref[cpu].count);
+                else
+                        ret = 0;
+                put_cpu();
+        }
+        return ret;
+}
+
+static inline void module_put(struct module *module)
+{
+        if (module) {
+                unsigned int cpu = get_cpu();
+                local_dec(&module->ref[cpu].count);
+                /* Maybe they're waiting for us to drop reference? */
+                if (unlikely(!module_is_live(module)))
+                        wake_up_process(module->waiter);
+                put_cpu();
+        }
+}
+
+#else /*!CONFIG_MODULE_UNLOAD*/
+static inline int try_module_get(struct module *module)
+{
+        return !module || module_is_live(module);
+}
+static inline void module_put(struct module *module)
+{
+}
+static inline void __module_get(struct module *module)
+{
+}
+#define symbol_put(x) do { } while(0)
+#define symbol_put_addr(p) do { } while(0)
+
+#endif /* CONFIG_MODULE_UNLOAD */
+
+/* This is a #define so the string doesn't get put in every .o file */
+#define module_name(mod)                        \
+({                                              \
+        struct module *__mod = (mod);           \
+        __mod ? __mod->name : "kernel";         \
+})
+
+#define __unsafe(mod)                                                        \
+do {                                                                         \
+        if (mod && !(mod)->unsafe) {                                         \
+                printk(KERN_WARNING                                          \
+                       "Module %s cannot be unloaded due to unsafe usage in" \
+                       " %s:%u\n", (mod)->name, __FILE__, __LINE__);         \
+                (mod)->unsafe = 1;                                           \
+        }                                                                    \
+} while(0)
+
+/* For kallsyms to ask for address resolution.  NULL means not found. */
+const char *module_address_lookup(unsigned long addr,
+                                  unsigned long *symbolsize,
+                                  unsigned long *offset,
+                                  char **modname);
+
+/* For extable.c to search modules' exception tables. */
+const struct exception_table_entry *search_module_extables(unsigned long addr);
+
+int register_module_notifier(struct notifier_block * nb);
+int unregister_module_notifier(struct notifier_block * nb);
+
+extern void print_modules(void);
+
+struct device_driver;
+void module_add_driver(struct module *, struct device_driver *);
+void module_remove_driver(struct device_driver *);
+
+#else /* !CONFIG_MODULES... */
+#define EXPORT_SYMBOL(sym)
+#define EXPORT_SYMBOL_GPL(sym)
+
+/* Given an address, look for it in the exception tables. */
+static inline const struct exception_table_entry *
+search_module_extables(unsigned long addr)
+{
+        return NULL;
+}
+
+/* Is this address in a module? */
+static inline struct module *module_text_address(unsigned long addr)
+{
+        return NULL;
+}
+
+/* Is this address in a module? (don't take a lock, we're oopsing) */
+static inline struct module *__module_text_address(unsigned long addr)
+{
+        return NULL;
+}
+
+/* Get/put a kernel symbol (calls should be symmetric) */
+#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
+#define symbol_put(x) do { } while(0)
+#define symbol_put_addr(x) do { } while(0)
+
+static inline void __module_get(struct module *module)
+{
+}
+
+static inline int try_module_get(struct module *module)
+{
+        return 1;
+}
+
+static inline void module_put(struct module *module)
+{
+}
+
+#define module_name(mod) "kernel"
+
+#define __unsafe(mod)
+
+/* For kallsyms to ask for address resolution.  NULL means not found. */
+static inline const char *module_address_lookup(unsigned long addr,
+                                                unsigned long *symbolsize,
+                                                unsigned long *offset,
+                                                char **modname)
+{
+        return NULL;
+}
+
+static inline struct module *module_get_kallsym(unsigned int symnum,
+                                                unsigned long *value,
+                                                char *type,
+                                                char namebuf[128])
+{
+        return NULL;
+}
+
+static inline unsigned long module_kallsyms_lookup_name(const char *name)
+{
+        return 0;
+}
+
+static inline int is_exported(const char *name, const struct module *mod)
+{
+        return 0;
+}
+
+static inline int register_module_notifier(struct notifier_block * nb)
+{
+        /* no events will happen anyway, so this can always succeed */
+        return 0;
+}
+
+static inline int unregister_module_notifier(struct notifier_block * nb)
+{
+        return 0;
+}
+
+#define module_put_and_exit(code) do_exit(code)
+
+static inline void print_modules(void)
+{
+}
+
+struct device_driver;
+struct module;
+
+static inline void module_add_driver(struct module *module, struct device_driver *driver)
+{
+}
+
+static inline void module_remove_driver(struct device_driver *driver)
+{
+}
+
+#endif /* CONFIG_MODULES */
+
+#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
+
+/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
+
+struct obsolete_modparm {
+        char name[64];
+        char type[64-sizeof(void *)];
+        void *addr;
+};
+
+static inline void MODULE_PARM_(void) { }
+#ifdef MODULE
+/* DEPRECATED: Do not use. */
+#define MODULE_PARM(var,type)                                               \
+struct obsolete_modparm __parm_##var __attribute__((section("__obsparm"))) = \
+{ __stringify(var), type, &MODULE_PARM_ }; \
+__MODULE_PARM_TYPE(var, type);
+#else
+#define MODULE_PARM(var,type) static void __attribute__((__unused__)) *__parm_##var = &MODULE_PARM_;
+#endif
+
+#define __MODULE_STRING(x) __stringify(x)
+
+/* Use symbol_get and symbol_put instead.  You'll thank me. */
+#define HAVE_INTER_MODULE
+extern void __deprecated inter_module_register(const char *,
+                struct module *, const void *);
+extern void __deprecated inter_module_unregister(const char *);
+extern const void * __deprecated inter_module_get_request(const char *,
+                const char *);
+extern void __deprecated inter_module_put(const char *);
+
+#endif /* _LINUX_MODULE_H */
diff --git a/include/linux/moduleloader.h b/include/linux/moduleloader.h
new file mode 100644
index 000000000000..eb1033957486
--- /dev/null
+++ b/include/linux/moduleloader.h
@@ -0,0 +1,47 @@
+#ifndef _LINUX_MODULELOADER_H
+#define _LINUX_MODULELOADER_H
+/* The stuff needed for archs to support modules. */
+
+#include <linux/module.h>
+#include <linux/elf.h>
+
+/* These must be implemented by the specific architecture */
+
+/* Adjust arch-specific sections.  Return 0 on success.  */
+int module_frob_arch_sections(Elf_Ehdr *hdr,
+                              Elf_Shdr *sechdrs,
+                              char *secstrings,
+                              struct module *mod);
+
+/* Allocator used for allocating struct module, core sections and init
+   sections.  Returns NULL on failure. */
+void *module_alloc(unsigned long size);
+
+/* Free memory returned from module_alloc. */
+void module_free(struct module *mod, void *module_region);
+
+/* Apply the given relocation to the (simplified) ELF.  Return -error
+   or 0. */
+int apply_relocate(Elf_Shdr *sechdrs,
+                   const char *strtab,
+                   unsigned int symindex,
+                   unsigned int relsec,
+                   struct module *mod);
+
+/* Apply the given add relocation to the (simplified) ELF.  Return
+   -error or 0 */
+int apply_relocate_add(Elf_Shdr *sechdrs,
+                       const char *strtab,
+                       unsigned int symindex,
+                       unsigned int relsec,
+                       struct module *mod);
+
+/* Any final processing of module before access.  Return -error or 0. */
+int module_finalize(const Elf_Ehdr *hdr,
+                    const Elf_Shdr *sechdrs,
+                    struct module *mod);
+
+/* Any cleanup needed when module leaves. */
+void module_arch_cleanup(struct module *mod);
+
+#endif
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
new file mode 100644
index 000000000000..368ec8e45bd0
--- /dev/null
+++ b/include/linux/moduleparam.h
@@ -0,0 +1,182 @@
+#ifndef _LINUX_MODULE_PARAMS_H
+#define _LINUX_MODULE_PARAMS_H
+/* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */
+#include <linux/init.h>
+#include <linux/stringify.h>
+#include <linux/kernel.h>
+
+/* You can override this manually, but generally this should match the
+   module name. */
+#ifdef MODULE
+#define MODULE_PARAM_PREFIX /* empty */
+#else
+#define MODULE_PARAM_PREFIX __stringify(KBUILD_MODNAME) "."
+#endif
+
+#ifdef MODULE
+#define ___module_cat(a,b) __mod_ ## a ## b
+#define __module_cat(a,b) ___module_cat(a,b)
+#define __MODULE_INFO(tag, name, info)                                    \
+static const char __module_cat(name,__LINE__)[]                           \
+  __attribute_used__                                                      \
+  __attribute__((section(".modinfo"),unused)) = __stringify(tag) "=" info
+#else  /* !MODULE */
+#define __MODULE_INFO(tag, name, info)
+#endif
+#define __MODULE_PARM_TYPE(name, _type)                                   \
+  __MODULE_INFO(parmtype, name##type, #name ":" _type)
+
+struct kernel_param;
+
+/* Returns 0, or -errno.  arg is in kp->arg. */
+typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
+/* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
+typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
+
+struct kernel_param {
+        const char *name;
+        unsigned int perm;
+        param_set_fn set;
+        param_get_fn get;
+        void *arg;
+};
+
+/* Special one for strings we want to copy into */
+struct kparam_string {
+        unsigned int maxlen;
+        char *string;
+};
+
+/* Special one for arrays */
+struct kparam_array
+{
+        unsigned int max;
+        unsigned int *num;
+        param_set_fn set;
+        param_get_fn get;
+        unsigned int elemsize;
+        void *elem;
+};
+
+/* This is the fundamental function for registering boot/module
+   parameters.  perm sets the visibility in driverfs: 000 means it's
+   not there, read bits mean it's readable, write bits mean it's
+   writable. */
+#define __module_param_call(prefix, name, set, get, arg, perm)          \
+        static char __param_str_##name[] = prefix #name;                \
+        static struct kernel_param const __param_##name                 \
+        __attribute_used__                                              \
+    __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
+        = { __param_str_##name, perm, set, get, arg }
+
+#define module_param_call(name, set, get, arg, perm)                          \
+        __module_param_call(MODULE_PARAM_PREFIX, name, set, get, arg, perm)
+
+/* Helper functions: type is byte, short, ushort, int, uint, long,
+   ulong, charp, bool or invbool, or XXX if you define param_get_XXX,
+   param_set_XXX and param_check_XXX. */
+#define module_param_named(name, value, type, perm)                        \
+        param_check_##type(name, &(value));                                \
+        module_param_call(name, param_set_##type, param_get_##type, &value, perm); \
+        __MODULE_PARM_TYPE(name, #type)
+
+#define module_param(name, type, perm)                          \
+        module_param_named(name, name, type, perm)
+
+/* Actually copy string: maxlen param is usually sizeof(string). */
+#define module_param_string(name, string, len, perm)                    \
+        static struct kparam_string __param_string_##name               \
+                = { len, string };                                      \
+        module_param_call(name, param_set_copystring, param_get_string, \
+                   &__param_string_##name, perm);                       \
+        __MODULE_PARM_TYPE(name, "string")
+
+/* Called on module insert or kernel boot */
+extern int parse_args(const char *name,
+                      char *args,
+                      struct kernel_param *params,
+                      unsigned num,
+                      int (*unknown)(char *param, char *val));
+
+/* All the helper functions */
+/* The macros to do compile-time type checking stolen from Jakub
+   Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
+#define __param_check(name, p, type) \
+        static inline type *__check_##name(void) { return(p); }
+
+extern int param_set_byte(const char *val, struct kernel_param *kp);
+extern int param_get_byte(char *buffer, struct kernel_param *kp);
+#define param_check_byte(name, p) __param_check(name, p, unsigned char)
+
+extern int param_set_short(const char *val, struct kernel_param *kp);
+extern int param_get_short(char *buffer, struct kernel_param *kp);
+#define param_check_short(name, p) __param_check(name, p, short)
+
+extern int param_set_ushort(const char *val, struct kernel_param *kp);
+extern int param_get_ushort(char *buffer, struct kernel_param *kp);
+#define param_check_ushort(name, p) __param_check(name, p, unsigned short)
+
+extern int param_set_int(const char *val, struct kernel_param *kp);
+extern int param_get_int(char *buffer, struct kernel_param *kp);
+#define param_check_int(name, p) __param_check(name, p, int)
+
+extern int param_set_uint(const char *val, struct kernel_param *kp);
+extern int param_get_uint(char *buffer, struct kernel_param *kp);
+#define param_check_uint(name, p) __param_check(name, p, unsigned int)
+
+extern int param_set_long(const char *val, struct kernel_param *kp);
+extern int param_get_long(char *buffer, struct kernel_param *kp);
+#define param_check_long(name, p) __param_check(name, p, long)
+
+extern int param_set_ulong(const char *val, struct kernel_param *kp);
+extern int param_get_ulong(char *buffer, struct kernel_param *kp);
+#define param_check_ulong(name, p) __param_check(name, p, unsigned long)
+
+extern int param_set_charp(const char *val, struct kernel_param *kp);
+extern int param_get_charp(char *buffer, struct kernel_param *kp);
+#define param_check_charp(name, p) __param_check(name, p, char *)
+
+extern int param_set_bool(const char *val, struct kernel_param *kp);
+extern int param_get_bool(char *buffer, struct kernel_param *kp);
+#define param_check_bool(name, p) __param_check(name, p, int)
+
+extern int param_set_invbool(const char *val, struct kernel_param *kp);
+extern int param_get_invbool(char *buffer, struct kernel_param *kp);
+#define param_check_invbool(name, p) __param_check(name, p, int)
+
+/* Comma-separated array: *nump is set to number they actually specified. */
+#define module_param_array_named(name, array, type, nump, perm)         \
+        static struct kparam_array __param_arr_##name                   \
+        = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\
+            sizeof(array[0]), array };                                  \
+        module_param_call(name, param_array_set, param_array_get,       \
+                          &__param_arr_##name, perm);                   \
+        __MODULE_PARM_TYPE(name, "array of " #type)
+
+#define module_param_array(name, type, nump, perm)              \
+        module_param_array_named(name, name, type, nump, perm)
+
+extern int param_array_set(const char *val, struct kernel_param *kp);
+extern int param_array_get(char *buffer, struct kernel_param *kp);
+
+extern int param_set_copystring(const char *val, struct kernel_param *kp);
+extern int param_get_string(char *buffer, struct kernel_param *kp);
+
+int param_array(const char *name,
+                const char *val,
+                unsigned int min, unsigned int max,
+                void *elem, int elemsize,
+                int (*set)(const char *, struct kernel_param *kp),
+                int *num);
+
+/* for exporting parameters in /sys/parameters */
+
+struct module;
+
+extern int module_param_sysfs_setup(struct module *mod,
+                                    struct kernel_param *kparam,
+                                    unsigned int num_params);
+
+extern void module_param_sysfs_remove(struct module *mod);
+
+#endif /* _LINUX_MODULE_PARAMS_H */
diff --git a/include/linux/mount.h b/include/linux/mount.h
new file mode 100644
index 000000000000..8b8d3b9beefd
--- /dev/null
+++ b/include/linux/mount.h
@@ -0,0 +1,81 @@
+/*
+ *
+ * Definitions for mount interface. This describes the in the kernel build 
+ * linkedlist with mounted filesystems.
+ *
+ * Author:  Marco van Wieringen <mvw@planets.elm.net>
+ *
+ * Version: $Id: mount.h,v 2.0 1996/11/17 16:48:14 mvw Exp mvw $
+ *
+ */
+#ifndef _LINUX_MOUNT_H
+#define _LINUX_MOUNT_H
+#ifdef __KERNEL__
+
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <asm/atomic.h>
+
+#define MNT_NOSUID      1
+#define MNT_NODEV       2
+#define MNT_NOEXEC      4
+
+struct vfsmount
+{
+        struct list_head mnt_hash;
+        struct vfsmount *mnt_parent;    /* fs we are mounted on */
+        struct dentry *mnt_mountpoint;  /* dentry of mountpoint */
+        struct dentry *mnt_root;        /* root of the mounted tree */
+        struct super_block *mnt_sb;     /* pointer to superblock */
+        struct list_head mnt_mounts;    /* list of children, anchored here */
+        struct list_head mnt_child;     /* and going through their mnt_child */
+        atomic_t mnt_count;
+        int mnt_flags;
+        int mnt_expiry_mark;            /* true if marked for expiry */
+        char *mnt_devname;              /* Name of device e.g. /dev/dsk/hda1 */
+        struct list_head mnt_list;
+        struct list_head mnt_fslink;    /* link in fs-specific expiry list */
+        struct namespace *mnt_namespace; /* containing namespace */
+};
+
+static inline struct vfsmount *mntget(struct vfsmount *mnt)
+{
+        if (mnt)
+                atomic_inc(&mnt->mnt_count);
+        return mnt;
+}
+
+extern void __mntput(struct vfsmount *mnt);
+
+static inline void _mntput(struct vfsmount *mnt)
+{
+        if (mnt) {
+                if (atomic_dec_and_test(&mnt->mnt_count))
+                        __mntput(mnt);
+        }
+}
+
+static inline void mntput(struct vfsmount *mnt)
+{
+        if (mnt) {
+                mnt->mnt_expiry_mark = 0;
+                _mntput(mnt);
+        }
+}
+
+extern void free_vfsmnt(struct vfsmount *mnt);
+extern struct vfsmount *alloc_vfsmnt(const char *name);
+extern struct vfsmount *do_kern_mount(const char *fstype, int flags,
+                                      const char *name, void *data);
+
+struct nameidata;
+
+extern int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
+                        int mnt_flags, struct list_head *fslist);
+
+extern void mark_mounts_for_expiry(struct list_head *mounts);
+
+extern spinlock_t vfsmount_lock;
+
+#endif
+#endif /* _LINUX_MOUNT_H */
diff --git a/include/linux/mpage.h b/include/linux/mpage.h
new file mode 100644
index 000000000000..dea1b0083661
--- /dev/null
+++ b/include/linux/mpage.h
@@ -0,0 +1,31 @@
+/*
+ * include/linux/mpage.h
+ *
+ * Contains declarations related to preparing and submitting BIOS which contain
+ * multiple pagecache pages.
+ */
+
+/*
+ * (And no, it doesn't do the #ifdef __MPAGE_H thing, and it doesn't do
+ * nested includes.  Get it right in the .c file).
+ */
+
+struct writeback_control;
+typedef int (writepage_t)(struct page *page, struct writeback_control *wbc);
+
+int mpage_readpages(struct address_space *mapping, struct list_head *pages,
+                                unsigned nr_pages, get_block_t get_block);
+int mpage_readpage(struct page *page, get_block_t get_block);
+int mpage_writepages(struct address_space *mapping,
+                struct writeback_control *wbc, get_block_t get_block);
+int mpage_writepage(struct page *page, get_block_t *get_block,
+                struct writeback_control *wbc);
+int __mpage_writepages(struct address_space *mapping,
+                struct writeback_control *wbc, get_block_t get_block,
+                writepage_t writepage);
+
+static inline int
+generic_writepages(struct address_space *mapping, struct writeback_control *wbc)
+{
+        return mpage_writepages(mapping, wbc, NULL);
+}
diff --git a/include/linux/mqueue.h b/include/linux/mqueue.h
new file mode 100644
index 000000000000..8db9d75541a6
--- /dev/null
+++ b/include/linux/mqueue.h
@@ -0,0 +1,55 @@
+/* Copyright (C) 2003 Krzysztof Benedyczak & Michal Wronski
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   It is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this software; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _LINUX_MQUEUE_H
+#define _LINUX_MQUEUE_H
+
+#include <linux/types.h>
+
+#define MQ_PRIO_MAX     32768
+/* per-uid limit of kernel memory used by mqueue, in bytes */
+#define MQ_BYTES_MAX    819200
+
+struct mq_attr {
+        long    mq_flags;       /* message queue flags                  */
+        long    mq_maxmsg;      /* maximum number of messages           */
+        long    mq_msgsize;     /* maximum message size                 */
+        long    mq_curmsgs;     /* number of messages currently queued  */
+        long    __reserved[4];  /* ignored for input, zeroed for output */
+};
+
+/*
+ * SIGEV_THREAD implementation:
+ * SIGEV_THREAD must be implemented in user space. If SIGEV_THREAD is passed
+ * to mq_notify, then
+ * - sigev_signo must be the file descriptor of an AF_NETLINK socket. It's not
+ *   necessary that the socket is bound.
+ * - sigev_value.sival_ptr must point to a cookie that is NOTIFY_COOKIE_LEN
+ *   bytes long.
+ * If the notification is triggered, then the cookie is sent to the netlink
+ * socket. The last byte of the cookie is replaced with the NOTIFY_?? codes:
+ * NOTIFY_WOKENUP if the notification got triggered, NOTIFY_REMOVED if it was
+ * removed, either due to a close() on the message queue fd or due to a
+ * mq_notify() that removed the notification.
+ */
+#define NOTIFY_NONE     0
+#define NOTIFY_WOKENUP  1
+#define NOTIFY_REMOVED  2
+
+#define NOTIFY_COOKIE_LEN       32
+
+#endif
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
new file mode 100644
index 000000000000..e05d54a90743
--- /dev/null
+++ b/include/linux/mroute.h
@@ -0,0 +1,226 @@
+#ifndef __LINUX_MROUTE_H
+#define __LINUX_MROUTE_H
+
+#include <linux/sockios.h>
+#include <linux/in.h>
+
+/*
+ *      Based on the MROUTING 3.5 defines primarily to keep
+ *      source compatibility with BSD.
+ *
+ *      See the mrouted code for the original history.
+ *
+ *      Protocol Independent Multicast (PIM) data structures included
+ *      Carlos Picoto (cap@di.fc.ul.pt)
+ *
+ */
+
+#define MRT_BASE        200
+#define MRT_INIT        (MRT_BASE)      /* Activate the kernel mroute code      */
+#define MRT_DONE        (MRT_BASE+1)    /* Shutdown the kernel mroute           */
+#define MRT_ADD_VIF     (MRT_BASE+2)    /* Add a virtual interface              */
+#define MRT_DEL_VIF     (MRT_BASE+3)    /* Delete a virtual interface           */
+#define MRT_ADD_MFC     (MRT_BASE+4)    /* Add a multicast forwarding entry     */
+#define MRT_DEL_MFC     (MRT_BASE+5)    /* Delete a multicast forwarding entry  */
+#define MRT_VERSION     (MRT_BASE+6)    /* Get the kernel multicast version     */
+#define MRT_ASSERT      (MRT_BASE+7)    /* Activate PIM assert mode             */
+#define MRT_PIM         (MRT_BASE+8)    /* enable PIM code      */
+
+#define SIOCGETVIFCNT   SIOCPROTOPRIVATE        /* IP protocol privates */
+#define SIOCGETSGCNT    (SIOCPROTOPRIVATE+1)
+#define SIOCGETRPF      (SIOCPROTOPRIVATE+2)
+
+#define MAXVIFS         32      
+typedef unsigned long vifbitmap_t;      /* User mode code depends on this lot */
+typedef unsigned short vifi_t;
+#define ALL_VIFS        ((vifi_t)(-1))
+
+/*
+ *      Same idea as select
+ */
+ 
+#define VIFM_SET(n,m)   ((m)|=(1<<(n)))
+#define VIFM_CLR(n,m)   ((m)&=~(1<<(n)))
+#define VIFM_ISSET(n,m) ((m)&(1<<(n)))
+#define VIFM_CLRALL(m)  ((m)=0)
+#define VIFM_COPY(mfrom,mto)    ((mto)=(mfrom))
+#define VIFM_SAME(m1,m2)        ((m1)==(m2))
+
+/*
+ *      Passed by mrouted for an MRT_ADD_VIF - again we use the
+ *      mrouted 3.6 structures for compatibility
+ */
+ 
+struct vifctl {
+        vifi_t  vifc_vifi;              /* Index of VIF */
+        unsigned char vifc_flags;       /* VIFF_ flags */
+        unsigned char vifc_threshold;   /* ttl limit */
+        unsigned int vifc_rate_limit;   /* Rate limiter values (NI) */
+        struct in_addr vifc_lcl_addr;   /* Our address */
+        struct in_addr vifc_rmt_addr;   /* IPIP tunnel addr */
+};
+
+#define VIFF_TUNNEL     0x1     /* IPIP tunnel */
+#define VIFF_SRCRT      0x2     /* NI */
+#define VIFF_REGISTER   0x4     /* register vif */
+
+/*
+ *      Cache manipulation structures for mrouted and PIMd
+ */
+ 
+struct mfcctl
+{
+        struct in_addr mfcc_origin;             /* Origin of mcast      */
+        struct in_addr mfcc_mcastgrp;           /* Group in question    */
+        vifi_t  mfcc_parent;                    /* Where it arrived     */
+        unsigned char mfcc_ttls[MAXVIFS];       /* Where it is going    */
+        unsigned int mfcc_pkt_cnt;              /* pkt count for src-grp */
+        unsigned int mfcc_byte_cnt;
+        unsigned int mfcc_wrong_if;
+        int          mfcc_expire;
+};
+
+/* 
+ *      Group count retrieval for mrouted
+ */
+ 
+struct sioc_sg_req
+{
+        struct in_addr src;
+        struct in_addr grp;
+        unsigned long pktcnt;
+        unsigned long bytecnt;
+        unsigned long wrong_if;
+};
+
+/*
+ *      To get vif packet counts
+ */
+
+struct sioc_vif_req
+{
+        vifi_t  vifi;           /* Which iface */
+        unsigned long icount;   /* In packets */
+        unsigned long ocount;   /* Out packets */
+        unsigned long ibytes;   /* In bytes */
+        unsigned long obytes;   /* Out bytes */
+};
+
+/*
+ *      This is the format the mroute daemon expects to see IGMP control
+ *      data. Magically happens to be like an IP packet as per the original
+ */
+ 
+struct igmpmsg
+{
+        __u32 unused1,unused2;
+        unsigned char im_msgtype;               /* What is this */
+        unsigned char im_mbz;                   /* Must be zero */
+        unsigned char im_vif;                   /* Interface (this ought to be a vifi_t!) */
+        unsigned char unused3;
+        struct in_addr im_src,im_dst;
+};
+
+/*
+ *      That's all usermode folks
+ */
+
+#ifdef __KERNEL__
+#include <net/sock.h>
+
+extern int ip_mroute_setsockopt(struct sock *, int, char __user *, int);
+extern int ip_mroute_getsockopt(struct sock *, int, char __user *, int __user *);
+extern int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg);
+extern void ip_mr_init(void);
+
+
+struct vif_device
+{
+        struct net_device       *dev;                   /* Device we are using */
+        unsigned long   bytes_in,bytes_out;
+        unsigned long   pkt_in,pkt_out;         /* Statistics                   */
+        unsigned long   rate_limit;             /* Traffic shaping (NI)         */
+        unsigned char   threshold;              /* TTL threshold                */
+        unsigned short  flags;                  /* Control flags                */
+        __u32           local,remote;           /* Addresses(remote for tunnels)*/
+        int             link;                   /* Physical interface index     */
+};
+
+#define VIFF_STATIC 0x8000
+
+struct mfc_cache 
+{
+        struct mfc_cache *next;                 /* Next entry on cache line     */
+        __u32 mfc_mcastgrp;                     /* Group the entry belongs to   */
+        __u32 mfc_origin;                       /* Source of packet             */
+        vifi_t mfc_parent;                      /* Source interface             */
+        int mfc_flags;                          /* Flags on line                */
+
+        union {
+                struct {
+                        unsigned long expires;
+                        struct sk_buff_head unresolved; /* Unresolved buffers           */
+                } unres;
+                struct {
+                        unsigned long last_assert;
+                        int minvif;
+                        int maxvif;
+                        unsigned long bytes;
+                        unsigned long pkt;
+                        unsigned long wrong_if;
+                        unsigned char ttls[MAXVIFS];    /* TTL thresholds               */
+                } res;
+        } mfc_un;
+};
+
+#define MFC_STATIC              1
+#define MFC_NOTIFY              2
+
+#define MFC_LINES               64
+
+#ifdef __BIG_ENDIAN
+#define MFC_HASH(a,b)   ((((a)>>24)^((b)>>26))&(MFC_LINES-1))
+#else
+#define MFC_HASH(a,b)   (((a)^((b)>>2))&(MFC_LINES-1))
+#endif          
+
+#endif
+
+
+#define MFC_ASSERT_THRESH (3*HZ)                /* Maximal freq. of asserts */
+
+/*
+ *      Pseudo messages used by mrouted
+ */
+
+#define IGMPMSG_NOCACHE         1               /* Kern cache fill request to mrouted */
+#define IGMPMSG_WRONGVIF        2               /* For PIM assert processing (unused) */
+#define IGMPMSG_WHOLEPKT        3               /* For PIM Register processing */
+
+#ifdef __KERNEL__
+
+#define PIM_V1_VERSION          __constant_htonl(0x10000000)
+#define PIM_V1_REGISTER         1
+
+#define PIM_VERSION             2
+#define PIM_REGISTER            1
+
+#define PIM_NULL_REGISTER       __constant_htonl(0x40000000)
+
+/* PIMv2 register message header layout (ietf-draft-idmr-pimvsm-v2-00.ps */
+
+struct pimreghdr
+{
+        __u8    type;
+        __u8    reserved;
+        __u16   csum;
+        __u32   flags;
+};
+
+extern int pim_rcv_v1(struct sk_buff *);
+
+struct rtmsg;
+extern int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait);
+#endif
+
+#endif
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
new file mode 100644
index 000000000000..9a3d27257984
--- /dev/null
+++ b/include/linux/msdos_fs.h
@@ -0,0 +1,412 @@
+#ifndef _LINUX_MSDOS_FS_H
+#define _LINUX_MSDOS_FS_H
+
+/*
+ * The MS-DOS filesystem constants/structures
+ */
+#include <asm/byteorder.h>
+
+#define SECTOR_SIZE     512             /* sector size (bytes) */
+#define SECTOR_BITS     9               /* log2(SECTOR_SIZE) */
+#define MSDOS_DPB       (MSDOS_DPS)     /* dir entries per block */
+#define MSDOS_DPB_BITS  4               /* log2(MSDOS_DPB) */
+#define MSDOS_DPS       (SECTOR_SIZE / sizeof(struct msdos_dir_entry))
+#define MSDOS_DPS_BITS  4               /* log2(MSDOS_DPS) */
+#define CF_LE_W(v)      le16_to_cpu(v)
+#define CF_LE_L(v)      le32_to_cpu(v)
+#define CT_LE_W(v)      cpu_to_le16(v)
+#define CT_LE_L(v)      cpu_to_le32(v)
+
+
+#define MSDOS_SUPER_MAGIC 0x4d44 /* MD */
+
+#define MSDOS_ROOT_INO  1       /* == MINIX_ROOT_INO */
+#define MSDOS_DIR_BITS  5       /* log2(sizeof(struct msdos_dir_entry)) */
+
+/* directory limit */
+#define FAT_MAX_DIR_ENTRIES     (65536)
+#define FAT_MAX_DIR_SIZE        (FAT_MAX_DIR_ENTRIES << MSDOS_DIR_BITS)
+
+#define ATTR_NONE       0       /* no attribute bits */
+#define ATTR_RO         1       /* read-only */
+#define ATTR_HIDDEN     2       /* hidden */
+#define ATTR_SYS        4       /* system */
+#define ATTR_VOLUME     8       /* volume label */
+#define ATTR_DIR        16      /* directory */
+#define ATTR_ARCH       32      /* archived */
+
+/* attribute bits that are copied "as is" */
+#define ATTR_UNUSED     (ATTR_VOLUME | ATTR_ARCH | ATTR_SYS | ATTR_HIDDEN)
+/* bits that are used by the Windows 95/Windows NT extended FAT */
+#define ATTR_EXT        (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME)
+
+#define CASE_LOWER_BASE 8       /* base is lower case */
+#define CASE_LOWER_EXT  16      /* extension is lower case */
+
+#define DELETED_FLAG    0xe5    /* marks file as deleted when in name[0] */
+#define IS_FREE(n)      (!*(n) || *(n) == DELETED_FLAG)
+
+/* valid file mode bits */
+#define MSDOS_VALID_MODE (S_IFREG | S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO)
+/* Convert attribute bits and a mask to the UNIX mode. */
+#define MSDOS_MKMODE(a, m) (m & (a & ATTR_RO ? S_IRUGO|S_IXUGO : S_IRWXUGO))
+
+#define MSDOS_NAME      11      /* maximum name length */
+#define MSDOS_LONGNAME  256     /* maximum name length */
+#define MSDOS_SLOTS     21      /* max # of slots for short and long names */
+#define MSDOS_DOT       ".          "   /* ".", padded to MSDOS_NAME chars */
+#define MSDOS_DOTDOT    "..         "   /* "..", padded to MSDOS_NAME chars */
+
+/* media of boot sector */
+#define FAT_VALID_MEDIA(x)      ((0xF8 <= (x) && (x) <= 0xFF) || (x) == 0xF0)
+#define FAT_FIRST_ENT(s, x)     ((MSDOS_SB(s)->fat_bits == 32 ? 0x0FFFFF00 : \
+        MSDOS_SB(s)->fat_bits == 16 ? 0xFF00 : 0xF00) | (x))
+
+/* start of data cluster's entry (number of reserved clusters) */
+#define FAT_START_ENT   2
+
+/* maximum number of clusters */
+#define MAX_FAT12       0xFF4
+#define MAX_FAT16       0xFFF4
+#define MAX_FAT32       0x0FFFFFF6
+#define MAX_FAT(s)      (MSDOS_SB(s)->fat_bits == 32 ? MAX_FAT32 : \
+        MSDOS_SB(s)->fat_bits == 16 ? MAX_FAT16 : MAX_FAT12)
+
+/* bad cluster mark */
+#define BAD_FAT12       0xFF7
+#define BAD_FAT16       0xFFF7
+#define BAD_FAT32       0x0FFFFFF7
+
+/* standard EOF */
+#define EOF_FAT12       0xFFF
+#define EOF_FAT16       0xFFFF
+#define EOF_FAT32       0x0FFFFFFF
+
+#define FAT_ENT_FREE    (0)
+#define FAT_ENT_BAD     (BAD_FAT32)
+#define FAT_ENT_EOF     (EOF_FAT32)
+
+#define FAT_FSINFO_SIG1 0x41615252
+#define FAT_FSINFO_SIG2 0x61417272
+#define IS_FSINFO(x)    (le32_to_cpu((x)->signature1) == FAT_FSINFO_SIG1 \
+                         && le32_to_cpu((x)->signature2) == FAT_FSINFO_SIG2)
+
+/*
+ * ioctl commands
+ */
+#define VFAT_IOCTL_READDIR_BOTH         _IOR('r', 1, struct dirent [2])
+#define VFAT_IOCTL_READDIR_SHORT        _IOR('r', 2, struct dirent [2])
+/* <linux/videotext.h> has used 0x72 ('r') in collision, so skip a few */
+#define FAT_IOCTL_GET_ATTRIBUTES        _IOR('r', 0x10, __u32)
+#define FAT_IOCTL_SET_ATTRIBUTES        _IOW('r', 0x11, __u32)
+
+/*
+ * vfat shortname flags
+ */
+#define VFAT_SFN_DISPLAY_LOWER  0x0001 /* convert to lowercase for display */
+#define VFAT_SFN_DISPLAY_WIN95  0x0002 /* emulate win95 rule for display */
+#define VFAT_SFN_DISPLAY_WINNT  0x0004 /* emulate winnt rule for display */
+#define VFAT_SFN_CREATE_WIN95   0x0100 /* emulate win95 rule for create */
+#define VFAT_SFN_CREATE_WINNT   0x0200 /* emulate winnt rule for create */
+
+struct fat_boot_sector {
+        __u8    ignored[3];     /* Boot strap short or near jump */
+        __u8    system_id[8];   /* Name - can be used to special case
+                                   partition manager volumes */
+        __u8    sector_size[2]; /* bytes per logical sector */
+        __u8    sec_per_clus;   /* sectors/cluster */
+        __le16  reserved;       /* reserved sectors */
+        __u8    fats;           /* number of FATs */
+        __u8    dir_entries[2]; /* root directory entries */
+        __u8    sectors[2];     /* number of sectors */
+        __u8    media;          /* media code */
+        __le16  fat_length;     /* sectors/FAT */
+        __le16  secs_track;     /* sectors per track */
+        __le16  heads;          /* number of heads */
+        __le32  hidden;         /* hidden sectors (unused) */
+        __le32  total_sect;     /* number of sectors (if sectors == 0) */
+
+        /* The following fields are only used by FAT32 */
+        __le32  fat32_length;   /* sectors/FAT */
+        __le16  flags;          /* bit 8: fat mirroring, low 4: active fat */
+        __u8    version[2];     /* major, minor filesystem version */
+        __le32  root_cluster;   /* first cluster in root directory */
+        __le16  info_sector;    /* filesystem info sector */
+        __le16  backup_boot;    /* backup boot sector */
+        __le16  reserved2[6];   /* Unused */
+};
+
+struct fat_boot_fsinfo {
+        __le32   signature1;    /* 0x41615252L */
+        __le32   reserved1[120];        /* Nothing as far as I can tell */
+        __le32   signature2;    /* 0x61417272L */
+        __le32   free_clusters; /* Free cluster count.  -1 if unknown */
+        __le32   next_cluster;  /* Most recently allocated cluster */
+        __le32   reserved2[4];
+};
+
+struct msdos_dir_entry {
+        __u8    name[8],ext[3]; /* name and extension */
+        __u8    attr;           /* attribute bits */
+        __u8    lcase;          /* Case for base and extension */
+        __u8    ctime_cs;       /* Creation time, centiseconds (0-199) */
+        __le16  ctime;          /* Creation time */
+        __le16  cdate;          /* Creation date */
+        __le16  adate;          /* Last access date */
+        __le16  starthi;        /* High 16 bits of cluster in FAT32 */
+        __le16  time,date,start;/* time, date and first cluster */
+        __le32  size;           /* file size (in bytes) */
+};
+
+/* Up to 13 characters of the name */
+struct msdos_dir_slot {
+        __u8    id;             /* sequence number for slot */
+        __u8    name0_4[10];    /* first 5 characters in name */
+        __u8    attr;           /* attribute byte */
+        __u8    reserved;       /* always 0 */
+        __u8    alias_checksum; /* checksum for 8.3 alias */
+        __u8    name5_10[12];   /* 6 more characters in name */
+        __le16   start;         /* starting cluster number, 0 in long slots */
+        __u8    name11_12[4];   /* last 2 characters in name */
+};
+
+struct fat_slot_info {
+        loff_t i_pos;           /* on-disk position of directory entry */
+        loff_t slot_off;        /* offset for slot or de start */
+        int nr_slots;           /* number of slots + 1(de) in filename */
+        struct msdos_dir_entry *de;
+        struct buffer_head *bh;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/buffer_head.h>
+#include <linux/string.h>
+#include <linux/nls.h>
+#include <linux/fs.h>
+
+struct fat_mount_options {
+        uid_t fs_uid;
+        gid_t fs_gid;
+        unsigned short fs_fmask;
+        unsigned short fs_dmask;
+        unsigned short codepage;  /* Codepage for shortname conversions */
+        char *iocharset;          /* Charset used for filename input/display */
+        unsigned short shortname; /* flags for shortname display/create rule */
+        unsigned char name_check; /* r = relaxed, n = normal, s = strict */
+        unsigned quiet:1,         /* set = fake successful chmods and chowns */
+                 showexec:1,      /* set = only set x bit for com/exe/bat */
+                 sys_immutable:1, /* set = system files are immutable */
+                 dotsOK:1,        /* set = hidden and system files are named '.filename' */
+                 isvfat:1,        /* 0=no vfat long filename support, 1=vfat support */
+                 utf8:1,          /* Use of UTF8 character set (Default) */
+                 unicode_xlate:1, /* create escape sequences for unhandled Unicode */
+                 numtail:1,       /* Does first alias have a numeric '~1' type tail? */
+                 atari:1,         /* Use Atari GEMDOS variation of MS-DOS fs */
+                 nocase:1;        /* Does this need case conversion? 0=need case conversion*/
+};
+
+#define FAT_HASH_BITS   8
+#define FAT_HASH_SIZE   (1UL << FAT_HASH_BITS)
+#define FAT_HASH_MASK   (FAT_HASH_SIZE-1)
+
+/*
+ * MS-DOS file system in-core superblock data
+ */
+struct msdos_sb_info {
+        unsigned short sec_per_clus; /* sectors/cluster */
+        unsigned short cluster_bits; /* log2(cluster_size) */
+        unsigned int cluster_size;   /* cluster size */
+        unsigned char fats,fat_bits; /* number of FATs, FAT bits (12 or 16) */
+        unsigned short fat_start;
+        unsigned long fat_length;    /* FAT start & length (sec.) */
+        unsigned long dir_start;
+        unsigned short dir_entries;  /* root dir start & entries */
+        unsigned long data_start;    /* first data sector */
+        unsigned long max_cluster;   /* maximum cluster number */
+        unsigned long root_cluster;  /* first cluster of the root directory */
+        unsigned long fsinfo_sector; /* sector number of FAT32 fsinfo */
+        struct semaphore fat_lock;
+        unsigned int prev_free;      /* previously allocated cluster number */
+        unsigned int free_clusters;  /* -1 if undefined */
+        struct fat_mount_options options;
+        struct nls_table *nls_disk;  /* Codepage used on disk */
+        struct nls_table *nls_io;    /* Charset used for input and display */
+        void *dir_ops;               /* Opaque; default directory operations */
+        int dir_per_block;           /* dir entries per block */
+        int dir_per_block_bits;      /* log2(dir_per_block) */
+
+        int fatent_shift;
+        struct fatent_operations *fatent_ops;
+
+        spinlock_t inode_hash_lock;
+        struct hlist_head inode_hashtable[FAT_HASH_SIZE];
+};
+
+#define FAT_CACHE_VALID 0       /* special case for valid cache */
+
+/*
+ * MS-DOS file system inode data in memory
+ */
+struct msdos_inode_info {
+        spinlock_t cache_lru_lock;
+        struct list_head cache_lru;
+        int nr_caches;
+        /* for avoiding the race between fat_free() and fat_get_cluster() */
+        unsigned int cache_valid_id;
+
+        loff_t mmu_private;
+        int i_start;            /* first cluster or 0 */
+        int i_logstart;         /* logical first cluster */
+        int i_attrs;            /* unused attribute bits */
+        loff_t i_pos;           /* on-disk position of directory entry or 0 */
+        struct hlist_node i_fat_hash;   /* hash by i_location */
+        struct inode vfs_inode;
+};
+
+static inline struct msdos_sb_info *MSDOS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct msdos_inode_info *MSDOS_I(struct inode *inode)
+{
+        return container_of(inode, struct msdos_inode_info, vfs_inode);
+}
+
+/* Return the FAT attribute byte for this inode */
+static inline u8 fat_attr(struct inode *inode)
+{
+        return ((inode->i_mode & S_IWUGO) ? ATTR_NONE : ATTR_RO) |
+                (S_ISDIR(inode->i_mode) ? ATTR_DIR : ATTR_NONE) |
+                MSDOS_I(inode)->i_attrs;
+}
+
+static inline sector_t fat_clus_to_blknr(struct msdos_sb_info *sbi, int clus)
+{
+        return ((sector_t)clus - FAT_START_ENT) * sbi->sec_per_clus
+                + sbi->data_start;
+}
+
+static inline void fat16_towchar(wchar_t *dst, const __u8 *src, size_t len)
+{
+#ifdef __BIG_ENDIAN
+        while (len--) {
+                *dst++ = src[0] | (src[1] << 8);
+                src += 2;
+        }
+#else
+        memcpy(dst, src, len * 2);
+#endif
+}
+
+static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)
+{
+#ifdef __BIG_ENDIAN
+        while (len--) {
+                dst[0] = *src & 0x00FF;
+                dst[1] = (*src & 0xFF00) >> 8;
+                dst += 2;
+                src++;
+        }
+#else
+        memcpy(dst, src, len * 2);
+#endif
+}
+
+/* fat/cache.c */
+extern void fat_cache_inval_inode(struct inode *inode);
+extern int fat_get_cluster(struct inode *inode, int cluster,
+                           int *fclus, int *dclus);
+extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys);
+
+/* fat/dir.c */
+extern struct file_operations fat_dir_operations;
+extern int fat_search_long(struct inode *inode, const unsigned char *name,
+                           int name_len, struct fat_slot_info *sinfo);
+extern int fat_dir_empty(struct inode *dir);
+extern int fat_subdirs(struct inode *dir);
+extern int fat_scan(struct inode *dir, const unsigned char *name,
+                    struct fat_slot_info *sinfo);
+extern int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
+                                struct msdos_dir_entry **de, loff_t *i_pos);
+extern int fat_alloc_new_dir(struct inode *dir, struct timespec *ts);
+extern int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
+                           struct fat_slot_info *sinfo);
+extern int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo);
+
+/* fat/fatent.c */
+struct fat_entry {
+        int entry;
+        union {
+                u8 *ent12_p[2];
+                __le16 *ent16_p;
+                __le32 *ent32_p;
+        } u;
+        int nr_bhs;
+        struct buffer_head *bhs[2];
+};
+
+static inline void fatent_init(struct fat_entry *fatent)
+{
+        fatent->nr_bhs = 0;
+        fatent->entry = 0;
+        fatent->u.ent32_p = NULL;
+        fatent->bhs[0] = fatent->bhs[1] = NULL;
+}
+
+static inline void fatent_set_entry(struct fat_entry *fatent, int entry)
+{
+        fatent->entry = entry;
+        fatent->u.ent32_p = NULL;
+}
+
+static inline void fatent_brelse(struct fat_entry *fatent)
+{
+        int i;
+        fatent->u.ent32_p = NULL;
+        for (i = 0; i < fatent->nr_bhs; i++)
+                brelse(fatent->bhs[i]);
+        fatent->nr_bhs = 0;
+        fatent->bhs[0] = fatent->bhs[1] = NULL;
+}
+
+extern void fat_ent_access_init(struct super_block *sb);
+extern int fat_ent_read(struct inode *inode, struct fat_entry *fatent,
+                        int entry);
+extern int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
+                         int new, int wait);
+extern int fat_alloc_clusters(struct inode *inode, int *cluster,
+                              int nr_cluster);
+extern int fat_free_clusters(struct inode *inode, int cluster);
+extern int fat_count_free_clusters(struct super_block *sb);
+
+/* fat/file.c */
+extern int fat_generic_ioctl(struct inode *inode, struct file *filp,
+                             unsigned int cmd, unsigned long arg);
+extern struct file_operations fat_file_operations;
+extern struct inode_operations fat_file_inode_operations;
+extern int fat_notify_change(struct dentry * dentry, struct iattr * attr);
+extern void fat_truncate(struct inode *inode);
+
+/* fat/inode.c */
+extern void fat_attach(struct inode *inode, loff_t i_pos);
+extern void fat_detach(struct inode *inode);
+extern struct inode *fat_iget(struct super_block *sb, loff_t i_pos);
+extern struct inode *fat_build_inode(struct super_block *sb,
+                        struct msdos_dir_entry *de, loff_t i_pos);
+extern int fat_sync_inode(struct inode *inode);
+extern int fat_fill_super(struct super_block *sb, void *data, int silent,
+                        struct inode_operations *fs_dir_inode_ops, int isvfat);
+
+/* fat/misc.c */
+extern void fat_fs_panic(struct super_block *s, const char *fmt, ...);
+extern void fat_clusters_flush(struct super_block *sb);
+extern int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster);
+extern int date_dos2unix(unsigned short time, unsigned short date);
+extern void fat_date_unix2dos(int unix_date, __le16 *time, __le16 *date);
+extern int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs);
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/msg.h b/include/linux/msg.h
new file mode 100644
index 000000000000..2c4c6aa643ff
--- /dev/null
+++ b/include/linux/msg.h
@@ -0,0 +1,96 @@
+#ifndef _LINUX_MSG_H
+#define _LINUX_MSG_H
+
+#include <linux/ipc.h>
+#include <linux/list.h>
+
+/* ipcs ctl commands */
+#define MSG_STAT 11
+#define MSG_INFO 12
+
+/* msgrcv options */
+#define MSG_NOERROR     010000  /* no error if message is too big */
+#define MSG_EXCEPT      020000  /* recv any msg except of specified type.*/
+
+/* Obsolete, used only for backwards compatibility and libc5 compiles */
+struct msqid_ds {
+        struct ipc_perm msg_perm;
+        struct msg *msg_first;          /* first message on queue,unused  */
+        struct msg *msg_last;           /* last message in queue,unused */
+        __kernel_time_t msg_stime;      /* last msgsnd time */
+        __kernel_time_t msg_rtime;      /* last msgrcv time */
+        __kernel_time_t msg_ctime;      /* last change time */
+        unsigned long  msg_lcbytes;     /* Reuse junk fields for 32 bit */
+        unsigned long  msg_lqbytes;     /* ditto */
+        unsigned short msg_cbytes;      /* current number of bytes on queue */
+        unsigned short msg_qnum;        /* number of messages in queue */
+        unsigned short msg_qbytes;      /* max number of bytes on queue */
+        __kernel_ipc_pid_t msg_lspid;   /* pid of last msgsnd */
+        __kernel_ipc_pid_t msg_lrpid;   /* last receive pid */
+};
+
+/* Include the definition of msqid64_ds */
+#include <asm/msgbuf.h>
+
+/* message buffer for msgsnd and msgrcv calls */
+struct msgbuf {
+        long mtype;         /* type of message */
+        char mtext[1];      /* message text */
+};
+
+/* buffer for msgctl calls IPC_INFO, MSG_INFO */
+struct msginfo {
+        int msgpool;
+        int msgmap; 
+        int msgmax; 
+        int msgmnb; 
+        int msgmni; 
+        int msgssz; 
+        int msgtql; 
+        unsigned short  msgseg; 
+};
+
+#define MSGMNI    16   /* <= IPCMNI */     /* max # of msg queue identifiers */
+#define MSGMAX  8192   /* <= INT_MAX */   /* max size of message (bytes) */
+#define MSGMNB 16384   /* <= INT_MAX */   /* default max size of a message queue */
+
+/* unused */
+#define MSGPOOL (MSGMNI*MSGMNB/1024)  /* size in kilobytes of message pool */
+#define MSGTQL  MSGMNB            /* number of system message headers */
+#define MSGMAP  MSGMNB            /* number of entries in message map */
+#define MSGSSZ  16                /* message segment size */
+#define __MSGSEG ((MSGPOOL*1024)/ MSGSSZ) /* max no. of segments */
+#define MSGSEG (__MSGSEG <= 0xffff ? __MSGSEG : 0xffff)
+
+#ifdef __KERNEL__
+
+/* one msg_msg structure for each message */
+struct msg_msg {
+        struct list_head m_list; 
+        long  m_type;          
+        int m_ts;           /* message text size */
+        struct msg_msgseg* next;
+        void *security;
+        /* the actual message follows immediately */
+};
+
+/* one msq_queue structure for each present queue on the system */
+struct msg_queue {
+        struct kern_ipc_perm q_perm;
+        time_t q_stime;                 /* last msgsnd time */
+        time_t q_rtime;                 /* last msgrcv time */
+        time_t q_ctime;                 /* last change time */
+        unsigned long q_cbytes;         /* current number of bytes on queue */
+        unsigned long q_qnum;           /* number of messages in queue */
+        unsigned long q_qbytes;         /* max number of bytes on queue */
+        pid_t q_lspid;                  /* pid of last msgsnd */
+        pid_t q_lrpid;                  /* last receive pid */
+
+        struct list_head q_messages;
+        struct list_head q_receivers;
+        struct list_head q_senders;
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_MSG_H */
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
new file mode 100644
index 000000000000..4ebc2e5a16e2
--- /dev/null
+++ b/include/linux/mtd/blktrans.h
@@ -0,0 +1,72 @@
+/*
+ * $Id: blktrans.h,v 1.5 2003/06/23 12:00:08 dwmw2 Exp $
+ *
+ * (C) 2003 David Woodhouse <dwmw2@infradead.org>
+ *
+ * Interface to Linux block layer for MTD 'translation layers'.
+ *
+ */
+
+#ifndef __MTD_TRANS_H__
+#define __MTD_TRANS_H__
+
+#include <asm/semaphore.h>
+
+struct hd_geometry;
+struct mtd_info;
+struct mtd_blktrans_ops;
+struct file;
+struct inode;
+
+struct mtd_blktrans_dev {
+        struct mtd_blktrans_ops *tr;
+        struct list_head list;
+        struct mtd_info *mtd;
+        struct semaphore sem;
+        int devnum;
+        int blksize;
+        unsigned long size;
+        int readonly;
+        void *blkcore_priv; /* gendisk in 2.5, devfs_handle in 2.4 */
+};
+
+struct blkcore_priv; /* Differs for 2.4 and 2.5 kernels; private */
+
+struct mtd_blktrans_ops {
+        char *name;
+        int major;
+        int part_bits;
+
+        /* Access functions */
+        int (*readsect)(struct mtd_blktrans_dev *dev,
+                    unsigned long block, char *buffer);
+        int (*writesect)(struct mtd_blktrans_dev *dev,
+                     unsigned long block, char *buffer);
+
+        /* Block layer ioctls */
+        int (*getgeo)(struct mtd_blktrans_dev *dev, struct hd_geometry *geo);
+        int (*flush)(struct mtd_blktrans_dev *dev);
+
+        /* Called with mtd_table_mutex held; no race with add/remove */
+        int (*open)(struct mtd_blktrans_dev *dev);
+        int (*release)(struct mtd_blktrans_dev *dev);
+
+        /* Called on {de,}registration and on subsequent addition/removal
+           of devices, with mtd_table_mutex held. */
+        void (*add_mtd)(struct mtd_blktrans_ops *tr, struct mtd_info *mtd);
+        void (*remove_dev)(struct mtd_blktrans_dev *dev);
+
+        struct list_head devs;
+        struct list_head list;
+        struct module *owner;
+
+        struct mtd_blkcore_priv *blkcore_priv;
+};
+
+extern int register_mtd_blktrans(struct mtd_blktrans_ops *tr);
+extern int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr);
+extern int add_mtd_blktrans_dev(struct mtd_blktrans_dev *dev);
+extern int del_mtd_blktrans_dev(struct mtd_blktrans_dev *dev);
+                                 
+
+#endif /* __MTD_TRANS_H__ */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
new file mode 100644
index 000000000000..2ed8c585021e
--- /dev/null
+++ b/include/linux/mtd/cfi.h
@@ -0,0 +1,394 @@
+
+/* Common Flash Interface structures 
+ * See http://support.intel.com/design/flash/technote/index.htm
+ * $Id: cfi.h,v 1.50 2004/11/20 12:46:51 dwmw2 Exp $
+ */
+
+#ifndef __MTD_CFI_H__
+#define __MTD_CFI_H__
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/delay.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/mtd/flashchip.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/cfi_endian.h>
+
+#ifdef CONFIG_MTD_CFI_I1
+#define cfi_interleave(cfi) 1
+#define cfi_interleave_is_1(cfi) (cfi_interleave(cfi) == 1)
+#else
+#define cfi_interleave_is_1(cfi) (0)
+#endif
+
+#ifdef CONFIG_MTD_CFI_I2
+# ifdef cfi_interleave
+#  undef cfi_interleave
+#  define cfi_interleave(cfi) ((cfi)->interleave)
+# else
+#  define cfi_interleave(cfi) 2
+# endif
+#define cfi_interleave_is_2(cfi) (cfi_interleave(cfi) == 2)
+#else
+#define cfi_interleave_is_2(cfi) (0)
+#endif
+
+#ifdef CONFIG_MTD_CFI_I4
+# ifdef cfi_interleave
+#  undef cfi_interleave
+#  define cfi_interleave(cfi) ((cfi)->interleave)
+# else
+#  define cfi_interleave(cfi) 4
+# endif
+#define cfi_interleave_is_4(cfi) (cfi_interleave(cfi) == 4)
+#else
+#define cfi_interleave_is_4(cfi) (0)
+#endif
+
+#ifdef CONFIG_MTD_CFI_I8
+# ifdef cfi_interleave
+#  undef cfi_interleave
+#  define cfi_interleave(cfi) ((cfi)->interleave)
+# else
+#  define cfi_interleave(cfi) 8
+# endif
+#define cfi_interleave_is_8(cfi) (cfi_interleave(cfi) == 8)
+#else
+#define cfi_interleave_is_8(cfi) (0)
+#endif
+
+static inline int cfi_interleave_supported(int i)
+{
+        switch (i) {
+#ifdef CONFIG_MTD_CFI_I1
+        case 1:
+#endif
+#ifdef CONFIG_MTD_CFI_I2
+        case 2:
+#endif
+#ifdef CONFIG_MTD_CFI_I4
+        case 4:
+#endif
+#ifdef CONFIG_MTD_CFI_I8
+        case 8:
+#endif
+                return 1;
+
+        default:
+                return 0;
+        }
+}
+
+
+/* NB: these values must represents the number of bytes needed to meet the 
+ *     device type (x8, x16, x32).  Eg. a 32 bit device is 4 x 8 bytes. 
+ *     These numbers are used in calculations.
+ */
+#define CFI_DEVICETYPE_X8  (8 / 8)
+#define CFI_DEVICETYPE_X16 (16 / 8)
+#define CFI_DEVICETYPE_X32 (32 / 8)
+#define CFI_DEVICETYPE_X64 (64 / 8)
+
+/* NB: We keep these structures in memory in HOST byteorder, except
+ * where individually noted.
+ */
+
+/* Basic Query Structure */
+struct cfi_ident {
+        uint8_t  qry[3];
+        uint16_t P_ID;
+        uint16_t P_ADR;
+        uint16_t A_ID;
+        uint16_t A_ADR;
+        uint8_t  VccMin;
+        uint8_t  VccMax;
+        uint8_t  VppMin;
+        uint8_t  VppMax;
+        uint8_t  WordWriteTimeoutTyp;
+        uint8_t  BufWriteTimeoutTyp;
+        uint8_t  BlockEraseTimeoutTyp;
+        uint8_t  ChipEraseTimeoutTyp;
+        uint8_t  WordWriteTimeoutMax;
+        uint8_t  BufWriteTimeoutMax;
+        uint8_t  BlockEraseTimeoutMax;
+        uint8_t  ChipEraseTimeoutMax;
+        uint8_t  DevSize;
+        uint16_t InterfaceDesc;
+        uint16_t MaxBufWriteSize;
+        uint8_t  NumEraseRegions;
+        uint32_t EraseRegionInfo[0]; /* Not host ordered */
+} __attribute__((packed));
+
+/* Extended Query Structure for both PRI and ALT */
+
+struct cfi_extquery {
+        uint8_t  pri[3];
+        uint8_t  MajorVersion;
+        uint8_t  MinorVersion;
+} __attribute__((packed));
+
+/* Vendor-Specific PRI for Intel/Sharp Extended Command Set (0x0001) */
+
+struct cfi_pri_intelext {
+        uint8_t  pri[3];
+        uint8_t  MajorVersion;
+        uint8_t  MinorVersion;
+        uint32_t FeatureSupport; /* if bit 31 is set then an additional uint32_t feature
+                                    block follows - FIXME - not currently supported */
+        uint8_t  SuspendCmdSupport;
+        uint16_t BlkStatusRegMask;
+        uint8_t  VccOptimal;
+        uint8_t  VppOptimal;
+        uint8_t  NumProtectionFields;
+        uint16_t ProtRegAddr;
+        uint8_t  FactProtRegSize;
+        uint8_t  UserProtRegSize;
+        uint8_t  extra[0];
+} __attribute__((packed));
+
+struct cfi_intelext_blockinfo {
+        uint16_t NumIdentBlocks;
+        uint16_t BlockSize;
+        uint16_t MinBlockEraseCycles;
+        uint8_t  BitsPerCell;
+        uint8_t  BlockCap;
+} __attribute__((packed));
+
+struct cfi_intelext_regioninfo {
+        uint16_t NumIdentPartitions;
+        uint8_t  NumOpAllowed;
+        uint8_t  NumOpAllowedSimProgMode;
+        uint8_t  NumOpAllowedSimEraMode;
+        uint8_t  NumBlockTypes;
+        struct cfi_intelext_blockinfo BlockTypes[1];
+} __attribute__((packed));
+
+/* Vendor-Specific PRI for AMD/Fujitsu Extended Command Set (0x0002) */
+
+struct cfi_pri_amdstd {
+        uint8_t  pri[3];
+        uint8_t  MajorVersion;
+        uint8_t  MinorVersion;
+        uint8_t  SiliconRevision; /* bits 1-0: Address Sensitive Unlock */
+        uint8_t  EraseSuspend;
+        uint8_t  BlkProt;
+        uint8_t  TmpBlkUnprotect;
+        uint8_t  BlkProtUnprot;
+        uint8_t  SimultaneousOps;
+        uint8_t  BurstMode;
+        uint8_t  PageMode;
+        uint8_t  VppMin;
+        uint8_t  VppMax;
+        uint8_t  TopBottom;
+} __attribute__((packed));
+
+struct cfi_pri_query {
+        uint8_t  NumFields;
+        uint32_t ProtField[1]; /* Not host ordered */
+} __attribute__((packed));
+
+struct cfi_bri_query {
+        uint8_t  PageModeReadCap;
+        uint8_t  NumFields;
+        uint32_t ConfField[1]; /* Not host ordered */
+} __attribute__((packed));
+
+#define P_ID_NONE               0x0000
+#define P_ID_INTEL_EXT          0x0001
+#define P_ID_AMD_STD            0x0002
+#define P_ID_INTEL_STD          0x0003
+#define P_ID_AMD_EXT            0x0004
+#define P_ID_WINBOND            0x0006
+#define P_ID_ST_ADV             0x0020
+#define P_ID_MITSUBISHI_STD     0x0100
+#define P_ID_MITSUBISHI_EXT     0x0101
+#define P_ID_SST_PAGE           0x0102
+#define P_ID_INTEL_PERFORMANCE  0x0200
+#define P_ID_INTEL_DATA         0x0210
+#define P_ID_RESERVED           0xffff
+
+
+#define CFI_MODE_CFI    1
+#define CFI_MODE_JEDEC  0
+
+struct cfi_private {
+        uint16_t cmdset;
+        void *cmdset_priv;
+        int interleave;
+        int device_type;
+        int cfi_mode;           /* Are we a JEDEC device pretending to be CFI? */
+        int addr_unlock1;
+        int addr_unlock2;
+        struct mtd_info *(*cmdset_setup)(struct map_info *);
+        struct cfi_ident *cfiq; /* For now only one. We insist that all devs
+                                  must be of the same type. */
+        int mfr, id;
+        int numchips;
+        unsigned long chipshift; /* Because they're of the same type */
+        const char *im_name;     /* inter_module name for cmdset_setup */
+        struct flchip chips[0];  /* per-chip data structure for each chip */
+};
+
+/*
+ * Returns the command address according to the given geometry.
+ */
+static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs, int interleave, int type)
+{
+        return (cmd_ofs * type) * interleave;
+}
+
+/*
+ * Transforms the CFI command for the given geometry (bus width & interleave).
+ * It looks too long to be inline, but in the common case it should almost all
+ * get optimised away. 
+ */
+static inline map_word cfi_build_cmd(u_char cmd, struct map_info *map, struct cfi_private *cfi)
+{
+        map_word val = { {0} };
+        int wordwidth, words_per_bus, chip_mode, chips_per_word;
+        unsigned long onecmd;
+        int i;
+
+        /* We do it this way to give the compiler a fighting chance 
+           of optimising away all the crap for 'bankwidth' larger than
+           an unsigned long, in the common case where that support is
+           disabled */
+        if (map_bankwidth_is_large(map)) {
+                wordwidth = sizeof(unsigned long);
+                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
+        } else {
+                wordwidth = map_bankwidth(map);
+                words_per_bus = 1;
+        }
+        
+        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
+        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
+
+        /* First, determine what the bit-pattern should be for a single
+           device, according to chip mode and endianness... */
+        switch (chip_mode) {
+        default: BUG();
+        case 1:
+                onecmd = cmd;
+                break;
+        case 2:
+                onecmd = cpu_to_cfi16(cmd);
+                break;
+        case 4:
+                onecmd = cpu_to_cfi32(cmd);
+                break;
+        }
+
+        /* Now replicate it across the size of an unsigned long, or 
+           just to the bus width as appropriate */
+        switch (chips_per_word) {
+        default: BUG();
+#if BITS_PER_LONG >= 64
+        case 8:
+                onecmd |= (onecmd << (chip_mode * 32));
+#endif
+        case 4:
+                onecmd |= (onecmd << (chip_mode * 16));
+        case 2:
+                onecmd |= (onecmd << (chip_mode * 8));
+        case 1:
+                ;
+        }
+
+        /* And finally, for the multi-word case, replicate it 
+           in all words in the structure */
+        for (i=0; i < words_per_bus; i++) {
+                val.x[i] = onecmd;
+        }
+
+        return val;
+}
+#define CMD(x)  cfi_build_cmd((x), map, cfi)
+
+/*
+ * Sends a CFI command to a bank of flash for the given geometry.
+ *
+ * Returns the offset in flash where the command was written.
+ * If prev_val is non-null, it will be set to the value at the command address,
+ * before the command was written.
+ */
+static inline uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
+                                struct map_info *map, struct cfi_private *cfi,
+                                int type, map_word *prev_val)
+{
+        map_word val;
+        uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, cfi_interleave(cfi), type);
+
+        val = cfi_build_cmd(cmd, map, cfi);
+
+        if (prev_val)
+                *prev_val = map_read(map, addr);
+
+        map_write(map, val, addr);
+
+        return addr - base;
+}
+
+static inline uint8_t cfi_read_query(struct map_info *map, uint32_t addr)
+{
+        map_word val = map_read(map, addr);
+
+        if (map_bankwidth_is_1(map)) {
+                return val.x[0];
+        } else if (map_bankwidth_is_2(map)) {
+                return cfi16_to_cpu(val.x[0]);
+        } else {
+                /* No point in a 64-bit byteswap since that would just be
+                   swapping the responses from different chips, and we are
+                   only interested in one chip (a representative sample) */
+                return cfi32_to_cpu(val.x[0]);
+        }
+}
+
+static inline void cfi_udelay(int us)
+{
+        if (us >= 1000) {
+                msleep((us+999)/1000);
+        } else {
+                udelay(us);
+                cond_resched();
+        }
+}
+
+static inline void cfi_spin_lock(spinlock_t *mutex)
+{
+        spin_lock_bh(mutex);
+}
+
+static inline void cfi_spin_unlock(spinlock_t *mutex)
+{
+        spin_unlock_bh(mutex);
+}
+
+struct cfi_extquery *cfi_read_pri(struct map_info *map, uint16_t adr, uint16_t size,
+                             const char* name);
+struct cfi_fixup {
+        uint16_t mfr;
+        uint16_t id;
+        void (*fixup)(struct mtd_info *mtd, void* param);
+        void* param;
+};
+
+#define CFI_MFR_ANY 0xffff
+#define CFI_ID_ANY  0xffff
+
+#define CFI_MFR_AMD 0x0001
+#define CFI_MFR_ST  0x0020      /* STMicroelectronics */
+
+void cfi_fixup(struct mtd_info *mtd, struct cfi_fixup* fixups);
+
+typedef int (*varsize_frob_t)(struct map_info *map, struct flchip *chip,
+                              unsigned long adr, int len, void *thunk);
+
+int cfi_varsize_frob(struct mtd_info *mtd, varsize_frob_t frob,
+        loff_t ofs, size_t len, void *thunk);
+
+
+#endif /* __MTD_CFI_H__ */
diff --git a/include/linux/mtd/cfi_endian.h b/include/linux/mtd/cfi_endian.h
new file mode 100644
index 000000000000..25724f7d3867
--- /dev/null
+++ b/include/linux/mtd/cfi_endian.h
@@ -0,0 +1,57 @@
+/*
+ * $Id: cfi_endian.h,v 1.11 2002/01/30 23:20:48 awozniak Exp $
+ *
+ */
+
+#include <asm/byteorder.h>
+
+#ifndef CONFIG_MTD_CFI_ADV_OPTIONS
+
+#define CFI_HOST_ENDIAN
+
+#else
+
+#ifdef CONFIG_MTD_CFI_NOSWAP
+#define CFI_HOST_ENDIAN
+#endif
+
+#ifdef CONFIG_MTD_CFI_LE_BYTE_SWAP
+#define CFI_LITTLE_ENDIAN
+#endif
+
+#ifdef CONFIG_MTD_CFI_BE_BYTE_SWAP
+#define CFI_BIG_ENDIAN
+#endif
+
+#endif
+
+#if defined(CFI_LITTLE_ENDIAN)
+#define cpu_to_cfi8(x) (x)
+#define cfi8_to_cpu(x) (x)
+#define cpu_to_cfi16(x) cpu_to_le16(x)
+#define cpu_to_cfi32(x) cpu_to_le32(x)
+#define cpu_to_cfi64(x) cpu_to_le64(x)
+#define cfi16_to_cpu(x) le16_to_cpu(x)
+#define cfi32_to_cpu(x) le32_to_cpu(x)
+#define cfi64_to_cpu(x) le64_to_cpu(x)
+#elif defined (CFI_BIG_ENDIAN)
+#define cpu_to_cfi8(x) (x)
+#define cfi8_to_cpu(x) (x)
+#define cpu_to_cfi16(x) cpu_to_be16(x)
+#define cpu_to_cfi32(x) cpu_to_be32(x)
+#define cpu_to_cfi64(x) cpu_to_be64(x)
+#define cfi16_to_cpu(x) be16_to_cpu(x)
+#define cfi32_to_cpu(x) be32_to_cpu(x)
+#define cfi64_to_cpu(x) be64_to_cpu(x)
+#elif defined (CFI_HOST_ENDIAN)
+#define cpu_to_cfi8(x) (x)
+#define cfi8_to_cpu(x) (x)
+#define cpu_to_cfi16(x) (x)
+#define cpu_to_cfi32(x) (x)
+#define cpu_to_cfi64(x) (x)
+#define cfi16_to_cpu(x) (x)
+#define cfi32_to_cpu(x) (x)
+#define cfi64_to_cpu(x) (x)
+#else
+#error No CFI endianness defined
+#endif
diff --git a/include/linux/mtd/compatmac.h b/include/linux/mtd/compatmac.h
new file mode 100644
index 000000000000..7d1300d9bd51
--- /dev/null
+++ b/include/linux/mtd/compatmac.h
@@ -0,0 +1,10 @@
+
+#ifndef __LINUX_MTD_COMPATMAC_H__
+#define __LINUX_MTD_COMPATMAC_H__
+
+/* Nothing to see here. We write 2.5-compatible code and this
+   file makes it all OK in older kernels, but it's empty in _current_
+   kernels. Include guard just to make GCC ignore it in future inclusions
+   anyway... */
+
+#endif /* __LINUX_MTD_COMPATMAC_H__ */
diff --git a/include/linux/mtd/concat.h b/include/linux/mtd/concat.h
new file mode 100644
index 000000000000..ed8dc6755219
--- /dev/null
+++ b/include/linux/mtd/concat.h
@@ -0,0 +1,23 @@
+/*
+ * MTD device concatenation layer definitions
+ *
+ * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
+ *
+ * This code is GPL
+ *
+ * $Id: concat.h,v 1.1 2002/03/08 16:34:36 rkaiser Exp $
+ */
+
+#ifndef MTD_CONCAT_H
+#define MTD_CONCAT_H
+
+
+struct mtd_info *mtd_concat_create(
+    struct mtd_info *subdev[],  /* subdevices to concatenate */
+    int num_devs,               /* number of subdevices      */
+    char *name);                /* name for the new device   */
+
+void mtd_concat_destroy(struct mtd_info *mtd);
+
+#endif
+
diff --git a/include/linux/mtd/doc2000.h b/include/linux/mtd/doc2000.h
new file mode 100644
index 000000000000..953e64fb8ac5
--- /dev/null
+++ b/include/linux/mtd/doc2000.h
@@ -0,0 +1,195 @@
+/* 
+ * Linux driver for Disk-On-Chip devices
+ *
+ * Copyright (C) 1999 Machine Vision Holdings, Inc.   
+ * Copyright (C) 2001-2003 David Woodhouse <dwmw2@infradead.org>
+ * Copyright (C) 2002-2003 Greg Ungerer <gerg@snapgear.com>
+ * Copyright (C) 2002-2003 SnapGear Inc
+ *
+ * $Id: doc2000.h,v 1.24 2005/01/05 12:40:38 dwmw2 Exp $ 
+ *
+ * Released under GPL
+ */
+
+#ifndef __MTD_DOC2000_H__
+#define __MTD_DOC2000_H__
+
+#include <linux/mtd/mtd.h>
+#include <asm/semaphore.h>
+
+#define DoC_Sig1 0
+#define DoC_Sig2 1
+
+#define DoC_ChipID              0x1000
+#define DoC_DOCStatus           0x1001
+#define DoC_DOCControl          0x1002
+#define DoC_FloorSelect         0x1003
+#define DoC_CDSNControl         0x1004
+#define DoC_CDSNDeviceSelect    0x1005
+#define DoC_ECCConf             0x1006
+#define DoC_2k_ECCStatus        0x1007
+
+#define DoC_CDSNSlowIO          0x100d
+#define DoC_ECCSyndrome0        0x1010
+#define DoC_ECCSyndrome1        0x1011
+#define DoC_ECCSyndrome2        0x1012
+#define DoC_ECCSyndrome3        0x1013
+#define DoC_ECCSyndrome4        0x1014
+#define DoC_ECCSyndrome5        0x1015
+#define DoC_AliasResolution     0x101b
+#define DoC_ConfigInput         0x101c
+#define DoC_ReadPipeInit        0x101d
+#define DoC_WritePipeTerm       0x101e
+#define DoC_LastDataRead        0x101f
+#define DoC_NOP                 0x1020
+
+#define DoC_Mil_CDSN_IO         0x0800
+#define DoC_2k_CDSN_IO          0x1800
+
+#define DoC_Mplus_NOP                   0x1002
+#define DoC_Mplus_AliasResolution       0x1004
+#define DoC_Mplus_DOCControl            0x1006
+#define DoC_Mplus_AccessStatus          0x1008
+#define DoC_Mplus_DeviceSelect          0x1008
+#define DoC_Mplus_Configuration         0x100a
+#define DoC_Mplus_OutputControl         0x100c
+#define DoC_Mplus_FlashControl          0x1020
+#define DoC_Mplus_FlashSelect           0x1022
+#define DoC_Mplus_FlashCmd              0x1024
+#define DoC_Mplus_FlashAddress          0x1026
+#define DoC_Mplus_FlashData0            0x1028
+#define DoC_Mplus_FlashData1            0x1029
+#define DoC_Mplus_ReadPipeInit          0x102a
+#define DoC_Mplus_LastDataRead          0x102c
+#define DoC_Mplus_LastDataRead1         0x102d
+#define DoC_Mplus_WritePipeTerm         0x102e
+#define DoC_Mplus_ECCSyndrome0          0x1040
+#define DoC_Mplus_ECCSyndrome1          0x1041
+#define DoC_Mplus_ECCSyndrome2          0x1042
+#define DoC_Mplus_ECCSyndrome3          0x1043
+#define DoC_Mplus_ECCSyndrome4          0x1044
+#define DoC_Mplus_ECCSyndrome5          0x1045
+#define DoC_Mplus_ECCConf               0x1046
+#define DoC_Mplus_Toggle                0x1046
+#define DoC_Mplus_DownloadStatus        0x1074
+#define DoC_Mplus_CtrlConfirm           0x1076
+#define DoC_Mplus_Power                 0x1fff
+
+/* How to access the device? 
+ * On ARM, it'll be mmap'd directly with 32-bit wide accesses. 
+ * On PPC, it's mmap'd and 16-bit wide.
+ * Others use readb/writeb 
+ */
+#if defined(__arm__)
+#define ReadDOC_(adr, reg)      ((unsigned char)(*(volatile __u32 *)(((unsigned long)adr)+((reg)<<2))))
+#define WriteDOC_(d, adr, reg)  do{ *(volatile __u32 *)(((unsigned long)adr)+((reg)<<2)) = (__u32)d; wmb();} while(0)
+#define DOC_IOREMAP_LEN 0x8000
+#elif defined(__ppc__)
+#define ReadDOC_(adr, reg)      ((unsigned char)(*(volatile __u16 *)(((unsigned long)adr)+((reg)<<1))))
+#define WriteDOC_(d, adr, reg)  do{ *(volatile __u16 *)(((unsigned long)adr)+((reg)<<1)) = (__u16)d; wmb();} while(0)
+#define DOC_IOREMAP_LEN 0x4000
+#else
+#define ReadDOC_(adr, reg)      readb((void __iomem *)(adr) + (reg))
+#define WriteDOC_(d, adr, reg)  writeb(d, (void __iomem *)(adr) + (reg))
+#define DOC_IOREMAP_LEN 0x2000
+
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+#define USE_MEMCPY
+#endif
+
+/* These are provided to directly use the DoC_xxx defines */
+#define ReadDOC(adr, reg)      ReadDOC_(adr,DoC_##reg)
+#define WriteDOC(d, adr, reg)  WriteDOC_(d,adr,DoC_##reg)
+
+#define DOC_MODE_RESET          0
+#define DOC_MODE_NORMAL         1
+#define DOC_MODE_RESERVED1      2
+#define DOC_MODE_RESERVED2      3
+
+#define DOC_MODE_CLR_ERR        0x80
+#define DOC_MODE_RST_LAT        0x10
+#define DOC_MODE_BDECT          0x08
+#define DOC_MODE_MDWREN         0x04
+
+#define DOC_ChipID_Doc2k        0x20
+#define DOC_ChipID_Doc2kTSOP    0x21    /* internal number for MTD */
+#define DOC_ChipID_DocMil       0x30
+#define DOC_ChipID_DocMilPlus32 0x40
+#define DOC_ChipID_DocMilPlus16 0x41
+
+#define CDSN_CTRL_FR_B          0x80
+#define CDSN_CTRL_FR_B0         0x40
+#define CDSN_CTRL_FR_B1         0x80
+
+#define CDSN_CTRL_ECC_IO        0x20
+#define CDSN_CTRL_FLASH_IO      0x10
+#define CDSN_CTRL_WP            0x08
+#define CDSN_CTRL_ALE           0x04
+#define CDSN_CTRL_CLE           0x02
+#define CDSN_CTRL_CE            0x01
+
+#define DOC_ECC_RESET           0
+#define DOC_ECC_ERROR           0x80
+#define DOC_ECC_RW              0x20
+#define DOC_ECC__EN             0x08
+#define DOC_TOGGLE_BIT          0x04
+#define DOC_ECC_RESV            0x02
+#define DOC_ECC_IGNORE          0x01
+
+#define DOC_FLASH_CE            0x80
+#define DOC_FLASH_WP            0x40
+#define DOC_FLASH_BANK          0x02
+
+/* We have to also set the reserved bit 1 for enable */
+#define DOC_ECC_EN (DOC_ECC__EN | DOC_ECC_RESV)
+#define DOC_ECC_DIS (DOC_ECC_RESV)
+
+struct Nand {
+        char floor, chip;
+        unsigned long curadr;
+        unsigned char curmode;
+        /* Also some erase/write/pipeline info when we get that far */
+};
+
+#define MAX_FLOORS 4
+#define MAX_CHIPS 4
+
+#define MAX_FLOORS_MIL 1
+#define MAX_CHIPS_MIL 1
+
+#define MAX_FLOORS_MPLUS 2
+#define MAX_CHIPS_MPLUS 1
+
+#define ADDR_COLUMN 1
+#define ADDR_PAGE 2
+#define ADDR_COLUMN_PAGE 3
+
+struct DiskOnChip {
+        unsigned long physadr;
+        void __iomem *virtadr;
+        unsigned long totlen;
+        unsigned char ChipID; /* Type of DiskOnChip */
+        int ioreg;
+        
+        unsigned long mfr; /* Flash IDs - only one type of flash per device */
+        unsigned long id;
+        int chipshift;
+        char page256;
+        char pageadrlen;
+        char interleave; /* Internal interleaving - Millennium Plus style */
+        unsigned long erasesize;
+        
+        int curfloor;
+        int curchip;
+        
+        int numchips;
+        struct Nand *chips;
+        struct mtd_info *nextdoc;
+        struct semaphore lock;
+};
+
+int doc_decode_ecc(unsigned char sector[512], unsigned char ecc1[6]);
+
+#endif /* __MTD_DOC2000_H__ */
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
new file mode 100644
index 000000000000..c66ba812bf90
--- /dev/null
+++ b/include/linux/mtd/flashchip.h
@@ -0,0 +1,89 @@
+
+/* 
+ * struct flchip definition
+ * 
+ * Contains information about the location and state of a given flash device 
+ *
+ * (C) 2000 Red Hat. GPLd.
+ *
+ * $Id: flashchip.h,v 1.15 2004/11/05 22:41:06 nico Exp $
+ *
+ */
+
+#ifndef __MTD_FLASHCHIP_H__
+#define __MTD_FLASHCHIP_H__
+
+/* For spinlocks. sched.h includes spinlock.h from whichever directory it
+ * happens to be in - so we don't have to care whether we're on 2.2, which
+ * has asm/spinlock.h, or 2.4, which has linux/spinlock.h 
+ */
+#include <linux/sched.h>
+
+typedef enum { 
+        FL_READY,
+        FL_STATUS,
+        FL_CFI_QUERY,
+        FL_JEDEC_QUERY,
+        FL_ERASING,
+        FL_ERASE_SUSPENDING,
+        FL_ERASE_SUSPENDED,
+        FL_WRITING,
+        FL_WRITING_TO_BUFFER,
+        FL_WRITE_SUSPENDING,
+        FL_WRITE_SUSPENDED,
+        FL_PM_SUSPENDED,
+        FL_SYNCING,
+        FL_UNLOADING,
+        FL_LOCKING,
+        FL_UNLOCKING,
+        FL_POINT,
+        FL_XIP_WHILE_ERASING,
+        FL_XIP_WHILE_WRITING,
+        FL_UNKNOWN
+} flstate_t;
+
+
+
+/* NOTE: confusingly, this can be used to refer to more than one chip at a time, 
+   if they're interleaved.  This can even refer to individual partitions on
+   the same physical chip when present. */
+
+struct flchip {
+        unsigned long start; /* Offset within the map */
+        //      unsigned long len;
+        /* We omit len for now, because when we group them together
+           we insist that they're all of the same size, and the chip size
+           is held in the next level up. If we get more versatile later,
+           it'll make it a damn sight harder to find which chip we want from
+           a given offset, and we'll want to add the per-chip length field
+           back in.
+        */
+        int ref_point_counter;
+        flstate_t state;
+        flstate_t oldstate;
+
+        int write_suspended:1;
+        int erase_suspended:1;
+        unsigned long in_progress_block_addr;
+
+        spinlock_t *mutex;
+        spinlock_t _spinlock; /* We do it like this because sometimes they'll be shared. */
+        wait_queue_head_t wq; /* Wait on here when we're waiting for the chip
+                             to be ready */
+        int word_write_time;
+        int buffer_write_time;
+        int erase_time;
+
+        void *priv;
+};
+
+/* This is used to handle contention on write/erase operations
+   between partitions of the same physical chip. */
+struct flchip_shared {
+        spinlock_t lock;
+        struct flchip *writing;
+        struct flchip *erasing;
+};
+
+
+#endif /* __MTD_FLASHCHIP_H__ */
diff --git a/include/linux/mtd/ftl.h b/include/linux/mtd/ftl.h
new file mode 100644
index 000000000000..3678459b4535
--- /dev/null
+++ b/include/linux/mtd/ftl.h
@@ -0,0 +1,76 @@
+/*
+ * $Id: ftl.h,v 1.6 2003/01/24 13:20:04 dwmw2 Exp $
+ * 
+ * Derived from (and probably identical to):
+ * ftl.h 1.7 1999/10/25 20:23:17
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License
+ * at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and
+ * limitations under the License. 
+ *
+ * The initial developer of the original code is David A. Hinds
+ * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
+ * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License version 2 (the "GPL"), in
+ * which case the provisions of the GPL are applicable instead of the
+ * above.  If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use
+ * your version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice and
+ * other provisions required by the GPL.  If you do not delete the
+ * provisions above, a recipient may use your version of this file
+ * under either the MPL or the GPL.
+ */
+
+#ifndef _LINUX_FTL_H
+#define _LINUX_FTL_H
+
+typedef struct erase_unit_header_t {
+    u_int8_t    LinkTargetTuple[5];
+    u_int8_t    DataOrgTuple[10];
+    u_int8_t    NumTransferUnits;
+    u_int32_t   EraseCount;
+    u_int16_t   LogicalEUN;
+    u_int8_t    BlockSize;
+    u_int8_t    EraseUnitSize;
+    u_int16_t   FirstPhysicalEUN;
+    u_int16_t   NumEraseUnits;
+    u_int32_t   FormattedSize;
+    u_int32_t   FirstVMAddress;
+    u_int16_t   NumVMPages;
+    u_int8_t    Flags;
+    u_int8_t    Code;
+    u_int32_t   SerialNumber;
+    u_int32_t   AltEUHOffset;
+    u_int32_t   BAMOffset;
+    u_int8_t    Reserved[12];
+    u_int8_t    EndTuple[2];
+} erase_unit_header_t;
+
+/* Flags in erase_unit_header_t */
+#define HIDDEN_AREA             0x01
+#define REVERSE_POLARITY        0x02
+#define DOUBLE_BAI              0x04
+
+/* Definitions for block allocation information */
+
+#define BLOCK_FREE(b)           ((b) == 0xffffffff)
+#define BLOCK_DELETED(b)        (((b) == 0) || ((b) == 0xfffffffe))
+
+#define BLOCK_TYPE(b)           ((b) & 0x7f)
+#define BLOCK_ADDRESS(b)        ((b) & ~0x7f)
+#define BLOCK_NUMBER(b)         ((b) >> 9)
+#define BLOCK_CONTROL           0x30
+#define BLOCK_DATA              0x40
+#define BLOCK_REPLACEMENT       0x60
+#define BLOCK_BAD               0x70
+
+#endif /* _LINUX_FTL_H */
diff --git a/include/linux/mtd/gen_probe.h b/include/linux/mtd/gen_probe.h
new file mode 100644
index 000000000000..3d7bdec14f97
--- /dev/null
+++ b/include/linux/mtd/gen_probe.h
@@ -0,0 +1,23 @@
+/*
+ * (C) 2001, 2001 Red Hat, Inc.
+ * GPL'd
+ * $Id: gen_probe.h,v 1.3 2004/10/20 22:10:33 dwmw2 Exp $
+ */
+
+#ifndef __LINUX_MTD_GEN_PROBE_H__
+#define __LINUX_MTD_GEN_PROBE_H__
+
+#include <linux/mtd/flashchip.h>
+#include <linux/mtd/map.h> 
+#include <linux/mtd/cfi.h>
+#include <linux/bitops.h>
+
+struct chip_probe {
+        char *name;
+        int (*probe_chip)(struct map_info *map, __u32 base,
+                          unsigned long *chip_map, struct cfi_private *cfi);
+};
+
+struct mtd_info *mtd_do_chip_probe(struct map_info *map, struct chip_probe *cp);
+
+#endif /* __LINUX_MTD_GEN_PROBE_H__ */
diff --git a/include/linux/mtd/iflash.h b/include/linux/mtd/iflash.h
new file mode 100644
index 000000000000..9aa5b4f02666
--- /dev/null
+++ b/include/linux/mtd/iflash.h
@@ -0,0 +1,98 @@
+/* $Id: iflash.h,v 1.2 2000/11/13 18:01:54 dwmw2 Exp $ */
+
+#ifndef __MTD_IFLASH_H__
+#define __MTD_IFLASH_H__
+
+/* Extended CIS registers for Series 2 and 2+ cards */
+/* The registers are all offsets from 0x4000 */
+#define CISREG_CSR              0x0100
+#define CISREG_WP               0x0104
+#define CISREG_RDYBSY           0x0140
+
+/* Extended CIS registers for Series 2 cards */
+#define CISREG_SLEEP            0x0118
+#define CISREG_RDY_MASK         0x0120
+#define CISREG_RDY_STATUS       0x0130
+
+/* Extended CIS registers for Series 2+ cards */
+#define CISREG_VCR              0x010c
+
+/* Card Status Register */
+#define CSR_SRESET              0x20    /* Soft reset */
+#define CSR_CMWP                0x10    /* Common memory write protect */
+#define CSR_PWRDOWN             0x08    /* Power down status */
+#define CSR_CISWP               0x04    /* Common memory CIS WP */
+#define CSR_WP                  0x02    /* Mechanical write protect */
+#define CSR_READY               0x01    /* Ready/busy status */
+
+/* Write Protection Register */
+#define WP_BLKEN                0x04    /* Enable block locking */
+#define WP_CMWP                 0x02    /* Common memory write protect */
+#define WP_CISWP                0x01    /* Common memory CIS WP */
+
+/* Voltage Control Register */
+#define VCR_VCC_LEVEL           0x80    /* 0 = 5V, 1 = 3.3V */
+#define VCR_VPP_VALID           0x02    /* Vpp Valid */
+#define VCR_VPP_GEN             0x01    /* Integrated Vpp generator */
+
+/* Ready/Busy Mode Register */
+#define RDYBSY_RACK             0x02    /* Ready acknowledge */
+#define RDYBSY_MODE             0x01    /* 1 = high performance */
+
+#define LOW(x) ((x) & 0xff)
+
+/* 28F008SA-Compatible Command Set */
+#define IF_READ_ARRAY           0xffff
+#define IF_INTEL_ID             0x9090
+#define IF_READ_CSR             0x7070
+#define IF_CLEAR_CSR            0x5050
+#define IF_WRITE                0x4040
+#define IF_BLOCK_ERASE          0x2020
+#define IF_ERASE_SUSPEND        0xb0b0
+#define IF_CONFIRM              0xd0d0
+
+/* 28F016SA Performance Enhancement Commands */
+#define IF_READ_PAGE            0x7575
+#define IF_PAGE_SWAP            0x7272
+#define IF_SINGLE_LOAD          0x7474
+#define IF_SEQ_LOAD             0xe0e0
+#define IF_PAGE_WRITE           0x0c0c
+#define IF_RDY_MODE             0x9696
+#define IF_RDY_LEVEL            0x0101
+#define IF_RDY_PULSE_WRITE      0x0202
+#define IF_RDY_PULSE_ERASE      0x0303
+#define IF_RDY_DISABLE          0x0404
+#define IF_LOCK_BLOCK           0x7777
+#define IF_UPLOAD_STATUS        0x9797
+#define IF_READ_ESR             0x7171
+#define IF_ERASE_UNLOCKED       0xa7a7
+#define IF_SLEEP                0xf0f0
+#define IF_ABORT                0x8080
+#define IF_UPLOAD_DEVINFO       0x9999
+
+/* Definitions for Compatible Status Register */
+#define CSR_WR_READY            0x8080  /* Write state machine status */
+#define CSR_ERA_SUSPEND         0x4040  /* Erase suspend status */
+#define CSR_ERA_ERR             0x2020  /* Erase status */
+#define CSR_WR_ERR              0x1010  /* Data write status */
+#define CSR_VPP_LOW             0x0808  /* Vpp status */
+
+/* Definitions for Global Status Register */
+#define GSR_WR_READY            0x8080  /* Write state machine status */
+#define GSR_OP_SUSPEND          0x4040  /* Operation suspend status */
+#define GSR_OP_ERR              0x2020  /* Device operation status */
+#define GSR_SLEEP               0x1010  /* Device sleep status */
+#define GSR_QUEUE_FULL          0x0808  /* Queue status */
+#define GSR_PAGE_AVAIL          0x0404  /* Page buffer available status */
+#define GSR_PAGE_READY          0x0202  /* Page buffer status */
+#define GSR_PAGE_SELECT         0x0101  /* Page buffer select status */
+
+/* Definitions for Block Status Register */
+#define BSR_READY               0x8080  /* Block status */
+#define BSR_UNLOCK              0x4040  /* Block lock status */
+#define BSR_FAILED              0x2020  /* Block operation status */
+#define BSR_ABORTED             0x1010  /* Operation abort status */
+#define BSR_QUEUE_FULL          0x0808  /* Queue status */
+#define BSR_VPP_LOW             0x0404  /* Vpp status */
+
+#endif /* __MTD_IFLASH_H__ */
diff --git a/include/linux/mtd/inftl.h b/include/linux/mtd/inftl.h
new file mode 100644
index 000000000000..b52c8cbd235c
--- /dev/null
+++ b/include/linux/mtd/inftl.h
@@ -0,0 +1,57 @@
+/*
+ *      inftl.h -- defines to support the Inverse NAND Flash Translation Layer
+ *
+ *      (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
+ *
+ *      $Id: inftl.h,v 1.6 2004/06/30 14:49:00 dbrown Exp $
+ */
+
+#ifndef __MTD_INFTL_H__
+#define __MTD_INFTL_H__
+
+#ifndef __KERNEL__
+#error This is a kernel header. Perhaps include nftl-user.h instead?
+#endif
+
+#include <linux/mtd/blktrans.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nftl.h>
+
+#include <mtd/inftl-user.h>
+
+#ifndef INFTL_MAJOR
+#define INFTL_MAJOR 94
+#endif
+#define INFTL_PARTN_BITS 4
+
+#ifdef __KERNEL__
+
+struct INFTLrecord {
+        struct mtd_blktrans_dev mbd;
+        __u16 MediaUnit;
+        __u32 EraseSize;
+        struct INFTLMediaHeader MediaHdr;
+        int usecount;
+        unsigned char heads;
+        unsigned char sectors;
+        unsigned short cylinders;
+        __u16 numvunits;
+        __u16 firstEUN;
+        __u16 lastEUN;
+        __u16 numfreeEUNs;
+        __u16 LastFreeEUN;              /* To speed up finding a free EUN */
+        int head,sect,cyl;
+        __u16 *PUtable;                 /* Physical Unit Table  */
+        __u16 *VUtable;                 /* Virtual Unit Table */
+        unsigned int nb_blocks;         /* number of physical blocks */
+        unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
+        struct erase_info instr;
+        struct nand_oobinfo oobinfo;
+};
+
+int INFTL_mount(struct INFTLrecord *s);
+int INFTL_formatblock(struct INFTLrecord *s, int block);
+
+#endif /* __KERNEL__ */
+
+#endif /* __MTD_INFTL_H__ */
diff --git a/include/linux/mtd/jedec.h b/include/linux/mtd/jedec.h
new file mode 100644
index 000000000000..2ba0f700ddbc
--- /dev/null
+++ b/include/linux/mtd/jedec.h
@@ -0,0 +1,66 @@
+
+/* JEDEC Flash Interface.
+ * This is an older type of interface for self programming flash. It is 
+ * commonly use in older AMD chips and is obsolete compared with CFI.
+ * It is called JEDEC because the JEDEC association distributes the ID codes
+ * for the chips.
+ *
+ * See the AMD flash databook for information on how to operate the interface.
+ *
+ * $Id: jedec.h,v 1.3 2003/05/21 11:51:01 dwmw2 Exp $
+ */
+
+#ifndef __LINUX_MTD_JEDEC_H__
+#define __LINUX_MTD_JEDEC_H__
+
+#include <linux/types.h>
+
+#define MAX_JEDEC_CHIPS 16
+
+// Listing of all supported chips and their information
+struct JEDECTable
+{
+   __u16 jedec;
+   char *name;
+   unsigned long size;
+   unsigned long sectorsize;
+   __u32 capabilities;
+};
+
+// JEDEC being 0 is the end of the chip array
+struct jedec_flash_chip
+{
+   __u16 jedec;
+   unsigned long size;
+   unsigned long sectorsize;
+   
+   // *(__u8*)(base + (adder << addrshift)) = data << datashift
+   // Address size = size << addrshift
+   unsigned long base;           // Byte 0 of the flash, will be unaligned
+   unsigned int datashift;       // Useful for 32bit/16bit accesses
+   unsigned int addrshift;
+   unsigned long offset;         // linerized start. base==offset for unbanked, uninterleaved flash
+   
+   __u32 capabilities;
+   
+   // These markers are filled in by the flash_chip_scan function
+   unsigned long start;
+   unsigned long length;
+};
+
+struct jedec_private
+{
+   unsigned long size;         // Total size of all the devices
+   
+   /* Bank handling. If sum(bank_fill) == size then this is linear flash.
+      Otherwise the mapping has holes in it. bank_fill may be used to
+      find the holes, but in the common symetric case 
+      bank_fill[0] == bank_fill[*], thus addresses may be computed 
+      mathmatically. bank_fill must be powers of two */
+   unsigned is_banked;
+   unsigned long bank_fill[MAX_JEDEC_CHIPS];
+   
+   struct jedec_flash_chip chips[MAX_JEDEC_CHIPS];  
+};
+
+#endif
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
new file mode 100644
index 000000000000..f0268b99c900
--- /dev/null
+++ b/include/linux/mtd/map.h
@@ -0,0 +1,412 @@
+
+/* Overhauled routines for dealing with different mmap regions of flash */
+/* $Id: map.h,v 1.46 2005/01/05 17:09:44 dwmw2 Exp $ */
+
+#ifndef __LINUX_MTD_MAP_H__
+#define __LINUX_MTD_MAP_H__
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/mtd/compatmac.h>
+#include <asm/unaligned.h>
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/bug.h>
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
+#define map_bankwidth(map) 1
+#define map_bankwidth_is_1(map) (map_bankwidth(map) == 1)
+#define map_bankwidth_is_large(map) (0)
+#define map_words(map) (1)
+#define MAX_MAP_BANKWIDTH 1
+#else
+#define map_bankwidth_is_1(map) (0)
+#endif
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
+# ifdef map_bankwidth
+#  undef map_bankwidth
+#  define map_bankwidth(map) ((map)->bankwidth)
+# else
+#  define map_bankwidth(map) 2
+#  define map_bankwidth_is_large(map) (0)
+#  define map_words(map) (1)
+# endif
+#define map_bankwidth_is_2(map) (map_bankwidth(map) == 2)
+#undef MAX_MAP_BANKWIDTH
+#define MAX_MAP_BANKWIDTH 2
+#else
+#define map_bankwidth_is_2(map) (0)
+#endif
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
+# ifdef map_bankwidth
+#  undef map_bankwidth
+#  define map_bankwidth(map) ((map)->bankwidth)
+# else
+#  define map_bankwidth(map) 4
+#  define map_bankwidth_is_large(map) (0)
+#  define map_words(map) (1)
+# endif
+#define map_bankwidth_is_4(map) (map_bankwidth(map) == 4)
+#undef MAX_MAP_BANKWIDTH
+#define MAX_MAP_BANKWIDTH 4
+#else
+#define map_bankwidth_is_4(map) (0)
+#endif
+
+/* ensure we never evaluate anything shorted than an unsigned long
+ * to zero, and ensure we'll never miss the end of an comparison (bjd) */
+
+#define map_calc_words(map) ((map_bankwidth(map) + (sizeof(unsigned long)-1))/ sizeof(unsigned long))
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
+# ifdef map_bankwidth
+#  undef map_bankwidth
+#  define map_bankwidth(map) ((map)->bankwidth)
+#  if BITS_PER_LONG < 64
+#   undef map_bankwidth_is_large
+#   define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
+#   undef map_words
+#   define map_words(map) map_calc_words(map)
+#  endif
+# else
+#  define map_bankwidth(map) 8
+#  define map_bankwidth_is_large(map) (BITS_PER_LONG < 64)
+#  define map_words(map) map_calc_words(map)
+# endif
+#define map_bankwidth_is_8(map) (map_bankwidth(map) == 8)
+#undef MAX_MAP_BANKWIDTH
+#define MAX_MAP_BANKWIDTH 8
+#else
+#define map_bankwidth_is_8(map) (0)
+#endif
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
+# ifdef map_bankwidth
+#  undef map_bankwidth
+#  define map_bankwidth(map) ((map)->bankwidth)
+#  undef map_bankwidth_is_large
+#  define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
+#  undef map_words
+#  define map_words(map) map_calc_words(map)
+# else
+#  define map_bankwidth(map) 16
+#  define map_bankwidth_is_large(map) (1)
+#  define map_words(map) map_calc_words(map)
+# endif
+#define map_bankwidth_is_16(map) (map_bankwidth(map) == 16)
+#undef MAX_MAP_BANKWIDTH
+#define MAX_MAP_BANKWIDTH 16
+#else
+#define map_bankwidth_is_16(map) (0)
+#endif
+
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
+# ifdef map_bankwidth
+#  undef map_bankwidth
+#  define map_bankwidth(map) ((map)->bankwidth)
+#  undef map_bankwidth_is_large
+#  define map_bankwidth_is_large(map) (map_bankwidth(map) > BITS_PER_LONG/8)
+#  undef map_words
+#  define map_words(map) map_calc_words(map)
+# else
+#  define map_bankwidth(map) 32
+#  define map_bankwidth_is_large(map) (1)
+#  define map_words(map) map_calc_words(map)
+# endif
+#define map_bankwidth_is_32(map) (map_bankwidth(map) == 32)
+#undef MAX_MAP_BANKWIDTH
+#define MAX_MAP_BANKWIDTH 32
+#else
+#define map_bankwidth_is_32(map) (0)
+#endif
+
+#ifndef map_bankwidth
+#error "No bus width supported. What's the point?"
+#endif
+
+static inline int map_bankwidth_supported(int w)
+{
+        switch (w) {
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_1
+        case 1:
+#endif
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_2
+        case 2:
+#endif
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_4
+        case 4:
+#endif
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_8
+        case 8:
+#endif
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_16
+        case 16:
+#endif
+#ifdef CONFIG_MTD_MAP_BANK_WIDTH_32
+        case 32:
+#endif
+                return 1;
+
+        default:
+                return 0;
+        }
+}
+
+#define MAX_MAP_LONGS ( ((MAX_MAP_BANKWIDTH*8) + BITS_PER_LONG - 1) / BITS_PER_LONG )
+
+typedef union {
+        unsigned long x[MAX_MAP_LONGS];
+} map_word;
+
+/* The map stuff is very simple. You fill in your struct map_info with
+   a handful of routines for accessing the device, making sure they handle
+   paging etc. correctly if your device needs it. Then you pass it off
+   to a chip probe routine -- either JEDEC or CFI probe or both -- via
+   do_map_probe(). If a chip is recognised, the probe code will invoke the
+   appropriate chip driver (if present) and return a struct mtd_info.
+   At which point, you fill in the mtd->module with your own module 
+   address, and register it with the MTD core code. Or you could partition
+   it and register the partitions instead, or keep it for your own private
+   use; whatever.
+   
+   The mtd->priv field will point to the struct map_info, and any further
+   private data required by the chip driver is linked from the 
+   mtd->priv->fldrv_priv field. This allows the map driver to get at 
+   the destructor function map->fldrv_destroy() when it's tired
+   of living.
+*/
+
+struct map_info {
+        char *name;
+        unsigned long size;
+        unsigned long phys;
+#define NO_XIP (-1UL)
+
+        void __iomem *virt;
+        void *cached;
+
+        int bankwidth; /* in octets. This isn't necessarily the width
+                       of actual bus cycles -- it's the repeat interval
+                      in bytes, before you are talking to the first chip again.
+                      */
+
+#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
+        map_word (*read)(struct map_info *, unsigned long);
+        void (*copy_from)(struct map_info *, void *, unsigned long, ssize_t);
+
+        void (*write)(struct map_info *, const map_word, unsigned long);
+        void (*copy_to)(struct map_info *, unsigned long, const void *, ssize_t);
+
+        /* We can perhaps put in 'point' and 'unpoint' methods, if we really
+           want to enable XIP for non-linear mappings. Not yet though. */
+#endif
+        /* It's possible for the map driver to use cached memory in its
+           copy_from implementation (and _only_ with copy_from).  However,
+           when the chip driver knows some flash area has changed contents,
+           it will signal it to the map driver through this routine to let
+           the map driver invalidate the corresponding cache as needed.
+           If there is no cache to care about this can be set to NULL. */
+        void (*inval_cache)(struct map_info *, unsigned long, ssize_t);
+
+        /* set_vpp() must handle being reentered -- enable, enable, disable 
+           must leave it enabled. */
+        void (*set_vpp)(struct map_info *, int);
+
+        unsigned long map_priv_1;
+        unsigned long map_priv_2;
+        void *fldrv_priv;
+        struct mtd_chip_driver *fldrv;
+};
+
+struct mtd_chip_driver {
+        struct mtd_info *(*probe)(struct map_info *map);
+        void (*destroy)(struct mtd_info *);
+        struct module *module;
+        char *name;
+        struct list_head list;
+};
+
+void register_mtd_chip_driver(struct mtd_chip_driver *);
+void unregister_mtd_chip_driver(struct mtd_chip_driver *);
+
+struct mtd_info *do_map_probe(const char *name, struct map_info *map);
+void map_destroy(struct mtd_info *mtd);
+
+#define ENABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 1); } while(0)
+#define DISABLE_VPP(map) do { if(map->set_vpp) map->set_vpp(map, 0); } while(0)
+
+#define INVALIDATE_CACHED_RANGE(map, from, size) \
+        do { if(map->inval_cache) map->inval_cache(map, from, size); } while(0)
+
+
+static inline int map_word_equal(struct map_info *map, map_word val1, map_word val2)
+{
+        int i;
+        for (i=0; i<map_words(map); i++) {
+                if (val1.x[i] != val2.x[i])
+                        return 0;
+        }
+        return 1;
+}
+
+static inline map_word map_word_and(struct map_info *map, map_word val1, map_word val2)
+{
+        map_word r;
+        int i;
+
+        for (i=0; i<map_words(map); i++) {
+                r.x[i] = val1.x[i] & val2.x[i];
+        }
+        return r;
+}
+
+static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
+{
+        map_word r;
+        int i;
+
+        for (i=0; i<map_words(map); i++) {
+                r.x[i] = val1.x[i] | val2.x[i];
+        }
+        return r;
+}
+#define map_word_andequal(m, a, b, z) map_word_equal(m, z, map_word_and(m, a, b))
+
+static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
+{
+        int i;
+
+        for (i=0; i<map_words(map); i++) {
+                if (val1.x[i] & val2.x[i])
+                        return 1;
+        }
+        return 0;
+}
+
+static inline map_word map_word_load(struct map_info *map, const void *ptr)
+{
+        map_word r;
+
+        if (map_bankwidth_is_1(map))
+                r.x[0] = *(unsigned char *)ptr;
+        else if (map_bankwidth_is_2(map))
+                r.x[0] = get_unaligned((uint16_t *)ptr);
+        else if (map_bankwidth_is_4(map))
+                r.x[0] = get_unaligned((uint32_t *)ptr);
+#if BITS_PER_LONG >= 64
+        else if (map_bankwidth_is_8(map))
+                r.x[0] = get_unaligned((uint64_t *)ptr);
+#endif
+        else if (map_bankwidth_is_large(map))
+                memcpy(r.x, ptr, map->bankwidth);
+
+        return r;
+}
+
+static inline map_word map_word_load_partial(struct map_info *map, map_word orig, const unsigned char *buf, int start, int len)
+{
+        int i;
+
+        if (map_bankwidth_is_large(map)) {
+                char *dest = (char *)&orig;
+                memcpy(dest+start, buf, len);
+        } else {
+                for (i=start; i < start+len; i++) {
+                        int bitpos;
+#ifdef __LITTLE_ENDIAN
+                        bitpos = i*8;
+#else /* __BIG_ENDIAN */
+                        bitpos = (map_bankwidth(map)-1-i)*8;
+#endif
+                        orig.x[0] &= ~(0xff << bitpos);
+                        orig.x[0] |= buf[i-start] << bitpos;
+                }
+        }
+        return orig;
+}
+
+static inline map_word map_word_ff(struct map_info *map)
+{
+        map_word r;
+        int i;
+
+        for (i=0; i<map_words(map); i++) {
+                r.x[i] = ~0UL;
+        }
+        return r;
+}
+static inline map_word inline_map_read(struct map_info *map, unsigned long ofs)
+{
+        map_word r;
+
+        if (map_bankwidth_is_1(map))
+                r.x[0] = __raw_readb(map->virt + ofs);
+        else if (map_bankwidth_is_2(map))
+                r.x[0] = __raw_readw(map->virt + ofs);
+        else if (map_bankwidth_is_4(map))
+                r.x[0] = __raw_readl(map->virt + ofs);
+#if BITS_PER_LONG >= 64
+        else if (map_bankwidth_is_8(map))
+                r.x[0] = __raw_readq(map->virt + ofs);
+#endif
+        else if (map_bankwidth_is_large(map))
+                memcpy_fromio(r.x, map->virt+ofs, map->bankwidth);
+
+        return r;
+}
+
+static inline void inline_map_write(struct map_info *map, const map_word datum, unsigned long ofs)
+{
+        if (map_bankwidth_is_1(map))
+                __raw_writeb(datum.x[0], map->virt + ofs);
+        else if (map_bankwidth_is_2(map))
+                __raw_writew(datum.x[0], map->virt + ofs);
+        else if (map_bankwidth_is_4(map))
+                __raw_writel(datum.x[0], map->virt + ofs);
+#if BITS_PER_LONG >= 64
+        else if (map_bankwidth_is_8(map))
+                __raw_writeq(datum.x[0], map->virt + ofs);
+#endif
+        else if (map_bankwidth_is_large(map))
+                memcpy_toio(map->virt+ofs, datum.x, map->bankwidth);
+        mb();
+}
+
+static inline void inline_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
+{
+        if (map->cached)
+                memcpy(to, (char *)map->cached + from, len);
+        else
+                memcpy_fromio(to, map->virt + from, len);
+}
+
+static inline void inline_map_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
+{
+        memcpy_toio(map->virt + to, from, len);
+}
+
+#ifdef CONFIG_MTD_COMPLEX_MAPPINGS
+#define map_read(map, ofs) (map)->read(map, ofs)
+#define map_copy_from(map, to, from, len) (map)->copy_from(map, to, from, len)
+#define map_write(map, datum, ofs) (map)->write(map, datum, ofs)
+#define map_copy_to(map, to, from, len) (map)->copy_to(map, to, from, len)
+
+extern void simple_map_init(struct map_info *);
+#define map_is_linear(map) (map->phys != NO_XIP)
+
+#else
+#define map_read(map, ofs) inline_map_read(map, ofs)
+#define map_copy_from(map, to, from, len) inline_map_copy_from(map, to, from, len)
+#define map_write(map, datum, ofs) inline_map_write(map, datum, ofs)
+#define map_copy_to(map, to, from, len) inline_map_copy_to(map, to, from, len)
+
+
+#define simple_map_init(map) BUG_ON(!map_bankwidth_supported((map)->bankwidth))
+#define map_is_linear(map) (1)
+
+#endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */
+
+#endif /* __LINUX_MTD_MAP_H__ */
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
new file mode 100644
index 000000000000..b3d134392b31
--- /dev/null
+++ b/include/linux/mtd/mtd.h
@@ -0,0 +1,226 @@
+/* 
+ * $Id: mtd.h,v 1.56 2004/08/09 18:46:04 dmarlin Exp $
+ *
+ * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
+ *
+ * Released under GPL
+ */
+
+#ifndef __MTD_MTD_H__
+#define __MTD_MTD_H__
+
+#ifndef __KERNEL__
+#error This is a kernel header. Perhaps include mtd-user.h instead?
+#endif
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/uio.h>
+
+#include <linux/mtd/compatmac.h>
+#include <mtd/mtd-abi.h>
+
+#define MTD_CHAR_MAJOR 90
+#define MTD_BLOCK_MAJOR 31
+#define MAX_MTD_DEVICES 16
+
+#define MTD_ERASE_PENDING       0x01
+#define MTD_ERASING             0x02
+#define MTD_ERASE_SUSPEND       0x04
+#define MTD_ERASE_DONE          0x08
+#define MTD_ERASE_FAILED        0x10
+
+/* If the erase fails, fail_addr might indicate exactly which block failed.  If
+   fail_addr = 0xffffffff, the failure was not at the device level or was not
+   specific to any particular block. */
+struct erase_info {
+        struct mtd_info *mtd;
+        u_int32_t addr;
+        u_int32_t len;
+        u_int32_t fail_addr;
+        u_long time;
+        u_long retries;
+        u_int dev;
+        u_int cell;
+        void (*callback) (struct erase_info *self);
+        u_long priv;
+        u_char state;
+        struct erase_info *next;
+};
+
+struct mtd_erase_region_info {
+        u_int32_t offset;                       /* At which this region starts, from the beginning of the MTD */
+        u_int32_t erasesize;            /* For this region */
+        u_int32_t numblocks;            /* Number of blocks of erasesize in this region */
+};
+
+struct mtd_info {
+        u_char type;
+        u_int32_t flags;
+        u_int32_t size;  // Total size of the MTD
+
+        /* "Major" erase size for the device. Naïve users may take this
+         * to be the only erase size available, or may use the more detailed
+         * information below if they desire
+         */
+        u_int32_t erasesize;
+
+        u_int32_t oobblock;  // Size of OOB blocks (e.g. 512)
+        u_int32_t oobsize;   // Amount of OOB data per block (e.g. 16)
+        u_int32_t oobavail;  // Number of bytes in OOB area available for fs 
+        u_int32_t ecctype;
+        u_int32_t eccsize;
+        
+
+        // Kernel-only stuff starts here.
+        char *name;
+        int index;
+
+        // oobinfo is a nand_oobinfo structure, which can be set by iotcl (MEMSETOOBINFO)
+        struct nand_oobinfo oobinfo;
+
+        /* Data for variable erase regions. If numeraseregions is zero,
+         * it means that the whole device has erasesize as given above. 
+         */
+        int numeraseregions;
+        struct mtd_erase_region_info *eraseregions; 
+
+        /* This really shouldn't be here. It can go away in 2.5 */
+        u_int32_t bank_size;
+
+        int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
+
+        /* This stuff for eXecute-In-Place */
+        int (*point) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);
+
+        /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
+        void (*unpoint) (struct mtd_info *mtd, u_char * addr, loff_t from, size_t len);
+
+
+        int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+        int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
+
+        int (*read_ecc) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
+        int (*write_ecc) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
+
+        int (*read_oob) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+        int (*write_oob) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
+
+        /* 
+         * Methods to access the protection register area, present in some 
+         * flash devices. The user data is one time programmable but the
+         * factory data is read only. 
+         */
+        int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+
+        int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+
+        /* This function is not yet implemented */
+        int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+
+        /* kvec-based read/write methods. We need these especially for NAND flash,
+           with its limited number of write cycles per erase.
+           NB: The 'count' parameter is the number of _vectors_, each of 
+           which contains an (ofs, len) tuple.
+        */
+        int (*readv) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from, size_t *retlen);
+        int (*readv_ecc) (struct mtd_info *mtd, struct kvec *vecs, unsigned long count, loff_t from, 
+                size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
+        int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
+        int (*writev_ecc) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, 
+                size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
+
+        /* Sync */
+        void (*sync) (struct mtd_info *mtd);
+
+        /* Chip-supported device locking */
+        int (*lock) (struct mtd_info *mtd, loff_t ofs, size_t len);
+        int (*unlock) (struct mtd_info *mtd, loff_t ofs, size_t len);
+
+        /* Power Management functions */
+        int (*suspend) (struct mtd_info *mtd);
+        void (*resume) (struct mtd_info *mtd);
+
+        /* Bad block management functions */
+        int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
+        int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
+
+        void *priv;
+
+        struct module *owner;
+        int usecount;
+};
+
+
+        /* Kernel-side ioctl definitions */
+
+extern int add_mtd_device(struct mtd_info *mtd);
+extern int del_mtd_device (struct mtd_info *mtd);
+
+extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num);
+
+extern void put_mtd_device(struct mtd_info *mtd);
+
+
+struct mtd_notifier {
+        void (*add)(struct mtd_info *mtd);
+        void (*remove)(struct mtd_info *mtd);
+        struct list_head list;
+};
+
+
+extern void register_mtd_user (struct mtd_notifier *new);
+extern int unregister_mtd_user (struct mtd_notifier *old);
+
+int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
+                       unsigned long count, loff_t to, size_t *retlen);
+
+int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
+                      unsigned long count, loff_t from, size_t *retlen);
+
+#define MTD_ERASE(mtd, args...) (*(mtd->erase))(mtd, args)
+#define MTD_POINT(mtd, a,b,c,d) (*(mtd->point))(mtd, a,b,c, (u_char **)(d))
+#define MTD_UNPOINT(mtd, arg) (*(mtd->unpoint))(mtd, (u_char *)arg)
+#define MTD_READ(mtd, args...) (*(mtd->read))(mtd, args)
+#define MTD_WRITE(mtd, args...) (*(mtd->write))(mtd, args)
+#define MTD_READV(mtd, args...) (*(mtd->readv))(mtd, args)
+#define MTD_WRITEV(mtd, args...) (*(mtd->writev))(mtd, args)
+#define MTD_READECC(mtd, args...) (*(mtd->read_ecc))(mtd, args)
+#define MTD_WRITEECC(mtd, args...) (*(mtd->write_ecc))(mtd, args)
+#define MTD_READOOB(mtd, args...) (*(mtd->read_oob))(mtd, args)
+#define MTD_WRITEOOB(mtd, args...) (*(mtd->write_oob))(mtd, args)
+#define MTD_SYNC(mtd) do { if (mtd->sync) (*(mtd->sync))(mtd);  } while (0) 
+
+
+#ifdef CONFIG_MTD_PARTITIONS
+void mtd_erase_callback(struct erase_info *instr);
+#else
+static inline void mtd_erase_callback(struct erase_info *instr)
+{
+        if (instr->callback)
+                instr->callback(instr);
+}
+#endif
+
+/*
+ * Debugging macro and defines
+ */
+#define MTD_DEBUG_LEVEL0        (0)     /* Quiet   */
+#define MTD_DEBUG_LEVEL1        (1)     /* Audible */
+#define MTD_DEBUG_LEVEL2        (2)     /* Loud    */
+#define MTD_DEBUG_LEVEL3        (3)     /* Noisy   */
+
+#ifdef CONFIG_MTD_DEBUG
+#define DEBUG(n, args...)                               \
+        do {                                            \
+                if (n <= CONFIG_MTD_DEBUG_VERBOSE)      \
+                        printk(KERN_INFO args);         \
+        } while(0)
+#else /* CONFIG_MTD_DEBUG */
+#define DEBUG(n, args...) do { } while(0)
+
+#endif /* CONFIG_MTD_DEBUG */
+
+#endif /* __MTD_MTD_H__ */
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
new file mode 100644
index 000000000000..9a19c65abd74
--- /dev/null
+++ b/include/linux/mtd/nand.h
@@ -0,0 +1,469 @@
+/*
+ *  linux/include/linux/mtd/nand.h
+ *
+ *  Copyright (c) 2000 David Woodhouse <dwmw2@mvhi.com>
+ *                     Steven J. Hill <sjhill@realitydiluted.com>
+ *                     Thomas Gleixner <tglx@linutronix.de>
+ *
+ * $Id: nand.h,v 1.68 2004/11/12 10:40:37 gleixner Exp $
+ *
+ * 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.
+ *
+ *  Info:
+ *   Contains standard defines and IDs for NAND flash devices
+ *
+ *  Changelog:
+ *   01-31-2000 DMW     Created
+ *   09-18-2000 SJH     Moved structure out of the Disk-On-Chip drivers
+ *                      so it can be used by other NAND flash device
+ *                      drivers. I also changed the copyright since none
+ *                      of the original contents of this file are specific
+ *                      to DoC devices. David can whack me with a baseball
+ *                      bat later if I did something naughty.
+ *   10-11-2000 SJH     Added private NAND flash structure for driver
+ *   10-24-2000 SJH     Added prototype for 'nand_scan' function
+ *   10-29-2001 TG      changed nand_chip structure to support 
+ *                      hardwarespecific function for accessing control lines
+ *   02-21-2002 TG      added support for different read/write adress and
+ *                      ready/busy line access function
+ *   02-26-2002 TG      added chip_delay to nand_chip structure to optimize
+ *                      command delay times for different chips
+ *   04-28-2002 TG      OOB config defines moved from nand.c to avoid duplicate
+ *                      defines in jffs2/wbuf.c
+ *   08-07-2002 TG      forced bad block location to byte 5 of OOB, even if
+ *                      CONFIG_MTD_NAND_ECC_JFFS2 is not set
+ *   08-10-2002 TG      extensions to nand_chip structure to support HW-ECC
+ *
+ *   08-29-2002 tglx    nand_chip structure: data_poi for selecting 
+ *                      internal / fs-driver buffer
+ *                      support for 6byte/512byte hardware ECC
+ *                      read_ecc, write_ecc extended for different oob-layout
+ *                      oob layout selections: NAND_NONE_OOB, NAND_JFFS2_OOB,
+ *                      NAND_YAFFS_OOB
+ *  11-25-2002 tglx     Added Manufacturer code FUJITSU, NATIONAL
+ *                      Split manufacturer and device ID structures 
+ *
+ *  02-08-2004 tglx     added option field to nand structure for chip anomalities
+ *  05-25-2004 tglx     added bad block table support, ST-MICRO manufacturer id
+ *                      update of nand_chip structure description
+ */
+#ifndef __LINUX_MTD_NAND_H
+#define __LINUX_MTD_NAND_H
+
+#include <linux/config.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+#include <linux/mtd/mtd.h>
+
+struct mtd_info;
+/* Scan and identify a NAND device */
+extern int nand_scan (struct mtd_info *mtd, int max_chips);
+/* Free resources held by the NAND device */
+extern void nand_release (struct mtd_info *mtd);
+
+/* Read raw data from the device without ECC */
+extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen);
+
+
+/* The maximum number of NAND chips in an array */
+#define NAND_MAX_CHIPS          8
+
+/* This constant declares the max. oobsize / page, which
+ * is supported now. If you add a chip with bigger oobsize/page
+ * adjust this accordingly.
+ */
+#define NAND_MAX_OOBSIZE        64
+
+/*
+ * Constants for hardware specific CLE/ALE/NCE function
+*/
+/* Select the chip by setting nCE to low */
+#define NAND_CTL_SETNCE         1
+/* Deselect the chip by setting nCE to high */
+#define NAND_CTL_CLRNCE         2
+/* Select the command latch by setting CLE to high */
+#define NAND_CTL_SETCLE         3
+/* Deselect the command latch by setting CLE to low */
+#define NAND_CTL_CLRCLE         4
+/* Select the address latch by setting ALE to high */
+#define NAND_CTL_SETALE         5
+/* Deselect the address latch by setting ALE to low */
+#define NAND_CTL_CLRALE         6
+/* Set write protection by setting WP to high. Not used! */
+#define NAND_CTL_SETWP          7
+/* Clear write protection by setting WP to low. Not used! */
+#define NAND_CTL_CLRWP          8
+
+/*
+ * Standard NAND flash commands
+ */
+#define NAND_CMD_READ0          0
+#define NAND_CMD_READ1          1
+#define NAND_CMD_PAGEPROG       0x10
+#define NAND_CMD_READOOB        0x50
+#define NAND_CMD_ERASE1         0x60
+#define NAND_CMD_STATUS         0x70
+#define NAND_CMD_STATUS_MULTI   0x71
+#define NAND_CMD_SEQIN          0x80
+#define NAND_CMD_READID         0x90
+#define NAND_CMD_ERASE2         0xd0
+#define NAND_CMD_RESET          0xff
+
+/* Extended commands for large page devices */
+#define NAND_CMD_READSTART      0x30
+#define NAND_CMD_CACHEDPROG     0x15
+
+/* Status bits */
+#define NAND_STATUS_FAIL        0x01
+#define NAND_STATUS_FAIL_N1     0x02
+#define NAND_STATUS_TRUE_READY  0x20
+#define NAND_STATUS_READY       0x40
+#define NAND_STATUS_WP          0x80
+
+/* 
+ * Constants for ECC_MODES
+ */
+
+/* No ECC. Usage is not recommended ! */
+#define NAND_ECC_NONE           0
+/* Software ECC 3 byte ECC per 256 Byte data */
+#define NAND_ECC_SOFT           1
+/* Hardware ECC 3 byte ECC per 256 Byte data */
+#define NAND_ECC_HW3_256        2
+/* Hardware ECC 3 byte ECC per 512 Byte data */
+#define NAND_ECC_HW3_512        3
+/* Hardware ECC 3 byte ECC per 512 Byte data */
+#define NAND_ECC_HW6_512        4
+/* Hardware ECC 8 byte ECC per 512 Byte data */
+#define NAND_ECC_HW8_512        6
+/* Hardware ECC 12 byte ECC per 2048 Byte data */
+#define NAND_ECC_HW12_2048      7
+
+/*
+ * Constants for Hardware ECC
+*/
+/* Reset Hardware ECC for read */
+#define NAND_ECC_READ           0
+/* Reset Hardware ECC for write */
+#define NAND_ECC_WRITE          1
+/* Enable Hardware ECC before syndrom is read back from flash */
+#define NAND_ECC_READSYN        2
+
+/* Option constants for bizarre disfunctionality and real
+*  features
+*/
+/* Chip can not auto increment pages */
+#define NAND_NO_AUTOINCR        0x00000001
+/* Buswitdh is 16 bit */
+#define NAND_BUSWIDTH_16        0x00000002
+/* Device supports partial programming without padding */
+#define NAND_NO_PADDING         0x00000004
+/* Chip has cache program function */
+#define NAND_CACHEPRG           0x00000008
+/* Chip has copy back function */
+#define NAND_COPYBACK           0x00000010
+/* AND Chip which has 4 banks and a confusing page / block 
+ * assignment. See Renesas datasheet for further information */
+#define NAND_IS_AND             0x00000020
+/* Chip has a array of 4 pages which can be read without
+ * additional ready /busy waits */
+#define NAND_4PAGE_ARRAY        0x00000040 
+
+/* Options valid for Samsung large page devices */
+#define NAND_SAMSUNG_LP_OPTIONS \
+        (NAND_NO_PADDING | NAND_CACHEPRG | NAND_COPYBACK)
+
+/* Macros to identify the above */
+#define NAND_CANAUTOINCR(chip) (!(chip->options & NAND_NO_AUTOINCR))
+#define NAND_MUST_PAD(chip) (!(chip->options & NAND_NO_PADDING))
+#define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
+#define NAND_HAS_COPYBACK(chip) ((chip->options & NAND_COPYBACK))
+
+/* Mask to zero out the chip options, which come from the id table */
+#define NAND_CHIPOPTIONS_MSK    (0x0000ffff & ~NAND_NO_AUTOINCR)
+
+/* Non chip related options */
+/* Use a flash based bad block table. This option is passed to the
+ * default bad block table function. */
+#define NAND_USE_FLASH_BBT      0x00010000
+/* The hw ecc generator provides a syndrome instead a ecc value on read 
+ * This can only work if we have the ecc bytes directly behind the 
+ * data bytes. Applies for DOC and AG-AND Renesas HW Reed Solomon generators */
+#define NAND_HWECC_SYNDROME     0x00020000
+
+
+/* Options set by nand scan */
+/* Nand scan has allocated oob_buf */
+#define NAND_OOBBUF_ALLOC       0x40000000
+/* Nand scan has allocated data_buf */
+#define NAND_DATABUF_ALLOC      0x80000000
+
+
+/*
+ * nand_state_t - chip states
+ * Enumeration for NAND flash chip state
+ */
+typedef enum {
+        FL_READY,
+        FL_READING,
+        FL_WRITING,
+        FL_ERASING,
+        FL_SYNCING,
+        FL_CACHEDPRG,
+} nand_state_t;
+
+/* Keep gcc happy */
+struct nand_chip;
+
+/**
+ * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independend devices
+ * @lock:               protection lock  
+ * @active:             the mtd device which holds the controller currently
+ */
+struct nand_hw_control {
+        spinlock_t       lock;
+        struct nand_chip *active;
+};
+
+/**
+ * struct nand_chip - NAND Private Flash Chip Data
+ * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the flash device 
+ * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the flash device 
+ * @read_byte:          [REPLACEABLE] read one byte from the chip
+ * @write_byte:         [REPLACEABLE] write one byte to the chip
+ * @read_word:          [REPLACEABLE] read one word from the chip
+ * @write_word:         [REPLACEABLE] write one word to the chip
+ * @write_buf:          [REPLACEABLE] write data from the buffer to the chip
+ * @read_buf:           [REPLACEABLE] read data from the chip into the buffer
+ * @verify_buf:         [REPLACEABLE] verify buffer contents against the chip data
+ * @select_chip:        [REPLACEABLE] select chip nr
+ * @block_bad:          [REPLACEABLE] check, if the block is bad
+ * @block_markbad:      [REPLACEABLE] mark the block bad
+ * @hwcontrol:          [BOARDSPECIFIC] hardwarespecific function for accesing control-lines
+ * @dev_ready:          [BOARDSPECIFIC] hardwarespecific function for accesing device ready/busy line
+ *                      If set to NULL no access to ready/busy is available and the ready/busy information
+ *                      is read from the chip status register
+ * @cmdfunc:            [REPLACEABLE] hardwarespecific function for writing commands to the chip
+ * @waitfunc:           [REPLACEABLE] hardwarespecific function for wait on ready
+ * @calculate_ecc:      [REPLACEABLE] function for ecc calculation or readback from ecc hardware
+ * @correct_data:       [REPLACEABLE] function for ecc correction, matching to ecc generator (sw/hw)
+ * @enable_hwecc:       [BOARDSPECIFIC] function to enable (reset) hardware ecc generator. Must only
+ *                      be provided if a hardware ECC is available
+ * @erase_cmd:          [INTERN] erase command write function, selectable due to AND support
+ * @scan_bbt:           [REPLACEABLE] function to scan bad block table
+ * @eccmode:            [BOARDSPECIFIC] mode of ecc, see defines 
+ * @eccsize:            [INTERN] databytes used per ecc-calculation
+ * @eccbytes:           [INTERN] number of ecc bytes per ecc-calculation step
+ * @eccsteps:           [INTERN] number of ecc calculation steps per page
+ * @chip_delay:         [BOARDSPECIFIC] chip dependent delay for transfering data from array to read regs (tR)
+ * @chip_lock:          [INTERN] spinlock used to protect access to this structure and the chip
+ * @wq:                 [INTERN] wait queue to sleep on if a NAND operation is in progress
+ * @state:              [INTERN] the current state of the NAND device
+ * @page_shift:         [INTERN] number of address bits in a page (column address bits)
+ * @phys_erase_shift:   [INTERN] number of address bits in a physical eraseblock
+ * @bbt_erase_shift:    [INTERN] number of address bits in a bbt entry
+ * @chip_shift:         [INTERN] number of address bits in one chip
+ * @data_buf:           [INTERN] internal buffer for one page + oob 
+ * @oob_buf:            [INTERN] oob buffer for one eraseblock
+ * @oobdirty:           [INTERN] indicates that oob_buf must be reinitialized
+ * @data_poi:           [INTERN] pointer to a data buffer
+ * @options:            [BOARDSPECIFIC] various chip options. They can partly be set to inform nand_scan about
+ *                      special functionality. See the defines for further explanation
+ * @badblockpos:        [INTERN] position of the bad block marker in the oob area
+ * @numchips:           [INTERN] number of physical chips
+ * @chipsize:           [INTERN] the size of one chip for multichip arrays
+ * @pagemask:           [INTERN] page number mask = number of (pages / chip) - 1
+ * @pagebuf:            [INTERN] holds the pagenumber which is currently in data_buf
+ * @autooob:            [REPLACEABLE] the default (auto)placement scheme
+ * @bbt:                [INTERN] bad block table pointer
+ * @bbt_td:             [REPLACEABLE] bad block table descriptor for flash lookup
+ * @bbt_md:             [REPLACEABLE] bad block table mirror descriptor
+ * @badblock_pattern:   [REPLACEABLE] bad block scan pattern used for initial bad block scan 
+ * @controller:         [OPTIONAL] a pointer to a hardware controller structure which is shared among multiple independend devices
+ * @priv:               [OPTIONAL] pointer to private chip date
+ */
+ 
+struct nand_chip {
+        void  __iomem   *IO_ADDR_R;
+        void  __iomem   *IO_ADDR_W;
+        
+        u_char          (*read_byte)(struct mtd_info *mtd);
+        void            (*write_byte)(struct mtd_info *mtd, u_char byte);
+        u16             (*read_word)(struct mtd_info *mtd);
+        void            (*write_word)(struct mtd_info *mtd, u16 word);
+        
+        void            (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);
+        void            (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);
+        int             (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);
+        void            (*select_chip)(struct mtd_info *mtd, int chip);
+        int             (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
+        int             (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
+        void            (*hwcontrol)(struct mtd_info *mtd, int cmd);
+        int             (*dev_ready)(struct mtd_info *mtd);
+        void            (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
+        int             (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this, int state);
+        int             (*calculate_ecc)(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);
+        int             (*correct_data)(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);
+        void            (*enable_hwecc)(struct mtd_info *mtd, int mode);
+        void            (*erase_cmd)(struct mtd_info *mtd, int page);
+        int             (*scan_bbt)(struct mtd_info *mtd);
+        int             eccmode;
+        int             eccsize;
+        int             eccbytes;
+        int             eccsteps;
+        int             chip_delay;
+        spinlock_t      chip_lock;
+        wait_queue_head_t wq;
+        nand_state_t    state;
+        int             page_shift;
+        int             phys_erase_shift;
+        int             bbt_erase_shift;
+        int             chip_shift;
+        u_char          *data_buf;
+        u_char          *oob_buf;
+        int             oobdirty;
+        u_char          *data_poi;
+        unsigned int    options;
+        int             badblockpos;
+        int             numchips;
+        unsigned long   chipsize;
+        int             pagemask;
+        int             pagebuf;
+        struct nand_oobinfo     *autooob;
+        uint8_t         *bbt;
+        struct nand_bbt_descr   *bbt_td;
+        struct nand_bbt_descr   *bbt_md;
+        struct nand_bbt_descr   *badblock_pattern;
+        struct nand_hw_control  *controller;
+        void            *priv;
+};
+
+/*
+ * NAND Flash Manufacturer ID Codes
+ */
+#define NAND_MFR_TOSHIBA        0x98
+#define NAND_MFR_SAMSUNG        0xec
+#define NAND_MFR_FUJITSU        0x04
+#define NAND_MFR_NATIONAL       0x8f
+#define NAND_MFR_RENESAS        0x07
+#define NAND_MFR_STMICRO        0x20
+
+/**
+ * struct nand_flash_dev - NAND Flash Device ID Structure
+ *
+ * @name:       Identify the device type
+ * @id:         device ID code
+ * @pagesize:   Pagesize in bytes. Either 256 or 512 or 0
+ *              If the pagesize is 0, then the real pagesize 
+ *              and the eraseize are determined from the
+ *              extended id bytes in the chip
+ * @erasesize:  Size of an erase block in the flash device.
+ * @chipsize:   Total chipsize in Mega Bytes
+ * @options:    Bitfield to store chip relevant options
+ */
+struct nand_flash_dev {
+        char *name;
+        int id;
+        unsigned long pagesize;
+        unsigned long chipsize;
+        unsigned long erasesize;
+        unsigned long options;
+};
+
+/**
+ * struct nand_manufacturers - NAND Flash Manufacturer ID Structure
+ * @name:       Manufacturer name
+ * @id:         manufacturer ID code of device.
+*/
+struct nand_manufacturers {
+        int id;
+        char * name;
+};
+
+extern struct nand_flash_dev nand_flash_ids[];
+extern struct nand_manufacturers nand_manuf_ids[];
+
+/** 
+ * struct nand_bbt_descr - bad block table descriptor
+ * @options:    options for this descriptor
+ * @pages:      the page(s) where we find the bbt, used with option BBT_ABSPAGE
+ *              when bbt is searched, then we store the found bbts pages here.
+ *              Its an array and supports up to 8 chips now
+ * @offs:       offset of the pattern in the oob area of the page
+ * @veroffs:    offset of the bbt version counter in the oob are of the page
+ * @version:    version read from the bbt page during scan
+ * @len:        length of the pattern, if 0 no pattern check is performed
+ * @maxblocks:  maximum number of blocks to search for a bbt. This number of
+ *              blocks is reserved at the end of the device where the tables are 
+ *              written.
+ * @reserved_block_code: if non-0, this pattern denotes a reserved (rather than
+ *              bad) block in the stored bbt
+ * @pattern:    pattern to identify bad block table or factory marked good / 
+ *              bad blocks, can be NULL, if len = 0
+ *
+ * Descriptor for the bad block table marker and the descriptor for the 
+ * pattern which identifies good and bad blocks. The assumption is made
+ * that the pattern and the version count are always located in the oob area
+ * of the first block.
+ */
+struct nand_bbt_descr {
+        int     options;
+        int     pages[NAND_MAX_CHIPS];
+        int     offs;
+        int     veroffs;
+        uint8_t version[NAND_MAX_CHIPS];
+        int     len;
+        int     maxblocks;
+        int     reserved_block_code;
+        uint8_t *pattern;
+};
+
+/* Options for the bad block table descriptors */
+
+/* The number of bits used per block in the bbt on the device */
+#define NAND_BBT_NRBITS_MSK     0x0000000F
+#define NAND_BBT_1BIT           0x00000001
+#define NAND_BBT_2BIT           0x00000002
+#define NAND_BBT_4BIT           0x00000004
+#define NAND_BBT_8BIT           0x00000008
+/* The bad block table is in the last good block of the device */
+#define NAND_BBT_LASTBLOCK      0x00000010
+/* The bbt is at the given page, else we must scan for the bbt */
+#define NAND_BBT_ABSPAGE        0x00000020
+/* The bbt is at the given page, else we must scan for the bbt */
+#define NAND_BBT_SEARCH         0x00000040
+/* bbt is stored per chip on multichip devices */
+#define NAND_BBT_PERCHIP        0x00000080
+/* bbt has a version counter at offset veroffs */
+#define NAND_BBT_VERSION        0x00000100
+/* Create a bbt if none axists */
+#define NAND_BBT_CREATE         0x00000200
+/* Search good / bad pattern through all pages of a block */
+#define NAND_BBT_SCANALLPAGES   0x00000400
+/* Scan block empty during good / bad block scan */
+#define NAND_BBT_SCANEMPTY      0x00000800
+/* Write bbt if neccecary */
+#define NAND_BBT_WRITE          0x00001000
+/* Read and write back block contents when writing bbt */
+#define NAND_BBT_SAVECONTENT    0x00002000
+/* Search good / bad pattern on the first and the second page */
+#define NAND_BBT_SCAN2NDPAGE    0x00004000
+
+/* The maximum number of blocks to scan for a bbt */
+#define NAND_BBT_SCAN_MAXBLOCKS 4
+
+extern int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd);
+extern int nand_update_bbt (struct mtd_info *mtd, loff_t offs);
+extern int nand_default_bbt (struct mtd_info *mtd);
+extern int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt);
+extern int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt);
+
+/*
+* Constants for oob configuration
+*/
+#define NAND_SMALL_BADBLOCK_POS         5
+#define NAND_LARGE_BADBLOCK_POS         0
+
+#endif /* __LINUX_MTD_NAND_H */
diff --git a/include/linux/mtd/nand_ecc.h b/include/linux/mtd/nand_ecc.h
new file mode 100644
index 000000000000..12c5bc342ead
--- /dev/null
+++ b/include/linux/mtd/nand_ecc.h
@@ -0,0 +1,30 @@
+/*
+ *  drivers/mtd/nand_ecc.h
+ *
+ *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
+ *
+ * $Id: nand_ecc.h,v 1.4 2004/06/17 02:35:02 dbrown Exp $
+ *
+ * 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.
+ *
+ * This file is the header for the ECC algorithm.
+ */
+
+#ifndef __MTD_NAND_ECC_H__
+#define __MTD_NAND_ECC_H__
+
+struct mtd_info;
+
+/*
+ * Calculate 3 byte ECC code for 256 byte block
+ */
+int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);
+
+/*
+ * Detect and correct a 1 bit error for 256 byte block
+ */
+int nand_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);
+
+#endif /* __MTD_NAND_ECC_H__ */
diff --git a/include/linux/mtd/nftl.h b/include/linux/mtd/nftl.h
new file mode 100644
index 000000000000..d35d2c21ff3e
--- /dev/null
+++ b/include/linux/mtd/nftl.h
@@ -0,0 +1,54 @@
+/*
+ * $Id: nftl.h,v 1.16 2004/06/30 14:49:00 dbrown Exp $
+ *
+ * (C) 1999-2003 David Woodhouse <dwmw2@infradead.org>
+ */
+
+#ifndef __MTD_NFTL_H__
+#define __MTD_NFTL_H__
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/blktrans.h>
+
+#include <mtd/nftl-user.h>
+
+/* these info are used in ReplUnitTable */
+#define BLOCK_NIL          0xffff /* last block of a chain */
+#define BLOCK_FREE         0xfffe /* free block */
+#define BLOCK_NOTEXPLORED  0xfffd /* non explored block, only used during mounting */
+#define BLOCK_RESERVED     0xfffc /* bios block or bad block */
+
+struct NFTLrecord {
+        struct mtd_blktrans_dev mbd;
+        __u16 MediaUnit, SpareMediaUnit;
+        __u32 EraseSize;
+        struct NFTLMediaHeader MediaHdr;
+        int usecount;
+        unsigned char heads;
+        unsigned char sectors;
+        unsigned short cylinders;
+        __u16 numvunits;
+        __u16 lastEUN;                  /* should be suppressed */
+        __u16 numfreeEUNs;
+        __u16 LastFreeEUN;              /* To speed up finding a free EUN */
+        int head,sect,cyl;
+        __u16 *EUNtable;                /* [numvunits]: First EUN for each virtual unit  */
+        __u16 *ReplUnitTable;           /* [numEUNs]: ReplUnitNumber for each */
+        unsigned int nb_blocks;         /* number of physical blocks */
+        unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
+        struct erase_info instr;
+        struct nand_oobinfo oobinfo;
+};
+
+int NFTL_mount(struct NFTLrecord *s);
+int NFTL_formatblock(struct NFTLrecord *s, int block);
+
+#ifndef NFTL_MAJOR
+#define NFTL_MAJOR 93
+#endif
+
+#define MAX_NFTLS 16
+#define MAX_SECTORS_PER_UNIT 64
+#define NFTL_PARTN_BITS 4
+
+#endif /* __MTD_NFTL_H__ */
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
new file mode 100644
index 000000000000..50b2edfc8f11
--- /dev/null
+++ b/include/linux/mtd/partitions.h
@@ -0,0 +1,75 @@
+/*
+ * MTD partitioning layer definitions
+ *
+ * (C) 2000 Nicolas Pitre <nico@cam.org>
+ *
+ * This code is GPL
+ *
+ * $Id: partitions.h,v 1.16 2004/11/16 18:34:40 dwmw2 Exp $
+ */
+
+#ifndef MTD_PARTITIONS_H
+#define MTD_PARTITIONS_H
+
+#include <linux/types.h>
+
+
+/*
+ * Partition definition structure:
+ * 
+ * An array of struct partition is passed along with a MTD object to
+ * add_mtd_partitions() to create them.
+ *
+ * For each partition, these fields are available:
+ * name: string that will be used to label the partition's MTD device.
+ * size: the partition size; if defined as MTDPART_SIZ_FULL, the partition 
+ *      will extend to the end of the master MTD device.
+ * offset: absolute starting position within the master MTD device; if 
+ *      defined as MTDPART_OFS_APPEND, the partition will start where the 
+ *      previous one ended; if MTDPART_OFS_NXTBLK, at the next erase block.
+ * mask_flags: contains flags that have to be masked (removed) from the 
+ *      master MTD flag set for the corresponding MTD partition.
+ *      For example, to force a read-only partition, simply adding 
+ *      MTD_WRITEABLE to the mask_flags will do the trick.
+ *
+ * Note: writeable partitions require their size and offset be 
+ * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
+ */ 
+
+struct mtd_partition {
+        char *name;                     /* identifier string */
+        u_int32_t size;                 /* partition size */
+        u_int32_t offset;               /* offset within the master MTD space */
+        u_int32_t mask_flags;           /* master MTD flags to mask out for this partition */
+        struct nand_oobinfo *oobsel;    /* out of band layout for this partition (NAND only)*/
+        struct mtd_info **mtdp;         /* pointer to store the MTD object */
+};
+
+#define MTDPART_OFS_NXTBLK      (-2)
+#define MTDPART_OFS_APPEND      (-1)
+#define MTDPART_SIZ_FULL        (0)
+
+
+int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
+int del_mtd_partitions(struct mtd_info *);
+
+/*
+ * Functions dealing with the various ways of partitioning the space
+ */
+
+struct mtd_part_parser {
+        struct list_head list;
+        struct module *owner;
+        const char *name;
+        int (*parse_fn)(struct mtd_info *, struct mtd_partition **, unsigned long);
+};
+
+extern int register_mtd_parser(struct mtd_part_parser *parser);
+extern int deregister_mtd_parser(struct mtd_part_parser *parser);
+extern int parse_mtd_partitions(struct mtd_info *master, const char **types, 
+                                struct mtd_partition **pparts, unsigned long origin);
+
+#define put_partition_parser(p) do { module_put((p)->owner); } while(0)
+
+#endif
+
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
new file mode 100644
index 000000000000..05aa4970677f
--- /dev/null
+++ b/include/linux/mtd/physmap.h
@@ -0,0 +1,61 @@
+/*
+ * For boards with physically mapped flash and using 
+ * drivers/mtd/maps/physmap.c mapping driver.
+ *
+ * $Id: physmap.h,v 1.3 2004/07/21 00:16:15 jwboyer Exp $
+ *
+ * Copyright (C) 2003 MontaVista Software Inc.
+ * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
+ *
+ * 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;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#ifndef __LINUX_MTD_PHYSMAP__
+
+#include <linux/config.h>
+
+#if defined(CONFIG_MTD_PHYSMAP) 
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/partitions.h>
+
+/*
+ * The map_info for physmap.  Board can override size, buswidth, phys,
+ * (*set_vpp)(), etc in their initial setup routine.
+ */
+extern struct map_info physmap_map;
+
+/*
+ * Board needs to specify the exact mapping during their setup time.
+ */
+static inline void physmap_configure(unsigned long addr, unsigned long size, int bankwidth, void (*set_vpp)(struct map_info *, int) )
+{
+        physmap_map.phys = addr;
+        physmap_map.size = size;
+        physmap_map.bankwidth = bankwidth;
+        physmap_map.set_vpp = set_vpp;
+}
+
+#if defined(CONFIG_MTD_PARTITIONS)
+
+/*
+ * Machines that wish to do flash partition may want to call this function in 
+ * their setup routine.  
+ *
+ *      physmap_set_partitions(mypartitions, num_parts);
+ *
+ * Note that one can always override this hard-coded partition with 
+ * command line partition (you need to enable CONFIG_MTD_CMDLINE_PARTS).
+ */
+void physmap_set_partitions(struct mtd_partition *parts, int num_parts);
+
+#endif /* defined(CONFIG_MTD_PARTITIONS) */
+#endif /* defined(CONFIG_MTD) */
+
+#endif /* __LINUX_MTD_PHYSMAP__ */
+
diff --git a/include/linux/mtd/pmc551.h b/include/linux/mtd/pmc551.h
new file mode 100644
index 000000000000..113e3087f68a
--- /dev/null
+++ b/include/linux/mtd/pmc551.h
@@ -0,0 +1,79 @@
+/*
+ * $Id: pmc551.h,v 1.5 2003/01/24 16:49:53 dwmw2 Exp $
+ *
+ * PMC551 PCI Mezzanine Ram Device
+ *
+ * Author:
+ *       Mark Ferrell
+ *       Copyright 1999,2000 Nortel Networks
+ *
+ * License: 
+ *       As part of this driver was derrived from the slram.c driver it falls
+ *       under the same license, which is GNU General Public License v2
+ */
+
+#ifndef __MTD_PMC551_H__
+#define __MTD_PMC551_H__
+
+#include <linux/mtd/mtd.h>
+
+#define PMC551_VERSION "$Id: pmc551.h,v 1.5 2003/01/24 16:49:53 dwmw2 Exp $\n"\
+       "Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n"
+
+/*
+ * Our personal and private information
+ */
+struct mypriv {
+        struct pci_dev *dev;
+        u_char *start;
+        u32    base_map0;
+        u32    curr_map0;
+        u32    asize;
+        struct mtd_info *nextpmc551;
+};                       
+
+/*
+ * Function Prototypes
+ */
+static int pmc551_erase(struct mtd_info *, struct erase_info *);
+static void pmc551_unpoint(struct mtd_info *, u_char *, loff_t, size_t);
+static int pmc551_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);
+static int pmc551_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
+static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);        
+
+
+/*
+ * Define the PCI ID's if the kernel doesn't define them for us
+ */
+#ifndef PCI_VENDOR_ID_V3_SEMI
+#define PCI_VENDOR_ID_V3_SEMI             0x11b0
+#endif
+
+#ifndef PCI_DEVICE_ID_V3_SEMI_V370PDC
+#define PCI_DEVICE_ID_V3_SEMI_V370PDC     0x0200  
+#endif
+
+
+#define PMC551_PCI_MEM_MAP0     0x50
+#define PMC551_PCI_MEM_MAP1     0x54
+#define PMC551_PCI_MEM_MAP_MAP_ADDR_MASK        0x3ff00000
+#define PMC551_PCI_MEM_MAP_APERTURE_MASK        0x000000f0
+#define PMC551_PCI_MEM_MAP_REG_EN               0x00000002
+#define PMC551_PCI_MEM_MAP_ENABLE               0x00000001
+
+#define PMC551_SDRAM_MA         0x60
+#define PMC551_SDRAM_CMD        0x62
+#define PMC551_DRAM_CFG         0x64
+#define PMC551_SYS_CTRL_REG     0x78
+
+#define PMC551_DRAM_BLK0        0x68
+#define PMC551_DRAM_BLK1        0x6c
+#define PMC551_DRAM_BLK2        0x70
+#define PMC551_DRAM_BLK3        0x74
+#define PMC551_DRAM_BLK_GET_SIZE(x) (524288<<((x>>4)&0x0f))
+#define PMC551_DRAM_BLK_SET_COL_MUX(x,v) (((x) & ~0x00007000) | (((v) & 0x7) << 12))
+#define PMC551_DRAM_BLK_SET_ROW_MUX(x,v) (((x) & ~0x00000f00) | (((v) & 0xf) << 8))
+
+
+#endif /* __MTD_PMC551_H__ */
+
diff --git a/include/linux/mtd/xip.h b/include/linux/mtd/xip.h
new file mode 100644
index 000000000000..fc071125cbcc
--- /dev/null
+++ b/include/linux/mtd/xip.h
@@ -0,0 +1,107 @@
+/*
+ * MTD primitives for XIP support
+ *
+ * Author:      Nicolas Pitre
+ * Created:     Nov 2, 2004
+ * Copyright:   (C) 2004 MontaVista Software, Inc.
+ *
+ * This XIP support for MTD has been loosely inspired
+ * by an earlier patch authored by David Woodhouse.
+ *
+ * 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.
+ *
+ * $Id: xip.h,v 1.2 2004/12/01 15:49:10 nico Exp $
+ */
+
+#ifndef __LINUX_MTD_XIP_H__
+#define __LINUX_MTD_XIP_H__
+
+#include <linux/config.h>
+
+#ifdef CONFIG_MTD_XIP
+
+/*
+ * Function that are modifying the flash state away from array mode must
+ * obviously not be running from flash.  The __xipram is therefore marking
+ * those functions so they get relocated to ram.
+ */
+#define __xipram __attribute__ ((__section__ (".data")))
+
+/*
+ * We really don't want gcc to guess anything.
+ * We absolutely _need_ proper inlining.
+ */
+#include <linux/compiler.h>
+
+/*
+ * Each architecture has to provide the following macros.  They must access
+ * the hardware directly and not rely on any other (XIP) functions since they
+ * won't be available when used (flash not in array mode).
+ *
+ * xip_irqpending()
+ *
+ *      return non zero when any hardware interrupt is pending.
+ *
+ * xip_currtime()
+ *
+ *      return a platform specific time reference to be used with
+ *      xip_elapsed_since().
+ *
+ * xip_elapsed_since(x)
+ *
+ *      return in usecs the elapsed timebetween now and the reference x as
+ *      returned by xip_currtime().
+ *
+ *      note 1: convertion to usec can be approximated, as long as the
+ *              returned value is <= the real elapsed time.
+ *      note 2: this should be able to cope with a few seconds without
+ *              overflowing.
+ */
+
+#if defined(CONFIG_ARCH_SA1100) || defined(CONFIG_ARCH_PXA)
+
+#include <asm/hardware.h>
+#ifdef CONFIG_ARCH_PXA
+#include <asm/arch/pxa-regs.h>
+#endif
+
+#define xip_irqpending()        (ICIP & ICMR)
+
+/* we sample OSCR and convert desired delta to usec (1/4 ~= 1000000/3686400) */
+#define xip_currtime()          (OSCR)
+#define xip_elapsed_since(x)    (signed)((OSCR - (x)) / 4)
+
+#else
+
+#warning "missing IRQ and timer primitives for XIP MTD support"
+#warning "some of the XIP MTD support code will be disabled"
+#warning "your system will therefore be unresponsive when writing or erasing flash"
+
+#define xip_irqpending()        (0)
+#define xip_currtime()          (0)
+#define xip_elapsed_since(x)    (0)
+
+#endif
+
+/*
+ * xip_cpu_idle() is used when waiting for a delay equal or larger than
+ * the system timer tick period.  This should put the CPU into idle mode
+ * to save power and to be woken up only when some interrupts are pending.
+ * As above, this should not rely upon standard kernel code.
+ */
+
+#if defined(CONFIG_CPU_XSCALE)
+#define xip_cpu_idle()  asm volatile ("mcr p14, 0, %0, c7, c0, 0" :: "r" (1))
+#else
+#define xip_cpu_idle()  do { } while (0)
+#endif
+
+#else
+
+#define __xipram
+
+#endif /* CONFIG_MTD_XIP */
+
+#endif /* __LINUX_MTD_XIP_H__ */
diff --git a/include/linux/mtio.h b/include/linux/mtio.h
new file mode 100644
index 000000000000..8c66151821e3
--- /dev/null
+++ b/include/linux/mtio.h
@@ -0,0 +1,351 @@
+/* 
+ * linux/mtio.h header file for Linux. Written by H. Bergman
+ *
+ * Modified for special ioctls provided by zftape in September 1997
+ * by C.-J. Heine.
+ */
+
+#ifndef _LINUX_MTIO_H
+#define _LINUX_MTIO_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <linux/qic117.h>
+
+/*
+ * Structures and definitions for mag tape io control commands
+ */
+
+/* structure for MTIOCTOP - mag tape op command */
+struct  mtop {
+        short   mt_op;          /* operations defined below */
+        int     mt_count;       /* how many of them */
+};
+
+/* Magnetic Tape operations [Not all operations supported by all drivers]: */
+#define MTRESET 0       /* +reset drive in case of problems */
+#define MTFSF   1       /* forward space over FileMark,
+                         * position at first record of next file 
+                         */
+#define MTBSF   2       /* backward space FileMark (position before FM) */
+#define MTFSR   3       /* forward space record */
+#define MTBSR   4       /* backward space record */
+#define MTWEOF  5       /* write an end-of-file record (mark) */
+#define MTREW   6       /* rewind */
+#define MTOFFL  7       /* rewind and put the drive offline (eject?) */
+#define MTNOP   8       /* no op, set status only (read with MTIOCGET) */
+#define MTRETEN 9       /* retension tape */
+#define MTBSFM  10      /* +backward space FileMark, position at FM */
+#define MTFSFM  11      /* +forward space FileMark, position at FM */
+#define MTEOM   12      /* goto end of recorded media (for appending files).
+                         * MTEOM positions after the last FM, ready for
+                         * appending another file.
+                         */
+#define MTERASE 13      /* erase tape -- be careful! */
+
+#define MTRAS1  14      /* run self test 1 (nondestructive) */
+#define MTRAS2  15      /* run self test 2 (destructive) */
+#define MTRAS3  16      /* reserved for self test 3 */
+
+#define MTSETBLK 20     /* set block length (SCSI) */
+#define MTSETDENSITY 21 /* set tape density (SCSI) */
+#define MTSEEK  22      /* seek to block (Tandberg, etc.) */
+#define MTTELL  23      /* tell block (Tandberg, etc.) */
+#define MTSETDRVBUFFER 24 /* set the drive buffering according to SCSI-2 */
+                        /* ordinary buffered operation with code 1 */
+#define MTFSS   25      /* space forward over setmarks */
+#define MTBSS   26      /* space backward over setmarks */
+#define MTWSM   27      /* write setmarks */
+
+#define MTLOCK  28      /* lock the drive door */
+#define MTUNLOCK 29     /* unlock the drive door */
+#define MTLOAD  30      /* execute the SCSI load command */
+#define MTUNLOAD 31     /* execute the SCSI unload command */
+#define MTCOMPRESSION 32/* control compression with SCSI mode page 15 */
+#define MTSETPART 33    /* Change the active tape partition */
+#define MTMKPART  34    /* Format the tape with one or two partitions */
+
+/* structure for MTIOCGET - mag tape get status command */
+
+struct  mtget {
+        long    mt_type;        /* type of magtape device */
+        long    mt_resid;       /* residual count: (not sure)
+                                 *      number of bytes ignored, or
+                                 *      number of files not skipped, or
+                                 *      number of records not skipped.
+                                 */
+        /* the following registers are device dependent */
+        long    mt_dsreg;       /* status register */
+        long    mt_gstat;       /* generic (device independent) status */
+        long    mt_erreg;       /* error register */
+        /* The next two fields are not always used */
+        __kernel_daddr_t mt_fileno;     /* number of current file on tape */
+        __kernel_daddr_t mt_blkno;      /* current block number */
+};
+
+
+
+/*
+ * Constants for mt_type. Not all of these are supported,
+ * and these are not all of the ones that are supported.
+ */
+#define MT_ISUNKNOWN            0x01
+#define MT_ISQIC02              0x02    /* Generic QIC-02 tape streamer */
+#define MT_ISWT5150             0x03    /* Wangtek 5150EQ, QIC-150, QIC-02 */
+#define MT_ISARCHIVE_5945L2     0x04    /* Archive 5945L-2, QIC-24, QIC-02? */
+#define MT_ISCMSJ500            0x05    /* CMS Jumbo 500 (QIC-02?) */
+#define MT_ISTDC3610            0x06    /* Tandberg 6310, QIC-24 */
+#define MT_ISARCHIVE_VP60I      0x07    /* Archive VP60i, QIC-02 */
+#define MT_ISARCHIVE_2150L      0x08    /* Archive Viper 2150L */
+#define MT_ISARCHIVE_2060L      0x09    /* Archive Viper 2060L */
+#define MT_ISARCHIVESC499       0x0A    /* Archive SC-499 QIC-36 controller */
+#define MT_ISQIC02_ALL_FEATURES 0x0F    /* Generic QIC-02 with all features */
+#define MT_ISWT5099EEN24        0x11    /* Wangtek 5099-een24, 60MB, QIC-24 */
+#define MT_ISTEAC_MT2ST         0x12    /* Teac MT-2ST 155mb drive, Teac DC-1 card (Wangtek type) */
+#define MT_ISEVEREX_FT40A       0x32    /* Everex FT40A (QIC-40) */
+#define MT_ISDDS1               0x51    /* DDS device without partitions */
+#define MT_ISDDS2               0x52    /* DDS device with partitions */
+#define MT_ISONSTREAM_SC        0x61   /* OnStream SCSI tape drives (SC-x0)
+                                          and SCSI emulated (DI, DP, USB) */
+#define MT_ISSCSI1              0x71    /* Generic ANSI SCSI-1 tape unit */
+#define MT_ISSCSI2              0x72    /* Generic ANSI SCSI-2 tape unit */
+
+/* QIC-40/80/3010/3020 ftape supported drives.
+ * 20bit vendor ID + 0x800000 (see ftape-vendors.h)
+ */
+#define MT_ISFTAPE_UNKNOWN      0x800000 /* obsolete */
+#define MT_ISFTAPE_FLAG 0x800000
+
+struct mt_tape_info {
+        long t_type;            /* device type id (mt_type) */
+        char *t_name;           /* descriptive name */
+};
+
+#define MT_TAPE_INFO    { \
+        {MT_ISUNKNOWN,          "Unknown type of tape device"}, \
+        {MT_ISQIC02,            "Generic QIC-02 tape streamer"}, \
+        {MT_ISWT5150,           "Wangtek 5150, QIC-150"}, \
+        {MT_ISARCHIVE_5945L2,   "Archive 5945L-2"}, \
+        {MT_ISCMSJ500,          "CMS Jumbo 500"}, \
+        {MT_ISTDC3610,          "Tandberg TDC 3610, QIC-24"}, \
+        {MT_ISARCHIVE_VP60I,    "Archive VP60i, QIC-02"}, \
+        {MT_ISARCHIVE_2150L,    "Archive Viper 2150L"}, \
+        {MT_ISARCHIVE_2060L,    "Archive Viper 2060L"}, \
+        {MT_ISARCHIVESC499,     "Archive SC-499 QIC-36 controller"}, \
+        {MT_ISQIC02_ALL_FEATURES, "Generic QIC-02 tape, all features"}, \
+        {MT_ISWT5099EEN24,      "Wangtek 5099-een24, 60MB"}, \
+        {MT_ISTEAC_MT2ST,       "Teac MT-2ST 155mb data cassette drive"}, \
+        {MT_ISEVEREX_FT40A,     "Everex FT40A, QIC-40"}, \
+        {MT_ISONSTREAM_SC,      "OnStream SC-, DI-, DP-, or USB tape drive"}, \
+        {MT_ISSCSI1,            "Generic SCSI-1 tape"}, \
+        {MT_ISSCSI2,            "Generic SCSI-2 tape"}, \
+        {0, NULL} \
+}
+
+
+/* structure for MTIOCPOS - mag tape get position command */
+
+struct  mtpos {
+        long    mt_blkno;       /* current block number */
+};
+
+
+/*  structure for MTIOCVOLINFO, query information about the volume
+ *  currently positioned at (zftape)
+ */
+struct mtvolinfo {
+        unsigned int mt_volno;   /* vol-number */
+        unsigned int mt_blksz;   /* blocksize used when recording */
+        unsigned int mt_rawsize; /* raw tape space consumed, in kb */
+        unsigned int mt_size;    /* volume size after decompression, in kb */
+        unsigned int mt_cmpr:1;  /* this volume has been compressed */
+};
+
+/* raw access to a floppy drive, read and write an arbitrary segment.
+ * For ftape/zftape to support formatting etc.
+ */
+#define MT_FT_RD_SINGLE  0
+#define MT_FT_RD_AHEAD   1
+#define MT_FT_WR_ASYNC   0 /* start tape only when all buffers are full     */
+#define MT_FT_WR_MULTI   1 /* start tape, continue until buffers are empty  */
+#define MT_FT_WR_SINGLE  2 /* write a single segment and stop afterwards    */
+#define MT_FT_WR_DELETE  3 /* write deleted data marks, one segment at time */
+
+struct mtftseg
+{            
+        unsigned mt_segno;   /* the segment to read or write */
+        unsigned mt_mode;    /* modes for read/write (sync/async etc.) */
+        int      mt_result;  /* result of r/w request, not of the ioctl */
+        void    __user *mt_data;    /* User space buffer: must be 29kb */
+};
+
+/* get tape capacity (ftape/zftape)
+ */
+struct mttapesize {
+        unsigned long mt_capacity; /* entire, uncompressed capacity 
+                                    * of a cartridge
+                                    */
+        unsigned long mt_used;     /* what has been used so far, raw 
+                                    * uncompressed amount
+                                    */
+};
+
+/*  possible values of the ftfmt_op field
+ */
+#define FTFMT_SET_PARMS         1 /* set software parms */
+#define FTFMT_GET_PARMS         2 /* get software parms */
+#define FTFMT_FORMAT_TRACK      3 /* start formatting a tape track   */
+#define FTFMT_STATUS            4 /* monitor formatting a tape track */
+#define FTFMT_VERIFY            5 /* verify the given segment        */
+
+struct ftfmtparms {
+        unsigned char  ft_qicstd;   /* QIC-40/QIC-80/QIC-3010/QIC-3020 */
+        unsigned char  ft_fmtcode;  /* Refer to the QIC specs */
+        unsigned char  ft_fhm;      /* floppy head max */
+        unsigned char  ft_ftm;      /* floppy track max */
+        unsigned short ft_spt;      /* segments per track */
+        unsigned short ft_tpc;      /* tracks per cartridge */
+};
+
+struct ftfmttrack {
+        unsigned int  ft_track;   /* track to format */
+        unsigned char ft_gap3;    /* size of gap3, for FORMAT_TRK */
+};
+
+struct ftfmtstatus {
+        unsigned int  ft_segment;  /* segment currently being formatted */
+};
+
+struct ftfmtverify {
+        unsigned int  ft_segment;   /* segment to verify */
+        unsigned long ft_bsm;       /* bsm as result of VERIFY cmd */
+};
+
+struct mtftformat {
+        unsigned int fmt_op;      /* operation to perform */
+        union fmt_arg {
+                struct ftfmtparms  fmt_parms;  /* format parameters */
+                struct ftfmttrack  fmt_track;  /* ctrl while formatting */
+                struct ftfmtstatus fmt_status;
+                struct ftfmtverify fmt_verify; /* for verifying */ 
+        } fmt_arg;
+};
+
+struct mtftcmd {
+        unsigned int ft_wait_before; /* timeout to wait for drive to get ready 
+                                      * before command is sent. Milliseconds
+                                      */
+        qic117_cmd_t ft_cmd;         /* command to send */
+        unsigned char ft_parm_cnt;   /* zero: no parm is sent. */
+        unsigned char ft_parms[3];   /* parameter(s) to send to
+                                      * the drive. The parms are nibbles
+                                      * driver sends cmd + 2 step pulses */
+        unsigned int ft_result_bits; /* if non zero, number of bits
+                                      * returned by the tape drive
+                                      */
+        unsigned int ft_result;      /* the result returned by the tape drive*/
+        unsigned int ft_wait_after;  /* timeout to wait for drive to get ready
+                                      * after command is sent. 0: don't wait */
+        int ft_status;               /* status returned by ready wait
+                                      * undefined if timeout was 0.
+                                      */
+        int ft_error;                /* error code if error status was set by 
+                                      * command
+                                      */
+};
+
+/* mag tape io control commands */
+#define MTIOCTOP        _IOW('m', 1, struct mtop)       /* do a mag tape op */
+#define MTIOCGET        _IOR('m', 2, struct mtget)      /* get tape status */
+#define MTIOCPOS        _IOR('m', 3, struct mtpos)      /* get tape position */
+
+/* The next two are used by the QIC-02 driver for runtime reconfiguration.
+ * See tpqic02.h for struct mtconfiginfo.
+ */
+#define MTIOCGETCONFIG  _IOR('m', 4, struct mtconfiginfo) /* get tape config */
+#define MTIOCSETCONFIG  _IOW('m', 5, struct mtconfiginfo) /* set tape config */
+
+/* the next six are used by the floppy ftape drivers and its frontends
+ * sorry, but MTIOCTOP commands are write only.
+ */
+#define MTIOCRDFTSEG    _IOWR('m', 6, struct mtftseg)  /* read a segment */
+#define MTIOCWRFTSEG    _IOWR('m', 7, struct mtftseg)   /* write a segment */
+#define MTIOCVOLINFO    _IOR('m',  8, struct mtvolinfo) /* info about volume */
+#define MTIOCGETSIZE    _IOR('m',  9, struct mttapesize)/* get cartridge size*/
+#define MTIOCFTFORMAT   _IOWR('m', 10, struct mtftformat) /* format ftape */
+#define MTIOCFTCMD      _IOWR('m', 11, struct mtftcmd) /* send QIC-117 cmd */
+
+/* Generic Mag Tape (device independent) status macros for examining
+ * mt_gstat -- HP-UX compatible.
+ * There is room for more generic status bits here, but I don't
+ * know which of them are reserved. At least three or so should
+ * be added to make this really useful.
+ */
+#define GMT_EOF(x)              ((x) & 0x80000000)
+#define GMT_BOT(x)              ((x) & 0x40000000)
+#define GMT_EOT(x)              ((x) & 0x20000000)
+#define GMT_SM(x)               ((x) & 0x10000000)  /* DDS setmark */
+#define GMT_EOD(x)              ((x) & 0x08000000)  /* DDS EOD */
+#define GMT_WR_PROT(x)          ((x) & 0x04000000)
+/* #define GMT_ ?               ((x) & 0x02000000) */
+#define GMT_ONLINE(x)           ((x) & 0x01000000)
+#define GMT_D_6250(x)           ((x) & 0x00800000)
+#define GMT_D_1600(x)           ((x) & 0x00400000)
+#define GMT_D_800(x)            ((x) & 0x00200000)
+/* #define GMT_ ?               ((x) & 0x00100000) */
+/* #define GMT_ ?               ((x) & 0x00080000) */
+#define GMT_DR_OPEN(x)          ((x) & 0x00040000)  /* door open (no tape) */
+/* #define GMT_ ?               ((x) & 0x00020000) */
+#define GMT_IM_REP_EN(x)        ((x) & 0x00010000)  /* immediate report mode */
+#define GMT_CLN(x)              ((x) & 0x00008000)  /* cleaning requested */
+/* 15 generic status bits unused */
+
+
+/* SCSI-tape specific definitions */
+/* Bitfield shifts in the status  */
+#define MT_ST_BLKSIZE_SHIFT     0
+#define MT_ST_BLKSIZE_MASK      0xffffff
+#define MT_ST_DENSITY_SHIFT     24
+#define MT_ST_DENSITY_MASK      0xff000000
+
+#define MT_ST_SOFTERR_SHIFT     0
+#define MT_ST_SOFTERR_MASK      0xffff
+
+/* Bitfields for the MTSETDRVBUFFER ioctl */
+#define MT_ST_OPTIONS           0xf0000000
+#define MT_ST_BOOLEANS          0x10000000
+#define MT_ST_SETBOOLEANS       0x30000000
+#define MT_ST_CLEARBOOLEANS     0x40000000
+#define MT_ST_WRITE_THRESHOLD   0x20000000
+#define MT_ST_DEF_BLKSIZE       0x50000000
+#define MT_ST_DEF_OPTIONS       0x60000000
+#define MT_ST_TIMEOUTS          0x70000000
+#define MT_ST_SET_TIMEOUT       (MT_ST_TIMEOUTS | 0x000000)
+#define MT_ST_SET_LONG_TIMEOUT  (MT_ST_TIMEOUTS | 0x100000)
+#define MT_ST_SET_CLN           0x80000000
+
+#define MT_ST_BUFFER_WRITES     0x1
+#define MT_ST_ASYNC_WRITES      0x2
+#define MT_ST_READ_AHEAD        0x4
+#define MT_ST_DEBUGGING         0x8
+#define MT_ST_TWO_FM            0x10
+#define MT_ST_FAST_MTEOM        0x20
+#define MT_ST_AUTO_LOCK         0x40
+#define MT_ST_DEF_WRITES        0x80
+#define MT_ST_CAN_BSR           0x100
+#define MT_ST_NO_BLKLIMS        0x200
+#define MT_ST_CAN_PARTITIONS    0x400
+#define MT_ST_SCSI2LOGICAL      0x800
+#define MT_ST_SYSV              0x1000
+#define MT_ST_NOWAIT            0x2000
+
+/* The mode parameters to be controlled. Parameter chosen with bits 20-28 */
+#define MT_ST_CLEAR_DEFAULT     0xfffff
+#define MT_ST_DEF_DENSITY       (MT_ST_DEF_OPTIONS | 0x100000)
+#define MT_ST_DEF_COMPRESSION   (MT_ST_DEF_OPTIONS | 0x200000)
+#define MT_ST_DEF_DRVBUFFER     (MT_ST_DEF_OPTIONS | 0x300000)
+
+/* The offset for the arguments for the special HP changer load command. */
+#define MT_ST_HPLOADER_OFFSET 10000
+
+#endif /* _LINUX_MTIO_H */
diff --git a/include/linux/mv643xx.h b/include/linux/mv643xx.h
new file mode 100644
index 000000000000..5773ea42f6e4
--- /dev/null
+++ b/include/linux/mv643xx.h
@@ -0,0 +1,1313 @@
+/*
+ * mv643xx.h - MV-643XX Internal registers definition file.
+ *
+ * Copyright 2002 Momentum Computer, Inc.
+ *      Author: Matthew Dharm <mdharm@momenco.com>
+ * Copyright 2002 GALILEO TECHNOLOGY, LTD. 
+ *
+ * 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;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+#ifndef __ASM_MV643XX_H
+#define __ASM_MV643XX_H
+
+#ifdef __MIPS__
+#include <asm/addrspace.h>
+#include <asm/marvell.h>
+#endif
+#include <asm/types.h>
+
+/****************************************/
+/* Processor Address Space              */
+/****************************************/
+
+/* DDR SDRAM BAR and size registers */
+
+#define MV64340_CS_0_BASE_ADDR                                      0x008
+#define MV64340_CS_0_SIZE                                           0x010
+#define MV64340_CS_1_BASE_ADDR                                      0x208
+#define MV64340_CS_1_SIZE                                           0x210
+#define MV64340_CS_2_BASE_ADDR                                      0x018
+#define MV64340_CS_2_SIZE                                           0x020
+#define MV64340_CS_3_BASE_ADDR                                      0x218
+#define MV64340_CS_3_SIZE                                           0x220
+
+/* Devices BAR and size registers */
+
+#define MV64340_DEV_CS0_BASE_ADDR                                   0x028
+#define MV64340_DEV_CS0_SIZE                                        0x030
+#define MV64340_DEV_CS1_BASE_ADDR                                   0x228
+#define MV64340_DEV_CS1_SIZE                                        0x230
+#define MV64340_DEV_CS2_BASE_ADDR                                   0x248
+#define MV64340_DEV_CS2_SIZE                                        0x250
+#define MV64340_DEV_CS3_BASE_ADDR                                   0x038
+#define MV64340_DEV_CS3_SIZE                                        0x040
+#define MV64340_BOOTCS_BASE_ADDR                                    0x238
+#define MV64340_BOOTCS_SIZE                                         0x240
+
+/* PCI 0 BAR and size registers */
+
+#define MV64340_PCI_0_IO_BASE_ADDR                                  0x048
+#define MV64340_PCI_0_IO_SIZE                                       0x050
+#define MV64340_PCI_0_MEMORY0_BASE_ADDR                             0x058
+#define MV64340_PCI_0_MEMORY0_SIZE                                  0x060
+#define MV64340_PCI_0_MEMORY1_BASE_ADDR                             0x080
+#define MV64340_PCI_0_MEMORY1_SIZE                                  0x088
+#define MV64340_PCI_0_MEMORY2_BASE_ADDR                             0x258
+#define MV64340_PCI_0_MEMORY2_SIZE                                  0x260
+#define MV64340_PCI_0_MEMORY3_BASE_ADDR                             0x280
+#define MV64340_PCI_0_MEMORY3_SIZE                                  0x288
+
+/* PCI 1 BAR and size registers */
+#define MV64340_PCI_1_IO_BASE_ADDR                                  0x090
+#define MV64340_PCI_1_IO_SIZE                                       0x098
+#define MV64340_PCI_1_MEMORY0_BASE_ADDR                             0x0a0
+#define MV64340_PCI_1_MEMORY0_SIZE                                  0x0a8
+#define MV64340_PCI_1_MEMORY1_BASE_ADDR                             0x0b0
+#define MV64340_PCI_1_MEMORY1_SIZE                                  0x0b8
+#define MV64340_PCI_1_MEMORY2_BASE_ADDR                             0x2a0
+#define MV64340_PCI_1_MEMORY2_SIZE                                  0x2a8
+#define MV64340_PCI_1_MEMORY3_BASE_ADDR                             0x2b0
+#define MV64340_PCI_1_MEMORY3_SIZE                                  0x2b8
+
+/* SRAM base address */
+#define MV64340_INTEGRATED_SRAM_BASE_ADDR                           0x268
+
+/* internal registers space base address */
+#define MV64340_INTERNAL_SPACE_BASE_ADDR                            0x068
+
+/* Enables the CS , DEV_CS , PCI 0 and PCI 1 
+   windows above */
+#define MV64340_BASE_ADDR_ENABLE                                    0x278
+
+/****************************************/
+/* PCI remap registers                  */
+/****************************************/
+      /* PCI 0 */
+#define MV64340_PCI_0_IO_ADDR_REMAP                                 0x0f0
+#define MV64340_PCI_0_MEMORY0_LOW_ADDR_REMAP                        0x0f8
+#define MV64340_PCI_0_MEMORY0_HIGH_ADDR_REMAP                       0x320
+#define MV64340_PCI_0_MEMORY1_LOW_ADDR_REMAP                        0x100
+#define MV64340_PCI_0_MEMORY1_HIGH_ADDR_REMAP                       0x328
+#define MV64340_PCI_0_MEMORY2_LOW_ADDR_REMAP                        0x2f8
+#define MV64340_PCI_0_MEMORY2_HIGH_ADDR_REMAP                       0x330
+#define MV64340_PCI_0_MEMORY3_LOW_ADDR_REMAP                        0x300
+#define MV64340_PCI_0_MEMORY3_HIGH_ADDR_REMAP                       0x338
+      /* PCI 1 */
+#define MV64340_PCI_1_IO_ADDR_REMAP                                 0x108
+#define MV64340_PCI_1_MEMORY0_LOW_ADDR_REMAP                        0x110
+#define MV64340_PCI_1_MEMORY0_HIGH_ADDR_REMAP                       0x340
+#define MV64340_PCI_1_MEMORY1_LOW_ADDR_REMAP                        0x118
+#define MV64340_PCI_1_MEMORY1_HIGH_ADDR_REMAP                       0x348
+#define MV64340_PCI_1_MEMORY2_LOW_ADDR_REMAP                        0x310
+#define MV64340_PCI_1_MEMORY2_HIGH_ADDR_REMAP                       0x350
+#define MV64340_PCI_1_MEMORY3_LOW_ADDR_REMAP                        0x318
+#define MV64340_PCI_1_MEMORY3_HIGH_ADDR_REMAP                       0x358
+ 
+#define MV64340_CPU_PCI_0_HEADERS_RETARGET_CONTROL                  0x3b0
+#define MV64340_CPU_PCI_0_HEADERS_RETARGET_BASE                     0x3b8
+#define MV64340_CPU_PCI_1_HEADERS_RETARGET_CONTROL                  0x3c0
+#define MV64340_CPU_PCI_1_HEADERS_RETARGET_BASE                     0x3c8
+#define MV64340_CPU_GE_HEADERS_RETARGET_CONTROL                     0x3d0
+#define MV64340_CPU_GE_HEADERS_RETARGET_BASE                        0x3d8
+#define MV64340_CPU_IDMA_HEADERS_RETARGET_CONTROL                   0x3e0
+#define MV64340_CPU_IDMA_HEADERS_RETARGET_BASE                      0x3e8
+
+/****************************************/
+/*         CPU Control Registers        */
+/****************************************/
+
+#define MV64340_CPU_CONFIG                                          0x000
+#define MV64340_CPU_MODE                                            0x120
+#define MV64340_CPU_MASTER_CONTROL                                  0x160
+#define MV64340_CPU_CROSS_BAR_CONTROL_LOW                           0x150
+#define MV64340_CPU_CROSS_BAR_CONTROL_HIGH                          0x158
+#define MV64340_CPU_CROSS_BAR_TIMEOUT                               0x168
+
+/****************************************/
+/* SMP RegisterS                        */
+/****************************************/
+
+#define MV64340_SMP_WHO_AM_I                                        0x200
+#define MV64340_SMP_CPU0_DOORBELL                                   0x214
+#define MV64340_SMP_CPU0_DOORBELL_CLEAR                             0x21C
+#define MV64340_SMP_CPU1_DOORBELL                                   0x224
+#define MV64340_SMP_CPU1_DOORBELL_CLEAR                             0x22C
+#define MV64340_SMP_CPU0_DOORBELL_MASK                              0x234
+#define MV64340_SMP_CPU1_DOORBELL_MASK                              0x23C
+#define MV64340_SMP_SEMAPHOR0                                       0x244
+#define MV64340_SMP_SEMAPHOR1                                       0x24c
+#define MV64340_SMP_SEMAPHOR2                                       0x254
+#define MV64340_SMP_SEMAPHOR3                                       0x25c
+#define MV64340_SMP_SEMAPHOR4                                       0x264
+#define MV64340_SMP_SEMAPHOR5                                       0x26c
+#define MV64340_SMP_SEMAPHOR6                                       0x274
+#define MV64340_SMP_SEMAPHOR7                                       0x27c
+
+/****************************************/
+/*  CPU Sync Barrier Register           */
+/****************************************/
+
+#define MV64340_CPU_0_SYNC_BARRIER_TRIGGER                          0x0c0
+#define MV64340_CPU_0_SYNC_BARRIER_VIRTUAL                          0x0c8
+#define MV64340_CPU_1_SYNC_BARRIER_TRIGGER                          0x0d0
+#define MV64340_CPU_1_SYNC_BARRIER_VIRTUAL                          0x0d8
+
+/****************************************/
+/* CPU Access Protect                   */
+/****************************************/
+
+#define MV64340_CPU_PROTECT_WINDOW_0_BASE_ADDR                      0x180
+#define MV64340_CPU_PROTECT_WINDOW_0_SIZE                           0x188
+#define MV64340_CPU_PROTECT_WINDOW_1_BASE_ADDR                      0x190
+#define MV64340_CPU_PROTECT_WINDOW_1_SIZE                           0x198
+#define MV64340_CPU_PROTECT_WINDOW_2_BASE_ADDR                      0x1a0
+#define MV64340_CPU_PROTECT_WINDOW_2_SIZE                           0x1a8
+#define MV64340_CPU_PROTECT_WINDOW_3_BASE_ADDR                      0x1b0
+#define MV64340_CPU_PROTECT_WINDOW_3_SIZE                           0x1b8
+
+
+/****************************************/
+/*          CPU Error Report            */
+/****************************************/
+
+#define MV64340_CPU_ERROR_ADDR_LOW                                  0x070
+#define MV64340_CPU_ERROR_ADDR_HIGH                                 0x078
+#define MV64340_CPU_ERROR_DATA_LOW                                  0x128
+#define MV64340_CPU_ERROR_DATA_HIGH                                 0x130
+#define MV64340_CPU_ERROR_PARITY                                    0x138
+#define MV64340_CPU_ERROR_CAUSE                                     0x140
+#define MV64340_CPU_ERROR_MASK                                      0x148
+
+/****************************************/
+/*      CPU Interface Debug Registers   */
+/****************************************/
+
+#define MV64340_PUNIT_SLAVE_DEBUG_LOW                               0x360
+#define MV64340_PUNIT_SLAVE_DEBUG_HIGH                              0x368
+#define MV64340_PUNIT_MASTER_DEBUG_LOW                              0x370
+#define MV64340_PUNIT_MASTER_DEBUG_HIGH                             0x378
+#define MV64340_PUNIT_MMASK                                         0x3e4
+
+/****************************************/
+/*  Integrated SRAM Registers           */
+/****************************************/
+
+#define MV64340_SRAM_CONFIG                                         0x380
+#define MV64340_SRAM_TEST_MODE                                      0X3F4
+#define MV64340_SRAM_ERROR_CAUSE                                    0x388
+#define MV64340_SRAM_ERROR_ADDR                                     0x390
+#define MV64340_SRAM_ERROR_ADDR_HIGH                                0X3F8
+#define MV64340_SRAM_ERROR_DATA_LOW                                 0x398
+#define MV64340_SRAM_ERROR_DATA_HIGH                                0x3a0
+#define MV64340_SRAM_ERROR_DATA_PARITY                              0x3a8
+
+/****************************************/
+/* SDRAM Configuration                  */
+/****************************************/
+
+#define MV64340_SDRAM_CONFIG                                        0x1400
+#define MV64340_D_UNIT_CONTROL_LOW                                  0x1404
+#define MV64340_D_UNIT_CONTROL_HIGH                                 0x1424
+#define MV64340_SDRAM_TIMING_CONTROL_LOW                            0x1408
+#define MV64340_SDRAM_TIMING_CONTROL_HIGH                           0x140c
+#define MV64340_SDRAM_ADDR_CONTROL                                  0x1410
+#define MV64340_SDRAM_OPEN_PAGES_CONTROL                            0x1414
+#define MV64340_SDRAM_OPERATION                                     0x1418
+#define MV64340_SDRAM_MODE                                          0x141c
+#define MV64340_EXTENDED_DRAM_MODE                                  0x1420
+#define MV64340_SDRAM_CROSS_BAR_CONTROL_LOW                         0x1430
+#define MV64340_SDRAM_CROSS_BAR_CONTROL_HIGH                        0x1434
+#define MV64340_SDRAM_CROSS_BAR_TIMEOUT                             0x1438
+#define MV64340_SDRAM_ADDR_CTRL_PADS_CALIBRATION                    0x14c0
+#define MV64340_SDRAM_DATA_PADS_CALIBRATION                         0x14c4
+
+/****************************************/
+/* SDRAM Error Report                   */
+/****************************************/
+
+#define MV64340_SDRAM_ERROR_DATA_LOW                                0x1444
+#define MV64340_SDRAM_ERROR_DATA_HIGH                               0x1440
+#define MV64340_SDRAM_ERROR_ADDR                                    0x1450
+#define MV64340_SDRAM_RECEIVED_ECC                                  0x1448
+#define MV64340_SDRAM_CALCULATED_ECC                                0x144c
+#define MV64340_SDRAM_ECC_CONTROL                                   0x1454
+#define MV64340_SDRAM_ECC_ERROR_COUNTER                             0x1458
+
+/******************************************/
+/*  Controlled Delay Line (CDL) Registers */
+/******************************************/
+
+#define MV64340_DFCDL_CONFIG0                                       0x1480
+#define MV64340_DFCDL_CONFIG1                                       0x1484
+#define MV64340_DLL_WRITE                                           0x1488
+#define MV64340_DLL_READ                                            0x148c
+#define MV64340_SRAM_ADDR                                           0x1490
+#define MV64340_SRAM_DATA0                                          0x1494
+#define MV64340_SRAM_DATA1                                          0x1498
+#define MV64340_SRAM_DATA2                                          0x149c
+#define MV64340_DFCL_PROBE                                          0x14a0
+
+/******************************************/
+/*   Debug Registers                      */
+/******************************************/
+
+#define MV64340_DUNIT_DEBUG_LOW                                     0x1460
+#define MV64340_DUNIT_DEBUG_HIGH                                    0x1464
+#define MV64340_DUNIT_MMASK                                         0X1b40
+
+/****************************************/
+/* Device Parameters                    */
+/****************************************/
+
+#define MV64340_DEVICE_BANK0_PARAMETERS                             0x45c
+#define MV64340_DEVICE_BANK1_PARAMETERS                             0x460
+#define MV64340_DEVICE_BANK2_PARAMETERS                             0x464
+#define MV64340_DEVICE_BANK3_PARAMETERS                             0x468
+#define MV64340_DEVICE_BOOT_BANK_PARAMETERS                         0x46c
+#define MV64340_DEVICE_INTERFACE_CONTROL                            0x4c0
+#define MV64340_DEVICE_INTERFACE_CROSS_BAR_CONTROL_LOW              0x4c8
+#define MV64340_DEVICE_INTERFACE_CROSS_BAR_CONTROL_HIGH             0x4cc
+#define MV64340_DEVICE_INTERFACE_CROSS_BAR_TIMEOUT                  0x4c4
+
+/****************************************/
+/* Device interrupt registers           */
+/****************************************/
+
+#define MV64340_DEVICE_INTERRUPT_CAUSE                              0x4d0
+#define MV64340_DEVICE_INTERRUPT_MASK                               0x4d4
+#define MV64340_DEVICE_ERROR_ADDR                                   0x4d8
+#define MV64340_DEVICE_ERROR_DATA                                   0x4dc
+#define MV64340_DEVICE_ERROR_PARITY                                 0x4e0
+
+/****************************************/
+/* Device debug registers               */
+/****************************************/
+
+#define MV64340_DEVICE_DEBUG_LOW                                    0x4e4
+#define MV64340_DEVICE_DEBUG_HIGH                                   0x4e8
+#define MV64340_RUNIT_MMASK                                         0x4f0
+
+/****************************************/
+/* PCI Slave Address Decoding registers */
+/****************************************/
+
+#define MV64340_PCI_0_CS_0_BANK_SIZE                                0xc08
+#define MV64340_PCI_1_CS_0_BANK_SIZE                                0xc88
+#define MV64340_PCI_0_CS_1_BANK_SIZE                                0xd08
+#define MV64340_PCI_1_CS_1_BANK_SIZE                                0xd88
+#define MV64340_PCI_0_CS_2_BANK_SIZE                                0xc0c
+#define MV64340_PCI_1_CS_2_BANK_SIZE                                0xc8c
+#define MV64340_PCI_0_CS_3_BANK_SIZE                                0xd0c
+#define MV64340_PCI_1_CS_3_BANK_SIZE                                0xd8c
+#define MV64340_PCI_0_DEVCS_0_BANK_SIZE                             0xc10
+#define MV64340_PCI_1_DEVCS_0_BANK_SIZE                             0xc90
+#define MV64340_PCI_0_DEVCS_1_BANK_SIZE                             0xd10
+#define MV64340_PCI_1_DEVCS_1_BANK_SIZE                             0xd90
+#define MV64340_PCI_0_DEVCS_2_BANK_SIZE                             0xd18
+#define MV64340_PCI_1_DEVCS_2_BANK_SIZE                             0xd98
+#define MV64340_PCI_0_DEVCS_3_BANK_SIZE                             0xc14
+#define MV64340_PCI_1_DEVCS_3_BANK_SIZE                             0xc94
+#define MV64340_PCI_0_DEVCS_BOOT_BANK_SIZE                          0xd14
+#define MV64340_PCI_1_DEVCS_BOOT_BANK_SIZE                          0xd94
+#define MV64340_PCI_0_P2P_MEM0_BAR_SIZE                             0xd1c
+#define MV64340_PCI_1_P2P_MEM0_BAR_SIZE                             0xd9c
+#define MV64340_PCI_0_P2P_MEM1_BAR_SIZE                             0xd20
+#define MV64340_PCI_1_P2P_MEM1_BAR_SIZE                             0xda0
+#define MV64340_PCI_0_P2P_I_O_BAR_SIZE                              0xd24
+#define MV64340_PCI_1_P2P_I_O_BAR_SIZE                              0xda4
+#define MV64340_PCI_0_CPU_BAR_SIZE                                  0xd28
+#define MV64340_PCI_1_CPU_BAR_SIZE                                  0xda8
+#define MV64340_PCI_0_INTERNAL_SRAM_BAR_SIZE                        0xe00
+#define MV64340_PCI_1_INTERNAL_SRAM_BAR_SIZE                        0xe80
+#define MV64340_PCI_0_EXPANSION_ROM_BAR_SIZE                        0xd2c
+#define MV64340_PCI_1_EXPANSION_ROM_BAR_SIZE                        0xd9c
+#define MV64340_PCI_0_BASE_ADDR_REG_ENABLE                          0xc3c
+#define MV64340_PCI_1_BASE_ADDR_REG_ENABLE                          0xcbc
+#define MV64340_PCI_0_CS_0_BASE_ADDR_REMAP                          0xc48
+#define MV64340_PCI_1_CS_0_BASE_ADDR_REMAP                          0xcc8
+#define MV64340_PCI_0_CS_1_BASE_ADDR_REMAP                          0xd48
+#define MV64340_PCI_1_CS_1_BASE_ADDR_REMAP                          0xdc8
+#define MV64340_PCI_0_CS_2_BASE_ADDR_REMAP                          0xc4c
+#define MV64340_PCI_1_CS_2_BASE_ADDR_REMAP                          0xccc
+#define MV64340_PCI_0_CS_3_BASE_ADDR_REMAP                          0xd4c
+#define MV64340_PCI_1_CS_3_BASE_ADDR_REMAP                          0xdcc
+#define MV64340_PCI_0_CS_0_BASE_HIGH_ADDR_REMAP                     0xF04
+#define MV64340_PCI_1_CS_0_BASE_HIGH_ADDR_REMAP                     0xF84
+#define MV64340_PCI_0_CS_1_BASE_HIGH_ADDR_REMAP                     0xF08
+#define MV64340_PCI_1_CS_1_BASE_HIGH_ADDR_REMAP                     0xF88
+#define MV64340_PCI_0_CS_2_BASE_HIGH_ADDR_REMAP                     0xF0C
+#define MV64340_PCI_1_CS_2_BASE_HIGH_ADDR_REMAP                     0xF8C
+#define MV64340_PCI_0_CS_3_BASE_HIGH_ADDR_REMAP                     0xF10
+#define MV64340_PCI_1_CS_3_BASE_HIGH_ADDR_REMAP                     0xF90
+#define MV64340_PCI_0_DEVCS_0_BASE_ADDR_REMAP                       0xc50
+#define MV64340_PCI_1_DEVCS_0_BASE_ADDR_REMAP                       0xcd0
+#define MV64340_PCI_0_DEVCS_1_BASE_ADDR_REMAP                       0xd50
+#define MV64340_PCI_1_DEVCS_1_BASE_ADDR_REMAP                       0xdd0
+#define MV64340_PCI_0_DEVCS_2_BASE_ADDR_REMAP                       0xd58
+#define MV64340_PCI_1_DEVCS_2_BASE_ADDR_REMAP                       0xdd8
+#define MV64340_PCI_0_DEVCS_3_BASE_ADDR_REMAP                       0xc54
+#define MV64340_PCI_1_DEVCS_3_BASE_ADDR_REMAP                       0xcd4
+#define MV64340_PCI_0_DEVCS_BOOTCS_BASE_ADDR_REMAP                  0xd54
+#define MV64340_PCI_1_DEVCS_BOOTCS_BASE_ADDR_REMAP                  0xdd4
+#define MV64340_PCI_0_P2P_MEM0_BASE_ADDR_REMAP_LOW                  0xd5c
+#define MV64340_PCI_1_P2P_MEM0_BASE_ADDR_REMAP_LOW                  0xddc
+#define MV64340_PCI_0_P2P_MEM0_BASE_ADDR_REMAP_HIGH                 0xd60
+#define MV64340_PCI_1_P2P_MEM0_BASE_ADDR_REMAP_HIGH                 0xde0
+#define MV64340_PCI_0_P2P_MEM1_BASE_ADDR_REMAP_LOW                  0xd64
+#define MV64340_PCI_1_P2P_MEM1_BASE_ADDR_REMAP_LOW                  0xde4
+#define MV64340_PCI_0_P2P_MEM1_BASE_ADDR_REMAP_HIGH                 0xd68
+#define MV64340_PCI_1_P2P_MEM1_BASE_ADDR_REMAP_HIGH                 0xde8
+#define MV64340_PCI_0_P2P_I_O_BASE_ADDR_REMAP                       0xd6c
+#define MV64340_PCI_1_P2P_I_O_BASE_ADDR_REMAP                       0xdec 
+#define MV64340_PCI_0_CPU_BASE_ADDR_REMAP_LOW                       0xd70
+#define MV64340_PCI_1_CPU_BASE_ADDR_REMAP_LOW                       0xdf0
+#define MV64340_PCI_0_CPU_BASE_ADDR_REMAP_HIGH                      0xd74
+#define MV64340_PCI_1_CPU_BASE_ADDR_REMAP_HIGH                      0xdf4
+#define MV64340_PCI_0_INTEGRATED_SRAM_BASE_ADDR_REMAP               0xf00
+#define MV64340_PCI_1_INTEGRATED_SRAM_BASE_ADDR_REMAP               0xf80
+#define MV64340_PCI_0_EXPANSION_ROM_BASE_ADDR_REMAP                 0xf38
+#define MV64340_PCI_1_EXPANSION_ROM_BASE_ADDR_REMAP                 0xfb8
+#define MV64340_PCI_0_ADDR_DECODE_CONTROL                           0xd3c
+#define MV64340_PCI_1_ADDR_DECODE_CONTROL                           0xdbc
+#define MV64340_PCI_0_HEADERS_RETARGET_CONTROL                      0xF40
+#define MV64340_PCI_1_HEADERS_RETARGET_CONTROL                      0xFc0
+#define MV64340_PCI_0_HEADERS_RETARGET_BASE                         0xF44
+#define MV64340_PCI_1_HEADERS_RETARGET_BASE                         0xFc4
+#define MV64340_PCI_0_HEADERS_RETARGET_HIGH                         0xF48
+#define MV64340_PCI_1_HEADERS_RETARGET_HIGH                         0xFc8
+
+/***********************************/
+/*   PCI Control Register Map      */
+/***********************************/
+
+#define MV64340_PCI_0_DLL_STATUS_AND_COMMAND                        0x1d20
+#define MV64340_PCI_1_DLL_STATUS_AND_COMMAND                        0x1da0
+#define MV64340_PCI_0_MPP_PADS_DRIVE_CONTROL                        0x1d1C
+#define MV64340_PCI_1_MPP_PADS_DRIVE_CONTROL                        0x1d9C
+#define MV64340_PCI_0_COMMAND                                       0xc00
+#define MV64340_PCI_1_COMMAND                                       0xc80
+#define MV64340_PCI_0_MODE                                          0xd00
+#define MV64340_PCI_1_MODE                                          0xd80
+#define MV64340_PCI_0_RETRY                                         0xc04
+#define MV64340_PCI_1_RETRY                                         0xc84
+#define MV64340_PCI_0_READ_BUFFER_DISCARD_TIMER                     0xd04
+#define MV64340_PCI_1_READ_BUFFER_DISCARD_TIMER                     0xd84
+#define MV64340_PCI_0_MSI_TRIGGER_TIMER                             0xc38
+#define MV64340_PCI_1_MSI_TRIGGER_TIMER                             0xcb8
+#define MV64340_PCI_0_ARBITER_CONTROL                               0x1d00
+#define MV64340_PCI_1_ARBITER_CONTROL                               0x1d80
+#define MV64340_PCI_0_CROSS_BAR_CONTROL_LOW                         0x1d08
+#define MV64340_PCI_1_CROSS_BAR_CONTROL_LOW                         0x1d88
+#define MV64340_PCI_0_CROSS_BAR_CONTROL_HIGH                        0x1d0c
+#define MV64340_PCI_1_CROSS_BAR_CONTROL_HIGH                        0x1d8c
+#define MV64340_PCI_0_CROSS_BAR_TIMEOUT                             0x1d04
+#define MV64340_PCI_1_CROSS_BAR_TIMEOUT                             0x1d84
+#define MV64340_PCI_0_SYNC_BARRIER_TRIGGER_REG                      0x1D18
+#define MV64340_PCI_1_SYNC_BARRIER_TRIGGER_REG                      0x1D98
+#define MV64340_PCI_0_SYNC_BARRIER_VIRTUAL_REG                      0x1d10
+#define MV64340_PCI_1_SYNC_BARRIER_VIRTUAL_REG                      0x1d90
+#define MV64340_PCI_0_P2P_CONFIG                                    0x1d14
+#define MV64340_PCI_1_P2P_CONFIG                                    0x1d94
+
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_0_LOW                     0x1e00
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_0_HIGH                    0x1e04
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_0                         0x1e08
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_1_LOW                     0x1e10
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_1_HIGH                    0x1e14
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_1                         0x1e18
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_2_LOW                     0x1e20
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_2_HIGH                    0x1e24
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_2                         0x1e28
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_3_LOW                     0x1e30
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_3_HIGH                    0x1e34
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_3                         0x1e38
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_4_LOW                     0x1e40
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_4_HIGH                    0x1e44
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_4                         0x1e48
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_5_LOW                     0x1e50
+#define MV64340_PCI_0_ACCESS_CONTROL_BASE_5_HIGH                    0x1e54
+#define MV64340_PCI_0_ACCESS_CONTROL_SIZE_5                         0x1e58
+
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_0_LOW                     0x1e80
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_0_HIGH                    0x1e84
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_0                         0x1e88
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_1_LOW                     0x1e90
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_1_HIGH                    0x1e94
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_1                         0x1e98
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_2_LOW                     0x1ea0
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_2_HIGH                    0x1ea4
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_2                         0x1ea8
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_3_LOW                     0x1eb0
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_3_HIGH                    0x1eb4
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_3                         0x1eb8
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_4_LOW                     0x1ec0
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_4_HIGH                    0x1ec4
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_4                         0x1ec8
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_5_LOW                     0x1ed0
+#define MV64340_PCI_1_ACCESS_CONTROL_BASE_5_HIGH                    0x1ed4
+#define MV64340_PCI_1_ACCESS_CONTROL_SIZE_5                         0x1ed8
+
+/****************************************/
+/*   PCI Configuration Access Registers */
+/****************************************/
+
+#define MV64340_PCI_0_CONFIG_ADDR                                   0xcf8
+#define MV64340_PCI_0_CONFIG_DATA_VIRTUAL_REG                       0xcfc
+#define MV64340_PCI_1_CONFIG_ADDR                                   0xc78
+#define MV64340_PCI_1_CONFIG_DATA_VIRTUAL_REG                       0xc7c
+#define MV64340_PCI_0_INTERRUPT_ACKNOWLEDGE_VIRTUAL_REG             0xc34
+#define MV64340_PCI_1_INTERRUPT_ACKNOWLEDGE_VIRTUAL_REG             0xcb4
+
+/****************************************/
+/*   PCI Error Report Registers         */
+/****************************************/
+
+#define MV64340_PCI_0_SERR_MASK                                     0xc28
+#define MV64340_PCI_1_SERR_MASK                                     0xca8
+#define MV64340_PCI_0_ERROR_ADDR_LOW                                0x1d40
+#define MV64340_PCI_1_ERROR_ADDR_LOW                                0x1dc0
+#define MV64340_PCI_0_ERROR_ADDR_HIGH                               0x1d44
+#define MV64340_PCI_1_ERROR_ADDR_HIGH                               0x1dc4
+#define MV64340_PCI_0_ERROR_ATTRIBUTE                               0x1d48
+#define MV64340_PCI_1_ERROR_ATTRIBUTE                               0x1dc8
+#define MV64340_PCI_0_ERROR_COMMAND                                 0x1d50
+#define MV64340_PCI_1_ERROR_COMMAND                                 0x1dd0
+#define MV64340_PCI_0_ERROR_CAUSE                                   0x1d58
+#define MV64340_PCI_1_ERROR_CAUSE                                   0x1dd8
+#define MV64340_PCI_0_ERROR_MASK                                    0x1d5c
+#define MV64340_PCI_1_ERROR_MASK                                    0x1ddc
+
+/****************************************/
+/*   PCI Debug Registers                */
+/****************************************/
+
+#define MV64340_PCI_0_MMASK                                         0X1D24
+#define MV64340_PCI_1_MMASK                                         0X1DA4
+
+/*********************************************/
+/* PCI Configuration, Function 0, Registers  */
+/*********************************************/
+
+#define MV64340_PCI_DEVICE_AND_VENDOR_ID                            0x000
+#define MV64340_PCI_STATUS_AND_COMMAND                              0x004
+#define MV64340_PCI_CLASS_CODE_AND_REVISION_ID                      0x008
+#define MV64340_PCI_BIST_HEADER_TYPE_LATENCY_TIMER_CACHE_LINE       0x00C
+
+#define MV64340_PCI_SCS_0_BASE_ADDR_LOW                             0x010
+#define MV64340_PCI_SCS_0_BASE_ADDR_HIGH                            0x014
+#define MV64340_PCI_SCS_1_BASE_ADDR_LOW                             0x018
+#define MV64340_PCI_SCS_1_BASE_ADDR_HIGH                            0x01C
+#define MV64340_PCI_INTERNAL_REG_MEM_MAPPED_BASE_ADDR_LOW           0x020
+#define MV64340_PCI_INTERNAL_REG_MEM_MAPPED_BASE_ADDR_HIGH          0x024
+#define MV64340_PCI_SUBSYSTEM_ID_AND_SUBSYSTEM_VENDOR_ID            0x02c
+#define MV64340_PCI_EXPANSION_ROM_BASE_ADDR_REG                     0x030
+#define MV64340_PCI_CAPABILTY_LIST_POINTER                          0x034
+#define MV64340_PCI_INTERRUPT_PIN_AND_LINE                          0x03C
+       /* capability list */
+#define MV64340_PCI_POWER_MANAGEMENT_CAPABILITY                     0x040
+#define MV64340_PCI_POWER_MANAGEMENT_STATUS_AND_CONTROL             0x044
+#define MV64340_PCI_VPD_ADDR                                        0x048
+#define MV64340_PCI_VPD_DATA                                        0x04c
+#define MV64340_PCI_MSI_MESSAGE_CONTROL                             0x050
+#define MV64340_PCI_MSI_MESSAGE_ADDR                                0x054
+#define MV64340_PCI_MSI_MESSAGE_UPPER_ADDR                          0x058
+#define MV64340_PCI_MSI_MESSAGE_DATA                                0x05c
+#define MV64340_PCI_X_COMMAND                                       0x060
+#define MV64340_PCI_X_STATUS                                        0x064
+#define MV64340_PCI_COMPACT_PCI_HOT_SWAP                            0x068
+
+/***********************************************/
+/*   PCI Configuration, Function 1, Registers  */
+/***********************************************/
+
+#define MV64340_PCI_SCS_2_BASE_ADDR_LOW                             0x110
+#define MV64340_PCI_SCS_2_BASE_ADDR_HIGH                            0x114
+#define MV64340_PCI_SCS_3_BASE_ADDR_LOW                             0x118
+#define MV64340_PCI_SCS_3_BASE_ADDR_HIGH                            0x11c
+#define MV64340_PCI_INTERNAL_SRAM_BASE_ADDR_LOW                     0x120
+#define MV64340_PCI_INTERNAL_SRAM_BASE_ADDR_HIGH                    0x124
+
+/***********************************************/
+/*  PCI Configuration, Function 2, Registers   */
+/***********************************************/
+
+#define MV64340_PCI_DEVCS_0_BASE_ADDR_LOW                           0x210
+#define MV64340_PCI_DEVCS_0_BASE_ADDR_HIGH                          0x214
+#define MV64340_PCI_DEVCS_1_BASE_ADDR_LOW                           0x218
+#define MV64340_PCI_DEVCS_1_BASE_ADDR_HIGH                          0x21c
+#define MV64340_PCI_DEVCS_2_BASE_ADDR_LOW                           0x220
+#define MV64340_PCI_DEVCS_2_BASE_ADDR_HIGH                          0x224
+
+/***********************************************/
+/*  PCI Configuration, Function 3, Registers   */
+/***********************************************/
+
+#define MV64340_PCI_DEVCS_3_BASE_ADDR_LOW                           0x310
+#define MV64340_PCI_DEVCS_3_BASE_ADDR_HIGH                          0x314
+#define MV64340_PCI_BOOT_CS_BASE_ADDR_LOW                           0x318
+#define MV64340_PCI_BOOT_CS_BASE_ADDR_HIGH                          0x31c
+#define MV64340_PCI_CPU_BASE_ADDR_LOW                               0x220
+#define MV64340_PCI_CPU_BASE_ADDR_HIGH                              0x224
+
+/***********************************************/
+/*  PCI Configuration, Function 4, Registers   */
+/***********************************************/
+
+#define MV64340_PCI_P2P_MEM0_BASE_ADDR_LOW                          0x410
+#define MV64340_PCI_P2P_MEM0_BASE_ADDR_HIGH                         0x414
+#define MV64340_PCI_P2P_MEM1_BASE_ADDR_LOW                          0x418
+#define MV64340_PCI_P2P_MEM1_BASE_ADDR_HIGH                         0x41c
+#define MV64340_PCI_P2P_I_O_BASE_ADDR                               0x420
+#define MV64340_PCI_INTERNAL_REGS_I_O_MAPPED_BASE_ADDR              0x424
+
+/****************************************/
+/* Messaging Unit Registers (I20)       */
+/****************************************/
+
+#define MV64340_I2O_INBOUND_MESSAGE_REG0_PCI_0_SIDE                 0x010
+#define MV64340_I2O_INBOUND_MESSAGE_REG1_PCI_0_SIDE                 0x014
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG0_PCI_0_SIDE                0x018
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG1_PCI_0_SIDE                0x01C
+#define MV64340_I2O_INBOUND_DOORBELL_REG_PCI_0_SIDE                 0x020
+#define MV64340_I2O_INBOUND_INTERRUPT_CAUSE_REG_PCI_0_SIDE          0x024
+#define MV64340_I2O_INBOUND_INTERRUPT_MASK_REG_PCI_0_SIDE           0x028
+#define MV64340_I2O_OUTBOUND_DOORBELL_REG_PCI_0_SIDE                0x02C
+#define MV64340_I2O_OUTBOUND_INTERRUPT_CAUSE_REG_PCI_0_SIDE         0x030
+#define MV64340_I2O_OUTBOUND_INTERRUPT_MASK_REG_PCI_0_SIDE          0x034
+#define MV64340_I2O_INBOUND_QUEUE_PORT_VIRTUAL_REG_PCI_0_SIDE       0x040
+#define MV64340_I2O_OUTBOUND_QUEUE_PORT_VIRTUAL_REG_PCI_0_SIDE      0x044
+#define MV64340_I2O_QUEUE_CONTROL_REG_PCI_0_SIDE                    0x050
+#define MV64340_I2O_QUEUE_BASE_ADDR_REG_PCI_0_SIDE                  0x054
+#define MV64340_I2O_INBOUND_FREE_HEAD_POINTER_REG_PCI_0_SIDE        0x060
+#define MV64340_I2O_INBOUND_FREE_TAIL_POINTER_REG_PCI_0_SIDE        0x064
+#define MV64340_I2O_INBOUND_POST_HEAD_POINTER_REG_PCI_0_SIDE        0x068
+#define MV64340_I2O_INBOUND_POST_TAIL_POINTER_REG_PCI_0_SIDE        0x06C
+#define MV64340_I2O_OUTBOUND_FREE_HEAD_POINTER_REG_PCI_0_SIDE       0x070
+#define MV64340_I2O_OUTBOUND_FREE_TAIL_POINTER_REG_PCI_0_SIDE       0x074
+#define MV64340_I2O_OUTBOUND_POST_HEAD_POINTER_REG_PCI_0_SIDE       0x0F8
+#define MV64340_I2O_OUTBOUND_POST_TAIL_POINTER_REG_PCI_0_SIDE       0x0FC
+
+#define MV64340_I2O_INBOUND_MESSAGE_REG0_PCI_1_SIDE                 0x090
+#define MV64340_I2O_INBOUND_MESSAGE_REG1_PCI_1_SIDE                 0x094
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG0_PCI_1_SIDE                0x098
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG1_PCI_1_SIDE                0x09C
+#define MV64340_I2O_INBOUND_DOORBELL_REG_PCI_1_SIDE                 0x0A0
+#define MV64340_I2O_INBOUND_INTERRUPT_CAUSE_REG_PCI_1_SIDE          0x0A4
+#define MV64340_I2O_INBOUND_INTERRUPT_MASK_REG_PCI_1_SIDE           0x0A8
+#define MV64340_I2O_OUTBOUND_DOORBELL_REG_PCI_1_SIDE                0x0AC
+#define MV64340_I2O_OUTBOUND_INTERRUPT_CAUSE_REG_PCI_1_SIDE         0x0B0
+#define MV64340_I2O_OUTBOUND_INTERRUPT_MASK_REG_PCI_1_SIDE          0x0B4
+#define MV64340_I2O_INBOUND_QUEUE_PORT_VIRTUAL_REG_PCI_1_SIDE       0x0C0
+#define MV64340_I2O_OUTBOUND_QUEUE_PORT_VIRTUAL_REG_PCI_1_SIDE      0x0C4
+#define MV64340_I2O_QUEUE_CONTROL_REG_PCI_1_SIDE                    0x0D0
+#define MV64340_I2O_QUEUE_BASE_ADDR_REG_PCI_1_SIDE                  0x0D4
+#define MV64340_I2O_INBOUND_FREE_HEAD_POINTER_REG_PCI_1_SIDE        0x0E0
+#define MV64340_I2O_INBOUND_FREE_TAIL_POINTER_REG_PCI_1_SIDE        0x0E4
+#define MV64340_I2O_INBOUND_POST_HEAD_POINTER_REG_PCI_1_SIDE        0x0E8
+#define MV64340_I2O_INBOUND_POST_TAIL_POINTER_REG_PCI_1_SIDE        0x0EC
+#define MV64340_I2O_OUTBOUND_FREE_HEAD_POINTER_REG_PCI_1_SIDE       0x0F0
+#define MV64340_I2O_OUTBOUND_FREE_TAIL_POINTER_REG_PCI_1_SIDE       0x0F4
+#define MV64340_I2O_OUTBOUND_POST_HEAD_POINTER_REG_PCI_1_SIDE       0x078
+#define MV64340_I2O_OUTBOUND_POST_TAIL_POINTER_REG_PCI_1_SIDE       0x07C
+
+#define MV64340_I2O_INBOUND_MESSAGE_REG0_CPU0_SIDE                  0x1C10
+#define MV64340_I2O_INBOUND_MESSAGE_REG1_CPU0_SIDE                  0x1C14
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG0_CPU0_SIDE                 0x1C18
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG1_CPU0_SIDE                 0x1C1C
+#define MV64340_I2O_INBOUND_DOORBELL_REG_CPU0_SIDE                  0x1C20
+#define MV64340_I2O_INBOUND_INTERRUPT_CAUSE_REG_CPU0_SIDE           0x1C24
+#define MV64340_I2O_INBOUND_INTERRUPT_MASK_REG_CPU0_SIDE            0x1C28
+#define MV64340_I2O_OUTBOUND_DOORBELL_REG_CPU0_SIDE                 0x1C2C
+#define MV64340_I2O_OUTBOUND_INTERRUPT_CAUSE_REG_CPU0_SIDE          0x1C30
+#define MV64340_I2O_OUTBOUND_INTERRUPT_MASK_REG_CPU0_SIDE           0x1C34
+#define MV64340_I2O_INBOUND_QUEUE_PORT_VIRTUAL_REG_CPU0_SIDE        0x1C40
+#define MV64340_I2O_OUTBOUND_QUEUE_PORT_VIRTUAL_REG_CPU0_SIDE       0x1C44
+#define MV64340_I2O_QUEUE_CONTROL_REG_CPU0_SIDE                     0x1C50
+#define MV64340_I2O_QUEUE_BASE_ADDR_REG_CPU0_SIDE                   0x1C54
+#define MV64340_I2O_INBOUND_FREE_HEAD_POINTER_REG_CPU0_SIDE         0x1C60
+#define MV64340_I2O_INBOUND_FREE_TAIL_POINTER_REG_CPU0_SIDE         0x1C64
+#define MV64340_I2O_INBOUND_POST_HEAD_POINTER_REG_CPU0_SIDE         0x1C68
+#define MV64340_I2O_INBOUND_POST_TAIL_POINTER_REG_CPU0_SIDE         0x1C6C
+#define MV64340_I2O_OUTBOUND_FREE_HEAD_POINTER_REG_CPU0_SIDE        0x1C70
+#define MV64340_I2O_OUTBOUND_FREE_TAIL_POINTER_REG_CPU0_SIDE        0x1C74
+#define MV64340_I2O_OUTBOUND_POST_HEAD_POINTER_REG_CPU0_SIDE        0x1CF8
+#define MV64340_I2O_OUTBOUND_POST_TAIL_POINTER_REG_CPU0_SIDE        0x1CFC
+#define MV64340_I2O_INBOUND_MESSAGE_REG0_CPU1_SIDE                  0x1C90
+#define MV64340_I2O_INBOUND_MESSAGE_REG1_CPU1_SIDE                  0x1C94
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG0_CPU1_SIDE                 0x1C98
+#define MV64340_I2O_OUTBOUND_MESSAGE_REG1_CPU1_SIDE                 0x1C9C
+#define MV64340_I2O_INBOUND_DOORBELL_REG_CPU1_SIDE                  0x1CA0
+#define MV64340_I2O_INBOUND_INTERRUPT_CAUSE_REG_CPU1_SIDE           0x1CA4
+#define MV64340_I2O_INBOUND_INTERRUPT_MASK_REG_CPU1_SIDE            0x1CA8
+#define MV64340_I2O_OUTBOUND_DOORBELL_REG_CPU1_SIDE                 0x1CAC
+#define MV64340_I2O_OUTBOUND_INTERRUPT_CAUSE_REG_CPU1_SIDE          0x1CB0
+#define MV64340_I2O_OUTBOUND_INTERRUPT_MASK_REG_CPU1_SIDE           0x1CB4
+#define MV64340_I2O_INBOUND_QUEUE_PORT_VIRTUAL_REG_CPU1_SIDE        0x1CC0
+#define MV64340_I2O_OUTBOUND_QUEUE_PORT_VIRTUAL_REG_CPU1_SIDE       0x1CC4
+#define MV64340_I2O_QUEUE_CONTROL_REG_CPU1_SIDE                     0x1CD0
+#define MV64340_I2O_QUEUE_BASE_ADDR_REG_CPU1_SIDE                   0x1CD4
+#define MV64340_I2O_INBOUND_FREE_HEAD_POINTER_REG_CPU1_SIDE         0x1CE0
+#define MV64340_I2O_INBOUND_FREE_TAIL_POINTER_REG_CPU1_SIDE         0x1CE4
+#define MV64340_I2O_INBOUND_POST_HEAD_POINTER_REG_CPU1_SIDE         0x1CE8
+#define MV64340_I2O_INBOUND_POST_TAIL_POINTER_REG_CPU1_SIDE         0x1CEC
+#define MV64340_I2O_OUTBOUND_FREE_HEAD_POINTER_REG_CPU1_SIDE        0x1CF0
+#define MV64340_I2O_OUTBOUND_FREE_TAIL_POINTER_REG_CPU1_SIDE        0x1CF4
+#define MV64340_I2O_OUTBOUND_POST_HEAD_POINTER_REG_CPU1_SIDE        0x1C78
+#define MV64340_I2O_OUTBOUND_POST_TAIL_POINTER_REG_CPU1_SIDE        0x1C7C
+
+/****************************************/
+/*        Ethernet Unit Registers               */
+/****************************************/
+
+#define MV643XX_ETH_SHARED_REGS                                     0x2000
+#define MV643XX_ETH_SHARED_REGS_SIZE                                0x2000
+
+#define MV643XX_ETH_PHY_ADDR_REG                                    0x2000
+#define MV643XX_ETH_SMI_REG                                         0x2004
+#define MV643XX_ETH_UNIT_DEFAULT_ADDR_REG                           0x2008
+#define MV643XX_ETH_UNIT_DEFAULTID_REG                              0x200c
+#define MV643XX_ETH_UNIT_INTERRUPT_CAUSE_REG                        0x2080
+#define MV643XX_ETH_UNIT_INTERRUPT_MASK_REG                         0x2084
+#define MV643XX_ETH_UNIT_INTERNAL_USE_REG                           0x24fc
+#define MV643XX_ETH_UNIT_ERROR_ADDR_REG                             0x2094
+#define MV643XX_ETH_BAR_0                                           0x2200
+#define MV643XX_ETH_BAR_1                                           0x2208
+#define MV643XX_ETH_BAR_2                                           0x2210
+#define MV643XX_ETH_BAR_3                                           0x2218
+#define MV643XX_ETH_BAR_4                                           0x2220
+#define MV643XX_ETH_BAR_5                                           0x2228
+#define MV643XX_ETH_SIZE_REG_0                                      0x2204
+#define MV643XX_ETH_SIZE_REG_1                                      0x220c
+#define MV643XX_ETH_SIZE_REG_2                                      0x2214
+#define MV643XX_ETH_SIZE_REG_3                                      0x221c
+#define MV643XX_ETH_SIZE_REG_4                                      0x2224
+#define MV643XX_ETH_SIZE_REG_5                                      0x222c
+#define MV643XX_ETH_HEADERS_RETARGET_BASE_REG                       0x2230
+#define MV643XX_ETH_HEADERS_RETARGET_CONTROL_REG                    0x2234
+#define MV643XX_ETH_HIGH_ADDR_REMAP_REG_0                           0x2280
+#define MV643XX_ETH_HIGH_ADDR_REMAP_REG_1                           0x2284
+#define MV643XX_ETH_HIGH_ADDR_REMAP_REG_2                           0x2288
+#define MV643XX_ETH_HIGH_ADDR_REMAP_REG_3                           0x228c
+#define MV643XX_ETH_BASE_ADDR_ENABLE_REG                            0x2290
+#define MV643XX_ETH_ACCESS_PROTECTION_REG(port)                    (0x2294 + (port<<2))
+#define MV643XX_ETH_MIB_COUNTERS_BASE(port)                        (0x3000 + (port<<7))
+#define MV643XX_ETH_PORT_CONFIG_REG(port)                          (0x2400 + (port<<10))
+#define MV643XX_ETH_PORT_CONFIG_EXTEND_REG(port)                   (0x2404 + (port<<10))
+#define MV643XX_ETH_MII_SERIAL_PARAMETRS_REG(port)                 (0x2408 + (port<<10))
+#define MV643XX_ETH_GMII_SERIAL_PARAMETRS_REG(port)                (0x240c + (port<<10))
+#define MV643XX_ETH_VLAN_ETHERTYPE_REG(port)                       (0x2410 + (port<<10))
+#define MV643XX_ETH_MAC_ADDR_LOW(port)                             (0x2414 + (port<<10))
+#define MV643XX_ETH_MAC_ADDR_HIGH(port)                            (0x2418 + (port<<10))
+#define MV643XX_ETH_SDMA_CONFIG_REG(port)                          (0x241c + (port<<10))
+#define MV643XX_ETH_DSCP_0(port)                                   (0x2420 + (port<<10))
+#define MV643XX_ETH_DSCP_1(port)                                   (0x2424 + (port<<10))
+#define MV643XX_ETH_DSCP_2(port)                                   (0x2428 + (port<<10))
+#define MV643XX_ETH_DSCP_3(port)                                   (0x242c + (port<<10))
+#define MV643XX_ETH_DSCP_4(port)                                   (0x2430 + (port<<10))
+#define MV643XX_ETH_DSCP_5(port)                                   (0x2434 + (port<<10))
+#define MV643XX_ETH_DSCP_6(port)                                   (0x2438 + (port<<10))
+#define MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port)                  (0x243c + (port<<10))
+#define MV643XX_ETH_VLAN_PRIORITY_TAG_TO_PRIORITY(port)            (0x2440 + (port<<10))
+#define MV643XX_ETH_PORT_STATUS_REG(port)                          (0x2444 + (port<<10))
+#define MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port)               (0x2448 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_FIXED_PRIORITY(port)                  (0x244c + (port<<10))
+#define MV643XX_ETH_PORT_TX_TOKEN_BUCKET_RATE_CONFIG(port)         (0x2450 + (port<<10))
+#define MV643XX_ETH_MAXIMUM_TRANSMIT_UNIT(port)                    (0x2458 + (port<<10))
+#define MV643XX_ETH_PORT_MAXIMUM_TOKEN_BUCKET_SIZE(port)           (0x245c + (port<<10))
+#define MV643XX_ETH_INTERRUPT_CAUSE_REG(port)                      (0x2460 + (port<<10))
+#define MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port)               (0x2464 + (port<<10))
+#define MV643XX_ETH_INTERRUPT_MASK_REG(port)                       (0x2468 + (port<<10))
+#define MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port)                (0x246c + (port<<10))
+#define MV643XX_ETH_RX_FIFO_URGENT_THRESHOLD_REG(port)             (0x2470 + (port<<10))
+#define MV643XX_ETH_TX_FIFO_URGENT_THRESHOLD_REG(port)             (0x2474 + (port<<10))
+#define MV643XX_ETH_RX_MINIMAL_FRAME_SIZE_REG(port)                (0x247c + (port<<10))
+#define MV643XX_ETH_RX_DISCARDED_FRAMES_COUNTER(port)              (0x2484 + (port<<10)
+#define MV643XX_ETH_PORT_DEBUG_0_REG(port)                         (0x248c + (port<<10))
+#define MV643XX_ETH_PORT_DEBUG_1_REG(port)                         (0x2490 + (port<<10))
+#define MV643XX_ETH_PORT_INTERNAL_ADDR_ERROR_REG(port)             (0x2494 + (port<<10))
+#define MV643XX_ETH_INTERNAL_USE_REG(port)                         (0x24fc + (port<<10))
+#define MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port)                (0x2680 + (port<<10))
+#define MV643XX_ETH_CURRENT_SERVED_TX_DESC_PTR(port)               (0x2684 + (port<<10))      
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port)              (0x260c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_1(port)              (0x261c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_2(port)              (0x262c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_3(port)              (0x263c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_4(port)              (0x264c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_5(port)              (0x265c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_6(port)              (0x266c + (port<<10))     
+#define MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_7(port)              (0x267c + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_0(port)              (0x26c0 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_1(port)              (0x26c4 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_2(port)              (0x26c8 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_3(port)              (0x26cc + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_4(port)              (0x26d0 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_5(port)              (0x26d4 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_6(port)              (0x26d8 + (port<<10))     
+#define MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_7(port)              (0x26dc + (port<<10))     
+#define MV643XX_ETH_TX_QUEUE_0_TOKEN_BUCKET_COUNT(port)            (0x2700 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_1_TOKEN_BUCKET_COUNT(port)            (0x2710 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_2_TOKEN_BUCKET_COUNT(port)            (0x2720 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_3_TOKEN_BUCKET_COUNT(port)            (0x2730 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_4_TOKEN_BUCKET_COUNT(port)            (0x2740 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_5_TOKEN_BUCKET_COUNT(port)            (0x2750 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_6_TOKEN_BUCKET_COUNT(port)            (0x2760 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_7_TOKEN_BUCKET_COUNT(port)            (0x2770 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_0_TOKEN_BUCKET_CONFIG(port)           (0x2704 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_1_TOKEN_BUCKET_CONFIG(port)           (0x2714 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_2_TOKEN_BUCKET_CONFIG(port)           (0x2724 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_3_TOKEN_BUCKET_CONFIG(port)           (0x2734 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_4_TOKEN_BUCKET_CONFIG(port)           (0x2744 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_5_TOKEN_BUCKET_CONFIG(port)           (0x2754 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_6_TOKEN_BUCKET_CONFIG(port)           (0x2764 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_7_TOKEN_BUCKET_CONFIG(port)           (0x2774 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_0_ARBITER_CONFIG(port)                (0x2708 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_1_ARBITER_CONFIG(port)                (0x2718 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_2_ARBITER_CONFIG(port)                (0x2728 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_3_ARBITER_CONFIG(port)                (0x2738 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_4_ARBITER_CONFIG(port)                (0x2748 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_5_ARBITER_CONFIG(port)                (0x2758 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_6_ARBITER_CONFIG(port)                (0x2768 + (port<<10))
+#define MV643XX_ETH_TX_QUEUE_7_ARBITER_CONFIG(port)                (0x2778 + (port<<10))
+#define MV643XX_ETH_PORT_TX_TOKEN_BUCKET_COUNT(port)               (0x2780 + (port<<10))
+#define MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE(port)   (0x3400 + (port<<10))
+#define MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE(port)     (0x3500 + (port<<10))
+#define MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE(port)             (0x3600 + (port<<10))
+
+/*******************************************/
+/*          CUNIT  Registers               */
+/*******************************************/
+
+         /* Address Decoding Register Map */
+           
+#define MV64340_CUNIT_BASE_ADDR_REG0                                0xf200
+#define MV64340_CUNIT_BASE_ADDR_REG1                                0xf208
+#define MV64340_CUNIT_BASE_ADDR_REG2                                0xf210
+#define MV64340_CUNIT_BASE_ADDR_REG3                                0xf218
+#define MV64340_CUNIT_SIZE0                                         0xf204
+#define MV64340_CUNIT_SIZE1                                         0xf20c
+#define MV64340_CUNIT_SIZE2                                         0xf214
+#define MV64340_CUNIT_SIZE3                                         0xf21c
+#define MV64340_CUNIT_HIGH_ADDR_REMAP_REG0                          0xf240
+#define MV64340_CUNIT_HIGH_ADDR_REMAP_REG1                          0xf244
+#define MV64340_CUNIT_BASE_ADDR_ENABLE_REG                          0xf250
+#define MV64340_MPSC0_ACCESS_PROTECTION_REG                         0xf254
+#define MV64340_MPSC1_ACCESS_PROTECTION_REG                         0xf258
+#define MV64340_CUNIT_INTERNAL_SPACE_BASE_ADDR_REG                  0xf25C
+
+        /*  Error Report Registers  */
+
+#define MV64340_CUNIT_INTERRUPT_CAUSE_REG                           0xf310
+#define MV64340_CUNIT_INTERRUPT_MASK_REG                            0xf314
+#define MV64340_CUNIT_ERROR_ADDR                                    0xf318
+
+        /*  Cunit Control Registers */
+
+#define MV64340_CUNIT_ARBITER_CONTROL_REG                           0xf300
+#define MV64340_CUNIT_CONFIG_REG                                    0xb40c
+#define MV64340_CUNIT_CRROSBAR_TIMEOUT_REG                          0xf304
+
+        /*  Cunit Debug Registers   */
+
+#define MV64340_CUNIT_DEBUG_LOW                                     0xf340
+#define MV64340_CUNIT_DEBUG_HIGH                                    0xf344
+#define MV64340_CUNIT_MMASK                                         0xf380
+
+        /*  MPSCs Clocks Routing Registers  */
+
+#define MV64340_MPSC_ROUTING_REG                                    0xb400
+#define MV64340_MPSC_RX_CLOCK_ROUTING_REG                           0xb404
+#define MV64340_MPSC_TX_CLOCK_ROUTING_REG                           0xb408
+
+        /*  MPSCs Interrupts Registers    */
+
+#define MV64340_MPSC_CAUSE_REG(port)                               (0xb804 + (port<<3))
+#define MV64340_MPSC_MASK_REG(port)                                (0xb884 + (port<<3))
+ 
+#define MV64340_MPSC_MAIN_CONFIG_LOW(port)                         (0x8000 + (port<<12))
+#define MV64340_MPSC_MAIN_CONFIG_HIGH(port)                        (0x8004 + (port<<12))    
+#define MV64340_MPSC_PROTOCOL_CONFIG(port)                         (0x8008 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG1(port)                            (0x800c + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG2(port)                            (0x8010 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG3(port)                            (0x8014 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG4(port)                            (0x8018 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG5(port)                            (0x801c + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG6(port)                            (0x8020 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG7(port)                            (0x8024 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG8(port)                            (0x8028 + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG9(port)                            (0x802c + (port<<12))    
+#define MV64340_MPSC_CHANNEL_REG10(port)                           (0x8030 + (port<<12))    
+        
+        /*  MPSC0 Registers      */
+
+
+/***************************************/
+/*          SDMA Registers             */
+/***************************************/
+
+#define MV64340_SDMA_CONFIG_REG(channel)                        (0x4000 + (channel<<13))        
+#define MV64340_SDMA_COMMAND_REG(channel)                       (0x4008 + (channel<<13))        
+#define MV64340_SDMA_CURRENT_RX_DESCRIPTOR_POINTER(channel)     (0x4810 + (channel<<13))        
+#define MV64340_SDMA_CURRENT_TX_DESCRIPTOR_POINTER(channel)     (0x4c10 + (channel<<13))        
+#define MV64340_SDMA_FIRST_TX_DESCRIPTOR_POINTER(channel)       (0x4c14 + (channel<<13)) 
+
+#define MV64340_SDMA_CAUSE_REG                                      0xb800
+#define MV64340_SDMA_MASK_REG                                       0xb880
+         
+/* BRG Interrupts */
+
+#define MV64340_BRG_CONFIG_REG(brg)                              (0xb200 + (brg<<3))
+#define MV64340_BRG_BAUDE_TUNING_REG(brg)                        (0xb208 + (brg<<3))
+#define MV64340_BRG_CAUSE_REG                                       0xb834
+#define MV64340_BRG_MASK_REG                                        0xb8b4
+
+/****************************************/
+/* DMA Channel Control                  */
+/****************************************/
+
+#define MV64340_DMA_CHANNEL0_CONTROL                                0x840
+#define MV64340_DMA_CHANNEL0_CONTROL_HIGH                           0x880
+#define MV64340_DMA_CHANNEL1_CONTROL                                0x844
+#define MV64340_DMA_CHANNEL1_CONTROL_HIGH                           0x884
+#define MV64340_DMA_CHANNEL2_CONTROL                                0x848
+#define MV64340_DMA_CHANNEL2_CONTROL_HIGH                           0x888
+#define MV64340_DMA_CHANNEL3_CONTROL                                0x84C
+#define MV64340_DMA_CHANNEL3_CONTROL_HIGH                           0x88C
+
+
+/****************************************/
+/*           IDMA Registers             */
+/****************************************/
+
+#define MV64340_DMA_CHANNEL0_BYTE_COUNT                             0x800
+#define MV64340_DMA_CHANNEL1_BYTE_COUNT                             0x804
+#define MV64340_DMA_CHANNEL2_BYTE_COUNT                             0x808
+#define MV64340_DMA_CHANNEL3_BYTE_COUNT                             0x80C
+#define MV64340_DMA_CHANNEL0_SOURCE_ADDR                            0x810
+#define MV64340_DMA_CHANNEL1_SOURCE_ADDR                            0x814
+#define MV64340_DMA_CHANNEL2_SOURCE_ADDR                            0x818
+#define MV64340_DMA_CHANNEL3_SOURCE_ADDR                            0x81c
+#define MV64340_DMA_CHANNEL0_DESTINATION_ADDR                       0x820
+#define MV64340_DMA_CHANNEL1_DESTINATION_ADDR                       0x824
+#define MV64340_DMA_CHANNEL2_DESTINATION_ADDR                       0x828
+#define MV64340_DMA_CHANNEL3_DESTINATION_ADDR                       0x82C
+#define MV64340_DMA_CHANNEL0_NEXT_DESCRIPTOR_POINTER                0x830
+#define MV64340_DMA_CHANNEL1_NEXT_DESCRIPTOR_POINTER                0x834
+#define MV64340_DMA_CHANNEL2_NEXT_DESCRIPTOR_POINTER                0x838
+#define MV64340_DMA_CHANNEL3_NEXT_DESCRIPTOR_POINTER                0x83C
+#define MV64340_DMA_CHANNEL0_CURRENT_DESCRIPTOR_POINTER             0x870
+#define MV64340_DMA_CHANNEL1_CURRENT_DESCRIPTOR_POINTER             0x874
+#define MV64340_DMA_CHANNEL2_CURRENT_DESCRIPTOR_POINTER             0x878
+#define MV64340_DMA_CHANNEL3_CURRENT_DESCRIPTOR_POINTER             0x87C
+
+ /*  IDMA Address Decoding Base Address Registers  */
+ 
+#define MV64340_DMA_BASE_ADDR_REG0                                  0xa00
+#define MV64340_DMA_BASE_ADDR_REG1                                  0xa08
+#define MV64340_DMA_BASE_ADDR_REG2                                  0xa10
+#define MV64340_DMA_BASE_ADDR_REG3                                  0xa18
+#define MV64340_DMA_BASE_ADDR_REG4                                  0xa20
+#define MV64340_DMA_BASE_ADDR_REG5                                  0xa28
+#define MV64340_DMA_BASE_ADDR_REG6                                  0xa30
+#define MV64340_DMA_BASE_ADDR_REG7                                  0xa38
+ 
+ /*  IDMA Address Decoding Size Address Register   */
+ 
+#define MV64340_DMA_SIZE_REG0                                       0xa04
+#define MV64340_DMA_SIZE_REG1                                       0xa0c
+#define MV64340_DMA_SIZE_REG2                                       0xa14
+#define MV64340_DMA_SIZE_REG3                                       0xa1c
+#define MV64340_DMA_SIZE_REG4                                       0xa24
+#define MV64340_DMA_SIZE_REG5                                       0xa2c
+#define MV64340_DMA_SIZE_REG6                                       0xa34
+#define MV64340_DMA_SIZE_REG7                                       0xa3C
+
+ /* IDMA Address Decoding High Address Remap and Access 
+                  Protection Registers                    */
+                  
+#define MV64340_DMA_HIGH_ADDR_REMAP_REG0                            0xa60
+#define MV64340_DMA_HIGH_ADDR_REMAP_REG1                            0xa64
+#define MV64340_DMA_HIGH_ADDR_REMAP_REG2                            0xa68
+#define MV64340_DMA_HIGH_ADDR_REMAP_REG3                            0xa6C
+#define MV64340_DMA_BASE_ADDR_ENABLE_REG                            0xa80
+#define MV64340_DMA_CHANNEL0_ACCESS_PROTECTION_REG                  0xa70
+#define MV64340_DMA_CHANNEL1_ACCESS_PROTECTION_REG                  0xa74
+#define MV64340_DMA_CHANNEL2_ACCESS_PROTECTION_REG                  0xa78
+#define MV64340_DMA_CHANNEL3_ACCESS_PROTECTION_REG                  0xa7c
+#define MV64340_DMA_ARBITER_CONTROL                                 0x860
+#define MV64340_DMA_CROSS_BAR_TIMEOUT                               0x8d0
+
+ /*  IDMA Headers Retarget Registers   */
+
+#define MV64340_DMA_HEADERS_RETARGET_CONTROL                        0xa84
+#define MV64340_DMA_HEADERS_RETARGET_BASE                           0xa88
+
+ /*  IDMA Interrupt Register  */
+
+#define MV64340_DMA_INTERRUPT_CAUSE_REG                             0x8c0
+#define MV64340_DMA_INTERRUPT_CAUSE_MASK                            0x8c4
+#define MV64340_DMA_ERROR_ADDR                                      0x8c8
+#define MV64340_DMA_ERROR_SELECT                                    0x8cc
+
+ /*  IDMA Debug Register ( for internal use )    */
+
+#define MV64340_DMA_DEBUG_LOW                                       0x8e0
+#define MV64340_DMA_DEBUG_HIGH                                      0x8e4
+#define MV64340_DMA_SPARE                                           0xA8C
+
+/****************************************/
+/* Timer_Counter                        */
+/****************************************/
+
+#define MV64340_TIMER_COUNTER0                                      0x850
+#define MV64340_TIMER_COUNTER1                                      0x854
+#define MV64340_TIMER_COUNTER2                                      0x858
+#define MV64340_TIMER_COUNTER3                                      0x85C
+#define MV64340_TIMER_COUNTER_0_3_CONTROL                           0x864
+#define MV64340_TIMER_COUNTER_0_3_INTERRUPT_CAUSE                   0x868
+#define MV64340_TIMER_COUNTER_0_3_INTERRUPT_MASK                    0x86c
+
+/****************************************/
+/*         Watchdog registers           */
+/****************************************/
+
+#define MV64340_WATCHDOG_CONFIG_REG                                 0xb410
+#define MV64340_WATCHDOG_VALUE_REG                                  0xb414
+
+/****************************************/
+/* I2C Registers                        */
+/****************************************/
+
+#define MV64XXX_I2C_CTLR_NAME                                   "mv64xxx i2c"
+#define MV64XXX_I2C_OFFSET                                          0xc000
+#define MV64XXX_I2C_REG_BLOCK_SIZE                                  0x0020
+
+/****************************************/
+/* GPP Interface Registers              */
+/****************************************/
+
+#define MV64340_GPP_IO_CONTROL                                      0xf100
+#define MV64340_GPP_LEVEL_CONTROL                                   0xf110
+#define MV64340_GPP_VALUE                                           0xf104
+#define MV64340_GPP_INTERRUPT_CAUSE                                 0xf108
+#define MV64340_GPP_INTERRUPT_MASK0                                 0xf10c
+#define MV64340_GPP_INTERRUPT_MASK1                                 0xf114
+#define MV64340_GPP_VALUE_SET                                       0xf118
+#define MV64340_GPP_VALUE_CLEAR                                     0xf11c
+
+/****************************************/
+/* Interrupt Controller Registers       */
+/****************************************/
+
+/****************************************/
+/* Interrupts                           */
+/****************************************/
+
+#define MV64340_MAIN_INTERRUPT_CAUSE_LOW                            0x004
+#define MV64340_MAIN_INTERRUPT_CAUSE_HIGH                           0x00c
+#define MV64340_CPU_INTERRUPT0_MASK_LOW                             0x014
+#define MV64340_CPU_INTERRUPT0_MASK_HIGH                            0x01c
+#define MV64340_CPU_INTERRUPT0_SELECT_CAUSE                         0x024
+#define MV64340_CPU_INTERRUPT1_MASK_LOW                             0x034
+#define MV64340_CPU_INTERRUPT1_MASK_HIGH                            0x03c
+#define MV64340_CPU_INTERRUPT1_SELECT_CAUSE                         0x044
+#define MV64340_INTERRUPT0_MASK_0_LOW                               0x054
+#define MV64340_INTERRUPT0_MASK_0_HIGH                              0x05c
+#define MV64340_INTERRUPT0_SELECT_CAUSE                             0x064
+#define MV64340_INTERRUPT1_MASK_0_LOW                               0x074
+#define MV64340_INTERRUPT1_MASK_0_HIGH                              0x07c
+#define MV64340_INTERRUPT1_SELECT_CAUSE                             0x084
+
+/****************************************/
+/*      MPP Interface Registers         */
+/****************************************/
+
+#define MV64340_MPP_CONTROL0                                        0xf000
+#define MV64340_MPP_CONTROL1                                        0xf004
+#define MV64340_MPP_CONTROL2                                        0xf008
+#define MV64340_MPP_CONTROL3                                        0xf00c
+
+/****************************************/
+/*    Serial Initialization registers   */
+/****************************************/
+
+#define MV64340_SERIAL_INIT_LAST_DATA                               0xf324
+#define MV64340_SERIAL_INIT_CONTROL                                 0xf328
+#define MV64340_SERIAL_INIT_STATUS                                  0xf32c
+
+extern void mv64340_irq_init(unsigned int base);
+
+/* MPSC Platform Device, Driver Data (Shared register regions) */
+#define MPSC_SHARED_NAME                "mpsc_shared"
+
+#define MPSC_ROUTING_BASE_ORDER         0
+#define MPSC_SDMA_INTR_BASE_ORDER       1
+
+#define MPSC_ROUTING_REG_BLOCK_SIZE     0x000c
+#define MPSC_SDMA_INTR_REG_BLOCK_SIZE   0x0084
+
+struct mpsc_shared_pdata {
+        u32     mrr_val;
+        u32     rcrr_val;
+        u32     tcrr_val;
+        u32     intr_cause_val;
+        u32     intr_mask_val;
+};
+
+/* MPSC Platform Device, Driver Data */
+#define MPSC_CTLR_NAME                  "mpsc"
+
+#define MPSC_BASE_ORDER                 0
+#define MPSC_SDMA_BASE_ORDER            1
+#define MPSC_BRG_BASE_ORDER             2
+
+#define MPSC_REG_BLOCK_SIZE             0x0038
+#define MPSC_SDMA_REG_BLOCK_SIZE        0x0c18
+#define MPSC_BRG_REG_BLOCK_SIZE         0x0008
+
+struct mpsc_pdata {
+        u8      mirror_regs;
+        u8      cache_mgmt;
+        u8      max_idle;
+        int     default_baud;
+        int     default_bits;
+        int     default_parity;
+        int     default_flow;
+        u32     chr_1_val;
+        u32     chr_2_val;
+        u32     chr_10_val;
+        u32     mpcr_val;
+        u32     bcr_val;
+        u8      brg_can_tune;
+        u8      brg_clk_src;
+        u32     brg_clk_freq;
+};
+
+/* i2c Platform Device, Driver Data */
+struct mv64xxx_i2c_pdata {
+        u32     freq_m;
+        u32     freq_n;
+        u32     timeout;        /* In milliseconds */
+        u32     retries;
+};
+
+/* These macros describe Ethernet Port configuration reg (Px_cR) bits */
+#define MV643XX_ETH_UNICAST_NORMAL_MODE         0
+#define MV643XX_ETH_UNICAST_PROMISCUOUS_MODE    (1<<0)
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_0          0
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_1          (1<<1)
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_2          (1<<2)
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_3          ((1<<2) | (1<<1))
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_4          (1<<3)
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_5          ((1<<3) | (1<<1))
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_6          ((1<<3) | (1<<2))
+#define MV643XX_ETH_DEFAULT_RX_QUEUE_7          ((1<<3) | (1<<2) | (1<<1))
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_0      0
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_1      (1<<4)
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_2      (1<<5)
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_3      ((1<<5) | (1<<4))
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_4      (1<<6)
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_5      ((1<<6) | (1<<4))
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_6      ((1<<6) | (1<<5))
+#define MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_7      ((1<<6) | (1<<5) | (1<<4))
+#define MV643XX_ETH_RECEIVE_BC_IF_NOT_IP_OR_ARP 0
+#define MV643XX_ETH_REJECT_BC_IF_NOT_IP_OR_ARP  (1<<7)
+#define MV643XX_ETH_RECEIVE_BC_IF_IP            0
+#define MV643XX_ETH_REJECT_BC_IF_IP             (1<<8)
+#define MV643XX_ETH_RECEIVE_BC_IF_ARP           0
+#define MV643XX_ETH_REJECT_BC_IF_ARP            (1<<9)
+#define MV643XX_ETH_TX_AM_NO_UPDATE_ERROR_SUMMARY (1<<12)
+#define MV643XX_ETH_CAPTURE_TCP_FRAMES_DIS      0
+#define MV643XX_ETH_CAPTURE_TCP_FRAMES_EN       (1<<14)
+#define MV643XX_ETH_CAPTURE_UDP_FRAMES_DIS      0
+#define MV643XX_ETH_CAPTURE_UDP_FRAMES_EN       (1<<15)
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_0      0
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_1      (1<<16)
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_2      (1<<17)
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_3      ((1<<17) | (1<<16))
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_4      (1<<18)
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_5      ((1<<18) | (1<<16))
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_6      ((1<<18) | (1<<17))
+#define MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_7      ((1<<18) | (1<<17) | (1<<16))
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_0      0
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_1      (1<<19)
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_2      (1<<20)
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_3      ((1<<20) | (1<<19))
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_4      ((1<<21)
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_5      ((1<<21) | (1<<19))
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_6      ((1<<21) | (1<<20))
+#define MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_7      ((1<<21) | (1<<20) | (1<<19))
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_0     0
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_1     (1<<22)
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_2     (1<<23)
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_3     ((1<<23) | (1<<22))
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_4     (1<<24)
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_5     ((1<<24) | (1<<22))
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_6     ((1<<24) | (1<<23))
+#define MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_7     ((1<<24) | (1<<23) | (1<<22))
+
+#define MV643XX_ETH_PORT_CONFIG_DEFAULT_VALUE                   \
+                MV643XX_ETH_UNICAST_NORMAL_MODE         |       \
+                MV643XX_ETH_DEFAULT_RX_QUEUE_0          |       \
+                MV643XX_ETH_DEFAULT_RX_ARP_QUEUE_0      |       \
+                MV643XX_ETH_RECEIVE_BC_IF_NOT_IP_OR_ARP |       \
+                MV643XX_ETH_RECEIVE_BC_IF_IP            |       \
+                MV643XX_ETH_RECEIVE_BC_IF_ARP           |       \
+                MV643XX_ETH_CAPTURE_TCP_FRAMES_DIS      |       \
+                MV643XX_ETH_CAPTURE_UDP_FRAMES_DIS      |       \
+                MV643XX_ETH_DEFAULT_RX_TCP_QUEUE_0      |       \
+                MV643XX_ETH_DEFAULT_RX_UDP_QUEUE_0      |       \
+                MV643XX_ETH_DEFAULT_RX_BPDU_QUEUE_0
+
+/* These macros describe Ethernet Port configuration extend reg (Px_cXR) bits*/
+#define MV643XX_ETH_CLASSIFY_EN                         (1<<0)
+#define MV643XX_ETH_SPAN_BPDU_PACKETS_AS_NORMAL         0
+#define MV643XX_ETH_SPAN_BPDU_PACKETS_TO_RX_QUEUE_7     (1<<1)
+#define MV643XX_ETH_PARTITION_DISABLE                   0
+#define MV643XX_ETH_PARTITION_ENABLE                    (1<<2)
+
+#define MV643XX_ETH_PORT_CONFIG_EXTEND_DEFAULT_VALUE            \
+                MV643XX_ETH_SPAN_BPDU_PACKETS_AS_NORMAL |       \
+                MV643XX_ETH_PARTITION_DISABLE
+
+/* These macros describe Ethernet Port Sdma configuration reg (SDCR) bits */
+#define MV643XX_ETH_RIFB                        (1<<0)
+#define MV643XX_ETH_RX_BURST_SIZE_1_64BIT               0
+#define MV643XX_ETH_RX_BURST_SIZE_2_64BIT               (1<<1)
+#define MV643XX_ETH_RX_BURST_SIZE_4_64BIT               (1<<2)
+#define MV643XX_ETH_RX_BURST_SIZE_8_64BIT               ((1<<2) | (1<<1))
+#define MV643XX_ETH_RX_BURST_SIZE_16_64BIT              (1<<3)
+#define MV643XX_ETH_BLM_RX_NO_SWAP                      (1<<4)
+#define MV643XX_ETH_BLM_RX_BYTE_SWAP                    0
+#define MV643XX_ETH_BLM_TX_NO_SWAP                      (1<<5)
+#define MV643XX_ETH_BLM_TX_BYTE_SWAP                    0
+#define MV643XX_ETH_DESCRIPTORS_BYTE_SWAP               (1<<6)
+#define MV643XX_ETH_DESCRIPTORS_NO_SWAP                 0
+#define MV643XX_ETH_TX_BURST_SIZE_1_64BIT               0
+#define MV643XX_ETH_TX_BURST_SIZE_2_64BIT               (1<<22)
+#define MV643XX_ETH_TX_BURST_SIZE_4_64BIT               (1<<23)
+#define MV643XX_ETH_TX_BURST_SIZE_8_64BIT               ((1<<23) | (1<<22))
+#define MV643XX_ETH_TX_BURST_SIZE_16_64BIT              (1<<24)
+
+#define MV643XX_ETH_IPG_INT_RX(value) ((value & 0x3fff) << 8)
+
+#define MV643XX_ETH_PORT_SDMA_CONFIG_DEFAULT_VALUE              \
+                MV643XX_ETH_RX_BURST_SIZE_4_64BIT       |       \
+                MV643XX_ETH_IPG_INT_RX(0)               |       \
+                MV643XX_ETH_TX_BURST_SIZE_4_64BIT
+
+/* These macros describe Ethernet Port serial control reg (PSCR) bits */
+#define MV643XX_ETH_SERIAL_PORT_DISABLE                 0
+#define MV643XX_ETH_SERIAL_PORT_ENABLE                  (1<<0)
+#define MV643XX_ETH_FORCE_LINK_PASS                     (1<<1)
+#define MV643XX_ETH_DO_NOT_FORCE_LINK_PASS              0
+#define MV643XX_ETH_ENABLE_AUTO_NEG_FOR_DUPLX           0
+#define MV643XX_ETH_DISABLE_AUTO_NEG_FOR_DUPLX          (1<<2)
+#define MV643XX_ETH_ENABLE_AUTO_NEG_FOR_FLOW_CTRL       0
+#define MV643XX_ETH_DISABLE_AUTO_NEG_FOR_FLOW_CTRL      (1<<3)
+#define MV643XX_ETH_ADV_NO_FLOW_CTRL                    0
+#define MV643XX_ETH_ADV_SYMMETRIC_FLOW_CTRL             (1<<4)
+#define MV643XX_ETH_FORCE_FC_MODE_NO_PAUSE_DIS_TX       0
+#define MV643XX_ETH_FORCE_FC_MODE_TX_PAUSE_DIS          (1<<5)
+#define MV643XX_ETH_FORCE_BP_MODE_NO_JAM                0
+#define MV643XX_ETH_FORCE_BP_MODE_JAM_TX                (1<<7)
+#define MV643XX_ETH_FORCE_BP_MODE_JAM_TX_ON_RX_ERR      (1<<8)
+#define MV643XX_ETH_FORCE_LINK_FAIL                     0
+#define MV643XX_ETH_DO_NOT_FORCE_LINK_FAIL              (1<<10)
+#define MV643XX_ETH_RETRANSMIT_16_ATTEMPTS              0
+#define MV643XX_ETH_RETRANSMIT_FOREVER                  (1<<11)
+#define MV643XX_ETH_DISABLE_AUTO_NEG_SPEED_GMII         (1<<13)
+#define MV643XX_ETH_ENABLE_AUTO_NEG_SPEED_GMII          0
+#define MV643XX_ETH_DTE_ADV_0                           0
+#define MV643XX_ETH_DTE_ADV_1                           (1<<14)
+#define MV643XX_ETH_DISABLE_AUTO_NEG_BYPASS             0
+#define MV643XX_ETH_ENABLE_AUTO_NEG_BYPASS              (1<<15)
+#define MV643XX_ETH_AUTO_NEG_NO_CHANGE                  0
+#define MV643XX_ETH_RESTART_AUTO_NEG                    (1<<16)
+#define MV643XX_ETH_MAX_RX_PACKET_1518BYTE              0
+#define MV643XX_ETH_MAX_RX_PACKET_1522BYTE              (1<<17)
+#define MV643XX_ETH_MAX_RX_PACKET_1552BYTE              (1<<18)
+#define MV643XX_ETH_MAX_RX_PACKET_9022BYTE              ((1<<18) | (1<<17))
+#define MV643XX_ETH_MAX_RX_PACKET_9192BYTE              (1<<19)
+#define MV643XX_ETH_MAX_RX_PACKET_9700BYTE              ((1<<19) | (1<<17))
+#define MV643XX_ETH_SET_EXT_LOOPBACK                    (1<<20)
+#define MV643XX_ETH_CLR_EXT_LOOPBACK                    0
+#define MV643XX_ETH_SET_FULL_DUPLEX_MODE                (1<<21)
+#define MV643XX_ETH_SET_HALF_DUPLEX_MODE                0
+#define MV643XX_ETH_ENABLE_FLOW_CTRL_TX_RX_IN_FULL_DUPLEX (1<<22)
+#define MV643XX_ETH_DISABLE_FLOW_CTRL_TX_RX_IN_FULL_DUPLEX 0
+#define MV643XX_ETH_SET_GMII_SPEED_TO_10_100            0
+#define MV643XX_ETH_SET_GMII_SPEED_TO_1000              (1<<23)
+#define MV643XX_ETH_SET_MII_SPEED_TO_10                 0
+#define MV643XX_ETH_SET_MII_SPEED_TO_100                (1<<24)
+
+#define MV643XX_ETH_PORT_SERIAL_CONTROL_DEFAULT_VALUE           \
+                MV643XX_ETH_DO_NOT_FORCE_LINK_PASS      |       \
+                MV643XX_ETH_ENABLE_AUTO_NEG_FOR_DUPLX   |       \
+                MV643XX_ETH_DISABLE_AUTO_NEG_FOR_FLOW_CTRL |    \
+                MV643XX_ETH_ADV_SYMMETRIC_FLOW_CTRL     |       \
+                MV643XX_ETH_FORCE_FC_MODE_NO_PAUSE_DIS_TX |     \
+                MV643XX_ETH_FORCE_BP_MODE_NO_JAM        |       \
+                (1<<9)  /* reserved */                  |       \
+                MV643XX_ETH_DO_NOT_FORCE_LINK_FAIL      |       \
+                MV643XX_ETH_RETRANSMIT_16_ATTEMPTS      |       \
+                MV643XX_ETH_ENABLE_AUTO_NEG_SPEED_GMII  |       \
+                MV643XX_ETH_DTE_ADV_0                   |       \
+                MV643XX_ETH_DISABLE_AUTO_NEG_BYPASS     |       \
+                MV643XX_ETH_AUTO_NEG_NO_CHANGE          |       \
+                MV643XX_ETH_MAX_RX_PACKET_9700BYTE      |       \
+                MV643XX_ETH_CLR_EXT_LOOPBACK            |       \
+                MV643XX_ETH_SET_FULL_DUPLEX_MODE        |       \
+                MV643XX_ETH_ENABLE_FLOW_CTRL_TX_RX_IN_FULL_DUPLEX
+
+/* These macros describe Ethernet Serial Status reg (PSR) bits */
+#define MV643XX_ETH_PORT_STATUS_MODE_10_BIT             (1<<0)
+#define MV643XX_ETH_PORT_STATUS_LINK_UP                 (1<<1)
+#define MV643XX_ETH_PORT_STATUS_FULL_DUPLEX             (1<<2)
+#define MV643XX_ETH_PORT_STATUS_FLOW_CONTROL            (1<<3)
+#define MV643XX_ETH_PORT_STATUS_GMII_1000               (1<<4)
+#define MV643XX_ETH_PORT_STATUS_MII_100                 (1<<5)
+/* PSR bit 6 is undocumented */
+#define MV643XX_ETH_PORT_STATUS_TX_IN_PROGRESS          (1<<7)
+#define MV643XX_ETH_PORT_STATUS_AUTONEG_BYPASSED        (1<<8)
+#define MV643XX_ETH_PORT_STATUS_PARTITION               (1<<9)
+#define MV643XX_ETH_PORT_STATUS_TX_FIFO_EMPTY           (1<<10)
+/* PSR bits 11-31 are reserved */
+
+#define MV643XX_ETH_PORT_DEFAULT_TRANSMIT_QUEUE_SIZE    800
+#define MV643XX_ETH_PORT_DEFAULT_RECEIVE_QUEUE_SIZE     400
+
+#define MV643XX_ETH_DESC_SIZE                           64
+
+#define MV643XX_ETH_SHARED_NAME "mv643xx_eth_shared"
+#define MV643XX_ETH_NAME        "mv643xx_eth"
+
+struct mv643xx_eth_platform_data {
+        /* 
+         * Non-values for mac_addr, phy_addr, port_config, etc.
+         * override the default value.  Setting the corresponding
+         * force_* field, causes the default value to be overridden
+         * even when zero.
+         */
+        unsigned int    force_phy_addr:1;
+        unsigned int    force_port_config:1;
+        unsigned int    force_port_config_extend:1;
+        unsigned int    force_port_sdma_config:1;
+        unsigned int    force_port_serial_control:1;
+        int             phy_addr;
+        char            *mac_addr;      /* pointer to mac address */
+        u32             port_config;
+        u32             port_config_extend;
+        u32             port_sdma_config;
+        u32             port_serial_control;
+        u32             tx_queue_size;
+        u32             rx_queue_size;
+        u32             tx_sram_addr;
+        u32             tx_sram_size;
+        u32             rx_sram_addr;
+        u32             rx_sram_size;
+};
+
+#endif /* __ASM_MV643XX_H */
diff --git a/include/linux/n_r3964.h b/include/linux/n_r3964.h
new file mode 100644
index 000000000000..2352bcd31a06
--- /dev/null
+++ b/include/linux/n_r3964.h
@@ -0,0 +1,226 @@
+/* r3964 linediscipline for linux
+ *
+ * -----------------------------------------------------------
+ * Copyright by
+ * Philips Automation Projects
+ * Kassel (Germany)
+ * http://www.pap-philips.de
+ * -----------------------------------------------------------
+ * This software may be used and distributed according to the terms of
+ * the GNU General Public License, incorporated herein by reference.
+ *
+ * Author:
+ * L. Haag
+ *
+ * $Log: r3964.h,v $
+ * Revision 1.3  2001/03/18 13:02:24  dwmw2
+ * Fix timer usage, use spinlocks properly.
+ *
+ * Revision 1.2  2001/03/18 12:53:15  dwmw2
+ * Merge changes in 2.4.2
+ *
+ * Revision 1.1.1.1  1998/10/13 16:43:14  dwmw2
+ * This'll screw the version control
+ *
+ * Revision 1.6  1998/09/30 00:40:38  dwmw2
+ * Updated to use kernel's N_R3964 if available
+ *
+ * Revision 1.4  1998/04/02 20:29:44  lhaag
+ * select, blocking, ...
+ *
+ * Revision 1.3  1998/02/12 18:58:43  root
+ * fixed some memory leaks
+ * calculation of checksum characters
+ *
+ * Revision 1.2  1998/02/07 13:03:17  root
+ * ioctl read_telegram
+ *
+ * Revision 1.1  1998/02/06 19:19:43  root
+ * Initial revision
+ *
+ *
+ */
+
+#ifndef __LINUX_N_R3964_H__
+#define __LINUX_N_R3964_H__
+
+/* line disciplines for r3964 protocol */
+#include <asm/termios.h>
+
+#ifdef __KERNEL__
+/*
+ * Common ascii handshake characters:
+ */
+
+#define STX 0x02
+#define ETX 0x03
+#define DLE 0x10
+#define NAK 0x15
+
+/*
+ * Timeouts (msecs/10 msecs per timer interrupt):
+ */
+
+#define R3964_TO_QVZ 550/10
+#define R3964_TO_ZVZ 220/10
+#define R3964_TO_NO_BUF 400/10
+#define R3964_NO_TX_ROOM 100/10
+#define R3964_TO_RX_PANIC 4000/10
+#define R3964_MAX_RETRIES 5
+
+#endif
+
+/*
+ * Ioctl-commands
+ */
+
+#define R3964_ENABLE_SIGNALS      0x5301
+#define R3964_SETPRIORITY         0x5302
+#define R3964_USE_BCC             0x5303
+#define R3964_READ_TELEGRAM       0x5304
+
+/* Options for R3964_SETPRIORITY */
+#define R3964_MASTER   0
+#define R3964_SLAVE    1
+
+/* Options for R3964_ENABLE_SIGNALS */
+#define R3964_SIG_ACK   0x0001
+#define R3964_SIG_DATA  0x0002
+#define R3964_SIG_ALL   0x000f
+#define R3964_SIG_NONE  0x0000
+#define R3964_USE_SIGIO 0x1000
+
+/*
+ * r3964 operation states:
+ */
+#ifdef __KERNEL__
+
+enum { R3964_IDLE, 
+           R3964_TX_REQUEST, R3964_TRANSMITTING, 
+           R3964_WAIT_ZVZ_BEFORE_TX_RETRY, R3964_WAIT_FOR_TX_ACK,
+           R3964_WAIT_FOR_RX_BUF,
+           R3964_RECEIVING, R3964_WAIT_FOR_BCC, R3964_WAIT_FOR_RX_REPEAT
+           };
+
+/*
+ * All open file-handles are 'clients' and are stored in a linked list:
+ */
+
+struct r3964_message;
+
+struct r3964_client_info {
+        spinlock_t     lock;
+        pid_t          pid;
+        unsigned int   sig_flags;
+
+        struct r3964_client_info *next;
+
+        struct r3964_message *first_msg;
+        struct r3964_message *last_msg;
+        struct r3964_block_header *next_block_to_read;
+        int            msg_count;
+};
+
+
+#endif
+
+/* types for msg_id: */
+enum {R3964_MSG_ACK=1, R3964_MSG_DATA };
+
+#define R3964_MAX_MSG_COUNT 32
+
+/* error codes for client messages */
+#define R3964_OK 0        /* no error. */
+#define R3964_TX_FAIL -1  /* transmission error, block NOT sent */
+#define R3964_OVERFLOW -2 /* msg queue overflow */
+
+/* the client gets this struct when calling read(fd,...): */
+struct r3964_client_message {
+          int     msg_id;
+          int     arg;
+          int     error_code;
+};
+
+#define R3964_MTU      256
+
+
+#ifdef __KERNEL__
+
+struct r3964_block_header;
+
+/* internal version of client_message: */
+struct r3964_message {
+          int     msg_id;
+          int     arg;
+          int     error_code;
+          struct r3964_block_header *block;
+          struct r3964_message *next;
+};
+
+/*
+ * Header of received block in rx_buf/tx_buf:
+ */
+
+struct r3964_block_header 
+{
+        unsigned int length;             /* length in chars without header */
+        unsigned char *data;             /* usually data is located 
+                                        immediately behind this struct */
+        unsigned int locks;              /* only used in rx_buffer */
+          
+    struct r3964_block_header *next;
+        struct r3964_client_info *owner;  /* =NULL in rx_buffer */
+};
+
+/*
+ * If rx_buf hasn't enough space to store R3964_MTU chars,
+ * we will reject all incoming STX-requests by sending NAK.
+ */
+
+#define RX_BUF_SIZE    4000
+#define TX_BUF_SIZE    4000
+#define R3964_MAX_BLOCKS_IN_RX_QUEUE 100
+
+#define R3964_PARITY 0x0001
+#define R3964_FRAME  0x0002
+#define R3964_OVERRUN 0x0004
+#define R3964_UNKNOWN 0x0008
+#define R3964_BREAK   0x0010
+#define R3964_CHECKSUM 0x0020
+#define R3964_ERROR  0x003f
+#define R3964_BCC   0x4000
+#define R3964_DEBUG 0x8000
+
+
+struct r3964_info {
+        spinlock_t     lock;
+        struct tty_struct *tty;
+        unsigned char priority;
+        unsigned char *rx_buf;            /* ring buffer */
+        unsigned char *tx_buf;
+
+        wait_queue_head_t read_wait;
+        //struct wait_queue *read_wait;
+
+        struct r3964_block_header *rx_first;
+        struct r3964_block_header *rx_last;
+        struct r3964_block_header *tx_first;
+        struct r3964_block_header *tx_last;
+        unsigned int tx_position;
+        unsigned int rx_position;
+        unsigned char last_rx;
+        unsigned char bcc;
+        unsigned int  blocks_in_rx_queue;
+          
+        
+        struct r3964_client_info *firstClient;
+        unsigned int state;
+        unsigned int flags;
+
+        struct timer_list tmr;
+        int nRetry;
+};
+
+#endif  
+
+#endif
diff --git a/include/linux/namei.h b/include/linux/namei.h
new file mode 100644
index 000000000000..7db67b008cac
--- /dev/null
+++ b/include/linux/namei.h
@@ -0,0 +1,87 @@
+#ifndef _LINUX_NAMEI_H
+#define _LINUX_NAMEI_H
+
+#include <linux/linkage.h>
+
+struct vfsmount;
+
+struct open_intent {
+        int     flags;
+        int     create_mode;
+};
+
+enum { MAX_NESTED_LINKS = 5 };
+
+struct nameidata {
+        struct dentry   *dentry;
+        struct vfsmount *mnt;
+        struct qstr     last;
+        unsigned int    flags;
+        int             last_type;
+        unsigned        depth;
+        char *saved_names[MAX_NESTED_LINKS + 1];
+
+        /* Intent data */
+        union {
+                struct open_intent open;
+        } intent;
+};
+
+/*
+ * Type of the last component on LOOKUP_PARENT
+ */
+enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
+
+/*
+ * The bitmask for a lookup event:
+ *  - follow links at the end
+ *  - require a directory
+ *  - ending slashes ok even for nonexistent files
+ *  - internal "there are more path compnents" flag
+ *  - locked when lookup done with dcache_lock held
+ *  - dentry cache is untrusted; force a real lookup
+ */
+#define LOOKUP_FOLLOW            1
+#define LOOKUP_DIRECTORY         2
+#define LOOKUP_CONTINUE          4
+#define LOOKUP_PARENT           16
+#define LOOKUP_NOALT            32
+#define LOOKUP_REVAL            64
+/*
+ * Intent data
+ */
+#define LOOKUP_OPEN             (0x0100)
+#define LOOKUP_CREATE           (0x0200)
+#define LOOKUP_ACCESS           (0x0400)
+
+extern int FASTCALL(__user_walk(const char __user *, unsigned, struct nameidata *));
+#define user_path_walk(name,nd) \
+        __user_walk(name, LOOKUP_FOLLOW, nd)
+#define user_path_walk_link(name,nd) \
+        __user_walk(name, 0, nd)
+extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
+extern int FASTCALL(path_walk(const char *, struct nameidata *));
+extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
+extern void path_release(struct nameidata *);
+extern void path_release_on_umount(struct nameidata *);
+
+extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
+extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
+
+extern int follow_down(struct vfsmount **, struct dentry **);
+extern int follow_up(struct vfsmount **, struct dentry **);
+
+extern struct dentry *lock_rename(struct dentry *, struct dentry *);
+extern void unlock_rename(struct dentry *, struct dentry *);
+
+static inline void nd_set_link(struct nameidata *nd, char *path)
+{
+        nd->saved_names[nd->depth] = path;
+}
+
+static inline char *nd_get_link(struct nameidata *nd)
+{
+        return nd->saved_names[nd->depth];
+}
+
+#endif /* _LINUX_NAMEI_H */
diff --git a/include/linux/namespace.h b/include/linux/namespace.h
new file mode 100644
index 000000000000..9eca1558d72f
--- /dev/null
+++ b/include/linux/namespace.h
@@ -0,0 +1,42 @@
+#ifndef _NAMESPACE_H_
+#define _NAMESPACE_H_
+#ifdef __KERNEL__
+
+#include <linux/mount.h>
+#include <linux/sched.h>
+
+struct namespace {
+        atomic_t                count;
+        struct vfsmount *       root;
+        struct list_head        list;
+        struct rw_semaphore     sem;
+};
+
+extern void umount_tree(struct vfsmount *);
+extern int copy_namespace(int, struct task_struct *);
+extern void __put_namespace(struct namespace *namespace);
+
+static inline void put_namespace(struct namespace *namespace)
+{
+        if (atomic_dec_and_test(&namespace->count))
+                __put_namespace(namespace);
+}
+
+static inline void exit_namespace(struct task_struct *p)
+{
+        struct namespace *namespace = p->namespace;
+        if (namespace) {
+                task_lock(p);
+                p->namespace = NULL;
+                task_unlock(p);
+                put_namespace(namespace);
+        }
+}
+
+static inline void get_namespace(struct namespace *namespace)
+{
+        atomic_inc(&namespace->count);
+}
+
+#endif
+#endif
diff --git a/include/linux/nbd.h b/include/linux/nbd.h
new file mode 100644
index 000000000000..090e210e98f0
--- /dev/null
+++ b/include/linux/nbd.h
@@ -0,0 +1,91 @@
+/*
+ * 1999 Copyright (C) Pavel Machek, pavel@ucw.cz. This code is GPL.
+ * 1999/11/04 Copyright (C) 1999 VMware, Inc. (Regis "HPReg" Duchesne)
+ *            Made nbd_end_request() use the io_request_lock
+ * 2001 Copyright (C) Steven Whitehouse
+ *            New nbd_end_request() for compatibility with new linux block
+ *            layer code.
+ * 2003/06/24 Louis D. Langholtz <ldl@aros.net>
+ *            Removed unneeded blksize_bits field from nbd_device struct.
+ *            Cleanup PARANOIA usage & code.
+ * 2004/02/19 Paul Clements
+ *            Removed PARANOIA, plus various cleanup and comments
+ */
+
+#ifndef LINUX_NBD_H
+#define LINUX_NBD_H
+
+#define NBD_SET_SOCK    _IO( 0xab, 0 )
+#define NBD_SET_BLKSIZE _IO( 0xab, 1 )
+#define NBD_SET_SIZE    _IO( 0xab, 2 )
+#define NBD_DO_IT       _IO( 0xab, 3 )
+#define NBD_CLEAR_SOCK  _IO( 0xab, 4 )
+#define NBD_CLEAR_QUE   _IO( 0xab, 5 )
+#define NBD_PRINT_DEBUG _IO( 0xab, 6 )
+#define NBD_SET_SIZE_BLOCKS     _IO( 0xab, 7 )
+#define NBD_DISCONNECT  _IO( 0xab, 8 )
+
+enum {
+        NBD_CMD_READ = 0,
+        NBD_CMD_WRITE = 1,
+        NBD_CMD_DISC = 2
+};
+
+#define nbd_cmd(req) ((req)->cmd[0])
+#define MAX_NBD 128
+
+/* userspace doesn't need the nbd_device structure */
+#ifdef __KERNEL__
+
+/* values for flags field */
+#define NBD_READ_ONLY 0x0001
+#define NBD_WRITE_NOCHK 0x0002
+
+struct nbd_device {
+        int flags;
+        int harderror;          /* Code of hard error                   */
+        struct socket * sock;
+        struct file * file;     /* If == NULL, device is not ready, yet */
+        int magic;
+        spinlock_t queue_lock;
+        struct list_head queue_head;/* Requests are added here...       */
+        struct semaphore tx_lock;
+        struct gendisk *disk;
+        int blksize;
+        u64 bytesize;
+};
+
+#endif
+
+/* These are sent over the network in the request/reply magic fields */
+
+#define NBD_REQUEST_MAGIC 0x25609513
+#define NBD_REPLY_MAGIC 0x67446698
+/* Do *not* use magics: 0x12560953 0x96744668. */
+
+/*
+ * This is the packet used for communication between client and
+ * server. All data are in network byte order.
+ */
+struct nbd_request {
+        u32 magic;
+        u32 type;       /* == READ || == WRITE  */
+        char handle[8];
+        u64 from;
+        u32 len;
+}
+#ifdef __GNUC__
+        __attribute__ ((packed))
+#endif
+;
+
+/*
+ * This is the reply packet that nbd-server sends back to the client after
+ * it has completed an I/O request (or an error occurs).
+ */
+struct nbd_reply {
+        u32 magic;
+        u32 error;              /* 0 = ok, else error   */
+        char handle[8];         /* handle you got from request  */
+};
+#endif
diff --git a/include/linux/ncp.h b/include/linux/ncp.h
new file mode 100644
index 000000000000..99f77876b716
--- /dev/null
+++ b/include/linux/ncp.h
@@ -0,0 +1,201 @@
+/*
+ *  ncp.h
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *  Modified for sparc by J.F. Chadima
+ *  Modified for __constant_ntoh by Frank A. Vorstenbosch
+ *
+ */
+
+#ifndef _LINUX_NCP_H
+#define _LINUX_NCP_H
+
+#include <linux/types.h>
+
+#define NCP_PTYPE                (0x11)
+#define NCP_PORT                 (0x0451)
+
+#define NCP_ALLOC_SLOT_REQUEST   (0x1111)
+#define NCP_REQUEST              (0x2222)
+#define NCP_DEALLOC_SLOT_REQUEST (0x5555)
+
+struct ncp_request_header {
+        __u16 type __attribute__((packed));
+        __u8 sequence __attribute__((packed));
+        __u8 conn_low __attribute__((packed));
+        __u8 task __attribute__((packed));
+        __u8 conn_high __attribute__((packed));
+        __u8 function __attribute__((packed));
+        __u8 data[0] __attribute__((packed));
+};
+
+#define NCP_REPLY                (0x3333)
+#define NCP_WATCHDOG             (0x3E3E)
+#define NCP_POSITIVE_ACK         (0x9999)
+
+struct ncp_reply_header {
+        __u16 type __attribute__((packed));
+        __u8 sequence __attribute__((packed));
+        __u8 conn_low __attribute__((packed));
+        __u8 task __attribute__((packed));
+        __u8 conn_high __attribute__((packed));
+        __u8 completion_code __attribute__((packed));
+        __u8 connection_state __attribute__((packed));
+        __u8 data[0] __attribute__((packed));
+};
+
+#define NCP_VOLNAME_LEN (16)
+#define NCP_NUMBER_OF_VOLUMES (256)
+struct ncp_volume_info {
+        __u32 total_blocks;
+        __u32 free_blocks;
+        __u32 purgeable_blocks;
+        __u32 not_yet_purgeable_blocks;
+        __u32 total_dir_entries;
+        __u32 available_dir_entries;
+        __u8 sectors_per_block;
+        char volume_name[NCP_VOLNAME_LEN + 1];
+};
+
+#define AR_READ      (cpu_to_le16(1))
+#define AR_WRITE     (cpu_to_le16(2))
+#define AR_EXCLUSIVE (cpu_to_le16(0x20))
+
+#define NCP_FILE_ID_LEN 6
+
+/* Defines for Name Spaces */
+#define NW_NS_DOS     0
+#define NW_NS_MAC     1
+#define NW_NS_NFS     2
+#define NW_NS_FTAM    3
+#define NW_NS_OS2     4
+
+/*  Defines for ReturnInformationMask */
+#define RIM_NAME              (cpu_to_le32(1))
+#define RIM_SPACE_ALLOCATED   (cpu_to_le32(2))
+#define RIM_ATTRIBUTES        (cpu_to_le32(4))
+#define RIM_DATA_SIZE         (cpu_to_le32(8))
+#define RIM_TOTAL_SIZE        (cpu_to_le32(0x10))
+#define RIM_EXT_ATTR_INFO     (cpu_to_le32(0x20))
+#define RIM_ARCHIVE           (cpu_to_le32(0x40))
+#define RIM_MODIFY            (cpu_to_le32(0x80))
+#define RIM_CREATION          (cpu_to_le32(0x100))
+#define RIM_OWNING_NAMESPACE  (cpu_to_le32(0x200))
+#define RIM_DIRECTORY         (cpu_to_le32(0x400))
+#define RIM_RIGHTS            (cpu_to_le32(0x800))
+#define RIM_ALL               (cpu_to_le32(0xFFF))
+#define RIM_COMPRESSED_INFO   (cpu_to_le32(0x80000000))
+
+/* Defines for NSInfoBitMask */
+#define NSIBM_NFS_NAME          0x0001
+#define NSIBM_NFS_MODE          0x0002
+#define NSIBM_NFS_GID           0x0004
+#define NSIBM_NFS_NLINKS        0x0008
+#define NSIBM_NFS_RDEV          0x0010
+#define NSIBM_NFS_LINK          0x0020
+#define NSIBM_NFS_CREATED       0x0040
+#define NSIBM_NFS_UID           0x0080
+#define NSIBM_NFS_ACSFLAG       0x0100
+#define NSIBM_NFS_MYFLAG        0x0200
+
+/* open/create modes */
+#define OC_MODE_OPEN      0x01
+#define OC_MODE_TRUNCATE  0x02
+#define OC_MODE_REPLACE   0x02
+#define OC_MODE_CREATE    0x08
+
+/* open/create results */
+#define OC_ACTION_NONE     0x00
+#define OC_ACTION_OPEN     0x01
+#define OC_ACTION_CREATE   0x02
+#define OC_ACTION_TRUNCATE 0x04
+#define OC_ACTION_REPLACE  0x04
+
+/* access rights attributes */
+#ifndef AR_READ_ONLY
+#define AR_READ_ONLY       0x0001
+#define AR_WRITE_ONLY      0x0002
+#define AR_DENY_READ       0x0004
+#define AR_DENY_WRITE      0x0008
+#define AR_COMPATIBILITY   0x0010
+#define AR_WRITE_THROUGH   0x0040
+#define AR_OPEN_COMPRESSED 0x0100
+#endif
+
+struct nw_nfs_info {
+        __u32 mode;
+        __u32 rdev;
+};
+
+struct nw_info_struct {
+        __u32 spaceAlloc __attribute__((packed));
+        __le32 attributes __attribute__((packed));
+        __u16 flags __attribute__((packed));
+        __le32 dataStreamSize __attribute__((packed));
+        __le32 totalStreamSize __attribute__((packed));
+        __u16 numberOfStreams __attribute__((packed));
+        __le16 creationTime __attribute__((packed));
+        __le16 creationDate __attribute__((packed));
+        __u32 creatorID __attribute__((packed));
+        __le16 modifyTime __attribute__((packed));
+        __le16 modifyDate __attribute__((packed));
+        __u32 modifierID __attribute__((packed));
+        __le16 lastAccessDate __attribute__((packed));
+        __u16 archiveTime __attribute__((packed));
+        __u16 archiveDate __attribute__((packed));
+        __u32 archiverID __attribute__((packed));
+        __u16 inheritedRightsMask __attribute__((packed));
+        __le32 dirEntNum __attribute__((packed));
+        __le32 DosDirNum __attribute__((packed));
+        __u32 volNumber __attribute__((packed));
+        __u32 EADataSize __attribute__((packed));
+        __u32 EAKeyCount __attribute__((packed));
+        __u32 EAKeySize __attribute__((packed));
+        __u32 NSCreator __attribute__((packed));
+        __u8 nameLen __attribute__((packed));
+        __u8 entryName[256] __attribute__((packed));
+        /* libncp may depend on there being nothing after entryName */
+#ifdef __KERNEL__
+        struct nw_nfs_info nfs;
+#endif
+};
+
+/* modify mask - use with MODIFY_DOS_INFO structure */
+#define DM_ATTRIBUTES             (cpu_to_le32(0x02))
+#define DM_CREATE_DATE            (cpu_to_le32(0x04))
+#define DM_CREATE_TIME            (cpu_to_le32(0x08))
+#define DM_CREATOR_ID             (cpu_to_le32(0x10))
+#define DM_ARCHIVE_DATE           (cpu_to_le32(0x20))
+#define DM_ARCHIVE_TIME           (cpu_to_le32(0x40))
+#define DM_ARCHIVER_ID            (cpu_to_le32(0x80))
+#define DM_MODIFY_DATE            (cpu_to_le32(0x0100))
+#define DM_MODIFY_TIME            (cpu_to_le32(0x0200))
+#define DM_MODIFIER_ID            (cpu_to_le32(0x0400))
+#define DM_LAST_ACCESS_DATE       (cpu_to_le32(0x0800))
+#define DM_INHERITED_RIGHTS_MASK  (cpu_to_le32(0x1000))
+#define DM_MAXIMUM_SPACE          (cpu_to_le32(0x2000))
+
+struct nw_modify_dos_info {
+        __le32 attributes __attribute__((packed));
+        __le16 creationDate __attribute__((packed));
+        __le16 creationTime __attribute__((packed));
+        __u32 creatorID __attribute__((packed));
+        __le16 modifyDate __attribute__((packed));
+        __le16 modifyTime __attribute__((packed));
+        __u32 modifierID __attribute__((packed));
+        __u16 archiveDate __attribute__((packed));
+        __u16 archiveTime __attribute__((packed));
+        __u32 archiverID __attribute__((packed));
+        __le16 lastAccessDate __attribute__((packed));
+        __u16 inheritanceGrantMask __attribute__((packed));
+        __u16 inheritanceRevokeMask __attribute__((packed));
+        __u32 maximumSpace __attribute__((packed));
+};
+
+struct nw_search_sequence {
+        __u8 volNumber __attribute__((packed));
+        __u32 dirBase __attribute__((packed));
+        __u32 sequence __attribute__((packed));
+};
+
+#endif                          /* _LINUX_NCP_H */
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
new file mode 100644
index 000000000000..7297e4372c0f
--- /dev/null
+++ b/include/linux/ncp_fs.h
@@ -0,0 +1,300 @@
+/*
+ *  ncp_fs.h
+ *
+ *  Copyright (C) 1995, 1996 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_FS_H
+#define _LINUX_NCP_FS_H
+
+#include <linux/fs.h>
+#include <linux/in.h>
+#include <linux/types.h>
+
+#include <linux/ncp_fs_i.h>
+#include <linux/ncp_fs_sb.h>
+#include <linux/ipx.h>
+#include <linux/ncp_no.h>
+
+/*
+ * ioctl commands
+ */
+
+struct ncp_ioctl_request {
+        unsigned int function;
+        unsigned int size;
+        char __user *data;
+};
+
+struct ncp_fs_info {
+        int version;
+        struct sockaddr_ipx addr;
+        __kernel_uid_t mounted_uid;
+        int connection;         /* Connection number the server assigned us */
+        int buffer_size;        /* The negotiated buffer size, to be
+                                   used for read/write requests! */
+
+        int volume_number;
+        __le32 directory_id;
+};
+
+struct ncp_fs_info_v2 {
+        int version;
+        unsigned long mounted_uid;
+        unsigned int connection;
+        unsigned int buffer_size;
+
+        unsigned int volume_number;
+        __le32 directory_id;
+
+        __u32 dummy1;
+        __u32 dummy2;
+        __u32 dummy3;
+};
+
+struct ncp_sign_init
+{
+        char sign_root[8];
+        char sign_last[16];
+};
+
+struct ncp_lock_ioctl
+{
+#define NCP_LOCK_LOG    0
+#define NCP_LOCK_SH     1
+#define NCP_LOCK_EX     2
+#define NCP_LOCK_CLEAR  256
+        int             cmd;
+        int             origin;
+        unsigned int    offset;
+        unsigned int    length;
+#define NCP_LOCK_DEFAULT_TIMEOUT        18
+#define NCP_LOCK_MAX_TIMEOUT            180
+        int             timeout;
+};
+
+struct ncp_setroot_ioctl
+{
+        int             volNumber;
+        int             namespace;
+        __le32          dirEntNum;
+};
+
+struct ncp_objectname_ioctl
+{
+#define NCP_AUTH_NONE   0x00
+#define NCP_AUTH_BIND   0x31
+#define NCP_AUTH_NDS    0x32
+        int             auth_type;
+        size_t          object_name_len;
+        void __user *   object_name;    /* an userspace data, in most cases user name */
+};
+
+struct ncp_privatedata_ioctl
+{
+        size_t          len;
+        void __user *   data;           /* ~1000 for NDS */
+};
+
+/* NLS charsets by ioctl */
+#define NCP_IOCSNAME_LEN 20
+struct ncp_nls_ioctl
+{
+        unsigned char codepage[NCP_IOCSNAME_LEN+1];
+        unsigned char iocharset[NCP_IOCSNAME_LEN+1];
+};
+
+#define NCP_IOC_NCPREQUEST              _IOR('n', 1, struct ncp_ioctl_request)
+#define NCP_IOC_GETMOUNTUID             _IOW('n', 2, __kernel_old_uid_t)
+#define NCP_IOC_GETMOUNTUID2            _IOW('n', 2, unsigned long)
+
+#define NCP_IOC_CONN_LOGGED_IN          _IO('n', 3)
+
+#define NCP_GET_FS_INFO_VERSION    (1)
+#define NCP_IOC_GET_FS_INFO             _IOWR('n', 4, struct ncp_fs_info)
+#define NCP_GET_FS_INFO_VERSION_V2 (2)
+#define NCP_IOC_GET_FS_INFO_V2          _IOWR('n', 4, struct ncp_fs_info_v2)
+
+#define NCP_IOC_SIGN_INIT               _IOR('n', 5, struct ncp_sign_init)
+#define NCP_IOC_SIGN_WANTED             _IOR('n', 6, int)
+#define NCP_IOC_SET_SIGN_WANTED         _IOW('n', 6, int)
+
+#define NCP_IOC_LOCKUNLOCK              _IOR('n', 7, struct ncp_lock_ioctl)
+
+#define NCP_IOC_GETROOT                 _IOW('n', 8, struct ncp_setroot_ioctl)
+#define NCP_IOC_SETROOT                 _IOR('n', 8, struct ncp_setroot_ioctl)
+
+#define NCP_IOC_GETOBJECTNAME           _IOWR('n', 9, struct ncp_objectname_ioctl)
+#define NCP_IOC_SETOBJECTNAME           _IOR('n', 9, struct ncp_objectname_ioctl)
+#define NCP_IOC_GETPRIVATEDATA          _IOWR('n', 10, struct ncp_privatedata_ioctl)
+#define NCP_IOC_SETPRIVATEDATA          _IOR('n', 10, struct ncp_privatedata_ioctl)
+
+#define NCP_IOC_GETCHARSETS             _IOWR('n', 11, struct ncp_nls_ioctl)
+#define NCP_IOC_SETCHARSETS             _IOR('n', 11, struct ncp_nls_ioctl)
+
+#define NCP_IOC_GETDENTRYTTL            _IOW('n', 12, __u32)
+#define NCP_IOC_SETDENTRYTTL            _IOR('n', 12, __u32)
+
+/*
+ * The packet size to allocate. One page should be enough.
+ */
+#define NCP_PACKET_SIZE 4070
+
+#define NCP_MAXPATHLEN 255
+#define NCP_MAXNAMELEN 14
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+
+/* undef because public define in umsdos_fs.h (ncp_fs.h isn't public) */
+#undef PRINTK
+/* define because it is easy to change PRINTK to {*}PRINTK */
+#define PRINTK(format, args...) printk(KERN_DEBUG format , ## args)
+
+#undef NCPFS_PARANOIA
+#ifdef NCPFS_PARANOIA
+#define PPRINTK(format, args...) PRINTK(format , ## args)
+#else
+#define PPRINTK(format, args...)
+#endif
+
+#ifndef DEBUG_NCP
+#define DEBUG_NCP 0
+#endif
+#if DEBUG_NCP > 0
+#define DPRINTK(format, args...) PRINTK(format , ## args)
+#else
+#define DPRINTK(format, args...)
+#endif
+#if DEBUG_NCP > 1
+#define DDPRINTK(format, args...) PRINTK(format , ## args)
+#else
+#define DDPRINTK(format, args...)
+#endif
+
+#define NCP_MAX_RPC_TIMEOUT (6*HZ)
+
+
+struct ncp_entry_info {
+        struct nw_info_struct   i;
+        ino_t                   ino;
+        int                     opened;
+        int                     access;
+        unsigned int            volume;
+        __u8                    file_handle[6];
+};
+
+/* Guess, what 0x564c is :-) */
+#define NCP_SUPER_MAGIC  0x564c
+
+
+static inline struct ncp_server *NCP_SBP(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+#define NCP_SERVER(inode)       NCP_SBP((inode)->i_sb)
+static inline struct ncp_inode_info *NCP_FINFO(struct inode *inode)
+{
+        return container_of(inode, struct ncp_inode_info, vfs_inode);
+}
+
+#ifdef DEBUG_NCP_MALLOC
+
+#include <linux/slab.h>
+
+extern int ncp_malloced;
+extern int ncp_current_malloced;
+
+static inline void *
+ ncp_kmalloc(unsigned int size, int priority)
+{
+        ncp_malloced += 1;
+        ncp_current_malloced += 1;
+        return kmalloc(size, priority);
+}
+
+static inline void ncp_kfree_s(void *obj, int size)
+{
+        ncp_current_malloced -= 1;
+        kfree(obj);
+}
+
+#else                           /* DEBUG_NCP_MALLOC */
+
+#define ncp_kmalloc(s,p) kmalloc(s,p)
+#define ncp_kfree_s(o,s) kfree(o)
+
+#endif                          /* DEBUG_NCP_MALLOC */
+
+/* linux/fs/ncpfs/inode.c */
+int ncp_notify_change(struct dentry *, struct iattr *);
+struct inode *ncp_iget(struct super_block *, struct ncp_entry_info *);
+void ncp_update_inode(struct inode *, struct ncp_entry_info *);
+void ncp_update_inode2(struct inode *, struct ncp_entry_info *);
+
+/* linux/fs/ncpfs/dir.c */
+extern struct inode_operations ncp_dir_inode_operations;
+extern struct file_operations ncp_dir_operations;
+int ncp_conn_logged_in(struct super_block *);
+int ncp_date_dos2unix(__le16 time, __le16 date);
+void ncp_date_unix2dos(int unix_date, __le16 * time, __le16 * date);
+
+/* linux/fs/ncpfs/ioctl.c */
+int ncp_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+
+/* linux/fs/ncpfs/sock.c */
+int ncp_request2(struct ncp_server *server, int function,
+        void* reply, int max_reply_size);
+static inline int ncp_request(struct ncp_server *server, int function) {
+        return ncp_request2(server, function, server->packet, server->packet_size);
+}
+int ncp_connect(struct ncp_server *server);
+int ncp_disconnect(struct ncp_server *server);
+void ncp_lock_server(struct ncp_server *server);
+void ncp_unlock_server(struct ncp_server *server);
+
+/* linux/fs/ncpfs/file.c */
+extern struct inode_operations ncp_file_inode_operations;
+extern struct file_operations ncp_file_operations;
+int ncp_make_open(struct inode *, int);
+
+/* linux/fs/ncpfs/mmap.c */
+int ncp_mmap(struct file *, struct vm_area_struct *);
+
+/* linux/fs/ncpfs/ncplib_kernel.c */
+int ncp_make_closed(struct inode *);
+
+#define ncp_namespace(i)        (NCP_SERVER(i)->name_space[NCP_FINFO(i)->volNumber])
+
+static inline int ncp_preserve_entry_case(struct inode *i, __u32 nscreator)
+{
+#ifdef CONFIG_NCPFS_SMALLDOS
+        int ns = ncp_namespace(i);
+
+        if ((ns == NW_NS_DOS)
+#ifdef CONFIG_NCPFS_OS2_NS
+                || ((ns == NW_NS_OS2) && (nscreator == NW_NS_DOS))
+#endif /* CONFIG_NCPFS_OS2_NS */
+                                )
+                return 0;
+#endif /* CONFIG_NCPFS_SMALLDOS */
+        return 1;
+}
+
+#define ncp_preserve_case(i)    (ncp_namespace(i) != NW_NS_DOS)
+
+static inline int ncp_case_sensitive(struct inode *i)
+{
+#ifdef CONFIG_NCPFS_NFS_NS
+        return ncp_namespace(i) == NW_NS_NFS;
+#else
+        return 0;
+#endif  /* CONFIG_NCPFS_NFS_NS */
+} 
+
+#endif                          /* __KERNEL__ */
+
+#endif                          /* _LINUX_NCP_FS_H */
diff --git a/include/linux/ncp_fs_i.h b/include/linux/ncp_fs_i.h
new file mode 100644
index 000000000000..415be1ec6f98
--- /dev/null
+++ b/include/linux/ncp_fs_i.h
@@ -0,0 +1,33 @@
+/*
+ *  ncp_fs_i.h
+ *
+ *  Copyright (C) 1995 Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_FS_I
+#define _LINUX_NCP_FS_I
+
+#ifdef __KERNEL__
+
+/*
+ * This is the ncpfs part of the inode structure. This must contain
+ * all the information we need to work with an inode after creation.
+ */
+struct ncp_inode_info {
+        __le32  dirEntNum;
+        __le32  DosDirNum;
+        __u8    volNumber;
+        __le32  nwattr;
+        struct semaphore open_sem;
+        atomic_t        opened;
+        int     access;
+        int     flags;
+#define NCPI_KLUDGE_SYMLINK     0x0001
+        __u8    file_handle[6];
+        struct inode vfs_inode;
+};
+
+#endif  /* __KERNEL__ */
+
+#endif  /* _LINUX_NCP_FS_I */
diff --git a/include/linux/ncp_fs_sb.h b/include/linux/ncp_fs_sb.h
new file mode 100644
index 000000000000..cf858eb80f0b
--- /dev/null
+++ b/include/linux/ncp_fs_sb.h
@@ -0,0 +1,157 @@
+/*
+ *  ncp_fs_sb.h
+ *
+ *  Copyright (C) 1995, 1996 by Volker Lendecke
+ *
+ */
+
+#ifndef _NCP_FS_SB
+#define _NCP_FS_SB
+
+#include <linux/types.h>
+#include <linux/ncp_mount.h>
+#include <linux/net.h>
+
+#ifdef __KERNEL__
+
+#include <linux/workqueue.h>
+
+#define NCP_DEFAULT_OPTIONS 0           /* 2 for packet signatures */
+
+struct sock;
+
+struct ncp_server {
+
+        struct ncp_mount_data_kernel m; /* Nearly all of the mount data is of
+                                           interest for us later, so we store
+                                           it completely. */
+
+        __u8 name_space[NCP_NUMBER_OF_VOLUMES + 2];
+
+        struct file *ncp_filp;  /* File pointer to ncp socket */
+        struct socket *ncp_sock;/* ncp socket */
+        struct file *info_filp;
+        struct socket *info_sock;
+
+        u8 sequence;
+        u8 task;
+        u16 connection;         /* Remote connection number */
+
+        u8 completion;          /* Status message from server */
+        u8 conn_status;         /* Bit 4 = 1 ==> Server going down, no
+                                   requests allowed anymore.
+                                   Bit 0 = 1 ==> Server is down. */
+
+        int buffer_size;        /* Negotiated bufsize */
+
+        int reply_size;         /* Size of last reply */
+
+        int packet_size;
+        unsigned char *packet;  /* Here we prepare requests and
+                                   receive replies */
+
+        int lock;               /* To prevent mismatch in protocols. */
+        struct semaphore sem;
+
+        int current_size;       /* for packet preparation */
+        int has_subfunction;
+        int ncp_reply_size;
+
+        int root_setuped;
+
+        /* info for packet signing */
+        int sign_wanted;        /* 1=Server needs signed packets */
+        int sign_active;        /* 0=don't do signing, 1=do */
+        char sign_root[8];      /* generated from password and encr. key */
+        char sign_last[16];     
+
+        /* Authentication info: NDS or BINDERY, username */
+        struct {
+                int     auth_type;
+                size_t  object_name_len;
+                void*   object_name;
+                int     object_type;
+        } auth;
+        /* Password info */
+        struct {
+                size_t  len;
+                void*   data;
+        } priv;
+
+        /* nls info: codepage for volume and charset for I/O */
+        struct nls_table *nls_vol;
+        struct nls_table *nls_io;
+
+        /* maximum age in jiffies */
+        int dentry_ttl;
+
+        /* miscellaneous */
+        unsigned int flags;
+
+        spinlock_t requests_lock;       /* Lock accesses to tx.requests, tx.creq and rcv.creq when STREAM mode */
+
+        void (*data_ready)(struct sock* sk, int len);
+        void (*error_report)(struct sock* sk);
+        void (*write_space)(struct sock* sk);   /* STREAM mode only */
+        struct {
+                struct work_struct tq;          /* STREAM/DGRAM: data/error ready */
+                struct ncp_request_reply* creq; /* STREAM/DGRAM: awaiting reply from this request */
+                struct semaphore creq_sem;      /* DGRAM only: lock accesses to rcv.creq */
+
+                unsigned int state;             /* STREAM only: receiver state */
+                struct {
+                        __u32 magic __attribute__((packed));
+                        __u32 len __attribute__((packed));
+                        __u16 type __attribute__((packed));
+                        __u16 p1 __attribute__((packed));
+                        __u16 p2 __attribute__((packed));
+                        __u16 p3 __attribute__((packed));
+                        __u16 type2 __attribute__((packed));
+                } buf;                          /* STREAM only: temporary buffer */
+                unsigned char* ptr;             /* STREAM only: pointer to data */
+                size_t len;                     /* STREAM only: length of data to receive */
+        } rcv;
+        struct {
+                struct list_head requests;      /* STREAM only: queued requests */
+                struct work_struct tq;          /* STREAM only: transmitter ready */
+                struct ncp_request_reply* creq; /* STREAM only: currently transmitted entry */
+        } tx;
+        struct timer_list timeout_tm;           /* DGRAM only: timeout timer */
+        struct work_struct timeout_tq;          /* DGRAM only: associated queue, we run timers from process context */
+        int timeout_last;                       /* DGRAM only: current timeout length */
+        int timeout_retries;                    /* DGRAM only: retries left */
+        struct {
+                size_t len;
+                __u8 data[128];
+        } unexpected_packet;
+};
+
+extern void ncp_tcp_rcv_proc(void *server);
+extern void ncp_tcp_tx_proc(void *server);
+extern void ncpdgram_rcv_proc(void *server);
+extern void ncpdgram_timeout_proc(void *server);
+extern void ncpdgram_timeout_call(unsigned long server);
+extern void ncp_tcp_data_ready(struct sock* sk, int len);
+extern void ncp_tcp_write_space(struct sock* sk);
+extern void ncp_tcp_error_report(struct sock* sk);
+
+#define NCP_FLAG_UTF8   1
+
+#define NCP_CLR_FLAG(server, flag)      ((server)->flags &= ~(flag))
+#define NCP_SET_FLAG(server, flag)      ((server)->flags |= (flag))
+#define NCP_IS_FLAG(server, flag)       ((server)->flags & (flag))
+
+static inline int ncp_conn_valid(struct ncp_server *server)
+{
+        return ((server->conn_status & 0x11) == 0);
+}
+
+static inline void ncp_invalidate_conn(struct ncp_server *server)
+{
+        server->conn_status |= 0x01;
+}
+
+#endif                          /* __KERNEL__ */
+
+#endif
+ 
diff --git a/include/linux/ncp_mount.h b/include/linux/ncp_mount.h
new file mode 100644
index 000000000000..f46bddcdbd3b
--- /dev/null
+++ b/include/linux/ncp_mount.h
@@ -0,0 +1,93 @@
+/*
+ *  ncp_mount.h
+ *
+ *  Copyright (C) 1995, 1996 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_MOUNT_H
+#define _LINUX_NCP_MOUNT_H
+
+#include <linux/types.h>
+#include <linux/ncp.h>
+
+#define NCP_MOUNT_VERSION 3     /* Binary */
+
+/* Values for flags */
+#define NCP_MOUNT_SOFT          0x0001
+#define NCP_MOUNT_INTR          0x0002
+#define NCP_MOUNT_STRONG        0x0004  /* enable delete/rename of r/o files */
+#define NCP_MOUNT_NO_OS2        0x0008  /* do not use OS/2 (LONG) namespace */
+#define NCP_MOUNT_NO_NFS        0x0010  /* do not use NFS namespace */
+#define NCP_MOUNT_EXTRAS        0x0020
+#define NCP_MOUNT_SYMLINKS      0x0040  /* enable symlinks */
+#define NCP_MOUNT_NFS_EXTRAS    0x0080  /* Enable use of NFS NS meta-info */
+
+struct ncp_mount_data {
+        int version;
+        unsigned int ncp_fd;    /* The socket to the ncp port */
+        __kernel_uid_t mounted_uid;     /* Who may umount() this filesystem? */
+        __kernel_pid_t wdog_pid;                /* Who cares for our watchdog packets? */
+
+        unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
+        unsigned int time_out;  /* How long should I wait after
+                                   sending a NCP request? */
+        unsigned int retry_count;       /* And how often should I retry? */
+        unsigned int flags;
+
+        __kernel_uid_t uid;
+        __kernel_gid_t gid;
+        __kernel_mode_t file_mode;
+        __kernel_mode_t dir_mode;
+};
+
+#define NCP_MOUNT_VERSION_V4    (4)     /* Binary or text */
+
+struct ncp_mount_data_v4 {
+        int version;
+        unsigned long flags;    /* NCP_MOUNT_* flags */
+        /* MIPS uses long __kernel_uid_t, but... */
+        /* we neever pass -1, so it is safe */
+        unsigned long mounted_uid;      /* Who may umount() this filesystem? */
+        /* MIPS uses long __kernel_pid_t */
+        long wdog_pid;          /* Who cares for our watchdog packets? */
+
+        unsigned int ncp_fd;    /* The socket to the ncp port */
+        unsigned int time_out;  /* How long should I wait after
+                                   sending a NCP request? */
+        unsigned int retry_count;       /* And how often should I retry? */
+
+        /* MIPS uses long __kernel_uid_t... */
+        /* we never pass -1, so it is safe */
+        unsigned long uid;
+        unsigned long gid;
+        /* MIPS uses unsigned long __kernel_mode_t */
+        unsigned long file_mode;
+        unsigned long dir_mode;
+};
+
+#define NCP_MOUNT_VERSION_V5    (5)     /* Text only */
+
+#ifdef __KERNEL__
+
+struct ncp_mount_data_kernel {
+        unsigned long    flags;         /* NCP_MOUNT_* flags */
+        unsigned int     int_flags;     /* internal flags */
+#define NCP_IMOUNT_LOGGEDIN_POSSIBLE    0x0001
+        __kernel_uid32_t mounted_uid;   /* Who may umount() this filesystem? */
+        __kernel_pid_t   wdog_pid;              /* Who cares for our watchdog packets? */
+        unsigned int     ncp_fd;        /* The socket to the ncp port */
+        unsigned int     time_out;      /* How long should I wait after
+                                           sending a NCP request? */
+        unsigned int     retry_count;   /* And how often should I retry? */
+        unsigned char    mounted_vol[NCP_VOLNAME_LEN + 1];
+        __kernel_uid32_t uid;
+        __kernel_gid32_t gid;
+        __kernel_mode_t  file_mode;
+        __kernel_mode_t  dir_mode;
+        int              info_fd;
+};
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/ncp_no.h b/include/linux/ncp_no.h
new file mode 100644
index 000000000000..f56a696a7cc6
--- /dev/null
+++ b/include/linux/ncp_no.h
@@ -0,0 +1,19 @@
+#ifndef _NCP_NO
+#define _NCP_NO
+
+/* these define the attribute byte as seen by NCP */
+#define aRONLY                  (__constant_cpu_to_le32(1))
+#define aHIDDEN                 (__constant_cpu_to_le32(2))
+#define aSYSTEM                 (__constant_cpu_to_le32(4))
+#define aEXECUTE                (__constant_cpu_to_le32(8))
+#define aDIR                    (__constant_cpu_to_le32(0x10))
+#define aARCH                   (__constant_cpu_to_le32(0x20))
+#define aSHARED                 (__constant_cpu_to_le32(0x80))
+#define aDONTSUBALLOCATE        (__constant_cpu_to_le32(1L<<11))
+#define aTRANSACTIONAL          (__constant_cpu_to_le32(1L<<12))
+#define aPURGE                  (__constant_cpu_to_le32(1L<<16))
+#define aRENAMEINHIBIT          (__constant_cpu_to_le32(1L<<17))
+#define aDELETEINHIBIT          (__constant_cpu_to_le32(1L<<18))
+#define aDONTCOMPRESS           (__constant_cpu_to_le32(1L<<27))
+
+#endif /* _NCP_NO */
diff --git a/include/linux/net.h b/include/linux/net.h
new file mode 100644
index 000000000000..7823b3482506
--- /dev/null
+++ b/include/linux/net.h
@@ -0,0 +1,287 @@
+/*
+ * NET          An implementation of the SOCKET network access protocol.
+ *              This is the master header file for the Linux NET layer,
+ *              or, in plain English: the networking handling part of the
+ *              kernel.
+ *
+ * Version:     @(#)net.h       1.0.3   05/25/93
+ *
+ * Authors:     Orest Zborowski, <obz@Kodak.COM>
+ *              Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_NET_H
+#define _LINUX_NET_H
+
+#include <linux/config.h>
+#include <linux/wait.h>
+#include <linux/stringify.h>
+#include <asm/socket.h>
+
+struct poll_table_struct;
+struct inode;
+
+#define NPROTO          32              /* should be enough for now..   */
+
+#define SYS_SOCKET      1               /* sys_socket(2)                */
+#define SYS_BIND        2               /* sys_bind(2)                  */
+#define SYS_CONNECT     3               /* sys_connect(2)               */
+#define SYS_LISTEN      4               /* sys_listen(2)                */
+#define SYS_ACCEPT      5               /* sys_accept(2)                */
+#define SYS_GETSOCKNAME 6               /* sys_getsockname(2)           */
+#define SYS_GETPEERNAME 7               /* sys_getpeername(2)           */
+#define SYS_SOCKETPAIR  8               /* sys_socketpair(2)            */
+#define SYS_SEND        9               /* sys_send(2)                  */
+#define SYS_RECV        10              /* sys_recv(2)                  */
+#define SYS_SENDTO      11              /* sys_sendto(2)                */
+#define SYS_RECVFROM    12              /* sys_recvfrom(2)              */
+#define SYS_SHUTDOWN    13              /* sys_shutdown(2)              */
+#define SYS_SETSOCKOPT  14              /* sys_setsockopt(2)            */
+#define SYS_GETSOCKOPT  15              /* sys_getsockopt(2)            */
+#define SYS_SENDMSG     16              /* sys_sendmsg(2)               */
+#define SYS_RECVMSG     17              /* sys_recvmsg(2)               */
+
+typedef enum {
+        SS_FREE = 0,                    /* not allocated                */
+        SS_UNCONNECTED,                 /* unconnected to any socket    */
+        SS_CONNECTING,                  /* in process of connecting     */
+        SS_CONNECTED,                   /* connected to socket          */
+        SS_DISCONNECTING                /* in process of disconnecting  */
+} socket_state;
+
+#define __SO_ACCEPTCON  (1 << 16)       /* performed a listen           */
+
+#ifdef __KERNEL__
+
+#define SOCK_ASYNC_NOSPACE      0
+#define SOCK_ASYNC_WAITDATA     1
+#define SOCK_NOSPACE            2
+#define SOCK_PASSCRED           3
+
+#ifndef ARCH_HAS_SOCKET_TYPES
+/** sock_type - Socket types
+ * 
+ * When adding some new socket type please
+ * grep ARCH_HAS_SOCKET_TYPE include/asm-* /socket.h, at least MIPS
+ * overrides this enum for binary compat reasons.
+ * 
+ * @SOCK_STREAM - stream (connection) socket
+ * @SOCK_DGRAM - datagram (conn.less) socket
+ * @SOCK_RAW - raw socket
+ * @SOCK_RDM - reliably-delivered message
+ * @SOCK_SEQPACKET - sequential packet socket 
+ * @SOCK_PACKET - linux specific way of getting packets at the dev level.
+ *                For writing rarp and other similar things on the user level.
+ */
+enum sock_type {
+        SOCK_STREAM     = 1,
+        SOCK_DGRAM      = 2,
+        SOCK_RAW        = 3,
+        SOCK_RDM        = 4,
+        SOCK_SEQPACKET  = 5,
+        SOCK_PACKET     = 10,
+};
+
+#define SOCK_MAX (SOCK_PACKET + 1)
+
+#endif /* ARCH_HAS_SOCKET_TYPES */
+
+/**
+ *  struct socket - general BSD socket
+ *  @state - socket state (%SS_CONNECTED, etc)
+ *  @flags - socket flags (%SOCK_ASYNC_NOSPACE, etc)
+ *  @ops - protocol specific socket operations
+ *  @fasync_list - Asynchronous wake up list
+ *  @file - File back pointer for gc
+ *  @sk - internal networking protocol agnostic socket representation
+ *  @wait - wait queue for several uses
+ *  @type - socket type (%SOCK_STREAM, etc)
+ *  @passcred - credentials (used only in Unix Sockets (aka PF_LOCAL))
+ */
+struct socket {
+        socket_state            state;
+        unsigned long           flags;
+        struct proto_ops        *ops;
+        struct fasync_struct    *fasync_list;
+        struct file             *file;
+        struct sock             *sk;
+        wait_queue_head_t       wait;
+        short                   type;
+};
+
+struct vm_area_struct;
+struct page;
+struct kiocb;
+struct sockaddr;
+struct msghdr;
+struct module;
+
+struct proto_ops {
+        int             family;
+        struct module   *owner;
+        int             (*release)   (struct socket *sock);
+        int             (*bind)      (struct socket *sock,
+                                      struct sockaddr *myaddr,
+                                      int sockaddr_len);
+        int             (*connect)   (struct socket *sock,
+                                      struct sockaddr *vaddr,
+                                      int sockaddr_len, int flags);
+        int             (*socketpair)(struct socket *sock1,
+                                      struct socket *sock2);
+        int             (*accept)    (struct socket *sock,
+                                      struct socket *newsock, int flags);
+        int             (*getname)   (struct socket *sock,
+                                      struct sockaddr *addr,
+                                      int *sockaddr_len, int peer);
+        unsigned int    (*poll)      (struct file *file, struct socket *sock,
+                                      struct poll_table_struct *wait);
+        int             (*ioctl)     (struct socket *sock, unsigned int cmd,
+                                      unsigned long arg);
+        int             (*listen)    (struct socket *sock, int len);
+        int             (*shutdown)  (struct socket *sock, int flags);
+        int             (*setsockopt)(struct socket *sock, int level,
+                                      int optname, char __user *optval, int optlen);
+        int             (*getsockopt)(struct socket *sock, int level,
+                                      int optname, char __user *optval, int __user *optlen);
+        int             (*sendmsg)   (struct kiocb *iocb, struct socket *sock,
+                                      struct msghdr *m, size_t total_len);
+        int             (*recvmsg)   (struct kiocb *iocb, struct socket *sock,
+                                      struct msghdr *m, size_t total_len,
+                                      int flags);
+        int             (*mmap)      (struct file *file, struct socket *sock,
+                                      struct vm_area_struct * vma);
+        ssize_t         (*sendpage)  (struct socket *sock, struct page *page,
+                                      int offset, size_t size, int flags);
+};
+
+struct net_proto_family {
+        int             family;
+        int             (*create)(struct socket *sock, int protocol);
+        /* These are counters for the number of different methods of
+           each we support */
+        short           authentication;
+        short           encryption;
+        short           encrypt_net;
+        struct module   *owner;
+};
+
+struct iovec;
+struct kvec;
+
+extern int           sock_wake_async(struct socket *sk, int how, int band);
+extern int           sock_register(struct net_proto_family *fam);
+extern int           sock_unregister(int family);
+extern int           sock_create(int family, int type, int proto,
+                                 struct socket **res);
+extern int           sock_create_kern(int family, int type, int proto,
+                                      struct socket **res);
+extern int           sock_create_lite(int family, int type, int proto,
+                                      struct socket **res); 
+extern void          sock_release(struct socket *sock);
+extern int           sock_sendmsg(struct socket *sock, struct msghdr *msg,
+                                  size_t len);
+extern int           sock_recvmsg(struct socket *sock, struct msghdr *msg,
+                                  size_t size, int flags);
+extern int           sock_map_fd(struct socket *sock);
+extern struct socket *sockfd_lookup(int fd, int *err);
+#define              sockfd_put(sock) fput(sock->file)
+extern int           net_ratelimit(void);
+extern unsigned long net_random(void);
+extern void          net_srandom(unsigned long);
+extern void          net_random_init(void);
+
+extern int           kernel_sendmsg(struct socket *sock, struct msghdr *msg,
+                                    struct kvec *vec, size_t num, size_t len);
+extern int           kernel_recvmsg(struct socket *sock, struct msghdr *msg,
+                                    struct kvec *vec, size_t num,
+                                    size_t len, int flags);
+
+#ifndef CONFIG_SMP
+#define SOCKOPS_WRAPPED(name) name
+#define SOCKOPS_WRAP(name, fam)
+#else
+
+#define SOCKOPS_WRAPPED(name) __unlocked_##name
+
+#define SOCKCALL_WRAP(name, call, parms, args)          \
+static int __lock_##name##_##call  parms                \
+{                                                       \
+        int ret;                                        \
+        lock_kernel();                                  \
+        ret = __unlocked_##name##_ops.call  args ;\
+        unlock_kernel();                                \
+        return ret;                                     \
+}
+
+#define SOCKCALL_UWRAP(name, call, parms, args)         \
+static unsigned int __lock_##name##_##call  parms       \
+{                                                       \
+        int ret;                                        \
+        lock_kernel();                                  \
+        ret = __unlocked_##name##_ops.call  args ;\
+        unlock_kernel();                                \
+        return ret;                                     \
+}
+
+
+#define SOCKOPS_WRAP(name, fam)                                 \
+SOCKCALL_WRAP(name, release, (struct socket *sock), (sock))     \
+SOCKCALL_WRAP(name, bind, (struct socket *sock, struct sockaddr *uaddr, int addr_len), \
+              (sock, uaddr, addr_len))                          \
+SOCKCALL_WRAP(name, connect, (struct socket *sock, struct sockaddr * uaddr, \
+                              int addr_len, int flags),         \
+              (sock, uaddr, addr_len, flags))                   \
+SOCKCALL_WRAP(name, socketpair, (struct socket *sock1, struct socket *sock2), \
+              (sock1, sock2))                                   \
+SOCKCALL_WRAP(name, accept, (struct socket *sock, struct socket *newsock, \
+                         int flags), (sock, newsock, flags)) \
+SOCKCALL_WRAP(name, getname, (struct socket *sock, struct sockaddr *uaddr, \
+                         int *addr_len, int peer), (sock, uaddr, addr_len, peer)) \
+SOCKCALL_UWRAP(name, poll, (struct file *file, struct socket *sock, struct poll_table_struct *wait), \
+              (file, sock, wait)) \
+SOCKCALL_WRAP(name, ioctl, (struct socket *sock, unsigned int cmd, \
+                         unsigned long arg), (sock, cmd, arg)) \
+SOCKCALL_WRAP(name, listen, (struct socket *sock, int len), (sock, len)) \
+SOCKCALL_WRAP(name, shutdown, (struct socket *sock, int flags), (sock, flags)) \
+SOCKCALL_WRAP(name, setsockopt, (struct socket *sock, int level, int optname, \
+                         char __user *optval, int optlen), (sock, level, optname, optval, optlen)) \
+SOCKCALL_WRAP(name, getsockopt, (struct socket *sock, int level, int optname, \
+                         char __user *optval, int __user *optlen), (sock, level, optname, optval, optlen)) \
+SOCKCALL_WRAP(name, sendmsg, (struct kiocb *iocb, struct socket *sock, struct msghdr *m, size_t len), \
+              (iocb, sock, m, len)) \
+SOCKCALL_WRAP(name, recvmsg, (struct kiocb *iocb, struct socket *sock, struct msghdr *m, size_t len, int flags), \
+              (iocb, sock, m, len, flags)) \
+SOCKCALL_WRAP(name, mmap, (struct file *file, struct socket *sock, struct vm_area_struct *vma), \
+              (file, sock, vma)) \
+              \
+static struct proto_ops name##_ops = {                  \
+        .family         = fam,                          \
+        .owner          = THIS_MODULE,                  \
+        .release        = __lock_##name##_release,      \
+        .bind           = __lock_##name##_bind,         \
+        .connect        = __lock_##name##_connect,      \
+        .socketpair     = __lock_##name##_socketpair,   \
+        .accept         = __lock_##name##_accept,       \
+        .getname        = __lock_##name##_getname,      \
+        .poll           = __lock_##name##_poll,         \
+        .ioctl          = __lock_##name##_ioctl,        \
+        .listen         = __lock_##name##_listen,       \
+        .shutdown       = __lock_##name##_shutdown,     \
+        .setsockopt     = __lock_##name##_setsockopt,   \
+        .getsockopt     = __lock_##name##_getsockopt,   \
+        .sendmsg        = __lock_##name##_sendmsg,      \
+        .recvmsg        = __lock_##name##_recvmsg,      \
+        .mmap           = __lock_##name##_mmap,         \
+};
+#endif
+
+#define MODULE_ALIAS_NETPROTO(proto) \
+        MODULE_ALIAS("net-pf-" __stringify(proto))
+
+#endif /* __KERNEL__ */
+#endif  /* _LINUX_NET_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
new file mode 100644
index 000000000000..8d775be67833
--- /dev/null
+++ b/include/linux/netdevice.h
@@ -0,0 +1,933 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the Interfaces handler.
+ *
+ * Version:     @(#)dev.h       1.0.10  08/12/93
+ *
+ * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *              Corey Minyard <wf-rch!minyard@relay.EU.net>
+ *              Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
+ *              Alan Cox, <Alan.Cox@linux.org>
+ *              Bjorn Ekwall. <bj0rn@blox.se>
+ *              Pekka Riikonen <priikone@poseidon.pspt.fi>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ *              Moved to /usr/include/linux for NET3
+ */
+#ifndef _LINUX_NETDEVICE_H
+#define _LINUX_NETDEVICE_H
+
+#include <linux/if.h>
+#include <linux/if_ether.h>
+#include <linux/if_packet.h>
+
+#ifdef __KERNEL__
+#include <asm/atomic.h>
+#include <asm/cache.h>
+#include <asm/byteorder.h>
+
+#include <linux/config.h>
+#include <linux/device.h>
+#include <linux/percpu.h>
+
+struct divert_blk;
+struct vlan_group;
+struct ethtool_ops;
+struct netpoll;
+                                        /* source back-compat hooks */
+#define SET_ETHTOOL_OPS(netdev,ops) \
+        ( (netdev)->ethtool_ops = (ops) )
+
+#define HAVE_ALLOC_NETDEV               /* feature macro: alloc_xxxdev
+                                           functions are available. */
+#define HAVE_FREE_NETDEV                /* free_netdev() */
+#define HAVE_NETDEV_PRIV                /* netdev_priv() */
+
+#define NET_XMIT_SUCCESS        0
+#define NET_XMIT_DROP           1       /* skb dropped                  */
+#define NET_XMIT_CN             2       /* congestion notification      */
+#define NET_XMIT_POLICED        3       /* skb is shot by police        */
+#define NET_XMIT_BYPASS         4       /* packet does not leave via dequeue;
+                                           (TC use only - dev_queue_xmit
+                                           returns this as NET_XMIT_SUCCESS) */
+
+/* Backlog congestion levels */
+#define NET_RX_SUCCESS          0   /* keep 'em coming, baby */
+#define NET_RX_DROP             1  /* packet dropped */
+#define NET_RX_CN_LOW           2   /* storm alert, just in case */
+#define NET_RX_CN_MOD           3   /* Storm on its way! */
+#define NET_RX_CN_HIGH          4   /* The storm is here */
+#define NET_RX_BAD              5  /* packet dropped due to kernel error */
+
+#define net_xmit_errno(e)       ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
+
+#endif
+
+#define MAX_ADDR_LEN    32              /* Largest hardware address length */
+
+/* Driver transmit return codes */
+#define NETDEV_TX_OK 0          /* driver took care of packet */
+#define NETDEV_TX_BUSY 1        /* driver tx path was busy*/
+#define NETDEV_TX_LOCKED -1     /* driver tx lock was already taken */
+
+/*
+ *      Compute the worst case header length according to the protocols
+ *      used.
+ */
+ 
+#if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
+#define LL_MAX_HEADER   32
+#else
+#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
+#define LL_MAX_HEADER   96
+#else
+#define LL_MAX_HEADER   48
+#endif
+#endif
+
+#if !defined(CONFIG_NET_IPIP) && \
+    !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
+#define MAX_HEADER LL_MAX_HEADER
+#else
+#define MAX_HEADER (LL_MAX_HEADER + 48)
+#endif
+
+/*
+ *      Network device statistics. Akin to the 2.0 ether stats but
+ *      with byte counters.
+ */
+ 
+struct net_device_stats
+{
+        unsigned long   rx_packets;             /* total packets received       */
+        unsigned long   tx_packets;             /* total packets transmitted    */
+        unsigned long   rx_bytes;               /* total bytes received         */
+        unsigned long   tx_bytes;               /* total bytes transmitted      */
+        unsigned long   rx_errors;              /* bad packets received         */
+        unsigned long   tx_errors;              /* packet transmit problems     */
+        unsigned long   rx_dropped;             /* no space in linux buffers    */
+        unsigned long   tx_dropped;             /* no space available in linux  */
+        unsigned long   multicast;              /* multicast packets received   */
+        unsigned long   collisions;
+
+        /* detailed rx_errors: */
+        unsigned long   rx_length_errors;
+        unsigned long   rx_over_errors;         /* receiver ring buff overflow  */
+        unsigned long   rx_crc_errors;          /* recved pkt with crc error    */
+        unsigned long   rx_frame_errors;        /* recv'd frame alignment error */
+        unsigned long   rx_fifo_errors;         /* recv'r fifo overrun          */
+        unsigned long   rx_missed_errors;       /* receiver missed packet       */
+
+        /* detailed tx_errors */
+        unsigned long   tx_aborted_errors;
+        unsigned long   tx_carrier_errors;
+        unsigned long   tx_fifo_errors;
+        unsigned long   tx_heartbeat_errors;
+        unsigned long   tx_window_errors;
+        
+        /* for cslip etc */
+        unsigned long   rx_compressed;
+        unsigned long   tx_compressed;
+};
+
+
+/* Media selection options. */
+enum {
+        IF_PORT_UNKNOWN = 0,
+        IF_PORT_10BASE2,
+        IF_PORT_10BASET,
+        IF_PORT_AUI,
+        IF_PORT_100BASET,
+        IF_PORT_100BASETX,
+        IF_PORT_100BASEFX
+};
+
+#ifdef __KERNEL__
+
+#include <linux/cache.h>
+#include <linux/skbuff.h>
+
+struct neighbour;
+struct neigh_parms;
+struct sk_buff;
+
+struct netif_rx_stats
+{
+        unsigned total;
+        unsigned dropped;
+        unsigned time_squeeze;
+        unsigned throttled;
+        unsigned fastroute_hit;
+        unsigned fastroute_success;
+        unsigned fastroute_defer;
+        unsigned fastroute_deferred_out;
+        unsigned fastroute_latency_reduction;
+        unsigned cpu_collision;
+};
+
+DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
+
+
+/*
+ *      We tag multicasts with these structures.
+ */
+ 
+struct dev_mc_list
+{       
+        struct dev_mc_list      *next;
+        __u8                    dmi_addr[MAX_ADDR_LEN];
+        unsigned char           dmi_addrlen;
+        int                     dmi_users;
+        int                     dmi_gusers;
+};
+
+struct hh_cache
+{
+        struct hh_cache *hh_next;       /* Next entry                        */
+        atomic_t        hh_refcnt;      /* number of users                   */
+        unsigned short  hh_type;        /* protocol identifier, f.e ETH_P_IP
+                                         *  NOTE:  For VLANs, this will be the
+                                         *  encapuslated type. --BLG
+                                         */
+        int             hh_len;         /* length of header */
+        int             (*hh_output)(struct sk_buff *skb);
+        rwlock_t        hh_lock;
+
+        /* cached hardware header; allow for machine alignment needs.        */
+#define HH_DATA_MOD     16
+#define HH_DATA_OFF(__len) \
+        (HH_DATA_MOD - ((__len) & (HH_DATA_MOD - 1)))
+#define HH_DATA_ALIGN(__len) \
+        (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
+        unsigned long   hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
+};
+
+/* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
+ * Alternative is:
+ *   dev->hard_header_len ? (dev->hard_header_len +
+ *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
+ *
+ * We could use other alignment values, but we must maintain the
+ * relationship HH alignment <= LL alignment.
+ */
+#define LL_RESERVED_SPACE(dev) \
+        (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
+#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
+        ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
+
+/* These flag bits are private to the generic network queueing
+ * layer, they may not be explicitly referenced by any other
+ * code.
+ */
+
+enum netdev_state_t
+{
+        __LINK_STATE_XOFF=0,
+        __LINK_STATE_START,
+        __LINK_STATE_PRESENT,
+        __LINK_STATE_SCHED,
+        __LINK_STATE_NOCARRIER,
+        __LINK_STATE_RX_SCHED,
+        __LINK_STATE_LINKWATCH_PENDING
+};
+
+
+/*
+ * This structure holds at boot time configured netdevice settings. They
+ * are then used in the device probing. 
+ */
+struct netdev_boot_setup {
+        char name[IFNAMSIZ];
+        struct ifmap map;
+};
+#define NETDEV_BOOT_SETUP_MAX 8
+
+
+/*
+ *      The DEVICE structure.
+ *      Actually, this whole structure is a big mistake.  It mixes I/O
+ *      data with strictly "high-level" data, and it has to know about
+ *      almost every data structure used in the INET module.
+ *
+ *      FIXME: cleanup struct net_device such that network protocol info
+ *      moves out.
+ */
+
+struct net_device
+{
+
+        /*
+         * This is the first field of the "visible" part of this structure
+         * (i.e. as seen by users in the "Space.c" file).  It is the name
+         * the interface.
+         */
+        char                    name[IFNAMSIZ];
+
+        /*
+         *      I/O specific fields
+         *      FIXME: Merge these and struct ifmap into one
+         */
+        unsigned long           mem_end;        /* shared mem end       */
+        unsigned long           mem_start;      /* shared mem start     */
+        unsigned long           base_addr;      /* device I/O address   */
+        unsigned int            irq;            /* device IRQ number    */
+
+        /*
+         *      Some hardware also needs these fields, but they are not
+         *      part of the usual set specified in Space.c.
+         */
+
+        unsigned char           if_port;        /* Selectable AUI, TP,..*/
+        unsigned char           dma;            /* DMA channel          */
+
+        unsigned long           state;
+
+        struct net_device       *next;
+        
+        /* The device initialization function. Called only once. */
+        int                     (*init)(struct net_device *dev);
+
+        /* ------- Fields preinitialized in Space.c finish here ------- */
+
+        struct net_device       *next_sched;
+
+        /* Interface index. Unique device identifier    */
+        int                     ifindex;
+        int                     iflink;
+
+
+        struct net_device_stats* (*get_stats)(struct net_device *dev);
+        struct iw_statistics*   (*get_wireless_stats)(struct net_device *dev);
+
+        /* List of functions to handle Wireless Extensions (instead of ioctl).
+         * See <net/iw_handler.h> for details. Jean II */
+        const struct iw_handler_def *   wireless_handlers;
+        /* Instance data managed by the core of Wireless Extensions. */
+        struct iw_public_data * wireless_data;
+
+        struct ethtool_ops *ethtool_ops;
+
+        /*
+         * This marks the end of the "visible" part of the structure. All
+         * fields hereafter are internal to the system, and may change at
+         * will (read: may be cleaned up at will).
+         */
+
+        /* These may be needed for future network-power-down code. */
+        unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
+        unsigned long           last_rx;        /* Time of last Rx      */
+
+        unsigned short          flags;  /* interface flags (a la BSD)   */
+        unsigned short          gflags;
+        unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
+        unsigned short          padded; /* How much padding added by alloc_netdev() */
+
+        unsigned                mtu;    /* interface MTU value          */
+        unsigned short          type;   /* interface hardware type      */
+        unsigned short          hard_header_len;        /* hardware hdr length  */
+        void                    *priv;  /* pointer to private data      */
+
+        struct net_device       *master; /* Pointer to master device of a group,
+                                          * which this device is member of.
+                                          */
+
+        /* Interface address info. */
+        unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
+        unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address   */
+        unsigned char           addr_len;       /* hardware address length      */
+        unsigned short          dev_id;         /* for shared network cards */
+
+        struct dev_mc_list      *mc_list;       /* Multicast mac addresses      */
+        int                     mc_count;       /* Number of installed mcasts   */
+        int                     promiscuity;
+        int                     allmulti;
+
+        int                     watchdog_timeo;
+        struct timer_list       watchdog_timer;
+
+        /* Protocol specific pointers */
+        
+        void                    *atalk_ptr;     /* AppleTalk link       */
+        void                    *ip_ptr;        /* IPv4 specific data   */  
+        void                    *dn_ptr;        /* DECnet specific data */
+        void                    *ip6_ptr;       /* IPv6 specific data */
+        void                    *ec_ptr;        /* Econet specific data */
+        void                    *ax25_ptr;      /* AX.25 specific data */
+
+        struct list_head        poll_list;      /* Link to poll list    */
+        int                     quota;
+        int                     weight;
+
+        struct Qdisc            *qdisc;
+        struct Qdisc            *qdisc_sleeping;
+        struct Qdisc            *qdisc_ingress;
+        struct list_head        qdisc_list;
+        unsigned long           tx_queue_len;   /* Max frames per queue allowed */
+
+        /* ingress path synchronizer */
+        spinlock_t              ingress_lock;
+        /* hard_start_xmit synchronizer */
+        spinlock_t              xmit_lock;
+        /* cpu id of processor entered to hard_start_xmit or -1,
+           if nobody entered there.
+         */
+        int                     xmit_lock_owner;
+        /* device queue lock */
+        spinlock_t              queue_lock;
+        /* Number of references to this device */
+        atomic_t                refcnt;
+        /* delayed register/unregister */
+        struct list_head        todo_list;
+        /* device name hash chain */
+        struct hlist_node       name_hlist;
+        /* device index hash chain */
+        struct hlist_node       index_hlist;
+
+        /* register/unregister state machine */
+        enum { NETREG_UNINITIALIZED=0,
+               NETREG_REGISTERING,      /* called register_netdevice */
+               NETREG_REGISTERED,       /* completed register todo */
+               NETREG_UNREGISTERING,    /* called unregister_netdevice */
+               NETREG_UNREGISTERED,     /* completed unregister todo */
+               NETREG_RELEASED,         /* called free_netdev */
+        } reg_state;
+
+        /* Net device features */
+        int                     features;
+#define NETIF_F_SG              1       /* Scatter/gather IO. */
+#define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
+#define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
+#define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
+#define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
+#define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
+#define NETIF_F_HW_VLAN_TX      128     /* Transmit VLAN hw acceleration */
+#define NETIF_F_HW_VLAN_RX      256     /* Receive VLAN hw acceleration */
+#define NETIF_F_HW_VLAN_FILTER  512     /* Receive filtering on VLAN */
+#define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
+#define NETIF_F_TSO             2048    /* Can offload TCP/IP segmentation */
+#define NETIF_F_LLTX            4096    /* LockLess TX */
+
+        /* Called after device is detached from network. */
+        void                    (*uninit)(struct net_device *dev);
+        /* Called after last user reference disappears. */
+        void                    (*destructor)(struct net_device *dev);
+
+        /* Pointers to interface service routines.      */
+        int                     (*open)(struct net_device *dev);
+        int                     (*stop)(struct net_device *dev);
+        int                     (*hard_start_xmit) (struct sk_buff *skb,
+                                                    struct net_device *dev);
+#define HAVE_NETDEV_POLL
+        int                     (*poll) (struct net_device *dev, int *quota);
+        int                     (*hard_header) (struct sk_buff *skb,
+                                                struct net_device *dev,
+                                                unsigned short type,
+                                                void *daddr,
+                                                void *saddr,
+                                                unsigned len);
+        int                     (*rebuild_header)(struct sk_buff *skb);
+#define HAVE_MULTICAST                   
+        void                    (*set_multicast_list)(struct net_device *dev);
+#define HAVE_SET_MAC_ADDR                
+        int                     (*set_mac_address)(struct net_device *dev,
+                                                   void *addr);
+#define HAVE_PRIVATE_IOCTL
+        int                     (*do_ioctl)(struct net_device *dev,
+                                            struct ifreq *ifr, int cmd);
+#define HAVE_SET_CONFIG
+        int                     (*set_config)(struct net_device *dev,
+                                              struct ifmap *map);
+#define HAVE_HEADER_CACHE
+        int                     (*hard_header_cache)(struct neighbour *neigh,
+                                                     struct hh_cache *hh);
+        void                    (*header_cache_update)(struct hh_cache *hh,
+                                                       struct net_device *dev,
+                                                       unsigned char *  haddr);
+#define HAVE_CHANGE_MTU
+        int                     (*change_mtu)(struct net_device *dev, int new_mtu);
+
+#define HAVE_TX_TIMEOUT
+        void                    (*tx_timeout) (struct net_device *dev);
+
+        void                    (*vlan_rx_register)(struct net_device *dev,
+                                                    struct vlan_group *grp);
+        void                    (*vlan_rx_add_vid)(struct net_device *dev,
+                                                   unsigned short vid);
+        void                    (*vlan_rx_kill_vid)(struct net_device *dev,
+                                                    unsigned short vid);
+
+        int                     (*hard_header_parse)(struct sk_buff *skb,
+                                                     unsigned char *haddr);
+        int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
+#ifdef CONFIG_NETPOLL
+        struct netpoll          *np;
+#endif
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        void                    (*poll_controller)(struct net_device *dev);
+#endif
+
+        /* bridge stuff */
+        struct net_bridge_port  *br_port;
+
+#ifdef CONFIG_NET_DIVERT
+        /* this will get initialized at each interface type init routine */
+        struct divert_blk       *divert;
+#endif /* CONFIG_NET_DIVERT */
+
+        /* class/net/name entry */
+        struct class_device     class_dev;
+};
+
+#define NETDEV_ALIGN            32
+#define NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)
+
+static inline void *netdev_priv(struct net_device *dev)
+{
+        return (char *)dev + ((sizeof(struct net_device)
+                                        + NETDEV_ALIGN_CONST)
+                                & ~NETDEV_ALIGN_CONST);
+}
+
+#define SET_MODULE_OWNER(dev) do { } while (0)
+/* Set the sysfs physical device reference for the network logical device
+ * if set prior to registration will cause a symlink during initialization.
+ */
+#define SET_NETDEV_DEV(net, pdev)       ((net)->class_dev.dev = (pdev))
+
+struct packet_type {
+        unsigned short          type;   /* This is really htons(ether_type).    */
+        struct net_device               *dev;   /* NULL is wildcarded here              */
+        int                     (*func) (struct sk_buff *, struct net_device *,
+                                         struct packet_type *);
+        void                    *af_packet_priv;
+        struct list_head        list;
+};
+
+#include <linux/interrupt.h>
+#include <linux/notifier.h>
+
+extern struct net_device                loopback_dev;           /* The loopback */
+extern struct net_device                *dev_base;              /* All devices */
+extern rwlock_t                         dev_base_lock;          /* Device list lock */
+
+extern int                      netdev_boot_setup_check(struct net_device *dev);
+extern unsigned long            netdev_boot_base(const char *prefix, int unit);
+extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
+extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
+extern void             dev_add_pack(struct packet_type *pt);
+extern void             dev_remove_pack(struct packet_type *pt);
+extern void             __dev_remove_pack(struct packet_type *pt);
+
+extern struct net_device        *dev_get_by_flags(unsigned short flags,
+                                                  unsigned short mask);
+extern struct net_device        *dev_get_by_name(const char *name);
+extern struct net_device        *__dev_get_by_name(const char *name);
+extern int              dev_alloc_name(struct net_device *dev, const char *name);
+extern int              dev_open(struct net_device *dev);
+extern int              dev_close(struct net_device *dev);
+extern int              dev_queue_xmit(struct sk_buff *skb);
+extern int              register_netdevice(struct net_device *dev);
+extern int              unregister_netdevice(struct net_device *dev);
+extern void             free_netdev(struct net_device *dev);
+extern void             synchronize_net(void);
+extern int              register_netdevice_notifier(struct notifier_block *nb);
+extern int              unregister_netdevice_notifier(struct notifier_block *nb);
+extern int              call_netdevice_notifiers(unsigned long val, void *v);
+extern struct net_device        *dev_get_by_index(int ifindex);
+extern struct net_device        *__dev_get_by_index(int ifindex);
+extern int              dev_restart(struct net_device *dev);
+#ifdef CONFIG_NETPOLL_TRAP
+extern int              netpoll_trap(void);
+#endif
+
+typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
+extern int              register_gifconf(unsigned int family, gifconf_func_t * gifconf);
+static inline int unregister_gifconf(unsigned int family)
+{
+        return register_gifconf(family, NULL);
+}
+
+/*
+ * Incoming packets are placed on per-cpu queues so that
+ * no locking is needed.
+ */
+
+struct softnet_data
+{
+        int                     throttle;
+        int                     cng_level;
+        int                     avg_blog;
+        struct sk_buff_head     input_pkt_queue;
+        struct list_head        poll_list;
+        struct net_device       *output_queue;
+        struct sk_buff          *completion_queue;
+
+        struct net_device       backlog_dev;    /* Sorry. 8) */
+};
+
+DECLARE_PER_CPU(struct softnet_data,softnet_data);
+
+#define HAVE_NETIF_QUEUE
+
+static inline void __netif_schedule(struct net_device *dev)
+{
+        if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
+                unsigned long flags;
+                struct softnet_data *sd;
+
+                local_irq_save(flags);
+                sd = &__get_cpu_var(softnet_data);
+                dev->next_sched = sd->output_queue;
+                sd->output_queue = dev;
+                raise_softirq_irqoff(NET_TX_SOFTIRQ);
+                local_irq_restore(flags);
+        }
+}
+
+static inline void netif_schedule(struct net_device *dev)
+{
+        if (!test_bit(__LINK_STATE_XOFF, &dev->state))
+                __netif_schedule(dev);
+}
+
+static inline void netif_start_queue(struct net_device *dev)
+{
+        clear_bit(__LINK_STATE_XOFF, &dev->state);
+}
+
+static inline void netif_wake_queue(struct net_device *dev)
+{
+#ifdef CONFIG_NETPOLL_TRAP
+        if (netpoll_trap())
+                return;
+#endif
+        if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
+                __netif_schedule(dev);
+}
+
+static inline void netif_stop_queue(struct net_device *dev)
+{
+#ifdef CONFIG_NETPOLL_TRAP
+        if (netpoll_trap())
+                return;
+#endif
+        set_bit(__LINK_STATE_XOFF, &dev->state);
+}
+
+static inline int netif_queue_stopped(const struct net_device *dev)
+{
+        return test_bit(__LINK_STATE_XOFF, &dev->state);
+}
+
+static inline int netif_running(const struct net_device *dev)
+{
+        return test_bit(__LINK_STATE_START, &dev->state);
+}
+
+
+/* Use this variant when it is known for sure that it
+ * is executing from interrupt context.
+ */
+static inline void dev_kfree_skb_irq(struct sk_buff *skb)
+{
+        if (atomic_dec_and_test(&skb->users)) {
+                struct softnet_data *sd;
+                unsigned long flags;
+
+                local_irq_save(flags);
+                sd = &__get_cpu_var(softnet_data);
+                skb->next = sd->completion_queue;
+                sd->completion_queue = skb;
+                raise_softirq_irqoff(NET_TX_SOFTIRQ);
+                local_irq_restore(flags);
+        }
+}
+
+/* Use this variant in places where it could be invoked
+ * either from interrupt or non-interrupt context.
+ */
+static inline void dev_kfree_skb_any(struct sk_buff *skb)
+{
+        if (in_irq() || irqs_disabled())
+                dev_kfree_skb_irq(skb);
+        else
+                dev_kfree_skb(skb);
+}
+
+#define HAVE_NETIF_RX 1
+extern int              netif_rx(struct sk_buff *skb);
+extern int              netif_rx_ni(struct sk_buff *skb);
+#define HAVE_NETIF_RECEIVE_SKB 1
+extern int              netif_receive_skb(struct sk_buff *skb);
+extern int              dev_ioctl(unsigned int cmd, void __user *);
+extern int              dev_ethtool(struct ifreq *);
+extern unsigned         dev_get_flags(const struct net_device *);
+extern int              dev_change_flags(struct net_device *, unsigned);
+extern int              dev_change_name(struct net_device *, char *);
+extern int              dev_set_mtu(struct net_device *, int);
+extern int              dev_set_mac_address(struct net_device *,
+                                            struct sockaddr *);
+extern void             dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
+
+extern void             dev_init(void);
+
+extern int              netdev_nit;
+
+/* Called by rtnetlink.c:rtnl_unlock() */
+extern void netdev_run_todo(void);
+
+static inline void dev_put(struct net_device *dev)
+{
+        atomic_dec(&dev->refcnt);
+}
+
+#define __dev_put(dev) atomic_dec(&(dev)->refcnt)
+#define dev_hold(dev) atomic_inc(&(dev)->refcnt)
+
+/* Carrier loss detection, dial on demand. The functions netif_carrier_on
+ * and _off may be called from IRQ context, but it is caller
+ * who is responsible for serialization of these calls.
+ */
+
+extern void linkwatch_fire_event(struct net_device *dev);
+
+static inline int netif_carrier_ok(const struct net_device *dev)
+{
+        return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
+}
+
+extern void __netdev_watchdog_up(struct net_device *dev);
+
+static inline void netif_carrier_on(struct net_device *dev)
+{
+        if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state))
+                linkwatch_fire_event(dev);
+        if (netif_running(dev))
+                __netdev_watchdog_up(dev);
+}
+
+static inline void netif_carrier_off(struct net_device *dev)
+{
+        if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state))
+                linkwatch_fire_event(dev);
+}
+
+/* Hot-plugging. */
+static inline int netif_device_present(struct net_device *dev)
+{
+        return test_bit(__LINK_STATE_PRESENT, &dev->state);
+}
+
+static inline void netif_device_detach(struct net_device *dev)
+{
+        if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
+            netif_running(dev)) {
+                netif_stop_queue(dev);
+        }
+}
+
+static inline void netif_device_attach(struct net_device *dev)
+{
+        if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
+            netif_running(dev)) {
+                netif_wake_queue(dev);
+                __netdev_watchdog_up(dev);
+        }
+}
+
+/*
+ * Network interface message level settings
+ */
+#define HAVE_NETIF_MSG 1
+
+enum {
+        NETIF_MSG_DRV           = 0x0001,
+        NETIF_MSG_PROBE         = 0x0002,
+        NETIF_MSG_LINK          = 0x0004,
+        NETIF_MSG_TIMER         = 0x0008,
+        NETIF_MSG_IFDOWN        = 0x0010,
+        NETIF_MSG_IFUP          = 0x0020,
+        NETIF_MSG_RX_ERR        = 0x0040,
+        NETIF_MSG_TX_ERR        = 0x0080,
+        NETIF_MSG_TX_QUEUED     = 0x0100,
+        NETIF_MSG_INTR          = 0x0200,
+        NETIF_MSG_TX_DONE       = 0x0400,
+        NETIF_MSG_RX_STATUS     = 0x0800,
+        NETIF_MSG_PKTDATA       = 0x1000,
+        NETIF_MSG_HW            = 0x2000,
+        NETIF_MSG_WOL           = 0x4000,
+};
+
+#define netif_msg_drv(p)        ((p)->msg_enable & NETIF_MSG_DRV)
+#define netif_msg_probe(p)      ((p)->msg_enable & NETIF_MSG_PROBE)
+#define netif_msg_link(p)       ((p)->msg_enable & NETIF_MSG_LINK)
+#define netif_msg_timer(p)      ((p)->msg_enable & NETIF_MSG_TIMER)
+#define netif_msg_ifdown(p)     ((p)->msg_enable & NETIF_MSG_IFDOWN)
+#define netif_msg_ifup(p)       ((p)->msg_enable & NETIF_MSG_IFUP)
+#define netif_msg_rx_err(p)     ((p)->msg_enable & NETIF_MSG_RX_ERR)
+#define netif_msg_tx_err(p)     ((p)->msg_enable & NETIF_MSG_TX_ERR)
+#define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
+#define netif_msg_intr(p)       ((p)->msg_enable & NETIF_MSG_INTR)
+#define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
+#define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
+#define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
+#define netif_msg_hw(p)         ((p)->msg_enable & NETIF_MSG_HW)
+#define netif_msg_wol(p)        ((p)->msg_enable & NETIF_MSG_WOL)
+
+static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
+{
+        /* use default */
+        if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
+                return default_msg_enable_bits;
+        if (debug_value == 0)   /* no output */
+                return 0;
+        /* set low N bits */
+        return (1 << debug_value) - 1;
+}
+
+/* Schedule rx intr now? */
+
+static inline int netif_rx_schedule_prep(struct net_device *dev)
+{
+        return netif_running(dev) &&
+                !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
+}
+
+/* Add interface to tail of rx poll list. This assumes that _prep has
+ * already been called and returned 1.
+ */
+
+static inline void __netif_rx_schedule(struct net_device *dev)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        dev_hold(dev);
+        list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
+        if (dev->quota < 0)
+                dev->quota += dev->weight;
+        else
+                dev->quota = dev->weight;
+        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
+        local_irq_restore(flags);
+}
+
+/* Try to reschedule poll. Called by irq handler. */
+
+static inline void netif_rx_schedule(struct net_device *dev)
+{
+        if (netif_rx_schedule_prep(dev))
+                __netif_rx_schedule(dev);
+}
+
+/* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
+ * Do not inline this?
+ */
+static inline int netif_rx_reschedule(struct net_device *dev, int undo)
+{
+        if (netif_rx_schedule_prep(dev)) {
+                unsigned long flags;
+
+                dev->quota += undo;
+
+                local_irq_save(flags);
+                list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
+                __raise_softirq_irqoff(NET_RX_SOFTIRQ);
+                local_irq_restore(flags);
+                return 1;
+        }
+        return 0;
+}
+
+/* Remove interface from poll list: it must be in the poll list
+ * on current cpu. This primitive is called by dev->poll(), when
+ * it completes the work. The device cannot be out of poll list at this
+ * moment, it is BUG().
+ */
+static inline void netif_rx_complete(struct net_device *dev)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
+        list_del(&dev->poll_list);
+        smp_mb__before_clear_bit();
+        clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
+        local_irq_restore(flags);
+}
+
+static inline void netif_poll_disable(struct net_device *dev)
+{
+        while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
+                /* No hurry. */
+                current->state = TASK_INTERRUPTIBLE;
+                schedule_timeout(1);
+        }
+}
+
+static inline void netif_poll_enable(struct net_device *dev)
+{
+        clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
+}
+
+/* same as netif_rx_complete, except that local_irq_save(flags)
+ * has already been issued
+ */
+static inline void __netif_rx_complete(struct net_device *dev)
+{
+        BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
+        list_del(&dev->poll_list);
+        smp_mb__before_clear_bit();
+        clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
+}
+
+static inline void netif_tx_disable(struct net_device *dev)
+{
+        spin_lock_bh(&dev->xmit_lock);
+        netif_stop_queue(dev);
+        spin_unlock_bh(&dev->xmit_lock);
+}
+
+/* These functions live elsewhere (drivers/net/net_init.c, but related) */
+
+extern void             ether_setup(struct net_device *dev);
+
+/* Support for loadable net-drivers */
+extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
+                                       void (*setup)(struct net_device *));
+extern int              register_netdev(struct net_device *dev);
+extern void             unregister_netdev(struct net_device *dev);
+/* Functions used for multicast support */
+extern void             dev_mc_upload(struct net_device *dev);
+extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
+extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
+extern void             dev_mc_discard(struct net_device *dev);
+extern void             dev_set_promiscuity(struct net_device *dev, int inc);
+extern void             dev_set_allmulti(struct net_device *dev, int inc);
+extern void             netdev_state_change(struct net_device *dev);
+/* Load a device via the kmod */
+extern void             dev_load(const char *name);
+extern void             dev_mcast_init(void);
+extern int              netdev_max_backlog;
+extern int              weight_p;
+extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
+extern int skb_checksum_help(struct sk_buff *skb, int inward);
+/* rx skb timestamps */
+extern void             net_enable_timestamp(void);
+extern void             net_disable_timestamp(void);
+
+#ifdef CONFIG_SYSCTL
+extern char *net_sysctl_strdup(const char *s);
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif  /* _LINUX_DEV_H */
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
new file mode 100644
index 000000000000..2e2045482cb1
--- /dev/null
+++ b/include/linux/netfilter.h
@@ -0,0 +1,199 @@
+#ifndef __LINUX_NETFILTER_H
+#define __LINUX_NETFILTER_H
+
+#ifdef __KERNEL__
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/skbuff.h>
+#include <linux/net.h>
+#include <linux/if.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#endif
+#include <linux/compiler.h>
+
+/* Responses from hook functions. */
+#define NF_DROP 0
+#define NF_ACCEPT 1
+#define NF_STOLEN 2
+#define NF_QUEUE 3
+#define NF_REPEAT 4
+#define NF_STOP 5
+#define NF_MAX_VERDICT NF_STOP
+
+/* Generic cache responses from hook functions.
+   <= 0x2000 is used for protocol-flags. */
+#define NFC_UNKNOWN 0x4000
+#define NFC_ALTERED 0x8000
+
+#ifdef __KERNEL__
+#include <linux/config.h>
+#ifdef CONFIG_NETFILTER
+
+extern void netfilter_init(void);
+
+/* Largest hook number + 1 */
+#define NF_MAX_HOOKS 8
+
+struct sk_buff;
+struct net_device;
+
+typedef unsigned int nf_hookfn(unsigned int hooknum,
+                               struct sk_buff **skb,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               int (*okfn)(struct sk_buff *));
+
+struct nf_hook_ops
+{
+        struct list_head list;
+
+        /* User fills in from here down. */
+        nf_hookfn *hook;
+        struct module *owner;
+        int pf;
+        int hooknum;
+        /* Hooks are ordered in ascending priority. */
+        int priority;
+};
+
+struct nf_sockopt_ops
+{
+        struct list_head list;
+
+        int pf;
+
+        /* Non-inclusive ranges: use 0/0/NULL to never get called. */
+        int set_optmin;
+        int set_optmax;
+        int (*set)(struct sock *sk, int optval, void __user *user, unsigned int len);
+
+        int get_optmin;
+        int get_optmax;
+        int (*get)(struct sock *sk, int optval, void __user *user, int *len);
+
+        /* Number of users inside set() or get(). */
+        unsigned int use;
+        struct task_struct *cleanup_task;
+};
+
+/* Each queued (to userspace) skbuff has one of these. */
+struct nf_info
+{
+        /* The ops struct which sent us to userspace. */
+        struct nf_hook_ops *elem;
+        
+        /* If we're sent to userspace, this keeps housekeeping info */
+        int pf;
+        unsigned int hook;
+        struct net_device *indev, *outdev;
+        int (*okfn)(struct sk_buff *);
+};
+                                                                                
+/* Function to register/unregister hook points. */
+int nf_register_hook(struct nf_hook_ops *reg);
+void nf_unregister_hook(struct nf_hook_ops *reg);
+
+/* Functions to register get/setsockopt ranges (non-inclusive).  You
+   need to check permissions yourself! */
+int nf_register_sockopt(struct nf_sockopt_ops *reg);
+void nf_unregister_sockopt(struct nf_sockopt_ops *reg);
+
+extern struct list_head nf_hooks[NPROTO][NF_MAX_HOOKS];
+
+typedef void nf_logfn(unsigned int hooknum,
+                      const struct sk_buff *skb,
+                      const struct net_device *in,
+                      const struct net_device *out,
+                      const char *prefix);
+
+/* Function to register/unregister log function. */
+int nf_log_register(int pf, nf_logfn *logfn);
+void nf_log_unregister(int pf, nf_logfn *logfn);
+
+/* Calls the registered backend logging function */
+void nf_log_packet(int pf,
+                   unsigned int hooknum,
+                   const struct sk_buff *skb,
+                   const struct net_device *in,
+                   const struct net_device *out,
+                   const char *fmt, ...);
+                   
+/* Activate hook; either okfn or kfree_skb called, unless a hook
+   returns NF_STOLEN (in which case, it's up to the hook to deal with
+   the consequences).
+
+   Returns -ERRNO if packet dropped.  Zero means queued, stolen or
+   accepted.
+*/
+
+/* RR:
+   > I don't want nf_hook to return anything because people might forget
+   > about async and trust the return value to mean "packet was ok".
+
+   AK:
+   Just document it clearly, then you can expect some sense from kernel
+   coders :)
+*/
+
+/* This is gross, but inline doesn't cut it for avoiding the function
+   call in fast path: gcc doesn't inline (needs value tracking?). --RR */
+#ifdef CONFIG_NETFILTER_DEBUG
+#define NF_HOOK(pf, hook, skb, indev, outdev, okfn)                            \
+({int __ret;                                                                   \
+if ((__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, INT_MIN)) == 1) \
+        __ret = (okfn)(skb);                                                   \
+__ret;})
+#define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)             \
+({int __ret;                                                                   \
+if ((__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, thresh)) == 1)  \
+        __ret = (okfn)(skb);                                                   \
+__ret;})
+#else
+#define NF_HOOK(pf, hook, skb, indev, outdev, okfn)                            \
+({int __ret;                                                                   \
+if (list_empty(&nf_hooks[pf][hook]) ||                                         \
+    (__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, INT_MIN)) == 1) \
+        __ret = (okfn)(skb);                                                   \
+__ret;})
+#define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)             \
+({int __ret;                                                                   \
+if (list_empty(&nf_hooks[pf][hook]) ||                                         \
+    (__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, thresh)) == 1)  \
+        __ret = (okfn)(skb);                                                   \
+__ret;})
+#endif
+
+int nf_hook_slow(int pf, unsigned int hook, struct sk_buff **pskb,
+                 struct net_device *indev, struct net_device *outdev,
+                 int (*okfn)(struct sk_buff *), int thresh);
+
+/* Call setsockopt() */
+int nf_setsockopt(struct sock *sk, int pf, int optval, char __user *opt, 
+                  int len);
+int nf_getsockopt(struct sock *sk, int pf, int optval, char __user *opt,
+                  int *len);
+
+/* Packet queuing */
+typedef int (*nf_queue_outfn_t)(struct sk_buff *skb, 
+                                struct nf_info *info, void *data);
+extern int nf_register_queue_handler(int pf, 
+                                     nf_queue_outfn_t outfn, void *data);
+extern int nf_unregister_queue_handler(int pf);
+extern void nf_reinject(struct sk_buff *skb,
+                        struct nf_info *info,
+                        unsigned int verdict);
+
+extern void (*ip_ct_attach)(struct sk_buff *, struct sk_buff *);
+extern void nf_ct_attach(struct sk_buff *, struct sk_buff *);
+
+/* FIXME: Before cache is ever used, this must be implemented for real. */
+extern void nf_invalidate_cache(int pf);
+
+#else /* !CONFIG_NETFILTER */
+#define NF_HOOK(pf, hook, skb, indev, outdev, okfn) (okfn)(skb)
+static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
+#endif /*CONFIG_NETFILTER*/
+
+#endif /*__KERNEL__*/
+#endif /*__LINUX_NETFILTER_H*/
diff --git a/include/linux/netfilter_arp.h b/include/linux/netfilter_arp.h
new file mode 100644
index 000000000000..a3f8977f7f12
--- /dev/null
+++ b/include/linux/netfilter_arp.h
@@ -0,0 +1,20 @@
+#ifndef __LINUX_ARP_NETFILTER_H
+#define __LINUX_ARP_NETFILTER_H
+
+/* ARP-specific defines for netfilter.
+ * (C)2002 Rusty Russell IBM -- This code is GPL.
+ */
+
+#include <linux/config.h>
+#include <linux/netfilter.h>
+
+/* There is no PF_ARP. */
+#define NF_ARP          0
+
+/* ARP Hooks */
+#define NF_ARP_IN       0
+#define NF_ARP_OUT      1
+#define NF_ARP_FORWARD  2
+#define NF_ARP_NUMHOOKS 3
+
+#endif /* __LINUX_ARP_NETFILTER_H */
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
new file mode 100644
index 000000000000..d759a637bded
--- /dev/null
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -0,0 +1,340 @@
+/*
+ *      Format of an ARP firewall descriptor
+ *
+ *      src, tgt, src_mask, tgt_mask, arpop, arpop_mask are always stored in
+ *      network byte order.
+ *      flags are stored in host byte order (of course).
+ */
+
+#ifndef _ARPTABLES_H
+#define _ARPTABLES_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#include <linux/types.h>
+#include <linux/in.h>
+#include <linux/if_arp.h>
+#include <linux/skbuff.h>
+#endif
+#include <linux/compiler.h>
+#include <linux/netfilter_arp.h>
+
+#define ARPT_FUNCTION_MAXNAMELEN 30
+#define ARPT_TABLE_MAXNAMELEN 32
+
+#define ARPT_DEV_ADDR_LEN_MAX 16
+
+struct arpt_devaddr_info {
+        char addr[ARPT_DEV_ADDR_LEN_MAX];
+        char mask[ARPT_DEV_ADDR_LEN_MAX];
+};
+
+/* Yes, Virginia, you have to zero the padding. */
+struct arpt_arp {
+        /* Source and target IP addr */
+        struct in_addr src, tgt;
+        /* Mask for src and target IP addr */
+        struct in_addr smsk, tmsk;
+
+        /* Device hw address length, src+target device addresses */
+        u_int8_t arhln, arhln_mask;
+        struct arpt_devaddr_info src_devaddr;
+        struct arpt_devaddr_info tgt_devaddr;
+
+        /* ARP operation code. */
+        u_int16_t arpop, arpop_mask;
+
+        /* ARP hardware address and protocol address format. */
+        u_int16_t arhrd, arhrd_mask;
+        u_int16_t arpro, arpro_mask;
+
+        /* The protocol address length is only accepted if it is 4
+         * so there is no use in offering a way to do filtering on it.
+         */
+
+        char iniface[IFNAMSIZ], outiface[IFNAMSIZ];
+        unsigned char iniface_mask[IFNAMSIZ], outiface_mask[IFNAMSIZ];
+
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int16_t invflags;
+};
+
+struct arpt_entry_target
+{
+        union {
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used by userspace */
+                        char name[ARPT_FUNCTION_MAXNAMELEN];
+                } user;
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used inside the kernel */
+                        struct arpt_target *target;
+                } kernel;
+
+                /* Total length */
+                u_int16_t target_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct arpt_standard_target
+{
+        struct arpt_entry_target target;
+        int verdict;
+};
+
+struct arpt_counters
+{
+        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
+};
+
+/* Values for "flag" field in struct arpt_ip (general arp structure).
+ * No flags defined yet.
+ */
+#define ARPT_F_MASK             0x00    /* All possible flag bits mask. */
+
+/* Values for "inv" field in struct arpt_arp. */
+#define ARPT_INV_VIA_IN         0x0001  /* Invert the sense of IN IFACE. */
+#define ARPT_INV_VIA_OUT        0x0002  /* Invert the sense of OUT IFACE */
+#define ARPT_INV_SRCIP          0x0004  /* Invert the sense of SRC IP. */
+#define ARPT_INV_TGTIP          0x0008  /* Invert the sense of TGT IP. */
+#define ARPT_INV_SRCDEVADDR     0x0010  /* Invert the sense of SRC DEV ADDR. */
+#define ARPT_INV_TGTDEVADDR     0x0020  /* Invert the sense of TGT DEV ADDR. */
+#define ARPT_INV_ARPOP          0x0040  /* Invert the sense of ARP OP. */
+#define ARPT_INV_ARPHRD         0x0080  /* Invert the sense of ARP HRD. */
+#define ARPT_INV_ARPPRO         0x0100  /* Invert the sense of ARP PRO. */
+#define ARPT_INV_ARPHLN         0x0200  /* Invert the sense of ARP HLN. */
+#define ARPT_INV_MASK           0x03FF  /* All possible flag bits mask. */
+
+/* This structure defines each of the firewall rules.  Consists of 3
+   parts which are 1) general ARP header stuff 2) match specific
+   stuff 3) the target to perform if the rule matches */
+struct arpt_entry
+{
+        struct arpt_arp arp;
+
+        /* Size of arpt_entry + matches */
+        u_int16_t target_offset;
+        /* Size of arpt_entry + matches + target */
+        u_int16_t next_offset;
+
+        /* Back pointer */
+        unsigned int comefrom;
+
+        /* Packet and byte counters. */
+        struct arpt_counters counters;
+
+        /* The matches (if any), then the target. */
+        unsigned char elems[0];
+};
+
+/*
+ * New IP firewall options for [gs]etsockopt at the RAW IP level.
+ * Unlike BSD Linux inherits IP options so you don't have to use a raw
+ * socket for this. Instead we check rights in the calls.
+ */
+#define ARPT_BASE_CTL           96      /* base for firewall socket options */
+
+#define ARPT_SO_SET_REPLACE             (ARPT_BASE_CTL)
+#define ARPT_SO_SET_ADD_COUNTERS        (ARPT_BASE_CTL + 1)
+#define ARPT_SO_SET_MAX                 ARPT_SO_SET_ADD_COUNTERS
+
+#define ARPT_SO_GET_INFO                (ARPT_BASE_CTL)
+#define ARPT_SO_GET_ENTRIES             (ARPT_BASE_CTL + 1)
+#define ARPT_SO_GET_MAX                 ARPT_SO_GET_ENTRIES
+
+/* CONTINUE verdict for targets */
+#define ARPT_CONTINUE 0xFFFFFFFF
+
+/* For standard target */
+#define ARPT_RETURN (-NF_REPEAT - 1)
+
+/* The argument to ARPT_SO_GET_INFO */
+struct arpt_getinfo
+{
+        /* Which table: caller fills this in. */
+        char name[ARPT_TABLE_MAXNAMELEN];
+
+        /* Kernel fills these in. */
+        /* Which hook entry points are valid: bitmask */
+        unsigned int valid_hooks;
+
+        /* Hook entry points: one per netfilter hook. */
+        unsigned int hook_entry[NF_ARP_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_ARP_NUMHOOKS];
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Size of entries. */
+        unsigned int size;
+};
+
+/* The argument to ARPT_SO_SET_REPLACE. */
+struct arpt_replace
+{
+        /* Which table. */
+        char name[ARPT_TABLE_MAXNAMELEN];
+
+        /* Which hook entry points are valid: bitmask.  You can't
+           change this. */
+        unsigned int valid_hooks;
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Total size of new entries */
+        unsigned int size;
+
+        /* Hook entry points. */
+        unsigned int hook_entry[NF_ARP_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_ARP_NUMHOOKS];
+
+        /* Information about old entries: */
+        /* Number of counters (must be equal to current number of entries). */
+        unsigned int num_counters;
+        /* The old entries' counters. */
+        struct arpt_counters __user *counters;
+
+        /* The entries (hang off end: not really an array). */
+        struct arpt_entry entries[0];
+};
+
+/* The argument to ARPT_SO_ADD_COUNTERS. */
+struct arpt_counters_info
+{
+        /* Which table. */
+        char name[ARPT_TABLE_MAXNAMELEN];
+
+        unsigned int num_counters;
+
+        /* The counters (actually `number' of these). */
+        struct arpt_counters counters[0];
+};
+
+/* The argument to ARPT_SO_GET_ENTRIES. */
+struct arpt_get_entries
+{
+        /* Which table: user fills this in. */
+        char name[ARPT_TABLE_MAXNAMELEN];
+
+        /* User fills this in: total entry size. */
+        unsigned int size;
+
+        /* The entries. */
+        struct arpt_entry entrytable[0];
+};
+
+/* Standard return verdict, or do jump. */
+#define ARPT_STANDARD_TARGET ""
+/* Error verdict. */
+#define ARPT_ERROR_TARGET "ERROR"
+
+/* Helper functions */
+static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e)
+{
+        return (void *)e + e->target_offset;
+}
+
+/* fn returns 0 to continue iteration */
+#define ARPT_ENTRY_ITERATE(entries, size, fn, args...)          \
+({                                                              \
+        unsigned int __i;                                       \
+        int __ret = 0;                                          \
+        struct arpt_entry *__entry;                             \
+                                                                \
+        for (__i = 0; __i < (size); __i += __entry->next_offset) { \
+                __entry = (void *)(entries) + __i;              \
+                                                                \
+                __ret = fn(__entry , ## args);                  \
+                if (__ret != 0)                                 \
+                        break;                                  \
+        }                                                       \
+        __ret;                                                  \
+})
+
+/*
+ *      Main firewall chains definitions and global var's definitions.
+ */
+#ifdef __KERNEL__
+
+/* Registration hooks for targets. */
+struct arpt_target
+{
+        struct list_head list;
+
+        const char name[ARPT_FUNCTION_MAXNAMELEN];
+
+        /* Returns verdict. */
+        unsigned int (*target)(struct sk_buff **pskb,
+                               unsigned int hooknum,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               const void *targinfo,
+                               void *userdata);
+
+        /* Called when user tries to insert an entry of this type:
+           hook_mask is a bitmask of hooks from which it can be
+           called. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const struct arpt_entry *e,
+                          void *targinfo,
+                          unsigned int targinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *targinfo, unsigned int targinfosize);
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+extern int arpt_register_target(struct arpt_target *target);
+extern void arpt_unregister_target(struct arpt_target *target);
+
+/* Furniture shopping... */
+struct arpt_table
+{
+        struct list_head list;
+
+        /* A unique name... */
+        char name[ARPT_TABLE_MAXNAMELEN];
+
+        /* What hooks you will enter on */
+        unsigned int valid_hooks;
+
+        /* Lock for the curtain */
+        rwlock_t lock;
+
+        /* Man behind the curtain... */
+        struct arpt_table_info *private;
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+extern int arpt_register_table(struct arpt_table *table,
+                               const struct arpt_replace *repl);
+extern void arpt_unregister_table(struct arpt_table *table);
+extern unsigned int arpt_do_table(struct sk_buff **pskb,
+                                  unsigned int hook,
+                                  const struct net_device *in,
+                                  const struct net_device *out,
+                                  struct arpt_table *table,
+                                  void *userdata);
+
+#define ARPT_ALIGN(s) (((s) + (__alignof__(struct arpt_entry)-1)) & ~(__alignof__(struct arpt_entry)-1))
+#endif /*__KERNEL__*/
+#endif /* _ARPTABLES_H */
diff --git a/include/linux/netfilter_arp/arpt_mangle.h b/include/linux/netfilter_arp/arpt_mangle.h
new file mode 100644
index 000000000000..250f502902bb
--- /dev/null
+++ b/include/linux/netfilter_arp/arpt_mangle.h
@@ -0,0 +1,26 @@
+#ifndef _ARPT_MANGLE_H
+#define _ARPT_MANGLE_H
+#include <linux/netfilter_arp/arp_tables.h>
+
+#define ARPT_MANGLE_ADDR_LEN_MAX sizeof(struct in_addr)
+struct arpt_mangle
+{
+        char src_devaddr[ARPT_DEV_ADDR_LEN_MAX];
+        char tgt_devaddr[ARPT_DEV_ADDR_LEN_MAX];
+        union {
+                struct in_addr src_ip;
+        } u_s;
+        union {
+                struct in_addr tgt_ip;
+        } u_t;
+        u_int8_t flags;
+        int target;
+};
+
+#define ARPT_MANGLE_SDEV 0x01
+#define ARPT_MANGLE_TDEV 0x02
+#define ARPT_MANGLE_SIP 0x04
+#define ARPT_MANGLE_TIP 0x08
+#define ARPT_MANGLE_MASK 0x0f
+
+#endif /* _ARPT_MANGLE_H */
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
new file mode 100644
index 000000000000..de4d397865ce
--- /dev/null
+++ b/include/linux/netfilter_bridge.h
@@ -0,0 +1,113 @@
+#ifndef __LINUX_BRIDGE_NETFILTER_H
+#define __LINUX_BRIDGE_NETFILTER_H
+
+/* bridge-specific defines for netfilter. 
+ */
+
+#include <linux/config.h>
+#include <linux/netfilter.h>
+#if defined(__KERNEL__) && defined(CONFIG_BRIDGE_NETFILTER)
+#include <asm/atomic.h>
+#include <linux/if_ether.h>
+#endif
+
+/* Bridge Hooks */
+/* After promisc drops, checksum checks. */
+#define NF_BR_PRE_ROUTING       0
+/* If the packet is destined for this box. */
+#define NF_BR_LOCAL_IN          1
+/* If the packet is destined for another interface. */
+#define NF_BR_FORWARD           2
+/* Packets coming from a local process. */
+#define NF_BR_LOCAL_OUT         3
+/* Packets about to hit the wire. */
+#define NF_BR_POST_ROUTING      4
+/* Not really a hook, but used for the ebtables broute table */
+#define NF_BR_BROUTING          5
+#define NF_BR_NUMHOOKS          6
+
+#ifdef __KERNEL__
+
+enum nf_br_hook_priorities {
+        NF_BR_PRI_FIRST = INT_MIN,
+        NF_BR_PRI_NAT_DST_BRIDGED = -300,
+        NF_BR_PRI_FILTER_BRIDGED = -200,
+        NF_BR_PRI_BRNF = 0,
+        NF_BR_PRI_NAT_DST_OTHER = 100,
+        NF_BR_PRI_FILTER_OTHER = 200,
+        NF_BR_PRI_NAT_SRC = 300,
+        NF_BR_PRI_LAST = INT_MAX,
+};
+
+#ifdef CONFIG_BRIDGE_NETFILTER
+
+#define BRNF_PKT_TYPE                   0x01
+#define BRNF_BRIDGED_DNAT               0x02
+#define BRNF_DONT_TAKE_PARENT           0x04
+#define BRNF_BRIDGED                    0x08
+#define BRNF_NF_BRIDGE_PREROUTING       0x10
+
+static inline
+struct nf_bridge_info *nf_bridge_alloc(struct sk_buff *skb)
+{
+        struct nf_bridge_info **nf_bridge = &(skb->nf_bridge);
+
+        if ((*nf_bridge = kmalloc(sizeof(**nf_bridge), GFP_ATOMIC)) != NULL) {
+                atomic_set(&(*nf_bridge)->use, 1);
+                (*nf_bridge)->mask = 0;
+                (*nf_bridge)->physindev = (*nf_bridge)->physoutdev = NULL;
+#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+                (*nf_bridge)->netoutdev = NULL;
+#endif
+        }
+
+        return *nf_bridge;
+}
+
+/* Only used in br_forward.c */
+static inline
+void nf_bridge_maybe_copy_header(struct sk_buff *skb)
+{
+        if (skb->nf_bridge) {
+                if (skb->protocol == __constant_htons(ETH_P_8021Q)) {
+                        memcpy(skb->data - 18, skb->nf_bridge->data, 18);
+                        skb_push(skb, 4);
+                } else
+                        memcpy(skb->data - 16, skb->nf_bridge->data, 16);
+        }
+}
+
+static inline
+void nf_bridge_save_header(struct sk_buff *skb)
+{
+        int header_size = 16;
+
+        if (skb->protocol == __constant_htons(ETH_P_8021Q))
+                header_size = 18;
+
+        memcpy(skb->nf_bridge->data, skb->data - header_size, header_size);
+}
+
+/* This is called by the IP fragmenting code and it ensures there is
+ * enough room for the encapsulating header (if there is one). */
+static inline
+int nf_bridge_pad(struct sk_buff *skb)
+{
+        if (skb->protocol == __constant_htons(ETH_P_IP))
+                return 0;
+        if (skb->nf_bridge) {
+                if (skb->protocol == __constant_htons(ETH_P_8021Q))
+                        return 4;
+        }
+        return 0;
+}
+
+struct bridge_skb_cb {
+        union {
+                __u32 ipv4;
+        } daddr;
+};
+#endif /* CONFIG_BRIDGE_NETFILTER */
+
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_802_3.h b/include/linux/netfilter_bridge/ebt_802_3.h
new file mode 100644
index 000000000000..b9f712c14a0a
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_802_3.h
@@ -0,0 +1,69 @@
+#ifndef __LINUX_BRIDGE_EBT_802_3_H
+#define __LINUX_BRIDGE_EBT_802_3_H
+
+#define EBT_802_3_SAP 0x01
+#define EBT_802_3_TYPE 0x02
+
+#define EBT_802_3_MATCH "802_3"
+
+/*
+ * If frame has DSAP/SSAP value 0xaa you must check the SNAP type
+ * to discover what kind of packet we're carrying. 
+ */
+#define CHECK_TYPE 0xaa
+
+/*
+ * Control field may be one or two bytes.  If the first byte has
+ * the value 0x03 then the entire length is one byte, otherwise it is two.
+ * One byte controls are used in Unnumbered Information frames.
+ * Two byte controls are used in Numbered Information frames.
+ */
+#define IS_UI 0x03
+
+#define EBT_802_3_MASK (EBT_802_3_SAP | EBT_802_3_TYPE | EBT_802_3)
+
+/* ui has one byte ctrl, ni has two */
+struct hdr_ui {
+        uint8_t dsap;
+        uint8_t ssap;
+        uint8_t ctrl;
+        uint8_t orig[3];
+        uint16_t type;
+};
+
+struct hdr_ni {
+        uint8_t dsap;
+        uint8_t ssap;
+        uint16_t ctrl;
+        uint8_t  orig[3];
+        uint16_t type;
+};
+
+struct ebt_802_3_hdr {
+        uint8_t  daddr[6];
+        uint8_t  saddr[6];
+        uint16_t len;
+        union {
+                struct hdr_ui ui;
+                struct hdr_ni ni;
+        } llc;
+};
+
+#ifdef __KERNEL__
+#include <linux/skbuff.h>
+
+static inline struct ebt_802_3_hdr *ebt_802_3_hdr(const struct sk_buff *skb)
+{
+        return (struct ebt_802_3_hdr *)skb->mac.raw;
+}
+#endif
+
+struct ebt_802_3_info 
+{
+        uint8_t  sap;
+        uint16_t type;
+        uint8_t  bitmask;
+        uint8_t  invflags;
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_among.h b/include/linux/netfilter_bridge/ebt_among.h
new file mode 100644
index 000000000000..307c1fed8511
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_among.h
@@ -0,0 +1,65 @@
+#ifndef __LINUX_BRIDGE_EBT_AMONG_H
+#define __LINUX_BRIDGE_EBT_AMONG_H
+
+#define EBT_AMONG_DST 0x01
+#define EBT_AMONG_SRC 0x02
+
+/* Grzegorz Borowiak <grzes@gnu.univ.gda.pl> 2003
+ * 
+ * Write-once-read-many hash table, used for checking if a given
+ * MAC address belongs to a set or not and possibly for checking
+ * if it is related with a given IPv4 address.
+ *
+ * The hash value of an address is its last byte.
+ * 
+ * In real-world ethernet addresses, values of the last byte are
+ * evenly distributed and there is no need to consider other bytes.
+ * It would only slow the routines down.
+ *
+ * For MAC address comparison speedup reasons, we introduce a trick.
+ * MAC address is mapped onto an array of two 32-bit integers.
+ * This pair of integers is compared with MAC addresses in the
+ * hash table, which are stored also in form of pairs of integers
+ * (in `cmp' array). This is quick as it requires only two elementary
+ * number comparisons in worst case. Further, we take advantage of
+ * fact that entropy of 3 last bytes of address is larger than entropy
+ * of 3 first bytes. So first we compare 4 last bytes of addresses and
+ * if they are the same we compare 2 first.
+ *
+ * Yes, it is a memory overhead, but in 2003 AD, who cares?
+ */
+
+struct ebt_mac_wormhash_tuple
+{
+        uint32_t cmp[2];
+        uint32_t ip;
+};
+
+struct ebt_mac_wormhash
+{
+        int table[257];
+        int poolsize;
+        struct ebt_mac_wormhash_tuple pool[0];
+};
+
+#define ebt_mac_wormhash_size(x) ((x) ? sizeof(struct ebt_mac_wormhash) \
+                + (x)->poolsize * sizeof(struct ebt_mac_wormhash_tuple) : 0)
+
+struct ebt_among_info
+{
+        int wh_dst_ofs;
+        int wh_src_ofs;
+        int bitmask;
+};
+
+#define EBT_AMONG_DST_NEG 0x1
+#define EBT_AMONG_SRC_NEG 0x2
+
+#define ebt_among_wh_dst(x) ((x)->wh_dst_ofs ? \
+        (struct ebt_mac_wormhash*)((char*)(x) + (x)->wh_dst_ofs) : NULL)
+#define ebt_among_wh_src(x) ((x)->wh_src_ofs ? \
+        (struct ebt_mac_wormhash*)((char*)(x) + (x)->wh_src_ofs) : NULL)
+
+#define EBT_AMONG_MATCH "among"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_arp.h b/include/linux/netfilter_bridge/ebt_arp.h
new file mode 100644
index 000000000000..537ec6b487a2
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_arp.h
@@ -0,0 +1,32 @@
+#ifndef __LINUX_BRIDGE_EBT_ARP_H
+#define __LINUX_BRIDGE_EBT_ARP_H
+
+#define EBT_ARP_OPCODE 0x01
+#define EBT_ARP_HTYPE 0x02
+#define EBT_ARP_PTYPE 0x04
+#define EBT_ARP_SRC_IP 0x08
+#define EBT_ARP_DST_IP 0x10
+#define EBT_ARP_SRC_MAC 0x20
+#define EBT_ARP_DST_MAC 0x40
+#define EBT_ARP_MASK (EBT_ARP_OPCODE | EBT_ARP_HTYPE | EBT_ARP_PTYPE | \
+   EBT_ARP_SRC_IP | EBT_ARP_DST_IP | EBT_ARP_SRC_MAC | EBT_ARP_DST_MAC)
+#define EBT_ARP_MATCH "arp"
+
+struct ebt_arp_info
+{
+        uint16_t htype;
+        uint16_t ptype;
+        uint16_t opcode;
+        uint32_t saddr;
+        uint32_t smsk;
+        uint32_t daddr;
+        uint32_t dmsk;
+        unsigned char smaddr[ETH_ALEN];
+        unsigned char smmsk[ETH_ALEN];
+        unsigned char dmaddr[ETH_ALEN];
+        unsigned char dmmsk[ETH_ALEN];
+        uint8_t  bitmask;
+        uint8_t  invflags;
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_arpreply.h b/include/linux/netfilter_bridge/ebt_arpreply.h
new file mode 100644
index 000000000000..96a8339960e0
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_arpreply.h
@@ -0,0 +1,11 @@
+#ifndef __LINUX_BRIDGE_EBT_ARPREPLY_H
+#define __LINUX_BRIDGE_EBT_ARPREPLY_H
+
+struct ebt_arpreply_info
+{
+        unsigned char mac[ETH_ALEN];
+        int target;
+};
+#define EBT_ARPREPLY_TARGET "arpreply"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_ip.h b/include/linux/netfilter_bridge/ebt_ip.h
new file mode 100644
index 000000000000..7247385cdcb1
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_ip.h
@@ -0,0 +1,43 @@
+/*
+ *  ebt_ip
+ *
+ *      Authors:
+ *      Bart De Schuymer <bart.de.schuymer@pandora.be>
+ *
+ *  April, 2002
+ *
+ *  Changes:
+ *    added ip-sport and ip-dport
+ *    Innominate Security Technologies AG <mhopf@innominate.com>
+ *    September, 2002
+ */
+
+#ifndef __LINUX_BRIDGE_EBT_IP_H
+#define __LINUX_BRIDGE_EBT_IP_H
+
+#define EBT_IP_SOURCE 0x01
+#define EBT_IP_DEST 0x02
+#define EBT_IP_TOS 0x04
+#define EBT_IP_PROTO 0x08
+#define EBT_IP_SPORT 0x10
+#define EBT_IP_DPORT 0x20
+#define EBT_IP_MASK (EBT_IP_SOURCE | EBT_IP_DEST | EBT_IP_TOS | EBT_IP_PROTO |\
+ EBT_IP_SPORT | EBT_IP_DPORT )
+#define EBT_IP_MATCH "ip"
+
+/* the same values are used for the invflags */
+struct ebt_ip_info
+{
+        uint32_t saddr;
+        uint32_t daddr;
+        uint32_t smsk;
+        uint32_t dmsk;
+        uint8_t  tos;
+        uint8_t  protocol;
+        uint8_t  bitmask;
+        uint8_t  invflags;
+        uint16_t sport[2];
+        uint16_t dport[2];
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_limit.h b/include/linux/netfilter_bridge/ebt_limit.h
new file mode 100644
index 000000000000..d8b65000afe4
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_limit.h
@@ -0,0 +1,23 @@
+#ifndef __LINUX_BRIDGE_EBT_LIMIT_H
+#define __LINUX_BRIDGE_EBT_LIMIT_H
+
+#define EBT_LIMIT_MATCH "limit"
+
+/* timings are in milliseconds. */
+#define EBT_LIMIT_SCALE 10000
+
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+
+struct ebt_limit_info
+{
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+
+        /* Used internally by the kernel */
+        unsigned long prev;
+        u_int32_t credit;
+        u_int32_t credit_cap, cost;
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_log.h b/include/linux/netfilter_bridge/ebt_log.h
new file mode 100644
index 000000000000..358fbc84fb59
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_log.h
@@ -0,0 +1,17 @@
+#ifndef __LINUX_BRIDGE_EBT_LOG_H
+#define __LINUX_BRIDGE_EBT_LOG_H
+
+#define EBT_LOG_IP 0x01 /* if the frame is made by ip, log the ip information */
+#define EBT_LOG_ARP 0x02
+#define EBT_LOG_MASK (EBT_LOG_IP | EBT_LOG_ARP)
+#define EBT_LOG_PREFIX_SIZE 30
+#define EBT_LOG_WATCHER "log"
+
+struct ebt_log_info
+{
+        uint8_t loglevel;
+        uint8_t prefix[EBT_LOG_PREFIX_SIZE];
+        uint32_t bitmask;
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_mark_m.h b/include/linux/netfilter_bridge/ebt_mark_m.h
new file mode 100644
index 000000000000..301524ff1065
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_mark_m.h
@@ -0,0 +1,15 @@
+#ifndef __LINUX_BRIDGE_EBT_MARK_M_H
+#define __LINUX_BRIDGE_EBT_MARK_M_H
+
+#define EBT_MARK_AND 0x01
+#define EBT_MARK_OR 0x02
+#define EBT_MARK_MASK (EBT_MARK_AND | EBT_MARK_OR)
+struct ebt_mark_m_info
+{
+        unsigned long mark, mask;
+        uint8_t invert;
+        uint8_t bitmask;
+};
+#define EBT_MARK_MATCH "mark_m"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_mark_t.h b/include/linux/netfilter_bridge/ebt_mark_t.h
new file mode 100644
index 000000000000..110fec6a40a2
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_mark_t.h
@@ -0,0 +1,12 @@
+#ifndef __LINUX_BRIDGE_EBT_MARK_T_H
+#define __LINUX_BRIDGE_EBT_MARK_T_H
+
+struct ebt_mark_t_info
+{
+        unsigned long mark;
+        /* EBT_ACCEPT, EBT_DROP, EBT_CONTINUE or EBT_RETURN */
+        int target;
+};
+#define EBT_MARK_TARGET "mark"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_nat.h b/include/linux/netfilter_bridge/ebt_nat.h
new file mode 100644
index 000000000000..26fd90da4cd6
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_nat.h
@@ -0,0 +1,13 @@
+#ifndef __LINUX_BRIDGE_EBT_NAT_H
+#define __LINUX_BRIDGE_EBT_NAT_H
+
+struct ebt_nat_info
+{
+        unsigned char mac[ETH_ALEN];
+        /* EBT_ACCEPT, EBT_DROP, EBT_CONTINUE or EBT_RETURN */
+        int target;
+};
+#define EBT_SNAT_TARGET "snat"
+#define EBT_DNAT_TARGET "dnat"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_pkttype.h b/include/linux/netfilter_bridge/ebt_pkttype.h
new file mode 100644
index 000000000000..0d64bbb29c66
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_pkttype.h
@@ -0,0 +1,11 @@
+#ifndef __LINUX_BRIDGE_EBT_PKTTYPE_H
+#define __LINUX_BRIDGE_EBT_PKTTYPE_H
+
+struct ebt_pkttype_info
+{
+        uint8_t pkt_type;
+        uint8_t invert;
+};
+#define EBT_PKTTYPE_MATCH "pkttype"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_redirect.h b/include/linux/netfilter_bridge/ebt_redirect.h
new file mode 100644
index 000000000000..5c67990fce39
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_redirect.h
@@ -0,0 +1,11 @@
+#ifndef __LINUX_BRIDGE_EBT_REDIRECT_H
+#define __LINUX_BRIDGE_EBT_REDIRECT_H
+
+struct ebt_redirect_info
+{
+        /* EBT_ACCEPT, EBT_DROP, EBT_CONTINUE or EBT_RETURN */
+        int target;
+};
+#define EBT_REDIRECT_TARGET "redirect"
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_stp.h b/include/linux/netfilter_bridge/ebt_stp.h
new file mode 100644
index 000000000000..e5fd67850f4d
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_stp.h
@@ -0,0 +1,46 @@
+#ifndef __LINUX_BRIDGE_EBT_STP_H
+#define __LINUX_BRIDGE_EBT_STP_H
+
+#define EBT_STP_TYPE            0x0001
+
+#define EBT_STP_FLAGS           0x0002
+#define EBT_STP_ROOTPRIO        0x0004
+#define EBT_STP_ROOTADDR        0x0008
+#define EBT_STP_ROOTCOST        0x0010
+#define EBT_STP_SENDERPRIO      0x0020
+#define EBT_STP_SENDERADDR      0x0040
+#define EBT_STP_PORT            0x0080
+#define EBT_STP_MSGAGE          0x0100
+#define EBT_STP_MAXAGE          0x0200
+#define EBT_STP_HELLOTIME       0x0400
+#define EBT_STP_FWDD            0x0800
+
+#define EBT_STP_MASK            0x0fff
+#define EBT_STP_CONFIG_MASK     0x0ffe
+
+#define EBT_STP_MATCH "stp"
+
+struct ebt_stp_config_info
+{
+        uint8_t flags;
+        uint16_t root_priol, root_priou;
+        char root_addr[6], root_addrmsk[6];
+        uint32_t root_costl, root_costu;
+        uint16_t sender_priol, sender_priou;
+        char sender_addr[6], sender_addrmsk[6];
+        uint16_t portl, portu;
+        uint16_t msg_agel, msg_ageu;
+        uint16_t max_agel, max_ageu;
+        uint16_t hello_timel, hello_timeu;
+        uint16_t forward_delayl, forward_delayu;
+};
+
+struct ebt_stp_info
+{
+        uint8_t type;
+        struct ebt_stp_config_info config;
+        uint16_t bitmask;
+        uint16_t invflags;
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebt_ulog.h b/include/linux/netfilter_bridge/ebt_ulog.h
new file mode 100644
index 000000000000..b677e2671541
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_ulog.h
@@ -0,0 +1,36 @@
+#ifndef _EBT_ULOG_H
+#define _EBT_ULOG_H
+
+#define EBT_ULOG_DEFAULT_NLGROUP 0
+#define EBT_ULOG_DEFAULT_QTHRESHOLD 1
+#define EBT_ULOG_MAXNLGROUPS 32 /* hardcoded netlink max */
+#define EBT_ULOG_PREFIX_LEN 32
+#define EBT_ULOG_MAX_QLEN 50
+#define EBT_ULOG_WATCHER "ulog"
+#define EBT_ULOG_VERSION 1
+
+struct ebt_ulog_info {
+        uint32_t nlgroup;
+        unsigned int cprange;
+        unsigned int qthreshold;
+        char prefix[EBT_ULOG_PREFIX_LEN];
+};
+
+typedef struct ebt_ulog_packet_msg {
+        int version;
+        char indev[IFNAMSIZ];
+        char outdev[IFNAMSIZ];
+        char physindev[IFNAMSIZ];
+        char physoutdev[IFNAMSIZ];
+        char prefix[EBT_ULOG_PREFIX_LEN];
+        struct timeval stamp;
+        unsigned long mark;
+        unsigned int hook;
+        size_t data_len;
+        /* The complete packet, including Ethernet header and perhaps
+         * the VLAN header is appended */
+        unsigned char data[0] __attribute__
+                              ((aligned (__alignof__(struct ebt_ulog_info))));
+} ebt_ulog_packet_msg_t;
+
+#endif /* _EBT_ULOG_H */
diff --git a/include/linux/netfilter_bridge/ebt_vlan.h b/include/linux/netfilter_bridge/ebt_vlan.h
new file mode 100644
index 000000000000..cb1fcc41565f
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebt_vlan.h
@@ -0,0 +1,20 @@
+#ifndef __LINUX_BRIDGE_EBT_VLAN_H
+#define __LINUX_BRIDGE_EBT_VLAN_H
+
+#define EBT_VLAN_ID     0x01
+#define EBT_VLAN_PRIO   0x02
+#define EBT_VLAN_ENCAP  0x04
+#define EBT_VLAN_MASK (EBT_VLAN_ID | EBT_VLAN_PRIO | EBT_VLAN_ENCAP)
+#define EBT_VLAN_MATCH "vlan"
+
+struct ebt_vlan_info {
+        uint16_t id;            /* VLAN ID {1-4095} */
+        uint8_t prio;           /* VLAN User Priority {0-7} */
+        uint16_t encap;         /* VLAN Encapsulated frame code {0-65535} */
+        uint8_t bitmask;                /* Args bitmask bit 1=1 - ID arg,
+                                   bit 2=1 User-Priority arg, bit 3=1 encap*/
+        uint8_t invflags;               /* Inverse bitmask  bit 1=1 - inversed ID arg, 
+                                   bit 2=1 - inversed Pirority arg */
+};
+
+#endif
diff --git a/include/linux/netfilter_bridge/ebtables.h b/include/linux/netfilter_bridge/ebtables.h
new file mode 100644
index 000000000000..b1a7cc90877b
--- /dev/null
+++ b/include/linux/netfilter_bridge/ebtables.h
@@ -0,0 +1,363 @@
+/*
+ *  ebtables
+ *
+ *      Authors:
+ *      Bart De Schuymer                <bdschuym@pandora.be>
+ *
+ *  ebtables.c,v 2.0, April, 2002
+ *
+ *  This code is stongly inspired on the iptables code which is
+ *  Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
+ */
+
+#ifndef __LINUX_BRIDGE_EFF_H
+#define __LINUX_BRIDGE_EFF_H
+#include <linux/if.h>
+#include <linux/netfilter_bridge.h>
+#include <linux/if_ether.h>
+
+#define EBT_TABLE_MAXNAMELEN 32
+#define EBT_CHAIN_MAXNAMELEN EBT_TABLE_MAXNAMELEN
+#define EBT_FUNCTION_MAXNAMELEN EBT_TABLE_MAXNAMELEN
+
+/* verdicts >0 are "branches" */
+#define EBT_ACCEPT   -1
+#define EBT_DROP     -2
+#define EBT_CONTINUE -3
+#define EBT_RETURN   -4
+#define NUM_STANDARD_TARGETS   4
+
+struct ebt_counter
+{
+        uint64_t pcnt;
+        uint64_t bcnt;
+};
+
+struct ebt_replace
+{
+        char name[EBT_TABLE_MAXNAMELEN];
+        unsigned int valid_hooks;
+        /* nr of rules in the table */
+        unsigned int nentries;
+        /* total size of the entries */
+        unsigned int entries_size;
+        /* start of the chains */
+        struct ebt_entries *hook_entry[NF_BR_NUMHOOKS];
+        /* nr of counters userspace expects back */
+        unsigned int num_counters;
+        /* where the kernel will put the old counters */
+        struct ebt_counter *counters;
+        char *entries;
+};
+
+struct ebt_entries {
+        /* this field is always set to zero
+         * See EBT_ENTRY_OR_ENTRIES.
+         * Must be same size as ebt_entry.bitmask */
+        unsigned int distinguisher;
+        /* the chain name */
+        char name[EBT_CHAIN_MAXNAMELEN];
+        /* counter offset for this chain */
+        unsigned int counter_offset;
+        /* one standard (accept, drop, return) per hook */
+        int policy;
+        /* nr. of entries */
+        unsigned int nentries;
+        /* entry list */
+        char data[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
+};
+
+/* used for the bitmask of struct ebt_entry */
+
+/* This is a hack to make a difference between an ebt_entry struct and an
+ * ebt_entries struct when traversing the entries from start to end.
+ * Using this simplifies the code alot, while still being able to use
+ * ebt_entries.
+ * Contrary, iptables doesn't use something like ebt_entries and therefore uses
+ * different techniques for naming the policy and such. So, iptables doesn't
+ * need a hack like this.
+ */
+#define EBT_ENTRY_OR_ENTRIES 0x01
+/* these are the normal masks */
+#define EBT_NOPROTO 0x02
+#define EBT_802_3 0x04
+#define EBT_SOURCEMAC 0x08
+#define EBT_DESTMAC 0x10
+#define EBT_F_MASK (EBT_NOPROTO | EBT_802_3 | EBT_SOURCEMAC | EBT_DESTMAC \
+   | EBT_ENTRY_OR_ENTRIES)
+
+#define EBT_IPROTO 0x01
+#define EBT_IIN 0x02
+#define EBT_IOUT 0x04
+#define EBT_ISOURCE 0x8
+#define EBT_IDEST 0x10
+#define EBT_ILOGICALIN 0x20
+#define EBT_ILOGICALOUT 0x40
+#define EBT_INV_MASK (EBT_IPROTO | EBT_IIN | EBT_IOUT | EBT_ILOGICALIN \
+   | EBT_ILOGICALOUT | EBT_ISOURCE | EBT_IDEST)
+
+struct ebt_entry_match
+{
+        union {
+                char name[EBT_FUNCTION_MAXNAMELEN];
+                struct ebt_match *match;
+        } u;
+        /* size of data */
+        unsigned int match_size;
+        unsigned char data[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
+};
+
+struct ebt_entry_watcher
+{
+        union {
+                char name[EBT_FUNCTION_MAXNAMELEN];
+                struct ebt_watcher *watcher;
+        } u;
+        /* size of data */
+        unsigned int watcher_size;
+        unsigned char data[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
+};
+
+struct ebt_entry_target
+{
+        union {
+                char name[EBT_FUNCTION_MAXNAMELEN];
+                struct ebt_target *target;
+        } u;
+        /* size of data */
+        unsigned int target_size;
+        unsigned char data[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
+};
+
+#define EBT_STANDARD_TARGET "standard"
+struct ebt_standard_target
+{
+        struct ebt_entry_target target;
+        int verdict;
+};
+
+/* one entry */
+struct ebt_entry {
+        /* this needs to be the first field */
+        unsigned int bitmask;
+        unsigned int invflags;
+        uint16_t ethproto;
+        /* the physical in-dev */
+        char in[IFNAMSIZ];
+        /* the logical in-dev */
+        char logical_in[IFNAMSIZ];
+        /* the physical out-dev */
+        char out[IFNAMSIZ];
+        /* the logical out-dev */
+        char logical_out[IFNAMSIZ];
+        unsigned char sourcemac[ETH_ALEN];
+        unsigned char sourcemsk[ETH_ALEN];
+        unsigned char destmac[ETH_ALEN];
+        unsigned char destmsk[ETH_ALEN];
+        /* sizeof ebt_entry + matches */
+        unsigned int watchers_offset;
+        /* sizeof ebt_entry + matches + watchers */
+        unsigned int target_offset;
+        /* sizeof ebt_entry + matches + watchers + target */
+        unsigned int next_offset;
+        unsigned char elems[0] __attribute__ ((aligned (__alignof__(struct ebt_replace))));
+};
+
+/* {g,s}etsockopt numbers */
+#define EBT_BASE_CTL            128
+
+#define EBT_SO_SET_ENTRIES      (EBT_BASE_CTL)
+#define EBT_SO_SET_COUNTERS     (EBT_SO_SET_ENTRIES+1)
+#define EBT_SO_SET_MAX          (EBT_SO_SET_COUNTERS+1)
+
+#define EBT_SO_GET_INFO         (EBT_BASE_CTL)
+#define EBT_SO_GET_ENTRIES      (EBT_SO_GET_INFO+1)
+#define EBT_SO_GET_INIT_INFO    (EBT_SO_GET_ENTRIES+1)
+#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO+1)
+#define EBT_SO_GET_MAX          (EBT_SO_GET_INIT_ENTRIES+1)
+
+#ifdef __KERNEL__
+
+/* return values for match() functions */
+#define EBT_MATCH 0
+#define EBT_NOMATCH 1
+
+struct ebt_match
+{
+        struct list_head list;
+        const char name[EBT_FUNCTION_MAXNAMELEN];
+        /* 0 == it matches */
+        int (*match)(const struct sk_buff *skb, const struct net_device *in,
+           const struct net_device *out, const void *matchdata,
+           unsigned int datalen);
+        /* 0 == let it in */
+        int (*check)(const char *tablename, unsigned int hookmask,
+           const struct ebt_entry *e, void *matchdata, unsigned int datalen);
+        void (*destroy)(void *matchdata, unsigned int datalen);
+        struct module *me;
+};
+
+struct ebt_watcher
+{
+        struct list_head list;
+        const char name[EBT_FUNCTION_MAXNAMELEN];
+        void (*watcher)(const struct sk_buff *skb, unsigned int hooknr,
+           const struct net_device *in, const struct net_device *out,
+           const void *watcherdata, unsigned int datalen);
+        /* 0 == let it in */
+        int (*check)(const char *tablename, unsigned int hookmask,
+           const struct ebt_entry *e, void *watcherdata, unsigned int datalen);
+        void (*destroy)(void *watcherdata, unsigned int datalen);
+        struct module *me;
+};
+
+struct ebt_target
+{
+        struct list_head list;
+        const char name[EBT_FUNCTION_MAXNAMELEN];
+        /* returns one of the standard verdicts */
+        int (*target)(struct sk_buff **pskb, unsigned int hooknr,
+           const struct net_device *in, const struct net_device *out,
+           const void *targetdata, unsigned int datalen);
+        /* 0 == let it in */
+        int (*check)(const char *tablename, unsigned int hookmask,
+           const struct ebt_entry *e, void *targetdata, unsigned int datalen);
+        void (*destroy)(void *targetdata, unsigned int datalen);
+        struct module *me;
+};
+
+/* used for jumping from and into user defined chains (udc) */
+struct ebt_chainstack
+{
+        struct ebt_entries *chaininfo; /* pointer to chain data */
+        struct ebt_entry *e; /* pointer to entry data */
+        unsigned int n; /* n'th entry */
+};
+
+struct ebt_table_info
+{
+        /* total size of the entries */
+        unsigned int entries_size;
+        unsigned int nentries;
+        /* pointers to the start of the chains */
+        struct ebt_entries *hook_entry[NF_BR_NUMHOOKS];
+        /* room to maintain the stack used for jumping from and into udc */
+        struct ebt_chainstack **chainstack;
+        char *entries;
+        struct ebt_counter counters[0] ____cacheline_aligned;
+};
+
+struct ebt_table
+{
+        struct list_head list;
+        char name[EBT_TABLE_MAXNAMELEN];
+        struct ebt_replace *table;
+        unsigned int valid_hooks;
+        rwlock_t lock;
+        /* e.g. could be the table explicitly only allows certain
+         * matches, targets, ... 0 == let it in */
+        int (*check)(const struct ebt_table_info *info,
+           unsigned int valid_hooks);
+        /* the data used by the kernel */
+        struct ebt_table_info *private;
+        struct module *me;
+};
+
+#define EBT_ALIGN(s) (((s) + (__alignof__(struct ebt_replace)-1)) & \
+                     ~(__alignof__(struct ebt_replace)-1))
+extern int ebt_register_table(struct ebt_table *table);
+extern void ebt_unregister_table(struct ebt_table *table);
+extern int ebt_register_match(struct ebt_match *match);
+extern void ebt_unregister_match(struct ebt_match *match);
+extern int ebt_register_watcher(struct ebt_watcher *watcher);
+extern void ebt_unregister_watcher(struct ebt_watcher *watcher);
+extern int ebt_register_target(struct ebt_target *target);
+extern void ebt_unregister_target(struct ebt_target *target);
+extern unsigned int ebt_do_table(unsigned int hook, struct sk_buff **pskb,
+   const struct net_device *in, const struct net_device *out,
+   struct ebt_table *table);
+
+/* Used in the kernel match() functions */
+#define FWINV(bool,invflg) ((bool) ^ !!(info->invflags & invflg))
+/* True if the hook mask denotes that the rule is in a base chain,
+ * used in the check() functions */
+#define BASE_CHAIN (hookmask & (1 << NF_BR_NUMHOOKS))
+/* Clear the bit in the hook mask that tells if the rule is on a base chain */
+#define CLEAR_BASE_CHAIN_BIT (hookmask &= ~(1 << NF_BR_NUMHOOKS))
+/* True if the target is not a standard target */
+#define INVALID_TARGET (info->target < -NUM_STANDARD_TARGETS || info->target >= 0)
+
+#endif /* __KERNEL__ */
+
+/* blatently stolen from ip_tables.h
+ * fn returns 0 to continue iteration */
+#define EBT_MATCH_ITERATE(e, fn, args...)                   \
+({                                                          \
+        unsigned int __i;                                   \
+        int __ret = 0;                                      \
+        struct ebt_entry_match *__match;                    \
+                                                            \
+        for (__i = sizeof(struct ebt_entry);                \
+             __i < (e)->watchers_offset;                    \
+             __i += __match->match_size +                   \
+             sizeof(struct ebt_entry_match)) {              \
+                __match = (void *)(e) + __i;                \
+                                                            \
+                __ret = fn(__match , ## args);              \
+                if (__ret != 0)                             \
+                        break;                              \
+        }                                                   \
+        if (__ret == 0) {                                   \
+                if (__i != (e)->watchers_offset)            \
+                        __ret = -EINVAL;                    \
+        }                                                   \
+        __ret;                                              \
+})
+
+#define EBT_WATCHER_ITERATE(e, fn, args...)                 \
+({                                                          \
+        unsigned int __i;                                   \
+        int __ret = 0;                                      \
+        struct ebt_entry_watcher *__watcher;                \
+                                                            \
+        for (__i = e->watchers_offset;                      \
+             __i < (e)->target_offset;                      \
+             __i += __watcher->watcher_size +               \
+             sizeof(struct ebt_entry_watcher)) {            \
+                __watcher = (void *)(e) + __i;              \
+                                                            \
+                __ret = fn(__watcher , ## args);            \
+                if (__ret != 0)                             \
+                        break;                              \
+        }                                                   \
+        if (__ret == 0) {                                   \
+                if (__i != (e)->target_offset)              \
+                        __ret = -EINVAL;                    \
+        }                                                   \
+        __ret;                                              \
+})
+
+#define EBT_ENTRY_ITERATE(entries, size, fn, args...)       \
+({                                                          \
+        unsigned int __i;                                   \
+        int __ret = 0;                                      \
+        struct ebt_entry *__entry;                          \
+                                                            \
+        for (__i = 0; __i < (size);) {                      \
+                __entry = (void *)(entries) + __i;          \
+                __ret = fn(__entry , ## args);              \
+                if (__ret != 0)                             \
+                        break;                              \
+                if (__entry->bitmask != 0)                  \
+                        __i += __entry->next_offset;        \
+                else                                        \
+                        __i += sizeof(struct ebt_entries);  \
+        }                                                   \
+        if (__ret == 0) {                                   \
+                if (__i != (size))                          \
+                        __ret = -EINVAL;                    \
+        }                                                   \
+        __ret;                                              \
+})
+
+#endif
diff --git a/include/linux/netfilter_decnet.h b/include/linux/netfilter_decnet.h
new file mode 100644
index 000000000000..3064eec9cb8e
--- /dev/null
+++ b/include/linux/netfilter_decnet.h
@@ -0,0 +1,59 @@
+#ifndef __LINUX_DECNET_NETFILTER_H
+#define __LINUX_DECNET_NETFILTER_H
+
+/* DECnet-specific defines for netfilter. 
+ * This file (C) Steve Whitehouse 1999 derived from the
+ * ipv4 netfilter header file which is
+ * (C)1998 Rusty Russell -- This code is GPL.
+ */
+
+#include <linux/netfilter.h>
+
+/* IP Cache bits. */
+/* Src IP address. */
+#define NFC_DN_SRC              0x0001
+/* Dest IP address. */
+#define NFC_DN_DST              0x0002
+/* Input device. */
+#define NFC_DN_IF_IN            0x0004
+/* Output device. */
+#define NFC_DN_IF_OUT           0x0008
+
+/* DECnet Hooks */
+/* After promisc drops, checksum checks. */
+#define NF_DN_PRE_ROUTING       0
+/* If the packet is destined for this box. */
+#define NF_DN_LOCAL_IN          1
+/* If the packet is destined for another interface. */
+#define NF_DN_FORWARD           2
+/* Packets coming from a local process. */
+#define NF_DN_LOCAL_OUT         3
+/* Packets about to hit the wire. */
+#define NF_DN_POST_ROUTING      4
+/* Input Hello Packets */
+#define NF_DN_HELLO             5
+/* Input Routing Packets */
+#define NF_DN_ROUTE             6
+#define NF_DN_NUMHOOKS          7
+
+enum nf_dn_hook_priorities {
+        NF_DN_PRI_FIRST = INT_MIN,
+        NF_DN_PRI_CONNTRACK = -200,
+        NF_DN_PRI_MANGLE = -150,
+        NF_DN_PRI_NAT_DST = -100,
+        NF_DN_PRI_FILTER = 0,
+        NF_DN_PRI_NAT_SRC = 100,
+        NF_DN_PRI_DNRTMSG = 200,
+        NF_DN_PRI_LAST = INT_MAX,
+};
+
+struct nf_dn_rtmsg {
+        int nfdn_ifindex;
+};
+
+#define NFDN_RTMSG(r) ((unsigned char *)(r) + NLMSG_ALIGN(sizeof(struct nf_dn_rtmsg)))
+
+#define DNRMG_L1_GROUP 0x01
+#define DNRMG_L2_GROUP 0x02
+
+#endif /*__LINUX_DECNET_NETFILTER_H*/
diff --git a/include/linux/netfilter_ipv4.h b/include/linux/netfilter_ipv4.h
new file mode 100644
index 000000000000..c9bacf9b2431
--- /dev/null
+++ b/include/linux/netfilter_ipv4.h
@@ -0,0 +1,90 @@
+#ifndef __LINUX_IP_NETFILTER_H
+#define __LINUX_IP_NETFILTER_H
+
+/* IPv4-specific defines for netfilter. 
+ * (C)1998 Rusty Russell -- This code is GPL.
+ */
+
+#include <linux/config.h>
+#include <linux/netfilter.h>
+
+/* IP Cache bits. */
+/* Src IP address. */
+#define NFC_IP_SRC              0x0001
+/* Dest IP address. */
+#define NFC_IP_DST              0x0002
+/* Input device. */
+#define NFC_IP_IF_IN            0x0004
+/* Output device. */
+#define NFC_IP_IF_OUT           0x0008
+/* TOS. */
+#define NFC_IP_TOS              0x0010
+/* Protocol. */
+#define NFC_IP_PROTO            0x0020
+/* IP options. */
+#define NFC_IP_OPTIONS          0x0040
+/* Frag & flags. */
+#define NFC_IP_FRAG             0x0080
+
+/* Per-protocol information: only matters if proto match. */
+/* TCP flags. */
+#define NFC_IP_TCPFLAGS         0x0100
+/* Source port. */
+#define NFC_IP_SRC_PT           0x0200
+/* Dest port. */
+#define NFC_IP_DST_PT           0x0400
+/* Something else about the proto */
+#define NFC_IP_PROTO_UNKNOWN    0x2000
+
+/* IP Hooks */
+/* After promisc drops, checksum checks. */
+#define NF_IP_PRE_ROUTING       0
+/* If the packet is destined for this box. */
+#define NF_IP_LOCAL_IN          1
+/* If the packet is destined for another interface. */
+#define NF_IP_FORWARD           2
+/* Packets coming from a local process. */
+#define NF_IP_LOCAL_OUT         3
+/* Packets about to hit the wire. */
+#define NF_IP_POST_ROUTING      4
+#define NF_IP_NUMHOOKS          5
+
+enum nf_ip_hook_priorities {
+        NF_IP_PRI_FIRST = INT_MIN,
+        NF_IP_PRI_CONNTRACK_DEFRAG = -400,
+        NF_IP_PRI_RAW = -300,
+        NF_IP_PRI_SELINUX_FIRST = -225,
+        NF_IP_PRI_CONNTRACK = -200,
+        NF_IP_PRI_BRIDGE_SABOTAGE_FORWARD = -175,
+        NF_IP_PRI_MANGLE = -150,
+        NF_IP_PRI_NAT_DST = -100,
+        NF_IP_PRI_BRIDGE_SABOTAGE_LOCAL_OUT = -50,
+        NF_IP_PRI_FILTER = 0,
+        NF_IP_PRI_NAT_SRC = 100,
+        NF_IP_PRI_SELINUX_LAST = 225,
+        NF_IP_PRI_LAST = INT_MAX,
+};
+
+/* Arguments for setsockopt SOL_IP: */
+/* 2.0 firewalling went from 64 through 71 (and +256, +512, etc). */
+/* 2.2 firewalling (+ masq) went from 64 through 76 */
+/* 2.4 firewalling went 64 through 67. */
+#define SO_ORIGINAL_DST 80
+
+#ifdef __KERNEL__
+#ifdef CONFIG_NETFILTER_DEBUG
+void nf_debug_ip_local_deliver(struct sk_buff *skb);
+void nf_debug_ip_loopback_xmit(struct sk_buff *newskb);
+void nf_debug_ip_finish_output2(struct sk_buff *skb);
+#endif /*CONFIG_NETFILTER_DEBUG*/
+
+extern int ip_route_me_harder(struct sk_buff **pskb);
+
+/* Call this before modifying an existing IP packet: ensures it is
+   modifiable and linear to the point you care about (writable_len).
+   Returns true or false. */
+extern int skb_ip_make_writable(struct sk_buff **pskb,
+                                unsigned int writable_len);
+#endif /*__KERNEL__*/
+
+#endif /*__LINUX_IP_NETFILTER_H*/
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
new file mode 100644
index 000000000000..3781192ce159
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -0,0 +1,314 @@
+#ifndef _IP_CONNTRACK_H
+#define _IP_CONNTRACK_H
+/* Connection state tracking for netfilter.  This is separated from,
+   but required by, the NAT layer; it can also be used by an iptables
+   extension. */
+enum ip_conntrack_info
+{
+        /* Part of an established connection (either direction). */
+        IP_CT_ESTABLISHED,
+
+        /* Like NEW, but related to an existing connection, or ICMP error
+           (in either direction). */
+        IP_CT_RELATED,
+
+        /* Started a new connection to track (only
+           IP_CT_DIR_ORIGINAL); may be a retransmission. */
+        IP_CT_NEW,
+
+        /* >= this indicates reply direction */
+        IP_CT_IS_REPLY,
+
+        /* Number of distinct IP_CT types (no NEW in reply dirn). */
+        IP_CT_NUMBER = IP_CT_IS_REPLY * 2 - 1
+};
+
+/* Bitset representing status of connection. */
+enum ip_conntrack_status {
+        /* It's an expected connection: bit 0 set.  This bit never changed */
+        IPS_EXPECTED_BIT = 0,
+        IPS_EXPECTED = (1 << IPS_EXPECTED_BIT),
+
+        /* We've seen packets both ways: bit 1 set.  Can be set, not unset. */
+        IPS_SEEN_REPLY_BIT = 1,
+        IPS_SEEN_REPLY = (1 << IPS_SEEN_REPLY_BIT),
+
+        /* Conntrack should never be early-expired. */
+        IPS_ASSURED_BIT = 2,
+        IPS_ASSURED = (1 << IPS_ASSURED_BIT),
+
+        /* Connection is confirmed: originating packet has left box */
+        IPS_CONFIRMED_BIT = 3,
+        IPS_CONFIRMED = (1 << IPS_CONFIRMED_BIT),
+
+        /* Connection needs src nat in orig dir.  This bit never changed. */
+        IPS_SRC_NAT_BIT = 4,
+        IPS_SRC_NAT = (1 << IPS_SRC_NAT_BIT),
+
+        /* Connection needs dst nat in orig dir.  This bit never changed. */
+        IPS_DST_NAT_BIT = 5,
+        IPS_DST_NAT = (1 << IPS_DST_NAT_BIT),
+
+        /* Both together. */
+        IPS_NAT_MASK = (IPS_DST_NAT | IPS_SRC_NAT),
+
+        /* Connection needs TCP sequence adjusted. */
+        IPS_SEQ_ADJUST_BIT = 6,
+        IPS_SEQ_ADJUST = (1 << IPS_SEQ_ADJUST_BIT),
+
+        /* NAT initialization bits. */
+        IPS_SRC_NAT_DONE_BIT = 7,
+        IPS_SRC_NAT_DONE = (1 << IPS_SRC_NAT_DONE_BIT),
+
+        IPS_DST_NAT_DONE_BIT = 8,
+        IPS_DST_NAT_DONE = (1 << IPS_DST_NAT_DONE_BIT),
+
+        /* Both together */
+        IPS_NAT_DONE_MASK = (IPS_DST_NAT_DONE | IPS_SRC_NAT_DONE),
+};
+
+#ifdef __KERNEL__
+#include <linux/config.h>
+#include <linux/netfilter_ipv4/ip_conntrack_tuple.h>
+#include <linux/bitops.h>
+#include <linux/compiler.h>
+#include <asm/atomic.h>
+
+#include <linux/netfilter_ipv4/ip_conntrack_tcp.h>
+#include <linux/netfilter_ipv4/ip_conntrack_icmp.h>
+#include <linux/netfilter_ipv4/ip_conntrack_sctp.h>
+
+/* per conntrack: protocol private data */
+union ip_conntrack_proto {
+        /* insert conntrack proto private data here */
+        struct ip_ct_sctp sctp;
+        struct ip_ct_tcp tcp;
+        struct ip_ct_icmp icmp;
+};
+
+union ip_conntrack_expect_proto {
+        /* insert expect proto private data here */
+};
+
+/* Add protocol helper include file here */
+#include <linux/netfilter_ipv4/ip_conntrack_amanda.h>
+#include <linux/netfilter_ipv4/ip_conntrack_ftp.h>
+#include <linux/netfilter_ipv4/ip_conntrack_irc.h>
+
+/* per conntrack: application helper private data */
+union ip_conntrack_help {
+        /* insert conntrack helper private data (master) here */
+        struct ip_ct_ftp_master ct_ftp_info;
+        struct ip_ct_irc_master ct_irc_info;
+};
+
+#ifdef CONFIG_IP_NF_NAT_NEEDED
+#include <linux/netfilter_ipv4/ip_nat.h>
+#endif
+
+#include <linux/types.h>
+#include <linux/skbuff.h>
+
+#ifdef CONFIG_NETFILTER_DEBUG
+#define IP_NF_ASSERT(x)                                                 \
+do {                                                                    \
+        if (!(x))                                                       \
+                /* Wooah!  I'm tripping my conntrack in a frenzy of     \
+                   netplay... */                                        \
+                printk("NF_IP_ASSERT: %s:%i(%s)\n",                     \
+                       __FILE__, __LINE__, __FUNCTION__);               \
+} while(0)
+#else
+#define IP_NF_ASSERT(x)
+#endif
+
+struct ip_conntrack_counter
+{
+        u_int64_t packets;
+        u_int64_t bytes;
+};
+
+struct ip_conntrack_helper;
+
+struct ip_conntrack
+{
+        /* Usage count in here is 1 for hash table/destruct timer, 1 per skb,
+           plus 1 for any connection(s) we are `master' for */
+        struct nf_conntrack ct_general;
+
+        /* Have we seen traffic both ways yet? (bitset) */
+        unsigned long status;
+
+        /* Timer function; drops refcnt when it goes off. */
+        struct timer_list timeout;
+
+#ifdef CONFIG_IP_NF_CT_ACCT
+        /* Accounting Information (same cache line as other written members) */
+        struct ip_conntrack_counter counters[IP_CT_DIR_MAX];
+#endif
+        /* If we were expected by an expectation, this will be it */
+        struct ip_conntrack *master;
+
+        /* Current number of expected connections */
+        unsigned int expecting;
+
+        /* Helper, if any. */
+        struct ip_conntrack_helper *helper;
+
+        /* Storage reserved for other modules: */
+        union ip_conntrack_proto proto;
+
+        union ip_conntrack_help help;
+
+#ifdef CONFIG_IP_NF_NAT_NEEDED
+        struct {
+                struct ip_nat_info info;
+#if defined(CONFIG_IP_NF_TARGET_MASQUERADE) || \
+        defined(CONFIG_IP_NF_TARGET_MASQUERADE_MODULE)
+                int masq_index;
+#endif
+        } nat;
+#endif /* CONFIG_IP_NF_NAT_NEEDED */
+
+#if defined(CONFIG_IP_NF_CONNTRACK_MARK)
+        unsigned long mark;
+#endif
+
+        /* Traversed often, so hopefully in different cacheline to top */
+        /* These are my tuples; original and reply */
+        struct ip_conntrack_tuple_hash tuplehash[IP_CT_DIR_MAX];
+};
+
+struct ip_conntrack_expect
+{
+        /* Internal linked list (global expectation list) */
+        struct list_head list;
+
+        /* We expect this tuple, with the following mask */
+        struct ip_conntrack_tuple tuple, mask;
+ 
+        /* Function to call after setup and insertion */
+        void (*expectfn)(struct ip_conntrack *new,
+                         struct ip_conntrack_expect *this);
+
+        /* The conntrack of the master connection */
+        struct ip_conntrack *master;
+
+        /* Timer function; deletes the expectation. */
+        struct timer_list timeout;
+
+#ifdef CONFIG_IP_NF_NAT_NEEDED
+        /* This is the original per-proto part, used to map the
+         * expected connection the way the recipient expects. */
+        union ip_conntrack_manip_proto saved_proto;
+        /* Direction relative to the master connection. */
+        enum ip_conntrack_dir dir;
+#endif
+};
+
+static inline struct ip_conntrack *
+tuplehash_to_ctrack(const struct ip_conntrack_tuple_hash *hash)
+{
+        return container_of(hash, struct ip_conntrack,
+                            tuplehash[hash->tuple.dst.dir]);
+}
+
+/* get master conntrack via master expectation */
+#define master_ct(conntr) (conntr->master)
+
+/* Alter reply tuple (maybe alter helper). */
+extern void
+ip_conntrack_alter_reply(struct ip_conntrack *conntrack,
+                         const struct ip_conntrack_tuple *newreply);
+
+/* Is this tuple taken? (ignoring any belonging to the given
+   conntrack). */
+extern int
+ip_conntrack_tuple_taken(const struct ip_conntrack_tuple *tuple,
+                         const struct ip_conntrack *ignored_conntrack);
+
+/* Return conntrack_info and tuple hash for given skb. */
+static inline struct ip_conntrack *
+ip_conntrack_get(const struct sk_buff *skb, enum ip_conntrack_info *ctinfo)
+{
+        *ctinfo = skb->nfctinfo;
+        return (struct ip_conntrack *)skb->nfct;
+}
+
+/* decrement reference count on a conntrack */
+extern inline void ip_conntrack_put(struct ip_conntrack *ct);
+
+/* call to create an explicit dependency on ip_conntrack. */
+extern void need_ip_conntrack(void);
+
+extern int invert_tuplepr(struct ip_conntrack_tuple *inverse,
+                          const struct ip_conntrack_tuple *orig);
+
+/* Refresh conntrack for this many jiffies */
+extern void ip_ct_refresh_acct(struct ip_conntrack *ct,
+                               enum ip_conntrack_info ctinfo,
+                               const struct sk_buff *skb,
+                               unsigned long extra_jiffies);
+
+/* These are for NAT.  Icky. */
+/* Update TCP window tracking data when NAT mangles the packet */
+extern void ip_conntrack_tcp_update(struct sk_buff *skb,
+                                    struct ip_conntrack *conntrack,
+                                    enum ip_conntrack_dir dir);
+
+/* Call me when a conntrack is destroyed. */
+extern void (*ip_conntrack_destroyed)(struct ip_conntrack *conntrack);
+
+/* Fake conntrack entry for untracked connections */
+extern struct ip_conntrack ip_conntrack_untracked;
+
+/* Returns new sk_buff, or NULL */
+struct sk_buff *
+ip_ct_gather_frags(struct sk_buff *skb, u_int32_t user);
+
+/* Iterate over all conntracks: if iter returns true, it's deleted. */
+extern void
+ip_ct_iterate_cleanup(int (*iter)(struct ip_conntrack *i, void *data),
+                      void *data);
+
+/* It's confirmed if it is, or has been in the hash table. */
+static inline int is_confirmed(struct ip_conntrack *ct)
+{
+        return test_bit(IPS_CONFIRMED_BIT, &ct->status);
+}
+
+extern unsigned int ip_conntrack_htable_size;
+ 
+struct ip_conntrack_stat
+{
+        unsigned int searched;
+        unsigned int found;
+        unsigned int new;
+        unsigned int invalid;
+        unsigned int ignore;
+        unsigned int delete;
+        unsigned int delete_list;
+        unsigned int insert;
+        unsigned int insert_failed;
+        unsigned int drop;
+        unsigned int early_drop;
+        unsigned int error;
+        unsigned int expect_new;
+        unsigned int expect_create;
+        unsigned int expect_delete;
+};
+
+#define CONNTRACK_STAT_INC(count) (__get_cpu_var(ip_conntrack_stat).count++)
+
+#ifdef CONFIG_IP_NF_NAT_NEEDED
+static inline int ip_nat_initialized(struct ip_conntrack *conntrack,
+                                     enum ip_nat_manip_type manip)
+{
+        if (manip == IP_NAT_MANIP_SRC)
+                return test_bit(IPS_SRC_NAT_DONE_BIT, &conntrack->status);
+        return test_bit(IPS_DST_NAT_DONE_BIT, &conntrack->status);
+}
+#endif /* CONFIG_IP_NF_NAT_NEEDED */
+
+#endif /* __KERNEL__ */
+#endif /* _IP_CONNTRACK_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_amanda.h b/include/linux/netfilter_ipv4/ip_conntrack_amanda.h
new file mode 100644
index 000000000000..de3e41f51aec
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_amanda.h
@@ -0,0 +1,11 @@
+#ifndef _IP_CONNTRACK_AMANDA_H
+#define _IP_CONNTRACK_AMANDA_H
+/* AMANDA tracking. */
+
+struct ip_conntrack_expect;
+extern unsigned int (*ip_nat_amanda_hook)(struct sk_buff **pskb,
+                                          enum ip_conntrack_info ctinfo,
+                                          unsigned int matchoff,
+                                          unsigned int matchlen,
+                                          struct ip_conntrack_expect *exp);
+#endif /* _IP_CONNTRACK_AMANDA_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_core.h b/include/linux/netfilter_ipv4/ip_conntrack_core.h
new file mode 100644
index 000000000000..d84be02cb4fc
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_core.h
@@ -0,0 +1,52 @@
+#ifndef _IP_CONNTRACK_CORE_H
+#define _IP_CONNTRACK_CORE_H
+#include <linux/netfilter.h>
+#include <linux/netfilter_ipv4/lockhelp.h>
+
+/* This header is used to share core functionality between the
+   standalone connection tracking module, and the compatibility layer's use
+   of connection tracking. */
+extern unsigned int ip_conntrack_in(unsigned int hooknum,
+                                    struct sk_buff **pskb,
+                                    const struct net_device *in,
+                                    const struct net_device *out,
+                                    int (*okfn)(struct sk_buff *));
+
+extern int ip_conntrack_init(void);
+extern void ip_conntrack_cleanup(void);
+
+struct ip_conntrack_protocol;
+
+extern int
+ip_ct_get_tuple(const struct iphdr *iph,
+                const struct sk_buff *skb,
+                unsigned int dataoff,
+                struct ip_conntrack_tuple *tuple,
+                const struct ip_conntrack_protocol *protocol);
+
+extern int
+ip_ct_invert_tuple(struct ip_conntrack_tuple *inverse,
+                   const struct ip_conntrack_tuple *orig,
+                   const struct ip_conntrack_protocol *protocol);
+
+/* Find a connection corresponding to a tuple. */
+struct ip_conntrack_tuple_hash *
+ip_conntrack_find_get(const struct ip_conntrack_tuple *tuple,
+                      const struct ip_conntrack *ignored_conntrack);
+
+extern int __ip_conntrack_confirm(struct sk_buff **pskb);
+
+/* Confirm a connection: returns NF_DROP if packet must be dropped. */
+static inline int ip_conntrack_confirm(struct sk_buff **pskb)
+{
+        if ((*pskb)->nfct
+            && !is_confirmed((struct ip_conntrack *)(*pskb)->nfct))
+                return __ip_conntrack_confirm(pskb);
+        return NF_ACCEPT;
+}
+
+extern struct list_head *ip_conntrack_hash;
+extern struct list_head ip_conntrack_expect_list;
+DECLARE_RWLOCK_EXTERN(ip_conntrack_lock);
+#endif /* _IP_CONNTRACK_CORE_H */
+
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_ftp.h b/include/linux/netfilter_ipv4/ip_conntrack_ftp.h
new file mode 100644
index 000000000000..5f06429b9047
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_ftp.h
@@ -0,0 +1,43 @@
+#ifndef _IP_CONNTRACK_FTP_H
+#define _IP_CONNTRACK_FTP_H
+/* FTP tracking. */
+
+#ifdef __KERNEL__
+
+#define FTP_PORT        21
+
+#endif /* __KERNEL__ */
+
+enum ip_ct_ftp_type
+{
+        /* PORT command from client */
+        IP_CT_FTP_PORT,
+        /* PASV response from server */
+        IP_CT_FTP_PASV,
+        /* EPRT command from client */
+        IP_CT_FTP_EPRT,
+        /* EPSV response from server */
+        IP_CT_FTP_EPSV,
+};
+
+#define NUM_SEQ_TO_REMEMBER 2
+/* This structure exists only once per master */
+struct ip_ct_ftp_master {
+        /* Valid seq positions for cmd matching after newline */
+        u_int32_t seq_aft_nl[IP_CT_DIR_MAX][NUM_SEQ_TO_REMEMBER];
+        /* 0 means seq_match_aft_nl not set */
+        int seq_aft_nl_num[IP_CT_DIR_MAX];
+};
+
+struct ip_conntrack_expect;
+
+/* For NAT to hook in when we find a packet which describes what other
+ * connection we should expect. */
+extern unsigned int (*ip_nat_ftp_hook)(struct sk_buff **pskb,
+                                       enum ip_conntrack_info ctinfo,
+                                       enum ip_ct_ftp_type type,
+                                       unsigned int matchoff,
+                                       unsigned int matchlen,
+                                       struct ip_conntrack_expect *exp,
+                                       u32 *seq);
+#endif /* _IP_CONNTRACK_FTP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_helper.h b/include/linux/netfilter_ipv4/ip_conntrack_helper.h
new file mode 100644
index 000000000000..b1bbba0a12cb
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_helper.h
@@ -0,0 +1,41 @@
+/* IP connection tracking helpers. */
+#ifndef _IP_CONNTRACK_HELPER_H
+#define _IP_CONNTRACK_HELPER_H
+#include <linux/netfilter_ipv4/ip_conntrack.h>
+
+struct module;
+
+struct ip_conntrack_helper
+{       
+        struct list_head list;          /* Internal use. */
+
+        const char *name;               /* name of the module */
+        struct module *me;              /* pointer to self */
+        unsigned int max_expected;      /* Maximum number of concurrent 
+                                         * expected connections */
+        unsigned int timeout;           /* timeout for expecteds */
+
+        /* Mask of things we will help (compared against server response) */
+        struct ip_conntrack_tuple tuple;
+        struct ip_conntrack_tuple mask;
+        
+        /* Function to call when data passes; return verdict, or -1 to
+           invalidate. */
+        int (*help)(struct sk_buff **pskb,
+                    struct ip_conntrack *ct,
+                    enum ip_conntrack_info conntrackinfo);
+};
+
+extern int ip_conntrack_helper_register(struct ip_conntrack_helper *);
+extern void ip_conntrack_helper_unregister(struct ip_conntrack_helper *);
+
+/* Allocate space for an expectation: this is mandatory before calling 
+   ip_conntrack_expect_related. */
+extern struct ip_conntrack_expect *ip_conntrack_expect_alloc(void);
+extern void ip_conntrack_expect_free(struct ip_conntrack_expect *exp);
+
+/* Add an expected connection: can have more than one per connection */
+extern int ip_conntrack_expect_related(struct ip_conntrack_expect *exp);
+extern void ip_conntrack_unexpect_related(struct ip_conntrack_expect *exp);
+
+#endif /*_IP_CONNTRACK_HELPER_H*/
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_icmp.h b/include/linux/netfilter_ipv4/ip_conntrack_icmp.h
new file mode 100644
index 000000000000..f1664abbe392
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_icmp.h
@@ -0,0 +1,11 @@
+#ifndef _IP_CONNTRACK_ICMP_H
+#define _IP_CONNTRACK_ICMP_H
+/* ICMP tracking. */
+#include <asm/atomic.h>
+
+struct ip_ct_icmp
+{
+        /* Optimization: when number in == number out, forget immediately. */
+        atomic_t count;
+};
+#endif /* _IP_CONNTRACK_ICMP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_irc.h b/include/linux/netfilter_ipv4/ip_conntrack_irc.h
new file mode 100644
index 000000000000..16601e0d5626
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_irc.h
@@ -0,0 +1,32 @@
+/* IRC extension for IP connection tracking.
+ * (C) 2000 by Harald Welte <laforge@gnumonks.org>
+ * based on RR's ip_conntrack_ftp.h
+ *
+ * ip_conntrack_irc.h,v 1.6 2000/11/07 18:26:42 laforge Exp
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ *
+ *
+ */
+#ifndef _IP_CONNTRACK_IRC_H
+#define _IP_CONNTRACK_IRC_H
+
+/* This structure exists only once per master */
+struct ip_ct_irc_master {
+};
+
+#ifdef __KERNEL__
+extern unsigned int (*ip_nat_irc_hook)(struct sk_buff **pskb,
+                                       enum ip_conntrack_info ctinfo,
+                                       unsigned int matchoff,
+                                       unsigned int matchlen,
+                                       struct ip_conntrack_expect *exp);
+
+#define IRC_PORT        6667
+
+#endif /* __KERNEL__ */
+
+#endif /* _IP_CONNTRACK_IRC_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_protocol.h b/include/linux/netfilter_ipv4/ip_conntrack_protocol.h
new file mode 100644
index 000000000000..e20b57c5e1b7
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_protocol.h
@@ -0,0 +1,89 @@
+/* Header for use in defining a given protocol for connection tracking. */
+#ifndef _IP_CONNTRACK_PROTOCOL_H
+#define _IP_CONNTRACK_PROTOCOL_H
+#include <linux/netfilter_ipv4/ip_conntrack.h>
+
+struct seq_file;
+
+struct ip_conntrack_protocol
+{
+        /* Protocol number. */
+        u_int8_t proto;
+
+        /* Protocol name */
+        const char *name;
+
+        /* Try to fill in the third arg: dataoff is offset past IP
+           hdr.  Return true if possible. */
+        int (*pkt_to_tuple)(const struct sk_buff *skb,
+                           unsigned int dataoff,
+                           struct ip_conntrack_tuple *tuple);
+
+        /* Invert the per-proto part of the tuple: ie. turn xmit into reply.
+         * Some packets can't be inverted: return 0 in that case.
+         */
+        int (*invert_tuple)(struct ip_conntrack_tuple *inverse,
+                            const struct ip_conntrack_tuple *orig);
+
+        /* Print out the per-protocol part of the tuple. Return like seq_* */
+        int (*print_tuple)(struct seq_file *,
+                           const struct ip_conntrack_tuple *);
+
+        /* Print out the private part of the conntrack. */
+        int (*print_conntrack)(struct seq_file *, const struct ip_conntrack *);
+
+        /* Returns verdict for packet, or -1 for invalid. */
+        int (*packet)(struct ip_conntrack *conntrack,
+                      const struct sk_buff *skb,
+                      enum ip_conntrack_info ctinfo);
+
+        /* Called when a new connection for this protocol found;
+         * returns TRUE if it's OK.  If so, packet() called next. */
+        int (*new)(struct ip_conntrack *conntrack, const struct sk_buff *skb);
+
+        /* Called when a conntrack entry is destroyed */
+        void (*destroy)(struct ip_conntrack *conntrack);
+
+        int (*error)(struct sk_buff *skb, enum ip_conntrack_info *ctinfo,
+                     unsigned int hooknum);
+
+        /* Module (if any) which this is connected to. */
+        struct module *me;
+};
+
+#define MAX_IP_CT_PROTO 256
+extern struct ip_conntrack_protocol *ip_ct_protos[MAX_IP_CT_PROTO];
+
+/* Protocol registration. */
+extern int ip_conntrack_protocol_register(struct ip_conntrack_protocol *proto);
+extern void ip_conntrack_protocol_unregister(struct ip_conntrack_protocol *proto);
+
+static inline struct ip_conntrack_protocol *ip_ct_find_proto(u_int8_t protocol)
+{
+        return ip_ct_protos[protocol];
+}
+
+/* Existing built-in protocols */
+extern struct ip_conntrack_protocol ip_conntrack_protocol_tcp;
+extern struct ip_conntrack_protocol ip_conntrack_protocol_udp;
+extern struct ip_conntrack_protocol ip_conntrack_protocol_icmp;
+extern struct ip_conntrack_protocol ip_conntrack_generic_protocol;
+extern int ip_conntrack_protocol_tcp_init(void);
+
+/* Log invalid packets */
+extern unsigned int ip_ct_log_invalid;
+
+#ifdef CONFIG_SYSCTL
+#ifdef DEBUG_INVALID_PACKETS
+#define LOG_INVALID(proto) \
+        (ip_ct_log_invalid == (proto) || ip_ct_log_invalid == IPPROTO_RAW)
+#else
+#define LOG_INVALID(proto) \
+        ((ip_ct_log_invalid == (proto) || ip_ct_log_invalid == IPPROTO_RAW) \
+         && net_ratelimit())
+#endif
+#else
+#define LOG_INVALID(proto) 0
+#endif /* CONFIG_SYSCTL */
+
+#endif /*_IP_CONNTRACK_PROTOCOL_H*/
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_sctp.h b/include/linux/netfilter_ipv4/ip_conntrack_sctp.h
new file mode 100644
index 000000000000..7a8d869321f7
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_sctp.h
@@ -0,0 +1,25 @@
+#ifndef _IP_CONNTRACK_SCTP_H
+#define _IP_CONNTRACK_SCTP_H
+/* SCTP tracking. */
+
+enum sctp_conntrack {
+        SCTP_CONNTRACK_NONE,
+        SCTP_CONNTRACK_CLOSED,
+        SCTP_CONNTRACK_COOKIE_WAIT,
+        SCTP_CONNTRACK_COOKIE_ECHOED,
+        SCTP_CONNTRACK_ESTABLISHED,
+        SCTP_CONNTRACK_SHUTDOWN_SENT,
+        SCTP_CONNTRACK_SHUTDOWN_RECD,
+        SCTP_CONNTRACK_SHUTDOWN_ACK_SENT,
+        SCTP_CONNTRACK_MAX
+};
+
+struct ip_ct_sctp
+{
+        enum sctp_conntrack state;
+
+        u_int32_t vtag[IP_CT_DIR_MAX];
+        u_int32_t ttag[IP_CT_DIR_MAX];
+};
+
+#endif /* _IP_CONNTRACK_SCTP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tcp.h b/include/linux/netfilter_ipv4/ip_conntrack_tcp.h
new file mode 100644
index 000000000000..16da044d97a7
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tcp.h
@@ -0,0 +1,51 @@
+#ifndef _IP_CONNTRACK_TCP_H
+#define _IP_CONNTRACK_TCP_H
+/* TCP tracking. */
+
+enum tcp_conntrack {
+        TCP_CONNTRACK_NONE,
+        TCP_CONNTRACK_SYN_SENT,
+        TCP_CONNTRACK_SYN_RECV,
+        TCP_CONNTRACK_ESTABLISHED,
+        TCP_CONNTRACK_FIN_WAIT,
+        TCP_CONNTRACK_CLOSE_WAIT,
+        TCP_CONNTRACK_LAST_ACK,
+        TCP_CONNTRACK_TIME_WAIT,
+        TCP_CONNTRACK_CLOSE,
+        TCP_CONNTRACK_LISTEN,
+        TCP_CONNTRACK_MAX,
+        TCP_CONNTRACK_IGNORE
+};
+
+/* Window scaling is advertised by the sender */
+#define IP_CT_TCP_FLAG_WINDOW_SCALE             0x01
+
+/* SACK is permitted by the sender */
+#define IP_CT_TCP_FLAG_SACK_PERM                0x02
+
+/* This sender sent FIN first */
+#define IP_CT_TCP_FLAG_CLOSE_INIT               0x03
+
+struct ip_ct_tcp_state {
+        u_int32_t       td_end;         /* max of seq + len */
+        u_int32_t       td_maxend;      /* max of ack + max(win, 1) */
+        u_int32_t       td_maxwin;      /* max(win) */
+        u_int8_t        td_scale;       /* window scale factor */
+        u_int8_t        loose;          /* used when connection picked up from the middle */
+        u_int8_t        flags;          /* per direction options */
+};
+
+struct ip_ct_tcp
+{
+        struct ip_ct_tcp_state seen[2]; /* connection parameters per direction */
+        u_int8_t        state;          /* state of the connection (enum tcp_conntrack) */
+        /* For detecting stale connections */
+        u_int8_t        last_dir;       /* Direction of the last packet (enum ip_conntrack_dir) */
+        u_int8_t        retrans;        /* Number of retransmitted packets */
+        u_int8_t        last_index;     /* Index of the last packet */
+        u_int32_t       last_seq;       /* Last sequence number seen in dir */
+        u_int32_t       last_ack;       /* Last sequence number seen in opposite dir */
+        u_int32_t       last_end;       /* Last seq + len */
+};
+
+#endif /* _IP_CONNTRACK_TCP_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tftp.h b/include/linux/netfilter_ipv4/ip_conntrack_tftp.h
new file mode 100644
index 000000000000..cde9729aa173
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tftp.h
@@ -0,0 +1,20 @@
+#ifndef _IP_CT_TFTP
+#define _IP_CT_TFTP
+
+#define TFTP_PORT 69
+
+struct tftphdr {
+        u_int16_t opcode;
+};
+
+#define TFTP_OPCODE_READ        1
+#define TFTP_OPCODE_WRITE       2
+#define TFTP_OPCODE_DATA        3
+#define TFTP_OPCODE_ACK         4
+#define TFTP_OPCODE_ERROR       5
+
+extern unsigned int (*ip_nat_tftp_hook)(struct sk_buff **pskb,
+                                 enum ip_conntrack_info ctinfo,
+                                 struct ip_conntrack_expect *exp);
+
+#endif /* _IP_CT_TFTP */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_tuple.h b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
new file mode 100644
index 000000000000..c33f0b5e0d0a
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_conntrack_tuple.h
@@ -0,0 +1,145 @@
+#ifndef _IP_CONNTRACK_TUPLE_H
+#define _IP_CONNTRACK_TUPLE_H
+
+/* A `tuple' is a structure containing the information to uniquely
+  identify a connection.  ie. if two packets have the same tuple, they
+  are in the same connection; if not, they are not.
+
+  We divide the structure along "manipulatable" and
+  "non-manipulatable" lines, for the benefit of the NAT code.
+*/
+
+/* The protocol-specific manipulable parts of the tuple: always in
+   network order! */
+union ip_conntrack_manip_proto
+{
+        /* Add other protocols here. */
+        u_int16_t all;
+
+        struct {
+                u_int16_t port;
+        } tcp;
+        struct {
+                u_int16_t port;
+        } udp;
+        struct {
+                u_int16_t id;
+        } icmp;
+        struct {
+                u_int16_t port;
+        } sctp;
+};
+
+/* The manipulable part of the tuple. */
+struct ip_conntrack_manip
+{
+        u_int32_t ip;
+        union ip_conntrack_manip_proto u;
+};
+
+/* This contains the information to distinguish a connection. */
+struct ip_conntrack_tuple
+{
+        struct ip_conntrack_manip src;
+
+        /* These are the parts of the tuple which are fixed. */
+        struct {
+                u_int32_t ip;
+                union {
+                        /* Add other protocols here. */
+                        u_int16_t all;
+
+                        struct {
+                                u_int16_t port;
+                        } tcp;
+                        struct {
+                                u_int16_t port;
+                        } udp;
+                        struct {
+                                u_int8_t type, code;
+                        } icmp;
+                        struct {
+                                u_int16_t port;
+                        } sctp;
+                } u;
+
+                /* The protocol. */
+                u_int8_t protonum;
+
+                /* The direction (for tuplehash) */
+                u_int8_t dir;
+        } dst;
+};
+
+/* This is optimized opposed to a memset of the whole structure.  Everything we
+ * really care about is the  source/destination unions */
+#define IP_CT_TUPLE_U_BLANK(tuple)                              \
+        do {                                                    \
+                (tuple)->src.u.all = 0;                         \
+                (tuple)->dst.u.all = 0;                         \
+        } while (0)
+
+enum ip_conntrack_dir
+{
+        IP_CT_DIR_ORIGINAL,
+        IP_CT_DIR_REPLY,
+        IP_CT_DIR_MAX
+};
+
+#ifdef __KERNEL__
+
+#define DUMP_TUPLE(tp)                                          \
+DEBUGP("tuple %p: %u %u.%u.%u.%u:%hu -> %u.%u.%u.%u:%hu\n",     \
+       (tp), (tp)->dst.protonum,                                \
+       NIPQUAD((tp)->src.ip), ntohs((tp)->src.u.all),           \
+       NIPQUAD((tp)->dst.ip), ntohs((tp)->dst.u.all))
+
+#define CTINFO2DIR(ctinfo) ((ctinfo) >= IP_CT_IS_REPLY ? IP_CT_DIR_REPLY : IP_CT_DIR_ORIGINAL)
+
+/* If we're the first tuple, it's the original dir. */
+#define DIRECTION(h) ((enum ip_conntrack_dir)(h)->tuple.dst.dir)
+
+/* Connections have two entries in the hash table: one for each way */
+struct ip_conntrack_tuple_hash
+{
+        struct list_head list;
+
+        struct ip_conntrack_tuple tuple;
+};
+
+#endif /* __KERNEL__ */
+
+static inline int ip_ct_tuple_src_equal(const struct ip_conntrack_tuple *t1,
+                                        const struct ip_conntrack_tuple *t2)
+{
+        return t1->src.ip == t2->src.ip
+                && t1->src.u.all == t2->src.u.all;
+}
+
+static inline int ip_ct_tuple_dst_equal(const struct ip_conntrack_tuple *t1,
+                                        const struct ip_conntrack_tuple *t2)
+{
+        return t1->dst.ip == t2->dst.ip
+                && t1->dst.u.all == t2->dst.u.all
+                && t1->dst.protonum == t2->dst.protonum;
+}
+
+static inline int ip_ct_tuple_equal(const struct ip_conntrack_tuple *t1,
+                                    const struct ip_conntrack_tuple *t2)
+{
+        return ip_ct_tuple_src_equal(t1, t2) && ip_ct_tuple_dst_equal(t1, t2);
+}
+
+static inline int ip_ct_tuple_mask_cmp(const struct ip_conntrack_tuple *t,
+                                       const struct ip_conntrack_tuple *tuple,
+                                       const struct ip_conntrack_tuple *mask)
+{
+        return !(((t->src.ip ^ tuple->src.ip) & mask->src.ip)
+                 || ((t->dst.ip ^ tuple->dst.ip) & mask->dst.ip)
+                 || ((t->src.u.all ^ tuple->src.u.all) & mask->src.u.all)
+                 || ((t->dst.u.all ^ tuple->dst.u.all) & mask->dst.u.all)
+                 || ((t->dst.protonum ^ tuple->dst.protonum)
+                     & mask->dst.protonum));
+}
+
+#endif /* _IP_CONNTRACK_TUPLE_H */
diff --git a/include/linux/netfilter_ipv4/ip_logging.h b/include/linux/netfilter_ipv4/ip_logging.h
new file mode 100644
index 000000000000..0c5c52cb6589
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_logging.h
@@ -0,0 +1,20 @@
+/* IPv4 macros for the internal logging interface. */
+#ifndef __IP_LOGGING_H
+#define __IP_LOGGING_H
+
+#ifdef __KERNEL__
+#include <linux/socket.h>
+#include <linux/netfilter_logging.h>
+
+#define nf_log_ip_packet(pskb,hooknum,in,out,fmt,args...) \
+        nf_log_packet(AF_INET,pskb,hooknum,in,out,fmt,##args)
+
+#define nf_log_ip(pfh,len,fmt,args...) \
+        nf_log(AF_INET,pfh,len,fmt,##args)
+
+#define nf_ip_log_register(logging) nf_log_register(AF_INET,logging)
+#define nf_ip_log_unregister(logging) nf_log_unregister(AF_INET,logging)
+        
+#endif /*__KERNEL__*/
+
+#endif /*__IP_LOGGING_H*/
diff --git a/include/linux/netfilter_ipv4/ip_nat.h b/include/linux/netfilter_ipv4/ip_nat.h
new file mode 100644
index 000000000000..2b72b86176f0
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_nat.h
@@ -0,0 +1,87 @@
+#ifndef _IP_NAT_H
+#define _IP_NAT_H
+#include <linux/netfilter_ipv4.h>
+#include <linux/netfilter_ipv4/ip_conntrack_tuple.h>
+
+#define IP_NAT_MAPPING_TYPE_MAX_NAMELEN 16
+
+enum ip_nat_manip_type
+{
+        IP_NAT_MANIP_SRC,
+        IP_NAT_MANIP_DST
+};
+
+/* SRC manip occurs POST_ROUTING or LOCAL_IN */
+#define HOOK2MANIP(hooknum) ((hooknum) != NF_IP_POST_ROUTING && (hooknum) != NF_IP_LOCAL_IN)
+
+#define IP_NAT_RANGE_MAP_IPS 1
+#define IP_NAT_RANGE_PROTO_SPECIFIED 2
+
+/* NAT sequence number modifications */
+struct ip_nat_seq {
+        /* position of the last TCP sequence number 
+         * modification (if any) */
+        u_int32_t correction_pos;
+        /* sequence number offset before and after last modification */
+        int32_t offset_before, offset_after;
+};
+
+/* Single range specification. */
+struct ip_nat_range
+{
+        /* Set to OR of flags above. */
+        unsigned int flags;
+
+        /* Inclusive: network order. */
+        u_int32_t min_ip, max_ip;
+
+        /* Inclusive: network order */
+        union ip_conntrack_manip_proto min, max;
+};
+
+/* For backwards compat: don't use in modern code. */
+struct ip_nat_multi_range_compat
+{
+        unsigned int rangesize; /* Must be 1. */
+
+        /* hangs off end. */
+        struct ip_nat_range range[1];
+};
+
+#ifdef __KERNEL__
+#include <linux/list.h>
+#include <linux/netfilter_ipv4/lockhelp.h>
+
+/* Protects NAT hash tables, and NAT-private part of conntracks. */
+DECLARE_RWLOCK_EXTERN(ip_nat_lock);
+
+/* The structure embedded in the conntrack structure. */
+struct ip_nat_info
+{
+        struct list_head bysource;
+
+        /* Helper (NULL if none). */
+        struct ip_nat_helper *helper;
+
+        struct ip_nat_seq seq[IP_CT_DIR_MAX];
+};
+
+struct ip_conntrack;
+
+/* Set up the info structure to map into this range. */
+extern unsigned int ip_nat_setup_info(struct ip_conntrack *conntrack,
+                                      const struct ip_nat_range *range,
+                                      unsigned int hooknum);
+
+/* Is this tuple already taken? (not by us)*/
+extern int ip_nat_used_tuple(const struct ip_conntrack_tuple *tuple,
+                             const struct ip_conntrack *ignored_conntrack);
+
+/* Calculate relative checksum. */
+extern u_int16_t ip_nat_cheat_check(u_int32_t oldvalinv,
+                                    u_int32_t newval,
+                                    u_int16_t oldcheck);
+#else  /* !__KERNEL__: iptables wants this to compile. */
+#define ip_nat_multi_range ip_nat_multi_range_compat
+#endif /*__KERNEL__*/
+#endif
diff --git a/include/linux/netfilter_ipv4/ip_nat_core.h b/include/linux/netfilter_ipv4/ip_nat_core.h
new file mode 100644
index 000000000000..3b50eb91f007
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_nat_core.h
@@ -0,0 +1,20 @@
+#ifndef _IP_NAT_CORE_H
+#define _IP_NAT_CORE_H
+#include <linux/list.h>
+#include <linux/netfilter_ipv4/ip_conntrack.h>
+
+/* This header used to share core functionality between the standalone
+   NAT module, and the compatibility layer's use of NAT for masquerading. */
+extern int ip_nat_init(void);
+extern void ip_nat_cleanup(void);
+
+extern unsigned int nat_packet(struct ip_conntrack *ct,
+                               enum ip_conntrack_info conntrackinfo,
+                               unsigned int hooknum,
+                               struct sk_buff **pskb);
+
+extern int icmp_reply_translation(struct sk_buff **pskb,
+                                  struct ip_conntrack *ct,
+                                  enum ip_nat_manip_type manip,
+                                  enum ip_conntrack_dir dir);
+#endif /* _IP_NAT_CORE_H */
diff --git a/include/linux/netfilter_ipv4/ip_nat_helper.h b/include/linux/netfilter_ipv4/ip_nat_helper.h
new file mode 100644
index 000000000000..bf9cb105c885
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_nat_helper.h
@@ -0,0 +1,33 @@
+#ifndef _IP_NAT_HELPER_H
+#define _IP_NAT_HELPER_H
+/* NAT protocol helper routines. */
+
+#include <linux/netfilter_ipv4/ip_conntrack.h>
+#include <linux/module.h>
+
+struct sk_buff;
+
+/* These return true or false. */
+extern int ip_nat_mangle_tcp_packet(struct sk_buff **skb,
+                                struct ip_conntrack *ct,
+                                enum ip_conntrack_info ctinfo,
+                                unsigned int match_offset,
+                                unsigned int match_len,
+                                const char *rep_buffer,
+                                unsigned int rep_len);
+extern int ip_nat_mangle_udp_packet(struct sk_buff **skb,
+                                struct ip_conntrack *ct,
+                                enum ip_conntrack_info ctinfo,
+                                unsigned int match_offset,
+                                unsigned int match_len,
+                                const char *rep_buffer,
+                                unsigned int rep_len);
+extern int ip_nat_seq_adjust(struct sk_buff **pskb, 
+                             struct ip_conntrack *ct, 
+                             enum ip_conntrack_info ctinfo);
+
+/* Setup NAT on this expected conntrack so it follows master, but goes
+ * to port ct->master->saved_proto. */
+extern void ip_nat_follow_master(struct ip_conntrack *ct,
+                                 struct ip_conntrack_expect *this);
+#endif
diff --git a/include/linux/netfilter_ipv4/ip_nat_protocol.h b/include/linux/netfilter_ipv4/ip_nat_protocol.h
new file mode 100644
index 000000000000..129708c22386
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_nat_protocol.h
@@ -0,0 +1,70 @@
+/* Header for use in defining a given protocol. */
+#ifndef _IP_NAT_PROTOCOL_H
+#define _IP_NAT_PROTOCOL_H
+#include <linux/init.h>
+#include <linux/list.h>
+
+struct iphdr;
+struct ip_nat_range;
+
+struct ip_nat_protocol
+{
+        /* Protocol name */
+        const char *name;
+
+        /* Protocol number. */
+        unsigned int protonum;
+
+        /* Translate a packet to the target according to manip type.
+           Return true if succeeded. */
+        int (*manip_pkt)(struct sk_buff **pskb,
+                         unsigned int iphdroff,
+                         const struct ip_conntrack_tuple *tuple,
+                         enum ip_nat_manip_type maniptype);
+
+        /* Is the manipable part of the tuple between min and max incl? */
+        int (*in_range)(const struct ip_conntrack_tuple *tuple,
+                        enum ip_nat_manip_type maniptype,
+                        const union ip_conntrack_manip_proto *min,
+                        const union ip_conntrack_manip_proto *max);
+
+        /* Alter the per-proto part of the tuple (depending on
+           maniptype), to give a unique tuple in the given range if
+           possible; return false if not.  Per-protocol part of tuple
+           is initialized to the incoming packet. */
+        int (*unique_tuple)(struct ip_conntrack_tuple *tuple,
+                            const struct ip_nat_range *range,
+                            enum ip_nat_manip_type maniptype,
+                            const struct ip_conntrack *conntrack);
+
+        unsigned int (*print)(char *buffer,
+                              const struct ip_conntrack_tuple *match,
+                              const struct ip_conntrack_tuple *mask);
+
+        unsigned int (*print_range)(char *buffer,
+                                    const struct ip_nat_range *range);
+};
+
+#define MAX_IP_NAT_PROTO 256
+extern struct ip_nat_protocol *ip_nat_protos[MAX_IP_NAT_PROTO];
+
+/* Protocol registration. */
+extern int ip_nat_protocol_register(struct ip_nat_protocol *proto);
+extern void ip_nat_protocol_unregister(struct ip_nat_protocol *proto);
+
+static inline struct ip_nat_protocol *ip_nat_find_proto(u_int8_t protocol)
+{
+        return ip_nat_protos[protocol];
+}
+
+/* Built-in protocols. */
+extern struct ip_nat_protocol ip_nat_protocol_tcp;
+extern struct ip_nat_protocol ip_nat_protocol_udp;
+extern struct ip_nat_protocol ip_nat_protocol_icmp;
+extern struct ip_nat_protocol ip_nat_unknown_protocol;
+
+extern int init_protocols(void) __init;
+extern void cleanup_protocols(void);
+extern struct ip_nat_protocol *find_nat_proto(u_int16_t protonum);
+
+#endif /*_IP_NAT_PROTO_H*/
diff --git a/include/linux/netfilter_ipv4/ip_nat_rule.h b/include/linux/netfilter_ipv4/ip_nat_rule.h
new file mode 100644
index 000000000000..fecd2a06dcd8
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_nat_rule.h
@@ -0,0 +1,23 @@
+#ifndef _IP_NAT_RULE_H
+#define _IP_NAT_RULE_H
+#include <linux/netfilter_ipv4/ip_conntrack.h>
+#include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/netfilter_ipv4/ip_nat.h>
+
+#ifdef __KERNEL__
+
+extern int ip_nat_rule_init(void) __init;
+extern void ip_nat_rule_cleanup(void);
+extern int ip_nat_rule_find(struct sk_buff **pskb,
+                            unsigned int hooknum,
+                            const struct net_device *in,
+                            const struct net_device *out,
+                            struct ip_conntrack *ct,
+                            struct ip_nat_info *info);
+
+extern unsigned int
+alloc_null_binding(struct ip_conntrack *conntrack,
+                   struct ip_nat_info *info,
+                   unsigned int hooknum);
+#endif
+#endif /* _IP_NAT_RULE_H */
diff --git a/include/linux/netfilter_ipv4/ip_queue.h b/include/linux/netfilter_ipv4/ip_queue.h
new file mode 100644
index 000000000000..aa08d68c4841
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_queue.h
@@ -0,0 +1,72 @@
+/*
+ * This is a module which is used for queueing IPv4 packets and
+ * communicating with userspace via netlink.
+ *
+ * (C) 2000 James Morris, this code is GPL.
+ */
+#ifndef _IP_QUEUE_H
+#define _IP_QUEUE_H
+
+#ifdef __KERNEL__
+#ifdef DEBUG_IPQ
+#define QDEBUG(x...) printk(KERN_DEBUG ## x)
+#else
+#define QDEBUG(x...)
+#endif  /* DEBUG_IPQ */
+#else
+#include <net/if.h>
+#endif  /* ! __KERNEL__ */
+
+/* Messages sent from kernel */
+typedef struct ipq_packet_msg {
+        unsigned long packet_id;        /* ID of queued packet */
+        unsigned long mark;             /* Netfilter mark value */
+        long timestamp_sec;             /* Packet arrival time (seconds) */
+        long timestamp_usec;            /* Packet arrvial time (+useconds) */
+        unsigned int hook;              /* Netfilter hook we rode in on */
+        char indev_name[IFNAMSIZ];      /* Name of incoming interface */
+        char outdev_name[IFNAMSIZ];     /* Name of outgoing interface */
+        unsigned short hw_protocol;     /* Hardware protocol (network order) */
+        unsigned short hw_type;         /* Hardware type */
+        unsigned char hw_addrlen;       /* Hardware address length */
+        unsigned char hw_addr[8];       /* Hardware address */
+        size_t data_len;                /* Length of packet data */
+        unsigned char payload[0];       /* Optional packet data */
+} ipq_packet_msg_t;
+
+/* Messages sent from userspace */
+typedef struct ipq_mode_msg {
+        unsigned char value;            /* Requested mode */
+        size_t range;                   /* Optional range of packet requested */
+} ipq_mode_msg_t;
+
+typedef struct ipq_verdict_msg {
+        unsigned int value;             /* Verdict to hand to netfilter */
+        unsigned long id;               /* Packet ID for this verdict */
+        size_t data_len;                /* Length of replacement data */
+        unsigned char payload[0];       /* Optional replacement packet */
+} ipq_verdict_msg_t;
+
+typedef struct ipq_peer_msg {
+        union {
+                ipq_verdict_msg_t verdict;
+                ipq_mode_msg_t mode;
+        } msg;
+} ipq_peer_msg_t;
+
+/* Packet delivery modes */
+enum {
+        IPQ_COPY_NONE,          /* Initial mode, packets are dropped */
+        IPQ_COPY_META,          /* Copy metadata */
+        IPQ_COPY_PACKET         /* Copy metadata + packet (range) */
+};
+#define IPQ_COPY_MAX IPQ_COPY_PACKET
+
+/* Types of messages */
+#define IPQM_BASE       0x10    /* standard netlink messages below this */
+#define IPQM_MODE       (IPQM_BASE + 1)         /* Mode request from peer */
+#define IPQM_VERDICT    (IPQM_BASE + 2)         /* Verdict from peer */ 
+#define IPQM_PACKET     (IPQM_BASE + 3)         /* Packet from kernel */
+#define IPQM_MAX        (IPQM_BASE + 4)
+
+#endif /*_IP_QUEUE_H*/
diff --git a/include/linux/netfilter_ipv4/ip_tables.h b/include/linux/netfilter_ipv4/ip_tables.h
new file mode 100644
index 000000000000..12ce47808e7d
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ip_tables.h
@@ -0,0 +1,490 @@
+/*
+ * 25-Jul-1998 Major changes to allow for ip chain table
+ *
+ * 3-Jan-2000 Named tables to allow packet selection for different uses.
+ */
+
+/*
+ *      Format of an IP firewall descriptor
+ *
+ *      src, dst, src_mask, dst_mask are always stored in network byte order.
+ *      flags are stored in host byte order (of course).
+ *      Port numbers are stored in HOST byte order.
+ */
+
+#ifndef _IPTABLES_H
+#define _IPTABLES_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#include <linux/types.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#endif
+#include <linux/compiler.h>
+#include <linux/netfilter_ipv4.h>
+
+#define IPT_FUNCTION_MAXNAMELEN 30
+#define IPT_TABLE_MAXNAMELEN 32
+
+/* Yes, Virginia, you have to zero the padding. */
+struct ipt_ip {
+        /* Source and destination IP addr */
+        struct in_addr src, dst;
+        /* Mask for src and dest IP addr */
+        struct in_addr smsk, dmsk;
+        char iniface[IFNAMSIZ], outiface[IFNAMSIZ];
+        unsigned char iniface_mask[IFNAMSIZ], outiface_mask[IFNAMSIZ];
+
+        /* Protocol, 0 = ANY */
+        u_int16_t proto;
+
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int8_t invflags;
+};
+
+struct ipt_entry_match
+{
+        union {
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used by userspace */
+                        char name[IPT_FUNCTION_MAXNAMELEN-1];
+
+                        u_int8_t revision;
+                } user;
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used inside the kernel */
+                        struct ipt_match *match;
+                } kernel;
+
+                /* Total length */
+                u_int16_t match_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct ipt_entry_target
+{
+        union {
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used by userspace */
+                        char name[IPT_FUNCTION_MAXNAMELEN-1];
+
+                        u_int8_t revision;
+                } user;
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used inside the kernel */
+                        struct ipt_target *target;
+                } kernel;
+
+                /* Total length */
+                u_int16_t target_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct ipt_standard_target
+{
+        struct ipt_entry_target target;
+        int verdict;
+};
+
+struct ipt_counters
+{
+        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
+};
+
+/* Values for "flag" field in struct ipt_ip (general ip structure). */
+#define IPT_F_FRAG              0x01    /* Set if rule is a fragment rule */
+#define IPT_F_MASK              0x01    /* All possible flag bits mask. */
+
+/* Values for "inv" field in struct ipt_ip. */
+#define IPT_INV_VIA_IN          0x01    /* Invert the sense of IN IFACE. */
+#define IPT_INV_VIA_OUT         0x02    /* Invert the sense of OUT IFACE */
+#define IPT_INV_TOS             0x04    /* Invert the sense of TOS. */
+#define IPT_INV_SRCIP           0x08    /* Invert the sense of SRC IP. */
+#define IPT_INV_DSTIP           0x10    /* Invert the sense of DST OP. */
+#define IPT_INV_FRAG            0x20    /* Invert the sense of FRAG. */
+#define IPT_INV_PROTO           0x40    /* Invert the sense of PROTO. */
+#define IPT_INV_MASK            0x7F    /* All possible flag bits mask. */
+
+/* This structure defines each of the firewall rules.  Consists of 3
+   parts which are 1) general IP header stuff 2) match specific
+   stuff 3) the target to perform if the rule matches */
+struct ipt_entry
+{
+        struct ipt_ip ip;
+
+        /* Mark with fields that we care about. */
+        unsigned int nfcache;
+
+        /* Size of ipt_entry + matches */
+        u_int16_t target_offset;
+        /* Size of ipt_entry + matches + target */
+        u_int16_t next_offset;
+
+        /* Back pointer */
+        unsigned int comefrom;
+
+        /* Packet and byte counters. */
+        struct ipt_counters counters;
+
+        /* The matches (if any), then the target. */
+        unsigned char elems[0];
+};
+
+/*
+ * New IP firewall options for [gs]etsockopt at the RAW IP level.
+ * Unlike BSD Linux inherits IP options so you don't have to use a raw
+ * socket for this. Instead we check rights in the calls. */
+#define IPT_BASE_CTL            64      /* base for firewall socket options */
+
+#define IPT_SO_SET_REPLACE      (IPT_BASE_CTL)
+#define IPT_SO_SET_ADD_COUNTERS (IPT_BASE_CTL + 1)
+#define IPT_SO_SET_MAX          IPT_SO_SET_ADD_COUNTERS
+
+#define IPT_SO_GET_INFO                 (IPT_BASE_CTL)
+#define IPT_SO_GET_ENTRIES              (IPT_BASE_CTL + 1)
+#define IPT_SO_GET_REVISION_MATCH       (IPT_BASE_CTL + 2)
+#define IPT_SO_GET_REVISION_TARGET      (IPT_BASE_CTL + 3)
+#define IPT_SO_GET_MAX                  IPT_SO_GET_REVISION_TARGET
+
+/* CONTINUE verdict for targets */
+#define IPT_CONTINUE 0xFFFFFFFF
+
+/* For standard target */
+#define IPT_RETURN (-NF_REPEAT - 1)
+
+/* TCP matching stuff */
+struct ipt_tcp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t option;                        /* TCP Option iff non-zero*/
+        u_int8_t flg_mask;                      /* TCP flags mask byte */
+        u_int8_t flg_cmp;                       /* TCP flags compare byte */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "inv" field in struct ipt_tcp. */
+#define IPT_TCP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
+#define IPT_TCP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
+#define IPT_TCP_INV_FLAGS       0x04    /* Invert the sense of TCP flags. */
+#define IPT_TCP_INV_OPTION      0x08    /* Invert the sense of option test. */
+#define IPT_TCP_INV_MASK        0x0F    /* All possible flags. */
+
+/* UDP matching stuff */
+struct ipt_udp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "invflags" field in struct ipt_udp. */
+#define IPT_UDP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
+#define IPT_UDP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
+#define IPT_UDP_INV_MASK        0x03    /* All possible flags. */
+
+/* ICMP matching stuff */
+struct ipt_icmp
+{
+        u_int8_t type;                          /* type to match */
+        u_int8_t code[2];                       /* range of code */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "inv" field for struct ipt_icmp. */
+#define IPT_ICMP_INV    0x01    /* Invert the sense of type/code test */
+
+/* The argument to IPT_SO_GET_INFO */
+struct ipt_getinfo
+{
+        /* Which table: caller fills this in. */
+        char name[IPT_TABLE_MAXNAMELEN];
+
+        /* Kernel fills these in. */
+        /* Which hook entry points are valid: bitmask */
+        unsigned int valid_hooks;
+
+        /* Hook entry points: one per netfilter hook. */
+        unsigned int hook_entry[NF_IP_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_IP_NUMHOOKS];
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Size of entries. */
+        unsigned int size;
+};
+
+/* The argument to IPT_SO_SET_REPLACE. */
+struct ipt_replace
+{
+        /* Which table. */
+        char name[IPT_TABLE_MAXNAMELEN];
+
+        /* Which hook entry points are valid: bitmask.  You can't
+           change this. */
+        unsigned int valid_hooks;
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Total size of new entries */
+        unsigned int size;
+
+        /* Hook entry points. */
+        unsigned int hook_entry[NF_IP_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_IP_NUMHOOKS];
+
+        /* Information about old entries: */
+        /* Number of counters (must be equal to current number of entries). */
+        unsigned int num_counters;
+        /* The old entries' counters. */
+        struct ipt_counters __user *counters;
+
+        /* The entries (hang off end: not really an array). */
+        struct ipt_entry entries[0];
+};
+
+/* The argument to IPT_SO_ADD_COUNTERS. */
+struct ipt_counters_info
+{
+        /* Which table. */
+        char name[IPT_TABLE_MAXNAMELEN];
+
+        unsigned int num_counters;
+
+        /* The counters (actually `number' of these). */
+        struct ipt_counters counters[0];
+};
+
+/* The argument to IPT_SO_GET_ENTRIES. */
+struct ipt_get_entries
+{
+        /* Which table: user fills this in. */
+        char name[IPT_TABLE_MAXNAMELEN];
+
+        /* User fills this in: total entry size. */
+        unsigned int size;
+
+        /* The entries. */
+        struct ipt_entry entrytable[0];
+};
+
+/* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
+ * kernel supports, if >= revision. */
+struct ipt_get_revision
+{
+        char name[IPT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+};
+
+/* Standard return verdict, or do jump. */
+#define IPT_STANDARD_TARGET ""
+/* Error verdict. */
+#define IPT_ERROR_TARGET "ERROR"
+
+/* Helper functions */
+static __inline__ struct ipt_entry_target *
+ipt_get_target(struct ipt_entry *e)
+{
+        return (void *)e + e->target_offset;
+}
+
+/* fn returns 0 to continue iteration */
+#define IPT_MATCH_ITERATE(e, fn, args...)       \
+({                                              \
+        unsigned int __i;                       \
+        int __ret = 0;                          \
+        struct ipt_entry_match *__match;        \
+                                                \
+        for (__i = sizeof(struct ipt_entry);    \
+             __i < (e)->target_offset;          \
+             __i += __match->u.match_size) {    \
+                __match = (void *)(e) + __i;    \
+                                                \
+                __ret = fn(__match , ## args);  \
+                if (__ret != 0)                 \
+                        break;                  \
+        }                                       \
+        __ret;                                  \
+})
+
+/* fn returns 0 to continue iteration */
+#define IPT_ENTRY_ITERATE(entries, size, fn, args...)           \
+({                                                              \
+        unsigned int __i;                                       \
+        int __ret = 0;                                          \
+        struct ipt_entry *__entry;                              \
+                                                                \
+        for (__i = 0; __i < (size); __i += __entry->next_offset) { \
+                __entry = (void *)(entries) + __i;              \
+                                                                \
+                __ret = fn(__entry , ## args);                  \
+                if (__ret != 0)                                 \
+                        break;                                  \
+        }                                                       \
+        __ret;                                                  \
+})
+
+/*
+ *      Main firewall chains definitions and global var's definitions.
+ */
+#ifdef __KERNEL__
+
+#include <linux/init.h>
+extern void ipt_init(void) __init;
+
+struct ipt_match
+{
+        struct list_head list;
+
+        const char name[IPT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+
+        /* Return true or false: return FALSE and set *hotdrop = 1 to
+           force immediate packet drop. */
+        /* Arguments changed since 2.4, as this must now handle
+           non-linear skbs, using skb_copy_bits and
+           skb_ip_make_writable. */
+        int (*match)(const struct sk_buff *skb,
+                     const struct net_device *in,
+                     const struct net_device *out,
+                     const void *matchinfo,
+                     int offset,
+                     int *hotdrop);
+
+        /* Called when user tries to insert an entry of this type. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const struct ipt_ip *ip,
+                          void *matchinfo,
+                          unsigned int matchinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
+
+        /* Set this to THIS_MODULE. */
+        struct module *me;
+};
+
+/* Registration hooks for targets. */
+struct ipt_target
+{
+        struct list_head list;
+
+        const char name[IPT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+
+        /* Called when user tries to insert an entry of this type:
+           hook_mask is a bitmask of hooks from which it can be
+           called. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const struct ipt_entry *e,
+                          void *targinfo,
+                          unsigned int targinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *targinfo, unsigned int targinfosize);
+
+        /* Returns verdict.  Argument order changed since 2.4, as this
+           must now handle non-linear skbs, using skb_copy_bits and
+           skb_ip_make_writable. */
+        unsigned int (*target)(struct sk_buff **pskb,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               unsigned int hooknum,
+                               const void *targinfo,
+                               void *userdata);
+
+        /* Set this to THIS_MODULE. */
+        struct module *me;
+};
+
+extern int ipt_register_target(struct ipt_target *target);
+extern void ipt_unregister_target(struct ipt_target *target);
+
+extern int ipt_register_match(struct ipt_match *match);
+extern void ipt_unregister_match(struct ipt_match *match);
+
+/* Furniture shopping... */
+struct ipt_table
+{
+        struct list_head list;
+
+        /* A unique name... */
+        char name[IPT_TABLE_MAXNAMELEN];
+
+        /* What hooks you will enter on */
+        unsigned int valid_hooks;
+
+        /* Lock for the curtain */
+        rwlock_t lock;
+
+        /* Man behind the curtain... */
+        struct ipt_table_info *private;
+
+        /* Set to THIS_MODULE. */
+        struct module *me;
+};
+
+/* net/sched/ipt.c: Gimme access to your targets!  Gets target->me. */
+extern struct ipt_target *ipt_find_target(const char *name, u8 revision);
+
+/* Standard entry. */
+struct ipt_standard
+{
+        struct ipt_entry entry;
+        struct ipt_standard_target target;
+};
+
+struct ipt_error_target
+{
+        struct ipt_entry_target target;
+        char errorname[IPT_FUNCTION_MAXNAMELEN];
+};
+
+struct ipt_error
+{
+        struct ipt_entry entry;
+        struct ipt_error_target target;
+};
+
+extern int ipt_register_table(struct ipt_table *table,
+                              const struct ipt_replace *repl);
+extern void ipt_unregister_table(struct ipt_table *table);
+extern unsigned int ipt_do_table(struct sk_buff **pskb,
+                                 unsigned int hook,
+                                 const struct net_device *in,
+                                 const struct net_device *out,
+                                 struct ipt_table *table,
+                                 void *userdata);
+
+#define IPT_ALIGN(s) (((s) + (__alignof__(struct ipt_entry)-1)) & ~(__alignof__(struct ipt_entry)-1))
+#endif /*__KERNEL__*/
+#endif /* _IPTABLES_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CLASSIFY.h b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
new file mode 100644
index 000000000000..7596e3dd00ca
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
@@ -0,0 +1,8 @@
+#ifndef _IPT_CLASSIFY_H
+#define _IPT_CLASSIFY_H
+
+struct ipt_classify_target_info {
+        u_int32_t priority;
+};
+
+#endif /*_IPT_CLASSIFY_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
new file mode 100644
index 000000000000..baa83e757156
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
@@ -0,0 +1,32 @@
+#ifndef _IPT_CLUSTERIP_H_target
+#define _IPT_CLUSTERIP_H_target
+
+enum clusterip_hashmode {
+    CLUSTERIP_HASHMODE_SIP = 0,
+    CLUSTERIP_HASHMODE_SIP_SPT,
+    CLUSTERIP_HASHMODE_SIP_SPT_DPT,
+};
+
+#define CLUSTERIP_HASHMODE_MAX CLUSTERIP_HASHMODE_SIP_SPT_DPT
+
+#define CLUSTERIP_MAX_NODES 16
+
+#define CLUSTERIP_FLAG_NEW 0x00000001
+
+struct clusterip_config;
+
+struct ipt_clusterip_tgt_info {
+
+        u_int32_t flags;
+        struct clusterip_config *config;
+        
+        /* only relevant for new ones */
+        u_int8_t clustermac[6];
+        u_int16_t num_total_nodes;
+        u_int16_t num_local_nodes;
+        u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
+        enum clusterip_hashmode hash_mode;
+        u_int32_t hash_initval;
+};
+
+#endif /*_IPT_CLUSTERIP_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_CONNMARK.h b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
new file mode 100644
index 000000000000..d3c02536fc4c
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
@@ -0,0 +1,25 @@
+#ifndef _IPT_CONNMARK_H_target
+#define _IPT_CONNMARK_H_target
+
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+enum {
+        IPT_CONNMARK_SET = 0,
+        IPT_CONNMARK_SAVE,
+        IPT_CONNMARK_RESTORE
+};
+
+struct ipt_connmark_target_info {
+        unsigned long mark;
+        unsigned long mask;
+        u_int8_t mode;
+};
+
+#endif /*_IPT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_DSCP.h b/include/linux/netfilter_ipv4/ipt_DSCP.h
new file mode 100644
index 000000000000..b30f510b5bef
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_DSCP.h
@@ -0,0 +1,20 @@
+/* iptables module for setting the IPv4 DSCP field
+ *
+ * (C) 2002 Harald Welte <laforge@gnumonks.org>
+ * based on ipt_FTOS.c (C) 2000 by Matthew G. Marsh <mgm@paktronix.com>
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+ * See RFC2474 for a description of the DSCP field within the IP Header.
+ *
+ * ipt_DSCP.h,v 1.7 2002/03/14 12:03:13 laforge Exp
+*/
+#ifndef _IPT_DSCP_TARGET_H
+#define _IPT_DSCP_TARGET_H
+#include <linux/netfilter_ipv4/ipt_dscp.h>
+
+/* target info */
+struct ipt_DSCP_info {
+        u_int8_t dscp;
+};
+
+#endif /* _IPT_DSCP_TARGET_H */
diff --git a/include/linux/netfilter_ipv4/ipt_ECN.h b/include/linux/netfilter_ipv4/ipt_ECN.h
new file mode 100644
index 000000000000..94e0d9866469
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_ECN.h
@@ -0,0 +1,31 @@
+/* Header file for iptables ipt_ECN target
+ *
+ * (C) 2002 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+ * ipt_ECN.h,v 1.3 2002/05/29 12:17:40 laforge Exp
+*/
+#ifndef _IPT_ECN_TARGET_H
+#define _IPT_ECN_TARGET_H
+#include <linux/netfilter_ipv4/ipt_DSCP.h>
+
+#define IPT_ECN_IP_MASK (~IPT_DSCP_MASK)
+
+#define IPT_ECN_OP_SET_IP       0x01    /* set ECN bits of IPv4 header */
+#define IPT_ECN_OP_SET_ECE      0x10    /* set ECE bit of TCP header */
+#define IPT_ECN_OP_SET_CWR      0x20    /* set CWR bit of TCP header */
+
+#define IPT_ECN_OP_MASK         0xce
+
+struct ipt_ECN_info {
+        u_int8_t operation;     /* bitset of operations */
+        u_int8_t ip_ect;        /* ECT codepoint of IPv4 header, pre-shifted */
+        union {
+                struct {
+                        u_int8_t ece:1, cwr:1; /* TCP ECT bits */
+                } tcp;
+        } proto;
+};
+
+#endif /* _IPT_ECN_TARGET_H */
diff --git a/include/linux/netfilter_ipv4/ipt_LOG.h b/include/linux/netfilter_ipv4/ipt_LOG.h
new file mode 100644
index 000000000000..d25f782e57d1
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_LOG.h
@@ -0,0 +1,16 @@
+#ifndef _IPT_LOG_H
+#define _IPT_LOG_H
+
+#define IPT_LOG_TCPSEQ          0x01    /* Log TCP sequence numbers */
+#define IPT_LOG_TCPOPT          0x02    /* Log TCP options */
+#define IPT_LOG_IPOPT           0x04    /* Log IP options */
+#define IPT_LOG_UID             0x08    /* Log UID owning local socket */
+#define IPT_LOG_MASK            0x0f
+
+struct ipt_log_info {
+        unsigned char level;
+        unsigned char logflags;
+        char prefix[30];
+};
+
+#endif /*_IPT_LOG_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_MARK.h b/include/linux/netfilter_ipv4/ipt_MARK.h
new file mode 100644
index 000000000000..f47485790ed4
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_MARK.h
@@ -0,0 +1,20 @@
+#ifndef _IPT_MARK_H_target
+#define _IPT_MARK_H_target
+
+/* Version 0 */
+struct ipt_mark_target_info {
+        unsigned long mark;
+};
+
+/* Version 1 */
+enum {
+        IPT_MARK_SET=0,
+        IPT_MARK_AND,
+        IPT_MARK_OR
+};
+
+struct ipt_mark_target_info_v1 {
+        unsigned long mark;
+        u_int8_t mode;
+};
+#endif /*_IPT_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_REJECT.h b/include/linux/netfilter_ipv4/ipt_REJECT.h
new file mode 100644
index 000000000000..4293a1ad1b01
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_REJECT.h
@@ -0,0 +1,20 @@
+#ifndef _IPT_REJECT_H
+#define _IPT_REJECT_H
+
+enum ipt_reject_with {
+        IPT_ICMP_NET_UNREACHABLE,
+        IPT_ICMP_HOST_UNREACHABLE,
+        IPT_ICMP_PROT_UNREACHABLE,
+        IPT_ICMP_PORT_UNREACHABLE,
+        IPT_ICMP_ECHOREPLY,
+        IPT_ICMP_NET_PROHIBITED,
+        IPT_ICMP_HOST_PROHIBITED,
+        IPT_TCP_RESET,
+        IPT_ICMP_ADMIN_PROHIBITED
+};
+
+struct ipt_reject_info {
+        enum ipt_reject_with with;      /* reject type */
+};
+
+#endif /*_IPT_REJECT_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_SAME.h b/include/linux/netfilter_ipv4/ipt_SAME.h
new file mode 100644
index 000000000000..cc4c0b2269af
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_SAME.h
@@ -0,0 +1,19 @@
+#ifndef _IPT_SAME_H
+#define _IPT_SAME_H
+
+#define IPT_SAME_MAX_RANGE      10
+
+#define IPT_SAME_NODST          0x01
+
+struct ipt_same_info
+{
+        unsigned char info;
+        u_int32_t rangesize;
+        u_int32_t ipnum;
+        u_int32_t *iparray;
+
+        /* hangs off end. */
+        struct ip_nat_range range[IPT_SAME_MAX_RANGE];
+};
+
+#endif /*_IPT_SAME_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_TCPMSS.h b/include/linux/netfilter_ipv4/ipt_TCPMSS.h
new file mode 100644
index 000000000000..aadb39580cd3
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_TCPMSS.h
@@ -0,0 +1,10 @@
+#ifndef _IPT_TCPMSS_H
+#define _IPT_TCPMSS_H
+
+struct ipt_tcpmss_info {
+        u_int16_t mss;
+};
+
+#define IPT_TCPMSS_CLAMP_PMTU 0xffff
+
+#endif /*_IPT_TCPMSS_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_TOS.h b/include/linux/netfilter_ipv4/ipt_TOS.h
new file mode 100644
index 000000000000..6bf9e1fdfd88
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_TOS.h
@@ -0,0 +1,12 @@
+#ifndef _IPT_TOS_H_target
+#define _IPT_TOS_H_target
+
+#ifndef IPTOS_NORMALSVC
+#define IPTOS_NORMALSVC 0
+#endif
+
+struct ipt_tos_target_info {
+        u_int8_t tos;
+};
+
+#endif /*_IPT_TOS_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_ULOG.h b/include/linux/netfilter_ipv4/ipt_ULOG.h
new file mode 100644
index 000000000000..417aad280bcc
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_ULOG.h
@@ -0,0 +1,49 @@
+/* Header file for IP tables userspace logging, Version 1.8
+ *
+ * (C) 2000-2002 by Harald Welte <laforge@gnumonks.org>
+ * 
+ * Distributed under the terms of GNU GPL */
+
+#ifndef _IPT_ULOG_H
+#define _IPT_ULOG_H
+
+#ifndef NETLINK_NFLOG
+#define NETLINK_NFLOG   5
+#endif
+
+#define ULOG_DEFAULT_NLGROUP    1
+#define ULOG_DEFAULT_QTHRESHOLD 1
+
+#define ULOG_MAC_LEN    80
+#define ULOG_PREFIX_LEN 32
+
+#define ULOG_MAX_QLEN   50
+/* Why 50? Well... there is a limit imposed by the slab cache 131000
+ * bytes. So the multipart netlink-message has to be < 131000 bytes.
+ * Assuming a standard ethernet-mtu of 1500, we could define this up
+ * to 80... but even 50 seems to be big enough. */
+
+/* private data structure for each rule with a ULOG target */
+struct ipt_ulog_info {
+        unsigned int nl_group;
+        size_t copy_range;
+        size_t qthreshold;
+        char prefix[ULOG_PREFIX_LEN];
+};
+
+/* Format of the ULOG packets passed through netlink */
+typedef struct ulog_packet_msg {
+        unsigned long mark;
+        long timestamp_sec;
+        long timestamp_usec;
+        unsigned int hook;
+        char indev_name[IFNAMSIZ];
+        char outdev_name[IFNAMSIZ];
+        size_t data_len;
+        char prefix[ULOG_PREFIX_LEN];
+        unsigned char mac_len;
+        unsigned char mac[ULOG_MAC_LEN];
+        unsigned char payload[0];
+} ulog_packet_msg_t;
+
+#endif /*_IPT_ULOG_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_addrtype.h b/include/linux/netfilter_ipv4/ipt_addrtype.h
new file mode 100644
index 000000000000..166ed01a8122
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_addrtype.h
@@ -0,0 +1,11 @@
+#ifndef _IPT_ADDRTYPE_H
+#define _IPT_ADDRTYPE_H
+
+struct ipt_addrtype_info {
+        u_int16_t       source;         /* source-type mask */
+        u_int16_t       dest;           /* dest-type mask */
+        u_int32_t       invert_source;
+        u_int32_t       invert_dest;
+};
+
+#endif
diff --git a/include/linux/netfilter_ipv4/ipt_ah.h b/include/linux/netfilter_ipv4/ipt_ah.h
new file mode 100644
index 000000000000..7b9a2ac7adb9
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_ah.h
@@ -0,0 +1,16 @@
+#ifndef _IPT_AH_H
+#define _IPT_AH_H
+
+struct ipt_ah
+{
+        u_int32_t spis[2];                      /* Security Parameter Index */
+        u_int8_t  invflags;                     /* Inverse flags */
+};
+
+
+
+/* Values for "invflags" field in struct ipt_ah. */
+#define IPT_AH_INV_SPI          0x01    /* Invert the sense of spi. */
+#define IPT_AH_INV_MASK 0x01    /* All possible flags. */
+
+#endif /*_IPT_AH_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_comment.h b/include/linux/netfilter_ipv4/ipt_comment.h
new file mode 100644
index 000000000000..85c1123c29ce
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_comment.h
@@ -0,0 +1,10 @@
+#ifndef _IPT_COMMENT_H
+#define _IPT_COMMENT_H
+
+#define IPT_MAX_COMMENT_LEN 256
+
+struct ipt_comment_info {
+        unsigned char comment[IPT_MAX_COMMENT_LEN];
+};
+
+#endif /* _IPT_COMMENT_H */
diff --git a/include/linux/netfilter_ipv4/ipt_connmark.h b/include/linux/netfilter_ipv4/ipt_connmark.h
new file mode 100644
index 000000000000..46573270d9aa
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_connmark.h
@@ -0,0 +1,18 @@
+#ifndef _IPT_CONNMARK_H
+#define _IPT_CONNMARK_H
+
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+struct ipt_connmark_info {
+        unsigned long mark, mask;
+        u_int8_t invert;
+};
+
+#endif /*_IPT_CONNMARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_conntrack.h b/include/linux/netfilter_ipv4/ipt_conntrack.h
new file mode 100644
index 000000000000..413c5658bd3a
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_conntrack.h
@@ -0,0 +1,60 @@
+/* Header file for kernel module to match connection tracking information.
+ * GPL (C) 2001  Marc Boucher (marc@mbsi.ca).
+ */
+
+#ifndef _IPT_CONNTRACK_H
+#define _IPT_CONNTRACK_H
+
+#define IPT_CONNTRACK_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define IPT_CONNTRACK_STATE_INVALID (1 << 0)
+
+#define IPT_CONNTRACK_STATE_SNAT (1 << (IP_CT_NUMBER + 1))
+#define IPT_CONNTRACK_STATE_DNAT (1 << (IP_CT_NUMBER + 2))
+#define IPT_CONNTRACK_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 3))
+
+/* flags, invflags: */
+#define IPT_CONNTRACK_STATE     0x01
+#define IPT_CONNTRACK_PROTO     0x02
+#define IPT_CONNTRACK_ORIGSRC   0x04
+#define IPT_CONNTRACK_ORIGDST   0x08
+#define IPT_CONNTRACK_REPLSRC   0x10
+#define IPT_CONNTRACK_REPLDST   0x20
+#define IPT_CONNTRACK_STATUS    0x40
+#define IPT_CONNTRACK_EXPIRES   0x80
+
+/* This is exposed to userspace, so remains frozen in time. */
+struct ip_conntrack_old_tuple
+{
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+        } src;
+
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+
+                /* The protocol. */
+                u16 protonum;
+        } dst;
+};
+
+struct ipt_conntrack_info
+{
+        unsigned int statemask, statusmask;
+
+        struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
+        struct in_addr sipmsk[IP_CT_DIR_MAX], dipmsk[IP_CT_DIR_MAX];
+
+        unsigned long expires_min, expires_max;
+
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int8_t invflags;
+};
+#endif /*_IPT_CONNTRACK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_dscp.h b/include/linux/netfilter_ipv4/ipt_dscp.h
new file mode 100644
index 000000000000..2fa6dfe92894
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_dscp.h
@@ -0,0 +1,23 @@
+/* iptables module for matching the IPv4 DSCP field
+ *
+ * (C) 2002 Harald Welte <laforge@gnumonks.org>
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+ * See RFC2474 for a description of the DSCP field within the IP Header.
+ *
+ * ipt_dscp.h,v 1.3 2002/08/05 19:00:21 laforge Exp
+*/
+#ifndef _IPT_DSCP_H
+#define _IPT_DSCP_H
+
+#define IPT_DSCP_MASK   0xfc    /* 11111100 */
+#define IPT_DSCP_SHIFT  2
+#define IPT_DSCP_MAX    0x3f    /* 00111111 */
+
+/* match info */
+struct ipt_dscp_info {
+        u_int8_t dscp;
+        u_int8_t invert;
+};
+
+#endif /* _IPT_DSCP_H */
diff --git a/include/linux/netfilter_ipv4/ipt_ecn.h b/include/linux/netfilter_ipv4/ipt_ecn.h
new file mode 100644
index 000000000000..1f0d9a4d3378
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_ecn.h
@@ -0,0 +1,33 @@
+/* iptables module for matching the ECN header in IPv4 and TCP header
+ *
+ * (C) 2002 Harald Welte <laforge@gnumonks.org>
+ *
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+ * ipt_ecn.h,v 1.4 2002/08/05 19:39:00 laforge Exp
+*/
+#ifndef _IPT_ECN_H
+#define _IPT_ECN_H
+#include <linux/netfilter_ipv4/ipt_dscp.h>
+
+#define IPT_ECN_IP_MASK (~IPT_DSCP_MASK)
+
+#define IPT_ECN_OP_MATCH_IP     0x01
+#define IPT_ECN_OP_MATCH_ECE    0x10
+#define IPT_ECN_OP_MATCH_CWR    0x20
+
+#define IPT_ECN_OP_MATCH_MASK   0xce
+
+/* match info */
+struct ipt_ecn_info {
+        u_int8_t operation;
+        u_int8_t invert;
+        u_int8_t ip_ect;
+        union {
+                struct {
+                        u_int8_t ect;
+                } tcp;
+        } proto;
+};
+
+#endif /* _IPT_ECN_H */
diff --git a/include/linux/netfilter_ipv4/ipt_esp.h b/include/linux/netfilter_ipv4/ipt_esp.h
new file mode 100644
index 000000000000..c782a83e53e0
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_esp.h
@@ -0,0 +1,16 @@
+#ifndef _IPT_ESP_H
+#define _IPT_ESP_H
+
+struct ipt_esp
+{
+        u_int32_t spis[2];                      /* Security Parameter Index */
+        u_int8_t  invflags;                     /* Inverse flags */
+};
+
+
+
+/* Values for "invflags" field in struct ipt_esp. */
+#define IPT_ESP_INV_SPI         0x01    /* Invert the sense of spi. */
+#define IPT_ESP_INV_MASK        0x01    /* All possible flags. */
+
+#endif /*_IPT_ESP_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_hashlimit.h b/include/linux/netfilter_ipv4/ipt_hashlimit.h
new file mode 100644
index 000000000000..ac2cb64ecd76
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_hashlimit.h
@@ -0,0 +1,40 @@
+#ifndef _IPT_HASHLIMIT_H
+#define _IPT_HASHLIMIT_H
+
+/* timings are in milliseconds. */
+#define IPT_HASHLIMIT_SCALE 10000
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+
+/* details of this structure hidden by the implementation */
+struct ipt_hashlimit_htable;
+
+#define IPT_HASHLIMIT_HASH_DIP  0x0001
+#define IPT_HASHLIMIT_HASH_DPT  0x0002
+#define IPT_HASHLIMIT_HASH_SIP  0x0004
+#define IPT_HASHLIMIT_HASH_SPT  0x0008
+
+struct hashlimit_cfg {
+        u_int32_t mode;   /* bitmask of IPT_HASHLIMIT_HASH_* */
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+
+        /* user specified */
+        u_int32_t size;         /* how many buckets */
+        u_int32_t max;          /* max number of entries */
+        u_int32_t gc_interval;  /* gc interval */
+        u_int32_t expire;       /* when do entries expire? */
+};
+
+struct ipt_hashlimit_info {
+        char name [IFNAMSIZ];           /* name */
+        struct hashlimit_cfg cfg;
+        struct ipt_hashlimit_htable *hinfo;
+
+        /* Used internally by the kernel */
+        union {
+                void *ptr;
+                struct ipt_hashlimit_info *master;
+        } u;
+};
+#endif /*_IPT_HASHLIMIT_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_helper.h b/include/linux/netfilter_ipv4/ipt_helper.h
new file mode 100644
index 000000000000..6f12ecb8c93d
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_helper.h
@@ -0,0 +1,8 @@
+#ifndef _IPT_HELPER_H
+#define _IPT_HELPER_H
+
+struct ipt_helper_info {
+        int invert;
+        char name[30];
+};
+#endif /* _IPT_HELPER_H */
diff --git a/include/linux/netfilter_ipv4/ipt_iprange.h b/include/linux/netfilter_ipv4/ipt_iprange.h
new file mode 100644
index 000000000000..3ecb3bd63676
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_iprange.h
@@ -0,0 +1,23 @@
+#ifndef _IPT_IPRANGE_H
+#define _IPT_IPRANGE_H
+
+#define IPRANGE_SRC             0x01    /* Match source IP address */
+#define IPRANGE_DST             0x02    /* Match destination IP address */
+#define IPRANGE_SRC_INV         0x10    /* Negate the condition */
+#define IPRANGE_DST_INV         0x20    /* Negate the condition */
+
+struct ipt_iprange {
+        /* Inclusive: network order. */
+        u_int32_t min_ip, max_ip;
+};
+
+struct ipt_iprange_info
+{
+        struct ipt_iprange src;
+        struct ipt_iprange dst;
+
+        /* Flags from above */
+        u_int8_t flags;
+};
+
+#endif /* _IPT_IPRANGE_H */
diff --git a/include/linux/netfilter_ipv4/ipt_length.h b/include/linux/netfilter_ipv4/ipt_length.h
new file mode 100644
index 000000000000..6e0885229615
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_length.h
@@ -0,0 +1,9 @@
+#ifndef _IPT_LENGTH_H
+#define _IPT_LENGTH_H
+
+struct ipt_length_info {
+    u_int16_t   min, max;
+    u_int8_t    invert;
+};
+
+#endif /*_IPT_LENGTH_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_limit.h b/include/linux/netfilter_ipv4/ipt_limit.h
new file mode 100644
index 000000000000..256453409e21
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_limit.h
@@ -0,0 +1,21 @@
+#ifndef _IPT_RATE_H
+#define _IPT_RATE_H
+
+/* timings are in milliseconds. */
+#define IPT_LIMIT_SCALE 10000
+
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+struct ipt_rateinfo {
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+
+        /* Used internally by the kernel */
+        unsigned long prev;
+        u_int32_t credit;
+        u_int32_t credit_cap, cost;
+
+        /* Ugly, ugly fucker. */
+        struct ipt_rateinfo *master;
+};
+#endif /*_IPT_RATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mac.h b/include/linux/netfilter_ipv4/ipt_mac.h
new file mode 100644
index 000000000000..f8d5b8e7ccdb
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_mac.h
@@ -0,0 +1,8 @@
+#ifndef _IPT_MAC_H
+#define _IPT_MAC_H
+
+struct ipt_mac_info {
+    unsigned char srcaddr[ETH_ALEN];
+    int invert;
+};
+#endif /*_IPT_MAC_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mark.h b/include/linux/netfilter_ipv4/ipt_mark.h
new file mode 100644
index 000000000000..f3952b563d4c
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_mark.h
@@ -0,0 +1,9 @@
+#ifndef _IPT_MARK_H
+#define _IPT_MARK_H
+
+struct ipt_mark_info {
+    unsigned long mark, mask;
+    u_int8_t invert;
+};
+
+#endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_multiport.h b/include/linux/netfilter_ipv4/ipt_multiport.h
new file mode 100644
index 000000000000..e6b6fff811df
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_multiport.h
@@ -0,0 +1,30 @@
+#ifndef _IPT_MULTIPORT_H
+#define _IPT_MULTIPORT_H
+#include <linux/netfilter_ipv4/ip_tables.h>
+
+enum ipt_multiport_flags
+{
+        IPT_MULTIPORT_SOURCE,
+        IPT_MULTIPORT_DESTINATION,
+        IPT_MULTIPORT_EITHER
+};
+
+#define IPT_MULTI_PORTS 15
+
+/* Must fit inside union ipt_matchinfo: 16 bytes */
+struct ipt_multiport
+{
+        u_int8_t flags;                         /* Type of comparison */
+        u_int8_t count;                         /* Number of ports */
+        u_int16_t ports[IPT_MULTI_PORTS];       /* Ports */
+};
+
+struct ipt_multiport_v1
+{
+        u_int8_t flags;                         /* Type of comparison */
+        u_int8_t count;                         /* Number of ports */
+        u_int16_t ports[IPT_MULTI_PORTS];       /* Ports */
+        u_int8_t pflags[IPT_MULTI_PORTS];       /* Port flags */
+        u_int8_t invert;                        /* Invert flag */
+};
+#endif /*_IPT_MULTIPORT_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_owner.h b/include/linux/netfilter_ipv4/ipt_owner.h
new file mode 100644
index 000000000000..92f4bdac54ef
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_owner.h
@@ -0,0 +1,20 @@
+#ifndef _IPT_OWNER_H
+#define _IPT_OWNER_H
+
+/* match and invert flags */
+#define IPT_OWNER_UID   0x01
+#define IPT_OWNER_GID   0x02
+#define IPT_OWNER_PID   0x04
+#define IPT_OWNER_SID   0x08
+#define IPT_OWNER_COMM  0x10
+
+struct ipt_owner_info {
+    uid_t uid;
+    gid_t gid;
+    pid_t pid;
+    pid_t sid;
+    char comm[16];
+    u_int8_t match, invert;     /* flags */
+};
+
+#endif /*_IPT_OWNER_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_physdev.h b/include/linux/netfilter_ipv4/ipt_physdev.h
new file mode 100644
index 000000000000..7538c8655ec0
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_physdev.h
@@ -0,0 +1,24 @@
+#ifndef _IPT_PHYSDEV_H
+#define _IPT_PHYSDEV_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#endif
+
+#define IPT_PHYSDEV_OP_IN               0x01
+#define IPT_PHYSDEV_OP_OUT              0x02
+#define IPT_PHYSDEV_OP_BRIDGED          0x04
+#define IPT_PHYSDEV_OP_ISIN             0x08
+#define IPT_PHYSDEV_OP_ISOUT            0x10
+#define IPT_PHYSDEV_OP_MASK             (0x20 - 1)
+
+struct ipt_physdev_info {
+        char physindev[IFNAMSIZ];
+        char in_mask[IFNAMSIZ];
+        char physoutdev[IFNAMSIZ];
+        char out_mask[IFNAMSIZ];
+        u_int8_t invert;
+        u_int8_t bitmask;
+};
+
+#endif /*_IPT_PHYSDEV_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_pkttype.h b/include/linux/netfilter_ipv4/ipt_pkttype.h
new file mode 100644
index 000000000000..d53a65848683
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_pkttype.h
@@ -0,0 +1,8 @@
+#ifndef _IPT_PKTTYPE_H
+#define _IPT_PKTTYPE_H
+
+struct ipt_pkttype_info {
+        int     pkttype;
+        int     invert;
+};
+#endif /*_IPT_PKTTYPE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_realm.h b/include/linux/netfilter_ipv4/ipt_realm.h
new file mode 100644
index 000000000000..a4d6698723ac
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_realm.h
@@ -0,0 +1,10 @@
+#ifndef _IPT_REALM_H
+#define _IPT_REALM_H
+
+struct ipt_realm_info {
+        u_int32_t id;
+        u_int32_t mask;
+        u_int8_t invert;
+};
+
+#endif /* _IPT_REALM_H */
diff --git a/include/linux/netfilter_ipv4/ipt_recent.h b/include/linux/netfilter_ipv4/ipt_recent.h
new file mode 100644
index 000000000000..6508a4592651
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_recent.h
@@ -0,0 +1,27 @@
+#ifndef _IPT_RECENT_H
+#define _IPT_RECENT_H
+
+#define RECENT_NAME     "ipt_recent"
+#define RECENT_VER      "v0.3.1"
+
+#define IPT_RECENT_CHECK  1
+#define IPT_RECENT_SET    2
+#define IPT_RECENT_UPDATE 4
+#define IPT_RECENT_REMOVE 8
+#define IPT_RECENT_TTL   16
+
+#define IPT_RECENT_SOURCE 0
+#define IPT_RECENT_DEST   1
+
+#define IPT_RECENT_NAME_LEN 200
+
+struct ipt_recent_info {
+        u_int32_t   seconds;
+        u_int32_t   hit_count;
+        u_int8_t    check_set;
+        u_int8_t    invert;
+        char        name[IPT_RECENT_NAME_LEN];
+        u_int8_t    side;
+};
+
+#endif /*_IPT_RECENT_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_sctp.h b/include/linux/netfilter_ipv4/ipt_sctp.h
new file mode 100644
index 000000000000..e93a9ec99fc2
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_sctp.h
@@ -0,0 +1,107 @@
+#ifndef _IPT_SCTP_H_
+#define _IPT_SCTP_H_
+
+#define IPT_SCTP_SRC_PORTS              0x01
+#define IPT_SCTP_DEST_PORTS             0x02
+#define IPT_SCTP_CHUNK_TYPES            0x04
+
+#define IPT_SCTP_VALID_FLAGS            0x07
+
+#define ELEMCOUNT(x) (sizeof(x)/sizeof(x[0]))
+
+
+struct ipt_sctp_flag_info {
+        u_int8_t chunktype;
+        u_int8_t flag;
+        u_int8_t flag_mask;
+};
+
+#define IPT_NUM_SCTP_FLAGS      4
+
+struct ipt_sctp_info {
+        u_int16_t dpts[2];  /* Min, Max */
+        u_int16_t spts[2];  /* Min, Max */
+
+        u_int32_t chunkmap[256 / sizeof (u_int32_t)];  /* Bit mask of chunks to be matched according to RFC 2960 */
+
+#define SCTP_CHUNK_MATCH_ANY   0x01  /* Match if any of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ALL   0x02  /* Match if all of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ONLY  0x04  /* Match if these are the only chunk types present */
+
+        u_int32_t chunk_match_type;
+        struct ipt_sctp_flag_info flag_info[IPT_NUM_SCTP_FLAGS];
+        int flag_count;
+
+        u_int32_t flags;
+        u_int32_t invflags;
+};
+
+#define bytes(type) (sizeof(type) * 8)
+
+#define SCTP_CHUNKMAP_SET(chunkmap, type)               \
+        do {                                            \
+                chunkmap[type / bytes(u_int32_t)] |=    \
+                        1 << (type % bytes(u_int32_t)); \
+        } while (0)
+
+#define SCTP_CHUNKMAP_CLEAR(chunkmap, type)                     \
+        do {                                                    \
+                chunkmap[type / bytes(u_int32_t)] &=            \
+                        ~(1 << (type % bytes(u_int32_t)));      \
+        } while (0)
+
+#define SCTP_CHUNKMAP_IS_SET(chunkmap, type)                    \
+({                                                              \
+        (chunkmap[type / bytes (u_int32_t)] &                   \
+                (1 << (type % bytes (u_int32_t)))) ? 1: 0;      \
+})
+
+#define SCTP_CHUNKMAP_RESET(chunkmap)                           \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = 0;                        \
+        } while (0)
+
+#define SCTP_CHUNKMAP_SET_ALL(chunkmap)                         \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = ~0;                       \
+        } while (0)
+
+#define SCTP_CHUNKMAP_COPY(destmap, srcmap)                     \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        destmap[i] = srcmap[i];                 \
+        } while (0)
+
+#define SCTP_CHUNKMAP_IS_CLEAR(chunkmap)                \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i]) {                      \
+                        flag = 0;                       \
+                        break;                          \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+
+#define SCTP_CHUNKMAP_IS_ALL_SET(chunkmap)              \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i] != ~0) {                \
+                        flag = 0;                       \
+                                break;                  \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+
+#endif /* _IPT_SCTP_H_ */
+
diff --git a/include/linux/netfilter_ipv4/ipt_state.h b/include/linux/netfilter_ipv4/ipt_state.h
new file mode 100644
index 000000000000..5df37868933d
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_state.h
@@ -0,0 +1,13 @@
+#ifndef _IPT_STATE_H
+#define _IPT_STATE_H
+
+#define IPT_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define IPT_STATE_INVALID (1 << 0)
+
+#define IPT_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 1))
+
+struct ipt_state_info
+{
+        unsigned int statemask;
+};
+#endif /*_IPT_STATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_tcpmss.h b/include/linux/netfilter_ipv4/ipt_tcpmss.h
new file mode 100644
index 000000000000..e2b14397f701
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_tcpmss.h
@@ -0,0 +1,9 @@
+#ifndef _IPT_TCPMSS_MATCH_H
+#define _IPT_TCPMSS_MATCH_H
+
+struct ipt_tcpmss_match_info {
+    u_int16_t mss_min, mss_max;
+    u_int8_t invert;
+};
+
+#endif /*_IPT_TCPMSS_MATCH_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_tos.h b/include/linux/netfilter_ipv4/ipt_tos.h
new file mode 100644
index 000000000000..a21f5df23c50
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_tos.h
@@ -0,0 +1,13 @@
+#ifndef _IPT_TOS_H
+#define _IPT_TOS_H
+
+struct ipt_tos_info {
+    u_int8_t tos;
+    u_int8_t invert;
+};
+
+#ifndef IPTOS_NORMALSVC
+#define IPTOS_NORMALSVC 0
+#endif
+
+#endif /*_IPT_TOS_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_ttl.h b/include/linux/netfilter_ipv4/ipt_ttl.h
new file mode 100644
index 000000000000..ee24fd86a3aa
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_ttl.h
@@ -0,0 +1,21 @@
+/* IP tables module for matching the value of the TTL
+ * (C) 2000 by Harald Welte <laforge@gnumonks.org> */
+
+#ifndef _IPT_TTL_H
+#define _IPT_TTL_H
+
+enum {
+        IPT_TTL_EQ = 0,         /* equals */
+        IPT_TTL_NE,             /* not equals */
+        IPT_TTL_LT,             /* less than */
+        IPT_TTL_GT,             /* greater than */
+};
+
+
+struct ipt_ttl_info {
+        u_int8_t        mode;
+        u_int8_t        ttl;
+};
+
+
+#endif
diff --git a/include/linux/netfilter_ipv4/listhelp.h b/include/linux/netfilter_ipv4/listhelp.h
new file mode 100644
index 000000000000..f2ae7c5e57bb
--- /dev/null
+++ b/include/linux/netfilter_ipv4/listhelp.h
@@ -0,0 +1,125 @@
+#ifndef _LISTHELP_H
+#define _LISTHELP_H
+#include <linux/config.h>
+#include <linux/list.h>
+#include <linux/netfilter_ipv4/lockhelp.h>
+
+/* Header to do more comprehensive job than linux/list.h; assume list
+   is first entry in structure. */
+
+/* Return pointer to first true entry, if any, or NULL.  A macro
+   required to allow inlining of cmpfn. */
+#define LIST_FIND(head, cmpfn, type, args...)           \
+({                                                      \
+        const struct list_head *__i, *__j = NULL;       \
+                                                        \
+        ASSERT_READ_LOCK(head);                         \
+        list_for_each(__i, (head))                      \
+                if (cmpfn((const type)__i , ## args)) { \
+                        __j = __i;                      \
+                        break;                          \
+                }                                       \
+        (type)__j;                                      \
+})
+
+#define LIST_FIND_W(head, cmpfn, type, args...)         \
+({                                                      \
+        const struct list_head *__i, *__j = NULL;       \
+                                                        \
+        ASSERT_WRITE_LOCK(head);                        \
+        list_for_each(__i, (head))                      \
+                if (cmpfn((type)__i , ## args)) {       \
+                        __j = __i;                      \
+                        break;                          \
+                }                                       \
+        (type)__j;                                      \
+})
+
+/* Just like LIST_FIND but we search backwards */
+#define LIST_FIND_B(head, cmpfn, type, args...)         \
+({                                                      \
+        const struct list_head *__i, *__j = NULL;       \
+                                                        \
+        ASSERT_READ_LOCK(head);                         \
+        list_for_each_prev(__i, (head))                 \
+                if (cmpfn((const type)__i , ## args)) { \
+                        __j = __i;                      \
+                        break;                          \
+                }                                       \
+        (type)__j;                                      \
+})
+
+static inline int
+__list_cmp_same(const void *p1, const void *p2) { return p1 == p2; }
+
+/* Is this entry in the list? */
+static inline int
+list_inlist(struct list_head *head, const void *entry)
+{
+        return LIST_FIND(head, __list_cmp_same, void *, entry) != NULL;
+}
+
+/* Delete from list. */
+#ifdef CONFIG_NETFILTER_DEBUG
+#define LIST_DELETE(head, oldentry)                                     \
+do {                                                                    \
+        ASSERT_WRITE_LOCK(head);                                        \
+        if (!list_inlist(head, oldentry))                               \
+                printk("LIST_DELETE: %s:%u `%s'(%p) not in %s.\n",      \
+                       __FILE__, __LINE__, #oldentry, oldentry, #head); \
+        else list_del((struct list_head *)oldentry);                    \
+} while(0)
+#else
+#define LIST_DELETE(head, oldentry) list_del((struct list_head *)oldentry)
+#endif
+
+/* Append. */
+static inline void
+list_append(struct list_head *head, void *new)
+{
+        ASSERT_WRITE_LOCK(head);
+        list_add((new), (head)->prev);
+}
+
+/* Prepend. */
+static inline void
+list_prepend(struct list_head *head, void *new)
+{
+        ASSERT_WRITE_LOCK(head);
+        list_add(new, head);
+}
+
+/* Insert according to ordering function; insert before first true. */
+#define LIST_INSERT(head, new, cmpfn)                           \
+do {                                                            \
+        struct list_head *__i;                                  \
+        ASSERT_WRITE_LOCK(head);                                \
+        list_for_each(__i, (head))                              \
+                if ((new), (typeof (new))__i)                   \
+                        break;                                  \
+        list_add((struct list_head *)(new), __i->prev);         \
+} while(0)
+
+/* If the field after the list_head is a nul-terminated string, you
+   can use these functions. */
+static inline int __list_cmp_name(const void *i, const char *name)
+{
+        return strcmp(name, i+sizeof(struct list_head)) == 0;
+}
+
+/* Returns false if same name already in list, otherwise does insert. */
+static inline int
+list_named_insert(struct list_head *head, void *new)
+{
+        if (LIST_FIND(head, __list_cmp_name, void *,
+                      new + sizeof(struct list_head)))
+                return 0;
+        list_prepend(head, new);
+        return 1;
+}
+
+/* Find this named element in the list. */
+#define list_named_find(head, name)                     \
+LIST_FIND(head, __list_cmp_name, void *, name)
+
+#endif /*_LISTHELP_H*/
diff --git a/include/linux/netfilter_ipv4/lockhelp.h b/include/linux/netfilter_ipv4/lockhelp.h
new file mode 100644
index 000000000000..a3288633ab46
--- /dev/null
+++ b/include/linux/netfilter_ipv4/lockhelp.h
@@ -0,0 +1,129 @@
+#ifndef _LOCKHELP_H
+#define _LOCKHELP_H
+#include <linux/config.h>
+
+#include <linux/spinlock.h>
+#include <asm/atomic.h>
+#include <linux/interrupt.h>
+#include <linux/smp.h>
+
+/* Header to do help in lock debugging. */
+
+#ifdef CONFIG_NETFILTER_DEBUG
+struct spinlock_debug
+{
+        spinlock_t l;
+        atomic_t locked_by;
+};
+
+struct rwlock_debug
+{
+        rwlock_t l;
+        long read_locked_map;
+        long write_locked_map;
+};
+
+#define DECLARE_LOCK(l)                                                 \
+struct spinlock_debug l = { SPIN_LOCK_UNLOCKED, ATOMIC_INIT(-1) }
+#define DECLARE_LOCK_EXTERN(l)                  \
+extern struct spinlock_debug l
+#define DECLARE_RWLOCK(l)                               \
+struct rwlock_debug l = { RW_LOCK_UNLOCKED, 0, 0 }
+#define DECLARE_RWLOCK_EXTERN(l)                \
+extern struct rwlock_debug l
+
+#define MUST_BE_LOCKED(l)                                               \
+do { if (atomic_read(&(l)->locked_by) != smp_processor_id())            \
+        printk("ASSERT %s:%u %s unlocked\n", __FILE__, __LINE__, #l);   \
+} while(0)
+
+#define MUST_BE_UNLOCKED(l)                                             \
+do { if (atomic_read(&(l)->locked_by) == smp_processor_id())            \
+        printk("ASSERT %s:%u %s locked\n", __FILE__, __LINE__, #l);     \
+} while(0)
+
+/* Write locked OK as well. */
+#define MUST_BE_READ_LOCKED(l)                                              \
+do { if (!((l)->read_locked_map & (1UL << smp_processor_id()))              \
+         && !((l)->write_locked_map & (1UL << smp_processor_id())))         \
+        printk("ASSERT %s:%u %s not readlocked\n", __FILE__, __LINE__, #l); \
+} while(0)
+
+#define MUST_BE_WRITE_LOCKED(l)                                              \
+do { if (!((l)->write_locked_map & (1UL << smp_processor_id())))             \
+        printk("ASSERT %s:%u %s not writelocked\n", __FILE__, __LINE__, #l); \
+} while(0)
+
+#define MUST_BE_READ_WRITE_UNLOCKED(l)                                    \
+do { if ((l)->read_locked_map & (1UL << smp_processor_id()))              \
+        printk("ASSERT %s:%u %s readlocked\n", __FILE__, __LINE__, #l);   \
+ else if ((l)->write_locked_map & (1UL << smp_processor_id()))            \
+         printk("ASSERT %s:%u %s writelocked\n", __FILE__, __LINE__, #l); \
+} while(0)
+
+#define LOCK_BH(lk)                                             \
+do {                                                            \
+        MUST_BE_UNLOCKED(lk);                                   \
+        spin_lock_bh(&(lk)->l);                                 \
+        atomic_set(&(lk)->locked_by, smp_processor_id());       \
+} while(0)
+
+#define UNLOCK_BH(lk)                           \
+do {                                            \
+        MUST_BE_LOCKED(lk);                     \
+        atomic_set(&(lk)->locked_by, -1);       \
+        spin_unlock_bh(&(lk)->l);               \
+} while(0)
+
+#define READ_LOCK(lk)                                           \
+do {                                                            \
+        MUST_BE_READ_WRITE_UNLOCKED(lk);                        \
+        read_lock_bh(&(lk)->l);                                 \
+        set_bit(smp_processor_id(), &(lk)->read_locked_map);    \
+} while(0)
+
+#define WRITE_LOCK(lk)                                                    \
+do {                                                                      \
+        MUST_BE_READ_WRITE_UNLOCKED(lk);                                  \
+        write_lock_bh(&(lk)->l);                                          \
+        set_bit(smp_processor_id(), &(lk)->write_locked_map);             \
+} while(0)
+
+#define READ_UNLOCK(lk)                                                 \
+do {                                                                    \
+        if (!((lk)->read_locked_map & (1UL << smp_processor_id())))     \
+                printk("ASSERT: %s:%u %s not readlocked\n",             \
+                       __FILE__, __LINE__, #lk);                        \
+        clear_bit(smp_processor_id(), &(lk)->read_locked_map);          \
+        read_unlock_bh(&(lk)->l);                                       \
+} while(0)
+
+#define WRITE_UNLOCK(lk)                                        \
+do {                                                            \
+        MUST_BE_WRITE_LOCKED(lk);                               \
+        clear_bit(smp_processor_id(), &(lk)->write_locked_map); \
+        write_unlock_bh(&(lk)->l);                              \
+} while(0)
+
+#else
+#define DECLARE_LOCK(l) spinlock_t l = SPIN_LOCK_UNLOCKED
+#define DECLARE_LOCK_EXTERN(l) extern spinlock_t l
+#define DECLARE_RWLOCK(l) rwlock_t l = RW_LOCK_UNLOCKED
+#define DECLARE_RWLOCK_EXTERN(l) extern rwlock_t l
+
+#define MUST_BE_LOCKED(l)
+#define MUST_BE_UNLOCKED(l)
+#define MUST_BE_READ_LOCKED(l)
+#define MUST_BE_WRITE_LOCKED(l)
+#define MUST_BE_READ_WRITE_UNLOCKED(l)
+
+#define LOCK_BH(l) spin_lock_bh(l)
+#define UNLOCK_BH(l) spin_unlock_bh(l)
+
+#define READ_LOCK(l) read_lock_bh(l)
+#define WRITE_LOCK(l) write_lock_bh(l)
+#define READ_UNLOCK(l) read_unlock_bh(l)
+#define WRITE_UNLOCK(l) write_unlock_bh(l)
+#endif /*CONFIG_NETFILTER_DEBUG*/
+
+#endif /* _LOCKHELP_H */
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
new file mode 100644
index 000000000000..bee7a5ec7c66
--- /dev/null
+++ b/include/linux/netfilter_ipv6.h
@@ -0,0 +1,71 @@
+#ifndef __LINUX_IP6_NETFILTER_H
+#define __LINUX_IP6_NETFILTER_H
+
+/* IPv6-specific defines for netfilter. 
+ * (C)1998 Rusty Russell -- This code is GPL.
+ * (C)1999 David Jeffery
+ *   this header was blatantly ripped from netfilter_ipv4.h 
+ *   it's amazing what adding a bunch of 6s can do =8^)
+ */
+
+#include <linux/netfilter.h>
+
+/* IP Cache bits. */
+/* Src IP address. */
+#define NFC_IP6_SRC              0x0001
+/* Dest IP address. */
+#define NFC_IP6_DST              0x0002
+/* Input device. */
+#define NFC_IP6_IF_IN            0x0004
+/* Output device. */
+#define NFC_IP6_IF_OUT           0x0008
+/* TOS. */
+#define NFC_IP6_TOS              0x0010
+/* Protocol. */
+#define NFC_IP6_PROTO            0x0020
+/* IP options. */
+#define NFC_IP6_OPTIONS          0x0040
+/* Frag & flags. */
+#define NFC_IP6_FRAG             0x0080
+
+
+/* Per-protocol information: only matters if proto match. */
+/* TCP flags. */
+#define NFC_IP6_TCPFLAGS         0x0100
+/* Source port. */
+#define NFC_IP6_SRC_PT           0x0200
+/* Dest port. */
+#define NFC_IP6_DST_PT           0x0400
+/* Something else about the proto */
+#define NFC_IP6_PROTO_UNKNOWN    0x2000
+
+
+/* IP6 Hooks */
+/* After promisc drops, checksum checks. */
+#define NF_IP6_PRE_ROUTING      0
+/* If the packet is destined for this box. */
+#define NF_IP6_LOCAL_IN         1
+/* If the packet is destined for another interface. */
+#define NF_IP6_FORWARD          2
+/* Packets coming from a local process. */
+#define NF_IP6_LOCAL_OUT                3
+/* Packets about to hit the wire. */
+#define NF_IP6_POST_ROUTING     4
+#define NF_IP6_NUMHOOKS         5
+
+
+enum nf_ip6_hook_priorities {
+        NF_IP6_PRI_FIRST = INT_MIN,
+        NF_IP6_PRI_SELINUX_FIRST = -225,
+        NF_IP6_PRI_CONNTRACK = -200,
+        NF_IP6_PRI_BRIDGE_SABOTAGE_FORWARD = -175,
+        NF_IP6_PRI_MANGLE = -150,
+        NF_IP6_PRI_NAT_DST = -100,
+        NF_IP6_PRI_BRIDGE_SABOTAGE_LOCAL_OUT = -50,
+        NF_IP6_PRI_FILTER = 0,
+        NF_IP6_PRI_NAT_SRC = 100,
+        NF_IP6_PRI_SELINUX_LAST = 225,
+        NF_IP6_PRI_LAST = INT_MAX,
+};
+
+#endif /*__LINUX_IP6_NETFILTER_H*/
diff --git a/include/linux/netfilter_ipv6/ip6_logging.h b/include/linux/netfilter_ipv6/ip6_logging.h
new file mode 100644
index 000000000000..a0b2ee3043aa
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6_logging.h
@@ -0,0 +1,20 @@
+/* IPv6 macros for the nternal logging interface. */
+#ifndef __IP6_LOGGING_H
+#define __IP6_LOGGING_H
+
+#ifdef __KERNEL__
+#include <linux/socket.h>
+#include <linux/netfilter_logging.h>
+
+#define nf_log_ip6_packet(pskb,hooknum,in,out,fmt,args...) \
+        nf_log_packet(AF_INET6,pskb,hooknum,in,out,fmt,##args)
+
+#define nf_log_ip6(pfh,len,fmt,args...) \
+        nf_log(AF_INET6,pfh,len,fmt,##args)
+
+#define nf_ip6_log_register(logging) nf_log_register(AF_INET6,logging)
+#define nf_ip6_log_unregister(logging) nf_log_unregister(AF_INET6,logging)
+        
+#endif /*__KERNEL__*/
+
+#endif /*__IP6_LOGGING_H*/
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
new file mode 100644
index 000000000000..f1ce3b009853
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -0,0 +1,461 @@
+/*
+ * 25-Jul-1998 Major changes to allow for ip chain table
+ *
+ * 3-Jan-2000 Named tables to allow packet selection for different uses.
+ */
+
+/*
+ *      Format of an IP6 firewall descriptor
+ *
+ *      src, dst, src_mask, dst_mask are always stored in network byte order.
+ *      flags are stored in host byte order (of course).
+ *      Port numbers are stored in HOST byte order.
+ */
+
+#ifndef _IP6_TABLES_H
+#define _IP6_TABLES_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#include <linux/types.h>
+#include <linux/in6.h>
+#include <linux/ipv6.h>
+#include <linux/skbuff.h>
+#endif
+#include <linux/compiler.h>
+#include <linux/netfilter_ipv6.h>
+
+#define IP6T_FUNCTION_MAXNAMELEN 30
+#define IP6T_TABLE_MAXNAMELEN 32
+
+/* Yes, Virginia, you have to zero the padding. */
+struct ip6t_ip6 {
+        /* Source and destination IP6 addr */
+        struct in6_addr src, dst;               
+        /* Mask for src and dest IP6 addr */
+        struct in6_addr smsk, dmsk;
+        char iniface[IFNAMSIZ], outiface[IFNAMSIZ];
+        unsigned char iniface_mask[IFNAMSIZ], outiface_mask[IFNAMSIZ];
+
+        /* ARGH, HopByHop uses 0, so can't do 0 = ANY,
+           instead IP6T_F_NOPROTO must be set */
+        u_int16_t proto;
+        /* TOS to match iff flags & IP6T_F_TOS */
+        u_int8_t tos;
+
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int8_t invflags;
+};
+
+/* FIXME: If alignment in kernel different from userspace? --RR */
+struct ip6t_entry_match
+{
+        union {
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used by userspace */
+                        char name[IP6T_FUNCTION_MAXNAMELEN];
+                } user;
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used inside the kernel */
+                        struct ip6t_match *match;
+                } kernel;
+
+                /* Total length */
+                u_int16_t match_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct ip6t_entry_target
+{
+        union {
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used by userspace */
+                        char name[IP6T_FUNCTION_MAXNAMELEN];
+                } user;
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used inside the kernel */
+                        struct ip6t_target *target;
+                } kernel;
+
+                /* Total length */
+                u_int16_t target_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct ip6t_standard_target
+{
+        struct ip6t_entry_target target;
+        int verdict;
+};
+
+struct ip6t_counters
+{
+        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
+};
+
+/* Values for "flag" field in struct ip6t_ip6 (general ip6 structure). */
+#define IP6T_F_PROTO            0x01    /* Set if rule cares about upper 
+                                           protocols */
+#define IP6T_F_TOS              0x02    /* Match the TOS. */
+#define IP6T_F_MASK             0x03    /* All possible flag bits mask. */
+
+/* Values for "inv" field in struct ip6t_ip6. */
+#define IP6T_INV_VIA_IN         0x01    /* Invert the sense of IN IFACE. */
+#define IP6T_INV_VIA_OUT                0x02    /* Invert the sense of OUT IFACE */
+#define IP6T_INV_TOS            0x04    /* Invert the sense of TOS. */
+#define IP6T_INV_SRCIP          0x08    /* Invert the sense of SRC IP. */
+#define IP6T_INV_DSTIP          0x10    /* Invert the sense of DST OP. */
+#define IP6T_INV_FRAG           0x20    /* Invert the sense of FRAG. */
+#define IP6T_INV_PROTO          0x40    /* Invert the sense of PROTO. */
+#define IP6T_INV_MASK           0x7F    /* All possible flag bits mask. */
+
+/* This structure defines each of the firewall rules.  Consists of 3
+   parts which are 1) general IP header stuff 2) match specific
+   stuff 3) the target to perform if the rule matches */
+struct ip6t_entry
+{
+        struct ip6t_ip6 ipv6;
+
+        /* Mark with fields that we care about. */
+        unsigned int nfcache;
+
+        /* Size of ipt_entry + matches */
+        u_int16_t target_offset;
+        /* Size of ipt_entry + matches + target */
+        u_int16_t next_offset;
+
+        /* Back pointer */
+        unsigned int comefrom;
+
+        /* Packet and byte counters. */
+        struct ip6t_counters counters;
+
+        /* The matches (if any), then the target. */
+        unsigned char elems[0];
+};
+
+/*
+ * New IP firewall options for [gs]etsockopt at the RAW IP level.
+ * Unlike BSD Linux inherits IP options so you don't have to use
+ * a raw socket for this. Instead we check rights in the calls. */
+#define IP6T_BASE_CTL                   64      /* base for firewall socket options */
+
+#define IP6T_SO_SET_REPLACE             (IP6T_BASE_CTL)
+#define IP6T_SO_SET_ADD_COUNTERS        (IP6T_BASE_CTL + 1)
+#define IP6T_SO_SET_MAX                 IP6T_SO_SET_ADD_COUNTERS
+
+#define IP6T_SO_GET_INFO                (IP6T_BASE_CTL)
+#define IP6T_SO_GET_ENTRIES             (IP6T_BASE_CTL + 1)
+#define IP6T_SO_GET_MAX                 IP6T_SO_GET_ENTRIES
+
+/* CONTINUE verdict for targets */
+#define IP6T_CONTINUE 0xFFFFFFFF
+
+/* For standard target */
+#define IP6T_RETURN (-NF_REPEAT - 1)
+
+/* TCP matching stuff */
+struct ip6t_tcp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t option;                        /* TCP Option iff non-zero*/
+        u_int8_t flg_mask;                      /* TCP flags mask byte */
+        u_int8_t flg_cmp;                       /* TCP flags compare byte */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "inv" field in struct ipt_tcp. */
+#define IP6T_TCP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
+#define IP6T_TCP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
+#define IP6T_TCP_INV_FLAGS      0x04    /* Invert the sense of TCP flags. */
+#define IP6T_TCP_INV_OPTION     0x08    /* Invert the sense of option test. */
+#define IP6T_TCP_INV_MASK       0x0F    /* All possible flags. */
+
+/* UDP matching stuff */
+struct ip6t_udp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "invflags" field in struct ipt_udp. */
+#define IP6T_UDP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
+#define IP6T_UDP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
+#define IP6T_UDP_INV_MASK       0x03    /* All possible flags. */
+
+/* ICMP matching stuff */
+struct ip6t_icmp
+{
+        u_int8_t type;                          /* type to match */
+        u_int8_t code[2];                       /* range of code */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "inv" field for struct ipt_icmp. */
+#define IP6T_ICMP_INV   0x01    /* Invert the sense of type/code test */
+
+/* The argument to IP6T_SO_GET_INFO */
+struct ip6t_getinfo
+{
+        /* Which table: caller fills this in. */
+        char name[IP6T_TABLE_MAXNAMELEN];
+
+        /* Kernel fills these in. */
+        /* Which hook entry points are valid: bitmask */
+        unsigned int valid_hooks;
+
+        /* Hook entry points: one per netfilter hook. */
+        unsigned int hook_entry[NF_IP6_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_IP6_NUMHOOKS];
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Size of entries. */
+        unsigned int size;
+};
+
+/* The argument to IP6T_SO_SET_REPLACE. */
+struct ip6t_replace
+{
+        /* Which table. */
+        char name[IP6T_TABLE_MAXNAMELEN];
+
+        /* Which hook entry points are valid: bitmask.  You can't
+           change this. */
+        unsigned int valid_hooks;
+
+        /* Number of entries */
+        unsigned int num_entries;
+
+        /* Total size of new entries */
+        unsigned int size;
+
+        /* Hook entry points. */
+        unsigned int hook_entry[NF_IP6_NUMHOOKS];
+
+        /* Underflow points. */
+        unsigned int underflow[NF_IP6_NUMHOOKS];
+
+        /* Information about old entries: */
+        /* Number of counters (must be equal to current number of entries). */
+        unsigned int num_counters;
+        /* The old entries' counters. */
+        struct ip6t_counters __user *counters;
+
+        /* The entries (hang off end: not really an array). */
+        struct ip6t_entry entries[0];
+};
+
+/* The argument to IP6T_SO_ADD_COUNTERS. */
+struct ip6t_counters_info
+{
+        /* Which table. */
+        char name[IP6T_TABLE_MAXNAMELEN];
+
+        unsigned int num_counters;
+
+        /* The counters (actually `number' of these). */
+        struct ip6t_counters counters[0];
+};
+
+/* The argument to IP6T_SO_GET_ENTRIES. */
+struct ip6t_get_entries
+{
+        /* Which table: user fills this in. */
+        char name[IP6T_TABLE_MAXNAMELEN];
+
+        /* User fills this in: total entry size. */
+        unsigned int size;
+
+        /* The entries. */
+        struct ip6t_entry entrytable[0];
+};
+
+/* Standard return verdict, or do jump. */
+#define IP6T_STANDARD_TARGET ""
+/* Error verdict. */
+#define IP6T_ERROR_TARGET "ERROR"
+
+/* Helper functions */
+static __inline__ struct ip6t_entry_target *
+ip6t_get_target(struct ip6t_entry *e)
+{
+        return (void *)e + e->target_offset;
+}
+
+/* fn returns 0 to continue iteration */
+#define IP6T_MATCH_ITERATE(e, fn, args...)      \
+({                                              \
+        unsigned int __i;                       \
+        int __ret = 0;                          \
+        struct ip6t_entry_match *__m;           \
+                                                \
+        for (__i = sizeof(struct ip6t_entry);   \
+             __i < (e)->target_offset;          \
+             __i += __m->u.match_size) {        \
+                __m = (void *)(e) + __i;        \
+                                                \
+                __ret = fn(__m , ## args);      \
+                if (__ret != 0)                 \
+                        break;                  \
+        }                                       \
+        __ret;                                  \
+})
+
+/* fn returns 0 to continue iteration */
+#define IP6T_ENTRY_ITERATE(entries, size, fn, args...)          \
+({                                                              \
+        unsigned int __i;                                       \
+        int __ret = 0;                                          \
+        struct ip6t_entry *__e;                                 \
+                                                                \
+        for (__i = 0; __i < (size); __i += __e->next_offset) {  \
+                __e = (void *)(entries) + __i;                  \
+                                                                \
+                __ret = fn(__e , ## args);                      \
+                if (__ret != 0)                                 \
+                        break;                                  \
+        }                                                       \
+        __ret;                                                  \
+})
+
+/*
+ *      Main firewall chains definitions and global var's definitions.
+ */
+
+#ifdef __KERNEL__
+
+#include <linux/init.h>
+extern void ip6t_init(void) __init;
+
+struct ip6t_match
+{
+        struct list_head list;
+
+        const char name[IP6T_FUNCTION_MAXNAMELEN];
+
+        /* Return true or false: return FALSE and set *hotdrop = 1 to
+           force immediate packet drop. */
+        /* Arguments changed since 2.6.9, as this must now handle
+           non-linear skb, using skb_header_pointer and
+           skb_ip_make_writable. */
+        int (*match)(const struct sk_buff *skb,
+                     const struct net_device *in,
+                     const struct net_device *out,
+                     const void *matchinfo,
+                     int offset,
+                     unsigned int protoff,
+                     int *hotdrop);
+
+        /* Called when user tries to insert an entry of this type. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const struct ip6t_ip6 *ip,
+                          void *matchinfo,
+                          unsigned int matchinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+/* Registration hooks for targets. */
+struct ip6t_target
+{
+        struct list_head list;
+
+        const char name[IP6T_FUNCTION_MAXNAMELEN];
+
+        /* Returns verdict. Argument order changed since 2.6.9, as this
+           must now handle non-linear skbs, using skb_copy_bits and
+           skb_ip_make_writable. */
+        unsigned int (*target)(struct sk_buff **pskb,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               unsigned int hooknum,
+                               const void *targinfo,
+                               void *userdata);
+
+        /* Called when user tries to insert an entry of this type:
+           hook_mask is a bitmask of hooks from which it can be
+           called. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const struct ip6t_entry *e,
+                          void *targinfo,
+                          unsigned int targinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *targinfo, unsigned int targinfosize);
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+extern int ip6t_register_target(struct ip6t_target *target);
+extern void ip6t_unregister_target(struct ip6t_target *target);
+
+extern int ip6t_register_match(struct ip6t_match *match);
+extern void ip6t_unregister_match(struct ip6t_match *match);
+
+/* Furniture shopping... */
+struct ip6t_table
+{
+        struct list_head list;
+
+        /* A unique name... */
+        char name[IP6T_TABLE_MAXNAMELEN];
+
+        /* What hooks you will enter on */
+        unsigned int valid_hooks;
+
+        /* Lock for the curtain */
+        rwlock_t lock;
+
+        /* Man behind the curtain... */
+        struct ip6t_table_info *private;
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+extern int ip6t_register_table(struct ip6t_table *table,
+                               const struct ip6t_replace *repl);
+extern void ip6t_unregister_table(struct ip6t_table *table);
+extern unsigned int ip6t_do_table(struct sk_buff **pskb,
+                                  unsigned int hook,
+                                  const struct net_device *in,
+                                  const struct net_device *out,
+                                  struct ip6t_table *table,
+                                  void *userdata);
+
+/* Check for an extension */
+extern int ip6t_ext_hdr(u8 nexthdr);
+
+#define IP6T_ALIGN(s) (((s) + (__alignof__(struct ip6t_entry)-1)) & ~(__alignof__(struct ip6t_entry)-1))
+
+#endif /*__KERNEL__*/
+#endif /* _IP6_TABLES_H */
diff --git a/include/linux/netfilter_ipv6/ip6t_LOG.h b/include/linux/netfilter_ipv6/ip6t_LOG.h
new file mode 100644
index 000000000000..42996a43bb39
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_LOG.h
@@ -0,0 +1,16 @@
+#ifndef _IP6T_LOG_H
+#define _IP6T_LOG_H
+
+#define IP6T_LOG_TCPSEQ         0x01    /* Log TCP sequence numbers */
+#define IP6T_LOG_TCPOPT         0x02    /* Log TCP options */
+#define IP6T_LOG_IPOPT          0x04    /* Log IP options */
+#define IP6T_LOG_UID            0x08    /* Log UID owning local socket */
+#define IP6T_LOG_MASK           0x0f
+
+struct ip6t_log_info {
+        unsigned char level;
+        unsigned char logflags;
+        char prefix[30];
+};
+
+#endif /*_IPT_LOG_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_MARK.h b/include/linux/netfilter_ipv6/ip6t_MARK.h
new file mode 100644
index 000000000000..7ade8d8f5246
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_MARK.h
@@ -0,0 +1,8 @@
+#ifndef _IP6T_MARK_H_target
+#define _IP6T_MARK_H_target
+
+struct ip6t_mark_target_info {
+        unsigned long mark;
+};
+
+#endif /*_IPT_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv6/ip6t_ah.h b/include/linux/netfilter_ipv6/ip6t_ah.h
new file mode 100644
index 000000000000..c4f0793a0a98
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_ah.h
@@ -0,0 +1,30 @@
+#ifndef _IP6T_AH_H
+#define _IP6T_AH_H
+
+struct ip6t_ah
+{
+        u_int32_t spis[2];                      /* Security Parameter Index */
+        u_int32_t hdrlen;                       /* Header Length */
+        u_int8_t  hdrres;                       /* Test of the Reserved Filed */
+        u_int8_t  invflags;                     /* Inverse flags */
+};
+
+#define IP6T_AH_SPI 0x01
+#define IP6T_AH_LEN 0x02
+#define IP6T_AH_RES 0x04
+
+/* Values for "invflags" field in struct ip6t_ah. */
+#define IP6T_AH_INV_SPI         0x01    /* Invert the sense of spi. */
+#define IP6T_AH_INV_LEN         0x02    /* Invert the sense of length. */
+#define IP6T_AH_INV_MASK        0x03    /* All possible flags. */
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /*_IP6T_AH_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_esp.h b/include/linux/netfilter_ipv6/ip6t_esp.h
new file mode 100644
index 000000000000..01142b98a231
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_esp.h
@@ -0,0 +1,23 @@
+#ifndef _IP6T_ESP_H
+#define _IP6T_ESP_H
+
+struct ip6t_esp
+{
+        u_int32_t spis[2];                      /* Security Parameter Index */
+        u_int8_t  invflags;                     /* Inverse flags */
+};
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+/* Values for "invflags" field in struct ip6t_esp. */
+#define IP6T_ESP_INV_SPI                0x01    /* Invert the sense of spi. */
+#define IP6T_ESP_INV_MASK       0x01    /* All possible flags. */
+
+#endif /*_IP6T_ESP_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_frag.h b/include/linux/netfilter_ipv6/ip6t_frag.h
new file mode 100644
index 000000000000..449a57eca7dd
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_frag.h
@@ -0,0 +1,33 @@
+#ifndef _IP6T_FRAG_H
+#define _IP6T_FRAG_H
+
+struct ip6t_frag
+{
+        u_int32_t ids[2];                       /* Security Parameter Index */
+        u_int32_t hdrlen;                       /* Header Length */
+        u_int8_t  flags;                        /*  */
+        u_int8_t  invflags;                     /* Inverse flags */
+};
+
+#define IP6T_FRAG_IDS           0x01
+#define IP6T_FRAG_LEN           0x02
+#define IP6T_FRAG_RES           0x04
+#define IP6T_FRAG_FST           0x08
+#define IP6T_FRAG_MF            0x10
+#define IP6T_FRAG_NMF           0x20
+
+/* Values for "invflags" field in struct ip6t_frag. */
+#define IP6T_FRAG_INV_IDS       0x01    /* Invert the sense of ids. */
+#define IP6T_FRAG_INV_LEN       0x02    /* Invert the sense of length. */
+#define IP6T_FRAG_INV_MASK      0x03    /* All possible flags. */
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /*_IP6T_FRAG_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_hl.h b/include/linux/netfilter_ipv6/ip6t_hl.h
new file mode 100644
index 000000000000..5ef91b8319a8
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_hl.h
@@ -0,0 +1,22 @@
+/* ip6tables module for matching the Hop Limit value
+ * Maciej Soltysiak <solt@dns.toxicfilms.tv>
+ * Based on HW's ttl module */
+
+#ifndef _IP6T_HL_H
+#define _IP6T_HL_H
+
+enum {
+        IP6T_HL_EQ = 0,         /* equals */
+        IP6T_HL_NE,             /* not equals */
+        IP6T_HL_LT,             /* less than */
+        IP6T_HL_GT,             /* greater than */
+};
+
+
+struct ip6t_hl_info {
+        u_int8_t        mode;
+        u_int8_t        hop_limit;
+};
+
+
+#endif
diff --git a/include/linux/netfilter_ipv6/ip6t_ipv6header.h b/include/linux/netfilter_ipv6/ip6t_ipv6header.h
new file mode 100644
index 000000000000..51c53fc9c44a
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_ipv6header.h
@@ -0,0 +1,27 @@
+/* ipv6header match - matches IPv6 packets based
+on whether they contain certain headers */
+
+/* Original idea: Brad Chapman 
+ * Rewritten by: Andras Kis-Szabo <kisza@sch.bme.hu> */
+
+
+#ifndef __IPV6HEADER_H
+#define __IPV6HEADER_H
+
+struct ip6t_ipv6header_info
+{
+        u_int8_t matchflags;
+        u_int8_t invflags;
+        u_int8_t modeflag;
+};
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /* __IPV6HEADER_H */
diff --git a/include/linux/netfilter_ipv6/ip6t_length.h b/include/linux/netfilter_ipv6/ip6t_length.h
new file mode 100644
index 000000000000..7fc09f9f9d63
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_length.h
@@ -0,0 +1,10 @@
+#ifndef _IP6T_LENGTH_H
+#define _IP6T_LENGTH_H
+
+struct ip6t_length_info {
+        u_int16_t  min, max;
+        u_int8_t   invert;
+};
+
+#endif /*_IP6T_LENGTH_H*/
+        
diff --git a/include/linux/netfilter_ipv6/ip6t_limit.h b/include/linux/netfilter_ipv6/ip6t_limit.h
new file mode 100644
index 000000000000..f2866e50f3b4
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_limit.h
@@ -0,0 +1,21 @@
+#ifndef _IP6T_RATE_H
+#define _IP6T_RATE_H
+
+/* timings are in milliseconds. */
+#define IP6T_LIMIT_SCALE 10000
+
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+struct ip6t_rateinfo {
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+
+        /* Used internally by the kernel */
+        unsigned long prev;
+        u_int32_t credit;
+        u_int32_t credit_cap, cost;
+
+        /* Ugly, ugly fucker. */
+        struct ip6t_rateinfo *master;
+};
+#endif /*_IPT_RATE_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mac.h b/include/linux/netfilter_ipv6/ip6t_mac.h
new file mode 100644
index 000000000000..87c088c21848
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_mac.h
@@ -0,0 +1,8 @@
+#ifndef _IP6T_MAC_H
+#define _IP6T_MAC_H
+
+struct ip6t_mac_info {
+    unsigned char srcaddr[ETH_ALEN];
+    int invert;
+};
+#endif /*_IPT_MAC_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mark.h b/include/linux/netfilter_ipv6/ip6t_mark.h
new file mode 100644
index 000000000000..a734441e1c19
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_mark.h
@@ -0,0 +1,9 @@
+#ifndef _IP6T_MARK_H
+#define _IP6T_MARK_H
+
+struct ip6t_mark_info {
+    unsigned long mark, mask;
+    u_int8_t invert;
+};
+
+#endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_multiport.h b/include/linux/netfilter_ipv6/ip6t_multiport.h
new file mode 100644
index 000000000000..efe4954a8681
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_multiport.h
@@ -0,0 +1,21 @@
+#ifndef _IP6T_MULTIPORT_H
+#define _IP6T_MULTIPORT_H
+#include <linux/netfilter_ipv6/ip6_tables.h>
+
+enum ip6t_multiport_flags
+{
+        IP6T_MULTIPORT_SOURCE,
+        IP6T_MULTIPORT_DESTINATION,
+        IP6T_MULTIPORT_EITHER
+};
+
+#define IP6T_MULTI_PORTS        15
+
+/* Must fit inside union ip6t_matchinfo: 16 bytes */
+struct ip6t_multiport
+{
+        u_int8_t flags;                         /* Type of comparison */
+        u_int8_t count;                         /* Number of ports */
+        u_int16_t ports[IP6T_MULTI_PORTS];      /* Ports */
+};
+#endif /*_IPT_MULTIPORT_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_opts.h b/include/linux/netfilter_ipv6/ip6t_opts.h
new file mode 100644
index 000000000000..e259b6275bd2
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_opts.h
@@ -0,0 +1,32 @@
+#ifndef _IP6T_OPTS_H
+#define _IP6T_OPTS_H
+
+#define IP6T_OPTS_OPTSNR 16
+
+struct ip6t_opts
+{
+        u_int32_t hdrlen;                       /* Header Length */
+        u_int8_t flags;                         /*  */
+        u_int8_t invflags;                      /* Inverse flags */
+        u_int16_t opts[IP6T_OPTS_OPTSNR];       /* opts */
+        u_int8_t optsnr;                        /* Nr of OPts */
+};
+
+#define IP6T_OPTS_LEN           0x01
+#define IP6T_OPTS_OPTS          0x02
+#define IP6T_OPTS_NSTRICT       0x04
+
+/* Values for "invflags" field in struct ip6t_rt. */
+#define IP6T_OPTS_INV_LEN       0x01    /* Invert the sense of length. */
+#define IP6T_OPTS_INV_MASK      0x01    /* All possible flags. */
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /*_IP6T_OPTS_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_owner.h b/include/linux/netfilter_ipv6/ip6t_owner.h
new file mode 100644
index 000000000000..19937da3d101
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_owner.h
@@ -0,0 +1,18 @@
+#ifndef _IP6T_OWNER_H
+#define _IP6T_OWNER_H
+
+/* match and invert flags */
+#define IP6T_OWNER_UID  0x01
+#define IP6T_OWNER_GID  0x02
+#define IP6T_OWNER_PID  0x04
+#define IP6T_OWNER_SID  0x08
+
+struct ip6t_owner_info {
+    uid_t uid;
+    gid_t gid;
+    pid_t pid;
+    pid_t sid;
+    u_int8_t match, invert;     /* flags */
+};
+
+#endif /*_IPT_OWNER_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_physdev.h b/include/linux/netfilter_ipv6/ip6t_physdev.h
new file mode 100644
index 000000000000..c234731cd66b
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_physdev.h
@@ -0,0 +1,24 @@
+#ifndef _IP6T_PHYSDEV_H
+#define _IP6T_PHYSDEV_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#endif
+
+#define IP6T_PHYSDEV_OP_IN              0x01
+#define IP6T_PHYSDEV_OP_OUT             0x02
+#define IP6T_PHYSDEV_OP_BRIDGED         0x04
+#define IP6T_PHYSDEV_OP_ISIN            0x08
+#define IP6T_PHYSDEV_OP_ISOUT           0x10
+#define IP6T_PHYSDEV_OP_MASK            (0x20 - 1)
+
+struct ip6t_physdev_info {
+        char physindev[IFNAMSIZ];
+        char in_mask[IFNAMSIZ];
+        char physoutdev[IFNAMSIZ];
+        char out_mask[IFNAMSIZ];
+        u_int8_t invert;
+        u_int8_t bitmask;
+};
+
+#endif /*_IP6T_PHYSDEV_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_rt.h b/include/linux/netfilter_ipv6/ip6t_rt.h
new file mode 100644
index 000000000000..f1070fbf2757
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_rt.h
@@ -0,0 +1,42 @@
+#ifndef _IP6T_RT_H
+#define _IP6T_RT_H
+
+/*#include <linux/in6.h>*/
+
+#define IP6T_RT_HOPS 16
+
+struct ip6t_rt
+{
+        u_int32_t rt_type;                      /* Routing Type */
+        u_int32_t segsleft[2];                  /* Segments Left */
+        u_int32_t hdrlen;                       /* Header Length */
+        u_int8_t  flags;                        /*  */
+        u_int8_t  invflags;                     /* Inverse flags */
+        struct in6_addr addrs[IP6T_RT_HOPS];    /* Hops */
+        u_int8_t addrnr;                        /* Nr of Addresses */
+};
+
+#define IP6T_RT_TYP             0x01
+#define IP6T_RT_SGS             0x02
+#define IP6T_RT_LEN             0x04
+#define IP6T_RT_RES             0x08
+#define IP6T_RT_FST_MASK        0x30
+#define IP6T_RT_FST             0x10
+#define IP6T_RT_FST_NSTRICT     0x20
+
+/* Values for "invflags" field in struct ip6t_rt. */
+#define IP6T_RT_INV_TYP         0x01    /* Invert the sense of type. */
+#define IP6T_RT_INV_SGS         0x02    /* Invert the sense of Segments. */
+#define IP6T_RT_INV_LEN         0x04    /* Invert the sense of length. */
+#define IP6T_RT_INV_MASK        0x07    /* All possible flags. */
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /*_IP6T_RT_H*/
diff --git a/include/linux/netfilter_logging.h b/include/linux/netfilter_logging.h
new file mode 100644
index 000000000000..562bb6aad4e1
--- /dev/null
+++ b/include/linux/netfilter_logging.h
@@ -0,0 +1,33 @@
+/* Internal logging interface, which relies on the real 
+   LOG target modules */
+#ifndef __LINUX_NETFILTER_LOGGING_H
+#define __LINUX_NETFILTER_LOGGING_H
+
+#ifdef __KERNEL__
+#include <asm/atomic.h>
+
+struct nf_logging_t {
+        void (*nf_log_packet)(struct sk_buff **pskb,
+                              unsigned int hooknum,
+                              const struct net_device *in,
+                              const struct net_device *out,
+                              const char *prefix);
+        void (*nf_log)(char *pfh, size_t len,
+                       const char *prefix);
+};
+
+extern void nf_log_register(int pf, const struct nf_logging_t *logging);
+extern void nf_log_unregister(int pf, const struct nf_logging_t *logging);
+
+extern void nf_log_packet(int pf,
+                          struct sk_buff **pskb,
+                          unsigned int hooknum,
+                          const struct net_device *in,
+                          const struct net_device *out,
+                          const char *fmt, ...);
+extern void nf_log(int pf,
+                   char *pfh, size_t len,
+                   const char *fmt, ...);
+#endif /*__KERNEL__*/
+
+#endif /*__LINUX_NETFILTER_LOGGING_H*/
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
new file mode 100644
index 000000000000..f731abdc1a29
--- /dev/null
+++ b/include/linux/netlink.h
@@ -0,0 +1,188 @@
+#ifndef __LINUX_NETLINK_H
+#define __LINUX_NETLINK_H
+
+#include <linux/socket.h> /* for sa_family_t */
+#include <linux/types.h>
+
+#define NETLINK_ROUTE           0       /* Routing/device hook                          */
+#define NETLINK_SKIP            1       /* Reserved for ENskip                          */
+#define NETLINK_USERSOCK        2       /* Reserved for user mode socket protocols      */
+#define NETLINK_FIREWALL        3       /* Firewalling hook                             */
+#define NETLINK_TCPDIAG         4       /* TCP socket monitoring                        */
+#define NETLINK_NFLOG           5       /* netfilter/iptables ULOG */
+#define NETLINK_XFRM            6       /* ipsec */
+#define NETLINK_SELINUX         7       /* SELinux event notifications */
+#define NETLINK_ARPD            8
+#define NETLINK_AUDIT           9       /* auditing */
+#define NETLINK_ROUTE6          11      /* af_inet6 route comm channel */
+#define NETLINK_IP6_FW          13
+#define NETLINK_DNRTMSG         14      /* DECnet routing messages */
+#define NETLINK_KOBJECT_UEVENT  15      /* Kernel messages to userspace */
+#define NETLINK_TAPBASE         16      /* 16 to 31 are ethertap */
+
+#define MAX_LINKS 32            
+
+struct sockaddr_nl
+{
+        sa_family_t     nl_family;      /* AF_NETLINK   */
+        unsigned short  nl_pad;         /* zero         */
+        __u32           nl_pid;         /* process pid  */
+        __u32           nl_groups;      /* multicast groups mask */
+};
+
+struct nlmsghdr
+{
+        __u32           nlmsg_len;      /* Length of message including header */
+        __u16           nlmsg_type;     /* Message content */
+        __u16           nlmsg_flags;    /* Additional flags */
+        __u32           nlmsg_seq;      /* Sequence number */
+        __u32           nlmsg_pid;      /* Sending process PID */
+};
+
+/* Flags values */
+
+#define NLM_F_REQUEST           1       /* It is request message.       */
+#define NLM_F_MULTI             2       /* Multipart message, terminated by NLMSG_DONE */
+#define NLM_F_ACK               4       /* Reply with ack, with zero or error code */
+#define NLM_F_ECHO              8       /* Echo this request            */
+
+/* Modifiers to GET request */
+#define NLM_F_ROOT      0x100   /* specify tree root    */
+#define NLM_F_MATCH     0x200   /* return all matching  */
+#define NLM_F_ATOMIC    0x400   /* atomic GET           */
+#define NLM_F_DUMP      (NLM_F_ROOT|NLM_F_MATCH)
+
+/* Modifiers to NEW request */
+#define NLM_F_REPLACE   0x100   /* Override existing            */
+#define NLM_F_EXCL      0x200   /* Do not touch, if it exists   */
+#define NLM_F_CREATE    0x400   /* Create, if it does not exist */
+#define NLM_F_APPEND    0x800   /* Add to end of list           */
+
+/*
+   4.4BSD ADD           NLM_F_CREATE|NLM_F_EXCL
+   4.4BSD CHANGE        NLM_F_REPLACE
+
+   True CHANGE          NLM_F_CREATE|NLM_F_REPLACE
+   Append               NLM_F_CREATE
+   Check                NLM_F_EXCL
+ */
+
+#define NLMSG_ALIGNTO   4
+#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
+#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))
+#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))
+#define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))
+#define NLMSG_NEXT(nlh,len)      ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
+                                  (struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
+#define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
+                           (nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
+                           (nlh)->nlmsg_len <= (len))
+#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))
+
+#define NLMSG_NOOP              0x1     /* Nothing.             */
+#define NLMSG_ERROR             0x2     /* Error                */
+#define NLMSG_DONE              0x3     /* End of a dump        */
+#define NLMSG_OVERRUN           0x4     /* Data lost            */
+
+struct nlmsgerr
+{
+        int             error;
+        struct nlmsghdr msg;
+};
+
+#define NET_MAJOR 36            /* Major 36 is reserved for networking                                          */
+
+enum {
+        NETLINK_UNCONNECTED = 0,
+        NETLINK_CONNECTED,
+};
+
+#ifdef __KERNEL__
+
+#include <linux/capability.h>
+#include <linux/skbuff.h>
+
+struct netlink_skb_parms
+{
+        struct ucred            creds;          /* Skb credentials      */
+        __u32                   pid;
+        __u32                   groups;
+        __u32                   dst_pid;
+        __u32                   dst_groups;
+        kernel_cap_t            eff_cap;
+};
+
+#define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))
+#define NETLINK_CREDS(skb)      (&NETLINK_CB((skb)).creds)
+
+
+extern struct sock *netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len));
+extern void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err);
+extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
+extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 pid,
+                             __u32 group, int allocation);
+extern void netlink_set_err(struct sock *ssk, __u32 pid, __u32 group, int code);
+extern int netlink_register_notifier(struct notifier_block *nb);
+extern int netlink_unregister_notifier(struct notifier_block *nb);
+
+/* finegrained unicast helpers: */
+struct sock *netlink_getsockbyfilp(struct file *filp);
+int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long timeo);
+void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
+int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol);
+
+/*
+ *      skb should fit one page. This choice is good for headerless malloc.
+ */
+#define NLMSG_GOODORDER 0
+#define NLMSG_GOODSIZE (SKB_MAX_ORDER(0, NLMSG_GOODORDER))
+
+
+struct netlink_callback
+{
+        struct sk_buff  *skb;
+        struct nlmsghdr *nlh;
+        int             (*dump)(struct sk_buff * skb, struct netlink_callback *cb);
+        int             (*done)(struct netlink_callback *cb);
+        int             family;
+        long            args[4];
+};
+
+struct netlink_notify
+{
+        int pid;
+        int protocol;
+};
+
+static __inline__ struct nlmsghdr *
+__nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len)
+{
+        struct nlmsghdr *nlh;
+        int size = NLMSG_LENGTH(len);
+
+        nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
+        nlh->nlmsg_type = type;
+        nlh->nlmsg_len = size;
+        nlh->nlmsg_flags = 0;
+        nlh->nlmsg_pid = pid;
+        nlh->nlmsg_seq = seq;
+        return nlh;
+}
+
+#define NLMSG_PUT(skb, pid, seq, type, len) \
+({ if (skb_tailroom(skb) < (int)NLMSG_SPACE(len)) goto nlmsg_failure; \
+   __nlmsg_put(skb, pid, seq, type, len); })
+
+extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
+                              struct nlmsghdr *nlh,
+                              int (*dump)(struct sk_buff *skb, struct netlink_callback*),
+                              int (*done)(struct netlink_callback*));
+
+
+#define NL_NONROOT_RECV 0x1
+#define NL_NONROOT_SEND 0x2
+extern void netlink_set_nonroot(int protocol, unsigned flag);
+
+#endif /* __KERNEL__ */
+
+#endif  /* __LINUX_NETLINK_H */
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
new file mode 100644
index 000000000000..c0d8b90c5202
--- /dev/null
+++ b/include/linux/netpoll.h
@@ -0,0 +1,67 @@
+/*
+ * Common code for low-level network console, dump, and debugger code
+ *
+ * Derived from netconsole, kgdb-over-ethernet, and netdump patches
+ */
+
+#ifndef _LINUX_NETPOLL_H
+#define _LINUX_NETPOLL_H
+
+#include <linux/netdevice.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+
+struct netpoll;
+
+struct netpoll {
+        struct net_device *dev;
+        char dev_name[16], *name;
+        int rx_flags;
+        void (*rx_hook)(struct netpoll *, int, char *, int);
+        void (*drop)(struct sk_buff *skb);
+        u32 local_ip, remote_ip;
+        u16 local_port, remote_port;
+        unsigned char local_mac[6], remote_mac[6];
+        spinlock_t poll_lock;
+        int poll_owner;
+};
+
+void netpoll_poll(struct netpoll *np);
+void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
+int netpoll_parse_options(struct netpoll *np, char *opt);
+int netpoll_setup(struct netpoll *np);
+int netpoll_trap(void);
+void netpoll_set_trap(int trap);
+void netpoll_cleanup(struct netpoll *np);
+int __netpoll_rx(struct sk_buff *skb);
+void netpoll_queue(struct sk_buff *skb);
+
+#ifdef CONFIG_NETPOLL
+static inline int netpoll_rx(struct sk_buff *skb)
+{
+        return skb->dev->np && skb->dev->np->rx_flags && __netpoll_rx(skb);
+}
+
+static inline void netpoll_poll_lock(struct net_device *dev)
+{
+        if (dev->np) {
+                spin_lock(&dev->np->poll_lock);
+                dev->np->poll_owner = smp_processor_id();
+        }
+}
+
+static inline void netpoll_poll_unlock(struct net_device *dev)
+{
+        if (dev->np) {
+                spin_unlock(&dev->np->poll_lock);
+                dev->np->poll_owner = -1;
+        }
+}
+
+#else
+#define netpoll_rx(a) 0
+#define netpoll_poll_lock(a)
+#define netpoll_poll_unlock(a)
+#endif
+
+#endif
diff --git a/include/linux/netrom.h b/include/linux/netrom.h
new file mode 100644
index 000000000000..6939b32f66a0
--- /dev/null
+++ b/include/linux/netrom.h
@@ -0,0 +1,34 @@
+/*
+ * These are the public elements of the Linux kernel NET/ROM implementation.
+ * For kernel AX.25 see the file ax25.h. This file requires ax25.h for the
+ * definition of the ax25_address structure.
+ */
+
+#ifndef NETROM_KERNEL_H
+#define NETROM_KERNEL_H
+
+#define NETROM_MTU      236
+
+#define NETROM_T1       1
+#define NETROM_T2       2
+#define NETROM_N2       3
+#define NETROM_T4       6
+#define NETROM_IDLE     7
+
+#define SIOCNRDECOBS            (SIOCPROTOPRIVATE+2)
+
+struct nr_route_struct {
+#define NETROM_NEIGH    0
+#define NETROM_NODE     1
+        int             type;
+        ax25_address    callsign;
+        char            device[16];
+        unsigned int    quality;
+        char            mnemonic[7];
+        ax25_address    neighbour;
+        unsigned int    obs_count;
+        unsigned int    ndigis;
+        ax25_address    digipeaters[AX25_MAX_DIGIS];
+};
+
+#endif
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
new file mode 100644
index 000000000000..ca2ffa6ae1d5
--- /dev/null
+++ b/include/linux/nfs.h
@@ -0,0 +1,171 @@
+/*
+ * NFS protocol definitions
+ *
+ * This file contains constants mostly for Version 2 of the protocol,
+ * but also has a couple of NFSv3 bits in (notably the error codes).
+ */
+#ifndef _LINUX_NFS_H
+#define _LINUX_NFS_H
+
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/string.h>
+
+#define NFS_PROGRAM     100003
+#define NFS_PORT        2049
+#define NFS_MAXDATA     8192
+#define NFS_MAXPATHLEN  1024
+#define NFS_MAXNAMLEN   255
+#define NFS_MAXGROUPS   16
+#define NFS_FHSIZE      32
+#define NFS_COOKIESIZE  4
+#define NFS_FIFO_DEV    (-1)
+#define NFSMODE_FMT     0170000
+#define NFSMODE_DIR     0040000
+#define NFSMODE_CHR     0020000
+#define NFSMODE_BLK     0060000
+#define NFSMODE_REG     0100000
+#define NFSMODE_LNK     0120000
+#define NFSMODE_SOCK    0140000
+#define NFSMODE_FIFO    0010000
+
+#define NFS_MNT_PROGRAM 100005
+#define NFS_MNT_PORT    627
+
+/*
+ * NFS stats. The good thing with these values is that NFSv3 errors are
+ * a superset of NFSv2 errors (with the exception of NFSERR_WFLUSH which
+ * no-one uses anyway), so we can happily mix code as long as we make sure
+ * no NFSv3 errors are returned to NFSv2 clients.
+ * Error codes that have a `--' in the v2 column are not part of the
+ * standard, but seem to be widely used nevertheless.
+ */
+ enum nfs_stat {
+        NFS_OK = 0,                     /* v2 v3 v4 */
+        NFSERR_PERM = 1,                /* v2 v3 v4 */
+        NFSERR_NOENT = 2,               /* v2 v3 v4 */
+        NFSERR_IO = 5,                  /* v2 v3 v4 */
+        NFSERR_NXIO = 6,                /* v2 v3 v4 */
+        NFSERR_EAGAIN = 11,             /* v2 v3 */
+        NFSERR_ACCES = 13,              /* v2 v3 v4 */
+        NFSERR_EXIST = 17,              /* v2 v3 v4 */
+        NFSERR_XDEV = 18,               /*    v3 v4 */
+        NFSERR_NODEV = 19,              /* v2 v3 v4 */
+        NFSERR_NOTDIR = 20,             /* v2 v3 v4 */
+        NFSERR_ISDIR = 21,              /* v2 v3 v4 */
+        NFSERR_INVAL = 22,              /* v2 v3 v4 */
+        NFSERR_FBIG = 27,               /* v2 v3 v4 */
+        NFSERR_NOSPC = 28,              /* v2 v3 v4 */
+        NFSERR_ROFS = 30,               /* v2 v3 v4 */
+        NFSERR_MLINK = 31,              /*    v3 v4 */
+        NFSERR_OPNOTSUPP = 45,          /* v2 v3 */
+        NFSERR_NAMETOOLONG = 63,        /* v2 v3 v4 */
+        NFSERR_NOTEMPTY = 66,           /* v2 v3 v4 */
+        NFSERR_DQUOT = 69,              /* v2 v3 v4 */
+        NFSERR_STALE = 70,              /* v2 v3 v4 */
+        NFSERR_REMOTE = 71,             /* v2 v3 */
+        NFSERR_WFLUSH = 99,             /* v2    */
+        NFSERR_BADHANDLE = 10001,       /*    v3 v4 */
+        NFSERR_NOT_SYNC = 10002,        /*    v3 */
+        NFSERR_BAD_COOKIE = 10003,      /*    v3 v4 */
+        NFSERR_NOTSUPP = 10004,         /*    v3 v4 */
+        NFSERR_TOOSMALL = 10005,        /*    v3 v4 */
+        NFSERR_SERVERFAULT = 10006,     /*    v3 v4 */
+        NFSERR_BADTYPE = 10007,         /*    v3 v4 */
+        NFSERR_JUKEBOX = 10008,         /*    v3 v4 */
+        NFSERR_SAME = 10009,            /*       v4 */
+        NFSERR_DENIED = 10010,          /*       v4 */
+        NFSERR_EXPIRED = 10011,         /*       v4 */
+        NFSERR_LOCKED = 10012,          /*       v4 */
+        NFSERR_GRACE = 10013,           /*       v4 */
+        NFSERR_FHEXPIRED = 10014,       /*       v4 */
+        NFSERR_SHARE_DENIED = 10015,    /*       v4 */
+        NFSERR_WRONGSEC = 10016,        /*       v4 */
+        NFSERR_CLID_INUSE = 10017,      /*       v4 */
+        NFSERR_RESOURCE = 10018,        /*       v4 */
+        NFSERR_MOVED = 10019,           /*       v4 */
+        NFSERR_NOFILEHANDLE = 10020,    /*       v4 */
+        NFSERR_MINOR_VERS_MISMATCH = 10021,   /* v4 */
+        NFSERR_STALE_CLIENTID = 10022,  /*       v4 */
+        NFSERR_STALE_STATEID = 10023,   /*       v4 */
+        NFSERR_OLD_STATEID = 10024,     /*       v4 */
+        NFSERR_BAD_STATEID = 10025,     /*       v4 */  
+        NFSERR_BAD_SEQID = 10026,       /*       v4 */
+        NFSERR_NOT_SAME = 10027,        /*       v4 */
+        NFSERR_LOCK_RANGE = 10028,      /*       v4 */
+        NFSERR_SYMLINK = 10029,         /*       v4 */
+        NFSERR_RESTOREFH = 10030,       /*       v4 */
+        NFSERR_LEASE_MOVED = 10031,     /*       v4 */
+        NFSERR_ATTRNOTSUPP = 10032,     /*       v4 */
+        NFSERR_NO_GRACE = 10033,        /*       v4 */
+        NFSERR_RECLAIM_BAD = 10034,     /*       v4 */
+        NFSERR_RECLAIM_CONFLICT = 10035,/*       v4 */
+        NFSERR_BAD_XDR = 10036,         /*       v4 */
+        NFSERR_LOCKS_HELD = 10037,      /*       v4 */
+        NFSERR_OPENMODE = 10038,       /*       v4 */
+        NFSERR_BADOWNER = 10039,       /*       v4 */
+        NFSERR_BADCHAR = 10040,        /*       v4 */
+        NFSERR_BADNAME = 10041,        /*       v4 */
+        NFSERR_BAD_RANGE = 10042,      /*       v4 */
+        NFSERR_LOCK_NOTSUPP = 10043,   /*       v4 */
+        NFSERR_OP_ILLEGAL = 10044,     /*       v4 */
+        NFSERR_DEADLOCK = 10045,       /*       v4 */
+        NFSERR_FILE_OPEN = 10046,      /*       v4 */
+        NFSERR_ADMIN_REVOKED = 10047,  /*       v4 */
+        NFSERR_CB_PATH_DOWN = 10048,   /*       v4 */
+        NFSERR_REPLAY_ME = 10049        /*       v4 */
+};
+
+/* NFSv2 file types - beware, these are not the same in NFSv3 */
+
+enum nfs_ftype {
+        NFNON = 0,
+        NFREG = 1,
+        NFDIR = 2,
+        NFBLK = 3,
+        NFCHR = 4,
+        NFLNK = 5,
+        NFSOCK = 6,
+        NFBAD = 7,
+        NFFIFO = 8
+};
+
+#if defined(__KERNEL__)
+/*
+ * This is the kernel NFS client file handle representation
+ */
+#define NFS_MAXFHSIZE           128
+struct nfs_fh {
+        unsigned short          size;
+        unsigned char           data[NFS_MAXFHSIZE];
+};
+
+/*
+ * Returns a zero iff the size and data fields match.
+ * Checks only "size" bytes in the data field.
+ */
+static inline int nfs_compare_fh(const struct nfs_fh *a, const struct nfs_fh *b)
+{
+        return a->size != b->size || memcmp(a->data, b->data, a->size) != 0;
+}
+
+static inline void nfs_copy_fh(struct nfs_fh *target, const struct nfs_fh *source)
+{
+        target->size = source->size;
+        memcpy(target->data, source->data, source->size);
+}
+
+
+/*
+ * This is really a general kernel constant, but since nothing like
+ * this is defined in the kernel headers, I have to do it here.
+ */
+#define NFS_OFFSET_MAX          ((__s64)((~(__u64)0) >> 1))
+
+
+enum nfs3_stable_how {
+        NFS_UNSTABLE = 0,
+        NFS_DATA_SYNC = 1,
+        NFS_FILE_SYNC = 2
+};
+#endif /* __KERNEL__ */
+#endif /* _LINUX_NFS_H */
diff --git a/include/linux/nfs2.h b/include/linux/nfs2.h
new file mode 100644
index 000000000000..0ed9517138fc
--- /dev/null
+++ b/include/linux/nfs2.h
@@ -0,0 +1,74 @@
+/*
+ * NFS protocol definitions
+ *
+ * This file contains constants for Version 2 of the protocol.
+ */
+#ifndef _LINUX_NFS2_H
+#define _LINUX_NFS2_H
+
+#define NFS2_PORT       2049
+#define NFS2_MAXDATA    8192
+#define NFS2_MAXPATHLEN 1024
+#define NFS2_MAXNAMLEN  255
+#define NFS2_MAXGROUPS  16
+#define NFS2_FHSIZE     32
+#define NFS2_COOKIESIZE 4
+#define NFS2_FIFO_DEV   (-1)
+#define NFS2MODE_FMT    0170000
+#define NFS2MODE_DIR    0040000
+#define NFS2MODE_CHR    0020000
+#define NFS2MODE_BLK    0060000
+#define NFS2MODE_REG    0100000
+#define NFS2MODE_LNK    0120000
+#define NFS2MODE_SOCK   0140000
+#define NFS2MODE_FIFO   0010000
+
+
+/* NFSv2 file types - beware, these are not the same in NFSv3 */
+enum nfs2_ftype {
+        NF2NON = 0,
+        NF2REG = 1,
+        NF2DIR = 2,
+        NF2BLK = 3,
+        NF2CHR = 4,
+        NF2LNK = 5,
+        NF2SOCK = 6,
+        NF2BAD = 7,
+        NF2FIFO = 8
+};
+
+struct nfs2_fh {
+        char                    data[NFS2_FHSIZE];
+};
+
+/*
+ * Procedure numbers for NFSv2
+ */
+#define NFS2_VERSION            2
+#define NFSPROC_NULL            0
+#define NFSPROC_GETATTR         1
+#define NFSPROC_SETATTR         2
+#define NFSPROC_ROOT            3
+#define NFSPROC_LOOKUP          4
+#define NFSPROC_READLINK        5
+#define NFSPROC_READ            6
+#define NFSPROC_WRITECACHE      7
+#define NFSPROC_WRITE           8
+#define NFSPROC_CREATE          9
+#define NFSPROC_REMOVE          10
+#define NFSPROC_RENAME          11
+#define NFSPROC_LINK            12
+#define NFSPROC_SYMLINK         13
+#define NFSPROC_MKDIR           14
+#define NFSPROC_RMDIR           15
+#define NFSPROC_READDIR         16
+#define NFSPROC_STATFS          17
+
+#define NFS_MNT_PROGRAM         100005
+#define NFS_MNT_VERSION         1
+#define MNTPROC_NULL            0
+#define MNTPROC_MNT             1
+#define MNTPROC_UMNT            3
+#define MNTPROC_UMNTALL         4
+
+#endif /* _LINUX_NFS2_H */
diff --git a/include/linux/nfs3.h b/include/linux/nfs3.h
new file mode 100644
index 000000000000..7f11fa589207
--- /dev/null
+++ b/include/linux/nfs3.h
@@ -0,0 +1,105 @@
+/*
+ * NFSv3 protocol definitions
+ */
+#ifndef _LINUX_NFS3_H
+#define _LINUX_NFS3_H
+
+#define NFS3_PORT               2049
+#define NFS3_MAXDATA            32768
+#define NFS3_MAXPATHLEN         PATH_MAX
+#define NFS3_MAXNAMLEN          NAME_MAX
+#define NFS3_MAXGROUPS          16
+#define NFS3_FHSIZE             64
+#define NFS3_COOKIESIZE         4
+#define NFS3_FIFO_DEV           (-1)
+#define NFS3MODE_FMT            0170000
+#define NFS3MODE_DIR            0040000
+#define NFS3MODE_CHR            0020000
+#define NFS3MODE_BLK            0060000
+#define NFS3MODE_REG            0100000
+#define NFS3MODE_LNK            0120000
+#define NFS3MODE_SOCK           0140000
+#define NFS3MODE_FIFO           0010000
+
+/* Flags for access() call */
+#define NFS3_ACCESS_READ        0x0001
+#define NFS3_ACCESS_LOOKUP      0x0002
+#define NFS3_ACCESS_MODIFY      0x0004
+#define NFS3_ACCESS_EXTEND      0x0008
+#define NFS3_ACCESS_DELETE      0x0010
+#define NFS3_ACCESS_EXECUTE     0x0020
+#define NFS3_ACCESS_FULL        0x003f
+
+/* Flags for create mode */
+enum nfs3_createmode {
+        NFS3_CREATE_UNCHECKED = 0,
+        NFS3_CREATE_GUARDED = 1,
+        NFS3_CREATE_EXCLUSIVE = 2
+};
+
+/* NFSv3 file system properties */
+#define NFS3_FSF_LINK           0x0001
+#define NFS3_FSF_SYMLINK        0x0002
+#define NFS3_FSF_HOMOGENEOUS    0x0008
+#define NFS3_FSF_CANSETTIME     0x0010
+/* Some shorthands. See fs/nfsd/nfs3proc.c */
+#define NFS3_FSF_DEFAULT        0x001B
+#define NFS3_FSF_BILLYBOY       0x0018
+#define NFS3_FSF_READONLY       0x0008
+
+enum nfs3_ftype {
+        NF3NON  = 0,
+        NF3REG  = 1,
+        NF3DIR  = 2,
+        NF3BLK  = 3,
+        NF3CHR  = 4,
+        NF3LNK  = 5,
+        NF3SOCK = 6,
+        NF3FIFO = 7,    /* changed from NFSv2 (was 8) */
+        NF3BAD  = 8
+};
+
+struct nfs3_fh {
+        unsigned short size;
+        unsigned char  data[NFS3_FHSIZE];
+};
+
+#define NFS3_VERSION            3
+#define NFS3PROC_NULL           0
+#define NFS3PROC_GETATTR        1
+#define NFS3PROC_SETATTR        2
+#define NFS3PROC_LOOKUP         3
+#define NFS3PROC_ACCESS         4
+#define NFS3PROC_READLINK       5
+#define NFS3PROC_READ           6
+#define NFS3PROC_WRITE          7
+#define NFS3PROC_CREATE         8
+#define NFS3PROC_MKDIR          9
+#define NFS3PROC_SYMLINK        10
+#define NFS3PROC_MKNOD          11
+#define NFS3PROC_REMOVE         12
+#define NFS3PROC_RMDIR          13
+#define NFS3PROC_RENAME         14
+#define NFS3PROC_LINK           15
+#define NFS3PROC_READDIR        16
+#define NFS3PROC_READDIRPLUS    17
+#define NFS3PROC_FSSTAT         18
+#define NFS3PROC_FSINFO         19
+#define NFS3PROC_PATHCONF       20
+#define NFS3PROC_COMMIT         21
+
+#define NFS_MNT3_PROGRAM        100005
+#define NFS_MNT3_VERSION        3
+#define MOUNTPROC3_NULL         0
+#define MOUNTPROC3_MNT          1
+#define MOUNTPROC3_UMNT         3
+#define MOUNTPROC3_UMNTALL      4
+ 
+
+#if defined(__KERNEL__) || defined(NFS_NEED_KERNEL_TYPES)
+
+/* Number of 32bit words in post_op_attr */
+#define NFS3_POST_OP_ATTR_WORDS         22
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_NFS3_H */
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
new file mode 100644
index 000000000000..5ca8a8d8ccdf
--- /dev/null
+++ b/include/linux/nfs4.h
@@ -0,0 +1,394 @@
+/*
+ *  include/linux/nfs4.h
+ *
+ *  NFSv4 protocol definitions.
+ *
+ *  Copyright (c) 2002 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Kendrick Smith <kmsmith@umich.edu>
+ *  Andy Adamson   <andros@umich.edu>
+ */
+
+#ifndef _LINUX_NFS4_H
+#define _LINUX_NFS4_H
+
+#include <linux/types.h>
+#include <linux/list.h>
+
+#define NFS4_VERIFIER_SIZE      8
+#define NFS4_FHSIZE             128
+#define NFS4_MAXPATHLEN         PATH_MAX
+#define NFS4_MAXNAMLEN          NAME_MAX
+
+#define NFS4_ACCESS_READ        0x0001
+#define NFS4_ACCESS_LOOKUP      0x0002
+#define NFS4_ACCESS_MODIFY      0x0004
+#define NFS4_ACCESS_EXTEND      0x0008
+#define NFS4_ACCESS_DELETE      0x0010
+#define NFS4_ACCESS_EXECUTE     0x0020
+
+#define NFS4_FH_PERISTENT               0x0000
+#define NFS4_FH_NOEXPIRE_WITH_OPEN      0x0001
+#define NFS4_FH_VOLATILE_ANY            0x0002
+#define NFS4_FH_VOL_MIGRATION           0x0004
+#define NFS4_FH_VOL_RENAME              0x0008
+
+#define NFS4_OPEN_RESULT_CONFIRM 0x0002
+#define NFS4_OPEN_RESULT_LOCKTYPE_POSIX 0x0004
+
+#define NFS4_SHARE_ACCESS_READ  0x0001
+#define NFS4_SHARE_ACCESS_WRITE 0x0002
+#define NFS4_SHARE_ACCESS_BOTH  0x0003
+#define NFS4_SHARE_DENY_READ    0x0001
+#define NFS4_SHARE_DENY_WRITE   0x0002
+#define NFS4_SHARE_DENY_BOTH    0x0003
+
+#define NFS4_SET_TO_SERVER_TIME 0
+#define NFS4_SET_TO_CLIENT_TIME 1
+
+#define NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE 0
+#define NFS4_ACE_ACCESS_DENIED_ACE_TYPE  1
+#define NFS4_ACE_SYSTEM_AUDIT_ACE_TYPE   2
+#define NFS4_ACE_SYSTEM_ALARM_ACE_TYPE   3
+
+#define ACL4_SUPPORT_ALLOW_ACL 0x01
+#define ACL4_SUPPORT_DENY_ACL  0x02
+#define ACL4_SUPPORT_AUDIT_ACL 0x04
+#define ACL4_SUPPORT_ALARM_ACL 0x08
+
+#define NFS4_ACE_FILE_INHERIT_ACE             0x00000001
+#define NFS4_ACE_DIRECTORY_INHERIT_ACE        0x00000002
+#define NFS4_ACE_NO_PROPAGATE_INHERIT_ACE     0x00000004
+#define NFS4_ACE_INHERIT_ONLY_ACE             0x00000008
+#define NFS4_ACE_SUCCESSFUL_ACCESS_ACE_FLAG   0x00000010
+#define NFS4_ACE_FAILED_ACCESS_ACE_FLAG       0x00000020
+#define NFS4_ACE_IDENTIFIER_GROUP             0x00000040
+#define NFS4_ACE_OWNER                        0x00000080
+#define NFS4_ACE_GROUP                        0x00000100
+#define NFS4_ACE_EVERYONE                     0x00000200
+
+#define NFS4_ACE_READ_DATA                    0x00000001
+#define NFS4_ACE_LIST_DIRECTORY               0x00000001
+#define NFS4_ACE_WRITE_DATA                   0x00000002
+#define NFS4_ACE_ADD_FILE                     0x00000002
+#define NFS4_ACE_APPEND_DATA                  0x00000004
+#define NFS4_ACE_ADD_SUBDIRECTORY             0x00000004
+#define NFS4_ACE_READ_NAMED_ATTRS             0x00000008
+#define NFS4_ACE_WRITE_NAMED_ATTRS            0x00000010
+#define NFS4_ACE_EXECUTE                      0x00000020
+#define NFS4_ACE_DELETE_CHILD                 0x00000040
+#define NFS4_ACE_READ_ATTRIBUTES              0x00000080
+#define NFS4_ACE_WRITE_ATTRIBUTES             0x00000100
+#define NFS4_ACE_DELETE                       0x00010000
+#define NFS4_ACE_READ_ACL                     0x00020000
+#define NFS4_ACE_WRITE_ACL                    0x00040000
+#define NFS4_ACE_WRITE_OWNER                  0x00080000
+#define NFS4_ACE_SYNCHRONIZE                  0x00100000
+#define NFS4_ACE_GENERIC_READ                 0x00120081
+#define NFS4_ACE_GENERIC_WRITE                0x00160106
+#define NFS4_ACE_GENERIC_EXECUTE              0x001200A0
+#define NFS4_ACE_MASK_ALL                     0x001F01FF
+
+enum nfs4_acl_whotype {
+        NFS4_ACL_WHO_NAMED = 0,
+        NFS4_ACL_WHO_OWNER,
+        NFS4_ACL_WHO_GROUP,
+        NFS4_ACL_WHO_EVERYONE,
+};
+
+struct nfs4_ace {
+        uint32_t        type;
+        uint32_t        flag;
+        uint32_t        access_mask;
+        int             whotype;
+        uid_t           who;
+        struct list_head l_ace;
+};
+
+struct nfs4_acl {
+        uint32_t        naces;
+        struct list_head ace_head;
+};
+
+typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
+typedef struct { char data[16]; } nfs4_stateid;
+
+enum nfs_opnum4 {
+        OP_ACCESS = 3,
+        OP_CLOSE = 4,
+        OP_COMMIT = 5,
+        OP_CREATE = 6,
+        OP_DELEGPURGE = 7,
+        OP_DELEGRETURN = 8,
+        OP_GETATTR = 9,
+        OP_GETFH = 10,
+        OP_LINK = 11,
+        OP_LOCK = 12,
+        OP_LOCKT = 13,
+        OP_LOCKU = 14,
+        OP_LOOKUP = 15,
+        OP_LOOKUPP = 16,
+        OP_NVERIFY = 17,
+        OP_OPEN = 18,
+        OP_OPENATTR = 19,
+        OP_OPEN_CONFIRM = 20,
+        OP_OPEN_DOWNGRADE = 21,
+        OP_PUTFH = 22,
+        OP_PUTPUBFH = 23,
+        OP_PUTROOTFH = 24,
+        OP_READ = 25,
+        OP_READDIR = 26,
+        OP_READLINK = 27,
+        OP_REMOVE = 28,
+        OP_RENAME = 29,
+        OP_RENEW = 30,
+        OP_RESTOREFH = 31,
+        OP_SAVEFH = 32,
+        OP_SECINFO = 33,
+        OP_SETATTR = 34,
+        OP_SETCLIENTID = 35,
+        OP_SETCLIENTID_CONFIRM = 36,
+        OP_VERIFY = 37,
+        OP_WRITE = 38,
+        OP_RELEASE_LOCKOWNER = 39,
+        OP_ILLEGAL = 10044,
+};
+
+enum nfsstat4 {
+        NFS4_OK = 0,
+        NFS4ERR_PERM = 1,
+        NFS4ERR_NOENT = 2,
+        NFS4ERR_IO = 5,
+        NFS4ERR_NXIO = 6,
+        NFS4ERR_ACCESS = 13,
+        NFS4ERR_EXIST = 17,
+        NFS4ERR_XDEV = 18,
+        /* Unused/reserved 19 */
+        NFS4ERR_NOTDIR = 20,
+        NFS4ERR_ISDIR = 21,
+        NFS4ERR_INVAL = 22,
+        NFS4ERR_FBIG = 27,
+        NFS4ERR_NOSPC = 28,
+        NFS4ERR_ROFS = 30,
+        NFS4ERR_MLINK = 31,
+        NFS4ERR_NAMETOOLONG = 63,
+        NFS4ERR_NOTEMPTY = 66,
+        NFS4ERR_DQUOT = 69,
+        NFS4ERR_STALE = 70,
+        NFS4ERR_BADHANDLE = 10001,
+        NFS4ERR_BAD_COOKIE = 10003,
+        NFS4ERR_NOTSUPP = 10004,
+        NFS4ERR_TOOSMALL = 10005,
+        NFS4ERR_SERVERFAULT = 10006,
+        NFS4ERR_BADTYPE = 10007,
+        NFS4ERR_DELAY = 10008,
+        NFS4ERR_SAME = 10009,
+        NFS4ERR_DENIED = 10010,
+        NFS4ERR_EXPIRED = 10011,
+        NFS4ERR_LOCKED = 10012,
+        NFS4ERR_GRACE = 10013,
+        NFS4ERR_FHEXPIRED = 10014,
+        NFS4ERR_SHARE_DENIED = 10015,
+        NFS4ERR_WRONGSEC = 10016,
+        NFS4ERR_CLID_INUSE = 10017,
+        NFS4ERR_RESOURCE = 10018,
+        NFS4ERR_MOVED = 10019,
+        NFS4ERR_NOFILEHANDLE = 10020,
+        NFS4ERR_MINOR_VERS_MISMATCH = 10021,
+        NFS4ERR_STALE_CLIENTID = 10022,
+        NFS4ERR_STALE_STATEID = 10023,
+        NFS4ERR_OLD_STATEID = 10024,
+        NFS4ERR_BAD_STATEID = 10025,
+        NFS4ERR_BAD_SEQID = 10026,
+        NFS4ERR_NOT_SAME = 10027,
+        NFS4ERR_LOCK_RANGE = 10028,
+        NFS4ERR_SYMLINK = 10029,
+        NFS4ERR_RESTOREFH = 10030,
+        NFS4ERR_LEASE_MOVED = 10031,
+        NFS4ERR_ATTRNOTSUPP = 10032,
+        NFS4ERR_NO_GRACE = 10033,
+        NFS4ERR_RECLAIM_BAD = 10034,
+        NFS4ERR_RECLAIM_CONFLICT = 10035,
+        NFS4ERR_BADXDR = 10036,
+        NFS4ERR_LOCKS_HELD = 10037,
+        NFS4ERR_OPENMODE = 10038,
+        NFS4ERR_BADOWNER = 10039,
+        NFS4ERR_BADCHAR = 10040,
+        NFS4ERR_BADNAME = 10041,
+        NFS4ERR_BAD_RANGE = 10042,
+        NFS4ERR_LOCK_NOTSUPP = 10043,
+        NFS4ERR_OP_ILLEGAL = 10044,
+        NFS4ERR_DEADLOCK = 10045,
+        NFS4ERR_FILE_OPEN = 10046,
+        NFS4ERR_ADMIN_REVOKED = 10047,
+        NFS4ERR_CB_PATH_DOWN = 10048
+};
+
+/*
+ * Note: NF4BAD is not actually part of the protocol; it is just used
+ * internally by nfsd.
+ */
+enum nfs_ftype4 {
+        NF4BAD          = 0,
+        NF4REG          = 1,    /* Regular File */
+        NF4DIR          = 2,    /* Directory */
+        NF4BLK          = 3,    /* Special File - block device */
+        NF4CHR          = 4,    /* Special File - character device */
+        NF4LNK          = 5,    /* Symbolic Link */
+        NF4SOCK         = 6,    /* Special File - socket */
+        NF4FIFO         = 7,    /* Special File - fifo */
+        NF4ATTRDIR      = 8,    /* Attribute Directory */
+        NF4NAMEDATTR    = 9     /* Named Attribute */
+};
+
+enum open_claim_type4 {
+        NFS4_OPEN_CLAIM_NULL = 0,
+        NFS4_OPEN_CLAIM_PREVIOUS = 1,
+        NFS4_OPEN_CLAIM_DELEGATE_CUR = 2,
+        NFS4_OPEN_CLAIM_DELEGATE_PREV = 3
+};
+
+enum opentype4 {
+        NFS4_OPEN_NOCREATE = 0,
+        NFS4_OPEN_CREATE = 1
+};
+
+enum createmode4 {
+        NFS4_CREATE_UNCHECKED = 0,
+        NFS4_CREATE_GUARDED = 1,
+        NFS4_CREATE_EXCLUSIVE = 2
+};
+
+enum limit_by4 {
+        NFS4_LIMIT_SIZE = 1,
+        NFS4_LIMIT_BLOCKS = 2
+};
+
+enum open_delegation_type4 {
+        NFS4_OPEN_DELEGATE_NONE = 0,
+        NFS4_OPEN_DELEGATE_READ = 1,
+        NFS4_OPEN_DELEGATE_WRITE = 2
+};
+
+enum lock_type4 {
+        NFS4_UNLOCK_LT = 0,
+        NFS4_READ_LT = 1,
+        NFS4_WRITE_LT = 2,
+        NFS4_READW_LT = 3,
+        NFS4_WRITEW_LT = 4
+};
+
+
+/* Mandatory Attributes */
+#define FATTR4_WORD0_SUPPORTED_ATTRS    (1UL << 0)
+#define FATTR4_WORD0_TYPE               (1UL << 1)
+#define FATTR4_WORD0_FH_EXPIRE_TYPE     (1UL << 2)
+#define FATTR4_WORD0_CHANGE             (1UL << 3)
+#define FATTR4_WORD0_SIZE               (1UL << 4)
+#define FATTR4_WORD0_LINK_SUPPORT       (1UL << 5)
+#define FATTR4_WORD0_SYMLINK_SUPPORT    (1UL << 6)
+#define FATTR4_WORD0_NAMED_ATTR         (1UL << 7)
+#define FATTR4_WORD0_FSID               (1UL << 8)
+#define FATTR4_WORD0_UNIQUE_HANDLES     (1UL << 9)
+#define FATTR4_WORD0_LEASE_TIME         (1UL << 10)
+#define FATTR4_WORD0_RDATTR_ERROR       (1UL << 11)
+
+/* Recommended Attributes */
+#define FATTR4_WORD0_ACL                (1UL << 12)
+#define FATTR4_WORD0_ACLSUPPORT         (1UL << 13)
+#define FATTR4_WORD0_ARCHIVE            (1UL << 14)
+#define FATTR4_WORD0_CANSETTIME         (1UL << 15)
+#define FATTR4_WORD0_CASE_INSENSITIVE   (1UL << 16)
+#define FATTR4_WORD0_CASE_PRESERVING    (1UL << 17)
+#define FATTR4_WORD0_CHOWN_RESTRICTED   (1UL << 18)
+#define FATTR4_WORD0_FILEHANDLE         (1UL << 19)
+#define FATTR4_WORD0_FILEID             (1UL << 20)
+#define FATTR4_WORD0_FILES_AVAIL        (1UL << 21)
+#define FATTR4_WORD0_FILES_FREE         (1UL << 22)
+#define FATTR4_WORD0_FILES_TOTAL        (1UL << 23)
+#define FATTR4_WORD0_FS_LOCATIONS       (1UL << 24)
+#define FATTR4_WORD0_HIDDEN             (1UL << 25)
+#define FATTR4_WORD0_HOMOGENEOUS        (1UL << 26)
+#define FATTR4_WORD0_MAXFILESIZE        (1UL << 27)
+#define FATTR4_WORD0_MAXLINK            (1UL << 28)
+#define FATTR4_WORD0_MAXNAME            (1UL << 29)
+#define FATTR4_WORD0_MAXREAD            (1UL << 30)
+#define FATTR4_WORD0_MAXWRITE           (1UL << 31)
+#define FATTR4_WORD1_MIMETYPE           (1UL << 0)
+#define FATTR4_WORD1_MODE               (1UL << 1)
+#define FATTR4_WORD1_NO_TRUNC           (1UL << 2)
+#define FATTR4_WORD1_NUMLINKS           (1UL << 3)
+#define FATTR4_WORD1_OWNER              (1UL << 4)
+#define FATTR4_WORD1_OWNER_GROUP        (1UL << 5)
+#define FATTR4_WORD1_QUOTA_HARD         (1UL << 6)
+#define FATTR4_WORD1_QUOTA_SOFT         (1UL << 7)
+#define FATTR4_WORD1_QUOTA_USED         (1UL << 8)
+#define FATTR4_WORD1_RAWDEV             (1UL << 9)
+#define FATTR4_WORD1_SPACE_AVAIL        (1UL << 10)
+#define FATTR4_WORD1_SPACE_FREE         (1UL << 11)
+#define FATTR4_WORD1_SPACE_TOTAL        (1UL << 12)
+#define FATTR4_WORD1_SPACE_USED         (1UL << 13)
+#define FATTR4_WORD1_SYSTEM             (1UL << 14)
+#define FATTR4_WORD1_TIME_ACCESS        (1UL << 15)
+#define FATTR4_WORD1_TIME_ACCESS_SET    (1UL << 16)
+#define FATTR4_WORD1_TIME_BACKUP        (1UL << 17)
+#define FATTR4_WORD1_TIME_CREATE        (1UL << 18)
+#define FATTR4_WORD1_TIME_DELTA         (1UL << 19)
+#define FATTR4_WORD1_TIME_METADATA      (1UL << 20)
+#define FATTR4_WORD1_TIME_MODIFY        (1UL << 21)
+#define FATTR4_WORD1_TIME_MODIFY_SET    (1UL << 22)
+#define FATTR4_WORD1_MOUNTED_ON_FILEID  (1UL << 23)
+
+#define NFSPROC4_NULL 0
+#define NFSPROC4_COMPOUND 1
+#define NFS4_MINOR_VERSION 0
+#define NFS4_DEBUG 1
+
+#ifdef __KERNEL__
+
+/* Index of predefined Linux client operations */
+
+enum {
+        NFSPROC4_CLNT_NULL = 0,         /* Unused */
+        NFSPROC4_CLNT_READ,
+        NFSPROC4_CLNT_WRITE,
+        NFSPROC4_CLNT_COMMIT,
+        NFSPROC4_CLNT_OPEN,
+        NFSPROC4_CLNT_OPEN_CONFIRM,
+        NFSPROC4_CLNT_OPEN_NOATTR,
+        NFSPROC4_CLNT_OPEN_DOWNGRADE,
+        NFSPROC4_CLNT_CLOSE,
+        NFSPROC4_CLNT_SETATTR,
+        NFSPROC4_CLNT_FSINFO,
+        NFSPROC4_CLNT_RENEW,
+        NFSPROC4_CLNT_SETCLIENTID,
+        NFSPROC4_CLNT_SETCLIENTID_CONFIRM,
+        NFSPROC4_CLNT_LOCK,
+        NFSPROC4_CLNT_LOCKT,
+        NFSPROC4_CLNT_LOCKU,
+        NFSPROC4_CLNT_ACCESS,
+        NFSPROC4_CLNT_GETATTR,
+        NFSPROC4_CLNT_LOOKUP,
+        NFSPROC4_CLNT_LOOKUP_ROOT,
+        NFSPROC4_CLNT_REMOVE,
+        NFSPROC4_CLNT_RENAME,
+        NFSPROC4_CLNT_LINK,
+        NFSPROC4_CLNT_SYMLINK,
+        NFSPROC4_CLNT_CREATE,
+        NFSPROC4_CLNT_PATHCONF,
+        NFSPROC4_CLNT_STATFS,
+        NFSPROC4_CLNT_READLINK,
+        NFSPROC4_CLNT_READDIR,
+        NFSPROC4_CLNT_SERVER_CAPS,
+        NFSPROC4_CLNT_DELEGRETURN,
+};
+
+#endif
+#endif
+
+/*
+ * Local variables:
+ *  c-basic-offset: 8
+ * End:
+ */
diff --git a/include/linux/nfs4_acl.h b/include/linux/nfs4_acl.h
new file mode 100644
index 000000000000..22aff4d01f20
--- /dev/null
+++ b/include/linux/nfs4_acl.h
@@ -0,0 +1,59 @@
+/*
+ *  include/linux/nfs4_acl.c
+ *
+ *  Common NFSv4 ACL handling definitions.
+ *
+ *  Copyright (c) 2002 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Marius Aamodt Eriksen <marius@umich.edu>
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the University nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LINUX_NFS4_ACL_H
+#define LINUX_NFS4_ACL_H
+
+#include <linux/posix_acl.h>
+
+struct nfs4_acl *nfs4_acl_new(void);
+void nfs4_acl_free(struct nfs4_acl *);
+int nfs4_acl_add_ace(struct nfs4_acl *, u32, u32, u32, int, uid_t);
+int nfs4_acl_get_whotype(char *, u32);
+int nfs4_acl_write_who(int who, char *p);
+int nfs4_acl_permission(struct nfs4_acl *acl, uid_t owner, gid_t group,
+                                        uid_t who, u32 mask);
+
+#define NFS4_ACL_TYPE_DEFAULT   0x01
+#define NFS4_ACL_DIR            0x02
+#define NFS4_ACL_OWNER          0x04
+
+struct nfs4_acl *nfs4_acl_posix_to_nfsv4(struct posix_acl *,
+                                struct posix_acl *, unsigned int flags);
+int nfs4_acl_nfsv4_to_posix(struct nfs4_acl *, struct posix_acl **,
+                                struct posix_acl **, unsigned int flags);
+
+#endif /* LINUX_NFS4_ACL_H */
diff --git a/include/linux/nfs4_mount.h b/include/linux/nfs4_mount.h
new file mode 100644
index 000000000000..26b4c83f831d
--- /dev/null
+++ b/include/linux/nfs4_mount.h
@@ -0,0 +1,70 @@
+#ifndef _LINUX_NFS4_MOUNT_H
+#define _LINUX_NFS4_MOUNT_H
+
+/*
+ *  linux/include/linux/nfs4_mount.h
+ *
+ *  Copyright (C) 2002  Trond Myklebust
+ *
+ *  structure passed from user-space to kernel-space during an nfsv4 mount
+ */
+
+/*
+ * WARNING!  Do not delete or change the order of these fields.  If
+ * a new field is required then add it to the end.  The version field
+ * tracks which fields are present.  This will ensure some measure of
+ * mount-to-kernel version compatibility.  Some of these aren't used yet
+ * but here they are anyway.
+ */
+#define NFS4_MOUNT_VERSION      1
+
+struct nfs_string {
+        unsigned int len;
+        const char __user * data;
+};
+
+struct nfs4_mount_data {
+        int version;                            /* 1 */
+        int flags;                              /* 1 */
+        int rsize;                              /* 1 */
+        int wsize;                              /* 1 */
+        int timeo;                              /* 1 */
+        int retrans;                            /* 1 */
+        int acregmin;                           /* 1 */
+        int acregmax;                           /* 1 */
+        int acdirmin;                           /* 1 */
+        int acdirmax;                           /* 1 */
+
+        /* see the definition of 'struct clientaddr4' in RFC3010 */
+        struct nfs_string client_addr;          /* 1 */
+
+        /* Mount path */
+        struct nfs_string mnt_path;             /* 1 */
+
+        /* Server details */
+        struct nfs_string hostname;             /* 1 */
+        /* Server IP address */
+        unsigned int host_addrlen;              /* 1 */
+        struct sockaddr __user * host_addr;     /* 1 */
+
+        /* Transport protocol to use */
+        int proto;                              /* 1 */
+
+        /* Pseudo-flavours to use for authentication. See RFC2623 */
+        int auth_flavourlen;                    /* 1 */
+        int __user *auth_flavours;              /* 1 */
+};
+
+/* bits in the flags field */
+/* Note: the fields that correspond to existing NFSv2/v3 mount options
+ *       should mirror the values from include/linux/nfs_mount.h
+ */
+
+#define NFS4_MOUNT_SOFT         0x0001  /* 1 */
+#define NFS4_MOUNT_INTR         0x0002  /* 1 */
+#define NFS4_MOUNT_NOCTO        0x0010  /* 1 */
+#define NFS4_MOUNT_NOAC         0x0020  /* 1 */
+#define NFS4_MOUNT_STRICTLOCK   0x1000  /* 1 */
+#define NFS4_MOUNT_FLAGMASK     0xFFFF
+
+#endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
new file mode 100644
index 000000000000..dbac7f363e5d
--- /dev/null
+++ b/include/linux/nfs_fs.h
@@ -0,0 +1,767 @@
+/*
+ *  linux/include/linux/nfs_fs.h
+ *
+ *  Copyright (C) 1992  Rick Sladkey
+ *
+ *  OS-specific nfs filesystem definitions and declarations
+ */
+
+#ifndef _LINUX_NFS_FS_H
+#define _LINUX_NFS_FS_H
+
+#include <linux/config.h>
+#include <linux/in.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/rwsem.h>
+#include <linux/wait.h>
+#include <linux/uio.h>
+
+#include <linux/nfs_fs_sb.h>
+
+#include <linux/sunrpc/debug.h>
+#include <linux/sunrpc/auth.h>
+#include <linux/sunrpc/clnt.h>
+
+#include <linux/nfs.h>
+#include <linux/nfs2.h>
+#include <linux/nfs3.h>
+#include <linux/nfs4.h>
+#include <linux/nfs_xdr.h>
+#include <linux/rwsem.h>
+#include <linux/workqueue.h>
+#include <linux/mempool.h>
+
+/*
+ * Enable debugging support for nfs client.
+ * Requires RPC_DEBUG.
+ */
+#ifdef RPC_DEBUG
+# define NFS_DEBUG
+#endif
+
+#define NFS_MAX_FILE_IO_BUFFER_SIZE     32768
+#define NFS_DEF_FILE_IO_BUFFER_SIZE     4096
+
+/*
+ * The upper limit on timeouts for the exponential backoff algorithm.
+ */
+#define NFS_WRITEBACK_DELAY             (5*HZ)
+#define NFS_WRITEBACK_LOCKDELAY         (60*HZ)
+#define NFS_COMMIT_DELAY                (5*HZ)
+
+/*
+ * superblock magic number for NFS
+ */
+#define NFS_SUPER_MAGIC                 0x6969
+
+/*
+ * These are the default flags for swap requests
+ */
+#define NFS_RPC_SWAPFLAGS               (RPC_TASK_SWAPPER|RPC_TASK_ROOTCREDS)
+
+#define NFS_RW_SYNC             0x0001  /* O_SYNC handling */
+#define NFS_RW_SWAP             0x0002  /* This is a swap request */
+
+/*
+ * When flushing a cluster of dirty pages, there can be different
+ * strategies:
+ */
+#define FLUSH_AGING             0       /* only flush old buffers */
+#define FLUSH_SYNC              1       /* file being synced, or contention */
+#define FLUSH_WAIT              2       /* wait for completion */
+#define FLUSH_STABLE            4       /* commit to stable storage */
+#define FLUSH_LOWPRI            8       /* low priority background flush */
+#define FLUSH_HIGHPRI           16      /* high priority memory reclaim flush */
+
+#ifdef __KERNEL__
+
+/*
+ * NFSv3/v4 Access mode cache entry
+ */
+struct nfs_access_entry {
+        unsigned long           jiffies;
+        struct rpc_cred *       cred;
+        int                     mask;
+};
+
+struct nfs4_state;
+struct nfs_open_context {
+        atomic_t count;
+        struct dentry *dentry;
+        struct rpc_cred *cred;
+        struct nfs4_state *state;
+        fl_owner_t lockowner;
+        int mode;
+        int error;
+
+        struct list_head list;
+        wait_queue_head_t waitq;
+};
+
+/*
+ * NFSv4 delegation
+ */
+struct nfs_delegation;
+
+/*
+ * nfs fs inode data in memory
+ */
+struct nfs_inode {
+        /*
+         * The 64bit 'inode number'
+         */
+        __u64 fileid;
+
+        /*
+         * NFS file handle
+         */
+        struct nfs_fh           fh;
+
+        /*
+         * Various flags
+         */
+        unsigned int            flags;
+
+        /*
+         * read_cache_jiffies is when we started read-caching this inode,
+         * and read_cache_mtime is the mtime of the inode at that time.
+         * attrtimeo is for how long the cached information is assumed
+         * to be valid. A successful attribute revalidation doubles
+         * attrtimeo (up to acregmax/acdirmax), a failure resets it to
+         * acregmin/acdirmin.
+         *
+         * We need to revalidate the cached attrs for this inode if
+         *
+         *      jiffies - read_cache_jiffies > attrtimeo
+         *
+         * and invalidate any cached data/flush out any dirty pages if
+         * we find that
+         *
+         *      mtime != read_cache_mtime
+         */
+        unsigned long           readdir_timestamp;
+        unsigned long           read_cache_jiffies;
+        unsigned long           attrtimeo;
+        unsigned long           attrtimeo_timestamp;
+        __u64                   change_attr;            /* v4 only */
+
+        /* "Generation counter" for the attribute cache. This is
+         * bumped whenever we update the metadata on the
+         * server.
+         */
+        unsigned long           cache_change_attribute;
+        /*
+         * Counter indicating the number of outstanding requests that
+         * will cause a file data update.
+         */
+        atomic_t                data_updates;
+
+        struct nfs_access_entry cache_access;
+
+        /*
+         * This is the cookie verifier used for NFSv3 readdir
+         * operations
+         */
+        __u32                   cookieverf[2];
+
+        /*
+         * This is the list of dirty unwritten pages.
+         */
+        spinlock_t              req_lock;
+        struct list_head        dirty;
+        struct list_head        commit;
+        struct radix_tree_root  nfs_page_tree;
+
+        unsigned int            ndirty,
+                                ncommit,
+                                npages;
+
+        /* Open contexts for shared mmap writes */
+        struct list_head        open_files;
+
+        wait_queue_head_t       nfs_i_wait;
+
+#ifdef CONFIG_NFS_V4
+        /* NFSv4 state */
+        struct list_head        open_states;
+        struct nfs_delegation   *delegation;
+        int                      delegation_state;
+        struct rw_semaphore     rwsem;
+#endif /* CONFIG_NFS_V4*/
+
+        struct inode            vfs_inode;
+};
+
+/*
+ * Legal inode flag values
+ */
+#define NFS_INO_STALE           0x0001          /* possible stale inode */
+#define NFS_INO_ADVISE_RDPLUS   0x0002          /* advise readdirplus */
+#define NFS_INO_REVALIDATING    0x0004          /* revalidating attrs */
+#define NFS_INO_INVALID_ATTR    0x0008          /* cached attrs are invalid */
+#define NFS_INO_INVALID_DATA    0x0010          /* cached data is invalid */
+#define NFS_INO_INVALID_ATIME   0x0020          /* cached atime is invalid */
+#define NFS_INO_INVALID_ACCESS  0x0040          /* cached access cred invalid */
+
+static inline struct nfs_inode *NFS_I(struct inode *inode)
+{
+        return container_of(inode, struct nfs_inode, vfs_inode);
+}
+#define NFS_SB(s)               ((struct nfs_server *)(s->s_fs_info))
+
+#define NFS_FH(inode)                   (&NFS_I(inode)->fh)
+#define NFS_SERVER(inode)               (NFS_SB(inode->i_sb))
+#define NFS_CLIENT(inode)               (NFS_SERVER(inode)->client)
+#define NFS_PROTO(inode)                (NFS_SERVER(inode)->rpc_ops)
+#define NFS_ADDR(inode)                 (RPC_PEERADDR(NFS_CLIENT(inode)))
+#define NFS_COOKIEVERF(inode)           (NFS_I(inode)->cookieverf)
+#define NFS_READTIME(inode)             (NFS_I(inode)->read_cache_jiffies)
+#define NFS_CHANGE_ATTR(inode)          (NFS_I(inode)->change_attr)
+#define NFS_ATTRTIMEO(inode)            (NFS_I(inode)->attrtimeo)
+#define NFS_MINATTRTIMEO(inode) \
+        (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmin \
+                               : NFS_SERVER(inode)->acregmin)
+#define NFS_MAXATTRTIMEO(inode) \
+        (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmax \
+                               : NFS_SERVER(inode)->acregmax)
+#define NFS_ATTRTIMEO_UPDATE(inode)     (NFS_I(inode)->attrtimeo_timestamp)
+
+#define NFS_FLAGS(inode)                (NFS_I(inode)->flags)
+#define NFS_REVALIDATING(inode)         (NFS_FLAGS(inode) & NFS_INO_REVALIDATING)
+#define NFS_STALE(inode)                (NFS_FLAGS(inode) & NFS_INO_STALE)
+
+#define NFS_FILEID(inode)               (NFS_I(inode)->fileid)
+
+static inline int nfs_caches_unstable(struct inode *inode)
+{
+        return atomic_read(&NFS_I(inode)->data_updates) != 0;
+}
+
+static inline void NFS_CACHEINV(struct inode *inode)
+{
+        if (!nfs_caches_unstable(inode))
+                NFS_FLAGS(inode) |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
+}
+
+static inline int nfs_server_capable(struct inode *inode, int cap)
+{
+        return NFS_SERVER(inode)->caps & cap;
+}
+
+static inline int NFS_USE_READDIRPLUS(struct inode *inode)
+{
+        return NFS_FLAGS(inode) & NFS_INO_ADVISE_RDPLUS;
+}
+
+/**
+ * nfs_save_change_attribute - Returns the inode attribute change cookie
+ * @inode - pointer to inode
+ * The "change attribute" is updated every time we finish an operation
+ * that will result in a metadata change on the server.
+ */
+static inline long nfs_save_change_attribute(struct inode *inode)
+{
+        return NFS_I(inode)->cache_change_attribute;
+}
+
+/**
+ * nfs_verify_change_attribute - Detects NFS inode cache updates
+ * @inode - pointer to inode
+ * @chattr - previously saved change attribute
+ * Return "false" if metadata has been updated (or is in the process of
+ * being updated) since the change attribute was saved.
+ */
+static inline int nfs_verify_change_attribute(struct inode *inode, unsigned long chattr)
+{
+        return !nfs_caches_unstable(inode)
+                && chattr == NFS_I(inode)->cache_change_attribute;
+}
+
+/*
+ * linux/fs/nfs/inode.c
+ */
+extern void nfs_zap_caches(struct inode *);
+extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
+                                struct nfs_fattr *);
+extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
+extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+extern int nfs_permission(struct inode *, int, struct nameidata *);
+extern int nfs_access_get_cached(struct inode *, struct rpc_cred *, struct nfs_access_entry *);
+extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *);
+extern int nfs_open(struct inode *, struct file *);
+extern int nfs_release(struct inode *, struct file *);
+extern int nfs_attribute_timeout(struct inode *inode);
+extern int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode);
+extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
+extern int nfs_setattr(struct dentry *, struct iattr *);
+extern void nfs_begin_attr_update(struct inode *);
+extern void nfs_end_attr_update(struct inode *);
+extern void nfs_begin_data_update(struct inode *);
+extern void nfs_end_data_update(struct inode *);
+extern void nfs_end_data_update_defer(struct inode *);
+extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred);
+extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
+extern void put_nfs_open_context(struct nfs_open_context *ctx);
+extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
+extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, int mode);
+extern void nfs_file_clear_open_context(struct file *filp);
+
+/* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
+extern u32 root_nfs_parse_addr(char *name); /*__init*/
+
+/*
+ * linux/fs/nfs/file.c
+ */
+extern struct inode_operations nfs_file_inode_operations;
+extern struct file_operations nfs_file_operations;
+extern struct address_space_operations nfs_file_aops;
+
+static inline struct rpc_cred *nfs_file_cred(struct file *file)
+{
+        if (file != NULL) {
+                struct nfs_open_context *ctx;
+
+                ctx = (struct nfs_open_context*)file->private_data;
+                return ctx->cred;
+        }
+        return NULL;
+}
+
+/*
+ * linux/fs/nfs/direct.c
+ */
+extern ssize_t nfs_direct_IO(int, struct kiocb *, const struct iovec *, loff_t,
+                        unsigned long);
+extern ssize_t nfs_file_direct_read(struct kiocb *iocb, char __user *buf,
+                        size_t count, loff_t pos);
+extern ssize_t nfs_file_direct_write(struct kiocb *iocb, const char __user *buf,
+                        size_t count, loff_t pos);
+
+/*
+ * linux/fs/nfs/dir.c
+ */
+extern struct inode_operations nfs_dir_inode_operations;
+extern struct file_operations nfs_dir_operations;
+extern struct dentry_operations nfs_dentry_operations;
+
+extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_fattr *fattr);
+
+/*
+ * linux/fs/nfs/symlink.c
+ */
+extern struct inode_operations nfs_symlink_inode_operations;
+
+/*
+ * linux/fs/nfs/unlink.c
+ */
+extern int  nfs_async_unlink(struct dentry *);
+extern void nfs_complete_unlink(struct dentry *);
+
+/*
+ * linux/fs/nfs/write.c
+ */
+extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
+extern int  nfs_writepages(struct address_space *, struct writeback_control *);
+extern int  nfs_flush_incompatible(struct file *file, struct page *page);
+extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
+extern void nfs_writeback_done(struct rpc_task *task);
+
+#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
+extern void nfs_commit_done(struct rpc_task *);
+#endif
+
+/*
+ * Try to write back everything synchronously (but check the
+ * return value!)
+ */
+extern int  nfs_sync_inode(struct inode *, unsigned long, unsigned int, int);
+#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
+extern int  nfs_commit_inode(struct inode *, unsigned long, unsigned int, int);
+#else
+static inline int
+nfs_commit_inode(struct inode *inode, unsigned long idx_start, unsigned int npages, int how)
+{
+        return 0;
+}
+#endif
+
+static inline int
+nfs_have_writebacks(struct inode *inode)
+{
+        return NFS_I(inode)->npages != 0;
+}
+
+static inline int
+nfs_wb_all(struct inode *inode)
+{
+        int error = nfs_sync_inode(inode, 0, 0, FLUSH_WAIT);
+        return (error < 0) ? error : 0;
+}
+
+/*
+ * Write back all requests on one page - we do this before reading it.
+ */
+static inline int nfs_wb_page_priority(struct inode *inode, struct page* page, int how)
+{
+        int error = nfs_sync_inode(inode, page->index, 1,
+                        how | FLUSH_WAIT | FLUSH_STABLE);
+        return (error < 0) ? error : 0;
+}
+
+static inline int nfs_wb_page(struct inode *inode, struct page* page)
+{
+        return nfs_wb_page_priority(inode, page, 0);
+}
+
+/*
+ * Allocate and free nfs_write_data structures
+ */
+extern mempool_t *nfs_wdata_mempool;
+
+static inline struct nfs_write_data *nfs_writedata_alloc(void)
+{
+        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, SLAB_NOFS);
+        if (p) {
+                memset(p, 0, sizeof(*p));
+                INIT_LIST_HEAD(&p->pages);
+        }
+        return p;
+}
+
+static inline void nfs_writedata_free(struct nfs_write_data *p)
+{
+        mempool_free(p, nfs_wdata_mempool);
+}
+
+/* Hack for future NFS swap support */
+#ifndef IS_SWAPFILE
+# define IS_SWAPFILE(inode)     (0)
+#endif
+
+/*
+ * linux/fs/nfs/read.c
+ */
+extern int  nfs_readpage(struct file *, struct page *);
+extern int  nfs_readpages(struct file *, struct address_space *,
+                struct list_head *, unsigned);
+extern void nfs_readpage_result(struct rpc_task *);
+
+/*
+ * Allocate and free nfs_read_data structures
+ */
+extern mempool_t *nfs_rdata_mempool;
+
+static inline struct nfs_read_data *nfs_readdata_alloc(void)
+{
+        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, SLAB_NOFS);
+        if (p)
+                memset(p, 0, sizeof(*p));
+        return p;
+}
+
+static inline void nfs_readdata_free(struct nfs_read_data *p)
+{
+        mempool_free(p, nfs_rdata_mempool);
+}
+
+extern void  nfs_readdata_release(struct rpc_task *task);
+
+/*
+ * linux/fs/mount_clnt.c
+ * (Used only by nfsroot module)
+ */
+extern int  nfsroot_mount(struct sockaddr_in *, char *, struct nfs_fh *,
+                int, int);
+
+/*
+ * inline functions
+ */
+
+static inline loff_t
+nfs_size_to_loff_t(__u64 size)
+{
+        loff_t maxsz = (((loff_t) ULONG_MAX) << PAGE_CACHE_SHIFT) + PAGE_CACHE_SIZE - 1;
+        if (size > maxsz)
+                return maxsz;
+        return (loff_t) size;
+}
+
+static inline ino_t
+nfs_fileid_to_ino_t(u64 fileid)
+{
+        ino_t ino = (ino_t) fileid;
+        if (sizeof(ino_t) < sizeof(u64))
+                ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8;
+        return ino;
+}
+
+/* NFS root */
+
+extern void * nfs_root_data(void);
+
+#define nfs_wait_event(clnt, wq, condition)                             \
+({                                                                      \
+        int __retval = 0;                                               \
+        if (clnt->cl_intr) {                                            \
+                sigset_t oldmask;                                       \
+                rpc_clnt_sigmask(clnt, &oldmask);                       \
+                __retval = wait_event_interruptible(wq, condition);     \
+                rpc_clnt_sigunmask(clnt, &oldmask);                     \
+        } else                                                          \
+                wait_event(wq, condition);                              \
+        __retval;                                                       \
+})
+
+#define NFS_JUKEBOX_RETRY_TIME (5 * HZ)
+
+#ifdef CONFIG_NFS_V4
+
+struct idmap;
+
+/*
+ * In a seqid-mutating op, this macro controls which error return
+ * values trigger incrementation of the seqid.
+ *
+ * from rfc 3010:
+ * The client MUST monotonically increment the sequence number for the
+ * CLOSE, LOCK, LOCKU, OPEN, OPEN_CONFIRM, and OPEN_DOWNGRADE
+ * operations.  This is true even in the event that the previous
+ * operation that used the sequence number received an error.  The only
+ * exception to this rule is if the previous operation received one of
+ * the following errors: NFSERR_STALE_CLIENTID, NFSERR_STALE_STATEID,
+ * NFSERR_BAD_STATEID, NFSERR_BAD_SEQID, NFSERR_BADXDR,
+ * NFSERR_RESOURCE, NFSERR_NOFILEHANDLE.
+ *
+ */
+#define seqid_mutating_err(err)       \
+(((err) != NFSERR_STALE_CLIENTID) &&  \
+ ((err) != NFSERR_STALE_STATEID)  &&  \
+ ((err) != NFSERR_BAD_STATEID)    &&  \
+ ((err) != NFSERR_BAD_SEQID)      &&  \
+ ((err) != NFSERR_BAD_XDR)        &&  \
+ ((err) != NFSERR_RESOURCE)       &&  \
+ ((err) != NFSERR_NOFILEHANDLE))
+
+enum nfs4_client_state {
+        NFS4CLNT_OK  = 0,
+};
+
+/*
+ * The nfs4_client identifies our client state to the server.
+ */
+struct nfs4_client {
+        struct list_head        cl_servers;     /* Global list of servers */
+        struct in_addr          cl_addr;        /* Server identifier */
+        u64                     cl_clientid;    /* constant */
+        nfs4_verifier           cl_confirm;
+        unsigned long           cl_state;
+
+        u32                     cl_lockowner_id;
+
+        /*
+         * The following rwsem ensures exclusive access to the server
+         * while we recover the state following a lease expiration.
+         */
+        struct rw_semaphore     cl_sem;
+
+        struct list_head        cl_delegations;
+        struct list_head        cl_state_owners;
+        struct list_head        cl_unused;
+        int                     cl_nunused;
+        spinlock_t              cl_lock;
+        atomic_t                cl_count;
+
+        struct rpc_clnt *       cl_rpcclient;
+        struct rpc_cred *       cl_cred;
+
+        struct list_head        cl_superblocks; /* List of nfs_server structs */
+
+        unsigned long           cl_lease_time;
+        unsigned long           cl_last_renewal;
+        struct work_struct      cl_renewd;
+        struct work_struct      cl_recoverd;
+
+        wait_queue_head_t       cl_waitq;
+        struct rpc_wait_queue   cl_rpcwaitq;
+
+        /* used for the setclientid verifier */
+        struct timespec         cl_boot_time;
+
+        /* idmapper */
+        struct idmap *          cl_idmap;
+
+        /* Our own IP address, as a null-terminated string.
+         * This is used to generate the clientid, and the callback address.
+         */
+        char                    cl_ipaddr[16];
+        unsigned char           cl_id_uniquifier;
+};
+
+/*
+ * NFS4 state_owners and lock_owners are simply labels for ordered
+ * sequences of RPC calls. Their sole purpose is to provide once-only
+ * semantics by allowing the server to identify replayed requests.
+ *
+ * The ->so_sema is held during all state_owner seqid-mutating operations:
+ * OPEN, OPEN_DOWNGRADE, and CLOSE. Its purpose is to properly serialize
+ * so_seqid.
+ */
+struct nfs4_state_owner {
+        struct list_head     so_list;    /* per-clientid list of state_owners */
+        struct nfs4_client   *so_client;
+        u32                  so_id;      /* 32-bit identifier, unique */
+        struct semaphore     so_sema;
+        u32                  so_seqid;   /* protected by so_sema */
+        atomic_t             so_count;
+
+        struct rpc_cred      *so_cred;   /* Associated cred */
+        struct list_head     so_states;
+        struct list_head     so_delegations;
+};
+
+/*
+ * struct nfs4_state maintains the client-side state for a given
+ * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
+ *
+ * OPEN:
+ * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
+ * we need to know how many files are open for reading or writing on a
+ * given inode. This information too is stored here.
+ *
+ * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
+ */
+
+struct nfs4_lock_state {
+        struct list_head        ls_locks;       /* Other lock stateids */
+        fl_owner_t              ls_owner;       /* POSIX lock owner */
+#define NFS_LOCK_INITIALIZED 1
+        int                     ls_flags;
+        u32                     ls_seqid;
+        u32                     ls_id;
+        nfs4_stateid            ls_stateid;
+        atomic_t                ls_count;
+};
+
+/* bits for nfs4_state->flags */
+enum {
+        LK_STATE_IN_USE,
+        NFS_DELEGATED_STATE,
+};
+
+struct nfs4_state {
+        struct list_head open_states;   /* List of states for the same state_owner */
+        struct list_head inode_states;  /* List of states for the same inode */
+        struct list_head lock_states;   /* List of subservient lock stateids */
+
+        struct nfs4_state_owner *owner; /* Pointer to the open owner */
+        struct inode *inode;            /* Pointer to the inode */
+
+        unsigned long flags;            /* Do we hold any locks? */
+        struct semaphore lock_sema;     /* Serializes file locking operations */
+        rwlock_t state_lock;            /* Protects the lock_states list */
+
+        nfs4_stateid stateid;
+
+        unsigned int nreaders;
+        unsigned int nwriters;
+        int state;                      /* State on the server (R,W, or RW) */
+        atomic_t count;
+};
+
+
+struct nfs4_exception {
+        long timeout;
+        int retry;
+};
+
+struct nfs4_state_recovery_ops {
+        int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
+        int (*recover_lock)(struct nfs4_state *, struct file_lock *);
+};
+
+extern struct dentry_operations nfs4_dentry_operations;
+extern struct inode_operations nfs4_dir_inode_operations;
+
+/* nfs4proc.c */
+extern int nfs4_map_errors(int err);
+extern int nfs4_proc_setclientid(struct nfs4_client *, u32, unsigned short);
+extern int nfs4_proc_setclientid_confirm(struct nfs4_client *);
+extern int nfs4_proc_async_renew(struct nfs4_client *);
+extern int nfs4_proc_renew(struct nfs4_client *);
+extern int nfs4_do_close(struct inode *inode, struct nfs4_state *state, mode_t mode);
+extern struct inode *nfs4_atomic_open(struct inode *, struct dentry *, struct nameidata *);
+extern int nfs4_open_revalidate(struct inode *, struct dentry *, int);
+
+extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;
+extern struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops;
+
+/* nfs4renewd.c */
+extern void nfs4_schedule_state_renewal(struct nfs4_client *);
+extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
+extern void nfs4_kill_renewd(struct nfs4_client *);
+
+/* nfs4state.c */
+extern void init_nfsv4_state(struct nfs_server *);
+extern void destroy_nfsv4_state(struct nfs_server *);
+extern struct nfs4_client *nfs4_get_client(struct in_addr *);
+extern void nfs4_put_client(struct nfs4_client *clp);
+extern int nfs4_init_client(struct nfs4_client *clp);
+extern struct nfs4_client *nfs4_find_client(struct in_addr *);
+extern u32 nfs4_alloc_lockowner_id(struct nfs4_client *);
+
+extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
+extern void nfs4_put_state_owner(struct nfs4_state_owner *);
+extern void nfs4_drop_state_owner(struct nfs4_state_owner *);
+extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
+extern void nfs4_put_open_state(struct nfs4_state *);
+extern void nfs4_close_state(struct nfs4_state *, mode_t);
+extern struct nfs4_state *nfs4_find_state(struct inode *, struct rpc_cred *, mode_t mode);
+extern void nfs4_increment_seqid(int status, struct nfs4_state_owner *sp);
+extern void nfs4_schedule_state_recovery(struct nfs4_client *);
+extern struct nfs4_lock_state *nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t);
+extern struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t);
+extern void nfs4_put_lock_state(struct nfs4_lock_state *state);
+extern void nfs4_increment_lock_seqid(int status, struct nfs4_lock_state *ls);
+extern void nfs4_notify_setlk(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
+extern void nfs4_notify_unlck(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
+extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);
+
+
+
+struct nfs4_mount_data;
+#else
+#define init_nfsv4_state(server)  do { } while (0)
+#define destroy_nfsv4_state(server)       do { } while (0)
+#define nfs4_put_state_owner(inode, owner) do { } while (0)
+#define nfs4_put_open_state(state) do { } while (0)
+#define nfs4_close_state(a, b) do { } while (0)
+#define nfs4_renewd_prepare_shutdown(server) do { } while (0)
+#endif
+
+#endif /* __KERNEL__ */
+
+/*
+ * NFS debug flags
+ */
+#define NFSDBG_VFS              0x0001
+#define NFSDBG_DIRCACHE         0x0002
+#define NFSDBG_LOOKUPCACHE      0x0004
+#define NFSDBG_PAGECACHE        0x0008
+#define NFSDBG_PROC             0x0010
+#define NFSDBG_XDR              0x0020
+#define NFSDBG_FILE             0x0040
+#define NFSDBG_ROOT             0x0080
+#define NFSDBG_CALLBACK         0x0100
+#define NFSDBG_ALL              0xFFFF
+
+#ifdef __KERNEL__
+# undef ifdebug
+# ifdef NFS_DEBUG
+#  define ifdebug(fac)          if (unlikely(nfs_debug & NFSDBG_##fac))
+# else
+#  define ifdebug(fac)          if (0)
+# endif
+#endif /* __KERNEL */
+
+#endif
diff --git a/include/linux/nfs_fs_i.h b/include/linux/nfs_fs_i.h
new file mode 100644
index 000000000000..e9a749588a7b
--- /dev/null
+++ b/include/linux/nfs_fs_i.h
@@ -0,0 +1,25 @@
+#ifndef _NFS_FS_I
+#define _NFS_FS_I
+
+#include <asm/types.h>
+#include <linux/list.h>
+#include <linux/nfs.h>
+
+struct nlm_lockowner;
+
+/*
+ * NFS lock info
+ */
+struct nfs_lock_info {
+        u32             state;
+        u32             flags;
+        struct nlm_lockowner *owner;
+};
+
+/*
+ * Lock flag values
+ */
+#define NFS_LCK_GRANTED         0x0001          /* lock has been granted */
+#define NFS_LCK_RECLAIM         0x0002          /* lock marked for reclaiming */
+
+#endif
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
new file mode 100644
index 000000000000..fc51645d61ee
--- /dev/null
+++ b/include/linux/nfs_fs_sb.h
@@ -0,0 +1,58 @@
+#ifndef _NFS_FS_SB
+#define _NFS_FS_SB
+
+#include <linux/list.h>
+#include <linux/backing-dev.h>
+
+/*
+ * NFS client parameters stored in the superblock.
+ */
+struct nfs_server {
+        struct rpc_clnt *       client;         /* RPC client handle */
+        struct rpc_clnt *       client_sys;     /* 2nd handle for FSINFO */
+        struct nfs_rpc_ops *    rpc_ops;        /* NFS protocol vector */
+        struct backing_dev_info backing_dev_info;
+        int                     flags;          /* various flags */
+        unsigned int            caps;           /* server capabilities */
+        unsigned int            rsize;          /* read size */
+        unsigned int            rpages;         /* read size (in pages) */
+        unsigned int            wsize;          /* write size */
+        unsigned int            wpages;         /* write size (in pages) */
+        unsigned int            wtmult;         /* server disk block size */
+        unsigned int            dtsize;         /* readdir size */
+        unsigned int            bsize;          /* server block size */
+        unsigned int            acregmin;       /* attr cache timeouts */
+        unsigned int            acregmax;
+        unsigned int            acdirmin;
+        unsigned int            acdirmax;
+        unsigned int            namelen;
+        char *                  hostname;       /* remote hostname */
+        struct nfs_fh           fh;
+        struct sockaddr_in      addr;
+#ifdef CONFIG_NFS_V4
+        /* Our own IP address, as a null-terminated string.
+         * This is used to generate the clientid, and the callback address.
+         */
+        char                    ip_addr[16];
+        char *                  mnt_path;
+        struct nfs4_client *    nfs4_state;     /* all NFSv4 state starts here */
+        struct list_head        nfs4_siblings;  /* List of other nfs_server structs
+                                                 * that share the same clientid
+                                                 */
+        u32                     attr_bitmask[2];/* V4 bitmask representing the set
+                                                   of attributes supported on this
+                                                   filesystem */
+        u32                     acl_bitmask;    /* V4 bitmask representing the ACEs
+                                                   that are supported on this
+                                                   filesystem */
+#endif
+};
+
+/* Server capabilities */
+#define NFS_CAP_READDIRPLUS     (1U << 0)
+#define NFS_CAP_HARDLINKS       (1U << 1)
+#define NFS_CAP_SYMLINKS        (1U << 2)
+#define NFS_CAP_ACLS            (1U << 3)
+#define NFS_CAP_ATOMIC_OPEN     (1U << 4)
+
+#endif
diff --git a/include/linux/nfs_idmap.h b/include/linux/nfs_idmap.h
new file mode 100644
index 000000000000..a0f1f25e0ead
--- /dev/null
+++ b/include/linux/nfs_idmap.h
@@ -0,0 +1,76 @@
+/*
+ * include/linux/nfs_idmap.h
+ *
+ *  UID and GID to name mapping for clients.
+ *
+ *  Copyright (c) 2002 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Marius Aamodt Eriksen <marius@umich.edu>
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the University nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NFS_IDMAP_H
+#define NFS_IDMAP_H
+
+/* XXX from bits/utmp.h  */
+#define IDMAP_NAMESZ  128
+
+#define IDMAP_TYPE_USER  0
+#define IDMAP_TYPE_GROUP 1
+
+#define IDMAP_CONV_IDTONAME 0
+#define IDMAP_CONV_NAMETOID 1
+
+#define IDMAP_STATUS_INVALIDMSG 0x01
+#define IDMAP_STATUS_AGAIN      0x02
+#define IDMAP_STATUS_LOOKUPFAIL 0x04
+#define IDMAP_STATUS_SUCCESS    0x08
+
+struct idmap_msg {
+        __u8  im_type;
+        __u8  im_conv;
+        char  im_name[IDMAP_NAMESZ];
+        __u32 im_id;
+        __u8  im_status;
+};
+
+#ifdef __KERNEL__
+
+/* Forward declaration to make this header independent of others */
+struct nfs4_client;
+
+void nfs_idmap_new(struct nfs4_client *);
+void nfs_idmap_delete(struct nfs4_client *);
+
+int nfs_map_name_to_uid(struct nfs4_client *, const char *, size_t, __u32 *);
+int nfs_map_group_to_gid(struct nfs4_client *, const char *, size_t, __u32 *);
+int nfs_map_uid_to_name(struct nfs4_client *, __u32, char *);
+int nfs_map_gid_to_group(struct nfs4_client *, __u32, char *);
+#endif /* __KERNEL__ */
+
+#endif /* NFS_IDMAP_H */
diff --git a/include/linux/nfs_mount.h b/include/linux/nfs_mount.h
new file mode 100644
index 000000000000..0071428231f9
--- /dev/null
+++ b/include/linux/nfs_mount.h
@@ -0,0 +1,65 @@
+#ifndef _LINUX_NFS_MOUNT_H
+#define _LINUX_NFS_MOUNT_H
+
+/*
+ *  linux/include/linux/nfs_mount.h
+ *
+ *  Copyright (C) 1992  Rick Sladkey
+ *
+ *  structure passed from user-space to kernel-space during an nfs mount
+ */
+#include <linux/in.h>
+#include <linux/nfs.h>
+#include <linux/nfs2.h>
+#include <linux/nfs3.h>
+
+/*
+ * WARNING!  Do not delete or change the order of these fields.  If
+ * a new field is required then add it to the end.  The version field
+ * tracks which fields are present.  This will ensure some measure of
+ * mount-to-kernel version compatibility.  Some of these aren't used yet
+ * but here they are anyway.
+ */
+#define NFS_MOUNT_VERSION       6
+#define NFS_MAX_CONTEXT_LEN     256
+
+struct nfs_mount_data {
+        int             version;                /* 1 */
+        int             fd;                     /* 1 */
+        struct nfs2_fh  old_root;               /* 1 */
+        int             flags;                  /* 1 */
+        int             rsize;                  /* 1 */
+        int             wsize;                  /* 1 */
+        int             timeo;                  /* 1 */
+        int             retrans;                /* 1 */
+        int             acregmin;               /* 1 */
+        int             acregmax;               /* 1 */
+        int             acdirmin;               /* 1 */
+        int             acdirmax;               /* 1 */
+        struct sockaddr_in addr;                /* 1 */
+        char            hostname[256];          /* 1 */
+        int             namlen;                 /* 2 */
+        unsigned int    bsize;                  /* 3 */
+        struct nfs3_fh  root;                   /* 4 */
+        int             pseudoflavor;           /* 5 */
+        char            context[NFS_MAX_CONTEXT_LEN + 1];       /* 6 */
+};
+
+/* bits in the flags field */
+
+#define NFS_MOUNT_SOFT          0x0001  /* 1 */
+#define NFS_MOUNT_INTR          0x0002  /* 1 */
+#define NFS_MOUNT_SECURE        0x0004  /* 1 */
+#define NFS_MOUNT_POSIX         0x0008  /* 1 */
+#define NFS_MOUNT_NOCTO         0x0010  /* 1 */
+#define NFS_MOUNT_NOAC          0x0020  /* 1 */
+#define NFS_MOUNT_TCP           0x0040  /* 2 */
+#define NFS_MOUNT_VER3          0x0080  /* 3 */
+#define NFS_MOUNT_KERBEROS      0x0100  /* 3 */
+#define NFS_MOUNT_NONLM         0x0200  /* 3 */
+#define NFS_MOUNT_BROKEN_SUID   0x0400  /* 4 */
+#define NFS_MOUNT_STRICTLOCK    0x1000  /* reserved for NFSv4 */
+#define NFS_MOUNT_SECFLAVOUR    0x2000  /* 5 */
+#define NFS_MOUNT_FLAGMASK      0xFFFF
+
+#endif
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
new file mode 100644
index 000000000000..39e4895bcdb4
--- /dev/null
+++ b/include/linux/nfs_page.h
@@ -0,0 +1,151 @@
+/*
+ * linux/include/linux/nfs_page.h
+ *
+ * Copyright (C) 2000 Trond Myklebust
+ *
+ * NFS page cache wrapper.
+ */
+
+#ifndef _LINUX_NFS_PAGE_H
+#define _LINUX_NFS_PAGE_H
+
+
+#include <linux/list.h>
+#include <linux/pagemap.h>
+#include <linux/wait.h>
+#include <linux/nfs_fs_sb.h>
+#include <linux/sunrpc/auth.h>
+#include <linux/nfs_xdr.h>
+
+#include <asm/atomic.h>
+
+/*
+ * Valid flags for a dirty buffer
+ */
+#define PG_BUSY                 0
+#define PG_NEED_COMMIT          1
+#define PG_NEED_RESCHED         2
+
+struct nfs_page {
+        struct list_head        wb_list,        /* Defines state of page: */
+                                *wb_list_head;  /*      read/write/commit */
+        struct page             *wb_page;       /* page to read in/write out */
+        struct nfs_open_context *wb_context;    /* File state context info */
+        atomic_t                wb_complete;    /* i/os we're waiting for */
+        unsigned long           wb_index;       /* Offset >> PAGE_CACHE_SHIFT */
+        unsigned int            wb_offset,      /* Offset & ~PAGE_CACHE_MASK */
+                                wb_pgbase,      /* Start of page data */
+                                wb_bytes;       /* Length of request */
+        atomic_t                wb_count;       /* reference count */
+        unsigned long           wb_flags;
+        struct nfs_writeverf    wb_verf;        /* Commit cookie */
+};
+
+#define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
+#define NFS_NEED_COMMIT(req)    (test_bit(PG_NEED_COMMIT,&(req)->wb_flags))
+#define NFS_NEED_RESCHED(req)   (test_bit(PG_NEED_RESCHED,&(req)->wb_flags))
+
+extern  struct nfs_page *nfs_create_request(struct nfs_open_context *ctx,
+                                            struct inode *inode,
+                                            struct page *page,
+                                            unsigned int offset,
+                                            unsigned int count);
+extern  void nfs_clear_request(struct nfs_page *req);
+extern  void nfs_release_request(struct nfs_page *req);
+
+
+extern  void nfs_list_add_request(struct nfs_page *, struct list_head *);
+
+extern  int nfs_scan_list(struct list_head *, struct list_head *,
+                          unsigned long, unsigned int);
+extern  int nfs_coalesce_requests(struct list_head *, struct list_head *,
+                                  unsigned int);
+extern  int nfs_wait_on_request(struct nfs_page *);
+extern  void nfs_unlock_request(struct nfs_page *req);
+
+/*
+ * Lock the page of an asynchronous request without incrementing the wb_count
+ */
+static inline int
+nfs_lock_request_dontget(struct nfs_page *req)
+{
+        if (test_and_set_bit(PG_BUSY, &req->wb_flags))
+                return 0;
+        return 1;
+}
+
+/*
+ * Lock the page of an asynchronous request
+ */
+static inline int
+nfs_lock_request(struct nfs_page *req)
+{
+        if (test_and_set_bit(PG_BUSY, &req->wb_flags))
+                return 0;
+        atomic_inc(&req->wb_count);
+        return 1;
+}
+
+
+/**
+ * nfs_list_remove_request - Remove a request from its wb_list
+ * @req: request
+ */
+static inline void
+nfs_list_remove_request(struct nfs_page *req)
+{
+        if (list_empty(&req->wb_list))
+                return;
+        if (!NFS_WBACK_BUSY(req)) {
+                printk(KERN_ERR "NFS: unlocked request attempted removed from list!\n");
+                BUG();
+        }
+        list_del_init(&req->wb_list);
+        req->wb_list_head = NULL;
+}
+
+static inline int
+nfs_defer_commit(struct nfs_page *req)
+{
+        if (test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags))
+                return 0;
+        return 1;
+}
+
+static inline void
+nfs_clear_commit(struct nfs_page *req)
+{
+        smp_mb__before_clear_bit();
+        clear_bit(PG_NEED_COMMIT, &req->wb_flags);
+        smp_mb__after_clear_bit();
+}
+
+static inline int
+nfs_defer_reschedule(struct nfs_page *req)
+{
+        if (test_and_set_bit(PG_NEED_RESCHED, &req->wb_flags))
+                return 0;
+        return 1;
+}
+
+static inline void
+nfs_clear_reschedule(struct nfs_page *req)
+{
+        smp_mb__before_clear_bit();
+        clear_bit(PG_NEED_RESCHED, &req->wb_flags);
+        smp_mb__after_clear_bit();
+}
+
+static inline struct nfs_page *
+nfs_list_entry(struct list_head *head)
+{
+        return list_entry(head, struct nfs_page, wb_list);
+}
+
+static inline
+loff_t req_offset(struct nfs_page *req)
+{
+        return (((loff_t)req->wb_index) << PAGE_CACHE_SHIFT) + req->wb_offset;
+}
+
+#endif /* _LINUX_NFS_PAGE_H */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
new file mode 100644
index 000000000000..47037d9521cb
--- /dev/null
+++ b/include/linux/nfs_xdr.h
@@ -0,0 +1,735 @@
+#ifndef _LINUX_NFS_XDR_H
+#define _LINUX_NFS_XDR_H
+
+#include <linux/sunrpc/xprt.h>
+
+struct nfs4_fsid {
+        __u64 major;
+        __u64 minor;
+};
+
+struct nfs_fattr {
+        unsigned short          valid;          /* which fields are valid */
+        __u64                   pre_size;       /* pre_op_attr.size       */
+        struct timespec         pre_mtime;      /* pre_op_attr.mtime      */
+        struct timespec         pre_ctime;      /* pre_op_attr.ctime      */
+        enum nfs_ftype          type;           /* always use NFSv2 types */
+        __u32                   mode;
+        __u32                   nlink;
+        __u32                   uid;
+        __u32                   gid;
+        __u64                   size;
+        union {
+                struct {
+                        __u32   blocksize;
+                        __u32   blocks;
+                } nfs2;
+                struct {
+                        __u64   used;
+                } nfs3;
+        } du;
+        dev_t                   rdev;
+        union {
+                __u64           nfs3;           /* also nfs2 */
+                struct nfs4_fsid nfs4;
+        } fsid_u;
+        __u64                   fileid;
+        struct timespec         atime;
+        struct timespec         mtime;
+        struct timespec         ctime;
+        __u32                   bitmap[2];      /* NFSv4 returned attribute bitmap */
+        __u64                   change_attr;    /* NFSv4 change attribute */
+        __u64                   pre_change_attr;/* pre-op NFSv4 change attribute */
+        unsigned long           timestamp;
+};
+
+#define NFS_ATTR_WCC            0x0001          /* pre-op WCC data    */
+#define NFS_ATTR_FATTR          0x0002          /* post-op attributes */
+#define NFS_ATTR_FATTR_V3       0x0004          /* NFSv3 attributes */
+#define NFS_ATTR_FATTR_V4       0x0008
+#define NFS_ATTR_PRE_CHANGE     0x0010
+
+/*
+ * Info on the file system
+ */
+struct nfs_fsinfo {
+        struct nfs_fattr        *fattr; /* Post-op attributes */
+        __u32                   rtmax;  /* max.  read transfer size */
+        __u32                   rtpref; /* pref. read transfer size */
+        __u32                   rtmult; /* reads should be multiple of this */
+        __u32                   wtmax;  /* max.  write transfer size */
+        __u32                   wtpref; /* pref. write transfer size */
+        __u32                   wtmult; /* writes should be multiple of this */
+        __u32                   dtpref; /* pref. readdir transfer size */
+        __u64                   maxfilesize;
+        __u32                   lease_time; /* in seconds */
+};
+
+struct nfs_fsstat {
+        struct nfs_fattr        *fattr; /* Post-op attributes */
+        __u64                   tbytes; /* total size in bytes */
+        __u64                   fbytes; /* # of free bytes */
+        __u64                   abytes; /* # of bytes available to user */
+        __u64                   tfiles; /* # of files */
+        __u64                   ffiles; /* # of free files */
+        __u64                   afiles; /* # of files available to user */
+};
+
+struct nfs2_fsstat {
+        __u32                   tsize;  /* Server transfer size */
+        __u32                   bsize;  /* Filesystem block size */
+        __u32                   blocks; /* No. of "bsize" blocks on filesystem */
+        __u32                   bfree;  /* No. of free "bsize" blocks */
+        __u32                   bavail; /* No. of available "bsize" blocks */
+};
+
+struct nfs_pathconf {
+        struct nfs_fattr        *fattr; /* Post-op attributes */
+        __u32                   max_link; /* max # of hard links */
+        __u32                   max_namelen; /* max name length */
+};
+
+struct nfs4_change_info {
+        u32                     atomic;
+        u64                     before;
+        u64                     after;
+};
+
+/*
+ * Arguments to the open call.
+ */
+struct nfs_openargs {
+        const struct nfs_fh *   fh;
+        __u32                   seqid;
+        int                     open_flags;
+        __u64                   clientid;
+        __u32                   id;
+        union {
+                struct iattr *  attrs;    /* UNCHECKED, GUARDED */
+                nfs4_verifier   verifier; /* EXCLUSIVE */
+                nfs4_stateid    delegation;             /* CLAIM_DELEGATE_CUR */
+                int             delegation_type;        /* CLAIM_PREVIOUS */
+        } u;
+        const struct qstr *     name;
+        const struct nfs_server *server;         /* Needed for ID mapping */
+        const u32 *             bitmask;
+        __u32                   claim;
+};
+
+struct nfs_openres {
+        nfs4_stateid            stateid;
+        struct nfs_fh           fh;
+        struct nfs4_change_info cinfo;
+        __u32                   rflags;
+        struct nfs_fattr *      f_attr;
+        const struct nfs_server *server;
+        int                     delegation_type;
+        nfs4_stateid            delegation;
+        __u32                   do_recall;
+        __u64                   maxsize;
+};
+
+/*
+ * Arguments to the open_confirm call.
+ */
+struct nfs_open_confirmargs {
+        const struct nfs_fh *   fh;
+        nfs4_stateid            stateid;
+        __u32                   seqid;
+};
+
+struct nfs_open_confirmres {
+        nfs4_stateid            stateid;
+};
+
+/*
+ * Arguments to the close call.
+ */
+struct nfs_closeargs {
+        struct nfs_fh *         fh;
+        nfs4_stateid            stateid;
+        __u32                   seqid;
+        int                     open_flags;
+};
+
+struct nfs_closeres {
+        nfs4_stateid            stateid;
+};
+/*
+ *  * Arguments to the lock,lockt, and locku call.
+ *   */
+struct nfs_lowner {
+        __u64           clientid;
+        u32                     id;
+};
+
+struct nfs_open_to_lock {
+        __u32                   open_seqid;
+        nfs4_stateid            open_stateid;
+        __u32                   lock_seqid;
+        struct nfs_lowner       lock_owner;
+};
+
+struct nfs_exist_lock {
+        nfs4_stateid            stateid;
+        __u32                   seqid;
+};
+
+struct nfs_lock_opargs {
+        __u32                   reclaim;
+        __u32                   new_lock_owner;
+        union {
+                struct nfs_open_to_lock *open_lock;
+                struct nfs_exist_lock   *exist_lock;
+        } u;
+};
+
+struct nfs_locku_opargs {
+        __u32                   seqid;
+        nfs4_stateid            stateid;
+};
+
+struct nfs_lockargs {
+        struct nfs_fh *         fh;
+        __u32                   type;
+        __u64                   offset; 
+        __u64                   length; 
+        union {
+                struct nfs_lock_opargs  *lock;    /* LOCK  */
+                struct nfs_lowner       *lockt;  /* LOCKT */
+                struct nfs_locku_opargs *locku;  /* LOCKU */
+        } u;
+};
+
+struct nfs_lock_denied {
+        __u64                   offset;
+        __u64                   length;
+        __u32                   type;
+        struct nfs_lowner       owner;
+};
+
+struct nfs_lockres {
+        union {
+                nfs4_stateid            stateid;/* LOCK success, LOCKU */
+                struct nfs_lock_denied  denied; /* LOCK failed, LOCKT success */
+        } u;
+        const struct nfs_server *       server;
+};
+
+struct nfs4_delegreturnargs {
+        const struct nfs_fh *fhandle;
+        const nfs4_stateid *stateid;
+};
+
+/*
+ * Arguments to the read call.
+ */
+
+#define NFS_READ_MAXIOV         (9U)
+#if (NFS_READ_MAXIOV > (MAX_IOVEC -2))
+#error "NFS_READ_MAXIOV is too large"
+#endif
+
+struct nfs_readargs {
+        struct nfs_fh *         fh;
+        struct nfs_open_context *context;
+        __u64                   offset;
+        __u32                   count;
+        unsigned int            pgbase;
+        struct page **          pages;
+};
+
+struct nfs_readres {
+        struct nfs_fattr *      fattr;
+        __u32                   count;
+        int                     eof;
+};
+
+/*
+ * Arguments to the write call.
+ */
+#define NFS_WRITE_MAXIOV        (9U)
+#if (NFS_WRITE_MAXIOV > (MAX_IOVEC -2))
+#error "NFS_WRITE_MAXIOV is too large"
+#endif
+
+struct nfs_writeargs {
+        struct nfs_fh *         fh;
+        struct nfs_open_context *context;
+        __u64                   offset;
+        __u32                   count;
+        enum nfs3_stable_how    stable;
+        unsigned int            pgbase;
+        struct page **          pages;
+};
+
+struct nfs_writeverf {
+        enum nfs3_stable_how    committed;
+        __u32                   verifier[2];
+};
+
+struct nfs_writeres {
+        struct nfs_fattr *      fattr;
+        struct nfs_writeverf *  verf;
+        __u32                   count;
+};
+
+/*
+ * Argument struct for decode_entry function
+ */
+struct nfs_entry {
+        __u64                   ino;
+        __u64                   cookie,
+                                prev_cookie;
+        const char *            name;
+        unsigned int            len;
+        int                     eof;
+        struct nfs_fh *         fh;
+        struct nfs_fattr *      fattr;
+};
+
+/*
+ * The following types are for NFSv2 only.
+ */
+struct nfs_sattrargs {
+        struct nfs_fh *         fh;
+        struct iattr *          sattr;
+};
+
+struct nfs_diropargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+};
+
+struct nfs_createargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+        struct iattr *          sattr;
+};
+
+struct nfs_renameargs {
+        struct nfs_fh *         fromfh;
+        const char *            fromname;
+        unsigned int            fromlen;
+        struct nfs_fh *         tofh;
+        const char *            toname;
+        unsigned int            tolen;
+};
+
+struct nfs_setattrargs {
+        struct nfs_fh *                 fh;
+        nfs4_stateid                    stateid;
+        struct iattr *                  iap;
+        const struct nfs_server *       server; /* Needed for name mapping */
+        const u32 *                     bitmask;
+};
+
+struct nfs_setattrres {
+        struct nfs_fattr *              fattr;
+        const struct nfs_server *       server;
+};
+
+struct nfs_linkargs {
+        struct nfs_fh *         fromfh;
+        struct nfs_fh *         tofh;
+        const char *            toname;
+        unsigned int            tolen;
+};
+
+struct nfs_symlinkargs {
+        struct nfs_fh *         fromfh;
+        const char *            fromname;
+        unsigned int            fromlen;
+        const char *            topath;
+        unsigned int            tolen;
+        struct iattr *          sattr;
+};
+
+struct nfs_readdirargs {
+        struct nfs_fh *         fh;
+        __u32                   cookie;
+        unsigned int            count;
+        struct page **          pages;
+};
+
+struct nfs_diropok {
+        struct nfs_fh *         fh;
+        struct nfs_fattr *      fattr;
+};
+
+struct nfs_readlinkargs {
+        struct nfs_fh *         fh;
+        unsigned int            pgbase;
+        unsigned int            pglen;
+        struct page **          pages;
+};
+
+struct nfs3_sattrargs {
+        struct nfs_fh *         fh;
+        struct iattr *          sattr;
+        unsigned int            guard;
+        struct timespec         guardtime;
+};
+
+struct nfs3_diropargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+};
+
+struct nfs3_accessargs {
+        struct nfs_fh *         fh;
+        __u32                   access;
+};
+
+struct nfs3_createargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+        struct iattr *          sattr;
+        enum nfs3_createmode    createmode;
+        __u32                   verifier[2];
+};
+
+struct nfs3_mkdirargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+        struct iattr *          sattr;
+};
+
+struct nfs3_symlinkargs {
+        struct nfs_fh *         fromfh;
+        const char *            fromname;
+        unsigned int            fromlen;
+        const char *            topath;
+        unsigned int            tolen;
+        struct iattr *          sattr;
+};
+
+struct nfs3_mknodargs {
+        struct nfs_fh *         fh;
+        const char *            name;
+        unsigned int            len;
+        enum nfs3_ftype         type;
+        struct iattr *          sattr;
+        dev_t                   rdev;
+};
+
+struct nfs3_renameargs {
+        struct nfs_fh *         fromfh;
+        const char *            fromname;
+        unsigned int            fromlen;
+        struct nfs_fh *         tofh;
+        const char *            toname;
+        unsigned int            tolen;
+};
+
+struct nfs3_linkargs {
+        struct nfs_fh *         fromfh;
+        struct nfs_fh *         tofh;
+        const char *            toname;
+        unsigned int            tolen;
+};
+
+struct nfs3_readdirargs {
+        struct nfs_fh *         fh;
+        __u64                   cookie;
+        __u32                   verf[2];
+        int                     plus;
+        unsigned int            count;
+        struct page **          pages;
+};
+
+struct nfs3_diropres {
+        struct nfs_fattr *      dir_attr;
+        struct nfs_fh *         fh;
+        struct nfs_fattr *      fattr;
+};
+
+struct nfs3_accessres {
+        struct nfs_fattr *      fattr;
+        __u32                   access;
+};
+
+struct nfs3_readlinkargs {
+        struct nfs_fh *         fh;
+        unsigned int            pgbase;
+        unsigned int            pglen;
+        struct page **          pages;
+};
+
+struct nfs3_renameres {
+        struct nfs_fattr *      fromattr;
+        struct nfs_fattr *      toattr;
+};
+
+struct nfs3_linkres {
+        struct nfs_fattr *      dir_attr;
+        struct nfs_fattr *      fattr;
+};
+
+struct nfs3_readdirres {
+        struct nfs_fattr *      dir_attr;
+        __u32 *                 verf;
+        int                     plus;
+};
+
+#ifdef CONFIG_NFS_V4
+
+typedef u64 clientid4;
+
+struct nfs4_accessargs {
+        const struct nfs_fh *           fh;
+        u32                             access;
+};
+
+struct nfs4_accessres {
+        u32                             supported;
+        u32                             access;
+};
+
+struct nfs4_create_arg {
+        u32                             ftype;
+        union {
+                struct qstr *           symlink;    /* NF4LNK */
+                struct {
+                        u32             specdata1;
+                        u32             specdata2;
+                } device;    /* NF4BLK, NF4CHR */
+        } u;
+        const struct qstr *             name;
+        const struct nfs_server *       server;
+        const struct iattr *            attrs;
+        const struct nfs_fh *           dir_fh;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_create_res {
+        const struct nfs_server *       server;
+        struct nfs_fh *                 fh;
+        struct nfs_fattr *              fattr;
+        struct nfs4_change_info         dir_cinfo;
+};
+
+struct nfs4_fsinfo_arg {
+        const struct nfs_fh *           fh;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_getattr_arg {
+        const struct nfs_fh *           fh;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_getattr_res {
+        const struct nfs_server *       server;
+        struct nfs_fattr *              fattr;
+};
+
+struct nfs4_link_arg {
+        const struct nfs_fh *           fh;
+        const struct nfs_fh *           dir_fh;
+        const struct qstr *             name;
+};
+
+struct nfs4_lookup_arg {
+        const struct nfs_fh *           dir_fh;
+        const struct qstr *             name;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_lookup_res {
+        const struct nfs_server *       server;
+        struct nfs_fattr *              fattr;
+        struct nfs_fh *                 fh;
+};
+
+struct nfs4_lookup_root_arg {
+        const u32 *                     bitmask;
+};
+
+struct nfs4_pathconf_arg {
+        const struct nfs_fh *           fh;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_readdir_arg {
+        const struct nfs_fh *           fh;
+        u64                             cookie;
+        nfs4_verifier                   verifier;
+        u32                             count;
+        struct page **                  pages;  /* zero-copy data */
+        unsigned int                    pgbase; /* zero-copy data */
+        const u32 *                     bitmask;
+};
+
+struct nfs4_readdir_res {
+        nfs4_verifier                   verifier;
+        unsigned int                    pgbase;
+};
+
+struct nfs4_readlink {
+        const struct nfs_fh *           fh;
+        unsigned int                    pgbase;
+        unsigned int                    pglen;   /* zero-copy data */
+        struct page **                  pages;   /* zero-copy data */
+};
+
+struct nfs4_remove_arg {
+        const struct nfs_fh *           fh;
+        const struct qstr *             name;
+};
+
+struct nfs4_rename_arg {
+        const struct nfs_fh *           old_dir;
+        const struct nfs_fh *           new_dir;
+        const struct qstr *             old_name;
+        const struct qstr *             new_name;
+};
+
+struct nfs4_rename_res {
+        struct nfs4_change_info         old_cinfo;
+        struct nfs4_change_info         new_cinfo;
+};
+
+struct nfs4_setclientid {
+        const nfs4_verifier *           sc_verifier;      /* request */
+        unsigned int                    sc_name_len;
+        char                            sc_name[32];      /* request */
+        u32                             sc_prog;          /* request */
+        unsigned int                    sc_netid_len;
+        char                            sc_netid[4];      /* request */
+        unsigned int                    sc_uaddr_len;
+        char                            sc_uaddr[24];     /* request */
+        u32                             sc_cb_ident;      /* request */
+};
+
+struct nfs4_statfs_arg {
+        const struct nfs_fh *           fh;
+        const u32 *                     bitmask;
+};
+
+struct nfs4_server_caps_res {
+        u32                             attr_bitmask[2];
+        u32                             acl_bitmask;
+        u32                             has_links;
+        u32                             has_symlinks;
+};
+
+#endif /* CONFIG_NFS_V4 */
+
+struct nfs_page;
+
+struct nfs_read_data {
+        int                     flags;
+        struct rpc_task         task;
+        struct inode            *inode;
+        struct rpc_cred         *cred;
+        struct nfs_fattr        fattr;  /* fattr storage */
+        struct list_head        pages;  /* Coalesced read requests */
+        struct nfs_page         *req;   /* multi ops per nfs_page */
+        struct page             *pagevec[NFS_READ_MAXIOV];
+        struct nfs_readargs args;
+        struct nfs_readres  res;
+#ifdef CONFIG_NFS_V4
+        unsigned long           timestamp;      /* For lease renewal */
+#endif
+        void (*complete) (struct nfs_read_data *, int);
+};
+
+struct nfs_write_data {
+        int                     flags;
+        struct rpc_task         task;
+        struct inode            *inode;
+        struct rpc_cred         *cred;
+        struct nfs_fattr        fattr;
+        struct nfs_writeverf    verf;
+        struct list_head        pages;          /* Coalesced requests we wish to flush */
+        struct nfs_page         *req;           /* multi ops per nfs_page */
+        struct page             *pagevec[NFS_WRITE_MAXIOV];
+        struct nfs_writeargs    args;           /* argument struct */
+        struct nfs_writeres     res;            /* result struct */
+#ifdef CONFIG_NFS_V4
+        unsigned long           timestamp;      /* For lease renewal */
+#endif
+        void (*complete) (struct nfs_write_data *, int);
+};
+
+struct nfs_access_entry;
+
+/*
+ * RPC procedure vector for NFSv2/NFSv3 demuxing
+ */
+struct nfs_rpc_ops {
+        int     version;                /* Protocol version */
+        struct dentry_operations *dentry_ops;
+        struct inode_operations *dir_inode_ops;
+
+        int     (*getroot) (struct nfs_server *, struct nfs_fh *,
+                            struct nfs_fsinfo *);
+        int     (*getattr) (struct nfs_server *, struct nfs_fh *,
+                            struct nfs_fattr *);
+        int     (*setattr) (struct dentry *, struct nfs_fattr *,
+                            struct iattr *);
+        int     (*lookup)  (struct inode *, struct qstr *,
+                            struct nfs_fh *, struct nfs_fattr *);
+        int     (*access)  (struct inode *, struct nfs_access_entry *);
+        int     (*readlink)(struct inode *, struct page *, unsigned int,
+                            unsigned int);
+        int     (*read)    (struct nfs_read_data *);
+        int     (*write)   (struct nfs_write_data *);
+        int     (*commit)  (struct nfs_write_data *);
+        int     (*create)  (struct inode *, struct dentry *,
+                            struct iattr *, int);
+        int     (*remove)  (struct inode *, struct qstr *);
+        int     (*unlink_setup)  (struct rpc_message *,
+                            struct dentry *, struct qstr *);
+        int     (*unlink_done) (struct dentry *, struct rpc_task *);
+        int     (*rename)  (struct inode *, struct qstr *,
+                            struct inode *, struct qstr *);
+        int     (*link)    (struct inode *, struct inode *, struct qstr *);
+        int     (*symlink) (struct inode *, struct qstr *, struct qstr *,
+                            struct iattr *, struct nfs_fh *,
+                            struct nfs_fattr *);
+        int     (*mkdir)   (struct inode *, struct dentry *, struct iattr *);
+        int     (*rmdir)   (struct inode *, struct qstr *);
+        int     (*readdir) (struct dentry *, struct rpc_cred *,
+                            u64, struct page *, unsigned int, int);
+        int     (*mknod)   (struct inode *, struct dentry *, struct iattr *,
+                            dev_t);
+        int     (*statfs)  (struct nfs_server *, struct nfs_fh *,
+                            struct nfs_fsstat *);
+        int     (*fsinfo)  (struct nfs_server *, struct nfs_fh *,
+                            struct nfs_fsinfo *);
+        int     (*pathconf) (struct nfs_server *, struct nfs_fh *,
+                             struct nfs_pathconf *);
+        u32 *   (*decode_dirent)(u32 *, struct nfs_entry *, int plus);
+        void    (*read_setup)   (struct nfs_read_data *);
+        void    (*write_setup)  (struct nfs_write_data *, int how);
+        void    (*commit_setup) (struct nfs_write_data *, int how);
+        int     (*file_open)   (struct inode *, struct file *);
+        int     (*file_release) (struct inode *, struct file *);
+        int     (*lock)(struct file *, int, struct file_lock *);
+};
+
+/*
+ *      NFS_CALL(getattr, inode, (fattr));
+ * into
+ *      NFS_PROTO(inode)->getattr(fattr);
+ */
+#define NFS_CALL(op, inode, args)       NFS_PROTO(inode)->op args
+
+/*
+ * Function vectors etc. for the NFS client
+ */
+extern struct nfs_rpc_ops       nfs_v2_clientops;
+extern struct nfs_rpc_ops       nfs_v3_clientops;
+extern struct nfs_rpc_ops       nfs_v4_clientops;
+extern struct rpc_version       nfs_version2;
+extern struct rpc_version       nfs_version3;
+extern struct rpc_version       nfs_version4;
+
+#endif
diff --git a/include/linux/nfsd/auth.h b/include/linux/nfsd/auth.h
new file mode 100644
index 000000000000..0fb9f7212195
--- /dev/null
+++ b/include/linux/nfsd/auth.h
@@ -0,0 +1,27 @@
+/*
+ * include/linux/nfsd/auth.h
+ *
+ * nfsd-specific authentication stuff.
+ * uid/gid mapping not yet implemented.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_NFSD_AUTH_H
+#define LINUX_NFSD_AUTH_H
+
+#ifdef __KERNEL__
+
+#define nfsd_luid(rq, uid)      ((u32)(uid))
+#define nfsd_lgid(rq, gid)      ((u32)(gid))
+#define nfsd_ruid(rq, uid)      ((u32)(uid))
+#define nfsd_rgid(rq, gid)      ((u32)(gid))
+
+/*
+ * Set the current process's fsuid/fsgid etc to those of the NFS
+ * client user
+ */
+int nfsd_setuser(struct svc_rqst *, struct svc_export *);
+
+#endif /* __KERNEL__ */
+#endif /* LINUX_NFSD_AUTH_H */
diff --git a/include/linux/nfsd/cache.h b/include/linux/nfsd/cache.h
new file mode 100644
index 000000000000..c3a3557c2a5b
--- /dev/null
+++ b/include/linux/nfsd/cache.h
@@ -0,0 +1,81 @@
+/*
+ * include/linux/nfsd/cache.h
+ *
+ * Request reply cache. This was heavily inspired by the
+ * implementation in 4.3BSD/4.4BSD.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef NFSCACHE_H
+#define NFSCACHE_H
+
+#ifdef __KERNEL__
+#include <linux/in.h>
+#include <linux/uio.h>
+
+/*
+ * Representation of a reply cache entry. The first two members *must*
+ * be hash_next and hash_prev.
+ */
+struct svc_cacherep {
+        struct hlist_node       c_hash;
+        struct list_head        c_lru;
+
+        unsigned char           c_state,        /* unused, inprog, done */
+                                c_type,         /* status, buffer */
+                                c_secure : 1;   /* req came from port < 1024 */
+        struct sockaddr_in      c_addr;
+        u32                     c_xid;
+        u32                     c_prot;
+        u32                     c_proc;
+        u32                     c_vers;
+        unsigned long           c_timestamp;
+        union {
+                struct kvec     u_vec;
+                u32             u_status;
+        }                       c_u;
+};
+
+#define c_replvec               c_u.u_vec
+#define c_replstat              c_u.u_status
+
+/* cache entry states */
+enum {
+        RC_UNUSED,
+        RC_INPROG,
+        RC_DONE
+};
+
+/* return values */
+enum {
+        RC_DROPIT,
+        RC_REPLY,
+        RC_DOIT,
+        RC_INTR
+};
+
+/*
+ * Cache types.
+ * We may want to add more types one day, e.g. for diropres and
+ * attrstat replies. Using cache entries with fixed length instead
+ * of buffer pointers may be more efficient.
+ */
+enum {
+        RC_NOCACHE,
+        RC_REPLSTAT,
+        RC_REPLBUFF,
+};
+
+/*
+ * If requests are retransmitted within this interval, they're dropped.
+ */
+#define RC_DELAY                (HZ/5)
+
+void    nfsd_cache_init(void);
+void    nfsd_cache_shutdown(void);
+int     nfsd_cache_lookup(struct svc_rqst *, int);
+void    nfsd_cache_update(struct svc_rqst *, int, u32 *);
+
+#endif /* __KERNEL__ */
+#endif /* NFSCACHE_H */
diff --git a/include/linux/nfsd/const.h b/include/linux/nfsd/const.h
new file mode 100644
index 000000000000..b75bb1b38d09
--- /dev/null
+++ b/include/linux/nfsd/const.h
@@ -0,0 +1,45 @@
+/*
+ * include/linux/nfsd/const.h
+ *
+ * Various constants related to NFS.
+ *
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_NFSD_CONST_H
+#define _LINUX_NFSD_CONST_H
+
+#include <linux/nfs.h>
+#include <linux/nfs2.h>
+#include <linux/nfs3.h>
+#include <linux/nfs4.h>
+
+/*
+ * Maximum protocol version supported by knfsd
+ */
+#define NFSSVC_MAXVERS          3
+
+/*
+ * Maximum blocksize supported by daemon currently at 32K
+ */
+#define NFSSVC_MAXBLKSIZE       (32*1024)
+
+#ifdef __KERNEL__
+
+#ifndef NFS_SUPER_MAGIC
+# define NFS_SUPER_MAGIC        0x6969
+#endif
+
+#define NFSD_BUFSIZE            (1024 + NFSSVC_MAXBLKSIZE)
+
+#ifdef CONFIG_NFSD_V4
+# define NFSSVC_XDRSIZE         NFS4_SVC_XDRSIZE
+#elif defined(CONFIG_NFSD_V3)
+# define NFSSVC_XDRSIZE         NFS3_SVC_XDRSIZE
+#else
+# define NFSSVC_XDRSIZE         NFS2_SVC_XDRSIZE
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_NFSD_CONST_H */
diff --git a/include/linux/nfsd/debug.h b/include/linux/nfsd/debug.h
new file mode 100644
index 000000000000..ee4aa91788e7
--- /dev/null
+++ b/include/linux/nfsd/debug.h
@@ -0,0 +1,48 @@
+/*
+ * linux/include/linux/nfsd/debug.h
+ *
+ * Debugging-related stuff for nfsd
+ *
+ * Copyright (C) 1995 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_NFSD_DEBUG_H
+#define LINUX_NFSD_DEBUG_H
+
+#include <linux/sunrpc/debug.h>
+
+/*
+ * Enable debugging for nfsd.
+ * Requires RPC_DEBUG.
+ */
+#ifdef RPC_DEBUG
+# define NFSD_DEBUG             1
+#endif
+
+/*
+ * knfsd debug flags
+ */
+#define NFSDDBG_SOCK            0x0001
+#define NFSDDBG_FH              0x0002
+#define NFSDDBG_EXPORT          0x0004
+#define NFSDDBG_SVC             0x0008
+#define NFSDDBG_PROC            0x0010
+#define NFSDDBG_FILEOP          0x0020
+#define NFSDDBG_AUTH            0x0040
+#define NFSDDBG_REPCACHE        0x0080
+#define NFSDDBG_XDR             0x0100
+#define NFSDDBG_LOCKD           0x0200
+#define NFSDDBG_ALL             0x7FFF
+#define NFSDDBG_NOCHANGE        0xFFFF
+
+
+#ifdef __KERNEL__
+# undef ifdebug
+# ifdef NFSD_DEBUG
+#  define ifdebug(flag)         if (nfsd_debug & NFSDDBG_##flag)
+# else
+#  define ifdebug(flag)         if (0)
+# endif
+#endif /* __KERNEL__ */
+
+#endif /* LINUX_NFSD_DEBUG_H */
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
new file mode 100644
index 000000000000..6bad4766d3d9
--- /dev/null
+++ b/include/linux/nfsd/export.h
@@ -0,0 +1,137 @@
+/*
+ * include/linux/nfsd/export.h
+ * 
+ * Public declarations for NFS exports. The definitions for the
+ * syscall interface are in nfsctl.h
+ *
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef NFSD_EXPORT_H
+#define NFSD_EXPORT_H
+
+#include <asm/types.h>
+#ifdef __KERNEL__
+# include <linux/types.h>
+# include <linux/in.h>
+#endif
+
+/*
+ * Important limits for the exports stuff.
+ */
+#define NFSCLNT_IDMAX           1024
+#define NFSCLNT_ADDRMAX         16
+#define NFSCLNT_KEYMAX          32
+
+/*
+ * Export flags.
+ */
+#define NFSEXP_READONLY         0x0001
+#define NFSEXP_INSECURE_PORT    0x0002
+#define NFSEXP_ROOTSQUASH       0x0004
+#define NFSEXP_ALLSQUASH        0x0008
+#define NFSEXP_ASYNC            0x0010
+#define NFSEXP_GATHERED_WRITES  0x0020
+/* 40 80 100 currently unused */
+#define NFSEXP_NOHIDE           0x0200
+#define NFSEXP_NOSUBTREECHECK   0x0400
+#define NFSEXP_NOAUTHNLM        0x0800          /* Don't authenticate NLM requests - just trust */
+#define NFSEXP_MSNFS            0x1000  /* do silly things that MS clients expect */
+#define NFSEXP_FSID             0x2000
+#define NFSEXP_CROSSMOUNT       0x4000
+#define NFSEXP_NOACL            0x8000  /* reserved for possible ACL related use */
+#define NFSEXP_ALLFLAGS         0xFE3F
+
+
+#ifdef __KERNEL__
+
+struct svc_export {
+        struct cache_head       h;
+        struct auth_domain *    ex_client;
+        int                     ex_flags;
+        struct vfsmount *       ex_mnt;
+        struct dentry *         ex_dentry;
+        uid_t                   ex_anon_uid;
+        gid_t                   ex_anon_gid;
+        int                     ex_fsid;
+};
+
+/* an "export key" (expkey) maps a filehandlefragement to an
+ * svc_export for a given client.  There can be two per export, one
+ * for type 0 (dev/ino), one for type 1 (fsid)
+ */
+struct svc_expkey {
+        struct cache_head       h;
+
+        struct auth_domain *    ek_client;
+        int                     ek_fsidtype;
+        u32                     ek_fsid[3];
+
+        struct svc_export *     ek_export;
+};
+
+#define EX_SECURE(exp)          (!((exp)->ex_flags & NFSEXP_INSECURE_PORT))
+#define EX_ISSYNC(exp)          (!((exp)->ex_flags & NFSEXP_ASYNC))
+#define EX_RDONLY(exp)          ((exp)->ex_flags & NFSEXP_READONLY)
+#define EX_NOHIDE(exp)          ((exp)->ex_flags & NFSEXP_NOHIDE)
+#define EX_WGATHER(exp)         ((exp)->ex_flags & NFSEXP_GATHERED_WRITES)
+
+
+/*
+ * Function declarations
+ */
+void                    nfsd_export_init(void);
+void                    nfsd_export_shutdown(void);
+void                    nfsd_export_flush(void);
+void                    exp_readlock(void);
+void                    exp_readunlock(void);
+struct svc_expkey *     exp_find_key(struct auth_domain *clp, 
+                                     int fsid_type, u32 *fsidv,
+                                     struct cache_req *reqp);
+struct svc_export *     exp_get_by_name(struct auth_domain *clp,
+                                        struct vfsmount *mnt,
+                                        struct dentry *dentry,
+                                        struct cache_req *reqp);
+struct svc_export *     exp_parent(struct auth_domain *clp,
+                                   struct vfsmount *mnt,
+                                   struct dentry *dentry,
+                                   struct cache_req *reqp);
+int                     exp_rootfh(struct auth_domain *, 
+                                        char *path, struct knfsd_fh *, int maxsize);
+int                     exp_pseudoroot(struct auth_domain *, struct svc_fh *fhp, struct cache_req *creq);
+int                     nfserrno(int errno);
+
+extern void expkey_put(struct cache_head *item, struct cache_detail *cd);
+extern void svc_export_put(struct cache_head *item, struct cache_detail *cd);
+extern struct cache_detail svc_export_cache, svc_expkey_cache;
+
+static inline void exp_put(struct svc_export *exp)
+{
+        svc_export_put(&exp->h, &svc_export_cache);
+}
+
+static inline void exp_get(struct svc_export *exp)
+{
+        cache_get(&exp->h);
+}
+static inline struct svc_export *
+exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
+         struct cache_req *reqp)
+{
+        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
+        if (ek && !IS_ERR(ek)) {
+                struct svc_export *exp = ek->ek_export;
+                int err;
+                exp_get(exp);
+                expkey_put(&ek->h, &svc_expkey_cache);
+                if ((err = cache_check(&svc_export_cache, &exp->h, reqp)))
+                        exp = ERR_PTR(err);
+                return exp;
+        } else
+                return ERR_PTR(PTR_ERR(ek));
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* NFSD_EXPORT_H */
+
diff --git a/include/linux/nfsd/interface.h b/include/linux/nfsd/interface.h
new file mode 100644
index 000000000000..af0979704afb
--- /dev/null
+++ b/include/linux/nfsd/interface.h
@@ -0,0 +1,13 @@
+/*
+ * include/linux/nfsd/interface.h
+ *
+ * defines interface between nfsd and other bits of
+ * the kernel.  Particularly filesystems (eventually).
+ *
+ * Copyright (C) 2000 Neil Brown <neilb@cse.unsw.edu.au>
+ */
+
+#ifndef LINUX_NFSD_INTERFACE_H
+#define LINUX_NFSD_INTERFACE_H
+
+#endif /* LINUX_NFSD_INTERFACE_H */
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
new file mode 100644
index 000000000000..8f85d9a59607
--- /dev/null
+++ b/include/linux/nfsd/nfsd.h
@@ -0,0 +1,311 @@
+/*
+ * linux/include/linux/nfsd/nfsd.h
+ *
+ * Hodge-podge collection of knfsd-related stuff.
+ * I will sort this out later.
+ *
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_NFSD_NFSD_H
+#define LINUX_NFSD_NFSD_H
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/unistd.h>
+#include <linux/dirent.h>
+#include <linux/fs.h>
+#include <linux/mount.h>
+
+#include <linux/nfsd/debug.h>
+#include <linux/nfsd/nfsfh.h>
+#include <linux/nfsd/export.h>
+#include <linux/nfsd/auth.h>
+#include <linux/nfsd/stats.h>
+#include <linux/nfsd/interface.h>
+/*
+ * nfsd version
+ */
+#define NFSD_VERSION            "0.5"
+#define NFSD_SUPPORTED_MINOR_VERSION    0
+
+#ifdef __KERNEL__
+/*
+ * Special flags for nfsd_permission. These must be different from MAY_READ,
+ * MAY_WRITE, and MAY_EXEC.
+ */
+#define MAY_NOP                 0
+#define MAY_SATTR               8
+#define MAY_TRUNC               16
+#define MAY_LOCK                32
+#define MAY_OWNER_OVERRIDE      64
+#define MAY_LOCAL_ACCESS        128 /* IRIX doing local access check on device special file*/
+#if (MAY_SATTR | MAY_TRUNC | MAY_LOCK | MAY_OWNER_OVERRIDE | MAY_LOCAL_ACCESS) & (MAY_READ | MAY_WRITE | MAY_EXEC)
+# error "please use a different value for MAY_SATTR or MAY_TRUNC or MAY_LOCK or MAY_LOCAL_ACCESS or MAY_OWNER_OVERRIDE."
+#endif
+#define MAY_CREATE              (MAY_EXEC|MAY_WRITE)
+#define MAY_REMOVE              (MAY_EXEC|MAY_WRITE|MAY_TRUNC)
+
+/*
+ * Callback function for readdir
+ */
+struct readdir_cd {
+        int                     err;    /* 0, nfserr, or nfserr_eof */
+};
+typedef int             (*encode_dent_fn)(struct readdir_cd *, const char *,
+                                                int, loff_t, ino_t, unsigned int);
+typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
+
+extern struct svc_program       nfsd_program;
+extern struct svc_version       nfsd_version2, nfsd_version3,
+                                nfsd_version4;
+
+/*
+ * Function prototypes.
+ */
+int             nfsd_svc(unsigned short port, int nrservs);
+int             nfsd_dispatch(struct svc_rqst *rqstp, u32 *statp);
+
+/* nfsd/vfs.c */
+int             fh_lock_parent(struct svc_fh *, struct dentry *);
+int             nfsd_racache_init(int);
+void            nfsd_racache_shutdown(void);
+int             nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
+                                struct svc_export **expp);
+int             nfsd_lookup(struct svc_rqst *, struct svc_fh *,
+                                const char *, int, struct svc_fh *);
+int             nfsd_setattr(struct svc_rqst *, struct svc_fh *,
+                                struct iattr *, int, time_t);
+#ifdef CONFIG_NFSD_V4
+int             nfsd4_set_nfs4_acl(struct svc_rqst *, struct svc_fh *,
+                    struct nfs4_acl *);
+int             nfsd4_get_nfs4_acl(struct svc_rqst *, struct dentry *, struct nfs4_acl **);
+#endif /* CONFIG_NFSD_V4 */
+int             nfsd_create(struct svc_rqst *, struct svc_fh *,
+                                char *name, int len, struct iattr *attrs,
+                                int type, dev_t rdev, struct svc_fh *res);
+#ifdef CONFIG_NFSD_V3
+int             nfsd_access(struct svc_rqst *, struct svc_fh *, u32 *, u32 *);
+int             nfsd_create_v3(struct svc_rqst *, struct svc_fh *,
+                                char *name, int len, struct iattr *attrs,
+                                struct svc_fh *res, int createmode,
+                                u32 *verifier, int *truncp);
+int             nfsd_commit(struct svc_rqst *, struct svc_fh *,
+                                loff_t, unsigned long);
+#endif /* CONFIG_NFSD_V3 */
+int             nfsd_open(struct svc_rqst *, struct svc_fh *, int,
+                                int, struct file **);
+void            nfsd_close(struct file *);
+int             nfsd_read(struct svc_rqst *, struct svc_fh *, struct file *,
+                                loff_t, struct kvec *, int, unsigned long *);
+int             nfsd_write(struct svc_rqst *, struct svc_fh *,struct file *,
+                                loff_t, struct kvec *,int, unsigned long, int *);
+int             nfsd_readlink(struct svc_rqst *, struct svc_fh *,
+                                char *, int *);
+int             nfsd_symlink(struct svc_rqst *, struct svc_fh *,
+                                char *name, int len, char *path, int plen,
+                                struct svc_fh *res, struct iattr *);
+int             nfsd_link(struct svc_rqst *, struct svc_fh *,
+                                char *, int, struct svc_fh *);
+int             nfsd_rename(struct svc_rqst *,
+                                struct svc_fh *, char *, int,
+                                struct svc_fh *, char *, int);
+int             nfsd_remove(struct svc_rqst *,
+                                struct svc_fh *, char *, int);
+int             nfsd_unlink(struct svc_rqst *, struct svc_fh *, int type,
+                                char *name, int len);
+int             nfsd_truncate(struct svc_rqst *, struct svc_fh *,
+                                unsigned long size);
+int             nfsd_readdir(struct svc_rqst *, struct svc_fh *,
+                             loff_t *, struct readdir_cd *, encode_dent_fn);
+int             nfsd_statfs(struct svc_rqst *, struct svc_fh *,
+                                struct kstatfs *);
+
+int             nfsd_notify_change(struct inode *, struct iattr *);
+int             nfsd_permission(struct svc_export *, struct dentry *, int);
+
+
+/* 
+ * NFSv4 State
+ */
+#ifdef CONFIG_NFSD_V4
+int nfs4_state_init(void);
+void nfs4_state_shutdown(void);
+time_t nfs4_lease_time(void);
+void nfs4_reset_lease(time_t leasetime);
+#else
+static inline int nfs4_state_init(void){return 0;}
+static inline void nfs4_state_shutdown(void){}
+static inline time_t nfs4_lease_time(void){return 0;}
+static inline void nfs4_reset_lease(time_t leasetime){}
+#endif
+
+/*
+ * lockd binding
+ */
+void            nfsd_lockd_init(void);
+void            nfsd_lockd_shutdown(void);
+
+
+/*
+ * These macros provide pre-xdr'ed values for faster operation.
+ */
+#define nfs_ok                  __constant_htonl(NFS_OK)
+#define nfserr_perm             __constant_htonl(NFSERR_PERM)
+#define nfserr_noent            __constant_htonl(NFSERR_NOENT)
+#define nfserr_io               __constant_htonl(NFSERR_IO)
+#define nfserr_nxio             __constant_htonl(NFSERR_NXIO)
+#define nfserr_eagain           __constant_htonl(NFSERR_EAGAIN)
+#define nfserr_acces            __constant_htonl(NFSERR_ACCES)
+#define nfserr_exist            __constant_htonl(NFSERR_EXIST)
+#define nfserr_xdev             __constant_htonl(NFSERR_XDEV)
+#define nfserr_nodev            __constant_htonl(NFSERR_NODEV)
+#define nfserr_notdir           __constant_htonl(NFSERR_NOTDIR)
+#define nfserr_isdir            __constant_htonl(NFSERR_ISDIR)
+#define nfserr_inval            __constant_htonl(NFSERR_INVAL)
+#define nfserr_fbig             __constant_htonl(NFSERR_FBIG)
+#define nfserr_nospc            __constant_htonl(NFSERR_NOSPC)
+#define nfserr_rofs             __constant_htonl(NFSERR_ROFS)
+#define nfserr_mlink            __constant_htonl(NFSERR_MLINK)
+#define nfserr_opnotsupp        __constant_htonl(NFSERR_OPNOTSUPP)
+#define nfserr_nametoolong      __constant_htonl(NFSERR_NAMETOOLONG)
+#define nfserr_notempty         __constant_htonl(NFSERR_NOTEMPTY)
+#define nfserr_dquot            __constant_htonl(NFSERR_DQUOT)
+#define nfserr_stale            __constant_htonl(NFSERR_STALE)
+#define nfserr_remote           __constant_htonl(NFSERR_REMOTE)
+#define nfserr_wflush           __constant_htonl(NFSERR_WFLUSH)
+#define nfserr_badhandle        __constant_htonl(NFSERR_BADHANDLE)
+#define nfserr_notsync          __constant_htonl(NFSERR_NOT_SYNC)
+#define nfserr_badcookie        __constant_htonl(NFSERR_BAD_COOKIE)
+#define nfserr_notsupp          __constant_htonl(NFSERR_NOTSUPP)
+#define nfserr_toosmall         __constant_htonl(NFSERR_TOOSMALL)
+#define nfserr_serverfault      __constant_htonl(NFSERR_SERVERFAULT)
+#define nfserr_badtype          __constant_htonl(NFSERR_BADTYPE)
+#define nfserr_jukebox          __constant_htonl(NFSERR_JUKEBOX)
+#define nfserr_denied           __constant_htonl(NFSERR_DENIED)
+#define nfserr_deadlock         __constant_htonl(NFSERR_DEADLOCK)
+#define nfserr_expired          __constant_htonl(NFSERR_EXPIRED)
+#define nfserr_bad_cookie       __constant_htonl(NFSERR_BAD_COOKIE)
+#define nfserr_same             __constant_htonl(NFSERR_SAME)
+#define nfserr_clid_inuse       __constant_htonl(NFSERR_CLID_INUSE)
+#define nfserr_stale_clientid   __constant_htonl(NFSERR_STALE_CLIENTID)
+#define nfserr_resource         __constant_htonl(NFSERR_RESOURCE)
+#define nfserr_nofilehandle     __constant_htonl(NFSERR_NOFILEHANDLE)
+#define nfserr_minor_vers_mismatch      __constant_htonl(NFSERR_MINOR_VERS_MISMATCH)
+#define nfserr_share_denied     __constant_htonl(NFSERR_SHARE_DENIED)
+#define nfserr_stale_stateid    __constant_htonl(NFSERR_STALE_STATEID)
+#define nfserr_old_stateid      __constant_htonl(NFSERR_OLD_STATEID)
+#define nfserr_bad_stateid      __constant_htonl(NFSERR_BAD_STATEID)
+#define nfserr_bad_seqid        __constant_htonl(NFSERR_BAD_SEQID)
+#define nfserr_symlink          __constant_htonl(NFSERR_SYMLINK)
+#define nfserr_not_same         __constant_htonl(NFSERR_NOT_SAME)
+#define nfserr_restorefh        __constant_htonl(NFSERR_RESTOREFH)
+#define nfserr_attrnotsupp      __constant_htonl(NFSERR_ATTRNOTSUPP)
+#define nfserr_bad_xdr          __constant_htonl(NFSERR_BAD_XDR)
+#define nfserr_openmode         __constant_htonl(NFSERR_OPENMODE)
+#define nfserr_locks_held       __constant_htonl(NFSERR_LOCKS_HELD)
+#define nfserr_op_illegal       __constant_htonl(NFSERR_OP_ILLEGAL)
+#define nfserr_grace            __constant_htonl(NFSERR_GRACE)
+#define nfserr_no_grace         __constant_htonl(NFSERR_NO_GRACE)
+#define nfserr_reclaim_bad      __constant_htonl(NFSERR_RECLAIM_BAD)
+#define nfserr_badname          __constant_htonl(NFSERR_BADNAME)
+#define nfserr_cb_path_down     __constant_htonl(NFSERR_CB_PATH_DOWN)
+
+/* error codes for internal use */
+/* if a request fails due to kmalloc failure, it gets dropped.
+ *  Client should resend eventually
+ */
+#define nfserr_dropit           __constant_htonl(30000)
+/* end-of-file indicator in readdir */
+#define nfserr_eof              __constant_htonl(30001)
+
+/* Check for dir entries '.' and '..' */
+#define isdotent(n, l)  (l < 3 && n[0] == '.' && (l == 1 || n[1] == '.'))
+
+/*
+ * Time of server startup
+ */
+extern struct timeval   nfssvc_boot;
+
+static inline int is_fsid(struct svc_fh *fh, struct knfsd_fh *reffh)
+{
+        if (fh->fh_export->ex_flags & NFSEXP_FSID) {
+                struct vfsmount *mnt = fh->fh_export->ex_mnt;
+                if (!old_valid_dev(mnt->mnt_sb->s_dev) ||
+                    (reffh->fh_version == 1 && reffh->fh_fsid_type == 1))
+                        return 1;
+        }
+        return 0;
+}
+
+
+#ifdef CONFIG_NFSD_V4
+
+/* before processing a COMPOUND operation, we have to check that there
+ * is enough space in the buffer for XDR encode to succeed.  otherwise,
+ * we might process an operation with side effects, and be unable to
+ * tell the client that the operation succeeded.
+ *
+ * COMPOUND_SLACK_SPACE - this is the minimum amount of buffer space
+ * needed to encode an "ordinary" _successful_ operation.  (GETATTR,
+ * READ, READDIR, and READLINK have their own buffer checks.)  if we
+ * fall below this level, we fail the next operation with NFS4ERR_RESOURCE.
+ *
+ * COMPOUND_ERR_SLACK_SPACE - this is the minimum amount of buffer space
+ * needed to encode an operation which has failed with NFS4ERR_RESOURCE.
+ * care is taken to ensure that we never fall below this level for any
+ * reason.
+ */
+#define COMPOUND_SLACK_SPACE            140    /* OP_GETFH */
+#define COMPOUND_ERR_SLACK_SPACE        12     /* OP_SETATTR */
+
+#define NFSD_LEASE_TIME                 (nfs4_lease_time())
+#define NFSD_LAUNDROMAT_MINTIMEOUT      10   /* seconds */
+
+/*
+ * The following attributes are currently not supported by the NFSv4 server:
+ *    ARCHIVE       (deprecated anyway)
+ *    FS_LOCATIONS  (will be supported eventually)
+ *    HIDDEN        (unlikely to be supported any time soon)
+ *    MIMETYPE      (unlikely to be supported any time soon)
+ *    QUOTA_*       (will be supported in a forthcoming patch)
+ *    SYSTEM        (unlikely to be supported any time soon)
+ *    TIME_BACKUP   (unlikely to be supported any time soon)
+ *    TIME_CREATE   (unlikely to be supported any time soon)
+ */
+#define NFSD_SUPPORTED_ATTRS_WORD0                                                          \
+(FATTR4_WORD0_SUPPORTED_ATTRS   | FATTR4_WORD0_TYPE         | FATTR4_WORD0_FH_EXPIRE_TYPE   \
+ | FATTR4_WORD0_CHANGE          | FATTR4_WORD0_SIZE         | FATTR4_WORD0_LINK_SUPPORT     \
+ | FATTR4_WORD0_SYMLINK_SUPPORT | FATTR4_WORD0_NAMED_ATTR   | FATTR4_WORD0_FSID             \
+ | FATTR4_WORD0_UNIQUE_HANDLES  | FATTR4_WORD0_LEASE_TIME   | FATTR4_WORD0_RDATTR_ERROR     \
+ | FATTR4_WORD0_ACLSUPPORT      | FATTR4_WORD0_CANSETTIME   | FATTR4_WORD0_CASE_INSENSITIVE \
+ | FATTR4_WORD0_CASE_PRESERVING | FATTR4_WORD0_CHOWN_RESTRICTED                             \
+ | FATTR4_WORD0_FILEHANDLE      | FATTR4_WORD0_FILEID       | FATTR4_WORD0_FILES_AVAIL      \
+ | FATTR4_WORD0_FILES_FREE      | FATTR4_WORD0_FILES_TOTAL  | FATTR4_WORD0_HOMOGENEOUS      \
+ | FATTR4_WORD0_MAXFILESIZE     | FATTR4_WORD0_MAXLINK      | FATTR4_WORD0_MAXNAME          \
+ | FATTR4_WORD0_MAXREAD         | FATTR4_WORD0_MAXWRITE     | FATTR4_WORD0_ACL)
+
+#define NFSD_SUPPORTED_ATTRS_WORD1                                                          \
+(FATTR4_WORD1_MODE              | FATTR4_WORD1_NO_TRUNC     | FATTR4_WORD1_NUMLINKS         \
+ | FATTR4_WORD1_OWNER           | FATTR4_WORD1_OWNER_GROUP  | FATTR4_WORD1_RAWDEV           \
+ | FATTR4_WORD1_SPACE_AVAIL     | FATTR4_WORD1_SPACE_FREE   | FATTR4_WORD1_SPACE_TOTAL      \
+ | FATTR4_WORD1_SPACE_USED      | FATTR4_WORD1_TIME_ACCESS  | FATTR4_WORD1_TIME_ACCESS_SET  \
+ | FATTR4_WORD1_TIME_DELTA   | FATTR4_WORD1_TIME_METADATA    \
+ | FATTR4_WORD1_TIME_MODIFY     | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
+
+/* These will return ERR_INVAL if specified in GETATTR or READDIR. */
+#define NFSD_WRITEONLY_ATTRS_WORD1                                                          \
+(FATTR4_WORD1_TIME_ACCESS_SET   | FATTR4_WORD1_TIME_MODIFY_SET)
+
+/* These are the only attrs allowed in CREATE/OPEN/SETATTR. */
+#define NFSD_WRITEABLE_ATTRS_WORD0                                                          \
+(FATTR4_WORD0_SIZE              | FATTR4_WORD0_ACL                                         )
+#define NFSD_WRITEABLE_ATTRS_WORD1                                                          \
+(FATTR4_WORD1_MODE              | FATTR4_WORD1_OWNER         | FATTR4_WORD1_OWNER_GROUP     \
+ | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_METADATA | FATTR4_WORD1_TIME_MODIFY_SET)
+
+#endif /* CONFIG_NFSD_V4 */
+
+#endif /* __KERNEL__ */
+
+#endif /* LINUX_NFSD_NFSD_H */
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
new file mode 100644
index 000000000000..bb842ea41033
--- /dev/null
+++ b/include/linux/nfsd/nfsfh.h
@@ -0,0 +1,343 @@
+/*
+ * include/linux/nfsd/nfsfh.h
+ *
+ * This file describes the layout of the file handles as passed
+ * over the wire.
+ *
+ * Earlier versions of knfsd used to sign file handles using keyed MD5
+ * or SHA. I've removed this code, because it doesn't give you more
+ * security than blocking external access to port 2049 on your firewall.
+ *
+ * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_NFSD_FH_H
+#define _LINUX_NFSD_FH_H
+
+#include <asm/types.h>
+#ifdef __KERNEL__
+# include <linux/config.h>
+# include <linux/types.h>
+# include <linux/string.h>
+# include <linux/fs.h>
+#endif
+#include <linux/nfsd/const.h>
+#include <linux/nfsd/debug.h>
+
+/*
+ * This is the old "dentry style" Linux NFSv2 file handle.
+ *
+ * The xino and xdev fields are currently used to transport the
+ * ino/dev of the exported inode.
+ */
+struct nfs_fhbase_old {
+        __u32           fb_dcookie;     /* dentry cookie - always 0xfeebbaca */
+        __u32           fb_ino;         /* our inode number */
+        __u32           fb_dirino;      /* dir inode number, 0 for directories */
+        __u32           fb_dev;         /* our device */
+        __u32           fb_xdev;
+        __u32           fb_xino;
+        __u32           fb_generation;
+};
+
+/*
+ * This is the new flexible, extensible style NFSv2/v3 file handle.
+ * by Neil Brown <neilb@cse.unsw.edu.au> - March 2000
+ *
+ * The file handle is seens as a list of 4byte words.
+ * The first word contains a version number (1) and four descriptor bytes
+ * that tell how the remaining 3 variable length fields should be handled.
+ * These three bytes are auth_type, fsid_type and fileid_type.
+ *
+ * All 4byte values are in host-byte-order.
+ *
+ * The auth_type field specifies how the filehandle can be authenticated
+ * This might allow a file to be confirmed to be in a writable part of a
+ * filetree without checking the path from it upto the root.
+ * Current values:
+ *     0  - No authentication.  fb_auth is 0 bytes long
+ * Possible future values:
+ *     1  - 4 bytes taken from MD5 hash of the remainer of the file handle
+ *          prefixed by a secret and with the important export flags.
+ *
+ * The fsid_type identifies how the filesystem (or export point) is
+ *    encoded.
+ *  Current values:
+ *     0  - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
+ *        NOTE: we cannot use the kdev_t device id value, because kdev_t.h
+ *              says we mustn't.  We must break it up and reassemble.
+ *     1  - 4 byte user specified identifier
+ *     2  - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
+ *     3  - 4 byte device id, encoded for user-space, 4 byte inode number
+ *
+ * The fileid_type identified how the file within the filesystem is encoded.
+ * This is (will be) passed to, and set by, the underlying filesystem if it supports
+ * filehandle operations.  The filesystem must not use the value '0' or '0xff' and may
+ * only use the values 1 and 2 as defined below:
+ *  Current values:
+ *    0   - The root, or export point, of the filesystem.  fb_fileid is 0 bytes.
+ *    1   - 32bit inode number, 32 bit generation number.
+ *    2   - 32bit inode number, 32 bit generation number, 32 bit parent directory inode number.
+ *
+ */
+struct nfs_fhbase_new {
+        __u8            fb_version;     /* == 1, even => nfs_fhbase_old */
+        __u8            fb_auth_type;
+        __u8            fb_fsid_type;
+        __u8            fb_fileid_type;
+        __u32           fb_auth[1];
+/*      __u32           fb_fsid[0]; floating */
+/*      __u32           fb_fileid[0]; floating */
+};
+
+struct knfsd_fh {
+        unsigned int    fh_size;        /* significant for NFSv3.
+                                         * Points to the current size while building
+                                         * a new file handle
+                                         */
+        union {
+                struct nfs_fhbase_old   fh_old;
+                __u32                   fh_pad[NFS4_FHSIZE/4];
+                struct nfs_fhbase_new   fh_new;
+        } fh_base;
+};
+
+#define ofh_dcookie             fh_base.fh_old.fb_dcookie
+#define ofh_ino                 fh_base.fh_old.fb_ino
+#define ofh_dirino              fh_base.fh_old.fb_dirino
+#define ofh_dev                 fh_base.fh_old.fb_dev
+#define ofh_xdev                fh_base.fh_old.fb_xdev
+#define ofh_xino                fh_base.fh_old.fb_xino
+#define ofh_generation          fh_base.fh_old.fb_generation
+
+#define fh_version              fh_base.fh_new.fb_version
+#define fh_fsid_type            fh_base.fh_new.fb_fsid_type
+#define fh_auth_type            fh_base.fh_new.fb_auth_type
+#define fh_fileid_type          fh_base.fh_new.fb_fileid_type
+#define fh_auth                 fh_base.fh_new.fb_auth
+#define fh_fsid                 fh_base.fh_new.fb_auth
+
+#ifdef __KERNEL__
+
+static inline __u32 ino_t_to_u32(ino_t ino)
+{
+        return (__u32) ino;
+}
+
+static inline ino_t u32_to_ino_t(__u32 uino)
+{
+        return (ino_t) uino;
+}
+
+/*
+ * This is the internal representation of an NFS handle used in knfsd.
+ * pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
+ */
+typedef struct svc_fh {
+        struct knfsd_fh         fh_handle;      /* FH data */
+        struct dentry *         fh_dentry;      /* validated dentry */
+        struct svc_export *     fh_export;      /* export pointer */
+        int                     fh_maxsize;     /* max size for fh_handle */
+
+        unsigned char           fh_locked;      /* inode locked by us */
+
+#ifdef CONFIG_NFSD_V3
+        unsigned char           fh_post_saved;  /* post-op attrs saved */
+        unsigned char           fh_pre_saved;   /* pre-op attrs saved */
+
+        /* Pre-op attributes saved during fh_lock */
+        __u64                   fh_pre_size;    /* size before operation */
+        struct timespec         fh_pre_mtime;   /* mtime before oper */
+        struct timespec         fh_pre_ctime;   /* ctime before oper */
+
+        /* Post-op attributes saved in fh_unlock */
+        umode_t                 fh_post_mode;   /* i_mode */
+        nlink_t                 fh_post_nlink;  /* i_nlink */
+        uid_t                   fh_post_uid;    /* i_uid */
+        gid_t                   fh_post_gid;    /* i_gid */
+        __u64                   fh_post_size;   /* i_size */
+        unsigned long           fh_post_blocks; /* i_blocks */
+        unsigned long           fh_post_blksize;/* i_blksize */
+        __u32                   fh_post_rdev[2];/* i_rdev */
+        struct timespec         fh_post_atime;  /* i_atime */
+        struct timespec         fh_post_mtime;  /* i_mtime */
+        struct timespec         fh_post_ctime;  /* i_ctime */
+#endif /* CONFIG_NFSD_V3 */
+
+} svc_fh;
+
+static inline void mk_fsid_v0(u32 *fsidv, dev_t dev, ino_t ino)
+{
+        fsidv[0] = htonl((MAJOR(dev)<<16) |
+                        MINOR(dev));
+        fsidv[1] = ino_t_to_u32(ino);
+}
+
+static inline void mk_fsid_v1(u32 *fsidv, u32 fsid)
+{
+        fsidv[0] = fsid;
+}
+
+static inline void mk_fsid_v2(u32 *fsidv, dev_t dev, ino_t ino)
+{
+        fsidv[0] = htonl(MAJOR(dev));
+        fsidv[1] = htonl(MINOR(dev));
+        fsidv[2] = ino_t_to_u32(ino);
+}
+
+static inline void mk_fsid_v3(u32 *fsidv, dev_t dev, ino_t ino)
+{
+        fsidv[0] = new_encode_dev(dev);
+        fsidv[1] = ino_t_to_u32(ino);
+}
+
+static inline int key_len(int type)
+{
+        switch(type) {
+        case 0: return 8;
+        case 1: return 4;
+        case 2: return 12;
+        case 3: return 8;
+        default: return 0;
+        }
+}
+
+/*
+ * Shorthand for dprintk()'s
+ */
+extern char * SVCFH_fmt(struct svc_fh *fhp);
+
+/*
+ * Function prototypes
+ */
+u32     fh_verify(struct svc_rqst *, struct svc_fh *, int, int);
+int     fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
+int     fh_update(struct svc_fh *);
+void    fh_put(struct svc_fh *);
+
+static __inline__ struct svc_fh *
+fh_copy(struct svc_fh *dst, struct svc_fh *src)
+{
+        if (src->fh_dentry || src->fh_locked) {
+                struct dentry *dentry = src->fh_dentry;
+                printk(KERN_ERR "fh_copy: copying %s/%s, already verified!\n",
+                        dentry->d_parent->d_name.name, dentry->d_name.name);
+        }
+                        
+        *dst = *src;
+        return dst;
+}
+
+static __inline__ struct svc_fh *
+fh_init(struct svc_fh *fhp, int maxsize)
+{
+        memset(fhp, 0, sizeof(*fhp));
+        fhp->fh_maxsize = maxsize;
+        return fhp;
+}
+
+#ifdef CONFIG_NFSD_V3
+/*
+ * Fill in the pre_op attr for the wcc data
+ */
+static inline void
+fill_pre_wcc(struct svc_fh *fhp)
+{
+        struct inode    *inode;
+
+        inode = fhp->fh_dentry->d_inode;
+        if (!fhp->fh_pre_saved) {
+                fhp->fh_pre_mtime = inode->i_mtime;
+                fhp->fh_pre_ctime = inode->i_ctime;
+                        fhp->fh_pre_size  = inode->i_size;
+                        fhp->fh_pre_saved = 1;
+        }
+}
+
+/*
+ * Fill in the post_op attr for the wcc data
+ */
+static inline void
+fill_post_wcc(struct svc_fh *fhp)
+{
+        struct inode    *inode = fhp->fh_dentry->d_inode;
+
+        if (fhp->fh_post_saved)
+                printk("nfsd: inode locked twice during operation.\n");
+
+        fhp->fh_post_mode       = inode->i_mode;
+        fhp->fh_post_nlink      = inode->i_nlink;
+        fhp->fh_post_uid        = inode->i_uid;
+        fhp->fh_post_gid        = inode->i_gid;
+        fhp->fh_post_size       = inode->i_size;
+        if (inode->i_blksize) {
+                fhp->fh_post_blksize    = inode->i_blksize;
+                fhp->fh_post_blocks     = inode->i_blocks;
+        } else {
+                fhp->fh_post_blksize    = BLOCK_SIZE;
+                /* how much do we care for accuracy with MinixFS? */
+                fhp->fh_post_blocks     = (inode->i_size+511) >> 9;
+        }
+        fhp->fh_post_rdev[0]    = htonl((u32)imajor(inode));
+        fhp->fh_post_rdev[1]    = htonl((u32)iminor(inode));
+        fhp->fh_post_atime      = inode->i_atime;
+        fhp->fh_post_mtime      = inode->i_mtime;
+        fhp->fh_post_ctime      = inode->i_ctime;
+        fhp->fh_post_saved      = 1;
+}
+#else
+#define fill_pre_wcc(ignored)
+#define fill_post_wcc(notused)
+#endif /* CONFIG_NFSD_V3 */
+
+
+/*
+ * Lock a file handle/inode
+ * NOTE: both fh_lock and fh_unlock are done "by hand" in
+ * vfs.c:nfsd_rename as it needs to grab 2 i_sem's at once
+ * so, any changes here should be reflected there.
+ */
+static inline void
+fh_lock(struct svc_fh *fhp)
+{
+        struct dentry   *dentry = fhp->fh_dentry;
+        struct inode    *inode;
+
+        dfprintk(FILEOP, "nfsd: fh_lock(%s) locked = %d\n",
+                        SVCFH_fmt(fhp), fhp->fh_locked);
+
+        if (!fhp->fh_dentry) {
+                printk(KERN_ERR "fh_lock: fh not verified!\n");
+                return;
+        }
+        if (fhp->fh_locked) {
+                printk(KERN_WARNING "fh_lock: %s/%s already locked!\n",
+                        dentry->d_parent->d_name.name, dentry->d_name.name);
+                return;
+        }
+
+        inode = dentry->d_inode;
+        down(&inode->i_sem);
+        fill_pre_wcc(fhp);
+        fhp->fh_locked = 1;
+}
+
+/*
+ * Unlock a file handle/inode
+ */
+static inline void
+fh_unlock(struct svc_fh *fhp)
+{
+        if (!fhp->fh_dentry)
+                printk(KERN_ERR "fh_unlock: fh not verified!\n");
+
+        if (fhp->fh_locked) {
+                fill_post_wcc(fhp);
+                up(&fhp->fh_dentry->d_inode->i_sem);
+                fhp->fh_locked = 0;
+        }
+}
+#endif /* __KERNEL__ */
+
+
+#endif /* _LINUX_NFSD_FH_H */
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h
new file mode 100644
index 000000000000..b6b2fe1e7c63
--- /dev/null
+++ b/include/linux/nfsd/state.h
@@ -0,0 +1,298 @@
+/*
+ *  linux/include/nfsd/state.h
+ *
+ *  Copyright (c) 2001 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Kendrick Smith <kmsmith@umich.edu>
+ *  Andy Adamson <andros@umich.edu>
+ *  
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *  
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the University nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _NFSD4_STATE_H
+#define _NFSD4_STATE_H
+
+#include <linux/list.h>
+#include <linux/kref.h>
+#include <linux/sunrpc/clnt.h>
+
+#define NFS4_OPAQUE_LIMIT 1024
+typedef struct {
+        u32             cl_boot;
+        u32             cl_id;
+} clientid_t;
+
+typedef struct {
+        u32             so_boot;
+        u32             so_stateownerid;
+        u32             so_fileid;
+} stateid_opaque_t;
+
+typedef struct {
+        u32                     si_generation;
+        stateid_opaque_t        si_opaque;
+} stateid_t;
+#define si_boot           si_opaque.so_boot
+#define si_stateownerid   si_opaque.so_stateownerid
+#define si_fileid         si_opaque.so_fileid
+
+extern stateid_t zerostateid;
+extern stateid_t onestateid;
+
+#define ZERO_STATEID(stateid)       (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
+#define ONE_STATEID(stateid)        (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
+
+struct nfs4_cb_recall {
+        u32                     cbr_ident;
+        int                     cbr_trunc;
+        stateid_t               cbr_stateid;
+        u32                     cbr_fhlen;
+        u32                     cbr_fhval[NFS4_FHSIZE];
+        struct nfs4_delegation  *cbr_dp;
+};
+
+struct nfs4_delegation {
+        struct list_head        dl_del_perfile; /* nfs4_file->fi_del_perfile */
+        struct list_head        dl_del_perclnt; /* nfs4_client->cl_del_perclnt*/
+        struct list_head        dl_recall_lru;  /* delegation recalled */
+        atomic_t                dl_count;       /* ref count */
+        struct nfs4_client      *dl_client;
+        struct nfs4_file        *dl_file;
+        struct file_lock        *dl_flock;
+        struct file             *dl_vfs_file;
+        u32                     dl_type;
+        time_t                  dl_time;
+        struct nfs4_cb_recall   dl_recall;
+};
+
+#define dl_stateid      dl_recall.cbr_stateid
+#define dl_fhlen        dl_recall.cbr_fhlen
+#define dl_fhval        dl_recall.cbr_fhval
+
+/* client delegation callback info */
+struct nfs4_callback {
+        /* SETCLIENTID info */
+        u32                     cb_parsed;  /* addr parsed */
+        u32                     cb_addr;
+        unsigned short          cb_port;
+        u32                     cb_prog;
+        u32                     cb_ident;
+        /* RPC client info */
+        atomic_t                cb_set;     /* successful CB_NULL call */
+        struct rpc_program      cb_program;
+        struct rpc_stat         cb_stat;
+        struct rpc_clnt *       cb_client;
+};
+
+/*
+ * struct nfs4_client - one per client.  Clientids live here.
+ *      o Each nfs4_client is hashed by clientid.
+ *
+ *      o Each nfs4_clients is also hashed by name 
+ *        (the opaque quantity initially sent by the client to identify itself).
+ *        
+ *      o cl_perclient list is used to ensure no dangling stateowner references
+ *        when we expire the nfs4_client
+ */
+struct nfs4_client {
+        struct list_head        cl_idhash;      /* hash by cl_clientid.id */
+        struct list_head        cl_strhash;     /* hash by cl_name */
+        struct list_head        cl_perclient;   /* list: stateowners */
+        struct list_head        cl_del_perclnt; /* list: delegations */
+        struct list_head        cl_lru;         /* tail queue */
+        struct xdr_netobj       cl_name;        /* id generated by client */
+        nfs4_verifier           cl_verifier;    /* generated by client */
+        time_t                  cl_time;        /* time of last lease renewal */
+        u32                     cl_addr;        /* client ipaddress */
+        struct svc_cred         cl_cred;        /* setclientid principal */
+        clientid_t              cl_clientid;    /* generated by server */
+        nfs4_verifier           cl_confirm;     /* generated by server */
+        struct nfs4_callback    cl_callback;    /* callback info */
+        atomic_t                cl_count;       /* ref count */
+};
+
+/* struct nfs4_client_reset
+ * one per old client. Populates reset_str_hashtbl. Filled from conf_id_hashtbl
+ * upon lease reset, or from upcall to state_daemon (to read in state
+ * from non-volitile storage) upon reboot.
+ */
+struct nfs4_client_reclaim {
+        struct list_head        cr_strhash;     /* hash by cr_name */
+        struct xdr_netobj       cr_name;        /* id generated by client */
+};
+
+static inline void
+update_stateid(stateid_t *stateid)
+{
+        stateid->si_generation++;
+}
+
+/* A reasonable value for REPLAY_ISIZE was estimated as follows:  
+ * The OPEN response, typically the largest, requires 
+ *   4(status) + 8(stateid) + 20(changeinfo) + 4(rflags) +  8(verifier) + 
+ *   4(deleg. type) + 8(deleg. stateid) + 4(deleg. recall flag) + 
+ *   20(deleg. space limit) + ~32(deleg. ace) = 112 bytes 
+ */
+
+#define NFSD4_REPLAY_ISIZE       112 
+
+/*
+ * Replay buffer, where the result of the last seqid-mutating operation 
+ * is cached. 
+ */
+struct nfs4_replay {
+        u32                     rp_status;
+        unsigned int            rp_buflen;
+        char                    *rp_buf;
+        unsigned                intrp_allocated;
+        int                     rp_openfh_len;
+        char                    rp_openfh[NFS4_FHSIZE];
+        char                    rp_ibuf[NFSD4_REPLAY_ISIZE];
+};
+
+/*
+* nfs4_stateowner can either be an open_owner, or a lock_owner
+*
+*    so_idhash:  stateid_hashtbl[] for open owner, lockstateid_hashtbl[]
+*         for lock_owner
+*    so_strhash: ownerstr_hashtbl[] for open_owner, lock_ownerstr_hashtbl[]
+*         for lock_owner
+*    so_perclient: nfs4_client->cl_perclient entry - used when nfs4_client
+*         struct is reaped.
+*    so_perfilestate: heads the list of nfs4_stateid (either open or lock) 
+*         and is used to ensure no dangling nfs4_stateid references when we 
+*         release a stateowner.
+*    so_perlockowner: (open) nfs4_stateid->st_perlockowner entry - used when
+*         close is called to reap associated byte-range locks
+*    so_close_lru: (open) stateowner is placed on this list instead of being
+*         reaped (when so_perfilestate is empty) to hold the last close replay.
+*         reaped by laundramat thread after lease period.
+*/
+struct nfs4_stateowner {
+        struct kref             so_ref;
+        struct list_head        so_idhash;   /* hash by so_id */
+        struct list_head        so_strhash;   /* hash by op_name */
+        struct list_head        so_perclient; /* nfs4_client->cl_perclient */
+        struct list_head        so_perfilestate; /* list: nfs4_stateid */
+        struct list_head        so_perlockowner; /* nfs4_stateid->st_perlockowner */
+        struct list_head        so_close_lru; /* tail queue */
+        time_t                  so_time; /* time of placement on so_close_lru */
+        int                     so_is_open_owner; /* 1=openowner,0=lockowner */
+        u32                     so_id;
+        struct nfs4_client *    so_client;
+        u32                     so_seqid;    
+        struct xdr_netobj       so_owner;     /* open owner name */
+        int                     so_confirmed; /* successful OPEN_CONFIRM? */
+        struct nfs4_replay      so_replay;
+};
+
+/*
+*  nfs4_file: a file opened by some number of (open) nfs4_stateowners.
+*    o fi_perfile list is used to search for conflicting 
+*      share_acces, share_deny on the file.
+*/
+struct nfs4_file {
+        struct list_head        fi_hash;    /* hash by "struct inode *" */
+        struct list_head        fi_perfile; /* list: nfs4_stateid */
+        struct list_head        fi_del_perfile; /* list: nfs4_delegation */
+        struct inode            *fi_inode;
+        u32                     fi_id;      /* used with stateowner->so_id 
+                                             * for stateid_hashtbl hash */
+};
+
+/*
+* nfs4_stateid can either be an open stateid or (eventually) a lock stateid
+*
+* (open)nfs4_stateid: one per (open)nfs4_stateowner, nfs4_file
+*
+*       st_hash: stateid_hashtbl[] entry or lockstateid_hashtbl entry
+*       st_perfile: file_hashtbl[] entry.
+*       st_perfile_state: nfs4_stateowner->so_perfilestate
+*       st_perlockowner: (open stateid) list of lock nfs4_stateowners
+*       st_access_bmap: used only for open stateid
+*       st_deny_bmap: used only for open stateid
+*/
+
+struct nfs4_stateid {
+        struct list_head              st_hash; 
+        struct list_head              st_perfile;
+        struct list_head              st_perfilestate; 
+        struct list_head              st_perlockowner;
+        struct nfs4_stateowner      * st_stateowner;
+        struct nfs4_file            * st_file;
+        stateid_t                     st_stateid;
+        struct file                 * st_vfs_file;
+        unsigned long                 st_access_bmap;
+        unsigned long                 st_deny_bmap;
+};
+
+/* flags for preprocess_seqid_op() */
+#define CHECK_FH                0x00000001
+#define CONFIRM                 0x00000002
+#define OPEN_STATE              0x00000004
+#define LOCK_STATE              0x00000008
+#define RD_STATE                0x00000010
+#define WR_STATE                0x00000020
+#define CLOSE_STATE             0x00000040
+#define DELEG_RET               0x00000080
+
+#define seqid_mutating_err(err)                       \
+        (((err) != nfserr_stale_clientid) &&    \
+        ((err) != nfserr_bad_seqid) &&          \
+        ((err) != nfserr_stale_stateid) &&      \
+        ((err) != nfserr_bad_stateid))
+
+extern time_t nfs4_laundromat(void);
+extern int nfsd4_renew(clientid_t *clid);
+extern int nfs4_preprocess_stateid_op(struct svc_fh *current_fh, 
+                stateid_t *stateid, int flags, struct file **filp);
+extern int nfs4_share_conflict(struct svc_fh *current_fh, 
+                unsigned int deny_type);
+extern void nfs4_lock_state(void);
+extern void nfs4_unlock_state(void);
+extern int nfs4_in_grace(void);
+extern int nfs4_check_open_reclaim(clientid_t *clid);
+extern void put_nfs4_client(struct nfs4_client *clp);
+extern void nfs4_free_stateowner(struct kref *kref);
+extern void nfsd4_probe_callback(struct nfs4_client *clp);
+extern void nfsd4_cb_recall(struct nfs4_delegation *dp);
+extern void nfs4_put_delegation(struct nfs4_delegation *dp);
+
+static inline void
+nfs4_put_stateowner(struct nfs4_stateowner *so)
+{
+        kref_put(&so->so_ref, nfs4_free_stateowner);
+}
+
+static inline void
+nfs4_get_stateowner(struct nfs4_stateowner *so)
+{
+        kref_get(&so->so_ref);
+}
+
+#endif   /* NFSD4_STATE_H */
diff --git a/include/linux/nfsd/stats.h b/include/linux/nfsd/stats.h
new file mode 100644
index 000000000000..b6f1e0cda4f2
--- /dev/null
+++ b/include/linux/nfsd/stats.h
@@ -0,0 +1,44 @@
+/*
+ * linux/include/nfsd/stats.h
+ *
+ * Statistics for NFS server.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef LINUX_NFSD_STATS_H
+#define LINUX_NFSD_STATS_H
+
+struct nfsd_stats {
+        unsigned int    rchits;         /* repcache hits */
+        unsigned int    rcmisses;       /* repcache hits */
+        unsigned int    rcnocache;      /* uncached reqs */
+        unsigned int    fh_stale;       /* FH stale error */
+        unsigned int    fh_lookup;      /* dentry cached */
+        unsigned int    fh_anon;        /* anon file dentry returned */
+        unsigned int    fh_nocache_dir; /* filehandle not found in dcache */
+        unsigned int    fh_nocache_nondir;      /* filehandle not found in dcache */
+        unsigned int    io_read;        /* bytes returned to read requests */
+        unsigned int    io_write;       /* bytes passed in write requests */
+        unsigned int    th_cnt;         /* number of available threads */
+        unsigned int    th_usage[10];   /* number of ticks during which n perdeciles
+                                         * of available threads were in use */
+        unsigned int    th_fullcnt;     /* number of times last free thread was used */
+        unsigned int    ra_size;        /* size of ra cache */
+        unsigned int    ra_depth[11];   /* number of times ra entry was found that deep
+                                         * in the cache (10percentiles). [10] = not found */
+};
+
+/* thread usage wraps very million seconds (approx one fortnight) */
+#define NFSD_USAGE_WRAP (HZ*1000000)
+
+#ifdef __KERNEL__
+
+extern struct nfsd_stats        nfsdstats;
+extern struct svc_stat          nfsd_svcstats;
+
+void    nfsd_stat_init(void);
+void    nfsd_stat_shutdown(void);
+
+#endif /* __KERNEL__ */
+#endif /* LINUX_NFSD_STATS_H */
diff --git a/include/linux/nfsd/syscall.h b/include/linux/nfsd/syscall.h
new file mode 100644
index 000000000000..e65c9db6d13f
--- /dev/null
+++ b/include/linux/nfsd/syscall.h
@@ -0,0 +1,125 @@
+/*
+ * include/linux/nfsd/syscall.h
+ *
+ * This file holds all declarations for the knfsd syscall interface.
+ *
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef NFSD_SYSCALL_H
+#define NFSD_SYSCALL_H
+
+#include <asm/types.h>
+#ifdef __KERNEL__
+# include <linux/config.h>
+# include <linux/types.h>
+# include <linux/in.h>
+#endif 
+#include <linux/posix_types.h>
+#include <linux/nfsd/const.h>
+#include <linux/nfsd/export.h>
+#include <linux/nfsd/nfsfh.h>
+#include <linux/nfsd/auth.h>
+
+/*
+ * Version of the syscall interface
+ */
+#define NFSCTL_VERSION          0x0201
+
+/*
+ * These are the commands understood by nfsctl().
+ */
+#define NFSCTL_SVC              0       /* This is a server process. */
+#define NFSCTL_ADDCLIENT        1       /* Add an NFS client. */
+#define NFSCTL_DELCLIENT        2       /* Remove an NFS client. */
+#define NFSCTL_EXPORT           3       /* export a file system. */
+#define NFSCTL_UNEXPORT         4       /* unexport a file system. */
+/*#define NFSCTL_UGIDUPDATE     5       / * update a client's uid/gid map. DISCARDED */
+/*#define NFSCTL_GETFH          6       / * get an fh by ino DISCARDED */
+#define NFSCTL_GETFD            7       /* get an fh by path (used by mountd) */
+#define NFSCTL_GETFS            8       /* get an fh by path with max FH len */
+
+/* SVC */
+struct nfsctl_svc {
+        unsigned short          svc_port;
+        int                     svc_nthreads;
+};
+
+/* ADDCLIENT/DELCLIENT */
+struct nfsctl_client {
+        char                    cl_ident[NFSCLNT_IDMAX+1];
+        int                     cl_naddr;
+        struct in_addr          cl_addrlist[NFSCLNT_ADDRMAX];
+        int                     cl_fhkeytype;
+        int                     cl_fhkeylen;
+        unsigned char           cl_fhkey[NFSCLNT_KEYMAX];
+};
+
+/* EXPORT/UNEXPORT */
+struct nfsctl_export {
+        char                    ex_client[NFSCLNT_IDMAX+1];
+        char                    ex_path[NFS_MAXPATHLEN+1];
+        __kernel_old_dev_t      ex_dev;
+        __kernel_ino_t          ex_ino;
+        int                     ex_flags;
+        __kernel_uid_t          ex_anon_uid;
+        __kernel_gid_t          ex_anon_gid;
+};
+
+/* GETFD */
+struct nfsctl_fdparm {
+        struct sockaddr         gd_addr;
+        char                    gd_path[NFS_MAXPATHLEN+1];
+        int                     gd_version;
+};
+
+/* GETFS - GET Filehandle with Size */
+struct nfsctl_fsparm {
+        struct sockaddr         gd_addr;
+        char                    gd_path[NFS_MAXPATHLEN+1];
+        int                     gd_maxlen;
+};
+
+/*
+ * This is the argument union.
+ */
+struct nfsctl_arg {
+        int                     ca_version;     /* safeguard */
+        union {
+                struct nfsctl_svc       u_svc;
+                struct nfsctl_client    u_client;
+                struct nfsctl_export    u_export;
+                struct nfsctl_fdparm    u_getfd;
+                struct nfsctl_fsparm    u_getfs;
+                /*
+                 * The following dummy member is needed to preserve binary compatibility
+                 * on platforms where alignof(void*)>alignof(int).  It's needed because
+                 * this union used to contain a member (u_umap) which contained a
+                 * pointer.
+                 */
+                void *u_ptr;
+        } u;
+#define ca_svc          u.u_svc
+#define ca_client       u.u_client
+#define ca_export       u.u_export
+#define ca_getfd        u.u_getfd
+#define ca_getfs        u.u_getfs
+};
+
+union nfsctl_res {
+        __u8                    cr_getfh[NFS_FHSIZE];
+        struct knfsd_fh         cr_getfs;
+};
+
+#ifdef __KERNEL__
+/*
+ * Kernel syscall implementation.
+ */
+extern int              exp_addclient(struct nfsctl_client *ncp);
+extern int              exp_delclient(struct nfsctl_client *ncp);
+extern int              exp_export(struct nfsctl_export *nxp);
+extern int              exp_unexport(struct nfsctl_export *nxp);
+
+#endif /* __KERNEL__ */
+
+#endif /* NFSD_SYSCALL_H */
diff --git a/include/linux/nfsd/xdr.h b/include/linux/nfsd/xdr.h
new file mode 100644
index 000000000000..ecccef777dae
--- /dev/null
+++ b/include/linux/nfsd/xdr.h
@@ -0,0 +1,172 @@
+/*
+ * linux/inxlude/linux/nfsd/xdr.h
+ *
+ * XDR types for nfsd. This is mainly a typing exercise.
+ */
+
+#ifndef LINUX_NFSD_H
+#define LINUX_NFSD_H
+
+#include <linux/fs.h>
+#include <linux/vfs.h>
+#include <linux/nfs.h>
+
+struct nfsd_fhandle {
+        struct svc_fh           fh;
+};
+
+struct nfsd_sattrargs {
+        struct svc_fh           fh;
+        struct iattr            attrs;
+};
+
+struct nfsd_diropargs {
+        struct svc_fh           fh;
+        char *                  name;
+        int                     len;
+};
+
+struct nfsd_readargs {
+        struct svc_fh           fh;
+        __u32                   offset;
+        __u32                   count;
+        struct kvec             vec[RPCSVC_MAXPAGES];
+        int                     vlen;
+};
+
+struct nfsd_writeargs {
+        svc_fh                  fh;
+        __u32                   offset;
+        int                     len;
+        struct kvec             vec[RPCSVC_MAXPAGES];
+        int                     vlen;
+};
+
+struct nfsd_createargs {
+        struct svc_fh           fh;
+        char *                  name;
+        int                     len;
+        struct iattr            attrs;
+};
+
+struct nfsd_renameargs {
+        struct svc_fh           ffh;
+        char *                  fname;
+        int                     flen;
+        struct svc_fh           tfh;
+        char *                  tname;
+        int                     tlen;
+};
+
+struct nfsd_readlinkargs {
+        struct svc_fh           fh;
+        char *                  buffer;
+};
+        
+struct nfsd_linkargs {
+        struct svc_fh           ffh;
+        struct svc_fh           tfh;
+        char *                  tname;
+        int                     tlen;
+};
+
+struct nfsd_symlinkargs {
+        struct svc_fh           ffh;
+        char *                  fname;
+        int                     flen;
+        char *                  tname;
+        int                     tlen;
+        struct iattr            attrs;
+};
+
+struct nfsd_readdirargs {
+        struct svc_fh           fh;
+        __u32                   cookie;
+        __u32                   count;
+        u32 *                   buffer;
+};
+
+struct nfsd_attrstat {
+        struct svc_fh           fh;
+};
+
+struct nfsd_diropres  {
+        struct svc_fh           fh;
+};
+
+struct nfsd_readlinkres {
+        int                     len;
+};
+
+struct nfsd_readres {
+        struct svc_fh           fh;
+        unsigned long           count;
+};
+
+struct nfsd_readdirres {
+        int                     count;
+
+        struct readdir_cd       common;
+        u32 *                   buffer;
+        int                     buflen;
+        u32 *                   offset;
+};
+
+struct nfsd_statfsres {
+        struct kstatfs          stats;
+};
+
+/*
+ * Storage requirements for XDR arguments and results.
+ */
+union nfsd_xdrstore {
+        struct nfsd_sattrargs   sattr;
+        struct nfsd_diropargs   dirop;
+        struct nfsd_readargs    read;
+        struct nfsd_writeargs   write;
+        struct nfsd_createargs  create;
+        struct nfsd_renameargs  rename;
+        struct nfsd_linkargs    link;
+        struct nfsd_symlinkargs symlink;
+        struct nfsd_readdirargs readdir;
+};
+
+#define NFS2_SVC_XDRSIZE        sizeof(union nfsd_xdrstore)
+
+
+int nfssvc_decode_void(struct svc_rqst *, u32 *, void *);
+int nfssvc_decode_fhandle(struct svc_rqst *, u32 *, struct nfsd_fhandle *);
+int nfssvc_decode_sattrargs(struct svc_rqst *, u32 *,
+                                struct nfsd_sattrargs *);
+int nfssvc_decode_diropargs(struct svc_rqst *, u32 *,
+                                struct nfsd_diropargs *);
+int nfssvc_decode_readargs(struct svc_rqst *, u32 *,
+                                struct nfsd_readargs *);
+int nfssvc_decode_writeargs(struct svc_rqst *, u32 *,
+                                struct nfsd_writeargs *);
+int nfssvc_decode_createargs(struct svc_rqst *, u32 *,
+                                struct nfsd_createargs *);
+int nfssvc_decode_renameargs(struct svc_rqst *, u32 *,
+                                struct nfsd_renameargs *);
+int nfssvc_decode_readlinkargs(struct svc_rqst *, u32 *,
+                                struct nfsd_readlinkargs *);
+int nfssvc_decode_linkargs(struct svc_rqst *, u32 *,
+                                struct nfsd_linkargs *);
+int nfssvc_decode_symlinkargs(struct svc_rqst *, u32 *,
+                                struct nfsd_symlinkargs *);
+int nfssvc_decode_readdirargs(struct svc_rqst *, u32 *,
+                                struct nfsd_readdirargs *);
+int nfssvc_encode_void(struct svc_rqst *, u32 *, void *);
+int nfssvc_encode_attrstat(struct svc_rqst *, u32 *, struct nfsd_attrstat *);
+int nfssvc_encode_diropres(struct svc_rqst *, u32 *, struct nfsd_diropres *);
+int nfssvc_encode_readlinkres(struct svc_rqst *, u32 *, struct nfsd_readlinkres *);
+int nfssvc_encode_readres(struct svc_rqst *, u32 *, struct nfsd_readres *);
+int nfssvc_encode_statfsres(struct svc_rqst *, u32 *, struct nfsd_statfsres *);
+int nfssvc_encode_readdirres(struct svc_rqst *, u32 *, struct nfsd_readdirres *);
+
+int nfssvc_encode_entry(struct readdir_cd *, const char *name,
+                                int namlen, loff_t offset, ino_t ino, unsigned int);
+
+int nfssvc_release_fhandle(struct svc_rqst *, u32 *, struct nfsd_fhandle *);
+
+#endif /* LINUX_NFSD_H */
diff --git a/include/linux/nfsd/xdr3.h b/include/linux/nfsd/xdr3.h
new file mode 100644
index 000000000000..0ae9e0ef5f68
--- /dev/null
+++ b/include/linux/nfsd/xdr3.h
@@ -0,0 +1,321 @@
+/*
+ * linux/include/linux/nfsd/xdr3.h
+ *
+ * XDR types for NFSv3 in nfsd.
+ *
+ * Copyright (C) 1996-1998, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_NFSD_XDR3_H
+#define _LINUX_NFSD_XDR3_H
+
+#include <linux/nfsd/xdr.h>
+
+struct nfsd3_sattrargs {
+        struct svc_fh           fh;
+        struct iattr            attrs;
+        int                     check_guard;
+        time_t                  guardtime;
+};
+
+struct nfsd3_diropargs {
+        struct svc_fh           fh;
+        char *                  name;
+        int                     len;
+};
+
+struct nfsd3_accessargs {
+        struct svc_fh           fh;
+        unsigned int            access;
+};
+
+struct nfsd3_readargs {
+        struct svc_fh           fh;
+        __u64                   offset;
+        __u32                   count;
+        struct kvec             vec[RPCSVC_MAXPAGES];
+        int                     vlen;
+};
+
+struct nfsd3_writeargs {
+        svc_fh                  fh;
+        __u64                   offset;
+        __u32                   count;
+        int                     stable;
+        int                     len;
+        struct kvec             vec[RPCSVC_MAXPAGES];
+        int                     vlen;
+};
+
+struct nfsd3_createargs {
+        struct svc_fh           fh;
+        char *                  name;
+        int                     len;
+        int                     createmode;
+        struct iattr            attrs;
+        __u32 *                 verf;
+};
+
+struct nfsd3_mknodargs {
+        struct svc_fh           fh;
+        char *                  name;
+        int                     len;
+        __u32                   ftype;
+        __u32                   major, minor;
+        struct iattr            attrs;
+};
+
+struct nfsd3_renameargs {
+        struct svc_fh           ffh;
+        char *                  fname;
+        int                     flen;
+        struct svc_fh           tfh;
+        char *                  tname;
+        int                     tlen;
+};
+
+struct nfsd3_readlinkargs {
+        struct svc_fh           fh;
+        char *                  buffer;
+};
+
+struct nfsd3_linkargs {
+        struct svc_fh           ffh;
+        struct svc_fh           tfh;
+        char *                  tname;
+        int                     tlen;
+};
+
+struct nfsd3_symlinkargs {
+        struct svc_fh           ffh;
+        char *                  fname;
+        int                     flen;
+        char *                  tname;
+        int                     tlen;
+        struct iattr            attrs;
+};
+
+struct nfsd3_readdirargs {
+        struct svc_fh           fh;
+        __u64                   cookie;
+        __u32                   dircount;
+        __u32                   count;
+        __u32 *                 verf;
+        u32 *                   buffer;
+};
+
+struct nfsd3_commitargs {
+        struct svc_fh           fh;
+        __u64                   offset;
+        __u32                   count;
+};
+
+struct nfsd3_attrstat {
+        __u32                   status;
+        struct svc_fh           fh;
+};
+
+/* LOOKUP, CREATE, MKDIR, SYMLINK, MKNOD */
+struct nfsd3_diropres  {
+        __u32                   status;
+        struct svc_fh           dirfh;
+        struct svc_fh           fh;
+};
+
+struct nfsd3_accessres {
+        __u32                   status;
+        struct svc_fh           fh;
+        __u32                   access;
+};
+
+struct nfsd3_readlinkres {
+        __u32                   status;
+        struct svc_fh           fh;
+        __u32                   len;
+};
+
+struct nfsd3_readres {
+        __u32                   status;
+        struct svc_fh           fh;
+        unsigned long           count;
+        int                     eof;
+};
+
+struct nfsd3_writeres {
+        __u32                   status;
+        struct svc_fh           fh;
+        unsigned long           count;
+        int                     committed;
+};
+
+struct nfsd3_renameres {
+        __u32                   status;
+        struct svc_fh           ffh;
+        struct svc_fh           tfh;
+};
+
+struct nfsd3_linkres {
+        __u32                   status;
+        struct svc_fh           tfh;
+        struct svc_fh           fh;
+};
+
+struct nfsd3_readdirres {
+        __u32                   status;
+        struct svc_fh           fh;
+        int                     count;
+        __u32                   verf[2];
+
+        struct readdir_cd       common;
+        u32 *                   buffer;
+        int                     buflen;
+        u32 *                   offset;
+        u32 *                   offset1;
+        struct svc_rqst *       rqstp;
+
+};
+
+struct nfsd3_fsstatres {
+        __u32                   status;
+        struct kstatfs          stats;
+        __u32                   invarsec;
+};
+
+struct nfsd3_fsinfores {
+        __u32                   status;
+        __u32                   f_rtmax;
+        __u32                   f_rtpref;
+        __u32                   f_rtmult;
+        __u32                   f_wtmax;
+        __u32                   f_wtpref;
+        __u32                   f_wtmult;
+        __u32                   f_dtpref;
+        __u64                   f_maxfilesize;
+        __u32                   f_properties;
+};
+
+struct nfsd3_pathconfres {
+        __u32                   status;
+        __u32                   p_link_max;
+        __u32                   p_name_max;
+        __u32                   p_no_trunc;
+        __u32                   p_chown_restricted;
+        __u32                   p_case_insensitive;
+        __u32                   p_case_preserving;
+};
+
+struct nfsd3_commitres {
+        __u32                   status;
+        struct svc_fh           fh;
+};
+
+/* dummy type for release */
+struct nfsd3_fhandle_pair {
+        __u32                   dummy;
+        struct svc_fh           fh1;
+        struct svc_fh           fh2;
+};
+
+/*
+ * Storage requirements for XDR arguments and results.
+ */
+union nfsd3_xdrstore {
+        struct nfsd3_sattrargs          sattrargs;
+        struct nfsd3_diropargs          diropargs;
+        struct nfsd3_readargs           readargs;
+        struct nfsd3_writeargs          writeargs;
+        struct nfsd3_createargs         createargs;
+        struct nfsd3_renameargs         renameargs;
+        struct nfsd3_linkargs           linkargs;
+        struct nfsd3_symlinkargs        symlinkargs;
+        struct nfsd3_readdirargs        readdirargs;
+        struct nfsd3_diropres           diropres;
+        struct nfsd3_accessres          accessres;
+        struct nfsd3_readlinkres        readlinkres;
+        struct nfsd3_readres            readres;
+        struct nfsd3_writeres           writeres;
+        struct nfsd3_renameres          renameres;
+        struct nfsd3_linkres            linkres;
+        struct nfsd3_readdirres         readdirres;
+        struct nfsd3_fsstatres          fsstatres;
+        struct nfsd3_fsinfores          fsinfores;
+        struct nfsd3_pathconfres        pathconfres;
+        struct nfsd3_commitres          commitres;
+};
+
+#define NFS3_SVC_XDRSIZE                sizeof(union nfsd3_xdrstore)
+
+int nfs3svc_decode_fhandle(struct svc_rqst *, u32 *, struct nfsd_fhandle *);
+int nfs3svc_decode_sattrargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_sattrargs *);
+int nfs3svc_decode_diropargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_diropargs *);
+int nfs3svc_decode_accessargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_accessargs *);
+int nfs3svc_decode_readargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_readargs *);
+int nfs3svc_decode_writeargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_writeargs *);
+int nfs3svc_decode_createargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_createargs *);
+int nfs3svc_decode_mkdirargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_createargs *);
+int nfs3svc_decode_mknodargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_mknodargs *);
+int nfs3svc_decode_renameargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_renameargs *);
+int nfs3svc_decode_readlinkargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_readlinkargs *);
+int nfs3svc_decode_linkargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_linkargs *);
+int nfs3svc_decode_symlinkargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_symlinkargs *);
+int nfs3svc_decode_readdirargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_readdirargs *);
+int nfs3svc_decode_readdirplusargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_readdirargs *);
+int nfs3svc_decode_commitargs(struct svc_rqst *, u32 *,
+                                struct nfsd3_commitargs *);
+int nfs3svc_encode_voidres(struct svc_rqst *, u32 *, void *);
+int nfs3svc_encode_attrstat(struct svc_rqst *, u32 *,
+                                struct nfsd3_attrstat *);
+int nfs3svc_encode_wccstat(struct svc_rqst *, u32 *,
+                                struct nfsd3_attrstat *);
+int nfs3svc_encode_diropres(struct svc_rqst *, u32 *,
+                                struct nfsd3_diropres *);
+int nfs3svc_encode_accessres(struct svc_rqst *, u32 *,
+                                struct nfsd3_accessres *);
+int nfs3svc_encode_readlinkres(struct svc_rqst *, u32 *,
+                                struct nfsd3_readlinkres *);
+int nfs3svc_encode_readres(struct svc_rqst *, u32 *, struct nfsd3_readres *);
+int nfs3svc_encode_writeres(struct svc_rqst *, u32 *, struct nfsd3_writeres *);
+int nfs3svc_encode_createres(struct svc_rqst *, u32 *,
+                                struct nfsd3_diropres *);
+int nfs3svc_encode_renameres(struct svc_rqst *, u32 *,
+                                struct nfsd3_renameres *);
+int nfs3svc_encode_linkres(struct svc_rqst *, u32 *,
+                                struct nfsd3_linkres *);
+int nfs3svc_encode_readdirres(struct svc_rqst *, u32 *,
+                                struct nfsd3_readdirres *);
+int nfs3svc_encode_fsstatres(struct svc_rqst *, u32 *,
+                                struct nfsd3_fsstatres *);
+int nfs3svc_encode_fsinfores(struct svc_rqst *, u32 *,
+                                struct nfsd3_fsinfores *);
+int nfs3svc_encode_pathconfres(struct svc_rqst *, u32 *,
+                                struct nfsd3_pathconfres *);
+int nfs3svc_encode_commitres(struct svc_rqst *, u32 *,
+                                struct nfsd3_commitres *);
+
+int nfs3svc_release_fhandle(struct svc_rqst *, u32 *,
+                                struct nfsd3_attrstat *);
+int nfs3svc_release_fhandle2(struct svc_rqst *, u32 *,
+                                struct nfsd3_fhandle_pair *);
+int nfs3svc_encode_entry(struct readdir_cd *, const char *name,
+                                int namlen, loff_t offset, ino_t ino,
+                                unsigned int);
+int nfs3svc_encode_entry_plus(struct readdir_cd *, const char *name,
+                                int namlen, loff_t offset, ino_t ino,
+                                unsigned int);
+
+
+#endif /* _LINUX_NFSD_XDR3_H */
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
new file mode 100644
index 000000000000..a1f5ad0be1bf
--- /dev/null
+++ b/include/linux/nfsd/xdr4.h
@@ -0,0 +1,463 @@
+/*
+ *  include/linux/nfsd/xdr4.h
+ *
+ *  Server-side types for NFSv4.
+ *
+ *  Copyright (c) 2002 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Kendrick Smith <kmsmith@umich.edu>
+ *  Andy Adamson   <andros@umich.edu>
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the University nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _LINUX_NFSD_XDR4_H
+#define _LINUX_NFSD_XDR4_H
+
+#include <linux/nfs4.h>
+
+#define NFSD4_MAX_TAGLEN        128
+#define XDR_LEN(n)                     (((n) + 3) & ~3)
+
+struct nfsd4_change_info {
+        u32             atomic;
+        u32             before_ctime_sec;
+        u32             before_ctime_nsec;
+        u32             after_ctime_sec;
+        u32             after_ctime_nsec;
+};
+
+struct nfsd4_access {
+        u32             ac_req_access;      /* request */
+        u32             ac_supported;       /* response */
+        u32             ac_resp_access;     /* response */
+};
+
+struct nfsd4_close {
+        u32             cl_seqid;           /* request */
+        stateid_t       cl_stateid;         /* request+response */
+        struct nfs4_stateowner * cl_stateowner; /* response */
+};
+
+struct nfsd4_commit {
+        u64             co_offset;          /* request */
+        u32             co_count;           /* request */
+        nfs4_verifier   co_verf;            /* response */
+};
+
+struct nfsd4_create {
+        u32             cr_namelen;         /* request */
+        char *          cr_name;            /* request */
+        u32             cr_type;            /* request */
+        union {                             /* request */
+                struct {
+                        u32 namelen;
+                        char *name;
+                } link;   /* NF4LNK */
+                struct {
+                        u32 specdata1;
+                        u32 specdata2;
+                } dev;    /* NF4BLK, NF4CHR */
+        } u;
+        u32             cr_bmval[2];        /* request */
+        struct iattr    cr_iattr;           /* request */
+        struct nfsd4_change_info  cr_cinfo; /* response */
+        struct nfs4_acl *cr_acl;
+};
+#define cr_linklen      u.link.namelen
+#define cr_linkname     u.link.name
+#define cr_specdata1    u.dev.specdata1
+#define cr_specdata2    u.dev.specdata2
+
+struct nfsd4_delegreturn {
+        stateid_t       dr_stateid;
+};
+
+struct nfsd4_getattr {
+        u32             ga_bmval[2];        /* request */
+        struct svc_fh   *ga_fhp;            /* response */
+};
+
+struct nfsd4_link {
+        u32             li_namelen;         /* request */
+        char *          li_name;            /* request */
+        struct nfsd4_change_info  li_cinfo; /* response */
+};
+
+struct nfsd4_lock_denied {
+        clientid_t      ld_clientid;
+        struct nfs4_stateowner   *ld_sop;
+        u64             ld_start;
+        u64             ld_length;
+        u32             ld_type;
+};
+
+struct nfsd4_lock {
+        /* request */
+        u32             lk_type;
+        u32             lk_reclaim;         /* boolean */
+        u64             lk_offset;
+        u64             lk_length;
+        u32             lk_is_new;
+        union {
+                struct {
+                        u32             open_seqid;
+                        stateid_t       open_stateid;
+                        u32             lock_seqid;
+                        clientid_t      clientid;
+                        struct xdr_netobj owner;
+                } new;
+                struct {
+                        stateid_t       lock_stateid;
+                        u32             lock_seqid;
+                } old;
+        } v;
+
+        /* response */
+        union {
+                struct {
+                        stateid_t               stateid;
+                } ok;
+                struct nfsd4_lock_denied        denied;
+        } u;
+
+        struct nfs4_stateowner *lk_stateowner;
+};
+#define lk_new_open_seqid       v.new.open_seqid
+#define lk_new_open_stateid     v.new.open_stateid
+#define lk_new_lock_seqid       v.new.lock_seqid
+#define lk_new_clientid         v.new.clientid
+#define lk_new_owner            v.new.owner
+#define lk_old_lock_stateid     v.old.lock_stateid
+#define lk_old_lock_seqid       v.old.lock_seqid
+
+#define lk_rflags       u.ok.rflags
+#define lk_resp_stateid u.ok.stateid
+#define lk_denied       u.denied
+
+
+struct nfsd4_lockt {
+        u32                             lt_type;
+        clientid_t                      lt_clientid;
+        struct xdr_netobj               lt_owner;
+        u64                             lt_offset;
+        u64                             lt_length;
+        struct nfs4_stateowner *        lt_stateowner;
+        struct nfsd4_lock_denied        lt_denied;
+};
+
+ 
+struct nfsd4_locku {
+        u32             lu_type;
+        u32             lu_seqid;
+        stateid_t       lu_stateid;
+        u64             lu_offset;
+        u64             lu_length;
+        struct nfs4_stateowner  *lu_stateowner;
+};
+
+
+struct nfsd4_lookup {
+        u32             lo_len;             /* request */
+        char *          lo_name;            /* request */
+};
+
+struct nfsd4_putfh {
+        u32             pf_fhlen;           /* request */
+        char            *pf_fhval;          /* request */
+};
+
+struct nfsd4_open {
+        u32             op_claim_type;      /* request */
+        struct xdr_netobj op_fname;         /* request - everything but CLAIM_PREV */
+        u32             op_delegate_type;   /* request - CLAIM_PREV only */
+        stateid_t       op_delegate_stateid; /* request - response */
+        u32             op_create;          /* request */
+        u32             op_createmode;      /* request */
+        u32             op_bmval[2];        /* request */
+        union {                             /* request */
+                struct iattr    iattr;                      /* UNCHECKED4,GUARDED4 */
+                nfs4_verifier   verf;                                /* EXCLUSIVE4 */
+        } u;
+        clientid_t      op_clientid;        /* request */
+        struct xdr_netobj op_owner;           /* request */
+        u32             op_seqid;           /* request */
+        u32             op_share_access;    /* request */
+        u32             op_share_deny;      /* request */
+        stateid_t       op_stateid;         /* response */
+        struct nfsd4_change_info  op_cinfo; /* response */
+        u32             op_rflags;          /* response */
+        int             op_truncate;        /* used during processing */
+        struct nfs4_stateowner *op_stateowner; /* used during processing */
+        struct nfs4_acl *op_acl;
+};
+#define op_iattr        u.iattr
+#define op_verf         u.verf
+
+struct nfsd4_open_confirm {
+        stateid_t       oc_req_stateid          /* request */;
+        u32             oc_seqid                /* request */;
+        stateid_t       oc_resp_stateid         /* response */;
+        struct nfs4_stateowner * oc_stateowner; /* response */
+};
+
+struct nfsd4_open_downgrade {
+        stateid_t       od_stateid;
+        u32             od_seqid;
+        u32             od_share_access;
+        u32             od_share_deny;
+        struct nfs4_stateowner *od_stateowner;
+};
+
+
+struct nfsd4_read {
+        stateid_t       rd_stateid;         /* request */
+        u64             rd_offset;          /* request */
+        u32             rd_length;          /* request */
+        struct kvec     rd_iov[RPCSVC_MAXPAGES];
+        int             rd_vlen;
+        struct file     *rd_filp;
+        
+        struct svc_rqst *rd_rqstp;          /* response */
+        struct svc_fh * rd_fhp;             /* response */
+};
+
+struct nfsd4_readdir {
+        u64             rd_cookie;          /* request */
+        nfs4_verifier   rd_verf;            /* request */
+        u32             rd_dircount;        /* request */
+        u32             rd_maxcount;        /* request */
+        u32             rd_bmval[2];        /* request */
+        struct svc_rqst *rd_rqstp;          /* response */
+        struct svc_fh * rd_fhp;             /* response */
+
+        struct readdir_cd       common;
+        u32 *                   buffer;
+        int                     buflen;
+        u32 *                   offset;
+};
+
+struct nfsd4_release_lockowner {
+        clientid_t        rl_clientid;
+        struct xdr_netobj rl_owner;
+};
+struct nfsd4_readlink {
+        struct svc_rqst *rl_rqstp;          /* request */
+        struct svc_fh * rl_fhp;             /* request */
+};
+
+struct nfsd4_remove {
+        u32             rm_namelen;         /* request */
+        char *          rm_name;            /* request */
+        struct nfsd4_change_info  rm_cinfo; /* response */
+};
+
+struct nfsd4_rename {
+        u32             rn_snamelen;        /* request */
+        char *          rn_sname;           /* request */
+        u32             rn_tnamelen;        /* request */
+        char *          rn_tname;           /* request */
+        struct nfsd4_change_info  rn_sinfo; /* response */
+        struct nfsd4_change_info  rn_tinfo; /* response */
+};
+
+struct nfsd4_setattr {
+        stateid_t       sa_stateid;         /* request */
+        u32             sa_bmval[2];        /* request */
+        struct iattr    sa_iattr;           /* request */
+        struct nfs4_acl *sa_acl;
+};
+
+struct nfsd4_setclientid {
+        nfs4_verifier   se_verf;            /* request */
+        u32             se_namelen;         /* request */
+        char *          se_name;            /* request */
+        u32             se_callback_prog;   /* request */
+        u32             se_callback_netid_len;  /* request */
+        char *          se_callback_netid_val;  /* request */
+        u32             se_callback_addr_len;   /* request */
+        char *          se_callback_addr_val;   /* request */
+        u32             se_callback_ident;  /* request */
+        clientid_t      se_clientid;        /* response */
+        nfs4_verifier   se_confirm;         /* response */
+};
+
+struct nfsd4_setclientid_confirm {
+        clientid_t      sc_clientid;
+        nfs4_verifier   sc_confirm;
+};
+
+/* also used for NVERIFY */
+struct nfsd4_verify {
+        u32             ve_bmval[2];        /* request */
+        u32             ve_attrlen;         /* request */
+        char *          ve_attrval;         /* request */
+};
+
+struct nfsd4_write {
+        stateid_t       wr_stateid;         /* request */
+        u64             wr_offset;          /* request */
+        u32             wr_stable_how;      /* request */
+        u32             wr_buflen;          /* request */
+        struct kvec     wr_vec[RPCSVC_MAXPAGES]; /* request */
+        int             wr_vlen;
+
+        u32             wr_bytes_written;   /* response */
+        u32             wr_how_written;     /* response */
+        nfs4_verifier   wr_verifier;        /* response */
+};
+
+struct nfsd4_op {
+        int                                     opnum;
+        int                                     status;
+        union {
+                struct nfsd4_access             access;
+                struct nfsd4_close              close;
+                struct nfsd4_commit             commit;
+                struct nfsd4_create             create;
+                struct nfsd4_delegreturn        delegreturn;
+                struct nfsd4_getattr            getattr;
+                struct svc_fh *                 getfh;
+                struct nfsd4_link               link;
+                struct nfsd4_lock               lock;
+                struct nfsd4_lockt              lockt;
+                struct nfsd4_locku              locku;
+                struct nfsd4_lookup             lookup;
+                struct nfsd4_verify             nverify;
+                struct nfsd4_open               open;
+                struct nfsd4_open_confirm       open_confirm;
+                struct nfsd4_open_downgrade     open_downgrade;
+                struct nfsd4_putfh              putfh;
+                struct nfsd4_read               read;
+                struct nfsd4_readdir            readdir;
+                struct nfsd4_readlink           readlink;
+                struct nfsd4_remove             remove;
+                struct nfsd4_rename             rename;
+                clientid_t                      renew;
+                struct nfsd4_setattr            setattr;
+                struct nfsd4_setclientid        setclientid;
+                struct nfsd4_setclientid_confirm setclientid_confirm;
+                struct nfsd4_verify             verify;
+                struct nfsd4_write              write;
+                struct nfsd4_release_lockowner  release_lockowner;
+        } u;
+        struct nfs4_replay *                    replay;
+};
+
+struct nfsd4_compoundargs {
+        /* scratch variables for XDR decode */
+        u32 *                           p;
+        u32 *                           end;
+        struct page **                  pagelist;
+        int                             pagelen;
+        u32                             tmp[8];
+        u32 *                           tmpp;
+        struct tmpbuf {
+                struct tmpbuf *next;
+                void (*release)(const void *);
+                void *buf;
+        }                               *to_free;
+
+        struct svc_rqst                 *rqstp;
+
+        u32                             taglen;
+        char *                          tag;
+        u32                             minorversion;
+        u32                             opcnt;
+        struct nfsd4_op                 *ops;
+        struct nfsd4_op                 iops[8];
+};
+
+struct nfsd4_compoundres {
+        /* scratch variables for XDR encode */
+        u32 *                           p;
+        u32 *                           end;
+        struct xdr_buf *                xbuf;
+        struct svc_rqst *               rqstp;
+
+        u32                             taglen;
+        char *                          tag;
+        u32                             opcnt;
+        u32 *                           tagp; /* where to encode tag and  opcount */
+};
+
+#define NFS4_SVC_XDRSIZE                sizeof(struct nfsd4_compoundargs)
+
+static inline void
+set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
+{
+        BUG_ON(!fhp->fh_pre_saved || !fhp->fh_post_saved);
+        cinfo->atomic = 1;
+        cinfo->before_ctime_sec = fhp->fh_pre_ctime.tv_sec;
+        cinfo->before_ctime_nsec = fhp->fh_pre_ctime.tv_nsec;
+        cinfo->after_ctime_sec = fhp->fh_post_ctime.tv_sec;
+        cinfo->after_ctime_nsec = fhp->fh_post_ctime.tv_nsec;
+}
+
+int nfs4svc_encode_voidres(struct svc_rqst *, u32 *, void *);
+int nfs4svc_decode_compoundargs(struct svc_rqst *, u32 *, 
+                struct nfsd4_compoundargs *);
+int nfs4svc_encode_compoundres(struct svc_rqst *, u32 *, 
+                struct nfsd4_compoundres *);
+void nfsd4_encode_operation(struct nfsd4_compoundres *, struct nfsd4_op *);
+void nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op);
+int nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
+                       struct dentry *dentry, u32 *buffer, int *countp, 
+                       u32 *bmval, struct svc_rqst *);
+extern int nfsd4_setclientid(struct svc_rqst *rqstp, 
+                struct nfsd4_setclientid *setclid);
+extern int nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 
+                struct nfsd4_setclientid_confirm *setclientid_confirm);
+extern int nfsd4_process_open1(struct nfsd4_open *open);
+extern int nfsd4_process_open2(struct svc_rqst *rqstp, 
+                struct svc_fh *current_fh, struct nfsd4_open *open);
+extern int nfsd4_open_confirm(struct svc_rqst *rqstp, 
+                struct svc_fh *current_fh, struct nfsd4_open_confirm *oc);
+extern  int nfsd4_close(struct svc_rqst *rqstp, struct svc_fh *current_fh, 
+                struct nfsd4_close *close);
+extern int nfsd4_open_downgrade(struct svc_rqst *rqstp, 
+                struct svc_fh *current_fh, struct nfsd4_open_downgrade *od);
+extern int nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, 
+                struct nfsd4_lock *lock);
+extern int nfsd4_lockt(struct svc_rqst *rqstp, struct svc_fh *current_fh, 
+                struct nfsd4_lockt *lockt);
+extern int nfsd4_locku(struct svc_rqst *rqstp, struct svc_fh *current_fh, 
+                struct nfsd4_locku *locku);
+extern int
+nfsd4_release_lockowner(struct svc_rqst *rqstp,
+                struct nfsd4_release_lockowner *rlockowner);
+extern void nfsd4_release_compoundargs(struct nfsd4_compoundargs *);
+extern int nfsd4_delegreturn(struct svc_rqst *rqstp,
+                struct svc_fh *current_fh, struct nfsd4_delegreturn *dr);
+#endif
+
+/*
+ * Local variables:
+ *  c-basic-offset: 8
+ * End:
+ */
diff --git a/include/linux/nfsd_idmap.h b/include/linux/nfsd_idmap.h
new file mode 100644
index 000000000000..9bb7f30e923b
--- /dev/null
+++ b/include/linux/nfsd_idmap.h
@@ -0,0 +1,54 @@
+/*
+ *  include/linux/nfsd_idmap.h
+ *
+ *  Mapping of UID to name and vice versa.
+ *
+ *  Copyright (c) 2002, 2003 The Regents of the University of
+ *  Michigan.  All rights reserved.
+> *
+ *  Marius Aamodt Eriksen <marius@umich.edu>
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the University nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LINUX_NFSD_IDMAP_H
+#define LINUX_NFSD_IDMAP_H
+
+#include <linux/in.h>
+#include <linux/sunrpc/svc.h>
+
+/* XXX from linux/nfs_idmap.h */
+#define IDMAP_NAMESZ 128
+
+void nfsd_idmap_init(void);
+void nfsd_idmap_shutdown(void);
+
+int nfsd_map_name_to_uid(struct svc_rqst *, const char *, size_t, __u32 *);
+int nfsd_map_name_to_gid(struct svc_rqst *, const char *, size_t, __u32 *);
+int nfsd_map_uid_to_name(struct svc_rqst *, __u32, char *);
+int nfsd_map_gid_to_name(struct svc_rqst *, __u32, char *);
+
+#endif /* LINUX_NFSD_IDMAP_H */
diff --git a/include/linux/nls.h b/include/linux/nls.h
new file mode 100644
index 000000000000..816c04ad7381
--- /dev/null
+++ b/include/linux/nls.h
@@ -0,0 +1,64 @@
+#ifndef _LINUX_NLS_H
+#define _LINUX_NLS_H
+
+#include <linux/init.h>
+
+/* unicode character */
+typedef __u16 wchar_t;
+
+struct nls_table {
+        char *charset;
+        char *alias;
+        int (*uni2char) (wchar_t uni, unsigned char *out, int boundlen);
+        int (*char2uni) (const unsigned char *rawstring, int boundlen,
+                         wchar_t *uni);
+        unsigned char *charset2lower;
+        unsigned char *charset2upper;
+        struct module *owner;
+        struct nls_table *next;
+};
+
+/* this value hold the maximum octet of charset */
+#define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */
+
+/* nls.c */
+extern int register_nls(struct nls_table *);
+extern int unregister_nls(struct nls_table *);
+extern struct nls_table *load_nls(char *);
+extern void unload_nls(struct nls_table *);
+extern struct nls_table *load_nls_default(void);
+
+extern int utf8_mbtowc(wchar_t *, const __u8 *, int);
+extern int utf8_mbstowcs(wchar_t *, const __u8 *, int);
+extern int utf8_wctomb(__u8 *, wchar_t, int);
+extern int utf8_wcstombs(__u8 *, const wchar_t *, int);
+
+static inline unsigned char nls_tolower(struct nls_table *t, unsigned char c)
+{
+        unsigned char nc = t->charset2lower[c];
+
+        return nc ? nc : c;
+}
+
+static inline unsigned char nls_toupper(struct nls_table *t, unsigned char c)
+{
+        unsigned char nc = t->charset2upper[c];
+
+        return nc ? nc : c;
+}
+
+static inline int nls_strnicmp(struct nls_table *t, const unsigned char *s1,
+                const unsigned char *s2, int len)
+{
+        while (len--) {
+                if (nls_tolower(t, *s1++) != nls_tolower(t, *s2++))
+                        return 1;
+        }
+
+        return 0;
+}
+
+#define MODULE_ALIAS_NLS(name)  MODULE_ALIAS("nls_" __stringify(name))
+
+#endif /* _LINUX_NLS_H */
+
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
new file mode 100644
index 000000000000..c8f4d2f627d7
--- /dev/null
+++ b/include/linux/nmi.h
@@ -0,0 +1,22 @@
+/*
+ *  linux/include/linux/nmi.h
+ */
+#ifndef LINUX_NMI_H
+#define LINUX_NMI_H
+
+#include <asm/irq.h>
+
+/**
+ * touch_nmi_watchdog - restart NMI watchdog timeout.
+ * 
+ * If the architecture supports the NMI watchdog, touch_nmi_watchdog()
+ * may be used to reset the timeout - for code which intentionally
+ * disables interrupts for a long time. This call is stateless.
+ */
+#ifdef ARCH_HAS_NMI_WATCHDOG
+extern void touch_nmi_watchdog(void);
+#else
+# define touch_nmi_watchdog() do { } while(0)
+#endif
+
+#endif
diff --git a/include/linux/node.h b/include/linux/node.h
new file mode 100644
index 000000000000..6e0a697e594e
--- /dev/null
+++ b/include/linux/node.h
@@ -0,0 +1,33 @@
+/*
+ * include/linux/node.h - generic node definition
+ *
+ * This is mainly for topological representation. We define the 
+ * basic 'struct node' here, which can be embedded in per-arch 
+ * definitions of processors.
+ *
+ * Basic handling of the devices is done in drivers/base/node.c
+ * and system devices are handled in drivers/base/sys.c. 
+ *
+ * Nodes are exported via driverfs in the class/node/devices/
+ * directory. 
+ *
+ * Per-node interfaces can be implemented using a struct device_interface. 
+ * See the following for how to do this: 
+ * - drivers/base/intf.c 
+ * - Documentation/driver-model/interface.txt
+ */
+#ifndef _LINUX_NODE_H_
+#define _LINUX_NODE_H_
+
+#include <linux/sysdev.h>
+#include <linux/cpumask.h>
+
+struct node {
+        struct sys_device       sysdev;
+};
+
+extern int register_node(struct node *, int, struct node *);
+
+#define to_node(sys_device) container_of(sys_device, struct node, sysdev)
+
+#endif /* _LINUX_NODE_H_ */
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
new file mode 100644
index 000000000000..e96fe9062500
--- /dev/null
+++ b/include/linux/nodemask.h
@@ -0,0 +1,356 @@
+#ifndef __LINUX_NODEMASK_H
+#define __LINUX_NODEMASK_H
+
+/*
+ * Nodemasks provide a bitmap suitable for representing the
+ * set of Node's in a system, one bit position per Node number.
+ *
+ * See detailed comments in the file linux/bitmap.h describing the
+ * data type on which these nodemasks are based.
+ *
+ * For details of nodemask_scnprintf() and nodemask_parse(),
+ * see bitmap_scnprintf() and bitmap_parse() in lib/bitmap.c.
+ * For details of nodelist_scnprintf() and nodelist_parse(), see
+ * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
+ *
+ * The available nodemask operations are:
+ *
+ * void node_set(node, mask)            turn on bit 'node' in mask
+ * void node_clear(node, mask)          turn off bit 'node' in mask
+ * void nodes_setall(mask)              set all bits
+ * void nodes_clear(mask)               clear all bits
+ * int node_isset(node, mask)           true iff bit 'node' set in mask
+ * int node_test_and_set(node, mask)    test and set bit 'node' in mask
+ *
+ * void nodes_and(dst, src1, src2)      dst = src1 & src2  [intersection]
+ * void nodes_or(dst, src1, src2)       dst = src1 | src2  [union]
+ * void nodes_xor(dst, src1, src2)      dst = src1 ^ src2
+ * void nodes_andnot(dst, src1, src2)   dst = src1 & ~src2
+ * void nodes_complement(dst, src)      dst = ~src
+ *
+ * int nodes_equal(mask1, mask2)        Does mask1 == mask2?
+ * int nodes_intersects(mask1, mask2)   Do mask1 and mask2 intersect?
+ * int nodes_subset(mask1, mask2)       Is mask1 a subset of mask2?
+ * int nodes_empty(mask)                Is mask empty (no bits sets)?
+ * int nodes_full(mask)                 Is mask full (all bits sets)?
+ * int nodes_weight(mask)               Hamming weight - number of set bits
+ *
+ * void nodes_shift_right(dst, src, n)  Shift right
+ * void nodes_shift_left(dst, src, n)   Shift left
+ *
+ * int first_node(mask)                 Number lowest set bit, or MAX_NUMNODES
+ * int next_node(node, mask)            Next node past 'node', or MAX_NUMNODES
+ * int first_unset_node(mask)           First node not set in mask, or 
+ *                                      MAX_NUMNODES.
+ *
+ * nodemask_t nodemask_of_node(node)    Return nodemask with bit 'node' set
+ * NODE_MASK_ALL                        Initializer - all bits set
+ * NODE_MASK_NONE                       Initializer - no bits set
+ * unsigned long *nodes_addr(mask)      Array of unsigned long's in mask
+ *
+ * int nodemask_scnprintf(buf, len, mask) Format nodemask for printing
+ * int nodemask_parse(ubuf, ulen, mask) Parse ascii string as nodemask
+ * int nodelist_scnprintf(buf, len, mask) Format nodemask as list for printing
+ * int nodelist_parse(buf, map)         Parse ascii string as nodelist
+ *
+ * for_each_node_mask(node, mask)       for-loop node over mask
+ *
+ * int num_online_nodes()               Number of online Nodes
+ * int num_possible_nodes()             Number of all possible Nodes
+ *
+ * int node_online(node)                Is some node online?
+ * int node_possible(node)              Is some node possible?
+ *
+ * int any_online_node(mask)            First online node in mask
+ *
+ * node_set_online(node)                set bit 'node' in node_online_map
+ * node_set_offline(node)               clear bit 'node' in node_online_map
+ *
+ * for_each_node(node)                  for-loop node over node_possible_map
+ * for_each_online_node(node)           for-loop node over node_online_map
+ *
+ * Subtlety:
+ * 1) The 'type-checked' form of node_isset() causes gcc (3.3.2, anyway)
+ *    to generate slightly worse code.  So use a simple one-line #define
+ *    for node_isset(), instead of wrapping an inline inside a macro, the
+ *    way we do the other calls.
+ */
+
+#include <linux/kernel.h>
+#include <linux/threads.h>
+#include <linux/bitmap.h>
+#include <linux/numa.h>
+#include <asm/bug.h>
+
+typedef struct { DECLARE_BITMAP(bits, MAX_NUMNODES); } nodemask_t;
+extern nodemask_t _unused_nodemask_arg_;
+
+#define node_set(node, dst) __node_set((node), &(dst))
+static inline void __node_set(int node, volatile nodemask_t *dstp)
+{
+        set_bit(node, dstp->bits);
+}
+
+#define node_clear(node, dst) __node_clear((node), &(dst))
+static inline void __node_clear(int node, volatile nodemask_t *dstp)
+{
+        clear_bit(node, dstp->bits);
+}
+
+#define nodes_setall(dst) __nodes_setall(&(dst), MAX_NUMNODES)
+static inline void __nodes_setall(nodemask_t *dstp, int nbits)
+{
+        bitmap_fill(dstp->bits, nbits);
+}
+
+#define nodes_clear(dst) __nodes_clear(&(dst), MAX_NUMNODES)
+static inline void __nodes_clear(nodemask_t *dstp, int nbits)
+{
+        bitmap_zero(dstp->bits, nbits);
+}
+
+/* No static inline type checking - see Subtlety (1) above. */
+#define node_isset(node, nodemask) test_bit((node), (nodemask).bits)
+
+#define node_test_and_set(node, nodemask) \
+                        __node_test_and_set((node), &(nodemask))
+static inline int __node_test_and_set(int node, nodemask_t *addr)
+{
+        return test_and_set_bit(node, addr->bits);
+}
+
+#define nodes_and(dst, src1, src2) \
+                        __nodes_and(&(dst), &(src1), &(src2), MAX_NUMNODES)
+static inline void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_or(dst, src1, src2) \
+                        __nodes_or(&(dst), &(src1), &(src2), MAX_NUMNODES)
+static inline void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_xor(dst, src1, src2) \
+                        __nodes_xor(&(dst), &(src1), &(src2), MAX_NUMNODES)
+static inline void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_andnot(dst, src1, src2) \
+                        __nodes_andnot(&(dst), &(src1), &(src2), MAX_NUMNODES)
+static inline void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_complement(dst, src) \
+                        __nodes_complement(&(dst), &(src), MAX_NUMNODES)
+static inline void __nodes_complement(nodemask_t *dstp,
+                                        const nodemask_t *srcp, int nbits)
+{
+        bitmap_complement(dstp->bits, srcp->bits, nbits);
+}
+
+#define nodes_equal(src1, src2) \
+                        __nodes_equal(&(src1), &(src2), MAX_NUMNODES)
+static inline int __nodes_equal(const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        return bitmap_equal(src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_intersects(src1, src2) \
+                        __nodes_intersects(&(src1), &(src2), MAX_NUMNODES)
+static inline int __nodes_intersects(const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        return bitmap_intersects(src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_subset(src1, src2) \
+                        __nodes_subset(&(src1), &(src2), MAX_NUMNODES)
+static inline int __nodes_subset(const nodemask_t *src1p,
+                                        const nodemask_t *src2p, int nbits)
+{
+        return bitmap_subset(src1p->bits, src2p->bits, nbits);
+}
+
+#define nodes_empty(src) __nodes_empty(&(src), MAX_NUMNODES)
+static inline int __nodes_empty(const nodemask_t *srcp, int nbits)
+{
+        return bitmap_empty(srcp->bits, nbits);
+}
+
+#define nodes_full(nodemask) __nodes_full(&(nodemask), MAX_NUMNODES)
+static inline int __nodes_full(const nodemask_t *srcp, int nbits)
+{
+        return bitmap_full(srcp->bits, nbits);
+}
+
+#define nodes_weight(nodemask) __nodes_weight(&(nodemask), MAX_NUMNODES)
+static inline int __nodes_weight(const nodemask_t *srcp, int nbits)
+{
+        return bitmap_weight(srcp->bits, nbits);
+}
+
+#define nodes_shift_right(dst, src, n) \
+                        __nodes_shift_right(&(dst), &(src), (n), MAX_NUMNODES)
+static inline void __nodes_shift_right(nodemask_t *dstp,
+                                        const nodemask_t *srcp, int n, int nbits)
+{
+        bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
+}
+
+#define nodes_shift_left(dst, src, n) \
+                        __nodes_shift_left(&(dst), &(src), (n), MAX_NUMNODES)
+static inline void __nodes_shift_left(nodemask_t *dstp,
+                                        const nodemask_t *srcp, int n, int nbits)
+{
+        bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
+}
+
+/* FIXME: better would be to fix all architectures to never return
+          > MAX_NUMNODES, then the silly min_ts could be dropped. */
+
+#define first_node(src) __first_node(&(src))
+static inline int __first_node(const nodemask_t *srcp)
+{
+        return min_t(int, MAX_NUMNODES, find_first_bit(srcp->bits, MAX_NUMNODES));
+}
+
+#define next_node(n, src) __next_node((n), &(src))
+static inline int __next_node(int n, const nodemask_t *srcp)
+{
+        return min_t(int,MAX_NUMNODES,find_next_bit(srcp->bits, MAX_NUMNODES, n+1));
+}
+
+#define nodemask_of_node(node)                                          \
+({                                                                      \
+        typeof(_unused_nodemask_arg_) m;                                \
+        if (sizeof(m) == sizeof(unsigned long)) {                       \
+                m.bits[0] = 1UL<<(node);                                \
+        } else {                                                        \
+                nodes_clear(m);                                         \
+                node_set((node), m);                                    \
+        }                                                               \
+        m;                                                              \
+})
+
+#define first_unset_node(mask) __first_unset_node(&(mask))
+static inline int __first_unset_node(const nodemask_t *maskp)
+{
+        return min_t(int,MAX_NUMNODES,
+                        find_first_zero_bit(maskp->bits, MAX_NUMNODES));
+}
+
+#define NODE_MASK_LAST_WORD BITMAP_LAST_WORD_MASK(MAX_NUMNODES)
+
+#if MAX_NUMNODES <= BITS_PER_LONG
+
+#define NODE_MASK_ALL                                                   \
+((nodemask_t) { {                                                       \
+        [BITS_TO_LONGS(MAX_NUMNODES)-1] = NODE_MASK_LAST_WORD           \
+} })
+
+#else
+
+#define NODE_MASK_ALL                                                   \
+((nodemask_t) { {                                                       \
+        [0 ... BITS_TO_LONGS(MAX_NUMNODES)-2] = ~0UL,                   \
+        [BITS_TO_LONGS(MAX_NUMNODES)-1] = NODE_MASK_LAST_WORD           \
+} })
+
+#endif
+
+#define NODE_MASK_NONE                                                  \
+((nodemask_t) { {                                                       \
+        [0 ... BITS_TO_LONGS(MAX_NUMNODES)-1] =  0UL                    \
+} })
+
+#define nodes_addr(src) ((src).bits)
+
+#define nodemask_scnprintf(buf, len, src) \
+                        __nodemask_scnprintf((buf), (len), &(src), MAX_NUMNODES)
+static inline int __nodemask_scnprintf(char *buf, int len,
+                                        const nodemask_t *srcp, int nbits)
+{
+        return bitmap_scnprintf(buf, len, srcp->bits, nbits);
+}
+
+#define nodemask_parse(ubuf, ulen, dst) \
+                        __nodemask_parse((ubuf), (ulen), &(dst), MAX_NUMNODES)
+static inline int __nodemask_parse(const char __user *buf, int len,
+                                        nodemask_t *dstp, int nbits)
+{
+        return bitmap_parse(buf, len, dstp->bits, nbits);
+}
+
+#define nodelist_scnprintf(buf, len, src) \
+                        __nodelist_scnprintf((buf), (len), &(src), MAX_NUMNODES)
+static inline int __nodelist_scnprintf(char *buf, int len,
+                                        const nodemask_t *srcp, int nbits)
+{
+        return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
+}
+
+#define nodelist_parse(buf, dst) __nodelist_parse((buf), &(dst), MAX_NUMNODES)
+static inline int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
+{
+        return bitmap_parselist(buf, dstp->bits, nbits);
+}
+
+#if MAX_NUMNODES > 1
+#define for_each_node_mask(node, mask)                  \
+        for ((node) = first_node(mask);                 \
+                (node) < MAX_NUMNODES;                  \
+                (node) = next_node((node), (mask)))
+#else /* MAX_NUMNODES == 1 */
+#define for_each_node_mask(node, mask)                  \
+        if (!nodes_empty(mask))                         \
+                for ((node) = 0; (node) < 1; (node)++)
+#endif /* MAX_NUMNODES */
+
+/*
+ * The following particular system nodemasks and operations
+ * on them manage all possible and online nodes.
+ */
+
+extern nodemask_t node_online_map;
+extern nodemask_t node_possible_map;
+
+#if MAX_NUMNODES > 1
+#define num_online_nodes()      nodes_weight(node_online_map)
+#define num_possible_nodes()    nodes_weight(node_possible_map)
+#define node_online(node)       node_isset((node), node_online_map)
+#define node_possible(node)     node_isset((node), node_possible_map)
+#else
+#define num_online_nodes()      1
+#define num_possible_nodes()    1
+#define node_online(node)       ((node) == 0)
+#define node_possible(node)     ((node) == 0)
+#endif
+
+#define any_online_node(mask)                   \
+({                                              \
+        int node;                               \
+        for_each_node_mask(node, (mask))        \
+                if (node_online(node))          \
+                        break;                  \
+        node;                                   \
+})
+
+#define node_set_online(node)      set_bit((node), node_online_map.bits)
+#define node_set_offline(node)     clear_bit((node), node_online_map.bits)
+
+#define for_each_node(node)        for_each_node_mask((node), node_possible_map)
+#define for_each_online_node(node) for_each_node_mask((node), node_online_map)
+
+#endif /* __LINUX_NODEMASK_H */
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
new file mode 100644
index 000000000000..9303a003e9ab
--- /dev/null
+++ b/include/linux/notifier.h
@@ -0,0 +1,75 @@
+/*
+ *      Routines to manage notifier chains for passing status changes to any
+ *      interested routines. We need this instead of hard coded call lists so
+ *      that modules can poke their nose into the innards. The network devices
+ *      needed them so here they are for the rest of you.
+ *
+ *                              Alan Cox <Alan.Cox@linux.org>
+ */
+ 
+#ifndef _LINUX_NOTIFIER_H
+#define _LINUX_NOTIFIER_H
+#include <linux/errno.h>
+
+struct notifier_block
+{
+        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
+        struct notifier_block *next;
+        int priority;
+};
+
+
+#ifdef __KERNEL__
+
+extern int notifier_chain_register(struct notifier_block **list, struct notifier_block *n);
+extern int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
+extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
+
+#define NOTIFY_DONE             0x0000          /* Don't care */
+#define NOTIFY_OK               0x0001          /* Suits me */
+#define NOTIFY_STOP_MASK        0x8000          /* Don't call further */
+#define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)       /* Bad/Veto action      */
+/*
+ * Clean way to return from the notifier and stop further calls.
+ */
+#define NOTIFY_STOP             (NOTIFY_OK|NOTIFY_STOP_MASK)
+
+/*
+ *      Declared notifiers so far. I can imagine quite a few more chains
+ *      over time (eg laptop power reset chains, reboot chain (to clean 
+ *      device units up), device [un]mount chain, module load/unload chain,
+ *      low memory chain, screenblank chain (for plug in modular screenblankers) 
+ *      VC switch chains (for loadable kernel svgalib VC switch helpers) etc...
+ */
+ 
+/* netdevice notifier chain */
+#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
+#define NETDEV_DOWN     0x0002
+#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
+                                   detected a hardware crash and restarted
+                                   - we can use this eg to kick tcp sessions
+                                   once done */
+#define NETDEV_CHANGE   0x0004  /* Notify device state change */
+#define NETDEV_REGISTER 0x0005
+#define NETDEV_UNREGISTER       0x0006
+#define NETDEV_CHANGEMTU        0x0007
+#define NETDEV_CHANGEADDR       0x0008
+#define NETDEV_GOING_DOWN       0x0009
+#define NETDEV_CHANGENAME       0x000A
+
+#define SYS_DOWN        0x0001  /* Notify of system down */
+#define SYS_RESTART     SYS_DOWN
+#define SYS_HALT        0x0002  /* Notify of system halt */
+#define SYS_POWER_OFF   0x0003  /* Notify of system power off */
+
+#define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
+
+#define CPU_ONLINE              0x0002 /* CPU (unsigned)v is up */
+#define CPU_UP_PREPARE          0x0003 /* CPU (unsigned)v coming up */
+#define CPU_UP_CANCELED         0x0004 /* CPU (unsigned)v NOT coming up */
+#define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
+#define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
+#define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_NOTIFIER_H */
diff --git a/include/linux/nubus.h b/include/linux/nubus.h
new file mode 100644
index 000000000000..870e66a96286
--- /dev/null
+++ b/include/linux/nubus.h
@@ -0,0 +1,334 @@
+/*
+  nubus.h: various definitions and prototypes for NuBus drivers to use.
+
+  Originally written by Alan Cox.
+
+  Hacked to death by C. Scott Ananian and David Huggins-Daines.
+  
+  Some of the constants in here are from the corresponding
+  NetBSD/OpenBSD header file, by Allen Briggs.  We figured out the
+  rest of them on our own. */
+
+#ifndef LINUX_NUBUS_H
+#define LINUX_NUBUS_H
+
+#ifdef __KERNEL__
+#include <asm/nubus.h>
+#endif
+
+enum nubus_category {
+        NUBUS_CAT_BOARD          = 0x0001,
+        NUBUS_CAT_DISPLAY        = 0x0003,
+        NUBUS_CAT_NETWORK        = 0x0004,
+        NUBUS_CAT_COMMUNICATIONS = 0x0006,
+        NUBUS_CAT_FONT           = 0x0009,
+        NUBUS_CAT_CPU            = 0x000A,
+        /* For lack of a better name */
+        NUBUS_CAT_DUODOCK        = 0x0020
+};
+
+enum nubus_type_network {
+        NUBUS_TYPE_ETHERNET      = 0x0001,
+        NUBUS_TYPE_RS232         = 0x0002
+};
+
+enum nubus_type_display {
+        NUBUS_TYPE_VIDEO         = 0x0001
+};
+
+enum nubus_type_cpu {
+        NUBUS_TYPE_68020         = 0x0003,
+        NUBUS_TYPE_68030         = 0x0004,
+        NUBUS_TYPE_68040         = 0x0005
+};
+
+/* Known <Cat,Type,SW,HW> tuples: (according to TattleTech and Slots)
+ *  68030 motherboards: <10,4,0,24>
+ *  68040 motherboards: <10,5,0,24>
+ *  DuoDock Plus: <32,1,1,2>
+ *
+ *  Toby Frame Buffer card: <3,1,1,1>
+ *  RBV built-in video (IIci): <3,1,1,24>
+ *  Valkyrie built-in video (Q630): <3,1,1,46>
+ *  Macintosh Display Card: <3,1,1,25>
+ *  Sonora built-in video (P460): <3,1,1,34>
+ *  Jet framebuffer (DuoDock Plus): <3,1,1,41>
+ *
+ *  SONIC comm-slot/on-board and DuoDock Ethernet: <4,1,1,272>
+ *  SONIC LC-PDS Ethernet (Dayna, but like Apple 16-bit, sort of): <4,1,1,271>
+ *  Sonic Systems Ethernet A-Series Card: <4,1,268,256>
+ *  Asante MacCon NuBus-A: <4,1,260,256> (alpha-1.0,1.1 revision)
+ *   ROM on the above card: <2,1,0,0>
+ *  Cabletron ethernet card: <4,1,1,265>
+ *  Farallon ethernet card: <4,1,268,256> (identical to Sonic Systems card)
+ *  Kinetics EtherPort IIN: <4,1,259,262>
+ *  API Engineering EtherRun_LCa PDS enet card: <4,1,282,256>
+ *
+ *  Add your devices to the list!  You can obtain the "Slots" utility
+ *  from Apple's FTP site at:
+ *  ftp://dev.apple.com/devworld/Tool_Chest/Devices_-_Hardware/NuBus_Slot_Manager/
+ *
+ *  Alternately, TattleTech can be found at any Info-Mac mirror site.  
+ *  or from its distribution site: ftp://ftp.decismkr.com/dms
+ */
+
+/* DrSW: Uniquely identifies the software interface to a board.  This
+   is usually the one you want to look at when writing a driver.  It's
+   not as useful as you think, though, because as we should know by
+   now (duh), "Apple Compatible" can mean a lot of things... */
+
+/* Add known DrSW values here */
+enum nubus_drsw {
+        /* NUBUS_CAT_DISPLAY */
+        NUBUS_DRSW_APPLE        = 0x0001,
+        NUBUS_DRSW_APPLE_HIRES  = 0x0013, /* MacII HiRes card driver */
+        
+        /* NUBUS_CAT_NETWORK */
+        NUBUS_DRSW_CABLETRON    = 0x0001,
+        NUBUS_DRSW_SONIC_LC     = 0x0001,
+        NUBUS_DRSW_KINETICS     = 0x0103,
+        NUBUS_DRSW_ASANTE       = 0x0104,
+        NUBUS_DRSW_DAYNA        = 0x010b,
+        NUBUS_DRSW_FARALLON     = 0x010c,
+        NUBUS_DRSW_APPLE_SN     = 0x010f,
+        NUBUS_DRSW_DAYNA2       = 0x0115,
+        NUBUS_DRSW_FOCUS        = 0x011a,
+        NUBUS_DRSW_ASANTE_CS    = 0x011d, /* use asante SMC9194 driver */
+        NUBUS_DRSW_DAYNA_LC     = 0x011e,
+
+        /* NUBUS_CAT_CPU */
+        NUBUS_DRSW_NONE         = 0x0000,
+};
+
+/* DrHW: Uniquely identifies the hardware interface to a board (or at
+   least, it should...  some video cards are known to incorrectly
+   identify themselves as Toby cards) */
+
+/* Add known DrHW values here */
+enum nubus_drhw {
+        /* NUBUS_CAT_DISPLAY */
+        NUBUS_DRHW_APPLE_TFB    = 0x0001, /* Toby frame buffer card */
+        NUBUS_DRHW_APPLE_HRVC   = 0x0013, /* Mac II High Res Video card */
+        NUBUS_DRHW_APPLE_RBV1   = 0x0018, /* IIci RBV video */
+        NUBUS_DRHW_APPLE_MDC    = 0x0019, /* Macintosh Display Card */
+        NUBUS_DRHW_APPLE_SONORA = 0x0022, /* Sonora built-in video */
+        NUBUS_DRHW_APPLE_JET    = 0x0029, /* Jet framebuffer (DuoDock) */
+        NUBUS_DRHW_APPLE_VALKYRIE = 0x002e,
+        NUBUS_DRHW_THUNDER24    = 0x02cb, /* SuperMac Thunder/24 */
+        
+        /* NUBUS_CAT_NETWORK */
+        NUBUS_DRHW_INTERLAN     = 0x0100,
+        NUBUS_DRHW_SMC9194      = 0x0101,
+        NUBUS_DRHW_KINETICS     = 0x0106,
+        NUBUS_DRHW_CABLETRON    = 0x0109,
+        NUBUS_DRHW_ASANTE_LC    = 0x010f,
+        NUBUS_DRHW_SONIC        = 0x0110,
+        NUBUS_DRHW_SONIC_NB     = 0x0118,
+        NUBUS_DRHW_SONIC_LC     = 0x0119,
+        
+        /* NUBUS_CAT_COMMUNICATIONS */
+        NUBUS_DRHW_DOVEFAX      = 0x0100,
+};
+
+/* Resource IDs: These are the identifiers for the various weird and
+   wonderful tidbits of information that may or may not reside in the
+   NuBus ROM directory. */
+enum nubus_res_id {
+        NUBUS_RESID_TYPE         = 0x0001,
+        NUBUS_RESID_NAME         = 0x0002,
+        NUBUS_RESID_ICON         = 0x0003,
+        NUBUS_RESID_DRVRDIR      = 0x0004,
+        NUBUS_RESID_LOADREC      = 0x0005,
+        NUBUS_RESID_BOOTREC      = 0x0006,
+        NUBUS_RESID_FLAGS        = 0x0007,
+        NUBUS_RESID_HWDEVID      = 0x0008,
+        NUBUS_RESID_MINOR_BASEOS = 0x000a,
+        NUBUS_RESID_MINOR_LENGTH = 0x000b,
+        NUBUS_RESID_MAJOR_BASEOS = 0x000c,
+        NUBUS_RESID_MAJOR_LENGTH = 0x000d,
+        NUBUS_RESID_CICN         = 0x000f,
+        NUBUS_RESID_ICL8         = 0x0010,
+        NUBUS_RESID_ICL4         = 0x0011,
+};
+
+/* Category-specific resources. */
+enum nubus_board_res_id {
+        NUBUS_RESID_BOARDID      = 0x0020,
+        NUBUS_RESID_PRAMINITDATA = 0x0021,
+        NUBUS_RESID_PRIMARYINIT  = 0x0022,
+        NUBUS_RESID_TIMEOUTCONST = 0x0023,
+        NUBUS_RESID_VENDORINFO   = 0x0024,
+        NUBUS_RESID_BOARDFLAGS   = 0x0025,
+        NUBUS_RESID_SECONDINIT   = 0x0026,
+
+        /* Not sure why Apple put these next two in here */
+        NUBUS_RESID_VIDNAMES     = 0x0041,
+        NUBUS_RESID_VIDMODES     = 0x007e
+};
+
+/* Fields within the vendor info directory */
+enum nubus_vendor_res_id {
+        NUBUS_RESID_VEND_ID     = 0x0001,
+        NUBUS_RESID_VEND_SERIAL = 0x0002,
+        NUBUS_RESID_VEND_REV    = 0x0003,
+        NUBUS_RESID_VEND_PART   = 0x0004,
+        NUBUS_RESID_VEND_DATE   = 0x0005
+};
+
+enum nubus_net_res_id {
+        NUBUS_RESID_MAC_ADDRESS  = 0x0080
+};
+
+enum nubus_cpu_res_id {
+        NUBUS_RESID_MEMINFO      = 0x0081,
+        NUBUS_RESID_ROMINFO      = 0x0082
+};
+
+enum nubus_display_res_id {
+        NUBUS_RESID_GAMMADIR    = 0x0040,
+        NUBUS_RESID_FIRSTMODE   = 0x0080,
+        NUBUS_RESID_SECONDMODE  = 0x0081,
+        NUBUS_RESID_THIRDMODE   = 0x0082,
+        NUBUS_RESID_FOURTHMODE  = 0x0083,
+        NUBUS_RESID_FIFTHMODE   = 0x0084,
+        NUBUS_RESID_SIXTHMODE   = 0x0085
+};
+
+struct nubus_dir
+{
+        unsigned char *base;
+        unsigned char *ptr;
+        int done;
+        int mask;
+};
+
+struct nubus_dirent
+{
+        unsigned char *base;
+        unsigned char type;
+        __u32 data;     /* Actually 24bits used */
+        int mask;
+};
+
+struct nubus_board {
+        struct nubus_board* next;
+        struct nubus_dev* first_dev;
+        
+        /* Only 9-E actually exist, though 0-8 are also theoretically
+           possible, and 0 is a special case which represents the
+           motherboard and onboard peripherals (Ethernet, video) */
+        int slot;
+        /* For slot 0, this is bogus. */
+        char name[64];
+
+        /* Format block */
+        unsigned char* fblock;
+        /* Root directory (does *not* always equal fblock + doffset!) */
+        unsigned char* directory;
+        
+        unsigned long slot_addr;
+        /* Offset to root directory (sometimes) */
+        unsigned long doffset;
+        /* Length over which to compute the crc */
+        unsigned long rom_length;
+        /* Completely useless most of the time */
+        unsigned long crc;
+        unsigned char rev;
+        unsigned char format;
+        unsigned char lanes;
+};
+
+struct nubus_dev {
+        /* Next link in device list */
+        struct nubus_dev* next;
+        /* Directory entry in /proc/bus/nubus */
+        struct proc_dir_entry* procdir;
+
+        /* The functional resource ID of this device */
+        unsigned char resid;
+        /* These are mostly here for convenience; we could always read
+           them from the ROMs if we wanted to */
+        unsigned short category;
+        unsigned short type;
+        unsigned short dr_sw;
+        unsigned short dr_hw;
+        /* This is the device's name rather than the board's.
+           Sometimes they are different.  Usually the board name is
+           more correct. */
+        char name[64];
+        /* MacOS driver (I kid you not) */
+        unsigned char* driver;
+        /* Actually this is an offset */
+        unsigned long iobase;
+        unsigned long iosize;
+        unsigned char flags, hwdevid;
+        
+        /* Functional directory */
+        unsigned char* directory;
+        /* Much of our info comes from here */
+        struct nubus_board* board;
+};
+
+/* This is all NuBus devices (used to find devices later on) */
+extern struct nubus_dev* nubus_devices;
+/* This is all NuBus cards */
+extern struct nubus_board* nubus_boards;
+
+/* Generic NuBus interface functions, modelled after the PCI interface */
+void nubus_scan_bus(void);
+extern void nubus_proc_init(void);
+int get_nubus_list(char *buf);
+int nubus_proc_attach_device(struct nubus_dev *dev);
+int nubus_proc_detach_device(struct nubus_dev *dev);
+/* If we need more precision we can add some more of these */
+struct nubus_dev* nubus_find_device(unsigned short category,
+                                    unsigned short type,
+                                    unsigned short dr_hw,
+                                    unsigned short dr_sw,
+                                    const struct nubus_dev* from);
+struct nubus_dev* nubus_find_type(unsigned short category,
+                                  unsigned short type,
+                                  const struct nubus_dev* from);
+/* Might have more than one device in a slot, you know... */
+struct nubus_dev* nubus_find_slot(unsigned int slot,
+                                  const struct nubus_dev* from);
+
+/* These are somewhat more NuBus-specific.  They all return 0 for
+   success and -1 for failure, as you'd expect. */
+
+/* The root directory which contains the board and functional
+   directories */
+int nubus_get_root_dir(const struct nubus_board* board,
+                       struct nubus_dir* dir);
+/* The board directory */
+int nubus_get_board_dir(const struct nubus_board* board,
+                        struct nubus_dir* dir);
+/* The functional directory */
+int nubus_get_func_dir(const struct nubus_dev* dev,
+                       struct nubus_dir* dir);
+
+/* These work on any directory gotten via the above */
+int nubus_readdir(struct nubus_dir* dir,
+                  struct nubus_dirent* ent);
+int nubus_find_rsrc(struct nubus_dir* dir,
+                    unsigned char rsrc_type,
+                    struct nubus_dirent* ent);
+int nubus_rewinddir(struct nubus_dir* dir);
+
+/* Things to do with directory entries */
+int nubus_get_subdir(const struct nubus_dirent* ent,
+                     struct nubus_dir* dir);
+void nubus_get_rsrc_mem(void* dest,
+                        const struct nubus_dirent *dirent,
+                        int len);
+void nubus_get_rsrc_str(void* dest,
+                        const struct nubus_dirent *dirent,
+                        int maxlen);
+
+/* We'd like to get rid of this eventually.  Only daynaport.c uses it now. */
+static inline void *nubus_slot_addr(int slot)
+{
+        return (void *)(0xF0000000|(slot<<24));
+}
+
+#endif /* LINUX_NUBUS_H */
diff --git a/include/linux/numa.h b/include/linux/numa.h
new file mode 100644
index 000000000000..bd0c8c4e9a95
--- /dev/null
+++ b/include/linux/numa.h
@@ -0,0 +1,16 @@
+#ifndef _LINUX_NUMA_H
+#define _LINUX_NUMA_H
+
+#include <linux/config.h>
+
+#ifdef CONFIG_DISCONTIGMEM
+#include <asm/numnodes.h>
+#endif
+
+#ifndef NODES_SHIFT
+#define NODES_SHIFT     0
+#endif
+
+#define MAX_NUMNODES    (1 << NODES_SHIFT)
+
+#endif /* _LINUX_NUMA_H */
diff --git a/include/linux/nvram.h b/include/linux/nvram.h
new file mode 100644
index 000000000000..b031e41b5e0d
--- /dev/null
+++ b/include/linux/nvram.h
@@ -0,0 +1,27 @@
+#ifndef _LINUX_NVRAM_H
+#define _LINUX_NVRAM_H
+
+#include <linux/ioctl.h>
+
+/* /dev/nvram ioctls */
+#define NVRAM_INIT      _IO('p', 0x40) /* initialize NVRAM and set checksum */
+#define NVRAM_SETCKS    _IO('p', 0x41) /* recalculate checksum */
+
+/* for all current systems, this is where NVRAM starts */
+#define NVRAM_FIRST_BYTE    14
+/* all these functions expect an NVRAM offset, not an absolute */
+#define NVRAM_OFFSET(x)   ((x)-NVRAM_FIRST_BYTE)
+
+#ifdef __KERNEL__
+/* __foo is foo without grabbing the rtc_lock - get it yourself */
+extern unsigned char __nvram_read_byte(int i);
+extern unsigned char nvram_read_byte(int i);
+extern void __nvram_write_byte(unsigned char c, int i);
+extern void nvram_write_byte(unsigned char c, int i);
+extern int __nvram_check_checksum(void);
+extern int nvram_check_checksum(void);
+extern void __nvram_set_checksum(void);
+extern void nvram_set_checksum(void);
+#endif
+
+#endif  /* _LINUX_NVRAM_H */
diff --git a/include/linux/openprom_fs.h b/include/linux/openprom_fs.h
new file mode 100644
index 000000000000..a837aab8217e
--- /dev/null
+++ b/include/linux/openprom_fs.h
@@ -0,0 +1,10 @@
+#ifndef _LINUX_OPENPROM_FS_H
+#define _LINUX_OPENPROM_FS_H
+
+/*
+ * The openprom filesystem constants/structures
+ */
+
+#define OPENPROM_SUPER_MAGIC 0x9fa1
+
+#endif /* _LINUX_OPENPROM_FS_H */
diff --git a/include/linux/oprofile.h b/include/linux/oprofile.h
new file mode 100644
index 000000000000..559c4c38a9c7
--- /dev/null
+++ b/include/linux/oprofile.h
@@ -0,0 +1,119 @@
+/**
+ * @file oprofile.h
+ *
+ * API for machine-specific interrupts to interface
+ * to oprofile.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon <levon@movementarian.org>
+ */
+
+#ifndef OPROFILE_H
+#define OPROFILE_H
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <asm/atomic.h>
+ 
+struct super_block;
+struct dentry;
+struct file_operations;
+struct pt_regs;
+ 
+/* Operations structure to be filled in */
+struct oprofile_operations {
+        /* create any necessary configuration files in the oprofile fs.
+         * Optional. */
+        int (*create_files)(struct super_block * sb, struct dentry * root);
+        /* Do any necessary interrupt setup. Optional. */
+        int (*setup)(void);
+        /* Do any necessary interrupt shutdown. Optional. */
+        void (*shutdown)(void);
+        /* Start delivering interrupts. */
+        int (*start)(void);
+        /* Stop delivering interrupts. */
+        void (*stop)(void);
+        /* Initiate a stack backtrace. Optional. */
+        void (*backtrace)(struct pt_regs * const regs, unsigned int depth);
+        /* CPU identification string. */
+        char * cpu_type;
+};
+
+/**
+ * One-time initialisation. *ops must be set to a filled-in
+ * operations structure. This is called even in timer interrupt
+ * mode so an arch can set a backtrace callback.
+ *
+ * If an error occurs, the fields should be left untouched.
+ */
+int oprofile_arch_init(struct oprofile_operations * ops);
+ 
+/**
+ * One-time exit/cleanup for the arch.
+ */
+void oprofile_arch_exit(void);
+
+/**
+ * Add a sample. This may be called from any context. Pass
+ * smp_processor_id() as cpu.
+ */
+void oprofile_add_sample(struct pt_regs * const regs, unsigned long event);
+
+/* Use this instead when the PC value is not from the regs. Doesn't
+ * backtrace. */
+void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event);
+
+/* add a backtrace entry, to be called from the ->backtrace callback */
+void oprofile_add_trace(unsigned long eip);
+
+
+/**
+ * Create a file of the given name as a child of the given root, with
+ * the specified file operations.
+ */
+int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
+        char const * name, struct file_operations * fops);
+
+int oprofilefs_create_file_perm(struct super_block * sb, struct dentry * root,
+        char const * name, struct file_operations * fops, int perm);
+ 
+/** Create a file for read/write access to an unsigned long. */
+int oprofilefs_create_ulong(struct super_block * sb, struct dentry * root,
+        char const * name, ulong * val);
+ 
+/** Create a file for read-only access to an unsigned long. */
+int oprofilefs_create_ro_ulong(struct super_block * sb, struct dentry * root,
+        char const * name, ulong * val);
+ 
+/** Create a file for read-only access to an atomic_t. */
+int oprofilefs_create_ro_atomic(struct super_block * sb, struct dentry * root,
+        char const * name, atomic_t * val);
+ 
+/** create a directory */
+struct dentry * oprofilefs_mkdir(struct super_block * sb, struct dentry * root,
+        char const * name);
+
+/**
+ * Write the given asciz string to the given user buffer @buf, updating *offset
+ * appropriately. Returns bytes written or -EFAULT.
+ */
+ssize_t oprofilefs_str_to_user(char const * str, char __user * buf, size_t count, loff_t * offset);
+
+/**
+ * Convert an unsigned long value into ASCII and copy it to the user buffer @buf,
+ * updating *offset appropriately. Returns bytes written or -EFAULT.
+ */
+ssize_t oprofilefs_ulong_to_user(unsigned long val, char __user * buf, size_t count, loff_t * offset);
+
+/**
+ * Read an ASCII string for a number from a userspace buffer and fill *val on success.
+ * Returns 0 on success, < 0 on error.
+ */
+int oprofilefs_ulong_from_user(unsigned long * val, char const __user * buf, size_t count);
+
+/** lock for read/write safety */
+extern spinlock_t oprofilefs_lock;
+ 
+#endif /* OPROFILE_H */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
new file mode 100644
index 000000000000..6b74fcf5bb63
--- /dev/null
+++ b/include/linux/page-flags.h
@@ -0,0 +1,324 @@
+/*
+ * Macros for manipulating and testing page->flags
+ */
+
+#ifndef PAGE_FLAGS_H
+#define PAGE_FLAGS_H
+
+#include <linux/percpu.h>
+#include <linux/cache.h>
+#include <asm/pgtable.h>
+
+/*
+ * Various page->flags bits:
+ *
+ * PG_reserved is set for special pages, which can never be swapped out. Some
+ * of them might not even exist (eg empty_bad_page)...
+ *
+ * The PG_private bitflag is set if page->private contains a valid value.
+ *
+ * During disk I/O, PG_locked is used. This bit is set before I/O and
+ * reset when I/O completes. page_waitqueue(page) is a wait queue of all tasks
+ * waiting for the I/O on this page to complete.
+ *
+ * PG_uptodate tells whether the page's contents is valid.  When a read
+ * completes, the page becomes uptodate, unless a disk I/O error happened.
+ *
+ * For choosing which pages to swap out, inode pages carry a PG_referenced bit,
+ * which is set any time the system accesses that page through the (mapping,
+ * index) hash table.  This referenced bit, together with the referenced bit
+ * in the page tables, is used to manipulate page->age and move the page across
+ * the active, inactive_dirty and inactive_clean lists.
+ *
+ * Note that the referenced bit, the page->lru list_head and the active,
+ * inactive_dirty and inactive_clean lists are protected by the
+ * zone->lru_lock, and *NOT* by the usual PG_locked bit!
+ *
+ * PG_error is set to indicate that an I/O error occurred on this page.
+ *
+ * PG_arch_1 is an architecture specific page state bit.  The generic code
+ * guarantees that this bit is cleared for a page when it first is entered into
+ * the page cache.
+ *
+ * PG_highmem pages are not permanently mapped into the kernel virtual address
+ * space, they need to be kmapped separately for doing IO on the pages.  The
+ * struct page (these bits with information) are always mapped into kernel
+ * address space...
+ */
+
+/*
+ * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
+ * locked- and dirty-page accounting.  The top eight bits of page->flags are
+ * used for page->zone, so putting flag bits there doesn't work.
+ */
+#define PG_locked                0      /* Page is locked. Don't touch. */
+#define PG_error                 1
+#define PG_referenced            2
+#define PG_uptodate              3
+
+#define PG_dirty                 4
+#define PG_lru                   5
+#define PG_active                6
+#define PG_slab                  7      /* slab debug (Suparna wants this) */
+
+#define PG_highmem               8
+#define PG_checked               9      /* kill me in 2.5.<early>. */
+#define PG_arch_1               10
+#define PG_reserved             11
+
+#define PG_private              12      /* Has something at ->private */
+#define PG_writeback            13      /* Page is under writeback */
+#define PG_nosave               14      /* Used for system suspend/resume */
+#define PG_compound             15      /* Part of a compound page */
+
+#define PG_swapcache            16      /* Swap page: swp_entry_t in private */
+#define PG_mappedtodisk         17      /* Has blocks allocated on-disk */
+#define PG_reclaim              18      /* To be reclaimed asap */
+#define PG_nosave_free          19      /* Free, should not be written */
+#define PG_uncached             20      /* Page has been mapped as uncached */
+
+/*
+ * Global page accounting.  One instance per CPU.  Only unsigned longs are
+ * allowed.
+ */
+struct page_state {
+        unsigned long nr_dirty;         /* Dirty writeable pages */
+        unsigned long nr_writeback;     /* Pages under writeback */
+        unsigned long nr_unstable;      /* NFS unstable pages */
+        unsigned long nr_page_table_pages;/* Pages used for pagetables */
+        unsigned long nr_mapped;        /* mapped into pagetables */
+        unsigned long nr_slab;          /* In slab */
+#define GET_PAGE_STATE_LAST nr_slab
+
+        /*
+         * The below are zeroed by get_page_state().  Use get_full_page_state()
+         * to add up all these.
+         */
+        unsigned long pgpgin;           /* Disk reads */
+        unsigned long pgpgout;          /* Disk writes */
+        unsigned long pswpin;           /* swap reads */
+        unsigned long pswpout;          /* swap writes */
+        unsigned long pgalloc_high;     /* page allocations */
+
+        unsigned long pgalloc_normal;
+        unsigned long pgalloc_dma;
+        unsigned long pgfree;           /* page freeings */
+        unsigned long pgactivate;       /* pages moved inactive->active */
+        unsigned long pgdeactivate;     /* pages moved active->inactive */
+
+        unsigned long pgfault;          /* faults (major+minor) */
+        unsigned long pgmajfault;       /* faults (major only) */
+        unsigned long pgrefill_high;    /* inspected in refill_inactive_zone */
+        unsigned long pgrefill_normal;
+        unsigned long pgrefill_dma;
+
+        unsigned long pgsteal_high;     /* total highmem pages reclaimed */
+        unsigned long pgsteal_normal;
+        unsigned long pgsteal_dma;
+        unsigned long pgscan_kswapd_high;/* total highmem pages scanned */
+        unsigned long pgscan_kswapd_normal;
+
+        unsigned long pgscan_kswapd_dma;
+        unsigned long pgscan_direct_high;/* total highmem pages scanned */
+        unsigned long pgscan_direct_normal;
+        unsigned long pgscan_direct_dma;
+        unsigned long pginodesteal;     /* pages reclaimed via inode freeing */
+
+        unsigned long slabs_scanned;    /* slab objects scanned */
+        unsigned long kswapd_steal;     /* pages reclaimed by kswapd */
+        unsigned long kswapd_inodesteal;/* reclaimed via kswapd inode freeing */
+        unsigned long pageoutrun;       /* kswapd's calls to page reclaim */
+        unsigned long allocstall;       /* direct reclaim calls */
+
+        unsigned long pgrotated;        /* pages rotated to tail of the LRU */
+};
+
+extern void get_page_state(struct page_state *ret);
+extern void get_full_page_state(struct page_state *ret);
+extern unsigned long __read_page_state(unsigned offset);
+extern void __mod_page_state(unsigned offset, unsigned long delta);
+
+#define read_page_state(member) \
+        __read_page_state(offsetof(struct page_state, member))
+
+#define mod_page_state(member, delta)   \
+        __mod_page_state(offsetof(struct page_state, member), (delta))
+
+#define inc_page_state(member)  mod_page_state(member, 1UL)
+#define dec_page_state(member)  mod_page_state(member, 0UL - 1)
+#define add_page_state(member,delta) mod_page_state(member, (delta))
+#define sub_page_state(member,delta) mod_page_state(member, 0UL - (delta))
+
+#define mod_page_state_zone(zone, member, delta)                                \
+        do {                                                                    \
+                unsigned offset;                                                \
+                if (is_highmem(zone))                                           \
+                        offset = offsetof(struct page_state, member##_high);    \
+                else if (is_normal(zone))                                       \
+                        offset = offsetof(struct page_state, member##_normal);  \
+                else                                                            \
+                        offset = offsetof(struct page_state, member##_dma);     \
+                __mod_page_state(offset, (delta));                              \
+        } while (0)
+
+/*
+ * Manipulation of page state flags
+ */
+#define PageLocked(page)                \
+                test_bit(PG_locked, &(page)->flags)
+#define SetPageLocked(page)             \
+                set_bit(PG_locked, &(page)->flags)
+#define TestSetPageLocked(page)         \
+                test_and_set_bit(PG_locked, &(page)->flags)
+#define ClearPageLocked(page)           \
+                clear_bit(PG_locked, &(page)->flags)
+#define TestClearPageLocked(page)       \
+                test_and_clear_bit(PG_locked, &(page)->flags)
+
+#define PageError(page)         test_bit(PG_error, &(page)->flags)
+#define SetPageError(page)      set_bit(PG_error, &(page)->flags)
+#define ClearPageError(page)    clear_bit(PG_error, &(page)->flags)
+
+#define PageReferenced(page)    test_bit(PG_referenced, &(page)->flags)
+#define SetPageReferenced(page) set_bit(PG_referenced, &(page)->flags)
+#define ClearPageReferenced(page)       clear_bit(PG_referenced, &(page)->flags)
+#define TestClearPageReferenced(page) test_and_clear_bit(PG_referenced, &(page)->flags)
+
+#define PageUptodate(page)      test_bit(PG_uptodate, &(page)->flags)
+#ifndef SetPageUptodate
+#define SetPageUptodate(page)   set_bit(PG_uptodate, &(page)->flags)
+#endif
+#define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags)
+
+#define PageDirty(page)         test_bit(PG_dirty, &(page)->flags)
+#define SetPageDirty(page)      set_bit(PG_dirty, &(page)->flags)
+#define TestSetPageDirty(page)  test_and_set_bit(PG_dirty, &(page)->flags)
+#define ClearPageDirty(page)    clear_bit(PG_dirty, &(page)->flags)
+#define TestClearPageDirty(page) test_and_clear_bit(PG_dirty, &(page)->flags)
+
+#define SetPageLRU(page)        set_bit(PG_lru, &(page)->flags)
+#define PageLRU(page)           test_bit(PG_lru, &(page)->flags)
+#define TestSetPageLRU(page)    test_and_set_bit(PG_lru, &(page)->flags)
+#define TestClearPageLRU(page)  test_and_clear_bit(PG_lru, &(page)->flags)
+
+#define PageActive(page)        test_bit(PG_active, &(page)->flags)
+#define SetPageActive(page)     set_bit(PG_active, &(page)->flags)
+#define ClearPageActive(page)   clear_bit(PG_active, &(page)->flags)
+#define TestClearPageActive(page) test_and_clear_bit(PG_active, &(page)->flags)
+#define TestSetPageActive(page) test_and_set_bit(PG_active, &(page)->flags)
+
+#define PageSlab(page)          test_bit(PG_slab, &(page)->flags)
+#define SetPageSlab(page)       set_bit(PG_slab, &(page)->flags)
+#define ClearPageSlab(page)     clear_bit(PG_slab, &(page)->flags)
+#define TestClearPageSlab(page) test_and_clear_bit(PG_slab, &(page)->flags)
+#define TestSetPageSlab(page)   test_and_set_bit(PG_slab, &(page)->flags)
+
+#ifdef CONFIG_HIGHMEM
+#define PageHighMem(page)       test_bit(PG_highmem, &(page)->flags)
+#else
+#define PageHighMem(page)       0 /* needed to optimize away at compile time */
+#endif
+
+#define PageChecked(page)       test_bit(PG_checked, &(page)->flags)
+#define SetPageChecked(page)    set_bit(PG_checked, &(page)->flags)
+#define ClearPageChecked(page)  clear_bit(PG_checked, &(page)->flags)
+
+#define PageReserved(page)      test_bit(PG_reserved, &(page)->flags)
+#define SetPageReserved(page)   set_bit(PG_reserved, &(page)->flags)
+#define ClearPageReserved(page) clear_bit(PG_reserved, &(page)->flags)
+#define __ClearPageReserved(page)       __clear_bit(PG_reserved, &(page)->flags)
+
+#define SetPagePrivate(page)    set_bit(PG_private, &(page)->flags)
+#define ClearPagePrivate(page)  clear_bit(PG_private, &(page)->flags)
+#define PagePrivate(page)       test_bit(PG_private, &(page)->flags)
+#define __SetPagePrivate(page)  __set_bit(PG_private, &(page)->flags)
+#define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags)
+
+#define PageWriteback(page)     test_bit(PG_writeback, &(page)->flags)
+#define SetPageWriteback(page)                                          \
+        do {                                                            \
+                if (!test_and_set_bit(PG_writeback,                     \
+                                &(page)->flags))                        \
+                        inc_page_state(nr_writeback);                   \
+        } while (0)
+#define TestSetPageWriteback(page)                                      \
+        ({                                                              \
+                int ret;                                                \
+                ret = test_and_set_bit(PG_writeback,                    \
+                                        &(page)->flags);                \
+                if (!ret)                                               \
+                        inc_page_state(nr_writeback);                   \
+                ret;                                                    \
+        })
+#define ClearPageWriteback(page)                                        \
+        do {                                                            \
+                if (test_and_clear_bit(PG_writeback,                    \
+                                &(page)->flags))                        \
+                        dec_page_state(nr_writeback);                   \
+        } while (0)
+#define TestClearPageWriteback(page)                                    \
+        ({                                                              \
+                int ret;                                                \
+                ret = test_and_clear_bit(PG_writeback,                  \
+                                &(page)->flags);                        \
+                if (ret)                                                \
+                        dec_page_state(nr_writeback);                   \
+                ret;                                                    \
+        })
+
+#define PageNosave(page)        test_bit(PG_nosave, &(page)->flags)
+#define SetPageNosave(page)     set_bit(PG_nosave, &(page)->flags)
+#define TestSetPageNosave(page) test_and_set_bit(PG_nosave, &(page)->flags)
+#define ClearPageNosave(page)           clear_bit(PG_nosave, &(page)->flags)
+#define TestClearPageNosave(page)       test_and_clear_bit(PG_nosave, &(page)->flags)
+
+#define PageNosaveFree(page)    test_bit(PG_nosave_free, &(page)->flags)
+#define SetPageNosaveFree(page) set_bit(PG_nosave_free, &(page)->flags)
+#define ClearPageNosaveFree(page)               clear_bit(PG_nosave_free, &(page)->flags)
+
+#define PageMappedToDisk(page)  test_bit(PG_mappedtodisk, &(page)->flags)
+#define SetPageMappedToDisk(page) set_bit(PG_mappedtodisk, &(page)->flags)
+#define ClearPageMappedToDisk(page) clear_bit(PG_mappedtodisk, &(page)->flags)
+
+#define PageReclaim(page)       test_bit(PG_reclaim, &(page)->flags)
+#define SetPageReclaim(page)    set_bit(PG_reclaim, &(page)->flags)
+#define ClearPageReclaim(page)  clear_bit(PG_reclaim, &(page)->flags)
+#define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags)
+
+#ifdef CONFIG_HUGETLB_PAGE
+#define PageCompound(page)      test_bit(PG_compound, &(page)->flags)
+#else
+#define PageCompound(page)      0
+#endif
+#define SetPageCompound(page)   set_bit(PG_compound, &(page)->flags)
+#define ClearPageCompound(page) clear_bit(PG_compound, &(page)->flags)
+
+#ifdef CONFIG_SWAP
+#define PageSwapCache(page)     test_bit(PG_swapcache, &(page)->flags)
+#define SetPageSwapCache(page)  set_bit(PG_swapcache, &(page)->flags)
+#define ClearPageSwapCache(page) clear_bit(PG_swapcache, &(page)->flags)
+#else
+#define PageSwapCache(page)     0
+#endif
+
+#define PageUncached(page)      test_bit(PG_uncached, &(page)->flags)
+#define SetPageUncached(page)   set_bit(PG_uncached, &(page)->flags)
+#define ClearPageUncached(page) clear_bit(PG_uncached, &(page)->flags)
+
+struct page;    /* forward declaration */
+
+int test_clear_page_dirty(struct page *page);
+int test_clear_page_writeback(struct page *page);
+int test_set_page_writeback(struct page *page);
+
+static inline void clear_page_dirty(struct page *page)
+{
+        test_clear_page_dirty(page);
+}
+
+static inline void set_page_writeback(struct page *page)
+{
+        test_set_page_writeback(page);
+}
+
+#endif  /* PAGE_FLAGS_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
new file mode 100644
index 000000000000..0422031161ba
--- /dev/null
+++ b/include/linux/pagemap.h
@@ -0,0 +1,246 @@
+#ifndef _LINUX_PAGEMAP_H
+#define _LINUX_PAGEMAP_H
+
+/*
+ * Copyright 1995 Linus Torvalds
+ */
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/highmem.h>
+#include <linux/compiler.h>
+#include <asm/uaccess.h>
+#include <linux/gfp.h>
+
+/*
+ * Bits in mapping->flags.  The lower __GFP_BITS_SHIFT bits are the page
+ * allocation mode flags.
+ */
+#define AS_EIO          (__GFP_BITS_SHIFT + 0)  /* IO error on async write */
+#define AS_ENOSPC       (__GFP_BITS_SHIFT + 1)  /* ENOSPC on async write */
+
+static inline unsigned int __nocast mapping_gfp_mask(struct address_space * mapping)
+{
+        return mapping->flags & __GFP_BITS_MASK;
+}
+
+/*
+ * This is non-atomic.  Only to be used before the mapping is activated.
+ * Probably needs a barrier...
+ */
+static inline void mapping_set_gfp_mask(struct address_space *m, int mask)
+{
+        m->flags = (m->flags & ~__GFP_BITS_MASK) | mask;
+}
+
+/*
+ * The page cache can done in larger chunks than
+ * one page, because it allows for more efficient
+ * throughput (it can then be mapped into user
+ * space in smaller chunks for same flexibility).
+ *
+ * Or rather, it _will_ be done in larger chunks.
+ */
+#define PAGE_CACHE_SHIFT        PAGE_SHIFT
+#define PAGE_CACHE_SIZE         PAGE_SIZE
+#define PAGE_CACHE_MASK         PAGE_MASK
+#define PAGE_CACHE_ALIGN(addr)  (((addr)+PAGE_CACHE_SIZE-1)&PAGE_CACHE_MASK)
+
+#define page_cache_get(page)            get_page(page)
+#define page_cache_release(page)        put_page(page)
+void release_pages(struct page **pages, int nr, int cold);
+
+static inline struct page *page_cache_alloc(struct address_space *x)
+{
+        return alloc_pages(mapping_gfp_mask(x), 0);
+}
+
+static inline struct page *page_cache_alloc_cold(struct address_space *x)
+{
+        return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD, 0);
+}
+
+typedef int filler_t(void *, struct page *);
+
+extern struct page * find_get_page(struct address_space *mapping,
+                                unsigned long index);
+extern struct page * find_lock_page(struct address_space *mapping,
+                                unsigned long index);
+extern struct page * find_trylock_page(struct address_space *mapping,
+                                unsigned long index);
+extern struct page * find_or_create_page(struct address_space *mapping,
+                                unsigned long index, unsigned int gfp_mask);
+unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
+                        unsigned int nr_pages, struct page **pages);
+unsigned find_get_pages_tag(struct address_space *mapping, pgoff_t *index,
+                        int tag, unsigned int nr_pages, struct page **pages);
+
+/*
+ * Returns locked page at given index in given cache, creating it if needed.
+ */
+static inline struct page *grab_cache_page(struct address_space *mapping, unsigned long index)
+{
+        return find_or_create_page(mapping, index, mapping_gfp_mask(mapping));
+}
+
+extern struct page * grab_cache_page_nowait(struct address_space *mapping,
+                                unsigned long index);
+extern struct page * read_cache_page(struct address_space *mapping,
+                                unsigned long index, filler_t *filler,
+                                void *data);
+extern int read_cache_pages(struct address_space *mapping,
+                struct list_head *pages, filler_t *filler, void *data);
+
+int add_to_page_cache(struct page *page, struct address_space *mapping,
+                                unsigned long index, int gfp_mask);
+int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
+                                unsigned long index, int gfp_mask);
+extern void remove_from_page_cache(struct page *page);
+extern void __remove_from_page_cache(struct page *page);
+
+extern atomic_t nr_pagecache;
+
+#ifdef CONFIG_SMP
+
+#define PAGECACHE_ACCT_THRESHOLD        max(16, NR_CPUS * 2)
+DECLARE_PER_CPU(long, nr_pagecache_local);
+
+/*
+ * pagecache_acct implements approximate accounting for pagecache.
+ * vm_enough_memory() do not need high accuracy. Writers will keep
+ * an offset in their per-cpu arena and will spill that into the
+ * global count whenever the absolute value of the local count
+ * exceeds the counter's threshold.
+ *
+ * MUST be protected from preemption.
+ * current protection is mapping->page_lock.
+ */
+static inline void pagecache_acct(int count)
+{
+        long *local;
+
+        local = &__get_cpu_var(nr_pagecache_local);
+        *local += count;
+        if (*local > PAGECACHE_ACCT_THRESHOLD || *local < -PAGECACHE_ACCT_THRESHOLD) {
+                atomic_add(*local, &nr_pagecache);
+                *local = 0;
+        }
+}
+
+#else
+
+static inline void pagecache_acct(int count)
+{
+        atomic_add(count, &nr_pagecache);
+}
+#endif
+
+static inline unsigned long get_page_cache_size(void)
+{
+        int ret = atomic_read(&nr_pagecache);
+        if (unlikely(ret < 0))
+                ret = 0;
+        return ret;
+}
+
+/*
+ * Return byte-offset into filesystem object for page.
+ */
+static inline loff_t page_offset(struct page *page)
+{
+        return ((loff_t)page->index) << PAGE_CACHE_SHIFT;
+}
+
+static inline pgoff_t linear_page_index(struct vm_area_struct *vma,
+                                        unsigned long address)
+{
+        pgoff_t pgoff = (address - vma->vm_start) >> PAGE_SHIFT;
+        pgoff += vma->vm_pgoff;
+        return pgoff >> (PAGE_CACHE_SHIFT - PAGE_SHIFT);
+}
+
+extern void FASTCALL(__lock_page(struct page *page));
+extern void FASTCALL(unlock_page(struct page *page));
+
+static inline void lock_page(struct page *page)
+{
+        might_sleep();
+        if (TestSetPageLocked(page))
+                __lock_page(page);
+}
+        
+/*
+ * This is exported only for wait_on_page_locked/wait_on_page_writeback.
+ * Never use this directly!
+ */
+extern void FASTCALL(wait_on_page_bit(struct page *page, int bit_nr));
+
+/* 
+ * Wait for a page to be unlocked.
+ *
+ * This must be called with the caller "holding" the page,
+ * ie with increased "page->count" so that the page won't
+ * go away during the wait..
+ */
+static inline void wait_on_page_locked(struct page *page)
+{
+        if (PageLocked(page))
+                wait_on_page_bit(page, PG_locked);
+}
+
+/* 
+ * Wait for a page to complete writeback
+ */
+static inline void wait_on_page_writeback(struct page *page)
+{
+        if (PageWriteback(page))
+                wait_on_page_bit(page, PG_writeback);
+}
+
+extern void end_page_writeback(struct page *page);
+
+/*
+ * Fault a userspace page into pagetables.  Return non-zero on a fault.
+ *
+ * This assumes that two userspace pages are always sufficient.  That's
+ * not true if PAGE_CACHE_SIZE > PAGE_SIZE.
+ */
+static inline int fault_in_pages_writeable(char __user *uaddr, int size)
+{
+        int ret;
+
+        /*
+         * Writing zeroes into userspace here is OK, because we know that if
+         * the zero gets there, we'll be overwriting it.
+         */
+        ret = __put_user(0, uaddr);
+        if (ret == 0) {
+                char __user *end = uaddr + size - 1;
+
+                /*
+                 * If the page was already mapped, this will get a cache miss
+                 * for sure, so try to avoid doing it.
+                 */
+                if (((unsigned long)uaddr & PAGE_MASK) !=
+                                ((unsigned long)end & PAGE_MASK))
+                        ret = __put_user(0, end);
+        }
+        return ret;
+}
+
+static inline void fault_in_pages_readable(const char __user *uaddr, int size)
+{
+        volatile char c;
+        int ret;
+
+        ret = __get_user(c, uaddr);
+        if (ret == 0) {
+                const char __user *end = uaddr + size - 1;
+
+                if (((unsigned long)uaddr & PAGE_MASK) !=
+                                ((unsigned long)end & PAGE_MASK))
+                        __get_user(c, end);
+        }
+}
+
+#endif /* _LINUX_PAGEMAP_H */
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h
new file mode 100644
index 000000000000..def32c5715be
--- /dev/null
+++ b/include/linux/pagevec.h
@@ -0,0 +1,85 @@
+/*
+ * include/linux/pagevec.h
+ *
+ * In many places it is efficient to batch an operation up against multiple
+ * pages.  A pagevec is a multipage container which is used for that.
+ */
+
+/* 14 pointers + two long's align the pagevec structure to a power of two */
+#define PAGEVEC_SIZE    14
+
+struct page;
+struct address_space;
+
+struct pagevec {
+        unsigned long nr;
+        unsigned long cold;
+        struct page *pages[PAGEVEC_SIZE];
+};
+
+void __pagevec_release(struct pagevec *pvec);
+void __pagevec_release_nonlru(struct pagevec *pvec);
+void __pagevec_free(struct pagevec *pvec);
+void __pagevec_lru_add(struct pagevec *pvec);
+void __pagevec_lru_add_active(struct pagevec *pvec);
+void pagevec_strip(struct pagevec *pvec);
+unsigned pagevec_lookup(struct pagevec *pvec, struct address_space *mapping,
+                pgoff_t start, unsigned nr_pages);
+unsigned pagevec_lookup_tag(struct pagevec *pvec,
+                struct address_space *mapping, pgoff_t *index, int tag,
+                unsigned nr_pages);
+
+static inline void pagevec_init(struct pagevec *pvec, int cold)
+{
+        pvec->nr = 0;
+        pvec->cold = cold;
+}
+
+static inline void pagevec_reinit(struct pagevec *pvec)
+{
+        pvec->nr = 0;
+}
+
+static inline unsigned pagevec_count(struct pagevec *pvec)
+{
+        return pvec->nr;
+}
+
+static inline unsigned pagevec_space(struct pagevec *pvec)
+{
+        return PAGEVEC_SIZE - pvec->nr;
+}
+
+/*
+ * Add a page to a pagevec.  Returns the number of slots still available.
+ */
+static inline unsigned pagevec_add(struct pagevec *pvec, struct page *page)
+{
+        pvec->pages[pvec->nr++] = page;
+        return pagevec_space(pvec);
+}
+
+
+static inline void pagevec_release(struct pagevec *pvec)
+{
+        if (pagevec_count(pvec))
+                __pagevec_release(pvec);
+}
+
+static inline void pagevec_release_nonlru(struct pagevec *pvec)
+{
+        if (pagevec_count(pvec))
+                __pagevec_release_nonlru(pvec);
+}
+
+static inline void pagevec_free(struct pagevec *pvec)
+{
+        if (pagevec_count(pvec))
+                __pagevec_free(pvec);
+}
+
+static inline void pagevec_lru_add(struct pagevec *pvec)
+{
+        if (pagevec_count(pvec))
+                __pagevec_lru_add(pvec);
+}
diff --git a/include/linux/param.h b/include/linux/param.h
new file mode 100644
index 000000000000..092e92f67b50
--- /dev/null
+++ b/include/linux/param.h
@@ -0,0 +1,6 @@
+#ifndef _LINUX_PARAM_H
+#define _LINUX_PARAM_H
+
+#include <asm/param.h>
+
+#endif
diff --git a/include/linux/parport.h b/include/linux/parport.h
new file mode 100644
index 000000000000..d2a4d9e1e6d1
--- /dev/null
+++ b/include/linux/parport.h
@@ -0,0 +1,552 @@
+/* $Id: parport.h,v 1.1 1998/05/17 10:57:52 andrea Exp andrea $ */
+
+/*
+ * Any part of this program may be used in documents licensed under
+ * the GNU Free Documentation License, Version 1.1 or any later version
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _PARPORT_H_
+#define _PARPORT_H_
+
+/* Start off with user-visible constants */
+
+/* Maximum of 16 ports per machine */
+#define PARPORT_MAX  16
+
+/* Magic numbers */
+#define PARPORT_IRQ_NONE  -1
+#define PARPORT_DMA_NONE  -1
+#define PARPORT_IRQ_AUTO  -2
+#define PARPORT_DMA_AUTO  -2
+#define PARPORT_DMA_NOFIFO -3
+#define PARPORT_DISABLE   -2
+#define PARPORT_IRQ_PROBEONLY -3
+#define PARPORT_IOHI_AUTO -1
+
+#define PARPORT_CONTROL_STROBE    0x1
+#define PARPORT_CONTROL_AUTOFD    0x2
+#define PARPORT_CONTROL_INIT      0x4
+#define PARPORT_CONTROL_SELECT    0x8
+
+#define PARPORT_STATUS_ERROR      0x8
+#define PARPORT_STATUS_SELECT     0x10
+#define PARPORT_STATUS_PAPEROUT   0x20
+#define PARPORT_STATUS_ACK        0x40
+#define PARPORT_STATUS_BUSY       0x80
+
+/* Type classes for Plug-and-Play probe.  */
+typedef enum {
+        PARPORT_CLASS_LEGACY = 0,       /* Non-IEEE1284 device */
+        PARPORT_CLASS_PRINTER,
+        PARPORT_CLASS_MODEM,
+        PARPORT_CLASS_NET,
+        PARPORT_CLASS_HDC,              /* Hard disk controller */
+        PARPORT_CLASS_PCMCIA,
+        PARPORT_CLASS_MEDIA,            /* Multimedia device */
+        PARPORT_CLASS_FDC,              /* Floppy disk controller */
+        PARPORT_CLASS_PORTS,
+        PARPORT_CLASS_SCANNER,
+        PARPORT_CLASS_DIGCAM,
+        PARPORT_CLASS_OTHER,            /* Anything else */
+        PARPORT_CLASS_UNSPEC,           /* No CLS field in ID */
+        PARPORT_CLASS_SCSIADAPTER
+} parport_device_class;
+
+/* The "modes" entry in parport is a bit field representing the
+   capabilities of the hardware. */
+#define PARPORT_MODE_PCSPP      (1<<0) /* IBM PC registers available. */
+#define PARPORT_MODE_TRISTATE   (1<<1) /* Can tristate. */
+#define PARPORT_MODE_EPP        (1<<2) /* Hardware EPP. */
+#define PARPORT_MODE_ECP        (1<<3) /* Hardware ECP. */
+#define PARPORT_MODE_COMPAT     (1<<4) /* Hardware 'printer protocol'. */
+#define PARPORT_MODE_DMA        (1<<5) /* Hardware can DMA. */
+#define PARPORT_MODE_SAFEININT  (1<<6) /* SPP registers accessible in IRQ. */
+
+/* IEEE1284 modes: 
+   Nibble mode, byte mode, ECP, ECPRLE and EPP are their own
+   'extensibility request' values.  Others are special.
+   'Real' ECP modes must have the IEEE1284_MODE_ECP bit set.  */
+#define IEEE1284_MODE_NIBBLE             0
+#define IEEE1284_MODE_BYTE              (1<<0)
+#define IEEE1284_MODE_COMPAT            (1<<8)
+#define IEEE1284_MODE_BECP              (1<<9) /* Bounded ECP mode */
+#define IEEE1284_MODE_ECP               (1<<4)
+#define IEEE1284_MODE_ECPRLE            (IEEE1284_MODE_ECP | (1<<5))
+#define IEEE1284_MODE_ECPSWE            (1<<10) /* Software-emulated */
+#define IEEE1284_MODE_EPP               (1<<6)
+#define IEEE1284_MODE_EPPSL             (1<<11) /* EPP 1.7 */
+#define IEEE1284_MODE_EPPSWE            (1<<12) /* Software-emulated */
+#define IEEE1284_DEVICEID               (1<<2)  /* This is a flag */
+#define IEEE1284_EXT_LINK               (1<<14) /* This flag causes the
+                                                 * extensibility link to
+                                                 * be requested, using
+                                                 * bits 0-6. */
+
+/* For the benefit of parport_read/write, you can use these with
+ * parport_negotiate to use address operations.  They have no effect
+ * other than to make parport_read/write use address transfers. */
+#define IEEE1284_ADDR                   (1<<13) /* This is a flag */
+#define IEEE1284_DATA                    0      /* So is this */
+
+/* Flags for block transfer operations. */
+#define PARPORT_EPP_FAST                (1<<0) /* Unreliable counts. */
+#define PARPORT_W91284PIC               (1<<1) /* have a Warp9 w91284pic in the device */
+
+/* The rest is for the kernel only */
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/jiffies.h>
+#include <linux/proc_fs.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include <asm/system.h>
+#include <asm/ptrace.h>
+#include <asm/semaphore.h>
+
+/* Define this later. */
+struct parport;
+struct pardevice;
+
+struct pc_parport_state {
+        unsigned int ctr;
+        unsigned int ecr;
+};
+
+struct ax_parport_state {
+        unsigned int ctr;
+        unsigned int ecr;
+        unsigned int dcsr;
+};
+
+/* used by both parport_amiga and parport_mfc3 */
+struct amiga_parport_state {
+       unsigned char data;     /* ciaa.prb */
+       unsigned char datadir;  /* ciaa.ddrb */
+       unsigned char status;   /* ciab.pra & 7 */
+       unsigned char statusdir;/* ciab.ddrb & 7 */
+};
+
+struct parport_state {
+        union {
+                struct pc_parport_state pc;
+                /* ARC has no state. */
+                struct ax_parport_state ax;
+                struct amiga_parport_state amiga;
+                /* Atari has not state. */
+                void *misc; 
+        } u;
+};
+
+struct parport_operations {
+        /* IBM PC-style virtual registers. */
+        void (*write_data)(struct parport *, unsigned char);
+        unsigned char (*read_data)(struct parport *);
+
+        void (*write_control)(struct parport *, unsigned char);
+        unsigned char (*read_control)(struct parport *);
+        unsigned char (*frob_control)(struct parport *, unsigned char mask,
+                                      unsigned char val);
+
+        unsigned char (*read_status)(struct parport *);
+
+        /* IRQs. */
+        void (*enable_irq)(struct parport *);
+        void (*disable_irq)(struct parport *);
+
+        /* Data direction. */
+        void (*data_forward) (struct parport *);
+        void (*data_reverse) (struct parport *);
+
+        /* For core parport code. */
+        void (*init_state)(struct pardevice *, struct parport_state *);
+        void (*save_state)(struct parport *, struct parport_state *);
+        void (*restore_state)(struct parport *, struct parport_state *);
+
+        /* Block read/write */
+        size_t (*epp_write_data) (struct parport *port, const void *buf,
+                                  size_t len, int flags);
+        size_t (*epp_read_data) (struct parport *port, void *buf, size_t len,
+                                 int flags);
+        size_t (*epp_write_addr) (struct parport *port, const void *buf,
+                                  size_t len, int flags);
+        size_t (*epp_read_addr) (struct parport *port, void *buf, size_t len,
+                                 int flags);
+
+        size_t (*ecp_write_data) (struct parport *port, const void *buf,
+                                  size_t len, int flags);
+        size_t (*ecp_read_data) (struct parport *port, void *buf, size_t len,
+                                 int flags);
+        size_t (*ecp_write_addr) (struct parport *port, const void *buf,
+                                  size_t len, int flags);
+
+        size_t (*compat_write_data) (struct parport *port, const void *buf,
+                                     size_t len, int flags);
+        size_t (*nibble_read_data) (struct parport *port, void *buf,
+                                    size_t len, int flags);
+        size_t (*byte_read_data) (struct parport *port, void *buf,
+                                  size_t len, int flags);
+        struct module *owner;
+};
+
+struct parport_device_info {
+        parport_device_class class;
+        const char *class_name;
+        const char *mfr;
+        const char *model;
+        const char *cmdset;
+        const char *description;
+};
+
+/* Each device can have two callback functions:
+ *  1) a preemption function, called by the resource manager to request
+ *     that the driver relinquish control of the port.  The driver should
+ *     return zero if it agrees to release the port, and nonzero if it 
+ *     refuses.  Do not call parport_release() - the kernel will do this
+ *     implicitly.
+ *
+ *  2) a wake-up function, called by the resource manager to tell drivers
+ *     that the port is available to be claimed.  If a driver wants to use
+ *     the port, it should call parport_claim() here.
+ */
+
+/* A parallel port device */
+struct pardevice {
+        const char *name;
+        struct parport *port;
+        int daisy;
+        int (*preempt)(void *);
+        void (*wakeup)(void *);
+        void *private;
+        void (*irq_func)(int, void *, struct pt_regs *);
+        unsigned int flags;
+        struct pardevice *next;
+        struct pardevice *prev;
+        struct parport_state *state;     /* saved status over preemption */
+        wait_queue_head_t wait_q;
+        unsigned long int time;
+        unsigned long int timeslice;
+        volatile long int timeout;
+        unsigned long waiting;           /* long req'd for set_bit --RR */
+        struct pardevice *waitprev;
+        struct pardevice *waitnext;
+        void * sysctl_table;
+};
+
+/* IEEE1284 information */
+
+/* IEEE1284 phases */
+enum ieee1284_phase {
+        IEEE1284_PH_FWD_DATA,
+        IEEE1284_PH_FWD_IDLE,
+        IEEE1284_PH_TERMINATE,
+        IEEE1284_PH_NEGOTIATION,
+        IEEE1284_PH_HBUSY_DNA,
+        IEEE1284_PH_REV_IDLE,
+        IEEE1284_PH_HBUSY_DAVAIL,
+        IEEE1284_PH_REV_DATA,
+        IEEE1284_PH_ECP_SETUP,
+        IEEE1284_PH_ECP_FWD_TO_REV,
+        IEEE1284_PH_ECP_REV_TO_FWD,
+        IEEE1284_PH_ECP_DIR_UNKNOWN,
+};
+struct ieee1284_info {
+        int mode;
+        volatile enum ieee1284_phase phase;
+        struct semaphore irq;
+};
+
+/* A parallel port */
+struct parport {
+        unsigned long base;     /* base address */
+        unsigned long base_hi;  /* base address (hi - ECR) */
+        unsigned int size;      /* IO extent */
+        const char *name;
+        unsigned int modes;
+        int irq;                /* interrupt (or -1 for none) */
+        int dma;
+        int muxport;            /* which muxport (if any) this is */
+        int portnum;            /* which physical parallel port (not mux) */
+
+        struct parport *physport;
+                                /* If this is a non-default mux
+                                   parport, i.e. we're a clone of a real
+                                   physical port, this is a pointer to that
+                                   port. The locking is only done in the
+                                   real port.  For a clone port, the
+                                   following structure members are
+                                   meaningless: devices, cad, muxsel,
+                                   waithead, waittail, flags, pdir,
+                                   ieee1284, *_lock.
+
+                                   It this is a default mux parport, or
+                                   there is no mux involved, this points to
+                                   ourself. */
+
+        struct pardevice *devices;
+        struct pardevice *cad;  /* port owner */
+        int daisy;              /* currently selected daisy addr */
+        int muxsel;             /* currently selected mux port */
+
+        struct pardevice *waithead;
+        struct pardevice *waittail;
+        
+        struct list_head list;
+        unsigned int flags;
+
+        void *sysctl_table;
+        struct parport_device_info probe_info[5]; /* 0-3 + non-IEEE1284.3 */
+        struct ieee1284_info ieee1284;
+
+        struct parport_operations *ops;
+        void *private_data;     /* for lowlevel driver */
+
+        int number;             /* port index - the `n' in `parportn' */
+        spinlock_t pardevice_lock;
+        spinlock_t waitlist_lock;
+        rwlock_t cad_lock;
+
+        int spintime;
+        atomic_t ref_count;
+
+        struct list_head full_list;
+        struct parport *slaves[3];
+};
+
+#define DEFAULT_SPIN_TIME 500 /* us */
+
+struct parport_driver {
+        const char *name;
+        void (*attach) (struct parport *);
+        void (*detach) (struct parport *);
+        struct list_head list;
+};
+
+/* parport_register_port registers a new parallel port at the given
+   address (if one does not already exist) and returns a pointer to it.
+   This entails claiming the I/O region, IRQ and DMA.  NULL is returned
+   if initialisation fails. */
+struct parport *parport_register_port(unsigned long base, int irq, int dma,
+                                      struct parport_operations *ops);
+
+/* Once a registered port is ready for high-level drivers to use, the
+   low-level driver that registered it should announce it.  This will
+   call the high-level drivers' attach() functions (after things like
+   determining the IEEE 1284.3 topology of the port and collecting
+   DeviceIDs). */
+void parport_announce_port (struct parport *port);
+
+/* Unregister a port. */
+extern void parport_remove_port(struct parport *port);
+
+/* Register a new high-level driver. */
+extern int parport_register_driver (struct parport_driver *);
+
+/* Unregister a high-level driver. */
+extern void parport_unregister_driver (struct parport_driver *);
+
+/* If parport_register_driver doesn't fit your needs, perhaps
+ * parport_find_xxx does. */
+extern struct parport *parport_find_number (int);
+extern struct parport *parport_find_base (unsigned long);
+
+/* Reference counting for ports. */
+extern struct parport *parport_get_port (struct parport *);
+extern void parport_put_port (struct parport *);
+
+/* parport_register_device declares that a device is connected to a
+   port, and tells the kernel all it needs to know.
+   - pf is the preemption function (may be NULL for no callback)
+   - kf is the wake-up function (may be NULL for no callback)
+   - irq_func is the interrupt handler (may be NULL for no interrupts)
+   - handle is a user pointer that gets handed to callback functions.  */
+struct pardevice *parport_register_device(struct parport *port, 
+                          const char *name,
+                          int (*pf)(void *), void (*kf)(void *),
+                          void (*irq_func)(int, void *, struct pt_regs *), 
+                          int flags, void *handle);
+
+/* parport_unregister unlinks a device from the chain. */
+extern void parport_unregister_device(struct pardevice *dev);
+
+/* parport_claim tries to gain ownership of the port for a particular
+   driver.  This may fail (return non-zero) if another driver is busy.
+   If this driver has registered an interrupt handler, it will be
+   enabled.  */
+extern int parport_claim(struct pardevice *dev);
+
+/* parport_claim_or_block is the same, but sleeps if the port cannot
+   be claimed.  Return value is 1 if it slept, 0 normally and -errno
+   on error.  */
+extern int parport_claim_or_block(struct pardevice *dev);
+
+/* parport_release reverses a previous parport_claim.  This can never
+   fail, though the effects are undefined (except that they are bad)
+   if you didn't previously own the port.  Once you have released the
+   port you should make sure that neither your code nor the hardware
+   on the port tries to initiate any communication without first
+   re-claiming the port.  If you mess with the port state (enabling
+   ECP for example) you should clean up before releasing the port. */
+
+extern void parport_release(struct pardevice *dev);
+
+/**
+ * parport_yield - relinquish a parallel port temporarily
+ * @dev: a device on the parallel port
+ *
+ * This function relinquishes the port if it would be helpful to other
+ * drivers to do so.  Afterwards it tries to reclaim the port using
+ * parport_claim(), and the return value is the same as for
+ * parport_claim().  If it fails, the port is left unclaimed and it is
+ * the driver's responsibility to reclaim the port.
+ *
+ * The parport_yield() and parport_yield_blocking() functions are for
+ * marking points in the driver at which other drivers may claim the
+ * port and use their devices.  Yielding the port is similar to
+ * releasing it and reclaiming it, but is more efficient because no
+ * action is taken if there are no other devices needing the port.  In
+ * fact, nothing is done even if there are other devices waiting but
+ * the current device is still within its "timeslice".  The default
+ * timeslice is half a second, but it can be adjusted via the /proc
+ * interface.
+ **/
+static __inline__ int parport_yield(struct pardevice *dev)
+{
+        unsigned long int timeslip = (jiffies - dev->time);
+        if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
+                return 0;
+        parport_release(dev);
+        return parport_claim(dev);
+}
+
+/**
+ * parport_yield_blocking - relinquish a parallel port temporarily
+ * @dev: a device on the parallel port
+ *
+ * This function relinquishes the port if it would be helpful to other
+ * drivers to do so.  Afterwards it tries to reclaim the port using
+ * parport_claim_or_block(), and the return value is the same as for
+ * parport_claim_or_block().
+ **/
+static __inline__ int parport_yield_blocking(struct pardevice *dev)
+{
+        unsigned long int timeslip = (jiffies - dev->time);
+        if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
+                return 0;
+        parport_release(dev);
+        return parport_claim_or_block(dev);
+}
+
+/* Flags used to identify what a device does. */
+#define PARPORT_DEV_TRAN                0       /* WARNING !! DEPRECATED !! */
+#define PARPORT_DEV_LURK                (1<<0)  /* WARNING !! DEPRECATED !! */
+#define PARPORT_DEV_EXCL                (1<<1)  /* Need exclusive access. */
+
+#define PARPORT_FLAG_EXCL               (1<<1)  /* EXCL driver registered. */
+
+/* IEEE1284 functions */
+extern void parport_ieee1284_interrupt (int, void *, struct pt_regs *);
+extern int parport_negotiate (struct parport *, int mode);
+extern ssize_t parport_write (struct parport *, const void *buf, size_t len);
+extern ssize_t parport_read (struct parport *, void *buf, size_t len);
+
+#define PARPORT_INACTIVITY_O_NONBLOCK 1
+extern long parport_set_timeout (struct pardevice *, long inactivity);
+
+extern int parport_wait_event (struct parport *, long timeout);
+extern int parport_wait_peripheral (struct parport *port,
+                                    unsigned char mask,
+                                    unsigned char val);
+extern int parport_poll_peripheral (struct parport *port,
+                                    unsigned char mask,
+                                    unsigned char val,
+                                    int usec);
+
+/* For architectural drivers */
+extern size_t parport_ieee1284_write_compat (struct parport *,
+                                             const void *, size_t, int);
+extern size_t parport_ieee1284_read_nibble (struct parport *,
+                                            void *, size_t, int);
+extern size_t parport_ieee1284_read_byte (struct parport *,
+                                          void *, size_t, int);
+extern size_t parport_ieee1284_ecp_read_data (struct parport *,
+                                              void *, size_t, int);
+extern size_t parport_ieee1284_ecp_write_data (struct parport *,
+                                               const void *, size_t, int);
+extern size_t parport_ieee1284_ecp_write_addr (struct parport *,
+                                               const void *, size_t, int);
+extern size_t parport_ieee1284_epp_write_data (struct parport *,
+                                               const void *, size_t, int);
+extern size_t parport_ieee1284_epp_read_data (struct parport *,
+                                              void *, size_t, int);
+extern size_t parport_ieee1284_epp_write_addr (struct parport *,
+                                               const void *, size_t, int);
+extern size_t parport_ieee1284_epp_read_addr (struct parport *,
+                                              void *, size_t, int);
+
+/* IEEE1284.3 functions */
+extern int parport_daisy_init (struct parport *port);
+extern void parport_daisy_fini (struct parport *port);
+extern struct pardevice *parport_open (int devnum, const char *name,
+                                       int (*pf) (void *),
+                                       void (*kf) (void *),
+                                       void (*irqf) (int, void *,
+                                                     struct pt_regs *),
+                                       int flags, void *handle);
+extern void parport_close (struct pardevice *dev);
+extern ssize_t parport_device_id (int devnum, char *buffer, size_t len);
+extern int parport_device_num (int parport, int mux, int daisy);
+extern void parport_daisy_deselect_all (struct parport *port);
+extern int parport_daisy_select (struct parport *port, int daisy, int mode);
+
+/* Lowlevel drivers _can_ call this support function to handle irqs.  */
+static __inline__ void parport_generic_irq(int irq, struct parport *port,
+                                           struct pt_regs *regs)
+{
+        parport_ieee1284_interrupt (irq, port, regs);
+        read_lock(&port->cad_lock);
+        if (port->cad && port->cad->irq_func)
+                port->cad->irq_func(irq, port->cad->private, regs);
+        read_unlock(&port->cad_lock);
+}
+
+/* Prototypes from parport_procfs */
+extern int parport_proc_register(struct parport *pp);
+extern int parport_proc_unregister(struct parport *pp);
+extern int parport_device_proc_register(struct pardevice *device);
+extern int parport_device_proc_unregister(struct pardevice *device);
+
+/* If PC hardware is the only type supported, we can optimise a bit.  */
+#if !defined(CONFIG_PARPORT_NOT_PC)
+
+#include <linux/parport_pc.h>
+#define parport_write_data(p,x)            parport_pc_write_data(p,x)
+#define parport_read_data(p)               parport_pc_read_data(p)
+#define parport_write_control(p,x)         parport_pc_write_control(p,x)
+#define parport_read_control(p)            parport_pc_read_control(p)
+#define parport_frob_control(p,m,v)        parport_pc_frob_control(p,m,v)
+#define parport_read_status(p)             parport_pc_read_status(p)
+#define parport_enable_irq(p)              parport_pc_enable_irq(p)
+#define parport_disable_irq(p)             parport_pc_disable_irq(p)
+#define parport_data_forward(p)            parport_pc_data_forward(p)
+#define parport_data_reverse(p)            parport_pc_data_reverse(p)
+
+#else  /*  !CONFIG_PARPORT_NOT_PC  */
+
+/* Generic operations vector through the dispatch table. */
+#define parport_write_data(p,x)            (p)->ops->write_data(p,x)
+#define parport_read_data(p)               (p)->ops->read_data(p)
+#define parport_write_control(p,x)         (p)->ops->write_control(p,x)
+#define parport_read_control(p)            (p)->ops->read_control(p)
+#define parport_frob_control(p,m,v)        (p)->ops->frob_control(p,m,v)
+#define parport_read_status(p)             (p)->ops->read_status(p)
+#define parport_enable_irq(p)              (p)->ops->enable_irq(p)
+#define parport_disable_irq(p)             (p)->ops->disable_irq(p)
+#define parport_data_forward(p)            (p)->ops->data_forward(p)
+#define parport_data_reverse(p)            (p)->ops->data_reverse(p)
+
+#endif /*  !CONFIG_PARPORT_NOT_PC  */
+
+#endif /* __KERNEL__ */
+#endif /* _PARPORT_H_ */
diff --git a/include/linux/parport_pc.h b/include/linux/parport_pc.h
new file mode 100644
index 000000000000..7825c76cbd00
--- /dev/null
+++ b/include/linux/parport_pc.h
@@ -0,0 +1,238 @@
+#ifndef __LINUX_PARPORT_PC_H
+#define __LINUX_PARPORT_PC_H
+
+#include <asm/io.h>
+
+/* --- register definitions ------------------------------- */
+
+#define ECONTROL(p) ((p)->base_hi + 0x2)
+#define CONFIGB(p)  ((p)->base_hi + 0x1)
+#define CONFIGA(p)  ((p)->base_hi + 0x0)
+#define FIFO(p)     ((p)->base_hi + 0x0)
+#define EPPDATA(p)  ((p)->base    + 0x4)
+#define EPPADDR(p)  ((p)->base    + 0x3)
+#define CONTROL(p)  ((p)->base    + 0x2)
+#define STATUS(p)   ((p)->base    + 0x1)
+#define DATA(p)     ((p)->base    + 0x0)
+
+struct parport_pc_private {
+        /* Contents of CTR. */
+        unsigned char ctr;
+
+        /* Bitmask of writable CTR bits. */
+        unsigned char ctr_writable;
+
+        /* Whether or not there's an ECR. */
+        int ecr;
+
+        /* Number of PWords that FIFO will hold. */
+        int fifo_depth;
+
+        /* Number of bytes per portword. */
+        int pword;
+
+        /* Not used yet. */
+        int readIntrThreshold;
+        int writeIntrThreshold;
+
+        /* buffer suitable for DMA, if DMA enabled */
+        char *dma_buf;
+        dma_addr_t dma_handle;
+        struct pci_dev *dev;
+        struct list_head list;
+        struct parport *port;
+};
+
+struct parport_pc_via_data
+{
+        /* ISA PnP IRQ routing register 1 */
+        u8 via_pci_parport_irq_reg;
+        /* ISA PnP DMA request routing register */
+        u8 via_pci_parport_dma_reg;
+        /* Register and value to enable SuperIO configuration access */
+        u8 via_pci_superio_config_reg;
+        u8 via_pci_superio_config_data;
+        /* SuperIO function register number */
+        u8 viacfg_function;
+        /* parallel port control register number */
+        u8 viacfg_parport_control;
+        /* Parallel port base address register */
+        u8 viacfg_parport_base;
+};
+
+static __inline__ void parport_pc_write_data(struct parport *p, unsigned char d)
+{
+#ifdef DEBUG_PARPORT
+        printk (KERN_DEBUG "parport_pc_write_data(%p,0x%02x)\n", p, d);
+#endif
+        outb(d, DATA(p));
+}
+
+static __inline__ unsigned char parport_pc_read_data(struct parport *p)
+{
+        unsigned char val = inb (DATA (p));
+#ifdef DEBUG_PARPORT
+        printk (KERN_DEBUG "parport_pc_read_data(%p) = 0x%02x\n",
+                p, val);
+#endif
+        return val;
+}
+
+#ifdef DEBUG_PARPORT
+extern __inline__ void dump_parport_state (char *str, struct parport *p)
+{
+        /* here's hoping that reading these ports won't side-effect anything underneath */
+        unsigned char ecr = inb (ECONTROL (p));
+        unsigned char dcr = inb (CONTROL (p));
+        unsigned char dsr = inb (STATUS (p));
+        static char *ecr_modes[] = {"SPP", "PS2", "PPFIFO", "ECP", "xXx", "yYy", "TST", "CFG"};
+        const struct parport_pc_private *priv = (parport_pc_private *)p->physport->private_data;
+        int i;
+
+        printk (KERN_DEBUG "*** parport state (%s): ecr=[%s", str, ecr_modes[(ecr & 0xe0) >> 5]);
+        if (ecr & 0x10) printk (",nErrIntrEn");
+        if (ecr & 0x08) printk (",dmaEn");
+        if (ecr & 0x04) printk (",serviceIntr");
+        if (ecr & 0x02) printk (",f_full");
+        if (ecr & 0x01) printk (",f_empty");
+        for (i=0; i<2; i++) {
+                printk ("]  dcr(%s)=[", i ? "soft" : "hard");
+                dcr = i ? priv->ctr : inb (CONTROL (p));
+        
+                if (dcr & 0x20) {
+                        printk ("rev");
+                } else {
+                        printk ("fwd");
+                }
+                if (dcr & 0x10) printk (",ackIntEn");
+                if (!(dcr & 0x08)) printk (",N-SELECT-IN");
+                if (dcr & 0x04) printk (",N-INIT");
+                if (!(dcr & 0x02)) printk (",N-AUTOFD");
+                if (!(dcr & 0x01)) printk (",N-STROBE");
+        }
+        printk ("]  dsr=[");
+        if (!(dsr & 0x80)) printk ("BUSY");
+        if (dsr & 0x40) printk (",N-ACK");
+        if (dsr & 0x20) printk (",PERROR");
+        if (dsr & 0x10) printk (",SELECT");
+        if (dsr & 0x08) printk (",N-FAULT");
+        printk ("]\n");
+        return;
+}
+#else   /* !DEBUG_PARPORT */
+#define dump_parport_state(args...)
+#endif  /* !DEBUG_PARPORT */
+
+/* __parport_pc_frob_control differs from parport_pc_frob_control in that
+ * it doesn't do any extra masking. */
+static __inline__ unsigned char __parport_pc_frob_control (struct parport *p,
+                                                           unsigned char mask,
+                                                           unsigned char val)
+{
+        struct parport_pc_private *priv = p->physport->private_data;
+        unsigned char ctr = priv->ctr;
+#ifdef DEBUG_PARPORT
+        printk (KERN_DEBUG
+                "__parport_pc_frob_control(%02x,%02x): %02x -> %02x\n",
+                mask, val, ctr, ((ctr & ~mask) ^ val) & priv->ctr_writable);
+#endif
+        ctr = (ctr & ~mask) ^ val;
+        ctr &= priv->ctr_writable; /* only write writable bits. */
+        outb (ctr, CONTROL (p));
+        priv->ctr = ctr;        /* Update soft copy */
+        return ctr;
+}
+
+static __inline__ void parport_pc_data_reverse (struct parport *p)
+{
+        __parport_pc_frob_control (p, 0x20, 0x20);
+}
+
+static __inline__ void parport_pc_data_forward (struct parport *p)
+{
+        __parport_pc_frob_control (p, 0x20, 0x00);
+}
+
+static __inline__ void parport_pc_write_control (struct parport *p,
+                                                 unsigned char d)
+{
+        const unsigned char wm = (PARPORT_CONTROL_STROBE |
+                                  PARPORT_CONTROL_AUTOFD |
+                                  PARPORT_CONTROL_INIT |
+                                  PARPORT_CONTROL_SELECT);
+
+        /* Take this out when drivers have adapted to newer interface. */
+        if (d & 0x20) {
+                printk (KERN_DEBUG "%s (%s): use data_reverse for this!\n",
+                        p->name, p->cad->name);
+                parport_pc_data_reverse (p);
+        }
+
+        __parport_pc_frob_control (p, wm, d & wm);
+}
+
+static __inline__ unsigned char parport_pc_read_control(struct parport *p)
+{
+        const unsigned char rm = (PARPORT_CONTROL_STROBE |
+                                  PARPORT_CONTROL_AUTOFD |
+                                  PARPORT_CONTROL_INIT |
+                                  PARPORT_CONTROL_SELECT);
+        const struct parport_pc_private *priv = p->physport->private_data;
+        return priv->ctr & rm; /* Use soft copy */
+}
+
+static __inline__ unsigned char parport_pc_frob_control (struct parport *p,
+                                                         unsigned char mask,
+                                                         unsigned char val)
+{
+        const unsigned char wm = (PARPORT_CONTROL_STROBE |
+                                  PARPORT_CONTROL_AUTOFD |
+                                  PARPORT_CONTROL_INIT |
+                                  PARPORT_CONTROL_SELECT);
+
+        /* Take this out when drivers have adapted to newer interface. */
+        if (mask & 0x20) {
+                printk (KERN_DEBUG "%s (%s): use data_%s for this!\n",
+                        p->name, p->cad->name,
+                        (val & 0x20) ? "reverse" : "forward");
+                if (val & 0x20)
+                        parport_pc_data_reverse (p);
+                else
+                        parport_pc_data_forward (p);
+        }
+
+        /* Restrict mask and val to control lines. */
+        mask &= wm;
+        val &= wm;
+
+        return __parport_pc_frob_control (p, mask, val);
+}
+
+static __inline__ unsigned char parport_pc_read_status(struct parport *p)
+{
+        return inb(STATUS(p));
+}
+
+
+static __inline__ void parport_pc_disable_irq(struct parport *p)
+{
+        __parport_pc_frob_control (p, 0x10, 0x00);
+}
+
+static __inline__ void parport_pc_enable_irq(struct parport *p)
+{
+        __parport_pc_frob_control (p, 0x10, 0x10);
+}
+
+extern void parport_pc_release_resources(struct parport *p);
+
+extern int parport_pc_claim_resources(struct parport *p);
+
+/* PCMCIA code will want to get us to look at a port.  Provide a mechanism. */
+extern struct parport *parport_pc_probe_port (unsigned long base,
+                                              unsigned long base_hi,
+                                              int irq, int dma,
+                                              struct pci_dev *dev);
+extern void parport_pc_unregister_port (struct parport *p);
+
+#endif
diff --git a/include/linux/parser.h b/include/linux/parser.h
new file mode 100644
index 000000000000..fa3332861a09
--- /dev/null
+++ b/include/linux/parser.h
@@ -0,0 +1,33 @@
+/*
+ * linux/include/linux/parser.h
+ *
+ * Header for lib/parser.c
+ * Intended use of these functions is parsing filesystem argument lists,
+ * but could potentially be used anywhere else that simple option=arg
+ * parsing is required.
+ */
+
+
+/* associates an integer enumerator with a pattern string. */
+struct match_token {
+        int token;
+        char *pattern;
+};
+
+typedef struct match_token match_table_t[];
+
+/* Maximum number of arguments that match_token will find in a pattern */
+enum {MAX_OPT_ARGS = 3};
+
+/* Describe the location within a string of a substring */
+typedef struct {
+        char *from;
+        char *to;
+} substring_t;
+
+int match_token(char *, match_table_t table, substring_t args[]);
+int match_int(substring_t *, int *result);
+int match_octal(substring_t *, int *result);
+int match_hex(substring_t *, int *result);
+void match_strcpy(char *, substring_t *);
+char *match_strdup(substring_t *);
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
new file mode 100644
index 000000000000..857126a36ecc
--- /dev/null
+++ b/include/linux/pci-acpi.h
@@ -0,0 +1,61 @@
+/*
+ * File         pci-acpi.h
+ *
+ * Copyright (C) 2004 Intel
+ * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
+ */
+
+#ifndef _PCI_ACPI_H_
+#define _PCI_ACPI_H_
+
+#define OSC_QUERY_TYPE                  0
+#define OSC_SUPPORT_TYPE                1
+#define OSC_CONTROL_TYPE                2
+#define OSC_SUPPORT_MASKS               0x1f
+
+/*
+ * _OSC DW0 Definition 
+ */
+#define OSC_QUERY_ENABLE                1
+#define OSC_REQUEST_ERROR               2
+#define OSC_INVALID_UUID_ERROR          4
+#define OSC_INVALID_REVISION_ERROR      8
+#define OSC_CAPABILITIES_MASK_ERROR     16
+
+/*
+ * _OSC DW1 Definition (OS Support Fields)
+ */
+#define OSC_EXT_PCI_CONFIG_SUPPORT              1
+#define OSC_ACTIVE_STATE_PWR_SUPPORT            2
+#define OSC_CLOCK_PWR_CAPABILITY_SUPPORT        4
+#define OSC_PCI_SEGMENT_GROUPS_SUPPORT          8
+#define OSC_MSI_SUPPORT                         16
+
+/*
+ * _OSC DW1 Definition (OS Control Fields)
+ */
+#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL       1
+#define OSC_SHPC_NATIVE_HP_CONTROL              2
+#define OSC_PCI_EXPRESS_PME_CONTROL             4
+#define OSC_PCI_EXPRESS_AER_CONTROL             8
+#define OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL   16
+
+#define OSC_CONTROL_MASKS       (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |    \
+                                OSC_SHPC_NATIVE_HP_CONTROL |            \
+                                OSC_PCI_EXPRESS_PME_CONTROL |           \
+                                OSC_PCI_EXPRESS_AER_CONTROL |           \
+                                OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL)
+
+#ifdef CONFIG_ACPI
+extern acpi_status pci_osc_control_set(u32 flags);
+extern acpi_status pci_osc_support_set(u32 flags);
+#else
+#if !defined(acpi_status)
+typedef u32             acpi_status;
+#define AE_ERROR        (acpi_status) (0x0001)
+#endif    
+static inline acpi_status pci_osc_control_set(u32 flags) {return AE_ERROR;}
+static inline acpi_status pci_osc_support_set(u32 flags) {return AE_ERROR;} 
+#endif
+
+#endif  /* _PCI_ACPI_H_ */
diff --git a/include/linux/pci-dynids.h b/include/linux/pci-dynids.h
new file mode 100644
index 000000000000..183b6b0de81c
--- /dev/null
+++ b/include/linux/pci-dynids.h
@@ -0,0 +1,18 @@
+/*
+ *      PCI defines and function prototypes
+ *      Copyright 2003 Dell Inc.
+ *        by Matt Domsch <Matt_Domsch@dell.com>
+ */
+
+#ifndef LINUX_PCI_DYNIDS_H
+#define LINUX_PCI_DYNIDS_H
+
+#include <linux/list.h>
+#include <linux/mod_devicetable.h>
+
+struct dynid {
+        struct list_head        node;
+        struct pci_device_id    id;
+};
+
+#endif
diff --git a/include/linux/pci.h b/include/linux/pci.h
new file mode 100644
index 000000000000..bea13a99e6fb
--- /dev/null
+++ b/include/linux/pci.h
@@ -0,0 +1,1067 @@
+/*
+ *      pci.h
+ *
+ *      PCI defines and function prototypes
+ *      Copyright 1994, Drew Eckhardt
+ *      Copyright 1997--1999 Martin Mares <mj@ucw.cz>
+ *
+ *      For more information, please consult the following manuals (look at
+ *      http://www.pcisig.com/ for how to get them):
+ *
+ *      PCI BIOS Specification
+ *      PCI Local Bus Specification
+ *      PCI to PCI Bridge Specification
+ *      PCI System Design Guide
+ */
+
+#ifndef LINUX_PCI_H
+#define LINUX_PCI_H
+
+#include <linux/mod_devicetable.h>
+
+/*
+ * Under PCI, each device has 256 bytes of configuration address space,
+ * of which the first 64 bytes are standardized as follows:
+ */
+#define PCI_VENDOR_ID           0x00    /* 16 bits */
+#define PCI_DEVICE_ID           0x02    /* 16 bits */
+#define PCI_COMMAND             0x04    /* 16 bits */
+#define  PCI_COMMAND_IO         0x1     /* Enable response in I/O space */
+#define  PCI_COMMAND_MEMORY     0x2     /* Enable response in Memory space */
+#define  PCI_COMMAND_MASTER     0x4     /* Enable bus mastering */
+#define  PCI_COMMAND_SPECIAL    0x8     /* Enable response to special cycles */
+#define  PCI_COMMAND_INVALIDATE 0x10    /* Use memory write and invalidate */
+#define  PCI_COMMAND_VGA_PALETTE 0x20   /* Enable palette snooping */
+#define  PCI_COMMAND_PARITY     0x40    /* Enable parity checking */
+#define  PCI_COMMAND_WAIT       0x80    /* Enable address/data stepping */
+#define  PCI_COMMAND_SERR       0x100   /* Enable SERR */
+#define  PCI_COMMAND_FAST_BACK  0x200   /* Enable back-to-back writes */
+#define  PCI_COMMAND_INTX_DISABLE 0x400 /* INTx Emulation Disable */
+
+#define PCI_STATUS              0x06    /* 16 bits */
+#define  PCI_STATUS_CAP_LIST    0x10    /* Support Capability List */
+#define  PCI_STATUS_66MHZ       0x20    /* Support 66 Mhz PCI 2.1 bus */
+#define  PCI_STATUS_UDF         0x40    /* Support User Definable Features [obsolete] */
+#define  PCI_STATUS_FAST_BACK   0x80    /* Accept fast-back to back */
+#define  PCI_STATUS_PARITY      0x100   /* Detected parity error */
+#define  PCI_STATUS_DEVSEL_MASK 0x600   /* DEVSEL timing */
+#define  PCI_STATUS_DEVSEL_FAST 0x000   
+#define  PCI_STATUS_DEVSEL_MEDIUM 0x200
+#define  PCI_STATUS_DEVSEL_SLOW 0x400
+#define  PCI_STATUS_SIG_TARGET_ABORT 0x800 /* Set on target abort */
+#define  PCI_STATUS_REC_TARGET_ABORT 0x1000 /* Master ack of " */
+#define  PCI_STATUS_REC_MASTER_ABORT 0x2000 /* Set on master abort */
+#define  PCI_STATUS_SIG_SYSTEM_ERROR 0x4000 /* Set when we drive SERR */
+#define  PCI_STATUS_DETECTED_PARITY 0x8000 /* Set on parity error */
+
+#define PCI_CLASS_REVISION      0x08    /* High 24 bits are class, low 8
+                                           revision */
+#define PCI_REVISION_ID         0x08    /* Revision ID */
+#define PCI_CLASS_PROG          0x09    /* Reg. Level Programming Interface */
+#define PCI_CLASS_DEVICE        0x0a    /* Device class */
+
+#define PCI_CACHE_LINE_SIZE     0x0c    /* 8 bits */
+#define PCI_LATENCY_TIMER       0x0d    /* 8 bits */
+#define PCI_HEADER_TYPE         0x0e    /* 8 bits */
+#define  PCI_HEADER_TYPE_NORMAL 0
+#define  PCI_HEADER_TYPE_BRIDGE 1
+#define  PCI_HEADER_TYPE_CARDBUS 2
+
+#define PCI_BIST                0x0f    /* 8 bits */
+#define  PCI_BIST_CODE_MASK     0x0f    /* Return result */
+#define  PCI_BIST_START         0x40    /* 1 to start BIST, 2 secs or less */
+#define  PCI_BIST_CAPABLE       0x80    /* 1 if BIST capable */
+
+/*
+ * Base addresses specify locations in memory or I/O space.
+ * Decoded size can be determined by writing a value of 
+ * 0xffffffff to the register, and reading it back.  Only 
+ * 1 bits are decoded.
+ */
+#define PCI_BASE_ADDRESS_0      0x10    /* 32 bits */
+#define PCI_BASE_ADDRESS_1      0x14    /* 32 bits [htype 0,1 only] */
+#define PCI_BASE_ADDRESS_2      0x18    /* 32 bits [htype 0 only] */
+#define PCI_BASE_ADDRESS_3      0x1c    /* 32 bits */
+#define PCI_BASE_ADDRESS_4      0x20    /* 32 bits */
+#define PCI_BASE_ADDRESS_5      0x24    /* 32 bits */
+#define  PCI_BASE_ADDRESS_SPACE 0x01    /* 0 = memory, 1 = I/O */
+#define  PCI_BASE_ADDRESS_SPACE_IO 0x01
+#define  PCI_BASE_ADDRESS_SPACE_MEMORY 0x00
+#define  PCI_BASE_ADDRESS_MEM_TYPE_MASK 0x06
+#define  PCI_BASE_ADDRESS_MEM_TYPE_32   0x00    /* 32 bit address */
+#define  PCI_BASE_ADDRESS_MEM_TYPE_1M   0x02    /* Below 1M [obsolete] */
+#define  PCI_BASE_ADDRESS_MEM_TYPE_64   0x04    /* 64 bit address */
+#define  PCI_BASE_ADDRESS_MEM_PREFETCH  0x08    /* prefetchable? */
+#define  PCI_BASE_ADDRESS_MEM_MASK      (~0x0fUL)
+#define  PCI_BASE_ADDRESS_IO_MASK       (~0x03UL)
+/* bit 1 is reserved if address_space = 1 */
+
+/* Header type 0 (normal devices) */
+#define PCI_CARDBUS_CIS         0x28
+#define PCI_SUBSYSTEM_VENDOR_ID 0x2c
+#define PCI_SUBSYSTEM_ID        0x2e  
+#define PCI_ROM_ADDRESS         0x30    /* Bits 31..11 are address, 10..1 reserved */
+#define  PCI_ROM_ADDRESS_ENABLE 0x01
+#define PCI_ROM_ADDRESS_MASK    (~0x7ffUL)
+
+#define PCI_CAPABILITY_LIST     0x34    /* Offset of first capability list entry */
+
+/* 0x35-0x3b are reserved */
+#define PCI_INTERRUPT_LINE      0x3c    /* 8 bits */
+#define PCI_INTERRUPT_PIN       0x3d    /* 8 bits */
+#define PCI_MIN_GNT             0x3e    /* 8 bits */
+#define PCI_MAX_LAT             0x3f    /* 8 bits */
+
+/* Header type 1 (PCI-to-PCI bridges) */
+#define PCI_PRIMARY_BUS         0x18    /* Primary bus number */
+#define PCI_SECONDARY_BUS       0x19    /* Secondary bus number */
+#define PCI_SUBORDINATE_BUS     0x1a    /* Highest bus number behind the bridge */
+#define PCI_SEC_LATENCY_TIMER   0x1b    /* Latency timer for secondary interface */
+#define PCI_IO_BASE             0x1c    /* I/O range behind the bridge */
+#define PCI_IO_LIMIT            0x1d
+#define  PCI_IO_RANGE_TYPE_MASK 0x0fUL  /* I/O bridging type */
+#define  PCI_IO_RANGE_TYPE_16   0x00
+#define  PCI_IO_RANGE_TYPE_32   0x01
+#define  PCI_IO_RANGE_MASK      (~0x0fUL)
+#define PCI_SEC_STATUS          0x1e    /* Secondary status register, only bit 14 used */
+#define PCI_MEMORY_BASE         0x20    /* Memory range behind */
+#define PCI_MEMORY_LIMIT        0x22
+#define  PCI_MEMORY_RANGE_TYPE_MASK 0x0fUL
+#define  PCI_MEMORY_RANGE_MASK  (~0x0fUL)
+#define PCI_PREF_MEMORY_BASE    0x24    /* Prefetchable memory range behind */
+#define PCI_PREF_MEMORY_LIMIT   0x26
+#define  PCI_PREF_RANGE_TYPE_MASK 0x0fUL
+#define  PCI_PREF_RANGE_TYPE_32 0x00
+#define  PCI_PREF_RANGE_TYPE_64 0x01
+#define  PCI_PREF_RANGE_MASK    (~0x0fUL)
+#define PCI_PREF_BASE_UPPER32   0x28    /* Upper half of prefetchable memory range */
+#define PCI_PREF_LIMIT_UPPER32  0x2c
+#define PCI_IO_BASE_UPPER16     0x30    /* Upper half of I/O addresses */
+#define PCI_IO_LIMIT_UPPER16    0x32
+/* 0x34 same as for htype 0 */
+/* 0x35-0x3b is reserved */
+#define PCI_ROM_ADDRESS1        0x38    /* Same as PCI_ROM_ADDRESS, but for htype 1 */
+/* 0x3c-0x3d are same as for htype 0 */
+#define PCI_BRIDGE_CONTROL      0x3e
+#define  PCI_BRIDGE_CTL_PARITY  0x01    /* Enable parity detection on secondary interface */
+#define  PCI_BRIDGE_CTL_SERR    0x02    /* The same for SERR forwarding */
+#define  PCI_BRIDGE_CTL_NO_ISA  0x04    /* Disable bridging of ISA ports */
+#define  PCI_BRIDGE_CTL_VGA     0x08    /* Forward VGA addresses */
+#define  PCI_BRIDGE_CTL_MASTER_ABORT 0x20  /* Report master aborts */
+#define  PCI_BRIDGE_CTL_BUS_RESET 0x40  /* Secondary bus reset */
+#define  PCI_BRIDGE_CTL_FAST_BACK 0x80  /* Fast Back2Back enabled on secondary interface */
+
+/* Header type 2 (CardBus bridges) */
+#define PCI_CB_CAPABILITY_LIST  0x14
+/* 0x15 reserved */
+#define PCI_CB_SEC_STATUS       0x16    /* Secondary status */
+#define PCI_CB_PRIMARY_BUS      0x18    /* PCI bus number */
+#define PCI_CB_CARD_BUS         0x19    /* CardBus bus number */
+#define PCI_CB_SUBORDINATE_BUS  0x1a    /* Subordinate bus number */
+#define PCI_CB_LATENCY_TIMER    0x1b    /* CardBus latency timer */
+#define PCI_CB_MEMORY_BASE_0    0x1c
+#define PCI_CB_MEMORY_LIMIT_0   0x20
+#define PCI_CB_MEMORY_BASE_1    0x24
+#define PCI_CB_MEMORY_LIMIT_1   0x28
+#define PCI_CB_IO_BASE_0        0x2c
+#define PCI_CB_IO_BASE_0_HI     0x2e
+#define PCI_CB_IO_LIMIT_0       0x30
+#define PCI_CB_IO_LIMIT_0_HI    0x32
+#define PCI_CB_IO_BASE_1        0x34
+#define PCI_CB_IO_BASE_1_HI     0x36
+#define PCI_CB_IO_LIMIT_1       0x38
+#define PCI_CB_IO_LIMIT_1_HI    0x3a
+#define  PCI_CB_IO_RANGE_MASK   (~0x03UL)
+/* 0x3c-0x3d are same as for htype 0 */
+#define PCI_CB_BRIDGE_CONTROL   0x3e
+#define  PCI_CB_BRIDGE_CTL_PARITY       0x01    /* Similar to standard bridge control register */
+#define  PCI_CB_BRIDGE_CTL_SERR         0x02
+#define  PCI_CB_BRIDGE_CTL_ISA          0x04
+#define  PCI_CB_BRIDGE_CTL_VGA          0x08
+#define  PCI_CB_BRIDGE_CTL_MASTER_ABORT 0x20
+#define  PCI_CB_BRIDGE_CTL_CB_RESET     0x40    /* CardBus reset */
+#define  PCI_CB_BRIDGE_CTL_16BIT_INT    0x80    /* Enable interrupt for 16-bit cards */
+#define  PCI_CB_BRIDGE_CTL_PREFETCH_MEM0 0x100  /* Prefetch enable for both memory regions */
+#define  PCI_CB_BRIDGE_CTL_PREFETCH_MEM1 0x200
+#define  PCI_CB_BRIDGE_CTL_POST_WRITES  0x400
+#define PCI_CB_SUBSYSTEM_VENDOR_ID 0x40
+#define PCI_CB_SUBSYSTEM_ID     0x42
+#define PCI_CB_LEGACY_MODE_BASE 0x44    /* 16-bit PC Card legacy mode base address (ExCa) */
+/* 0x48-0x7f reserved */
+
+/* Capability lists */
+
+#define PCI_CAP_LIST_ID         0       /* Capability ID */
+#define  PCI_CAP_ID_PM          0x01    /* Power Management */
+#define  PCI_CAP_ID_AGP         0x02    /* Accelerated Graphics Port */
+#define  PCI_CAP_ID_VPD         0x03    /* Vital Product Data */
+#define  PCI_CAP_ID_SLOTID      0x04    /* Slot Identification */
+#define  PCI_CAP_ID_MSI         0x05    /* Message Signalled Interrupts */
+#define  PCI_CAP_ID_CHSWP       0x06    /* CompactPCI HotSwap */
+#define  PCI_CAP_ID_PCIX        0x07    /* PCI-X */
+#define  PCI_CAP_ID_SHPC        0x0C    /* PCI Standard Hot-Plug Controller */
+#define  PCI_CAP_ID_EXP         0x10    /* PCI Express */
+#define  PCI_CAP_ID_MSIX        0x11    /* MSI-X */
+#define PCI_CAP_LIST_NEXT       1       /* Next capability in the list */
+#define PCI_CAP_FLAGS           2       /* Capability defined flags (16 bits) */
+#define PCI_CAP_SIZEOF          4
+
+/* Power Management Registers */
+
+#define PCI_PM_PMC              2       /* PM Capabilities Register */
+#define  PCI_PM_CAP_VER_MASK    0x0007  /* Version */
+#define  PCI_PM_CAP_PME_CLOCK   0x0008  /* PME clock required */
+#define  PCI_PM_CAP_RESERVED    0x0010  /* Reserved field */
+#define  PCI_PM_CAP_DSI         0x0020  /* Device specific initialization */
+#define  PCI_PM_CAP_AUX_POWER   0x01C0  /* Auxilliary power support mask */
+#define  PCI_PM_CAP_D1          0x0200  /* D1 power state support */
+#define  PCI_PM_CAP_D2          0x0400  /* D2 power state support */
+#define  PCI_PM_CAP_PME         0x0800  /* PME pin supported */
+#define  PCI_PM_CAP_PME_MASK    0xF800  /* PME Mask of all supported states */
+#define  PCI_PM_CAP_PME_D0      0x0800  /* PME# from D0 */
+#define  PCI_PM_CAP_PME_D1      0x1000  /* PME# from D1 */
+#define  PCI_PM_CAP_PME_D2      0x2000  /* PME# from D2 */
+#define  PCI_PM_CAP_PME_D3      0x4000  /* PME# from D3 (hot) */
+#define  PCI_PM_CAP_PME_D3cold  0x8000  /* PME# from D3 (cold) */
+#define PCI_PM_CTRL             4       /* PM control and status register */
+#define  PCI_PM_CTRL_STATE_MASK 0x0003  /* Current power state (D0 to D3) */
+#define  PCI_PM_CTRL_PME_ENABLE 0x0100  /* PME pin enable */
+#define  PCI_PM_CTRL_DATA_SEL_MASK      0x1e00  /* Data select (??) */
+#define  PCI_PM_CTRL_DATA_SCALE_MASK    0x6000  /* Data scale (??) */
+#define  PCI_PM_CTRL_PME_STATUS 0x8000  /* PME pin status */
+#define PCI_PM_PPB_EXTENSIONS   6       /* PPB support extensions (??) */
+#define  PCI_PM_PPB_B2_B3       0x40    /* Stop clock when in D3hot (??) */
+#define  PCI_PM_BPCC_ENABLE     0x80    /* Bus power/clock control enable (??) */
+#define PCI_PM_DATA_REGISTER    7       /* (??) */
+#define PCI_PM_SIZEOF           8
+
+/* AGP registers */
+
+#define PCI_AGP_VERSION         2       /* BCD version number */
+#define PCI_AGP_RFU             3       /* Rest of capability flags */
+#define PCI_AGP_STATUS          4       /* Status register */
+#define  PCI_AGP_STATUS_RQ_MASK 0xff000000      /* Maximum number of requests - 1 */
+#define  PCI_AGP_STATUS_SBA     0x0200  /* Sideband addressing supported */
+#define  PCI_AGP_STATUS_64BIT   0x0020  /* 64-bit addressing supported */
+#define  PCI_AGP_STATUS_FW      0x0010  /* FW transfers supported */
+#define  PCI_AGP_STATUS_RATE4   0x0004  /* 4x transfer rate supported */
+#define  PCI_AGP_STATUS_RATE2   0x0002  /* 2x transfer rate supported */
+#define  PCI_AGP_STATUS_RATE1   0x0001  /* 1x transfer rate supported */
+#define PCI_AGP_COMMAND         8       /* Control register */
+#define  PCI_AGP_COMMAND_RQ_MASK 0xff000000  /* Master: Maximum number of requests */
+#define  PCI_AGP_COMMAND_SBA    0x0200  /* Sideband addressing enabled */
+#define  PCI_AGP_COMMAND_AGP    0x0100  /* Allow processing of AGP transactions */
+#define  PCI_AGP_COMMAND_64BIT  0x0020  /* Allow processing of 64-bit addresses */
+#define  PCI_AGP_COMMAND_FW     0x0010  /* Force FW transfers */
+#define  PCI_AGP_COMMAND_RATE4  0x0004  /* Use 4x rate */
+#define  PCI_AGP_COMMAND_RATE2  0x0002  /* Use 2x rate */
+#define  PCI_AGP_COMMAND_RATE1  0x0001  /* Use 1x rate */
+#define PCI_AGP_SIZEOF          12
+
+/* Vital Product Data */
+
+#define PCI_VPD_ADDR            2       /* Address to access (15 bits!) */
+#define  PCI_VPD_ADDR_MASK      0x7fff  /* Address mask */
+#define  PCI_VPD_ADDR_F         0x8000  /* Write 0, 1 indicates completion */
+#define PCI_VPD_DATA            4       /* 32-bits of data returned here */
+
+/* Slot Identification */
+
+#define PCI_SID_ESR             2       /* Expansion Slot Register */
+#define  PCI_SID_ESR_NSLOTS     0x1f    /* Number of expansion slots available */
+#define  PCI_SID_ESR_FIC        0x20    /* First In Chassis Flag */
+#define PCI_SID_CHASSIS_NR      3       /* Chassis Number */
+
+/* Message Signalled Interrupts registers */
+
+#define PCI_MSI_FLAGS           2       /* Various flags */
+#define  PCI_MSI_FLAGS_64BIT    0x80    /* 64-bit addresses allowed */
+#define  PCI_MSI_FLAGS_QSIZE    0x70    /* Message queue size configured */
+#define  PCI_MSI_FLAGS_QMASK    0x0e    /* Maximum queue size available */
+#define  PCI_MSI_FLAGS_ENABLE   0x01    /* MSI feature enabled */
+#define  PCI_MSI_FLAGS_MASKBIT  0x100   /* 64-bit mask bits allowed */
+#define PCI_MSI_RFU             3       /* Rest of capability flags */
+#define PCI_MSI_ADDRESS_LO      4       /* Lower 32 bits */
+#define PCI_MSI_ADDRESS_HI      8       /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) */
+#define PCI_MSI_DATA_32         8       /* 16 bits of data for 32-bit devices */
+#define PCI_MSI_DATA_64         12      /* 16 bits of data for 64-bit devices */
+#define PCI_MSI_MASK_BIT        16      /* Mask bits register */
+
+/* CompactPCI Hotswap Register */
+
+#define PCI_CHSWP_CSR           2       /* Control and Status Register */
+#define  PCI_CHSWP_DHA          0x01    /* Device Hiding Arm */
+#define  PCI_CHSWP_EIM          0x02    /* ENUM# Signal Mask */
+#define  PCI_CHSWP_PIE          0x04    /* Pending Insert or Extract */
+#define  PCI_CHSWP_LOO          0x08    /* LED On / Off */
+#define  PCI_CHSWP_PI           0x30    /* Programming Interface */
+#define  PCI_CHSWP_EXT          0x40    /* ENUM# status - extraction */
+#define  PCI_CHSWP_INS          0x80    /* ENUM# status - insertion */
+
+/* PCI-X registers */
+
+#define PCI_X_CMD               2       /* Modes & Features */
+#define  PCI_X_CMD_DPERR_E      0x0001  /* Data Parity Error Recovery Enable */
+#define  PCI_X_CMD_ERO          0x0002  /* Enable Relaxed Ordering */
+#define  PCI_X_CMD_MAX_READ     0x000c  /* Max Memory Read Byte Count */
+#define  PCI_X_CMD_MAX_SPLIT    0x0070  /* Max Outstanding Split Transactions */
+#define  PCI_X_CMD_VERSION(x)   (((x) >> 12) & 3) /* Version */
+#define PCI_X_STATUS            4       /* PCI-X capabilities */
+#define  PCI_X_STATUS_DEVFN     0x000000ff      /* A copy of devfn */
+#define  PCI_X_STATUS_BUS       0x0000ff00      /* A copy of bus nr */
+#define  PCI_X_STATUS_64BIT     0x00010000      /* 64-bit device */
+#define  PCI_X_STATUS_133MHZ    0x00020000      /* 133 MHz capable */
+#define  PCI_X_STATUS_SPL_DISC  0x00040000      /* Split Completion Discarded */
+#define  PCI_X_STATUS_UNX_SPL   0x00080000      /* Unexpected Split Completion */
+#define  PCI_X_STATUS_COMPLEX   0x00100000      /* Device Complexity */
+#define  PCI_X_STATUS_MAX_READ  0x00600000      /* Designed Max Memory Read Count */
+#define  PCI_X_STATUS_MAX_SPLIT 0x03800000      /* Designed Max Outstanding Split Transactions */
+#define  PCI_X_STATUS_MAX_CUM   0x1c000000      /* Designed Max Cumulative Read Size */
+#define  PCI_X_STATUS_SPL_ERR   0x20000000      /* Rcvd Split Completion Error Msg */
+#define  PCI_X_STATUS_266MHZ    0x40000000      /* 266 MHz capable */
+#define  PCI_X_STATUS_533MHZ    0x80000000      /* 533 MHz capable */
+
+/* PCI Express capability registers */
+
+#define PCI_EXP_FLAGS           2       /* Capabilities register */
+#define PCI_EXP_FLAGS_VERS      0x000f  /* Capability version */
+#define PCI_EXP_FLAGS_TYPE      0x00f0  /* Device/Port type */
+#define  PCI_EXP_TYPE_ENDPOINT  0x0     /* Express Endpoint */
+#define  PCI_EXP_TYPE_LEG_END   0x1     /* Legacy Endpoint */
+#define  PCI_EXP_TYPE_ROOT_PORT 0x4     /* Root Port */
+#define  PCI_EXP_TYPE_UPSTREAM  0x5     /* Upstream Port */
+#define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
+#define  PCI_EXP_TYPE_PCI_BRIDGE 0x7    /* PCI/PCI-X Bridge */
+#define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
+#define PCI_EXP_FLAGS_IRQ       0x3e00  /* Interrupt message number */
+#define PCI_EXP_DEVCAP          4       /* Device capabilities */
+#define  PCI_EXP_DEVCAP_PAYLOAD 0x07    /* Max_Payload_Size */
+#define  PCI_EXP_DEVCAP_PHANTOM 0x18    /* Phantom functions */
+#define  PCI_EXP_DEVCAP_EXT_TAG 0x20    /* Extended tags */
+#define  PCI_EXP_DEVCAP_L0S     0x1c0   /* L0s Acceptable Latency */
+#define  PCI_EXP_DEVCAP_L1      0xe00   /* L1 Acceptable Latency */
+#define  PCI_EXP_DEVCAP_ATN_BUT 0x1000  /* Attention Button Present */
+#define  PCI_EXP_DEVCAP_ATN_IND 0x2000  /* Attention Indicator Present */
+#define  PCI_EXP_DEVCAP_PWR_IND 0x4000  /* Power Indicator Present */
+#define  PCI_EXP_DEVCAP_PWR_VAL 0x3fc0000 /* Slot Power Limit Value */
+#define  PCI_EXP_DEVCAP_PWR_SCL 0xc000000 /* Slot Power Limit Scale */
+#define PCI_EXP_DEVCTL          8       /* Device Control */
+#define  PCI_EXP_DEVCTL_CERE    0x0001  /* Correctable Error Reporting En. */
+#define  PCI_EXP_DEVCTL_NFERE   0x0002  /* Non-Fatal Error Reporting Enable */
+#define  PCI_EXP_DEVCTL_FERE    0x0004  /* Fatal Error Reporting Enable */
+#define  PCI_EXP_DEVCTL_URRE    0x0008  /* Unsupported Request Reporting En. */
+#define  PCI_EXP_DEVCTL_RELAX_EN 0x0010 /* Enable relaxed ordering */
+#define  PCI_EXP_DEVCTL_PAYLOAD 0x00e0  /* Max_Payload_Size */
+#define  PCI_EXP_DEVCTL_EXT_TAG 0x0100  /* Extended Tag Field Enable */
+#define  PCI_EXP_DEVCTL_PHANTOM 0x0200  /* Phantom Functions Enable */
+#define  PCI_EXP_DEVCTL_AUX_PME 0x0400  /* Auxiliary Power PM Enable */
+#define  PCI_EXP_DEVCTL_NOSNOOP_EN 0x0800  /* Enable No Snoop */
+#define  PCI_EXP_DEVCTL_READRQ  0x7000  /* Max_Read_Request_Size */
+#define PCI_EXP_DEVSTA          10      /* Device Status */
+#define  PCI_EXP_DEVSTA_CED     0x01    /* Correctable Error Detected */
+#define  PCI_EXP_DEVSTA_NFED    0x02    /* Non-Fatal Error Detected */
+#define  PCI_EXP_DEVSTA_FED     0x04    /* Fatal Error Detected */
+#define  PCI_EXP_DEVSTA_URD     0x08    /* Unsupported Request Detected */
+#define  PCI_EXP_DEVSTA_AUXPD   0x10    /* AUX Power Detected */
+#define  PCI_EXP_DEVSTA_TRPND   0x20    /* Transactions Pending */
+#define PCI_EXP_LNKCAP          12      /* Link Capabilities */
+#define PCI_EXP_LNKCTL          16      /* Link Control */
+#define PCI_EXP_LNKSTA          18      /* Link Status */
+#define PCI_EXP_SLTCAP          20      /* Slot Capabilities */
+#define PCI_EXP_SLTCTL          24      /* Slot Control */
+#define PCI_EXP_SLTSTA          26      /* Slot Status */
+#define PCI_EXP_RTCTL           28      /* Root Control */
+#define  PCI_EXP_RTCTL_SECEE    0x01    /* System Error on Correctable Error */
+#define  PCI_EXP_RTCTL_SENFEE   0x02    /* System Error on Non-Fatal Error */
+#define  PCI_EXP_RTCTL_SEFEE    0x04    /* System Error on Fatal Error */
+#define  PCI_EXP_RTCTL_PMEIE    0x08    /* PME Interrupt Enable */
+#define  PCI_EXP_RTCTL_CRSSVE   0x10    /* CRS Software Visibility Enable */
+#define PCI_EXP_RTCAP           30      /* Root Capabilities */
+#define PCI_EXP_RTSTA           32      /* Root Status */
+
+/* Extended Capabilities (PCI-X 2.0 and Express) */
+#define PCI_EXT_CAP_ID(header)          (header & 0x0000ffff)
+#define PCI_EXT_CAP_VER(header)         ((header >> 16) & 0xf)
+#define PCI_EXT_CAP_NEXT(header)        ((header >> 20) & 0xffc)
+
+#define PCI_EXT_CAP_ID_ERR      1
+#define PCI_EXT_CAP_ID_VC       2
+#define PCI_EXT_CAP_ID_DSN      3
+#define PCI_EXT_CAP_ID_PWR      4
+
+/* Advanced Error Reporting */
+#define PCI_ERR_UNCOR_STATUS    4       /* Uncorrectable Error Status */
+#define  PCI_ERR_UNC_TRAIN      0x00000001      /* Training */
+#define  PCI_ERR_UNC_DLP        0x00000010      /* Data Link Protocol */
+#define  PCI_ERR_UNC_POISON_TLP 0x00001000      /* Poisoned TLP */
+#define  PCI_ERR_UNC_FCP        0x00002000      /* Flow Control Protocol */
+#define  PCI_ERR_UNC_COMP_TIME  0x00004000      /* Completion Timeout */
+#define  PCI_ERR_UNC_COMP_ABORT 0x00008000      /* Completer Abort */
+#define  PCI_ERR_UNC_UNX_COMP   0x00010000      /* Unexpected Completion */
+#define  PCI_ERR_UNC_RX_OVER    0x00020000      /* Receiver Overflow */
+#define  PCI_ERR_UNC_MALF_TLP   0x00040000      /* Malformed TLP */
+#define  PCI_ERR_UNC_ECRC       0x00080000      /* ECRC Error Status */
+#define  PCI_ERR_UNC_UNSUP      0x00100000      /* Unsupported Request */
+#define PCI_ERR_UNCOR_MASK      8       /* Uncorrectable Error Mask */
+        /* Same bits as above */
+#define PCI_ERR_UNCOR_SEVER     12      /* Uncorrectable Error Severity */
+        /* Same bits as above */
+#define PCI_ERR_COR_STATUS      16      /* Correctable Error Status */
+#define  PCI_ERR_COR_RCVR       0x00000001      /* Receiver Error Status */
+#define  PCI_ERR_COR_BAD_TLP    0x00000040      /* Bad TLP Status */
+#define  PCI_ERR_COR_BAD_DLLP   0x00000080      /* Bad DLLP Status */
+#define  PCI_ERR_COR_REP_ROLL   0x00000100      /* REPLAY_NUM Rollover */
+#define  PCI_ERR_COR_REP_TIMER  0x00001000      /* Replay Timer Timeout */
+#define PCI_ERR_COR_MASK        20      /* Correctable Error Mask */
+        /* Same bits as above */
+#define PCI_ERR_CAP             24      /* Advanced Error Capabilities */
+#define  PCI_ERR_CAP_FEP(x)     ((x) & 31)      /* First Error Pointer */
+#define  PCI_ERR_CAP_ECRC_GENC  0x00000020      /* ECRC Generation Capable */
+#define  PCI_ERR_CAP_ECRC_GENE  0x00000040      /* ECRC Generation Enable */
+#define  PCI_ERR_CAP_ECRC_CHKC  0x00000080      /* ECRC Check Capable */
+#define  PCI_ERR_CAP_ECRC_CHKE  0x00000100      /* ECRC Check Enable */
+#define PCI_ERR_HEADER_LOG      28      /* Header Log Register (16 bytes) */
+#define PCI_ERR_ROOT_COMMAND    44      /* Root Error Command */
+#define PCI_ERR_ROOT_STATUS     48
+#define PCI_ERR_ROOT_COR_SRC    52
+#define PCI_ERR_ROOT_SRC        54
+
+/* Virtual Channel */
+#define PCI_VC_PORT_REG1        4
+#define PCI_VC_PORT_REG2        8
+#define PCI_VC_PORT_CTRL        12
+#define PCI_VC_PORT_STATUS      14
+#define PCI_VC_RES_CAP          16
+#define PCI_VC_RES_CTRL         20
+#define PCI_VC_RES_STATUS       26
+
+/* Power Budgeting */
+#define PCI_PWR_DSR             4       /* Data Select Register */
+#define PCI_PWR_DATA            8       /* Data Register */
+#define  PCI_PWR_DATA_BASE(x)   ((x) & 0xff)        /* Base Power */
+#define  PCI_PWR_DATA_SCALE(x)  (((x) >> 8) & 3)    /* Data Scale */
+#define  PCI_PWR_DATA_PM_SUB(x) (((x) >> 10) & 7)   /* PM Sub State */
+#define  PCI_PWR_DATA_PM_STATE(x) (((x) >> 13) & 3) /* PM State */
+#define  PCI_PWR_DATA_TYPE(x)   (((x) >> 15) & 7)   /* Type */
+#define  PCI_PWR_DATA_RAIL(x)   (((x) >> 18) & 7)   /* Power Rail */
+#define PCI_PWR_CAP             12      /* Capability */
+#define  PCI_PWR_CAP_BUDGET(x)  ((x) & 1)       /* Included in system budget */
+
+/* Include the ID list */
+
+#include <linux/pci_ids.h>
+
+/*
+ * The PCI interface treats multi-function devices as independent
+ * devices.  The slot/function address of each device is encoded
+ * in a single byte as follows:
+ *
+ *      7:3 = slot
+ *      2:0 = function
+ */
+#define PCI_DEVFN(slot,func)    ((((slot) & 0x1f) << 3) | ((func) & 0x07))
+#define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
+#define PCI_FUNC(devfn)         ((devfn) & 0x07)
+
+/* Ioctls for /proc/bus/pci/X/Y nodes. */
+#define PCIIOC_BASE             ('P' << 24 | 'C' << 16 | 'I' << 8)
+#define PCIIOC_CONTROLLER       (PCIIOC_BASE | 0x00)    /* Get controller for PCI device. */
+#define PCIIOC_MMAP_IS_IO       (PCIIOC_BASE | 0x01)    /* Set mmap state to I/O space. */
+#define PCIIOC_MMAP_IS_MEM      (PCIIOC_BASE | 0x02)    /* Set mmap state to MEM space. */
+#define PCIIOC_WRITE_COMBINE    (PCIIOC_BASE | 0x03)    /* Enable/disable write-combining. */
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/config.h>
+#include <linux/ioport.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+
+/* File state for mmap()s on /proc/bus/pci/X/Y */
+enum pci_mmap_state {
+        pci_mmap_io,
+        pci_mmap_mem
+};
+
+/* This defines the direction arg to the DMA mapping routines. */
+#define PCI_DMA_BIDIRECTIONAL   0
+#define PCI_DMA_TODEVICE        1
+#define PCI_DMA_FROMDEVICE      2
+#define PCI_DMA_NONE            3
+
+#define DEVICE_COUNT_COMPATIBLE 4
+#define DEVICE_COUNT_RESOURCE   12
+
+typedef int __bitwise pci_power_t;
+
+#define PCI_D0  ((pci_power_t __force) 0)
+#define PCI_D1  ((pci_power_t __force) 1)
+#define PCI_D2  ((pci_power_t __force) 2)
+#define PCI_D3hot       ((pci_power_t __force) 3)
+#define PCI_D3cold      ((pci_power_t __force) 4)
+
+/*
+ * The pci_dev structure is used to describe PCI devices.
+ */
+struct pci_dev {
+        struct list_head global_list;   /* node in list of all PCI devices */
+        struct list_head bus_list;      /* node in per-bus list */
+        struct pci_bus  *bus;           /* bus this device is on */
+        struct pci_bus  *subordinate;   /* bus this device bridges to */
+
+        void            *sysdata;       /* hook for sys-specific extension */
+        struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
+
+        unsigned int    devfn;          /* encoded device & function index */
+        unsigned short  vendor;
+        unsigned short  device;
+        unsigned short  subsystem_vendor;
+        unsigned short  subsystem_device;
+        unsigned int    class;          /* 3 bytes: (base,sub,prog-if) */
+        u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
+        u8              rom_base_reg;   /* which config register controls the ROM */
+
+        struct pci_driver *driver;      /* which driver has allocated this device */
+        u64             dma_mask;       /* Mask of the bits of bus address this
+                                           device implements.  Normally this is
+                                           0xffffffff.  You only need to change
+                                           this if your device has broken DMA
+                                           or supports 64-bit transfers.  */
+
+        pci_power_t     current_state;  /* Current operating state. In ACPI-speak,
+                                           this is D0-D3, D0 being fully functional,
+                                           and D3 being off. */
+
+        struct  device  dev;            /* Generic device interface */
+
+        /* device is compatible with these IDs */
+        unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];
+        unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];
+
+        int             cfg_size;       /* Size of configuration space */
+
+        /*
+         * Instead of touching interrupt line and base address registers
+         * directly, use the values stored here. They might be different!
+         */
+        unsigned int    irq;
+        struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
+
+        /* These fields are used by common fixups */
+        unsigned int    transparent:1;  /* Transparent PCI bridge */
+        unsigned int    multifunction:1;/* Part of multi-function device */
+        /* keep track of device state */
+        unsigned int    is_enabled:1;   /* pci_enable_device has been called */
+        unsigned int    is_busmaster:1; /* device is busmaster */
+        
+        u32             saved_config_space[16]; /* config space saved at suspend time */
+        struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
+        int rom_attr_enabled;           /* has display of the rom attribute been enabled? */
+        struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
+#ifdef CONFIG_PCI_NAMES
+#define PCI_NAME_SIZE   255
+#define PCI_NAME_HALF   __stringify(43) /* less than half to handle slop */
+        char            pretty_name[PCI_NAME_SIZE];     /* pretty name for users to see */
+#endif
+};
+
+#define pci_dev_g(n) list_entry(n, struct pci_dev, global_list)
+#define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list)
+#define to_pci_dev(n) container_of(n, struct pci_dev, dev)
+#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
+
+/*
+ *  For PCI devices, the region numbers are assigned this way:
+ *
+ *      0-5     standard PCI regions
+ *      6       expansion ROM
+ *      7-10    bridges: address space assigned to buses behind the bridge
+ */
+
+#define PCI_ROM_RESOURCE 6
+#define PCI_BRIDGE_RESOURCES 7
+#define PCI_NUM_RESOURCES 11
+
+#ifndef PCI_BUS_NUM_RESOURCES
+#define PCI_BUS_NUM_RESOURCES 4
+#endif
+  
+#define PCI_REGION_FLAG_MASK 0x0fU      /* These bits of resource flags tell us the PCI region flags */
+
+struct pci_bus {
+        struct list_head node;          /* node in list of buses */
+        struct pci_bus  *parent;        /* parent bus this bridge is on */
+        struct list_head children;      /* list of child buses */
+        struct list_head devices;       /* list of devices on this bus */
+        struct pci_dev  *self;          /* bridge device as seen by parent */
+        struct resource *resource[PCI_BUS_NUM_RESOURCES];
+                                        /* address space routed to this bus */
+
+        struct pci_ops  *ops;           /* configuration access functions */
+        void            *sysdata;       /* hook for sys-specific extension */
+        struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
+
+        unsigned char   number;         /* bus number */
+        unsigned char   primary;        /* number of primary bridge */
+        unsigned char   secondary;      /* number of secondary bridge */
+        unsigned char   subordinate;    /* max number of subordinate buses */
+
+        char            name[48];
+
+        unsigned short  bridge_ctl;     /* manage NO_ISA/FBB/et al behaviors */
+        unsigned short  pad2;
+        struct device           *bridge;
+        struct class_device     class_dev;
+        struct bin_attribute    *legacy_io; /* legacy I/O for this bus */
+        struct bin_attribute    *legacy_mem; /* legacy mem */
+};
+
+#define pci_bus_b(n)    list_entry(n, struct pci_bus, node)
+#define to_pci_bus(n)   container_of(n, struct pci_bus, class_dev)
+
+/*
+ * Error values that may be returned by PCI functions.
+ */
+#define PCIBIOS_SUCCESSFUL              0x00
+#define PCIBIOS_FUNC_NOT_SUPPORTED      0x81
+#define PCIBIOS_BAD_VENDOR_ID           0x83
+#define PCIBIOS_DEVICE_NOT_FOUND        0x86
+#define PCIBIOS_BAD_REGISTER_NUMBER     0x87
+#define PCIBIOS_SET_FAILED              0x88
+#define PCIBIOS_BUFFER_TOO_SMALL        0x89
+
+/* Low-level architecture-dependent routines */
+
+struct pci_ops {
+        int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
+        int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
+};
+
+struct pci_raw_ops {
+        int (*read)(unsigned int domain, unsigned int bus, unsigned int devfn,
+                    int reg, int len, u32 *val);
+        int (*write)(unsigned int domain, unsigned int bus, unsigned int devfn,
+                     int reg, int len, u32 val);
+};
+
+extern struct pci_raw_ops *raw_pci_ops;
+
+struct pci_bus_region {
+        unsigned long start;
+        unsigned long end;
+};
+
+struct pci_dynids {
+        spinlock_t lock;            /* protects list, index */
+        struct list_head list;      /* for IDs added at runtime */
+        unsigned int use_driver_data:1; /* pci_driver->driver_data is used */
+};
+
+struct module;
+struct pci_driver {
+        struct list_head node;
+        char *name;
+        struct module *owner;
+        const struct pci_device_id *id_table;   /* must be non-NULL for probe to be called */
+        int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);   /* New device inserted */
+        void (*remove) (struct pci_dev *dev);   /* Device removed (NULL if not a hot-plug capable driver) */
+        int  (*suspend) (struct pci_dev *dev, pm_message_t state);      /* Device suspended */
+        int  (*resume) (struct pci_dev *dev);                   /* Device woken up */
+        int  (*enable_wake) (struct pci_dev *dev, u32 state, int enable);   /* Enable wake event */
+
+        struct device_driver    driver;
+        struct pci_dynids dynids;
+};
+
+#define to_pci_driver(drv) container_of(drv,struct pci_driver, driver)
+
+/**
+ * PCI_DEVICE - macro used to describe a specific pci device
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device.  The subvendor and subdevice fields will be set to
+ * PCI_ANY_ID.
+ */
+#define PCI_DEVICE(vend,dev) \
+        .vendor = (vend), .device = (dev), \
+        .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class.  The vendor, device, subvendor, and subdevice 
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
+        .class = (dev_class), .class_mask = (dev_class_mask), \
+        .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+        .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/* 
+ * pci_module_init is obsolete, this stays here till we fix up all usages of it
+ * in the tree.
+ */
+#define pci_module_init pci_register_driver
+
+/* these external functions are only available when PCI support is enabled */
+#ifdef CONFIG_PCI
+
+extern struct bus_type pci_bus_type;
+
+/* Do NOT directly access these two variables, unless you are arch specific pci
+ * code, or pci core code. */
+extern struct list_head pci_root_buses; /* list of all known PCI buses */
+extern struct list_head pci_devices;    /* list of all devices */
+
+void pcibios_fixup_bus(struct pci_bus *);
+int pcibios_enable_device(struct pci_dev *, int mask);
+char *pcibios_setup (char *str);
+
+/* Used only when drivers/pci/setup.c is used */
+void pcibios_align_resource(void *, struct resource *,
+                            unsigned long, unsigned long);
+void pcibios_update_irq(struct pci_dev *, int irq);
+
+/* Generic PCI functions used internally */
+
+extern struct pci_bus *pci_find_bus(int domain, int busnr);
+struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus, struct pci_ops *ops, void *sysdata);
+static inline struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata)
+{
+        return pci_scan_bus_parented(NULL, bus, ops, sysdata);
+}
+int pci_scan_slot(struct pci_bus *bus, int devfn);
+struct pci_dev * pci_scan_single_device(struct pci_bus *bus, int devfn);
+unsigned int pci_scan_child_bus(struct pci_bus *bus);
+void pci_bus_add_device(struct pci_dev *dev);
+void pci_bus_add_devices(struct pci_bus *bus);
+void pci_name_device(struct pci_dev *dev);
+char *pci_class_name(u32 class);
+void pci_read_bridge_bases(struct pci_bus *child);
+struct resource *pci_find_parent_resource(const struct pci_dev *dev, struct resource *res);
+int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
+extern struct pci_dev *pci_dev_get(struct pci_dev *dev);
+extern void pci_dev_put(struct pci_dev *dev);
+extern void pci_remove_bus(struct pci_bus *b);
+extern void pci_remove_bus_device(struct pci_dev *dev);
+
+/* Generic PCI functions exported to card drivers */
+
+struct pci_dev *pci_find_device (unsigned int vendor, unsigned int device, const struct pci_dev *from);
+struct pci_dev *pci_find_device_reverse (unsigned int vendor, unsigned int device, const struct pci_dev *from);
+struct pci_dev *pci_find_slot (unsigned int bus, unsigned int devfn);
+int pci_find_capability (struct pci_dev *dev, int cap);
+int pci_find_ext_capability (struct pci_dev *dev, int cap);
+struct pci_bus * pci_find_next_bus(const struct pci_bus *from);
+
+struct pci_dev *pci_get_device (unsigned int vendor, unsigned int device, struct pci_dev *from);
+struct pci_dev *pci_get_subsys (unsigned int vendor, unsigned int device,
+                                unsigned int ss_vendor, unsigned int ss_device,
+                                struct pci_dev *from);
+struct pci_dev *pci_get_slot (struct pci_bus *bus, unsigned int devfn);
+struct pci_dev *pci_get_class (unsigned int class, struct pci_dev *from);
+int pci_dev_present(const struct pci_device_id *ids);
+
+int pci_bus_read_config_byte (struct pci_bus *bus, unsigned int devfn, int where, u8 *val);
+int pci_bus_read_config_word (struct pci_bus *bus, unsigned int devfn, int where, u16 *val);
+int pci_bus_read_config_dword (struct pci_bus *bus, unsigned int devfn, int where, u32 *val);
+int pci_bus_write_config_byte (struct pci_bus *bus, unsigned int devfn, int where, u8 val);
+int pci_bus_write_config_word (struct pci_bus *bus, unsigned int devfn, int where, u16 val);
+int pci_bus_write_config_dword (struct pci_bus *bus, unsigned int devfn, int where, u32 val);
+
+static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val)
+{
+        return pci_bus_read_config_byte (dev->bus, dev->devfn, where, val);
+}
+static inline int pci_read_config_word(struct pci_dev *dev, int where, u16 *val)
+{
+        return pci_bus_read_config_word (dev->bus, dev->devfn, where, val);
+}
+static inline int pci_read_config_dword(struct pci_dev *dev, int where, u32 *val)
+{
+        return pci_bus_read_config_dword (dev->bus, dev->devfn, where, val);
+}
+static inline int pci_write_config_byte(struct pci_dev *dev, int where, u8 val)
+{
+        return pci_bus_write_config_byte (dev->bus, dev->devfn, where, val);
+}
+static inline int pci_write_config_word(struct pci_dev *dev, int where, u16 val)
+{
+        return pci_bus_write_config_word (dev->bus, dev->devfn, where, val);
+}
+static inline int pci_write_config_dword(struct pci_dev *dev, int where, u32 val)
+{
+        return pci_bus_write_config_dword (dev->bus, dev->devfn, where, val);
+}
+
+int pci_enable_device(struct pci_dev *dev);
+int pci_enable_device_bars(struct pci_dev *dev, int mask);
+void pci_disable_device(struct pci_dev *dev);
+void pci_set_master(struct pci_dev *dev);
+#define HAVE_PCI_SET_MWI
+int pci_set_mwi(struct pci_dev *dev);
+void pci_clear_mwi(struct pci_dev *dev);
+int pci_set_dma_mask(struct pci_dev *dev, u64 mask);
+int pci_dac_set_dma_mask(struct pci_dev *dev, u64 mask);
+int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask);
+int pci_assign_resource(struct pci_dev *dev, int i);
+
+/* ROM control related routines */
+void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size);
+void __iomem *pci_map_rom_copy(struct pci_dev *pdev, size_t *size);
+void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
+void pci_remove_rom(struct pci_dev *pdev);
+
+/* Power management related routines */
+int pci_save_state(struct pci_dev *dev);
+int pci_restore_state(struct pci_dev *dev);
+int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
+pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
+int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable);
+
+/* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
+void pci_bus_assign_resources(struct pci_bus *bus);
+void pci_bus_size_bridges(struct pci_bus *bus);
+int pci_claim_resource(struct pci_dev *, int);
+void pci_assign_unassigned_resources(void);
+void pdev_enable_device(struct pci_dev *);
+void pdev_sort_resources(struct pci_dev *, struct resource_list *);
+void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
+                    int (*)(struct pci_dev *, u8, u8));
+#define HAVE_PCI_REQ_REGIONS    2
+int pci_request_regions(struct pci_dev *, char *);
+void pci_release_regions(struct pci_dev *);
+int pci_request_region(struct pci_dev *, int, char *);
+void pci_release_region(struct pci_dev *, int);
+
+/* drivers/pci/bus.c */
+int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
+                           unsigned long size, unsigned long align,
+                           unsigned long min, unsigned int type_mask,
+                           void (*alignf)(void *, struct resource *,
+                                          unsigned long, unsigned long),
+                           void *alignf_data);
+void pci_enable_bridges(struct pci_bus *bus);
+
+/* New-style probing supporting hot-pluggable devices */
+int pci_register_driver(struct pci_driver *);
+void pci_unregister_driver(struct pci_driver *);
+void pci_remove_behind_bridge(struct pci_dev *);
+struct pci_driver *pci_dev_driver(const struct pci_dev *);
+const struct pci_device_id *pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev);
+int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass);
+
+/* kmem_cache style wrapper around pci_alloc_consistent() */
+
+#include <linux/dmapool.h>
+
+#define pci_pool dma_pool
+#define pci_pool_create(name, pdev, size, align, allocation) \
+                dma_pool_create(name, &pdev->dev, size, align, allocation)
+#define pci_pool_destroy(pool) dma_pool_destroy(pool)
+#define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
+#define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
+
+#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
+extern struct pci_dev *isa_bridge;
+#endif
+
+struct msix_entry {
+        u16     vector; /* kernel uses to write allocated vector */
+        u16     entry;  /* driver uses to specify entry, OS writes */
+};
+
+#ifndef CONFIG_PCI_MSI
+static inline void pci_scan_msi_device(struct pci_dev *dev) {}
+static inline int pci_enable_msi(struct pci_dev *dev) {return -1;}
+static inline void pci_disable_msi(struct pci_dev *dev) {}
+static inline int pci_enable_msix(struct pci_dev* dev,
+        struct msix_entry *entries, int nvec) {return -1;}
+static inline void pci_disable_msix(struct pci_dev *dev) {}
+static inline void msi_remove_pci_irq_vectors(struct pci_dev *dev) {}
+#else
+extern void pci_scan_msi_device(struct pci_dev *dev);
+extern int pci_enable_msi(struct pci_dev *dev);
+extern void pci_disable_msi(struct pci_dev *dev);
+extern int pci_enable_msix(struct pci_dev* dev,
+        struct msix_entry *entries, int nvec);
+extern void pci_disable_msix(struct pci_dev *dev);
+extern void msi_remove_pci_irq_vectors(struct pci_dev *dev);
+#endif
+
+#endif /* CONFIG_PCI */
+
+/* Include architecture-dependent settings and functions */
+
+#include <asm/pci.h>
+
+/*
+ *  If the system does not have PCI, clearly these return errors.  Define
+ *  these as simple inline functions to avoid hair in drivers.
+ */
+
+#ifndef CONFIG_PCI
+#define _PCI_NOP(o,s,t) \
+        static inline int pci_##o##_config_##s (struct pci_dev *dev, int where, t val) \
+                { return PCIBIOS_FUNC_NOT_SUPPORTED; }
+#define _PCI_NOP_ALL(o,x)       _PCI_NOP(o,byte,u8 x) \
+                                _PCI_NOP(o,word,u16 x) \
+                                _PCI_NOP(o,dword,u32 x)
+_PCI_NOP_ALL(read, *)
+_PCI_NOP_ALL(write,)
+
+static inline struct pci_dev *pci_find_device(unsigned int vendor, unsigned int device, const struct pci_dev *from)
+{ return NULL; }
+
+static inline struct pci_dev *pci_find_slot(unsigned int bus, unsigned int devfn)
+{ return NULL; }
+
+static inline struct pci_dev *pci_get_device (unsigned int vendor, unsigned int device, struct pci_dev *from)
+{ return NULL; }
+
+static inline struct pci_dev *pci_get_subsys (unsigned int vendor, unsigned int device,
+unsigned int ss_vendor, unsigned int ss_device, struct pci_dev *from)
+{ return NULL; }
+
+static inline struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
+{ return NULL; }
+
+#define pci_dev_present(ids)    (0)
+#define pci_dev_put(dev)        do { } while (0)
+
+static inline void pci_set_master(struct pci_dev *dev) { }
+static inline int pci_enable_device(struct pci_dev *dev) { return -EIO; }
+static inline void pci_disable_device(struct pci_dev *dev) { }
+static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask) { return -EIO; }
+static inline int pci_dac_set_dma_mask(struct pci_dev *dev, u64 mask) { return -EIO; }
+static inline int pci_assign_resource(struct pci_dev *dev, int i) { return -EBUSY;}
+static inline int pci_register_driver(struct pci_driver *drv) { return 0;}
+static inline void pci_unregister_driver(struct pci_driver *drv) { }
+static inline int pci_find_capability (struct pci_dev *dev, int cap) {return 0; }
+static inline int pci_find_ext_capability (struct pci_dev *dev, int cap) {return 0; }
+static inline const struct pci_device_id *pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev) { return NULL; }
+
+/* Power management related routines */
+static inline int pci_save_state(struct pci_dev *dev) { return 0; }
+static inline int pci_restore_state(struct pci_dev *dev) { return 0; }
+static inline int pci_set_power_state(struct pci_dev *dev, pci_power_t state) { return 0; }
+static inline pci_power_t pci_choose_state(struct pci_dev *dev, u32 state) { return PCI_D0; }
+static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable) { return 0; }
+
+#define isa_bridge      ((struct pci_dev *)NULL)
+
+#else
+
+/*
+ * PCI domain support.  Sometimes called PCI segment (eg by ACPI),
+ * a PCI domain is defined to be a set of PCI busses which share
+ * configuration space.
+ */
+#ifndef CONFIG_PCI_DOMAINS
+static inline int pci_domain_nr(struct pci_bus *bus) { return 0; }
+static inline int pci_proc_domain(struct pci_bus *bus)
+{
+        return 0;
+}
+#endif
+
+#endif /* !CONFIG_PCI */
+
+/* these helpers provide future and backwards compatibility
+ * for accessing popular PCI BAR info */
+#define pci_resource_start(dev,bar)   ((dev)->resource[(bar)].start)
+#define pci_resource_end(dev,bar)     ((dev)->resource[(bar)].end)
+#define pci_resource_flags(dev,bar)   ((dev)->resource[(bar)].flags)
+#define pci_resource_len(dev,bar) \
+        ((pci_resource_start((dev),(bar)) == 0 &&       \
+          pci_resource_end((dev),(bar)) ==              \
+          pci_resource_start((dev),(bar))) ? 0 :        \
+                                                        \
+         (pci_resource_end((dev),(bar)) -               \
+          pci_resource_start((dev),(bar)) + 1))
+
+/* Similar to the helpers above, these manipulate per-pci_dev
+ * driver-specific data.  They are really just a wrapper around
+ * the generic device structure functions of these calls.
+ */
+static inline void *pci_get_drvdata (struct pci_dev *pdev)
+{
+        return dev_get_drvdata(&pdev->dev);
+}
+
+static inline void pci_set_drvdata (struct pci_dev *pdev, void *data)
+{
+        dev_set_drvdata(&pdev->dev, data);
+}
+
+/* If you want to know what to call your pci_dev, ask this function.
+ * Again, it's a wrapper around the generic device.
+ */
+static inline char *pci_name(struct pci_dev *pdev)
+{
+        return pdev->dev.bus_id;
+}
+
+/* Some archs want to see the pretty pci name, so use this macro */
+#ifdef CONFIG_PCI_NAMES
+#define pci_pretty_name(dev) ((dev)->pretty_name)
+#else
+#define pci_pretty_name(dev) ""
+#endif
+
+/*
+ *  The world is not perfect and supplies us with broken PCI devices.
+ *  For at least a part of these bugs we need a work-around, so both
+ *  generic (drivers/pci/quirks.c) and per-architecture code can define
+ *  fixup hooks to be called for particular buggy devices.
+ */
+
+struct pci_fixup {
+        u16 vendor, device;     /* You can use PCI_ANY_ID here of course */
+        void (*hook)(struct pci_dev *dev);
+};
+
+enum pci_fixup_pass {
+        pci_fixup_early,        /* Before probing BARs */
+        pci_fixup_header,       /* After reading configuration header */
+        pci_fixup_final,        /* Final phase of device fixups */
+        pci_fixup_enable,       /* pci_enable_device() time */
+};
+
+/* Anonymous variables would be nice... */
+#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, hook)  \
+        static struct pci_fixup __pci_fixup_##name __attribute_used__   \
+        __attribute__((__section__(#section))) = { vendor, device, hook };
+#define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook)                   \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
+                        vendor##device##hook, vendor, device, hook)
+#define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook)                  \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,                    \
+                        vendor##device##hook, vendor, device, hook)
+#define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook)                   \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,                     \
+                        vendor##device##hook, vendor, device, hook)
+#define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook)                  \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,                    \
+                        vendor##device##hook, vendor, device, hook)
+
+
+void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
+
+extern int pci_pci_problems;
+#define PCIPCI_FAIL             1
+#define PCIPCI_TRITON           2
+#define PCIPCI_NATOMA           4
+#define PCIPCI_VIAETBF          8
+#define PCIPCI_VSFX             16
+#define PCIPCI_ALIMAGIK         32
+
+#endif /* __KERNEL__ */
+#endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
new file mode 100644
index 000000000000..de33f6724867
--- /dev/null
+++ b/include/linux/pci_ids.h
@@ -0,0 +1,2562 @@
+/*
+ *      PCI Class, Vendor and Device IDs
+ *
+ *      Please keep sorted.
+ */
+
+/* Device classes and subclasses */
+
+#define PCI_CLASS_NOT_DEFINED           0x0000
+#define PCI_CLASS_NOT_DEFINED_VGA       0x0001
+
+#define PCI_BASE_CLASS_STORAGE          0x01
+#define PCI_CLASS_STORAGE_SCSI          0x0100
+#define PCI_CLASS_STORAGE_IDE           0x0101
+#define PCI_CLASS_STORAGE_FLOPPY        0x0102
+#define PCI_CLASS_STORAGE_IPI           0x0103
+#define PCI_CLASS_STORAGE_RAID          0x0104
+#define PCI_CLASS_STORAGE_OTHER         0x0180
+
+#define PCI_BASE_CLASS_NETWORK          0x02
+#define PCI_CLASS_NETWORK_ETHERNET      0x0200
+#define PCI_CLASS_NETWORK_TOKEN_RING    0x0201
+#define PCI_CLASS_NETWORK_FDDI          0x0202
+#define PCI_CLASS_NETWORK_ATM           0x0203
+#define PCI_CLASS_NETWORK_OTHER         0x0280
+
+#define PCI_BASE_CLASS_DISPLAY          0x03
+#define PCI_CLASS_DISPLAY_VGA           0x0300
+#define PCI_CLASS_DISPLAY_XGA           0x0301
+#define PCI_CLASS_DISPLAY_3D            0x0302
+#define PCI_CLASS_DISPLAY_OTHER         0x0380
+
+#define PCI_BASE_CLASS_MULTIMEDIA       0x04
+#define PCI_CLASS_MULTIMEDIA_VIDEO      0x0400
+#define PCI_CLASS_MULTIMEDIA_AUDIO      0x0401
+#define PCI_CLASS_MULTIMEDIA_PHONE      0x0402
+#define PCI_CLASS_MULTIMEDIA_OTHER      0x0480
+
+#define PCI_BASE_CLASS_MEMORY           0x05
+#define PCI_CLASS_MEMORY_RAM            0x0500
+#define PCI_CLASS_MEMORY_FLASH          0x0501
+#define PCI_CLASS_MEMORY_OTHER          0x0580
+
+#define PCI_BASE_CLASS_BRIDGE           0x06
+#define PCI_CLASS_BRIDGE_HOST           0x0600
+#define PCI_CLASS_BRIDGE_ISA            0x0601
+#define PCI_CLASS_BRIDGE_EISA           0x0602
+#define PCI_CLASS_BRIDGE_MC             0x0603
+#define PCI_CLASS_BRIDGE_PCI            0x0604
+#define PCI_CLASS_BRIDGE_PCMCIA         0x0605
+#define PCI_CLASS_BRIDGE_NUBUS          0x0606
+#define PCI_CLASS_BRIDGE_CARDBUS        0x0607
+#define PCI_CLASS_BRIDGE_RACEWAY        0x0608
+#define PCI_CLASS_BRIDGE_OTHER          0x0680
+
+#define PCI_BASE_CLASS_COMMUNICATION    0x07
+#define PCI_CLASS_COMMUNICATION_SERIAL  0x0700
+#define PCI_CLASS_COMMUNICATION_PARALLEL 0x0701
+#define PCI_CLASS_COMMUNICATION_MULTISERIAL 0x0702
+#define PCI_CLASS_COMMUNICATION_MODEM   0x0703
+#define PCI_CLASS_COMMUNICATION_OTHER   0x0780
+
+#define PCI_BASE_CLASS_SYSTEM           0x08
+#define PCI_CLASS_SYSTEM_PIC            0x0800
+#define PCI_CLASS_SYSTEM_DMA            0x0801
+#define PCI_CLASS_SYSTEM_TIMER          0x0802
+#define PCI_CLASS_SYSTEM_RTC            0x0803
+#define PCI_CLASS_SYSTEM_PCI_HOTPLUG    0x0804
+#define PCI_CLASS_SYSTEM_OTHER          0x0880
+
+#define PCI_BASE_CLASS_INPUT            0x09
+#define PCI_CLASS_INPUT_KEYBOARD        0x0900
+#define PCI_CLASS_INPUT_PEN             0x0901
+#define PCI_CLASS_INPUT_MOUSE           0x0902
+#define PCI_CLASS_INPUT_SCANNER         0x0903
+#define PCI_CLASS_INPUT_GAMEPORT        0x0904
+#define PCI_CLASS_INPUT_OTHER           0x0980
+
+#define PCI_BASE_CLASS_DOCKING          0x0a
+#define PCI_CLASS_DOCKING_GENERIC       0x0a00
+#define PCI_CLASS_DOCKING_OTHER         0x0a80
+
+#define PCI_BASE_CLASS_PROCESSOR        0x0b
+#define PCI_CLASS_PROCESSOR_386         0x0b00
+#define PCI_CLASS_PROCESSOR_486         0x0b01
+#define PCI_CLASS_PROCESSOR_PENTIUM     0x0b02
+#define PCI_CLASS_PROCESSOR_ALPHA       0x0b10
+#define PCI_CLASS_PROCESSOR_POWERPC     0x0b20
+#define PCI_CLASS_PROCESSOR_MIPS        0x0b30
+#define PCI_CLASS_PROCESSOR_CO          0x0b40
+
+#define PCI_BASE_CLASS_SERIAL           0x0c
+#define PCI_CLASS_SERIAL_FIREWIRE       0x0c00
+#define PCI_CLASS_SERIAL_ACCESS         0x0c01
+#define PCI_CLASS_SERIAL_SSA            0x0c02
+#define PCI_CLASS_SERIAL_USB            0x0c03
+#define PCI_CLASS_SERIAL_FIBER          0x0c04
+#define PCI_CLASS_SERIAL_SMBUS          0x0c05
+
+#define PCI_BASE_CLASS_INTELLIGENT      0x0e
+#define PCI_CLASS_INTELLIGENT_I2O       0x0e00
+
+#define PCI_BASE_CLASS_SATELLITE        0x0f
+#define PCI_CLASS_SATELLITE_TV          0x0f00
+#define PCI_CLASS_SATELLITE_AUDIO       0x0f01
+#define PCI_CLASS_SATELLITE_VOICE       0x0f03
+#define PCI_CLASS_SATELLITE_DATA        0x0f04
+
+#define PCI_BASE_CLASS_CRYPT            0x10
+#define PCI_CLASS_CRYPT_NETWORK         0x1000
+#define PCI_CLASS_CRYPT_ENTERTAINMENT   0x1001
+#define PCI_CLASS_CRYPT_OTHER           0x1080
+
+#define PCI_BASE_CLASS_SIGNAL_PROCESSING 0x11
+#define PCI_CLASS_SP_DPIO               0x1100
+#define PCI_CLASS_SP_OTHER              0x1180
+
+#define PCI_CLASS_OTHERS                0xff
+
+/* Vendors and devices.  Sort key: vendor first, device next. */
+
+#define PCI_VENDOR_ID_DYNALINK          0x0675
+#define PCI_DEVICE_ID_DYNALINK_IS64PH   0x1702
+
+#define PCI_VENDOR_ID_BERKOM                    0x0871
+#define PCI_DEVICE_ID_BERKOM_A1T                0xffa1
+#define PCI_DEVICE_ID_BERKOM_T_CONCEPT          0xffa2
+#define PCI_DEVICE_ID_BERKOM_A4T                0xffa4
+#define PCI_DEVICE_ID_BERKOM_SCITEL_QUADRO      0xffa8
+
+#define PCI_VENDOR_ID_COMPAQ            0x0e11
+#define PCI_DEVICE_ID_COMPAQ_TOKENRING  0x0508
+#define PCI_DEVICE_ID_COMPAQ_1280       0x3033
+#define PCI_DEVICE_ID_COMPAQ_TRIFLEX    0x4000
+#define PCI_DEVICE_ID_COMPAQ_6010       0x6010
+#define PCI_DEVICE_ID_COMPAQ_TACHYON    0xa0fc
+#define PCI_DEVICE_ID_COMPAQ_SMART2P    0xae10
+#define PCI_DEVICE_ID_COMPAQ_NETEL100   0xae32
+#define PCI_DEVICE_ID_COMPAQ_NETEL10    0xae34
+#define PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE 0xae33
+#define PCI_DEVICE_ID_COMPAQ_NETFLEX3I  0xae35
+#define PCI_DEVICE_ID_COMPAQ_NETEL100D  0xae40
+#define PCI_DEVICE_ID_COMPAQ_NETEL100PI 0xae43
+#define PCI_DEVICE_ID_COMPAQ_NETEL100I  0xb011
+#define PCI_DEVICE_ID_COMPAQ_CISS       0xb060
+#define PCI_DEVICE_ID_COMPAQ_CISSB      0xb178
+#define PCI_DEVICE_ID_COMPAQ_CISSC      0x46
+#define PCI_DEVICE_ID_COMPAQ_THUNDER    0xf130
+#define PCI_DEVICE_ID_COMPAQ_NETFLEX3B  0xf150
+
+#define PCI_VENDOR_ID_NCR               0x1000
+#define PCI_VENDOR_ID_LSI_LOGIC         0x1000
+#define PCI_DEVICE_ID_NCR_53C810        0x0001
+#define PCI_DEVICE_ID_NCR_53C820        0x0002
+#define PCI_DEVICE_ID_NCR_53C825        0x0003
+#define PCI_DEVICE_ID_NCR_53C815        0x0004
+#define PCI_DEVICE_ID_LSI_53C810AP      0x0005
+#define PCI_DEVICE_ID_NCR_53C860        0x0006
+#define PCI_DEVICE_ID_LSI_53C1510       0x000a
+#define PCI_DEVICE_ID_NCR_53C896        0x000b
+#define PCI_DEVICE_ID_NCR_53C895        0x000c
+#define PCI_DEVICE_ID_NCR_53C885        0x000d
+#define PCI_DEVICE_ID_NCR_53C875        0x000f
+#define PCI_DEVICE_ID_NCR_53C1510       0x0010
+#define PCI_DEVICE_ID_LSI_53C895A       0x0012
+#define PCI_DEVICE_ID_LSI_53C875A       0x0013
+#define PCI_DEVICE_ID_LSI_53C1010_33    0x0020
+#define PCI_DEVICE_ID_LSI_53C1010_66    0x0021
+#define PCI_DEVICE_ID_LSI_53C1030       0x0030
+#define PCI_DEVICE_ID_LSI_1030_53C1035  0x0032
+#define PCI_DEVICE_ID_LSI_53C1035       0x0040
+#define PCI_DEVICE_ID_NCR_53C875J       0x008f
+#define PCI_DEVICE_ID_LSI_FC909         0x0621
+#define PCI_DEVICE_ID_LSI_FC929         0x0622
+#define PCI_DEVICE_ID_LSI_FC929_LAN     0x0623
+#define PCI_DEVICE_ID_LSI_FC919         0x0624
+#define PCI_DEVICE_ID_LSI_FC919_LAN     0x0625
+#define PCI_DEVICE_ID_LSI_FC929X        0x0626
+#define PCI_DEVICE_ID_LSI_FC939X        0x0642
+#define PCI_DEVICE_ID_LSI_FC949X        0x0640
+#define PCI_DEVICE_ID_LSI_FC919X        0x0628
+#define PCI_DEVICE_ID_NCR_YELLOWFIN     0x0701
+#define PCI_DEVICE_ID_LSI_61C102        0x0901
+#define PCI_DEVICE_ID_LSI_63C815        0x1000
+#define PCI_DEVICE_ID_LSI_SAS1064       0x0050
+#define PCI_DEVICE_ID_LSI_SAS1066       0x005E
+#define PCI_DEVICE_ID_LSI_SAS1068       0x0054
+#define PCI_DEVICE_ID_LSI_SAS1064A      0x005C
+#define PCI_DEVICE_ID_LSI_SAS1064E      0x0056
+#define PCI_DEVICE_ID_LSI_SAS1066E      0x005A
+#define PCI_DEVICE_ID_LSI_SAS1068E      0x0058
+#define PCI_DEVICE_ID_LSI_SAS1078       0x0060
+
+#define PCI_VENDOR_ID_ATI               0x1002
+/* Mach64 */
+#define PCI_DEVICE_ID_ATI_68800         0x4158
+#define PCI_DEVICE_ID_ATI_215CT222      0x4354
+#define PCI_DEVICE_ID_ATI_210888CX      0x4358
+#define PCI_DEVICE_ID_ATI_215ET222      0x4554
+/* Mach64 / Rage */
+#define PCI_DEVICE_ID_ATI_215GB         0x4742
+#define PCI_DEVICE_ID_ATI_215GD         0x4744
+#define PCI_DEVICE_ID_ATI_215GI         0x4749
+#define PCI_DEVICE_ID_ATI_215GP         0x4750
+#define PCI_DEVICE_ID_ATI_215GQ         0x4751
+#define PCI_DEVICE_ID_ATI_215XL         0x4752
+#define PCI_DEVICE_ID_ATI_215GT         0x4754
+#define PCI_DEVICE_ID_ATI_215GTB        0x4755
+#define PCI_DEVICE_ID_ATI_215_IV        0x4756
+#define PCI_DEVICE_ID_ATI_215_IW        0x4757
+#define PCI_DEVICE_ID_ATI_215_IZ        0x475A
+#define PCI_DEVICE_ID_ATI_210888GX      0x4758
+#define PCI_DEVICE_ID_ATI_215_LB        0x4c42
+#define PCI_DEVICE_ID_ATI_215_LD        0x4c44
+#define PCI_DEVICE_ID_ATI_215_LG        0x4c47
+#define PCI_DEVICE_ID_ATI_215_LI        0x4c49
+#define PCI_DEVICE_ID_ATI_215_LM        0x4c4D
+#define PCI_DEVICE_ID_ATI_215_LN        0x4c4E
+#define PCI_DEVICE_ID_ATI_215_LR        0x4c52
+#define PCI_DEVICE_ID_ATI_215_LS        0x4c53
+#define PCI_DEVICE_ID_ATI_264_LT        0x4c54
+/* Mach64 VT */
+#define PCI_DEVICE_ID_ATI_264VT         0x5654
+#define PCI_DEVICE_ID_ATI_264VU         0x5655
+#define PCI_DEVICE_ID_ATI_264VV         0x5656
+/* Rage128 GL */
+#define PCI_DEVICE_ID_ATI_RAGE128_RE    0x5245
+#define PCI_DEVICE_ID_ATI_RAGE128_RF    0x5246
+#define PCI_DEVICE_ID_ATI_RAGE128_RG    0x5247
+/* Rage128 VR */
+#define PCI_DEVICE_ID_ATI_RAGE128_RK    0x524b
+#define PCI_DEVICE_ID_ATI_RAGE128_RL    0x524c
+#define PCI_DEVICE_ID_ATI_RAGE128_SE    0x5345
+#define PCI_DEVICE_ID_ATI_RAGE128_SF    0x5346
+#define PCI_DEVICE_ID_ATI_RAGE128_SG    0x5347
+#define PCI_DEVICE_ID_ATI_RAGE128_SH    0x5348
+#define PCI_DEVICE_ID_ATI_RAGE128_SK    0x534b
+#define PCI_DEVICE_ID_ATI_RAGE128_SL    0x534c
+#define PCI_DEVICE_ID_ATI_RAGE128_SM    0x534d
+#define PCI_DEVICE_ID_ATI_RAGE128_SN    0x534e
+/* Rage128 Ultra */
+#define PCI_DEVICE_ID_ATI_RAGE128_TF    0x5446
+#define PCI_DEVICE_ID_ATI_RAGE128_TL    0x544c
+#define PCI_DEVICE_ID_ATI_RAGE128_TR    0x5452
+#define PCI_DEVICE_ID_ATI_RAGE128_TS    0x5453
+#define PCI_DEVICE_ID_ATI_RAGE128_TT    0x5454
+#define PCI_DEVICE_ID_ATI_RAGE128_TU    0x5455
+/* Rage128 M3 */
+#define PCI_DEVICE_ID_ATI_RAGE128_LE    0x4c45
+#define PCI_DEVICE_ID_ATI_RAGE128_LF    0x4c46
+/* Rage128 M4 */
+#define PCI_DEVICE_ID_ATI_RAGE128_MF    0x4d46
+#define PCI_DEVICE_ID_ATI_RAGE128_ML    0x4d4c
+/* Rage128 Pro GL */
+#define PCI_DEVICE_ID_ATI_RAGE128_PA    0x5041
+#define PCI_DEVICE_ID_ATI_RAGE128_PB    0x5042
+#define PCI_DEVICE_ID_ATI_RAGE128_PC    0x5043
+#define PCI_DEVICE_ID_ATI_RAGE128_PD    0x5044
+#define PCI_DEVICE_ID_ATI_RAGE128_PE    0x5045
+#define PCI_DEVICE_ID_ATI_RAGE128_PF    0x5046
+/* Rage128 Pro VR */
+#define PCI_DEVICE_ID_ATI_RAGE128_PG    0x5047
+#define PCI_DEVICE_ID_ATI_RAGE128_PH    0x5048
+#define PCI_DEVICE_ID_ATI_RAGE128_PI    0x5049
+#define PCI_DEVICE_ID_ATI_RAGE128_PJ    0x504A
+#define PCI_DEVICE_ID_ATI_RAGE128_PK    0x504B
+#define PCI_DEVICE_ID_ATI_RAGE128_PL    0x504C
+#define PCI_DEVICE_ID_ATI_RAGE128_PM    0x504D
+#define PCI_DEVICE_ID_ATI_RAGE128_PN    0x504E
+#define PCI_DEVICE_ID_ATI_RAGE128_PO    0x504F
+#define PCI_DEVICE_ID_ATI_RAGE128_PP    0x5050
+#define PCI_DEVICE_ID_ATI_RAGE128_PQ    0x5051
+#define PCI_DEVICE_ID_ATI_RAGE128_PR    0x5052
+#define PCI_DEVICE_ID_ATI_RAGE128_TR    0x5452
+#define PCI_DEVICE_ID_ATI_RAGE128_PS    0x5053
+#define PCI_DEVICE_ID_ATI_RAGE128_PT    0x5054
+#define PCI_DEVICE_ID_ATI_RAGE128_PU    0x5055
+#define PCI_DEVICE_ID_ATI_RAGE128_PV    0x5056
+#define PCI_DEVICE_ID_ATI_RAGE128_PW    0x5057
+#define PCI_DEVICE_ID_ATI_RAGE128_PX    0x5058
+/* Rage128 M4 */
+#define PCI_DEVICE_ID_ATI_RADEON_LE     0x4d45
+#define PCI_DEVICE_ID_ATI_RADEON_LF     0x4d46
+/* Radeon R100 */
+#define PCI_DEVICE_ID_ATI_RADEON_QD     0x5144
+#define PCI_DEVICE_ID_ATI_RADEON_QE     0x5145
+#define PCI_DEVICE_ID_ATI_RADEON_QF     0x5146
+#define PCI_DEVICE_ID_ATI_RADEON_QG     0x5147
+/* Radeon RV100 (VE) */
+#define PCI_DEVICE_ID_ATI_RADEON_QY     0x5159
+#define PCI_DEVICE_ID_ATI_RADEON_QZ     0x515a
+/* Radeon R200 (8500) */
+#define PCI_DEVICE_ID_ATI_RADEON_QL     0x514c
+#define PCI_DEVICE_ID_ATI_RADEON_QN     0x514e
+#define PCI_DEVICE_ID_ATI_RADEON_QO     0x514f
+#define PCI_DEVICE_ID_ATI_RADEON_Ql     0x516c
+#define PCI_DEVICE_ID_ATI_RADEON_BB     0x4242
+/* Radeon R200 (9100) */
+#define PCI_DEVICE_ID_ATI_RADEON_QM     0x514d
+/* Radeon RV200 (7500) */
+#define PCI_DEVICE_ID_ATI_RADEON_QW     0x5157
+#define PCI_DEVICE_ID_ATI_RADEON_QX     0x5158
+/* Radeon NV-100 */
+#define PCI_DEVICE_ID_ATI_RADEON_N1     0x5159
+#define PCI_DEVICE_ID_ATI_RADEON_N2     0x515a
+/* Radeon RV250 (9000) */
+#define PCI_DEVICE_ID_ATI_RADEON_Id     0x4964
+#define PCI_DEVICE_ID_ATI_RADEON_Ie     0x4965
+#define PCI_DEVICE_ID_ATI_RADEON_If     0x4966
+#define PCI_DEVICE_ID_ATI_RADEON_Ig     0x4967
+/* Radeon RV280 (9200) */
+#define PCI_DEVICE_ID_ATI_RADEON_Y_     0x5960
+#define PCI_DEVICE_ID_ATI_RADEON_Ya     0x5961
+#define PCI_DEVICE_ID_ATI_RADEON_Yd     0x5964
+/* Radeon R300 (9500) */
+#define PCI_DEVICE_ID_ATI_RADEON_AD     0x4144
+/* Radeon R300 (9700) */
+#define PCI_DEVICE_ID_ATI_RADEON_ND     0x4e44
+#define PCI_DEVICE_ID_ATI_RADEON_NE     0x4e45
+#define PCI_DEVICE_ID_ATI_RADEON_NF     0x4e46
+#define PCI_DEVICE_ID_ATI_RADEON_NG     0x4e47
+#define PCI_DEVICE_ID_ATI_RADEON_AE     0x4145
+#define PCI_DEVICE_ID_ATI_RADEON_AF     0x4146
+/* Radeon R350 (9800) */
+#define PCI_DEVICE_ID_ATI_RADEON_NH     0x4e48
+#define PCI_DEVICE_ID_ATI_RADEON_NI     0x4e49
+/* Radeon RV350 (9600) */
+#define PCI_DEVICE_ID_ATI_RADEON_AP     0x4150
+#define PCI_DEVICE_ID_ATI_RADEON_AR     0x4152
+/* Radeon M6 */
+#define PCI_DEVICE_ID_ATI_RADEON_LY     0x4c59
+#define PCI_DEVICE_ID_ATI_RADEON_LZ     0x4c5a
+/* Radeon M7 */
+#define PCI_DEVICE_ID_ATI_RADEON_LW     0x4c57
+#define PCI_DEVICE_ID_ATI_RADEON_LX     0x4c58
+/* Radeon M9 */
+#define PCI_DEVICE_ID_ATI_RADEON_Ld     0x4c64
+#define PCI_DEVICE_ID_ATI_RADEON_Le     0x4c65
+#define PCI_DEVICE_ID_ATI_RADEON_Lf     0x4c66
+#define PCI_DEVICE_ID_ATI_RADEON_Lg     0x4c67
+/* Radeon */
+#define PCI_DEVICE_ID_ATI_RADEON_RA     0x5144
+#define PCI_DEVICE_ID_ATI_RADEON_RB     0x5145
+#define PCI_DEVICE_ID_ATI_RADEON_RC     0x5146
+#define PCI_DEVICE_ID_ATI_RADEON_RD     0x5147
+/* RadeonIGP */
+#define PCI_DEVICE_ID_ATI_RS100         0xcab0
+#define PCI_DEVICE_ID_ATI_RS200         0xcab2
+#define PCI_DEVICE_ID_ATI_RS200_B       0xcbb2
+#define PCI_DEVICE_ID_ATI_RS250         0xcab3
+#define PCI_DEVICE_ID_ATI_RS300_100     0x5830
+#define PCI_DEVICE_ID_ATI_RS300_133     0x5831
+#define PCI_DEVICE_ID_ATI_RS300_166     0x5832
+#define PCI_DEVICE_ID_ATI_RS300_200     0x5833
+#define PCI_DEVICE_ID_ATI_RS350_100     0x7830
+#define PCI_DEVICE_ID_ATI_RS350_133     0x7831
+#define PCI_DEVICE_ID_ATI_RS350_166     0x7832
+#define PCI_DEVICE_ID_ATI_RS350_200     0x7833
+#define PCI_DEVICE_ID_ATI_RS400_100     0x5a30
+#define PCI_DEVICE_ID_ATI_RS400_133     0x5a31
+#define PCI_DEVICE_ID_ATI_RS400_166     0x5a32
+#define PCI_DEVICE_ID_ATI_RS400_200     0x5a33
+#define PCI_DEVICE_ID_ATI_RS480         0x5950
+/* ATI IXP Chipset */
+#define PCI_DEVICE_ID_ATI_IXP200_IDE    0x4349
+#define PCI_DEVICE_ID_ATI_IXP300_IDE    0x4369
+#define PCI_DEVICE_ID_ATI_IXP300_SATA   0x436e
+#define PCI_DEVICE_ID_ATI_IXP400_IDE    0x4376
+#define PCI_DEVICE_ID_ATI_IXP400_SATA   0x4379
+
+#define PCI_VENDOR_ID_VLSI              0x1004
+#define PCI_DEVICE_ID_VLSI_82C592       0x0005
+#define PCI_DEVICE_ID_VLSI_82C593       0x0006
+#define PCI_DEVICE_ID_VLSI_82C594       0x0007
+#define PCI_DEVICE_ID_VLSI_82C597       0x0009
+#define PCI_DEVICE_ID_VLSI_82C541       0x000c
+#define PCI_DEVICE_ID_VLSI_82C543       0x000d
+#define PCI_DEVICE_ID_VLSI_82C532       0x0101
+#define PCI_DEVICE_ID_VLSI_82C534       0x0102
+#define PCI_DEVICE_ID_VLSI_82C535       0x0104
+#define PCI_DEVICE_ID_VLSI_82C147       0x0105
+#define PCI_DEVICE_ID_VLSI_VAS96011     0x0702
+
+#define PCI_VENDOR_ID_ADL               0x1005
+#define PCI_DEVICE_ID_ADL_2301          0x2301
+
+#define PCI_VENDOR_ID_NS                0x100b
+#define PCI_DEVICE_ID_NS_87415          0x0002
+#define PCI_DEVICE_ID_NS_87560_LIO      0x000e
+#define PCI_DEVICE_ID_NS_87560_USB      0x0012
+#define PCI_DEVICE_ID_NS_83815          0x0020
+#define PCI_DEVICE_ID_NS_83820          0x0022
+#define PCI_DEVICE_ID_NS_SCx200_BRIDGE  0x0500
+#define PCI_DEVICE_ID_NS_SCx200_SMI     0x0501
+#define PCI_DEVICE_ID_NS_SCx200_IDE     0x0502
+#define PCI_DEVICE_ID_NS_SCx200_AUDIO   0x0503
+#define PCI_DEVICE_ID_NS_SCx200_VIDEO   0x0504
+#define PCI_DEVICE_ID_NS_SCx200_XBUS    0x0505
+#define PCI_DEVICE_ID_NS_SC1100_BRIDGE  0x0510
+#define PCI_DEVICE_ID_NS_SC1100_SMI     0x0511
+#define PCI_DEVICE_ID_NS_SC1100_XBUS    0x0515
+#define PCI_DEVICE_ID_NS_87410          0xd001
+
+#define PCI_VENDOR_ID_TSENG             0x100c
+#define PCI_DEVICE_ID_TSENG_W32P_2      0x3202
+#define PCI_DEVICE_ID_TSENG_W32P_b      0x3205
+#define PCI_DEVICE_ID_TSENG_W32P_c      0x3206
+#define PCI_DEVICE_ID_TSENG_W32P_d      0x3207
+#define PCI_DEVICE_ID_TSENG_ET6000      0x3208
+
+#define PCI_VENDOR_ID_WEITEK            0x100e
+#define PCI_DEVICE_ID_WEITEK_P9000      0x9001
+#define PCI_DEVICE_ID_WEITEK_P9100      0x9100
+
+#define PCI_VENDOR_ID_DEC               0x1011
+#define PCI_DEVICE_ID_DEC_BRD           0x0001
+#define PCI_DEVICE_ID_DEC_TULIP         0x0002
+#define PCI_DEVICE_ID_DEC_TGA           0x0004
+#define PCI_DEVICE_ID_DEC_TULIP_FAST    0x0009
+#define PCI_DEVICE_ID_DEC_TGA2          0x000D
+#define PCI_DEVICE_ID_DEC_FDDI          0x000F
+#define PCI_DEVICE_ID_DEC_TULIP_PLUS    0x0014
+#define PCI_DEVICE_ID_DEC_21142         0x0019
+#define PCI_DEVICE_ID_DEC_21052         0x0021
+#define PCI_DEVICE_ID_DEC_21150         0x0022
+#define PCI_DEVICE_ID_DEC_21152         0x0024
+#define PCI_DEVICE_ID_DEC_21153         0x0025
+#define PCI_DEVICE_ID_DEC_21154         0x0026
+#define PCI_DEVICE_ID_DEC_21285         0x1065
+#define PCI_DEVICE_ID_COMPAQ_42XX       0x0046
+
+#define PCI_VENDOR_ID_CIRRUS            0x1013
+#define PCI_DEVICE_ID_CIRRUS_7548       0x0038
+#define PCI_DEVICE_ID_CIRRUS_5430       0x00a0
+#define PCI_DEVICE_ID_CIRRUS_5434_4     0x00a4
+#define PCI_DEVICE_ID_CIRRUS_5434_8     0x00a8
+#define PCI_DEVICE_ID_CIRRUS_5436       0x00ac
+#define PCI_DEVICE_ID_CIRRUS_5446       0x00b8
+#define PCI_DEVICE_ID_CIRRUS_5480       0x00bc
+#define PCI_DEVICE_ID_CIRRUS_5462       0x00d0
+#define PCI_DEVICE_ID_CIRRUS_5464       0x00d4
+#define PCI_DEVICE_ID_CIRRUS_5465       0x00d6
+#define PCI_DEVICE_ID_CIRRUS_6729       0x1100
+#define PCI_DEVICE_ID_CIRRUS_6832       0x1110
+#define PCI_DEVICE_ID_CIRRUS_7542       0x1200
+#define PCI_DEVICE_ID_CIRRUS_7543       0x1202
+#define PCI_DEVICE_ID_CIRRUS_7541       0x1204
+
+#define PCI_VENDOR_ID_IBM               0x1014
+#define PCI_DEVICE_ID_IBM_FIRE_CORAL    0x000a
+#define PCI_DEVICE_ID_IBM_TR            0x0018
+#define PCI_DEVICE_ID_IBM_82G2675       0x001d
+#define PCI_DEVICE_ID_IBM_MCA           0x0020
+#define PCI_DEVICE_ID_IBM_82351         0x0022
+#define PCI_DEVICE_ID_IBM_PYTHON        0x002d
+#define PCI_DEVICE_ID_IBM_SERVERAID     0x002e
+#define PCI_DEVICE_ID_IBM_TR_WAKE       0x003e
+#define PCI_DEVICE_ID_IBM_MPIC          0x0046
+#define PCI_DEVICE_ID_IBM_3780IDSP      0x007d
+#define PCI_DEVICE_ID_IBM_CHUKAR        0x0096
+#define PCI_DEVICE_ID_IBM_CPC710_PCI64  0x00fc
+#define PCI_DEVICE_ID_IBM_CPC710_PCI32  0x0105
+#define PCI_DEVICE_ID_IBM_405GP         0x0156
+#define PCI_DEVICE_ID_IBM_SNIPE         0x0180
+#define PCI_DEVICE_ID_IBM_SERVERAIDI960 0x01bd
+#define PCI_DEVICE_ID_IBM_CITRINE               0x028C
+#define PCI_DEVICE_ID_IBM_GEMSTONE              0xB166
+#define PCI_DEVICE_ID_IBM_MPIC_2        0xffff
+#define PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1 0x0031
+#define PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2 0x0219
+#define PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX         0x021A
+#define PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM     0x0251
+#define PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL  0x252
+
+#define PCI_VENDOR_ID_COMPEX2           0x101a // pci.ids says "AT&T GIS (NCR)"
+#define PCI_DEVICE_ID_COMPEX2_100VG     0x0005
+
+#define PCI_VENDOR_ID_WD                0x101c
+#define PCI_DEVICE_ID_WD_7197           0x3296
+#define PCI_DEVICE_ID_WD_90C            0xc24a
+
+#define PCI_VENDOR_ID_AMI               0x101e
+#define PCI_DEVICE_ID_AMI_MEGARAID3     0x1960
+#define PCI_DEVICE_ID_AMI_MEGARAID      0x9010
+#define PCI_DEVICE_ID_AMI_MEGARAID2     0x9060
+
+#define PCI_VENDOR_ID_AMD               0x1022
+#define PCI_DEVICE_ID_AMD_LANCE         0x2000
+#define PCI_DEVICE_ID_AMD_LANCE_HOME    0x2001
+#define PCI_DEVICE_ID_AMD_SCSI          0x2020
+#define PCI_DEVICE_ID_AMD_SERENADE      0x36c0
+#define PCI_DEVICE_ID_AMD_FE_GATE_7006  0x7006
+#define PCI_DEVICE_ID_AMD_FE_GATE_7007  0x7007
+#define PCI_DEVICE_ID_AMD_FE_GATE_700C  0x700C
+#define PCI_DEVICE_ID_AMD_FE_GATE_700D  0x700D
+#define PCI_DEVICE_ID_AMD_FE_GATE_700E  0x700E
+#define PCI_DEVICE_ID_AMD_FE_GATE_700F  0x700F
+#define PCI_DEVICE_ID_AMD_COBRA_7400    0x7400
+#define PCI_DEVICE_ID_AMD_COBRA_7401    0x7401
+#define PCI_DEVICE_ID_AMD_COBRA_7403    0x7403
+#define PCI_DEVICE_ID_AMD_COBRA_7404    0x7404
+#define PCI_DEVICE_ID_AMD_VIPER_7408    0x7408
+#define PCI_DEVICE_ID_AMD_VIPER_7409    0x7409
+#define PCI_DEVICE_ID_AMD_VIPER_740B    0x740B
+#define PCI_DEVICE_ID_AMD_VIPER_740C    0x740C
+#define PCI_DEVICE_ID_AMD_VIPER_7410    0x7410
+#define PCI_DEVICE_ID_AMD_VIPER_7411    0x7411
+#define PCI_DEVICE_ID_AMD_VIPER_7413    0x7413
+#define PCI_DEVICE_ID_AMD_VIPER_7414    0x7414
+#define PCI_DEVICE_ID_AMD_OPUS_7440     0x7440
+#       define PCI_DEVICE_ID_AMD_VIPER_7440     PCI_DEVICE_ID_AMD_OPUS_7440
+#define PCI_DEVICE_ID_AMD_OPUS_7441     0x7441
+#       define PCI_DEVICE_ID_AMD_VIPER_7441     PCI_DEVICE_ID_AMD_OPUS_7441
+#define PCI_DEVICE_ID_AMD_OPUS_7443     0x7443
+#       define PCI_DEVICE_ID_AMD_VIPER_7443     PCI_DEVICE_ID_AMD_OPUS_7443
+#define PCI_DEVICE_ID_AMD_OPUS_7445     0x7445
+#define PCI_DEVICE_ID_AMD_OPUS_7448     0x7448
+# define        PCI_DEVICE_ID_AMD_VIPER_7448    PCI_DEVICE_ID_AMD_OPUS_7448
+#define PCI_DEVICE_ID_AMD_OPUS_7449     0x7449
+#       define PCI_DEVICE_ID_AMD_VIPER_7449     PCI_DEVICE_ID_AMD_OPUS_7449
+#define PCI_DEVICE_ID_AMD_8111_LAN      0x7462
+#define PCI_DEVICE_ID_AMD_8111_LPC      0x7468
+#define PCI_DEVICE_ID_AMD_8111_IDE      0x7469
+#define PCI_DEVICE_ID_AMD_8111_SMBUS2   0x746a
+#define PCI_DEVICE_ID_AMD_8111_SMBUS    0x746b
+#define PCI_DEVICE_ID_AMD_8111_AUDIO    0x746d
+#define PCI_DEVICE_ID_AMD_8151_0        0x7454
+#define PCI_DEVICE_ID_AMD_8131_APIC     0x7450
+
+#define PCI_VENDOR_ID_TRIDENT           0x1023
+#define PCI_DEVICE_ID_TRIDENT_4DWAVE_DX 0x2000
+#define PCI_DEVICE_ID_TRIDENT_4DWAVE_NX 0x2001
+#define PCI_DEVICE_ID_TRIDENT_9320      0x9320
+#define PCI_DEVICE_ID_TRIDENT_9388      0x9388
+#define PCI_DEVICE_ID_TRIDENT_9397      0x9397
+#define PCI_DEVICE_ID_TRIDENT_939A      0x939A
+#define PCI_DEVICE_ID_TRIDENT_9520      0x9520
+#define PCI_DEVICE_ID_TRIDENT_9525      0x9525
+#define PCI_DEVICE_ID_TRIDENT_9420      0x9420
+#define PCI_DEVICE_ID_TRIDENT_9440      0x9440
+#define PCI_DEVICE_ID_TRIDENT_9660      0x9660
+#define PCI_DEVICE_ID_TRIDENT_9750      0x9750
+#define PCI_DEVICE_ID_TRIDENT_9850      0x9850
+#define PCI_DEVICE_ID_TRIDENT_9880      0x9880
+#define PCI_DEVICE_ID_TRIDENT_8400      0x8400
+#define PCI_DEVICE_ID_TRIDENT_8420      0x8420
+#define PCI_DEVICE_ID_TRIDENT_8500      0x8500
+
+#define PCI_VENDOR_ID_AI                0x1025
+#define PCI_DEVICE_ID_AI_M1435          0x1435
+
+#define PCI_VENDOR_ID_DELL              0x1028
+#define PCI_DEVICE_ID_DELL_RACIII       0x0008
+#define PCI_DEVICE_ID_DELL_RAC4         0x0012
+
+#define PCI_VENDOR_ID_MATROX            0x102B
+#define PCI_DEVICE_ID_MATROX_MGA_2      0x0518
+#define PCI_DEVICE_ID_MATROX_MIL        0x0519
+#define PCI_DEVICE_ID_MATROX_MYS        0x051A
+#define PCI_DEVICE_ID_MATROX_MIL_2      0x051b
+#define PCI_DEVICE_ID_MATROX_MIL_2_AGP  0x051f
+#define PCI_DEVICE_ID_MATROX_MGA_IMP    0x0d10
+#define PCI_DEVICE_ID_MATROX_G100_MM    0x1000
+#define PCI_DEVICE_ID_MATROX_G100_AGP   0x1001
+#define PCI_DEVICE_ID_MATROX_G200_PCI   0x0520
+#define PCI_DEVICE_ID_MATROX_G200_AGP   0x0521
+#define PCI_DEVICE_ID_MATROX_G400       0x0525
+#define PCI_DEVICE_ID_MATROX_G550       0x2527
+#define PCI_DEVICE_ID_MATROX_VIA        0x4536
+
+#define PCI_VENDOR_ID_CT                0x102c
+#define PCI_DEVICE_ID_CT_69000          0x00c0
+#define PCI_DEVICE_ID_CT_65545          0x00d8
+#define PCI_DEVICE_ID_CT_65548          0x00dc
+#define PCI_DEVICE_ID_CT_65550          0x00e0
+#define PCI_DEVICE_ID_CT_65554          0x00e4
+#define PCI_DEVICE_ID_CT_65555          0x00e5
+
+#define PCI_VENDOR_ID_MIRO              0x1031
+#define PCI_DEVICE_ID_MIRO_36050        0x5601
+#define PCI_DEVICE_ID_MIRO_DC10PLUS     0x7efe
+#define PCI_DEVICE_ID_MIRO_DC30PLUS     0xd801
+
+#define PCI_VENDOR_ID_NEC               0x1033
+#define PCI_DEVICE_ID_NEC_CBUS_1        0x0001 /* PCI-Cbus Bridge */
+#define PCI_DEVICE_ID_NEC_LOCAL         0x0002 /* Local Bridge */
+#define PCI_DEVICE_ID_NEC_ATM           0x0003 /* ATM LAN Controller */
+#define PCI_DEVICE_ID_NEC_R4000         0x0004 /* R4000 Bridge */
+#define PCI_DEVICE_ID_NEC_486           0x0005 /* 486 Like Peripheral Bus Bridge */
+#define PCI_DEVICE_ID_NEC_ACCEL_1       0x0006 /* Graphic Accelerator */
+#define PCI_DEVICE_ID_NEC_UXBUS         0x0007 /* UX-Bus Bridge */
+#define PCI_DEVICE_ID_NEC_ACCEL_2       0x0008 /* Graphic Accelerator */
+#define PCI_DEVICE_ID_NEC_GRAPH         0x0009 /* PCI-CoreGraph Bridge */
+#define PCI_DEVICE_ID_NEC_VL            0x0016 /* PCI-VL Bridge */
+#define PCI_DEVICE_ID_NEC_STARALPHA2    0x002c /* STAR ALPHA2 */
+#define PCI_DEVICE_ID_NEC_CBUS_2        0x002d /* PCI-Cbus Bridge */
+#define PCI_DEVICE_ID_NEC_USB           0x0035 /* PCI-USB Host */
+#define PCI_DEVICE_ID_NEC_CBUS_3        0x003b
+#define PCI_DEVICE_ID_NEC_NAPCCARD      0x003e
+#define PCI_DEVICE_ID_NEC_PCX2          0x0046 /* PowerVR */
+#define PCI_DEVICE_ID_NEC_NILE4         0x005a
+#define PCI_DEVICE_ID_NEC_VRC5476       0x009b
+#define PCI_DEVICE_ID_NEC_VRC4173       0x00a5
+#define PCI_DEVICE_ID_NEC_VRC5477_AC97  0x00a6
+#define PCI_DEVICE_ID_NEC_PC9821CS01    0x800c /* PC-9821-CS01 */
+#define PCI_DEVICE_ID_NEC_PC9821NRB06   0x800d /* PC-9821NR-B06 */
+
+#define PCI_VENDOR_ID_FD                0x1036
+#define PCI_DEVICE_ID_FD_36C70          0x0000
+
+#define PCI_VENDOR_ID_SI                0x1039
+#define PCI_DEVICE_ID_SI_5591_AGP       0x0001
+#define PCI_DEVICE_ID_SI_6202           0x0002
+#define PCI_DEVICE_ID_SI_503            0x0008
+#define PCI_DEVICE_ID_SI_ACPI           0x0009
+#define PCI_DEVICE_ID_SI_SMBUS          0x0016
+#define PCI_DEVICE_ID_SI_LPC            0x0018
+#define PCI_DEVICE_ID_SI_5597_VGA       0x0200
+#define PCI_DEVICE_ID_SI_6205           0x0205
+#define PCI_DEVICE_ID_SI_501            0x0406
+#define PCI_DEVICE_ID_SI_496            0x0496
+#define PCI_DEVICE_ID_SI_300            0x0300
+#define PCI_DEVICE_ID_SI_315H           0x0310
+#define PCI_DEVICE_ID_SI_315            0x0315
+#define PCI_DEVICE_ID_SI_315PRO         0x0325
+#define PCI_DEVICE_ID_SI_530            0x0530
+#define PCI_DEVICE_ID_SI_540            0x0540
+#define PCI_DEVICE_ID_SI_550            0x0550
+#define PCI_DEVICE_ID_SI_540_VGA        0x5300
+#define PCI_DEVICE_ID_SI_550_VGA        0x5315
+#define PCI_DEVICE_ID_SI_601            0x0601
+#define PCI_DEVICE_ID_SI_620            0x0620
+#define PCI_DEVICE_ID_SI_630            0x0630
+#define PCI_DEVICE_ID_SI_633            0x0633
+#define PCI_DEVICE_ID_SI_635            0x0635
+#define PCI_DEVICE_ID_SI_640            0x0640
+#define PCI_DEVICE_ID_SI_645            0x0645
+#define PCI_DEVICE_ID_SI_646            0x0646
+#define PCI_DEVICE_ID_SI_648            0x0648
+#define PCI_DEVICE_ID_SI_650            0x0650
+#define PCI_DEVICE_ID_SI_651            0x0651
+#define PCI_DEVICE_ID_SI_652            0x0652
+#define PCI_DEVICE_ID_SI_655            0x0655
+#define PCI_DEVICE_ID_SI_661            0x0661
+#define PCI_DEVICE_ID_SI_730            0x0730
+#define PCI_DEVICE_ID_SI_733            0x0733
+#define PCI_DEVICE_ID_SI_630_VGA        0x6300
+#define PCI_DEVICE_ID_SI_730_VGA        0x7300
+#define PCI_DEVICE_ID_SI_735            0x0735
+#define PCI_DEVICE_ID_SI_740            0x0740
+#define PCI_DEVICE_ID_SI_741            0x0741
+#define PCI_DEVICE_ID_SI_745            0x0745
+#define PCI_DEVICE_ID_SI_746            0x0746
+#define PCI_DEVICE_ID_SI_748            0x0748
+#define PCI_DEVICE_ID_SI_750            0x0750
+#define PCI_DEVICE_ID_SI_751            0x0751
+#define PCI_DEVICE_ID_SI_752            0x0752
+#define PCI_DEVICE_ID_SI_755            0x0755
+#define PCI_DEVICE_ID_SI_760            0x0760
+#define PCI_DEVICE_ID_SI_900            0x0900
+#define PCI_DEVICE_ID_SI_961            0x0961
+#define PCI_DEVICE_ID_SI_962            0x0962
+#define PCI_DEVICE_ID_SI_963            0x0963
+#define PCI_DEVICE_ID_SI_5107           0x5107
+#define PCI_DEVICE_ID_SI_5300           0x5300
+#define PCI_DEVICE_ID_SI_5511           0x5511
+#define PCI_DEVICE_ID_SI_5513           0x5513
+#define PCI_DEVICE_ID_SI_5518           0x5518
+#define PCI_DEVICE_ID_SI_5571           0x5571
+#define PCI_DEVICE_ID_SI_5581           0x5581
+#define PCI_DEVICE_ID_SI_5582           0x5582
+#define PCI_DEVICE_ID_SI_5591           0x5591
+#define PCI_DEVICE_ID_SI_5596           0x5596
+#define PCI_DEVICE_ID_SI_5597           0x5597
+#define PCI_DEVICE_ID_SI_5598           0x5598
+#define PCI_DEVICE_ID_SI_5600           0x5600
+#define PCI_DEVICE_ID_SI_6300           0x6300
+#define PCI_DEVICE_ID_SI_6306           0x6306
+#define PCI_DEVICE_ID_SI_6326           0x6326
+#define PCI_DEVICE_ID_SI_7001           0x7001
+#define PCI_DEVICE_ID_SI_7012           0x7012
+#define PCI_DEVICE_ID_SI_7016           0x7016
+
+#define PCI_VENDOR_ID_HP                0x103c
+#define PCI_DEVICE_ID_HP_VISUALIZE_EG   0x1005
+#define PCI_DEVICE_ID_HP_VISUALIZE_FX6  0x1006
+#define PCI_DEVICE_ID_HP_VISUALIZE_FX4  0x1008
+#define PCI_DEVICE_ID_HP_VISUALIZE_FX2  0x100a
+#define PCI_DEVICE_ID_HP_TACHYON        0x1028
+#define PCI_DEVICE_ID_HP_TACHLITE       0x1029
+#define PCI_DEVICE_ID_HP_J2585A         0x1030
+#define PCI_DEVICE_ID_HP_J2585B         0x1031
+#define PCI_DEVICE_ID_HP_J2973A         0x1040
+#define PCI_DEVICE_ID_HP_J2970A         0x1042
+#define PCI_DEVICE_ID_HP_DIVA           0x1048
+#define PCI_DEVICE_ID_HP_DIVA_TOSCA1    0x1049
+#define PCI_DEVICE_ID_HP_DIVA_TOSCA2    0x104A
+#define PCI_DEVICE_ID_HP_DIVA_MAESTRO   0x104B
+#define PCI_DEVICE_ID_HP_PCI_LBA        0x1054
+#define PCI_DEVICE_ID_HP_REO_SBA        0x10f0
+#define PCI_DEVICE_ID_HP_REO_IOC        0x10f1
+#define PCI_DEVICE_ID_HP_VISUALIZE_FXE  0x108b
+#define PCI_DEVICE_ID_HP_DIVA_HALFDOME  0x1223
+#define PCI_DEVICE_ID_HP_DIVA_KEYSTONE  0x1226
+#define PCI_DEVICE_ID_HP_DIVA_POWERBAR  0x1227
+#define PCI_DEVICE_ID_HP_ZX1_SBA        0x1229
+#define PCI_DEVICE_ID_HP_ZX1_IOC        0x122a
+#define PCI_DEVICE_ID_HP_PCIX_LBA       0x122e
+#define PCI_DEVICE_ID_HP_SX1000_IOC     0x127c
+#define PCI_DEVICE_ID_HP_DIVA_EVEREST   0x1282
+#define PCI_DEVICE_ID_HP_DIVA_AUX       0x1290
+#define PCI_DEVICE_ID_HP_DIVA_RMP3      0x1301
+#define PCI_DEVICE_ID_HP_CISSA          0x3220
+#define PCI_DEVICE_ID_HP_CISSB          0x3230
+#define PCI_DEVICE_ID_HP_ZX2_IOC        0x4031
+
+#define PCI_VENDOR_ID_PCTECH            0x1042
+#define PCI_DEVICE_ID_PCTECH_RZ1000     0x1000
+#define PCI_DEVICE_ID_PCTECH_RZ1001     0x1001
+#define PCI_DEVICE_ID_PCTECH_SAMURAI_0  0x3000
+#define PCI_DEVICE_ID_PCTECH_SAMURAI_1  0x3010
+#define PCI_DEVICE_ID_PCTECH_SAMURAI_IDE 0x3020
+
+#define PCI_VENDOR_ID_ASUSTEK           0x1043
+#define PCI_DEVICE_ID_ASUSTEK_0675      0x0675
+
+#define PCI_VENDOR_ID_DPT               0x1044
+#define PCI_DEVICE_ID_DPT               0xa400
+
+#define PCI_VENDOR_ID_OPTI              0x1045
+#define PCI_DEVICE_ID_OPTI_92C178       0xc178
+#define PCI_DEVICE_ID_OPTI_82C557       0xc557
+#define PCI_DEVICE_ID_OPTI_82C558       0xc558
+#define PCI_DEVICE_ID_OPTI_82C621       0xc621
+#define PCI_DEVICE_ID_OPTI_82C700       0xc700
+#define PCI_DEVICE_ID_OPTI_82C701       0xc701
+#define PCI_DEVICE_ID_OPTI_82C814       0xc814
+#define PCI_DEVICE_ID_OPTI_82C822       0xc822
+#define PCI_DEVICE_ID_OPTI_82C861       0xc861
+#define PCI_DEVICE_ID_OPTI_82C825       0xd568
+
+#define PCI_VENDOR_ID_ELSA              0x1048
+#define PCI_DEVICE_ID_ELSA_MICROLINK    0x1000
+#define PCI_DEVICE_ID_ELSA_QS3000       0x3000
+
+#define PCI_VENDOR_ID_SGS               0x104a
+#define PCI_DEVICE_ID_SGS_2000          0x0008
+#define PCI_DEVICE_ID_SGS_1764          0x0009
+
+#define PCI_VENDOR_ID_BUSLOGIC                0x104B
+#define PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC 0x0140
+#define PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER    0x1040
+#define PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT     0x8130
+
+#define PCI_VENDOR_ID_TI                0x104c
+#define PCI_DEVICE_ID_TI_TVP4010        0x3d04
+#define PCI_DEVICE_ID_TI_TVP4020        0x3d07
+#define PCI_DEVICE_ID_TI_4450           0x8011
+#define PCI_DEVICE_ID_TI_1130           0xac12
+#define PCI_DEVICE_ID_TI_1031           0xac13
+#define PCI_DEVICE_ID_TI_1131           0xac15
+#define PCI_DEVICE_ID_TI_1250           0xac16
+#define PCI_DEVICE_ID_TI_1220           0xac17
+#define PCI_DEVICE_ID_TI_1221           0xac19
+#define PCI_DEVICE_ID_TI_1210           0xac1a
+#define PCI_DEVICE_ID_TI_1450           0xac1b
+#define PCI_DEVICE_ID_TI_1225           0xac1c
+#define PCI_DEVICE_ID_TI_1251A          0xac1d
+#define PCI_DEVICE_ID_TI_1211           0xac1e
+#define PCI_DEVICE_ID_TI_1251B          0xac1f
+#define PCI_DEVICE_ID_TI_4410           0xac41
+#define PCI_DEVICE_ID_TI_4451           0xac42
+#define PCI_DEVICE_ID_TI_4510           0xac44
+#define PCI_DEVICE_ID_TI_4520           0xac46
+#define PCI_DEVICE_ID_TI_1410           0xac50
+#define PCI_DEVICE_ID_TI_1420           0xac51
+#define PCI_DEVICE_ID_TI_1451A          0xac52
+#define PCI_DEVICE_ID_TI_1620           0xac54
+#define PCI_DEVICE_ID_TI_1520           0xac55
+#define PCI_DEVICE_ID_TI_1510           0xac56
+
+#define PCI_VENDOR_ID_SONY              0x104d
+#define PCI_DEVICE_ID_SONY_CXD3222      0x8039
+
+#define PCI_VENDOR_ID_OAK               0x104e
+#define PCI_DEVICE_ID_OAK_OTI107        0x0107
+
+/* Winbond have two vendor IDs! See 0x10ad as well */
+#define PCI_VENDOR_ID_WINBOND2          0x1050
+#define PCI_DEVICE_ID_WINBOND2_89C940   0x0940
+#define PCI_DEVICE_ID_WINBOND2_89C940F  0x5a5a
+#define PCI_DEVICE_ID_WINBOND2_6692     0x6692
+
+#define PCI_VENDOR_ID_ANIGMA            0x1051
+#define PCI_DEVICE_ID_ANIGMA_MC145575   0x0100
+  
+#define PCI_VENDOR_ID_EFAR              0x1055
+#define PCI_DEVICE_ID_EFAR_SLC90E66_1   0x9130
+#define PCI_DEVICE_ID_EFAR_SLC90E66_0   0x9460
+#define PCI_DEVICE_ID_EFAR_SLC90E66_2   0x9462
+#define PCI_DEVICE_ID_EFAR_SLC90E66_3   0x9463
+
+#define PCI_VENDOR_ID_MOTOROLA          0x1057
+#define PCI_VENDOR_ID_MOTOROLA_OOPS     0x1507
+#define PCI_DEVICE_ID_MOTOROLA_MPC105   0x0001
+#define PCI_DEVICE_ID_MOTOROLA_MPC106   0x0002
+#define PCI_DEVICE_ID_MOTOROLA_MPC107   0x0004
+#define PCI_DEVICE_ID_MOTOROLA_RAVEN    0x4801
+#define PCI_DEVICE_ID_MOTOROLA_FALCON   0x4802
+#define PCI_DEVICE_ID_MOTOROLA_HAWK     0x4803
+#define PCI_DEVICE_ID_MOTOROLA_CPX8216  0x4806
+#define PCI_DEVICE_ID_MOTOROLA_HARRIER  0x480b
+#define PCI_DEVICE_ID_MOTOROLA_MPC5200  0x5803
+
+#define PCI_VENDOR_ID_PROMISE           0x105a
+#define PCI_DEVICE_ID_PROMISE_20265     0x0d30
+#define PCI_DEVICE_ID_PROMISE_20267     0x4d30
+#define PCI_DEVICE_ID_PROMISE_20246     0x4d33
+#define PCI_DEVICE_ID_PROMISE_20262     0x4d38
+#define PCI_DEVICE_ID_PROMISE_20263     0x0D38
+#define PCI_DEVICE_ID_PROMISE_20268     0x4d68
+#define PCI_DEVICE_ID_PROMISE_20268R    0x6268
+#define PCI_DEVICE_ID_PROMISE_20269     0x4d69
+#define PCI_DEVICE_ID_PROMISE_20270     0x6268
+#define PCI_DEVICE_ID_PROMISE_20271     0x6269
+#define PCI_DEVICE_ID_PROMISE_20275     0x1275
+#define PCI_DEVICE_ID_PROMISE_20276     0x5275
+#define PCI_DEVICE_ID_PROMISE_20277     0x7275
+#define PCI_DEVICE_ID_PROMISE_5300      0x5300
+
+#define PCI_VENDOR_ID_N9                0x105d
+#define PCI_DEVICE_ID_N9_I128           0x2309
+#define PCI_DEVICE_ID_N9_I128_2         0x2339
+#define PCI_DEVICE_ID_N9_I128_T2R       0x493d
+
+#define PCI_VENDOR_ID_UMC               0x1060
+#define PCI_DEVICE_ID_UMC_UM8673F       0x0101
+#define PCI_DEVICE_ID_UMC_UM8891A       0x0891
+#define PCI_DEVICE_ID_UMC_UM8886BF      0x673a
+#define PCI_DEVICE_ID_UMC_UM8886A       0x886a
+#define PCI_DEVICE_ID_UMC_UM8881F       0x8881
+#define PCI_DEVICE_ID_UMC_UM8886F       0x8886
+#define PCI_DEVICE_ID_UMC_UM9017F       0x9017
+#define PCI_DEVICE_ID_UMC_UM8886N       0xe886
+#define PCI_DEVICE_ID_UMC_UM8891N       0xe891
+
+#define PCI_VENDOR_ID_X                 0x1061
+#define PCI_DEVICE_ID_X_AGX016          0x0001
+
+#define PCI_VENDOR_ID_MYLEX             0x1069
+#define PCI_DEVICE_ID_MYLEX_DAC960_P    0x0001
+#define PCI_DEVICE_ID_MYLEX_DAC960_PD   0x0002
+#define PCI_DEVICE_ID_MYLEX_DAC960_PG   0x0010
+#define PCI_DEVICE_ID_MYLEX_DAC960_LA   0x0020
+#define PCI_DEVICE_ID_MYLEX_DAC960_LP   0x0050
+#define PCI_DEVICE_ID_MYLEX_DAC960_BA   0xBA56
+
+#define PCI_VENDOR_ID_PICOP             0x1066
+#define PCI_DEVICE_ID_PICOP_PT86C52X    0x0001
+#define PCI_DEVICE_ID_PICOP_PT80C524    0x8002
+
+#define PCI_VENDOR_ID_APPLE             0x106b
+#define PCI_DEVICE_ID_APPLE_BANDIT      0x0001
+#define PCI_DEVICE_ID_APPLE_GC          0x0002
+#define PCI_DEVICE_ID_APPLE_HYDRA       0x000e
+#define PCI_DEVICE_ID_APPLE_UNI_N_FW    0x0018
+#define PCI_DEVICE_ID_APPLE_KL_USB      0x0019
+#define PCI_DEVICE_ID_APPLE_UNI_N_AGP   0x0020
+#define PCI_DEVICE_ID_APPLE_UNI_N_GMAC  0x0021
+#define PCI_DEVICE_ID_APPLE_KEYLARGO    0x0022
+#define PCI_DEVICE_ID_APPLE_UNI_N_GMACP 0x0024
+#define PCI_DEVICE_ID_APPLE_KEYLARGO_P  0x0025
+#define PCI_DEVICE_ID_APPLE_KL_USB_P    0x0026
+#define PCI_DEVICE_ID_APPLE_UNI_N_AGP_P 0x0027
+#define PCI_DEVICE_ID_APPLE_UNI_N_AGP15 0x002d
+#define PCI_DEVICE_ID_APPLE_UNI_N_FW2   0x0030
+#define PCI_DEVICE_ID_APPLE_UNI_N_GMAC2 0x0032
+#define PCI_DEVIEC_ID_APPLE_UNI_N_ATA   0x0033
+#define PCI_DEVICE_ID_APPLE_UNI_N_AGP2  0x0034
+#define PCI_DEVICE_ID_APPLE_IPID_ATA100 0x003b
+#define PCI_DEVICE_ID_APPLE_KEYLARGO_I  0x003e
+#define PCI_DEVICE_ID_APPLE_K2_ATA100   0x0043
+#define PCI_DEVICE_ID_APPLE_U3_AGP      0x004b
+#define PCI_DEVICE_ID_APPLE_K2_GMAC     0x004c
+#define PCI_DEVICE_ID_APPLE_SH_ATA      0x0050
+#define PCI_DEVICE_ID_APPLE_SH_SUNGEM   0x0051
+#define PCI_DEVICE_ID_APPLE_SH_FW       0x0052
+#define PCI_DEVICE_ID_APPLE_U3L_AGP     0x0058
+#define PCI_DEVICE_ID_APPLE_U3H_AGP     0x0059
+#define PCI_DEVICE_ID_APPLE_TIGON3      0x1645
+
+#define PCI_VENDOR_ID_YAMAHA            0x1073
+#define PCI_DEVICE_ID_YAMAHA_724        0x0004
+#define PCI_DEVICE_ID_YAMAHA_724F       0x000d
+#define PCI_DEVICE_ID_YAMAHA_740        0x000a
+#define PCI_DEVICE_ID_YAMAHA_740C       0x000c
+#define PCI_DEVICE_ID_YAMAHA_744        0x0010
+#define PCI_DEVICE_ID_YAMAHA_754        0x0012
+
+#define PCI_VENDOR_ID_NEXGEN            0x1074
+#define PCI_DEVICE_ID_NEXGEN_82C501     0x4e78
+
+#define PCI_VENDOR_ID_QLOGIC            0x1077
+#define PCI_DEVICE_ID_QLOGIC_ISP1020    0x1020
+#define PCI_DEVICE_ID_QLOGIC_ISP1022    0x1022
+#define PCI_DEVICE_ID_QLOGIC_ISP2100    0x2100
+#define PCI_DEVICE_ID_QLOGIC_ISP2200    0x2200
+
+#define PCI_VENDOR_ID_CYRIX             0x1078
+#define PCI_DEVICE_ID_CYRIX_5510        0x0000
+#define PCI_DEVICE_ID_CYRIX_PCI_MASTER  0x0001
+#define PCI_DEVICE_ID_CYRIX_5520        0x0002
+#define PCI_DEVICE_ID_CYRIX_5530_LEGACY 0x0100
+#define PCI_DEVICE_ID_CYRIX_5530_SMI    0x0101
+#define PCI_DEVICE_ID_CYRIX_5530_IDE    0x0102
+#define PCI_DEVICE_ID_CYRIX_5530_AUDIO  0x0103
+#define PCI_DEVICE_ID_CYRIX_5530_VIDEO  0x0104
+
+#define PCI_VENDOR_ID_LEADTEK           0x107d
+#define PCI_DEVICE_ID_LEADTEK_805       0x0000
+
+#define PCI_VENDOR_ID_INTERPHASE        0x107e
+#define PCI_DEVICE_ID_INTERPHASE_5526   0x0004
+#define PCI_DEVICE_ID_INTERPHASE_55x6   0x0005
+#define PCI_DEVICE_ID_INTERPHASE_5575   0x0008
+
+#define PCI_VENDOR_ID_CONTAQ            0x1080
+#define PCI_DEVICE_ID_CONTAQ_82C599     0x0600
+#define PCI_DEVICE_ID_CONTAQ_82C693     0xc693
+
+#define PCI_VENDOR_ID_FOREX             0x1083
+
+#define PCI_VENDOR_ID_OLICOM            0x108d
+#define PCI_DEVICE_ID_OLICOM_OC3136     0x0001
+#define PCI_DEVICE_ID_OLICOM_OC2315     0x0011
+#define PCI_DEVICE_ID_OLICOM_OC2325     0x0012
+#define PCI_DEVICE_ID_OLICOM_OC2183     0x0013
+#define PCI_DEVICE_ID_OLICOM_OC2326     0x0014
+#define PCI_DEVICE_ID_OLICOM_OC6151     0x0021
+
+#define PCI_VENDOR_ID_SUN               0x108e
+#define PCI_DEVICE_ID_SUN_EBUS          0x1000
+#define PCI_DEVICE_ID_SUN_HAPPYMEAL     0x1001
+#define PCI_DEVICE_ID_SUN_RIO_EBUS      0x1100
+#define PCI_DEVICE_ID_SUN_RIO_GEM       0x1101
+#define PCI_DEVICE_ID_SUN_RIO_1394      0x1102
+#define PCI_DEVICE_ID_SUN_RIO_USB       0x1103
+#define PCI_DEVICE_ID_SUN_GEM           0x2bad
+#define PCI_DEVICE_ID_SUN_SIMBA         0x5000
+#define PCI_DEVICE_ID_SUN_PBM           0x8000
+#define PCI_DEVICE_ID_SUN_SCHIZO        0x8001
+#define PCI_DEVICE_ID_SUN_SABRE         0xa000
+#define PCI_DEVICE_ID_SUN_HUMMINGBIRD   0xa001
+#define PCI_DEVICE_ID_SUN_TOMATILLO     0xa801
+
+#define PCI_VENDOR_ID_CMD               0x1095
+#define PCI_DEVICE_ID_CMD_640           0x0640
+#define PCI_DEVICE_ID_CMD_643           0x0643
+#define PCI_DEVICE_ID_CMD_646           0x0646
+#define PCI_DEVICE_ID_CMD_647           0x0647
+#define PCI_DEVICE_ID_CMD_648           0x0648
+#define PCI_DEVICE_ID_CMD_649           0x0649
+#define PCI_DEVICE_ID_CMD_670           0x0670
+#define PCI_DEVICE_ID_CMD_680           0x0680
+
+#define PCI_DEVICE_ID_SII_680           0x0680
+#define PCI_DEVICE_ID_SII_3112          0x3112
+#define PCI_DEVICE_ID_SII_1210SA        0x0240
+
+#define PCI_VENDOR_ID_VISION            0x1098
+#define PCI_DEVICE_ID_VISION_QD8500     0x0001
+#define PCI_DEVICE_ID_VISION_QD8580     0x0002
+
+#define PCI_VENDOR_ID_BROOKTREE         0x109e
+#define PCI_DEVICE_ID_BROOKTREE_848     0x0350
+#define PCI_DEVICE_ID_BROOKTREE_849A    0x0351
+#define PCI_DEVICE_ID_BROOKTREE_878_1   0x036e
+#define PCI_DEVICE_ID_BROOKTREE_878     0x0878
+#define PCI_DEVICE_ID_BROOKTREE_8474    0x8474
+
+#define PCI_VENDOR_ID_SIERRA            0x10a8
+#define PCI_DEVICE_ID_SIERRA_STB        0x0000
+
+#define PCI_VENDOR_ID_SGI               0x10a9
+#define PCI_DEVICE_ID_SGI_IOC3          0x0003
+#define PCI_DEVICE_ID_SGI_IOC4          0x100a
+#define PCI_VENDOR_ID_SGI_LITHIUM       0x1002
+
+#define PCI_VENDOR_ID_ACC               0x10aa
+#define PCI_DEVICE_ID_ACC_2056          0x0000
+
+#define PCI_VENDOR_ID_WINBOND           0x10ad
+#define PCI_DEVICE_ID_WINBOND_83769     0x0001
+#define PCI_DEVICE_ID_WINBOND_82C105    0x0105
+#define PCI_DEVICE_ID_WINBOND_83C553    0x0565
+
+#define PCI_VENDOR_ID_DATABOOK          0x10b3
+#define PCI_DEVICE_ID_DATABOOK_87144    0xb106
+
+#define PCI_VENDOR_ID_PLX               0x10b5
+#define PCI_DEVICE_ID_PLX_R685          0x1030
+#define PCI_DEVICE_ID_PLX_ROMULUS       0x106a
+#define PCI_DEVICE_ID_PLX_SPCOM800      0x1076
+#define PCI_DEVICE_ID_PLX_1077          0x1077
+#define PCI_DEVICE_ID_PLX_SPCOM200      0x1103
+#define PCI_DEVICE_ID_PLX_DJINN_ITOO    0x1151
+#define PCI_DEVICE_ID_PLX_R753          0x1152
+#define PCI_DEVICE_ID_PLX_9030          0x9030
+#define PCI_DEVICE_ID_PLX_9050          0x9050
+#define PCI_DEVICE_ID_PLX_9060          0x9060
+#define PCI_DEVICE_ID_PLX_9060ES        0x906E
+#define PCI_DEVICE_ID_PLX_9060SD        0x906D
+#define PCI_DEVICE_ID_PLX_9080          0x9080
+#define PCI_DEVICE_ID_PLX_GTEK_SERIAL2  0xa001
+
+#define PCI_VENDOR_ID_MADGE             0x10b6
+#define PCI_DEVICE_ID_MADGE_MK2         0x0002
+#define PCI_DEVICE_ID_MADGE_C155S       0x1001
+
+#define PCI_VENDOR_ID_3COM              0x10b7
+#define PCI_DEVICE_ID_3COM_3C985        0x0001
+#define PCI_DEVICE_ID_3COM_3C940        0x1700
+#define PCI_DEVICE_ID_3COM_3C339        0x3390
+#define PCI_DEVICE_ID_3COM_3C359        0x3590
+#define PCI_DEVICE_ID_3COM_3C590        0x5900
+#define PCI_DEVICE_ID_3COM_3C595TX      0x5950
+#define PCI_DEVICE_ID_3COM_3C595T4      0x5951
+#define PCI_DEVICE_ID_3COM_3C595MII     0x5952
+#define PCI_DEVICE_ID_3COM_3C940B       0x80eb
+#define PCI_DEVICE_ID_3COM_3C900TPO     0x9000
+#define PCI_DEVICE_ID_3COM_3C900COMBO   0x9001
+#define PCI_DEVICE_ID_3COM_3C905TX      0x9050
+#define PCI_DEVICE_ID_3COM_3C905T4      0x9051
+#define PCI_DEVICE_ID_3COM_3C905B_TX    0x9055
+#define PCI_DEVICE_ID_3COM_3CR990       0x9900
+#define PCI_DEVICE_ID_3COM_3CR990_TX_95 0x9902
+#define PCI_DEVICE_ID_3COM_3CR990_TX_97 0x9903
+#define PCI_DEVICE_ID_3COM_3CR990B      0x9904
+#define PCI_DEVICE_ID_3COM_3CR990_FX    0x9905
+#define PCI_DEVICE_ID_3COM_3CR990SVR95  0x9908
+#define PCI_DEVICE_ID_3COM_3CR990SVR97  0x9909
+#define PCI_DEVICE_ID_3COM_3CR990SVR    0x990a
+
+#define PCI_VENDOR_ID_SMC               0x10b8
+#define PCI_DEVICE_ID_SMC_EPIC100       0x0005
+
+#define PCI_VENDOR_ID_AL                0x10b9
+#define PCI_DEVICE_ID_AL_M1445          0x1445
+#define PCI_DEVICE_ID_AL_M1449          0x1449
+#define PCI_DEVICE_ID_AL_M1451          0x1451
+#define PCI_DEVICE_ID_AL_M1461          0x1461
+#define PCI_DEVICE_ID_AL_M1489          0x1489
+#define PCI_DEVICE_ID_AL_M1511          0x1511
+#define PCI_DEVICE_ID_AL_M1513          0x1513
+#define PCI_DEVICE_ID_AL_M1521          0x1521
+#define PCI_DEVICE_ID_AL_M1523          0x1523
+#define PCI_DEVICE_ID_AL_M1531          0x1531
+#define PCI_DEVICE_ID_AL_M1533          0x1533
+#define PCI_DEVICE_ID_AL_M1535          0x1535
+#define PCI_DEVICE_ID_AL_M1541          0x1541
+#define PCI_DEVICE_ID_AL_M1543          0x1543
+#define PCI_DEVICE_ID_AL_M1563          0x1563
+#define PCI_DEVICE_ID_AL_M1621          0x1621
+#define PCI_DEVICE_ID_AL_M1631          0x1631
+#define PCI_DEVICE_ID_AL_M1632          0x1632
+#define PCI_DEVICE_ID_AL_M1641          0x1641
+#define PCI_DEVICE_ID_AL_M1644          0x1644
+#define PCI_DEVICE_ID_AL_M1647          0x1647
+#define PCI_DEVICE_ID_AL_M1651          0x1651
+#define PCI_DEVICE_ID_AL_M1671          0x1671
+#define PCI_DEVICE_ID_AL_M1681          0x1681
+#define PCI_DEVICE_ID_AL_M1683          0x1683
+#define PCI_DEVICE_ID_AL_M1689          0x1689
+#define PCI_DEVICE_ID_AL_M3307          0x3307
+#define PCI_DEVICE_ID_AL_M4803          0x5215
+#define PCI_DEVICE_ID_AL_M5219          0x5219
+#define PCI_DEVICE_ID_AL_M5228          0x5228
+#define PCI_DEVICE_ID_AL_M5229          0x5229
+#define PCI_DEVICE_ID_AL_M5237          0x5237
+#define PCI_DEVICE_ID_AL_M5243          0x5243
+#define PCI_DEVICE_ID_AL_M5451          0x5451
+#define PCI_DEVICE_ID_AL_M7101          0x7101
+
+#define PCI_VENDOR_ID_MITSUBISHI        0x10ba
+
+#define PCI_VENDOR_ID_SURECOM           0x10bd
+#define PCI_DEVICE_ID_SURECOM_NE34      0x0e34
+
+#define PCI_VENDOR_ID_NEOMAGIC          0x10c8
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_NM2070 0x0001
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128V 0x0002
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128ZV 0x0003
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_NM2160 0x0004
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICMEDIA_256AV       0x0005
+#define PCI_DEVICE_ID_NEOMAGIC_MAGICGRAPH_128ZVPLUS   0x0083
+
+#define PCI_VENDOR_ID_ASP               0x10cd
+#define PCI_DEVICE_ID_ASP_ABP940        0x1200
+#define PCI_DEVICE_ID_ASP_ABP940U       0x1300
+#define PCI_DEVICE_ID_ASP_ABP940UW      0x2300
+
+#define PCI_VENDOR_ID_MACRONIX          0x10d9
+#define PCI_DEVICE_ID_MACRONIX_MX98713  0x0512
+#define PCI_DEVICE_ID_MACRONIX_MX987x5  0x0531
+
+#define PCI_VENDOR_ID_TCONRAD           0x10da
+#define PCI_DEVICE_ID_TCONRAD_TOKENRING 0x0508
+
+#define PCI_VENDOR_ID_CERN              0x10dc
+#define PCI_DEVICE_ID_CERN_SPSB_PMC     0x0001
+#define PCI_DEVICE_ID_CERN_SPSB_PCI     0x0002
+#define PCI_DEVICE_ID_CERN_HIPPI_DST    0x0021
+#define PCI_DEVICE_ID_CERN_HIPPI_SRC    0x0022
+
+#define PCI_VENDOR_ID_NVIDIA                    0x10de
+#define PCI_DEVICE_ID_NVIDIA_TNT                0x0020
+#define PCI_DEVICE_ID_NVIDIA_TNT2               0x0028
+#define PCI_DEVICE_ID_NVIDIA_UTNT2              0x0029
+#define PCI_DEVICE_ID_NVIDIA_TNT_UNKNOWN        0x002a
+#define PCI_DEVICE_ID_NVIDIA_VTNT2              0x002C
+#define PCI_DEVICE_ID_NVIDIA_UVTNT2             0x002D
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE   0x0035
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA  0x0036
+#define PCI_DEVICE_ID_NVIDIA_NVENET_10          0x0037
+#define PCI_DEVICE_ID_NVIDIA_NVENET_11          0x0038
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2 0x003e
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800_ULTRA 0x0040
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800       0x0041
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800_LE    0x0042
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800_GT    0x0045
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_4000     0x004E
+#define PCI_DEVICE_ID_NVIDIA_NFORCE4_SMBUS      0x0052
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE   0x0053
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA  0x0054
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2 0x0055
+#define PCI_DEVICE_ID_NVIDIA_NVENET_8           0x0056
+#define PCI_DEVICE_ID_NVIDIA_NVENET_9           0x0057
+#define PCI_DEVICE_ID_NVIDIA_CK804_AUDIO        0x0059
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS      0x0064
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE        0x0065
+#define PCI_DEVICE_ID_NVIDIA_NVENET_2           0x0066
+#define PCI_DEVICE_ID_NVIDIA_MCP2_AUDIO         0x006a
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2S_SMBUS     0x0084
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2S_IDE       0x0085
+#define PCI_DEVICE_ID_NVIDIA_NVENET_4           0x0086
+#define PCI_DEVICE_ID_NVIDIA_NVENET_5           0x008c
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA      0x008e
+#define PCI_DEVICE_ID_NVIDIA_ITNT2              0x00A0
+#define PCI_DEVICE_ID_GEFORCE_6800A             0x00c1
+#define PCI_DEVICE_ID_GEFORCE_6800A_LE          0x00c2
+#define PCI_DEVICE_ID_GEFORCE_GO_6800           0x00c8
+#define PCI_DEVICE_ID_GEFORCE_GO_6800_ULTRA     0x00c9
+#define PCI_DEVICE_ID_QUADRO_FX_GO1400          0x00cc
+#define PCI_DEVICE_ID_QUADRO_FX_1400            0x00ce
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3            0x00d1
+#define PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO         0x00da
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3_SMBUS      0x00d4
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE        0x00d5
+#define PCI_DEVICE_ID_NVIDIA_NVENET_3           0x00d6
+#define PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO         0x00da
+#define PCI_DEVICE_ID_NVIDIA_NVENET_7           0x00df
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3S           0x00e1
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA      0x00e3
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SMBUS     0x00e4
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3S_IDE       0x00e5
+#define PCI_DEVICE_ID_NVIDIA_NVENET_6           0x00e6
+#define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2     0x00ee
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR        0x0100
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR        0x0101
+#define PCI_DEVICE_ID_NVIDIA_QUADRO             0x0103
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX        0x0110
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX2       0x0111
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_GO        0x0112
+#define PCI_DEVICE_ID_NVIDIA_QUADRO2_MXR        0x0113
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6600_GT    0x0140
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6600       0x0141
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6610_XL    0x0145
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_540      0x014E
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6200       0x014F
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS       0x0150
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS2      0x0151
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE2_ULTRA     0x0152
+#define PCI_DEVICE_ID_NVIDIA_QUADRO2_PRO        0x0153
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6200_TURBOCACHE 0x0161
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_6200    0x0164
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_6250    0x0166
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_6200_1  0x0167
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_GO_6250_1  0x0168
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_460    0x0170
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440    0x0171
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_420    0x0172
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440_SE 0x0173
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO    0x0174
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO    0x0175
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO_M32 0x0176
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_460_GO    0x0177
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_500XGL     0x0178
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO_M64 0x0179
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_200        0x017A
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_550XGL     0x017B
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_500_GOGL   0x017C
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_410_GO_M16 0x017D
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440_8X 0x0181
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440SE_8X 0x0182
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_420_8X 0x0183
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_448_GO    0x0186
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_488_GO    0x0187
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_580_XGL    0x0188
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_MAC    0x0189
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_280_NVS    0x018A
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_380_XGL    0x018B
+#define PCI_DEVICE_ID_NVIDIA_IGEFORCE2          0x01a0
+#define PCI_DEVICE_ID_NVIDIA_NFORCE             0x01a4
+#define PCI_DEVICE_ID_NVIDIA_MCP1_AUDIO         0x01b1
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_SMBUS       0x01b4
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_IDE         0x01bc
+#define PCI_DEVICE_ID_NVIDIA_NVENET_1           0x01c3
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2            0x01e0
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE3           0x0200
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE3_1         0x0201
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE3_2         0x0202
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_DDC         0x0203
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800B      0x0211
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800B_LE   0x0212
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800B_GT   0x0215
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4600   0x0250
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4400   0x0251
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4200   0x0253
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_900XGL     0x0258
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_750XGL     0x0259
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_700XGL     0x025B
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800   0x0280
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800_8X    0x0281
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800SE     0x0282
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE4_4200_GO       0x0286
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_980_XGL        0x0288
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_780_XGL        0x0289
+#define PCI_DEVICE_ID_NVIDIA_QUADRO4_700_GOGL       0x028C
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5800_ULTRA  0x0301
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5800        0x0302
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_2000         0x0308
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_1000         0x0309
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5600_ULTRA  0x0311
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5600        0x0312
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5600SE      0x0314
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5600      0x031A
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5650      0x031B
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_GO700        0x031C
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5200        0x0320
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5200_ULTRA  0x0321
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5200_1      0x0322
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5200SE      0x0323
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5200      0x0324
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5250      0x0325
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5500        0x0326
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5100        0x0327
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5250_32   0x0328
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO_5200     0x0329
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_NVS_280_PCI     0x032A
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_500          0x032B
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5300      0x032C
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5100      0x032D
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5900_ULTRA  0x0330
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5900        0x0331
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5900XT      0x0332
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5950_ULTRA  0x0333
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5900ZT      0x0334
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_3000         0x0338
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_700          0x033F
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5700_ULTRA  0x0341
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5700        0x0342
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5700LE      0x0343
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_5700VE      0x0344
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5700_1    0x0347
+#define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5700_2    0x0348
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_GO1000       0x034C
+#define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_1100         0x034E
+
+#define PCI_VENDOR_ID_IMS               0x10e0
+#define PCI_DEVICE_ID_IMS_8849          0x8849
+#define PCI_DEVICE_ID_IMS_TT128         0x9128
+#define PCI_DEVICE_ID_IMS_TT3D          0x9135
+
+#define PCI_VENDOR_ID_TEKRAM2           0x10e1
+#define PCI_DEVICE_ID_TEKRAM2_690c      0x690c
+
+#define PCI_VENDOR_ID_TUNDRA            0x10e3
+#define PCI_DEVICE_ID_TUNDRA_CA91C042   0x0000
+
+#define PCI_VENDOR_ID_AMCC              0x10e8
+#define PCI_DEVICE_ID_AMCC_MYRINET      0x8043
+#define PCI_DEVICE_ID_AMCC_PARASTATION  0x8062
+#define PCI_DEVICE_ID_AMCC_S5933        0x807d
+#define PCI_DEVICE_ID_AMCC_S5933_HEPC3  0x809c
+
+#define PCI_VENDOR_ID_INTERG            0x10ea
+#define PCI_DEVICE_ID_INTERG_1680       0x1680
+#define PCI_DEVICE_ID_INTERG_1682       0x1682
+#define PCI_DEVICE_ID_INTERG_2000       0x2000
+#define PCI_DEVICE_ID_INTERG_2010       0x2010
+#define PCI_DEVICE_ID_INTERG_5000       0x5000
+#define PCI_DEVICE_ID_INTERG_5050       0x5050
+
+#define PCI_VENDOR_ID_REALTEK           0x10ec
+#define PCI_DEVICE_ID_REALTEK_8029      0x8029
+#define PCI_DEVICE_ID_REALTEK_8129      0x8129
+#define PCI_DEVICE_ID_REALTEK_8139      0x8139
+#define PCI_DEVICE_ID_REALTEK_8169      0x8169
+
+#define PCI_VENDOR_ID_XILINX            0x10ee
+#define PCI_DEVICE_ID_TURBOPAM          0x4020
+
+#define PCI_VENDOR_ID_TRUEVISION        0x10fa
+#define PCI_DEVICE_ID_TRUEVISION_T1000  0x000c
+
+#define PCI_VENDOR_ID_INIT              0x1101
+#define PCI_DEVICE_ID_INIT_320P         0x9100
+#define PCI_DEVICE_ID_INIT_360P         0x9500
+
+#define PCI_VENDOR_ID_CREATIVE          0x1102 // duplicate: ECTIVA
+#define PCI_DEVICE_ID_CREATIVE_EMU10K1  0x0002
+
+#define PCI_VENDOR_ID_ECTIVA            0x1102 // duplicate: CREATIVE
+#define PCI_DEVICE_ID_ECTIVA_EV1938     0x8938
+
+#define PCI_VENDOR_ID_TTI               0x1103
+#define PCI_DEVICE_ID_TTI_HPT343        0x0003
+#define PCI_DEVICE_ID_TTI_HPT366        0x0004
+#define PCI_DEVICE_ID_TTI_HPT372        0x0005
+#define PCI_DEVICE_ID_TTI_HPT302        0x0006
+#define PCI_DEVICE_ID_TTI_HPT371        0x0007
+#define PCI_DEVICE_ID_TTI_HPT374        0x0008
+#define PCI_DEVICE_ID_TTI_HPT372N       0x0009  // apparently a 372N variant?
+
+#define PCI_VENDOR_ID_VIA               0x1106
+#define PCI_DEVICE_ID_VIA_8763_0        0x0198
+#define PCI_DEVICE_ID_VIA_8380_0        0x0204
+#define PCI_DEVICE_ID_VIA_3238_0        0x0238
+#define PCI_DEVICE_ID_VIA_PT880         0x0258
+#define PCI_DEVICE_ID_VIA_PX8X0_0       0x0259
+#define PCI_DEVICE_ID_VIA_3269_0        0x0269
+#define PCI_DEVICE_ID_VIA_K8T800PRO_0   0x0282
+#define PCI_DEVICE_ID_VIA_8363_0        0x0305
+#define PCI_DEVICE_ID_VIA_8371_0        0x0391
+#define PCI_DEVICE_ID_VIA_8501_0        0x0501
+#define PCI_DEVICE_ID_VIA_82C505        0x0505
+#define PCI_DEVICE_ID_VIA_82C561        0x0561
+#define PCI_DEVICE_ID_VIA_82C586_1      0x0571
+#define PCI_DEVICE_ID_VIA_82C576        0x0576
+#define PCI_DEVICE_ID_VIA_82C585        0x0585
+#define PCI_DEVICE_ID_VIA_82C586_0      0x0586
+#define PCI_DEVICE_ID_VIA_82C595        0x0595
+#define PCI_DEVICE_ID_VIA_82C596        0x0596
+#define PCI_DEVICE_ID_VIA_82C597_0      0x0597
+#define PCI_DEVICE_ID_VIA_82C598_0      0x0598
+#define PCI_DEVICE_ID_VIA_8601_0        0x0601
+#define PCI_DEVICE_ID_VIA_8605_0        0x0605
+#define PCI_DEVICE_ID_VIA_82C680        0x0680
+#define PCI_DEVICE_ID_VIA_82C686        0x0686
+#define PCI_DEVICE_ID_VIA_82C691_0      0x0691
+#define PCI_DEVICE_ID_VIA_82C693        0x0693
+#define PCI_DEVICE_ID_VIA_82C693_1      0x0698
+#define PCI_DEVICE_ID_VIA_82C926        0x0926
+#define PCI_DEVICE_ID_VIA_82C576_1      0x1571
+#define PCI_DEVICE_ID_VIA_82C595_97     0x1595
+#define PCI_DEVICE_ID_VIA_82C586_2      0x3038
+#define PCI_DEVICE_ID_VIA_82C586_3      0x3040
+#define PCI_DEVICE_ID_VIA_6305          0x3044
+#define PCI_DEVICE_ID_VIA_82C596_3      0x3050
+#define PCI_DEVICE_ID_VIA_82C596B_3     0x3051
+#define PCI_DEVICE_ID_VIA_82C686_4      0x3057
+#define PCI_DEVICE_ID_VIA_82C686_5      0x3058
+#define PCI_DEVICE_ID_VIA_8233_5        0x3059
+#define PCI_DEVICE_ID_VIA_8233_7        0x3065
+#define PCI_DEVICE_ID_VIA_82C686_6      0x3068
+#define PCI_DEVICE_ID_VIA_8233_0        0x3074
+#define PCI_DEVICE_ID_VIA_8633_0        0x3091
+#define PCI_DEVICE_ID_VIA_8367_0        0x3099
+#define PCI_DEVICE_ID_VIA_8653_0        0x3101
+#define PCI_DEVICE_ID_VIA_8622          0x3102
+#define PCI_DEVICE_ID_VIA_8233C_0       0x3109
+#define PCI_DEVICE_ID_VIA_8361          0x3112
+#define PCI_DEVICE_ID_VIA_XM266         0x3116
+#define PCI_DEVICE_ID_VIA_612X          0x3119
+#define PCI_DEVICE_ID_VIA_862X_0        0x3123
+#define PCI_DEVICE_ID_VIA_8753_0        0x3128
+#define PCI_DEVICE_ID_VIA_8233A         0x3147
+#define PCI_DEVICE_ID_VIA_8703_51_0     0x3148
+#define PCI_DEVICE_ID_VIA_8237_SATA     0x3149
+#define PCI_DEVICE_ID_VIA_XN266         0x3156
+#define PCI_DEVICE_ID_VIA_8754C_0       0x3168
+#define PCI_DEVICE_ID_VIA_8235          0x3177
+#define PCI_DEVICE_ID_VIA_P4N333        0x3178
+#define PCI_DEVICE_ID_VIA_8385_0        0x3188
+#define PCI_DEVICE_ID_VIA_8377_0        0x3189
+#define PCI_DEVICE_ID_VIA_8378_0        0x3205
+#define PCI_DEVICE_ID_VIA_8783_0        0x3208
+#define PCI_DEVICE_ID_VIA_P4M400        0x3209
+#define PCI_DEVICE_ID_VIA_8237          0x3227
+#define PCI_DEVICE_ID_VIA_3296_0        0x0296
+#define PCI_DEVICE_ID_VIA_86C100A       0x6100
+#define PCI_DEVICE_ID_VIA_8231          0x8231
+#define PCI_DEVICE_ID_VIA_8231_4        0x8235
+#define PCI_DEVICE_ID_VIA_8365_1        0x8305
+#define PCI_DEVICE_ID_VIA_8371_1        0x8391
+#define PCI_DEVICE_ID_VIA_8501_1        0x8501
+#define PCI_DEVICE_ID_VIA_82C597_1      0x8597
+#define PCI_DEVICE_ID_VIA_82C598_1      0x8598
+#define PCI_DEVICE_ID_VIA_8601_1        0x8601
+#define PCI_DEVICE_ID_VIA_8505_1        0x8605
+#define PCI_DEVICE_ID_VIA_8633_1        0xB091
+#define PCI_DEVICE_ID_VIA_8367_1        0xB099
+#define PCI_DEVICE_ID_VIA_P4X266_1      0xB101
+#define PCI_DEVICE_ID_VIA_8615_1        0xB103
+#define PCI_DEVICE_ID_VIA_8361_1        0xB112
+#define PCI_DEVICE_ID_VIA_8235_1        0xB168
+#define PCI_DEVICE_ID_VIA_838X_1        0xB188
+#define PCI_DEVICE_ID_VIA_83_87XX_1     0xB198
+
+#define PCI_VENDOR_ID_SIEMENS           0x110A
+#define PCI_DEVICE_ID_SIEMENS_DSCC4     0x2102
+
+#define PCI_VENDOR_ID_SMC2              0x1113
+#define PCI_DEVICE_ID_SMC2_1211TX       0x1211
+
+#define PCI_VENDOR_ID_VORTEX            0x1119
+#define PCI_DEVICE_ID_VORTEX_GDT60x0    0x0000
+#define PCI_DEVICE_ID_VORTEX_GDT6000B   0x0001
+#define PCI_DEVICE_ID_VORTEX_GDT6x10    0x0002
+#define PCI_DEVICE_ID_VORTEX_GDT6x20    0x0003
+#define PCI_DEVICE_ID_VORTEX_GDT6530    0x0004
+#define PCI_DEVICE_ID_VORTEX_GDT6550    0x0005
+#define PCI_DEVICE_ID_VORTEX_GDT6x17    0x0006
+#define PCI_DEVICE_ID_VORTEX_GDT6x27    0x0007
+#define PCI_DEVICE_ID_VORTEX_GDT6537    0x0008
+#define PCI_DEVICE_ID_VORTEX_GDT6557    0x0009
+#define PCI_DEVICE_ID_VORTEX_GDT6x15    0x000a
+#define PCI_DEVICE_ID_VORTEX_GDT6x25    0x000b
+#define PCI_DEVICE_ID_VORTEX_GDT6535    0x000c
+#define PCI_DEVICE_ID_VORTEX_GDT6555    0x000d
+#define PCI_DEVICE_ID_VORTEX_GDT6x17RP  0x0100
+#define PCI_DEVICE_ID_VORTEX_GDT6x27RP  0x0101
+#define PCI_DEVICE_ID_VORTEX_GDT6537RP  0x0102
+#define PCI_DEVICE_ID_VORTEX_GDT6557RP  0x0103
+#define PCI_DEVICE_ID_VORTEX_GDT6x11RP  0x0104
+#define PCI_DEVICE_ID_VORTEX_GDT6x21RP  0x0105
+#define PCI_DEVICE_ID_VORTEX_GDT6x17RP1 0x0110
+#define PCI_DEVICE_ID_VORTEX_GDT6x27RP1 0x0111
+#define PCI_DEVICE_ID_VORTEX_GDT6537RP1 0x0112
+#define PCI_DEVICE_ID_VORTEX_GDT6557RP1 0x0113
+#define PCI_DEVICE_ID_VORTEX_GDT6x11RP1 0x0114
+#define PCI_DEVICE_ID_VORTEX_GDT6x21RP1 0x0115
+#define PCI_DEVICE_ID_VORTEX_GDT6x17RP2 0x0120
+#define PCI_DEVICE_ID_VORTEX_GDT6x27RP2 0x0121
+#define PCI_DEVICE_ID_VORTEX_GDT6537RP2 0x0122
+#define PCI_DEVICE_ID_VORTEX_GDT6557RP2 0x0123
+#define PCI_DEVICE_ID_VORTEX_GDT6x11RP2 0x0124
+#define PCI_DEVICE_ID_VORTEX_GDT6x21RP2 0x0125
+
+#define PCI_VENDOR_ID_EF                0x111a
+#define PCI_DEVICE_ID_EF_ATM_FPGA       0x0000
+#define PCI_DEVICE_ID_EF_ATM_ASIC       0x0002
+#define PCI_VENDOR_ID_EF_ATM_LANAI2     0x0003
+#define PCI_VENDOR_ID_EF_ATM_LANAIHB    0x0005
+
+#define PCI_VENDOR_ID_IDT               0x111d
+#define PCI_DEVICE_ID_IDT_IDT77201      0x0001
+
+#define PCI_VENDOR_ID_FORE              0x1127
+#define PCI_DEVICE_ID_FORE_PCA200PC     0x0210
+#define PCI_DEVICE_ID_FORE_PCA200E      0x0300
+
+#define PCI_VENDOR_ID_IMAGINGTECH       0x112f
+#define PCI_DEVICE_ID_IMAGINGTECH_ICPCI 0x0000
+
+#define PCI_VENDOR_ID_PHILIPS           0x1131
+#define PCI_DEVICE_ID_PHILIPS_SAA7145   0x7145
+#define PCI_DEVICE_ID_PHILIPS_SAA7146   0x7146
+#define PCI_DEVICE_ID_PHILIPS_SAA9730   0x9730
+
+#define PCI_VENDOR_ID_EICON             0x1133
+#define PCI_DEVICE_ID_EICON_DIVA20PRO   0xe001
+#define PCI_DEVICE_ID_EICON_DIVA20      0xe002
+#define PCI_DEVICE_ID_EICON_DIVA20PRO_U 0xe003
+#define PCI_DEVICE_ID_EICON_DIVA20_U    0xe004
+#define PCI_DEVICE_ID_EICON_DIVA201     0xe005
+#define PCI_DEVICE_ID_EICON_DIVA202     0xe00b
+#define PCI_DEVICE_ID_EICON_MAESTRA     0xe010
+#define PCI_DEVICE_ID_EICON_MAESTRAQ    0xe012
+#define PCI_DEVICE_ID_EICON_MAESTRAQ_U  0xe013
+#define PCI_DEVICE_ID_EICON_MAESTRAP    0xe014
+
+#define PCI_VENDOR_ID_ZIATECH           0x1138
+#define PCI_DEVICE_ID_ZIATECH_5550_HC   0x5550
+ 
+#define PCI_VENDOR_ID_CYCLONE           0x113c
+#define PCI_DEVICE_ID_CYCLONE_SDK       0x0001
+
+#define PCI_VENDOR_ID_ALLIANCE          0x1142
+#define PCI_DEVICE_ID_ALLIANCE_PROMOTIO 0x3210
+#define PCI_DEVICE_ID_ALLIANCE_PROVIDEO 0x6422
+#define PCI_DEVICE_ID_ALLIANCE_AT24     0x6424
+#define PCI_DEVICE_ID_ALLIANCE_AT3D     0x643d
+
+#define PCI_VENDOR_ID_SYSKONNECT        0x1148
+#define PCI_DEVICE_ID_SYSKONNECT_FP     0x4000
+#define PCI_DEVICE_ID_SYSKONNECT_TR     0x4200
+#define PCI_DEVICE_ID_SYSKONNECT_GE     0x4300
+#define PCI_DEVICE_ID_SYSKONNECT_YU     0x4320
+#define PCI_DEVICE_ID_SYSKONNECT_9DXX   0x4400
+#define PCI_DEVICE_ID_SYSKONNECT_9MXX   0x4500
+
+#define PCI_VENDOR_ID_VMIC              0x114a
+#define PCI_DEVICE_ID_VMIC_VME          0x7587
+
+#define PCI_VENDOR_ID_DIGI              0x114f
+#define PCI_DEVICE_ID_DIGI_EPC          0x0002
+#define PCI_DEVICE_ID_DIGI_RIGHTSWITCH  0x0003
+#define PCI_DEVICE_ID_DIGI_XEM          0x0004
+#define PCI_DEVICE_ID_DIGI_XR           0x0005
+#define PCI_DEVICE_ID_DIGI_CX           0x0006
+#define PCI_DEVICE_ID_DIGI_XRJ          0x0009
+#define PCI_DEVICE_ID_DIGI_EPCJ         0x000a
+#define PCI_DEVICE_ID_DIGI_XR_920       0x0027
+#define PCI_DEVICE_ID_DIGI_DF_M_IOM2_E  0x0070
+#define PCI_DEVICE_ID_DIGI_DF_M_E       0x0071
+#define PCI_DEVICE_ID_DIGI_DF_M_IOM2_A  0x0072
+#define PCI_DEVICE_ID_DIGI_DF_M_A       0x0073
+#define PCI_DEVICE_ID_NEO_2DB9          0x00C8
+#define PCI_DEVICE_ID_NEO_2DB9PRI       0x00C9
+#define PCI_DEVICE_ID_NEO_2RJ45         0x00CA
+#define PCI_DEVICE_ID_NEO_2RJ45PRI      0x00CB
+
+#define PCI_VENDOR_ID_MUTECH            0x1159
+#define PCI_DEVICE_ID_MUTECH_MV1000     0x0001
+
+#define PCI_VENDOR_ID_XIRCOM            0x115d
+#define PCI_DEVICE_ID_XIRCOM_X3201_ETH  0x0003
+#define PCI_DEVICE_ID_XIRCOM_RBM56G     0x0101
+#define PCI_DEVICE_ID_XIRCOM_X3201_MDM  0x0103
+
+#define PCI_VENDOR_ID_RENDITION         0x1163
+#define PCI_DEVICE_ID_RENDITION_VERITE  0x0001
+#define PCI_DEVICE_ID_RENDITION_VERITE2100 0x2000
+
+#define PCI_VENDOR_ID_SERVERWORKS         0x1166
+#define PCI_DEVICE_ID_SERVERWORKS_HE      0x0008
+#define PCI_DEVICE_ID_SERVERWORKS_LE      0x0009
+#define PCI_DEVICE_ID_SERVERWORKS_CIOB30  0x0010
+#define PCI_DEVICE_ID_SERVERWORKS_CMIC_HE 0x0011
+#define PCI_DEVICE_ID_SERVERWORKS_GCNB_LE 0x0017
+#define PCI_DEVICE_ID_SERVERWORKS_OSB4    0x0200
+#define PCI_DEVICE_ID_SERVERWORKS_CSB5    0x0201
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6    0x0203
+#define PCI_DEVICE_ID_SERVERWORKS_OSB4IDE 0x0211
+#define PCI_DEVICE_ID_SERVERWORKS_CSB5IDE 0x0212
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE 0x0213
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2 0x0217
+#define PCI_DEVICE_ID_SERVERWORKS_OSB4USB 0x0220
+#define PCI_DEVICE_ID_SERVERWORKS_CSB5USB PCI_DEVICE_ID_SERVERWORKS_OSB4USB
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6USB 0x0221
+#define PCI_DEVICE_ID_SERVERWORKS_GCLE    0x0225
+#define PCI_DEVICE_ID_SERVERWORKS_GCLE2   0x0227
+#define PCI_DEVICE_ID_SERVERWORKS_CSB5ISA 0x0230
+
+#define PCI_VENDOR_ID_SBE               0x1176
+#define PCI_DEVICE_ID_SBE_WANXL100      0x0301
+#define PCI_DEVICE_ID_SBE_WANXL200      0x0302
+#define PCI_DEVICE_ID_SBE_WANXL400      0x0104
+
+#define PCI_VENDOR_ID_TOSHIBA           0x1179
+#define PCI_DEVICE_ID_TOSHIBA_PICCOLO   0x0102
+#define PCI_DEVICE_ID_TOSHIBA_PICCOLO_1 0x0103
+#define PCI_DEVICE_ID_TOSHIBA_PICCOLO_2 0x0105
+#define PCI_DEVICE_ID_TOSHIBA_601       0x0601
+#define PCI_DEVICE_ID_TOSHIBA_TOPIC95   0x060a
+#define PCI_DEVICE_ID_TOSHIBA_TOPIC95_A 0x0603
+#define PCI_DEVICE_ID_TOSHIBA_TOPIC95_B 0x060a
+#define PCI_DEVICE_ID_TOSHIBA_TOPIC97   0x060f
+#define PCI_DEVICE_ID_TOSHIBA_TOPIC100  0x0617
+
+#define PCI_VENDOR_ID_TOSHIBA_2         0x102f
+#define PCI_DEVICE_ID_TOSHIBA_TX3927    0x000a
+#define PCI_DEVICE_ID_TOSHIBA_TC35815CF 0x0030
+#define PCI_DEVICE_ID_TOSHIBA_TX4927    0x0180
+#define PCI_DEVICE_ID_TOSHIBA_TC86C001_MISC     0x0108
+
+#define PCI_VENDOR_ID_RICOH             0x1180
+#define PCI_DEVICE_ID_RICOH_RL5C465     0x0465
+#define PCI_DEVICE_ID_RICOH_RL5C466     0x0466
+#define PCI_DEVICE_ID_RICOH_RL5C475     0x0475
+#define PCI_DEVICE_ID_RICOH_RL5C476     0x0476
+#define PCI_DEVICE_ID_RICOH_RL5C478     0x0478
+
+#define PCI_VENDOR_ID_DLINK             0x1186
+#define PCI_DEVICE_ID_DLINK_DGE510T     0x4c00
+
+#define PCI_VENDOR_ID_ARTOP             0x1191
+#define PCI_DEVICE_ID_ARTOP_ATP8400     0x0004
+#define PCI_DEVICE_ID_ARTOP_ATP850UF    0x0005
+#define PCI_DEVICE_ID_ARTOP_ATP860      0x0006
+#define PCI_DEVICE_ID_ARTOP_ATP860R     0x0007
+#define PCI_DEVICE_ID_ARTOP_ATP865      0x0008
+#define PCI_DEVICE_ID_ARTOP_ATP865R     0x0009
+#define PCI_DEVICE_ID_ARTOP_AEC7610     0x8002
+#define PCI_DEVICE_ID_ARTOP_AEC7612UW   0x8010
+#define PCI_DEVICE_ID_ARTOP_AEC7612U    0x8020
+#define PCI_DEVICE_ID_ARTOP_AEC7612S    0x8030
+#define PCI_DEVICE_ID_ARTOP_AEC7612D    0x8040
+#define PCI_DEVICE_ID_ARTOP_AEC7612SUW  0x8050
+#define PCI_DEVICE_ID_ARTOP_8060        0x8060
+#define PCI_DEVICE_ID_ARTOP_AEC67160    0x8080
+#define PCI_DEVICE_ID_ARTOP_AEC67160_2  0x8081
+#define PCI_DEVICE_ID_ARTOP_AEC67162    0x808a
+
+#define PCI_VENDOR_ID_ZEITNET           0x1193
+#define PCI_DEVICE_ID_ZEITNET_1221      0x0001
+#define PCI_DEVICE_ID_ZEITNET_1225      0x0002
+
+#define PCI_VENDOR_ID_OMEGA             0x119b
+#define PCI_DEVICE_ID_OMEGA_82C092G     0x1221
+
+#define PCI_VENDOR_ID_FUJITSU_ME        0x119e
+#define PCI_DEVICE_ID_FUJITSU_FS155     0x0001
+#define PCI_DEVICE_ID_FUJITSU_FS50      0x0003
+
+#define PCI_SUBVENDOR_ID_KEYSPAN        0x11a9
+#define PCI_SUBDEVICE_ID_KEYSPAN_SX2    0x5334
+
+#define PCI_VENDOR_ID_MARVELL           0x11ab
+#define PCI_DEVICE_ID_MARVELL_GT64011   0x4146
+#define PCI_DEVICE_ID_MARVELL_GT64111   0x4146
+#define PCI_DEVICE_ID_MARVELL_GT64260   0x6430
+#define PCI_DEVICE_ID_MARVELL_MV64360   0x6460
+#define PCI_DEVICE_ID_MARVELL_MV64460   0x6480
+#define PCI_DEVICE_ID_MARVELL_GT96100   0x9652
+#define PCI_DEVICE_ID_MARVELL_GT96100A  0x9653
+
+#define PCI_VENDOR_ID_LITEON            0x11ad
+#define PCI_DEVICE_ID_LITEON_LNE100TX   0x0002
+
+#define PCI_VENDOR_ID_V3                0x11b0
+#define PCI_DEVICE_ID_V3_V960           0x0001
+#define PCI_DEVICE_ID_V3_V350           0x0001
+#define PCI_DEVICE_ID_V3_V961           0x0002
+#define PCI_DEVICE_ID_V3_V351           0x0002
+
+#define PCI_VENDOR_ID_NP                0x11bc
+#define PCI_DEVICE_ID_NP_PCI_FDDI       0x0001
+
+#define PCI_VENDOR_ID_ATT               0x11c1
+#define PCI_DEVICE_ID_ATT_L56XMF        0x0440
+#define PCI_DEVICE_ID_ATT_VENUS_MODEM   0x480
+
+#define PCI_VENDOR_ID_NEC2              0x11c3 /* NEC (2nd) */
+
+#define PCI_VENDOR_ID_SPECIALIX         0x11cb
+#define PCI_DEVICE_ID_SPECIALIX_IO8     0x2000
+#define PCI_DEVICE_ID_SPECIALIX_XIO     0x4000
+#define PCI_DEVICE_ID_SPECIALIX_RIO     0x8000
+#define PCI_SUBDEVICE_ID_SPECIALIX_SPEED4 0xa004
+
+#define PCI_VENDOR_ID_AURAVISION        0x11d1
+#define PCI_DEVICE_ID_AURAVISION_VXP524 0x01f7
+
+#define PCI_VENDOR_ID_ANALOG_DEVICES    0x11d4
+#define PCI_DEVICE_ID_AD1889JS          0x1889
+
+#define PCI_VENDOR_ID_IKON              0x11d5
+#define PCI_DEVICE_ID_IKON_10115        0x0115
+#define PCI_DEVICE_ID_IKON_10117        0x0117
+
+#define PCI_VENDOR_ID_SEGA              0x11db
+#define PCI_DEVICE_ID_SEGA_BBA          0x1234
+
+#define PCI_VENDOR_ID_ZORAN             0x11de
+#define PCI_DEVICE_ID_ZORAN_36057       0x6057
+#define PCI_DEVICE_ID_ZORAN_36120       0x6120
+
+#define PCI_VENDOR_ID_KINETIC           0x11f4
+#define PCI_DEVICE_ID_KINETIC_2915      0x2915
+
+#define PCI_VENDOR_ID_COMPEX            0x11f6
+#define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
+#define PCI_DEVICE_ID_COMPEX_RL2000     0x1401
+
+#define PCI_VENDOR_ID_RP                0x11fe
+#define PCI_DEVICE_ID_RP32INTF          0x0001
+#define PCI_DEVICE_ID_RP8INTF           0x0002
+#define PCI_DEVICE_ID_RP16INTF          0x0003
+#define PCI_DEVICE_ID_RP4QUAD           0x0004
+#define PCI_DEVICE_ID_RP8OCTA           0x0005
+#define PCI_DEVICE_ID_RP8J              0x0006
+#define PCI_DEVICE_ID_RP4J              0x0007
+#define PCI_DEVICE_ID_RP8SNI            0x0008  
+#define PCI_DEVICE_ID_RP16SNI           0x0009  
+#define PCI_DEVICE_ID_RPP4              0x000A
+#define PCI_DEVICE_ID_RPP8              0x000B
+#define PCI_DEVICE_ID_RP8M              0x000C
+#define PCI_DEVICE_ID_RP4M              0x000D
+#define PCI_DEVICE_ID_RP2_232           0x000E
+#define PCI_DEVICE_ID_RP2_422           0x000F
+#define PCI_DEVICE_ID_URP32INTF         0x0801
+#define PCI_DEVICE_ID_URP8INTF          0x0802
+#define PCI_DEVICE_ID_URP16INTF         0x0803
+#define PCI_DEVICE_ID_URP8OCTA          0x0805
+#define PCI_DEVICE_ID_UPCI_RM3_8PORT    0x080C       
+#define PCI_DEVICE_ID_UPCI_RM3_4PORT    0x080D
+#define PCI_DEVICE_ID_CRP16INTF         0x0903       
+
+#define PCI_VENDOR_ID_CYCLADES          0x120e
+#define PCI_DEVICE_ID_CYCLOM_Y_Lo       0x0100
+#define PCI_DEVICE_ID_CYCLOM_Y_Hi       0x0101
+#define PCI_DEVICE_ID_CYCLOM_4Y_Lo      0x0102
+#define PCI_DEVICE_ID_CYCLOM_4Y_Hi      0x0103
+#define PCI_DEVICE_ID_CYCLOM_8Y_Lo      0x0104
+#define PCI_DEVICE_ID_CYCLOM_8Y_Hi      0x0105
+#define PCI_DEVICE_ID_CYCLOM_Z_Lo       0x0200
+#define PCI_DEVICE_ID_CYCLOM_Z_Hi       0x0201
+#define PCI_DEVICE_ID_PC300_RX_2        0x0300
+#define PCI_DEVICE_ID_PC300_RX_1        0x0301
+#define PCI_DEVICE_ID_PC300_TE_2        0x0310
+#define PCI_DEVICE_ID_PC300_TE_1        0x0311
+#define PCI_DEVICE_ID_PC300_TE_M_2      0x0320
+#define PCI_DEVICE_ID_PC300_TE_M_1      0x0321
+
+/* Allied Telesyn */
+#define PCI_VENDOR_ID_AT                0x1259
+#define PCI_SUBDEVICE_ID_AT_2701FX      0x2703
+
+#define PCI_VENDOR_ID_ESSENTIAL         0x120f
+#define PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER      0x0001
+
+#define PCI_VENDOR_ID_O2                0x1217
+#define PCI_DEVICE_ID_O2_6729           0x6729
+#define PCI_DEVICE_ID_O2_6730           0x673a
+#define PCI_DEVICE_ID_O2_6832           0x6832
+#define PCI_DEVICE_ID_O2_6836           0x6836
+
+#define PCI_VENDOR_ID_3DFX              0x121a
+#define PCI_DEVICE_ID_3DFX_VOODOO       0x0001
+#define PCI_DEVICE_ID_3DFX_VOODOO2      0x0002
+#define PCI_DEVICE_ID_3DFX_BANSHEE      0x0003
+#define PCI_DEVICE_ID_3DFX_VOODOO3      0x0005
+#define PCI_DEVICE_ID_3DFX_VOODOO5      0x0009
+
+#define PCI_VENDOR_ID_SIGMADES          0x1236
+#define PCI_DEVICE_ID_SIGMADES_6425     0x6401
+
+#define PCI_VENDOR_ID_CCUBE             0x123f
+
+#define PCI_VENDOR_ID_AVM               0x1244
+#define PCI_DEVICE_ID_AVM_B1            0x0700
+#define PCI_DEVICE_ID_AVM_C4            0x0800
+#define PCI_DEVICE_ID_AVM_A1            0x0a00
+#define PCI_DEVICE_ID_AVM_A1_V2         0x0e00
+#define PCI_DEVICE_ID_AVM_C2            0x1100
+#define PCI_DEVICE_ID_AVM_T1            0x1200
+
+#define PCI_VENDOR_ID_DIPIX             0x1246
+
+#define PCI_VENDOR_ID_STALLION          0x124d
+#define PCI_DEVICE_ID_STALLION_ECHPCI832 0x0000
+#define PCI_DEVICE_ID_STALLION_ECHPCI864 0x0002
+#define PCI_DEVICE_ID_STALLION_EIOPCI   0x0003
+
+#define PCI_VENDOR_ID_OPTIBASE          0x1255
+#define PCI_DEVICE_ID_OPTIBASE_FORGE    0x1110
+#define PCI_DEVICE_ID_OPTIBASE_FUSION   0x1210
+#define PCI_DEVICE_ID_OPTIBASE_VPLEX    0x2110
+#define PCI_DEVICE_ID_OPTIBASE_VPLEXCC  0x2120
+#define PCI_DEVICE_ID_OPTIBASE_VQUEST   0x2130
+
+/* Allied Telesyn */
+#define PCI_VENDOR_ID_AT                0x1259
+#define PCI_SUBDEVICE_ID_AT_2700FX      0x2701
+#define PCI_SUBDEVICE_ID_AT_2701FX      0x2703
+
+#define PCI_VENDOR_ID_ESS               0x125d
+#define PCI_DEVICE_ID_ESS_ESS1968       0x1968
+#define PCI_DEVICE_ID_ESS_AUDIOPCI      0x1969
+#define PCI_DEVICE_ID_ESS_ESS1978       0x1978
+
+#define PCI_VENDOR_ID_SATSAGEM          0x1267
+#define PCI_DEVICE_ID_SATSAGEM_NICCY    0x1016
+#define PCI_DEVICE_ID_SATSAGEM_PCR2101  0x5352
+#define PCI_DEVICE_ID_SATSAGEM_TELSATTURBO 0x5a4b
+
+#define PCI_VENDOR_ID_HUGHES            0x1273
+#define PCI_DEVICE_ID_HUGHES_DIRECPC    0x0002
+
+#define PCI_VENDOR_ID_ENSONIQ           0x1274
+#define PCI_DEVICE_ID_ENSONIQ_CT5880    0x5880
+#define PCI_DEVICE_ID_ENSONIQ_ES1370    0x5000
+#define PCI_DEVICE_ID_ENSONIQ_ES1371    0x1371
+
+#define PCI_VENDOR_ID_TRANSMETA         0x1279
+#define PCI_DEVICE_ID_EFFICEON          0x0060
+
+#define PCI_VENDOR_ID_ROCKWELL          0x127A
+
+#define PCI_VENDOR_ID_ITE               0x1283
+#define PCI_DEVICE_ID_ITE_IT8172G       0x8172
+#define PCI_DEVICE_ID_ITE_IT8172G_AUDIO 0x0801
+#define PCI_DEVICE_ID_ITE_8872          0x8872
+#define PCI_DEVICE_ID_ITE_IT8330G_0     0xe886
+
+/* formerly Platform Tech */
+#define PCI_VENDOR_ID_ESS_OLD           0x1285
+#define PCI_DEVICE_ID_ESS_ESS0100       0x0100
+
+#define PCI_VENDOR_ID_ALTEON            0x12ae
+#define PCI_DEVICE_ID_ALTEON_ACENIC     0x0001
+
+#define PCI_VENDOR_ID_USR               0x12B9
+
+#define PCI_SUBVENDOR_ID_CONNECT_TECH                   0x12c4
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232           0x0001
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232           0x0002
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_232           0x0003
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485           0x0004
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_4_4       0x0005
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485           0x0006
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485_2_2       0x0007
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_485           0x0008
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_2_6       0x0009
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH081101V1        0x000A
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH041101V1        0x000B
+
+#define PCI_VENDOR_ID_PICTUREL          0x12c5
+#define PCI_DEVICE_ID_PICTUREL_PCIVST   0x0081
+
+#define PCI_VENDOR_ID_NVIDIA_SGS        0x12d2
+#define PCI_DEVICE_ID_NVIDIA_SGS_RIVA128 0x0018
+
+#define PCI_SUBVENDOR_ID_CHASE_PCIFAST          0x12E0
+#define PCI_SUBDEVICE_ID_CHASE_PCIFAST4         0x0031
+#define PCI_SUBDEVICE_ID_CHASE_PCIFAST8         0x0021
+#define PCI_SUBDEVICE_ID_CHASE_PCIFAST16        0x0011
+#define PCI_SUBDEVICE_ID_CHASE_PCIFAST16FMC     0x0041
+#define PCI_SUBVENDOR_ID_CHASE_PCIRAS           0x124D
+#define PCI_SUBDEVICE_ID_CHASE_PCIRAS4          0xF001
+#define PCI_SUBDEVICE_ID_CHASE_PCIRAS8          0xF010
+
+#define PCI_VENDOR_ID_AUREAL            0x12eb
+#define PCI_DEVICE_ID_AUREAL_VORTEX_1   0x0001
+#define PCI_DEVICE_ID_AUREAL_VORTEX_2   0x0002
+#define PCI_DEVICE_ID_AUREAL_ADVANTAGE  0x0003
+
+#define PCI_VENDOR_ID_ELECTRONICDESIGNGMBH 0x12f8
+#define PCI_DEVICE_ID_LML_33R10         0x8a02
+
+#define PCI_VENDOR_ID_CBOARDS           0x1307
+#define PCI_DEVICE_ID_CBOARDS_DAS1602_16 0x0001
+
+#define PCI_VENDOR_ID_SIIG              0x131f
+#define PCI_DEVICE_ID_SIIG_1S_10x_550   0x1000
+#define PCI_DEVICE_ID_SIIG_1S_10x_650   0x1001
+#define PCI_DEVICE_ID_SIIG_1S_10x_850   0x1002
+#define PCI_DEVICE_ID_SIIG_1S1P_10x_550 0x1010
+#define PCI_DEVICE_ID_SIIG_1S1P_10x_650 0x1011
+#define PCI_DEVICE_ID_SIIG_1S1P_10x_850 0x1012
+#define PCI_DEVICE_ID_SIIG_1P_10x       0x1020
+#define PCI_DEVICE_ID_SIIG_2P_10x       0x1021
+#define PCI_DEVICE_ID_SIIG_2S_10x_550   0x1030
+#define PCI_DEVICE_ID_SIIG_2S_10x_650   0x1031
+#define PCI_DEVICE_ID_SIIG_2S_10x_850   0x1032
+#define PCI_DEVICE_ID_SIIG_2S1P_10x_550 0x1034
+#define PCI_DEVICE_ID_SIIG_2S1P_10x_650 0x1035
+#define PCI_DEVICE_ID_SIIG_2S1P_10x_850 0x1036
+#define PCI_DEVICE_ID_SIIG_4S_10x_550   0x1050
+#define PCI_DEVICE_ID_SIIG_4S_10x_650   0x1051
+#define PCI_DEVICE_ID_SIIG_4S_10x_850   0x1052
+#define PCI_DEVICE_ID_SIIG_1S_20x_550   0x2000
+#define PCI_DEVICE_ID_SIIG_1S_20x_650   0x2001
+#define PCI_DEVICE_ID_SIIG_1S_20x_850   0x2002
+#define PCI_DEVICE_ID_SIIG_1P_20x       0x2020
+#define PCI_DEVICE_ID_SIIG_2P_20x       0x2021
+#define PCI_DEVICE_ID_SIIG_2S_20x_550   0x2030
+#define PCI_DEVICE_ID_SIIG_2S_20x_650   0x2031
+#define PCI_DEVICE_ID_SIIG_2S_20x_850   0x2032
+#define PCI_DEVICE_ID_SIIG_2P1S_20x_550 0x2040
+#define PCI_DEVICE_ID_SIIG_2P1S_20x_650 0x2041
+#define PCI_DEVICE_ID_SIIG_2P1S_20x_850 0x2042
+#define PCI_DEVICE_ID_SIIG_1S1P_20x_550 0x2010
+#define PCI_DEVICE_ID_SIIG_1S1P_20x_650 0x2011
+#define PCI_DEVICE_ID_SIIG_1S1P_20x_850 0x2012
+#define PCI_DEVICE_ID_SIIG_4S_20x_550   0x2050
+#define PCI_DEVICE_ID_SIIG_4S_20x_650   0x2051
+#define PCI_DEVICE_ID_SIIG_4S_20x_850   0x2052
+#define PCI_DEVICE_ID_SIIG_2S1P_20x_550 0x2060
+#define PCI_DEVICE_ID_SIIG_2S1P_20x_650 0x2061
+#define PCI_DEVICE_ID_SIIG_2S1P_20x_850 0x2062
+
+#define PCI_VENDOR_ID_RADISYS           0x1331
+#define PCI_DEVICE_ID_RADISYS_ENP2611   0x0030
+
+#define PCI_VENDOR_ID_DOMEX             0x134a
+#define PCI_DEVICE_ID_DOMEX_DMX3191D    0x0001
+
+#define PCI_VENDOR_ID_QUATECH           0x135C
+#define PCI_DEVICE_ID_QUATECH_QSC100    0x0010
+#define PCI_DEVICE_ID_QUATECH_DSC100    0x0020
+#define PCI_DEVICE_ID_QUATECH_DSC200    0x0030
+#define PCI_DEVICE_ID_QUATECH_QSC200    0x0040
+#define PCI_DEVICE_ID_QUATECH_ESC100D   0x0050
+#define PCI_DEVICE_ID_QUATECH_ESC100M   0x0060
+
+#define PCI_VENDOR_ID_SEALEVEL          0x135e
+#define PCI_DEVICE_ID_SEALEVEL_U530     0x7101
+#define PCI_DEVICE_ID_SEALEVEL_UCOMM2   0x7201
+#define PCI_DEVICE_ID_SEALEVEL_UCOMM422 0x7402
+#define PCI_DEVICE_ID_SEALEVEL_UCOMM232 0x7202
+#define PCI_DEVICE_ID_SEALEVEL_COMM4    0x7401
+#define PCI_DEVICE_ID_SEALEVEL_COMM8    0x7801
+#define PCI_DEVICE_ID_SEALEVEL_UCOMM8   0x7804
+
+#define PCI_VENDOR_ID_HYPERCOPE         0x1365
+#define PCI_DEVICE_ID_HYPERCOPE_PLX     0x9050
+#define PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO     0x0104
+#define PCI_SUBDEVICE_ID_HYPERCOPE_ERGO         0x0106
+#define PCI_SUBDEVICE_ID_HYPERCOPE_METRO        0x0107
+#define PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2       0x0108
+#define PCI_SUBDEVICE_ID_HYPERCOPE_PLEXUS       0x0109
+
+#define PCI_VENDOR_ID_KAWASAKI          0x136b
+#define PCI_DEVICE_ID_MCHIP_KL5A72002   0xff01
+
+#define PCI_VENDOR_ID_CNET              0x1371
+#define PCI_DEVICE_ID_CNET_GIGACARD     0x434e
+
+#define PCI_VENDOR_ID_LMC               0x1376
+#define PCI_DEVICE_ID_LMC_HSSI          0x0003
+#define PCI_DEVICE_ID_LMC_DS3           0x0004
+#define PCI_DEVICE_ID_LMC_SSI           0x0005
+#define PCI_DEVICE_ID_LMC_T1            0x0006
+
+#define PCI_VENDOR_ID_NETGEAR           0x1385
+#define PCI_DEVICE_ID_NETGEAR_GA620     0x620a
+#define PCI_DEVICE_ID_NETGEAR_GA622     0x622a
+
+#define PCI_VENDOR_ID_APPLICOM          0x1389
+#define PCI_DEVICE_ID_APPLICOM_PCIGENERIC 0x0001
+#define PCI_DEVICE_ID_APPLICOM_PCI2000IBS_CAN 0x0002
+#define PCI_DEVICE_ID_APPLICOM_PCI2000PFB 0x0003
+
+#define PCI_VENDOR_ID_MOXA              0x1393
+#define PCI_DEVICE_ID_MOXA_RC7000       0x0001
+#define PCI_DEVICE_ID_MOXA_CP102        0x1020
+#define PCI_DEVICE_ID_MOXA_CP102UL      0x1021
+#define PCI_DEVICE_ID_MOXA_CP102U       0x1022
+#define PCI_DEVICE_ID_MOXA_C104         0x1040
+#define PCI_DEVICE_ID_MOXA_CP104U       0x1041
+#define PCI_DEVICE_ID_MOXA_CP104JU      0x1042
+#define PCI_DEVICE_ID_MOXA_CT114        0x1140
+#define PCI_DEVICE_ID_MOXA_CP114        0x1141
+#define PCI_DEVICE_ID_MOXA_CP118U       0x1180
+#define PCI_DEVICE_ID_MOXA_CP132        0x1320
+#define PCI_DEVICE_ID_MOXA_CP132U       0x1321
+#define PCI_DEVICE_ID_MOXA_CP134U       0x1340
+#define PCI_DEVICE_ID_MOXA_C168         0x1680
+#define PCI_DEVICE_ID_MOXA_CP168U       0x1681
+#define PCI_DEVICE_ID_MOXA_CP204J       0x2040
+#define PCI_DEVICE_ID_MOXA_C218         0x2180
+#define PCI_DEVICE_ID_MOXA_C320         0x3200
+
+#define PCI_VENDOR_ID_CCD               0x1397
+#define PCI_DEVICE_ID_CCD_2BD0          0x2bd0
+#define PCI_DEVICE_ID_CCD_B000          0xb000
+#define PCI_DEVICE_ID_CCD_B006          0xb006
+#define PCI_DEVICE_ID_CCD_B007          0xb007
+#define PCI_DEVICE_ID_CCD_B008          0xb008
+#define PCI_DEVICE_ID_CCD_B009          0xb009
+#define PCI_DEVICE_ID_CCD_B00A          0xb00a
+#define PCI_DEVICE_ID_CCD_B00B          0xb00b
+#define PCI_DEVICE_ID_CCD_B00C          0xb00c
+#define PCI_DEVICE_ID_CCD_B100          0xb100
+
+#define PCI_VENDOR_ID_EXAR              0x13a8
+#define PCI_DEVICE_ID_EXAR_XR17C152     0x0152
+#define PCI_DEVICE_ID_EXAR_XR17C154     0x0154
+#define PCI_DEVICE_ID_EXAR_XR17C158     0x0158
+
+#define PCI_VENDOR_ID_MICROGATE         0x13c0
+#define PCI_DEVICE_ID_MICROGATE_USC     0x0010
+#define PCI_DEVICE_ID_MICROGATE_SCC     0x0020
+#define PCI_DEVICE_ID_MICROGATE_SCA     0x0030
+#define PCI_DEVICE_ID_MICROGATE_USC2    0x0210
+
+#define PCI_VENDOR_ID_3WARE             0x13C1
+#define PCI_DEVICE_ID_3WARE_1000        0x1000
+#define PCI_DEVICE_ID_3WARE_7000        0x1001
+#define PCI_DEVICE_ID_3WARE_9000        0x1002
+
+#define PCI_VENDOR_ID_IOMEGA            0x13ca
+#define PCI_DEVICE_ID_IOMEGA_BUZ        0x4231
+
+#define PCI_VENDOR_ID_ABOCOM            0x13D1
+#define PCI_DEVICE_ID_ABOCOM_2BD1       0x2BD1
+
+#define PCI_VENDOR_ID_CMEDIA            0x13f6
+#define PCI_DEVICE_ID_CMEDIA_CM8338A    0x0100
+#define PCI_DEVICE_ID_CMEDIA_CM8338B    0x0101
+#define PCI_DEVICE_ID_CMEDIA_CM8738     0x0111
+#define PCI_DEVICE_ID_CMEDIA_CM8738B    0x0112
+
+#define PCI_VENDOR_ID_LAVA              0x1407
+#define PCI_DEVICE_ID_LAVA_DSERIAL      0x0100 /* 2x 16550 */
+#define PCI_DEVICE_ID_LAVA_QUATRO_A     0x0101 /* 2x 16550, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_QUATRO_B     0x0102 /* 2x 16550, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_OCTO_A       0x0180 /* 4x 16550A, half of 8 port */
+#define PCI_DEVICE_ID_LAVA_OCTO_B       0x0181 /* 4x 16550A, half of 8 port */
+#define PCI_DEVICE_ID_LAVA_PORT_PLUS    0x0200 /* 2x 16650 */
+#define PCI_DEVICE_ID_LAVA_QUAD_A       0x0201 /* 2x 16650, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_QUAD_B       0x0202 /* 2x 16650, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_SSERIAL      0x0500 /* 1x 16550 */
+#define PCI_DEVICE_ID_LAVA_PORT_650     0x0600 /* 1x 16650 */
+#define PCI_DEVICE_ID_LAVA_PARALLEL     0x8000
+#define PCI_DEVICE_ID_LAVA_DUAL_PAR_A   0x8002 /* The Lava Dual Parallel is */
+#define PCI_DEVICE_ID_LAVA_DUAL_PAR_B   0x8003 /* two PCI devices on a card */
+#define PCI_DEVICE_ID_LAVA_BOCA_IOPPAR  0x8800
+
+#define PCI_VENDOR_ID_TIMEDIA           0x1409
+#define PCI_DEVICE_ID_TIMEDIA_1889      0x7168
+
+#define PCI_VENDOR_ID_OXSEMI            0x1415
+#define PCI_DEVICE_ID_OXSEMI_12PCI840   0x8403
+#define PCI_DEVICE_ID_OXSEMI_16PCI954   0x9501
+#define PCI_DEVICE_ID_OXSEMI_16PCI95N   0x9511
+#define PCI_DEVICE_ID_OXSEMI_16PCI954PP 0x9513
+#define PCI_DEVICE_ID_OXSEMI_16PCI952   0x9521
+
+#define PCI_VENDOR_ID_SAMSUNG           0x144d
+
+#define PCI_VENDOR_ID_AIRONET           0x14b9
+#define PCI_DEVICE_ID_AIRONET_4800_1    0x0001
+#define PCI_DEVICE_ID_AIRONET_4800      0x4500 // values switched?  see
+#define PCI_DEVICE_ID_AIRONET_4500      0x4800 // drivers/net/aironet4500_card.c
+
+#define PCI_VENDOR_ID_TITAN             0x14D2
+#define PCI_DEVICE_ID_TITAN_010L        0x8001
+#define PCI_DEVICE_ID_TITAN_100L        0x8010
+#define PCI_DEVICE_ID_TITAN_110L        0x8011
+#define PCI_DEVICE_ID_TITAN_200L        0x8020
+#define PCI_DEVICE_ID_TITAN_210L        0x8021
+#define PCI_DEVICE_ID_TITAN_400L        0x8040
+#define PCI_DEVICE_ID_TITAN_800L        0x8080
+#define PCI_DEVICE_ID_TITAN_100         0xA001
+#define PCI_DEVICE_ID_TITAN_200         0xA005
+#define PCI_DEVICE_ID_TITAN_400         0xA003
+#define PCI_DEVICE_ID_TITAN_800B        0xA004
+
+#define PCI_VENDOR_ID_PANACOM           0x14d4
+#define PCI_DEVICE_ID_PANACOM_QUADMODEM 0x0400
+#define PCI_DEVICE_ID_PANACOM_DUALMODEM 0x0402
+
+#define PCI_VENDOR_ID_SIPACKETS         0x14d9
+#define PCI_DEVICE_ID_SP_HT             0x0010
+
+#define PCI_VENDOR_ID_AFAVLAB           0x14db
+#define PCI_DEVICE_ID_AFAVLAB_P028      0x2180
+#define PCI_DEVICE_ID_AFAVLAB_P030      0x2182
+
+#define PCI_VENDOR_ID_BROADCOM          0x14e4
+#define PCI_DEVICE_ID_TIGON3_5700       0x1644
+#define PCI_DEVICE_ID_TIGON3_5701       0x1645
+#define PCI_DEVICE_ID_TIGON3_5702       0x1646
+#define PCI_DEVICE_ID_TIGON3_5703       0x1647
+#define PCI_DEVICE_ID_TIGON3_5704       0x1648
+#define PCI_DEVICE_ID_TIGON3_5704S_2    0x1649
+#define PCI_DEVICE_ID_TIGON3_5702FE     0x164d
+#define PCI_DEVICE_ID_TIGON3_5705       0x1653
+#define PCI_DEVICE_ID_TIGON3_5705_2     0x1654
+#define PCI_DEVICE_ID_TIGON3_5720       0x1658
+#define PCI_DEVICE_ID_TIGON3_5721       0x1659
+#define PCI_DEVICE_ID_TIGON3_5705M      0x165d
+#define PCI_DEVICE_ID_TIGON3_5705M_2    0x165e
+#define PCI_DEVICE_ID_TIGON3_5705F      0x166e
+#define PCI_DEVICE_ID_TIGON3_5750       0x1676
+#define PCI_DEVICE_ID_TIGON3_5751       0x1677
+#define PCI_DEVICE_ID_TIGON3_5750M      0x167c
+#define PCI_DEVICE_ID_TIGON3_5751M      0x167d
+#define PCI_DEVICE_ID_TIGON3_5751F      0x167e
+#define PCI_DEVICE_ID_TIGON3_5782       0x1696
+#define PCI_DEVICE_ID_TIGON3_5788       0x169c
+#define PCI_DEVICE_ID_TIGON3_5789       0x169d
+#define PCI_DEVICE_ID_TIGON3_5702X      0x16a6
+#define PCI_DEVICE_ID_TIGON3_5703X      0x16a7
+#define PCI_DEVICE_ID_TIGON3_5704S      0x16a8
+#define PCI_DEVICE_ID_TIGON3_5702A3     0x16c6
+#define PCI_DEVICE_ID_TIGON3_5703A3     0x16c7
+#define PCI_DEVICE_ID_TIGON3_5781       0x16dd
+#define PCI_DEVICE_ID_TIGON3_5753       0x16f7
+#define PCI_DEVICE_ID_TIGON3_5753M      0x16fd
+#define PCI_DEVICE_ID_TIGON3_5753F      0x16fe
+#define PCI_DEVICE_ID_TIGON3_5901       0x170d
+#define PCI_DEVICE_ID_BCM4401B1         0x170c
+#define PCI_DEVICE_ID_TIGON3_5901_2     0x170e
+#define PCI_DEVICE_ID_BCM4401           0x4401
+#define PCI_DEVICE_ID_BCM4401B0         0x4402
+
+#define PCI_VENDOR_ID_TOPIC             0x151f
+#define PCI_DEVICE_ID_TOPIC_TP560       0x0000
+
+#define PCI_VENDOR_ID_ENE               0x1524
+#define PCI_DEVICE_ID_ENE_1211          0x1211
+#define PCI_DEVICE_ID_ENE_1225          0x1225
+#define PCI_DEVICE_ID_ENE_1410          0x1410
+#define PCI_DEVICE_ID_ENE_1420          0x1420
+
+#define PCI_VENDOR_ID_SYBA              0x1592
+#define PCI_DEVICE_ID_SYBA_2P_EPP       0x0782
+#define PCI_DEVICE_ID_SYBA_1P_ECP       0x0783
+
+#define PCI_VENDOR_ID_MORETON           0x15aa
+#define PCI_DEVICE_ID_RASTEL_2PORT      0x2000
+
+#define PCI_VENDOR_ID_ZOLTRIX           0x15b0
+#define PCI_DEVICE_ID_ZOLTRIX_2BD0      0x2bd0 
+
+#define PCI_VENDOR_ID_MELLANOX          0x15b3
+#define PCI_DEVICE_ID_MELLANOX_TAVOR    0x5a44
+#define PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT 0x6278
+#define PCI_DEVICE_ID_MELLANOX_ARBEL    0x6282
+#define PCI_DEVICE_ID_MELLANOX_SINAI_OLD 0x5e8c
+#define PCI_DEVICE_ID_MELLANOX_SINAI    0x6274
+
+#define PCI_VENDOR_ID_PDC               0x15e9
+#define PCI_DEVICE_ID_PDC_1841          0x1841
+
+#define PCI_VENDOR_ID_MACROLINK         0x15ed
+#define PCI_DEVICE_ID_MACROLINK_MCCS8   0x1000
+#define PCI_DEVICE_ID_MACROLINK_MCCS    0x1001
+#define PCI_DEVICE_ID_MACROLINK_MCCS8H  0x1002
+#define PCI_DEVICE_ID_MACROLINK_MCCSH   0x1003
+#define PCI_DEVICE_ID_MACROLINK_MCCR8   0x2000
+#define PCI_DEVICE_ID_MACROLINK_MCCR    0x2001
+
+#define PCI_VENDOR_ID_FARSITE           0x1619
+#define PCI_DEVICE_ID_FARSITE_T2P       0x0400
+#define PCI_DEVICE_ID_FARSITE_T4P       0x0440
+#define PCI_DEVICE_ID_FARSITE_T1U       0x0610
+#define PCI_DEVICE_ID_FARSITE_T2U       0x0620
+#define PCI_DEVICE_ID_FARSITE_T4U       0x0640
+#define PCI_DEVICE_ID_FARSITE_TE1       0x1610
+#define PCI_DEVICE_ID_FARSITE_TE1C      0x1612
+
+#define PCI_VENDOR_ID_SIBYTE            0x166d
+#define PCI_DEVICE_ID_BCM1250_HT        0x0002
+
+#define PCI_VENDOR_ID_LINKSYS           0x1737
+#define PCI_DEVICE_ID_LINKSYS_EG1032    0x1032
+#define PCI_DEVICE_ID_LINKSYS_EG1064    0x1064
+
+#define PCI_VENDOR_ID_ALTIMA            0x173b
+#define PCI_DEVICE_ID_ALTIMA_AC1000     0x03e8
+#define PCI_DEVICE_ID_ALTIMA_AC1001     0x03e9
+#define PCI_DEVICE_ID_ALTIMA_AC9100     0x03ea
+#define PCI_DEVICE_ID_ALTIMA_AC1003     0x03eb
+
+#define PCI_VENDOR_ID_S2IO              0x17d5
+#define PCI_DEVICE_ID_S2IO_WIN          0x5731
+#define PCI_DEVICE_ID_S2IO_UNI          0x5831
+#define PCI_DEVICE_ID_HERC_WIN          0x5732
+#define PCI_DEVICE_ID_HERC_UNI          0x5832
+
+#define PCI_VENDOR_ID_INFINICON         0x1820
+
+#define PCI_VENDOR_ID_TOPSPIN           0x1867
+
+#define PCI_VENDOR_ID_TDI               0x192E
+#define PCI_DEVICE_ID_TDI_EHCI          0x0101
+
+#define PCI_VENDOR_ID_SYMPHONY          0x1c1c
+#define PCI_DEVICE_ID_SYMPHONY_101      0x0001
+
+#define PCI_VENDOR_ID_TEKRAM            0x1de1
+#define PCI_DEVICE_ID_TEKRAM_DC290      0xdc29
+
+#define PCI_VENDOR_ID_HINT             0x3388
+#define PCI_DEVICE_ID_HINT_VXPROII_IDE 0x8013
+
+#define PCI_VENDOR_ID_3DLABS            0x3d3d
+#define PCI_DEVICE_ID_3DLABS_300SX      0x0001
+#define PCI_DEVICE_ID_3DLABS_500TX      0x0002
+#define PCI_DEVICE_ID_3DLABS_DELTA      0x0003
+#define PCI_DEVICE_ID_3DLABS_PERMEDIA   0x0004
+#define PCI_DEVICE_ID_3DLABS_MX         0x0006
+#define PCI_DEVICE_ID_3DLABS_PERMEDIA2  0x0007
+#define PCI_DEVICE_ID_3DLABS_GAMMA      0x0008
+#define PCI_DEVICE_ID_3DLABS_PERMEDIA2V 0x0009
+
+#define PCI_VENDOR_ID_AVANCE            0x4005
+#define PCI_DEVICE_ID_AVANCE_ALG2064    0x2064
+#define PCI_DEVICE_ID_AVANCE_2302       0x2302
+
+#define PCI_VENDOR_ID_AKS               0x416c
+#define PCI_DEVICE_ID_AKS_ALADDINCARD   0x0100
+#define PCI_DEVICE_ID_AKS_CPC           0x0200
+
+#define PCI_VENDOR_ID_REDCREEK          0x4916
+#define PCI_DEVICE_ID_RC45              0x1960
+
+#define PCI_VENDOR_ID_NETVIN            0x4a14
+#define PCI_DEVICE_ID_NETVIN_NV5000SC   0x5000
+
+#define PCI_VENDOR_ID_S3                0x5333
+#define PCI_DEVICE_ID_S3_PLATO_PXS      0x0551
+#define PCI_DEVICE_ID_S3_ViRGE          0x5631
+#define PCI_DEVICE_ID_S3_TRIO           0x8811
+#define PCI_DEVICE_ID_S3_AURORA64VP     0x8812
+#define PCI_DEVICE_ID_S3_TRIO64UVP      0x8814
+#define PCI_DEVICE_ID_S3_ViRGE_VX       0x883d
+#define PCI_DEVICE_ID_S3_868            0x8880
+#define PCI_DEVICE_ID_S3_928            0x88b0
+#define PCI_DEVICE_ID_S3_864_1          0x88c0
+#define PCI_DEVICE_ID_S3_864_2          0x88c1
+#define PCI_DEVICE_ID_S3_964_1          0x88d0
+#define PCI_DEVICE_ID_S3_964_2          0x88d1
+#define PCI_DEVICE_ID_S3_968            0x88f0
+#define PCI_DEVICE_ID_S3_TRIO64V2       0x8901
+#define PCI_DEVICE_ID_S3_PLATO_PXG      0x8902
+#define PCI_DEVICE_ID_S3_ViRGE_DXGX     0x8a01
+#define PCI_DEVICE_ID_S3_ViRGE_GX2      0x8a10
+#define PCI_DEVICE_ID_S3_SAVAGE4        0x8a25
+#define PCI_DEVICE_ID_S3_ViRGE_MX       0x8c01
+#define PCI_DEVICE_ID_S3_ViRGE_MXP      0x8c02
+#define PCI_DEVICE_ID_S3_ViRGE_MXPMV    0x8c03
+#define PCI_DEVICE_ID_S3_PROSAVAGE8     0x8d04
+#define PCI_DEVICE_ID_S3_SONICVIBES     0xca00
+
+#define PCI_VENDOR_ID_DUNORD            0x5544
+#define PCI_DEVICE_ID_DUNORD_I3000      0x0001
+
+#define PCI_VENDOR_ID_DCI               0x6666
+#define PCI_DEVICE_ID_DCI_PCCOM4        0x0001
+#define PCI_DEVICE_ID_DCI_PCCOM8        0x0002
+
+#define PCI_VENDOR_ID_DUNORD            0x5544
+#define PCI_DEVICE_ID_DUNORD_I3000      0x0001
+
+#define PCI_VENDOR_ID_GENROCO           0x5555
+#define PCI_DEVICE_ID_GENROCO_HFP832    0x0003
+
+#define PCI_VENDOR_ID_INTEL             0x8086
+#define PCI_DEVICE_ID_INTEL_EESSC       0x0008
+#define PCI_DEVICE_ID_INTEL_21145       0x0039
+#define PCI_DEVICE_ID_INTEL_82375       0x0482
+#define PCI_DEVICE_ID_INTEL_82424       0x0483
+#define PCI_DEVICE_ID_INTEL_82378       0x0484
+#define PCI_DEVICE_ID_INTEL_82430       0x0486
+#define PCI_DEVICE_ID_INTEL_82434       0x04a3
+#define PCI_DEVICE_ID_INTEL_I960        0x0960
+#define PCI_DEVICE_ID_INTEL_I960RM      0x0962
+#define PCI_DEVICE_ID_INTEL_82562ET     0x1031
+#define PCI_DEVICE_ID_INTEL_82801CAM    0x1038
+#define PCI_DEVICE_ID_INTEL_82815_MC    0x1130
+#define PCI_DEVICE_ID_INTEL_82815_AB    0x1131
+#define PCI_DEVICE_ID_INTEL_82815_CGC   0x1132
+#define PCI_DEVICE_ID_INTEL_82559ER     0x1209
+#define PCI_DEVICE_ID_INTEL_82092AA_0   0x1221
+#define PCI_DEVICE_ID_INTEL_82092AA_1   0x1222
+#define PCI_DEVICE_ID_INTEL_7116        0x1223
+#define PCI_DEVICE_ID_INTEL_7505_0      0x2550  
+#define PCI_DEVICE_ID_INTEL_7505_1      0x2552  
+#define PCI_DEVICE_ID_INTEL_7205_0      0x255d
+#define PCI_DEVICE_ID_INTEL_82596       0x1226
+#define PCI_DEVICE_ID_INTEL_82865       0x1227
+#define PCI_DEVICE_ID_INTEL_82557       0x1229
+#define PCI_DEVICE_ID_INTEL_82437       0x122d
+#define PCI_DEVICE_ID_INTEL_82371FB_0   0x122e
+#define PCI_DEVICE_ID_INTEL_82371FB_1   0x1230
+#define PCI_DEVICE_ID_INTEL_82371MX     0x1234
+#define PCI_DEVICE_ID_INTEL_82437MX     0x1235
+#define PCI_DEVICE_ID_INTEL_82441       0x1237
+#define PCI_DEVICE_ID_INTEL_82380FB     0x124b
+#define PCI_DEVICE_ID_INTEL_82439       0x1250
+#define PCI_DEVICE_ID_INTEL_80960_RP    0x1960
+#define PCI_DEVICE_ID_INTEL_82840_HB    0x1a21
+#define PCI_DEVICE_ID_INTEL_82845_HB    0x1a30
+#define PCI_DEVICE_ID_INTEL_82801AA_0   0x2410
+#define PCI_DEVICE_ID_INTEL_82801AA_1   0x2411
+#define PCI_DEVICE_ID_INTEL_82801AA_2   0x2412
+#define PCI_DEVICE_ID_INTEL_82801AA_3   0x2413
+#define PCI_DEVICE_ID_INTEL_82801AA_5   0x2415
+#define PCI_DEVICE_ID_INTEL_82801AA_6   0x2416
+#define PCI_DEVICE_ID_INTEL_82801AA_8   0x2418
+#define PCI_DEVICE_ID_INTEL_82801AB_0   0x2420
+#define PCI_DEVICE_ID_INTEL_82801AB_1   0x2421
+#define PCI_DEVICE_ID_INTEL_82801AB_2   0x2422
+#define PCI_DEVICE_ID_INTEL_82801AB_3   0x2423
+#define PCI_DEVICE_ID_INTEL_82801AB_5   0x2425
+#define PCI_DEVICE_ID_INTEL_82801AB_6   0x2426
+#define PCI_DEVICE_ID_INTEL_82801AB_8   0x2428
+#define PCI_DEVICE_ID_INTEL_82801BA_0   0x2440
+#define PCI_DEVICE_ID_INTEL_82801BA_1   0x2442
+#define PCI_DEVICE_ID_INTEL_82801BA_2   0x2443
+#define PCI_DEVICE_ID_INTEL_82801BA_3   0x2444
+#define PCI_DEVICE_ID_INTEL_82801BA_4   0x2445
+#define PCI_DEVICE_ID_INTEL_82801BA_5   0x2446
+#define PCI_DEVICE_ID_INTEL_82801BA_6   0x2448
+#define PCI_DEVICE_ID_INTEL_82801BA_7   0x2449
+#define PCI_DEVICE_ID_INTEL_82801BA_8   0x244a
+#define PCI_DEVICE_ID_INTEL_82801BA_9   0x244b
+#define PCI_DEVICE_ID_INTEL_82801BA_10  0x244c
+#define PCI_DEVICE_ID_INTEL_82801BA_11  0x244e
+#define PCI_DEVICE_ID_INTEL_82801E_0    0x2450
+#define PCI_DEVICE_ID_INTEL_82801E_2    0x2452
+#define PCI_DEVICE_ID_INTEL_82801E_3    0x2453
+#define PCI_DEVICE_ID_INTEL_82801E_9    0x2459
+#define PCI_DEVICE_ID_INTEL_82801E_11   0x245b
+#define PCI_DEVICE_ID_INTEL_82801E_13   0x245d
+#define PCI_DEVICE_ID_INTEL_82801E_14   0x245e
+#define PCI_DEVICE_ID_INTEL_82801CA_0   0x2480
+#define PCI_DEVICE_ID_INTEL_82801CA_2   0x2482
+#define PCI_DEVICE_ID_INTEL_82801CA_3   0x2483
+#define PCI_DEVICE_ID_INTEL_82801CA_4   0x2484
+#define PCI_DEVICE_ID_INTEL_82801CA_5   0x2485
+#define PCI_DEVICE_ID_INTEL_82801CA_6   0x2486
+#define PCI_DEVICE_ID_INTEL_82801CA_7   0x2487
+#define PCI_DEVICE_ID_INTEL_82801CA_10  0x248a
+#define PCI_DEVICE_ID_INTEL_82801CA_11  0x248b
+#define PCI_DEVICE_ID_INTEL_82801CA_12  0x248c
+#define PCI_DEVICE_ID_INTEL_82801DB_0   0x24c0
+#define PCI_DEVICE_ID_INTEL_82801DB_1   0x24c1
+#define PCI_DEVICE_ID_INTEL_82801DB_2   0x24c2
+#define PCI_DEVICE_ID_INTEL_82801DB_3   0x24c3
+#define PCI_DEVICE_ID_INTEL_82801DB_4   0x24c4
+#define PCI_DEVICE_ID_INTEL_82801DB_5   0x24c5
+#define PCI_DEVICE_ID_INTEL_82801DB_6   0x24c6
+#define PCI_DEVICE_ID_INTEL_82801DB_7   0x24c7
+#define PCI_DEVICE_ID_INTEL_82801DB_9   0x24c9
+#define PCI_DEVICE_ID_INTEL_82801DB_10  0x24ca
+#define PCI_DEVICE_ID_INTEL_82801DB_11  0x24cb
+#define PCI_DEVICE_ID_INTEL_82801DB_12  0x24cc
+#define PCI_DEVICE_ID_INTEL_82801DB_13  0x24cd
+#define PCI_DEVICE_ID_INTEL_82801EB_0   0x24d0
+#define PCI_DEVICE_ID_INTEL_82801EB_1   0x24d1
+#define PCI_DEVICE_ID_INTEL_82801EB_2   0x24d2
+#define PCI_DEVICE_ID_INTEL_82801EB_3   0x24d3
+#define PCI_DEVICE_ID_INTEL_82801EB_4   0x24d4
+#define PCI_DEVICE_ID_INTEL_82801EB_5   0x24d5
+#define PCI_DEVICE_ID_INTEL_82801EB_6   0x24d6
+#define PCI_DEVICE_ID_INTEL_82801EB_7   0x24d7
+#define PCI_DEVICE_ID_INTEL_82801EB_11  0x24db
+#define PCI_DEVICE_ID_INTEL_82801EB_13  0x24dd
+#define PCI_DEVICE_ID_INTEL_ESB_1       0x25a1
+#define PCI_DEVICE_ID_INTEL_ESB_2       0x25a2
+#define PCI_DEVICE_ID_INTEL_ESB_3       0x25a3
+#define PCI_DEVICE_ID_INTEL_ESB_31      0x25b0
+#define PCI_DEVICE_ID_INTEL_ESB_4       0x25a4
+#define PCI_DEVICE_ID_INTEL_ESB_5       0x25a6
+#define PCI_DEVICE_ID_INTEL_ESB_6       0x25a7
+#define PCI_DEVICE_ID_INTEL_ESB_7       0x25a9
+#define PCI_DEVICE_ID_INTEL_ESB_8       0x25aa
+#define PCI_DEVICE_ID_INTEL_ESB_9       0x25ab
+#define PCI_DEVICE_ID_INTEL_ESB_11      0x25ac
+#define PCI_DEVICE_ID_INTEL_ESB_12      0x25ad
+#define PCI_DEVICE_ID_INTEL_ESB_13      0x25ae
+#define PCI_DEVICE_ID_INTEL_82820_HB    0x2500
+#define PCI_DEVICE_ID_INTEL_82820_UP_HB 0x2501
+#define PCI_DEVICE_ID_INTEL_82850_HB    0x2530
+#define PCI_DEVICE_ID_INTEL_82860_HB    0x2531
+#define PCI_DEVICE_ID_INTEL_82845G_HB   0x2560
+#define PCI_DEVICE_ID_INTEL_82845G_IG   0x2562
+#define PCI_DEVICE_ID_INTEL_82865_HB    0x2570
+#define PCI_DEVICE_ID_INTEL_82865_IG    0x2572
+#define PCI_DEVICE_ID_INTEL_82875_HB    0x2578
+#define PCI_DEVICE_ID_INTEL_82875_IG    0x257b
+#define PCI_DEVICE_ID_INTEL_82915G_HB   0x2580
+#define PCI_DEVICE_ID_INTEL_82915G_IG   0x2582
+#define PCI_DEVICE_ID_INTEL_82915GM_HB  0x2590
+#define PCI_DEVICE_ID_INTEL_82915GM_IG  0x2592
+#define PCI_DEVICE_ID_INTEL_ICH6_0      0x2640
+#define PCI_DEVICE_ID_INTEL_ICH6_1      0x2641
+#define PCI_DEVICE_ID_INTEL_ICH6_2      0x2642
+#define PCI_DEVICE_ID_INTEL_ICH6_3      0x2651
+#define PCI_DEVICE_ID_INTEL_ICH6_4      0x2652
+#define PCI_DEVICE_ID_INTEL_ICH6_5      0x2653
+#define PCI_DEVICE_ID_INTEL_ICH6_6      0x2658
+#define PCI_DEVICE_ID_INTEL_ICH6_7      0x2659
+#define PCI_DEVICE_ID_INTEL_ICH6_8      0x265a
+#define PCI_DEVICE_ID_INTEL_ICH6_9      0x265b
+#define PCI_DEVICE_ID_INTEL_ICH6_10     0x265c
+#define PCI_DEVICE_ID_INTEL_ICH6_11     0x2660
+#define PCI_DEVICE_ID_INTEL_ICH6_12     0x2662
+#define PCI_DEVICE_ID_INTEL_ICH6_13     0x2664
+#define PCI_DEVICE_ID_INTEL_ICH6_14     0x2666
+#define PCI_DEVICE_ID_INTEL_ICH6_15     0x2668
+#define PCI_DEVICE_ID_INTEL_ICH6_16     0x266a
+#define PCI_DEVICE_ID_INTEL_ICH6_17     0x266d
+#define PCI_DEVICE_ID_INTEL_ICH6_18     0x266e
+#define PCI_DEVICE_ID_INTEL_ICH6_19     0x266f
+#define PCI_DEVICE_ID_INTEL_ICH7_0      0x27b8
+#define PCI_DEVICE_ID_INTEL_ICH7_1      0x27b9
+#define PCI_DEVICE_ID_INTEL_ICH7_2      0x27c0
+#define PCI_DEVICE_ID_INTEL_ICH7_3      0x27c1
+#define PCI_DEVICE_ID_INTEL_ICH7_5      0x27c4
+#define PCI_DEVICE_ID_INTEL_ICH7_6      0x27c5
+#define PCI_DEVICE_ID_INTEL_ICH7_7      0x27c8
+#define PCI_DEVICE_ID_INTEL_ICH7_8      0x27c9
+#define PCI_DEVICE_ID_INTEL_ICH7_9      0x27ca
+#define PCI_DEVICE_ID_INTEL_ICH7_10     0x27cb
+#define PCI_DEVICE_ID_INTEL_ICH7_11     0x27cc
+#define PCI_DEVICE_ID_INTEL_ICH7_12     0x27d0
+#define PCI_DEVICE_ID_INTEL_ICH7_13     0x27d2
+#define PCI_DEVICE_ID_INTEL_ICH7_14     0x27d4
+#define PCI_DEVICE_ID_INTEL_ICH7_15     0x27d6
+#define PCI_DEVICE_ID_INTEL_ICH7_16     0x27d8
+#define PCI_DEVICE_ID_INTEL_ICH7_17     0x27da
+#define PCI_DEVICE_ID_INTEL_ICH7_18     0x27dc
+#define PCI_DEVICE_ID_INTEL_ICH7_19     0x27dd
+#define PCI_DEVICE_ID_INTEL_ICH7_20     0x27de
+#define PCI_DEVICE_ID_INTEL_ICH7_21     0x27df
+#define PCI_DEVICE_ID_INTEL_ICH7_22     0x27e0
+#define PCI_DEVICE_ID_INTEL_ICH7_23     0x27e2
+#define PCI_DEVICE_ID_INTEL_82855PM_HB  0x3340
+#define PCI_DEVICE_ID_INTEL_82830_HB    0x3575
+#define PCI_DEVICE_ID_INTEL_82830_CGC   0x3577
+#define PCI_DEVICE_ID_INTEL_82855GM_HB  0x3580
+#define PCI_DEVICE_ID_INTEL_82855GM_IG  0x3582
+#define PCI_DEVICE_ID_INTEL_E7520_MCH   0x3590
+#define PCI_DEVICE_ID_INTEL_E7320_MCH   0x3592
+#define PCI_DEVICE_ID_INTEL_MCH_PA      0x3595
+#define PCI_DEVICE_ID_INTEL_MCH_PA1     0x3596
+#define PCI_DEVICE_ID_INTEL_MCH_PB      0x3597
+#define PCI_DEVICE_ID_INTEL_MCH_PB1     0x3598
+#define PCI_DEVICE_ID_INTEL_MCH_PC      0x3599
+#define PCI_DEVICE_ID_INTEL_MCH_PC1     0x359a
+#define PCI_DEVICE_ID_INTEL_E7525_MCH   0x359e
+#define PCI_DEVICE_ID_INTEL_80310       0x530d
+#define PCI_DEVICE_ID_INTEL_82371SB_0   0x7000
+#define PCI_DEVICE_ID_INTEL_82371SB_1   0x7010
+#define PCI_DEVICE_ID_INTEL_82371SB_2   0x7020
+#define PCI_DEVICE_ID_INTEL_82437VX     0x7030
+#define PCI_DEVICE_ID_INTEL_82439TX     0x7100
+#define PCI_DEVICE_ID_INTEL_82371AB_0   0x7110
+#define PCI_DEVICE_ID_INTEL_82371AB     0x7111
+#define PCI_DEVICE_ID_INTEL_82371AB_2   0x7112
+#define PCI_DEVICE_ID_INTEL_82371AB_3   0x7113
+#define PCI_DEVICE_ID_INTEL_82810_MC1   0x7120
+#define PCI_DEVICE_ID_INTEL_82810_IG1   0x7121
+#define PCI_DEVICE_ID_INTEL_82810_MC3   0x7122
+#define PCI_DEVICE_ID_INTEL_82810_IG3   0x7123
+#define PCI_DEVICE_ID_INTEL_82810E_MC   0x7124
+#define PCI_DEVICE_ID_INTEL_82810E_IG   0x7125
+#define PCI_DEVICE_ID_INTEL_82443LX_0   0x7180
+#define PCI_DEVICE_ID_INTEL_82443LX_1   0x7181
+#define PCI_DEVICE_ID_INTEL_82443BX_0   0x7190
+#define PCI_DEVICE_ID_INTEL_82443BX_1   0x7191
+#define PCI_DEVICE_ID_INTEL_82443BX_2   0x7192
+#define PCI_DEVICE_ID_INTEL_440MX       0x7195
+#define PCI_DEVICE_ID_INTEL_82443MX_0   0x7198
+#define PCI_DEVICE_ID_INTEL_82443MX_1   0x7199
+#define PCI_DEVICE_ID_INTEL_82443MX_2   0x719a
+#define PCI_DEVICE_ID_INTEL_82443MX_3   0x719b
+#define PCI_DEVICE_ID_INTEL_82443GX_0   0x71a0
+#define PCI_DEVICE_ID_INTEL_82443GX_1   0x71a1
+#define PCI_DEVICE_ID_INTEL_82443GX_2   0x71a2
+#define PCI_DEVICE_ID_INTEL_82372FB_0   0x7600
+#define PCI_DEVICE_ID_INTEL_82372FB_1   0x7601
+#define PCI_DEVICE_ID_INTEL_82372FB_2   0x7602
+#define PCI_DEVICE_ID_INTEL_82372FB_3   0x7603
+#define PCI_DEVICE_ID_INTEL_82454GX     0x84c4
+#define PCI_DEVICE_ID_INTEL_82450GX     0x84c5
+#define PCI_DEVICE_ID_INTEL_82451NX     0x84ca
+#define PCI_DEVICE_ID_INTEL_82454NX     0x84cb
+#define PCI_DEVICE_ID_INTEL_84460GX     0x84ea
+#define PCI_DEVICE_ID_INTEL_IXP4XX      0x8500
+#define PCI_DEVICE_ID_INTEL_IXP2400     0x9001
+#define PCI_DEVICE_ID_INTEL_IXP2800     0x9004
+#define PCI_DEVICE_ID_INTEL_S21152BB    0xb152
+
+#define PCI_VENDOR_ID_COMPUTONE         0x8e0e
+#define PCI_DEVICE_ID_COMPUTONE_IP2EX   0x0291
+#define PCI_DEVICE_ID_COMPUTONE_PG      0x0302
+#define PCI_SUBVENDOR_ID_COMPUTONE      0x8e0e
+#define PCI_SUBDEVICE_ID_COMPUTONE_PG4  0x0001
+#define PCI_SUBDEVICE_ID_COMPUTONE_PG8  0x0002
+#define PCI_SUBDEVICE_ID_COMPUTONE_PG6  0x0003
+
+#define PCI_VENDOR_ID_KTI               0x8e2e
+#define PCI_DEVICE_ID_KTI_ET32P2        0x3000
+
+#define PCI_VENDOR_ID_ADAPTEC           0x9004
+#define PCI_DEVICE_ID_ADAPTEC_7810      0x1078
+#define PCI_DEVICE_ID_ADAPTEC_7821      0x2178
+#define PCI_DEVICE_ID_ADAPTEC_38602     0x3860
+#define PCI_DEVICE_ID_ADAPTEC_7850      0x5078
+#define PCI_DEVICE_ID_ADAPTEC_7855      0x5578
+#define PCI_DEVICE_ID_ADAPTEC_5800      0x5800
+#define PCI_DEVICE_ID_ADAPTEC_3860      0x6038
+#define PCI_DEVICE_ID_ADAPTEC_1480A     0x6075
+#define PCI_DEVICE_ID_ADAPTEC_7860      0x6078
+#define PCI_DEVICE_ID_ADAPTEC_7861      0x6178
+#define PCI_DEVICE_ID_ADAPTEC_7870      0x7078
+#define PCI_DEVICE_ID_ADAPTEC_7871      0x7178
+#define PCI_DEVICE_ID_ADAPTEC_7872      0x7278
+#define PCI_DEVICE_ID_ADAPTEC_7873      0x7378
+#define PCI_DEVICE_ID_ADAPTEC_7874      0x7478
+#define PCI_DEVICE_ID_ADAPTEC_7895      0x7895
+#define PCI_DEVICE_ID_ADAPTEC_7880      0x8078
+#define PCI_DEVICE_ID_ADAPTEC_7881      0x8178
+#define PCI_DEVICE_ID_ADAPTEC_7882      0x8278
+#define PCI_DEVICE_ID_ADAPTEC_7883      0x8378
+#define PCI_DEVICE_ID_ADAPTEC_7884      0x8478
+#define PCI_DEVICE_ID_ADAPTEC_7885      0x8578
+#define PCI_DEVICE_ID_ADAPTEC_7886      0x8678
+#define PCI_DEVICE_ID_ADAPTEC_7887      0x8778
+#define PCI_DEVICE_ID_ADAPTEC_7888      0x8878
+#define PCI_DEVICE_ID_ADAPTEC_1030      0x8b78
+
+#define PCI_VENDOR_ID_ADAPTEC2          0x9005
+#define PCI_DEVICE_ID_ADAPTEC2_2940U2   0x0010
+#define PCI_DEVICE_ID_ADAPTEC2_2930U2   0x0011
+#define PCI_DEVICE_ID_ADAPTEC2_7890B    0x0013
+#define PCI_DEVICE_ID_ADAPTEC2_7890     0x001f
+#define PCI_DEVICE_ID_ADAPTEC2_3940U2   0x0050
+#define PCI_DEVICE_ID_ADAPTEC2_3950U2D  0x0051
+#define PCI_DEVICE_ID_ADAPTEC2_7896     0x005f
+#define PCI_DEVICE_ID_ADAPTEC2_7892A    0x0080
+#define PCI_DEVICE_ID_ADAPTEC2_7892B    0x0081
+#define PCI_DEVICE_ID_ADAPTEC2_7892D    0x0083
+#define PCI_DEVICE_ID_ADAPTEC2_7892P    0x008f
+#define PCI_DEVICE_ID_ADAPTEC2_7899A    0x00c0
+#define PCI_DEVICE_ID_ADAPTEC2_7899B    0x00c1
+#define PCI_DEVICE_ID_ADAPTEC2_7899D    0x00c3
+#define PCI_DEVICE_ID_ADAPTEC2_7899P    0x00cf
+#define PCI_DEVICE_ID_ADAPTEC2_SCAMP    0x0503
+
+#define PCI_VENDOR_ID_ATRONICS          0x907f
+#define PCI_DEVICE_ID_ATRONICS_2015     0x2015
+
+#define PCI_VENDOR_ID_HOLTEK            0x9412
+#define PCI_DEVICE_ID_HOLTEK_6565       0x6565
+
+#define PCI_VENDOR_ID_NETMOS            0x9710
+#define PCI_DEVICE_ID_NETMOS_9705       0x9705
+#define PCI_DEVICE_ID_NETMOS_9715       0x9715
+#define PCI_DEVICE_ID_NETMOS_9735       0x9735
+#define PCI_DEVICE_ID_NETMOS_9745       0x9745
+#define PCI_DEVICE_ID_NETMOS_9755       0x9755
+#define PCI_DEVICE_ID_NETMOS_9805       0x9805
+#define PCI_DEVICE_ID_NETMOS_9815       0x9815
+#define PCI_DEVICE_ID_NETMOS_9835       0x9835
+#define PCI_DEVICE_ID_NETMOS_9845       0x9845
+#define PCI_DEVICE_ID_NETMOS_9855       0x9855
+
+#define PCI_SUBVENDOR_ID_EXSYS          0xd84d
+#define PCI_SUBDEVICE_ID_EXSYS_4014     0x4014
+
+#define PCI_VENDOR_ID_TIGERJET          0xe159
+#define PCI_DEVICE_ID_TIGERJET_300      0x0001
+#define PCI_DEVICE_ID_TIGERJET_100      0x0002
+
+#define PCI_VENDOR_ID_TTTECH            0x0357
+#define PCI_DEVICE_ID_TTTECH_MC322      0x000A
+
+#define PCI_VENDOR_ID_ARK               0xedd8
+#define PCI_DEVICE_ID_ARK_STING         0xa091
+#define PCI_DEVICE_ID_ARK_STINGARK      0xa099
+#define PCI_DEVICE_ID_ARK_2000MT        0xa0a1
diff --git a/include/linux/pcieport_if.h b/include/linux/pcieport_if.h
new file mode 100644
index 000000000000..cd3eafc2c233
--- /dev/null
+++ b/include/linux/pcieport_if.h
@@ -0,0 +1,74 @@
+/*
+ * File:        pcieport_if.h
+ * Purpose:     PCI Express Port Bus Driver's IF Data Structure
+ *
+ * Copyright (C) 2004 Intel
+ * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
+ */
+
+#ifndef _PCIEPORT_IF_H_
+#define _PCIEPORT_IF_H_
+
+/* Port Type */
+#define PCIE_RC_PORT                    4       /* Root port of RC */
+#define PCIE_SW_UPSTREAM_PORT           5       /* Upstream port of Switch */
+#define PCIE_SW_DOWNSTREAM_PORT         6       /* Downstream port of Switch */
+#define PCIE_ANY_PORT                   7
+
+/* Service Type */
+#define PCIE_PORT_SERVICE_PME           1       /* Power Management Event */
+#define PCIE_PORT_SERVICE_AER           2       /* Advanced Error Reporting */
+#define PCIE_PORT_SERVICE_HP            4       /* Native Hotplug */
+#define PCIE_PORT_SERVICE_VC            8       /* Virtual Channel */
+
+/* Root/Upstream/Downstream Port's Interrupt Mode */
+#define PCIE_PORT_INTx_MODE             0
+#define PCIE_PORT_MSI_MODE              1
+#define PCIE_PORT_MSIX_MODE             2
+
+struct pcie_port_service_id {
+        __u32 vendor, device;           /* Vendor and device ID or PCI_ANY_ID*/
+        __u32 subvendor, subdevice;     /* Subsystem ID's or PCI_ANY_ID */
+        __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
+        __u32 port_type, service_type;  /* Port Entity */
+        kernel_ulong_t driver_data;
+};
+
+struct pcie_device {
+        int             irq;        /* Service IRQ/MSI/MSI-X Vector */
+        int             interrupt_mode; /* [0:INTx | 1:MSI | 2:MSI-X] */        
+        struct pcie_port_service_id id; /* Service ID */
+        struct pci_dev  *port;      /* Root/Upstream/Downstream Port */
+        void            *priv_data; /* Service Private Data */
+        struct device   device;     /* Generic Device Interface */
+};
+#define to_pcie_device(d) container_of(d, struct pcie_device, device)
+
+static inline void set_service_data(struct pcie_device *dev, void *data)
+{
+        dev->priv_data = data;
+}
+
+static inline void* get_service_data(struct pcie_device *dev)
+{
+        return dev->priv_data;
+}
+
+struct pcie_port_service_driver {
+        const char *name;
+        int (*probe) (struct pcie_device *dev, 
+                const struct pcie_port_service_id *id);
+        void (*remove) (struct pcie_device *dev);
+        int (*suspend) (struct pcie_device *dev, u32 state);
+        int (*resume) (struct pcie_device *dev);
+
+        const struct pcie_port_service_id *id_table;
+        struct device_driver driver;
+};
+#define to_service_driver(d) \
+        container_of(d, struct pcie_port_service_driver, driver)
+
+extern int pcie_port_service_register(struct pcie_port_service_driver *new);
+extern void pcie_port_service_unregister(struct pcie_port_service_driver *new);
+
+#endif /* _PCIEPORT_IF_H_ */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
new file mode 100644
index 000000000000..5451eb1e781d
--- /dev/null
+++ b/include/linux/percpu.h
@@ -0,0 +1,61 @@
+#ifndef __LINUX_PERCPU_H
+#define __LINUX_PERCPU_H
+#include <linux/spinlock.h> /* For preempt_disable() */
+#include <linux/slab.h> /* For kmalloc() */
+#include <linux/smp.h>
+#include <linux/string.h> /* For memset() */
+#include <asm/percpu.h>
+
+/* Enough to cover all DEFINE_PER_CPUs in kernel, including modules. */
+#ifndef PERCPU_ENOUGH_ROOM
+#define PERCPU_ENOUGH_ROOM 32768
+#endif
+
+/* Must be an lvalue. */
+#define get_cpu_var(var) (*({ preempt_disable(); &__get_cpu_var(var); }))
+#define put_cpu_var(var) preempt_enable()
+
+#ifdef CONFIG_SMP
+
+struct percpu_data {
+        void *ptrs[NR_CPUS];
+        void *blkp;
+};
+
+/* 
+ * Use this to get to a cpu's version of the per-cpu object allocated using
+ * alloc_percpu.  Non-atomic access to the current CPU's version should
+ * probably be combined with get_cpu()/put_cpu().
+ */ 
+#define per_cpu_ptr(ptr, cpu)                   \
+({                                              \
+        struct percpu_data *__p = (struct percpu_data *)~(unsigned long)(ptr); \
+        (__typeof__(ptr))__p->ptrs[(cpu)];      \
+})
+
+extern void *__alloc_percpu(size_t size, size_t align);
+extern void free_percpu(const void *);
+
+#else /* CONFIG_SMP */
+
+#define per_cpu_ptr(ptr, cpu) (ptr)
+
+static inline void *__alloc_percpu(size_t size, size_t align)
+{
+        void *ret = kmalloc(size, GFP_KERNEL);
+        if (ret)
+                memset(ret, 0, size);
+        return ret;
+}
+static inline void free_percpu(const void *ptr)
+{       
+        kfree(ptr);
+}
+
+#endif /* CONFIG_SMP */
+
+/* Simple wrapper for the common case: zeros memory. */
+#define alloc_percpu(type) \
+        ((type *)(__alloc_percpu(sizeof(type), __alignof__(type))))
+
+#endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
new file mode 100644
index 000000000000..bd6708e2c027
--- /dev/null
+++ b/include/linux/percpu_counter.h
@@ -0,0 +1,107 @@
+#ifndef _LINUX_PERCPU_COUNTER_H
+#define _LINUX_PERCPU_COUNTER_H
+/*
+ * A simple "approximate counter" for use in ext2 and ext3 superblocks.
+ *
+ * WARNING: these things are HUGE.  4 kbytes per counter on 32-way P4.
+ */
+
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/threads.h>
+#include <linux/percpu.h>
+
+#ifdef CONFIG_SMP
+
+struct percpu_counter {
+        spinlock_t lock;
+        long count;
+        long *counters;
+};
+
+#if NR_CPUS >= 16
+#define FBC_BATCH       (NR_CPUS*2)
+#else
+#define FBC_BATCH       (NR_CPUS*4)
+#endif
+
+static inline void percpu_counter_init(struct percpu_counter *fbc)
+{
+        spin_lock_init(&fbc->lock);
+        fbc->count = 0;
+        fbc->counters = alloc_percpu(long);
+}
+
+static inline void percpu_counter_destroy(struct percpu_counter *fbc)
+{
+        free_percpu(fbc->counters);
+}
+
+void percpu_counter_mod(struct percpu_counter *fbc, long amount);
+
+static inline long percpu_counter_read(struct percpu_counter *fbc)
+{
+        return fbc->count;
+}
+
+/*
+ * It is possible for the percpu_counter_read() to return a small negative
+ * number for some counter which should never be negative.
+ */
+static inline long percpu_counter_read_positive(struct percpu_counter *fbc)
+{
+        long ret = fbc->count;
+
+        barrier();              /* Prevent reloads of fbc->count */
+        if (ret > 0)
+                return ret;
+        return 1;
+}
+
+#else
+
+struct percpu_counter {
+        long count;
+};
+
+static inline void percpu_counter_init(struct percpu_counter *fbc)
+{
+        fbc->count = 0;
+}
+
+static inline void percpu_counter_destroy(struct percpu_counter *fbc)
+{
+}
+
+static inline void
+percpu_counter_mod(struct percpu_counter *fbc, long amount)
+{
+        preempt_disable();
+        fbc->count += amount;
+        preempt_enable();
+}
+
+static inline long percpu_counter_read(struct percpu_counter *fbc)
+{
+        return fbc->count;
+}
+
+static inline long percpu_counter_read_positive(struct percpu_counter *fbc)
+{
+        return fbc->count;
+}
+
+#endif  /* CONFIG_SMP */
+
+static inline void percpu_counter_inc(struct percpu_counter *fbc)
+{
+        percpu_counter_mod(fbc, 1);
+}
+
+static inline void percpu_counter_dec(struct percpu_counter *fbc)
+{
+        percpu_counter_mod(fbc, -1);
+}
+
+#endif /* _LINUX_PERCPU_COUNTER_H */
diff --git a/include/linux/personality.h b/include/linux/personality.h
new file mode 100644
index 000000000000..80d780e5a8f5
--- /dev/null
+++ b/include/linux/personality.h
@@ -0,0 +1,114 @@
+#ifndef _LINUX_PERSONALITY_H
+#define _LINUX_PERSONALITY_H
+
+/*
+ * Handling of different ABIs (personalities).
+ */
+
+struct exec_domain;
+struct pt_regs;
+
+extern int              register_exec_domain(struct exec_domain *);
+extern int              unregister_exec_domain(struct exec_domain *);
+extern int              __set_personality(unsigned long);
+
+/*
+ * Flags for bug emulation.
+ *
+ * These occupy the top three bytes.
+ */
+enum {
+        ADDR_NO_RANDOMIZE =     0x0040000,      /* disable randomization of VA space */
+        FDPIC_FUNCPTRS =        0x0080000,      /* userspace function ptrs point to descriptors
+                                                 * (signal handling)
+                                                 */
+        MMAP_PAGE_ZERO =        0x0100000,
+        ADDR_COMPAT_LAYOUT =    0x0200000,
+        READ_IMPLIES_EXEC =     0x0400000,
+        ADDR_LIMIT_32BIT =      0x0800000,
+        SHORT_INODE =           0x1000000,
+        WHOLE_SECONDS =         0x2000000,
+        STICKY_TIMEOUTS =       0x4000000,
+        ADDR_LIMIT_3GB =        0x8000000,
+};
+
+/*
+ * Security-relevant compatibility flags that must be
+ * cleared upon setuid or setgid exec:
+ */
+#define PER_CLEAR_ON_SETID (READ_IMPLIES_EXEC|ADDR_NO_RANDOMIZE)
+
+/*
+ * Personality types.
+ *
+ * These go in the low byte.  Avoid using the top bit, it will
+ * conflict with error returns.
+ */
+enum {
+        PER_LINUX =             0x0000,
+        PER_LINUX_32BIT =       0x0000 | ADDR_LIMIT_32BIT,
+        PER_LINUX_FDPIC =       0x0000 | FDPIC_FUNCPTRS,
+        PER_SVR4 =              0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
+        PER_SVR3 =              0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
+        PER_SCOSVR3 =           0x0003 | STICKY_TIMEOUTS |
+                                         WHOLE_SECONDS | SHORT_INODE,
+        PER_OSR5 =              0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
+        PER_WYSEV386 =          0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
+        PER_ISCR4 =             0x0005 | STICKY_TIMEOUTS,
+        PER_BSD =               0x0006,
+        PER_SUNOS =             0x0006 | STICKY_TIMEOUTS,
+        PER_XENIX =             0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
+        PER_LINUX32 =           0x0008,
+        PER_LINUX32_3GB =       0x0008 | ADDR_LIMIT_3GB,
+        PER_IRIX32 =            0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
+        PER_IRIXN32 =           0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
+        PER_IRIX64 =            0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
+        PER_RISCOS =            0x000c,
+        PER_SOLARIS =           0x000d | STICKY_TIMEOUTS,
+        PER_UW7 =               0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
+        PER_OSF4 =              0x000f,                  /* OSF/1 v4 */
+        PER_HPUX =              0x0010,
+        PER_MASK =              0x00ff,
+};
+
+
+/*
+ * Description of an execution domain.
+ * 
+ * The first two members are refernced from assembly source
+ * and should stay where they are unless explicitly needed.
+ */
+typedef void (*handler_t)(int, struct pt_regs *);
+
+struct exec_domain {
+        const char              *name;          /* name of the execdomain */
+        handler_t               handler;        /* handler for syscalls */
+        unsigned char           pers_low;       /* lowest personality */
+        unsigned char           pers_high;      /* highest personality */
+        unsigned long           *signal_map;    /* signal mapping */
+        unsigned long           *signal_invmap; /* reverse signal mapping */
+        struct map_segment      *err_map;       /* error mapping */
+        struct map_segment      *socktype_map;  /* socket type mapping */
+        struct map_segment      *sockopt_map;   /* socket option mapping */
+        struct map_segment      *af_map;        /* address family mapping */
+        struct module           *module;        /* module context of the ed. */
+        struct exec_domain      *next;          /* linked list (internal) */
+};
+
+/*
+ * Return the base personality without flags.
+ */
+#define personality(pers)       (pers & PER_MASK)
+
+/*
+ * Personality of the currently running process.
+ */
+#define get_personality         (current->personality)
+
+/*
+ * Change personality of the currently running process.
+ */
+#define set_personality(pers) \
+        ((current->personality == pers) ? 0 : __set_personality(pers))
+
+#endif /* _LINUX_PERSONALITY_H */
diff --git a/include/linux/pfkeyv2.h b/include/linux/pfkeyv2.h
new file mode 100644
index 000000000000..e6b519220245
--- /dev/null
+++ b/include/linux/pfkeyv2.h
@@ -0,0 +1,336 @@
+/* PF_KEY user interface, this is defined by rfc2367 so
+ * do not make arbitrary modifications or else this header
+ * file will not be compliant.
+ */
+
+#ifndef _LINUX_PFKEY2_H
+#define _LINUX_PFKEY2_H
+
+#include <linux/types.h>
+
+#define PF_KEY_V2               2
+#define PFKEYV2_REVISION        199806L
+
+struct sadb_msg {
+        uint8_t         sadb_msg_version;
+        uint8_t         sadb_msg_type;
+        uint8_t         sadb_msg_errno;
+        uint8_t         sadb_msg_satype;
+        uint16_t        sadb_msg_len;
+        uint16_t        sadb_msg_reserved;
+        uint32_t        sadb_msg_seq;
+        uint32_t        sadb_msg_pid;
+} __attribute__((packed));
+/* sizeof(struct sadb_msg) == 16 */
+
+struct sadb_ext {
+        uint16_t        sadb_ext_len;
+        uint16_t        sadb_ext_type;
+} __attribute__((packed));
+/* sizeof(struct sadb_ext) == 4 */
+
+struct sadb_sa {
+        uint16_t        sadb_sa_len;
+        uint16_t        sadb_sa_exttype;
+        uint32_t        sadb_sa_spi;
+        uint8_t         sadb_sa_replay;
+        uint8_t         sadb_sa_state;
+        uint8_t         sadb_sa_auth;
+        uint8_t         sadb_sa_encrypt;
+        uint32_t        sadb_sa_flags;
+} __attribute__((packed));
+/* sizeof(struct sadb_sa) == 16 */
+
+struct sadb_lifetime {
+        uint16_t        sadb_lifetime_len;
+        uint16_t        sadb_lifetime_exttype;
+        uint32_t        sadb_lifetime_allocations;
+        uint64_t        sadb_lifetime_bytes;
+        uint64_t        sadb_lifetime_addtime;
+        uint64_t        sadb_lifetime_usetime;
+} __attribute__((packed));
+/* sizeof(struct sadb_lifetime) == 32 */
+
+struct sadb_address {
+        uint16_t        sadb_address_len;
+        uint16_t        sadb_address_exttype;
+        uint8_t         sadb_address_proto;
+        uint8_t         sadb_address_prefixlen;
+        uint16_t        sadb_address_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_address) == 8 */
+
+struct sadb_key {
+        uint16_t        sadb_key_len;
+        uint16_t        sadb_key_exttype;
+        uint16_t        sadb_key_bits;
+        uint16_t        sadb_key_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_key) == 8 */
+
+struct sadb_ident {
+        uint16_t        sadb_ident_len;
+        uint16_t        sadb_ident_exttype;
+        uint16_t        sadb_ident_type;
+        uint16_t        sadb_ident_reserved;
+        uint64_t        sadb_ident_id;
+} __attribute__((packed));
+/* sizeof(struct sadb_ident) == 16 */
+
+struct sadb_sens {
+        uint16_t        sadb_sens_len;
+        uint16_t        sadb_sens_exttype;
+        uint32_t        sadb_sens_dpd;
+        uint8_t         sadb_sens_sens_level;
+        uint8_t         sadb_sens_sens_len;
+        uint8_t         sadb_sens_integ_level;
+        uint8_t         sadb_sens_integ_len;
+        uint32_t        sadb_sens_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_sens) == 16 */
+
+/* followed by:
+        uint64_t        sadb_sens_bitmap[sens_len];
+        uint64_t        sadb_integ_bitmap[integ_len];  */
+
+struct sadb_prop {
+        uint16_t        sadb_prop_len;
+        uint16_t        sadb_prop_exttype;
+        uint8_t         sadb_prop_replay;
+        uint8_t         sadb_prop_reserved[3];
+} __attribute__((packed));
+/* sizeof(struct sadb_prop) == 8 */
+
+/* followed by:
+        struct sadb_comb sadb_combs[(sadb_prop_len +
+                sizeof(uint64_t) - sizeof(struct sadb_prop)) /
+                sizeof(strut sadb_comb)]; */
+
+struct sadb_comb {
+        uint8_t         sadb_comb_auth;
+        uint8_t         sadb_comb_encrypt;
+        uint16_t        sadb_comb_flags;
+        uint16_t        sadb_comb_auth_minbits;
+        uint16_t        sadb_comb_auth_maxbits;
+        uint16_t        sadb_comb_encrypt_minbits;
+        uint16_t        sadb_comb_encrypt_maxbits;
+        uint32_t        sadb_comb_reserved;
+        uint32_t        sadb_comb_soft_allocations;
+        uint32_t        sadb_comb_hard_allocations;
+        uint64_t        sadb_comb_soft_bytes;
+        uint64_t        sadb_comb_hard_bytes;
+        uint64_t        sadb_comb_soft_addtime;
+        uint64_t        sadb_comb_hard_addtime;
+        uint64_t        sadb_comb_soft_usetime;
+        uint64_t        sadb_comb_hard_usetime;
+} __attribute__((packed));
+/* sizeof(struct sadb_comb) == 72 */
+
+struct sadb_supported {
+        uint16_t        sadb_supported_len;
+        uint16_t        sadb_supported_exttype;
+        uint32_t        sadb_supported_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_supported) == 8 */
+
+/* followed by:
+        struct sadb_alg sadb_algs[(sadb_supported_len +
+                sizeof(uint64_t) - sizeof(struct sadb_supported)) /
+                sizeof(struct sadb_alg)]; */
+
+struct sadb_alg {
+        uint8_t         sadb_alg_id;
+        uint8_t         sadb_alg_ivlen;
+        uint16_t        sadb_alg_minbits;
+        uint16_t        sadb_alg_maxbits;
+        uint16_t        sadb_alg_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_alg) == 8 */
+
+struct sadb_spirange {
+        uint16_t        sadb_spirange_len;
+        uint16_t        sadb_spirange_exttype;
+        uint32_t        sadb_spirange_min;
+        uint32_t        sadb_spirange_max;
+        uint32_t        sadb_spirange_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_spirange) == 16 */
+
+struct sadb_x_kmprivate {
+        uint16_t        sadb_x_kmprivate_len;
+        uint16_t        sadb_x_kmprivate_exttype;
+        u_int32_t       sadb_x_kmprivate_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_x_kmprivate) == 8 */
+
+struct sadb_x_sa2 {
+        uint16_t        sadb_x_sa2_len;
+        uint16_t        sadb_x_sa2_exttype;
+        uint8_t         sadb_x_sa2_mode;
+        uint8_t         sadb_x_sa2_reserved1;
+        uint16_t        sadb_x_sa2_reserved2;
+        uint32_t        sadb_x_sa2_sequence;
+        uint32_t        sadb_x_sa2_reqid;
+} __attribute__((packed));
+/* sizeof(struct sadb_x_sa2) == 16 */
+
+struct sadb_x_policy {
+        uint16_t        sadb_x_policy_len;
+        uint16_t        sadb_x_policy_exttype;
+        uint16_t        sadb_x_policy_type;
+        uint8_t         sadb_x_policy_dir;
+        uint8_t         sadb_x_policy_reserved;
+        uint32_t        sadb_x_policy_id;
+        uint32_t        sadb_x_policy_priority;
+} __attribute__((packed));
+/* sizeof(struct sadb_x_policy) == 16 */
+
+struct sadb_x_ipsecrequest {
+        uint16_t        sadb_x_ipsecrequest_len;
+        uint16_t        sadb_x_ipsecrequest_proto;
+        uint8_t         sadb_x_ipsecrequest_mode;
+        uint8_t         sadb_x_ipsecrequest_level;
+        uint16_t        sadb_x_ipsecrequest_reserved1;
+        uint32_t        sadb_x_ipsecrequest_reqid;
+        uint32_t        sadb_x_ipsecrequest_reserved2;
+} __attribute__((packed));
+/* sizeof(struct sadb_x_ipsecrequest) == 16 */
+
+/* This defines the TYPE of Nat Traversal in use.  Currently only one
+ * type of NAT-T is supported, draft-ietf-ipsec-udp-encaps-06
+ */
+struct sadb_x_nat_t_type {
+        uint16_t        sadb_x_nat_t_type_len;
+        uint16_t        sadb_x_nat_t_type_exttype;
+        uint8_t         sadb_x_nat_t_type_type;
+        uint8_t         sadb_x_nat_t_type_reserved[3];
+} __attribute__((packed));
+/* sizeof(struct sadb_x_nat_t_type) == 8 */
+
+/* Pass a NAT Traversal port (Source or Dest port) */
+struct sadb_x_nat_t_port {
+        uint16_t        sadb_x_nat_t_port_len;
+        uint16_t        sadb_x_nat_t_port_exttype;
+        uint16_t        sadb_x_nat_t_port_port;
+        uint16_t        sadb_x_nat_t_port_reserved;
+} __attribute__((packed));
+/* sizeof(struct sadb_x_nat_t_port) == 8 */
+
+/* Message types */
+#define SADB_RESERVED           0
+#define SADB_GETSPI             1
+#define SADB_UPDATE             2
+#define SADB_ADD                3
+#define SADB_DELETE             4
+#define SADB_GET                5
+#define SADB_ACQUIRE            6
+#define SADB_REGISTER           7
+#define SADB_EXPIRE             8
+#define SADB_FLUSH              9
+#define SADB_DUMP               10
+#define SADB_X_PROMISC          11
+#define SADB_X_PCHANGE          12
+#define SADB_X_SPDUPDATE        13
+#define SADB_X_SPDADD           14
+#define SADB_X_SPDDELETE        15
+#define SADB_X_SPDGET           16
+#define SADB_X_SPDACQUIRE       17
+#define SADB_X_SPDDUMP          18
+#define SADB_X_SPDFLUSH         19
+#define SADB_X_SPDSETIDX        20
+#define SADB_X_SPDEXPIRE        21
+#define SADB_X_SPDDELETE2       22
+#define SADB_X_NAT_T_NEW_MAPPING        23
+#define SADB_MAX                23
+
+/* Security Association flags */
+#define SADB_SAFLAGS_PFS        1
+#define SADB_SAFLAGS_DECAP_DSCP 0x40000000
+#define SADB_SAFLAGS_NOECN      0x80000000
+
+/* Security Association states */
+#define SADB_SASTATE_LARVAL     0
+#define SADB_SASTATE_MATURE     1
+#define SADB_SASTATE_DYING      2
+#define SADB_SASTATE_DEAD       3
+#define SADB_SASTATE_MAX        3
+
+/* Security Association types */
+#define SADB_SATYPE_UNSPEC      0
+#define SADB_SATYPE_AH          2
+#define SADB_SATYPE_ESP         3
+#define SADB_SATYPE_RSVP        5
+#define SADB_SATYPE_OSPFV2      6
+#define SADB_SATYPE_RIPV2       7
+#define SADB_SATYPE_MIP         8
+#define SADB_X_SATYPE_IPCOMP    9
+#define SADB_SATYPE_MAX         9
+
+/* Authentication algorithms */
+#define SADB_AALG_NONE                  0
+#define SADB_AALG_MD5HMAC               2
+#define SADB_AALG_SHA1HMAC              3
+#define SADB_X_AALG_SHA2_256HMAC        5
+#define SADB_X_AALG_SHA2_384HMAC        6
+#define SADB_X_AALG_SHA2_512HMAC        7
+#define SADB_X_AALG_RIPEMD160HMAC       8
+#define SADB_X_AALG_NULL                251     /* kame */
+#define SADB_AALG_MAX                   251
+
+/* Encryption algorithms */
+#define SADB_EALG_NONE                  0
+#define SADB_EALG_DESCBC                2
+#define SADB_EALG_3DESCBC               3
+#define SADB_X_EALG_CASTCBC             6
+#define SADB_X_EALG_BLOWFISHCBC         7
+#define SADB_EALG_NULL                  11
+#define SADB_X_EALG_AESCBC              12
+#define SADB_EALG_MAX                   253 /* last EALG */
+/* private allocations should use 249-255 (RFC2407) */
+#define SADB_X_EALG_SERPENTCBC  252     /* draft-ietf-ipsec-ciph-aes-cbc-00 */
+#define SADB_X_EALG_TWOFISHCBC  253     /* draft-ietf-ipsec-ciph-aes-cbc-00 */
+
+/* Compression algorithms */
+#define SADB_X_CALG_NONE                0
+#define SADB_X_CALG_OUI                 1
+#define SADB_X_CALG_DEFLATE             2
+#define SADB_X_CALG_LZS                 3
+#define SADB_X_CALG_LZJH                4
+#define SADB_X_CALG_MAX                 4
+
+/* Extension Header values */
+#define SADB_EXT_RESERVED               0
+#define SADB_EXT_SA                     1
+#define SADB_EXT_LIFETIME_CURRENT       2
+#define SADB_EXT_LIFETIME_HARD          3
+#define SADB_EXT_LIFETIME_SOFT          4
+#define SADB_EXT_ADDRESS_SRC            5
+#define SADB_EXT_ADDRESS_DST            6
+#define SADB_EXT_ADDRESS_PROXY          7
+#define SADB_EXT_KEY_AUTH               8
+#define SADB_EXT_KEY_ENCRYPT            9
+#define SADB_EXT_IDENTITY_SRC           10
+#define SADB_EXT_IDENTITY_DST           11
+#define SADB_EXT_SENSITIVITY            12
+#define SADB_EXT_PROPOSAL               13
+#define SADB_EXT_SUPPORTED_AUTH         14
+#define SADB_EXT_SUPPORTED_ENCRYPT      15
+#define SADB_EXT_SPIRANGE               16
+#define SADB_X_EXT_KMPRIVATE            17
+#define SADB_X_EXT_POLICY               18
+#define SADB_X_EXT_SA2                  19
+/* The next four entries are for setting up NAT Traversal */
+#define SADB_X_EXT_NAT_T_TYPE           20
+#define SADB_X_EXT_NAT_T_SPORT          21
+#define SADB_X_EXT_NAT_T_DPORT          22
+#define SADB_X_EXT_NAT_T_OA             23
+#define SADB_EXT_MAX                    23
+
+/* Identity Extension values */
+#define SADB_IDENTTYPE_RESERVED 0
+#define SADB_IDENTTYPE_PREFIX   1
+#define SADB_IDENTTYPE_FQDN     2
+#define SADB_IDENTTYPE_USERFQDN 3
+#define SADB_IDENTTYPE_MAX      3
+
+#endif /* !(_LINUX_PFKEY2_H) */
diff --git a/include/linux/pg.h b/include/linux/pg.h
new file mode 100644
index 000000000000..db994bb0c794
--- /dev/null
+++ b/include/linux/pg.h
@@ -0,0 +1,63 @@
+/*      pg.h (c) 1998  Grant R. Guenther <grant@torque.net>
+                       Under the terms of the GNU General Public License
+
+
+        pg.h defines the user interface to the generic ATAPI packet
+        command driver for parallel port ATAPI devices (pg). The
+        driver is loosely modelled after the generic SCSI driver, sg,
+        although the actual interface is different.
+
+        The pg driver provides a simple character device interface for
+        sending ATAPI commands to a device.  With the exception of the
+        ATAPI reset operation, all operations are performed by a pair
+        of read and write operations to the appropriate /dev/pgN device.
+        A write operation delivers a command and any outbound data in
+        a single buffer.  Normally, the write will succeed unless the
+        device is offline or malfunctioning, or there is already another
+        command pending.  If the write succeeds, it should be followed
+        immediately by a read operation, to obtain any returned data and
+        status information.  A read will fail if there is no operation
+        in progress.
+
+        As a special case, the device can be reset with a write operation,
+        and in this case, no following read is expected, or permitted.
+
+        There are no ioctl() operations.  Any single operation
+        may transfer at most PG_MAX_DATA bytes.  Note that the driver must
+        copy the data through an internal buffer.  In keeping with all
+        current ATAPI devices, command packets are assumed to be exactly
+        12 bytes in length.
+
+        To permit future changes to this interface, the headers in the
+        read and write buffers contain a single character "magic" flag.
+        Currently this flag must be the character "P".
+
+*/
+
+#define PG_MAGIC        'P'
+#define PG_RESET        'Z'
+#define PG_COMMAND      'C'
+
+#define PG_MAX_DATA     32768
+
+struct pg_write_hdr {
+
+        char    magic;          /* == PG_MAGIC */
+        char    func;           /* PG_RESET or PG_COMMAND */
+        int     dlen;           /* number of bytes expected to transfer */
+        int     timeout;        /* number of seconds before timeout */
+        char    packet[12];     /* packet command */
+
+};
+
+struct pg_read_hdr {
+
+        char    magic;          /* == PG_MAGIC */
+        char    scsi;           /* "scsi" status == sense key */
+        int     dlen;           /* size of device transfer request */
+        int     duration;       /* time in seconds command took */
+        char    pad[12];        /* not used */
+
+};
+
+/* end of pg.h */
diff --git a/include/linux/phonedev.h b/include/linux/phonedev.h
new file mode 100644
index 000000000000..d54049eed0c3
--- /dev/null
+++ b/include/linux/phonedev.h
@@ -0,0 +1,26 @@
+#ifndef __LINUX_PHONEDEV_H
+#define __LINUX_PHONEDEV_H
+
+#include <linux/types.h>
+#include <linux/version.h>
+
+#ifdef __KERNEL__
+
+#include <linux/poll.h>
+
+struct phone_device {
+        struct phone_device *next;
+        struct file_operations *f_op;
+        int (*open) (struct phone_device *, struct file *);
+        int board;              /* Device private index */
+        int minor;
+};
+
+extern int phonedev_init(void);
+#define PHONE_MAJOR     100
+extern int phone_register_device(struct phone_device *, int unit);
+#define PHONE_UNIT_ANY  -1
+extern void phone_unregister_device(struct phone_device *);
+
+#endif
+#endif
diff --git a/include/linux/pid.h b/include/linux/pid.h
new file mode 100644
index 000000000000..5b2fcb19d2da
--- /dev/null
+++ b/include/linux/pid.h
@@ -0,0 +1,55 @@
+#ifndef _LINUX_PID_H
+#define _LINUX_PID_H
+
+enum pid_type
+{
+        PIDTYPE_PID,
+        PIDTYPE_TGID,
+        PIDTYPE_PGID,
+        PIDTYPE_SID,
+        PIDTYPE_MAX
+};
+
+struct pid
+{
+        /* Try to keep pid_chain in the same cacheline as nr for find_pid */
+        int nr;
+        struct hlist_node pid_chain;
+        /* list of pids with the same nr, only one of them is in the hash */
+        struct list_head pid_list;
+};
+
+#define pid_task(elem, type) \
+        list_entry(elem, struct task_struct, pids[type].pid_list)
+
+/*
+ * attach_pid() and detach_pid() must be called with the tasklist_lock
+ * write-held.
+ */
+extern int FASTCALL(attach_pid(struct task_struct *task, enum pid_type type, int nr));
+
+extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type));
+
+/*
+ * look up a PID in the hash table. Must be called with the tasklist_lock
+ * held.
+ */
+extern struct pid *FASTCALL(find_pid(enum pid_type, int));
+
+extern int alloc_pidmap(void);
+extern void FASTCALL(free_pidmap(int));
+extern void switch_exec_pids(struct task_struct *leader, struct task_struct *thread);
+
+#define do_each_task_pid(who, type, task)                               \
+        if ((task = find_task_by_pid_type(type, who))) {                \
+                prefetch((task)->pids[type].pid_list.next);             \
+                do {
+
+#define while_each_task_pid(who, type, task)                            \
+                } while (task = pid_task((task)->pids[type].pid_list.next,\
+                                                type),                  \
+                        prefetch((task)->pids[type].pid_list.next),     \
+                        hlist_unhashed(&(task)->pids[type].pid_chain)); \
+        }                                                               \
+
+#endif /* _LINUX_PID_H */
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
new file mode 100644
index 000000000000..36725e7c02c6
--- /dev/null
+++ b/include/linux/pipe_fs_i.h
@@ -0,0 +1,59 @@
+#ifndef _LINUX_PIPE_FS_I_H
+#define _LINUX_PIPE_FS_I_H
+
+#define PIPEFS_MAGIC 0x50495045
+
+#define PIPE_BUFFERS (16)
+
+struct pipe_buffer {
+        struct page *page;
+        unsigned int offset, len;
+        struct pipe_buf_operations *ops;
+};
+
+struct pipe_buf_operations {
+        int can_merge;
+        void * (*map)(struct file *, struct pipe_inode_info *, struct pipe_buffer *);
+        void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *);
+        void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
+};
+
+struct pipe_inode_info {
+        wait_queue_head_t wait;
+        unsigned int nrbufs, curbuf;
+        struct pipe_buffer bufs[PIPE_BUFFERS];
+        struct page *tmp_page;
+        unsigned int start;
+        unsigned int readers;
+        unsigned int writers;
+        unsigned int waiting_writers;
+        unsigned int r_counter;
+        unsigned int w_counter;
+        struct fasync_struct *fasync_readers;
+        struct fasync_struct *fasync_writers;
+};
+
+/* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
+   memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
+#define PIPE_SIZE               PAGE_SIZE
+
+#define PIPE_SEM(inode)         (&(inode).i_sem)
+#define PIPE_WAIT(inode)        (&(inode).i_pipe->wait)
+#define PIPE_BASE(inode)        ((inode).i_pipe->base)
+#define PIPE_START(inode)       ((inode).i_pipe->start)
+#define PIPE_LEN(inode)         ((inode).i_pipe->len)
+#define PIPE_READERS(inode)     ((inode).i_pipe->readers)
+#define PIPE_WRITERS(inode)     ((inode).i_pipe->writers)
+#define PIPE_WAITING_WRITERS(inode)     ((inode).i_pipe->waiting_writers)
+#define PIPE_RCOUNTER(inode)    ((inode).i_pipe->r_counter)
+#define PIPE_WCOUNTER(inode)    ((inode).i_pipe->w_counter)
+#define PIPE_FASYNC_READERS(inode)     (&((inode).i_pipe->fasync_readers))
+#define PIPE_FASYNC_WRITERS(inode)     (&((inode).i_pipe->fasync_writers))
+
+/* Drop the inode semaphore and wait for a pipe event, atomically */
+void pipe_wait(struct inode * inode);
+
+struct inode* pipe_new(struct inode* inode);
+void free_pipe_info(struct inode* inode);
+
+#endif
diff --git a/include/linux/pkt_cls.h b/include/linux/pkt_cls.h
new file mode 100644
index 000000000000..d2aa214d6803
--- /dev/null
+++ b/include/linux/pkt_cls.h
@@ -0,0 +1,426 @@
+#ifndef __LINUX_PKT_CLS_H
+#define __LINUX_PKT_CLS_H
+
+#include <linux/pkt_sched.h>
+
+/* I think i could have done better macros ; for now this is stolen from
+ * some arch/mips code - jhs
+*/
+#define _TC_MAKE32(x) ((x))
+
+#define _TC_MAKEMASK1(n) (_TC_MAKE32(1) << _TC_MAKE32(n))
+#define _TC_MAKEMASK(v,n) (_TC_MAKE32((_TC_MAKE32(1)<<(v))-1) << _TC_MAKE32(n))
+#define _TC_MAKEVALUE(v,n) (_TC_MAKE32(v) << _TC_MAKE32(n))
+#define _TC_GETVALUE(v,n,m) ((_TC_MAKE32(v) & _TC_MAKE32(m)) >> _TC_MAKE32(n))
+
+/* verdict bit breakdown 
+ *
+bit 0: when set -> this packet has been munged already
+
+bit 1: when set -> It is ok to munge this packet
+
+bit 2,3,4,5: Reclassify counter - sort of reverse TTL - if exceeded
+assume loop
+
+bit 6,7: Where this packet was last seen 
+0: Above the transmit example at the socket level
+1: on the Ingress
+2: on the Egress
+
+bit 8: when set --> Request not to classify on ingress. 
+
+bits 9,10,11: redirect counter -  redirect TTL. Loop avoidance
+
+ *
+ * */
+
+#define TC_MUNGED          _TC_MAKEMASK1(0)
+#define SET_TC_MUNGED(v)   ( TC_MUNGED | (v & ~TC_MUNGED))
+#define CLR_TC_MUNGED(v)   ( v & ~TC_MUNGED)
+
+#define TC_OK2MUNGE        _TC_MAKEMASK1(1)
+#define SET_TC_OK2MUNGE(v)   ( TC_OK2MUNGE | (v & ~TC_OK2MUNGE))
+#define CLR_TC_OK2MUNGE(v)   ( v & ~TC_OK2MUNGE)
+
+#define S_TC_VERD          _TC_MAKE32(2)
+#define M_TC_VERD          _TC_MAKEMASK(4,S_TC_VERD)
+#define G_TC_VERD(x)       _TC_GETVALUE(x,S_TC_VERD,M_TC_VERD)
+#define V_TC_VERD(x)       _TC_MAKEVALUE(x,S_TC_VERD)
+#define SET_TC_VERD(v,n)   ((V_TC_VERD(n)) | (v & ~M_TC_VERD))
+
+#define S_TC_FROM          _TC_MAKE32(6)
+#define M_TC_FROM          _TC_MAKEMASK(2,S_TC_FROM)
+#define G_TC_FROM(x)       _TC_GETVALUE(x,S_TC_FROM,M_TC_FROM)
+#define V_TC_FROM(x)       _TC_MAKEVALUE(x,S_TC_FROM)
+#define SET_TC_FROM(v,n)   ((V_TC_FROM(n)) | (v & ~M_TC_FROM))
+#define AT_STACK        0x0
+#define AT_INGRESS      0x1
+#define AT_EGRESS       0x2
+
+#define TC_NCLS          _TC_MAKEMASK1(8)
+#define SET_TC_NCLS(v)   ( TC_NCLS | (v & ~TC_NCLS))
+#define CLR_TC_NCLS(v)   ( v & ~TC_NCLS)
+
+#define S_TC_RTTL          _TC_MAKE32(9)
+#define M_TC_RTTL          _TC_MAKEMASK(3,S_TC_RTTL)
+#define G_TC_RTTL(x)       _TC_GETVALUE(x,S_TC_RTTL,M_TC_RTTL)
+#define V_TC_RTTL(x)       _TC_MAKEVALUE(x,S_TC_RTTL)
+#define SET_TC_RTTL(v,n)   ((V_TC_RTTL(n)) | (v & ~M_TC_RTTL))
+
+#define S_TC_AT          _TC_MAKE32(12)
+#define M_TC_AT          _TC_MAKEMASK(2,S_TC_AT)
+#define G_TC_AT(x)       _TC_GETVALUE(x,S_TC_AT,M_TC_AT)
+#define V_TC_AT(x)       _TC_MAKEVALUE(x,S_TC_AT)
+#define SET_TC_AT(v,n)   ((V_TC_AT(n)) | (v & ~M_TC_AT))
+
+/* Action attributes */
+enum
+{
+        TCA_ACT_UNSPEC,
+        TCA_ACT_KIND,
+        TCA_ACT_OPTIONS,
+        TCA_ACT_INDEX,
+        TCA_ACT_STATS,
+        __TCA_ACT_MAX
+};
+
+#define TCA_ACT_MAX __TCA_ACT_MAX
+#define TCA_OLD_COMPAT (TCA_ACT_MAX+1)
+#define TCA_ACT_MAX_PRIO 32
+#define TCA_ACT_BIND    1
+#define TCA_ACT_NOBIND  0
+#define TCA_ACT_UNBIND  1
+#define TCA_ACT_NOUNBIND        0
+#define TCA_ACT_REPLACE         1
+#define TCA_ACT_NOREPLACE       0
+#define MAX_REC_LOOP 4
+#define MAX_RED_LOOP 4
+
+#define TC_ACT_UNSPEC   (-1)
+#define TC_ACT_OK               0
+#define TC_ACT_RECLASSIFY       1
+#define TC_ACT_SHOT             2
+#define TC_ACT_PIPE             3
+#define TC_ACT_STOLEN           4
+#define TC_ACT_QUEUED           5
+#define TC_ACT_REPEAT           6
+#define TC_ACT_JUMP             0x10000000
+
+/* Action type identifiers*/
+enum
+{
+        TCA_ID_UNSPEC=0,
+        TCA_ID_POLICE=1,
+        /* other actions go here */
+        __TCA_ID_MAX=255
+};
+
+#define TCA_ID_MAX __TCA_ID_MAX
+
+struct tc_police
+{
+        __u32                   index;
+        int                     action;
+#define TC_POLICE_UNSPEC        TC_ACT_UNSPEC
+#define TC_POLICE_OK            TC_ACT_OK
+#define TC_POLICE_RECLASSIFY    TC_ACT_RECLASSIFY
+#define TC_POLICE_SHOT          TC_ACT_SHOT
+#define TC_POLICE_PIPE          TC_ACT_PIPE
+
+        __u32                   limit;
+        __u32                   burst;
+        __u32                   mtu;
+        struct tc_ratespec      rate;
+        struct tc_ratespec      peakrate;
+        int                     refcnt;
+        int                     bindcnt;
+        __u32                   capab;
+};
+
+struct tcf_t
+{
+        __u64   install;
+        __u64   lastuse;
+        __u64   expires;
+};
+
+struct tc_cnt
+{
+        int                   refcnt; 
+        int                   bindcnt;
+};
+
+#define tc_gen \
+        __u32                 index; \
+        __u32                 capab; \
+        int                   action; \
+        int                   refcnt; \
+        int                   bindcnt
+
+enum
+{
+        TCA_POLICE_UNSPEC,
+        TCA_POLICE_TBF,
+        TCA_POLICE_RATE,
+        TCA_POLICE_PEAKRATE,
+        TCA_POLICE_AVRATE,
+        TCA_POLICE_RESULT,
+        __TCA_POLICE_MAX
+#define TCA_POLICE_RESULT TCA_POLICE_RESULT
+};
+
+#define TCA_POLICE_MAX (__TCA_POLICE_MAX - 1)
+
+/* U32 filters */
+
+#define TC_U32_HTID(h) ((h)&0xFFF00000)
+#define TC_U32_USERHTID(h) (TC_U32_HTID(h)>>20)
+#define TC_U32_HASH(h) (((h)>>12)&0xFF)
+#define TC_U32_NODE(h) ((h)&0xFFF)
+#define TC_U32_KEY(h) ((h)&0xFFFFF)
+#define TC_U32_UNSPEC   0
+#define TC_U32_ROOT     (0xFFF00000)
+
+enum
+{
+        TCA_U32_UNSPEC,
+        TCA_U32_CLASSID,
+        TCA_U32_HASH,
+        TCA_U32_LINK,
+        TCA_U32_DIVISOR,
+        TCA_U32_SEL,
+        TCA_U32_POLICE,
+        TCA_U32_ACT,   
+        TCA_U32_INDEV,
+        TCA_U32_PCNT,
+        TCA_U32_MARK,
+        __TCA_U32_MAX
+};
+
+#define TCA_U32_MAX (__TCA_U32_MAX - 1)
+
+struct tc_u32_key
+{
+        __u32           mask;
+        __u32           val;
+        int             off;
+        int             offmask;
+};
+
+struct tc_u32_sel
+{
+        unsigned char           flags;
+        unsigned char           offshift;
+        unsigned char           nkeys;
+
+        __u16                   offmask;
+        __u16                   off;
+        short                   offoff;
+
+        short                   hoff;
+        __u32                   hmask;
+        struct tc_u32_key       keys[0];
+};
+
+struct tc_u32_mark
+{
+        __u32           val;
+        __u32           mask;
+        __u32           success;
+};
+
+struct tc_u32_pcnt
+{
+        __u64 rcnt;
+        __u64 rhit;
+        __u64 kcnts[0];
+};
+
+/* Flags */
+
+#define TC_U32_TERMINAL         1
+#define TC_U32_OFFSET           2
+#define TC_U32_VAROFFSET        4
+#define TC_U32_EAT              8
+
+#define TC_U32_MAXDEPTH 8
+
+
+/* RSVP filter */
+
+enum
+{
+        TCA_RSVP_UNSPEC,
+        TCA_RSVP_CLASSID,
+        TCA_RSVP_DST,
+        TCA_RSVP_SRC,
+        TCA_RSVP_PINFO,
+        TCA_RSVP_POLICE,
+        TCA_RSVP_ACT,
+        __TCA_RSVP_MAX
+};
+
+#define TCA_RSVP_MAX (__TCA_RSVP_MAX - 1 )
+
+struct tc_rsvp_gpi
+{
+        __u32   key;
+        __u32   mask;
+        int     offset;
+};
+
+struct tc_rsvp_pinfo
+{
+        struct tc_rsvp_gpi dpi;
+        struct tc_rsvp_gpi spi;
+        __u8    protocol;
+        __u8    tunnelid;
+        __u8    tunnelhdr;
+};
+
+/* ROUTE filter */
+
+enum
+{
+        TCA_ROUTE4_UNSPEC,
+        TCA_ROUTE4_CLASSID,
+        TCA_ROUTE4_TO,
+        TCA_ROUTE4_FROM,
+        TCA_ROUTE4_IIF,
+        TCA_ROUTE4_POLICE,
+        TCA_ROUTE4_ACT,
+        __TCA_ROUTE4_MAX
+};
+
+#define TCA_ROUTE4_MAX (__TCA_ROUTE4_MAX - 1)
+
+
+/* FW filter */
+
+enum
+{
+        TCA_FW_UNSPEC,
+        TCA_FW_CLASSID,
+        TCA_FW_POLICE,
+        TCA_FW_INDEV, /*  used by CONFIG_NET_CLS_IND */
+        TCA_FW_ACT, /* used by CONFIG_NET_CLS_ACT */
+        __TCA_FW_MAX
+};
+
+#define TCA_FW_MAX (__TCA_FW_MAX - 1)
+
+/* TC index filter */
+
+enum
+{
+        TCA_TCINDEX_UNSPEC,
+        TCA_TCINDEX_HASH,
+        TCA_TCINDEX_MASK,
+        TCA_TCINDEX_SHIFT,
+        TCA_TCINDEX_FALL_THROUGH,
+        TCA_TCINDEX_CLASSID,
+        TCA_TCINDEX_POLICE,
+        TCA_TCINDEX_ACT,
+        __TCA_TCINDEX_MAX
+};
+
+#define TCA_TCINDEX_MAX     (__TCA_TCINDEX_MAX - 1)
+
+/* Basic filter */
+
+enum
+{
+        TCA_BASIC_UNSPEC,
+        TCA_BASIC_CLASSID,
+        TCA_BASIC_EMATCHES,
+        TCA_BASIC_ACT,
+        TCA_BASIC_POLICE,
+        __TCA_BASIC_MAX
+};
+
+#define TCA_BASIC_MAX (__TCA_BASIC_MAX - 1)
+
+/* Extended Matches */
+
+struct tcf_ematch_tree_hdr
+{
+        __u16           nmatches;
+        __u16           progid;
+};
+
+enum
+{
+        TCA_EMATCH_TREE_UNSPEC,
+        TCA_EMATCH_TREE_HDR,
+        TCA_EMATCH_TREE_LIST,
+        __TCA_EMATCH_TREE_MAX
+};
+#define TCA_EMATCH_TREE_MAX (__TCA_EMATCH_TREE_MAX - 1)
+
+struct tcf_ematch_hdr
+{
+        __u16           matchid;
+        __u16           kind;
+        __u16           flags;
+        __u16           pad; /* currently unused */
+};
+
+/*  0                   1
+ *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 
+ * +-----------------------+-+-+---+
+ * |         Unused        |S|I| R |
+ * +-----------------------+-+-+---+
+ *
+ * R(2) ::= relation to next ematch
+ *          where: 0 0 END (last ematch)
+ *                 0 1 AND
+ *                 1 0 OR
+ *                 1 1 Unused (invalid)
+ * I(1) ::= invert result
+ * S(1) ::= simple payload
+ */
+#define TCF_EM_REL_END  0
+#define TCF_EM_REL_AND  (1<<0)
+#define TCF_EM_REL_OR   (1<<1)
+#define TCF_EM_INVERT   (1<<2)
+#define TCF_EM_SIMPLE   (1<<3)
+
+#define TCF_EM_REL_MASK 3
+#define TCF_EM_REL_VALID(v) (((v) & TCF_EM_REL_MASK) != TCF_EM_REL_MASK)
+
+enum
+{
+        TCF_LAYER_LINK,
+        TCF_LAYER_NETWORK,
+        TCF_LAYER_TRANSPORT,
+        __TCF_LAYER_MAX
+};
+#define TCF_LAYER_MAX (__TCF_LAYER_MAX - 1)
+
+/* Ematch type assignments
+ *   1..32767           Reserved for ematches inside kernel tree
+ *   32768..65535       Free to use, not reliable
+ */
+enum
+{
+        TCF_EM_CONTAINER,
+        TCF_EM_CMP,
+        TCF_EM_NBYTE,
+        TCF_EM_U32,
+        TCF_EM_META,
+        __TCF_EM_MAX
+};
+
+enum
+{
+        TCF_EM_PROG_TC
+};
+
+enum
+{
+        TCF_EM_OPND_EQ,
+        TCF_EM_OPND_GT,
+        TCF_EM_OPND_LT
+};
+
+#endif
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
new file mode 100644
index 000000000000..73d84c071cb1
--- /dev/null
+++ b/include/linux/pkt_sched.h
@@ -0,0 +1,454 @@
+#ifndef __LINUX_PKT_SCHED_H
+#define __LINUX_PKT_SCHED_H
+
+/* Logical priority bands not depending on specific packet scheduler.
+   Every scheduler will map them to real traffic classes, if it has
+   no more precise mechanism to classify packets.
+
+   These numbers have no special meaning, though their coincidence
+   with obsolete IPv6 values is not occasional :-). New IPv6 drafts
+   preferred full anarchy inspired by diffserv group.
+
+   Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
+   class, actually, as rule it will be handled with more care than
+   filler or even bulk.
+ */
+
+#define TC_PRIO_BESTEFFORT              0
+#define TC_PRIO_FILLER                  1
+#define TC_PRIO_BULK                    2
+#define TC_PRIO_INTERACTIVE_BULK        4
+#define TC_PRIO_INTERACTIVE             6
+#define TC_PRIO_CONTROL                 7
+
+#define TC_PRIO_MAX                     15
+
+/* Generic queue statistics, available for all the elements.
+   Particular schedulers may have also their private records.
+ */
+
+struct tc_stats
+{
+        __u64   bytes;                  /* NUmber of enqueues bytes */
+        __u32   packets;                /* Number of enqueued packets   */
+        __u32   drops;                  /* Packets dropped because of lack of resources */
+        __u32   overlimits;             /* Number of throttle events when this
+                                         * flow goes out of allocated bandwidth */
+        __u32   bps;                    /* Current flow byte rate */
+        __u32   pps;                    /* Current flow packet rate */
+        __u32   qlen;
+        __u32   backlog;
+};
+
+struct tc_estimator
+{
+        signed char     interval;
+        unsigned char   ewma_log;
+};
+
+/* "Handles"
+   ---------
+
+    All the traffic control objects have 32bit identifiers, or "handles".
+
+    They can be considered as opaque numbers from user API viewpoint,
+    but actually they always consist of two fields: major and
+    minor numbers, which are interpreted by kernel specially,
+    that may be used by applications, though not recommended.
+
+    F.e. qdisc handles always have minor number equal to zero,
+    classes (or flows) have major equal to parent qdisc major, and
+    minor uniquely identifying class inside qdisc.
+
+    Macros to manipulate handles:
+ */
+
+#define TC_H_MAJ_MASK (0xFFFF0000U)
+#define TC_H_MIN_MASK (0x0000FFFFU)
+#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
+#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
+#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
+
+#define TC_H_UNSPEC     (0U)
+#define TC_H_ROOT       (0xFFFFFFFFU)
+#define TC_H_INGRESS    (0xFFFFFFF1U)
+
+struct tc_ratespec
+{
+        unsigned char   cell_log;
+        unsigned char   __reserved;
+        unsigned short  feature;
+        short           addend;
+        unsigned short  mpu;
+        __u32           rate;
+};
+
+/* FIFO section */
+
+struct tc_fifo_qopt
+{
+        __u32   limit;  /* Queue length: bytes for bfifo, packets for pfifo */
+};
+
+/* PRIO section */
+
+#define TCQ_PRIO_BANDS  16
+
+struct tc_prio_qopt
+{
+        int     bands;                  /* Number of bands */
+        __u8    priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
+};
+
+/* TBF section */
+
+struct tc_tbf_qopt
+{
+        struct tc_ratespec rate;
+        struct tc_ratespec peakrate;
+        __u32           limit;
+        __u32           buffer;
+        __u32           mtu;
+};
+
+enum
+{
+        TCA_TBF_UNSPEC,
+        TCA_TBF_PARMS,
+        TCA_TBF_RTAB,
+        TCA_TBF_PTAB,
+        __TCA_TBF_MAX,
+};
+
+#define TCA_TBF_MAX (__TCA_TBF_MAX - 1)
+
+
+/* TEQL section */
+
+/* TEQL does not require any parameters */
+
+/* SFQ section */
+
+struct tc_sfq_qopt
+{
+        unsigned        quantum;        /* Bytes per round allocated to flow */
+        int             perturb_period; /* Period of hash perturbation */
+        __u32           limit;          /* Maximal packets in queue */
+        unsigned        divisor;        /* Hash divisor  */
+        unsigned        flows;          /* Maximal number of flows  */
+};
+
+/*
+ *  NOTE: limit, divisor and flows are hardwired to code at the moment.
+ *
+ *      limit=flows=128, divisor=1024;
+ *
+ *      The only reason for this is efficiency, it is possible
+ *      to change these parameters in compile time.
+ */
+
+/* RED section */
+
+enum
+{
+        TCA_RED_UNSPEC,
+        TCA_RED_PARMS,
+        TCA_RED_STAB,
+        __TCA_RED_MAX,
+};
+
+#define TCA_RED_MAX (__TCA_RED_MAX - 1)
+
+struct tc_red_qopt
+{
+        __u32           limit;          /* HARD maximal queue length (bytes)    */
+        __u32           qth_min;        /* Min average length threshold (bytes) */
+        __u32           qth_max;        /* Max average length threshold (bytes) */
+        unsigned char   Wlog;           /* log(W)               */
+        unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+        unsigned char   Scell_log;      /* cell size for idle damping */
+        unsigned char   flags;
+#define TC_RED_ECN      1
+};
+
+struct tc_red_xstats
+{
+        __u32           early;          /* Early drops */
+        __u32           pdrop;          /* Drops due to queue limits */
+        __u32           other;          /* Drops due to drop() calls */
+        __u32           marked;         /* Marked packets */
+};
+
+/* GRED section */
+
+#define MAX_DPs 16
+
+enum
+{
+       TCA_GRED_UNSPEC,
+       TCA_GRED_PARMS,
+       TCA_GRED_STAB,
+       TCA_GRED_DPS,
+           __TCA_GRED_MAX,
+};
+
+#define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
+
+#define TCA_SET_OFF TCA_GRED_PARMS
+struct tc_gred_qopt
+{
+       __u32           limit;          /* HARD maximal queue length (bytes)    
+*/
+       __u32           qth_min;        /* Min average length threshold (bytes) 
+*/
+       __u32           qth_max;        /* Max average length threshold (bytes) 
+*/
+       __u32           DP;             /* upto 2^32 DPs */
+       __u32           backlog;        
+       __u32           qave;   
+       __u32           forced; 
+       __u32           early;  
+       __u32           other;  
+       __u32           pdrop;  
+
+       unsigned char   Wlog;           /* log(W)               */
+       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+       unsigned char   Scell_log;      /* cell size for idle damping */
+       __u8            prio;            /* prio of this VQ */
+       __u32    packets;
+       __u32    bytesin;
+};
+/* gred setup */
+struct tc_gred_sopt
+{
+       __u32           DPs;
+       __u32           def_DP;
+       __u8            grio;
+};
+
+/* HTB section */
+#define TC_HTB_NUMPRIO          8
+#define TC_HTB_MAXDEPTH         8
+#define TC_HTB_PROTOVER         3 /* the same as HTB and TC's major */
+
+struct tc_htb_opt
+{
+        struct tc_ratespec      rate;
+        struct tc_ratespec      ceil;
+        __u32   buffer;
+        __u32   cbuffer;
+        __u32   quantum;
+        __u32   level;          /* out only */
+        __u32   prio;
+};
+struct tc_htb_glob
+{
+        __u32 version;          /* to match HTB/TC */
+        __u32 rate2quantum;     /* bps->quantum divisor */
+        __u32 defcls;           /* default class number */
+        __u32 debug;            /* debug flags */
+
+        /* stats */
+        __u32 direct_pkts; /* count of non shapped packets */
+};
+enum
+{
+        TCA_HTB_UNSPEC,
+        TCA_HTB_PARMS,
+        TCA_HTB_INIT,
+        TCA_HTB_CTAB,
+        TCA_HTB_RTAB,
+        __TCA_HTB_MAX,
+};
+
+#define TCA_HTB_MAX (__TCA_HTB_MAX - 1)
+
+struct tc_htb_xstats
+{
+        __u32 lends;
+        __u32 borrows;
+        __u32 giants;   /* too big packets (rate will not be accurate) */
+        __u32 tokens;
+        __u32 ctokens;
+};
+
+/* HFSC section */
+
+struct tc_hfsc_qopt
+{
+        __u16   defcls;         /* default class */
+};
+
+struct tc_service_curve
+{
+        __u32   m1;             /* slope of the first segment in bps */
+        __u32   d;              /* x-projection of the first segment in us */
+        __u32   m2;             /* slope of the second segment in bps */
+};
+
+struct tc_hfsc_stats
+{
+        __u64   work;           /* total work done */
+        __u64   rtwork;         /* work done by real-time criteria */
+        __u32   period;         /* current period */
+        __u32   level;          /* class level in hierarchy */
+};
+
+enum
+{
+        TCA_HFSC_UNSPEC,
+        TCA_HFSC_RSC,
+        TCA_HFSC_FSC,
+        TCA_HFSC_USC,
+        __TCA_HFSC_MAX,
+};
+
+#define TCA_HFSC_MAX (__TCA_HFSC_MAX - 1)
+
+
+/* CBQ section */
+
+#define TC_CBQ_MAXPRIO          8
+#define TC_CBQ_MAXLEVEL         8
+#define TC_CBQ_DEF_EWMA         5
+
+struct tc_cbq_lssopt
+{
+        unsigned char   change;
+        unsigned char   flags;
+#define TCF_CBQ_LSS_BOUNDED     1
+#define TCF_CBQ_LSS_ISOLATED    2
+        unsigned char   ewma_log;
+        unsigned char   level;
+#define TCF_CBQ_LSS_FLAGS       1
+#define TCF_CBQ_LSS_EWMA        2
+#define TCF_CBQ_LSS_MAXIDLE     4
+#define TCF_CBQ_LSS_MINIDLE     8
+#define TCF_CBQ_LSS_OFFTIME     0x10
+#define TCF_CBQ_LSS_AVPKT       0x20
+        __u32           maxidle;
+        __u32           minidle;
+        __u32           offtime;
+        __u32           avpkt;
+};
+
+struct tc_cbq_wrropt
+{
+        unsigned char   flags;
+        unsigned char   priority;
+        unsigned char   cpriority;
+        unsigned char   __reserved;
+        __u32           allot;
+        __u32           weight;
+};
+
+struct tc_cbq_ovl
+{
+        unsigned char   strategy;
+#define TC_CBQ_OVL_CLASSIC      0
+#define TC_CBQ_OVL_DELAY        1
+#define TC_CBQ_OVL_LOWPRIO      2
+#define TC_CBQ_OVL_DROP         3
+#define TC_CBQ_OVL_RCLASSIC     4
+        unsigned char   priority2;
+        __u32           penalty;
+};
+
+struct tc_cbq_police
+{
+        unsigned char   police;
+        unsigned char   __res1;
+        unsigned short  __res2;
+};
+
+struct tc_cbq_fopt
+{
+        __u32           split;
+        __u32           defmap;
+        __u32           defchange;
+};
+
+struct tc_cbq_xstats
+{
+        __u32           borrows;
+        __u32           overactions;
+        __s32           avgidle;
+        __s32           undertime;
+};
+
+enum
+{
+        TCA_CBQ_UNSPEC,
+        TCA_CBQ_LSSOPT,
+        TCA_CBQ_WRROPT,
+        TCA_CBQ_FOPT,
+        TCA_CBQ_OVL_STRATEGY,
+        TCA_CBQ_RATE,
+        TCA_CBQ_RTAB,
+        TCA_CBQ_POLICE,
+        __TCA_CBQ_MAX,
+};
+
+#define TCA_CBQ_MAX     (__TCA_CBQ_MAX - 1)
+
+/* dsmark section */
+
+enum {
+        TCA_DSMARK_UNSPEC,
+        TCA_DSMARK_INDICES,
+        TCA_DSMARK_DEFAULT_INDEX,
+        TCA_DSMARK_SET_TC_INDEX,
+        TCA_DSMARK_MASK,
+        TCA_DSMARK_VALUE,
+        __TCA_DSMARK_MAX,
+};
+
+#define TCA_DSMARK_MAX (__TCA_DSMARK_MAX - 1)
+
+/* ATM  section */
+
+enum {
+        TCA_ATM_UNSPEC,
+        TCA_ATM_FD,             /* file/socket descriptor */
+        TCA_ATM_PTR,            /* pointer to descriptor - later */
+        TCA_ATM_HDR,            /* LL header */
+        TCA_ATM_EXCESS,         /* excess traffic class (0 for CLP)  */
+        TCA_ATM_ADDR,           /* PVC address (for output only) */
+        TCA_ATM_STATE,          /* VC state (ATM_VS_*; for output only) */
+        __TCA_ATM_MAX,
+};
+
+#define TCA_ATM_MAX     (__TCA_ATM_MAX - 1)
+
+/* Network emulator */
+
+enum
+{
+        TCA_NETEM_UNSPEC,
+        TCA_NETEM_CORR,
+        TCA_NETEM_DELAY_DIST,
+        __TCA_NETEM_MAX,
+};
+
+#define TCA_NETEM_MAX (__TCA_NETEM_MAX - 1)
+
+struct tc_netem_qopt
+{
+        __u32   latency;        /* added delay (us) */
+        __u32   limit;          /* fifo limit (packets) */
+        __u32   loss;           /* random packet loss (0=none ~0=100%) */
+        __u32   gap;            /* re-ordering gap (0 for delay all) */
+        __u32   duplicate;      /* random packet dup  (0=none ~0=100%) */
+        __u32   jitter;         /* random jitter in latency (us) */
+};
+
+struct tc_netem_corr
+{
+        __u32   delay_corr;     /* delay correlation */
+        __u32   loss_corr;      /* packet loss correlation */
+        __u32   dup_corr;       /* duplicate correlation  */
+};
+
+#define NETEM_DIST_SCALE        8192
+
+#endif
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
new file mode 100644
index 000000000000..4e2d2a942ecb
--- /dev/null
+++ b/include/linux/pktcdvd.h
@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2000 Jens Axboe <axboe@suse.de>
+ * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
+ *
+ * May be copied or modified under the terms of the GNU General Public
+ * License.  See linux/COPYING for more information.
+ *
+ * Packet writing layer for ATAPI and SCSI CD-R, CD-RW, DVD-R, and
+ * DVD-RW devices.
+ *
+ */
+#ifndef __PKTCDVD_H
+#define __PKTCDVD_H
+
+#include <linux/types.h>
+
+/*
+ * 1 for normal debug messages, 2 is very verbose. 0 to turn it off.
+ */
+#define PACKET_DEBUG            1
+
+#define MAX_WRITERS             8
+
+#define PKT_RB_POOL_SIZE        512
+
+/*
+ * How long we should hold a non-full packet before starting data gathering.
+ */
+#define PACKET_WAIT_TIME        (HZ * 5 / 1000)
+
+/*
+ * use drive write caching -- we need deferred error handling to be
+ * able to sucessfully recover with this option (drive will return good
+ * status as soon as the cdb is validated).
+ */
+#if defined(CONFIG_CDROM_PKTCDVD_WCACHE)
+#define USE_WCACHING            1
+#else
+#define USE_WCACHING            0
+#endif
+
+/*
+ * No user-servicable parts beyond this point ->
+ */
+
+/*
+ * device types
+ */
+#define PACKET_CDR              1
+#define PACKET_CDRW             2
+#define PACKET_DVDR             3
+#define PACKET_DVDRW            4
+
+/*
+ * flags
+ */
+#define PACKET_WRITABLE         1       /* pd is writable */
+#define PACKET_NWA_VALID        2       /* next writable address valid */
+#define PACKET_LRA_VALID        3       /* last recorded address valid */
+#define PACKET_MERGE_SEGS       4       /* perform segment merging to keep */
+                                        /* underlying cdrom device happy */
+
+/*
+ * Disc status -- from READ_DISC_INFO
+ */
+#define PACKET_DISC_EMPTY       0
+#define PACKET_DISC_INCOMPLETE  1
+#define PACKET_DISC_COMPLETE    2
+#define PACKET_DISC_OTHER       3
+
+/*
+ * write type, and corresponding data block type
+ */
+#define PACKET_MODE1            1
+#define PACKET_MODE2            2
+#define PACKET_BLOCK_MODE1      8
+#define PACKET_BLOCK_MODE2      10
+
+/*
+ * Last session/border status
+ */
+#define PACKET_SESSION_EMPTY            0
+#define PACKET_SESSION_INCOMPLETE       1
+#define PACKET_SESSION_RESERVED         2
+#define PACKET_SESSION_COMPLETE         3
+
+#define PACKET_MCN                      "4a656e734178626f65323030300000"
+
+#undef PACKET_USE_LS
+
+#define PKT_CTRL_CMD_SETUP      0
+#define PKT_CTRL_CMD_TEARDOWN   1
+#define PKT_CTRL_CMD_STATUS     2
+
+struct pkt_ctrl_command {
+        __u32 command;                          /* in: Setup, teardown, status */
+        __u32 dev_index;                        /* in/out: Device index */
+        __u32 dev;                              /* in/out: Device nr for cdrw device */
+        __u32 pkt_dev;                          /* in/out: Device nr for packet device */
+        __u32 num_devices;                      /* out: Largest device index + 1 */
+        __u32 padding;                          /* Not used */
+};
+
+/*
+ * packet ioctls
+ */
+#define PACKET_IOCTL_MAGIC      ('X')
+#define PACKET_CTRL_CMD         _IOWR(PACKET_IOCTL_MAGIC, 1, struct pkt_ctrl_command)
+
+#ifdef __KERNEL__
+#include <linux/blkdev.h>
+#include <linux/completion.h>
+#include <linux/cdrom.h>
+
+struct packet_settings
+{
+        __u8                    size;           /* packet size in (512 byte) sectors */
+        __u8                    fp;             /* fixed packets */
+        __u8                    link_loss;      /* the rest is specified
+                                                 * as per Mt Fuji */
+        __u8                    write_type;
+        __u8                    track_mode;
+        __u8                    block_mode;
+};
+
+/*
+ * Very crude stats for now
+ */
+struct packet_stats
+{
+        unsigned long           pkt_started;
+        unsigned long           pkt_ended;
+        unsigned long           secs_w;
+        unsigned long           secs_rg;
+        unsigned long           secs_r;
+};
+
+struct packet_cdrw
+{
+        struct list_head        pkt_free_list;
+        struct list_head        pkt_active_list;
+        spinlock_t              active_list_lock; /* Serialize access to pkt_active_list */
+        struct task_struct      *thread;
+        atomic_t                pending_bios;
+};
+
+/*
+ * Switch to high speed reading after reading this many kilobytes
+ * with no interspersed writes.
+ */
+#define HI_SPEED_SWITCH 512
+
+struct packet_iosched
+{
+        atomic_t                attention;      /* Set to non-zero when queue processing is needed */
+        int                     writing;        /* Non-zero when writing, zero when reading */
+        spinlock_t              lock;           /* Protecting read/write queue manipulations */
+        struct bio              *read_queue;
+        struct bio              *read_queue_tail;
+        struct bio              *write_queue;
+        struct bio              *write_queue_tail;
+        int                     high_prio_read; /* An important read request has been queued */
+        int                     successive_reads;
+};
+
+/*
+ * 32 buffers of 2048 bytes
+ */
+#define PACKET_MAX_SIZE         32
+#define PAGES_PER_PACKET        (PACKET_MAX_SIZE * CD_FRAMESIZE / PAGE_SIZE)
+#define PACKET_MAX_SECTORS      (PACKET_MAX_SIZE * CD_FRAMESIZE >> 9)
+
+enum packet_data_state {
+        PACKET_IDLE_STATE,                      /* Not used at the moment */
+        PACKET_WAITING_STATE,                   /* Waiting for more bios to arrive, so */
+                                                /* we don't have to do as much */
+                                                /* data gathering */
+        PACKET_READ_WAIT_STATE,                 /* Waiting for reads to fill in holes */
+        PACKET_WRITE_WAIT_STATE,                /* Waiting for the write to complete */
+        PACKET_RECOVERY_STATE,                  /* Recover after read/write errors */
+        PACKET_FINISHED_STATE,                  /* After write has finished */
+
+        PACKET_NUM_STATES                       /* Number of possible states */
+};
+
+/*
+ * Information needed for writing a single packet
+ */
+struct pktcdvd_device;
+
+struct packet_data
+{
+        struct list_head        list;
+
+        spinlock_t              lock;           /* Lock protecting state transitions and */
+                                                /* orig_bios list */
+
+        struct bio              *orig_bios;     /* Original bios passed to pkt_make_request */
+        struct bio              *orig_bios_tail;/* that will be handled by this packet */
+        int                     write_size;     /* Total size of all bios in the orig_bios */
+                                                /* list, measured in number of frames */
+
+        struct bio              *w_bio;         /* The bio we will send to the real CD */
+                                                /* device once we have all data for the */
+                                                /* packet we are going to write */
+        sector_t                sector;         /* First sector in this packet */
+        int                     frames;         /* Number of frames in this packet */
+
+        enum packet_data_state  state;          /* Current state */
+        atomic_t                run_sm;         /* Incremented whenever the state */
+                                                /* machine needs to be run */
+        long                    sleep_time;     /* Set this to non-zero to make the state */
+                                                /* machine run after this many jiffies. */
+
+        atomic_t                io_wait;        /* Number of pending IO operations */
+        atomic_t                io_errors;      /* Number of read/write errors during IO */
+
+        struct bio              *r_bios[PACKET_MAX_SIZE]; /* bios to use during data gathering */
+        struct page             *pages[PAGES_PER_PACKET];
+
+        int                     cache_valid;    /* If non-zero, the data for the zone defined */
+                                                /* by the sector variable is completely cached */
+                                                /* in the pages[] vector. */
+
+        int                     id;             /* ID number for debugging */
+        struct pktcdvd_device   *pd;
+};
+
+struct pkt_rb_node {
+        struct rb_node          rb_node;
+        struct bio              *bio;
+};
+
+struct packet_stacked_data
+{
+        struct bio              *bio;           /* Original read request bio */
+        struct pktcdvd_device   *pd;
+};
+#define PSD_POOL_SIZE           64
+
+struct pktcdvd_device
+{
+        struct block_device     *bdev;          /* dev attached */
+        dev_t                   pkt_dev;        /* our dev */
+        char                    name[20];
+        struct packet_settings  settings;
+        struct packet_stats     stats;
+        int                     refcnt;         /* Open count */
+        int                     write_speed;    /* current write speed, kB/s */
+        int                     read_speed;     /* current read speed, kB/s */
+        unsigned long           offset;         /* start offset */
+        __u8                    mode_offset;    /* 0 / 8 */
+        __u8                    type;
+        unsigned long           flags;
+        __u16                   mmc3_profile;
+        __u32                   nwa;            /* next writable address */
+        __u32                   lra;            /* last recorded address */
+        struct packet_cdrw      cdrw;
+        wait_queue_head_t       wqueue;
+
+        spinlock_t              lock;           /* Serialize access to bio_queue */
+        struct rb_root          bio_queue;      /* Work queue of bios we need to handle */
+        int                     bio_queue_size; /* Number of nodes in bio_queue */
+        sector_t                current_sector; /* Keep track of where the elevator is */
+        atomic_t                scan_queue;     /* Set to non-zero when pkt_handle_queue */
+                                                /* needs to be run. */
+        mempool_t               *rb_pool;       /* mempool for pkt_rb_node allocations */
+
+        struct packet_iosched   iosched;
+        struct gendisk          *disk;
+};
+
+#endif /* __KERNEL__ */
+
+#endif /* __PKTCDVD_H */
diff --git a/include/linux/platform.h b/include/linux/platform.h
new file mode 100644
index 000000000000..3c33084a6ec2
--- /dev/null
+++ b/include/linux/platform.h
@@ -0,0 +1,43 @@
+/*
+ * include/linux/platform.h - platform driver definitions
+ *
+ * Because of the prolific consumerism of the average American,
+ * and the dominant marketing budgets of PC OEMs, we have been
+ * blessed with frequent updates of the PC architecture. 
+ *
+ * While most of these calls are singular per architecture, they 
+ * require an extra layer of abstraction on the x86 so the right
+ * subsystem gets the right call. 
+ *
+ * Basically, this consolidates the power off and reboot callbacks 
+ * into one structure, as well as adding power management hooks.
+ *
+ * When adding a platform driver, please make sure all callbacks are 
+ * filled. There are defaults defined below that do nothing; use those
+ * if you do not support that callback.
+ */ 
+
+#ifndef _PLATFORM_H_
+#define _PLATFORM_H_
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+
+struct platform_t {
+        char    * name;
+        u32     suspend_states;
+        void    (*reboot)(char * cmd);
+        void    (*halt)(void);
+        void    (*power_off)(void);
+        int     (*suspend)(int state, int flags);
+        void    (*idle)(void);
+};
+
+extern struct platform_t * platform;
+extern void default_reboot(char * cmd);
+extern void default_halt(void);
+extern int default_suspend(int state, int flags);
+extern void default_idle(void);
+
+#endif /* __KERNEL__ */
+#endif /* _PLATFORM_H */
diff --git a/include/linux/pm.h b/include/linux/pm.h
new file mode 100644
index 000000000000..ed2b76e75199
--- /dev/null
+++ b/include/linux/pm.h
@@ -0,0 +1,233 @@
+/*
+ *  pm.h - Power management interface
+ *
+ *  Copyright (C) 2000 Andrew Henroid
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_PM_H
+#define _LINUX_PM_H
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/list.h>
+#include <asm/atomic.h>
+
+/*
+ * Power management requests... these are passed to pm_send_all() and friends.
+ *
+ * these functions are old and deprecated, see below.
+ */
+typedef int __bitwise pm_request_t;
+
+#define PM_SUSPEND      ((__force pm_request_t) 1)      /* enter D1-D3 */
+#define PM_RESUME       ((__force pm_request_t) 2)      /* enter D0 */
+
+
+/*
+ * Device types... these are passed to pm_register
+ */
+typedef int __bitwise pm_dev_t;
+
+#define PM_UNKNOWN_DEV  ((__force pm_dev_t) 0)  /* generic */
+#define PM_SYS_DEV      ((__force pm_dev_t) 1)  /* system device (fan, KB controller, ...) */
+#define PM_PCI_DEV      ((__force pm_dev_t) 2)  /* PCI device */
+#define PM_USB_DEV      ((__force pm_dev_t) 3)  /* USB device */
+#define PM_SCSI_DEV     ((__force pm_dev_t) 4)  /* SCSI device */
+#define PM_ISA_DEV      ((__force pm_dev_t) 5)  /* ISA device */
+#define PM_MTD_DEV      ((__force pm_dev_t) 6)  /* Memory Technology Device */
+
+/*
+ * System device hardware ID (PnP) values
+ */
+enum
+{
+        PM_SYS_UNKNOWN = 0x00000000, /* generic */
+        PM_SYS_KBC =     0x41d00303, /* keyboard controller */
+        PM_SYS_COM =     0x41d00500, /* serial port */
+        PM_SYS_IRDA =    0x41d00510, /* IRDA controller */
+        PM_SYS_FDC =     0x41d00700, /* floppy controller */
+        PM_SYS_VGA =     0x41d00900, /* VGA controller */
+        PM_SYS_PCMCIA =  0x41d00e00, /* PCMCIA controller */
+};
+
+/*
+ * Device identifier
+ */
+#define PM_PCI_ID(dev) ((dev)->bus->number << 16 | (dev)->devfn)
+
+/*
+ * Request handler callback
+ */
+struct pm_dev;
+
+typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);
+
+/*
+ * Dynamic device information
+ */
+struct pm_dev
+{
+        pm_dev_t         type;
+        unsigned long    id;
+        pm_callback      callback;
+        void            *data;
+
+        unsigned long    flags;
+        unsigned long    state;
+        unsigned long    prev_state;
+
+        struct list_head entry;
+};
+
+#ifdef CONFIG_PM
+
+extern int pm_active;
+
+#define PM_IS_ACTIVE() (pm_active != 0)
+
+/*
+ * Register a device with power management
+ */
+struct pm_dev __deprecated *pm_register(pm_dev_t type, unsigned long id, pm_callback callback);
+
+/*
+ * Unregister a device with power management
+ */
+void __deprecated pm_unregister(struct pm_dev *dev);
+
+/*
+ * Unregister all devices with matching callback
+ */
+void __deprecated pm_unregister_all(pm_callback callback);
+
+/*
+ * Send a request to all devices
+ */
+int __deprecated pm_send_all(pm_request_t rqst, void *data);
+
+#else /* CONFIG_PM */
+
+#define PM_IS_ACTIVE() 0
+
+static inline struct pm_dev *pm_register(pm_dev_t type,
+                                         unsigned long id,
+                                         pm_callback callback)
+{
+        return NULL;
+}
+
+static inline void pm_unregister(struct pm_dev *dev) {}
+
+static inline void pm_unregister_all(pm_callback callback) {}
+
+static inline int pm_send_all(pm_request_t rqst, void *data)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PM */
+
+/* Functions above this comment are list-based old-style power
+ * managment. Please avoid using them.  */
+
+/*
+ * Callbacks for platform drivers to implement.
+ */
+extern void (*pm_idle)(void);
+extern void (*pm_power_off)(void);
+
+typedef int __bitwise suspend_state_t;
+
+#define PM_SUSPEND_ON           ((__force suspend_state_t) 0)
+#define PM_SUSPEND_STANDBY      ((__force suspend_state_t) 1)
+#define PM_SUSPEND_MEM          ((__force suspend_state_t) 3)
+#define PM_SUSPEND_DISK         ((__force suspend_state_t) 4)
+#define PM_SUSPEND_MAX          ((__force suspend_state_t) 5)
+
+typedef int __bitwise suspend_disk_method_t;
+
+#define PM_DISK_FIRMWARE        ((__force suspend_disk_method_t) 1)
+#define PM_DISK_PLATFORM        ((__force suspend_disk_method_t) 2)
+#define PM_DISK_SHUTDOWN        ((__force suspend_disk_method_t) 3)
+#define PM_DISK_REBOOT          ((__force suspend_disk_method_t) 4)
+#define PM_DISK_MAX             ((__force suspend_disk_method_t) 5)
+
+struct pm_ops {
+        suspend_disk_method_t pm_disk_mode;
+        int (*prepare)(suspend_state_t state);
+        int (*enter)(suspend_state_t state);
+        int (*finish)(suspend_state_t state);
+};
+
+extern void pm_set_ops(struct pm_ops *);
+
+extern int pm_suspend(suspend_state_t state);
+
+
+/*
+ * Device power management
+ */
+
+struct device;
+
+typedef u32 __bitwise pm_message_t;
+
+/*
+ * There are 4 important states driver can be in:
+ * ON     -- driver is working
+ * FREEZE -- stop operations and apply whatever policy is applicable to a suspended driver
+ *           of that class, freeze queues for block like IDE does, drop packets for
+ *           ethernet, etc... stop DMA engine too etc... so a consistent image can be
+ *           saved; but do not power any hardware down.
+ * SUSPEND - like FREEZE, but hardware is doing as much powersaving as possible. Roughly
+ *           pci D3.
+ *
+ * Unfortunately, current drivers only recognize numeric values 0 (ON) and 3 (SUSPEND).
+ * We'll need to fix the drivers. So yes, putting 3 to all diferent defines is intentional,
+ * and will go away as soon as drivers are fixed. Also note that typedef is neccessary,
+ * we'll probably want to switch to
+ *   typedef struct pm_message_t { int event; int flags; } pm_message_t
+ * or something similar soon.
+ */
+
+#define PMSG_FREEZE     ((__force pm_message_t) 3)
+#define PMSG_SUSPEND    ((__force pm_message_t) 3)
+#define PMSG_ON         ((__force pm_message_t) 0)
+
+struct dev_pm_info {
+        pm_message_t            power_state;
+#ifdef  CONFIG_PM
+        pm_message_t            prev_state;
+        void                    * saved_state;
+        atomic_t                pm_users;
+        struct device           * pm_parent;
+        struct list_head        entry;
+#endif
+};
+
+extern void device_pm_set_parent(struct device * dev, struct device * parent);
+
+extern int device_suspend(pm_message_t state);
+extern int device_power_down(pm_message_t state);
+extern void device_power_up(void);
+extern void device_resume(void);
+
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_PM_H */
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
new file mode 100644
index 000000000000..6d73eada277e
--- /dev/null
+++ b/include/linux/pmu.h
@@ -0,0 +1,240 @@
+/*
+ * Definitions for talking to the PMU.  The PMU is a microcontroller
+ * which controls battery charging and system power on PowerBook 3400
+ * and 2400 models as well as the RTC and various other things.
+ *
+ * Copyright (C) 1998 Paul Mackerras.
+ */
+
+#include <linux/config.h>
+
+#define PMU_DRIVER_VERSION      2
+
+/*
+ * PMU commands
+ */
+#define PMU_POWER_CTRL0         0x10    /* control power of some devices */
+#define PMU_POWER_CTRL          0x11    /* control power of some devices */
+#define PMU_ADB_CMD             0x20    /* send ADB packet */
+#define PMU_ADB_POLL_OFF        0x21    /* disable ADB auto-poll */
+#define PMU_WRITE_NVRAM         0x33    /* write non-volatile RAM */
+#define PMU_READ_NVRAM          0x3b    /* read non-volatile RAM */
+#define PMU_SET_RTC             0x30    /* set real-time clock */
+#define PMU_READ_RTC            0x38    /* read real-time clock */
+#define PMU_SET_VOLBUTTON       0x40    /* set volume up/down position */
+#define PMU_BACKLIGHT_BRIGHT    0x41    /* set backlight brightness */
+#define PMU_GET_VOLBUTTON       0x48    /* get volume up/down position */
+#define PMU_PCEJECT             0x4c    /* eject PC-card from slot */
+#define PMU_BATTERY_STATE       0x6b    /* report battery state etc. */
+#define PMU_SMART_BATTERY_STATE 0x6f    /* report battery state (new way) */
+#define PMU_SET_INTR_MASK       0x70    /* set PMU interrupt mask */
+#define PMU_INT_ACK             0x78    /* read interrupt bits */
+#define PMU_SHUTDOWN            0x7e    /* turn power off */
+#define PMU_CPU_SPEED           0x7d    /* control CPU speed on some models */
+#define PMU_SLEEP               0x7f    /* put CPU to sleep */
+#define PMU_POWER_EVENTS        0x8f    /* Send power-event commands to PMU */
+#define PMU_I2C_CMD             0x9a    /* I2C operations */
+#define PMU_RESET               0xd0    /* reset CPU */
+#define PMU_GET_BRIGHTBUTTON    0xd9    /* report brightness up/down pos */
+#define PMU_GET_COVER           0xdc    /* report cover open/closed */
+#define PMU_SYSTEM_READY        0xdf    /* tell PMU we are awake */
+#define PMU_GET_VERSION         0xea    /* read the PMU version */
+
+/* Bits to use with the PMU_POWER_CTRL0 command */
+#define PMU_POW0_ON             0x80    /* OR this to power ON the device */
+#define PMU_POW0_OFF            0x00    /* leave bit 7 to 0 to power it OFF */
+#define PMU_POW0_HARD_DRIVE     0x04    /* Hard drive power (on wallstreet/lombard ?) */
+
+/* Bits to use with the PMU_POWER_CTRL command */
+#define PMU_POW_ON              0x80    /* OR this to power ON the device */
+#define PMU_POW_OFF             0x00    /* leave bit 7 to 0 to power it OFF */
+#define PMU_POW_BACKLIGHT       0x01    /* backlight power */
+#define PMU_POW_CHARGER         0x02    /* battery charger power */
+#define PMU_POW_IRLED           0x04    /* IR led power (on wallstreet) */
+#define PMU_POW_MEDIABAY        0x08    /* media bay power (wallstreet/lombard ?) */
+
+/* Bits in PMU interrupt and interrupt mask bytes */
+#define PMU_INT_PCEJECT         0x04    /* PC-card eject buttons */
+#define PMU_INT_SNDBRT          0x08    /* sound/brightness up/down buttons */
+#define PMU_INT_ADB             0x10    /* ADB autopoll or reply data */
+#define PMU_INT_BATTERY         0x20    /* Battery state change */
+#define PMU_INT_ENVIRONMENT     0x40    /* Environment interrupts */
+#define PMU_INT_TICK            0x80    /* 1-second tick interrupt */
+
+/* Other bits in PMU interrupt valid when PMU_INT_ADB is set */
+#define PMU_INT_ADB_AUTO        0x04    /* ADB autopoll, when PMU_INT_ADB */
+#define PMU_INT_WAITING_CHARGER 0x01    /* ??? */
+#define PMU_INT_AUTO_SRQ_POLL   0x02    /* ??? */
+
+/* Bits in the environement message (either obtained via PMU_GET_COVER,
+ * or via PMU_INT_ENVIRONMENT on core99 */
+#define PMU_ENV_LID_CLOSED      0x01    /* The lid is closed */
+
+/* I2C related definitions */
+#define PMU_I2C_MODE_SIMPLE     0
+#define PMU_I2C_MODE_STDSUB     1
+#define PMU_I2C_MODE_COMBINED   2
+
+#define PMU_I2C_BUS_STATUS      0
+#define PMU_I2C_BUS_SYSCLK      1
+#define PMU_I2C_BUS_POWER       2
+
+#define PMU_I2C_STATUS_OK       0
+#define PMU_I2C_STATUS_DATAREAD 1
+#define PMU_I2C_STATUS_BUSY     0xfe
+
+
+/* Kind of PMU (model) */
+enum {
+        PMU_UNKNOWN,
+        PMU_OHARE_BASED,        /* 2400, 3400, 3500 (old G3 powerbook) */
+        PMU_HEATHROW_BASED,     /* PowerBook G3 series */
+        PMU_PADDINGTON_BASED,   /* 1999 PowerBook G3 */
+        PMU_KEYLARGO_BASED,     /* Core99 motherboard (PMU99) */
+        PMU_68K_V1,             /* 68K PMU, version 1 */
+        PMU_68K_V2,             /* 68K PMU, version 2 */
+};
+
+/* PMU PMU_POWER_EVENTS commands */
+enum {
+        PMU_PWR_GET_POWERUP_EVENTS      = 0x00,
+        PMU_PWR_SET_POWERUP_EVENTS      = 0x01,
+        PMU_PWR_CLR_POWERUP_EVENTS      = 0x02,
+        PMU_PWR_GET_WAKEUP_EVENTS       = 0x03,
+        PMU_PWR_SET_WAKEUP_EVENTS       = 0x04,
+        PMU_PWR_CLR_WAKEUP_EVENTS       = 0x05,
+};
+
+/* Power events wakeup bits */
+enum {
+        PMU_PWR_WAKEUP_KEY              = 0x01, /* Wake on key press */
+        PMU_PWR_WAKEUP_AC_INSERT        = 0x02, /* Wake on AC adapter plug */
+        PMU_PWR_WAKEUP_AC_CHANGE        = 0x04,
+        PMU_PWR_WAKEUP_LID_OPEN         = 0x08,
+        PMU_PWR_WAKEUP_RING             = 0x10,
+};
+        
+/*
+ * Ioctl commands for the /dev/pmu device
+ */
+#include <linux/ioctl.h>
+
+/* no param */
+#define PMU_IOC_SLEEP           _IO('B', 0)
+/* out param: u32*      backlight value: 0 to 15 */
+#define PMU_IOC_GET_BACKLIGHT   _IOR('B', 1, size_t)
+/* in param: u32        backlight value: 0 to 15 */
+#define PMU_IOC_SET_BACKLIGHT   _IOW('B', 2, size_t)
+/* out param: u32*      PMU model */
+#define PMU_IOC_GET_MODEL       _IOR('B', 3, size_t)
+/* out param: u32*      has_adb: 0 or 1 */
+#define PMU_IOC_HAS_ADB         _IOR('B', 4, size_t) 
+/* out param: u32*      can_sleep: 0 or 1 */
+#define PMU_IOC_CAN_SLEEP       _IOR('B', 5, size_t) 
+/* no param, but historically was _IOR('B', 6, 0), meaning 4 bytes */
+#define PMU_IOC_GRAB_BACKLIGHT  _IOR('B', 6, size_t) 
+
+#ifdef __KERNEL__
+
+extern int find_via_pmu(void);
+
+extern int pmu_request(struct adb_request *req,
+                void (*done)(struct adb_request *), int nbytes, ...);
+
+extern void pmu_poll(void);
+extern void pmu_poll_adb(void); /* For use by xmon */
+extern void pmu_wait_complete(struct adb_request *req);
+
+/* For use before switching interrupts off for a long time;
+ * warning: not stackable
+ */
+extern void pmu_suspend(void);
+extern void pmu_resume(void);
+
+extern void pmu_enable_irled(int on);
+
+extern void pmu_restart(void);
+extern void pmu_shutdown(void);
+extern void pmu_unlock(void);
+
+extern int pmu_present(void);
+extern int pmu_get_model(void);
+
+extern int pmu_i2c_combined_read(int bus, int addr, int subaddr,  u8* data, int len);
+extern int pmu_i2c_stdsub_write(int bus, int addr, int subaddr,  u8* data, int len);
+extern int pmu_i2c_simple_read(int bus, int addr,  u8* data, int len);
+extern int pmu_i2c_simple_write(int bus, int addr,  u8* data, int len);
+
+
+#ifdef CONFIG_PMAC_PBOOK
+/*
+ * Stuff for putting the powerbook to sleep and waking it again.
+ *
+ */
+#include <linux/list.h>
+
+struct pmu_sleep_notifier
+{
+        int (*notifier_call)(struct pmu_sleep_notifier *self, int when);
+        int priority;
+        struct list_head list;
+};
+
+/* Code values for calling sleep/wakeup handlers
+ *
+ * Note: If a sleep request got cancelled, all drivers will get
+ * the PBOOK_SLEEP_REJECT, even those who didn't get the PBOOK_SLEEP_REQUEST.
+ */
+#define PBOOK_SLEEP_REQUEST     1
+#define PBOOK_SLEEP_NOW         2
+#define PBOOK_SLEEP_REJECT      3
+#define PBOOK_WAKE              4
+
+/* Result codes returned by the notifiers */
+#define PBOOK_SLEEP_OK          0
+#define PBOOK_SLEEP_REFUSE      -1
+
+/* priority levels in notifiers */
+#define SLEEP_LEVEL_VIDEO       100     /* Video driver (first wake) */
+#define SLEEP_LEVEL_MEDIABAY    90      /* Media bay driver */
+#define SLEEP_LEVEL_BLOCK       80      /* IDE, SCSI */
+#define SLEEP_LEVEL_NET         70      /* bmac, gmac */
+#define SLEEP_LEVEL_MISC        60      /* Anything else */
+#define SLEEP_LEVEL_USERLAND    55      /* Reserved for apm_emu */
+#define SLEEP_LEVEL_ADB         50      /* ADB (async) */
+#define SLEEP_LEVEL_SOUND       40      /* Sound driver (blocking) */
+
+/* special register notifier functions */
+int pmu_register_sleep_notifier(struct pmu_sleep_notifier* notifier);
+int pmu_unregister_sleep_notifier(struct pmu_sleep_notifier* notifier);
+
+#define PMU_MAX_BATTERIES       2
+
+/* values for pmu_power_flags */
+#define PMU_PWR_AC_PRESENT      0x00000001
+
+/* values for pmu_battery_info.flags */
+#define PMU_BATT_PRESENT        0x00000001
+#define PMU_BATT_CHARGING       0x00000002
+#define PMU_BATT_TYPE_MASK      0x000000f0
+#define PMU_BATT_TYPE_SMART     0x00000010 /* Smart battery */
+#define PMU_BATT_TYPE_HOOPER    0x00000020 /* 3400/3500 */
+#define PMU_BATT_TYPE_COMET     0x00000030 /* 2400 */
+
+struct pmu_battery_info
+{
+        unsigned int    flags;
+        unsigned int    charge;         /* current charge */
+        unsigned int    max_charge;     /* maximum charge */
+        signed int      amperage;       /* current, positive if charging */
+        unsigned int    voltage;        /* voltage */
+        unsigned int    time_remaining; /* remaining time */
+};
+
+extern int pmu_battery_count;
+extern struct pmu_battery_info pmu_batteries[PMU_MAX_BATTERIES];
+extern unsigned int pmu_power_flags;
+
+#endif /* CONFIG_PMAC_PBOOK */
+
+#endif  /* __KERNEL__ */
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
new file mode 100644
index 000000000000..5ec2bd0c2848
--- /dev/null
+++ b/include/linux/pnp.h
@@ -0,0 +1,454 @@
+/*
+ * Linux Plug and Play Support
+ * Copyright by Adam Belay <ambx1@neo.rr.com>
+ *
+ */
+
+#ifndef _LINUX_PNP_H
+#define _LINUX_PNP_H
+
+#ifdef __KERNEL__
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/mod_devicetable.h>
+
+#define PNP_MAX_PORT            8
+#define PNP_MAX_MEM             4
+#define PNP_MAX_IRQ             2
+#define PNP_MAX_DMA             2
+#define PNP_NAME_LEN            50
+
+struct pnp_protocol;
+struct pnp_dev;
+
+
+/*
+ * Resource Management
+ */
+
+/* Use these instead of directly reading pnp_dev to get resource information */
+#define pnp_port_start(dev,bar)   ((dev)->res.port_resource[(bar)].start)
+#define pnp_port_end(dev,bar)     ((dev)->res.port_resource[(bar)].end)
+#define pnp_port_flags(dev,bar)   ((dev)->res.port_resource[(bar)].flags)
+#define pnp_port_valid(dev,bar) \
+        ((pnp_port_flags((dev),(bar)) & (IORESOURCE_IO | IORESOURCE_UNSET)) \
+                == IORESOURCE_IO)
+#define pnp_port_len(dev,bar) \
+        ((pnp_port_start((dev),(bar)) == 0 &&   \
+          pnp_port_end((dev),(bar)) ==          \
+          pnp_port_start((dev),(bar))) ? 0 :    \
+                                                \
+         (pnp_port_end((dev),(bar)) -           \
+          pnp_port_start((dev),(bar)) + 1))
+
+#define pnp_mem_start(dev,bar)   ((dev)->res.mem_resource[(bar)].start)
+#define pnp_mem_end(dev,bar)     ((dev)->res.mem_resource[(bar)].end)
+#define pnp_mem_flags(dev,bar)   ((dev)->res.mem_resource[(bar)].flags)
+#define pnp_mem_valid(dev,bar) \
+        ((pnp_mem_flags((dev),(bar)) & (IORESOURCE_MEM | IORESOURCE_UNSET)) \
+                == IORESOURCE_MEM)
+#define pnp_mem_len(dev,bar) \
+        ((pnp_mem_start((dev),(bar)) == 0 &&    \
+          pnp_mem_end((dev),(bar)) ==           \
+          pnp_mem_start((dev),(bar))) ? 0 :     \
+                                                \
+         (pnp_mem_end((dev),(bar)) -            \
+          pnp_mem_start((dev),(bar)) + 1))
+
+#define pnp_irq(dev,bar)         ((dev)->res.irq_resource[(bar)].start)
+#define pnp_irq_flags(dev,bar)   ((dev)->res.irq_resource[(bar)].flags)
+#define pnp_irq_valid(dev,bar) \
+        ((pnp_irq_flags((dev),(bar)) & (IORESOURCE_IRQ | IORESOURCE_UNSET)) \
+                == IORESOURCE_IRQ)
+
+#define pnp_dma(dev,bar)         ((dev)->res.dma_resource[(bar)].start)
+#define pnp_dma_flags(dev,bar)   ((dev)->res.dma_resource[(bar)].flags)
+#define pnp_dma_valid(dev,bar) \
+        ((pnp_dma_flags((dev),(bar)) & (IORESOURCE_DMA | IORESOURCE_UNSET)) \
+                == IORESOURCE_DMA)
+
+#define PNP_PORT_FLAG_16BITADDR (1<<0)
+#define PNP_PORT_FLAG_FIXED     (1<<1)
+
+struct pnp_port {
+        unsigned short min;             /* min base number */
+        unsigned short max;             /* max base number */
+        unsigned char align;            /* align boundary */
+        unsigned char size;             /* size of range */
+        unsigned char flags;            /* port flags */
+        unsigned char pad;              /* pad */
+        struct pnp_port *next;          /* next port */
+};
+
+#define PNP_IRQ_NR 256
+struct pnp_irq {
+        DECLARE_BITMAP(map, PNP_IRQ_NR); /* bitmaks for IRQ lines */
+        unsigned char flags;            /* IRQ flags */
+        unsigned char pad;              /* pad */
+        struct pnp_irq *next;           /* next IRQ */
+};
+
+struct pnp_dma {
+        unsigned char map;              /* bitmask for DMA channels */
+        unsigned char flags;            /* DMA flags */
+        struct pnp_dma *next;           /* next port */
+};
+
+struct pnp_mem {
+        unsigned int min;               /* min base number */
+        unsigned int max;               /* max base number */
+        unsigned int align;             /* align boundary */
+        unsigned int size;              /* size of range */
+        unsigned char flags;            /* memory flags */
+        unsigned char pad;              /* pad */
+        struct pnp_mem *next;           /* next memory resource */
+};
+
+#define PNP_RES_PRIORITY_PREFERRED      0
+#define PNP_RES_PRIORITY_ACCEPTABLE     1
+#define PNP_RES_PRIORITY_FUNCTIONAL     2
+#define PNP_RES_PRIORITY_INVALID        65535
+
+struct pnp_option {
+        unsigned short priority;        /* priority */
+        struct pnp_port *port;          /* first port */
+        struct pnp_irq *irq;            /* first IRQ */
+        struct pnp_dma *dma;            /* first DMA */
+        struct pnp_mem *mem;            /* first memory resource */
+        struct pnp_option *next;        /* used to chain dependent resources */
+};
+
+struct pnp_resource_table {
+        struct resource port_resource[PNP_MAX_PORT];
+        struct resource mem_resource[PNP_MAX_MEM];
+        struct resource dma_resource[PNP_MAX_DMA];
+        struct resource irq_resource[PNP_MAX_IRQ];
+};
+
+
+/*
+ * Device Managemnt
+ */
+
+struct pnp_card {
+        struct device dev;              /* Driver Model device interface */
+        unsigned char number;           /* used as an index, must be unique */
+        struct list_head global_list;   /* node in global list of cards */
+        struct list_head protocol_list; /* node in protocol's list of cards */
+        struct list_head devices;       /* devices attached to the card */
+
+        struct pnp_protocol * protocol;
+        struct pnp_id * id;             /* contains supported EISA IDs*/
+
+        char name[PNP_NAME_LEN];        /* contains a human-readable name */
+        unsigned char   pnpver;         /* Plug & Play version */
+        unsigned char   productver;     /* product version */
+        unsigned int    serial;         /* serial number */
+        unsigned char   checksum;       /* if zero - checksum passed */
+        struct proc_dir_entry *procdir; /* directory entry in /proc/bus/isapnp */
+};
+
+#define global_to_pnp_card(n) list_entry(n, struct pnp_card, global_list)
+#define protocol_to_pnp_card(n) list_entry(n, struct pnp_card, protocol_list)
+#define to_pnp_card(n) container_of(n, struct pnp_card, dev)
+#define pnp_for_each_card(card) \
+        for((card) = global_to_pnp_card(pnp_cards.next); \
+        (card) != global_to_pnp_card(&pnp_cards); \
+        (card) = global_to_pnp_card((card)->global_list.next))
+
+struct pnp_card_link {
+        struct pnp_card * card;
+        struct pnp_card_driver * driver;
+        void * driver_data;
+};
+
+static inline void *pnp_get_card_drvdata (struct pnp_card_link *pcard)
+{
+        return pcard->driver_data;
+}
+
+static inline void pnp_set_card_drvdata (struct pnp_card_link *pcard, void *data)
+{
+        pcard->driver_data = data;
+}
+
+struct pnp_dev {
+        struct device dev;              /* Driver Model device interface */
+        unsigned char number;           /* used as an index, must be unique */
+        int status;
+
+        struct list_head global_list;   /* node in global list of devices */
+        struct list_head protocol_list; /* node in list of device's protocol */
+        struct list_head card_list;     /* node in card's list of devices */
+        struct list_head rdev_list;     /* node in cards list of requested devices */
+
+        struct pnp_protocol * protocol;
+        struct pnp_card * card;         /* card the device is attached to, none if NULL */
+        struct pnp_driver * driver;
+        struct pnp_card_link * card_link;
+
+        struct pnp_id   * id;   /* supported EISA IDs*/
+
+        int active;
+        int capabilities;
+        struct pnp_option * independent;
+        struct pnp_option * dependent;
+        struct pnp_resource_table res;
+
+        char name[PNP_NAME_LEN];        /* contains a human-readable name */
+        unsigned short  regs;           /* ISAPnP: supported registers */
+        int             flags;          /* used by protocols */
+        struct proc_dir_entry *procent; /* device entry in /proc/bus/isapnp */
+        void *data;
+};
+
+#define global_to_pnp_dev(n) list_entry(n, struct pnp_dev, global_list)
+#define card_to_pnp_dev(n) list_entry(n, struct pnp_dev, card_list)
+#define protocol_to_pnp_dev(n) list_entry(n, struct pnp_dev, protocol_list)
+#define to_pnp_dev(n) container_of(n, struct pnp_dev, dev)
+#define pnp_for_each_dev(dev) \
+        for((dev) = global_to_pnp_dev(pnp_global.next); \
+        (dev) != global_to_pnp_dev(&pnp_global); \
+        (dev) = global_to_pnp_dev((dev)->global_list.next))
+#define card_for_each_dev(card,dev) \
+        for((dev) = card_to_pnp_dev((card)->devices.next); \
+        (dev) != card_to_pnp_dev(&(card)->devices); \
+        (dev) = card_to_pnp_dev((dev)->card_list.next))
+#define pnp_dev_name(dev) (dev)->name
+
+static inline void *pnp_get_drvdata (struct pnp_dev *pdev)
+{
+        return dev_get_drvdata(&pdev->dev);
+}
+
+static inline void pnp_set_drvdata (struct pnp_dev *pdev, void *data)
+{
+        dev_set_drvdata(&pdev->dev, data);
+}
+
+struct pnp_fixup {
+        char id[7];
+        void (*quirk_function)(struct pnp_dev *dev);    /* fixup function */
+};
+
+/* config parameters */
+#define PNP_CONFIG_NORMAL       0x0001
+#define PNP_CONFIG_FORCE        0x0002  /* disables validity checking */
+
+/* capabilities */
+#define PNP_READ                0x0001
+#define PNP_WRITE               0x0002
+#define PNP_DISABLE             0x0004
+#define PNP_CONFIGURABLE        0x0008
+#define PNP_REMOVABLE           0x0010
+
+#define pnp_can_read(dev)       (((dev)->protocol) && ((dev)->protocol->get) && \
+                                 ((dev)->capabilities & PNP_READ))
+#define pnp_can_write(dev)      (((dev)->protocol) && ((dev)->protocol->set) && \
+                                 ((dev)->capabilities & PNP_WRITE))
+#define pnp_can_disable(dev)    (((dev)->protocol) && ((dev)->protocol->disable) && \
+                                 ((dev)->capabilities & PNP_DISABLE))
+#define pnp_can_configure(dev)  ((!(dev)->active) && \
+                                 ((dev)->capabilities & PNP_CONFIGURABLE))
+
+#ifdef CONFIG_ISAPNP
+extern struct pnp_protocol isapnp_protocol;
+#define pnp_device_is_isapnp(dev) ((dev)->protocol == (&isapnp_protocol))
+#else
+#define pnp_device_is_isapnp(dev) 0
+#endif
+
+#ifdef CONFIG_PNPBIOS
+extern struct pnp_protocol pnpbios_protocol;
+#define pnp_device_is_pnpbios(dev) ((dev)->protocol == (&pnpbios_protocol))
+#else
+#define pnp_device_is_pnpbios(dev) 0
+#endif
+
+
+/* status */
+#define PNP_READY               0x0000
+#define PNP_ATTACHED            0x0001
+#define PNP_BUSY                0x0002
+#define PNP_FAULTY              0x0004
+
+/* isapnp specific macros */
+
+#define isapnp_card_number(dev) ((dev)->card ? (dev)->card->number : -1)
+#define isapnp_csn_number(dev)  ((dev)->number)
+
+/*
+ * Driver Management
+ */
+
+struct pnp_id {
+        char id[PNP_ID_LEN];
+        struct pnp_id * next;
+};
+
+struct pnp_driver {
+        char * name;
+        const struct pnp_device_id *id_table;
+        unsigned int flags;
+        int  (*probe)  (struct pnp_dev *dev, const struct pnp_device_id *dev_id);
+        void (*remove) (struct pnp_dev *dev);
+        struct device_driver driver;
+};
+
+#define to_pnp_driver(drv) container_of(drv, struct pnp_driver, driver)
+
+struct pnp_card_driver {
+        struct list_head global_list;
+        char * name;
+        const struct pnp_card_device_id *id_table;
+        unsigned int flags;
+        int  (*probe)  (struct pnp_card_link *card, const struct pnp_card_device_id *card_id);
+        void (*remove) (struct pnp_card_link *card);
+        struct pnp_driver link;
+};
+
+#define to_pnp_card_driver(drv) container_of(drv, struct pnp_card_driver, link)
+
+/* pnp driver flags */
+#define PNP_DRIVER_RES_DO_NOT_CHANGE    0x0001  /* do not change the state of the device */
+#define PNP_DRIVER_RES_DISABLE          0x0003  /* ensure the device is disabled */
+
+
+/*
+ * Protocol Management
+ */
+
+struct pnp_protocol {
+        struct list_head        protocol_list;
+        char                  * name;
+
+        /* resource control functions */
+        int (*get)(struct pnp_dev *dev, struct pnp_resource_table *res);
+        int (*set)(struct pnp_dev *dev, struct pnp_resource_table *res);
+        int (*disable)(struct pnp_dev *dev);
+
+        /* used by pnp layer only (look but don't touch) */
+        unsigned char           number;         /* protocol number*/
+        struct device           dev;            /* link to driver model */
+        struct list_head        cards;
+        struct list_head        devices;
+};
+
+#define to_pnp_protocol(n) list_entry(n, struct pnp_protocol, protocol_list)
+#define protocol_for_each_card(protocol,card) \
+        for((card) = protocol_to_pnp_card((protocol)->cards.next); \
+        (card) != protocol_to_pnp_card(&(protocol)->cards); \
+        (card) = protocol_to_pnp_card((card)->protocol_list.next))
+#define protocol_for_each_dev(protocol,dev) \
+        for((dev) = protocol_to_pnp_dev((protocol)->devices.next); \
+        (dev) != protocol_to_pnp_dev(&(protocol)->devices); \
+        (dev) = protocol_to_pnp_dev((dev)->protocol_list.next))
+
+
+#if defined(CONFIG_PNP)
+
+/* device management */
+int pnp_register_protocol(struct pnp_protocol *protocol);
+void pnp_unregister_protocol(struct pnp_protocol *protocol);
+int pnp_add_device(struct pnp_dev *dev);
+void pnp_remove_device(struct pnp_dev *dev);
+int pnp_device_attach(struct pnp_dev *pnp_dev);
+void pnp_device_detach(struct pnp_dev *pnp_dev);
+extern struct list_head pnp_global;
+
+/* multidevice card support */
+int pnp_add_card(struct pnp_card *card);
+void pnp_remove_card(struct pnp_card *card);
+int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev);
+void pnp_remove_card_device(struct pnp_dev *dev);
+int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card);
+struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from);
+void pnp_release_card_device(struct pnp_dev * dev);
+int pnp_register_card_driver(struct pnp_card_driver * drv);
+void pnp_unregister_card_driver(struct pnp_card_driver * drv);
+extern struct list_head pnp_cards;
+
+/* resource management */
+struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev);
+struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority);
+int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data);
+int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data);
+int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data);
+int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data);
+void pnp_init_resource_table(struct pnp_resource_table *table);
+int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode);
+int pnp_auto_config_dev(struct pnp_dev *dev);
+int pnp_validate_config(struct pnp_dev *dev);
+int pnp_activate_dev(struct pnp_dev *dev);
+int pnp_disable_dev(struct pnp_dev *dev);
+void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size);
+
+/* protocol helpers */
+int pnp_is_active(struct pnp_dev * dev);
+int compare_pnp_id(struct pnp_id * pos, const char * id);
+int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev);
+int pnp_register_driver(struct pnp_driver *drv);
+void pnp_unregister_driver(struct pnp_driver *drv);
+
+#else
+
+/* device management */
+static inline int pnp_register_protocol(struct pnp_protocol *protocol) { return -ENODEV; }
+static inline void pnp_unregister_protocol(struct pnp_protocol *protocol) { }
+static inline int pnp_init_device(struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_add_device(struct pnp_dev *dev) { return -ENODEV; }
+static inline void pnp_remove_device(struct pnp_dev *dev) { }
+static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; }
+static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { ; }
+
+/* multidevice card support */
+static inline int pnp_add_card(struct pnp_card *card) { return -ENODEV; }
+static inline void pnp_remove_card(struct pnp_card *card) { ; }
+static inline int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) { return -ENODEV; }
+static inline void pnp_remove_card_device(struct pnp_dev *dev) { ; }
+static inline int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) { return -ENODEV; }
+static inline struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from) { return NULL; }
+static inline void pnp_release_card_device(struct pnp_dev * dev) { ; }
+static inline int pnp_register_card_driver(struct pnp_card_driver * drv) { return -ENODEV; }
+static inline void pnp_unregister_card_driver(struct pnp_card_driver * drv) { ; }
+
+/* resource management */
+static inline struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev) { return NULL; }
+static inline struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority) { return NULL; }
+static inline int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) { return -ENODEV; }
+static inline int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) { return -ENODEV; }
+static inline int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) { return -ENODEV; }
+static inline int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data) { return -ENODEV; }
+static inline void pnp_init_resource_table(struct pnp_resource_table *table) { }
+static inline int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode) { return -ENODEV; }
+static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_validate_config(struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
+static inline void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size) { }
+
+/* protocol helpers */
+static inline int pnp_is_active(struct pnp_dev * dev) { return 0; }
+static inline int compare_pnp_id(struct pnp_id * pos, const char * id) { return -ENODEV; }
+static inline int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; }
+static inline void pnp_unregister_driver(struct pnp_driver *drv) { ; }
+
+#endif /* CONFIG_PNP */
+
+
+#define pnp_err(format, arg...) printk(KERN_ERR "pnp: " format "\n" , ## arg)
+#define pnp_info(format, arg...) printk(KERN_INFO "pnp: " format "\n" , ## arg)
+#define pnp_warn(format, arg...) printk(KERN_WARNING "pnp: " format "\n" , ## arg)
+
+#ifdef DEBUG
+#define pnp_dbg(format, arg...) printk(KERN_DEBUG "pnp: " format "\n" , ## arg)
+#else
+#define pnp_dbg(format, arg...) do {} while (0)
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_PNP_H */
diff --git a/include/linux/pnpbios.h b/include/linux/pnpbios.h
new file mode 100644
index 000000000000..0a282ac1f6b2
--- /dev/null
+++ b/include/linux/pnpbios.h
@@ -0,0 +1,157 @@
+/*
+ * Include file for the interface to a PnP BIOS
+ *
+ * Original BIOS code (C) 1998 Christian Schmidt (chr.schmidt@tu-bs.de)
+ * PnP handler parts (c) 1998 Tom Lees <tom@lpsg.demon.co.uk>
+ * Minor reorganizations by David Hinds <dahinds@users.sourceforge.net>
+ *
+ * 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; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_PNPBIOS_H
+#define _LINUX_PNPBIOS_H
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/pnp.h>
+
+/*
+ * Return codes
+ */
+#define PNP_SUCCESS                     0x00
+#define PNP_NOT_SET_STATICALLY          0x7f
+#define PNP_UNKNOWN_FUNCTION            0x81
+#define PNP_FUNCTION_NOT_SUPPORTED      0x82
+#define PNP_INVALID_HANDLE              0x83
+#define PNP_BAD_PARAMETER               0x84
+#define PNP_SET_FAILED                  0x85
+#define PNP_EVENTS_NOT_PENDING          0x86
+#define PNP_SYSTEM_NOT_DOCKED           0x87
+#define PNP_NO_ISA_PNP_CARDS            0x88
+#define PNP_UNABLE_TO_DETERMINE_DOCK_CAPABILITIES 0x89
+#define PNP_CONFIG_CHANGE_FAILED_NO_BATTERY 0x8a
+#define PNP_CONFIG_CHANGE_FAILED_RESOURCE_CONFLICT 0x8b
+#define PNP_BUFFER_TOO_SMALL            0x8c
+#define PNP_USE_ESCD_SUPPORT            0x8d
+#define PNP_MESSAGE_NOT_SUPPORTED       0x8e
+#define PNP_HARDWARE_ERROR              0x8f
+
+#define ESCD_SUCCESS                    0x00
+#define ESCD_IO_ERROR_READING           0x55
+#define ESCD_INVALID                    0x56
+#define ESCD_BUFFER_TOO_SMALL           0x59
+#define ESCD_NVRAM_TOO_SMALL            0x5a
+#define ESCD_FUNCTION_NOT_SUPPORTED     0x81
+
+/*
+ * Events that can be received by "get event"
+ */
+#define PNPEV_ABOUT_TO_CHANGE_CONFIG    0x0001
+#define PNPEV_DOCK_CHANGED              0x0002
+#define PNPEV_SYSTEM_DEVICE_CHANGED     0x0003
+#define PNPEV_CONFIG_CHANGED_FAILED     0x0004
+#define PNPEV_UNKNOWN_SYSTEM_EVENT      0xffff
+/* 0x8000 through 0xfffe are OEM defined */
+
+/*
+ * Messages that should be sent through "send message"
+ */
+#define PNPMSG_OK                       0x00
+#define PNPMSG_ABORT                    0x01
+#define PNPMSG_UNDOCK_DEFAULT_ACTION    0x40
+#define PNPMSG_POWER_OFF                0x41
+#define PNPMSG_PNP_OS_ACTIVE            0x42
+#define PNPMSG_PNP_OS_INACTIVE          0x43
+
+/*
+ * Plug and Play BIOS flags
+ */
+#define PNPBIOS_NO_DISABLE              0x0001
+#define PNPBIOS_NO_CONFIG               0x0002
+#define PNPBIOS_OUTPUT                  0x0004
+#define PNPBIOS_INPUT                   0x0008
+#define PNPBIOS_BOOTABLE                0x0010
+#define PNPBIOS_DOCK                    0x0020
+#define PNPBIOS_REMOVABLE               0x0040
+#define pnpbios_is_static(x) (((x)->flags & 0x0100) == 0x0000)
+#define pnpbios_is_dynamic(x) ((x)->flags & 0x0080)
+
+/*
+ * Function Parameters
+ */
+#define PNPMODE_STATIC 1
+#define PNPMODE_DYNAMIC 0
+
+/* 0x8000 through 0xffff are OEM defined */
+
+#pragma pack(1)
+struct pnp_dev_node_info {
+        __u16   no_nodes;
+        __u16   max_node_size;
+};
+struct pnp_docking_station_info {
+        __u32   location_id;
+        __u32   serial;
+        __u16   capabilities;
+};
+struct pnp_isa_config_struc {
+        __u8    revision;
+        __u8    no_csns;
+        __u16   isa_rd_data_port;
+        __u16   reserved;
+};
+struct escd_info_struc {
+        __u16   min_escd_write_size;
+        __u16   escd_size;
+        __u32   nv_storage_base;
+};
+struct pnp_bios_node {
+        __u16   size;
+        __u8    handle;
+        __u32   eisa_id;
+        __u8    type_code[3];
+        __u16   flags;
+        __u8    data[0];
+};
+#pragma pack()
+
+#ifdef CONFIG_PNPBIOS
+
+/* non-exported */
+extern struct pnp_dev_node_info node_info;
+
+extern int pnp_bios_dev_node_info (struct pnp_dev_node_info *data);
+extern int pnp_bios_get_dev_node (u8 *nodenum, char config, struct pnp_bios_node *data);
+extern int pnp_bios_set_dev_node (u8 nodenum, char config, struct pnp_bios_node *data);
+extern int pnp_bios_get_stat_res (char *info);
+extern int pnp_bios_isapnp_config (struct pnp_isa_config_struc *data);
+extern int pnp_bios_escd_info (struct escd_info_struc *data);
+extern int pnp_bios_read_escd (char *data, u32 nvram_base);
+extern int pnp_bios_dock_station_info(struct pnp_docking_station_info *data);
+#define needed 0
+#if needed
+extern int pnp_bios_get_event (u16 *message);
+extern int pnp_bios_send_message (u16 message);
+extern int pnp_bios_set_stat_res (char *info);
+extern int pnp_bios_apm_id_table (char *table, u16 *size);
+extern int pnp_bios_write_escd (char *data, u32 nvram_base);
+#endif
+
+#endif /* CONFIG_PNPBIOS */
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_PNPBIOS_H */
diff --git a/include/linux/poll.h b/include/linux/poll.h
new file mode 100644
index 000000000000..f6da702088f4
--- /dev/null
+++ b/include/linux/poll.h
@@ -0,0 +1,99 @@
+#ifndef _LINUX_POLL_H
+#define _LINUX_POLL_H
+
+#include <asm/poll.h>
+
+#ifdef __KERNEL__
+
+#include <linux/compiler.h>
+#include <linux/wait.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <asm/uaccess.h>
+
+struct poll_table_struct;
+
+/* 
+ * structures and helpers for f_op->poll implementations
+ */
+typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
+
+typedef struct poll_table_struct {
+        poll_queue_proc qproc;
+} poll_table;
+
+static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
+{
+        if (p && wait_address)
+                p->qproc(filp, wait_address, p);
+}
+
+static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
+{
+        pt->qproc = qproc;
+}
+
+/*
+ * Structures and helpers for sys_poll/sys_poll
+ */
+struct poll_wqueues {
+        poll_table pt;
+        struct poll_table_page * table;
+        int error;
+};
+
+extern void poll_initwait(struct poll_wqueues *pwq);
+extern void poll_freewait(struct poll_wqueues *pwq);
+
+/*
+ * Scaleable version of the fd_set.
+ */
+
+typedef struct {
+        unsigned long *in, *out, *ex;
+        unsigned long *res_in, *res_out, *res_ex;
+} fd_set_bits;
+
+/*
+ * How many longwords for "nr" bits?
+ */
+#define FDS_BITPERLONG  (8*sizeof(long))
+#define FDS_LONGS(nr)   (((nr)+FDS_BITPERLONG-1)/FDS_BITPERLONG)
+#define FDS_BYTES(nr)   (FDS_LONGS(nr)*sizeof(long))
+
+/*
+ * We do a VERIFY_WRITE here even though we are only reading this time:
+ * we'll write to it eventually..
+ *
+ * Use "unsigned long" accesses to let user-mode fd_set's be long-aligned.
+ */
+static inline
+int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
+{
+        nr = FDS_BYTES(nr);
+        if (ufdset)
+                return copy_from_user(fdset, ufdset, nr) ? -EFAULT : 0;
+
+        memset(fdset, 0, nr);
+        return 0;
+}
+
+static inline unsigned long __must_check
+set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
+{
+        if (ufdset)
+                return __copy_to_user(ufdset, fdset, FDS_BYTES(nr));
+        return 0;
+}
+
+static inline
+void zero_fd_set(unsigned long nr, unsigned long *fdset)
+{
+        memset(fdset, 0, FDS_BYTES(nr));
+}
+
+extern int do_select(int n, fd_set_bits *fds, long *timeout);
+
+#endif /* KERNEL */
+
+#endif /* _LINUX_POLL_H */
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
new file mode 100644
index 000000000000..f942e2bad8e3
--- /dev/null
+++ b/include/linux/posix-timers.h
@@ -0,0 +1,139 @@
+#ifndef _linux_POSIX_TIMERS_H
+#define _linux_POSIX_TIMERS_H
+
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/sched.h>
+
+union cpu_time_count {
+        cputime_t cpu;
+        unsigned long long sched;
+};
+
+struct cpu_timer_list {
+        struct list_head entry;
+        union cpu_time_count expires, incr;
+        struct task_struct *task;
+        int firing;
+};
+
+#define CPUCLOCK_PID(clock)             ((pid_t) ~((clock) >> 3))
+#define CPUCLOCK_PERTHREAD(clock) \
+        (((clock) & (clockid_t) CPUCLOCK_PERTHREAD_MASK) != 0)
+#define CPUCLOCK_PID_MASK       7
+#define CPUCLOCK_PERTHREAD_MASK 4
+#define CPUCLOCK_WHICH(clock)   ((clock) & (clockid_t) CPUCLOCK_CLOCK_MASK)
+#define CPUCLOCK_CLOCK_MASK     3
+#define CPUCLOCK_PROF           0
+#define CPUCLOCK_VIRT           1
+#define CPUCLOCK_SCHED          2
+#define CPUCLOCK_MAX            3
+
+#define MAKE_PROCESS_CPUCLOCK(pid, clock) \
+        ((~(clockid_t) (pid) << 3) | (clockid_t) (clock))
+#define MAKE_THREAD_CPUCLOCK(tid, clock) \
+        MAKE_PROCESS_CPUCLOCK((tid), (clock) | CPUCLOCK_PERTHREAD_MASK)
+
+/* POSIX.1b interval timer structure. */
+struct k_itimer {
+        struct list_head list;          /* free/ allocate list */
+        spinlock_t it_lock;
+        clockid_t it_clock;             /* which timer type */
+        timer_t it_id;                  /* timer id */
+        int it_overrun;                 /* overrun on pending signal  */
+        int it_overrun_last;            /* overrun on last delivered signal */
+        int it_requeue_pending;         /* waiting to requeue this timer */
+#define REQUEUE_PENDING 1
+        int it_sigev_notify;            /* notify word of sigevent struct */
+        int it_sigev_signo;             /* signo word of sigevent struct */
+        sigval_t it_sigev_value;        /* value word of sigevent struct */
+        struct task_struct *it_process; /* process to send signal to */
+        struct sigqueue *sigq;          /* signal queue entry. */
+        union {
+                struct {
+                        struct timer_list timer;
+                        struct list_head abs_timer_entry; /* clock abs_timer_list */
+                        struct timespec wall_to_prev;   /* wall_to_monotonic used when set */
+                        unsigned long incr; /* interval in jiffies */
+                } real;
+                struct cpu_timer_list cpu;
+                struct {
+                        unsigned int clock;
+                        unsigned int node;
+                        unsigned long incr;
+                        unsigned long expires;
+                } mmtimer;
+        } it;
+};
+
+struct k_clock_abs {
+        struct list_head list;
+        spinlock_t lock;
+};
+struct k_clock {
+        int res;                /* in nano seconds */
+        int (*clock_getres) (clockid_t which_clock, struct timespec *tp);
+        struct k_clock_abs *abs_struct;
+        int (*clock_set) (clockid_t which_clock, struct timespec * tp);
+        int (*clock_get) (clockid_t which_clock, struct timespec * tp);
+        int (*timer_create) (struct k_itimer *timer);
+        int (*nsleep) (clockid_t which_clock, int flags, struct timespec *);
+        int (*timer_set) (struct k_itimer * timr, int flags,
+                          struct itimerspec * new_setting,
+                          struct itimerspec * old_setting);
+        int (*timer_del) (struct k_itimer * timr);
+#define TIMER_RETRY 1
+        void (*timer_get) (struct k_itimer * timr,
+                           struct itimerspec * cur_setting);
+};
+
+void register_posix_clock(clockid_t clock_id, struct k_clock *new_clock);
+
+/* Error handlers for timer_create, nanosleep and settime */
+int do_posix_clock_notimer_create(struct k_itimer *timer);
+int do_posix_clock_nonanosleep(clockid_t, int flags, struct timespec *);
+int do_posix_clock_nosettime(clockid_t, struct timespec *tp);
+
+/* function to call to trigger timer event */
+int posix_timer_event(struct k_itimer *timr, int si_private);
+
+struct now_struct {
+        unsigned long jiffies;
+};
+
+#define posix_get_now(now) (now)->jiffies = jiffies;
+#define posix_time_before(timer, now) \
+                      time_before((timer)->expires, (now)->jiffies)
+
+#define posix_bump_timer(timr, now)                                     \
+         do {                                                           \
+              long delta, orun;                                         \
+              delta = now.jiffies - (timr)->it.real.timer.expires;      \
+              if (delta >= 0) {                                         \
+                   orun = 1 + (delta / (timr)->it.real.incr);           \
+                  (timr)->it.real.timer.expires +=                      \
+                         orun * (timr)->it.real.incr;                   \
+                  (timr)->it_overrun += orun;                           \
+              }                                                         \
+            }while (0)
+
+int posix_cpu_clock_getres(clockid_t which_clock, struct timespec *);
+int posix_cpu_clock_get(clockid_t which_clock, struct timespec *);
+int posix_cpu_clock_set(clockid_t which_clock, const struct timespec *tp);
+int posix_cpu_timer_create(struct k_itimer *);
+int posix_cpu_nsleep(clockid_t, int, struct timespec *);
+int posix_cpu_timer_set(struct k_itimer *, int,
+                        struct itimerspec *, struct itimerspec *);
+int posix_cpu_timer_del(struct k_itimer *);
+void posix_cpu_timer_get(struct k_itimer *, struct itimerspec *);
+
+void posix_cpu_timer_schedule(struct k_itimer *);
+
+void run_posix_cpu_timers(struct task_struct *);
+void posix_cpu_timers_exit(struct task_struct *);
+void posix_cpu_timers_exit_group(struct task_struct *);
+
+void set_process_cpu_timer(struct task_struct *, unsigned int,
+                           cputime_t *, cputime_t *);
+
+#endif
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
new file mode 100644
index 000000000000..4caedddaa033
--- /dev/null
+++ b/include/linux/posix_acl.h
@@ -0,0 +1,86 @@
+/*
+  File: linux/posix_acl.h
+
+  (C) 2002 Andreas Gruenbacher, <a.gruenbacher@computer.org>
+*/
+
+
+#ifndef __LINUX_POSIX_ACL_H
+#define __LINUX_POSIX_ACL_H
+
+#include <linux/slab.h>
+
+#define ACL_UNDEFINED_ID        (-1)
+
+/* a_type field in acl_user_posix_entry_t */
+#define ACL_TYPE_ACCESS         (0x8000)
+#define ACL_TYPE_DEFAULT        (0x4000)
+
+/* e_tag entry in struct posix_acl_entry */
+#define ACL_USER_OBJ            (0x01)
+#define ACL_USER                (0x02)
+#define ACL_GROUP_OBJ           (0x04)
+#define ACL_GROUP               (0x08)
+#define ACL_MASK                (0x10)
+#define ACL_OTHER               (0x20)
+
+/* permissions in the e_perm field */
+#define ACL_READ                (0x04)
+#define ACL_WRITE               (0x02)
+#define ACL_EXECUTE             (0x01)
+//#define ACL_ADD               (0x08)
+//#define ACL_DELETE            (0x10)
+
+struct posix_acl_entry {
+        short                   e_tag;
+        unsigned short          e_perm;
+        unsigned int            e_id;
+};
+
+struct posix_acl {
+        atomic_t                a_refcount;
+        unsigned int            a_count;
+        struct posix_acl_entry  a_entries[0];
+};
+
+#define FOREACH_ACL_ENTRY(pa, acl, pe) \
+        for(pa=(acl)->a_entries, pe=pa+(acl)->a_count; pa<pe; pa++)
+
+
+/*
+ * Duplicate an ACL handle.
+ */
+static inline struct posix_acl *
+posix_acl_dup(struct posix_acl *acl)
+{
+        if (acl)
+                atomic_inc(&acl->a_refcount);
+        return acl;
+}
+
+/*
+ * Free an ACL handle.
+ */
+static inline void
+posix_acl_release(struct posix_acl *acl)
+{
+        if (acl && atomic_dec_and_test(&acl->a_refcount))
+                kfree(acl);
+}
+
+
+/* posix_acl.c */
+
+extern struct posix_acl *posix_acl_alloc(int, unsigned int __nocast);
+extern struct posix_acl *posix_acl_clone(const struct posix_acl *, unsigned int __nocast);
+extern int posix_acl_valid(const struct posix_acl *);
+extern int posix_acl_permission(struct inode *, const struct posix_acl *, int);
+extern struct posix_acl *posix_acl_from_mode(mode_t, unsigned int __nocast);
+extern int posix_acl_equiv_mode(const struct posix_acl *, mode_t *);
+extern int posix_acl_create_masq(struct posix_acl *, mode_t *);
+extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
+
+extern struct posix_acl *get_posix_acl(struct inode *, int);
+extern int set_posix_acl(struct inode *, int, struct posix_acl *);
+
+#endif  /* __LINUX_POSIX_ACL_H */
diff --git a/include/linux/posix_acl_xattr.h b/include/linux/posix_acl_xattr.h
new file mode 100644
index 000000000000..5efd0a6dad94
--- /dev/null
+++ b/include/linux/posix_acl_xattr.h
@@ -0,0 +1,55 @@
+/*
+  File: linux/posix_acl_xattr.h
+
+  Extended attribute system call representation of Access Control Lists.
+
+  Copyright (C) 2000 by Andreas Gruenbacher <a.gruenbacher@computer.org>
+  Copyright (C) 2002 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
+ */
+#ifndef _POSIX_ACL_XATTR_H
+#define _POSIX_ACL_XATTR_H
+
+#include <linux/posix_acl.h>
+
+/* Extended attribute names */
+#define POSIX_ACL_XATTR_ACCESS  "system.posix_acl_access"
+#define POSIX_ACL_XATTR_DEFAULT "system.posix_acl_default"
+
+/* Supported ACL a_version fields */
+#define POSIX_ACL_XATTR_VERSION 0x0002
+
+
+/* An undefined entry e_id value */
+#define ACL_UNDEFINED_ID        (-1)
+
+typedef struct {
+        __u16                   e_tag;
+        __u16                   e_perm;
+        __u32                   e_id;
+} posix_acl_xattr_entry;
+
+typedef struct {
+        __u32                   a_version;
+        posix_acl_xattr_entry   a_entries[0];
+} posix_acl_xattr_header;
+
+
+static inline size_t
+posix_acl_xattr_size(int count)
+{
+        return (sizeof(posix_acl_xattr_header) +
+                (count * sizeof(posix_acl_xattr_entry)));
+}
+
+static inline int
+posix_acl_xattr_count(size_t size)
+{
+        if (size < sizeof(posix_acl_xattr_header))
+                return -1;
+        size -= sizeof(posix_acl_xattr_header);
+        if (size % sizeof(posix_acl_xattr_entry))
+                return -1;
+        return size / sizeof(posix_acl_xattr_entry);
+}
+
+#endif  /* _POSIX_ACL_XATTR_H */
diff --git a/include/linux/posix_types.h b/include/linux/posix_types.h
new file mode 100644
index 000000000000..f04c98cf44f3
--- /dev/null
+++ b/include/linux/posix_types.h
@@ -0,0 +1,49 @@
+#ifndef _LINUX_POSIX_TYPES_H
+#define _LINUX_POSIX_TYPES_H
+
+#include <linux/stddef.h>
+
+/*
+ * This allows for 1024 file descriptors: if NR_OPEN is ever grown
+ * beyond that you'll have to change this too. But 1024 fd's seem to be
+ * enough even for such "real" unices like OSF/1, so hopefully this is
+ * one limit that doesn't have to be changed [again].
+ *
+ * Note that POSIX wants the FD_CLEAR(fd,fdsetp) defines to be in
+ * <sys/time.h> (and thus <linux/time.h>) - but this is a more logical
+ * place for them. Solved by having dummy defines in <sys/time.h>.
+ */
+
+/*
+ * Those macros may have been defined in <gnu/types.h>. But we always
+ * use the ones here. 
+ */
+#undef __NFDBITS
+#define __NFDBITS       (8 * sizeof(unsigned long))
+
+#undef __FD_SETSIZE
+#define __FD_SETSIZE    1024
+
+#undef __FDSET_LONGS
+#define __FDSET_LONGS   (__FD_SETSIZE/__NFDBITS)
+
+#undef __FDELT
+#define __FDELT(d)      ((d) / __NFDBITS)
+
+#undef __FDMASK
+#define __FDMASK(d)     (1UL << ((d) % __NFDBITS))
+
+typedef struct {
+        unsigned long fds_bits [__FDSET_LONGS];
+} __kernel_fd_set;
+
+/* Type of a signal handler.  */
+typedef void (*__kernel_sighandler_t)(int);
+
+/* Type of a SYSV IPC key.  */
+typedef int __kernel_key_t;
+typedef int __kernel_mqd_t;
+
+#include <asm/posix_types.h>
+
+#endif /* _LINUX_POSIX_TYPES_H */
diff --git a/include/linux/ppdev.h b/include/linux/ppdev.h
new file mode 100644
index 000000000000..141c96586824
--- /dev/null
+++ b/include/linux/ppdev.h
@@ -0,0 +1,101 @@
+/*
+ * linux/drivers/char/ppdev.h
+ *
+ * User-space parallel port device driver (header file).
+ *
+ * Copyright (C) 1998-9 Tim Waugh <tim@cyberelk.demon.co.uk>
+ *
+ * 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; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Added PPGETTIME/PPSETTIME, Fred Barnes, 1999
+ * Added PPGETMODES/PPGETMODE/PPGETPHASE, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001
+ */
+
+#define PP_MAJOR        99
+
+#define PP_IOCTL        'p'
+
+/* Set mode for read/write (e.g. IEEE1284_MODE_EPP) */
+#define PPSETMODE       _IOW(PP_IOCTL, 0x80, int)
+
+/* Read status */
+#define PPRSTATUS       _IOR(PP_IOCTL, 0x81, unsigned char)
+#define PPWSTATUS       OBSOLETE__IOW(PP_IOCTL, 0x82, unsigned char)
+
+/* Read/write control */
+#define PPRCONTROL      _IOR(PP_IOCTL, 0x83, unsigned char)
+#define PPWCONTROL      _IOW(PP_IOCTL, 0x84, unsigned char)
+
+struct ppdev_frob_struct {
+        unsigned char mask;
+        unsigned char val;
+};
+#define PPFCONTROL      _IOW(PP_IOCTL, 0x8e, struct ppdev_frob_struct)
+
+/* Read/write data */
+#define PPRDATA         _IOR(PP_IOCTL, 0x85, unsigned char)
+#define PPWDATA         _IOW(PP_IOCTL, 0x86, unsigned char)
+
+/* Read/write econtrol (not used) */
+#define PPRECONTROL     OBSOLETE__IOR(PP_IOCTL, 0x87, unsigned char)
+#define PPWECONTROL     OBSOLETE__IOW(PP_IOCTL, 0x88, unsigned char)
+
+/* Read/write FIFO (not used) */
+#define PPRFIFO         OBSOLETE__IOR(PP_IOCTL, 0x89, unsigned char)
+#define PPWFIFO         OBSOLETE__IOW(PP_IOCTL, 0x8a, unsigned char)
+
+/* Claim the port to start using it */
+#define PPCLAIM         _IO(PP_IOCTL, 0x8b)
+
+/* Release the port when you aren't using it */
+#define PPRELEASE       _IO(PP_IOCTL, 0x8c)
+
+/* Yield the port (release it if another driver is waiting,
+ * then reclaim) */
+#define PPYIELD         _IO(PP_IOCTL, 0x8d)
+
+/* Register device exclusively (must be before PPCLAIM). */
+#define PPEXCL          _IO(PP_IOCTL, 0x8f)
+
+/* Data line direction: non-zero for input mode. */
+#define PPDATADIR       _IOW(PP_IOCTL, 0x90, int)
+
+/* Negotiate a particular IEEE 1284 mode. */
+#define PPNEGOT         _IOW(PP_IOCTL, 0x91, int)
+
+/* Set control lines when an interrupt occurs. */
+#define PPWCTLONIRQ     _IOW(PP_IOCTL, 0x92, unsigned char)
+
+/* Clear (and return) interrupt count. */
+#define PPCLRIRQ        _IOR(PP_IOCTL, 0x93, int)
+
+/* Set the IEEE 1284 phase that we're in (e.g. IEEE1284_PH_FWD_IDLE) */
+#define PPSETPHASE      _IOW(PP_IOCTL, 0x94, int)
+
+/* Set and get port timeout (struct timeval's) */
+#define PPGETTIME       _IOR(PP_IOCTL, 0x95, struct timeval)
+#define PPSETTIME       _IOW(PP_IOCTL, 0x96, struct timeval)
+
+/* Get available modes (what the hardware can do) */
+#define PPGETMODES      _IOR(PP_IOCTL, 0x97, unsigned int)
+
+/* Get the current mode and phaze */
+#define PPGETMODE       _IOR(PP_IOCTL, 0x98, int)
+#define PPGETPHASE      _IOR(PP_IOCTL, 0x99, int)
+
+/* get/set flags */
+#define PPGETFLAGS      _IOR(PP_IOCTL, 0x9a, int)
+#define PPSETFLAGS      _IOW(PP_IOCTL, 0x9b, int)
+
+/* flags visible to the world */
+#define PP_FASTWRITE    (1<<2)
+#define PP_FASTREAD     (1<<3)
+#define PP_W91284PIC    (1<<4)
+
+/* only masks user-visible flags */
+#define PP_FLAGMASK     (PP_FASTWRITE | PP_FASTREAD | PP_W91284PIC)
+
+
diff --git a/include/linux/ppp-comp.h b/include/linux/ppp-comp.h
new file mode 100644
index 000000000000..7227e653b3be
--- /dev/null
+++ b/include/linux/ppp-comp.h
@@ -0,0 +1,207 @@
+/*
+ * ppp-comp.h - Definitions for doing PPP packet compression.
+ *
+ * Copyright (c) 1994 The Australian National University.
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation is hereby granted, provided that the above copyright
+ * notice appears in all copies.  This software is provided without any
+ * warranty, express or implied. The Australian National University
+ * makes no representations about the suitability of this software for
+ * any purpose.
+ *
+ * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
+ * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
+ * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
+ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
+ * OR MODIFICATIONS.
+ *
+ * $Id: ppp-comp.h,v 1.6 1997/11/27 06:04:44 paulus Exp $
+ */
+
+/*
+ *  ==FILEVERSION 980319==
+ *
+ *  NOTE TO MAINTAINERS:
+ *     If you modify this file at all, please set the above date.
+ *     ppp-comp.h is shipped with a PPP distribution as well as with the kernel;
+ *     if everyone increases the FILEVERSION number above, then scripts
+ *     can do the right thing when deciding whether to install a new ppp-comp.h
+ *     file.  Don't change the format of that line otherwise, so the
+ *     installation script can recognize it.
+ */
+
+#ifndef _NET_PPP_COMP_H
+#define _NET_PPP_COMP_H
+
+struct module;
+
+/*
+ * The following symbols control whether we include code for
+ * various compression methods.
+ */
+
+#ifndef DO_BSD_COMPRESS
+#define DO_BSD_COMPRESS 1       /* by default, include BSD-Compress */
+#endif
+#ifndef DO_DEFLATE
+#define DO_DEFLATE      1       /* by default, include Deflate */
+#endif
+#define DO_PREDICTOR_1  0
+#define DO_PREDICTOR_2  0
+
+/*
+ * Structure giving methods for compression/decompression.
+ */
+
+struct compressor {
+        int     compress_proto; /* CCP compression protocol number */
+
+        /* Allocate space for a compressor (transmit side) */
+        void    *(*comp_alloc) (unsigned char *options, int opt_len);
+
+        /* Free space used by a compressor */
+        void    (*comp_free) (void *state);
+
+        /* Initialize a compressor */
+        int     (*comp_init) (void *state, unsigned char *options,
+                              int opt_len, int unit, int opthdr, int debug);
+
+        /* Reset a compressor */
+        void    (*comp_reset) (void *state);
+
+        /* Compress a packet */
+        int     (*compress) (void *state, unsigned char *rptr,
+                              unsigned char *obuf, int isize, int osize);
+
+        /* Return compression statistics */
+        void    (*comp_stat) (void *state, struct compstat *stats);
+
+        /* Allocate space for a decompressor (receive side) */
+        void    *(*decomp_alloc) (unsigned char *options, int opt_len);
+
+        /* Free space used by a decompressor */
+        void    (*decomp_free) (void *state);
+
+        /* Initialize a decompressor */
+        int     (*decomp_init) (void *state, unsigned char *options,
+                                int opt_len, int unit, int opthdr, int mru,
+                                int debug);
+
+        /* Reset a decompressor */
+        void    (*decomp_reset) (void *state);
+
+        /* Decompress a packet. */
+        int     (*decompress) (void *state, unsigned char *ibuf, int isize,
+                                unsigned char *obuf, int osize);
+
+        /* Update state for an incompressible packet received */
+        void    (*incomp) (void *state, unsigned char *ibuf, int icnt);
+
+        /* Return decompression statistics */
+        void    (*decomp_stat) (void *state, struct compstat *stats);
+
+        /* Used in locking compressor modules */
+        struct module *owner;
+};
+
+/*
+ * The return value from decompress routine is the length of the
+ * decompressed packet if successful, otherwise DECOMP_ERROR
+ * or DECOMP_FATALERROR if an error occurred.
+ * 
+ * We need to make this distinction so that we can disable certain
+ * useful functionality, namely sending a CCP reset-request as a result
+ * of an error detected after decompression.  This is to avoid infringing
+ * a patent held by Motorola.
+ * Don't you just lurve software patents.
+ */
+
+#define DECOMP_ERROR            -1      /* error detected before decomp. */
+#define DECOMP_FATALERROR       -2      /* error detected after decomp. */
+
+/*
+ * CCP codes.
+ */
+
+#define CCP_CONFREQ     1
+#define CCP_CONFACK     2
+#define CCP_TERMREQ     5
+#define CCP_TERMACK     6
+#define CCP_RESETREQ    14
+#define CCP_RESETACK    15
+
+/*
+ * Max # bytes for a CCP option
+ */
+
+#define CCP_MAX_OPTION_LENGTH   32
+
+/*
+ * Parts of a CCP packet.
+ */
+
+#define CCP_CODE(dp)            ((dp)[0])
+#define CCP_ID(dp)              ((dp)[1])
+#define CCP_LENGTH(dp)          (((dp)[2] << 8) + (dp)[3])
+#define CCP_HDRLEN              4
+
+#define CCP_OPT_CODE(dp)        ((dp)[0])
+#define CCP_OPT_LENGTH(dp)      ((dp)[1])
+#define CCP_OPT_MINLEN          2
+
+/*
+ * Definitions for BSD-Compress.
+ */
+
+#define CI_BSD_COMPRESS         21      /* config. option for BSD-Compress */
+#define CILEN_BSD_COMPRESS      3       /* length of config. option */
+
+/* Macros for handling the 3rd byte of the BSD-Compress config option. */
+#define BSD_NBITS(x)            ((x) & 0x1F)    /* number of bits requested */
+#define BSD_VERSION(x)          ((x) >> 5)      /* version of option format */
+#define BSD_CURRENT_VERSION     1               /* current version number */
+#define BSD_MAKE_OPT(v, n)      (((v) << 5) | (n))
+
+#define BSD_MIN_BITS            9       /* smallest code size supported */
+#define BSD_MAX_BITS            15      /* largest code size supported */
+
+/*
+ * Definitions for Deflate.
+ */
+
+#define CI_DEFLATE              26      /* config option for Deflate */
+#define CI_DEFLATE_DRAFT        24      /* value used in original draft RFC */
+#define CILEN_DEFLATE           4       /* length of its config option */
+
+#define DEFLATE_MIN_SIZE        9
+#define DEFLATE_MAX_SIZE        15
+#define DEFLATE_METHOD_VAL      8
+#define DEFLATE_SIZE(x)         (((x) >> 4) + 8)
+#define DEFLATE_METHOD(x)       ((x) & 0x0F)
+#define DEFLATE_MAKE_OPT(w)     ((((w) - 8) << 4) + DEFLATE_METHOD_VAL)
+#define DEFLATE_CHK_SEQUENCE    0
+
+/*
+ * Definitions for other, as yet unsupported, compression methods.
+ */
+
+#define CI_PREDICTOR_1          1       /* config option for Predictor-1 */
+#define CILEN_PREDICTOR_1       2       /* length of its config option */
+#define CI_PREDICTOR_2          2       /* config option for Predictor-2 */
+#define CILEN_PREDICTOR_2       2       /* length of its config option */
+
+#ifdef __KERNEL__
+extern int ppp_register_compressor(struct compressor *);
+extern void ppp_unregister_compressor(struct compressor *);
+#endif /* __KERNEL__ */
+
+#endif /* _NET_PPP_COMP_H */
diff --git a/include/linux/ppp_channel.h b/include/linux/ppp_channel.h
new file mode 100644
index 000000000000..a942892d6dfe
--- /dev/null
+++ b/include/linux/ppp_channel.h
@@ -0,0 +1,81 @@
+#ifndef _PPP_CHANNEL_H_
+#define _PPP_CHANNEL_H_
+/*
+ * Definitions for the interface between the generic PPP code
+ * and a PPP channel.
+ *
+ * A PPP channel provides a way for the generic PPP code to send
+ * and receive packets over some sort of communications medium.
+ * Packets are stored in sk_buffs and have the 2-byte PPP protocol
+ * number at the start, but not the address and control bytes.
+ *
+ * Copyright 1999 Paul Mackerras.
+ *
+ *  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; either version
+ *  2 of the License, or (at your option) any later version.
+ *
+ * ==FILEVERSION 20000322==
+ */
+
+#include <linux/list.h>
+#include <linux/skbuff.h>
+#include <linux/poll.h>
+
+struct ppp_channel;
+
+struct ppp_channel_ops {
+        /* Send a packet (or multilink fragment) on this channel.
+           Returns 1 if it was accepted, 0 if not. */
+        int     (*start_xmit)(struct ppp_channel *, struct sk_buff *);
+        /* Handle an ioctl call that has come in via /dev/ppp. */
+        int     (*ioctl)(struct ppp_channel *, unsigned int, unsigned long);
+};
+
+struct ppp_channel {
+        void            *private;       /* channel private data */
+        struct ppp_channel_ops *ops;    /* operations for this channel */
+        int             mtu;            /* max transmit packet size */
+        int             hdrlen;         /* amount of headroom channel needs */
+        void            *ppp;           /* opaque to channel */
+        /* the following are not used at present */
+        int             speed;          /* transfer rate (bytes/second) */
+        int             latency;        /* overhead time in milliseconds */
+};
+
+#ifdef __KERNEL__
+/* Called by the channel when it can send some more data. */
+extern void ppp_output_wakeup(struct ppp_channel *);
+
+/* Called by the channel to process a received PPP packet.
+   The packet should have just the 2-byte PPP protocol header. */
+extern void ppp_input(struct ppp_channel *, struct sk_buff *);
+
+/* Called by the channel when an input error occurs, indicating
+   that we may have missed a packet. */
+extern void ppp_input_error(struct ppp_channel *, int code);
+
+/* Attach a channel to a given PPP unit. */
+extern int ppp_register_channel(struct ppp_channel *);
+
+/* Detach a channel from its PPP unit (e.g. on hangup). */
+extern void ppp_unregister_channel(struct ppp_channel *);
+
+/* Get the channel number for a channel */
+extern int ppp_channel_index(struct ppp_channel *);
+
+/* Get the unit number associated with a channel, or -1 if none */
+extern int ppp_unit_number(struct ppp_channel *);
+
+/*
+ * SMP locking notes:
+ * The channel code must ensure that when it calls ppp_unregister_channel,
+ * nothing is executing in any of the procedures above, for that
+ * channel.  The generic layer will ensure that nothing is executing
+ * in the start_xmit and ioctl routines for the channel by the time
+ * that ppp_unregister_channel returns.
+ */
+
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/ppp_defs.h b/include/linux/ppp_defs.h
new file mode 100644
index 000000000000..402056cd049d
--- /dev/null
+++ b/include/linux/ppp_defs.h
@@ -0,0 +1,190 @@
+/*      $Id: ppp_defs.h,v 1.2 1994/09/21 01:31:06 paulus Exp $  */
+
+/*
+ * ppp_defs.h - PPP definitions.
+ *
+ * Copyright (c) 1994 The Australian National University.
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation is hereby granted, provided that the above copyright
+ * notice appears in all copies.  This software is provided without any
+ * warranty, express or implied. The Australian National University
+ * makes no representations about the suitability of this software for
+ * any purpose.
+ *
+ * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
+ * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
+ * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
+ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
+ * OR MODIFICATIONS.
+ */
+
+/*
+ *  ==FILEVERSION 20000114==
+ *
+ *  NOTE TO MAINTAINERS:
+ *     If you modify this file at all, please set the above date.
+ *     ppp_defs.h is shipped with a PPP distribution as well as with the kernel;
+ *     if everyone increases the FILEVERSION number above, then scripts
+ *     can do the right thing when deciding whether to install a new ppp_defs.h
+ *     file.  Don't change the format of that line otherwise, so the
+ *     installation script can recognize it.
+ */
+
+#ifndef _PPP_DEFS_H_
+#define _PPP_DEFS_H_
+
+#include <linux/crc-ccitt.h>
+
+/*
+ * The basic PPP frame.
+ */
+#define PPP_HDRLEN      4       /* octets for standard ppp header */
+#define PPP_FCSLEN      2       /* octets for FCS */
+#define PPP_MRU         1500    /* default MRU = max length of info field */
+
+#define PPP_ADDRESS(p)  (((__u8 *)(p))[0])
+#define PPP_CONTROL(p)  (((__u8 *)(p))[1])
+#define PPP_PROTOCOL(p) ((((__u8 *)(p))[2] << 8) + ((__u8 *)(p))[3])
+
+/*
+ * Significant octet values.
+ */
+#define PPP_ALLSTATIONS 0xff    /* All-Stations broadcast address */
+#define PPP_UI          0x03    /* Unnumbered Information */
+#define PPP_FLAG        0x7e    /* Flag Sequence */
+#define PPP_ESCAPE      0x7d    /* Asynchronous Control Escape */
+#define PPP_TRANS       0x20    /* Asynchronous transparency modifier */
+
+/*
+ * Protocol field values.
+ */
+#define PPP_IP          0x21    /* Internet Protocol */
+#define PPP_AT          0x29    /* AppleTalk Protocol */
+#define PPP_IPX         0x2b    /* IPX protocol */
+#define PPP_VJC_COMP    0x2d    /* VJ compressed TCP */
+#define PPP_VJC_UNCOMP  0x2f    /* VJ uncompressed TCP */
+#define PPP_MP          0x3d    /* Multilink protocol */
+#define PPP_IPV6        0x57    /* Internet Protocol Version 6 */
+#define PPP_COMPFRAG    0xfb    /* fragment compressed below bundle */
+#define PPP_COMP        0xfd    /* compressed packet */
+#define PPP_MPLS_UC     0x0281  /* Multi Protocol Label Switching - Unicast */
+#define PPP_MPLS_MC     0x0283  /* Multi Protocol Label Switching - Multicast */
+#define PPP_IPCP        0x8021  /* IP Control Protocol */
+#define PPP_ATCP        0x8029  /* AppleTalk Control Protocol */
+#define PPP_IPXCP       0x802b  /* IPX Control Protocol */
+#define PPP_IPV6CP      0x8057  /* IPv6 Control Protocol */
+#define PPP_CCPFRAG     0x80fb  /* CCP at link level (below MP bundle) */
+#define PPP_CCP         0x80fd  /* Compression Control Protocol */
+#define PPP_MPLSCP      0x80fd  /* MPLS Control Protocol */
+#define PPP_LCP         0xc021  /* Link Control Protocol */
+#define PPP_PAP         0xc023  /* Password Authentication Protocol */
+#define PPP_LQR         0xc025  /* Link Quality Report protocol */
+#define PPP_CHAP        0xc223  /* Cryptographic Handshake Auth. Protocol */
+#define PPP_CBCP        0xc029  /* Callback Control Protocol */
+
+/*
+ * Values for FCS calculations.
+ */
+
+#define PPP_INITFCS     0xffff  /* Initial FCS value */
+#define PPP_GOODFCS     0xf0b8  /* Good final FCS value */
+#define PPP_FCS(fcs, c) crc_ccitt_byte(fcs, c)
+
+/*
+ * Extended asyncmap - allows any character to be escaped.
+ */
+
+typedef __u32           ext_accm[8];
+
+/*
+ * What to do with network protocol (NP) packets.
+ */
+enum NPmode {
+    NPMODE_PASS,                /* pass the packet through */
+    NPMODE_DROP,                /* silently drop the packet */
+    NPMODE_ERROR,               /* return an error */
+    NPMODE_QUEUE                /* save it up for later. */
+};
+
+/*
+ * Statistics for LQRP and pppstats
+ */
+struct pppstat  {
+    __u32       ppp_discards;   /* # frames discarded */
+
+    __u32       ppp_ibytes;     /* bytes received */
+    __u32       ppp_ioctects;   /* bytes received not in error */
+    __u32       ppp_ipackets;   /* packets received */
+    __u32       ppp_ierrors;    /* receive errors */
+    __u32       ppp_ilqrs;      /* # LQR frames received */
+
+    __u32       ppp_obytes;     /* raw bytes sent */
+    __u32       ppp_ooctects;   /* frame bytes sent */
+    __u32       ppp_opackets;   /* packets sent */
+    __u32       ppp_oerrors;    /* transmit errors */ 
+    __u32       ppp_olqrs;      /* # LQR frames sent */
+};
+
+struct vjstat {
+    __u32       vjs_packets;    /* outbound packets */
+    __u32       vjs_compressed; /* outbound compressed packets */
+    __u32       vjs_searches;   /* searches for connection state */
+    __u32       vjs_misses;     /* times couldn't find conn. state */
+    __u32       vjs_uncompressedin; /* inbound uncompressed packets */
+    __u32       vjs_compressedin;   /* inbound compressed packets */
+    __u32       vjs_errorin;    /* inbound unknown type packets */
+    __u32       vjs_tossed;     /* inbound packets tossed because of error */
+};
+
+struct compstat {
+    __u32       unc_bytes;      /* total uncompressed bytes */
+    __u32       unc_packets;    /* total uncompressed packets */
+    __u32       comp_bytes;     /* compressed bytes */
+    __u32       comp_packets;   /* compressed packets */
+    __u32       inc_bytes;      /* incompressible bytes */
+    __u32       inc_packets;    /* incompressible packets */
+
+    /* the compression ratio is defined as in_count / bytes_out */
+    __u32       in_count;       /* Bytes received */
+    __u32       bytes_out;      /* Bytes transmitted */
+
+    double      ratio;          /* not computed in kernel. */
+};
+
+struct ppp_stats {
+    struct pppstat      p;      /* basic PPP statistics */
+    struct vjstat       vj;     /* VJ header compression statistics */
+};
+
+struct ppp_comp_stats {
+    struct compstat     c;      /* packet compression statistics */
+    struct compstat     d;      /* packet decompression statistics */
+};
+
+/*
+ * The following structure records the time in seconds since
+ * the last NP packet was sent or received.
+ */
+struct ppp_idle {
+    time_t xmit_idle;           /* time since last NP packet sent */
+    time_t recv_idle;           /* time since last NP packet received */
+};
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(x)  x
+#else
+#define __P(x)  ()
+#endif
+#endif
+
+#endif /* _PPP_DEFS_H_ */
diff --git a/include/linux/prctl.h b/include/linux/prctl.h
new file mode 100644
index 000000000000..bf022c43a18e
--- /dev/null
+++ b/include/linux/prctl.h
@@ -0,0 +1,55 @@
+#ifndef _LINUX_PRCTL_H
+#define _LINUX_PRCTL_H
+
+/* Values to pass as first argument to prctl() */
+
+#define PR_SET_PDEATHSIG  1  /* Second arg is a signal */
+#define PR_GET_PDEATHSIG  2  /* Second arg is a ptr to return the signal */
+
+/* Get/set current->mm->dumpable */
+#define PR_GET_DUMPABLE   3
+#define PR_SET_DUMPABLE   4
+
+/* Get/set unaligned access control bits (if meaningful) */
+#define PR_GET_UNALIGN    5
+#define PR_SET_UNALIGN    6
+# define PR_UNALIGN_NOPRINT     1       /* silently fix up unaligned user accesses */
+# define PR_UNALIGN_SIGBUS      2       /* generate SIGBUS on unaligned user access */
+
+/* Get/set whether or not to drop capabilities on setuid() away from uid 0 */
+#define PR_GET_KEEPCAPS   7
+#define PR_SET_KEEPCAPS   8
+
+/* Get/set floating-point emulation control bits (if meaningful) */
+#define PR_GET_FPEMU  9
+#define PR_SET_FPEMU 10
+# define PR_FPEMU_NOPRINT       1       /* silently emulate fp operations accesses */
+# define PR_FPEMU_SIGFPE        2       /* don't emulate fp operations, send SIGFPE instead */
+
+/* Get/set floating-point exception mode (if meaningful) */
+#define PR_GET_FPEXC    11
+#define PR_SET_FPEXC    12
+# define PR_FP_EXC_SW_ENABLE    0x80    /* Use FPEXC for FP exception enables */
+# define PR_FP_EXC_DIV          0x010000        /* floating point divide by zero */
+# define PR_FP_EXC_OVF          0x020000        /* floating point overflow */
+# define PR_FP_EXC_UND          0x040000        /* floating point underflow */
+# define PR_FP_EXC_RES          0x080000        /* floating point inexact result */
+# define PR_FP_EXC_INV          0x100000        /* floating point invalid operation */
+# define PR_FP_EXC_DISABLED     0       /* FP exceptions disabled */
+# define PR_FP_EXC_NONRECOV     1       /* async non-recoverable exc. mode */
+# define PR_FP_EXC_ASYNC        2       /* async recoverable exception mode */
+# define PR_FP_EXC_PRECISE      3       /* precise exception mode */
+
+/* Get/set whether we use statistical process timing or accurate timestamp
+ * based process timing */
+#define PR_GET_TIMING   13
+#define PR_SET_TIMING   14
+# define PR_TIMING_STATISTICAL  0       /* Normal, traditional,
+                                                   statistical process timing */
+# define PR_TIMING_TIMESTAMP    1       /* Accurate timestamp based
+                                                   process timing */
+
+#define PR_SET_NAME    15               /* Set process name */
+#define PR_GET_NAME    16               /* Get process name */
+
+#endif /* _LINUX_PRCTL_H */
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
new file mode 100644
index 000000000000..dd98c54a23b4
--- /dev/null
+++ b/include/linux/preempt.h
@@ -0,0 +1,62 @@
+#ifndef __LINUX_PREEMPT_H
+#define __LINUX_PREEMPT_H
+
+/*
+ * include/linux/preempt.h - macros for accessing and manipulating
+ * preempt_count (used for kernel preemption, interrupt count, etc.)
+ */
+
+#include <linux/config.h>
+#include <linux/linkage.h>
+
+#ifdef CONFIG_DEBUG_PREEMPT
+  extern void fastcall add_preempt_count(int val);
+  extern void fastcall sub_preempt_count(int val);
+#else
+# define add_preempt_count(val) do { preempt_count() += (val); } while (0)
+# define sub_preempt_count(val) do { preempt_count() -= (val); } while (0)
+#endif
+
+#define inc_preempt_count() add_preempt_count(1)
+#define dec_preempt_count() sub_preempt_count(1)
+
+#define preempt_count() (current_thread_info()->preempt_count)
+
+#ifdef CONFIG_PREEMPT
+
+asmlinkage void preempt_schedule(void);
+
+#define preempt_disable() \
+do { \
+        inc_preempt_count(); \
+        barrier(); \
+} while (0)
+
+#define preempt_enable_no_resched() \
+do { \
+        barrier(); \
+        dec_preempt_count(); \
+} while (0)
+
+#define preempt_check_resched() \
+do { \
+        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
+                preempt_schedule(); \
+} while (0)
+
+#define preempt_enable() \
+do { \
+        preempt_enable_no_resched(); \
+        preempt_check_resched(); \
+} while (0)
+
+#else
+
+#define preempt_disable()               do { } while (0)
+#define preempt_enable_no_resched()     do { } while (0)
+#define preempt_enable()                do { } while (0)
+#define preempt_check_resched()         do { } while (0)
+
+#endif
+
+#endif /* __LINUX_PREEMPT_H */
diff --git a/include/linux/prefetch.h b/include/linux/prefetch.h
new file mode 100644
index 000000000000..fc86f274147f
--- /dev/null
+++ b/include/linux/prefetch.h
@@ -0,0 +1,69 @@
+/*
+ *  Generic cache management functions. Everything is arch-specific,  
+ *  but this header exists to make sure the defines/functions can be
+ *  used in a generic way.
+ *
+ *  2000-11-13  Arjan van de Ven   <arjan@fenrus.demon.nl>
+ *
+ */
+
+#ifndef _LINUX_PREFETCH_H
+#define _LINUX_PREFETCH_H
+
+#include <linux/types.h>
+#include <asm/processor.h>
+#include <asm/cache.h>
+
+/*
+        prefetch(x) attempts to pre-emptively get the memory pointed to
+        by address "x" into the CPU L1 cache. 
+        prefetch(x) should not cause any kind of exception, prefetch(0) is
+        specifically ok.
+
+        prefetch() should be defined by the architecture, if not, the 
+        #define below provides a no-op define.  
+        
+        There are 3 prefetch() macros:
+        
+        prefetch(x)     - prefetches the cacheline at "x" for read
+        prefetchw(x)    - prefetches the cacheline at "x" for write
+        spin_lock_prefetch(x) - prefectches the spinlock *x for taking
+        
+        there is also PREFETCH_STRIDE which is the architecure-prefered 
+        "lookahead" size for prefetching streamed operations.
+        
+*/
+
+/*
+ *      These cannot be do{}while(0) macros. See the mental gymnastics in
+ *      the loop macro.
+ */
+ 
+#ifndef ARCH_HAS_PREFETCH
+static inline void prefetch(const void *x) {;}
+#endif
+
+#ifndef ARCH_HAS_PREFETCHW
+static inline void prefetchw(const void *x) {;}
+#endif
+
+#ifndef ARCH_HAS_SPINLOCK_PREFETCH
+#define spin_lock_prefetch(x) prefetchw(x)
+#endif
+
+#ifndef PREFETCH_STRIDE
+#define PREFETCH_STRIDE (4*L1_CACHE_BYTES)
+#endif
+
+static inline void prefetch_range(void *addr, size_t len)
+{
+#ifdef ARCH_HAS_PREFETCH
+        char *cp;
+        char *end = addr + len;
+
+        for (cp = addr; cp < end; cp += PREFETCH_STRIDE)
+                prefetch(cp);
+#endif
+}
+
+#endif
diff --git a/include/linux/prio_tree.h b/include/linux/prio_tree.h
new file mode 100644
index 000000000000..db04abb557e0
--- /dev/null
+++ b/include/linux/prio_tree.h
@@ -0,0 +1,120 @@
+#ifndef _LINUX_PRIO_TREE_H
+#define _LINUX_PRIO_TREE_H
+
+/*
+ * K&R 2nd ed. A8.3 somewhat obliquely hints that initial sequences of struct
+ * fields with identical types should end up at the same location. We'll use
+ * this until we can scrap struct raw_prio_tree_node.
+ *
+ * Note: all this could be done more elegantly by using unnamed union/struct
+ * fields. However, gcc 2.95.3 and apparently also gcc 3.0.4 don't support this
+ * language extension.
+ */
+
+struct raw_prio_tree_node {
+        struct prio_tree_node   *left;
+        struct prio_tree_node   *right;
+        struct prio_tree_node   *parent;
+};
+
+struct prio_tree_node {
+        struct prio_tree_node   *left;
+        struct prio_tree_node   *right;
+        struct prio_tree_node   *parent;
+        unsigned long           start;
+        unsigned long           last;   /* last location _in_ interval */
+};
+
+struct prio_tree_root {
+        struct prio_tree_node   *prio_tree_node;
+        unsigned short          index_bits;
+        unsigned short          raw;
+                /*
+                 * 0: nodes are of type struct prio_tree_node
+                 * 1: nodes are of type raw_prio_tree_node
+                 */
+};
+
+struct prio_tree_iter {
+        struct prio_tree_node   *cur;
+        unsigned long           mask;
+        unsigned long           value;
+        int                     size_level;
+
+        struct prio_tree_root   *root;
+        pgoff_t                 r_index;
+        pgoff_t                 h_index;
+};
+
+static inline void prio_tree_iter_init(struct prio_tree_iter *iter,
+                struct prio_tree_root *root, pgoff_t r_index, pgoff_t h_index)
+{
+        iter->root = root;
+        iter->r_index = r_index;
+        iter->h_index = h_index;
+        iter->cur = NULL;
+}
+
+#define __INIT_PRIO_TREE_ROOT(ptr, _raw)        \
+do {                                    \
+        (ptr)->prio_tree_node = NULL;   \
+        (ptr)->index_bits = 1;          \
+        (ptr)->raw = (_raw);            \
+} while (0)
+
+#define INIT_PRIO_TREE_ROOT(ptr)        __INIT_PRIO_TREE_ROOT(ptr, 0)
+#define INIT_RAW_PRIO_TREE_ROOT(ptr)    __INIT_PRIO_TREE_ROOT(ptr, 1)
+
+#define INIT_PRIO_TREE_NODE(ptr)                                \
+do {                                                            \
+        (ptr)->left = (ptr)->right = (ptr)->parent = (ptr);     \
+} while (0)
+
+#define INIT_PRIO_TREE_ITER(ptr)        \
+do {                                    \
+        (ptr)->cur = NULL;              \
+        (ptr)->mask = 0UL;              \
+        (ptr)->value = 0UL;             \
+        (ptr)->size_level = 0;          \
+} while (0)
+
+#define prio_tree_entry(ptr, type, member) \
+       ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+
+static inline int prio_tree_empty(const struct prio_tree_root *root)
+{
+        return root->prio_tree_node == NULL;
+}
+
+static inline int prio_tree_root(const struct prio_tree_node *node)
+{
+        return node->parent == node;
+}
+
+static inline int prio_tree_left_empty(const struct prio_tree_node *node)
+{
+        return node->left == node;
+}
+
+static inline int prio_tree_right_empty(const struct prio_tree_node *node)
+{
+        return node->right == node;
+}
+
+
+struct prio_tree_node *prio_tree_replace(struct prio_tree_root *root,
+                struct prio_tree_node *old, struct prio_tree_node *node);
+struct prio_tree_node *prio_tree_insert(struct prio_tree_root *root,
+                struct prio_tree_node *node);
+void prio_tree_remove(struct prio_tree_root *root, struct prio_tree_node *node);
+struct prio_tree_node *prio_tree_next(struct prio_tree_iter *iter);
+
+#define raw_prio_tree_replace(root, old, node) \
+        prio_tree_replace(root, (struct prio_tree_node *) (old), \
+            (struct prio_tree_node *) (node))
+#define raw_prio_tree_insert(root, node) \
+        prio_tree_insert(root, (struct prio_tree_node *) (node))
+#define raw_prio_tree_remove(root, node) \
+        prio_tree_remove(root, (struct prio_tree_node *) (node))
+
+#endif /* _LINUX_PRIO_TREE_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
new file mode 100644
index 000000000000..59e505261fd6
--- /dev/null
+++ b/include/linux/proc_fs.h
@@ -0,0 +1,259 @@
+#ifndef _LINUX_PROC_FS_H
+#define _LINUX_PROC_FS_H
+
+#include <linux/config.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <asm/atomic.h>
+
+/*
+ * The proc filesystem constants/structures
+ */
+
+/*
+ * Offset of the first process in the /proc root directory..
+ */
+#define FIRST_PROCESS_ENTRY 256
+
+
+/*
+ * We always define these enumerators
+ */
+
+enum {
+        PROC_ROOT_INO = 1,
+};
+
+#define PROC_SUPER_MAGIC 0x9fa0
+
+/*
+ * This is not completely implemented yet. The idea is to
+ * create an in-memory tree (like the actual /proc filesystem
+ * tree) of these proc_dir_entries, so that we can dynamically
+ * add new files to /proc.
+ *
+ * The "next" pointer creates a linked list of one /proc directory,
+ * while parent/subdir create the directory structure (every
+ * /proc file has a parent, but "subdir" is NULL for all
+ * non-directory entries).
+ *
+ * "get_info" is called at "read", while "owner" is used to protect module
+ * from unloading while proc_dir_entry is in use
+ */
+
+typedef int (read_proc_t)(char *page, char **start, off_t off,
+                          int count, int *eof, void *data);
+typedef int (write_proc_t)(struct file *file, const char __user *buffer,
+                           unsigned long count, void *data);
+typedef int (get_info_t)(char *, char **, off_t, int);
+
+struct proc_dir_entry {
+        unsigned int low_ino;
+        unsigned short namelen;
+        const char *name;
+        mode_t mode;
+        nlink_t nlink;
+        uid_t uid;
+        gid_t gid;
+        unsigned long size;
+        struct inode_operations * proc_iops;
+        struct file_operations * proc_fops;
+        get_info_t *get_info;
+        struct module *owner;
+        struct proc_dir_entry *next, *parent, *subdir;
+        void *data;
+        read_proc_t *read_proc;
+        write_proc_t *write_proc;
+        atomic_t count;         /* use count */
+        int deleted;            /* delete flag */
+};
+
+struct kcore_list {
+        struct kcore_list *next;
+        unsigned long addr;
+        size_t size;
+};
+
+#ifdef CONFIG_PROC_FS
+
+extern struct proc_dir_entry proc_root;
+extern struct proc_dir_entry *proc_root_fs;
+extern struct proc_dir_entry *proc_net;
+extern struct proc_dir_entry *proc_net_stat;
+extern struct proc_dir_entry *proc_bus;
+extern struct proc_dir_entry *proc_root_driver;
+extern struct proc_dir_entry *proc_root_kcore;
+
+extern void proc_root_init(void);
+extern void proc_misc_init(void);
+
+struct mm_struct;
+
+struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *);
+struct dentry *proc_pid_unhash(struct task_struct *p);
+void proc_pid_flush(struct dentry *proc_dentry);
+int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir);
+unsigned long task_vsize(struct mm_struct *);
+int task_statm(struct mm_struct *, int *, int *, int *, int *);
+char *task_mem(struct mm_struct *, char *);
+
+extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
+                                                struct proc_dir_entry *parent);
+extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
+
+extern struct vfsmount *proc_mnt;
+extern int proc_fill_super(struct super_block *,void *,int);
+extern struct inode *proc_get_inode(struct super_block *, unsigned int, struct proc_dir_entry *);
+
+extern int proc_match(int, const char *,struct proc_dir_entry *);
+
+/*
+ * These are generic /proc routines that use the internal
+ * "struct proc_dir_entry" tree to traverse the filesystem.
+ *
+ * The /proc root directory has extended versions to take care
+ * of the /proc/<pid> subdirectories.
+ */
+extern int proc_readdir(struct file *, void *, filldir_t);
+extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);
+
+extern struct file_operations proc_kcore_operations;
+extern struct file_operations proc_kmsg_operations;
+extern struct file_operations ppc_htab_operations;
+
+/*
+ * proc_tty.c
+ */
+struct tty_driver;
+extern void proc_tty_init(void);
+extern void proc_tty_register_driver(struct tty_driver *driver);
+extern void proc_tty_unregister_driver(struct tty_driver *driver);
+
+/*
+ * proc_devtree.c
+ */
+struct device_node;
+extern void proc_device_tree_init(void);
+#ifdef CONFIG_PROC_DEVICETREE
+extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
+#else /* !CONFIG_PROC_DEVICETREE */
+static inline void proc_device_tree_add_node(struct device_node *np, struct proc_dir_entry *pde)
+{
+        return;
+}
+#endif /* CONFIG_PROC_DEVICETREE */
+
+extern struct proc_dir_entry *proc_symlink(const char *,
+                struct proc_dir_entry *, const char *);
+extern struct proc_dir_entry *proc_mkdir(const char *,struct proc_dir_entry *);
+extern struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
+                        struct proc_dir_entry *parent);
+
+static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
+        mode_t mode, struct proc_dir_entry *base, 
+        read_proc_t *read_proc, void * data)
+{
+        struct proc_dir_entry *res=create_proc_entry(name,mode,base);
+        if (res) {
+                res->read_proc=read_proc;
+                res->data=data;
+        }
+        return res;
+}
+ 
+static inline struct proc_dir_entry *create_proc_info_entry(const char *name,
+        mode_t mode, struct proc_dir_entry *base, get_info_t *get_info)
+{
+        struct proc_dir_entry *res=create_proc_entry(name,mode,base);
+        if (res) res->get_info=get_info;
+        return res;
+}
+ 
+static inline struct proc_dir_entry *proc_net_create(const char *name,
+        mode_t mode, get_info_t *get_info)
+{
+        return create_proc_info_entry(name,mode,proc_net,get_info);
+}
+
+static inline struct proc_dir_entry *proc_net_fops_create(const char *name,
+        mode_t mode, struct file_operations *fops)
+{
+        struct proc_dir_entry *res = create_proc_entry(name, mode, proc_net);
+        if (res)
+                res->proc_fops = fops;
+        return res;
+}
+
+static inline void proc_net_remove(const char *name)
+{
+        remove_proc_entry(name,proc_net);
+}
+
+#else
+
+#define proc_root_driver NULL
+#define proc_net NULL
+#define proc_bus NULL
+
+#define proc_net_fops_create(name, mode, fops)  ({ (void)(mode), NULL; })
+#define proc_net_create(name, mode, info)       ({ (void)(mode), NULL; })
+static inline void proc_net_remove(const char *name) {}
+
+static inline struct dentry *proc_pid_unhash(struct task_struct *p) { return NULL; }
+static inline void proc_pid_flush(struct dentry *proc_dentry) { }
+
+static inline struct proc_dir_entry *create_proc_entry(const char *name,
+        mode_t mode, struct proc_dir_entry *parent) { return NULL; }
+
+#define remove_proc_entry(name, parent) do {} while (0)
+
+static inline struct proc_dir_entry *proc_symlink(const char *name,
+                struct proc_dir_entry *parent,const char *dest) {return NULL;}
+static inline struct proc_dir_entry *proc_mkdir(const char *name,
+        struct proc_dir_entry *parent) {return NULL;}
+
+static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
+        mode_t mode, struct proc_dir_entry *base, 
+        read_proc_t *read_proc, void * data) { return NULL; }
+static inline struct proc_dir_entry *create_proc_info_entry(const char *name,
+        mode_t mode, struct proc_dir_entry *base, get_info_t *get_info)
+        { return NULL; }
+
+struct tty_driver;
+static inline void proc_tty_register_driver(struct tty_driver *driver) {};
+static inline void proc_tty_unregister_driver(struct tty_driver *driver) {};
+
+extern struct proc_dir_entry proc_root;
+
+#endif /* CONFIG_PROC_FS */
+
+#if !defined(CONFIG_PROC_KCORE)
+static inline void kclist_add(struct kcore_list *new, void *addr, size_t size)
+{
+}
+#else
+extern void kclist_add(struct kcore_list *, void *, size_t);
+#endif
+
+struct proc_inode {
+        struct task_struct *task;
+        int type;
+        union {
+                int (*proc_get_link)(struct inode *, struct dentry **, struct vfsmount **);
+                int (*proc_read)(struct task_struct *task, char *page);
+        } op;
+        struct proc_dir_entry *pde;
+        struct inode vfs_inode;
+};
+
+static inline struct proc_inode *PROC_I(const struct inode *inode)
+{
+        return container_of(inode, struct proc_inode, vfs_inode);
+}
+
+static inline struct proc_dir_entry *PDE(const struct inode *inode)
+{
+        return PROC_I(inode)->pde;
+}
+
+#endif /* _LINUX_PROC_FS_H */
diff --git a/include/linux/profile.h b/include/linux/profile.h
new file mode 100644
index 000000000000..026969a5595c
--- /dev/null
+++ b/include/linux/profile.h
@@ -0,0 +1,104 @@
+#ifndef _LINUX_PROFILE_H
+#define _LINUX_PROFILE_H
+
+#ifdef __KERNEL__
+
+#include <linux/kernel.h>
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/cpumask.h>
+#include <asm/errno.h>
+
+#define CPU_PROFILING   1
+#define SCHED_PROFILING 2
+
+struct proc_dir_entry;
+struct pt_regs;
+
+/* init basic kernel profiler */
+void __init profile_init(void);
+void profile_tick(int, struct pt_regs *);
+void profile_hit(int, void *);
+#ifdef CONFIG_PROC_FS
+void create_prof_cpu_mask(struct proc_dir_entry *);
+#else
+#define create_prof_cpu_mask(x)                 do { (void)(x); } while (0)
+#endif
+
+enum profile_type {
+        PROFILE_TASK_EXIT,
+        PROFILE_MUNMAP
+};
+
+#ifdef CONFIG_PROFILING
+
+struct notifier_block;
+struct task_struct;
+struct mm_struct;
+
+/* task is in do_exit() */
+void profile_task_exit(struct task_struct * task);
+
+/* task is dead, free task struct ? Returns 1 if
+ * the task was taken, 0 if the task should be freed.
+ */
+int profile_handoff_task(struct task_struct * task);
+
+/* sys_munmap */
+void profile_munmap(unsigned long addr);
+
+int task_handoff_register(struct notifier_block * n);
+int task_handoff_unregister(struct notifier_block * n);
+
+int profile_event_register(enum profile_type, struct notifier_block * n);
+int profile_event_unregister(enum profile_type, struct notifier_block * n);
+
+int register_timer_hook(int (*hook)(struct pt_regs *));
+void unregister_timer_hook(int (*hook)(struct pt_regs *));
+
+/* Timer based profiling hook */
+extern int (*timer_hook)(struct pt_regs *);
+
+struct pt_regs;
+
+#else
+
+static inline int task_handoff_register(struct notifier_block * n)
+{
+        return -ENOSYS;
+}
+
+static inline int task_handoff_unregister(struct notifier_block * n)
+{
+        return -ENOSYS;
+}
+
+static inline int profile_event_register(enum profile_type t, struct notifier_block * n)
+{
+        return -ENOSYS;
+}
+
+static inline int profile_event_unregister(enum profile_type t, struct notifier_block * n)
+{
+        return -ENOSYS;
+}
+
+#define profile_task_exit(a) do { } while (0)
+#define profile_handoff_task(a) (0)
+#define profile_munmap(a) do { } while (0)
+
+static inline int register_timer_hook(int (*hook)(struct pt_regs *))
+{
+        return -ENOSYS;
+}
+
+static inline void unregister_timer_hook(int (*hook)(struct pt_regs *))
+{
+        return;
+}
+
+#endif /* CONFIG_PROFILING */
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_PROFILE_H */
diff --git a/include/linux/ps2esdi.h b/include/linux/ps2esdi.h
new file mode 100644
index 000000000000..c0e050b1dfe9
--- /dev/null
+++ b/include/linux/ps2esdi.h
@@ -0,0 +1,98 @@
+#ifndef _PS2ESDI_H_
+#define _PS2ESDI_H_
+
+#define NRML_ESDI_ID 0xddff
+#define INTG_ESDI_ID 0xdf9f
+
+#define PRIMARY_IO_BASE 0x3510
+#define ALT_IO_BASE 0x3518
+
+#define ESDI_CMD_INT (io_base+0)
+#define ESDI_STT_INT (io_base+0)
+#define ESDI_CONTROL (io_base+2)
+#define ESDI_STATUS  (io_base+2)
+#define ESDI_ATTN    (io_base+3)
+#define ESDI_INTRPT  (io_base+3)
+
+#define STATUS_ENABLED    0x01
+#define STATUS_ALTERNATE  0x02
+#define STATUS_BUSY       0x10
+#define STATUS_STAT_AVAIL 0x08
+#define STATUS_INTR       0x01
+#define STATUS_RESET_FAIL 0xea
+#define STATUS_CMD_INF    0x04
+
+#define CTRL_SOFT_RESET   0xe4
+#define CTRL_HARD_RESET   0x80
+#define CTRL_EOI          0xe2
+#define CTRL_ENABLE_DMA   0x02
+#define CTRL_ENABLE_INTR  0x01
+#define CTRL_DISABLE_INTR  0x00
+
+#define ATT_EOI 0x02
+
+/* bits of word 0 of configuration status block. more info see p.38 of tech ref */
+#define CONFIG_IS 0x10 /* Invalid Secondary */
+#define CONFIG_ZD 0x08 /* Zero Defect */
+#define CONFIG_SF 0x04 /* Skewed Format */
+#define CONFIG_FR 0x02 /* Removable */
+#define CONFIG_RT 0x01 /* Retries */
+
+#define PORT_SYS_A   0x92
+#define PORT_DMA_FN  0x18
+#define PORT_DMA_EX  0x1a
+
+#define ON (unsigned char)0x40
+#define OFF (unsigned char)~ON
+#define LITE_ON outb(inb(PORT_SYS_A) | ON,PORT_SYS_A)
+#define LITE_OFF outb((inb(PORT_SYS_A) & OFF),PORT_SYS_A)
+
+#define FAIL 0
+#define SUCCES 1
+
+#define INT_CMD_COMPLETE 0x01
+#define INT_CMD_ECC      0x03
+#define INT_CMD_RETRY    0x05
+#define INT_CMD_FORMAT   0x06
+#define INT_CMD_ECC_RETRY 0x07
+#define INT_CMD_WARNING  0x08
+#define INT_CMD_ABORT    0x09
+#define INT_RESET        0x0A
+#define INT_TRANSFER_REQ 0x0B
+#define INT_CMD_FAILED   0x0C
+#define INT_DMA_ERR      0x0D
+#define INT_CMD_BLK_ERR  0x0E
+#define INT_ATTN_ERROR   0x0F
+
+#define DMA_MASK_CHAN 0x90
+#define DMA_UNMASK_CHAN 0xA0
+#define DMA_WRITE_ADDR 0x20
+#define DMA_WRITE_TC 0x40
+#define DMA_WRITE_MODE 0x70
+
+#define CMD_GET_DEV_CONFIG 0x09
+#define CMD_READ 0x4601
+#define CMD_WRITE 0x4602
+#define DMA_READ_16 0x4C
+#define DMA_WRITE_16 0x44
+
+
+#define MB 1024*1024
+#define SECT_SIZE 512   
+
+#define ERROR 1
+#define OK 0
+
+#define HDIO_GETGEO 0x0301
+
+#define FALSE 0
+#define TRUE !FALSE
+
+struct ps2esdi_geometry {
+        unsigned char heads;
+        unsigned char sectors;
+        unsigned short cylinders;
+        unsigned long start;
+};
+
+#endif /* _PS2ESDI_H_ */
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
new file mode 100644
index 000000000000..a373fc254df2
--- /dev/null
+++ b/include/linux/ptrace.h
@@ -0,0 +1,122 @@
+#ifndef _LINUX_PTRACE_H
+#define _LINUX_PTRACE_H
+/* ptrace.h */
+/* structs and defines to help the user use the ptrace system call. */
+
+/* has the defines to get at the registers. */
+
+#define PTRACE_TRACEME             0
+#define PTRACE_PEEKTEXT            1
+#define PTRACE_PEEKDATA            2
+#define PTRACE_PEEKUSR             3
+#define PTRACE_POKETEXT            4
+#define PTRACE_POKEDATA            5
+#define PTRACE_POKEUSR             6
+#define PTRACE_CONT                7
+#define PTRACE_KILL                8
+#define PTRACE_SINGLESTEP          9
+
+#define PTRACE_ATTACH           0x10
+#define PTRACE_DETACH           0x11
+
+#define PTRACE_SYSCALL            24
+
+/* 0x4200-0x4300 are reserved for architecture-independent additions.  */
+#define PTRACE_SETOPTIONS       0x4200
+#define PTRACE_GETEVENTMSG      0x4201
+#define PTRACE_GETSIGINFO       0x4202
+#define PTRACE_SETSIGINFO       0x4203
+
+/* options set using PTRACE_SETOPTIONS */
+#define PTRACE_O_TRACESYSGOOD   0x00000001
+#define PTRACE_O_TRACEFORK      0x00000002
+#define PTRACE_O_TRACEVFORK     0x00000004
+#define PTRACE_O_TRACECLONE     0x00000008
+#define PTRACE_O_TRACEEXEC      0x00000010
+#define PTRACE_O_TRACEVFORKDONE 0x00000020
+#define PTRACE_O_TRACEEXIT      0x00000040
+
+#define PTRACE_O_MASK           0x0000007f
+
+/* Wait extended result codes for the above trace options.  */
+#define PTRACE_EVENT_FORK       1
+#define PTRACE_EVENT_VFORK      2
+#define PTRACE_EVENT_CLONE      3
+#define PTRACE_EVENT_EXEC       4
+#define PTRACE_EVENT_VFORK_DONE 5
+#define PTRACE_EVENT_EXIT       6
+
+#include <asm/ptrace.h>
+
+#ifdef __KERNEL__
+/*
+ * Ptrace flags
+ */
+
+#define PT_PTRACED      0x00000001
+#define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
+#define PT_TRACESYSGOOD 0x00000004
+#define PT_PTRACE_CAP   0x00000008      /* ptracer can follow suid-exec */
+#define PT_TRACE_FORK   0x00000010
+#define PT_TRACE_VFORK  0x00000020
+#define PT_TRACE_CLONE  0x00000040
+#define PT_TRACE_EXEC   0x00000080
+#define PT_TRACE_VFORK_DONE     0x00000100
+#define PT_TRACE_EXIT   0x00000200
+#define PT_ATTACHED     0x00000400      /* parent != real_parent */
+
+#define PT_TRACE_MASK   0x000003f4
+
+/* single stepping state bits (used on ARM and PA-RISC) */
+#define PT_SINGLESTEP_BIT       31
+#define PT_SINGLESTEP           (1<<PT_SINGLESTEP_BIT)
+#define PT_BLOCKSTEP_BIT        30
+#define PT_BLOCKSTEP            (1<<PT_BLOCKSTEP_BIT)
+
+#include <linux/compiler.h>             /* For unlikely.  */
+#include <linux/sched.h>                /* For struct task_struct.  */
+
+extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
+extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
+extern int ptrace_attach(struct task_struct *tsk);
+extern int ptrace_detach(struct task_struct *, unsigned int);
+extern void ptrace_disable(struct task_struct *);
+extern int ptrace_check_attach(struct task_struct *task, int kill);
+extern int ptrace_request(struct task_struct *child, long request, long addr, long data);
+extern void ptrace_notify(int exit_code);
+extern void __ptrace_link(struct task_struct *child,
+                          struct task_struct *new_parent);
+extern void __ptrace_unlink(struct task_struct *child);
+extern void ptrace_untrace(struct task_struct *child);
+
+static inline void ptrace_link(struct task_struct *child,
+                               struct task_struct *new_parent)
+{
+        if (unlikely(child->ptrace))
+                __ptrace_link(child, new_parent);
+}
+static inline void ptrace_unlink(struct task_struct *child)
+{
+        if (unlikely(child->ptrace))
+                __ptrace_unlink(child);
+}
+
+
+#ifndef force_successful_syscall_return
+/*
+ * System call handlers that, upon successful completion, need to return a
+ * negative value should call force_successful_syscall_return() right before
+ * returning.  On architectures where the syscall convention provides for a
+ * separate error flag (e.g., alpha, ia64, ppc{,64}, sparc{,64}, possibly
+ * others), this macro can be used to ensure that the error flag will not get
+ * set.  On architectures which do not support a separate error flag, the macro
+ * is a no-op and the spurious error condition needs to be filtered out by some
+ * other means (e.g., in user-level, by passing an extra argument to the
+ * syscall handler, or something along those lines).
+ */
+#define force_successful_syscall_return() do { } while (0)
+#endif
+
+#endif
+
+#endif
diff --git a/include/linux/qic117.h b/include/linux/qic117.h
new file mode 100644
index 000000000000..07b537e5d359
--- /dev/null
+++ b/include/linux/qic117.h
@@ -0,0 +1,290 @@
+#ifndef _QIC117_H
+#define _QIC117_H
+
+/*
+ *      Copyright (C) 1993-1996 Bas Laarhoven,
+ *                (C) 1997      Claus-Justus Heine.
+
+ 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; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ *
+ * $Source: /homes/cvs/ftape-stacked/include/linux/qic117.h,v $
+ * $Revision: 1.2 $
+ * $Date: 1997/10/05 19:19:32 $
+ *
+ *      This file contains QIC-117 spec. related definitions for the
+ *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
+ *
+ *      These data were taken from the Quarter-Inch Cartridge
+ *      Drive Standards, Inc. document titled:
+ *      `Common Command Set Interface Specification for Flexible
+ *       Disk Controller Based Minicartridge Tape Drives'
+ *       document QIC-117 Revision J, 28 Aug 96.
+ *      For more information, contact:
+ *       Quarter-Inch Cartridge Drive Standards, Inc.
+ *       311 East Carrillo Street
+ *       Santa Barbara, California 93101
+ *       Telephone (805) 963-3853
+ *       Fax       (805) 962-1541
+ *       WWW       http://www.qic.org
+ *
+ *      Current QIC standard revisions (of interest) are:
+ *       QIC-40-MC,   Rev. M,  2 Sep 92.
+ *       QIC-80-MC,   Rev. N, 20 Mar 96.
+ *       QIC-80-MC,   Rev. K, 15 Dec 94.
+ *       QIC-113,     Rev. G, 15 Jun 95.
+ *       QIC-117,     Rev. J, 28 Aug 96.
+ *       QIC-122,     Rev. B,  6 Mar 91.
+ *       QIC-130,     Rev. C,  2 Sep 92.
+ *       QIC-3010-MC, Rev. F, 14 Jun 95.
+ *       QIC-3020-MC, Rev. G, 31 Aug 95.
+ *       QIC-CRF3,    Rev. B, 15 Jun 95.
+ * */
+
+/*
+ *      QIC-117 common command set rev. J.
+ *      These commands are sent to the tape unit
+ *      as number of pulses over the step line.
+ */
+
+typedef enum {
+        QIC_NO_COMMAND                  = 0,
+        QIC_RESET                       = 1,
+        QIC_REPORT_NEXT_BIT             = 2,
+        QIC_PAUSE                       = 3,
+        QIC_MICRO_STEP_PAUSE            = 4,
+        QIC_ALTERNATE_TIMEOUT           = 5,
+        QIC_REPORT_DRIVE_STATUS         = 6,
+        QIC_REPORT_ERROR_CODE           = 7,
+        QIC_REPORT_DRIVE_CONFIGURATION  = 8,
+        QIC_REPORT_ROM_VERSION          = 9,
+        QIC_LOGICAL_FORWARD             = 10,
+        QIC_PHYSICAL_REVERSE            = 11,
+        QIC_PHYSICAL_FORWARD            = 12,
+        QIC_SEEK_HEAD_TO_TRACK          = 13,
+        QIC_SEEK_LOAD_POINT             = 14,
+        QIC_ENTER_FORMAT_MODE           = 15,
+        QIC_WRITE_REFERENCE_BURST       = 16,
+        QIC_ENTER_VERIFY_MODE           = 17,
+        QIC_STOP_TAPE                   = 18,
+/* commands 19-20: reserved */
+        QIC_MICRO_STEP_HEAD_UP          = 21,
+        QIC_MICRO_STEP_HEAD_DOWN        = 22,
+        QIC_SOFT_SELECT                 = 23,
+        QIC_SOFT_DESELECT               = 24,
+        QIC_SKIP_REVERSE                = 25,
+        QIC_SKIP_FORWARD                = 26,
+        QIC_SELECT_RATE                 = 27,
+/* command 27, in ccs2: Select Rate or Format */
+        QIC_ENTER_DIAGNOSTIC_1          = 28,
+        QIC_ENTER_DIAGNOSTIC_2          = 29,
+        QIC_ENTER_PRIMARY_MODE          = 30,
+/* command 31: vendor unique */
+        QIC_REPORT_VENDOR_ID            = 32,
+        QIC_REPORT_TAPE_STATUS          = 33,
+        QIC_SKIP_EXTENDED_REVERSE       = 34,
+        QIC_SKIP_EXTENDED_FORWARD       = 35,
+        QIC_CALIBRATE_TAPE_LENGTH       = 36,
+        QIC_REPORT_FORMAT_SEGMENTS      = 37,
+        QIC_SET_FORMAT_SEGMENTS         = 38,
+/* commands 39-45: reserved */
+        QIC_PHANTOM_SELECT              = 46,
+        QIC_PHANTOM_DESELECT            = 47
+} qic117_cmd_t;
+
+typedef enum {
+        discretional = 0, required, ccs1, ccs2
+} qic_compatibility;
+
+typedef enum {
+        unused, mode, motion, report
+} command_types;
+
+struct qic117_command_table {
+        char *name;
+        __u8 mask;
+        __u8 state;
+        __u8 cmd_type;
+        __u8 non_intr;
+        __u8 level;
+};
+
+#define QIC117_COMMANDS {\
+/* command                           mask  state cmd_type           */\
+/* |    name                         |     |     |       non_intr   */\
+/* |    |                            |     |     |       |  level   */\
+/* 0*/ {NULL,                        0x00, 0x00, mode,   0, discretional},\
+/* 1*/ {"soft reset",                0x00, 0x00, motion, 1, required},\
+/* 2*/ {"report next bit",           0x00, 0x00, report, 0, required},\
+/* 3*/ {"pause",                     0x36, 0x24, motion, 1, required},\
+/* 4*/ {"micro step pause",          0x36, 0x24, motion, 1, required},\
+/* 5*/ {"alternate command timeout", 0x00, 0x00, mode,   0, required},\
+/* 6*/ {"report drive status",       0x00, 0x00, report, 0, required},\
+/* 7*/ {"report error code",         0x01, 0x01, report, 0, required},\
+/* 8*/ {"report drive configuration",0x00, 0x00, report, 0, required},\
+/* 9*/ {"report rom version",        0x00, 0x00, report, 0, required},\
+/*10*/ {"logical forward",           0x37, 0x25, motion, 0, required},\
+/*11*/ {"physical reverse",          0x17, 0x05, motion, 0, required},\
+/*12*/ {"physical forward",          0x17, 0x05, motion, 0, required},\
+/*13*/ {"seek head to track",        0x37, 0x25, motion, 0, required},\
+/*14*/ {"seek load point",           0x17, 0x05, motion, 1, required},\
+/*15*/ {"enter format mode",         0x1f, 0x05, mode,   0, required},\
+/*16*/ {"write reference burst",     0x1f, 0x05, motion, 1, required},\
+/*17*/ {"enter verify mode",         0x37, 0x25, mode,   0, required},\
+/*18*/ {"stop tape",                 0x00, 0x00, motion, 1, required},\
+/*19*/ {"reserved (19)",             0x00, 0x00, unused, 0, discretional},\
+/*20*/ {"reserved (20)",             0x00, 0x00, unused, 0, discretional},\
+/*21*/ {"micro step head up",        0x02, 0x00, motion, 0, required},\
+/*22*/ {"micro step head down",      0x02, 0x00, motion, 0, required},\
+/*23*/ {"soft select",               0x00, 0x00, mode,   0, discretional},\
+/*24*/ {"soft deselect",             0x00, 0x00, mode,   0, discretional},\
+/*25*/ {"skip segments reverse",     0x36, 0x24, motion, 1, required},\
+/*26*/ {"skip segments forward",     0x36, 0x24, motion, 1, required},\
+/*27*/ {"select rate or format",     0x03, 0x01, mode,   0, required /* [ccs2] */},\
+/*28*/ {"enter diag mode 1",         0x00, 0x00, mode,   0, discretional},\
+/*29*/ {"enter diag mode 2",         0x00, 0x00, mode,   0, discretional},\
+/*30*/ {"enter primary mode",        0x00, 0x00, mode,   0, required},\
+/*31*/ {"vendor unique (31)",        0x00, 0x00, unused, 0, discretional},\
+/*32*/ {"report vendor id",          0x00, 0x00, report, 0, required},\
+/*33*/ {"report tape status",        0x04, 0x04, report, 0, ccs1},\
+/*34*/ {"skip extended reverse",     0x36, 0x24, motion, 1, ccs1},\
+/*35*/ {"skip extended forward",     0x36, 0x24, motion, 1, ccs1},\
+/*36*/ {"calibrate tape length",     0x17, 0x05, motion, 1, ccs2},\
+/*37*/ {"report format segments",    0x17, 0x05, report, 0, ccs2},\
+/*38*/ {"set format segments",       0x17, 0x05, mode,   0, ccs2},\
+/*39*/ {"reserved (39)",             0x00, 0x00, unused, 0, discretional},\
+/*40*/ {"vendor unique (40)",        0x00, 0x00, unused, 0, discretional},\
+/*41*/ {"vendor unique (41)",        0x00, 0x00, unused, 0, discretional},\
+/*42*/ {"vendor unique (42)",        0x00, 0x00, unused, 0, discretional},\
+/*43*/ {"vendor unique (43)",        0x00, 0x00, unused, 0, discretional},\
+/*44*/ {"vendor unique (44)",        0x00, 0x00, unused, 0, discretional},\
+/*45*/ {"vendor unique (45)",        0x00, 0x00, unused, 0, discretional},\
+/*46*/ {"phantom select",            0x00, 0x00, mode,   0, discretional},\
+/*47*/ {"phantom deselect",          0x00, 0x00, mode,   0, discretional},\
+}
+
+/*
+ *      Status bits returned by QIC_REPORT_DRIVE_STATUS
+ */
+
+#define QIC_STATUS_READY        0x01    /* Drive is ready or idle. */
+#define QIC_STATUS_ERROR        0x02    /* Error detected, must read
+                                           error code to clear this */
+#define QIC_STATUS_CARTRIDGE_PRESENT 0x04       /* Tape is present */
+#define QIC_STATUS_WRITE_PROTECT 0x08   /* Tape is write protected */
+#define QIC_STATUS_NEW_CARTRIDGE 0x10   /* New cartridge inserted, must
+                                           read error status to clear. */
+#define QIC_STATUS_REFERENCED   0x20    /* Cartridge appears to have been
+                                           formatted. */
+#define QIC_STATUS_AT_BOT       0x40    /* Cartridge is at physical
+                                           beginning of tape. */
+#define QIC_STATUS_AT_EOT       0x80    /* Cartridge is at physical end
+                                           of tape. */
+/*
+ *      Status bits returned by QIC_REPORT_DRIVE_CONFIGURATION
+ */
+
+#define QIC_CONFIG_RATE_MASK    0x18
+#define QIC_CONFIG_RATE_SHIFT   3
+#define QIC_CONFIG_RATE_250     0
+#define QIC_CONFIG_RATE_500     2
+#define QIC_CONFIG_RATE_1000    3
+#define QIC_CONFIG_RATE_2000    1
+#define QIC_CONFIG_RATE_4000    0       /* since QIC-117 Rev. J */
+
+#define QIC_CONFIG_LONG         0x40    /* Extra Length Tape Detected */
+#define QIC_CONFIG_80           0x80    /* QIC-80 detected. */
+
+/*
+ *      Status bits returned by QIC_REPORT_TAPE_STATUS
+ */
+
+#define QIC_TAPE_STD_MASK       0x0f
+#define QIC_TAPE_QIC40          0x01
+#define QIC_TAPE_QIC80          0x02
+#define QIC_TAPE_QIC3020        0x03
+#define QIC_TAPE_QIC3010        0x04
+
+#define QIC_TAPE_LEN_MASK       0x70
+#define QIC_TAPE_205FT          0x10
+#define QIC_TAPE_307FT          0x20
+#define QIC_TAPE_VARIABLE       0x30
+#define QIC_TAPE_1100FT         0x40
+#define QIC_TAPE_FLEX           0x60
+
+#define QIC_TAPE_WIDE           0x80
+
+/* Define a value (in feet) slightly higher than 
+ * the possible maximum tape length.
+ */
+#define QIC_TOP_TAPE_LEN        1500
+
+/*
+ *      Errors: List of error codes, and their severity.
+ */
+
+typedef struct {
+        char *message;          /* Text describing the error. */
+        unsigned int fatal:1;   /* Non-zero if the error is fatal. */
+} ftape_error;
+
+#define QIC117_ERRORS {\
+  /* 0*/ { "No error", 0, },\
+  /* 1*/ { "Command Received while Drive Not Ready", 0, },\
+  /* 2*/ { "Cartridge Not Present or Removed", 1, },\
+  /* 3*/ { "Motor Speed Error (not within 1%)", 1, },\
+  /* 4*/ { "Motor Speed Fault (jammed, or gross speed error", 1, },\
+  /* 5*/ { "Cartridge Write Protected", 1, },\
+  /* 6*/ { "Undefined or Reserved Command Code", 1, },\
+  /* 7*/ { "Illegal Track Address Specified for Seek", 1, },\
+  /* 8*/ { "Illegal Command in Report Subcontext", 0, },\
+  /* 9*/ { "Illegal Entry into a Diagnostic Mode", 1, },\
+  /*10*/ { "Broken Tape Detected (based on hole sensor)", 1, },\
+  /*11*/ { "Warning--Read Gain Setting Error", 1, },\
+  /*12*/ { "Command Received While Error Status Pending (obs)", 1, },\
+  /*13*/ { "Command Received While New Cartridge Pending", 1, },\
+  /*14*/ { "Command Illegal or Undefined in Primary Mode", 1, },\
+  /*15*/ { "Command Illegal or Undefined in Format Mode", 1, },\
+  /*16*/ { "Command Illegal or Undefined in Verify Mode", 1, },\
+  /*17*/ { "Logical Forward Not at Logical BOT or no Format Segments in Format Mode", 1, },\
+  /*18*/ { "Logical EOT Before All Segments generated", 1, },\
+  /*19*/ { "Command Illegal When Cartridge Not Referenced", 1, },\
+  /*20*/ { "Self-Diagnostic Failed (cannot be cleared)", 1, },\
+  /*21*/ { "Warning EEPROM Not Initialized, Defaults Set", 1, },\
+  /*22*/ { "EEPROM Corrupted or Hardware Failure", 1, },\
+  /*23*/ { "Motion Time-out Error", 1, },\
+  /*24*/ { "Data Segment Too Long -- Logical Forward or Pause", 1, },\
+  /*25*/ { "Transmit Overrun (obs)", 1, },\
+  /*26*/ { "Power On Reset Occurred", 0, },\
+  /*27*/ { "Software Reset Occurred", 0, },\
+  /*28*/ { "Diagnostic Mode 1 Error", 1, },\
+  /*29*/ { "Diagnostic Mode 2 Error", 1, },\
+  /*30*/ { "Command Received During Non-Interruptible Process", 1, },\
+  /*31*/ { "Rate or Format Selection Error", 1, },\
+  /*32*/ { "Illegal Command While in High Speed Mode", 1, },\
+  /*33*/ { "Illegal Seek Segment Value", 1, },\
+  /*34*/ { "Invalid Media", 1, },\
+  /*35*/ { "Head Positioning Failure", 1, },\
+  /*36*/ { "Write Reference Burst Failure", 1, },\
+  /*37*/ { "Prom Code Missing", 1, },\
+  /*38*/ { "Invalid Format", 1, },\
+  /*39*/ { "EOT/BOT System Failure", 1, },\
+  /*40*/ { "Prom A Checksum Error", 1, },\
+  /*41*/ { "Drive Wakeup Reset Occurred", 1, },\
+  /*42*/ { "Prom B Checksum Error", 1, },\
+  /*43*/ { "Illegal Entry into Format Mode", 1, },\
+}
+
+#endif                          /* _QIC117_H */
diff --git a/include/linux/qnx4_fs.h b/include/linux/qnx4_fs.h
new file mode 100644
index 000000000000..22ba580b0ae8
--- /dev/null
+++ b/include/linux/qnx4_fs.h
@@ -0,0 +1,150 @@
+/*
+ *  Name                         : qnx4_fs.h
+ *  Author                       : Richard Frowijn
+ *  Function                     : qnx4 global filesystem definitions
+ *  Version                      : 1.0.2
+ *  Last modified                : 2000-01-31
+ *
+ *  History                      : 23-03-1998 created
+ */
+#ifndef _LINUX_QNX4_FS_H
+#define _LINUX_QNX4_FS_H
+
+#include <linux/qnxtypes.h>
+
+#define QNX4_ROOT_INO 1
+
+#define QNX4_MAX_XTNTS_PER_XBLK 60
+/* for di_status */
+#define QNX4_FILE_USED          0x01
+#define QNX4_FILE_MODIFIED      0x02
+#define QNX4_FILE_BUSY          0x04
+#define QNX4_FILE_LINK          0x08
+#define QNX4_FILE_INODE         0x10
+#define QNX4_FILE_FSYSCLEAN     0x20
+
+#define QNX4_I_MAP_SLOTS        8
+#define QNX4_Z_MAP_SLOTS        64
+#define QNX4_SUPER_MAGIC        0x002f  /* qnx4 fs detection */
+#define QNX4_VALID_FS           0x0001  /* Clean fs. */
+#define QNX4_ERROR_FS           0x0002  /* fs has errors. */
+#define QNX4_BLOCK_SIZE         0x200   /* blocksize of 512 bytes */
+#define QNX4_BLOCK_SIZE_BITS    9       /* blocksize shift */
+#define QNX4_DIR_ENTRY_SIZE     0x040   /* dir entry size of 64 bytes */
+#define QNX4_DIR_ENTRY_SIZE_BITS 6      /* dir entry size shift */
+#define QNX4_XBLK_ENTRY_SIZE    0x200   /* xblk entry size */
+#define QNX4_INODES_PER_BLOCK   0x08    /* 512 / 64 */
+
+/* for filenames */
+#define QNX4_SHORT_NAME_MAX     16
+#define QNX4_NAME_MAX           48
+
+/*
+ * This is the original qnx4 inode layout on disk.
+ */
+struct qnx4_inode_entry {
+        char            di_fname[QNX4_SHORT_NAME_MAX];
+        qnx4_off_t      di_size;
+        qnx4_xtnt_t     di_first_xtnt;
+        __u32           di_xblk;
+        __s32           di_ftime;
+        __s32           di_mtime;
+        __s32           di_atime;
+        __s32           di_ctime;
+        qnx4_nxtnt_t    di_num_xtnts;
+        qnx4_mode_t     di_mode;
+        qnx4_muid_t     di_uid;
+        qnx4_mgid_t     di_gid;
+        qnx4_nlink_t    di_nlink;
+        __u8            di_zero[4];
+        qnx4_ftype_t    di_type;
+        __u8            di_status;
+};
+
+struct qnx4_link_info {
+        char            dl_fname[QNX4_NAME_MAX];
+        __u32           dl_inode_blk;
+        __u8            dl_inode_ndx;
+        __u8            dl_spare[10];
+        __u8            dl_status;
+};
+
+struct qnx4_xblk {
+        __u32           xblk_next_xblk;
+        __u32           xblk_prev_xblk;
+        __u8            xblk_num_xtnts;
+        __u8            xblk_spare[3];
+        __s32           xblk_num_blocks;
+        qnx4_xtnt_t     xblk_xtnts[QNX4_MAX_XTNTS_PER_XBLK];
+        char            xblk_signature[8];
+        qnx4_xtnt_t     xblk_first_xtnt;
+};
+
+struct qnx4_super_block {
+        struct qnx4_inode_entry RootDir;
+        struct qnx4_inode_entry Inode;
+        struct qnx4_inode_entry Boot;
+        struct qnx4_inode_entry AltBoot;
+};
+
+#ifdef __KERNEL__
+
+#define QNX4_DEBUG 0
+
+#if QNX4_DEBUG
+#define QNX4DEBUG(X) printk X
+#else
+#define QNX4DEBUG(X) (void) 0
+#endif
+
+struct qnx4_sb_info {
+        struct buffer_head      *sb_buf;        /* superblock buffer */
+        struct qnx4_super_block *sb;            /* our superblock */
+        unsigned int            Version;        /* may be useful */
+        struct qnx4_inode_entry *BitMap;        /* useful */
+};
+
+struct qnx4_inode_info {
+        struct qnx4_inode_entry raw;
+        loff_t mmu_private;
+        struct inode vfs_inode;
+};
+
+extern struct dentry *qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd);
+extern unsigned long qnx4_count_free_blocks(struct super_block *sb);
+extern unsigned long qnx4_block_map(struct inode *inode, long iblock);
+
+extern struct buffer_head *qnx4_bread(struct inode *, int, int);
+
+extern struct inode_operations qnx4_file_inode_operations;
+extern struct inode_operations qnx4_dir_inode_operations;
+extern struct file_operations qnx4_file_operations;
+extern struct file_operations qnx4_dir_operations;
+extern int qnx4_is_free(struct super_block *sb, long block);
+extern int qnx4_set_bitmap(struct super_block *sb, long block, int busy);
+extern int qnx4_create(struct inode *inode, struct dentry *dentry, int mode, struct nameidata *nd);
+extern void qnx4_truncate(struct inode *inode);
+extern void qnx4_free_inode(struct inode *inode);
+extern int qnx4_unlink(struct inode *dir, struct dentry *dentry);
+extern int qnx4_rmdir(struct inode *dir, struct dentry *dentry);
+extern int qnx4_sync_file(struct file *file, struct dentry *dentry, int);
+extern int qnx4_sync_inode(struct inode *inode);
+
+static inline struct qnx4_sb_info *qnx4_sb(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct qnx4_inode_info *qnx4_i(struct inode *inode)
+{
+        return container_of(inode, struct qnx4_inode_info, vfs_inode);
+}
+
+static inline struct qnx4_inode_entry *qnx4_raw_inode(struct inode *inode)
+{
+        return &qnx4_i(inode)->raw;
+}
+
+#endif                          /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/qnxtypes.h b/include/linux/qnxtypes.h
new file mode 100644
index 000000000000..fb518e318c7c
--- /dev/null
+++ b/include/linux/qnxtypes.h
@@ -0,0 +1,29 @@
+/*
+ *  Name                         : qnxtypes.h
+ *  Author                       : Richard Frowijn
+ *  Function                     : standard qnx types
+ *  Version                      : 1.0.2
+ *  Last modified                : 2000-01-06
+ *
+ *  History                      : 22-03-1998 created
+ *
+ */
+
+#ifndef _QNX4TYPES_H
+#define _QNX4TYPES_H
+
+typedef __u16 qnx4_nxtnt_t;
+typedef __u8  qnx4_ftype_t;
+
+typedef struct {
+        __u32 xtnt_blk;
+        __u32 xtnt_size;
+} qnx4_xtnt_t;
+
+typedef __u16 qnx4_mode_t;
+typedef __u16 qnx4_muid_t;
+typedef __u16 qnx4_mgid_t;
+typedef __u32 qnx4_off_t;
+typedef __u16 qnx4_nlink_t;
+
+#endif
diff --git a/include/linux/quota.h b/include/linux/quota.h
new file mode 100644
index 000000000000..ac5b90f4f256
--- /dev/null
+++ b/include/linux/quota.h
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Robert Elz at The University of Melbourne.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Version: $Id: quota.h,v 2.0 1996/11/17 16:48:14 mvw Exp mvw $
+ */
+
+#ifndef _LINUX_QUOTA_
+#define _LINUX_QUOTA_
+
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+
+#define __DQUOT_VERSION__       "dquot_6.5.1"
+#define __DQUOT_NUM_VERSION__   6*10000+5*100+1
+
+typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
+typedef __u64 qsize_t;          /* Type in which we store sizes */
+
+extern spinlock_t dq_data_lock;
+
+/* Size of blocks in which are counted size limits */
+#define QUOTABLOCK_BITS 10
+#define QUOTABLOCK_SIZE (1 << QUOTABLOCK_BITS)
+
+/* Conversion routines from and to quota blocks */
+#define qb2kb(x) ((x) << (QUOTABLOCK_BITS-10))
+#define kb2qb(x) ((x) >> (QUOTABLOCK_BITS-10))
+#define toqb(x) (((x) + QUOTABLOCK_SIZE - 1) >> QUOTABLOCK_BITS)
+
+#define MAXQUOTAS 2
+#define USRQUOTA  0             /* element used for user quotas */
+#define GRPQUOTA  1             /* element used for group quotas */
+
+/*
+ * Definitions for the default names of the quotas files.
+ */
+#define INITQFNAMES { \
+        "user",    /* USRQUOTA */ \
+        "group",   /* GRPQUOTA */ \
+        "undefined", \
+};
+
+/*
+ * Command definitions for the 'quotactl' system call.
+ * The commands are broken into a main command defined below
+ * and a subcommand that is used to convey the type of
+ * quota that is being manipulated (see above).
+ */
+#define SUBCMDMASK  0x00ff
+#define SUBCMDSHIFT 8
+#define QCMD(cmd, type)  (((cmd) << SUBCMDSHIFT) | ((type) & SUBCMDMASK))
+
+#define Q_SYNC     0x800001     /* sync disk copy of a filesystems quotas */
+#define Q_QUOTAON  0x800002     /* turn quotas on */
+#define Q_QUOTAOFF 0x800003     /* turn quotas off */
+#define Q_GETFMT   0x800004     /* get quota format used on given filesystem */
+#define Q_GETINFO  0x800005     /* get information about quota files */
+#define Q_SETINFO  0x800006     /* set information about quota files */
+#define Q_GETQUOTA 0x800007     /* get user quota structure */
+#define Q_SETQUOTA 0x800008     /* set user quota structure */
+
+/*
+ * Quota structure used for communication with userspace via quotactl
+ * Following flags are used to specify which fields are valid
+ */
+#define QIF_BLIMITS     1
+#define QIF_SPACE       2
+#define QIF_ILIMITS     4
+#define QIF_INODES      8
+#define QIF_BTIME       16
+#define QIF_ITIME       32
+#define QIF_LIMITS      (QIF_BLIMITS | QIF_ILIMITS)
+#define QIF_USAGE       (QIF_SPACE | QIF_INODES)
+#define QIF_TIMES       (QIF_BTIME | QIF_ITIME)
+#define QIF_ALL         (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
+
+struct if_dqblk {
+        __u64 dqb_bhardlimit;
+        __u64 dqb_bsoftlimit;
+        __u64 dqb_curspace;
+        __u64 dqb_ihardlimit;
+        __u64 dqb_isoftlimit;
+        __u64 dqb_curinodes;
+        __u64 dqb_btime;
+        __u64 dqb_itime;
+        __u32 dqb_valid;
+};
+
+/*
+ * Structure used for setting quota information about file via quotactl
+ * Following flags are used to specify which fields are valid
+ */
+#define IIF_BGRACE      1
+#define IIF_IGRACE      2
+#define IIF_FLAGS       4
+#define IIF_ALL         (IIF_BGRACE | IIF_IGRACE | IIF_FLAGS)
+
+struct if_dqinfo {
+        __u64 dqi_bgrace;
+        __u64 dqi_igrace;
+        __u32 dqi_flags;
+        __u32 dqi_valid;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/dqblk_xfs.h>
+#include <linux/dqblk_v1.h>
+#include <linux/dqblk_v2.h>
+
+/* Maximal numbers of writes for quota operation (insert/delete/update)
+ * (over all formats) - info block, 4 pointer blocks, data block */
+#define DQUOT_MAX_WRITES        6
+
+/*
+ * Data for one user/group kept in memory
+ */
+struct mem_dqblk {
+        __u32 dqb_bhardlimit;   /* absolute limit on disk blks alloc */
+        __u32 dqb_bsoftlimit;   /* preferred limit on disk blks */
+        qsize_t dqb_curspace;   /* current used space */
+        __u32 dqb_ihardlimit;   /* absolute limit on allocated inodes */
+        __u32 dqb_isoftlimit;   /* preferred inode limit */
+        __u32 dqb_curinodes;    /* current # allocated inodes */
+        time_t dqb_btime;       /* time limit for excessive disk use */
+        time_t dqb_itime;       /* time limit for excessive inode use */
+};
+
+/*
+ * Data for one quotafile kept in memory
+ */
+struct quota_format_type;
+
+struct mem_dqinfo {
+        struct quota_format_type *dqi_format;
+        struct list_head dqi_dirty_list;        /* List of dirty dquots */
+        unsigned long dqi_flags;
+        unsigned int dqi_bgrace;
+        unsigned int dqi_igrace;
+        union {
+                struct v1_mem_dqinfo v1_i;
+                struct v2_mem_dqinfo v2_i;
+        } u;
+};
+
+struct super_block;
+
+#define DQF_MASK 0xffff         /* Mask for format specific flags */
+#define DQF_INFO_DIRTY_B 16
+#define DQF_INFO_DIRTY (1 << DQF_INFO_DIRTY_B)  /* Is info dirty? */
+
+extern void mark_info_dirty(struct super_block *sb, int type);
+#define info_dirty(info) test_bit(DQF_INFO_DIRTY_B, &(info)->dqi_flags)
+#define info_any_dquot_dirty(info) (!list_empty(&(info)->dqi_dirty_list))
+#define info_any_dirty(info) (info_dirty(info) || info_any_dquot_dirty(info))
+
+#define sb_dqopt(sb) (&(sb)->s_dquot)
+#define sb_dqinfo(sb, type) (sb_dqopt(sb)->info+(type))
+
+struct dqstats {
+        int lookups;
+        int drops;
+        int reads;
+        int writes;
+        int cache_hits;
+        int allocated_dquots;
+        int free_dquots;
+        int syncs;
+};
+
+extern struct dqstats dqstats;
+
+#define DQ_MOD_B        0       /* dquot modified since read */
+#define DQ_BLKS_B       1       /* uid/gid has been warned about blk limit */
+#define DQ_INODES_B     2       /* uid/gid has been warned about inode limit */
+#define DQ_FAKE_B       3       /* no limits only usage */
+#define DQ_READ_B       4       /* dquot was read into memory */
+#define DQ_ACTIVE_B     5       /* dquot is active (dquot_release not called) */
+#define DQ_WAITFREE_B   6       /* dquot being waited (by invalidate_dquots) */
+
+struct dquot {
+        struct hlist_node dq_hash;      /* Hash list in memory */
+        struct list_head dq_inuse;      /* List of all quotas */
+        struct list_head dq_free;       /* Free list element */
+        struct list_head dq_dirty;      /* List of dirty dquots */
+        struct semaphore dq_lock;       /* dquot IO lock */
+        atomic_t dq_count;              /* Use count */
+        wait_queue_head_t dq_wait_unused;       /* Wait queue for dquot to become unused */
+        struct super_block *dq_sb;      /* superblock this applies to */
+        unsigned int dq_id;             /* ID this applies to (uid, gid) */
+        loff_t dq_off;                  /* Offset of dquot on disk */
+        unsigned long dq_flags;         /* See DQ_* */
+        short dq_type;                  /* Type of quota */
+        struct mem_dqblk dq_dqb;        /* Diskquota usage */
+};
+
+#define NODQUOT (struct dquot *)NULL
+
+#define QUOTA_OK          0
+#define NO_QUOTA          1
+
+/* Operations which must be implemented by each quota format */
+struct quota_format_ops {
+        int (*check_quota_file)(struct super_block *sb, int type);      /* Detect whether file is in our format */
+        int (*read_file_info)(struct super_block *sb, int type);        /* Read main info about file - called on quotaon() */
+        int (*write_file_info)(struct super_block *sb, int type);       /* Write main info about file */
+        int (*free_file_info)(struct super_block *sb, int type);        /* Called on quotaoff() */
+        int (*read_dqblk)(struct dquot *dquot);         /* Read structure for one user */
+        int (*commit_dqblk)(struct dquot *dquot);       /* Write structure for one user */
+        int (*release_dqblk)(struct dquot *dquot);      /* Called when last reference to dquot is being dropped */
+};
+
+/* Operations working with dquots */
+struct dquot_operations {
+        int (*initialize) (struct inode *, int);
+        int (*drop) (struct inode *);
+        int (*alloc_space) (struct inode *, qsize_t, int);
+        int (*alloc_inode) (const struct inode *, unsigned long);
+        int (*free_space) (struct inode *, qsize_t);
+        int (*free_inode) (const struct inode *, unsigned long);
+        int (*transfer) (struct inode *, struct iattr *);
+        int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
+        int (*acquire_dquot) (struct dquot *);          /* Quota is going to be created on disk */
+        int (*release_dquot) (struct dquot *);          /* Quota is going to be deleted from disk */
+        int (*mark_dirty) (struct dquot *);             /* Dquot is marked dirty */
+        int (*write_info) (struct super_block *, int);  /* Write of quota "superblock" */
+};
+
+/* Operations handling requests from userspace */
+struct quotactl_ops {
+        int (*quota_on)(struct super_block *, int, int, char *);
+        int (*quota_off)(struct super_block *, int);
+        int (*quota_sync)(struct super_block *, int);
+        int (*get_info)(struct super_block *, int, struct if_dqinfo *);
+        int (*set_info)(struct super_block *, int, struct if_dqinfo *);
+        int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
+        int (*set_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
+        int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
+        int (*set_xstate)(struct super_block *, unsigned int, int);
+        int (*get_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
+        int (*set_xquota)(struct super_block *, int, qid_t, struct fs_disk_quota *);
+};
+
+struct quota_format_type {
+        int qf_fmt_id;  /* Quota format id */
+        struct quota_format_ops *qf_ops;        /* Operations of format */
+        struct module *qf_owner;                /* Module implementing quota format */
+        struct quota_format_type *qf_next;
+};
+
+#define DQUOT_USR_ENABLED       0x01            /* User diskquotas enabled */
+#define DQUOT_GRP_ENABLED       0x02            /* Group diskquotas enabled */
+
+struct quota_info {
+        unsigned int flags;                     /* Flags for diskquotas on this device */
+        struct semaphore dqio_sem;              /* lock device while I/O in progress */
+        struct semaphore dqonoff_sem;           /* Serialize quotaon & quotaoff */
+        struct rw_semaphore dqptr_sem;          /* serialize ops using quota_info struct, pointers from inode to dquots */
+        struct inode *files[MAXQUOTAS];         /* inodes of quotafiles */
+        struct vfsmount *mnt[MAXQUOTAS];        /* mountpoint entries of filesystems with quota files */
+        struct mem_dqinfo info[MAXQUOTAS];      /* Information for each quota type */
+        struct quota_format_ops *ops[MAXQUOTAS];        /* Operations for each type */
+};
+
+/* Inline would be better but we need to dereference super_block which is not defined yet */
+int mark_dquot_dirty(struct dquot *dquot);
+
+#define dquot_dirty(dquot) test_bit(DQ_MOD_B, &(dquot)->dq_flags)
+
+#define sb_has_quota_enabled(sb, type) ((type)==USRQUOTA ? \
+        (sb_dqopt(sb)->flags & DQUOT_USR_ENABLED) : (sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED))
+
+#define sb_any_quota_enabled(sb) (sb_has_quota_enabled(sb, USRQUOTA) | \
+                                  sb_has_quota_enabled(sb, GRPQUOTA))
+
+int register_quota_format(struct quota_format_type *fmt);
+void unregister_quota_format(struct quota_format_type *fmt);
+
+struct quota_module_name {
+        int qm_fmt_id;
+        char *qm_mod_name;
+};
+
+#define INIT_QUOTA_MODULE_NAMES {\
+        {QFMT_VFS_OLD, "quota_v1"},\
+        {QFMT_VFS_V0, "quota_v2"},\
+        {0, NULL}}
+
+#else
+
+# /* nodep */ include <sys/cdefs.h>
+
+__BEGIN_DECLS
+long quotactl __P ((unsigned int, const char *, int, caddr_t));
+__END_DECLS
+
+#endif /* __KERNEL__ */
+#endif /* _QUOTA_ */
diff --git a/include/linux/quotaio_v1.h b/include/linux/quotaio_v1.h
new file mode 100644
index 000000000000..746654b5de70
--- /dev/null
+++ b/include/linux/quotaio_v1.h
@@ -0,0 +1,33 @@
+#ifndef _LINUX_QUOTAIO_V1_H
+#define _LINUX_QUOTAIO_V1_H
+
+#include <linux/types.h>
+
+/*
+ * The following constants define the amount of time given a user
+ * before the soft limits are treated as hard limits (usually resulting
+ * in an allocation failure). The timer is started when the user crosses
+ * their soft limit, it is reset when they go below their soft limit.
+ */
+#define MAX_IQ_TIME  604800     /* (7*24*60*60) 1 week */
+#define MAX_DQ_TIME  604800     /* (7*24*60*60) 1 week */
+
+/*
+ * The following structure defines the format of the disk quota file
+ * (as it appears on disk) - the file is an array of these structures
+ * indexed by user or group number.
+ */
+struct v1_disk_dqblk {
+        __u32 dqb_bhardlimit;   /* absolute limit on disk blks alloc */
+        __u32 dqb_bsoftlimit;   /* preferred limit on disk blks */
+        __u32 dqb_curblocks;    /* current block count */
+        __u32 dqb_ihardlimit;   /* absolute limit on allocated inodes */
+        __u32 dqb_isoftlimit;   /* preferred inode limit */
+        __u32 dqb_curinodes;    /* current # allocated inodes */
+        time_t dqb_btime;       /* time limit for excessive disk use */
+        time_t dqb_itime;       /* time limit for excessive inode use */
+};
+
+#define v1_dqoff(UID)      ((loff_t)((UID) * sizeof (struct v1_disk_dqblk)))
+
+#endif  /* _LINUX_QUOTAIO_V1_H */
diff --git a/include/linux/quotaio_v2.h b/include/linux/quotaio_v2.h
new file mode 100644
index 000000000000..303d7cbe30d4
--- /dev/null
+++ b/include/linux/quotaio_v2.h
@@ -0,0 +1,79 @@
+/*
+ *      Definitions of structures for vfsv0 quota format
+ */
+
+#ifndef _LINUX_QUOTAIO_V2_H
+#define _LINUX_QUOTAIO_V2_H
+
+#include <linux/types.h>
+#include <linux/quota.h>
+
+/*
+ * Definitions of magics and versions of current quota files
+ */
+#define V2_INITQMAGICS {\
+        0xd9c01f11,     /* USRQUOTA */\
+        0xd9c01927      /* GRPQUOTA */\
+}
+
+#define V2_INITQVERSIONS {\
+        0,              /* USRQUOTA */\
+        0               /* GRPQUOTA */\
+}
+
+/*
+ * The following structure defines the format of the disk quota file
+ * (as it appears on disk) - the file is a radix tree whose leaves point
+ * to blocks of these structures.
+ */
+struct v2_disk_dqblk {
+        __le32 dqb_id;          /* id this quota applies to */
+        __le32 dqb_ihardlimit;  /* absolute limit on allocated inodes */
+        __le32 dqb_isoftlimit;  /* preferred inode limit */
+        __le32 dqb_curinodes;   /* current # allocated inodes */
+        __le32 dqb_bhardlimit;  /* absolute limit on disk space (in QUOTABLOCK_SIZE) */
+        __le32 dqb_bsoftlimit;  /* preferred limit on disk space (in QUOTABLOCK_SIZE) */
+        __le64 dqb_curspace;    /* current space occupied (in bytes) */
+        __le64 dqb_btime;       /* time limit for excessive disk use */
+        __le64 dqb_itime;       /* time limit for excessive inode use */
+};
+
+/*
+ * Here are header structures as written on disk and their in-memory copies
+ */
+/* First generic header */
+struct v2_disk_dqheader {
+        __le32 dqh_magic;       /* Magic number identifying file */
+        __le32 dqh_version;     /* File version */
+};
+
+/* Header with type and version specific information */
+struct v2_disk_dqinfo {
+        __le32 dqi_bgrace;      /* Time before block soft limit becomes hard limit */
+        __le32 dqi_igrace;      /* Time before inode soft limit becomes hard limit */
+        __le32 dqi_flags;       /* Flags for quotafile (DQF_*) */
+        __le32 dqi_blocks;      /* Number of blocks in file */
+        __le32 dqi_free_blk;    /* Number of first free block in the list */
+        __le32 dqi_free_entry;  /* Number of block with at least one free entry */
+};
+
+/*
+ *  Structure of header of block with quota structures. It is padded to 16 bytes so
+ *  there will be space for exactly 21 quota-entries in a block
+ */
+struct v2_disk_dqdbheader {
+        __le32 dqdh_next_free;  /* Number of next block with free entry */
+        __le32 dqdh_prev_free;  /* Number of previous block with free entry */
+        __le16 dqdh_entries;    /* Number of valid entries in block */
+        __le16 dqdh_pad1;
+        __le32 dqdh_pad2;
+};
+
+#define V2_DQINFOOFF    sizeof(struct v2_disk_dqheader) /* Offset of info header in file */
+#define V2_DQBLKSIZE_BITS       10
+#define V2_DQBLKSIZE    (1 << V2_DQBLKSIZE_BITS)        /* Size of block with quota structures */
+#define V2_DQTREEOFF    1               /* Offset of tree in file in blocks */
+#define V2_DQTREEDEPTH  4               /* Depth of quota tree */
+#define V2_DQSTRINBLK   ((V2_DQBLKSIZE - sizeof(struct v2_disk_dqdbheader)) / sizeof(struct v2_disk_dqblk))     /* Number of entries in one blocks */
+
+#endif /* _LINUX_QUOTAIO_V2_H */
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
new file mode 100644
index 000000000000..e57baa85e744
--- /dev/null
+++ b/include/linux/quotaops.h
@@ -0,0 +1,246 @@
+/*
+ * Definitions for diskquota-operations. When diskquota is configured these
+ * macros expand to the right source-code.
+ *
+ * Author:  Marco van Wieringen <mvw@planets.elm.net>
+ *
+ * Version: $Id: quotaops.h,v 1.2 1998/01/15 16:22:26 ecd Exp $
+ *
+ */
+#ifndef _LINUX_QUOTAOPS_
+#define _LINUX_QUOTAOPS_
+
+#include <linux/config.h>
+#include <linux/smp_lock.h>
+
+#include <linux/fs.h>
+
+#if defined(CONFIG_QUOTA)
+
+/*
+ * declaration of quota_function calls in kernel.
+ */
+extern void sync_dquots(struct super_block *sb, int type);
+
+extern int dquot_initialize(struct inode *inode, int type);
+extern int dquot_drop(struct inode *inode);
+
+extern int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
+extern int dquot_alloc_inode(const struct inode *inode, unsigned long number);
+
+extern int dquot_free_space(struct inode *inode, qsize_t number);
+extern int dquot_free_inode(const struct inode *inode, unsigned long number);
+
+extern int dquot_transfer(struct inode *inode, struct iattr *iattr);
+extern int dquot_commit(struct dquot *dquot);
+extern int dquot_acquire(struct dquot *dquot);
+extern int dquot_release(struct dquot *dquot);
+extern int dquot_commit_info(struct super_block *sb, int type);
+extern int dquot_mark_dquot_dirty(struct dquot *dquot);
+
+extern int vfs_quota_on(struct super_block *sb, int type, int format_id, char *path);
+extern int vfs_quota_on_mount(int type, int format_id, struct dentry *dentry);
+extern int vfs_quota_off(struct super_block *sb, int type);
+#define vfs_quota_off_mount(sb, type) vfs_quota_off(sb, type)
+extern int vfs_quota_sync(struct super_block *sb, int type);
+extern int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
+extern int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
+extern int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
+extern int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
+
+/*
+ * Operations supported for diskquotas.
+ */
+extern struct dquot_operations dquot_operations;
+extern struct quotactl_ops vfs_quotactl_ops;
+
+#define sb_dquot_ops (&dquot_operations)
+#define sb_quotactl_ops (&vfs_quotactl_ops)
+
+/* It is better to call this function outside of any transaction as it might
+ * need a lot of space in journal for dquot structure allocation. */
+static __inline__ void DQUOT_INIT(struct inode *inode)
+{
+        BUG_ON(!inode->i_sb);
+        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
+                inode->i_sb->dq_op->initialize(inode, -1);
+}
+
+/* The same as with DQUOT_INIT */
+static __inline__ void DQUOT_DROP(struct inode *inode)
+{
+        /* Here we can get arbitrary inode from clear_inode() so we have
+         * to be careful. OTOH we don't need locking as quota operations
+         * are allowed to change only at mount time */
+        if (!IS_NOQUOTA(inode) && inode->i_sb && inode->i_sb->dq_op
+            && inode->i_sb->dq_op->drop) {
+                int cnt;
+                /* Test before calling to rule out calls from proc and such
+                 * where we are not allowed to block. Note that this is
+                 * actually reliable test even without the lock - the caller
+                 * must assure that nobody can come after the DQUOT_DROP and
+                 * add quota pointers back anyway */
+                for (cnt = 0; cnt < MAXQUOTAS; cnt++)
+                        if (inode->i_dquot[cnt] != NODQUOT)
+                                break;
+                if (cnt < MAXQUOTAS)
+                        inode->i_sb->dq_op->drop(inode);
+        }
+}
+
+/* The following allocation/freeing/transfer functions *must* be called inside
+ * a transaction (deadlocks possible otherwise) */
+static __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        if (sb_any_quota_enabled(inode->i_sb)) {
+                /* Used space is updated in alloc_space() */
+                if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
+                        return 1;
+        }
+        else
+                inode_add_bytes(inode, nr);
+        return 0;
+}
+
+static __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
+{
+        int ret;
+        if (!(ret =  DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr)))
+                mark_inode_dirty(inode);
+        return ret;
+}
+
+static __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        if (sb_any_quota_enabled(inode->i_sb)) {
+                /* Used space is updated in alloc_space() */
+                if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
+                        return 1;
+        }
+        else
+                inode_add_bytes(inode, nr);
+        return 0;
+}
+
+static __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
+{
+        int ret;
+        if (!(ret = DQUOT_ALLOC_SPACE_NODIRTY(inode, nr)))
+                mark_inode_dirty(inode);
+        return ret;
+}
+
+static __inline__ int DQUOT_ALLOC_INODE(struct inode *inode)
+{
+        if (sb_any_quota_enabled(inode->i_sb)) {
+                DQUOT_INIT(inode);
+                if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
+                        return 1;
+        }
+        return 0;
+}
+
+static __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        if (sb_any_quota_enabled(inode->i_sb))
+                inode->i_sb->dq_op->free_space(inode, nr);
+        else
+                inode_sub_bytes(inode, nr);
+}
+
+static __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
+{
+        DQUOT_FREE_SPACE_NODIRTY(inode, nr);
+        mark_inode_dirty(inode);
+}
+
+static __inline__ void DQUOT_FREE_INODE(struct inode *inode)
+{
+        if (sb_any_quota_enabled(inode->i_sb))
+                inode->i_sb->dq_op->free_inode(inode, 1);
+}
+
+static __inline__ int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
+{
+        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode)) {
+                DQUOT_INIT(inode);
+                if (inode->i_sb->dq_op->transfer(inode, iattr) == NO_QUOTA)
+                        return 1;
+        }
+        return 0;
+}
+
+/* The following two functions cannot be called inside a transaction */
+#define DQUOT_SYNC(sb)  sync_dquots(sb, -1)
+
+static __inline__ int DQUOT_OFF(struct super_block *sb)
+{
+        int ret = -ENOSYS;
+
+        if (sb_any_quota_enabled(sb) && sb->s_qcop && sb->s_qcop->quota_off)
+                ret = sb->s_qcop->quota_off(sb, -1);
+        return ret;
+}
+
+#else
+
+/*
+ * NO-OP when quota not configured.
+ */
+#define sb_dquot_ops                            (NULL)
+#define sb_quotactl_ops                         (NULL)
+#define sync_dquots_dev(dev,type)               (NULL)
+#define DQUOT_INIT(inode)                       do { } while(0)
+#define DQUOT_DROP(inode)                       do { } while(0)
+#define DQUOT_ALLOC_INODE(inode)                (0)
+#define DQUOT_FREE_INODE(inode)                 do { } while(0)
+#define DQUOT_SYNC(sb)                          do { } while(0)
+#define DQUOT_OFF(sb)                           do { } while(0)
+#define DQUOT_TRANSFER(inode, iattr)            (0)
+extern __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        inode_add_bytes(inode, nr);
+        return 0;
+}
+
+extern __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
+{
+        DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr);
+        mark_inode_dirty(inode);
+        return 0;
+}
+
+extern __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        inode_add_bytes(inode, nr);
+        return 0;
+}
+
+extern __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
+{
+        DQUOT_ALLOC_SPACE_NODIRTY(inode, nr);
+        mark_inode_dirty(inode);
+        return 0;
+}
+
+extern __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        inode_sub_bytes(inode, nr);
+}
+
+extern __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
+{
+        DQUOT_FREE_SPACE_NODIRTY(inode, nr);
+        mark_inode_dirty(inode);
+}       
+
+#endif /* CONFIG_QUOTA */
+
+#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) DQUOT_PREALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+#define DQUOT_PREALLOC_BLOCK(inode, nr) DQUOT_PREALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) DQUOT_ALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+#define DQUOT_ALLOC_BLOCK(inode, nr) DQUOT_ALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) DQUOT_FREE_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+#define DQUOT_FREE_BLOCK(inode, nr) DQUOT_FREE_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+
+#endif /* _LINUX_QUOTAOPS_ */
diff --git a/include/linux/radeonfb.h b/include/linux/radeonfb.h
new file mode 100644
index 000000000000..5bd8975ed78e
--- /dev/null
+++ b/include/linux/radeonfb.h
@@ -0,0 +1,15 @@
+#ifndef __LINUX_RADEONFB_H__
+#define __LINUX_RADEONFB_H__
+
+#include <asm/ioctl.h>
+#include <asm/types.h>
+
+#define ATY_RADEON_LCD_ON       0x00000001
+#define ATY_RADEON_CRT_ON       0x00000002
+
+
+#define FBIO_RADEON_GET_MIRROR  _IOR('@', 3, size_t)
+#define FBIO_RADEON_SET_MIRROR  _IOW('@', 4, size_t)
+
+#endif
+
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
new file mode 100644
index 000000000000..8081a281fa5e
--- /dev/null
+++ b/include/linux/radix-tree.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2001 Momchil Velikov
+ * Portions Copyright (C) 2001 Christoph Hellwig
+ *
+ * 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; either version 2, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef _LINUX_RADIX_TREE_H
+#define _LINUX_RADIX_TREE_H
+
+#include <linux/preempt.h>
+#include <linux/types.h>
+
+struct radix_tree_root {
+        unsigned int            height;
+        int                     gfp_mask;
+        struct radix_tree_node  *rnode;
+};
+
+#define RADIX_TREE_INIT(mask)   {                                       \
+        .height = 0,                                                    \
+        .gfp_mask = (mask),                                             \
+        .rnode = NULL,                                                  \
+}
+
+#define RADIX_TREE(name, mask) \
+        struct radix_tree_root name = RADIX_TREE_INIT(mask)
+
+#define INIT_RADIX_TREE(root, mask)                                     \
+do {                                                                    \
+        (root)->height = 0;                                             \
+        (root)->gfp_mask = (mask);                                      \
+        (root)->rnode = NULL;                                           \
+} while (0)
+
+int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
+void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
+void *radix_tree_delete(struct radix_tree_root *, unsigned long);
+unsigned int
+radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
+                        unsigned long first_index, unsigned int max_items);
+int radix_tree_preload(int gfp_mask);
+void radix_tree_init(void);
+void *radix_tree_tag_set(struct radix_tree_root *root,
+                        unsigned long index, int tag);
+void *radix_tree_tag_clear(struct radix_tree_root *root,
+                        unsigned long index, int tag);
+int radix_tree_tag_get(struct radix_tree_root *root,
+                        unsigned long index, int tag);
+unsigned int
+radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
+                unsigned long first_index, unsigned int max_items, int tag);
+int radix_tree_tagged(struct radix_tree_root *root, int tag);
+
+static inline void radix_tree_preload_end(void)
+{
+        preempt_enable();
+}
+
+#endif /* _LINUX_RADIX_TREE_H */
diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h
new file mode 100644
index 000000000000..e04c4fe45b53
--- /dev/null
+++ b/include/linux/raid/linear.h
@@ -0,0 +1,27 @@
+#ifndef _LINEAR_H
+#define _LINEAR_H
+
+#include <linux/raid/md.h>
+
+struct dev_info {
+        mdk_rdev_t      *rdev;
+        sector_t        size;
+        sector_t        offset;
+};
+
+typedef struct dev_info dev_info_t;
+
+struct linear_private_data
+{
+        dev_info_t              **hash_table;
+        dev_info_t              *smallest;
+        int                     nr_zones;
+        dev_info_t              disks[0];
+};
+
+
+typedef struct linear_private_data linear_conf_t;
+
+#define mddev_to_conf(mddev) ((linear_conf_t *) mddev->private)
+
+#endif
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
new file mode 100644
index 000000000000..a6a67d102bfa
--- /dev/null
+++ b/include/linux/raid/md.h
@@ -0,0 +1,84 @@
+/*
+   md.h : Multiple Devices driver for Linux
+          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
+          Copyright (C) 1994-96 Marc ZYNGIER
+          <zyngier@ufr-info-p7.ibp.fr> or
+          <maz@gloups.fdn.fr>
+          
+   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; either version 2, or (at your option)
+   any later version.
+   
+   You should have received a copy of the GNU General Public License
+   (for example /usr/src/linux/COPYING); if not, write to the Free
+   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+*/
+
+#ifndef _MD_H
+#define _MD_H
+
+#include <linux/blkdev.h>
+#include <asm/semaphore.h>
+#include <linux/major.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <linux/bitops.h>
+#include <linux/module.h>
+#include <linux/hdreg.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/smp_lock.h>
+#include <linux/delay.h>
+#include <net/checksum.h>
+#include <linux/random.h>
+#include <linux/kernel_stat.h>
+#include <asm/io.h>
+#include <linux/completion.h>
+#include <linux/mempool.h>
+#include <linux/list.h>
+#include <linux/reboot.h>
+#include <linux/vmalloc.h>
+#include <linux/blkpg.h>
+#include <linux/bio.h>
+
+/*
+ * 'md_p.h' holds the 'physical' layout of RAID devices
+ * 'md_u.h' holds the user <=> kernel API
+ *
+ * 'md_k.h' holds kernel internal definitions
+ */
+
+#include <linux/raid/md_p.h>
+#include <linux/raid/md_u.h>
+#include <linux/raid/md_k.h>
+
+/*
+ * Different major versions are not compatible.
+ * Different minor versions are only downward compatible.
+ * Different patchlevel versions are downward and upward compatible.
+ */
+#define MD_MAJOR_VERSION                0
+#define MD_MINOR_VERSION                90
+#define MD_PATCHLEVEL_VERSION           1
+
+extern int register_md_personality (int p_num, mdk_personality_t *p);
+extern int unregister_md_personality (int p_num);
+extern mdk_thread_t * md_register_thread (void (*run) (mddev_t *mddev),
+                                mddev_t *mddev, const char *name);
+extern void md_unregister_thread (mdk_thread_t *thread);
+extern void md_wakeup_thread(mdk_thread_t *thread);
+extern void md_check_recovery(mddev_t *mddev);
+extern void md_write_start(mddev_t *mddev);
+extern void md_write_end(mddev_t *mddev);
+extern void md_handle_safemode(mddev_t *mddev);
+extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
+extern void md_error (mddev_t *mddev, mdk_rdev_t *rdev);
+extern void md_unplug_mddev(mddev_t *mddev);
+
+extern void md_print_devices (void);
+
+#define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
+
+#endif 
+
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
new file mode 100644
index 000000000000..c9a0d4013be7
--- /dev/null
+++ b/include/linux/raid/md_k.h
@@ -0,0 +1,369 @@
+/*
+   md_k.h : kernel internal structure of the Linux MD driver
+          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
+          
+   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; either version 2, or (at your option)
+   any later version.
+   
+   You should have received a copy of the GNU General Public License
+   (for example /usr/src/linux/COPYING); if not, write to the Free
+   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+*/
+
+#ifndef _MD_K_H
+#define _MD_K_H
+
+#define MD_RESERVED       0UL
+#define LINEAR            1UL
+#define RAID0             2UL
+#define RAID1             3UL
+#define RAID5             4UL
+#define TRANSLUCENT       5UL
+#define HSM               6UL
+#define MULTIPATH         7UL
+#define RAID6             8UL
+#define RAID10            9UL
+#define FAULTY            10UL
+#define MAX_PERSONALITY   11UL
+
+#define LEVEL_MULTIPATH         (-4)
+#define LEVEL_LINEAR            (-1)
+#define LEVEL_FAULTY            (-5)
+
+#define MaxSector (~(sector_t)0)
+#define MD_THREAD_NAME_MAX 14
+
+static inline int pers_to_level (int pers)
+{
+        switch (pers) {
+                case FAULTY:            return LEVEL_FAULTY;
+                case MULTIPATH:         return LEVEL_MULTIPATH;
+                case HSM:               return -3;
+                case TRANSLUCENT:       return -2;
+                case LINEAR:            return LEVEL_LINEAR;
+                case RAID0:             return 0;
+                case RAID1:             return 1;
+                case RAID5:             return 5;
+                case RAID6:             return 6;
+                case RAID10:            return 10;
+        }
+        BUG();
+        return MD_RESERVED;
+}
+
+static inline int level_to_pers (int level)
+{
+        switch (level) {
+                case LEVEL_FAULTY: return FAULTY;
+                case LEVEL_MULTIPATH: return MULTIPATH;
+                case -3: return HSM;
+                case -2: return TRANSLUCENT;
+                case LEVEL_LINEAR: return LINEAR;
+                case 0: return RAID0;
+                case 1: return RAID1;
+                case 4:
+                case 5: return RAID5;
+                case 6: return RAID6;
+                case 10: return RAID10;
+        }
+        return MD_RESERVED;
+}
+
+typedef struct mddev_s mddev_t;
+typedef struct mdk_rdev_s mdk_rdev_t;
+
+#define MAX_MD_DEVS  256        /* Max number of md dev */
+
+/*
+ * options passed in raidrun:
+ */
+
+#define MAX_CHUNK_SIZE (4096*1024)
+
+/*
+ * default readahead
+ */
+
+static inline int disk_faulty(mdp_disk_t * d)
+{
+        return d->state & (1 << MD_DISK_FAULTY);
+}
+
+static inline int disk_active(mdp_disk_t * d)
+{
+        return d->state & (1 << MD_DISK_ACTIVE);
+}
+
+static inline int disk_sync(mdp_disk_t * d)
+{
+        return d->state & (1 << MD_DISK_SYNC);
+}
+
+static inline int disk_spare(mdp_disk_t * d)
+{
+        return !disk_sync(d) && !disk_active(d) && !disk_faulty(d);
+}
+
+static inline int disk_removed(mdp_disk_t * d)
+{
+        return d->state & (1 << MD_DISK_REMOVED);
+}
+
+static inline void mark_disk_faulty(mdp_disk_t * d)
+{
+        d->state |= (1 << MD_DISK_FAULTY);
+}
+
+static inline void mark_disk_active(mdp_disk_t * d)
+{
+        d->state |= (1 << MD_DISK_ACTIVE);
+}
+
+static inline void mark_disk_sync(mdp_disk_t * d)
+{
+        d->state |= (1 << MD_DISK_SYNC);
+}
+
+static inline void mark_disk_spare(mdp_disk_t * d)
+{
+        d->state = 0;
+}
+
+static inline void mark_disk_removed(mdp_disk_t * d)
+{
+        d->state = (1 << MD_DISK_FAULTY) | (1 << MD_DISK_REMOVED);
+}
+
+static inline void mark_disk_inactive(mdp_disk_t * d)
+{
+        d->state &= ~(1 << MD_DISK_ACTIVE);
+}
+
+static inline void mark_disk_nonsync(mdp_disk_t * d)
+{
+        d->state &= ~(1 << MD_DISK_SYNC);
+}
+
+/*
+ * MD's 'extended' device
+ */
+struct mdk_rdev_s
+{
+        struct list_head same_set;      /* RAID devices within the same set */
+
+        sector_t size;                  /* Device size (in blocks) */
+        mddev_t *mddev;                 /* RAID array if running */
+        unsigned long last_events;      /* IO event timestamp */
+
+        struct block_device *bdev;      /* block device handle */
+
+        struct page     *sb_page;
+        int             sb_loaded;
+        sector_t        data_offset;    /* start of data in array */
+        sector_t        sb_offset;
+        int             preferred_minor;        /* autorun support */
+
+        /* A device can be in one of three states based on two flags:
+         * Not working:   faulty==1 in_sync==0
+         * Fully working: faulty==0 in_sync==1
+         * Working, but not
+         * in sync with array
+         *                faulty==0 in_sync==0
+         *
+         * It can never have faulty==1, in_sync==1
+         * This reduces the burden of testing multiple flags in many cases
+         */
+        int faulty;                     /* if faulty do not issue IO requests */
+        int in_sync;                    /* device is a full member of the array */
+
+        int desc_nr;                    /* descriptor index in the superblock */
+        int raid_disk;                  /* role of device in array */
+
+        atomic_t        nr_pending;     /* number of pending requests.
+                                         * only maintained for arrays that
+                                         * support hot removal
+                                         */
+};
+
+typedef struct mdk_personality_s mdk_personality_t;
+
+struct mddev_s
+{
+        void                            *private;
+        mdk_personality_t               *pers;
+        dev_t                           unit;
+        int                             md_minor;
+        struct list_head                disks;
+        int                             sb_dirty;
+        int                             ro;
+
+        struct gendisk                  *gendisk;
+
+        /* Superblock information */
+        int                             major_version,
+                                        minor_version,
+                                        patch_version;
+        int                             persistent;
+        int                             chunk_size;
+        time_t                          ctime, utime;
+        int                             level, layout;
+        int                             raid_disks;
+        int                             max_disks;
+        sector_t                        size; /* used size of component devices */
+        sector_t                        array_size; /* exported array size */
+        __u64                           events;
+
+        char                            uuid[16];
+
+        struct mdk_thread_s             *thread;        /* management thread */
+        struct mdk_thread_s             *sync_thread;   /* doing resync or reconstruct */
+        sector_t                        curr_resync;    /* blocks scheduled */
+        unsigned long                   resync_mark;    /* a recent timestamp */
+        sector_t                        resync_mark_cnt;/* blocks written at resync_mark */
+
+        sector_t                        resync_max_sectors; /* may be set by personality */
+        /* recovery/resync flags 
+         * NEEDED:   we might need to start a resync/recover
+         * RUNNING:  a thread is running, or about to be started
+         * SYNC:     actually doing a resync, not a recovery
+         * ERR:      and IO error was detected - abort the resync/recovery
+         * INTR:     someone requested a (clean) early abort.
+         * DONE:     thread is done and is waiting to be reaped
+         */
+#define MD_RECOVERY_RUNNING     0
+#define MD_RECOVERY_SYNC        1
+#define MD_RECOVERY_ERR         2
+#define MD_RECOVERY_INTR        3
+#define MD_RECOVERY_DONE        4
+#define MD_RECOVERY_NEEDED      5
+        unsigned long                   recovery;
+
+        int                             in_sync;        /* know to not need resync */
+        struct semaphore                reconfig_sem;
+        atomic_t                        active;
+
+        int                             changed;        /* true if we might need to reread partition info */
+        int                             degraded;       /* whether md should consider
+                                                         * adding a spare
+                                                         */
+
+        atomic_t                        recovery_active; /* blocks scheduled, but not written */
+        wait_queue_head_t               recovery_wait;
+        sector_t                        recovery_cp;
+        unsigned int                    safemode;       /* if set, update "clean" superblock
+                                                         * when no writes pending.
+                                                         */ 
+        unsigned int                    safemode_delay;
+        struct timer_list               safemode_timer;
+        atomic_t                        writes_pending; 
+        request_queue_t                 *queue; /* for plugging ... */
+
+        struct list_head                all_mddevs;
+};
+
+
+static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
+{
+        int faulty = rdev->faulty;
+        if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
+                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+}
+
+static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
+{
+        atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
+}
+
+struct mdk_personality_s
+{
+        char *name;
+        struct module *owner;
+        int (*make_request)(request_queue_t *q, struct bio *bio);
+        int (*run)(mddev_t *mddev);
+        int (*stop)(mddev_t *mddev);
+        void (*status)(struct seq_file *seq, mddev_t *mddev);
+        /* error_handler must set ->faulty and clear ->in_sync
+         * if appropriate, and should abort recovery if needed 
+         */
+        void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
+        int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
+        int (*hot_remove_disk) (mddev_t *mddev, int number);
+        int (*spare_active) (mddev_t *mddev);
+        int (*sync_request)(mddev_t *mddev, sector_t sector_nr, int go_faster);
+        int (*resize) (mddev_t *mddev, sector_t sectors);
+        int (*reshape) (mddev_t *mddev, int raid_disks);
+        int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
+};
+
+
+static inline char * mdname (mddev_t * mddev)
+{
+        return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
+}
+
+extern mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr);
+
+/*
+ * iterates through some rdev ringlist. It's safe to remove the
+ * current 'rdev'. Dont touch 'tmp' though.
+ */
+#define ITERATE_RDEV_GENERIC(head,rdev,tmp)                             \
+                                                                        \
+        for ((tmp) = (head).next;                                       \
+                (rdev) = (list_entry((tmp), mdk_rdev_t, same_set)),     \
+                        (tmp) = (tmp)->next, (tmp)->prev != &(head)     \
+                ; )
+/*
+ * iterates through the 'same array disks' ringlist
+ */
+#define ITERATE_RDEV(mddev,rdev,tmp)                                    \
+        ITERATE_RDEV_GENERIC((mddev)->disks,rdev,tmp)
+
+/*
+ * Iterates through 'pending RAID disks'
+ */
+#define ITERATE_RDEV_PENDING(rdev,tmp)                                  \
+        ITERATE_RDEV_GENERIC(pending_raid_disks,rdev,tmp)
+
+typedef struct mdk_thread_s {
+        void                    (*run) (mddev_t *mddev);
+        mddev_t                 *mddev;
+        wait_queue_head_t       wqueue;
+        unsigned long           flags;
+        struct completion       *event;
+        struct task_struct      *tsk;
+        const char              *name;
+} mdk_thread_t;
+
+#define THREAD_WAKEUP  0
+
+#define __wait_event_lock_irq(wq, condition, lock, cmd)                 \
+do {                                                                    \
+        wait_queue_t __wait;                                            \
+        init_waitqueue_entry(&__wait, current);                         \
+                                                                        \
+        add_wait_queue(&wq, &__wait);                                   \
+        for (;;) {                                                      \
+                set_current_state(TASK_UNINTERRUPTIBLE);                \
+                if (condition)                                          \
+                        break;                                          \
+                spin_unlock_irq(&lock);                                 \
+                cmd;                                                    \
+                schedule();                                             \
+                spin_lock_irq(&lock);                                   \
+        }                                                               \
+        current->state = TASK_RUNNING;                                  \
+        remove_wait_queue(&wq, &__wait);                                \
+} while (0)
+
+#define wait_event_lock_irq(wq, condition, lock, cmd)                   \
+do {                                                                    \
+        if (condition)                                                  \
+                break;                                                  \
+        __wait_event_lock_irq(wq, condition, lock, cmd);                \
+} while (0)
+
+#endif
+
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
new file mode 100644
index 000000000000..8ba95d67329f
--- /dev/null
+++ b/include/linux/raid/md_p.h
@@ -0,0 +1,230 @@
+/*
+   md_p.h : physical layout of Linux RAID devices
+          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
+          
+   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; either version 2, or (at your option)
+   any later version.
+   
+   You should have received a copy of the GNU General Public License
+   (for example /usr/src/linux/COPYING); if not, write to the Free
+   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+*/
+
+#ifndef _MD_P_H
+#define _MD_P_H
+
+/*
+ * RAID superblock.
+ *
+ * The RAID superblock maintains some statistics on each RAID configuration.
+ * Each real device in the RAID set contains it near the end of the device.
+ * Some of the ideas are copied from the ext2fs implementation.
+ *
+ * We currently use 4096 bytes as follows:
+ *
+ *      word offset     function
+ *
+ *         0  -    31   Constant generic RAID device information.
+ *        32  -    63   Generic state information.
+ *        64  -   127   Personality specific information.
+ *       128  -   511   12 32-words descriptors of the disks in the raid set.
+ *       512  -   911   Reserved.
+ *       912  -  1023   Disk specific descriptor.
+ */
+
+/*
+ * If x is the real device size in bytes, we return an apparent size of:
+ *
+ *      y = (x & ~(MD_RESERVED_BYTES - 1)) - MD_RESERVED_BYTES
+ *
+ * and place the 4kB superblock at offset y.
+ */
+#define MD_RESERVED_BYTES               (64 * 1024)
+#define MD_RESERVED_SECTORS             (MD_RESERVED_BYTES / 512)
+#define MD_RESERVED_BLOCKS              (MD_RESERVED_BYTES / BLOCK_SIZE)
+
+#define MD_NEW_SIZE_SECTORS(x)          ((x & ~(MD_RESERVED_SECTORS - 1)) - MD_RESERVED_SECTORS)
+#define MD_NEW_SIZE_BLOCKS(x)           ((x & ~(MD_RESERVED_BLOCKS - 1)) - MD_RESERVED_BLOCKS)
+
+#define MD_SB_BYTES                     4096
+#define MD_SB_WORDS                     (MD_SB_BYTES / 4)
+#define MD_SB_BLOCKS                    (MD_SB_BYTES / BLOCK_SIZE)
+#define MD_SB_SECTORS                   (MD_SB_BYTES / 512)
+
+/*
+ * The following are counted in 32-bit words
+ */
+#define MD_SB_GENERIC_OFFSET            0
+#define MD_SB_PERSONALITY_OFFSET        64
+#define MD_SB_DISKS_OFFSET              128
+#define MD_SB_DESCRIPTOR_OFFSET         992
+
+#define MD_SB_GENERIC_CONSTANT_WORDS    32
+#define MD_SB_GENERIC_STATE_WORDS       32
+#define MD_SB_GENERIC_WORDS             (MD_SB_GENERIC_CONSTANT_WORDS + MD_SB_GENERIC_STATE_WORDS)
+#define MD_SB_PERSONALITY_WORDS         64
+#define MD_SB_DESCRIPTOR_WORDS          32
+#define MD_SB_DISKS                     27
+#define MD_SB_DISKS_WORDS               (MD_SB_DISKS*MD_SB_DESCRIPTOR_WORDS)
+#define MD_SB_RESERVED_WORDS            (1024 - MD_SB_GENERIC_WORDS - MD_SB_PERSONALITY_WORDS - MD_SB_DISKS_WORDS - MD_SB_DESCRIPTOR_WORDS)
+#define MD_SB_EQUAL_WORDS               (MD_SB_GENERIC_WORDS + MD_SB_PERSONALITY_WORDS + MD_SB_DISKS_WORDS)
+
+/*
+ * Device "operational" state bits
+ */
+#define MD_DISK_FAULTY          0 /* disk is faulty / operational */
+#define MD_DISK_ACTIVE          1 /* disk is running or spare disk */
+#define MD_DISK_SYNC            2 /* disk is in sync with the raid set */
+#define MD_DISK_REMOVED         3 /* disk is in sync with the raid set */
+
+typedef struct mdp_device_descriptor_s {
+        __u32 number;           /* 0 Device number in the entire set          */
+        __u32 major;            /* 1 Device major number                      */
+        __u32 minor;            /* 2 Device minor number                      */
+        __u32 raid_disk;        /* 3 The role of the device in the raid set   */
+        __u32 state;            /* 4 Operational state                        */
+        __u32 reserved[MD_SB_DESCRIPTOR_WORDS - 5];
+} mdp_disk_t;
+
+#define MD_SB_MAGIC             0xa92b4efc
+
+/*
+ * Superblock state bits
+ */
+#define MD_SB_CLEAN             0
+#define MD_SB_ERRORS            1
+
+typedef struct mdp_superblock_s {
+        /*
+         * Constant generic information
+         */
+        __u32 md_magic;         /*  0 MD identifier                           */
+        __u32 major_version;    /*  1 major version to which the set conforms */
+        __u32 minor_version;    /*  2 minor version ...                       */
+        __u32 patch_version;    /*  3 patchlevel version ...                  */
+        __u32 gvalid_words;     /*  4 Number of used words in this section    */
+        __u32 set_uuid0;        /*  5 Raid set identifier                     */
+        __u32 ctime;            /*  6 Creation time                           */
+        __u32 level;            /*  7 Raid personality                        */
+        __u32 size;             /*  8 Apparent size of each individual disk   */
+        __u32 nr_disks;         /*  9 total disks in the raid set             */
+        __u32 raid_disks;       /* 10 disks in a fully functional raid set    */
+        __u32 md_minor;         /* 11 preferred MD minor device number        */
+        __u32 not_persistent;   /* 12 does it have a persistent superblock    */
+        __u32 set_uuid1;        /* 13 Raid set identifier #2                  */
+        __u32 set_uuid2;        /* 14 Raid set identifier #3                  */
+        __u32 set_uuid3;        /* 15 Raid set identifier #4                  */
+        __u32 gstate_creserved[MD_SB_GENERIC_CONSTANT_WORDS - 16];
+
+        /*
+         * Generic state information
+         */
+        __u32 utime;            /*  0 Superblock update time                  */
+        __u32 state;            /*  1 State bits (clean, ...)                 */
+        __u32 active_disks;     /*  2 Number of currently active disks        */
+        __u32 working_disks;    /*  3 Number of working disks                 */
+        __u32 failed_disks;     /*  4 Number of failed disks                  */
+        __u32 spare_disks;      /*  5 Number of spare disks                   */
+        __u32 sb_csum;          /*  6 checksum of the whole superblock        */
+#ifdef __BIG_ENDIAN
+        __u32 events_hi;        /*  7 high-order of superblock update count   */
+        __u32 events_lo;        /*  8 low-order of superblock update count    */
+        __u32 cp_events_hi;     /*  9 high-order of checkpoint update count   */
+        __u32 cp_events_lo;     /* 10 low-order of checkpoint update count    */
+#else
+        __u32 events_lo;        /*  7 low-order of superblock update count    */
+        __u32 events_hi;        /*  8 high-order of superblock update count   */
+        __u32 cp_events_lo;     /*  9 low-order of checkpoint update count    */
+        __u32 cp_events_hi;     /* 10 high-order of checkpoint update count   */
+#endif
+        __u32 recovery_cp;      /* 11 recovery checkpoint sector count        */
+        __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 12];
+
+        /*
+         * Personality information
+         */
+        __u32 layout;           /*  0 the array's physical layout             */
+        __u32 chunk_size;       /*  1 chunk size in bytes                     */
+        __u32 root_pv;          /*  2 LV root PV */
+        __u32 root_block;       /*  3 LV root block */
+        __u32 pstate_reserved[MD_SB_PERSONALITY_WORDS - 4];
+
+        /*
+         * Disks information
+         */
+        mdp_disk_t disks[MD_SB_DISKS];
+
+        /*
+         * Reserved
+         */
+        __u32 reserved[MD_SB_RESERVED_WORDS];
+
+        /*
+         * Active descriptor
+         */
+        mdp_disk_t this_disk;
+
+} mdp_super_t;
+
+static inline __u64 md_event(mdp_super_t *sb) {
+        __u64 ev = sb->events_hi;
+        return (ev<<32)| sb->events_lo;
+}
+
+/*
+ * The version-1 superblock :
+ * All numeric fields are little-endian.
+ *
+ * total size: 256 bytes plus 2 per device.
+ *  1K allows 384 devices.
+ */
+struct mdp_superblock_1 {
+        /* constant array information - 128 bytes */
+        __u32   magic;          /* MD_SB_MAGIC: 0xa92b4efc - little endian */
+        __u32   major_version;  /* 1 */
+        __u32   feature_map;    /* 0 for now */
+        __u32   pad0;           /* always set to 0 when writing */
+
+        __u8    set_uuid[16];   /* user-space generated. */
+        char    set_name[32];   /* set and interpreted by user-space */
+
+        __u64   ctime;          /* lo 40 bits are seconds, top 24 are microseconds or 0*/
+        __u32   level;          /* -4 (multipath), -1 (linear), 0,1,4,5 */
+        __u32   layout;         /* only for raid5 currently */
+        __u64   size;           /* used size of component devices, in 512byte sectors */
+
+        __u32   chunksize;      /* in 512byte sectors */
+        __u32   raid_disks;
+        __u8    pad1[128-96];   /* set to 0 when written */
+
+        /* constant this-device information - 64 bytes */
+        __u64   data_offset;    /* sector start of data, often 0 */
+        __u64   data_size;      /* sectors in this device that can be used for data */
+        __u64   super_offset;   /* sector start of this superblock */
+        __u64   recovery_offset;/* sectors before this offset (from data_offset) have been recovered */
+        __u32   dev_number;     /* permanent identifier of this  device - not role in raid */
+        __u32   cnt_corrected_read; /* number of read errors that were corrected by re-writing */
+        __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
+        __u8    pad2[64-56];    /* set to 0 when writing */
+
+        /* array state information - 64 bytes */
+        __u64   utime;          /* 40 bits second, 24 btes microseconds */
+        __u64   events;         /* incremented when superblock updated */
+        __u64   resync_offset;  /* data before this offset (from data_offset) known to be in sync */
+        __u32   sb_csum;        /* checksum upto devs[max_dev] */
+        __u32   max_dev;        /* size of devs[] array to consider */
+        __u8    pad3[64-32];    /* set to 0 when writing */
+
+        /* device state information. Indexed by dev_number.
+         * 2 bytes per device
+         * Note there are no per-device state flags. State information is rolled
+         * into the 'roles' value.  If a device is spare or faulty, then it doesn't
+         * have a meaningful role.
+         */
+        __u16   dev_roles[0];   /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
+};
+
+#endif 
+
diff --git a/include/linux/raid/md_u.h b/include/linux/raid/md_u.h
new file mode 100644
index 000000000000..a2df5c2a42af
--- /dev/null
+++ b/include/linux/raid/md_u.h
@@ -0,0 +1,117 @@
+/*
+   md_u.h : user <=> kernel API between Linux raidtools and RAID drivers
+          Copyright (C) 1998 Ingo Molnar
+          
+   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; either version 2, or (at your option)
+   any later version.
+   
+   You should have received a copy of the GNU General Public License
+   (for example /usr/src/linux/COPYING); if not, write to the Free
+   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+*/
+
+#ifndef _MD_U_H
+#define _MD_U_H
+
+/* ioctls */
+
+/* status */
+#define RAID_VERSION            _IOR (MD_MAJOR, 0x10, mdu_version_t)
+#define GET_ARRAY_INFO          _IOR (MD_MAJOR, 0x11, mdu_array_info_t)
+#define GET_DISK_INFO           _IOR (MD_MAJOR, 0x12, mdu_disk_info_t)
+#define PRINT_RAID_DEBUG        _IO (MD_MAJOR, 0x13)
+#define RAID_AUTORUN            _IO (MD_MAJOR, 0x14)
+
+/* configuration */
+#define CLEAR_ARRAY             _IO (MD_MAJOR, 0x20)
+#define ADD_NEW_DISK            _IOW (MD_MAJOR, 0x21, mdu_disk_info_t)
+#define HOT_REMOVE_DISK         _IO (MD_MAJOR, 0x22)
+#define SET_ARRAY_INFO          _IOW (MD_MAJOR, 0x23, mdu_array_info_t)
+#define SET_DISK_INFO           _IO (MD_MAJOR, 0x24)
+#define WRITE_RAID_INFO         _IO (MD_MAJOR, 0x25)
+#define UNPROTECT_ARRAY         _IO (MD_MAJOR, 0x26)
+#define PROTECT_ARRAY           _IO (MD_MAJOR, 0x27)
+#define HOT_ADD_DISK            _IO (MD_MAJOR, 0x28)
+#define SET_DISK_FAULTY         _IO (MD_MAJOR, 0x29)
+#define HOT_GENERATE_ERROR      _IO (MD_MAJOR, 0x2a)
+
+/* usage */
+#define RUN_ARRAY               _IOW (MD_MAJOR, 0x30, mdu_param_t)
+#define START_ARRAY             _IO (MD_MAJOR, 0x31)
+#define STOP_ARRAY              _IO (MD_MAJOR, 0x32)
+#define STOP_ARRAY_RO           _IO (MD_MAJOR, 0x33)
+#define RESTART_ARRAY_RW        _IO (MD_MAJOR, 0x34)
+
+typedef struct mdu_version_s {
+        int major;
+        int minor;
+        int patchlevel;
+} mdu_version_t;
+
+typedef struct mdu_array_info_s {
+        /*
+         * Generic constant information
+         */
+        int major_version;
+        int minor_version;
+        int patch_version;
+        int ctime;
+        int level;
+        int size;
+        int nr_disks;
+        int raid_disks;
+        int md_minor;
+        int not_persistent;
+
+        /*
+         * Generic state information
+         */
+        int utime;              /*  0 Superblock update time                  */
+        int state;              /*  1 State bits (clean, ...)                 */
+        int active_disks;       /*  2 Number of currently active disks        */
+        int working_disks;      /*  3 Number of working disks                 */
+        int failed_disks;       /*  4 Number of failed disks                  */
+        int spare_disks;        /*  5 Number of spare disks                   */
+
+        /*
+         * Personality information
+         */
+        int layout;             /*  0 the array's physical layout             */
+        int chunk_size; /*  1 chunk size in bytes                     */
+
+} mdu_array_info_t;
+
+typedef struct mdu_disk_info_s {
+        /*
+         * configuration/status of one particular disk
+         */
+        int number;
+        int major;
+        int minor;
+        int raid_disk;
+        int state;
+
+} mdu_disk_info_t;
+
+typedef struct mdu_start_info_s {
+        /*
+         * configuration/status of one particular disk
+         */
+        int major;
+        int minor;
+        int raid_disk;
+        int state;
+
+} mdu_start_info_t;
+
+typedef struct mdu_param_s
+{
+        int                     personality;    /* 1,2,3,4 */
+        int                     chunk_size;     /* in bytes */
+        int                     max_fault;      /* unused for now */
+} mdu_param_t;
+
+#endif 
+
diff --git a/include/linux/raid/multipath.h b/include/linux/raid/multipath.h
new file mode 100644
index 000000000000..6f53fc177a47
--- /dev/null
+++ b/include/linux/raid/multipath.h
@@ -0,0 +1,42 @@
+#ifndef _MULTIPATH_H
+#define _MULTIPATH_H
+
+#include <linux/raid/md.h>
+
+struct multipath_info {
+        mdk_rdev_t      *rdev;
+};
+
+struct multipath_private_data {
+        mddev_t                 *mddev;
+        struct multipath_info   *multipaths;
+        int                     raid_disks;
+        int                     working_disks;
+        spinlock_t              device_lock;
+        struct list_head        retry_list;
+
+        mempool_t               *pool;
+};
+
+typedef struct multipath_private_data multipath_conf_t;
+
+/*
+ * this is the only point in the RAID code where we violate
+ * C type safety. mddev->private is an 'opaque' pointer.
+ */
+#define mddev_to_conf(mddev) ((multipath_conf_t *) mddev->private)
+
+/*
+ * this is our 'private' 'collective' MULTIPATH buffer head.
+ * it contains information about what kind of IO operations were started
+ * for this MULTIPATH operation, and about their status:
+ */
+
+struct multipath_bh {
+        mddev_t                 *mddev;
+        struct bio              *master_bio;
+        struct bio              bio;
+        int                     path;
+        struct list_head        retry_list;
+};
+#endif
diff --git a/include/linux/raid/raid0.h b/include/linux/raid/raid0.h
new file mode 100644
index 000000000000..1b2dda035f8e
--- /dev/null
+++ b/include/linux/raid/raid0.h
@@ -0,0 +1,30 @@
+#ifndef _RAID0_H
+#define _RAID0_H
+
+#include <linux/raid/md.h>
+
+struct strip_zone
+{
+        sector_t zone_offset;   /* Zone offset in md_dev */
+        sector_t dev_offset;    /* Zone offset in real dev */
+        sector_t size;          /* Zone size */
+        int nb_dev;             /* # of devices attached to the zone */
+        mdk_rdev_t **dev;       /* Devices attached to the zone */
+};
+
+struct raid0_private_data
+{
+        struct strip_zone **hash_table; /* Table of indexes into strip_zone */
+        struct strip_zone *strip_zone;
+        mdk_rdev_t **devlist; /* lists of rdevs, pointed to by strip_zone->dev */
+        int nr_strip_zones;
+
+        sector_t hash_spacing;
+        int preshift;                   /* shift this before divide by hash_spacing */
+};
+
+typedef struct raid0_private_data raid0_conf_t;
+
+#define mddev_to_conf(mddev) ((raid0_conf_t *) mddev->private)
+
+#endif
diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h
new file mode 100644
index 000000000000..abbfdd9afe1e
--- /dev/null
+++ b/include/linux/raid/raid1.h
@@ -0,0 +1,98 @@
+#ifndef _RAID1_H
+#define _RAID1_H
+
+#include <linux/raid/md.h>
+
+typedef struct mirror_info mirror_info_t;
+
+struct mirror_info {
+        mdk_rdev_t      *rdev;
+        sector_t        head_position;
+};
+
+/*
+ * memory pools need a pointer to the mddev, so they can force an unplug
+ * when memory is tight, and a count of the number of drives that the
+ * pool was allocated for, so they know how much to allocate and free.
+ * mddev->raid_disks cannot be used, as it can change while a pool is active
+ * These two datums are stored in a kmalloced struct.
+ */
+
+struct pool_info {
+        mddev_t *mddev;
+        int     raid_disks;
+};
+
+
+typedef struct r1bio_s r1bio_t;
+
+struct r1_private_data_s {
+        mddev_t                 *mddev;
+        mirror_info_t           *mirrors;
+        int                     raid_disks;
+        int                     working_disks;
+        int                     last_used;
+        sector_t                next_seq_sect;
+        spinlock_t              device_lock;
+
+        struct list_head        retry_list;
+        /* for use when syncing mirrors: */
+
+        spinlock_t              resync_lock;
+        int nr_pending;
+        int barrier;
+        sector_t                next_resync;
+
+        wait_queue_head_t       wait_idle;
+        wait_queue_head_t       wait_resume;
+
+        struct pool_info        *poolinfo;
+
+        mempool_t *r1bio_pool;
+        mempool_t *r1buf_pool;
+};
+
+typedef struct r1_private_data_s conf_t;
+
+/*
+ * this is the only point in the RAID code where we violate
+ * C type safety. mddev->private is an 'opaque' pointer.
+ */
+#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
+
+/*
+ * this is our 'private' RAID1 bio.
+ *
+ * it contains information about what kind of IO operations were started
+ * for this RAID1 operation, and about their status:
+ */
+
+struct r1bio_s {
+        atomic_t                remaining; /* 'have we finished' count,
+                                            * used from IRQ handlers
+                                            */
+        sector_t                sector;
+        int                     sectors;
+        unsigned long           state;
+        mddev_t                 *mddev;
+        /*
+         * original bio going to /dev/mdx
+         */
+        struct bio              *master_bio;
+        /*
+         * if the IO is in READ direction, then this is where we read
+         */
+        int                     read_disk;
+
+        struct list_head        retry_list;
+        /*
+         * if the IO is in WRITE direction, then multiple bios are used.
+         * We choose the number when they are allocated.
+         */
+        struct bio              *bios[0];
+};
+
+/* bits for r1bio.state */
+#define R1BIO_Uptodate  0
+#define R1BIO_IsSync    1
+#endif
diff --git a/include/linux/raid/raid10.h b/include/linux/raid/raid10.h
new file mode 100644
index 000000000000..60708789c8f9
--- /dev/null
+++ b/include/linux/raid/raid10.h
@@ -0,0 +1,103 @@
+#ifndef _RAID10_H
+#define _RAID10_H
+
+#include <linux/raid/md.h>
+
+typedef struct mirror_info mirror_info_t;
+
+struct mirror_info {
+        mdk_rdev_t      *rdev;
+        sector_t        head_position;
+};
+
+typedef struct r10bio_s r10bio_t;
+
+struct r10_private_data_s {
+        mddev_t                 *mddev;
+        mirror_info_t           *mirrors;
+        int                     raid_disks;
+        int                     working_disks;
+        spinlock_t              device_lock;
+
+        /* geometry */
+        int                     near_copies;  /* number of copies layed out raid0 style */
+        int                     far_copies;   /* number of copies layed out
+                                               * at large strides across drives
+                                               */
+        int                     copies;       /* near_copies * far_copies.
+                                               * must be <= raid_disks
+                                               */
+        sector_t                stride;       /* distance between far copies.
+                                               * This is size / far_copies
+                                               */
+
+        int chunk_shift; /* shift from chunks to sectors */
+        sector_t chunk_mask;
+
+        struct list_head        retry_list;
+        /* for use when syncing mirrors: */
+
+        spinlock_t              resync_lock;
+        int nr_pending;
+        int barrier;
+        sector_t                next_resync;
+
+        wait_queue_head_t       wait_idle;
+        wait_queue_head_t       wait_resume;
+
+        mempool_t *r10bio_pool;
+        mempool_t *r10buf_pool;
+};
+
+typedef struct r10_private_data_s conf_t;
+
+/*
+ * this is the only point in the RAID code where we violate
+ * C type safety. mddev->private is an 'opaque' pointer.
+ */
+#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
+
+/*
+ * this is our 'private' RAID10 bio.
+ *
+ * it contains information about what kind of IO operations were started
+ * for this RAID10 operation, and about their status:
+ */
+
+struct r10bio_s {
+        atomic_t                remaining; /* 'have we finished' count,
+                                            * used from IRQ handlers
+                                            */
+        sector_t                sector; /* virtual sector number */
+        int                     sectors;
+        unsigned long           state;
+        mddev_t                 *mddev;
+        /*
+         * original bio going to /dev/mdx
+         */
+        struct bio              *master_bio;
+        /*
+         * if the IO is in READ direction, then this is where we read
+         */
+        int                     read_slot;
+
+        struct list_head        retry_list;
+        /*
+         * if the IO is in WRITE direction, then multiple bios are used,
+         * one for each copy.
+         * When resyncing we also use one for each copy.
+         * When reconstructing, we use 2 bios, one for read, one for write.
+         * We choose the number when they are allocated.
+         */
+        struct {
+                struct bio              *bio;
+                sector_t addr;
+                int devnum;
+        } devs[0];
+};
+
+/* bits for r10bio.state */
+#define R10BIO_Uptodate 0
+#define R10BIO_IsSync   1
+#define R10BIO_IsRecover 2
+#endif
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
new file mode 100644
index 000000000000..d63ddcb4afad
--- /dev/null
+++ b/include/linux/raid/raid5.h
@@ -0,0 +1,243 @@
+#ifndef _RAID5_H
+#define _RAID5_H
+
+#include <linux/raid/md.h>
+#include <linux/raid/xor.h>
+
+/*
+ *
+ * Each stripe contains one buffer per disc.  Each buffer can be in
+ * one of a number of states stored in "flags".  Changes between
+ * these states happen *almost* exclusively under a per-stripe
+ * spinlock.  Some very specific changes can happen in bi_end_io, and
+ * these are not protected by the spin lock.
+ *
+ * The flag bits that are used to represent these states are:
+ *   R5_UPTODATE and R5_LOCKED
+ *
+ * State Empty == !UPTODATE, !LOCK
+ *        We have no data, and there is no active request
+ * State Want == !UPTODATE, LOCK
+ *        A read request is being submitted for this block
+ * State Dirty == UPTODATE, LOCK
+ *        Some new data is in this buffer, and it is being written out
+ * State Clean == UPTODATE, !LOCK
+ *        We have valid data which is the same as on disc
+ *
+ * The possible state transitions are:
+ *
+ *  Empty -> Want   - on read or write to get old data for  parity calc
+ *  Empty -> Dirty  - on compute_parity to satisfy write/sync request.(RECONSTRUCT_WRITE)
+ *  Empty -> Clean  - on compute_block when computing a block for failed drive
+ *  Want  -> Empty  - on failed read
+ *  Want  -> Clean  - on successful completion of read request
+ *  Dirty -> Clean  - on successful completion of write request
+ *  Dirty -> Clean  - on failed write
+ *  Clean -> Dirty  - on compute_parity to satisfy write/sync (RECONSTRUCT or RMW)
+ *
+ * The Want->Empty, Want->Clean, Dirty->Clean, transitions
+ * all happen in b_end_io at interrupt time.
+ * Each sets the Uptodate bit before releasing the Lock bit.
+ * This leaves one multi-stage transition:
+ *    Want->Dirty->Clean
+ * This is safe because thinking that a Clean buffer is actually dirty
+ * will at worst delay some action, and the stripe will be scheduled
+ * for attention after the transition is complete.
+ *
+ * There is one possibility that is not covered by these states.  That
+ * is if one drive has failed and there is a spare being rebuilt.  We
+ * can't distinguish between a clean block that has been generated
+ * from parity calculations, and a clean block that has been
+ * successfully written to the spare ( or to parity when resyncing).
+ * To distingush these states we have a stripe bit STRIPE_INSYNC that
+ * is set whenever a write is scheduled to the spare, or to the parity
+ * disc if there is no spare.  A sync request clears this bit, and
+ * when we find it set with no buffers locked, we know the sync is
+ * complete.
+ *
+ * Buffers for the md device that arrive via make_request are attached
+ * to the appropriate stripe in one of two lists linked on b_reqnext.
+ * One list (bh_read) for read requests, one (bh_write) for write.
+ * There should never be more than one buffer on the two lists
+ * together, but we are not guaranteed of that so we allow for more.
+ *
+ * If a buffer is on the read list when the associated cache buffer is
+ * Uptodate, the data is copied into the read buffer and it's b_end_io
+ * routine is called.  This may happen in the end_request routine only
+ * if the buffer has just successfully been read.  end_request should
+ * remove the buffers from the list and then set the Uptodate bit on
+ * the buffer.  Other threads may do this only if they first check
+ * that the Uptodate bit is set.  Once they have checked that they may
+ * take buffers off the read queue.
+ *
+ * When a buffer on the write list is committed for write it is copied
+ * into the cache buffer, which is then marked dirty, and moved onto a
+ * third list, the written list (bh_written).  Once both the parity
+ * block and the cached buffer are successfully written, any buffer on
+ * a written list can be returned with b_end_io.
+ *
+ * The write list and read list both act as fifos.  The read list is
+ * protected by the device_lock.  The write and written lists are
+ * protected by the stripe lock.  The device_lock, which can be
+ * claimed while the stipe lock is held, is only for list
+ * manipulations and will only be held for a very short time.  It can
+ * be claimed from interrupts.
+ *
+ *
+ * Stripes in the stripe cache can be on one of two lists (or on
+ * neither).  The "inactive_list" contains stripes which are not
+ * currently being used for any request.  They can freely be reused
+ * for another stripe.  The "handle_list" contains stripes that need
+ * to be handled in some way.  Both of these are fifo queues.  Each
+ * stripe is also (potentially) linked to a hash bucket in the hash
+ * table so that it can be found by sector number.  Stripes that are
+ * not hashed must be on the inactive_list, and will normally be at
+ * the front.  All stripes start life this way.
+ *
+ * The inactive_list, handle_list and hash bucket lists are all protected by the
+ * device_lock.
+ *  - stripes on the inactive_list never have their stripe_lock held.
+ *  - stripes have a reference counter. If count==0, they are on a list.
+ *  - If a stripe might need handling, STRIPE_HANDLE is set.
+ *  - When refcount reaches zero, then if STRIPE_HANDLE it is put on
+ *    handle_list else inactive_list
+ *
+ * This, combined with the fact that STRIPE_HANDLE is only ever
+ * cleared while a stripe has a non-zero count means that if the
+ * refcount is 0 and STRIPE_HANDLE is set, then it is on the
+ * handle_list and if recount is 0 and STRIPE_HANDLE is not set, then
+ * the stripe is on inactive_list.
+ *
+ * The possible transitions are:
+ *  activate an unhashed/inactive stripe (get_active_stripe())
+ *     lockdev check-hash unlink-stripe cnt++ clean-stripe hash-stripe unlockdev
+ *  activate a hashed, possibly active stripe (get_active_stripe())
+ *     lockdev check-hash if(!cnt++)unlink-stripe unlockdev
+ *  attach a request to an active stripe (add_stripe_bh())
+ *     lockdev attach-buffer unlockdev
+ *  handle a stripe (handle_stripe())
+ *     lockstripe clrSTRIPE_HANDLE ... (lockdev check-buffers unlockdev) .. change-state .. record io needed unlockstripe schedule io
+ *  release an active stripe (release_stripe())
+ *     lockdev if (!--cnt) { if  STRIPE_HANDLE, add to handle_list else add to inactive-list } unlockdev
+ *
+ * The refcount counts each thread that have activated the stripe,
+ * plus raid5d if it is handling it, plus one for each active request
+ * on a cached buffer.
+ */
+
+struct stripe_head {
+        struct stripe_head      *hash_next, **hash_pprev; /* hash pointers */
+        struct list_head        lru;                    /* inactive_list or handle_list */
+        struct raid5_private_data       *raid_conf;
+        sector_t                sector;                 /* sector of this row */
+        int                     pd_idx;                 /* parity disk index */
+        unsigned long           state;                  /* state flags */
+        atomic_t                count;                  /* nr of active thread/requests */
+        spinlock_t              lock;
+        struct r5dev {
+                struct bio      req;
+                struct bio_vec  vec;
+                struct page     *page;
+                struct bio      *toread, *towrite, *written;
+                sector_t        sector;                 /* sector of this page */
+                unsigned long   flags;
+        } dev[1]; /* allocated with extra space depending of RAID geometry */
+};
+/* Flags */
+#define R5_UPTODATE     0       /* page contains current data */
+#define R5_LOCKED       1       /* IO has been submitted on "req" */
+#define R5_OVERWRITE    2       /* towrite covers whole page */
+/* and some that are internal to handle_stripe */
+#define R5_Insync       3       /* rdev && rdev->in_sync at start */
+#define R5_Wantread     4       /* want to schedule a read */
+#define R5_Wantwrite    5
+#define R5_Syncio       6       /* this io need to be accounted as resync io */
+#define R5_Overlap      7       /* There is a pending overlapping request on this block */
+
+/*
+ * Write method
+ */
+#define RECONSTRUCT_WRITE       1
+#define READ_MODIFY_WRITE       2
+/* not a write method, but a compute_parity mode */
+#define CHECK_PARITY            3
+
+/*
+ * Stripe state
+ */
+#define STRIPE_ERROR            1
+#define STRIPE_HANDLE           2
+#define STRIPE_SYNCING          3
+#define STRIPE_INSYNC           4
+#define STRIPE_PREREAD_ACTIVE   5
+#define STRIPE_DELAYED          6
+
+/*
+ * Plugging:
+ *
+ * To improve write throughput, we need to delay the handling of some
+ * stripes until there has been a chance that several write requests
+ * for the one stripe have all been collected.
+ * In particular, any write request that would require pre-reading
+ * is put on a "delayed" queue until there are no stripes currently
+ * in a pre-read phase.  Further, if the "delayed" queue is empty when
+ * a stripe is put on it then we "plug" the queue and do not process it
+ * until an unplug call is made. (the unplug_io_fn() is called).
+ *
+ * When preread is initiated on a stripe, we set PREREAD_ACTIVE and add
+ * it to the count of prereading stripes.
+ * When write is initiated, or the stripe refcnt == 0 (just in case) we
+ * clear the PREREAD_ACTIVE flag and decrement the count
+ * Whenever the delayed queue is empty and the device is not plugged, we
+ * move any strips from delayed to handle and clear the DELAYED flag and set PREREAD_ACTIVE.
+ * In stripe_handle, if we find pre-reading is necessary, we do it if
+ * PREREAD_ACTIVE is set, else we set DELAYED which will send it to the delayed queue.
+ * HANDLE gets cleared if stripe_handle leave nothing locked.
+ */
+ 
+
+struct disk_info {
+        mdk_rdev_t      *rdev;
+};
+
+struct raid5_private_data {
+        struct stripe_head      **stripe_hashtbl;
+        mddev_t                 *mddev;
+        struct disk_info        *spare;
+        int                     chunk_size, level, algorithm;
+        int                     raid_disks, working_disks, failed_disks;
+        int                     max_nr_stripes;
+
+        struct list_head        handle_list; /* stripes needing handling */
+        struct list_head        delayed_list; /* stripes that have plugged requests */
+        atomic_t                preread_active_stripes; /* stripes with scheduled io */
+
+        char                    cache_name[20];
+        kmem_cache_t            *slab_cache; /* for allocating stripes */
+        /*
+         * Free stripes pool
+         */
+        atomic_t                active_stripes;
+        struct list_head        inactive_list;
+        wait_queue_head_t       wait_for_stripe;
+        wait_queue_head_t       wait_for_overlap;
+        int                     inactive_blocked;       /* release of inactive stripes blocked,
+                                                         * waiting for 25% to be free
+                                                         */        
+        spinlock_t              device_lock;
+        struct disk_info        disks[0];
+};
+
+typedef struct raid5_private_data raid5_conf_t;
+
+#define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
+
+/*
+ * Our supported algorithms
+ */
+#define ALGORITHM_LEFT_ASYMMETRIC       0
+#define ALGORITHM_RIGHT_ASYMMETRIC      1
+#define ALGORITHM_LEFT_SYMMETRIC        2
+#define ALGORITHM_RIGHT_SYMMETRIC       3
+
+#endif
diff --git a/include/linux/raid/xor.h b/include/linux/raid/xor.h
new file mode 100644
index 000000000000..f0d67cbdea40
--- /dev/null
+++ b/include/linux/raid/xor.h
@@ -0,0 +1,23 @@
+#ifndef _XOR_H
+#define _XOR_H
+
+#include <linux/raid/md.h>
+
+#define MAX_XOR_BLOCKS 5
+
+extern void xor_block(unsigned int count, unsigned int bytes, void **ptr);
+
+struct xor_block_template {
+        struct xor_block_template *next;
+        const char *name;
+        int speed;
+        void (*do_2)(unsigned long, unsigned long *, unsigned long *);
+        void (*do_3)(unsigned long, unsigned long *, unsigned long *,
+                     unsigned long *);
+        void (*do_4)(unsigned long, unsigned long *, unsigned long *,
+                     unsigned long *, unsigned long *);
+        void (*do_5)(unsigned long, unsigned long *, unsigned long *,
+                     unsigned long *, unsigned long *, unsigned long *);
+};
+
+#endif
diff --git a/include/linux/ramfs.h b/include/linux/ramfs.h
new file mode 100644
index 000000000000..e0a4faa9610c
--- /dev/null
+++ b/include/linux/ramfs.h
@@ -0,0 +1,11 @@
+#ifndef _LINUX_RAMFS_H
+#define _LINUX_RAMFS_H
+
+struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev);
+struct super_block *ramfs_get_sb(struct file_system_type *fs_type,
+         int flags, const char *dev_name, void *data);
+
+extern struct file_operations ramfs_file_operations;
+extern struct vm_operations_struct generic_file_vm_ops;
+
+#endif
diff --git a/include/linux/random.h b/include/linux/random.h
new file mode 100644
index 000000000000..cc6703449916
--- /dev/null
+++ b/include/linux/random.h
@@ -0,0 +1,72 @@
+/*
+ * include/linux/random.h
+ *
+ * Include file for the random number generator.
+ */
+
+#ifndef _LINUX_RANDOM_H
+#define _LINUX_RANDOM_H
+
+#include <linux/ioctl.h>
+
+/* ioctl()'s for the random number generator */
+
+/* Get the entropy count. */
+#define RNDGETENTCNT    _IOR( 'R', 0x00, int )
+
+/* Add to (or subtract from) the entropy count.  (Superuser only.) */
+#define RNDADDTOENTCNT  _IOW( 'R', 0x01, int )
+
+/* Get the contents of the entropy pool.  (Superuser only.) */
+#define RNDGETPOOL      _IOR( 'R', 0x02, int [2] )
+
+/* 
+ * Write bytes into the entropy pool and add to the entropy count.
+ * (Superuser only.)
+ */
+#define RNDADDENTROPY   _IOW( 'R', 0x03, int [2] )
+
+/* Clear entropy count to 0.  (Superuser only.) */
+#define RNDZAPENTCNT    _IO( 'R', 0x04 )
+
+/* Clear the entropy pool and associated counters.  (Superuser only.) */
+#define RNDCLEARPOOL    _IO( 'R', 0x06 )
+
+struct rand_pool_info {
+        int     entropy_count;
+        int     buf_size;
+        __u32   buf[0];
+};
+
+/* Exported functions */
+
+#ifdef __KERNEL__
+
+extern void rand_initialize_irq(int irq);
+
+extern void add_input_randomness(unsigned int type, unsigned int code,
+                                 unsigned int value);
+extern void add_interrupt_randomness(int irq);
+
+extern void get_random_bytes(void *buf, int nbytes);
+void generate_random_uuid(unsigned char uuid_out[16]);
+
+extern __u32 secure_ip_id(__u32 daddr);
+extern u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport);
+extern u32 secure_tcpv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, 
+                                       __u16 dport);
+extern __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
+                                        __u16 sport, __u16 dport);
+extern __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr,
+                                          __u16 sport, __u16 dport);
+
+#ifndef MODULE
+extern struct file_operations random_fops, urandom_fops;
+#endif
+
+unsigned int get_random_int(void);
+unsigned long randomize_range(unsigned long start, unsigned long end, unsigned long len);
+
+#endif /* __KERNEL___ */
+
+#endif /* _LINUX_RANDOM_H */
diff --git a/include/linux/raw.h b/include/linux/raw.h
new file mode 100644
index 000000000000..62d543e70603
--- /dev/null
+++ b/include/linux/raw.h
@@ -0,0 +1,18 @@
+#ifndef __LINUX_RAW_H
+#define __LINUX_RAW_H
+
+#include <linux/types.h>
+
+#define RAW_SETBIND     _IO( 0xac, 0 )
+#define RAW_GETBIND     _IO( 0xac, 1 )
+
+struct raw_config_request 
+{
+        int     raw_minor;
+        __u64   block_major;
+        __u64   block_minor;
+};
+
+#define MAX_RAW_MINORS CONFIG_MAX_RAW_DEVS
+
+#endif /* __LINUX_RAW_H */
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
new file mode 100644
index 000000000000..4b7cc4fe366d
--- /dev/null
+++ b/include/linux/rbtree.h
@@ -0,0 +1,141 @@
+/*
+  Red Black Trees
+  (C) 1999  Andrea Arcangeli <andrea@suse.de>
+  
+  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; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  linux/include/linux/rbtree.h
+
+  To use rbtrees you'll have to implement your own insert and search cores.
+  This will avoid us to use callbacks and to drop drammatically performances.
+  I know it's not the cleaner way,  but in C (not in C++) to get
+  performances and genericity...
+
+  Some example of insert and search follows here. The search is a plain
+  normal search over an ordered tree. The insert instead must be implemented
+  int two steps: as first thing the code must insert the element in
+  order as a red leaf in the tree, then the support library function
+  rb_insert_color() must be called. Such function will do the
+  not trivial work to rebalance the rbtree if necessary.
+
+-----------------------------------------------------------------------
+static inline struct page * rb_search_page_cache(struct inode * inode,
+                                                 unsigned long offset)
+{
+        struct rb_node * n = inode->i_rb_page_cache.rb_node;
+        struct page * page;
+
+        while (n)
+        {
+                page = rb_entry(n, struct page, rb_page_cache);
+
+                if (offset < page->offset)
+                        n = n->rb_left;
+                else if (offset > page->offset)
+                        n = n->rb_right;
+                else
+                        return page;
+        }
+        return NULL;
+}
+
+static inline struct page * __rb_insert_page_cache(struct inode * inode,
+                                                   unsigned long offset,
+                                                   struct rb_node * node)
+{
+        struct rb_node ** p = &inode->i_rb_page_cache.rb_node;
+        struct rb_node * parent = NULL;
+        struct page * page;
+
+        while (*p)
+        {
+                parent = *p;
+                page = rb_entry(parent, struct page, rb_page_cache);
+
+                if (offset < page->offset)
+                        p = &(*p)->rb_left;
+                else if (offset > page->offset)
+                        p = &(*p)->rb_right;
+                else
+                        return page;
+        }
+
+        rb_link_node(node, parent, p);
+
+        return NULL;
+}
+
+static inline struct page * rb_insert_page_cache(struct inode * inode,
+                                                 unsigned long offset,
+                                                 struct rb_node * node)
+{
+        struct page * ret;
+        if ((ret = __rb_insert_page_cache(inode, offset, node)))
+                goto out;
+        rb_insert_color(node, &inode->i_rb_page_cache);
+ out:
+        return ret;
+}
+-----------------------------------------------------------------------
+*/
+
+#ifndef _LINUX_RBTREE_H
+#define _LINUX_RBTREE_H
+
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+
+struct rb_node
+{
+        struct rb_node *rb_parent;
+        int rb_color;
+#define RB_RED          0
+#define RB_BLACK        1
+        struct rb_node *rb_right;
+        struct rb_node *rb_left;
+};
+
+struct rb_root
+{
+        struct rb_node *rb_node;
+};
+
+#define RB_ROOT (struct rb_root) { NULL, }
+#define rb_entry(ptr, type, member) container_of(ptr, type, member)
+
+extern void rb_insert_color(struct rb_node *, struct rb_root *);
+extern void rb_erase(struct rb_node *, struct rb_root *);
+
+/* Find logical next and previous nodes in a tree */
+extern struct rb_node *rb_next(struct rb_node *);
+extern struct rb_node *rb_prev(struct rb_node *);
+extern struct rb_node *rb_first(struct rb_root *);
+extern struct rb_node *rb_last(struct rb_root *);
+
+/* Fast replacement of a single node without remove/rebalance/add/rebalance */
+extern void rb_replace_node(struct rb_node *victim, struct rb_node *new, 
+                            struct rb_root *root);
+
+static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
+                                struct rb_node ** rb_link)
+{
+        node->rb_parent = parent;
+        node->rb_color = RB_RED;
+        node->rb_left = node->rb_right = NULL;
+
+        *rb_link = node;
+}
+
+#endif  /* _LINUX_RBTREE_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
new file mode 100644
index 000000000000..4d747433916b
--- /dev/null
+++ b/include/linux/rcupdate.h
@@ -0,0 +1,271 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion 
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright (C) IBM Corporation, 2001
+ *
+ * Author: Dipankar Sarma <dipankar@in.ibm.com>
+ * 
+ * Based on the original work by Paul McKenney <paul.mckenney@us.ibm.com>
+ * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
+ * Papers:
+ * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
+ * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
+ *
+ * For detailed explanation of Read-Copy Update mechanism see -
+ *              http://lse.sourceforge.net/locking/rcupdate.html
+ *
+ */
+
+#ifndef __LINUX_RCUPDATE_H
+#define __LINUX_RCUPDATE_H
+
+#ifdef __KERNEL__
+
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/threads.h>
+#include <linux/percpu.h>
+#include <linux/cpumask.h>
+#include <linux/seqlock.h>
+
+/**
+ * struct rcu_head - callback structure for use with RCU
+ * @next: next update requests in a list
+ * @func: actual update function to call after the grace period.
+ */
+struct rcu_head {
+        struct rcu_head *next;
+        void (*func)(struct rcu_head *head);
+};
+
+#define RCU_HEAD_INIT(head) { .next = NULL, .func = NULL }
+#define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT(head)
+#define INIT_RCU_HEAD(ptr) do { \
+       (ptr)->next = NULL; (ptr)->func = NULL; \
+} while (0)
+
+
+
+/* Global control variables for rcupdate callback mechanism. */
+struct rcu_ctrlblk {
+        long    cur;            /* Current batch number.                      */
+        long    completed;      /* Number of the last completed batch         */
+        int     next_pending;   /* Is the next batch already waiting?         */
+} ____cacheline_maxaligned_in_smp;
+
+/* Is batch a before batch b ? */
+static inline int rcu_batch_before(long a, long b)
+{
+        return (a - b) < 0;
+}
+
+/* Is batch a after batch b ? */
+static inline int rcu_batch_after(long a, long b)
+{
+        return (a - b) > 0;
+}
+
+/*
+ * Per-CPU data for Read-Copy UPdate.
+ * nxtlist - new callbacks are added here
+ * curlist - current batch for which quiescent cycle started if any
+ */
+struct rcu_data {
+        /* 1) quiescent state handling : */
+        long            quiescbatch;     /* Batch # for grace period */
+        int             passed_quiesc;   /* User-mode/idle loop etc. */
+        int             qs_pending;      /* core waits for quiesc state */
+
+        /* 2) batch handling */
+        long            batch;           /* Batch # for current RCU batch */
+        struct rcu_head *nxtlist;
+        struct rcu_head **nxttail;
+        struct rcu_head *curlist;
+        struct rcu_head **curtail;
+        struct rcu_head *donelist;
+        struct rcu_head **donetail;
+        int cpu;
+};
+
+DECLARE_PER_CPU(struct rcu_data, rcu_data);
+DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
+extern struct rcu_ctrlblk rcu_ctrlblk;
+extern struct rcu_ctrlblk rcu_bh_ctrlblk;
+
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+static inline void rcu_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+        rdp->passed_quiesc = 1;
+}
+static inline void rcu_bh_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+        rdp->passed_quiesc = 1;
+}
+
+static inline int __rcu_pending(struct rcu_ctrlblk *rcp,
+                                                struct rcu_data *rdp)
+{
+        /* This cpu has pending rcu entries and the grace period
+         * for them has completed.
+         */
+        if (rdp->curlist && !rcu_batch_before(rcp->completed, rdp->batch))
+                return 1;
+
+        /* This cpu has no pending entries, but there are new entries */
+        if (!rdp->curlist && rdp->nxtlist)
+                return 1;
+
+        /* This cpu has finished callbacks to invoke */
+        if (rdp->donelist)
+                return 1;
+
+        /* The rcu core waits for a quiescent state from the cpu */
+        if (rdp->quiescbatch != rcp->cur || rdp->qs_pending)
+                return 1;
+
+        /* nothing to do */
+        return 0;
+}
+
+static inline int rcu_pending(int cpu)
+{
+        return __rcu_pending(&rcu_ctrlblk, &per_cpu(rcu_data, cpu)) ||
+                __rcu_pending(&rcu_bh_ctrlblk, &per_cpu(rcu_bh_data, cpu));
+}
+
+/**
+ * rcu_read_lock - mark the beginning of an RCU read-side critical section.
+ *
+ * When synchronize_kernel() is invoked on one CPU while other CPUs
+ * are within RCU read-side critical sections, then the
+ * synchronize_kernel() is guaranteed to block until after all the other
+ * CPUs exit their critical sections.  Similarly, if call_rcu() is invoked
+ * on one CPU while other CPUs are within RCU read-side critical
+ * sections, invocation of the corresponding RCU callback is deferred
+ * until after the all the other CPUs exit their critical sections.
+ *
+ * Note, however, that RCU callbacks are permitted to run concurrently
+ * with RCU read-side critical sections.  One way that this can happen
+ * is via the following sequence of events: (1) CPU 0 enters an RCU
+ * read-side critical section, (2) CPU 1 invokes call_rcu() to register
+ * an RCU callback, (3) CPU 0 exits the RCU read-side critical section,
+ * (4) CPU 2 enters a RCU read-side critical section, (5) the RCU
+ * callback is invoked.  This is legal, because the RCU read-side critical
+ * section that was running concurrently with the call_rcu() (and which
+ * therefore might be referencing something that the corresponding RCU
+ * callback would free up) has completed before the corresponding
+ * RCU callback is invoked.
+ *
+ * RCU read-side critical sections may be nested.  Any deferred actions
+ * will be deferred until the outermost RCU read-side critical section
+ * completes.
+ *
+ * It is illegal to block while in an RCU read-side critical section.
+ */
+#define rcu_read_lock()         preempt_disable()
+
+/**
+ * rcu_read_unlock - marks the end of an RCU read-side critical section.
+ *
+ * See rcu_read_lock() for more information.
+ */
+#define rcu_read_unlock()       preempt_enable()
+
+/*
+ * So where is rcu_write_lock()?  It does not exist, as there is no
+ * way for writers to lock out RCU readers.  This is a feature, not
+ * a bug -- this property is what provides RCU's performance benefits.
+ * Of course, writers must coordinate with each other.  The normal
+ * spinlock primitives work well for this, but any other technique may be
+ * used as well.  RCU does not care how the writers keep out of each
+ * others' way, as long as they do so.
+ */
+
+/**
+ * rcu_read_lock_bh - mark the beginning of a softirq-only RCU critical section
+ *
+ * This is equivalent of rcu_read_lock(), but to be used when updates
+ * are being done using call_rcu_bh(). Since call_rcu_bh() callbacks
+ * consider completion of a softirq handler to be a quiescent state,
+ * a process in RCU read-side critical section must be protected by
+ * disabling softirqs. Read-side critical sections in interrupt context
+ * can use just rcu_read_lock().
+ *
+ */
+#define rcu_read_lock_bh()      local_bh_disable()
+
+/*
+ * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
+ *
+ * See rcu_read_lock_bh() for more information.
+ */
+#define rcu_read_unlock_bh()    local_bh_enable()
+
+/**
+ * rcu_dereference - fetch an RCU-protected pointer in an
+ * RCU read-side critical section.  This pointer may later
+ * be safely dereferenced.
+ *
+ * Inserts memory barriers on architectures that require them
+ * (currently only the Alpha), and, more importantly, documents
+ * exactly which pointers are protected by RCU.
+ */
+
+#define rcu_dereference(p)     ({ \
+                                typeof(p) _________p1 = p; \
+                                smp_read_barrier_depends(); \
+                                (_________p1); \
+                                })
+
+/**
+ * rcu_assign_pointer - assign (publicize) a pointer to a newly
+ * initialized structure that will be dereferenced by RCU read-side
+ * critical sections.  Returns the value assigned.
+ *
+ * Inserts memory barriers on architectures that require them
+ * (pretty much all of them other than x86), and also prevents
+ * the compiler from reordering the code that initializes the
+ * structure after the pointer assignment.  More importantly, this
+ * call documents which pointers will be dereferenced by RCU read-side
+ * code.
+ */
+
+#define rcu_assign_pointer(p, v)        ({ \
+                                                smp_wmb(); \
+                                                (p) = (v); \
+                                        })
+
+extern void rcu_init(void);
+extern void rcu_check_callbacks(int cpu, int user);
+extern void rcu_restart_cpu(int cpu);
+
+/* Exported interfaces */
+extern void FASTCALL(call_rcu(struct rcu_head *head, 
+                                void (*func)(struct rcu_head *head)));
+extern void FASTCALL(call_rcu_bh(struct rcu_head *head,
+                                void (*func)(struct rcu_head *head)));
+extern void synchronize_kernel(void);
+
+#endif /* __KERNEL__ */
+#endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
new file mode 100644
index 000000000000..d60fafc8bdc5
--- /dev/null
+++ b/include/linux/reboot.h
@@ -0,0 +1,56 @@
+#ifndef _LINUX_REBOOT_H
+#define _LINUX_REBOOT_H
+
+/*
+ * Magic values required to use _reboot() system call.
+ */
+
+#define LINUX_REBOOT_MAGIC1     0xfee1dead
+#define LINUX_REBOOT_MAGIC2     672274793
+#define LINUX_REBOOT_MAGIC2A    85072278
+#define LINUX_REBOOT_MAGIC2B    369367448
+#define LINUX_REBOOT_MAGIC2C    537993216
+
+
+/*
+ * Commands accepted by the _reboot() system call.
+ *
+ * RESTART     Restart system using default command and mode.
+ * HALT        Stop OS and give system control to ROM monitor, if any.
+ * CAD_ON      Ctrl-Alt-Del sequence causes RESTART command.
+ * CAD_OFF     Ctrl-Alt-Del sequence sends SIGINT to init task.
+ * POWER_OFF   Stop OS and remove all power from system, if possible.
+ * RESTART2    Restart system using given command string.
+ * SW_SUSPEND  Suspend system using software suspend if compiled in.
+ * KEXEC       Restart system using a previously loaded Linux kernel
+ */
+
+#define LINUX_REBOOT_CMD_RESTART        0x01234567
+#define LINUX_REBOOT_CMD_HALT           0xCDEF0123
+#define LINUX_REBOOT_CMD_CAD_ON         0x89ABCDEF
+#define LINUX_REBOOT_CMD_CAD_OFF        0x00000000
+#define LINUX_REBOOT_CMD_POWER_OFF      0x4321FEDC
+#define LINUX_REBOOT_CMD_RESTART2       0xA1B2C3D4
+#define LINUX_REBOOT_CMD_SW_SUSPEND     0xD000FCE2
+#define LINUX_REBOOT_CMD_KEXEC          0x45584543
+
+
+#ifdef __KERNEL__
+
+#include <linux/notifier.h>
+
+extern int register_reboot_notifier(struct notifier_block *);
+extern int unregister_reboot_notifier(struct notifier_block *);
+
+
+/*
+ * Architecture-specific implementations of sys_reboot commands.
+ */
+
+extern void machine_restart(char *cmd);
+extern void machine_halt(void);
+extern void machine_power_off(void);
+
+#endif
+
+#endif /* _LINUX_REBOOT_H */
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
new file mode 100644
index 000000000000..a57e973af0bd
--- /dev/null
+++ b/include/linux/reiserfs_acl.h
@@ -0,0 +1,89 @@
+#include <linux/init.h>
+#include <linux/posix_acl.h>
+#include <linux/xattr_acl.h>
+
+#define REISERFS_ACL_VERSION    0x0001
+
+typedef struct {
+        __u16           e_tag;
+        __u16           e_perm;
+        __u32           e_id;
+} reiserfs_acl_entry;
+
+typedef struct {
+        __u16           e_tag;
+        __u16           e_perm;
+} reiserfs_acl_entry_short;
+
+typedef struct {
+        __u32           a_version;
+} reiserfs_acl_header;
+
+static inline size_t reiserfs_acl_size(int count)
+{
+        if (count <= 4) {
+                return sizeof(reiserfs_acl_header) +
+                       count * sizeof(reiserfs_acl_entry_short);
+        } else {
+                return sizeof(reiserfs_acl_header) +
+                       4 * sizeof(reiserfs_acl_entry_short) +
+                       (count - 4) * sizeof(reiserfs_acl_entry);
+        }
+}
+
+static inline int reiserfs_acl_count(size_t size)
+{
+        ssize_t s;
+        size -= sizeof(reiserfs_acl_header);
+        s = size - 4 * sizeof(reiserfs_acl_entry_short);
+        if (s < 0) {
+                if (size % sizeof(reiserfs_acl_entry_short))
+                        return -1;
+                return size / sizeof(reiserfs_acl_entry_short);
+        } else {
+                if (s % sizeof(reiserfs_acl_entry))
+                        return -1;
+                return s / sizeof(reiserfs_acl_entry) + 4;
+        }
+}
+
+
+#ifdef CONFIG_REISERFS_FS_POSIX_ACL
+struct posix_acl * reiserfs_get_acl(struct inode *inode, int type);
+int reiserfs_acl_chmod (struct inode *inode);
+int reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct inode *inode);
+int reiserfs_cache_default_acl (struct inode *dir);
+extern int reiserfs_xattr_posix_acl_init (void) __init;
+extern int reiserfs_xattr_posix_acl_exit (void);
+extern struct reiserfs_xattr_handler posix_acl_default_handler;
+extern struct reiserfs_xattr_handler posix_acl_access_handler;
+#else
+
+#define reiserfs_get_acl NULL
+#define reiserfs_cache_default_acl(inode) 0
+
+static inline int
+reiserfs_xattr_posix_acl_init (void)
+{
+    return 0;
+}
+
+static inline int
+reiserfs_xattr_posix_acl_exit (void)
+{
+    return 0;
+}
+
+static inline int
+reiserfs_acl_chmod (struct inode *inode)
+{
+    return 0;
+}
+
+static inline int
+reiserfs_inherit_default_acl (const struct inode *dir, struct dentry *dentry, struct inode *inode)
+{
+    return 0;
+}
+
+#endif
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
new file mode 100644
index 000000000000..bccff8b17dc4
--- /dev/null
+++ b/include/linux/reiserfs_fs.h
@@ -0,0 +1,2255 @@
+/*
+ * Copyright 1996, 1997, 1998 Hans Reiser, see reiserfs/README for licensing and copyright details
+ */
+
+                                /* this file has an amazingly stupid
+                                   name, yura please fix it to be
+                                   reiserfs.h, and merge all the rest
+                                   of our .h files that are in this
+                                   directory into it.  */
+
+
+#ifndef _LINUX_REISER_FS_H
+#define _LINUX_REISER_FS_H
+
+#include <linux/types.h>
+#ifdef __KERNEL__
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/workqueue.h>
+#include <asm/unaligned.h>
+#include <linux/bitops.h>
+#include <linux/proc_fs.h>
+#include <linux/smp_lock.h>
+#include <linux/buffer_head.h>
+#include <linux/reiserfs_fs_i.h>
+#include <linux/reiserfs_fs_sb.h>
+#endif
+
+/*
+ *  include/linux/reiser_fs.h
+ *
+ *  Reiser File System constants and structures
+ *
+ */
+
+/* in reading the #defines, it may help to understand that they employ
+   the following abbreviations:
+
+   B = Buffer
+   I = Item header
+   H = Height within the tree (should be changed to LEV)
+   N = Number of the item in the node
+   STAT = stat data
+   DEH = Directory Entry Header
+   EC = Entry Count
+   E = Entry number
+   UL = Unsigned Long
+   BLKH = BLocK Header
+   UNFM = UNForMatted node
+   DC = Disk Child
+   P = Path
+
+   These #defines are named by concatenating these abbreviations,
+   where first comes the arguments, and last comes the return value,
+   of the macro.
+
+*/
+
+#define USE_INODE_GENERATION_COUNTER
+
+#define REISERFS_PREALLOCATE
+#define DISPLACE_NEW_PACKING_LOCALITIES
+#define PREALLOCATION_SIZE 9
+
+/* n must be power of 2 */
+#define _ROUND_UP(x,n) (((x)+(n)-1u) & ~((n)-1u))
+
+// to be ok for alpha and others we have to align structures to 8 byte
+// boundary.
+// FIXME: do not change 4 by anything else: there is code which relies on that
+#define ROUND_UP(x) _ROUND_UP(x,8LL)
+
+/* debug levels.  Right now, CONFIG_REISERFS_CHECK means print all debug
+** messages.
+*/
+#define REISERFS_DEBUG_CODE 5 /* extra messages to help find/debug errors */ 
+
+void reiserfs_warning (struct super_block *s, const char * fmt, ...);
+/* assertions handling */
+
+/** always check a condition and panic if it's false. */
+#define RASSERT( cond, format, args... )                                        \
+if( !( cond ) )                                                                 \
+  reiserfs_panic( NULL, "reiserfs[%i]: assertion " #cond " failed at "  \
+                  __FILE__ ":%i:%s: " format "\n",              \
+                  in_interrupt() ? -1 : current -> pid, __LINE__ , __FUNCTION__ , ##args )
+
+#if defined( CONFIG_REISERFS_CHECK )
+#define RFALSE( cond, format, args... ) RASSERT( !( cond ), format, ##args )
+#else
+#define RFALSE( cond, format, args... ) do {;} while( 0 )
+#endif
+
+#define CONSTF __attribute_const__
+/*
+ * Disk Data Structures
+ */
+
+/***************************************************************************/
+/*                             SUPER BLOCK                                 */
+/***************************************************************************/
+
+/*
+ * Structure of super block on disk, a version of which in RAM is often accessed as REISERFS_SB(s)->s_rs
+ * the version in RAM is part of a larger structure containing fields never written to disk.
+ */
+#define UNSET_HASH 0 // read_super will guess about, what hash names
+                     // in directories were sorted with
+#define TEA_HASH  1
+#define YURA_HASH 2
+#define R5_HASH   3
+#define DEFAULT_HASH R5_HASH
+
+
+struct journal_params {
+    __u32 jp_journal_1st_block;       /* where does journal start from on its
+                                       * device */
+    __u32 jp_journal_dev;             /* journal device st_rdev */
+    __u32 jp_journal_size;            /* size of the journal */
+    __u32 jp_journal_trans_max;       /* max number of blocks in a transaction. */
+    __u32 jp_journal_magic;           /* random value made on fs creation (this
+                                       * was sb_journal_block_count) */
+    __u32 jp_journal_max_batch;       /* max number of blocks to batch into a
+                                       * trans */
+    __u32 jp_journal_max_commit_age;  /* in seconds, how old can an async
+                                       * commit be */
+    __u32 jp_journal_max_trans_age;   /* in seconds, how old can a transaction
+                                       * be */
+};
+
+/* this is the super from 3.5.X, where X >= 10 */
+struct reiserfs_super_block_v1
+{
+    __u32 s_block_count;           /* blocks count         */
+    __u32 s_free_blocks;           /* free blocks count    */
+    __u32 s_root_block;            /* root block number    */
+    struct journal_params s_journal;
+    __u16 s_blocksize;             /* block size */
+    __u16 s_oid_maxsize;           /* max size of object id array, see
+                                    * get_objectid() commentary  */
+    __u16 s_oid_cursize;           /* current size of object id array */
+    __u16 s_umount_state;          /* this is set to 1 when filesystem was
+                                    * umounted, to 2 - when not */    
+    char s_magic[10];              /* reiserfs magic string indicates that
+                                    * file system is reiserfs:
+                                    * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
+    __u16 s_fs_state;              /* it is set to used by fsck to mark which
+                                    * phase of rebuilding is done */
+    __u32 s_hash_function_code;    /* indicate, what hash function is being use
+                                    * to sort names in a directory*/
+    __u16 s_tree_height;           /* height of disk tree */
+    __u16 s_bmap_nr;               /* amount of bitmap blocks needed to address
+                                    * each block of file system */
+    __u16 s_version;               /* this field is only reliable on filesystem
+                                    * with non-standard journal */
+    __u16 s_reserved_for_journal;  /* size in blocks of journal area on main
+                                    * device, we need to keep after
+                                    * making fs with non-standard journal */    
+} __attribute__ ((__packed__));
+
+#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
+
+/* this is the on disk super block */
+struct reiserfs_super_block
+{
+    struct reiserfs_super_block_v1 s_v1;
+    __u32 s_inode_generation;
+    __u32 s_flags;                  /* Right now used only by inode-attributes, if enabled */
+    unsigned char s_uuid[16];       /* filesystem unique identifier */
+    unsigned char s_label[16];      /* filesystem volume label */
+    char s_unused[88] ;             /* zero filled by mkreiserfs and
+                                     * reiserfs_convert_objectid_map_v1()
+                                     * so any additions must be updated
+                                     * there as well. */
+}  __attribute__ ((__packed__));
+
+#define SB_SIZE (sizeof(struct reiserfs_super_block))
+
+#define REISERFS_VERSION_1 0
+#define REISERFS_VERSION_2 2
+
+
+// on-disk super block fields converted to cpu form
+#define SB_DISK_SUPER_BLOCK(s) (REISERFS_SB(s)->s_rs)
+#define SB_V1_DISK_SUPER_BLOCK(s) (&(SB_DISK_SUPER_BLOCK(s)->s_v1))
+#define SB_BLOCKSIZE(s) \
+        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_blocksize))
+#define SB_BLOCK_COUNT(s) \
+        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_block_count))
+#define SB_FREE_BLOCKS(s) \
+        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks))
+#define SB_REISERFS_MAGIC(s) \
+        (SB_V1_DISK_SUPER_BLOCK(s)->s_magic)
+#define SB_ROOT_BLOCK(s) \
+        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_root_block))
+#define SB_TREE_HEIGHT(s) \
+        le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height))
+#define SB_REISERFS_STATE(s) \
+        le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state))
+#define SB_VERSION(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_version))
+#define SB_BMAP_NR(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr))
+
+#define PUT_SB_BLOCK_COUNT(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_block_count = cpu_to_le32(val); } while (0)
+#define PUT_SB_FREE_BLOCKS(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks = cpu_to_le32(val); } while (0)
+#define PUT_SB_ROOT_BLOCK(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_root_block = cpu_to_le32(val); } while (0)
+#define PUT_SB_TREE_HEIGHT(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height = cpu_to_le16(val); } while (0)
+#define PUT_SB_REISERFS_STATE(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0) 
+#define PUT_SB_VERSION(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_version = cpu_to_le16(val); } while (0)
+#define PUT_SB_BMAP_NR(s, val) \
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr = cpu_to_le16 (val); } while (0)
+
+
+#define SB_ONDISK_JP(s) (&SB_V1_DISK_SUPER_BLOCK(s)->s_journal)
+#define SB_ONDISK_JOURNAL_SIZE(s) \
+         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_size))
+#define SB_ONDISK_JOURNAL_1st_BLOCK(s) \
+         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_1st_block))
+#define SB_ONDISK_JOURNAL_DEVICE(s) \
+         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_dev))
+#define SB_ONDISK_RESERVED_FOR_JOURNAL(s) \
+         le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_reserved_for_journal))
+
+#define is_block_in_log_or_reserved_area(s, block) \
+         block >= SB_JOURNAL_1st_RESERVED_BLOCK(s) \
+         && block < SB_JOURNAL_1st_RESERVED_BLOCK(s) +  \
+         ((!is_reiserfs_jr(SB_DISK_SUPER_BLOCK(s)) ? \
+         SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s))) 
+
+
+
+                                /* used by gcc */
+#define REISERFS_SUPER_MAGIC 0x52654973
+                                /* used by file system utilities that
+                                   look at the superblock, etc. */
+#define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
+#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
+#define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
+
+int is_reiserfs_3_5 (struct reiserfs_super_block * rs);
+int is_reiserfs_3_6 (struct reiserfs_super_block * rs);
+int is_reiserfs_jr (struct reiserfs_super_block * rs);
+
+/* ReiserFS leaves the first 64k unused, so that partition labels have
+   enough space.  If someone wants to write a fancy bootloader that
+   needs more than 64k, let us know, and this will be increased in size.
+   This number must be larger than than the largest block size on any
+   platform, or code will break.  -Hans */
+#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
+#define REISERFS_FIRST_BLOCK unused_define
+#define REISERFS_JOURNAL_OFFSET_IN_BYTES REISERFS_DISK_OFFSET_IN_BYTES
+
+/* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */
+#define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)
+
+// reiserfs internal error code (used by search_by_key adn fix_nodes))
+#define CARRY_ON      0
+#define REPEAT_SEARCH -1
+#define IO_ERROR      -2
+#define NO_DISK_SPACE -3
+#define NO_BALANCING_NEEDED  (-4)
+#define NO_MORE_UNUSED_CONTIGUOUS_BLOCKS (-5)
+#define QUOTA_EXCEEDED -6
+
+typedef __u32 b_blocknr_t;
+typedef __u32 unp_t;
+
+struct unfm_nodeinfo {
+    unp_t unfm_nodenum;
+    unsigned short unfm_freespace;
+};
+
+/* there are two formats of keys: 3.5 and 3.6
+ */
+#define KEY_FORMAT_3_5 0
+#define KEY_FORMAT_3_6 1
+
+/* there are two stat datas */
+#define STAT_DATA_V1 0
+#define STAT_DATA_V2 1
+
+
+static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode)
+{
+        return container_of(inode, struct reiserfs_inode_info, vfs_inode);
+}
+
+static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+/** this says about version of key of all items (but stat data) the
+    object consists of */
+#define get_inode_item_key_version( inode )                                    \
+    ((REISERFS_I(inode)->i_flags & i_item_key_version_mask) ? KEY_FORMAT_3_6 : KEY_FORMAT_3_5)
+
+#define set_inode_item_key_version( inode, version )                           \
+         ({ if((version)==KEY_FORMAT_3_6)                                      \
+                REISERFS_I(inode)->i_flags |= i_item_key_version_mask;      \
+            else                                                               \
+                REISERFS_I(inode)->i_flags &= ~i_item_key_version_mask; })
+
+#define get_inode_sd_version(inode)                                            \
+    ((REISERFS_I(inode)->i_flags & i_stat_data_version_mask) ? STAT_DATA_V2 : STAT_DATA_V1)
+
+#define set_inode_sd_version(inode, version)                                   \
+         ({ if((version)==STAT_DATA_V2)                                        \
+                REISERFS_I(inode)->i_flags |= i_stat_data_version_mask;     \
+            else                                                               \
+                REISERFS_I(inode)->i_flags &= ~i_stat_data_version_mask; })
+
+/* This is an aggressive tail suppression policy, I am hoping it
+   improves our benchmarks. The principle behind it is that percentage
+   space saving is what matters, not absolute space saving.  This is
+   non-intuitive, but it helps to understand it if you consider that the
+   cost to access 4 blocks is not much more than the cost to access 1
+   block, if you have to do a seek and rotate.  A tail risks a
+   non-linear disk access that is significant as a percentage of total
+   time cost for a 4 block file and saves an amount of space that is
+   less significant as a percentage of space, or so goes the hypothesis.
+   -Hans */
+#define STORE_TAIL_IN_UNFM_S1(n_file_size,n_tail_size,n_block_size) \
+(\
+  (!(n_tail_size)) || \
+  (((n_tail_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) || \
+   ( (n_file_size) >= (n_block_size) * 4 ) || \
+   ( ( (n_file_size) >= (n_block_size) * 3 ) && \
+     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size))/4) ) || \
+   ( ( (n_file_size) >= (n_block_size) * 2 ) && \
+     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size))/2) ) || \
+   ( ( (n_file_size) >= (n_block_size) ) && \
+     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size) * 3)/4) ) ) \
+)
+
+/* Another strategy for tails, this one means only create a tail if all the
+   file would fit into one DIRECT item.
+   Primary intention for this one is to increase performance by decreasing
+   seeking.
+*/   
+#define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) \
+(\
+  (!(n_tail_size)) || \
+  (((n_file_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) ) \
+)
+
+
+
+/*
+ * values for s_umount_state field
+ */
+#define REISERFS_VALID_FS    1
+#define REISERFS_ERROR_FS    2
+
+//
+// there are 5 item types currently
+//
+#define TYPE_STAT_DATA 0
+#define TYPE_INDIRECT 1
+#define TYPE_DIRECT 2
+#define TYPE_DIRENTRY 3 
+#define TYPE_MAXTYPE 3 
+#define TYPE_ANY 15 // FIXME: comment is required
+
+/***************************************************************************/
+/*                       KEY & ITEM HEAD                                   */
+/***************************************************************************/
+
+//
+// directories use this key as well as old files
+//
+struct offset_v1 {
+    __u32 k_offset;
+    __u32 k_uniqueness;
+} __attribute__ ((__packed__));
+
+struct offset_v2 {
+#ifdef __LITTLE_ENDIAN
+            /* little endian version */
+            __u64 k_offset:60;
+            __u64 k_type: 4;
+#else
+            /* big endian version */
+            __u64 k_type: 4;
+            __u64 k_offset:60;
+#endif
+} __attribute__ ((__packed__));
+
+#ifndef __LITTLE_ENDIAN
+typedef union {
+    struct offset_v2 offset_v2;
+    __u64 linear;
+} __attribute__ ((__packed__)) offset_v2_esafe_overlay;
+
+static inline __u16 offset_v2_k_type( const struct offset_v2 *v2 )
+{
+    offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2;
+    tmp.linear = le64_to_cpu( tmp.linear );
+    return (tmp.offset_v2.k_type <= TYPE_MAXTYPE)?tmp.offset_v2.k_type:TYPE_ANY;
+}
+ 
+static inline void set_offset_v2_k_type( struct offset_v2 *v2, int type )
+{
+    offset_v2_esafe_overlay *tmp = (offset_v2_esafe_overlay *)v2;
+    tmp->linear = le64_to_cpu(tmp->linear);
+    tmp->offset_v2.k_type = type;
+    tmp->linear = cpu_to_le64(tmp->linear);
+}
+ 
+static inline loff_t offset_v2_k_offset( const struct offset_v2 *v2 )
+{
+    offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2;
+    tmp.linear = le64_to_cpu( tmp.linear );
+    return tmp.offset_v2.k_offset;
+}
+
+static inline void set_offset_v2_k_offset( struct offset_v2 *v2, loff_t offset ){
+    offset_v2_esafe_overlay *tmp = (offset_v2_esafe_overlay *)v2;
+    tmp->linear = le64_to_cpu(tmp->linear);
+    tmp->offset_v2.k_offset = offset;
+    tmp->linear = cpu_to_le64(tmp->linear);
+}
+#else
+# define offset_v2_k_type(v2)           ((v2)->k_type)
+# define set_offset_v2_k_type(v2,val)   (offset_v2_k_type(v2) = (val))
+# define offset_v2_k_offset(v2)         ((v2)->k_offset)
+# define set_offset_v2_k_offset(v2,val) (offset_v2_k_offset(v2) = (val))
+#endif
+
+/* Key of an item determines its location in the S+tree, and
+   is composed of 4 components */
+struct reiserfs_key {
+    __u32 k_dir_id;    /* packing locality: by default parent
+                          directory object id */
+    __u32 k_objectid;  /* object identifier */
+    union {
+        struct offset_v1 k_offset_v1;
+        struct offset_v2 k_offset_v2;
+    } __attribute__ ((__packed__)) u;
+} __attribute__ ((__packed__));
+
+
+struct cpu_key {
+    struct reiserfs_key on_disk_key;
+    int version;
+    int key_length; /* 3 in all cases but direct2indirect and
+                       indirect2direct conversion */
+};
+
+/* Our function for comparing keys can compare keys of different
+   lengths.  It takes as a parameter the length of the keys it is to
+   compare.  These defines are used in determining what is to be passed
+   to it as that parameter. */
+#define REISERFS_FULL_KEY_LEN     4
+#define REISERFS_SHORT_KEY_LEN    2
+
+/* The result of the key compare */
+#define FIRST_GREATER 1
+#define SECOND_GREATER -1
+#define KEYS_IDENTICAL 0
+#define KEY_FOUND 1
+#define KEY_NOT_FOUND 0
+
+#define KEY_SIZE (sizeof(struct reiserfs_key))
+#define SHORT_KEY_SIZE (sizeof (__u32) + sizeof (__u32))
+
+/* return values for search_by_key and clones */
+#define ITEM_FOUND 1
+#define ITEM_NOT_FOUND 0
+#define ENTRY_FOUND 1
+#define ENTRY_NOT_FOUND 0
+#define DIRECTORY_NOT_FOUND -1
+#define REGULAR_FILE_FOUND -2
+#define DIRECTORY_FOUND -3
+#define BYTE_FOUND 1
+#define BYTE_NOT_FOUND 0
+#define FILE_NOT_FOUND -1
+
+#define POSITION_FOUND 1
+#define POSITION_NOT_FOUND 0
+
+// return values for reiserfs_find_entry and search_by_entry_key
+#define NAME_FOUND 1
+#define NAME_NOT_FOUND 0
+#define GOTO_PREVIOUS_ITEM 2
+#define NAME_FOUND_INVISIBLE 3
+
+/*  Everything in the filesystem is stored as a set of items.  The
+    item head contains the key of the item, its free space (for
+    indirect items) and specifies the location of the item itself
+    within the block.  */
+
+struct item_head
+{
+        /* Everything in the tree is found by searching for it based on
+         * its key.*/
+        struct reiserfs_key ih_key;
+        union {
+                /* The free space in the last unformatted node of an
+                   indirect item if this is an indirect item.  This
+                   equals 0xFFFF iff this is a direct item or stat data
+                   item. Note that the key, not this field, is used to
+                   determine the item type, and thus which field this
+                   union contains. */
+                __u16 ih_free_space_reserved; 
+                /* Iff this is a directory item, this field equals the
+                   number of directory entries in the directory item. */
+                __u16 ih_entry_count; 
+        } __attribute__ ((__packed__)) u;
+        __u16 ih_item_len;           /* total size of the item body */
+        __u16 ih_item_location;      /* an offset to the item body
+                                      * within the block */
+        __u16 ih_version;            /* 0 for all old items, 2 for new
+                                        ones. Highest bit is set by fsck
+                                        temporary, cleaned after all
+                                        done */
+} __attribute__ ((__packed__));
+/* size of item header     */
+#define IH_SIZE (sizeof(struct item_head))
+
+#define ih_free_space(ih)            le16_to_cpu((ih)->u.ih_free_space_reserved)
+#define ih_version(ih)               le16_to_cpu((ih)->ih_version)
+#define ih_entry_count(ih)           le16_to_cpu((ih)->u.ih_entry_count)
+#define ih_location(ih)              le16_to_cpu((ih)->ih_item_location)
+#define ih_item_len(ih)              le16_to_cpu((ih)->ih_item_len)
+
+#define put_ih_free_space(ih, val)   do { (ih)->u.ih_free_space_reserved = cpu_to_le16(val); } while(0)
+#define put_ih_version(ih, val)      do { (ih)->ih_version = cpu_to_le16(val); } while (0)
+#define put_ih_entry_count(ih, val)  do { (ih)->u.ih_entry_count = cpu_to_le16(val); } while (0)
+#define put_ih_location(ih, val)     do { (ih)->ih_item_location = cpu_to_le16(val); } while (0)
+#define put_ih_item_len(ih, val)     do { (ih)->ih_item_len = cpu_to_le16(val); } while (0)
+
+
+#define unreachable_item(ih) (ih_version(ih) & (1 << 15))
+
+#define get_ih_free_space(ih) (ih_version (ih) == KEY_FORMAT_3_6 ? 0 : ih_free_space (ih))
+#define set_ih_free_space(ih,val) put_ih_free_space((ih), ((ih_version(ih) == KEY_FORMAT_3_6) ? 0 : (val)))
+
+/* these operate on indirect items, where you've got an array of ints
+** at a possibly unaligned location.  These are a noop on ia32
+** 
+** p is the array of __u32, i is the index into the array, v is the value
+** to store there.
+*/
+#define get_block_num(p, i) le32_to_cpu(get_unaligned((p) + (i)))
+#define put_block_num(p, i, v) put_unaligned(cpu_to_le32(v), (p) + (i))
+
+//
+// in old version uniqueness field shows key type
+//
+#define V1_SD_UNIQUENESS 0
+#define V1_INDIRECT_UNIQUENESS 0xfffffffe
+#define V1_DIRECT_UNIQUENESS 0xffffffff
+#define V1_DIRENTRY_UNIQUENESS 500
+#define V1_ANY_UNIQUENESS 555 // FIXME: comment is required
+
+//
+// here are conversion routines
+//
+static inline int uniqueness2type (__u32 uniqueness) CONSTF;
+static inline int uniqueness2type (__u32 uniqueness)
+{
+    switch ((int)uniqueness) {
+    case V1_SD_UNIQUENESS: return TYPE_STAT_DATA;
+    case V1_INDIRECT_UNIQUENESS: return TYPE_INDIRECT;
+    case V1_DIRECT_UNIQUENESS: return TYPE_DIRECT;
+    case V1_DIRENTRY_UNIQUENESS: return TYPE_DIRENTRY;
+    default:
+            reiserfs_warning (NULL, "vs-500: unknown uniqueness %d",
+                              uniqueness);
+        case V1_ANY_UNIQUENESS:
+            return TYPE_ANY;
+    }
+}
+
+static inline __u32 type2uniqueness (int type) CONSTF;
+static inline __u32 type2uniqueness (int type)
+{
+    switch (type) {
+    case TYPE_STAT_DATA: return V1_SD_UNIQUENESS;
+    case TYPE_INDIRECT: return V1_INDIRECT_UNIQUENESS;
+    case TYPE_DIRECT: return V1_DIRECT_UNIQUENESS;
+    case TYPE_DIRENTRY: return V1_DIRENTRY_UNIQUENESS;
+    default:
+            reiserfs_warning (NULL, "vs-501: unknown type %d", type);
+        case TYPE_ANY:
+            return V1_ANY_UNIQUENESS;
+    }
+}
+
+//
+// key is pointer to on disk key which is stored in le, result is cpu,
+// there is no way to get version of object from key, so, provide
+// version to these defines
+//
+static inline loff_t le_key_k_offset (int version, const struct reiserfs_key * key)
+{
+    return (version == KEY_FORMAT_3_5) ?
+        le32_to_cpu( key->u.k_offset_v1.k_offset ) :
+        offset_v2_k_offset( &(key->u.k_offset_v2) );
+}
+
+static inline loff_t le_ih_k_offset (const struct item_head * ih)
+{
+    return le_key_k_offset (ih_version (ih), &(ih->ih_key));
+}
+
+static inline loff_t le_key_k_type (int version, const struct reiserfs_key * key)
+{
+    return (version == KEY_FORMAT_3_5) ?
+        uniqueness2type( le32_to_cpu( key->u.k_offset_v1.k_uniqueness)) :
+        offset_v2_k_type( &(key->u.k_offset_v2) );
+}
+
+static inline loff_t le_ih_k_type (const struct item_head * ih)
+{
+    return le_key_k_type (ih_version (ih), &(ih->ih_key));
+}
+
+
+static inline void set_le_key_k_offset (int version, struct reiserfs_key * key, loff_t offset)
+{
+    (version == KEY_FORMAT_3_5) ?
+        (void)(key->u.k_offset_v1.k_offset = cpu_to_le32 (offset)) : /* jdm check */
+        (void)(set_offset_v2_k_offset( &(key->u.k_offset_v2), offset ));
+}
+
+
+static inline void set_le_ih_k_offset (struct item_head * ih, loff_t offset)
+{
+    set_le_key_k_offset (ih_version (ih), &(ih->ih_key), offset);
+}
+
+
+static inline void set_le_key_k_type (int version, struct reiserfs_key * key, int type)
+{
+    (version == KEY_FORMAT_3_5) ?
+        (void)(key->u.k_offset_v1.k_uniqueness = cpu_to_le32(type2uniqueness(type))):
+        (void)(set_offset_v2_k_type( &(key->u.k_offset_v2), type ));
+}
+static inline void set_le_ih_k_type (struct item_head * ih, int type)
+{
+    set_le_key_k_type (ih_version (ih), &(ih->ih_key), type);
+}
+
+
+#define is_direntry_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRENTRY)
+#define is_direct_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRECT)
+#define is_indirect_le_key(version,key) (le_key_k_type (version, key) == TYPE_INDIRECT)
+#define is_statdata_le_key(version,key) (le_key_k_type (version, key) == TYPE_STAT_DATA)
+
+//
+// item header has version.
+//
+#define is_direntry_le_ih(ih) is_direntry_le_key (ih_version (ih), &((ih)->ih_key))
+#define is_direct_le_ih(ih) is_direct_le_key (ih_version (ih), &((ih)->ih_key))
+#define is_indirect_le_ih(ih) is_indirect_le_key (ih_version(ih), &((ih)->ih_key))
+#define is_statdata_le_ih(ih) is_statdata_le_key (ih_version (ih), &((ih)->ih_key))
+
+
+
+//
+// key is pointer to cpu key, result is cpu
+//
+static inline loff_t cpu_key_k_offset (const struct cpu_key * key)
+{
+    return (key->version == KEY_FORMAT_3_5) ?
+        key->on_disk_key.u.k_offset_v1.k_offset :
+        key->on_disk_key.u.k_offset_v2.k_offset;
+}
+
+static inline loff_t cpu_key_k_type (const struct cpu_key * key)
+{
+    return (key->version == KEY_FORMAT_3_5) ?
+        uniqueness2type (key->on_disk_key.u.k_offset_v1.k_uniqueness) :
+        key->on_disk_key.u.k_offset_v2.k_type;
+}
+
+static inline void set_cpu_key_k_offset (struct cpu_key * key, loff_t offset)
+{
+    (key->version == KEY_FORMAT_3_5) ?
+        (key->on_disk_key.u.k_offset_v1.k_offset = offset) :
+        (key->on_disk_key.u.k_offset_v2.k_offset = offset);
+}
+
+
+static inline void set_cpu_key_k_type (struct cpu_key * key, int type)
+{
+    (key->version == KEY_FORMAT_3_5) ?
+        (key->on_disk_key.u.k_offset_v1.k_uniqueness = type2uniqueness (type)):
+        (key->on_disk_key.u.k_offset_v2.k_type = type);
+}
+
+
+static inline void cpu_key_k_offset_dec (struct cpu_key * key)
+{
+    if (key->version == KEY_FORMAT_3_5)
+        key->on_disk_key.u.k_offset_v1.k_offset --;
+    else
+        key->on_disk_key.u.k_offset_v2.k_offset --;
+}
+
+
+#define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)
+#define is_direct_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRECT)
+#define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)
+#define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)
+
+
+/* are these used ? */
+#define is_direntry_cpu_ih(ih) (is_direntry_cpu_key (&((ih)->ih_key)))
+#define is_direct_cpu_ih(ih) (is_direct_cpu_key (&((ih)->ih_key)))
+#define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))
+#define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))
+
+
+
+
+
+#define I_K_KEY_IN_ITEM(p_s_ih, p_s_key, n_blocksize) \
+    ( ! COMP_SHORT_KEYS(p_s_ih, p_s_key) && \
+          I_OFF_BYTE_IN_ITEM(p_s_ih, k_offset (p_s_key), n_blocksize) )
+
+/* maximal length of item */ 
+#define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
+#define MIN_ITEM_LEN 1
+
+
+/* object identifier for root dir */
+#define REISERFS_ROOT_OBJECTID 2
+#define REISERFS_ROOT_PARENT_OBJECTID 1
+extern struct reiserfs_key root_key;
+
+
+
+
+/* 
+ * Picture represents a leaf of the S+tree
+ *  ______________________________________________________
+ * |      |  Array of     |                   |           |
+ * |Block |  Object-Item  |      F r e e      |  Objects- |
+ * | head |  Headers      |     S p a c e     |   Items   |
+ * |______|_______________|___________________|___________|
+ */
+
+/* Header of a disk block.  More precisely, header of a formatted leaf
+   or internal node, and not the header of an unformatted node. */
+struct block_head {       
+  __u16 blk_level;        /* Level of a block in the tree. */
+  __u16 blk_nr_item;      /* Number of keys/items in a block. */
+  __u16 blk_free_space;   /* Block free space in bytes. */
+  __u16 blk_reserved;
+                                /* dump this in v4/planA */
+  struct reiserfs_key  blk_right_delim_key; /* kept only for compatibility */
+};
+
+#define BLKH_SIZE                     (sizeof(struct block_head))
+#define blkh_level(p_blkh)            (le16_to_cpu((p_blkh)->blk_level))
+#define blkh_nr_item(p_blkh)          (le16_to_cpu((p_blkh)->blk_nr_item))
+#define blkh_free_space(p_blkh)       (le16_to_cpu((p_blkh)->blk_free_space))
+#define blkh_reserved(p_blkh)         (le16_to_cpu((p_blkh)->blk_reserved))
+#define set_blkh_level(p_blkh,val)    ((p_blkh)->blk_level = cpu_to_le16(val))
+#define set_blkh_nr_item(p_blkh,val)  ((p_blkh)->blk_nr_item = cpu_to_le16(val))
+#define set_blkh_free_space(p_blkh,val) ((p_blkh)->blk_free_space = cpu_to_le16(val))
+#define set_blkh_reserved(p_blkh,val) ((p_blkh)->blk_reserved = cpu_to_le16(val))
+#define blkh_right_delim_key(p_blkh)  ((p_blkh)->blk_right_delim_key)
+#define set_blkh_right_delim_key(p_blkh,val)  ((p_blkh)->blk_right_delim_key = val)
+
+/*
+ * values for blk_level field of the struct block_head
+ */
+
+#define FREE_LEVEL 0 /* when node gets removed from the tree its
+                        blk_level is set to FREE_LEVEL. It is then
+                        used to see whether the node is still in the
+                        tree */
+
+#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level.*/
+
+/* Given the buffer head of a formatted node, resolve to the block head of that node. */
+#define B_BLK_HEAD(p_s_bh)            ((struct block_head *)((p_s_bh)->b_data))
+/* Number of items that are in buffer. */
+#define B_NR_ITEMS(p_s_bh)            (blkh_nr_item(B_BLK_HEAD(p_s_bh)))
+#define B_LEVEL(p_s_bh)               (blkh_level(B_BLK_HEAD(p_s_bh)))
+#define B_FREE_SPACE(p_s_bh)          (blkh_free_space(B_BLK_HEAD(p_s_bh)))
+
+#define PUT_B_NR_ITEMS(p_s_bh,val)    do { set_blkh_nr_item(B_BLK_HEAD(p_s_bh),val); } while (0)
+#define PUT_B_LEVEL(p_s_bh,val)       do { set_blkh_level(B_BLK_HEAD(p_s_bh),val); } while (0)
+#define PUT_B_FREE_SPACE(p_s_bh,val)  do { set_blkh_free_space(B_BLK_HEAD(p_s_bh),val); } while (0)
+
+
+/* Get right delimiting key. -- little endian */
+#define B_PRIGHT_DELIM_KEY(p_s_bh)   (&(blk_right_delim_key(B_BLK_HEAD(p_s_bh))
+
+/* Does the buffer contain a disk leaf. */
+#define B_IS_ITEMS_LEVEL(p_s_bh)     (B_LEVEL(p_s_bh) == DISK_LEAF_NODE_LEVEL)
+
+/* Does the buffer contain a disk internal node */
+#define B_IS_KEYS_LEVEL(p_s_bh)      (B_LEVEL(p_s_bh) > DISK_LEAF_NODE_LEVEL \
+                                            && B_LEVEL(p_s_bh) <= MAX_HEIGHT)
+
+
+
+
+/***************************************************************************/
+/*                             STAT DATA                                   */
+/***************************************************************************/
+
+
+//
+// old stat data is 32 bytes long. We are going to distinguish new one by
+// different size
+//
+struct stat_data_v1
+{
+    __u16 sd_mode;      /* file type, permissions */
+    __u16 sd_nlink;     /* number of hard links */
+    __u16 sd_uid;               /* owner */
+    __u16 sd_gid;               /* group */
+    __u32 sd_size;      /* file size */
+    __u32 sd_atime;     /* time of last access */
+    __u32 sd_mtime;     /* time file was last modified  */
+    __u32 sd_ctime;     /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
+    union {
+        __u32 sd_rdev;
+        __u32 sd_blocks;        /* number of blocks file uses */
+    } __attribute__ ((__packed__)) u;
+    __u32 sd_first_direct_byte; /* first byte of file which is stored
+                                   in a direct item: except that if it
+                                   equals 1 it is a symlink and if it
+                                   equals ~(__u32)0 there is no
+                                   direct item.  The existence of this
+                                   field really grates on me. Let's
+                                   replace it with a macro based on
+                                   sd_size and our tail suppression
+                                   policy.  Someday.  -Hans */
+} __attribute__ ((__packed__));
+
+#define SD_V1_SIZE              (sizeof(struct stat_data_v1))
+#define stat_data_v1(ih)        (ih_version (ih) == KEY_FORMAT_3_5)
+#define sd_v1_mode(sdp)         (le16_to_cpu((sdp)->sd_mode))
+#define set_sd_v1_mode(sdp,v)   ((sdp)->sd_mode = cpu_to_le16(v))
+#define sd_v1_nlink(sdp)        (le16_to_cpu((sdp)->sd_nlink))
+#define set_sd_v1_nlink(sdp,v)  ((sdp)->sd_nlink = cpu_to_le16(v))
+#define sd_v1_uid(sdp)          (le16_to_cpu((sdp)->sd_uid))
+#define set_sd_v1_uid(sdp,v)    ((sdp)->sd_uid = cpu_to_le16(v))
+#define sd_v1_gid(sdp)          (le16_to_cpu((sdp)->sd_gid))
+#define set_sd_v1_gid(sdp,v)    ((sdp)->sd_gid = cpu_to_le16(v))
+#define sd_v1_size(sdp)         (le32_to_cpu((sdp)->sd_size))
+#define set_sd_v1_size(sdp,v)   ((sdp)->sd_size = cpu_to_le32(v))
+#define sd_v1_atime(sdp)        (le32_to_cpu((sdp)->sd_atime))
+#define set_sd_v1_atime(sdp,v)  ((sdp)->sd_atime = cpu_to_le32(v))
+#define sd_v1_mtime(sdp)        (le32_to_cpu((sdp)->sd_mtime))
+#define set_sd_v1_mtime(sdp,v)  ((sdp)->sd_mtime = cpu_to_le32(v))
+#define sd_v1_ctime(sdp)        (le32_to_cpu((sdp)->sd_ctime))
+#define set_sd_v1_ctime(sdp,v)  ((sdp)->sd_ctime = cpu_to_le32(v))
+#define sd_v1_rdev(sdp)         (le32_to_cpu((sdp)->u.sd_rdev))
+#define set_sd_v1_rdev(sdp,v)   ((sdp)->u.sd_rdev = cpu_to_le32(v))
+#define sd_v1_blocks(sdp)       (le32_to_cpu((sdp)->u.sd_blocks))
+#define set_sd_v1_blocks(sdp,v) ((sdp)->u.sd_blocks = cpu_to_le32(v))
+#define sd_v1_first_direct_byte(sdp) \
+                                (le32_to_cpu((sdp)->sd_first_direct_byte))
+#define set_sd_v1_first_direct_byte(sdp,v) \
+                                ((sdp)->sd_first_direct_byte = cpu_to_le32(v))
+
+#include <linux/ext2_fs.h>
+
+/* inode flags stored in sd_attrs (nee sd_reserved) */
+
+/* we want common flags to have the same values as in ext2,
+   so chattr(1) will work without problems */
+#define REISERFS_IMMUTABLE_FL EXT2_IMMUTABLE_FL
+#define REISERFS_APPEND_FL    EXT2_APPEND_FL
+#define REISERFS_SYNC_FL      EXT2_SYNC_FL
+#define REISERFS_NOATIME_FL   EXT2_NOATIME_FL
+#define REISERFS_NODUMP_FL    EXT2_NODUMP_FL
+#define REISERFS_SECRM_FL     EXT2_SECRM_FL
+#define REISERFS_UNRM_FL      EXT2_UNRM_FL
+#define REISERFS_COMPR_FL     EXT2_COMPR_FL
+#define REISERFS_NOTAIL_FL    EXT2_NOTAIL_FL
+
+/* persistent flags that file inherits from the parent directory */
+#define REISERFS_INHERIT_MASK ( REISERFS_IMMUTABLE_FL | \
+                                REISERFS_SYNC_FL |      \
+                                REISERFS_NOATIME_FL |   \
+                                REISERFS_NODUMP_FL |    \
+                                REISERFS_SECRM_FL |     \
+                                REISERFS_COMPR_FL |     \
+                                REISERFS_NOTAIL_FL )
+
+/* Stat Data on disk (reiserfs version of UFS disk inode minus the
+   address blocks) */
+struct stat_data {
+    __u16 sd_mode;      /* file type, permissions */
+    __u16 sd_attrs;     /* persistent inode flags */
+    __u32 sd_nlink;     /* number of hard links */
+    __u64 sd_size;      /* file size */
+    __u32 sd_uid;               /* owner */
+    __u32 sd_gid;               /* group */
+    __u32 sd_atime;     /* time of last access */
+    __u32 sd_mtime;     /* time file was last modified  */
+    __u32 sd_ctime;     /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
+    __u32 sd_blocks;
+    union {
+        __u32 sd_rdev;
+        __u32 sd_generation;
+      //__u32 sd_first_direct_byte; 
+      /* first byte of file which is stored in a
+                                       direct item: except that if it equals 1
+                                       it is a symlink and if it equals
+                                       ~(__u32)0 there is no direct item.  The
+                                       existence of this field really grates
+                                       on me. Let's replace it with a macro
+                                       based on sd_size and our tail
+                                       suppression policy? */
+  } __attribute__ ((__packed__)) u;
+} __attribute__ ((__packed__));
+//
+// this is 44 bytes long
+//
+#define SD_SIZE (sizeof(struct stat_data))
+#define SD_V2_SIZE              SD_SIZE
+#define stat_data_v2(ih)        (ih_version (ih) == KEY_FORMAT_3_6)
+#define sd_v2_mode(sdp)         (le16_to_cpu((sdp)->sd_mode))
+#define set_sd_v2_mode(sdp,v)   ((sdp)->sd_mode = cpu_to_le16(v))
+/* sd_reserved */
+/* set_sd_reserved */
+#define sd_v2_nlink(sdp)        (le32_to_cpu((sdp)->sd_nlink))
+#define set_sd_v2_nlink(sdp,v)  ((sdp)->sd_nlink = cpu_to_le32(v))
+#define sd_v2_size(sdp)         (le64_to_cpu((sdp)->sd_size))
+#define set_sd_v2_size(sdp,v)   ((sdp)->sd_size = cpu_to_le64(v))
+#define sd_v2_uid(sdp)          (le32_to_cpu((sdp)->sd_uid))
+#define set_sd_v2_uid(sdp,v)    ((sdp)->sd_uid = cpu_to_le32(v))
+#define sd_v2_gid(sdp)          (le32_to_cpu((sdp)->sd_gid))
+#define set_sd_v2_gid(sdp,v)    ((sdp)->sd_gid = cpu_to_le32(v))
+#define sd_v2_atime(sdp)        (le32_to_cpu((sdp)->sd_atime))
+#define set_sd_v2_atime(sdp,v)  ((sdp)->sd_atime = cpu_to_le32(v))
+#define sd_v2_mtime(sdp)        (le32_to_cpu((sdp)->sd_mtime))
+#define set_sd_v2_mtime(sdp,v)  ((sdp)->sd_mtime = cpu_to_le32(v))
+#define sd_v2_ctime(sdp)        (le32_to_cpu((sdp)->sd_ctime))
+#define set_sd_v2_ctime(sdp,v)  ((sdp)->sd_ctime = cpu_to_le32(v))
+#define sd_v2_blocks(sdp)       (le32_to_cpu((sdp)->sd_blocks))
+#define set_sd_v2_blocks(sdp,v) ((sdp)->sd_blocks = cpu_to_le32(v))
+#define sd_v2_rdev(sdp)         (le32_to_cpu((sdp)->u.sd_rdev))
+#define set_sd_v2_rdev(sdp,v)   ((sdp)->u.sd_rdev = cpu_to_le32(v))
+#define sd_v2_generation(sdp)   (le32_to_cpu((sdp)->u.sd_generation))
+#define set_sd_v2_generation(sdp,v) ((sdp)->u.sd_generation = cpu_to_le32(v))
+#define sd_v2_attrs(sdp)         (le16_to_cpu((sdp)->sd_attrs))
+#define set_sd_v2_attrs(sdp,v)   ((sdp)->sd_attrs = cpu_to_le16(v))
+
+
+/***************************************************************************/
+/*                      DIRECTORY STRUCTURE                                */
+/***************************************************************************/
+/* 
+   Picture represents the structure of directory items
+   ________________________________________________
+   |  Array of     |   |     |        |       |   |
+   | directory     |N-1| N-2 | ....   |   1st |0th|
+   | entry headers |   |     |        |       |   |
+   |_______________|___|_____|________|_______|___|
+                    <----   directory entries         ------>
+
+ First directory item has k_offset component 1. We store "." and ".."
+ in one item, always, we never split "." and ".." into differing
+ items.  This makes, among other things, the code for removing
+ directories simpler. */
+#define SD_OFFSET  0
+#define SD_UNIQUENESS 0
+#define DOT_OFFSET 1
+#define DOT_DOT_OFFSET 2
+#define DIRENTRY_UNIQUENESS 500
+
+/* */
+#define FIRST_ITEM_OFFSET 1
+
+/*
+   Q: How to get key of object pointed to by entry from entry?  
+
+   A: Each directory entry has its header. This header has deh_dir_id and deh_objectid fields, those are key
+      of object, entry points to */
+
+/* NOT IMPLEMENTED:   
+   Directory will someday contain stat data of object */
+
+
+
+struct reiserfs_de_head
+{
+  __u32 deh_offset;             /* third component of the directory entry key */
+  __u32 deh_dir_id;             /* objectid of the parent directory of the object, that is referenced
+                                           by directory entry */
+  __u32 deh_objectid;           /* objectid of the object, that is referenced by directory entry */
+  __u16 deh_location;           /* offset of name in the whole item */
+  __u16 deh_state;              /* whether 1) entry contains stat data (for future), and 2) whether
+                                           entry is hidden (unlinked) */
+} __attribute__ ((__packed__));
+#define DEH_SIZE                  sizeof(struct reiserfs_de_head)
+#define deh_offset(p_deh)         (le32_to_cpu((p_deh)->deh_offset))
+#define deh_dir_id(p_deh)         (le32_to_cpu((p_deh)->deh_dir_id))
+#define deh_objectid(p_deh)       (le32_to_cpu((p_deh)->deh_objectid))
+#define deh_location(p_deh)       (le16_to_cpu((p_deh)->deh_location))
+#define deh_state(p_deh)          (le16_to_cpu((p_deh)->deh_state))
+
+#define put_deh_offset(p_deh,v)   ((p_deh)->deh_offset = cpu_to_le32((v)))
+#define put_deh_dir_id(p_deh,v)   ((p_deh)->deh_dir_id = cpu_to_le32((v)))
+#define put_deh_objectid(p_deh,v) ((p_deh)->deh_objectid = cpu_to_le32((v)))
+#define put_deh_location(p_deh,v) ((p_deh)->deh_location = cpu_to_le16((v)))
+#define put_deh_state(p_deh,v)    ((p_deh)->deh_state = cpu_to_le16((v)))
+
+/* empty directory contains two entries "." and ".." and their headers */
+#define EMPTY_DIR_SIZE \
+(DEH_SIZE * 2 + ROUND_UP (strlen (".")) + ROUND_UP (strlen ("..")))
+
+/* old format directories have this size when empty */
+#define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
+
+#define DEH_Statdata 0                  /* not used now */
+#define DEH_Visible 2
+
+/* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */
+#if BITS_PER_LONG == 64 || defined(__s390__) || defined(__hppa__)
+#   define ADDR_UNALIGNED_BITS  (3)
+#endif
+
+/* These are only used to manipulate deh_state.
+ * Because of this, we'll use the ext2_ bit routines,
+ * since they are little endian */
+#ifdef ADDR_UNALIGNED_BITS
+
+#   define aligned_address(addr)           ((void *)((long)(addr) & ~((1UL << ADDR_UNALIGNED_BITS) - 1)))
+#   define unaligned_offset(addr)          (((int)((long)(addr) & ((1 << ADDR_UNALIGNED_BITS) - 1))) << 3)
+
+#   define set_bit_unaligned(nr, addr)     ext2_set_bit((nr) + unaligned_offset(addr), aligned_address(addr))
+#   define clear_bit_unaligned(nr, addr)   ext2_clear_bit((nr) + unaligned_offset(addr), aligned_address(addr))
+#   define test_bit_unaligned(nr, addr)    ext2_test_bit((nr) + unaligned_offset(addr), aligned_address(addr))
+
+#else
+
+#   define set_bit_unaligned(nr, addr)     ext2_set_bit(nr, addr)
+#   define clear_bit_unaligned(nr, addr)   ext2_clear_bit(nr, addr)
+#   define test_bit_unaligned(nr, addr)    ext2_test_bit(nr, addr)
+
+#endif
+
+#define mark_de_with_sd(deh)        set_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
+#define mark_de_without_sd(deh)     clear_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
+#define mark_de_visible(deh)        set_bit_unaligned (DEH_Visible, &((deh)->deh_state))
+#define mark_de_hidden(deh)         clear_bit_unaligned (DEH_Visible, &((deh)->deh_state))
+
+#define de_with_sd(deh)             test_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
+#define de_visible(deh)             test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
+#define de_hidden(deh)              !test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
+
+extern void make_empty_dir_item_v1 (char * body, __u32 dirid, __u32 objid,
+                                    __u32 par_dirid, __u32 par_objid);
+extern void make_empty_dir_item (char * body, __u32 dirid, __u32 objid,
+                                 __u32 par_dirid, __u32 par_objid);
+
+/* array of the entry headers */
+ /* get item body */
+#define B_I_PITEM(bh,ih) ( (bh)->b_data + ih_location(ih) )
+#define B_I_DEH(bh,ih) ((struct reiserfs_de_head *)(B_I_PITEM(bh,ih)))
+
+/* length of the directory entry in directory item. This define
+   calculates length of i-th directory entry using directory entry
+   locations from dir entry head. When it calculates length of 0-th
+   directory entry, it uses length of whole item in place of entry
+   location of the non-existent following entry in the calculation.
+   See picture above.*/
+/*
+#define I_DEH_N_ENTRY_LENGTH(ih,deh,i) \
+((i) ? (deh_location((deh)-1) - deh_location((deh))) : (ih_item_len((ih)) - deh_location((deh))))
+*/
+static inline int entry_length (const struct buffer_head * bh, 
+                                                                const struct item_head * ih, int pos_in_item)
+{
+    struct reiserfs_de_head * deh;
+
+    deh = B_I_DEH (bh, ih) + pos_in_item;
+    if (pos_in_item)
+        return deh_location(deh-1) - deh_location(deh);
+
+    return ih_item_len(ih) - deh_location(deh);
+}
+
+
+
+/* number of entries in the directory item, depends on ENTRY_COUNT being at the start of directory dynamic data. */
+#define I_ENTRY_COUNT(ih) (ih_entry_count((ih)))
+
+
+/* name by bh, ih and entry_num */
+#define B_I_E_NAME(bh,ih,entry_num) ((char *)(bh->b_data + ih_location(ih) + deh_location(B_I_DEH(bh,ih)+(entry_num))))
+
+// two entries per block (at least)
+#define REISERFS_MAX_NAME(block_size) 255
+
+
+/* this structure is used for operations on directory entries. It is
+   not a disk structure. */
+/* When reiserfs_find_entry or search_by_entry_key find directory
+   entry, they return filled reiserfs_dir_entry structure */
+struct reiserfs_dir_entry
+{
+  struct buffer_head * de_bh;
+  int de_item_num;
+  struct item_head * de_ih;
+  int de_entry_num;
+  struct reiserfs_de_head * de_deh;
+  int de_entrylen;
+  int de_namelen;
+  char * de_name;
+  char * de_gen_number_bit_string;
+
+  __u32 de_dir_id;
+  __u32 de_objectid;
+
+  struct cpu_key de_entry_key;
+};
+   
+/* these defines are useful when a particular member of a reiserfs_dir_entry is needed */
+
+/* pointer to file name, stored in entry */
+#define B_I_DEH_ENTRY_FILE_NAME(bh,ih,deh) (B_I_PITEM (bh, ih) + deh_location(deh))
+
+/* length of name */
+#define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \
+(I_DEH_N_ENTRY_LENGTH (ih, deh, entry_num) - (de_with_sd (deh) ? SD_SIZE : 0))
+
+
+
+/* hash value occupies bits from 7 up to 30 */
+#define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)
+/* generation number occupies 7 bits starting from 0 up to 6 */
+#define GET_GENERATION_NUMBER(offset) ((offset) & 0x7fLL)
+#define MAX_GENERATION_NUMBER  127
+
+#define SET_GENERATION_NUMBER(offset,gen_number) (GET_HASH_VALUE(offset)|(gen_number))
+
+
+/*
+ * Picture represents an internal node of the reiserfs tree
+ *  ______________________________________________________
+ * |      |  Array of     |  Array of         |  Free     |
+ * |block |    keys       |  pointers         | space     |
+ * | head |      N        |      N+1          |           |
+ * |______|_______________|___________________|___________|
+ */
+
+/***************************************************************************/
+/*                      DISK CHILD                                         */
+/***************************************************************************/
+/* Disk child pointer: The pointer from an internal node of the tree
+   to a node that is on disk. */
+struct disk_child {
+  __u32       dc_block_number;              /* Disk child's block number. */
+  __u16       dc_size;                      /* Disk child's used space.   */
+  __u16       dc_reserved;
+};
+
+#define DC_SIZE (sizeof(struct disk_child))
+#define dc_block_number(dc_p)   (le32_to_cpu((dc_p)->dc_block_number))
+#define dc_size(dc_p)           (le16_to_cpu((dc_p)->dc_size))
+#define put_dc_block_number(dc_p, val)   do { (dc_p)->dc_block_number = cpu_to_le32(val); } while(0)
+#define put_dc_size(dc_p, val)   do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)
+
+/* Get disk child by buffer header and position in the tree node. */
+#define B_N_CHILD(p_s_bh,n_pos)  ((struct disk_child *)\
+((p_s_bh)->b_data+BLKH_SIZE+B_NR_ITEMS(p_s_bh)*KEY_SIZE+DC_SIZE*(n_pos)))
+
+/* Get disk child number by buffer header and position in the tree node. */
+#define B_N_CHILD_NUM(p_s_bh,n_pos) (dc_block_number(B_N_CHILD(p_s_bh,n_pos)))
+#define PUT_B_N_CHILD_NUM(p_s_bh,n_pos, val) (put_dc_block_number(B_N_CHILD(p_s_bh,n_pos), val ))
+
+ /* maximal value of field child_size in structure disk_child */ 
+ /* child size is the combined size of all items and their headers */
+#define MAX_CHILD_SIZE(bh) ((int)( (bh)->b_size - BLKH_SIZE ))
+
+/* amount of used space in buffer (not including block head) */
+#define B_CHILD_SIZE(cur) (MAX_CHILD_SIZE(cur)-(B_FREE_SPACE(cur)))
+
+/* max and min number of keys in internal node */
+#define MAX_NR_KEY(bh) ( (MAX_CHILD_SIZE(bh)-DC_SIZE)/(KEY_SIZE+DC_SIZE) )
+#define MIN_NR_KEY(bh)    (MAX_NR_KEY(bh)/2)
+
+/***************************************************************************/
+/*                      PATH STRUCTURES AND DEFINES                        */
+/***************************************************************************/
+
+
+/* Search_by_key fills up the path from the root to the leaf as it descends the tree looking for the
+   key.  It uses reiserfs_bread to try to find buffers in the cache given their block number.  If it
+   does not find them in the cache it reads them from disk.  For each node search_by_key finds using
+   reiserfs_bread it then uses bin_search to look through that node.  bin_search will find the
+   position of the block_number of the next node if it is looking through an internal node.  If it
+   is looking through a leaf node bin_search will find the position of the item which has key either
+   equal to given key, or which is the maximal key less than the given key. */
+
+struct  path_element  {
+  struct buffer_head *  pe_buffer;    /* Pointer to the buffer at the path in the tree. */
+  int                   pe_position;  /* Position in the tree node which is placed in the */
+                                      /* buffer above.                                  */
+};
+
+#define MAX_HEIGHT 5 /* maximal height of a tree. don't change this without changing JOURNAL_PER_BALANCE_CNT */
+#define EXTENDED_MAX_HEIGHT         7 /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */
+#define FIRST_PATH_ELEMENT_OFFSET   2 /* Must be equal to at least 2. */
+
+#define ILLEGAL_PATH_ELEMENT_OFFSET 1 /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */
+#define MAX_FEB_SIZE 6   /* this MUST be MAX_HEIGHT + 1. See about FEB below */
+
+
+
+/* We need to keep track of who the ancestors of nodes are.  When we
+   perform a search we record which nodes were visited while
+   descending the tree looking for the node we searched for. This list
+   of nodes is called the path.  This information is used while
+   performing balancing.  Note that this path information may become
+   invalid, and this means we must check it when using it to see if it
+   is still valid. You'll need to read search_by_key and the comments
+   in it, especially about decrement_counters_in_path(), to understand
+   this structure.  
+
+Paths make the code so much harder to work with and debug.... An
+enormous number of bugs are due to them, and trying to write or modify
+code that uses them just makes my head hurt.  They are based on an
+excessive effort to avoid disturbing the precious VFS code.:-( The
+gods only know how we are going to SMP the code that uses them.
+znodes are the way! */
+
+#define PATH_READA      0x1 /* do read ahead */
+#define PATH_READA_BACK 0x2 /* read backwards */
+
+struct  path {
+  int                   path_length;                            /* Length of the array above.   */
+  int                   reada;
+  struct  path_element  path_elements[EXTENDED_MAX_HEIGHT];     /* Array of the path elements.  */
+  int                   pos_in_item;
+};
+
+#define pos_in_item(path) ((path)->pos_in_item)
+
+#define INITIALIZE_PATH(var) \
+struct path var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
+
+/* Get path element by path and path position. */
+#define PATH_OFFSET_PELEMENT(p_s_path,n_offset)  ((p_s_path)->path_elements +(n_offset))
+
+/* Get buffer header at the path by path and path position. */
+#define PATH_OFFSET_PBUFFER(p_s_path,n_offset)   (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_buffer)
+
+/* Get position in the element at the path by path and path position. */
+#define PATH_OFFSET_POSITION(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_position)
+
+
+#define PATH_PLAST_BUFFER(p_s_path) (PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length))
+                                /* you know, to the person who didn't
+                                   write this the macro name does not
+                                   at first suggest what it does.
+                                   Maybe POSITION_FROM_PATH_END? Or
+                                   maybe we should just focus on
+                                   dumping paths... -Hans */
+#define PATH_LAST_POSITION(p_s_path) (PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length))
+
+
+#define PATH_PITEM_HEAD(p_s_path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path),PATH_LAST_POSITION(p_s_path))
+
+/* in do_balance leaf has h == 0 in contrast with path structure,
+   where root has level == 0. That is why we need these defines */
+#define PATH_H_PBUFFER(p_s_path, h) PATH_OFFSET_PBUFFER (p_s_path, p_s_path->path_length - (h)) /* tb->S[h] */
+#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)                  /* tb->F[h] or tb->S[0]->b_parent */
+#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))   
+#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)               /* tb->S[h]->b_item_order */
+
+#define PATH_H_PATH_OFFSET(p_s_path, n_h) ((p_s_path)->path_length - (n_h))
+
+#define get_last_bh(path) PATH_PLAST_BUFFER(path)
+#define get_ih(path) PATH_PITEM_HEAD(path)
+#define get_item_pos(path) PATH_LAST_POSITION(path)
+#define get_item(path) ((void *)B_N_PITEM(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION (path)))
+#define item_moved(ih,path) comp_items(ih, path)
+#define path_changed(ih,path) comp_items (ih, path)
+
+
+/***************************************************************************/
+/*                       MISC                                              */
+/***************************************************************************/
+
+/* Size of pointer to the unformatted node. */
+#define UNFM_P_SIZE (sizeof(unp_t))
+#define UNFM_P_SHIFT 2
+
+// in in-core inode key is stored on le form
+#define INODE_PKEY(inode) ((struct reiserfs_key *)(REISERFS_I(inode)->i_key))
+
+#define MAX_UL_INT 0xffffffff
+#define MAX_INT    0x7ffffff
+#define MAX_US_INT 0xffff
+
+// reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset
+#define U32_MAX (~(__u32)0)
+
+static inline loff_t max_reiserfs_offset (struct inode * inode)
+{
+    if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)
+        return (loff_t)U32_MAX;
+
+    return (loff_t)((~(__u64)0) >> 4);
+}
+
+
+/*#define MAX_KEY_UNIQUENESS    MAX_UL_INT*/
+#define MAX_KEY_OBJECTID        MAX_UL_INT
+
+
+#define MAX_B_NUM  MAX_UL_INT
+#define MAX_FC_NUM MAX_US_INT
+
+
+/* the purpose is to detect overflow of an unsigned short */
+#define REISERFS_LINK_MAX (MAX_US_INT - 1000)
+
+
+/* The following defines are used in reiserfs_insert_item and reiserfs_append_item  */
+#define REISERFS_KERNEL_MEM             0       /* reiserfs kernel memory mode  */
+#define REISERFS_USER_MEM               1       /* reiserfs user memory mode            */
+
+#define fs_generation(s) (REISERFS_SB(s)->s_generation_counter)
+#define get_generation(s) atomic_read (&fs_generation(s))
+#define FILESYSTEM_CHANGED_TB(tb)  (get_generation((tb)->tb_sb) != (tb)->fs_gen)
+#define __fs_changed(gen,s) (gen != get_generation (s))
+#define fs_changed(gen,s) ({cond_resched(); __fs_changed(gen, s);})
+
+
+/***************************************************************************/
+/*                  FIXATE NODES                                           */
+/***************************************************************************/
+
+#define VI_TYPE_LEFT_MERGEABLE 1
+#define VI_TYPE_RIGHT_MERGEABLE 2
+
+/* To make any changes in the tree we always first find node, that
+   contains item to be changed/deleted or place to insert a new
+   item. We call this node S. To do balancing we need to decide what
+   we will shift to left/right neighbor, or to a new node, where new
+   item will be etc. To make this analysis simpler we build virtual
+   node. Virtual node is an array of items, that will replace items of
+   node S. (For instance if we are going to delete an item, virtual
+   node does not contain it). Virtual node keeps information about
+   item sizes and types, mergeability of first and last items, sizes
+   of all entries in directory item. We use this array of items when
+   calculating what we can shift to neighbors and how many nodes we
+   have to have if we do not any shiftings, if we shift to left/right
+   neighbor or to both. */
+struct virtual_item
+{
+    int vi_index; // index in the array of item operations
+    unsigned short vi_type;     // left/right mergeability
+    unsigned short vi_item_len;           /* length of item that it will have after balancing */
+    struct item_head * vi_ih;
+    const char * vi_item;     // body of item (old or new)
+    const void * vi_new_data; // 0 always but paste mode
+    void * vi_uarea;    // item specific area
+};
+
+
+struct virtual_node
+{
+  char * vn_free_ptr;           /* this is a pointer to the free space in the buffer */
+  unsigned short vn_nr_item;    /* number of items in virtual node */
+  short vn_size;                /* size of node , that node would have if it has unlimited size and no balancing is performed */
+  short vn_mode;                /* mode of balancing (paste, insert, delete, cut) */
+  short vn_affected_item_num; 
+  short vn_pos_in_item;
+  struct item_head * vn_ins_ih; /* item header of inserted item, 0 for other modes */
+  const void * vn_data;
+  struct virtual_item * vn_vi;  /* array of items (including a new one, excluding item to be deleted) */
+};
+
+/* used by directory items when creating virtual nodes */
+struct direntry_uarea {
+    int flags;
+    __u16 entry_count;
+    __u16 entry_sizes[1];
+} __attribute__ ((__packed__)) ;
+
+
+/***************************************************************************/
+/*                  TREE BALANCE                                           */
+/***************************************************************************/
+
+/* This temporary structure is used in tree balance algorithms, and
+   constructed as we go to the extent that its various parts are
+   needed.  It contains arrays of nodes that can potentially be
+   involved in the balancing of node S, and parameters that define how
+   each of the nodes must be balanced.  Note that in these algorithms
+   for balancing the worst case is to need to balance the current node
+   S and the left and right neighbors and all of their parents plus
+   create a new node.  We implement S1 balancing for the leaf nodes
+   and S0 balancing for the internal nodes (S1 and S0 are defined in
+   our papers.)*/
+
+#define MAX_FREE_BLOCK 7        /* size of the array of buffers to free at end of do_balance */
+
+/* maximum number of FEB blocknrs on a single level */
+#define MAX_AMOUNT_NEEDED 2
+
+/* someday somebody will prefix every field in this struct with tb_ */
+struct tree_balance
+{
+  int tb_mode;
+  int need_balance_dirty;
+  struct super_block * tb_sb;
+  struct reiserfs_transaction_handle *transaction_handle ;
+  struct path * tb_path;
+  struct buffer_head * L[MAX_HEIGHT];        /* array of left neighbors of nodes in the path */
+  struct buffer_head * R[MAX_HEIGHT];        /* array of right neighbors of nodes in the path*/
+  struct buffer_head * FL[MAX_HEIGHT];       /* array of fathers of the left  neighbors      */
+  struct buffer_head * FR[MAX_HEIGHT];       /* array of fathers of the right neighbors      */
+  struct buffer_head * CFL[MAX_HEIGHT];      /* array of common parents of center node and its left neighbor  */
+  struct buffer_head * CFR[MAX_HEIGHT];      /* array of common parents of center node and its right neighbor */
+
+  struct buffer_head * FEB[MAX_FEB_SIZE]; /* array of empty buffers. Number of buffers in array equals
+                                             cur_blknum. */
+  struct buffer_head * used[MAX_FEB_SIZE];
+  struct buffer_head * thrown[MAX_FEB_SIZE];
+  int lnum[MAX_HEIGHT]; /* array of number of items which must be
+                           shifted to the left in order to balance the
+                           current node; for leaves includes item that
+                           will be partially shifted; for internal
+                           nodes, it is the number of child pointers
+                           rather than items. It includes the new item
+                           being created. The code sometimes subtracts
+                           one to get the number of wholly shifted
+                           items for other purposes. */
+  int rnum[MAX_HEIGHT]; /* substitute right for left in comment above */
+  int lkey[MAX_HEIGHT];               /* array indexed by height h mapping the key delimiting L[h] and
+                                               S[h] to its item number within the node CFL[h] */
+  int rkey[MAX_HEIGHT];               /* substitute r for l in comment above */
+  int insert_size[MAX_HEIGHT];        /* the number of bytes by we are trying to add or remove from
+                                               S[h]. A negative value means removing.  */
+  int blknum[MAX_HEIGHT];             /* number of nodes that will replace node S[h] after
+                                               balancing on the level h of the tree.  If 0 then S is
+                                               being deleted, if 1 then S is remaining and no new nodes
+                                               are being created, if 2 or 3 then 1 or 2 new nodes is
+                                               being created */
+
+  /* fields that are used only for balancing leaves of the tree */
+  int cur_blknum;       /* number of empty blocks having been already allocated                 */
+  int s0num;             /* number of items that fall into left most  node when S[0] splits     */
+  int s1num;             /* number of items that fall into first  new node when S[0] splits     */
+  int s2num;             /* number of items that fall into second new node when S[0] splits     */
+  int lbytes;            /* number of bytes which can flow to the left neighbor from the        left    */
+  /* most liquid item that cannot be shifted from S[0] entirely         */
+  /* if -1 then nothing will be partially shifted */
+  int rbytes;            /* number of bytes which will flow to the right neighbor from the right        */
+  /* most liquid item that cannot be shifted from S[0] entirely         */
+  /* if -1 then nothing will be partially shifted                           */
+  int s1bytes;          /* number of bytes which flow to the first  new node when S[0] splits   */
+                                /* note: if S[0] splits into 3 nodes, then items do not need to be cut  */
+  int s2bytes;
+  struct buffer_head * buf_to_free[MAX_FREE_BLOCK]; /* buffers which are to be freed after do_balance finishes by unfix_nodes */
+  char * vn_buf;                /* kmalloced memory. Used to create
+                                   virtual node and keep map of
+                                   dirtied bitmap blocks */
+  int vn_buf_size;              /* size of the vn_buf */
+  struct virtual_node * tb_vn;  /* VN starts after bitmap of bitmap blocks */
+
+  int fs_gen;                  /* saved value of `reiserfs_generation' counter
+                                  see FILESYSTEM_CHANGED() macro in reiserfs_fs.h */
+#ifdef DISPLACE_NEW_PACKING_LOCALITIES
+  struct reiserfs_key  key;           /* key pointer, to pass to block allocator or
+                                 another low-level subsystem */
+#endif
+} ;
+
+/* These are modes of balancing */
+
+/* When inserting an item. */
+#define M_INSERT        'i'
+/* When inserting into (directories only) or appending onto an already
+   existant item. */
+#define M_PASTE         'p'
+/* When deleting an item. */
+#define M_DELETE        'd'
+/* When truncating an item or removing an entry from a (directory) item. */
+#define M_CUT           'c'
+
+/* used when balancing on leaf level skipped (in reiserfsck) */
+#define M_INTERNAL      'n'
+
+/* When further balancing is not needed, then do_balance does not need
+   to be called. */
+#define M_SKIP_BALANCING                's'
+#define M_CONVERT       'v'
+
+/* modes of leaf_move_items */
+#define LEAF_FROM_S_TO_L 0
+#define LEAF_FROM_S_TO_R 1
+#define LEAF_FROM_R_TO_L 2
+#define LEAF_FROM_L_TO_R 3
+#define LEAF_FROM_S_TO_SNEW 4
+
+#define FIRST_TO_LAST 0
+#define LAST_TO_FIRST 1
+
+/* used in do_balance for passing parent of node information that has
+   been gotten from tb struct */
+struct buffer_info {
+    struct tree_balance * tb;
+    struct buffer_head * bi_bh;
+    struct buffer_head * bi_parent;
+    int bi_position;
+};
+
+
+/* there are 4 types of items: stat data, directory item, indirect, direct.
++-------------------+------------+--------------+------------+
+|                   |  k_offset  | k_uniqueness | mergeable? |
++-------------------+------------+--------------+------------+
+|     stat data     |   0        |      0       |   no       |
++-------------------+------------+--------------+------------+
+| 1st directory item| DOT_OFFSET |DIRENTRY_UNIQUENESS|   no       | 
+| non 1st directory | hash value |              |   yes      |
+|     item          |            |              |            |
++-------------------+------------+--------------+------------+
+| indirect item     | offset + 1 |TYPE_INDIRECT |   if this is not the first indirect item of the object
++-------------------+------------+--------------+------------+
+| direct item       | offset + 1 |TYPE_DIRECT   | if not this is not the first direct item of the object
++-------------------+------------+--------------+------------+
+*/
+
+struct item_operations {
+    int (*bytes_number) (struct item_head * ih, int block_size);
+    void (*decrement_key) (struct cpu_key *);
+    int (*is_left_mergeable) (struct reiserfs_key * ih, unsigned long bsize);
+    void (*print_item) (struct item_head *, char * item);
+    void (*check_item) (struct item_head *, char * item);
+
+    int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi, 
+                      int is_affected, int insert_size);
+    int (*check_left) (struct virtual_item * vi, int free, 
+                            int start_skip, int end_skip);
+    int (*check_right) (struct virtual_item * vi, int free);
+    int (*part_size) (struct virtual_item * vi, int from, int to);
+    int (*unit_num) (struct virtual_item * vi);
+    void (*print_vi) (struct virtual_item * vi);
+};
+
+
+extern struct item_operations * item_ops [TYPE_ANY + 1];
+
+#define op_bytes_number(ih,bsize)                    item_ops[le_ih_k_type (ih)]->bytes_number (ih, bsize)
+#define op_is_left_mergeable(key,bsize)              item_ops[le_key_k_type (le_key_version (key), key)]->is_left_mergeable (key, bsize)
+#define op_print_item(ih,item)                       item_ops[le_ih_k_type (ih)]->print_item (ih, item)
+#define op_check_item(ih,item)                       item_ops[le_ih_k_type (ih)]->check_item (ih, item)
+#define op_create_vi(vn,vi,is_affected,insert_size)  item_ops[le_ih_k_type ((vi)->vi_ih)]->create_vi (vn,vi,is_affected,insert_size)
+#define op_check_left(vi,free,start_skip,end_skip) item_ops[(vi)->vi_index]->check_left (vi, free, start_skip, end_skip)
+#define op_check_right(vi,free)                      item_ops[(vi)->vi_index]->check_right (vi, free)
+#define op_part_size(vi,from,to)                     item_ops[(vi)->vi_index]->part_size (vi, from, to)
+#define op_unit_num(vi)                              item_ops[(vi)->vi_index]->unit_num (vi)
+#define op_print_vi(vi)                              item_ops[(vi)->vi_index]->print_vi (vi)
+
+
+
+#define COMP_SHORT_KEYS comp_short_keys
+
+/* number of blocks pointed to by the indirect item */
+#define I_UNFM_NUM(p_s_ih)      ( ih_item_len(p_s_ih) / UNFM_P_SIZE )
+
+/* the used space within the unformatted node corresponding to pos within the item pointed to by ih */
+#define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size))
+
+/* number of bytes contained by the direct item or the unformatted nodes the indirect item points to */
+
+
+/* get the item header */ 
+#define B_N_PITEM_HEAD(bh,item_num) ( (struct item_head * )((bh)->b_data + BLKH_SIZE) + (item_num) )
+
+/* get key */
+#define B_N_PDELIM_KEY(bh,item_num) ( (struct reiserfs_key * )((bh)->b_data + BLKH_SIZE) + (item_num) )
+
+/* get the key */
+#define B_N_PKEY(bh,item_num) ( &(B_N_PITEM_HEAD(bh,item_num)->ih_key) )
+
+/* get item body */
+#define B_N_PITEM(bh,item_num) ( (bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(item_num))))
+
+/* get the stat data by the buffer header and the item order */
+#define B_N_STAT_DATA(bh,nr) \
+( (struct stat_data *)((bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(nr))) ) )
+
+    /* following defines use reiserfs buffer header and item header */
+
+/* get stat-data */
+#define B_I_STAT_DATA(bh, ih) ( (struct stat_data * )((bh)->b_data + ih_location(ih)) )
+
+// this is 3976 for size==4096
+#define MAX_DIRECT_ITEM_LEN(size) ((size) - BLKH_SIZE - 2*IH_SIZE - SD_SIZE - UNFM_P_SIZE)
+
+/* indirect items consist of entries which contain blocknrs, pos
+   indicates which entry, and B_I_POS_UNFM_POINTER resolves to the
+   blocknr contained by the entry pos points to */
+#define B_I_POS_UNFM_POINTER(bh,ih,pos) le32_to_cpu(*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)))
+#define PUT_B_I_POS_UNFM_POINTER(bh,ih,pos, val) do {*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)) = cpu_to_le32(val); } while (0)
+
+struct reiserfs_iget_args {
+    __u32 objectid ;
+    __u32 dirid ;
+} ;
+
+/***************************************************************************/
+/*                    FUNCTION DECLARATIONS                                */
+/***************************************************************************/
+
+/*#ifdef __KERNEL__*/
+#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)
+
+#define journal_trans_half(blocksize) \
+        ((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32))
+
+/* journal.c see journal.c for all the comments here */
+
+/* first block written in a commit.  */
+struct reiserfs_journal_desc {
+  __u32 j_trans_id ;                    /* id of commit */
+  __u32 j_len ;                 /* length of commit. len +1 is the commit block */
+  __u32 j_mount_id ;                            /* mount id of this trans*/
+  __u32 j_realblock[1] ; /* real locations for each block */
+} ;
+
+#define get_desc_trans_id(d)   le32_to_cpu((d)->j_trans_id)
+#define get_desc_trans_len(d)  le32_to_cpu((d)->j_len)
+#define get_desc_mount_id(d)   le32_to_cpu((d)->j_mount_id)
+
+#define set_desc_trans_id(d,val)       do { (d)->j_trans_id = cpu_to_le32 (val); } while (0)
+#define set_desc_trans_len(d,val)      do { (d)->j_len = cpu_to_le32 (val); } while (0)
+#define set_desc_mount_id(d,val)       do { (d)->j_mount_id = cpu_to_le32 (val); } while (0)
+
+/* last block written in a commit */
+struct reiserfs_journal_commit {
+  __u32 j_trans_id ;                    /* must match j_trans_id from the desc block */
+  __u32 j_len ;                 /* ditto */
+  __u32 j_realblock[1] ; /* real locations for each block */
+} ;
+
+#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)
+#define get_commit_trans_len(c)        le32_to_cpu((c)->j_len)
+#define get_commit_mount_id(c) le32_to_cpu((c)->j_mount_id)
+
+#define set_commit_trans_id(c,val)     do { (c)->j_trans_id = cpu_to_le32 (val); } while (0)
+#define set_commit_trans_len(c,val)    do { (c)->j_len = cpu_to_le32 (val); } while (0)
+
+/* this header block gets written whenever a transaction is considered fully flushed, and is more recent than the
+** last fully flushed transaction.  fully flushed means all the log blocks and all the real blocks are on disk,
+** and this transaction does not need to be replayed.
+*/
+struct reiserfs_journal_header {
+  __u32 j_last_flush_trans_id ;         /* id of last fully flushed transaction */
+  __u32 j_first_unflushed_offset ;      /* offset in the log of where to start replay after a crash */
+  __u32 j_mount_id ;
+  /* 12 */ struct journal_params jh_journal;
+} ;
+
+/* biggest tunable defines are right here */
+#define JOURNAL_BLOCK_COUNT 8192 /* number of blocks in the journal */
+#define JOURNAL_TRANS_MAX_DEFAULT 1024   /* biggest possible single transaction, don't change for now (8/3/99) */
+#define JOURNAL_TRANS_MIN_DEFAULT 256
+#define JOURNAL_MAX_BATCH_DEFAULT   900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */
+#define JOURNAL_MIN_RATIO 2
+#define JOURNAL_MAX_COMMIT_AGE 30 
+#define JOURNAL_MAX_TRANS_AGE 30
+#define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)
+#ifdef CONFIG_QUOTA
+#define REISERFS_QUOTA_TRANS_BLOCKS 2   /* We need to update data and inode (atime) */
+#define REISERFS_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*(JOURNAL_PER_BALANCE_CNT+2)+1)     /* 1 balancing, 1 bitmap, 1 data per write + stat data update */
+#else
+#define REISERFS_QUOTA_TRANS_BLOCKS 0
+#define REISERFS_QUOTA_INIT_BLOCKS 0
+#endif
+
+/* both of these can be as low as 1, or as high as you want.  The min is the
+** number of 4k bitmap nodes preallocated on mount. New nodes are allocated
+** as needed, and released when transactions are committed.  On release, if 
+** the current number of nodes is > max, the node is freed, otherwise, 
+** it is put on a free list for faster use later.
+*/
+#define REISERFS_MIN_BITMAP_NODES 10 
+#define REISERFS_MAX_BITMAP_NODES 100 
+
+#define JBH_HASH_SHIFT 13 /* these are based on journal hash size of 8192 */
+#define JBH_HASH_MASK 8191
+
+#define _jhashfn(sb,block)      \
+        (((unsigned long)sb>>L1_CACHE_SHIFT) ^ \
+         (((block)<<(JBH_HASH_SHIFT - 6)) ^ ((block) >> 13) ^ ((block) << (JBH_HASH_SHIFT - 12))))
+#define journal_hash(t,sb,block) ((t)[_jhashfn((sb),(block)) & JBH_HASH_MASK])
+
+// We need these to make journal.c code more readable
+#define journal_find_get_block(s, block) __find_get_block(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
+#define journal_getblk(s, block) __getblk(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
+#define journal_bread(s, block) __bread(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
+
+enum reiserfs_bh_state_bits {
+    BH_JDirty = BH_PrivateStart, /* buffer is in current transaction */
+    BH_JDirty_wait,
+    BH_JNew,                     /* disk block was taken off free list before
+                                  * being in a finished transaction, or
+                                  * written to disk. Can be reused immed. */
+    BH_JPrepared,
+    BH_JRestore_dirty,
+    BH_JTest, // debugging only will go away
+};
+
+BUFFER_FNS(JDirty, journaled);
+TAS_BUFFER_FNS(JDirty, journaled);
+BUFFER_FNS(JDirty_wait, journal_dirty);
+TAS_BUFFER_FNS(JDirty_wait, journal_dirty);
+BUFFER_FNS(JNew, journal_new);
+TAS_BUFFER_FNS(JNew, journal_new);
+BUFFER_FNS(JPrepared, journal_prepared);
+TAS_BUFFER_FNS(JPrepared, journal_prepared);
+BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
+TAS_BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
+BUFFER_FNS(JTest, journal_test);
+TAS_BUFFER_FNS(JTest, journal_test);
+
+/*
+** transaction handle which is passed around for all journal calls
+*/
+struct reiserfs_transaction_handle {
+  struct super_block *t_super ; /* super for this FS when journal_begin was
+                                   called. saves calls to reiserfs_get_super
+                                   also used by nested transactions to make
+                                   sure they are nesting on the right FS
+                                   _must_ be first in the handle
+                                */
+  int t_refcount;
+  int t_blocks_logged ;         /* number of blocks this writer has logged */
+  int t_blocks_allocated ;      /* number of blocks this writer allocated */
+  unsigned long t_trans_id ;    /* sanity check, equals the current trans id */
+  void *t_handle_save ;         /* save existing current->journal_info */
+  unsigned displace_new_blocks:1; /* if new block allocation occurres, that block
+                                   should be displaced from others */
+  struct list_head t_list;
+} ;
+
+/* used to keep track of ordered and tail writes, attached to the buffer
+ * head through b_journal_head.
+ */
+struct reiserfs_jh {
+    struct reiserfs_journal_list *jl;
+    struct buffer_head *bh;
+    struct list_head list;
+};
+
+void reiserfs_free_jh(struct buffer_head *bh);
+int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh);
+int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh);
+int journal_mark_dirty(struct reiserfs_transaction_handle *, struct super_block *, struct buffer_head *bh) ;
+
+static inline int
+reiserfs_file_data_log(struct inode *inode) {
+    if (reiserfs_data_log(inode->i_sb) ||
+       (REISERFS_I(inode)->i_flags & i_data_log))
+        return 1 ;
+    return 0 ;
+}
+
+static inline int reiserfs_transaction_running(struct super_block *s) {
+    struct reiserfs_transaction_handle *th = current->journal_info ;
+    if (th && th->t_super == s)
+        return 1 ;
+    if (th && th->t_super == NULL)
+        BUG();
+    return 0 ;
+}
+
+int reiserfs_async_progress_wait(struct super_block *s);
+
+struct reiserfs_transaction_handle *
+reiserfs_persistent_transaction(struct super_block *, int count);
+int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *);
+int reiserfs_commit_page(struct inode *inode, struct page *page,
+                unsigned from, unsigned to);
+int reiserfs_flush_old_commits(struct super_block *);
+int reiserfs_commit_for_inode(struct inode *) ;
+int  reiserfs_inode_needs_commit(struct inode *) ;
+void reiserfs_update_inode_transaction(struct inode *) ;
+void reiserfs_wait_on_write_block(struct super_block *s) ;
+void reiserfs_block_writes(struct reiserfs_transaction_handle *th) ;
+void reiserfs_allow_writes(struct super_block *s) ;
+void reiserfs_check_lock_depth(struct super_block *s, char *caller) ;
+int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh, int wait) ;
+void reiserfs_restore_prepared_buffer(struct super_block *, struct buffer_head *bh) ;
+int journal_init(struct super_block *, const char * j_dev_name, int old_format, unsigned int) ;
+int journal_release(struct reiserfs_transaction_handle*, struct super_block *) ;
+int journal_release_error(struct reiserfs_transaction_handle*, struct super_block *) ;
+int journal_end(struct reiserfs_transaction_handle *, struct super_block *, unsigned long) ;
+int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *, unsigned long) ;
+int journal_mark_freed(struct reiserfs_transaction_handle *, struct super_block *, b_blocknr_t blocknr) ;
+int journal_transaction_should_end(struct reiserfs_transaction_handle *, int) ;
+int reiserfs_in_journal(struct super_block *p_s_sb, int bmap_nr, int bit_nr, int searchall, b_blocknr_t *next) ;
+int journal_begin(struct reiserfs_transaction_handle *, struct super_block *p_s_sb, unsigned long) ;
+int journal_join_abort(struct reiserfs_transaction_handle *, struct super_block *p_s_sb, unsigned long) ;
+void reiserfs_journal_abort (struct super_block *sb, int errno);
+void reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...);
+int reiserfs_allocate_list_bitmaps(struct super_block *s, struct reiserfs_list_bitmap *, int) ;
+
+void add_save_link (struct reiserfs_transaction_handle * th,
+                                        struct inode * inode, int truncate);
+int remove_save_link (struct inode * inode, int truncate);
+
+/* objectid.c */
+__u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th);
+void reiserfs_release_objectid (struct reiserfs_transaction_handle *th, __u32 objectid_to_release);
+int reiserfs_convert_objectid_map_v1(struct super_block *) ;
+
+/* stree.c */
+int B_IS_IN_TREE(const struct buffer_head *);
+extern void copy_item_head(struct item_head * p_v_to,
+                                                                  const struct item_head * p_v_from);
+
+// first key is in cpu form, second - le
+extern int  comp_short_keys (const struct reiserfs_key * le_key,
+                                    const struct cpu_key * cpu_key);
+extern void le_key2cpu_key (struct cpu_key * to, const struct reiserfs_key * from);
+
+// both are in le form
+extern int comp_le_keys (const struct reiserfs_key *, const struct reiserfs_key *);
+extern int comp_short_le_keys (const struct reiserfs_key *, const struct reiserfs_key *);
+
+//
+// get key version from on disk key - kludge
+//
+static inline int le_key_version (const struct reiserfs_key * key)
+{
+    int type;
+    
+    type = offset_v2_k_type( &(key->u.k_offset_v2));
+    if (type != TYPE_DIRECT && type != TYPE_INDIRECT && type != TYPE_DIRENTRY)
+        return KEY_FORMAT_3_5;
+
+    return KEY_FORMAT_3_6;
+        
+}
+
+
+static inline void copy_key (struct reiserfs_key *to, const struct reiserfs_key *from)
+{
+    memcpy (to, from, KEY_SIZE);
+}
+
+
+int comp_items (const struct item_head * stored_ih, const struct path * p_s_path);
+const struct reiserfs_key * get_rkey (const struct path * p_s_chk_path,
+                                                         const struct super_block  * p_s_sb);
+int search_by_key (struct super_block *, const struct cpu_key *, 
+                                   struct path *, int);
+#define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
+int search_for_position_by_key (struct super_block * p_s_sb, 
+                                                                const struct cpu_key * p_s_cpu_key, 
+                                                                struct path * p_s_search_path);
+extern void decrement_bcount (struct buffer_head * p_s_bh);
+void decrement_counters_in_path (struct path * p_s_search_path);
+void pathrelse (struct path * p_s_search_path);
+int reiserfs_check_path(struct path *p) ;
+void pathrelse_and_restore (struct super_block *s, struct path * p_s_search_path);
+
+int reiserfs_insert_item (struct reiserfs_transaction_handle *th, 
+                          struct path * path, 
+                          const struct cpu_key * key,
+                          struct item_head * ih,
+                          struct inode *inode, const char * body);
+
+int reiserfs_paste_into_item (struct reiserfs_transaction_handle *th,
+                              struct path * path,
+                              const struct cpu_key * key,
+                              struct inode *inode,
+                              const char * body, int paste_size);
+
+int reiserfs_cut_from_item (struct reiserfs_transaction_handle *th,
+                            struct path * path,
+                            struct cpu_key * key,
+                            struct inode * inode,
+                            struct page *page,
+                            loff_t new_file_size);
+
+int reiserfs_delete_item (struct reiserfs_transaction_handle *th,
+                          struct path * path, 
+                          const struct cpu_key * key,
+                          struct inode * inode, 
+                          struct buffer_head  * p_s_un_bh);
+
+void reiserfs_delete_solid_item (struct reiserfs_transaction_handle *th,
+                        struct inode *inode, struct reiserfs_key * key);
+int reiserfs_delete_object (struct reiserfs_transaction_handle *th, struct inode * p_s_inode);
+int reiserfs_do_truncate (struct reiserfs_transaction_handle *th,
+                           struct  inode * p_s_inode, struct page *, 
+                           int update_timestamps);
+
+#define i_block_size(inode) ((inode)->i_sb->s_blocksize)
+#define file_size(inode) ((inode)->i_size)
+#define tail_size(inode) (file_size (inode) & (i_block_size (inode) - 1))
+
+#define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\
+!STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )
+
+void padd_item (char * item, int total_length, int length);
+
+/* inode.c */
+/* args for the create parameter of reiserfs_get_block */
+#define GET_BLOCK_NO_CREATE 0 /* don't create new blocks or convert tails */
+#define GET_BLOCK_CREATE 1    /* add anything you need to find block */
+#define GET_BLOCK_NO_HOLE 2   /* return -ENOENT for file holes */
+#define GET_BLOCK_READ_DIRECT 4  /* read the tail if indirect item not found */
+#define GET_BLOCK_NO_ISEM     8 /* i_sem is not held, don't preallocate */
+#define GET_BLOCK_NO_DANGLE   16 /* don't leave any transactions running */
+
+int restart_transaction(struct reiserfs_transaction_handle *th, struct inode *inode, struct path *path);
+void reiserfs_read_locked_inode(struct inode * inode, struct reiserfs_iget_args *args) ;
+int reiserfs_find_actor(struct inode * inode, void *p) ;
+int reiserfs_init_locked_inode(struct inode * inode, void *p) ;
+void reiserfs_delete_inode (struct inode * inode);
+int reiserfs_write_inode (struct inode * inode, int) ;
+int reiserfs_get_block (struct inode * inode, sector_t block, struct buffer_head * bh_result, int create);
+struct dentry *reiserfs_get_dentry(struct super_block *, void *) ;
+struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 *data,
+                                     int len, int fhtype,
+                                  int (*acceptable)(void *contect, struct dentry *de),
+                                  void *context) ;
+int reiserfs_encode_fh( struct dentry *dentry, __u32 *data, int *lenp, 
+                                                int connectable );
+
+int reiserfs_truncate_file(struct inode *, int update_timestamps) ;
+void make_cpu_key (struct cpu_key * cpu_key, struct inode * inode, loff_t offset,
+                   int type, int key_length);
+void make_le_item_head (struct item_head * ih, const struct cpu_key * key, 
+                        int version,
+                        loff_t offset, int type, int length, int entry_count);
+struct inode * reiserfs_iget (struct super_block * s, 
+                              const struct cpu_key * key);
+
+
+int reiserfs_new_inode (struct reiserfs_transaction_handle *th, 
+                                   struct inode * dir, int mode, 
+                                   const char * symname, loff_t i_size,
+                                   struct dentry *dentry, struct inode *inode);
+
+void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th,
+                              struct inode * inode, loff_t size);
+
+static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th,
+                                      struct inode *inode)
+{
+    reiserfs_update_sd_size(th, inode, inode->i_size) ;
+}
+
+void sd_attrs_to_i_attrs( __u16 sd_attrs, struct inode *inode );
+void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs );
+int reiserfs_setattr(struct dentry *dentry, struct iattr *attr);
+
+/* namei.c */
+void set_de_name_and_namelen (struct reiserfs_dir_entry * de);
+int search_by_entry_key (struct super_block * sb, const struct cpu_key * key, 
+                         struct path * path, 
+                         struct reiserfs_dir_entry * de);
+struct dentry *reiserfs_get_parent(struct dentry *) ;
+/* procfs.c */
+
+#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
+#define REISERFS_PROC_INFO
+#else
+#undef REISERFS_PROC_INFO
+#endif
+
+int reiserfs_proc_info_init( struct super_block *sb );
+int reiserfs_proc_info_done( struct super_block *sb );
+struct proc_dir_entry *reiserfs_proc_register_global( char *name, 
+                                                                                                          read_proc_t *func );
+void reiserfs_proc_unregister_global( const char *name );
+int reiserfs_proc_info_global_init( void );
+int reiserfs_proc_info_global_done( void );
+int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset,
+                                                                         int count, int *eof, void *data );
+
+#if defined( REISERFS_PROC_INFO )
+
+#define PROC_EXP( e )   e
+
+#define __PINFO( sb ) REISERFS_SB(sb) -> s_proc_info_data
+#define PROC_INFO_MAX( sb, field, value )                                                               \
+    __PINFO( sb ).field =                                                                                               \
+        max( REISERFS_SB( sb ) -> s_proc_info_data.field, value )
+#define PROC_INFO_INC( sb, field ) ( ++ ( __PINFO( sb ).field ) )
+#define PROC_INFO_ADD( sb, field, val ) ( __PINFO( sb ).field += ( val ) )
+#define PROC_INFO_BH_STAT( sb, bh, level )                                                      \
+    PROC_INFO_INC( sb, sbk_read_at[ ( level ) ] );                                              \
+    PROC_INFO_ADD( sb, free_at[ ( level ) ], B_FREE_SPACE( bh ) );      \
+    PROC_INFO_ADD( sb, items_at[ ( level ) ], B_NR_ITEMS( bh ) )
+#else
+#define PROC_EXP( e )
+#define VOID_V ( ( void ) 0 )
+#define PROC_INFO_MAX( sb, field, value ) VOID_V
+#define PROC_INFO_INC( sb, field ) VOID_V
+#define PROC_INFO_ADD( sb, field, val ) VOID_V
+#define PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level ) VOID_V
+#endif
+
+/* dir.c */
+extern struct inode_operations reiserfs_dir_inode_operations;
+extern struct inode_operations reiserfs_symlink_inode_operations;
+extern struct inode_operations reiserfs_special_inode_operations;
+extern struct file_operations reiserfs_dir_operations;
+
+/* tail_conversion.c */
+int direct2indirect (struct reiserfs_transaction_handle *, struct inode *, struct path *, struct buffer_head *, loff_t);
+int indirect2direct (struct reiserfs_transaction_handle *, struct inode *, struct page *, struct path *, const struct cpu_key *, loff_t, char *);
+void reiserfs_unmap_buffer(struct buffer_head *) ;
+
+
+/* file.c */
+extern struct inode_operations reiserfs_file_inode_operations;
+extern struct file_operations reiserfs_file_operations;
+extern struct address_space_operations reiserfs_address_space_operations ;
+
+/* fix_nodes.c */
+#ifdef CONFIG_REISERFS_CHECK
+void * reiserfs_kmalloc (size_t size, int flags, struct super_block * s);
+void reiserfs_kfree (const void * vp, size_t size, struct super_block * s);
+#else
+static inline void *reiserfs_kmalloc(size_t size, int flags,
+                                        struct super_block *s)
+{
+        return kmalloc(size, flags);
+}
+
+static inline void reiserfs_kfree(const void *vp, size_t size,
+                                        struct super_block *s)
+{
+        kfree(vp);
+}
+#endif
+
+int fix_nodes (int n_op_mode, struct tree_balance * p_s_tb, 
+               struct item_head * p_s_ins_ih, const void *);
+void unfix_nodes (struct tree_balance *);
+
+
+/* prints.c */
+void reiserfs_panic (struct super_block * s, const char * fmt, ...) __attribute__ ( ( noreturn ) );
+void reiserfs_info (struct super_block *s, const char * fmt, ...);
+void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...);
+void print_indirect_item (struct buffer_head * bh, int item_num);
+void store_print_tb (struct tree_balance * tb);
+void print_cur_tb (char * mes);
+void print_de (struct reiserfs_dir_entry * de);
+void print_bi (struct buffer_info * bi, char * mes);
+#define PRINT_LEAF_ITEMS 1   /* print all items */
+#define PRINT_DIRECTORY_ITEMS 2 /* print directory items */
+#define PRINT_DIRECT_ITEMS 4 /* print contents of direct items */
+void print_block (struct buffer_head * bh, ...);
+void print_bmap (struct super_block * s, int silent);
+void print_bmap_block (int i, char * data, int size, int silent);
+/*void print_super_block (struct super_block * s, char * mes);*/
+void print_objectid_map (struct super_block * s);
+void print_block_head (struct buffer_head * bh, char * mes);
+void check_leaf (struct buffer_head * bh);
+void check_internal (struct buffer_head * bh);
+void print_statistics (struct super_block * s);
+char * reiserfs_hashname(int code);
+
+/* lbalance.c */
+int leaf_move_items (int shift_mode, struct tree_balance * tb, int mov_num, int mov_bytes, struct buffer_head * Snew);
+int leaf_shift_left (struct tree_balance * tb, int shift_num, int shift_bytes);
+int leaf_shift_right (struct tree_balance * tb, int shift_num, int shift_bytes);
+void leaf_delete_items (struct buffer_info * cur_bi, int last_first, int first, int del_num, int del_bytes);
+void leaf_insert_into_buf (struct buffer_info * bi, int before, 
+                           struct item_head * inserted_item_ih, const char * inserted_item_body, int zeros_number);
+void leaf_paste_in_buffer (struct buffer_info * bi, int pasted_item_num, 
+                           int pos_in_item, int paste_size, const char * body, int zeros_number);
+void leaf_cut_from_buffer (struct buffer_info * bi, int cut_item_num, int pos_in_item, 
+                           int cut_size);
+void leaf_paste_entries (struct buffer_head * bh, int item_num, int before, 
+                         int new_entry_count, struct reiserfs_de_head * new_dehs, const char * records, int paste_size);
+/* ibalance.c */
+int balance_internal (struct tree_balance * , int, int, struct item_head * , 
+                      struct buffer_head **);
+
+/* do_balance.c */
+void do_balance_mark_leaf_dirty (struct tree_balance * tb,
+                                        struct buffer_head * bh, int flag);
+#define do_balance_mark_internal_dirty do_balance_mark_leaf_dirty
+#define do_balance_mark_sb_dirty do_balance_mark_leaf_dirty
+
+void do_balance (struct tree_balance * tb, struct item_head * ih, 
+                 const char * body, int flag);
+void reiserfs_invalidate_buffer (struct tree_balance * tb, struct buffer_head * bh);
+
+int get_left_neighbor_position (struct tree_balance * tb, int h);
+int get_right_neighbor_position (struct tree_balance * tb, int h);
+void replace_key (struct tree_balance * tb, struct buffer_head *, int, struct buffer_head *, int);
+void make_empty_node (struct buffer_info *);
+struct buffer_head * get_FEB (struct tree_balance *);
+
+/* bitmap.c */
+
+/* structure contains hints for block allocator, and it is a container for
+ * arguments, such as node, search path, transaction_handle, etc. */
+ struct __reiserfs_blocknr_hint {
+     struct inode * inode;              /* inode passed to allocator, if we allocate unf. nodes */
+     long block;                        /* file offset, in blocks */
+     struct reiserfs_key key;
+     struct path * path;                /* search path, used by allocator to deternine search_start by
+                                         * various ways */
+     struct reiserfs_transaction_handle * th; /* transaction handle is needed to log super blocks and
+                                               * bitmap blocks changes  */
+     b_blocknr_t beg, end;
+     b_blocknr_t search_start;          /* a field used to transfer search start value (block number)
+                                         * between different block allocator procedures
+                                         * (determine_search_start() and others) */
+    int prealloc_size;                  /* is set in determine_prealloc_size() function, used by underlayed
+                                         * function that do actual allocation */
+
+    unsigned formatted_node:1;          /* the allocator uses different polices for getting disk space for
+                                         * formatted/unformatted blocks with/without preallocation */
+    unsigned preallocate:1;
+};
+
+typedef struct __reiserfs_blocknr_hint reiserfs_blocknr_hint_t;
+
+int reiserfs_parse_alloc_options (struct super_block *, char *);
+void reiserfs_init_alloc_options (struct super_block *s);
+
+/*
+ * given a directory, this will tell you what packing locality
+ * to use for a new object underneat it.  The locality is returned
+ * in disk byte order (le).
+ */
+u32 reiserfs_choose_packing(struct inode *dir);
+
+int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value);
+void reiserfs_free_block (struct reiserfs_transaction_handle *th, struct inode *, b_blocknr_t, int for_unformatted);
+int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t * , int, int);
+extern inline int reiserfs_new_form_blocknrs (struct tree_balance * tb,
+                                              b_blocknr_t *new_blocknrs, int amount_needed)
+{
+    reiserfs_blocknr_hint_t hint = {
+        .th = tb->transaction_handle,
+        .path = tb->tb_path,
+        .inode = NULL,
+        .key = tb->key,
+        .block = 0,
+        .formatted_node = 1
+    };
+    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed, 0);
+}
+
+extern inline int reiserfs_new_unf_blocknrs (struct reiserfs_transaction_handle *th,
+                                             struct inode *inode,
+                                             b_blocknr_t *new_blocknrs,
+                                             struct path * path, long block)
+{
+    reiserfs_blocknr_hint_t hint = {
+        .th = th,
+        .path = path,
+        .inode = inode,
+        .block = block,
+        .formatted_node = 0,
+        .preallocate = 0
+    };
+    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
+}
+
+#ifdef REISERFS_PREALLOCATE
+extern inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle *th,
+                                             struct inode * inode,
+                                             b_blocknr_t *new_blocknrs,
+                                             struct path * path, long block)
+{
+    reiserfs_blocknr_hint_t hint = {
+        .th = th,
+        .path = path,
+        .inode = inode,
+        .block = block,
+        .formatted_node = 0,
+        .preallocate = 1
+    };
+    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
+}
+
+void reiserfs_discard_prealloc (struct reiserfs_transaction_handle *th, 
+                                struct inode * inode);
+void reiserfs_discard_all_prealloc (struct reiserfs_transaction_handle *th);
+#endif
+void reiserfs_claim_blocks_to_be_allocated( struct super_block *sb, int blocks);
+void reiserfs_release_claimed_blocks( struct super_block *sb, int blocks);
+int reiserfs_can_fit_pages(struct super_block *sb);
+
+/* hashes.c */
+__u32 keyed_hash (const signed char *msg, int len);
+__u32 yura_hash (const signed char *msg, int len);
+__u32 r5_hash (const signed char *msg, int len);
+
+/* the ext2 bit routines adjust for big or little endian as
+** appropriate for the arch, so in our laziness we use them rather
+** than using the bit routines they call more directly.  These
+** routines must be used when changing on disk bitmaps.  */
+#define reiserfs_test_and_set_le_bit   ext2_set_bit
+#define reiserfs_test_and_clear_le_bit ext2_clear_bit
+#define reiserfs_test_le_bit           ext2_test_bit
+#define reiserfs_find_next_zero_le_bit ext2_find_next_zero_bit
+
+/* sometimes reiserfs_truncate may require to allocate few new blocks
+   to perform indirect2direct conversion. People probably used to
+   think, that truncate should work without problems on a filesystem
+   without free disk space. They may complain that they can not
+   truncate due to lack of free disk space. This spare space allows us
+   to not worry about it. 500 is probably too much, but it should be
+   absolutely safe */
+#define SPARE_SPACE 500
+
+
+/* prototypes from ioctl.c */
+int reiserfs_ioctl (struct inode * inode, struct file * filp, 
+                    unsigned int cmd, unsigned long arg);
+ 
+/* ioctl's command */
+#define REISERFS_IOC_UNPACK             _IOW(0xCD,1,long)
+/* define following flags to be the same as in ext2, so that chattr(1),
+   lsattr(1) will work with us. */
+#define REISERFS_IOC_GETFLAGS           EXT2_IOC_GETFLAGS
+#define REISERFS_IOC_SETFLAGS           EXT2_IOC_SETFLAGS
+#define REISERFS_IOC_GETVERSION         EXT2_IOC_GETVERSION
+#define REISERFS_IOC_SETVERSION         EXT2_IOC_SETVERSION
+
+/* Locking primitives */
+/* Right now we are still falling back to (un)lock_kernel, but eventually that
+   would evolve into real per-fs locks */
+#define reiserfs_write_lock( sb ) lock_kernel()
+#define reiserfs_write_unlock( sb ) unlock_kernel()
+                                 
+/* xattr stuff */
+#define REISERFS_XATTR_DIR_SEM(s) (REISERFS_SB(s)->xattr_dir_sem)
+
+#endif /* _LINUX_REISER_FS_H */
+
+
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
new file mode 100644
index 000000000000..e321eb050d65
--- /dev/null
+++ b/include/linux/reiserfs_fs_i.h
@@ -0,0 +1,63 @@
+#ifndef _REISER_FS_I
+#define _REISER_FS_I
+
+#include <linux/list.h>
+
+struct reiserfs_journal_list;
+
+/** bitmasks for i_flags field in reiserfs-specific part of inode */
+typedef enum {
+    /** this says what format of key do all items (but stat data) of
+      an object have.  If this is set, that format is 3.6 otherwise
+      - 3.5 */
+    i_item_key_version_mask    =  0x0001,
+    /** If this is unset, object has 3.5 stat data, otherwise, it has
+      3.6 stat data with 64bit size, 32bit nlink etc. */
+    i_stat_data_version_mask   =  0x0002,
+    /** file might need tail packing on close */
+    i_pack_on_close_mask       =  0x0004,
+    /** don't pack tail of file */
+    i_nopack_mask              =  0x0008,
+    /** If those is set, "safe link" was created for this file during
+      truncate or unlink. Safe link is used to avoid leakage of disk
+      space on crash with some files open, but unlinked. */
+    i_link_saved_unlink_mask   =  0x0010,
+    i_link_saved_truncate_mask =  0x0020,
+    i_has_xattr_dir            =  0x0040,
+    i_data_log                 =  0x0080,
+} reiserfs_inode_flags;
+
+
+struct reiserfs_inode_info {
+    __u32 i_key [4];/* key is still 4 32 bit integers */
+    /** transient inode flags that are never stored on disk. Bitmasks
+      for this field are defined above. */
+    __u32 i_flags;
+
+    __u32 i_first_direct_byte; // offset of first byte stored in direct item.
+
+    /* copy of persistent inode flags read from sd_attrs. */
+    __u32 i_attrs;
+
+    int i_prealloc_block; /* first unused block of a sequence of unused blocks */
+    int i_prealloc_count; /* length of that sequence */
+    struct list_head i_prealloc_list; /* per-transaction list of inodes which
+                                       * have preallocated blocks */
+
+    unsigned new_packing_locality:1;  /* new_packig_locality is created; new blocks
+                                       * for the contents of this directory should be
+                                       * displaced */
+
+    /* we use these for fsync or O_SYNC to decide which transaction
+    ** needs to be committed in order for this inode to be properly
+    ** flushed */
+    unsigned long i_trans_id ;
+    struct reiserfs_journal_list *i_jl;
+
+    struct posix_acl *i_acl_access;
+    struct posix_acl *i_acl_default;
+    struct rw_semaphore xattr_sem;
+    struct inode vfs_inode;
+};
+
+#endif
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
new file mode 100644
index 000000000000..37a3a7afbec7
--- /dev/null
+++ b/include/linux/reiserfs_fs_sb.h
@@ -0,0 +1,535 @@
+/* Copyright 1996-2000 Hans Reiser, see reiserfs/README for licensing
+ * and copyright details */
+
+#ifndef _LINUX_REISER_FS_SB
+#define _LINUX_REISER_FS_SB
+
+#ifdef __KERNEL__
+#include <linux/workqueue.h>
+#include <linux/rwsem.h>
+#endif
+
+typedef enum {
+  reiserfs_attrs_cleared        = 0x00000001,
+} reiserfs_super_block_flags;
+
+/* struct reiserfs_super_block accessors/mutators
+ * since this is a disk structure, it will always be in 
+ * little endian format. */
+#define sb_block_count(sbp)         (le32_to_cpu((sbp)->s_v1.s_block_count))
+#define set_sb_block_count(sbp,v)   ((sbp)->s_v1.s_block_count = cpu_to_le32(v))
+#define sb_free_blocks(sbp)         (le32_to_cpu((sbp)->s_v1.s_free_blocks))
+#define set_sb_free_blocks(sbp,v)   ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v))
+#define sb_root_block(sbp)          (le32_to_cpu((sbp)->s_v1.s_root_block))
+#define set_sb_root_block(sbp,v)    ((sbp)->s_v1.s_root_block = cpu_to_le32(v))
+
+#define sb_jp_journal_1st_block(sbp)  \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block))
+#define set_sb_jp_journal_1st_block(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v))
+#define sb_jp_journal_dev(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev))
+#define set_sb_jp_journal_dev(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v))
+#define sb_jp_journal_size(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size))
+#define set_sb_jp_journal_size(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v))
+#define sb_jp_journal_trans_max(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max))
+#define set_sb_jp_journal_trans_max(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v))
+#define sb_jp_journal_magic(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic))
+#define set_sb_jp_journal_magic(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v))
+#define sb_jp_journal_max_batch(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch))
+#define set_sb_jp_journal_max_batch(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v))
+#define sb_jp_jourmal_max_commit_age(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age))
+#define set_sb_jp_journal_max_commit_age(sbp,v) \
+              ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v))
+
+#define sb_blocksize(sbp)          (le16_to_cpu((sbp)->s_v1.s_blocksize))
+#define set_sb_blocksize(sbp,v)    ((sbp)->s_v1.s_blocksize = cpu_to_le16(v))
+#define sb_oid_maxsize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_maxsize))
+#define set_sb_oid_maxsize(sbp,v)  ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v))
+#define sb_oid_cursize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_cursize))
+#define set_sb_oid_cursize(sbp,v)  ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v))
+#define sb_umount_state(sbp)       (le16_to_cpu((sbp)->s_v1.s_umount_state))
+#define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))
+#define sb_fs_state(sbp)           (le16_to_cpu((sbp)->s_v1.s_fs_state))
+#define set_sb_fs_state(sbp,v)     ((sbp)->s_v1.s_fs_state = cpu_to_le16(v)) 
+#define sb_hash_function_code(sbp) \
+              (le32_to_cpu((sbp)->s_v1.s_hash_function_code))
+#define set_sb_hash_function_code(sbp,v) \
+              ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v))
+#define sb_tree_height(sbp)        (le16_to_cpu((sbp)->s_v1.s_tree_height))
+#define set_sb_tree_height(sbp,v)  ((sbp)->s_v1.s_tree_height = cpu_to_le16(v))
+#define sb_bmap_nr(sbp)            (le16_to_cpu((sbp)->s_v1.s_bmap_nr))
+#define set_sb_bmap_nr(sbp,v)      ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v))
+#define sb_version(sbp)            (le16_to_cpu((sbp)->s_v1.s_version))
+#define set_sb_version(sbp,v)      ((sbp)->s_v1.s_version = cpu_to_le16(v))
+
+#define sb_reserved_for_journal(sbp) \
+              (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))
+#define set_sb_reserved_for_journal(sbp,v) \
+              ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v))
+
+/* LOGGING -- */
+
+/* These all interelate for performance.  
+**
+** If the journal block count is smaller than n transactions, you lose speed. 
+** I don't know what n is yet, I'm guessing 8-16.
+**
+** typical transaction size depends on the application, how often fsync is
+** called, and how many metadata blocks you dirty in a 30 second period.  
+** The more small files (<16k) you use, the larger your transactions will
+** be.
+** 
+** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal
+** to wrap, which slows things down.  If you need high speed meta data updates, the journal should be big enough
+** to prevent wrapping before dirty meta blocks get to disk.
+**
+** If the batch max is smaller than the transaction max, you'll waste space at the end of the journal
+** because journal_end sets the next transaction to start at 0 if the next transaction has any chance of wrapping.
+**
+** The large the batch max age, the better the speed, and the more meta data changes you'll lose after a crash.
+**
+*/
+
+/* don't mess with these for a while */
+                                /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
+#define JOURNAL_BLOCK_SIZE  4096 /* BUG gotta get rid of this */
+#define JOURNAL_MAX_CNODE   1500 /* max cnodes to allocate. */
+#define JOURNAL_HASH_SIZE 8192   
+#define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating.  Must be >= 2 */
+
+/* One of these for every block in every transaction
+** Each one is in two hash tables.  First, a hash of the current transaction, and after journal_end, a
+** hash of all the in memory transactions.
+** next and prev are used by the current transaction (journal_hash).
+** hnext and hprev are used by journal_list_hash.  If a block is in more than one transaction, the journal_list_hash
+** links it in multiple times.  This allows flush_journal_list to remove just the cnode belonging
+** to a given transaction.
+*/
+struct reiserfs_journal_cnode {
+  struct buffer_head *bh ;               /* real buffer head */
+  struct super_block *sb ;               /* dev of real buffer head */
+  __u32 blocknr ;                /* block number of real buffer head, == 0 when buffer on disk */
+  long state ;
+  struct reiserfs_journal_list *jlist ;  /* journal list this cnode lives in */
+  struct reiserfs_journal_cnode *next ;  /* next in transaction list */
+  struct reiserfs_journal_cnode *prev ;  /* prev in transaction list */
+  struct reiserfs_journal_cnode *hprev ; /* prev in hash list */
+  struct reiserfs_journal_cnode *hnext ; /* next in hash list */
+};
+
+struct reiserfs_bitmap_node {
+  int id ;
+  char *data ;
+  struct list_head list ;
+} ;
+
+struct reiserfs_list_bitmap {
+  struct reiserfs_journal_list *journal_list ;
+  struct reiserfs_bitmap_node **bitmaps ;
+} ;
+
+/*
+** one of these for each transaction.  The most important part here is the j_realblock.
+** this list of cnodes is used to hash all the blocks in all the commits, to mark all the
+** real buffer heads dirty once all the commits hit the disk,
+** and to make sure every real block in a transaction is on disk before allowing the log area
+** to be overwritten */
+struct reiserfs_journal_list {
+  unsigned long j_start ;
+  unsigned long j_state;
+  unsigned long j_len ;
+  atomic_t j_nonzerolen ;
+  atomic_t j_commit_left ;
+  atomic_t j_older_commits_done ;      /* all commits older than this on disk*/
+  struct semaphore j_commit_lock;
+  unsigned long j_trans_id ;
+  time_t j_timestamp ;
+  struct reiserfs_list_bitmap *j_list_bitmap ;
+  struct buffer_head *j_commit_bh ; /* commit buffer head */
+  struct reiserfs_journal_cnode *j_realblock  ;
+  struct reiserfs_journal_cnode *j_freedlist ; /* list of buffers that were freed during this trans.  free each of these on flush */
+  /* time ordered list of all active transactions */
+  struct list_head j_list;
+
+  /* time ordered list of all transactions we haven't tried to flush yet */
+  struct list_head j_working_list;
+
+  /* list of tail conversion targets in need of flush before commit */
+  struct list_head j_tail_bh_list;
+  /* list of data=ordered buffers in need of flush before commit */
+  struct list_head j_bh_list;
+  int j_refcount;
+} ;
+
+struct reiserfs_journal {
+  struct buffer_head ** j_ap_blocks ; /* journal blocks on disk */
+  struct reiserfs_journal_cnode *j_last ; /* newest journal block */
+  struct reiserfs_journal_cnode *j_first ; /*  oldest journal block.  start here for traverse */
+
+  struct file         *j_dev_file;
+  struct block_device *j_dev_bd;  
+  int j_1st_reserved_block;     /* first block on s_dev of reserved area journal */        
+        
+  long j_state ;                        
+  unsigned long j_trans_id ;
+  unsigned long j_mount_id ;
+  unsigned long j_start ;             /* start of current waiting commit (index into j_ap_blocks) */
+  unsigned long j_len ;               /* lenght of current waiting commit */
+  unsigned long j_len_alloc ;         /* number of buffers requested by journal_begin() */
+  atomic_t j_wcount ;            /* count of writers for current commit */
+  unsigned long j_bcount ;            /* batch count. allows turning X transactions into 1 */
+  unsigned long j_first_unflushed_offset ;  /* first unflushed transactions offset */
+  unsigned long j_last_flush_trans_id ;    /* last fully flushed journal timestamp */
+  struct buffer_head *j_header_bh ;   
+
+  time_t j_trans_start_time ;         /* time this transaction started */
+  struct semaphore j_lock;
+  struct semaphore j_flush_sem;
+  wait_queue_head_t j_join_wait ;    /* wait for current transaction to finish before starting new one */
+  atomic_t j_jlock ;                       /* lock for j_join_wait */
+  int j_list_bitmap_index ;           /* number of next list bitmap to use */
+  int j_must_wait ;                    /* no more journal begins allowed. MUST sleep on j_join_wait */
+  int j_next_full_flush ;             /* next journal_end will flush all journal list */
+  int j_next_async_flush ;             /* next journal_end will flush all async commits */
+
+  int j_cnode_used ;          /* number of cnodes on the used list */
+  int j_cnode_free ;          /* number of cnodes on the free list */
+
+  unsigned int j_trans_max ;           /* max number of blocks in a transaction.  */
+  unsigned int j_max_batch ;           /* max number of blocks to batch into a trans */
+  unsigned int j_max_commit_age ;      /* in seconds, how old can an async commit be */
+  unsigned int j_max_trans_age ;       /* in seconds, how old can a transaction be */
+  unsigned int j_default_max_commit_age ; /* the default for the max commit age */
+
+  struct reiserfs_journal_cnode *j_cnode_free_list ;
+  struct reiserfs_journal_cnode *j_cnode_free_orig ; /* orig pointer returned from vmalloc */
+
+  struct reiserfs_journal_list *j_current_jl;
+  int j_free_bitmap_nodes ;
+  int j_used_bitmap_nodes ;
+
+  int j_num_lists;      /* total number of active transactions */
+  int j_num_work_lists; /* number that need attention from kreiserfsd */
+
+  /* debugging to make sure things are flushed in order */
+  int j_last_flush_id;
+
+  /* debugging to make sure things are committed in order */
+  int j_last_commit_id;
+
+  struct list_head j_bitmap_nodes ;
+  struct list_head j_dirty_buffers ;
+  spinlock_t j_dirty_buffers_lock ; /* protects j_dirty_buffers */
+
+  /* list of all active transactions */
+  struct list_head j_journal_list;
+  /* lists that haven't been touched by writeback attempts */
+  struct list_head j_working_list;
+
+  struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS] ;      /* array of bitmaps to record the deleted blocks */
+  struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE] ;          /* hash table for real buffer heads in current trans */ 
+  struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for all the real buffer heads in all 
+                                                                                the transactions */
+  struct list_head j_prealloc_list;     /* list of inodes which have preallocated blocks */
+  int j_persistent_trans;
+  unsigned long j_max_trans_size ;
+  unsigned long j_max_batch_size ;
+
+  int j_errno;
+
+  /* when flushing ordered buffers, throttle new ordered writers */
+  struct work_struct j_work;
+  atomic_t j_async_throttle;
+};
+
+enum journal_state_bits {
+    J_WRITERS_BLOCKED = 1,   /* set when new writers not allowed */
+    J_WRITERS_QUEUED,        /* set when log is full due to too many writers */
+    J_ABORTED,               /* set when log is aborted */
+};
+
+
+#define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick.  magic string to find desc blocks in the journal */
+
+typedef __u32 (*hashf_t) (const signed char *, int);
+
+struct reiserfs_bitmap_info
+{
+    // FIXME: Won't work with block sizes > 8K
+    __u16  first_zero_hint;
+    __u16  free_count;
+    struct buffer_head *bh; /* the actual bitmap */
+};
+
+struct proc_dir_entry;
+
+#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
+typedef unsigned long int stat_cnt_t;
+typedef struct reiserfs_proc_info_data
+{
+  spinlock_t lock;
+  int exiting;
+  int max_hash_collisions;
+
+  stat_cnt_t breads;
+  stat_cnt_t bread_miss;
+  stat_cnt_t search_by_key;
+  stat_cnt_t search_by_key_fs_changed;
+  stat_cnt_t search_by_key_restarted;
+
+  stat_cnt_t insert_item_restarted;
+  stat_cnt_t paste_into_item_restarted;
+  stat_cnt_t cut_from_item_restarted;
+  stat_cnt_t delete_solid_item_restarted;
+  stat_cnt_t delete_item_restarted;
+
+  stat_cnt_t leaked_oid;
+  stat_cnt_t leaves_removable;
+
+  /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
+  stat_cnt_t balance_at[ 5 ]; /* XXX */
+  /* sbk == search_by_key */
+  stat_cnt_t sbk_read_at[ 5 ]; /* XXX */
+  stat_cnt_t sbk_fs_changed[ 5 ];
+  stat_cnt_t sbk_restarted[ 5 ];
+  stat_cnt_t items_at[ 5 ]; /* XXX */
+  stat_cnt_t free_at[ 5 ]; /* XXX */
+  stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */
+  long int lnum[ 5 ]; /* XXX */
+  long int rnum[ 5 ]; /* XXX */
+  long int lbytes[ 5 ]; /* XXX */
+  long int rbytes[ 5 ]; /* XXX */
+  stat_cnt_t get_neighbors[ 5 ];
+  stat_cnt_t get_neighbors_restart[ 5 ];
+  stat_cnt_t need_l_neighbor[ 5 ];
+  stat_cnt_t need_r_neighbor[ 5 ];
+
+  stat_cnt_t free_block;
+  struct __scan_bitmap_stats {
+        stat_cnt_t call;
+        stat_cnt_t wait;
+        stat_cnt_t bmap;
+        stat_cnt_t retry;
+        stat_cnt_t in_journal_hint;
+        stat_cnt_t in_journal_nohint;
+        stat_cnt_t stolen;
+  } scan_bitmap;
+  struct __journal_stats {
+        stat_cnt_t in_journal;
+        stat_cnt_t in_journal_bitmap;
+        stat_cnt_t in_journal_reusable;
+        stat_cnt_t lock_journal;
+        stat_cnt_t lock_journal_wait;
+        stat_cnt_t journal_being;
+        stat_cnt_t journal_relock_writers;
+        stat_cnt_t journal_relock_wcount;
+        stat_cnt_t mark_dirty;
+        stat_cnt_t mark_dirty_already;
+        stat_cnt_t mark_dirty_notjournal;
+        stat_cnt_t restore_prepared;
+        stat_cnt_t prepare;
+        stat_cnt_t prepare_retry;
+  } journal;
+} reiserfs_proc_info_data_t;
+#else
+typedef struct reiserfs_proc_info_data
+{} reiserfs_proc_info_data_t;
+#endif
+
+/* reiserfs union of in-core super block data */
+struct reiserfs_sb_info
+{
+    struct buffer_head * s_sbh;                   /* Buffer containing the super block */
+                                /* both the comment and the choice of
+                                   name are unclear for s_rs -Hans */
+    struct reiserfs_super_block * s_rs;           /* Pointer to the super block in the buffer */
+    struct reiserfs_bitmap_info * s_ap_bitmap;
+    struct reiserfs_journal *s_journal ;                /* pointer to journal information */
+    unsigned short s_mount_state;                 /* reiserfs state (valid, invalid) */
+  
+                                /* Comment? -Hans */
+    void (*end_io_handler)(struct buffer_head *, int);
+    hashf_t s_hash_function;    /* pointer to function which is used
+                                   to sort names in directory. Set on
+                                   mount */
+    unsigned long s_mount_opt;  /* reiserfs's mount options are set
+                                   here (currently - NOTAIL, NOLOG,
+                                   REPLAYONLY) */
+
+    struct {                    /* This is a structure that describes block allocator options */
+        unsigned long bits;     /* Bitfield for enable/disable kind of options */
+        unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */
+        int border;             /* percentage of disk, border takes */
+        int preallocmin;        /* Minimal file size (in blocks) starting from which we do preallocations */
+        int preallocsize;       /* Number of blocks we try to prealloc when file
+                                   reaches preallocmin size (in blocks) or
+                                   prealloc_list is empty. */
+    } s_alloc_options;
+
+                                /* Comment? -Hans */
+    wait_queue_head_t s_wait;
+                                /* To be obsoleted soon by per buffer seals.. -Hans */
+    atomic_t s_generation_counter; // increased by one every time the
+    // tree gets re-balanced
+    unsigned long s_properties;    /* File system properties. Currently holds
+                                     on-disk FS format */
+    
+    /* session statistics */
+    int s_kmallocs;
+    int s_disk_reads;
+    int s_disk_writes;
+    int s_fix_nodes;
+    int s_do_balance;
+    int s_unneeded_left_neighbor;
+    int s_good_search_by_key_reada;
+    int s_bmaps;
+    int s_bmaps_without_search;
+    int s_direct2indirect;
+    int s_indirect2direct;
+        /* set up when it's ok for reiserfs_read_inode2() to read from
+           disk inode with nlink==0. Currently this is only used during
+           finish_unfinished() processing at mount time */
+    int s_is_unlinked_ok;
+    reiserfs_proc_info_data_t s_proc_info_data;
+    struct proc_dir_entry *procdir;
+    int reserved_blocks; /* amount of blocks reserved for further allocations */
+    spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
+    struct dentry *priv_root; /* root of /.reiserfs_priv */
+    struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */
+    struct rw_semaphore xattr_dir_sem;
+
+    int j_errno;
+#ifdef CONFIG_QUOTA
+    char *s_qf_names[MAXQUOTAS];
+    int s_jquota_fmt;
+#endif
+};
+
+/* Definitions of reiserfs on-disk properties: */
+#define REISERFS_3_5 0
+#define REISERFS_3_6 1
+
+enum reiserfs_mount_options {
+/* Mount options */
+    REISERFS_LARGETAIL,  /* large tails will be created in a session */
+    REISERFS_SMALLTAIL,  /* small (for files less than block size) tails will be created in a session */
+    REPLAYONLY, /* replay journal and return 0. Use by fsck */
+    REISERFS_CONVERT,    /* -o conv: causes conversion of old
+                                 format super block to the new
+                                 format. If not specified - old
+                                 partition will be dealt with in a
+                                 manner of 3.5.x */
+
+/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
+** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
+** is not required.  If the normal autodection code can't determine which
+** hash to use (because both hases had the same value for a file)
+** use this option to force a specific hash.  It won't allow you to override
+** the existing hash on the FS, so if you have a tea hash disk, and mount
+** with -o hash=rupasov, the mount will fail.
+*/
+    FORCE_TEA_HASH,      /* try to force tea hash on mount */
+    FORCE_RUPASOV_HASH,  /* try to force rupasov hash on mount */
+    FORCE_R5_HASH,       /* try to force rupasov hash on mount */
+    FORCE_HASH_DETECT,   /* try to detect hash function on mount */
+
+    REISERFS_DATA_LOG,
+    REISERFS_DATA_ORDERED,
+    REISERFS_DATA_WRITEBACK,
+
+/* used for testing experimental features, makes benchmarking new
+   features with and without more convenient, should never be used by
+   users in any code shipped to users (ideally) */
+
+    REISERFS_NO_BORDER,
+    REISERFS_NO_UNHASHED_RELOCATION,
+    REISERFS_HASHED_RELOCATION,
+    REISERFS_ATTRS,
+    REISERFS_XATTRS,
+    REISERFS_XATTRS_USER,
+    REISERFS_POSIXACL,
+    REISERFS_BARRIER_NONE,
+    REISERFS_BARRIER_FLUSH,
+
+    /* Actions on error */
+    REISERFS_ERROR_PANIC,
+    REISERFS_ERROR_RO,
+    REISERFS_ERROR_CONTINUE,
+
+    REISERFS_TEST1,
+    REISERFS_TEST2,
+    REISERFS_TEST3,
+    REISERFS_TEST4,
+    REISERFS_UNSUPPORTED_OPT,
+};
+
+#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
+#define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))
+#define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))
+#define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))
+#define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))
+#define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
+#define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
+#define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))
+
+#define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))
+#define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))
+#define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))
+#define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))
+#define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))
+#define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))
+#define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
+#define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
+#define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
+#define reiserfs_xattrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS))
+#define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
+#define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
+#define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
+#define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
+#define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))
+
+#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
+#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
+
+void reiserfs_file_buffer (struct buffer_head * bh, int list);
+extern struct file_system_type reiserfs_fs_type;
+int reiserfs_resize(struct super_block *, unsigned long) ;
+
+#define CARRY_ON                0
+#define SCHEDULE_OCCURRED       1
+
+
+#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
+#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
+#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
+#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) 
+#define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)
+
+#define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
+
+/* A safe version of the "bdevname", which returns the "s_id" field of
+ * a superblock or else "Null superblock" if the super block is NULL.
+ */
+static inline char *reiserfs_bdevname(struct super_block *s)
+{
+        return (s == NULL) ? "Null superblock" : s -> s_id;
+}
+
+#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
+static inline int __reiserfs_is_journal_aborted (struct reiserfs_journal *journal)
+{
+    return test_bit (J_ABORTED, &journal->j_state);
+}
+
+#endif  /* _LINUX_REISER_FS_SB */
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
new file mode 100644
index 000000000000..1eaa48eca811
--- /dev/null
+++ b/include/linux/reiserfs_xattr.h
@@ -0,0 +1,139 @@
+/*
+  File: linux/reiserfs_xattr.h
+*/
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/xattr.h>
+
+/* Magic value in header */
+#define REISERFS_XATTR_MAGIC 0x52465841 /* "RFXA" */
+
+struct reiserfs_xattr_header {
+    __u32 h_magic;              /* magic number for identification */
+    __u32 h_hash;               /* hash of the value */
+};
+
+#ifdef __KERNEL__
+
+struct reiserfs_xattr_handler {
+        char *prefix;
+        int (*init)(void);
+        void (*exit)(void);
+        int (*get)(struct inode *inode, const char *name, void *buffer,
+                   size_t size);
+        int (*set)(struct inode *inode, const char *name, const void *buffer,
+                   size_t size, int flags);
+        int (*del)(struct inode *inode, const char *name);
+        int (*list)(struct inode *inode, const char *name, int namelen, char *out);
+        struct list_head handlers;
+};
+
+
+#ifdef CONFIG_REISERFS_FS_XATTR
+#define is_reiserfs_priv_object(inode) IS_PRIVATE(inode)
+#define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
+ssize_t reiserfs_getxattr (struct dentry *dentry, const char *name,
+                           void *buffer, size_t size);
+int reiserfs_setxattr (struct dentry *dentry, const char *name,
+                       const void *value, size_t size, int flags);
+ssize_t reiserfs_listxattr (struct dentry *dentry, char *buffer, size_t size);
+int reiserfs_removexattr (struct dentry *dentry, const char *name);
+int reiserfs_delete_xattrs (struct inode *inode);
+int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs);
+int reiserfs_xattr_init (struct super_block *sb, int mount_flags);
+int reiserfs_permission (struct inode *inode, int mask, struct nameidata *nd);
+int reiserfs_permission_locked (struct inode *inode, int mask, struct nameidata *nd);
+
+int reiserfs_xattr_del (struct inode *, const char *);
+int reiserfs_xattr_get (const struct inode *, const char *, void *, size_t);
+int reiserfs_xattr_set (struct inode *, const char *, const void *,
+                               size_t, int);
+
+extern struct reiserfs_xattr_handler user_handler;
+extern struct reiserfs_xattr_handler trusted_handler;
+#ifdef CONFIG_REISERFS_FS_SECURITY
+extern struct reiserfs_xattr_handler security_handler;
+#endif
+
+int reiserfs_xattr_register_handlers (void) __init;
+void reiserfs_xattr_unregister_handlers (void);
+
+static inline void
+reiserfs_write_lock_xattrs(struct super_block *sb)
+{
+    down_write (&REISERFS_XATTR_DIR_SEM(sb));
+}
+static inline void
+reiserfs_write_unlock_xattrs(struct super_block *sb)
+{
+    up_write (&REISERFS_XATTR_DIR_SEM(sb));
+}
+static inline void
+reiserfs_read_lock_xattrs(struct super_block *sb)
+{
+    down_read (&REISERFS_XATTR_DIR_SEM(sb));
+}
+
+static inline void
+reiserfs_read_unlock_xattrs(struct super_block *sb)
+{
+    up_read (&REISERFS_XATTR_DIR_SEM(sb));
+}
+
+static inline void
+reiserfs_write_lock_xattr_i(struct inode *inode)
+{
+    down_write (&REISERFS_I(inode)->xattr_sem);
+}
+static inline void
+reiserfs_write_unlock_xattr_i(struct inode *inode)
+{
+    up_write (&REISERFS_I(inode)->xattr_sem);
+}
+static inline void
+reiserfs_read_lock_xattr_i(struct inode *inode)
+{
+    down_read (&REISERFS_I(inode)->xattr_sem);
+}
+
+static inline void
+reiserfs_read_unlock_xattr_i(struct inode *inode)
+{
+    up_read (&REISERFS_I(inode)->xattr_sem);
+}
+
+static inline void
+reiserfs_mark_inode_private(struct inode *inode)
+{
+    inode->i_flags |= S_PRIVATE;
+}
+
+#else
+
+#define is_reiserfs_priv_object(inode) 0
+#define reiserfs_mark_inode_private(inode)
+#define reiserfs_getxattr NULL
+#define reiserfs_setxattr NULL
+#define reiserfs_listxattr NULL
+#define reiserfs_removexattr NULL
+#define reiserfs_write_lock_xattrs(sb)
+#define reiserfs_write_unlock_xattrs(sb)
+#define reiserfs_read_lock_xattrs(sb)
+#define reiserfs_read_unlock_xattrs(sb)
+
+#define reiserfs_permission NULL
+
+#define reiserfs_xattr_register_handlers() 0
+#define reiserfs_xattr_unregister_handlers()
+
+static inline int reiserfs_delete_xattrs (struct inode *inode) { return 0; };
+static inline int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs) { return 0; };
+static inline int reiserfs_xattr_init (struct super_block *sb, int mount_flags)
+{
+    sb->s_flags = (sb->s_flags & ~MS_POSIXACL); /* to be sure */
+    return 0;
+};
+#endif
+
+#endif  /* __KERNEL__ */
diff --git a/include/linux/resource.h b/include/linux/resource.h
new file mode 100644
index 000000000000..21a86cb6acdb
--- /dev/null
+++ b/include/linux/resource.h
@@ -0,0 +1,70 @@
+#ifndef _LINUX_RESOURCE_H
+#define _LINUX_RESOURCE_H
+
+#include <linux/time.h>
+
+/*
+ * Resource control/accounting header file for linux
+ */
+
+/*
+ * Definition of struct rusage taken from BSD 4.3 Reno
+ * 
+ * We don't support all of these yet, but we might as well have them....
+ * Otherwise, each time we add new items, programs which depend on this
+ * structure will lose.  This reduces the chances of that happening.
+ */
+#define RUSAGE_SELF     0
+#define RUSAGE_CHILDREN (-1)
+#define RUSAGE_BOTH     (-2)            /* sys_wait4() uses this */
+
+struct  rusage {
+        struct timeval ru_utime;        /* user time used */
+        struct timeval ru_stime;        /* system time used */
+        long    ru_maxrss;              /* maximum resident set size */
+        long    ru_ixrss;               /* integral shared memory size */
+        long    ru_idrss;               /* integral unshared data size */
+        long    ru_isrss;               /* integral unshared stack size */
+        long    ru_minflt;              /* page reclaims */
+        long    ru_majflt;              /* page faults */
+        long    ru_nswap;               /* swaps */
+        long    ru_inblock;             /* block input operations */
+        long    ru_oublock;             /* block output operations */
+        long    ru_msgsnd;              /* messages sent */
+        long    ru_msgrcv;              /* messages received */
+        long    ru_nsignals;            /* signals received */
+        long    ru_nvcsw;               /* voluntary context switches */
+        long    ru_nivcsw;              /* involuntary " */
+};
+
+struct rlimit {
+        unsigned long   rlim_cur;
+        unsigned long   rlim_max;
+};
+
+#define PRIO_MIN        (-20)
+#define PRIO_MAX        20
+
+#define PRIO_PROCESS    0
+#define PRIO_PGRP       1
+#define PRIO_USER       2
+
+/*
+ * Limit the stack by to some sane default: root can always
+ * increase this limit if needed..  8MB seems reasonable.
+ */
+#define _STK_LIM        (8*1024*1024)
+
+/*
+ * GPG wants 32kB of mlocked memory, to make sure pass phrases
+ * and other sensitive information are never written to disk.
+ */
+#define MLOCK_LIMIT     (8 * PAGE_SIZE)
+
+/*
+ * Due to binary compatibility, the actual resource numbers
+ * may be different for different linux versions..
+ */
+#include <asm/resource.h>
+
+#endif
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
new file mode 100644
index 000000000000..11b484e37ac9
--- /dev/null
+++ b/include/linux/rmap.h
@@ -0,0 +1,118 @@
+#ifndef _LINUX_RMAP_H
+#define _LINUX_RMAP_H
+/*
+ * Declarations for Reverse Mapping functions in mm/rmap.c
+ */
+
+#include <linux/config.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/spinlock.h>
+
+/*
+ * The anon_vma heads a list of private "related" vmas, to scan if
+ * an anonymous page pointing to this anon_vma needs to be unmapped:
+ * the vmas on the list will be related by forking, or by splitting.
+ *
+ * Since vmas come and go as they are split and merged (particularly
+ * in mprotect), the mapping field of an anonymous page cannot point
+ * directly to a vma: instead it points to an anon_vma, on whose list
+ * the related vmas can be easily linked or unlinked.
+ *
+ * After unlinking the last vma on the list, we must garbage collect
+ * the anon_vma object itself: we're guaranteed no page can be
+ * pointing to this anon_vma once its vma list is empty.
+ */
+struct anon_vma {
+        spinlock_t lock;        /* Serialize access to vma list */
+        struct list_head head;  /* List of private "related" vmas */
+};
+
+#ifdef CONFIG_MMU
+
+extern kmem_cache_t *anon_vma_cachep;
+
+static inline struct anon_vma *anon_vma_alloc(void)
+{
+        return kmem_cache_alloc(anon_vma_cachep, SLAB_KERNEL);
+}
+
+static inline void anon_vma_free(struct anon_vma *anon_vma)
+{
+        kmem_cache_free(anon_vma_cachep, anon_vma);
+}
+
+static inline void anon_vma_lock(struct vm_area_struct *vma)
+{
+        struct anon_vma *anon_vma = vma->anon_vma;
+        if (anon_vma)
+                spin_lock(&anon_vma->lock);
+}
+
+static inline void anon_vma_unlock(struct vm_area_struct *vma)
+{
+        struct anon_vma *anon_vma = vma->anon_vma;
+        if (anon_vma)
+                spin_unlock(&anon_vma->lock);
+}
+
+/*
+ * anon_vma helper functions.
+ */
+void anon_vma_init(void);       /* create anon_vma_cachep */
+int  anon_vma_prepare(struct vm_area_struct *);
+void __anon_vma_merge(struct vm_area_struct *, struct vm_area_struct *);
+void anon_vma_unlink(struct vm_area_struct *);
+void anon_vma_link(struct vm_area_struct *);
+void __anon_vma_link(struct vm_area_struct *);
+
+/*
+ * rmap interfaces called when adding or removing pte of page
+ */
+void page_add_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
+void page_add_file_rmap(struct page *);
+void page_remove_rmap(struct page *);
+
+/**
+ * page_dup_rmap - duplicate pte mapping to a page
+ * @page:       the page to add the mapping to
+ *
+ * For copy_page_range only: minimal extract from page_add_rmap,
+ * avoiding unnecessary tests (already checked) so it's quicker.
+ */
+static inline void page_dup_rmap(struct page *page)
+{
+        atomic_inc(&page->_mapcount);
+}
+
+/*
+ * Called from mm/vmscan.c to handle paging out
+ */
+int page_referenced(struct page *, int is_locked, int ignore_token);
+int try_to_unmap(struct page *);
+
+/*
+ * Used by swapoff to help locate where page is expected in vma.
+ */
+unsigned long page_address_in_vma(struct page *, struct vm_area_struct *);
+
+#else   /* !CONFIG_MMU */
+
+#define anon_vma_init()         do {} while (0)
+#define anon_vma_prepare(vma)   (0)
+#define anon_vma_link(vma)      do {} while (0)
+
+#define page_referenced(page,l,i) TestClearPageReferenced(page)
+#define try_to_unmap(page)      SWAP_FAIL
+
+#endif  /* CONFIG_MMU */
+
+/*
+ * Return values of try_to_unmap
+ */
+#define SWAP_SUCCESS    0
+#define SWAP_AGAIN      1
+#define SWAP_FAIL       2
+
+#endif  /* _LINUX_RMAP_H */
diff --git a/include/linux/romfs_fs.h b/include/linux/romfs_fs.h
new file mode 100644
index 000000000000..e20bbf9eb365
--- /dev/null
+++ b/include/linux/romfs_fs.h
@@ -0,0 +1,61 @@
+#ifndef __LINUX_ROMFS_FS_H
+#define __LINUX_ROMFS_FS_H
+
+/* The basic structures of the romfs filesystem */
+
+#define ROMBSIZE BLOCK_SIZE
+#define ROMBSBITS BLOCK_SIZE_BITS
+#define ROMBMASK (ROMBSIZE-1)
+#define ROMFS_MAGIC 0x7275
+
+#define ROMFS_MAXFN 128
+
+#define __mkw(h,l) (((h)&0x00ff)<< 8|((l)&0x00ff))
+#define __mkl(h,l) (((h)&0xffff)<<16|((l)&0xffff))
+#define __mk4(a,b,c,d) cpu_to_be32(__mkl(__mkw(a,b),__mkw(c,d)))
+#define ROMSB_WORD0 __mk4('-','r','o','m')
+#define ROMSB_WORD1 __mk4('1','f','s','-')
+
+/* On-disk "super block" */
+
+struct romfs_super_block {
+        __be32 word0;
+        __be32 word1;
+        __be32 size;
+        __be32 checksum;
+        char name[0];           /* volume name */
+};
+
+/* On disk inode */
+
+struct romfs_inode {
+        __be32 next;            /* low 4 bits see ROMFH_ */
+        __be32 spec;
+        __be32 size;
+        __be32 checksum;
+        char name[0];
+};
+
+#define ROMFH_TYPE 7
+#define ROMFH_HRD 0
+#define ROMFH_DIR 1
+#define ROMFH_REG 2
+#define ROMFH_SYM 3
+#define ROMFH_BLK 4
+#define ROMFH_CHR 5
+#define ROMFH_SCK 6
+#define ROMFH_FIF 7
+#define ROMFH_EXEC 8
+
+/* Alignment */
+
+#define ROMFH_SIZE 16
+#define ROMFH_PAD (ROMFH_SIZE-1)
+#define ROMFH_MASK (~ROMFH_PAD)
+
+#ifdef __KERNEL__
+
+/* Not much now */
+
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/root_dev.h b/include/linux/root_dev.h
new file mode 100644
index 000000000000..ea4bc9d13735
--- /dev/null
+++ b/include/linux/root_dev.h
@@ -0,0 +1,21 @@
+#ifndef _ROOT_DEV_H_
+#define _ROOT_DEV_H_
+
+#include <linux/major.h>
+
+enum {
+        Root_NFS = MKDEV(UNNAMED_MAJOR, 255),
+        Root_RAM0 = MKDEV(RAMDISK_MAJOR, 0),
+        Root_RAM1 = MKDEV(RAMDISK_MAJOR, 1),
+        Root_FD0 = MKDEV(FLOPPY_MAJOR, 0),
+        Root_HDA1 = MKDEV(IDE0_MAJOR, 1),
+        Root_HDA2 = MKDEV(IDE0_MAJOR, 2),
+        Root_SDA1 = MKDEV(SCSI_DISK0_MAJOR, 1),
+        Root_SDA2 = MKDEV(SCSI_DISK0_MAJOR, 2),
+        Root_HDC1 = MKDEV(IDE1_MAJOR, 1),
+        Root_SR0 = MKDEV(SCSI_CDROM_MAJOR, 0),
+};
+
+extern dev_t ROOT_DEV;
+
+#endif
diff --git a/include/linux/rose.h b/include/linux/rose.h
new file mode 100644
index 000000000000..c7b4b184c82e
--- /dev/null
+++ b/include/linux/rose.h
@@ -0,0 +1,87 @@
+/*
+ * These are the public elements of the Linux kernel Rose implementation.
+ * For kernel AX.25 see the file ax25.h. This file requires ax25.h for the
+ * definition of the ax25_address structure.
+ */
+
+#ifndef ROSE_KERNEL_H
+#define ROSE_KERNEL_H
+
+#define ROSE_MTU        251
+
+#define ROSE_MAX_DIGIS 6
+
+#define ROSE_DEFER      1
+#define ROSE_T1         2
+#define ROSE_T2         3
+#define ROSE_T3         4
+#define ROSE_IDLE       5
+#define ROSE_QBITINCL   6
+#define ROSE_HOLDBACK   7
+
+#define SIOCRSGCAUSE            (SIOCPROTOPRIVATE+0)
+#define SIOCRSSCAUSE            (SIOCPROTOPRIVATE+1)
+#define SIOCRSL2CALL            (SIOCPROTOPRIVATE+2)
+#define SIOCRSSL2CALL           (SIOCPROTOPRIVATE+2)
+#define SIOCRSACCEPT            (SIOCPROTOPRIVATE+3)
+#define SIOCRSCLRRT             (SIOCPROTOPRIVATE+4)
+#define SIOCRSGL2CALL           (SIOCPROTOPRIVATE+5)
+#define SIOCRSGFACILITIES       (SIOCPROTOPRIVATE+6)
+
+#define ROSE_DTE_ORIGINATED     0x00
+#define ROSE_NUMBER_BUSY        0x01
+#define ROSE_INVALID_FACILITY   0x03
+#define ROSE_NETWORK_CONGESTION 0x05
+#define ROSE_OUT_OF_ORDER       0x09
+#define ROSE_ACCESS_BARRED      0x0B
+#define ROSE_NOT_OBTAINABLE     0x0D
+#define ROSE_REMOTE_PROCEDURE   0x11
+#define ROSE_LOCAL_PROCEDURE    0x13
+#define ROSE_SHIP_ABSENT        0x39
+
+typedef struct {
+        char            rose_addr[5];
+} rose_address;
+
+struct sockaddr_rose {
+        sa_family_t     srose_family;
+        rose_address    srose_addr;
+        ax25_address    srose_call;
+        int             srose_ndigis;
+        ax25_address    srose_digi;
+};
+
+struct full_sockaddr_rose {
+        sa_family_t     srose_family;
+        rose_address    srose_addr;
+        ax25_address    srose_call;
+        unsigned int    srose_ndigis;
+        ax25_address    srose_digis[ROSE_MAX_DIGIS];
+};
+
+struct rose_route_struct {
+        rose_address    address;
+        unsigned short  mask;
+        ax25_address    neighbour;
+        char            device[16];
+        unsigned char   ndigis;
+        ax25_address    digipeaters[AX25_MAX_DIGIS];
+};
+
+struct rose_cause_struct {
+        unsigned char   cause;
+        unsigned char   diagnostic;
+};
+
+struct rose_facilities_struct {
+        rose_address    source_addr,   dest_addr;
+        ax25_address    source_call,   dest_call;
+        unsigned char   source_ndigis, dest_ndigis;
+        ax25_address    source_digis[ROSE_MAX_DIGIS];
+        ax25_address    dest_digis[ROSE_MAX_DIGIS];
+        unsigned int    rand;
+        rose_address    fail_addr;
+        ax25_address    fail_call;
+};
+
+#endif
diff --git a/include/linux/route.h b/include/linux/route.h
new file mode 100644
index 000000000000..f7ed35d5e653
--- /dev/null
+++ b/include/linux/route.h
@@ -0,0 +1,70 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the IP router interface.
+ *
+ * Version:     @(#)route.h     1.0.3   05/27/93
+ *
+ * Authors:     Original taken from Berkeley UNIX 4.3, (c) UCB 1986-1988
+ *              for the purposes of compatibility only.
+ *
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ * Changes:
+ *              Mike McLagan    :       Routing by source
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_ROUTE_H
+#define _LINUX_ROUTE_H
+
+#include <linux/if.h>
+#include <linux/compiler.h>
+
+/* This structure gets passed by the SIOCADDRT and SIOCDELRT calls. */
+struct rtentry 
+{
+        unsigned long   rt_pad1;
+        struct sockaddr rt_dst;         /* target address               */
+        struct sockaddr rt_gateway;     /* gateway addr (RTF_GATEWAY)   */
+        struct sockaddr rt_genmask;     /* target network mask (IP)     */
+        unsigned short  rt_flags;
+        short           rt_pad2;
+        unsigned long   rt_pad3;
+        void            *rt_pad4;
+        short           rt_metric;      /* +1 for binary compatibility! */
+        char __user     *rt_dev;        /* forcing the device at add    */
+        unsigned long   rt_mtu;         /* per route MTU/Window         */
+#ifndef __KERNEL__
+#define rt_mss  rt_mtu                  /* Compatibility :-(            */
+#endif
+        unsigned long   rt_window;      /* Window clamping              */
+        unsigned short  rt_irtt;        /* Initial RTT                  */
+};
+
+
+#define RTF_UP          0x0001          /* route usable                 */
+#define RTF_GATEWAY     0x0002          /* destination is a gateway     */
+#define RTF_HOST        0x0004          /* host entry (net otherwise)   */
+#define RTF_REINSTATE   0x0008          /* reinstate route after tmout  */
+#define RTF_DYNAMIC     0x0010          /* created dyn. (by redirect)   */
+#define RTF_MODIFIED    0x0020          /* modified dyn. (by redirect)  */
+#define RTF_MTU         0x0040          /* specific MTU for this route  */
+#define RTF_MSS         RTF_MTU         /* Compatibility :-(            */
+#define RTF_WINDOW      0x0080          /* per route window clamping    */
+#define RTF_IRTT        0x0100          /* Initial round trip time      */
+#define RTF_REJECT      0x0200          /* Reject route                 */
+
+/*
+ *      <linux/ipv6_route.h> uses RTF values >= 64k
+ */
+
+
+
+#endif  /* _LINUX_ROUTE_H */
+
diff --git a/include/linux/rslib.h b/include/linux/rslib.h
new file mode 100644
index 000000000000..980c8f74d8dc
--- /dev/null
+++ b/include/linux/rslib.h
@@ -0,0 +1,105 @@
+/* 
+ * include/linux/rslib.h
+ *
+ * Overview:
+ *   Generic Reed Solomon encoder / decoder library
+ *   
+ * Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
+ *
+ * RS code lifted from reed solomon library written by Phil Karn
+ * Copyright 2002 Phil Karn, KA9Q
+ *
+ * $Id: rslib.h,v 1.3 2004/10/05 22:08:22 gleixner Exp $
+ *
+ * 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 _RSLIB_H_
+#define _RSLIB_H_
+
+#include <linux/list.h>
+
+/** 
+ * struct rs_control - rs control structure
+ * 
+ * @mm:         Bits per symbol
+ * @nn:         Symbols per block (= (1<<mm)-1)
+ * @alpha_to:   log lookup table
+ * @index_of:   Antilog lookup table
+ * @genpoly:    Generator polynomial 
+ * @nroots:     Number of generator roots = number of parity symbols
+ * @fcr:        First consecutive root, index form
+ * @prim:       Primitive element, index form 
+ * @iprim:      prim-th root of 1, index form 
+ * @gfpoly:     The primitive generator polynominal 
+ * @users:      Users of this structure 
+ * @list:       List entry for the rs control list
+*/
+struct rs_control {
+        int             mm;
+        int             nn;
+        uint16_t        *alpha_to;
+        uint16_t        *index_of;
+        uint16_t        *genpoly;
+        int             nroots;
+        int             fcr;
+        int             prim;
+        int             iprim;
+        int             gfpoly;
+        int             users;
+        struct list_head list;
+};
+
+/* General purpose RS codec, 8-bit data width, symbol width 1-15 bit  */
+#ifdef CONFIG_REED_SOLOMON_ENC8
+int encode_rs8(struct rs_control *rs, uint8_t *data, int len, uint16_t *par,
+               uint16_t invmsk);
+#endif
+#ifdef CONFIG_REED_SOLOMON_DEC8
+int decode_rs8(struct rs_control *rs, uint8_t *data, uint16_t *par, int len, 
+                uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk,
+               uint16_t *corr);
+#endif
+
+/* General purpose RS codec, 16-bit data width, symbol width 1-15 bit  */
+#ifdef CONFIG_REED_SOLOMON_ENC16
+int encode_rs16(struct rs_control *rs, uint16_t *data, int len, uint16_t *par,
+                uint16_t invmsk);
+#endif
+#ifdef CONFIG_REED_SOLOMON_DEC16
+int decode_rs16(struct rs_control *rs, uint16_t *data, uint16_t *par, int len,
+                uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk,
+                uint16_t *corr);
+#endif
+
+/* Create or get a matching rs control structure */
+struct rs_control *init_rs(int symsize, int gfpoly, int fcr, int prim, 
+                           int nroots);
+
+/* Release a rs control structure */
+void free_rs(struct rs_control *rs);
+
+/** modulo replacement for galois field arithmetics
+ *
+ *  @rs:        the rs control structure
+ *  @x:         the value to reduce
+ *
+ *  where
+ *  rs->mm = number of bits per symbol  
+ *  rs->nn = (2^rs->mm) - 1
+ *  
+ *  Simple arithmetic modulo would return a wrong result for values
+ *  >= 3 * rs->nn
+*/
+static inline int rs_modnn(struct rs_control *rs, int x)
+{
+        while (x >= rs->nn) {
+                x -= rs->nn;
+                x = (x >> rs->mm) + (x & rs->nn);
+        }
+        return x;
+}
+
+#endif
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
new file mode 100644
index 000000000000..e1aaf1fac8e0
--- /dev/null
+++ b/include/linux/rtc.h
@@ -0,0 +1,108 @@
+/*
+ * Generic RTC interface.
+ * This version contains the part of the user interface to the Real Time Clock
+ * service. It is used with both the legacy mc146818 and also  EFI
+ * Struct rtc_time and first 12 ioctl by Paul Gortmaker, 1996 - separated out
+ * from <linux/mc146818rtc.h> to this file for 2.4 kernels.
+ * 
+ * Copyright (C) 1999 Hewlett-Packard Co.
+ * Copyright (C) 1999 Stephane Eranian <eranian@hpl.hp.com>
+ */
+#ifndef _LINUX_RTC_H_
+#define _LINUX_RTC_H_
+
+/*
+ * The struct used to pass data via the following ioctl. Similar to the
+ * struct tm in <time.h>, but it needs to be here so that the kernel 
+ * source is self contained, allowing cross-compiles, etc. etc.
+ */
+
+struct rtc_time {
+        int tm_sec;
+        int tm_min;
+        int tm_hour;
+        int tm_mday;
+        int tm_mon;
+        int tm_year;
+        int tm_wday;
+        int tm_yday;
+        int tm_isdst;
+};
+
+/*
+ * This data structure is inspired by the EFI (v0.92) wakeup
+ * alarm API.
+ */
+struct rtc_wkalrm {
+        unsigned char enabled;  /* 0 = alarm disable, 1 = alarm disabled */
+        unsigned char pending;  /* 0 = alarm pending, 1 = alarm not pending */
+        struct rtc_time time;   /* time the alarm is set to */
+};
+
+/*
+ * Data structure to control PLL correction some better RTC feature
+ * pll_value is used to get or set current value of correction,
+ * the rest of the struct is used to query HW capabilities.
+ * This is modeled after the RTC used in Q40/Q60 computers but
+ * should be sufficiently flexible for other devices
+ *
+ * +ve pll_value means clock will run faster by
+ *   pll_value*pll_posmult/pll_clock
+ * -ve pll_value means clock will run slower by
+ *   pll_value*pll_negmult/pll_clock
+ */ 
+
+struct rtc_pll_info {
+        int pll_ctrl;       /* placeholder for fancier control */
+        int pll_value;      /* get/set correction value */
+        int pll_max;        /* max +ve (faster) adjustment value */
+        int pll_min;        /* max -ve (slower) adjustment value */
+        int pll_posmult;    /* factor for +ve correction */
+        int pll_negmult;    /* factor for -ve correction */
+        long pll_clock;     /* base PLL frequency */
+};
+
+/*
+ * ioctl calls that are permitted to the /dev/rtc interface, if
+ * any of the RTC drivers are enabled.
+ */
+
+#define RTC_AIE_ON      _IO('p', 0x01)  /* Alarm int. enable on         */
+#define RTC_AIE_OFF     _IO('p', 0x02)  /* ... off                      */
+#define RTC_UIE_ON      _IO('p', 0x03)  /* Update int. enable on        */
+#define RTC_UIE_OFF     _IO('p', 0x04)  /* ... off                      */
+#define RTC_PIE_ON      _IO('p', 0x05)  /* Periodic int. enable on      */
+#define RTC_PIE_OFF     _IO('p', 0x06)  /* ... off                      */
+#define RTC_WIE_ON      _IO('p', 0x0f)  /* Watchdog int. enable on      */
+#define RTC_WIE_OFF     _IO('p', 0x10)  /* ... off                      */
+
+#define RTC_ALM_SET     _IOW('p', 0x07, struct rtc_time) /* Set alarm time  */
+#define RTC_ALM_READ    _IOR('p', 0x08, struct rtc_time) /* Read alarm time */
+#define RTC_RD_TIME     _IOR('p', 0x09, struct rtc_time) /* Read RTC time   */
+#define RTC_SET_TIME    _IOW('p', 0x0a, struct rtc_time) /* Set RTC time    */
+#define RTC_IRQP_READ   _IOR('p', 0x0b, unsigned long)   /* Read IRQ rate   */
+#define RTC_IRQP_SET    _IOW('p', 0x0c, unsigned long)   /* Set IRQ rate    */
+#define RTC_EPOCH_READ  _IOR('p', 0x0d, unsigned long)   /* Read epoch      */
+#define RTC_EPOCH_SET   _IOW('p', 0x0e, unsigned long)   /* Set epoch       */
+
+#define RTC_WKALM_SET   _IOW('p', 0x0f, struct rtc_wkalrm)/* Set wakeup alarm*/
+#define RTC_WKALM_RD    _IOR('p', 0x10, struct rtc_wkalrm)/* Get wakeup alarm*/
+
+#define RTC_PLL_GET     _IOR('p', 0x11, struct rtc_pll_info)  /* Get PLL correction */
+#define RTC_PLL_SET     _IOW('p', 0x12, struct rtc_pll_info)  /* Set PLL correction */
+
+#ifdef __KERNEL__
+
+typedef struct rtc_task {
+        void (*func)(void *private_data);
+        void *private_data;
+} rtc_task_t;
+
+int rtc_register(rtc_task_t *task);
+int rtc_unregister(rtc_task_t *task);
+int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
+void rtc_get_rtc_time(struct rtc_time *rtc_tm);
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_RTC_H_ */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
new file mode 100644
index 000000000000..32e52769a00b
--- /dev/null
+++ b/include/linux/rtnetlink.h
@@ -0,0 +1,842 @@
+#ifndef __LINUX_RTNETLINK_H
+#define __LINUX_RTNETLINK_H
+
+#include <linux/netlink.h>
+
+/****
+ *              Routing/neighbour discovery messages.
+ ****/
+
+/* Types of messages */
+
+enum {
+        RTM_BASE        = 16,
+#define RTM_BASE        RTM_BASE
+
+        RTM_NEWLINK     = 16,
+#define RTM_NEWLINK     RTM_NEWLINK
+        RTM_DELLINK,
+#define RTM_DELLINK     RTM_DELLINK
+        RTM_GETLINK,
+#define RTM_GETLINK     RTM_GETLINK
+        RTM_SETLINK,
+#define RTM_SETLINK     RTM_SETLINK
+
+        RTM_NEWADDR     = 20,
+#define RTM_NEWADDR     RTM_NEWADDR
+        RTM_DELADDR,
+#define RTM_DELADDR     RTM_DELADDR
+        RTM_GETADDR,
+#define RTM_GETADDR     RTM_GETADDR
+
+        RTM_NEWROUTE    = 24,
+#define RTM_NEWROUTE    RTM_NEWROUTE
+        RTM_DELROUTE,
+#define RTM_DELROUTE    RTM_DELROUTE
+        RTM_GETROUTE,
+#define RTM_GETROUTE    RTM_GETROUTE
+
+        RTM_NEWNEIGH    = 28,
+#define RTM_NEWNEIGH    RTM_NEWNEIGH
+        RTM_DELNEIGH,
+#define RTM_DELNEIGH    RTM_DELNEIGH
+        RTM_GETNEIGH,
+#define RTM_GETNEIGH    RTM_GETNEIGH
+
+        RTM_NEWRULE     = 32,
+#define RTM_NEWRULE     RTM_NEWRULE
+        RTM_DELRULE,
+#define RTM_DELRULE     RTM_DELRULE
+        RTM_GETRULE,
+#define RTM_GETRULE     RTM_GETRULE
+
+        RTM_NEWQDISC    = 36,
+#define RTM_NEWQDISC    RTM_NEWQDISC
+        RTM_DELQDISC,
+#define RTM_DELQDISC    RTM_DELQDISC
+        RTM_GETQDISC,
+#define RTM_GETQDISC    RTM_GETQDISC
+
+        RTM_NEWTCLASS   = 40,
+#define RTM_NEWTCLASS   RTM_NEWTCLASS
+        RTM_DELTCLASS,
+#define RTM_DELTCLASS   RTM_DELTCLASS
+        RTM_GETTCLASS,
+#define RTM_GETTCLASS   RTM_GETTCLASS
+
+        RTM_NEWTFILTER  = 44,
+#define RTM_NEWTFILTER  RTM_NEWTFILTER
+        RTM_DELTFILTER,
+#define RTM_DELTFILTER  RTM_DELTFILTER
+        RTM_GETTFILTER,
+#define RTM_GETTFILTER  RTM_GETTFILTER
+
+        RTM_NEWACTION   = 48,
+#define RTM_NEWACTION   RTM_NEWACTION
+        RTM_DELACTION,
+#define RTM_DELACTION   RTM_DELACTION
+        RTM_GETACTION,
+#define RTM_GETACTION   RTM_GETACTION
+
+        RTM_NEWPREFIX   = 52,
+#define RTM_NEWPREFIX   RTM_NEWPREFIX
+        RTM_GETPREFIX   = 54,
+#define RTM_GETPREFIX   RTM_GETPREFIX
+
+        RTM_GETMULTICAST = 58,
+#define RTM_GETMULTICAST RTM_GETMULTICAST
+
+        RTM_GETANYCAST  = 62,
+#define RTM_GETANYCAST  RTM_GETANYCAST
+
+        RTM_MAX,
+#define RTM_MAX         RTM_MAX
+};
+
+/* 
+   Generic structure for encapsulation of optional route information.
+   It is reminiscent of sockaddr, but with sa_family replaced
+   with attribute type.
+ */
+
+struct rtattr
+{
+        unsigned short  rta_len;
+        unsigned short  rta_type;
+};
+
+/* Macros to handle rtattributes */
+
+#define RTA_ALIGNTO     4
+#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
+#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
+                         (rta)->rta_len >= sizeof(struct rtattr) && \
+                         (rta)->rta_len <= (len))
+#define RTA_NEXT(rta,attrlen)   ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
+                                 (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
+#define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
+#define RTA_SPACE(len)  RTA_ALIGN(RTA_LENGTH(len))
+#define RTA_DATA(rta)   ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
+#define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
+
+
+
+
+/******************************************************************************
+ *              Definitions used in routing table administration.
+ ****/
+
+struct rtmsg
+{
+        unsigned char           rtm_family;
+        unsigned char           rtm_dst_len;
+        unsigned char           rtm_src_len;
+        unsigned char           rtm_tos;
+
+        unsigned char           rtm_table;      /* Routing table id */
+        unsigned char           rtm_protocol;   /* Routing protocol; see below  */
+        unsigned char           rtm_scope;      /* See below */ 
+        unsigned char           rtm_type;       /* See below    */
+
+        unsigned                rtm_flags;
+};
+
+/* rtm_type */
+
+enum
+{
+        RTN_UNSPEC,
+        RTN_UNICAST,            /* Gateway or direct route      */
+        RTN_LOCAL,              /* Accept locally               */
+        RTN_BROADCAST,          /* Accept locally as broadcast,
+                                   send as broadcast */
+        RTN_ANYCAST,            /* Accept locally as broadcast,
+                                   but send as unicast */
+        RTN_MULTICAST,          /* Multicast route              */
+        RTN_BLACKHOLE,          /* Drop                         */
+        RTN_UNREACHABLE,        /* Destination is unreachable   */
+        RTN_PROHIBIT,           /* Administratively prohibited  */
+        RTN_THROW,              /* Not in this table            */
+        RTN_NAT,                /* Translate this address       */
+        RTN_XRESOLVE,           /* Use external resolver        */
+        __RTN_MAX
+};
+
+#define RTN_MAX (__RTN_MAX - 1)
+
+
+/* rtm_protocol */
+
+#define RTPROT_UNSPEC   0
+#define RTPROT_REDIRECT 1       /* Route installed by ICMP redirects;
+                                   not used by current IPv4 */
+#define RTPROT_KERNEL   2       /* Route installed by kernel            */
+#define RTPROT_BOOT     3       /* Route installed during boot          */
+#define RTPROT_STATIC   4       /* Route installed by administrator     */
+
+/* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
+   they are just passed from user and back as is.
+   It will be used by hypothetical multiple routing daemons.
+   Note that protocol values should be standardized in order to
+   avoid conflicts.
+ */
+
+#define RTPROT_GATED    8       /* Apparently, GateD */
+#define RTPROT_RA       9       /* RDISC/ND router advertisements */
+#define RTPROT_MRT      10      /* Merit MRT */
+#define RTPROT_ZEBRA    11      /* Zebra */
+#define RTPROT_BIRD     12      /* BIRD */
+#define RTPROT_DNROUTED 13      /* DECnet routing daemon */
+#define RTPROT_XORP     14      /* XORP */
+
+/* rtm_scope
+
+   Really it is not scope, but sort of distance to the destination.
+   NOWHERE are reserved for not existing destinations, HOST is our
+   local addresses, LINK are destinations, located on directly attached
+   link and UNIVERSE is everywhere in the Universe.
+
+   Intermediate values are also possible f.e. interior routes
+   could be assigned a value between UNIVERSE and LINK.
+*/
+
+enum rt_scope_t
+{
+        RT_SCOPE_UNIVERSE=0,
+/* User defined values  */
+        RT_SCOPE_SITE=200,
+        RT_SCOPE_LINK=253,
+        RT_SCOPE_HOST=254,
+        RT_SCOPE_NOWHERE=255
+};
+
+/* rtm_flags */
+
+#define RTM_F_NOTIFY            0x100   /* Notify user of route change  */
+#define RTM_F_CLONED            0x200   /* This route is cloned         */
+#define RTM_F_EQUALIZE          0x400   /* Multipath equalizer: NI      */
+#define RTM_F_PREFIX            0x800   /* Prefix addresses             */
+
+/* Reserved table identifiers */
+
+enum rt_class_t
+{
+        RT_TABLE_UNSPEC=0,
+/* User defined values */
+        RT_TABLE_DEFAULT=253,
+        RT_TABLE_MAIN=254,
+        RT_TABLE_LOCAL=255,
+        __RT_TABLE_MAX
+};
+#define RT_TABLE_MAX (__RT_TABLE_MAX - 1)
+
+
+
+/* Routing message attributes */
+
+enum rtattr_type_t
+{
+        RTA_UNSPEC,
+        RTA_DST,
+        RTA_SRC,
+        RTA_IIF,
+        RTA_OIF,
+        RTA_GATEWAY,
+        RTA_PRIORITY,
+        RTA_PREFSRC,
+        RTA_METRICS,
+        RTA_MULTIPATH,
+        RTA_PROTOINFO,
+        RTA_FLOW,
+        RTA_CACHEINFO,
+        RTA_SESSION,
+        RTA_MP_ALGO,
+        __RTA_MAX
+};
+
+#define RTA_MAX (__RTA_MAX - 1)
+
+#define RTM_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
+#define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
+
+/* RTM_MULTIPATH --- array of struct rtnexthop.
+ *
+ * "struct rtnexthop" describes all necessary nexthop information,
+ * i.e. parameters of path to a destination via this nexthop.
+ *
+ * At the moment it is impossible to set different prefsrc, mtu, window
+ * and rtt for different paths from multipath.
+ */
+
+struct rtnexthop
+{
+        unsigned short          rtnh_len;
+        unsigned char           rtnh_flags;
+        unsigned char           rtnh_hops;
+        int                     rtnh_ifindex;
+};
+
+/* rtnh_flags */
+
+#define RTNH_F_DEAD             1       /* Nexthop is dead (used by multipath)  */
+#define RTNH_F_PERVASIVE        2       /* Do recursive gateway lookup  */
+#define RTNH_F_ONLINK           4       /* Gateway is forced on link    */
+
+/* Macros to handle hexthops */
+
+#define RTNH_ALIGNTO    4
+#define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
+#define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
+                           ((int)(rtnh)->rtnh_len) <= (len))
+#define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
+#define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
+#define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
+#define RTNH_DATA(rtnh)   ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
+
+/* RTM_CACHEINFO */
+
+struct rta_cacheinfo
+{
+        __u32   rta_clntref;
+        __u32   rta_lastuse;
+        __s32   rta_expires;
+        __u32   rta_error;
+        __u32   rta_used;
+
+#define RTNETLINK_HAVE_PEERINFO 1
+        __u32   rta_id;
+        __u32   rta_ts;
+        __u32   rta_tsage;
+};
+
+/* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
+
+enum
+{
+        RTAX_UNSPEC,
+#define RTAX_UNSPEC RTAX_UNSPEC
+        RTAX_LOCK,
+#define RTAX_LOCK RTAX_LOCK
+        RTAX_MTU,
+#define RTAX_MTU RTAX_MTU
+        RTAX_WINDOW,
+#define RTAX_WINDOW RTAX_WINDOW
+        RTAX_RTT,
+#define RTAX_RTT RTAX_RTT
+        RTAX_RTTVAR,
+#define RTAX_RTTVAR RTAX_RTTVAR
+        RTAX_SSTHRESH,
+#define RTAX_SSTHRESH RTAX_SSTHRESH
+        RTAX_CWND,
+#define RTAX_CWND RTAX_CWND
+        RTAX_ADVMSS,
+#define RTAX_ADVMSS RTAX_ADVMSS
+        RTAX_REORDERING,
+#define RTAX_REORDERING RTAX_REORDERING
+        RTAX_HOPLIMIT,
+#define RTAX_HOPLIMIT RTAX_HOPLIMIT
+        RTAX_INITCWND,
+#define RTAX_INITCWND RTAX_INITCWND
+        RTAX_FEATURES,
+#define RTAX_FEATURES RTAX_FEATURES
+        __RTAX_MAX
+};
+
+#define RTAX_MAX (__RTAX_MAX - 1)
+
+#define RTAX_FEATURE_ECN        0x00000001
+#define RTAX_FEATURE_SACK       0x00000002
+#define RTAX_FEATURE_TIMESTAMP  0x00000004
+#define RTAX_FEATURE_ALLFRAG    0x00000008
+
+struct rta_session
+{
+        __u8    proto;
+
+        union {
+                struct {
+                        __u16   sport;
+                        __u16   dport;
+                } ports;
+
+                struct {
+                        __u8    type;
+                        __u8    code;
+                        __u16   ident;
+                } icmpt;
+
+                __u32           spi;
+        } u;
+};
+
+
+/*********************************************************
+ *              Interface address.
+ ****/
+
+struct ifaddrmsg
+{
+        unsigned char   ifa_family;
+        unsigned char   ifa_prefixlen;  /* The prefix length            */
+        unsigned char   ifa_flags;      /* Flags                        */
+        unsigned char   ifa_scope;      /* See above                    */
+        int             ifa_index;      /* Link index                   */
+};
+
+enum
+{
+        IFA_UNSPEC,
+        IFA_ADDRESS,
+        IFA_LOCAL,
+        IFA_LABEL,
+        IFA_BROADCAST,
+        IFA_ANYCAST,
+        IFA_CACHEINFO,
+        IFA_MULTICAST,
+        __IFA_MAX
+};
+
+#define IFA_MAX (__IFA_MAX - 1)
+
+/* ifa_flags */
+
+#define IFA_F_SECONDARY         0x01
+#define IFA_F_TEMPORARY         IFA_F_SECONDARY
+
+#define IFA_F_DEPRECATED        0x20
+#define IFA_F_TENTATIVE         0x40
+#define IFA_F_PERMANENT         0x80
+
+struct ifa_cacheinfo
+{
+        __u32   ifa_prefered;
+        __u32   ifa_valid;
+        __u32   cstamp; /* created timestamp, hundredths of seconds */
+        __u32   tstamp; /* updated timestamp, hundredths of seconds */
+};
+
+
+#define IFA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
+#define IFA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifaddrmsg))
+
+/*
+   Important comment:
+   IFA_ADDRESS is prefix address, rather than local interface address.
+   It makes no difference for normally configured broadcast interfaces,
+   but for point-to-point IFA_ADDRESS is DESTINATION address,
+   local address is supplied in IFA_LOCAL attribute.
+ */
+
+/**************************************************************
+ *              Neighbour discovery.
+ ****/
+
+struct ndmsg
+{
+        unsigned char   ndm_family;
+        unsigned char   ndm_pad1;
+        unsigned short  ndm_pad2;
+        int             ndm_ifindex;    /* Link index                   */
+        __u16           ndm_state;
+        __u8            ndm_flags;
+        __u8            ndm_type;
+};
+
+enum
+{
+        NDA_UNSPEC,
+        NDA_DST,
+        NDA_LLADDR,
+        NDA_CACHEINFO,
+        NDA_PROBES,
+        __NDA_MAX
+};
+
+#define NDA_MAX (__NDA_MAX - 1)
+
+#define NDA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
+#define NDA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndmsg))
+
+/*
+ *      Neighbor Cache Entry Flags
+ */
+
+#define NTF_PROXY       0x08    /* == ATF_PUBL */
+#define NTF_ROUTER      0x80
+
+/*
+ *      Neighbor Cache Entry States.
+ */
+
+#define NUD_INCOMPLETE  0x01
+#define NUD_REACHABLE   0x02
+#define NUD_STALE       0x04
+#define NUD_DELAY       0x08
+#define NUD_PROBE       0x10
+#define NUD_FAILED      0x20
+
+/* Dummy states */
+#define NUD_NOARP       0x40
+#define NUD_PERMANENT   0x80
+#define NUD_NONE        0x00
+
+
+struct nda_cacheinfo
+{
+        __u32           ndm_confirmed;
+        __u32           ndm_used;
+        __u32           ndm_updated;
+        __u32           ndm_refcnt;
+};
+
+/****
+ *              General form of address family dependent message.
+ ****/
+
+struct rtgenmsg
+{
+        unsigned char           rtgen_family;
+};
+
+/*****************************************************************
+ *              Link layer specific messages.
+ ****/
+
+/* struct ifinfomsg
+ * passes link level specific information, not dependent
+ * on network protocol.
+ */
+
+struct ifinfomsg
+{
+        unsigned char   ifi_family;
+        unsigned char   __ifi_pad;
+        unsigned short  ifi_type;               /* ARPHRD_* */
+        int             ifi_index;              /* Link index   */
+        unsigned        ifi_flags;              /* IFF_* flags  */
+        unsigned        ifi_change;             /* IFF_* change mask */
+};
+
+/********************************************************************
+ *              prefix information 
+ ****/
+
+struct prefixmsg
+{
+        unsigned char   prefix_family;
+        int             prefix_ifindex;
+        unsigned char   prefix_type;
+        unsigned char   prefix_len;
+        unsigned char   prefix_flags;
+};
+
+enum 
+{
+        PREFIX_UNSPEC,
+        PREFIX_ADDRESS,
+        PREFIX_CACHEINFO,
+        __PREFIX_MAX
+};
+
+#define PREFIX_MAX      (__PREFIX_MAX - 1)
+
+struct prefix_cacheinfo
+{
+        __u32   preferred_time;
+        __u32   valid_time;
+};
+
+/* The struct should be in sync with struct net_device_stats */
+struct rtnl_link_stats
+{
+        __u32   rx_packets;             /* total packets received       */
+        __u32   tx_packets;             /* total packets transmitted    */
+        __u32   rx_bytes;               /* total bytes received         */
+        __u32   tx_bytes;               /* total bytes transmitted      */
+        __u32   rx_errors;              /* bad packets received         */
+        __u32   tx_errors;              /* packet transmit problems     */
+        __u32   rx_dropped;             /* no space in linux buffers    */
+        __u32   tx_dropped;             /* no space available in linux  */
+        __u32   multicast;              /* multicast packets received   */
+        __u32   collisions;
+
+        /* detailed rx_errors: */
+        __u32   rx_length_errors;
+        __u32   rx_over_errors;         /* receiver ring buff overflow  */
+        __u32   rx_crc_errors;          /* recved pkt with crc error    */
+        __u32   rx_frame_errors;        /* recv'd frame alignment error */
+        __u32   rx_fifo_errors;         /* recv'r fifo overrun          */
+        __u32   rx_missed_errors;       /* receiver missed packet       */
+
+        /* detailed tx_errors */
+        __u32   tx_aborted_errors;
+        __u32   tx_carrier_errors;
+        __u32   tx_fifo_errors;
+        __u32   tx_heartbeat_errors;
+        __u32   tx_window_errors;
+        
+        /* for cslip etc */
+        __u32   rx_compressed;
+        __u32   tx_compressed;
+};
+
+/* The struct should be in sync with struct ifmap */
+struct rtnl_link_ifmap
+{
+        __u64   mem_start;
+        __u64   mem_end;
+        __u64   base_addr;
+        __u16   irq;
+        __u8    dma;
+        __u8    port;
+};
+
+enum
+{
+        IFLA_UNSPEC,
+        IFLA_ADDRESS,
+        IFLA_BROADCAST,
+        IFLA_IFNAME,
+        IFLA_MTU,
+        IFLA_LINK,
+        IFLA_QDISC,
+        IFLA_STATS,
+        IFLA_COST,
+#define IFLA_COST IFLA_COST
+        IFLA_PRIORITY,
+#define IFLA_PRIORITY IFLA_PRIORITY
+        IFLA_MASTER,
+#define IFLA_MASTER IFLA_MASTER
+        IFLA_WIRELESS,          /* Wireless Extension event - see wireless.h */
+#define IFLA_WIRELESS IFLA_WIRELESS
+        IFLA_PROTINFO,          /* Protocol specific information for a link */
+#define IFLA_PROTINFO IFLA_PROTINFO
+        IFLA_TXQLEN,
+#define IFLA_TXQLEN IFLA_TXQLEN
+        IFLA_MAP,
+#define IFLA_MAP IFLA_MAP
+        IFLA_WEIGHT,
+#define IFLA_WEIGHT IFLA_WEIGHT
+        __IFLA_MAX
+};
+
+
+#define IFLA_MAX (__IFLA_MAX - 1)
+
+#define IFLA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
+#define IFLA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifinfomsg))
+
+/* ifi_flags.
+
+   IFF_* flags.
+
+   The only change is:
+   IFF_LOOPBACK, IFF_BROADCAST and IFF_POINTOPOINT are
+   more not changeable by user. They describe link media
+   characteristics and set by device driver.
+
+   Comments:
+   - Combination IFF_BROADCAST|IFF_POINTOPOINT is invalid
+   - If neither of these three flags are set;
+     the interface is NBMA.
+
+   - IFF_MULTICAST does not mean anything special:
+   multicasts can be used on all not-NBMA links.
+   IFF_MULTICAST means that this media uses special encapsulation
+   for multicast frames. Apparently, all IFF_POINTOPOINT and
+   IFF_BROADCAST devices are able to use multicasts too.
+ */
+
+/* IFLA_LINK.
+   For usual devices it is equal ifi_index.
+   If it is a "virtual interface" (f.e. tunnel), ifi_link
+   can point to real physical interface (f.e. for bandwidth calculations),
+   or maybe 0, what means, that real media is unknown (usual
+   for IPIP tunnels, when route to endpoint is allowed to change)
+ */
+
+/* Subtype attributes for IFLA_PROTINFO */
+enum
+{
+        IFLA_INET6_UNSPEC,
+        IFLA_INET6_FLAGS,       /* link flags                   */
+        IFLA_INET6_CONF,        /* sysctl parameters            */
+        IFLA_INET6_STATS,       /* statistics                   */
+        IFLA_INET6_MCAST,       /* MC things. What of them?     */
+        IFLA_INET6_CACHEINFO,   /* time values and max reasm size */
+        __IFLA_INET6_MAX
+};
+
+#define IFLA_INET6_MAX  (__IFLA_INET6_MAX - 1)
+
+struct ifla_cacheinfo
+{
+        __u32   max_reasm_len;
+        __u32   tstamp;         /* ipv6InterfaceTable updated timestamp */
+        __u32   reachable_time;
+        __u32   retrans_time;
+};
+
+/*****************************************************************
+ *              Traffic control messages.
+ ****/
+
+struct tcmsg
+{
+        unsigned char   tcm_family;
+        unsigned char   tcm__pad1;
+        unsigned short  tcm__pad2;
+        int             tcm_ifindex;
+        __u32           tcm_handle;
+        __u32           tcm_parent;
+        __u32           tcm_info;
+};
+
+enum
+{
+        TCA_UNSPEC,
+        TCA_KIND,
+        TCA_OPTIONS,
+        TCA_STATS,
+        TCA_XSTATS,
+        TCA_RATE,
+        TCA_FCNT,
+        TCA_STATS2,
+        __TCA_MAX
+};
+
+#define TCA_MAX (__TCA_MAX - 1)
+
+#define TCA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
+#define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
+
+
+/* RTnetlink multicast groups */
+
+#define RTMGRP_LINK             1
+#define RTMGRP_NOTIFY           2
+#define RTMGRP_NEIGH            4
+#define RTMGRP_TC               8
+
+#define RTMGRP_IPV4_IFADDR      0x10
+#define RTMGRP_IPV4_MROUTE      0x20
+#define RTMGRP_IPV4_ROUTE       0x40
+
+#define RTMGRP_IPV6_IFADDR      0x100
+#define RTMGRP_IPV6_MROUTE      0x200
+#define RTMGRP_IPV6_ROUTE       0x400
+#define RTMGRP_IPV6_IFINFO      0x800
+
+#define RTMGRP_DECnet_IFADDR    0x1000
+#define RTMGRP_DECnet_ROUTE     0x4000
+
+#define RTMGRP_IPV6_PREFIX      0x20000
+
+/* TC action piece */
+struct tcamsg
+{
+        unsigned char   tca_family;
+        unsigned char   tca__pad1;
+        unsigned short  tca__pad2;
+};
+#define TA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
+#define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
+#define TCA_ACT_TAB 1 /* attr type must be >=1 */       
+#define TCAA_MAX 1
+
+/* End of information exported to user level */
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+
+extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
+static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
+{
+        int len = strlen(str) + 1;
+        return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
+}
+
+extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
+
+#define rtattr_parse_nested(tb, max, rta) \
+        rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
+
+extern struct sock *rtnl;
+
+struct rtnetlink_link
+{
+        int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
+        int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
+};
+
+extern struct rtnetlink_link * rtnetlink_links[NPROTO];
+extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
+extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
+
+extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
+
+#define RTA_PUT(skb, attrtype, attrlen, data) \
+({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
+                 goto rtattr_failure; \
+        __rta_fill(skb, attrtype, attrlen, data); }) 
+
+#define RTA_PUT_NOHDR(skb, attrlen, data) \
+({      if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
+                goto rtattr_failure; \
+        memcpy(skb_put(skb, RTA_ALIGN(attrlen)), data, attrlen); })
+                
+static inline struct rtattr *
+__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
+{
+        struct rtattr *rta;
+        int size = RTA_LENGTH(attrlen);
+
+        rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
+        rta->rta_type = attrtype;
+        rta->rta_len = size;
+        return rta;
+}
+
+#define __RTA_PUT(skb, attrtype, attrlen) \
+({      if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
+                goto rtattr_failure; \
+        __rta_reserve(skb, attrtype, attrlen); })
+
+extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
+
+extern struct semaphore rtnl_sem;
+
+#define rtnl_shlock()           down(&rtnl_sem)
+#define rtnl_shlock_nowait()    down_trylock(&rtnl_sem)
+
+#define rtnl_shunlock() do { up(&rtnl_sem); \
+                             if (rtnl && rtnl->sk_receive_queue.qlen) \
+                                     rtnl->sk_data_ready(rtnl, 0); \
+                        } while(0)
+
+extern void rtnl_lock(void);
+extern int rtnl_lock_interruptible(void);
+extern void rtnl_unlock(void);
+extern void rtnetlink_init(void);
+
+#define ASSERT_RTNL() do { \
+        if (unlikely(down_trylock(&rtnl_sem) == 0)) { \
+                up(&rtnl_sem); \
+                printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
+                       __FILE__,  __LINE__); \
+                dump_stack(); \
+        } \
+} while(0)
+
+#define BUG_TRAP(x) do { \
+        if (unlikely(!(x))) { \
+                printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
+                        #x,  __FILE__ , __LINE__); \
+        } \
+} while(0)
+
+#endif /* __KERNEL__ */
+
+
+#endif  /* __LINUX_RTNETLINK_H */
diff --git a/include/linux/rwsem-spinlock.h b/include/linux/rwsem-spinlock.h
new file mode 100644
index 000000000000..b52a2af25f1f
--- /dev/null
+++ b/include/linux/rwsem-spinlock.h
@@ -0,0 +1,65 @@
+/* rwsem-spinlock.h: fallback C implementation
+ *
+ * Copyright (c) 2001   David Howells (dhowells@redhat.com).
+ * - Derived partially from ideas by Andrea Arcangeli <andrea@suse.de>
+ * - Derived also from comments by Linus
+ */
+
+#ifndef _LINUX_RWSEM_SPINLOCK_H
+#define _LINUX_RWSEM_SPINLOCK_H
+
+#ifndef _LINUX_RWSEM_H
+#error "please don't include linux/rwsem-spinlock.h directly, use linux/rwsem.h instead"
+#endif
+
+#include <linux/spinlock.h>
+#include <linux/list.h>
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+
+struct rwsem_waiter;
+
+/*
+ * the rw-semaphore definition
+ * - if activity is 0 then there are no active readers or writers
+ * - if activity is +ve then that is the number of active readers
+ * - if activity is -1 then there is one active writer
+ * - if wait_list is not empty, then there are processes waiting for the semaphore
+ */
+struct rw_semaphore {
+        __s32                   activity;
+        spinlock_t              wait_lock;
+        struct list_head        wait_list;
+#if RWSEM_DEBUG
+        int                     debug;
+#endif
+};
+
+/*
+ * initialisation
+ */
+#if RWSEM_DEBUG
+#define __RWSEM_DEBUG_INIT      , 0
+#else
+#define __RWSEM_DEBUG_INIT      /* */
+#endif
+
+#define __RWSEM_INITIALIZER(name) \
+{ 0, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) __RWSEM_DEBUG_INIT }
+
+#define DECLARE_RWSEM(name) \
+        struct rw_semaphore name = __RWSEM_INITIALIZER(name)
+
+extern void FASTCALL(init_rwsem(struct rw_semaphore *sem));
+extern void FASTCALL(__down_read(struct rw_semaphore *sem));
+extern int FASTCALL(__down_read_trylock(struct rw_semaphore *sem));
+extern void FASTCALL(__down_write(struct rw_semaphore *sem));
+extern int FASTCALL(__down_write_trylock(struct rw_semaphore *sem));
+extern void FASTCALL(__up_read(struct rw_semaphore *sem));
+extern void FASTCALL(__up_write(struct rw_semaphore *sem));
+extern void FASTCALL(__downgrade_write(struct rw_semaphore *sem));
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_RWSEM_SPINLOCK_H */
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
new file mode 100644
index 000000000000..bfb988885002
--- /dev/null
+++ b/include/linux/rwsem.h
@@ -0,0 +1,115 @@
+/* rwsem.h: R/W semaphores, public interface
+ *
+ * Written by David Howells (dhowells@redhat.com).
+ * Derived from asm-i386/semaphore.h
+ */
+
+#ifndef _LINUX_RWSEM_H
+#define _LINUX_RWSEM_H
+
+#include <linux/linkage.h>
+
+#define RWSEM_DEBUG 0
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <asm/system.h>
+#include <asm/atomic.h>
+
+struct rw_semaphore;
+
+#ifdef CONFIG_RWSEM_GENERIC_SPINLOCK
+#include <linux/rwsem-spinlock.h> /* use a generic implementation */
+#else
+#include <asm/rwsem.h> /* use an arch-specific implementation */
+#endif
+
+#ifndef rwsemtrace
+#if RWSEM_DEBUG
+extern void FASTCALL(rwsemtrace(struct rw_semaphore *sem, const char *str));
+#else
+#define rwsemtrace(SEM,FMT)
+#endif
+#endif
+
+/*
+ * lock for reading
+ */
+static inline void down_read(struct rw_semaphore *sem)
+{
+        might_sleep();
+        rwsemtrace(sem,"Entering down_read");
+        __down_read(sem);
+        rwsemtrace(sem,"Leaving down_read");
+}
+
+/*
+ * trylock for reading -- returns 1 if successful, 0 if contention
+ */
+static inline int down_read_trylock(struct rw_semaphore *sem)
+{
+        int ret;
+        rwsemtrace(sem,"Entering down_read_trylock");
+        ret = __down_read_trylock(sem);
+        rwsemtrace(sem,"Leaving down_read_trylock");
+        return ret;
+}
+
+/*
+ * lock for writing
+ */
+static inline void down_write(struct rw_semaphore *sem)
+{
+        might_sleep();
+        rwsemtrace(sem,"Entering down_write");
+        __down_write(sem);
+        rwsemtrace(sem,"Leaving down_write");
+}
+
+/*
+ * trylock for writing -- returns 1 if successful, 0 if contention
+ */
+static inline int down_write_trylock(struct rw_semaphore *sem)
+{
+        int ret;
+        rwsemtrace(sem,"Entering down_write_trylock");
+        ret = __down_write_trylock(sem);
+        rwsemtrace(sem,"Leaving down_write_trylock");
+        return ret;
+}
+
+/*
+ * release a read lock
+ */
+static inline void up_read(struct rw_semaphore *sem)
+{
+        rwsemtrace(sem,"Entering up_read");
+        __up_read(sem);
+        rwsemtrace(sem,"Leaving up_read");
+}
+
+/*
+ * release a write lock
+ */
+static inline void up_write(struct rw_semaphore *sem)
+{
+        rwsemtrace(sem,"Entering up_write");
+        __up_write(sem);
+        rwsemtrace(sem,"Leaving up_write");
+}
+
+/*
+ * downgrade write lock to read lock
+ */
+static inline void downgrade_write(struct rw_semaphore *sem)
+{
+        rwsemtrace(sem,"Entering downgrade_write");
+        __downgrade_write(sem);
+        rwsemtrace(sem,"Leaving downgrade_write");
+}
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_RWSEM_H */
diff --git a/include/linux/sc26198.h b/include/linux/sc26198.h
new file mode 100644
index 000000000000..7ca35abad387
--- /dev/null
+++ b/include/linux/sc26198.h
@@ -0,0 +1,533 @@
+/*****************************************************************************/
+
+/*
+ *      sc26198.h  -- SC26198 UART hardware info.
+ *
+ *      Copyright (C) 1995-1998  Stallion Technologies
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*****************************************************************************/
+#ifndef _SC26198_H
+#define _SC26198_H
+/*****************************************************************************/
+
+/*
+ *      Define the number of async ports per sc26198 uart device.
+ */
+#define SC26198_PORTS           8
+
+/*
+ *      Baud rate timing clocks. All derived from a master 14.7456 MHz clock.
+ */
+#define SC26198_MASTERCLOCK     14745600L
+#define SC26198_DCLK            (SC26198_MASTERCLOCK)
+#define SC26198_CCLK            (SC26198_MASTERCLOCK / 2)
+#define SC26198_BCLK            (SC26198_MASTERCLOCK / 4)
+
+/*
+ *      Define internal FIFO sizes for the 26198 ports.
+ */
+#define SC26198_TXFIFOSIZE      16
+#define SC26198_RXFIFOSIZE      16
+
+/*****************************************************************************/
+
+/*
+ *      Global register definitions. These registers are global to each 26198
+ *      device, not specific ports on it.
+ */
+#define TSTR            0x0d
+#define GCCR            0x0f
+#define ICR             0x1b
+#define WDTRCR          0x1d
+#define IVR             0x1f
+#define BRGTRUA         0x84
+#define GPOSR           0x87
+#define GPOC            0x8b
+#define UCIR            0x8c
+#define CIR             0x8c
+#define BRGTRUB         0x8d
+#define GRXFIFO         0x8e
+#define GTXFIFO         0x8e
+#define GCCR2           0x8f
+#define BRGTRLA         0x94
+#define GPOR            0x97
+#define GPOD            0x9b
+#define BRGTCR          0x9c
+#define GICR            0x9c
+#define BRGTRLB         0x9d
+#define GIBCR           0x9d
+#define GITR            0x9f
+
+/*
+ *      Per port channel registers. These are the register offsets within
+ *      the port address space, so need to have the port address (0 to 7)
+ *      inserted in bit positions 4:6.
+ */
+#define MR0             0x00
+#define MR1             0x01
+#define IOPCR           0x02
+#define BCRBRK          0x03
+#define BCRCOS          0x04
+#define BCRX            0x06
+#define BCRA            0x07
+#define XONCR           0x08
+#define XOFFCR          0x09
+#define ARCR            0x0a
+#define RXCSR           0x0c
+#define TXCSR           0x0e
+#define MR2             0x80
+#define SR              0x81
+#define SCCR            0x81
+#define ISR             0x82
+#define IMR             0x82
+#define TXFIFO          0x83
+#define RXFIFO          0x83
+#define IPR             0x84
+#define IOPIOR          0x85
+#define XISR            0x86
+
+/*
+ *      For any given port calculate the address to use to access a specified
+ *      register. This is only used for unusual access, mostly this is done
+ *      through the assembler access routines.
+ */
+#define SC26198_PORTREG(port,reg)       ((((port) & 0x07) << 4) | (reg))
+
+/*****************************************************************************/
+
+/*
+ *      Global configuration control register bit definitions.
+ */
+#define GCCR_NOACK              0x00
+#define GCCR_IVRACK             0x02
+#define GCCR_IVRCHANACK         0x04
+#define GCCR_IVRTYPCHANACK      0x06
+#define GCCR_ASYNCCYCLE         0x00
+#define GCCR_SYNCCYCLE          0x40
+
+/*****************************************************************************/
+
+/*
+ *      Mode register 0 bit definitions.
+ */
+#define MR0_ADDRNONE            0x00
+#define MR0_AUTOWAKE            0x01
+#define MR0_AUTODOZE            0x02
+#define MR0_AUTOWAKEDOZE        0x03
+#define MR0_SWFNONE             0x00
+#define MR0_SWFTX               0x04
+#define MR0_SWFRX               0x08
+#define MR0_SWFRXTX             0x0c
+#define MR0_TXMASK              0x30
+#define MR0_TXEMPTY             0x00
+#define MR0_TXHIGH              0x10
+#define MR0_TXHALF              0x20
+#define MR0_TXRDY               0x00
+#define MR0_ADDRNT              0x00
+#define MR0_ADDRT               0x40
+#define MR0_SWFNT               0x00
+#define MR0_SWFT                0x80
+
+/*
+ *      Mode register 1 bit definitions.
+ */
+#define MR1_CS5                 0x00
+#define MR1_CS6                 0x01
+#define MR1_CS7                 0x02
+#define MR1_CS8                 0x03
+#define MR1_PAREVEN             0x00
+#define MR1_PARODD              0x04
+#define MR1_PARENB              0x00
+#define MR1_PARFORCE            0x08
+#define MR1_PARNONE             0x10
+#define MR1_PARSPECIAL          0x18
+#define MR1_ERRCHAR             0x00
+#define MR1_ERRBLOCK            0x20
+#define MR1_ISRUNMASKED         0x00
+#define MR1_ISRMASKED           0x40
+#define MR1_AUTORTS             0x80
+
+/*
+ *      Mode register 2 bit definitions.
+ */
+#define MR2_STOP1               0x00
+#define MR2_STOP15              0x01
+#define MR2_STOP2               0x02
+#define MR2_STOP916             0x03
+#define MR2_RXFIFORDY           0x00
+#define MR2_RXFIFOHALF          0x04
+#define MR2_RXFIFOHIGH          0x08
+#define MR2_RXFIFOFULL          0x0c
+#define MR2_AUTOCTS             0x10
+#define MR2_TXRTS               0x20
+#define MR2_MODENORM            0x00
+#define MR2_MODEAUTOECHO        0x40
+#define MR2_MODELOOP            0x80
+#define MR2_MODEREMECHO         0xc0
+
+/*****************************************************************************/
+
+/*
+ *      Baud Rate Generator (BRG) selector values.
+ */
+#define BRG_50                  0x00
+#define BRG_75                  0x01
+#define BRG_150                 0x02
+#define BRG_200                 0x03
+#define BRG_300                 0x04
+#define BRG_450                 0x05
+#define BRG_600                 0x06
+#define BRG_900                 0x07
+#define BRG_1200                0x08
+#define BRG_1800                0x09
+#define BRG_2400                0x0a
+#define BRG_3600                0x0b
+#define BRG_4800                0x0c
+#define BRG_7200                0x0d
+#define BRG_9600                0x0e
+#define BRG_14400               0x0f
+#define BRG_19200               0x10
+#define BRG_28200               0x11
+#define BRG_38400               0x12
+#define BRG_57600               0x13
+#define BRG_115200              0x14
+#define BRG_230400              0x15
+#define BRG_GIN0                0x16
+#define BRG_GIN1                0x17
+#define BRG_CT0                 0x18
+#define BRG_CT1                 0x19
+#define BRG_RX2TX316            0x1b
+#define BRG_RX2TX31             0x1c
+
+#define SC26198_MAXBAUD         921600
+
+/*****************************************************************************/
+
+/*
+ *      Command register command definitions.
+ */
+#define CR_NULL                 0x04
+#define CR_ADDRNORMAL           0x0c
+#define CR_RXRESET              0x14
+#define CR_TXRESET              0x1c
+#define CR_CLEARRXERR           0x24
+#define CR_BREAKRESET           0x2c
+#define CR_TXSTARTBREAK         0x34
+#define CR_TXSTOPBREAK          0x3c
+#define CR_RTSON                0x44
+#define CR_RTSOFF               0x4c
+#define CR_ADDRINIT             0x5c
+#define CR_RXERRBLOCK           0x6c
+#define CR_TXSENDXON            0x84
+#define CR_TXSENDXOFF           0x8c
+#define CR_GANGXONSET           0x94
+#define CR_GANGXOFFSET          0x9c
+#define CR_GANGXONINIT          0xa4
+#define CR_GANGXOFFINIT         0xac
+#define CR_HOSTXON              0xb4
+#define CR_HOSTXOFF             0xbc
+#define CR_CANCELXOFF           0xc4
+#define CR_ADDRRESET            0xdc
+#define CR_RESETALLPORTS        0xf4
+#define CR_RESETALL             0xfc
+
+#define CR_RXENABLE             0x01
+#define CR_TXENABLE             0x02
+
+/*****************************************************************************/
+
+/*
+ *      Channel status register.
+ */
+#define SR_RXRDY                0x01
+#define SR_RXFULL               0x02
+#define SR_TXRDY                0x04
+#define SR_TXEMPTY              0x08
+#define SR_RXOVERRUN            0x10
+#define SR_RXPARITY             0x20
+#define SR_RXFRAMING            0x40
+#define SR_RXBREAK              0x80
+
+#define SR_RXERRS               (SR_RXPARITY | SR_RXFRAMING | SR_RXOVERRUN)
+
+/*****************************************************************************/
+
+/*
+ *      Interrupt status register and interrupt mask register bit definitions.
+ */
+#define IR_TXRDY                0x01
+#define IR_RXRDY                0x02
+#define IR_RXBREAK              0x04
+#define IR_XONXOFF              0x10
+#define IR_ADDRRECOG            0x20
+#define IR_RXWATCHDOG           0x40
+#define IR_IOPORT               0x80
+
+/*****************************************************************************/
+
+/*
+ *      Interrupt vector register field definitions.
+ */
+#define IVR_CHANMASK            0x07
+#define IVR_TYPEMASK            0x18
+#define IVR_CONSTMASK           0xc0
+
+#define IVR_RXDATA              0x10
+#define IVR_RXBADDATA           0x18
+#define IVR_TXDATA              0x08
+#define IVR_OTHER               0x00
+
+/*****************************************************************************/
+
+/*
+ *      BRG timer control register bit definitions.
+ */
+#define BRGCTCR_DISABCLK0       0x00
+#define BRGCTCR_ENABCLK0        0x08
+#define BRGCTCR_DISABCLK1       0x00
+#define BRGCTCR_ENABCLK1        0x80
+
+#define BRGCTCR_0SCLK16         0x00
+#define BRGCTCR_0SCLK32         0x01
+#define BRGCTCR_0SCLK64         0x02
+#define BRGCTCR_0SCLK128        0x03
+#define BRGCTCR_0X1             0x04
+#define BRGCTCR_0X12            0x05
+#define BRGCTCR_0IO1A           0x06
+#define BRGCTCR_0GIN0           0x07
+
+#define BRGCTCR_1SCLK16         0x00
+#define BRGCTCR_1SCLK32         0x10
+#define BRGCTCR_1SCLK64         0x20
+#define BRGCTCR_1SCLK128        0x30
+#define BRGCTCR_1X1             0x40
+#define BRGCTCR_1X12            0x50
+#define BRGCTCR_1IO1B           0x60
+#define BRGCTCR_1GIN1           0x70
+
+/*****************************************************************************/
+
+/*
+ *      Watch dog timer enable register.
+ */
+#define WDTRCR_ENABALL          0xff
+
+/*****************************************************************************/
+
+/*
+ *      XON/XOFF interrupt status register.
+ */
+#define XISR_TXCHARMASK         0x03
+#define XISR_TXCHARNORMAL       0x00
+#define XISR_TXWAIT             0x01
+#define XISR_TXXOFFPEND         0x02
+#define XISR_TXXONPEND          0x03
+
+#define XISR_TXFLOWMASK         0x0c
+#define XISR_TXNORMAL           0x00
+#define XISR_TXSTOPPEND         0x04
+#define XISR_TXSTARTED          0x08
+#define XISR_TXSTOPPED          0x0c
+
+#define XISR_RXFLOWMASK         0x30
+#define XISR_RXFLOWNONE         0x00
+#define XISR_RXXONSENT          0x10
+#define XISR_RXXOFFSENT         0x20
+
+#define XISR_RXXONGOT           0x40
+#define XISR_RXXOFFGOT          0x80
+
+/*****************************************************************************/
+
+/*
+ *      Current interrupt register.
+ */
+#define CIR_TYPEMASK            0xc0
+#define CIR_TYPEOTHER           0x00
+#define CIR_TYPETX              0x40
+#define CIR_TYPERXGOOD          0x80
+#define CIR_TYPERXBAD           0xc0
+
+#define CIR_RXDATA              0x80
+#define CIR_RXBADDATA           0x40
+#define CIR_TXDATA              0x40
+
+#define CIR_CHANMASK            0x07
+#define CIR_CNTMASK             0x38
+
+#define CIR_SUBTYPEMASK         0x38
+#define CIR_SUBNONE             0x00
+#define CIR_SUBCOS              0x08
+#define CIR_SUBADDR             0x10
+#define CIR_SUBXONXOFF          0x18
+#define CIR_SUBBREAK            0x28
+
+/*****************************************************************************/
+
+/*
+ *      Global interrupting channel register.
+ */
+#define GICR_CHANMASK           0x07
+
+/*****************************************************************************/
+
+/*
+ *      Global interrupting byte count register.
+ */
+#define GICR_COUNTMASK          0x0f
+
+/*****************************************************************************/
+
+/*
+ *      Global interrupting type register.
+ */
+#define GITR_RXMASK             0xc0
+#define GITR_RXNONE             0x00
+#define GITR_RXBADDATA          0x80
+#define GITR_RXGOODDATA         0xc0
+#define GITR_TXDATA             0x20
+
+#define GITR_SUBTYPEMASK        0x07
+#define GITR_SUBNONE            0x00
+#define GITR_SUBCOS             0x01
+#define GITR_SUBADDR            0x02
+#define GITR_SUBXONXOFF         0x03
+#define GITR_SUBBREAK           0x05
+
+/*****************************************************************************/
+
+/*
+ *      Input port change register.
+ */
+#define IPR_CTS                 0x01
+#define IPR_DTR                 0x02
+#define IPR_RTS                 0x04
+#define IPR_DCD                 0x08
+#define IPR_CTSCHANGE           0x10
+#define IPR_DTRCHANGE           0x20
+#define IPR_RTSCHANGE           0x40
+#define IPR_DCDCHANGE           0x80
+
+#define IPR_CHANGEMASK          0xf0
+
+/*****************************************************************************/
+
+/*
+ *      IO port interrupt and output register.
+ */
+#define IOPR_CTS                0x01
+#define IOPR_DTR                0x02
+#define IOPR_RTS                0x04
+#define IOPR_DCD                0x08
+#define IOPR_CTSCOS             0x10
+#define IOPR_DTRCOS             0x20
+#define IOPR_RTSCOS             0x40
+#define IOPR_DCDCOS             0x80
+
+/*****************************************************************************/
+
+/*
+ *      IO port configuration register.
+ */
+#define IOPCR_SETCTS            0x00
+#define IOPCR_SETDTR            0x04
+#define IOPCR_SETRTS            0x10
+#define IOPCR_SETDCD            0x00
+
+#define IOPCR_SETSIGS           (IOPCR_SETRTS | IOPCR_SETRTS | IOPCR_SETDTR | IOPCR_SETDCD)
+
+/*****************************************************************************/
+
+/*
+ *      General purpose output select register.
+ */
+#define GPORS_TXC1XA            0x08
+#define GPORS_TXC16XA           0x09
+#define GPORS_RXC16XA           0x0a
+#define GPORS_TXC16XB           0x0b
+#define GPORS_GPOR3             0x0c
+#define GPORS_GPOR2             0x0d
+#define GPORS_GPOR1             0x0e
+#define GPORS_GPOR0             0x0f
+
+/*****************************************************************************/
+
+/*
+ *      General purpose output register.
+ */
+#define GPOR_0                  0x01
+#define GPOR_1                  0x02
+#define GPOR_2                  0x04
+#define GPOR_3                  0x08
+
+/*****************************************************************************/
+
+/*
+ *      General purpose output clock register.
+ */
+#define GPORC_0NONE             0x00
+#define GPORC_0GIN0             0x01
+#define GPORC_0GIN1             0x02
+#define GPORC_0IO3A             0x02
+
+#define GPORC_1NONE             0x00
+#define GPORC_1GIN0             0x04
+#define GPORC_1GIN1             0x08
+#define GPORC_1IO3C             0x0c
+
+#define GPORC_2NONE             0x00
+#define GPORC_2GIN0             0x10
+#define GPORC_2GIN1             0x20
+#define GPORC_2IO3E             0x20
+
+#define GPORC_3NONE             0x00
+#define GPORC_3GIN0             0x40
+#define GPORC_3GIN1             0x80
+#define GPORC_3IO3G             0xc0
+
+/*****************************************************************************/
+
+/*
+ *      General purpose output data register.
+ */
+#define GPOD_0MASK              0x03
+#define GPOD_0SET1              0x00
+#define GPOD_0SET0              0x01
+#define GPOD_0SETR0             0x02
+#define GPOD_0SETIO3B           0x03
+
+#define GPOD_1MASK              0x0c
+#define GPOD_1SET1              0x00
+#define GPOD_1SET0              0x04
+#define GPOD_1SETR0             0x08
+#define GPOD_1SETIO3D           0x0c
+
+#define GPOD_2MASK              0x30
+#define GPOD_2SET1              0x00
+#define GPOD_2SET0              0x10
+#define GPOD_2SETR0             0x20
+#define GPOD_2SETIO3F           0x30
+
+#define GPOD_3MASK              0xc0
+#define GPOD_3SET1              0x00
+#define GPOD_3SET0              0x40
+#define GPOD_3SETR0             0x80
+#define GPOD_3SETIO3H           0xc0
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
new file mode 100644
index 000000000000..7f717e95ae37
--- /dev/null
+++ b/include/linux/scatterlist.h
@@ -0,0 +1,14 @@
+#ifndef _LINUX_SCATTERLIST_H
+#define _LINUX_SCATTERLIST_H
+
+static inline void sg_init_one(struct scatterlist *sg,
+                               u8 *buf, unsigned int buflen)
+{
+        memset(sg, 0, sizeof(*sg));
+
+        sg->page = virt_to_page(buf);
+        sg->offset = offset_in_page(buf);
+        sg->length = buflen;
+}
+
+#endif /* _LINUX_SCATTERLIST_H */
diff --git a/include/linux/scc.h b/include/linux/scc.h
new file mode 100644
index 000000000000..885a4a02b23c
--- /dev/null
+++ b/include/linux/scc.h
@@ -0,0 +1,253 @@
+/* $Id: scc.h,v 1.29 1997/04/02 14:56:45 jreuter Exp jreuter $ */
+
+#ifndef _SCC_H
+#define _SCC_H
+
+#include <linux/config.h>
+
+/* selection of hardware types */
+
+#define PA0HZP          0x00    /* hardware type for PA0HZP SCC card and compatible */
+#define EAGLE           0x01    /* hardware type for EAGLE card */
+#define PC100           0x02    /* hardware type for PC100 card */
+#define PRIMUS          0x04    /* hardware type for PRIMUS-PC (DG9BL) card */
+#define DRSI            0x08    /* hardware type for DRSI PC*Packet card */
+#define BAYCOM          0x10    /* hardware type for BayCom (U)SCC */
+
+/* DEV ioctl() commands */
+
+enum SCC_ioctl_cmds {
+        SIOCSCCRESERVED = SIOCDEVPRIVATE,
+        SIOCSCCCFG,
+        SIOCSCCINI,
+        SIOCSCCCHANINI,
+        SIOCSCCSMEM,
+        SIOCSCCGKISS,
+        SIOCSCCSKISS,
+        SIOCSCCGSTAT,
+        SIOCSCCCAL
+};
+
+/* Device parameter control (from WAMPES) */
+
+enum L1_params {
+        PARAM_DATA,
+        PARAM_TXDELAY,
+        PARAM_PERSIST,
+        PARAM_SLOTTIME,
+        PARAM_TXTAIL,
+        PARAM_FULLDUP,
+        PARAM_SOFTDCD,          /* was: PARAM_HW */
+        PARAM_MUTE,             /* ??? */
+        PARAM_DTR,
+        PARAM_RTS,
+        PARAM_SPEED,
+        PARAM_ENDDELAY,         /* ??? */
+        PARAM_GROUP,
+        PARAM_IDLE,
+        PARAM_MIN,
+        PARAM_MAXKEY,
+        PARAM_WAIT,
+        PARAM_MAXDEFER,
+        PARAM_TX,
+        PARAM_HWEVENT = 31,
+        PARAM_RETURN = 255      /* reset kiss mode */
+};
+
+/* fulldup parameter */
+
+enum FULLDUP_modes {
+        KISS_DUPLEX_HALF,       /* normal CSMA operation */
+        KISS_DUPLEX_FULL,       /* fullduplex, key down trx after transmission */
+        KISS_DUPLEX_LINK,       /* fullduplex, key down trx after 'idletime' sec */
+        KISS_DUPLEX_OPTIMA      /* fullduplex, let the protocol layer control the hw */
+};
+
+/* misc. parameters */
+
+#define TIMER_OFF       65535U  /* to switch off timers */
+#define NO_SUCH_PARAM   65534U  /* param not implemented */
+
+/* HWEVENT parameter */
+
+enum HWEVENT_opts {
+        HWEV_DCD_ON,
+        HWEV_DCD_OFF,
+        HWEV_ALL_SENT
+};
+
+/* channel grouping */
+
+#define RXGROUP         0100    /* if set, only tx when all channels clear */
+#define TXGROUP         0200    /* if set, don't transmit simultaneously */
+
+/* Tx/Rx clock sources */
+
+enum CLOCK_sources {
+        CLK_DPLL,       /* normal halfduplex operation */
+        CLK_EXTERNAL,   /* external clocking (G3RUH/DF9IC modems) */
+        CLK_DIVIDER,    /* Rx = DPLL, Tx = divider (fullduplex with */
+                        /* modems without clock regeneration */
+        CLK_BRG         /* experimental fullduplex mode with DPLL/BRG for */
+                        /* MODEMs without clock recovery */
+};
+
+/* Tx state */
+
+enum TX_state {
+        TXS_IDLE,       /* Transmitter off, no data pending */
+        TXS_BUSY,       /* waiting for permission to send / tailtime */
+        TXS_ACTIVE,     /* Transmitter on, sending data */
+        TXS_NEWFRAME,   /* reset CRC and send (next) frame */
+        TXS_IDLE2,      /* Transmitter on, no data pending */
+        TXS_WAIT,       /* Waiting for Mintime to expire */
+        TXS_TIMEOUT     /* We had a transmission timeout */
+};
+
+typedef unsigned long io_port;  /* type definition for an 'io port address' */
+
+/* SCC statistical information */
+
+struct scc_stat {
+        long rxints;            /* Receiver interrupts */
+        long txints;            /* Transmitter interrupts */
+        long exints;            /* External/status interrupts */
+        long spints;            /* Special receiver interrupts */
+
+        long txframes;          /* Packets sent */
+        long rxframes;          /* Number of Frames Actually Received */
+        long rxerrs;            /* CRC Errors */
+        long txerrs;            /* KISS errors */
+        
+        unsigned int nospace;   /* "Out of buffers" */
+        unsigned int rx_over;   /* Receiver Overruns */
+        unsigned int tx_under;  /* Transmitter Underruns */
+
+        unsigned int tx_state;  /* Transmitter state */
+        int tx_queued;          /* tx frames enqueued */
+
+        unsigned int maxqueue;  /* allocated tx_buffers */
+        unsigned int bufsize;   /* used buffersize */
+};
+
+struct scc_modem {
+        long speed;             /* Line speed, bps */
+        char clocksrc;          /* 0 = DPLL, 1 = external, 2 = divider */
+        char nrz;               /* NRZ instead of NRZI */       
+};
+
+struct scc_kiss_cmd {
+        int      command;       /* one of the KISS-Commands defined above */
+        unsigned param;         /* KISS-Param */
+};
+
+struct scc_hw_config {
+        io_port data_a;         /* data port channel A */
+        io_port ctrl_a;         /* control port channel A */
+        io_port data_b;         /* data port channel B */
+        io_port ctrl_b;         /* control port channel B */
+        io_port vector_latch;   /* INTACK-Latch (#) */
+        io_port special;        /* special function port */
+
+        int     irq;            /* irq */
+        long    clock;          /* clock */
+        char    option;         /* command for function port */
+
+        char brand;             /* hardware type */
+        char escc;              /* use ext. features of a 8580/85180/85280 */
+};
+
+/* (#) only one INTACK latch allowed. */
+
+
+struct scc_mem_config {
+        unsigned int dummy;
+        unsigned int bufsize;
+};
+
+struct scc_calibrate {
+        unsigned int time;
+        unsigned char pattern;
+};
+
+#ifdef __KERNEL__
+
+enum {TX_OFF, TX_ON};   /* command for scc_key_trx() */
+
+/* Vector masks in RR2B */
+
+#define VECTOR_MASK     0x06
+#define TXINT           0x00
+#define EXINT           0x02
+#define RXINT           0x04
+#define SPINT           0x06
+
+#ifdef CONFIG_SCC_DELAY
+#define Inb(port)       inb_p(port)
+#define Outb(port, val) outb_p(val, port)
+#else
+#define Inb(port)       inb(port)
+#define Outb(port, val) outb(val, port)
+#endif
+
+/* SCC channel control structure for KISS */
+
+struct scc_kiss {
+        unsigned char txdelay;          /* Transmit Delay 10 ms/cnt */
+        unsigned char persist;          /* Persistence (0-255) as a % */
+        unsigned char slottime;         /* Delay to wait on persistence hit */
+        unsigned char tailtime;         /* Delay after last byte written */
+        unsigned char fulldup;          /* Full Duplex mode 0=CSMA 1=DUP 2=ALWAYS KEYED */
+        unsigned char waittime;         /* Waittime before any transmit attempt */
+        unsigned int  maxkeyup;         /* Maximum time to transmit (seconds) */
+        unsigned int  mintime;          /* Minimal offtime after MAXKEYUP timeout (seconds) */
+        unsigned int  idletime;         /* Maximum idle time in ALWAYS KEYED mode (seconds) */
+        unsigned int  maxdefer;         /* Timer for CSMA channel busy limit */
+        unsigned char tx_inhibit;       /* Transmit is not allowed when set */  
+        unsigned char group;            /* Group ID for AX.25 TX interlocking */
+        unsigned char mode;             /* 'normal' or 'hwctrl' mode (unused) */
+        unsigned char softdcd;          /* Use DPLL instead of DCD pin for carrier detect */
+};
+
+
+/* SCC channel structure */
+
+struct scc_channel {
+        int init;                       /* channel exists? */
+
+        struct net_device *dev;         /* link to device control structure */
+        struct net_device_stats dev_stat;/* device statistics */
+
+        char brand;                     /* manufacturer of the board */
+        long clock;                     /* used clock */
+
+        io_port ctrl;                   /* I/O address of CONTROL register */
+        io_port data;                   /* I/O address of DATA register */
+        io_port special;                /* I/O address of special function port */
+        int irq;                        /* Number of Interrupt */
+
+        char option;
+        char enhanced;                  /* Enhanced SCC support */
+
+        unsigned char wreg[16];         /* Copy of last written value in WRx */
+        unsigned char status;           /* Copy of R0 at last external interrupt */
+        unsigned char dcd;              /* DCD status */
+
+        struct scc_kiss kiss;           /* control structure for KISS params */
+        struct scc_stat stat;           /* statistical information */
+        struct scc_modem modem;         /* modem information */
+
+        struct sk_buff_head tx_queue;   /* next tx buffer */
+        struct sk_buff *rx_buff;        /* pointer to frame currently received */
+        struct sk_buff *tx_buff;        /* pointer to frame currently transmitted */
+
+        /* Timer */
+        struct timer_list tx_t;         /* tx timer for this channel */
+        struct timer_list tx_wdog;      /* tx watchdogs */
+        
+        /* Channel lock */
+        spinlock_t      lock;           /* Channel guard lock */
+};
+
+#endif /* defined(__KERNEL__) */
+#endif /* defined(_SCC_H) */
diff --git a/include/linux/sched.h b/include/linux/sched.h
new file mode 100644
index 000000000000..a30e91f40da6
--- /dev/null
+++ b/include/linux/sched.h
@@ -0,0 +1,1273 @@
+#ifndef _LINUX_SCHED_H
+#define _LINUX_SCHED_H
+
+#include <asm/param.h>  /* for HZ */
+
+#include <linux/config.h>
+#include <linux/capability.h>
+#include <linux/threads.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/timex.h>
+#include <linux/jiffies.h>
+#include <linux/rbtree.h>
+#include <linux/thread_info.h>
+#include <linux/cpumask.h>
+#include <linux/errno.h>
+#include <linux/nodemask.h>
+
+#include <asm/system.h>
+#include <asm/semaphore.h>
+#include <asm/page.h>
+#include <asm/ptrace.h>
+#include <asm/mmu.h>
+#include <asm/cputime.h>
+
+#include <linux/smp.h>
+#include <linux/sem.h>
+#include <linux/signal.h>
+#include <linux/securebits.h>
+#include <linux/fs_struct.h>
+#include <linux/compiler.h>
+#include <linux/completion.h>
+#include <linux/pid.h>
+#include <linux/percpu.h>
+#include <linux/topology.h>
+#include <linux/seccomp.h>
+
+struct exec_domain;
+
+/*
+ * cloning flags:
+ */
+#define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
+#define CLONE_VM        0x00000100      /* set if VM shared between processes */
+#define CLONE_FS        0x00000200      /* set if fs info shared between processes */
+#define CLONE_FILES     0x00000400      /* set if open files shared between processes */
+#define CLONE_SIGHAND   0x00000800      /* set if signal handlers and blocked signals shared */
+#define CLONE_PTRACE    0x00002000      /* set if we want to let tracing continue on the child too */
+#define CLONE_VFORK     0x00004000      /* set if the parent wants the child to wake it up on mm_release */
+#define CLONE_PARENT    0x00008000      /* set if we want to have the same parent as the cloner */
+#define CLONE_THREAD    0x00010000      /* Same thread group? */
+#define CLONE_NEWNS     0x00020000      /* New namespace group? */
+#define CLONE_SYSVSEM   0x00040000      /* share system V SEM_UNDO semantics */
+#define CLONE_SETTLS    0x00080000      /* create a new TLS for the child */
+#define CLONE_PARENT_SETTID     0x00100000      /* set the TID in the parent */
+#define CLONE_CHILD_CLEARTID    0x00200000      /* clear the TID in the child */
+#define CLONE_DETACHED          0x00400000      /* Unused, ignored */
+#define CLONE_UNTRACED          0x00800000      /* set if the tracing process can't force CLONE_PTRACE on this clone */
+#define CLONE_CHILD_SETTID      0x01000000      /* set the TID in the child */
+#define CLONE_STOPPED           0x02000000      /* Start in stopped state */
+
+/*
+ * List of flags we want to share for kernel threads,
+ * if only because they are not used by them anyway.
+ */
+#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
+
+/*
+ * These are the constant used to fake the fixed-point load-average
+ * counting. Some notes:
+ *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
+ *    a load-average precision of 10 bits integer + 11 bits fractional
+ *  - if you want to count load-averages more often, you need more
+ *    precision, or rounding will get you. With 2-second counting freq,
+ *    the EXP_n values would be 1981, 2034 and 2043 if still using only
+ *    11 bit fractions.
+ */
+extern unsigned long avenrun[];         /* Load averages */
+
+#define FSHIFT          11              /* nr of bits of precision */
+#define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
+#define LOAD_FREQ       (5*HZ)          /* 5 sec intervals */
+#define EXP_1           1884            /* 1/exp(5sec/1min) as fixed-point */
+#define EXP_5           2014            /* 1/exp(5sec/5min) */
+#define EXP_15          2037            /* 1/exp(5sec/15min) */
+
+#define CALC_LOAD(load,exp,n) \
+        load *= exp; \
+        load += n*(FIXED_1-exp); \
+        load >>= FSHIFT;
+
+extern unsigned long total_forks;
+extern int nr_threads;
+extern int last_pid;
+DECLARE_PER_CPU(unsigned long, process_counts);
+extern int nr_processes(void);
+extern unsigned long nr_running(void);
+extern unsigned long nr_uninterruptible(void);
+extern unsigned long nr_iowait(void);
+
+#include <linux/time.h>
+#include <linux/param.h>
+#include <linux/resource.h>
+#include <linux/timer.h>
+
+#include <asm/processor.h>
+
+#define TASK_RUNNING            0
+#define TASK_INTERRUPTIBLE      1
+#define TASK_UNINTERRUPTIBLE    2
+#define TASK_STOPPED            4
+#define TASK_TRACED             8
+#define EXIT_ZOMBIE             16
+#define EXIT_DEAD               32
+
+#define __set_task_state(tsk, state_value)              \
+        do { (tsk)->state = (state_value); } while (0)
+#define set_task_state(tsk, state_value)                \
+        set_mb((tsk)->state, (state_value))
+
+#define __set_current_state(state_value)                        \
+        do { current->state = (state_value); } while (0)
+#define set_current_state(state_value)          \
+        set_mb(current->state, (state_value))
+
+/* Task command name length */
+#define TASK_COMM_LEN 16
+
+/*
+ * Scheduling policies
+ */
+#define SCHED_NORMAL            0
+#define SCHED_FIFO              1
+#define SCHED_RR                2
+
+struct sched_param {
+        int sched_priority;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/spinlock.h>
+
+/*
+ * This serializes "schedule()" and also protects
+ * the run-queue from deletions/modifications (but
+ * _adding_ to the beginning of the run-queue has
+ * a separate lock).
+ */
+extern rwlock_t tasklist_lock;
+extern spinlock_t mmlist_lock;
+
+typedef struct task_struct task_t;
+
+extern void sched_init(void);
+extern void sched_init_smp(void);
+extern void init_idle(task_t *idle, int cpu);
+
+extern cpumask_t nohz_cpu_mask;
+
+extern void show_state(void);
+extern void show_regs(struct pt_regs *);
+
+/*
+ * TASK is a pointer to the task whose backtrace we want to see (or NULL for current
+ * task), SP is the stack pointer of the first frame that should be shown in the back
+ * trace (or NULL if the entire call-chain of the task should be shown).
+ */
+extern void show_stack(struct task_struct *task, unsigned long *sp);
+
+void io_schedule(void);
+long io_schedule_timeout(long timeout);
+
+extern void cpu_init (void);
+extern void trap_init(void);
+extern void update_process_times(int user);
+extern void scheduler_tick(void);
+
+/* Attach to any functions which should be ignored in wchan output. */
+#define __sched         __attribute__((__section__(".sched.text")))
+/* Is this address in the __sched functions? */
+extern int in_sched_functions(unsigned long addr);
+
+#define MAX_SCHEDULE_TIMEOUT    LONG_MAX
+extern signed long FASTCALL(schedule_timeout(signed long timeout));
+asmlinkage void schedule(void);
+
+struct namespace;
+
+/* Maximum number of active map areas.. This is a random (large) number */
+#define DEFAULT_MAX_MAP_COUNT   65536
+
+extern int sysctl_max_map_count;
+
+#include <linux/aio.h>
+
+extern unsigned long
+arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
+                       unsigned long, unsigned long);
+extern unsigned long
+arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
+                          unsigned long len, unsigned long pgoff,
+                          unsigned long flags);
+extern void arch_unmap_area(struct vm_area_struct *area);
+extern void arch_unmap_area_topdown(struct vm_area_struct *area);
+
+#define set_mm_counter(mm, member, value) (mm)->_##member = (value)
+#define get_mm_counter(mm, member) ((mm)->_##member)
+#define add_mm_counter(mm, member, value) (mm)->_##member += (value)
+#define inc_mm_counter(mm, member) (mm)->_##member++
+#define dec_mm_counter(mm, member) (mm)->_##member--
+typedef unsigned long mm_counter_t;
+
+struct mm_struct {
+        struct vm_area_struct * mmap;           /* list of VMAs */
+        struct rb_root mm_rb;
+        struct vm_area_struct * mmap_cache;     /* last find_vma result */
+        unsigned long (*get_unmapped_area) (struct file *filp,
+                                unsigned long addr, unsigned long len,
+                                unsigned long pgoff, unsigned long flags);
+        void (*unmap_area) (struct vm_area_struct *area);
+        unsigned long mmap_base;                /* base of mmap area */
+        unsigned long free_area_cache;          /* first hole */
+        pgd_t * pgd;
+        atomic_t mm_users;                      /* How many users with user space? */
+        atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
+        int map_count;                          /* number of VMAs */
+        struct rw_semaphore mmap_sem;
+        spinlock_t page_table_lock;             /* Protects page tables and some counters */
+
+        struct list_head mmlist;                /* List of maybe swapped mm's.  These are globally strung
+                                                 * together off init_mm.mmlist, and are protected
+                                                 * by mmlist_lock
+                                                 */
+
+        unsigned long start_code, end_code, start_data, end_data;
+        unsigned long start_brk, brk, start_stack;
+        unsigned long arg_start, arg_end, env_start, env_end;
+        unsigned long total_vm, locked_vm, shared_vm;
+        unsigned long exec_vm, stack_vm, reserved_vm, def_flags, nr_ptes;
+
+        /* Special counters protected by the page_table_lock */
+        mm_counter_t _rss;
+        mm_counter_t _anon_rss;
+
+        unsigned long saved_auxv[42]; /* for /proc/PID/auxv */
+
+        unsigned dumpable:1;
+        cpumask_t cpu_vm_mask;
+
+        /* Architecture-specific MM context */
+        mm_context_t context;
+
+        /* Token based thrashing protection. */
+        unsigned long swap_token_time;
+        char recent_pagein;
+
+        /* coredumping support */
+        int core_waiters;
+        struct completion *core_startup_done, core_done;
+
+        /* aio bits */
+        rwlock_t                ioctx_list_lock;
+        struct kioctx           *ioctx_list;
+
+        struct kioctx           default_kioctx;
+
+        unsigned long hiwater_rss;      /* High-water RSS usage */
+        unsigned long hiwater_vm;       /* High-water virtual memory usage */
+};
+
+struct sighand_struct {
+        atomic_t                count;
+        struct k_sigaction      action[_NSIG];
+        spinlock_t              siglock;
+};
+
+/*
+ * NOTE! "signal_struct" does not have it's own
+ * locking, because a shared signal_struct always
+ * implies a shared sighand_struct, so locking
+ * sighand_struct is always a proper superset of
+ * the locking of signal_struct.
+ */
+struct signal_struct {
+        atomic_t                count;
+        atomic_t                live;
+
+        wait_queue_head_t       wait_chldexit;  /* for wait4() */
+
+        /* current thread group signal load-balancing target: */
+        task_t                  *curr_target;
+
+        /* shared signal handling: */
+        struct sigpending       shared_pending;
+
+        /* thread group exit support */
+        int                     group_exit_code;
+        /* overloaded:
+         * - notify group_exit_task when ->count is equal to notify_count
+         * - everyone except group_exit_task is stopped during signal delivery
+         *   of fatal signals, group_exit_task processes the signal.
+         */
+        struct task_struct      *group_exit_task;
+        int                     notify_count;
+
+        /* thread group stop support, overloads group_exit_code too */
+        int                     group_stop_count;
+        unsigned int            flags; /* see SIGNAL_* flags below */
+
+        /* POSIX.1b Interval Timers */
+        struct list_head posix_timers;
+
+        /* ITIMER_REAL timer for the process */
+        struct timer_list real_timer;
+        unsigned long it_real_value, it_real_incr;
+
+        /* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
+        cputime_t it_prof_expires, it_virt_expires;
+        cputime_t it_prof_incr, it_virt_incr;
+
+        /* job control IDs */
+        pid_t pgrp;
+        pid_t tty_old_pgrp;
+        pid_t session;
+        /* boolean value for session group leader */
+        int leader;
+
+        struct tty_struct *tty; /* NULL if no tty */
+
+        /*
+         * Cumulative resource counters for dead threads in the group,
+         * and for reaped dead child processes forked by this group.
+         * Live threads maintain their own counters and add to these
+         * in __exit_signal, except for the group leader.
+         */
+        cputime_t utime, stime, cutime, cstime;
+        unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
+        unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
+
+        /*
+         * Cumulative ns of scheduled CPU time for dead threads in the
+         * group, not including a zombie group leader.  (This only differs
+         * from jiffies_to_ns(utime + stime) if sched_clock uses something
+         * other than jiffies.)
+         */
+        unsigned long long sched_time;
+
+        /*
+         * We don't bother to synchronize most readers of this at all,
+         * because there is no reader checking a limit that actually needs
+         * to get both rlim_cur and rlim_max atomically, and either one
+         * alone is a single word that can safely be read normally.
+         * getrlimit/setrlimit use task_lock(current->group_leader) to
+         * protect this instead of the siglock, because they really
+         * have no need to disable irqs.
+         */
+        struct rlimit rlim[RLIM_NLIMITS];
+
+        struct list_head cpu_timers[3];
+
+        /* keep the process-shared keyrings here so that they do the right
+         * thing in threads created with CLONE_THREAD */
+#ifdef CONFIG_KEYS
+        struct key *session_keyring;    /* keyring inherited over fork */
+        struct key *process_keyring;    /* keyring private to this process */
+#endif
+};
+
+/*
+ * Bits in flags field of signal_struct.
+ */
+#define SIGNAL_STOP_STOPPED     0x00000001 /* job control stop in effect */
+#define SIGNAL_STOP_DEQUEUED    0x00000002 /* stop signal dequeued */
+#define SIGNAL_STOP_CONTINUED   0x00000004 /* SIGCONT since WCONTINUED reap */
+#define SIGNAL_GROUP_EXIT       0x00000008 /* group exit in progress */
+
+
+/*
+ * Priority of a process goes from 0..MAX_PRIO-1, valid RT
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL tasks are
+ * in the range MAX_RT_PRIO..MAX_PRIO-1. Priority values
+ * are inverted: lower p->prio value means higher priority.
+ *
+ * The MAX_USER_RT_PRIO value allows the actual maximum
+ * RT priority to be separate from the value exported to
+ * user-space.  This allows kernel threads to set their
+ * priority to a value higher than any user task. Note:
+ * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
+ */
+
+#define MAX_USER_RT_PRIO        100
+#define MAX_RT_PRIO             MAX_USER_RT_PRIO
+
+#define MAX_PRIO                (MAX_RT_PRIO + 40)
+
+#define rt_task(p)              (unlikely((p)->prio < MAX_RT_PRIO))
+
+/*
+ * Some day this will be a full-fledged user tracking system..
+ */
+struct user_struct {
+        atomic_t __count;       /* reference count */
+        atomic_t processes;     /* How many processes does this user have? */
+        atomic_t files;         /* How many open files does this user have? */
+        atomic_t sigpending;    /* How many pending signals does this user have? */
+        /* protected by mq_lock */
+        unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
+        unsigned long locked_shm; /* How many pages of mlocked shm ? */
+
+#ifdef CONFIG_KEYS
+        struct key *uid_keyring;        /* UID specific keyring */
+        struct key *session_keyring;    /* UID's default session keyring */
+#endif
+
+        /* Hash table maintenance information */
+        struct list_head uidhash_list;
+        uid_t uid;
+};
+
+extern struct user_struct *find_user(uid_t);
+
+extern struct user_struct root_user;
+#define INIT_USER (&root_user)
+
+typedef struct prio_array prio_array_t;
+struct backing_dev_info;
+struct reclaim_state;
+
+#ifdef CONFIG_SCHEDSTATS
+struct sched_info {
+        /* cumulative counters */
+        unsigned long   cpu_time,       /* time spent on the cpu */
+                        run_delay,      /* time spent waiting on a runqueue */
+                        pcnt;           /* # of timeslices run on this cpu */
+
+        /* timestamps */
+        unsigned long   last_arrival,   /* when we last ran on a cpu */
+                        last_queued;    /* when we were last queued to run */
+};
+
+extern struct file_operations proc_schedstat_operations;
+#endif
+
+enum idle_type
+{
+        SCHED_IDLE,
+        NOT_IDLE,
+        NEWLY_IDLE,
+        MAX_IDLE_TYPES
+};
+
+/*
+ * sched-domains (multiprocessor balancing) declarations:
+ */
+#ifdef CONFIG_SMP
+#define SCHED_LOAD_SCALE        128UL   /* increase resolution of load */
+
+#define SD_LOAD_BALANCE         1       /* Do load balancing on this domain. */
+#define SD_BALANCE_NEWIDLE      2       /* Balance when about to become idle */
+#define SD_BALANCE_EXEC         4       /* Balance on exec */
+#define SD_WAKE_IDLE            8       /* Wake to idle CPU on task wakeup */
+#define SD_WAKE_AFFINE          16      /* Wake task to waking CPU */
+#define SD_WAKE_BALANCE         32      /* Perform balancing at task wakeup */
+#define SD_SHARE_CPUPOWER       64      /* Domain members share cpu power */
+
+struct sched_group {
+        struct sched_group *next;       /* Must be a circular list */
+        cpumask_t cpumask;
+
+        /*
+         * CPU power of this group, SCHED_LOAD_SCALE being max power for a
+         * single CPU. This is read only (except for setup, hotplug CPU).
+         */
+        unsigned long cpu_power;
+};
+
+struct sched_domain {
+        /* These fields must be setup */
+        struct sched_domain *parent;    /* top domain must be null terminated */
+        struct sched_group *groups;     /* the balancing groups of the domain */
+        cpumask_t span;                 /* span of all CPUs in this domain */
+        unsigned long min_interval;     /* Minimum balance interval ms */
+        unsigned long max_interval;     /* Maximum balance interval ms */
+        unsigned int busy_factor;       /* less balancing by factor if busy */
+        unsigned int imbalance_pct;     /* No balance until over watermark */
+        unsigned long long cache_hot_time; /* Task considered cache hot (ns) */
+        unsigned int cache_nice_tries;  /* Leave cache hot tasks for # tries */
+        unsigned int per_cpu_gain;      /* CPU % gained by adding domain cpus */
+        int flags;                      /* See SD_* */
+
+        /* Runtime fields. */
+        unsigned long last_balance;     /* init to jiffies. units in jiffies */
+        unsigned int balance_interval;  /* initialise to 1. units in ms. */
+        unsigned int nr_balance_failed; /* initialise to 0 */
+
+#ifdef CONFIG_SCHEDSTATS
+        /* load_balance() stats */
+        unsigned long lb_cnt[MAX_IDLE_TYPES];
+        unsigned long lb_failed[MAX_IDLE_TYPES];
+        unsigned long lb_balanced[MAX_IDLE_TYPES];
+        unsigned long lb_imbalance[MAX_IDLE_TYPES];
+        unsigned long lb_gained[MAX_IDLE_TYPES];
+        unsigned long lb_hot_gained[MAX_IDLE_TYPES];
+        unsigned long lb_nobusyg[MAX_IDLE_TYPES];
+        unsigned long lb_nobusyq[MAX_IDLE_TYPES];
+
+        /* Active load balancing */
+        unsigned long alb_cnt;
+        unsigned long alb_failed;
+        unsigned long alb_pushed;
+
+        /* sched_balance_exec() stats */
+        unsigned long sbe_attempts;
+        unsigned long sbe_pushed;
+
+        /* try_to_wake_up() stats */
+        unsigned long ttwu_wake_remote;
+        unsigned long ttwu_move_affine;
+        unsigned long ttwu_move_balance;
+#endif
+};
+
+#ifdef ARCH_HAS_SCHED_DOMAIN
+/* Useful helpers that arch setup code may use. Defined in kernel/sched.c */
+extern cpumask_t cpu_isolated_map;
+extern void init_sched_build_groups(struct sched_group groups[],
+                                cpumask_t span, int (*group_fn)(int cpu));
+extern void cpu_attach_domain(struct sched_domain *sd, int cpu);
+#endif /* ARCH_HAS_SCHED_DOMAIN */
+#endif /* CONFIG_SMP */
+
+
+struct io_context;                      /* See blkdev.h */
+void exit_io_context(void);
+struct cpuset;
+
+#define NGROUPS_SMALL           32
+#define NGROUPS_PER_BLOCK       ((int)(PAGE_SIZE / sizeof(gid_t)))
+struct group_info {
+        int ngroups;
+        atomic_t usage;
+        gid_t small_block[NGROUPS_SMALL];
+        int nblocks;
+        gid_t *blocks[0];
+};
+
+/*
+ * get_group_info() must be called with the owning task locked (via task_lock())
+ * when task != current.  The reason being that the vast majority of callers are
+ * looking at current->group_info, which can not be changed except by the
+ * current task.  Changing current->group_info requires the task lock, too.
+ */
+#define get_group_info(group_info) do { \
+        atomic_inc(&(group_info)->usage); \
+} while (0)
+
+#define put_group_info(group_info) do { \
+        if (atomic_dec_and_test(&(group_info)->usage)) \
+                groups_free(group_info); \
+} while (0)
+
+struct group_info *groups_alloc(int gidsetsize);
+void groups_free(struct group_info *group_info);
+int set_current_groups(struct group_info *group_info);
+/* access the groups "array" with this macro */
+#define GROUP_AT(gi, i) \
+    ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
+
+
+struct audit_context;           /* See audit.c */
+struct mempolicy;
+
+struct task_struct {
+        volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
+        struct thread_info *thread_info;
+        atomic_t usage;
+        unsigned long flags;    /* per process flags, defined below */
+        unsigned long ptrace;
+
+        int lock_depth;         /* Lock depth */
+
+        int prio, static_prio;
+        struct list_head run_list;
+        prio_array_t *array;
+
+        unsigned long sleep_avg;
+        unsigned long long timestamp, last_ran;
+        unsigned long long sched_time; /* sched_clock time spent running */
+        int activated;
+
+        unsigned long policy;
+        cpumask_t cpus_allowed;
+        unsigned int time_slice, first_time_slice;
+
+#ifdef CONFIG_SCHEDSTATS
+        struct sched_info sched_info;
+#endif
+
+        struct list_head tasks;
+        /*
+         * ptrace_list/ptrace_children forms the list of my children
+         * that were stolen by a ptracer.
+         */
+        struct list_head ptrace_children;
+        struct list_head ptrace_list;
+
+        struct mm_struct *mm, *active_mm;
+
+/* task state */
+        struct linux_binfmt *binfmt;
+        long exit_state;
+        int exit_code, exit_signal;
+        int pdeath_signal;  /*  The signal sent when the parent dies  */
+        /* ??? */
+        unsigned long personality;
+        unsigned did_exec:1;
+        pid_t pid;
+        pid_t tgid;
+        /* 
+         * pointers to (original) parent process, youngest child, younger sibling,
+         * older sibling, respectively.  (p->father can be replaced with 
+         * p->parent->pid)
+         */
+        struct task_struct *real_parent; /* real parent process (when being debugged) */
+        struct task_struct *parent;     /* parent process */
+        /*
+         * children/sibling forms the list of my children plus the
+         * tasks I'm ptracing.
+         */
+        struct list_head children;      /* list of my children */
+        struct list_head sibling;       /* linkage in my parent's children list */
+        struct task_struct *group_leader;       /* threadgroup leader */
+
+        /* PID/PID hash table linkage. */
+        struct pid pids[PIDTYPE_MAX];
+
+        struct completion *vfork_done;          /* for vfork() */
+        int __user *set_child_tid;              /* CLONE_CHILD_SETTID */
+        int __user *clear_child_tid;            /* CLONE_CHILD_CLEARTID */
+
+        unsigned long rt_priority;
+        cputime_t utime, stime;
+        unsigned long nvcsw, nivcsw; /* context switch counts */
+        struct timespec start_time;
+/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
+        unsigned long min_flt, maj_flt;
+
+        cputime_t it_prof_expires, it_virt_expires;
+        unsigned long long it_sched_expires;
+        struct list_head cpu_timers[3];
+
+/* process credentials */
+        uid_t uid,euid,suid,fsuid;
+        gid_t gid,egid,sgid,fsgid;
+        struct group_info *group_info;
+        kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
+        unsigned keep_capabilities:1;
+        struct user_struct *user;
+#ifdef CONFIG_KEYS
+        struct key *thread_keyring;     /* keyring private to this thread */
+#endif
+        int oomkilladj; /* OOM kill score adjustment (bit shift). */
+        char comm[TASK_COMM_LEN];
+/* file system info */
+        int link_count, total_link_count;
+/* ipc stuff */
+        struct sysv_sem sysvsem;
+/* CPU-specific state of this task */
+        struct thread_struct thread;
+/* filesystem information */
+        struct fs_struct *fs;
+/* open file information */
+        struct files_struct *files;
+/* namespace */
+        struct namespace *namespace;
+/* signal handlers */
+        struct signal_struct *signal;
+        struct sighand_struct *sighand;
+
+        sigset_t blocked, real_blocked;
+        struct sigpending pending;
+
+        unsigned long sas_ss_sp;
+        size_t sas_ss_size;
+        int (*notifier)(void *priv);
+        void *notifier_data;
+        sigset_t *notifier_mask;
+        
+        void *security;
+        struct audit_context *audit_context;
+        seccomp_t seccomp;
+
+/* Thread group tracking */
+        u32 parent_exec_id;
+        u32 self_exec_id;
+/* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
+        spinlock_t alloc_lock;
+/* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
+        spinlock_t proc_lock;
+/* context-switch lock */
+        spinlock_t switch_lock;
+
+/* journalling filesystem info */
+        void *journal_info;
+
+/* VM state */
+        struct reclaim_state *reclaim_state;
+
+        struct dentry *proc_dentry;
+        struct backing_dev_info *backing_dev_info;
+
+        struct io_context *io_context;
+
+        unsigned long ptrace_message;
+        siginfo_t *last_siginfo; /* For ptrace use.  */
+/*
+ * current io wait handle: wait queue entry to use for io waits
+ * If this thread is processing aio, this points at the waitqueue
+ * inside the currently handled kiocb. It may be NULL (i.e. default
+ * to a stack based synchronous wait) if its doing sync IO.
+ */
+        wait_queue_t *io_wait;
+/* i/o counters(bytes read/written, #syscalls */
+        u64 rchar, wchar, syscr, syscw;
+#if defined(CONFIG_BSD_PROCESS_ACCT)
+        u64 acct_rss_mem1;      /* accumulated rss usage */
+        u64 acct_vm_mem1;       /* accumulated virtual memory usage */
+        clock_t acct_stimexpd;  /* clock_t-converted stime since last update */
+#endif
+#ifdef CONFIG_NUMA
+        struct mempolicy *mempolicy;
+        short il_next;
+#endif
+#ifdef CONFIG_CPUSETS
+        struct cpuset *cpuset;
+        nodemask_t mems_allowed;
+        int cpuset_mems_generation;
+#endif
+};
+
+static inline pid_t process_group(struct task_struct *tsk)
+{
+        return tsk->signal->pgrp;
+}
+
+/**
+ * pid_alive - check that a task structure is not stale
+ * @p: Task structure to be checked.
+ *
+ * Test if a process is not yet dead (at most zombie state)
+ * If pid_alive fails, then pointers within the task structure
+ * can be stale and must not be dereferenced.
+ */
+static inline int pid_alive(struct task_struct *p)
+{
+        return p->pids[PIDTYPE_PID].nr != 0;
+}
+
+extern void free_task(struct task_struct *tsk);
+extern void __put_task_struct(struct task_struct *tsk);
+#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
+#define put_task_struct(tsk) \
+do { if (atomic_dec_and_test(&(tsk)->usage)) __put_task_struct(tsk); } while(0)
+
+/*
+ * Per process flags
+ */
+#define PF_ALIGNWARN    0x00000001      /* Print alignment warning msgs */
+                                        /* Not implemented yet, only for 486*/
+#define PF_STARTING     0x00000002      /* being created */
+#define PF_EXITING      0x00000004      /* getting shut down */
+#define PF_DEAD         0x00000008      /* Dead */
+#define PF_FORKNOEXEC   0x00000040      /* forked but didn't exec */
+#define PF_SUPERPRIV    0x00000100      /* used super-user privileges */
+#define PF_DUMPCORE     0x00000200      /* dumped core */
+#define PF_SIGNALED     0x00000400      /* killed by a signal */
+#define PF_MEMALLOC     0x00000800      /* Allocating memory */
+#define PF_FLUSHER      0x00001000      /* responsible for disk writeback */
+#define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
+#define PF_FREEZE       0x00004000      /* this task is being frozen for suspend now */
+#define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
+#define PF_FROZEN       0x00010000      /* frozen for system suspend */
+#define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
+#define PF_KSWAPD       0x00040000      /* I am kswapd */
+#define PF_SWAPOFF      0x00080000      /* I am in swapoff */
+#define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
+#define PF_SYNCWRITE    0x00200000      /* I am doing a sync write */
+#define PF_BORROWED_MM  0x00400000      /* I am a kthread doing use_mm */
+#define PF_RANDOMIZE    0x00800000      /* randomize virtual address space */
+
+/*
+ * Only the _current_ task can read/write to tsk->flags, but other
+ * tasks can access tsk->flags in readonly mode for example
+ * with tsk_used_math (like during threaded core dumping).
+ * There is however an exception to this rule during ptrace
+ * or during fork: the ptracer task is allowed to write to the
+ * child->flags of its traced child (same goes for fork, the parent
+ * can write to the child->flags), because we're guaranteed the
+ * child is not running and in turn not changing child->flags
+ * at the same time the parent does it.
+ */
+#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
+#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
+#define clear_used_math() clear_stopped_child_used_math(current)
+#define set_used_math() set_stopped_child_used_math(current)
+#define conditional_stopped_child_used_math(condition, child) \
+        do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
+#define conditional_used_math(condition) \
+        conditional_stopped_child_used_math(condition, current)
+#define copy_to_stopped_child_used_math(child) \
+        do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
+/* NOTE: this will return 0 or PF_USED_MATH, it will never return 1 */
+#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
+#define used_math() tsk_used_math(current)
+
+#ifdef CONFIG_SMP
+extern int set_cpus_allowed(task_t *p, cpumask_t new_mask);
+#else
+static inline int set_cpus_allowed(task_t *p, cpumask_t new_mask)
+{
+        if (!cpus_intersects(new_mask, cpu_online_map))
+                return -EINVAL;
+        return 0;
+}
+#endif
+
+extern unsigned long long sched_clock(void);
+extern unsigned long long current_sched_time(const task_t *current_task);
+
+/* sched_exec is called by processes performing an exec */
+#ifdef CONFIG_SMP
+extern void sched_exec(void);
+#else
+#define sched_exec()   {}
+#endif
+
+#ifdef CONFIG_HOTPLUG_CPU
+extern void idle_task_exit(void);
+#else
+static inline void idle_task_exit(void) {}
+#endif
+
+extern void sched_idle_next(void);
+extern void set_user_nice(task_t *p, long nice);
+extern int task_prio(const task_t *p);
+extern int task_nice(const task_t *p);
+extern int task_curr(const task_t *p);
+extern int idle_cpu(int cpu);
+extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
+extern task_t *idle_task(int cpu);
+
+void yield(void);
+
+/*
+ * The default (Linux) execution domain.
+ */
+extern struct exec_domain       default_exec_domain;
+
+union thread_union {
+        struct thread_info thread_info;
+        unsigned long stack[THREAD_SIZE/sizeof(long)];
+};
+
+#ifndef __HAVE_ARCH_KSTACK_END
+static inline int kstack_end(void *addr)
+{
+        /* Reliable end of stack detection:
+         * Some APM bios versions misalign the stack
+         */
+        return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
+}
+#endif
+
+extern union thread_union init_thread_union;
+extern struct task_struct init_task;
+
+extern struct   mm_struct init_mm;
+
+#define find_task_by_pid(nr)    find_task_by_pid_type(PIDTYPE_PID, nr)
+extern struct task_struct *find_task_by_pid_type(int type, int pid);
+extern void set_special_pids(pid_t session, pid_t pgrp);
+extern void __set_special_pids(pid_t session, pid_t pgrp);
+
+/* per-UID process charging. */
+extern struct user_struct * alloc_uid(uid_t);
+static inline struct user_struct *get_uid(struct user_struct *u)
+{
+        atomic_inc(&u->__count);
+        return u;
+}
+extern void free_uid(struct user_struct *);
+extern void switch_uid(struct user_struct *);
+
+#include <asm/current.h>
+
+extern void do_timer(struct pt_regs *);
+
+extern int FASTCALL(wake_up_state(struct task_struct * tsk, unsigned int state));
+extern int FASTCALL(wake_up_process(struct task_struct * tsk));
+extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
+                                                unsigned long clone_flags));
+#ifdef CONFIG_SMP
+ extern void kick_process(struct task_struct *tsk);
+#else
+ static inline void kick_process(struct task_struct *tsk) { }
+#endif
+extern void FASTCALL(sched_fork(task_t * p));
+extern void FASTCALL(sched_exit(task_t * p));
+
+extern int in_group_p(gid_t);
+extern int in_egroup_p(gid_t);
+
+extern void proc_caches_init(void);
+extern void flush_signals(struct task_struct *);
+extern void flush_signal_handlers(struct task_struct *, int force_default);
+extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
+
+static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&tsk->sighand->siglock, flags);
+        ret = dequeue_signal(tsk, mask, info);
+        spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
+
+        return ret;
+}       
+
+extern void block_all_signals(int (*notifier)(void *priv), void *priv,
+                              sigset_t *mask);
+extern void unblock_all_signals(void);
+extern void release_task(struct task_struct * p);
+extern int send_sig_info(int, struct siginfo *, struct task_struct *);
+extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
+extern int force_sigsegv(int, struct task_struct *);
+extern int force_sig_info(int, struct siginfo *, struct task_struct *);
+extern int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp);
+extern int kill_pg_info(int, struct siginfo *, pid_t);
+extern int kill_proc_info(int, struct siginfo *, pid_t);
+extern void do_notify_parent(struct task_struct *, int);
+extern void force_sig(int, struct task_struct *);
+extern void force_sig_specific(int, struct task_struct *);
+extern int send_sig(int, struct task_struct *, int);
+extern void zap_other_threads(struct task_struct *p);
+extern int kill_pg(pid_t, int, int);
+extern int kill_sl(pid_t, int, int);
+extern int kill_proc(pid_t, int, int);
+extern struct sigqueue *sigqueue_alloc(void);
+extern void sigqueue_free(struct sigqueue *);
+extern int send_sigqueue(int, struct sigqueue *,  struct task_struct *);
+extern int send_group_sigqueue(int, struct sigqueue *,  struct task_struct *);
+extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
+extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
+
+/* These can be the second arg to send_sig_info/send_group_sig_info.  */
+#define SEND_SIG_NOINFO ((struct siginfo *) 0)
+#define SEND_SIG_PRIV   ((struct siginfo *) 1)
+#define SEND_SIG_FORCED ((struct siginfo *) 2)
+
+/* True if we are on the alternate signal stack.  */
+
+static inline int on_sig_stack(unsigned long sp)
+{
+        return (sp - current->sas_ss_sp < current->sas_ss_size);
+}
+
+static inline int sas_ss_flags(unsigned long sp)
+{
+        return (current->sas_ss_size == 0 ? SS_DISABLE
+                : on_sig_stack(sp) ? SS_ONSTACK : 0);
+}
+
+
+#ifdef CONFIG_SECURITY
+/* code is in security.c */
+extern int capable(int cap);
+#else
+static inline int capable(int cap)
+{
+        if (cap_raised(current->cap_effective, cap)) {
+                current->flags |= PF_SUPERPRIV;
+                return 1;
+        }
+        return 0;
+}
+#endif
+
+/*
+ * Routines for handling mm_structs
+ */
+extern struct mm_struct * mm_alloc(void);
+
+/* mmdrop drops the mm and the page tables */
+extern void FASTCALL(__mmdrop(struct mm_struct *));
+static inline void mmdrop(struct mm_struct * mm)
+{
+        if (atomic_dec_and_test(&mm->mm_count))
+                __mmdrop(mm);
+}
+
+/* mmput gets rid of the mappings and all user-space */
+extern void mmput(struct mm_struct *);
+/* Grab a reference to a task's mm, if it is not already going away */
+extern struct mm_struct *get_task_mm(struct task_struct *task);
+/* Remove the current tasks stale references to the old mm_struct */
+extern void mm_release(struct task_struct *, struct mm_struct *);
+
+extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
+extern void flush_thread(void);
+extern void exit_thread(void);
+
+extern void exit_mm(struct task_struct *);
+extern void exit_files(struct task_struct *);
+extern void exit_signal(struct task_struct *);
+extern void __exit_signal(struct task_struct *);
+extern void exit_sighand(struct task_struct *);
+extern void __exit_sighand(struct task_struct *);
+extern void exit_itimers(struct signal_struct *);
+
+extern NORET_TYPE void do_group_exit(int);
+
+extern void reparent_to_init(void);
+extern void daemonize(const char *, ...);
+extern int allow_signal(int);
+extern int disallow_signal(int);
+extern task_t *child_reaper;
+
+extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
+extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
+task_t *fork_idle(int);
+
+extern void set_task_comm(struct task_struct *tsk, char *from);
+extern void get_task_comm(char *to, struct task_struct *tsk);
+
+#ifdef CONFIG_SMP
+extern void wait_task_inactive(task_t * p);
+#else
+#define wait_task_inactive(p)   do { } while (0)
+#endif
+
+#define remove_parent(p)        list_del_init(&(p)->sibling)
+#define add_parent(p, parent)   list_add_tail(&(p)->sibling,&(parent)->children)
+
+#define REMOVE_LINKS(p) do {                                    \
+        if (thread_group_leader(p))                             \
+                list_del_init(&(p)->tasks);                     \
+        remove_parent(p);                                       \
+        } while (0)
+
+#define SET_LINKS(p) do {                                       \
+        if (thread_group_leader(p))                             \
+                list_add_tail(&(p)->tasks,&init_task.tasks);    \
+        add_parent(p, (p)->parent);                             \
+        } while (0)
+
+#define next_task(p)    list_entry((p)->tasks.next, struct task_struct, tasks)
+#define prev_task(p)    list_entry((p)->tasks.prev, struct task_struct, tasks)
+
+#define for_each_process(p) \
+        for (p = &init_task ; (p = next_task(p)) != &init_task ; )
+
+/*
+ * Careful: do_each_thread/while_each_thread is a double loop so
+ *          'break' will not work as expected - use goto instead.
+ */
+#define do_each_thread(g, t) \
+        for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
+
+#define while_each_thread(g, t) \
+        while ((t = next_thread(t)) != g)
+
+extern task_t * FASTCALL(next_thread(const task_t *p));
+
+#define thread_group_leader(p)  (p->pid == p->tgid)
+
+static inline int thread_group_empty(task_t *p)
+{
+        return list_empty(&p->pids[PIDTYPE_TGID].pid_list);
+}
+
+#define delay_group_leader(p) \
+                (thread_group_leader(p) && !thread_group_empty(p))
+
+extern void unhash_process(struct task_struct *p);
+
+/*
+ * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
+ * subscriptions and synchronises with wait4().  Also used in procfs.
+ *
+ * Nests both inside and outside of read_lock(&tasklist_lock).
+ * It must not be nested with write_lock_irq(&tasklist_lock),
+ * neither inside nor outside.
+ */
+static inline void task_lock(struct task_struct *p)
+{
+        spin_lock(&p->alloc_lock);
+}
+
+static inline void task_unlock(struct task_struct *p)
+{
+        spin_unlock(&p->alloc_lock);
+}
+
+/* set thread flags in other task's structures
+ * - see asm/thread_info.h for TIF_xxxx flags available
+ */
+static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
+{
+        set_ti_thread_flag(tsk->thread_info,flag);
+}
+
+static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
+{
+        clear_ti_thread_flag(tsk->thread_info,flag);
+}
+
+static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
+{
+        return test_and_set_ti_thread_flag(tsk->thread_info,flag);
+}
+
+static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
+{
+        return test_and_clear_ti_thread_flag(tsk->thread_info,flag);
+}
+
+static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
+{
+        return test_ti_thread_flag(tsk->thread_info,flag);
+}
+
+static inline void set_tsk_need_resched(struct task_struct *tsk)
+{
+        set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
+}
+
+static inline void clear_tsk_need_resched(struct task_struct *tsk)
+{
+        clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
+}
+
+static inline int signal_pending(struct task_struct *p)
+{
+        return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
+}
+  
+static inline int need_resched(void)
+{
+        return unlikely(test_thread_flag(TIF_NEED_RESCHED));
+}
+
+/*
+ * cond_resched() and cond_resched_lock(): latency reduction via
+ * explicit rescheduling in places that are safe. The return
+ * value indicates whether a reschedule was done in fact.
+ * cond_resched_lock() will drop the spinlock before scheduling,
+ * cond_resched_softirq() will enable bhs before scheduling.
+ */
+extern int cond_resched(void);
+extern int cond_resched_lock(spinlock_t * lock);
+extern int cond_resched_softirq(void);
+
+/*
+ * Does a critical section need to be broken due to another
+ * task waiting?:
+ */
+#if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
+# define need_lockbreak(lock) ((lock)->break_lock)
+#else
+# define need_lockbreak(lock) 0
+#endif
+
+/*
+ * Does a critical section need to be broken due to another
+ * task waiting or preemption being signalled:
+ */
+static inline int lock_need_resched(spinlock_t *lock)
+{
+        if (need_lockbreak(lock) || need_resched())
+                return 1;
+        return 0;
+}
+
+/* Reevaluate whether the task has signals pending delivery.
+   This is required every time the blocked sigset_t changes.
+   callers must hold sighand->siglock.  */
+
+extern FASTCALL(void recalc_sigpending_tsk(struct task_struct *t));
+extern void recalc_sigpending(void);
+
+extern void signal_wake_up(struct task_struct *t, int resume_stopped);
+
+/*
+ * Wrappers for p->thread_info->cpu access. No-op on UP.
+ */
+#ifdef CONFIG_SMP
+
+static inline unsigned int task_cpu(const struct task_struct *p)
+{
+        return p->thread_info->cpu;
+}
+
+static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
+{
+        p->thread_info->cpu = cpu;
+}
+
+#else
+
+static inline unsigned int task_cpu(const struct task_struct *p)
+{
+        return 0;
+}
+
+static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
+{
+}
+
+#endif /* CONFIG_SMP */
+
+#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
+extern void arch_pick_mmap_layout(struct mm_struct *mm);
+#else
+static inline void arch_pick_mmap_layout(struct mm_struct *mm)
+{
+        mm->mmap_base = TASK_UNMAPPED_BASE;
+        mm->get_unmapped_area = arch_get_unmapped_area;
+        mm->unmap_area = arch_unmap_area;
+}
+#endif
+
+extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
+extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
+
+#ifdef CONFIG_MAGIC_SYSRQ
+
+extern void normalize_rt_tasks(void);
+
+#endif
+
+/* try_to_freeze
+ *
+ * Checks whether we need to enter the refrigerator
+ * and returns 1 if we did so.
+ */
+#ifdef CONFIG_PM
+extern void refrigerator(unsigned long);
+extern int freeze_processes(void);
+extern void thaw_processes(void);
+
+static inline int try_to_freeze(unsigned long refrigerator_flags)
+{
+        if (unlikely(current->flags & PF_FREEZE)) {
+                refrigerator(refrigerator_flags);
+                return 1;
+        } else
+                return 0;
+}
+#else
+static inline void refrigerator(unsigned long flag) {}
+static inline int freeze_processes(void) { BUG(); return 0; }
+static inline void thaw_processes(void) {}
+
+static inline int try_to_freeze(unsigned long refrigerator_flags)
+{
+        return 0;
+}
+#endif /* CONFIG_PM */
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/sctp.h b/include/linux/sctp.h
new file mode 100644
index 000000000000..6ec66dec29f7
--- /dev/null
+++ b/include/linux/sctp.h
@@ -0,0 +1,594 @@
+/* SCTP kernel reference Implementation
+ * (C) Copyright IBM Corp. 2001, 2004
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * This file is part of the SCTP kernel reference Implementation
+ *
+ * Various protocol defined structures.
+ *
+ * The SCTP reference implementation 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; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP reference implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *                 ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ *    lksctp developers <lksctp-developerst@lists.sourceforge.net>
+ *
+ * Or submit a bug report through the following website:
+ *    http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ *    La Monte H.P. Yarroll <piggy@acm.org>
+ *    Karl Knutson <karl@athena.chicago.il.us>
+ *    Jon Grimm <jgrimm@us.ibm.com>
+ *    Xingang Guo <xingang.guo@intel.com>
+ *    randall@sctp.chicago.il.us
+ *    kmorneau@cisco.com
+ *    qxie1@email.mot.com
+ *    Sridhar Samudrala <sri@us.ibm.com>
+ *    Kevin Gao <kevin.gao@intel.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+#ifndef __LINUX_SCTP_H__
+#define __LINUX_SCTP_H__
+
+#include <linux/in.h>           /* We need in_addr.  */
+#include <linux/in6.h>          /* We need in6_addr.  */
+
+
+/* Section 3.1.  SCTP Common Header Format */
+typedef struct sctphdr {
+        __u16 source;
+        __u16 dest;
+        __u32 vtag;
+        __u32 checksum;
+} __attribute__((packed)) sctp_sctphdr_t;
+
+/* Section 3.2.  Chunk Field Descriptions. */
+typedef struct sctp_chunkhdr {
+        __u8 type;
+        __u8 flags;
+        __u16 length;
+} __attribute__((packed)) sctp_chunkhdr_t;
+
+
+/* Section 3.2.  Chunk Type Values.
+ * [Chunk Type] identifies the type of information contained in the Chunk
+ * Value field. It takes a value from 0 to 254. The value of 255 is
+ * reserved for future use as an extension field.
+ */
+typedef enum {
+        SCTP_CID_DATA                   = 0,
+        SCTP_CID_INIT                   = 1,
+        SCTP_CID_INIT_ACK               = 2,
+        SCTP_CID_SACK                   = 3,
+        SCTP_CID_HEARTBEAT              = 4,
+        SCTP_CID_HEARTBEAT_ACK          = 5,
+        SCTP_CID_ABORT                  = 6,
+        SCTP_CID_SHUTDOWN               = 7,
+        SCTP_CID_SHUTDOWN_ACK           = 8,
+        SCTP_CID_ERROR                  = 9,
+        SCTP_CID_COOKIE_ECHO            = 10,
+        SCTP_CID_COOKIE_ACK             = 11,
+        SCTP_CID_ECN_ECNE               = 12,
+        SCTP_CID_ECN_CWR                = 13,
+        SCTP_CID_SHUTDOWN_COMPLETE      = 14,
+
+        /* PR-SCTP Sec 3.2 */
+        SCTP_CID_FWD_TSN                = 0xC0,
+
+        /* Use hex, as defined in ADDIP sec. 3.1 */
+        SCTP_CID_ASCONF                 = 0xC1,
+        SCTP_CID_ASCONF_ACK             = 0x80,
+} sctp_cid_t; /* enum */
+
+
+/* Section 3.2
+ *  Chunk Types are encoded such that the highest-order two bits specify
+ *  the action that must be taken if the processing endpoint does not
+ *  recognize the Chunk Type.
+ */
+typedef enum {
+        SCTP_CID_ACTION_DISCARD     = 0x00,
+        SCTP_CID_ACTION_DISCARD_ERR = 0x40,
+        SCTP_CID_ACTION_SKIP        = 0x80,
+        SCTP_CID_ACTION_SKIP_ERR    = 0xc0,
+} sctp_cid_action_t;
+
+enum { SCTP_CID_ACTION_MASK = 0xc0, };
+
+/* This flag is used in Chunk Flags for ABORT and SHUTDOWN COMPLETE.
+ *
+ * 3.3.7 Abort Association (ABORT) (6):
+ *    The T bit is set to 0 if the sender had a TCB that it destroyed.
+ *    If the sender did not have a TCB it should set this bit to 1.
+ */
+enum { SCTP_CHUNK_FLAG_T = 0x01 };
+
+/*
+ *  Set the T bit
+ *
+ *      0                   1                   2                   3
+ *      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *     |   Type = 14   |Reserved     |T|      Length = 4               |
+ *     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * Chunk Flags: 8 bits
+ *
+ *   Reserved:  7 bits
+ *     Set to 0 on transmit and ignored on receipt.
+ *
+ *   T bit:  1 bit
+ *     The T bit is set to 0 if the sender had a TCB that it destroyed. If
+ *     the sender did NOT have a TCB it should set this bit to 1.
+ *
+ * Note: Special rules apply to this chunk for verification, please
+ * see Section 8.5.1 for details.
+ */
+
+#define sctp_test_T_bit(c)    ((c)->chunk_hdr->flags & SCTP_CHUNK_FLAG_T)
+
+/* RFC 2960
+ * Section 3.2.1 Optional/Variable-length Parmaeter Format.
+ */
+
+typedef struct sctp_paramhdr {
+        __u16 type;
+        __u16 length;
+} __attribute__((packed)) sctp_paramhdr_t;
+
+typedef enum {
+
+        /* RFC 2960 Section 3.3.5 */
+        SCTP_PARAM_HEARTBEAT_INFO               = __constant_htons(1),
+        /* RFC 2960 Section 3.3.2.1 */
+        SCTP_PARAM_IPV4_ADDRESS                 = __constant_htons(5),
+        SCTP_PARAM_IPV6_ADDRESS                 = __constant_htons(6),
+        SCTP_PARAM_STATE_COOKIE                 = __constant_htons(7),
+        SCTP_PARAM_UNRECOGNIZED_PARAMETERS      = __constant_htons(8),
+        SCTP_PARAM_COOKIE_PRESERVATIVE          = __constant_htons(9),
+        SCTP_PARAM_HOST_NAME_ADDRESS            = __constant_htons(11),
+        SCTP_PARAM_SUPPORTED_ADDRESS_TYPES      = __constant_htons(12),
+        SCTP_PARAM_ECN_CAPABLE                  = __constant_htons(0x8000),
+
+        /* PR-SCTP Sec 3.1 */
+        SCTP_PARAM_FWD_TSN_SUPPORT      = __constant_htons(0xc000),
+
+        /* Add-IP Extension. Section 3.2 */
+        SCTP_PARAM_ADD_IP               = __constant_htons(0xc001),
+        SCTP_PARAM_DEL_IP               = __constant_htons(0xc002),
+        SCTP_PARAM_ERR_CAUSE            = __constant_htons(0xc003),
+        SCTP_PARAM_SET_PRIMARY          = __constant_htons(0xc004),
+        SCTP_PARAM_SUCCESS_REPORT       = __constant_htons(0xc005),
+        SCTP_PARAM_ADAPTION_LAYER_IND   = __constant_htons(0xc006),
+
+} sctp_param_t; /* enum */
+
+
+/* RFC 2960 Section 3.2.1
+ *  The Parameter Types are encoded such that the highest-order two bits
+ *  specify the action that must be taken if the processing endpoint does
+ *  not recognize the Parameter Type.
+ *
+ */
+typedef enum {
+        SCTP_PARAM_ACTION_DISCARD     = __constant_htons(0x0000),
+        SCTP_PARAM_ACTION_DISCARD_ERR = __constant_htons(0x4000),
+        SCTP_PARAM_ACTION_SKIP        = __constant_htons(0x8000),
+        SCTP_PARAM_ACTION_SKIP_ERR    = __constant_htons(0xc000),
+} sctp_param_action_t;
+
+enum { SCTP_PARAM_ACTION_MASK = __constant_htons(0xc000), };
+
+/* RFC 2960 Section 3.3.1 Payload Data (DATA) (0) */
+
+typedef struct sctp_datahdr {
+        __u32 tsn;
+        __u16 stream;
+        __u16 ssn;
+        __u32 ppid;
+        __u8  payload[0];
+} __attribute__((packed)) sctp_datahdr_t;
+
+typedef struct sctp_data_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_datahdr_t  data_hdr;
+} __attribute__((packed)) sctp_data_chunk_t;
+
+/* DATA Chuck Specific Flags */
+enum {
+        SCTP_DATA_MIDDLE_FRAG   = 0x00,
+        SCTP_DATA_LAST_FRAG     = 0x01,
+        SCTP_DATA_FIRST_FRAG    = 0x02,
+        SCTP_DATA_NOT_FRAG      = 0x03,
+        SCTP_DATA_UNORDERED     = 0x04,
+};
+enum { SCTP_DATA_FRAG_MASK = 0x03, };
+
+
+/* RFC 2960 Section 3.3.2 Initiation (INIT) (1)
+ *
+ *  This chunk is used to initiate a SCTP association between two
+ *  endpoints.
+ */
+typedef struct sctp_inithdr {
+        __u32 init_tag;
+        __u32 a_rwnd;
+        __u16 num_outbound_streams;
+        __u16 num_inbound_streams;
+        __u32 initial_tsn;
+        __u8  params[0];
+} __attribute__((packed)) sctp_inithdr_t;
+
+typedef struct sctp_init_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_inithdr_t init_hdr;
+} __attribute__((packed)) sctp_init_chunk_t;
+
+
+/* Section 3.3.2.1. IPv4 Address Parameter (5) */
+typedef struct sctp_ipv4addr_param {
+        sctp_paramhdr_t param_hdr;
+        struct in_addr  addr;
+} __attribute__((packed)) sctp_ipv4addr_param_t;
+
+/* Section 3.3.2.1. IPv6 Address Parameter (6) */
+typedef struct sctp_ipv6addr_param {
+        sctp_paramhdr_t param_hdr;
+        struct in6_addr addr;
+} __attribute__((packed)) sctp_ipv6addr_param_t;
+
+/* Section 3.3.2.1 Cookie Preservative (9) */
+typedef struct sctp_cookie_preserve_param {
+        sctp_paramhdr_t param_hdr;
+        uint32_t        lifespan_increment;
+} __attribute__((packed)) sctp_cookie_preserve_param_t;
+
+/* Section 3.3.2.1 Host Name Address (11) */
+typedef struct sctp_hostname_param {
+        sctp_paramhdr_t param_hdr;
+        uint8_t hostname[0];
+} __attribute__((packed)) sctp_hostname_param_t;
+
+/* Section 3.3.2.1 Supported Address Types (12) */
+typedef struct sctp_supported_addrs_param {
+        sctp_paramhdr_t param_hdr;
+        uint16_t types[0];
+} __attribute__((packed)) sctp_supported_addrs_param_t;
+
+/* Appendix A. ECN Capable (32768) */
+typedef struct sctp_ecn_capable_param {
+        sctp_paramhdr_t param_hdr;
+} __attribute__((packed)) sctp_ecn_capable_param_t;
+
+/* ADDIP Section 3.2.6 Adaption Layer Indication */
+typedef struct sctp_adaption_ind_param {
+        struct sctp_paramhdr param_hdr;
+        __u32 adaption_ind;
+} __attribute__((packed)) sctp_adaption_ind_param_t;
+
+/* RFC 2960.  Section 3.3.3 Initiation Acknowledgement (INIT ACK) (2):
+ *   The INIT ACK chunk is used to acknowledge the initiation of an SCTP
+ *   association.
+ */
+typedef sctp_init_chunk_t sctp_initack_chunk_t;
+
+/* Section 3.3.3.1 State Cookie (7) */
+typedef struct sctp_cookie_param {
+        sctp_paramhdr_t p;
+        __u8 body[0];
+} __attribute__((packed)) sctp_cookie_param_t;
+
+/* Section 3.3.3.1 Unrecognized Parameters (8) */
+typedef struct sctp_unrecognized_param {
+        sctp_paramhdr_t param_hdr;
+        sctp_paramhdr_t unrecognized;
+} __attribute__((packed)) sctp_unrecognized_param_t;
+
+
+
+/*
+ * 3.3.4 Selective Acknowledgement (SACK) (3):
+ *
+ *  This chunk is sent to the peer endpoint to acknowledge received DATA
+ *  chunks and to inform the peer endpoint of gaps in the received
+ *  subsequences of DATA chunks as represented by their TSNs.
+ */
+
+typedef struct sctp_gap_ack_block {
+        __u16 start;
+        __u16 end;
+} __attribute__((packed)) sctp_gap_ack_block_t;
+
+typedef uint32_t sctp_dup_tsn_t;
+
+typedef union {
+        sctp_gap_ack_block_t    gab;
+        sctp_dup_tsn_t          dup;
+} sctp_sack_variable_t;
+
+typedef struct sctp_sackhdr {
+        __u32 cum_tsn_ack;
+        __u32 a_rwnd;
+        __u16 num_gap_ack_blocks;
+        __u16 num_dup_tsns;
+        sctp_sack_variable_t variable[0];
+} __attribute__((packed)) sctp_sackhdr_t;
+
+typedef struct sctp_sack_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_sackhdr_t sack_hdr;
+} __attribute__((packed)) sctp_sack_chunk_t;
+
+
+/* RFC 2960.  Section 3.3.5 Heartbeat Request (HEARTBEAT) (4):
+ *
+ *  An endpoint should send this chunk to its peer endpoint to probe the
+ *  reachability of a particular destination transport address defined in
+ *  the present association.
+ */
+
+typedef struct sctp_heartbeathdr {
+        sctp_paramhdr_t info;
+} __attribute__((packed)) sctp_heartbeathdr_t;
+
+typedef struct sctp_heartbeat_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_heartbeathdr_t hb_hdr;
+} __attribute__((packed)) sctp_heartbeat_chunk_t;
+
+
+/* For the abort and shutdown ACK we must carry the init tag in the
+ * common header. Just the common header is all that is needed with a
+ * chunk descriptor.
+ */
+typedef struct sctp_abort_chunk {
+        sctp_chunkhdr_t uh;
+} __attribute__((packed)) sctp_abort_chunk_t;
+
+
+/* For the graceful shutdown we must carry the tag (in common header)
+ * and the highest consecutive acking value.
+ */
+typedef struct sctp_shutdownhdr {
+        __u32 cum_tsn_ack;
+} __attribute__((packed)) sctp_shutdownhdr_t;
+
+struct sctp_shutdown_chunk_t {
+        sctp_chunkhdr_t    chunk_hdr;
+        sctp_shutdownhdr_t shutdown_hdr;
+} __attribute__ ((packed));
+
+/* RFC 2960.  Section 3.3.10 Operation Error (ERROR) (9) */
+
+typedef struct sctp_errhdr {
+        __u16 cause;
+        __u16 length;
+        __u8  variable[0];
+} __attribute__((packed)) sctp_errhdr_t;
+
+typedef struct sctp_operr_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_errhdr_t   err_hdr;
+} __attribute__((packed)) sctp_operr_chunk_t;
+
+/* RFC 2960 3.3.10 - Operation Error
+ *
+ * Cause Code: 16 bits (unsigned integer)
+ *
+ *     Defines the type of error conditions being reported.
+ *    Cause Code
+ *     Value           Cause Code
+ *     ---------      ----------------
+ *      1              Invalid Stream Identifier
+ *      2              Missing Mandatory Parameter
+ *      3              Stale Cookie Error
+ *      4              Out of Resource
+ *      5              Unresolvable Address
+ *      6              Unrecognized Chunk Type
+ *      7              Invalid Mandatory Parameter
+ *      8              Unrecognized Parameters
+ *      9              No User Data
+ *     10              Cookie Received While Shutting Down
+ */
+typedef enum {
+
+        SCTP_ERROR_NO_ERROR        = __constant_htons(0x00),
+        SCTP_ERROR_INV_STRM        = __constant_htons(0x01),
+        SCTP_ERROR_MISS_PARAM      = __constant_htons(0x02),
+        SCTP_ERROR_STALE_COOKIE    = __constant_htons(0x03),
+        SCTP_ERROR_NO_RESOURCE     = __constant_htons(0x04),
+        SCTP_ERROR_DNS_FAILED      = __constant_htons(0x05),
+        SCTP_ERROR_UNKNOWN_CHUNK   = __constant_htons(0x06),
+        SCTP_ERROR_INV_PARAM       = __constant_htons(0x07),
+        SCTP_ERROR_UNKNOWN_PARAM   = __constant_htons(0x08),
+        SCTP_ERROR_NO_DATA         = __constant_htons(0x09),
+        SCTP_ERROR_COOKIE_IN_SHUTDOWN = __constant_htons(0x0a),
+
+
+        /* SCTP Implementation Guide:
+         *  11  Restart of an association with new addresses
+         *  12  User Initiated Abort
+         *  13  Protocol Violation
+         */
+
+        SCTP_ERROR_RESTART         = __constant_htons(0x0b),
+        SCTP_ERROR_USER_ABORT      = __constant_htons(0x0c),
+        SCTP_ERROR_PROTO_VIOLATION = __constant_htons(0x0d),
+
+        /* ADDIP Section 3.3  New Error Causes
+         *
+         * Four new Error Causes are added to the SCTP Operational Errors,
+         * primarily for use in the ASCONF-ACK chunk.
+         *
+         * Value          Cause Code
+         * ---------      ----------------
+         * 0x0100          Request to Delete Last Remaining IP Address.
+         * 0x0101          Operation Refused Due to Resource Shortage.
+         * 0x0102          Request to Delete Source IP Address.
+         * 0x0103          Association Aborted due to illegal ASCONF-ACK
+         * 0x0104          Request refused - no authorization.
+         */
+        SCTP_ERROR_DEL_LAST_IP  = __constant_htons(0x0100),
+        SCTP_ERROR_RSRC_LOW     = __constant_htons(0x0101),
+        SCTP_ERROR_DEL_SRC_IP   = __constant_htons(0x0102),
+        SCTP_ERROR_ASCONF_ACK   = __constant_htons(0x0103),
+        SCTP_ERROR_REQ_REFUSED  = __constant_htons(0x0104)
+} sctp_error_t;
+
+
+
+/* RFC 2960.  Appendix A.  Explicit Congestion Notification.
+ *   Explicit Congestion Notification Echo (ECNE) (12)
+ */
+typedef struct sctp_ecnehdr {
+        __u32 lowest_tsn;
+} sctp_ecnehdr_t;
+
+typedef struct sctp_ecne_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_ecnehdr_t ence_hdr;
+} __attribute__((packed)) sctp_ecne_chunk_t;
+
+/* RFC 2960.  Appendix A.  Explicit Congestion Notification.
+ *   Congestion Window Reduced (CWR) (13)
+ */
+typedef struct sctp_cwrhdr {
+        __u32 lowest_tsn;
+} sctp_cwrhdr_t;
+
+typedef struct sctp_cwr_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_cwrhdr_t cwr_hdr;
+} __attribute__((packed)) sctp_cwr_chunk_t;
+
+/* PR-SCTP
+ * 3.2 Forward Cumulative TSN Chunk Definition (FORWARD TSN)
+ *
+ * Forward Cumulative TSN chunk has the following format:
+ *
+ *        0                   1                   2                   3
+ *        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      |   Type = 192  |  Flags = 0x00 |        Length = Variable      |
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      |                      New Cumulative TSN                       |
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      |         Stream-1              |       Stream Sequence-1       |
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      \                                                               /
+ *      /                                                               \
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *      |         Stream-N              |       Stream Sequence-N       |
+ *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ *      Chunk Flags:
+ *
+ *        Set to all zeros on transmit and ignored on receipt.
+ *
+ *      New Cumulative TSN: 32 bit u_int
+ *
+ *       This indicates the new cumulative TSN to the data receiver. Upon
+ *       the reception of this value, the data receiver MUST consider
+ *       any missing TSNs earlier than or equal to this value as received
+ *       and stop reporting them as gaps in any subsequent SACKs.
+ *
+ *      Stream-N: 16 bit u_int
+ *
+ *       This field holds a stream number that was skipped by this
+ *       FWD-TSN.
+ *
+ *      Stream Sequence-N: 16 bit u_int
+ *       This field holds the sequence number associated with the stream
+ *       that was skipped. The stream sequence field holds the largest stream
+ *       sequence number in this stream being skipped.  The receiver of
+ *       the FWD-TSN's can use the Stream-N and Stream Sequence-N fields
+ *       to enable delivery of any stranded TSN's that remain on the stream
+ *       re-ordering queues. This field MUST NOT report TSN's corresponding
+ *       to DATA chunk that are marked as unordered. For ordered DATA
+ *       chunks this field MUST be filled in.
+ */
+struct sctp_fwdtsn_skip {
+        __u16 stream;
+        __u16 ssn;
+} __attribute__((packed));
+
+struct sctp_fwdtsn_hdr {
+        __u32 new_cum_tsn;
+        struct sctp_fwdtsn_skip skip[0];
+} __attribute((packed));
+
+struct sctp_fwdtsn_chunk {
+        struct sctp_chunkhdr chunk_hdr;
+        struct sctp_fwdtsn_hdr fwdtsn_hdr;
+} __attribute((packed));
+
+
+/* ADDIP
+ * Section 3.1.1 Address Configuration Change Chunk (ASCONF)
+ *
+ *      Serial Number: 32 bits (unsigned integer)
+ *      This value represents a Serial Number for the ASCONF Chunk. The
+ *      valid range of Serial Number is from 0 to 2^32-1.
+ *      Serial Numbers wrap back to 0 after reaching 2^32 -1.
+ *
+ *      Address Parameter: 8 or 20 bytes (depending on type)
+ *      The address is an address of the sender of the ASCONF chunk,
+ *      the address MUST be considered part of the association by the
+ *      peer endpoint. This field may be used by the receiver of the 
+ *      ASCONF to help in finding the association. This parameter MUST
+ *      be present in every ASCONF message i.e. it is a mandatory TLV
+ *      parameter.
+ *
+ *      ASCONF Parameter: TLV format
+ *      Each Address configuration change is represented by a TLV
+ *      parameter as defined in Section 3.2. One or more requests may
+ *      be present in an ASCONF Chunk.
+ *
+ * Section 3.1.2 Address Configuration Acknowledgement Chunk (ASCONF-ACK)
+ * 
+ *      Serial Number: 32 bits (unsigned integer)
+ *      This value represents the Serial Number for the received ASCONF
+ *      Chunk that is acknowledged by this chunk. This value is copied
+ *      from the received ASCONF Chunk. 
+ *
+ *      ASCONF Parameter Response: TLV format
+ *      The ASCONF Parameter Response is used in the ASCONF-ACK to
+ *      report status of ASCONF processing.
+ */
+typedef struct sctp_addip_param {
+        sctp_paramhdr_t param_hdr;
+        __u32           crr_id; 
+} __attribute__((packed)) sctp_addip_param_t;
+
+typedef struct sctp_addiphdr {
+        __u32   serial;
+        __u8    params[0];
+} __attribute__((packed)) sctp_addiphdr_t;
+
+typedef struct sctp_addip_chunk {
+        sctp_chunkhdr_t chunk_hdr;
+        sctp_addiphdr_t addip_hdr;
+} __attribute__((packed)) sctp_addip_chunk_t;
+
+#endif /* __LINUX_SCTP_H__ */
diff --git a/include/linux/scx200.h b/include/linux/scx200.h
new file mode 100644
index 000000000000..a22f9e173ad2
--- /dev/null
+++ b/include/linux/scx200.h
@@ -0,0 +1,58 @@
+/* linux/include/linux/scx200.h
+
+   Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
+
+   Defines for the National Semiconductor SCx200 Processors
+*/
+
+/* Interesting stuff for the National Semiconductor SCx200 CPU */
+
+extern unsigned scx200_cb_base;
+
+#define scx200_cb_present() (scx200_cb_base!=0)
+
+/* F0 PCI Header/Bridge Configuration Registers */
+#define SCx200_DOCCS_BASE 0x78  /* DOCCS Base Address Register */
+#define SCx200_DOCCS_CTRL 0x7c  /* DOCCS Control Register */
+
+/* GPIO Register Block */
+#define SCx200_GPIO_SIZE 0x2c   /* Size of GPIO register block */
+
+/* General Configuration Block */
+#define SCx200_CB_BASE_FIXED 0x9000     /* Base fixed at 0x9000 according to errata? */
+
+/* Watchdog Timer */
+#define SCx200_WDT_OFFSET 0x00  /* offset within configuration block */
+#define SCx200_WDT_SIZE 0x05    /* size */
+
+#define SCx200_WDT_WDTO 0x00    /* Time-Out Register */
+#define SCx200_WDT_WDCNFG 0x02  /* Configuration Register */
+#define SCx200_WDT_WDSTS 0x04   /* Status Register */
+#define SCx200_WDT_WDSTS_WDOVF (1<<0) /* Overflow bit */
+
+/* High Resolution Timer */
+#define SCx200_TIMER_OFFSET 0x08
+#define SCx200_TIMER_SIZE 0x05
+
+/* Clock Generators */
+#define SCx200_CLOCKGEN_OFFSET 0x10
+#define SCx200_CLOCKGEN_SIZE 0x10
+
+/* Pin Multiplexing and Miscellaneous Configuration Registers */
+#define SCx200_MISC_OFFSET 0x30
+#define SCx200_MISC_SIZE 0x10
+
+#define SCx200_PMR 0x30         /* Pin Multiplexing Register */
+#define SCx200_MCR 0x34         /* Miscellaneous Configuration Register */
+#define SCx200_INTSEL 0x38      /* Interrupt Selection Register */
+#define SCx200_IID 0x3c         /* IA On a Chip Identification Number Reg */
+#define SCx200_REV 0x3d         /* Revision Register */
+#define SCx200_CBA 0x3e         /* Configuration Base Address Register */
+#define SCx200_CBA_SCRATCH 0x64 /* Configuration Base Address Scratchpad */
+
+/*
+    Local variables:
+        compile-command: "make -C ../.. bzImage modules"
+        c-basic-offset: 8
+    End:
+*/
diff --git a/include/linux/scx200_gpio.h b/include/linux/scx200_gpio.h
new file mode 100644
index 000000000000..30cdd648ba79
--- /dev/null
+++ b/include/linux/scx200_gpio.h
@@ -0,0 +1,96 @@
+#include <linux/spinlock.h>
+
+u32 scx200_gpio_configure(int index, u32 set, u32 clear);
+
+extern unsigned scx200_gpio_base;
+extern long scx200_gpio_shadow[2];
+
+#define scx200_gpio_present() (scx200_gpio_base!=0)
+
+/* Definitions to make sure I do the same thing in all functions */
+#define __SCx200_GPIO_BANK unsigned bank = index>>5
+#define __SCx200_GPIO_IOADDR unsigned short ioaddr = scx200_gpio_base+0x10*bank
+#define __SCx200_GPIO_SHADOW long *shadow = scx200_gpio_shadow+bank
+#define __SCx200_GPIO_INDEX index &= 31
+
+#define __SCx200_GPIO_OUT __asm__ __volatile__("outsl":"=mS" (shadow):"d" (ioaddr), "0" (shadow))
+
+/* returns the value of the GPIO pin */
+
+static inline int scx200_gpio_get(int index) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_IOADDR + 0x04;
+        __SCx200_GPIO_INDEX;
+                
+        return (inl(ioaddr) & (1<<index)) ? 1 : 0;
+}
+
+/* return the value driven on the GPIO signal (the value that will be
+   driven if the GPIO is configured as an output, it might not be the
+   state of the GPIO right now if the GPIO is configured as an input) */
+
+static inline int scx200_gpio_current(int index) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_INDEX;
+                
+        return (scx200_gpio_shadow[bank] & (1<<index)) ? 1 : 0;
+}
+
+/* drive the GPIO signal high */
+
+static inline void scx200_gpio_set_high(int index) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_IOADDR;
+        __SCx200_GPIO_SHADOW;
+        __SCx200_GPIO_INDEX;
+        set_bit(index, shadow);
+        __SCx200_GPIO_OUT;
+}
+
+/* drive the GPIO signal low */
+
+static inline void scx200_gpio_set_low(int index) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_IOADDR;
+        __SCx200_GPIO_SHADOW;
+        __SCx200_GPIO_INDEX;
+        clear_bit(index, shadow);
+        __SCx200_GPIO_OUT;
+}
+
+/* drive the GPIO signal to state */
+
+static inline void scx200_gpio_set(int index, int state) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_IOADDR;
+        __SCx200_GPIO_SHADOW;
+        __SCx200_GPIO_INDEX;
+        if (state)
+                set_bit(index, shadow);
+        else
+                clear_bit(index, shadow);
+        __SCx200_GPIO_OUT;
+}
+
+/* toggle the GPIO signal */
+static inline void scx200_gpio_change(int index) {
+        __SCx200_GPIO_BANK;
+        __SCx200_GPIO_IOADDR;
+        __SCx200_GPIO_SHADOW;
+        __SCx200_GPIO_INDEX;
+        change_bit(index, shadow);
+        __SCx200_GPIO_OUT;
+}
+
+#undef __SCx200_GPIO_BANK
+#undef __SCx200_GPIO_IOADDR
+#undef __SCx200_GPIO_SHADOW
+#undef __SCx200_GPIO_INDEX
+#undef __SCx200_GPIO_OUT
+
+/*
+    Local variables:
+        compile-command: "make -C ../.. bzImage modules"
+        c-basic-offset: 8
+    End:
+*/
diff --git a/include/linux/sdla.h b/include/linux/sdla.h
new file mode 100644
index 000000000000..3b6afb8caa42
--- /dev/null
+++ b/include/linux/sdla.h
@@ -0,0 +1,339 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Global definitions for the Frame relay interface.
+ *
+ * Version:     @(#)if_ifrad.h  0.20    13 Apr 96
+ *
+ * Author:      Mike McLagan <mike.mclagan@linux.org>
+ *
+ * Changes:
+ *              0.15    Mike McLagan    Structure packing
+ *
+ *              0.20    Mike McLagan    New flags for S508 buffer handling
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+
+#ifndef SDLA_H
+#define SDLA_H
+
+/* adapter type */
+#define SDLA_TYPES
+#define SDLA_S502A                      5020
+#define SDLA_S502E                      5021
+#define SDLA_S503                       5030
+#define SDLA_S507                       5070
+#define SDLA_S508                       5080
+#define SDLA_S509                       5090
+#define SDLA_UNKNOWN                    -1
+
+/* port selection flags for the S508 */
+#define SDLA_S508_PORT_V35              0x00
+#define SDLA_S508_PORT_RS232            0x02
+
+/* Z80 CPU speeds */
+#define SDLA_CPU_3M                     0x00
+#define SDLA_CPU_5M                     0x01
+#define SDLA_CPU_7M                     0x02
+#define SDLA_CPU_8M                     0x03
+#define SDLA_CPU_10M                    0x04
+#define SDLA_CPU_16M                    0x05
+#define SDLA_CPU_12M                    0x06
+
+/* some private IOCTLs */
+#define SDLA_IDENTIFY                   (FRAD_LAST_IOCTL + 1)
+#define SDLA_CPUSPEED                   (FRAD_LAST_IOCTL + 2)
+#define SDLA_PROTOCOL                   (FRAD_LAST_IOCTL + 3)
+
+#define SDLA_CLEARMEM                   (FRAD_LAST_IOCTL + 4)
+#define SDLA_WRITEMEM                   (FRAD_LAST_IOCTL + 5)
+#define SDLA_READMEM                    (FRAD_LAST_IOCTL + 6)
+
+struct sdla_mem {
+   int  addr;
+   int  len;
+   void __user *data;
+};
+
+#define SDLA_START                      (FRAD_LAST_IOCTL + 7)
+#define SDLA_STOP                       (FRAD_LAST_IOCTL + 8)
+
+/* some offsets in the Z80's memory space */
+#define SDLA_NMIADDR                    0x0000
+#define SDLA_CONF_ADDR                  0x0010
+#define SDLA_S502A_NMIADDR              0x0066
+#define SDLA_CODE_BASEADDR              0x0100
+#define SDLA_WINDOW_SIZE                0x2000
+#define SDLA_ADDR_MASK                  0x1FFF
+
+/* largest handleable block of data */
+#define SDLA_MAX_DATA                   4080
+#define SDLA_MAX_MTU                    4072    /* MAX_DATA - sizeof(fradhdr) */
+#define SDLA_MAX_DLCI                   24
+
+/* this should be the same as frad_conf */
+struct sdla_conf {
+   short station;
+   short config;
+   short kbaud;
+   short clocking;
+   short max_frm;
+   short T391;
+   short T392;
+   short N391;
+   short N392;
+   short N393;
+   short CIR_fwd;
+   short Bc_fwd;
+   short Be_fwd;
+   short CIR_bwd;
+   short Bc_bwd;
+   short Be_bwd;
+};
+
+/* this should be the same as dlci_conf */
+struct sdla_dlci_conf {
+   short config;
+   short CIR_fwd;
+   short Bc_fwd;
+   short Be_fwd;
+   short CIR_bwd;
+   short Bc_bwd;
+   short Be_bwd; 
+   short Tc_fwd;
+   short Tc_bwd;
+   short Tf_max;
+   short Tb_max;
+};
+
+#ifndef __KERNEL__
+
+void sdla(void *cfg_info, char *dev, struct frad_conf *conf, int quiet);
+
+#else
+
+/* important Z80 window addresses */
+#define SDLA_CONTROL_WND                0xE000
+
+#define SDLA_502_CMD_BUF                0xEF60
+#define SDLA_502_RCV_BUF                0xA900
+#define SDLA_502_TXN_AVAIL              0xFFF1
+#define SDLA_502_RCV_AVAIL              0xFFF2
+#define SDLA_502_EVENT_FLAGS            0xFFF3
+#define SDLA_502_MDM_STATUS             0xFFF4
+#define SDLA_502_IRQ_INTERFACE          0xFFFD
+#define SDLA_502_IRQ_PERMISSION         0xFFFE
+#define SDLA_502_DATA_OFS               0x0010
+
+#define SDLA_508_CMD_BUF                0xE000
+#define SDLA_508_TXBUF_INFO             0xF100
+#define SDLA_508_RXBUF_INFO             0xF120
+#define SDLA_508_EVENT_FLAGS            0xF003
+#define SDLA_508_MDM_STATUS             0xF004
+#define SDLA_508_IRQ_INTERFACE          0xF010
+#define SDLA_508_IRQ_PERMISSION         0xF011
+#define SDLA_508_TSE_OFFSET             0xF012
+
+/* Event flags */
+#define SDLA_EVENT_STATUS               0x01
+#define SDLA_EVENT_DLCI_STATUS          0x02
+#define SDLA_EVENT_BAD_DLCI             0x04
+#define SDLA_EVENT_LINK_DOWN            0x40
+
+/* IRQ Trigger flags */
+#define SDLA_INTR_RX                    0x01
+#define SDLA_INTR_TX                    0x02
+#define SDLA_INTR_MODEM                 0x04
+#define SDLA_INTR_COMPLETE              0x08
+#define SDLA_INTR_STATUS                0x10
+#define SDLA_INTR_TIMER                 0x20
+
+/* DLCI status bits */
+#define SDLA_DLCI_DELETED               0x01
+#define SDLA_DLCI_ACTIVE                0x02
+#define SDLA_DLCI_WAITING               0x04
+#define SDLA_DLCI_NEW                   0x08
+#define SDLA_DLCI_INCLUDED              0x40
+
+/* valid command codes */
+#define SDLA_INFORMATION_WRITE          0x01
+#define SDLA_INFORMATION_READ           0x02
+#define SDLA_ISSUE_IN_CHANNEL_SIGNAL    0x03
+#define SDLA_SET_DLCI_CONFIGURATION     0x10
+#define SDLA_READ_DLCI_CONFIGURATION    0x11
+#define SDLA_DISABLE_COMMUNICATIONS     0x12
+#define SDLA_ENABLE_COMMUNICATIONS      0x13
+#define SDLA_READ_DLC_STATUS            0x14
+#define SDLA_READ_DLC_STATISTICS        0x15
+#define SDLA_FLUSH_DLC_STATISTICS       0x16
+#define SDLA_LIST_ACTIVE_DLCI           0x17
+#define SDLA_FLUSH_INFORMATION_BUFFERS  0x18
+#define SDLA_ADD_DLCI                   0x20
+#define SDLA_DELETE_DLCI                0x21
+#define SDLA_ACTIVATE_DLCI              0x22
+#define SDLA_DEACTIVATE_DLCI            0x23
+#define SDLA_READ_MODEM_STATUS          0x30
+#define SDLA_SET_MODEM_STATUS           0x31
+#define SDLA_READ_COMMS_ERR_STATS       0x32
+#define SDLA_FLUSH_COMMS_ERR_STATS      0x33
+#define SDLA_READ_CODE_VERSION          0x40
+#define SDLA_SET_IRQ_TRIGGER            0x50
+#define SDLA_GET_IRQ_TRIGGER            0x51
+
+/* In channel signal types */
+#define SDLA_ICS_LINK_VERIFY            0x02
+#define SDLA_ICS_STATUS_ENQ             0x03
+
+/* modem status flags */
+#define SDLA_MODEM_DTR_HIGH             0x01
+#define SDLA_MODEM_RTS_HIGH             0x02
+#define SDLA_MODEM_DCD_HIGH             0x08
+#define SDLA_MODEM_CTS_HIGH             0x20
+
+/* used for RET_MODEM interpretation */
+#define SDLA_MODEM_DCD_LOW              0x01
+#define SDLA_MODEM_CTS_LOW              0x02
+
+/* return codes */
+#define SDLA_RET_OK                     0x00
+#define SDLA_RET_COMMUNICATIONS         0x01
+#define SDLA_RET_CHANNEL_INACTIVE       0x02
+#define SDLA_RET_DLCI_INACTIVE          0x03
+#define SDLA_RET_DLCI_CONFIG            0x04
+#define SDLA_RET_BUF_TOO_BIG            0x05
+#define SDLA_RET_NO_DATA                0x05
+#define SDLA_RET_BUF_OVERSIZE           0x06
+#define SDLA_RET_CIR_OVERFLOW           0x07
+#define SDLA_RET_NO_BUFS                0x08
+#define SDLA_RET_TIMEOUT                0x0A
+#define SDLA_RET_MODEM                  0x10
+#define SDLA_RET_CHANNEL_OFF            0x11
+#define SDLA_RET_CHANNEL_ON             0x12
+#define SDLA_RET_DLCI_STATUS            0x13
+#define SDLA_RET_DLCI_UNKNOWN           0x14
+#define SDLA_RET_COMMAND_INVALID        0x1F
+
+/* Configuration flags */
+#define SDLA_DIRECT_RECV                0x0080
+#define SDLA_TX_NO_EXCEPT               0x0020
+#define SDLA_NO_ICF_MSGS                0x1000
+#define SDLA_TX50_RX50                  0x0000
+#define SDLA_TX70_RX30                  0x2000
+#define SDLA_TX30_RX70                  0x4000
+
+/* IRQ selection flags */
+#define SDLA_IRQ_RECEIVE                0x01
+#define SDLA_IRQ_TRANSMIT               0x02
+#define SDLA_IRQ_MODEM_STAT             0x04
+#define SDLA_IRQ_COMMAND                0x08
+#define SDLA_IRQ_CHANNEL                0x10
+#define SDLA_IRQ_TIMER                  0x20
+
+/* definitions for PC memory mapping */
+#define SDLA_8K_WINDOW                  0x01
+#define SDLA_S502_SEG_A                 0x10
+#define SDLA_S502_SEG_C                 0x20
+#define SDLA_S502_SEG_D                 0x00
+#define SDLA_S502_SEG_E                 0x30
+#define SDLA_S507_SEG_A                 0x00
+#define SDLA_S507_SEG_B                 0x40
+#define SDLA_S507_SEG_C                 0x80
+#define SDLA_S507_SEG_E                 0xC0
+#define SDLA_S508_SEG_A                 0x00
+#define SDLA_S508_SEG_C                 0x10
+#define SDLA_S508_SEG_D                 0x08
+#define SDLA_S508_SEG_E                 0x18
+
+/* SDLA adapter port constants */
+#define SDLA_IO_EXTENTS                 0x04
+        
+#define SDLA_REG_CONTROL                0x00
+#define SDLA_REG_PC_WINDOW              0x01    /* offset for PC window select latch */
+#define SDLA_REG_Z80_WINDOW             0x02    /* offset for Z80 window select latch */
+#define SDLA_REG_Z80_CONTROL            0x03    /* offset for Z80 control latch */
+        
+#define SDLA_S502_STS                   0x00    /* status reg for 502, 502E, 507 */
+#define SDLA_S508_GNRL                  0x00    /* general purp. reg for 508 */
+#define SDLA_S508_STS                   0x01    /* status reg for 508 */
+#define SDLA_S508_IDR                   0x02    /* ID reg for 508 */
+        
+/* control register flags */
+#define SDLA_S502A_START                0x00    /* start the CPU */
+#define SDLA_S502A_INTREQ               0x02
+#define SDLA_S502A_INTEN                0x04
+#define SDLA_S502A_HALT                 0x08    /* halt the CPU */      
+#define SDLA_S502A_NMI                  0x10    /* issue an NMI to the CPU */
+
+#define SDLA_S502E_CPUEN                0x01
+#define SDLA_S502E_ENABLE               0x02
+#define SDLA_S502E_INTACK               0x04
+        
+#define SDLA_S507_ENABLE                0x01
+#define SDLA_S507_IRQ3                  0x00
+#define SDLA_S507_IRQ4                  0x20
+#define SDLA_S507_IRQ5                  0x40
+#define SDLA_S507_IRQ7                  0x60
+#define SDLA_S507_IRQ10                 0x80
+#define SDLA_S507_IRQ11                 0xA0
+#define SDLA_S507_IRQ12                 0xC0
+#define SDLA_S507_IRQ15                 0xE0
+        
+#define SDLA_HALT                       0x00
+#define SDLA_CPUEN                      0x02
+#define SDLA_MEMEN                      0x04
+#define SDLA_S507_EPROMWR               0x08
+#define SDLA_S507_EPROMCLK              0x10
+#define SDLA_S508_INTRQ                 0x08
+#define SDLA_S508_INTEN                 0x10
+
+struct sdla_cmd {
+   char  opp_flag               __attribute__((packed));
+   char  cmd                    __attribute__((packed));
+   short length                 __attribute__((packed));
+   char  retval                 __attribute__((packed));
+   short dlci                   __attribute__((packed));
+   char  flags                  __attribute__((packed));
+   short rxlost_int             __attribute__((packed));
+   long  rxlost_app             __attribute__((packed));
+   char  reserve[2]             __attribute__((packed));
+   char  data[SDLA_MAX_DATA]    __attribute__((packed));        /* transfer data buffer */
+};
+
+struct intr_info {
+   char  flags          __attribute__((packed));
+   short txlen          __attribute__((packed));
+   char  irq            __attribute__((packed));
+   char  flags2         __attribute__((packed));
+   short timeout        __attribute__((packed));
+};
+
+/* found in the 508's control window at RXBUF_INFO */
+struct buf_info {
+   unsigned short rse_num       __attribute__((packed));
+   unsigned long  rse_base      __attribute__((packed));
+   unsigned long  rse_next      __attribute__((packed));
+   unsigned long  buf_base      __attribute__((packed));
+   unsigned short reserved      __attribute__((packed));
+   unsigned long  buf_top       __attribute__((packed));
+};
+
+/* structure pointed to by rse_base in RXBUF_INFO struct */
+struct buf_entry {
+   char  opp_flag       __attribute__((packed));
+   short length         __attribute__((packed));
+   short dlci           __attribute__((packed));
+   char  flags          __attribute__((packed));
+   short timestamp      __attribute__((packed));
+   short reserved[2]    __attribute__((packed));
+   long  buf_addr       __attribute__((packed));
+};
+
+#endif
+
+#endif
diff --git a/include/linux/sdla_asy.h b/include/linux/sdla_asy.h
new file mode 100644
index 000000000000..f62242537c86
--- /dev/null
+++ b/include/linux/sdla_asy.h
@@ -0,0 +1,226 @@
+/*****************************************************************************
+* sdla_asy.h    Header file for the Sangoma S508/S514 asynchronous code API     
+*
+* Author:       Gideon Hack     
+*
+* Copyright:    (c) 2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+*
+* Jan 28, 2000  Gideon Hack     Initial Version
+*
+*****************************************************************************/
+
+
+#ifndef _WANPIPE_ASYNC_H
+#define _WANPIPE_ASYNC_H
+
+/* ----------------------------------------------------------------------------
+ *                        Interface commands
+ * --------------------------------------------------------------------------*/
+
+#define SET_ASY_CONFIGURATION           0xE2    /* set the asychronous operational configuration */
+#define READ_ASY_CONFIGURATION          0xE3    /* read the current asychronous operational configuration */
+#define ENABLE_ASY_COMMUNICATIONS       0xE4    /* enable asychronous communications */
+#define DISABLE_ASY_COMMUNICATIONS      0xE5    /* disable asychronous communications */
+#define READ_ASY_OPERATIONAL_STATS      0xE7    /* retrieve the asychronous operational statistics */
+#define FLUSH_ASY_OPERATIONAL_STATS     0xE8    /* flush the asychronous operational statistics */
+#define TRANSMIT_ASY_BREAK_SIGNAL       0xEC    /* transmit an asychronous break signal */
+
+
+
+/* ----------------------------------------------------------------------------
+ *                     Return codes from interface commands
+ * --------------------------------------------------------------------------*/
+
+#define COMMAND_INVALID_FOR_PORT        0x50    /* the command is invalid for the selected port */
+#define DISABLE_ASY_COMMS_BEFORE_CFG    0xE1    /* communications must be disabled before setting the configuration */
+#define ASY_COMMS_ENABLED               0xE1    /* communications are currently enabled */
+#define ASY_COMMS_DISABLED              0xE1    /* communications are currently disabled */
+#define ASY_CFG_BEFORE_COMMS_ENABLED    0xE2    /* perform a SET_ASY_CONFIGURATION before enabling comms */
+#define LGTH_ASY_CFG_DATA_INVALID       0xE2    /* the length of the passed configuration data is invalid */
+#define INVALID_ASY_CFG_DATA            0xE3    /* the passed configuration data is invalid */
+#define ASY_BREAK_SIGNAL_BUSY           0xEC    /* a break signal is being transmitted */
+
+
+
+/* ----------------------------------------------------------------------------
+ *   Constants for the SET_ASY_CONFIGURATION/READ_ASY_CONFIGURATION command
+ * --------------------------------------------------------------------------*/
+
+/* the asynchronous configuration structure */
+typedef struct {
+        unsigned long baud_rate                 PACKED;                                                 /* the baud rate */     
+        unsigned short line_config_options      PACKED; /* line configuration options */
+        unsigned short modem_config_options     PACKED; /* modem configuration options */
+        unsigned short asy_API_options          PACKED; /* asynchronous API options */
+        unsigned short asy_protocol_options     PACKED; /* asynchronous protocol options */
+        unsigned short Tx_bits_per_char         PACKED; /* number of bits per tx character */
+        unsigned short Rx_bits_per_char         PACKED; /* number of bits per received character */
+        unsigned short stop_bits                PACKED; /* number of stop bits per character */
+        unsigned short parity                   PACKED; /* parity definition */
+        unsigned short break_timer              PACKED; /* the break signal timer */
+        unsigned short asy_Rx_inter_char_timer  PACKED; /* the receive inter-character timer */
+        unsigned short asy_Rx_complete_length   PACKED; /* the receive 'buffer complete' length */
+        unsigned short XON_char                 PACKED; /* the XON character */
+        unsigned short XOFF_char                PACKED; /* the XOFF character */
+        unsigned short asy_statistics_options   PACKED; /* async operational stat options */
+        unsigned long ptr_shared_mem_info_struct    PACKED;/* ptr to the shared memory area information structure */
+        unsigned long ptr_asy_Tx_stat_el_cfg_struct PACKED;/* ptr to the transmit status element configuration structure */
+        unsigned long ptr_asy_Rx_stat_el_cfg_struct PACKED;/* ptr to the receive status element configuration structure */
+} ASY_CONFIGURATION_STRUCT;
+
+/* permitted minimum and maximum values for setting the asynchronous configuration */
+#define MIN_ASY_BAUD_RATE               50      /* maximum baud rate */
+#define MAX_ASY_BAUD_RATE               250000  /* minimum baud rate */
+#define MIN_ASY_BITS_PER_CHAR           5       /* minimum number of bits per character */
+#define MAX_ASY_BITS_PER_CHAR           8       /* maximum number of bits per character */
+#define MIN_BREAK_TMR_VAL               0       /* minimum break signal timer */
+#define MAX_BREAK_TMR_VAL               5000    /* maximum break signal timer */
+#define MIN_ASY_RX_INTER_CHAR_TMR       0       /* minimum receive inter-character timer */
+#define MAX_ASY_RX_INTER_CHAR_TMR       30000   /* maximum receive inter-character timer */
+#define MIN_ASY_RX_CPLT_LENGTH          0       /* minimum receive 'length complete' value */
+#define MAX_ASY_RX_CPLT_LENGTH          2000    /* maximum receive 'length complete' value */
+
+/* bit settings for the 'asy_API_options' */
+#define ASY_RX_DATA_TRANSPARENT         0x0001  /* do not strip parity and unused bits from received characters */
+
+/* bit settings for the 'asy_protocol_options' */
+#define ASY_RTS_HS_FOR_RX               0x0001  /* RTS handshaking is used for reception control */
+#define ASY_XON_XOFF_HS_FOR_RX          0x0002  /* XON/XOFF handshaking is used for reception control */
+#define ASY_XON_XOFF_HS_FOR_TX          0x0004  /* XON/XOFF handshaking is used for transmission control */
+#define ASY_DCD_HS_FOR_TX               0x0008  /* DCD handshaking is used for transmission control */
+#define ASY_CTS_HS_FOR_TX               0x0020  /* CTS handshaking is used for transmission control */
+
+/* bit settings for the 'stop_bits' definition */
+#define ONE_STOP_BIT                    1                       /* representation for 1 stop bit */
+#define TWO_STOP_BITS                   2                       /* representation for 2 stop bits */
+#define ONE_AND_A_HALF_STOP_BITS        3                       /* representation for 1.5 stop bits */
+
+/* bit settings for the 'parity' definition */
+#define NO_PARITY                       0                       /* representation for no parity */
+#define ODD_PARITY                      1                       /* representation for odd parity */
+#define EVEN_PARITY                     2                       /* representation for even parity */
+
+
+
+/* ----------------------------------------------------------------------------
+ *    Constants for the READ_COMMS_ERROR_STATS command (asynchronous mode)
+ * --------------------------------------------------------------------------*/
+
+/* the communications error statistics structure */
+typedef struct {
+        unsigned short Rx_overrun_err_count     PACKED; /* receiver overrun error count */
+        unsigned short Rx_parity_err_count      PACKED; /* parity errors received count */
+        unsigned short Rx_framing_err_count     PACKED; /* framing errors received count */
+        unsigned short comms_err_stat_reserved_1 PACKED;/* reserved for later use */
+        unsigned short comms_err_stat_reserved_2 PACKED;/* reserved for later use */
+        unsigned short comms_err_stat_reserved_3 PACKED;/* reserved for later use */
+        unsigned short comms_err_stat_reserved_4 PACKED;/* reserved for later use */
+        unsigned short comms_err_stat_reserved_5 PACKED;/* reserved for later use */
+        unsigned short DCD_state_change_count   PACKED; /* DCD state change count */
+        unsigned short CTS_state_change_count   PACKED; /* CTS state change count */
+} ASY_COMMS_ERROR_STATS_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *         Constants for the READ_ASY_OPERATIONAL_STATS command
+ * --------------------------------------------------------------------------*/
+
+/* the asynchronous operational statistics structure */
+typedef struct {
+
+        /* Data transmission statistics */
+        unsigned long Data_blocks_Tx_count PACKED;/* number of blocks transmitted */
+        unsigned long Data_bytes_Tx_count  PACKED;/* number of bytes transmitted */
+        unsigned long Data_Tx_throughput   PACKED;/* transmit throughput */
+        unsigned long no_ms_for_Data_Tx_thruput_comp PACKED;/* millisecond time used for the Tx throughput computation */
+        unsigned long Tx_Data_discard_lgth_err_count PACKED;/* number of Data blocks discarded (length error) */
+        unsigned long reserved_Data_frm_Tx_stat1 PACKED;/* reserved for later use */
+        unsigned long reserved_Data_frm_Tx_stat2 PACKED;/* reserved for later use */
+        unsigned long reserved_Data_frm_Tx_stat3 PACKED;/* reserved for later use */
+
+        /* Data reception statistics */
+        unsigned long Data_blocks_Rx_count PACKED;/* number of blocks received */
+        unsigned long Data_bytes_Rx_count  PACKED;/* number of bytes received */
+        unsigned long Data_Rx_throughput   PACKED;/* receive throughput */
+        unsigned long no_ms_for_Data_Rx_thruput_comp PACKED;/* millisecond time used for the Rx throughput computation */
+        unsigned long Rx_Data_bytes_discard_count    PACKED;/* received Data bytes discarded */
+        unsigned long reserved_Data_frm_Rx_stat1     PACKED;/* reserved for later use */
+
+        /* handshaking protocol statistics */
+        unsigned short XON_chars_Tx_count       PACKED; /* number of XON characters transmitted */
+        unsigned short XOFF_chars_Tx_count      PACKED; /* number of XOFF characters transmitted */
+        unsigned short XON_chars_Rx_count       PACKED; /* number of XON characters received */
+        unsigned short XOFF_chars_Rx_count      PACKED; /* number of XOFF characters received */
+        unsigned short Tx_halt_modem_low_count  PACKED; /* number of times Tx halted (modem line low) */
+        unsigned short Rx_halt_RTS_low_count    PACKED; /* number of times Rx halted by setting RTS low */
+        unsigned long reserved_handshaking_stat1 PACKED;/* reserved for later use */
+
+        /* break statistics */
+        unsigned short break_Tx_count   PACKED; /* number of break sequences transmitted */
+        unsigned short break_Rx_count   PACKED; /* number of break sequences received */
+        unsigned long reserved_break_stat1 PACKED;/* reserved for later use */
+
+        /* miscellaneous statistics */
+        unsigned long reserved_misc_stat1       PACKED; /* reserved for later use */
+        unsigned long reserved_misc_stat2       PACKED; /* reserved for later use */
+
+} ASY_OPERATIONAL_STATS_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *                      Constants for Data transmission
+ * --------------------------------------------------------------------------*/
+
+/* the Data block transmit status element configuration structure */
+typedef struct {
+        unsigned short number_Tx_status_elements PACKED;                /* number of transmit status elements */
+        unsigned long base_addr_Tx_status_elements PACKED;      /* base address of the transmit element list */
+        unsigned long next_Tx_status_element_to_use PACKED;     /* pointer to the next transmit element to be used */
+} ASY_TX_STATUS_EL_CFG_STRUCT;
+
+
+/* the Data block transmit status element structure */
+typedef struct {
+        unsigned char opp_flag PACKED;                                                          /* opp flag */
+        unsigned short data_length PACKED;                                              /* length of the block to be transmitted */
+        unsigned char reserved_1 PACKED;                                                        /* reserved for internal use */
+        unsigned long reserved_2 PACKED;                                                        /* reserved for internal use */
+        unsigned long reserved_3 PACKED;                                                        /* reserved for internal use */
+        unsigned long ptr_data_bfr PACKED;                                              /* pointer to the data area */
+} ASY_DATA_TX_STATUS_EL_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *                      Constants for Data reception
+ * --------------------------------------------------------------------------*/
+
+/* the Data block receive status element configuration structure */
+typedef struct {
+        unsigned short number_Rx_status_elements    PACKED;/* number of receive status elements */
+        unsigned long base_addr_Rx_status_elements  PACKED;/* base address of the receive element list */
+        unsigned long next_Rx_status_element_to_use PACKED;/* pointer to the next receive element to be used */
+        unsigned long base_addr_Rx_buffer       PACKED;/* base address of the receive data buffer */
+        unsigned long end_addr_Rx_buffer        PACKED;/* end address of the receive data buffer */
+} ASY_RX_STATUS_EL_CFG_STRUCT;
+
+/* the Data block receive status element structure */
+typedef struct {
+        unsigned char opp_flag          PACKED; /* opp flag */
+        unsigned short data_length      PACKED; /* length of the received data block */
+        unsigned char reserved_1        PACKED; /* reserved for internal use */
+        unsigned short time_stamp       PACKED; /* receive time stamp (HDLC_STREAMING_MODE) */
+        unsigned short data_buffered    PACKED; /* the number of data bytes still buffered */
+        unsigned long reserved_2        PACKED; /* reserved for internal use */
+        unsigned long ptr_data_bfr      PACKED; /* pointer to the data area */
+} ASY_DATA_RX_STATUS_EL_STRUCT;
+
+#endif
diff --git a/include/linux/sdla_chdlc.h b/include/linux/sdla_chdlc.h
new file mode 100644
index 000000000000..d2e35a299034
--- /dev/null
+++ b/include/linux/sdla_chdlc.h
@@ -0,0 +1,813 @@
+/*************************************************************************
+ sdla_chdlc.h   Sangoma Cisco HDLC firmware API definitions
+
+ Author:        Gideon Hack
+                Nenad Corbic <ncorbic@sangoma.com>      
+
+ Copyright:     (c) 1995-2000 Sangoma Technologies Inc.
+
+                This program is free software; you can redistribute it and/or
+                modify it under the term of the GNU General Public License
+                as published by the Free Software Foundation; either version
+                2 of the License, or (at your option) any later version.
+
+===========================================================================
+  Oct 04, 1999  Nenad Corbic    Updated API support
+  Jun 02, 1999  Gideon Hack     Changes for S514 usage.
+  Oct 28, 1998  Jaspreet Singh  Made changes for Dual Port CHDLC.
+  Jun 11, 1998  David Fong      Initial version.
+===========================================================================
+
+ Organization
+        - Compatibility notes
+        - Constants defining the shared memory control block (mailbox)
+        - Interface commands
+        - Return code from interface commands
+        - Constants for the commands (structures for casting data)
+        - UDP Management constants and structures
+
+*************************************************************************/
+
+#ifndef _SDLA_CHDLC_H
+#  define _SDLC_CHDLC_H
+
+/*------------------------------------------------------------------------
+   Notes:
+
+        All structres defined in this file are byte-aligned.  
+
+        Compiler        Platform
+        ------------------------
+        GNU C           Linux
+
+------------------------------------------------------------------------*/
+
+#ifndef PACKED
+#define PACKED __attribute__((packed))
+#endif  /* PACKED */
+
+
+/* ----------------------------------------------------------------------------
+ *        Constants defining the shared memory control block (mailbox)
+ * --------------------------------------------------------------------------*/
+
+#define PRI_BASE_ADDR_MB_STRUCT         0xE000  /* the base address of the mailbox structure on the adapter */
+#define SEC_BASE_ADDR_MB_STRUCT         0xE800  /* the base address of the mailbox structure on the adapter */
+#define SIZEOF_MB_DATA_BFR              2032    /* the size of the actual mailbox data area */
+#define NUMBER_MB_RESERVED_BYTES        0x0B    /* the number of reserved bytes in the mailbox header area */
+
+
+#define MIN_LGTH_CHDLC_DATA_CFG         300     /* min length of the CHDLC data field (for configuration purposes) */
+#define PRI_MAX_NO_DATA_BYTES_IN_FRAME  15354 /* PRIMARY - max length of the CHDLC data field */
+
+typedef struct {
+        unsigned char opp_flag PACKED;                  /* the opp flag */
+        unsigned char command PACKED;                   /* the user command */
+        unsigned short buffer_length PACKED;            /* the data length */
+        unsigned char return_code PACKED;               /* the return code */
+        unsigned char MB_reserved[NUMBER_MB_RESERVED_BYTES] PACKED;     /* reserved for later */
+        unsigned char data[SIZEOF_MB_DATA_BFR] PACKED;  /* the data area */
+} CHDLC_MAILBOX_STRUCT;
+
+typedef struct {
+        pid_t                   pid_num PACKED;
+        CHDLC_MAILBOX_STRUCT     cmdarea PACKED;
+
+} CMDBLOCK_STRUCT;
+
+
+
+
+/* ----------------------------------------------------------------------------
+ *                        Interface commands
+ * --------------------------------------------------------------------------*/
+
+/* global interface commands */
+#define READ_GLOBAL_EXCEPTION_CONDITION 0x01
+#define SET_GLOBAL_CONFIGURATION        0x02
+#define READ_GLOBAL_CONFIGURATION       0x03
+#define READ_GLOBAL_STATISTICS          0x04
+#define FLUSH_GLOBAL_STATISTICS         0x05
+#define SET_MODEM_STATUS                0x06    /* set status of DTR or RTS */
+#define READ_MODEM_STATUS               0x07    /* read status of CTS and DCD */
+#define READ_COMMS_ERROR_STATS          0x08    
+#define FLUSH_COMMS_ERROR_STATS         0x09
+#define SET_TRACE_CONFIGURATION         0x0A    /* set the line trace config */
+#define READ_TRACE_CONFIGURATION        0x0B    /* read the line trace config */
+#define READ_TRACE_STATISTICS           0x0C    /* read the trace statistics */
+#define FLUSH_TRACE_STATISTICS          0x0D    /* flush the trace statistics */
+#define FT1_MONITOR_STATUS_CTRL         0x1C    /* set the status of the S508/FT1 monitoring */
+#define SET_FT1_CONFIGURATION           0x18    /* set the FT1 configuration */
+#define READ_FT1_CONFIGURATION          0x19    /* read the FT1 configuration */
+#define TRANSMIT_ASYNC_DATA_TO_FT1      0x1A    /* output asynchronous data to the FT1 */
+#define RECEIVE_ASYNC_DATA_FROM_FT1     0x1B    /* receive asynchronous data from the FT1 */
+#define FT1_MONITOR_STATUS_CTRL         0x1C    /* set the status of the FT1 monitoring */
+
+#define READ_FT1_OPERATIONAL_STATS      0x1D    /* read the S508/FT1 operational statistics */
+#define SET_FT1_MODE                    0x1E    /* set the operational mode of the S508/FT1 module */
+
+/* CHDLC-level interface commands */
+#define READ_CHDLC_CODE_VERSION         0x20    
+#define READ_CHDLC_EXCEPTION_CONDITION  0x21    /* read exception condition from the adapter */
+#define SET_CHDLC_CONFIGURATION         0x22
+#define READ_CHDLC_CONFIGURATION        0x23
+#define ENABLE_CHDLC_COMMUNICATIONS     0x24
+#define DISABLE_CHDLC_COMMUNICATIONS    0x25
+#define READ_CHDLC_LINK_STATUS          0x26
+#define READ_CHDLC_OPERATIONAL_STATS    0x27
+#define FLUSH_CHDLC_OPERATIONAL_STATS   0x28
+#define SET_CHDLC_INTERRUPT_TRIGGERS    0x30    /* set application interrupt triggers */
+#define READ_CHDLC_INTERRUPT_TRIGGERS   0x31    /* read application interrupt trigger configuration */
+
+/* Special UDP drivers management commands */
+#define CPIPE_ENABLE_TRACING                            0x50
+#define CPIPE_DISABLE_TRACING                           0x51
+#define CPIPE_GET_TRACE_INFO                            0x52
+#define CPIPE_GET_IBA_DATA                              0x53
+#define CPIPE_FT1_READ_STATUS                           0x54
+#define CPIPE_DRIVER_STAT_IFSEND                        0x55
+#define CPIPE_DRIVER_STAT_INTR                          0x56
+#define CPIPE_DRIVER_STAT_GEN                           0x57
+#define CPIPE_FLUSH_DRIVER_STATS                        0x58
+#define CPIPE_ROUTER_UP_TIME                            0x59
+
+/* Driver specific commands for API */
+#define CHDLC_READ_TRACE_DATA           0xE4    /* read trace data */
+#define TRACE_ALL                       0x00
+#define TRACE_PROT                      0x01
+#define TRACE_DATA                      0x02
+
+#define DISCARD_RX_ERROR_FRAMES 0x0001
+
+/* ----------------------------------------------------------------------------
+ *                     Return codes from interface commands
+ * --------------------------------------------------------------------------*/
+
+#define COMMAND_OK                              0x00
+
+/* return codes from global interface commands */
+#define NO_GLOBAL_EXCEP_COND_TO_REPORT          0x01    /* there is no CHDLC exception condition to report */
+#define LGTH_GLOBAL_CFG_DATA_INVALID            0x01    /* the length of the passed global configuration data is invalid */
+#define LGTH_TRACE_CFG_DATA_INVALID             0x01    /* the length of the passed trace configuration data is invalid */
+#define IRQ_TIMEOUT_VALUE_INVALID               0x02    /* an invalid application IRQ timeout value was selected */
+#define TRACE_CONFIG_INVALID                    0x02    /* the passed line trace configuration is invalid */
+#define ADAPTER_OPERATING_FREQ_INVALID          0x03    /* an invalid adapter operating frequency was selected */
+#define TRC_DEAC_TMR_INVALID                    0x03    /* the trace deactivation timer is invalid */
+#define S508_FT1_ADPTR_NOT_PRESENT              0x0C    /* the S508/FT1 adapter is not present */
+#define INVALID_FT1_STATUS_SELECTION            0x0D    /* the S508/FT1 status selection is invalid */
+#define FT1_OP_STATS_NOT_ENABLED                0x0D    /* the FT1 operational statistics have not been enabled */
+#define FT1_OP_STATS_NOT_AVAILABLE              0x0E    /* the FT1 operational statistics are not currently available */
+#define S508_FT1_MODE_SELECTION_BUSY            0x0E    /* the S508/FT1 adapter is busy selecting the operational mode */
+
+/* return codes from command READ_GLOBAL_EXCEPTION_CONDITION */
+#define EXCEP_MODEM_STATUS_CHANGE               0x10            /* a modem status change occurred */
+#define EXCEP_TRC_DISABLED                      0x11            /* the trace has been disabled */
+#define EXCEP_IRQ_TIMEOUT                       0x12            /* IRQ timeout */
+
+/* return codes from CHDLC-level interface commands */
+#define NO_CHDLC_EXCEP_COND_TO_REPORT           0x21    /* there is no CHDLC exception condition to report */
+#define CHDLC_COMMS_DISABLED                    0x21    /* communications are not currently enabled */
+#define CHDLC_COMMS_ENABLED                     0x21    /* communications are currently enabled */
+#define DISABLE_CHDLC_COMMS_BEFORE_CFG          0x21    /* CHDLC communications must be disabled before setting the configuration */
+#define ENABLE_CHDLC_COMMS_BEFORE_CONN          0x21    /* communications must be enabled before using the CHDLC_CONNECT conmmand */
+#define CHDLC_CFG_BEFORE_COMMS_ENABLED          0x22    /* perform a SET_CHDLC_CONFIGURATION before enabling comms */
+#define LGTH_CHDLC_CFG_DATA_INVALID             0x22    /* the length of the passed CHDLC configuration data is invalid */
+#define LGTH_INT_TRIGGERS_DATA_INVALID          0x22    /* the length of the passed interrupt trigger data is invalid */
+#define INVALID_IRQ_SELECTED                    0x23    /* in invalid IRQ was selected in the SET_CHDLC_INTERRUPT_TRIGGERS */
+#define INVALID_CHDLC_CFG_DATA                  0x23    /* the passed CHDLC configuration data is invalid */
+#define IRQ_TMR_VALUE_INVALID                   0x24    /* an invalid application IRQ timer value was selected */
+#define LARGER_PERCENT_TX_BFR_REQUIRED          0x24    /* a larger Tx buffer percentage is required */
+#define LARGER_PERCENT_RX_BFR_REQUIRED          0x25    /* a larger Rx buffer percentage is required */
+#define S514_BOTH_PORTS_SAME_CLK_MODE           0x26    /* S514 - both ports must have same clock mode */
+#define INVALID_CMND_HDLC_STREAM_MODE           0x4E    /* the CHDLC interface command is invalid for HDLC streaming mode */
+#define INVALID_CHDLC_COMMAND                   0x4F    /* the defined CHDLC interface command is invalid */
+
+/* return codes from command READ_CHDLC_EXCEPTION_CONDITION */
+#define EXCEP_LINK_ACTIVE                       0x30    /* the CHDLC link has become active */
+#define EXCEP_LINK_INACTIVE_MODEM               0x31    /* the CHDLC link has become inactive (modem status) */
+#define EXCEP_LINK_INACTIVE_KPALV               0x32    /* the CHDLC link has become inactive (keepalive status) */
+#define EXCEP_IP_ADDRESS_DISCOVERED             0x33    /* the IP address has been discovered */
+#define EXCEP_LOOPBACK_CONDITION                0x34    /* a loopback condition has occurred */
+
+
+/* return code from command CHDLC_SEND_WAIT and CHDLC_SEND_NO_WAIT */
+#define LINK_DISCONNECTED                       0x21
+#define NO_TX_BFRS_AVAIL                        0x24
+
+
+/* ----------------------------------------------------------------------------
+ * Constants for the SET_GLOBAL_CONFIGURATION/READ_GLOBAL_CONFIGURATION commands
+ * --------------------------------------------------------------------------*/
+
+/* the global configuration structure */
+typedef struct {
+        unsigned short adapter_config_options PACKED;   /* adapter config options */
+        unsigned short app_IRQ_timeout PACKED;          /* application IRQ timeout */
+        unsigned long adapter_operating_frequency PACKED;       /* adapter operating frequency */
+} GLOBAL_CONFIGURATION_STRUCT;
+
+/* settings for the 'app_IRQ_timeout' */
+#define MAX_APP_IRQ_TIMEOUT_VALUE       5000    /* the maximum permitted IRQ timeout */
+
+
+
+/* ----------------------------------------------------------------------------
+ *             Constants for the READ_GLOBAL_STATISTICS command
+ * --------------------------------------------------------------------------*/
+
+/* the global statistics structure */
+typedef struct {
+        unsigned short app_IRQ_timeout_count PACKED;
+} GLOBAL_STATS_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *             Constants for the READ_COMMS_ERROR_STATS command
+ * --------------------------------------------------------------------------*/
+
+/* the communications error statistics structure */
+typedef struct {
+        unsigned short Rx_overrun_err_count PACKED;
+        unsigned short CRC_err_count PACKED;    /* receiver CRC error count */
+        unsigned short Rx_abort_count PACKED;   /* abort frames recvd count */
+        unsigned short Rx_dis_pri_bfrs_full_count PACKED;/* receiver disabled */
+        unsigned short comms_err_stat_reserved_1 PACKED;/* reserved for later */
+        unsigned short sec_Tx_abort_msd_Tx_int_count PACKED; /* secondary - abort frames transmitted count (missed Tx interrupt) */
+        unsigned short missed_Tx_und_int_count PACKED;  /* missed tx underrun interrupt count */
+        unsigned short sec_Tx_abort_count PACKED;   /*secondary-abort frames tx count */
+        unsigned short DCD_state_change_count PACKED; /* DCD state change */
+        unsigned short CTS_state_change_count PACKED; /* CTS state change */
+} COMMS_ERROR_STATS_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *                  Constants used for line tracing
+ * --------------------------------------------------------------------------*/
+
+/* the trace configuration structure (SET_TRACE_CONFIGURATION/READ_TRACE_CONFIGURATION commands) */
+typedef struct {
+        unsigned char trace_config PACKED;              /* trace configuration */
+        unsigned short trace_deactivation_timer PACKED; /* trace deactivation timer */
+        unsigned long ptr_trace_stat_el_cfg_struct PACKED;      /* a pointer to the line trace element configuration structure */
+} LINE_TRACE_CONFIG_STRUCT;
+
+/* 'trace_config' bit settings */
+#define TRACE_INACTIVE          0x00    /* trace is inactive */
+#define TRACE_ACTIVE            0x01    /* trace is active */
+#define TRACE_DELAY_MODE        0x04    /* operate the trace in delay mode */
+#define TRACE_DATA_FRAMES       0x08    /* trace Data frames */
+#define TRACE_SLARP_FRAMES      0x10    /* trace SLARP frames */
+#define TRACE_CDP_FRAMES        0x20    /* trace CDP frames */
+
+/* the line trace status element configuration structure */
+typedef struct {
+        unsigned short number_trace_status_elements PACKED;     /* number of line trace elements */
+        unsigned long base_addr_trace_status_elements PACKED;   /* base address of the trace element list */
+        unsigned long next_trace_element_to_use PACKED; /* pointer to the next trace element to be used */
+        unsigned long base_addr_trace_buffer PACKED;            /* base address of the trace data buffer */
+        unsigned long end_addr_trace_buffer PACKED;             /* end address of the trace data buffer */
+} TRACE_STATUS_EL_CFG_STRUCT;
+
+/* the line trace status element structure */
+typedef struct {
+        unsigned char opp_flag PACKED;                  /* opp flag */
+        unsigned short trace_length PACKED;             /* trace length */
+        unsigned char trace_type PACKED;                /* trace type */
+        unsigned short trace_time_stamp PACKED; /* time stamp */
+        unsigned short trace_reserved_1 PACKED; /* reserved for later use */
+        unsigned long trace_reserved_2 PACKED;          /* reserved for later use */
+        unsigned long ptr_data_bfr PACKED;              /* ptr to the trace data buffer */
+} TRACE_STATUS_ELEMENT_STRUCT;
+
+/* "trace_type" bit settings */
+#define TRACE_INCOMING                  0x00
+#define TRACE_OUTGOINGING               0x01
+#define TRACE_INCOMING_ABORTED          0x10
+#define TRACE_INCOMING_CRC_ERROR        0x20
+#define TRACE_INCOMING_OVERRUN_ERROR    0x40
+
+
+
+/* the line trace statistics structure */
+typedef struct {
+        unsigned long frames_traced_count PACKED;       /* number of frames traced */
+        unsigned long trc_frms_not_recorded_count PACKED;       /* number of trace frames discarded */
+} LINE_TRACE_STATS_STRUCT;
+
+
+/* ----------------------------------------------------------------------------
+ *               Constants for the FT1_MONITOR_STATUS_CTRL command
+ * --------------------------------------------------------------------------*/
+
+#define DISABLE_FT1_STATUS_STATISTICS   0x00    /* disable the FT1 status and statistics monitoring */
+#define ENABLE_READ_FT1_STATUS          0x01    /* read the FT1 operational status */
+#define ENABLE_READ_FT1_OP_STATS        0x02    /* read the FT1 operational statistics */
+#define FLUSH_FT1_OP_STATS              0x04    /* flush the FT1 operational statistics */
+
+
+
+
+/* ----------------------------------------------------------------------------
+ *               Constants for the SET_CHDLC_CONFIGURATION command
+ * --------------------------------------------------------------------------*/
+
+/* the CHDLC configuration structure */
+typedef struct {
+        unsigned long baud_rate PACKED;         /* the baud rate */     
+        unsigned short line_config_options PACKED;      /* line configuration options */
+        unsigned short modem_config_options PACKED;     /* modem configration options */
+        unsigned short modem_status_timer PACKED;       /* timer for monitoring modem status changes */
+        unsigned short CHDLC_API_options PACKED;        /* CHDLC API options */
+        unsigned short CHDLC_protocol_options PACKED;   /* CHDLC protocol options */
+        unsigned short percent_data_buffer_for_Tx PACKED;       /* percentage data buffering used for Tx */
+        unsigned short CHDLC_statistics_options PACKED; /* CHDLC operational statistics options */
+        unsigned short max_CHDLC_data_field_length PACKED;      /* the maximum length of the CHDLC Data field */
+        unsigned short transmit_keepalive_timer PACKED;         /* the transmit keepalive timer */
+        unsigned short receive_keepalive_timer PACKED;          /* the receive keepalive timer */
+        unsigned short keepalive_error_tolerance PACKED;        /* the receive keepalive error tolerance */
+        unsigned short SLARP_request_timer PACKED;              /* the SLARP request timer */
+        unsigned long IP_address PACKED;                        /* the IP address */
+        unsigned long IP_netmask PACKED;                        /* the IP netmask */
+        unsigned long ptr_shared_mem_info_struct PACKED;        /* a pointer to the shared memory area information structure */
+        unsigned long ptr_CHDLC_Tx_stat_el_cfg_struct PACKED;   /* a pointer to the transmit status element configuration structure */
+        unsigned long ptr_CHDLC_Rx_stat_el_cfg_struct PACKED;   /* a pointer to the receive status element configuration structure */
+} CHDLC_CONFIGURATION_STRUCT;
+
+/* settings for the 'line_config_options' */
+#define INTERFACE_LEVEL_V35                                     0x0000 /* V.35 interface level */
+#define INTERFACE_LEVEL_RS232                                   0x0001 /* RS-232 interface level */
+
+/* settings for the 'modem_config_options' */
+
+#define DONT_RAISE_DTR_RTS_ON_EN_COMMS          0x0001
+/* don't automatically raise DTR and RTS when performing an
+   ENABLE_CHDLC_COMMUNICATIONS command */
+
+#define DONT_REPORT_CHG_IN_MODEM_STAT           0x0002
+/* don't report changes in modem status to the application */
+
+
+/* bit settings for the 'CHDLC_protocol_options' byte */
+
+#define IGNORE_DCD_FOR_LINK_STAT                0x0001
+/* ignore DCD in determining the CHDLC link status */
+
+#define IGNORE_CTS_FOR_LINK_STAT                0x0002
+/* ignore CTS in determining the CHDLC link status */
+
+#define IGNORE_KPALV_FOR_LINK_STAT              0x0004
+/* ignore keepalive frames in determining the CHDLC link status */ 
+
+#define SINGLE_TX_BUFFER                        0x4000 
+/* configure a single transmit buffer */
+
+#define HDLC_STREAMING_MODE                     0x8000
+
+/*   settings for the 'CHDLC_statistics_options' */
+
+#define CHDLC_TX_DATA_BYTE_COUNT_STAT           0x0001
+/* record the number of Data bytes transmitted */
+
+#define CHDLC_RX_DATA_BYTE_COUNT_STAT           0x0002
+/* record the number of Data bytes received */
+
+#define CHDLC_TX_THROUGHPUT_STAT                0x0004
+/* compute the Data frame transmit throughput */
+
+#define CHDLC_RX_THROUGHPUT_STAT                0x0008
+/* compute the Data frame receive throughput */
+
+
+/* permitted minimum and maximum values for setting the CHDLC configuration */
+#define PRI_MAX_BAUD_RATE_S508  2666666 /* PRIMARY   - maximum baud rate (S508) */
+#define SEC_MAX_BAUD_RATE_S508  258064  /* SECONDARY - maximum baud rate (S508) */
+#define PRI_MAX_BAUD_RATE_S514  2750000 /* PRIMARY   - maximum baud rate (S508) */
+#define SEC_MAX_BAUD_RATE_S514  515625  /* SECONDARY - maximum baud rate (S508) */
+ 
+#define MIN_MODEM_TIMER 0                       /* minimum modem status timer */
+#define MAX_MODEM_TIMER 5000                    /* maximum modem status timer */
+
+#define SEC_MAX_NO_DATA_BYTES_IN_FRAME  2048 /* SECONDARY - max length of the CHDLC data field */
+
+#define MIN_Tx_KPALV_TIMER      0         /* minimum transmit keepalive timer */
+#define MAX_Tx_KPALV_TIMER      60000     /* maximum transmit keepalive timer */
+#define DEFAULT_Tx_KPALV_TIMER  10000     /* default transmit keepalive timer */
+
+#define MIN_Rx_KPALV_TIMER      10        /* minimum receive keepalive timer */
+#define MAX_Rx_KPALV_TIMER      60000     /* maximum receive keepalive timer */
+#define DEFAULT_Rx_KPALV_TIMER  10000     /* default receive keepalive timer */
+
+#define MIN_KPALV_ERR_TOL       1         /* min kpalv error tolerance count */
+#define MAX_KPALV_ERR_TOL       20        /* max kpalv error tolerance count */
+#define DEFAULT_KPALV_ERR_TOL   3         /* default value */
+
+#define MIN_SLARP_REQ_TIMER     0         /* min transmit SLARP Request timer */
+#define MAX_SLARP_REQ_TIMER     60000     /* max transmit SLARP Request timer */
+#define DEFAULT_SLARP_REQ_TIMER 0         /* default value -- no SLARP */
+
+
+
+/* ----------------------------------------------------------------------------
+ *             Constants for the READ_CHDLC_LINK_STATUS command
+ * --------------------------------------------------------------------------*/
+
+/* the CHDLC status structure */
+typedef struct {
+        unsigned char CHDLC_link_status PACKED; /* CHDLC link status */
+        unsigned char no_Data_frms_for_app PACKED;      /* number of Data frames available for the application */
+        unsigned char receiver_status PACKED;   /* enabled/disabled */
+        unsigned char SLARP_state PACKED;       /* internal SLARP state */
+} CHDLC_LINK_STATUS_STRUCT;
+
+/* settings for the 'CHDLC_link_status' variable */
+#define CHDLC_LINK_INACTIVE             0x00    /* the CHDLC link is inactive */
+#define CHDLC_LINK_ACTIVE               0x01    /* the CHDLC link is active */
+
+
+
+/* ----------------------------------------------------------------------------
+ *           Constants for the READ_CHDLC_OPERATIONAL_STATS command
+ * --------------------------------------------------------------------------*/
+
+/* the CHDLC operational statistics structure */
+typedef struct {
+
+        /* Data frame transmission statistics */
+        unsigned long Data_frames_Tx_count PACKED;      /* # of frames transmitted */
+        unsigned long Data_bytes_Tx_count PACKED;       /* # of bytes transmitted */
+        unsigned long Data_Tx_throughput PACKED;        /* transmit throughput */
+        unsigned long no_ms_for_Data_Tx_thruput_comp PACKED;    /* millisecond time used for the Tx throughput computation */
+        unsigned long Tx_Data_discard_lgth_err_count PACKED;    /* number of Data frames discarded (length error) */
+        unsigned long reserved_Data_frm_Tx_stat1 PACKED;        /* reserved for later */
+        unsigned long reserved_Data_frm_Tx_stat2 PACKED;        /* reserved for later */
+        unsigned long reserved_Data_frm_Tx_stat3 PACKED;        /* reserved for later */
+
+        /* Data frame reception statistics */
+        unsigned long Data_frames_Rx_count PACKED;      /* number of frames received */
+        unsigned long Data_bytes_Rx_count PACKED;       /* number of bytes received */
+        unsigned long Data_Rx_throughput PACKED;        /* receive throughput */
+        unsigned long no_ms_for_Data_Rx_thruput_comp PACKED;    /* millisecond time used for the Rx throughput computation */
+        unsigned long Rx_Data_discard_short_count PACKED;       /* received Data frames discarded (too short) */
+        unsigned long Rx_Data_discard_long_count PACKED;        /* received Data frames discarded (too long) */
+        unsigned long Rx_Data_discard_inactive_count PACKED;    /* received Data frames discarded (link inactive) */
+        unsigned long reserved_Data_frm_Rx_stat1 PACKED;        /* reserved for later */
+
+        /* SLARP frame transmission/reception statistics */
+        unsigned long CHDLC_SLARP_REQ_Tx_count PACKED;          /* number of SLARP Request frames transmitted */
+        unsigned long CHDLC_SLARP_REQ_Rx_count PACKED;          /* number of SLARP Request frames received */
+        unsigned long CHDLC_SLARP_REPLY_Tx_count PACKED;        /* number of SLARP Reply frames transmitted */
+        unsigned long CHDLC_SLARP_REPLY_Rx_count PACKED;        /* number of SLARP Reply frames received */
+        unsigned long CHDLC_SLARP_KPALV_Tx_count PACKED;        /* number of SLARP keepalive frames transmitted */
+        unsigned long CHDLC_SLARP_KPALV_Rx_count PACKED;        /* number of SLARP keepalive frames received */
+        unsigned long reserved_SLARP_stat1 PACKED;              /* reserved for later */
+        unsigned long reserved_SLARP_stat2 PACKED;              /* reserved for later */
+
+        /* CDP frame transmission/reception statistics */
+        unsigned long CHDLC_CDP_Tx_count PACKED;                /* number of CDP frames transmitted */
+        unsigned long CHDLC_CDP_Rx_count PACKED;                /* number of CDP frames received */
+        unsigned long reserved_CDP_stat1 PACKED;                /* reserved for later */
+        unsigned long reserved_CDP_stat2 PACKED;                /* reserved for later */
+        unsigned long reserved_CDP_stat3 PACKED;                /* reserved for later */
+        unsigned long reserved_CDP_stat4 PACKED;                /* reserved for later */
+        unsigned long reserved_CDP_stat5 PACKED;                /* reserved for later */
+        unsigned long reserved_CDP_stat6 PACKED;                /* reserved for later */
+
+        /* Incoming frames with a format error statistics */
+        unsigned short Rx_frm_incomp_CHDLC_hdr_count PACKED;    /* frames received of with incomplete Cisco HDLC header */
+        unsigned short Rx_frms_too_long_count PACKED;           /* frames received of excessive length count */
+        unsigned short Rx_invalid_CHDLC_addr_count PACKED;      /* frames received with an invalid CHDLC address count */
+        unsigned short Rx_invalid_CHDLC_ctrl_count PACKED;      /* frames received with an invalid CHDLC control field count */
+        unsigned short Rx_invalid_CHDLC_type_count PACKED;      /* frames received of an invalid CHDLC frame type count */
+        unsigned short Rx_SLARP_invalid_code_count PACKED;      /* SLARP frame received with an invalid packet code */
+        unsigned short Rx_SLARP_Reply_bad_IP_addr PACKED;       /* SLARP Reply received - bad IP address */
+        unsigned short Rx_SLARP_Reply_bad_netmask PACKED;       /* SLARP Reply received - bad netmask */
+        unsigned long reserved_frm_format_err1 PACKED;          /* reserved for later */
+        unsigned long reserved_frm_format_err2 PACKED;          /* reserved for later */
+        unsigned long reserved_frm_format_err3 PACKED;          /* reserved for later */
+        unsigned long reserved_frm_format_err4 PACKED;          /* reserved for later */
+
+        /* CHDLC timeout/retry statistics */
+        unsigned short SLARP_Rx_keepalive_TO_count PACKED;      /* timeout count for incoming SLARP frames */
+        unsigned short SLARP_Request_TO_count PACKED;           /* timeout count for SLARP Request frames */
+        unsigned long To_retry_reserved_stat1 PACKED;           /* reserved for later */
+        unsigned long To_retry_reserved_stat2 PACKED;           /* reserved for later */
+        unsigned long To_retry_reserved_stat3 PACKED;           /* reserved for later */
+
+        /* CHDLC link active/inactive and loopback statistics */
+        unsigned short link_active_count PACKED;                /* number of times that the link went active */
+        unsigned short link_inactive_modem_count PACKED;        /* number of times that the link went inactive (modem failure) */
+        unsigned short link_inactive_keepalive_count PACKED;    /* number of times that the link went inactive (keepalive failure) */
+        unsigned short link_looped_count PACKED;                /* link looped count */
+        unsigned long link_status_reserved_stat1 PACKED;        /* reserved for later use */
+        unsigned long link_status_reserved_stat2 PACKED;        /* reserved for later use */
+
+        /* miscellaneous statistics */
+        unsigned long reserved_misc_stat1 PACKED;               /* reserved for later */
+        unsigned long reserved_misc_stat2 PACKED;               /* reserved for later */
+        unsigned long reserved_misc_stat3 PACKED;               /* reserved for later */
+        unsigned long reserved_misc_stat4 PACKED;               /* reserved for later */
+
+} CHDLC_OPERATIONAL_STATS_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *                 Constants for using application interrupts
+ * --------------------------------------------------------------------------*/
+
+/* the structure used for the SET_CHDLC_INTERRUPT_TRIGGERS/READ_CHDLC_INTERRUPT_TRIGGERS command */
+typedef struct {
+        unsigned char CHDLC_interrupt_triggers PACKED;  /* CHDLC interrupt trigger configuration */
+        unsigned char IRQ PACKED;                       /* IRQ to be used */
+        unsigned short interrupt_timer PACKED;          /* interrupt timer */
+        unsigned short misc_interrupt_bits PACKED;      /* miscellaneous bits */
+} CHDLC_INT_TRIGGERS_STRUCT;
+
+/* 'CHDLC_interrupt_triggers' bit settings */
+#define APP_INT_ON_RX_FRAME             0x01    /* interrupt on Data frame reception */
+#define APP_INT_ON_TX_FRAME             0x02    /* interrupt when an Data frame may be transmitted */
+#define APP_INT_ON_COMMAND_COMPLETE     0x04    /* interrupt when an interface command is complete */
+#define APP_INT_ON_TIMER                0x08    /* interrupt on a defined millisecond timeout */
+#define APP_INT_ON_GLOBAL_EXCEP_COND    0x10    /* interrupt on a global exception condition */
+#define APP_INT_ON_CHDLC_EXCEP_COND     0x20    /* interrupt on an CHDLC exception condition */
+#define APP_INT_ON_TRACE_DATA_AVAIL     0x80    /* interrupt when trace data is available */
+
+/* interrupt types indicated at 'interrupt_type' byte of the INTERRUPT_INFORMATION_STRUCT */
+#define NO_APP_INTS_PEND                0x00    /* no interrups are pending */
+#define RX_APP_INT_PEND                 0x01    /* a receive interrupt is pending */
+#define TX_APP_INT_PEND                 0x02    /* a transmit interrupt is pending */
+#define COMMAND_COMPLETE_APP_INT_PEND   0x04    /* a 'command complete' interrupt is pending */
+#define TIMER_APP_INT_PEND              0x08    /* a timer interrupt is pending */
+#define GLOBAL_EXCEP_COND_APP_INT_PEND  0x10    /* a global exception condition interrupt is pending */
+#define CHDLC_EXCEP_COND_APP_INT_PEND   0x20    /* an CHDLC exception condition interrupt is pending */
+#define TRACE_DATA_AVAIL_APP_INT_PEND   0x80    /* a trace data available interrupt is pending */
+
+
+/* modem status changes */
+#define DCD_HIGH                        0x08
+#define CTS_HIGH                        0x20
+
+
+/* ----------------------------------------------------------------------------
+ *                   Constants for Data frame transmission
+ * --------------------------------------------------------------------------*/
+
+/* the Data frame transmit status element configuration structure */
+typedef struct {
+        unsigned short number_Tx_status_elements PACKED;        /* number of transmit status elements */
+        unsigned long base_addr_Tx_status_elements PACKED;      /* base address of the transmit element list */
+        unsigned long next_Tx_status_element_to_use PACKED;     /* pointer to the next transmit element to be used */
+} CHDLC_TX_STATUS_EL_CFG_STRUCT;
+
+/* the Data frame transmit status element structure */
+typedef struct {
+        unsigned char opp_flag PACKED;          /* opp flag */
+        unsigned short frame_length PACKED;     /* length of the frame to be transmitted */
+        unsigned char reserved_1 PACKED;        /* reserved for internal use */
+        unsigned long reserved_2 PACKED;        /* reserved for internal use */
+        unsigned long reserved_3 PACKED;        /* reserved for internal use */
+        unsigned long ptr_data_bfr PACKED;      /* pointer to the data area */
+} CHDLC_DATA_TX_STATUS_EL_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *                   Constants for Data frame reception
+ * --------------------------------------------------------------------------*/
+
+/* the Data frame receive status element configuration structure */
+typedef struct {
+        unsigned short number_Rx_status_elements PACKED;        /* number of receive status elements */
+        unsigned long base_addr_Rx_status_elements PACKED;      /* base address of the receive element list */
+        unsigned long next_Rx_status_element_to_use PACKED;     /* pointer to the next receive element to be used */
+        unsigned long base_addr_Rx_buffer PACKED;               /* base address of the receive data buffer */
+        unsigned long end_addr_Rx_buffer PACKED;                /* end address of the receive data buffer */
+} CHDLC_RX_STATUS_EL_CFG_STRUCT;
+
+/* the Data frame receive status element structure */
+typedef struct {
+        unsigned char opp_flag PACKED;          /* opp flag */
+        unsigned short frame_length PACKED;   /* length of the received frame */
+        unsigned char error_flag PACKED; /* frame errors (HDLC_STREAMING_MODE)*/
+        unsigned short time_stamp PACKED; /* receive time stamp (HDLC_STREAMING_MODE) */
+        unsigned long reserved_1 PACKED;        /* reserved for internal use */
+        unsigned short reserved_2 PACKED;       /* reserved for internal use */
+        unsigned long ptr_data_bfr PACKED;      /* pointer to the data area */
+} CHDLC_DATA_RX_STATUS_EL_STRUCT;
+
+
+
+/* ----------------------------------------------------------------------------
+ *         Constants defining the shared memory information area
+ * --------------------------------------------------------------------------*/
+
+/* the global information structure */
+typedef struct {
+        unsigned char global_status PACKED;             /* global status */
+        unsigned char modem_status PACKED;              /* current modem status */
+        unsigned char global_excep_conditions PACKED;   /* global exception conditions */
+        unsigned char glob_info_reserved[5] PACKED;     /* reserved */
+        unsigned char codename[4] PACKED;               /* Firmware name */
+        unsigned char codeversion[4] PACKED;            /* Firmware version */
+} GLOBAL_INFORMATION_STRUCT;
+
+/* the CHDLC information structure */
+typedef struct {
+        unsigned char CHDLC_status PACKED;              /* CHDLC status */
+        unsigned char CHDLC_excep_conditions PACKED;    /* CHDLC exception conditions */
+        unsigned char CHDLC_info_reserved[14] PACKED;   /* reserved */
+} CHDLC_INFORMATION_STRUCT;
+
+/* the interrupt information structure */
+typedef struct {
+        unsigned char interrupt_type PACKED;            /* type of interrupt triggered */
+        unsigned char interrupt_permission PACKED;      /* interrupt permission mask */
+        unsigned char int_info_reserved[14] PACKED;     /* reserved */
+} INTERRUPT_INFORMATION_STRUCT;
+
+/* the S508/FT1 information structure */
+typedef struct {
+        unsigned char parallel_port_A_input PACKED;     /* input - parallel port A */
+        unsigned char parallel_port_B_input PACKED;     /* input - parallel port B */
+        unsigned char FT1_info_reserved[14] PACKED;     /* reserved */
+} FT1_INFORMATION_STRUCT;
+
+/* the shared memory area information structure */
+typedef struct {
+        GLOBAL_INFORMATION_STRUCT global_info_struct PACKED;            /* the global information structure */
+        CHDLC_INFORMATION_STRUCT CHDLC_info_struct PACKED;              /* the CHDLC information structure */
+        INTERRUPT_INFORMATION_STRUCT interrupt_info_struct PACKED;      /* the interrupt information structure */
+        FT1_INFORMATION_STRUCT FT1_info_struct PACKED;                  /* the S508/FT1 information structure */
+} SHARED_MEMORY_INFO_STRUCT;
+
+/* ----------------------------------------------------------------------------
+ *        UDP Management constants and structures 
+ * --------------------------------------------------------------------------*/
+
+/* The embedded control block for UDP mgmt 
+   This is essentially a mailbox structure, without the large data field */
+
+typedef struct {
+        unsigned char  opp_flag PACKED;                  /* the opp flag */
+        unsigned char  command PACKED;                   /* the user command */
+        unsigned short buffer_length PACKED;             /* the data length */
+        unsigned char  return_code PACKED;               /* the return code */
+        unsigned char  MB_reserved[NUMBER_MB_RESERVED_BYTES] PACKED;    /* reserved for later */
+} cblock_t;
+
+
+/* UDP management packet layout (data area of ip packet) */
+/*
+typedef struct {
+        unsigned char           signature[8]    PACKED;
+        unsigned char           request_reply   PACKED;
+        unsigned char           id              PACKED;
+        unsigned char           reserved[6]     PACKED;
+        cblock_t                cblock          PACKED;
+        unsigned char           num_frames      PACKED;
+        unsigned char           ismoredata      PACKED;
+        unsigned char           data[SIZEOF_MB_DATA_BFR]        PACKED;
+} udp_management_packet_t;
+
+*/
+
+typedef struct {
+        unsigned char           num_frames      PACKED;
+        unsigned char           ismoredata      PACKED;
+} trace_info_t;
+
+typedef struct {
+        ip_pkt_t                ip_pkt          PACKED;
+        udp_pkt_t               udp_pkt         PACKED;
+        wp_mgmt_t               wp_mgmt         PACKED;
+        cblock_t                cblock          PACKED;
+        trace_info_t            trace_info      PACKED;
+        unsigned char           data[SIZEOF_MB_DATA_BFR]      PACKED;
+} chdlc_udp_pkt_t;
+
+typedef struct ft1_exec_cmd{
+        unsigned char  command PACKED;                   /* the user command */
+        unsigned short buffer_length PACKED;             /* the data length */
+        unsigned char  return_code PACKED;               /* the return code */
+        unsigned char  MB_reserved[NUMBER_MB_RESERVED_BYTES] PACKED;
+} ft1_exec_cmd_t;
+
+typedef struct {
+        unsigned char  opp_flag                         PACKED;
+        ft1_exec_cmd_t cmd                              PACKED;
+        unsigned char  data[SIZEOF_MB_DATA_BFR]         PACKED;
+} ft1_exec_t;
+
+#define UDPMGMT_SIGNATURE       "CTPIPEAB"
+
+
+/* UDP/IP packet (for UDP management) layout */
+/*
+typedef struct {
+        unsigned char   reserved[2]     PACKED;
+        unsigned short  ip_length       PACKED;
+        unsigned char   reserved2[4]    PACKED;
+        unsigned char   ip_ttl          PACKED;
+        unsigned char   ip_protocol     PACKED;
+        unsigned short  ip_checksum     PACKED;
+        unsigned long   ip_src_address  PACKED;
+        unsigned long   ip_dst_address  PACKED;
+        unsigned short  udp_src_port    PACKED;
+        unsigned short  udp_dst_port    PACKED;
+        unsigned short  udp_length      PACKED;
+        unsigned short  udp_checksum    PACKED;
+        udp_management_packet_t um_packet PACKED;
+} ip_packet_t;
+*/
+
+/* valid ip_protocol for UDP management */
+#define UDPMGMT_UDP_PROTOCOL 0x11
+
+
+typedef struct {
+        unsigned char   status          PACKED;
+        unsigned char   data_avail      PACKED;
+        unsigned short  real_length     PACKED;
+        unsigned short  time_stamp      PACKED;
+        unsigned char   data[1]         PACKED;
+} trace_pkt_t;
+
+typedef struct {
+        unsigned char   error_flag      PACKED;
+        unsigned short  time_stamp      PACKED;
+        unsigned char   reserved[13]    PACKED;
+} api_rx_hdr_t;
+
+typedef struct {
+        api_rx_hdr_t    api_rx_hdr      PACKED;
+        void *          data            PACKED;
+} api_rx_element_t;
+
+typedef struct {
+        unsigned char   attr            PACKED;
+        unsigned char   reserved[15]    PACKED;
+} api_tx_hdr_t;
+
+typedef struct {
+        api_tx_hdr_t    api_tx_hdr      PACKED;
+        void *          data            PACKED;
+} api_tx_element_t;
+
+/* ----------------------------------------------------------------------------
+ *   Constants for the SET_FT1_CONFIGURATION/READ_FT1_CONFIGURATION command
+ * --------------------------------------------------------------------------*/
+
+/* the FT1 configuration structure */
+typedef struct {
+        unsigned short framing_mode;
+        unsigned short encoding_mode;
+        unsigned short line_build_out;
+        unsigned short channel_base;
+        unsigned short baud_rate_kbps;                                  /* the baud rate (in kbps) */   
+        unsigned short clock_mode;
+} ft1_config_t;
+
+/* settings for the 'framing_mode' */
+#define ESF_FRAMING     0x00    /* ESF framing */
+#define D4_FRAMING      0x01    /* D4 framing */
+
+/* settings for the 'encoding_mode' */
+#define B8ZS_ENCODING   0x00    /* B8ZS encoding */
+#define AMI_ENCODING    0x01    /* AMI encoding */
+
+/* settings for the 'line_build_out' */
+#define LN_BLD_CSU_0dB_DSX1_0_to_133    0x00    /* set build out to CSU (0db) or DSX-1 (0-133ft) */
+#define LN_BLD_DSX1_133_to_266          0x01    /* set build out DSX-1 (133-266ft) */
+#define LN_BLD_DSX1_266_to_399          0x02    /* set build out DSX-1 (266-399ft) */
+#define LN_BLD_DSX1_399_to_533          0x03    /* set build out DSX-1 (399-533ft) */
+#define LN_BLD_DSX1_533_to_655          0x04    /* set build out DSX-1 (533-655ft) */
+#define LN_BLD_CSU_NEG_7dB              0x05    /* set build out to CSU (-7.5db) */
+#define LN_BLD_CSU_NEG_15dB             0x06    /* set build out to CSU (-15db) */
+#define LN_BLD_CSU_NEG_22dB             0x07    /* set build out to CSU (-22.5db) */
+
+/* settings for the 'channel_base' */
+#define MIN_CHANNEL_BASE_VALUE          1               /* the minimum permitted channel base value */
+#define MAX_CHANNEL_BASE_VALUE          24              /* the maximum permitted channel base value */
+
+/* settings for the 'baud_rate_kbps' */
+#define MIN_BAUD_RATE_KBPS              0               /* the minimum permitted baud rate (kbps) */
+#define MAX_BAUD_RATE_KBPS              1536    /* the maximum permitted baud rate (kbps) */
+#define BAUD_RATE_FT1_AUTO_CONFIG       0xFFFF /* the baud rate used to trigger an automatic FT1 configuration */
+
+/* settings for the 'clock_mode' */
+#define CLOCK_MODE_NORMAL               0x00    /* clock mode set to normal (slave) */
+#define CLOCK_MODE_MASTER               0x01    /* clock mode set to master */
+
+
+#define BAUD_RATE_FT1_AUTO_CONFIG       0xFFFF
+#define AUTO_FT1_CONFIG_NOT_COMPLETE    0x08
+#define AUTO_FT1_CFG_FAIL_OP_MODE       0x0C
+#define AUTO_FT1_CFG_FAIL_INVALID_LINE  0x0D
+
+ 
+#ifdef          _MSC_
+#  pragma       pack()
+#endif
+#endif  /* _SDLA_CHDLC_H */
diff --git a/include/linux/sdla_fr.h b/include/linux/sdla_fr.h
new file mode 100644
index 000000000000..cdfa77fcb06b
--- /dev/null
+++ b/include/linux/sdla_fr.h
@@ -0,0 +1,638 @@
+/*****************************************************************************
+* sdla_fr.h     Sangoma frame relay firmware API definitions.
+*
+* Author:       Gideon Hack     
+*               Nenad Corbic <ncorbic@sangoma.com>      
+*
+* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Oct 04, 1999  Gideon Hack     Updated API structures
+* Jun 02, 1999  Gideon Hack     Modifications for S514 support
+* Oct 12, 1997  Jaspreet Singh  Added FR_READ_DLCI_IB_MAPPING
+* Jul 21, 1997  Jaspreet Singh  Changed FRRES_TOO_LONG and FRRES_TOO_MANY to 
+*                               0x05 and 0x06 respectively.
+* Dec 23, 1996  Gene Kozin      v2.0
+* Apr 29, 1996  Gene Kozin      v1.0 (merged version S502 & S508 definitions).
+* Sep 26, 1995  Gene Kozin      Initial version.
+*****************************************************************************/
+#ifndef _SDLA_FR_H
+#define _SDLA_FR_H
+
+/*----------------------------------------------------------------------------
+ * Notes:
+ * ------
+ * 1. All structures defined in this file are byte-alined.  
+ *
+ *      Compiler        Platform
+ *      --------        --------
+ *      GNU C           Linux
+ */
+
+#ifndef PACKED
+#    define     PACKED  __attribute__((packed))
+#endif  /* PACKED */
+
+/* Adapter memory layout */
+#define FR_MB_VECTOR    0xE000  /* mailbox window vector */
+#define FR502_RX_VECTOR 0xA000  /* S502 direct receive window vector */
+#define FR502_MBOX_OFFS 0xF60   /* S502 mailbox offset */
+#define FR508_MBOX_OFFS 0       /* S508 mailbox offset */
+#define FR502_FLAG_OFFS 0x1FF0  /* S502 status flags offset */
+#define FR508_FLAG_OFFS 0x1000  /* S508 status flags offset */
+#define FR502_RXMB_OFFS 0x900   /* S502 direct receive mailbox offset */
+#define FR508_TXBC_OFFS 0x1100  /* S508 Tx buffer info offset */
+#define FR508_RXBC_OFFS 0x1120  /* S508 Rx buffer info offset */
+
+/* Important constants */
+#define FR502_MAX_DATA  4096    /* maximum data buffer length */
+#define FR508_MAX_DATA  4080    /* maximum data buffer length */
+#define MIN_LGTH_FR_DATA_CFG         300     /* min Information frame length
+(for configuration purposes) */
+#define FR_MAX_NO_DATA_BYTES_IN_FRAME  15354    /* max Information frame length */
+ 
+#define HIGHEST_VALID_DLCI      991
+
+/****** Data Structures *****************************************************/
+
+/*----------------------------------------------------------------------------
+ * Frame relay command block.
+ */
+typedef struct fr_cmd
+{
+        unsigned char  command  PACKED; /* command code */
+        unsigned short length   PACKED; /* length of data buffer */
+        unsigned char  result   PACKED; /* return code */
+        unsigned short dlci     PACKED; /* DLCI number */
+        unsigned char  attr     PACKED; /* FECN, BECN, DE and C/R bits */
+        unsigned short rxlost1  PACKED; /* frames discarded at int. level */
+        unsigned long  rxlost2  PACKED; /* frames discarded at app. level */
+        unsigned char  rsrv[2]  PACKED; /* reserved for future use */
+} fr_cmd_t;
+
+/* 'command' field defines */
+#define FR_WRITE                0x01
+#define FR_READ                 0x02
+#define FR_ISSUE_IS_FRAME       0x03
+#define FR_SET_CONFIG           0x10
+#define FR_READ_CONFIG          0x11
+#define FR_COMM_DISABLE         0x12
+#define FR_COMM_ENABLE          0x13
+#define FR_READ_STATUS          0x14
+#define FR_READ_STATISTICS      0x15
+#define FR_FLUSH_STATISTICS     0x16
+#define FR_LIST_ACTIVE_DLCI     0x17
+#define FR_FLUSH_DATA_BUFFERS   0x18
+#define FR_READ_ADD_DLC_STATS   0x19
+#define FR_ADD_DLCI             0x20
+#define FR_DELETE_DLCI          0x21
+#define FR_ACTIVATE_DLCI        0x22
+#define FR_DEACTIVATE_DLCI      0x22
+#define FR_READ_MODEM_STATUS    0x30
+#define FR_SET_MODEM_STATUS     0x31
+#define FR_READ_ERROR_STATS     0x32
+#define FR_FLUSH_ERROR_STATS    0x33
+#define FR_READ_DLCI_IB_MAPPING 0x34
+#define FR_READ_CODE_VERSION    0x40
+#define FR_SET_INTR_MODE        0x50
+#define FR_READ_INTR_MODE       0x51
+#define FR_SET_TRACE_CONFIG     0x60
+#define FR_FT1_STATUS_CTRL      0x80
+#define FR_SET_FT1_MODE         0x81
+
+/* Special UDP drivers management commands */
+#define FPIPE_ENABLE_TRACING            0x41
+#define FPIPE_DISABLE_TRACING           0x42
+#define FPIPE_GET_TRACE_INFO            0x43
+#define FPIPE_FT1_READ_STATUS           0x44
+#define FPIPE_DRIVER_STAT_IFSEND        0x45
+#define FPIPE_DRIVER_STAT_INTR          0x46
+#define FPIPE_DRIVER_STAT_GEN           0x47
+#define FPIPE_FLUSH_DRIVER_STATS        0x48
+#define FPIPE_ROUTER_UP_TIME            0x49
+
+/* 'result' field defines */
+#define FRRES_OK                0x00    /* command executed successfully */
+#define FRRES_DISABLED          0x01    /* communications not enabled */
+#define FRRES_INOPERATIVE       0x02    /* channel inoperative */
+#define FRRES_DLCI_INACTIVE     0x03    /* DLCI is inactive */
+#define FRRES_DLCI_INVALID      0x04    /* DLCI is not configured */
+#define FRRES_TOO_LONG          0x05
+#define FRRES_TOO_MANY          0x06
+#define FRRES_CIR_OVERFLOW      0x07    /* Tx throughput has exceeded CIR */
+#define FRRES_BUFFER_OVERFLOW   0x08
+#define FRRES_MODEM_FAILURE     0x10    /* DCD and/or CTS dropped */
+#define FRRES_CHANNEL_DOWN      0x11    /* channel became inoperative */
+#define FRRES_CHANNEL_UP        0x12    /* channel became operative */
+#define FRRES_DLCI_CHANGE       0x13    /* DLCI status (or number) changed */
+#define FRRES_DLCI_MISMATCH     0x14
+#define FRRES_INVALID_CMD       0x1F    /* invalid command */
+
+/* 'attr' field defines */
+#define FRATTR_
+
+/*----------------------------------------------------------------------------
+ * Frame relay mailbox.
+ *      This structure is located at offset FR50?_MBOX_OFFS into FR_MB_VECTOR.
+ *      For S502 it is also located at offset FR502_RXMB_OFFS into
+ *      FR502_RX_VECTOR.
+ */
+typedef struct fr_mbox
+{
+        unsigned char opflag    PACKED; /* 00h: execution flag */
+        fr_cmd_t cmd            PACKED; /* 01h: command block */
+        unsigned char data[1]   PACKED; /* 10h: variable length data buffer */
+} fr_mbox_t;
+
+/*----------------------------------------------------------------------------
+ * S502 frame relay status flags.
+ *      This structure is located at offset FR502_FLAG_OFFS into FR_MB_VECTOR.
+ */
+typedef struct  fr502_flags
+{       
+        unsigned char rsrv1[1]  PACKED; /* 00h: */
+        unsigned char tx_ready  PACKED; /* 01h: Tx buffer available */
+        unsigned char rx_ready  PACKED; /* 02h: Rx frame available */
+        unsigned char event     PACKED; /* 03h: asynchronous event */
+        unsigned char mstatus   PACKED; /* 04h: modem status */
+        unsigned char rsrv2[8]  PACKED; /* 05h: */
+        unsigned char iflag     PACKED; /* 0Dh: interrupt flag */
+        unsigned char imask     PACKED; /* 0Eh: interrupt mask */
+} fr502_flags_t;
+
+/*----------------------------------------------------------------------------
+ * S508 frame relay status flags.
+ *      This structure is located at offset FR508_FLAG_OFFS into FR_MB_VECTOR.
+ */
+typedef struct  fr508_flags
+{
+        unsigned char rsrv1[3]  PACKED; /* 00h: reserved */
+        unsigned char event     PACKED; /* 03h: asynchronous event */
+        unsigned char mstatus   PACKED; /* 04h: modem status */
+        unsigned char rsrv2[11] PACKED; /* 05h: reserved */
+        unsigned char iflag     PACKED; /* 10h: interrupt flag */
+        unsigned char imask     PACKED; /* 11h: interrupt mask */
+        unsigned long tse_offs  PACKED; /* 12h: Tx status element */
+        unsigned short dlci     PACKED; /* 16h: DLCI NUMBER */
+} fr508_flags_t;
+
+/* 'event' field defines */
+#define FR_EVENT_STATUS         0x01    /* channel status change */
+#define FR_EVENT_DLC_STATUS     0x02    /* DLC status change */
+#define FR_EVENT_BAD_DLCI       0x04    /* FSR included wrong DLCI */
+#define FR_EVENT_LINK_DOWN      0x40    /* DCD or CTS low */
+
+/* 'mstatus' field defines */
+#define FR_MDM_DCD              0x08    /* mdm_status: DCD */
+#define FR_MDM_CTS              0x20    /* mdm_status: CTS */
+
+/* 'iflag' & 'imask' fields defines */
+#define FR_INTR_RXRDY           0x01    /* Rx ready */
+#define FR_INTR_TXRDY           0x02    /* Tx ready */
+#define FR_INTR_MODEM           0x04    /* modem status change (DCD, CTS) */
+#define FR_INTR_READY           0x08    /* interface command completed */
+#define FR_INTR_DLC             0x10    /* DLC status change */
+#define FR_INTR_TIMER           0x20    /* millisecond timer */
+#define FR_INTR_TX_MULT_DLCIs   0x80    /* Tx interrupt on multiple DLCIs */
+
+
+/*----------------------------------------------------------------------------
+ * Receive Buffer Configuration Info. S508 only!
+ *      This structure is located at offset FR508_RXBC_OFFS into FR_MB_VECTOR.
+ */
+typedef struct  fr_buf_info
+{
+        unsigned short rse_num  PACKED; /* 00h: number of status elements */
+        unsigned long rse_base  PACKED; /* 02h: receive status array base */
+        unsigned long rse_next  PACKED; /* 06h: next status element */
+        unsigned long buf_base  PACKED; /* 0Ah: rotational buffer base */
+        unsigned short reserved PACKED; /* 0Eh:  */
+        unsigned long buf_top   PACKED; /* 10h: rotational buffer top */
+} fr_buf_info_t;
+
+/*----------------------------------------------------------------------------
+ * Buffer Status Element. S508 only!
+ *      Array of structures of this type is located at offset defined by the
+ *      'rse_base' field of the frBufInfo_t structure into absolute adapter
+ *      memory address space.
+ */
+typedef struct  fr_rx_buf_ctl
+{
+        unsigned char flag      PACKED; /* 00h: ready flag */
+        unsigned short length   PACKED; /* 01h: frame length */
+        unsigned short dlci     PACKED; /* 03h: DLCI */
+        unsigned char attr      PACKED; /* 05h: FECN/BECN/DE/CR */
+        unsigned short tmstamp  PACKED; /* 06h: time stamp */
+        unsigned short rsrv[2]  PACKED; /* 08h:  */
+        unsigned long offset    PACKED; /* 0Ch: buffer absolute address */
+} fr_rx_buf_ctl_t;
+
+typedef struct  fr_tx_buf_ctl
+{
+        unsigned char flag      PACKED; /* 00h: ready flag */
+        unsigned short rsrv0[2] PACKED; /* 01h: */
+        unsigned short length   PACKED; /* 05h: frame length */
+        unsigned short dlci     PACKED; /* 07h: DLCI */
+        unsigned char attr      PACKED; /* 09h: FECN/BECN/DE/CR */
+        unsigned short rsrv1    PACKED; /* 0Ah:  */
+        unsigned long offset    PACKED; /* 0Ch: buffer absolute address */
+} fr_tx_buf_ctl_t;
+
+/*----------------------------------------------------------------------------
+ * Global Configuration Block. Passed to FR_SET_CONFIG command when dlci == 0.
+ */
+typedef struct  fr_conf
+{
+        unsigned short station  PACKED; /* 00h: CPE/Node */
+        unsigned short options  PACKED; /* 02h: configuration options */
+        unsigned short kbps     PACKED; /* 04h: baud rate in kbps */
+        unsigned short port     PACKED; /* 06h: RS-232/V.35 */
+        unsigned short mtu      PACKED; /* 08h: max. transmit length */
+        unsigned short t391     PACKED; /* 0Ah:  */
+        unsigned short t392     PACKED; /* 0Ch:  */
+        unsigned short n391     PACKED; /* 0Eh:  */
+        unsigned short n392     PACKED; /* 10h:  */
+        unsigned short n393     PACKED; /* 12h:  */
+        unsigned short cir_fwd  PACKED; /* 14h:  */
+        unsigned short bc_fwd   PACKED; /* 16h:  */
+        unsigned short be_fwd   PACKED; /* 18h:  */
+        unsigned short cir_bwd  PACKED; /* 1Ah:  */
+        unsigned short bc_bwd   PACKED; /* 1Ch:  */
+        unsigned short be_bwd   PACKED; /* 1Eh:  */
+        unsigned short dlci[0]  PACKED; /* 20h:  */
+} fr_conf_t;
+
+/* 'station_type' defines */
+#define FRCFG_STATION_CPE       0
+#define FRCFG_STATION_NODE      1
+
+/* 'conf_flags' defines */
+#define FRCFG_IGNORE_TX_CIR     0x0001
+#define FRCFG_IGNORE_RX_CIR     0x0002
+#define FRCFG_DONT_RETRANSMIT   0x0004
+#define FRCFG_IGNORE_CBS        0x0008
+#define FRCFG_THROUGHPUT        0x0010  /* enable throughput calculation */
+#define FRCFG_DIRECT_RX         0x0080  /* enable direct receive buffer */
+#define FRCFG_AUTO_CONFIG       0x8000  /* enable  auto DLCI configuration */
+
+/* 'baud_rate' defines */
+#define FRCFG_BAUD_1200         12
+#define FRCFG_BAUD_2400         24
+#define FRCFG_BAUD_4800         48
+#define FRCFG_BAUD_9600         96
+#define FRCFG_BAUD_19200        19
+#define FRCFG_BAUD_38400        38
+#define FRCFG_BAUD_56000        56
+#define FRCFG_BAUD_64000        64
+#define FRCFG_BAUD_128000       128
+
+/* 'port_mode' defines */
+#define FRCFG_MODE_EXT_CLK      0x0000
+#define FRCFG_MODE_INT_CLK      0x0001
+#define FRCFG_MODE_V35          0x0000  /* S508 only */
+#define FRCFG_MODE_RS232        0x0002  /* S508 only */
+
+/* defines for line tracing */
+
+/* the line trace status element presented by the frame relay code */
+typedef struct {
+        unsigned char flag      PACKED; /* ready flag */
+        unsigned short length   PACKED; /* trace length */
+        unsigned char rsrv0[2]  PACKED; /* reserved */
+        unsigned char attr      PACKED; /* trace attributes */
+        unsigned short tmstamp  PACKED; /* time stamp */
+        unsigned char rsrv1[4]  PACKED; /* reserved */
+        unsigned long offset    PACKED; /* buffer absolute address */
+} fr_trc_el_t;
+
+typedef struct {
+        unsigned char status            PACKED; /* status flag */
+        unsigned char data_passed       PACKED; /* 0 if no data passed, 1 if */
+                                                /* data passed */
+        unsigned short length           PACKED; /* frame length */
+        unsigned short tmstamp          PACKED; /* time stamp */
+} fpipemon_trc_hdr_t;
+
+typedef struct {
+        fpipemon_trc_hdr_t fpipemon_trc_hdr                     PACKED;
+        unsigned char data[FR_MAX_NO_DATA_BYTES_IN_FRAME]       PACKED;
+} fpipemon_trc_t;
+
+/* bit settings for the 'status' byte  - note that bits 1, 2 and 3 are used */
+/* for returning the number of frames being passed to fpipemon */
+#define TRC_OUTGOING_FRM        0x01
+#define TRC_ABORT_ERROR         0x10
+#define TRC_CRC_ERROR           0x20
+#define TRC_OVERRUN_ERROR       0x40
+#define MORE_TRC_DATA           0x80
+
+#define MAX_FRMS_TRACED         0x07
+
+#define NO_TRC_ELEMENTS_OFF             0x9000
+#define BASE_TRC_ELEMENTS_OFF           0x9002
+#define TRC_ACTIVE                      0x01
+#define FLUSH_TRC_BUFFERS               0x02
+#define FLUSH_TRC_STATISTICS            0x04
+#define TRC_SIGNALLING_FRMS             0x10
+#define TRC_INFO_FRMS                   0x20
+#define ACTIVATE_TRC    (TRC_ACTIVE | TRC_SIGNALLING_FRMS | TRC_INFO_FRMS)
+#define RESET_TRC       (FLUSH_TRC_BUFFERS | FLUSH_TRC_STATISTICS)
+
+/*----------------------------------------------------------------------------
+ * Channel configuration.
+ *      This structure is passed to the FR_SET_CONFIG command when dlci != 0.
+ */
+typedef struct  fr_dlc_conf
+{
+        unsigned short conf_flags       PACKED; /* 00h: configuration bits */
+        unsigned short cir_fwd          PACKED; /* 02h:  */
+        unsigned short bc_fwd           PACKED; /* 04h:  */
+        unsigned short be_fwd           PACKED; /* 06h:  */
+        unsigned short cir_bwd          PACKED; /* 08h:  */
+        unsigned short bc_bwd           PACKED; /* 0Ah:  */
+        unsigned short be_bwd           PACKED; /* 0Ch:  */
+} fr_dlc_conf_t;
+
+/*----------------------------------------------------------------------------
+ * S502 interrupt mode control block.
+ *      This structure is passed to the FR_SET_INTR_FLAGS and returned by the
+ *      FR_READ_INTR_FLAGS commands.
+ */
+typedef struct fr502_intr_ctl
+{
+        unsigned char mode      PACKED; /* 00h: interrupt enable flags */
+        unsigned short tx_len   PACKED; /* 01h: required Tx buffer size */
+} fr502_intr_ctl_t;
+
+/*----------------------------------------------------------------------------
+ * S508 interrupt mode control block.
+ *      This structure is passed to the FR_SET_INTR_FLAGS and returned by the
+ *      FR_READ_INTR_FLAGS commands.
+ */
+typedef struct fr508_intr_ctl
+{
+        unsigned char mode      PACKED; /* 00h: interrupt enable flags */
+        unsigned short tx_len   PACKED; /* 01h: required Tx buffer size */
+        unsigned char irq       PACKED; /* 03h: IRQ level to activate */
+        unsigned char flags     PACKED; /* 04h: ?? */
+        unsigned short timeout  PACKED; /* 05h: ms, for timer interrupt */
+} fr508_intr_ctl_t;
+
+/*----------------------------------------------------------------------------
+ * Channel status.
+ *      This structure is returned by the FR_READ_STATUS command.
+ */
+typedef struct  fr_dlc_Status
+{
+        unsigned char status            PACKED; /* 00h: link/DLCI status */
+        struct
+        {
+                unsigned short dlci     PACKED; /* 01h: DLCI number */
+                unsigned char status    PACKED; /* 03h: DLCI status */
+        } circuit[1]                    PACKED;
+} fr_dlc_status_t;
+
+/* 'status' defines */
+#define FR_LINK_INOPER  0x00            /* for global status (DLCI == 0) */
+#define FR_LINK_OPER    0x01
+#define FR_DLCI_DELETED 0x01            /* for circuit status (DLCI != 0) */
+#define FR_DLCI_ACTIVE  0x02
+#define FR_DLCI_WAITING 0x04
+#define FR_DLCI_NEW     0x08
+#define FR_DLCI_REPORT  0x40
+
+/*----------------------------------------------------------------------------
+ * Global Statistics Block.
+ *      This structure is returned by the FR_READ_STATISTICS command when
+ *      dcli == 0.
+ */
+typedef struct  fr_link_stat
+{
+        unsigned short rx_too_long      PACKED; /* 00h:  */
+        unsigned short rx_dropped       PACKED; /* 02h:  */
+        unsigned short rx_dropped2      PACKED; /* 04h:  */
+        unsigned short rx_bad_dlci      PACKED; /* 06h:  */
+        unsigned short rx_bad_format    PACKED; /* 08h:  */
+        unsigned short retransmitted    PACKED; /* 0Ah:  */
+        unsigned short cpe_tx_FSE       PACKED; /* 0Ch:  */
+        unsigned short cpe_tx_LIV       PACKED; /* 0Eh:  */
+        unsigned short cpe_rx_FSR       PACKED; /* 10h:  */
+        unsigned short cpe_rx_LIV       PACKED; /* 12h:  */
+        unsigned short node_rx_FSE      PACKED; /* 14h:  */
+        unsigned short node_rx_LIV      PACKED; /* 16h:  */
+        unsigned short node_tx_FSR      PACKED; /* 18h:  */
+        unsigned short node_tx_LIV      PACKED; /* 1Ah:  */
+        unsigned short rx_ISF_err       PACKED; /* 1Ch:  */
+        unsigned short rx_unsolicited   PACKED; /* 1Eh:  */
+        unsigned short rx_SSN_err       PACKED; /* 20h:  */
+        unsigned short rx_RSN_err       PACKED; /* 22h:  */
+        unsigned short T391_timeouts    PACKED; /* 24h:  */
+        unsigned short T392_timeouts    PACKED; /* 26h:  */
+        unsigned short N392_reached     PACKED; /* 28h:  */
+        unsigned short cpe_SSN_RSN      PACKED; /* 2Ah:  */
+        unsigned short current_SSN      PACKED; /* 2Ch:  */
+        unsigned short current_RSN      PACKED; /* 2Eh:  */
+        unsigned short curreny_T391     PACKED; /* 30h:  */
+        unsigned short current_T392     PACKED; /* 32h:  */
+        unsigned short current_N392     PACKED; /* 34h:  */
+        unsigned short current_N393     PACKED; /* 36h:  */
+} fr_link_stat_t;
+
+/*----------------------------------------------------------------------------
+ * DLCI statistics.
+ *      This structure is returned by the FR_READ_STATISTICS command when
+ *      dlci != 0.
+ */
+typedef struct  fr_dlci_stat
+{
+        unsigned long tx_frames         PACKED; /* 00h:  */
+        unsigned long tx_bytes          PACKED; /* 04h:  */
+        unsigned long rx_frames         PACKED; /* 08h:  */
+        unsigned long rx_bytes          PACKED; /* 0Ch:  */
+        unsigned long rx_dropped        PACKED; /* 10h:  */
+        unsigned long rx_inactive       PACKED; /* 14h:  */
+        unsigned long rx_exceed_CIR     PACKED; /* 18h:  */
+        unsigned long rx_DE_set         PACKED; /* 1Ch:  */
+        unsigned long tx_throughput     PACKED; /* 20h:  */
+        unsigned long tx_calc_timer     PACKED; /* 24h:  */
+        unsigned long rx_throughput     PACKED; /* 28h:  */
+        unsigned long rx_calc_timer     PACKED; /* 2Ch:  */
+} fr_dlci_stat_t;
+
+/*----------------------------------------------------------------------------
+ * Communications error statistics.
+ *      This structure is returned by the FR_READ_ERROR_STATS command.
+ */
+typedef struct  fr_comm_stat
+{
+        unsigned char rx_overruns       PACKED; /* 00h:  */
+        unsigned char rx_bad_crc        PACKED; /* 01h:  */
+        unsigned char rx_aborts         PACKED; /* 02h:  */
+        unsigned char rx_too_long       PACKED; /* 03h:  */
+        unsigned char tx_aborts         PACKED; /* 04h:  */
+        unsigned char tx_underruns      PACKED; /* 05h:  */
+        unsigned char tx_missed_undr    PACKED; /* 06h:  */
+        unsigned char dcd_dropped       PACKED; /* 07h:  */
+        unsigned char cts_dropped       PACKED; /* 08h:  */
+} fr_comm_stat_t;
+
+/*----------------------------------------------------------------------------
+ * Defines for the FR_ISSUE_IS_FRAME command.
+ */
+#define FR_ISF_LVE      2               /* issue Link Verification Enquiry */
+#define FR_ISF_FSE      3               /* issue Full Status Enquiry */
+
+/*----------------------------------------------------------------------------
+ * Frame Relay ARP Header -- Used for Dynamic route creation with InvARP 
+ */
+
+typedef struct arphdr_fr
+        {
+        unsigned short ar_hrd PACKED;           /* format of hardware addr */
+        unsigned short ar_pro PACKED;           /* format of protocol addr */
+        unsigned char  ar_hln PACKED;           /* length of hardware addr */   
+        unsigned char  ar_pln PACKED;           /* length of protocol addr */
+        unsigned short ar_op  PACKED;           /* ARP opcode              */
+        unsigned short ar_sha PACKED;           /* Sender DLCI addr 2 bytes */
+        unsigned long  ar_sip PACKED;           /* Sender IP   addr 4 bytes */
+        unsigned short ar_tha PACKED;           /* Target DLCI addr 2 bytes */
+        unsigned long  ar_tip PACKED;           /* Target IP   addr 4 bytes */
+        } arphdr_fr_t;
+
+/*----------------------------------------------------------------------------
+ * Frame Relay RFC 1490 SNAP Header -- Used to check for ARP packets
+ */
+typedef struct arphdr_1490
+        {
+        unsigned char control PACKED;           /* UI, etc...  */
+        unsigned char pad     PACKED;           /* Pad */
+        unsigned char NLPID   PACKED;           /* SNAP */
+        unsigned char OUI[3]  PACKED;           /* Ethertype, etc... */
+        unsigned short PID    PACKED;           /* ARP, IP, etc... */
+        }  arphdr_1490_t;
+
+/* UDP/IP packet (for UDP management) layout */
+
+/* The embedded control block for UDP mgmt
+   This is essentially a mailbox structure, without the large data field */
+
+typedef struct {
+        unsigned char  opp_flag PACKED; /* the opp flag */
+        unsigned char  command  PACKED; /* command code */
+        unsigned short length   PACKED; /* length of data buffer */
+        unsigned char  result   PACKED; /* return code */
+        unsigned short dlci     PACKED; /* DLCI number */
+        unsigned char  attr     PACKED; /* FECN, BECN, DE and C/R bits */
+        unsigned short rxlost1  PACKED; /* frames discarded at int. level */
+        unsigned long  rxlost2  PACKED; /* frames discarded at app. level */
+        unsigned char  rsrv[2]  PACKED; /* reserved for future use */
+} cblock_t;
+
+
+/* UDP management packet layout (data area of ip packet) */
+
+typedef struct {
+        unsigned char   control                 PACKED;
+        unsigned char   NLPID                   PACKED;
+} fr_encap_hdr_t;
+
+typedef struct {
+//      fr_encap_hdr_t          fr_encap_hdr    PACKED;
+        ip_pkt_t                ip_pkt          PACKED;
+        udp_pkt_t               udp_pkt         PACKED;
+        wp_mgmt_t               wp_mgmt         PACKED;
+        cblock_t                cblock          PACKED;
+        unsigned char           data[4080]      PACKED;
+} fr_udp_pkt_t;
+
+
+/* valid ip_protocol for UDP management */
+#define UDPMGMT_UDP_PROTOCOL 0x11
+
+#define UDPMGMT_FPIPE_SIGNATURE         "FPIPE8ND"
+#define UDPMGMT_DRVRSTATS_SIGNATURE     "DRVSTATS"
+
+/* values for request/reply byte */
+#define UDPMGMT_REQUEST 0x01
+#define UDPMGMT_REPLY   0x02
+#define UDP_OFFSET      12
+
+typedef struct {
+        unsigned long if_send_entry;
+        unsigned long if_send_skb_null;
+        unsigned long if_send_broadcast;
+        unsigned long if_send_multicast;
+        unsigned long if_send_critical_ISR;
+        unsigned long if_send_critical_non_ISR;
+        unsigned long if_send_busy;
+        unsigned long if_send_busy_timeout;
+        unsigned long if_send_DRVSTATS_request;
+        unsigned long if_send_FPIPE_request;
+        unsigned long if_send_wan_disconnected;
+        unsigned long if_send_dlci_disconnected;
+        unsigned long if_send_no_bfrs;
+        unsigned long if_send_adptr_bfrs_full;
+        unsigned long if_send_bfrs_passed_to_adptr;
+        unsigned long if_send_consec_send_fail;
+} drvstats_if_send_t; 
+
+typedef struct {
+        unsigned long rx_intr_no_socket;
+        unsigned long rx_intr_dev_not_started;
+        unsigned long rx_intr_DRVSTATS_request;
+        unsigned long rx_intr_FPIPE_request;
+        unsigned long rx_intr_bfr_not_passed_to_stack;
+        unsigned long rx_intr_bfr_passed_to_stack;
+ } drvstats_rx_intr_t;
+
+typedef struct {
+        unsigned long UDP_FPIPE_mgmt_kmalloc_err;
+        unsigned long UDP_FPIPE_mgmt_direction_err;
+        unsigned long UDP_FPIPE_mgmt_adptr_type_err;
+        unsigned long UDP_FPIPE_mgmt_adptr_cmnd_OK;
+        unsigned long UDP_FPIPE_mgmt_adptr_cmnd_timeout;
+        unsigned long UDP_FPIPE_mgmt_adptr_send_passed;
+        unsigned long UDP_FPIPE_mgmt_adptr_send_failed;
+        unsigned long UDP_FPIPE_mgmt_not_passed_to_stack;
+        unsigned long UDP_FPIPE_mgmt_passed_to_stack;
+        unsigned long UDP_FPIPE_mgmt_no_socket;
+        unsigned long UDP_DRVSTATS_mgmt_kmalloc_err;
+        unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_OK;
+        unsigned long UDP_DRVSTATS_mgmt_adptr_cmnd_timeout;
+        unsigned long UDP_DRVSTATS_mgmt_adptr_send_passed;
+        unsigned long UDP_DRVSTATS_mgmt_adptr_send_failed;
+        unsigned long UDP_DRVSTATS_mgmt_not_passed_to_stack;
+        unsigned long UDP_DRVSTATS_mgmt_passed_to_stack;
+        unsigned long UDP_DRVSTATS_mgmt_no_socket;
+} drvstats_gen_t;
+
+typedef struct {
+        unsigned char   attr            PACKED;
+        unsigned short  time_stamp      PACKED;
+        unsigned char   reserved[13]    PACKED;
+} api_rx_hdr_t;
+
+typedef struct {
+        api_rx_hdr_t    api_rx_hdr      PACKED;
+        void *          data            PACKED;
+} api_rx_element_t;
+
+typedef struct {
+        unsigned char   attr            PACKED;
+        unsigned char   reserved[15]    PACKED;
+} api_tx_hdr_t;
+
+typedef struct {
+        api_tx_hdr_t    api_tx_hdr      PACKED;
+        void *          data            PACKED;
+} api_tx_element_t;
+
+#ifdef          _MSC_
+#  pragma       pack()
+#endif
+#endif  /* _SDLA_FR_H */
+
diff --git a/include/linux/sdla_ppp.h b/include/linux/sdla_ppp.h
new file mode 100644
index 000000000000..6f3923179c29
--- /dev/null
+++ b/include/linux/sdla_ppp.h
@@ -0,0 +1,575 @@
+/*****************************************************************************
+* sdla_ppp.h    Sangoma PPP firmware API definitions.
+*
+* Author:       Nenad Corbic    <ncorbic@sangoma.com>
+*
+* Copyright:    (c) 1995-1997 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Feb 24, 2000  Nenad Corbic    v2.1.2
+* Jan 06, 1997  Gene Kozin      v2.0
+* Apr 11, 1996  Gene Kozin      Initial version.
+*****************************************************************************/
+#ifndef _SDLA_PPP_H
+#define _SDLA_PPP_H
+
+/*----------------------------------------------------------------------------
+ * Notes:
+ * ------
+ * 1. All structures defined in this file are byte-alined.  
+ *
+ *      Compiler        Platform
+ *      --------        --------
+ *      GNU C           Linux           
+ */
+
+#ifndef PACKED
+#    define     PACKED  __attribute__((packed))
+#endif  /* PACKED */
+
+/* Adapter memory layout and important constants */
+#define PPP508_MB_VECT  0xE000  /* mailbox window vector */
+#define PPP508_MB_OFFS  0               /* mailbox offset */
+#define PPP508_FLG_OFFS 0x1000  /* status flags offset */
+#define PPP508_BUF_OFFS 0x1100  /* buffer info block offset */
+#define PPP514_MB_OFFS  0xE000  /* mailbox offset */
+#define PPP514_FLG_OFFS 0xF000  /* status flags offset */
+#define PPP514_BUF_OFFS 0xF100  /* buffer info block offset */
+
+#define PPP_MAX_DATA    1008    /* command block data buffer length */
+
+/****** Data Structures *****************************************************/
+
+/*----------------------------------------------------------------------------
+ * PPP Command Block.
+ */
+typedef struct ppp_cmd{
+        unsigned char  command  PACKED; /* command code */
+        unsigned short length   PACKED; /* length of data buffer */
+        unsigned char  result   PACKED; /* return code */
+        unsigned char  rsrv[11] PACKED; /* reserved for future use */
+} ppp_cmd_t;
+
+typedef struct cblock{
+        unsigned char  opp_flag PACKED;
+        unsigned char  command  PACKED; /* command code */
+        unsigned short length   PACKED; /* length of data buffer */
+        unsigned char  result   PACKED; /* return code */
+        unsigned char  rsrv[11] PACKED; /* reserved for future use */
+} cblock_t;
+
+typedef struct ppp_udp_pkt{
+        ip_pkt_t        ip_pkt  PACKED;
+        udp_pkt_t       udp_pkt PACKED;
+        wp_mgmt_t       wp_mgmt PACKED;
+        cblock_t        cblock  PACKED;
+        unsigned char   data[MAX_LGTH_UDP_MGNT_PKT] PACKED;
+} ppp_udp_pkt_t;        
+
+typedef struct {
+        unsigned char   status          PACKED;
+        unsigned char   data_avail      PACKED;
+        unsigned short  real_length     PACKED;
+        unsigned short  time_stamp      PACKED;
+        unsigned char   data[1]         PACKED;
+} trace_pkt_t;
+
+
+typedef struct {
+        unsigned char   opp_flag        PACKED;
+        unsigned char   trace_type      PACKED;
+        unsigned short  trace_length    PACKED;
+        unsigned short  trace_data_ptr  PACKED;
+        unsigned short  trace_time_stamp PACKED;
+} trace_element_t;
+
+/* 'command' field defines */
+#define PPP_READ_CODE_VERSION   0x10    /* configuration commands */
+#define PPP_SET_CONFIG          0x05
+#define PPP_READ_CONFIG         0x06
+#define PPP_SET_INTR_FLAGS      0x20
+#define PPP_READ_INTR_FLAGS     0x21
+#define PPP_SET_INBOUND_AUTH    0x30
+#define PPP_SET_OUTBOUND_AUTH   0x31
+#define PPP_GET_CONNECTION_INFO 0x32
+
+#define PPP_COMM_ENABLE         0x03    /* operational commands */
+#define PPP_COMM_DISABLE        0x04
+#define PPP_SEND_SIGN_FRAME     0x23
+#define PPP_READ_SIGN_RESPONSE  0x24
+#define PPP_DATALINE_MONITOR    0x33
+
+#define PPP_READ_STATISTICS     0x07    /* statistics commands */
+#define PPP_FLUSH_STATISTICS    0x08
+#define PPP_READ_ERROR_STATS    0x09
+#define PPP_FLUSH_ERROR_STATS   0x0A
+#define PPP_READ_PACKET_STATS   0x12
+#define PPP_FLUSH_PACKET_STATS  0x13
+#define PPP_READ_LCP_STATS      0x14
+#define PPP_FLUSH_LCP_STATS     0x15
+#define PPP_READ_LPBK_STATS     0x16
+#define PPP_FLUSH_LPBK_STATS    0x17
+#define PPP_READ_IPCP_STATS     0x18
+#define PPP_FLUSH_IPCP_STATS    0x19
+#define PPP_READ_IPXCP_STATS    0x1A
+#define PPP_FLUSH_IPXCP_STATS   0x1B
+#define PPP_READ_PAP_STATS      0x1C
+#define PPP_FLUSH_PAP_STATS     0x1D
+#define PPP_READ_CHAP_STATS     0x1E
+#define PPP_FLUSH_CHAP_STATS    0x1F
+
+/* 'result' field defines */
+#define PPPRES_OK               0x00    /* command executed successfully */
+#define PPPRES_INVALID_STATE    0x09    /* invalid command in this context */
+
+/*----------------------------------------------------------------------------
+ * PPP Mailbox.
+ *      This structure is located at offset PPP???_MB_OFFS into PPP???_MB_VECT
+ */
+typedef struct ppp_mbox
+{
+        unsigned char flag      PACKED; /* 00h: command execution flag */
+        ppp_cmd_t     cmd       PACKED; /* 01h: command block */
+        unsigned char data[1]   PACKED; /* 10h: variable length data buffer */
+} ppp_mbox_t;
+
+/*----------------------------------------------------------------------------
+ * PPP Status Flags.
+ *      This structure is located at offset PPP???_FLG_OFFS into
+ *      PPP???_MB_VECT.
+ */
+typedef struct  ppp_flags
+{
+        unsigned char iflag             PACKED; /* 00: interrupt flag */
+        unsigned char imask             PACKED; /* 01: interrupt mask */
+        unsigned char resrv             PACKED;
+        unsigned char mstatus           PACKED; /* 03: modem status */
+        unsigned char lcp_state         PACKED; /* 04: LCP state */
+        unsigned char ppp_phase         PACKED; /* 05: PPP phase */
+        unsigned char ip_state          PACKED; /* 06: IPCP state */
+        unsigned char ipx_state         PACKED; /* 07: IPXCP state */
+        unsigned char pap_state         PACKED; /* 08: PAP state */
+        unsigned char chap_state        PACKED; /* 09: CHAP state */
+        unsigned short disc_cause       PACKED; /* 0A: disconnection cause */
+} ppp_flags_t;
+
+/* 'iflag' defines */
+#define PPP_INTR_RXRDY          0x01    /* Rx ready */
+#define PPP_INTR_TXRDY          0x02    /* Tx ready */
+#define PPP_INTR_MODEM          0x04    /* modem status change (DCD, CTS) */
+#define PPP_INTR_CMD            0x08    /* interface command completed */
+#define PPP_INTR_DISC           0x10    /* data link disconnected */
+#define PPP_INTR_OPEN           0x20    /* data link open */
+#define PPP_INTR_DROP_DTR       0x40    /* DTR drop timeout expired */
+#define PPP_INTR_TIMER          0x80    /* timer interrupt */
+
+
+/* 'mstatus' defines */
+#define PPP_MDM_DCD             0x08    /* mdm_status: DCD */
+#define PPP_MDM_CTS             0x20    /* mdm_status: CTS */
+
+/* 'disc_cause' defines */
+#define PPP_LOCAL_TERMINATION   0x0001  /* Local Request by PPP termination phase */
+#define PPP_DCD_CTS_DROP        0x0002  /* DCD and/or CTS dropped. Link down */
+#define PPP_REMOTE_TERMINATION  0x0800  /* Remote Request by PPP termination phase */
+
+/* 'misc_config_bits' defines */
+#define DONT_RE_TX_ABORTED_I_FRAMES     0x01
+#define TX_FRM_BYTE_COUNT_STATS         0x02
+#define RX_FRM_BYTE_COUNT_STATS         0x04
+#define TIME_STAMP_IN_RX_FRAMES         0x08
+#define NON_STD_ADPTR_FREQ              0x10
+#define INTERFACE_LEVEL_RS232           0x20
+#define AUTO_LINK_RECOVERY              0x100
+#define DONT_TERMINATE_LNK_MAX_CONFIG   0x200                    
+
+/* 'authentication options' defines */
+#define NO_AUTHENTICATION       0x00
+#define INBOUND_AUTH            0x80
+#define PAP_AUTH                0x01
+#define CHAP_AUTH               0x02            
+
+/* 'ip options' defines */
+#define L_AND_R_IP_NO_ASSIG     0x00
+#define L_IP_LOCAL_ASSIG        0x01
+#define L_IP_REMOTE_ASSIG       0x02
+#define R_IP_LOCAL_ASSIG        0x04
+#define R_IP_REMOTE_ASSIG       0x08
+#define ENABLE_IP               0x80
+
+/* 'ipx options' defines */
+#define ROUTING_PROT_DEFAULT    0x20
+#define ENABLE_IPX              0x80
+#define DISABLE_IPX             0x00
+
+/*----------------------------------------------------------------------------
+ * PPP Buffer Info.
+ *      This structure is located at offset PPP508_BUF_OFFS into
+ *      PPP508_MB_VECT.
+ */
+typedef struct  ppp508_buf_info
+{
+        unsigned short txb_num  PACKED; /* 00: number of transmit buffers */
+        unsigned long  txb_ptr  PACKED; /* 02: pointer to the buffer ctl. */
+        unsigned long  txb_nxt  PACKED;
+        unsigned char  rsrv1[22] PACKED;
+        unsigned short rxb_num  PACKED; /* 20: number of receive buffers */
+        unsigned long  rxb_ptr  PACKED; /* 22: pointer to the buffer ctl. */
+        unsigned long  rxb1_ptr PACKED; /* 26: pointer to the first buf.ctl. */
+        unsigned long  rxb_base PACKED; /* 2A: pointer to the buffer base */
+        unsigned char  rsrv2[2] PACKED;
+        unsigned long  rxb_end  PACKED; /* 30: pointer to the buffer end */
+} ppp508_buf_info_t;
+
+/*----------------------------------------------------------------------------
+ * Transmit/Receive Buffer Control Block.
+ */
+typedef struct  ppp_buf_ctl
+{
+        unsigned char  flag             PACKED; /* 00: 'buffer ready' flag */
+        unsigned short length           PACKED; /* 01: length of data */
+        unsigned char  reserved1[1]     PACKED; /* 03: */
+        unsigned char  proto            PACKED; /* 04: protocol */
+        unsigned short timestamp        PACKED; /* 05: time stamp (Rx only) */
+        unsigned char  reserved2[5]     PACKED; /* 07: */
+        union
+        {
+                unsigned short o_p[2];  /* 1C: buffer offset & page (S502) */
+                unsigned long  ptr;     /* 1C: buffer pointer (S508) */
+        } buf                           PACKED;
+} ppp_buf_ctl_t;
+
+/*----------------------------------------------------------------------------
+ * S508 Adapter Configuration Block (passed to the PPP_SET_CONFIG command).
+ */
+typedef struct  ppp508_conf
+{
+        unsigned long  line_speed       PACKED; /* 00: baud rate, bps */
+        unsigned short txbuf_percent    PACKED; /* 04: % of Tx buffer */
+        unsigned short conf_flags       PACKED; /* 06: configuration bits */
+        unsigned short mtu_local        PACKED; /* 08: local MTU */
+        unsigned short mtu_remote       PACKED; /* 0A: remote MTU */
+        unsigned short restart_tmr      PACKED; /* 0C: restart timer */
+        unsigned short auth_rsrt_tmr    PACKED; /* 0E: authentication timer */
+        unsigned short auth_wait_tmr    PACKED; /* 10: authentication timer */
+        unsigned short mdm_fail_tmr     PACKED; /* 12: modem failure timer */
+        unsigned short dtr_drop_tmr     PACKED; /* 14: DTR drop timer */
+        unsigned short connect_tmout    PACKED; /* 16: connection timeout */
+        unsigned short conf_retry       PACKED; /* 18: max. retry */
+        unsigned short term_retry       PACKED; /* 1A: max. retry */
+        unsigned short fail_retry       PACKED; /* 1C: max. retry */
+        unsigned short auth_retry       PACKED; /* 1E: max. retry */
+        unsigned char  auth_options     PACKED; /* 20: authentication opt. */
+        unsigned char  ip_options       PACKED; /* 21: IP options */
+        unsigned long  ip_local         PACKED; /* 22: local IP address */
+        unsigned long  ip_remote        PACKED; /* 26: remote IP address */
+        unsigned char  ipx_options      PACKED; /* 2A: IPX options */
+        unsigned char  ipx_netno[4]     PACKED; /* 2B: IPX net number */
+        unsigned char  ipx_local[6]     PACKED; /* 2F: local IPX node number*/
+        unsigned char  ipx_remote[6]    PACKED; /* 35: remote IPX node num.*/
+        unsigned char  ipx_router[48]   PACKED; /* 3B: IPX router name*/
+        unsigned long  alt_cpu_clock    PACKED; /* 6B:  */
+} ppp508_conf_t;
+
+/*----------------------------------------------------------------------------
+ * S508 Adapter Read Connection Information Block 
+ *    Returned by the PPP_GET_CONNECTION_INFO command
+ */
+typedef struct  ppp508_connect_info
+{
+        unsigned short  mru             PACKED; /* 00-01 Remote Max Rec' Unit */
+        unsigned char   ip_options      PACKED; /* 02: Negotiated ip options  */
+        unsigned long   ip_local        PACKED; /* 03-06: local IP address    */
+        unsigned long   ip_remote       PACKED; /* 07-0A: remote IP address   */
+        unsigned char   ipx_options     PACKED; /* 0B: Negotiated ipx options */
+        unsigned char   ipx_netno[4]    PACKED; /* 0C-0F: IPX net number      */
+        unsigned char   ipx_local[6]    PACKED; /* 10-1F: local IPX node #    */
+        unsigned char   ipx_remote[6]   PACKED; /* 16-1B: remote IPX node #   */
+        unsigned char   ipx_router[48]  PACKED; /* 1C-4B: IPX router name     */
+        unsigned char   auth_status     PACKED; /* 4C: Authentication Status  */
+        unsigned char   inbd_auth_peerID[1] PACKED; /* 4D: variable length inbound authenticated peer ID */
+} ppp508_connect_info_t;
+
+/* 'line_speed' field */
+#define PPP_BITRATE_1200        0x01
+#define PPP_BITRATE_2400        0x02
+#define PPP_BITRATE_4800        0x03
+#define PPP_BITRATE_9600        0x04
+#define PPP_BITRATE_19200       0x05
+#define PPP_BITRATE_38400       0x06
+#define PPP_BITRATE_45000       0x07
+#define PPP_BITRATE_56000       0x08
+#define PPP_BITRATE_64000       0x09
+#define PPP_BITRATE_74000       0x0A
+#define PPP_BITRATE_112000      0x0B
+#define PPP_BITRATE_128000      0x0C
+#define PPP_BITRATE_156000      0x0D
+
+/* Defines for the 'conf_flags' field */
+#define PPP_IGNORE_TX_ABORT     0x01    /* don't re-transmit aborted frames */
+#define PPP_ENABLE_TX_STATS     0x02    /* enable Tx statistics */
+#define PPP_ENABLE_RX_STATS     0x04    /* enable Rx statistics */
+#define PPP_ENABLE_TIMESTAMP    0x08    /* enable timestamp */
+
+/* 'ip_options' defines */
+#define PPP_LOCAL_IP_LOCAL      0x01
+#define PPP_LOCAL_IP_REMOTE     0x02
+#define PPP_REMOTE_IP_LOCAL     0x04
+#define PPP_REMOTE_IP_REMOTE    0x08
+
+/* 'ipx_options' defines */
+#define PPP_REMOTE_IPX_NETNO    0x01
+#define PPP_REMOTE_IPX_LOCAL    0x02
+#define PPP_REMOTE_IPX_REMOTE   0x04
+#define PPP_IPX_ROUTE_RIP_SAP   0x08
+#define PPP_IPX_ROUTE_NLSP      0x10
+#define PPP_IPX_ROUTE_DEFAULT   0x20
+#define PPP_IPX_CONF_COMPLETE   0x40
+#define PPP_IPX_ENABLE          0x80
+
+/*----------------------------------------------------------------------------
+ * S508 Adapter Configuration Block (returned by the PPP_READ_CONFIG command).
+ */
+typedef struct  ppp508_get_conf
+{
+        unsigned long  bps      PACKED; /* 00: baud rate, bps */
+        ppp508_conf_t  conf     PACKED; /* 04: requested config. */
+        unsigned short txb_num  PACKED; /* 6F: number of Tx buffers */
+        unsigned short rxb_num  PACKED; /* 71: number of Rx buffers */
+} ppp508_get_conf_t;
+
+/*----------------------------------------------------------------------------
+ * S508 Operational Statistics (returned by the PPP_READ_STATISTIC command).
+ */
+typedef struct ppp508_stats
+{
+        unsigned short reserved1        PACKED; /* 00: */
+        unsigned short rx_bad_len       PACKED; /* 02: */
+        unsigned short reserved2        PACKED; /* 04: */
+        unsigned long  tx_frames        PACKED; /* 06: */
+        unsigned long  tx_bytes PACKED; /* 0A: */
+        unsigned long  rx_frames        PACKED; /* 0E: */
+        unsigned long  rx_bytes PACKED; /* 12: */
+} ppp508_stats_t;
+
+/*----------------------------------------------------------------------------
+ * Adapter Error Statistics (returned by the PPP_READ_ERROR_STATS command).
+ */
+typedef struct  ppp_err_stats
+{
+        unsigned char    rx_overrun     PACKED; /* 00: Rx overrun errors */
+        unsigned char    rx_bad_crc     PACKED; /* 01: Rx CRC errors */
+        unsigned char    rx_abort       PACKED; /* 02: Rx aborted frames */
+        unsigned char    rx_lost        PACKED; /* 03: Rx frames lost */
+        unsigned char    tx_abort       PACKED; /* 04: Tx aborted frames */
+        unsigned char    tx_underrun    PACKED; /* 05: Tx underrun errors */
+        unsigned char    tx_missed_intr PACKED; /* 06: Tx underruns missed */
+        unsigned char    reserved       PACKED; /* 07: Tx underruns missed */
+        unsigned char    dcd_trans      PACKED; /* 08: DCD transitions */
+        unsigned char    cts_trans      PACKED; /* 09: CTS transitions */
+} ppp_err_stats_t;
+
+/*----------------------------------------------------------------------------
+ * Packet Statistics (returned by the PPP_READ_PACKET_STATS command).
+ */
+typedef struct  ppp_pkt_stats
+{
+        unsigned short rx_bad_header    PACKED; /* 00: */
+        unsigned short rx_prot_unknwn   PACKED; /* 02: */
+        unsigned short rx_too_large     PACKED; /* 04: */
+        unsigned short rx_lcp           PACKED; /* 06: */
+        unsigned short tx_lcp           PACKED; /* 08: */
+        unsigned short rx_ipcp          PACKED; /* 0A: */
+        unsigned short tx_ipcp          PACKED; /* 0C: */
+        unsigned short rx_ipxcp         PACKED; /* 0E: */
+        unsigned short tx_ipxcp         PACKED; /* 10: */
+        unsigned short rx_pap           PACKED; /* 12: */
+        unsigned short tx_pap           PACKED; /* 14: */
+        unsigned short rx_chap          PACKED; /* 16: */
+        unsigned short tx_chap          PACKED; /* 18: */
+        unsigned short rx_lqr           PACKED; /* 1A: */
+        unsigned short tx_lqr           PACKED; /* 1C: */
+        unsigned short rx_ip            PACKED; /* 1E: */
+        unsigned short tx_ip            PACKED; /* 20: */
+        unsigned short rx_ipx           PACKED; /* 22: */
+        unsigned short tx_ipx           PACKED; /* 24: */
+} ppp_pkt_stats_t;
+
+/*----------------------------------------------------------------------------
+ * LCP Statistics (returned by the PPP_READ_LCP_STATS command).
+ */
+typedef struct  ppp_lcp_stats
+{
+        unsigned short rx_unknown       PACKED; /* 00: unknown LCP type */
+        unsigned short rx_conf_rqst     PACKED; /* 02: Configure-Request */
+        unsigned short rx_conf_ack      PACKED; /* 04: Configure-Ack */
+        unsigned short rx_conf_nak      PACKED; /* 06: Configure-Nak */
+        unsigned short rx_conf_rej      PACKED; /* 08: Configure-Reject */
+        unsigned short rx_term_rqst     PACKED; /* 0A: Terminate-Request */
+        unsigned short rx_term_ack      PACKED; /* 0C: Terminate-Ack */
+        unsigned short rx_code_rej      PACKED; /* 0E: Code-Reject */
+        unsigned short rx_proto_rej     PACKED; /* 10: Protocol-Reject */
+        unsigned short rx_echo_rqst     PACKED; /* 12: Echo-Request */
+        unsigned short rx_echo_reply    PACKED; /* 14: Echo-Reply */
+        unsigned short rx_disc_rqst     PACKED; /* 16: Discard-Request */
+        unsigned short tx_conf_rqst     PACKED; /* 18: Configure-Request */
+        unsigned short tx_conf_ack      PACKED; /* 1A: Configure-Ack */
+        unsigned short tx_conf_nak      PACKED; /* 1C: Configure-Nak */
+        unsigned short tx_conf_rej      PACKED; /* 1E: Configure-Reject */
+        unsigned short tx_term_rqst     PACKED; /* 20: Terminate-Request */
+        unsigned short tx_term_ack      PACKED; /* 22: Terminate-Ack */
+        unsigned short tx_code_rej      PACKED; /* 24: Code-Reject */
+        unsigned short tx_proto_rej     PACKED; /* 26: Protocol-Reject */
+        unsigned short tx_echo_rqst     PACKED; /* 28: Echo-Request */
+        unsigned short tx_echo_reply    PACKED; /* 2A: Echo-Reply */
+        unsigned short tx_disc_rqst     PACKED; /* 2E: Discard-Request */
+        unsigned short rx_too_large     PACKED; /* 30: packets too large */
+        unsigned short rx_ack_inval     PACKED; /* 32: invalid Conf-Ack */
+        unsigned short rx_rej_inval     PACKED; /* 34: invalid Conf-Reject */
+        unsigned short rx_rej_badid     PACKED; /* 36: Conf-Reject w/bad ID */
+} ppp_lcp_stats_t;
+
+/*----------------------------------------------------------------------------
+ * Loopback Error Statistics (returned by the PPP_READ_LPBK_STATS command).
+ */
+typedef struct  ppp_lpbk_stats
+{
+        unsigned short conf_magic       PACKED; /* 00:  */
+        unsigned short loc_echo_rqst    PACKED; /* 02:  */
+        unsigned short rem_echo_rqst    PACKED; /* 04:  */
+        unsigned short loc_echo_reply   PACKED; /* 06:  */
+        unsigned short rem_echo_reply   PACKED; /* 08:  */
+        unsigned short loc_disc_rqst    PACKED; /* 0A:  */
+        unsigned short rem_disc_rqst    PACKED; /* 0C:  */
+        unsigned short echo_tx_collsn   PACKED; /* 0E:  */
+        unsigned short echo_rx_collsn   PACKED; /* 10:  */
+} ppp_lpbk_stats_t;
+
+/*----------------------------------------------------------------------------
+ * Protocol Statistics (returned by the PPP_READ_IPCP_STATS and
+ * PPP_READ_IPXCP_STATS commands).
+ */
+typedef struct  ppp_prot_stats
+{
+        unsigned short rx_unknown       PACKED; /* 00: unknown type */
+        unsigned short rx_conf_rqst     PACKED; /* 02: Configure-Request */
+        unsigned short rx_conf_ack      PACKED; /* 04: Configure-Ack */
+        unsigned short rx_conf_nak      PACKED; /* 06: Configure-Nak */
+        unsigned short rx_conf_rej      PACKED; /* 08: Configure-Reject */
+        unsigned short rx_term_rqst     PACKED; /* 0A: Terminate-Request */
+        unsigned short rx_term_ack      PACKED; /* 0C: Terminate-Ack */
+        unsigned short rx_code_rej      PACKED; /* 0E: Code-Reject */
+        unsigned short reserved         PACKED; /* 10: */
+        unsigned short tx_conf_rqst     PACKED; /* 12: Configure-Request */
+        unsigned short tx_conf_ack      PACKED; /* 14: Configure-Ack */
+        unsigned short tx_conf_nak      PACKED; /* 16: Configure-Nak */
+        unsigned short tx_conf_rej      PACKED; /* 18: Configure-Reject */
+        unsigned short tx_term_rqst     PACKED; /* 1A: Terminate-Request */
+        unsigned short tx_term_ack      PACKED; /* 1C: Terminate-Ack */
+        unsigned short tx_code_rej      PACKED; /* 1E: Code-Reject */
+        unsigned short rx_too_large     PACKED; /* 20: packets too large */
+        unsigned short rx_ack_inval     PACKED; /* 22: invalid Conf-Ack */
+        unsigned short rx_rej_inval     PACKED; /* 24: invalid Conf-Reject */
+        unsigned short rx_rej_badid     PACKED; /* 26: Conf-Reject w/bad ID */
+} ppp_prot_stats_t;
+
+/*----------------------------------------------------------------------------
+ * PAP Statistics (returned by the PPP_READ_PAP_STATS command).
+ */
+typedef struct  ppp_pap_stats
+{
+        unsigned short rx_unknown       PACKED; /* 00: unknown type */
+        unsigned short rx_auth_rqst     PACKED; /* 02: Authenticate-Request */
+        unsigned short rx_auth_ack      PACKED; /* 04: Authenticate-Ack */
+        unsigned short rx_auth_nak      PACKED; /* 06: Authenticate-Nak */
+        unsigned short reserved         PACKED; /* 08: */
+        unsigned short tx_auth_rqst     PACKED; /* 0A: Authenticate-Request */
+        unsigned short tx_auth_ack      PACKED; /* 0C: Authenticate-Ack */
+        unsigned short tx_auth_nak      PACKED; /* 0E: Authenticate-Nak */
+        unsigned short rx_too_large     PACKED; /* 10: packets too large */
+        unsigned short rx_bad_peerid    PACKED; /* 12: invalid peer ID */
+        unsigned short rx_bad_passwd    PACKED; /* 14: invalid password */
+} ppp_pap_stats_t;
+
+/*----------------------------------------------------------------------------
+ * CHAP Statistics (returned by the PPP_READ_CHAP_STATS command).
+ */
+typedef struct  ppp_chap_stats
+{
+        unsigned short rx_unknown       PACKED; /* 00: unknown type */
+        unsigned short rx_challenge     PACKED; /* 02: Authenticate-Request */
+        unsigned short rx_response      PACKED; /* 04: Authenticate-Ack */
+        unsigned short rx_success       PACKED; /* 06: Authenticate-Nak */
+        unsigned short rx_failure       PACKED; /* 08: Authenticate-Nak */
+        unsigned short reserved         PACKED; /* 0A: */
+        unsigned short tx_challenge     PACKED; /* 0C: Authenticate-Request */
+        unsigned short tx_response      PACKED; /* 0E: Authenticate-Ack */
+        unsigned short tx_success       PACKED; /* 10: Authenticate-Nak */
+        unsigned short tx_failure       PACKED; /* 12: Authenticate-Nak */
+        unsigned short rx_too_large     PACKED; /* 14: packets too large */
+        unsigned short rx_bad_peerid    PACKED; /* 16: invalid peer ID */
+        unsigned short rx_bad_passwd    PACKED; /* 18: invalid password */
+        unsigned short rx_bad_md5       PACKED; /* 1A: invalid MD5 format */
+        unsigned short rx_bad_resp      PACKED; /* 1C: invalid response */
+} ppp_chap_stats_t;
+
+/*----------------------------------------------------------------------------
+ * Connection Information (returned by the PPP_GET_CONNECTION_INFO command).
+ */
+typedef struct  ppp_conn_info
+{
+        unsigned short remote_mru       PACKED; /* 00:  */
+        unsigned char  ip_options       PACKED; /* 02:  */
+        unsigned char  ip_local[4]      PACKED; /* 03:  */
+        unsigned char  ip_remote[4]     PACKED; /* 07:  */
+        unsigned char  ipx_options      PACKED; /* 0B:  */
+        unsigned char  ipx_network[4]   PACKED; /* 0C:  */
+        unsigned char  ipx_local[6]     PACKED; /* 10:  */
+        unsigned char  ipx_remote[6]    PACKED; /* 16:  */
+        unsigned char  ipx_router[48]   PACKED; /* 1C:  */
+        unsigned char  auth_status      PACKED; /* 4C:  */
+        unsigned char  peer_id[0]       PACKED; /* 4D:  */
+} ppp_conn_info_t;
+
+/* Data structure for SET_TRIGGER_INTR command
+ */
+
+typedef struct ppp_intr_info{
+        unsigned char  i_enable         PACKED; /* 0 Interrupt enable bits */
+        unsigned char  irq              PACKED; /* 1 Irq number */
+        unsigned short timer_len        PACKED; /* 2 Timer delay */
+} ppp_intr_info_t;
+
+
+#define FT1_MONITOR_STATUS_CTRL                         0x80
+#define SET_FT1_MODE                                    0x81
+
+
+
+/* Special UDP drivers management commands */
+#define PPIPE_ENABLE_TRACING                            0x20
+#define PPIPE_DISABLE_TRACING                           0x21
+#define PPIPE_GET_TRACE_INFO                            0x22
+#define PPIPE_GET_IBA_DATA                              0x23
+#define PPIPE_KILL_BOARD                                0x24
+#define PPIPE_FT1_READ_STATUS                           0x25
+#define PPIPE_DRIVER_STAT_IFSEND                        0x26
+#define PPIPE_DRIVER_STAT_INTR                          0x27
+#define PPIPE_DRIVER_STAT_GEN                           0x28
+#define PPIPE_FLUSH_DRIVER_STATS                        0x29
+#define PPIPE_ROUTER_UP_TIME                            0x30
+
+#define DISABLE_TRACING                                 0x00
+#define TRACE_SIGNALLING_FRAMES                         0x01
+#define TRACE_DATA_FRAMES                               0x02
+
+
+
+#ifdef          _MSC_
+#  pragma       pack()
+#endif
+#endif  /* _SDLA_PPP_H */
diff --git a/include/linux/sdla_x25.h b/include/linux/sdla_x25.h
new file mode 100644
index 000000000000..57db980e27ad
--- /dev/null
+++ b/include/linux/sdla_x25.h
@@ -0,0 +1,772 @@
+/*****************************************************************************
+* sdla_x25.h    Sangoma X.25 firmware API definitions.
+*
+* Author:       Nenad Corbic    <ncorbic@sangoma.com>
+*
+* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+                2 of the License, or (at your option) any later version.
+* ============================================================================
+* Feb 28, 2000  Nenad Corbic    Updated for socket based x25api
+* Dec 13, 1996  Gene Kozin      Initial version
+*****************************************************************************/
+#ifndef _SDLA_X25_H
+#define _SDLA_X25_H
+
+/*----------------------------------------------------------------------------
+ * Notes:
+ * ------
+ * 1. All structures defined in this file are byte-alined.  
+ *      Compiler        Platform        
+ *      --------        --------
+ *      GNU C           Linux
+ *
+ */
+
+#ifndef PACKED
+#       define  PACKED  __attribute__((packed))
+#endif  /* PACKED */
+
+/****** CONSTANTS DEFINITIONS ***********************************************/
+
+#define X25_MAX_CHAN    255     /* max number of open X.25 circuits */
+#define X25_MAX_DATA    1024    /* max length of X.25 data buffer */
+/*
+ * X.25 shared memory layout.
+ */
+#define X25_MBOX_OFFS   0x16B0  /* general mailbox block */
+#define X25_RXMBOX_OFFS 0x1AD0  /* receive mailbox */
+#define X25_STATUS_OFFS 0x1EF0  /* X.25 status structure */
+#define X25_MB_VECTOR   0xE000  /* S514 mailbox window vecotr */
+#define X25_MISC_HDLC_BITS 0x1F00 /*X.25 miscallaneous HDLC bits */
+
+/* code levels */
+#define HDLC_LEVEL 0x01
+#define X25_LEVEL  0x02
+#define X25_AND_HDLC_LEVEL 0x03
+#define DO_HDLC_LEVEL_ERROR_CHECKING 0x04
+
+/****** DATA STRUCTURES *****************************************************/
+
+/*----------------------------------------------------------------------------
+ * X.25 Command Block.
+ */
+typedef struct X25Cmd
+{
+        unsigned char command   PACKED; /* command code */
+        unsigned short length   PACKED; /* transfer data length */
+        unsigned char result    PACKED; /* return code */
+        unsigned char pf        PACKED; /* P/F bit */
+        unsigned short lcn      PACKED; /* logical channel */
+        unsigned char qdm       PACKED; /* Q/D/M bits */
+        unsigned char cause     PACKED; /* cause field */
+        unsigned char diagn     PACKED; /* diagnostics */
+        unsigned char pktType   PACKED; /* packet type */
+        unsigned char resrv[4]  PACKED; /* reserved */
+} TX25Cmd;
+
+/*
+ * Defines for the 'command' field.
+ */
+/*----- General commands --------------*/
+#define X25_SET_GLOBAL_VARS     0x0B    /* set global variables */ 
+#define X25_READ_MODEM_STATUS   0x0C    /* read modem status */
+#define X25_READ_CODE_VERSION   0x15    /* read firmware version number */
+#define X25_TRACE_CONFIGURE     0x14    /* configure trace facility */
+#define X25_READ_TRACE_DATA     0x16    /* read trace data */
+#define X25_SET_INTERRUPT_MODE  0x17    /* set interrupt generation mode */
+#define X25_READ_INTERRUPT_MODE 0x18    /* read interrupt generation mode */
+/*----- HDLC-level commands -----------*/
+#define X25_HDLC_LINK_CONFIGURE 0x01    /* configure HDLC link level */   
+#define X25_HDLC_LINK_OPEN      0x02    /* open HDLC link */            
+#define X25_HDLC_LINK_CLOSE     0x03    /* close HDLC link */
+#define X25_HDLC_LINK_SETUP     0x04    /* set up HDLC link */ 
+#define X25_HDLC_LINK_DISC      0x05    /* disconnect DHLC link */
+#define X25_HDLC_LINK_STATUS    0x06    /* read DHLC link status */
+#define X25_HDLC_READ_STATS     0x07    /* read operational statistics */
+#define X25_HDLC_FLUSH_STATS    0x08    /* flush operational statistics */
+#define X25_HDLC_READ_COMM_ERR  0x09    /* read error statistics */
+#define X25_HDLC_FLUSH_COMM_ERR 0x0A    /* flush error statistics */
+#define X25_HDLC_FLUSH_BUFFERS  0x0D    /* flush HDLC-level data buffers */
+#define X25_HDLC_SPRVS_CNT_STAT 0x0F    /* read surervisory count status */
+#define X25_HDLC_SEND_UI_FRAME  0x10    /* send unnumbered information frame */
+#define X25_HDLC_WRITE          0x11    /* send HDLC information frame */
+#define X25_HDLC_READ           0x21    /* read HDLC information frame */
+#define X25_HDLC_READ_CONFIG    0x12    /* read HDLC configuration */
+#define X25_HDLC_SET_CONFIG     0x13    /* set HDLC configuration */
+#define SET_PROTOCOL_LEVEL      0x1F    /* set protocol level */
+/*----- X.25-level commands -----------*/
+#define X25_READ                0x22    /* read X.25 packet */
+#define X25_WRITE               0x23    /* send X.25 packet */
+#define X25_PLACE_CALL          0x30    /* place a call on SVC */
+#define X25_ACCEPT_CALL         0x31    /* accept incomming call */
+#define X25_CLEAR_CALL          0x32    /* clear call */
+#define X25_CLEAR_CONFRM        0x33    /* send clear confirmation packet */
+#define X25_RESET               0x34    /* send reset request packet */
+#define X25_RESET_CONFRM        0x35    /* send reset confirmation packet */
+#define X25_RESTART             0x36    /* send restart request packet */
+#define X25_RESTART_CONFRM      0x37    /* send restart confirmation packet */
+#define X25_INTERRUPT           0x38    /* send interrupt request packet */
+#define X25_INTERRUPT_CONFRM    0x39    /* send interrupt confirmation pkt */
+#define X25_REGISTRATION_RQST   0x3A    /* send registration request packet */
+#define X25_REGISTRATION_CONFRM 0x3B    /* send registration confirmation */
+#define X25_IS_DATA_AVAILABLE   0x40    /* querry receive queue */
+#define X25_INCOMMING_CALL_CTL  0x41    /* select incomming call options */
+#define X25_CONFIGURE_PVC       0x42    /* configure PVC */
+#define X25_GET_ACTIVE_CHANNELS 0x43    /* get a list of active circuits */
+#define X25_READ_CHANNEL_CONFIG 0x44    /* read virt. circuit configuration */
+#define X25_FLUSH_DATA_BUFFERS  0x45    /* flush X.25-level data buffers */
+#define X25_READ_HISTORY_TABLE  0x46    /* read asynchronous event log */
+#define X25_HISTORY_TABLE_CTL   0x47    /* control asynchronous event log */
+#define X25_GET_TX_D_BIT_STATUS 0x48    /* is packet with D-bit acknowleged */
+#define X25_READ_STATISTICS     0x49    /* read X.25-level statistics */
+#define X25_FLUSH_STATISTICS    0x4A    /* flush X.25-level statistics */
+#define X25_READ_CONFIGURATION  0x50    /* read HDLC & X.25 configuration */
+#define X25_SET_CONFIGURATION   0x51    /* set HDLC & X.25 configuration */
+
+/*
+ * Defines for the 'result' field.
+ */
+/*----- General results ---------------*/
+#define X25RES_OK               0x00
+#define X25RES_ERROR            0x01
+#define X25RES_LINK_NOT_IN_ABM  0x02    /* link is not in ABM mode */
+#define X25RES_LINK_CLOSED      0x03
+#define X25RES_INVAL_LENGTH     0x04
+#define X25RES_INVAL_CMD        0x05
+#define X25RES_UNNUMBERED_FRAME 0x06    /* unnunbered frame received */
+#define X25RES_FRM_REJECT_MODE  0x07    /* link is in Frame Reject mode */
+#define X25RES_MODEM_FAILURE    0x08    /* DCD and/or CTS dropped */
+#define X25RES_N2_RETRY_LIMIT   0x09    /* N2 retry limit has been exceeded */
+#define X25RES_INVAL_LCN        0x30    /* invalid logical channel number */
+#define X25RES_INVAL_STATE      0x31    /* channel is not in data xfer mode */
+#define X25RES_INVAL_DATA_LEN   0x32    /* invalid data length */
+#define X25RES_NOT_READY        0x33    /* no data available / buffers full */
+#define X25RES_NETWORK_DOWN     0x34
+#define X25RES_CHANNEL_IN_USE   0x35    /* there is data queued on this LCN */
+#define X25RES_REGST_NOT_SUPPRT 0x36    /* registration not supported */
+#define X25RES_INVAL_FORMAT     0x37    /* invalid packet format */
+#define X25RES_D_BIT_NOT_SUPPRT 0x38    /* D-bit pragmatics not supported */
+#define X25RES_FACIL_NOT_SUPPRT 0x39    /* Call facility not supported */
+#define X25RES_INVAL_CALL_ARG   0x3A    /* errorneous call arguments */
+#define X25RES_INVAL_CALL_DATA  0x3B    /* errorneous call user data */
+#define X25RES_ASYNC_PACKET     0x40    /* asynchronous packet received */
+#define X25RES_PROTO_VIOLATION  0x41    /* protocol violation occurred */
+#define X25RES_PKT_TIMEOUT      0x42    /* X.25 packet time out */
+#define X25RES_PKT_RETRY_LIMIT  0x43    /* X.25 packet retry limit exceeded */
+/*----- Command-dependent results -----*/
+#define X25RES_LINK_DISC        0x00    /* HDLC_LINK_STATUS */
+#define X25RES_LINK_IN_ABM      0x01    /* HDLC_LINK_STATUS */
+#define X25RES_NO_DATA          0x01    /* HDLC_READ/READ_TRACE_DATA*/
+#define X25RES_TRACE_INACTIVE   0x02    /* READ_TRACE_DATA */
+#define X25RES_LINK_IS_OPEN     0x01    /* HDLC_LINK_OPEN */
+#define X25RES_LINK_IS_DISC     0x02    /* HDLC_LINK_DISC */
+#define X25RES_LINK_IS_CLOSED   0x03    /* HDLC_LINK_CLOSE */
+#define X25RES_INVAL_PARAM      0x31    /* INCOMMING_CALL_CTL */
+#define X25RES_INVAL_CONFIG     0x35    /* REGISTR_RQST/CONFRM */
+
+/*
+ * Defines for the 'qdm_bits' field.
+ */
+#define X25CMD_Q_BIT_MASK       0x04
+#define X25CMD_D_BIT_MASK       0x02
+#define X25CMD_M_BIT_MASK       0x01
+
+/*
+ * Defines for the 'pkt_type' field.
+ */
+/*----- Asynchronous events ------*/
+#define ASE_CLEAR_RQST          0x02
+#define ASE_RESET_RQST          0x04
+#define ASE_RESTART_RQST        0x08
+#define ASE_INTERRUPT           0x10
+#define ASE_DTE_REGISTR_RQST    0x20
+#define ASE_CALL_RQST           0x30
+#define ASE_CALL_ACCEPTED       0x31
+#define ASE_CLEAR_CONFRM        0x32
+#define ASE_RESET_CONFRM        0x33
+#define ASE_RESTART_CONFRM      0x34
+#define ASE_INTERRUPT_CONFRM    0x35
+#define ASE_DCE_REGISTR_CONFRM  0x36
+#define ASE_DIAGNOSTIC          0x37
+#define ASE_CALL_AUTO_CLEAR     0x38
+#define AUTO_RESPONSE_FLAG      0x80
+/*----- Time-Out events ----------*/
+#define TOE_RESTART_RQST        0x03
+#define TOE_CALL_RQST           0x05
+#define TOE_CLEAR_RQST          0x08
+#define TOE_RESET_RQST          0x0A
+/*----- Protocol Violation events */
+#define PVE_CLEAR_RQST          0x32
+#define PVE_RESET_RQST          0x33
+#define PVE_RESTART_RQST        0x34
+#define PVE_DIAGNOSTIC          0x37
+
+#define INTR_ON_RX_FRAME            0x01
+#define INTR_ON_TX_FRAME            0x02
+#define INTR_ON_MODEM_STATUS_CHANGE 0x04
+#define INTR_ON_COMMAND_COMPLETE    0x08
+#define INTR_ON_X25_ASY_TRANSACTION 0x10
+#define INTR_ON_TIMER               0x40
+#define DIRECT_RX_INTR_USAGE        0x80
+
+#define NO_INTR_PENDING                 0x00
+#define RX_INTR_PENDING                 0x01    
+#define TX_INTR_PENDING                 0x02
+#define MODEM_INTR_PENDING              0x04
+#define COMMAND_COMPLETE_INTR_PENDING   0x08
+#define X25_ASY_TRANS_INTR_PENDING      0x10
+#define TIMER_INTR_PENDING              0x40
+
+/*----------------------------------------------------------------------------
+ * X.25 Mailbox.
+ *      This structure is located at offsets X25_MBOX_OFFS and X25_RXMBOX_OFFS
+ *      into shared memory window.
+ */
+typedef struct X25Mbox
+{
+        unsigned char opflag    PACKED; /* 00h: execution flag */
+        TX25Cmd cmd             PACKED; /* 01h: command block */
+        unsigned char data[1]   PACKED; /* 10h: data buffer */
+} TX25Mbox;
+
+/*----------------------------------------------------------------------------
+ * X.25 Time Stamp Structure.
+ */
+typedef struct X25TimeStamp
+{
+        unsigned char month     PACKED;
+        unsigned char date      PACKED;
+        unsigned char sec       PACKED;
+        unsigned char min       PACKED;
+        unsigned char hour      PACKED;
+} TX25TimeStamp;
+
+/*----------------------------------------------------------------------------
+ * X.25 Status Block.
+ *      This structure is located at offset X25_STATUS_OFF into shared memory
+ *      window.
+ */
+typedef struct X25Status
+{
+        unsigned short pvc_map  PACKED; /* 00h: PVC map */
+        unsigned short icc_map  PACKED; /* 02h: Incomming Chan. map */
+        unsigned short twc_map  PACKED; /* 04h: Two-way Cnan. map */
+        unsigned short ogc_map  PACKED; /* 06h: Outgoing Chan. map */
+        TX25TimeStamp tstamp    PACKED; /* 08h: timestamp (BCD) */
+        unsigned char iflags    PACKED; /* 0Dh: interrupt flags */
+        unsigned char imask     PACKED; /* 0Eh: interrupt mask  */
+        unsigned char resrv     PACKED; /* 0Eh: */
+        unsigned char gflags    PACKED; /* 10h: misc. HDLC/X25 flags */
+        unsigned char cflags[X25_MAX_CHAN] PACKED; /* channel status bytes */
+} TX25Status;
+
+/*
+ * Bitmasks for the 'iflags' field.
+ */
+#define X25_RX_INTR     0x01    /* receive interrupt */
+#define X25_TX_INTR     0x02    /* transmit interrupt */
+#define X25_MODEM_INTR  0x04    /* modem status interrupt (CTS/DCD) */
+#define X25_EVENT_INTR  0x10    /* asyncronous event encountered */
+#define X25_CMD_INTR    0x08    /* interface command complete */
+
+/*
+ * Bitmasks for the 'gflags' field.
+ */
+#define X25_HDLC_ABM    0x01    /* HDLC is in ABM mode */
+#define X25_RX_READY    0x02    /* X.25 data available */
+#define X25_TRACE_READY 0x08    /* trace data available */
+#define X25_EVENT_IND   0x20    /* asynchronous event indicator */
+#define X25_TX_READY    0x40    /* space is available in Tx buf.*/
+
+/*
+ * Bitmasks for the 'cflags' field.
+ */
+#define X25_XFER_MODE   0x80    /* channel is in data transfer mode */
+#define X25_TXWIN_OPEN  0x40    /* transmit window open */
+#define X25_RXBUF_MASK  0x3F    /* number of data buffers available */
+
+/*****************************************************************************
+ * Following definitions structurize contents of the TX25Mbox.data field for
+ * different X.25 interface commands.
+ ****************************************************************************/
+
+/* ---------------------------------------------------------------------------
+ * X25_SET_GLOBAL_VARS Command.
+ */
+typedef struct X25GlobalVars
+{
+        unsigned char resrv     PACKED; /* 00h: reserved */
+        unsigned char dtrCtl    PACKED; /* 01h: DTR control code */
+        unsigned char resErr    PACKED; /* 01h: '1' - reset modem error */
+} TX25GlobalVars;
+
+/*
+ * Defines for the 'dtrCtl' field.
+ */
+#define X25_RAISE_DTR   0x01
+#define X25_DROP_DTR    0x02
+
+/* ---------------------------------------------------------------------------
+ * X25_READ_MODEM_STATUS Command.
+ */
+typedef struct X25ModemStatus
+{
+        unsigned char   status  PACKED;         /* 00h: modem status */
+} TX25ModemStatus;
+
+/*
+ * Defines for the 'status' field.
+ */
+#define X25_CTS_MASK    0x20
+#define X25_DCD_MASK    0x08
+
+/* ---------------------------------------------------------------------------
+ * X25_HDLC_LINK_STATUS Command.
+ */
+typedef struct X25LinkStatus
+{
+        unsigned char txQueued  PACKED; /* 00h: queued Tx I-frames*/
+        unsigned char rxQueued  PACKED; /* 01h: queued Rx I-frames*/
+        unsigned char station   PACKED; /* 02h: DTE/DCE config. */
+        unsigned char reserved  PACKED; /* 03h: reserved */
+        unsigned char sfTally   PACKED; /* 04h: supervisory frame tally */
+} TX25LinkStatus;
+
+/*
+ * Defines for the 'station' field.
+ */
+#define X25_STATION_DTE 0x01    /* station configured as DTE */
+#define X25_STATION_DCE 0x02    /* station configured as DCE */
+
+/* ---------------------------------------------------------------------------
+ * X25_HDLC_READ_STATS Command.
+ */
+typedef struct HdlcStats
+{                                               /*      a number of ... */
+        unsigned short rxIFrames        PACKED; /* 00h: ready Rx I-frames */
+        unsigned short rxNoseq          PACKED; /* 02h: frms out-of-sequence */
+        unsigned short rxNodata         PACKED; /* 04h: I-frms without data */
+        unsigned short rxDiscarded      PACKED; /* 06h: discarded frames */
+        unsigned short rxTooLong        PACKED; /* 08h: frames too long */
+        unsigned short rxBadAddr        PACKED; /* 0Ah: frms with inval.addr*/
+        unsigned short txAcked          PACKED; /* 0Ch: acknowledged I-frms */
+        unsigned short txRetransm       PACKED; /* 0Eh: re-transmit. I-frms */
+        unsigned short t1Timeout        PACKED; /* 10h: T1 timeouts */
+        unsigned short rxSABM           PACKED; /* 12h: received SABM frames */
+        unsigned short rxDISC           PACKED; /* 14h: received DISC frames */
+        unsigned short rxDM             PACKED; /* 16h: received DM frames */
+        unsigned short rxFRMR           PACKED; /* 18h: FRMR frames received */
+        unsigned short txSABM           PACKED; /* 1Ah: transm. SABM frames*/
+        unsigned short txDISC           PACKED; /* 1Ch: transm. DISC frames*/
+        unsigned short txDM             PACKED; /* 1Eh: transm. DM frames */
+        unsigned short txFRMR           PACKED; /* 20h: transm. FRMR frames*/
+} THdlcStats;
+
+/* ---------------------------------------------------------------------------
+ * X25_HDLC_READ_COMM_ERR Command.
+ */
+typedef struct HdlcCommErr
+{                                               /*      a number of ... */
+        unsigned char rxOverrun         PACKED; /* 00h: Rx overrun errors */
+        unsigned char rxBadCrc          PACKED; /* 01h: Rx CRC errors */
+        unsigned char rxAborted         PACKED; /* 02h: Rx aborted frames */
+        unsigned char rxDropped         PACKED; /* 03h: frames lost */
+        unsigned char txAborted         PACKED; /* 04h: Tx aborted frames */
+        unsigned char txUnderrun        PACKED; /* 05h: Tx underrun errors */
+        unsigned char txMissIntr        PACKED; /* 06h: missed underrun ints */
+        unsigned char reserved          PACKED; /* 07h: reserved */
+        unsigned char droppedDCD        PACKED; /* 08h: times DCD dropped */
+        unsigned char droppedCTS        PACKED; /* 09h: times CTS dropped */
+} THdlcCommErr;
+
+/* ---------------------------------------------------------------------------
+ * X25_SET_CONFIGURATION & X25_READ_CONFIGURATION Commands.
+ */
+typedef struct X25Config
+{
+unsigned char baudRate          PACKED; /* 00h:  */
+        unsigned char t1                PACKED; /* 01h:  */
+        unsigned char t2                PACKED; /* 02h:  */
+        unsigned char n2                PACKED; /* 03h:  */
+        unsigned short hdlcMTU          PACKED; /* 04h:  */
+        unsigned char hdlcWindow        PACKED; /* 06h:  */
+        unsigned char t4                PACKED; /* 07h:  */
+        unsigned char autoModem         PACKED; /* 08h:  */
+        unsigned char autoHdlc          PACKED; /* 09h:  */
+        unsigned char hdlcOptions       PACKED; /* 0Ah:  */
+        unsigned char station           PACKED; /* 0Bh:  */
+        unsigned char pktWindow         PACKED; /* 0Ch:  */
+        unsigned short defPktSize       PACKED; /* 0Dh:  */
+        unsigned short pktMTU           PACKED; /* 0Fh:  */
+        unsigned short loPVC            PACKED; /* 11h:  */
+        unsigned short hiPVC            PACKED; /* 13h:  */
+        unsigned short loIncommingSVC   PACKED; /* 15h:  */
+        unsigned short hiIncommingSVC   PACKED; /* 17h:  */
+        unsigned short loTwoWaySVC      PACKED; /* 19h:  */
+        unsigned short hiTwoWaySVC      PACKED; /* 1Bh:  */
+        unsigned short loOutgoingSVC    PACKED; /* 1Dh:  */
+        unsigned short hiOutgoingSVC    PACKED; /* 1Fh:  */
+        unsigned short options          PACKED; /* 21h:  */
+        unsigned char responseOpt       PACKED; /* 23h:  */
+        unsigned short facil1           PACKED; /* 24h:  */
+        unsigned short facil2           PACKED; /* 26h:  */
+        unsigned short ccittFacil       PACKED; /* 28h:  */
+        unsigned short otherFacil       PACKED; /* 2Ah:  */
+        unsigned short ccittCompat      PACKED; /* 2Ch:  */
+        unsigned char t10t20            PACKED; /* 2Eh:  */
+        unsigned char t11t21            PACKED; /* 2Fh:  */
+        unsigned char t12t22            PACKED; /* 30h:  */
+        unsigned char t13t23            PACKED; /* 31h:  */
+        unsigned char t16t26            PACKED; /* 32H:  */
+        unsigned char t28               PACKED; /* 33h:  */
+        unsigned char r10r20            PACKED; /* 34h:  */
+        unsigned char r12r22            PACKED; /* 35h:  */
+        unsigned char r13r23            PACKED; /* 36h:  */
+} TX25Config;
+
+/* ---------------------------------------------------------------------------
+ * X25_READ_CHANNEL_CONFIG Command.
+ */
+typedef struct X25ChanAlloc                     /*----- Channel allocation -*/
+{
+        unsigned short loPVC            PACKED; /* 00h: lowest PVC number */
+        unsigned short hiPVC            PACKED; /* 02h: highest PVC number */
+        unsigned short loIncommingSVC   PACKED; /* 04h: lowest incoming SVC */
+        unsigned short hiIncommingSVC   PACKED; /* 06h: highest incoming SVC */
+        unsigned short loTwoWaySVC      PACKED; /* 08h: lowest two-way SVC */
+        unsigned short hiTwoWaySVC      PACKED; /* 0Ah: highest two-way SVC */
+        unsigned short loOutgoingSVC    PACKED; /* 0Ch: lowest outgoing SVC */
+        unsigned short hiOutgoingSVC    PACKED; /* 0Eh: highest outgoing SVC */
+} TX25ChanAlloc;
+
+typedef struct X25ChanCfg               /*------ Channel configuration -----*/
+{
+        unsigned char type      PACKED; /* 00h: channel type */
+        unsigned char txConf    PACKED; /* 01h: Tx packet and window sizes */
+        unsigned char rxConf    PACKED; /* 01h: Rx packet and window sizes */
+} TX25ChanCfg;
+
+/*
+ * Defines for the 'type' field.
+ */
+#define X25_PVC         0x01    /* PVC */
+#define X25_SVC_IN      0x03    /* Incoming SVC */
+#define X25_SVC_TWOWAY  0x07    /* Two-way SVC */
+#define X25_SVC_OUT     0x0B    /* Outgoing SVC */
+
+/*----------------------------------------------------------------------------
+ * X25_READ_STATISTICS Command.
+ */
+typedef struct X25Stats
+{                                               /* number of packets Tx/Rx'ed */
+        unsigned short txRestartRqst    PACKED; /* 00h: Restart Request */
+        unsigned short rxRestartRqst    PACKED; /* 02h: Restart Request */
+        unsigned short txRestartConf    PACKED; /* 04h: Restart Confirmation */
+        unsigned short rxRestartConf    PACKED; /* 06h: Restart Confirmation */
+        unsigned short txResetRqst      PACKED; /* 08h: Reset Request */
+        unsigned short rxResetRqst      PACKED; /* 0Ah: Reset Request */
+        unsigned short txResetConf      PACKED; /* 0Ch: Reset Confirmation */
+        unsigned short rxResetConf      PACKED; /* 0Eh: Reset Confirmation */
+        unsigned short txCallRequest    PACKED; /* 10h: Call Request */
+        unsigned short rxCallRequest    PACKED; /* 12h: Call Request */
+        unsigned short txCallAccept     PACKED; /* 14h: Call Accept */
+        unsigned short rxCallAccept     PACKED; /* 16h: Call Accept */
+        unsigned short txClearRqst      PACKED; /* 18h: Clear Request */
+        unsigned short rxClearRqst      PACKED; /* 1Ah: Clear Request */
+        unsigned short txClearConf      PACKED; /* 1Ch: Clear Confirmation */
+        unsigned short rxClearConf      PACKED; /* 1Eh: Clear Confirmation */
+        unsigned short txDiagnostic     PACKED; /* 20h: Diagnostic */
+        unsigned short rxDiagnostic     PACKED; /* 22h: Diagnostic */
+        unsigned short txRegRqst        PACKED; /* 24h: Registration Request */
+        unsigned short rxRegRqst        PACKED; /* 26h: Registration Request */
+        unsigned short txRegConf        PACKED; /* 28h: Registration Confirm.*/
+        unsigned short rxRegConf        PACKED; /* 2Ah: Registration Confirm.*/
+        unsigned short txInterrupt      PACKED; /* 2Ch: Interrupt */
+        unsigned short rxInterrupt      PACKED; /* 2Eh: Interrupt */
+        unsigned short txIntrConf       PACKED; /* 30h: Interrupt Confirm. */
+        unsigned short rxIntrConf       PACKED; /* 32h: Interrupt Confirm. */
+        unsigned short txData           PACKED; /* 34h: Data */
+        unsigned short rxData           PACKED; /* 36h: Data */
+        unsigned short txRR             PACKED; /* 38h: RR */
+        unsigned short rxRR             PACKED; /* 3Ah: RR */
+        unsigned short txRNR            PACKED; /* 3Ch: RNR */
+        unsigned short rxRNR            PACKED; /* 3Eh: RNR */
+} TX25Stats;
+
+/*----------------------------------------------------------------------------
+ * X25_READ_HISTORY_TABLE Command.
+ */
+typedef struct X25EventLog
+{
+        unsigned char   type    PACKED; /* 00h: transaction type */
+        unsigned short  lcn     PACKED; /* 01h: logical channel num */
+        unsigned char   packet  PACKED; /* 03h: async packet type */
+        unsigned char   cause   PACKED; /* 04h: X.25 cause field */
+        unsigned char   diag    PACKED; /* 05h: X.25 diag field */
+        TX25TimeStamp   ts      PACKED; /* 06h: time stamp */
+} TX25EventLog;
+
+/*
+ * Defines for the 'type' field.
+ */
+#define X25LOG_INCOMMING        0x00
+#define X25LOG_APPLICATION      0x01
+#define X25LOG_AUTOMATIC        0x02
+#define X25LOG_ERROR            0x04
+#define X25LOG_TIMEOUT          0x08
+#define X25LOG_RECOVERY         0x10
+
+/*
+ * Defines for the 'packet' field.
+ */
+#define X25LOG_CALL_RQST        0x0B
+#define X25LOG_CALL_ACCEPTED    0x0F
+#define X25LOG_CLEAR_RQST       0x13
+#define X25LOG_CLEAR_CONFRM     0x17
+#define X25LOG_RESET_RQST       0x1B
+#define X25LOG_RESET_CONFRM     0x1F
+#define X25LOG_RESTART_RQST     0xFB
+#define X25LOG_RESTART_COMFRM   0xFF
+#define X25LOG_DIAGNOSTIC       0xF1
+#define X25LOG_DTE_REG_RQST     0xF3
+#define X25LOG_DTE_REG_COMFRM   0xF7
+
+/* ---------------------------------------------------------------------------
+ * X25_TRACE_CONFIGURE Command.
+ */
+typedef struct X25TraceCfg
+{
+        unsigned char flags     PACKED; /* 00h: trace configuration flags */
+        unsigned char timeout   PACKED; /* 01h: timeout for trace delay mode*/
+} TX25TraceCfg;
+
+/*
+ * Defines for the 'flags' field.
+ */
+#define X25_TRC_ENABLE          0x01    /* bit0: '1' - trace enabled */
+#define X25_TRC_TIMESTAMP       0x02    /* bit1: '1' - time stamping enabled*/
+#define X25_TRC_DELAY           0x04    /* bit2: '1' - trace delay enabled */
+#define X25_TRC_DATA            0x08    /* bit3: '1' - trace data packets */
+#define X25_TRC_SUPERVISORY     0x10    /* bit4: '1' - trace suprvisory pkts*/
+#define X25_TRC_ASYNCHRONOUS    0x20    /* bit5: '1' - trace asynch. packets*/
+#define X25_TRC_HDLC            0x40    /* bit6: '1' - trace all packets */
+#define X25_TRC_READ            0x80    /* bit7: '1' - get current config. */
+
+/* ---------------------------------------------------------------------------
+ * X25_READ_TRACE_DATA Command.
+ */
+typedef struct X25Trace                 /*----- Trace data structure -------*/
+{
+        unsigned short length   PACKED; /* 00h: trace data length */
+        unsigned char type      PACKED; /* 02h: trace type */
+        unsigned char lost_cnt  PACKED; /* 03h: N of traces lost */
+        TX25TimeStamp tstamp    PACKED; /* 04h: mon/date/sec/min/hour */
+        unsigned short millisec PACKED; /* 09h: ms time stamp */
+        unsigned char data[0]   PACKED; /* 0Bh: traced frame */
+} TX25Trace;
+
+/*
+ * Defines for the 'type' field.
+ */
+#define X25_TRC_TYPE_MASK       0x0F    /* bits 0..3: trace type */
+#define X25_TRC_TYPE_RX_FRAME   0x00    /* received frame trace */
+#define X25_TRC_TYPE_TX_FRAME   0x01    /* transmitted frame */
+#define X25_TRC_TYPE_ERR_FRAME  0x02    /* error frame */
+
+#define X25_TRC_ERROR_MASK      0xF0    /* bits 4..7: error code */
+#define X25_TRCERR_RX_ABORT     0x10    /* receive abort error */
+#define X25_TRCERR_RX_BADCRC    0x20    /* receive CRC error */
+#define X25_TRCERR_RX_OVERRUN   0x30    /* receiver overrun error */
+#define X25_TRCERR_RX_TOO_LONG  0x40    /* excessive frame length error */
+#define X25_TRCERR_TX_ABORT     0x70    /* aborted frame transmittion error */
+#define X25_TRCERR_TX_UNDERRUN  0x80    /* transmit underrun error */
+
+/*****************************************************************************
+ * Following definitions describe HDLC frame and X.25 packet formats.
+ ****************************************************************************/
+
+typedef struct HDLCFrame                /*----- DHLC Frame Format ----------*/
+{
+        unsigned char addr      PACKED; /* address field */
+        unsigned char cntl      PACKED; /* control field */
+        unsigned char data[0]   PACKED;
+} THDLCFrame;
+
+typedef struct X25Pkt                   /*----- X.25 Paket Format ----------*/
+{
+        unsigned char lcn_hi    PACKED; /* 4 MSB of Logical Channel Number */
+        unsigned char lcn_lo    PACKED; /* 8 LSB of Logical Channel Number */
+        unsigned char type      PACKED;
+        unsigned char data[0]   PACKED;
+} TX25Pkt;
+
+/*
+ * Defines for the 'lcn_hi' field.
+ */
+#define X25_Q_BIT_MASK          0x80    /* Data Qualifier Bit mask */
+#define X25_D_BIT_MASK          0x40    /* Delivery Confirmation Bit mask */
+#define X25_M_BITS_MASK         0x30    /* Modulo Bits mask */
+#define X25_LCN_MSB_MASK        0x0F    /* LCN most significant bits mask */
+
+/*
+ * Defines for the 'type' field.
+ */
+#define X25PKT_DATA             0x01    /* Data packet mask */
+#define X25PKT_SUPERVISORY      0x02    /* Supervisory packet mask */
+#define X25PKT_CALL_RQST        0x0B    /* Call Request/Incoming */
+#define X25PKT_CALL_ACCEPTED    0x0F    /* Call Accepted/Connected */
+#define X25PKT_CLEAR_RQST       0x13    /* Clear Request/Indication */
+#define X25PKT_CLEAR_CONFRM     0x17    /* Clear Confirmation */
+#define X25PKT_RESET_RQST       0x1B    /* Reset Request/Indication */
+#define X25PKT_RESET_CONFRM     0x1F    /* Reset Confirmation */
+#define X25PKT_RESTART_RQST     0xFB    /* Restart Request/Indication */
+#define X25PKT_RESTART_CONFRM   0xFF    /* Restart Confirmation */
+#define X25PKT_INTERRUPT        0x23    /* Interrupt */
+#define X25PKT_INTERRUPT_CONFRM 0x27    /* Interrupt Confirmation */
+#define X25PKT_DIAGNOSTIC       0xF1    /* Diagnostic */
+#define X25PKT_REGISTR_RQST     0xF3    /* Registration Request */
+#define X25PKT_REGISTR_CONFRM   0xF7    /* Registration Confirmation */
+#define X25PKT_RR_MASKED        0x01    /* Receive Ready packet after masking */
+#define X25PKT_RNR_MASKED       0x05    /* Receive Not Ready after masking  */
+
+
+typedef struct {
+        TX25Cmd cmd             PACKED;
+        char data[X25_MAX_DATA] PACKED;
+} mbox_cmd_t;
+
+
+typedef struct {
+        unsigned char  qdm      PACKED; /* Q/D/M bits */
+        unsigned char  cause    PACKED; /* cause field */
+        unsigned char  diagn    PACKED; /* diagnostics */
+        unsigned char  pktType  PACKED;
+        unsigned short length   PACKED;
+        unsigned char  result   PACKED;
+        unsigned short lcn      PACKED;
+        char reserved[7]        PACKED;
+}x25api_hdr_t;
+
+
+typedef struct {
+        x25api_hdr_t hdr        PACKED;
+        char data[X25_MAX_DATA] PACKED;
+}x25api_t;
+
+
+/* 
+ * XPIPEMON Definitions
+ */
+
+/* valid ip_protocol for UDP management */
+#define UDPMGMT_UDP_PROTOCOL 0x11
+#define UDPMGMT_XPIPE_SIGNATURE         "XLINK8ND"
+#define UDPMGMT_DRVRSTATS_SIGNATURE     "DRVSTATS"
+
+/* values for request/reply byte */
+#define UDPMGMT_REQUEST 0x01
+#define UDPMGMT_REPLY   0x02
+#define UDP_OFFSET      12
+
+
+typedef struct {
+        unsigned char opp_flag  PACKED; /* the opp flag */
+        unsigned char command   PACKED; /* command code */
+        unsigned short length   PACKED; /* transfer data length */
+        unsigned char result    PACKED; /* return code */
+        unsigned char pf        PACKED; /* P/F bit */
+        unsigned short lcn      PACKED; /* logical channel */
+        unsigned char qdm       PACKED; /* Q/D/M bits */
+        unsigned char cause     PACKED; /* cause field */
+        unsigned char diagn     PACKED; /* diagnostics */
+        unsigned char pktType   PACKED; /* packet type */
+        unsigned char resrv[4]  PACKED; /* reserved */
+} cblock_t;
+
+typedef struct {
+        ip_pkt_t                ip_pkt          PACKED;
+        udp_pkt_t               udp_pkt         PACKED;
+        wp_mgmt_t               wp_mgmt         PACKED;
+        cblock_t                cblock          PACKED;
+        unsigned char           data[4080]      PACKED;
+} x25_udp_pkt_t;
+
+
+typedef struct read_hdlc_stat {
+        unsigned short inf_frames_rx_ok PACKED;
+        unsigned short inf_frames_rx_out_of_seq PACKED;
+        unsigned short inf_frames_rx_no_data PACKED;
+        unsigned short inf_frames_rx_dropped PACKED;
+        unsigned short inf_frames_rx_data_too_long PACKED;
+        unsigned short inf_frames_rx_invalid_addr PACKED;
+        unsigned short inf_frames_tx_ok PACKED;
+        unsigned short inf_frames_tx_retransmit PACKED;
+        unsigned short T1_timeouts PACKED;
+        unsigned short SABM_frames_rx PACKED;
+        unsigned short DISC_frames_rx PACKED;
+        unsigned short DM_frames_rx PACKED;
+        unsigned short FRMR_frames_rx PACKED;
+        unsigned short SABM_frames_tx PACKED;
+        unsigned short DISC_frames_tx PACKED;
+        unsigned short DM_frames_tx PACKED;
+        unsigned short FRMR_frames_tx PACKED;
+} read_hdlc_stat_t;
+
+typedef struct read_comms_err_stats{
+        unsigned char overrun_err_rx PACKED;
+        unsigned char CRC_err PACKED;
+        unsigned char abort_frames_rx PACKED;
+        unsigned char frames_dropped_buf_full PACKED;
+        unsigned char abort_frames_tx PACKED;
+        unsigned char transmit_underruns PACKED;
+        unsigned char missed_tx_underruns_intr PACKED;
+        unsigned char reserved PACKED;
+        unsigned char DCD_drop PACKED;
+        unsigned char CTS_drop PACKED;
+} read_comms_err_stats_t;
+
+typedef struct trace_data {
+        unsigned short length PACKED;
+        unsigned char  type PACKED;
+        unsigned char  trace_dropped PACKED;
+        unsigned char  reserved[5] PACKED;
+        unsigned short timestamp PACKED;
+        unsigned char  data PACKED;
+} trace_data_t;
+
+enum {UDP_XPIPE_TYPE};
+
+#define XPIPE_ENABLE_TRACING                    0x14
+#define XPIPE_DISABLE_TRACING                   0x14
+#define XPIPE_GET_TRACE_INFO                    0x16
+#define XPIPE_FT1_READ_STATUS                   0x74
+#define XPIPE_DRIVER_STAT_IFSEND                0x75
+#define XPIPE_DRIVER_STAT_INTR                  0x76
+#define XPIPE_DRIVER_STAT_GEN                   0x77
+#define XPIPE_FLUSH_DRIVER_STATS                0x78
+#define XPIPE_ROUTER_UP_TIME                    0x79        
+#define XPIPE_SET_FT1_MODE                      0x81
+#define XPIPE_FT1_STATUS_CTRL                   0x80
+
+
+/* error messages */
+#define NO_BUFFS_OR_CLOSED_WIN  0x33
+#define DATA_LENGTH_TOO_BIG     0x32
+#define NO_DATA_AVAILABLE       0x33
+#define Z80_TIMEOUT_ERROR       0x0a   
+#define NO_BUFFS                0x08
+
+
+/* Trace options */
+#define TRACE_DEFAULT           0x03
+#define TRACE_SUPERVISOR_FRMS   0x10
+#define TRACE_ASYNC_FRMS        0x20
+#define TRACE_ALL_HDLC_FRMS     0x40
+#define TRACE_DATA_FRMS         0x08
+
+
+#endif  /* _SDLA_X25_H */
diff --git a/include/linux/sdladrv.h b/include/linux/sdladrv.h
new file mode 100644
index 000000000000..78f634007fc6
--- /dev/null
+++ b/include/linux/sdladrv.h
@@ -0,0 +1,70 @@
+/*****************************************************************************
+* sdladrv.h     SDLA Support Module.  Kernel API Definitions.
+*
+* Author:       Gideon Hack     
+*
+* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Jun 02, 1999  Gideon Hack     Added support for the S514 PCI adapter.
+* Dec 11, 1996  Gene Kozin      Complete overhaul.
+* Oct 17, 1996  Gene Kozin      Minor bug fixes.
+* Jun 12, 1996  Gene Kozin      Added support for S503 card.
+* Dec 06, 1995  Gene Kozin      Initial version.
+*****************************************************************************/
+#ifndef _SDLADRV_H
+#define _SDLADRV_H
+
+
+#define SDLA_MAXIORANGE 4       /* maximum I/O port range */
+#define SDLA_WINDOWSIZE 0x2000  /* default dual-port memory window size */
+/****** Data Structures *****************************************************/
+
+/*----------------------------------------------------------------------------
+ * Adapter hardware configuration. Pointer to this structure is passed to all
+ * APIs.
+ */
+typedef struct sdlahw
+{
+        unsigned type;                  /* adapter type */
+        unsigned fwid;                  /* firmware ID */
+        unsigned port;                  /* adapter I/O port base */
+        int irq;                        /* interrupt request level */
+        char S514_cpu_no[1];            /* PCI CPU Number */
+        unsigned char S514_slot_no;     /* PCI Slot Number */
+        char auto_pci_cfg;              /* Autodetect PCI Slot */
+        struct pci_dev *pci_dev;        /* PCI device */
+        void * dpmbase;                 /* dual-port memory base */
+        unsigned dpmsize;               /* dual-port memory size */
+        unsigned pclk;                  /* CPU clock rate, kHz */
+        unsigned long memory;           /* memory size */
+        unsigned long vector;           /* local offset of the DPM window */
+        unsigned io_range;              /* I/O port range */
+        unsigned char regs[SDLA_MAXIORANGE]; /* was written to registers */
+        unsigned reserved[5];
+} sdlahw_t;
+
+/****** Function Prototypes *************************************************/
+
+extern int sdla_setup   (sdlahw_t* hw, void* sfm, unsigned len);
+extern int sdla_down    (sdlahw_t* hw);
+extern int sdla_inten   (sdlahw_t* hw);
+extern int sdla_intde   (sdlahw_t* hw);
+extern int sdla_intack  (sdlahw_t* hw);
+extern void S514_intack  (sdlahw_t* hw, u32 int_status);
+extern void read_S514_int_stat (sdlahw_t* hw, u32* int_status);
+extern int sdla_intr    (sdlahw_t* hw);
+extern int sdla_mapmem  (sdlahw_t* hw, unsigned long addr);
+extern int sdla_peek    (sdlahw_t* hw, unsigned long addr, void* buf,
+                         unsigned len);
+extern int sdla_poke    (sdlahw_t* hw, unsigned long addr, void* buf,
+                         unsigned len);
+extern int sdla_exec    (void* opflag);
+
+extern unsigned wanpipe_hw_probe(void);
+
+#endif  /* _SDLADRV_H */
diff --git a/include/linux/sdlapci.h b/include/linux/sdlapci.h
new file mode 100644
index 000000000000..6f7c904f188d
--- /dev/null
+++ b/include/linux/sdlapci.h
@@ -0,0 +1,72 @@
+/*****************************************************************************
+* sdlapci.h     WANPIPE(tm) Multiprotocol WAN Link Driver.
+*               Definitions for the SDLA PCI adapter.
+*
+* Author:       Gideon Hack     <ghack@sangoma.com>
+*
+* Copyright:    (c) 1999-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Jun 02, 1999  Gideon Hack     Initial version.
+*****************************************************************************/
+#ifndef _SDLAPCI_H
+#define _SDLAPCI_H
+
+/****** Defines *************************************************************/
+
+/* Definitions for identifying and finding S514 PCI adapters */
+#define V3_VENDOR_ID            0x11B0          /* V3 vendor ID number */
+#define V3_DEVICE_ID            0x0002          /* V3 device ID number */
+#define SANGOMA_SUBSYS_VENDOR   0x4753          /* ID for Sangoma */
+#define PCI_DEV_SLOT_MASK       0x1F            /* mask for slot numbering */
+#define PCI_IRQ_NOT_ALLOCATED   0xFF            /* interrupt line for no IRQ */
+
+/* Local PCI register offsets */ 
+#define PCI_VENDOR_ID_WORD      0x00            /* vendor ID */
+#define PCI_IO_BASE_DWORD       0x10            /* IO base */   
+#define PCI_MEM_BASE0_DWORD     0x14            /* memory base - apperture 0 */
+#define PCI_MEM_BASE1_DWORD     0x18            /* memory base - apperture 1 */
+#define PCI_SUBSYS_VENDOR_WORD  0x2C            /* subsystem vendor ID */
+#define PCI_INT_LINE_BYTE       0x3C            /* interrupt line */
+#define PCI_INT_PIN_BYTE        0x3D            /* interrupt pin */
+#define PCI_MAP0_DWORD          0x40            /* PCI to local bus address 0 */
+#define PCI_MAP1_DWORD          0x44            /* PCI to local bus address 1 */
+#define PCI_INT_STATUS          0x48            /* interrupt status */
+#define PCI_INT_CONFIG          0x4C            /* interrupt configuration */
+  
+/* Local PCI register usage */
+#define PCI_MEMORY_ENABLE       0x00000003      /* enable PCI memory */
+#define PCI_CPU_A_MEM_DISABLE   0x00000002      /* disable CPU A memory */
+#define PCI_CPU_B_MEM_DISABLE   0x00100002      /* disable CPU B memory */
+#define PCI_ENABLE_IRQ_CPU_A    0x005A0004      /* enable IRQ for CPU A */
+#define PCI_ENABLE_IRQ_CPU_B    0x005A0008      /* enable IRQ for CPU B */
+#define PCI_DISABLE_IRQ_CPU_A   0x00000004      /* disable IRQ for CPU A */
+#define PCI_DISABLE_IRQ_CPU_B   0x00000008      /* disable IRQ for CPU B */
+ 
+/* Setting for the Interrupt Status register */  
+#define IRQ_CPU_A               0x04            /* IRQ for CPU A */
+#define IRQ_CPU_B               0x08            /* IRQ for CPU B */
+
+/* The maximum size of the S514 memory */
+#define MAX_SIZEOF_S514_MEMORY  (256 * 1024)
+
+/* S514 control register offsets within the memory address space */
+#define S514_CTRL_REG_BYTE      0x80000
+ 
+/* S514 adapter control bytes */
+#define S514_CPU_HALT           0x00
+#define S514_CPU_START          0x01
+
+/* The maximum number of S514 adapters supported */
+#define MAX_S514_CARDS          20      
+
+#define PCI_CARD_TYPE           0x2E
+#define S514_DUAL_CPU           0x12
+#define S514_SINGLE_CPU         0x11
+
+#endif  /* _SDLAPCI_H */
+
diff --git a/include/linux/sdlasfm.h b/include/linux/sdlasfm.h
new file mode 100644
index 000000000000..94aaa8ada667
--- /dev/null
+++ b/include/linux/sdlasfm.h
@@ -0,0 +1,104 @@
+/*****************************************************************************
+* sdlasfm.h     WANPIPE(tm) Multiprotocol WAN Link Driver.
+*               Definitions for the SDLA Firmware Module (SFM).
+*
+* Author:       Gideon Hack     
+*
+* Copyright:    (c) 1995-1999 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Jun 02, 1999  Gideon Hack     Added support for the S514 adapter.
+* Dec 11, 1996  Gene Kozin      Cosmetic changes
+* Apr 16, 1996  Gene Kozin      Changed adapter & firmware IDs. Version 2
+* Dec 15, 1995  Gene Kozin      Structures chaned
+* Nov 09, 1995  Gene Kozin      Initial version.
+*****************************************************************************/
+#ifndef _SDLASFM_H
+#define _SDLASFM_H
+
+/****** Defines *************************************************************/
+
+#define SFM_VERSION     2
+#define SFM_SIGNATURE   "SFM - Sangoma SDLA Firmware Module"
+
+/* min/max */
+#define SFM_IMAGE_SIZE  0x8000  /* max size of SDLA code image file */
+#define SFM_DESCR_LEN   256     /* max length of description string */
+#define SFM_MAX_SDLA    16      /* max number of compatible adapters */
+
+/* Adapter types */
+#define SDLA_S502A      5020
+#define SDLA_S502E      5021
+#define SDLA_S503       5030
+#define SDLA_S508       5080
+#define SDLA_S507       5070
+#define SDLA_S509       5090
+#define SDLA_S514       5140
+
+/* S514 PCI adapter CPU numbers */
+#define S514_CPU_A      'A'
+#define S514_CPU_B      'B'
+
+
+/* Firmware identification numbers:
+ *    0  ..  999        Test & Diagnostics
+ *  1000 .. 1999        Streaming HDLC
+ *  2000 .. 2999        Bisync
+ *  3000 .. 3999        SDLC
+ *  4000 .. 4999        HDLC
+ *  5000 .. 5999        X.25
+ *  6000 .. 6999        Frame Relay
+ *  7000 .. 7999        PPP
+ *  8000 .. 8999        Cisco HDLC
+ */
+#define SFID_CALIB502    200
+#define SFID_STRM502    1200
+#define SFID_STRM508    1800
+#define SFID_BSC502     2200
+#define SFID_SDLC502    3200
+#define SFID_HDLC502    4200
+#define SFID_HDLC508    4800
+#define SFID_X25_502    5200
+#define SFID_X25_508    5800
+#define SFID_FR502      6200
+#define SFID_FR508      6800
+#define SFID_PPP502     7200
+#define SFID_PPP508     7800
+#define SFID_PPP514     7140
+#define SFID_CHDLC508   8800
+#define SFID_CHDLC514   8140
+
+/****** Data Types **********************************************************/
+
+typedef struct  sfm_info                /* firmware module information */
+{
+        unsigned short  codeid;         /* firmware ID */
+        unsigned short  version;        /* firmaware version number */
+        unsigned short  adapter[SFM_MAX_SDLA]; /* compatible adapter types */
+        unsigned long   memsize;        /* minimum memory size */
+        unsigned short  reserved[2];    /* reserved */
+        unsigned short  startoffs;      /* entry point offset */
+        unsigned short  winoffs;        /* dual-port memory window offset */
+        unsigned short  codeoffs;       /* code load offset */
+        unsigned short  codesize;       /* code size */
+        unsigned short  dataoffs;       /* configuration data load offset */
+        unsigned short  datasize;       /* configuration data size */
+} sfm_info_t;
+
+typedef struct sfm                      /* SDLA firmware file structire */
+{
+        char            signature[80];  /* SFM file signature */
+        unsigned short  version;        /* file format version */
+        unsigned short  checksum;       /* info + image */
+        unsigned short  reserved[6];    /* reserved */
+        char            descr[SFM_DESCR_LEN]; /* description string */
+        sfm_info_t      info;           /* firmware module info */
+        unsigned char   image[1];       /* code image (variable size) */
+} sfm_t;
+
+#endif  /* _SDLASFM_H */
+
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
new file mode 100644
index 000000000000..3a2702bbb1d6
--- /dev/null
+++ b/include/linux/seccomp.h
@@ -0,0 +1,34 @@
+#ifndef _LINUX_SECCOMP_H
+#define _LINUX_SECCOMP_H
+
+#include <linux/config.h>
+
+#ifdef CONFIG_SECCOMP
+
+#define NR_SECCOMP_MODES 1
+
+#include <linux/thread_info.h>
+#include <asm/seccomp.h>
+
+typedef struct { int mode; } seccomp_t;
+
+extern void __secure_computing(int);
+static inline void secure_computing(int this_syscall)
+{
+        if (unlikely(test_thread_flag(TIF_SECCOMP)))
+                __secure_computing(this_syscall);
+}
+
+#else /* CONFIG_SECCOMP */
+
+#if (__GNUC__ > 2)
+  typedef struct { } seccomp_t;
+#else
+  typedef struct { int gcc_is_buggy; } seccomp_t;
+#endif
+
+#define secure_computing(x) do { } while (0)
+
+#endif /* CONFIG_SECCOMP */
+
+#endif /* _LINUX_SECCOMP_H */
diff --git a/include/linux/securebits.h b/include/linux/securebits.h
new file mode 100644
index 000000000000..5b0617840fa4
--- /dev/null
+++ b/include/linux/securebits.h
@@ -0,0 +1,30 @@
+#ifndef _LINUX_SECUREBITS_H
+#define _LINUX_SECUREBITS_H 1
+
+#define SECUREBITS_DEFAULT 0x00000000
+
+extern unsigned securebits;
+
+/* When set UID 0 has no special privileges. When unset, we support
+   inheritance of root-permissions and suid-root executable under
+   compatibility mode. We raise the effective and inheritable bitmasks
+   *of the executable file* if the effective uid of the new process is
+   0. If the real uid is 0, we raise the inheritable bitmask of the
+   executable file. */
+#define SECURE_NOROOT            0
+
+/* When set, setuid to/from uid 0 does not trigger capability-"fixes"
+   to be compatible with old programs relying on set*uid to loose
+   privileges. When unset, setuid doesn't change privileges. */
+#define SECURE_NO_SETUID_FIXUP   2
+
+/* Each securesetting is implemented using two bits. One bit specify
+   whether the setting is on or off. The other bit specify whether the
+   setting is fixed or not. A setting which is fixed cannot be changed
+   from user-level. */
+
+#define issecure(X) ( (1 << (X+1)) & SECUREBITS_DEFAULT ?       \
+                      (1 << (X)) & SECUREBITS_DEFAULT :         \
+                      (1 << (X)) & securebits )
+
+#endif /* !_LINUX_SECUREBITS_H */
diff --git a/include/linux/security.h b/include/linux/security.h
new file mode 100644
index 000000000000..b42095a68b1c
--- /dev/null
+++ b/include/linux/security.h
@@ -0,0 +1,2858 @@
+/*
+ * Linux Security plug
+ *
+ * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
+ * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
+ * Copyright (C) 2001 James Morris <jmorris@intercode.com.au>
+ * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group)
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      Due to this file being licensed under the GPL there is controversy over
+ *      whether this permits you to write a module that #includes this file
+ *      without placing your module under the GPL.  Please consult a lawyer for
+ *      advice before doing this.
+ *
+ */
+
+#ifndef __LINUX_SECURITY_H
+#define __LINUX_SECURITY_H
+
+#include <linux/fs.h>
+#include <linux/binfmts.h>
+#include <linux/signal.h>
+#include <linux/resource.h>
+#include <linux/sem.h>
+#include <linux/shm.h>
+#include <linux/msg.h>
+#include <linux/sched.h>
+
+struct ctl_table;
+
+/*
+ * These functions are in security/capability.c and are used
+ * as the default capabilities functions
+ */
+extern int cap_capable (struct task_struct *tsk, int cap);
+extern int cap_settime (struct timespec *ts, struct timezone *tz);
+extern int cap_ptrace (struct task_struct *parent, struct task_struct *child);
+extern int cap_capget (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern int cap_capset_check (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern void cap_capset_set (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern int cap_bprm_set_security (struct linux_binprm *bprm);
+extern void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe);
+extern int cap_bprm_secureexec(struct linux_binprm *bprm);
+extern int cap_inode_setxattr(struct dentry *dentry, char *name, void *value, size_t size, int flags);
+extern int cap_inode_removexattr(struct dentry *dentry, char *name);
+extern int cap_task_post_setuid (uid_t old_ruid, uid_t old_euid, uid_t old_suid, int flags);
+extern void cap_task_reparent_to_init (struct task_struct *p);
+extern int cap_syslog (int type);
+extern int cap_vm_enough_memory (long pages);
+
+struct msghdr;
+struct sk_buff;
+struct sock;
+struct sockaddr;
+struct socket;
+
+extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
+extern int cap_netlink_recv(struct sk_buff *skb);
+
+/*
+ * Values used in the task_security_ops calls
+ */
+/* setuid or setgid, id0 == uid or gid */
+#define LSM_SETID_ID    1
+
+/* setreuid or setregid, id0 == real, id1 == eff */
+#define LSM_SETID_RE    2
+
+/* setresuid or setresgid, id0 == real, id1 == eff, uid2 == saved */
+#define LSM_SETID_RES   4
+
+/* setfsuid or setfsgid, id0 == fsuid or fsgid */
+#define LSM_SETID_FS    8
+
+/* forward declares to avoid warnings */
+struct nfsctl_arg;
+struct sched_param;
+struct swap_info_struct;
+
+/* bprm_apply_creds unsafe reasons */
+#define LSM_UNSAFE_SHARE        1
+#define LSM_UNSAFE_PTRACE       2
+#define LSM_UNSAFE_PTRACE_CAP   4
+
+#ifdef CONFIG_SECURITY
+
+/**
+ * struct security_operations - main security structure
+ *
+ * Security hooks for program execution operations.
+ *
+ * @bprm_alloc_security:
+ *      Allocate and attach a security structure to the @bprm->security field.
+ *      The security field is initialized to NULL when the bprm structure is
+ *      allocated.
+ *      @bprm contains the linux_binprm structure to be modified.
+ *      Return 0 if operation was successful.
+ * @bprm_free_security:
+ *      @bprm contains the linux_binprm structure to be modified.
+ *      Deallocate and clear the @bprm->security field.
+ * @bprm_apply_creds:
+ *      Compute and set the security attributes of a process being transformed
+ *      by an execve operation based on the old attributes (current->security)
+ *      and the information saved in @bprm->security by the set_security hook.
+ *      Since this hook function (and its caller) are void, this hook can not
+ *      return an error.  However, it can leave the security attributes of the
+ *      process unchanged if an access failure occurs at this point.
+ *      bprm_apply_creds is called under task_lock.  @unsafe indicates various
+ *      reasons why it may be unsafe to change security state.
+ *      @bprm contains the linux_binprm structure.
+ * @bprm_post_apply_creds:
+ *      Runs after bprm_apply_creds with the task_lock dropped, so that
+ *      functions which cannot be called safely under the task_lock can
+ *      be used.  This hook is a good place to perform state changes on
+ *      the process such as closing open file descriptors to which access
+ *      is no longer granted if the attributes were changed.
+ *      Note that a security module might need to save state between
+ *      bprm_apply_creds and bprm_post_apply_creds to store the decision
+ *      on whether the process may proceed.
+ *      @bprm contains the linux_binprm structure.
+ * @bprm_set_security:
+ *      Save security information in the bprm->security field, typically based
+ *      on information about the bprm->file, for later use by the apply_creds
+ *      hook.  This hook may also optionally check permissions (e.g. for
+ *      transitions between security domains).
+ *      This hook may be called multiple times during a single execve, e.g. for
+ *      interpreters.  The hook can tell whether it has already been called by
+ *      checking to see if @bprm->security is non-NULL.  If so, then the hook
+ *      may decide either to retain the security information saved earlier or
+ *      to replace it.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_check_security:
+ *      This hook mediates the point when a search for a binary handler will
+ *      begin.  It allows a check the @bprm->security value which is set in
+ *      the preceding set_security call.  The primary difference from
+ *      set_security is that the argv list and envp list are reliably
+ *      available in @bprm.  This hook may be called multiple times
+ *      during a single execve; and in each pass set_security is called
+ *      first.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_secureexec:
+ *      Return a boolean value (0 or 1) indicating whether a "secure exec" 
+ *      is required.  The flag is passed in the auxiliary table
+ *      on the initial stack to the ELF interpreter to indicate whether libc 
+ *      should enable secure mode.
+ *      @bprm contains the linux_binprm structure.
+ *
+ * Security hooks for filesystem operations.
+ *
+ * @sb_alloc_security:
+ *      Allocate and attach a security structure to the sb->s_security field.
+ *      The s_security field is initialized to NULL when the structure is
+ *      allocated.
+ *      @sb contains the super_block structure to be modified.
+ *      Return 0 if operation was successful.
+ * @sb_free_security:
+ *      Deallocate and clear the sb->s_security field.
+ *      @sb contains the super_block structure to be modified.
+ * @sb_statfs:
+ *      Check permission before obtaining filesystem statistics for the @sb
+ *      filesystem.
+ *      @sb contains the super_block structure for the filesystem.
+ *      Return 0 if permission is granted.  
+ * @sb_mount:
+ *      Check permission before an object specified by @dev_name is mounted on
+ *      the mount point named by @nd.  For an ordinary mount, @dev_name
+ *      identifies a device if the file system type requires a device.  For a
+ *      remount (@flags & MS_REMOUNT), @dev_name is irrelevant.  For a
+ *      loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
+ *      pathname of the object being mounted.
+ *      @dev_name contains the name for object being mounted.
+ *      @nd contains the nameidata structure for mount point object.
+ *      @type contains the filesystem type.
+ *      @flags contains the mount flags.
+ *      @data contains the filesystem-specific data.
+ *      Return 0 if permission is granted.
+ * @sb_copy_data:
+ *      Allow mount option data to be copied prior to parsing by the filesystem,
+ *      so that the security module can extract security-specific mount
+ *      options cleanly (a filesystem may modify the data e.g. with strsep()).
+ *      This also allows the original mount data to be stripped of security-
+ *      specific options to avoid having to make filesystems aware of them.
+ *      @type the type of filesystem being mounted.
+ *      @orig the original mount data copied from userspace.
+ *      @copy copied data which will be passed to the security module.
+ *      Returns 0 if the copy was successful.
+ * @sb_check_sb:
+ *      Check permission before the device with superblock @mnt->sb is mounted
+ *      on the mount point named by @nd.
+ *      @mnt contains the vfsmount for device being mounted.
+ *      @nd contains the nameidata object for the mount point.
+ *      Return 0 if permission is granted.
+ * @sb_umount:
+ *      Check permission before the @mnt file system is unmounted.
+ *      @mnt contains the mounted file system.
+ *      @flags contains the unmount flags, e.g. MNT_FORCE.
+ *      Return 0 if permission is granted.
+ * @sb_umount_close:
+ *      Close any files in the @mnt mounted filesystem that are held open by
+ *      the security module.  This hook is called during an umount operation
+ *      prior to checking whether the filesystem is still busy.
+ *      @mnt contains the mounted filesystem.
+ * @sb_umount_busy:
+ *      Handle a failed umount of the @mnt mounted filesystem, e.g.  re-opening
+ *      any files that were closed by umount_close.  This hook is called during
+ *      an umount operation if the umount fails after a call to the
+ *      umount_close hook.
+ *      @mnt contains the mounted filesystem.
+ * @sb_post_remount:
+ *      Update the security module's state when a filesystem is remounted.
+ *      This hook is only called if the remount was successful.
+ *      @mnt contains the mounted file system.
+ *      @flags contains the new filesystem flags.
+ *      @data contains the filesystem-specific data.
+ * @sb_post_mountroot:
+ *      Update the security module's state when the root filesystem is mounted.
+ *      This hook is only called if the mount was successful.
+ * @sb_post_addmount:
+ *      Update the security module's state when a filesystem is mounted.
+ *      This hook is called any time a mount is successfully grafetd to
+ *      the tree.
+ *      @mnt contains the mounted filesystem.
+ *      @mountpoint_nd contains the nameidata structure for the mount point.
+ * @sb_pivotroot:
+ *      Check permission before pivoting the root filesystem.
+ *      @old_nd contains the nameidata structure for the new location of the current root (put_old).
+ *      @new_nd contains the nameidata structure for the new root (new_root).
+ *      Return 0 if permission is granted.
+ * @sb_post_pivotroot:
+ *      Update module state after a successful pivot.
+ *      @old_nd contains the nameidata structure for the old root.
+ *      @new_nd contains the nameidata structure for the new root.
+ *
+ * Security hooks for inode operations.
+ *
+ * @inode_alloc_security:
+ *      Allocate and attach a security structure to @inode->i_security.  The
+ *      i_security field is initialized to NULL when the inode structure is
+ *      allocated.
+ *      @inode contains the inode structure.
+ *      Return 0 if operation was successful.
+ * @inode_free_security:
+ *      @inode contains the inode structure.
+ *      Deallocate the inode security structure and set @inode->i_security to
+ *      NULL. 
+ * @inode_create:
+ *      Check permission to create a regular file.
+ *      @dir contains inode structure of the parent of the new file.
+ *      @dentry contains the dentry structure for the file to be created.
+ *      @mode contains the file mode of the file to be created.
+ *      Return 0 if permission is granted.
+ * @inode_post_create:
+ *      Set the security attributes on a newly created regular file.  This hook
+ *      is called after a file has been successfully created.
+ *      @dir contains the inode structure of the parent directory of the new file.
+ *      @dentry contains the the dentry structure for the newly created file.
+ *      @mode contains the file mode.
+ * @inode_link:
+ *      Check permission before creating a new hard link to a file.
+ *      @old_dentry contains the dentry structure for an existing link to the file.
+ *      @dir contains the inode structure of the parent directory of the new link.
+ *      @new_dentry contains the dentry structure for the new link.
+ *      Return 0 if permission is granted.
+ * @inode_post_link:
+ *      Set security attributes for a new hard link to a file.
+ *      @old_dentry contains the dentry structure for the existing link.
+ *      @dir contains the inode structure of the parent directory of the new file.
+ *      @new_dentry contains the dentry structure for the new file link.
+ * @inode_unlink:
+ *      Check the permission to remove a hard link to a file. 
+ *      @dir contains the inode structure of parent directory of the file.
+ *      @dentry contains the dentry structure for file to be unlinked.
+ *      Return 0 if permission is granted.
+ * @inode_symlink:
+ *      Check the permission to create a symbolic link to a file.
+ *      @dir contains the inode structure of parent directory of the symbolic link.
+ *      @dentry contains the dentry structure of the symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Return 0 if permission is granted.
+ * @inode_post_symlink:
+ *      @dir contains the inode structure of the parent directory of the new link.
+ *      @dentry contains the dentry structure of new symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Set security attributes for a newly created symbolic link.  Note that
+ *      @dentry->d_inode may be NULL, since the filesystem might not
+ *      instantiate the dentry (e.g. NFS).
+ * @inode_mkdir:
+ *      Check permissions to create a new directory in the existing directory
+ *      associated with inode strcture @dir. 
+ *      @dir containst the inode structure of parent of the directory to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ *      Return 0 if permission is granted.
+ * @inode_post_mkdir:
+ *      Set security attributes on a newly created directory.
+ *      @dir contains the inode structure of parent of the directory to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ * @inode_rmdir:
+ *      Check the permission to remove a directory.
+ *      @dir contains the inode structure of parent of the directory to be removed.
+ *      @dentry contains the dentry structure of directory to be removed.
+ *      Return 0 if permission is granted.
+ * @inode_mknod:
+ *      Check permissions when creating a special file (or a socket or a fifo
+ *      file created via the mknod system call).  Note that if mknod operation
+ *      is being done for a regular file, then the create hook will be called
+ *      and not this hook.
+ *      @dir contains the inode structure of parent of the new file.
+ *      @dentry contains the dentry structure of the new file.
+ *      @mode contains the mode of the new file.
+ *      @dev contains the the device number.
+ *      Return 0 if permission is granted.
+ * @inode_post_mknod:
+ *      Set security attributes on a newly created special file (or socket or
+ *      fifo file created via the mknod system call).
+ *      @dir contains the inode structure of parent of the new node.
+ *      @dentry contains the dentry structure of the new node.
+ *      @mode contains the mode of the new node.
+ *      @dev contains the the device number.
+ * @inode_rename:
+ *      Check for permission to rename a file or directory.
+ *      @old_dir contains the inode structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the inode structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ *      Return 0 if permission is granted.
+ * @inode_post_rename:
+ *      Set security attributes on a renamed file or directory.
+ *      @old_dir contains the inode structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the inode structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ * @inode_readlink:
+ *      Check the permission to read the symbolic link.
+ *      @dentry contains the dentry structure for the file link.
+ *      Return 0 if permission is granted.
+ * @inode_follow_link:
+ *      Check permission to follow a symbolic link when looking up a pathname.
+ *      @dentry contains the dentry structure for the link.
+ *      @nd contains the nameidata structure for the parent directory.
+ *      Return 0 if permission is granted.
+ * @inode_permission:
+ *      Check permission before accessing an inode.  This hook is called by the
+ *      existing Linux permission function, so a security module can use it to
+ *      provide additional checking for existing Linux permission checks.
+ *      Notice that this hook is called when a file is opened (as well as many
+ *      other operations), whereas the file_security_ops permission hook is
+ *      called when the actual read/write operations are performed.
+ *      @inode contains the inode structure to check.
+ *      @mask contains the permission mask.
+ *     @nd contains the nameidata (may be NULL).
+ *      Return 0 if permission is granted.
+ * @inode_setattr:
+ *      Check permission before setting file attributes.  Note that the kernel
+ *      call to notify_change is performed from several locations, whenever
+ *      file attributes change (such as when a file is truncated, chown/chmod
+ *      operations, transferring disk quotas, etc).
+ *      @dentry contains the dentry structure for the file.
+ *      @attr is the iattr structure containing the new file attributes.
+ *      Return 0 if permission is granted.
+ * @inode_getattr:
+ *      Check permission before obtaining file attributes.
+ *      @mnt is the vfsmount where the dentry was looked up
+ *      @dentry contains the dentry structure for the file.
+ *      Return 0 if permission is granted.
+ * @inode_delete:
+ *      @inode contains the inode structure for deleted inode.
+ *      This hook is called when a deleted inode is released (i.e. an inode
+ *      with no hard links has its use count drop to zero).  A security module
+ *      can use this hook to release any persistent label associated with the
+ *      inode.
+ * @inode_setxattr:
+ *      Check permission before setting the extended attributes
+ *      @value identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_post_setxattr:
+ *      Update inode security field after successful setxattr operation.
+ *      @value identified by @name for @dentry.
+ * @inode_getxattr:
+ *      Check permission before obtaining the extended attributes
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_listxattr:
+ *      Check permission before obtaining the list of extended attribute 
+ *      names for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_removexattr:
+ *      Check permission before removing the extended attribute
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_getsecurity:
+ *      Copy the extended attribute representation of the security label 
+ *      associated with @name for @inode into @buffer.  @buffer may be
+ *      NULL to request the size of the buffer required.  @size indicates
+ *      the size of @buffer in bytes.  Note that @name is the remainder
+ *      of the attribute name after the security. prefix has been removed.
+ *      Return number of bytes used/required on success.
+ * @inode_setsecurity:
+ *      Set the security label associated with @name for @inode from the
+ *      extended attribute value @value.  @size indicates the size of the
+ *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
+ *      Note that @name is the remainder of the attribute name after the 
+ *      security. prefix has been removed.
+ *      Return 0 on success.
+ * @inode_listsecurity:
+ *      Copy the extended attribute names for the security labels
+ *      associated with @inode into @buffer.  The maximum size of @buffer
+ *      is specified by @buffer_size.  @buffer may be NULL to request
+ *      the size of the buffer required.
+ *      Returns number of bytes used/required on success.
+ *
+ * Security hooks for file operations
+ *
+ * @file_permission:
+ *      Check file permissions before accessing an open file.  This hook is
+ *      called by various operations that read or write files.  A security
+ *      module can use this hook to perform additional checking on these
+ *      operations, e.g.  to revalidate permissions on use to support privilege
+ *      bracketing or policy changes.  Notice that this hook is used when the
+ *      actual read/write operations are performed, whereas the
+ *      inode_security_ops hook is called when a file is opened (as well as
+ *      many other operations).
+ *      Caveat:  Although this hook can be used to revalidate permissions for
+ *      various system call operations that read or write files, it does not
+ *      address the revalidation of permissions for memory-mapped files.
+ *      Security modules must handle this separately if they need such
+ *      revalidation.
+ *      @file contains the file structure being accessed.
+ *      @mask contains the requested permissions.
+ *      Return 0 if permission is granted.
+ * @file_alloc_security:
+ *      Allocate and attach a security structure to the file->f_security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @file contains the file structure to secure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @file_free_security:
+ *      Deallocate and free any security structures stored in file->f_security.
+ *      @file contains the file structure being modified.
+ * @file_ioctl:
+ *      @file contains the file structure.
+ *      @cmd contains the operation to perform.
+ *      @arg contains the operational arguments.
+ *      Check permission for an ioctl operation on @file.  Note that @arg can
+ *      sometimes represents a user space pointer; in other cases, it may be a
+ *      simple integer value.  When @arg represents a user space pointer, it
+ *      should never be used by the security module.
+ *      Return 0 if permission is granted.
+ * @file_mmap :
+ *      Check permissions for a mmap operation.  The @file may be NULL, e.g.
+ *      if mapping anonymous memory.
+ *      @file contains the file structure for file to map (may be NULL).
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.
+ * @file_mprotect:
+ *      Check permissions before changing memory access permissions.
+ *      @vma contains the memory region to modify.
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      Return 0 if permission is granted.
+ * @file_lock:
+ *      Check permission before performing file locking operations.
+ *      Note: this hook mediates both flock and fcntl style locks.
+ *      @file contains the file structure.
+ *      @cmd contains the posix-translated lock operation to perform
+ *      (e.g. F_RDLCK, F_WRLCK).
+ *      Return 0 if permission is granted.
+ * @file_fcntl:
+ *      Check permission before allowing the file operation specified by @cmd
+ *      from being performed on the file @file.  Note that @arg can sometimes
+ *      represents a user space pointer; in other cases, it may be a simple
+ *      integer value.  When @arg represents a user space pointer, it should
+ *      never be used by the security module.
+ *      @file contains the file structure.
+ *      @cmd contains the operation to be performed.
+ *      @arg contains the operational arguments.
+ *      Return 0 if permission is granted.
+ * @file_set_fowner:
+ *      Save owner security information (typically from current->security) in
+ *      file->f_security for later use by the send_sigiotask hook.
+ *      @file contains the file structure to update.
+ *      Return 0 on success.
+ * @file_send_sigiotask:
+ *      Check permission for the file owner @fown to send SIGIO or SIGURG to the
+ *      process @tsk.  Note that this hook is sometimes called from interrupt.
+ *      Note that the fown_struct, @fown, is never outside the context of a
+ *      struct file, so the file structure (and associated security information)
+ *      can always be obtained:
+ *              (struct file *)((long)fown - offsetof(struct file,f_owner));
+ *      @tsk contains the structure of task receiving signal.
+ *      @fown contains the file owner information.
+ *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
+ *      Return 0 if permission is granted.
+ * @file_receive:
+ *      This hook allows security modules to control the ability of a process
+ *      to receive an open file descriptor via socket IPC.
+ *      @file contains the file structure being received.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for task operations.
+ *
+ * @task_create:
+ *      Check permission before creating a child process.  See the clone(2)
+ *      manual page for definitions of the @clone_flags.
+ *      @clone_flags contains the flags indicating what should be shared.
+ *      Return 0 if permission is granted.
+ * @task_alloc_security:
+ *      @p contains the task_struct for child process.
+ *      Allocate and attach a security structure to the p->security field. The
+ *      security field is initialized to NULL when the task structure is
+ *      allocated.
+ *      Return 0 if operation was successful.
+ * @task_free_security:
+ *      @p contains the task_struct for process.
+ *      Deallocate and clear the p->security field.
+ * @task_setuid:
+ *      Check permission before setting one or more of the user identity
+ *      attributes of the current process.  The @flags parameter indicates
+ *      which of the set*uid system calls invoked this hook and how to
+ *      interpret the @id0, @id1, and @id2 parameters.  See the LSM_SETID
+ *      definitions at the beginning of this file for the @flags values and
+ *      their meanings.
+ *      @id0 contains a uid.
+ *      @id1 contains a uid.
+ *      @id2 contains a uid.
+ *      @flags contains one of the LSM_SETID_* values.
+ *      Return 0 if permission is granted.
+ * @task_post_setuid:
+ *      Update the module's state after setting one or more of the user
+ *      identity attributes of the current process.  The @flags parameter
+ *      indicates which of the set*uid system calls invoked this hook.  If
+ *      @flags is LSM_SETID_FS, then @old_ruid is the old fs uid and the other
+ *      parameters are not used.
+ *      @old_ruid contains the old real uid (or fs uid if LSM_SETID_FS).
+ *      @old_euid contains the old effective uid (or -1 if LSM_SETID_FS).
+ *      @old_suid contains the old saved uid (or -1 if LSM_SETID_FS).
+ *      @flags contains one of the LSM_SETID_* values.
+ *      Return 0 on success.
+ * @task_setgid:
+ *      Check permission before setting one or more of the group identity
+ *      attributes of the current process.  The @flags parameter indicates
+ *      which of the set*gid system calls invoked this hook and how to
+ *      interpret the @id0, @id1, and @id2 parameters.  See the LSM_SETID
+ *      definitions at the beginning of this file for the @flags values and
+ *      their meanings.
+ *      @id0 contains a gid.
+ *      @id1 contains a gid.
+ *      @id2 contains a gid.
+ *      @flags contains one of the LSM_SETID_* values.
+ *      Return 0 if permission is granted.
+ * @task_setpgid:
+ *      Check permission before setting the process group identifier of the
+ *      process @p to @pgid.
+ *      @p contains the task_struct for process being modified.
+ *      @pgid contains the new pgid.
+ *      Return 0 if permission is granted.
+ * @task_getpgid:
+ *      Check permission before getting the process group identifier of the
+ *      process @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_getsid:
+ *      Check permission before getting the session identifier of the process
+ *      @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_setgroups:
+ *      Check permission before setting the supplementary group set of the
+ *      current process.
+ *      @group_info contains the new group information.
+ *      Return 0 if permission is granted.
+ * @task_setnice:
+ *      Check permission before setting the nice value of @p to @nice.
+ *      @p contains the task_struct of process.
+ *      @nice contains the new nice value.
+ *      Return 0 if permission is granted.
+ * @task_setrlimit:
+ *      Check permission before setting the resource limits of the current
+ *      process for @resource to @new_rlim.  The old resource limit values can
+ *      be examined by dereferencing (current->signal->rlim + resource).
+ *      @resource contains the resource whose limit is being set.
+ *      @new_rlim contains the new limits for @resource.
+ *      Return 0 if permission is granted.
+ * @task_setscheduler:
+ *      Check permission before setting scheduling policy and/or parameters of
+ *      process @p based on @policy and @lp.
+ *      @p contains the task_struct for process.
+ *      @policy contains the scheduling policy.
+ *      @lp contains the scheduling parameters.
+ *      Return 0 if permission is granted.
+ * @task_getscheduler:
+ *      Check permission before obtaining scheduling information for process
+ *      @p.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_kill:
+ *      Check permission before sending signal @sig to @p.  @info can be NULL,
+ *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
+ *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
+ *      from the kernel and should typically be permitted.
+ *      SIGIO signals are handled separately by the send_sigiotask hook in
+ *      file_security_ops.
+ *      @p contains the task_struct for process.
+ *      @info contains the signal information.
+ *      @sig contains the signal value.
+ *      Return 0 if permission is granted.
+ * @task_wait:
+ *      Check permission before allowing a process to reap a child process @p
+ *      and collect its status information.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_prctl:
+ *      Check permission before performing a process control operation on the
+ *      current process.
+ *      @option contains the operation.
+ *      @arg2 contains a argument.
+ *      @arg3 contains a argument.
+ *      @arg4 contains a argument.
+ *      @arg5 contains a argument.
+ *      Return 0 if permission is granted.
+ * @task_reparent_to_init:
+ *      Set the security attributes in @p->security for a kernel thread that
+ *      is being reparented to the init task.
+ *      @p contains the task_struct for the kernel thread.
+ * @task_to_inode:
+ *      Set the security attributes for an inode based on an associated task's
+ *      security attributes, e.g. for /proc/pid inodes.
+ *      @p contains the task_struct for the task.
+ *      @inode contains the inode structure for the inode.
+ *
+ * Security hooks for Netlink messaging.
+ *
+ * @netlink_send:
+ *      Save security information for a netlink message so that permission
+ *      checking can be performed when the message is processed.  The security
+ *      information can be saved using the eff_cap field of the
+ *      netlink_skb_parms structure.  Also may be used to provide fine
+ *      grained control over message transmission.
+ *      @sk associated sock of task sending the message.,
+ *      @skb contains the sk_buff structure for the netlink message.
+ *      Return 0 if the information was successfully saved and message
+ *      is allowed to be transmitted.
+ * @netlink_recv:
+ *      Check permission before processing the received netlink message in
+ *      @skb.
+ *      @skb contains the sk_buff structure for the netlink message.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for Unix domain networking.
+ *
+ * @unix_stream_connect:
+ *      Check permissions before establishing a Unix domain stream connection
+ *      between @sock and @other.
+ *      @sock contains the socket structure.
+ *      @other contains the peer socket structure.
+ *      Return 0 if permission is granted.
+ * @unix_may_send:
+ *      Check permissions before connecting or sending datagrams from @sock to
+ *      @other.
+ *      @sock contains the socket structure.
+ *      @sock contains the peer socket structure.
+ *      Return 0 if permission is granted.
+ *
+ * The @unix_stream_connect and @unix_may_send hooks were necessary because
+ * Linux provides an alternative to the conventional file name space for Unix
+ * domain sockets.  Whereas binding and connecting to sockets in the file name
+ * space is mediated by the typical file permissions (and caught by the mknod
+ * and permission hooks in inode_security_ops), binding and connecting to
+ * sockets in the abstract name space is completely unmediated.  Sufficient
+ * control of Unix domain sockets in the abstract name space isn't possible
+ * using only the socket layer hooks, since we need to know the actual target
+ * socket, which is not looked up until we are inside the af_unix code.
+ *
+ * Security hooks for socket operations.
+ *
+ * @socket_create:
+ *      Check permissions prior to creating a new socket.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ *      Return 0 if permission is granted.
+ * @socket_post_create:
+ *      This hook allows a module to update or allocate a per-socket security
+ *      structure. Note that the security field was not added directly to the
+ *      socket structure, but rather, the socket security information is stored
+ *      in the associated inode.  Typically, the inode alloc_security hook will
+ *      allocate and and attach security information to
+ *      sock->inode->i_security.  This hook may be used to update the
+ *      sock->inode->i_security field with additional information that wasn't
+ *      available when the inode was allocated.
+ *      @sock contains the newly created socket structure.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ * @socket_bind:
+ *      Check permission before socket protocol layer bind operation is
+ *      performed and the socket @sock is bound to the address specified in the
+ *      @address parameter.
+ *      @sock contains the socket structure.
+ *      @address contains the address to bind to.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.  
+ * @socket_connect:
+ *      Check permission before socket protocol layer connect operation
+ *      attempts to connect socket @sock to a remote address, @address.
+ *      @sock contains the socket structure.
+ *      @address contains the address of remote endpoint.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.  
+ * @socket_listen:
+ *      Check permission before socket protocol layer listen operation.
+ *      @sock contains the socket structure.
+ *      @backlog contains the maximum length for the pending connection queue.
+ *      Return 0 if permission is granted.
+ * @socket_accept:
+ *      Check permission before accepting a new connection.  Note that the new
+ *      socket, @newsock, has been created and some information copied to it,
+ *      but the accept operation has not actually been performed.
+ *      @sock contains the listening socket structure.
+ *      @newsock contains the newly created server socket for connection.
+ *      Return 0 if permission is granted.
+ * @socket_post_accept:
+ *      This hook allows a security module to copy security
+ *      information into the newly created socket's inode.
+ *      @sock contains the listening socket structure.
+ *      @newsock contains the newly created server socket for connection.
+ * @socket_sendmsg:
+ *      Check permission before transmitting a message to another socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message to be transmitted.
+ *      @size contains the size of message.
+ *      Return 0 if permission is granted.
+ * @socket_recvmsg:
+ *      Check permission before receiving a message from a socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message structure.
+ *      @size contains the size of message structure.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.  
+ * @socket_getsockname:
+ *      Check permission before the local address (name) of the socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getpeername:
+ *      Check permission before the remote address (name) of a socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getsockopt:
+ *      Check permissions before retrieving the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to retrieve option from.
+ *      @optname contains the name of option to retrieve.
+ *      Return 0 if permission is granted.
+ * @socket_setsockopt:
+ *      Check permissions before setting the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to set options for.
+ *      @optname contains the name of the option to set.
+ *      Return 0 if permission is granted.  
+ * @socket_shutdown:
+ *      Checks permission before all or part of a connection on the socket
+ *      @sock is shut down.
+ *      @sock contains the socket structure.
+ *      @how contains the flag indicating how future sends and receives are handled.
+ *      Return 0 if permission is granted.
+ * @socket_sock_rcv_skb:
+ *      Check permissions on incoming network packets.  This hook is distinct
+ *      from Netfilter's IP input hooks since it is the first time that the
+ *      incoming sk_buff @skb has been associated with a particular socket, @sk.
+ *      @sk contains the sock (not socket) associated with the incoming sk_buff.
+ *      @skb contains the incoming network data.
+ * @socket_getpeersec:
+ *      This hook allows the security module to provide peer socket security
+ *      state to userspace via getsockopt SO_GETPEERSEC.
+ *      @sock is the local socket.
+ *      @optval userspace memory where the security state is to be copied.
+ *      @optlen userspace int where the module should copy the actual length
+ *      of the security state.
+ *      @len as input is the maximum length to copy to userspace provided
+ *      by the caller.
+ *      Return 0 if all is well, otherwise, typical getsockopt return
+ *      values.
+ * @sk_alloc_security:
+ *      Allocate and attach a security structure to the sk->sk_security field,
+ *      which is used to copy security attributes between local stream sockets.
+ * @sk_free_security:
+ *      Deallocate security structure.
+ *
+ * Security hooks affecting all System V IPC operations.
+ *
+ * @ipc_permission:
+ *      Check permissions for access to IPC
+ *      @ipcp contains the kernel IPC permission structure
+ *      @flag contains the desired (requested) permission set
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for individual messages held in System V IPC message queues
+ * @msg_msg_alloc_security:
+ *      Allocate and attach a security structure to the msg->security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @msg contains the message structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_msg_free_security:
+ *      Deallocate the security structure for this message.
+ *      @msg contains the message structure to be modified.
+ *
+ * Security hooks for System V IPC Message Queues
+ *
+ * @msg_queue_alloc_security:
+ *      Allocate and attach a security structure to the
+ *      msq->q_perm.security field. The security field is initialized to
+ *      NULL when the structure is first created.
+ *      @msq contains the message queue structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_queue_free_security:
+ *      Deallocate security structure for this message queue.
+ *      @msq contains the message queue structure to be modified.
+ * @msg_queue_associate:
+ *      Check permission when a message queue is requested through the
+ *      msgget system call.  This hook is only called when returning the
+ *      message queue identifier for an existing message queue, not when a
+ *      new message queue is created.
+ *      @msq contains the message queue to act upon.
+ *      @msqflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgctl:
+ *      Check permission when a message control operation specified by @cmd
+ *      is to be performed on the message queue @msq.
+ *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
+ *      @msq contains the message queue to act upon.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.  
+ * @msg_queue_msgsnd:
+ *      Check permission before a message, @msg, is enqueued on the message
+ *      queue, @msq.
+ *      @msq contains the message queue to send message to.
+ *      @msg contains the message to be enqueued.
+ *      @msqflg contains operational flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgrcv:
+ *      Check permission before a message, @msg, is removed from the message
+ *      queue, @msq.  The @target task structure contains a pointer to the 
+ *      process that will be receiving the message (not equal to the current 
+ *      process when inline receives are being performed).
+ *      @msq contains the message queue to retrieve message from.
+ *      @msg contains the message destination.
+ *      @target contains the task structure for recipient process.
+ *      @type contains the type of message requested.
+ *      @mode contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Shared Memory Segments
+ *
+ * @shm_alloc_security:
+ *      Allocate and attach a security structure to the shp->shm_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @shp contains the shared memory structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @shm_free_security:
+ *      Deallocate the security struct for this memory segment.
+ *      @shp contains the shared memory structure to be modified.
+ * @shm_associate:
+ *      Check permission when a shared memory region is requested through the
+ *      shmget system call.  This hook is only called when returning the shared
+ *      memory region identifier for an existing region, not when a new shared
+ *      memory region is created.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @shm_shmctl:
+ *      Check permission when a shared memory control operation specified by
+ *      @cmd is to be performed on the shared memory region @shp.
+ *      The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO.
+ *      @shp contains shared memory structure to be modified.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @shm_shmat:
+ *      Check permissions prior to allowing the shmat system call to attach the
+ *      shared memory segment @shp to the data segment of the calling process.
+ *      The attaching address is specified by @shmaddr.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmaddr contains the address to attach memory region to.
+ *      @shmflg contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Semaphores
+ *
+ * @sem_alloc_security:
+ *      Allocate and attach a security structure to the sma->sem_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @sma contains the semaphore structure
+ *      Return 0 if operation was successful and permission is granted.
+ * @sem_free_security:
+ *      deallocate security struct for this semaphore
+ *      @sma contains the semaphore structure.
+ * @sem_associate:
+ *      Check permission when a semaphore is requested through the semget
+ *      system call.  This hook is only called when returning the semaphore
+ *      identifier for an existing semaphore, not when a new one must be
+ *      created.
+ *      @sma contains the semaphore structure.
+ *      @semflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @sem_semctl:
+ *      Check permission when a semaphore operation specified by @cmd is to be
+ *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for 
+ *      IPC_INFO or SEM_INFO.
+ *      @sma contains the semaphore structure.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @sem_semop
+ *      Check permissions before performing operations on members of the
+ *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set 
+ *      may be modified.
+ *      @sma contains the semaphore structure.
+ *      @sops contains the operations to perform.
+ *      @nsops contains the number of operations to perform.
+ *      @alter contains the flag indicating whether changes are to be made.
+ *      Return 0 if permission is granted.
+ *
+ * @ptrace:
+ *      Check permission before allowing the @parent process to trace the
+ *      @child process.
+ *      Security modules may also want to perform a process tracing check
+ *      during an execve in the set_security or apply_creds hooks of
+ *      binprm_security_ops if the process is being traced and its security
+ *      attributes would be changed by the execve.
+ *      @parent contains the task_struct structure for parent process.
+ *      @child contains the task_struct structure for child process.
+ *      Return 0 if permission is granted.
+ * @capget:
+ *      Get the @effective, @inheritable, and @permitted capability sets for
+ *      the @target process.  The hook may also perform permission checking to
+ *      determine if the current process is allowed to see the capability sets
+ *      of the @target process.
+ *      @target contains the task_struct structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 if the capability sets were successfully obtained.
+ * @capset_check:
+ *      Check permission before setting the @effective, @inheritable, and
+ *      @permitted capability sets for the @target process.
+ *      Caveat:  @target is also set to current if a set of processes is
+ *      specified (i.e. all processes other than current and init or a
+ *      particular process group).  Hence, the capset_set hook may need to
+ *      revalidate permission to the actual target process.
+ *      @target contains the task_struct structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 if permission is granted.
+ * @capset_set:
+ *      Set the @effective, @inheritable, and @permitted capability sets for
+ *      the @target process.  Since capset_check cannot always check permission
+ *      to the real @target process, this hook may also perform permission
+ *      checking to determine if the current process is allowed to set the
+ *      capability sets of the @target process.  However, this hook has no way
+ *      of returning an error due to the structure of the sys_capset code.
+ *      @target contains the task_struct structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ * @acct:
+ *      Check permission before enabling or disabling process accounting.  If
+ *      accounting is being enabled, then @file refers to the open file used to
+ *      store accounting records.  If accounting is being disabled, then @file
+ *      is NULL.
+ *      @file contains the file structure for the accounting file (may be NULL).
+ *      Return 0 if permission is granted.
+ * @sysctl:
+ *      Check permission before accessing the @table sysctl variable in the
+ *      manner specified by @op.
+ *      @table contains the ctl_table structure for the sysctl variable.
+ *      @op contains the operation (001 = search, 002 = write, 004 = read).
+ *      Return 0 if permission is granted.
+ * @capable:
+ *      Check whether the @tsk process has the @cap capability.
+ *      @tsk contains the task_struct for the process.
+ *      @cap contains the capability <include/linux/capability.h>.
+ *      Return 0 if the capability is granted for @tsk.
+ * @syslog:
+ *      Check permission before accessing the kernel message ring or changing
+ *      logging to the console.
+ *      See the syslog(2) manual page for an explanation of the @type values.  
+ *      @type contains the type of action.
+ *      Return 0 if permission is granted.
+ * @settime:
+ *      Check permission to change the system time.
+ *      struct timespec and timezone are defined in include/linux/time.h
+ *      @ts contains new time
+ *      @tz contains new timezone
+ *      Return 0 if permission is granted.
+ * @vm_enough_memory:
+ *      Check permissions for allocating a new virtual mapping.
+ *      @pages contains the number of pages.
+ *      Return 0 if permission is granted.
+ *
+ * @register_security:
+ *      allow module stacking.
+ *      @name contains the name of the security module being stacked.
+ *      @ops contains a pointer to the struct security_operations of the module to stack.
+ * @unregister_security:
+ *      remove a stacked module.
+ *      @name contains the name of the security module being unstacked.
+ *      @ops contains a pointer to the struct security_operations of the module to unstack.
+ * 
+ * This is the main security structure.
+ */
+struct security_operations {
+        int (*ptrace) (struct task_struct * parent, struct task_struct * child);
+        int (*capget) (struct task_struct * target,
+                       kernel_cap_t * effective,
+                       kernel_cap_t * inheritable, kernel_cap_t * permitted);
+        int (*capset_check) (struct task_struct * target,
+                             kernel_cap_t * effective,
+                             kernel_cap_t * inheritable,
+                             kernel_cap_t * permitted);
+        void (*capset_set) (struct task_struct * target,
+                            kernel_cap_t * effective,
+                            kernel_cap_t * inheritable,
+                            kernel_cap_t * permitted);
+        int (*acct) (struct file * file);
+        int (*sysctl) (struct ctl_table * table, int op);
+        int (*capable) (struct task_struct * tsk, int cap);
+        int (*quotactl) (int cmds, int type, int id, struct super_block * sb);
+        int (*quota_on) (struct dentry * dentry);
+        int (*syslog) (int type);
+        int (*settime) (struct timespec *ts, struct timezone *tz);
+        int (*vm_enough_memory) (long pages);
+
+        int (*bprm_alloc_security) (struct linux_binprm * bprm);
+        void (*bprm_free_security) (struct linux_binprm * bprm);
+        void (*bprm_apply_creds) (struct linux_binprm * bprm, int unsafe);
+        void (*bprm_post_apply_creds) (struct linux_binprm * bprm);
+        int (*bprm_set_security) (struct linux_binprm * bprm);
+        int (*bprm_check_security) (struct linux_binprm * bprm);
+        int (*bprm_secureexec) (struct linux_binprm * bprm);
+
+        int (*sb_alloc_security) (struct super_block * sb);
+        void (*sb_free_security) (struct super_block * sb);
+        int (*sb_copy_data)(struct file_system_type *type,
+                            void *orig, void *copy);
+        int (*sb_kern_mount) (struct super_block *sb, void *data);
+        int (*sb_statfs) (struct super_block * sb);
+        int (*sb_mount) (char *dev_name, struct nameidata * nd,
+                         char *type, unsigned long flags, void *data);
+        int (*sb_check_sb) (struct vfsmount * mnt, struct nameidata * nd);
+        int (*sb_umount) (struct vfsmount * mnt, int flags);
+        void (*sb_umount_close) (struct vfsmount * mnt);
+        void (*sb_umount_busy) (struct vfsmount * mnt);
+        void (*sb_post_remount) (struct vfsmount * mnt,
+                                 unsigned long flags, void *data);
+        void (*sb_post_mountroot) (void);
+        void (*sb_post_addmount) (struct vfsmount * mnt,
+                                  struct nameidata * mountpoint_nd);
+        int (*sb_pivotroot) (struct nameidata * old_nd,
+                             struct nameidata * new_nd);
+        void (*sb_post_pivotroot) (struct nameidata * old_nd,
+                                   struct nameidata * new_nd);
+
+        int (*inode_alloc_security) (struct inode *inode);      
+        void (*inode_free_security) (struct inode *inode);
+        int (*inode_create) (struct inode *dir,
+                             struct dentry *dentry, int mode);
+        void (*inode_post_create) (struct inode *dir,
+                                   struct dentry *dentry, int mode);
+        int (*inode_link) (struct dentry *old_dentry,
+                           struct inode *dir, struct dentry *new_dentry);
+        void (*inode_post_link) (struct dentry *old_dentry,
+                                 struct inode *dir, struct dentry *new_dentry);
+        int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
+        int (*inode_symlink) (struct inode *dir,
+                              struct dentry *dentry, const char *old_name);
+        void (*inode_post_symlink) (struct inode *dir,
+                                    struct dentry *dentry,
+                                    const char *old_name);
+        int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, int mode);
+        void (*inode_post_mkdir) (struct inode *dir, struct dentry *dentry, 
+                            int mode);
+        int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
+        int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
+                            int mode, dev_t dev);
+        void (*inode_post_mknod) (struct inode *dir, struct dentry *dentry,
+                                  int mode, dev_t dev);
+        int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
+                             struct inode *new_dir, struct dentry *new_dentry);
+        void (*inode_post_rename) (struct inode *old_dir,
+                                   struct dentry *old_dentry,
+                                   struct inode *new_dir,
+                                   struct dentry *new_dentry);
+        int (*inode_readlink) (struct dentry *dentry);
+        int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
+        int (*inode_permission) (struct inode *inode, int mask, struct nameidata *nd);
+        int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
+        int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
+        void (*inode_delete) (struct inode *inode);
+        int (*inode_setxattr) (struct dentry *dentry, char *name, void *value,
+                               size_t size, int flags);
+        void (*inode_post_setxattr) (struct dentry *dentry, char *name, void *value,
+                                     size_t size, int flags);
+        int (*inode_getxattr) (struct dentry *dentry, char *name);
+        int (*inode_listxattr) (struct dentry *dentry);
+        int (*inode_removexattr) (struct dentry *dentry, char *name);
+        int (*inode_getsecurity)(struct inode *inode, const char *name, void *buffer, size_t size);
+        int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags);
+        int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size);
+
+        int (*file_permission) (struct file * file, int mask);
+        int (*file_alloc_security) (struct file * file);
+        void (*file_free_security) (struct file * file);
+        int (*file_ioctl) (struct file * file, unsigned int cmd,
+                           unsigned long arg);
+        int (*file_mmap) (struct file * file,
+                          unsigned long reqprot,
+                          unsigned long prot, unsigned long flags);
+        int (*file_mprotect) (struct vm_area_struct * vma,
+                              unsigned long reqprot,
+                              unsigned long prot);
+        int (*file_lock) (struct file * file, unsigned int cmd);
+        int (*file_fcntl) (struct file * file, unsigned int cmd,
+                           unsigned long arg);
+        int (*file_set_fowner) (struct file * file);
+        int (*file_send_sigiotask) (struct task_struct * tsk,
+                                    struct fown_struct * fown, int sig);
+        int (*file_receive) (struct file * file);
+
+        int (*task_create) (unsigned long clone_flags);
+        int (*task_alloc_security) (struct task_struct * p);
+        void (*task_free_security) (struct task_struct * p);
+        int (*task_setuid) (uid_t id0, uid_t id1, uid_t id2, int flags);
+        int (*task_post_setuid) (uid_t old_ruid /* or fsuid */ ,
+                                 uid_t old_euid, uid_t old_suid, int flags);
+        int (*task_setgid) (gid_t id0, gid_t id1, gid_t id2, int flags);
+        int (*task_setpgid) (struct task_struct * p, pid_t pgid);
+        int (*task_getpgid) (struct task_struct * p);
+        int (*task_getsid) (struct task_struct * p);
+        int (*task_setgroups) (struct group_info *group_info);
+        int (*task_setnice) (struct task_struct * p, int nice);
+        int (*task_setrlimit) (unsigned int resource, struct rlimit * new_rlim);
+        int (*task_setscheduler) (struct task_struct * p, int policy,
+                                  struct sched_param * lp);
+        int (*task_getscheduler) (struct task_struct * p);
+        int (*task_kill) (struct task_struct * p,
+                          struct siginfo * info, int sig);
+        int (*task_wait) (struct task_struct * p);
+        int (*task_prctl) (int option, unsigned long arg2,
+                           unsigned long arg3, unsigned long arg4,
+                           unsigned long arg5);
+        void (*task_reparent_to_init) (struct task_struct * p);
+        void (*task_to_inode)(struct task_struct *p, struct inode *inode);
+
+        int (*ipc_permission) (struct kern_ipc_perm * ipcp, short flag);
+
+        int (*msg_msg_alloc_security) (struct msg_msg * msg);
+        void (*msg_msg_free_security) (struct msg_msg * msg);
+
+        int (*msg_queue_alloc_security) (struct msg_queue * msq);
+        void (*msg_queue_free_security) (struct msg_queue * msq);
+        int (*msg_queue_associate) (struct msg_queue * msq, int msqflg);
+        int (*msg_queue_msgctl) (struct msg_queue * msq, int cmd);
+        int (*msg_queue_msgsnd) (struct msg_queue * msq,
+                                 struct msg_msg * msg, int msqflg);
+        int (*msg_queue_msgrcv) (struct msg_queue * msq,
+                                 struct msg_msg * msg,
+                                 struct task_struct * target,
+                                 long type, int mode);
+
+        int (*shm_alloc_security) (struct shmid_kernel * shp);
+        void (*shm_free_security) (struct shmid_kernel * shp);
+        int (*shm_associate) (struct shmid_kernel * shp, int shmflg);
+        int (*shm_shmctl) (struct shmid_kernel * shp, int cmd);
+        int (*shm_shmat) (struct shmid_kernel * shp, 
+                          char __user *shmaddr, int shmflg);
+
+        int (*sem_alloc_security) (struct sem_array * sma);
+        void (*sem_free_security) (struct sem_array * sma);
+        int (*sem_associate) (struct sem_array * sma, int semflg);
+        int (*sem_semctl) (struct sem_array * sma, int cmd);
+        int (*sem_semop) (struct sem_array * sma, 
+                          struct sembuf * sops, unsigned nsops, int alter);
+
+        int (*netlink_send) (struct sock * sk, struct sk_buff * skb);
+        int (*netlink_recv) (struct sk_buff * skb);
+
+        /* allow module stacking */
+        int (*register_security) (const char *name,
+                                  struct security_operations *ops);
+        int (*unregister_security) (const char *name,
+                                    struct security_operations *ops);
+
+        void (*d_instantiate) (struct dentry *dentry, struct inode *inode);
+
+        int (*getprocattr)(struct task_struct *p, char *name, void *value, size_t size);
+        int (*setprocattr)(struct task_struct *p, char *name, void *value, size_t size);
+
+#ifdef CONFIG_SECURITY_NETWORK
+        int (*unix_stream_connect) (struct socket * sock,
+                                    struct socket * other, struct sock * newsk);
+        int (*unix_may_send) (struct socket * sock, struct socket * other);
+
+        int (*socket_create) (int family, int type, int protocol, int kern);
+        void (*socket_post_create) (struct socket * sock, int family,
+                                    int type, int protocol, int kern);
+        int (*socket_bind) (struct socket * sock,
+                            struct sockaddr * address, int addrlen);
+        int (*socket_connect) (struct socket * sock,
+                               struct sockaddr * address, int addrlen);
+        int (*socket_listen) (struct socket * sock, int backlog);
+        int (*socket_accept) (struct socket * sock, struct socket * newsock);
+        void (*socket_post_accept) (struct socket * sock,
+                                    struct socket * newsock);
+        int (*socket_sendmsg) (struct socket * sock,
+                               struct msghdr * msg, int size);
+        int (*socket_recvmsg) (struct socket * sock,
+                               struct msghdr * msg, int size, int flags);
+        int (*socket_getsockname) (struct socket * sock);
+        int (*socket_getpeername) (struct socket * sock);
+        int (*socket_getsockopt) (struct socket * sock, int level, int optname);
+        int (*socket_setsockopt) (struct socket * sock, int level, int optname);
+        int (*socket_shutdown) (struct socket * sock, int how);
+        int (*socket_sock_rcv_skb) (struct sock * sk, struct sk_buff * skb);
+        int (*socket_getpeersec) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len);
+        int (*sk_alloc_security) (struct sock *sk, int family, int priority);
+        void (*sk_free_security) (struct sock *sk);
+#endif  /* CONFIG_SECURITY_NETWORK */
+};
+
+/* global variables */
+extern struct security_operations *security_ops;
+
+/* inline stuff */
+static inline int security_ptrace (struct task_struct * parent, struct task_struct * child)
+{
+        return security_ops->ptrace (parent, child);
+}
+
+static inline int security_capget (struct task_struct *target,
+                                   kernel_cap_t *effective,
+                                   kernel_cap_t *inheritable,
+                                   kernel_cap_t *permitted)
+{
+        return security_ops->capget (target, effective, inheritable, permitted);
+}
+
+static inline int security_capset_check (struct task_struct *target,
+                                         kernel_cap_t *effective,
+                                         kernel_cap_t *inheritable,
+                                         kernel_cap_t *permitted)
+{
+        return security_ops->capset_check (target, effective, inheritable, permitted);
+}
+
+static inline void security_capset_set (struct task_struct *target,
+                                        kernel_cap_t *effective,
+                                        kernel_cap_t *inheritable,
+                                        kernel_cap_t *permitted)
+{
+        security_ops->capset_set (target, effective, inheritable, permitted);
+}
+
+static inline int security_acct (struct file *file)
+{
+        return security_ops->acct (file);
+}
+
+static inline int security_sysctl(struct ctl_table *table, int op)
+{
+        return security_ops->sysctl(table, op);
+}
+
+static inline int security_quotactl (int cmds, int type, int id,
+                                     struct super_block *sb)
+{
+        return security_ops->quotactl (cmds, type, id, sb);
+}
+
+static inline int security_quota_on (struct dentry * dentry)
+{
+        return security_ops->quota_on (dentry);
+}
+
+static inline int security_syslog(int type)
+{
+        return security_ops->syslog(type);
+}
+
+static inline int security_settime(struct timespec *ts, struct timezone *tz)
+{
+        return security_ops->settime(ts, tz);
+}
+
+
+static inline int security_vm_enough_memory(long pages)
+{
+        return security_ops->vm_enough_memory(pages);
+}
+
+static inline int security_bprm_alloc (struct linux_binprm *bprm)
+{
+        return security_ops->bprm_alloc_security (bprm);
+}
+static inline void security_bprm_free (struct linux_binprm *bprm)
+{
+        security_ops->bprm_free_security (bprm);
+}
+static inline void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
+{
+        security_ops->bprm_apply_creds (bprm, unsafe);
+}
+static inline void security_bprm_post_apply_creds (struct linux_binprm *bprm)
+{
+        security_ops->bprm_post_apply_creds (bprm);
+}
+static inline int security_bprm_set (struct linux_binprm *bprm)
+{
+        return security_ops->bprm_set_security (bprm);
+}
+
+static inline int security_bprm_check (struct linux_binprm *bprm)
+{
+        return security_ops->bprm_check_security (bprm);
+}
+
+static inline int security_bprm_secureexec (struct linux_binprm *bprm)
+{
+        return security_ops->bprm_secureexec (bprm);
+}
+
+static inline int security_sb_alloc (struct super_block *sb)
+{
+        return security_ops->sb_alloc_security (sb);
+}
+
+static inline void security_sb_free (struct super_block *sb)
+{
+        security_ops->sb_free_security (sb);
+}
+
+static inline int security_sb_copy_data (struct file_system_type *type,
+                                         void *orig, void *copy)
+{
+        return security_ops->sb_copy_data (type, orig, copy);
+}
+
+static inline int security_sb_kern_mount (struct super_block *sb, void *data)
+{
+        return security_ops->sb_kern_mount (sb, data);
+}
+
+static inline int security_sb_statfs (struct super_block *sb)
+{
+        return security_ops->sb_statfs (sb);
+}
+
+static inline int security_sb_mount (char *dev_name, struct nameidata *nd,
+                                    char *type, unsigned long flags,
+                                    void *data)
+{
+        return security_ops->sb_mount (dev_name, nd, type, flags, data);
+}
+
+static inline int security_sb_check_sb (struct vfsmount *mnt,
+                                        struct nameidata *nd)
+{
+        return security_ops->sb_check_sb (mnt, nd);
+}
+
+static inline int security_sb_umount (struct vfsmount *mnt, int flags)
+{
+        return security_ops->sb_umount (mnt, flags);
+}
+
+static inline void security_sb_umount_close (struct vfsmount *mnt)
+{
+        security_ops->sb_umount_close (mnt);
+}
+
+static inline void security_sb_umount_busy (struct vfsmount *mnt)
+{
+        security_ops->sb_umount_busy (mnt);
+}
+
+static inline void security_sb_post_remount (struct vfsmount *mnt,
+                                             unsigned long flags, void *data)
+{
+        security_ops->sb_post_remount (mnt, flags, data);
+}
+
+static inline void security_sb_post_mountroot (void)
+{
+        security_ops->sb_post_mountroot ();
+}
+
+static inline void security_sb_post_addmount (struct vfsmount *mnt,
+                                              struct nameidata *mountpoint_nd)
+{
+        security_ops->sb_post_addmount (mnt, mountpoint_nd);
+}
+
+static inline int security_sb_pivotroot (struct nameidata *old_nd,
+                                         struct nameidata *new_nd)
+{
+        return security_ops->sb_pivotroot (old_nd, new_nd);
+}
+
+static inline void security_sb_post_pivotroot (struct nameidata *old_nd,
+                                               struct nameidata *new_nd)
+{
+        security_ops->sb_post_pivotroot (old_nd, new_nd);
+}
+
+static inline int security_inode_alloc (struct inode *inode)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return 0;
+        return security_ops->inode_alloc_security (inode);
+}
+
+static inline void security_inode_free (struct inode *inode)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return;
+        security_ops->inode_free_security (inode);
+}
+        
+static inline int security_inode_create (struct inode *dir,
+                                         struct dentry *dentry,
+                                         int mode)
+{
+        if (unlikely (IS_PRIVATE (dir)))
+                return 0;
+        return security_ops->inode_create (dir, dentry, mode);
+}
+
+static inline void security_inode_post_create (struct inode *dir,
+                                               struct dentry *dentry,
+                                               int mode)
+{
+        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
+                return;
+        security_ops->inode_post_create (dir, dentry, mode);
+}
+
+static inline int security_inode_link (struct dentry *old_dentry,
+                                       struct inode *dir,
+                                       struct dentry *new_dentry)
+{
+        if (unlikely (IS_PRIVATE (old_dentry->d_inode)))
+                return 0;
+        return security_ops->inode_link (old_dentry, dir, new_dentry);
+}
+
+static inline void security_inode_post_link (struct dentry *old_dentry,
+                                             struct inode *dir,
+                                             struct dentry *new_dentry)
+{
+        if (new_dentry->d_inode && unlikely (IS_PRIVATE (new_dentry->d_inode)))
+                return;
+        security_ops->inode_post_link (old_dentry, dir, new_dentry);
+}
+
+static inline int security_inode_unlink (struct inode *dir,
+                                         struct dentry *dentry)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_unlink (dir, dentry);
+}
+
+static inline int security_inode_symlink (struct inode *dir,
+                                          struct dentry *dentry,
+                                          const char *old_name)
+{
+        if (unlikely (IS_PRIVATE (dir)))
+                return 0;
+        return security_ops->inode_symlink (dir, dentry, old_name);
+}
+
+static inline void security_inode_post_symlink (struct inode *dir,
+                                                struct dentry *dentry,
+                                                const char *old_name)
+{
+        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
+                return;
+        security_ops->inode_post_symlink (dir, dentry, old_name);
+}
+
+static inline int security_inode_mkdir (struct inode *dir,
+                                        struct dentry *dentry,
+                                        int mode)
+{
+        if (unlikely (IS_PRIVATE (dir)))
+                return 0;
+        return security_ops->inode_mkdir (dir, dentry, mode);
+}
+
+static inline void security_inode_post_mkdir (struct inode *dir,
+                                              struct dentry *dentry,
+                                              int mode)
+{
+        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
+                return;
+        security_ops->inode_post_mkdir (dir, dentry, mode);
+}
+
+static inline int security_inode_rmdir (struct inode *dir,
+                                        struct dentry *dentry)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_rmdir (dir, dentry);
+}
+
+static inline int security_inode_mknod (struct inode *dir,
+                                        struct dentry *dentry,
+                                        int mode, dev_t dev)
+{
+        if (unlikely (IS_PRIVATE (dir)))
+                return 0;
+        return security_ops->inode_mknod (dir, dentry, mode, dev);
+}
+
+static inline void security_inode_post_mknod (struct inode *dir,
+                                              struct dentry *dentry,
+                                              int mode, dev_t dev)
+{
+        if (dentry->d_inode && unlikely (IS_PRIVATE (dentry->d_inode)))
+                return;
+        security_ops->inode_post_mknod (dir, dentry, mode, dev);
+}
+
+static inline int security_inode_rename (struct inode *old_dir,
+                                         struct dentry *old_dentry,
+                                         struct inode *new_dir,
+                                         struct dentry *new_dentry)
+{
+        if (unlikely (IS_PRIVATE (old_dentry->d_inode) ||
+            (new_dentry->d_inode && IS_PRIVATE (new_dentry->d_inode))))
+                return 0;
+        return security_ops->inode_rename (old_dir, old_dentry,
+                                           new_dir, new_dentry);
+}
+
+static inline void security_inode_post_rename (struct inode *old_dir,
+                                               struct dentry *old_dentry,
+                                               struct inode *new_dir,
+                                               struct dentry *new_dentry)
+{
+        if (unlikely (IS_PRIVATE (old_dentry->d_inode) ||
+            (new_dentry->d_inode && IS_PRIVATE (new_dentry->d_inode))))
+                return;
+        security_ops->inode_post_rename (old_dir, old_dentry,
+                                                new_dir, new_dentry);
+}
+
+static inline int security_inode_readlink (struct dentry *dentry)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_readlink (dentry);
+}
+
+static inline int security_inode_follow_link (struct dentry *dentry,
+                                              struct nameidata *nd)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_follow_link (dentry, nd);
+}
+
+static inline int security_inode_permission (struct inode *inode, int mask,
+                                             struct nameidata *nd)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return 0;
+        return security_ops->inode_permission (inode, mask, nd);
+}
+
+static inline int security_inode_setattr (struct dentry *dentry,
+                                          struct iattr *attr)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_setattr (dentry, attr);
+}
+
+static inline int security_inode_getattr (struct vfsmount *mnt,
+                                          struct dentry *dentry)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_getattr (mnt, dentry);
+}
+
+static inline void security_inode_delete (struct inode *inode)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return;
+        security_ops->inode_delete (inode);
+}
+
+static inline int security_inode_setxattr (struct dentry *dentry, char *name,
+                                           void *value, size_t size, int flags)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_setxattr (dentry, name, value, size, flags);
+}
+
+static inline void security_inode_post_setxattr (struct dentry *dentry, char *name,
+                                                void *value, size_t size, int flags)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return;
+        security_ops->inode_post_setxattr (dentry, name, value, size, flags);
+}
+
+static inline int security_inode_getxattr (struct dentry *dentry, char *name)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_getxattr (dentry, name);
+}
+
+static inline int security_inode_listxattr (struct dentry *dentry)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_listxattr (dentry);
+}
+
+static inline int security_inode_removexattr (struct dentry *dentry, char *name)
+{
+        if (unlikely (IS_PRIVATE (dentry->d_inode)))
+                return 0;
+        return security_ops->inode_removexattr (dentry, name);
+}
+
+static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return 0;
+        return security_ops->inode_getsecurity(inode, name, buffer, size);
+}
+
+static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return 0;
+        return security_ops->inode_setsecurity(inode, name, value, size, flags);
+}
+
+static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
+{
+        if (unlikely (IS_PRIVATE (inode)))
+                return 0;
+        return security_ops->inode_listsecurity(inode, buffer, buffer_size);
+}
+
+static inline int security_file_permission (struct file *file, int mask)
+{
+        return security_ops->file_permission (file, mask);
+}
+
+static inline int security_file_alloc (struct file *file)
+{
+        return security_ops->file_alloc_security (file);
+}
+
+static inline void security_file_free (struct file *file)
+{
+        security_ops->file_free_security (file);
+}
+
+static inline int security_file_ioctl (struct file *file, unsigned int cmd,
+                                       unsigned long arg)
+{
+        return security_ops->file_ioctl (file, cmd, arg);
+}
+
+static inline int security_file_mmap (struct file *file, unsigned long reqprot,
+                                      unsigned long prot,
+                                      unsigned long flags)
+{
+        return security_ops->file_mmap (file, reqprot, prot, flags);
+}
+
+static inline int security_file_mprotect (struct vm_area_struct *vma,
+                                          unsigned long reqprot,
+                                          unsigned long prot)
+{
+        return security_ops->file_mprotect (vma, reqprot, prot);
+}
+
+static inline int security_file_lock (struct file *file, unsigned int cmd)
+{
+        return security_ops->file_lock (file, cmd);
+}
+
+static inline int security_file_fcntl (struct file *file, unsigned int cmd,
+                                       unsigned long arg)
+{
+        return security_ops->file_fcntl (file, cmd, arg);
+}
+
+static inline int security_file_set_fowner (struct file *file)
+{
+        return security_ops->file_set_fowner (file);
+}
+
+static inline int security_file_send_sigiotask (struct task_struct *tsk,
+                                                struct fown_struct *fown,
+                                                int sig)
+{
+        return security_ops->file_send_sigiotask (tsk, fown, sig);
+}
+
+static inline int security_file_receive (struct file *file)
+{
+        return security_ops->file_receive (file);
+}
+
+static inline int security_task_create (unsigned long clone_flags)
+{
+        return security_ops->task_create (clone_flags);
+}
+
+static inline int security_task_alloc (struct task_struct *p)
+{
+        return security_ops->task_alloc_security (p);
+}
+
+static inline void security_task_free (struct task_struct *p)
+{
+        security_ops->task_free_security (p);
+}
+
+static inline int security_task_setuid (uid_t id0, uid_t id1, uid_t id2,
+                                        int flags)
+{
+        return security_ops->task_setuid (id0, id1, id2, flags);
+}
+
+static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid,
+                                             uid_t old_suid, int flags)
+{
+        return security_ops->task_post_setuid (old_ruid, old_euid, old_suid, flags);
+}
+
+static inline int security_task_setgid (gid_t id0, gid_t id1, gid_t id2,
+                                        int flags)
+{
+        return security_ops->task_setgid (id0, id1, id2, flags);
+}
+
+static inline int security_task_setpgid (struct task_struct *p, pid_t pgid)
+{
+        return security_ops->task_setpgid (p, pgid);
+}
+
+static inline int security_task_getpgid (struct task_struct *p)
+{
+        return security_ops->task_getpgid (p);
+}
+
+static inline int security_task_getsid (struct task_struct *p)
+{
+        return security_ops->task_getsid (p);
+}
+
+static inline int security_task_setgroups (struct group_info *group_info)
+{
+        return security_ops->task_setgroups (group_info);
+}
+
+static inline int security_task_setnice (struct task_struct *p, int nice)
+{
+        return security_ops->task_setnice (p, nice);
+}
+
+static inline int security_task_setrlimit (unsigned int resource,
+                                           struct rlimit *new_rlim)
+{
+        return security_ops->task_setrlimit (resource, new_rlim);
+}
+
+static inline int security_task_setscheduler (struct task_struct *p,
+                                              int policy,
+                                              struct sched_param *lp)
+{
+        return security_ops->task_setscheduler (p, policy, lp);
+}
+
+static inline int security_task_getscheduler (struct task_struct *p)
+{
+        return security_ops->task_getscheduler (p);
+}
+
+static inline int security_task_kill (struct task_struct *p,
+                                      struct siginfo *info, int sig)
+{
+        return security_ops->task_kill (p, info, sig);
+}
+
+static inline int security_task_wait (struct task_struct *p)
+{
+        return security_ops->task_wait (p);
+}
+
+static inline int security_task_prctl (int option, unsigned long arg2,
+                                       unsigned long arg3,
+                                       unsigned long arg4,
+                                       unsigned long arg5)
+{
+        return security_ops->task_prctl (option, arg2, arg3, arg4, arg5);
+}
+
+static inline void security_task_reparent_to_init (struct task_struct *p)
+{
+        security_ops->task_reparent_to_init (p);
+}
+
+static inline void security_task_to_inode(struct task_struct *p, struct inode *inode)
+{
+        security_ops->task_to_inode(p, inode);
+}
+
+static inline int security_ipc_permission (struct kern_ipc_perm *ipcp,
+                                           short flag)
+{
+        return security_ops->ipc_permission (ipcp, flag);
+}
+
+static inline int security_msg_msg_alloc (struct msg_msg * msg)
+{
+        return security_ops->msg_msg_alloc_security (msg);
+}
+
+static inline void security_msg_msg_free (struct msg_msg * msg)
+{
+        security_ops->msg_msg_free_security(msg);
+}
+
+static inline int security_msg_queue_alloc (struct msg_queue *msq)
+{
+        return security_ops->msg_queue_alloc_security (msq);
+}
+
+static inline void security_msg_queue_free (struct msg_queue *msq)
+{
+        security_ops->msg_queue_free_security (msq);
+}
+
+static inline int security_msg_queue_associate (struct msg_queue * msq, 
+                                                int msqflg)
+{
+        return security_ops->msg_queue_associate (msq, msqflg);
+}
+
+static inline int security_msg_queue_msgctl (struct msg_queue * msq, int cmd)
+{
+        return security_ops->msg_queue_msgctl (msq, cmd);
+}
+
+static inline int security_msg_queue_msgsnd (struct msg_queue * msq,
+                                             struct msg_msg * msg, int msqflg)
+{
+        return security_ops->msg_queue_msgsnd (msq, msg, msqflg);
+}
+
+static inline int security_msg_queue_msgrcv (struct msg_queue * msq,
+                                             struct msg_msg * msg,
+                                             struct task_struct * target,
+                                             long type, int mode)
+{
+        return security_ops->msg_queue_msgrcv (msq, msg, target, type, mode);
+}
+
+static inline int security_shm_alloc (struct shmid_kernel *shp)
+{
+        return security_ops->shm_alloc_security (shp);
+}
+
+static inline void security_shm_free (struct shmid_kernel *shp)
+{
+        security_ops->shm_free_security (shp);
+}
+
+static inline int security_shm_associate (struct shmid_kernel * shp, 
+                                          int shmflg)
+{
+        return security_ops->shm_associate(shp, shmflg);
+}
+
+static inline int security_shm_shmctl (struct shmid_kernel * shp, int cmd)
+{
+        return security_ops->shm_shmctl (shp, cmd);
+}
+
+static inline int security_shm_shmat (struct shmid_kernel * shp, 
+                                      char __user *shmaddr, int shmflg)
+{
+        return security_ops->shm_shmat(shp, shmaddr, shmflg);
+}
+
+static inline int security_sem_alloc (struct sem_array *sma)
+{
+        return security_ops->sem_alloc_security (sma);
+}
+
+static inline void security_sem_free (struct sem_array *sma)
+{
+        security_ops->sem_free_security (sma);
+}
+
+static inline int security_sem_associate (struct sem_array * sma, int semflg)
+{
+        return security_ops->sem_associate (sma, semflg);
+}
+
+static inline int security_sem_semctl (struct sem_array * sma, int cmd)
+{
+        return security_ops->sem_semctl(sma, cmd);
+}
+
+static inline int security_sem_semop (struct sem_array * sma, 
+                                      struct sembuf * sops, unsigned nsops, 
+                                      int alter)
+{
+        return security_ops->sem_semop(sma, sops, nsops, alter);
+}
+
+static inline void security_d_instantiate (struct dentry *dentry, struct inode *inode)
+{
+        if (unlikely (inode && IS_PRIVATE (inode)))
+                return;
+        security_ops->d_instantiate (dentry, inode);
+}
+
+static inline int security_getprocattr(struct task_struct *p, char *name, void *value, size_t size)
+{
+        return security_ops->getprocattr(p, name, value, size);
+}
+
+static inline int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
+{
+        return security_ops->setprocattr(p, name, value, size);
+}
+
+static inline int security_netlink_send(struct sock *sk, struct sk_buff * skb)
+{
+        return security_ops->netlink_send(sk, skb);
+}
+
+static inline int security_netlink_recv(struct sk_buff * skb)
+{
+        return security_ops->netlink_recv(skb);
+}
+
+/* prototypes */
+extern int security_init        (void);
+extern int register_security    (struct security_operations *ops);
+extern int unregister_security  (struct security_operations *ops);
+extern int mod_reg_security     (const char *name, struct security_operations *ops);
+extern int mod_unreg_security   (const char *name, struct security_operations *ops);
+
+
+#else /* CONFIG_SECURITY */
+
+/*
+ * This is the default capabilities functionality.  Most of these functions
+ * are just stubbed out, but a few must call the proper capable code.
+ */
+
+static inline int security_init(void)
+{
+        return 0;
+}
+
+static inline int security_ptrace (struct task_struct *parent, struct task_struct * child)
+{
+        return cap_ptrace (parent, child);
+}
+
+static inline int security_capget (struct task_struct *target,
+                                   kernel_cap_t *effective,
+                                   kernel_cap_t *inheritable,
+                                   kernel_cap_t *permitted)
+{
+        return cap_capget (target, effective, inheritable, permitted);
+}
+
+static inline int security_capset_check (struct task_struct *target,
+                                         kernel_cap_t *effective,
+                                         kernel_cap_t *inheritable,
+                                         kernel_cap_t *permitted)
+{
+        return cap_capset_check (target, effective, inheritable, permitted);
+}
+
+static inline void security_capset_set (struct task_struct *target,
+                                        kernel_cap_t *effective,
+                                        kernel_cap_t *inheritable,
+                                        kernel_cap_t *permitted)
+{
+        cap_capset_set (target, effective, inheritable, permitted);
+}
+
+static inline int security_acct (struct file *file)
+{
+        return 0;
+}
+
+static inline int security_sysctl(struct ctl_table *table, int op)
+{
+        return 0;
+}
+
+static inline int security_quotactl (int cmds, int type, int id,
+                                     struct super_block * sb)
+{
+        return 0;
+}
+
+static inline int security_quota_on (struct dentry * dentry)
+{
+        return 0;
+}
+
+static inline int security_syslog(int type)
+{
+        return cap_syslog(type);
+}
+
+static inline int security_settime(struct timespec *ts, struct timezone *tz)
+{
+        return cap_settime(ts, tz);
+}
+
+static inline int security_vm_enough_memory(long pages)
+{
+        return cap_vm_enough_memory(pages);
+}
+
+static inline int security_bprm_alloc (struct linux_binprm *bprm)
+{
+        return 0;
+}
+
+static inline void security_bprm_free (struct linux_binprm *bprm)
+{ }
+
+static inline void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
+{ 
+        cap_bprm_apply_creds (bprm, unsafe);
+}
+
+static inline void security_bprm_post_apply_creds (struct linux_binprm *bprm)
+{
+        return;
+}
+
+static inline int security_bprm_set (struct linux_binprm *bprm)
+{
+        return cap_bprm_set_security (bprm);
+}
+
+static inline int security_bprm_check (struct linux_binprm *bprm)
+{
+        return 0;
+}
+
+static inline int security_bprm_secureexec (struct linux_binprm *bprm)
+{
+        return cap_bprm_secureexec(bprm);
+}
+
+static inline int security_sb_alloc (struct super_block *sb)
+{
+        return 0;
+}
+
+static inline void security_sb_free (struct super_block *sb)
+{ }
+
+static inline int security_sb_copy_data (struct file_system_type *type,
+                                         void *orig, void *copy)
+{
+        return 0;
+}
+
+static inline int security_sb_kern_mount (struct super_block *sb, void *data)
+{
+        return 0;
+}
+
+static inline int security_sb_statfs (struct super_block *sb)
+{
+        return 0;
+}
+
+static inline int security_sb_mount (char *dev_name, struct nameidata *nd,
+                                    char *type, unsigned long flags,
+                                    void *data)
+{
+        return 0;
+}
+
+static inline int security_sb_check_sb (struct vfsmount *mnt,
+                                        struct nameidata *nd)
+{
+        return 0;
+}
+
+static inline int security_sb_umount (struct vfsmount *mnt, int flags)
+{
+        return 0;
+}
+
+static inline void security_sb_umount_close (struct vfsmount *mnt)
+{ }
+
+static inline void security_sb_umount_busy (struct vfsmount *mnt)
+{ }
+
+static inline void security_sb_post_remount (struct vfsmount *mnt,
+                                             unsigned long flags, void *data)
+{ }
+
+static inline void security_sb_post_mountroot (void)
+{ }
+
+static inline void security_sb_post_addmount (struct vfsmount *mnt,
+                                              struct nameidata *mountpoint_nd)
+{ }
+
+static inline int security_sb_pivotroot (struct nameidata *old_nd,
+                                         struct nameidata *new_nd)
+{
+        return 0;
+}
+
+static inline void security_sb_post_pivotroot (struct nameidata *old_nd,
+                                               struct nameidata *new_nd)
+{ }
+
+static inline int security_inode_alloc (struct inode *inode)
+{
+        return 0;
+}
+
+static inline void security_inode_free (struct inode *inode)
+{ }
+        
+static inline int security_inode_create (struct inode *dir,
+                                         struct dentry *dentry,
+                                         int mode)
+{
+        return 0;
+}
+
+static inline void security_inode_post_create (struct inode *dir,
+                                               struct dentry *dentry,
+                                               int mode)
+{ }
+
+static inline int security_inode_link (struct dentry *old_dentry,
+                                       struct inode *dir,
+                                       struct dentry *new_dentry)
+{
+        return 0;
+}
+
+static inline void security_inode_post_link (struct dentry *old_dentry,
+                                             struct inode *dir,
+                                             struct dentry *new_dentry)
+{ }
+
+static inline int security_inode_unlink (struct inode *dir,
+                                         struct dentry *dentry)
+{
+        return 0;
+}
+
+static inline int security_inode_symlink (struct inode *dir,
+                                          struct dentry *dentry,
+                                          const char *old_name)
+{
+        return 0;
+}
+
+static inline void security_inode_post_symlink (struct inode *dir,
+                                                struct dentry *dentry,
+                                                const char *old_name)
+{ }
+
+static inline int security_inode_mkdir (struct inode *dir,
+                                        struct dentry *dentry,
+                                        int mode)
+{
+        return 0;
+}
+
+static inline void security_inode_post_mkdir (struct inode *dir,
+                                              struct dentry *dentry,
+                                              int mode)
+{ }
+
+static inline int security_inode_rmdir (struct inode *dir,
+                                        struct dentry *dentry)
+{
+        return 0;
+}
+
+static inline int security_inode_mknod (struct inode *dir,
+                                        struct dentry *dentry,
+                                        int mode, dev_t dev)
+{
+        return 0;
+}
+
+static inline void security_inode_post_mknod (struct inode *dir,
+                                              struct dentry *dentry,
+                                              int mode, dev_t dev)
+{ }
+
+static inline int security_inode_rename (struct inode *old_dir,
+                                         struct dentry *old_dentry,
+                                         struct inode *new_dir,
+                                         struct dentry *new_dentry)
+{
+        return 0;
+}
+
+static inline void security_inode_post_rename (struct inode *old_dir,
+                                               struct dentry *old_dentry,
+                                               struct inode *new_dir,
+                                               struct dentry *new_dentry)
+{ }
+
+static inline int security_inode_readlink (struct dentry *dentry)
+{
+        return 0;
+}
+
+static inline int security_inode_follow_link (struct dentry *dentry,
+                                              struct nameidata *nd)
+{
+        return 0;
+}
+
+static inline int security_inode_permission (struct inode *inode, int mask,
+                                             struct nameidata *nd)
+{
+        return 0;
+}
+
+static inline int security_inode_setattr (struct dentry *dentry,
+                                          struct iattr *attr)
+{
+        return 0;
+}
+
+static inline int security_inode_getattr (struct vfsmount *mnt,
+                                          struct dentry *dentry)
+{
+        return 0;
+}
+
+static inline void security_inode_delete (struct inode *inode)
+{ }
+
+static inline int security_inode_setxattr (struct dentry *dentry, char *name,
+                                           void *value, size_t size, int flags)
+{
+        return cap_inode_setxattr(dentry, name, value, size, flags);
+}
+
+static inline void security_inode_post_setxattr (struct dentry *dentry, char *name,
+                                                 void *value, size_t size, int flags)
+{ }
+
+static inline int security_inode_getxattr (struct dentry *dentry, char *name)
+{
+        return 0;
+}
+
+static inline int security_inode_listxattr (struct dentry *dentry)
+{
+        return 0;
+}
+
+static inline int security_inode_removexattr (struct dentry *dentry, char *name)
+{
+        return cap_inode_removexattr(dentry, name);
+}
+
+static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
+{
+        return 0;
+}
+
+static inline int security_file_permission (struct file *file, int mask)
+{
+        return 0;
+}
+
+static inline int security_file_alloc (struct file *file)
+{
+        return 0;
+}
+
+static inline void security_file_free (struct file *file)
+{ }
+
+static inline int security_file_ioctl (struct file *file, unsigned int cmd,
+                                       unsigned long arg)
+{
+        return 0;
+}
+
+static inline int security_file_mmap (struct file *file, unsigned long reqprot,
+                                      unsigned long prot,
+                                      unsigned long flags)
+{
+        return 0;
+}
+
+static inline int security_file_mprotect (struct vm_area_struct *vma,
+                                          unsigned long reqprot,
+                                          unsigned long prot)
+{
+        return 0;
+}
+
+static inline int security_file_lock (struct file *file, unsigned int cmd)
+{
+        return 0;
+}
+
+static inline int security_file_fcntl (struct file *file, unsigned int cmd,
+                                       unsigned long arg)
+{
+        return 0;
+}
+
+static inline int security_file_set_fowner (struct file *file)
+{
+        return 0;
+}
+
+static inline int security_file_send_sigiotask (struct task_struct *tsk,
+                                                struct fown_struct *fown,
+                                                int sig)
+{
+        return 0;
+}
+
+static inline int security_file_receive (struct file *file)
+{
+        return 0;
+}
+
+static inline int security_task_create (unsigned long clone_flags)
+{
+        return 0;
+}
+
+static inline int security_task_alloc (struct task_struct *p)
+{
+        return 0;
+}
+
+static inline void security_task_free (struct task_struct *p)
+{ }
+
+static inline int security_task_setuid (uid_t id0, uid_t id1, uid_t id2,
+                                        int flags)
+{
+        return 0;
+}
+
+static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid,
+                                             uid_t old_suid, int flags)
+{
+        return cap_task_post_setuid (old_ruid, old_euid, old_suid, flags);
+}
+
+static inline int security_task_setgid (gid_t id0, gid_t id1, gid_t id2,
+                                        int flags)
+{
+        return 0;
+}
+
+static inline int security_task_setpgid (struct task_struct *p, pid_t pgid)
+{
+        return 0;
+}
+
+static inline int security_task_getpgid (struct task_struct *p)
+{
+        return 0;
+}
+
+static inline int security_task_getsid (struct task_struct *p)
+{
+        return 0;
+}
+
+static inline int security_task_setgroups (struct group_info *group_info)
+{
+        return 0;
+}
+
+static inline int security_task_setnice (struct task_struct *p, int nice)
+{
+        return 0;
+}
+
+static inline int security_task_setrlimit (unsigned int resource,
+                                           struct rlimit *new_rlim)
+{
+        return 0;
+}
+
+static inline int security_task_setscheduler (struct task_struct *p,
+                                              int policy,
+                                              struct sched_param *lp)
+{
+        return 0;
+}
+
+static inline int security_task_getscheduler (struct task_struct *p)
+{
+        return 0;
+}
+
+static inline int security_task_kill (struct task_struct *p,
+                                      struct siginfo *info, int sig)
+{
+        return 0;
+}
+
+static inline int security_task_wait (struct task_struct *p)
+{
+        return 0;
+}
+
+static inline int security_task_prctl (int option, unsigned long arg2,
+                                       unsigned long arg3,
+                                       unsigned long arg4,
+                                       unsigned long arg5)
+{
+        return 0;
+}
+
+static inline void security_task_reparent_to_init (struct task_struct *p)
+{
+        cap_task_reparent_to_init (p);
+}
+
+static inline void security_task_to_inode(struct task_struct *p, struct inode *inode)
+{ }
+
+static inline int security_ipc_permission (struct kern_ipc_perm *ipcp,
+                                           short flag)
+{
+        return 0;
+}
+
+static inline int security_msg_msg_alloc (struct msg_msg * msg)
+{
+        return 0;
+}
+
+static inline void security_msg_msg_free (struct msg_msg * msg)
+{ }
+
+static inline int security_msg_queue_alloc (struct msg_queue *msq)
+{
+        return 0;
+}
+
+static inline void security_msg_queue_free (struct msg_queue *msq)
+{ }
+
+static inline int security_msg_queue_associate (struct msg_queue * msq, 
+                                                int msqflg)
+{
+        return 0;
+}
+
+static inline int security_msg_queue_msgctl (struct msg_queue * msq, int cmd)
+{
+        return 0;
+}
+
+static inline int security_msg_queue_msgsnd (struct msg_queue * msq,
+                                             struct msg_msg * msg, int msqflg)
+{
+        return 0;
+}
+
+static inline int security_msg_queue_msgrcv (struct msg_queue * msq,
+                                             struct msg_msg * msg,
+                                             struct task_struct * target,
+                                             long type, int mode)
+{
+        return 0;
+}
+
+static inline int security_shm_alloc (struct shmid_kernel *shp)
+{
+        return 0;
+}
+
+static inline void security_shm_free (struct shmid_kernel *shp)
+{ }
+
+static inline int security_shm_associate (struct shmid_kernel * shp, 
+                                          int shmflg)
+{
+        return 0;
+}
+
+static inline int security_shm_shmctl (struct shmid_kernel * shp, int cmd)
+{
+        return 0;
+}
+
+static inline int security_shm_shmat (struct shmid_kernel * shp, 
+                                      char __user *shmaddr, int shmflg)
+{
+        return 0;
+}
+
+static inline int security_sem_alloc (struct sem_array *sma)
+{
+        return 0;
+}
+
+static inline void security_sem_free (struct sem_array *sma)
+{ }
+
+static inline int security_sem_associate (struct sem_array * sma, int semflg)
+{
+        return 0;
+}
+
+static inline int security_sem_semctl (struct sem_array * sma, int cmd)
+{
+        return 0;
+}
+
+static inline int security_sem_semop (struct sem_array * sma, 
+                                      struct sembuf * sops, unsigned nsops, 
+                                      int alter)
+{
+        return 0;
+}
+
+static inline void security_d_instantiate (struct dentry *dentry, struct inode *inode)
+{ }
+
+static inline int security_getprocattr(struct task_struct *p, char *name, void *value, size_t size)
+{
+        return -EINVAL;
+}
+
+static inline int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
+{
+        return -EINVAL;
+}
+
+static inline int security_netlink_send (struct sock *sk, struct sk_buff *skb)
+{
+        return cap_netlink_send (sk, skb);
+}
+
+static inline int security_netlink_recv (struct sk_buff *skb)
+{
+        return cap_netlink_recv (skb);
+}
+
+#endif  /* CONFIG_SECURITY */
+
+#ifdef CONFIG_SECURITY_NETWORK
+static inline int security_unix_stream_connect(struct socket * sock,
+                                               struct socket * other, 
+                                               struct sock * newsk)
+{
+        return security_ops->unix_stream_connect(sock, other, newsk);
+}
+
+
+static inline int security_unix_may_send(struct socket * sock, 
+                                         struct socket * other)
+{
+        return security_ops->unix_may_send(sock, other);
+}
+
+static inline int security_socket_create (int family, int type,
+                                          int protocol, int kern)
+{
+        return security_ops->socket_create(family, type, protocol, kern);
+}
+
+static inline void security_socket_post_create(struct socket * sock, 
+                                               int family,
+                                               int type, 
+                                               int protocol, int kern)
+{
+        security_ops->socket_post_create(sock, family, type,
+                                         protocol, kern);
+}
+
+static inline int security_socket_bind(struct socket * sock, 
+                                       struct sockaddr * address, 
+                                       int addrlen)
+{
+        return security_ops->socket_bind(sock, address, addrlen);
+}
+
+static inline int security_socket_connect(struct socket * sock, 
+                                          struct sockaddr * address, 
+                                          int addrlen)
+{
+        return security_ops->socket_connect(sock, address, addrlen);
+}
+
+static inline int security_socket_listen(struct socket * sock, int backlog)
+{
+        return security_ops->socket_listen(sock, backlog);
+}
+
+static inline int security_socket_accept(struct socket * sock, 
+                                         struct socket * newsock)
+{
+        return security_ops->socket_accept(sock, newsock);
+}
+
+static inline void security_socket_post_accept(struct socket * sock, 
+                                               struct socket * newsock)
+{
+        security_ops->socket_post_accept(sock, newsock);
+}
+
+static inline int security_socket_sendmsg(struct socket * sock, 
+                                          struct msghdr * msg, int size)
+{
+        return security_ops->socket_sendmsg(sock, msg, size);
+}
+
+static inline int security_socket_recvmsg(struct socket * sock, 
+                                          struct msghdr * msg, int size, 
+                                          int flags)
+{
+        return security_ops->socket_recvmsg(sock, msg, size, flags);
+}
+
+static inline int security_socket_getsockname(struct socket * sock)
+{
+        return security_ops->socket_getsockname(sock);
+}
+
+static inline int security_socket_getpeername(struct socket * sock)
+{
+        return security_ops->socket_getpeername(sock);
+}
+
+static inline int security_socket_getsockopt(struct socket * sock, 
+                                             int level, int optname)
+{
+        return security_ops->socket_getsockopt(sock, level, optname);
+}
+
+static inline int security_socket_setsockopt(struct socket * sock, 
+                                             int level, int optname)
+{
+        return security_ops->socket_setsockopt(sock, level, optname);
+}
+
+static inline int security_socket_shutdown(struct socket * sock, int how)
+{
+        return security_ops->socket_shutdown(sock, how);
+}
+
+static inline int security_sock_rcv_skb (struct sock * sk, 
+                                         struct sk_buff * skb)
+{
+        return security_ops->socket_sock_rcv_skb (sk, skb);
+}
+
+static inline int security_socket_getpeersec(struct socket *sock, char __user *optval,
+                                             int __user *optlen, unsigned len)
+{
+        return security_ops->socket_getpeersec(sock, optval, optlen, len);
+}
+
+static inline int security_sk_alloc(struct sock *sk, int family, int priority)
+{
+        return security_ops->sk_alloc_security(sk, family, priority);
+}
+
+static inline void security_sk_free(struct sock *sk)
+{
+        return security_ops->sk_free_security(sk);
+}
+#else   /* CONFIG_SECURITY_NETWORK */
+static inline int security_unix_stream_connect(struct socket * sock,
+                                               struct socket * other, 
+                                               struct sock * newsk)
+{
+        return 0;
+}
+
+static inline int security_unix_may_send(struct socket * sock, 
+                                         struct socket * other)
+{
+        return 0;
+}
+
+static inline int security_socket_create (int family, int type,
+                                          int protocol, int kern)
+{
+        return 0;
+}
+
+static inline void security_socket_post_create(struct socket * sock, 
+                                               int family,
+                                               int type, 
+                                               int protocol, int kern)
+{
+}
+
+static inline int security_socket_bind(struct socket * sock, 
+                                       struct sockaddr * address, 
+                                       int addrlen)
+{
+        return 0;
+}
+
+static inline int security_socket_connect(struct socket * sock, 
+                                          struct sockaddr * address, 
+                                          int addrlen)
+{
+        return 0;
+}
+
+static inline int security_socket_listen(struct socket * sock, int backlog)
+{
+        return 0;
+}
+
+static inline int security_socket_accept(struct socket * sock, 
+                                         struct socket * newsock)
+{
+        return 0;
+}
+
+static inline void security_socket_post_accept(struct socket * sock, 
+                                               struct socket * newsock)
+{
+}
+
+static inline int security_socket_sendmsg(struct socket * sock, 
+                                          struct msghdr * msg, int size)
+{
+        return 0;
+}
+
+static inline int security_socket_recvmsg(struct socket * sock, 
+                                          struct msghdr * msg, int size, 
+                                          int flags)
+{
+        return 0;
+}
+
+static inline int security_socket_getsockname(struct socket * sock)
+{
+        return 0;
+}
+
+static inline int security_socket_getpeername(struct socket * sock)
+{
+        return 0;
+}
+
+static inline int security_socket_getsockopt(struct socket * sock, 
+                                             int level, int optname)
+{
+        return 0;
+}
+
+static inline int security_socket_setsockopt(struct socket * sock, 
+                                             int level, int optname)
+{
+        return 0;
+}
+
+static inline int security_socket_shutdown(struct socket * sock, int how)
+{
+        return 0;
+}
+static inline int security_sock_rcv_skb (struct sock * sk, 
+                                         struct sk_buff * skb)
+{
+        return 0;
+}
+
+static inline int security_socket_getpeersec(struct socket *sock, char __user *optval,
+                                             int __user *optlen, unsigned len)
+{
+        return -ENOPROTOOPT;
+}
+
+static inline int security_sk_alloc(struct sock *sk, int family, int priority)
+{
+        return 0;
+}
+
+static inline void security_sk_free(struct sock *sk)
+{
+}
+#endif  /* CONFIG_SECURITY_NETWORK */
+
+#endif /* ! __LINUX_SECURITY_H */
+
diff --git a/include/linux/selection.h b/include/linux/selection.h
new file mode 100644
index 000000000000..ed3408b400f1
--- /dev/null
+++ b/include/linux/selection.h
@@ -0,0 +1,40 @@
+/*
+ * selection.h
+ *
+ * Interface between console.c, tty_io.c, vt.c, vc_screen.c and selection.c
+ */
+
+#ifndef _LINUX_SELECTION_H_
+#define _LINUX_SELECTION_H_
+
+#include <linux/tiocl.h>
+#include <linux/vt_buffer.h>
+
+extern struct vc_data *sel_cons;
+
+extern void clear_selection(void);
+extern int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *tty);
+extern int paste_selection(struct tty_struct *tty);
+extern int sel_loadlut(char __user *p);
+extern int mouse_reporting(void);
+extern void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry);
+
+extern int console_blanked;
+
+extern unsigned char color_table[];
+extern int default_red[];
+extern int default_grn[];
+extern int default_blu[];
+
+extern unsigned short *screen_pos(struct vc_data *vc, int w_offset, int viewed);
+extern u16 screen_glyph(struct vc_data *vc, int offset);
+extern void complement_pos(struct vc_data *vc, int offset);
+extern void invert_screen(struct vc_data *vc, int offset, int count, int shift);
+
+extern void getconsxy(struct vc_data *vc, unsigned char *p);
+extern void putconsxy(struct vc_data *vc, unsigned char *p);
+
+extern u16 vcs_scr_readw(struct vc_data *vc, const u16 *org);
+extern void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org);
+
+#endif
diff --git a/include/linux/selinux_netlink.h b/include/linux/selinux_netlink.h
new file mode 100644
index 000000000000..957e6ebca4e6
--- /dev/null
+++ b/include/linux/selinux_netlink.h
@@ -0,0 +1,37 @@
+/*
+ * Netlink event notifications for SELinux.
+ *
+ * Author: James Morris <jmorris@redhat.com>
+ *
+ * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
+ *
+ * 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 _LINUX_SELINUX_NETLINK_H
+#define _LINUX_SELINUX_NETLINK_H
+
+/* Message types. */
+#define SELNL_MSG_BASE 0x10
+enum {
+        SELNL_MSG_SETENFORCE = SELNL_MSG_BASE,
+        SELNL_MSG_POLICYLOAD,
+        SELNL_MSG_MAX
+};
+
+/* Multicast groups */
+#define SELNL_GRP_NONE          0x00000000
+#define SELNL_GRP_AVC           0x00000001      /* AVC notifications */
+#define SELNL_GRP_ALL           0xffffffff
+
+/* Message structures */
+struct selnl_msg_setenforce {
+        int32_t         val;
+};
+
+struct selnl_msg_policyload {
+        u_int32_t       seqno;
+};
+
+#endif /* _LINUX_SELINUX_NETLINK_H */
diff --git a/include/linux/sem.h b/include/linux/sem.h
new file mode 100644
index 000000000000..2d8516be9fd7
--- /dev/null
+++ b/include/linux/sem.h
@@ -0,0 +1,157 @@
+#ifndef _LINUX_SEM_H
+#define _LINUX_SEM_H
+
+#include <linux/ipc.h>
+#include <asm/atomic.h>
+
+/* semop flags */
+#define SEM_UNDO        0x1000  /* undo the operation on exit */
+
+/* semctl Command Definitions. */
+#define GETPID  11       /* get sempid */
+#define GETVAL  12       /* get semval */
+#define GETALL  13       /* get all semval's */
+#define GETNCNT 14       /* get semncnt */
+#define GETZCNT 15       /* get semzcnt */
+#define SETVAL  16       /* set semval */
+#define SETALL  17       /* set all semval's */
+
+/* ipcs ctl cmds */
+#define SEM_STAT 18
+#define SEM_INFO 19
+
+/* Obsolete, used only for backwards compatibility and libc5 compiles */
+struct semid_ds {
+        struct ipc_perm sem_perm;               /* permissions .. see ipc.h */
+        __kernel_time_t sem_otime;              /* last semop time */
+        __kernel_time_t sem_ctime;              /* last change time */
+        struct sem      *sem_base;              /* ptr to first semaphore in array */
+        struct sem_queue *sem_pending;          /* pending operations to be processed */
+        struct sem_queue **sem_pending_last;    /* last pending operation */
+        struct sem_undo *undo;                  /* undo requests on this array */
+        unsigned short  sem_nsems;              /* no. of semaphores in array */
+};
+
+/* Include the definition of semid64_ds */
+#include <asm/sembuf.h>
+
+/* semop system calls takes an array of these. */
+struct sembuf {
+        unsigned short  sem_num;        /* semaphore index in array */
+        short           sem_op;         /* semaphore operation */
+        short           sem_flg;        /* operation flags */
+};
+
+/* arg for semctl system calls. */
+union semun {
+        int val;                        /* value for SETVAL */
+        struct semid_ds __user *buf;    /* buffer for IPC_STAT & IPC_SET */
+        unsigned short __user *array;   /* array for GETALL & SETALL */
+        struct seminfo __user *__buf;   /* buffer for IPC_INFO */
+        void __user *__pad;
+};
+
+struct  seminfo {
+        int semmap;
+        int semmni;
+        int semmns;
+        int semmnu;
+        int semmsl;
+        int semopm;
+        int semume;
+        int semusz;
+        int semvmx;
+        int semaem;
+};
+
+#define SEMMNI  128             /* <= IPCMNI  max # of semaphore identifiers */
+#define SEMMSL  250             /* <= 8 000 max num of semaphores per id */
+#define SEMMNS  (SEMMNI*SEMMSL) /* <= INT_MAX max # of semaphores in system */
+#define SEMOPM  32              /* <= 1 000 max num of ops per semop call */
+#define SEMVMX  32767           /* <= 32767 semaphore maximum value */
+#define SEMAEM  SEMVMX          /* adjust on exit max value */
+
+/* unused */
+#define SEMUME  SEMOPM          /* max num of undo entries per process */
+#define SEMMNU  SEMMNS          /* num of undo structures system wide */
+#define SEMMAP  SEMMNS          /* # of entries in semaphore map */
+#define SEMUSZ  20              /* sizeof struct sem_undo */
+
+#ifdef __KERNEL__
+
+/* One semaphore structure for each semaphore in the system. */
+struct sem {
+        int     semval;         /* current value */
+        int     sempid;         /* pid of last operation */
+};
+
+/* One sem_array data structure for each set of semaphores in the system. */
+struct sem_array {
+        struct kern_ipc_perm    sem_perm;       /* permissions .. see ipc.h */
+        time_t                  sem_otime;      /* last semop time */
+        time_t                  sem_ctime;      /* last change time */
+        struct sem              *sem_base;      /* ptr to first semaphore in array */
+        struct sem_queue        *sem_pending;   /* pending operations to be processed */
+        struct sem_queue        **sem_pending_last; /* last pending operation */
+        struct sem_undo         *undo;          /* undo requests on this array */
+        unsigned long           sem_nsems;      /* no. of semaphores in array */
+};
+
+/* One queue for each sleeping process in the system. */
+struct sem_queue {
+        struct sem_queue *      next;    /* next entry in the queue */
+        struct sem_queue **     prev;    /* previous entry in the queue, *(q->prev) == q */
+        struct task_struct*     sleeper; /* this process */
+        struct sem_undo *       undo;    /* undo structure */
+        int                     pid;     /* process id of requesting process */
+        int                     status;  /* completion status of operation */
+        struct sem_array *      sma;     /* semaphore array for operations */
+        int                     id;      /* internal sem id */
+        struct sembuf *         sops;    /* array of pending operations */
+        int                     nsops;   /* number of operations */
+        int                     alter;   /* does the operation alter the array? */
+};
+
+/* Each task has a list of undo requests. They are executed automatically
+ * when the process exits.
+ */
+struct sem_undo {
+        struct sem_undo *       proc_next;      /* next entry on this process */
+        struct sem_undo *       id_next;        /* next entry on this semaphore set */
+        int                     semid;          /* semaphore set identifier */
+        short *                 semadj;         /* array of adjustments, one per semaphore */
+};
+
+/* sem_undo_list controls shared access to the list of sem_undo structures
+ * that may be shared among all a CLONE_SYSVSEM task group.
+ */ 
+struct sem_undo_list {
+        atomic_t        refcnt;
+        spinlock_t      lock;
+        struct sem_undo *proc_list;
+};
+
+struct sysv_sem {
+        struct sem_undo_list *undo_list;
+};
+
+#ifdef CONFIG_SYSVIPC
+
+extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
+extern void exit_sem(struct task_struct *tsk);
+
+#else
+static inline int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
+{
+        return 0;
+}
+
+static inline void exit_sem(struct task_struct *tsk)
+{
+        return;
+}
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SEM_H */
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
new file mode 100644
index 000000000000..850a974ee505
--- /dev/null
+++ b/include/linux/seq_file.h
@@ -0,0 +1,54 @@
+#ifndef _LINUX_SEQ_FILE_H
+#define _LINUX_SEQ_FILE_H
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/string.h>
+#include <asm/semaphore.h>
+
+struct seq_operations;
+struct file;
+struct vfsmount;
+struct dentry;
+struct inode;
+
+struct seq_file {
+        char *buf;
+        size_t size;
+        size_t from;
+        size_t count;
+        loff_t index;
+        loff_t version;
+        struct semaphore sem;
+        struct seq_operations *op;
+        void *private;
+};
+
+struct seq_operations {
+        void * (*start) (struct seq_file *m, loff_t *pos);
+        void (*stop) (struct seq_file *m, void *v);
+        void * (*next) (struct seq_file *m, void *v, loff_t *pos);
+        int (*show) (struct seq_file *m, void *v);
+};
+
+int seq_open(struct file *, struct seq_operations *);
+ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
+loff_t seq_lseek(struct file *, loff_t, int);
+int seq_release(struct inode *, struct file *);
+int seq_escape(struct seq_file *, const char *, const char *);
+int seq_putc(struct seq_file *m, char c);
+int seq_puts(struct seq_file *m, const char *s);
+
+int seq_printf(struct seq_file *, const char *, ...)
+        __attribute__ ((format (printf,2,3)));
+
+int seq_path(struct seq_file *, struct vfsmount *, struct dentry *, char *);
+
+int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
+int single_release(struct inode *, struct file *);
+int seq_release_private(struct inode *, struct file *);
+
+#define SEQ_START_TOKEN ((void *)1)
+
+#endif
+#endif
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
new file mode 100644
index 000000000000..fca9b0fb5b4e
--- /dev/null
+++ b/include/linux/seqlock.h
@@ -0,0 +1,175 @@
+#ifndef __LINUX_SEQLOCK_H
+#define __LINUX_SEQLOCK_H
+/*
+ * Reader/writer consistent mechanism without starving writers. This type of
+ * lock for data where the reader wants a consitent set of information
+ * and is willing to retry if the information changes.  Readers never
+ * block but they may have to retry if a writer is in
+ * progress. Writers do not wait for readers. 
+ *
+ * This is not as cache friendly as brlock. Also, this will not work
+ * for data that contains pointers, because any writer could
+ * invalidate a pointer that a reader was following.
+ *
+ * Expected reader usage:
+ *      do {
+ *          seq = read_seqbegin(&foo);
+ *      ...
+ *      } while (read_seqretry(&foo, seq));
+ *
+ *
+ * On non-SMP the spin locks disappear but the writer still needs
+ * to increment the sequence variables because an interrupt routine could
+ * change the state of the data.
+ *
+ * Based on x86_64 vsyscall gettimeofday 
+ * by Keith Owens and Andrea Arcangeli
+ */
+
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/preempt.h>
+
+typedef struct {
+        unsigned sequence;
+        spinlock_t lock;
+} seqlock_t;
+
+/*
+ * These macros triggered gcc-3.x compile-time problems.  We think these are
+ * OK now.  Be cautious.
+ */
+#define SEQLOCK_UNLOCKED { 0, SPIN_LOCK_UNLOCKED }
+#define seqlock_init(x) do { *(x) = (seqlock_t) SEQLOCK_UNLOCKED; } while (0)
+
+
+/* Lock out other writers and update the count.
+ * Acts like a normal spin_lock/unlock.
+ * Don't need preempt_disable() because that is in the spin_lock already.
+ */
+static inline void write_seqlock(seqlock_t *sl)
+{
+        spin_lock(&sl->lock);
+        ++sl->sequence;
+        smp_wmb();                      
+}       
+
+static inline void write_sequnlock(seqlock_t *sl) 
+{
+        smp_wmb();
+        sl->sequence++;
+        spin_unlock(&sl->lock);
+}
+
+static inline int write_tryseqlock(seqlock_t *sl)
+{
+        int ret = spin_trylock(&sl->lock);
+
+        if (ret) {
+                ++sl->sequence;
+                smp_wmb();                      
+        }
+        return ret;
+}
+
+/* Start of read calculation -- fetch last complete writer token */
+static inline unsigned read_seqbegin(const seqlock_t *sl)
+{
+        unsigned ret = sl->sequence;
+        smp_rmb();
+        return ret;
+}
+
+/* Test if reader processed invalid data.
+ * If initial values is odd, 
+ *      then writer had already started when section was entered
+ * If sequence value changed
+ *      then writer changed data while in section
+ *    
+ * Using xor saves one conditional branch.
+ */
+static inline int read_seqretry(const seqlock_t *sl, unsigned iv)
+{
+        smp_rmb();
+        return (iv & 1) | (sl->sequence ^ iv);
+}
+
+
+/*
+ * Version using sequence counter only.
+ * This can be used when code has its own mutex protecting the
+ * updating starting before the write_seqcountbeqin() and ending
+ * after the write_seqcount_end().
+ */
+
+typedef struct seqcount {
+        unsigned sequence;
+} seqcount_t;
+
+#define SEQCNT_ZERO { 0 }
+#define seqcount_init(x)        do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)
+
+/* Start of read using pointer to a sequence counter only.  */
+static inline unsigned read_seqcount_begin(const seqcount_t *s)
+{
+        unsigned ret = s->sequence;
+        smp_rmb();
+        return ret;
+}
+
+/* Test if reader processed invalid data.
+ * Equivalent to: iv is odd or sequence number has changed.
+ *                (iv & 1) || (*s != iv)
+ * Using xor saves one conditional branch.
+ */
+static inline int read_seqcount_retry(const seqcount_t *s, unsigned iv)
+{
+        smp_rmb();
+        return (iv & 1) | (s->sequence ^ iv);
+}
+
+
+/*
+ * Sequence counter only version assumes that callers are using their
+ * own mutexing.
+ */
+static inline void write_seqcount_begin(seqcount_t *s)
+{
+        s->sequence++;
+        smp_wmb();
+}
+
+static inline void write_seqcount_end(seqcount_t *s)
+{
+        smp_wmb();
+        s->sequence++;
+}
+
+/*
+ * Possible sw/hw IRQ protected versions of the interfaces.
+ */
+#define write_seqlock_irqsave(lock, flags)                              \
+        do { local_irq_save(flags); write_seqlock(lock); } while (0)
+#define write_seqlock_irq(lock)                                         \
+        do { local_irq_disable();   write_seqlock(lock); } while (0)
+#define write_seqlock_bh(lock)                                          \
+        do { local_bh_disable();    write_seqlock(lock); } while (0)
+
+#define write_sequnlock_irqrestore(lock, flags)                         \
+        do { write_sequnlock(lock); local_irq_restore(flags); } while(0)
+#define write_sequnlock_irq(lock)                                       \
+        do { write_sequnlock(lock); local_irq_enable(); } while(0)
+#define write_sequnlock_bh(lock)                                        \
+        do { write_sequnlock(lock); local_bh_enable(); } while(0)
+
+#define read_seqbegin_irqsave(lock, flags)                              \
+        ({ local_irq_save(flags);   read_seqbegin(lock); })
+
+#define read_seqretry_irqrestore(lock, iv, flags)                       \
+        ({                                                              \
+                int ret = read_seqretry(lock, iv);                      \
+                local_irq_restore(flags);                               \
+                ret;                                                    \
+        })
+
+#endif /* __LINUX_SEQLOCK_H */
diff --git a/include/linux/serial.h b/include/linux/serial.h
new file mode 100644
index 000000000000..00145822fb74
--- /dev/null
+++ b/include/linux/serial.h
@@ -0,0 +1,188 @@
+/*
+ * include/linux/serial.h
+ *
+ * Copyright (C) 1992 by Theodore Ts'o.
+ * 
+ * Redistribution of this file is permitted under the terms of the GNU 
+ * Public License (GPL)
+ */
+
+#ifndef _LINUX_SERIAL_H
+#define _LINUX_SERIAL_H
+
+#ifdef __KERNEL__
+#include <asm/page.h>
+
+/*
+ * Counters of the input lines (CTS, DSR, RI, CD) interrupts
+ */
+
+struct async_icount {
+        __u32   cts, dsr, rng, dcd, tx, rx;
+        __u32   frame, parity, overrun, brk;
+        __u32   buf_overrun;
+};
+
+/*
+ * The size of the serial xmit buffer is 1 page, or 4096 bytes
+ */
+#define SERIAL_XMIT_SIZE PAGE_SIZE
+
+#endif
+
+struct serial_struct {
+        int     type;
+        int     line;
+        unsigned int    port;
+        int     irq;
+        int     flags;
+        int     xmit_fifo_size;
+        int     custom_divisor;
+        int     baud_base;
+        unsigned short  close_delay;
+        char    io_type;
+        char    reserved_char[1];
+        int     hub6;
+        unsigned short  closing_wait; /* time to wait before closing */
+        unsigned short  closing_wait2; /* no longer used... */
+        unsigned char   *iomem_base;
+        unsigned short  iomem_reg_shift;
+        unsigned int    port_high;
+        unsigned long   iomap_base;     /* cookie passed into ioremap */
+};
+
+/*
+ * For the close wait times, 0 means wait forever for serial port to
+ * flush its output.  65535 means don't wait at all.
+ */
+#define ASYNC_CLOSING_WAIT_INF  0
+#define ASYNC_CLOSING_WAIT_NONE 65535
+
+/*
+ * These are the supported serial types.
+ */
+#define PORT_UNKNOWN    0
+#define PORT_8250       1
+#define PORT_16450      2
+#define PORT_16550      3
+#define PORT_16550A     4
+#define PORT_CIRRUS     5       /* usurped by cyclades.c */
+#define PORT_16650      6
+#define PORT_16650V2    7
+#define PORT_16750      8
+#define PORT_STARTECH   9       /* usurped by cyclades.c */
+#define PORT_16C950     10      /* Oxford Semiconductor */
+#define PORT_16654      11
+#define PORT_16850      12
+#define PORT_RSA        13      /* RSA-DV II/S card */
+#define PORT_MAX        13
+
+#define SERIAL_IO_PORT  0
+#define SERIAL_IO_HUB6  1
+#define SERIAL_IO_MEM   2
+
+struct serial_uart_config {
+        char    *name;
+        int     dfl_xmit_fifo_size;
+        int     flags;
+};
+
+#define UART_CLEAR_FIFO         0x01
+#define UART_USE_FIFO           0x02
+#define UART_STARTECH           0x04
+#define UART_NATSEMI            0x08
+
+/*
+ * Definitions for async_struct (and serial_struct) flags field
+ */
+#define ASYNC_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes 
+                                   on the callout port */
+#define ASYNC_FOURPORT  0x0002  /* Set OU1, OUT2 per AST Fourport settings */
+#define ASYNC_SAK       0x0004  /* Secure Attention Key (Orange book) */
+#define ASYNC_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */
+
+#define ASYNC_SPD_MASK  0x1030
+#define ASYNC_SPD_HI    0x0010  /* Use 56000 instead of 38400 bps */
+
+#define ASYNC_SPD_VHI   0x0020  /* Use 115200 instead of 38400 bps */
+#define ASYNC_SPD_CUST  0x0030  /* Use user-specified divisor */
+
+#define ASYNC_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */
+#define ASYNC_AUTO_IRQ  0x0080 /* Do automatic IRQ during autoconfiguration */
+#define ASYNC_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */
+#define ASYNC_PGRP_LOCKOUT    0x0200 /* Lock out cua opens based on pgrp */
+#define ASYNC_CALLOUT_NOHUP   0x0400 /* Don't do hangups for cua device */
+
+#define ASYNC_HARDPPS_CD        0x0800  /* Call hardpps when CD goes high  */
+
+#define ASYNC_SPD_SHI   0x1000  /* Use 230400 instead of 38400 bps */
+#define ASYNC_SPD_WARP  0x1010  /* Use 460800 instead of 38400 bps */
+
+#define ASYNC_LOW_LATENCY 0x2000 /* Request low latency behaviour */
+
+#define ASYNC_BUGGY_UART  0x4000 /* This is a buggy UART, skip some safety
+                                  * checks.  Note: can be dangerous! */
+
+#define ASYNC_AUTOPROBE  0x8000 /* Port was autoprobed by PCI or PNP code */
+
+#define ASYNC_FLAGS     0x7FFF  /* Possible legal async flags */
+#define ASYNC_USR_MASK  0x3430  /* Legal flags that non-privileged
+                                 * users can set or reset */
+
+/* Internal flags used only by kernel/chr_drv/serial.c */
+#define ASYNC_INITIALIZED       0x80000000 /* Serial port was initialized */
+#define ASYNC_NORMAL_ACTIVE     0x20000000 /* Normal device is active */
+#define ASYNC_BOOT_AUTOCONF     0x10000000 /* Autoconfigure port on bootup */
+#define ASYNC_CLOSING           0x08000000 /* Serial port is closing */
+#define ASYNC_CTS_FLOW          0x04000000 /* Do CTS flow control */
+#define ASYNC_CHECK_CD          0x02000000 /* i.e., CLOCAL */
+#define ASYNC_SHARE_IRQ         0x01000000 /* for multifunction cards
+                                             --- no longer used */
+#define ASYNC_CONS_FLOW         0x00800000 /* flow control for console  */
+
+#define ASYNC_BOOT_ONLYMCA      0x00400000 /* Probe only if MCA bus */
+#define ASYNC_INTERNAL_FLAGS    0xFFC00000 /* Internal flags */
+
+/*
+ * Multiport serial configuration structure --- external structure
+ */
+struct serial_multiport_struct {
+        int             irq;
+        int             port1;
+        unsigned char   mask1, match1;
+        int             port2;
+        unsigned char   mask2, match2;
+        int             port3;
+        unsigned char   mask3, match3;
+        int             port4;
+        unsigned char   mask4, match4;
+        int             port_monitor;
+        int     reserved[32];
+};
+
+/*
+ * Serial input interrupt line counters -- external structure
+ * Four lines can interrupt: CTS, DSR, RI, DCD
+ */
+struct serial_icounter_struct {
+        int cts, dsr, rng, dcd;
+        int rx, tx;
+        int frame, overrun, parity, brk;
+        int buf_overrun;
+        int reserved[9];
+};
+
+
+#ifdef __KERNEL__
+/* Export to allow PCMCIA to use this - Dave Hinds */
+extern int register_serial(struct serial_struct *req);
+extern void unregister_serial(int line);
+
+/* Allow architectures to override entries in serial8250_ports[] at run time: */
+struct uart_port;       /* forward declaration */
+extern int early_serial_setup(struct uart_port *port);
+extern int early_serial_console_init(char *options);
+extern int serial8250_start_console(struct uart_port *port, char *options);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SERIAL_H */
diff --git a/include/linux/serial167.h b/include/linux/serial167.h
new file mode 100644
index 000000000000..71b6df2516a6
--- /dev/null
+++ b/include/linux/serial167.h
@@ -0,0 +1,171 @@
+/*
+ * serial167.h
+ *
+ * Richard Hirst [richard@sleepie.demon.co.uk]
+ *
+ * Based on cyclades.h
+ */
+
+struct cyclades_monitor {
+        unsigned long           int_count;
+        unsigned long           char_count;
+        unsigned long           char_max;
+        unsigned long           char_last;
+};
+
+/*
+ * This is our internal structure for each serial port's state.
+ * 
+ * Many fields are paralleled by the structure used by the serial_struct
+ * structure.
+ *
+ * For definitions of the flags field, see tty.h
+ */
+
+struct cyclades_port {
+        int                     magic;
+        int                     type;
+        int                     card;
+        int                     line;
+        int                     flags;          /* defined in tty.h */
+        struct tty_struct       *tty;
+        int                     read_status_mask;
+        int                     timeout;
+        int                     xmit_fifo_size;
+        int                     cor1,cor2,cor3,cor4,cor5,cor6,cor7;
+        int                     tbpr,tco,rbpr,rco;
+        int                     ignore_status_mask;
+        int                     close_delay;
+        int                     IER;    /* Interrupt Enable Register */
+        unsigned long           event;
+        unsigned long           last_active;
+        int                     count;  /* # of fd on device */
+        int                     x_char; /* to be pushed out ASAP */
+        int                     x_break;
+        int                     blocked_open; /* # of blocked opens */
+        unsigned char           *xmit_buf;
+        int                     xmit_head;
+        int                     xmit_tail;
+        int                     xmit_cnt;
+        int                     default_threshold;
+        int                     default_timeout;
+        struct work_struct      tqueue;
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        struct cyclades_monitor mon;
+};
+
+#define CYCLADES_MAGIC  0x4359
+
+#define CYGETMON                0x435901
+#define CYGETTHRESH             0x435902
+#define CYSETTHRESH             0x435903
+#define CYGETDEFTHRESH          0x435904
+#define CYSETDEFTHRESH          0x435905
+#define CYGETTIMEOUT            0x435906
+#define CYSETTIMEOUT            0x435907
+#define CYGETDEFTIMEOUT         0x435908
+#define CYSETDEFTIMEOUT         0x435909
+
+/*
+ * Events are used to schedule things to happen at timer-interrupt
+ * time, instead of at cy interrupt time.
+ */
+#define Cy_EVENT_READ_PROCESS   0
+#define Cy_EVENT_WRITE_WAKEUP   1
+#define Cy_EVENT_HANGUP         2
+#define Cy_EVENT_BREAK          3
+#define Cy_EVENT_OPEN_WAKEUP    4
+
+
+
+#define CyMaxChipsPerCard 1
+
+/**** cd2401 registers ****/
+
+#define CyGFRCR         (0x81)
+#define CyCCR           (0x13)
+#define      CyCLR_CHAN         (0x40)
+#define      CyINIT_CHAN        (0x20)
+#define      CyCHIP_RESET       (0x10)
+#define      CyENB_XMTR         (0x08)
+#define      CyDIS_XMTR         (0x04)
+#define      CyENB_RCVR         (0x02)
+#define      CyDIS_RCVR         (0x01)
+#define CyCAR           (0xee)
+#define CyIER           (0x11)
+#define      CyMdmCh            (0x80)
+#define      CyRxExc            (0x20)
+#define      CyRxData           (0x08)
+#define      CyTxMpty           (0x02)
+#define      CyTxRdy            (0x01)
+#define CyLICR          (0x26)
+#define CyRISR          (0x89)
+#define      CyTIMEOUT          (0x80)
+#define      CySPECHAR          (0x70)
+#define      CyOVERRUN          (0x08)
+#define      CyPARITY           (0x04)
+#define      CyFRAME            (0x02)
+#define      CyBREAK            (0x01)
+#define CyREOIR         (0x84)
+#define CyTEOIR         (0x85)
+#define CyMEOIR         (0x86)
+#define      CyNOTRANS          (0x08)
+#define CyRFOC          (0x30)
+#define CyRDR           (0xf8)
+#define CyTDR           (0xf8)
+#define CyMISR          (0x8b)
+#define CyRISR          (0x89)
+#define CyTISR          (0x8a)
+#define CyMSVR1         (0xde)
+#define CyMSVR2         (0xdf)
+#define      CyDSR              (0x80)
+#define      CyDCD              (0x40)
+#define      CyCTS              (0x20)
+#define      CyDTR              (0x02)
+#define      CyRTS              (0x01)
+#define CyRTPRL         (0x25)
+#define CyRTPRH         (0x24)
+#define CyCOR1          (0x10)
+#define      CyPARITY_NONE      (0x00)
+#define      CyPARITY_E         (0x40)
+#define      CyPARITY_O         (0xC0)
+#define      Cy_5_BITS          (0x04)
+#define      Cy_6_BITS          (0x05)
+#define      Cy_7_BITS          (0x06)
+#define      Cy_8_BITS          (0x07)
+#define CyCOR2          (0x17)
+#define      CyETC              (0x20)
+#define      CyCtsAE            (0x02)
+#define CyCOR3          (0x16)
+#define      Cy_1_STOP          (0x02)
+#define      Cy_2_STOP          (0x04)
+#define CyCOR4          (0x15)
+#define      CyREC_FIFO         (0x0F)  /* Receive FIFO threshold */
+#define CyCOR5          (0x14)
+#define CyCOR6          (0x18)
+#define CyCOR7          (0x07)
+#define CyRBPR          (0xcb)
+#define CyRCOR          (0xc8)
+#define CyTBPR          (0xc3)
+#define CyTCOR          (0xc0)
+#define CySCHR1         (0x1f)
+#define CySCHR2         (0x1e)
+#define CyTPR           (0xda)
+#define CyPILR1         (0xe3)
+#define CyPILR2         (0xe0)
+#define CyPILR3         (0xe1)
+#define CyCMR           (0x1b)
+#define      CyASYNC            (0x02)
+#define CyLICR          (0x26)
+#define CyLIVR          (0x09)
+#define CySCRL          (0x23)
+#define CySCRH          (0x22)
+#define CyTFTC          (0x80)
+
+
+/* max number of chars in the FIFO */
+
+#define CyMAX_CHAR_FIFO 12
+
+/***************************************************************************/
diff --git a/include/linux/serialP.h b/include/linux/serialP.h
new file mode 100644
index 000000000000..2307f11d8a6b
--- /dev/null
+++ b/include/linux/serialP.h
@@ -0,0 +1,184 @@
+/*
+ * Private header file for the (dumb) serial driver
+ *
+ * Copyright (C) 1997 by Theodore Ts'o.
+ * 
+ * Redistribution of this file is permitted under the terms of the GNU 
+ * Public License (GPL)
+ */
+
+#ifndef _LINUX_SERIALP_H
+#define _LINUX_SERIALP_H
+
+/*
+ * This is our internal structure for each serial port's state.
+ * 
+ * Many fields are paralleled by the structure used by the serial_struct
+ * structure.
+ *
+ * For definitions of the flags field, see tty.h
+ */
+
+#include <linux/version.h>
+#include <linux/config.h>
+#include <linux/termios.h>
+#include <linux/workqueue.h>
+#include <linux/interrupt.h>
+#include <linux/circ_buf.h>
+#include <linux/wait.h>
+
+struct serial_state {
+        int     magic;
+        int     baud_base;
+        unsigned long   port;
+        int     irq;
+        int     flags;
+        int     hub6;
+        int     type;
+        int     line;
+        int     revision;       /* Chip revision (950) */
+        int     xmit_fifo_size;
+        int     custom_divisor;
+        int     count;
+        u8      *iomem_base;
+        u16     iomem_reg_shift;
+        unsigned short  close_delay;
+        unsigned short  closing_wait; /* time to wait before closing */
+        struct async_icount     icount; 
+        int     io_type;
+        struct async_struct *info;
+        struct pci_dev  *dev;
+};
+
+struct async_struct {
+        int                     magic;
+        unsigned long           port;
+        int                     hub6;
+        int                     flags;
+        int                     xmit_fifo_size;
+        struct serial_state     *state;
+        struct tty_struct       *tty;
+        int                     read_status_mask;
+        int                     ignore_status_mask;
+        int                     timeout;
+        int                     quot;
+        int                     x_char; /* xon/xoff character */
+        int                     close_delay;
+        unsigned short          closing_wait;
+        unsigned short          closing_wait2; /* obsolete */
+        int                     IER;    /* Interrupt Enable Register */
+        int                     MCR;    /* Modem control register */
+        int                     LCR;    /* Line control register */
+        int                     ACR;     /* 16950 Additional Control Reg. */
+        unsigned long           event;
+        unsigned long           last_active;
+        int                     line;
+        int                     blocked_open; /* # of blocked opens */
+        struct circ_buf         xmit;
+        spinlock_t              xmit_lock;
+        u8                      *iomem_base;
+        u16                     iomem_reg_shift;
+        int                     io_type;
+        struct work_struct                      work;
+        struct tasklet_struct   tlet;
+#ifdef DECLARE_WAITQUEUE
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        wait_queue_head_t       delta_msr_wait;
+#else   
+        struct wait_queue       *open_wait;
+        struct wait_queue       *close_wait;
+        struct wait_queue       *delta_msr_wait;
+#endif  
+        struct async_struct     *next_port; /* For the linked list */
+        struct async_struct     *prev_port;
+};
+
+#define CONFIGURED_SERIAL_PORT(info) ((info)->port || ((info)->iomem_base))
+
+#define SERIAL_MAGIC 0x5301
+#define SSTATE_MAGIC 0x5302
+
+/*
+ * Events are used to schedule things to happen at timer-interrupt
+ * time, instead of at rs interrupt time.
+ */
+#define RS_EVENT_WRITE_WAKEUP   0
+
+/*
+ * Multiport serial configuration structure --- internal structure
+ */
+struct rs_multiport_struct {
+        int             port1;
+        unsigned char   mask1, match1;
+        int             port2;
+        unsigned char   mask2, match2;
+        int             port3;
+        unsigned char   mask3, match3;
+        int             port4;
+        unsigned char   mask4, match4;
+        int             port_monitor;
+};
+
+#if defined(__alpha__) && !defined(CONFIG_PCI)
+/*
+ * Digital did something really horribly wrong with the OUT1 and OUT2
+ * lines on at least some ALPHA's.  The failure mode is that if either
+ * is cleared, the machine locks up with endless interrupts.
+ *
+ * This is still used by arch/mips/au1000/common/serial.c for some weird
+ * reason (mips != alpha!)
+ */
+#define ALPHA_KLUDGE_MCR  (UART_MCR_OUT2 | UART_MCR_OUT1)
+#elif defined(CONFIG_SBC8560)
+/*
+ * WindRiver did something similarly broken on their SBC8560 board. The
+ * UART tristates its IRQ output while OUT2 is clear, but they pulled
+ * the interrupt line _up_ instead of down, so if we register the IRQ
+ * while the UART is in that state, we die in an IRQ storm. */
+#define ALPHA_KLUDGE_MCR (UART_MCR_OUT2)
+#else
+#define ALPHA_KLUDGE_MCR 0
+#endif
+
+/*
+ * Definitions for PCI support.
+ */
+#define SPCI_FL_BASE_MASK       0x0007
+#define SPCI_FL_BASE0   0x0000
+#define SPCI_FL_BASE1   0x0001
+#define SPCI_FL_BASE2   0x0002
+#define SPCI_FL_BASE3   0x0003
+#define SPCI_FL_BASE4   0x0004
+#define SPCI_FL_GET_BASE(x)     (x & SPCI_FL_BASE_MASK)
+
+#define SPCI_FL_IRQ_MASK       (0x0007 << 4)
+#define SPCI_FL_IRQBASE0       (0x0000 << 4)
+#define SPCI_FL_IRQBASE1       (0x0001 << 4)
+#define SPCI_FL_IRQBASE2       (0x0002 << 4)
+#define SPCI_FL_IRQBASE3       (0x0003 << 4)
+#define SPCI_FL_IRQBASE4       (0x0004 << 4)
+#define SPCI_FL_GET_IRQBASE(x)        ((x & SPCI_FL_IRQ_MASK) >> 4)
+
+/* Use successive BARs (PCI base address registers), 
+   else use offset into some specified BAR */
+#define SPCI_FL_BASE_TABLE      0x0100
+
+/* Use successive entries in the irq resource table */
+#define SPCI_FL_IRQ_TABLE       0x0200
+
+/* Use the irq resource table instead of dev->irq */
+#define SPCI_FL_IRQRESOURCE     0x0400
+
+/* Use the Base address register size to cap number of ports */
+#define SPCI_FL_REGION_SZ_CAP   0x0800
+
+/* Do not use irq sharing for this device */
+#define SPCI_FL_NO_SHIRQ        0x1000
+
+/* This is a PNP device */
+#define SPCI_FL_ISPNP           0x2000
+
+#define SPCI_FL_PNPDEFAULT      (SPCI_FL_IRQRESOURCE|SPCI_FL_ISPNP)
+
+#endif /* _LINUX_SERIAL_H */
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
new file mode 100644
index 000000000000..823181af6ddf
--- /dev/null
+++ b/include/linux/serial_8250.h
@@ -0,0 +1,28 @@
+/*
+ *  linux/include/linux/serial_8250.h
+ *
+ *  Copyright (C) 2004 Russell King
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#ifndef _LINUX_SERIAL_8250_H
+#define _LINUX_SERIAL_8250_H
+
+#include <linux/serial_core.h>
+#include <linux/device.h>
+
+struct plat_serial8250_port {
+        unsigned long   iobase;         /* io base address */
+        void __iomem    *membase;       /* ioremap cookie or NULL */
+        unsigned long   mapbase;        /* resource base */
+        unsigned int    irq;            /* interrupt number */
+        unsigned int    uartclk;        /* UART clock rate */
+        unsigned char   regshift;       /* register shift */
+        unsigned char   iotype;         /* UPIO_* */
+        unsigned int    flags;          /* UPF_* flags */
+};
+
+#endif
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
new file mode 100644
index 000000000000..c3fb5984f250
--- /dev/null
+++ b/include/linux/serial_core.h
@@ -0,0 +1,491 @@
+/*
+ *  linux/drivers/char/serial_core.h
+ *
+ *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef LINUX_SERIAL_CORE_H
+#define LINUX_SERIAL_CORE_H
+
+/*
+ * The type definitions.  These are from Ted Ts'o's serial.h
+ */
+#define PORT_UNKNOWN    0
+#define PORT_8250       1
+#define PORT_16450      2
+#define PORT_16550      3
+#define PORT_16550A     4
+#define PORT_CIRRUS     5
+#define PORT_16650      6
+#define PORT_16650V2    7
+#define PORT_16750      8
+#define PORT_STARTECH   9
+#define PORT_16C950     10
+#define PORT_16654      11
+#define PORT_16850      12
+#define PORT_RSA        13
+#define PORT_NS16550A   14
+#define PORT_XSCALE     15
+#define PORT_MAX_8250   15      /* max port ID */
+
+/*
+ * ARM specific type numbers.  These are not currently guaranteed
+ * to be implemented, and will change in the future.  These are
+ * separate so any additions to the old serial.c that occur before
+ * we are merged can be easily merged here.
+ */
+#define PORT_PXA        31
+#define PORT_AMBA       32
+#define PORT_CLPS711X   33
+#define PORT_SA1100     34
+#define PORT_UART00     35
+#define PORT_21285      37
+
+/* Sparc type numbers.  */
+#define PORT_SUNZILOG   38
+#define PORT_SUNSAB     39
+
+/* NEC v850.  */
+#define PORT_V850E_UART 40
+
+/* DZ */
+#define PORT_DZ         47
+
+/* Parisc type numbers. */
+#define PORT_MUX        48
+
+/* Macintosh Zilog type numbers */
+#define PORT_MAC_ZILOG  50      /* m68k : not yet implemented */
+#define PORT_PMAC_ZILOG 51
+
+/* SH-SCI */
+#define PORT_SCI        52
+#define PORT_SCIF       53
+#define PORT_IRDA       54
+
+/* Samsung S3C2410 SoC and derivatives thereof */
+#define PORT_S3C2410    55
+
+/* SGI IP22 aka Indy / Challenge S / Indigo 2 */
+#define PORT_IP22ZILOG  56
+
+/* Sharp LH7a40x -- an ARM9 SoC series */
+#define PORT_LH7A40X    57
+
+/* PPC CPM type number */
+#define PORT_CPM        58
+
+/* MPC52xx type numbers */
+#define PORT_MPC52xx    59
+
+/* IBM icom */
+#define PORT_ICOM       60
+
+/* Samsung S3C2440 SoC */
+#define PORT_S3C2440    61
+
+/* Motorola i.MX SoC */
+#define PORT_IMX        62
+
+/* Marvell MPSC */
+#define PORT_MPSC       63
+
+/* TXX9 type number */
+#define PORT_TXX9       64
+
+/* NEC VR4100 series SIU/DSIU */
+#define PORT_VR41XX_SIU         65
+#define PORT_VR41XX_DSIU        66
+
+/* Samsung S3C2400 SoC */
+#define PORT_S3C2400    67
+
+/* M32R SIO */
+#define PORT_M32R_SIO   68
+
+/*Digi jsm */
+#define PORT_JSM        65
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/interrupt.h>
+#include <linux/circ_buf.h>
+#include <linux/spinlock.h>
+#include <linux/sched.h>
+#include <linux/tty.h>
+
+struct uart_port;
+struct uart_info;
+struct serial_struct;
+struct device;
+
+/*
+ * This structure describes all the operations that can be
+ * done on the physical hardware.
+ */
+struct uart_ops {
+        unsigned int    (*tx_empty)(struct uart_port *);
+        void            (*set_mctrl)(struct uart_port *, unsigned int mctrl);
+        unsigned int    (*get_mctrl)(struct uart_port *);
+        void            (*stop_tx)(struct uart_port *, unsigned int tty_stop);
+        void            (*start_tx)(struct uart_port *, unsigned int tty_start);
+        void            (*send_xchar)(struct uart_port *, char ch);
+        void            (*stop_rx)(struct uart_port *);
+        void            (*enable_ms)(struct uart_port *);
+        void            (*break_ctl)(struct uart_port *, int ctl);
+        int             (*startup)(struct uart_port *);
+        void            (*shutdown)(struct uart_port *);
+        void            (*set_termios)(struct uart_port *, struct termios *new,
+                                       struct termios *old);
+        void            (*pm)(struct uart_port *, unsigned int state,
+                              unsigned int oldstate);
+        int             (*set_wake)(struct uart_port *, unsigned int state);
+
+        /*
+         * Return a string describing the type of the port
+         */
+        const char *(*type)(struct uart_port *);
+
+        /*
+         * Release IO and memory resources used by the port.
+         * This includes iounmap if necessary.
+         */
+        void            (*release_port)(struct uart_port *);
+
+        /*
+         * Request IO and memory resources used by the port.
+         * This includes iomapping the port if necessary.
+         */
+        int             (*request_port)(struct uart_port *);
+        void            (*config_port)(struct uart_port *, int);
+        int             (*verify_port)(struct uart_port *, struct serial_struct *);
+        int             (*ioctl)(struct uart_port *, unsigned int, unsigned long);
+};
+
+#define UART_CONFIG_TYPE        (1 << 0)
+#define UART_CONFIG_IRQ         (1 << 1)
+
+struct uart_icount {
+        __u32   cts;
+        __u32   dsr;
+        __u32   rng;
+        __u32   dcd;
+        __u32   rx;
+        __u32   tx;
+        __u32   frame;
+        __u32   overrun;
+        __u32   parity;
+        __u32   brk;
+        __u32   buf_overrun;
+};
+
+struct uart_port {
+        spinlock_t              lock;                   /* port lock */
+        unsigned int            iobase;                 /* in/out[bwl] */
+        unsigned char __iomem   *membase;               /* read/write[bwl] */
+        unsigned int            irq;                    /* irq number */
+        unsigned int            uartclk;                /* base uart clock */
+        unsigned char           fifosize;               /* tx fifo size */
+        unsigned char           x_char;                 /* xon/xoff char */
+        unsigned char           regshift;               /* reg offset shift */
+        unsigned char           iotype;                 /* io access style */
+
+#define UPIO_PORT               (0)
+#define UPIO_HUB6               (1)
+#define UPIO_MEM                (2)
+#define UPIO_MEM32              (3)
+
+        unsigned int            read_status_mask;       /* driver specific */
+        unsigned int            ignore_status_mask;     /* driver specific */
+        struct uart_info        *info;                  /* pointer to parent info */
+        struct uart_icount      icount;                 /* statistics */
+
+        struct console          *cons;                  /* struct console, if any */
+#ifdef CONFIG_SERIAL_CORE_CONSOLE
+        unsigned long           sysrq;                  /* sysrq timeout */
+#endif
+
+        unsigned int            flags;
+
+#define UPF_FOURPORT            (1 << 1)
+#define UPF_SAK                 (1 << 2)
+#define UPF_SPD_MASK            (0x1030)
+#define UPF_SPD_HI              (0x0010)
+#define UPF_SPD_VHI             (0x0020)
+#define UPF_SPD_CUST            (0x0030)
+#define UPF_SPD_SHI             (0x1000)
+#define UPF_SPD_WARP            (0x1010)
+#define UPF_SKIP_TEST           (1 << 6)
+#define UPF_AUTO_IRQ            (1 << 7)
+#define UPF_HARDPPS_CD          (1 << 11)
+#define UPF_LOW_LATENCY         (1 << 13)
+#define UPF_BUGGY_UART          (1 << 14)
+#define UPF_AUTOPROBE           (1 << 15)
+#define UPF_MAGIC_MULTIPLIER    (1 << 16)
+#define UPF_BOOT_ONLYMCA        (1 << 22)
+#define UPF_CONS_FLOW           (1 << 23)
+#define UPF_SHARE_IRQ           (1 << 24)
+#define UPF_BOOT_AUTOCONF       (1 << 28)
+#define UPF_IOREMAP             (1 << 31)
+
+#define UPF_CHANGE_MASK         (0x17fff)
+#define UPF_USR_MASK            (UPF_SPD_MASK|UPF_LOW_LATENCY)
+
+        unsigned int            mctrl;                  /* current modem ctrl settings */
+        unsigned int            timeout;                /* character-based timeout */
+        unsigned int            type;                   /* port type */
+        struct uart_ops         *ops;
+        unsigned int            custom_divisor;
+        unsigned int            line;                   /* port index */
+        unsigned long           mapbase;                /* for ioremap */
+        struct device           *dev;                   /* parent device */
+        unsigned char           hub6;                   /* this should be in the 8250 driver */
+        unsigned char           unused[3];
+};
+
+/*
+ * This is the state information which is persistent across opens.
+ * The low level driver must not to touch any elements contained
+ * within.
+ */
+struct uart_state {
+        unsigned int            close_delay;            /* msec */
+        unsigned int            closing_wait;           /* msec */
+
+#define USF_CLOSING_WAIT_INF    (0)
+#define USF_CLOSING_WAIT_NONE   (~0U)
+
+        int                     count;
+        int                     pm_state;
+        struct uart_info        *info;
+        struct uart_port        *port;
+
+        struct semaphore        sem;
+};
+
+#define UART_XMIT_SIZE  PAGE_SIZE
+/*
+ * This is the state information which is only valid when the port
+ * is open; it may be freed by the core driver once the device has
+ * been closed.  Either the low level driver or the core can modify
+ * stuff here.
+ */
+struct uart_info {
+        struct tty_struct       *tty;
+        struct circ_buf         xmit;
+        unsigned int            flags;
+
+/*
+ * These are the flags that specific to info->flags, and reflect our
+ * internal state.  They can not be accessed via port->flags.  Low
+ * level drivers must not change these, but may query them instead.
+ */
+#define UIF_CHECK_CD            (1 << 25)
+#define UIF_CTS_FLOW            (1 << 26)
+#define UIF_NORMAL_ACTIVE       (1 << 29)
+#define UIF_INITIALIZED         (1 << 31)
+
+        int                     blocked_open;
+
+        struct tasklet_struct   tlet;
+
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       delta_msr_wait;
+};
+
+/* number of characters left in xmit buffer before we ask for more */
+#define WAKEUP_CHARS            256
+
+struct module;
+struct tty_driver;
+
+struct uart_driver {
+        struct module           *owner;
+        const char              *driver_name;
+        const char              *dev_name;
+        const char              *devfs_name;
+        int                      major;
+        int                      minor;
+        int                      nr;
+        struct console          *cons;
+
+        /*
+         * these are private; the low level driver should not
+         * touch these; they should be initialised to NULL
+         */
+        struct uart_state       *state;
+        struct tty_driver       *tty_driver;
+};
+
+void uart_write_wakeup(struct uart_port *port);
+
+/*
+ * Baud rate helpers.
+ */
+void uart_update_timeout(struct uart_port *port, unsigned int cflag,
+                         unsigned int baud);
+unsigned int uart_get_baud_rate(struct uart_port *port, struct termios *termios,
+                                struct termios *old, unsigned int min,
+                                unsigned int max);
+unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud);
+
+/*
+ * Console helpers.
+ */
+struct uart_port *uart_get_console(struct uart_port *ports, int nr,
+                                   struct console *c);
+void uart_parse_options(char *options, int *baud, int *parity, int *bits,
+                        int *flow);
+int uart_set_options(struct uart_port *port, struct console *co, int baud,
+                     int parity, int bits, int flow);
+struct tty_driver *uart_console_device(struct console *co, int *index);
+
+/*
+ * Port/driver registration/removal
+ */
+int uart_register_driver(struct uart_driver *uart);
+void uart_unregister_driver(struct uart_driver *uart);
+void uart_unregister_port(struct uart_driver *reg, int line);
+int uart_register_port(struct uart_driver *reg, struct uart_port *port);
+int uart_add_one_port(struct uart_driver *reg, struct uart_port *port);
+int uart_remove_one_port(struct uart_driver *reg, struct uart_port *port);
+int uart_match_port(struct uart_port *port1, struct uart_port *port2);
+
+/*
+ * Power Management
+ */
+int uart_suspend_port(struct uart_driver *reg, struct uart_port *port);
+int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
+
+#define uart_circ_empty(circ)           ((circ)->head == (circ)->tail)
+#define uart_circ_clear(circ)           ((circ)->head = (circ)->tail = 0)
+
+#define uart_circ_chars_pending(circ)   \
+        (CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
+
+#define uart_circ_chars_free(circ)      \
+        (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
+
+#define uart_tx_stopped(port)           \
+        ((port)->info->tty->stopped || (port)->info->tty->hw_stopped)
+
+/*
+ * The following are helper functions for the low level drivers.
+ */
+#ifdef SUPPORT_SYSRQ
+static inline int
+uart_handle_sysrq_char(struct uart_port *port, unsigned int ch,
+                       struct pt_regs *regs)
+{
+        if (port->sysrq) {
+                if (ch && time_before(jiffies, port->sysrq)) {
+                        handle_sysrq(ch, regs, NULL);
+                        port->sysrq = 0;
+                        return 1;
+                }
+                port->sysrq = 0;
+        }
+        return 0;
+}
+#else
+#define uart_handle_sysrq_char(port,ch,regs)    (0)
+#endif
+
+/*
+ * We do the SysRQ and SAK checking like this...
+ */
+static inline int uart_handle_break(struct uart_port *port)
+{
+        struct uart_info *info = port->info;
+#ifdef SUPPORT_SYSRQ
+        if (port->cons && port->cons->index == port->line) {
+                if (!port->sysrq) {
+                        port->sysrq = jiffies + HZ*5;
+                        return 1;
+                }
+                port->sysrq = 0;
+        }
+#endif
+        if (info->flags & UPF_SAK)
+                do_SAK(info->tty);
+        return 0;
+}
+
+/**
+ *      uart_handle_dcd_change - handle a change of carrier detect state
+ *      @port: uart_port structure for the open port
+ *      @status: new carrier detect status, nonzero if active
+ */
+static inline void
+uart_handle_dcd_change(struct uart_port *port, unsigned int status)
+{
+        struct uart_info *info = port->info;
+
+        port->icount.dcd++;
+
+#ifdef CONFIG_HARD_PPS
+        if ((port->flags & UPF_HARDPPS_CD) && status)
+                hardpps();
+#endif
+
+        if (info->flags & UIF_CHECK_CD) {
+                if (status)
+                        wake_up_interruptible(&info->open_wait);
+                else if (info->tty)
+                        tty_hangup(info->tty);
+        }
+}
+
+/**
+ *      uart_handle_cts_change - handle a change of clear-to-send state
+ *      @port: uart_port structure for the open port
+ *      @status: new clear to send status, nonzero if active
+ */
+static inline void
+uart_handle_cts_change(struct uart_port *port, unsigned int status)
+{
+        struct uart_info *info = port->info;
+        struct tty_struct *tty = info->tty;
+
+        port->icount.cts++;
+
+        if (info->flags & UIF_CTS_FLOW) {
+                if (tty->hw_stopped) {
+                        if (status) {
+                                tty->hw_stopped = 0;
+                                port->ops->start_tx(port, 0);
+                                uart_write_wakeup(port);
+                        }
+                } else {
+                        if (!status) {
+                                tty->hw_stopped = 1;
+                                port->ops->stop_tx(port, 0);
+                        }
+                }
+        }
+}
+
+/*
+ *      UART_ENABLE_MS - determine if port should enable modem status irqs
+ */
+#define UART_ENABLE_MS(port,cflag)      ((port)->flags & UPF_HARDPPS_CD || \
+                                         (cflag) & CRTSCTS || \
+                                         !((cflag) & CLOCAL))
+
+#endif
+
+#endif /* LINUX_SERIAL_CORE_H */
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
new file mode 100644
index 000000000000..6a2bb955844b
--- /dev/null
+++ b/include/linux/serial_reg.h
@@ -0,0 +1,325 @@
+/*
+ * include/linux/serial_reg.h
+ *
+ * Copyright (C) 1992, 1994 by Theodore Ts'o.
+ * 
+ * Redistribution of this file is permitted under the terms of the GNU 
+ * Public License (GPL)
+ * 
+ * These are the UART port assignments, expressed as offsets from the base
+ * register.  These assignments should hold for any serial port based on
+ * a 8250, 16450, or 16550(A).
+ */
+
+#ifndef _LINUX_SERIAL_REG_H
+#define _LINUX_SERIAL_REG_H
+
+/*
+ * DLAB=0
+ */
+#define UART_RX         0       /* In:  Receive buffer */
+#define UART_TX         0       /* Out: Transmit buffer */
+
+#define UART_IER        1       /* Out: Interrupt Enable Register */
+#define UART_IER_MSI            0x08 /* Enable Modem status interrupt */
+#define UART_IER_RLSI           0x04 /* Enable receiver line status interrupt */
+#define UART_IER_THRI           0x02 /* Enable Transmitter holding register int. */
+#define UART_IER_RDI            0x01 /* Enable receiver data interrupt */
+/*
+ * Sleep mode for ST16650 and TI16750.  For the ST16650, EFR[4]=1
+ */
+#define UART_IERX_SLEEP         0x10 /* Enable sleep mode */
+
+#define UART_IIR        2       /* In:  Interrupt ID Register */
+#define UART_IIR_NO_INT         0x01 /* No interrupts pending */
+#define UART_IIR_ID             0x06 /* Mask for the interrupt ID */
+#define UART_IIR_MSI            0x00 /* Modem status interrupt */
+#define UART_IIR_THRI           0x02 /* Transmitter holding register empty */
+#define UART_IIR_RDI            0x04 /* Receiver data interrupt */
+#define UART_IIR_RLSI           0x06 /* Receiver line status interrupt */
+
+#define UART_FCR        2       /* Out: FIFO Control Register */
+#define UART_FCR_ENABLE_FIFO    0x01 /* Enable the FIFO */
+#define UART_FCR_CLEAR_RCVR     0x02 /* Clear the RCVR FIFO */
+#define UART_FCR_CLEAR_XMIT     0x04 /* Clear the XMIT FIFO */
+#define UART_FCR_DMA_SELECT     0x08 /* For DMA applications */
+/*
+ * Note: The FIFO trigger levels are chip specific:
+ *      RX:76 = 00  01  10  11  TX:54 = 00  01  10  11
+ * PC16550D:     1   4   8  14          xx  xx  xx  xx
+ * TI16C550A:    1   4   8  14          xx  xx  xx  xx
+ * TI16C550C:    1   4   8  14          xx  xx  xx  xx
+ * ST16C550:     1   4   8  14          xx  xx  xx  xx
+ * ST16C650:     8  16  24  28          16   8  24  30  PORT_16650V2
+ * NS16C552:     1   4   8  14          xx  xx  xx  xx
+ * ST16C654:     8  16  56  60           8  16  32  56  PORT_16654
+ * TI16C750:     1  16  32  56          xx  xx  xx  xx  PORT_16750
+ * TI16C752:     8  16  56  60           8  16  32  56
+ */
+#define UART_FCR_R_TRIG_00      0x00
+#define UART_FCR_R_TRIG_01      0x40
+#define UART_FCR_R_TRIG_10      0x80
+#define UART_FCR_R_TRIG_11      0xc0
+#define UART_FCR_T_TRIG_00      0x00
+#define UART_FCR_T_TRIG_01      0x10
+#define UART_FCR_T_TRIG_10      0x20
+#define UART_FCR_T_TRIG_11      0x30
+
+#define UART_FCR_TRIGGER_MASK   0xC0 /* Mask for the FIFO trigger range */
+#define UART_FCR_TRIGGER_1      0x00 /* Mask for trigger set at 1 */
+#define UART_FCR_TRIGGER_4      0x40 /* Mask for trigger set at 4 */
+#define UART_FCR_TRIGGER_8      0x80 /* Mask for trigger set at 8 */
+#define UART_FCR_TRIGGER_14     0xC0 /* Mask for trigger set at 14 */
+/* 16650 definitions */
+#define UART_FCR6_R_TRIGGER_8   0x00 /* Mask for receive trigger set at 1 */
+#define UART_FCR6_R_TRIGGER_16  0x40 /* Mask for receive trigger set at 4 */
+#define UART_FCR6_R_TRIGGER_24  0x80 /* Mask for receive trigger set at 8 */
+#define UART_FCR6_R_TRIGGER_28  0xC0 /* Mask for receive trigger set at 14 */
+#define UART_FCR6_T_TRIGGER_16  0x00 /* Mask for transmit trigger set at 16 */
+#define UART_FCR6_T_TRIGGER_8   0x10 /* Mask for transmit trigger set at 8 */
+#define UART_FCR6_T_TRIGGER_24  0x20 /* Mask for transmit trigger set at 24 */
+#define UART_FCR6_T_TRIGGER_30  0x30 /* Mask for transmit trigger set at 30 */
+#define UART_FCR7_64BYTE        0x20 /* Go into 64 byte mode (TI16C750) */
+
+#define UART_LCR        3       /* Out: Line Control Register */
+/*
+ * Note: if the word length is 5 bits (UART_LCR_WLEN5), then setting 
+ * UART_LCR_STOP will select 1.5 stop bits, not 2 stop bits.
+ */
+#define UART_LCR_DLAB           0x80 /* Divisor latch access bit */
+#define UART_LCR_SBC            0x40 /* Set break control */
+#define UART_LCR_SPAR           0x20 /* Stick parity (?) */
+#define UART_LCR_EPAR           0x10 /* Even parity select */
+#define UART_LCR_PARITY         0x08 /* Parity Enable */
+#define UART_LCR_STOP           0x04 /* Stop bits: 0=1 bit, 1=2 bits */
+#define UART_LCR_WLEN5          0x00 /* Wordlength: 5 bits */
+#define UART_LCR_WLEN6          0x01 /* Wordlength: 6 bits */
+#define UART_LCR_WLEN7          0x02 /* Wordlength: 7 bits */
+#define UART_LCR_WLEN8          0x03 /* Wordlength: 8 bits */
+
+#define UART_MCR        4       /* Out: Modem Control Register */
+#define UART_MCR_CLKSEL         0x80 /* Divide clock by 4 (TI16C752, EFR[4]=1) */
+#define UART_MCR_TCRTLR         0x40 /* Access TCR/TLR (TI16C752, EFR[4]=1) */
+#define UART_MCR_XONANY         0x20 /* Enable Xon Any (TI16C752, EFR[4]=1) */
+#define UART_MCR_AFE            0x20 /* Enable auto-RTS/CTS (TI16C550C/TI16C750) */
+#define UART_MCR_LOOP           0x10 /* Enable loopback test mode */
+#define UART_MCR_OUT2           0x08 /* Out2 complement */
+#define UART_MCR_OUT1           0x04 /* Out1 complement */
+#define UART_MCR_RTS            0x02 /* RTS complement */
+#define UART_MCR_DTR            0x01 /* DTR complement */
+
+#define UART_LSR        5       /* In:  Line Status Register */
+#define UART_LSR_TEMT           0x40 /* Transmitter empty */
+#define UART_LSR_THRE           0x20 /* Transmit-hold-register empty */
+#define UART_LSR_BI             0x10 /* Break interrupt indicator */
+#define UART_LSR_FE             0x08 /* Frame error indicator */
+#define UART_LSR_PE             0x04 /* Parity error indicator */
+#define UART_LSR_OE             0x02 /* Overrun error indicator */
+#define UART_LSR_DR             0x01 /* Receiver data ready */
+
+#define UART_MSR        6       /* In:  Modem Status Register */
+#define UART_MSR_DCD            0x80 /* Data Carrier Detect */
+#define UART_MSR_RI             0x40 /* Ring Indicator */
+#define UART_MSR_DSR            0x20 /* Data Set Ready */
+#define UART_MSR_CTS            0x10 /* Clear to Send */
+#define UART_MSR_DDCD           0x08 /* Delta DCD */
+#define UART_MSR_TERI           0x04 /* Trailing edge ring indicator */
+#define UART_MSR_DDSR           0x02 /* Delta DSR */
+#define UART_MSR_DCTS           0x01 /* Delta CTS */
+#define UART_MSR_ANY_DELTA      0x0F /* Any of the delta bits! */
+
+#define UART_SCR        7       /* I/O: Scratch Register */
+
+/*
+ * DLAB=1
+ */
+#define UART_DLL        0       /* Out: Divisor Latch Low */
+#define UART_DLM        1       /* Out: Divisor Latch High */
+
+/*
+ * LCR=0xBF (or DLAB=1 for 16C660)
+ */
+#define UART_EFR        2       /* I/O: Extended Features Register */
+#define UART_EFR_CTS            0x80 /* CTS flow control */
+#define UART_EFR_RTS            0x40 /* RTS flow control */
+#define UART_EFR_SCD            0x20 /* Special character detect */
+#define UART_EFR_ECB            0x10 /* Enhanced control bit */
+/*
+ * the low four bits control software flow control
+ */
+
+/*
+ * LCR=0xBF, TI16C752, ST16650, ST16650A, ST16654
+ */
+#define UART_XON1       4       /* I/O: Xon character 1 */
+#define UART_XON2       5       /* I/O: Xon character 2 */
+#define UART_XOFF1      6       /* I/O: Xoff character 1 */
+#define UART_XOFF2      7       /* I/O: Xoff character 2 */
+
+/*
+ * EFR[4]=1 MCR[6]=1, TI16C752
+ */
+#define UART_TI752_TCR  6       /* I/O: transmission control register */
+#define UART_TI752_TLR  7       /* I/O: trigger level register */
+
+/*
+ * LCR=0xBF, XR16C85x
+ */
+#define UART_TRG        0       /* FCTR bit 7 selects Rx or Tx
+                                 * In: Fifo count
+                                 * Out: Fifo custom trigger levels */
+/*
+ * These are the definitions for the Programmable Trigger Register
+ */
+#define UART_TRG_1              0x01
+#define UART_TRG_4              0x04
+#define UART_TRG_8              0x08
+#define UART_TRG_16             0x10
+#define UART_TRG_32             0x20
+#define UART_TRG_64             0x40
+#define UART_TRG_96             0x60
+#define UART_TRG_120            0x78
+#define UART_TRG_128            0x80
+
+#define UART_FCTR       1       /* Feature Control Register */
+#define UART_FCTR_RTS_NODELAY   0x00  /* RTS flow control delay */
+#define UART_FCTR_RTS_4DELAY    0x01
+#define UART_FCTR_RTS_6DELAY    0x02
+#define UART_FCTR_RTS_8DELAY    0x03
+#define UART_FCTR_IRDA          0x04  /* IrDa data encode select */
+#define UART_FCTR_TX_INT        0x08  /* Tx interrupt type select */
+#define UART_FCTR_TRGA          0x00  /* Tx/Rx 550 trigger table select */
+#define UART_FCTR_TRGB          0x10  /* Tx/Rx 650 trigger table select */
+#define UART_FCTR_TRGC          0x20  /* Tx/Rx 654 trigger table select */
+#define UART_FCTR_TRGD          0x30  /* Tx/Rx 850 programmable trigger select */
+#define UART_FCTR_SCR_SWAP      0x40  /* Scratch pad register swap */
+#define UART_FCTR_RX            0x00  /* Programmable trigger mode select */
+#define UART_FCTR_TX            0x80  /* Programmable trigger mode select */
+
+/*
+ * LCR=0xBF, FCTR[6]=1
+ */
+#define UART_EMSR       7       /* Extended Mode Select Register */
+#define UART_EMSR_FIFO_COUNT    0x01  /* Rx/Tx select */
+#define UART_EMSR_ALT_COUNT     0x02  /* Alternating count select */
+
+/*
+ * The Intel XScale on-chip UARTs define these bits
+ */
+#define UART_IER_DMAE   0x80    /* DMA Requests Enable */
+#define UART_IER_UUE    0x40    /* UART Unit Enable */
+#define UART_IER_NRZE   0x20    /* NRZ coding Enable */
+#define UART_IER_RTOIE  0x10    /* Receiver Time Out Interrupt Enable */
+
+#define UART_IIR_TOD    0x08    /* Character Timeout Indication Detected */
+
+#define UART_FCR_PXAR1  0x00    /* receive FIFO treshold = 1 */
+#define UART_FCR_PXAR8  0x40    /* receive FIFO treshold = 8 */
+#define UART_FCR_PXAR16 0x80    /* receive FIFO treshold = 16 */
+#define UART_FCR_PXAR32 0xc0    /* receive FIFO treshold = 32 */
+
+
+
+
+/*
+ * These register definitions are for the 16C950
+ */
+#define UART_ASR        0x01    /* Additional Status Register */
+#define UART_RFL        0x03    /* Receiver FIFO level */
+#define UART_TFL        0x04    /* Transmitter FIFO level */
+#define UART_ICR        0x05    /* Index Control Register */
+
+/* The 16950 ICR registers */
+#define UART_ACR        0x00    /* Additional Control Register */
+#define UART_CPR        0x01    /* Clock Prescalar Register */
+#define UART_TCR        0x02    /* Times Clock Register */
+#define UART_CKS        0x03    /* Clock Select Register */
+#define UART_TTL        0x04    /* Transmitter Interrupt Trigger Level */
+#define UART_RTL        0x05    /* Receiver Interrupt Trigger Level */
+#define UART_FCL        0x06    /* Flow Control Level Lower */
+#define UART_FCH        0x07    /* Flow Control Level Higher */
+#define UART_ID1        0x08    /* ID #1 */
+#define UART_ID2        0x09    /* ID #2 */
+#define UART_ID3        0x0A    /* ID #3 */
+#define UART_REV        0x0B    /* Revision */
+#define UART_CSR        0x0C    /* Channel Software Reset */
+#define UART_NMR        0x0D    /* Nine-bit Mode Register */
+#define UART_CTR        0xFF
+
+/*
+ * The 16C950 Additional Control Reigster
+ */
+#define UART_ACR_RXDIS  0x01    /* Receiver disable */
+#define UART_ACR_TXDIS  0x02    /* Receiver disable */
+#define UART_ACR_DSRFC  0x04    /* DSR Flow Control */
+#define UART_ACR_TLENB  0x20    /* 950 trigger levels enable */
+#define UART_ACR_ICRRD  0x40    /* ICR Read enable */
+#define UART_ACR_ASREN  0x80    /* Additional status enable */
+
+
+
+/*
+ * These definitions are for the RSA-DV II/S card, from
+ *
+ * Kiyokazu SUTO <suto@ks-and-ks.ne.jp>
+ */
+
+#define UART_RSA_BASE (-8)
+
+#define UART_RSA_MSR ((UART_RSA_BASE) + 0) /* I/O: Mode Select Register */
+
+#define UART_RSA_MSR_SWAP (1 << 0) /* Swap low/high 8 bytes in I/O port addr */
+#define UART_RSA_MSR_FIFO (1 << 2) /* Enable the external FIFO */
+#define UART_RSA_MSR_FLOW (1 << 3) /* Enable the auto RTS/CTS flow control */
+#define UART_RSA_MSR_ITYP (1 << 4) /* Level (1) / Edge triger (0) */
+
+#define UART_RSA_IER ((UART_RSA_BASE) + 1) /* I/O: Interrupt Enable Register */
+
+#define UART_RSA_IER_Rx_FIFO_H (1 << 0) /* Enable Rx FIFO half full int. */
+#define UART_RSA_IER_Tx_FIFO_H (1 << 1) /* Enable Tx FIFO half full int. */
+#define UART_RSA_IER_Tx_FIFO_E (1 << 2) /* Enable Tx FIFO empty int. */
+#define UART_RSA_IER_Rx_TOUT (1 << 3) /* Enable char receive timeout int */
+#define UART_RSA_IER_TIMER (1 << 4) /* Enable timer interrupt */
+
+#define UART_RSA_SRR ((UART_RSA_BASE) + 2) /* IN: Status Read Register */
+
+#define UART_RSA_SRR_Tx_FIFO_NEMP (1 << 0) /* Tx FIFO is not empty (1) */
+#define UART_RSA_SRR_Tx_FIFO_NHFL (1 << 1) /* Tx FIFO is not half full (1) */
+#define UART_RSA_SRR_Tx_FIFO_NFUL (1 << 2) /* Tx FIFO is not full (1) */
+#define UART_RSA_SRR_Rx_FIFO_NEMP (1 << 3) /* Rx FIFO is not empty (1) */
+#define UART_RSA_SRR_Rx_FIFO_NHFL (1 << 4) /* Rx FIFO is not half full (1) */
+#define UART_RSA_SRR_Rx_FIFO_NFUL (1 << 5) /* Rx FIFO is not full (1) */
+#define UART_RSA_SRR_Rx_TOUT (1 << 6) /* Character reception timeout occurred (1) */
+#define UART_RSA_SRR_TIMER (1 << 7) /* Timer interrupt occurred */
+
+#define UART_RSA_FRR ((UART_RSA_BASE) + 2) /* OUT: FIFO Reset Register */
+
+#define UART_RSA_TIVSR ((UART_RSA_BASE) + 3) /* I/O: Timer Interval Value Set Register */
+
+#define UART_RSA_TCR ((UART_RSA_BASE) + 4) /* OUT: Timer Control Register */
+
+#define UART_RSA_TCR_SWITCH (1 << 0) /* Timer on */
+
+/*
+ * The RSA DSV/II board has two fixed clock frequencies.  One is the
+ * standard rate, and the other is 8 times faster.
+ */
+#define SERIAL_RSA_BAUD_BASE (921600)
+#define SERIAL_RSA_BAUD_BASE_LO (SERIAL_RSA_BAUD_BASE / 8)
+
+/*
+ * Extra serial register definitions for the internal UARTs
+ * in TI OMAP processors.
+ */
+#define UART_OMAP_MDR1          0x08    /* Mode definition register */
+#define UART_OMAP_MDR2          0x09    /* Mode definition register 2 */
+#define UART_OMAP_SCR           0x10    /* Supplementary control register */
+#define UART_OMAP_SSR           0x11    /* Supplementary status register */
+#define UART_OMAP_EBLR          0x12    /* BOF length register */
+#define UART_OMAP_OSC_12M_SEL   0x13    /* OMAP1510 12MHz osc select */
+#define UART_OMAP_MVER          0x14    /* Module version register */
+#define UART_OMAP_SYSC          0x15    /* System configuration register */
+#define UART_OMAP_SYSS          0x16    /* System status register */
+
+#endif /* _LINUX_SERIAL_REG_H */
+
diff --git a/include/linux/serio.h b/include/linux/serio.h
new file mode 100644
index 000000000000..a2d3b9ae06f4
--- /dev/null
+++ b/include/linux/serio.h
@@ -0,0 +1,214 @@
+#ifndef _SERIO_H
+#define _SERIO_H
+
+/*
+ * Copyright (C) 1999-2002 Vojtech Pavlik
+*
+ * 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.
+ */
+
+#include <linux/ioctl.h>
+
+#define SPIOCSTYPE      _IOW('q', 0x01, unsigned long)
+
+#ifdef __KERNEL__
+
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/device.h>
+#include <linux/mod_devicetable.h>
+
+struct serio {
+        void *port_data;
+
+        char name[32];
+        char phys[32];
+
+        unsigned int manual_bind;
+
+        struct serio_device_id id;
+
+        spinlock_t lock;                /* protects critical sections from port's interrupt handler */
+
+        int (*write)(struct serio *, unsigned char);
+        int (*open)(struct serio *);
+        void (*close)(struct serio *);
+        int (*start)(struct serio *);
+        void (*stop)(struct serio *);
+
+        struct serio *parent, *child;
+
+        struct serio_driver *drv;       /* accessed from interrupt, must be protected by serio->lock and serio->sem */
+        struct semaphore drv_sem;       /* protects serio->drv so attributes can pin driver */
+
+        struct device dev;
+        unsigned int registered;        /* port has been fully registered with driver core */
+
+        struct list_head node;
+};
+#define to_serio_port(d)        container_of(d, struct serio, dev)
+
+struct serio_driver {
+        void *private;
+        char *description;
+
+        struct serio_device_id *id_table;
+        unsigned int manual_bind;
+
+        void (*write_wakeup)(struct serio *);
+        irqreturn_t (*interrupt)(struct serio *, unsigned char,
+                        unsigned int, struct pt_regs *);
+        int  (*connect)(struct serio *, struct serio_driver *drv);
+        int  (*reconnect)(struct serio *);
+        void (*disconnect)(struct serio *);
+        void (*cleanup)(struct serio *);
+
+        struct device_driver driver;
+};
+#define to_serio_driver(d)      container_of(d, struct serio_driver, driver)
+
+int serio_open(struct serio *serio, struct serio_driver *drv);
+void serio_close(struct serio *serio);
+void serio_rescan(struct serio *serio);
+void serio_reconnect(struct serio *serio);
+irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags, struct pt_regs *regs);
+
+void __serio_register_port(struct serio *serio, struct module *owner);
+static inline void serio_register_port(struct serio *serio)
+{
+        __serio_register_port(serio, THIS_MODULE);
+}
+
+void serio_unregister_port(struct serio *serio);
+void __serio_unregister_port_delayed(struct serio *serio, struct module *owner);
+static inline void serio_unregister_port_delayed(struct serio *serio)
+{
+        __serio_unregister_port_delayed(serio, THIS_MODULE);
+}
+
+void __serio_register_driver(struct serio_driver *drv, struct module *owner);
+static inline void serio_register_driver(struct serio_driver *drv)
+{
+        __serio_register_driver(drv, THIS_MODULE);
+}
+
+void serio_unregister_driver(struct serio_driver *drv);
+
+static inline int serio_write(struct serio *serio, unsigned char data)
+{
+        if (serio->write)
+                return serio->write(serio, data);
+        else
+                return -1;
+}
+
+static inline void serio_drv_write_wakeup(struct serio *serio)
+{
+        if (serio->drv && serio->drv->write_wakeup)
+                serio->drv->write_wakeup(serio);
+}
+
+static inline void serio_cleanup(struct serio *serio)
+{
+        if (serio->drv && serio->drv->cleanup)
+                serio->drv->cleanup(serio);
+}
+
+/*
+ * Use the following fucntions to manipulate serio's per-port
+ * driver-specific data.
+ */
+static inline void *serio_get_drvdata(struct serio *serio)
+{
+        return dev_get_drvdata(&serio->dev);
+}
+
+static inline void serio_set_drvdata(struct serio *serio, void *data)
+{
+        dev_set_drvdata(&serio->dev, data);
+}
+
+/*
+ * Use the following fucntions to protect critical sections in
+ * driver code from port's interrupt handler
+ */
+static inline void serio_pause_rx(struct serio *serio)
+{
+        spin_lock_irq(&serio->lock);
+}
+
+static inline void serio_continue_rx(struct serio *serio)
+{
+        spin_unlock_irq(&serio->lock);
+}
+
+/*
+ * Use the following fucntions to pin serio's driver in process context
+ */
+static inline int serio_pin_driver(struct serio *serio)
+{
+        return down_interruptible(&serio->drv_sem);
+}
+
+static inline void serio_unpin_driver(struct serio *serio)
+{
+        up(&serio->drv_sem);
+}
+
+
+#endif
+
+/*
+ * bit masks for use in "interrupt" flags (3rd argument)
+ */
+#define SERIO_TIMEOUT   1
+#define SERIO_PARITY    2
+#define SERIO_FRAME     4
+
+/*
+ * Serio types
+ */
+#define SERIO_XT        0x00
+#define SERIO_8042      0x01
+#define SERIO_RS232     0x02
+#define SERIO_HIL_MLC   0x03
+#define SERIO_PS_PSTHRU 0x05
+#define SERIO_8042_XL   0x06
+
+/*
+ * Serio types
+ */
+#define SERIO_UNKNOWN   0x00
+#define SERIO_MSC       0x01
+#define SERIO_SUN       0x02
+#define SERIO_MS        0x03
+#define SERIO_MP        0x04
+#define SERIO_MZ        0x05
+#define SERIO_MZP       0x06
+#define SERIO_MZPP      0x07
+#define SERIO_VSXXXAA   0x08
+#define SERIO_SUNKBD    0x10
+#define SERIO_WARRIOR   0x18
+#define SERIO_SPACEORB  0x19
+#define SERIO_MAGELLAN  0x1a
+#define SERIO_SPACEBALL 0x1b
+#define SERIO_GUNZE     0x1c
+#define SERIO_IFORCE    0x1d
+#define SERIO_STINGER   0x1e
+#define SERIO_NEWTON    0x1f
+#define SERIO_STOWAWAY  0x20
+#define SERIO_H3600     0x21
+#define SERIO_PS2SER    0x22
+#define SERIO_TWIDKBD   0x23
+#define SERIO_TWIDJOY   0x24
+#define SERIO_HIL       0x25
+#define SERIO_SNES232   0x26
+#define SERIO_SEMTECH   0x27
+#define SERIO_LKKBD     0x28
+#define SERIO_ELO       0x29
+#define SERIO_MICROTOUCH        0x30
+
+#endif
diff --git a/include/linux/shm.h b/include/linux/shm.h
new file mode 100644
index 000000000000..80113a1f60bc
--- /dev/null
+++ b/include/linux/shm.h
@@ -0,0 +1,108 @@
+#ifndef _LINUX_SHM_H_
+#define _LINUX_SHM_H_
+
+#include <linux/ipc.h>
+#include <linux/errno.h>
+#include <asm/page.h>
+
+/*
+ * SHMMAX, SHMMNI and SHMALL are upper limits are defaults which can
+ * be increased by sysctl
+ */
+
+#define SHMMAX 0x2000000                 /* max shared seg size (bytes) */
+#define SHMMIN 1                         /* min shared seg size (bytes) */
+#define SHMMNI 4096                      /* max num of segs system wide */
+#define SHMALL (SHMMAX/PAGE_SIZE*(SHMMNI/16)) /* max shm system wide (pages) */
+#define SHMSEG SHMMNI                    /* max shared segs per process */
+
+#include <asm/shmparam.h>
+
+/* Obsolete, used only for backwards compatibility and libc5 compiles */
+struct shmid_ds {
+        struct ipc_perm         shm_perm;       /* operation perms */
+        int                     shm_segsz;      /* size of segment (bytes) */
+        __kernel_time_t         shm_atime;      /* last attach time */
+        __kernel_time_t         shm_dtime;      /* last detach time */
+        __kernel_time_t         shm_ctime;      /* last change time */
+        __kernel_ipc_pid_t      shm_cpid;       /* pid of creator */
+        __kernel_ipc_pid_t      shm_lpid;       /* pid of last operator */
+        unsigned short          shm_nattch;     /* no. of current attaches */
+        unsigned short          shm_unused;     /* compatibility */
+        void                    *shm_unused2;   /* ditto - used by DIPC */
+        void                    *shm_unused3;   /* unused */
+};
+
+/* Include the definition of shmid64_ds and shminfo64 */
+#include <asm/shmbuf.h>
+
+/* permission flag for shmget */
+#define SHM_R           0400    /* or S_IRUGO from <linux/stat.h> */
+#define SHM_W           0200    /* or S_IWUGO from <linux/stat.h> */
+
+/* mode for attach */
+#define SHM_RDONLY      010000  /* read-only access */
+#define SHM_RND         020000  /* round attach address to SHMLBA boundary */
+#define SHM_REMAP       040000  /* take-over region on attach */
+#define SHM_EXEC        0100000 /* execution access */
+
+/* super user shmctl commands */
+#define SHM_LOCK        11
+#define SHM_UNLOCK      12
+
+/* ipcs ctl commands */
+#define SHM_STAT        13
+#define SHM_INFO        14
+
+/* Obsolete, used only for backwards compatibility */
+struct  shminfo {
+        int shmmax;
+        int shmmin;
+        int shmmni;
+        int shmseg;
+        int shmall;
+};
+
+struct shm_info {
+        int used_ids;
+        unsigned long shm_tot;  /* total allocated shm */
+        unsigned long shm_rss;  /* total resident shm */
+        unsigned long shm_swp;  /* total swapped shm */
+        unsigned long swap_attempts;
+        unsigned long swap_successes;
+};
+
+#ifdef __KERNEL__
+struct shmid_kernel /* private to the kernel */
+{       
+        struct kern_ipc_perm    shm_perm;
+        struct file *           shm_file;
+        int                     id;
+        unsigned long           shm_nattch;
+        unsigned long           shm_segsz;
+        time_t                  shm_atim;
+        time_t                  shm_dtim;
+        time_t                  shm_ctim;
+        pid_t                   shm_cprid;
+        pid_t                   shm_lprid;
+        struct user_struct      *mlock_user;
+};
+
+/* shm_mode upper byte flags */
+#define SHM_DEST        01000   /* segment will be destroyed on last detach */
+#define SHM_LOCKED      02000   /* segment will not be swapped */
+#define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
+
+#ifdef CONFIG_SYSVIPC
+long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr);
+#else
+static inline long do_shmat(int shmid, char __user *shmaddr,
+                                int shmflg, unsigned long *addr)
+{
+        return -ENOSYS;
+}
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SHM_H_ */
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
new file mode 100644
index 000000000000..c3e598276e78
--- /dev/null
+++ b/include/linux/shmem_fs.h
@@ -0,0 +1,37 @@
+#ifndef __SHMEM_FS_H
+#define __SHMEM_FS_H
+
+#include <linux/swap.h>
+#include <linux/mempolicy.h>
+
+/* inode in-kernel data */
+
+#define SHMEM_NR_DIRECT 16
+
+struct shmem_inode_info {
+        spinlock_t              lock;
+        unsigned long           flags;
+        unsigned long           alloced;        /* data pages alloced to file */
+        unsigned long           swapped;        /* subtotal assigned to swap */
+        unsigned long           next_index;     /* highest alloced index + 1 */
+        struct shared_policy    policy;         /* NUMA memory alloc policy */
+        struct page             *i_indirect;    /* top indirect blocks page */
+        swp_entry_t             i_direct[SHMEM_NR_DIRECT]; /* first blocks */
+        struct list_head        swaplist;       /* chain of maybes on swap */
+        struct inode            vfs_inode;
+};
+
+struct shmem_sb_info {
+        unsigned long max_blocks;   /* How many blocks are allowed */
+        unsigned long free_blocks;  /* How many are left for allocation */
+        unsigned long max_inodes;   /* How many inodes are allowed */
+        unsigned long free_inodes;  /* How many are left for allocation */
+        spinlock_t    stat_lock;
+};
+
+static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
+{
+        return container_of(inode, struct shmem_inode_info, vfs_inode);
+}
+
+#endif
diff --git a/include/linux/signal.h b/include/linux/signal.h
new file mode 100644
index 000000000000..99c97ad026c8
--- /dev/null
+++ b/include/linux/signal.h
@@ -0,0 +1,224 @@
+#ifndef _LINUX_SIGNAL_H
+#define _LINUX_SIGNAL_H
+
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <asm/signal.h>
+#include <asm/siginfo.h>
+
+#ifdef __KERNEL__
+
+/*
+ * Real Time signals may be queued.
+ */
+
+struct sigqueue {
+        struct list_head list;
+        spinlock_t *lock;
+        int flags;
+        siginfo_t info;
+        struct user_struct *user;
+};
+
+/* flags values. */
+#define SIGQUEUE_PREALLOC       1
+
+struct sigpending {
+        struct list_head list;
+        sigset_t signal;
+};
+
+/*
+ * Define some primitives to manipulate sigset_t.
+ */
+
+#ifndef __HAVE_ARCH_SIG_BITOPS
+#include <linux/bitops.h>
+
+/* We don't use <linux/bitops.h> for these because there is no need to
+   be atomic.  */
+static inline void sigaddset(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        if (_NSIG_WORDS == 1)
+                set->sig[0] |= 1UL << sig;
+        else
+                set->sig[sig / _NSIG_BPW] |= 1UL << (sig % _NSIG_BPW);
+}
+
+static inline void sigdelset(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        if (_NSIG_WORDS == 1)
+                set->sig[0] &= ~(1UL << sig);
+        else
+                set->sig[sig / _NSIG_BPW] &= ~(1UL << (sig % _NSIG_BPW));
+}
+
+static inline int sigismember(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        if (_NSIG_WORDS == 1)
+                return 1 & (set->sig[0] >> sig);
+        else
+                return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
+}
+
+static inline int sigfindinword(unsigned long word)
+{
+        return ffz(~word);
+}
+
+#endif /* __HAVE_ARCH_SIG_BITOPS */
+
+#define sigmask(sig)    (1UL << ((sig) - 1))
+
+#ifndef __HAVE_ARCH_SIG_SETOPS
+#include <linux/string.h>
+
+#define _SIG_SET_BINOP(name, op)                                        \
+static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
+{                                                                       \
+        extern void _NSIG_WORDS_is_unsupported_size(void);              \
+        unsigned long a0, a1, a2, a3, b0, b1, b2, b3;                   \
+                                                                        \
+        switch (_NSIG_WORDS) {                                          \
+            case 4:                                                     \
+                a3 = a->sig[3]; a2 = a->sig[2];                         \
+                b3 = b->sig[3]; b2 = b->sig[2];                         \
+                r->sig[3] = op(a3, b3);                                 \
+                r->sig[2] = op(a2, b2);                                 \
+            case 2:                                                     \
+                a1 = a->sig[1]; b1 = b->sig[1];                         \
+                r->sig[1] = op(a1, b1);                                 \
+            case 1:                                                     \
+                a0 = a->sig[0]; b0 = b->sig[0];                         \
+                r->sig[0] = op(a0, b0);                                 \
+                break;                                                  \
+            default:                                                    \
+                _NSIG_WORDS_is_unsupported_size();                      \
+        }                                                               \
+}
+
+#define _sig_or(x,y)    ((x) | (y))
+_SIG_SET_BINOP(sigorsets, _sig_or)
+
+#define _sig_and(x,y)   ((x) & (y))
+_SIG_SET_BINOP(sigandsets, _sig_and)
+
+#define _sig_nand(x,y)  ((x) & ~(y))
+_SIG_SET_BINOP(signandsets, _sig_nand)
+
+#undef _SIG_SET_BINOP
+#undef _sig_or
+#undef _sig_and
+#undef _sig_nand
+
+#define _SIG_SET_OP(name, op)                                           \
+static inline void name(sigset_t *set)                                  \
+{                                                                       \
+        extern void _NSIG_WORDS_is_unsupported_size(void);              \
+                                                                        \
+        switch (_NSIG_WORDS) {                                          \
+            case 4: set->sig[3] = op(set->sig[3]);                      \
+                    set->sig[2] = op(set->sig[2]);                      \
+            case 2: set->sig[1] = op(set->sig[1]);                      \
+            case 1: set->sig[0] = op(set->sig[0]);                      \
+                    break;                                              \
+            default:                                                    \
+                _NSIG_WORDS_is_unsupported_size();                      \
+        }                                                               \
+}
+
+#define _sig_not(x)     (~(x))
+_SIG_SET_OP(signotset, _sig_not)
+
+#undef _SIG_SET_OP
+#undef _sig_not
+
+static inline void sigemptyset(sigset_t *set)
+{
+        switch (_NSIG_WORDS) {
+        default:
+                memset(set, 0, sizeof(sigset_t));
+                break;
+        case 2: set->sig[1] = 0;
+        case 1: set->sig[0] = 0;
+                break;
+        }
+}
+
+static inline void sigfillset(sigset_t *set)
+{
+        switch (_NSIG_WORDS) {
+        default:
+                memset(set, -1, sizeof(sigset_t));
+                break;
+        case 2: set->sig[1] = -1;
+        case 1: set->sig[0] = -1;
+                break;
+        }
+}
+
+/* Some extensions for manipulating the low 32 signals in particular.  */
+
+static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
+{
+        set->sig[0] |= mask;
+}
+
+static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
+{
+        set->sig[0] &= ~mask;
+}
+
+static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
+{
+        return (set->sig[0] & mask) != 0;
+}
+
+static inline void siginitset(sigset_t *set, unsigned long mask)
+{
+        set->sig[0] = mask;
+        switch (_NSIG_WORDS) {
+        default:
+                memset(&set->sig[1], 0, sizeof(long)*(_NSIG_WORDS-1));
+                break;
+        case 2: set->sig[1] = 0;
+        case 1: ;
+        }
+}
+
+static inline void siginitsetinv(sigset_t *set, unsigned long mask)
+{
+        set->sig[0] = ~mask;
+        switch (_NSIG_WORDS) {
+        default:
+                memset(&set->sig[1], -1, sizeof(long)*(_NSIG_WORDS-1));
+                break;
+        case 2: set->sig[1] = -1;
+        case 1: ;
+        }
+}
+
+#endif /* __HAVE_ARCH_SIG_SETOPS */
+
+static inline void init_sigpending(struct sigpending *sig)
+{
+        sigemptyset(&sig->signal);
+        INIT_LIST_HEAD(&sig->list);
+}
+
+extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
+extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
+extern long do_sigpending(void __user *, unsigned long);
+extern int sigprocmask(int, sigset_t *, sigset_t *);
+
+#ifndef HAVE_ARCH_GET_SIGNAL_TO_DELIVER
+struct pt_regs;
+extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SIGNAL_H */
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
new file mode 100644
index 000000000000..aa35797ebfbf
--- /dev/null
+++ b/include/linux/skbuff.h
@@ -0,0 +1,1253 @@
+/*
+ *      Definitions for the 'struct sk_buff' memory handlers.
+ *
+ *      Authors:
+ *              Alan Cox, <gw4pts@gw4pts.ampr.org>
+ *              Florian La Roche, <rzsfl@rz.uni-sb.de>
+ *
+ *      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; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_SKBUFF_H
+#define _LINUX_SKBUFF_H
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/compiler.h>
+#include <linux/time.h>
+#include <linux/cache.h>
+
+#include <asm/atomic.h>
+#include <asm/types.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/poll.h>
+#include <linux/net.h>
+#include <net/checksum.h>
+
+#define HAVE_ALLOC_SKB          /* For the drivers to know */
+#define HAVE_ALIGNABLE_SKB      /* Ditto 8)                */
+#define SLAB_SKB                /* Slabified skbuffs       */
+
+#define CHECKSUM_NONE 0
+#define CHECKSUM_HW 1
+#define CHECKSUM_UNNECESSARY 2
+
+#define SKB_DATA_ALIGN(X)       (((X) + (SMP_CACHE_BYTES - 1)) & \
+                                 ~(SMP_CACHE_BYTES - 1))
+#define SKB_MAX_ORDER(X, ORDER) (((PAGE_SIZE << (ORDER)) - (X) - \
+                                  sizeof(struct skb_shared_info)) & \
+                                  ~(SMP_CACHE_BYTES - 1))
+#define SKB_MAX_HEAD(X)         (SKB_MAX_ORDER((X), 0))
+#define SKB_MAX_ALLOC           (SKB_MAX_ORDER(0, 2))
+
+/* A. Checksumming of received packets by device.
+ *
+ *      NONE: device failed to checksum this packet.
+ *              skb->csum is undefined.
+ *
+ *      UNNECESSARY: device parsed packet and wouldbe verified checksum.
+ *              skb->csum is undefined.
+ *            It is bad option, but, unfortunately, many of vendors do this.
+ *            Apparently with secret goal to sell you new device, when you
+ *            will add new protocol to your host. F.e. IPv6. 8)
+ *
+ *      HW: the most generic way. Device supplied checksum of _all_
+ *          the packet as seen by netif_rx in skb->csum.
+ *          NOTE: Even if device supports only some protocols, but
+ *          is able to produce some skb->csum, it MUST use HW,
+ *          not UNNECESSARY.
+ *
+ * B. Checksumming on output.
+ *
+ *      NONE: skb is checksummed by protocol or csum is not required.
+ *
+ *      HW: device is required to csum packet as seen by hard_start_xmit
+ *      from skb->h.raw to the end and to record the checksum
+ *      at skb->h.raw+skb->csum.
+ *
+ *      Device must show its capabilities in dev->features, set
+ *      at device setup time.
+ *      NETIF_F_HW_CSUM - it is clever device, it is able to checksum
+ *                        everything.
+ *      NETIF_F_NO_CSUM - loopback or reliable single hop media.
+ *      NETIF_F_IP_CSUM - device is dumb. It is able to csum only
+ *                        TCP/UDP over IPv4. Sigh. Vendors like this
+ *                        way by an unknown reason. Though, see comment above
+ *                        about CHECKSUM_UNNECESSARY. 8)
+ *
+ *      Any questions? No questions, good.              --ANK
+ */
+
+#ifdef __i386__
+#define NET_CALLER(arg) (*(((void **)&arg) - 1))
+#else
+#define NET_CALLER(arg) __builtin_return_address(0)
+#endif
+
+struct net_device;
+
+#ifdef CONFIG_NETFILTER
+struct nf_conntrack {
+        atomic_t use;
+        void (*destroy)(struct nf_conntrack *);
+};
+
+#ifdef CONFIG_BRIDGE_NETFILTER
+struct nf_bridge_info {
+        atomic_t use;
+        struct net_device *physindev;
+        struct net_device *physoutdev;
+#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+        struct net_device *netoutdev;
+#endif
+        unsigned int mask;
+        unsigned long data[32 / sizeof(unsigned long)];
+};
+#endif
+
+#endif
+
+struct sk_buff_head {
+        /* These two members must be first. */
+        struct sk_buff  *next;
+        struct sk_buff  *prev;
+
+        __u32           qlen;
+        spinlock_t      lock;
+};
+
+struct sk_buff;
+
+/* To allow 64K frame to be packed as single skb without frag_list */
+#define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
+
+typedef struct skb_frag_struct skb_frag_t;
+
+struct skb_frag_struct {
+        struct page *page;
+        __u16 page_offset;
+        __u16 size;
+};
+
+/* This data is invariant across clones and lives at
+ * the end of the header data, ie. at skb->end.
+ */
+struct skb_shared_info {
+        atomic_t        dataref;
+        unsigned int    nr_frags;
+        unsigned short  tso_size;
+        unsigned short  tso_segs;
+        struct sk_buff  *frag_list;
+        skb_frag_t      frags[MAX_SKB_FRAGS];
+};
+
+/* We divide dataref into two halves.  The higher 16 bits hold references
+ * to the payload part of skb->data.  The lower 16 bits hold references to
+ * the entire skb->data.  It is up to the users of the skb to agree on
+ * where the payload starts.
+ *
+ * All users must obey the rule that the skb->data reference count must be
+ * greater than or equal to the payload reference count.
+ *
+ * Holding a reference to the payload part means that the user does not
+ * care about modifications to the header part of skb->data.
+ */
+#define SKB_DATAREF_SHIFT 16
+#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
+
+/** 
+ *      struct sk_buff - socket buffer
+ *      @next: Next buffer in list
+ *      @prev: Previous buffer in list
+ *      @list: List we are on
+ *      @sk: Socket we are owned by
+ *      @stamp: Time we arrived
+ *      @dev: Device we arrived on/are leaving by
+ *      @input_dev: Device we arrived on
+ *      @real_dev: The real device we are using
+ *      @h: Transport layer header
+ *      @nh: Network layer header
+ *      @mac: Link layer header
+ *      @dst: FIXME: Describe this field
+ *      @cb: Control buffer. Free for use by every layer. Put private vars here
+ *      @len: Length of actual data
+ *      @data_len: Data length
+ *      @mac_len: Length of link layer header
+ *      @csum: Checksum
+ *      @__unused: Dead field, may be reused
+ *      @cloned: Head may be cloned (check refcnt to be sure)
+ *      @nohdr: Payload reference only, must not modify header
+ *      @pkt_type: Packet class
+ *      @ip_summed: Driver fed us an IP checksum
+ *      @priority: Packet queueing priority
+ *      @users: User count - see {datagram,tcp}.c
+ *      @protocol: Packet protocol from driver
+ *      @security: Security level of packet
+ *      @truesize: Buffer size 
+ *      @head: Head of buffer
+ *      @data: Data head pointer
+ *      @tail: Tail pointer
+ *      @end: End pointer
+ *      @destructor: Destruct function
+ *      @nfmark: Can be used for communication between hooks
+ *      @nfcache: Cache info
+ *      @nfct: Associated connection, if any
+ *      @nfctinfo: Relationship of this skb to the connection
+ *      @nf_debug: Netfilter debugging
+ *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
+ *      @private: Data which is private to the HIPPI implementation
+ *      @tc_index: Traffic control index
+ *      @tc_verd: traffic control verdict
+ *      @tc_classid: traffic control classid
+ */
+
+struct sk_buff {
+        /* These two members must be first. */
+        struct sk_buff          *next;
+        struct sk_buff          *prev;
+
+        struct sk_buff_head     *list;
+        struct sock             *sk;
+        struct timeval          stamp;
+        struct net_device       *dev;
+        struct net_device       *input_dev;
+        struct net_device       *real_dev;
+
+        union {
+                struct tcphdr   *th;
+                struct udphdr   *uh;
+                struct icmphdr  *icmph;
+                struct igmphdr  *igmph;
+                struct iphdr    *ipiph;
+                struct ipv6hdr  *ipv6h;
+                unsigned char   *raw;
+        } h;
+
+        union {
+                struct iphdr    *iph;
+                struct ipv6hdr  *ipv6h;
+                struct arphdr   *arph;
+                unsigned char   *raw;
+        } nh;
+
+        union {
+                unsigned char   *raw;
+        } mac;
+
+        struct  dst_entry       *dst;
+        struct  sec_path        *sp;
+
+        /*
+         * This is the control buffer. It is free to use for every
+         * layer. Please put your private variables there. If you
+         * want to keep them across layers you have to do a skb_clone()
+         * first. This is owned by whoever has the skb queued ATM.
+         */
+        char                    cb[40];
+
+        unsigned int            len,
+                                data_len,
+                                mac_len,
+                                csum;
+        unsigned char           local_df,
+                                cloned:1,
+                                nohdr:1,
+                                pkt_type,
+                                ip_summed;
+        __u32                   priority;
+        unsigned short          protocol,
+                                security;
+
+        void                    (*destructor)(struct sk_buff *skb);
+#ifdef CONFIG_NETFILTER
+        unsigned long           nfmark;
+        __u32                   nfcache;
+        __u32                   nfctinfo;
+        struct nf_conntrack     *nfct;
+#ifdef CONFIG_NETFILTER_DEBUG
+        unsigned int            nf_debug;
+#endif
+#ifdef CONFIG_BRIDGE_NETFILTER
+        struct nf_bridge_info   *nf_bridge;
+#endif
+#endif /* CONFIG_NETFILTER */
+#if defined(CONFIG_HIPPI)
+        union {
+                __u32           ifield;
+        } private;
+#endif
+#ifdef CONFIG_NET_SCHED
+       __u32                    tc_index;        /* traffic control index */
+#ifdef CONFIG_NET_CLS_ACT
+        __u32           tc_verd;               /* traffic control verdict */
+        __u32           tc_classid;            /* traffic control classid */
+#endif
+
+#endif
+
+
+        /* These elements must be at the end, see alloc_skb() for details.  */
+        unsigned int            truesize;
+        atomic_t                users;
+        unsigned char           *head,
+                                *data,
+                                *tail,
+                                *end;
+};
+
+#ifdef __KERNEL__
+/*
+ *      Handling routines are only of interest to the kernel
+ */
+#include <linux/slab.h>
+
+#include <asm/system.h>
+
+extern void            __kfree_skb(struct sk_buff *skb);
+extern struct sk_buff *alloc_skb(unsigned int size, int priority);
+extern struct sk_buff *alloc_skb_from_cache(kmem_cache_t *cp,
+                                            unsigned int size, int priority);
+extern void            kfree_skbmem(struct sk_buff *skb);
+extern struct sk_buff *skb_clone(struct sk_buff *skb, int priority);
+extern struct sk_buff *skb_copy(const struct sk_buff *skb, int priority);
+extern struct sk_buff *pskb_copy(struct sk_buff *skb, int gfp_mask);
+extern int             pskb_expand_head(struct sk_buff *skb,
+                                        int nhead, int ntail, int gfp_mask);
+extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
+                                            unsigned int headroom);
+extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
+                                       int newheadroom, int newtailroom,
+                                       int priority);
+extern struct sk_buff *         skb_pad(struct sk_buff *skb, int pad);
+#define dev_kfree_skb(a)        kfree_skb(a)
+extern void           skb_over_panic(struct sk_buff *skb, int len,
+                                     void *here);
+extern void           skb_under_panic(struct sk_buff *skb, int len,
+                                      void *here);
+
+/* Internal */
+#define skb_shinfo(SKB)         ((struct skb_shared_info *)((SKB)->end))
+
+/**
+ *      skb_queue_empty - check if a queue is empty
+ *      @list: queue head
+ *
+ *      Returns true if the queue is empty, false otherwise.
+ */
+static inline int skb_queue_empty(const struct sk_buff_head *list)
+{
+        return list->next == (struct sk_buff *)list;
+}
+
+/**
+ *      skb_get - reference buffer
+ *      @skb: buffer to reference
+ *
+ *      Makes another reference to a socket buffer and returns a pointer
+ *      to the buffer.
+ */
+static inline struct sk_buff *skb_get(struct sk_buff *skb)
+{
+        atomic_inc(&skb->users);
+        return skb;
+}
+
+/*
+ * If users == 1, we are the only owner and are can avoid redundant
+ * atomic change.
+ */
+
+/**
+ *      kfree_skb - free an sk_buff
+ *      @skb: buffer to free
+ *
+ *      Drop a reference to the buffer and free it if the usage count has
+ *      hit zero.
+ */
+static inline void kfree_skb(struct sk_buff *skb)
+{
+        if (likely(atomic_read(&skb->users) == 1))
+                smp_rmb();
+        else if (likely(!atomic_dec_and_test(&skb->users)))
+                return;
+        __kfree_skb(skb);
+}
+
+/**
+ *      skb_cloned - is the buffer a clone
+ *      @skb: buffer to check
+ *
+ *      Returns true if the buffer was generated with skb_clone() and is
+ *      one of multiple shared copies of the buffer. Cloned buffers are
+ *      shared data so must not be written to under normal circumstances.
+ */
+static inline int skb_cloned(const struct sk_buff *skb)
+{
+        return skb->cloned &&
+               (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
+}
+
+/**
+ *      skb_header_cloned - is the header a clone
+ *      @skb: buffer to check
+ *
+ *      Returns true if modifying the header part of the buffer requires
+ *      the data to be copied.
+ */
+static inline int skb_header_cloned(const struct sk_buff *skb)
+{
+        int dataref;
+
+        if (!skb->cloned)
+                return 0;
+
+        dataref = atomic_read(&skb_shinfo(skb)->dataref);
+        dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
+        return dataref != 1;
+}
+
+/**
+ *      skb_header_release - release reference to header
+ *      @skb: buffer to operate on
+ *
+ *      Drop a reference to the header part of the buffer.  This is done
+ *      by acquiring a payload reference.  You must not read from the header
+ *      part of skb->data after this.
+ */
+static inline void skb_header_release(struct sk_buff *skb)
+{
+        BUG_ON(skb->nohdr);
+        skb->nohdr = 1;
+        atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
+}
+
+/**
+ *      skb_shared - is the buffer shared
+ *      @skb: buffer to check
+ *
+ *      Returns true if more than one person has a reference to this
+ *      buffer.
+ */
+static inline int skb_shared(const struct sk_buff *skb)
+{
+        return atomic_read(&skb->users) != 1;
+}
+
+/**
+ *      skb_share_check - check if buffer is shared and if so clone it
+ *      @skb: buffer to check
+ *      @pri: priority for memory allocation
+ *
+ *      If the buffer is shared the buffer is cloned and the old copy
+ *      drops a reference. A new clone with a single reference is returned.
+ *      If the buffer is not shared the original buffer is returned. When
+ *      being called from interrupt status or with spinlocks held pri must
+ *      be GFP_ATOMIC.
+ *
+ *      NULL is returned on a memory allocation failure.
+ */
+static inline struct sk_buff *skb_share_check(struct sk_buff *skb, int pri)
+{
+        might_sleep_if(pri & __GFP_WAIT);
+        if (skb_shared(skb)) {
+                struct sk_buff *nskb = skb_clone(skb, pri);
+                kfree_skb(skb);
+                skb = nskb;
+        }
+        return skb;
+}
+
+/*
+ *      Copy shared buffers into a new sk_buff. We effectively do COW on
+ *      packets to handle cases where we have a local reader and forward
+ *      and a couple of other messy ones. The normal one is tcpdumping
+ *      a packet thats being forwarded.
+ */
+
+/**
+ *      skb_unshare - make a copy of a shared buffer
+ *      @skb: buffer to check
+ *      @pri: priority for memory allocation
+ *
+ *      If the socket buffer is a clone then this function creates a new
+ *      copy of the data, drops a reference count on the old copy and returns
+ *      the new copy with the reference count at 1. If the buffer is not a clone
+ *      the original buffer is returned. When called with a spinlock held or
+ *      from interrupt state @pri must be %GFP_ATOMIC
+ *
+ *      %NULL is returned on a memory allocation failure.
+ */
+static inline struct sk_buff *skb_unshare(struct sk_buff *skb, int pri)
+{
+        might_sleep_if(pri & __GFP_WAIT);
+        if (skb_cloned(skb)) {
+                struct sk_buff *nskb = skb_copy(skb, pri);
+                kfree_skb(skb); /* Free our shared copy */
+                skb = nskb;
+        }
+        return skb;
+}
+
+/**
+ *      skb_peek
+ *      @list_: list to peek at
+ *
+ *      Peek an &sk_buff. Unlike most other operations you _MUST_
+ *      be careful with this one. A peek leaves the buffer on the
+ *      list and someone else may run off with it. You must hold
+ *      the appropriate locks or have a private queue to do this.
+ *
+ *      Returns %NULL for an empty list or a pointer to the head element.
+ *      The reference count is not incremented and the reference is therefore
+ *      volatile. Use with caution.
+ */
+static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
+{
+        struct sk_buff *list = ((struct sk_buff *)list_)->next;
+        if (list == (struct sk_buff *)list_)
+                list = NULL;
+        return list;
+}
+
+/**
+ *      skb_peek_tail
+ *      @list_: list to peek at
+ *
+ *      Peek an &sk_buff. Unlike most other operations you _MUST_
+ *      be careful with this one. A peek leaves the buffer on the
+ *      list and someone else may run off with it. You must hold
+ *      the appropriate locks or have a private queue to do this.
+ *
+ *      Returns %NULL for an empty list or a pointer to the tail element.
+ *      The reference count is not incremented and the reference is therefore
+ *      volatile. Use with caution.
+ */
+static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
+{
+        struct sk_buff *list = ((struct sk_buff *)list_)->prev;
+        if (list == (struct sk_buff *)list_)
+                list = NULL;
+        return list;
+}
+
+/**
+ *      skb_queue_len   - get queue length
+ *      @list_: list to measure
+ *
+ *      Return the length of an &sk_buff queue.
+ */
+static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
+{
+        return list_->qlen;
+}
+
+static inline void skb_queue_head_init(struct sk_buff_head *list)
+{
+        spin_lock_init(&list->lock);
+        list->prev = list->next = (struct sk_buff *)list;
+        list->qlen = 0;
+}
+
+/*
+ *      Insert an sk_buff at the start of a list.
+ *
+ *      The "__skb_xxxx()" functions are the non-atomic ones that
+ *      can only be called with interrupts disabled.
+ */
+
+/**
+ *      __skb_queue_head - queue a buffer at the list head
+ *      @list: list to use
+ *      @newsk: buffer to queue
+ *
+ *      Queue a buffer at the start of a list. This function takes no locks
+ *      and you must therefore hold required locks before calling it.
+ *
+ *      A buffer cannot be placed on two lists at the same time.
+ */
+extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
+static inline void __skb_queue_head(struct sk_buff_head *list,
+                                    struct sk_buff *newsk)
+{
+        struct sk_buff *prev, *next;
+
+        newsk->list = list;
+        list->qlen++;
+        prev = (struct sk_buff *)list;
+        next = prev->next;
+        newsk->next = next;
+        newsk->prev = prev;
+        next->prev  = prev->next = newsk;
+}
+
+/**
+ *      __skb_queue_tail - queue a buffer at the list tail
+ *      @list: list to use
+ *      @newsk: buffer to queue
+ *
+ *      Queue a buffer at the end of a list. This function takes no locks
+ *      and you must therefore hold required locks before calling it.
+ *
+ *      A buffer cannot be placed on two lists at the same time.
+ */
+extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
+static inline void __skb_queue_tail(struct sk_buff_head *list,
+                                   struct sk_buff *newsk)
+{
+        struct sk_buff *prev, *next;
+
+        newsk->list = list;
+        list->qlen++;
+        next = (struct sk_buff *)list;
+        prev = next->prev;
+        newsk->next = next;
+        newsk->prev = prev;
+        next->prev  = prev->next = newsk;
+}
+
+
+/**
+ *      __skb_dequeue - remove from the head of the queue
+ *      @list: list to dequeue from
+ *
+ *      Remove the head of the list. This function does not take any locks
+ *      so must be used with appropriate locks held only. The head item is
+ *      returned or %NULL if the list is empty.
+ */
+extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
+static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
+{
+        struct sk_buff *next, *prev, *result;
+
+        prev = (struct sk_buff *) list;
+        next = prev->next;
+        result = NULL;
+        if (next != prev) {
+                result       = next;
+                next         = next->next;
+                list->qlen--;
+                next->prev   = prev;
+                prev->next   = next;
+                result->next = result->prev = NULL;
+                result->list = NULL;
+        }
+        return result;
+}
+
+
+/*
+ *      Insert a packet on a list.
+ */
+extern void        skb_insert(struct sk_buff *old, struct sk_buff *newsk);
+static inline void __skb_insert(struct sk_buff *newsk,
+                                struct sk_buff *prev, struct sk_buff *next,
+                                struct sk_buff_head *list)
+{
+        newsk->next = next;
+        newsk->prev = prev;
+        next->prev  = prev->next = newsk;
+        newsk->list = list;
+        list->qlen++;
+}
+
+/*
+ *      Place a packet after a given packet in a list.
+ */
+extern void        skb_append(struct sk_buff *old, struct sk_buff *newsk);
+static inline void __skb_append(struct sk_buff *old, struct sk_buff *newsk)
+{
+        __skb_insert(newsk, old, old->next, old->list);
+}
+
+/*
+ * remove sk_buff from list. _Must_ be called atomically, and with
+ * the list known..
+ */
+extern void        skb_unlink(struct sk_buff *skb);
+static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
+{
+        struct sk_buff *next, *prev;
+
+        list->qlen--;
+        next       = skb->next;
+        prev       = skb->prev;
+        skb->next  = skb->prev = NULL;
+        skb->list  = NULL;
+        next->prev = prev;
+        prev->next = next;
+}
+
+
+/* XXX: more streamlined implementation */
+
+/**
+ *      __skb_dequeue_tail - remove from the tail of the queue
+ *      @list: list to dequeue from
+ *
+ *      Remove the tail of the list. This function does not take any locks
+ *      so must be used with appropriate locks held only. The tail item is
+ *      returned or %NULL if the list is empty.
+ */
+extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
+static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
+{
+        struct sk_buff *skb = skb_peek_tail(list);
+        if (skb)
+                __skb_unlink(skb, list);
+        return skb;
+}
+
+
+static inline int skb_is_nonlinear(const struct sk_buff *skb)
+{
+        return skb->data_len;
+}
+
+static inline unsigned int skb_headlen(const struct sk_buff *skb)
+{
+        return skb->len - skb->data_len;
+}
+
+static inline int skb_pagelen(const struct sk_buff *skb)
+{
+        int i, len = 0;
+
+        for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
+                len += skb_shinfo(skb)->frags[i].size;
+        return len + skb_headlen(skb);
+}
+
+static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
+                                      struct page *page, int off, int size)
+{
+        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+
+        frag->page                = page;
+        frag->page_offset         = off;
+        frag->size                = size;
+        skb_shinfo(skb)->nr_frags = i + 1;
+}
+
+#define SKB_PAGE_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->nr_frags)
+#define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->frag_list)
+#define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
+
+/*
+ *      Add data to an sk_buff
+ */
+static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
+{
+        unsigned char *tmp = skb->tail;
+        SKB_LINEAR_ASSERT(skb);
+        skb->tail += len;
+        skb->len  += len;
+        return tmp;
+}
+
+/**
+ *      skb_put - add data to a buffer
+ *      @skb: buffer to use
+ *      @len: amount of data to add
+ *
+ *      This function extends the used data area of the buffer. If this would
+ *      exceed the total buffer size the kernel will panic. A pointer to the
+ *      first byte of the extra data is returned.
+ */
+static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
+{
+        unsigned char *tmp = skb->tail;
+        SKB_LINEAR_ASSERT(skb);
+        skb->tail += len;
+        skb->len  += len;
+        if (unlikely(skb->tail>skb->end))
+                skb_over_panic(skb, len, current_text_addr());
+        return tmp;
+}
+
+static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
+{
+        skb->data -= len;
+        skb->len  += len;
+        return skb->data;
+}
+
+/**
+ *      skb_push - add data to the start of a buffer
+ *      @skb: buffer to use
+ *      @len: amount of data to add
+ *
+ *      This function extends the used data area of the buffer at the buffer
+ *      start. If this would exceed the total buffer headroom the kernel will
+ *      panic. A pointer to the first byte of the extra data is returned.
+ */
+static inline unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
+{
+        skb->data -= len;
+        skb->len  += len;
+        if (unlikely(skb->data<skb->head))
+                skb_under_panic(skb, len, current_text_addr());
+        return skb->data;
+}
+
+static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
+{
+        skb->len -= len;
+        BUG_ON(skb->len < skb->data_len);
+        return skb->data += len;
+}
+
+/**
+ *      skb_pull - remove data from the start of a buffer
+ *      @skb: buffer to use
+ *      @len: amount of data to remove
+ *
+ *      This function removes data from the start of a buffer, returning
+ *      the memory to the headroom. A pointer to the next data in the buffer
+ *      is returned. Once the data has been pulled future pushes will overwrite
+ *      the old data.
+ */
+static inline unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
+{
+        return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
+}
+
+extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
+
+static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
+{
+        if (len > skb_headlen(skb) &&
+            !__pskb_pull_tail(skb, len-skb_headlen(skb)))
+                return NULL;
+        skb->len -= len;
+        return skb->data += len;
+}
+
+static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
+{
+        return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
+}
+
+static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
+{
+        if (likely(len <= skb_headlen(skb)))
+                return 1;
+        if (unlikely(len > skb->len))
+                return 0;
+        return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
+}
+
+/**
+ *      skb_headroom - bytes at buffer head
+ *      @skb: buffer to check
+ *
+ *      Return the number of bytes of free space at the head of an &sk_buff.
+ */
+static inline int skb_headroom(const struct sk_buff *skb)
+{
+        return skb->data - skb->head;
+}
+
+/**
+ *      skb_tailroom - bytes at buffer end
+ *      @skb: buffer to check
+ *
+ *      Return the number of bytes of free space at the tail of an sk_buff
+ */
+static inline int skb_tailroom(const struct sk_buff *skb)
+{
+        return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
+}
+
+/**
+ *      skb_reserve - adjust headroom
+ *      @skb: buffer to alter
+ *      @len: bytes to move
+ *
+ *      Increase the headroom of an empty &sk_buff by reducing the tail
+ *      room. This is only allowed for an empty buffer.
+ */
+static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
+{
+        skb->data += len;
+        skb->tail += len;
+}
+
+/*
+ * CPUs often take a performance hit when accessing unaligned memory
+ * locations. The actual performance hit varies, it can be small if the
+ * hardware handles it or large if we have to take an exception and fix it
+ * in software.
+ *
+ * Since an ethernet header is 14 bytes network drivers often end up with
+ * the IP header at an unaligned offset. The IP header can be aligned by
+ * shifting the start of the packet by 2 bytes. Drivers should do this
+ * with:
+ *
+ * skb_reserve(NET_IP_ALIGN);
+ *
+ * The downside to this alignment of the IP header is that the DMA is now
+ * unaligned. On some architectures the cost of an unaligned DMA is high
+ * and this cost outweighs the gains made by aligning the IP header.
+ * 
+ * Since this trade off varies between architectures, we allow NET_IP_ALIGN
+ * to be overridden.
+ */
+#ifndef NET_IP_ALIGN
+#define NET_IP_ALIGN    2
+#endif
+
+extern int ___pskb_trim(struct sk_buff *skb, unsigned int len, int realloc);
+
+static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
+{
+        if (!skb->data_len) {
+                skb->len  = len;
+                skb->tail = skb->data + len;
+        } else
+                ___pskb_trim(skb, len, 0);
+}
+
+/**
+ *      skb_trim - remove end from a buffer
+ *      @skb: buffer to alter
+ *      @len: new length
+ *
+ *      Cut the length of a buffer down by removing data from the tail. If
+ *      the buffer is already under the length specified it is not modified.
+ */
+static inline void skb_trim(struct sk_buff *skb, unsigned int len)
+{
+        if (skb->len > len)
+                __skb_trim(skb, len);
+}
+
+
+static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
+{
+        if (!skb->data_len) {
+                skb->len  = len;
+                skb->tail = skb->data+len;
+                return 0;
+        }
+        return ___pskb_trim(skb, len, 1);
+}
+
+static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
+{
+        return (len < skb->len) ? __pskb_trim(skb, len) : 0;
+}
+
+/**
+ *      skb_orphan - orphan a buffer
+ *      @skb: buffer to orphan
+ *
+ *      If a buffer currently has an owner then we call the owner's
+ *      destructor function and make the @skb unowned. The buffer continues
+ *      to exist but is no longer charged to its former owner.
+ */
+static inline void skb_orphan(struct sk_buff *skb)
+{
+        if (skb->destructor)
+                skb->destructor(skb);
+        skb->destructor = NULL;
+        skb->sk         = NULL;
+}
+
+/**
+ *      __skb_queue_purge - empty a list
+ *      @list: list to empty
+ *
+ *      Delete all buffers on an &sk_buff list. Each buffer is removed from
+ *      the list and one reference dropped. This function does not take the
+ *      list lock and the caller must hold the relevant locks to use it.
+ */
+extern void skb_queue_purge(struct sk_buff_head *list);
+static inline void __skb_queue_purge(struct sk_buff_head *list)
+{
+        struct sk_buff *skb;
+        while ((skb = __skb_dequeue(list)) != NULL)
+                kfree_skb(skb);
+}
+
+/**
+ *      __dev_alloc_skb - allocate an skbuff for sending
+ *      @length: length to allocate
+ *      @gfp_mask: get_free_pages mask, passed to alloc_skb
+ *
+ *      Allocate a new &sk_buff and assign it a usage count of one. The
+ *      buffer has unspecified headroom built in. Users should allocate
+ *      the headroom they think they need without accounting for the
+ *      built in space. The built in space is used for optimisations.
+ *
+ *      %NULL is returned in there is no free memory.
+ */
+#ifndef CONFIG_HAVE_ARCH_DEV_ALLOC_SKB
+static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
+                                              int gfp_mask)
+{
+        struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
+        if (likely(skb))
+                skb_reserve(skb, 16);
+        return skb;
+}
+#else
+extern struct sk_buff *__dev_alloc_skb(unsigned int length, int gfp_mask);
+#endif
+
+/**
+ *      dev_alloc_skb - allocate an skbuff for sending
+ *      @length: length to allocate
+ *
+ *      Allocate a new &sk_buff and assign it a usage count of one. The
+ *      buffer has unspecified headroom built in. Users should allocate
+ *      the headroom they think they need without accounting for the
+ *      built in space. The built in space is used for optimisations.
+ *
+ *      %NULL is returned in there is no free memory. Although this function
+ *      allocates memory it can be called from an interrupt.
+ */
+static inline struct sk_buff *dev_alloc_skb(unsigned int length)
+{
+        return __dev_alloc_skb(length, GFP_ATOMIC);
+}
+
+/**
+ *      skb_cow - copy header of skb when it is required
+ *      @skb: buffer to cow
+ *      @headroom: needed headroom
+ *
+ *      If the skb passed lacks sufficient headroom or its data part
+ *      is shared, data is reallocated. If reallocation fails, an error
+ *      is returned and original skb is not changed.
+ *
+ *      The result is skb with writable area skb->head...skb->tail
+ *      and at least @headroom of space at head.
+ */
+static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
+{
+        int delta = (headroom > 16 ? headroom : 16) - skb_headroom(skb);
+
+        if (delta < 0)
+                delta = 0;
+
+        if (delta || skb_cloned(skb))
+                return pskb_expand_head(skb, (delta + 15) & ~15, 0, GFP_ATOMIC);
+        return 0;
+}
+
+/**
+ *      skb_padto       - pad an skbuff up to a minimal size
+ *      @skb: buffer to pad
+ *      @len: minimal length
+ *
+ *      Pads up a buffer to ensure the trailing bytes exist and are
+ *      blanked. If the buffer already contains sufficient data it
+ *      is untouched. Returns the buffer, which may be a replacement
+ *      for the original, or NULL for out of memory - in which case
+ *      the original buffer is still freed.
+ */
+ 
+static inline struct sk_buff *skb_padto(struct sk_buff *skb, unsigned int len)
+{
+        unsigned int size = skb->len;
+        if (likely(size >= len))
+                return skb;
+        return skb_pad(skb, len-size);
+}
+
+static inline int skb_add_data(struct sk_buff *skb,
+                               char __user *from, int copy)
+{
+        const int off = skb->len;
+
+        if (skb->ip_summed == CHECKSUM_NONE) {
+                int err = 0;
+                unsigned int csum = csum_and_copy_from_user(from,
+                                                            skb_put(skb, copy),
+                                                            copy, 0, &err);
+                if (!err) {
+                        skb->csum = csum_block_add(skb->csum, csum, off);
+                        return 0;
+                }
+        } else if (!copy_from_user(skb_put(skb, copy), from, copy))
+                return 0;
+
+        __skb_trim(skb, off);
+        return -EFAULT;
+}
+
+static inline int skb_can_coalesce(struct sk_buff *skb, int i,
+                                   struct page *page, int off)
+{
+        if (i) {
+                struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
+
+                return page == frag->page &&
+                       off == frag->page_offset + frag->size;
+        }
+        return 0;
+}
+
+/**
+ *      skb_linearize - convert paged skb to linear one
+ *      @skb: buffer to linarize
+ *      @gfp: allocation mode
+ *
+ *      If there is no free memory -ENOMEM is returned, otherwise zero
+ *      is returned and the old skb data released.
+ */
+extern int __skb_linearize(struct sk_buff *skb, int gfp);
+static inline int skb_linearize(struct sk_buff *skb, int gfp)
+{
+        return __skb_linearize(skb, gfp);
+}
+
+/**
+ *      skb_postpull_rcsum - update checksum for received skb after pull
+ *      @skb: buffer to update
+ *      @start: start of data before pull
+ *      @len: length of data pulled
+ *
+ *      After doing a pull on a received packet, you need to call this to
+ *      update the CHECKSUM_HW checksum, or set ip_summed to CHECKSUM_NONE
+ *      so that it can be recomputed from scratch.
+ */
+
+static inline void skb_postpull_rcsum(struct sk_buff *skb,
+                                         const void *start, int len)
+{
+        if (skb->ip_summed == CHECKSUM_HW)
+                skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
+}
+
+/**
+ *      pskb_trim_rcsum - trim received skb and update checksum
+ *      @skb: buffer to trim
+ *      @len: new length
+ *
+ *      This is exactly the same as pskb_trim except that it ensures the
+ *      checksum of received packets are still valid after the operation.
+ */
+
+static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
+{
+        if (len >= skb->len)
+                return 0;
+        if (skb->ip_summed == CHECKSUM_HW)
+                skb->ip_summed = CHECKSUM_NONE;
+        return __pskb_trim(skb, len);
+}
+
+static inline void *kmap_skb_frag(const skb_frag_t *frag)
+{
+#ifdef CONFIG_HIGHMEM
+        BUG_ON(in_irq());
+
+        local_bh_disable();
+#endif
+        return kmap_atomic(frag->page, KM_SKB_DATA_SOFTIRQ);
+}
+
+static inline void kunmap_skb_frag(void *vaddr)
+{
+        kunmap_atomic(vaddr, KM_SKB_DATA_SOFTIRQ);
+#ifdef CONFIG_HIGHMEM
+        local_bh_enable();
+#endif
+}
+
+#define skb_queue_walk(queue, skb) \
+                for (skb = (queue)->next;                                       \
+                     prefetch(skb->next), (skb != (struct sk_buff *)(queue));   \
+                     skb = skb->next)
+
+
+extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
+                                         int noblock, int *err);
+extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
+                                     struct poll_table_struct *wait);
+extern int             skb_copy_datagram_iovec(const struct sk_buff *from,
+                                               int offset, struct iovec *to,
+                                               int size);
+extern int             skb_copy_and_csum_datagram_iovec(const
+                                                        struct sk_buff *skb,
+                                                        int hlen,
+                                                        struct iovec *iov);
+extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
+extern unsigned int    skb_checksum(const struct sk_buff *skb, int offset,
+                                    int len, unsigned int csum);
+extern int             skb_copy_bits(const struct sk_buff *skb, int offset,
+                                     void *to, int len);
+extern unsigned int    skb_copy_and_csum_bits(const struct sk_buff *skb,
+                                              int offset, u8 *to, int len,
+                                              unsigned int csum);
+extern void            skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
+extern void            skb_split(struct sk_buff *skb,
+                                 struct sk_buff *skb1, const u32 len);
+
+static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
+                                       int len, void *buffer)
+{
+        int hlen = skb_headlen(skb);
+
+        if (offset + len <= hlen)
+                return skb->data + offset;
+
+        if (skb_copy_bits(skb, offset, buffer, len) < 0)
+                return NULL;
+
+        return buffer;
+}
+
+extern void skb_init(void);
+extern void skb_add_mtu(int mtu);
+
+#ifdef CONFIG_NETFILTER
+static inline void nf_conntrack_put(struct nf_conntrack *nfct)
+{
+        if (nfct && atomic_dec_and_test(&nfct->use))
+                nfct->destroy(nfct);
+}
+static inline void nf_conntrack_get(struct nf_conntrack *nfct)
+{
+        if (nfct)
+                atomic_inc(&nfct->use);
+}
+static inline void nf_reset(struct sk_buff *skb)
+{
+        nf_conntrack_put(skb->nfct);
+        skb->nfct = NULL;
+#ifdef CONFIG_NETFILTER_DEBUG
+        skb->nf_debug = 0;
+#endif
+}
+static inline void nf_reset_debug(struct sk_buff *skb)
+{
+#ifdef CONFIG_NETFILTER_DEBUG
+        skb->nf_debug = 0;
+#endif
+}
+
+#ifdef CONFIG_BRIDGE_NETFILTER
+static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
+{
+        if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
+                kfree(nf_bridge);
+}
+static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
+{
+        if (nf_bridge)
+                atomic_inc(&nf_bridge->use);
+}
+#endif /* CONFIG_BRIDGE_NETFILTER */
+#else /* CONFIG_NETFILTER */
+static inline void nf_reset(struct sk_buff *skb) {}
+#endif /* CONFIG_NETFILTER */
+
+#endif  /* __KERNEL__ */
+#endif  /* _LINUX_SKBUFF_H */
diff --git a/include/linux/slab.h b/include/linux/slab.h
new file mode 100644
index 000000000000..3e3c3ab8ff94
--- /dev/null
+++ b/include/linux/slab.h
@@ -0,0 +1,129 @@
+/*
+ * linux/mm/slab.h
+ * Written by Mark Hemment, 1996.
+ * (markhe@nextd.demon.co.uk)
+ */
+
+#ifndef _LINUX_SLAB_H
+#define _LINUX_SLAB_H
+
+#if     defined(__KERNEL__)
+
+typedef struct kmem_cache_s kmem_cache_t;
+
+#include        <linux/config.h>        /* kmalloc_sizes.h needs CONFIG_ options */
+#include        <linux/gfp.h>
+#include        <linux/init.h>
+#include        <linux/types.h>
+#include        <asm/page.h>            /* kmalloc_sizes.h needs PAGE_SIZE */
+#include        <asm/cache.h>           /* kmalloc_sizes.h needs L1_CACHE_BYTES */
+
+/* flags for kmem_cache_alloc() */
+#define SLAB_NOFS               GFP_NOFS
+#define SLAB_NOIO               GFP_NOIO
+#define SLAB_ATOMIC             GFP_ATOMIC
+#define SLAB_USER               GFP_USER
+#define SLAB_KERNEL             GFP_KERNEL
+#define SLAB_DMA                GFP_DMA
+
+#define SLAB_LEVEL_MASK         GFP_LEVEL_MASK
+
+#define SLAB_NO_GROW            __GFP_NO_GROW   /* don't grow a cache */
+
+/* flags to pass to kmem_cache_create().
+ * The first 3 are only valid when the allocator as been build
+ * SLAB_DEBUG_SUPPORT.
+ */
+#define SLAB_DEBUG_FREE         0x00000100UL    /* Peform (expensive) checks on free */
+#define SLAB_DEBUG_INITIAL      0x00000200UL    /* Call constructor (as verifier) */
+#define SLAB_RED_ZONE           0x00000400UL    /* Red zone objs in a cache */
+#define SLAB_POISON             0x00000800UL    /* Poison objects */
+#define SLAB_NO_REAP            0x00001000UL    /* never reap from the cache */
+#define SLAB_HWCACHE_ALIGN      0x00002000UL    /* align objs on a h/w cache lines */
+#define SLAB_CACHE_DMA          0x00004000UL    /* use GFP_DMA memory */
+#define SLAB_MUST_HWCACHE_ALIGN 0x00008000UL    /* force alignment */
+#define SLAB_STORE_USER         0x00010000UL    /* store the last owner for bug hunting */
+#define SLAB_RECLAIM_ACCOUNT    0x00020000UL    /* track pages allocated to indicate
+                                                   what is reclaimable later*/
+#define SLAB_PANIC              0x00040000UL    /* panic if kmem_cache_create() fails */
+#define SLAB_DESTROY_BY_RCU     0x00080000UL    /* defer freeing pages to RCU */
+
+/* flags passed to a constructor func */
+#define SLAB_CTOR_CONSTRUCTOR   0x001UL         /* if not set, then deconstructor */
+#define SLAB_CTOR_ATOMIC        0x002UL         /* tell constructor it can't sleep */
+#define SLAB_CTOR_VERIFY        0x004UL         /* tell constructor it's a verify call */
+
+/* prototypes */
+extern void __init kmem_cache_init(void);
+
+extern kmem_cache_t *kmem_cache_create(const char *, size_t, size_t, unsigned long,
+                                       void (*)(void *, kmem_cache_t *, unsigned long),
+                                       void (*)(void *, kmem_cache_t *, unsigned long));
+extern int kmem_cache_destroy(kmem_cache_t *);
+extern int kmem_cache_shrink(kmem_cache_t *);
+extern void *kmem_cache_alloc(kmem_cache_t *, unsigned int __nocast);
+#ifdef CONFIG_NUMA
+extern void *kmem_cache_alloc_node(kmem_cache_t *, int);
+#else
+static inline void *kmem_cache_alloc_node(kmem_cache_t *cachep, int node)
+{
+        return kmem_cache_alloc(cachep, GFP_KERNEL);
+}
+#endif
+extern void kmem_cache_free(kmem_cache_t *, void *);
+extern unsigned int kmem_cache_size(kmem_cache_t *);
+
+/* Size description struct for general caches. */
+struct cache_sizes {
+        size_t           cs_size;
+        kmem_cache_t    *cs_cachep;
+        kmem_cache_t    *cs_dmacachep;
+};
+extern struct cache_sizes malloc_sizes[];
+extern void *__kmalloc(size_t, unsigned int __nocast);
+
+static inline void *kmalloc(size_t size, unsigned int __nocast flags)
+{
+        if (__builtin_constant_p(size)) {
+                int i = 0;
+#define CACHE(x) \
+                if (size <= x) \
+                        goto found; \
+                else \
+                        i++;
+#include "kmalloc_sizes.h"
+#undef CACHE
+                {
+                        extern void __you_cannot_kmalloc_that_much(void);
+                        __you_cannot_kmalloc_that_much();
+                }
+found:
+                return kmem_cache_alloc((flags & GFP_DMA) ?
+                        malloc_sizes[i].cs_dmacachep :
+                        malloc_sizes[i].cs_cachep, flags);
+        }
+        return __kmalloc(size, flags);
+}
+
+extern void *kcalloc(size_t, size_t, unsigned int __nocast);
+extern void kfree(const void *);
+extern unsigned int ksize(const void *);
+
+extern int FASTCALL(kmem_cache_reap(int));
+extern int FASTCALL(kmem_ptr_validate(kmem_cache_t *cachep, void *ptr));
+
+/* System wide caches */
+extern kmem_cache_t     *vm_area_cachep;
+extern kmem_cache_t     *names_cachep;
+extern kmem_cache_t     *files_cachep;
+extern kmem_cache_t     *filp_cachep;
+extern kmem_cache_t     *fs_cachep;
+extern kmem_cache_t     *signal_cachep;
+extern kmem_cache_t     *sighand_cachep;
+extern kmem_cache_t     *bio_cachep;
+
+extern atomic_t slab_reclaim_pages;
+
+#endif  /* __KERNEL__ */
+
+#endif  /* _LINUX_SLAB_H */
diff --git a/include/linux/smb.h b/include/linux/smb.h
new file mode 100644
index 000000000000..b0162208c963
--- /dev/null
+++ b/include/linux/smb.h
@@ -0,0 +1,117 @@
+/*
+ *  smb.h
+ *
+ *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
+ *  Copyright (C) 1997 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_SMB_H
+#define _LINUX_SMB_H
+
+#include <linux/types.h>
+
+enum smb_protocol { 
+        SMB_PROTOCOL_NONE, 
+        SMB_PROTOCOL_CORE, 
+        SMB_PROTOCOL_COREPLUS, 
+        SMB_PROTOCOL_LANMAN1, 
+        SMB_PROTOCOL_LANMAN2, 
+        SMB_PROTOCOL_NT1 
+};
+
+enum smb_case_hndl {
+        SMB_CASE_DEFAULT,
+        SMB_CASE_LOWER,
+        SMB_CASE_UPPER
+};
+
+struct smb_dskattr {
+        __u16 total;
+        __u16 allocblocks;
+        __u16 blocksize;
+        __u16 free;
+};
+
+struct smb_conn_opt {
+
+        /* The socket */
+        unsigned int fd;
+
+        enum smb_protocol protocol;
+        enum smb_case_hndl case_handling;
+
+        /* Connection-Options */
+
+        __u32              max_xmit;
+        __u16              server_uid;
+        __u16              tid;
+
+        /* The following are LANMAN 1.0 options */
+        __u16              secmode;
+        __u16              maxmux;
+        __u16              maxvcs;
+        __u16              rawmode;
+        __u32              sesskey;
+
+        /* The following are NT LM 0.12 options */
+        __u32              maxraw;
+        __u32              capabilities;
+        __s16              serverzone;
+};
+
+#ifdef __KERNEL__
+
+#define SMB_NLS_MAXNAMELEN 20
+struct smb_nls_codepage {
+        char local_name[SMB_NLS_MAXNAMELEN];
+        char remote_name[SMB_NLS_MAXNAMELEN];
+};
+
+
+#define SMB_MAXNAMELEN 255
+#define SMB_MAXPATHLEN 1024
+
+/*
+ * Contains all relevant data on a SMB networked file.
+ */
+struct smb_fattr {
+        __u16 attr;
+
+        unsigned long   f_ino;
+        umode_t         f_mode;
+        nlink_t         f_nlink;
+        uid_t           f_uid;
+        gid_t           f_gid;
+        dev_t           f_rdev;
+        loff_t          f_size;
+        struct timespec f_atime;
+        struct timespec f_mtime;
+        struct timespec f_ctime;
+        unsigned long   f_blksize;
+        unsigned long   f_blocks;
+        int             f_unix;
+};
+
+enum smb_conn_state {
+        CONN_VALID,             /* everything's fine */
+        CONN_INVALID,           /* Something went wrong, but did not
+                                   try to reconnect yet. */
+        CONN_RETRIED,           /* Tried a reconnection, but was refused */
+        CONN_RETRYING           /* Currently trying to reconnect */
+};
+
+#define SMB_SUPER_MAGIC               0x517B
+
+#define SMB_HEADER_LEN   37     /* includes everything up to, but not
+                                 * including smb_bcc */
+
+#define SMB_INITIAL_PACKET_SIZE         4000
+#define SMB_MAX_PACKET_SIZE             32768
+
+/* reserve this much space for trans2 parameters. Shouldn't have to be more
+   than 10 or so, but OS/2 seems happier like this. */
+#define SMB_TRANS2_MAX_PARAM 64
+
+#endif
+#endif
diff --git a/include/linux/smb_fs.h b/include/linux/smb_fs.h
new file mode 100644
index 000000000000..c4153120ade6
--- /dev/null
+++ b/include/linux/smb_fs.h
@@ -0,0 +1,204 @@
+/*
+ *  smb_fs.h
+ *
+ *  Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
+ *  Copyright (C) 1997 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_SMB_FS_H
+#define _LINUX_SMB_FS_H
+
+#include <linux/smb.h>
+#include <linux/smb_fs_i.h>
+#include <linux/smb_fs_sb.h>
+
+/*
+ * ioctl commands
+ */
+#define SMB_IOC_GETMOUNTUID             _IOR('u', 1, __kernel_old_uid_t)
+#define SMB_IOC_NEWCONN                 _IOW('u', 2, struct smb_conn_opt)
+
+/* __kernel_uid_t can never change, so we have to use __kernel_uid32_t */
+#define SMB_IOC_GETMOUNTUID32           _IOR('u', 3, __kernel_uid32_t)
+
+
+#ifdef __KERNEL__
+
+#include <linux/fs.h>
+#include <linux/pagemap.h>
+#include <linux/vmalloc.h>
+#include <linux/smb_mount.h>
+#include <asm/unaligned.h>
+
+static inline struct smb_sb_info *SMB_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct smb_inode_info *SMB_I(struct inode *inode)
+{
+        return container_of(inode, struct smb_inode_info, vfs_inode);
+}
+
+/* macro names are short for word, double-word, long value (?) */
+#define WVAL(buf,pos) \
+        (le16_to_cpu(get_unaligned((u16 *)((u8 *)(buf) + (pos)))))
+#define DVAL(buf,pos) \
+        (le32_to_cpu(get_unaligned((u32 *)((u8 *)(buf) + (pos)))))
+#define LVAL(buf,pos) \
+        (le64_to_cpu(get_unaligned((u64 *)((u8 *)(buf) + (pos)))))
+#define WSET(buf,pos,val) \
+        put_unaligned(cpu_to_le16((u16)(val)), (u16 *)((u8 *)(buf) + (pos)))
+#define DSET(buf,pos,val) \
+        put_unaligned(cpu_to_le32((u32)(val)), (u32 *)((u8 *)(buf) + (pos)))
+#define LSET(buf,pos,val) \
+        put_unaligned(cpu_to_le64((u64)(val)), (u64 *)((u8 *)(buf) + (pos)))
+
+/* where to find the base of the SMB packet proper */
+#define smb_base(buf) ((u8 *)(((u8 *)(buf))+4))
+
+#ifdef DEBUG_SMB_MALLOC
+
+#include <linux/slab.h>
+
+extern int smb_malloced;
+extern int smb_current_vmalloced;
+extern int smb_current_kmalloced;
+
+static inline void *
+smb_vmalloc(unsigned int size)
+{
+        smb_malloced += 1;
+        smb_current_vmalloced += 1;
+        return vmalloc(size);
+}
+
+static inline void
+smb_vfree(void *obj)
+{
+        smb_current_vmalloced -= 1;
+        vfree(obj);
+}
+
+static inline void *
+smb_kmalloc(size_t size, int flags)
+{
+        smb_malloced += 1;
+        smb_current_kmalloced += 1;
+        return kmalloc(size, flags);
+}
+
+static inline void
+smb_kfree(void *obj)
+{
+        smb_current_kmalloced -= 1;
+        kfree(obj);
+}
+
+#else /* DEBUG_SMB_MALLOC */
+
+#define smb_kmalloc(s,p)        kmalloc(s,p)
+#define smb_kfree(o)            kfree(o)
+#define smb_vmalloc(s)          vmalloc(s)
+#define smb_vfree(o)            vfree(o)
+
+#endif /* DEBUG_SMB_MALLOC */
+
+/*
+ * Flags for the in-memory inode
+ */
+#define SMB_F_LOCALWRITE        0x02    /* file modified locally */
+
+
+/* NT1 protocol capability bits */
+#define SMB_CAP_RAW_MODE         0x00000001
+#define SMB_CAP_MPX_MODE         0x00000002
+#define SMB_CAP_UNICODE          0x00000004
+#define SMB_CAP_LARGE_FILES      0x00000008
+#define SMB_CAP_NT_SMBS          0x00000010
+#define SMB_CAP_RPC_REMOTE_APIS  0x00000020
+#define SMB_CAP_STATUS32         0x00000040
+#define SMB_CAP_LEVEL_II_OPLOCKS 0x00000080
+#define SMB_CAP_LOCK_AND_READ    0x00000100
+#define SMB_CAP_NT_FIND          0x00000200
+#define SMB_CAP_DFS              0x00001000
+#define SMB_CAP_LARGE_READX      0x00004000
+#define SMB_CAP_LARGE_WRITEX     0x00008000
+#define SMB_CAP_UNIX             0x00800000     /* unofficial ... */
+
+
+/*
+ * This is the time we allow an inode, dentry or dir cache to live. It is bad
+ * for performance to have shorter ttl on an inode than on the cache. It can
+ * cause refresh on each inode for a dir listing ... one-by-one
+ */
+#define SMB_MAX_AGE(server) (((server)->mnt->ttl * HZ) / 1000)
+
+static inline void
+smb_age_dentry(struct smb_sb_info *server, struct dentry *dentry)
+{
+        dentry->d_time = jiffies - SMB_MAX_AGE(server);
+}
+
+struct smb_cache_head {
+        time_t          mtime;  /* unused */
+        unsigned long   time;   /* cache age */
+        unsigned long   end;    /* last valid fpos in cache */
+        int             eof;
+};
+
+#define SMB_DIRCACHE_SIZE       ((int)(PAGE_CACHE_SIZE/sizeof(struct dentry *)))
+union smb_dir_cache {
+        struct smb_cache_head   head;
+        struct dentry           *dentry[SMB_DIRCACHE_SIZE];
+};
+
+#define SMB_FIRSTCACHE_SIZE     ((int)((SMB_DIRCACHE_SIZE * \
+        sizeof(struct dentry *) - sizeof(struct smb_cache_head)) / \
+        sizeof(struct dentry *)))
+
+#define SMB_DIRCACHE_START      (SMB_DIRCACHE_SIZE - SMB_FIRSTCACHE_SIZE)
+
+struct smb_cache_control {
+        struct  smb_cache_head          head;
+        struct  page                    *page;
+        union   smb_dir_cache           *cache;
+        unsigned long                   fpos, ofs;
+        int                             filled, valid, idx;
+};
+
+#define SMB_OPS_NUM_STATIC      5
+struct smb_ops {
+        int (*read)(struct inode *inode, loff_t offset, int count,
+                    char *data);
+        int (*write)(struct inode *inode, loff_t offset, int count, const
+                     char *data);
+        int (*readdir)(struct file *filp, void *dirent, filldir_t filldir,
+                       struct smb_cache_control *ctl);
+
+        int (*getattr)(struct smb_sb_info *server, struct dentry *dir,
+                       struct smb_fattr *fattr);
+        /* int (*setattr)(...); */      /* setattr is really icky! */
+
+        int (*truncate)(struct inode *inode, loff_t length);
+
+
+        /* --- --- --- end of "static" entries --- --- --- */
+
+        int (*convert)(unsigned char *output, int olen,
+                       const unsigned char *input, int ilen,
+                       struct nls_table *nls_from,
+                       struct nls_table *nls_to);
+};
+
+static inline int
+smb_is_open(struct inode *i)
+{
+        return (SMB_I(i)->open == server_from_inode(i)->generation);
+}
+
+extern void smb_install_null_ops(struct smb_ops *);
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SMB_FS_H */
diff --git a/include/linux/smb_fs_i.h b/include/linux/smb_fs_i.h
new file mode 100644
index 000000000000..8516954a5141
--- /dev/null
+++ b/include/linux/smb_fs_i.h
@@ -0,0 +1,39 @@
+/*
+ *  smb_fs_i.h
+ *
+ *  Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
+ *  Copyright (C) 1997 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_SMB_FS_I
+#define _LINUX_SMB_FS_I
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#include <linux/fs.h>
+
+/*
+ * smb fs inode data (in memory only)
+ */
+struct smb_inode_info {
+
+        /*
+         * file handles are local to a connection. A file is open if
+         * (open == generation).
+         */
+        unsigned int open;      /* open generation */
+        __u16 fileid;           /* What id to handle a file with? */
+        __u16 attr;             /* Attribute fields, DOS value */
+
+        __u16 access;           /* Access mode */
+        __u16 flags;
+        unsigned long oldmtime; /* last time refreshed */
+        unsigned long closed;   /* timestamp when closed */
+        unsigned openers;       /* number of fileid users */
+
+        struct inode vfs_inode; /* must be at the end */
+};
+
+#endif
+#endif
diff --git a/include/linux/smb_fs_sb.h b/include/linux/smb_fs_sb.h
new file mode 100644
index 000000000000..5b4ae2cc445c
--- /dev/null
+++ b/include/linux/smb_fs_sb.h
@@ -0,0 +1,101 @@
+/*
+ *  smb_fs_sb.h
+ *
+ *  Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
+ *  Copyright (C) 1997 by Volker Lendecke
+ *
+ */
+
+#ifndef _SMB_FS_SB
+#define _SMB_FS_SB
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+#include <linux/smb.h>
+
+/*
+ * Upper limit on the total number of active smb_request structs.
+ */
+#define MAX_REQUEST_HARD       256
+
+enum smb_receive_state {
+        SMB_RECV_START,         /* No data read, looking for length + sig */
+        SMB_RECV_HEADER,        /* Reading the header data */
+        SMB_RECV_HCOMPLETE,     /* Done with the header */
+        SMB_RECV_PARAM,         /* Reading parameter words */
+        SMB_RECV_DATA,          /* Reading data bytes */
+        SMB_RECV_END,           /* End of request */
+        SMB_RECV_DROP,          /* Dropping this SMB */
+        SMB_RECV_REQUEST,       /* Received a request and not a reply */
+};
+
+/* structure access macros */
+#define server_from_inode(inode) SMB_SB((inode)->i_sb)
+#define server_from_dentry(dentry) SMB_SB((dentry)->d_sb)
+#define SB_of(server) ((server)->super_block)
+
+struct smb_sb_info {
+        /* List of all smbfs superblocks */
+        struct list_head entry;
+
+        enum smb_conn_state state;
+        struct file * sock_file;
+        int conn_error;
+        enum smb_receive_state rstate;
+
+        atomic_t nr_requests;
+        struct list_head xmitq;
+        struct list_head recvq;
+        u16 mid;
+
+        struct smb_mount_data_kernel *mnt;
+
+        /* Connections are counted. Each time a new socket arrives,
+         * generation is incremented.
+         */
+        unsigned int generation;
+        pid_t conn_pid;
+        struct smb_conn_opt opt;
+        wait_queue_head_t conn_wq;
+        int conn_complete;
+        struct semaphore sem;
+
+        unsigned char      header[SMB_HEADER_LEN + 20*2 + 2];
+        u32                header_len;
+        u32                smb_len;
+        u32                smb_read;
+
+        /* We use our own data_ready callback, but need the original one */
+        void *data_ready;
+
+        /* nls pointers for codepage conversions */
+        struct nls_table *remote_nls;
+        struct nls_table *local_nls;
+
+        struct smb_ops *ops;
+
+        struct super_block *super_block;
+};
+
+static inline int
+smb_lock_server_interruptible(struct smb_sb_info *server)
+{
+        return down_interruptible(&(server->sem));
+}
+
+static inline void
+smb_lock_server(struct smb_sb_info *server)
+{
+        down(&(server->sem));
+}
+
+static inline void
+smb_unlock_server(struct smb_sb_info *server)
+{
+        up(&(server->sem));
+}
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/smb_mount.h b/include/linux/smb_mount.h
new file mode 100644
index 000000000000..d10f00cb5703
--- /dev/null
+++ b/include/linux/smb_mount.h
@@ -0,0 +1,65 @@
+/*
+ *  smb_mount.h
+ *
+ *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
+ *  Copyright (C) 1997 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_SMB_MOUNT_H
+#define _LINUX_SMB_MOUNT_H
+
+#include <linux/types.h>
+
+#define SMB_MOUNT_VERSION       6
+
+struct smb_mount_data {
+        int version;
+        __kernel_uid_t mounted_uid; /* Who may umount() this filesystem? */
+        __kernel_uid_t uid;
+        __kernel_gid_t gid;
+        __kernel_mode_t file_mode;
+        __kernel_mode_t dir_mode;
+};
+
+
+#ifdef __KERNEL__
+
+/* "vers" in big-endian */
+#define SMB_MOUNT_ASCII 0x76657273
+
+#define SMB_MOUNT_OLDVERSION    6
+#undef SMB_MOUNT_VERSION
+#define SMB_MOUNT_VERSION       7
+
+/* flags */
+#define SMB_MOUNT_WIN95         0x0001  /* Win 95 server */
+#define SMB_MOUNT_OLDATTR       0x0002  /* Use core getattr (Win 95 speedup) */
+#define SMB_MOUNT_DIRATTR       0x0004  /* Use find_first for getattr */
+#define SMB_MOUNT_CASE          0x0008  /* Be case sensitive */
+#define SMB_MOUNT_UNICODE       0x0010  /* Server talks unicode */
+#define SMB_MOUNT_UID           0x0020  /* Use user specified uid */
+#define SMB_MOUNT_GID           0x0040  /* Use user specified gid */
+#define SMB_MOUNT_FMODE         0x0080  /* Use user specified file mode */
+#define SMB_MOUNT_DMODE         0x0100  /* Use user specified dir mode */
+
+struct smb_mount_data_kernel {
+        int version;
+
+        uid_t mounted_uid;      /* Who may umount() this filesystem? */
+        uid_t uid;
+        gid_t gid;
+        mode_t file_mode;
+        mode_t dir_mode;
+
+        u32 flags;
+
+        /* maximum age in jiffies (inode, dentry and dircache) */
+        int ttl;
+
+        struct smb_nls_codepage codepage;
+};
+
+#endif
+
+#endif
diff --git a/include/linux/smbno.h b/include/linux/smbno.h
new file mode 100644
index 000000000000..f99e02d9ffe2
--- /dev/null
+++ b/include/linux/smbno.h
@@ -0,0 +1,363 @@
+#ifndef _SMBNO_H_
+#define _SMBNO_H_
+
+/* these define the attribute byte as seen by DOS */
+#define aRONLY  (1L<<0)
+#define aHIDDEN (1L<<1)
+#define aSYSTEM (1L<<2)
+#define aVOLID  (1L<<3)
+#define aDIR    (1L<<4)
+#define aARCH   (1L<<5)
+
+/* error classes */
+#define SUCCESS 0  /* The request was successful. */
+#define ERRDOS 0x01 /*  Error is from the core DOS operating system set. */
+#define ERRSRV 0x02 /* Error is generated by the server network file manager.*/
+#define ERRHRD 0x03  /* Error is an hardware error. */
+#define ERRCMD 0xFF  /* Command was not in the "SMB" format. */
+
+/* SMB X/Open error codes for the ERRdos error class */
+
+#define ERRbadfunc 1            /* Invalid function (or system call) */
+#define ERRbadfile 2            /* File not found (pathname error) */
+#define ERRbadpath 3            /* Directory not found */
+#define ERRnofids 4             /* Too many open files */
+#define ERRnoaccess 5           /* Access denied */
+#define ERRbadfid 6             /* Invalid fid */
+#define ERRbadmcb 7             /* Memory control blocks destroyed */
+#define ERRnomem 8              /* Out of memory */
+#define ERRbadmem 9             /* Invalid memory block address */
+#define ERRbadenv 10            /* Invalid environment */
+#define ERRbadformat 11         /* Invalid format */
+#define ERRbadaccess 12         /* Invalid open mode */
+#define ERRbaddata 13           /* Invalid data (only from ioctl call) */
+#define ERRres 14               /* reserved */
+#define ERRbaddrive 15          /* Invalid drive */
+#define ERRremcd 16             /* Attempt to delete current directory */
+#define ERRdiffdevice 17        /* rename/move across different filesystems */
+#define ERRnofiles 18           /* no more files found in file search */
+#define ERRbadshare 32          /* Share mode on file conflict with open mode */
+#define ERRlock 33              /* Lock request conflicts with existing lock */
+#define ERRfilexists 80         /* File in operation already exists */
+#define ERRbadpipe 230          /* Named pipe invalid */
+#define ERRpipebusy 231         /* All instances of pipe are busy */
+#define ERRpipeclosing 232      /* named pipe close in progress */
+#define ERRnotconnected 233     /* No process on other end of named pipe */
+#define ERRmoredata 234         /* More data to be returned */
+
+#define ERROR_INVALID_PARAMETER  87
+#define ERROR_DISK_FULL         112
+#define ERROR_INVALID_NAME      123
+#define ERROR_DIR_NOT_EMPTY     145
+#define ERROR_NOT_LOCKED        158
+#define ERROR_ALREADY_EXISTS    183  /* see also 80 ? */
+#define ERROR_EAS_DIDNT_FIT     275 /* Extended attributes didn't fit */
+#define ERROR_EAS_NOT_SUPPORTED 282 /* Extended attributes not supported */
+
+/* Error codes for the ERRSRV class */
+
+#define ERRerror 1              /* Non specific error code */
+#define ERRbadpw 2              /* Bad password */
+#define ERRbadtype 3            /* reserved */
+#define ERRaccess 4          /* No permissions to do the requested operation */
+#define ERRinvnid 5             /* tid invalid */
+#define ERRinvnetname 6         /* Invalid servername */
+#define ERRinvdevice 7          /* Invalid device */
+#define ERRqfull 49             /* Print queue full */
+#define ERRqtoobig 50           /* Queued item too big */
+#define ERRinvpfid 52           /* Invalid print file in smb_fid */
+#define ERRsmbcmd 64            /* Unrecognised command */
+#define ERRsrverror 65          /* smb server internal error */
+#define ERRfilespecs 67         /* fid and pathname invalid combination */
+#define ERRbadlink 68           /* reserved */
+#define ERRbadpermits 69        /* Access specified for a file is not valid */
+#define ERRbadpid 70            /* reserved */
+#define ERRsetattrmode 71       /* attribute mode invalid */
+#define ERRpaused 81            /* Message server paused */
+#define ERRmsgoff 82            /* Not receiving messages */
+#define ERRnoroom 83            /* No room for message */
+#define ERRrmuns 87             /* too many remote usernames */
+#define ERRtimeout 88           /* operation timed out */
+#define ERRnoresource  89   /* No resources currently available for request. */
+#define ERRtoomanyuids 90       /* too many userids */
+#define ERRbaduid 91            /* bad userid */
+#define ERRuseMPX 250    /* temporarily unable to use raw mode, use MPX mode */
+#define ERRuseSTD 251    /* temporarily unable to use raw mode, use std.mode */
+#define ERRcontMPX 252          /* resume MPX mode */
+#define ERRbadPW                /* reserved */
+#define ERRnosupport 0xFFFF
+
+/* Error codes for the ERRHRD class */
+
+#define ERRnowrite 19           /* read only media */
+#define ERRbadunit 20           /* Unknown device */
+#define ERRnotready 21          /* Drive not ready */
+#define ERRbadcmd 22            /* Unknown command */
+#define ERRdata 23              /* Data (CRC) error */
+#define ERRbadreq 24            /* Bad request structure length */
+#define ERRseek 25
+#define ERRbadmedia 26
+#define ERRbadsector 27
+#define ERRnopaper 28
+#define ERRwrite 29             /* write fault */
+#define ERRread 30              /* read fault */
+#define ERRgeneral 31           /* General hardware failure */
+#define ERRwrongdisk 34
+#define ERRFCBunavail 35
+#define ERRsharebufexc 36       /* share buffer exceeded */
+#define ERRdiskfull 39
+
+/*
+ * Access modes when opening a file
+ */
+#define SMB_ACCMASK     0x0003
+#define SMB_O_RDONLY    0x0000
+#define SMB_O_WRONLY    0x0001
+#define SMB_O_RDWR      0x0002
+
+/* offsets into message for common items */
+#define smb_com 8
+#define smb_rcls 9
+#define smb_reh 10
+#define smb_err 11
+#define smb_flg 13
+#define smb_flg2 14
+#define smb_reb 13
+#define smb_tid 28
+#define smb_pid 30
+#define smb_uid 32
+#define smb_mid 34
+#define smb_wct 36
+#define smb_vwv 37
+#define smb_vwv0 37
+#define smb_vwv1 39
+#define smb_vwv2 41
+#define smb_vwv3 43
+#define smb_vwv4 45
+#define smb_vwv5 47
+#define smb_vwv6 49
+#define smb_vwv7 51
+#define smb_vwv8 53
+#define smb_vwv9 55
+#define smb_vwv10 57
+#define smb_vwv11 59
+#define smb_vwv12 61
+#define smb_vwv13 63
+#define smb_vwv14 65
+
+/* these are the trans2 sub fields for primary requests */
+#define smb_tpscnt smb_vwv0
+#define smb_tdscnt smb_vwv1
+#define smb_mprcnt smb_vwv2
+#define smb_mdrcnt smb_vwv3
+#define smb_msrcnt smb_vwv4
+#define smb_flags smb_vwv5
+#define smb_timeout smb_vwv6
+#define smb_pscnt smb_vwv9
+#define smb_psoff smb_vwv10
+#define smb_dscnt smb_vwv11
+#define smb_dsoff smb_vwv12
+#define smb_suwcnt smb_vwv13
+#define smb_setup smb_vwv14
+#define smb_setup0 smb_setup
+#define smb_setup1 (smb_setup+2)
+#define smb_setup2 (smb_setup+4)
+
+/* these are for the secondary requests */
+#define smb_spscnt smb_vwv2
+#define smb_spsoff smb_vwv3
+#define smb_spsdisp smb_vwv4
+#define smb_sdscnt smb_vwv5
+#define smb_sdsoff smb_vwv6
+#define smb_sdsdisp smb_vwv7
+#define smb_sfid smb_vwv8
+
+/* and these for responses */
+#define smb_tprcnt smb_vwv0
+#define smb_tdrcnt smb_vwv1
+#define smb_prcnt smb_vwv3
+#define smb_proff smb_vwv4
+#define smb_prdisp smb_vwv5
+#define smb_drcnt smb_vwv6
+#define smb_droff smb_vwv7
+#define smb_drdisp smb_vwv8
+
+/* the complete */
+#define SMBmkdir      0x00   /* create directory */
+#define SMBrmdir      0x01   /* delete directory */
+#define SMBopen       0x02   /* open file */
+#define SMBcreate     0x03   /* create file */
+#define SMBclose      0x04   /* close file */
+#define SMBflush      0x05   /* flush file */
+#define SMBunlink     0x06   /* delete file */
+#define SMBmv         0x07   /* rename file */
+#define SMBgetatr     0x08   /* get file attributes */
+#define SMBsetatr     0x09   /* set file attributes */
+#define SMBread       0x0A   /* read from file */
+#define SMBwrite      0x0B   /* write to file */
+#define SMBlock       0x0C   /* lock byte range */
+#define SMBunlock     0x0D   /* unlock byte range */
+#define SMBctemp      0x0E   /* create temporary file */
+#define SMBmknew      0x0F   /* make new file */
+#define SMBchkpth     0x10   /* check directory path */
+#define SMBexit       0x11   /* process exit */
+#define SMBlseek      0x12   /* seek */
+#define SMBtcon       0x70   /* tree connect */
+#define SMBtconX      0x75   /* tree connect and X*/
+#define SMBtdis       0x71   /* tree disconnect */
+#define SMBnegprot    0x72   /* negotiate protocol */
+#define SMBdskattr    0x80   /* get disk attributes */
+#define SMBsearch     0x81   /* search directory */
+#define SMBsplopen    0xC0   /* open print spool file */
+#define SMBsplwr      0xC1   /* write to print spool file */
+#define SMBsplclose   0xC2   /* close print spool file */
+#define SMBsplretq    0xC3   /* return print queue */
+#define SMBsends      0xD0   /* send single block message */
+#define SMBsendb      0xD1   /* send broadcast message */
+#define SMBfwdname    0xD2   /* forward user name */
+#define SMBcancelf    0xD3   /* cancel forward */
+#define SMBgetmac     0xD4   /* get machine name */
+#define SMBsendstrt   0xD5   /* send start of multi-block message */
+#define SMBsendend    0xD6   /* send end of multi-block message */
+#define SMBsendtxt    0xD7   /* send text of multi-block message */
+
+/* Core+ protocol */
+#define SMBlockread       0x13   /* Lock a range and read */
+#define SMBwriteunlock 0x14 /* Unlock a range then write */
+#define SMBreadbraw   0x1a  /* read a block of data with no smb header */
+#define SMBwritebraw  0x1d  /* write a block of data with no smb header */
+#define SMBwritec     0x20  /* secondary write request */
+#define SMBwriteclose 0x2c  /* write a file then close it */
+
+/* dos extended protocol */
+#define SMBreadBraw      0x1A   /* read block raw */
+#define SMBreadBmpx      0x1B   /* read block multiplexed */
+#define SMBreadBs        0x1C   /* read block (secondary response) */
+#define SMBwriteBraw     0x1D   /* write block raw */
+#define SMBwriteBmpx     0x1E   /* write block multiplexed */
+#define SMBwriteBs       0x1F   /* write block (secondary request) */
+#define SMBwriteC        0x20   /* write complete response */
+#define SMBsetattrE      0x22   /* set file attributes expanded */
+#define SMBgetattrE      0x23   /* get file attributes expanded */
+#define SMBlockingX      0x24   /* lock/unlock byte ranges and X */
+#define SMBtrans         0x25   /* transaction - name, bytes in/out */
+#define SMBtranss        0x26   /* transaction (secondary request/response) */
+#define SMBioctl         0x27   /* IOCTL */
+#define SMBioctls        0x28   /* IOCTL  (secondary request/response) */
+#define SMBcopy          0x29   /* copy */
+#define SMBmove          0x2A   /* move */
+#define SMBecho          0x2B   /* echo */
+#define SMBopenX         0x2D   /* open and X */
+#define SMBreadX         0x2E   /* read and X */
+#define SMBwriteX        0x2F   /* write and X */
+#define SMBsesssetupX    0x73   /* Session Set Up & X (including User Logon) */
+#define SMBtconX         0x75   /* tree connect and X */
+#define SMBffirst        0x82   /* find first */
+#define SMBfunique       0x83   /* find unique */
+#define SMBfclose        0x84   /* find close */
+#define SMBinvalid       0xFE   /* invalid command */
+
+
+/* Extended 2.0 protocol */
+#define SMBtrans2        0x32   /* TRANS2 protocol set */
+#define SMBtranss2       0x33   /* TRANS2 protocol set, secondary command */
+#define SMBfindclose     0x34   /* Terminate a TRANSACT2_FINDFIRST */
+#define SMBfindnclose    0x35   /* Terminate a TRANSACT2_FINDNOTIFYFIRST */
+#define SMBulogoffX      0x74   /* user logoff */
+
+/* these are the TRANS2 sub commands */
+#define TRANSACT2_OPEN          0
+#define TRANSACT2_FINDFIRST     1
+#define TRANSACT2_FINDNEXT      2
+#define TRANSACT2_QFSINFO       3
+#define TRANSACT2_SETFSINFO     4
+#define TRANSACT2_QPATHINFO     5
+#define TRANSACT2_SETPATHINFO   6
+#define TRANSACT2_QFILEINFO     7
+#define TRANSACT2_SETFILEINFO   8
+#define TRANSACT2_FSCTL         9
+#define TRANSACT2_IOCTL           10
+#define TRANSACT2_FINDNOTIFYFIRST 11
+#define TRANSACT2_FINDNOTIFYNEXT  12
+#define TRANSACT2_MKDIR           13
+
+/* Information Levels -  Shared? */
+#define SMB_INFO_STANDARD               1
+#define SMB_INFO_QUERY_EA_SIZE          2
+#define SMB_INFO_QUERY_EAS_FROM_LIST    3
+#define SMB_INFO_QUERY_ALL_EAS          4
+#define SMB_INFO_IS_NAME_VALID          6
+
+/* Information Levels -  TRANSACT2_FINDFIRST */
+#define SMB_FIND_FILE_DIRECTORY_INFO            0x101
+#define SMB_FIND_FILE_FULL_DIRECTORY_INFO       0x102
+#define SMB_FIND_FILE_NAMES_INFO                0x103
+#define SMB_FIND_FILE_BOTH_DIRECTORY_INFO       0x104
+
+/* Information Levels -  TRANSACT2_QPATHINFO */
+#define SMB_QUERY_FILE_BASIC_INFO       0x101
+#define SMB_QUERY_FILE_STANDARD_INFO    0x102
+#define SMB_QUERY_FILE_EA_INFO          0x103
+#define SMB_QUERY_FILE_NAME_INFO        0x104
+#define SMB_QUERY_FILE_ALL_INFO         0x107
+#define SMB_QUERY_FILE_ALT_NAME_INFO    0x108
+#define SMB_QUERY_FILE_STREAM_INFO      0x109
+#define SMB_QUERY_FILE_COMPRESSION_INFO 0x10b
+
+/* Information Levels - TRANSACT2_SETFILEINFO */
+#define SMB_SET_FILE_BASIC_INFO         0x101
+#define SMB_SET_FILE_DISPOSITION_INFO   0x102
+#define SMB_SET_FILE_ALLOCATION_INFO    0x103
+#define SMB_SET_FILE_END_OF_FILE_INFO   0x104
+
+/* smb_flg field flags */
+#define SMB_FLAGS_SUPPORT_LOCKREAD      0x01
+#define SMB_FLAGS_CLIENT_BUF_AVAIL      0x02
+#define SMB_FLAGS_RESERVED              0x04
+#define SMB_FLAGS_CASELESS_PATHNAMES    0x08
+#define SMB_FLAGS_CANONICAL_PATHNAMES   0x10
+#define SMB_FLAGS_REQUEST_OPLOCK        0x20
+#define SMB_FLAGS_REQUEST_BATCH_OPLOCK  0x40
+#define SMB_FLAGS_REPLY                 0x80
+
+/* smb_flg2 field flags (samba-2.2.0/source/include/smb.h) */
+#define SMB_FLAGS2_LONG_PATH_COMPONENTS         0x0001
+#define SMB_FLAGS2_EXTENDED_ATTRIBUTES          0x0002
+#define SMB_FLAGS2_DFS_PATHNAMES                0x1000
+#define SMB_FLAGS2_READ_PERMIT_NO_EXECUTE       0x2000
+#define SMB_FLAGS2_32_BIT_ERROR_CODES           0x4000 
+#define SMB_FLAGS2_UNICODE_STRINGS              0x8000
+
+
+/*
+ * UNIX stuff  (from samba trans2.h)
+ */
+#define MIN_UNIX_INFO_LEVEL             0x200
+#define MAX_UNIX_INFO_LEVEL             0x2FF
+#define SMB_FIND_FILE_UNIX              0x202
+#define SMB_QUERY_FILE_UNIX_BASIC       0x200
+#define SMB_QUERY_FILE_UNIX_LINK        0x201
+#define SMB_QUERY_FILE_UNIX_HLINK       0x202
+#define SMB_SET_FILE_UNIX_BASIC         0x200
+#define SMB_SET_FILE_UNIX_LINK          0x201
+#define SMB_SET_FILE_UNIX_HLINK         0x203
+#define SMB_QUERY_CIFS_UNIX_INFO        0x200
+
+/* values which means "don't change it" */
+#define SMB_MODE_NO_CHANGE              0xFFFFFFFF
+#define SMB_UID_NO_CHANGE               0xFFFFFFFF
+#define SMB_GID_NO_CHANGE               0xFFFFFFFF
+#define SMB_TIME_NO_CHANGE              0xFFFFFFFFFFFFFFFFULL
+#define SMB_SIZE_NO_CHANGE              0xFFFFFFFFFFFFFFFFULL
+
+/* UNIX filetype mappings. */
+#define UNIX_TYPE_FILE          0
+#define UNIX_TYPE_DIR           1
+#define UNIX_TYPE_SYMLINK       2
+#define UNIX_TYPE_CHARDEV       3
+#define UNIX_TYPE_BLKDEV        4
+#define UNIX_TYPE_FIFO          5
+#define UNIX_TYPE_SOCKET        6
+#define UNIX_TYPE_UNKNOWN       0xFFFFFFFF
+
+#endif /* _SMBNO_H_ */
diff --git a/include/linux/smp.h b/include/linux/smp.h
new file mode 100644
index 000000000000..dcf1db3b35d3
--- /dev/null
+++ b/include/linux/smp.h
@@ -0,0 +1,139 @@
+#ifndef __LINUX_SMP_H
+#define __LINUX_SMP_H
+
+/*
+ *      Generic SMP support
+ *              Alan Cox. <alan@redhat.com>
+ */
+
+#include <linux/config.h>
+
+extern void cpu_idle(void);
+
+#ifdef CONFIG_SMP
+
+#include <linux/preempt.h>
+#include <linux/kernel.h>
+#include <linux/compiler.h>
+#include <linux/thread_info.h>
+#include <asm/smp.h>
+#include <asm/bug.h>
+
+/*
+ * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
+ * (defined in asm header):
+ */ 
+
+/*
+ * stops all CPUs but the current one:
+ */
+extern void smp_send_stop(void);
+
+/*
+ * sends a 'reschedule' event to another CPU:
+ */
+extern void smp_send_reschedule(int cpu);
+
+
+/*
+ * Prepare machine for booting other CPUs.
+ */
+extern void smp_prepare_cpus(unsigned int max_cpus);
+
+/*
+ * Bring a CPU up
+ */
+extern int __cpu_up(unsigned int cpunum);
+
+/*
+ * Final polishing of CPUs
+ */
+extern void smp_cpus_done(unsigned int max_cpus);
+
+/*
+ * Call a function on all other processors
+ */
+extern int smp_call_function (void (*func) (void *info), void *info,
+                              int retry, int wait);
+
+/*
+ * Call a function on all processors
+ */
+static inline int on_each_cpu(void (*func) (void *info), void *info,
+                              int retry, int wait)
+{
+        int ret = 0;
+
+        preempt_disable();
+        ret = smp_call_function(func, info, retry, wait);
+        func(info);
+        preempt_enable();
+        return ret;
+}
+
+#define MSG_ALL_BUT_SELF        0x8000  /* Assume <32768 CPU's */
+#define MSG_ALL                 0x8001
+
+#define MSG_INVALIDATE_TLB      0x0001  /* Remote processor TLB invalidate */
+#define MSG_STOP_CPU            0x0002  /* Sent to shut down slave CPU's
+                                         * when rebooting
+                                         */
+#define MSG_RESCHEDULE          0x0003  /* Reschedule request from master CPU*/
+#define MSG_CALL_FUNCTION       0x0004  /* Call function on all other CPUs */
+
+/*
+ * Mark the boot cpu "online" so that it can call console drivers in
+ * printk() and can access its per-cpu storage.
+ */
+void smp_prepare_boot_cpu(void);
+
+#else /* !SMP */
+
+/*
+ *      These macros fold the SMP functionality into a single CPU system
+ */
+
+#if !defined(__smp_processor_id) || !defined(CONFIG_PREEMPT)
+# define smp_processor_id()                     0
+#endif
+#define hard_smp_processor_id()                 0
+#define smp_call_function(func,info,retry,wait) ({ 0; })
+#define on_each_cpu(func,info,retry,wait)       ({ func(info); 0; })
+static inline void smp_send_reschedule(int cpu) { }
+#define num_booting_cpus()                      1
+#define smp_prepare_boot_cpu()                  do {} while (0)
+
+#endif /* !SMP */
+
+/*
+ * DEBUG_PREEMPT support: check whether smp_processor_id() is being
+ * used in a preemption-safe way.
+ *
+ * An architecture has to enable this debugging code explicitly.
+ * It can do so by renaming the smp_processor_id() macro to
+ * __smp_processor_id().  This should only be done after some minimal
+ * testing, because usually there are a number of false positives
+ * that an architecture will trigger.
+ *
+ * To fix a false positive (i.e. smp_processor_id() use that the
+ * debugging code reports but which use for some reason is legal),
+ * change the smp_processor_id() reference to _smp_processor_id(),
+ * which is the nondebug variant.  NOTE: don't use this to hack around
+ * real bugs.
+ */
+#ifdef __smp_processor_id
+# if defined(CONFIG_PREEMPT) && defined(CONFIG_DEBUG_PREEMPT)
+   extern unsigned int smp_processor_id(void);
+# else
+#  define smp_processor_id() __smp_processor_id()
+# endif
+# define _smp_processor_id() __smp_processor_id()
+#else
+# define _smp_processor_id() smp_processor_id()
+#endif
+
+#define get_cpu()               ({ preempt_disable(); smp_processor_id(); })
+#define put_cpu()               preempt_enable()
+#define put_cpu_no_resched()    preempt_enable_no_resched()
+
+#endif /* __LINUX_SMP_H */
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h
new file mode 100644
index 000000000000..b63ce7014093
--- /dev/null
+++ b/include/linux/smp_lock.h
@@ -0,0 +1,54 @@
+#ifndef __LINUX_SMPLOCK_H
+#define __LINUX_SMPLOCK_H
+
+#include <linux/config.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+
+#ifdef CONFIG_LOCK_KERNEL
+
+#define kernel_locked()         (current->lock_depth >= 0)
+
+extern int __lockfunc __reacquire_kernel_lock(void);
+extern void __lockfunc __release_kernel_lock(void);
+
+/*
+ * Release/re-acquire global kernel lock for the scheduler
+ */
+#define release_kernel_lock(tsk) do {           \
+        if (unlikely((tsk)->lock_depth >= 0))   \
+                __release_kernel_lock();        \
+} while (0)
+
+/*
+ * Non-SMP kernels will never block on the kernel lock,
+ * so we are better off returning a constant zero from
+ * reacquire_kernel_lock() so that the compiler can see
+ * it at compile-time.
+ */
+#if defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT_BKL)
+# define return_value_on_smp return
+#else
+# define return_value_on_smp
+#endif
+
+static inline int reacquire_kernel_lock(struct task_struct *task)
+{
+        if (unlikely(task->lock_depth >= 0))
+                return_value_on_smp __reacquire_kernel_lock();
+        return 0;
+}
+
+extern void __lockfunc lock_kernel(void)        __acquires(kernel_lock);
+extern void __lockfunc unlock_kernel(void)      __releases(kernel_lock);
+
+#else
+
+#define lock_kernel()                           do { } while(0)
+#define unlock_kernel()                         do { } while(0)
+#define release_kernel_lock(task)               do { } while(0)
+#define reacquire_kernel_lock(task)             0
+#define kernel_locked()                         1
+
+#endif /* CONFIG_LOCK_KERNEL */
+#endif /* __LINUX_SMPLOCK_H */
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
new file mode 100644
index 000000000000..4db25d5c7cd1
--- /dev/null
+++ b/include/linux/snmp.h
@@ -0,0 +1,266 @@
+/*
+ * Definitions for MIBs
+ *
+ * Author: Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>
+ */
+
+#ifndef _LINUX_SNMP_H
+#define _LINUX_SNMP_H
+
+/* ipstats mib definitions */
+/*
+ * RFC 1213:  MIB-II
+ * RFC 2011 (updates 1213):  SNMPv2-MIB-IP
+ * RFC 2863:  Interfaces Group MIB
+ * RFC 2465:  IPv6 MIB: General Group
+ * draft-ietf-ipv6-rfc2011-update-10.txt: MIB for IP: IP Statistics Tables
+ */
+enum
+{
+        IPSTATS_MIB_NUM = 0,
+        IPSTATS_MIB_INRECEIVES,                 /* InReceives */
+        IPSTATS_MIB_INHDRERRORS,                /* InHdrErrors */
+        IPSTATS_MIB_INTOOBIGERRORS,             /* InTooBigErrors */
+        IPSTATS_MIB_INNOROUTES,                 /* InNoRoutes */
+        IPSTATS_MIB_INADDRERRORS,               /* InAddrErrors */
+        IPSTATS_MIB_INUNKNOWNPROTOS,            /* InUnknownProtos */
+        IPSTATS_MIB_INTRUNCATEDPKTS,            /* InTruncatedPkts */
+        IPSTATS_MIB_INDISCARDS,                 /* InDiscards */
+        IPSTATS_MIB_INDELIVERS,                 /* InDelivers */
+        IPSTATS_MIB_OUTFORWDATAGRAMS,           /* OutForwDatagrams */
+        IPSTATS_MIB_OUTREQUESTS,                /* OutRequests */
+        IPSTATS_MIB_OUTDISCARDS,                /* OutDiscards */
+        IPSTATS_MIB_OUTNOROUTES,                /* OutNoRoutes */
+        IPSTATS_MIB_REASMTIMEOUT,               /* ReasmTimeout */
+        IPSTATS_MIB_REASMREQDS,                 /* ReasmReqds */
+        IPSTATS_MIB_REASMOKS,                   /* ReasmOKs */
+        IPSTATS_MIB_REASMFAILS,                 /* ReasmFails */
+        IPSTATS_MIB_FRAGOKS,                    /* FragOKs */
+        IPSTATS_MIB_FRAGFAILS,                  /* FragFails */
+        IPSTATS_MIB_FRAGCREATES,                /* FragCreates */
+        IPSTATS_MIB_INMCASTPKTS,                /* InMcastPkts */
+        IPSTATS_MIB_OUTMCASTPKTS,               /* OutMcastPkts */
+        __IPSTATS_MIB_MAX
+};
+
+/* icmp mib definitions */
+/*
+ * RFC 1213:  MIB-II ICMP Group
+ * RFC 2011 (updates 1213):  SNMPv2 MIB for IP: ICMP group
+ */
+enum
+{
+        ICMP_MIB_NUM = 0,
+        ICMP_MIB_INMSGS,                        /* InMsgs */
+        ICMP_MIB_INERRORS,                      /* InErrors */
+        ICMP_MIB_INDESTUNREACHS,                /* InDestUnreachs */
+        ICMP_MIB_INTIMEEXCDS,                   /* InTimeExcds */
+        ICMP_MIB_INPARMPROBS,                   /* InParmProbs */
+        ICMP_MIB_INSRCQUENCHS,                  /* InSrcQuenchs */
+        ICMP_MIB_INREDIRECTS,                   /* InRedirects */
+        ICMP_MIB_INECHOS,                       /* InEchos */
+        ICMP_MIB_INECHOREPS,                    /* InEchoReps */
+        ICMP_MIB_INTIMESTAMPS,                  /* InTimestamps */
+        ICMP_MIB_INTIMESTAMPREPS,               /* InTimestampReps */
+        ICMP_MIB_INADDRMASKS,                   /* InAddrMasks */
+        ICMP_MIB_INADDRMASKREPS,                /* InAddrMaskReps */
+        ICMP_MIB_OUTMSGS,                       /* OutMsgs */
+        ICMP_MIB_OUTERRORS,                     /* OutErrors */
+        ICMP_MIB_OUTDESTUNREACHS,               /* OutDestUnreachs */
+        ICMP_MIB_OUTTIMEEXCDS,                  /* OutTimeExcds */
+        ICMP_MIB_OUTPARMPROBS,                  /* OutParmProbs */
+        ICMP_MIB_OUTSRCQUENCHS,                 /* OutSrcQuenchs */
+        ICMP_MIB_OUTREDIRECTS,                  /* OutRedirects */
+        ICMP_MIB_OUTECHOS,                      /* OutEchos */
+        ICMP_MIB_OUTECHOREPS,                   /* OutEchoReps */
+        ICMP_MIB_OUTTIMESTAMPS,                 /* OutTimestamps */
+        ICMP_MIB_OUTTIMESTAMPREPS,              /* OutTimestampReps */
+        ICMP_MIB_OUTADDRMASKS,                  /* OutAddrMasks */
+        ICMP_MIB_OUTADDRMASKREPS,               /* OutAddrMaskReps */
+        __ICMP_MIB_MAX
+};
+
+/* icmp6 mib definitions */
+/*
+ * RFC 2466:  ICMPv6-MIB
+ */
+enum
+{
+        ICMP6_MIB_NUM = 0,
+        ICMP6_MIB_INMSGS,                       /* InMsgs */
+        ICMP6_MIB_INERRORS,                     /* InErrors */
+        ICMP6_MIB_INDESTUNREACHS,               /* InDestUnreachs */
+        ICMP6_MIB_INPKTTOOBIGS,                 /* InPktTooBigs */
+        ICMP6_MIB_INTIMEEXCDS,                  /* InTimeExcds */
+        ICMP6_MIB_INPARMPROBLEMS,               /* InParmProblems */
+        ICMP6_MIB_INECHOS,                      /* InEchos */
+        ICMP6_MIB_INECHOREPLIES,                /* InEchoReplies */
+        ICMP6_MIB_INGROUPMEMBQUERIES,           /* InGroupMembQueries */
+        ICMP6_MIB_INGROUPMEMBRESPONSES,         /* InGroupMembResponses */
+        ICMP6_MIB_INGROUPMEMBREDUCTIONS,        /* InGroupMembReductions */
+        ICMP6_MIB_INROUTERSOLICITS,             /* InRouterSolicits */
+        ICMP6_MIB_INROUTERADVERTISEMENTS,       /* InRouterAdvertisements */
+        ICMP6_MIB_INNEIGHBORSOLICITS,           /* InNeighborSolicits */
+        ICMP6_MIB_INNEIGHBORADVERTISEMENTS,     /* InNeighborAdvertisements */
+        ICMP6_MIB_INREDIRECTS,                  /* InRedirects */
+        ICMP6_MIB_OUTMSGS,                      /* OutMsgs */
+        ICMP6_MIB_OUTDESTUNREACHS,              /* OutDestUnreachs */
+        ICMP6_MIB_OUTPKTTOOBIGS,                /* OutPktTooBigs */
+        ICMP6_MIB_OUTTIMEEXCDS,                 /* OutTimeExcds */
+        ICMP6_MIB_OUTPARMPROBLEMS,              /* OutParmProblems */
+        ICMP6_MIB_OUTECHOREPLIES,               /* OutEchoReplies */
+        ICMP6_MIB_OUTROUTERSOLICITS,            /* OutRouterSolicits */
+        ICMP6_MIB_OUTNEIGHBORSOLICITS,          /* OutNeighborSolicits */
+        ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS,    /* OutNeighborAdvertisements */
+        ICMP6_MIB_OUTREDIRECTS,                 /* OutRedirects */
+        ICMP6_MIB_OUTGROUPMEMBRESPONSES,        /* OutGroupMembResponses */
+        ICMP6_MIB_OUTGROUPMEMBREDUCTIONS,       /* OutGroupMembReductions */
+        __ICMP6_MIB_MAX
+};
+
+/* tcp mib definitions */
+/*
+ * RFC 1213:  MIB-II TCP group
+ * RFC 2012 (updates 1213):  SNMPv2-MIB-TCP
+ */
+enum
+{
+        TCP_MIB_NUM = 0,
+        TCP_MIB_RTOALGORITHM,                   /* RtoAlgorithm */
+        TCP_MIB_RTOMIN,                         /* RtoMin */
+        TCP_MIB_RTOMAX,                         /* RtoMax */
+        TCP_MIB_MAXCONN,                        /* MaxConn */
+        TCP_MIB_ACTIVEOPENS,                    /* ActiveOpens */
+        TCP_MIB_PASSIVEOPENS,                   /* PassiveOpens */
+        TCP_MIB_ATTEMPTFAILS,                   /* AttemptFails */
+        TCP_MIB_ESTABRESETS,                    /* EstabResets */
+        TCP_MIB_CURRESTAB,                      /* CurrEstab */
+        TCP_MIB_INSEGS,                         /* InSegs */
+        TCP_MIB_OUTSEGS,                        /* OutSegs */
+        TCP_MIB_RETRANSSEGS,                    /* RetransSegs */
+        TCP_MIB_INERRS,                         /* InErrs */
+        TCP_MIB_OUTRSTS,                        /* OutRsts */
+        __TCP_MIB_MAX
+};
+
+/* udp mib definitions */
+/*
+ * RFC 1213:  MIB-II UDP group
+ * RFC 2013 (updates 1213):  SNMPv2-MIB-UDP
+ */
+enum
+{
+        UDP_MIB_NUM = 0,
+        UDP_MIB_INDATAGRAMS,                    /* InDatagrams */
+        UDP_MIB_NOPORTS,                        /* NoPorts */
+        UDP_MIB_INERRORS,                       /* InErrors */
+        UDP_MIB_OUTDATAGRAMS,                   /* OutDatagrams */
+        __UDP_MIB_MAX
+};
+
+/* sctp mib definitions */
+/*
+ * draft-ietf-sigtran-sctp-mib-07.txt
+ */
+enum
+{
+        SCTP_MIB_NUM = 0,
+        SCTP_MIB_CURRESTAB,                     /* CurrEstab */
+        SCTP_MIB_ACTIVEESTABS,                  /* ActiveEstabs */
+        SCTP_MIB_PASSIVEESTABS,                 /* PassiveEstabs */
+        SCTP_MIB_ABORTEDS,                      /* Aborteds */
+        SCTP_MIB_SHUTDOWNS,                     /* Shutdowns */
+        SCTP_MIB_OUTOFBLUES,                    /* OutOfBlues */
+        SCTP_MIB_CHECKSUMERRORS,                /* ChecksumErrors */
+        SCTP_MIB_OUTCTRLCHUNKS,                 /* OutCtrlChunks */
+        SCTP_MIB_OUTORDERCHUNKS,                /* OutOrderChunks */
+        SCTP_MIB_OUTUNORDERCHUNKS,              /* OutUnorderChunks */
+        SCTP_MIB_INCTRLCHUNKS,                  /* InCtrlChunks */
+        SCTP_MIB_INORDERCHUNKS,                 /* InOrderChunks */
+        SCTP_MIB_INUNORDERCHUNKS,               /* InUnorderChunks */
+        SCTP_MIB_FRAGUSRMSGS,                   /* FragUsrMsgs */
+        SCTP_MIB_REASMUSRMSGS,                  /* ReasmUsrMsgs */
+        SCTP_MIB_OUTSCTPPACKS,                  /* OutSCTPPacks */
+        SCTP_MIB_INSCTPPACKS,                   /* InSCTPPacks */
+        SCTP_MIB_RTOALGORITHM,                  /* RtoAlgorithm */
+        SCTP_MIB_RTOMIN,                        /* RtoMin */
+        SCTP_MIB_RTOMAX,                        /* RtoMax */
+        SCTP_MIB_RTOINITIAL,                    /* RtoInitial */
+        SCTP_MIB_VALCOOKIELIFE,                 /* ValCookieLife */
+        SCTP_MIB_MAXINITRETR,                   /* MaxInitRetr */
+        __SCTP_MIB_MAX
+};
+
+/* linux mib definitions */
+enum
+{
+        LINUX_MIB_NUM = 0,
+        LINUX_MIB_SYNCOOKIESSENT,               /* SyncookiesSent */
+        LINUX_MIB_SYNCOOKIESRECV,               /* SyncookiesRecv */
+        LINUX_MIB_SYNCOOKIESFAILED,             /* SyncookiesFailed */
+        LINUX_MIB_EMBRYONICRSTS,                /* EmbryonicRsts */
+        LINUX_MIB_PRUNECALLED,                  /* PruneCalled */
+        LINUX_MIB_RCVPRUNED,                    /* RcvPruned */
+        LINUX_MIB_OFOPRUNED,                    /* OfoPruned */
+        LINUX_MIB_OUTOFWINDOWICMPS,             /* OutOfWindowIcmps */
+        LINUX_MIB_LOCKDROPPEDICMPS,             /* LockDroppedIcmps */
+        LINUX_MIB_ARPFILTER,                    /* ArpFilter */
+        LINUX_MIB_TIMEWAITED,                   /* TimeWaited */
+        LINUX_MIB_TIMEWAITRECYCLED,             /* TimeWaitRecycled */
+        LINUX_MIB_TIMEWAITKILLED,               /* TimeWaitKilled */
+        LINUX_MIB_PAWSPASSIVEREJECTED,          /* PAWSPassiveRejected */
+        LINUX_MIB_PAWSACTIVEREJECTED,           /* PAWSActiveRejected */
+        LINUX_MIB_PAWSESTABREJECTED,            /* PAWSEstabRejected */
+        LINUX_MIB_DELAYEDACKS,                  /* DelayedACKs */
+        LINUX_MIB_DELAYEDACKLOCKED,             /* DelayedACKLocked */
+        LINUX_MIB_DELAYEDACKLOST,               /* DelayedACKLost */
+        LINUX_MIB_LISTENOVERFLOWS,              /* ListenOverflows */
+        LINUX_MIB_LISTENDROPS,                  /* ListenDrops */
+        LINUX_MIB_TCPPREQUEUED,                 /* TCPPrequeued */
+        LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG,     /* TCPDirectCopyFromBacklog */
+        LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE,    /* TCPDirectCopyFromPrequeue */
+        LINUX_MIB_TCPPREQUEUEDROPPED,           /* TCPPrequeueDropped */
+        LINUX_MIB_TCPHPHITS,                    /* TCPHPHits */
+        LINUX_MIB_TCPHPHITSTOUSER,              /* TCPHPHitsToUser */
+        LINUX_MIB_TCPPUREACKS,                  /* TCPPureAcks */
+        LINUX_MIB_TCPHPACKS,                    /* TCPHPAcks */
+        LINUX_MIB_TCPRENORECOVERY,              /* TCPRenoRecovery */
+        LINUX_MIB_TCPSACKRECOVERY,              /* TCPSackRecovery */
+        LINUX_MIB_TCPSACKRENEGING,              /* TCPSACKReneging */
+        LINUX_MIB_TCPFACKREORDER,               /* TCPFACKReorder */
+        LINUX_MIB_TCPSACKREORDER,               /* TCPSACKReorder */
+        LINUX_MIB_TCPRENOREORDER,               /* TCPRenoReorder */
+        LINUX_MIB_TCPTSREORDER,                 /* TCPTSReorder */
+        LINUX_MIB_TCPFULLUNDO,                  /* TCPFullUndo */
+        LINUX_MIB_TCPPARTIALUNDO,               /* TCPPartialUndo */
+        LINUX_MIB_TCPDSACKUNDO,                 /* TCPDSACKUndo */
+        LINUX_MIB_TCPLOSSUNDO,                  /* TCPLossUndo */
+        LINUX_MIB_TCPLOSS,                      /* TCPLoss */
+        LINUX_MIB_TCPLOSTRETRANSMIT,            /* TCPLostRetransmit */
+        LINUX_MIB_TCPRENOFAILURES,              /* TCPRenoFailures */
+        LINUX_MIB_TCPSACKFAILURES,              /* TCPSackFailures */
+        LINUX_MIB_TCPLOSSFAILURES,              /* TCPLossFailures */
+        LINUX_MIB_TCPFASTRETRANS,               /* TCPFastRetrans */
+        LINUX_MIB_TCPFORWARDRETRANS,            /* TCPForwardRetrans */
+        LINUX_MIB_TCPSLOWSTARTRETRANS,          /* TCPSlowStartRetrans */
+        LINUX_MIB_TCPTIMEOUTS,                  /* TCPTimeouts */
+        LINUX_MIB_TCPRENORECOVERYFAIL,          /* TCPRenoRecoveryFail */
+        LINUX_MIB_TCPSACKRECOVERYFAIL,          /* TCPSackRecoveryFail */
+        LINUX_MIB_TCPSCHEDULERFAILED,           /* TCPSchedulerFailed */
+        LINUX_MIB_TCPRCVCOLLAPSED,              /* TCPRcvCollapsed */
+        LINUX_MIB_TCPDSACKOLDSENT,              /* TCPDSACKOldSent */
+        LINUX_MIB_TCPDSACKOFOSENT,              /* TCPDSACKOfoSent */
+        LINUX_MIB_TCPDSACKRECV,                 /* TCPDSACKRecv */
+        LINUX_MIB_TCPDSACKOFORECV,              /* TCPDSACKOfoRecv */
+        LINUX_MIB_TCPABORTONSYN,                /* TCPAbortOnSyn */
+        LINUX_MIB_TCPABORTONDATA,               /* TCPAbortOnData */
+        LINUX_MIB_TCPABORTONCLOSE,              /* TCPAbortOnClose */
+        LINUX_MIB_TCPABORTONMEMORY,             /* TCPAbortOnMemory */
+        LINUX_MIB_TCPABORTONTIMEOUT,            /* TCPAbortOnTimeout */
+        LINUX_MIB_TCPABORTONLINGER,             /* TCPAbortOnLinger */
+        LINUX_MIB_TCPABORTFAILED,               /* TCPAbortFailed */
+        LINUX_MIB_TCPMEMORYPRESSURES,           /* TCPMemoryPressures */
+        __LINUX_MIB_MAX
+};
+
+#endif  /* _LINUX_SNMP_H */
diff --git a/include/linux/socket.h b/include/linux/socket.h
new file mode 100644
index 000000000000..a5c7d96e4d2e
--- /dev/null
+++ b/include/linux/socket.h
@@ -0,0 +1,295 @@
+#ifndef _LINUX_SOCKET_H
+#define _LINUX_SOCKET_H
+
+/*
+ * Desired design of maximum size and alignment (see RFC2553)
+ */
+#define _K_SS_MAXSIZE   128     /* Implementation specific max size */
+#define _K_SS_ALIGNSIZE (__alignof__ (struct sockaddr *))
+                                /* Implementation specific desired alignment */
+
+struct __kernel_sockaddr_storage {
+        unsigned short  ss_family;              /* address family */
+        /* Following field(s) are implementation specific */
+        char            __data[_K_SS_MAXSIZE - sizeof(unsigned short)];
+                                /* space to achieve desired size, */
+                                /* _SS_MAXSIZE value minus size of ss_family */
+} __attribute__ ((aligned(_K_SS_ALIGNSIZE)));   /* force desired alignment */
+
+#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
+
+#include <linux/config.h>               /* for CONFIG_COMPAT */
+#include <linux/linkage.h>
+#include <asm/socket.h>                 /* arch-dependent defines       */
+#include <linux/sockios.h>              /* the SIOCxxx I/O controls     */
+#include <linux/uio.h>                  /* iovec support                */
+#include <linux/types.h>                /* pid_t                        */
+#include <linux/compiler.h>             /* __user                       */
+
+typedef unsigned short  sa_family_t;
+
+/*
+ *      1003.1g requires sa_family_t and that sa_data is char.
+ */
+ 
+struct sockaddr {
+        sa_family_t     sa_family;      /* address family, AF_xxx       */
+        char            sa_data[14];    /* 14 bytes of protocol address */
+};
+
+struct linger {
+        int             l_onoff;        /* Linger active                */
+        int             l_linger;       /* How long to linger for       */
+};
+
+#define sockaddr_storage __kernel_sockaddr_storage
+
+/*
+ *      As we do 4.4BSD message passing we use a 4.4BSD message passing
+ *      system, not 4.3. Thus msg_accrights(len) are now missing. They
+ *      belong in an obscure libc emulation or the bin.
+ */
+ 
+struct msghdr {
+        void    *       msg_name;       /* Socket name                  */
+        int             msg_namelen;    /* Length of name               */
+        struct iovec *  msg_iov;        /* Data blocks                  */
+        __kernel_size_t msg_iovlen;     /* Number of blocks             */
+        void    *       msg_control;    /* Per protocol magic (eg BSD file descriptor passing) */
+        __kernel_size_t msg_controllen; /* Length of cmsg list */
+        unsigned        msg_flags;
+};
+
+/*
+ *      POSIX 1003.1g - ancillary data object information
+ *      Ancillary data consits of a sequence of pairs of
+ *      (cmsghdr, cmsg_data[])
+ */
+
+struct cmsghdr {
+        __kernel_size_t cmsg_len;       /* data byte count, including hdr */
+        int             cmsg_level;     /* originating protocol */
+        int             cmsg_type;      /* protocol-specific type */
+};
+
+/*
+ *      Ancilliary data object information MACROS
+ *      Table 5-14 of POSIX 1003.1g
+ */
+
+#define __CMSG_NXTHDR(ctl, len, cmsg) __cmsg_nxthdr((ctl),(len),(cmsg))
+#define CMSG_NXTHDR(mhdr, cmsg) cmsg_nxthdr((mhdr), (cmsg))
+
+#define CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
+
+#define CMSG_DATA(cmsg) ((void *)((char *)(cmsg) + CMSG_ALIGN(sizeof(struct cmsghdr))))
+#define CMSG_SPACE(len) (CMSG_ALIGN(sizeof(struct cmsghdr)) + CMSG_ALIGN(len))
+#define CMSG_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr)) + (len))
+
+#define __CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct cmsghdr) ? \
+                                  (struct cmsghdr *)(ctl) : \
+                                  (struct cmsghdr *)NULL)
+#define CMSG_FIRSTHDR(msg)      __CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
+#define CMSG_OK(mhdr, cmsg) ((cmsg)->cmsg_len >= sizeof(struct cmsghdr) && \
+                             (cmsg)->cmsg_len <= (unsigned long) \
+                             ((mhdr)->msg_controllen - \
+                              ((char *)(cmsg) - (char *)(mhdr)->msg_control)))
+
+/*
+ *      This mess will go away with glibc
+ */
+ 
+#ifdef __KERNEL__
+#define __KINLINE static inline
+#elif  defined(__GNUC__) 
+#define __KINLINE static __inline__
+#elif defined(__cplusplus)
+#define __KINLINE static inline
+#else
+#define __KINLINE static
+#endif
+
+
+/*
+ *      Get the next cmsg header
+ *
+ *      PLEASE, do not touch this function. If you think, that it is
+ *      incorrect, grep kernel sources and think about consequences
+ *      before trying to improve it.
+ *
+ *      Now it always returns valid, not truncated ancillary object
+ *      HEADER. But caller still MUST check, that cmsg->cmsg_len is
+ *      inside range, given by msg->msg_controllen before using
+ *      ancillary object DATA.                          --ANK (980731)
+ */
+ 
+__KINLINE struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
+                                               struct cmsghdr *__cmsg)
+{
+        struct cmsghdr * __ptr;
+
+        __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) +  CMSG_ALIGN(__cmsg->cmsg_len));
+        if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
+                return (struct cmsghdr *)0;
+
+        return __ptr;
+}
+
+__KINLINE struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
+{
+        return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
+}
+
+/* "Socket"-level control message types: */
+
+#define SCM_RIGHTS      0x01            /* rw: access rights (array of int) */
+#define SCM_CREDENTIALS 0x02            /* rw: struct ucred             */
+
+struct ucred {
+        __u32   pid;
+        __u32   uid;
+        __u32   gid;
+};
+
+/* Supported address families. */
+#define AF_UNSPEC       0
+#define AF_UNIX         1       /* Unix domain sockets          */
+#define AF_LOCAL        1       /* POSIX name for AF_UNIX       */
+#define AF_INET         2       /* Internet IP Protocol         */
+#define AF_AX25         3       /* Amateur Radio AX.25          */
+#define AF_IPX          4       /* Novell IPX                   */
+#define AF_APPLETALK    5       /* AppleTalk DDP                */
+#define AF_NETROM       6       /* Amateur Radio NET/ROM        */
+#define AF_BRIDGE       7       /* Multiprotocol bridge         */
+#define AF_ATMPVC       8       /* ATM PVCs                     */
+#define AF_X25          9       /* Reserved for X.25 project    */
+#define AF_INET6        10      /* IP version 6                 */
+#define AF_ROSE         11      /* Amateur Radio X.25 PLP       */
+#define AF_DECnet       12      /* Reserved for DECnet project  */
+#define AF_NETBEUI      13      /* Reserved for 802.2LLC project*/
+#define AF_SECURITY     14      /* Security callback pseudo AF */
+#define AF_KEY          15      /* PF_KEY key management API */
+#define AF_NETLINK      16
+#define AF_ROUTE        AF_NETLINK /* Alias to emulate 4.4BSD */
+#define AF_PACKET       17      /* Packet family                */
+#define AF_ASH          18      /* Ash                          */
+#define AF_ECONET       19      /* Acorn Econet                 */
+#define AF_ATMSVC       20      /* ATM SVCs                     */
+#define AF_SNA          22      /* Linux SNA Project (nutters!) */
+#define AF_IRDA         23      /* IRDA sockets                 */
+#define AF_PPPOX        24      /* PPPoX sockets                */
+#define AF_WANPIPE      25      /* Wanpipe API Sockets */
+#define AF_LLC          26      /* Linux LLC                    */
+#define AF_BLUETOOTH    31      /* Bluetooth sockets            */
+#define AF_MAX          32      /* For now.. */
+
+/* Protocol families, same as address families. */
+#define PF_UNSPEC       AF_UNSPEC
+#define PF_UNIX         AF_UNIX
+#define PF_LOCAL        AF_LOCAL
+#define PF_INET         AF_INET
+#define PF_AX25         AF_AX25
+#define PF_IPX          AF_IPX
+#define PF_APPLETALK    AF_APPLETALK
+#define PF_NETROM       AF_NETROM
+#define PF_BRIDGE       AF_BRIDGE
+#define PF_ATMPVC       AF_ATMPVC
+#define PF_X25          AF_X25
+#define PF_INET6        AF_INET6
+#define PF_ROSE         AF_ROSE
+#define PF_DECnet       AF_DECnet
+#define PF_NETBEUI      AF_NETBEUI
+#define PF_SECURITY     AF_SECURITY
+#define PF_KEY          AF_KEY
+#define PF_NETLINK      AF_NETLINK
+#define PF_ROUTE        AF_ROUTE
+#define PF_PACKET       AF_PACKET
+#define PF_ASH          AF_ASH
+#define PF_ECONET       AF_ECONET
+#define PF_ATMSVC       AF_ATMSVC
+#define PF_SNA          AF_SNA
+#define PF_IRDA         AF_IRDA
+#define PF_PPPOX        AF_PPPOX
+#define PF_WANPIPE      AF_WANPIPE
+#define PF_LLC          AF_LLC
+#define PF_BLUETOOTH    AF_BLUETOOTH
+#define PF_MAX          AF_MAX
+
+/* Maximum queue length specifiable by listen.  */
+#define SOMAXCONN       128
+
+/* Flags we can use with send/ and recv. 
+   Added those for 1003.1g not all are supported yet
+ */
+ 
+#define MSG_OOB         1
+#define MSG_PEEK        2
+#define MSG_DONTROUTE   4
+#define MSG_TRYHARD     4       /* Synonym for MSG_DONTROUTE for DECnet */
+#define MSG_CTRUNC      8
+#define MSG_PROBE       0x10    /* Do not send. Only probe path f.e. for MTU */
+#define MSG_TRUNC       0x20
+#define MSG_DONTWAIT    0x40    /* Nonblocking io                */
+#define MSG_EOR         0x80    /* End of record */
+#define MSG_WAITALL     0x100   /* Wait for a full request */
+#define MSG_FIN         0x200
+#define MSG_SYN         0x400
+#define MSG_CONFIRM     0x800   /* Confirm path validity */
+#define MSG_RST         0x1000
+#define MSG_ERRQUEUE    0x2000  /* Fetch message from error queue */
+#define MSG_NOSIGNAL    0x4000  /* Do not generate SIGPIPE */
+#define MSG_MORE        0x8000  /* Sender will send more */
+
+#define MSG_EOF         MSG_FIN
+
+#if defined(CONFIG_COMPAT)
+#define MSG_CMSG_COMPAT 0x80000000      /* This message needs 32 bit fixups */
+#else
+#define MSG_CMSG_COMPAT 0               /* We never have 32 bit fixups */
+#endif
+
+
+/* Setsockoptions(2) level. Thanks to BSD these must match IPPROTO_xxx */
+#define SOL_IP          0
+/* #define SOL_ICMP     1       No-no-no! Due to Linux :-) we cannot use SOL_ICMP=1 */
+#define SOL_TCP         6
+#define SOL_UDP         17
+#define SOL_IPV6        41
+#define SOL_ICMPV6      58
+#define SOL_SCTP        132
+#define SOL_RAW         255
+#define SOL_IPX         256
+#define SOL_AX25        257
+#define SOL_ATALK       258
+#define SOL_NETROM      259
+#define SOL_ROSE        260
+#define SOL_DECNET      261
+#define SOL_X25         262
+#define SOL_PACKET      263
+#define SOL_ATM         264     /* ATM layer (cell level) */
+#define SOL_AAL         265     /* ATM Adaption Layer (packet level) */
+#define SOL_IRDA        266
+#define SOL_NETBEUI     267
+#define SOL_LLC         268
+
+/* IPX options */
+#define IPX_TYPE        1
+
+#ifdef __KERNEL__
+extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
+extern int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov, 
+                                int offset, int len);
+extern int csum_partial_copy_fromiovecend(unsigned char *kdata, 
+                                          struct iovec *iov, 
+                                          int offset, 
+                                          unsigned int len, int *csump);
+
+extern int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode);
+extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
+extern int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen);
+extern int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr);
+extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
+
+#endif
+#endif /* not kernel and not glibc */
+#endif /* _LINUX_SOCKET_H */
diff --git a/include/linux/sockios.h b/include/linux/sockios.h
new file mode 100644
index 000000000000..5eb33205cc04
--- /dev/null
+++ b/include/linux/sockios.h
@@ -0,0 +1,143 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions of the socket-level I/O control calls.
+ *
+ * Version:     @(#)sockios.h   1.0.2   03/09/93
+ *
+ * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_SOCKIOS_H
+#define _LINUX_SOCKIOS_H
+
+#include <asm/sockios.h>
+
+/* Linux-specific socket ioctls */
+#define SIOCINQ         FIONREAD
+#define SIOCOUTQ        TIOCOUTQ
+
+/* Routing table calls. */
+#define SIOCADDRT       0x890B          /* add routing table entry      */
+#define SIOCDELRT       0x890C          /* delete routing table entry   */
+#define SIOCRTMSG       0x890D          /* call to routing system       */
+
+/* Socket configuration controls. */
+#define SIOCGIFNAME     0x8910          /* get iface name               */
+#define SIOCSIFLINK     0x8911          /* set iface channel            */
+#define SIOCGIFCONF     0x8912          /* get iface list               */
+#define SIOCGIFFLAGS    0x8913          /* get flags                    */
+#define SIOCSIFFLAGS    0x8914          /* set flags                    */
+#define SIOCGIFADDR     0x8915          /* get PA address               */
+#define SIOCSIFADDR     0x8916          /* set PA address               */
+#define SIOCGIFDSTADDR  0x8917          /* get remote PA address        */
+#define SIOCSIFDSTADDR  0x8918          /* set remote PA address        */
+#define SIOCGIFBRDADDR  0x8919          /* get broadcast PA address     */
+#define SIOCSIFBRDADDR  0x891a          /* set broadcast PA address     */
+#define SIOCGIFNETMASK  0x891b          /* get network PA mask          */
+#define SIOCSIFNETMASK  0x891c          /* set network PA mask          */
+#define SIOCGIFMETRIC   0x891d          /* get metric                   */
+#define SIOCSIFMETRIC   0x891e          /* set metric                   */
+#define SIOCGIFMEM      0x891f          /* get memory address (BSD)     */
+#define SIOCSIFMEM      0x8920          /* set memory address (BSD)     */
+#define SIOCGIFMTU      0x8921          /* get MTU size                 */
+#define SIOCSIFMTU      0x8922          /* set MTU size                 */
+#define SIOCSIFNAME     0x8923          /* set interface name */
+#define SIOCSIFHWADDR   0x8924          /* set hardware address         */
+#define SIOCGIFENCAP    0x8925          /* get/set encapsulations       */
+#define SIOCSIFENCAP    0x8926          
+#define SIOCGIFHWADDR   0x8927          /* Get hardware address         */
+#define SIOCGIFSLAVE    0x8929          /* Driver slaving support       */
+#define SIOCSIFSLAVE    0x8930
+#define SIOCADDMULTI    0x8931          /* Multicast address lists      */
+#define SIOCDELMULTI    0x8932
+#define SIOCGIFINDEX    0x8933          /* name -> if_index mapping     */
+#define SIOGIFINDEX     SIOCGIFINDEX    /* misprint compatibility :-)   */
+#define SIOCSIFPFLAGS   0x8934          /* set/get extended flags set   */
+#define SIOCGIFPFLAGS   0x8935
+#define SIOCDIFADDR     0x8936          /* delete PA address            */
+#define SIOCSIFHWBROADCAST      0x8937  /* set hardware broadcast addr  */
+#define SIOCGIFCOUNT    0x8938          /* get number of devices */
+
+#define SIOCGIFBR       0x8940          /* Bridging support             */
+#define SIOCSIFBR       0x8941          /* Set bridging options         */
+
+#define SIOCGIFTXQLEN   0x8942          /* Get the tx queue length      */
+#define SIOCSIFTXQLEN   0x8943          /* Set the tx queue length      */
+
+#define SIOCGIFDIVERT   0x8944          /* Frame diversion support */
+#define SIOCSIFDIVERT   0x8945          /* Set frame diversion options */
+
+#define SIOCETHTOOL     0x8946          /* Ethtool interface            */
+
+#define SIOCGMIIPHY     0x8947          /* Get address of MII PHY in use. */
+#define SIOCGMIIREG     0x8948          /* Read MII PHY register.       */
+#define SIOCSMIIREG     0x8949          /* Write MII PHY register.      */
+
+#define SIOCWANDEV      0x894A          /* get/set netdev parameters    */
+
+/* ARP cache control calls. */
+                    /*  0x8950 - 0x8952  * obsolete calls, don't re-use */
+#define SIOCDARP        0x8953          /* delete ARP table entry       */
+#define SIOCGARP        0x8954          /* get ARP table entry          */
+#define SIOCSARP        0x8955          /* set ARP table entry          */
+
+/* RARP cache control calls. */
+#define SIOCDRARP       0x8960          /* delete RARP table entry      */
+#define SIOCGRARP       0x8961          /* get RARP table entry         */
+#define SIOCSRARP       0x8962          /* set RARP table entry         */
+
+/* Driver configuration calls */
+
+#define SIOCGIFMAP      0x8970          /* Get device parameters        */
+#define SIOCSIFMAP      0x8971          /* Set device parameters        */
+
+/* DLCI configuration calls */
+
+#define SIOCADDDLCI     0x8980          /* Create new DLCI device       */
+#define SIOCDELDLCI     0x8981          /* Delete DLCI device           */
+
+#define SIOCGIFVLAN     0x8982          /* 802.1Q VLAN support          */
+#define SIOCSIFVLAN     0x8983          /* Set 802.1Q VLAN options      */
+
+/* bonding calls */
+
+#define SIOCBONDENSLAVE 0x8990          /* enslave a device to the bond */
+#define SIOCBONDRELEASE 0x8991          /* release a slave from the bond*/
+#define SIOCBONDSETHWADDR      0x8992   /* set the hw addr of the bond  */
+#define SIOCBONDSLAVEINFOQUERY 0x8993   /* rtn info about slave state   */
+#define SIOCBONDINFOQUERY      0x8994   /* rtn info about bond state    */
+#define SIOCBONDCHANGEACTIVE   0x8995   /* update to a new active slave */
+                        
+/* bridge calls */
+#define SIOCBRADDBR     0x89a0          /* create new bridge device     */
+#define SIOCBRDELBR     0x89a1          /* remove bridge device         */
+#define SIOCBRADDIF     0x89a2          /* add interface to bridge      */
+#define SIOCBRDELIF     0x89a3          /* remove interface from bridge */
+
+/* Device private ioctl calls */
+
+/*
+ *      These 16 ioctls are available to devices via the do_ioctl() device
+ *      vector. Each device should include this file and redefine these names
+ *      as their own. Because these are device dependent it is a good idea
+ *      _NOT_ to issue them to random objects and hope.
+ *
+ *      THESE IOCTLS ARE _DEPRECATED_ AND WILL DISAPPEAR IN 2.5.X -DaveM
+ */
+ 
+#define SIOCDEVPRIVATE  0x89F0  /* to 89FF */
+
+/*
+ *      These 16 ioctl calls are protocol private
+ */
+ 
+#define SIOCPROTOPRIVATE 0x89E0 /* to 89EF */
+#endif  /* _LINUX_SOCKIOS_H */
diff --git a/include/linux/som.h b/include/linux/som.h
new file mode 100644
index 000000000000..166594e4e7be
--- /dev/null
+++ b/include/linux/som.h
@@ -0,0 +1,154 @@
+#ifndef _LINUX_SOM_H
+#define _LINUX_SOM_H
+
+/* File format definition for SOM executables / shared libraries */
+
+/* we need struct timespec */
+#include <linux/time.h>
+
+#define SOM_PAGESIZE 4096
+
+/* this is the SOM header */
+struct som_hdr {
+        short           system_id;              /* magic number - system */
+        short           a_magic;                /* magic number - file type */
+        unsigned int    version_id;             /* versiod ID: YYMMDDHH */
+        struct timespec file_time;              /* system clock */
+        unsigned int    entry_space;            /* space for entry point */
+        unsigned int    entry_subspace;         /* subspace for entry point */
+        unsigned int    entry_offset;           /* offset of entry point */
+        unsigned int    aux_header_location;    /* auxiliary header location */
+        unsigned int    aux_header_size;        /* auxiliary header size */
+        unsigned int    som_length;             /* length of entire SOM */
+        unsigned int    presumed_dp;            /* compiler's DP value */
+        unsigned int    space_location;         /* space dictionary location */
+        unsigned int    space_total;            /* number of space entries */
+        unsigned int    subspace_location;      /* subspace entries location */
+        unsigned int    subspace_total;         /* number of subspace entries */
+        unsigned int    loader_fixup_location;  /* MPE/iX loader fixup */
+        unsigned int    loader_fixup_total;     /* number of fixup records */
+        unsigned int    space_strings_location; /* (sub)space names */
+        unsigned int    space_strings_size;     /* size of strings area */
+        unsigned int    init_array_location;    /* reserved */
+        unsigned int    init_array_total;       /* reserved */
+        unsigned int    compiler_location;      /* module dictionary */
+        unsigned int    compiler_total;         /* number of modules */
+        unsigned int    symbol_location;        /* symbol dictionary */
+        unsigned int    symbol_total;           /* number of symbols */
+        unsigned int    fixup_request_location; /* fixup requests */
+        unsigned int    fixup_request_total;    /* number of fixup requests */
+        unsigned int    symbol_strings_location;/* module & symbol names area */
+        unsigned int    symbol_strings_size;    /* size of strings area */
+        unsigned int    unloadable_sp_location; /* unloadable spaces location */
+        unsigned int    unloadable_sp_size;     /* size of data */
+        unsigned int    checksum;
+};
+
+/* values for system_id */
+
+#define SOM_SID_PARISC_1_0      0x020b
+#define SOM_SID_PARISC_1_1      0x0210
+#define SOM_SID_PARISC_2_0      0x0214
+
+/* values for a_magic */
+
+#define SOM_LIB_EXEC            0x0104
+#define SOM_RELOCATABLE         0x0106
+#define SOM_EXEC_NONSHARE       0x0107
+#define SOM_EXEC_SHARE          0x0108
+#define SOM_EXEC_DEMAND         0x010B
+#define SOM_LIB_DYN             0x010D
+#define SOM_LIB_SHARE           0x010E
+#define SOM_LIB_RELOC           0x0619
+
+/* values for version_id.  Decimal not hex, yes.  Grr. */
+
+#define SOM_ID_OLD              85082112
+#define SOM_ID_NEW              87102412
+
+struct aux_id {
+        unsigned int    mandatory :1;   /* the linker must understand this */
+        unsigned int    copy      :1;   /* Must be copied by the linker */
+        unsigned int    append    :1;   /* Must be merged by the linker */
+        unsigned int    ignore    :1;   /* Discard section if unknown */
+        unsigned int    reserved  :12;
+        unsigned int    type      :16;  /* Header type */
+        unsigned int    length;         /* length of _following_ data */
+};
+
+/* The Exec Auxiliary Header.  Called The HP-UX Header within HP apparently. */
+struct som_exec_auxhdr {
+        struct aux_id   som_auxhdr;
+        int             exec_tsize;     /* Text size in bytes */
+        int             exec_tmem;      /* Address to load text at */
+        int             exec_tfile;     /* Location of text in file */
+        int             exec_dsize;     /* Data size in bytes */
+        int             exec_dmem;      /* Address to load data at */
+        int             exec_dfile;     /* Location of data in file */
+        int             exec_bsize;     /* Uninitialised data (bss) */
+        int             exec_entry;     /* Address to start executing */
+        int             exec_flags;     /* loader flags */
+        int             exec_bfill;     /* initialisation value for bss */
+};
+
+/* Oh, the things people do to avoid casts.  Shame it'll break with gcc's
+ * new aliasing rules really.
+ */
+union name_pt {
+        char *          n_name;
+        unsigned int    n_strx;
+};
+
+/* The Space Dictionary */
+struct space_dictionary_record {
+        union name_pt   name;                   /* index to subspace name */
+        unsigned int    is_loadable     :1;     /* loadable */
+        unsigned int    is_defined      :1;     /* defined within file */
+        unsigned int    is_private      :1;     /* not sharable */
+        unsigned int    has_intermediate_code :1; /* contains intermediate code */
+        unsigned int    is_tspecific    :1;     /* thread specific */
+        unsigned int    reserved        :11;    /* for future expansion */
+        unsigned int    sort_key        :8;     /* for linker */
+        unsigned int    reserved2       :8;     /* for future expansion */
+
+        int             space_number;           /* index */
+        int             subspace_index;         /* index into subspace dict */
+        unsigned int    subspace_quantity;      /* number of subspaces */
+        int             loader_fix_index;       /* for loader */
+        unsigned int    loader_fix_quantity;    /* for loader */
+        int             init_pointer_index;     /* data pointer array index */
+        unsigned int    init_pointer_quantity;  /* number of data pointers */
+};
+
+/* The Subspace Dictionary */
+struct subspace_dictionary_record {
+        int             space_index;
+        unsigned int    access_control_bits :7;
+        unsigned int    memory_resident :1;
+        unsigned int    dup_common      :1;
+        unsigned int    is_common       :1;
+        unsigned int    quadrant        :2;
+        unsigned int    initially_frozen :1;
+        unsigned int    is_first        :1;
+        unsigned int    code_only       :1;
+        unsigned int    sort_key        :8;
+        unsigned int    replicate_init  :1;
+        unsigned int    continuation    :1;
+        unsigned int    is_tspecific    :1;
+        unsigned int    is_comdat       :1;
+        unsigned int    reserved        :4;
+
+        int             file_loc_init_value;
+        unsigned int    initialization_length;
+        unsigned int    subspace_start;
+        unsigned int    subspace_length;
+
+        unsigned int    reserved2       :5;
+        unsigned int    alignment       :27;
+
+        union name_pt   name;
+        int             fixup_request_index;
+        unsigned int    fixup_request_quantity;
+};
+
+#endif /* _LINUX_SOM_H */
diff --git a/include/linux/sonet.h b/include/linux/sonet.h
new file mode 100644
index 000000000000..753680296e17
--- /dev/null
+++ b/include/linux/sonet.h
@@ -0,0 +1,75 @@
+/* sonet.h - SONET/SHD physical layer control */
+ 
+/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
+ 
+
+#ifndef LINUX_SONET_H
+#define LINUX_SONET_H
+
+#define __SONET_ITEMS \
+    __HANDLE_ITEM(section_bip);         /* section parity errors (B1) */ \
+    __HANDLE_ITEM(line_bip);            /* line parity errors (B2) */ \
+    __HANDLE_ITEM(path_bip);            /* path parity errors (B3) */ \
+    __HANDLE_ITEM(line_febe);           /* line parity errors at remote */ \
+    __HANDLE_ITEM(path_febe);           /* path parity errors at remote */ \
+    __HANDLE_ITEM(corr_hcs);            /* correctable header errors */ \
+    __HANDLE_ITEM(uncorr_hcs);          /* uncorrectable header errors */ \
+    __HANDLE_ITEM(tx_cells);            /* cells sent */ \
+    __HANDLE_ITEM(rx_cells);            /* cells received */
+
+struct sonet_stats {
+#define __HANDLE_ITEM(i) int i
+        __SONET_ITEMS
+#undef __HANDLE_ITEM
+} __attribute__ ((packed));
+
+
+#define SONET_GETSTAT   _IOR('a',ATMIOC_PHYTYP,struct sonet_stats)
+                                        /* get statistics */
+#define SONET_GETSTATZ  _IOR('a',ATMIOC_PHYTYP+1,struct sonet_stats)
+                                        /* ... and zero counters */
+#define SONET_SETDIAG   _IOWR('a',ATMIOC_PHYTYP+2,int)
+                                        /* set error insertion */
+#define SONET_CLRDIAG   _IOWR('a',ATMIOC_PHYTYP+3,int)
+                                        /* clear error insertion */
+#define SONET_GETDIAG   _IOR('a',ATMIOC_PHYTYP+4,int)
+                                        /* query error insertion */
+#define SONET_SETFRAMING _IO('a',ATMIOC_PHYTYP+5)
+                                        /* set framing mode (SONET/SDH) */
+#define SONET_GETFRAMING _IOR('a',ATMIOC_PHYTYP+6,int)
+                                        /* get framing mode */
+#define SONET_GETFRSENSE _IOR('a',ATMIOC_PHYTYP+7, \
+  unsigned char[SONET_FRSENSE_SIZE])    /* get framing sense information */
+
+#define SONET_INS_SBIP    1             /* section BIP */
+#define SONET_INS_LBIP    2             /* line BIP */
+#define SONET_INS_PBIP    4             /* path BIP */
+#define SONET_INS_FRAME   8             /* out of frame */
+#define SONET_INS_LOS    16             /* set line to zero */
+#define SONET_INS_LAIS   32             /* line alarm indication signal */
+#define SONET_INS_PAIS   64             /* path alarm indication signal */
+#define SONET_INS_HCS   128             /* insert HCS error */
+
+#define SONET_FRAME_SONET 0             /* SONET STS-3 framing */
+#define SONET_FRAME_SDH   1             /* SDH STM-1 framing */
+
+#define SONET_FRSENSE_SIZE 6            /* C1[3],H1[3] (0xff for unknown) */
+
+
+#ifdef __KERNEL__
+
+#include <asm/atomic.h>
+
+struct k_sonet_stats {
+#define __HANDLE_ITEM(i) atomic_t i
+        __SONET_ITEMS
+#undef __HANDLE_ITEM
+};
+
+extern void sonet_copy_stats(struct k_sonet_stats *from,struct sonet_stats *to);
+extern void sonet_subtract_stats(struct k_sonet_stats *from,
+    struct sonet_stats *to);
+
+#endif
+
+#endif
diff --git a/include/linux/sonypi.h b/include/linux/sonypi.h
new file mode 100644
index 000000000000..768cbba617d0
--- /dev/null
+++ b/include/linux/sonypi.h
@@ -0,0 +1,158 @@
+/*
+ * Sony Programmable I/O Control Device driver for VAIO
+ *
+ * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net>
+ *
+ * Copyright (C) 2005 Narayanan R S <nars@kadamba.org>
+
+ * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
+ *
+ * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
+ *
+ * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
+ *
+ * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
+ *
+ * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
+ *
+ * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef _SONYPI_H_
+#define _SONYPI_H_
+
+#include <linux/types.h>
+
+/* events the user application reading /dev/sonypi can use */
+
+#define SONYPI_EVENT_JOGDIAL_DOWN                1
+#define SONYPI_EVENT_JOGDIAL_UP                  2
+#define SONYPI_EVENT_JOGDIAL_DOWN_PRESSED        3
+#define SONYPI_EVENT_JOGDIAL_UP_PRESSED          4
+#define SONYPI_EVENT_JOGDIAL_PRESSED             5
+#define SONYPI_EVENT_JOGDIAL_RELEASED            6      /* obsolete */
+#define SONYPI_EVENT_CAPTURE_PRESSED             7
+#define SONYPI_EVENT_CAPTURE_RELEASED            8      /* obsolete */
+#define SONYPI_EVENT_CAPTURE_PARTIALPRESSED      9
+#define SONYPI_EVENT_CAPTURE_PARTIALRELEASED    10
+#define SONYPI_EVENT_FNKEY_ESC                  11
+#define SONYPI_EVENT_FNKEY_F1                   12
+#define SONYPI_EVENT_FNKEY_F2                   13
+#define SONYPI_EVENT_FNKEY_F3                   14
+#define SONYPI_EVENT_FNKEY_F4                   15
+#define SONYPI_EVENT_FNKEY_F5                   16
+#define SONYPI_EVENT_FNKEY_F6                   17
+#define SONYPI_EVENT_FNKEY_F7                   18
+#define SONYPI_EVENT_FNKEY_F8                   19
+#define SONYPI_EVENT_FNKEY_F9                   20
+#define SONYPI_EVENT_FNKEY_F10                  21
+#define SONYPI_EVENT_FNKEY_F11                  22
+#define SONYPI_EVENT_FNKEY_F12                  23
+#define SONYPI_EVENT_FNKEY_1                    24
+#define SONYPI_EVENT_FNKEY_2                    25
+#define SONYPI_EVENT_FNKEY_D                    26
+#define SONYPI_EVENT_FNKEY_E                    27
+#define SONYPI_EVENT_FNKEY_F                    28
+#define SONYPI_EVENT_FNKEY_S                    29
+#define SONYPI_EVENT_FNKEY_B                    30
+#define SONYPI_EVENT_BLUETOOTH_PRESSED          31
+#define SONYPI_EVENT_PKEY_P1                    32
+#define SONYPI_EVENT_PKEY_P2                    33
+#define SONYPI_EVENT_PKEY_P3                    34
+#define SONYPI_EVENT_BACK_PRESSED               35
+#define SONYPI_EVENT_LID_CLOSED                 36
+#define SONYPI_EVENT_LID_OPENED                 37
+#define SONYPI_EVENT_BLUETOOTH_ON               38
+#define SONYPI_EVENT_BLUETOOTH_OFF              39
+#define SONYPI_EVENT_HELP_PRESSED               40
+#define SONYPI_EVENT_FNKEY_ONLY                 41
+#define SONYPI_EVENT_JOGDIAL_FAST_DOWN          42
+#define SONYPI_EVENT_JOGDIAL_FAST_UP            43
+#define SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED  44
+#define SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED    45
+#define SONYPI_EVENT_JOGDIAL_VFAST_DOWN         46
+#define SONYPI_EVENT_JOGDIAL_VFAST_UP           47
+#define SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED 48
+#define SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED   49
+#define SONYPI_EVENT_ZOOM_PRESSED               50
+#define SONYPI_EVENT_THUMBPHRASE_PRESSED        51
+#define SONYPI_EVENT_MEYE_FACE                  52
+#define SONYPI_EVENT_MEYE_OPPOSITE              53
+#define SONYPI_EVENT_MEMORYSTICK_INSERT         54
+#define SONYPI_EVENT_MEMORYSTICK_EJECT          55
+#define SONYPI_EVENT_ANYBUTTON_RELEASED         56
+#define SONYPI_EVENT_BATTERY_INSERT             57
+#define SONYPI_EVENT_BATTERY_REMOVE             58
+#define SONYPI_EVENT_FNKEY_RELEASED             59
+
+/* get/set brightness */
+#define SONYPI_IOCGBRT          _IOR('v', 0, __u8)
+#define SONYPI_IOCSBRT          _IOW('v', 0, __u8)
+
+/* get battery full capacity/remaining capacity */
+#define SONYPI_IOCGBAT1CAP      _IOR('v', 2, __u16)
+#define SONYPI_IOCGBAT1REM      _IOR('v', 3, __u16)
+#define SONYPI_IOCGBAT2CAP      _IOR('v', 4, __u16)
+#define SONYPI_IOCGBAT2REM      _IOR('v', 5, __u16)
+
+/* get battery flags: battery1/battery2/ac adapter present */
+#define SONYPI_BFLAGS_B1        0x01
+#define SONYPI_BFLAGS_B2        0x02
+#define SONYPI_BFLAGS_AC        0x04
+#define SONYPI_IOCGBATFLAGS     _IOR('v', 7, __u8)
+
+/* get/set bluetooth subsystem state on/off */
+#define SONYPI_IOCGBLUE         _IOR('v', 8, __u8)
+#define SONYPI_IOCSBLUE         _IOW('v', 9, __u8)
+
+/* get/set fan state on/off */
+#define SONYPI_IOCGFAN          _IOR('v', 10, __u8)
+#define SONYPI_IOCSFAN          _IOW('v', 11, __u8)
+
+/* get temperature (C) */
+#define SONYPI_IOCGTEMP         _IOR('v', 12, __u8)
+
+#ifdef __KERNEL__
+
+/* used only for communication between v4l and sonypi */
+
+#define SONYPI_COMMAND_GETCAMERA                 1      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERA                 2
+#define SONYPI_COMMAND_GETCAMERABRIGHTNESS       3      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERABRIGHTNESS       4
+#define SONYPI_COMMAND_GETCAMERACONTRAST         5      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERACONTRAST         6
+#define SONYPI_COMMAND_GETCAMERAHUE              7      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERAHUE              8
+#define SONYPI_COMMAND_GETCAMERACOLOR            9      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERACOLOR           10
+#define SONYPI_COMMAND_GETCAMERASHARPNESS       11      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERASHARPNESS       12
+#define SONYPI_COMMAND_GETCAMERAPICTURE         13      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERAPICTURE         14
+#define SONYPI_COMMAND_GETCAMERAAGC             15      /* obsolete */
+#define SONYPI_COMMAND_SETCAMERAAGC             16
+#define SONYPI_COMMAND_GETCAMERADIRECTION       17      /* obsolete */
+#define SONYPI_COMMAND_GETCAMERAROMVERSION      18      /* obsolete */
+#define SONYPI_COMMAND_GETCAMERAREVISION        19      /* obsolete */
+
+int sonypi_camera_command(int command, u8 value);
+
+#endif                          /* __KERNEL__ */
+
+#endif                          /* _SONYPI_H_ */
diff --git a/include/linux/sort.h b/include/linux/sort.h
new file mode 100644
index 000000000000..d534da2b5575
--- /dev/null
+++ b/include/linux/sort.h
@@ -0,0 +1,10 @@
+#ifndef _LINUX_SORT_H
+#define _LINUX_SORT_H
+
+#include <linux/types.h>
+
+void sort(void *base, size_t num, size_t size,
+          int (*cmp)(const void *, const void *),
+          void (*swap)(void *, void *, int));
+
+#endif
diff --git a/include/linux/sound.h b/include/linux/sound.h
new file mode 100644
index 000000000000..428f59794f48
--- /dev/null
+++ b/include/linux/sound.h
@@ -0,0 +1,42 @@
+
+/*
+ * Minor numbers for the sound driver.
+ */
+
+#include <linux/fs.h>
+
+#define SND_DEV_CTL             0       /* Control port /dev/mixer */
+#define SND_DEV_SEQ             1       /* Sequencer output /dev/sequencer (FM
+                                                synthesizer and MIDI output) */
+#define SND_DEV_MIDIN           2       /* Raw midi access */
+#define SND_DEV_DSP             3       /* Digitized voice /dev/dsp */
+#define SND_DEV_AUDIO           4       /* Sparc compatible /dev/audio */
+#define SND_DEV_DSP16           5       /* Like /dev/dsp but 16 bits/sample */
+/* #define SND_DEV_STATUS       6 */    /* /dev/sndstat (obsolete) */
+#define SND_DEV_UNUSED          6
+#define SND_DEV_AWFM            7       /* Reserved */
+#define SND_DEV_SEQ2            8       /* /dev/sequencer, level 2 interface */
+/* #define SND_DEV_SNDPROC      9 */    /* /dev/sndproc for programmable devices (not used) */
+/* #define SND_DEV_DMMIDI       9 */
+#define SND_DEV_SYNTH           9       /* Raw synth access /dev/synth (same as /dev/dmfm) */
+#define SND_DEV_DMFM            10      /* Raw synth access /dev/dmfm */
+#define SND_DEV_UNKNOWN11       11
+#define SND_DEV_ADSP            12      /* Like /dev/dsp (obsolete) */
+#define SND_DEV_AMIDI           13      /* Like /dev/midi (obsolete) */
+#define SND_DEV_ADMMIDI         14      /* Like /dev/dmmidi (onsolete) */
+
+/*
+ *      Sound core interface functions
+ */
+ 
+extern int register_sound_special(struct file_operations *fops, int unit);
+extern int register_sound_mixer(struct file_operations *fops, int dev);
+extern int register_sound_midi(struct file_operations *fops, int dev);
+extern int register_sound_dsp(struct file_operations *fops, int dev);
+extern int register_sound_synth(struct file_operations *fops, int dev);
+
+extern void unregister_sound_special(int unit);
+extern void unregister_sound_mixer(int unit);
+extern void unregister_sound_midi(int unit);
+extern void unregister_sound_dsp(int unit);
+extern void unregister_sound_synth(int unit);
diff --git a/include/linux/soundcard.h b/include/linux/soundcard.h
new file mode 100644
index 000000000000..28d2d1881978
--- /dev/null
+++ b/include/linux/soundcard.h
@@ -0,0 +1,1298 @@
+#ifndef SOUNDCARD_H
+#define SOUNDCARD_H
+/*
+ * Copyright by Hannu Savolainen 1993-1997
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer. 2.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+/*
+ * OSS interface version. With versions earlier than 3.6 this value is
+ * an integer with value less than 361. In versions 3.6 and later
+ * it's a six digit hexadecimal value. For example value
+ * of 0x030600 represents OSS version 3.6.0.
+ * Use ioctl(fd, OSS_GETVERSION, &int) to get the version number of
+ * the currently active driver.
+ */
+#define SOUND_VERSION   0x030802
+#define OPEN_SOUND_SYSTEM
+
+/* In Linux we need to be prepared for cross compiling */
+#include <linux/ioctl.h>
+
+/*
+ *      Supported card ID numbers (Should be somewhere else?)
+ */
+
+#define SNDCARD_ADLIB           1
+#define SNDCARD_SB              2
+#define SNDCARD_PAS             3
+#define SNDCARD_GUS             4
+#define SNDCARD_MPU401          5
+#define SNDCARD_SB16            6
+#define SNDCARD_SB16MIDI        7
+#define SNDCARD_UART6850        8
+#define SNDCARD_GUS16           9
+#define SNDCARD_MSS             10
+#define SNDCARD_PSS             11
+#define SNDCARD_SSCAPE          12
+#define SNDCARD_PSS_MPU         13
+#define SNDCARD_PSS_MSS         14
+#define SNDCARD_SSCAPE_MSS      15
+#define SNDCARD_TRXPRO          16
+#define SNDCARD_TRXPRO_SB       17
+#define SNDCARD_TRXPRO_MPU      18
+#define SNDCARD_MAD16           19
+#define SNDCARD_MAD16_MPU       20
+#define SNDCARD_CS4232          21
+#define SNDCARD_CS4232_MPU      22
+#define SNDCARD_MAUI            23
+#define SNDCARD_PSEUDO_MSS      24
+#define SNDCARD_GUSPNP          25
+#define SNDCARD_UART401         26
+/* Sound card numbers 27 to N are reserved. Don't add more numbers here. */
+
+/***********************************
+ * IOCTL Commands for /dev/sequencer
+ */
+
+#ifndef _SIOWR
+#if defined(_IOWR) && (defined(_AIX) || (!defined(sun) && !defined(sparc) && !defined(__sparc__) && !defined(__INCioctlh) && !defined(__Lynx__)))
+/* Use already defined ioctl defines if they exist (except with Sun or Sparc) */
+#define SIOCPARM_MASK   IOCPARM_MASK
+#define SIOC_VOID       IOC_VOID
+#define SIOC_OUT        IOC_OUT
+#define SIOC_IN         IOC_IN
+#define SIOC_INOUT      IOC_INOUT
+#define _SIOC_SIZE      _IOC_SIZE
+#define _SIOC_DIR       _IOC_DIR
+#define _SIOC_NONE      _IOC_NONE
+#define _SIOC_READ      _IOC_READ
+#define _SIOC_WRITE     _IOC_WRITE
+#define _SIO            _IO
+#define _SIOR           _IOR
+#define _SIOW           _IOW
+#define _SIOWR          _IOWR
+#else
+
+/* Ioctl's have the command encoded in the lower word,
+ * and the size of any in or out parameters in the upper
+ * word.  The high 2 bits of the upper word are used
+ * to encode the in/out status of the parameter; for now
+ * we restrict parameters to at most 8191 bytes.
+ */
+/* #define      SIOCTYPE                (0xff<<8) */
+#define SIOCPARM_MASK   0x1fff          /* parameters must be < 8192 bytes */
+#define SIOC_VOID       0x00000000      /* no parameters */
+#define SIOC_OUT        0x20000000      /* copy out parameters */
+#define SIOC_IN         0x40000000      /* copy in parameters */
+#define SIOC_INOUT      (SIOC_IN|SIOC_OUT)
+/* the 0x20000000 is so we can distinguish new ioctl's from old */
+#define _SIO(x,y)       ((int)(SIOC_VOID|(x<<8)|y))
+#define _SIOR(x,y,t)    ((int)(SIOC_OUT|((sizeof(t)&SIOCPARM_MASK)<<16)|(x<<8)|y))
+#define _SIOW(x,y,t)    ((int)(SIOC_IN|((sizeof(t)&SIOCPARM_MASK)<<16)|(x<<8)|y))
+/* this should be _SIORW, but stdio got there first */
+#define _SIOWR(x,y,t)   ((int)(SIOC_INOUT|((sizeof(t)&SIOCPARM_MASK)<<16)|(x<<8)|y))
+#define _SIOC_SIZE(x)   ((x>>16)&SIOCPARM_MASK) 
+#define _SIOC_DIR(x)    (x & 0xf0000000)
+#define _SIOC_NONE      SIOC_VOID
+#define _SIOC_READ      SIOC_OUT
+#define _SIOC_WRITE     SIOC_IN
+#  endif /* _IOWR */
+#endif  /* !_SIOWR */
+
+#define SNDCTL_SEQ_RESET                _SIO  ('Q', 0)
+#define SNDCTL_SEQ_SYNC                 _SIO  ('Q', 1)
+#define SNDCTL_SYNTH_INFO               _SIOWR('Q', 2, struct synth_info)
+#define SNDCTL_SEQ_CTRLRATE             _SIOWR('Q', 3, int)     /* Set/get timer resolution (HZ) */
+#define SNDCTL_SEQ_GETOUTCOUNT          _SIOR ('Q', 4, int)
+#define SNDCTL_SEQ_GETINCOUNT           _SIOR ('Q', 5, int)
+#define SNDCTL_SEQ_PERCMODE             _SIOW ('Q', 6, int)
+#define SNDCTL_FM_LOAD_INSTR            _SIOW ('Q', 7, struct sbi_instrument)   /* Obsolete. Don't use!!!!!! */
+#define SNDCTL_SEQ_TESTMIDI             _SIOW ('Q', 8, int)
+#define SNDCTL_SEQ_RESETSAMPLES         _SIOW ('Q', 9, int)
+#define SNDCTL_SEQ_NRSYNTHS             _SIOR ('Q',10, int)
+#define SNDCTL_SEQ_NRMIDIS              _SIOR ('Q',11, int)
+#define SNDCTL_MIDI_INFO                _SIOWR('Q',12, struct midi_info)
+#define SNDCTL_SEQ_THRESHOLD            _SIOW ('Q',13, int)
+#define SNDCTL_SYNTH_MEMAVL             _SIOWR('Q',14, int)     /* in=dev#, out=memsize */
+#define SNDCTL_FM_4OP_ENABLE            _SIOW ('Q',15, int)     /* in=dev# */
+#define SNDCTL_SEQ_PANIC                _SIO  ('Q',17)
+#define SNDCTL_SEQ_OUTOFBAND            _SIOW ('Q',18, struct seq_event_rec)
+#define SNDCTL_SEQ_GETTIME              _SIOR ('Q',19, int)
+#define SNDCTL_SYNTH_ID                 _SIOWR('Q',20, struct synth_info)
+#define SNDCTL_SYNTH_CONTROL            _SIOWR('Q',21, struct synth_control)
+#define SNDCTL_SYNTH_REMOVESAMPLE       _SIOWR('Q',22, struct remove_sample)
+
+typedef struct synth_control
+{
+        int devno;      /* Synthesizer # */
+        char data[4000]; /* Device spesific command/data record */
+}synth_control;
+
+typedef struct remove_sample
+{
+        int devno;      /* Synthesizer # */
+        int bankno;     /* MIDI bank # (0=General MIDI) */
+        int instrno;    /* MIDI instrument number */
+} remove_sample;
+
+typedef struct seq_event_rec {
+                unsigned char arr[8];
+} seq_event_rec;
+
+#define SNDCTL_TMR_TIMEBASE             _SIOWR('T', 1, int)
+#define SNDCTL_TMR_START                _SIO  ('T', 2)
+#define SNDCTL_TMR_STOP                 _SIO  ('T', 3)
+#define SNDCTL_TMR_CONTINUE             _SIO  ('T', 4)
+#define SNDCTL_TMR_TEMPO                _SIOWR('T', 5, int)
+#define SNDCTL_TMR_SOURCE               _SIOWR('T', 6, int)
+#       define TMR_INTERNAL             0x00000001
+#       define TMR_EXTERNAL             0x00000002
+#               define TMR_MODE_MIDI    0x00000010
+#               define TMR_MODE_FSK     0x00000020
+#               define TMR_MODE_CLS     0x00000040
+#               define TMR_MODE_SMPTE   0x00000080
+#define SNDCTL_TMR_METRONOME            _SIOW ('T', 7, int)
+#define SNDCTL_TMR_SELECT               _SIOW ('T', 8, int)
+
+/*
+ * Some big endian/little endian handling macros
+ */
+
+#if defined(_AIX) || defined(AIX) || defined(sparc) || defined(__sparc__) || defined(HPPA) || defined(PPC) || defined(__mc68000__)
+/* Big endian machines */
+#  define _PATCHKEY(id) (0xfd00|id)
+#  define AFMT_S16_NE AFMT_S16_BE
+#else
+#  define _PATCHKEY(id) ((id<<8)|0xfd)
+#  define AFMT_S16_NE AFMT_S16_LE
+#endif
+
+/*
+ *      Sample loading mechanism for internal synthesizers (/dev/sequencer)
+ *      The following patch_info structure has been designed to support
+ *      Gravis UltraSound. It tries to be universal format for uploading
+ *      sample based patches but is probably too limited.
+ *
+ *      (PBD) As Hannu guessed, the GUS structure is too limited for 
+ *      the WaveFront, but this is the right place for a constant definition.
+ */
+
+struct patch_info {
+                unsigned short key;             /* Use WAVE_PATCH here */
+#define WAVE_PATCH         _PATCHKEY(0x04)
+#define GUS_PATCH          WAVE_PATCH
+#define WAVEFRONT_PATCH    _PATCHKEY(0x06)
+
+                short device_no;        /* Synthesizer number */
+                short instr_no;         /* Midi pgm# */
+
+                unsigned int mode;
+/*
+ * The least significant byte has the same format than the GUS .PAT
+ * files
+ */
+#define WAVE_16_BITS    0x01    /* bit 0 = 8 or 16 bit wave data. */
+#define WAVE_UNSIGNED   0x02    /* bit 1 = Signed - Unsigned data. */
+#define WAVE_LOOPING    0x04    /* bit 2 = looping enabled-1. */
+#define WAVE_BIDIR_LOOP 0x08    /* bit 3 = Set is bidirectional looping. */
+#define WAVE_LOOP_BACK  0x10    /* bit 4 = Set is looping backward. */
+#define WAVE_SUSTAIN_ON 0x20    /* bit 5 = Turn sustaining on. (Env. pts. 3)*/
+#define WAVE_ENVELOPES  0x40    /* bit 6 = Enable envelopes - 1 */
+#define WAVE_FAST_RELEASE 0x80  /* bit 7 = Shut off immediately after note off */
+                                /*      (use the env_rate/env_offs fields). */
+/* Linux specific bits */
+#define WAVE_VIBRATO    0x00010000      /* The vibrato info is valid */
+#define WAVE_TREMOLO    0x00020000      /* The tremolo info is valid */
+#define WAVE_SCALE      0x00040000      /* The scaling info is valid */
+#define WAVE_FRACTIONS  0x00080000      /* Fraction information is valid */
+/* Reserved bits */
+#define WAVE_ROM        0x40000000      /* For future use */
+#define WAVE_MULAW      0x20000000      /* For future use */
+/* Other bits must be zeroed */
+
+                int len;        /* Size of the wave data in bytes */
+                int loop_start, loop_end; /* Byte offsets from the beginning */
+
+/* 
+ * The base_freq and base_note fields are used when computing the
+ * playback speed for a note. The base_note defines the tone frequency
+ * which is heard if the sample is played using the base_freq as the
+ * playback speed.
+ *
+ * The low_note and high_note fields define the minimum and maximum note
+ * frequencies for which this sample is valid. It is possible to define
+ * more than one samples for an instrument number at the same time. The
+ * low_note and high_note fields are used to select the most suitable one.
+ *
+ * The fields base_note, high_note and low_note should contain
+ * the note frequency multiplied by 1000. For example value for the
+ * middle A is 440*1000.
+ */
+
+                unsigned int base_freq;
+                unsigned int base_note;
+                unsigned int high_note;
+                unsigned int low_note;
+                int panning;    /* -128=left, 127=right */
+                int detuning;
+
+/*      New fields introduced in version 1.99.5 */
+
+       /* Envelope. Enabled by mode bit WAVE_ENVELOPES  */
+                unsigned char   env_rate[ 6 ];   /* GUS HW ramping rate */
+                unsigned char   env_offset[ 6 ]; /* 255 == 100% */
+
+        /* 
+         * The tremolo, vibrato and scale info are not supported yet.
+         * Enable by setting the mode bits WAVE_TREMOLO, WAVE_VIBRATO or
+         * WAVE_SCALE
+         */
+
+                unsigned char   tremolo_sweep;
+                unsigned char   tremolo_rate;
+                unsigned char   tremolo_depth;
+        
+                unsigned char   vibrato_sweep;
+                unsigned char   vibrato_rate;
+                unsigned char   vibrato_depth;
+
+                int             scale_frequency;
+                unsigned int    scale_factor;           /* from 0 to 2048 or 0 to 2 */
+        
+                int             volume;
+                int             fractions;
+                int             reserved1;
+                int             spare[2];
+                char data[1];   /* The waveform data starts here */
+        };
+
+struct sysex_info {
+                short key;              /* Use SYSEX_PATCH or MAUI_PATCH here */
+#define SYSEX_PATCH     _PATCHKEY(0x05)
+#define MAUI_PATCH      _PATCHKEY(0x06)
+                short device_no;        /* Synthesizer number */
+                int len;        /* Size of the sysex data in bytes */
+                unsigned char data[1];  /* Sysex data starts here */
+        };
+
+/*
+ * /dev/sequencer input events.
+ *
+ * The data written to the /dev/sequencer is a stream of events. Events
+ * are records of 4 or 8 bytes. The first byte defines the size. 
+ * Any number of events can be written with a write call. There
+ * is a set of macros for sending these events. Use these macros if you
+ * want to maximize portability of your program.
+ *
+ * Events SEQ_WAIT, SEQ_MIDIPUTC and SEQ_ECHO. Are also input events.
+ * (All input events are currently 4 bytes long. Be prepared to support
+ * 8 byte events also. If you receive any event having first byte >= 128,
+ * it's a 8 byte event.
+ *
+ * The events are documented at the end of this file.
+ *
+ * Normal events (4 bytes)
+ * There is also a 8 byte version of most of the 4 byte events. The
+ * 8 byte one is recommended.
+ */
+#define SEQ_NOTEOFF             0
+#define SEQ_FMNOTEOFF           SEQ_NOTEOFF     /* Just old name */
+#define SEQ_NOTEON              1
+#define SEQ_FMNOTEON            SEQ_NOTEON
+#define SEQ_WAIT                TMR_WAIT_ABS
+#define SEQ_PGMCHANGE           3
+#define SEQ_FMPGMCHANGE         SEQ_PGMCHANGE
+#define SEQ_SYNCTIMER           TMR_START
+#define SEQ_MIDIPUTC            5
+#define SEQ_DRUMON              6       /*** OBSOLETE ***/
+#define SEQ_DRUMOFF             7       /*** OBSOLETE ***/
+#define SEQ_ECHO                TMR_ECHO        /* For synching programs with output */
+#define SEQ_AFTERTOUCH          9
+#define SEQ_CONTROLLER          10
+
+/*******************************************
+ *      Midi controller numbers
+ *******************************************
+ * Controllers 0 to 31 (0x00 to 0x1f) and
+ * 32 to 63 (0x20 to 0x3f) are continuous
+ * controllers.
+ * In the MIDI 1.0 these controllers are sent using
+ * two messages. Controller numbers 0 to 31 are used
+ * to send the MSB and the controller numbers 32 to 63
+ * are for the LSB. Note that just 7 bits are used in MIDI bytes.
+ */
+
+#define    CTL_BANK_SELECT              0x00
+#define    CTL_MODWHEEL                 0x01
+#define    CTL_BREATH                   0x02
+/*              undefined               0x03 */
+#define    CTL_FOOT                     0x04
+#define    CTL_PORTAMENTO_TIME          0x05
+#define    CTL_DATA_ENTRY               0x06
+#define    CTL_MAIN_VOLUME              0x07
+#define    CTL_BALANCE                  0x08
+/*              undefined               0x09 */
+#define    CTL_PAN                      0x0a
+#define    CTL_EXPRESSION               0x0b
+/*              undefined               0x0c */
+/*              undefined               0x0d */
+/*              undefined               0x0e */
+/*              undefined               0x0f */
+#define    CTL_GENERAL_PURPOSE1 0x10
+#define    CTL_GENERAL_PURPOSE2 0x11
+#define    CTL_GENERAL_PURPOSE3 0x12
+#define    CTL_GENERAL_PURPOSE4 0x13
+/*              undefined               0x14 - 0x1f */
+
+/*              undefined               0x20 */
+/* The controller numbers 0x21 to 0x3f are reserved for the */
+/* least significant bytes of the controllers 0x00 to 0x1f. */
+/* These controllers are not recognised by the driver. */
+
+/* Controllers 64 to 69 (0x40 to 0x45) are on/off switches. */
+/* 0=OFF and 127=ON (intermediate values are possible) */
+#define    CTL_DAMPER_PEDAL             0x40
+#define    CTL_SUSTAIN                  0x40    /* Alias */
+#define    CTL_HOLD                     0x40    /* Alias */
+#define    CTL_PORTAMENTO               0x41
+#define    CTL_SOSTENUTO                0x42
+#define    CTL_SOFT_PEDAL               0x43
+/*              undefined               0x44 */
+#define    CTL_HOLD2                    0x45
+/*              undefined               0x46 - 0x4f */
+
+#define    CTL_GENERAL_PURPOSE5 0x50
+#define    CTL_GENERAL_PURPOSE6 0x51
+#define    CTL_GENERAL_PURPOSE7 0x52
+#define    CTL_GENERAL_PURPOSE8 0x53
+/*              undefined               0x54 - 0x5a */
+#define    CTL_EXT_EFF_DEPTH            0x5b
+#define    CTL_TREMOLO_DEPTH            0x5c
+#define    CTL_CHORUS_DEPTH             0x5d
+#define    CTL_DETUNE_DEPTH             0x5e
+#define    CTL_CELESTE_DEPTH            0x5e    /* Alias for the above one */
+#define    CTL_PHASER_DEPTH             0x5f
+#define    CTL_DATA_INCREMENT           0x60
+#define    CTL_DATA_DECREMENT           0x61
+#define    CTL_NONREG_PARM_NUM_LSB      0x62
+#define    CTL_NONREG_PARM_NUM_MSB      0x63
+#define    CTL_REGIST_PARM_NUM_LSB      0x64
+#define    CTL_REGIST_PARM_NUM_MSB      0x65
+/*              undefined               0x66 - 0x78 */
+/*              reserved                0x79 - 0x7f */
+
+/* Pseudo controllers (not midi compatible) */
+#define    CTRL_PITCH_BENDER            255
+#define    CTRL_PITCH_BENDER_RANGE      254
+#define    CTRL_EXPRESSION              253     /* Obsolete */
+#define    CTRL_MAIN_VOLUME             252     /* Obsolete */
+#define SEQ_BALANCE             11
+#define SEQ_VOLMODE             12
+
+/*
+ * Volume mode decides how volumes are used
+ */
+
+#define VOL_METHOD_ADAGIO       1
+#define VOL_METHOD_LINEAR       2
+
+/*
+ * Note! SEQ_WAIT, SEQ_MIDIPUTC and SEQ_ECHO are used also as
+ *       input events.
+ */
+
+/*
+ * Event codes 0xf0 to 0xfc are reserved for future extensions.
+ */
+
+#define SEQ_FULLSIZE            0xfd    /* Long events */
+/*
+ *      SEQ_FULLSIZE events are used for loading patches/samples to the
+ *      synthesizer devices. These events are passed directly to the driver
+ *      of the associated synthesizer device. There is no limit to the size
+ *      of the extended events. These events are not queued but executed
+ *      immediately when the write() is called (execution can take several
+ *      seconds of time). 
+ *
+ *      When a SEQ_FULLSIZE message is written to the device, it must
+ *      be written using exactly one write() call. Other events cannot
+ *      be mixed to the same write.
+ *      
+ *      For FM synths (YM3812/OPL3) use struct sbi_instrument and write it to the 
+ *      /dev/sequencer. Don't write other data together with the instrument structure
+ *      Set the key field of the structure to FM_PATCH. The device field is used to
+ *      route the patch to the corresponding device.
+ *
+ *      For wave table use struct patch_info. Initialize the key field
+ *      to WAVE_PATCH.
+ */
+#define SEQ_PRIVATE             0xfe    /* Low level HW dependent events (8 bytes) */
+#define SEQ_EXTENDED            0xff    /* Extended events (8 bytes) OBSOLETE */
+
+/*
+ * Record for FM patches
+ */
+
+typedef unsigned char sbi_instr_data[32];
+
+struct sbi_instrument {
+                unsigned short  key;    /* FM_PATCH or OPL3_PATCH */
+#define FM_PATCH        _PATCHKEY(0x01)
+#define OPL3_PATCH      _PATCHKEY(0x03)
+                short           device;         /*      Synth# (0-4)    */
+                int             channel;        /*      Program# to be initialized      */
+                sbi_instr_data  operators;      /*      Register settings for operator cells (.SBI format)      */
+        };
+
+struct synth_info {     /* Read only */
+                char    name[30];
+                int     device;         /* 0-N. INITIALIZE BEFORE CALLING */
+                int     synth_type;
+#define SYNTH_TYPE_FM                   0
+#define SYNTH_TYPE_SAMPLE               1
+#define SYNTH_TYPE_MIDI                 2       /* Midi interface */
+
+                int     synth_subtype;
+#define FM_TYPE_ADLIB                   0x00
+#define FM_TYPE_OPL3                    0x01
+#define MIDI_TYPE_MPU401                0x401
+
+#define SAMPLE_TYPE_BASIC               0x10
+#define SAMPLE_TYPE_GUS                 SAMPLE_TYPE_BASIC
+#define SAMPLE_TYPE_WAVEFRONT           0x11
+
+                int     perc_mode;      /* No longer supported */
+                int     nr_voices;
+                int     nr_drums;       /* Obsolete field */
+                int     instr_bank_size;
+                unsigned int    capabilities;   
+#define SYNTH_CAP_PERCMODE              0x00000001 /* No longer used */
+#define SYNTH_CAP_OPL3                  0x00000002 /* Set if OPL3 supported */
+#define SYNTH_CAP_INPUT                 0x00000004 /* Input (MIDI) device */
+                int     dummies[19];    /* Reserve space */
+        };
+
+struct sound_timer_info {
+                char name[32];
+                int caps;
+        };
+
+#define MIDI_CAP_MPU401         1               /* MPU-401 intelligent mode */
+
+struct midi_info {
+                char            name[30];
+                int             device;         /* 0-N. INITIALIZE BEFORE CALLING */
+                unsigned int    capabilities;   /* To be defined later */
+                int             dev_type;
+                int             dummies[18];    /* Reserve space */
+        };
+
+/********************************************
+ * ioctl commands for the /dev/midi##
+ */
+typedef struct {
+                unsigned char cmd;
+                char nr_args, nr_returns;
+                unsigned char data[30];
+        } mpu_command_rec;
+
+#define SNDCTL_MIDI_PRETIME             _SIOWR('m', 0, int)
+#define SNDCTL_MIDI_MPUMODE             _SIOWR('m', 1, int)
+#define SNDCTL_MIDI_MPUCMD              _SIOWR('m', 2, mpu_command_rec)
+
+/********************************************
+ * IOCTL commands for /dev/dsp and /dev/audio
+ */
+
+#define SNDCTL_DSP_RESET                _SIO  ('P', 0)
+#define SNDCTL_DSP_SYNC                 _SIO  ('P', 1)
+#define SNDCTL_DSP_SPEED                _SIOWR('P', 2, int)
+#define SNDCTL_DSP_STEREO               _SIOWR('P', 3, int)
+#define SNDCTL_DSP_GETBLKSIZE           _SIOWR('P', 4, int)
+#define SNDCTL_DSP_SAMPLESIZE           SNDCTL_DSP_SETFMT
+#define SNDCTL_DSP_CHANNELS             _SIOWR('P', 6, int)
+#define SOUND_PCM_WRITE_CHANNELS        SNDCTL_DSP_CHANNELS
+#define SOUND_PCM_WRITE_FILTER          _SIOWR('P', 7, int)
+#define SNDCTL_DSP_POST                 _SIO  ('P', 8)
+#define SNDCTL_DSP_SUBDIVIDE            _SIOWR('P', 9, int)
+#define SNDCTL_DSP_SETFRAGMENT          _SIOWR('P',10, int)
+
+/*      Audio data formats (Note! U8=8 and S16_LE=16 for compatibility) */
+#define SNDCTL_DSP_GETFMTS              _SIOR ('P',11, int) /* Returns a mask */
+#define SNDCTL_DSP_SETFMT               _SIOWR('P',5, int) /* Selects ONE fmt*/
+#       define AFMT_QUERY               0x00000000      /* Return current fmt */
+#       define AFMT_MU_LAW              0x00000001
+#       define AFMT_A_LAW               0x00000002
+#       define AFMT_IMA_ADPCM           0x00000004
+#       define AFMT_U8                  0x00000008
+#       define AFMT_S16_LE              0x00000010      /* Little endian signed 16*/
+#       define AFMT_S16_BE              0x00000020      /* Big endian signed 16 */
+#       define AFMT_S8                  0x00000040
+#       define AFMT_U16_LE              0x00000080      /* Little endian U16 */
+#       define AFMT_U16_BE              0x00000100      /* Big endian U16 */
+#       define AFMT_MPEG                0x00000200      /* MPEG (2) audio */
+#       define AFMT_AC3         0x00000400      /* Dolby Digital AC3 */
+
+/*
+ * Buffer status queries.
+ */
+typedef struct audio_buf_info {
+                        int fragments;  /* # of available fragments (partially usend ones not counted) */
+                        int fragstotal; /* Total # of fragments allocated */
+                        int fragsize;   /* Size of a fragment in bytes */
+
+                        int bytes;      /* Available space in bytes (includes partially used fragments) */
+                        /* Note! 'bytes' could be more than fragments*fragsize */
+                } audio_buf_info;
+
+#define SNDCTL_DSP_GETOSPACE            _SIOR ('P',12, audio_buf_info)
+#define SNDCTL_DSP_GETISPACE            _SIOR ('P',13, audio_buf_info)
+#define SNDCTL_DSP_NONBLOCK             _SIO  ('P',14)
+#define SNDCTL_DSP_GETCAPS              _SIOR ('P',15, int)
+#       define DSP_CAP_REVISION         0x000000ff      /* Bits for revision level (0 to 255) */
+#       define DSP_CAP_DUPLEX           0x00000100      /* Full duplex record/playback */
+#       define DSP_CAP_REALTIME         0x00000200      /* Real time capability */
+#       define DSP_CAP_BATCH            0x00000400      /* Device has some kind of */
+                                                        /* internal buffers which may */
+                                                        /* cause some delays and */
+                                                        /* decrease precision of timing */
+#       define DSP_CAP_COPROC           0x00000800      /* Has a coprocessor */
+                                                        /* Sometimes it's a DSP */
+                                                        /* but usually not */
+#       define DSP_CAP_TRIGGER          0x00001000      /* Supports SETTRIGGER */
+#       define DSP_CAP_MMAP             0x00002000      /* Supports mmap() */
+#       define DSP_CAP_MULTI            0x00004000      /* support multiple open */
+#       define DSP_CAP_BIND             0x00008000      /* channel binding to front/rear/cneter/lfe */
+
+
+#define SNDCTL_DSP_GETTRIGGER           _SIOR ('P',16, int)
+#define SNDCTL_DSP_SETTRIGGER           _SIOW ('P',16, int)
+#       define PCM_ENABLE_INPUT         0x00000001
+#       define PCM_ENABLE_OUTPUT                0x00000002
+
+typedef struct count_info {
+                int bytes;      /* Total # of bytes processed */
+                int blocks;     /* # of fragment transitions since last time */
+                int ptr;        /* Current DMA pointer value */
+        } count_info;
+
+#define SNDCTL_DSP_GETIPTR              _SIOR ('P',17, count_info)
+#define SNDCTL_DSP_GETOPTR              _SIOR ('P',18, count_info)
+
+typedef struct buffmem_desc {
+                unsigned *buffer;
+                int size;
+        } buffmem_desc;
+#define SNDCTL_DSP_MAPINBUF             _SIOR ('P', 19, buffmem_desc)
+#define SNDCTL_DSP_MAPOUTBUF            _SIOR ('P', 20, buffmem_desc)
+#define SNDCTL_DSP_SETSYNCRO            _SIO  ('P', 21)
+#define SNDCTL_DSP_SETDUPLEX            _SIO  ('P', 22)
+#define SNDCTL_DSP_GETODELAY            _SIOR ('P', 23, int)
+
+#define SNDCTL_DSP_GETCHANNELMASK               _SIOWR('P', 64, int)
+#define SNDCTL_DSP_BIND_CHANNEL         _SIOWR('P', 65, int)
+#       define DSP_BIND_QUERY           0x00000000
+#       define DSP_BIND_FRONT           0x00000001
+#       define DSP_BIND_SURR            0x00000002
+#       define DSP_BIND_CENTER_LFE      0x00000004
+#       define DSP_BIND_HANDSET         0x00000008
+#       define DSP_BIND_MIC             0x00000010
+#       define DSP_BIND_MODEM1          0x00000020
+#       define DSP_BIND_MODEM2          0x00000040
+#       define DSP_BIND_I2S             0x00000080
+#       define DSP_BIND_SPDIF           0x00000100
+
+#define SNDCTL_DSP_SETSPDIF             _SIOW ('P', 66, int)
+#define SNDCTL_DSP_GETSPDIF             _SIOR ('P', 67, int)
+#       define SPDIF_PRO        0x0001
+#       define SPDIF_N_AUD      0x0002
+#       define SPDIF_COPY       0x0004
+#       define SPDIF_PRE        0x0008
+#       define SPDIF_CC         0x07f0
+#       define SPDIF_L          0x0800
+#       define SPDIF_DRS        0x4000
+#       define SPDIF_V          0x8000
+
+/*
+ * Application's profile defines the way how playback underrun situations should be handled.
+ * 
+ *      APF_NORMAL (the default) and APF_NETWORK make the driver to cleanup the
+ *      playback buffer whenever an underrun occurs. This consumes some time
+ *      prevents looping the existing buffer.
+ *      APF_CPUINTENS is intended to be set by CPU intensive applications which
+ *      are likely to run out of time occasionally. In this mode the buffer cleanup is
+ *      disabled which saves CPU time but also let's the previous buffer content to
+ *      be played during the "pause" after the underrun.
+ */
+#define SNDCTL_DSP_PROFILE              _SIOW ('P', 23, int)
+#define   APF_NORMAL    0       /* Normal applications */
+#define   APF_NETWORK   1       /* Underruns probably caused by an "external" delay */
+#define   APF_CPUINTENS 2       /* Underruns probably caused by "overheating" the CPU */
+
+#define SOUND_PCM_READ_RATE             _SIOR ('P', 2, int)
+#define SOUND_PCM_READ_CHANNELS         _SIOR ('P', 6, int)
+#define SOUND_PCM_READ_BITS             _SIOR ('P', 5, int)
+#define SOUND_PCM_READ_FILTER           _SIOR ('P', 7, int)
+
+/* Some alias names */
+#define SOUND_PCM_WRITE_BITS            SNDCTL_DSP_SETFMT
+#define SOUND_PCM_WRITE_RATE            SNDCTL_DSP_SPEED
+#define SOUND_PCM_POST                  SNDCTL_DSP_POST
+#define SOUND_PCM_RESET                 SNDCTL_DSP_RESET
+#define SOUND_PCM_SYNC                  SNDCTL_DSP_SYNC
+#define SOUND_PCM_SUBDIVIDE             SNDCTL_DSP_SUBDIVIDE
+#define SOUND_PCM_SETFRAGMENT           SNDCTL_DSP_SETFRAGMENT
+#define SOUND_PCM_GETFMTS               SNDCTL_DSP_GETFMTS
+#define SOUND_PCM_SETFMT                SNDCTL_DSP_SETFMT
+#define SOUND_PCM_GETOSPACE             SNDCTL_DSP_GETOSPACE
+#define SOUND_PCM_GETISPACE             SNDCTL_DSP_GETISPACE
+#define SOUND_PCM_NONBLOCK              SNDCTL_DSP_NONBLOCK
+#define SOUND_PCM_GETCAPS               SNDCTL_DSP_GETCAPS
+#define SOUND_PCM_GETTRIGGER            SNDCTL_DSP_GETTRIGGER
+#define SOUND_PCM_SETTRIGGER            SNDCTL_DSP_SETTRIGGER
+#define SOUND_PCM_SETSYNCRO             SNDCTL_DSP_SETSYNCRO
+#define SOUND_PCM_GETIPTR               SNDCTL_DSP_GETIPTR
+#define SOUND_PCM_GETOPTR               SNDCTL_DSP_GETOPTR
+#define SOUND_PCM_MAPINBUF              SNDCTL_DSP_MAPINBUF
+#define SOUND_PCM_MAPOUTBUF             SNDCTL_DSP_MAPOUTBUF
+
+/*
+ * ioctl calls to be used in communication with coprocessors and
+ * DSP chips.
+ */
+
+typedef struct copr_buffer {
+                int command;    /* Set to 0 if not used */
+                int flags;
+#define CPF_NONE                0x0000
+#define CPF_FIRST               0x0001  /* First block */
+#define CPF_LAST                0x0002  /* Last block */
+                int len;
+                int offs;       /* If required by the device (0 if not used) */
+
+                unsigned char data[4000]; /* NOTE! 4000 is not 4k */
+        } copr_buffer;
+
+typedef struct copr_debug_buf {
+                int command;    /* Used internally. Set to 0 */
+                int parm1;
+                int parm2;
+                int flags;      
+                int len;        /* Length of data in bytes */
+        } copr_debug_buf;
+
+typedef struct copr_msg {
+                int len;
+                unsigned char data[4000];
+        } copr_msg;
+
+#define SNDCTL_COPR_RESET             _SIO  ('C',  0)
+#define SNDCTL_COPR_LOAD              _SIOWR('C',  1, copr_buffer)
+#define SNDCTL_COPR_RDATA             _SIOWR('C',  2, copr_debug_buf)
+#define SNDCTL_COPR_RCODE             _SIOWR('C',  3, copr_debug_buf)
+#define SNDCTL_COPR_WDATA             _SIOW ('C',  4, copr_debug_buf)
+#define SNDCTL_COPR_WCODE             _SIOW ('C',  5, copr_debug_buf)
+#define SNDCTL_COPR_RUN               _SIOWR('C',  6, copr_debug_buf)
+#define SNDCTL_COPR_HALT              _SIOWR('C',  7, copr_debug_buf)
+#define SNDCTL_COPR_SENDMSG           _SIOWR('C',  8, copr_msg)
+#define SNDCTL_COPR_RCVMSG            _SIOR ('C',  9, copr_msg)
+
+/*********************************************
+ * IOCTL commands for /dev/mixer
+ */
+        
+/* 
+ * Mixer devices
+ *
+ * There can be up to 20 different analog mixer channels. The
+ * SOUND_MIXER_NRDEVICES gives the currently supported maximum. 
+ * The SOUND_MIXER_READ_DEVMASK returns a bitmask which tells
+ * the devices supported by the particular mixer.
+ */
+
+#define SOUND_MIXER_NRDEVICES   25
+#define SOUND_MIXER_VOLUME      0
+#define SOUND_MIXER_BASS        1
+#define SOUND_MIXER_TREBLE      2
+#define SOUND_MIXER_SYNTH       3
+#define SOUND_MIXER_PCM         4
+#define SOUND_MIXER_SPEAKER     5
+#define SOUND_MIXER_LINE        6
+#define SOUND_MIXER_MIC         7
+#define SOUND_MIXER_CD          8
+#define SOUND_MIXER_IMIX        9       /*  Recording monitor  */
+#define SOUND_MIXER_ALTPCM      10
+#define SOUND_MIXER_RECLEV      11      /* Recording level */
+#define SOUND_MIXER_IGAIN       12      /* Input gain */
+#define SOUND_MIXER_OGAIN       13      /* Output gain */
+/* 
+ * The AD1848 codec and compatibles have three line level inputs
+ * (line, aux1 and aux2). Since each card manufacturer have assigned
+ * different meanings to these inputs, it's inpractical to assign
+ * specific meanings (line, cd, synth etc.) to them.
+ */
+#define SOUND_MIXER_LINE1       14      /* Input source 1  (aux1) */
+#define SOUND_MIXER_LINE2       15      /* Input source 2  (aux2) */
+#define SOUND_MIXER_LINE3       16      /* Input source 3  (line) */
+#define SOUND_MIXER_DIGITAL1    17      /* Digital (input) 1 */
+#define SOUND_MIXER_DIGITAL2    18      /* Digital (input) 2 */
+#define SOUND_MIXER_DIGITAL3    19      /* Digital (input) 3 */
+#define SOUND_MIXER_PHONEIN     20      /* Phone input */
+#define SOUND_MIXER_PHONEOUT    21      /* Phone output */
+#define SOUND_MIXER_VIDEO       22      /* Video/TV (audio) in */
+#define SOUND_MIXER_RADIO       23      /* Radio in */
+#define SOUND_MIXER_MONITOR     24      /* Monitor (usually mic) volume */
+
+/* Some on/off settings (SOUND_SPECIAL_MIN - SOUND_SPECIAL_MAX) */
+/* Not counted to SOUND_MIXER_NRDEVICES, but use the same number space */
+#define SOUND_ONOFF_MIN         28
+#define SOUND_ONOFF_MAX         30
+
+/* Note!        Number 31 cannot be used since the sign bit is reserved */
+#define SOUND_MIXER_NONE        31
+
+/*
+ * The following unsupported macros are no longer functional.
+ * Use SOUND_MIXER_PRIVATE# macros in future.
+ */
+#define SOUND_MIXER_ENHANCE     SOUND_MIXER_NONE
+#define SOUND_MIXER_MUTE        SOUND_MIXER_NONE
+#define SOUND_MIXER_LOUD        SOUND_MIXER_NONE
+
+
+#define SOUND_DEVICE_LABELS     {"Vol  ", "Bass ", "Trebl", "Synth", "Pcm  ", "Spkr ", "Line ", \
+                                 "Mic  ", "CD   ", "Mix  ", "Pcm2 ", "Rec  ", "IGain", "OGain", \
+                                 "Line1", "Line2", "Line3", "Digital1", "Digital2", "Digital3", \
+                                 "PhoneIn", "PhoneOut", "Video", "Radio", "Monitor"}
+
+#define SOUND_DEVICE_NAMES      {"vol", "bass", "treble", "synth", "pcm", "speaker", "line", \
+                                 "mic", "cd", "mix", "pcm2", "rec", "igain", "ogain", \
+                                 "line1", "line2", "line3", "dig1", "dig2", "dig3", \
+                                 "phin", "phout", "video", "radio", "monitor"}
+
+/*      Device bitmask identifiers      */
+
+#define SOUND_MIXER_RECSRC      0xff    /* Arg contains a bit for each recording source */
+#define SOUND_MIXER_DEVMASK     0xfe    /* Arg contains a bit for each supported device */
+#define SOUND_MIXER_RECMASK     0xfd    /* Arg contains a bit for each supported recording source */
+#define SOUND_MIXER_CAPS        0xfc
+#       define SOUND_CAP_EXCL_INPUT     0x00000001      /* Only one recording source at a time */
+#define SOUND_MIXER_STEREODEVS  0xfb    /* Mixer channels supporting stereo */
+#define SOUND_MIXER_OUTSRC      0xfa    /* Arg contains a bit for each input source to output */
+#define SOUND_MIXER_OUTMASK     0xf9    /* Arg contains a bit for each supported input source to output */
+
+/*      Device mask bits        */
+
+#define SOUND_MASK_VOLUME       (1 << SOUND_MIXER_VOLUME)
+#define SOUND_MASK_BASS         (1 << SOUND_MIXER_BASS)
+#define SOUND_MASK_TREBLE       (1 << SOUND_MIXER_TREBLE)
+#define SOUND_MASK_SYNTH        (1 << SOUND_MIXER_SYNTH)
+#define SOUND_MASK_PCM          (1 << SOUND_MIXER_PCM)
+#define SOUND_MASK_SPEAKER      (1 << SOUND_MIXER_SPEAKER)
+#define SOUND_MASK_LINE         (1 << SOUND_MIXER_LINE)
+#define SOUND_MASK_MIC          (1 << SOUND_MIXER_MIC)
+#define SOUND_MASK_CD           (1 << SOUND_MIXER_CD)
+#define SOUND_MASK_IMIX         (1 << SOUND_MIXER_IMIX)
+#define SOUND_MASK_ALTPCM       (1 << SOUND_MIXER_ALTPCM)
+#define SOUND_MASK_RECLEV       (1 << SOUND_MIXER_RECLEV)
+#define SOUND_MASK_IGAIN        (1 << SOUND_MIXER_IGAIN)
+#define SOUND_MASK_OGAIN        (1 << SOUND_MIXER_OGAIN)
+#define SOUND_MASK_LINE1        (1 << SOUND_MIXER_LINE1)
+#define SOUND_MASK_LINE2        (1 << SOUND_MIXER_LINE2)
+#define SOUND_MASK_LINE3        (1 << SOUND_MIXER_LINE3)
+#define SOUND_MASK_DIGITAL1     (1 << SOUND_MIXER_DIGITAL1)
+#define SOUND_MASK_DIGITAL2     (1 << SOUND_MIXER_DIGITAL2)
+#define SOUND_MASK_DIGITAL3     (1 << SOUND_MIXER_DIGITAL3)
+#define SOUND_MASK_PHONEIN      (1 << SOUND_MIXER_PHONEIN)
+#define SOUND_MASK_PHONEOUT     (1 << SOUND_MIXER_PHONEOUT)
+#define SOUND_MASK_RADIO        (1 << SOUND_MIXER_RADIO)
+#define SOUND_MASK_VIDEO        (1 << SOUND_MIXER_VIDEO)
+#define SOUND_MASK_MONITOR      (1 << SOUND_MIXER_MONITOR)
+
+/* Obsolete macros */
+#define SOUND_MASK_MUTE         (1 << SOUND_MIXER_MUTE)
+#define SOUND_MASK_ENHANCE      (1 << SOUND_MIXER_ENHANCE)
+#define SOUND_MASK_LOUD         (1 << SOUND_MIXER_LOUD)
+
+#define MIXER_READ(dev)         _SIOR('M', dev, int)
+#define SOUND_MIXER_READ_VOLUME         MIXER_READ(SOUND_MIXER_VOLUME)
+#define SOUND_MIXER_READ_BASS           MIXER_READ(SOUND_MIXER_BASS)
+#define SOUND_MIXER_READ_TREBLE         MIXER_READ(SOUND_MIXER_TREBLE)
+#define SOUND_MIXER_READ_SYNTH          MIXER_READ(SOUND_MIXER_SYNTH)
+#define SOUND_MIXER_READ_PCM            MIXER_READ(SOUND_MIXER_PCM)
+#define SOUND_MIXER_READ_SPEAKER        MIXER_READ(SOUND_MIXER_SPEAKER)
+#define SOUND_MIXER_READ_LINE           MIXER_READ(SOUND_MIXER_LINE)
+#define SOUND_MIXER_READ_MIC            MIXER_READ(SOUND_MIXER_MIC)
+#define SOUND_MIXER_READ_CD             MIXER_READ(SOUND_MIXER_CD)
+#define SOUND_MIXER_READ_IMIX           MIXER_READ(SOUND_MIXER_IMIX)
+#define SOUND_MIXER_READ_ALTPCM         MIXER_READ(SOUND_MIXER_ALTPCM)
+#define SOUND_MIXER_READ_RECLEV         MIXER_READ(SOUND_MIXER_RECLEV)
+#define SOUND_MIXER_READ_IGAIN          MIXER_READ(SOUND_MIXER_IGAIN)
+#define SOUND_MIXER_READ_OGAIN          MIXER_READ(SOUND_MIXER_OGAIN)
+#define SOUND_MIXER_READ_LINE1          MIXER_READ(SOUND_MIXER_LINE1)
+#define SOUND_MIXER_READ_LINE2          MIXER_READ(SOUND_MIXER_LINE2)
+#define SOUND_MIXER_READ_LINE3          MIXER_READ(SOUND_MIXER_LINE3)
+
+/* Obsolete macros */
+#define SOUND_MIXER_READ_MUTE           MIXER_READ(SOUND_MIXER_MUTE)
+#define SOUND_MIXER_READ_ENHANCE        MIXER_READ(SOUND_MIXER_ENHANCE)
+#define SOUND_MIXER_READ_LOUD           MIXER_READ(SOUND_MIXER_LOUD)
+
+#define SOUND_MIXER_READ_RECSRC         MIXER_READ(SOUND_MIXER_RECSRC)
+#define SOUND_MIXER_READ_DEVMASK        MIXER_READ(SOUND_MIXER_DEVMASK)
+#define SOUND_MIXER_READ_RECMASK        MIXER_READ(SOUND_MIXER_RECMASK)
+#define SOUND_MIXER_READ_STEREODEVS     MIXER_READ(SOUND_MIXER_STEREODEVS)
+#define SOUND_MIXER_READ_CAPS           MIXER_READ(SOUND_MIXER_CAPS)
+
+#define MIXER_WRITE(dev)                _SIOWR('M', dev, int)
+#define SOUND_MIXER_WRITE_VOLUME        MIXER_WRITE(SOUND_MIXER_VOLUME)
+#define SOUND_MIXER_WRITE_BASS          MIXER_WRITE(SOUND_MIXER_BASS)
+#define SOUND_MIXER_WRITE_TREBLE        MIXER_WRITE(SOUND_MIXER_TREBLE)
+#define SOUND_MIXER_WRITE_SYNTH         MIXER_WRITE(SOUND_MIXER_SYNTH)
+#define SOUND_MIXER_WRITE_PCM           MIXER_WRITE(SOUND_MIXER_PCM)
+#define SOUND_MIXER_WRITE_SPEAKER       MIXER_WRITE(SOUND_MIXER_SPEAKER)
+#define SOUND_MIXER_WRITE_LINE          MIXER_WRITE(SOUND_MIXER_LINE)
+#define SOUND_MIXER_WRITE_MIC           MIXER_WRITE(SOUND_MIXER_MIC)
+#define SOUND_MIXER_WRITE_CD            MIXER_WRITE(SOUND_MIXER_CD)
+#define SOUND_MIXER_WRITE_IMIX          MIXER_WRITE(SOUND_MIXER_IMIX)
+#define SOUND_MIXER_WRITE_ALTPCM        MIXER_WRITE(SOUND_MIXER_ALTPCM)
+#define SOUND_MIXER_WRITE_RECLEV        MIXER_WRITE(SOUND_MIXER_RECLEV)
+#define SOUND_MIXER_WRITE_IGAIN         MIXER_WRITE(SOUND_MIXER_IGAIN)
+#define SOUND_MIXER_WRITE_OGAIN         MIXER_WRITE(SOUND_MIXER_OGAIN)
+#define SOUND_MIXER_WRITE_LINE1         MIXER_WRITE(SOUND_MIXER_LINE1)
+#define SOUND_MIXER_WRITE_LINE2         MIXER_WRITE(SOUND_MIXER_LINE2)
+#define SOUND_MIXER_WRITE_LINE3         MIXER_WRITE(SOUND_MIXER_LINE3)
+
+/* Obsolete macros */
+#define SOUND_MIXER_WRITE_MUTE          MIXER_WRITE(SOUND_MIXER_MUTE)
+#define SOUND_MIXER_WRITE_ENHANCE       MIXER_WRITE(SOUND_MIXER_ENHANCE)
+#define SOUND_MIXER_WRITE_LOUD          MIXER_WRITE(SOUND_MIXER_LOUD)
+
+#define SOUND_MIXER_WRITE_RECSRC        MIXER_WRITE(SOUND_MIXER_RECSRC)
+
+typedef struct mixer_info
+{
+  char id[16];
+  char name[32];
+  int  modify_counter;
+  int fillers[10];
+} mixer_info;
+
+typedef struct _old_mixer_info /* Obsolete */
+{
+  char id[16];
+  char name[32];
+} _old_mixer_info;
+
+#define SOUND_MIXER_INFO                _SIOR ('M', 101, mixer_info)
+#define SOUND_OLD_MIXER_INFO            _SIOR ('M', 101, _old_mixer_info)
+
+/*
+ * A mechanism for accessing "proprietary" mixer features. This method
+ * permits passing 128 bytes of arbitrary data between a mixer application
+ * and the mixer driver. Interpretation of the record is defined by
+ * the particular mixer driver.
+ */
+typedef unsigned char mixer_record[128];
+
+#define SOUND_MIXER_ACCESS              _SIOWR('M', 102, mixer_record)
+
+/*
+ * Two ioctls for special souncard function
+ */
+#define SOUND_MIXER_AGC  _SIOWR('M', 103, int)
+#define SOUND_MIXER_3DSE  _SIOWR('M', 104, int)
+
+/*
+ * The SOUND_MIXER_PRIVATE# commands can be redefined by low level drivers.
+ * These features can be used when accessing device specific features.
+ */
+#define SOUND_MIXER_PRIVATE1            _SIOWR('M', 111, int)
+#define SOUND_MIXER_PRIVATE2            _SIOWR('M', 112, int)
+#define SOUND_MIXER_PRIVATE3            _SIOWR('M', 113, int)
+#define SOUND_MIXER_PRIVATE4            _SIOWR('M', 114, int)
+#define SOUND_MIXER_PRIVATE5            _SIOWR('M', 115, int)
+
+/*
+ * SOUND_MIXER_GETLEVELS and SOUND_MIXER_SETLEVELS calls can be used
+ * for querying current mixer settings from the driver and for loading
+ * default volume settings _prior_ activating the mixer (loading
+ * doesn't affect current state of the mixer hardware). These calls
+ * are for internal use only.
+ */
+
+typedef struct mixer_vol_table {
+  int num;      /* Index to volume table */
+  char name[32];
+  int levels[32];
+} mixer_vol_table;
+
+#define SOUND_MIXER_GETLEVELS           _SIOWR('M', 116, mixer_vol_table)
+#define SOUND_MIXER_SETLEVELS           _SIOWR('M', 117, mixer_vol_table)
+
+/* 
+ * An ioctl for identifying the driver version. It will return value
+ * of the SOUND_VERSION macro used when compiling the driver.
+ * This call was introduced in OSS version 3.6 and it will not work
+ * with earlier versions (returns EINVAL).
+ */
+#define OSS_GETVERSION                  _SIOR ('M', 118, int)
+
+/*
+ * Level 2 event types for /dev/sequencer
+ */
+
+/*
+ * The 4 most significant bits of byte 0 specify the class of
+ * the event: 
+ *
+ *      0x8X = system level events,
+ *      0x9X = device/port specific events, event[1] = device/port,
+ *              The last 4 bits give the subtype:
+ *                      0x02    = Channel event (event[3] = chn).
+ *                      0x01    = note event (event[4] = note).
+ *                      (0x01 is not used alone but always with bit 0x02).
+ *             event[2] = MIDI message code (0x80=note off etc.)
+ *
+ */
+
+#define EV_SEQ_LOCAL            0x80
+#define EV_TIMING               0x81
+#define EV_CHN_COMMON           0x92
+#define EV_CHN_VOICE            0x93
+#define EV_SYSEX                0x94
+/*
+ * Event types 200 to 220 are reserved for application use.
+ * These numbers will not be used by the driver.
+ */
+
+/*
+ * Events for event type EV_CHN_VOICE
+ */
+
+#define MIDI_NOTEOFF            0x80
+#define MIDI_NOTEON             0x90
+#define MIDI_KEY_PRESSURE       0xA0
+
+/*
+ * Events for event type EV_CHN_COMMON
+ */
+
+#define MIDI_CTL_CHANGE         0xB0
+#define MIDI_PGM_CHANGE         0xC0
+#define MIDI_CHN_PRESSURE       0xD0
+#define MIDI_PITCH_BEND         0xE0
+
+#define MIDI_SYSTEM_PREFIX      0xF0
+
+/*
+ * Timer event types
+ */
+#define TMR_WAIT_REL            1       /* Time relative to the prev time */
+#define TMR_WAIT_ABS            2       /* Absolute time since TMR_START */
+#define TMR_STOP                3
+#define TMR_START               4
+#define TMR_CONTINUE            5
+#define TMR_TEMPO               6
+#define TMR_ECHO                8
+#define TMR_CLOCK               9       /* MIDI clock */
+#define TMR_SPP                 10      /* Song position pointer */
+#define TMR_TIMESIG             11      /* Time signature */
+
+/*
+ *      Local event types
+ */
+#define LOCL_STARTAUDIO         1
+
+#if (!defined(__KERNEL__) && !defined(KERNEL) && !defined(INKERNEL) && !defined(_KERNEL)) || defined(USE_SEQ_MACROS) 
+/*
+ *      Some convenience macros to simplify programming of the
+ *      /dev/sequencer interface
+ *
+ *      These macros define the API which should be used when possible.
+ */
+#define SEQ_DECLAREBUF()                SEQ_USE_EXTBUF()
+
+void seqbuf_dump(void); /* This function must be provided by programs */
+
+extern int OSS_init(int seqfd, int buflen);
+extern void OSS_seqbuf_dump(int fd, unsigned char *buf, int buflen);
+extern void OSS_seq_advbuf(int len, int fd, unsigned char *buf, int buflen);
+extern void OSS_seq_needbuf(int len, int fd, unsigned char *buf, int buflen);
+extern void OSS_patch_caching(int dev, int chn, int patch,
+                              int fd, unsigned char *buf, int buflen);
+extern void OSS_drum_caching(int dev, int chn, int patch,
+                              int fd, unsigned char *buf, int buflen);
+extern void OSS_write_patch(int fd, unsigned char *buf, int len);
+extern int OSS_write_patch2(int fd, unsigned char *buf, int len);
+
+#define SEQ_PM_DEFINES int __foo_bar___
+#ifdef OSSLIB
+#  define SEQ_USE_EXTBUF() \
+                extern unsigned char *_seqbuf; \
+                extern int _seqbuflen;extern int _seqbufptr
+#  define SEQ_DEFINEBUF(len) SEQ_USE_EXTBUF();static int _requested_seqbuflen=len
+#  define _SEQ_ADVBUF(len) OSS_seq_advbuf(len, seqfd, _seqbuf, _seqbuflen)
+#  define _SEQ_NEEDBUF(len) OSS_seq_needbuf(len, seqfd, _seqbuf, _seqbuflen)
+#  define SEQ_DUMPBUF() OSS_seqbuf_dump(seqfd, _seqbuf, _seqbuflen)
+
+#  define SEQ_LOAD_GMINSTR(dev, instr) \
+                OSS_patch_caching(dev, -1, instr, seqfd, _seqbuf, _seqbuflen)
+#  define SEQ_LOAD_GMDRUM(dev, drum) \
+                OSS_drum_caching(dev, -1, drum, seqfd, _seqbuf, _seqbuflen)
+#else /* !OSSLIB */
+
+#  define SEQ_LOAD_GMINSTR(dev, instr)
+#  define SEQ_LOAD_GMDRUM(dev, drum)
+
+#  define SEQ_USE_EXTBUF() \
+                extern unsigned char _seqbuf[]; \
+                extern int _seqbuflen;extern int _seqbufptr
+
+#ifndef USE_SIMPLE_MACROS
+/* Sample seqbuf_dump() implementation:
+ *
+ *      SEQ_DEFINEBUF (2048);   -- Defines a buffer for 2048 bytes
+ *
+ *      int seqfd;              -- The file descriptor for /dev/sequencer.
+ *
+ *      void
+ *      seqbuf_dump ()
+ *      {
+ *        if (_seqbufptr)
+ *          if (write (seqfd, _seqbuf, _seqbufptr) == -1)
+ *            {
+ *              perror ("write /dev/sequencer");
+ *              exit (-1);
+ *            }
+ *        _seqbufptr = 0;
+ *      }
+ */
+
+#define SEQ_DEFINEBUF(len)              unsigned char _seqbuf[len]; int _seqbuflen = len;int _seqbufptr = 0
+#define _SEQ_NEEDBUF(len)               if ((_seqbufptr+(len)) > _seqbuflen) seqbuf_dump()
+#define _SEQ_ADVBUF(len)                _seqbufptr += len
+#define SEQ_DUMPBUF                     seqbuf_dump
+#else
+/*
+ * This variation of the sequencer macros is used just to format one event
+ * using fixed buffer.
+ * 
+ * The program using the macro library must define the following macros before
+ * using this library.
+ *
+ * #define _seqbuf               name of the buffer (unsigned char[]) 
+ * #define _SEQ_ADVBUF(len)      If the applic needs to know the exact
+ *                               size of the event, this macro can be used.
+ *                               Otherwise this must be defined as empty.
+ * #define _seqbufptr            Define the name of index variable or 0 if
+ *                               not required. 
+ */
+#define _SEQ_NEEDBUF(len)       /* empty */
+#endif
+#endif /* !OSSLIB */
+
+#define SEQ_VOLUME_MODE(dev, mode)      {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr] = SEQ_EXTENDED;\
+                                        _seqbuf[_seqbufptr+1] = SEQ_VOLMODE;\
+                                        _seqbuf[_seqbufptr+2] = (dev);\
+                                        _seqbuf[_seqbufptr+3] = (mode);\
+                                        _seqbuf[_seqbufptr+4] = 0;\
+                                        _seqbuf[_seqbufptr+5] = 0;\
+                                        _seqbuf[_seqbufptr+6] = 0;\
+                                        _seqbuf[_seqbufptr+7] = 0;\
+                                        _SEQ_ADVBUF(8);}
+
+/*
+ * Midi voice messages
+ */
+
+#define _CHN_VOICE(dev, event, chn, note, parm) \
+                                        {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr] = EV_CHN_VOICE;\
+                                        _seqbuf[_seqbufptr+1] = (dev);\
+                                        _seqbuf[_seqbufptr+2] = (event);\
+                                        _seqbuf[_seqbufptr+3] = (chn);\
+                                        _seqbuf[_seqbufptr+4] = (note);\
+                                        _seqbuf[_seqbufptr+5] = (parm);\
+                                        _seqbuf[_seqbufptr+6] = (0);\
+                                        _seqbuf[_seqbufptr+7] = 0;\
+                                        _SEQ_ADVBUF(8);}
+
+#define SEQ_START_NOTE(dev, chn, note, vol) \
+                _CHN_VOICE(dev, MIDI_NOTEON, chn, note, vol)
+
+#define SEQ_STOP_NOTE(dev, chn, note, vol) \
+                _CHN_VOICE(dev, MIDI_NOTEOFF, chn, note, vol)
+
+#define SEQ_KEY_PRESSURE(dev, chn, note, pressure) \
+                _CHN_VOICE(dev, MIDI_KEY_PRESSURE, chn, note, pressure)
+
+/*
+ * Midi channel messages
+ */
+
+#define _CHN_COMMON(dev, event, chn, p1, p2, w14) \
+                                        {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr] = EV_CHN_COMMON;\
+                                        _seqbuf[_seqbufptr+1] = (dev);\
+                                        _seqbuf[_seqbufptr+2] = (event);\
+                                        _seqbuf[_seqbufptr+3] = (chn);\
+                                        _seqbuf[_seqbufptr+4] = (p1);\
+                                        _seqbuf[_seqbufptr+5] = (p2);\
+                                        *(short *)&_seqbuf[_seqbufptr+6] = (w14);\
+                                        _SEQ_ADVBUF(8);}
+/*
+ * SEQ_SYSEX permits sending of sysex messages. (It may look that it permits
+ * sending any MIDI bytes but it's absolutely not possible. Trying to do
+ * so _will_ cause problems with MPU401 intelligent mode).
+ *
+ * Sysex messages are sent in blocks of 1 to 6 bytes. Longer messages must be 
+ * sent by calling SEQ_SYSEX() several times (there must be no other events
+ * between them). First sysex fragment must have 0xf0 in the first byte
+ * and the last byte (buf[len-1] of the last fragment must be 0xf7. No byte
+ * between these sysex start and end markers cannot be larger than 0x7f. Also
+ * lengths of each fragments (except the last one) must be 6.
+ *
+ * Breaking the above rules may work with some MIDI ports but is likely to
+ * cause fatal problems with some other devices (such as MPU401).
+ */
+#define SEQ_SYSEX(dev, buf, len) \
+                                        {int ii, ll=(len); \
+                                         unsigned char *bufp=buf;\
+                                         if (ll>6)ll=6;\
+                                        _SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr] = EV_SYSEX;\
+                                        _seqbuf[_seqbufptr+1] = (dev);\
+                                        for(ii=0;ii<ll;ii++)\
+                                           _seqbuf[_seqbufptr+ii+2] = bufp[ii];\
+                                        for(ii=ll;ii<6;ii++)\
+                                           _seqbuf[_seqbufptr+ii+2] = 0xff;\
+                                        _SEQ_ADVBUF(8);}
+
+#define SEQ_CHN_PRESSURE(dev, chn, pressure) \
+                _CHN_COMMON(dev, MIDI_CHN_PRESSURE, chn, pressure, 0, 0)
+
+#define SEQ_SET_PATCH SEQ_PGM_CHANGE
+#ifdef OSSLIB
+#   define SEQ_PGM_CHANGE(dev, chn, patch) \
+                {OSS_patch_caching(dev, chn, patch, seqfd, _seqbuf, _seqbuflen); \
+                 _CHN_COMMON(dev, MIDI_PGM_CHANGE, chn, patch, 0, 0);}
+#else
+#   define SEQ_PGM_CHANGE(dev, chn, patch) \
+                _CHN_COMMON(dev, MIDI_PGM_CHANGE, chn, patch, 0, 0)
+#endif
+
+#define SEQ_CONTROL(dev, chn, controller, value) \
+                _CHN_COMMON(dev, MIDI_CTL_CHANGE, chn, controller, 0, value)
+
+#define SEQ_BENDER(dev, chn, value) \
+                _CHN_COMMON(dev, MIDI_PITCH_BEND, chn, 0, 0, value)
+
+
+#define SEQ_V2_X_CONTROL(dev, voice, controller, value) {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr] = SEQ_EXTENDED;\
+                                        _seqbuf[_seqbufptr+1] = SEQ_CONTROLLER;\
+                                        _seqbuf[_seqbufptr+2] = (dev);\
+                                        _seqbuf[_seqbufptr+3] = (voice);\
+                                        _seqbuf[_seqbufptr+4] = (controller);\
+                                        _seqbuf[_seqbufptr+5] = ((value)&0xff);\
+                                        _seqbuf[_seqbufptr+6] = ((value>>8)&0xff);\
+                                        _seqbuf[_seqbufptr+7] = 0;\
+                                        _SEQ_ADVBUF(8);}
+/*
+ * The following 5 macros are incorrectly implemented and obsolete.
+ * Use SEQ_BENDER and SEQ_CONTROL (with proper controller) instead.
+ */
+#define SEQ_PITCHBEND(dev, voice, value) SEQ_V2_X_CONTROL(dev, voice, CTRL_PITCH_BENDER, value)
+#define SEQ_BENDER_RANGE(dev, voice, value) SEQ_V2_X_CONTROL(dev, voice, CTRL_PITCH_BENDER_RANGE, value)
+#define SEQ_EXPRESSION(dev, voice, value) SEQ_CONTROL(dev, voice, CTL_EXPRESSION, value*128)
+#define SEQ_MAIN_VOLUME(dev, voice, value) SEQ_CONTROL(dev, voice, CTL_MAIN_VOLUME, (value*16383)/100)
+#define SEQ_PANNING(dev, voice, pos) SEQ_CONTROL(dev, voice, CTL_PAN, (pos+128) / 2)
+
+/*
+ * Timing and syncronization macros
+ */
+
+#define _TIMER_EVENT(ev, parm)          {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr+0] = EV_TIMING; \
+                                        _seqbuf[_seqbufptr+1] = (ev); \
+                                        _seqbuf[_seqbufptr+2] = 0;\
+                                        _seqbuf[_seqbufptr+3] = 0;\
+                                        *(unsigned int *)&_seqbuf[_seqbufptr+4] = (parm); \
+                                        _SEQ_ADVBUF(8);}
+
+#define SEQ_START_TIMER()               _TIMER_EVENT(TMR_START, 0)
+#define SEQ_STOP_TIMER()                _TIMER_EVENT(TMR_STOP, 0)
+#define SEQ_CONTINUE_TIMER()            _TIMER_EVENT(TMR_CONTINUE, 0)
+#define SEQ_WAIT_TIME(ticks)            _TIMER_EVENT(TMR_WAIT_ABS, ticks)
+#define SEQ_DELTA_TIME(ticks)           _TIMER_EVENT(TMR_WAIT_REL, ticks)
+#define SEQ_ECHO_BACK(key)              _TIMER_EVENT(TMR_ECHO, key)
+#define SEQ_SET_TEMPO(value)            _TIMER_EVENT(TMR_TEMPO, value)
+#define SEQ_SONGPOS(pos)                _TIMER_EVENT(TMR_SPP, pos)
+#define SEQ_TIME_SIGNATURE(sig)         _TIMER_EVENT(TMR_TIMESIG, sig)
+
+/*
+ * Local control events
+ */
+
+#define _LOCAL_EVENT(ev, parm)          {_SEQ_NEEDBUF(8);\
+                                        _seqbuf[_seqbufptr+0] = EV_SEQ_LOCAL; \
+                                        _seqbuf[_seqbufptr+1] = (ev); \
+                                        _seqbuf[_seqbufptr+2] = 0;\
+                                        _seqbuf[_seqbufptr+3] = 0;\
+                                        *(unsigned int *)&_seqbuf[_seqbufptr+4] = (parm); \
+                                        _SEQ_ADVBUF(8);}
+
+#define SEQ_PLAYAUDIO(devmask)          _LOCAL_EVENT(LOCL_STARTAUDIO, devmask)
+/*
+ * Events for the level 1 interface only 
+ */
+
+#define SEQ_MIDIOUT(device, byte)       {_SEQ_NEEDBUF(4);\
+                                        _seqbuf[_seqbufptr] = SEQ_MIDIPUTC;\
+                                        _seqbuf[_seqbufptr+1] = (byte);\
+                                        _seqbuf[_seqbufptr+2] = (device);\
+                                        _seqbuf[_seqbufptr+3] = 0;\
+                                        _SEQ_ADVBUF(4);}
+
+/*
+ * Patch loading.
+ */
+#ifdef OSSLIB
+#   define SEQ_WRPATCH(patchx, len) \
+                OSS_write_patch(seqfd, (char*)(patchx), len)
+#   define SEQ_WRPATCH2(patchx, len) \
+                OSS_write_patch2(seqfd, (char*)(patchx), len)
+#else
+#   define SEQ_WRPATCH(patchx, len) \
+                {if (_seqbufptr) SEQ_DUMPBUF();\
+                 if (write(seqfd, (char*)(patchx), len)==-1) \
+                    perror("Write patch: /dev/sequencer");}
+#   define SEQ_WRPATCH2(patchx, len) \
+                (SEQ_DUMPBUF(), write(seqfd, (char*)(patchx), len))
+#endif
+
+#endif
+#endif
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
new file mode 100644
index 000000000000..e895f3eaf53a
--- /dev/null
+++ b/include/linux/spinlock.h
@@ -0,0 +1,606 @@
+#ifndef __LINUX_SPINLOCK_H
+#define __LINUX_SPINLOCK_H
+
+/*
+ * include/linux/spinlock.h - generic locking declarations
+ */
+
+#include <linux/config.h>
+#include <linux/preempt.h>
+#include <linux/linkage.h>
+#include <linux/compiler.h>
+#include <linux/thread_info.h>
+#include <linux/kernel.h>
+#include <linux/stringify.h>
+
+#include <asm/processor.h>      /* for cpu relax */
+#include <asm/system.h>
+
+/*
+ * Must define these before including other files, inline functions need them
+ */
+#define LOCK_SECTION_NAME                       \
+        ".text.lock." __stringify(KBUILD_BASENAME)
+
+#define LOCK_SECTION_START(extra)               \
+        ".subsection 1\n\t"                     \
+        extra                                   \
+        ".ifndef " LOCK_SECTION_NAME "\n\t"     \
+        LOCK_SECTION_NAME ":\n\t"               \
+        ".endif\n"
+
+#define LOCK_SECTION_END                        \
+        ".previous\n\t"
+
+#define __lockfunc fastcall __attribute__((section(".spinlock.text")))
+
+/*
+ * If CONFIG_SMP is set, pull in the _raw_* definitions
+ */
+#ifdef CONFIG_SMP
+
+#define assert_spin_locked(x)   BUG_ON(!spin_is_locked(x))
+#include <asm/spinlock.h>
+
+int __lockfunc _spin_trylock(spinlock_t *lock);
+int __lockfunc _read_trylock(rwlock_t *lock);
+int __lockfunc _write_trylock(rwlock_t *lock);
+
+void __lockfunc _spin_lock(spinlock_t *lock)    __acquires(spinlock_t);
+void __lockfunc _read_lock(rwlock_t *lock)      __acquires(rwlock_t);
+void __lockfunc _write_lock(rwlock_t *lock)     __acquires(rwlock_t);
+
+void __lockfunc _spin_unlock(spinlock_t *lock)  __releases(spinlock_t);
+void __lockfunc _read_unlock(rwlock_t *lock)    __releases(rwlock_t);
+void __lockfunc _write_unlock(rwlock_t *lock)   __releases(rwlock_t);
+
+unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)   __acquires(spinlock_t);
+unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)     __acquires(rwlock_t);
+unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)    __acquires(rwlock_t);
+
+void __lockfunc _spin_lock_irq(spinlock_t *lock)        __acquires(spinlock_t);
+void __lockfunc _spin_lock_bh(spinlock_t *lock)         __acquires(spinlock_t);
+void __lockfunc _read_lock_irq(rwlock_t *lock)          __acquires(rwlock_t);
+void __lockfunc _read_lock_bh(rwlock_t *lock)           __acquires(rwlock_t);
+void __lockfunc _write_lock_irq(rwlock_t *lock)         __acquires(rwlock_t);
+void __lockfunc _write_lock_bh(rwlock_t *lock)          __acquires(rwlock_t);
+
+void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)  __releases(spinlock_t);
+void __lockfunc _spin_unlock_irq(spinlock_t *lock)                              __releases(spinlock_t);
+void __lockfunc _spin_unlock_bh(spinlock_t *lock)                               __releases(spinlock_t);
+void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)    __releases(rwlock_t);
+void __lockfunc _read_unlock_irq(rwlock_t *lock)                                __releases(rwlock_t);
+void __lockfunc _read_unlock_bh(rwlock_t *lock)                                 __releases(rwlock_t);
+void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)   __releases(rwlock_t);
+void __lockfunc _write_unlock_irq(rwlock_t *lock)                               __releases(rwlock_t);
+void __lockfunc _write_unlock_bh(rwlock_t *lock)                                __releases(rwlock_t);
+
+int __lockfunc _spin_trylock_bh(spinlock_t *lock);
+int __lockfunc generic_raw_read_trylock(rwlock_t *lock);
+int in_lock_functions(unsigned long addr);
+
+#else
+
+#define in_lock_functions(ADDR) 0
+
+#if !defined(CONFIG_PREEMPT) && !defined(CONFIG_DEBUG_SPINLOCK)
+# define _atomic_dec_and_lock(atomic,lock) atomic_dec_and_test(atomic)
+# define ATOMIC_DEC_AND_LOCK
+#endif
+
+#ifdef CONFIG_DEBUG_SPINLOCK
+ 
+#define SPINLOCK_MAGIC  0x1D244B3C
+typedef struct {
+        unsigned long magic;
+        volatile unsigned long lock;
+        volatile unsigned int babble;
+        const char *module;
+        char *owner;
+        int oline;
+} spinlock_t;
+#define SPIN_LOCK_UNLOCKED (spinlock_t) { SPINLOCK_MAGIC, 0, 10, __FILE__ , NULL, 0}
+
+#define spin_lock_init(x) \
+        do { \
+                (x)->magic = SPINLOCK_MAGIC; \
+                (x)->lock = 0; \
+                (x)->babble = 5; \
+                (x)->module = __FILE__; \
+                (x)->owner = NULL; \
+                (x)->oline = 0; \
+        } while (0)
+
+#define CHECK_LOCK(x) \
+        do { \
+                if ((x)->magic != SPINLOCK_MAGIC) { \
+                        printk(KERN_ERR "%s:%d: spin_is_locked on uninitialized spinlock %p.\n", \
+                                        __FILE__, __LINE__, (x)); \
+                } \
+        } while(0)
+
+#define _raw_spin_lock(x)               \
+        do { \
+                CHECK_LOCK(x); \
+                if ((x)->lock&&(x)->babble) { \
+                        (x)->babble--; \
+                        printk("%s:%d: spin_lock(%s:%p) already locked by %s/%d\n", \
+                                        __FILE__,__LINE__, (x)->module, \
+                                        (x), (x)->owner, (x)->oline); \
+                } \
+                (x)->lock = 1; \
+                (x)->owner = __FILE__; \
+                (x)->oline = __LINE__; \
+        } while (0)
+
+/* without debugging, spin_is_locked on UP always says
+ * FALSE. --> printk if already locked. */
+#define spin_is_locked(x) \
+        ({ \
+                CHECK_LOCK(x); \
+                if ((x)->lock&&(x)->babble) { \
+                        (x)->babble--; \
+                        printk("%s:%d: spin_is_locked(%s:%p) already locked by %s/%d\n", \
+                                        __FILE__,__LINE__, (x)->module, \
+                                        (x), (x)->owner, (x)->oline); \
+                } \
+                0; \
+        })
+
+/* with debugging, assert_spin_locked() on UP does check
+ * the lock value properly */
+#define assert_spin_locked(x) \
+        ({ \
+                CHECK_LOCK(x); \
+                BUG_ON(!(x)->lock); \
+        })
+
+/* without debugging, spin_trylock on UP always says
+ * TRUE. --> printk if already locked. */
+#define _raw_spin_trylock(x) \
+        ({ \
+                CHECK_LOCK(x); \
+                if ((x)->lock&&(x)->babble) { \
+                        (x)->babble--; \
+                        printk("%s:%d: spin_trylock(%s:%p) already locked by %s/%d\n", \
+                                        __FILE__,__LINE__, (x)->module, \
+                                        (x), (x)->owner, (x)->oline); \
+                } \
+                (x)->lock = 1; \
+                (x)->owner = __FILE__; \
+                (x)->oline = __LINE__; \
+                1; \
+        })
+
+#define spin_unlock_wait(x)     \
+        do { \
+                CHECK_LOCK(x); \
+                if ((x)->lock&&(x)->babble) { \
+                        (x)->babble--; \
+                        printk("%s:%d: spin_unlock_wait(%s:%p) owned by %s/%d\n", \
+                                        __FILE__,__LINE__, (x)->module, (x), \
+                                        (x)->owner, (x)->oline); \
+                }\
+        } while (0)
+
+#define _raw_spin_unlock(x) \
+        do { \
+                CHECK_LOCK(x); \
+                if (!(x)->lock&&(x)->babble) { \
+                        (x)->babble--; \
+                        printk("%s:%d: spin_unlock(%s:%p) not locked\n", \
+                                        __FILE__,__LINE__, (x)->module, (x));\
+                } \
+                (x)->lock = 0; \
+        } while (0)
+#else
+/*
+ * gcc versions before ~2.95 have a nasty bug with empty initializers.
+ */
+#if (__GNUC__ > 2)
+  typedef struct { } spinlock_t;
+  #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
+#else
+  typedef struct { int gcc_is_buggy; } spinlock_t;
+  #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
+#endif
+
+/*
+ * If CONFIG_SMP is unset, declare the _raw_* definitions as nops
+ */
+#define spin_lock_init(lock)    do { (void)(lock); } while(0)
+#define _raw_spin_lock(lock)    do { (void)(lock); } while(0)
+#define spin_is_locked(lock)    ((void)(lock), 0)
+#define assert_spin_locked(lock)        do { (void)(lock); } while(0)
+#define _raw_spin_trylock(lock) (((void)(lock), 1))
+#define spin_unlock_wait(lock)  (void)(lock)
+#define _raw_spin_unlock(lock) do { (void)(lock); } while(0)
+#endif /* CONFIG_DEBUG_SPINLOCK */
+
+/* RW spinlocks: No debug version */
+
+#if (__GNUC__ > 2)
+  typedef struct { } rwlock_t;
+  #define RW_LOCK_UNLOCKED (rwlock_t) { }
+#else
+  typedef struct { int gcc_is_buggy; } rwlock_t;
+  #define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
+#endif
+
+#define rwlock_init(lock)       do { (void)(lock); } while(0)
+#define _raw_read_lock(lock)    do { (void)(lock); } while(0)
+#define _raw_read_unlock(lock)  do { (void)(lock); } while(0)
+#define _raw_write_lock(lock)   do { (void)(lock); } while(0)
+#define _raw_write_unlock(lock) do { (void)(lock); } while(0)
+#define read_can_lock(lock)     (((void)(lock), 1))
+#define write_can_lock(lock)    (((void)(lock), 1))
+#define _raw_read_trylock(lock) ({ (void)(lock); (1); })
+#define _raw_write_trylock(lock) ({ (void)(lock); (1); })
+
+#define _spin_trylock(lock)     ({preempt_disable(); _raw_spin_trylock(lock) ? \
+                                1 : ({preempt_enable(); 0;});})
+
+#define _read_trylock(lock)     ({preempt_disable();_raw_read_trylock(lock) ? \
+                                1 : ({preempt_enable(); 0;});})
+
+#define _write_trylock(lock)    ({preempt_disable(); _raw_write_trylock(lock) ? \
+                                1 : ({preempt_enable(); 0;});})
+
+#define _spin_trylock_bh(lock)  ({preempt_disable(); local_bh_disable(); \
+                                _raw_spin_trylock(lock) ? \
+                                1 : ({preempt_enable(); local_bh_enable(); 0;});})
+
+#define _spin_lock(lock)        \
+do { \
+        preempt_disable(); \
+        _raw_spin_lock(lock); \
+        __acquire(lock); \
+} while(0)
+
+#define _write_lock(lock) \
+do { \
+        preempt_disable(); \
+        _raw_write_lock(lock); \
+        __acquire(lock); \
+} while(0)
+ 
+#define _read_lock(lock)        \
+do { \
+        preempt_disable(); \
+        _raw_read_lock(lock); \
+        __acquire(lock); \
+} while(0)
+
+#define _spin_unlock(lock) \
+do { \
+        _raw_spin_unlock(lock); \
+        preempt_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _write_unlock(lock) \
+do { \
+        _raw_write_unlock(lock); \
+        preempt_enable(); \
+        __release(lock); \
+} while(0)
+
+#define _read_unlock(lock) \
+do { \
+        _raw_read_unlock(lock); \
+        preempt_enable(); \
+        __release(lock); \
+} while(0)
+
+#define _spin_lock_irqsave(lock, flags) \
+do {    \
+        local_irq_save(flags); \
+        preempt_disable(); \
+        _raw_spin_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _spin_lock_irq(lock) \
+do { \
+        local_irq_disable(); \
+        preempt_disable(); \
+        _raw_spin_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _spin_lock_bh(lock) \
+do { \
+        local_bh_disable(); \
+        preempt_disable(); \
+        _raw_spin_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _read_lock_irqsave(lock, flags) \
+do {    \
+        local_irq_save(flags); \
+        preempt_disable(); \
+        _raw_read_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _read_lock_irq(lock) \
+do { \
+        local_irq_disable(); \
+        preempt_disable(); \
+        _raw_read_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _read_lock_bh(lock) \
+do { \
+        local_bh_disable(); \
+        preempt_disable(); \
+        _raw_read_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _write_lock_irqsave(lock, flags) \
+do {    \
+        local_irq_save(flags); \
+        preempt_disable(); \
+        _raw_write_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _write_lock_irq(lock) \
+do { \
+        local_irq_disable(); \
+        preempt_disable(); \
+        _raw_write_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _write_lock_bh(lock) \
+do { \
+        local_bh_disable(); \
+        preempt_disable(); \
+        _raw_write_lock(lock); \
+        __acquire(lock); \
+} while (0)
+
+#define _spin_unlock_irqrestore(lock, flags) \
+do { \
+        _raw_spin_unlock(lock); \
+        local_irq_restore(flags); \
+        preempt_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _spin_unlock_irq(lock) \
+do { \
+        _raw_spin_unlock(lock); \
+        local_irq_enable(); \
+        preempt_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _spin_unlock_bh(lock) \
+do { \
+        _raw_spin_unlock(lock); \
+        preempt_enable(); \
+        local_bh_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _write_unlock_bh(lock) \
+do { \
+        _raw_write_unlock(lock); \
+        preempt_enable(); \
+        local_bh_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _read_unlock_irqrestore(lock, flags) \
+do { \
+        _raw_read_unlock(lock); \
+        local_irq_restore(flags); \
+        preempt_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _write_unlock_irqrestore(lock, flags) \
+do { \
+        _raw_write_unlock(lock); \
+        local_irq_restore(flags); \
+        preempt_enable(); \
+        __release(lock); \
+} while (0)
+
+#define _read_unlock_irq(lock)  \
+do { \
+        _raw_read_unlock(lock); \
+        local_irq_enable();     \
+        preempt_enable();       \
+        __release(lock); \
+} while (0)
+
+#define _read_unlock_bh(lock)   \
+do { \
+        _raw_read_unlock(lock); \
+        local_bh_enable();      \
+        preempt_enable();       \
+        __release(lock); \
+} while (0)
+
+#define _write_unlock_irq(lock) \
+do { \
+        _raw_write_unlock(lock);        \
+        local_irq_enable();     \
+        preempt_enable();       \
+        __release(lock); \
+} while (0)
+
+#endif /* !SMP */
+
+/*
+ * Define the various spin_lock and rw_lock methods.  Note we define these
+ * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
+ * methods are defined as nops in the case they are not required.
+ */
+#define spin_trylock(lock)      __cond_lock(_spin_trylock(lock))
+#define read_trylock(lock)      __cond_lock(_read_trylock(lock))
+#define write_trylock(lock)     __cond_lock(_write_trylock(lock))
+
+#define spin_lock(lock)         _spin_lock(lock)
+#define write_lock(lock)        _write_lock(lock)
+#define read_lock(lock)         _read_lock(lock)
+
+#ifdef CONFIG_SMP
+#define spin_lock_irqsave(lock, flags)  flags = _spin_lock_irqsave(lock)
+#define read_lock_irqsave(lock, flags)  flags = _read_lock_irqsave(lock)
+#define write_lock_irqsave(lock, flags) flags = _write_lock_irqsave(lock)
+#else
+#define spin_lock_irqsave(lock, flags)  _spin_lock_irqsave(lock, flags)
+#define read_lock_irqsave(lock, flags)  _read_lock_irqsave(lock, flags)
+#define write_lock_irqsave(lock, flags) _write_lock_irqsave(lock, flags)
+#endif
+
+#define spin_lock_irq(lock)             _spin_lock_irq(lock)
+#define spin_lock_bh(lock)              _spin_lock_bh(lock)
+
+#define read_lock_irq(lock)             _read_lock_irq(lock)
+#define read_lock_bh(lock)              _read_lock_bh(lock)
+
+#define write_lock_irq(lock)            _write_lock_irq(lock)
+#define write_lock_bh(lock)             _write_lock_bh(lock)
+
+#define spin_unlock(lock)       _spin_unlock(lock)
+#define write_unlock(lock)      _write_unlock(lock)
+#define read_unlock(lock)       _read_unlock(lock)
+
+#define spin_unlock_irqrestore(lock, flags)     _spin_unlock_irqrestore(lock, flags)
+#define spin_unlock_irq(lock)           _spin_unlock_irq(lock)
+#define spin_unlock_bh(lock)            _spin_unlock_bh(lock)
+
+#define read_unlock_irqrestore(lock, flags)     _read_unlock_irqrestore(lock, flags)
+#define read_unlock_irq(lock)                   _read_unlock_irq(lock)
+#define read_unlock_bh(lock)                    _read_unlock_bh(lock)
+
+#define write_unlock_irqrestore(lock, flags)    _write_unlock_irqrestore(lock, flags)
+#define write_unlock_irq(lock)                  _write_unlock_irq(lock)
+#define write_unlock_bh(lock)                   _write_unlock_bh(lock)
+
+#define spin_trylock_bh(lock)                   __cond_lock(_spin_trylock_bh(lock))
+
+#define spin_trylock_irq(lock) \
+({ \
+        local_irq_disable(); \
+        _spin_trylock(lock) ? \
+        1 : ({local_irq_enable(); 0; }); \
+})
+
+#define spin_trylock_irqsave(lock, flags) \
+({ \
+        local_irq_save(flags); \
+        _spin_trylock(lock) ? \
+        1 : ({local_irq_restore(flags); 0;}); \
+})
+
+#ifdef CONFIG_LOCKMETER
+extern void _metered_spin_lock   (spinlock_t *lock);
+extern void _metered_spin_unlock (spinlock_t *lock);
+extern int  _metered_spin_trylock(spinlock_t *lock);
+extern void _metered_read_lock    (rwlock_t *lock);
+extern void _metered_read_unlock  (rwlock_t *lock);
+extern void _metered_write_lock   (rwlock_t *lock);
+extern void _metered_write_unlock (rwlock_t *lock);
+extern int  _metered_read_trylock (rwlock_t *lock);
+extern int  _metered_write_trylock(rwlock_t *lock);
+#endif
+
+/* "lock on reference count zero" */
+#ifndef ATOMIC_DEC_AND_LOCK
+#include <asm/atomic.h>
+extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
+#endif
+
+#define atomic_dec_and_lock(atomic,lock) __cond_lock(_atomic_dec_and_lock(atomic,lock))
+
+/*
+ *  bit-based spin_lock()
+ *
+ * Don't use this unless you really need to: spin_lock() and spin_unlock()
+ * are significantly faster.
+ */
+static inline void bit_spin_lock(int bitnum, unsigned long *addr)
+{
+        /*
+         * Assuming the lock is uncontended, this never enters
+         * the body of the outer loop. If it is contended, then
+         * within the inner loop a non-atomic test is used to
+         * busywait with less bus contention for a good time to
+         * attempt to acquire the lock bit.
+         */
+        preempt_disable();
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        while (test_and_set_bit(bitnum, addr)) {
+                while (test_bit(bitnum, addr)) {
+                        preempt_enable();
+                        cpu_relax();
+                        preempt_disable();
+                }
+        }
+#endif
+        __acquire(bitlock);
+}
+
+/*
+ * Return true if it was acquired
+ */
+static inline int bit_spin_trylock(int bitnum, unsigned long *addr)
+{
+        preempt_disable();      
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        if (test_and_set_bit(bitnum, addr)) {
+                preempt_enable();
+                return 0;
+        }
+#endif
+        __acquire(bitlock);
+        return 1;
+}
+
+/*
+ *  bit-based spin_unlock()
+ */
+static inline void bit_spin_unlock(int bitnum, unsigned long *addr)
+{
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        BUG_ON(!test_bit(bitnum, addr));
+        smp_mb__before_clear_bit();
+        clear_bit(bitnum, addr);
+#endif
+        preempt_enable();
+        __release(bitlock);
+}
+
+/*
+ * Return true if the lock is held.
+ */
+static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
+{
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+        return test_bit(bitnum, addr);
+#elif defined CONFIG_PREEMPT
+        return preempt_count();
+#else
+        return 1;
+#endif
+}
+
+#define DEFINE_SPINLOCK(x) spinlock_t x = SPIN_LOCK_UNLOCKED
+#define DEFINE_RWLOCK(x) rwlock_t x = RW_LOCK_UNLOCKED
+
+/**
+ * spin_can_lock - would spin_trylock() succeed?
+ * @lock: the spinlock in question.
+ */
+#define spin_can_lock(lock)             (!spin_is_locked(lock))
+
+#endif /* __LINUX_SPINLOCK_H */
diff --git a/include/linux/stallion.h b/include/linux/stallion.h
new file mode 100644
index 000000000000..e89b77b6505a
--- /dev/null
+++ b/include/linux/stallion.h
@@ -0,0 +1,154 @@
+/*****************************************************************************/
+
+/*
+ *      stallion.h  -- stallion multiport serial driver.
+ *
+ *      Copyright (C) 1996-1998  Stallion Technologies
+ *      Copyright (C) 1994-1996  Greg Ungerer.
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/version.h>
+
+/*****************************************************************************/
+#ifndef _STALLION_H
+#define _STALLION_H
+/*****************************************************************************/
+
+/*
+ *      Define important driver constants here.
+ */
+#define STL_MAXBRDS             4
+#define STL_MAXPANELS           4
+#define STL_MAXBANKS            8
+#define STL_PORTSPERPANEL       16
+#define STL_MAXPORTS            64
+#define STL_MAXDEVS             (STL_MAXBRDS * STL_MAXPORTS)
+
+
+/*
+ *      Define a set of structures to hold all the board/panel/port info
+ *      for our ports. These will be dynamically allocated as required.
+ */
+
+/*
+ *      Define a ring queue structure for each port. This will hold the
+ *      TX data waiting to be output. Characters are fed into this buffer
+ *      from the line discipline (or even direct from user space!) and
+ *      then fed into the UARTs during interrupts. Will use a classic ring
+ *      queue here for this. The good thing about this type of ring queue
+ *      is that the head and tail pointers can be updated without interrupt
+ *      protection - since "write" code only needs to change the head, and
+ *      interrupt code only needs to change the tail.
+ */
+typedef struct {
+        char    *buf;
+        char    *head;
+        char    *tail;
+} stlrq_t;
+
+/*
+ *      Port, panel and board structures to hold status info about each.
+ *      The board structure contains pointers to structures for each panel
+ *      connected to it, and in turn each panel structure contains pointers
+ *      for each port structure for each port on that panel. Note that
+ *      the port structure also contains the board and panel number that it
+ *      is associated with, this makes it (fairly) easy to get back to the
+ *      board/panel info for a port.
+ */
+typedef struct stlport {
+        unsigned long           magic;
+        int                     portnr;
+        int                     panelnr;
+        int                     brdnr;
+        int                     ioaddr;
+        int                     uartaddr;
+        int                     pagenr;
+        long                    istate;
+        int                     flags;
+        int                     baud_base;
+        int                     custom_divisor;
+        int                     close_delay;
+        int                     closing_wait;
+        int                     refcount;
+        int                     openwaitcnt;
+        int                     brklen;
+        unsigned int            sigs;
+        unsigned int            rxignoremsk;
+        unsigned int            rxmarkmsk;
+        unsigned int            imr;
+        unsigned int            crenable;
+        unsigned long           clk;
+        unsigned long           hwid;
+        void                    *uartp;
+        struct tty_struct       *tty;
+        wait_queue_head_t       open_wait;
+        wait_queue_head_t       close_wait;
+        struct work_struct      tqueue;
+        comstats_t              stats;
+        stlrq_t                 tx;
+} stlport_t;
+
+typedef struct stlpanel {
+        unsigned long   magic;
+        int             panelnr;
+        int             brdnr;
+        int             pagenr;
+        int             nrports;
+        int             iobase;
+        void            *uartp;
+        void            (*isr)(struct stlpanel *panelp, unsigned int iobase);
+        unsigned int    hwid;
+        unsigned int    ackmask;
+        stlport_t       *ports[STL_PORTSPERPANEL];
+} stlpanel_t;
+
+typedef struct stlbrd {
+        unsigned long   magic;
+        int             brdnr;
+        int             brdtype;
+        int             state;
+        int             nrpanels;
+        int             nrports;
+        int             nrbnks;
+        int             irq;
+        int             irqtype;
+        int             (*isr)(struct stlbrd *brdp);
+        unsigned int    ioaddr1;
+        unsigned int    ioaddr2;
+        unsigned int    iosize1;
+        unsigned int    iosize2;
+        unsigned int    iostatus;
+        unsigned int    ioctrl;
+        unsigned int    ioctrlval;
+        unsigned int    hwid;
+        unsigned long   clk;
+        unsigned int    bnkpageaddr[STL_MAXBANKS];
+        unsigned int    bnkstataddr[STL_MAXBANKS];
+        stlpanel_t      *bnk2panel[STL_MAXBANKS];
+        stlpanel_t      *panels[STL_MAXPANELS];
+} stlbrd_t;
+
+
+/*
+ *      Define MAGIC numbers used for above structures.
+ */
+#define STL_PORTMAGIC   0x5a7182c9
+#define STL_PANELMAGIC  0x7ef621a1
+#define STL_BOARDMAGIC  0xa2267f52
+
+/*****************************************************************************/
+#endif
diff --git a/include/linux/stat.h b/include/linux/stat.h
new file mode 100644
index 000000000000..8ff2a122dfef
--- /dev/null
+++ b/include/linux/stat.h
@@ -0,0 +1,77 @@
+#ifndef _LINUX_STAT_H
+#define _LINUX_STAT_H
+
+#ifdef __KERNEL__
+
+#include <asm/stat.h>
+
+#endif
+
+#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
+
+#define S_IFMT  00170000
+#define S_IFSOCK 0140000
+#define S_IFLNK  0120000
+#define S_IFREG  0100000
+#define S_IFBLK  0060000
+#define S_IFDIR  0040000
+#define S_IFCHR  0020000
+#define S_IFIFO  0010000
+#define S_ISUID  0004000
+#define S_ISGID  0002000
+#define S_ISVTX  0001000
+
+#define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)
+#define S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)
+#define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)
+#define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)
+#define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)
+#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)
+#define S_ISSOCK(m)     (((m) & S_IFMT) == S_IFSOCK)
+
+#define S_IRWXU 00700
+#define S_IRUSR 00400
+#define S_IWUSR 00200
+#define S_IXUSR 00100
+
+#define S_IRWXG 00070
+#define S_IRGRP 00040
+#define S_IWGRP 00020
+#define S_IXGRP 00010
+
+#define S_IRWXO 00007
+#define S_IROTH 00004
+#define S_IWOTH 00002
+#define S_IXOTH 00001
+
+#endif
+
+#ifdef __KERNEL__
+#define S_IRWXUGO       (S_IRWXU|S_IRWXG|S_IRWXO)
+#define S_IALLUGO       (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)
+#define S_IRUGO         (S_IRUSR|S_IRGRP|S_IROTH)
+#define S_IWUGO         (S_IWUSR|S_IWGRP|S_IWOTH)
+#define S_IXUGO         (S_IXUSR|S_IXGRP|S_IXOTH)
+
+#include <linux/types.h>
+#include <linux/time.h>
+
+struct kstat {
+        unsigned long   ino;
+        dev_t           dev;
+        umode_t         mode;
+        unsigned int    nlink;
+        uid_t           uid;
+        gid_t           gid;
+        dev_t           rdev;
+        loff_t          size;
+        struct timespec  atime;
+        struct timespec mtime;
+        struct timespec ctime;
+        unsigned long   blksize;
+        unsigned long   blocks;
+};
+
+#endif
+
+#endif
diff --git a/include/linux/statfs.h b/include/linux/statfs.h
new file mode 100644
index 000000000000..ad83a2bdb821
--- /dev/null
+++ b/include/linux/statfs.h
@@ -0,0 +1,22 @@
+#ifndef _LINUX_STATFS_H
+#define _LINUX_STATFS_H
+
+#include <linux/types.h>
+
+#include <asm/statfs.h>
+
+struct kstatfs {
+        long f_type;
+        long f_bsize;
+        sector_t f_blocks;
+        sector_t f_bfree;
+        sector_t f_bavail;
+        sector_t f_files;
+        sector_t f_ffree;
+        __kernel_fsid_t f_fsid;
+        long f_namelen;
+        long f_frsize;
+        long f_spare[5];
+};
+
+#endif
diff --git a/include/linux/stddef.h b/include/linux/stddef.h
new file mode 100644
index 000000000000..b3a2cadf90f2
--- /dev/null
+++ b/include/linux/stddef.h
@@ -0,0 +1,20 @@
+#ifndef _LINUX_STDDEF_H
+#define _LINUX_STDDEF_H
+
+#include <linux/compiler.h>
+
+#undef NULL
+#if defined(__cplusplus)
+#define NULL 0
+#else
+#define NULL ((void *)0)
+#endif
+
+#undef offsetof
+#ifdef __compiler_offsetof
+#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
+#else
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
+#endif
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
new file mode 100644
index 000000000000..151a803ed0ed
--- /dev/null
+++ b/include/linux/stop_machine.h
@@ -0,0 +1,52 @@
+#ifndef _LINUX_STOP_MACHINE
+#define _LINUX_STOP_MACHINE
+/* "Bogolock": stop the entire machine, disable interrupts.  This is a
+   very heavy lock, which is equivalent to grabbing every spinlock
+   (and more).  So the "read" side to such a lock is anything which
+   diables preeempt. */
+#include <linux/config.h>
+#include <linux/cpu.h>
+#include <asm/system.h>
+
+#if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP)
+/**
+ * stop_machine_run: freeze the machine on all CPUs and run this function
+ * @fn: the function to run
+ * @data: the data ptr for the @fn()
+ * @cpu: the cpu to run @fn() on (or any, if @cpu == NR_CPUS.
+ *
+ * Description: This causes a thread to be scheduled on every other cpu,
+ * each of which disables interrupts, and finally interrupts are disabled
+ * on the current CPU.  The result is that noone is holding a spinlock
+ * or inside any other preempt-disabled region when @fn() runs.
+ *
+ * This can be thought of as a very heavy write lock, equivalent to
+ * grabbing every spinlock in the kernel. */
+int stop_machine_run(int (*fn)(void *), void *data, unsigned int cpu);
+
+/**
+ * __stop_machine_run: freeze the machine on all CPUs and run this function
+ * @fn: the function to run
+ * @data: the data ptr for the @fn
+ * @cpu: the cpu to run @fn on (or any, if @cpu == NR_CPUS.
+ *
+ * Description: This is a special version of the above, which returns the
+ * thread which has run @fn(): kthread_stop will return the return value
+ * of @fn().  Used by hotplug cpu.
+ */
+struct task_struct *__stop_machine_run(int (*fn)(void *), void *data,
+                                       unsigned int cpu);
+
+#else
+
+static inline int stop_machine_run(int (*fn)(void *), void *data,
+                                   unsigned int cpu)
+{
+        int ret;
+        local_irq_disable();
+        ret = fn(data);
+        local_irq_enable();
+        return ret;
+}
+#endif /* CONFIG_SMP */
+#endif /* _LINUX_STOP_MACHINE */
diff --git a/include/linux/string.h b/include/linux/string.h
new file mode 100644
index 000000000000..b9fc59469956
--- /dev/null
+++ b/include/linux/string.h
@@ -0,0 +1,96 @@
+#ifndef _LINUX_STRING_H_
+#define _LINUX_STRING_H_
+
+/* We don't want strings.h stuff being user by user stuff by accident */
+
+#ifdef __KERNEL__
+
+#include <linux/compiler.h>     /* for inline */
+#include <linux/types.h>        /* for size_t */
+#include <linux/stddef.h>       /* for NULL */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern char * strpbrk(const char *,const char *);
+extern char * strsep(char **,const char *);
+extern __kernel_size_t strspn(const char *,const char *);
+extern __kernel_size_t strcspn(const char *,const char *);
+
+/*
+ * Include machine specific inline routines
+ */
+#include <asm/string.h>
+
+#ifndef __HAVE_ARCH_STRCPY
+extern char * strcpy(char *,const char *);
+#endif
+#ifndef __HAVE_ARCH_STRNCPY
+extern char * strncpy(char *,const char *, __kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_STRLCPY
+size_t strlcpy(char *, const char *, size_t);
+#endif
+#ifndef __HAVE_ARCH_STRCAT
+extern char * strcat(char *, const char *);
+#endif
+#ifndef __HAVE_ARCH_STRNCAT
+extern char * strncat(char *, const char *, __kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_STRLCAT
+extern size_t strlcat(char *, const char *, __kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_STRCMP
+extern int strcmp(const char *,const char *);
+#endif
+#ifndef __HAVE_ARCH_STRNCMP
+extern int strncmp(const char *,const char *,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_STRNICMP
+extern int strnicmp(const char *, const char *, __kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_STRCHR
+extern char * strchr(const char *,int);
+#endif
+#ifndef __HAVE_ARCH_STRNCHR
+extern char * strnchr(const char *, size_t, int);
+#endif
+#ifndef __HAVE_ARCH_STRRCHR
+extern char * strrchr(const char *,int);
+#endif
+#ifndef __HAVE_ARCH_STRSTR
+extern char * strstr(const char *,const char *);
+#endif
+#ifndef __HAVE_ARCH_STRLEN
+extern __kernel_size_t strlen(const char *);
+#endif
+#ifndef __HAVE_ARCH_STRNLEN
+extern __kernel_size_t strnlen(const char *,__kernel_size_t);
+#endif
+
+#ifndef __HAVE_ARCH_MEMSET
+extern void * memset(void *,int,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_MEMCPY
+extern void * memcpy(void *,const void *,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_MEMMOVE
+extern void * memmove(void *,const void *,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_MEMSCAN
+extern void * memscan(void *,int,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_MEMCMP
+extern int memcmp(const void *,const void *,__kernel_size_t);
+#endif
+#ifndef __HAVE_ARCH_MEMCHR
+extern void * memchr(const void *,int,__kernel_size_t);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* _LINUX_STRING_H_ */
diff --git a/include/linux/stringify.h b/include/linux/stringify.h
new file mode 100644
index 000000000000..0b4388356c87
--- /dev/null
+++ b/include/linux/stringify.h
@@ -0,0 +1,12 @@
+#ifndef __LINUX_STRINGIFY_H
+#define __LINUX_STRINGIFY_H
+
+/* Indirect stringification.  Doing two levels allows the parameter to be a
+ * macro itself.  For example, compile with -DFOO=bar, __stringify(FOO)
+ * converts to "bar".
+ */
+
+#define __stringify_1(x)        #x
+#define __stringify(x)          __stringify_1(x)
+
+#endif  /* !__LINUX_STRINGIFY_H */
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
new file mode 100644
index 000000000000..04ebc24db348
--- /dev/null
+++ b/include/linux/sunrpc/auth.h
@@ -0,0 +1,149 @@
+/*
+ * linux/include/linux/sunrpc/auth.h
+ *
+ * Declarations for the RPC client authentication machinery.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_AUTH_H
+#define _LINUX_SUNRPC_AUTH_H
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/sunrpc/sched.h>
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/sunrpc/xdr.h>
+
+#include <asm/atomic.h>
+
+/* size of the nodename buffer */
+#define UNX_MAXNODENAME 32
+
+/* Maximum size (in bytes) of an rpc credential or verifier */
+#define RPC_MAX_AUTH_SIZE (400)
+
+/* Work around the lack of a VFS credential */
+struct auth_cred {
+        uid_t   uid;
+        gid_t   gid;
+        struct group_info *group_info;
+};
+
+/*
+ * Client user credentials
+ */
+struct rpc_cred {
+        struct hlist_node       cr_hash;        /* hash chain */
+        struct rpc_credops *    cr_ops;
+        unsigned long           cr_expire;      /* when to gc */
+        atomic_t                cr_count;       /* ref count */
+        unsigned short          cr_flags;       /* various flags */
+#ifdef RPC_DEBUG
+        unsigned long           cr_magic;       /* 0x0f4aa4f0 */
+#endif
+
+        uid_t                   cr_uid;
+
+        /* per-flavor data */
+};
+#define RPCAUTH_CRED_LOCKED     0x0001
+#define RPCAUTH_CRED_UPTODATE   0x0002
+
+#define RPCAUTH_CRED_MAGIC      0x0f4aa4f0
+
+/*
+ * Client authentication handle
+ */
+#define RPC_CREDCACHE_NR        8
+#define RPC_CREDCACHE_MASK      (RPC_CREDCACHE_NR - 1)
+struct rpc_cred_cache {
+        struct hlist_head       hashtable[RPC_CREDCACHE_NR];
+        unsigned long           nextgc;         /* next garbage collection */
+        unsigned long           expire;         /* cache expiry interval */
+};
+
+struct rpc_auth {
+        unsigned int            au_cslack;      /* call cred size estimate */
+        unsigned int            au_rslack;      /* reply verf size guess */
+        unsigned int            au_flags;       /* various flags */
+        struct rpc_authops *    au_ops;         /* operations */
+        rpc_authflavor_t        au_flavor;      /* pseudoflavor (note may
+                                                 * differ from the flavor in
+                                                 * au_ops->au_flavor in gss
+                                                 * case) */
+        atomic_t                au_count;       /* Reference counter */
+
+        struct rpc_cred_cache * au_credcache;
+        /* per-flavor data */
+};
+#define RPC_AUTH_PROC_CREDS     0x0010          /* process creds (including
+                                                 * uid/gid, fs[ug]id, gids)
+                                                 */
+
+/*
+ * Client authentication ops
+ */
+struct rpc_authops {
+        struct module           *owner;
+        rpc_authflavor_t        au_flavor;      /* flavor (RPC_AUTH_*) */
+#ifdef RPC_DEBUG
+        char *                  au_name;
+#endif
+        struct rpc_auth *       (*create)(struct rpc_clnt *, rpc_authflavor_t);
+        void                    (*destroy)(struct rpc_auth *);
+
+        struct rpc_cred *       (*lookup_cred)(struct rpc_auth *, struct auth_cred *, int);
+        struct rpc_cred *       (*crcreate)(struct rpc_auth*, struct auth_cred *, int);
+};
+
+struct rpc_credops {
+        const char *            cr_name;        /* Name of the auth flavour */
+        void                    (*crdestroy)(struct rpc_cred *);
+
+        int                     (*crmatch)(struct auth_cred *, struct rpc_cred *, int);
+        u32 *                   (*crmarshal)(struct rpc_task *, u32 *);
+        int                     (*crrefresh)(struct rpc_task *);
+        u32 *                   (*crvalidate)(struct rpc_task *, u32 *);
+        int                     (*crwrap_req)(struct rpc_task *, kxdrproc_t,
+                                                void *, u32 *, void *);
+        int                     (*crunwrap_resp)(struct rpc_task *, kxdrproc_t,
+                                                void *, u32 *, void *);
+};
+
+extern struct rpc_authops       authunix_ops;
+extern struct rpc_authops       authnull_ops;
+#ifdef CONFIG_SUNRPC_SECURE
+extern struct rpc_authops       authdes_ops;
+#endif
+
+int                     rpcauth_register(struct rpc_authops *);
+int                     rpcauth_unregister(struct rpc_authops *);
+struct rpc_auth *       rpcauth_create(rpc_authflavor_t, struct rpc_clnt *);
+void                    rpcauth_destroy(struct rpc_auth *);
+struct rpc_cred *       rpcauth_lookup_credcache(struct rpc_auth *, struct auth_cred *, int);
+struct rpc_cred *       rpcauth_lookupcred(struct rpc_auth *, int);
+struct rpc_cred *       rpcauth_bindcred(struct rpc_task *);
+void                    rpcauth_holdcred(struct rpc_task *);
+void                    put_rpccred(struct rpc_cred *);
+void                    rpcauth_unbindcred(struct rpc_task *);
+u32 *                   rpcauth_marshcred(struct rpc_task *, u32 *);
+u32 *                   rpcauth_checkverf(struct rpc_task *, u32 *);
+int                     rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, u32 *data, void *obj);
+int                     rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, u32 *data, void *obj);
+int                     rpcauth_refreshcred(struct rpc_task *);
+void                    rpcauth_invalcred(struct rpc_task *);
+int                     rpcauth_uptodatecred(struct rpc_task *);
+int                     rpcauth_init_credcache(struct rpc_auth *, unsigned long);
+void                    rpcauth_free_credcache(struct rpc_auth *);
+
+static inline
+struct rpc_cred *       get_rpccred(struct rpc_cred *cred)
+{
+        atomic_inc(&cred->cr_count);
+        return cred;
+}
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_AUTH_H */
diff --git a/include/linux/sunrpc/auth_gss.h b/include/linux/sunrpc/auth_gss.h
new file mode 100644
index 000000000000..03084dc4bb6a
--- /dev/null
+++ b/include/linux/sunrpc/auth_gss.h
@@ -0,0 +1,97 @@
+/*
+ * linux/include/linux/auth_gss.h
+ *
+ * Declarations for RPCSEC_GSS
+ *
+ * Dug Song <dugsong@monkey.org>
+ * Andy Adamson <andros@umich.edu>
+ * Bruce Fields <bfields@umich.edu>
+ * Copyright (c) 2000 The Regents of the University of Michigan
+ *
+ * $Id$
+ */
+
+#ifndef _LINUX_SUNRPC_AUTH_GSS_H
+#define _LINUX_SUNRPC_AUTH_GSS_H
+
+#ifdef __KERNEL__
+#include <linux/sunrpc/auth.h>
+#include <linux/sunrpc/svc.h>
+#include <linux/sunrpc/gss_api.h>
+
+#define RPC_GSS_VERSION         1
+
+#define MAXSEQ 0x80000000 /* maximum legal sequence number, from rfc 2203 */
+
+enum rpc_gss_proc {
+        RPC_GSS_PROC_DATA = 0,
+        RPC_GSS_PROC_INIT = 1,
+        RPC_GSS_PROC_CONTINUE_INIT = 2,
+        RPC_GSS_PROC_DESTROY = 3
+};
+
+enum rpc_gss_svc {
+        RPC_GSS_SVC_NONE = 1,
+        RPC_GSS_SVC_INTEGRITY = 2,
+        RPC_GSS_SVC_PRIVACY = 3
+};
+
+/* on-the-wire gss cred: */
+struct rpc_gss_wire_cred {
+        u32                     gc_v;           /* version */
+        u32                     gc_proc;        /* control procedure */
+        u32                     gc_seq;         /* sequence number */
+        u32                     gc_svc;         /* service */
+        struct xdr_netobj       gc_ctx;         /* context handle */
+};
+
+/* on-the-wire gss verifier: */
+struct rpc_gss_wire_verf {
+        u32                     gv_flavor;
+        struct xdr_netobj       gv_verf;
+};
+
+/* return from gss NULL PROC init sec context */
+struct rpc_gss_init_res {
+        struct xdr_netobj       gr_ctx;         /* context handle */
+        u32                     gr_major;       /* major status */
+        u32                     gr_minor;       /* minor status */
+        u32                     gr_win;         /* sequence window */
+        struct xdr_netobj       gr_token;       /* token */
+};
+
+/* The gss_cl_ctx struct holds all the information the rpcsec_gss client
+ * code needs to know about a single security context.  In particular,
+ * gc_gss_ctx is the context handle that is used to do gss-api calls, while
+ * gc_wire_ctx is the context handle that is used to identify the context on
+ * the wire when communicating with a server. */
+
+struct gss_cl_ctx {
+        atomic_t                count;
+        enum rpc_gss_proc       gc_proc;
+        u32                     gc_seq;
+        spinlock_t              gc_seq_lock;
+        struct gss_ctx          *gc_gss_ctx;
+        struct xdr_netobj       gc_wire_ctx;
+        u32                     gc_win;
+        unsigned long           gc_expiry;
+};
+
+struct gss_upcall_msg;
+struct gss_cred {
+        struct rpc_cred         gc_base;
+        enum rpc_gss_svc        gc_service;
+        struct gss_cl_ctx       *gc_ctx;
+        struct gss_upcall_msg   *gc_upcall;
+};
+
+#define gc_uid                  gc_base.cr_uid
+#define gc_count                gc_base.cr_count
+#define gc_flags                gc_base.cr_flags
+#define gc_expire               gc_base.cr_expire
+
+void print_hexl(u32 *p, u_int length, u_int offset);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_AUTH_GSS_H */
+
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
new file mode 100644
index 000000000000..6864063d1b9f
--- /dev/null
+++ b/include/linux/sunrpc/cache.h
@@ -0,0 +1,312 @@
+/*
+ * include/linux/sunrpc/cache.h
+ *
+ * Generic code for various authentication-related caches
+ * used by sunrpc clients and servers.
+ *
+ * Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au>
+ *
+ * Released under terms in GPL version 2.  See COPYING.
+ *
+ */
+
+#ifndef _LINUX_SUNRPC_CACHE_H_
+#define _LINUX_SUNRPC_CACHE_H_
+
+#include <linux/slab.h>
+#include <asm/atomic.h>
+#include <linux/proc_fs.h>
+
+/*
+ * Each cache requires:
+ *  - A 'struct cache_detail' which contains information specific to the cache
+ *    for common code to use.
+ *  - An item structure that must contain a "struct cache_head"
+ *  - A lookup function defined using DefineCacheLookup
+ *  - A 'put' function that can release a cache item. It will only
+ *    be called after cache_put has succeed, so there are guarantee
+ *    to be no references.
+ *  - A function to calculate a hash of an item's key.
+ *
+ * as well as assorted code fragments (e.g. compare keys) and numbers
+ * (e.g. hash size, goal_age, etc).
+ *
+ * Each cache must be registered so that it can be cleaned regularly.
+ * When the cache is unregistered, it is flushed completely.
+ *
+ * Entries have a ref count and a 'hashed' flag which counts the existance
+ * in the hash table.
+ * We only expire entries when refcount is zero.
+ * Existance in the cache is counted  the refcount.
+ */
+
+/* Every cache item has a common header that is used
+ * for expiring and refreshing entries.
+ * 
+ */
+struct cache_head {
+        struct cache_head * next;
+        time_t          expiry_time;    /* After time time, don't use the data */
+        time_t          last_refresh;   /* If CACHE_PENDING, this is when upcall 
+                                         * was sent, else this is when update was received
+                                         */
+        atomic_t        refcnt;
+        unsigned long   flags;
+};
+#define CACHE_VALID     0       /* Entry contains valid data */
+#define CACHE_NEGATIVE  1       /* Negative entry - there is no match for the key */
+#define CACHE_PENDING   2       /* An upcall has been sent but no reply received yet*/
+
+#define CACHE_NEW_EXPIRY 120    /* keep new things pending confirmation for 120 seconds */
+
+struct cache_detail {
+        int                     hash_size;
+        struct cache_head **    hash_table;
+        rwlock_t                hash_lock;
+
+        atomic_t                inuse; /* active user-space update or lookup */
+
+        char                    *name;
+        void                    (*cache_put)(struct cache_head *,
+                                             struct cache_detail*);
+
+        void                    (*cache_request)(struct cache_detail *cd,
+                                                 struct cache_head *h,
+                                                 char **bpp, int *blen);
+        int                     (*cache_parse)(struct cache_detail *,
+                                               char *buf, int len);
+
+        int                     (*cache_show)(struct seq_file *m,
+                                              struct cache_detail *cd,
+                                              struct cache_head *h);
+
+        /* fields below this comment are for internal use
+         * and should not be touched by cache owners
+         */
+        time_t                  flush_time;             /* flush all cache items with last_refresh
+                                                         * earlier than this */
+        struct list_head        others;
+        time_t                  nextcheck;
+        int                     entries;
+
+        /* fields for communication over channel */
+        struct list_head        queue;
+        struct proc_dir_entry   *proc_ent;
+        struct proc_dir_entry   *flush_ent, *channel_ent, *content_ent;
+
+        atomic_t                readers;                /* how many time is /chennel open */
+        time_t                  last_close;             /* if no readers, when did last close */
+        time_t                  last_warn;              /* when we last warned about no readers */
+        void                    (*warn_no_listener)(struct cache_detail *cd);
+};
+
+
+/* this must be embedded in any request structure that
+ * identifies an object that will want a callback on
+ * a cache fill
+ */
+struct cache_req {
+        struct cache_deferred_req *(*defer)(struct cache_req *req);
+};
+/* this must be embedded in a deferred_request that is being
+ * delayed awaiting cache-fill
+ */
+struct cache_deferred_req {
+        struct list_head        hash;   /* on hash chain */
+        struct list_head        recent; /* on fifo */
+        struct cache_head       *item;  /* cache item we wait on */
+        time_t                  recv_time;
+        void                    *owner; /* we might need to discard all defered requests
+                                         * owned by someone */
+        void                    (*revisit)(struct cache_deferred_req *req,
+                                           int too_many);
+};
+
+/*
+ * just like a template in C++, this macro does cache lookup
+ * for us.
+ * The function is passed some sort of HANDLE from which a cache_detail
+ * structure can be determined (via SETUP, DETAIL), a template
+ * cache entry (type RTN*), and a "set" flag.  Using the HASHFN and the 
+ * TEST, the function will try to find a matching cache entry in the cache.
+ * If "set" == 0 :
+ *    If an entry is found, it is returned
+ *    If no entry is found, a new non-VALID entry is created.
+ * If "set" == 1 and INPLACE == 0 :
+ *    If no entry is found a new one is inserted with data from "template"
+ *    If a non-CACHE_VALID entry is found, it is updated from template using UPDATE
+ *    If a CACHE_VALID entry is found, a new entry is swapped in with data
+ *       from "template"
+ * If set == 1, and INPLACE == 1 :
+ *    As above, except that if a CACHE_VALID entry is found, we UPDATE in place
+ *       instead of swapping in a new entry.
+ *
+ * If the passed handle has the CACHE_NEGATIVE flag set, then UPDATE is not
+ * run but insteead CACHE_NEGATIVE is set in any new item.
+
+ *  In any case, the new entry is returned with a reference count.
+ *
+ *    
+ * RTN is a struct type for a cache entry
+ * MEMBER is the member of the cache which is cache_head, which must be first
+ * FNAME is the name for the function   
+ * ARGS are arguments to function and must contain RTN *item, int set.  May
+ *   also contain something to be usedby SETUP or DETAIL to find cache_detail.
+ * SETUP  locates the cache detail and makes it available as...
+ * DETAIL identifies the cache detail, possibly set up by SETUP
+ * HASHFN returns a hash value of the cache entry "item"
+ * TEST  tests if "tmp" matches "item"
+ * INIT copies key information from "item" to "new"
+ * UPDATE copies content information from "item" to "tmp"
+ * INPLACE is true if updates can happen inplace rather than allocating a new structure
+ *
+ * WARNING: any substantial changes to this must be reflected in
+ *   net/sunrpc/svcauth.c(auth_domain_lookup)
+ *  which is a similar routine that is open-coded.
+ */
+#define DefineCacheLookup(RTN,MEMBER,FNAME,ARGS,SETUP,DETAIL,HASHFN,TEST,INIT,UPDATE,INPLACE)   \
+RTN *FNAME ARGS                                                                         \
+{                                                                                       \
+        RTN *tmp, *new=NULL;                                                            \
+        struct cache_head **hp, **head;                                                 \
+        SETUP;                                                                          \
+        head = &(DETAIL)->hash_table[HASHFN];                                           \
+ retry:                                                                                 \
+        if (set||new) write_lock(&(DETAIL)->hash_lock);                                 \
+        else read_lock(&(DETAIL)->hash_lock);                                           \
+        for(hp=head; *hp != NULL; hp = &tmp->MEMBER.next) {                             \
+                tmp = container_of(*hp, RTN, MEMBER);                                   \
+                if (TEST) { /* found a match */                                         \
+                                                                                        \
+                        if (set && !INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags) && !new) \
+                                break;                                                  \
+                                                                                        \
+                        if (new)                                                        \
+                                {INIT;}                                                 \
+                        if (set) {                                                      \
+                                if (!INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags))\
+                                { /* need to swap in new */                             \
+                                        RTN *t2;                                        \
+                                                                                        \
+                                        new->MEMBER.next = tmp->MEMBER.next;            \
+                                        *hp = &new->MEMBER;                             \
+                                        tmp->MEMBER.next = NULL;                        \
+                                        t2 = tmp; tmp = new; new = t2;                  \
+                                }                                                       \
+                                if (test_bit(CACHE_NEGATIVE,  &item->MEMBER.flags))     \
+                                        set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);    \
+                                else {                                                  \
+                                        UPDATE;                                         \
+                                        clear_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);  \
+                                }                                                       \
+                        }                                                               \
+                        cache_get(&tmp->MEMBER);                                        \
+                        if (set||new) write_unlock(&(DETAIL)->hash_lock);               \
+                        else read_unlock(&(DETAIL)->hash_lock);                         \
+                        if (set)                                                        \
+                                cache_fresh(DETAIL, &tmp->MEMBER, item->MEMBER.expiry_time); \
+                        if (set && !INPLACE && new) cache_fresh(DETAIL, &new->MEMBER, 0);       \
+                        if (new) (DETAIL)->cache_put(&new->MEMBER, DETAIL);             \
+                        return tmp;                                                     \
+                }                                                                       \
+        }                                                                               \
+        /* Didn't find anything */                                                      \
+        if (new) {                                                                      \
+                INIT;                                                                   \
+                new->MEMBER.next = *head;                                               \
+                *head = &new->MEMBER;                                                   \
+                (DETAIL)->entries ++;                                                   \
+                cache_get(&new->MEMBER);                                                \
+                if (set) {                                                              \
+                        tmp = new;                                                      \
+                        if (test_bit(CACHE_NEGATIVE, &item->MEMBER.flags))              \
+                                set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);            \
+                        else {UPDATE;}                                                  \
+                }                                                                       \
+        }                                                                               \
+        if (set||new) write_unlock(&(DETAIL)->hash_lock);                               \
+        else read_unlock(&(DETAIL)->hash_lock);                                         \
+        if (new && set)                                                                 \
+                cache_fresh(DETAIL, &new->MEMBER, item->MEMBER.expiry_time);            \
+        if (new)                                                                        \
+                return new;                                                             \
+        new = kmalloc(sizeof(*new), GFP_KERNEL);                                        \
+        if (new) {                                                                      \
+                cache_init(&new->MEMBER);                                               \
+                goto retry;                                                             \
+        }                                                                               \
+        return NULL;                                                                    \
+}
+
+#define DefineSimpleCacheLookup(STRUCT,INPLACE) \
+        DefineCacheLookup(struct STRUCT, h, STRUCT##_lookup, (struct STRUCT *item, int set), /*no setup */,     \
+                          & STRUCT##_cache, STRUCT##_hash(item), STRUCT##_match(item, tmp),\
+                          STRUCT##_init(new, item), STRUCT##_update(tmp, item),INPLACE)
+
+#define cache_for_each(pos, detail, index, member)                                              \
+        for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ;                \
+             ({if (index==0)read_unlock(&(detail)->hash_lock); index--;});                      \
+                )                                                                               \
+                for (pos = container_of((detail)->hash_table[index], typeof(*pos), member);     \
+                     &pos->member;                                                              \
+                     pos = container_of(pos->member.next, typeof(*pos), member))
+
+             
+
+extern void cache_clean_deferred(void *owner);
+
+static inline struct cache_head  *cache_get(struct cache_head *h)
+{
+        atomic_inc(&h->refcnt);
+        return h;
+}
+
+
+static inline int cache_put(struct cache_head *h, struct cache_detail *cd)
+{
+        if (atomic_read(&h->refcnt) <= 2 &&
+            h->expiry_time < cd->nextcheck)
+                cd->nextcheck = h->expiry_time;
+        return atomic_dec_and_test(&h->refcnt);
+}
+
+extern void cache_init(struct cache_head *h);
+extern void cache_fresh(struct cache_detail *detail,
+                        struct cache_head *head, time_t expiry);
+extern int cache_check(struct cache_detail *detail,
+                       struct cache_head *h, struct cache_req *rqstp);
+extern void cache_flush(void);
+extern void cache_purge(struct cache_detail *detail);
+#define NEVER (0x7FFFFFFF)
+extern void cache_register(struct cache_detail *cd);
+extern int cache_unregister(struct cache_detail *cd);
+
+extern void qword_add(char **bpp, int *lp, char *str);
+extern void qword_addhex(char **bpp, int *lp, char *buf, int blen);
+extern int qword_get(char **bpp, char *dest, int bufsize);
+
+static inline int get_int(char **bpp, int *anint)
+{
+        char buf[50];
+        char *ep;
+        int rv;
+        int len = qword_get(bpp, buf, 50);
+        if (len < 0) return -EINVAL;
+        if (len ==0) return -ENOENT;
+        rv = simple_strtol(buf, &ep, 0);
+        if (*ep) return -EINVAL;
+        *anint = rv;
+        return 0;
+}
+
+static inline time_t get_expiry(char **bpp)
+{
+        int rv;
+        if (get_int(bpp, &rv))
+                return 0;
+        if (rv < 0)
+                return 0;
+        return rv;
+}
+
+#endif /*  _LINUX_SUNRPC_CACHE_H_ */
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
new file mode 100644
index 000000000000..2709caf4d128
--- /dev/null
+++ b/include/linux/sunrpc/clnt.h
@@ -0,0 +1,153 @@
+/*
+ *  linux/include/linux/sunrpc/clnt.h
+ *
+ *  Declarations for the high-level RPC client interface
+ *
+ *  Copyright (C) 1995, 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_CLNT_H
+#define _LINUX_SUNRPC_CLNT_H
+
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/sunrpc/sched.h>
+#include <linux/sunrpc/xprt.h>
+#include <linux/sunrpc/auth.h>
+#include <linux/sunrpc/stats.h>
+#include <linux/sunrpc/xdr.h>
+#include <linux/sunrpc/timer.h>
+#include <asm/signal.h>
+
+/*
+ * This defines an RPC port mapping
+ */
+struct rpc_portmap {
+        __u32                   pm_prog;
+        __u32                   pm_vers;
+        __u32                   pm_prot;
+        __u16                   pm_port;
+        unsigned char           pm_binding : 1; /* doing a getport() */
+        struct rpc_wait_queue   pm_bindwait;    /* waiting on getport() */
+};
+
+struct rpc_inode;
+
+/*
+ * The high-level client handle
+ */
+struct rpc_clnt {
+        atomic_t                cl_count;       /* Number of clones */
+        atomic_t                cl_users;       /* number of references */
+        struct rpc_xprt *       cl_xprt;        /* transport */
+        struct rpc_procinfo *   cl_procinfo;    /* procedure info */
+        u32                     cl_maxproc;     /* max procedure number */
+
+        char *                  cl_server;      /* server machine name */
+        char *                  cl_protname;    /* protocol name */
+        struct rpc_auth *       cl_auth;        /* authenticator */
+        struct rpc_stat *       cl_stats;       /* statistics */
+
+        unsigned int            cl_softrtry : 1,/* soft timeouts */
+                                cl_intr     : 1,/* interruptible */
+                                cl_chatty   : 1,/* be verbose */
+                                cl_autobind : 1,/* use getport() */
+                                cl_oneshot  : 1,/* dispose after use */
+                                cl_dead     : 1;/* abandoned */
+
+        struct rpc_rtt *        cl_rtt;         /* RTO estimator data */
+        struct rpc_portmap *    cl_pmap;        /* port mapping */
+
+        int                     cl_nodelen;     /* nodename length */
+        char                    cl_nodename[UNX_MAXNODENAME];
+        char                    cl_pathname[30];/* Path in rpc_pipe_fs */
+        struct dentry *         cl_dentry;      /* inode */
+        struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
+        struct rpc_rtt          cl_rtt_default;
+        struct rpc_portmap      cl_pmap_default;
+        char                    cl_inline_name[32];
+};
+#define cl_timeout              cl_xprt->timeout
+#define cl_prog                 cl_pmap->pm_prog
+#define cl_vers                 cl_pmap->pm_vers
+#define cl_port                 cl_pmap->pm_port
+#define cl_prot                 cl_pmap->pm_prot
+
+/*
+ * General RPC program info
+ */
+#define RPC_MAXVERSION          4
+struct rpc_program {
+        char *                  name;           /* protocol name */
+        u32                     number;         /* program number */
+        unsigned int            nrvers;         /* number of versions */
+        struct rpc_version **   version;        /* version array */
+        struct rpc_stat *       stats;          /* statistics */
+        char *                  pipe_dir_name;  /* path to rpc_pipefs dir */
+};
+
+struct rpc_version {
+        u32                     number;         /* version number */
+        unsigned int            nrprocs;        /* number of procs */
+        struct rpc_procinfo *   procs;          /* procedure array */
+};
+
+/*
+ * Procedure information
+ */
+struct rpc_procinfo {
+        u32                     p_proc;         /* RPC procedure number */
+        kxdrproc_t              p_encode;       /* XDR encode function */
+        kxdrproc_t              p_decode;       /* XDR decode function */
+        unsigned int            p_bufsiz;       /* req. buffer size */
+        unsigned int            p_count;        /* call count */
+        unsigned int            p_timer;        /* Which RTT timer to use */
+};
+
+#define RPC_CONGESTED(clnt)     (RPCXPRT_CONGESTED((clnt)->cl_xprt))
+#define RPC_PEERADDR(clnt)      (&(clnt)->cl_xprt->addr)
+
+#ifdef __KERNEL__
+
+struct rpc_clnt *rpc_create_client(struct rpc_xprt *xprt, char *servname,
+                                struct rpc_program *info,
+                                u32 version, rpc_authflavor_t authflavor);
+struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
+int             rpc_shutdown_client(struct rpc_clnt *);
+int             rpc_destroy_client(struct rpc_clnt *);
+void            rpc_release_client(struct rpc_clnt *);
+void            rpc_getport(struct rpc_task *, struct rpc_clnt *);
+int             rpc_register(u32, u32, int, unsigned short, int *);
+
+void            rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
+
+int             rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg,
+                               int flags, rpc_action callback, void *clntdata);
+int             rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg,
+                              int flags);
+void            rpc_restart_call(struct rpc_task *);
+void            rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset);
+void            rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset);
+void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
+size_t          rpc_max_payload(struct rpc_clnt *);
+
+static __inline__
+int rpc_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp, int flags)
+{
+        struct rpc_message msg = {
+                .rpc_proc       = &clnt->cl_procinfo[proc],
+                .rpc_argp       = argp,
+                .rpc_resp       = resp,
+                .rpc_cred       = NULL
+        };
+        return rpc_call_sync(clnt, &msg, flags);
+}
+                
+extern void rpciod_wake_up(void);
+
+/*
+ * Helper function for NFSroot support
+ */
+int             rpc_getport_external(struct sockaddr_in *, __u32, __u32, int);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_CLNT_H */
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
new file mode 100644
index 000000000000..eadb31e3c198
--- /dev/null
+++ b/include/linux/sunrpc/debug.h
@@ -0,0 +1,99 @@
+/*
+ * linux/include/linux/sunrpc/debug.h
+ *
+ * Debugging support for sunrpc module
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_DEBUG_H_
+#define _LINUX_SUNRPC_DEBUG_H_
+
+#include <linux/config.h>
+
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+/*
+ * Enable RPC debugging/profiling.
+ */
+#ifdef CONFIG_SYSCTL
+#define  RPC_DEBUG
+#endif
+/* #define  RPC_PROFILE */
+
+/*
+ * RPC debug facilities
+ */
+#define RPCDBG_XPRT             0x0001
+#define RPCDBG_CALL             0x0002
+#define RPCDBG_DEBUG            0x0004
+#define RPCDBG_NFS              0x0008
+#define RPCDBG_AUTH             0x0010
+#define RPCDBG_PMAP             0x0020
+#define RPCDBG_SCHED            0x0040
+#define RPCDBG_SVCSOCK          0x0100
+#define RPCDBG_SVCDSP           0x0200
+#define RPCDBG_MISC             0x0400
+#define RPCDBG_CACHE            0x0800
+#define RPCDBG_ALL              0x7fff
+
+#ifdef __KERNEL__
+
+/*
+ * Debugging macros etc
+ */
+#ifdef RPC_DEBUG
+extern unsigned int             rpc_debug;
+extern unsigned int             nfs_debug;
+extern unsigned int             nfsd_debug;
+extern unsigned int             nlm_debug;
+#endif
+
+#define dprintk(args...)        dfprintk(FACILITY, ## args)
+
+#undef ifdebug
+#ifdef RPC_DEBUG                        
+# define ifdebug(fac)           if (unlikely(rpc_debug & RPCDBG_##fac))
+# define dfprintk(fac, args...) do { ifdebug(fac) printk(args); } while(0)
+# define RPC_IFDEBUG(x)         x
+#else
+# define ifdebug(fac)           if (0)
+# define dfprintk(fac, args...) do ; while (0)
+# define RPC_IFDEBUG(x)
+#endif
+
+#ifdef RPC_PROFILE
+# define pprintk(args...)       printk(## args)
+#else
+# define pprintk(args...)       do ; while (0)
+#endif
+
+/*
+ * Sysctl interface for RPC debugging
+ */
+#ifdef RPC_DEBUG
+void            rpc_register_sysctl(void);
+void            rpc_unregister_sysctl(void);
+#endif
+
+#endif /* __KERNEL__ */
+
+/*
+ * Declarations for the sysctl debug interface, which allows to read or
+ * change the debug flags for rpc, nfs, nfsd, and lockd. Since the sunrpc
+ * module currently registers its sysctl table dynamically, the sysctl path
+ * for module FOO is <CTL_SUNRPC, CTL_FOODEBUG>.
+ */
+#define CTL_SUNRPC      7249    /* arbitrary and hopefully unused */
+
+enum {
+        CTL_RPCDEBUG = 1,
+        CTL_NFSDEBUG,
+        CTL_NFSDDEBUG,
+        CTL_NLMDEBUG,
+        CTL_SLOTTABLE_UDP,
+        CTL_SLOTTABLE_TCP,
+};
+
+#endif /* _LINUX_SUNRPC_DEBUG_H_ */
diff --git a/include/linux/sunrpc/gss_api.h b/include/linux/sunrpc/gss_api.h
new file mode 100644
index 000000000000..689262f63059
--- /dev/null
+++ b/include/linux/sunrpc/gss_api.h
@@ -0,0 +1,122 @@
+/*
+ * linux/include/linux/gss_api.h
+ *
+ * Somewhat simplified version of the gss api.
+ *
+ * Dug Song <dugsong@monkey.org>
+ * Andy Adamson <andros@umich.edu>
+ * Bruce Fields <bfields@umich.edu>
+ * Copyright (c) 2000 The Regents of the University of Michigan
+ *
+ * $Id$
+ */
+
+#ifndef _LINUX_SUNRPC_GSS_API_H
+#define _LINUX_SUNRPC_GSS_API_H
+
+#ifdef __KERNEL__
+#include <linux/sunrpc/xdr.h>
+#include <linux/uio.h>
+
+/* The mechanism-independent gss-api context: */
+struct gss_ctx {
+        struct gss_api_mech     *mech_type;
+        void                    *internal_ctx_id;
+};
+
+#define GSS_C_NO_BUFFER         ((struct xdr_netobj) 0)
+#define GSS_C_NO_CONTEXT        ((struct gss_ctx *) 0)
+#define GSS_C_NULL_OID          ((struct xdr_netobj) 0)
+
+/*XXX  arbitrary length - is this set somewhere? */
+#define GSS_OID_MAX_LEN 32
+
+/* gss-api prototypes; note that these are somewhat simplified versions of
+ * the prototypes specified in RFC 2744. */
+int gss_import_sec_context(
+                const void*             input_token,
+                size_t                  bufsize,
+                struct gss_api_mech     *mech,
+                struct gss_ctx          **ctx_id);
+u32 gss_get_mic(
+                struct gss_ctx          *ctx_id,
+                u32                     qop,
+                struct xdr_buf          *message,
+                struct xdr_netobj       *mic_token);
+u32 gss_verify_mic(
+                struct gss_ctx          *ctx_id,
+                struct xdr_buf          *message,
+                struct xdr_netobj       *mic_token,
+                u32                     *qstate);
+u32 gss_delete_sec_context(
+                struct gss_ctx          **ctx_id);
+
+u32 gss_pseudoflavor_to_service(struct gss_api_mech *, u32 pseudoflavor);
+char *gss_service_to_auth_domain_name(struct gss_api_mech *, u32 service);
+
+struct pf_desc {
+        u32     pseudoflavor;
+        u32     qop;
+        u32     service;
+        char    *name;
+        char    *auth_domain_name;
+};
+
+/* Different mechanisms (e.g., krb5 or spkm3) may implement gss-api, and
+ * mechanisms may be dynamically registered or unregistered by modules. */
+
+/* Each mechanism is described by the following struct: */
+struct gss_api_mech {
+        struct list_head        gm_list;
+        struct module           *gm_owner;
+        struct xdr_netobj       gm_oid;
+        char                    *gm_name;
+        struct gss_api_ops      *gm_ops;
+        /* pseudoflavors supported by this mechanism: */
+        int                     gm_pf_num;
+        struct pf_desc *        gm_pfs;
+};
+
+/* and must provide the following operations: */
+struct gss_api_ops {
+        int (*gss_import_sec_context)(
+                        const void              *input_token,
+                        size_t                  bufsize,
+                        struct gss_ctx          *ctx_id);
+        u32 (*gss_get_mic)(
+                        struct gss_ctx          *ctx_id,
+                        u32                     qop, 
+                        struct xdr_buf          *message,
+                        struct xdr_netobj       *mic_token);
+        u32 (*gss_verify_mic)(
+                        struct gss_ctx          *ctx_id,
+                        struct xdr_buf          *message,
+                        struct xdr_netobj       *mic_token,
+                        u32                     *qstate);
+        void (*gss_delete_sec_context)(
+                        void                    *internal_ctx_id);
+};
+
+int gss_mech_register(struct gss_api_mech *);
+void gss_mech_unregister(struct gss_api_mech *);
+
+/* returns a mechanism descriptor given an OID, and increments the mechanism's
+ * reference count. */
+struct gss_api_mech * gss_mech_get_by_OID(struct xdr_netobj *);
+
+/* Returns a reference to a mechanism, given a name like "krb5" etc. */
+struct gss_api_mech *gss_mech_get_by_name(const char *);
+
+/* Similar, but get by pseudoflavor. */
+struct gss_api_mech *gss_mech_get_by_pseudoflavor(u32);
+
+/* Just increments the mechanism's reference count and returns its input: */
+struct gss_api_mech * gss_mech_get(struct gss_api_mech *);
+
+/* For every succesful gss_mech_get or gss_mech_get_by_* call there must be a
+ * corresponding call to gss_mech_put. */
+void gss_mech_put(struct gss_api_mech *);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_GSS_API_H */
+
diff --git a/include/linux/sunrpc/gss_asn1.h b/include/linux/sunrpc/gss_asn1.h
new file mode 100644
index 000000000000..3ccecd0ad229
--- /dev/null
+++ b/include/linux/sunrpc/gss_asn1.h
@@ -0,0 +1,81 @@
+/*
+ *  linux/include/linux/sunrpc/gss_asn1.h
+ *
+ *  minimal asn1 for generic encoding/decoding of gss tokens
+ *
+ *  Adapted from MIT Kerberos 5-1.2.1 lib/include/krb5.h,
+ *  lib/gssapi/krb5/gssapiP_krb5.h, and others
+ *
+ *  Copyright (c) 2000 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Andy Adamson   <andros@umich.edu>
+ */
+
+/*
+ * Copyright 1995 by the Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ *   require a specific license from the United States Government.
+ *   It is the responsibility of any person or organization contemplating
+ *   export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, 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 M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ *
+ */
+
+
+#include <linux/sunrpc/gss_api.h>
+
+#define SIZEOF_INT 4
+
+/* from gssapi_err_generic.h */
+#define G_BAD_SERVICE_NAME                       (-2045022976L)
+#define G_BAD_STRING_UID                         (-2045022975L)
+#define G_NOUSER                                 (-2045022974L)
+#define G_VALIDATE_FAILED                        (-2045022973L)
+#define G_BUFFER_ALLOC                           (-2045022972L)
+#define G_BAD_MSG_CTX                            (-2045022971L)
+#define G_WRONG_SIZE                             (-2045022970L)
+#define G_BAD_USAGE                              (-2045022969L)
+#define G_UNKNOWN_QOP                            (-2045022968L)
+#define G_NO_HOSTNAME                            (-2045022967L)
+#define G_BAD_HOSTNAME                           (-2045022966L)
+#define G_WRONG_MECH                             (-2045022965L)
+#define G_BAD_TOK_HEADER                         (-2045022964L)
+#define G_BAD_DIRECTION                          (-2045022963L)
+#define G_TOK_TRUNC                              (-2045022962L)
+#define G_REFLECT                                (-2045022961L)
+#define G_WRONG_TOKID                            (-2045022960L)
+
+#define g_OID_equal(o1,o2) \
+   (((o1)->len == (o2)->len) && \
+    (memcmp((o1)->data,(o2)->data,(int) (o1)->len) == 0))
+
+u32 g_verify_token_header(
+     struct xdr_netobj *mech,
+     int *body_size,
+     unsigned char **buf_in,
+     int toksize);
+
+int g_token_size(
+     struct xdr_netobj *mech,
+     unsigned int body_size);
+
+void g_make_token_header(
+     struct xdr_netobj *mech,
+     int body_size,
+     unsigned char **buf);
diff --git a/include/linux/sunrpc/gss_err.h b/include/linux/sunrpc/gss_err.h
new file mode 100644
index 000000000000..92608a2e574c
--- /dev/null
+++ b/include/linux/sunrpc/gss_err.h
@@ -0,0 +1,177 @@
+/*
+ *  linux/include/sunrpc/gss_err.h
+ *
+ *  Adapted from MIT Kerberos 5-1.2.1 include/gssapi/gssapi.h
+ *
+ *  Copyright (c) 2002 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Andy Adamson   <andros@umich.edu>
+ */
+
+/*
+ * Copyright 1993 by OpenVision Technologies, Inc.
+ * 
+ * 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 appears in all copies and
+ * that both that copyright notice and this permission notice appear in
+ * supporting documentation, and that the name of OpenVision not be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. OpenVision makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ * 
+ * OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL OPENVISION 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.
+ */
+
+#ifndef _LINUX_SUNRPC_GSS_ERR_H
+#define _LINUX_SUNRPC_GSS_ERR_H
+
+#ifdef __KERNEL__
+
+typedef unsigned int OM_uint32;
+
+/*
+ * Flag bits for context-level services.
+ */
+#define GSS_C_DELEG_FLAG 1
+#define GSS_C_MUTUAL_FLAG 2
+#define GSS_C_REPLAY_FLAG 4
+#define GSS_C_SEQUENCE_FLAG 8
+#define GSS_C_CONF_FLAG 16
+#define GSS_C_INTEG_FLAG 32
+#define GSS_C_ANON_FLAG 64
+#define GSS_C_PROT_READY_FLAG 128
+#define GSS_C_TRANS_FLAG 256
+
+/*
+ * Credential usage options
+ */
+#define GSS_C_BOTH 0
+#define GSS_C_INITIATE 1
+#define GSS_C_ACCEPT 2
+
+/*
+ * Status code types for gss_display_status
+ */
+#define GSS_C_GSS_CODE 1
+#define GSS_C_MECH_CODE 2
+
+
+/*
+ * Define the default Quality of Protection for per-message services.  Note
+ * that an implementation that offers multiple levels of QOP may either reserve
+ * a value (for example zero, as assumed here) to mean "default protection", or
+ * alternatively may simply equate GSS_C_QOP_DEFAULT to a specific explicit
+ * QOP value.  However a value of 0 should always be interpreted by a GSSAPI
+ * implementation as a request for the default protection level.
+ */
+#define GSS_C_QOP_DEFAULT 0
+
+/*
+ * Expiration time of 2^32-1 seconds means infinite lifetime for a
+ * credential or security context
+ */
+#define GSS_C_INDEFINITE ((OM_uint32) 0xfffffffful)
+
+
+/* Major status codes */
+
+#define GSS_S_COMPLETE 0
+
+/*
+ * Some "helper" definitions to make the status code macros obvious.
+ */
+#define GSS_C_CALLING_ERROR_OFFSET 24
+#define GSS_C_ROUTINE_ERROR_OFFSET 16
+#define GSS_C_SUPPLEMENTARY_OFFSET 0
+#define GSS_C_CALLING_ERROR_MASK ((OM_uint32) 0377ul)
+#define GSS_C_ROUTINE_ERROR_MASK ((OM_uint32) 0377ul)
+#define GSS_C_SUPPLEMENTARY_MASK ((OM_uint32) 0177777ul)
+
+/*
+ * The macros that test status codes for error conditions.  Note that the
+ * GSS_ERROR() macro has changed slightly from the V1 GSSAPI so that it now
+ * evaluates its argument only once.
+ */
+#define GSS_CALLING_ERROR(x) \
+  ((x) & (GSS_C_CALLING_ERROR_MASK << GSS_C_CALLING_ERROR_OFFSET))
+#define GSS_ROUTINE_ERROR(x) \
+  ((x) & (GSS_C_ROUTINE_ERROR_MASK << GSS_C_ROUTINE_ERROR_OFFSET))
+#define GSS_SUPPLEMENTARY_INFO(x) \
+  ((x) & (GSS_C_SUPPLEMENTARY_MASK << GSS_C_SUPPLEMENTARY_OFFSET))
+#define GSS_ERROR(x) \
+  ((x) & ((GSS_C_CALLING_ERROR_MASK << GSS_C_CALLING_ERROR_OFFSET) | \
+          (GSS_C_ROUTINE_ERROR_MASK << GSS_C_ROUTINE_ERROR_OFFSET)))
+
+/*
+ * Now the actual status code definitions
+ */
+
+/*
+ * Calling errors:
+ */
+#define GSS_S_CALL_INACCESSIBLE_READ \
+                             (((OM_uint32) 1ul) << GSS_C_CALLING_ERROR_OFFSET)
+#define GSS_S_CALL_INACCESSIBLE_WRITE \
+                             (((OM_uint32) 2ul) << GSS_C_CALLING_ERROR_OFFSET)
+#define GSS_S_CALL_BAD_STRUCTURE \
+                             (((OM_uint32) 3ul) << GSS_C_CALLING_ERROR_OFFSET)
+
+/*
+ * Routine errors:
+ */
+#define GSS_S_BAD_MECH (((OM_uint32) 1ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_NAME (((OM_uint32) 2ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_NAMETYPE (((OM_uint32) 3ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_BINDINGS (((OM_uint32) 4ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_STATUS (((OM_uint32) 5ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_SIG (((OM_uint32) 6ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_NO_CRED (((OM_uint32) 7ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_NO_CONTEXT (((OM_uint32) 8ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_DEFECTIVE_TOKEN (((OM_uint32) 9ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_DEFECTIVE_CREDENTIAL \
+     (((OM_uint32) 10ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_CREDENTIALS_EXPIRED \
+     (((OM_uint32) 11ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_CONTEXT_EXPIRED \
+     (((OM_uint32) 12ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_FAILURE (((OM_uint32) 13ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_BAD_QOP (((OM_uint32) 14ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_UNAUTHORIZED (((OM_uint32) 15ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_UNAVAILABLE (((OM_uint32) 16ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_DUPLICATE_ELEMENT \
+     (((OM_uint32) 17ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+#define GSS_S_NAME_NOT_MN \
+     (((OM_uint32) 18ul) << GSS_C_ROUTINE_ERROR_OFFSET)
+
+/*
+ * Supplementary info bits:
+ */
+#define GSS_S_CONTINUE_NEEDED (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 0))
+#define GSS_S_DUPLICATE_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 1))
+#define GSS_S_OLD_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 2))
+#define GSS_S_UNSEQ_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 3))
+#define GSS_S_GAP_TOKEN (1 << (GSS_C_SUPPLEMENTARY_OFFSET + 4))
+
+/* XXXX these are not part of the GSSAPI C bindings!  (but should be) */
+
+#define GSS_CALLING_ERROR_FIELD(x) \
+   (((x) >> GSS_C_CALLING_ERROR_OFFSET) & GSS_C_CALLING_ERROR_MASK)
+#define GSS_ROUTINE_ERROR_FIELD(x) \
+   (((x) >> GSS_C_ROUTINE_ERROR_OFFSET) & GSS_C_ROUTINE_ERROR_MASK)
+#define GSS_SUPPLEMENTARY_INFO_FIELD(x) \
+   (((x) >> GSS_C_SUPPLEMENTARY_OFFSET) & GSS_C_SUPPLEMENTARY_MASK)
+
+/* XXXX This is a necessary evil until the spec is fixed */
+#define GSS_S_CRED_UNAVAIL GSS_S_FAILURE
+
+#endif /* __KERNEL__ */
+#endif /* __LINUX_SUNRPC_GSS_ERR_H */
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
new file mode 100644
index 000000000000..ffe31d2eb9ec
--- /dev/null
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -0,0 +1,148 @@
+/*
+ *  linux/include/linux/sunrpc/gss_krb5_types.h
+ *
+ *  Adapted from MIT Kerberos 5-1.2.1 lib/include/krb5.h,
+ *  lib/gssapi/krb5/gssapiP_krb5.h, and others
+ *
+ *  Copyright (c) 2000 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Andy Adamson   <andros@umich.edu>
+ *  Bruce Fields   <bfields@umich.edu>
+ */
+
+/*
+ * Copyright 1995 by the Massachusetts Institute of Technology.
+ * All Rights Reserved.
+ *
+ * Export of this software from the United States of America may
+ *   require a specific license from the United States Government.
+ *   It is the responsibility of any person or organization contemplating
+ *   export to obtain such a license before exporting.
+ *
+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
+ * distribute this software and its documentation for any purpose and
+ * without fee is hereby granted, 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 M.I.T. not be used in advertising or publicity pertaining
+ * to distribution of the software without specific, written prior
+ * permission.  Furthermore if you modify this software you must label
+ * your software as modified software and not distribute it in such a
+ * fashion that it might be confused with the original M.I.T. software.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ *
+ */
+
+#include <linux/sunrpc/auth_gss.h>
+#include <linux/sunrpc/gss_err.h>
+#include <linux/sunrpc/gss_asn1.h>
+
+struct krb5_ctx {
+        int                     initiate; /* 1 = initiating, 0 = accepting */
+        int                     seed_init;
+        unsigned char           seed[16];
+        int                     signalg;
+        int                     sealalg;
+        struct crypto_tfm       *enc;
+        struct crypto_tfm       *seq;
+        s32                     endtime;
+        u32                     seq_send;
+        struct xdr_netobj       mech_used;
+};
+
+#define KG_TOK_MIC_MSG    0x0101
+#define KG_TOK_WRAP_MSG   0x0201
+
+enum sgn_alg {
+        SGN_ALG_DES_MAC_MD5 = 0x0000,
+        SGN_ALG_MD2_5 = 0x0001,
+        SGN_ALG_DES_MAC = 0x0002,
+        SGN_ALG_3 = 0x0003,             /* not published */
+        SGN_ALG_HMAC_MD5 = 0x0011,      /* microsoft w2k; no support */
+        SGN_ALG_HMAC_SHA1_DES3_KD = 0x0004
+};
+enum seal_alg {
+        SEAL_ALG_NONE = 0xffff,
+        SEAL_ALG_DES = 0x0000,
+        SEAL_ALG_1 = 0x0001,            /* not published */
+        SEAL_ALG_MICROSOFT_RC4 = 0x0010,/* microsoft w2k; no support */
+        SEAL_ALG_DES3KD = 0x0002
+};
+
+#define KRB5_CKSUM_LENGTH 8
+
+#define CKSUMTYPE_CRC32                 0x0001
+#define CKSUMTYPE_RSA_MD4               0x0002
+#define CKSUMTYPE_RSA_MD4_DES           0x0003
+#define CKSUMTYPE_DESCBC                0x0004
+#define CKSUMTYPE_RSA_MD5               0x0007
+#define CKSUMTYPE_RSA_MD5_DES           0x0008
+#define CKSUMTYPE_NIST_SHA              0x0009
+#define CKSUMTYPE_HMAC_SHA1_DES3        0x000c
+
+/* from gssapi_err_krb5.h */
+#define KG_CCACHE_NOMATCH                        (39756032L)
+#define KG_KEYTAB_NOMATCH                        (39756033L)
+#define KG_TGT_MISSING                           (39756034L)
+#define KG_NO_SUBKEY                             (39756035L)
+#define KG_CONTEXT_ESTABLISHED                   (39756036L)
+#define KG_BAD_SIGN_TYPE                         (39756037L)
+#define KG_BAD_LENGTH                            (39756038L)
+#define KG_CTX_INCOMPLETE                        (39756039L)
+#define KG_CONTEXT                               (39756040L)
+#define KG_CRED                                  (39756041L)
+#define KG_ENC_DESC                              (39756042L)
+#define KG_BAD_SEQ                               (39756043L)
+#define KG_EMPTY_CCACHE                          (39756044L)
+#define KG_NO_CTYPES                             (39756045L)
+
+/* per Kerberos v5 protocol spec crypto types from the wire. 
+ * these get mapped to linux kernel crypto routines.  
+ */
+#define ENCTYPE_NULL            0x0000
+#define ENCTYPE_DES_CBC_CRC     0x0001  /* DES cbc mode with CRC-32 */
+#define ENCTYPE_DES_CBC_MD4     0x0002  /* DES cbc mode with RSA-MD4 */
+#define ENCTYPE_DES_CBC_MD5     0x0003  /* DES cbc mode with RSA-MD5 */
+#define ENCTYPE_DES_CBC_RAW     0x0004  /* DES cbc mode raw */
+/* XXX deprecated? */
+#define ENCTYPE_DES3_CBC_SHA    0x0005  /* DES-3 cbc mode with NIST-SHA */
+#define ENCTYPE_DES3_CBC_RAW    0x0006  /* DES-3 cbc mode raw */
+#define ENCTYPE_DES_HMAC_SHA1   0x0008
+#define ENCTYPE_DES3_CBC_SHA1   0x0010
+#define ENCTYPE_UNKNOWN         0x01ff
+
+s32
+make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body,
+                   struct xdr_netobj *cksum);
+
+u32
+krb5_make_token(struct krb5_ctx *context_handle, int qop_req,
+        struct xdr_buf *input_message_buffer,
+        struct xdr_netobj *output_message_buffer, int toktype);
+
+u32
+krb5_read_token(struct krb5_ctx *context_handle,
+          struct xdr_netobj *input_token_buffer,
+          struct xdr_buf *message_buffer,
+          int *qop_state, int toktype);
+
+u32
+krb5_encrypt(struct crypto_tfm * key,
+             void *iv, void *in, void *out, int length);
+
+u32
+krb5_decrypt(struct crypto_tfm * key,
+             void *iv, void *in, void *out, int length); 
+
+s32
+krb5_make_seq_num(struct crypto_tfm * key,
+                int direction,
+                s32 seqnum, unsigned char *cksum, unsigned char *buf);
+
+s32
+krb5_get_seq_num(struct crypto_tfm * key,
+               unsigned char *cksum,
+               unsigned char *buf, int *direction, s32 * seqnum);
diff --git a/include/linux/sunrpc/gss_spkm3.h b/include/linux/sunrpc/gss_spkm3.h
new file mode 100644
index 000000000000..b5c9968c3c17
--- /dev/null
+++ b/include/linux/sunrpc/gss_spkm3.h
@@ -0,0 +1,61 @@
+/*
+ *  linux/include/linux/sunrpc/gss_spkm3.h
+ *
+ *  Copyright (c) 2000 The Regents of the University of Michigan.
+ *  All rights reserved.
+ *
+ *  Andy Adamson   <andros@umich.edu>
+ */
+
+#include <linux/sunrpc/auth_gss.h>
+#include <linux/sunrpc/gss_err.h>
+#include <linux/sunrpc/gss_asn1.h>
+
+struct spkm3_ctx {
+        struct xdr_netobj       ctx_id; /* per message context id */
+        int                     qop;         /* negotiated qop */
+        struct xdr_netobj       mech_used;
+        unsigned int            ret_flags ;
+        unsigned int            req_flags ;
+        struct xdr_netobj       share_key;
+        int                     conf_alg;
+        struct crypto_tfm*      derived_conf_key;
+        int                     intg_alg;
+        struct crypto_tfm*      derived_integ_key;
+        int                     keyestb_alg;   /* alg used to get share_key */
+        int                     owf_alg;   /* one way function */
+};
+
+/* from openssl/objects.h */
+/* XXX need SEAL_ALG_NONE */
+#define NID_md5         4
+#define NID_dhKeyAgreement      28 
+#define NID_des_cbc             31 
+#define NID_sha1                64
+#define NID_cast5_cbc           108
+
+/* SPKM InnerContext Token types */
+
+#define SPKM_ERROR_TOK  3
+#define SPKM_MIC_TOK    4
+#define SPKM_WRAP_TOK   5
+#define SPKM_DEL_TOK    6
+
+u32 spkm3_make_token(struct spkm3_ctx *ctx, int qop_req, struct xdr_buf * text, struct xdr_netobj * token, int toktype);
+
+u32 spkm3_read_token(struct spkm3_ctx *ctx, struct xdr_netobj *read_token, struct xdr_buf *message_buffer, int *qop_state, int toktype);
+
+#define CKSUMTYPE_RSA_MD5            0x0007
+
+s32 make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body,
+                   struct xdr_netobj *cksum);
+void asn1_bitstring_len(struct xdr_netobj *in, int *enclen, int *zerobits);
+int decode_asn1_bitstring(struct xdr_netobj *out, char *in, int enclen, 
+                   int explen);
+void spkm3_mic_header(unsigned char **hdrbuf, unsigned int *hdrlen, 
+                   unsigned char *ctxhdr, int elen, int zbit);
+void spkm3_make_mic_token(unsigned  char **tokp, int toklen, 
+                   struct xdr_netobj *mic_hdr,
+                   struct xdr_netobj *md5cksum, int md5elen, int md5zbit);
+u32 spkm3_verify_mic_token(unsigned char **tokp, int *mic_hdrlen, 
+                   unsigned char **cksum);
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
new file mode 100644
index 000000000000..15f115332389
--- /dev/null
+++ b/include/linux/sunrpc/msg_prot.h
@@ -0,0 +1,80 @@
+/*
+ * linux/include/net/sunrpc/msg_prot.h
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_MSGPROT_H_
+#define _LINUX_SUNRPC_MSGPROT_H_
+
+#ifdef __KERNEL__ /* user programs should get these from the rpc header files */
+
+#define RPC_VERSION 2
+
+/* spec defines authentication flavor as an unsigned 32 bit integer */
+typedef u32     rpc_authflavor_t;
+
+enum rpc_auth_flavors {
+        RPC_AUTH_NULL  = 0,
+        RPC_AUTH_UNIX  = 1,
+        RPC_AUTH_SHORT = 2,
+        RPC_AUTH_DES   = 3,
+        RPC_AUTH_KRB   = 4,
+        RPC_AUTH_GSS   = 6,
+        RPC_AUTH_MAXFLAVOR = 8,
+        /* pseudoflavors: */
+        RPC_AUTH_GSS_KRB5  = 390003,
+        RPC_AUTH_GSS_KRB5I = 390004,
+        RPC_AUTH_GSS_KRB5P = 390005,
+        RPC_AUTH_GSS_LKEY  = 390006,
+        RPC_AUTH_GSS_LKEYI = 390007,
+        RPC_AUTH_GSS_LKEYP = 390008,
+        RPC_AUTH_GSS_SPKM  = 390009,
+        RPC_AUTH_GSS_SPKMI = 390010,
+        RPC_AUTH_GSS_SPKMP = 390011,
+};
+
+enum rpc_msg_type {
+        RPC_CALL = 0,
+        RPC_REPLY = 1
+};
+
+enum rpc_reply_stat {
+        RPC_MSG_ACCEPTED = 0,
+        RPC_MSG_DENIED = 1
+};
+
+enum rpc_accept_stat {
+        RPC_SUCCESS = 0,
+        RPC_PROG_UNAVAIL = 1,
+        RPC_PROG_MISMATCH = 2,
+        RPC_PROC_UNAVAIL = 3,
+        RPC_GARBAGE_ARGS = 4,
+        RPC_SYSTEM_ERR = 5
+};
+
+enum rpc_reject_stat {
+        RPC_MISMATCH = 0,
+        RPC_AUTH_ERROR = 1
+};
+
+enum rpc_auth_stat {
+        RPC_AUTH_OK = 0,
+        RPC_AUTH_BADCRED = 1,
+        RPC_AUTH_REJECTEDCRED = 2,
+        RPC_AUTH_BADVERF = 3,
+        RPC_AUTH_REJECTEDVERF = 4,
+        RPC_AUTH_TOOWEAK = 5,
+        /* RPCSEC_GSS errors */
+        RPCSEC_GSS_CREDPROBLEM = 13,
+        RPCSEC_GSS_CTXPROBLEM = 14
+};
+
+#define RPC_PMAP_PROGRAM        100000
+#define RPC_PMAP_VERSION        2
+#define RPC_PMAP_PORT           111
+
+#define RPC_MAXNETNAMELEN       256
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_MSGPROT_H_ */
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
new file mode 100644
index 000000000000..63929349571f
--- /dev/null
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -0,0 +1,50 @@
+#ifndef _LINUX_SUNRPC_RPC_PIPE_FS_H
+#define _LINUX_SUNRPC_RPC_PIPE_FS_H
+
+#ifdef __KERNEL__
+
+struct rpc_pipe_msg {
+        struct list_head list;
+        void *data;
+        size_t len;
+        size_t copied;
+        int errno;
+};
+
+struct rpc_pipe_ops {
+        ssize_t (*upcall)(struct file *, struct rpc_pipe_msg *, char __user *, size_t);
+        ssize_t (*downcall)(struct file *, const char __user *, size_t);
+        void (*release_pipe)(struct inode *);
+        void (*destroy_msg)(struct rpc_pipe_msg *);
+};
+
+struct rpc_inode {
+        struct inode vfs_inode;
+        void *private;
+        struct list_head pipe;
+        struct list_head in_upcall;
+        int pipelen;
+        int nreaders;
+        int nwriters;
+        wait_queue_head_t waitq;
+#define RPC_PIPE_WAIT_FOR_OPEN  1
+        int flags;
+        struct rpc_pipe_ops *ops;
+        struct work_struct queue_timeout;
+};
+
+static inline struct rpc_inode *
+RPC_I(struct inode *inode)
+{
+        return container_of(inode, struct rpc_inode, vfs_inode);
+}
+
+extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *);
+
+extern struct dentry *rpc_mkdir(char *, struct rpc_clnt *);
+extern int rpc_rmdir(char *);
+extern struct dentry *rpc_mkpipe(char *, void *, struct rpc_pipe_ops *, int flags);
+extern int rpc_unlink(char *);
+
+#endif
+#endif
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
new file mode 100644
index 000000000000..99d17ed7cebb
--- /dev/null
+++ b/include/linux/sunrpc/sched.h
@@ -0,0 +1,273 @@
+/*
+ * linux/include/linux/sunrpc/sched.h
+ *
+ * Scheduling primitives for kernel Sun RPC.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_SCHED_H_
+#define _LINUX_SUNRPC_SCHED_H_
+
+#include <linux/timer.h>
+#include <linux/sunrpc/types.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+#include <linux/sunrpc/xdr.h>
+
+/*
+ * This is the actual RPC procedure call info.
+ */
+struct rpc_procinfo;
+struct rpc_message {
+        struct rpc_procinfo *   rpc_proc;       /* Procedure information */
+        void *                  rpc_argp;       /* Arguments */
+        void *                  rpc_resp;       /* Result */
+        struct rpc_cred *       rpc_cred;       /* Credentials */
+};
+
+struct rpc_wait_queue;
+struct rpc_wait {
+        struct list_head        list;           /* wait queue links */
+        struct list_head        links;          /* Links to related tasks */
+        wait_queue_head_t       waitq;          /* sync: sleep on this q */
+        struct rpc_wait_queue * rpc_waitq;      /* RPC wait queue we're on */
+};
+
+/*
+ * This is the RPC task struct
+ */
+struct rpc_task {
+#ifdef RPC_DEBUG
+        unsigned long           tk_magic;       /* 0xf00baa */
+#endif
+        struct list_head        tk_task;        /* global list of tasks */
+        struct rpc_clnt *       tk_client;      /* RPC client */
+        struct rpc_rqst *       tk_rqstp;       /* RPC request */
+        int                     tk_status;      /* result of last operation */
+
+        /*
+         * RPC call state
+         */
+        struct rpc_message      tk_msg;         /* RPC call info */
+        __u32 *                 tk_buffer;      /* XDR buffer */
+        size_t                  tk_bufsize;
+        __u8                    tk_garb_retry;
+        __u8                    tk_cred_retry;
+
+        unsigned long           tk_cookie;      /* Cookie for batching tasks */
+
+        /*
+         * timeout_fn   to be executed by timer bottom half
+         * callback     to be executed after waking up
+         * action       next procedure for async tasks
+         * exit         exit async task and report to caller
+         */
+        void                    (*tk_timeout_fn)(struct rpc_task *);
+        void                    (*tk_callback)(struct rpc_task *);
+        void                    (*tk_action)(struct rpc_task *);
+        void                    (*tk_exit)(struct rpc_task *);
+        void                    (*tk_release)(struct rpc_task *);
+        void *                  tk_calldata;
+
+        /*
+         * tk_timer is used for async processing by the RPC scheduling
+         * primitives. You should not access this directly unless
+         * you have a pathological interest in kernel oopses.
+         */
+        struct timer_list       tk_timer;       /* kernel timer */
+        unsigned long           tk_timeout;     /* timeout for rpc_sleep() */
+        unsigned short          tk_flags;       /* misc flags */
+        unsigned char           tk_active   : 1;/* Task has been activated */
+        unsigned char           tk_priority : 2;/* Task priority */
+        unsigned long           tk_runstate;    /* Task run status */
+        struct workqueue_struct *tk_workqueue;  /* Normally rpciod, but could
+                                                 * be any workqueue
+                                                 */
+        union {
+                struct work_struct      tk_work;        /* Async task work queue */
+                struct rpc_wait         tk_wait;        /* RPC wait */
+        } u;
+#ifdef RPC_DEBUG
+        unsigned short          tk_pid;         /* debugging aid */
+#endif
+};
+#define tk_auth                 tk_client->cl_auth
+#define tk_xprt                 tk_client->cl_xprt
+
+/* support walking a list of tasks on a wait queue */
+#define task_for_each(task, pos, head) \
+        list_for_each(pos, head) \
+                if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)
+
+#define task_for_first(task, head) \
+        if (!list_empty(head) &&  \
+            ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
+
+/* .. and walking list of all tasks */
+#define alltask_for_each(task, pos, head) \
+        list_for_each(pos, head) \
+                if ((task=list_entry(pos, struct rpc_task, tk_task)),1)
+
+typedef void                    (*rpc_action)(struct rpc_task *);
+
+/*
+ * RPC task flags
+ */
+#define RPC_TASK_ASYNC          0x0001          /* is an async task */
+#define RPC_TASK_SWAPPER        0x0002          /* is swapping in/out */
+#define RPC_TASK_CHILD          0x0008          /* is child of other task */
+#define RPC_CALL_MAJORSEEN      0x0020          /* major timeout seen */
+#define RPC_TASK_ROOTCREDS      0x0040          /* force root creds */
+#define RPC_TASK_DYNAMIC        0x0080          /* task was kmalloc'ed */
+#define RPC_TASK_KILLED         0x0100          /* task was killed */
+#define RPC_TASK_SOFT           0x0200          /* Use soft timeouts */
+#define RPC_TASK_NOINTR         0x0400          /* uninterruptible task */
+
+#define RPC_IS_ASYNC(t)         ((t)->tk_flags & RPC_TASK_ASYNC)
+#define RPC_IS_CHILD(t)         ((t)->tk_flags & RPC_TASK_CHILD)
+#define RPC_IS_SWAPPER(t)       ((t)->tk_flags & RPC_TASK_SWAPPER)
+#define RPC_DO_ROOTOVERRIDE(t)  ((t)->tk_flags & RPC_TASK_ROOTCREDS)
+#define RPC_ASSASSINATED(t)     ((t)->tk_flags & RPC_TASK_KILLED)
+#define RPC_IS_ACTIVATED(t)     ((t)->tk_active)
+#define RPC_DO_CALLBACK(t)      ((t)->tk_callback != NULL)
+#define RPC_IS_SOFT(t)          ((t)->tk_flags & RPC_TASK_SOFT)
+#define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR)
+
+#define RPC_TASK_RUNNING        0
+#define RPC_TASK_QUEUED         1
+#define RPC_TASK_WAKEUP         2
+#define RPC_TASK_HAS_TIMER      3
+
+#define RPC_IS_RUNNING(t)       (test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
+#define rpc_set_running(t)      (set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
+#define rpc_test_and_set_running(t) \
+                                (test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
+#define rpc_clear_running(t)    \
+        do { \
+                smp_mb__before_clear_bit(); \
+                clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \
+                smp_mb__after_clear_bit(); \
+        } while (0)
+
+#define RPC_IS_QUEUED(t)        (test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate))
+#define rpc_set_queued(t)       (set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate))
+#define rpc_clear_queued(t)     \
+        do { \
+                smp_mb__before_clear_bit(); \
+                clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \
+                smp_mb__after_clear_bit(); \
+        } while (0)
+
+#define rpc_start_wakeup(t) \
+        (test_and_set_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate) == 0)
+#define rpc_finish_wakeup(t) \
+        do { \
+                smp_mb__before_clear_bit(); \
+                clear_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate); \
+                smp_mb__after_clear_bit(); \
+        } while (0)
+
+/*
+ * Task priorities.
+ * Note: if you change these, you must also change
+ * the task initialization definitions below.
+ */
+#define RPC_PRIORITY_LOW        0
+#define RPC_PRIORITY_NORMAL     1
+#define RPC_PRIORITY_HIGH       2
+#define RPC_NR_PRIORITY         (RPC_PRIORITY_HIGH+1)
+
+/*
+ * RPC synchronization objects
+ */
+struct rpc_wait_queue {
+        spinlock_t              lock;
+        struct list_head        tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */
+        unsigned long           cookie;                 /* cookie of last task serviced */
+        unsigned char           maxpriority;            /* maximum priority (0 if queue is not a priority queue) */
+        unsigned char           priority;               /* current priority */
+        unsigned char           count;                  /* # task groups remaining serviced so far */
+        unsigned char           nr;                     /* # tasks remaining for cookie */
+#ifdef RPC_DEBUG
+        const char *            name;
+#endif
+};
+
+/*
+ * This is the # requests to send consecutively
+ * from a single cookie.  The aim is to improve
+ * performance of NFS operations such as read/write.
+ */
+#define RPC_BATCH_COUNT                 16
+
+#ifndef RPC_DEBUG
+# define RPC_WAITQ_INIT(var,qname) { \
+                .lock = SPIN_LOCK_UNLOCKED, \
+                .tasks = { \
+                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
+                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
+                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
+                }, \
+        }
+#else
+# define RPC_WAITQ_INIT(var,qname) { \
+                .lock = SPIN_LOCK_UNLOCKED, \
+                .tasks = { \
+                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
+                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
+                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
+                }, \
+                .name = qname, \
+        }
+#endif
+# define RPC_WAITQ(var,qname)      struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname)
+
+#define RPC_IS_PRIORITY(q)              ((q)->maxpriority > 0)
+
+/*
+ * Function prototypes
+ */
+struct rpc_task *rpc_new_task(struct rpc_clnt *, rpc_action, int flags);
+struct rpc_task *rpc_new_child(struct rpc_clnt *, struct rpc_task *parent);
+void            rpc_init_task(struct rpc_task *, struct rpc_clnt *,
+                                        rpc_action exitfunc, int flags);
+void            rpc_release_task(struct rpc_task *);
+void            rpc_killall_tasks(struct rpc_clnt *);
+int             rpc_execute(struct rpc_task *);
+void            rpc_run_child(struct rpc_task *parent, struct rpc_task *child,
+                                        rpc_action action);
+void            rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *);
+void            rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
+void            rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
+                                        rpc_action action, rpc_action timer);
+void            rpc_wake_up_task(struct rpc_task *);
+void            rpc_wake_up(struct rpc_wait_queue *);
+struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
+void            rpc_wake_up_status(struct rpc_wait_queue *, int);
+void            rpc_delay(struct rpc_task *, unsigned long);
+void *          rpc_malloc(struct rpc_task *, size_t);
+int             rpciod_up(void);
+void            rpciod_down(void);
+void            rpciod_wake_up(void);
+#ifdef RPC_DEBUG
+void            rpc_show_tasks(void);
+#endif
+int             rpc_init_mempool(void);
+void            rpc_destroy_mempool(void);
+
+static inline void rpc_exit(struct rpc_task *task, int status)
+{
+        task->tk_status = status;
+        task->tk_action = NULL;
+}
+
+#ifdef RPC_DEBUG
+static inline const char * rpc_qname(struct rpc_wait_queue *q)
+{
+        return ((q && q->name) ? q->name : "unknown");
+}
+#endif
+
+#endif /* _LINUX_SUNRPC_SCHED_H_ */
diff --git a/include/linux/sunrpc/stats.h b/include/linux/sunrpc/stats.h
new file mode 100644
index 000000000000..0d6ed3c8bdc4
--- /dev/null
+++ b/include/linux/sunrpc/stats.h
@@ -0,0 +1,78 @@
+/*
+ * linux/include/linux/sunrpc/stats.h
+ *
+ * Client statistics collection for SUN RPC
+ *
+ * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_STATS_H
+#define _LINUX_SUNRPC_STATS_H
+
+#include <linux/config.h>
+#include <linux/proc_fs.h>
+
+struct rpc_stat {
+        struct rpc_program *    program;
+
+        unsigned int            netcnt,
+                                netudpcnt,
+                                nettcpcnt,
+                                nettcpconn,
+                                netreconn;
+        unsigned int            rpccnt,
+                                rpcretrans,
+                                rpcauthrefresh,
+                                rpcgarbage;
+};
+
+struct svc_stat {
+        struct svc_program *    program;
+
+        unsigned int            netcnt,
+                                netudpcnt,
+                                nettcpcnt,
+                                nettcpconn;
+        unsigned int            rpccnt,
+                                rpcbadfmt,
+                                rpcbadauth,
+                                rpcbadclnt;
+};
+
+void                    rpc_proc_init(void);
+void                    rpc_proc_exit(void);
+#ifdef MODULE
+void                    rpc_modcount(struct inode *, int);
+#endif
+
+#ifdef CONFIG_PROC_FS
+struct proc_dir_entry * rpc_proc_register(struct rpc_stat *);
+void                    rpc_proc_unregister(const char *);
+void                    rpc_proc_zero(struct rpc_program *);
+struct proc_dir_entry * svc_proc_register(struct svc_stat *,
+                                          struct file_operations *);
+void                    svc_proc_unregister(const char *);
+
+void                    svc_seq_show(struct seq_file *,
+                                     const struct svc_stat *);
+
+extern struct proc_dir_entry    *proc_net_rpc;
+
+#else
+
+static inline struct proc_dir_entry *rpc_proc_register(struct rpc_stat *s) { return NULL; }
+static inline void rpc_proc_unregister(const char *p) {}
+static inline void rpc_proc_zero(struct rpc_program *p) {}
+
+static inline struct proc_dir_entry *svc_proc_register(struct svc_stat *s,
+                                                       struct file_operations *f) { return NULL; }
+static inline void svc_proc_unregister(const char *p) {}
+
+static inline void svc_seq_show(struct seq_file *seq,
+                                const struct svc_stat *st) {}
+
+#define proc_net_rpc NULL
+
+#endif
+
+#endif /* _LINUX_SUNRPC_STATS_H */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
new file mode 100644
index 000000000000..37003970cf2e
--- /dev/null
+++ b/include/linux/sunrpc/svc.h
@@ -0,0 +1,306 @@
+/*
+ * linux/include/linux/sunrpc/svc.h
+ *
+ * RPC server declarations.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+
+#ifndef SUNRPC_SVC_H
+#define SUNRPC_SVC_H
+
+#include <linux/in.h>
+#include <linux/sunrpc/types.h>
+#include <linux/sunrpc/xdr.h>
+#include <linux/sunrpc/svcauth.h>
+#include <linux/wait.h>
+#include <linux/mm.h>
+
+/*
+ * RPC service.
+ *
+ * An RPC service is a ``daemon,'' possibly multithreaded, which
+ * receives and processes incoming RPC messages.
+ * It has one or more transport sockets associated with it, and maintains
+ * a list of idle threads waiting for input.
+ *
+ * We currently do not support more than one RPC program per daemon.
+ */
+struct svc_serv {
+        struct list_head        sv_threads;     /* idle server threads */
+        struct list_head        sv_sockets;     /* pending sockets */
+        struct svc_program *    sv_program;     /* RPC program */
+        struct svc_stat *       sv_stats;       /* RPC statistics */
+        spinlock_t              sv_lock;
+        unsigned int            sv_nrthreads;   /* # of server threads */
+        unsigned int            sv_bufsz;       /* datagram buffer size */
+        unsigned int            sv_xdrsize;     /* XDR buffer size */
+
+        struct list_head        sv_permsocks;   /* all permanent sockets */
+        struct list_head        sv_tempsocks;   /* all temporary sockets */
+        int                     sv_tmpcnt;      /* count of temporary sockets */
+
+        char *                  sv_name;        /* service name */
+};
+
+/*
+ * Maximum payload size supported by a kernel RPC server.
+ * This is use to determine the max number of pages nfsd is
+ * willing to return in a single READ operation.
+ */
+#define RPCSVC_MAXPAYLOAD       (64*1024u)
+
+/*
+ * RPC Requsts and replies are stored in one or more pages.
+ * We maintain an array of pages for each server thread.
+ * Requests are copied into these pages as they arrive.  Remaining
+ * pages are available to write the reply into.
+ *
+ * Pages are sent using ->sendpage so each server thread needs to
+ * allocate more to replace those used in sending.  To help keep track
+ * of these pages we have a receive list where all pages initialy live,
+ * and a send list where pages are moved to when there are to be part
+ * of a reply.
+ *
+ * We use xdr_buf for holding responses as it fits well with NFS
+ * read responses (that have a header, and some data pages, and possibly
+ * a tail) and means we can share some client side routines.
+ *
+ * The xdr_buf.head kvec always points to the first page in the rq_*pages
+ * list.  The xdr_buf.pages pointer points to the second page on that
+ * list.  xdr_buf.tail points to the end of the first page.
+ * This assumes that the non-page part of an rpc reply will fit
+ * in a page - NFSd ensures this.  lockd also has no trouble.
+ *
+ * Each request/reply pair can have at most one "payload", plus two pages,
+ * one for the request, and one for the reply.
+ */
+#define RPCSVC_MAXPAGES         ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE + 2)
+
+static inline u32 svc_getu32(struct kvec *iov)
+{
+        u32 val, *vp;
+        vp = iov->iov_base;
+        val = *vp++;
+        iov->iov_base = (void*)vp;
+        iov->iov_len -= sizeof(u32);
+        return val;
+}
+
+static inline void svc_ungetu32(struct kvec *iov)
+{
+        u32 *vp = (u32 *)iov->iov_base;
+        iov->iov_base = (void *)(vp - 1);
+        iov->iov_len += sizeof(*vp);
+}
+
+static inline void svc_putu32(struct kvec *iov, u32 val)
+{
+        u32 *vp = iov->iov_base + iov->iov_len;
+        *vp = val;
+        iov->iov_len += sizeof(u32);
+}
+
+        
+/*
+ * The context of a single thread, including the request currently being
+ * processed.
+ * NOTE: First two items must be prev/next.
+ */
+struct svc_rqst {
+        struct list_head        rq_list;        /* idle list */
+        struct svc_sock *       rq_sock;        /* socket */
+        struct sockaddr_in      rq_addr;        /* peer address */
+        int                     rq_addrlen;
+
+        struct svc_serv *       rq_server;      /* RPC service definition */
+        struct svc_procedure *  rq_procinfo;    /* procedure info */
+        struct auth_ops *       rq_authop;      /* authentication flavour */
+        struct svc_cred         rq_cred;        /* auth info */
+        struct sk_buff *        rq_skbuff;      /* fast recv inet buffer */
+        struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
+
+        struct xdr_buf          rq_arg;
+        struct xdr_buf          rq_res;
+        struct page *           rq_argpages[RPCSVC_MAXPAGES];
+        struct page *           rq_respages[RPCSVC_MAXPAGES];
+        int                     rq_restailpage;
+        short                   rq_argused;     /* pages used for argument */
+        short                   rq_arghi;       /* pages available in argument page list */
+        short                   rq_resused;     /* pages used for result */
+
+        u32                     rq_xid;         /* transmission id */
+        u32                     rq_prog;        /* program number */
+        u32                     rq_vers;        /* program version */
+        u32                     rq_proc;        /* procedure number */
+        u32                     rq_prot;        /* IP protocol */
+        unsigned short
+                                rq_secure  : 1; /* secure port */
+
+
+        __u32                   rq_daddr;       /* dest addr of request - reply from here */
+
+        void *                  rq_argp;        /* decoded arguments */
+        void *                  rq_resp;        /* xdr'd results */
+        void *                  rq_auth_data;   /* flavor-specific data */
+
+        int                     rq_reserved;    /* space on socket outq
+                                                 * reserved for this request
+                                                 */
+
+        struct cache_req        rq_chandle;     /* handle passed to caches for 
+                                                 * request delaying 
+                                                 */
+        /* Catering to nfsd */
+        struct auth_domain *    rq_client;      /* RPC peer info */
+        struct svc_cacherep *   rq_cacherep;    /* cache info */
+        struct knfsd_fh *       rq_reffh;       /* Referrence filehandle, used to
+                                                 * determine what device number
+                                                 * to report (real or virtual)
+                                                 */
+
+        wait_queue_head_t       rq_wait;        /* synchronization */
+};
+
+/*
+ * Check buffer bounds after decoding arguments
+ */
+static inline int
+xdr_argsize_check(struct svc_rqst *rqstp, u32 *p)
+{
+        char *cp = (char *)p;
+        struct kvec *vec = &rqstp->rq_arg.head[0];
+        return cp - (char*)vec->iov_base <= vec->iov_len;
+}
+
+static inline int
+xdr_ressize_check(struct svc_rqst *rqstp, u32 *p)
+{
+        struct kvec *vec = &rqstp->rq_res.head[0];
+        char *cp = (char*)p;
+
+        vec->iov_len = cp - (char*)vec->iov_base;
+
+        return vec->iov_len <= PAGE_SIZE;
+}
+
+static inline int svc_take_page(struct svc_rqst *rqstp)
+{
+        if (rqstp->rq_arghi <= rqstp->rq_argused)
+                return -ENOMEM;
+        rqstp->rq_arghi--;
+        rqstp->rq_respages[rqstp->rq_resused] =
+                rqstp->rq_argpages[rqstp->rq_arghi];
+        rqstp->rq_resused++;
+        return 0;
+}
+
+static inline void svc_pushback_allpages(struct svc_rqst *rqstp)
+{
+        while (rqstp->rq_resused) {
+                if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
+                        continue;
+                rqstp->rq_argpages[rqstp->rq_arghi++] =
+                        rqstp->rq_respages[rqstp->rq_resused];
+                rqstp->rq_respages[rqstp->rq_resused] = NULL;
+        }
+}
+
+static inline void svc_pushback_unused_pages(struct svc_rqst *rqstp)
+{
+        while (rqstp->rq_resused &&
+               rqstp->rq_res.pages != &rqstp->rq_respages[rqstp->rq_resused]) {
+
+                if (rqstp->rq_respages[--rqstp->rq_resused] != NULL) {
+                        rqstp->rq_argpages[rqstp->rq_arghi++] =
+                                rqstp->rq_respages[rqstp->rq_resused];
+                        rqstp->rq_respages[rqstp->rq_resused] = NULL;
+                }
+        }
+}
+
+static inline void svc_free_allpages(struct svc_rqst *rqstp)
+{
+        while (rqstp->rq_resused) {
+                if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
+                        continue;
+                put_page(rqstp->rq_respages[rqstp->rq_resused]);
+                rqstp->rq_respages[rqstp->rq_resused] = NULL;
+        }
+}
+
+struct svc_deferred_req {
+        u32                     prot;   /* protocol (UDP or TCP) */
+        struct sockaddr_in      addr;
+        struct svc_sock         *svsk;  /* where reply must go */
+        struct cache_deferred_req handle;
+        int                     argslen;
+        u32                     args[0];
+};
+
+/*
+ * RPC program
+ */
+struct svc_program {
+        u32                     pg_prog;        /* program number */
+        unsigned int            pg_lovers;      /* lowest version */
+        unsigned int            pg_hivers;      /* lowest version */
+        unsigned int            pg_nvers;       /* number of versions */
+        struct svc_version **   pg_vers;        /* version array */
+        char *                  pg_name;        /* service name */
+        char *                  pg_class;       /* class name: services sharing authentication */
+        struct svc_stat *       pg_stats;       /* rpc statistics */
+        int                     (*pg_authenticate)(struct svc_rqst *);
+};
+
+/*
+ * RPC program version
+ */
+struct svc_version {
+        u32                     vs_vers;        /* version number */
+        u32                     vs_nproc;       /* number of procedures */
+        struct svc_procedure *  vs_proc;        /* per-procedure info */
+        u32                     vs_xdrsize;     /* xdrsize needed for this version */
+
+        /* Override dispatch function (e.g. when caching replies).
+         * A return value of 0 means drop the request. 
+         * vs_dispatch == NULL means use default dispatcher.
+         */
+        int                     (*vs_dispatch)(struct svc_rqst *, u32 *);
+};
+
+/*
+ * RPC procedure info
+ */
+typedef int     (*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
+struct svc_procedure {
+        svc_procfunc            pc_func;        /* process the request */
+        kxdrproc_t              pc_decode;      /* XDR decode args */
+        kxdrproc_t              pc_encode;      /* XDR encode result */
+        kxdrproc_t              pc_release;     /* XDR free result */
+        unsigned int            pc_argsize;     /* argument struct size */
+        unsigned int            pc_ressize;     /* result struct size */
+        unsigned int            pc_count;       /* call count */
+        unsigned int            pc_cachetype;   /* cache info (NFS) */
+        unsigned int            pc_xdrressize;  /* maximum size of XDR reply */
+};
+
+/*
+ * This is the RPC server thread function prototype
+ */
+typedef void            (*svc_thread_fn)(struct svc_rqst *);
+
+/*
+ * Function prototypes.
+ */
+struct svc_serv *  svc_create(struct svc_program *, unsigned int);
+int                svc_create_thread(svc_thread_fn, struct svc_serv *);
+void               svc_exit_thread(struct svc_rqst *);
+void               svc_destroy(struct svc_serv *);
+int                svc_process(struct svc_serv *, struct svc_rqst *);
+int                svc_register(struct svc_serv *, int, unsigned short);
+void               svc_wake_up(struct svc_serv *);
+void               svc_reserve(struct svc_rqst *rqstp, int space);
+
+#endif /* SUNRPC_SVC_H */
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
new file mode 100644
index 000000000000..c119ce7cbd22
--- /dev/null
+++ b/include/linux/sunrpc/svcauth.h
@@ -0,0 +1,167 @@
+/*
+ * linux/include/linux/sunrpc/svcauth.h
+ *
+ * RPC server-side authentication stuff.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_SVCAUTH_H_
+#define _LINUX_SUNRPC_SVCAUTH_H_
+
+#ifdef __KERNEL__
+
+#include <linux/string.h>
+#include <linux/sunrpc/msg_prot.h>
+#include <linux/sunrpc/cache.h>
+#include <linux/hash.h>
+
+#define SVC_CRED_NGROUPS        32
+struct svc_cred {
+        uid_t                   cr_uid;
+        gid_t                   cr_gid;
+        struct group_info       *cr_group_info;
+};
+
+struct svc_rqst;                /* forward decl */
+
+/* Authentication is done in the context of a domain.
+ *
+ * Currently, the nfs server uses the auth_domain to stand
+ * for the "client" listed in /etc/exports.
+ *
+ * More generally, a domain might represent a group of clients using
+ * a common mechanism for authentication and having a common mapping
+ * between local identity (uid) and network identity.  All clients
+ * in a domain have similar general access rights.  Each domain can
+ * contain multiple principals which will have different specific right
+ * based on normal Discretionary Access Control.
+ *
+ * A domain is created by an authentication flavour module based on name
+ * only.  Userspace then fills in detail on demand.
+ *
+ * In the case of auth_unix and auth_null, the auth_domain is also
+ * associated with entries in another cache representing the mapping
+ * of ip addresses to the given client.
+ */
+struct auth_domain {
+        struct  cache_head      h;
+        char                    *name;
+        int                     flavour;
+};
+
+/*
+ * Each authentication flavour registers an auth_ops
+ * structure.
+ * name is simply the name.
+ * flavour gives the auth flavour. It determines where the flavour is registered
+ * accept() is given a request and should verify it.
+ *   It should inspect the authenticator and verifier, and possibly the data.
+ *    If there is a problem with the authentication *authp should be set.
+ *    The return value of accept() can indicate:
+ *      OK - authorised. client and credential are set in rqstp.
+ *           reqbuf points to arguments
+ *           resbuf points to good place for results.  verfier
+ *             is (probably) already in place.  Certainly space is
+ *             reserved for it.
+ *      DROP - simply drop the request. It may have been deferred
+ *      GARBAGE - rpc garbage_args error
+ *      SYSERR - rpc system_err error
+ *      DENIED - authp holds reason for denial.
+ *      COMPLETE - the reply is encoded already and ready to be sent; no
+ *              further processing is necessary.  (This is used for processing
+ *              null procedure calls which are used to set up encryption
+ *              contexts.)
+ *
+ *   accept is passed the proc number so that it can accept NULL rpc requests
+ *   even if it cannot authenticate the client (as is sometimes appropriate).
+ *
+ * release() is given a request after the procedure has been run.
+ *  It should sign/encrypt the results if needed
+ * It should return:
+ *    OK - the resbuf is ready to be sent
+ *    DROP - the reply should be quitely dropped
+ *    DENIED - authp holds a reason for MSG_DENIED
+ *    SYSERR - rpc system_err
+ *
+ * domain_release()
+ *   This call releases a domain.
+ */
+struct auth_ops {
+        char *  name;
+        struct module *owner;
+        int     flavour;
+        int     (*accept)(struct svc_rqst *rq, u32 *authp);
+        int     (*release)(struct svc_rqst *rq);
+        void    (*domain_release)(struct auth_domain *);
+        int     (*set_client)(struct svc_rqst *rq);
+};
+
+#define SVC_GARBAGE     1
+#define SVC_SYSERR      2
+#define SVC_VALID       3
+#define SVC_NEGATIVE    4
+#define SVC_OK          5
+#define SVC_DROP        6
+#define SVC_DENIED      7
+#define SVC_PENDING     8
+#define SVC_COMPLETE    9
+
+
+extern int      svc_authenticate(struct svc_rqst *rqstp, u32 *authp);
+extern int      svc_authorise(struct svc_rqst *rqstp);
+extern int      svc_set_client(struct svc_rqst *rqstp);
+extern int      svc_auth_register(rpc_authflavor_t flavor, struct auth_ops *aops);
+extern void     svc_auth_unregister(rpc_authflavor_t flavor);
+
+extern struct auth_domain *unix_domain_find(char *name);
+extern void auth_domain_put(struct auth_domain *item);
+extern int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom);
+extern struct auth_domain *auth_domain_lookup(struct auth_domain *item, int set);
+extern struct auth_domain *auth_domain_find(char *name);
+extern struct auth_domain *auth_unix_lookup(struct in_addr addr);
+extern int auth_unix_forget_old(struct auth_domain *dom);
+extern void svcauth_unix_purge(void);
+
+static inline unsigned long hash_str(char *name, int bits)
+{
+        unsigned long hash = 0;
+        unsigned long l = 0;
+        int len = 0;
+        unsigned char c;
+        do {
+                if (unlikely(!(c = *name++))) {
+                        c = (char)len; len = -1;
+                }
+                l = (l << 8) | c;
+                len++;
+                if ((len & (BITS_PER_LONG/8-1))==0)
+                        hash = hash_long(hash^l, BITS_PER_LONG);
+        } while (len);
+        return hash >> (BITS_PER_LONG - bits);
+}
+
+static inline unsigned long hash_mem(char *buf, int length, int bits)
+{
+        unsigned long hash = 0;
+        unsigned long l = 0;
+        int len = 0;
+        unsigned char c;
+        do {
+                if (len == length) {
+                        c = (char)len; len = -1;
+                } else
+                        c = *buf++;
+                l = (l << 8) | c;
+                len++;
+                if ((len & (BITS_PER_LONG/8-1))==0)
+                        hash = hash_long(hash^l, BITS_PER_LONG);
+        } while (len);
+        return hash >> (BITS_PER_LONG - bits);
+}
+
+extern struct cache_detail auth_domain_cache, ip_map_cache;
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SUNRPC_SVCAUTH_H_ */
diff --git a/include/linux/sunrpc/svcauth_gss.h b/include/linux/sunrpc/svcauth_gss.h
new file mode 100644
index 000000000000..3a2206f61de0
--- /dev/null
+++ b/include/linux/sunrpc/svcauth_gss.h
@@ -0,0 +1,27 @@
+/*
+ * linux/include/linux/svcauth_gss.h
+ *
+ * Bruce Fields <bfields@umich.edu>
+ * Copyright (c) 2002 The Regents of the Unviersity of Michigan
+ *
+ * $Id$
+ *
+ */
+
+#ifndef _LINUX_SUNRPC_SVCAUTH_GSS_H
+#define _LINUX_SUNRPC_SVCAUTH_GSS_H
+
+#ifdef __KERNEL__
+#include <linux/sched.h>
+#include <linux/sunrpc/types.h>
+#include <linux/sunrpc/xdr.h>
+#include <linux/sunrpc/svcauth.h>
+#include <linux/sunrpc/svcsock.h>
+#include <linux/sunrpc/auth_gss.h>
+
+int gss_svc_init(void);
+void gss_svc_shutdown(void);
+int svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_SUNRPC_SVCAUTH_GSS_H */
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
new file mode 100644
index 000000000000..d33c6face032
--- /dev/null
+++ b/include/linux/sunrpc/svcsock.h
@@ -0,0 +1,65 @@
+/*
+ * linux/include/linux/sunrpc/svcsock.h
+ *
+ * RPC server socket I/O.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef SUNRPC_SVCSOCK_H
+#define SUNRPC_SVCSOCK_H
+
+#include <linux/sunrpc/svc.h>
+
+/*
+ * RPC server socket.
+ */
+struct svc_sock {
+        struct list_head        sk_ready;       /* list of ready sockets */
+        struct list_head        sk_list;        /* list of all sockets */
+        struct socket *         sk_sock;        /* berkeley socket layer */
+        struct sock *           sk_sk;          /* INET layer */
+
+        struct svc_serv *       sk_server;      /* service for this socket */
+        unsigned int            sk_inuse;       /* use count */
+        unsigned long           sk_flags;
+#define SK_BUSY         0                       /* enqueued/receiving */
+#define SK_CONN         1                       /* conn pending */
+#define SK_CLOSE        2                       /* dead or dying */
+#define SK_DATA         3                       /* data pending */
+#define SK_TEMP         4                       /* temp (TCP) socket */
+#define SK_DEAD         6                       /* socket closed */
+#define SK_CHNGBUF      7                       /* need to change snd/rcv buffer sizes */
+#define SK_DEFERRED     8                       /* request on sk_deferred */
+
+        int                     sk_reserved;    /* space on outq that is reserved */
+
+        struct list_head        sk_deferred;    /* deferred requests that need to
+                                                 * be revisted */
+        struct semaphore        sk_sem;         /* to serialize sending data */
+
+        int                     (*sk_recvfrom)(struct svc_rqst *rqstp);
+        int                     (*sk_sendto)(struct svc_rqst *rqstp);
+
+        /* We keep the old state_change and data_ready CB's here */
+        void                    (*sk_ostate)(struct sock *);
+        void                    (*sk_odata)(struct sock *, int bytes);
+        void                    (*sk_owspace)(struct sock *);
+
+        /* private TCP part */
+        int                     sk_reclen;      /* length of record */
+        int                     sk_tcplen;      /* current read length */
+        time_t                  sk_lastrecv;    /* time of last received request */
+};
+
+/*
+ * Function prototypes.
+ */
+int             svc_makesock(struct svc_serv *, int, unsigned short);
+void            svc_delete_socket(struct svc_sock *);
+int             svc_recv(struct svc_serv *, struct svc_rqst *, long);
+int             svc_send(struct svc_rqst *);
+void            svc_drop(struct svc_rqst *);
+void            svc_sock_update_bufs(struct svc_serv *serv);
+
+#endif /* SUNRPC_SVCSOCK_H */
diff --git a/include/linux/sunrpc/timer.h b/include/linux/sunrpc/timer.h
new file mode 100644
index 000000000000..a67fd734c73b
--- /dev/null
+++ b/include/linux/sunrpc/timer.h
@@ -0,0 +1,49 @@
+/*
+ *  linux/include/linux/sunrpc/timer.h
+ *
+ *  Declarations for the RPC transport timer.
+ *
+ *  Copyright (C) 2002 Trond Myklebust <trond.myklebust@fys.uio.no>
+ */
+
+#ifndef _LINUX_SUNRPC_TIMER_H
+#define _LINUX_SUNRPC_TIMER_H
+
+#include <asm/atomic.h>
+
+struct rpc_rtt {
+        unsigned long timeo;    /* default timeout value */
+        unsigned long srtt[5];  /* smoothed round trip time << 3 */
+        unsigned long sdrtt[5]; /* smoothed medium deviation of RTT */
+        int ntimeouts[5];       /* Number of timeouts for the last request */
+};
+
+
+extern void rpc_init_rtt(struct rpc_rtt *rt, unsigned long timeo);
+extern void rpc_update_rtt(struct rpc_rtt *rt, unsigned timer, long m);
+extern unsigned long rpc_calc_rto(struct rpc_rtt *rt, unsigned timer);
+
+static inline void rpc_set_timeo(struct rpc_rtt *rt, int timer, int ntimeo)
+{
+        int *t;
+        if (!timer)
+                return;
+        t = &rt->ntimeouts[timer-1];
+        if (ntimeo < *t) {
+                if (*t > 0)
+                        (*t)--;
+        } else {
+                if (ntimeo > 8)
+                        ntimeo = 8;
+                *t = ntimeo;
+        }
+}
+
+static inline int rpc_ntimeo(struct rpc_rtt *rt, int timer)
+{
+        if (!timer)
+                return 0;
+        return rt->ntimeouts[timer-1];
+}
+
+#endif /* _LINUX_SUNRPC_TIMER_H */
diff --git a/include/linux/sunrpc/types.h b/include/linux/sunrpc/types.h
new file mode 100644
index 000000000000..d222f47550af
--- /dev/null
+++ b/include/linux/sunrpc/types.h
@@ -0,0 +1,22 @@
+/*
+ * linux/include/linux/sunrpc/types.h
+ *
+ * Generic types and misc stuff for RPC.
+ *
+ * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_TYPES_H_
+#define _LINUX_SUNRPC_TYPES_H_
+
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+#include <linux/sunrpc/debug.h>
+#include <linux/list.h>
+
+/*
+ * Shorthands
+ */
+#define signalled()             (signal_pending(current))
+
+#endif /* _LINUX_SUNRPC_TYPES_H_ */
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
new file mode 100644
index 000000000000..541dcf838abf
--- /dev/null
+++ b/include/linux/sunrpc/xdr.h
@@ -0,0 +1,192 @@
+/*
+ * include/linux/sunrpc/xdr.h
+ *
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _SUNRPC_XDR_H_
+#define _SUNRPC_XDR_H_
+
+#ifdef __KERNEL__
+
+#include <linux/uio.h>
+#include <asm/byteorder.h>
+
+/*
+ * Buffer adjustment
+ */
+#define XDR_QUADLEN(l)          (((l) + 3) >> 2)
+
+/*
+ * Generic opaque `network object.' At the kernel level, this type
+ * is used only by lockd.
+ */
+#define XDR_MAX_NETOBJ          1024
+struct xdr_netobj {
+        unsigned int            len;
+        u8 *                    data;
+};
+
+/*
+ * This is the generic XDR function. rqstp is either a rpc_rqst (client
+ * side) or svc_rqst pointer (server side).
+ * Encode functions always assume there's enough room in the buffer.
+ */
+typedef int     (*kxdrproc_t)(void *rqstp, u32 *data, void *obj);
+
+/*
+ * Basic structure for transmission/reception of a client XDR message.
+ * Features a header (for a linear buffer containing RPC headers
+ * and the data payload for short messages), and then an array of
+ * pages.
+ * The tail iovec allows you to append data after the page array. Its
+ * main interest is for appending padding to the pages in order to
+ * satisfy the int_32-alignment requirements in RFC1832.
+ *
+ * For the future, we might want to string several of these together
+ * in a list if anybody wants to make use of NFSv4 COMPOUND
+ * operations and/or has a need for scatter/gather involving pages.
+ */
+struct xdr_buf {
+        struct kvec     head[1],        /* RPC header + non-page data */
+                        tail[1];        /* Appended after page data */
+
+        struct page **  pages;          /* Array of contiguous pages */
+        unsigned int    page_base,      /* Start of page data */
+                        page_len;       /* Length of page data */
+
+        unsigned int    buflen,         /* Total length of storage buffer */
+                        len;            /* Length of XDR encoded message */
+
+};
+
+/*
+ * pre-xdr'ed macros.
+ */
+
+#define xdr_zero        __constant_htonl(0)
+#define xdr_one         __constant_htonl(1)
+#define xdr_two         __constant_htonl(2)
+
+#define rpc_success             __constant_htonl(RPC_SUCCESS)
+#define rpc_prog_unavail        __constant_htonl(RPC_PROG_UNAVAIL)
+#define rpc_prog_mismatch       __constant_htonl(RPC_PROG_MISMATCH)
+#define rpc_proc_unavail        __constant_htonl(RPC_PROC_UNAVAIL)
+#define rpc_garbage_args        __constant_htonl(RPC_GARBAGE_ARGS)
+#define rpc_system_err          __constant_htonl(RPC_SYSTEM_ERR)
+
+#define rpc_auth_ok             __constant_htonl(RPC_AUTH_OK)
+#define rpc_autherr_badcred     __constant_htonl(RPC_AUTH_BADCRED)
+#define rpc_autherr_rejectedcred __constant_htonl(RPC_AUTH_REJECTEDCRED)
+#define rpc_autherr_badverf     __constant_htonl(RPC_AUTH_BADVERF)
+#define rpc_autherr_rejectedverf __constant_htonl(RPC_AUTH_REJECTEDVERF)
+#define rpc_autherr_tooweak     __constant_htonl(RPC_AUTH_TOOWEAK)
+#define rpcsec_gsserr_credproblem       __constant_htonl(RPCSEC_GSS_CREDPROBLEM)
+#define rpcsec_gsserr_ctxproblem        __constant_htonl(RPCSEC_GSS_CTXPROBLEM)
+#define rpc_autherr_oldseqnum   __constant_htonl(101)
+
+/*
+ * Miscellaneous XDR helper functions
+ */
+u32 *   xdr_encode_opaque_fixed(u32 *p, const void *ptr, unsigned int len);
+u32 *   xdr_encode_opaque(u32 *p, const void *ptr, unsigned int len);
+u32 *   xdr_encode_string(u32 *p, const char *s);
+u32 *   xdr_decode_string(u32 *p, char **sp, int *lenp, int maxlen);
+u32 *   xdr_decode_string_inplace(u32 *p, char **sp, int *lenp, int maxlen);
+u32 *   xdr_encode_netobj(u32 *p, const struct xdr_netobj *);
+u32 *   xdr_decode_netobj(u32 *p, struct xdr_netobj *);
+
+void    xdr_encode_pages(struct xdr_buf *, struct page **, unsigned int,
+                         unsigned int);
+void    xdr_inline_pages(struct xdr_buf *, unsigned int,
+                         struct page **, unsigned int, unsigned int);
+
+static inline u32 *xdr_encode_array(u32 *p, const void *s, unsigned int len)
+{
+        return xdr_encode_opaque(p, s, len);
+}
+
+/*
+ * Decode 64bit quantities (NFSv3 support)
+ */
+static inline u32 *
+xdr_encode_hyper(u32 *p, __u64 val)
+{
+        *p++ = htonl(val >> 32);
+        *p++ = htonl(val & 0xFFFFFFFF);
+        return p;
+}
+
+static inline u32 *
+xdr_decode_hyper(u32 *p, __u64 *valp)
+{
+        *valp  = ((__u64) ntohl(*p++)) << 32;
+        *valp |= ntohl(*p++);
+        return p;
+}
+
+/*
+ * Adjust kvec to reflect end of xdr'ed data (RPC client XDR)
+ */
+static inline int
+xdr_adjust_iovec(struct kvec *iov, u32 *p)
+{
+        return iov->iov_len = ((u8 *) p - (u8 *) iov->iov_base);
+}
+
+/*
+ * Maximum number of iov's we use.
+ */
+#define MAX_IOVEC       (12)
+
+/*
+ * XDR buffer helper functions
+ */
+extern void xdr_shift_buf(struct xdr_buf *, size_t);
+extern void xdr_buf_from_iov(struct kvec *, struct xdr_buf *);
+extern int xdr_buf_subsegment(struct xdr_buf *, struct xdr_buf *, int, int);
+extern int xdr_buf_read_netobj(struct xdr_buf *, struct xdr_netobj *, int);
+extern int read_bytes_from_xdr_buf(struct xdr_buf *buf, int base, void *obj, int len);
+
+/*
+ * Helper structure for copying from an sk_buff.
+ */
+typedef struct {
+        struct sk_buff  *skb;
+        unsigned int    offset;
+        size_t          count;
+        unsigned int    csum;
+} skb_reader_t;
+
+typedef size_t (*skb_read_actor_t)(skb_reader_t *desc, void *to, size_t len);
+
+extern void xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
+                skb_reader_t *, skb_read_actor_t);
+
+struct socket;
+struct sockaddr;
+extern int xdr_sendpages(struct socket *, struct sockaddr *, int,
+                struct xdr_buf *, unsigned int, int);
+
+/*
+ * Provide some simple tools for XDR buffer overflow-checking etc.
+ */
+struct xdr_stream {
+        uint32_t *p;            /* start of available buffer */
+        struct xdr_buf *buf;    /* XDR buffer to read/write */
+
+        uint32_t *end;          /* end of available buffer space */
+        struct kvec *iov;       /* pointer to the current kvec */
+};
+
+extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p);
+extern uint32_t *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
+extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
+                unsigned int base, unsigned int len);
+extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p);
+extern uint32_t *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
+extern void xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
+
+#endif /* __KERNEL__ */
+
+#endif /* _SUNRPC_XDR_H_ */
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
new file mode 100644
index 000000000000..e618c1649814
--- /dev/null
+++ b/include/linux/sunrpc/xprt.h
@@ -0,0 +1,232 @@
+/*
+ *  linux/include/linux/sunrpc/clnt_xprt.h
+ *
+ *  Declarations for the RPC transport interface.
+ *
+ *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+
+#ifndef _LINUX_SUNRPC_XPRT_H
+#define _LINUX_SUNRPC_XPRT_H
+
+#include <linux/uio.h>
+#include <linux/socket.h>
+#include <linux/in.h>
+#include <linux/sunrpc/sched.h>
+#include <linux/sunrpc/xdr.h>
+
+/*
+ * The transport code maintains an estimate on the maximum number of out-
+ * standing RPC requests, using a smoothed version of the congestion
+ * avoidance implemented in 44BSD. This is basically the Van Jacobson
+ * congestion algorithm: If a retransmit occurs, the congestion window is
+ * halved; otherwise, it is incremented by 1/cwnd when
+ *
+ *      -       a reply is received and
+ *      -       a full number of requests are outstanding and
+ *      -       the congestion window hasn't been updated recently.
+ *
+ * Upper procedures may check whether a request would block waiting for
+ * a free RPC slot by using the RPC_CONGESTED() macro.
+ */
+extern unsigned int xprt_udp_slot_table_entries;
+extern unsigned int xprt_tcp_slot_table_entries;
+
+#define RPC_MIN_SLOT_TABLE      (2U)
+#define RPC_DEF_SLOT_TABLE      (16U)
+#define RPC_MAX_SLOT_TABLE      (128U)
+
+#define RPC_CWNDSHIFT           (8U)
+#define RPC_CWNDSCALE           (1U << RPC_CWNDSHIFT)
+#define RPC_INITCWND            RPC_CWNDSCALE
+#define RPC_MAXCWND(xprt)       ((xprt)->max_reqs << RPC_CWNDSHIFT)
+#define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
+
+/* Default timeout values */
+#define RPC_MAX_UDP_TIMEOUT     (60*HZ)
+#define RPC_MAX_TCP_TIMEOUT     (600*HZ)
+
+/*
+ * Wait duration for an RPC TCP connection to be established.  Solaris
+ * NFS over TCP uses 60 seconds, for example, which is in line with how
+ * long a server takes to reboot.
+ */
+#define RPC_CONNECT_TIMEOUT     (60*HZ)
+
+/*
+ * Delay an arbitrary number of seconds before attempting to reconnect
+ * after an error.
+ */
+#define RPC_REESTABLISH_TIMEOUT (15*HZ)
+
+/* RPC call and reply header size as number of 32bit words (verifier
+ * size computed separately)
+ */
+#define RPC_CALLHDRSIZE         6
+#define RPC_REPHDRSIZE          4
+
+/*
+ * This describes a timeout strategy
+ */
+struct rpc_timeout {
+        unsigned long           to_initval,             /* initial timeout */
+                                to_maxval,              /* max timeout */
+                                to_increment;           /* if !exponential */
+        unsigned int            to_retries;             /* max # of retries */
+        unsigned char           to_exponential;
+};
+
+/*
+ * This describes a complete RPC request
+ */
+struct rpc_rqst {
+        /*
+         * This is the user-visible part
+         */
+        struct rpc_xprt *       rq_xprt;                /* RPC client */
+        struct xdr_buf          rq_snd_buf;             /* send buffer */
+        struct xdr_buf          rq_rcv_buf;             /* recv buffer */
+
+        /*
+         * This is the private part
+         */
+        struct rpc_task *       rq_task;        /* RPC task data */
+        __u32                   rq_xid;         /* request XID */
+        int                     rq_cong;        /* has incremented xprt->cong */
+        int                     rq_received;    /* receive completed */
+        u32                     rq_seqno;       /* gss seq no. used on req. */
+
+        struct list_head        rq_list;
+
+        struct xdr_buf          rq_private_buf;         /* The receive buffer
+                                                         * used in the softirq.
+                                                         */
+        unsigned long           rq_majortimeo;  /* major timeout alarm */
+        unsigned long           rq_timeout;     /* Current timeout value */
+        unsigned int            rq_retries;     /* # of retries */
+        /*
+         * For authentication (e.g. auth_des)
+         */
+        u32                     rq_creddata[2];
+        
+        /*
+         * Partial send handling
+         */
+        
+        u32                     rq_bytes_sent;  /* Bytes we have sent */
+
+        unsigned long           rq_xtime;       /* when transmitted */
+        int                     rq_ntrans;
+};
+#define rq_svec                 rq_snd_buf.head
+#define rq_slen                 rq_snd_buf.len
+
+#define XPRT_LAST_FRAG          (1 << 0)
+#define XPRT_COPY_RECM          (1 << 1)
+#define XPRT_COPY_XID           (1 << 2)
+#define XPRT_COPY_DATA          (1 << 3)
+
+struct rpc_xprt {
+        struct socket *         sock;           /* BSD socket layer */
+        struct sock *           inet;           /* INET layer */
+
+        struct rpc_timeout      timeout;        /* timeout parms */
+        struct sockaddr_in      addr;           /* server address */
+        int                     prot;           /* IP protocol */
+
+        unsigned long           cong;           /* current congestion */
+        unsigned long           cwnd;           /* congestion window */
+
+        unsigned int            rcvsize,        /* socket receive buffer size */
+                                sndsize;        /* socket send buffer size */
+
+        size_t                  max_payload;    /* largest RPC payload size,
+                                                   in bytes */
+
+        struct rpc_wait_queue   sending;        /* requests waiting to send */
+        struct rpc_wait_queue   resend;         /* requests waiting to resend */
+        struct rpc_wait_queue   pending;        /* requests in flight */
+        struct rpc_wait_queue   backlog;        /* waiting for slot */
+        struct list_head        free;           /* free slots */
+        struct rpc_rqst *       slot;           /* slot table storage */
+        unsigned int            max_reqs;       /* total slots */
+        unsigned long           sockstate;      /* Socket state */
+        unsigned char           shutdown   : 1, /* being shut down */
+                                nocong     : 1, /* no congestion control */
+                                resvport   : 1, /* use a reserved port */
+                                stream     : 1; /* TCP */
+
+        /*
+         * XID
+         */
+        __u32                   xid;            /* Next XID value to use */
+
+        /*
+         * State of TCP reply receive stuff
+         */
+        u32                     tcp_recm,       /* Fragment header */
+                                tcp_xid,        /* Current XID */
+                                tcp_reclen,     /* fragment length */
+                                tcp_offset;     /* fragment offset */
+        unsigned long           tcp_copied,     /* copied to request */
+                                tcp_flags;
+        /*
+         * Connection of sockets
+         */
+        struct work_struct      sock_connect;
+        unsigned short          port;
+        /*
+         * Disconnection of idle sockets
+         */
+        struct work_struct      task_cleanup;
+        struct timer_list       timer;
+        unsigned long           last_used;
+
+        /*
+         * Send stuff
+         */
+        spinlock_t              sock_lock;      /* lock socket info */
+        spinlock_t              xprt_lock;      /* lock xprt info */
+        struct rpc_task *       snd_task;       /* Task blocked in send */
+
+        struct list_head        recv;
+
+
+        void                    (*old_data_ready)(struct sock *, int);
+        void                    (*old_state_change)(struct sock *);
+        void                    (*old_write_space)(struct sock *);
+
+        wait_queue_head_t       cong_wait;
+};
+
+#ifdef __KERNEL__
+
+struct rpc_xprt *       xprt_create_proto(int proto, struct sockaddr_in *addr,
+                                        struct rpc_timeout *toparms);
+int                     xprt_destroy(struct rpc_xprt *);
+void                    xprt_set_timeout(struct rpc_timeout *, unsigned int,
+                                        unsigned long);
+
+void                    xprt_reserve(struct rpc_task *);
+int                     xprt_prepare_transmit(struct rpc_task *);
+void                    xprt_transmit(struct rpc_task *);
+void                    xprt_receive(struct rpc_task *);
+int                     xprt_adjust_timeout(struct rpc_rqst *req);
+void                    xprt_release(struct rpc_task *);
+void                    xprt_connect(struct rpc_task *);
+void                    xprt_sock_setbufsize(struct rpc_xprt *);
+
+#define XPRT_LOCKED     0
+#define XPRT_CONNECT    1
+#define XPRT_CONNECTING 2
+
+#define xprt_connected(xp)              (test_bit(XPRT_CONNECT, &(xp)->sockstate))
+#define xprt_set_connected(xp)          (set_bit(XPRT_CONNECT, &(xp)->sockstate))
+#define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate))
+#define xprt_test_and_clear_connected(xp) \
+                                        (test_and_clear_bit(XPRT_CONNECT, &(xp)->sockstate))
+#define xprt_clear_connected(xp)        (clear_bit(XPRT_CONNECT, &(xp)->sockstate))
+
+#endif /* __KERNEL__*/
+
+#endif /* _LINUX_SUNRPC_XPRT_H */
diff --git a/include/linux/superhyway.h b/include/linux/superhyway.h
new file mode 100644
index 000000000000..c906c5a0aaef
--- /dev/null
+++ b/include/linux/superhyway.h
@@ -0,0 +1,79 @@
+/*
+ * include/linux/superhyway.h
+ *
+ * SuperHyway Bus definitions
+ *
+ * Copyright (C) 2004, 2005  Paul Mundt <lethal@linux-sh.org>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#ifndef __LINUX_SUPERHYWAY_H
+#define __LINUX_SUPERHYWAY_H
+
+#include <linux/device.h>
+
+/*
+ * SuperHyway IDs
+ */
+#define SUPERHYWAY_DEVICE_ID_SH5_DMAC   0x0183
+
+struct vcr_info {
+        u8      perr_flags;     /* P-port Error flags */
+        u8      merr_flags;     /* Module Error flags */
+        u16     mod_vers;       /* Module Version */
+        u16     mod_id;         /* Module ID */
+        u8      bot_mb;         /* Bottom Memory block */
+        u8      top_mb;         /* Top Memory block */
+};
+
+struct superhyway_device_id {
+        unsigned int id;
+        unsigned long driver_data;
+};
+
+struct superhyway_device;
+extern struct bus_type superhyway_bus_type;
+
+struct superhyway_driver {
+        char *name;
+
+        const struct superhyway_device_id *id_table;
+        struct device_driver drv;
+
+        int (*probe)(struct superhyway_device *dev, const struct superhyway_device_id *id);
+        void (*remove)(struct superhyway_device *dev);
+};
+
+#define to_superhyway_driver(d) container_of((d), struct superhyway_driver, drv)
+
+struct superhyway_device {
+        char name[32];
+
+        struct device dev;
+
+        struct superhyway_device_id id;
+        struct superhyway_driver *drv;
+
+        struct resource resource;
+        struct vcr_info vcr;
+};
+
+#define to_superhyway_device(d) container_of((d), struct superhyway_device, dev)
+
+#define superhyway_get_drvdata(d)       dev_get_drvdata(&(d)->dev)
+#define superhyway_set_drvdata(d,p)     dev_set_drvdata(&(d)->dev, (p))
+
+extern int superhyway_scan_bus(void);
+
+/* drivers/sh/superhyway/superhyway.c */
+int superhyway_register_driver(struct superhyway_driver *);
+void superhyway_unregister_driver(struct superhyway_driver *);
+int superhyway_add_device(unsigned int, unsigned long, unsigned long long);
+
+/* drivers/sh/superhyway/superhyway-sysfs.c */
+extern struct device_attribute superhyway_dev_attrs[];
+
+#endif /* __LINUX_SUPERHYWAY_H */
+
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
new file mode 100644
index 000000000000..2bf0d5fabcdb
--- /dev/null
+++ b/include/linux/suspend.h
@@ -0,0 +1,75 @@
+#ifndef _LINUX_SWSUSP_H
+#define _LINUX_SWSUSP_H
+
+#if defined(CONFIG_X86) || defined(CONFIG_FRV) || defined(CONFIG_PPC32)
+#include <asm/suspend.h>
+#endif
+#include <linux/swap.h>
+#include <linux/notifier.h>
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/pm.h>
+
+/* page backup entry */
+typedef struct pbe {
+        unsigned long address;          /* address of the copy */
+        unsigned long orig_address;     /* original address of page */
+        swp_entry_t swap_address;       
+
+        struct pbe *next;       /* also used as scratch space at
+                                 * end of page (see link, diskpage)
+                                 */
+} suspend_pagedir_t;
+
+#define for_each_pbe(pbe, pblist) \
+        for (pbe = pblist ; pbe ; pbe = pbe->next)
+
+#define PBES_PER_PAGE      (PAGE_SIZE/sizeof(struct pbe))
+#define PB_PAGE_SKIP       (PBES_PER_PAGE-1)
+
+#define for_each_pb_page(pbe, pblist) \
+        for (pbe = pblist ; pbe ; pbe = (pbe+PB_PAGE_SKIP)->next)
+
+
+#define SWAP_FILENAME_MAXLENGTH 32
+
+
+extern dev_t swsusp_resume_device;
+   
+/* mm/vmscan.c */
+extern int shrink_mem(void);
+
+/* mm/page_alloc.c */
+extern void drain_local_pages(void);
+extern void mark_free_pages(struct zone *zone);
+
+#ifdef CONFIG_PM
+/* kernel/power/swsusp.c */
+extern int software_suspend(void);
+
+extern int pm_prepare_console(void);
+extern void pm_restore_console(void);
+
+#else
+static inline int software_suspend(void)
+{
+        printk("Warning: fake suspend called\n");
+        return -EPERM;
+}
+#endif
+
+#ifdef CONFIG_SMP
+extern void disable_nonboot_cpus(void);
+extern void enable_nonboot_cpus(void);
+#else
+static inline void disable_nonboot_cpus(void) {}
+static inline void enable_nonboot_cpus(void) {}
+#endif
+
+void save_processor_state(void);
+void restore_processor_state(void);
+struct saved_context;
+void __save_processor_state(struct saved_context *ctxt);
+void __restore_processor_state(struct saved_context *ctxt);
+
+#endif /* _LINUX_SWSUSP_H */
diff --git a/include/linux/swap.h b/include/linux/swap.h
new file mode 100644
index 000000000000..3bbc41be9bd0
--- /dev/null
+++ b/include/linux/swap.h
@@ -0,0 +1,293 @@
+#ifndef _LINUX_SWAP_H
+#define _LINUX_SWAP_H
+
+#include <linux/config.h>
+#include <linux/spinlock.h>
+#include <linux/linkage.h>
+#include <linux/mmzone.h>
+#include <linux/list.h>
+#include <linux/sched.h>
+#include <asm/atomic.h>
+#include <asm/page.h>
+
+#define SWAP_FLAG_PREFER        0x8000  /* set if swap priority specified */
+#define SWAP_FLAG_PRIO_MASK     0x7fff
+#define SWAP_FLAG_PRIO_SHIFT    0
+
+static inline int current_is_kswapd(void)
+{
+        return current->flags & PF_KSWAPD;
+}
+
+/*
+ * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
+ * be swapped to.  The swap type and the offset into that swap type are
+ * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
+ * for the type means that the maximum number of swapcache pages is 27 bits
+ * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
+ * the type/offset into the pte as 5/27 as well.
+ */
+#define MAX_SWAPFILES_SHIFT     5
+#define MAX_SWAPFILES           (1 << MAX_SWAPFILES_SHIFT)
+
+/*
+ * Magic header for a swap area. The first part of the union is
+ * what the swap magic looks like for the old (limited to 128MB)
+ * swap area format, the second part of the union adds - in the
+ * old reserved area - some extra information. Note that the first
+ * kilobyte is reserved for boot loader or disk label stuff...
+ *
+ * Having the magic at the end of the PAGE_SIZE makes detecting swap
+ * areas somewhat tricky on machines that support multiple page sizes.
+ * For 2.5 we'll probably want to move the magic to just beyond the
+ * bootbits...
+ */
+union swap_header {
+        struct {
+                char reserved[PAGE_SIZE - 10];
+                char magic[10];                 /* SWAP-SPACE or SWAPSPACE2 */
+        } magic;
+        struct {
+                char         bootbits[1024];    /* Space for disklabel etc. */
+                unsigned int version;
+                unsigned int last_page;
+                unsigned int nr_badpages;
+                unsigned int padding[125];
+                unsigned int badpages[1];
+        } info;
+};
+
+ /* A swap entry has to fit into a "unsigned long", as
+  * the entry is hidden in the "index" field of the
+  * swapper address space.
+  */
+typedef struct {
+        unsigned long val;
+} swp_entry_t;
+
+/*
+ * current->reclaim_state points to one of these when a task is running
+ * memory reclaim
+ */
+struct reclaim_state {
+        unsigned long reclaimed_slab;
+};
+
+#ifdef __KERNEL__
+
+struct address_space;
+struct sysinfo;
+struct writeback_control;
+struct zone;
+
+/*
+ * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
+ * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
+ * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
+ * from setup, they're handled identically.
+ *
+ * We always assume that blocks are of size PAGE_SIZE.
+ */
+struct swap_extent {
+        struct list_head list;
+        pgoff_t start_page;
+        pgoff_t nr_pages;
+        sector_t start_block;
+};
+
+/*
+ * Max bad pages in the new format..
+ */
+#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
+#define MAX_SWAP_BADPAGES \
+        ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
+
+enum {
+        SWP_USED        = (1 << 0),     /* is slot in swap_info[] used? */
+        SWP_WRITEOK     = (1 << 1),     /* ok to write to this swap?    */
+        SWP_ACTIVE      = (SWP_USED | SWP_WRITEOK),
+};
+
+#define SWAP_CLUSTER_MAX 32
+
+#define SWAP_MAP_MAX    0x7fff
+#define SWAP_MAP_BAD    0x8000
+
+/*
+ * The in-memory structure used to track swap areas.
+ * extent_list.prev points at the lowest-index extent.  That list is
+ * sorted.
+ */
+struct swap_info_struct {
+        unsigned int flags;
+        spinlock_t sdev_lock;
+        struct file *swap_file;
+        struct block_device *bdev;
+        struct list_head extent_list;
+        int nr_extents;
+        struct swap_extent *curr_swap_extent;
+        unsigned old_block_size;
+        unsigned short * swap_map;
+        unsigned int lowest_bit;
+        unsigned int highest_bit;
+        unsigned int cluster_next;
+        unsigned int cluster_nr;
+        int prio;                       /* swap priority */
+        int pages;
+        unsigned long max;
+        unsigned long inuse_pages;
+        int next;                       /* next entry on swap list */
+};
+
+struct swap_list_t {
+        int head;       /* head of priority-ordered swapfile list */
+        int next;       /* swapfile to be used next */
+};
+
+/* Swap 50% full? Release swapcache more aggressively.. */
+#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
+
+/* linux/mm/oom_kill.c */
+extern void out_of_memory(unsigned int __nocast gfp_mask);
+
+/* linux/mm/memory.c */
+extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
+
+/* linux/mm/page_alloc.c */
+extern unsigned long totalram_pages;
+extern unsigned long totalhigh_pages;
+extern long nr_swap_pages;
+extern unsigned int nr_free_pages(void);
+extern unsigned int nr_free_pages_pgdat(pg_data_t *pgdat);
+extern unsigned int nr_free_buffer_pages(void);
+extern unsigned int nr_free_pagecache_pages(void);
+
+/* linux/mm/swap.c */
+extern void FASTCALL(lru_cache_add(struct page *));
+extern void FASTCALL(lru_cache_add_active(struct page *));
+extern void FASTCALL(activate_page(struct page *));
+extern void FASTCALL(mark_page_accessed(struct page *));
+extern void lru_add_drain(void);
+extern int rotate_reclaimable_page(struct page *page);
+extern void swap_setup(void);
+
+/* linux/mm/vmscan.c */
+extern int try_to_free_pages(struct zone **, unsigned int, unsigned int);
+extern int shrink_all_memory(int);
+extern int vm_swappiness;
+
+#ifdef CONFIG_MMU
+/* linux/mm/shmem.c */
+extern int shmem_unuse(swp_entry_t entry, struct page *page);
+#endif /* CONFIG_MMU */
+
+extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
+
+#ifdef CONFIG_SWAP
+/* linux/mm/page_io.c */
+extern int swap_readpage(struct file *, struct page *);
+extern int swap_writepage(struct page *page, struct writeback_control *wbc);
+extern int rw_swap_page_sync(int, swp_entry_t, struct page *);
+
+/* linux/mm/swap_state.c */
+extern struct address_space swapper_space;
+#define total_swapcache_pages  swapper_space.nrpages
+extern void show_swap_cache_info(void);
+extern int add_to_swap(struct page *);
+extern void __delete_from_swap_cache(struct page *);
+extern void delete_from_swap_cache(struct page *);
+extern int move_to_swap_cache(struct page *, swp_entry_t);
+extern int move_from_swap_cache(struct page *, unsigned long,
+                struct address_space *);
+extern void free_page_and_swap_cache(struct page *);
+extern void free_pages_and_swap_cache(struct page **, int);
+extern struct page * lookup_swap_cache(swp_entry_t);
+extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma,
+                                           unsigned long addr);
+/* linux/mm/swapfile.c */
+extern long total_swap_pages;
+extern unsigned int nr_swapfiles;
+extern struct swap_info_struct swap_info[];
+extern void si_swapinfo(struct sysinfo *);
+extern swp_entry_t get_swap_page(void);
+extern int swap_duplicate(swp_entry_t);
+extern int valid_swaphandles(swp_entry_t, unsigned long *);
+extern void swap_free(swp_entry_t);
+extern void free_swap_and_cache(swp_entry_t);
+extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
+extern struct swap_info_struct *get_swap_info_struct(unsigned);
+extern int can_share_swap_page(struct page *);
+extern int remove_exclusive_swap_page(struct page *);
+struct backing_dev_info;
+
+extern struct swap_list_t swap_list;
+extern spinlock_t swaplock;
+
+#define swap_list_lock()        spin_lock(&swaplock)
+#define swap_list_unlock()      spin_unlock(&swaplock)
+#define swap_device_lock(p)     spin_lock(&p->sdev_lock)
+#define swap_device_unlock(p)   spin_unlock(&p->sdev_lock)
+
+/* linux/mm/thrash.c */
+extern struct mm_struct * swap_token_mm;
+extern unsigned long swap_token_default_timeout;
+extern void grab_swap_token(void);
+extern void __put_swap_token(struct mm_struct *);
+
+static inline int has_swap_token(struct mm_struct *mm)
+{
+        return (mm == swap_token_mm);
+}
+
+static inline void put_swap_token(struct mm_struct *mm)
+{
+        if (has_swap_token(mm))
+                __put_swap_token(mm);
+}
+
+#else /* CONFIG_SWAP */
+
+#define total_swap_pages                        0
+#define total_swapcache_pages                   0UL
+
+#define si_swapinfo(val) \
+        do { (val)->freeswap = (val)->totalswap = 0; } while (0)
+#define free_page_and_swap_cache(page) \
+        page_cache_release(page)
+#define free_pages_and_swap_cache(pages, nr) \
+        release_pages((pages), (nr), 0);
+
+#define show_swap_cache_info()                  /*NOTHING*/
+#define free_swap_and_cache(swp)                /*NOTHING*/
+#define swap_duplicate(swp)                     /*NOTHING*/
+#define swap_free(swp)                          /*NOTHING*/
+#define read_swap_cache_async(swp,vma,addr)     NULL
+#define lookup_swap_cache(swp)                  NULL
+#define valid_swaphandles(swp, off)             0
+#define can_share_swap_page(p)                  0
+#define move_to_swap_cache(p, swp)              1
+#define move_from_swap_cache(p, i, m)           1
+#define __delete_from_swap_cache(p)             /*NOTHING*/
+#define delete_from_swap_cache(p)               /*NOTHING*/
+#define swap_token_default_timeout              0
+
+static inline int remove_exclusive_swap_page(struct page *p)
+{
+        return 0;
+}
+
+static inline swp_entry_t get_swap_page(void)
+{
+        swp_entry_t entry;
+        entry.val = 0;
+        return entry;
+}
+
+/* linux/mm/thrash.c */
+#define put_swap_token(x) do { } while(0)
+#define grab_swap_token()  do { } while(0)
+#define has_swap_token(x) 0
+
+#endif /* CONFIG_SWAP */
+#endif /* __KERNEL__*/
+#endif /* _LINUX_SWAP_H */
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
new file mode 100644
index 000000000000..d4c7db35e708
--- /dev/null
+++ b/include/linux/swapops.h
@@ -0,0 +1,69 @@
+/*
+ * swapcache pages are stored in the swapper_space radix tree.  We want to
+ * get good packing density in that tree, so the index should be dense in
+ * the low-order bits.
+ *
+ * We arrange the `type' and `offset' fields so that `type' is at the five
+ * high-order bits of the smp_entry_t and `offset' is right-aligned in the
+ * remaining bits.
+ *
+ * swp_entry_t's are *never* stored anywhere in their arch-dependent format.
+ */
+#define SWP_TYPE_SHIFT(e)       (sizeof(e.val) * 8 - MAX_SWAPFILES_SHIFT)
+#define SWP_OFFSET_MASK(e)      ((1UL << SWP_TYPE_SHIFT(e)) - 1)
+
+/*
+ * Store a type+offset into a swp_entry_t in an arch-independent format
+ */
+static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
+{
+        swp_entry_t ret;
+
+        ret.val = (type << SWP_TYPE_SHIFT(ret)) |
+                        (offset & SWP_OFFSET_MASK(ret));
+        return ret;
+}
+
+/*
+ * Extract the `type' field from a swp_entry_t.  The swp_entry_t is in
+ * arch-independent format
+ */
+static inline unsigned swp_type(swp_entry_t entry)
+{
+        return (entry.val >> SWP_TYPE_SHIFT(entry));
+}
+
+/*
+ * Extract the `offset' field from a swp_entry_t.  The swp_entry_t is in
+ * arch-independent format
+ */
+static inline pgoff_t swp_offset(swp_entry_t entry)
+{
+        return entry.val & SWP_OFFSET_MASK(entry);
+}
+
+/*
+ * Convert the arch-dependent pte representation of a swp_entry_t into an
+ * arch-independent swp_entry_t.
+ */
+static inline swp_entry_t pte_to_swp_entry(pte_t pte)
+{
+        swp_entry_t arch_entry;
+
+        BUG_ON(pte_file(pte));
+        arch_entry = __pte_to_swp_entry(pte);
+        return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
+}
+
+/*
+ * Convert the arch-independent representation of a swp_entry_t into the
+ * arch-dependent pte representation.
+ */
+static inline pte_t swp_entry_to_pte(swp_entry_t entry)
+{
+        swp_entry_t arch_entry;
+
+        arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
+        BUG_ON(pte_file(__swp_entry_to_pte(arch_entry)));
+        return __swp_entry_to_pte(arch_entry);
+}
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
new file mode 100644
index 000000000000..763bd290f28d
--- /dev/null
+++ b/include/linux/synclink.h
@@ -0,0 +1,273 @@
+/*
+ * SyncLink Multiprotocol Serial Adapter Driver
+ *
+ * $Id: synclink.h,v 3.6 2002/02/20 21:58:20 paulkf Exp $
+ *
+ * Copyright (C) 1998-2000 by Microgate Corporation
+ *
+ * Redistribution of this file is permitted under
+ * the terms of the GNU Public License (GPL)
+ */
+
+#ifndef _SYNCLINK_H_
+#define _SYNCLINK_H_
+#define SYNCLINK_H_VERSION 3.6
+
+#define BOOLEAN int
+#define TRUE 1
+#define FALSE 0
+
+#define BIT0    0x0001
+#define BIT1    0x0002
+#define BIT2    0x0004
+#define BIT3    0x0008
+#define BIT4    0x0010
+#define BIT5    0x0020
+#define BIT6    0x0040
+#define BIT7    0x0080
+#define BIT8    0x0100
+#define BIT9    0x0200
+#define BIT10   0x0400
+#define BIT11   0x0800
+#define BIT12   0x1000
+#define BIT13   0x2000
+#define BIT14   0x4000
+#define BIT15   0x8000
+#define BIT16   0x00010000
+#define BIT17   0x00020000
+#define BIT18   0x00040000
+#define BIT19   0x00080000
+#define BIT20   0x00100000
+#define BIT21   0x00200000
+#define BIT22   0x00400000
+#define BIT23   0x00800000
+#define BIT24   0x01000000
+#define BIT25   0x02000000
+#define BIT26   0x04000000
+#define BIT27   0x08000000
+#define BIT28   0x10000000
+#define BIT29   0x20000000
+#define BIT30   0x40000000
+#define BIT31   0x80000000
+
+
+#define HDLC_MAX_FRAME_SIZE     65535
+#define MAX_ASYNC_TRANSMIT      4096
+#define MAX_ASYNC_BUFFER_SIZE   4096
+
+#define ASYNC_PARITY_NONE               0
+#define ASYNC_PARITY_EVEN               1
+#define ASYNC_PARITY_ODD                2
+#define ASYNC_PARITY_SPACE              3
+
+#define HDLC_FLAG_UNDERRUN_ABORT7       0x0000
+#define HDLC_FLAG_UNDERRUN_ABORT15      0x0001
+#define HDLC_FLAG_UNDERRUN_FLAG         0x0002
+#define HDLC_FLAG_UNDERRUN_CRC          0x0004
+#define HDLC_FLAG_SHARE_ZERO            0x0010
+#define HDLC_FLAG_AUTO_CTS              0x0020
+#define HDLC_FLAG_AUTO_DCD              0x0040
+#define HDLC_FLAG_AUTO_RTS              0x0080
+#define HDLC_FLAG_RXC_DPLL              0x0100
+#define HDLC_FLAG_RXC_BRG               0x0200
+#define HDLC_FLAG_RXC_TXCPIN            0x8000
+#define HDLC_FLAG_RXC_RXCPIN            0x0000
+#define HDLC_FLAG_TXC_DPLL              0x0400
+#define HDLC_FLAG_TXC_BRG               0x0800
+#define HDLC_FLAG_TXC_TXCPIN            0x0000
+#define HDLC_FLAG_TXC_RXCPIN            0x0008
+#define HDLC_FLAG_DPLL_DIV8             0x1000
+#define HDLC_FLAG_DPLL_DIV16            0x2000
+#define HDLC_FLAG_DPLL_DIV32            0x0000
+#define HDLC_FLAG_HDLC_LOOPMODE         0x4000
+
+#define HDLC_CRC_NONE                   0
+#define HDLC_CRC_16_CCITT               1
+#define HDLC_CRC_32_CCITT               2
+#define HDLC_CRC_MASK                   0x00ff
+#define HDLC_CRC_RETURN_EX              0x8000
+
+#define RX_OK                           0
+#define RX_CRC_ERROR                    1
+
+#define HDLC_TXIDLE_FLAGS               0
+#define HDLC_TXIDLE_ALT_ZEROS_ONES      1
+#define HDLC_TXIDLE_ZEROS               2
+#define HDLC_TXIDLE_ONES                3
+#define HDLC_TXIDLE_ALT_MARK_SPACE      4
+#define HDLC_TXIDLE_SPACE               5
+#define HDLC_TXIDLE_MARK                6
+
+#define HDLC_ENCODING_NRZ                       0
+#define HDLC_ENCODING_NRZB                      1
+#define HDLC_ENCODING_NRZI_MARK                 2
+#define HDLC_ENCODING_NRZI_SPACE                3
+#define HDLC_ENCODING_NRZI                      HDLC_ENCODING_NRZI_SPACE
+#define HDLC_ENCODING_BIPHASE_MARK              4
+#define HDLC_ENCODING_BIPHASE_SPACE             5
+#define HDLC_ENCODING_BIPHASE_LEVEL             6
+#define HDLC_ENCODING_DIFF_BIPHASE_LEVEL        7
+
+#define HDLC_PREAMBLE_LENGTH_8BITS      0
+#define HDLC_PREAMBLE_LENGTH_16BITS     1
+#define HDLC_PREAMBLE_LENGTH_32BITS     2
+#define HDLC_PREAMBLE_LENGTH_64BITS     3
+
+#define HDLC_PREAMBLE_PATTERN_NONE      0
+#define HDLC_PREAMBLE_PATTERN_ZEROS     1
+#define HDLC_PREAMBLE_PATTERN_FLAGS     2
+#define HDLC_PREAMBLE_PATTERN_10        3
+#define HDLC_PREAMBLE_PATTERN_01        4
+#define HDLC_PREAMBLE_PATTERN_ONES      5
+
+#define MGSL_MODE_ASYNC         1
+#define MGSL_MODE_HDLC          2
+#define MGSL_MODE_RAW           6
+
+#define MGSL_BUS_TYPE_ISA       1
+#define MGSL_BUS_TYPE_EISA      2
+#define MGSL_BUS_TYPE_PCI       5
+
+#define MGSL_INTERFACE_DISABLE  0
+#define MGSL_INTERFACE_RS232    1
+#define MGSL_INTERFACE_V35      2
+#define MGSL_INTERFACE_RS422    3
+
+typedef struct _MGSL_PARAMS
+{
+        /* Common */
+
+        unsigned long   mode;           /* Asynchronous or HDLC */
+        unsigned char   loopback;       /* internal loopback mode */
+
+        /* HDLC Only */
+
+        unsigned short  flags;
+        unsigned char   encoding;       /* NRZ, NRZI, etc. */
+        unsigned long   clock_speed;    /* external clock speed in bits per second */
+        unsigned char   addr_filter;    /* receive HDLC address filter, 0xFF = disable */
+        unsigned short  crc_type;       /* None, CRC16-CCITT, or CRC32-CCITT */
+        unsigned char   preamble_length;
+        unsigned char   preamble;
+
+        /* Async Only */
+
+        unsigned long   data_rate;      /* bits per second */
+        unsigned char   data_bits;      /* 7 or 8 data bits */
+        unsigned char   stop_bits;      /* 1 or 2 stop bits */
+        unsigned char   parity;         /* none, even, or odd */
+
+} MGSL_PARAMS, *PMGSL_PARAMS;
+
+#define MICROGATE_VENDOR_ID 0x13c0
+#define SYNCLINK_DEVICE_ID 0x0010
+#define MGSCC_DEVICE_ID 0x0020
+#define SYNCLINK_SCA_DEVICE_ID 0x0030
+#define MGSL_MAX_SERIAL_NUMBER 30
+
+/*
+** device diagnostics status
+*/
+
+#define DiagStatus_OK                           0
+#define DiagStatus_AddressFailure               1
+#define DiagStatus_AddressConflict              2
+#define DiagStatus_IrqFailure                   3
+#define DiagStatus_IrqConflict                  4
+#define DiagStatus_DmaFailure                   5
+#define DiagStatus_DmaConflict                  6
+#define DiagStatus_PciAdapterNotFound           7
+#define DiagStatus_CantAssignPciResources       8
+#define DiagStatus_CantAssignPciMemAddr         9
+#define DiagStatus_CantAssignPciIoAddr          10
+#define DiagStatus_CantAssignPciIrq             11
+#define DiagStatus_MemoryError                  12
+
+#define SerialSignal_DCD            0x01     /* Data Carrier Detect */
+#define SerialSignal_TXD            0x02     /* Transmit Data */
+#define SerialSignal_RI             0x04     /* Ring Indicator */
+#define SerialSignal_RXD            0x08     /* Receive Data */
+#define SerialSignal_CTS            0x10     /* Clear to Send */
+#define SerialSignal_RTS            0x20     /* Request to Send */
+#define SerialSignal_DSR            0x40     /* Data Set Ready */
+#define SerialSignal_DTR            0x80     /* Data Terminal Ready */
+
+
+/*
+ * Counters of the input lines (CTS, DSR, RI, CD) interrupts
+ */
+struct mgsl_icount {
+        __u32   cts, dsr, rng, dcd, tx, rx;
+        __u32   frame, parity, overrun, brk;
+        __u32   buf_overrun;
+        __u32   txok;
+        __u32   txunder;
+        __u32   txabort;
+        __u32   txtimeout;
+        __u32   rxshort;
+        __u32   rxlong;
+        __u32   rxabort;
+        __u32   rxover;
+        __u32   rxcrc;
+        __u32   rxok;
+        __u32   exithunt;
+        __u32   rxidle;
+};
+
+
+#define DEBUG_LEVEL_DATA        1
+#define DEBUG_LEVEL_ERROR       2
+#define DEBUG_LEVEL_INFO        3
+#define DEBUG_LEVEL_BH          4
+#define DEBUG_LEVEL_ISR         5
+
+/*
+** Event bit flags for use with MgslWaitEvent
+*/
+
+#define MgslEvent_DsrActive     0x0001
+#define MgslEvent_DsrInactive   0x0002
+#define MgslEvent_Dsr           0x0003
+#define MgslEvent_CtsActive     0x0004
+#define MgslEvent_CtsInactive   0x0008
+#define MgslEvent_Cts           0x000c
+#define MgslEvent_DcdActive     0x0010
+#define MgslEvent_DcdInactive   0x0020
+#define MgslEvent_Dcd           0x0030
+#define MgslEvent_RiActive      0x0040
+#define MgslEvent_RiInactive    0x0080
+#define MgslEvent_Ri            0x00c0
+#define MgslEvent_ExitHuntMode  0x0100
+#define MgslEvent_IdleReceived  0x0200
+
+/* Private IOCTL codes:
+ *
+ * MGSL_IOCSPARAMS      set MGSL_PARAMS structure values
+ * MGSL_IOCGPARAMS      get current MGSL_PARAMS structure values
+ * MGSL_IOCSTXIDLE      set current transmit idle mode
+ * MGSL_IOCGTXIDLE      get current transmit idle mode
+ * MGSL_IOCTXENABLE     enable or disable transmitter
+ * MGSL_IOCRXENABLE     enable or disable receiver
+ * MGSL_IOCTXABORT      abort transmitting frame (HDLC)
+ * MGSL_IOCGSTATS       return current statistics
+ * MGSL_IOCWAITEVENT    wait for specified event to occur
+ * MGSL_LOOPTXDONE      transmit in HDLC LoopMode done
+ * MGSL_IOCSIF          set the serial interface type
+ * MGSL_IOCGIF          get the serial interface type
+ */
+#define MGSL_MAGIC_IOC  'm'
+#define MGSL_IOCSPARAMS         _IOW(MGSL_MAGIC_IOC,0,struct _MGSL_PARAMS)
+#define MGSL_IOCGPARAMS         _IOR(MGSL_MAGIC_IOC,1,struct _MGSL_PARAMS)
+#define MGSL_IOCSTXIDLE         _IO(MGSL_MAGIC_IOC,2)
+#define MGSL_IOCGTXIDLE         _IO(MGSL_MAGIC_IOC,3)
+#define MGSL_IOCTXENABLE        _IO(MGSL_MAGIC_IOC,4)
+#define MGSL_IOCRXENABLE        _IO(MGSL_MAGIC_IOC,5)
+#define MGSL_IOCTXABORT         _IO(MGSL_MAGIC_IOC,6)
+#define MGSL_IOCGSTATS          _IO(MGSL_MAGIC_IOC,7)
+#define MGSL_IOCWAITEVENT       _IOWR(MGSL_MAGIC_IOC,8,int)
+#define MGSL_IOCCLRMODCOUNT     _IO(MGSL_MAGIC_IOC,15)
+#define MGSL_IOCLOOPTXDONE      _IO(MGSL_MAGIC_IOC,9)
+#define MGSL_IOCSIF             _IO(MGSL_MAGIC_IOC,10)
+#define MGSL_IOCGIF             _IO(MGSL_MAGIC_IOC,11)
+
+#endif /* _SYNCLINK_H_ */
diff --git a/include/linux/sys.h b/include/linux/sys.h
new file mode 100644
index 000000000000..daa6008bfdc8
--- /dev/null
+++ b/include/linux/sys.h
@@ -0,0 +1,29 @@
+#ifndef _LINUX_SYS_H
+#define _LINUX_SYS_H
+
+/*
+ * This file is no longer used or needed
+ */
+
+/*
+ * These are system calls that will be removed at some time
+ * due to newer versions existing..
+ * (please be careful - ibcs2 may need some of these).
+ */
+#ifdef notdef
+#define _sys_waitpid    _sys_old_syscall        /* _sys_wait4 */
+#define _sys_olduname   _sys_old_syscall        /* _sys_newuname */
+#define _sys_uname      _sys_old_syscall        /* _sys_newuname */
+#define _sys_stat       _sys_old_syscall        /* _sys_newstat */
+#define _sys_fstat      _sys_old_syscall        /* _sys_newfstat */
+#define _sys_lstat      _sys_old_syscall        /* _sys_newlstat */
+#define _sys_signal     _sys_old_syscall        /* _sys_sigaction */
+#define _sys_sgetmask   _sys_old_syscall        /* _sys_sigprocmask */
+#define _sys_ssetmask   _sys_old_syscall        /* _sys_sigprocmask */
+#endif
+
+/*
+ * These are system calls that haven't been implemented yet
+ * but have an entry in the table for future expansion..
+ */
+#endif
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
new file mode 100644
index 000000000000..757cd9be7743
--- /dev/null
+++ b/include/linux/syscalls.h
@@ -0,0 +1,509 @@
+/*
+ * syscalls.h - Linux syscall interfaces (non-arch-specific)
+ *
+ * Copyright (c) 2004 Randy Dunlap
+ * Copyright (c) 2004 Open Source Development Labs
+ *
+ * This file is released under the GPLv2.
+ * See the file COPYING for more details.
+ */
+
+#ifndef _LINUX_SYSCALLS_H
+#define _LINUX_SYSCALLS_H
+
+struct epoll_event;
+struct iattr;
+struct inode;
+struct iocb;
+struct io_event;
+struct iovec;
+struct itimerspec;
+struct itimerval;
+struct kexec_segment;
+struct linux_dirent;
+struct linux_dirent64;
+struct list_head;
+struct msgbuf;
+struct msghdr;
+struct msqid_ds;
+struct new_utsname;
+struct nfsctl_arg;
+struct __old_kernel_stat;
+struct pollfd;
+struct rlimit;
+struct rusage;
+struct sched_param;
+struct semaphore;
+struct sembuf;
+struct shmid_ds;
+struct sockaddr;
+struct stat;
+struct stat64;
+struct statfs;
+struct statfs64;
+struct __sysctl_args;
+struct sysinfo;
+struct timespec;
+struct timeval;
+struct timex;
+struct timezone;
+struct tms;
+struct utimbuf;
+struct mq_attr;
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/aio_abi.h>
+#include <linux/capability.h>
+#include <linux/list.h>
+#include <linux/sem.h>
+#include <asm/semaphore.h>
+#include <asm/siginfo.h>
+#include <asm/signal.h>
+#include <linux/quota.h>
+#include <linux/key.h>
+
+asmlinkage long sys_time(time_t __user *tloc);
+asmlinkage long sys_stime(time_t __user *tptr);
+asmlinkage long sys_gettimeofday(struct timeval __user *tv,
+                                struct timezone __user *tz);
+asmlinkage long sys_settimeofday(struct timeval __user *tv,
+                                struct timezone __user *tz);
+asmlinkage long sys_adjtimex(struct timex __user *txc_p);
+
+asmlinkage long sys_times(struct tms __user *tbuf);
+
+asmlinkage long sys_gettid(void);
+asmlinkage long sys_nanosleep(struct timespec __user *rqtp, struct timespec __user *rmtp);
+asmlinkage unsigned long sys_alarm(unsigned int seconds);
+asmlinkage long sys_getpid(void);
+asmlinkage long sys_getppid(void);
+asmlinkage long sys_getuid(void);
+asmlinkage long sys_geteuid(void);
+asmlinkage long sys_getgid(void);
+asmlinkage long sys_getegid(void);
+asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid);
+asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid);
+asmlinkage long sys_getpgid(pid_t pid);
+asmlinkage long sys_getpgrp(void);
+asmlinkage long sys_getsid(pid_t pid);
+asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist);
+
+asmlinkage long sys_setregid(gid_t rgid, gid_t egid);
+asmlinkage long sys_setgid(gid_t gid);
+asmlinkage long sys_setreuid(uid_t ruid, uid_t euid);
+asmlinkage long sys_setuid(uid_t uid);
+asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
+asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
+asmlinkage long sys_setfsuid(uid_t uid);
+asmlinkage long sys_setfsgid(gid_t gid);
+asmlinkage long sys_setpgid(pid_t pid, pid_t pgid);
+asmlinkage long sys_setsid(void);
+asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist);
+
+asmlinkage long sys_acct(const char __user *name);
+asmlinkage long sys_capget(cap_user_header_t header,
+                                cap_user_data_t dataptr);
+asmlinkage long sys_capset(cap_user_header_t header,
+                                const cap_user_data_t data);
+asmlinkage long sys_personality(u_long personality);
+
+asmlinkage long sys_sigpending(old_sigset_t __user *set);
+asmlinkage long sys_sigprocmask(int how, old_sigset_t __user *set,
+                                old_sigset_t __user *oset);
+asmlinkage long sys_getitimer(int which, struct itimerval __user *value);
+asmlinkage long sys_setitimer(int which,
+                                struct itimerval __user *value,
+                                struct itimerval __user *ovalue);
+asmlinkage long sys_timer_create(clockid_t which_clock,
+                                 struct sigevent __user *timer_event_spec,
+                                 timer_t __user * created_timer_id);
+asmlinkage long sys_timer_gettime(timer_t timer_id,
+                                struct itimerspec __user *setting);
+asmlinkage long sys_timer_getoverrun(timer_t timer_id);
+asmlinkage long sys_timer_settime(timer_t timer_id, int flags,
+                                const struct itimerspec __user *new_setting,
+                                struct itimerspec __user *old_setting);
+asmlinkage long sys_timer_delete(timer_t timer_id);
+asmlinkage long sys_clock_settime(clockid_t which_clock,
+                                const struct timespec __user *tp);
+asmlinkage long sys_clock_gettime(clockid_t which_clock,
+                                struct timespec __user *tp);
+asmlinkage long sys_clock_getres(clockid_t which_clock,
+                                struct timespec __user *tp);
+asmlinkage long sys_clock_nanosleep(clockid_t which_clock, int flags,
+                                const struct timespec __user *rqtp,
+                                struct timespec __user *rmtp);
+
+asmlinkage long sys_nice(int increment);
+asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,
+                                        struct sched_param __user *param);
+asmlinkage long sys_sched_setparam(pid_t pid,
+                                        struct sched_param __user *param);
+asmlinkage long sys_sched_getscheduler(pid_t pid);
+asmlinkage long sys_sched_getparam(pid_t pid,
+                                        struct sched_param __user *param);
+asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
+                                        unsigned long __user *user_mask_ptr);
+asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
+                                        unsigned long __user *user_mask_ptr);
+asmlinkage long sys_sched_yield(void);
+asmlinkage long sys_sched_get_priority_max(int policy);
+asmlinkage long sys_sched_get_priority_min(int policy);
+asmlinkage long sys_sched_rr_get_interval(pid_t pid,
+                                        struct timespec __user *interval);
+asmlinkage long sys_setpriority(int which, int who, int niceval);
+asmlinkage long sys_getpriority(int which, int who);
+
+asmlinkage long sys_shutdown(int, int);
+asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd,
+                                void __user *arg);
+asmlinkage long sys_restart_syscall(void);
+asmlinkage long sys_kexec_load(void *entry, unsigned long nr_segments,
+                        struct kexec_segment *segments, unsigned long flags);
+
+asmlinkage long sys_exit(int error_code);
+asmlinkage void sys_exit_group(int error_code);
+asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr,
+                                int options, struct rusage __user *ru);
+asmlinkage long sys_waitid(int which, pid_t pid,
+                           struct siginfo __user *infop,
+                           int options, struct rusage __user *ru);
+asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options);
+asmlinkage long sys_set_tid_address(int __user *tidptr);
+asmlinkage long sys_futex(u32 __user *uaddr, int op, int val,
+                        struct timespec __user *utime, u32 __user *uaddr2,
+                        int val3);
+
+asmlinkage long sys_init_module(void __user *umod, unsigned long len,
+                                const char __user *uargs);
+asmlinkage long sys_delete_module(const char __user *name_user,
+                                unsigned int flags);
+
+asmlinkage long sys_rt_sigprocmask(int how, sigset_t __user *set,
+                                sigset_t __user *oset, size_t sigsetsize);
+asmlinkage long sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize);
+asmlinkage long sys_rt_sigtimedwait(const sigset_t __user *uthese,
+                                siginfo_t __user *uinfo,
+                                const struct timespec __user *uts,
+                                size_t sigsetsize);
+asmlinkage long sys_kill(int pid, int sig);
+asmlinkage long sys_tgkill(int tgid, int pid, int sig);
+asmlinkage long sys_tkill(int pid, int sig);
+asmlinkage long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo);
+asmlinkage long sys_sgetmask(void);
+asmlinkage long sys_ssetmask(int newmask);
+asmlinkage unsigned long sys_signal(int sig, __sighandler_t handler);
+asmlinkage long sys_pause(void);
+
+asmlinkage long sys_sync(void);
+asmlinkage long sys_fsync(unsigned int fd);
+asmlinkage long sys_fdatasync(unsigned int fd);
+asmlinkage long sys_bdflush(int func, long data);
+asmlinkage long sys_mount(char __user *dev_name, char __user *dir_name,
+                                char __user *type, unsigned long flags,
+                                void __user *data);
+asmlinkage long sys_umount(char __user *name, int flags);
+asmlinkage long sys_oldumount(char __user *name);
+asmlinkage long sys_truncate(const char __user *path,
+                                unsigned long length);
+asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
+asmlinkage long sys_stat(char __user *filename,
+                        struct __old_kernel_stat __user *statbuf);
+asmlinkage long sys_statfs(const char __user * path,
+                                struct statfs __user *buf);
+asmlinkage long sys_statfs64(const char __user *path, size_t sz,
+                                struct statfs64 __user *buf);
+asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user *buf);
+asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz,
+                                struct statfs64 __user *buf);
+asmlinkage long sys_lstat(char __user *filename,
+                        struct __old_kernel_stat __user *statbuf);
+asmlinkage long sys_fstat(unsigned int fd,
+                        struct __old_kernel_stat __user *statbuf);
+asmlinkage long sys_newstat(char __user *filename,
+                                struct stat __user *statbuf);
+asmlinkage long sys_newlstat(char __user *filename,
+                                struct stat __user *statbuf);
+asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf);
+asmlinkage long sys_ustat(unsigned dev, struct ustat __user *ubuf);
+#if BITS_PER_LONG == 32
+asmlinkage long sys_stat64(char __user *filename,
+                                struct stat64 __user *statbuf);
+asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user *statbuf);
+asmlinkage long sys_lstat64(char __user *filename,
+                                struct stat64 __user *statbuf);
+asmlinkage long sys_truncate64(const char __user *path, loff_t length);
+asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length);
+#endif
+
+asmlinkage long sys_setxattr(char __user *path, char __user *name,
+                                void __user *value, size_t size, int flags);
+asmlinkage long sys_lsetxattr(char __user *path, char __user *name,
+                                void __user *value, size_t size, int flags);
+asmlinkage long sys_fsetxattr(int fd, char __user *name, void __user *value,
+                                size_t size, int flags);
+asmlinkage ssize_t sys_getxattr(char __user *path, char __user *name,
+                                void __user *value, size_t size);
+asmlinkage ssize_t sys_lgetxattr(char __user *path, char __user *name,
+                                void __user *value, size_t size);
+asmlinkage ssize_t sys_fgetxattr(int fd, char __user *name,
+                                void __user *value, size_t size);
+asmlinkage ssize_t sys_listxattr(char __user *path, char __user *list,
+                                size_t size);
+asmlinkage ssize_t sys_llistxattr(char __user *path, char __user *list,
+                                size_t size);
+asmlinkage ssize_t sys_flistxattr(int fd, char __user *list, size_t size);
+asmlinkage long sys_removexattr(char __user *path, char __user *name);
+asmlinkage long sys_lremovexattr(char __user *path, char __user *name);
+asmlinkage long sys_fremovexattr(int fd, char __user *name);
+
+asmlinkage unsigned long sys_brk(unsigned long brk);
+asmlinkage long sys_mprotect(unsigned long start, size_t len,
+                                unsigned long prot);
+asmlinkage unsigned long sys_mremap(unsigned long addr,
+                                unsigned long old_len, unsigned long new_len,
+                                unsigned long flags, unsigned long new_addr);
+asmlinkage long sys_remap_file_pages(unsigned long start, unsigned long size,
+                        unsigned long prot, unsigned long pgoff,
+                        unsigned long flags);
+asmlinkage long sys_msync(unsigned long start, size_t len, int flags);
+asmlinkage long sys_fadvise64(int fd, loff_t offset, size_t len, int advice);
+asmlinkage long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice);
+asmlinkage long sys_munmap(unsigned long addr, size_t len);
+asmlinkage long sys_mlock(unsigned long start, size_t len);
+asmlinkage long sys_munlock(unsigned long start, size_t len);
+asmlinkage long sys_mlockall(int flags);
+asmlinkage long sys_munlockall(void);
+asmlinkage long sys_madvise(unsigned long start, size_t len, int behavior);
+asmlinkage long sys_mincore(unsigned long start, size_t len,
+                                unsigned char __user * vec);
+
+asmlinkage long sys_pivot_root(const char __user *new_root,
+                                const char __user *put_old);
+asmlinkage long sys_chroot(const char __user *filename);
+asmlinkage long sys_mknod(const char __user *filename, int mode,
+                                unsigned dev);
+asmlinkage long sys_link(const char __user *oldname,
+                                const char __user *newname);
+asmlinkage long sys_symlink(const char __user *old, const char __user *new);
+asmlinkage long sys_unlink(const char __user *pathname);
+asmlinkage long sys_rename(const char __user *oldname,
+                                const char __user *newname);
+asmlinkage long sys_chmod(const char __user *filename, mode_t mode);
+asmlinkage long sys_fchmod(unsigned int fd, mode_t mode);
+
+asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
+#if BITS_PER_LONG == 32
+asmlinkage long sys_fcntl64(unsigned int fd,
+                                unsigned int cmd, unsigned long arg);
+#endif
+asmlinkage long sys_dup(unsigned int fildes);
+asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd);
+asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int on);
+asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd,
+                                unsigned long arg);
+asmlinkage long sys_flock(unsigned int fd, unsigned int cmd);
+asmlinkage long sys_io_setup(unsigned nr_reqs, aio_context_t __user *ctx);
+asmlinkage long sys_io_destroy(aio_context_t ctx);
+asmlinkage long sys_io_getevents(aio_context_t ctx_id,
+                                long min_nr,
+                                long nr,
+                                struct io_event __user *events,
+                                struct timespec __user *timeout);
+asmlinkage long sys_io_submit(aio_context_t, long,
+                                struct iocb __user * __user *);
+asmlinkage long sys_io_cancel(aio_context_t ctx_id, struct iocb __user *iocb,
+                              struct io_event __user *result);
+asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd,
+                                off_t __user *offset, size_t count);
+asmlinkage ssize_t sys_sendfile64(int out_fd, int in_fd,
+                                loff_t __user *offset, size_t count);
+asmlinkage long sys_readlink(const char __user *path,
+                                char __user *buf, int bufsiz);
+asmlinkage long sys_creat(const char __user *pathname, int mode);
+asmlinkage long sys_open(const char __user *filename,
+                                int flags, int mode);
+asmlinkage long sys_close(unsigned int fd);
+asmlinkage long sys_access(const char __user *filename, int mode);
+asmlinkage long sys_vhangup(void);
+asmlinkage long sys_chown(const char __user *filename,
+                                uid_t user, gid_t group);
+asmlinkage long sys_lchown(const char __user *filename,
+                                uid_t user, gid_t group);
+asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group);
+#ifdef CONFIG_UID16
+asmlinkage long sys_chown16(const char __user *filename,
+                                old_uid_t user, old_gid_t group);
+asmlinkage long sys_lchown16(const char __user *filename,
+                                old_uid_t user, old_gid_t group);
+asmlinkage long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group);
+asmlinkage long sys_setregid16(old_gid_t rgid, old_gid_t egid);
+asmlinkage long sys_setgid16(old_gid_t gid);
+asmlinkage long sys_setreuid16(old_uid_t ruid, old_uid_t euid);
+asmlinkage long sys_setuid16(old_uid_t uid);
+asmlinkage long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid);
+asmlinkage long sys_getresuid16(old_uid_t __user *ruid,
+                                old_uid_t __user *euid, old_uid_t __user *suid);
+asmlinkage long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid);
+asmlinkage long sys_getresgid16(old_gid_t __user *rgid,
+                                old_gid_t __user *egid, old_gid_t __user *sgid);
+asmlinkage long sys_setfsuid16(old_uid_t uid);
+asmlinkage long sys_setfsgid16(old_gid_t gid);
+asmlinkage long sys_getgroups16(int gidsetsize, old_gid_t __user *grouplist);
+asmlinkage long sys_setgroups16(int gidsetsize, old_gid_t __user *grouplist);
+asmlinkage long sys_getuid16(void);
+asmlinkage long sys_geteuid16(void);
+asmlinkage long sys_getgid16(void);
+asmlinkage long sys_getegid16(void);
+#endif
+
+asmlinkage long sys_utime(char __user *filename,
+                                struct utimbuf __user *times);
+asmlinkage long sys_utimes(char __user *filename,
+                                struct timeval __user *utimes);
+asmlinkage off_t sys_lseek(unsigned int fd, off_t offset,
+                                unsigned int origin);
+asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high,
+                        unsigned long offset_low, loff_t __user *result,
+                        unsigned int origin);
+asmlinkage ssize_t sys_read(unsigned int fd, char __user *buf,
+                                size_t count);
+asmlinkage ssize_t sys_readahead(int fd, loff_t offset, size_t count);
+asmlinkage ssize_t sys_readv(unsigned long fd,
+                                const struct iovec __user *vec,
+                                unsigned long vlen);
+asmlinkage ssize_t sys_write(unsigned int fd, const char __user *buf,
+                                size_t count);
+asmlinkage ssize_t sys_writev(unsigned long fd,
+                                const struct iovec __user *vec,
+                                unsigned long vlen);
+asmlinkage ssize_t sys_pread64(unsigned int fd, char __user *buf,
+                                size_t count, loff_t pos);
+asmlinkage ssize_t sys_pwrite64(unsigned int fd, const char __user *buf,
+                                size_t count, loff_t pos);
+asmlinkage long sys_getcwd(char __user *buf, unsigned long size);
+asmlinkage long sys_mkdir(const char __user *pathname, int mode);
+asmlinkage long sys_chdir(const char __user *filename);
+asmlinkage long sys_fchdir(unsigned int fd);
+asmlinkage long sys_rmdir(const char __user *pathname);
+asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user *buf, size_t len);
+asmlinkage long sys_quotactl(unsigned int cmd, const char __user *special,
+                                qid_t id, void __user *addr);
+asmlinkage long sys_getdents(unsigned int fd,
+                                struct linux_dirent __user *dirent,
+                                unsigned int count);
+asmlinkage long sys_getdents64(unsigned int fd,
+                                struct linux_dirent64 __user *dirent,
+                                unsigned int count);
+
+asmlinkage long sys_setsockopt(int fd, int level, int optname,
+                                char __user *optval, int optlen);
+asmlinkage long sys_getsockopt(int fd, int level, int optname,
+                                char __user *optval, int __user *optlen);
+asmlinkage long sys_bind(int, struct sockaddr __user *, int);
+asmlinkage long sys_connect(int, struct sockaddr __user *, int);
+asmlinkage long sys_accept(int, struct sockaddr __user *, int __user *);
+asmlinkage long sys_getsockname(int, struct sockaddr __user *, int __user *);
+asmlinkage long sys_getpeername(int, struct sockaddr __user *, int __user *);
+asmlinkage long sys_send(int, void __user *, size_t, unsigned);
+asmlinkage long sys_sendto(int, void __user *, size_t, unsigned,
+                                struct sockaddr __user *, int);
+asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
+asmlinkage long sys_recv(int, void __user *, size_t, unsigned);
+asmlinkage long sys_recvfrom(int, void __user *, size_t, unsigned,
+                                struct sockaddr __user *, int __user *);
+asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags);
+asmlinkage long sys_socket(int, int, int);
+asmlinkage long sys_socketpair(int, int, int, int __user *);
+asmlinkage long sys_socketcall(int call, unsigned long __user *args);
+asmlinkage long sys_listen(int, int);
+asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
+                                long timeout);
+asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
+                        fd_set __user *exp, struct timeval __user *tvp);
+asmlinkage long sys_epoll_create(int size);
+asmlinkage long sys_epoll_ctl(int epfd, int op, int fd,
+                                struct epoll_event __user *event);
+asmlinkage long sys_epoll_wait(int epfd, struct epoll_event __user *events,
+                                int maxevents, int timeout);
+asmlinkage long sys_gethostname(char __user *name, int len);
+asmlinkage long sys_sethostname(char __user *name, int len);
+asmlinkage long sys_setdomainname(char __user *name, int len);
+asmlinkage long sys_newuname(struct new_utsname __user *name);
+
+asmlinkage long sys_getrlimit(unsigned int resource,
+                                struct rlimit __user *rlim);
+#if defined(COMPAT_RLIM_OLD_INFINITY) || !(defined(CONFIG_IA64) || defined(CONFIG_V850))
+asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim);
+#endif
+asmlinkage long sys_setrlimit(unsigned int resource,
+                                struct rlimit __user *rlim);
+asmlinkage long sys_getrusage(int who, struct rusage __user *ru);
+asmlinkage long sys_umask(int mask);
+
+asmlinkage long sys_msgget(key_t key, int msgflg);
+asmlinkage long sys_msgsnd(int msqid, struct msgbuf __user *msgp,
+                                size_t msgsz, int msgflg);
+asmlinkage long sys_msgrcv(int msqid, struct msgbuf __user *msgp,
+                                size_t msgsz, long msgtyp, int msgflg);
+asmlinkage long sys_msgctl(int msqid, int cmd, struct msqid_ds __user *buf);
+
+asmlinkage long sys_semget(key_t key, int nsems, int semflg);
+asmlinkage long sys_semop(int semid, struct sembuf __user *sops,
+                                unsigned nsops);
+asmlinkage long sys_semctl(int semid, int semnum, int cmd, union semun arg);
+asmlinkage long sys_semtimedop(int semid, struct sembuf __user *sops,
+                                unsigned nsops,
+                                const struct timespec __user *timeout);
+asmlinkage long sys_shmat(int shmid, char __user *shmaddr,
+                                int shmflg, unsigned long __user *addr);
+asmlinkage long sys_shmget(key_t key, size_t size, int flag);
+asmlinkage long sys_shmdt(char __user *shmaddr);
+asmlinkage long sys_shmctl(int shmid, int cmd, struct shmid_ds __user *buf);
+
+asmlinkage long sys_mq_open(const char __user *name, int oflag, mode_t mode, struct mq_attr __user *attr);
+asmlinkage long sys_mq_unlink(const char __user *name);
+asmlinkage long sys_mq_timedsend(mqd_t mqdes, const char __user *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec __user *abs_timeout);
+asmlinkage ssize_t sys_mq_timedreceive(mqd_t mqdes, char __user *msg_ptr, size_t msg_len, unsigned int __user *msg_prio, const struct timespec __user *abs_timeout);
+asmlinkage long sys_mq_notify(mqd_t mqdes, const struct sigevent __user *notification);
+asmlinkage long sys_mq_getsetattr(mqd_t mqdes, const struct mq_attr __user *mqstat, struct mq_attr __user *omqstat);
+
+asmlinkage long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn);
+asmlinkage long sys_pciconfig_read(unsigned long bus, unsigned long dfn,
+                                unsigned long off, unsigned long len,
+                                void __user *buf);
+asmlinkage long sys_pciconfig_write(unsigned long bus, unsigned long dfn,
+                                unsigned long off, unsigned long len,
+                                void __user *buf);
+
+asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
+                        unsigned long arg4, unsigned long arg5);
+asmlinkage long sys_swapon(const char __user *specialfile, int swap_flags);
+asmlinkage long sys_swapoff(const char __user *specialfile);
+asmlinkage long sys_sysctl(struct __sysctl_args __user *args);
+asmlinkage long sys_sysinfo(struct sysinfo __user *info);
+asmlinkage long sys_sysfs(int option,
+                                unsigned long arg1, unsigned long arg2);
+asmlinkage long sys_nfsservctl(int cmd,
+                                struct nfsctl_arg __user *arg,
+                                void __user *res);
+asmlinkage long sys_syslog(int type, char __user *buf, int len);
+asmlinkage long sys_uselib(const char __user *library);
+asmlinkage long sys_ni_syscall(void);
+
+asmlinkage long sys_add_key(const char __user *_type,
+                            const char __user *_description,
+                            const void __user *_payload,
+                            size_t plen,
+                            key_serial_t destringid);
+
+asmlinkage long sys_request_key(const char __user *_type,
+                                const char __user *_description,
+                                const char __user *_callout_info,
+                                key_serial_t destringid);
+
+asmlinkage long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
+                           unsigned long arg4, unsigned long arg5);
+
+#endif
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
new file mode 100644
index 000000000000..358d52b0c445
--- /dev/null
+++ b/include/linux/sysctl.h
@@ -0,0 +1,898 @@
+/*
+ * sysctl.h: General linux system control interface
+ *
+ * Begun 24 March 1995, Stephen Tweedie
+ *
+ ****************************************************************
+ ****************************************************************
+ **
+ **  The values in this file are exported to user space via 
+ **  the sysctl() binary interface.  However this interface
+ **  is unstable and deprecated and will be removed in the future. 
+ **  For a stable interface use /proc/sys.
+ **
+ ****************************************************************
+ ****************************************************************
+ */
+
+#ifndef _LINUX_SYSCTL_H
+#define _LINUX_SYSCTL_H
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/compiler.h>
+
+struct file;
+
+#define CTL_MAXNAME 10          /* how many path components do we allow in a
+                                   call to sysctl?   In other words, what is
+                                   the largest acceptable value for the nlen
+                                   member of a struct __sysctl_args to have? */
+
+struct __sysctl_args {
+        int __user *name;
+        int nlen;
+        void __user *oldval;
+        size_t __user *oldlenp;
+        void __user *newval;
+        size_t newlen;
+        unsigned long __unused[4];
+};
+
+/* Define sysctl names first */
+
+/* Top-level names: */
+
+/* For internal pattern-matching use only: */
+#ifdef __KERNEL__
+#define CTL_ANY         -1      /* Matches any name */
+#define CTL_NONE        0
+#endif
+
+enum
+{
+        CTL_KERN=1,             /* General kernel info and control */
+        CTL_VM=2,               /* VM management */
+        CTL_NET=3,              /* Networking */
+        CTL_PROC=4,             /* Process info */
+        CTL_FS=5,               /* Filesystems */
+        CTL_DEBUG=6,            /* Debugging */
+        CTL_DEV=7,              /* Devices */
+        CTL_BUS=8,              /* Busses */
+        CTL_ABI=9,              /* Binary emulation */
+        CTL_CPU=10              /* CPU stuff (speed scaling, etc) */
+};
+
+/* CTL_BUS names: */
+enum
+{
+        CTL_BUS_ISA=1           /* ISA */
+};
+
+/* CTL_KERN names: */
+enum
+{
+        KERN_OSTYPE=1,          /* string: system version */
+        KERN_OSRELEASE=2,       /* string: system release */
+        KERN_OSREV=3,           /* int: system revision */
+        KERN_VERSION=4,         /* string: compile time info */
+        KERN_SECUREMASK=5,      /* struct: maximum rights mask */
+        KERN_PROF=6,            /* table: profiling information */
+        KERN_NODENAME=7,
+        KERN_DOMAINNAME=8,
+
+        KERN_CAP_BSET=14,       /* int: capability bounding set */
+        KERN_PANIC=15,          /* int: panic timeout */
+        KERN_REALROOTDEV=16,    /* real root device to mount after initrd */
+
+        KERN_SPARC_REBOOT=21,   /* reboot command on Sparc */
+        KERN_CTLALTDEL=22,      /* int: allow ctl-alt-del to reboot */
+        KERN_PRINTK=23,         /* struct: control printk logging parameters */
+        KERN_NAMETRANS=24,      /* Name translation */
+        KERN_PPC_HTABRECLAIM=25, /* turn htab reclaimation on/off on PPC */
+        KERN_PPC_ZEROPAGED=26,  /* turn idle page zeroing on/off on PPC */
+        KERN_PPC_POWERSAVE_NAP=27, /* use nap mode for power saving */
+        KERN_MODPROBE=28,
+        KERN_SG_BIG_BUFF=29,
+        KERN_ACCT=30,           /* BSD process accounting parameters */
+        KERN_PPC_L2CR=31,       /* l2cr register on PPC */
+
+        KERN_RTSIGNR=32,        /* Number of rt sigs queued */
+        KERN_RTSIGMAX=33,       /* Max queuable */
+        
+        KERN_SHMMAX=34,         /* long: Maximum shared memory segment */
+        KERN_MSGMAX=35,         /* int: Maximum size of a messege */
+        KERN_MSGMNB=36,         /* int: Maximum message queue size */
+        KERN_MSGPOOL=37,        /* int: Maximum system message pool size */
+        KERN_SYSRQ=38,          /* int: Sysreq enable */
+        KERN_MAX_THREADS=39,    /* int: Maximum nr of threads in the system */
+        KERN_RANDOM=40,         /* Random driver */
+        KERN_SHMALL=41,         /* int: Maximum size of shared memory */
+        KERN_MSGMNI=42,         /* int: msg queue identifiers */
+        KERN_SEM=43,            /* struct: sysv semaphore limits */
+        KERN_SPARC_STOP_A=44,   /* int: Sparc Stop-A enable */
+        KERN_SHMMNI=45,         /* int: shm array identifiers */
+        KERN_OVERFLOWUID=46,    /* int: overflow UID */
+        KERN_OVERFLOWGID=47,    /* int: overflow GID */
+        KERN_SHMPATH=48,        /* string: path to shm fs */
+        KERN_HOTPLUG=49,        /* string: path to hotplug policy agent */
+        KERN_IEEE_EMULATION_WARNINGS=50, /* int: unimplemented ieee instructions */
+        KERN_S390_USER_DEBUG_LOGGING=51,  /* int: dumps of user faults */
+        KERN_CORE_USES_PID=52,          /* int: use core or core.%pid */
+        KERN_TAINTED=53,        /* int: various kernel tainted flags */
+        KERN_CADPID=54,         /* int: PID of the process to notify on CAD */
+        KERN_PIDMAX=55,         /* int: PID # limit */
+        KERN_CORE_PATTERN=56,   /* string: pattern for core-file names */
+        KERN_PANIC_ON_OOPS=57,  /* int: whether we will panic on an oops */
+        KERN_HPPA_PWRSW=58,     /* int: hppa soft-power enable */
+        KERN_HPPA_UNALIGNED=59, /* int: hppa unaligned-trap enable */
+        KERN_PRINTK_RATELIMIT=60, /* int: tune printk ratelimiting */
+        KERN_PRINTK_RATELIMIT_BURST=61, /* int: tune printk ratelimiting */
+        KERN_PTY=62,            /* dir: pty driver */
+        KERN_NGROUPS_MAX=63,    /* int: NGROUPS_MAX */
+        KERN_SPARC_SCONS_PWROFF=64, /* int: serial console power-off halt */
+        KERN_HZ_TIMER=65,       /* int: hz timer on or off */
+        KERN_UNKNOWN_NMI_PANIC=66, /* int: unknown nmi panic flag */
+        KERN_BOOTLOADER_TYPE=67, /* int: boot loader type */
+        KERN_RANDOMIZE=68, /* int: randomize virtual address space */
+};
+
+
+/* CTL_VM names: */
+enum
+{
+        VM_UNUSED1=1,           /* was: struct: Set vm swapping control */
+        VM_UNUSED2=2,           /* was; int: Linear or sqrt() swapout for hogs */
+        VM_UNUSED3=3,           /* was: struct: Set free page thresholds */
+        VM_UNUSED4=4,           /* Spare */
+        VM_OVERCOMMIT_MEMORY=5, /* Turn off the virtual memory safety limit */
+        VM_UNUSED5=6,           /* was: struct: Set buffer memory thresholds */
+        VM_UNUSED7=7,           /* was: struct: Set cache memory thresholds */
+        VM_UNUSED8=8,           /* was: struct: Control kswapd behaviour */
+        VM_UNUSED9=9,           /* was: struct: Set page table cache parameters */
+        VM_PAGE_CLUSTER=10,     /* int: set number of pages to swap together */
+        VM_DIRTY_BACKGROUND=11, /* dirty_background_ratio */
+        VM_DIRTY_RATIO=12,      /* dirty_ratio */
+        VM_DIRTY_WB_CS=13,      /* dirty_writeback_centisecs */
+        VM_DIRTY_EXPIRE_CS=14,  /* dirty_expire_centisecs */
+        VM_NR_PDFLUSH_THREADS=15, /* nr_pdflush_threads */
+        VM_OVERCOMMIT_RATIO=16, /* percent of RAM to allow overcommit in */
+        VM_PAGEBUF=17,          /* struct: Control pagebuf parameters */
+        VM_HUGETLB_PAGES=18,    /* int: Number of available Huge Pages */
+        VM_SWAPPINESS=19,       /* Tendency to steal mapped memory */
+        VM_LOWMEM_RESERVE_RATIO=20,/* reservation ratio for lower memory zones */
+        VM_MIN_FREE_KBYTES=21,  /* Minimum free kilobytes to maintain */
+        VM_MAX_MAP_COUNT=22,    /* int: Maximum number of mmaps/address-space */
+        VM_LAPTOP_MODE=23,      /* vm laptop mode */
+        VM_BLOCK_DUMP=24,       /* block dump mode */
+        VM_HUGETLB_GROUP=25,    /* permitted hugetlb group */
+        VM_VFS_CACHE_PRESSURE=26, /* dcache/icache reclaim pressure */
+        VM_LEGACY_VA_LAYOUT=27, /* legacy/compatibility virtual address space layout */
+        VM_SWAP_TOKEN_TIMEOUT=28, /* default time for token time out */
+};
+
+
+/* CTL_NET names: */
+enum
+{
+        NET_CORE=1,
+        NET_ETHER=2,
+        NET_802=3,
+        NET_UNIX=4,
+        NET_IPV4=5,
+        NET_IPX=6,
+        NET_ATALK=7,
+        NET_NETROM=8,
+        NET_AX25=9,
+        NET_BRIDGE=10,
+        NET_ROSE=11,
+        NET_IPV6=12,
+        NET_X25=13,
+        NET_TR=14,
+        NET_DECNET=15,
+        NET_ECONET=16,
+        NET_SCTP=17, 
+};
+
+/* /proc/sys/kernel/random */
+enum
+{
+        RANDOM_POOLSIZE=1,
+        RANDOM_ENTROPY_COUNT=2,
+        RANDOM_READ_THRESH=3,
+        RANDOM_WRITE_THRESH=4,
+        RANDOM_BOOT_ID=5,
+        RANDOM_UUID=6
+};
+
+/* /proc/sys/kernel/pty */
+enum
+{
+        PTY_MAX=1,
+        PTY_NR=2
+};
+
+/* /proc/sys/bus/isa */
+enum
+{
+        BUS_ISA_MEM_BASE=1,
+        BUS_ISA_PORT_BASE=2,
+        BUS_ISA_PORT_SHIFT=3
+};
+
+/* /proc/sys/net/core */
+enum
+{
+        NET_CORE_WMEM_MAX=1,
+        NET_CORE_RMEM_MAX=2,
+        NET_CORE_WMEM_DEFAULT=3,
+        NET_CORE_RMEM_DEFAULT=4,
+/* was  NET_CORE_DESTROY_DELAY */
+        NET_CORE_MAX_BACKLOG=6,
+        NET_CORE_FASTROUTE=7,
+        NET_CORE_MSG_COST=8,
+        NET_CORE_MSG_BURST=9,
+        NET_CORE_OPTMEM_MAX=10,
+        NET_CORE_HOT_LIST_LENGTH=11,
+        NET_CORE_DIVERT_VERSION=12,
+        NET_CORE_NO_CONG_THRESH=13,
+        NET_CORE_NO_CONG=14,
+        NET_CORE_LO_CONG=15,
+        NET_CORE_MOD_CONG=16,
+        NET_CORE_DEV_WEIGHT=17,
+        NET_CORE_SOMAXCONN=18,
+};
+
+/* /proc/sys/net/ethernet */
+
+/* /proc/sys/net/802 */
+
+/* /proc/sys/net/unix */
+
+enum
+{
+        NET_UNIX_DESTROY_DELAY=1,
+        NET_UNIX_DELETE_DELAY=2,
+        NET_UNIX_MAX_DGRAM_QLEN=3,
+};
+
+/* /proc/sys/net/ipv4 */
+enum
+{
+        /* v2.0 compatibile variables */
+        NET_IPV4_FORWARD=8,
+        NET_IPV4_DYNADDR=9,
+
+        NET_IPV4_CONF=16,
+        NET_IPV4_NEIGH=17,
+        NET_IPV4_ROUTE=18,
+        NET_IPV4_FIB_HASH=19,
+        NET_IPV4_NETFILTER=20,
+
+        NET_IPV4_TCP_TIMESTAMPS=33,
+        NET_IPV4_TCP_WINDOW_SCALING=34,
+        NET_IPV4_TCP_SACK=35,
+        NET_IPV4_TCP_RETRANS_COLLAPSE=36,
+        NET_IPV4_DEFAULT_TTL=37,
+        NET_IPV4_AUTOCONFIG=38,
+        NET_IPV4_NO_PMTU_DISC=39,
+        NET_IPV4_TCP_SYN_RETRIES=40,
+        NET_IPV4_IPFRAG_HIGH_THRESH=41,
+        NET_IPV4_IPFRAG_LOW_THRESH=42,
+        NET_IPV4_IPFRAG_TIME=43,
+        NET_IPV4_TCP_MAX_KA_PROBES=44,
+        NET_IPV4_TCP_KEEPALIVE_TIME=45,
+        NET_IPV4_TCP_KEEPALIVE_PROBES=46,
+        NET_IPV4_TCP_RETRIES1=47,
+        NET_IPV4_TCP_RETRIES2=48,
+        NET_IPV4_TCP_FIN_TIMEOUT=49,
+        NET_IPV4_IP_MASQ_DEBUG=50,
+        NET_TCP_SYNCOOKIES=51,
+        NET_TCP_STDURG=52,
+        NET_TCP_RFC1337=53,
+        NET_TCP_SYN_TAILDROP=54,
+        NET_TCP_MAX_SYN_BACKLOG=55,
+        NET_IPV4_LOCAL_PORT_RANGE=56,
+        NET_IPV4_ICMP_ECHO_IGNORE_ALL=57,
+        NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS=58,
+        NET_IPV4_ICMP_SOURCEQUENCH_RATE=59,
+        NET_IPV4_ICMP_DESTUNREACH_RATE=60,
+        NET_IPV4_ICMP_TIMEEXCEED_RATE=61,
+        NET_IPV4_ICMP_PARAMPROB_RATE=62,
+        NET_IPV4_ICMP_ECHOREPLY_RATE=63,
+        NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES=64,
+        NET_IPV4_IGMP_MAX_MEMBERSHIPS=65,
+        NET_TCP_TW_RECYCLE=66,
+        NET_IPV4_ALWAYS_DEFRAG=67,
+        NET_IPV4_TCP_KEEPALIVE_INTVL=68,
+        NET_IPV4_INET_PEER_THRESHOLD=69,
+        NET_IPV4_INET_PEER_MINTTL=70,
+        NET_IPV4_INET_PEER_MAXTTL=71,
+        NET_IPV4_INET_PEER_GC_MINTIME=72,
+        NET_IPV4_INET_PEER_GC_MAXTIME=73,
+        NET_TCP_ORPHAN_RETRIES=74,
+        NET_TCP_ABORT_ON_OVERFLOW=75,
+        NET_TCP_SYNACK_RETRIES=76,
+        NET_TCP_MAX_ORPHANS=77,
+        NET_TCP_MAX_TW_BUCKETS=78,
+        NET_TCP_FACK=79,
+        NET_TCP_REORDERING=80,
+        NET_TCP_ECN=81,
+        NET_TCP_DSACK=82,
+        NET_TCP_MEM=83,
+        NET_TCP_WMEM=84,
+        NET_TCP_RMEM=85,
+        NET_TCP_APP_WIN=86,
+        NET_TCP_ADV_WIN_SCALE=87,
+        NET_IPV4_NONLOCAL_BIND=88,
+        NET_IPV4_ICMP_RATELIMIT=89,
+        NET_IPV4_ICMP_RATEMASK=90,
+        NET_TCP_TW_REUSE=91,
+        NET_TCP_FRTO=92,
+        NET_TCP_LOW_LATENCY=93,
+        NET_IPV4_IPFRAG_SECRET_INTERVAL=94,
+        NET_TCP_WESTWOOD=95,
+        NET_IPV4_IGMP_MAX_MSF=96,
+        NET_TCP_NO_METRICS_SAVE=97,
+        NET_TCP_VEGAS=98,
+        NET_TCP_VEGAS_ALPHA=99,
+        NET_TCP_VEGAS_BETA=100,
+        NET_TCP_VEGAS_GAMMA=101,
+        NET_TCP_BIC=102,
+        NET_TCP_BIC_FAST_CONVERGENCE=103,
+        NET_TCP_BIC_LOW_WINDOW=104,
+        NET_TCP_DEFAULT_WIN_SCALE=105,
+        NET_TCP_MODERATE_RCVBUF=106,
+        NET_TCP_TSO_WIN_DIVISOR=107,
+        NET_TCP_BIC_BETA=108,
+};
+
+enum {
+        NET_IPV4_ROUTE_FLUSH=1,
+        NET_IPV4_ROUTE_MIN_DELAY=2,
+        NET_IPV4_ROUTE_MAX_DELAY=3,
+        NET_IPV4_ROUTE_GC_THRESH=4,
+        NET_IPV4_ROUTE_MAX_SIZE=5,
+        NET_IPV4_ROUTE_GC_MIN_INTERVAL=6,
+        NET_IPV4_ROUTE_GC_TIMEOUT=7,
+        NET_IPV4_ROUTE_GC_INTERVAL=8,
+        NET_IPV4_ROUTE_REDIRECT_LOAD=9,
+        NET_IPV4_ROUTE_REDIRECT_NUMBER=10,
+        NET_IPV4_ROUTE_REDIRECT_SILENCE=11,
+        NET_IPV4_ROUTE_ERROR_COST=12,
+        NET_IPV4_ROUTE_ERROR_BURST=13,
+        NET_IPV4_ROUTE_GC_ELASTICITY=14,
+        NET_IPV4_ROUTE_MTU_EXPIRES=15,
+        NET_IPV4_ROUTE_MIN_PMTU=16,
+        NET_IPV4_ROUTE_MIN_ADVMSS=17,
+        NET_IPV4_ROUTE_SECRET_INTERVAL=18,
+        NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS=19,
+};
+
+enum
+{
+        NET_PROTO_CONF_ALL=-2,
+        NET_PROTO_CONF_DEFAULT=-3
+
+        /* And device ifindices ... */
+};
+
+enum
+{
+        NET_IPV4_CONF_FORWARDING=1,
+        NET_IPV4_CONF_MC_FORWARDING=2,
+        NET_IPV4_CONF_PROXY_ARP=3,
+        NET_IPV4_CONF_ACCEPT_REDIRECTS=4,
+        NET_IPV4_CONF_SECURE_REDIRECTS=5,
+        NET_IPV4_CONF_SEND_REDIRECTS=6,
+        NET_IPV4_CONF_SHARED_MEDIA=7,
+        NET_IPV4_CONF_RP_FILTER=8,
+        NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE=9,
+        NET_IPV4_CONF_BOOTP_RELAY=10,
+        NET_IPV4_CONF_LOG_MARTIANS=11,
+        NET_IPV4_CONF_TAG=12,
+        NET_IPV4_CONF_ARPFILTER=13,
+        NET_IPV4_CONF_MEDIUM_ID=14,
+        NET_IPV4_CONF_NOXFRM=15,
+        NET_IPV4_CONF_NOPOLICY=16,
+        NET_IPV4_CONF_FORCE_IGMP_VERSION=17,
+        NET_IPV4_CONF_ARP_ANNOUNCE=18,
+        NET_IPV4_CONF_ARP_IGNORE=19,
+        __NET_IPV4_CONF_MAX
+};
+
+/* /proc/sys/net/ipv4/netfilter */
+enum
+{
+        NET_IPV4_NF_CONNTRACK_MAX=1,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
+        NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT=10,
+        NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
+        NET_IPV4_NF_CONNTRACK_ICMP_TIMEOUT=12,
+        NET_IPV4_NF_CONNTRACK_GENERIC_TIMEOUT=13,
+        NET_IPV4_NF_CONNTRACK_BUCKETS=14,
+        NET_IPV4_NF_CONNTRACK_LOG_INVALID=15,
+        NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
+        NET_IPV4_NF_CONNTRACK_TCP_LOOSE=17,
+        NET_IPV4_NF_CONNTRACK_TCP_BE_LIBERAL=18,
+        NET_IPV4_NF_CONNTRACK_TCP_MAX_RETRANS=19,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
+        NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
+        NET_IPV4_NF_CONNTRACK_COUNT=27,
+};
+ 
+/* /proc/sys/net/ipv6 */
+enum {
+        NET_IPV6_CONF=16,
+        NET_IPV6_NEIGH=17,
+        NET_IPV6_ROUTE=18,
+        NET_IPV6_ICMP=19,
+        NET_IPV6_BINDV6ONLY=20,
+        NET_IPV6_IP6FRAG_HIGH_THRESH=21,
+        NET_IPV6_IP6FRAG_LOW_THRESH=22,
+        NET_IPV6_IP6FRAG_TIME=23,
+        NET_IPV6_IP6FRAG_SECRET_INTERVAL=24,
+        NET_IPV6_MLD_MAX_MSF=25,
+};
+
+enum {
+        NET_IPV6_ROUTE_FLUSH=1,
+        NET_IPV6_ROUTE_GC_THRESH=2,
+        NET_IPV6_ROUTE_MAX_SIZE=3,
+        NET_IPV6_ROUTE_GC_MIN_INTERVAL=4,
+        NET_IPV6_ROUTE_GC_TIMEOUT=5,
+        NET_IPV6_ROUTE_GC_INTERVAL=6,
+        NET_IPV6_ROUTE_GC_ELASTICITY=7,
+        NET_IPV6_ROUTE_MTU_EXPIRES=8,
+        NET_IPV6_ROUTE_MIN_ADVMSS=9,
+        NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS=10
+};
+
+enum {
+        NET_IPV6_FORWARDING=1,
+        NET_IPV6_HOP_LIMIT=2,
+        NET_IPV6_MTU=3,
+        NET_IPV6_ACCEPT_RA=4,
+        NET_IPV6_ACCEPT_REDIRECTS=5,
+        NET_IPV6_AUTOCONF=6,
+        NET_IPV6_DAD_TRANSMITS=7,
+        NET_IPV6_RTR_SOLICITS=8,
+        NET_IPV6_RTR_SOLICIT_INTERVAL=9,
+        NET_IPV6_RTR_SOLICIT_DELAY=10,
+        NET_IPV6_USE_TEMPADDR=11,
+        NET_IPV6_TEMP_VALID_LFT=12,
+        NET_IPV6_TEMP_PREFERED_LFT=13,
+        NET_IPV6_REGEN_MAX_RETRY=14,
+        NET_IPV6_MAX_DESYNC_FACTOR=15,
+        NET_IPV6_MAX_ADDRESSES=16,
+        NET_IPV6_FORCE_MLD_VERSION=17,
+        __NET_IPV6_MAX
+};
+
+/* /proc/sys/net/ipv6/icmp */
+enum {
+        NET_IPV6_ICMP_RATELIMIT=1
+};
+
+/* /proc/sys/net/<protocol>/neigh/<dev> */
+enum {
+        NET_NEIGH_MCAST_SOLICIT=1,
+        NET_NEIGH_UCAST_SOLICIT=2,
+        NET_NEIGH_APP_SOLICIT=3,
+        NET_NEIGH_RETRANS_TIME=4,
+        NET_NEIGH_REACHABLE_TIME=5,
+        NET_NEIGH_DELAY_PROBE_TIME=6,
+        NET_NEIGH_GC_STALE_TIME=7,
+        NET_NEIGH_UNRES_QLEN=8,
+        NET_NEIGH_PROXY_QLEN=9,
+        NET_NEIGH_ANYCAST_DELAY=10,
+        NET_NEIGH_PROXY_DELAY=11,
+        NET_NEIGH_LOCKTIME=12,
+        NET_NEIGH_GC_INTERVAL=13,
+        NET_NEIGH_GC_THRESH1=14,
+        NET_NEIGH_GC_THRESH2=15,
+        NET_NEIGH_GC_THRESH3=16,
+        NET_NEIGH_RETRANS_TIME_MS=17,
+        NET_NEIGH_REACHABLE_TIME_MS=18,
+        __NET_NEIGH_MAX
+};
+
+/* /proc/sys/net/ipx */
+enum {
+        NET_IPX_PPROP_BROADCASTING=1,
+        NET_IPX_FORWARDING=2
+};
+
+
+/* /proc/sys/net/appletalk */
+enum {
+        NET_ATALK_AARP_EXPIRY_TIME=1,
+        NET_ATALK_AARP_TICK_TIME=2,
+        NET_ATALK_AARP_RETRANSMIT_LIMIT=3,
+        NET_ATALK_AARP_RESOLVE_TIME=4
+};
+
+
+/* /proc/sys/net/netrom */
+enum {
+        NET_NETROM_DEFAULT_PATH_QUALITY=1,
+        NET_NETROM_OBSOLESCENCE_COUNT_INITIALISER=2,
+        NET_NETROM_NETWORK_TTL_INITIALISER=3,
+        NET_NETROM_TRANSPORT_TIMEOUT=4,
+        NET_NETROM_TRANSPORT_MAXIMUM_TRIES=5,
+        NET_NETROM_TRANSPORT_ACKNOWLEDGE_DELAY=6,
+        NET_NETROM_TRANSPORT_BUSY_DELAY=7,
+        NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE=8,
+        NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT=9,
+        NET_NETROM_ROUTING_CONTROL=10,
+        NET_NETROM_LINK_FAILS_COUNT=11
+};
+
+/* /proc/sys/net/ax25 */
+enum {
+        NET_AX25_IP_DEFAULT_MODE=1,
+        NET_AX25_DEFAULT_MODE=2,
+        NET_AX25_BACKOFF_TYPE=3,
+        NET_AX25_CONNECT_MODE=4,
+        NET_AX25_STANDARD_WINDOW=5,
+        NET_AX25_EXTENDED_WINDOW=6,
+        NET_AX25_T1_TIMEOUT=7,
+        NET_AX25_T2_TIMEOUT=8,
+        NET_AX25_T3_TIMEOUT=9,
+        NET_AX25_IDLE_TIMEOUT=10,
+        NET_AX25_N2=11,
+        NET_AX25_PACLEN=12,
+        NET_AX25_PROTOCOL=13,
+        NET_AX25_DAMA_SLAVE_TIMEOUT=14
+};
+
+/* /proc/sys/net/rose */
+enum {
+        NET_ROSE_RESTART_REQUEST_TIMEOUT=1,
+        NET_ROSE_CALL_REQUEST_TIMEOUT=2,
+        NET_ROSE_RESET_REQUEST_TIMEOUT=3,
+        NET_ROSE_CLEAR_REQUEST_TIMEOUT=4,
+        NET_ROSE_ACK_HOLD_BACK_TIMEOUT=5,
+        NET_ROSE_ROUTING_CONTROL=6,
+        NET_ROSE_LINK_FAIL_TIMEOUT=7,
+        NET_ROSE_MAX_VCS=8,
+        NET_ROSE_WINDOW_SIZE=9,
+        NET_ROSE_NO_ACTIVITY_TIMEOUT=10
+};
+
+/* /proc/sys/net/x25 */
+enum {
+        NET_X25_RESTART_REQUEST_TIMEOUT=1,
+        NET_X25_CALL_REQUEST_TIMEOUT=2,
+        NET_X25_RESET_REQUEST_TIMEOUT=3,
+        NET_X25_CLEAR_REQUEST_TIMEOUT=4,
+        NET_X25_ACK_HOLD_BACK_TIMEOUT=5
+};
+
+/* /proc/sys/net/token-ring */
+enum
+{
+        NET_TR_RIF_TIMEOUT=1
+};
+
+/* /proc/sys/net/decnet/ */
+enum {
+        NET_DECNET_NODE_TYPE = 1,
+        NET_DECNET_NODE_ADDRESS = 2,
+        NET_DECNET_NODE_NAME = 3,
+        NET_DECNET_DEFAULT_DEVICE = 4,
+        NET_DECNET_TIME_WAIT = 5,
+        NET_DECNET_DN_COUNT = 6,
+        NET_DECNET_DI_COUNT = 7,
+        NET_DECNET_DR_COUNT = 8,
+        NET_DECNET_DST_GC_INTERVAL = 9,
+        NET_DECNET_CONF = 10,
+        NET_DECNET_NO_FC_MAX_CWND = 11,
+        NET_DECNET_DEBUG_LEVEL = 255
+};
+
+/* /proc/sys/net/decnet/conf/<dev> */
+enum {
+        NET_DECNET_CONF_LOOPBACK = -2,
+        NET_DECNET_CONF_DDCMP = -3,
+        NET_DECNET_CONF_PPP = -4,
+        NET_DECNET_CONF_X25 = -5,
+        NET_DECNET_CONF_GRE = -6,
+        NET_DECNET_CONF_ETHER = -7
+
+        /* ... and ifindex of devices */
+};
+
+/* /proc/sys/net/decnet/conf/<dev>/ */
+enum {
+        NET_DECNET_CONF_DEV_PRIORITY = 1,
+        NET_DECNET_CONF_DEV_T1 = 2,
+        NET_DECNET_CONF_DEV_T2 = 3,
+        NET_DECNET_CONF_DEV_T3 = 4,
+        NET_DECNET_CONF_DEV_FORWARDING = 5,
+        NET_DECNET_CONF_DEV_BLKSIZE = 6,
+        NET_DECNET_CONF_DEV_STATE = 7
+};
+
+/* /proc/sys/net/sctp */
+enum {
+        NET_SCTP_RTO_INITIAL = 1,
+        NET_SCTP_RTO_MIN     = 2,
+        NET_SCTP_RTO_MAX     = 3,
+        NET_SCTP_RTO_ALPHA   = 4,
+        NET_SCTP_RTO_BETA    = 5,
+        NET_SCTP_VALID_COOKIE_LIFE       =  6,
+        NET_SCTP_ASSOCIATION_MAX_RETRANS =  7,
+        NET_SCTP_PATH_MAX_RETRANS        =  8,
+        NET_SCTP_MAX_INIT_RETRANSMITS    =  9,
+        NET_SCTP_HB_INTERVAL             = 10,
+        NET_SCTP_PRESERVE_ENABLE         = 11,
+        NET_SCTP_MAX_BURST               = 12,
+        NET_SCTP_ADDIP_ENABLE            = 13,
+        NET_SCTP_PRSCTP_ENABLE           = 14,
+};
+
+/* /proc/sys/net/bridge */
+enum {
+        NET_BRIDGE_NF_CALL_ARPTABLES = 1,
+        NET_BRIDGE_NF_CALL_IPTABLES = 2,
+        NET_BRIDGE_NF_CALL_IP6TABLES = 3,
+        NET_BRIDGE_NF_FILTER_VLAN_TAGGED = 4,
+};
+
+/* CTL_PROC names: */
+
+/* CTL_FS names: */
+enum
+{
+        FS_NRINODE=1,   /* int:current number of allocated inodes */
+        FS_STATINODE=2,
+        FS_MAXINODE=3,  /* int:maximum number of inodes that can be allocated */
+        FS_NRDQUOT=4,   /* int:current number of allocated dquots */
+        FS_MAXDQUOT=5,  /* int:maximum number of dquots that can be allocated */
+        FS_NRFILE=6,    /* int:current number of allocated filedescriptors */
+        FS_MAXFILE=7,   /* int:maximum number of filedescriptors that can be allocated */
+        FS_DENTRY=8,
+        FS_NRSUPER=9,   /* int:current number of allocated super_blocks */
+        FS_MAXSUPER=10, /* int:maximum number of super_blocks that can be allocated */
+        FS_OVERFLOWUID=11,      /* int: overflow UID */
+        FS_OVERFLOWGID=12,      /* int: overflow GID */
+        FS_LEASES=13,   /* int: leases enabled */
+        FS_DIR_NOTIFY=14,       /* int: directory notification enabled */
+        FS_LEASE_TIME=15,       /* int: maximum time to wait for a lease break */
+        FS_DQSTATS=16,  /* disc quota usage statistics and control */
+        FS_XFS=17,      /* struct: control xfs parameters */
+        FS_AIO_NR=18,   /* current system-wide number of aio requests */
+        FS_AIO_MAX_NR=19,       /* system-wide maximum number of aio requests */
+};
+
+/* /proc/sys/fs/quota/ */
+enum {
+        FS_DQ_LOOKUPS = 1,
+        FS_DQ_DROPS = 2,
+        FS_DQ_READS = 3,
+        FS_DQ_WRITES = 4,
+        FS_DQ_CACHE_HITS = 5,
+        FS_DQ_ALLOCATED = 6,
+        FS_DQ_FREE = 7,
+        FS_DQ_SYNCS = 8,
+        FS_DQ_WARNINGS = 9,
+};
+
+/* CTL_DEBUG names: */
+
+/* CTL_DEV names: */
+enum {
+        DEV_CDROM=1,
+        DEV_HWMON=2,
+        DEV_PARPORT=3,
+        DEV_RAID=4,
+        DEV_MAC_HID=5,
+        DEV_SCSI=6,
+};
+
+/* /proc/sys/dev/cdrom */
+enum {
+        DEV_CDROM_INFO=1,
+        DEV_CDROM_AUTOCLOSE=2,
+        DEV_CDROM_AUTOEJECT=3,
+        DEV_CDROM_DEBUG=4,
+        DEV_CDROM_LOCK=5,
+        DEV_CDROM_CHECK_MEDIA=6
+};
+
+/* /proc/sys/dev/parport */
+enum {
+        DEV_PARPORT_DEFAULT=-3
+};
+
+/* /proc/sys/dev/raid */
+enum {
+        DEV_RAID_SPEED_LIMIT_MIN=1,
+        DEV_RAID_SPEED_LIMIT_MAX=2
+};
+
+/* /proc/sys/dev/parport/default */
+enum {
+        DEV_PARPORT_DEFAULT_TIMESLICE=1,
+        DEV_PARPORT_DEFAULT_SPINTIME=2
+};
+
+/* /proc/sys/dev/parport/parport n */
+enum {
+        DEV_PARPORT_SPINTIME=1,
+        DEV_PARPORT_BASE_ADDR=2,
+        DEV_PARPORT_IRQ=3,
+        DEV_PARPORT_DMA=4,
+        DEV_PARPORT_MODES=5,
+        DEV_PARPORT_DEVICES=6,
+        DEV_PARPORT_AUTOPROBE=16
+};
+
+/* /proc/sys/dev/parport/parport n/devices/ */
+enum {
+        DEV_PARPORT_DEVICES_ACTIVE=-3,
+};
+
+/* /proc/sys/dev/parport/parport n/devices/device n */
+enum {
+        DEV_PARPORT_DEVICE_TIMESLICE=1,
+};
+
+/* /proc/sys/dev/mac_hid */
+enum {
+        DEV_MAC_HID_KEYBOARD_SENDS_LINUX_KEYCODES=1,
+        DEV_MAC_HID_KEYBOARD_LOCK_KEYCODES=2,
+        DEV_MAC_HID_MOUSE_BUTTON_EMULATION=3,
+        DEV_MAC_HID_MOUSE_BUTTON2_KEYCODE=4,
+        DEV_MAC_HID_MOUSE_BUTTON3_KEYCODE=5,
+        DEV_MAC_HID_ADB_MOUSE_SENDS_KEYCODES=6
+};
+
+/* /proc/sys/dev/scsi */
+enum {
+        DEV_SCSI_LOGGING_LEVEL=1,
+};
+
+/* /proc/sys/abi */
+enum
+{
+        ABI_DEFHANDLER_COFF=1,  /* default handler for coff binaries */
+        ABI_DEFHANDLER_ELF=2,   /* default handler for ELF binaries */
+        ABI_DEFHANDLER_LCALL7=3,/* default handler for procs using lcall7 */
+        ABI_DEFHANDLER_LIBCSO=4,/* default handler for an libc.so ELF interp */
+        ABI_TRACE=5,            /* tracing flags */
+        ABI_FAKE_UTSNAME=6,     /* fake target utsname information */
+};
+
+#ifdef __KERNEL__
+
+extern void sysctl_init(void);
+
+typedef struct ctl_table ctl_table;
+
+typedef int ctl_handler (ctl_table *table, int __user *name, int nlen,
+                         void __user *oldval, size_t __user *oldlenp,
+                         void __user *newval, size_t newlen, 
+                         void **context);
+
+typedef int proc_handler (ctl_table *ctl, int write, struct file * filp,
+                          void __user *buffer, size_t *lenp, loff_t *ppos);
+
+extern int proc_dostring(ctl_table *, int, struct file *,
+                         void __user *, size_t *, loff_t *);
+extern int proc_dointvec(ctl_table *, int, struct file *,
+                         void __user *, size_t *, loff_t *);
+extern int proc_dointvec_bset(ctl_table *, int, struct file *,
+                              void __user *, size_t *, loff_t *);
+extern int proc_dointvec_minmax(ctl_table *, int, struct file *,
+                                void __user *, size_t *, loff_t *);
+extern int proc_dointvec_jiffies(ctl_table *, int, struct file *,
+                                 void __user *, size_t *, loff_t *);
+extern int proc_dointvec_userhz_jiffies(ctl_table *, int, struct file *,
+                                        void __user *, size_t *, loff_t *);
+extern int proc_dointvec_ms_jiffies(ctl_table *, int, struct file *,
+                                    void __user *, size_t *, loff_t *);
+extern int proc_doulongvec_minmax(ctl_table *, int, struct file *,
+                                  void __user *, size_t *, loff_t *);
+extern int proc_doulongvec_ms_jiffies_minmax(ctl_table *table, int,
+                                      struct file *, void __user *, size_t *, loff_t *);
+
+extern int do_sysctl (int __user *name, int nlen,
+                      void __user *oldval, size_t __user *oldlenp,
+                      void __user *newval, size_t newlen);
+
+extern int do_sysctl_strategy (ctl_table *table, 
+                               int __user *name, int nlen,
+                               void __user *oldval, size_t __user *oldlenp,
+                               void __user *newval, size_t newlen, void ** context);
+
+extern ctl_handler sysctl_string;
+extern ctl_handler sysctl_intvec;
+extern ctl_handler sysctl_jiffies;
+extern ctl_handler sysctl_ms_jiffies;
+
+
+/*
+ * Register a set of sysctl names by calling register_sysctl_table
+ * with an initialised array of ctl_table's.  An entry with zero
+ * ctl_name terminates the table.  table->de will be set up by the
+ * registration and need not be initialised in advance.
+ *
+ * sysctl names can be mirrored automatically under /proc/sys.  The
+ * procname supplied controls /proc naming.
+ *
+ * The table's mode will be honoured both for sys_sysctl(2) and
+ * proc-fs access.
+ *
+ * Leaf nodes in the sysctl tree will be represented by a single file
+ * under /proc; non-leaf nodes will be represented by directories.  A
+ * null procname disables /proc mirroring at this node.
+ * 
+ * sysctl(2) can automatically manage read and write requests through
+ * the sysctl table.  The data and maxlen fields of the ctl_table
+ * struct enable minimal validation of the values being written to be
+ * performed, and the mode field allows minimal authentication.
+ * 
+ * More sophisticated management can be enabled by the provision of a
+ * strategy routine with the table entry.  This will be called before
+ * any automatic read or write of the data is performed.
+ * 
+ * The strategy routine may return:
+ * <0: Error occurred (error is passed to user process)
+ * 0:  OK - proceed with automatic read or write.
+ * >0: OK - read or write has been done by the strategy routine, so 
+ *     return immediately.
+ * 
+ * There must be a proc_handler routine for any terminal nodes
+ * mirrored under /proc/sys (non-terminals are handled by a built-in
+ * directory handler).  Several default handlers are available to
+ * cover common cases.
+ */
+
+/* A sysctl table is an array of struct ctl_table: */
+struct ctl_table 
+{
+        int ctl_name;                   /* Binary ID */
+        const char *procname;           /* Text ID for /proc/sys, or zero */
+        void *data;
+        int maxlen;
+        mode_t mode;
+        ctl_table *child;
+        proc_handler *proc_handler;     /* Callback for text formatting */
+        ctl_handler *strategy;          /* Callback function for all r/w */
+        struct proc_dir_entry *de;      /* /proc control block */
+        void *extra1;
+        void *extra2;
+};
+
+/* struct ctl_table_header is used to maintain dynamic lists of
+   ctl_table trees. */
+struct ctl_table_header
+{
+        ctl_table *ctl_table;
+        struct list_head ctl_entry;
+};
+
+struct ctl_table_header * register_sysctl_table(ctl_table * table, 
+                                                int insert_at_head);
+void unregister_sysctl_table(struct ctl_table_header * table);
+
+#else /* __KERNEL__ */
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SYSCTL_H */
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
new file mode 100644
index 000000000000..635db1df656f
--- /dev/null
+++ b/include/linux/sysdev.h
@@ -0,0 +1,94 @@
+/**
+ * System devices follow a slightly different driver model. 
+ * They don't need to do dynammic driver binding, can't be probed, 
+ * and don't reside on any type of peripheral bus. 
+ * So, we represent and treat them a little differently.
+ * 
+ * We still have a notion of a driver for a system device, because we still
+ * want to perform basic operations on these devices. 
+ *
+ * We also support auxillary drivers binding to devices of a certain class.
+ * 
+ * This allows configurable drivers to register themselves for devices of
+ * a certain type. And, it allows class definitions to reside in generic
+ * code while arch-specific code can register specific drivers.
+ *
+ * Auxillary drivers registered with a NULL cls are registered as drivers
+ * for all system devices, and get notification calls for each device. 
+ */
+
+
+#ifndef _SYSDEV_H_
+#define _SYSDEV_H_
+
+#include <linux/kobject.h>
+
+
+struct sys_device;
+
+struct sysdev_class {
+        struct list_head        drivers;
+
+        /* Default operations for these types of devices */
+        int     (*shutdown)(struct sys_device *);
+        int     (*suspend)(struct sys_device *, u32 state);
+        int     (*resume)(struct sys_device *);
+        struct kset             kset;
+};
+
+
+extern int sysdev_class_register(struct sysdev_class *);
+extern void sysdev_class_unregister(struct sysdev_class *);
+
+
+/**
+ * Auxillary system device drivers.
+ */
+
+struct sysdev_driver {
+        struct list_head        entry;
+        int     (*add)(struct sys_device *);
+        int     (*remove)(struct sys_device *);
+        int     (*shutdown)(struct sys_device *);
+        int     (*suspend)(struct sys_device *, u32 state);
+        int     (*resume)(struct sys_device *);
+};
+
+
+extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
+extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
+
+
+/**
+ * sys_devices can be simplified a lot from regular devices, because they're
+ * simply not as versatile. 
+ */
+
+struct sys_device {
+        u32             id;
+        struct sysdev_class     * cls;
+        struct kobject          kobj;
+};
+
+extern int sysdev_register(struct sys_device *);
+extern void sysdev_unregister(struct sys_device *);
+
+
+struct sysdev_attribute { 
+        struct attribute        attr;
+        ssize_t (*show)(struct sys_device *, char *);
+        ssize_t (*store)(struct sys_device *, const char *, size_t);
+};
+
+
+#define SYSDEV_ATTR(_name,_mode,_show,_store)           \
+struct sysdev_attribute attr_##_name = {                        \
+        .attr = {.name = __stringify(_name), .mode = _mode },   \
+        .show   = _show,                                        \
+        .store  = _store,                                       \
+};
+
+extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
+extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
+
+#endif /* _SYSDEV_H_ */
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
new file mode 100644
index 000000000000..6f502ff7902a
--- /dev/null
+++ b/include/linux/sysfs.h
@@ -0,0 +1,182 @@
+/*
+ * sysfs.h - definitions for the device driver filesystem
+ *
+ * Copyright (c) 2001,2002 Patrick Mochel
+ * Copyright (c) 2004 Silicon Graphics, Inc.
+ *
+ * Please see Documentation/filesystems/sysfs.txt for more information.
+ */
+
+#ifndef _SYSFS_H_
+#define _SYSFS_H_
+
+#include <asm/atomic.h>
+
+struct kobject;
+struct module;
+
+struct attribute {
+        char                    * name;
+        struct module           * owner;
+        mode_t                  mode;
+};
+
+struct attribute_group {
+        char                    * name;
+        struct attribute        ** attrs;
+};
+
+
+
+/**
+ * Use these macros to make defining attributes easier. See include/linux/device.h
+ * for examples..
+ */
+
+#define __ATTR(_name,_mode,_show,_store) { \
+        .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE },     \
+        .show   = _show,                                        \
+        .store  = _store,                                       \
+}
+
+#define __ATTR_RO(_name) { \
+        .attr   = { .name = __stringify(_name), .mode = 0444, .owner = THIS_MODULE },   \
+        .show   = _name##_show, \
+}
+
+#define __ATTR_NULL { .attr = { .name = NULL } }
+
+#define attr_name(_attr) (_attr).attr.name
+
+struct vm_area_struct;
+
+struct bin_attribute {
+        struct attribute        attr;
+        size_t                  size;
+        void                    *private;
+        ssize_t (*read)(struct kobject *, char *, loff_t, size_t);
+        ssize_t (*write)(struct kobject *, char *, loff_t, size_t);
+        int (*mmap)(struct kobject *, struct bin_attribute *attr,
+                    struct vm_area_struct *vma);
+};
+
+struct sysfs_ops {
+        ssize_t (*show)(struct kobject *, struct attribute *,char *);
+        ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
+};
+
+struct sysfs_dirent {
+        atomic_t                s_count;
+        struct list_head        s_sibling;
+        struct list_head        s_children;
+        void                    * s_element;
+        int                     s_type;
+        umode_t                 s_mode;
+        struct dentry           * s_dentry;
+};
+
+#define SYSFS_ROOT              0x0001
+#define SYSFS_DIR               0x0002
+#define SYSFS_KOBJ_ATTR         0x0004
+#define SYSFS_KOBJ_BIN_ATTR     0x0008
+#define SYSFS_KOBJ_LINK         0x0020
+#define SYSFS_NOT_PINNED        (SYSFS_KOBJ_ATTR | SYSFS_KOBJ_BIN_ATTR | SYSFS_KOBJ_LINK)
+
+#ifdef CONFIG_SYSFS
+
+extern int
+sysfs_create_dir(struct kobject *);
+
+extern void
+sysfs_remove_dir(struct kobject *);
+
+extern int
+sysfs_rename_dir(struct kobject *, const char *new_name);
+
+extern int
+sysfs_create_file(struct kobject *, const struct attribute *);
+
+extern int
+sysfs_update_file(struct kobject *, const struct attribute *);
+
+extern void
+sysfs_remove_file(struct kobject *, const struct attribute *);
+
+extern int 
+sysfs_create_link(struct kobject * kobj, struct kobject * target, char * name);
+
+extern void
+sysfs_remove_link(struct kobject *, char * name);
+
+int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr);
+int sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr);
+
+int sysfs_create_group(struct kobject *, const struct attribute_group *);
+void sysfs_remove_group(struct kobject *, const struct attribute_group *);
+
+#else /* CONFIG_SYSFS */
+
+static inline int sysfs_create_dir(struct kobject * k)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_dir(struct kobject * k)
+{
+        ;
+}
+
+static inline int sysfs_rename_dir(struct kobject * k, const char *new_name)
+{
+        return 0;
+}
+
+static inline int sysfs_create_file(struct kobject * k, const struct attribute * a)
+{
+        return 0;
+}
+
+static inline int sysfs_update_file(struct kobject * k, const struct attribute * a)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_file(struct kobject * k, const struct attribute * a)
+{
+        ;
+}
+
+static inline int sysfs_create_link(struct kobject * k, struct kobject * t, char * n)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_link(struct kobject * k, char * name)
+{
+        ;
+}
+
+
+static inline int sysfs_create_bin_file(struct kobject * k, struct bin_attribute * a)
+{
+        return 0;
+}
+
+static inline int sysfs_remove_bin_file(struct kobject * k, struct bin_attribute * a)
+{
+        return 0;
+}
+
+static inline int sysfs_create_group(struct kobject * k, const struct attribute_group *g)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_group(struct kobject * k, const struct attribute_group * g)
+{
+        ;
+}
+
+#endif /* CONFIG_SYSFS */
+
+#endif /* _SYSFS_H_ */
diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h
new file mode 100644
index 000000000000..ea819b89c235
--- /dev/null
+++ b/include/linux/sysrq.h
@@ -0,0 +1,60 @@
+/* -*- linux-c -*-
+ *
+ *      $Id: sysrq.h,v 1.3 1997/07/17 11:54:33 mj Exp $
+ *
+ *      Linux Magic System Request Key Hacks
+ *
+ *      (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
+ *
+ *      (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
+ *      overhauled to use key registration
+ *      based upon discusions in irc://irc.openprojects.net/#kernelnewbies
+ */
+
+#include <linux/config.h>
+
+struct pt_regs;
+struct tty_struct;
+
+/* Possible values of bitmask for enabling sysrq functions */
+/* 0x0001 is reserved for enable everything */
+#define SYSRQ_ENABLE_LOG        0x0002
+#define SYSRQ_ENABLE_KEYBOARD   0x0004
+#define SYSRQ_ENABLE_DUMP       0x0008
+#define SYSRQ_ENABLE_SYNC       0x0010
+#define SYSRQ_ENABLE_REMOUNT    0x0020
+#define SYSRQ_ENABLE_SIGNAL     0x0040
+#define SYSRQ_ENABLE_BOOT       0x0080
+#define SYSRQ_ENABLE_RTNICE     0x0100
+
+struct sysrq_key_op {
+        void (*handler)(int, struct pt_regs *, struct tty_struct *);
+        char *help_msg;
+        char *action_msg;
+        int enable_mask;
+};
+
+#ifdef CONFIG_MAGIC_SYSRQ
+
+/* Generic SysRq interface -- you may call it from any device driver, supplying
+ * ASCII code of the key, pointer to registers and kbd/tty structs (if they
+ * are available -- else NULL's).
+ */
+
+void handle_sysrq(int, struct pt_regs *, struct tty_struct *);
+void __handle_sysrq(int, struct pt_regs *, struct tty_struct *, int check_mask);
+int register_sysrq_key(int, struct sysrq_key_op *);
+int unregister_sysrq_key(int, struct sysrq_key_op *);
+struct sysrq_key_op *__sysrq_get_key_op(int key);
+
+#else
+
+static inline int __reterr(void)
+{
+        return -EINVAL;
+}
+
+#define register_sysrq_key(ig,nore) __reterr()
+#define unregister_sysrq_key(ig,nore) __reterr()
+
+#endif
diff --git a/include/linux/sysv_fs.h b/include/linux/sysv_fs.h
new file mode 100644
index 000000000000..e0248631e461
--- /dev/null
+++ b/include/linux/sysv_fs.h
@@ -0,0 +1,206 @@
+#ifndef _LINUX_SYSV_FS_H
+#define _LINUX_SYSV_FS_H
+
+#if defined(__GNUC__)
+# define __packed2__    __attribute__((packed, aligned(2)))
+#else
+>> I want to scream! <<
+#endif
+
+
+#ifndef __KERNEL__
+typedef u16 __fs16;
+typedef u32 __fs16;
+#endif
+
+/* inode numbers are 16 bit */
+typedef __fs16 sysv_ino_t;
+
+/* Block numbers are 24 bit, sometimes stored in 32 bit.
+   On Coherent FS, they are always stored in PDP-11 manner: the least
+   significant 16 bits come last. */
+typedef __fs32 sysv_zone_t;
+
+/* 0 is non-existent */
+#define SYSV_BADBL_INO  1       /* inode of bad blocks file */
+#define SYSV_ROOT_INO   2       /* inode of root directory */
+
+
+/* Xenix super-block data on disk */
+#define XENIX_NICINOD   100     /* number of inode cache entries */
+#define XENIX_NICFREE   100     /* number of free block list chunk entries */
+struct xenix_super_block {
+        __fs16          s_isize; /* index of first data zone */
+        __fs32          s_fsize __packed2__; /* total number of zones of this fs */
+        /* the start of the free block list: */
+        __fs16          s_nfree;        /* number of free blocks in s_free, <= XENIX_NICFREE */
+        sysv_zone_t     s_free[XENIX_NICFREE]; /* first free block list chunk */
+        /* the cache of free inodes: */
+        __fs16          s_ninode; /* number of free inodes in s_inode, <= XENIX_NICINOD */
+        sysv_ino_t      s_inode[XENIX_NICINOD]; /* some free inodes */
+        /* locks, not used by Linux: */
+        char            s_flock;        /* lock during free block list manipulation */
+        char            s_ilock;        /* lock during inode cache manipulation */
+        char            s_fmod;         /* super-block modified flag */
+        char            s_ronly;        /* flag whether fs is mounted read-only */
+        __fs32          s_time __packed2__; /* time of last super block update */
+        __fs32          s_tfree __packed2__; /* total number of free zones */
+        __fs16          s_tinode;       /* total number of free inodes */
+        __fs16          s_dinfo[4];     /* device information ?? */
+        char            s_fname[6];     /* file system volume name */
+        char            s_fpack[6];     /* file system pack name */
+        char            s_clean;        /* set to 0x46 when filesystem is properly unmounted */
+        char            s_fill[371];
+        s32             s_magic;        /* version of file system */
+        __fs32          s_type;         /* type of file system: 1 for 512 byte blocks
+                                                                2 for 1024 byte blocks
+                                                                3 for 2048 byte blocks */
+                                                                
+};
+
+/*
+ * SystemV FS comes in two variants:
+ * sysv2: System V Release 2 (e.g. Microport), structure elements aligned(2).
+ * sysv4: System V Release 4 (e.g. Consensys), structure elements aligned(4).
+ */
+#define SYSV_NICINOD    100     /* number of inode cache entries */
+#define SYSV_NICFREE    50      /* number of free block list chunk entries */
+
+/* SystemV4 super-block data on disk */
+struct sysv4_super_block {
+        __fs16  s_isize;        /* index of first data zone */
+        u16     s_pad0;
+        __fs32  s_fsize;        /* total number of zones of this fs */
+        /* the start of the free block list: */
+        __fs16  s_nfree;        /* number of free blocks in s_free, <= SYSV_NICFREE */
+        u16     s_pad1;
+        sysv_zone_t     s_free[SYSV_NICFREE]; /* first free block list chunk */
+        /* the cache of free inodes: */
+        __fs16  s_ninode;       /* number of free inodes in s_inode, <= SYSV_NICINOD */
+        u16     s_pad2;
+        sysv_ino_t     s_inode[SYSV_NICINOD]; /* some free inodes */
+        /* locks, not used by Linux: */
+        char    s_flock;        /* lock during free block list manipulation */
+        char    s_ilock;        /* lock during inode cache manipulation */
+        char    s_fmod;         /* super-block modified flag */
+        char    s_ronly;        /* flag whether fs is mounted read-only */
+        __fs32  s_time;         /* time of last super block update */
+        __fs16  s_dinfo[4];     /* device information ?? */
+        __fs32  s_tfree;        /* total number of free zones */
+        __fs16  s_tinode;       /* total number of free inodes */
+        u16     s_pad3;
+        char    s_fname[6];     /* file system volume name */
+        char    s_fpack[6];     /* file system pack name */
+        s32     s_fill[12];
+        __fs32  s_state;        /* file system state: 0x7c269d38-s_time means clean */
+        s32     s_magic;        /* version of file system */
+        __fs32  s_type;         /* type of file system: 1 for 512 byte blocks
+                                                                2 for 1024 byte blocks */
+};
+
+/* SystemV2 super-block data on disk */
+struct sysv2_super_block {
+        __fs16  s_isize;                /* index of first data zone */
+        __fs32  s_fsize __packed2__;    /* total number of zones of this fs */
+        /* the start of the free block list: */
+        __fs16  s_nfree;                /* number of free blocks in s_free, <= SYSV_NICFREE */
+        sysv_zone_t s_free[SYSV_NICFREE];       /* first free block list chunk */
+        /* the cache of free inodes: */
+        __fs16  s_ninode;               /* number of free inodes in s_inode, <= SYSV_NICINOD */
+        sysv_ino_t     s_inode[SYSV_NICINOD]; /* some free inodes */
+        /* locks, not used by Linux: */
+        char    s_flock;                /* lock during free block list manipulation */
+        char    s_ilock;                /* lock during inode cache manipulation */
+        char    s_fmod;                 /* super-block modified flag */
+        char    s_ronly;                /* flag whether fs is mounted read-only */
+        __fs32  s_time __packed2__;     /* time of last super block update */
+        __fs16  s_dinfo[4];             /* device information ?? */
+        __fs32  s_tfree __packed2__;    /* total number of free zones */
+        __fs16  s_tinode;               /* total number of free inodes */
+        char    s_fname[6];             /* file system volume name */
+        char    s_fpack[6];             /* file system pack name */
+        s32     s_fill[14];
+        __fs32  s_state;                /* file system state: 0xcb096f43 means clean */
+        s32     s_magic;                /* version of file system */
+        __fs32  s_type;                 /* type of file system: 1 for 512 byte blocks
+                                                                2 for 1024 byte blocks */
+};
+
+/* V7 super-block data on disk */
+#define V7_NICINOD     100     /* number of inode cache entries */
+#define V7_NICFREE     50      /* number of free block list chunk entries */
+struct v7_super_block {
+        __fs16 s_isize;        /* index of first data zone */
+        __fs32 s_fsize __packed2__; /* total number of zones of this fs */
+        /* the start of the free block list: */
+        __fs16 s_nfree;        /* number of free blocks in s_free, <= V7_NICFREE */
+        sysv_zone_t s_free[V7_NICFREE]; /* first free block list chunk */
+        /* the cache of free inodes: */
+        __fs16 s_ninode;       /* number of free inodes in s_inode, <= V7_NICINOD */
+        sysv_ino_t      s_inode[V7_NICINOD]; /* some free inodes */
+        /* locks, not used by Linux or V7: */
+        char    s_flock;        /* lock during free block list manipulation */
+        char    s_ilock;        /* lock during inode cache manipulation */
+        char    s_fmod;         /* super-block modified flag */
+        char    s_ronly;        /* flag whether fs is mounted read-only */
+        __fs32  s_time __packed2__; /* time of last super block update */
+        /* the following fields are not maintained by V7: */
+        __fs32  s_tfree __packed2__; /* total number of free zones */
+        __fs16  s_tinode;       /* total number of free inodes */
+        __fs16  s_m;            /* interleave factor */
+        __fs16  s_n;            /* interleave factor */
+        char    s_fname[6];     /* file system name */
+        char    s_fpack[6];     /* file system pack name */
+};
+
+/* Coherent super-block data on disk */
+#define COH_NICINOD     100     /* number of inode cache entries */
+#define COH_NICFREE     64      /* number of free block list chunk entries */
+struct coh_super_block {
+        __fs16          s_isize;        /* index of first data zone */
+        __fs32          s_fsize __packed2__; /* total number of zones of this fs */
+        /* the start of the free block list: */
+        __fs16 s_nfree; /* number of free blocks in s_free, <= COH_NICFREE */
+        sysv_zone_t     s_free[COH_NICFREE] __packed2__; /* first free block list chunk */
+        /* the cache of free inodes: */
+        __fs16          s_ninode;       /* number of free inodes in s_inode, <= COH_NICINOD */
+        sysv_ino_t      s_inode[COH_NICINOD]; /* some free inodes */
+        /* locks, not used by Linux: */
+        char            s_flock;        /* lock during free block list manipulation */
+        char            s_ilock;        /* lock during inode cache manipulation */
+        char            s_fmod;         /* super-block modified flag */
+        char            s_ronly;        /* flag whether fs is mounted read-only */
+        __fs32          s_time __packed2__; /* time of last super block update */
+        __fs32          s_tfree __packed2__; /* total number of free zones */
+        __fs16          s_tinode;       /* total number of free inodes */
+        __fs16          s_interleave_m; /* interleave factor */
+        __fs16          s_interleave_n;
+        char            s_fname[6];     /* file system volume name */
+        char            s_fpack[6];     /* file system pack name */
+        __fs32          s_unique;       /* zero, not used */
+};
+
+/* SystemV/Coherent inode data on disk */
+struct sysv_inode {
+        __fs16 i_mode;
+        __fs16 i_nlink;
+        __fs16 i_uid;
+        __fs16 i_gid;
+        __fs32 i_size;
+        u8  i_data[3*(10+1+1+1)];
+        u8  i_gen;
+        __fs32 i_atime; /* time of last access */
+        __fs32 i_mtime; /* time of last modification */
+        __fs32 i_ctime; /* time of creation */
+};
+
+/* SystemV/Coherent directory entry on disk */
+#define SYSV_NAMELEN    14      /* max size of name in struct sysv_dir_entry */
+struct sysv_dir_entry {
+        sysv_ino_t inode;
+        char name[SYSV_NAMELEN]; /* up to 14 characters, the rest are zeroes */
+};
+
+#define SYSV_DIRSIZE    sizeof(struct sysv_dir_entry)   /* size of every directory entry */
+
+#endif /* _LINUX_SYSV_FS_H */
diff --git a/include/linux/tc_act/tc_gact.h b/include/linux/tc_act/tc_gact.h
new file mode 100644
index 000000000000..23a03eb630db
--- /dev/null
+++ b/include/linux/tc_act/tc_gact.h
@@ -0,0 +1,34 @@
+#ifndef __LINUX_TC_GACT_H
+#define __LINUX_TC_GACT_H
+
+#include <linux/pkt_cls.h>
+
+#define TCA_ACT_GACT 5
+struct tc_gact
+{
+        tc_gen;
+
+};
+
+struct tc_gact_p
+{
+#define PGACT_NONE              0
+#define PGACT_NETRAND           1
+#define PGACT_DETERM            2
+#define MAX_RAND                (PGACT_DETERM + 1 )
+        __u16                 ptype;
+        __u16                 pval;
+        int                   paction;
+};
+ 
+enum
+{
+        TCA_GACT_UNSPEC,
+        TCA_GACT_TM,
+        TCA_GACT_PARMS,
+        TCA_GACT_PROB,
+        __TCA_GACT_MAX
+};
+#define TCA_GACT_MAX (__TCA_GACT_MAX - 1)
+ 
+#endif
diff --git a/include/linux/tc_act/tc_ipt.h b/include/linux/tc_act/tc_ipt.h
new file mode 100644
index 000000000000..4b6f7b6c7a79
--- /dev/null
+++ b/include/linux/tc_act/tc_ipt.h
@@ -0,0 +1,21 @@
+#ifndef __LINUX_TC_IPT_H
+#define __LINUX_TC_IPT_H
+
+#include <linux/pkt_cls.h>
+
+#define TCA_ACT_IPT 6
+
+enum
+{
+        TCA_IPT_UNSPEC,
+        TCA_IPT_TABLE,
+        TCA_IPT_HOOK,
+        TCA_IPT_INDEX,
+        TCA_IPT_CNT,
+        TCA_IPT_TM,
+        TCA_IPT_TARG,
+        __TCA_IPT_MAX
+};
+#define TCA_IPT_MAX (__TCA_IPT_MAX - 1)
+                                                                                
+#endif
diff --git a/include/linux/tc_act/tc_mirred.h b/include/linux/tc_act/tc_mirred.h
new file mode 100644
index 000000000000..71d63409d568
--- /dev/null
+++ b/include/linux/tc_act/tc_mirred.h
@@ -0,0 +1,28 @@
+#ifndef __LINUX_TC_MIR_H
+#define __LINUX_TC_MIR_H
+
+#include <linux/pkt_cls.h>
+
+#define TCA_ACT_MIRRED 8
+#define TCA_EGRESS_REDIR 1  /* packet redirect to EGRESS*/
+#define TCA_EGRESS_MIRROR 2 /* mirror packet to EGRESS */
+#define TCA_INGRESS_REDIR 3  /* packet redirect to INGRESS*/
+#define TCA_INGRESS_MIRROR 4 /* mirror packet to INGRESS */
+                                                                                
+struct tc_mirred
+{
+        tc_gen;
+        int                     eaction;   /* one of IN/EGRESS_MIRROR/REDIR */
+        __u32                   ifindex;  /* ifindex of egress port */
+};
+                                                                                
+enum
+{
+        TCA_MIRRED_UNSPEC,
+        TCA_MIRRED_TM,
+        TCA_MIRRED_PARMS,
+        __TCA_MIRRED_MAX
+};
+#define TCA_MIRRED_MAX (__TCA_MIRRED_MAX - 1)
+                                                                                
+#endif
diff --git a/include/linux/tc_act/tc_pedit.h b/include/linux/tc_act/tc_pedit.h
new file mode 100644
index 000000000000..83e56e32e8e0
--- /dev/null
+++ b/include/linux/tc_act/tc_pedit.h
@@ -0,0 +1,36 @@
+#ifndef __LINUX_TC_PED_H
+#define __LINUX_TC_PED_H
+
+#include <linux/pkt_cls.h>
+
+#define TCA_ACT_PEDIT 7
+
+enum
+{
+        TCA_PEDIT_UNSPEC,
+        TCA_PEDIT_TM,
+        TCA_PEDIT_PARMS,
+        __TCA_PEDIT_MAX
+};
+#define TCA_PEDIT_MAX (__TCA_PEDIT_MAX - 1)
+                                                                                
+struct tc_pedit_key
+{
+        __u32           mask;  /* AND */
+        __u32           val;   /*XOR */
+        __u32           off;  /*offset */
+        __u32           at;
+        __u32           offmask;
+        __u32           shift;
+};
+                                                                                
+struct tc_pedit_sel
+{
+        tc_gen;
+        unsigned char           nkeys;
+        unsigned char           flags;
+        struct tc_pedit_key     keys[0];
+};
+#define tc_pedit tc_pedit_sel
+
+#endif
diff --git a/include/linux/tc_ematch/tc_em_cmp.h b/include/linux/tc_ematch/tc_em_cmp.h
new file mode 100644
index 000000000000..c7f4d43618fd
--- /dev/null
+++ b/include/linux/tc_ematch/tc_em_cmp.h
@@ -0,0 +1,26 @@
+#ifndef __LINUX_TC_EM_CMP_H
+#define __LINUX_TC_EM_CMP_H
+
+#include <linux/pkt_cls.h>
+
+struct tcf_em_cmp
+{
+        __u32           val;
+        __u32           mask;
+        __u16           off;
+        __u8            align:4;
+        __u8            flags:4;
+        __u8            layer:4;
+        __u8            opnd:4;
+};
+
+enum
+{
+        TCF_EM_ALIGN_U8  = 1,
+        TCF_EM_ALIGN_U16 = 2,
+        TCF_EM_ALIGN_U32 = 4
+};
+
+#define TCF_EM_CMP_TRANS        1
+
+#endif
diff --git a/include/linux/tc_ematch/tc_em_meta.h b/include/linux/tc_ematch/tc_em_meta.h
new file mode 100644
index 000000000000..aa6b48bb4dcd
--- /dev/null
+++ b/include/linux/tc_ematch/tc_em_meta.h
@@ -0,0 +1,69 @@
+#ifndef __LINUX_TC_EM_META_H
+#define __LINUX_TC_EM_META_H
+
+#include <linux/pkt_cls.h>
+
+enum
+{
+        TCA_EM_META_UNSPEC,
+        TCA_EM_META_HDR,
+        TCA_EM_META_LVALUE,
+        TCA_EM_META_RVALUE,
+        __TCA_EM_META_MAX
+};
+#define TCA_EM_META_MAX (__TCA_EM_META_MAX - 1)
+
+struct tcf_meta_val
+{
+        __u16                   kind;
+        __u8                    shift;
+        __u8                    op;
+};
+
+#define TCF_META_TYPE_MASK      (0xf << 12)
+#define TCF_META_TYPE(kind)     (((kind) & TCF_META_TYPE_MASK) >> 12)
+#define TCF_META_ID_MASK        0x7ff
+#define TCF_META_ID(kind)       ((kind) & TCF_META_ID_MASK)
+
+enum
+{
+        TCF_META_TYPE_VAR,
+        TCF_META_TYPE_INT,
+        __TCF_META_TYPE_MAX
+};
+#define TCF_META_TYPE_MAX (__TCF_META_TYPE_MAX - 1)
+
+enum
+{
+        TCF_META_ID_VALUE,
+        TCF_META_ID_RANDOM,
+        TCF_META_ID_LOADAVG_0,
+        TCF_META_ID_LOADAVG_1,
+        TCF_META_ID_LOADAVG_2,
+        TCF_META_ID_DEV,
+        TCF_META_ID_INDEV,
+        TCF_META_ID_REALDEV,
+        TCF_META_ID_PRIORITY,
+        TCF_META_ID_PROTOCOL,
+        TCF_META_ID_SECURITY,
+        TCF_META_ID_PKTTYPE,
+        TCF_META_ID_PKTLEN,
+        TCF_META_ID_DATALEN,
+        TCF_META_ID_MACLEN,
+        TCF_META_ID_NFMARK,
+        TCF_META_ID_TCINDEX,
+        TCF_META_ID_TCVERDICT,
+        TCF_META_ID_TCCLASSID,
+        TCF_META_ID_RTCLASSID,
+        TCF_META_ID_RTIIF,
+        __TCF_META_ID_MAX
+};
+#define TCF_META_ID_MAX (__TCF_META_ID_MAX - 1)
+
+struct tcf_meta_hdr
+{
+        struct tcf_meta_val     left;
+        struct tcf_meta_val     right;
+};
+
+#endif
diff --git a/include/linux/tc_ematch/tc_em_nbyte.h b/include/linux/tc_ematch/tc_em_nbyte.h
new file mode 100644
index 000000000000..f19d1f58ec9d
--- /dev/null
+++ b/include/linux/tc_ematch/tc_em_nbyte.h
@@ -0,0 +1,13 @@
+#ifndef __LINUX_TC_EM_NBYTE_H
+#define __LINUX_TC_EM_NBYTE_H
+
+#include <linux/pkt_cls.h>
+
+struct tcf_em_nbyte
+{
+        __u16           off;
+        __u16           len:12;
+        __u8            layer:4;
+};
+
+#endif
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
new file mode 100644
index 000000000000..14a55e3e3a50
--- /dev/null
+++ b/include/linux/tcp.h
@@ -0,0 +1,448 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the TCP protocol.
+ *
+ * Version:     @(#)tcp.h       1.0.2   04/28/93
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_TCP_H
+#define _LINUX_TCP_H
+
+#include <linux/types.h>
+#include <asm/byteorder.h>
+
+struct tcphdr {
+        __u16   source;
+        __u16   dest;
+        __u32   seq;
+        __u32   ack_seq;
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u16   res1:4,
+                doff:4,
+                fin:1,
+                syn:1,
+                rst:1,
+                psh:1,
+                ack:1,
+                urg:1,
+                ece:1,
+                cwr:1;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+        __u16   doff:4,
+                res1:4,
+                cwr:1,
+                ece:1,
+                urg:1,
+                ack:1,
+                psh:1,
+                rst:1,
+                syn:1,
+                fin:1;
+#else
+#error  "Adjust your <asm/byteorder.h> defines"
+#endif  
+        __u16   window;
+        __u16   check;
+        __u16   urg_ptr;
+};
+
+
+enum {
+  TCP_ESTABLISHED = 1,
+  TCP_SYN_SENT,
+  TCP_SYN_RECV,
+  TCP_FIN_WAIT1,
+  TCP_FIN_WAIT2,
+  TCP_TIME_WAIT,
+  TCP_CLOSE,
+  TCP_CLOSE_WAIT,
+  TCP_LAST_ACK,
+  TCP_LISTEN,
+  TCP_CLOSING,   /* now a valid state */
+
+  TCP_MAX_STATES /* Leave at the end! */
+};
+
+#define TCP_STATE_MASK  0xF
+#define TCP_ACTION_FIN  (1 << 7)
+
+enum {
+  TCPF_ESTABLISHED = (1 << 1),
+  TCPF_SYN_SENT  = (1 << 2),
+  TCPF_SYN_RECV  = (1 << 3),
+  TCPF_FIN_WAIT1 = (1 << 4),
+  TCPF_FIN_WAIT2 = (1 << 5),
+  TCPF_TIME_WAIT = (1 << 6),
+  TCPF_CLOSE     = (1 << 7),
+  TCPF_CLOSE_WAIT = (1 << 8),
+  TCPF_LAST_ACK  = (1 << 9),
+  TCPF_LISTEN    = (1 << 10),
+  TCPF_CLOSING   = (1 << 11) 
+};
+
+/*
+ *      The union cast uses a gcc extension to avoid aliasing problems
+ *  (union is compatible to any of its members)
+ *  This means this part of the code is -fstrict-aliasing safe now.
+ */
+union tcp_word_hdr { 
+        struct tcphdr hdr;
+        __u32             words[5];
+}; 
+
+#define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words [3]) 
+
+enum { 
+        TCP_FLAG_CWR = __constant_htonl(0x00800000), 
+        TCP_FLAG_ECE = __constant_htonl(0x00400000), 
+        TCP_FLAG_URG = __constant_htonl(0x00200000), 
+        TCP_FLAG_ACK = __constant_htonl(0x00100000), 
+        TCP_FLAG_PSH = __constant_htonl(0x00080000), 
+        TCP_FLAG_RST = __constant_htonl(0x00040000), 
+        TCP_FLAG_SYN = __constant_htonl(0x00020000), 
+        TCP_FLAG_FIN = __constant_htonl(0x00010000),
+        TCP_RESERVED_BITS = __constant_htonl(0x0F000000),
+        TCP_DATA_OFFSET = __constant_htonl(0xF0000000)
+}; 
+
+/* TCP socket options */
+#define TCP_NODELAY             1       /* Turn off Nagle's algorithm. */
+#define TCP_MAXSEG              2       /* Limit MSS */
+#define TCP_CORK                3       /* Never send partially complete segments */
+#define TCP_KEEPIDLE            4       /* Start keeplives after this period */
+#define TCP_KEEPINTVL           5       /* Interval between keepalives */
+#define TCP_KEEPCNT             6       /* Number of keepalives before death */
+#define TCP_SYNCNT              7       /* Number of SYN retransmits */
+#define TCP_LINGER2             8       /* Life time of orphaned FIN-WAIT-2 state */
+#define TCP_DEFER_ACCEPT        9       /* Wake up listener only when data arrive */
+#define TCP_WINDOW_CLAMP        10      /* Bound advertised window */
+#define TCP_INFO                11      /* Information about this connection. */
+#define TCP_QUICKACK            12      /* Block/reenable quick acks */
+
+#define TCPI_OPT_TIMESTAMPS     1
+#define TCPI_OPT_SACK           2
+#define TCPI_OPT_WSCALE         4
+#define TCPI_OPT_ECN            8
+
+enum tcp_ca_state
+{
+        TCP_CA_Open = 0,
+#define TCPF_CA_Open    (1<<TCP_CA_Open)
+        TCP_CA_Disorder = 1,
+#define TCPF_CA_Disorder (1<<TCP_CA_Disorder)
+        TCP_CA_CWR = 2,
+#define TCPF_CA_CWR     (1<<TCP_CA_CWR)
+        TCP_CA_Recovery = 3,
+#define TCPF_CA_Recovery (1<<TCP_CA_Recovery)
+        TCP_CA_Loss = 4
+#define TCPF_CA_Loss    (1<<TCP_CA_Loss)
+};
+
+struct tcp_info
+{
+        __u8    tcpi_state;
+        __u8    tcpi_ca_state;
+        __u8    tcpi_retransmits;
+        __u8    tcpi_probes;
+        __u8    tcpi_backoff;
+        __u8    tcpi_options;
+        __u8    tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
+
+        __u32   tcpi_rto;
+        __u32   tcpi_ato;
+        __u32   tcpi_snd_mss;
+        __u32   tcpi_rcv_mss;
+
+        __u32   tcpi_unacked;
+        __u32   tcpi_sacked;
+        __u32   tcpi_lost;
+        __u32   tcpi_retrans;
+        __u32   tcpi_fackets;
+
+        /* Times. */
+        __u32   tcpi_last_data_sent;
+        __u32   tcpi_last_ack_sent;     /* Not remembered, sorry. */
+        __u32   tcpi_last_data_recv;
+        __u32   tcpi_last_ack_recv;
+
+        /* Metrics. */
+        __u32   tcpi_pmtu;
+        __u32   tcpi_rcv_ssthresh;
+        __u32   tcpi_rtt;
+        __u32   tcpi_rttvar;
+        __u32   tcpi_snd_ssthresh;
+        __u32   tcpi_snd_cwnd;
+        __u32   tcpi_advmss;
+        __u32   tcpi_reordering;
+
+        __u32   tcpi_rcv_rtt;
+        __u32   tcpi_rcv_space;
+
+        __u32   tcpi_total_retrans;
+};
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/skbuff.h>
+#include <linux/ip.h>
+#include <net/sock.h>
+
+/* This defines a selective acknowledgement block. */
+struct tcp_sack_block {
+        __u32   start_seq;
+        __u32   end_seq;
+};
+
+enum tcp_congestion_algo {
+        TCP_RENO=0,
+        TCP_VEGAS,
+        TCP_WESTWOOD,
+        TCP_BIC,
+};
+
+struct tcp_options_received {
+/*      PAWS/RTTM data  */
+        long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
+        __u32   ts_recent;      /* Time stamp to echo next              */
+        __u32   rcv_tsval;      /* Time stamp value                     */
+        __u32   rcv_tsecr;      /* Time stamp echo reply                */
+        __u16   saw_tstamp : 1, /* Saw TIMESTAMP on last packet         */
+                tstamp_ok : 1,  /* TIMESTAMP seen on SYN packet         */
+                dsack : 1,      /* D-SACK is scheduled                  */
+                wscale_ok : 1,  /* Wscale seen on SYN packet            */
+                sack_ok : 4,    /* SACK seen on SYN packet              */
+                snd_wscale : 4, /* Window scaling received from sender  */
+                rcv_wscale : 4; /* Window scaling to send to receiver   */
+/*      SACKs data      */
+        __u8    eff_sacks;      /* Size of SACK array to send with next packet */
+        __u8    num_sacks;      /* Number of SACK blocks                */
+        __u16   user_mss;       /* mss requested by user in ioctl */
+        __u16   mss_clamp;      /* Maximal mss, negotiated at connection setup */
+};
+
+struct tcp_sock {
+        /* inet_sock has to be the first member of tcp_sock */
+        struct inet_sock        inet;
+        int     tcp_header_len; /* Bytes of tcp header to send          */
+
+/*
+ *      Header prediction flags
+ *      0x5?10 << 16 + snd_wnd in net byte order
+ */
+        __u32   pred_flags;
+
+/*
+ *      RFC793 variables by their proper names. This means you can
+ *      read the code and the spec side by side (and laugh ...)
+ *      See RFC793 and RFC1122. The RFC writes these in capitals.
+ */
+        __u32   rcv_nxt;        /* What we want to receive next         */
+        __u32   snd_nxt;        /* Next sequence we send                */
+
+        __u32   snd_una;        /* First byte we want an ack for        */
+        __u32   snd_sml;        /* Last byte of the most recently transmitted small packet */
+        __u32   rcv_tstamp;     /* timestamp of last received ACK (for keepalives) */
+        __u32   lsndtime;       /* timestamp of last sent data packet (for restart window) */
+        struct tcp_bind_bucket *bind_hash;
+        /* Delayed ACK control data */
+        struct {
+                __u8    pending;        /* ACK is pending */
+                __u8    quick;          /* Scheduled number of quick acks       */
+                __u8    pingpong;       /* The session is interactive           */
+                __u8    blocked;        /* Delayed ACK was blocked by socket lock*/
+                __u32   ato;            /* Predicted tick of soft clock         */
+                unsigned long timeout;  /* Currently scheduled timeout          */
+                __u32   lrcvtime;       /* timestamp of last received data packet*/
+                __u16   last_seg_size;  /* Size of last incoming segment        */
+                __u16   rcv_mss;        /* MSS used for delayed ACK decisions   */ 
+        } ack;
+
+        /* Data for direct copy to user */
+        struct {
+                struct sk_buff_head     prequeue;
+                struct task_struct      *task;
+                struct iovec            *iov;
+                int                     memory;
+                int                     len;
+        } ucopy;
+
+        __u32   snd_wl1;        /* Sequence for window update           */
+        __u32   snd_wnd;        /* The window we expect to receive      */
+        __u32   max_window;     /* Maximal window ever seen from peer   */
+        __u32   pmtu_cookie;    /* Last pmtu seen by socket             */
+        __u32   mss_cache;      /* Cached effective mss, not including SACKS */
+        __u16   mss_cache_std;  /* Like mss_cache, but without TSO */
+        __u16   ext_header_len; /* Network protocol overhead (IP/IPv6 options) */
+        __u8    ca_state;       /* State of fast-retransmit machine     */
+        __u8    retransmits;    /* Number of unrecovered RTO timeouts.  */
+
+        __u16   advmss;         /* Advertised MSS                       */
+        __u32   window_clamp;   /* Maximal window to advertise          */
+        __u32   rcv_ssthresh;   /* Current window clamp                 */
+
+        __u32   frto_highmark;  /* snd_nxt when RTO occurred */
+        __u8    reordering;     /* Packet reordering metric.            */
+        __u8    frto_counter;   /* Number of new acks after RTO */
+
+        __u8    adv_cong;       /* Using Vegas, Westwood, or BIC */
+        __u8    defer_accept;   /* User waits for some data after accept() */
+
+/* RTT measurement */
+        __u32   srtt;           /* smoothed round trip time << 3        */
+        __u32   mdev;           /* medium deviation                     */
+        __u32   mdev_max;       /* maximal mdev for the last rtt period */
+        __u32   rttvar;         /* smoothed mdev_max                    */
+        __u32   rtt_seq;        /* sequence number to update rttvar     */
+        __u32   rto;            /* retransmit timeout                   */
+
+        __u32   packets_out;    /* Packets which are "in flight"        */
+        __u32   left_out;       /* Packets which leaved network */
+        __u32   retrans_out;    /* Retransmitted packets out            */
+        __u8    backoff;        /* backoff                              */
+/*
+ *      Options received (usually on last packet, some only on SYN packets).
+ */
+        __u8    nonagle;        /* Disable Nagle algorithm?             */
+        __u8    keepalive_probes; /* num of allowed keep alive probes   */
+
+        __u8    probes_out;     /* unanswered 0 window probes           */
+        struct tcp_options_received rx_opt;
+
+/*
+ *      Slow start and congestion control (see also Nagle, and Karn & Partridge)
+ */
+        __u32   snd_ssthresh;   /* Slow start size threshold            */
+        __u32   snd_cwnd;       /* Sending congestion window            */
+        __u16   snd_cwnd_cnt;   /* Linear increase counter              */
+        __u16   snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */
+        __u32   snd_cwnd_used;
+        __u32   snd_cwnd_stamp;
+
+        /* Two commonly used timers in both sender and receiver paths. */
+        unsigned long           timeout;
+        struct timer_list       retransmit_timer;       /* Resend (no ack)      */
+        struct timer_list       delack_timer;           /* Ack delay            */
+
+        struct sk_buff_head     out_of_order_queue; /* Out of order segments go here */
+
+        struct tcp_func         *af_specific;   /* Operations which are AF_INET{4,6} specific   */
+
+        __u32   rcv_wnd;        /* Current receiver window              */
+        __u32   rcv_wup;        /* rcv_nxt on last window update sent   */
+        __u32   write_seq;      /* Tail(+1) of data held in tcp send buffer */
+        __u32   pushed_seq;     /* Last pushed seq, required to talk to windows */
+        __u32   copied_seq;     /* Head of yet unread data              */
+
+/*      SACKs data      */
+        struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
+        struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
+
+        __u8    syn_retries;    /* num of allowed syn retries */
+        __u8    ecn_flags;      /* ECN status bits.                     */
+        __u16   prior_ssthresh; /* ssthresh saved at recovery start     */
+        __u32   lost_out;       /* Lost packets                 */
+        __u32   sacked_out;     /* SACK'd packets                       */
+        __u32   fackets_out;    /* FACK'd packets                       */
+        __u32   high_seq;       /* snd_nxt at onset of congestion       */
+
+        __u32   retrans_stamp;  /* Timestamp of the last retransmit,
+                                 * also used in SYN-SENT to remember stamp of
+                                 * the first SYN. */
+        __u32   undo_marker;    /* tracking retrans started here. */
+        int     undo_retrans;   /* number of undoable retransmissions. */
+        __u32   urg_seq;        /* Seq of received urgent pointer */
+        __u16   urg_data;       /* Saved octet of OOB data and control flags */
+        __u8    pending;        /* Scheduled timer event        */
+        __u8    urg_mode;       /* In urgent mode               */
+        __u32   snd_up;         /* Urgent pointer               */
+
+        __u32   total_retrans;  /* Total retransmits for entire connection */
+
+        /* The syn_wait_lock is necessary only to avoid proc interface having
+         * to grab the main lock sock while browsing the listening hash
+         * (otherwise it's deadlock prone).
+         * This lock is acquired in read mode only from listening_get_next()
+         * and it's acquired in write mode _only_ from code that is actively
+         * changing the syn_wait_queue. All readers that are holding
+         * the master sock lock don't need to grab this lock in read mode
+         * too as the syn_wait_queue writes are always protected from
+         * the main sock lock.
+         */
+        rwlock_t                syn_wait_lock;
+        struct tcp_listen_opt   *listen_opt;
+
+        /* FIFO of established children */
+        struct open_request     *accept_queue;
+        struct open_request     *accept_queue_tail;
+
+        unsigned int            keepalive_time;   /* time before keep alive takes place */
+        unsigned int            keepalive_intvl;  /* time interval between keep alive probes */
+        int                     linger2;
+
+        unsigned long last_synq_overflow; 
+
+/* Receiver side RTT estimation */
+        struct {
+                __u32   rtt;
+                __u32   seq;
+                __u32   time;
+        } rcv_rtt_est;
+
+/* Receiver queue space */
+        struct {
+                int     space;
+                __u32   seq;
+                __u32   time;
+        } rcvq_space;
+
+/* TCP Westwood structure */
+        struct {
+                __u32    bw_ns_est;        /* first bandwidth estimation..not too smoothed 8) */
+                __u32    bw_est;           /* bandwidth estimate */
+                __u32    rtt_win_sx;       /* here starts a new evaluation... */
+                __u32    bk;
+                __u32    snd_una;          /* used for evaluating the number of acked bytes */
+                __u32    cumul_ack;
+                __u32    accounted;
+                __u32    rtt;
+                __u32    rtt_min;          /* minimum observed RTT */
+        } westwood;
+
+/* Vegas variables */
+        struct {
+                __u32   beg_snd_nxt;    /* right edge during last RTT */
+                __u32   beg_snd_una;    /* left edge  during last RTT */
+                __u32   beg_snd_cwnd;   /* saves the size of the cwnd */
+                __u8    doing_vegas_now;/* if true, do vegas for this RTT */
+                __u16   cntRTT;         /* # of RTTs measured within last RTT */
+                __u32   minRTT;         /* min of RTTs measured within last RTT (in usec) */
+                __u32   baseRTT;        /* the min of all Vegas RTT measurements seen (in usec) */
+        } vegas;
+
+        /* BI TCP Parameters */
+        struct {
+                __u32   cnt;            /* increase cwnd by 1 after this number of ACKs */
+                __u32   last_max_cwnd;  /* last maximium snd_cwnd */
+                __u32   last_cwnd;      /* the last snd_cwnd */
+                __u32   last_stamp;     /* time when updated last_cwnd */
+        } bictcp;
+};
+
+static inline struct tcp_sock *tcp_sk(const struct sock *sk)
+{
+        return (struct tcp_sock *)sk;
+}
+
+#endif
+
+#endif  /* _LINUX_TCP_H */
diff --git a/include/linux/tcp_diag.h b/include/linux/tcp_diag.h
new file mode 100644
index 000000000000..ceee962e1d15
--- /dev/null
+++ b/include/linux/tcp_diag.h
@@ -0,0 +1,127 @@
+#ifndef _TCP_DIAG_H_
+#define _TCP_DIAG_H_ 1
+
+/* Just some random number */
+#define TCPDIAG_GETSOCK 18
+
+/* Socket identity */
+struct tcpdiag_sockid
+{
+        __u16   tcpdiag_sport;
+        __u16   tcpdiag_dport;
+        __u32   tcpdiag_src[4];
+        __u32   tcpdiag_dst[4];
+        __u32   tcpdiag_if;
+        __u32   tcpdiag_cookie[2];
+#define TCPDIAG_NOCOOKIE (~0U)
+};
+
+/* Request structure */
+
+struct tcpdiagreq
+{
+        __u8    tcpdiag_family;         /* Family of addresses. */
+        __u8    tcpdiag_src_len;
+        __u8    tcpdiag_dst_len;
+        __u8    tcpdiag_ext;            /* Query extended information */
+
+        struct tcpdiag_sockid id;
+
+        __u32   tcpdiag_states;         /* States to dump */
+        __u32   tcpdiag_dbs;            /* Tables to dump (NI) */
+};
+
+enum
+{
+        TCPDIAG_REQ_NONE,
+        TCPDIAG_REQ_BYTECODE,
+};
+
+#define TCPDIAG_REQ_MAX TCPDIAG_REQ_BYTECODE
+
+/* Bytecode is sequence of 4 byte commands followed by variable arguments.
+ * All the commands identified by "code" are conditional jumps forward:
+ * to offset cc+"yes" or to offset cc+"no". "yes" is supposed to be
+ * length of the command and its arguments.
+ */
+ 
+struct tcpdiag_bc_op
+{
+        unsigned char   code;
+        unsigned char   yes;
+        unsigned short  no;
+};
+
+enum
+{
+        TCPDIAG_BC_NOP,
+        TCPDIAG_BC_JMP,
+        TCPDIAG_BC_S_GE,
+        TCPDIAG_BC_S_LE,
+        TCPDIAG_BC_D_GE,
+        TCPDIAG_BC_D_LE,
+        TCPDIAG_BC_AUTO,
+        TCPDIAG_BC_S_COND,
+        TCPDIAG_BC_D_COND,
+};
+
+struct tcpdiag_hostcond
+{
+        __u8    family;
+        __u8    prefix_len;
+        int     port;
+        __u32   addr[0];
+};
+
+/* Base info structure. It contains socket identity (addrs/ports/cookie)
+ * and, alas, the information shown by netstat. */
+struct tcpdiagmsg
+{
+        __u8    tcpdiag_family;
+        __u8    tcpdiag_state;
+        __u8    tcpdiag_timer;
+        __u8    tcpdiag_retrans;
+
+        struct tcpdiag_sockid id;
+
+        __u32   tcpdiag_expires;
+        __u32   tcpdiag_rqueue;
+        __u32   tcpdiag_wqueue;
+        __u32   tcpdiag_uid;
+        __u32   tcpdiag_inode;
+};
+
+/* Extensions */
+
+enum
+{
+        TCPDIAG_NONE,
+        TCPDIAG_MEMINFO,
+        TCPDIAG_INFO,
+        TCPDIAG_VEGASINFO,
+};
+
+#define TCPDIAG_MAX TCPDIAG_VEGASINFO
+
+
+/* TCPDIAG_MEM */
+
+struct tcpdiag_meminfo
+{
+        __u32   tcpdiag_rmem;
+        __u32   tcpdiag_wmem;
+        __u32   tcpdiag_fmem;
+        __u32   tcpdiag_tmem;
+};
+
+/* TCPDIAG_VEGASINFO */
+
+struct tcpvegas_info {
+        __u32   tcpv_enabled;
+        __u32   tcpv_rttcnt;
+        __u32   tcpv_rtt;
+        __u32   tcpv_minrtt;
+};
+
+
+#endif /* _TCP_DIAG_H_ */
diff --git a/include/linux/telephony.h b/include/linux/telephony.h
new file mode 100644
index 000000000000..0d0cf2a1e7bc
--- /dev/null
+++ b/include/linux/telephony.h
@@ -0,0 +1,266 @@
+/******************************************************************************
+ *
+ *              telephony.h
+ *
+ *              Basic Linux Telephony Interface
+ *
+ *              (c) Copyright 1999-2001 Quicknet Technologies, Inc.
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ *    Authors:       Ed Okerson, <eokerson@quicknet.net>
+ *                   Greg Herlein, <gherlein@quicknet.net>
+ *
+ *    Contributors:  Alan Cox, <alan@redhat.com>
+ *                   David W. Erhart, <derhart@quicknet.net>
+ *
+ * IN NO EVENT SHALL QUICKNET TECHNOLOGIES, INC. BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
+ * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF QUICKNET
+ * TECHNOLOGIES, INC. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * QUICKNET TECHNOLOGIES, INC. SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION
+ * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ * Version:       $Revision: 4.2 $
+ *
+ * $Id: telephony.h,v 4.2 2001/08/06 07:09:43 craigs Exp $
+ *
+ *****************************************************************************/
+
+#ifndef TELEPHONY_H
+#define TELEPHONY_H
+
+#define TELEPHONY_VERSION 3013
+
+#define PHONE_VENDOR_IXJ          1
+#define PHONE_VENDOR_QUICKNET     PHONE_VENDOR_IXJ
+#define PHONE_VENDOR_VOICETRONIX  2
+#define PHONE_VENDOR_ACULAB       3
+#define PHONE_VENDOR_DIGI         4
+#define PHONE_VENDOR_FRANKLIN     5
+
+/******************************************************************************
+ *  Vendor Summary Information Area
+ *
+ *  Quicknet Technologies, Inc. - makes low density analog telephony cards
+ *    with audio compression, POTS and PSTN interfaces (www.quicknet.net)
+ *
+ *  (other vendors following this API shuld add a short description of
+ *  the telephony products they support under Linux)
+ *
+ *****************************************************************************/
+#define QTI_PHONEJACK           100
+#define QTI_LINEJACK            300
+#define QTI_PHONEJACK_LITE      400
+#define QTI_PHONEJACK_PCI       500
+#define QTI_PHONECARD           600
+
+/******************************************************************************
+*
+* The capabilities ioctls can inform you of the capabilities of each phone
+* device installed in your system.  The PHONECTL_CAPABILITIES ioctl
+* returns an integer value indicating the number of capabilities the   
+* device has.  The PHONECTL_CAPABILITIES_LIST will fill an array of 
+* capability structs with all of its capabilities.  The
+* PHONECTL_CAPABILITIES_CHECK takes a single capability struct and returns
+* a TRUE if the device has that capability, otherwise it returns false.
+* 
+******************************************************************************/
+typedef enum {
+        vendor = 0,
+        device,
+        port,
+        codec,
+        dsp
+} phone_cap;
+
+struct phone_capability {
+        char desc[80];
+        phone_cap captype;
+        int cap;
+        int handle;
+};
+
+typedef enum {
+        pots = 0,
+        pstn,
+        handset,
+        speaker
+} phone_ports;
+
+#define PHONE_CAPABILITIES              _IO  ('q', 0x80)
+#define PHONE_CAPABILITIES_LIST         _IOR ('q', 0x81, struct phone_capability *)
+#define PHONE_CAPABILITIES_CHECK        _IOW ('q', 0x82, struct phone_capability *)
+
+typedef struct {
+        char month[3];
+        char day[3];
+        char hour[3];
+        char min[3];
+        int numlen;
+        char number[11];
+        int namelen;
+        char name[80];
+} PHONE_CID;
+ 
+#define PHONE_RING                      _IO  ('q', 0x83)
+#define PHONE_HOOKSTATE                 _IO  ('q', 0x84)
+#define PHONE_MAXRINGS                  _IOW ('q', 0x85, char)
+#define PHONE_RING_CADENCE              _IOW ('q', 0x86, short)
+#define OLD_PHONE_RING_START            _IO  ('q', 0x87)
+#define PHONE_RING_START                _IOW ('q', 0x87, PHONE_CID *)
+#define PHONE_RING_STOP                 _IO  ('q', 0x88)
+
+#define USA_RING_CADENCE         0xC0C0
+
+#define PHONE_REC_CODEC                 _IOW ('q', 0x89, int)
+#define PHONE_REC_START                 _IO  ('q', 0x8A)
+#define PHONE_REC_STOP                  _IO  ('q', 0x8B)
+#define PHONE_REC_DEPTH                 _IOW ('q', 0x8C, int)
+#define PHONE_FRAME                     _IOW ('q', 0x8D, int)
+#define PHONE_REC_VOLUME                _IOW ('q', 0x8E, int)
+#define PHONE_REC_VOLUME_LINEAR         _IOW ('q', 0xDB, int)
+#define PHONE_REC_LEVEL                 _IO  ('q', 0x8F)
+
+#define PHONE_PLAY_CODEC                _IOW ('q', 0x90, int)
+#define PHONE_PLAY_START                _IO  ('q', 0x91)
+#define PHONE_PLAY_STOP                 _IO  ('q', 0x92)
+#define PHONE_PLAY_DEPTH                _IOW ('q', 0x93, int)
+#define PHONE_PLAY_VOLUME               _IOW ('q', 0x94, int)
+#define PHONE_PLAY_VOLUME_LINEAR        _IOW ('q', 0xDC, int)
+#define PHONE_PLAY_LEVEL                _IO  ('q', 0x95)
+#define PHONE_DTMF_READY                _IOR ('q', 0x96, int)
+#define PHONE_GET_DTMF                  _IOR ('q', 0x97, int)
+#define PHONE_GET_DTMF_ASCII            _IOR ('q', 0x98, int)
+#define PHONE_DTMF_OOB                  _IOW ('q', 0x99, int)
+#define PHONE_EXCEPTION                 _IOR ('q', 0x9A, int)
+#define PHONE_PLAY_TONE                 _IOW ('q', 0x9B, char)
+#define PHONE_SET_TONE_ON_TIME          _IOW ('q', 0x9C, int)
+#define PHONE_SET_TONE_OFF_TIME         _IOW ('q', 0x9D, int)
+#define PHONE_GET_TONE_ON_TIME          _IO  ('q', 0x9E)
+#define PHONE_GET_TONE_OFF_TIME         _IO  ('q', 0x9F)
+#define PHONE_GET_TONE_STATE            _IO  ('q', 0xA0)
+#define PHONE_BUSY                      _IO  ('q', 0xA1)
+#define PHONE_RINGBACK                  _IO  ('q', 0xA2)
+#define PHONE_DIALTONE                  _IO  ('q', 0xA3)
+#define PHONE_CPT_STOP                  _IO  ('q', 0xA4)
+
+#define PHONE_PSTN_SET_STATE            _IOW ('q', 0xA4, int)
+#define PHONE_PSTN_GET_STATE            _IO  ('q', 0xA5)
+
+#define PSTN_ON_HOOK            0
+#define PSTN_RINGING            1
+#define PSTN_OFF_HOOK           2
+#define PSTN_PULSE_DIAL         3
+
+/******************************************************************************
+* 
+* The wink duration is tunable with this ioctl.  The default wink duration  
+* is 320ms.  You do not need to use this ioctl if you do not require a
+* different wink duration.
+* 
+******************************************************************************/
+#define PHONE_WINK_DURATION             _IOW ('q', 0xA6, int)
+#define PHONE_WINK                      _IOW ('q', 0xAA, int)
+
+/******************************************************************************
+* 
+*  Codec Definitions
+* 
+******************************************************************************/
+typedef enum {
+        G723_63 = 1,
+        G723_53 = 2,
+        TS85 = 3,
+        TS48 = 4,
+        TS41 = 5,
+        G728 = 6,
+        G729 = 7,
+        ULAW = 8,
+        ALAW = 9,
+        LINEAR16 = 10,
+        LINEAR8 = 11,
+        WSS = 12,
+        G729B = 13
+} phone_codec;
+
+struct phone_codec_data
+{
+        phone_codec type;
+        unsigned short buf_min, buf_opt, buf_max;
+};
+
+#define PHONE_QUERY_CODEC               _IOWR ('q', 0xA7, struct phone_codec_data *)
+#define PHONE_PSTN_LINETEST             _IO ('q', 0xA8)
+
+/******************************************************************************
+* 
+* This controls the VAD/CNG functionality of G.723.1.  The driver will
+* always pass full size frames, any unused bytes will be padded with zeros,
+* and frames passed to the driver should also be padded with zeros.  The
+* frame type is encoded in the least significant two bits of the first
+* WORD of the frame as follows:
+*
+* bits 1-0      Frame Type      Data Rate               Significant Words
+* 00            0               G.723.1 6.3             12
+* 01            1               G.723.1 5.3             10
+* 10            2               VAD/CNG                  2
+* 11            3               Repeat last CNG          2 bits
+* 
+******************************************************************************/
+#define PHONE_VAD                       _IOW ('q', 0xA9, int)
+
+
+/******************************************************************************
+*
+* The exception structure allows us to multiplex multiple events onto the
+* select() exception set.  If any of these flags are set select() will
+* return with a positive indication on the exception set.  The dtmf_ready
+* bit indicates if there is data waiting in the DTMF buffer.  The
+* hookstate bit is set if there is a change in hookstate status, it does not
+* indicate the current state of the hookswitch.  The pstn_ring bit
+* indicates that the DAA on a LineJACK card has detected ring voltage on
+* the PSTN port.  The caller_id bit indicates that caller_id data has been
+* received and is available.  The pstn_wink bit indicates that the DAA on
+* the LineJACK has received a wink from the telco switch.  The f0, f1, f2
+* and f3 bits indicate that the filter has been triggered by detecting the
+* frequency programmed into that filter.
+*
+* The remaining bits should be set to zero. They will become defined over time
+* for other interface cards and their needs.
+*
+******************************************************************************/
+struct phone_except
+{
+        unsigned int dtmf_ready:1;
+        unsigned int hookstate:1;
+        unsigned int pstn_ring:1;
+        unsigned int caller_id:1;
+        unsigned int pstn_wink:1;
+        unsigned int f0:1;
+        unsigned int f1:1;
+        unsigned int f2:1;
+        unsigned int f3:1;
+        unsigned int flash:1;
+        unsigned int fc0:1;
+        unsigned int fc1:1;
+        unsigned int fc2:1;
+        unsigned int fc3:1;
+        unsigned int reserved:18;
+};
+
+union telephony_exception {
+        struct phone_except bits;
+        unsigned int bytes;
+};
+
+
+#endif          /* TELEPHONY_H */
+
diff --git a/include/linux/termios.h b/include/linux/termios.h
new file mode 100644
index 000000000000..478662889f48
--- /dev/null
+++ b/include/linux/termios.h
@@ -0,0 +1,7 @@
+#ifndef _LINUX_TERMIOS_H
+#define _LINUX_TERMIOS_H
+
+#include <linux/types.h>
+#include <asm/termios.h>
+
+#endif
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
new file mode 100644
index 000000000000..d252f45a0f9b
--- /dev/null
+++ b/include/linux/thread_info.h
@@ -0,0 +1,92 @@
+/* thread_info.h: common low-level thread information accessors
+ *
+ * Copyright (C) 2002  David Howells (dhowells@redhat.com)
+ * - Incorporating suggestions made by Linus Torvalds
+ */
+
+#ifndef _LINUX_THREAD_INFO_H
+#define _LINUX_THREAD_INFO_H
+
+/*
+ * System call restart block. 
+ */
+struct restart_block {
+        long (*fn)(struct restart_block *);
+        unsigned long arg0, arg1, arg2, arg3;
+};
+
+extern long do_no_restart_syscall(struct restart_block *parm);
+
+#include <linux/bitops.h>
+#include <asm/thread_info.h>
+
+#ifdef __KERNEL__
+
+/*
+ * flag set/clear/test wrappers
+ * - pass TIF_xxxx constants to these functions
+ */
+
+static inline void set_thread_flag(int flag)
+{
+        set_bit(flag,&current_thread_info()->flags);
+}
+
+static inline void clear_thread_flag(int flag)
+{
+        clear_bit(flag,&current_thread_info()->flags);
+}
+
+static inline int test_and_set_thread_flag(int flag)
+{
+        return test_and_set_bit(flag,&current_thread_info()->flags);
+}
+
+static inline int test_and_clear_thread_flag(int flag)
+{
+        return test_and_clear_bit(flag,&current_thread_info()->flags);
+}
+
+static inline int test_thread_flag(int flag)
+{
+        return test_bit(flag,&current_thread_info()->flags);
+}
+
+static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
+{
+        set_bit(flag,&ti->flags);
+}
+
+static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
+{
+        clear_bit(flag,&ti->flags);
+}
+
+static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
+{
+        return test_and_set_bit(flag,&ti->flags);
+}
+
+static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
+{
+        return test_and_clear_bit(flag,&ti->flags);
+}
+
+static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
+{
+        return test_bit(flag,&ti->flags);
+}
+
+static inline void set_need_resched(void)
+{
+        set_thread_flag(TIF_NEED_RESCHED);
+}
+
+static inline void clear_need_resched(void)
+{
+        clear_thread_flag(TIF_NEED_RESCHED);
+}
+
+#endif
+
+#endif /* _LINUX_THREAD_INFO_H */
diff --git a/include/linux/threads.h b/include/linux/threads.h
new file mode 100644
index 000000000000..b59738ac6197
--- /dev/null
+++ b/include/linux/threads.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_THREADS_H
+#define _LINUX_THREADS_H
+
+#include <linux/config.h>
+
+/*
+ * The default limit for the nr of threads is now in
+ * /proc/sys/kernel/threads-max.
+ */
+
+/*
+ * Maximum supported processors that can run under SMP.  This value is
+ * set via configure setting.  The maximum is equal to the size of the
+ * bitmasks used on that platform, i.e. 32 or 64.  Setting this smaller
+ * saves quite a bit of memory.
+ */
+#ifdef CONFIG_SMP
+#define NR_CPUS         CONFIG_NR_CPUS
+#else
+#define NR_CPUS         1
+#endif
+
+#define MIN_THREADS_LEFT_FOR_ROOT 4
+
+/*
+ * This controls the default maximum pid allocated to a process
+ */
+#define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000)
+
+/*
+ * A maximum of 4 million PIDs should be enough for a while:
+ */
+#define PID_MAX_LIMIT (CONFIG_BASE_SMALL ? PAGE_SIZE * 8 : \
+        (sizeof(long) > 4 ? 4 * 1024 * 1024 : PID_MAX_DEFAULT))
+
+#endif
diff --git a/include/linux/ticable.h b/include/linux/ticable.h
new file mode 100644
index 000000000000..8c2212086dcd
--- /dev/null
+++ b/include/linux/ticable.h
@@ -0,0 +1,44 @@
+/* Hey EMACS -*- linux-c -*-
+ *
+ * tipar/tiser/tiusb - low level driver for handling link cables
+ * designed for Texas Instruments graphing calculators.
+ *
+ * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org>
+ *
+ * Redistribution of this file is permitted under the terms of the GNU
+ * Public License (GPL)
+ */
+
+#ifndef _TICABLE_H 
+#define _TICABLE_H 1
+
+/* Internal default constants for the kernel module */
+#define TIMAXTIME 15      /* 1.5 seconds       */
+#define IO_DELAY  10      /* 10 micro-seconds  */
+
+/* Major & minor number for character devices */
+#define TIPAR_MAJOR  115 /* 0 to 7 */
+#define TIPAR_MINOR    0
+
+#define TISER_MAJOR  115 /* 8 to 15 */
+#define TISER_MINOR    8
+
+#define TIUSB_MAJOR  115  /* 16 to 31 */
+#define TIUSB_MINOR   16
+
+/*
+ * Request values for the 'ioctl' function.
+ */
+#define IOCTL_TIPAR_DELAY     _IOW('p', 0xa8, int) /* set delay   */
+#define IOCTL_TIPAR_TIMEOUT   _IOW('p', 0xa9, int) /* set timeout */
+
+#define IOCTL_TISER_DELAY     _IOW('p', 0xa0, int) /* set delay   */
+#define IOCTL_TISER_TIMEOUT   _IOW('p', 0xa1, int) /* set timeout */
+
+#define IOCTL_TIUSB_TIMEOUT        _IOW('N', 0x20, int) /* set timeout */
+#define IOCTL_TIUSB_RESET_DEVICE   _IOW('N', 0x21, int) /* reset device */
+#define IOCTL_TIUSB_RESET_PIPES    _IOW('N', 0x22, int) /* reset both pipes*/
+#define IOCTL_TIUSB_GET_MAXPS      _IOR('N', 0x23, int) /* max packet size */
+#define IOCTL_TIUSB_GET_DEVID      _IOR('N', 0x24, int) /* get device type */
+
+#endif /* TICABLE_H */
diff --git a/include/linux/time.h b/include/linux/time.h
new file mode 100644
index 000000000000..5634497ff5df
--- /dev/null
+++ b/include/linux/time.h
@@ -0,0 +1,181 @@
+#ifndef _LINUX_TIME_H
+#define _LINUX_TIME_H
+
+#include <linux/types.h>
+
+#ifdef __KERNEL__
+#include <linux/seqlock.h>
+#endif
+
+#ifndef _STRUCT_TIMESPEC
+#define _STRUCT_TIMESPEC
+struct timespec {
+        time_t  tv_sec;         /* seconds */
+        long    tv_nsec;        /* nanoseconds */
+};
+#endif /* _STRUCT_TIMESPEC */
+
+struct timeval {
+        time_t          tv_sec;         /* seconds */
+        suseconds_t     tv_usec;        /* microseconds */
+};
+
+struct timezone {
+        int     tz_minuteswest; /* minutes west of Greenwich */
+        int     tz_dsttime;     /* type of dst correction */
+};
+
+#ifdef __KERNEL__
+
+/* Parameters used to convert the timespec values */
+#ifndef USEC_PER_SEC
+#define USEC_PER_SEC (1000000L)
+#endif
+
+#ifndef NSEC_PER_SEC
+#define NSEC_PER_SEC (1000000000L)
+#endif
+
+#ifndef NSEC_PER_USEC
+#define NSEC_PER_USEC (1000L)
+#endif
+
+static __inline__ int timespec_equal(struct timespec *a, struct timespec *b) 
+{ 
+        return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
+} 
+
+/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
+ * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
+ * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
+ *
+ * [For the Julian calendar (which was used in Russia before 1917,
+ * Britain & colonies before 1752, anywhere else before 1582,
+ * and is still in use by some communities) leave out the
+ * -year/100+year/400 terms, and add 10.]
+ *
+ * This algorithm was first published by Gauss (I think).
+ *
+ * WARNING: this function will overflow on 2106-02-07 06:28:16 on
+ * machines were long is 32-bit! (However, as time_t is signed, we
+ * will already get problems at other places on 2038-01-19 03:14:08)
+ */
+static inline unsigned long
+mktime (unsigned int year, unsigned int mon,
+        unsigned int day, unsigned int hour,
+        unsigned int min, unsigned int sec)
+{
+        if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
+                mon += 12;              /* Puts Feb last since it has leap day */
+                year -= 1;
+        }
+
+        return (((
+                (unsigned long) (year/4 - year/100 + year/400 + 367*mon/12 + day) +
+                        year*365 - 719499
+            )*24 + hour /* now have hours */
+          )*60 + min /* now have minutes */
+        )*60 + sec; /* finally seconds */
+}
+
+extern struct timespec xtime;
+extern struct timespec wall_to_monotonic;
+extern seqlock_t xtime_lock;
+
+static inline unsigned long get_seconds(void)
+{ 
+        return xtime.tv_sec;
+}
+
+struct timespec current_kernel_time(void);
+
+#define CURRENT_TIME (current_kernel_time())
+#define CURRENT_TIME_SEC ((struct timespec) { xtime.tv_sec, 0 })
+
+extern void do_gettimeofday(struct timeval *tv);
+extern int do_settimeofday(struct timespec *tv);
+extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
+extern void clock_was_set(void); // call when ever the clock is set
+extern int do_posix_clock_monotonic_gettime(struct timespec *tp);
+extern long do_nanosleep(struct timespec *t);
+extern long do_utimes(char __user * filename, struct timeval * times);
+struct itimerval;
+extern int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue);
+extern int do_getitimer(int which, struct itimerval *value);
+extern void getnstimeofday (struct timespec *tv);
+
+extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
+
+static inline void
+set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
+{
+        while (nsec > NSEC_PER_SEC) {
+                nsec -= NSEC_PER_SEC;
+                ++sec;
+        }
+        while (nsec < 0) {
+                nsec += NSEC_PER_SEC;
+                --sec;
+        }
+        ts->tv_sec = sec;
+        ts->tv_nsec = nsec;
+}
+
+#endif /* __KERNEL__ */
+
+#define NFDBITS                 __NFDBITS
+
+#define FD_SETSIZE              __FD_SETSIZE
+#define FD_SET(fd,fdsetp)       __FD_SET(fd,fdsetp)
+#define FD_CLR(fd,fdsetp)       __FD_CLR(fd,fdsetp)
+#define FD_ISSET(fd,fdsetp)     __FD_ISSET(fd,fdsetp)
+#define FD_ZERO(fdsetp)         __FD_ZERO(fdsetp)
+
+/*
+ * Names of the interval timers, and structure
+ * defining a timer setting.
+ */
+#define ITIMER_REAL     0
+#define ITIMER_VIRTUAL  1
+#define ITIMER_PROF     2
+
+struct  itimerspec {
+        struct  timespec it_interval;    /* timer period */
+        struct  timespec it_value;       /* timer expiration */
+};
+
+struct  itimerval {
+        struct  timeval it_interval;    /* timer interval */
+        struct  timeval it_value;       /* current value */
+};
+
+
+/*
+ * The IDs of the various system clocks (for POSIX.1b interval timers).
+ */
+#define CLOCK_REALTIME            0
+#define CLOCK_MONOTONIC   1
+#define CLOCK_PROCESS_CPUTIME_ID 2
+#define CLOCK_THREAD_CPUTIME_ID  3
+#define CLOCK_REALTIME_HR        4
+#define CLOCK_MONOTONIC_HR        5
+
+/*
+ * The IDs of various hardware clocks
+ */
+
+
+#define CLOCK_SGI_CYCLE 10
+#define MAX_CLOCKS 16
+#define CLOCKS_MASK  (CLOCK_REALTIME | CLOCK_MONOTONIC | \
+                     CLOCK_REALTIME_HR | CLOCK_MONOTONIC_HR)
+#define CLOCKS_MONO (CLOCK_MONOTONIC & CLOCK_MONOTONIC_HR)
+
+/*
+ * The various flags for setting POSIX.1b interval timers.
+ */
+
+#define TIMER_ABSTIME 0x01
+
+
+#endif
diff --git a/include/linux/timer.h b/include/linux/timer.h
new file mode 100644
index 000000000000..90db1cc62ddd
--- /dev/null
+++ b/include/linux/timer.h
@@ -0,0 +1,102 @@
+#ifndef _LINUX_TIMER_H
+#define _LINUX_TIMER_H
+
+#include <linux/config.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/stddef.h>
+
+struct tvec_t_base_s;
+
+struct timer_list {
+        struct list_head entry;
+        unsigned long expires;
+
+        spinlock_t lock;
+        unsigned long magic;
+
+        void (*function)(unsigned long);
+        unsigned long data;
+
+        struct tvec_t_base_s *base;
+};
+
+#define TIMER_MAGIC     0x4b87ad6e
+
+#define TIMER_INITIALIZER(_function, _expires, _data) {         \
+                .function = (_function),                        \
+                .expires = (_expires),                          \
+                .data = (_data),                                \
+                .base = NULL,                                   \
+                .magic = TIMER_MAGIC,                           \
+                .lock = SPIN_LOCK_UNLOCKED,                     \
+        }
+
+/***
+ * init_timer - initialize a timer.
+ * @timer: the timer to be initialized
+ *
+ * init_timer() must be done to a timer prior calling *any* of the
+ * other timer functions.
+ */
+static inline void init_timer(struct timer_list * timer)
+{
+        timer->base = NULL;
+        timer->magic = TIMER_MAGIC;
+        spin_lock_init(&timer->lock);
+}
+
+/***
+ * timer_pending - is a timer pending?
+ * @timer: the timer in question
+ *
+ * timer_pending will tell whether a given timer is currently pending,
+ * or not. Callers must ensure serialization wrt. other operations done
+ * to this timer, eg. interrupt contexts, or other CPUs on SMP.
+ *
+ * return value: 1 if the timer is pending, 0 if not.
+ */
+static inline int timer_pending(const struct timer_list * timer)
+{
+        return timer->base != NULL;
+}
+
+extern void add_timer_on(struct timer_list *timer, int cpu);
+extern int del_timer(struct timer_list * timer);
+extern int __mod_timer(struct timer_list *timer, unsigned long expires);
+extern int mod_timer(struct timer_list *timer, unsigned long expires);
+
+extern unsigned long next_timer_interrupt(void);
+
+/***
+ * add_timer - start a timer
+ * @timer: the timer to be added
+ *
+ * The kernel will do a ->function(->data) callback from the
+ * timer interrupt at the ->expired point in the future. The
+ * current time is 'jiffies'.
+ *
+ * The timer's ->expired, ->function (and if the handler uses it, ->data)
+ * fields must be set prior calling this function.
+ *
+ * Timers with an ->expired field in the past will be executed in the next
+ * timer tick.
+ */
+static inline void add_timer(struct timer_list * timer)
+{
+        __mod_timer(timer, timer->expires);
+}
+
+#ifdef CONFIG_SMP
+  extern int del_timer_sync(struct timer_list *timer);
+  extern int del_singleshot_timer_sync(struct timer_list *timer);
+#else
+# define del_timer_sync(t) del_timer(t)
+# define del_singleshot_timer_sync(t) del_timer(t)
+#endif
+
+extern void init_timers(void);
+extern void run_local_timers(void);
+extern void it_real_fn(unsigned long);
+
+#endif
diff --git a/include/linux/times.h b/include/linux/times.h
new file mode 100644
index 000000000000..e2d3020742a6
--- /dev/null
+++ b/include/linux/times.h
@@ -0,0 +1,13 @@
+#ifndef _LINUX_TIMES_H
+#define _LINUX_TIMES_H
+
+#include <linux/types.h>
+
+struct tms {
+        clock_t tms_utime;
+        clock_t tms_stime;
+        clock_t tms_cutime;
+        clock_t tms_cstime;
+};
+
+#endif
diff --git a/include/linux/timex.h b/include/linux/timex.h
new file mode 100644
index 000000000000..74fdd07d3792
--- /dev/null
+++ b/include/linux/timex.h
@@ -0,0 +1,320 @@
+/*****************************************************************************
+ *                                                                           *
+ * Copyright (c) David L. Mills 1993                                         *
+ *                                                                           *
+ * Permission to use, copy, modify, and distribute this software and its     *
+ * documentation for any purpose and without fee is hereby granted, provided *
+ * that the above copyright notice appears in all copies and that both the   *
+ * copyright notice and this permission notice appear in supporting          *
+ * documentation, and that the name University of Delaware not be used in    *
+ * advertising or publicity pertaining to distribution of the software       *
+ * without specific, written prior permission.  The University of Delaware   *
+ * makes no representations about the suitability this software for any      *
+ * purpose.  It is provided "as is" without express or implied warranty.     *
+ *                                                                           *
+ *****************************************************************************/
+
+/*
+ * Modification history timex.h
+ *
+ * 29 Dec 97    Russell King
+ *      Moved CLOCK_TICK_RATE, CLOCK_TICK_FACTOR and FINETUNE to asm/timex.h
+ *      for ARM machines
+ *
+ *  9 Jan 97    Adrian Sun
+ *      Shifted LATCH define to allow access to alpha machines.
+ *
+ * 26 Sep 94    David L. Mills
+ *      Added defines for hybrid phase/frequency-lock loop.
+ *
+ * 19 Mar 94    David L. Mills
+ *      Moved defines from kernel routines to header file and added new
+ *      defines for PPS phase-lock loop.
+ *
+ * 20 Feb 94    David L. Mills
+ *      Revised status codes and structures for external clock and PPS
+ *      signal discipline.
+ *
+ * 28 Nov 93    David L. Mills
+ *      Adjusted parameters to improve stability and increase poll
+ *      interval.
+ *
+ * 17 Sep 93    David L. Mills
+ *      Created file $NTP/include/sys/timex.h
+ * 07 Oct 93    Torsten Duwe
+ *      Derived linux/timex.h
+ * 1995-08-13    Torsten Duwe
+ *      kernel PLL updated to 1994-12-13 specs (rfc-1589)
+ * 1997-08-30    Ulrich Windl
+ *      Added new constant NTP_PHASE_LIMIT
+ * 2004-08-12    Christoph Lameter
+ *      Reworked time interpolation logic
+ */
+#ifndef _LINUX_TIMEX_H
+#define _LINUX_TIMEX_H
+
+#include <linux/config.h>
+#include <linux/compiler.h>
+#include <linux/time.h>
+
+#include <asm/param.h>
+#include <asm/timex.h>
+
+/*
+ * SHIFT_KG and SHIFT_KF establish the damping of the PLL and are chosen
+ * for a slightly underdamped convergence characteristic. SHIFT_KH
+ * establishes the damping of the FLL and is chosen by wisdom and black
+ * art.
+ *
+ * MAXTC establishes the maximum time constant of the PLL. With the
+ * SHIFT_KG and SHIFT_KF values given and a time constant range from
+ * zero to MAXTC, the PLL will converge in 15 minutes to 16 hours,
+ * respectively.
+ */
+#define SHIFT_KG 6              /* phase factor (shift) */
+#define SHIFT_KF 16             /* PLL frequency factor (shift) */
+#define SHIFT_KH 2              /* FLL frequency factor (shift) */
+#define MAXTC 6                 /* maximum time constant (shift) */
+
+/*
+ * The SHIFT_SCALE define establishes the decimal point of the time_phase
+ * variable which serves as an extension to the low-order bits of the
+ * system clock variable. The SHIFT_UPDATE define establishes the decimal
+ * point of the time_offset variable which represents the current offset
+ * with respect to standard time. The FINENSEC define represents 1 nsec in
+ * scaled units.
+ *
+ * SHIFT_USEC defines the scaling (shift) of the time_freq and
+ * time_tolerance variables, which represent the current frequency
+ * offset and maximum frequency tolerance.
+ *
+ * FINENSEC is 1 ns in SHIFT_UPDATE units of the time_phase variable.
+ */
+#define SHIFT_SCALE 22          /* phase scale (shift) */
+#define SHIFT_UPDATE (SHIFT_KG + MAXTC) /* time offset scale (shift) */
+#define SHIFT_USEC 16           /* frequency offset scale (shift) */
+#define FINENSEC (1L << (SHIFT_SCALE - 10)) /* ~1 ns in phase units */
+
+#define MAXPHASE 512000L        /* max phase error (us) */
+#define MAXFREQ (512L << SHIFT_USEC)  /* max frequency error (ppm) */
+#define MAXTIME (200L << PPS_AVG) /* max PPS error (jitter) (200 us) */
+#define MINSEC 16L              /* min interval between updates (s) */
+#define MAXSEC 1200L            /* max interval between updates (s) */
+#define NTP_PHASE_LIMIT (MAXPHASE << 5) /* beyond max. dispersion */
+
+/*
+ * The following defines are used only if a pulse-per-second (PPS)
+ * signal is available and connected via a modem control lead, such as
+ * produced by the optional ppsclock feature incorporated in the Sun
+ * asynch driver. They establish the design parameters of the frequency-
+ * lock loop used to discipline the CPU clock oscillator to the PPS
+ * signal.
+ *
+ * PPS_AVG is the averaging factor for the frequency loop, as well as
+ * the time and frequency dispersion.
+ *
+ * PPS_SHIFT and PPS_SHIFTMAX specify the minimum and maximum
+ * calibration intervals, respectively, in seconds as a power of two.
+ *
+ * PPS_VALID is the maximum interval before the PPS signal is considered
+ * invalid and protocol updates used directly instead.
+ *
+ * MAXGLITCH is the maximum interval before a time offset of more than
+ * MAXTIME is believed.
+ */
+#define PPS_AVG 2               /* pps averaging constant (shift) */
+#define PPS_SHIFT 2             /* min interval duration (s) (shift) */
+#define PPS_SHIFTMAX 8          /* max interval duration (s) (shift) */
+#define PPS_VALID 120           /* pps signal watchdog max (s) */
+#define MAXGLITCH 30            /* pps signal glitch max (s) */
+
+/*
+ * syscall interface - used (mainly by NTP daemon)
+ * to discipline kernel clock oscillator
+ */
+struct timex {
+        unsigned int modes;     /* mode selector */
+        long offset;            /* time offset (usec) */
+        long freq;              /* frequency offset (scaled ppm) */
+        long maxerror;          /* maximum error (usec) */
+        long esterror;          /* estimated error (usec) */
+        int status;             /* clock command/status */
+        long constant;          /* pll time constant */
+        long precision;         /* clock precision (usec) (read only) */
+        long tolerance;         /* clock frequency tolerance (ppm)
+                                 * (read only)
+                                 */
+        struct timeval time;    /* (read only) */
+        long tick;              /* (modified) usecs between clock ticks */
+
+        long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
+        long jitter;            /* pps jitter (us) (ro) */
+        int shift;              /* interval duration (s) (shift) (ro) */
+        long stabil;            /* pps stability (scaled ppm) (ro) */
+        long jitcnt;            /* jitter limit exceeded (ro) */
+        long calcnt;            /* calibration intervals (ro) */
+        long errcnt;            /* calibration errors (ro) */
+        long stbcnt;            /* stability limit exceeded (ro) */
+
+        int  :32; int  :32; int  :32; int  :32;
+        int  :32; int  :32; int  :32; int  :32;
+        int  :32; int  :32; int  :32; int  :32;
+};
+
+/*
+ * Mode codes (timex.mode)
+ */
+#define ADJ_OFFSET              0x0001  /* time offset */
+#define ADJ_FREQUENCY           0x0002  /* frequency offset */
+#define ADJ_MAXERROR            0x0004  /* maximum time error */
+#define ADJ_ESTERROR            0x0008  /* estimated time error */
+#define ADJ_STATUS              0x0010  /* clock status */
+#define ADJ_TIMECONST           0x0020  /* pll time constant */
+#define ADJ_TICK                0x4000  /* tick value */
+#define ADJ_OFFSET_SINGLESHOT   0x8001  /* old-fashioned adjtime */
+
+/* xntp 3.4 compatibility names */
+#define MOD_OFFSET      ADJ_OFFSET
+#define MOD_FREQUENCY   ADJ_FREQUENCY
+#define MOD_MAXERROR    ADJ_MAXERROR
+#define MOD_ESTERROR    ADJ_ESTERROR
+#define MOD_STATUS      ADJ_STATUS
+#define MOD_TIMECONST   ADJ_TIMECONST
+#define MOD_CLKB        ADJ_TICK
+#define MOD_CLKA        ADJ_OFFSET_SINGLESHOT /* 0x8000 in original */
+
+
+/*
+ * Status codes (timex.status)
+ */
+#define STA_PLL         0x0001  /* enable PLL updates (rw) */
+#define STA_PPSFREQ     0x0002  /* enable PPS freq discipline (rw) */
+#define STA_PPSTIME     0x0004  /* enable PPS time discipline (rw) */
+#define STA_FLL         0x0008  /* select frequency-lock mode (rw) */
+
+#define STA_INS         0x0010  /* insert leap (rw) */
+#define STA_DEL         0x0020  /* delete leap (rw) */
+#define STA_UNSYNC      0x0040  /* clock unsynchronized (rw) */
+#define STA_FREQHOLD    0x0080  /* hold frequency (rw) */
+
+#define STA_PPSSIGNAL   0x0100  /* PPS signal present (ro) */
+#define STA_PPSJITTER   0x0200  /* PPS signal jitter exceeded (ro) */
+#define STA_PPSWANDER   0x0400  /* PPS signal wander exceeded (ro) */
+#define STA_PPSERROR    0x0800  /* PPS signal calibration error (ro) */
+
+#define STA_CLOCKERR    0x1000  /* clock hardware fault (ro) */
+
+#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \
+    STA_PPSERROR | STA_CLOCKERR) /* read-only bits */
+
+/*
+ * Clock states (time_state)
+ */
+#define TIME_OK         0       /* clock synchronized, no leap second */
+#define TIME_INS        1       /* insert leap second */
+#define TIME_DEL        2       /* delete leap second */
+#define TIME_OOP        3       /* leap second in progress */
+#define TIME_WAIT       4       /* leap second has occurred */
+#define TIME_ERROR      5       /* clock not synchronized */
+#define TIME_BAD        TIME_ERROR /* bw compat */
+
+#ifdef __KERNEL__
+/*
+ * kernel variables
+ * Note: maximum error = NTP synch distance = dispersion + delay / 2;
+ * estimated error = NTP dispersion.
+ */
+extern unsigned long tick_usec;         /* USER_HZ period (usec) */
+extern unsigned long tick_nsec;         /* ACTHZ          period (nsec) */
+extern int tickadj;                     /* amount of adjustment per tick */
+
+/*
+ * phase-lock loop variables
+ */
+extern int time_state;          /* clock status */
+extern int time_status;         /* clock synchronization status bits */
+extern long time_offset;        /* time adjustment (us) */
+extern long time_constant;      /* pll time constant */
+extern long time_tolerance;     /* frequency tolerance (ppm) */
+extern long time_precision;     /* clock precision (us) */
+extern long time_maxerror;      /* maximum error */
+extern long time_esterror;      /* estimated error */
+
+extern long time_freq;          /* frequency offset (scaled ppm) */
+extern long time_reftime;       /* time at last adjustment (s) */
+
+extern long time_adjust;        /* The amount of adjtime left */
+extern long time_next_adjust;   /* Value for time_adjust at next tick */
+
+/* interface variables pps->timer interrupt */
+extern long pps_offset;         /* pps time offset (us) */
+extern long pps_jitter;         /* time dispersion (jitter) (us) */
+extern long pps_freq;           /* frequency offset (scaled ppm) */
+extern long pps_stabil;         /* frequency dispersion (scaled ppm) */
+extern long pps_valid;          /* pps signal watchdog counter */
+
+/* interface variables pps->adjtimex */
+extern int pps_shift;           /* interval duration (s) (shift) */
+extern long pps_jitcnt;         /* jitter limit exceeded */
+extern long pps_calcnt;         /* calibration intervals */
+extern long pps_errcnt;         /* calibration errors */
+extern long pps_stbcnt;         /* stability limit exceeded */
+
+#ifdef CONFIG_TIME_INTERPOLATION
+
+#define TIME_SOURCE_CPU 0
+#define TIME_SOURCE_MMIO64 1
+#define TIME_SOURCE_MMIO32 2
+#define TIME_SOURCE_FUNCTION 3
+
+/* For proper operations time_interpolator clocks must run slightly slower
+ * than the standard clock since the interpolator may only correct by having
+ * time jump forward during a tick. A slower clock is usually a side effect
+ * of the integer divide of the nanoseconds in a second by the frequency.
+ * The accuracy of the division can be increased by specifying a shift.
+ * However, this may cause the clock not to be slow enough.
+ * The interpolator will self-tune the clock by slowing down if no
+ * resets occur or speeding up if the time jumps per analysis cycle
+ * become too high.
+ *
+ * Setting jitter compensates for a fluctuating timesource by comparing
+ * to the last value read from the timesource to insure that an earlier value
+ * is not returned by a later call. The price to pay
+ * for the compensation is that the timer routines are not as scalable anymore.
+ */
+
+struct time_interpolator {
+        u16 source;                     /* time source flags */
+        u8 shift;                       /* increases accuracy of multiply by shifting. */
+                                /* Note that bits may be lost if shift is set too high */
+        u8 jitter;                      /* if set compensate for fluctuations */
+        u32 nsec_per_cyc;               /* set by register_time_interpolator() */
+        void *addr;                     /* address of counter or function */
+        u64 mask;                       /* mask the valid bits of the counter */
+        unsigned long offset;           /* nsec offset at last update of interpolator */
+        u64 last_counter;               /* counter value in units of the counter at last update */
+        u64 last_cycle;                 /* Last timer value if TIME_SOURCE_JITTER is set */
+        u64 frequency;                  /* frequency in counts/second */
+        long drift;                     /* drift in parts-per-million (or -1) */
+        unsigned long skips;            /* skips forward */
+        unsigned long ns_skipped;       /* nanoseconds skipped */
+        struct time_interpolator *next;
+};
+
+extern void register_time_interpolator(struct time_interpolator *);
+extern void unregister_time_interpolator(struct time_interpolator *);
+extern void time_interpolator_reset(void);
+extern unsigned long time_interpolator_get_offset(void);
+
+#else /* !CONFIG_TIME_INTERPOLATION */
+
+static inline void
+time_interpolator_reset(void)
+{
+}
+
+#endif /* !CONFIG_TIME_INTERPOLATION */
+
+#endif /* KERNEL */
+
+#endif /* LINUX_TIMEX_H */
diff --git a/include/linux/tiocl.h b/include/linux/tiocl.h
new file mode 100644
index 000000000000..2c9e847f6ed1
--- /dev/null
+++ b/include/linux/tiocl.h
@@ -0,0 +1,38 @@
+#ifndef _LINUX_TIOCL_H
+#define _LINUX_TIOCL_H
+
+#define TIOCL_SETSEL    2       /* set a selection */
+#define         TIOCL_SELCHAR   0       /* select characters */
+#define         TIOCL_SELWORD   1       /* select whole words */
+#define         TIOCL_SELLINE   2       /* select whole lines */
+#define         TIOCL_SELPOINTER        3       /* show the pointer */
+#define         TIOCL_SELCLEAR  4       /* clear visibility of selection */
+#define         TIOCL_SELMOUSEREPORT    16      /* report beginning of selection */
+#define         TIOCL_SELBUTTONMASK     15      /* button mask for report */
+/* selection extent */
+struct tiocl_selection {
+        unsigned short xs;      /* X start */
+        unsigned short ys;      /* Y start */
+        unsigned short xe;      /* X end */
+        unsigned short ye;      /* Y end */
+        unsigned short sel_mode;        /* selection mode */
+};
+
+#define TIOCL_PASTESEL  3       /* paste previous selection */
+#define TIOCL_UNBLANKSCREEN     4       /* unblank screen */
+
+#define TIOCL_SELLOADLUT        5
+        /* set characters to be considered alphabetic when selecting */
+        /* u32[8] bit array, 4 bytes-aligned with type */
+
+/* these two don't return a value: they write it back in the type */
+#define TIOCL_GETSHIFTSTATE     6       /* write shift state */
+#define TIOCL_GETMOUSEREPORTING 7       /* write whether mouse event are reported */
+#define TIOCL_SETVESABLANK      10      /* set vesa blanking mode */
+#define TIOCL_SETKMSGREDIRECT   11      /* restrict kernel messages to a vt */
+#define TIOCL_GETFGCONSOLE      12      /* get foreground vt */
+#define TIOCL_SCROLLCONSOLE     13      /* scroll console */
+#define TIOCL_BLANKSCREEN       14      /* keep screen blank even if a key is pressed */
+#define TIOCL_BLANKEDSCREEN     15      /* return which vt was blanked */
+
+#endif /* _LINUX_TIOCL_H */
diff --git a/include/linux/topology.h b/include/linux/topology.h
new file mode 100644
index 000000000000..d70e8972c67f
--- /dev/null
+++ b/include/linux/topology.h
@@ -0,0 +1,136 @@
+/*
+ * include/linux/topology.h
+ *
+ * Written by: Matthew Dobson, IBM Corporation
+ *
+ * Copyright (C) 2002, IBM Corp.
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Send feedback to <colpatch@us.ibm.com>
+ */
+#ifndef _LINUX_TOPOLOGY_H
+#define _LINUX_TOPOLOGY_H
+
+#include <linux/cpumask.h>
+#include <linux/bitops.h>
+#include <linux/mmzone.h>
+#include <linux/smp.h>
+#include <asm/topology.h>
+
+#ifndef node_has_online_mem
+#define node_has_online_mem(nid) (1)
+#endif
+
+#ifndef nr_cpus_node
+#define nr_cpus_node(node)                                                      \
+        ({                                                                      \
+                cpumask_t __tmp__;                                              \
+                __tmp__ = node_to_cpumask(node);                                \
+                cpus_weight(__tmp__);                                           \
+        })
+#endif
+
+#define for_each_node_with_cpus(node)                                           \
+        for_each_online_node(node)                                              \
+                if (nr_cpus_node(node))
+
+#ifndef node_distance
+/* Conform to ACPI 2.0 SLIT distance definitions */
+#define LOCAL_DISTANCE          10
+#define REMOTE_DISTANCE         20
+#define node_distance(from,to)  ((from) == (to) ? LOCAL_DISTANCE : REMOTE_DISTANCE)
+#endif
+#ifndef PENALTY_FOR_NODE_WITH_CPUS
+#define PENALTY_FOR_NODE_WITH_CPUS      (1)
+#endif
+
+/*
+ * Below are the 3 major initializers used in building sched_domains:
+ * SD_SIBLING_INIT, for SMT domains
+ * SD_CPU_INIT, for SMP domains
+ * SD_NODE_INIT, for NUMA domains
+ *
+ * Any architecture that cares to do any tuning to these values should do so
+ * by defining their own arch-specific initializer in include/asm/topology.h.
+ * A definition there will automagically override these default initializers
+ * and allow arch-specific performance tuning of sched_domains.
+ */
+#ifdef CONFIG_SCHED_SMT
+/* MCD - Do we really need this?  It is always on if CONFIG_SCHED_SMT is,
+ * so can't we drop this in favor of CONFIG_SCHED_SMT?
+ */
+#define ARCH_HAS_SCHED_WAKE_IDLE
+/* Common values for SMT siblings */
+#ifndef SD_SIBLING_INIT
+#define SD_SIBLING_INIT (struct sched_domain) {         \
+        .span                   = CPU_MASK_NONE,        \
+        .parent                 = NULL,                 \
+        .groups                 = NULL,                 \
+        .min_interval           = 1,                    \
+        .max_interval           = 2,                    \
+        .busy_factor            = 8,                    \
+        .imbalance_pct          = 110,                  \
+        .cache_hot_time         = 0,                    \
+        .cache_nice_tries       = 0,                    \
+        .per_cpu_gain           = 25,                   \
+        .flags                  = SD_LOAD_BALANCE       \
+                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_EXEC       \
+                                | SD_WAKE_AFFINE        \
+                                | SD_WAKE_IDLE          \
+                                | SD_SHARE_CPUPOWER,    \
+        .last_balance           = jiffies,              \
+        .balance_interval       = 1,                    \
+        .nr_balance_failed      = 0,                    \
+}
+#endif
+#endif /* CONFIG_SCHED_SMT */
+
+/* Common values for CPUs */
+#ifndef SD_CPU_INIT
+#define SD_CPU_INIT (struct sched_domain) {             \
+        .span                   = CPU_MASK_NONE,        \
+        .parent                 = NULL,                 \
+        .groups                 = NULL,                 \
+        .min_interval           = 1,                    \
+        .max_interval           = 4,                    \
+        .busy_factor            = 64,                   \
+        .imbalance_pct          = 125,                  \
+        .cache_hot_time         = (5*1000000/2),        \
+        .cache_nice_tries       = 1,                    \
+        .per_cpu_gain           = 100,                  \
+        .flags                  = SD_LOAD_BALANCE       \
+                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_EXEC       \
+                                | SD_WAKE_AFFINE        \
+                                | SD_WAKE_IDLE          \
+                                | SD_WAKE_BALANCE,      \
+        .last_balance           = jiffies,              \
+        .balance_interval       = 1,                    \
+        .nr_balance_failed      = 0,                    \
+}
+#endif
+
+#ifdef CONFIG_NUMA
+#ifndef SD_NODE_INIT
+#error Please define an appropriate SD_NODE_INIT in include/asm/topology.h!!!
+#endif
+#endif /* CONFIG_NUMA */
+
+#endif /* _LINUX_TOPOLOGY_H */
diff --git a/include/linux/toshiba.h b/include/linux/toshiba.h
new file mode 100644
index 000000000000..916e5e3a699b
--- /dev/null
+++ b/include/linux/toshiba.h
@@ -0,0 +1,36 @@
+/* toshiba.h -- Linux driver for accessing the SMM on Toshiba laptops 
+ *
+ * Copyright (c) 1996-2000  Jonathan A. Buzzard (jonathan@buzzard.org.uk)
+ *
+ * Thanks to Juergen Heinzl <juergen@monocerus.demon.co.uk> for the pointers
+ * on making sure the structure is aligned and packed.
+ *
+ * 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; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_TOSHIBA_H
+#define _LINUX_TOSHIBA_H
+
+#define TOSH_PROC "/proc/toshiba"
+#define TOSH_DEVICE "/dev/toshiba"
+#define TOSH_SMM _IOWR('t', 0x90, int)  /* broken: meant 24 bytes */
+
+typedef struct {
+        unsigned int eax;
+        unsigned int ebx __attribute__ ((packed));
+        unsigned int ecx __attribute__ ((packed));
+        unsigned int edx __attribute__ ((packed));
+        unsigned int esi __attribute__ ((packed));
+        unsigned int edi __attribute__ ((packed));
+} SMMRegisters;
+
+#endif
diff --git a/include/linux/transport_class.h b/include/linux/transport_class.h
new file mode 100644
index 000000000000..87d98d1faefb
--- /dev/null
+++ b/include/linux/transport_class.h
@@ -0,0 +1,95 @@
+/*
+ * transport_class.h - a generic container for all transport classes
+ *
+ * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
+ *
+ * This file is licensed under GPLv2
+ */
+
+#ifndef _TRANSPORT_CLASS_H_
+#define _TRANSPORT_CLASS_H_
+
+#include <linux/device.h>
+#include <linux/attribute_container.h>
+
+struct transport_class {
+        struct class class;
+        int (*setup)(struct device *);
+        int (*configure)(struct device *);
+        int (*remove)(struct device *);
+};
+
+#define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg)                   \
+struct transport_class cls = {                                          \
+        .class = {                                                      \
+                .name = nm,                                             \
+        },                                                              \
+        .setup = su,                                                    \
+        .remove = rm,                                                   \
+        .configure = cfg,                                               \
+}
+
+
+struct anon_transport_class {
+        struct transport_class tclass;
+        struct attribute_container container;
+};
+
+#define DECLARE_ANON_TRANSPORT_CLASS(cls, mtch, cfg)            \
+struct anon_transport_class cls = {                             \
+        .tclass = {                                             \
+                .configure = cfg,                               \
+        },                                                      \
+        . container = {                                         \
+                .match = mtch,                                  \
+        },                                                      \
+}
+
+#define class_to_transport_class(x) \
+        container_of(x, struct transport_class, class)
+
+struct transport_container {
+        struct attribute_container ac;
+        struct attribute_group *statistics;
+};
+
+#define attribute_container_to_transport_container(x) \
+        container_of(x, struct transport_container, ac)
+
+void transport_remove_device(struct device *);
+void transport_add_device(struct device *);
+void transport_setup_device(struct device *);
+void transport_configure_device(struct device *);
+void transport_destroy_device(struct device *);
+
+static inline void
+transport_register_device(struct device *dev)
+{
+        transport_setup_device(dev);
+        transport_add_device(dev);
+}
+
+static inline void
+transport_unregister_device(struct device *dev)
+{
+        transport_remove_device(dev);
+        transport_destroy_device(dev);
+}
+
+static inline int transport_container_register(struct transport_container *tc)
+{
+        return attribute_container_register(&tc->ac);
+}
+
+static inline int transport_container_unregister(struct transport_container *tc)
+{
+        return attribute_container_unregister(&tc->ac);
+}
+
+int transport_class_register(struct transport_class *);
+int anon_transport_class_register(struct anon_transport_class *);
+void transport_class_unregister(struct transport_class *);
+void anon_transport_class_unregister(struct anon_transport_class *);
+
+
+#endif
diff --git a/include/linux/trdevice.h b/include/linux/trdevice.h
new file mode 100644
index 000000000000..aaa1f337edcb
--- /dev/null
+++ b/include/linux/trdevice.h
@@ -0,0 +1,37 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  NET  is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the Token-ring handlers.
+ *
+ * Version:     @(#)eth.h       1.0.4   05/13/93
+ *
+ * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
+ *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              Relocated to include/linux where it belongs by Alan Cox 
+ *                                                      <gw4pts@gw4pts.ampr.org>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ *      WARNING: This move may well be temporary. This file will get merged with others RSN.
+ *
+ */
+#ifndef _LINUX_TRDEVICE_H
+#define _LINUX_TRDEVICE_H
+
+
+#include <linux/if_tr.h>
+
+#ifdef __KERNEL__
+extern unsigned short   tr_type_trans(struct sk_buff *skb, struct net_device *dev);
+extern void tr_source_route(struct sk_buff *skb, struct trh_hdr *trh, struct net_device *dev);
+extern struct net_device *alloc_trdev(int sizeof_priv);
+
+#endif
+
+#endif  /* _LINUX_TRDEVICE_H */
diff --git a/include/linux/tty.h b/include/linux/tty.h
new file mode 100644
index 000000000000..1b76106272d3
--- /dev/null
+++ b/include/linux/tty.h
@@ -0,0 +1,412 @@
+#ifndef _LINUX_TTY_H
+#define _LINUX_TTY_H
+
+/*
+ * 'tty.h' defines some structures used by tty_io.c and some defines.
+ */
+
+/*
+ * These constants are also useful for user-level apps (e.g., VC
+ * resizing).
+ */
+#define MIN_NR_CONSOLES 1       /* must be at least 1 */
+#define MAX_NR_CONSOLES 63      /* serial lines start at 64 */
+#define MAX_NR_USER_CONSOLES 63 /* must be root to allocate above this */
+                /* Note: the ioctl VT_GETSTATE does not work for
+                   consoles 16 and higher (since it returns a short) */
+
+#ifdef __KERNEL__
+#include <linux/config.h>
+#include <linux/fs.h>
+#include <linux/major.h>
+#include <linux/termios.h>
+#include <linux/workqueue.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_ldisc.h>
+
+#include <asm/system.h>
+
+
+/*
+ * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
+ * hardcoded at present.)
+ */
+#define NR_PTYS CONFIG_LEGACY_PTY_COUNT   /* Number of legacy ptys */
+#define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
+#define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
+#define NR_LDISCS               16
+
+/*
+ * These are set up by the setup-routine at boot-time:
+ */
+
+struct screen_info {
+        u8  orig_x;             /* 0x00 */
+        u8  orig_y;             /* 0x01 */
+        u16 dontuse1;           /* 0x02 -- EXT_MEM_K sits here */
+        u16 orig_video_page;    /* 0x04 */
+        u8  orig_video_mode;    /* 0x06 */
+        u8  orig_video_cols;    /* 0x07 */
+        u16 unused2;            /* 0x08 */
+        u16 orig_video_ega_bx;  /* 0x0a */
+        u16 unused3;            /* 0x0c */
+        u8  orig_video_lines;   /* 0x0e */
+        u8  orig_video_isVGA;   /* 0x0f */
+        u16 orig_video_points;  /* 0x10 */
+
+        /* VESA graphic mode -- linear frame buffer */
+        u16 lfb_width;          /* 0x12 */
+        u16 lfb_height;         /* 0x14 */
+        u16 lfb_depth;          /* 0x16 */
+        u32 lfb_base;           /* 0x18 */
+        u32 lfb_size;           /* 0x1c */
+        u16 dontuse2, dontuse3; /* 0x20 -- CL_MAGIC and CL_OFFSET here */
+        u16 lfb_linelength;     /* 0x24 */
+        u8  red_size;           /* 0x26 */
+        u8  red_pos;            /* 0x27 */
+        u8  green_size;         /* 0x28 */
+        u8  green_pos;          /* 0x29 */
+        u8  blue_size;          /* 0x2a */
+        u8  blue_pos;           /* 0x2b */
+        u8  rsvd_size;          /* 0x2c */
+        u8  rsvd_pos;           /* 0x2d */
+        u16 vesapm_seg;         /* 0x2e */
+        u16 vesapm_off;         /* 0x30 */
+        u16 pages;              /* 0x32 */
+        u16 vesa_attributes;    /* 0x34 */
+                                /* 0x36 -- 0x3f reserved for future expansion */
+};
+
+extern struct screen_info screen_info;
+
+#define ORIG_X                  (screen_info.orig_x)
+#define ORIG_Y                  (screen_info.orig_y)
+#define ORIG_VIDEO_MODE         (screen_info.orig_video_mode)
+#define ORIG_VIDEO_COLS         (screen_info.orig_video_cols)
+#define ORIG_VIDEO_EGA_BX       (screen_info.orig_video_ega_bx)
+#define ORIG_VIDEO_LINES        (screen_info.orig_video_lines)
+#define ORIG_VIDEO_ISVGA        (screen_info.orig_video_isVGA)
+#define ORIG_VIDEO_POINTS       (screen_info.orig_video_points)
+
+#define VIDEO_TYPE_MDA          0x10    /* Monochrome Text Display      */
+#define VIDEO_TYPE_CGA          0x11    /* CGA Display                  */
+#define VIDEO_TYPE_EGAM         0x20    /* EGA/VGA in Monochrome Mode   */
+#define VIDEO_TYPE_EGAC         0x21    /* EGA in Color Mode            */
+#define VIDEO_TYPE_VGAC         0x22    /* VGA+ in Color Mode           */
+#define VIDEO_TYPE_VLFB         0x23    /* VESA VGA in graphic mode     */
+
+#define VIDEO_TYPE_PICA_S3      0x30    /* ACER PICA-61 local S3 video  */
+#define VIDEO_TYPE_MIPS_G364    0x31    /* MIPS Magnum 4000 G364 video  */
+#define VIDEO_TYPE_SGI          0x33    /* Various SGI graphics hardware */
+
+#define VIDEO_TYPE_TGAC         0x40    /* DEC TGA */
+
+#define VIDEO_TYPE_SUN          0x50    /* Sun frame buffer. */
+#define VIDEO_TYPE_SUNPCI       0x51    /* Sun PCI based frame buffer. */
+
+#define VIDEO_TYPE_PMAC         0x60    /* PowerMacintosh frame buffer. */
+
+/*
+ * This character is the same as _POSIX_VDISABLE: it cannot be used as
+ * a c_cc[] character, but indicates that a particular special character
+ * isn't in use (eg VINTR has no character etc)
+ */
+#define __DISABLED_CHAR '\0'
+
+/*
+ * This is the flip buffer used for the tty driver.  The buffer is
+ * located in the tty structure, and is used as a high speed interface
+ * between the tty driver and the tty line discipline.
+ */
+#define TTY_FLIPBUF_SIZE 512
+
+struct tty_flip_buffer {
+        struct work_struct              work;
+        struct semaphore pty_sem;
+        char            *char_buf_ptr;
+        unsigned char   *flag_buf_ptr;
+        int             count;
+        int             buf_num;
+        unsigned char   char_buf[2*TTY_FLIPBUF_SIZE];
+        char            flag_buf[2*TTY_FLIPBUF_SIZE];
+        unsigned char   slop[4]; /* N.B. bug overwrites buffer by 1 */
+};
+/*
+ * The pty uses char_buf and flag_buf as a contiguous buffer
+ */
+#define PTY_BUF_SIZE    4*TTY_FLIPBUF_SIZE
+
+/*
+ * When a break, frame error, or parity error happens, these codes are
+ * stuffed into the flags buffer.
+ */
+#define TTY_NORMAL      0
+#define TTY_BREAK       1
+#define TTY_FRAME       2
+#define TTY_PARITY      3
+#define TTY_OVERRUN     4
+
+#define INTR_CHAR(tty) ((tty)->termios->c_cc[VINTR])
+#define QUIT_CHAR(tty) ((tty)->termios->c_cc[VQUIT])
+#define ERASE_CHAR(tty) ((tty)->termios->c_cc[VERASE])
+#define KILL_CHAR(tty) ((tty)->termios->c_cc[VKILL])
+#define EOF_CHAR(tty) ((tty)->termios->c_cc[VEOF])
+#define TIME_CHAR(tty) ((tty)->termios->c_cc[VTIME])
+#define MIN_CHAR(tty) ((tty)->termios->c_cc[VMIN])
+#define SWTC_CHAR(tty) ((tty)->termios->c_cc[VSWTC])
+#define START_CHAR(tty) ((tty)->termios->c_cc[VSTART])
+#define STOP_CHAR(tty) ((tty)->termios->c_cc[VSTOP])
+#define SUSP_CHAR(tty) ((tty)->termios->c_cc[VSUSP])
+#define EOL_CHAR(tty) ((tty)->termios->c_cc[VEOL])
+#define REPRINT_CHAR(tty) ((tty)->termios->c_cc[VREPRINT])
+#define DISCARD_CHAR(tty) ((tty)->termios->c_cc[VDISCARD])
+#define WERASE_CHAR(tty) ((tty)->termios->c_cc[VWERASE])
+#define LNEXT_CHAR(tty) ((tty)->termios->c_cc[VLNEXT])
+#define EOL2_CHAR(tty) ((tty)->termios->c_cc[VEOL2])
+
+#define _I_FLAG(tty,f)  ((tty)->termios->c_iflag & (f))
+#define _O_FLAG(tty,f)  ((tty)->termios->c_oflag & (f))
+#define _C_FLAG(tty,f)  ((tty)->termios->c_cflag & (f))
+#define _L_FLAG(tty,f)  ((tty)->termios->c_lflag & (f))
+
+#define I_IGNBRK(tty)   _I_FLAG((tty),IGNBRK)
+#define I_BRKINT(tty)   _I_FLAG((tty),BRKINT)
+#define I_IGNPAR(tty)   _I_FLAG((tty),IGNPAR)
+#define I_PARMRK(tty)   _I_FLAG((tty),PARMRK)
+#define I_INPCK(tty)    _I_FLAG((tty),INPCK)
+#define I_ISTRIP(tty)   _I_FLAG((tty),ISTRIP)
+#define I_INLCR(tty)    _I_FLAG((tty),INLCR)
+#define I_IGNCR(tty)    _I_FLAG((tty),IGNCR)
+#define I_ICRNL(tty)    _I_FLAG((tty),ICRNL)
+#define I_IUCLC(tty)    _I_FLAG((tty),IUCLC)
+#define I_IXON(tty)     _I_FLAG((tty),IXON)
+#define I_IXANY(tty)    _I_FLAG((tty),IXANY)
+#define I_IXOFF(tty)    _I_FLAG((tty),IXOFF)
+#define I_IMAXBEL(tty)  _I_FLAG((tty),IMAXBEL)
+#define I_IUTF8(tty)    _I_FLAG((tty),IUTF8)
+
+#define O_OPOST(tty)    _O_FLAG((tty),OPOST)
+#define O_OLCUC(tty)    _O_FLAG((tty),OLCUC)
+#define O_ONLCR(tty)    _O_FLAG((tty),ONLCR)
+#define O_OCRNL(tty)    _O_FLAG((tty),OCRNL)
+#define O_ONOCR(tty)    _O_FLAG((tty),ONOCR)
+#define O_ONLRET(tty)   _O_FLAG((tty),ONLRET)
+#define O_OFILL(tty)    _O_FLAG((tty),OFILL)
+#define O_OFDEL(tty)    _O_FLAG((tty),OFDEL)
+#define O_NLDLY(tty)    _O_FLAG((tty),NLDLY)
+#define O_CRDLY(tty)    _O_FLAG((tty),CRDLY)
+#define O_TABDLY(tty)   _O_FLAG((tty),TABDLY)
+#define O_BSDLY(tty)    _O_FLAG((tty),BSDLY)
+#define O_VTDLY(tty)    _O_FLAG((tty),VTDLY)
+#define O_FFDLY(tty)    _O_FLAG((tty),FFDLY)
+
+#define C_BAUD(tty)     _C_FLAG((tty),CBAUD)
+#define C_CSIZE(tty)    _C_FLAG((tty),CSIZE)
+#define C_CSTOPB(tty)   _C_FLAG((tty),CSTOPB)
+#define C_CREAD(tty)    _C_FLAG((tty),CREAD)
+#define C_PARENB(tty)   _C_FLAG((tty),PARENB)
+#define C_PARODD(tty)   _C_FLAG((tty),PARODD)
+#define C_HUPCL(tty)    _C_FLAG((tty),HUPCL)
+#define C_CLOCAL(tty)   _C_FLAG((tty),CLOCAL)
+#define C_CIBAUD(tty)   _C_FLAG((tty),CIBAUD)
+#define C_CRTSCTS(tty)  _C_FLAG((tty),CRTSCTS)
+
+#define L_ISIG(tty)     _L_FLAG((tty),ISIG)
+#define L_ICANON(tty)   _L_FLAG((tty),ICANON)
+#define L_XCASE(tty)    _L_FLAG((tty),XCASE)
+#define L_ECHO(tty)     _L_FLAG((tty),ECHO)
+#define L_ECHOE(tty)    _L_FLAG((tty),ECHOE)
+#define L_ECHOK(tty)    _L_FLAG((tty),ECHOK)
+#define L_ECHONL(tty)   _L_FLAG((tty),ECHONL)
+#define L_NOFLSH(tty)   _L_FLAG((tty),NOFLSH)
+#define L_TOSTOP(tty)   _L_FLAG((tty),TOSTOP)
+#define L_ECHOCTL(tty)  _L_FLAG((tty),ECHOCTL)
+#define L_ECHOPRT(tty)  _L_FLAG((tty),ECHOPRT)
+#define L_ECHOKE(tty)   _L_FLAG((tty),ECHOKE)
+#define L_FLUSHO(tty)   _L_FLAG((tty),FLUSHO)
+#define L_PENDIN(tty)   _L_FLAG((tty),PENDIN)
+#define L_IEXTEN(tty)   _L_FLAG((tty),IEXTEN)
+
+struct device;
+/*
+ * Where all of the state associated with a tty is kept while the tty
+ * is open.  Since the termios state should be kept even if the tty
+ * has been closed --- for things like the baud rate, etc --- it is
+ * not stored here, but rather a pointer to the real state is stored
+ * here.  Possible the winsize structure should have the same
+ * treatment, but (1) the default 80x24 is usually right and (2) it's
+ * most often used by a windowing system, which will set the correct
+ * size each time the window is created or resized anyway.
+ *                                              - TYT, 9/14/92
+ */
+struct tty_struct {
+        int     magic;
+        struct tty_driver *driver;
+        int index;
+        struct tty_ldisc ldisc;
+        struct semaphore termios_sem;
+        struct termios *termios, *termios_locked;
+        char name[64];
+        int pgrp;
+        int session;
+        unsigned long flags;
+        int count;
+        struct winsize winsize;
+        unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;
+        unsigned char low_latency:1, warned:1;
+        unsigned char ctrl_status;
+
+        struct tty_struct *link;
+        struct fasync_struct *fasync;
+        struct tty_flip_buffer flip;
+        int max_flip_cnt;
+        int alt_speed;          /* For magic substitution of 38400 bps */
+        wait_queue_head_t write_wait;
+        wait_queue_head_t read_wait;
+        struct work_struct hangup_work;
+        void *disc_data;
+        void *driver_data;
+        struct list_head tty_files;
+
+#define N_TTY_BUF_SIZE 4096
+        
+        /*
+         * The following is data for the N_TTY line discipline.  For
+         * historical reasons, this is included in the tty structure.
+         */
+        unsigned int column;
+        unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
+        unsigned char closing:1;
+        unsigned short minimum_to_wake;
+        unsigned long overrun_time;
+        int num_overrun;
+        unsigned long process_char_map[256/(8*sizeof(unsigned long))];
+        char *read_buf;
+        int read_head;
+        int read_tail;
+        int read_cnt;
+        unsigned long read_flags[N_TTY_BUF_SIZE/(8*sizeof(unsigned long))];
+        int canon_data;
+        unsigned long canon_head;
+        unsigned int canon_column;
+        struct semaphore atomic_read;
+        struct semaphore atomic_write;
+        unsigned char *write_buf;
+        int write_cnt;
+        spinlock_t read_lock;
+        /* If the tty has a pending do_SAK, queue it here - akpm */
+        struct work_struct SAK_work;
+};
+
+/* tty magic number */
+#define TTY_MAGIC               0x5401
+
+/*
+ * These bits are used in the flags field of the tty structure.
+ * 
+ * So that interrupts won't be able to mess up the queues,
+ * copy_to_cooked must be atomic with respect to itself, as must
+ * tty->write.  Thus, you must use the inline functions set_bit() and
+ * clear_bit() to make things atomic.
+ */
+#define TTY_THROTTLED           0       /* Call unthrottle() at threshold min */
+#define TTY_IO_ERROR            1       /* Canse an I/O error (may be no ldisc too) */
+#define TTY_OTHER_CLOSED        2       /* Other side (if any) has closed */
+#define TTY_EXCLUSIVE           3       /* Exclusive open mode */
+#define TTY_DEBUG               4       /* Debugging */
+#define TTY_DO_WRITE_WAKEUP     5       /* Call write_wakeup after queuing new */
+#define TTY_PUSH                6       /* n_tty private */
+#define TTY_CLOSING             7       /* ->close() in progress */
+#define TTY_DONT_FLIP           8       /* Defer buffer flip */
+#define TTY_LDISC               9       /* Line discipline attached */
+#define TTY_HW_COOK_OUT         14      /* Hardware can do output cooking */
+#define TTY_HW_COOK_IN          15      /* Hardware can do input cooking */
+#define TTY_PTY_LOCK            16      /* pty private */
+#define TTY_NO_WRITE_SPLIT      17      /* Preserve write boundaries to driver */
+#define TTY_HUPPED              18      /* Post driver->hangup() */
+
+#define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
+
+extern void tty_write_flush(struct tty_struct *);
+
+extern struct termios tty_std_termios;
+extern int fg_console, last_console, want_console;
+
+extern int kmsg_redirect;
+
+extern void console_init(void);
+extern int vcs_init(void);
+
+extern int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
+                              const char *routine);
+extern char *tty_name(struct tty_struct *tty, char *buf);
+extern void tty_wait_until_sent(struct tty_struct * tty, long timeout);
+extern int tty_check_change(struct tty_struct * tty);
+extern void stop_tty(struct tty_struct * tty);
+extern void start_tty(struct tty_struct * tty);
+extern int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc);
+extern int tty_register_driver(struct tty_driver *driver);
+extern int tty_unregister_driver(struct tty_driver *driver);
+extern void tty_register_device(struct tty_driver *driver, unsigned index, struct device *dev);
+extern void tty_unregister_device(struct tty_driver *driver, unsigned index);
+extern int tty_read_raw_data(struct tty_struct *tty, unsigned char *bufp,
+                             int buflen);
+extern void tty_write_message(struct tty_struct *tty, char *msg);
+
+extern int is_orphaned_pgrp(int pgrp);
+extern int is_ignored(int sig);
+extern int tty_signal(int sig, struct tty_struct *tty);
+extern void tty_hangup(struct tty_struct * tty);
+extern void tty_vhangup(struct tty_struct * tty);
+extern void tty_unhangup(struct file *filp);
+extern int tty_hung_up_p(struct file * filp);
+extern void do_SAK(struct tty_struct *tty);
+extern void disassociate_ctty(int priv);
+extern void tty_flip_buffer_push(struct tty_struct *tty);
+extern int tty_get_baud_rate(struct tty_struct *tty);
+extern int tty_termios_baud_rate(struct termios *termios);
+
+extern struct tty_ldisc *tty_ldisc_ref(struct tty_struct *);
+extern void tty_ldisc_deref(struct tty_ldisc *);
+extern struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *);
+
+extern struct tty_ldisc *tty_ldisc_get(int);
+extern void tty_ldisc_put(int);
+
+extern void tty_wakeup(struct tty_struct *tty);
+extern void tty_ldisc_flush(struct tty_struct *tty);
+
+struct semaphore;
+extern struct semaphore tty_sem;
+
+/* n_tty.c */
+extern struct tty_ldisc tty_ldisc_N_TTY;
+
+/* tty_ioctl.c */
+extern int n_tty_ioctl(struct tty_struct * tty, struct file * file,
+                       unsigned int cmd, unsigned long arg);
+
+/* serial.c */
+
+extern void serial_console_init(void);
+ 
+/* pcxx.c */
+
+extern int pcxe_open(struct tty_struct *tty, struct file *filp);
+
+/* printk.c */
+
+extern void console_print(const char *);
+
+/* vt.c */
+
+extern int vt_ioctl(struct tty_struct *tty, struct file * file,
+                    unsigned int cmd, unsigned long arg);
+
+static inline dev_t tty_devnum(struct tty_struct *tty)
+{
+        return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
+}
+
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
new file mode 100644
index 000000000000..b368b296d035
--- /dev/null
+++ b/include/linux/tty_driver.h
@@ -0,0 +1,279 @@
+#ifndef _LINUX_TTY_DRIVER_H
+#define _LINUX_TTY_DRIVER_H
+
+/*
+ * This structure defines the interface between the low-level tty
+ * driver and the tty routines.  The following routines can be
+ * defined; unless noted otherwise, they are optional, and can be
+ * filled in with a null pointer.
+ *
+ * int  (*open)(struct tty_struct * tty, struct file * filp);
+ *
+ *      This routine is called when a particular tty device is opened.
+ *      This routine is mandatory; if this routine is not filled in,
+ *      the attempted open will fail with ENODEV.
+ *     
+ * void (*close)(struct tty_struct * tty, struct file * filp);
+ *
+ *      This routine is called when a particular tty device is closed.
+ *
+ * int (*write)(struct tty_struct * tty,
+ *               const unsigned char *buf, int count);
+ *
+ *      This routine is called by the kernel to write a series of
+ *      characters to the tty device.  The characters may come from
+ *      user space or kernel space.  This routine will return the
+ *      number of characters actually accepted for writing.  This
+ *      routine is mandatory.
+ *
+ * void (*put_char)(struct tty_struct *tty, unsigned char ch);
+ *
+ *      This routine is called by the kernel to write a single
+ *      character to the tty device.  If the kernel uses this routine,
+ *      it must call the flush_chars() routine (if defined) when it is
+ *      done stuffing characters into the driver.  If there is no room
+ *      in the queue, the character is ignored.
+ *
+ * void (*flush_chars)(struct tty_struct *tty);
+ *
+ *      This routine is called by the kernel after it has written a
+ *      series of characters to the tty device using put_char().  
+ * 
+ * int  (*write_room)(struct tty_struct *tty);
+ *
+ *      This routine returns the numbers of characters the tty driver
+ *      will accept for queuing to be written.  This number is subject
+ *      to change as output buffers get emptied, or if the output flow
+ *      control is acted.
+ * 
+ * int  (*ioctl)(struct tty_struct *tty, struct file * file,
+ *          unsigned int cmd, unsigned long arg);
+ *
+ *      This routine allows the tty driver to implement
+ *      device-specific ioctl's.  If the ioctl number passed in cmd
+ *      is not recognized by the driver, it should return ENOIOCTLCMD.
+ * 
+ * void (*set_termios)(struct tty_struct *tty, struct termios * old);
+ *
+ *      This routine allows the tty driver to be notified when
+ *      device's termios settings have changed.  Note that a
+ *      well-designed tty driver should be prepared to accept the case
+ *      where old == NULL, and try to do something rational.
+ *
+ * void (*set_ldisc)(struct tty_struct *tty);
+ *
+ *      This routine allows the tty driver to be notified when the
+ *      device's termios settings have changed.
+ * 
+ * void (*throttle)(struct tty_struct * tty);
+ *
+ *      This routine notifies the tty driver that input buffers for
+ *      the line discipline are close to full, and it should somehow
+ *      signal that no more characters should be sent to the tty.
+ * 
+ * void (*unthrottle)(struct tty_struct * tty);
+ *
+ *      This routine notifies the tty drivers that it should signals
+ *      that characters can now be sent to the tty without fear of
+ *      overrunning the input buffers of the line disciplines.
+ * 
+ * void (*stop)(struct tty_struct *tty);
+ *
+ *      This routine notifies the tty driver that it should stop
+ *      outputting characters to the tty device.  
+ * 
+ * void (*start)(struct tty_struct *tty);
+ *
+ *      This routine notifies the tty driver that it resume sending
+ *      characters to the tty device.
+ * 
+ * void (*hangup)(struct tty_struct *tty);
+ *
+ *      This routine notifies the tty driver that it should hangup the
+ *      tty device.
+ *
+ * void (*break_ctl)(struct tty_stuct *tty, int state);
+ *
+ *      This optional routine requests the tty driver to turn on or
+ *      off BREAK status on the RS-232 port.  If state is -1,
+ *      then the BREAK status should be turned on; if state is 0, then
+ *      BREAK should be turned off.
+ *
+ *      If this routine is implemented, the high-level tty driver will
+ *      handle the following ioctls: TCSBRK, TCSBRKP, TIOCSBRK,
+ *      TIOCCBRK.  Otherwise, these ioctls will be passed down to the
+ *      driver to handle.
+ *
+ * void (*wait_until_sent)(struct tty_struct *tty, int timeout);
+ * 
+ *      This routine waits until the device has written out all of the
+ *      characters in its transmitter FIFO.
+ *
+ * void (*send_xchar)(struct tty_struct *tty, char ch);
+ *
+ *      This routine is used to send a high-priority XON/XOFF
+ *      character to the device.
+ */
+
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/cdev.h>
+
+struct tty_struct;
+
+struct tty_operations {
+        int  (*open)(struct tty_struct * tty, struct file * filp);
+        void (*close)(struct tty_struct * tty, struct file * filp);
+        int  (*write)(struct tty_struct * tty,
+                      const unsigned char *buf, int count);
+        void (*put_char)(struct tty_struct *tty, unsigned char ch);
+        void (*flush_chars)(struct tty_struct *tty);
+        int  (*write_room)(struct tty_struct *tty);
+        int  (*chars_in_buffer)(struct tty_struct *tty);
+        int  (*ioctl)(struct tty_struct *tty, struct file * file,
+                    unsigned int cmd, unsigned long arg);
+        void (*set_termios)(struct tty_struct *tty, struct termios * old);
+        void (*throttle)(struct tty_struct * tty);
+        void (*unthrottle)(struct tty_struct * tty);
+        void (*stop)(struct tty_struct *tty);
+        void (*start)(struct tty_struct *tty);
+        void (*hangup)(struct tty_struct *tty);
+        void (*break_ctl)(struct tty_struct *tty, int state);
+        void (*flush_buffer)(struct tty_struct *tty);
+        void (*set_ldisc)(struct tty_struct *tty);
+        void (*wait_until_sent)(struct tty_struct *tty, int timeout);
+        void (*send_xchar)(struct tty_struct *tty, char ch);
+        int (*read_proc)(char *page, char **start, off_t off,
+                          int count, int *eof, void *data);
+        int (*write_proc)(struct file *file, const char __user *buffer,
+                          unsigned long count, void *data);
+        int (*tiocmget)(struct tty_struct *tty, struct file *file);
+        int (*tiocmset)(struct tty_struct *tty, struct file *file,
+                        unsigned int set, unsigned int clear);
+};
+
+struct tty_driver {
+        int     magic;          /* magic number for this structure */
+        struct cdev cdev;
+        struct module   *owner;
+        const char      *driver_name;
+        const char      *devfs_name;
+        const char      *name;
+        int     name_base;      /* offset of printed name */
+        int     major;          /* major device number */
+        int     minor_start;    /* start of minor device number */
+        int     minor_num;      /* number of *possible* devices */
+        int     num;            /* number of devices allocated */
+        short   type;           /* type of tty driver */
+        short   subtype;        /* subtype of tty driver */
+        struct termios init_termios; /* Initial termios */
+        int     flags;          /* tty driver flags */
+        int     refcount;       /* for loadable tty drivers */
+        struct proc_dir_entry *proc_entry; /* /proc fs entry */
+        struct tty_driver *other; /* only used for the PTY driver */
+
+        /*
+         * Pointer to the tty data structures
+         */
+        struct tty_struct **ttys;
+        struct termios **termios;
+        struct termios **termios_locked;
+        void *driver_state;     /* only used for the PTY driver */
+        
+        /*
+         * Interface routines from the upper tty layer to the tty
+         * driver.      Will be replaced with struct tty_operations.
+         */
+        int  (*open)(struct tty_struct * tty, struct file * filp);
+        void (*close)(struct tty_struct * tty, struct file * filp);
+        int  (*write)(struct tty_struct * tty,
+                      const unsigned char *buf, int count);
+        void (*put_char)(struct tty_struct *tty, unsigned char ch);
+        void (*flush_chars)(struct tty_struct *tty);
+        int  (*write_room)(struct tty_struct *tty);
+        int  (*chars_in_buffer)(struct tty_struct *tty);
+        int  (*ioctl)(struct tty_struct *tty, struct file * file,
+                    unsigned int cmd, unsigned long arg);
+        void (*set_termios)(struct tty_struct *tty, struct termios * old);
+        void (*throttle)(struct tty_struct * tty);
+        void (*unthrottle)(struct tty_struct * tty);
+        void (*stop)(struct tty_struct *tty);
+        void (*start)(struct tty_struct *tty);
+        void (*hangup)(struct tty_struct *tty);
+        void (*break_ctl)(struct tty_struct *tty, int state);
+        void (*flush_buffer)(struct tty_struct *tty);
+        void (*set_ldisc)(struct tty_struct *tty);
+        void (*wait_until_sent)(struct tty_struct *tty, int timeout);
+        void (*send_xchar)(struct tty_struct *tty, char ch);
+        int (*read_proc)(char *page, char **start, off_t off,
+                          int count, int *eof, void *data);
+        int (*write_proc)(struct file *file, const char __user *buffer,
+                          unsigned long count, void *data);
+        int (*tiocmget)(struct tty_struct *tty, struct file *file);
+        int (*tiocmset)(struct tty_struct *tty, struct file *file,
+                        unsigned int set, unsigned int clear);
+
+        struct list_head tty_drivers;
+};
+
+extern struct list_head tty_drivers;
+
+struct tty_driver *alloc_tty_driver(int lines);
+void put_tty_driver(struct tty_driver *driver);
+void tty_set_operations(struct tty_driver *driver, struct tty_operations *op);
+
+/* tty driver magic number */
+#define TTY_DRIVER_MAGIC                0x5402
+
+/*
+ * tty driver flags
+ * 
+ * TTY_DRIVER_RESET_TERMIOS --- requests the tty layer to reset the
+ *      termios setting when the last process has closed the device.
+ *      Used for PTY's, in particular.
+ * 
+ * TTY_DRIVER_REAL_RAW --- if set, indicates that the driver will
+ *      guarantee never not to set any special character handling
+ *      flags if ((IGNBRK || (!BRKINT && !PARMRK)) && (IGNPAR ||
+ *      !INPCK)).  That is, if there is no reason for the driver to
+ *      send notifications of parity and break characters up to the
+ *      line driver, it won't do so.  This allows the line driver to
+ *      optimize for this case if this flag is set.  (Note that there
+ *      is also a promise, if the above case is true, not to signal
+ *      overruns, either.)
+ *
+ * TTY_DRIVER_NO_DEVFS --- if set, do not create devfs entries. This
+ *      is only used by tty_register_driver().
+ *
+ * TTY_DRIVER_DEVPTS_MEM -- don't use the standard arrays, instead
+ *      use dynamic memory keyed through the devpts filesystem.  This
+ *      is only applicable to the pty driver.
+ */
+#define TTY_DRIVER_INSTALLED            0x0001
+#define TTY_DRIVER_RESET_TERMIOS        0x0002
+#define TTY_DRIVER_REAL_RAW             0x0004
+#define TTY_DRIVER_NO_DEVFS             0x0008
+#define TTY_DRIVER_DEVPTS_MEM           0x0010
+
+/* tty driver types */
+#define TTY_DRIVER_TYPE_SYSTEM          0x0001
+#define TTY_DRIVER_TYPE_CONSOLE         0x0002
+#define TTY_DRIVER_TYPE_SERIAL          0x0003
+#define TTY_DRIVER_TYPE_PTY             0x0004
+#define TTY_DRIVER_TYPE_SCC             0x0005  /* scc driver */
+#define TTY_DRIVER_TYPE_SYSCONS         0x0006
+
+/* system subtypes (magic, used by tty_io.c) */
+#define SYSTEM_TYPE_TTY                 0x0001
+#define SYSTEM_TYPE_CONSOLE             0x0002
+#define SYSTEM_TYPE_SYSCONS             0x0003
+#define SYSTEM_TYPE_SYSPTMX             0x0004
+
+/* pty subtypes (magic, used by tty_io.c) */
+#define PTY_TYPE_MASTER                 0x0001
+#define PTY_TYPE_SLAVE                  0x0002
+
+/* serial subtype definitions */
+#define SERIAL_TYPE_NORMAL      1
+
+#endif /* #ifdef _LINUX_TTY_DRIVER_H */
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
new file mode 100644
index 000000000000..abe9bfcf226c
--- /dev/null
+++ b/include/linux/tty_flip.h
@@ -0,0 +1,35 @@
+#ifndef _LINUX_TTY_FLIP_H
+#define _LINUX_TTY_FLIP_H
+
+#ifdef INCLUDE_INLINE_FUNCS
+#define _INLINE_ extern
+#else
+#define _INLINE_ static __inline__
+#endif
+
+_INLINE_ void tty_insert_flip_char(struct tty_struct *tty,
+                                   unsigned char ch, char flag)
+{
+        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
+                tty->flip.count++;
+                *tty->flip.flag_buf_ptr++ = flag;
+                *tty->flip.char_buf_ptr++ = ch;
+        }
+}
+
+_INLINE_ void tty_schedule_flip(struct tty_struct *tty)
+{
+        schedule_delayed_work(&tty->flip.work, 1);
+}
+
+#undef _INLINE_
+
+
+#endif /* _LINUX_TTY_FLIP_H */
+
+
+
+
+
+
+
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
new file mode 100644
index 000000000000..6066afde5ce4
--- /dev/null
+++ b/include/linux/tty_ldisc.h
@@ -0,0 +1,154 @@
+#ifndef _LINUX_TTY_LDISC_H
+#define _LINUX_TTY_LDISC_H
+
+/*
+ * This structure defines the interface between the tty line discipline
+ * implementation and the tty routines.  The following routines can be
+ * defined; unless noted otherwise, they are optional, and can be
+ * filled in with a null pointer.
+ *
+ * int  (*open)(struct tty_struct *);
+ *
+ *      This function is called when the line discipline is associated
+ *      with the tty.  The line discipline can use this as an
+ *      opportunity to initialize any state needed by the ldisc routines.
+ * 
+ * void (*close)(struct tty_struct *);
+ *
+ *      This function is called when the line discipline is being
+ *      shutdown, either because the tty is being closed or because
+ *      the tty is being changed to use a new line discipline
+ * 
+ * void (*flush_buffer)(struct tty_struct *tty);
+ *
+ *      This function instructs the line discipline to clear its
+ *      buffers of any input characters it may have queued to be
+ *      delivered to the user mode process.
+ * 
+ * ssize_t (*chars_in_buffer)(struct tty_struct *tty);
+ *
+ *      This function returns the number of input characters the line
+ *      discipline may have queued up to be delivered to the user mode
+ *      process.
+ * 
+ * ssize_t (*read)(struct tty_struct * tty, struct file * file,
+ *                 unsigned char * buf, size_t nr);
+ *
+ *      This function is called when the user requests to read from
+ *      the tty.  The line discipline will return whatever characters
+ *      it has buffered up for the user.  If this function is not
+ *      defined, the user will receive an EIO error.
+ * 
+ * ssize_t (*write)(struct tty_struct * tty, struct file * file,
+ *                  const unsigned char * buf, size_t nr);
+ *
+ *      This function is called when the user requests to write to the
+ *      tty.  The line discipline will deliver the characters to the
+ *      low-level tty device for transmission, optionally performing
+ *      some processing on the characters first.  If this function is
+ *      not defined, the user will receive an EIO error.
+ * 
+ * int  (*ioctl)(struct tty_struct * tty, struct file * file,
+ *               unsigned int cmd, unsigned long arg);
+ *
+ *      This function is called when the user requests an ioctl which
+ *      is not handled by the tty layer or the low-level tty driver.
+ *      It is intended for ioctls which affect line discpline
+ *      operation.  Note that the search order for ioctls is (1) tty
+ *      layer, (2) tty low-level driver, (3) line discpline.  So a
+ *      low-level driver can "grab" an ioctl request before the line
+ *      discpline has a chance to see it.
+ * 
+ * void (*set_termios)(struct tty_struct *tty, struct termios * old);
+ *
+ *      This function notifies the line discpline that a change has
+ *      been made to the termios structure.
+ * 
+ * int  (*poll)(struct tty_struct * tty, struct file * file,
+ *                poll_table *wait);
+ *
+ *      This function is called when a user attempts to select/poll on a
+ *      tty device.  It is solely the responsibility of the line
+ *      discipline to handle poll requests.
+ *
+ * void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
+ *                     char *fp, int count);
+ *
+ *      This function is called by the low-level tty driver to send
+ *      characters received by the hardware to the line discpline for
+ *      processing.  <cp> is a pointer to the buffer of input
+ *      character received by the device.  <fp> is a pointer to a
+ *      pointer of flag bytes which indicate whether a character was
+ *      received with a parity error, etc.
+ * 
+ * int  (*receive_room)(struct tty_struct *);
+ *
+ *      This function is called by the low-level tty driver to
+ *      determine how many characters the line discpline can accept.
+ *      The low-level driver must not send more characters than was
+ *      indicated by receive_room, or the line discpline may drop
+ *      those characters.
+ * 
+ * void (*write_wakeup)(struct tty_struct *);
+ *
+ *      This function is called by the low-level tty driver to signal
+ *      that line discpline should try to send more characters to the
+ *      low-level driver for transmission.  If the line discpline does
+ *      not have any more data to send, it can just return.
+ *
+ * int (*hangup)(struct tty_struct *)
+ *
+ *      Called on a hangup. Tells the discipline that it should
+ *      cease I/O to the tty driver. Can sleep. The driver should
+ *      seek to perform this action quickly but should wait until
+ *      any pending driver I/O is completed.
+ */
+
+#include <linux/fs.h>
+#include <linux/wait.h>
+
+struct tty_ldisc {
+        int     magic;
+        char    *name;
+        int     num;
+        int     flags;
+        
+        /*
+         * The following routines are called from above.
+         */
+        int     (*open)(struct tty_struct *);
+        void    (*close)(struct tty_struct *);
+        void    (*flush_buffer)(struct tty_struct *tty);
+        ssize_t (*chars_in_buffer)(struct tty_struct *tty);
+        ssize_t (*read)(struct tty_struct * tty, struct file * file,
+                        unsigned char __user * buf, size_t nr);
+        ssize_t (*write)(struct tty_struct * tty, struct file * file,
+                         const unsigned char * buf, size_t nr); 
+        int     (*ioctl)(struct tty_struct * tty, struct file * file,
+                         unsigned int cmd, unsigned long arg);
+        void    (*set_termios)(struct tty_struct *tty, struct termios * old);
+        unsigned int (*poll)(struct tty_struct *, struct file *,
+                             struct poll_table_struct *);
+        int     (*hangup)(struct tty_struct *tty);
+        
+        /*
+         * The following routines are called from below.
+         */
+        void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
+                               char *fp, int count);
+        int     (*receive_room)(struct tty_struct *);
+        void    (*write_wakeup)(struct tty_struct *);
+
+        struct  module *owner;
+        
+        int refcount;
+};
+
+#define TTY_LDISC_MAGIC 0x5403
+
+#define LDISC_FLAG_DEFINED      0x00000001
+
+#define MODULE_ALIAS_LDISC(ldisc) \
+        MODULE_ALIAS("tty-ldisc-" __stringify(ldisc))
+
+#endif /* _LINUX_TTY_LDISC_H */
diff --git a/include/linux/types.h b/include/linux/types.h
new file mode 100644
index 000000000000..dcb13f865df9
--- /dev/null
+++ b/include/linux/types.h
@@ -0,0 +1,172 @@
+#ifndef _LINUX_TYPES_H
+#define _LINUX_TYPES_H
+
+#ifdef  __KERNEL__
+#include <linux/config.h>
+
+#define BITS_TO_LONGS(bits) \
+        (((bits)+BITS_PER_LONG-1)/BITS_PER_LONG)
+#define DECLARE_BITMAP(name,bits) \
+        unsigned long name[BITS_TO_LONGS(bits)]
+#endif
+
+#include <linux/posix_types.h>
+#include <asm/types.h>
+
+#ifndef __KERNEL_STRICT_NAMES
+
+typedef __u32 __kernel_dev_t;
+
+typedef __kernel_fd_set         fd_set;
+typedef __kernel_dev_t          dev_t;
+typedef __kernel_ino_t          ino_t;
+typedef __kernel_mode_t         mode_t;
+typedef __kernel_nlink_t        nlink_t;
+typedef __kernel_off_t          off_t;
+typedef __kernel_pid_t          pid_t;
+typedef __kernel_daddr_t        daddr_t;
+typedef __kernel_key_t          key_t;
+typedef __kernel_suseconds_t    suseconds_t;
+typedef __kernel_timer_t        timer_t;
+typedef __kernel_clockid_t      clockid_t;
+typedef __kernel_mqd_t          mqd_t;
+
+#ifdef __KERNEL__
+typedef __kernel_uid32_t        uid_t;
+typedef __kernel_gid32_t        gid_t;
+typedef __kernel_uid16_t        uid16_t;
+typedef __kernel_gid16_t        gid16_t;
+
+#ifdef CONFIG_UID16
+/* This is defined by include/asm-{arch}/posix_types.h */
+typedef __kernel_old_uid_t      old_uid_t;
+typedef __kernel_old_gid_t      old_gid_t;
+#endif /* CONFIG_UID16 */
+
+/* libc5 includes this file to define uid_t, thus uid_t can never change
+ * when it is included by non-kernel code
+ */
+#else
+typedef __kernel_uid_t          uid_t;
+typedef __kernel_gid_t          gid_t;
+#endif /* __KERNEL__ */
+
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+typedef __kernel_loff_t         loff_t;
+#endif
+
+/*
+ * The following typedefs are also protected by individual ifdefs for
+ * historical reasons:
+ */
+#ifndef _SIZE_T
+#define _SIZE_T
+typedef __kernel_size_t         size_t;
+#endif
+
+#ifndef _SSIZE_T
+#define _SSIZE_T
+typedef __kernel_ssize_t        ssize_t;
+#endif
+
+#ifndef _PTRDIFF_T
+#define _PTRDIFF_T
+typedef __kernel_ptrdiff_t      ptrdiff_t;
+#endif
+
+#ifndef _TIME_T
+#define _TIME_T
+typedef __kernel_time_t         time_t;
+#endif
+
+#ifndef _CLOCK_T
+#define _CLOCK_T
+typedef __kernel_clock_t        clock_t;
+#endif
+
+#ifndef _CADDR_T
+#define _CADDR_T
+typedef __kernel_caddr_t        caddr_t;
+#endif
+
+/* bsd */
+typedef unsigned char           u_char;
+typedef unsigned short          u_short;
+typedef unsigned int            u_int;
+typedef unsigned long           u_long;
+
+/* sysv */
+typedef unsigned char           unchar;
+typedef unsigned short          ushort;
+typedef unsigned int            uint;
+typedef unsigned long           ulong;
+
+#ifndef __BIT_TYPES_DEFINED__
+#define __BIT_TYPES_DEFINED__
+
+typedef         __u8            u_int8_t;
+typedef         __s8            int8_t;
+typedef         __u16           u_int16_t;
+typedef         __s16           int16_t;
+typedef         __u32           u_int32_t;
+typedef         __s32           int32_t;
+
+#endif /* !(__BIT_TYPES_DEFINED__) */
+
+typedef         __u8            uint8_t;
+typedef         __u16           uint16_t;
+typedef         __u32           uint32_t;
+
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+typedef         __u64           uint64_t;
+typedef         __u64           u_int64_t;
+typedef         __s64           int64_t;
+#endif
+
+/*
+ * The type used for indexing onto a disc or disc partition.
+ * If required, asm/types.h can override it and define
+ * HAVE_SECTOR_T
+ */
+#ifndef HAVE_SECTOR_T
+typedef unsigned long sector_t;
+#endif
+
+/*
+ * The type of an index into the pagecache.  Use a #define so asm/types.h
+ * can override it.
+ */
+#ifndef pgoff_t
+#define pgoff_t unsigned long
+#endif
+
+#endif /* __KERNEL_STRICT_NAMES */
+
+/*
+ * Below are truly Linux-specific types that should never collide with
+ * any application/library that wants linux/types.h.
+ */
+
+#ifdef __CHECKER__
+#define __bitwise __attribute__((bitwise))
+#else
+#define __bitwise
+#endif
+
+typedef __u16 __bitwise __le16;
+typedef __u16 __bitwise __be16;
+typedef __u32 __bitwise __le32;
+typedef __u32 __bitwise __be32;
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+typedef __u64 __bitwise __le64;
+typedef __u64 __bitwise __be64;
+#endif
+
+struct ustat {
+        __kernel_daddr_t        f_tfree;
+        __kernel_ino_t          f_tinode;
+        char                    f_fname[6];
+        char                    f_fpack[6];
+};
+
+#endif /* _LINUX_TYPES_H */
diff --git a/include/linux/udf_fs.h b/include/linux/udf_fs.h
new file mode 100644
index 000000000000..46e2bb945353
--- /dev/null
+++ b/include/linux/udf_fs.h
@@ -0,0 +1,59 @@
+/*
+ * udf_fs.h
+ *
+ * PURPOSE
+ *  Included by fs/filesystems.c
+ *
+ * DESCRIPTION
+ *  OSTA-UDF(tm) = Optical Storage Technology Association
+ *  Universal Disk Format.
+ *
+ *  This code is based on version 2.50 of the UDF specification,
+ *  and revision 3 of the ECMA 167 standard [equivalent to ISO 13346].
+ *    http://www.osta.org/ *    http://www.ecma.ch/
+ *    http://www.iso.org/
+ *
+ * CONTACTS
+ *      E-mail regarding any portion of the Linux UDF file system should be
+ *      directed to the development team mailing list (run by majordomo):
+ *              linux_udf@hpesjro.fc.hp.com
+ *
+ * COPYRIGHT
+ *      This file is distributed under the terms of the GNU General Public
+ *      License (GPL). Copies of the GPL can be obtained from:
+ *              ftp://prep.ai.mit.edu/pub/gnu/GPL
+ *      Each contributing author retains all rights to their own work.
+ *
+ *  (C) 1999-2004 Ben Fennema
+ *  (C) 1999-2000 Stelias Computing Inc
+ *
+ * HISTORY
+ *
+ */
+
+#ifndef _UDF_FS_H
+#define _UDF_FS_H 1
+
+#define UDF_PREALLOCATE
+#define UDF_DEFAULT_PREALLOC_BLOCKS     8
+
+#define UDFFS_DATE                      "2004/29/09"
+#define UDFFS_VERSION                   "0.9.8.1"
+
+#undef UDFFS_DEBUG
+
+#ifdef UDFFS_DEBUG
+#define udf_debug(f, a...) \
+        { \
+                printk (KERN_DEBUG "UDF-fs DEBUG %s:%d:%s: ", \
+                        __FILE__, __LINE__, __FUNCTION__); \
+                printk (f, ##a); \
+        }
+#else
+#define udf_debug(f, a...) /**/
+#endif
+
+#define udf_info(f, a...) \
+                printk (KERN_INFO "UDF-fs INFO " f, ##a);
+
+#endif /* _UDF_FS_H */
diff --git a/include/linux/udf_fs_i.h b/include/linux/udf_fs_i.h
new file mode 100644
index 000000000000..62b15a4214e6
--- /dev/null
+++ b/include/linux/udf_fs_i.h
@@ -0,0 +1,78 @@
+/*
+ * udf_fs_i.h
+ *
+ * This file is intended for the Linux kernel/module. 
+ *
+ * CONTACTS
+ *      E-mail regarding any portion of the Linux UDF file system should be
+ *      directed to the development team mailing list (run by majordomo):
+ *              linux_udf@hpesjro.fc.hp.com
+ *
+ * COPYRIGHT
+ *      This file is distributed under the terms of the GNU General Public
+ *      License (GPL). Copies of the GPL can be obtained from:
+ *              ftp://prep.ai.mit.edu/pub/gnu/GPL
+ *      Each contributing author retains all rights to their own work.
+ */
+
+#ifndef _UDF_FS_I_H
+#define _UDF_FS_I_H 1
+
+#ifdef __KERNEL__
+
+#ifndef _ECMA_167_H
+typedef struct
+{
+        __u32                   logicalBlockNum;
+        __u16                   partitionReferenceNum;
+} __attribute__ ((packed)) lb_addr;
+
+typedef struct
+{
+        __u32                   extLength;
+        __u32                   extPosition;
+} __attribute__ ((packed)) short_ad;
+
+typedef struct
+{
+        __u32                   extLength;
+        lb_addr                 extLocation;
+        __u8                    impUse[6];
+} __attribute__ ((packed)) long_ad;
+#endif
+
+struct udf_inode_info
+{
+        struct timespec         i_crtime;
+        /* Physical address of inode */
+        kernel_lb_addr          i_location;
+        __u64                   i_unique;
+        __u32                   i_lenEAttr;
+        __u32                   i_lenAlloc;
+        __u64                   i_lenExtents;
+        __u32                   i_next_alloc_block;
+        __u32                   i_next_alloc_goal;
+        unsigned                i_alloc_type : 3;
+        unsigned                i_efe : 1;
+        unsigned                i_use : 1;
+        unsigned                i_strat4096 : 1;
+        unsigned                reserved : 26;
+        union
+        {
+                short_ad        *i_sad;
+                long_ad         *i_lad;
+                __u8            *i_data;
+        } i_ext;
+        struct inode vfs_inode;
+};
+
+#endif
+
+/* exported IOCTLs, we have 'l', 0x40-0x7f */
+
+#define UDF_GETEASIZE   _IOR('l', 0x40, int)
+#define UDF_GETEABLOCK  _IOR('l', 0x41, void *)
+#define UDF_GETVOLIDENT _IOR('l', 0x42, void *)
+#define UDF_RELOCATE_BLOCKS _IOWR('l', 0x43, long)
+
+#endif /* _UDF_FS_I_H */
diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
new file mode 100644
index 000000000000..1966a6dbb4b6
--- /dev/null
+++ b/include/linux/udf_fs_sb.h
@@ -0,0 +1,122 @@
+/*
+ * udf_fs_sb.h
+ * 
+ * This include file is for the Linux kernel/module.
+ *
+ * CONTACTS
+ *      E-mail regarding any portion of the Linux UDF file system should be
+ *      directed to the development team mailing list (run by majordomo):
+ *              linux_udf@hpesjro.fc.hp.com
+ *
+ * COPYRIGHT
+ *      This file is distributed under the terms of the GNU General Public
+ *      License (GPL). Copies of the GPL can be obtained from:
+ *              ftp://prep.ai.mit.edu/pub/gnu/GPL
+ *      Each contributing author retains all rights to their own work.
+ */
+
+#ifndef _UDF_FS_SB_H
+#define _UDF_FS_SB_H 1
+
+#include <asm/semaphore.h>
+
+#pragma pack(1)
+
+#define UDF_MAX_BLOCK_LOADED    8
+
+#define UDF_TYPE1_MAP15                 0x1511U
+#define UDF_VIRTUAL_MAP15               0x1512U
+#define UDF_VIRTUAL_MAP20               0x2012U
+#define UDF_SPARABLE_MAP15              0x1522U
+
+struct udf_sparing_data
+{
+        __u16   s_packet_len;
+        struct buffer_head *s_spar_map[4];
+};
+
+struct udf_virtual_data
+{
+        __u32   s_num_entries;
+        __u16   s_start_offset;
+};
+
+struct udf_bitmap
+{
+        __u32                   s_extLength;
+        __u32                   s_extPosition;
+        __u16                   s_nr_groups;
+        struct buffer_head      **s_block_bitmap;
+};
+
+struct udf_part_map
+{
+        union
+        {
+                struct udf_bitmap       *s_bitmap;
+                struct inode            *s_table;
+        } s_uspace;
+        union
+        {
+                struct udf_bitmap       *s_bitmap;
+                struct inode            *s_table;
+        } s_fspace;
+        __u32   s_partition_root;
+        __u32   s_partition_len;
+        __u16   s_partition_type;
+        __u16   s_partition_num;
+        union
+        {
+                struct udf_sparing_data s_sparing;
+                struct udf_virtual_data s_virtual;
+        } s_type_specific;
+        __u32   (*s_partition_func)(struct super_block *, __u32, __u16, __u32);
+        __u16   s_volumeseqnum;
+        __u16   s_partition_flags;
+};
+
+#pragma pack()
+
+struct udf_sb_info
+{
+        struct udf_part_map     *s_partmaps;
+        __u8                    s_volident[32];
+
+        /* Overall info */
+        __u16                   s_partitions;
+        __u16                   s_partition;
+
+        /* Sector headers */
+        __s32                   s_session;
+        __u32                   s_anchor[4];
+        __u32                   s_lastblock;
+
+        struct buffer_head      *s_lvidbh;
+
+        /* Default permissions */
+        mode_t                  s_umask;
+        gid_t                   s_gid;
+        uid_t                   s_uid;
+
+        /* Root Info */
+        struct timespec         s_recordtime;
+
+        /* Fileset Info */
+        __u16                   s_serialnum;
+
+        /* highest UDF revision we have recorded to this media */
+        __u16                   s_udfrev;
+
+        /* Miscellaneous flags */
+        __u32                   s_flags;
+
+        /* Encoding info */
+        struct nls_table        *s_nls_map;
+
+        /* VAT inode */
+        struct inode            *s_vat;
+
+        struct semaphore        s_alloc_sem;
+};
+
+#endif /* _UDF_FS_SB_H */
diff --git a/include/linux/udp.h b/include/linux/udp.h
new file mode 100644
index 000000000000..b60e0b4a25c4
--- /dev/null
+++ b/include/linux/udp.h
@@ -0,0 +1,63 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              Definitions for the UDP protocol.
+ *
+ * Version:     @(#)udp.h       1.0.2   04/28/93
+ *
+ * Author:      Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _LINUX_UDP_H
+#define _LINUX_UDP_H
+
+#include <linux/types.h>
+
+struct udphdr {
+        __u16   source;
+        __u16   dest;
+        __u16   len;
+        __u16   check;
+};
+
+/* UDP socket options */
+#define UDP_CORK        1       /* Never send partially complete segments */
+#define UDP_ENCAP       100     /* Set the socket to accept encapsulated packets */
+
+/* UDP encapsulation types */
+#define UDP_ENCAP_ESPINUDP_NON_IKE      1 /* draft-ietf-ipsec-nat-t-ike-00/01 */
+#define UDP_ENCAP_ESPINUDP      2 /* draft-ietf-ipsec-udp-encaps-06 */
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <net/sock.h>
+#include <linux/ip.h>
+
+struct udp_sock {
+        /* inet_sock has to be the first member */
+        struct inet_sock inet;
+        int              pending;       /* Any pending frames ? */
+        unsigned int     corkflag;      /* Cork is required */
+        __u16            encap_type;    /* Is this an Encapsulation socket? */
+        /*
+         * Following member retains the infomation to create a UDP header
+         * when the socket is uncorked.
+         */
+        __u16            len;           /* total length of pending frames */
+};
+
+static inline struct udp_sock *udp_sk(const struct sock *sk)
+{
+        return (struct udp_sock *)sk;
+}
+
+#endif
+
+#endif  /* _LINUX_UDP_H */
diff --git a/include/linux/ufs_fs.h b/include/linux/ufs_fs.h
new file mode 100644
index 000000000000..7a6babeca256
--- /dev/null
+++ b/include/linux/ufs_fs.h
@@ -0,0 +1,943 @@
+/*
+ *  linux/include/linux/ufs_fs.h
+ *
+ * Copyright (C) 1996
+ * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
+ * Laboratory for Computer Science Research Computing Facility
+ * Rutgers, The State University of New Jersey
+ *
+ * Clean swab support by Fare <fare@tunes.org>
+ * just hope no one is using NNUUXXI on __?64 structure elements
+ * 64-bit clean thanks to Maciej W. Rozycki <macro@ds2.pg.gda.pl>
+ *
+ * 4.4BSD (FreeBSD) support added on February 1st 1998 by
+ * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
+ * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
+ *
+ * NeXTstep support added on February 5th 1998 by
+ * Niels Kristian Bech Jensen <nkbj@image.dk>.
+ *
+ * Write support by Daniel Pirkl <daniel.pirkl@email.cz>
+ *
+ * HP/UX hfs filesystem support added by
+ * Martin K. Petersen <mkp@mkp.net>, August 1999
+ *
+ * UFS2 (of FreeBSD 5.x) support added by
+ * Niraj Kumar <niraj17@iitbombay.org>  , Jan 2004
+ *
+ */
+
+#ifndef __LINUX_UFS_FS_H
+#define __LINUX_UFS_FS_H
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/stat.h>
+#include <linux/fs.h>
+
+#ifndef __KERNEL__
+typedef __u64 __fs64;
+typedef __u32 __fs32;
+typedef __u16 __fs16;
+#else
+typedef __u64 __bitwise __fs64;
+typedef __u32 __bitwise __fs32;
+typedef __u16 __bitwise __fs16;
+#endif
+
+#include <linux/ufs_fs_i.h>
+#include <linux/ufs_fs_sb.h>
+
+#define UFS_BBLOCK 0
+#define UFS_BBSIZE 8192
+#define UFS_SBLOCK 8192
+#define UFS_SBSIZE 8192
+
+#define UFS_SECTOR_SIZE 512
+#define UFS_SECTOR_BITS 9
+#define UFS_MAGIC  0x00011954
+#define UFS2_MAGIC 0x19540119
+#define UFS_CIGAM  0x54190100 /* byteswapped MAGIC */
+
+/* Copied from FreeBSD */
+/*
+ * Each disk drive contains some number of filesystems.
+ * A filesystem consists of a number of cylinder groups.
+ * Each cylinder group has inodes and data.
+ *
+ * A filesystem is described by its super-block, which in turn
+ * describes the cylinder groups.  The super-block is critical
+ * data and is replicated in each cylinder group to protect against
+ * catastrophic loss.  This is done at `newfs' time and the critical
+ * super-block data does not change, so the copies need not be
+ * referenced further unless disaster strikes.
+ *
+ * For filesystem fs, the offsets of the various blocks of interest
+ * are given in the super block as:
+ *      [fs->fs_sblkno]         Super-block
+ *      [fs->fs_cblkno]         Cylinder group block
+ *      [fs->fs_iblkno]         Inode blocks
+ *      [fs->fs_dblkno]         Data blocks
+ * The beginning of cylinder group cg in fs, is given by
+ * the ``cgbase(fs, cg)'' macro.
+ *
+ * Depending on the architecture and the media, the superblock may
+ * reside in any one of four places. For tiny media where every block
+ * counts, it is placed at the very front of the partition. Historically,
+ * UFS1 placed it 8K from the front to leave room for the disk label and
+ * a small bootstrap. For UFS2 it got moved to 64K from the front to leave
+ * room for the disk label and a bigger bootstrap, and for really piggy
+ * systems we check at 256K from the front if the first three fail. In
+ * all cases the size of the superblock will be SBLOCKSIZE. All values are
+ * given in byte-offset form, so they do not imply a sector size. The
+ * SBLOCKSEARCH specifies the order in which the locations should be searched.
+ */
+#define SBLOCK_FLOPPY        0
+#define SBLOCK_UFS1       8192
+#define SBLOCK_UFS2      65536
+#define SBLOCK_PIGGY    262144
+#define SBLOCKSIZE        8192
+#define SBLOCKSEARCH \
+        { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
+
+
+/* HP specific MAGIC values */
+
+#define UFS_MAGIC_LFN   0x00095014 /* fs supports filenames > 14 chars */
+#define UFS_CIGAM_LFN   0x14500900 /* srahc 41 < semanelif stroppus sf */
+
+#define UFS_MAGIC_SEC   0x00612195 /* B1 security fs */
+#define UFS_CIGAM_SEC   0x95216100
+
+#define UFS_MAGIC_FEA   0x00195612 /* fs_featurebits supported */
+#define UFS_CIGAM_FEA   0x12561900
+
+#define UFS_MAGIC_4GB   0x05231994 /* fs > 4 GB && fs_featurebits */
+#define UFS_CIGAM_4GB   0x94192305
+
+/* Seems somebody at HP goofed here. B1 and lfs are both 0x2 !?! */
+#define UFS_FSF_LFN     0x00000001 /* long file names */
+#define UFS_FSF_B1      0x00000002 /* B1 security */
+#define UFS_FSF_LFS     0x00000002 /* large files */
+#define UFS_FSF_LUID    0x00000004 /* large UIDs */
+
+/* End of HP stuff */
+
+
+#define UFS_BSIZE       8192
+#define UFS_MINBSIZE    4096
+#define UFS_FSIZE       1024
+#define UFS_MAXFRAG     (UFS_BSIZE / UFS_FSIZE)
+
+#define UFS_NDADDR 12
+#define UFS_NINDIR 3
+
+#define UFS_IND_BLOCK   (UFS_NDADDR + 0)
+#define UFS_DIND_BLOCK  (UFS_NDADDR + 1)
+#define UFS_TIND_BLOCK  (UFS_NDADDR + 2)
+
+#define UFS_NDIR_FRAGMENT (UFS_NDADDR << uspi->s_fpbshift)
+#define UFS_IND_FRAGMENT (UFS_IND_BLOCK << uspi->s_fpbshift)
+#define UFS_DIND_FRAGMENT (UFS_DIND_BLOCK << uspi->s_fpbshift)
+#define UFS_TIND_FRAGMENT (UFS_TIND_BLOCK << uspi->s_fpbshift)
+
+#define UFS_ROOTINO 2
+#define UFS_FIRST_INO (UFS_ROOTINO + 1)
+
+#define UFS_USEEFT  ((__u16)65535)
+
+#define UFS_FSOK      0x7c269d38
+#define UFS_FSACTIVE  ((char)0x00)
+#define UFS_FSCLEAN   ((char)0x01)
+#define UFS_FSSTABLE  ((char)0x02)
+#define UFS_FSOSF1    ((char)0x03)      /* is this correct for DEC OSF/1? */
+#define UFS_FSBAD     ((char)0xff)
+
+/* From here to next blank line, s_flags for ufs_sb_info */
+/* directory entry encoding */
+#define UFS_DE_MASK             0x00000010      /* mask for the following */
+#define UFS_DE_OLD              0x00000000
+#define UFS_DE_44BSD            0x00000010
+/* uid encoding */
+#define UFS_UID_MASK            0x00000060      /* mask for the following */
+#define UFS_UID_OLD             0x00000000
+#define UFS_UID_44BSD           0x00000020
+#define UFS_UID_EFT             0x00000040
+/* superblock state encoding */
+#define UFS_ST_MASK             0x00000700      /* mask for the following */
+#define UFS_ST_OLD              0x00000000
+#define UFS_ST_44BSD            0x00000100
+#define UFS_ST_SUN              0x00000200
+#define UFS_ST_SUNx86           0x00000400
+/*cylinder group encoding */
+#define UFS_CG_MASK             0x00003000      /* mask for the following */
+#define UFS_CG_OLD              0x00000000
+#define UFS_CG_44BSD            0x00002000
+#define UFS_CG_SUN              0x00001000
+/* filesystem type encoding */
+#define UFS_TYPE_MASK           0x00010000      /* mask for the following */
+#define UFS_TYPE_UFS1           0x00000000
+#define UFS_TYPE_UFS2           0x00010000
+
+
+/* fs_inodefmt options */
+#define UFS_42INODEFMT  -1
+#define UFS_44INODEFMT  2
+
+/* mount options */
+#define UFS_MOUNT_ONERROR               0x0000000F
+#define UFS_MOUNT_ONERROR_PANIC         0x00000001
+#define UFS_MOUNT_ONERROR_LOCK          0x00000002
+#define UFS_MOUNT_ONERROR_UMOUNT        0x00000004
+#define UFS_MOUNT_ONERROR_REPAIR        0x00000008
+
+#define UFS_MOUNT_UFSTYPE               0x0000FFF0
+#define UFS_MOUNT_UFSTYPE_OLD           0x00000010
+#define UFS_MOUNT_UFSTYPE_44BSD         0x00000020
+#define UFS_MOUNT_UFSTYPE_SUN           0x00000040
+#define UFS_MOUNT_UFSTYPE_NEXTSTEP      0x00000080
+#define UFS_MOUNT_UFSTYPE_NEXTSTEP_CD   0x00000100
+#define UFS_MOUNT_UFSTYPE_OPENSTEP      0x00000200
+#define UFS_MOUNT_UFSTYPE_SUNx86        0x00000400
+#define UFS_MOUNT_UFSTYPE_HP            0x00000800
+#define UFS_MOUNT_UFSTYPE_UFS2          0x00001000
+
+#define ufs_clear_opt(o,opt)    o &= ~UFS_MOUNT_##opt
+#define ufs_set_opt(o,opt)      o |= UFS_MOUNT_##opt
+#define ufs_test_opt(o,opt)     ((o) & UFS_MOUNT_##opt)
+
+/*
+ * MINFREE gives the minimum acceptable percentage of file system
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the file system
+ * is run at between 95% and 100% full; thus the minimum default
+ * value of fs_minfree is 5%. However, to get good clustering
+ * performance, 10% is a better choice. hence we use 10% as our
+ * default value. With 10% free space, fragmentation is not a
+ * problem, so we choose to optimize for time.
+ */
+#define UFS_MINFREE         5
+#define UFS_DEFAULTOPT      UFS_OPTTIME
+            
+/*
+ * Turn file system block numbers into disk block addresses.
+ * This maps file system blocks to device size blocks.
+ */
+#define ufs_fsbtodb(uspi, b)    ((b) << (uspi)->s_fsbtodb)
+#define ufs_dbtofsb(uspi, b)    ((b) >> (uspi)->s_fsbtodb)
+
+/*
+ * Cylinder group macros to locate things in cylinder groups.
+ * They calc file system addresses of cylinder group data structures.
+ */
+#define ufs_cgbase(c)   (uspi->s_fpg * (c))
+#define ufs_cgstart(c)  ((uspi)->fs_magic == UFS2_MAGIC ?  ufs_cgbase(c) : \
+        (ufs_cgbase(c)  + uspi->s_cgoffset * ((c) & ~uspi->s_cgmask)))
+#define ufs_cgsblock(c) (ufs_cgstart(c) + uspi->s_sblkno)       /* super blk */
+#define ufs_cgcmin(c)   (ufs_cgstart(c) + uspi->s_cblkno)       /* cg block */
+#define ufs_cgimin(c)   (ufs_cgstart(c) + uspi->s_iblkno)       /* inode blk */
+#define ufs_cgdmin(c)   (ufs_cgstart(c) + uspi->s_dblkno)       /* 1st data */
+
+/*
+ * Macros for handling inode numbers:
+ *     inode number to file system block offset.
+ *     inode number to cylinder group number.
+ *     inode number to file system block address.
+ */
+#define ufs_inotocg(x)          ((x) / uspi->s_ipg)
+#define ufs_inotocgoff(x)       ((x) % uspi->s_ipg)
+#define ufs_inotofsba(x)        (ufs_cgimin(ufs_inotocg(x)) + ufs_inotocgoff(x) / uspi->s_inopf)
+#define ufs_inotofsbo(x)        ((x) % uspi->s_inopf)
+
+/*
+ * Give cylinder group number for a file system block.
+ * Give cylinder group block number for a file system block.
+ */
+#define ufs_dtog(d)     ((d) / uspi->s_fpg)
+#define ufs_dtogd(d)    ((d) % uspi->s_fpg)
+
+/*
+ * Compute the cylinder and rotational position of a cyl block addr.
+ */
+#define ufs_cbtocylno(bno) \
+        ((bno) * uspi->s_nspf / uspi->s_spc)
+#define ufs_cbtorpos(bno) \
+        ((((bno) * uspi->s_nspf % uspi->s_spc / uspi->s_nsect \
+        * uspi->s_trackskew + (bno) * uspi->s_nspf % uspi->s_spc \
+        % uspi->s_nsect * uspi->s_interleave) % uspi->s_nsect \
+        * uspi->s_nrpos) / uspi->s_npsect)
+
+/*
+ * The following macros optimize certain frequently calculated
+ * quantities by using shifts and masks in place of divisions
+ * modulos and multiplications.
+ */
+#define ufs_blkoff(loc)         ((loc) & uspi->s_qbmask)
+#define ufs_fragoff(loc)        ((loc) & uspi->s_qfmask)
+#define ufs_lblktosize(blk)     ((blk) << uspi->s_bshift)
+#define ufs_lblkno(loc)         ((loc) >> uspi->s_bshift)
+#define ufs_numfrags(loc)       ((loc) >> uspi->s_fshift)
+#define ufs_blkroundup(size)    (((size) + uspi->s_qbmask) & uspi->s_bmask)
+#define ufs_fragroundup(size)   (((size) + uspi->s_qfmask) & uspi->s_fmask)
+#define ufs_fragstoblks(frags)  ((frags) >> uspi->s_fpbshift)
+#define ufs_blkstofrags(blks)   ((blks) << uspi->s_fpbshift)
+#define ufs_fragnum(fsb)        ((fsb) & uspi->s_fpbmask)
+#define ufs_blknum(fsb)         ((fsb) & ~uspi->s_fpbmask)
+
+#define UFS_MAXNAMLEN 255
+#define UFS_MAXMNTLEN 512
+#define UFS2_MAXMNTLEN 468
+#define UFS2_MAXVOLLEN 32
+/* #define UFS_MAXCSBUFS 31 */
+#define UFS_LINK_MAX 32000
+/*
+#define UFS2_NOCSPTRS   ((128 / sizeof(void *)) - 4)
+*/
+#define UFS2_NOCSPTRS   28
+
+/*
+ * UFS_DIR_PAD defines the directory entries boundaries
+ * (must be a multiple of 4)
+ */
+#define UFS_DIR_PAD                     4
+#define UFS_DIR_ROUND                   (UFS_DIR_PAD - 1)
+#define UFS_DIR_REC_LEN(name_len)       (((name_len) + 1 + 8 + UFS_DIR_ROUND) & ~UFS_DIR_ROUND)
+
+struct ufs_timeval {
+        __fs32  tv_sec;
+        __fs32  tv_usec;
+};
+
+struct ufs_dir_entry {
+        __fs32  d_ino;                  /* inode number of this entry */
+        __fs16  d_reclen;               /* length of this entry */
+        union {
+                __fs16  d_namlen;               /* actual length of d_name */
+                struct {
+                        __u8    d_type;         /* file type */
+                        __u8    d_namlen;       /* length of string in d_name */
+                } d_44;
+        } d_u;
+        __u8    d_name[UFS_MAXNAMLEN + 1];      /* file name */
+};
+
+struct ufs_csum {
+        __fs32  cs_ndir;        /* number of directories */
+        __fs32  cs_nbfree;      /* number of free blocks */
+        __fs32  cs_nifree;      /* number of free inodes */
+        __fs32  cs_nffree;      /* number of free frags */
+};
+struct ufs2_csum_total {
+        __fs64  cs_ndir;        /* number of directories */
+        __fs64  cs_nbfree;      /* number of free blocks */
+        __fs64  cs_nifree;      /* number of free inodes */
+        __fs64  cs_nffree;      /* number of free frags */
+        __fs64   cs_numclusters;        /* number of free clusters */
+        __fs64   cs_spare[3];   /* future expansion */
+};
+
+/*
+ * This is the actual superblock, as it is laid out on the disk.
+ */
+struct ufs_super_block {
+        __fs32  fs_link;        /* UNUSED */
+        __fs32  fs_rlink;       /* UNUSED */
+        __fs32  fs_sblkno;      /* addr of super-block in filesys */
+        __fs32  fs_cblkno;      /* offset of cyl-block in filesys */
+        __fs32  fs_iblkno;      /* offset of inode-blocks in filesys */
+        __fs32  fs_dblkno;      /* offset of first data after cg */
+        __fs32  fs_cgoffset;    /* cylinder group offset in cylinder */
+        __fs32  fs_cgmask;      /* used to calc mod fs_ntrak */
+        __fs32  fs_time;        /* last time written -- time_t */
+        __fs32  fs_size;        /* number of blocks in fs */
+        __fs32  fs_dsize;       /* number of data blocks in fs */
+        __fs32  fs_ncg;         /* number of cylinder groups */
+        __fs32  fs_bsize;       /* size of basic blocks in fs */
+        __fs32  fs_fsize;       /* size of frag blocks in fs */
+        __fs32  fs_frag;        /* number of frags in a block in fs */
+/* these are configuration parameters */
+        __fs32  fs_minfree;     /* minimum percentage of free blocks */
+        __fs32  fs_rotdelay;    /* num of ms for optimal next block */
+        __fs32  fs_rps;         /* disk revolutions per second */
+/* these fields can be computed from the others */
+        __fs32  fs_bmask;       /* ``blkoff'' calc of blk offsets */
+        __fs32  fs_fmask;       /* ``fragoff'' calc of frag offsets */
+        __fs32  fs_bshift;      /* ``lblkno'' calc of logical blkno */
+        __fs32  fs_fshift;      /* ``numfrags'' calc number of frags */
+/* these are configuration parameters */
+        __fs32  fs_maxcontig;   /* max number of contiguous blks */
+        __fs32  fs_maxbpg;      /* max number of blks per cyl group */
+/* these fields can be computed from the others */
+        __fs32  fs_fragshift;   /* block to frag shift */
+        __fs32  fs_fsbtodb;     /* fsbtodb and dbtofsb shift constant */
+        __fs32  fs_sbsize;      /* actual size of super block */
+        __fs32  fs_csmask;      /* csum block offset */
+        __fs32  fs_csshift;     /* csum block number */
+        __fs32  fs_nindir;      /* value of NINDIR */
+        __fs32  fs_inopb;       /* value of INOPB */
+        __fs32  fs_nspf;        /* value of NSPF */
+/* yet another configuration parameter */
+        __fs32  fs_optim;       /* optimization preference, see below */
+/* these fields are derived from the hardware */
+        union {
+                struct {
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                } fs_sun;
+                struct {
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_sunx86;
+        } fs_u1;
+        __fs32  fs_interleave;  /* hardware sector interleave */
+        __fs32  fs_trackskew;   /* sector 0 skew, per track */
+/* a unique id for this filesystem (currently unused and unmaintained) */
+/* In 4.3 Tahoe this space is used by fs_headswitch and fs_trkseek */
+/* Neither of those fields is used in the Tahoe code right now but */
+/* there could be problems if they are.                            */
+        __fs32  fs_id[2];       /* file system id */
+/* sizes determined by number of cylinder groups and their sizes */
+        __fs32  fs_csaddr;      /* blk addr of cyl grp summary area */
+        __fs32  fs_cssize;      /* size of cyl grp summary area */
+        __fs32  fs_cgsize;      /* cylinder group size */
+/* these fields are derived from the hardware */
+        __fs32  fs_ntrak;       /* tracks per cylinder */
+        __fs32  fs_nsect;       /* sectors per track */
+        __fs32  fs_spc;         /* sectors per cylinder */
+/* this comes from the disk driver partitioning */
+        __fs32  fs_ncyl;        /* cylinders in file system */
+/* these fields can be computed from the others */
+        __fs32  fs_cpg;         /* cylinders per group */
+        __fs32  fs_ipg;         /* inodes per cylinder group */
+        __fs32  fs_fpg;         /* blocks per group * fs_frag */
+/* this data must be re-computed after crashes */
+        struct ufs_csum fs_cstotal;     /* cylinder summary information */
+/* these fields are cleared at mount time */
+        __s8    fs_fmod;        /* super block modified flag */
+        __s8    fs_clean;       /* file system is clean flag */
+        __s8    fs_ronly;       /* mounted read-only flag */
+        __s8    fs_flags;       /* currently unused flag */
+        union {
+                struct {
+                        __s8    fs_fsmnt[UFS_MAXMNTLEN];/* name mounted on */
+                        __fs32  fs_cgrotor;     /* last cg searched */
+                        __fs32  fs_csp[UFS_MAXCSBUFS];/*list of fs_cs info buffers */
+                        __fs32  fs_maxcluster;
+                        __fs32  fs_cpc;         /* cyl per cycle in postbl */
+                        __fs16  fs_opostbl[16][8]; /* old rotation block list head */
+                } fs_u1;
+                struct {
+                        __s8  fs_fsmnt[UFS2_MAXMNTLEN]; /* name mounted on */
+                        __u8   fs_volname[UFS2_MAXVOLLEN]; /* volume name */
+                        __fs64  fs_swuid;               /* system-wide uid */
+                        __fs32  fs_pad; /* due to alignment of fs_swuid */
+                        __fs32   fs_cgrotor;     /* last cg searched */
+                        __fs32   fs_ocsp[UFS2_NOCSPTRS]; /*list of fs_cs info buffers */
+                        __fs32   fs_contigdirs;/*# of contiguously allocated dirs */
+                        __fs32   fs_csp;        /* cg summary info buffer for fs_cs */
+                        __fs32   fs_maxcluster;
+                        __fs32   fs_active;/* used by snapshots to track fs */
+                        __fs32   fs_old_cpc;    /* cyl per cycle in postbl */
+                        __fs32   fs_maxbsize;/*maximum blocking factor permitted */
+                        __fs64   fs_sparecon64[17];/*old rotation block list head */
+                        __fs64   fs_sblockloc; /* byte offset of standard superblock */
+                        struct  ufs2_csum_total fs_cstotal;/*cylinder summary information*/
+                        struct  ufs_timeval    fs_time;         /* last time written */
+                        __fs64    fs_size;              /* number of blocks in fs */
+                        __fs64    fs_dsize;     /* number of data blocks in fs */
+                        __fs64   fs_csaddr;     /* blk addr of cyl grp summary area */
+                        __fs64    fs_pendingblocks;/* blocks in process of being freed */
+                        __fs32    fs_pendinginodes;/*inodes in process of being freed */
+                } fs_u2;
+        }  fs_u11;
+        union {
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_state;       /* file system state time stamp */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sun;
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sunx86;
+                struct {
+                        __fs32  fs_sparecon[50];/* reserved for future constants */
+                        __fs32  fs_contigsumsize;/* size of cluster summary array */
+                        __fs32  fs_maxsymlinklen;/* max length of an internal symlink */
+                        __fs32  fs_inodefmt;    /* format of on-disk inodes */
+                        __fs32  fs_maxfilesize[2];      /* max representable file size */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_44;
+        } fs_u2;
+        __fs32  fs_postblformat;        /* format of positional layout tables */
+        __fs32  fs_nrpos;               /* number of rotational positions */
+        __fs32  fs_postbloff;           /* (__s16) rotation block list head */
+        __fs32  fs_rotbloff;            /* (__u8) blocks for each rotation */
+        __fs32  fs_magic;               /* magic number */
+        __u8    fs_space[1];            /* list of blocks for each rotation */
+};
+
+/*
+ * Preference for optimization.
+ */
+#define UFS_OPTTIME     0       /* minimize allocation time */
+#define UFS_OPTSPACE    1       /* minimize disk fragmentation */
+
+/*
+ * Rotational layout table format types
+ */
+#define UFS_42POSTBLFMT         -1      /* 4.2BSD rotational table format */
+#define UFS_DYNAMICPOSTBLFMT    1       /* dynamic rotational table format */
+
+/*
+ * Convert cylinder group to base address of its global summary info.
+ */
+#define fs_cs(indx) \
+        s_csp[(indx) >> uspi->s_csshift][(indx) & ~uspi->s_csmask]
+
+/*
+ * Cylinder group block for a file system.
+ *
+ * Writable fields in the cylinder group are protected by the associated
+ * super block lock fs->fs_lock.
+ */
+#define CG_MAGIC        0x090255
+#define ufs_cg_chkmagic(sb, ucg) \
+        (fs32_to_cpu((sb), (ucg)->cg_magic) == CG_MAGIC)
+
+/*
+ * size of this structure is 172 B
+ */
+struct  ufs_cylinder_group {
+        __fs32  cg_link;                /* linked list of cyl groups */
+        __fs32  cg_magic;               /* magic number */
+        __fs32  cg_time;                /* time last written */
+        __fs32  cg_cgx;                 /* we are the cgx'th cylinder group */
+        __fs16  cg_ncyl;                /* number of cyl's this cg */
+        __fs16  cg_niblk;               /* number of inode blocks this cg */
+        __fs32  cg_ndblk;               /* number of data blocks this cg */
+        struct  ufs_csum cg_cs;         /* cylinder summary information */
+        __fs32  cg_rotor;               /* position of last used block */
+        __fs32  cg_frotor;              /* position of last used frag */
+        __fs32  cg_irotor;              /* position of last used inode */
+        __fs32  cg_frsum[UFS_MAXFRAG];  /* counts of available frags */
+        __fs32  cg_btotoff;             /* (__u32) block totals per cylinder */
+        __fs32  cg_boff;                /* (short) free block positions */
+        __fs32  cg_iusedoff;            /* (char) used inode map */
+        __fs32  cg_freeoff;             /* (u_char) free block map */
+        __fs32  cg_nextfreeoff;         /* (u_char) next available space */
+        union {
+                struct {
+                        __fs32  cg_clustersumoff;       /* (u_int32) counts of avail clusters */
+                        __fs32  cg_clusteroff;          /* (u_int8) free cluster map */
+                        __fs32  cg_nclusterblks;        /* number of clusters this cg */
+                        __fs32  cg_sparecon[13];        /* reserved for future use */
+                } cg_44;
+                struct {
+                        __fs32  cg_clustersumoff;/* (u_int32) counts of avail clusters */
+                        __fs32  cg_clusteroff;  /* (u_int8) free cluster map */
+                        __fs32  cg_nclusterblks;/* number of clusters this cg */
+                        __fs32   cg_niblk; /* number of inode blocks this cg */
+                        __fs32   cg_initediblk; /* last initialized inode */
+                        __fs32   cg_sparecon32[3];/* reserved for future use */
+                        __fs64   cg_time;       /* time last written */
+                        __fs64  cg_sparecon[3]; /* reserved for future use */
+                } cg_u2;
+                __fs32  cg_sparecon[16];        /* reserved for future use */
+        } cg_u;
+        __u8    cg_space[1];            /* space for cylinder group maps */
+/* actually longer */
+};
+
+/*
+ * structure of an on-disk inode
+ */
+struct ufs_inode {
+        __fs16  ui_mode;                /*  0x0 */
+        __fs16  ui_nlink;               /*  0x2 */
+        union {
+                struct {
+                        __fs16  ui_suid;        /*  0x4 */
+                        __fs16  ui_sgid;        /*  0x6 */
+                } oldids;
+                __fs32  ui_inumber;             /*  0x4 lsf: inode number */
+                __fs32  ui_author;              /*  0x4 GNU HURD: author */
+        } ui_u1;
+        __fs64  ui_size;                /*  0x8 */
+        struct ufs_timeval ui_atime;    /* 0x10 access */
+        struct ufs_timeval ui_mtime;    /* 0x18 modification */
+        struct ufs_timeval ui_ctime;    /* 0x20 creation */
+        union {
+                struct {
+                        __fs32  ui_db[UFS_NDADDR];/* 0x28 data blocks */
+                        __fs32  ui_ib[UFS_NINDIR];/* 0x58 indirect blocks */
+                } ui_addr;
+                __u8    ui_symlink[4*(UFS_NDADDR+UFS_NINDIR)];/* 0x28 fast symlink */
+        } ui_u2;
+        __fs32  ui_flags;               /* 0x64 immutable, append-only... */
+        __fs32  ui_blocks;              /* 0x68 blocks in use */
+        __fs32  ui_gen;                 /* 0x6c like ext2 i_version, for NFS support */
+        union {
+                struct {
+                        __fs32  ui_shadow;      /* 0x70 shadow inode with security data */
+                        __fs32  ui_uid;         /* 0x74 long EFT version of uid */
+                        __fs32  ui_gid;         /* 0x78 long EFT version of gid */
+                        __fs32  ui_oeftflag;    /* 0x7c reserved */
+                } ui_sun;
+                struct {
+                        __fs32  ui_uid;         /* 0x70 File owner */
+                        __fs32  ui_gid;         /* 0x74 File group */
+                        __fs32  ui_spare[2];    /* 0x78 reserved */
+                } ui_44;
+                struct {
+                        __fs32  ui_uid;         /* 0x70 */
+                        __fs32  ui_gid;         /* 0x74 */
+                        __fs16  ui_modeh;       /* 0x78 mode high bits */
+                        __fs16  ui_spare;       /* 0x7A unused */
+                        __fs32  ui_trans;       /* 0x7c filesystem translator */
+                } ui_hurd;
+        } ui_u3;
+};
+
+#define UFS_NXADDR  2            /* External addresses in inode. */
+struct ufs2_inode {
+        __fs16     ui_mode;        /*   0: IFMT, permissions; see below. */
+        __fs16     ui_nlink;       /*   2: File link count. */
+        __fs32     ui_uid;         /*   4: File owner. */
+        __fs32     ui_gid;         /*   8: File group. */
+        __fs32     ui_blksize;     /*  12: Inode blocksize. */
+        __fs64     ui_size;        /*  16: File byte count. */
+        __fs64     ui_blocks;      /*  24: Bytes actually held. */
+        struct ufs_timeval   ui_atime;       /*  32: Last access time. */
+        struct ufs_timeval   ui_mtime;       /*  40: Last modified time. */
+        struct ufs_timeval   ui_ctime;       /*  48: Last inode change time. */
+        struct ufs_timeval   ui_birthtime;   /*  56: Inode creation time. */
+        __fs32     ui_mtimensec;   /*  64: Last modified time. */
+        __fs32     ui_atimensec;   /*  68: Last access time. */
+        __fs32     ui_ctimensec;   /*  72: Last inode change time. */
+        __fs32     ui_birthnsec;   /*  76: Inode creation time. */
+        __fs32     ui_gen;         /*  80: Generation number. */
+        __fs32     ui_kernflags;   /*  84: Kernel flags. */
+        __fs32     ui_flags;       /*  88: Status flags (chflags). */
+        __fs32     ui_extsize;     /*  92: External attributes block. */
+        __fs64     ui_extb[UFS_NXADDR];/*  96: External attributes block. */
+        union {
+                struct {
+                        __fs64     ui_db[UFS_NDADDR]; /* 112: Direct disk blocks. */
+                        __fs64     ui_ib[UFS_NINDIR];/* 208: Indirect disk blocks.*/
+                } ui_addr;
+        __u8    ui_symlink[2*4*(UFS_NDADDR+UFS_NINDIR)];/* 0x28 fast symlink */
+        } ui_u2;
+        __fs64     ui_spare[3];    /* 232: Reserved; currently unused */
+};
+
+
+/* FreeBSD has these in sys/stat.h */
+/* ui_flags that can be set by a file owner */
+#define UFS_UF_SETTABLE   0x0000ffff
+#define UFS_UF_NODUMP     0x00000001  /* do not dump */
+#define UFS_UF_IMMUTABLE  0x00000002  /* immutable (can't "change") */
+#define UFS_UF_APPEND     0x00000004  /* append-only */
+#define UFS_UF_OPAQUE     0x00000008  /* directory is opaque (unionfs) */
+#define UFS_UF_NOUNLINK   0x00000010  /* can't be removed or renamed */
+/* ui_flags that only root can set */
+#define UFS_SF_SETTABLE   0xffff0000
+#define UFS_SF_ARCHIVED   0x00010000  /* archived */
+#define UFS_SF_IMMUTABLE  0x00020000  /* immutable (can't "change") */
+#define UFS_SF_APPEND     0x00040000  /* append-only */
+#define UFS_SF_NOUNLINK   0x00100000  /* can't be removed or renamed */
+
+/*
+ * This structure is used for reading disk structures larger
+ * than the size of fragment.
+ */
+struct ufs_buffer_head {
+        __u64 fragment;                 /* first fragment */
+        __u64 count;                            /* number of fragments */
+        struct buffer_head * bh[UFS_MAXFRAG];   /* buffers */
+};
+
+struct ufs_cg_private_info {
+        struct ufs_cylinder_group ucg;
+        __u32   c_cgx;          /* number of cylidner group */
+        __u16   c_ncyl;         /* number of cyl's this cg */
+        __u16   c_niblk;        /* number of inode blocks this cg */
+        __u32   c_ndblk;        /* number of data blocks this cg */
+        __u32   c_rotor;        /* position of last used block */
+        __u32   c_frotor;       /* position of last used frag */
+        __u32   c_irotor;       /* position of last used inode */
+        __u32   c_btotoff;      /* (__u32) block totals per cylinder */
+        __u32   c_boff;         /* (short) free block positions */
+        __u32   c_iusedoff;     /* (char) used inode map */
+        __u32   c_freeoff;      /* (u_char) free block map */
+        __u32   c_nextfreeoff;  /* (u_char) next available space */
+        __u32   c_clustersumoff;/* (u_int32) counts of avail clusters */
+        __u32   c_clusteroff;   /* (u_int8) free cluster map */
+        __u32   c_nclusterblks; /* number of clusters this cg */
+};      
+
+struct ufs_sb_private_info {
+        struct ufs_buffer_head s_ubh; /* buffer containing super block */
+        __u32   s_sblkno;       /* offset of super-blocks in filesys */
+        __u32   s_cblkno;       /* offset of cg-block in filesys */
+        __u32   s_iblkno;       /* offset of inode-blocks in filesys */
+        __u32   s_dblkno;       /* offset of first data after cg */
+        __u32   s_cgoffset;     /* cylinder group offset in cylinder */
+        __u32   s_cgmask;       /* used to calc mod fs_ntrak */
+        __u32   s_size;         /* number of blocks (fragments) in fs */
+        __u32   s_dsize;        /* number of data blocks in fs */
+        __u64   s_u2_size;      /* ufs2: number of blocks (fragments) in fs */
+        __u64   s_u2_dsize;     /*ufs2:  number of data blocks in fs */
+        __u32   s_ncg;          /* number of cylinder groups */
+        __u32   s_bsize;        /* size of basic blocks */
+        __u32   s_fsize;        /* size of fragments */
+        __u32   s_fpb;          /* fragments per block */
+        __u32   s_minfree;      /* minimum percentage of free blocks */
+        __u32   s_bmask;        /* `blkoff'' calc of blk offsets */
+        __u32   s_fmask;        /* s_fsize mask */
+        __u32   s_bshift;       /* `lblkno'' calc of logical blkno */
+        __u32   s_fshift;       /* s_fsize shift */
+        __u32   s_fpbshift;     /* fragments per block shift */
+        __u32   s_fsbtodb;      /* fsbtodb and dbtofsb shift constant */
+        __u32   s_sbsize;       /* actual size of super block */
+        __u32   s_csmask;       /* csum block offset */
+        __u32   s_csshift;      /* csum block number */
+        __u32   s_nindir;       /* value of NINDIR */
+        __u32   s_inopb;        /* value of INOPB */
+        __u32   s_nspf;         /* value of NSPF */
+        __u32   s_npsect;       /* # sectors/track including spares */
+        __u32   s_interleave;   /* hardware sector interleave */
+        __u32   s_trackskew;    /* sector 0 skew, per track */
+        __u32   s_csaddr;       /* blk addr of cyl grp summary area */
+        __u32   s_cssize;       /* size of cyl grp summary area */
+        __u32   s_cgsize;       /* cylinder group size */
+        __u32   s_ntrak;        /* tracks per cylinder */
+        __u32   s_nsect;        /* sectors per track */
+        __u32   s_spc;          /* sectors per cylinder */
+        __u32   s_ipg;          /* inodes per cylinder group */
+        __u32   s_fpg;          /* fragments per group */
+        __u32   s_cpc;          /* cyl per cycle in postbl */
+        __s32   s_contigsumsize;/* size of cluster summary array, 44bsd */
+        __s64   s_qbmask;       /* ~usb_bmask */
+        __s64   s_qfmask;       /* ~usb_fmask */
+        __s32   s_postblformat; /* format of positional layout tables */
+        __s32   s_nrpos;        /* number of rotational positions */
+        __s32   s_postbloff;    /* (__s16) rotation block list head */
+        __s32   s_rotbloff;     /* (__u8) blocks for each rotation */
+
+        __u32   s_fpbmask;      /* fragments per block mask */
+        __u32   s_apb;          /* address per block */
+        __u32   s_2apb;         /* address per block^2 */
+        __u32   s_3apb;         /* address per block^3 */
+        __u32   s_apbmask;      /* address per block mask */
+        __u32   s_apbshift;     /* address per block shift */
+        __u32   s_2apbshift;    /* address per block shift * 2 */
+        __u32   s_3apbshift;    /* address per block shift * 3 */
+        __u32   s_nspfshift;    /* number of sector per fragment shift */
+        __u32   s_nspb;         /* number of sector per block */
+        __u32   s_inopf;        /* inodes per fragment */
+        __u32   s_sbbase;       /* offset of NeXTstep superblock */
+        __u32   s_bpf;          /* bits per fragment */
+        __u32   s_bpfshift;     /* bits per fragment shift*/
+        __u32   s_bpfmask;      /* bits per fragment mask */
+
+        __u32   s_maxsymlinklen;/* upper limit on fast symlinks' size */
+        __s32   fs_magic;       /* filesystem magic */
+};
+
+/*
+ * Sizes of this structures are:
+ *      ufs_super_block_first   512
+ *      ufs_super_block_second  512
+ *      ufs_super_block_third   356
+ */
+struct ufs_super_block_first {
+        __fs32  fs_link;
+        __fs32  fs_rlink;
+        __fs32  fs_sblkno;
+        __fs32  fs_cblkno;
+        __fs32  fs_iblkno;
+        __fs32  fs_dblkno;
+        __fs32  fs_cgoffset;
+        __fs32  fs_cgmask;
+        __fs32  fs_time;
+        __fs32  fs_size;
+        __fs32  fs_dsize;
+        __fs32  fs_ncg;
+        __fs32  fs_bsize;
+        __fs32  fs_fsize;
+        __fs32  fs_frag;
+        __fs32  fs_minfree;
+        __fs32  fs_rotdelay;
+        __fs32  fs_rps;
+        __fs32  fs_bmask;
+        __fs32  fs_fmask;
+        __fs32  fs_bshift;
+        __fs32  fs_fshift;
+        __fs32  fs_maxcontig;
+        __fs32  fs_maxbpg;
+        __fs32  fs_fragshift;
+        __fs32  fs_fsbtodb;
+        __fs32  fs_sbsize;
+        __fs32  fs_csmask;
+        __fs32  fs_csshift;
+        __fs32  fs_nindir;
+        __fs32  fs_inopb;
+        __fs32  fs_nspf;
+        __fs32  fs_optim;
+        union {
+                struct {
+                        __fs32  fs_npsect;
+                } fs_sun;
+                struct {
+                        __fs32  fs_state;
+                } fs_sunx86;
+        } fs_u1;
+        __fs32  fs_interleave;
+        __fs32  fs_trackskew;
+        __fs32  fs_id[2];
+        __fs32  fs_csaddr;
+        __fs32  fs_cssize;
+        __fs32  fs_cgsize;
+        __fs32  fs_ntrak;
+        __fs32  fs_nsect;
+        __fs32  fs_spc;
+        __fs32  fs_ncyl;
+        __fs32  fs_cpg;
+        __fs32  fs_ipg;
+        __fs32  fs_fpg;
+        struct ufs_csum fs_cstotal;
+        __s8    fs_fmod;
+        __s8    fs_clean;
+        __s8    fs_ronly;
+        __s8    fs_flags;
+        __s8    fs_fsmnt[UFS_MAXMNTLEN - 212];
+
+};
+
+struct ufs_super_block_second {
+        __s8    fs_fsmnt[212];
+        __fs32  fs_cgrotor;
+        __fs32  fs_csp[UFS_MAXCSBUFS];
+        __fs32  fs_maxcluster;
+        __fs32  fs_cpc;
+        __fs16  fs_opostbl[82];
+};      
+
+struct ufs_super_block_third {
+        __fs16  fs_opostbl[46];
+        union {
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_state;       /* file system state time stamp */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sun;
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sunx86;
+                struct {
+                        __fs32  fs_sparecon[50];/* reserved for future constants */
+                        __fs32  fs_contigsumsize;/* size of cluster summary array */
+                        __fs32  fs_maxsymlinklen;/* max length of an internal symlink */
+                        __fs32  fs_inodefmt;    /* format of on-disk inodes */
+                        __fs32  fs_maxfilesize[2];      /* max representable file size */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_44;
+        } fs_u2;
+        __fs32  fs_postblformat;
+        __fs32  fs_nrpos;
+        __fs32  fs_postbloff;
+        __fs32  fs_rotbloff;
+        __fs32  fs_magic;
+        __u8    fs_space[1];
+};
+
+#ifdef __KERNEL__
+
+/* balloc.c */
+extern void ufs_free_fragments (struct inode *, unsigned, unsigned);
+extern void ufs_free_blocks (struct inode *, unsigned, unsigned);
+extern unsigned ufs_new_fragments (struct inode *, __fs32 *, unsigned, unsigned, unsigned, int *);
+
+/* cylinder.c */
+extern struct ufs_cg_private_info * ufs_load_cylinder (struct super_block *, unsigned);
+extern void ufs_put_cylinder (struct super_block *, unsigned);
+
+/* dir.c */
+extern struct inode_operations ufs_dir_inode_operations;
+extern int ufs_add_link (struct dentry *, struct inode *);
+extern ino_t ufs_inode_by_name(struct inode *, struct dentry *);
+extern int ufs_make_empty(struct inode *, struct inode *);
+extern struct ufs_dir_entry * ufs_find_entry (struct dentry *, struct buffer_head **);
+extern int ufs_delete_entry (struct inode *, struct ufs_dir_entry *, struct buffer_head *);
+extern int ufs_empty_dir (struct inode *);
+extern struct ufs_dir_entry * ufs_dotdot (struct inode *, struct buffer_head **);
+extern void ufs_set_link(struct inode *, struct ufs_dir_entry *, struct buffer_head *, struct inode *);
+
+/* file.c */
+extern struct inode_operations ufs_file_inode_operations;
+extern struct file_operations ufs_file_operations;
+
+extern struct address_space_operations ufs_aops;
+
+/* ialloc.c */
+extern void ufs_free_inode (struct inode *inode);
+extern struct inode * ufs_new_inode (struct inode *, int);
+
+/* inode.c */
+extern u64  ufs_frag_map (struct inode *, sector_t);
+extern void ufs_read_inode (struct inode *);
+extern void ufs_put_inode (struct inode *);
+extern int ufs_write_inode (struct inode *, int);
+extern int ufs_sync_inode (struct inode *);
+extern void ufs_delete_inode (struct inode *);
+extern struct buffer_head * ufs_getfrag (struct inode *, unsigned, int, int *);
+extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
+
+/* namei.c */
+extern struct file_operations ufs_dir_operations;
+        
+/* super.c */
+extern void ufs_warning (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern void ufs_error (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+extern void ufs_panic (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
+
+/* symlink.c */
+extern struct inode_operations ufs_fast_symlink_inode_operations;
+
+/* truncate.c */
+extern void ufs_truncate (struct inode *);
+
+static inline struct ufs_sb_info *UFS_SB(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+
+static inline struct ufs_inode_info *UFS_I(struct inode *inode)
+{
+        return container_of(inode, struct ufs_inode_info, vfs_inode);
+}
+
+#endif  /* __KERNEL__ */
+
+#endif /* __LINUX_UFS_FS_H */
diff --git a/include/linux/ufs_fs_i.h b/include/linux/ufs_fs_i.h
new file mode 100644
index 000000000000..21665a953978
--- /dev/null
+++ b/include/linux/ufs_fs_i.h
@@ -0,0 +1,33 @@
+/*
+ *  linux/include/linux/ufs_fs_i.h
+ *
+ * Copyright (C) 1996
+ * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
+ * Laboratory for Computer Science Research Computing Facility
+ * Rutgers, The State University of New Jersey
+ *
+ * NeXTstep support added on February 5th 1998 by
+ * Niels Kristian Bech Jensen <nkbj@image.dk>.
+ */
+
+#ifndef _LINUX_UFS_FS_I_H
+#define _LINUX_UFS_FS_I_H
+
+struct ufs_inode_info {
+        union {
+                __fs32  i_data[15];
+                __u8    i_symlink[4*15];
+                __fs64  u2_i_data[15];
+        } i_u1;
+        __u32   i_flags;
+        __u32   i_gen;
+        __u32   i_shadow;
+        __u32   i_unused1;
+        __u32   i_unused2;
+        __u32   i_oeftflag;
+        __u16   i_osync;
+        __u32   i_lastfrag;
+        struct inode vfs_inode;
+};
+
+#endif /* _LINUX_UFS_FS_I_H */
diff --git a/include/linux/ufs_fs_sb.h b/include/linux/ufs_fs_sb.h
new file mode 100644
index 000000000000..c1be4c226486
--- /dev/null
+++ b/include/linux/ufs_fs_sb.h
@@ -0,0 +1,38 @@
+/* 
+ *  linux/include/linux/ufs_fs_sb.h
+ *
+ * Copyright (C) 1996
+ * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
+ * Laboratory for Computer Science Research Computing Facility
+ * Rutgers, The State University of New Jersey
+ *
+ * $Id: ufs_fs_sb.h,v 1.8 1998/05/06 12:04:40 jj Exp $
+ *
+ * Write support by Daniel Pirkl <daniel.pirkl@email.cz>
+ */
+
+#ifndef __LINUX_UFS_FS_SB_H
+#define __LINUX_UFS_FS_SB_H
+
+
+#define UFS_MAX_GROUP_LOADED 8
+#define UFS_CGNO_EMPTY ((unsigned)-1)
+
+struct ufs_sb_private_info;
+struct ufs_cg_private_info;
+struct ufs_csum;
+#define UFS_MAXCSBUFS 31
+
+struct ufs_sb_info {
+        struct ufs_sb_private_info * s_uspi;    
+        struct ufs_csum * s_csp[UFS_MAXCSBUFS];
+        unsigned s_bytesex;
+        unsigned s_flags;
+        struct buffer_head ** s_ucg;
+        struct ufs_cg_private_info * s_ucpi[UFS_MAX_GROUP_LOADED]; 
+        unsigned s_cgno[UFS_MAX_GROUP_LOADED];
+        unsigned short s_cg_loaded;
+        unsigned s_mount_opt;
+};
+
+#endif
diff --git a/include/linux/uinput.h b/include/linux/uinput.h
new file mode 100644
index 000000000000..4c2c82336d10
--- /dev/null
+++ b/include/linux/uinput.h
@@ -0,0 +1,167 @@
+#ifndef __UINPUT_H_
+#define __UINPUT_H_
+/*
+ *  User level driver support for input subsystem
+ *
+ * Heavily based on evdev.c by Vojtech Pavlik
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
+ * 
+ * Changes/Revisions:
+ *      0.2     16/10/2004 (Micah Dowty <micah@navi.cx>)
+ *              - added force feedback support
+ *             - added UI_SET_PHYS
+ *      0.1     20/06/2002
+ *              - first public version
+ */
+#ifdef __KERNEL__
+#define UINPUT_MINOR            223
+#define UINPUT_NAME             "uinput"
+#define UINPUT_BUFFER_SIZE      16
+#define UINPUT_NUM_REQUESTS     16
+
+/* state flags => bit index for {set|clear|test}_bit ops */
+#define UIST_CREATED            0
+
+struct uinput_request {
+        int                     id;
+        int                     code;   /* UI_FF_UPLOAD, UI_FF_ERASE */
+
+        int                     retval;
+        wait_queue_head_t       waitq;
+        int                     completed;
+
+        union {
+                int             effect_id;
+                struct ff_effect* effect;
+        } u;
+};
+
+struct uinput_device {
+        struct input_dev        *dev;
+        unsigned long           state;
+        wait_queue_head_t       waitq;
+        unsigned char           ready,
+                                head,
+                                tail;
+        struct input_event      buff[UINPUT_BUFFER_SIZE];
+
+        struct uinput_request   *requests[UINPUT_NUM_REQUESTS];
+        wait_queue_head_t       requests_waitq;
+        struct semaphore        requests_sem;
+};
+#endif  /* __KERNEL__ */
+
+struct uinput_ff_upload {
+        int                     request_id;
+        int                     retval;
+        struct ff_effect        effect;
+};
+
+struct uinput_ff_erase {
+        int                     request_id;
+        int                     retval;
+        int                     effect_id;
+};
+
+/* ioctl */
+#define UINPUT_IOCTL_BASE       'U'
+#define UI_DEV_CREATE           _IO(UINPUT_IOCTL_BASE, 1)
+#define UI_DEV_DESTROY          _IO(UINPUT_IOCTL_BASE, 2)
+
+#define UI_SET_EVBIT            _IOW(UINPUT_IOCTL_BASE, 100, int)
+#define UI_SET_KEYBIT           _IOW(UINPUT_IOCTL_BASE, 101, int)
+#define UI_SET_RELBIT           _IOW(UINPUT_IOCTL_BASE, 102, int)
+#define UI_SET_ABSBIT           _IOW(UINPUT_IOCTL_BASE, 103, int)
+#define UI_SET_MSCBIT           _IOW(UINPUT_IOCTL_BASE, 104, int)
+#define UI_SET_LEDBIT           _IOW(UINPUT_IOCTL_BASE, 105, int)
+#define UI_SET_SNDBIT           _IOW(UINPUT_IOCTL_BASE, 106, int)
+#define UI_SET_FFBIT            _IOW(UINPUT_IOCTL_BASE, 107, int)
+#define UI_SET_PHYS             _IOW(UINPUT_IOCTL_BASE, 108, char*)
+
+#define UI_BEGIN_FF_UPLOAD      _IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload)
+#define UI_END_FF_UPLOAD        _IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload)
+#define UI_BEGIN_FF_ERASE       _IOWR(UINPUT_IOCTL_BASE, 202, struct uinput_ff_erase)
+#define UI_END_FF_ERASE         _IOW(UINPUT_IOCTL_BASE, 203, struct uinput_ff_erase)
+
+/* To write a force-feedback-capable driver, the upload_effect
+ * and erase_effect callbacks in input_dev must be implemented.
+ * The uinput driver will generate a fake input event when one of
+ * these callbacks are invoked. The userspace code then uses
+ * ioctls to retrieve additional parameters and send the return code.
+ * The callback blocks until this return code is sent.
+ *
+ * The described callback mechanism is only used if EV_FF is set.
+ * Otherwise, default implementations of upload_effect and erase_effect
+ * are used.
+ *
+ * To implement upload_effect():
+ *   1. Wait for an event with type==EV_UINPUT and code==UI_FF_UPLOAD.
+ *      A request ID will be given in 'value'.
+ *   2. Allocate a uinput_ff_upload struct, fill in request_id with
+ *      the 'value' from the EV_UINPUT event.
+ *   3. Issue a UI_BEGIN_FF_UPLOAD ioctl, giving it the
+ *      uinput_ff_upload struct. It will be filled in with the
+ *      ff_effect passed to upload_effect().
+ *   4. Perform the effect upload, and place the modified ff_effect
+ *      and a return code back into the uinput_ff_upload struct.
+ *   5. Issue a UI_END_FF_UPLOAD ioctl, also giving it the
+ *      uinput_ff_upload_effect struct. This will complete execution
+ *      of our upload_effect() handler.
+ *
+ * To implement erase_effect():
+ *   1. Wait for an event with type==EV_UINPUT and code==UI_FF_ERASE.
+ *      A request ID will be given in 'value'.
+ *   2. Allocate a uinput_ff_erase struct, fill in request_id with
+ *      the 'value' from the EV_UINPUT event.
+ *   3. Issue a UI_BEGIN_FF_ERASE ioctl, giving it the
+ *      uinput_ff_erase struct. It will be filled in with the
+ *      effect ID passed to erase_effect().
+ *   4. Perform the effect erasure, and place a return code back
+ *      into the uinput_ff_erase struct.
+ *      and a return code back into the uinput_ff_erase struct.
+ *   5. Issue a UI_END_FF_ERASE ioctl, also giving it the
+ *      uinput_ff_erase_effect struct. This will complete execution
+ *      of our erase_effect() handler.
+ */
+
+/* This is the new event type, used only by uinput.
+ * 'code' is UI_FF_UPLOAD or UI_FF_ERASE, and 'value'
+ * is the unique request ID. This number was picked
+ * arbitrarily, above EV_MAX (since the input system
+ * never sees it) but in the range of a 16-bit int.
+ */
+#define EV_UINPUT               0x0101
+#define UI_FF_UPLOAD            1
+#define UI_FF_ERASE             2
+
+#ifndef NBITS
+#define NBITS(x) ((((x)-1)/(sizeof(long)*8))+1)
+#endif  /* NBITS */
+
+#define UINPUT_MAX_NAME_SIZE    80
+struct uinput_user_dev {
+        char name[UINPUT_MAX_NAME_SIZE];
+        struct input_id id;
+        int ff_effects_max;
+        int absmax[ABS_MAX + 1];
+        int absmin[ABS_MAX + 1];
+        int absfuzz[ABS_MAX + 1];
+        int absflat[ABS_MAX + 1];
+};
+#endif  /* __UINPUT_H_ */
+
diff --git a/include/linux/uio.h b/include/linux/uio.h
new file mode 100644
index 000000000000..9af8bbcd8963
--- /dev/null
+++ b/include/linux/uio.h
@@ -0,0 +1,66 @@
+#ifndef __LINUX_UIO_H
+#define __LINUX_UIO_H
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+/*
+ *      Berkeley style UIO structures   -       Alan Cox 1994.
+ *
+ *              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; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+
+
+/* A word of warning: Our uio structure will clash with the C library one (which is now obsolete). Remove the C
+   library one from sys/uio.h if you have a very old library set */
+
+struct iovec
+{
+        void __user *iov_base;  /* BSD uses caddr_t (1003.1g requires void *) */
+        __kernel_size_t iov_len; /* Must be size_t (1003.1g) */
+};
+
+#ifdef __KERNEL__
+
+struct kvec {
+        void *iov_base; /* and that should *never* hold a userland pointer */
+        size_t iov_len;
+};
+
+#endif
+
+/*
+ *      UIO_MAXIOV shall be at least 16 1003.1g (5.4.1.1)
+ */
+ 
+#define UIO_FASTIOV     8
+#define UIO_MAXIOV      1024
+#if 0
+#define UIO_MAXIOV      16      /* Maximum iovec's in one operation 
+                                   16 matches BSD */
+                                /* Beg pardon: BSD has 1024 --ANK */
+#endif
+
+/*
+ * Total number of bytes covered by an iovec.
+ *
+ * NOTE that it is not safe to use this function until all the iovec's
+ * segment lengths have been validated.  Because the individual lengths can
+ * overflow a size_t when added together.
+ */
+static inline size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
+{
+        unsigned long seg;
+        size_t ret = 0;
+
+        for (seg = 0; seg < nr_segs; seg++)
+                ret += iov[seg].iov_len;
+        return ret;
+}
+
+unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to);
+
+#endif
diff --git a/include/linux/ultrasound.h b/include/linux/ultrasound.h
new file mode 100644
index 000000000000..6b7703e75cec
--- /dev/null
+++ b/include/linux/ultrasound.h
@@ -0,0 +1,103 @@
+#ifndef _ULTRASOUND_H_
+#define _ULTRASOUND_H_
+/*
+ *      ultrasound.h - Macros for programming the Gravis Ultrasound
+ *                      These macros are extremely device dependent
+ *                      and not portable.
+ */
+/*
+ * Copyright (C) by Hannu Savolainen 1993-1997
+ *
+ * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
+ * Version 2 (June 1991). See the "COPYING" file distributed with this software
+ * for more info.
+ */
+
+
+/*
+ *      Private events for Gravis Ultrasound (GUS)
+ *
+ *      Format:
+ *              byte 0          - SEQ_PRIVATE (0xfe)
+ *              byte 1          - Synthesizer device number (0-N)
+ *              byte 2          - Command (see below)
+ *              byte 3          - Voice number (0-31)
+ *              bytes 4 and 5   - parameter P1 (unsigned short)
+ *              bytes 6 and 7   - parameter P2 (unsigned short)
+ *
+ *      Commands:
+ *              Each command affects one voice defined in byte 3.
+ *              Unused parameters (P1 and/or P2 *MUST* be initialized to zero).
+ *              _GUS_NUMVOICES  - Sets max. number of concurrent voices (P1=14-31, default 16)
+ *              _GUS_VOICESAMPLE- ************ OBSOLETE *************
+ *              _GUS_VOICEON    - Starts voice (P1=voice mode)
+ *              _GUS_VOICEOFF   - Stops voice (no parameters)
+ *              _GUS_VOICEFADE  - Stops the voice smoothly.
+ *              _GUS_VOICEMODE  - Alters the voice mode, don't start or stop voice (P1=voice mode)
+ *              _GUS_VOICEBALA  - Sets voice balence (P1, 0=left, 7=middle and 15=right, default 7)
+ *              _GUS_VOICEFREQ  - Sets voice (sample) playback frequency (P1=Hz)
+ *              _GUS_VOICEVOL   - Sets voice volume (P1=volume, 0xfff=max, 0xeff=half, 0x000=off)
+ *              _GUS_VOICEVOL2  - Sets voice volume (P1=volume, 0xfff=max, 0xeff=half, 0x000=off)
+ *                                (Like GUS_VOICEVOL but doesn't change the hw
+ *                                volume. It just updates volume in the voice table).
+ *
+ *              _GUS_RAMPRANGE  - Sets limits for volume ramping (P1=low volume, P2=high volume)
+ *              _GUS_RAMPRATE   - Sets the speed for volume ramping (P1=scale, P2=rate)
+ *              _GUS_RAMPMODE   - Sets the volume ramping mode (P1=ramping mode)
+ *              _GUS_RAMPON     - Starts volume ramping (no parameters)
+ *              _GUS_RAMPOFF    - Stops volume ramping (no parameters)
+ *              _GUS_VOLUME_SCALE - Changes the volume calculation constants
+ *                                for all voices.
+ */
+
+#define _GUS_NUMVOICES          0x00
+#define _GUS_VOICESAMPLE        0x01    /* OBSOLETE */
+#define _GUS_VOICEON            0x02
+#define _GUS_VOICEOFF           0x03
+#define _GUS_VOICEMODE          0x04
+#define _GUS_VOICEBALA          0x05
+#define _GUS_VOICEFREQ          0x06
+#define _GUS_VOICEVOL           0x07
+#define _GUS_RAMPRANGE          0x08
+#define _GUS_RAMPRATE           0x09
+#define _GUS_RAMPMODE           0x0a
+#define _GUS_RAMPON             0x0b
+#define _GUS_RAMPOFF            0x0c
+#define _GUS_VOICEFADE          0x0d
+#define _GUS_VOLUME_SCALE       0x0e
+#define _GUS_VOICEVOL2          0x0f
+#define _GUS_VOICE_POS          0x10
+
+/*
+ *      GUS API macros
+ */
+
+#define _GUS_CMD(chn, voice, cmd, p1, p2) \
+                                        {_SEQ_NEEDBUF(8); _seqbuf[_seqbufptr] = SEQ_PRIVATE;\
+                                        _seqbuf[_seqbufptr+1] = (chn); _seqbuf[_seqbufptr+2] = cmd;\
+                                        _seqbuf[_seqbufptr+3] = voice;\
+                                        *(unsigned short*)&_seqbuf[_seqbufptr+4] = p1;\
+                                        *(unsigned short*)&_seqbuf[_seqbufptr+6] = p2;\
+                                        _SEQ_ADVBUF(8);}
+
+#define GUS_NUMVOICES(chn, p1)                  _GUS_CMD(chn, 0, _GUS_NUMVOICES, (p1), 0)
+#define GUS_VOICESAMPLE(chn, voice, p1)         _GUS_CMD(chn, voice, _GUS_VOICESAMPLE, (p1), 0) /* OBSOLETE */
+#define GUS_VOICEON(chn, voice, p1)             _GUS_CMD(chn, voice, _GUS_VOICEON, (p1), 0)
+#define GUS_VOICEOFF(chn, voice)                _GUS_CMD(chn, voice, _GUS_VOICEOFF, 0, 0)
+#define GUS_VOICEFADE(chn, voice)               _GUS_CMD(chn, voice, _GUS_VOICEFADE, 0, 0)
+#define GUS_VOICEMODE(chn, voice, p1)           _GUS_CMD(chn, voice, _GUS_VOICEMODE, (p1), 0)
+#define GUS_VOICEBALA(chn, voice, p1)           _GUS_CMD(chn, voice, _GUS_VOICEBALA, (p1), 0)
+#define GUS_VOICEFREQ(chn, voice, p)            _GUS_CMD(chn, voice, _GUS_VOICEFREQ, \
+                                                        (p) & 0xffff, ((p) >> 16) & 0xffff)
+#define GUS_VOICEVOL(chn, voice, p1)            _GUS_CMD(chn, voice, _GUS_VOICEVOL, (p1), 0)
+#define GUS_VOICEVOL2(chn, voice, p1)           _GUS_CMD(chn, voice, _GUS_VOICEVOL2, (p1), 0)
+#define GUS_RAMPRANGE(chn, voice, low, high)    _GUS_CMD(chn, voice, _GUS_RAMPRANGE, (low), (high))
+#define GUS_RAMPRATE(chn, voice, p1, p2)        _GUS_CMD(chn, voice, _GUS_RAMPRATE, (p1), (p2))
+#define GUS_RAMPMODE(chn, voice, p1)            _GUS_CMD(chn, voice, _GUS_RAMPMODE, (p1), 0)
+#define GUS_RAMPON(chn, voice, p1)              _GUS_CMD(chn, voice, _GUS_RAMPON, (p1), 0)
+#define GUS_RAMPOFF(chn, voice)                 _GUS_CMD(chn, voice, _GUS_RAMPOFF, 0, 0)
+#define GUS_VOLUME_SCALE(chn, voice, p1, p2)    _GUS_CMD(chn, voice, _GUS_VOLUME_SCALE, (p1), (p2))
+#define GUS_VOICE_POS(chn, voice, p)            _GUS_CMD(chn, voice, _GUS_VOICE_POS, \
+                                                        (p) & 0xffff, ((p) >> 16) & 0xffff)
+
+#endif
diff --git a/include/linux/umem.h b/include/linux/umem.h
new file mode 100644
index 000000000000..f36ebfc32bf6
--- /dev/null
+++ b/include/linux/umem.h
@@ -0,0 +1,138 @@
+
+/*
+ * This file contains defines for the
+ *   Micro Memory MM5415
+ * family PCI Memory Module with Battery Backup.
+ *
+ * Copyright Micro Memory INC 2001.  All rights reserved.
+ * Release under the terms of the GNU GENERAL PUBLIC LICENSE version 2.
+ * See the file COPYING.
+ */
+
+#ifndef _DRIVERS_BLOCK_MM_H
+#define _DRIVERS_BLOCK_MM_H
+
+
+#define IRQ_TIMEOUT (1 * HZ)
+
+/* CSR register definition */
+#define MEMCTRLSTATUS_MAGIC     0x00
+#define  MM_MAGIC_VALUE         (unsigned char)0x59
+
+#define MEMCTRLSTATUS_BATTERY   0x04
+#define  BATTERY_1_DISABLED     0x01
+#define  BATTERY_1_FAILURE      0x02
+#define  BATTERY_2_DISABLED     0x04
+#define  BATTERY_2_FAILURE      0x08
+
+#define MEMCTRLSTATUS_MEMORY    0x07
+#define  MEM_128_MB             0xfe
+#define  MEM_256_MB             0xfc
+#define  MEM_512_MB             0xf8
+#define  MEM_1_GB               0xf0
+#define  MEM_2_GB               0xe0
+
+#define MEMCTRLCMD_LEDCTRL      0x08
+#define  LED_REMOVE             2
+#define  LED_FAULT              4
+#define  LED_POWER              6
+#define  LED_FLIP               255
+#define  LED_OFF                0x00
+#define  LED_ON                 0x01
+#define  LED_FLASH_3_5          0x02
+#define  LED_FLASH_7_0          0x03
+#define  LED_POWER_ON           0x00
+#define  LED_POWER_OFF          0x01
+#define  USER_BIT1              0x01
+#define  USER_BIT2              0x02
+
+#define MEMORY_INITIALIZED      USER_BIT1
+
+#define MEMCTRLCMD_ERRCTRL      0x0C
+#define  EDC_NONE_DEFAULT       0x00
+#define  EDC_NONE               0x01
+#define  EDC_STORE_READ         0x02
+#define  EDC_STORE_CORRECT      0x03
+
+#define MEMCTRLCMD_ERRCNT       0x0D
+#define MEMCTRLCMD_ERRSTATUS    0x0E
+
+#define ERROR_DATA_LOG          0x20
+#define ERROR_ADDR_LOG          0x28
+#define ERROR_COUNT             0x3D
+#define ERROR_SYNDROME          0x3E
+#define ERROR_CHECK             0x3F
+
+#define DMA_PCI_ADDR            0x40
+#define DMA_LOCAL_ADDR          0x48
+#define DMA_TRANSFER_SIZE       0x50
+#define DMA_DESCRIPTOR_ADDR     0x58
+#define DMA_SEMAPHORE_ADDR      0x60
+#define DMA_STATUS_CTRL         0x68
+#define  DMASCR_GO              0x00001
+#define  DMASCR_TRANSFER_READ   0x00002
+#define  DMASCR_CHAIN_EN        0x00004
+#define  DMASCR_SEM_EN          0x00010
+#define  DMASCR_DMA_COMP_EN     0x00020
+#define  DMASCR_CHAIN_COMP_EN   0x00040
+#define  DMASCR_ERR_INT_EN      0x00080
+#define  DMASCR_PARITY_INT_EN   0x00100
+#define  DMASCR_ANY_ERR         0x00800
+#define  DMASCR_MBE_ERR         0x01000
+#define  DMASCR_PARITY_ERR_REP  0x02000
+#define  DMASCR_PARITY_ERR_DET  0x04000
+#define  DMASCR_SYSTEM_ERR_SIG  0x08000
+#define  DMASCR_TARGET_ABT      0x10000
+#define  DMASCR_MASTER_ABT      0x20000
+#define  DMASCR_DMA_COMPLETE    0x40000
+#define  DMASCR_CHAIN_COMPLETE  0x80000
+
+/* 
+3.SOME PCs HAVE HOST BRIDGES WHICH APPARENTLY DO NOT CORRECTLY HANDLE 
+READ-LINE (0xE) OR READ-MULTIPLE (0xC) PCI COMMAND CODES DURING DMA 
+TRANSFERS. IN OTHER SYSTEMS THESE COMMAND CODES WILL CAUSE THE HOST BRIDGE 
+TO ALLOW LONGER BURSTS DURING DMA READ OPERATIONS. THE UPPER FOUR BITS 
+(31..28) OF THE DMA CSR HAVE BEEN MADE PROGRAMMABLE, SO THAT EITHER A 0x6, 
+AN 0xE OR A 0xC CAN BE WRITTEN TO THEM TO SET THE COMMAND CODE USED DURING 
+DMA READ OPERATIONS.
+*/
+#define        DMASCR_READ   0x60000000
+#define        DMASCR_READLINE   0xE0000000
+#define        DMASCR_READMULTI   0xC0000000
+
+
+#define DMASCR_ERROR_MASK       (DMASCR_MASTER_ABT | DMASCR_TARGET_ABT | DMASCR_SYSTEM_ERR_SIG | DMASCR_PARITY_ERR_DET | DMASCR_MBE_ERR | DMASCR_ANY_ERR)
+#define DMASCR_HARD_ERROR       (DMASCR_MASTER_ABT | DMASCR_TARGET_ABT | DMASCR_SYSTEM_ERR_SIG | DMASCR_PARITY_ERR_DET | DMASCR_MBE_ERR)
+
+#define WINDOWMAP_WINNUM        0x7B
+
+#define DMA_READ_FROM_HOST 0
+#define DMA_WRITE_TO_HOST 1
+
+struct mm_dma_desc {
+        __le64  pci_addr;
+        __le64  local_addr;
+        __le32  transfer_size;
+        u32     zero1;
+        __le64  next_desc_addr;
+        __le64  sem_addr;
+        __le32  control_bits;
+        u32     zero2;
+
+        dma_addr_t data_dma_handle;
+
+        /* Copy of the bits */
+        __le64  sem_control_bits;
+} __attribute__((aligned(8)));
+
+#define PCI_VENDOR_ID_MICRO_MEMORY              0x1332
+#define PCI_DEVICE_ID_MICRO_MEMORY_5415CN       0x5415
+#define PCI_DEVICE_ID_MICRO_MEMORY_5425CN       0x5425
+#define PCI_DEVICE_ID_MICRO_MEMORY_6155         0x6155
+
+/* bits for card->flags */
+#define UM_FLAG_DMA_IN_REGS             1
+#define UM_FLAG_NO_BYTE_STATUS          2
+#define UM_FLAG_NO_BATTREG              4
+#define UM_FLAG_NO_BATT                 8
+#endif
diff --git a/include/linux/un.h b/include/linux/un.h
new file mode 100644
index 000000000000..45561c564b8e
--- /dev/null
+++ b/include/linux/un.h
@@ -0,0 +1,11 @@
+#ifndef _LINUX_UN_H
+#define _LINUX_UN_H
+
+#define UNIX_PATH_MAX   108
+
+struct sockaddr_un {
+        sa_family_t sun_family; /* AF_UNIX */
+        char sun_path[UNIX_PATH_MAX];   /* pathname */
+};
+
+#endif /* _LINUX_UN_H */
diff --git a/include/linux/unistd.h b/include/linux/unistd.h
new file mode 100644
index 000000000000..10ed9834b822
--- /dev/null
+++ b/include/linux/unistd.h
@@ -0,0 +1,11 @@
+#ifndef _LINUX_UNISTD_H_
+#define _LINUX_UNISTD_H_
+
+extern int errno;
+
+/*
+ * Include machine specific syscallX macros
+ */
+#include <asm/unistd.h>
+
+#endif /* _LINUX_UNISTD_H_ */
diff --git a/include/linux/usb.h b/include/linux/usb.h
new file mode 100644
index 000000000000..c96728435935
--- /dev/null
+++ b/include/linux/usb.h
@@ -0,0 +1,1157 @@
+#ifndef __LINUX_USB_H
+#define __LINUX_USB_H
+
+#include <linux/mod_devicetable.h>
+#include <linux/usb_ch9.h>
+
+#define USB_MAJOR                       180
+
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/errno.h>        /* for -ENODEV */
+#include <linux/delay.h>        /* for mdelay() */
+#include <linux/interrupt.h>    /* for in_interrupt() */
+#include <linux/list.h>         /* for struct list_head */
+#include <linux/kref.h>         /* for struct kref */
+#include <linux/device.h>       /* for struct device */
+#include <linux/fs.h>           /* for struct file_operations */
+#include <linux/completion.h>   /* for struct completion */
+#include <linux/sched.h>        /* for current && schedule_timeout */
+
+struct usb_device;
+struct usb_driver;
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Host-side wrappers for standard USB descriptors ... these are parsed
+ * from the data provided by devices.  Parsing turns them from a flat
+ * sequence of descriptors into a hierarchy:
+ *
+ *  - devices have one (usually) or more configs;
+ *  - configs have one (often) or more interfaces;
+ *  - interfaces have one (usually) or more settings;
+ *  - each interface setting has zero or (usually) more endpoints.
+ *
+ * And there might be other descriptors mixed in with those.
+ *
+ * Devices may also have class-specific or vendor-specific descriptors.
+ */
+
+/**
+ * struct usb_host_endpoint - host-side endpoint descriptor and queue
+ * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
+ * @urb_list: urbs queued to this endpoint; maintained by usbcore
+ * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
+ *      with one or more transfer descriptors (TDs) per urb
+ * @extra: descriptors following this endpoint in the configuration
+ * @extralen: how many bytes of "extra" are valid
+ *
+ * USB requests are always queued to a given endpoint, identified by a
+ * descriptor within an active interface in a given USB configuration.
+ */
+struct usb_host_endpoint {
+        struct usb_endpoint_descriptor  desc;
+        struct list_head                urb_list;
+        void                            *hcpriv;
+
+        unsigned char *extra;   /* Extra descriptors */
+        int extralen;
+};
+
+/* host-side wrapper for one interface setting's parsed descriptors */
+struct usb_host_interface {
+        struct usb_interface_descriptor desc;
+
+        /* array of desc.bNumEndpoint endpoints associated with this
+         * interface setting.  these will be in no particular order.
+         */
+        struct usb_host_endpoint *endpoint;
+
+        char *string;           /* iInterface string, if present */
+        unsigned char *extra;   /* Extra descriptors */
+        int extralen;
+};
+
+enum usb_interface_condition {
+        USB_INTERFACE_UNBOUND = 0,
+        USB_INTERFACE_BINDING,
+        USB_INTERFACE_BOUND,
+        USB_INTERFACE_UNBINDING,
+};
+
+/**
+ * struct usb_interface - what usb device drivers talk to
+ * @altsetting: array of interface structures, one for each alternate
+ *      setting that may be selected.  Each one includes a set of
+ *      endpoint configurations.  They will be in no particular order.
+ * @num_altsetting: number of altsettings defined.
+ * @cur_altsetting: the current altsetting.
+ * @driver: the USB driver that is bound to this interface.
+ * @minor: the minor number assigned to this interface, if this
+ *      interface is bound to a driver that uses the USB major number.
+ *      If this interface does not use the USB major, this field should
+ *      be unused.  The driver should set this value in the probe()
+ *      function of the driver, after it has been assigned a minor
+ *      number from the USB core by calling usb_register_dev().
+ * @condition: binding state of the interface: not bound, binding
+ *      (in probe()), bound to a driver, or unbinding (in disconnect())
+ * @dev: driver model's view of this device
+ * @class_dev: driver model's class view of this device.
+ *
+ * USB device drivers attach to interfaces on a physical device.  Each
+ * interface encapsulates a single high level function, such as feeding
+ * an audio stream to a speaker or reporting a change in a volume control.
+ * Many USB devices only have one interface.  The protocol used to talk to
+ * an interface's endpoints can be defined in a usb "class" specification,
+ * or by a product's vendor.  The (default) control endpoint is part of
+ * every interface, but is never listed among the interface's descriptors.
+ *
+ * The driver that is bound to the interface can use standard driver model
+ * calls such as dev_get_drvdata() on the dev member of this structure.
+ *
+ * Each interface may have alternate settings.  The initial configuration
+ * of a device sets altsetting 0, but the device driver can change
+ * that setting using usb_set_interface().  Alternate settings are often
+ * used to control the the use of periodic endpoints, such as by having
+ * different endpoints use different amounts of reserved USB bandwidth.
+ * All standards-conformant USB devices that use isochronous endpoints
+ * will use them in non-default settings.
+ *
+ * The USB specification says that alternate setting numbers must run from
+ * 0 to one less than the total number of alternate settings.  But some
+ * devices manage to mess this up, and the structures aren't necessarily
+ * stored in numerical order anyhow.  Use usb_altnum_to_altsetting() to
+ * look up an alternate setting in the altsetting array based on its number.
+ */
+struct usb_interface {
+        /* array of alternate settings for this interface,
+         * stored in no particular order */
+        struct usb_host_interface *altsetting;
+
+        struct usb_host_interface *cur_altsetting;      /* the currently
+                                         * active alternate setting */
+        unsigned num_altsetting;        /* number of alternate settings */
+
+        int minor;                      /* minor number this interface is bound to */
+        enum usb_interface_condition condition;         /* state of binding */
+        struct device dev;              /* interface specific device info */
+        struct class_device *class_dev;
+};
+#define to_usb_interface(d) container_of(d, struct usb_interface, dev)
+#define interface_to_usbdev(intf) \
+        container_of(intf->dev.parent, struct usb_device, dev)
+
+static inline void *usb_get_intfdata (struct usb_interface *intf)
+{
+        return dev_get_drvdata (&intf->dev);
+}
+
+static inline void usb_set_intfdata (struct usb_interface *intf, void *data)
+{
+        dev_set_drvdata(&intf->dev, data);
+}
+
+struct usb_interface *usb_get_intf(struct usb_interface *intf);
+void usb_put_intf(struct usb_interface *intf);
+
+/* this maximum is arbitrary */
+#define USB_MAXINTERFACES       32
+
+/**
+ * struct usb_interface_cache - long-term representation of a device interface
+ * @num_altsetting: number of altsettings defined.
+ * @ref: reference counter.
+ * @altsetting: variable-length array of interface structures, one for
+ *      each alternate setting that may be selected.  Each one includes a
+ *      set of endpoint configurations.  They will be in no particular order.
+ *
+ * These structures persist for the lifetime of a usb_device, unlike
+ * struct usb_interface (which persists only as long as its configuration
+ * is installed).  The altsetting arrays can be accessed through these
+ * structures at any time, permitting comparison of configurations and
+ * providing support for the /proc/bus/usb/devices pseudo-file.
+ */
+struct usb_interface_cache {
+        unsigned num_altsetting;        /* number of alternate settings */
+        struct kref ref;                /* reference counter */
+
+        /* variable-length array of alternate settings for this interface,
+         * stored in no particular order */
+        struct usb_host_interface altsetting[0];
+};
+#define ref_to_usb_interface_cache(r) \
+                container_of(r, struct usb_interface_cache, ref)
+#define altsetting_to_usb_interface_cache(a) \
+                container_of(a, struct usb_interface_cache, altsetting[0])
+
+/**
+ * struct usb_host_config - representation of a device's configuration
+ * @desc: the device's configuration descriptor.
+ * @string: pointer to the cached version of the iConfiguration string, if
+ *      present for this configuration.
+ * @interface: array of pointers to usb_interface structures, one for each
+ *      interface in the configuration.  The number of interfaces is stored
+ *      in desc.bNumInterfaces.  These pointers are valid only while the
+ *      the configuration is active.
+ * @intf_cache: array of pointers to usb_interface_cache structures, one
+ *      for each interface in the configuration.  These structures exist
+ *      for the entire life of the device.
+ * @extra: pointer to buffer containing all extra descriptors associated
+ *      with this configuration (those preceding the first interface
+ *      descriptor).
+ * @extralen: length of the extra descriptors buffer.
+ *
+ * USB devices may have multiple configurations, but only one can be active
+ * at any time.  Each encapsulates a different operational environment;
+ * for example, a dual-speed device would have separate configurations for
+ * full-speed and high-speed operation.  The number of configurations
+ * available is stored in the device descriptor as bNumConfigurations.
+ *
+ * A configuration can contain multiple interfaces.  Each corresponds to
+ * a different function of the USB device, and all are available whenever
+ * the configuration is active.  The USB standard says that interfaces
+ * are supposed to be numbered from 0 to desc.bNumInterfaces-1, but a lot
+ * of devices get this wrong.  In addition, the interface array is not
+ * guaranteed to be sorted in numerical order.  Use usb_ifnum_to_if() to
+ * look up an interface entry based on its number.
+ *
+ * Device drivers should not attempt to activate configurations.  The choice
+ * of which configuration to install is a policy decision based on such
+ * considerations as available power, functionality provided, and the user's
+ * desires (expressed through hotplug scripts).  However, drivers can call
+ * usb_reset_configuration() to reinitialize the current configuration and
+ * all its interfaces.
+ */
+struct usb_host_config {
+        struct usb_config_descriptor    desc;
+
+        char *string;
+        /* the interfaces associated with this configuration,
+         * stored in no particular order */
+        struct usb_interface *interface[USB_MAXINTERFACES];
+
+        /* Interface information available even when this is not the
+         * active configuration */
+        struct usb_interface_cache *intf_cache[USB_MAXINTERFACES];
+
+        unsigned char *extra;   /* Extra descriptors */
+        int extralen;
+};
+
+int __usb_get_extra_descriptor(char *buffer, unsigned size,
+        unsigned char type, void **ptr);
+#define usb_get_extra_descriptor(ifpoint,type,ptr)\
+        __usb_get_extra_descriptor((ifpoint)->extra,(ifpoint)->extralen,\
+                type,(void**)ptr)
+
+/* -------------------------------------------------------------------------- */
+
+struct usb_operations;
+
+/* USB device number allocation bitmap */
+struct usb_devmap {
+        unsigned long devicemap[128 / (8*sizeof(unsigned long))];
+};
+
+/*
+ * Allocated per bus (tree of devices) we have:
+ */
+struct usb_bus {
+        struct device *controller;      /* host/master side hardware */
+        int busnum;                     /* Bus number (in order of reg) */
+        char *bus_name;                 /* stable id (PCI slot_name etc) */
+        u8 otg_port;                    /* 0, or number of OTG/HNP port */
+        unsigned is_b_host:1;           /* true during some HNP roleswitches */
+        unsigned b_hnp_enable:1;        /* OTG: did A-Host enable HNP? */
+
+        int devnum_next;                /* Next open device number in round-robin allocation */
+
+        struct usb_devmap devmap;       /* device address allocation map */
+        struct usb_operations *op;      /* Operations (specific to the HC) */
+        struct usb_device *root_hub;    /* Root hub */
+        struct list_head bus_list;      /* list of busses */
+        void *hcpriv;                   /* Host Controller private data */
+
+        int bandwidth_allocated;        /* on this bus: how much of the time
+                                         * reserved for periodic (intr/iso)
+                                         * requests is used, on average?
+                                         * Units: microseconds/frame.
+                                         * Limits: Full/low speed reserve 90%,
+                                         * while high speed reserves 80%.
+                                         */
+        int bandwidth_int_reqs;         /* number of Interrupt requests */
+        int bandwidth_isoc_reqs;        /* number of Isoc. requests */
+
+        struct dentry *usbfs_dentry;    /* usbfs dentry entry for the bus */
+
+        struct class_device class_dev;  /* class device for this bus */
+        void (*release)(struct usb_bus *bus);   /* function to destroy this bus's memory */
+#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
+        struct mon_bus *mon_bus;        /* non-null when associated */
+        int monitored;                  /* non-zero when monitored */
+#endif
+};
+#define to_usb_bus(d) container_of(d, struct usb_bus, class_dev)
+
+
+/* -------------------------------------------------------------------------- */
+
+/* This is arbitrary.
+ * From USB 2.0 spec Table 11-13, offset 7, a hub can
+ * have up to 255 ports. The most yet reported is 10.
+ */
+#define USB_MAXCHILDREN         (16)
+
+struct usb_tt;
+
+/*
+ * struct usb_device - kernel's representation of a USB device
+ *
+ * FIXME: Write the kerneldoc!
+ *
+ * Usbcore drivers should not set usbdev->state directly.  Instead use
+ * usb_set_device_state().
+ */
+struct usb_device {
+        int             devnum;         /* Address on USB bus */
+        char            devpath [16];   /* Use in messages: /port/port/... */
+        enum usb_device_state   state;  /* configured, not attached, etc */
+        enum usb_device_speed   speed;  /* high/full/low (or error) */
+
+        struct usb_tt   *tt;            /* low/full speed dev, highspeed hub */
+        int             ttport;         /* device port on that tt hub */
+
+        struct semaphore serialize;
+
+        unsigned int toggle[2];         /* one bit for each endpoint ([0] = IN, [1] = OUT) */
+
+        struct usb_device *parent;      /* our hub, unless we're the root */
+        struct usb_bus *bus;            /* Bus we're part of */
+        struct usb_host_endpoint ep0;
+
+        struct device dev;              /* Generic device interface */
+
+        struct usb_device_descriptor descriptor;/* Descriptor */
+        struct usb_host_config *config; /* All of the configs */
+
+        struct usb_host_config *actconfig;/* the active configuration */
+        struct usb_host_endpoint *ep_in[16];
+        struct usb_host_endpoint *ep_out[16];
+
+        char **rawdescriptors;          /* Raw descriptors for each config */
+
+        int have_langid;                /* whether string_langid is valid yet */
+        int string_langid;              /* language ID for strings */
+
+        char *product;
+        char *manufacturer;
+        char *serial;                   /* static strings from the device */
+        struct list_head filelist;
+        struct dentry *usbfs_dentry;    /* usbfs dentry entry for the device */
+
+        /*
+         * Child devices - these can be either new devices
+         * (if this is a hub device), or different instances
+         * of this same device.
+         *
+         * Each instance needs its own set of data structures.
+         */
+
+        int maxchild;                   /* Number of ports if hub */
+        struct usb_device *children[USB_MAXCHILDREN];
+};
+#define to_usb_device(d) container_of(d, struct usb_device, dev)
+
+extern struct usb_device *usb_get_dev(struct usb_device *dev);
+extern void usb_put_dev(struct usb_device *dev);
+
+extern void usb_lock_device(struct usb_device *udev);
+extern int usb_trylock_device(struct usb_device *udev);
+extern int usb_lock_device_for_reset(struct usb_device *udev,
+                struct usb_interface *iface);
+extern void usb_unlock_device(struct usb_device *udev);
+
+/* USB port reset for device reinitialization */
+extern int usb_reset_device(struct usb_device *dev);
+
+extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
+
+/*-------------------------------------------------------------------------*/
+
+/* for drivers using iso endpoints */
+extern int usb_get_current_frame_number (struct usb_device *usb_dev);
+
+/* used these for multi-interface device registration */
+extern int usb_driver_claim_interface(struct usb_driver *driver,
+                        struct usb_interface *iface, void* priv);
+
+/**
+ * usb_interface_claimed - returns true iff an interface is claimed
+ * @iface: the interface being checked
+ *
+ * Returns true (nonzero) iff the interface is claimed, else false (zero).
+ * Callers must own the driver model's usb bus readlock.  So driver
+ * probe() entries don't need extra locking, but other call contexts
+ * may need to explicitly claim that lock.
+ *
+ */
+static inline int usb_interface_claimed(struct usb_interface *iface) {
+        return (iface->dev.driver != NULL);
+}
+
+extern void usb_driver_release_interface(struct usb_driver *driver,
+                        struct usb_interface *iface);
+const struct usb_device_id *usb_match_id(struct usb_interface *interface,
+                                         const struct usb_device_id *id);
+
+extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
+                int minor);
+extern struct usb_interface *usb_ifnum_to_if(struct usb_device *dev,
+                unsigned ifnum);
+extern struct usb_host_interface *usb_altnum_to_altsetting(
+                struct usb_interface *intf, unsigned int altnum);
+
+
+/**
+ * usb_make_path - returns stable device path in the usb tree
+ * @dev: the device whose path is being constructed
+ * @buf: where to put the string
+ * @size: how big is "buf"?
+ *
+ * Returns length of the string (> 0) or negative if size was too small.
+ *
+ * This identifier is intended to be "stable", reflecting physical paths in
+ * hardware such as physical bus addresses for host controllers or ports on
+ * USB hubs.  That makes it stay the same until systems are physically
+ * reconfigured, by re-cabling a tree of USB devices or by moving USB host
+ * controllers.  Adding and removing devices, including virtual root hubs
+ * in host controller driver modules, does not change these path identifers;
+ * neither does rebooting or re-enumerating.  These are more useful identifiers
+ * than changeable ("unstable") ones like bus numbers or device addresses.
+ *
+ * With a partial exception for devices connected to USB 2.0 root hubs, these
+ * identifiers are also predictable.  So long as the device tree isn't changed,
+ * plugging any USB device into a given hub port always gives it the same path.
+ * Because of the use of "companion" controllers, devices connected to ports on
+ * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
+ * high speed, and a different one if they are full or low speed.
+ */
+static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
+{
+        int actual;
+        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name, dev->devpath);
+        return (actual >= (int)size) ? -1 : actual;
+}
+
+/*-------------------------------------------------------------------------*/
+
+#define USB_DEVICE_ID_MATCH_DEVICE              (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
+#define USB_DEVICE_ID_MATCH_DEV_RANGE           (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
+#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION  (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
+#define USB_DEVICE_ID_MATCH_DEV_INFO \
+        (USB_DEVICE_ID_MATCH_DEV_CLASS | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
+#define USB_DEVICE_ID_MATCH_INT_INFO \
+        (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)
+
+/**
+ * USB_DEVICE - macro used to describe a specific usb device
+ * @vend: the 16 bit USB Vendor ID
+ * @prod: the 16 bit USB Product ID
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific device.
+ */
+#define USB_DEVICE(vend,prod) \
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), .idProduct = (prod)
+/**
+ * USB_DEVICE_VER - macro used to describe a specific usb device with a version range
+ * @vend: the 16 bit USB Vendor ID
+ * @prod: the 16 bit USB Product ID
+ * @lo: the bcdDevice_lo value
+ * @hi: the bcdDevice_hi value
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific device, with a version range.
+ */
+#define USB_DEVICE_VER(vend,prod,lo,hi) \
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, .idVendor = (vend), .idProduct = (prod), .bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
+
+/**
+ * USB_DEVICE_INFO - macro used to describe a class of usb devices
+ * @cl: bDeviceClass value
+ * @sc: bDeviceSubClass value
+ * @pr: bDeviceProtocol value
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific class of devices.
+ */
+#define USB_DEVICE_INFO(cl,sc,pr) \
+        .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), .bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
+
+/**
+ * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces 
+ * @cl: bInterfaceClass value
+ * @sc: bInterfaceSubClass value
+ * @pr: bInterfaceProtocol value
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific class of interfaces.
+ */
+#define USB_INTERFACE_INFO(cl,sc,pr) \
+        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * struct usb_driver - identifies USB driver to usbcore
+ * @owner: Pointer to the module owner of this driver; initialize
+ *      it using THIS_MODULE.
+ * @name: The driver name should be unique among USB drivers,
+ *      and should normally be the same as the module name.
+ * @probe: Called to see if the driver is willing to manage a particular
+ *      interface on a device.  If it is, probe returns zero and uses
+ *      dev_set_drvdata() to associate driver-specific data with the
+ *      interface.  It may also use usb_set_interface() to specify the
+ *      appropriate altsetting.  If unwilling to manage the interface,
+ *      return a negative errno value.
+ * @disconnect: Called when the interface is no longer accessible, usually
+ *      because its device has been (or is being) disconnected or the
+ *      driver module is being unloaded.
+ * @ioctl: Used for drivers that want to talk to userspace through
+ *      the "usbfs" filesystem.  This lets devices provide ways to
+ *      expose information to user space regardless of where they
+ *      do (or don't) show up otherwise in the filesystem.
+ * @suspend: Called when the device is going to be suspended by the system.
+ * @resume: Called when the device is being resumed by the system.
+ * @id_table: USB drivers use ID table to support hotplugging.
+ *      Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
+ *      or your driver's probe function will never get called.
+ * @driver: the driver model core driver structure.
+ *
+ * USB drivers must provide a name, probe() and disconnect() methods,
+ * and an id_table.  Other driver fields are optional.
+ *
+ * The id_table is used in hotplugging.  It holds a set of descriptors,
+ * and specialized data may be associated with each entry.  That table
+ * is used by both user and kernel mode hotplugging support.
+ *
+ * The probe() and disconnect() methods are called in a context where
+ * they can sleep, but they should avoid abusing the privilege.  Most
+ * work to connect to a device should be done when the device is opened,
+ * and undone at the last close.  The disconnect code needs to address
+ * concurrency issues with respect to open() and close() methods, as
+ * well as forcing all pending I/O requests to complete (by unlinking
+ * them as necessary, and blocking until the unlinks complete).
+ */
+struct usb_driver {
+        struct module *owner;
+
+        const char *name;
+
+        int (*probe) (struct usb_interface *intf,
+                      const struct usb_device_id *id);
+
+        void (*disconnect) (struct usb_interface *intf);
+
+        int (*ioctl) (struct usb_interface *intf, unsigned int code, void *buf);
+
+        int (*suspend) (struct usb_interface *intf, u32 state);
+        int (*resume) (struct usb_interface *intf);
+
+        const struct usb_device_id *id_table;
+
+        struct device_driver driver;
+};
+#define to_usb_driver(d) container_of(d, struct usb_driver, driver)
+
+extern struct bus_type usb_bus_type;
+
+/**
+ * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
+ * @name: devfs name for this driver.  Will also be used by the driver
+ *      class code to create a usb class device.
+ * @fops: pointer to the struct file_operations of this driver.
+ * @mode: the mode for the devfs file to be created for this driver.
+ * @minor_base: the start of the minor range for this driver.
+ *
+ * This structure is used for the usb_register_dev() and
+ * usb_unregister_dev() functions, to consolidate a number of the
+ * parameters used for them.
+ */
+struct usb_class_driver {
+        char *name;
+        struct file_operations *fops;
+        mode_t mode;
+        int minor_base; 
+};
+
+/*
+ * use these in module_init()/module_exit()
+ * and don't forget MODULE_DEVICE_TABLE(usb, ...)
+ */
+extern int usb_register(struct usb_driver *);
+extern void usb_deregister(struct usb_driver *);
+
+extern int usb_register_dev(struct usb_interface *intf,
+                            struct usb_class_driver *class_driver);
+extern void usb_deregister_dev(struct usb_interface *intf,
+                               struct usb_class_driver *class_driver);
+
+extern int usb_disabled(void);
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * URB support, for asynchronous request completions
+ */
+
+/*
+ * urb->transfer_flags:
+ */
+#define URB_SHORT_NOT_OK        0x0001  /* report short reads as errors */
+#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame ignored */
+#define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
+#define URB_NO_SETUP_DMA_MAP    0x0008  /* urb->setup_dma valid on submit */
+#define URB_ASYNC_UNLINK        0x0010  /* usb_unlink_urb() returns asap */
+#define URB_NO_FSBR             0x0020  /* UHCI-specific */
+#define URB_ZERO_PACKET         0x0040  /* Finish bulk OUTs with short packet */
+#define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt needed */
+
+struct usb_iso_packet_descriptor {
+        unsigned int offset;
+        unsigned int length;            /* expected length */
+        unsigned int actual_length;
+        unsigned int status;
+};
+
+struct urb;
+struct pt_regs;
+
+typedef void (*usb_complete_t)(struct urb *, struct pt_regs *);
+
+/**
+ * struct urb - USB Request Block
+ * @urb_list: For use by current owner of the URB.
+ * @pipe: Holds endpoint number, direction, type, and more.
+ *      Create these values with the eight macros available;
+ *      usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
+ *      (control), "bulk", "int" (interrupt), or "iso" (isochronous).
+ *      For example usb_sndbulkpipe() or usb_rcvintpipe().  Endpoint
+ *      numbers range from zero to fifteen.  Note that "in" endpoint two
+ *      is a different endpoint (and pipe) from "out" endpoint two.
+ *      The current configuration controls the existence, type, and
+ *      maximum packet size of any given endpoint.
+ * @dev: Identifies the USB device to perform the request.
+ * @status: This is read in non-iso completion functions to get the
+ *      status of the particular request.  ISO requests only use it
+ *      to tell whether the URB was unlinked; detailed status for
+ *      each frame is in the fields of the iso_frame-desc.
+ * @transfer_flags: A variety of flags may be used to affect how URB
+ *      submission, unlinking, or operation are handled.  Different
+ *      kinds of URB can use different flags.
+ * @transfer_buffer:  This identifies the buffer to (or from) which
+ *      the I/O request will be performed (unless URB_NO_TRANSFER_DMA_MAP
+ *      is set).  This buffer must be suitable for DMA; allocate it with
+ *      kmalloc() or equivalent.  For transfers to "in" endpoints, contents
+ *      of this buffer will be modified.  This buffer is used for the data
+ *      stage of control transfers.
+ * @transfer_dma: When transfer_flags includes URB_NO_TRANSFER_DMA_MAP,
+ *      the device driver is saying that it provided this DMA address,
+ *      which the host controller driver should use in preference to the
+ *      transfer_buffer.
+ * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
+ *      be broken up into chunks according to the current maximum packet
+ *      size for the endpoint, which is a function of the configuration
+ *      and is encoded in the pipe.  When the length is zero, neither
+ *      transfer_buffer nor transfer_dma is used.
+ * @actual_length: This is read in non-iso completion functions, and
+ *      it tells how many bytes (out of transfer_buffer_length) were
+ *      transferred.  It will normally be the same as requested, unless
+ *      either an error was reported or a short read was performed.
+ *      The URB_SHORT_NOT_OK transfer flag may be used to make such
+ *      short reads be reported as errors. 
+ * @setup_packet: Only used for control transfers, this points to eight bytes
+ *      of setup data.  Control transfers always start by sending this data
+ *      to the device.  Then transfer_buffer is read or written, if needed.
+ * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the
+ *      device driver has provided this DMA address for the setup packet.
+ *      The host controller driver should use this in preference to
+ *      setup_packet.
+ * @start_frame: Returns the initial frame for isochronous transfers.
+ * @number_of_packets: Lists the number of ISO transfer buffers.
+ * @interval: Specifies the polling interval for interrupt or isochronous
+ *      transfers.  The units are frames (milliseconds) for for full and low
+ *      speed devices, and microframes (1/8 millisecond) for highspeed ones.
+ * @error_count: Returns the number of ISO transfers that reported errors.
+ * @context: For use in completion functions.  This normally points to
+ *      request-specific driver context.
+ * @complete: Completion handler. This URB is passed as the parameter to the
+ *      completion function.  The completion function may then do what
+ *      it likes with the URB, including resubmitting or freeing it.
+ * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to 
+ *      collect the transfer status for each buffer.
+ *
+ * This structure identifies USB transfer requests.  URBs must be allocated by
+ * calling usb_alloc_urb() and freed with a call to usb_free_urb().
+ * Initialization may be done using various usb_fill_*_urb() functions.  URBs
+ * are submitted using usb_submit_urb(), and pending requests may be canceled
+ * using usb_unlink_urb() or usb_kill_urb().
+ *
+ * Data Transfer Buffers:
+ *
+ * Normally drivers provide I/O buffers allocated with kmalloc() or otherwise
+ * taken from the general page pool.  That is provided by transfer_buffer
+ * (control requests also use setup_packet), and host controller drivers
+ * perform a dma mapping (and unmapping) for each buffer transferred.  Those
+ * mapping operations can be expensive on some platforms (perhaps using a dma
+ * bounce buffer or talking to an IOMMU),
+ * although they're cheap on commodity x86 and ppc hardware.
+ *
+ * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags,
+ * which tell the host controller driver that no such mapping is needed since
+ * the device driver is DMA-aware.  For example, a device driver might
+ * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map().
+ * When these transfer flags are provided, host controller drivers will
+ * attempt to use the dma addresses found in the transfer_dma and/or
+ * setup_dma fields rather than determining a dma address themselves.  (Note
+ * that transfer_buffer and setup_packet must still be set because not all
+ * host controllers use DMA, nor do virtual root hubs).
+ *
+ * Initialization:
+ *
+ * All URBs submitted must initialize the dev, pipe, transfer_flags (may be
+ * zero), and complete fields.
+ * The URB_ASYNC_UNLINK transfer flag affects later invocations of
+ * the usb_unlink_urb() routine.  Note: Failure to set URB_ASYNC_UNLINK
+ * with usb_unlink_urb() is deprecated.  For synchronous unlinks use
+ * usb_kill_urb() instead.
+ *
+ * All URBs must also initialize 
+ * transfer_buffer and transfer_buffer_length.  They may provide the
+ * URB_SHORT_NOT_OK transfer flag, indicating that short reads are
+ * to be treated as errors; that flag is invalid for write requests.
+ *
+ * Bulk URBs may
+ * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
+ * should always terminate with a short packet, even if it means adding an
+ * extra zero length packet.
+ *
+ * Control URBs must provide a setup_packet.  The setup_packet and
+ * transfer_buffer may each be mapped for DMA or not, independently of
+ * the other.  The transfer_flags bits URB_NO_TRANSFER_DMA_MAP and
+ * URB_NO_SETUP_DMA_MAP indicate which buffers have already been mapped.
+ * URB_NO_SETUP_DMA_MAP is ignored for non-control URBs.
+ *
+ * Interrupt URBs must provide an interval, saying how often (in milliseconds
+ * or, for highspeed devices, 125 microsecond units)
+ * to poll for transfers.  After the URB has been submitted, the interval
+ * field reflects how the transfer was actually scheduled.
+ * The polling interval may be more frequent than requested.
+ * For example, some controllers have a maximum interval of 32 milliseconds,
+ * while others support intervals of up to 1024 milliseconds.
+ * Isochronous URBs also have transfer intervals.  (Note that for isochronous
+ * endpoints, as well as high speed interrupt endpoints, the encoding of
+ * the transfer interval in the endpoint descriptor is logarithmic.
+ * Device drivers must convert that value to linear units themselves.)
+ *
+ * Isochronous URBs normally use the URB_ISO_ASAP transfer flag, telling
+ * the host controller to schedule the transfer as soon as bandwidth
+ * utilization allows, and then set start_frame to reflect the actual frame
+ * selected during submission.  Otherwise drivers must specify the start_frame
+ * and handle the case where the transfer can't begin then.  However, drivers
+ * won't know how bandwidth is currently allocated, and while they can
+ * find the current frame using usb_get_current_frame_number () they can't
+ * know the range for that frame number.  (Ranges for frame counter values
+ * are HC-specific, and can go from 256 to 65536 frames from "now".)
+ *
+ * Isochronous URBs have a different data transfer model, in part because
+ * the quality of service is only "best effort".  Callers provide specially
+ * allocated URBs, with number_of_packets worth of iso_frame_desc structures
+ * at the end.  Each such packet is an individual ISO transfer.  Isochronous
+ * URBs are normally queued, submitted by drivers to arrange that
+ * transfers are at least double buffered, and then explicitly resubmitted
+ * in completion handlers, so
+ * that data (such as audio or video) streams at as constant a rate as the
+ * host controller scheduler can support.
+ *
+ * Completion Callbacks:
+ *
+ * The completion callback is made in_interrupt(), and one of the first
+ * things that a completion handler should do is check the status field.
+ * The status field is provided for all URBs.  It is used to report
+ * unlinked URBs, and status for all non-ISO transfers.  It should not
+ * be examined before the URB is returned to the completion handler.
+ *
+ * The context field is normally used to link URBs back to the relevant
+ * driver or request state.
+ *
+ * When the completion callback is invoked for non-isochronous URBs, the
+ * actual_length field tells how many bytes were transferred.  This field
+ * is updated even when the URB terminated with an error or was unlinked.
+ *
+ * ISO transfer status is reported in the status and actual_length fields
+ * of the iso_frame_desc array, and the number of errors is reported in
+ * error_count.  Completion callbacks for ISO transfers will normally
+ * (re)submit URBs to ensure a constant transfer rate.
+ */
+struct urb
+{
+        /* private, usb core and host controller only fields in the urb */
+        struct kref kref;               /* reference count of the URB */
+        spinlock_t lock;                /* lock for the URB */
+        void *hcpriv;                   /* private data for host controller */
+        struct list_head urb_list;      /* list pointer to all active urbs */
+        int bandwidth;                  /* bandwidth for INT/ISO request */
+        atomic_t use_count;             /* concurrent submissions counter */
+        u8 reject;                      /* submissions will fail */
+
+        /* public, documented fields in the urb that can be used by drivers */
+        struct usb_device *dev;         /* (in) pointer to associated device */
+        unsigned int pipe;              /* (in) pipe information */
+        int status;                     /* (return) non-ISO status */
+        unsigned int transfer_flags;    /* (in) URB_SHORT_NOT_OK | ...*/
+        void *transfer_buffer;          /* (in) associated data buffer */
+        dma_addr_t transfer_dma;        /* (in) dma addr for transfer_buffer */
+        int transfer_buffer_length;     /* (in) data buffer length */
+        int actual_length;              /* (return) actual transfer length */
+        unsigned char *setup_packet;    /* (in) setup packet (control only) */
+        dma_addr_t setup_dma;           /* (in) dma addr for setup_packet */
+        int start_frame;                /* (modify) start frame (ISO) */
+        int number_of_packets;          /* (in) number of ISO packets */
+        int interval;                   /* (modify) transfer interval (INT/ISO) */
+        int error_count;                /* (return) number of ISO errors */
+        void *context;                  /* (in) context for completion */
+        usb_complete_t complete;        /* (in) completion routine */
+        struct usb_iso_packet_descriptor iso_frame_desc[0];     /* (in) ISO ONLY */
+};
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * usb_fill_control_urb - initializes a control urb
+ * @urb: pointer to the urb to initialize.
+ * @dev: pointer to the struct usb_device for this urb.
+ * @pipe: the endpoint pipe
+ * @setup_packet: pointer to the setup_packet buffer
+ * @transfer_buffer: pointer to the transfer buffer
+ * @buffer_length: length of the transfer buffer
+ * @complete: pointer to the usb_complete_t function
+ * @context: what to set the urb context to.
+ *
+ * Initializes a control urb with the proper information needed to submit
+ * it to a device.
+ */
+static inline void usb_fill_control_urb (struct urb *urb,
+                                         struct usb_device *dev,
+                                         unsigned int pipe,
+                                         unsigned char *setup_packet,
+                                         void *transfer_buffer,
+                                         int buffer_length,
+                                         usb_complete_t complete,
+                                         void *context)
+{
+        spin_lock_init(&urb->lock);
+        urb->dev = dev;
+        urb->pipe = pipe;
+        urb->setup_packet = setup_packet;
+        urb->transfer_buffer = transfer_buffer;
+        urb->transfer_buffer_length = buffer_length;
+        urb->complete = complete;
+        urb->context = context;
+}
+
+/**
+ * usb_fill_bulk_urb - macro to help initialize a bulk urb
+ * @urb: pointer to the urb to initialize.
+ * @dev: pointer to the struct usb_device for this urb.
+ * @pipe: the endpoint pipe
+ * @transfer_buffer: pointer to the transfer buffer
+ * @buffer_length: length of the transfer buffer
+ * @complete: pointer to the usb_complete_t function
+ * @context: what to set the urb context to.
+ *
+ * Initializes a bulk urb with the proper information needed to submit it
+ * to a device.
+ */
+static inline void usb_fill_bulk_urb (struct urb *urb,
+                                      struct usb_device *dev,
+                                      unsigned int pipe,
+                                      void *transfer_buffer,
+                                      int buffer_length,
+                                      usb_complete_t complete,
+                                      void *context)
+{
+        spin_lock_init(&urb->lock);
+        urb->dev = dev;
+        urb->pipe = pipe;
+        urb->transfer_buffer = transfer_buffer;
+        urb->transfer_buffer_length = buffer_length;
+        urb->complete = complete;
+        urb->context = context;
+}
+
+/**
+ * usb_fill_int_urb - macro to help initialize a interrupt urb
+ * @urb: pointer to the urb to initialize.
+ * @dev: pointer to the struct usb_device for this urb.
+ * @pipe: the endpoint pipe
+ * @transfer_buffer: pointer to the transfer buffer
+ * @buffer_length: length of the transfer buffer
+ * @complete: pointer to the usb_complete_t function
+ * @context: what to set the urb context to.
+ * @interval: what to set the urb interval to, encoded like
+ *      the endpoint descriptor's bInterval value.
+ *
+ * Initializes a interrupt urb with the proper information needed to submit
+ * it to a device.
+ * Note that high speed interrupt endpoints use a logarithmic encoding of
+ * the endpoint interval, and express polling intervals in microframes
+ * (eight per millisecond) rather than in frames (one per millisecond).
+ */
+static inline void usb_fill_int_urb (struct urb *urb,
+                                     struct usb_device *dev,
+                                     unsigned int pipe,
+                                     void *transfer_buffer,
+                                     int buffer_length,
+                                     usb_complete_t complete,
+                                     void *context,
+                                     int interval)
+{
+        spin_lock_init(&urb->lock);
+        urb->dev = dev;
+        urb->pipe = pipe;
+        urb->transfer_buffer = transfer_buffer;
+        urb->transfer_buffer_length = buffer_length;
+        urb->complete = complete;
+        urb->context = context;
+        if (dev->speed == USB_SPEED_HIGH)
+                urb->interval = 1 << (interval - 1);
+        else
+                urb->interval = interval;
+        urb->start_frame = -1;
+}
+
+extern void usb_init_urb(struct urb *urb);
+extern struct urb *usb_alloc_urb(int iso_packets, int mem_flags);
+extern void usb_free_urb(struct urb *urb);
+#define usb_put_urb usb_free_urb
+extern struct urb *usb_get_urb(struct urb *urb);
+extern int usb_submit_urb(struct urb *urb, int mem_flags);
+extern int usb_unlink_urb(struct urb *urb);
+extern void usb_kill_urb(struct urb *urb);
+
+#define HAVE_USB_BUFFERS
+void *usb_buffer_alloc (struct usb_device *dev, size_t size,
+        int mem_flags, dma_addr_t *dma);
+void usb_buffer_free (struct usb_device *dev, size_t size,
+        void *addr, dma_addr_t dma);
+
+#if 0
+struct urb *usb_buffer_map (struct urb *urb);
+void usb_buffer_dmasync (struct urb *urb);
+void usb_buffer_unmap (struct urb *urb);
+#endif
+
+struct scatterlist;
+int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe,
+                struct scatterlist *sg, int nents);
+#if 0
+void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe,
+                struct scatterlist *sg, int n_hw_ents);
+#endif
+void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
+                struct scatterlist *sg, int n_hw_ents);
+
+/*-------------------------------------------------------------------*
+ *                         SYNCHRONOUS CALL SUPPORT                  *
+ *-------------------------------------------------------------------*/
+
+extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
+        __u8 request, __u8 requesttype, __u16 value, __u16 index,
+        void *data, __u16 size, int timeout);
+extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
+        void *data, int len, int *actual_length,
+        int timeout);
+
+/* selective suspend/resume */
+extern int usb_suspend_device(struct usb_device *dev, u32 state);
+extern int usb_resume_device(struct usb_device *dev);
+
+
+/* wrappers around usb_control_msg() for the most common standard requests */
+extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
+        unsigned char descindex, void *buf, int size);
+extern int usb_get_status(struct usb_device *dev,
+        int type, int target, void *data);
+extern int usb_get_string(struct usb_device *dev,
+        unsigned short langid, unsigned char index, void *buf, int size);
+extern int usb_string(struct usb_device *dev, int index,
+        char *buf, size_t size);
+
+/* wrappers that also update important state inside usbcore */
+extern int usb_clear_halt(struct usb_device *dev, int pipe);
+extern int usb_reset_configuration(struct usb_device *dev);
+extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
+
+/*
+ * timeouts, in milliseconds, used for sending/receiving control messages
+ * they typically complete within a few frames (msec) after they're issued
+ * USB identifies 5 second timeouts, maybe more in a few cases, and a few
+ * slow devices (like some MGE Ellipse UPSes) actually push that limit.
+ */
+#define USB_CTRL_GET_TIMEOUT    5000
+#define USB_CTRL_SET_TIMEOUT    5000
+
+
+/**
+ * struct usb_sg_request - support for scatter/gather I/O
+ * @status: zero indicates success, else negative errno
+ * @bytes: counts bytes transferred.
+ *
+ * These requests are initialized using usb_sg_init(), and then are used
+ * as request handles passed to usb_sg_wait() or usb_sg_cancel().  Most
+ * members of the request object aren't for driver access.
+ *
+ * The status and bytecount values are valid only after usb_sg_wait()
+ * returns.  If the status is zero, then the bytecount matches the total
+ * from the request.
+ *
+ * After an error completion, drivers may need to clear a halt condition
+ * on the endpoint.
+ */
+struct usb_sg_request {
+        int                     status;
+        size_t                  bytes;
+
+        /* 
+         * members below are private to usbcore,
+         * and are not provided for driver access!
+         */
+        spinlock_t              lock;
+
+        struct usb_device       *dev;
+        int                     pipe;
+        struct scatterlist      *sg;
+        int                     nents;
+
+        int                     entries;
+        struct urb              **urbs;
+
+        int                     count;
+        struct completion       complete;
+};
+
+int usb_sg_init (
+        struct usb_sg_request   *io,
+        struct usb_device       *dev,
+        unsigned                pipe, 
+        unsigned                period,
+        struct scatterlist      *sg,
+        int                     nents,
+        size_t                  length,
+        int                     mem_flags
+);
+void usb_sg_cancel (struct usb_sg_request *io);
+void usb_sg_wait (struct usb_sg_request *io);
+
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * For various legacy reasons, Linux has a small cookie that's paired with
+ * a struct usb_device to identify an endpoint queue.  Queue characteristics
+ * are defined by the endpoint's descriptor.  This cookie is called a "pipe",
+ * an unsigned int encoded as:
+ *
+ *  - direction:        bit 7           (0 = Host-to-Device [Out],
+ *                                       1 = Device-to-Host [In] ...
+ *                                      like endpoint bEndpointAddress)
+ *  - device address:   bits 8-14       ... bit positions known to uhci-hcd
+ *  - endpoint:         bits 15-18      ... bit positions known to uhci-hcd
+ *  - pipe type:        bits 30-31      (00 = isochronous, 01 = interrupt,
+ *                                       10 = control, 11 = bulk)
+ *
+ * Given the device address and endpoint descriptor, pipes are redundant.
+ */
+
+/* NOTE:  these are not the standard USB_ENDPOINT_XFER_* values!! */
+/* (yet ... they're the values used by usbfs) */
+#define PIPE_ISOCHRONOUS                0
+#define PIPE_INTERRUPT                  1
+#define PIPE_CONTROL                    2
+#define PIPE_BULK                       3
+
+#define usb_pipein(pipe)        ((pipe) & USB_DIR_IN)
+#define usb_pipeout(pipe)       (!usb_pipein(pipe))
+
+#define usb_pipedevice(pipe)    (((pipe) >> 8) & 0x7f)
+#define usb_pipeendpoint(pipe)  (((pipe) >> 15) & 0xf)
+
+#define usb_pipetype(pipe)      (((pipe) >> 30) & 3)
+#define usb_pipeisoc(pipe)      (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
+#define usb_pipeint(pipe)       (usb_pipetype((pipe)) == PIPE_INTERRUPT)
+#define usb_pipecontrol(pipe)   (usb_pipetype((pipe)) == PIPE_CONTROL)
+#define usb_pipebulk(pipe)      (usb_pipetype((pipe)) == PIPE_BULK)
+
+/* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
+#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
+#define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
+#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | ((bit) << (ep)))
+
+
+static inline unsigned int __create_pipe(struct usb_device *dev, unsigned int endpoint)
+{
+        return (dev->devnum << 8) | (endpoint << 15);
+}
+
+/* Create various pipes... */
+#define usb_sndctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+
+/*-------------------------------------------------------------------------*/
+
+static inline __u16
+usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
+{
+        struct usb_host_endpoint        *ep;
+        unsigned                        epnum = usb_pipeendpoint(pipe);
+
+        if (is_out) {
+                WARN_ON(usb_pipein(pipe));
+                ep = udev->ep_out[epnum];
+        } else {
+                WARN_ON(usb_pipeout(pipe));
+                ep = udev->ep_in[epnum];
+        }
+        if (!ep)
+                return 0;
+
+        /* NOTE:  only 0x07ff bits are for packet size... */
+        return le16_to_cpu(ep->desc.wMaxPacketSize);
+}
+
+/* -------------------------------------------------------------------------- */
+
+#ifdef DEBUG
+#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , ## arg)
+#else
+#define dbg(format, arg...) do {} while (0)
+#endif
+
+#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , __FILE__ , ## arg)
+#define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , __FILE__ , ## arg)
+#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , __FILE__ , ## arg)
+
+
+#endif  /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/usb_cdc.h b/include/linux/usb_cdc.h
new file mode 100644
index 000000000000..1b68c122279a
--- /dev/null
+++ b/include/linux/usb_cdc.h
@@ -0,0 +1,192 @@
+/*
+ * USB Communications Device Class (CDC) definitions
+ *
+ * CDC says how to talk to lots of different types of network adapters,
+ * notably ethernet adapters and various modems.  It's used mostly with
+ * firmware based USB peripherals.
+ */
+
+#define USB_CDC_SUBCLASS_ACM                    0x02
+#define USB_CDC_SUBCLASS_ETHERNET               0x06
+#define USB_CDC_SUBCLASS_WHCM                   0x08
+#define USB_CDC_SUBCLASS_DMM                    0x09
+#define USB_CDC_SUBCLASS_MDLM                   0x0a
+#define USB_CDC_SUBCLASS_OBEX                   0x0b
+
+#define USB_CDC_PROTO_NONE                      0
+
+#define USB_CDC_ACM_PROTO_AT_V25TER             1
+#define USB_CDC_ACM_PROTO_AT_PCCA101            2
+#define USB_CDC_ACM_PROTO_AT_PCCA101_WAKE       3
+#define USB_CDC_ACM_PROTO_AT_GSM                4
+#define USB_CDC_ACM_PROTO_AT_3G                 5
+#define USB_CDC_ACM_PROTO_AT_CDMA               6
+#define USB_CDC_ACM_PROTO_VENDOR                0xff
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Class-Specific descriptors ... there are a couple dozen of them
+ */
+
+#define USB_CDC_HEADER_TYPE             0x00            /* header_desc */
+#define USB_CDC_CALL_MANAGEMENT_TYPE    0x01            /* call_mgmt_descriptor */
+#define USB_CDC_ACM_TYPE                0x02            /* acm_descriptor */
+#define USB_CDC_UNION_TYPE              0x06            /* union_desc */
+#define USB_CDC_COUNTRY_TYPE            0x07
+#define USB_CDC_ETHERNET_TYPE           0x0f            /* ether_desc */
+#define USB_CDC_WHCM_TYPE               0x11
+#define USB_CDC_MDLM_TYPE               0x12            /* mdlm_desc */
+#define USB_CDC_MDLM_DETAIL_TYPE        0x13            /* mdlm_detail_desc */
+#define USB_CDC_DMM_TYPE                0x14
+#define USB_CDC_OBEX_TYPE               0x15
+
+/* "Header Functional Descriptor" from CDC spec  5.2.3.1 */
+struct usb_cdc_header_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __le16  bcdCDC;
+} __attribute__ ((packed));
+
+/* "Call Management Descriptor" from CDC spec  5.2.3.2 */
+struct usb_cdc_call_mgmt_descriptor {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __u8    bmCapabilities;
+#define USB_CDC_CALL_MGMT_CAP_CALL_MGMT         0x01
+#define USB_CDC_CALL_MGMT_CAP_DATA_INTF         0x02
+
+        __u8    bDataInterface;
+} __attribute__ ((packed));
+
+/* "Abstract Control Management Descriptor" from CDC spec  5.2.3.3 */
+struct usb_cdc_acm_descriptor {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __u8    bmCapabilities;
+} __attribute__ ((packed));
+
+/* "Union Functional Descriptor" from CDC spec 5.2.3.8 */
+struct usb_cdc_union_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __u8    bMasterInterface0;
+        __u8    bSlaveInterface0;
+        /* ... and there could be other slave interfaces */
+} __attribute__ ((packed));
+
+/* "Ethernet Networking Functional Descriptor" from CDC spec 5.2.3.16 */
+struct usb_cdc_ether_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __u8    iMACAddress;
+        __le32  bmEthernetStatistics;
+        __le16  wMaxSegmentSize;
+        __le16  wNumberMCFilters;
+        __u8    bNumberPowerFilters;
+} __attribute__ ((packed));
+
+/* "MDLM Functional Descriptor" from CDC WMC spec 6.7.2.3 */
+struct usb_cdc_mdlm_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        __le16  bcdVersion;
+        __u8    bGUID[16];
+} __attribute__ ((packed));
+
+/* "MDLM Detail Functional Descriptor" from CDC WMC spec 6.7.2.4 */
+struct usb_cdc_mdlm_detail_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+
+        /* type is associated with mdlm_desc.bGUID */
+        __u8    bGuidDescriptorType;
+        __u8    bDetailData[];
+} __attribute__ ((packed));
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Class-Specific Control Requests (6.2)
+ *
+ * section 3.6.2.1 table 4 has the ACM profile, for modems.
+ * section 3.8.2 table 10 has the ethernet profile.
+ *
+ * Microsoft's RNDIS stack for Ethernet is a vendor-specific CDC ACM variant,
+ * heavily dependent on the encapsulated (proprietary) command mechanism.
+ */
+
+#define USB_CDC_SEND_ENCAPSULATED_COMMAND       0x00
+#define USB_CDC_GET_ENCAPSULATED_RESPONSE       0x01
+#define USB_CDC_REQ_SET_LINE_CODING             0x20
+#define USB_CDC_REQ_GET_LINE_CODING             0x21
+#define USB_CDC_REQ_SET_CONTROL_LINE_STATE      0x22
+#define USB_CDC_REQ_SEND_BREAK                  0x23
+#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS  0x40
+#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER  0x41
+#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER  0x42
+#define USB_CDC_SET_ETHERNET_PACKET_FILTER      0x43
+#define USB_CDC_GET_ETHERNET_STATISTIC          0x44
+
+/* Line Coding Structure from CDC spec 6.2.13 */
+struct usb_cdc_line_coding {
+        __le32  dwDTERate;
+        __u8    bCharFormat;
+#define USB_CDC_1_STOP_BITS                     0
+#define USB_CDC_1_5_STOP_BITS                   1
+#define USB_CDC_2_STOP_BITS                     2
+
+        __u8    bParityType;
+#define USB_CDC_NO_PARITY                       0
+#define USB_CDC_ODD_PARITY                      1
+#define USB_CDC_EVEN_PARITY                     2
+#define USB_CDC_MARK_PARITY                     3
+#define USB_CDC_SPACE_PARITY                    4
+
+        __u8    bDataBits;
+} __attribute__ ((packed));
+
+/* table 62; bits in multicast filter */
+#define USB_CDC_PACKET_TYPE_PROMISCUOUS         (1 << 0)
+#define USB_CDC_PACKET_TYPE_ALL_MULTICAST       (1 << 1) /* no filter */
+#define USB_CDC_PACKET_TYPE_DIRECTED            (1 << 2)
+#define USB_CDC_PACKET_TYPE_BROADCAST           (1 << 3)
+#define USB_CDC_PACKET_TYPE_MULTICAST           (1 << 4) /* filtered */
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Class-Specific Notifications (6.3) sent by interrupt transfers
+ *
+ * section 3.8.2 table 11 of the CDC spec lists Ethernet notifications
+ * section 3.6.2.1 table 5 specifies ACM notifications, accepted by RNDIS
+ * RNDIS also defines its own bit-incompatible notifications
+ */
+
+#define USB_CDC_NOTIFY_NETWORK_CONNECTION       0x00
+#define USB_CDC_NOTIFY_RESPONSE_AVAILABLE       0x01
+#define USB_CDC_NOTIFY_SERIAL_STATE             0x20
+#define USB_CDC_NOTIFY_SPEED_CHANGE             0x2a
+
+struct usb_cdc_notification {
+        __u8    bmRequestType;
+        __u8    bNotificationType;
+        __le16  wValue;
+        __le16  wIndex;
+        __le16  wLength;
+} __attribute__ ((packed));
+
diff --git a/include/linux/usb_ch9.h b/include/linux/usb_ch9.h
new file mode 100644
index 000000000000..f5fe94e09a03
--- /dev/null
+++ b/include/linux/usb_ch9.h
@@ -0,0 +1,384 @@
+/*
+ * This file holds USB constants and structures that are needed for USB
+ * device APIs.  These are used by the USB device model, which is defined
+ * in chapter 9 of the USB 2.0 specification.  Linux has several APIs in C
+ * that need these:
+ *
+ * - the master/host side Linux-USB kernel driver API;
+ * - the "usbfs" user space API; and
+ * - (eventually) a Linux "gadget" slave/device side driver API.
+ *
+ * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
+ * act either as a USB master/host or as a USB slave/device.  That means
+ * the master and slave side APIs will benefit from working well together.
+ */
+
+#ifndef __LINUX_USB_CH9_H
+#define __LINUX_USB_CH9_H
+
+#include <asm/types.h>          /* __u8 etc */
+
+/*-------------------------------------------------------------------------*/
+
+/* CONTROL REQUEST SUPPORT */
+
+/*
+ * USB directions
+ *
+ * This bit flag is used in endpoint descriptors' bEndpointAddress field.
+ * It's also one of three fields in control requests bRequestType.
+ */
+#define USB_DIR_OUT                     0               /* to device */
+#define USB_DIR_IN                      0x80            /* to host */
+
+/*
+ * USB types, the second of three bRequestType fields
+ */
+#define USB_TYPE_MASK                   (0x03 << 5)
+#define USB_TYPE_STANDARD               (0x00 << 5)
+#define USB_TYPE_CLASS                  (0x01 << 5)
+#define USB_TYPE_VENDOR                 (0x02 << 5)
+#define USB_TYPE_RESERVED               (0x03 << 5)
+
+/*
+ * USB recipients, the third of three bRequestType fields
+ */
+#define USB_RECIP_MASK                  0x1f
+#define USB_RECIP_DEVICE                0x00
+#define USB_RECIP_INTERFACE             0x01
+#define USB_RECIP_ENDPOINT              0x02
+#define USB_RECIP_OTHER                 0x03
+
+/*
+ * Standard requests, for the bRequest field of a SETUP packet.
+ *
+ * These are qualified by the bRequestType field, so that for example
+ * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved
+ * by a GET_STATUS request.
+ */
+#define USB_REQ_GET_STATUS              0x00
+#define USB_REQ_CLEAR_FEATURE           0x01
+#define USB_REQ_SET_FEATURE             0x03
+#define USB_REQ_SET_ADDRESS             0x05
+#define USB_REQ_GET_DESCRIPTOR          0x06
+#define USB_REQ_SET_DESCRIPTOR          0x07
+#define USB_REQ_GET_CONFIGURATION       0x08
+#define USB_REQ_SET_CONFIGURATION       0x09
+#define USB_REQ_GET_INTERFACE           0x0A
+#define USB_REQ_SET_INTERFACE           0x0B
+#define USB_REQ_SYNCH_FRAME             0x0C
+
+/*
+ * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and
+ * are read as a bit array returned by USB_REQ_GET_STATUS.  (So there
+ * are at most sixteen features of each type.)
+ */
+#define USB_DEVICE_SELF_POWERED         0       /* (read only) */
+#define USB_DEVICE_REMOTE_WAKEUP        1       /* dev may initiate wakeup */
+#define USB_DEVICE_TEST_MODE            2       /* (high speed only) */
+#define USB_DEVICE_B_HNP_ENABLE         3       /* dev may initiate HNP */
+#define USB_DEVICE_A_HNP_SUPPORT        4       /* RH port supports HNP */
+#define USB_DEVICE_A_ALT_HNP_SUPPORT    5       /* other RH port does */
+#define USB_DEVICE_DEBUG_MODE           6       /* (special devices only) */
+
+#define USB_ENDPOINT_HALT               0       /* IN/OUT will STALL */
+
+
+/**
+ * struct usb_ctrlrequest - SETUP data for a USB device control request
+ * @bRequestType: matches the USB bmRequestType field
+ * @bRequest: matches the USB bRequest field
+ * @wValue: matches the USB wValue field (le16 byte order)
+ * @wIndex: matches the USB wIndex field (le16 byte order)
+ * @wLength: matches the USB wLength field (le16 byte order)
+ *
+ * This structure is used to send control requests to a USB device.  It matches
+ * the different fields of the USB 2.0 Spec section 9.3, table 9-2.  See the
+ * USB spec for a fuller description of the different fields, and what they are
+ * used for.
+ *
+ * Note that the driver for any interface can issue control requests.
+ * For most devices, interfaces don't coordinate with each other, so
+ * such requests may be made at any time.
+ */
+struct usb_ctrlrequest {
+        __u8 bRequestType;
+        __u8 bRequest;
+        __le16 wValue;
+        __le16 wIndex;
+        __le16 wLength;
+} __attribute__ ((packed));
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or
+ * (rarely) accepted by SET_DESCRIPTOR.
+ *
+ * Note that all multi-byte values here are encoded in little endian
+ * byte order "on the wire".  But when exposed through Linux-USB APIs,
+ * they've been converted to cpu byte order.
+ */
+
+/*
+ * Descriptor types ... USB 2.0 spec table 9.5
+ */
+#define USB_DT_DEVICE                   0x01
+#define USB_DT_CONFIG                   0x02
+#define USB_DT_STRING                   0x03
+#define USB_DT_INTERFACE                0x04
+#define USB_DT_ENDPOINT                 0x05
+#define USB_DT_DEVICE_QUALIFIER         0x06
+#define USB_DT_OTHER_SPEED_CONFIG       0x07
+#define USB_DT_INTERFACE_POWER          0x08
+/* these are from a minor usb 2.0 revision (ECN) */
+#define USB_DT_OTG                      0x09
+#define USB_DT_DEBUG                    0x0a
+#define USB_DT_INTERFACE_ASSOCIATION    0x0b
+
+/* conventional codes for class-specific descriptors */
+#define USB_DT_CS_DEVICE                0x21
+#define USB_DT_CS_CONFIG                0x22
+#define USB_DT_CS_STRING                0x23
+#define USB_DT_CS_INTERFACE             0x24
+#define USB_DT_CS_ENDPOINT              0x25
+
+/* All standard descriptors have these 2 fields at the beginning */
+struct usb_descriptor_header {
+        __u8  bLength;
+        __u8  bDescriptorType;
+} __attribute__ ((packed));
+
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_DEVICE: Device descriptor */
+struct usb_device_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __le16 bcdUSB;
+        __u8  bDeviceClass;
+        __u8  bDeviceSubClass;
+        __u8  bDeviceProtocol;
+        __u8  bMaxPacketSize0;
+        __le16 idVendor;
+        __le16 idProduct;
+        __le16 bcdDevice;
+        __u8  iManufacturer;
+        __u8  iProduct;
+        __u8  iSerialNumber;
+        __u8  bNumConfigurations;
+} __attribute__ ((packed));
+
+#define USB_DT_DEVICE_SIZE              18
+
+
+/*
+ * Device and/or Interface Class codes
+ * as found in bDeviceClass or bInterfaceClass
+ * and defined by www.usb.org documents
+ */
+#define USB_CLASS_PER_INTERFACE         0       /* for DeviceClass */
+#define USB_CLASS_AUDIO                 1
+#define USB_CLASS_COMM                  2
+#define USB_CLASS_HID                   3
+#define USB_CLASS_PHYSICAL              5
+#define USB_CLASS_STILL_IMAGE           6
+#define USB_CLASS_PRINTER               7
+#define USB_CLASS_MASS_STORAGE          8
+#define USB_CLASS_HUB                   9
+#define USB_CLASS_CDC_DATA              0x0a
+#define USB_CLASS_CSCID                 0x0b    /* chip+ smart card */
+#define USB_CLASS_CONTENT_SEC           0x0d    /* content security */
+#define USB_CLASS_VIDEO                 0x0e
+#define USB_CLASS_APP_SPEC              0xfe
+#define USB_CLASS_VENDOR_SPEC           0xff
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_CONFIG: Configuration descriptor information.
+ *
+ * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
+ * descriptor type is different.  Highspeed-capable devices can look
+ * different depending on what speed they're currently running.  Only
+ * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
+ * descriptors.
+ */
+struct usb_config_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __le16 wTotalLength;
+        __u8  bNumInterfaces;
+        __u8  bConfigurationValue;
+        __u8  iConfiguration;
+        __u8  bmAttributes;
+        __u8  bMaxPower;
+} __attribute__ ((packed));
+
+#define USB_DT_CONFIG_SIZE              9
+
+/* from config descriptor bmAttributes */
+#define USB_CONFIG_ATT_ONE              (1 << 7)        /* must be set */
+#define USB_CONFIG_ATT_SELFPOWER        (1 << 6)        /* self powered */
+#define USB_CONFIG_ATT_WAKEUP           (1 << 5)        /* can wakeup */
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_STRING: String descriptor */
+struct usb_string_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __le16 wData[1];                /* UTF-16LE encoded */
+} __attribute__ ((packed));
+
+/* note that "string" zero is special, it holds language codes that
+ * the device supports, not Unicode characters.
+ */
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_INTERFACE: Interface descriptor */
+struct usb_interface_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bInterfaceNumber;
+        __u8  bAlternateSetting;
+        __u8  bNumEndpoints;
+        __u8  bInterfaceClass;
+        __u8  bInterfaceSubClass;
+        __u8  bInterfaceProtocol;
+        __u8  iInterface;
+} __attribute__ ((packed));
+
+#define USB_DT_INTERFACE_SIZE           9
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_ENDPOINT: Endpoint descriptor */
+struct usb_endpoint_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bEndpointAddress;
+        __u8  bmAttributes;
+        __le16 wMaxPacketSize;
+        __u8  bInterval;
+
+        // NOTE:  these two are _only_ in audio endpoints.
+        // use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof.
+        __u8  bRefresh;
+        __u8  bSynchAddress;
+} __attribute__ ((packed));
+
+#define USB_DT_ENDPOINT_SIZE            7
+#define USB_DT_ENDPOINT_AUDIO_SIZE      9       /* Audio extension */
+
+
+/*
+ * Endpoints
+ */
+#define USB_ENDPOINT_NUMBER_MASK        0x0f    /* in bEndpointAddress */
+#define USB_ENDPOINT_DIR_MASK           0x80
+
+#define USB_ENDPOINT_XFERTYPE_MASK      0x03    /* in bmAttributes */
+#define USB_ENDPOINT_XFER_CONTROL       0
+#define USB_ENDPOINT_XFER_ISOC          1
+#define USB_ENDPOINT_XFER_BULK          2
+#define USB_ENDPOINT_XFER_INT           3
+
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
+struct usb_qualifier_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __le16 bcdUSB;
+        __u8  bDeviceClass;
+        __u8  bDeviceSubClass;
+        __u8  bDeviceProtocol;
+        __u8  bMaxPacketSize0;
+        __u8  bNumConfigurations;
+        __u8  bRESERVED;
+} __attribute__ ((packed));
+
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_OTG (from OTG 1.0a supplement) */
+struct usb_otg_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bmAttributes;     /* support for HNP, SRP, etc */
+} __attribute__ ((packed));
+
+/* from usb_otg_descriptor.bmAttributes */
+#define USB_OTG_SRP             (1 << 0)
+#define USB_OTG_HNP             (1 << 1)        /* swap host/device roles */
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_DEBUG:  for special highspeed devices, replacing serial console */
+struct usb_debug_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        /* bulk endpoints with 8 byte maxpacket */
+        __u8  bDebugInEndpoint;
+        __u8  bDebugOutEndpoint;
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* USB_DT_INTERFACE_ASSOCIATION: groups interfaces */
+struct usb_interface_assoc_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bFirstInterface;
+        __u8  bInterfaceCount;
+        __u8  bFunctionClass;
+        __u8  bFunctionSubClass;
+        __u8  bFunctionProtocol;
+        __u8  iFunction;
+} __attribute__ ((packed));
+
+
+/*-------------------------------------------------------------------------*/
+
+/* USB 2.0 defines three speeds, here's how Linux identifies them */
+
+enum usb_device_speed {
+        USB_SPEED_UNKNOWN = 0,                  /* enumerating */
+        USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
+        USB_SPEED_HIGH                          /* usb 2.0 */
+};
+
+enum usb_device_state {
+        /* NOTATTACHED isn't in the USB spec, and this state acts
+         * the same as ATTACHED ... but it's clearer this way.
+         */
+        USB_STATE_NOTATTACHED = 0,
+
+        /* the chapter 9 device states */
+        USB_STATE_ATTACHED,
+        USB_STATE_POWERED,
+        USB_STATE_DEFAULT,                      /* limited function */
+        USB_STATE_ADDRESS,
+        USB_STATE_CONFIGURED,                   /* most functions */
+
+        USB_STATE_SUSPENDED
+
+        /* NOTE:  there are actually four different SUSPENDED
+         * states, returning to POWERED, DEFAULT, ADDRESS, or
+         * CONFIGURED respectively when SOF tokens flow again.
+         */
+};
+
+#endif  /* __LINUX_USB_CH9_H */
diff --git a/include/linux/usb_gadget.h b/include/linux/usb_gadget.h
new file mode 100644
index 000000000000..9bba9997947b
--- /dev/null
+++ b/include/linux/usb_gadget.h
@@ -0,0 +1,878 @@
+/*
+ * <linux/usb_gadget.h>
+ *
+ * We call the USB code inside a Linux-based peripheral device a "gadget"
+ * driver, except for the hardware-specific bus glue.  One USB host can
+ * master many USB gadgets, but the gadgets are only slaved to one host.
+ *
+ *
+ * (C) Copyright 2002-2004 by David Brownell
+ * All Rights Reserved.
+ *
+ * This software is licensed under the GNU GPL version 2.
+ */
+
+#ifndef __LINUX_USB_GADGET_H
+#define __LINUX_USB_GADGET_H
+
+#ifdef __KERNEL__
+
+struct usb_ep;
+
+/**
+ * struct usb_request - describes one i/o request
+ * @buf: Buffer used for data.  Always provide this; some controllers
+ *      only use PIO, or don't use DMA for some endpoints.
+ * @dma: DMA address corresponding to 'buf'.  If you don't set this
+ *      field, and the usb controller needs one, it is responsible
+ *      for mapping and unmapping the buffer.
+ * @length: Length of that data
+ * @no_interrupt: If true, hints that no completion irq is needed.
+ *      Helpful sometimes with deep request queues that are handled
+ *      directly by DMA controllers.
+ * @zero: If true, when writing data, makes the last packet be "short"
+ *     by adding a zero length packet as needed;
+ * @short_not_ok: When reading data, makes short packets be
+ *     treated as errors (queue stops advancing till cleanup).
+ * @complete: Function called when request completes, so this request and
+ *      its buffer may be re-used.
+ *      Reads terminate with a short packet, or when the buffer fills,
+ *      whichever comes first.  When writes terminate, some data bytes
+ *      will usually still be in flight (often in a hardware fifo).
+ *      Errors (for reads or writes) stop the queue from advancing
+ *      until the completion function returns, so that any transfers
+ *      invalidated by the error may first be dequeued.
+ * @context: For use by the completion callback
+ * @list: For use by the gadget driver.
+ * @status: Reports completion code, zero or a negative errno.
+ *      Normally, faults block the transfer queue from advancing until
+ *      the completion callback returns.
+ *      Code "-ESHUTDOWN" indicates completion caused by device disconnect,
+ *      or when the driver disabled the endpoint.
+ * @actual: Reports bytes transferred to/from the buffer.  For reads (OUT
+ *      transfers) this may be less than the requested length.  If the
+ *      short_not_ok flag is set, short reads are treated as errors
+ *      even when status otherwise indicates successful completion.
+ *      Note that for writes (IN transfers) some data bytes may still
+ *      reside in a device-side FIFO when the request is reported as
+ *      complete.
+ *
+ * These are allocated/freed through the endpoint they're used with.  The
+ * hardware's driver can add extra per-request data to the memory it returns,
+ * which often avoids separate memory allocations (potential failures),
+ * later when the request is queued.
+ *
+ * Request flags affect request handling, such as whether a zero length
+ * packet is written (the "zero" flag), whether a short read should be
+ * treated as an error (blocking request queue advance, the "short_not_ok"
+ * flag), or hinting that an interrupt is not required (the "no_interrupt"
+ * flag, for use with deep request queues).
+ *
+ * Bulk endpoints can use any size buffers, and can also be used for interrupt
+ * transfers. interrupt-only endpoints can be much less functional.
+ */
+        // NOTE this is analagous to 'struct urb' on the host side,
+        // except that it's thinner and promotes more pre-allocation.
+
+struct usb_request {
+        void                    *buf;
+        unsigned                length;
+        dma_addr_t              dma;
+
+        unsigned                no_interrupt:1;
+        unsigned                zero:1;
+        unsigned                short_not_ok:1;
+
+        void                    (*complete)(struct usb_ep *ep,
+                                        struct usb_request *req);
+        void                    *context;
+        struct list_head        list;
+
+        int                     status;
+        unsigned                actual;
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* endpoint-specific parts of the api to the usb controller hardware.
+ * unlike the urb model, (de)multiplexing layers are not required.
+ * (so this api could slash overhead if used on the host side...)
+ *
+ * note that device side usb controllers commonly differ in how many
+ * endpoints they support, as well as their capabilities.
+ */
+struct usb_ep_ops {
+        int (*enable) (struct usb_ep *ep,
+                const struct usb_endpoint_descriptor *desc);
+        int (*disable) (struct usb_ep *ep);
+
+        struct usb_request *(*alloc_request) (struct usb_ep *ep,
+                int gfp_flags);
+        void (*free_request) (struct usb_ep *ep, struct usb_request *req);
+
+        void *(*alloc_buffer) (struct usb_ep *ep, unsigned bytes,
+                dma_addr_t *dma, int gfp_flags);
+        void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
+                unsigned bytes);
+        // NOTE:  on 2.6, drivers may also use dma_map() and
+        // dma_sync_single_*() to directly manage dma overhead. 
+
+        int (*queue) (struct usb_ep *ep, struct usb_request *req,
+                int gfp_flags);
+        int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
+
+        int (*set_halt) (struct usb_ep *ep, int value);
+        int (*fifo_status) (struct usb_ep *ep);
+        void (*fifo_flush) (struct usb_ep *ep);
+};
+
+/**
+ * struct usb_ep - device side representation of USB endpoint
+ * @name:identifier for the endpoint, such as "ep-a" or "ep9in-bulk"
+ * @ops: Function pointers used to access hardware-specific operations.
+ * @ep_list:the gadget's ep_list holds all of its endpoints
+ * @maxpacket:The maximum packet size used on this endpoint.  The initial
+ *      value can sometimes be reduced (hardware allowing), according to
+ *      the endpoint descriptor used to configure the endpoint.
+ * @driver_data:for use by the gadget driver.  all other fields are
+ *      read-only to gadget drivers.
+ *
+ * the bus controller driver lists all the general purpose endpoints in
+ * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
+ * and is accessed only in response to a driver setup() callback.
+ */
+struct usb_ep {
+        void                    *driver_data;
+
+        const char              *name;
+        const struct usb_ep_ops *ops;
+        struct list_head        ep_list;
+        unsigned                maxpacket:16;
+};
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_ep_enable - configure endpoint, making it usable
+ * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
+ *      drivers discover endpoints through the ep_list of a usb_gadget.
+ * @desc:descriptor for desired behavior.  caller guarantees this pointer
+ *      remains valid until the endpoint is disabled; the data byte order
+ *      is little-endian (usb-standard).
+ *
+ * when configurations are set, or when interface settings change, the driver
+ * will enable or disable the relevant endpoints.  while it is enabled, an
+ * endpoint may be used for i/o until the driver receives a disconnect() from
+ * the host or until the endpoint is disabled.
+ *
+ * the ep0 implementation (which calls this routine) must ensure that the
+ * hardware capabilities of each endpoint match the descriptor provided
+ * for it.  for example, an endpoint named "ep2in-bulk" would be usable
+ * for interrupt transfers as well as bulk, but it likely couldn't be used
+ * for iso transfers or for endpoint 14.  some endpoints are fully
+ * configurable, with more generic names like "ep-a".  (remember that for
+ * USB, "in" means "towards the USB master".)
+ *
+ * returns zero, or a negative error code.
+ */
+static inline int
+usb_ep_enable (struct usb_ep *ep, const struct usb_endpoint_descriptor *desc)
+{
+        return ep->ops->enable (ep, desc);
+}
+
+/**
+ * usb_ep_disable - endpoint is no longer usable
+ * @ep:the endpoint being unconfigured.  may not be the endpoint named "ep0".
+ *
+ * no other task may be using this endpoint when this is called.
+ * any pending and uncompleted requests will complete with status
+ * indicating disconnect (-ESHUTDOWN) before this call returns.
+ * gadget drivers must call usb_ep_enable() again before queueing
+ * requests to the endpoint.
+ *
+ * returns zero, or a negative error code.
+ */
+static inline int
+usb_ep_disable (struct usb_ep *ep)
+{
+        return ep->ops->disable (ep);
+}
+
+/**
+ * usb_ep_alloc_request - allocate a request object to use with this endpoint
+ * @ep:the endpoint to be used with with the request
+ * @gfp_flags:GFP_* flags to use
+ *
+ * Request objects must be allocated with this call, since they normally
+ * need controller-specific setup and may even need endpoint-specific
+ * resources such as allocation of DMA descriptors.
+ * Requests may be submitted with usb_ep_queue(), and receive a single
+ * completion callback.  Free requests with usb_ep_free_request(), when
+ * they are no longer needed.
+ *
+ * Returns the request, or null if one could not be allocated.
+ */
+static inline struct usb_request *
+usb_ep_alloc_request (struct usb_ep *ep, int gfp_flags)
+{
+        return ep->ops->alloc_request (ep, gfp_flags);
+}
+
+/**
+ * usb_ep_free_request - frees a request object
+ * @ep:the endpoint associated with the request
+ * @req:the request being freed
+ *
+ * Reverses the effect of usb_ep_alloc_request().
+ * Caller guarantees the request is not queued, and that it will
+ * no longer be requeued (or otherwise used).
+ */
+static inline void
+usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
+{
+        ep->ops->free_request (ep, req);
+}
+
+/**
+ * usb_ep_alloc_buffer - allocate an I/O buffer
+ * @ep:the endpoint associated with the buffer
+ * @len:length of the desired buffer
+ * @dma:pointer to the buffer's DMA address; must be valid
+ * @gfp_flags:GFP_* flags to use
+ *
+ * Returns a new buffer, or null if one could not be allocated.
+ * The buffer is suitably aligned for dma, if that endpoint uses DMA,
+ * and the caller won't have to care about dma-inconsistency
+ * or any hidden "bounce buffer" mechanism.  No additional per-request
+ * DMA mapping will be required for such buffers.
+ * Free it later with usb_ep_free_buffer().
+ *
+ * You don't need to use this call to allocate I/O buffers unless you
+ * want to make sure drivers don't incur costs for such "bounce buffer"
+ * copies or per-request DMA mappings.
+ */
+static inline void *
+usb_ep_alloc_buffer (struct usb_ep *ep, unsigned len, dma_addr_t *dma,
+        int gfp_flags)
+{
+        return ep->ops->alloc_buffer (ep, len, dma, gfp_flags);
+}
+
+/**
+ * usb_ep_free_buffer - frees an i/o buffer
+ * @ep:the endpoint associated with the buffer
+ * @buf:CPU view address of the buffer
+ * @dma:the buffer's DMA address
+ * @len:length of the buffer
+ *
+ * reverses the effect of usb_ep_alloc_buffer().
+ * caller guarantees the buffer will no longer be accessed
+ */
+static inline void
+usb_ep_free_buffer (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned len)
+{
+        ep->ops->free_buffer (ep, buf, dma, len);
+}
+
+/**
+ * usb_ep_queue - queues (submits) an I/O request to an endpoint.
+ * @ep:the endpoint associated with the request
+ * @req:the request being submitted
+ * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
+ *      pre-allocate all necessary memory with the request.
+ *
+ * This tells the device controller to perform the specified request through
+ * that endpoint (reading or writing a buffer).  When the request completes,
+ * including being canceled by usb_ep_dequeue(), the request's completion
+ * routine is called to return the request to the driver.  Any endpoint
+ * (except control endpoints like ep0) may have more than one transfer
+ * request queued; they complete in FIFO order.  Once a gadget driver
+ * submits a request, that request may not be examined or modified until it
+ * is given back to that driver through the completion callback.
+ *
+ * Each request is turned into one or more packets.  The controller driver
+ * never merges adjacent requests into the same packet.  OUT transfers
+ * will sometimes use data that's already buffered in the hardware.
+ * Drivers can rely on the fact that the first byte of the request's buffer
+ * always corresponds to the first byte of some USB packet, for both
+ * IN and OUT transfers.
+ *
+ * Bulk endpoints can queue any amount of data; the transfer is packetized
+ * automatically.  The last packet will be short if the request doesn't fill it
+ * out completely.  Zero length packets (ZLPs) should be avoided in portable
+ * protocols since not all usb hardware can successfully handle zero length
+ * packets.  (ZLPs may be explicitly written, and may be implicitly written if
+ * the request 'zero' flag is set.)  Bulk endpoints may also be used
+ * for interrupt transfers; but the reverse is not true, and some endpoints
+ * won't support every interrupt transfer.  (Such as 768 byte packets.)
+ *
+ * Interrupt-only endpoints are less functional than bulk endpoints, for
+ * example by not supporting queueing or not handling buffers that are
+ * larger than the endpoint's maxpacket size.  They may also treat data
+ * toggle differently.
+ *
+ * Control endpoints ... after getting a setup() callback, the driver queues
+ * one response (even if it would be zero length).  That enables the
+ * status ack, after transfering data as specified in the response.  Setup
+ * functions may return negative error codes to generate protocol stalls.
+ * (Note that some USB device controllers disallow protocol stall responses
+ * in some cases.)  When control responses are deferred (the response is
+ * written after the setup callback returns), then usb_ep_set_halt() may be
+ * used on ep0 to trigger protocol stalls.
+ *
+ * For periodic endpoints, like interrupt or isochronous ones, the usb host
+ * arranges to poll once per interval, and the gadget driver usually will
+ * have queued some data to transfer at that time.
+ *
+ * Returns zero, or a negative error code.  Endpoints that are not enabled
+ * report errors; errors will also be
+ * reported when the usb peripheral is disconnected.
+ */
+static inline int
+usb_ep_queue (struct usb_ep *ep, struct usb_request *req, int gfp_flags)
+{
+        return ep->ops->queue (ep, req, gfp_flags);
+}
+
+/**
+ * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
+ * @ep:the endpoint associated with the request
+ * @req:the request being canceled
+ *
+ * if the request is still active on the endpoint, it is dequeued and its
+ * completion routine is called (with status -ECONNRESET); else a negative
+ * error code is returned.
+ *
+ * note that some hardware can't clear out write fifos (to unlink the request
+ * at the head of the queue) except as part of disconnecting from usb.  such
+ * restrictions prevent drivers from supporting configuration changes,
+ * even to configuration zero (a "chapter 9" requirement).
+ */
+static inline int usb_ep_dequeue (struct usb_ep *ep, struct usb_request *req)
+{
+        return ep->ops->dequeue (ep, req);
+}
+
+/**
+ * usb_ep_set_halt - sets the endpoint halt feature.
+ * @ep: the non-isochronous endpoint being stalled
+ *
+ * Use this to stall an endpoint, perhaps as an error report.
+ * Except for control endpoints,
+ * the endpoint stays halted (will not stream any data) until the host
+ * clears this feature; drivers may need to empty the endpoint's request
+ * queue first, to make sure no inappropriate transfers happen.
+ *
+ * Note that while an endpoint CLEAR_FEATURE will be invisible to the
+ * gadget driver, a SET_INTERFACE will not be.  To reset endpoints for the
+ * current altsetting, see usb_ep_clear_halt().  When switching altsettings,
+ * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
+ *
+ * Returns zero, or a negative error code.  On success, this call sets
+ * underlying hardware state that blocks data transfers.
+ * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
+ * transfer requests are still queued, or if the controller hardware
+ * (usually a FIFO) still holds bytes that the host hasn't collected.
+ */
+static inline int
+usb_ep_set_halt (struct usb_ep *ep)
+{
+        return ep->ops->set_halt (ep, 1);
+}
+
+/**
+ * usb_ep_clear_halt - clears endpoint halt, and resets toggle
+ * @ep:the bulk or interrupt endpoint being reset
+ *
+ * Use this when responding to the standard usb "set interface" request,
+ * for endpoints that aren't reconfigured, after clearing any other state
+ * in the endpoint's i/o queue.
+ *
+ * Returns zero, or a negative error code.  On success, this call clears
+ * the underlying hardware state reflecting endpoint halt and data toggle.
+ * Note that some hardware can't support this request (like pxa2xx_udc),
+ * and accordingly can't correctly implement interface altsettings.
+ */
+static inline int
+usb_ep_clear_halt (struct usb_ep *ep)
+{
+        return ep->ops->set_halt (ep, 0);
+}
+
+/**
+ * usb_ep_fifo_status - returns number of bytes in fifo, or error
+ * @ep: the endpoint whose fifo status is being checked.
+ *
+ * FIFO endpoints may have "unclaimed data" in them in certain cases,
+ * such as after aborted transfers.  Hosts may not have collected all
+ * the IN data written by the gadget driver (and reported by a request
+ * completion).  The gadget driver may not have collected all the data
+ * written OUT to it by the host.  Drivers that need precise handling for
+ * fault reporting or recovery may need to use this call.
+ *
+ * This returns the number of such bytes in the fifo, or a negative
+ * errno if the endpoint doesn't use a FIFO or doesn't support such
+ * precise handling.
+ */
+static inline int
+usb_ep_fifo_status (struct usb_ep *ep)
+{
+        if (ep->ops->fifo_status)
+                return ep->ops->fifo_status (ep);
+        else
+                return -EOPNOTSUPP;
+}
+
+/**
+ * usb_ep_fifo_flush - flushes contents of a fifo
+ * @ep: the endpoint whose fifo is being flushed.
+ *
+ * This call may be used to flush the "unclaimed data" that may exist in
+ * an endpoint fifo after abnormal transaction terminations.  The call
+ * must never be used except when endpoint is not being used for any
+ * protocol translation.
+ */
+static inline void
+usb_ep_fifo_flush (struct usb_ep *ep)
+{
+        if (ep->ops->fifo_flush)
+                ep->ops->fifo_flush (ep);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+struct usb_gadget;
+
+/* the rest of the api to the controller hardware: device operations,
+ * which don't involve endpoints (or i/o).
+ */
+struct usb_gadget_ops {
+        int     (*get_frame)(struct usb_gadget *);
+        int     (*wakeup)(struct usb_gadget *);
+        int     (*set_selfpowered) (struct usb_gadget *, int is_selfpowered);
+        int     (*vbus_session) (struct usb_gadget *, int is_active);
+        int     (*vbus_draw) (struct usb_gadget *, unsigned mA);
+        int     (*pullup) (struct usb_gadget *, int is_on);
+        int     (*ioctl)(struct usb_gadget *,
+                                unsigned code, unsigned long param);
+};
+
+/**
+ * struct usb_gadget - represents a usb slave device
+ * @ops: Function pointers used to access hardware-specific operations.
+ * @ep0: Endpoint zero, used when reading or writing responses to
+ *      driver setup() requests
+ * @ep_list: List of other endpoints supported by the device.
+ * @speed: Speed of current connection to USB host.
+ * @is_dualspeed: True if the controller supports both high and full speed
+ *      operation.  If it does, the gadget driver must also support both.
+ * @is_otg: True if the USB device port uses a Mini-AB jack, so that the
+ *      gadget driver must provide a USB OTG descriptor.
+ * @is_a_peripheral: False unless is_otg, the "A" end of a USB cable
+ *      is in the Mini-AB jack, and HNP has been used to switch roles
+ *      so that the "A" device currently acts as A-Peripheral, not A-Host.
+ * @a_hnp_support: OTG device feature flag, indicating that the A-Host
+ *      supports HNP at this port.
+ * @a_alt_hnp_support: OTG device feature flag, indicating that the A-Host
+ *      only supports HNP on a different root port.
+ * @b_hnp_enable: OTG device feature flag, indicating that the A-Host
+ *      enabled HNP support.
+ * @name: Identifies the controller hardware type.  Used in diagnostics
+ *      and sometimes configuration.
+ * @dev: Driver model state for this abstract device.
+ *
+ * Gadgets have a mostly-portable "gadget driver" implementing device
+ * functions, handling all usb configurations and interfaces.  Gadget
+ * drivers talk to hardware-specific code indirectly, through ops vectors.
+ * That insulates the gadget driver from hardware details, and packages
+ * the hardware endpoints through generic i/o queues.  The "usb_gadget"
+ * and "usb_ep" interfaces provide that insulation from the hardware.
+ *
+ * Except for the driver data, all fields in this structure are
+ * read-only to the gadget driver.  That driver data is part of the
+ * "driver model" infrastructure in 2.6 (and later) kernels, and for
+ * earlier systems is grouped in a similar structure that's not known
+ * to the rest of the kernel.
+ *
+ * Values of the three OTG device feature flags are updated before the
+ * setup() call corresponding to USB_REQ_SET_CONFIGURATION, and before
+ * driver suspend() calls.  They are valid only when is_otg, and when the
+ * device is acting as a B-Peripheral (so is_a_peripheral is false).
+ */
+struct usb_gadget {
+        /* readonly to gadget driver */
+        const struct usb_gadget_ops     *ops;
+        struct usb_ep                   *ep0;
+        struct list_head                ep_list;        /* of usb_ep */
+        enum usb_device_speed           speed;
+        unsigned                        is_dualspeed:1;
+        unsigned                        is_otg:1;
+        unsigned                        is_a_peripheral:1;
+        unsigned                        b_hnp_enable:1;
+        unsigned                        a_hnp_support:1;
+        unsigned                        a_alt_hnp_support:1;
+        const char                      *name;
+        struct device                   dev;
+};
+
+static inline void set_gadget_data (struct usb_gadget *gadget, void *data)
+        { dev_set_drvdata (&gadget->dev, data); }
+static inline void *get_gadget_data (struct usb_gadget *gadget)
+        { return dev_get_drvdata (&gadget->dev); }
+
+/* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
+#define gadget_for_each_ep(tmp,gadget) \
+        list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)
+
+
+/**
+ * usb_gadget_frame_number - returns the current frame number
+ * @gadget: controller that reports the frame number
+ *
+ * Returns the usb frame number, normally eleven bits from a SOF packet,
+ * or negative errno if this device doesn't support this capability.
+ */
+static inline int usb_gadget_frame_number (struct usb_gadget *gadget)
+{
+        return gadget->ops->get_frame (gadget);
+}
+
+/**
+ * usb_gadget_wakeup - tries to wake up the host connected to this gadget
+ * @gadget: controller used to wake up the host
+ *
+ * Returns zero on success, else negative error code if the hardware
+ * doesn't support such attempts, or its support has not been enabled
+ * by the usb host.  Drivers must return device descriptors that report
+ * their ability to support this, or hosts won't enable it.
+ *
+ * This may also try to use SRP to wake the host and start enumeration,
+ * even if OTG isn't otherwise in use.  OTG devices may also start
+ * remote wakeup even when hosts don't explicitly enable it.
+ */
+static inline int usb_gadget_wakeup (struct usb_gadget *gadget)
+{
+        if (!gadget->ops->wakeup)
+                return -EOPNOTSUPP;
+        return gadget->ops->wakeup (gadget);
+}
+
+/**
+ * usb_gadget_set_selfpowered - sets the device selfpowered feature.
+ * @gadget:the device being declared as self-powered
+ *
+ * this affects the device status reported by the hardware driver
+ * to reflect that it now has a local power supply.
+ *
+ * returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_set_selfpowered (struct usb_gadget *gadget)
+{
+        if (!gadget->ops->set_selfpowered)
+                return -EOPNOTSUPP;
+        return gadget->ops->set_selfpowered (gadget, 1);
+}
+
+/**
+ * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
+ * @gadget:the device being declared as bus-powered
+ *
+ * this affects the device status reported by the hardware driver.
+ * some hardware may not support bus-powered operation, in which
+ * case this feature's value can never change.
+ *
+ * returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_clear_selfpowered (struct usb_gadget *gadget)
+{
+        if (!gadget->ops->set_selfpowered)
+                return -EOPNOTSUPP;
+        return gadget->ops->set_selfpowered (gadget, 0);
+}
+
+/**
+ * usb_gadget_vbus_connect - Notify controller that VBUS is powered
+ * @gadget:The device which now has VBUS power.
+ *
+ * This call is used by a driver for an external transceiver (or GPIO)
+ * that detects a VBUS power session starting.  Common responses include
+ * resuming the controller, activating the D+ (or D-) pullup to let the
+ * host detect that a USB device is attached, and starting to draw power
+ * (8mA or possibly more, especially after SET_CONFIGURATION).
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_vbus_connect(struct usb_gadget *gadget)
+{
+        if (!gadget->ops->vbus_session)
+                return -EOPNOTSUPP;
+        return gadget->ops->vbus_session (gadget, 1);
+}
+
+/**
+ * usb_gadget_vbus_draw - constrain controller's VBUS power usage
+ * @gadget:The device whose VBUS usage is being described
+ * @mA:How much current to draw, in milliAmperes.  This should be twice
+ *      the value listed in the configuration descriptor bMaxPower field.
+ *
+ * This call is used by gadget drivers during SET_CONFIGURATION calls,
+ * reporting how much power the device may consume.  For example, this
+ * could affect how quickly batteries are recharged.
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
+{
+        if (!gadget->ops->vbus_draw)
+                return -EOPNOTSUPP;
+        return gadget->ops->vbus_draw (gadget, mA);
+}
+
+/**
+ * usb_gadget_vbus_disconnect - notify controller about VBUS session end
+ * @gadget:the device whose VBUS supply is being described
+ *
+ * This call is used by a driver for an external transceiver (or GPIO)
+ * that detects a VBUS power session ending.  Common responses include
+ * reversing everything done in usb_gadget_vbus_connect().
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
+{
+        if (!gadget->ops->vbus_session)
+                return -EOPNOTSUPP;
+        return gadget->ops->vbus_session (gadget, 0);
+}
+
+/**
+ * usb_gadget_connect - software-controlled connect to USB host
+ * @gadget:the peripheral being connected
+ *
+ * Enables the D+ (or potentially D-) pullup.  The host will start
+ * enumerating this gadget when the pullup is active and a VBUS session
+ * is active (the link is powered).  This pullup is always enabled unless
+ * usb_gadget_disconnect() has been used to disable it.
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_connect (struct usb_gadget *gadget)
+{
+        if (!gadget->ops->pullup)
+                return -EOPNOTSUPP;
+        return gadget->ops->pullup (gadget, 1);
+}
+
+/**
+ * usb_gadget_disconnect - software-controlled disconnect from USB host
+ * @gadget:the peripheral being disconnected
+ *
+ * Disables the D+ (or potentially D-) pullup, which the host may see
+ * as a disconnect (when a VBUS session is active).  Not all systems
+ * support software pullup controls.
+ *
+ * This routine may be used during the gadget driver bind() call to prevent
+ * the peripheral from ever being visible to the USB host, unless later
+ * usb_gadget_connect() is called.  For example, user mode components may
+ * need to be activated before the system can talk to hosts.
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_gadget_disconnect (struct usb_gadget *gadget)
+{
+        if (!gadget->ops->pullup)
+                return -EOPNOTSUPP;
+        return gadget->ops->pullup (gadget, 0);
+}
+
+
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * struct usb_gadget_driver - driver for usb 'slave' devices
+ * @function: String describing the gadget's function
+ * @speed: Highest speed the driver handles.
+ * @bind: Invoked when the driver is bound to a gadget, usually
+ *      after registering the driver.
+ *      At that point, ep0 is fully initialized, and ep_list holds
+ *      the currently-available endpoints.
+ *      Called in a context that permits sleeping.
+ * @setup: Invoked for ep0 control requests that aren't handled by
+ *      the hardware level driver. Most calls must be handled by
+ *      the gadget driver, including descriptor and configuration
+ *      management.  The 16 bit members of the setup data are in
+ *      cpu order. Called in_interrupt; this may not sleep.  Driver
+ *      queues a response to ep0, or returns negative to stall.
+ * @disconnect: Invoked after all transfers have been stopped,
+ *      when the host is disconnected.  May be called in_interrupt; this
+ *      may not sleep.  Some devices can't detect disconnect, so this might
+ *      not be called except as part of controller shutdown.
+ * @unbind: Invoked when the driver is unbound from a gadget,
+ *      usually from rmmod (after a disconnect is reported).
+ *      Called in a context that permits sleeping.
+ * @suspend: Invoked on USB suspend.  May be called in_interrupt.
+ * @resume: Invoked on USB resume.  May be called in_interrupt.
+ * @driver: Driver model state for this driver.
+ *
+ * Devices are disabled till a gadget driver successfully bind()s, which
+ * means the driver will handle setup() requests needed to enumerate (and
+ * meet "chapter 9" requirements) then do some useful work.
+ *
+ * If gadget->is_otg is true, the gadget driver must provide an OTG
+ * descriptor during enumeration, or else fail the bind() call.  In such
+ * cases, no USB traffic may flow until both bind() returns without
+ * having called usb_gadget_disconnect(), and the USB host stack has
+ * initialized.
+ *
+ * Drivers use hardware-specific knowledge to configure the usb hardware.
+ * endpoint addressing is only one of several hardware characteristics that
+ * are in descriptors the ep0 implementation returns from setup() calls.
+ *
+ * Except for ep0 implementation, most driver code shouldn't need change to
+ * run on top of different usb controllers.  It'll use endpoints set up by
+ * that ep0 implementation.
+ *
+ * The usb controller driver handles a few standard usb requests.  Those
+ * include set_address, and feature flags for devices, interfaces, and
+ * endpoints (the get_status, set_feature, and clear_feature requests).
+ *
+ * Accordingly, the driver's setup() callback must always implement all
+ * get_descriptor requests, returning at least a device descriptor and
+ * a configuration descriptor.  Drivers must make sure the endpoint
+ * descriptors match any hardware constraints. Some hardware also constrains
+ * other descriptors. (The pxa250 allows only configurations 1, 2, or 3).
+ *
+ * The driver's setup() callback must also implement set_configuration,
+ * and should also implement set_interface, get_configuration, and
+ * get_interface.  Setting a configuration (or interface) is where
+ * endpoints should be activated or (config 0) shut down.
+ *
+ * (Note that only the default control endpoint is supported.  Neither
+ * hosts nor devices generally support control traffic except to ep0.)
+ *
+ * Most devices will ignore USB suspend/resume operations, and so will
+ * not provide those callbacks.  However, some may need to change modes
+ * when the host is not longer directing those activities.  For example,
+ * local controls (buttons, dials, etc) may need to be re-enabled since
+ * the (remote) host can't do that any longer; or an error state might
+ * be cleared, to make the device behave identically whether or not
+ * power is maintained.
+ */
+struct usb_gadget_driver {
+        char                    *function;
+        enum usb_device_speed   speed;
+        int                     (*bind)(struct usb_gadget *);
+        void                    (*unbind)(struct usb_gadget *);
+        int                     (*setup)(struct usb_gadget *,
+                                        const struct usb_ctrlrequest *);
+        void                    (*disconnect)(struct usb_gadget *);
+        void                    (*suspend)(struct usb_gadget *);
+        void                    (*resume)(struct usb_gadget *);
+
+        // FIXME support safe rmmod
+        struct device_driver    driver;
+};
+
+
+
+/*-------------------------------------------------------------------------*/
+
+/* driver modules register and unregister, as usual.
+ * these calls must be made in a context that can sleep.
+ *
+ * these will usually be implemented directly by the hardware-dependent
+ * usb bus interface driver, which will only support a single driver.
+ */
+
+/**
+ * usb_gadget_register_driver - register a gadget driver
+ * @driver:the driver being registered
+ *
+ * Call this in your gadget driver's module initialization function,
+ * to tell the underlying usb controller driver about your driver.
+ * The driver's bind() function will be called to bind it to a
+ * gadget.  This function must be called in a context that can sleep.
+ */
+int usb_gadget_register_driver (struct usb_gadget_driver *driver);
+
+/**
+ * usb_gadget_unregister_driver - unregister a gadget driver
+ * @driver:the driver being unregistered
+ *
+ * Call this in your gadget driver's module cleanup function,
+ * to tell the underlying usb controller that your driver is
+ * going away.  If the controller is connected to a USB host,
+ * it will first disconnect().  The driver is also requested
+ * to unbind() and clean up any device state, before this procedure
+ * finally returns.
+ * This function must be called in a context that can sleep.
+ */
+int usb_gadget_unregister_driver (struct usb_gadget_driver *driver);
+
+/*-------------------------------------------------------------------------*/
+
+/* utility to simplify dealing with string descriptors */
+
+/**
+ * struct usb_string - wraps a C string and its USB id
+ * @id:the (nonzero) ID for this string
+ * @s:the string, in UTF-8 encoding
+ *
+ * If you're using usb_gadget_get_string(), use this to wrap a string
+ * together with its ID.
+ */
+struct usb_string {
+        u8                      id;
+        const char              *s;
+};
+
+/**
+ * struct usb_gadget_strings - a set of USB strings in a given language
+ * @language:identifies the strings' language (0x0409 for en-us)
+ * @strings:array of strings with their ids
+ *
+ * If you're using usb_gadget_get_string(), use this to wrap all the
+ * strings for a given language.
+ */
+struct usb_gadget_strings {
+        u16                     language;       /* 0x0409 for en-us */
+        struct usb_string       *strings;
+};
+
+/* put descriptor for string with that id into buf (buflen >= 256) */
+int usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf);
+
+/*-------------------------------------------------------------------------*/
+
+/* utility to simplify managing config descriptors */
+
+/* write vector of descriptors into buffer */
+int usb_descriptor_fillbuf(void *, unsigned,
+                const struct usb_descriptor_header **);
+
+/* build config descriptor from single descriptor vector */
+int usb_gadget_config_buf(const struct usb_config_descriptor *config,
+        void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
+
+/*-------------------------------------------------------------------------*/
+
+/* utility wrapping a simple endpoint selection policy */
+
+extern struct usb_ep *usb_ep_autoconfig (struct usb_gadget *,
+                        struct usb_endpoint_descriptor *) __init;
+
+extern void usb_ep_autoconfig_reset (struct usb_gadget *) __init;
+
+#endif  /* __KERNEL__ */
+
+#endif  /* __LINUX_USB_GADGET_H */
diff --git a/include/linux/usb_gadgetfs.h b/include/linux/usb_gadgetfs.h
new file mode 100644
index 000000000000..b53d6ae8e55e
--- /dev/null
+++ b/include/linux/usb_gadgetfs.h
@@ -0,0 +1,75 @@
+
+#include <asm/types.h>
+#include <asm/ioctl.h>
+
+#include <linux/usb_ch9.h>
+
+/*
+ * Filesystem based user-mode API to USB Gadget controller hardware
+ *
+ * Almost everything can be done with only read and write operations,
+ * on endpoint files found in one directory.  They are configured by
+ * writing descriptors, and then may be used for normal stream style
+ * i/o requests.  When ep0 is configured, the device can enumerate;
+ * when it's closed, the device disconnects from usb.
+ *
+ * Configuration and device descriptors get written to /dev/gadget/$CHIP,
+ * which may then be used to read usb_gadgetfs_event structs.  The driver
+ * may activate endpoints as it handles SET_CONFIGURATION setup events,
+ * or earlier; writing endpoint descriptors to /dev/gadget/$ENDPOINT
+ * then performing data transfers by reading or writing.
+ */
+
+/*
+ * Events are delivered on the ep0 file descriptor, if the user mode driver
+ * reads from this file descriptor after writing the descriptors.  Don't
+ * stop polling this descriptor, if you write that kind of driver.
+ */
+
+enum usb_gadgetfs_event_type {
+        GADGETFS_NOP = 0,
+
+        GADGETFS_CONNECT,
+        GADGETFS_DISCONNECT,
+        GADGETFS_SETUP,
+        GADGETFS_SUSPEND,
+        // and likely more !
+};
+
+struct usb_gadgetfs_event {
+        enum usb_gadgetfs_event_type    type;
+        union {
+                // NOP, DISCONNECT, SUSPEND: nothing
+                // ... some hardware can't report disconnection
+
+                // CONNECT: just the speed
+                enum usb_device_speed   speed;
+
+                // SETUP: packet; DATA phase i/o precedes next event
+                // (setup.bmRequestType & USB_DIR_IN) flags direction 
+                // ... includes SET_CONFIGURATION, SET_INTERFACE
+                struct usb_ctrlrequest  setup;
+        } u;
+};
+
+
+/* endpoint ioctls */
+
+/* IN transfers may be reported to the gadget driver as complete
+ *      when the fifo is loaded, before the host reads the data;
+ * OUT transfers may be reported to the host's "client" driver as
+ *      complete when they're sitting in the FIFO unread.
+ * THIS returns how many bytes are "unclaimed" in the endpoint fifo
+ * (needed for precise fault handling, when the hardware allows it)
+ */
+#define GADGETFS_FIFO_STATUS    _IO('g',1)
+
+/* discards any unclaimed data in the fifo. */
+#define GADGETFS_FIFO_FLUSH     _IO('g',2)
+
+/* resets endpoint halt+toggle; used to implement set_interface.
+ * some hardware (like pxa2xx) can't support this.
+ */
+#define GADGETFS_CLEAR_HALT     _IO('g',3)
+
+
diff --git a/include/linux/usb_otg.h b/include/linux/usb_otg.h
new file mode 100644
index 000000000000..c6683146e9b0
--- /dev/null
+++ b/include/linux/usb_otg.h
@@ -0,0 +1,118 @@
+// include/linux/usb_otg.h 
+
+/*
+ * These APIs may be used between USB controllers.  USB device drivers
+ * (for either host or peripheral roles) don't use these calls; they
+ * continue to use just usb_device and usb_gadget.
+ */
+
+
+/* OTG defines lots of enumeration states before device reset */
+enum usb_otg_state {
+        OTG_STATE_UNDEFINED = 0,
+
+        /* single-role peripheral, and dual-role default-b */
+        OTG_STATE_B_IDLE,
+        OTG_STATE_B_SRP_INIT,
+        OTG_STATE_B_PERIPHERAL,
+
+        /* extra dual-role default-b states */
+        OTG_STATE_B_WAIT_ACON,
+        OTG_STATE_B_HOST,
+
+        /* dual-role default-a */
+        OTG_STATE_A_IDLE,
+        OTG_STATE_A_WAIT_VRISE,
+        OTG_STATE_A_WAIT_BCON,
+        OTG_STATE_A_HOST,
+        OTG_STATE_A_SUSPEND,
+        OTG_STATE_A_PERIPHERAL,
+        OTG_STATE_A_WAIT_VFALL,
+        OTG_STATE_A_VBUS_ERR,
+};
+
+/*
+ * the otg driver needs to interact with both device side and host side
+ * usb controllers.  it decides which controller is active at a given
+ * moment, using the transceiver, ID signal, HNP and sometimes static
+ * configuration information (including "board isn't wired for otg").
+ */
+struct otg_transceiver {
+        struct device           *dev;
+        const char              *label;
+
+        u8                      default_a;
+        enum usb_otg_state      state;
+
+        struct usb_bus          *host;
+        struct usb_gadget       *gadget;
+
+        /* to pass extra port status to the root hub */
+        u16                     port_status;
+        u16                     port_change;
+
+        /* bind/unbind the host controller */
+        int     (*set_host)(struct otg_transceiver *otg,
+                                struct usb_bus *host);
+
+        /* bind/unbind the peripheral controller */
+        int     (*set_peripheral)(struct otg_transceiver *otg,
+                                struct usb_gadget *gadget);
+
+        /* effective for B devices, ignored for A-peripheral */
+        int     (*set_power)(struct otg_transceiver *otg,
+                                unsigned mA);
+
+        /* for B devices only:  start session with A-Host */
+        int     (*start_srp)(struct otg_transceiver *otg);
+
+        /* start or continue HNP role switch */
+        int     (*start_hnp)(struct otg_transceiver *otg);
+
+};
+
+
+/* for board-specific init logic */
+extern int otg_set_transceiver(struct otg_transceiver *);
+
+
+/* for usb host and peripheral controller drivers */
+extern struct otg_transceiver *otg_get_transceiver(void);
+
+static inline int
+otg_start_hnp(struct otg_transceiver *otg)
+{
+        return otg->start_hnp(otg);
+}
+
+
+/* for HCDs */
+static inline int
+otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
+{
+        return otg->set_host(otg, host);
+}
+
+
+/* for usb peripheral controller drivers */
+static inline int
+otg_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *periph)
+{
+        return otg->set_peripheral(otg, periph);
+}
+
+static inline int
+otg_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        return otg->set_power(otg, mA);
+}
+
+static inline int
+otg_start_srp(struct otg_transceiver *otg)
+{
+        return otg->start_srp(otg);
+}
+
+
+/* for OTG controller drivers (and maybe other stuff) */
+extern int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num);
diff --git a/include/linux/usb_sl811.h b/include/linux/usb_sl811.h
new file mode 100644
index 000000000000..4f2d012d7309
--- /dev/null
+++ b/include/linux/usb_sl811.h
@@ -0,0 +1,26 @@
+
+/*
+ * board initialization should put one of these into dev->platform_data
+ * and place the sl811hs onto platform_bus named "sl811-hcd".
+ */
+
+struct sl811_platform_data {
+        unsigned        can_wakeup:1;
+
+        /* given port_power, msec/2 after power on till power good */
+        u8              potpg;
+
+        /* mA/2 power supplied on this port (max = default = 250) */
+        u8              power;
+
+        /* sl811 relies on an external source of VBUS current */
+        void            (*port_power)(struct device *dev, int is_on);
+
+        /* pulse sl811 nRST (probably with a GPIO) */
+        void            (*reset)(struct device *dev);
+
+        // some boards need something like these:
+        // int          (*check_overcurrent)(struct device *dev);
+        // void         (*clock_enable)(struct device *dev, int is_on);
+};
+
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
new file mode 100644
index 000000000000..fb57c2217468
--- /dev/null
+++ b/include/linux/usbdevice_fs.h
@@ -0,0 +1,168 @@
+/*****************************************************************************/
+
+/*
+ *      usbdevice_fs.h  --  USB device file system.
+ *
+ *      Copyright (C) 2000
+ *          Thomas Sailer (sailer@ife.ee.ethz.ch)
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  History:
+ *   0.1  04.01.2000  Created
+ *
+ *  $Id: usbdevice_fs.h,v 1.1 2000/01/06 18:40:41 tom Exp $
+ */
+
+/*****************************************************************************/
+
+#ifndef _LINUX_USBDEVICE_FS_H
+#define _LINUX_USBDEVICE_FS_H
+
+#include <linux/types.h>
+#include <linux/compat.h>
+
+/* --------------------------------------------------------------------- */
+
+#define USBDEVICE_SUPER_MAGIC 0x9fa2
+
+/* usbdevfs ioctl codes */
+
+struct usbdevfs_ctrltransfer {
+        __u8 bRequestType;
+        __u8 bRequest;
+        __u16 wValue;
+        __u16 wIndex;
+        __u16 wLength;
+        __u32 timeout;  /* in milliseconds */
+        void __user *data;
+};
+
+struct usbdevfs_bulktransfer {
+        unsigned int ep;
+        unsigned int len;
+        unsigned int timeout; /* in milliseconds */
+        void __user *data;
+};
+
+struct usbdevfs_setinterface {
+        unsigned int interface;
+        unsigned int altsetting;
+};
+
+struct usbdevfs_disconnectsignal {
+        unsigned int signr;
+        void __user *context;
+};
+
+#define USBDEVFS_MAXDRIVERNAME 255
+
+struct usbdevfs_getdriver {
+        unsigned int interface;
+        char driver[USBDEVFS_MAXDRIVERNAME + 1];
+};
+
+struct usbdevfs_connectinfo {
+        unsigned int devnum;
+        unsigned char slow;
+};
+
+#define USBDEVFS_URB_SHORT_NOT_OK          1
+#define USBDEVFS_URB_ISO_ASAP              2
+
+#define USBDEVFS_URB_TYPE_ISO              0
+#define USBDEVFS_URB_TYPE_INTERRUPT        1
+#define USBDEVFS_URB_TYPE_CONTROL          2
+#define USBDEVFS_URB_TYPE_BULK             3
+
+struct usbdevfs_iso_packet_desc {
+        unsigned int length;
+        unsigned int actual_length;
+        unsigned int status;
+};
+
+struct usbdevfs_urb {
+        unsigned char type;
+        unsigned char endpoint;
+        int status;
+        unsigned int flags;
+        void __user *buffer;
+        int buffer_length;
+        int actual_length;
+        int start_frame;
+        int number_of_packets;
+        int error_count;
+        unsigned int signr;  /* signal to be sent on error, -1 if none should be sent */
+        void *usercontext;
+        struct usbdevfs_iso_packet_desc iso_frame_desc[0];
+};
+
+/* ioctls for talking directly to drivers */
+struct usbdevfs_ioctl {
+        int     ifno;           /* interface 0..N ; negative numbers reserved */
+        int     ioctl_code;     /* MUST encode size + direction of data so the
+                                 * macros in <asm/ioctl.h> give correct values */
+        void __user *data;      /* param buffer (in, or out) */
+};
+
+/* You can do most things with hubs just through control messages,
+ * except find out what device connects to what port. */
+struct usbdevfs_hub_portinfo {
+        char nports;            /* number of downstream ports in this hub */
+        char port [127];        /* e.g. port 3 connects to device 27 */
+};
+
+#ifdef CONFIG_COMPAT
+struct usbdevfs_urb32 {
+        unsigned char type;
+        unsigned char endpoint;
+        compat_int_t status;
+        compat_uint_t flags;
+        compat_caddr_t buffer;
+        compat_int_t buffer_length;
+        compat_int_t actual_length;
+        compat_int_t start_frame;
+        compat_int_t number_of_packets;
+        compat_int_t error_count;
+        compat_uint_t signr;
+        compat_caddr_t usercontext; /* unused */
+        struct usbdevfs_iso_packet_desc iso_frame_desc[0];
+};
+#endif
+
+#define USBDEVFS_CONTROL           _IOWR('U', 0, struct usbdevfs_ctrltransfer)
+#define USBDEVFS_BULK              _IOWR('U', 2, struct usbdevfs_bulktransfer)
+#define USBDEVFS_RESETEP           _IOR('U', 3, unsigned int)
+#define USBDEVFS_SETINTERFACE      _IOR('U', 4, struct usbdevfs_setinterface)
+#define USBDEVFS_SETCONFIGURATION  _IOR('U', 5, unsigned int)
+#define USBDEVFS_GETDRIVER         _IOW('U', 8, struct usbdevfs_getdriver)
+#define USBDEVFS_SUBMITURB         _IOR('U', 10, struct usbdevfs_urb)
+#define USBDEVFS_SUBMITURB32       _IOR('U', 10, struct usbdevfs_urb32)
+#define USBDEVFS_DISCARDURB        _IO('U', 11)
+#define USBDEVFS_REAPURB           _IOW('U', 12, void *)
+#define USBDEVFS_REAPURB32         _IOW('U', 12, u32)
+#define USBDEVFS_REAPURBNDELAY     _IOW('U', 13, void *)
+#define USBDEVFS_REAPURBNDELAY32   _IOW('U', 13, u32)
+#define USBDEVFS_DISCSIGNAL        _IOR('U', 14, struct usbdevfs_disconnectsignal)
+#define USBDEVFS_CLAIMINTERFACE    _IOR('U', 15, unsigned int)
+#define USBDEVFS_RELEASEINTERFACE  _IOR('U', 16, unsigned int)
+#define USBDEVFS_CONNECTINFO       _IOW('U', 17, struct usbdevfs_connectinfo)
+#define USBDEVFS_IOCTL             _IOWR('U', 18, struct usbdevfs_ioctl)
+#define USBDEVFS_HUB_PORTINFO      _IOR('U', 19, struct usbdevfs_hub_portinfo)
+#define USBDEVFS_RESET             _IO('U', 20)
+#define USBDEVFS_CLEAR_HALT        _IOR('U', 21, unsigned int)
+#define USBDEVFS_DISCONNECT        _IO('U', 22)
+#define USBDEVFS_CONNECT           _IO('U', 23)
+#endif /* _LINUX_USBDEVICE_FS_H */
diff --git a/include/linux/user.h b/include/linux/user.h
new file mode 100644
index 000000000000..68daf840f6c8
--- /dev/null
+++ b/include/linux/user.h
@@ -0,0 +1 @@
+#include <asm/user.h>
diff --git a/include/linux/utime.h b/include/linux/utime.h
new file mode 100644
index 000000000000..c6bf27b7897e
--- /dev/null
+++ b/include/linux/utime.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_UTIME_H
+#define _LINUX_UTIME_H
+
+struct utimbuf {
+        time_t actime;
+        time_t modtime;
+};
+
+#endif
diff --git a/include/linux/uts.h b/include/linux/uts.h
new file mode 100644
index 000000000000..73eb1ed36ec4
--- /dev/null
+++ b/include/linux/uts.h
@@ -0,0 +1,19 @@
+#ifndef _LINUX_UTS_H
+#define _LINUX_UTS_H
+
+/*
+ * Defines for what uname() should return 
+ */
+#ifndef UTS_SYSNAME
+#define UTS_SYSNAME "Linux"
+#endif
+
+#ifndef UTS_NODENAME
+#define UTS_NODENAME "(none)"   /* set by sethostname() */
+#endif
+
+#ifndef UTS_DOMAINNAME
+#define UTS_DOMAINNAME "(none)" /* set by setdomainname() */
+#endif
+
+#endif
diff --git a/include/linux/utsname.h b/include/linux/utsname.h
new file mode 100644
index 000000000000..13e1da0c538d
--- /dev/null
+++ b/include/linux/utsname.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_UTSNAME_H
+#define _LINUX_UTSNAME_H
+
+#define __OLD_UTS_LEN 8
+
+struct oldold_utsname {
+        char sysname[9];
+        char nodename[9];
+        char release[9];
+        char version[9];
+        char machine[9];
+};
+
+#define __NEW_UTS_LEN 64
+
+struct old_utsname {
+        char sysname[65];
+        char nodename[65];
+        char release[65];
+        char version[65];
+        char machine[65];
+};
+
+struct new_utsname {
+        char sysname[65];
+        char nodename[65];
+        char release[65];
+        char version[65];
+        char machine[65];
+        char domainname[65];
+};
+
+extern struct new_utsname system_utsname;
+
+extern struct rw_semaphore uts_sem;
+#endif
diff --git a/include/linux/vermagic.h b/include/linux/vermagic.h
new file mode 100644
index 000000000000..fadc535e2925
--- /dev/null
+++ b/include/linux/vermagic.h
@@ -0,0 +1,23 @@
+#include <linux/version.h>
+#include <linux/module.h>
+
+/* Simply sanity version stamp for modules. */
+#ifdef CONFIG_SMP
+#define MODULE_VERMAGIC_SMP "SMP "
+#else
+#define MODULE_VERMAGIC_SMP ""
+#endif
+#ifdef CONFIG_PREEMPT
+#define MODULE_VERMAGIC_PREEMPT "preempt "
+#else
+#define MODULE_VERMAGIC_PREEMPT ""
+#endif
+#ifndef MODULE_ARCH_VERMAGIC
+#define MODULE_ARCH_VERMAGIC ""
+#endif
+
+#define VERMAGIC_STRING                                                 \
+        UTS_RELEASE " "                                                 \
+        MODULE_VERMAGIC_SMP MODULE_VERMAGIC_PREEMPT                     \
+        MODULE_ARCH_VERMAGIC                                            \
+        "gcc-" __stringify(__GNUC__) "." __stringify(__GNUC_MINOR__)
diff --git a/include/linux/vfs.h b/include/linux/vfs.h
new file mode 100644
index 000000000000..e701d0541405
--- /dev/null
+++ b/include/linux/vfs.h
@@ -0,0 +1,6 @@
+#ifndef _LINUX_VFS_H
+#define _LINUX_VFS_H
+
+#include <linux/statfs.h>
+
+#endif
diff --git a/include/linux/via.h b/include/linux/via.h
new file mode 100644
index 000000000000..86ae3bcdb2ba
--- /dev/null
+++ b/include/linux/via.h
@@ -0,0 +1,22 @@
+/* Miscellaneous definitions for VIA chipsets
+   Currently used only by drivers/parport/parport_pc.c */
+
+/* Values for SuperIO function select configuration register */
+#define VIA_FUNCTION_PARPORT_SPP     0x00
+#define VIA_FUNCTION_PARPORT_ECP     0x01
+#define VIA_FUNCTION_PARPORT_EPP     0x02
+#define VIA_FUNCTION_PARPORT_DISABLE 0x03
+#define VIA_FUNCTION_PROBE           0xFF /* Special magic value to be used in code, not to be written into chip */
+
+/* Bits for parallel port mode configuration register */
+#define VIA_PARPORT_ECPEPP 0X20
+#define VIA_PARPORT_BIDIR  0x80
+
+/* VIA configuration registers */
+#define VIA_CONFIG_INDEX 0x3F0
+#define VIA_CONFIG_DATA  0x3F1
+
+/* Mask for parallel port IRQ bits (in ISA PnP IRQ routing register 1) */
+#define VIA_IRQCONTROL_PARALLEL 0xF0
+/* Mask for parallel port DMA bits (in ISA PnP DMA routing register) */
+#define VIA_DMACONTROL_PARALLEL 0x0C
diff --git a/include/linux/video_decoder.h b/include/linux/video_decoder.h
new file mode 100644
index 000000000000..0e9e48b83e3b
--- /dev/null
+++ b/include/linux/video_decoder.h
@@ -0,0 +1,44 @@
+#ifndef _LINUX_VIDEO_DECODER_H
+#define _LINUX_VIDEO_DECODER_H
+
+struct video_decoder_capability { /* this name is too long */
+        __u32   flags;
+#define VIDEO_DECODER_PAL       1       /* can decode PAL signal */
+#define VIDEO_DECODER_NTSC      2       /* can decode NTSC */
+#define VIDEO_DECODER_SECAM     4       /* can decode SECAM */
+#define VIDEO_DECODER_AUTO      8       /* can autosense norm */
+#define VIDEO_DECODER_CCIR      16      /* CCIR-601 pixel rate (720 pixels per line) instead of square pixel rate */
+        int     inputs;                 /* number of inputs */
+        int     outputs;                /* number of outputs */
+};
+
+/*
+DECODER_GET_STATUS returns the following flags.  The only one you need is
+DECODER_STATUS_GOOD, the others are just nice things to know.
+*/
+#define DECODER_STATUS_GOOD     1       /* receiving acceptable input */
+#define DECODER_STATUS_COLOR    2       /* receiving color information */
+#define DECODER_STATUS_PAL      4       /* auto detected */
+#define DECODER_STATUS_NTSC     8       /* auto detected */
+#define DECODER_STATUS_SECAM    16      /* auto detected */
+
+struct video_decoder_init {
+        unsigned char len;
+        const unsigned char *data;
+};
+
+#define DECODER_GET_CAPABILITIES _IOR('d', 1, struct video_decoder_capability)
+#define DECODER_GET_STATUS      _IOR('d', 2, int)
+#define DECODER_SET_NORM        _IOW('d', 3, int)
+#define DECODER_SET_INPUT       _IOW('d', 4, int)       /* 0 <= input < #inputs */
+#define DECODER_SET_OUTPUT      _IOW('d', 5, int)       /* 0 <= output < #outputs */
+#define DECODER_ENABLE_OUTPUT   _IOW('d', 6, int)       /* boolean output enable control */
+#define DECODER_SET_PICTURE     _IOW('d', 7, struct video_picture)
+#define DECODER_SET_GPIO        _IOW('d', 8, int)       /* switch general purpose pin */
+#define DECODER_INIT            _IOW('d', 9, struct video_decoder_init) /* init internal registers at once */
+#define DECODER_SET_VBI_BYPASS  _IOW('d', 10, int)      /* switch vbi bypass */
+
+#define DECODER_DUMP            _IO('d', 192)           /* debug hook */
+
+
+#endif
diff --git a/include/linux/video_encoder.h b/include/linux/video_encoder.h
new file mode 100644
index 000000000000..4b0e6907a7b4
--- /dev/null
+++ b/include/linux/video_encoder.h
@@ -0,0 +1,21 @@
+#ifndef _LINUX_VIDEO_ENCODER_H
+#define _LINUX_VIDEO_ENCODER_H
+
+struct video_encoder_capability { /* this name is too long */
+        __u32   flags;
+#define VIDEO_ENCODER_PAL       1       /* can encode PAL signal */
+#define VIDEO_ENCODER_NTSC      2       /* can encode NTSC */
+#define VIDEO_ENCODER_SECAM     4       /* can encode SECAM */
+#define VIDEO_ENCODER_CCIR      16      /* CCIR-601 pixel rate (720 pixels per line) instead of square pixel rate */
+        int     inputs;                 /* number of inputs */
+        int     outputs;                /* number of outputs */
+};
+
+#define ENCODER_GET_CAPABILITIES _IOR('e', 1, struct video_encoder_capability)
+#define ENCODER_SET_NORM        _IOW('e', 2, int)
+#define ENCODER_SET_INPUT       _IOW('e', 3, int)       /* 0 <= input < #inputs */
+#define ENCODER_SET_OUTPUT      _IOW('e', 4, int)       /* 0 <= output < #outputs */
+#define ENCODER_ENABLE_OUTPUT   _IOW('e', 5, int)       /* boolean output enable control */
+
+
+#endif
diff --git a/include/linux/videodev.h b/include/linux/videodev.h
new file mode 100644
index 000000000000..9d6fbde3d29c
--- /dev/null
+++ b/include/linux/videodev.h
@@ -0,0 +1,443 @@
+#ifndef __LINUX_VIDEODEV_H
+#define __LINUX_VIDEODEV_H
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+#include <linux/version.h>
+
+#define HAVE_V4L2 1
+#include <linux/videodev2.h>
+
+#ifdef __KERNEL__
+
+#include <linux/poll.h>
+#include <linux/mm.h>
+#include <linux/device.h>
+
+struct video_device
+{
+        /* device info */
+        struct device *dev;
+        char name[32];
+        int type;       /* v4l1 */
+        int type2;      /* v4l2 */
+        int hardware;
+        int minor;
+
+        /* device ops + callbacks */
+        struct file_operations *fops;
+        void (*release)(struct video_device *vfd);
+
+
+#if 1 /* to be removed in 2.7.x */
+        /* obsolete -- fops->owner is used instead */
+        struct module *owner;
+        /* dev->driver_data will be used instead some day.
+         * Use the video_{get|set}_drvdata() helper functions,
+         * so the switch over will be transparent for you.
+         * Or use {pci|usb}_{get|set}_drvdata() directly. */
+        void *priv;
+#endif
+
+        /* for videodev.c intenal usage -- please don't touch */
+        int users;                     /* video_exclusive_{open|close} ... */
+        struct semaphore lock;         /* ... helper function uses these   */
+        char devfs_name[64];           /* devfs */
+        struct class_device class_dev; /* sysfs */
+};
+
+#define VIDEO_MAJOR     81
+
+#define VFL_TYPE_GRABBER        0
+#define VFL_TYPE_VBI            1
+#define VFL_TYPE_RADIO          2
+#define VFL_TYPE_VTX            3
+
+extern int video_register_device(struct video_device *, int type, int nr);
+extern void video_unregister_device(struct video_device *);
+extern struct video_device* video_devdata(struct file*);
+
+#define to_video_device(cd) container_of(cd, struct video_device, class_dev)
+static inline void
+video_device_create_file(struct video_device *vfd,
+                         struct class_device_attribute *attr)
+{
+        class_device_create_file(&vfd->class_dev, attr);
+}
+static inline void
+video_device_remove_file(struct video_device *vfd,
+                         struct class_device_attribute *attr)
+{
+        class_device_remove_file(&vfd->class_dev, attr);
+}
+
+/* helper functions to alloc / release struct video_device, the
+   later can be used for video_device->release() */
+struct video_device *video_device_alloc(void);
+void video_device_release(struct video_device *vfd);
+
+/* helper functions to access driver private data. */
+static inline void *video_get_drvdata(struct video_device *dev)
+{
+        return dev->priv;
+}
+
+static inline void video_set_drvdata(struct video_device *dev, void *data)
+{
+        dev->priv = data;
+}
+
+extern int video_exclusive_open(struct inode *inode, struct file *file);
+extern int video_exclusive_release(struct inode *inode, struct file *file);
+extern int video_usercopy(struct inode *inode, struct file *file,
+                          unsigned int cmd, unsigned long arg,
+                          int (*func)(struct inode *inode, struct file *file,
+                                      unsigned int cmd, void *arg));
+#endif /* __KERNEL__ */
+
+#define VID_TYPE_CAPTURE        1       /* Can capture */
+#define VID_TYPE_TUNER          2       /* Can tune */
+#define VID_TYPE_TELETEXT       4       /* Does teletext */
+#define VID_TYPE_OVERLAY        8       /* Overlay onto frame buffer */
+#define VID_TYPE_CHROMAKEY      16      /* Overlay by chromakey */
+#define VID_TYPE_CLIPPING       32      /* Can clip */
+#define VID_TYPE_FRAMERAM       64      /* Uses the frame buffer memory */
+#define VID_TYPE_SCALES         128     /* Scalable */
+#define VID_TYPE_MONOCHROME     256     /* Monochrome only */
+#define VID_TYPE_SUBCAPTURE     512     /* Can capture subareas of the image */
+#define VID_TYPE_MPEG_DECODER   1024    /* Can decode MPEG streams */
+#define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
+#define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
+#define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */
+
+struct video_capability
+{
+        char name[32];
+        int type;
+        int channels;   /* Num channels */
+        int audios;     /* Num audio devices */
+        int maxwidth;   /* Supported width */
+        int maxheight;  /* And height */
+        int minwidth;   /* Supported width */
+        int minheight;  /* And height */
+};
+
+
+struct video_channel
+{
+        int channel;
+        char name[32];
+        int tuners;
+        __u32  flags;
+#define VIDEO_VC_TUNER          1       /* Channel has a tuner */
+#define VIDEO_VC_AUDIO          2       /* Channel has audio */
+        __u16  type;
+#define VIDEO_TYPE_TV           1
+#define VIDEO_TYPE_CAMERA       2
+        __u16 norm;                     /* Norm set by channel */
+};
+
+struct video_tuner
+{
+        int tuner;
+        char name[32];
+        unsigned long rangelow, rangehigh;      /* Tuner range */
+        __u32 flags;
+#define VIDEO_TUNER_PAL         1
+#define VIDEO_TUNER_NTSC        2
+#define VIDEO_TUNER_SECAM       4
+#define VIDEO_TUNER_LOW         8       /* Uses KHz not MHz */
+#define VIDEO_TUNER_NORM        16      /* Tuner can set norm */
+#define VIDEO_TUNER_STEREO_ON   128     /* Tuner is seeing stereo */
+#define VIDEO_TUNER_RDS_ON      256     /* Tuner is seeing an RDS datastream */
+#define VIDEO_TUNER_MBS_ON      512     /* Tuner is seeing an MBS datastream */
+        __u16 mode;                     /* PAL/NTSC/SECAM/OTHER */
+#define VIDEO_MODE_PAL          0
+#define VIDEO_MODE_NTSC         1
+#define VIDEO_MODE_SECAM        2
+#define VIDEO_MODE_AUTO         3
+        __u16 signal;                   /* Signal strength 16bit scale */
+};
+
+struct video_picture
+{
+        __u16   brightness;
+        __u16   hue;
+        __u16   colour;
+        __u16   contrast;
+        __u16   whiteness;      /* Black and white only */
+        __u16   depth;          /* Capture depth */
+        __u16   palette;        /* Palette in use */
+#define VIDEO_PALETTE_GREY      1       /* Linear greyscale */
+#define VIDEO_PALETTE_HI240     2       /* High 240 cube (BT848) */
+#define VIDEO_PALETTE_RGB565    3       /* 565 16 bit RGB */
+#define VIDEO_PALETTE_RGB24     4       /* 24bit RGB */
+#define VIDEO_PALETTE_RGB32     5       /* 32bit RGB */
+#define VIDEO_PALETTE_RGB555    6       /* 555 15bit RGB */
+#define VIDEO_PALETTE_YUV422    7       /* YUV422 capture */
+#define VIDEO_PALETTE_YUYV      8
+#define VIDEO_PALETTE_UYVY      9       /* The great thing about standards is ... */
+#define VIDEO_PALETTE_YUV420    10
+#define VIDEO_PALETTE_YUV411    11      /* YUV411 capture */
+#define VIDEO_PALETTE_RAW       12      /* RAW capture (BT848) */
+#define VIDEO_PALETTE_YUV422P   13      /* YUV 4:2:2 Planar */
+#define VIDEO_PALETTE_YUV411P   14      /* YUV 4:1:1 Planar */
+#define VIDEO_PALETTE_YUV420P   15      /* YUV 4:2:0 Planar */
+#define VIDEO_PALETTE_YUV410P   16      /* YUV 4:1:0 Planar */
+#define VIDEO_PALETTE_PLANAR    13      /* start of planar entries */
+#define VIDEO_PALETTE_COMPONENT 7       /* start of component entries */
+};
+
+struct video_audio
+{
+        int     audio;          /* Audio channel */
+        __u16   volume;         /* If settable */
+        __u16   bass, treble;
+        __u32   flags;
+#define VIDEO_AUDIO_MUTE        1
+#define VIDEO_AUDIO_MUTABLE     2
+#define VIDEO_AUDIO_VOLUME      4
+#define VIDEO_AUDIO_BASS        8
+#define VIDEO_AUDIO_TREBLE      16
+#define VIDEO_AUDIO_BALANCE     32
+        char    name[16];
+#define VIDEO_SOUND_MONO        1
+#define VIDEO_SOUND_STEREO      2
+#define VIDEO_SOUND_LANG1       4
+#define VIDEO_SOUND_LANG2       8
+        __u16   mode;
+        __u16   balance;        /* Stereo balance */
+        __u16   step;           /* Step actual volume uses */
+};
+
+struct video_clip
+{
+        __s32   x,y;
+        __s32   width, height;
+        struct  video_clip *next;       /* For user use/driver use only */
+};
+
+struct video_window
+{
+        __u32   x,y;                    /* Position of window */
+        __u32   width,height;           /* Its size */
+        __u32   chromakey;
+        __u32   flags;
+        struct  video_clip __user *clips;       /* Set only */
+        int     clipcount;
+#define VIDEO_WINDOW_INTERLACE  1
+#define VIDEO_WINDOW_CHROMAKEY  16      /* Overlay by chromakey */
+#define VIDEO_CLIP_BITMAP       -1
+/* bitmap is 1024x625, a '1' bit represents a clipped pixel */
+#define VIDEO_CLIPMAP_SIZE      (128 * 625)
+};
+
+struct video_capture
+{
+        __u32   x,y;                    /* Offsets into image */
+        __u32   width, height;          /* Area to capture */
+        __u16   decimation;             /* Decimation divider */
+        __u16   flags;                  /* Flags for capture */
+#define VIDEO_CAPTURE_ODD               0       /* Temporal */
+#define VIDEO_CAPTURE_EVEN              1
+};
+
+struct video_buffer
+{
+        void    *base;
+        int     height,width;
+        int     depth;
+        int     bytesperline;
+};
+
+struct video_mmap
+{
+        unsigned        int frame;              /* Frame (0 - n) for double buffer */
+        int             height,width;
+        unsigned        int format;             /* should be VIDEO_PALETTE_* */
+};
+
+struct video_key
+{
+        __u8    key[8];
+        __u32   flags;
+};
+
+
+#define VIDEO_MAX_FRAME         32
+
+struct video_mbuf
+{
+        int     size;           /* Total memory to map */
+        int     frames;         /* Frames */
+        int     offsets[VIDEO_MAX_FRAME];
+};
+
+
+#define         VIDEO_NO_UNIT   (-1)
+
+
+struct video_unit
+{
+        int     video;          /* Video minor */
+        int     vbi;            /* VBI minor */
+        int     radio;          /* Radio minor */
+        int     audio;          /* Audio minor */
+        int     teletext;       /* Teletext minor */
+};
+
+struct vbi_format {
+        __u32   sampling_rate;  /* in Hz */
+        __u32   samples_per_line;
+        __u32   sample_format;  /* VIDEO_PALETTE_RAW only (1 byte) */
+        __s32   start[2];       /* starting line for each frame */
+        __u32   count[2];       /* count of lines for each frame */
+        __u32   flags;
+#define VBI_UNSYNC      1       /* can distingues between top/bottom field */
+#define VBI_INTERLACED  2       /* lines are interlaced */
+};
+
+/* video_info is biased towards hardware mpeg encode/decode */
+/* but it could apply generically to any hardware compressor/decompressor */
+struct video_info
+{
+        __u32   frame_count;    /* frames output since decode/encode began */
+        __u32   h_size;         /* current unscaled horizontal size */
+        __u32   v_size;         /* current unscaled veritcal size */
+        __u32   smpte_timecode; /* current SMPTE timecode (for current GOP) */
+        __u32   picture_type;   /* current picture type */
+        __u32   temporal_reference;     /* current temporal reference */
+        __u8    user_data[256]; /* user data last found in compressed stream */
+        /* user_data[0] contains user data flags, user_data[1] has count */
+};
+
+/* generic structure for setting playback modes */
+struct video_play_mode
+{
+        int     mode;
+        int     p1;
+        int     p2;
+};
+
+/* for loading microcode / fpga programming */
+struct video_code
+{
+        char    loadwhat[16];   /* name or tag of file being passed */
+        int     datasize;
+        __u8    *data;
+};
+
+#define VIDIOCGCAP              _IOR('v',1,struct video_capability)     /* Get capabilities */
+#define VIDIOCGCHAN             _IOWR('v',2,struct video_channel)       /* Get channel info (sources) */
+#define VIDIOCSCHAN             _IOW('v',3,struct video_channel)        /* Set channel  */
+#define VIDIOCGTUNER            _IOWR('v',4,struct video_tuner)         /* Get tuner abilities */
+#define VIDIOCSTUNER            _IOW('v',5,struct video_tuner)          /* Tune the tuner for the current channel */
+#define VIDIOCGPICT             _IOR('v',6,struct video_picture)        /* Get picture properties */
+#define VIDIOCSPICT             _IOW('v',7,struct video_picture)        /* Set picture properties */
+#define VIDIOCCAPTURE           _IOW('v',8,int)                         /* Start, end capture */
+#define VIDIOCGWIN              _IOR('v',9, struct video_window)        /* Get the video overlay window */
+#define VIDIOCSWIN              _IOW('v',10, struct video_window)       /* Set the video overlay window - passes clip list for hardware smarts , chromakey etc */
+#define VIDIOCGFBUF             _IOR('v',11, struct video_buffer)       /* Get frame buffer */
+#define VIDIOCSFBUF             _IOW('v',12, struct video_buffer)       /* Set frame buffer - root only */
+#define VIDIOCKEY               _IOR('v',13, struct video_key)          /* Video key event - to dev 255 is to all - cuts capture on all DMA windows with this key (0xFFFFFFFF == all) */
+#define VIDIOCGFREQ             _IOR('v',14, unsigned long)             /* Set tuner */
+#define VIDIOCSFREQ             _IOW('v',15, unsigned long)             /* Set tuner */
+#define VIDIOCGAUDIO            _IOR('v',16, struct video_audio)        /* Get audio info */
+#define VIDIOCSAUDIO            _IOW('v',17, struct video_audio)        /* Audio source, mute etc */
+#define VIDIOCSYNC              _IOW('v',18, int)                       /* Sync with mmap grabbing */
+#define VIDIOCMCAPTURE          _IOW('v',19, struct video_mmap)         /* Grab frames */
+#define VIDIOCGMBUF             _IOR('v',20, struct video_mbuf)         /* Memory map buffer info */
+#define VIDIOCGUNIT             _IOR('v',21, struct video_unit)         /* Get attached units */
+#define VIDIOCGCAPTURE          _IOR('v',22, struct video_capture)      /* Get subcapture */
+#define VIDIOCSCAPTURE          _IOW('v',23, struct video_capture)      /* Set subcapture */
+#define VIDIOCSPLAYMODE         _IOW('v',24, struct video_play_mode)    /* Set output video mode/feature */
+#define VIDIOCSWRITEMODE        _IOW('v',25, int)                       /* Set write mode */
+#define VIDIOCGPLAYINFO         _IOR('v',26, struct video_info)         /* Get current playback info from hardware */
+#define VIDIOCSMICROCODE        _IOW('v',27, struct video_code)         /* Load microcode into hardware */
+#define VIDIOCGVBIFMT           _IOR('v',28, struct vbi_format)         /* Get VBI information */
+#define VIDIOCSVBIFMT           _IOW('v',29, struct vbi_format)         /* Set VBI information */
+
+
+#define BASE_VIDIOCPRIVATE      192             /* 192-255 are private */
+
+/* VIDIOCSWRITEMODE */
+#define VID_WRITE_MPEG_AUD              0
+#define VID_WRITE_MPEG_VID              1
+#define VID_WRITE_OSD                   2
+#define VID_WRITE_TTX                   3
+#define VID_WRITE_CC                    4
+#define VID_WRITE_MJPEG                 5
+
+/* VIDIOCSPLAYMODE */
+#define VID_PLAY_VID_OUT_MODE           0
+        /* p1: = VIDEO_MODE_PAL, VIDEO_MODE_NTSC, etc ... */
+#define VID_PLAY_GENLOCK                1
+        /* p1: 0 = OFF, 1 = ON */
+        /* p2: GENLOCK FINE DELAY value */
+#define VID_PLAY_NORMAL                 2
+#define VID_PLAY_PAUSE                  3
+#define VID_PLAY_SINGLE_FRAME           4
+#define VID_PLAY_FAST_FORWARD           5
+#define VID_PLAY_SLOW_MOTION            6
+#define VID_PLAY_IMMEDIATE_NORMAL       7
+#define VID_PLAY_SWITCH_CHANNELS        8
+#define VID_PLAY_FREEZE_FRAME           9
+#define VID_PLAY_STILL_MODE             10
+#define VID_PLAY_MASTER_MODE            11
+        /* p1: see below */
+#define         VID_PLAY_MASTER_NONE    1
+#define         VID_PLAY_MASTER_VIDEO   2
+#define         VID_PLAY_MASTER_AUDIO   3
+#define VID_PLAY_ACTIVE_SCANLINES       12
+        /* p1 = first active; p2 = last active */
+#define VID_PLAY_RESET                  13
+#define VID_PLAY_END_MARK               14
+
+
+
+#define VID_HARDWARE_BT848      1
+#define VID_HARDWARE_QCAM_BW    2
+#define VID_HARDWARE_PMS        3
+#define VID_HARDWARE_QCAM_C     4
+#define VID_HARDWARE_PSEUDO     5
+#define VID_HARDWARE_SAA5249    6
+#define VID_HARDWARE_AZTECH     7
+#define VID_HARDWARE_SF16MI     8
+#define VID_HARDWARE_RTRACK     9
+#define VID_HARDWARE_ZOLTRIX    10
+#define VID_HARDWARE_SAA7146    11
+#define VID_HARDWARE_VIDEUM     12      /* Reserved for Winnov videum */
+#define VID_HARDWARE_RTRACK2    13
+#define VID_HARDWARE_PERMEDIA2  14      /* Reserved for Permedia2 */
+#define VID_HARDWARE_RIVA128    15      /* Reserved for RIVA 128 */
+#define VID_HARDWARE_PLANB      16      /* PowerMac motherboard video-in */
+#define VID_HARDWARE_BROADWAY   17      /* Broadway project */
+#define VID_HARDWARE_GEMTEK     18
+#define VID_HARDWARE_TYPHOON    19
+#define VID_HARDWARE_VINO       20      /* SGI Indy Vino */
+#define VID_HARDWARE_CADET      21      /* Cadet radio */
+#define VID_HARDWARE_TRUST      22      /* Trust FM Radio */
+#define VID_HARDWARE_TERRATEC   23      /* TerraTec ActiveRadio */
+#define VID_HARDWARE_CPIA       24
+#define VID_HARDWARE_ZR36120    25      /* Zoran ZR36120/ZR36125 */
+#define VID_HARDWARE_ZR36067    26      /* Zoran ZR36067/36060 */
+#define VID_HARDWARE_OV511      27
+#define VID_HARDWARE_ZR356700   28      /* Zoran 36700 series */
+#define VID_HARDWARE_W9966      29
+#define VID_HARDWARE_SE401      30      /* SE401 USB webcams */
+#define VID_HARDWARE_PWC        31      /* Philips webcams */
+#define VID_HARDWARE_MEYE       32      /* Sony Vaio MotionEye cameras */
+#define VID_HARDWARE_CPIA2      33
+#define VID_HARDWARE_VICAM      34
+#define VID_HARDWARE_SF16FMR2   35
+#define VID_HARDWARE_W9968CF    36
+#define VID_HARDWARE_SAA7114H   37
+#define VID_HARDWARE_SN9C102    38
+#define VID_HARDWARE_ARV        39
+#endif /* __LINUX_VIDEODEV_H */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
new file mode 100644
index 000000000000..4e0edce53760
--- /dev/null
+++ b/include/linux/videodev2.h
@@ -0,0 +1,977 @@
+#ifndef __LINUX_VIDEODEV2_H
+#define __LINUX_VIDEODEV2_H
+/*
+ *      Video for Linux Two
+ *
+ *      Header file for v4l or V4L2 drivers and applications, for
+ *      Linux kernels 2.2.x or 2.4.x.
+ *
+ *      See http://bytesex.org/v4l/ for API specs and other
+ *      v4l2 documentation.
+ *
+ *      Author: Bill Dirks <bdirks@pacbell.net>
+ *              Justin Schoeman
+ *              et al.
+ */
+#ifdef __KERNEL__
+#include <linux/time.h> /* need struct timeval */
+#endif
+#include <linux/compiler.h> /* need __user */
+
+/*
+ *      M I S C E L L A N E O U S
+ */
+
+/*  Four-character-code (FOURCC) */
+#define v4l2_fourcc(a,b,c,d)\
+        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
+
+/*
+ *      E N U M S
+ */
+enum v4l2_field {
+        V4L2_FIELD_ANY        = 0, /* driver can choose from none,
+                                      top, bottom, interlaced
+                                      depending on whatever it thinks
+                                      is approximate ... */
+        V4L2_FIELD_NONE       = 1, /* this device has no fields ... */
+        V4L2_FIELD_TOP        = 2, /* top field only */
+        V4L2_FIELD_BOTTOM     = 3, /* bottom field only */
+        V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */
+        V4L2_FIELD_SEQ_TB     = 5, /* both fields sequential into one
+                                      buffer, top-bottom order */
+        V4L2_FIELD_SEQ_BT     = 6, /* same as above + bottom-top order */
+        V4L2_FIELD_ALTERNATE  = 7, /* both fields alternating into
+                                      separate buffers */
+};
+#define V4L2_FIELD_HAS_TOP(field)       \
+        ((field) == V4L2_FIELD_TOP      ||\
+         (field) == V4L2_FIELD_INTERLACED ||\
+         (field) == V4L2_FIELD_SEQ_TB   ||\
+         (field) == V4L2_FIELD_SEQ_BT)
+#define V4L2_FIELD_HAS_BOTTOM(field)    \
+        ((field) == V4L2_FIELD_BOTTOM   ||\
+         (field) == V4L2_FIELD_INTERLACED ||\
+         (field) == V4L2_FIELD_SEQ_TB   ||\
+         (field) == V4L2_FIELD_SEQ_BT)
+#define V4L2_FIELD_HAS_BOTH(field)      \
+        ((field) == V4L2_FIELD_INTERLACED ||\
+         (field) == V4L2_FIELD_SEQ_TB   ||\
+         (field) == V4L2_FIELD_SEQ_BT)
+
+enum v4l2_buf_type {
+        V4L2_BUF_TYPE_VIDEO_CAPTURE  = 1,
+        V4L2_BUF_TYPE_VIDEO_OUTPUT   = 2,
+        V4L2_BUF_TYPE_VIDEO_OVERLAY  = 3,
+        V4L2_BUF_TYPE_VBI_CAPTURE    = 4,
+        V4L2_BUF_TYPE_VBI_OUTPUT     = 5,
+        V4L2_BUF_TYPE_PRIVATE        = 0x80,
+};
+
+enum v4l2_ctrl_type {
+        V4L2_CTRL_TYPE_INTEGER       = 1,
+        V4L2_CTRL_TYPE_BOOLEAN       = 2,
+        V4L2_CTRL_TYPE_MENU          = 3,
+        V4L2_CTRL_TYPE_BUTTON        = 4,
+};
+
+enum v4l2_tuner_type {
+        V4L2_TUNER_RADIO             = 1,
+        V4L2_TUNER_ANALOG_TV         = 2,
+        V4L2_TUNER_DIGITAL_TV        = 3,
+};
+
+enum v4l2_memory {
+        V4L2_MEMORY_MMAP             = 1,
+        V4L2_MEMORY_USERPTR          = 2,
+        V4L2_MEMORY_OVERLAY          = 3,
+};
+
+/* see also http://vektor.theorem.ca/graphics/ycbcr/ */
+enum v4l2_colorspace {
+        /* ITU-R 601 -- broadcast NTSC/PAL */
+        V4L2_COLORSPACE_SMPTE170M     = 1,
+
+        /* 1125-Line (US) HDTV */
+        V4L2_COLORSPACE_SMPTE240M     = 2,
+
+        /* HD and modern captures. */
+        V4L2_COLORSPACE_REC709        = 3,
+
+        /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */
+        V4L2_COLORSPACE_BT878         = 4,
+
+        /* These should be useful.  Assume 601 extents. */
+        V4L2_COLORSPACE_470_SYSTEM_M  = 5,
+        V4L2_COLORSPACE_470_SYSTEM_BG = 6,
+
+        /* I know there will be cameras that send this.  So, this is
+         * unspecified chromaticities and full 0-255 on each of the
+         * Y'CbCr components
+         */
+        V4L2_COLORSPACE_JPEG          = 7,
+
+        /* For RGB colourspaces, this is probably a good start. */
+        V4L2_COLORSPACE_SRGB          = 8,
+};
+
+enum v4l2_priority {
+        V4L2_PRIORITY_UNSET       = 0,  /* not initialized */
+        V4L2_PRIORITY_BACKGROUND  = 1,
+        V4L2_PRIORITY_INTERACTIVE = 2,
+        V4L2_PRIORITY_RECORD      = 3,
+        V4L2_PRIORITY_DEFAULT     = V4L2_PRIORITY_INTERACTIVE,
+};
+
+struct v4l2_rect {
+        __s32   left;
+        __s32   top;
+        __s32   width;
+        __s32   height;
+};
+
+struct v4l2_fract {
+        __u32   numerator;
+        __u32   denominator;
+};
+
+/*
+ *      D R I V E R   C A P A B I L I T I E S
+ */
+struct v4l2_capability
+{
+        __u8    driver[16];     /* i.e. "bttv" */
+        __u8    card[32];       /* i.e. "Hauppauge WinTV" */
+        __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */
+        __u32   version;        /* should use KERNEL_VERSION() */
+        __u32   capabilities;   /* Device capabilities */
+        __u32   reserved[4];
+};
+
+/* Values for 'capabilities' field */
+#define V4L2_CAP_VIDEO_CAPTURE  0x00000001  /* Is a video capture device */
+#define V4L2_CAP_VIDEO_OUTPUT   0x00000002  /* Is a video output device */
+#define V4L2_CAP_VIDEO_OVERLAY  0x00000004  /* Can do video overlay */
+#define V4L2_CAP_VBI_CAPTURE    0x00000010  /* Is a VBI capture device */
+#define V4L2_CAP_VBI_OUTPUT     0x00000020  /* Is a VBI output device */
+#define V4L2_CAP_RDS_CAPTURE    0x00000100  /* RDS data capture */
+
+#define V4L2_CAP_TUNER          0x00010000  /* has a tuner */
+#define V4L2_CAP_AUDIO          0x00020000  /* has audio support */
+#define V4L2_CAP_RADIO          0x00040000  /* is a radio device */
+
+#define V4L2_CAP_READWRITE      0x01000000  /* read/write systemcalls */
+#define V4L2_CAP_ASYNCIO        0x02000000  /* async I/O */
+#define V4L2_CAP_STREAMING      0x04000000  /* streaming I/O ioctls */
+
+/*
+ *      V I D E O   I M A G E   F O R M A T
+ */
+
+struct v4l2_pix_format
+{
+        __u32                   width;
+        __u32                   height;
+        __u32                   pixelformat;
+        enum v4l2_field         field;
+        __u32                   bytesperline;   /* for padding, zero if unused */
+        __u32                   sizeimage;
+        enum v4l2_colorspace    colorspace;
+        __u32                   priv;           /* private data, depends on pixelformat */
+};
+
+/*           Pixel format    FOURCC                  depth  Description   */
+#define V4L2_PIX_FMT_RGB332  v4l2_fourcc('R','G','B','1') /*  8  RGB-3-3-2     */
+#define V4L2_PIX_FMT_RGB555  v4l2_fourcc('R','G','B','O') /* 16  RGB-5-5-5     */
+#define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R','G','B','P') /* 16  RGB-5-6-5     */
+#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16  RGB-5-5-5 BE  */
+#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16  RGB-5-6-5 BE  */
+#define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B','G','R','3') /* 24  BGR-8-8-8     */
+#define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R','G','B','3') /* 24  RGB-8-8-8     */
+#define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B','G','R','4') /* 32  BGR-8-8-8-8   */
+#define V4L2_PIX_FMT_RGB32   v4l2_fourcc('R','G','B','4') /* 32  RGB-8-8-8-8   */
+#define V4L2_PIX_FMT_GREY    v4l2_fourcc('G','R','E','Y') /*  8  Greyscale     */
+#define V4L2_PIX_FMT_YVU410  v4l2_fourcc('Y','V','U','9') /*  9  YVU 4:1:0     */
+#define V4L2_PIX_FMT_YVU420  v4l2_fourcc('Y','V','1','2') /* 12  YVU 4:2:0     */
+#define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y','U','Y','V') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U','Y','V','Y') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16  YVU422 planar */
+#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16  YVU411 planar */
+#define V4L2_PIX_FMT_Y41P    v4l2_fourcc('Y','4','1','P') /* 12  YUV 4:1:1     */
+
+/* two planes -- one Y, one Cr + Cb interleaved  */
+#define V4L2_PIX_FMT_NV12    v4l2_fourcc('N','V','1','2') /* 12  Y/CbCr 4:2:0  */
+#define V4L2_PIX_FMT_NV21    v4l2_fourcc('N','V','2','1') /* 12  Y/CrCb 4:2:0  */
+
+/*  The following formats are not defined in the V4L2 specification */
+#define V4L2_PIX_FMT_YUV410  v4l2_fourcc('Y','U','V','9') /*  9  YUV 4:1:0     */
+#define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y','U','1','2') /* 12  YUV 4:2:0     */
+#define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y','Y','U','V') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_HI240   v4l2_fourcc('H','I','2','4') /*  8  8-bit color   */
+
+/* see http://www.siliconimaging.com/RGB%20Bayer.htm */
+#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B','A','8','1') /*  8  BGBG.. GRGR.. */
+
+/* compressed formats */
+#define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M','J','P','G') /* Motion-JPEG   */
+#define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J','P','E','G') /* JFIF JPEG     */
+#define V4L2_PIX_FMT_DV       v4l2_fourcc('d','v','s','d') /* 1394          */
+#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M','P','E','G') /* MPEG          */
+
+/*  Vendor-specific formats   */
+#define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W','N','V','A') /* Winnov hw compress */
+#define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S','9','1','0') /* SN9C10x compression */
+
+/*
+ *      F O R M A T   E N U M E R A T I O N
+ */
+struct v4l2_fmtdesc
+{
+        __u32               index;             /* Format number      */
+        enum v4l2_buf_type  type;              /* buffer type        */
+        __u32               flags;
+        __u8                description[32];   /* Description string */
+        __u32               pixelformat;       /* Format fourcc      */
+        __u32               reserved[4];
+};
+
+#define V4L2_FMT_FLAG_COMPRESSED 0x0001
+
+
+/*
+ *      T I M E C O D E
+ */
+struct v4l2_timecode
+{
+        __u32   type;
+        __u32   flags;
+        __u8    frames;
+        __u8    seconds;
+        __u8    minutes;
+        __u8    hours;
+        __u8    userbits[4];
+};
+
+/*  Type  */
+#define V4L2_TC_TYPE_24FPS              1
+#define V4L2_TC_TYPE_25FPS              2
+#define V4L2_TC_TYPE_30FPS              3
+#define V4L2_TC_TYPE_50FPS              4
+#define V4L2_TC_TYPE_60FPS              5
+
+/*  Flags  */
+#define V4L2_TC_FLAG_DROPFRAME          0x0001 /* "drop-frame" mode */
+#define V4L2_TC_FLAG_COLORFRAME         0x0002
+#define V4L2_TC_USERBITS_field          0x000C
+#define V4L2_TC_USERBITS_USERDEFINED    0x0000
+#define V4L2_TC_USERBITS_8BITCHARS      0x0008
+/* The above is based on SMPTE timecodes */
+
+
+#if 1
+/*
+ *      M P E G   C O M P R E S S I O N   P A R A M E T E R S
+ *
+ *  ### WARNING: this is still work-in-progress right now, most likely
+ *  ###          there will be some incompatible changes.
+ *
+ */
+
+
+enum v4l2_bitrate_mode {
+        V4L2_BITRATE_NONE = 0,  /* not specified */
+        V4L2_BITRATE_CBR,       /* constant bitrate */
+        V4L2_BITRATE_VBR,       /* variable bitrate */
+};
+struct v4l2_bitrate {
+        /* rates are specified in kbit/sec */
+        enum v4l2_bitrate_mode  mode;
+        __u32                   min;
+        __u32                   target;  /* use this one for CBR */
+        __u32                   max;
+};
+
+enum v4l2_mpeg_streamtype {
+        V4L2_MPEG_SS_1,         /* MPEG-1 system stream */
+        V4L2_MPEG_PS_2,         /* MPEG-2 program stream */
+        V4L2_MPEG_TS_2,         /* MPEG-2 transport stream */
+        V4L2_MPEG_PS_DVD,       /* MPEG-2 program stream with DVD header fixups */
+};
+enum v4l2_mpeg_audiotype {
+        V4L2_MPEG_AU_2_I,       /* MPEG-2 layer 1 */
+        V4L2_MPEG_AU_2_II,      /* MPEG-2 layer 2 */
+        V4L2_MPEG_AU_2_III,     /* MPEG-2 layer 3 */
+        V4L2_MPEG_AC3,          /* AC3 */
+        V4L2_MPEG_LPCM,         /* LPCM */
+};
+enum v4l2_mpeg_videotype {
+        V4L2_MPEG_VI_1,         /* MPEG-1 */
+        V4L2_MPEG_VI_2,         /* MPEG-2 */
+};
+enum v4l2_mpeg_aspectratio {
+        V4L2_MPEG_ASPECT_SQUARE = 1,   /* square pixel */
+        V4L2_MPEG_ASPECT_4_3    = 2,   /*  4 : 3       */
+        V4L2_MPEG_ASPECT_16_9   = 3,   /* 16 : 9       */
+        V4L2_MPEG_ASPECT_1_221  = 4,   /*  1 : 2,21    */
+};
+
+struct v4l2_mpeg_compression {
+        /* general */
+        enum v4l2_mpeg_streamtype       st_type;
+        struct v4l2_bitrate             st_bitrate;
+
+        /* transport streams */
+        __u16                           ts_pid_pmt;
+        __u16                           ts_pid_audio;
+        __u16                           ts_pid_video;
+        __u16                           ts_pid_pcr;
+
+        /* program stream */
+        __u16                           ps_size;
+        __u16                           reserved_1;    /* align */
+
+        /* audio */
+        enum v4l2_mpeg_audiotype        au_type;
+        struct v4l2_bitrate             au_bitrate;
+        __u32                           au_sample_rate;
+        __u8                            au_pesid;
+        __u8                            reserved_2[3]; /* align */
+
+        /* video */
+        enum v4l2_mpeg_videotype        vi_type;
+        enum v4l2_mpeg_aspectratio      vi_aspect_ratio;
+        struct v4l2_bitrate             vi_bitrate;
+        __u32                           vi_frame_rate;
+        __u16                           vi_frames_per_gop;
+        __u16                           vi_bframes_count;
+        __u8                            vi_pesid;
+        __u8                            reserved_3[3]; /* align */
+
+        /* misc flags */
+        __u32                           closed_gops:1;
+        __u32                           pulldown:1;
+        __u32                           reserved_4:30; /* align */
+
+        /* I don't expect the above being perfect yet ;) */
+        __u32                           reserved_5[8];
+};
+#endif
+
+struct v4l2_jpegcompression
+{
+        int quality;
+
+        int  APPn;              /* Number of APP segment to be written,
+                                 * must be 0..15 */
+        int  APP_len;           /* Length of data in JPEG APPn segment */
+        char APP_data[60];      /* Data in the JPEG APPn segment. */
+
+        int  COM_len;           /* Length of data in JPEG COM segment */
+        char COM_data[60];      /* Data in JPEG COM segment */
+
+        __u32 jpeg_markers;     /* Which markers should go into the JPEG
+                                 * output. Unless you exactly know what
+                                 * you do, leave them untouched.
+                                 * Inluding less markers will make the
+                                 * resulting code smaller, but there will
+                                 * be fewer aplications which can read it.
+                                 * The presence of the APP and COM marker
+                                 * is influenced by APP_len and COM_len
+                                 * ONLY, not by this property! */
+
+#define V4L2_JPEG_MARKER_DHT (1<<3)    /* Define Huffman Tables */
+#define V4L2_JPEG_MARKER_DQT (1<<4)    /* Define Quantization Tables */
+#define V4L2_JPEG_MARKER_DRI (1<<5)    /* Define Restart Interval */
+#define V4L2_JPEG_MARKER_COM (1<<6)    /* Comment segment */
+#define V4L2_JPEG_MARKER_APP (1<<7)    /* App segment, driver will
+                                        * allways use APP0 */
+};
+
+
+/*
+ *      M E M O R Y - M A P P I N G   B U F F E R S
+ */
+struct v4l2_requestbuffers
+{
+        __u32                   count;
+        enum v4l2_buf_type      type;
+        enum v4l2_memory        memory;
+        __u32                   reserved[2];
+};
+
+struct v4l2_buffer
+{
+        __u32                   index;
+        enum v4l2_buf_type      type;
+        __u32                   bytesused;
+        __u32                   flags;
+        enum v4l2_field         field;
+        struct timeval          timestamp;
+        struct v4l2_timecode    timecode;
+        __u32                   sequence;
+
+        /* memory location */
+        enum v4l2_memory        memory;
+        union {
+                __u32           offset;
+                unsigned long   userptr;
+        } m;
+        __u32                   length;
+        __u32                   input;
+        __u32                   reserved;
+};
+
+/*  Flags for 'flags' field */
+#define V4L2_BUF_FLAG_MAPPED    0x0001  /* Buffer is mapped (flag) */
+#define V4L2_BUF_FLAG_QUEUED    0x0002  /* Buffer is queued for processing */
+#define V4L2_BUF_FLAG_DONE      0x0004  /* Buffer is ready */
+#define V4L2_BUF_FLAG_KEYFRAME  0x0008  /* Image is a keyframe (I-frame) */
+#define V4L2_BUF_FLAG_PFRAME    0x0010  /* Image is a P-frame */
+#define V4L2_BUF_FLAG_BFRAME    0x0020  /* Image is a B-frame */
+#define V4L2_BUF_FLAG_TIMECODE  0x0100  /* timecode field is valid */
+#define V4L2_BUF_FLAG_INPUT     0x0200  /* input field is valid */
+
+/*
+ *      O V E R L A Y   P R E V I E W
+ */
+struct v4l2_framebuffer
+{
+        __u32                   capability;
+        __u32                   flags;
+/* FIXME: in theory we should pass something like PCI device + memory
+ * region + offset instead of some physical address */
+        void*                   base;
+        struct v4l2_pix_format  fmt;
+};
+/*  Flags for the 'capability' field. Read only */
+#define V4L2_FBUF_CAP_EXTERNOVERLAY     0x0001
+#define V4L2_FBUF_CAP_CHROMAKEY         0x0002
+#define V4L2_FBUF_CAP_LIST_CLIPPING     0x0004
+#define V4L2_FBUF_CAP_BITMAP_CLIPPING   0x0008
+/*  Flags for the 'flags' field. */
+#define V4L2_FBUF_FLAG_PRIMARY          0x0001
+#define V4L2_FBUF_FLAG_OVERLAY          0x0002
+#define V4L2_FBUF_FLAG_CHROMAKEY        0x0004
+
+struct v4l2_clip
+{
+        struct v4l2_rect        c;
+        struct v4l2_clip        *next;
+};
+
+struct v4l2_window
+{
+        struct v4l2_rect        w;
+        enum v4l2_field         field;
+        __u32                   chromakey;
+        struct v4l2_clip        __user *clips;
+        __u32                   clipcount;
+        void                    __user *bitmap;
+};
+
+
+/*
+ *      C A P T U R E   P A R A M E T E R S
+ */
+struct v4l2_captureparm
+{
+        __u32              capability;    /*  Supported modes */
+        __u32              capturemode;   /*  Current mode */
+        struct v4l2_fract  timeperframe;  /*  Time per frame in .1us units */
+        __u32              extendedmode;  /*  Driver-specific extensions */
+        __u32              readbuffers;   /*  # of buffers for read */
+        __u32              reserved[4];
+};
+/*  Flags for 'capability' and 'capturemode' fields */
+#define V4L2_MODE_HIGHQUALITY   0x0001  /*  High quality imaging mode */
+#define V4L2_CAP_TIMEPERFRAME   0x1000  /*  timeperframe field is supported */
+
+struct v4l2_outputparm
+{
+        __u32              capability;   /*  Supported modes */
+        __u32              outputmode;   /*  Current mode */
+        struct v4l2_fract  timeperframe; /*  Time per frame in seconds */
+        __u32              extendedmode; /*  Driver-specific extensions */
+        __u32              writebuffers; /*  # of buffers for write */
+        __u32              reserved[4];
+};
+
+/*
+ *      I N P U T   I M A G E   C R O P P I N G
+ */
+
+struct v4l2_cropcap {
+        enum v4l2_buf_type      type;
+        struct v4l2_rect        bounds;
+        struct v4l2_rect        defrect;
+        struct v4l2_fract       pixelaspect;
+};
+
+struct v4l2_crop {
+        enum v4l2_buf_type      type;
+        struct v4l2_rect        c;
+};
+
+/*
+ *      A N A L O G   V I D E O   S T A N D A R D
+ */
+
+typedef __u64 v4l2_std_id;
+
+/* one bit for each */
+#define V4L2_STD_PAL_B          ((v4l2_std_id)0x00000001)
+#define V4L2_STD_PAL_B1         ((v4l2_std_id)0x00000002)
+#define V4L2_STD_PAL_G          ((v4l2_std_id)0x00000004)
+#define V4L2_STD_PAL_H          ((v4l2_std_id)0x00000008)
+#define V4L2_STD_PAL_I          ((v4l2_std_id)0x00000010)
+#define V4L2_STD_PAL_D          ((v4l2_std_id)0x00000020)
+#define V4L2_STD_PAL_D1         ((v4l2_std_id)0x00000040)
+#define V4L2_STD_PAL_K          ((v4l2_std_id)0x00000080)
+
+#define V4L2_STD_PAL_M          ((v4l2_std_id)0x00000100)
+#define V4L2_STD_PAL_N          ((v4l2_std_id)0x00000200)
+#define V4L2_STD_PAL_Nc         ((v4l2_std_id)0x00000400)
+#define V4L2_STD_PAL_60         ((v4l2_std_id)0x00000800)
+
+#define V4L2_STD_NTSC_M         ((v4l2_std_id)0x00001000)
+#define V4L2_STD_NTSC_M_JP      ((v4l2_std_id)0x00002000)
+
+#define V4L2_STD_SECAM_B        ((v4l2_std_id)0x00010000)
+#define V4L2_STD_SECAM_D        ((v4l2_std_id)0x00020000)
+#define V4L2_STD_SECAM_G        ((v4l2_std_id)0x00040000)
+#define V4L2_STD_SECAM_H        ((v4l2_std_id)0x00080000)
+#define V4L2_STD_SECAM_K        ((v4l2_std_id)0x00100000)
+#define V4L2_STD_SECAM_K1       ((v4l2_std_id)0x00200000)
+#define V4L2_STD_SECAM_L        ((v4l2_std_id)0x00400000)
+
+/* ATSC/HDTV */
+#define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
+#define V4L2_STD_ATSC_16_VSB    ((v4l2_std_id)0x02000000)
+
+/* some common needed stuff */
+#define V4L2_STD_PAL_BG         (V4L2_STD_PAL_B         |\
+                                 V4L2_STD_PAL_B1        |\
+                                 V4L2_STD_PAL_G)
+#define V4L2_STD_PAL_DK         (V4L2_STD_PAL_D         |\
+                                 V4L2_STD_PAL_D1        |\
+                                 V4L2_STD_PAL_K)
+#define V4L2_STD_PAL            (V4L2_STD_PAL_BG        |\
+                                 V4L2_STD_PAL_DK        |\
+                                 V4L2_STD_PAL_H         |\
+                                 V4L2_STD_PAL_I)
+#define V4L2_STD_NTSC           (V4L2_STD_NTSC_M        |\
+                                 V4L2_STD_NTSC_M_JP)
+#define V4L2_STD_SECAM_DK       (V4L2_STD_SECAM_D       |\
+                                 V4L2_STD_SECAM_K       |\
+                                 V4L2_STD_SECAM_K1)
+#define V4L2_STD_SECAM          (V4L2_STD_SECAM_B       |\
+                                 V4L2_STD_SECAM_G       |\
+                                 V4L2_STD_SECAM_H       |\
+                                 V4L2_STD_SECAM_DK      |\
+                                 V4L2_STD_SECAM_L)
+
+#define V4L2_STD_525_60         (V4L2_STD_PAL_M         |\
+                                 V4L2_STD_PAL_60        |\
+                                 V4L2_STD_NTSC)
+#define V4L2_STD_625_50         (V4L2_STD_PAL           |\
+                                 V4L2_STD_PAL_N         |\
+                                 V4L2_STD_PAL_Nc        |\
+                                 V4L2_STD_SECAM)
+#define V4L2_STD_ATSC           (V4L2_STD_ATSC_8_VSB    |\
+                                 V4L2_STD_ATSC_16_VSB)
+
+#define V4L2_STD_UNKNOWN        0
+#define V4L2_STD_ALL            (V4L2_STD_525_60        |\
+                                 V4L2_STD_625_50)
+
+struct v4l2_standard
+{
+        __u32                index;
+        v4l2_std_id          id;
+        __u8                 name[24];
+        struct v4l2_fract    frameperiod; /* Frames, not fields */
+        __u32                framelines;
+        __u32                reserved[4];
+};
+
+
+/*
+ *      V I D E O   I N P U T S
+ */
+struct v4l2_input
+{
+        __u32        index;             /*  Which input */
+        __u8         name[32];          /*  Label */
+        __u32        type;              /*  Type of input */
+        __u32        audioset;          /*  Associated audios (bitfield) */
+        __u32        tuner;             /*  Associated tuner */
+        v4l2_std_id  std;
+        __u32        status;
+        __u32        reserved[4];
+};
+/*  Values for the 'type' field */
+#define V4L2_INPUT_TYPE_TUNER           1
+#define V4L2_INPUT_TYPE_CAMERA          2
+
+/* field 'status' - general */
+#define V4L2_IN_ST_NO_POWER    0x00000001  /* Attached device is off */
+#define V4L2_IN_ST_NO_SIGNAL   0x00000002
+#define V4L2_IN_ST_NO_COLOR    0x00000004
+
+/* field 'status' - analog */
+#define V4L2_IN_ST_NO_H_LOCK   0x00000100  /* No horizontal sync lock */
+#define V4L2_IN_ST_COLOR_KILL  0x00000200  /* Color killer is active */
+
+/* field 'status' - digital */
+#define V4L2_IN_ST_NO_SYNC     0x00010000  /* No synchronization lock */
+#define V4L2_IN_ST_NO_EQU      0x00020000  /* No equalizer lock */
+#define V4L2_IN_ST_NO_CARRIER  0x00040000  /* Carrier recovery failed */
+
+/* field 'status' - VCR and set-top box */
+#define V4L2_IN_ST_MACROVISION 0x01000000  /* Macrovision detected */
+#define V4L2_IN_ST_NO_ACCESS   0x02000000  /* Conditional access denied */
+#define V4L2_IN_ST_VTR         0x04000000  /* VTR time constant */
+
+/*
+ *      V I D E O   O U T P U T S
+ */
+struct v4l2_output
+{
+        __u32        index;             /*  Which output */
+        __u8         name[32];          /*  Label */
+        __u32        type;              /*  Type of output */
+        __u32        audioset;          /*  Associated audios (bitfield) */
+        __u32        modulator;         /*  Associated modulator */
+        v4l2_std_id  std;
+        __u32        reserved[4];
+};
+/*  Values for the 'type' field */
+#define V4L2_OUTPUT_TYPE_MODULATOR              1
+#define V4L2_OUTPUT_TYPE_ANALOG                 2
+#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY       3
+
+/*
+ *      C O N T R O L S
+ */
+struct v4l2_control
+{
+        __u32                id;
+        __s32                value;
+};
+
+/*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
+struct v4l2_queryctrl
+{
+        __u32                id;
+        enum v4l2_ctrl_type  type;
+        __u8                 name[32];  /* Whatever */
+        __s32                minimum;   /* Note signedness */
+        __s32                maximum;
+        __s32                step;
+        __s32                default_value;
+        __u32                flags;
+        __u32                reserved[2];
+};
+
+/*  Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
+struct v4l2_querymenu
+{
+        __u32           id;
+        __u32           index;
+        __u8            name[32];       /* Whatever */
+        __u32           reserved;
+};
+
+/*  Control flags  */
+#define V4L2_CTRL_FLAG_DISABLED         0x0001
+#define V4L2_CTRL_FLAG_GRABBED          0x0002
+
+/*  Control IDs defined by V4L2 */
+#define V4L2_CID_BASE                   0x00980900
+/*  IDs reserved for driver specific controls */
+#define V4L2_CID_PRIVATE_BASE           0x08000000
+
+#define V4L2_CID_BRIGHTNESS             (V4L2_CID_BASE+0)
+#define V4L2_CID_CONTRAST               (V4L2_CID_BASE+1)
+#define V4L2_CID_SATURATION             (V4L2_CID_BASE+2)
+#define V4L2_CID_HUE                    (V4L2_CID_BASE+3)
+#define V4L2_CID_AUDIO_VOLUME           (V4L2_CID_BASE+5)
+#define V4L2_CID_AUDIO_BALANCE          (V4L2_CID_BASE+6)
+#define V4L2_CID_AUDIO_BASS             (V4L2_CID_BASE+7)
+#define V4L2_CID_AUDIO_TREBLE           (V4L2_CID_BASE+8)
+#define V4L2_CID_AUDIO_MUTE             (V4L2_CID_BASE+9)
+#define V4L2_CID_AUDIO_LOUDNESS         (V4L2_CID_BASE+10)
+#define V4L2_CID_BLACK_LEVEL            (V4L2_CID_BASE+11)
+#define V4L2_CID_AUTO_WHITE_BALANCE     (V4L2_CID_BASE+12)
+#define V4L2_CID_DO_WHITE_BALANCE       (V4L2_CID_BASE+13)
+#define V4L2_CID_RED_BALANCE            (V4L2_CID_BASE+14)
+#define V4L2_CID_BLUE_BALANCE           (V4L2_CID_BASE+15)
+#define V4L2_CID_GAMMA                  (V4L2_CID_BASE+16)
+#define V4L2_CID_WHITENESS              (V4L2_CID_GAMMA) /* ? Not sure */
+#define V4L2_CID_EXPOSURE               (V4L2_CID_BASE+17)
+#define V4L2_CID_AUTOGAIN               (V4L2_CID_BASE+18)
+#define V4L2_CID_GAIN                   (V4L2_CID_BASE+19)
+#define V4L2_CID_HFLIP                  (V4L2_CID_BASE+20)
+#define V4L2_CID_VFLIP                  (V4L2_CID_BASE+21)
+#define V4L2_CID_HCENTER                (V4L2_CID_BASE+22)
+#define V4L2_CID_VCENTER                (V4L2_CID_BASE+23)
+#define V4L2_CID_LASTP1                 (V4L2_CID_BASE+24) /* last CID + 1 */
+
+/*
+ *      T U N I N G
+ */
+struct v4l2_tuner
+{
+        __u32                   index;
+        __u8                    name[32];
+        enum v4l2_tuner_type    type;
+        __u32                   capability;
+        __u32                   rangelow;
+        __u32                   rangehigh;
+        __u32                   rxsubchans;
+        __u32                   audmode;
+        __s32                   signal;
+        __s32                   afc;
+        __u32                   reserved[4];
+};
+
+struct v4l2_modulator
+{
+        __u32                   index;
+        __u8                    name[32];
+        __u32                   capability;
+        __u32                   rangelow;
+        __u32                   rangehigh;
+        __u32                   txsubchans;
+        __u32                   reserved[4];
+};
+
+/*  Flags for the 'capability' field */
+#define V4L2_TUNER_CAP_LOW              0x0001
+#define V4L2_TUNER_CAP_NORM             0x0002
+#define V4L2_TUNER_CAP_STEREO           0x0010
+#define V4L2_TUNER_CAP_LANG2            0x0020
+#define V4L2_TUNER_CAP_SAP              0x0020
+#define V4L2_TUNER_CAP_LANG1            0x0040
+
+/*  Flags for the 'rxsubchans' field */
+#define V4L2_TUNER_SUB_MONO             0x0001
+#define V4L2_TUNER_SUB_STEREO           0x0002
+#define V4L2_TUNER_SUB_LANG2            0x0004
+#define V4L2_TUNER_SUB_SAP              0x0004
+#define V4L2_TUNER_SUB_LANG1            0x0008
+
+/*  Values for the 'audmode' field */
+#define V4L2_TUNER_MODE_MONO            0x0000
+#define V4L2_TUNER_MODE_STEREO          0x0001
+#define V4L2_TUNER_MODE_LANG2           0x0002
+#define V4L2_TUNER_MODE_SAP             0x0002
+#define V4L2_TUNER_MODE_LANG1           0x0003
+
+struct v4l2_frequency
+{
+        __u32                 tuner;
+        enum v4l2_tuner_type  type;
+        __u32                 frequency;
+        __u32                 reserved[8];
+};
+
+/*
+ *      A U D I O
+ */
+struct v4l2_audio
+{
+        __u32   index;
+        __u8    name[32];
+        __u32   capability;
+        __u32   mode;
+        __u32   reserved[2];
+};
+/*  Flags for the 'capability' field */
+#define V4L2_AUDCAP_STEREO              0x00001
+#define V4L2_AUDCAP_AVL                 0x00002
+
+/*  Flags for the 'mode' field */
+#define V4L2_AUDMODE_AVL                0x00001
+
+struct v4l2_audioout
+{
+        __u32   index;
+        __u8    name[32];
+        __u32   capability;
+        __u32   mode;
+        __u32   reserved[2];
+};
+
+/*
+ *      D A T A   S E R V I C E S   ( V B I )
+ *
+ *      Data services API by Michael Schimek
+ */
+
+struct v4l2_vbi_format
+{
+        __u32   sampling_rate;          /* in 1 Hz */
+        __u32   offset;
+        __u32   samples_per_line;
+        __u32   sample_format;          /* V4L2_PIX_FMT_* */
+        __s32   start[2];
+        __u32   count[2];
+        __u32   flags;                  /* V4L2_VBI_* */
+        __u32   reserved[2];            /* must be zero */
+};
+
+/*  VBI flags  */
+#define V4L2_VBI_UNSYNC         (1<< 0)
+#define V4L2_VBI_INTERLACED     (1<< 1)
+
+
+/*
+ *      A G G R E G A T E   S T R U C T U R E S
+ */
+
+/*      Stream data format
+ */
+struct v4l2_format
+{
+        enum v4l2_buf_type type;
+        union
+        {
+                struct v4l2_pix_format  pix;  // V4L2_BUF_TYPE_VIDEO_CAPTURE
+                struct v4l2_window      win;  // V4L2_BUF_TYPE_VIDEO_OVERLAY
+                struct v4l2_vbi_format  vbi;  // V4L2_BUF_TYPE_VBI_CAPTURE
+                __u8    raw_data[200];        // user-defined
+        } fmt;
+};
+
+
+/*      Stream type-dependent parameters
+ */
+struct v4l2_streamparm
+{
+        enum v4l2_buf_type type;
+        union
+        {
+                struct v4l2_captureparm capture;
+                struct v4l2_outputparm  output;
+                __u8    raw_data[200];  /* user-defined */
+        } parm;
+};
+
+
+
+/*
+ *      I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
+ *
+ */
+#define VIDIOC_QUERYCAP         _IOR  ('V',  0, struct v4l2_capability)
+#define VIDIOC_RESERVED         _IO   ('V',  1)
+#define VIDIOC_ENUM_FMT         _IOWR ('V',  2, struct v4l2_fmtdesc)
+#define VIDIOC_G_FMT            _IOWR ('V',  4, struct v4l2_format)
+#define VIDIOC_S_FMT            _IOWR ('V',  5, struct v4l2_format)
+#if 1 /* experimental */
+#define VIDIOC_G_MPEGCOMP       _IOR  ('V',  6, struct v4l2_mpeg_compression)
+#define VIDIOC_S_MPEGCOMP       _IOW  ('V',  7, struct v4l2_mpeg_compression)
+#endif
+#define VIDIOC_REQBUFS          _IOWR ('V',  8, struct v4l2_requestbuffers)
+#define VIDIOC_QUERYBUF         _IOWR ('V',  9, struct v4l2_buffer)
+#define VIDIOC_G_FBUF           _IOR  ('V', 10, struct v4l2_framebuffer)
+#define VIDIOC_S_FBUF           _IOW  ('V', 11, struct v4l2_framebuffer)
+#define VIDIOC_OVERLAY          _IOW  ('V', 14, int)
+#define VIDIOC_QBUF             _IOWR ('V', 15, struct v4l2_buffer)
+#define VIDIOC_DQBUF            _IOWR ('V', 17, struct v4l2_buffer)
+#define VIDIOC_STREAMON         _IOW  ('V', 18, int)
+#define VIDIOC_STREAMOFF        _IOW  ('V', 19, int)
+#define VIDIOC_G_PARM           _IOWR ('V', 21, struct v4l2_streamparm)
+#define VIDIOC_S_PARM           _IOWR ('V', 22, struct v4l2_streamparm)
+#define VIDIOC_G_STD            _IOR  ('V', 23, v4l2_std_id)
+#define VIDIOC_S_STD            _IOW  ('V', 24, v4l2_std_id)
+#define VIDIOC_ENUMSTD          _IOWR ('V', 25, struct v4l2_standard)
+#define VIDIOC_ENUMINPUT        _IOWR ('V', 26, struct v4l2_input)
+#define VIDIOC_G_CTRL           _IOWR ('V', 27, struct v4l2_control)
+#define VIDIOC_S_CTRL           _IOWR ('V', 28, struct v4l2_control)
+#define VIDIOC_G_TUNER          _IOWR ('V', 29, struct v4l2_tuner)
+#define VIDIOC_S_TUNER          _IOW  ('V', 30, struct v4l2_tuner)
+#define VIDIOC_G_AUDIO          _IOR  ('V', 33, struct v4l2_audio)
+#define VIDIOC_S_AUDIO          _IOW  ('V', 34, struct v4l2_audio)
+#define VIDIOC_QUERYCTRL        _IOWR ('V', 36, struct v4l2_queryctrl)
+#define VIDIOC_QUERYMENU        _IOWR ('V', 37, struct v4l2_querymenu)
+#define VIDIOC_G_INPUT          _IOR  ('V', 38, int)
+#define VIDIOC_S_INPUT          _IOWR ('V', 39, int)
+#define VIDIOC_G_OUTPUT         _IOR  ('V', 46, int)
+#define VIDIOC_S_OUTPUT         _IOWR ('V', 47, int)
+#define VIDIOC_ENUMOUTPUT       _IOWR ('V', 48, struct v4l2_output)
+#define VIDIOC_G_AUDOUT         _IOR  ('V', 49, struct v4l2_audioout)
+#define VIDIOC_S_AUDOUT         _IOW  ('V', 50, struct v4l2_audioout)
+#define VIDIOC_G_MODULATOR      _IOWR ('V', 54, struct v4l2_modulator)
+#define VIDIOC_S_MODULATOR      _IOW  ('V', 55, struct v4l2_modulator)
+#define VIDIOC_G_FREQUENCY      _IOWR ('V', 56, struct v4l2_frequency)
+#define VIDIOC_S_FREQUENCY      _IOW  ('V', 57, struct v4l2_frequency)
+#define VIDIOC_CROPCAP          _IOWR ('V', 58, struct v4l2_cropcap)
+#define VIDIOC_G_CROP           _IOWR ('V', 59, struct v4l2_crop)
+#define VIDIOC_S_CROP           _IOW  ('V', 60, struct v4l2_crop)
+#define VIDIOC_G_JPEGCOMP       _IOR  ('V', 61, struct v4l2_jpegcompression)
+#define VIDIOC_S_JPEGCOMP       _IOW  ('V', 62, struct v4l2_jpegcompression)
+#define VIDIOC_QUERYSTD         _IOR  ('V', 63, v4l2_std_id)
+#define VIDIOC_TRY_FMT          _IOWR ('V', 64, struct v4l2_format)
+#define VIDIOC_ENUMAUDIO        _IOWR ('V', 65, struct v4l2_audio)
+#define VIDIOC_ENUMAUDOUT       _IOWR ('V', 66, struct v4l2_audioout)
+#define VIDIOC_G_PRIORITY       _IOR  ('V', 67, enum v4l2_priority)
+#define VIDIOC_S_PRIORITY       _IOW  ('V', 68, enum v4l2_priority)
+
+/* for compatibility, will go away some day */
+#define VIDIOC_OVERLAY_OLD      _IOWR ('V', 14, int)
+#define VIDIOC_S_PARM_OLD       _IOW  ('V', 22, struct v4l2_streamparm)
+#define VIDIOC_S_CTRL_OLD       _IOW  ('V', 28, struct v4l2_control)
+#define VIDIOC_G_AUDIO_OLD      _IOWR ('V', 33, struct v4l2_audio)
+#define VIDIOC_G_AUDOUT_OLD     _IOWR ('V', 49, struct v4l2_audioout)
+#define VIDIOC_CROPCAP_OLD      _IOR  ('V', 58, struct v4l2_cropcap)
+
+#define BASE_VIDIOC_PRIVATE     192             /* 192-255 are private */
+
+
+#ifdef __KERNEL__
+/*
+ *
+ *      V 4 L 2   D R I V E R   H E L P E R   A P I
+ *
+ *      Some commonly needed functions for drivers (v4l2-common.o module)
+ */
+#include <linux/fs.h>
+
+/*  Video standard functions  */
+extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs);
+extern int v4l2_video_std_construct(struct v4l2_standard *vs,
+                                    int id, char *name);
+
+/* prority handling */
+struct v4l2_prio_state {
+        atomic_t prios[4];
+};
+int v4l2_prio_init(struct v4l2_prio_state *global);
+int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
+                     enum v4l2_priority new);
+int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
+int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local);
+enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
+int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local);
+
+/* names for fancy debug output */
+extern char *v4l2_field_names[];
+extern char *v4l2_type_names[];
+extern char *v4l2_ioctl_names[];
+
+/*  Compatibility layer interface  --  v4l1-compat module */
+typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
+                           unsigned int cmd, void *arg);
+int v4l_compat_translate_ioctl(struct inode *inode, struct file *file,
+                               int cmd, void *arg, v4l2_kioctl driver_ioctl);
+
+#endif /* __KERNEL__ */
+#endif /* __LINUX_VIDEODEV2_H */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/include/linux/videotext.h b/include/linux/videotext.h
new file mode 100644
index 000000000000..018f92047ff8
--- /dev/null
+++ b/include/linux/videotext.h
@@ -0,0 +1,125 @@
+#ifndef _VTX_H
+#define _VTX_H
+
+/*
+ * Teletext (=Videotext) hardware decoders using interface /dev/vtx
+ * Do not confuse with drivers using /dev/vbi which decode videotext by software
+ *
+ * Videotext IOCTLs changed in order to use _IO() macros defined in <linux/ioctl.h>,
+ * unused tuner IOCTLs cleaned up by
+ * Michael Geng <linux@MichaelGeng.de>
+ *
+ * Copyright (c) 1994-97 Martin Buck  <martin-2.buck@student.uni-ulm.de>
+ * Read COPYING for more information
+ *
+ */
+
+
+/*
+ *      Videotext ioctls
+ */
+#define VTXIOCGETINFO   _IOR  (0x81,  1, vtx_info_t)
+#define VTXIOCCLRPAGE   _IOW  (0x81,  2, vtx_pagereq_t)
+#define VTXIOCCLRFOUND  _IOW  (0x81,  3, vtx_pagereq_t)
+#define VTXIOCPAGEREQ   _IOW  (0x81,  4, vtx_pagereq_t)
+#define VTXIOCGETSTAT   _IOW  (0x81,  5, vtx_pagereq_t)
+#define VTXIOCGETPAGE   _IOW  (0x81,  6, vtx_pagereq_t)
+#define VTXIOCSTOPDAU   _IOW  (0x81,  7, vtx_pagereq_t)
+#define VTXIOCPUTPAGE   _IO   (0x81,  8)
+#define VTXIOCSETDISP   _IO   (0x81,  9)
+#define VTXIOCPUTSTAT   _IO   (0x81, 10)
+#define VTXIOCCLRCACHE  _IO   (0x81, 11)
+#define VTXIOCSETVIRT   _IOW  (0x81, 12, long)
+
+/* for compatibility, will go away some day */
+#define VTXIOCGETINFO_OLD  0x7101  /* get version of driver & capabilities of vtx-chipset */
+#define VTXIOCCLRPAGE_OLD  0x7102  /* clear page-buffer */
+#define VTXIOCCLRFOUND_OLD 0x7103  /* clear bits indicating that page was found */
+#define VTXIOCPAGEREQ_OLD  0x7104  /* search for page */
+#define VTXIOCGETSTAT_OLD  0x7105  /* get status of page-buffer */
+#define VTXIOCGETPAGE_OLD  0x7106  /* get contents of page-buffer */
+#define VTXIOCSTOPDAU_OLD  0x7107  /* stop data acquisition unit */
+#define VTXIOCPUTPAGE_OLD  0x7108  /* display page on TV-screen */
+#define VTXIOCSETDISP_OLD  0x7109  /* set TV-mode */
+#define VTXIOCPUTSTAT_OLD  0x710a  /* set status of TV-output-buffer */
+#define VTXIOCCLRCACHE_OLD 0x710b  /* clear cache on VTX-interface (if avail.) */
+#define VTXIOCSETVIRT_OLD  0x710c  /* turn on virtual mode (this disables TV-display) */
+
+/* 
+ *      Definitions for VTXIOCGETINFO
+ */
+ 
+#define SAA5243 0
+#define SAA5246 1
+#define SAA5249 2
+#define SAA5248 3
+#define XSTV5346 4
+
+typedef struct {
+        int version_major, version_minor;       /* version of driver; if version_major changes, driver */
+                                                /* is not backward compatible!!! CHECK THIS!!! */  
+        int numpages;                           /* number of page-buffers of vtx-chipset */
+        int cct_type;                           /* type of vtx-chipset (SAA5243, SAA5246, SAA5248 or
+                                                 * SAA5249) */
+}
+vtx_info_t;
+
+
+/*
+ *      Definitions for VTXIOC{CLRPAGE,CLRFOUND,PAGEREQ,GETSTAT,GETPAGE,STOPDAU,PUTPAGE,SETDISP}
+ */
+
+#define MIN_UNIT   (1<<0)
+#define MIN_TEN    (1<<1)
+#define HR_UNIT    (1<<2)
+#define HR_TEN     (1<<3)
+#define PG_UNIT    (1<<4)
+#define PG_TEN     (1<<5)
+#define PG_HUND    (1<<6)
+#define PGMASK_MAX (1<<7)
+#define PGMASK_PAGE (PG_HUND | PG_TEN | PG_UNIT)
+#define PGMASK_HOUR (HR_TEN | HR_UNIT)
+#define PGMASK_MINUTE (MIN_TEN | MIN_UNIT)
+
+typedef struct 
+{
+        int page;       /* number of requested page (hexadecimal) */
+        int hour;       /* requested hour (hexadecimal) */
+        int minute;     /* requested minute (hexadecimal) */
+        int pagemask;   /* mask defining which values of the above are set */
+        int pgbuf;      /* buffer where page will be stored */
+        int start;      /* start of requested part of page */
+        int end;        /* end of requested part of page */
+        void __user *buffer;    /* pointer to beginning of destination buffer */
+}
+vtx_pagereq_t;
+
+
+/*
+ *      Definitions for VTXIOC{GETSTAT,PUTSTAT}
+ */
+ 
+#define VTX_PAGESIZE (40 * 24)
+#define VTX_VIRTUALSIZE (40 * 49)
+
+typedef struct 
+{
+        int pagenum;                    /* number of page (hexadecimal) */
+        int hour;                       /* hour (hexadecimal) */
+        int minute;                     /* minute (hexadecimal) */
+        int charset;                    /* national charset */
+        unsigned delete : 1;            /* delete page (C4) */
+        unsigned headline : 1;          /* insert headline (C5) */
+        unsigned subtitle : 1;          /* insert subtitle (C6) */
+        unsigned supp_header : 1;       /* suppress header (C7) */
+        unsigned update : 1;            /* update page (C8) */
+        unsigned inter_seq : 1;         /* interrupted sequence (C9) */
+        unsigned dis_disp : 1;          /* disable/suppress display (C10) */
+        unsigned serial : 1;            /* serial mode (C11) */
+        unsigned notfound : 1;          /* /FOUND */
+        unsigned pblf : 1;              /* PBLF */
+        unsigned hamming : 1;           /* hamming-error occurred */
+}
+vtx_pageinfo_t;
+ 
+#endif /* _VTX_H */
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
new file mode 100644
index 000000000000..3a358c895188
--- /dev/null
+++ b/include/linux/vmalloc.h
@@ -0,0 +1,54 @@
+#ifndef _LINUX_VMALLOC_H
+#define _LINUX_VMALLOC_H
+
+#include <linux/spinlock.h>
+#include <asm/page.h>           /* pgprot_t */
+
+/* bits in vm_struct->flags */
+#define VM_IOREMAP      0x00000001      /* ioremap() and friends */
+#define VM_ALLOC        0x00000002      /* vmalloc() */
+#define VM_MAP          0x00000004      /* vmap()ed pages */
+/* bits [20..32] reserved for arch specific ioremap internals */
+
+struct vm_struct {
+        void                    *addr;
+        unsigned long           size;
+        unsigned long           flags;
+        struct page             **pages;
+        unsigned int            nr_pages;
+        unsigned long           phys_addr;
+        struct vm_struct        *next;
+};
+
+/*
+ *      Highlevel APIs for driver use
+ */
+extern void *vmalloc(unsigned long size);
+extern void *vmalloc_exec(unsigned long size);
+extern void *vmalloc_32(unsigned long size);
+extern void *__vmalloc(unsigned long size, unsigned int __nocast gfp_mask, pgprot_t prot);
+extern void *__vmalloc_area(struct vm_struct *area, unsigned int __nocast gfp_mask, pgprot_t prot);
+extern void vfree(void *addr);
+
+extern void *vmap(struct page **pages, unsigned int count,
+                        unsigned long flags, pgprot_t prot);
+extern void vunmap(void *addr);
+ 
+/*
+ *      Lowlevel-APIs (not for driver use!)
+ */
+extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
+extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
+                                        unsigned long start, unsigned long end);
+extern struct vm_struct *remove_vm_area(void *addr);
+extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
+                        struct page ***pages);
+extern void unmap_vm_area(struct vm_struct *area);
+
+/*
+ *      Internals.  Dont't use..
+ */
+extern rwlock_t vmlist_lock;
+extern struct vm_struct *vmlist;
+
+#endif /* _LINUX_VMALLOC_H */
diff --git a/include/linux/vt.h b/include/linux/vt.h
new file mode 100644
index 000000000000..9f95b0bea5b3
--- /dev/null
+++ b/include/linux/vt.h
@@ -0,0 +1,54 @@
+#ifndef _LINUX_VT_H
+#define _LINUX_VT_H
+
+/* 0x56 is 'V', to avoid collision with termios and kd */
+
+#define VT_OPENQRY      0x5600  /* find available vt */
+
+struct vt_mode {
+        char mode;              /* vt mode */
+        char waitv;             /* if set, hang on writes if not active */
+        short relsig;           /* signal to raise on release req */
+        short acqsig;           /* signal to raise on acquisition */
+        short frsig;            /* unused (set to 0) */
+};
+#define VT_GETMODE      0x5601  /* get mode of active vt */
+#define VT_SETMODE      0x5602  /* set mode of active vt */
+#define         VT_AUTO         0x00    /* auto vt switching */
+#define         VT_PROCESS      0x01    /* process controls switching */
+#define         VT_ACKACQ       0x02    /* acknowledge switch */
+
+struct vt_stat {
+        unsigned short v_active;        /* active vt */
+        unsigned short v_signal;        /* signal to send */
+        unsigned short v_state;         /* vt bitmask */
+};
+#define VT_GETSTATE     0x5603  /* get global vt state info */
+#define VT_SENDSIG      0x5604  /* signal to send to bitmask of vts */
+
+#define VT_RELDISP      0x5605  /* release display */
+
+#define VT_ACTIVATE     0x5606  /* make vt active */
+#define VT_WAITACTIVE   0x5607  /* wait for vt active */
+#define VT_DISALLOCATE  0x5608  /* free memory associated to vt */
+
+struct vt_sizes {
+        unsigned short v_rows;          /* number of rows */
+        unsigned short v_cols;          /* number of columns */
+        unsigned short v_scrollsize;    /* number of lines of scrollback */
+};
+#define VT_RESIZE       0x5609  /* set kernel's idea of screensize */
+
+struct vt_consize {
+        unsigned short v_rows;  /* number of rows */
+        unsigned short v_cols;  /* number of columns */
+        unsigned short v_vlin;  /* number of pixel rows on screen */
+        unsigned short v_clin;  /* number of pixel rows per character */
+        unsigned short v_vcol;  /* number of pixel columns on screen */
+        unsigned short v_ccol;  /* number of pixel columns per character */
+};
+#define VT_RESIZEX      0x560A  /* set kernel's idea of screensize + more */
+#define VT_LOCKSWITCH   0x560B  /* disallow vt switching */
+#define VT_UNLOCKSWITCH 0x560C  /* allow vt switching */
+
+#endif /* _LINUX_VT_H */
diff --git a/include/linux/vt_buffer.h b/include/linux/vt_buffer.h
new file mode 100644
index 000000000000..1f7ba3629053
--- /dev/null
+++ b/include/linux/vt_buffer.h
@@ -0,0 +1,64 @@
+/*
+ *      include/linux/vt_buffer.h -- Access to VT screen buffer
+ *
+ *      (c) 1998 Martin Mares <mj@ucw.cz>
+ *
+ *      This is a set of macros and functions which are used in the
+ *      console driver and related code to access the screen buffer.
+ *      In most cases the console works with simple in-memory buffer,
+ *      but when handling hardware text mode consoles, we store
+ *      the foreground console directly in video memory.
+ */
+
+#ifndef _LINUX_VT_BUFFER_H_
+#define _LINUX_VT_BUFFER_H_
+
+#include <linux/config.h>
+
+#if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_MDA_CONSOLE)
+#include <asm/vga.h>
+#endif
+
+#ifndef VT_BUF_HAVE_RW
+#define scr_writew(val, addr) (*(addr) = (val))
+#define scr_readw(addr) (*(addr))
+#define scr_memcpyw(d, s, c) memcpy(d, s, c)
+#define scr_memmovew(d, s, c) memmove(d, s, c)
+#define VT_BUF_HAVE_MEMCPYW
+#define VT_BUF_HAVE_MEMMOVEW
+#endif
+
+#ifndef VT_BUF_HAVE_MEMSETW
+static inline void scr_memsetw(u16 *s, u16 c, unsigned int count)
+{
+        count /= 2;
+        while (count--)
+                scr_writew(c, s++);
+}
+#endif
+
+#ifndef VT_BUF_HAVE_MEMCPYW
+static inline void scr_memcpyw(u16 *d, const u16 *s, unsigned int count)
+{
+        count /= 2;
+        while (count--)
+                scr_writew(scr_readw(s++), d++);
+}
+#endif
+
+#ifndef VT_BUF_HAVE_MEMMOVEW
+static inline void scr_memmovew(u16 *d, const u16 *s, unsigned int count)
+{
+        if (d < s)
+                scr_memcpyw(d, s, count);
+        else {
+                count /= 2;
+                d += count;
+                s += count;
+                while (count--)
+                        scr_writew(scr_readw(--s), --d);
+        }
+}
+#endif
+
+#endif
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
new file mode 100644
index 000000000000..fab5aed8ca31
--- /dev/null
+++ b/include/linux/vt_kern.h
@@ -0,0 +1,86 @@
+#ifndef _VT_KERN_H
+#define _VT_KERN_H
+
+/*
+ * this really is an extension of the vc_cons structure in console.c, but
+ * with information needed by the vt package
+ */
+
+#include <linux/config.h>
+#include <linux/vt.h>
+#include <linux/kd.h>
+#include <linux/tty.h>
+#include <linux/console_struct.h>
+#include <linux/mm.h>
+
+/*
+ * Presently, a lot of graphics programs do not restore the contents of
+ * the higher font pages.  Defining this flag will avoid use of them, but
+ * will lose support for PIO_FONTRESET.  Note that many font operations are
+ * not likely to work with these programs anyway; they need to be
+ * fixed.  The linux/Documentation directory includes a code snippet
+ * to save and restore the text font.
+ */
+#ifdef CONFIG_VGA_CONSOLE
+#define BROKEN_GRAPHICS_PROGRAMS 1
+#endif
+
+extern void kd_mksound(unsigned int hz, unsigned int ticks);
+extern int kbd_rate(struct kbd_repeat *rep);
+
+/* console.c */
+
+int vc_allocate(unsigned int console);
+int vc_cons_allocated(unsigned int console);
+int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
+void vc_disallocate(unsigned int console);
+void reset_palette(struct vc_data *vc);
+void do_blank_screen(int entering_gfx);
+void do_unblank_screen(int leaving_gfx);
+void unblank_screen(void);
+void poke_blanked_console(void);
+int con_font_op(struct vc_data *vc, struct console_font_op *op);
+int con_set_cmap(unsigned char __user *cmap);
+int con_get_cmap(unsigned char __user *cmap);
+void scrollback(struct vc_data *vc, int lines);
+void scrollfront(struct vc_data *vc, int lines);
+void update_region(struct vc_data *vc, unsigned long start, int count);
+void redraw_screen(struct vc_data *vc, int is_switch);
+#define update_screen(x) redraw_screen(x, 0)
+#define switch_screen(x) redraw_screen(x, 1)
+
+struct tty_struct;
+int tioclinux(struct tty_struct *tty, unsigned long arg);
+
+/* consolemap.c */
+
+struct unimapinit;
+struct unipair;
+
+int con_set_trans_old(unsigned char __user * table);
+int con_get_trans_old(unsigned char __user * table);
+int con_set_trans_new(unsigned short __user * table);
+int con_get_trans_new(unsigned short __user * table);
+int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui);
+int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list);
+int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct, struct unipair __user *list);
+int con_set_default_unimap(struct vc_data *vc);
+void con_free_unimap(struct vc_data *vc);
+void con_protect_unimap(struct vc_data *vc, int rdonly);
+int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
+
+/* vt.c */
+int vt_waitactive(int vt);
+void change_console(struct vc_data *new_vc);
+void reset_vc(struct vc_data *vc);
+
+/*
+ * vc_screen.c shares this temporary buffer with the console write code so that
+ * we can easily avoid touching user space while holding the console spinlock.
+ */
+
+#define CON_BUF_SIZE (CONFIG_BASE_SMALL ? 256 : PAGE_SIZE)
+extern char con_buf[CON_BUF_SIZE];
+extern struct semaphore con_buf_sem;
+
+#endif /* _VT_KERN_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
new file mode 100644
index 000000000000..17c874a8eb3f
--- /dev/null
+++ b/include/linux/wait.h
@@ -0,0 +1,460 @@
+#ifndef _LINUX_WAIT_H
+#define _LINUX_WAIT_H
+
+#define WNOHANG         0x00000001
+#define WUNTRACED       0x00000002
+#define WSTOPPED        WUNTRACED
+#define WEXITED         0x00000004
+#define WCONTINUED      0x00000008
+#define WNOWAIT         0x01000000      /* Don't reap, just poll status.  */
+
+#define __WNOTHREAD     0x20000000      /* Don't wait on children of other threads in this group */
+#define __WALL          0x40000000      /* Wait on all children, regardless of type */
+#define __WCLONE        0x80000000      /* Wait only on non-SIGCHLD children */
+
+/* First argument to waitid: */
+#define P_ALL           0
+#define P_PID           1
+#define P_PGID          2
+
+#ifdef __KERNEL__
+
+#include <linux/config.h>
+#include <linux/list.h>
+#include <linux/stddef.h>
+#include <linux/spinlock.h>
+#include <asm/system.h>
+#include <asm/current.h>
+
+typedef struct __wait_queue wait_queue_t;
+typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
+int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
+
+struct __wait_queue {
+        unsigned int flags;
+#define WQ_FLAG_EXCLUSIVE       0x01
+        struct task_struct * task;
+        wait_queue_func_t func;
+        struct list_head task_list;
+};
+
+struct wait_bit_key {
+        void *flags;
+        int bit_nr;
+};
+
+struct wait_bit_queue {
+        struct wait_bit_key key;
+        wait_queue_t wait;
+};
+
+struct __wait_queue_head {
+        spinlock_t lock;
+        struct list_head task_list;
+};
+typedef struct __wait_queue_head wait_queue_head_t;
+
+
+/*
+ * Macros for declaration and initialisaton of the datatypes
+ */
+
+#define __WAITQUEUE_INITIALIZER(name, tsk) {                            \
+        .task           = tsk,                                          \
+        .func           = default_wake_function,                        \
+        .task_list      = { NULL, NULL } }
+
+#define DECLARE_WAITQUEUE(name, tsk)                                    \
+        wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
+
+#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                           \
+        .lock           = SPIN_LOCK_UNLOCKED,                           \
+        .task_list      = { &(name).task_list, &(name).task_list } }
+
+#define DECLARE_WAIT_QUEUE_HEAD(name) \
+        wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
+
+#define __WAIT_BIT_KEY_INITIALIZER(word, bit)                           \
+        { .flags = word, .bit_nr = bit, }
+
+static inline void init_waitqueue_head(wait_queue_head_t *q)
+{
+        spin_lock_init(&q->lock);
+        INIT_LIST_HEAD(&q->task_list);
+}
+
+static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
+{
+        q->flags = 0;
+        q->task = p;
+        q->func = default_wake_function;
+}
+
+static inline void init_waitqueue_func_entry(wait_queue_t *q,
+                                        wait_queue_func_t func)
+{
+        q->flags = 0;
+        q->task = NULL;
+        q->func = func;
+}
+
+static inline int waitqueue_active(wait_queue_head_t *q)
+{
+        return !list_empty(&q->task_list);
+}
+
+/*
+ * Used to distinguish between sync and async io wait context:
+ * sync i/o typically specifies a NULL wait queue entry or a wait
+ * queue entry bound to a task (current task) to wake up.
+ * aio specifies a wait queue entry with an async notification
+ * callback routine, not associated with any task.
+ */
+#define is_sync_wait(wait)      (!(wait) || ((wait)->task))
+
+extern void FASTCALL(add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));
+extern void FASTCALL(add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait));
+extern void FASTCALL(remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));
+
+static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
+{
+        list_add(&new->task_list, &head->task_list);
+}
+
+/*
+ * Used for wake-one threads:
+ */
+static inline void __add_wait_queue_tail(wait_queue_head_t *head,
+                                                wait_queue_t *new)
+{
+        list_add_tail(&new->task_list, &head->task_list);
+}
+
+static inline void __remove_wait_queue(wait_queue_head_t *head,
+                                                        wait_queue_t *old)
+{
+        list_del(&old->task_list);
+}
+
+void FASTCALL(__wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key));
+extern void FASTCALL(__wake_up_locked(wait_queue_head_t *q, unsigned int mode));
+extern void FASTCALL(__wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr));
+void FASTCALL(__wake_up_bit(wait_queue_head_t *, void *, int));
+int FASTCALL(__wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned));
+int FASTCALL(__wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned));
+void FASTCALL(wake_up_bit(void *, int));
+int FASTCALL(out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned));
+int FASTCALL(out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned));
+wait_queue_head_t *FASTCALL(bit_waitqueue(void *, int));
+
+#define wake_up(x)                      __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, NULL)
+#define wake_up_nr(x, nr)               __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr, NULL)
+#define wake_up_all(x)                  __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, NULL)
+#define wake_up_interruptible(x)        __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
+#define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
+#define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
+#define wake_up_locked(x)               __wake_up_locked((x), TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE)
+#define wake_up_interruptible_sync(x)   __wake_up_sync((x),TASK_INTERRUPTIBLE, 1)
+
+#define __wait_event(wq, condition)                                     \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
+                if (condition)                                          \
+                        break;                                          \
+                schedule();                                             \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+/**
+ * wait_event - sleep until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
+ * @condition evaluates to true. The @condition is checked each time
+ * the waitqueue @wq is woken up.
+ *
+ * wake_up() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ */
+#define wait_event(wq, condition)                                       \
+do {                                                                    \
+        if (condition)                                                  \
+                break;                                                  \
+        __wait_event(wq, condition);                                    \
+} while (0)
+
+#define __wait_event_timeout(wq, condition, ret)                        \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
+                if (condition)                                          \
+                        break;                                          \
+                ret = schedule_timeout(ret);                            \
+                if (!ret)                                               \
+                        break;                                          \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+/**
+ * wait_event_timeout - sleep until a condition gets true or a timeout elapses
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ * @timeout: timeout, in jiffies
+ *
+ * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
+ * @condition evaluates to true. The @condition is checked each time
+ * the waitqueue @wq is woken up.
+ *
+ * wake_up() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function returns 0 if the @timeout elapsed, and the remaining
+ * jiffies if the condition evaluated to true before the timeout elapsed.
+ */
+#define wait_event_timeout(wq, condition, timeout)                      \
+({                                                                      \
+        long __ret = timeout;                                           \
+        if (!(condition))                                               \
+                __wait_event_timeout(wq, condition, __ret);             \
+        __ret;                                                          \
+})
+
+#define __wait_event_interruptible(wq, condition, ret)                  \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \
+                if (condition)                                          \
+                        break;                                          \
+                if (!signal_pending(current)) {                         \
+                        schedule();                                     \
+                        continue;                                       \
+                }                                                       \
+                ret = -ERESTARTSYS;                                     \
+                break;                                                  \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+/**
+ * wait_event_interruptible - sleep until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * wake_up() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function will return -ERESTARTSYS if it was interrupted by a
+ * signal and 0 if @condition evaluated to true.
+ */
+#define wait_event_interruptible(wq, condition)                         \
+({                                                                      \
+        int __ret = 0;                                                  \
+        if (!(condition))                                               \
+                __wait_event_interruptible(wq, condition, __ret);       \
+        __ret;                                                          \
+})
+
+#define __wait_event_interruptible_timeout(wq, condition, ret)          \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \
+                if (condition)                                          \
+                        break;                                          \
+                if (!signal_pending(current)) {                         \
+                        ret = schedule_timeout(ret);                    \
+                        if (!ret)                                       \
+                                break;                                  \
+                        continue;                                       \
+                }                                                       \
+                ret = -ERESTARTSYS;                                     \
+                break;                                                  \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+/**
+ * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ * @timeout: timeout, in jiffies
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE) until the
+ * @condition evaluates to true or a signal is received.
+ * The @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * wake_up() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ *
+ * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
+ * was interrupted by a signal, and the remaining jiffies otherwise
+ * if the condition evaluated to true before the timeout elapsed.
+ */
+#define wait_event_interruptible_timeout(wq, condition, timeout)        \
+({                                                                      \
+        long __ret = timeout;                                           \
+        if (!(condition))                                               \
+                __wait_event_interruptible_timeout(wq, condition, __ret); \
+        __ret;                                                          \
+})
+
+#define __wait_event_interruptible_exclusive(wq, condition, ret)        \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait_exclusive(&wq, &__wait,                 \
+                                        TASK_INTERRUPTIBLE);            \
+                if (condition)                                          \
+                        break;                                          \
+                if (!signal_pending(current)) {                         \
+                        schedule();                                     \
+                        continue;                                       \
+                }                                                       \
+                ret = -ERESTARTSYS;                                     \
+                break;                                                  \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
+
+#define wait_event_interruptible_exclusive(wq, condition)               \
+({                                                                      \
+        int __ret = 0;                                                  \
+        if (!(condition))                                               \
+                __wait_event_interruptible_exclusive(wq, condition, __ret);\
+        __ret;                                                          \
+})
+
+/*
+ * Must be called with the spinlock in the wait_queue_head_t held.
+ */
+static inline void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
+                                                   wait_queue_t * wait)
+{
+        wait->flags |= WQ_FLAG_EXCLUSIVE;
+        __add_wait_queue_tail(q,  wait);
+}
+
+/*
+ * Must be called with the spinlock in the wait_queue_head_t held.
+ */
+static inline void remove_wait_queue_locked(wait_queue_head_t *q,
+                                            wait_queue_t * wait)
+{
+        __remove_wait_queue(q,  wait);
+}
+
+/*
+ * These are the old interfaces to sleep waiting for an event.
+ * They are racy.  DO NOT use them, use the wait_event* interfaces above.  
+ * We plan to remove these interfaces during 2.7.
+ */
+extern void FASTCALL(sleep_on(wait_queue_head_t *q));
+extern long FASTCALL(sleep_on_timeout(wait_queue_head_t *q,
+                                      signed long timeout));
+extern void FASTCALL(interruptible_sleep_on(wait_queue_head_t *q));
+extern long FASTCALL(interruptible_sleep_on_timeout(wait_queue_head_t *q,
+                                                    signed long timeout));
+
+/*
+ * Waitqueues which are removed from the waitqueue_head at wakeup time
+ */
+void FASTCALL(prepare_to_wait(wait_queue_head_t *q,
+                                wait_queue_t *wait, int state));
+void FASTCALL(prepare_to_wait_exclusive(wait_queue_head_t *q,
+                                wait_queue_t *wait, int state));
+void FASTCALL(finish_wait(wait_queue_head_t *q, wait_queue_t *wait));
+int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
+int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
+
+#define DEFINE_WAIT(name)                                               \
+        wait_queue_t name = {                                           \
+                .task           = current,                              \
+                .func           = autoremove_wake_function,             \
+                .task_list      = {     .next = &(name).task_list,      \
+                                        .prev = &(name).task_list,      \
+                                },                                      \
+        }
+
+#define DEFINE_WAIT_BIT(name, word, bit)                                \
+        struct wait_bit_queue name = {                                  \
+                .key = __WAIT_BIT_KEY_INITIALIZER(word, bit),           \
+                .wait   = {                                             \
+                        .task           = current,                      \
+                        .func           = wake_bit_function,            \
+                        .task_list      =                               \
+                                LIST_HEAD_INIT((name).wait.task_list),  \
+                },                                                      \
+        }
+
+#define init_wait(wait)                                                 \
+        do {                                                            \
+                (wait)->task = current;                                 \
+                (wait)->func = autoremove_wake_function;                \
+                INIT_LIST_HEAD(&(wait)->task_list);                     \
+        } while (0)
+
+/**
+ * wait_on_bit - wait for a bit to be cleared
+ * @word: the word being waited on, a kernel virtual address
+ * @bit: the bit of the word being waited on
+ * @action: the function used to sleep, which may take special actions
+ * @mode: the task state to sleep in
+ *
+ * There is a standard hashed waitqueue table for generic use. This
+ * is the part of the hashtable's accessor API that waits on a bit.
+ * For instance, if one were to have waiters on a bitflag, one would
+ * call wait_on_bit() in threads waiting for the bit to clear.
+ * One uses wait_on_bit() where one is waiting for the bit to clear,
+ * but has no intention of setting it.
+ */
+static inline int wait_on_bit(void *word, int bit,
+                                int (*action)(void *), unsigned mode)
+{
+        if (!test_bit(bit, word))
+                return 0;
+        return out_of_line_wait_on_bit(word, bit, action, mode);
+}
+
+/**
+ * wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it
+ * @word: the word being waited on, a kernel virtual address
+ * @bit: the bit of the word being waited on
+ * @action: the function used to sleep, which may take special actions
+ * @mode: the task state to sleep in
+ *
+ * There is a standard hashed waitqueue table for generic use. This
+ * is the part of the hashtable's accessor API that waits on a bit
+ * when one intends to set it, for instance, trying to lock bitflags.
+ * For instance, if one were to have waiters trying to set bitflag
+ * and waiting for it to clear before setting it, one would call
+ * wait_on_bit() in threads waiting to be able to set the bit.
+ * One uses wait_on_bit_lock() where one is waiting for the bit to
+ * clear with the intention of setting it, and when done, clearing it.
+ */
+static inline int wait_on_bit_lock(void *word, int bit,
+                                int (*action)(void *), unsigned mode)
+{
+        if (!test_and_set_bit(bit, word))
+                return 0;
+        return out_of_line_wait_on_bit_lock(word, bit, action, mode);
+}
+        
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/wanpipe.h b/include/linux/wanpipe.h
new file mode 100644
index 000000000000..167d956c492b
--- /dev/null
+++ b/include/linux/wanpipe.h
@@ -0,0 +1,492 @@
+/*****************************************************************************
+* wanpipe.h     WANPIPE(tm) Multiprotocol WAN Link Driver.
+*               User-level API definitions.
+*
+* Author:       Nenad Corbic <ncorbic@sangoma.com>
+*               Gideon Hack     
+*
+* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Nov 3,  2000  Nenad Corbic    Added config_id to sdla_t structure.
+*                               Used to determine the protocol running.
+* Jul 13, 2000  Nenad Corbic    Added SyncPPP Support
+* Feb 24, 2000  Nenad Corbic    Added support for x25api driver
+* Oct 04, 1999  Nenad Corbic    New CHDLC and FRAME RELAY code, SMP support
+* Jun 02, 1999  Gideon Hack     Added 'update_call_count' for Cisco HDLC 
+*                               support
+* Jun 26, 1998  David Fong      Added 'ip_mode' in sdla_t.u.p for dynamic IP
+*                               routing mode configuration
+* Jun 12, 1998  David Fong      Added Cisco HDLC union member in sdla_t
+* Dec 08, 1997  Jaspreet Singh  Added 'authenticator' in union of 'sdla_t' 
+* Nov 26, 1997  Jaspreet Singh  Added 'load_sharing' structure.  Also added 
+*                               'devs_struct','dev_to_devtint_next' to 'sdla_t' 
+* Nov 24, 1997  Jaspreet Singh  Added 'irq_dis_if_send_count', 
+*                               'irq_dis_poll_count' to 'sdla_t'.
+* Nov 06, 1997  Jaspreet Singh  Added a define called 'INTR_TEST_MODE'
+* Oct 20, 1997  Jaspreet Singh  Added 'buff_intr_mode_unbusy' and 
+*                               'dlci_intr_mode_unbusy' to 'sdla_t'
+* Oct 18, 1997  Jaspreet Singh  Added structure to maintain global driver
+*                               statistics.
+* Jan 15, 1997  Gene Kozin      Version 3.1.0
+*                                o added UDP management stuff
+* Jan 02, 1997  Gene Kozin      Version 3.0.0
+*****************************************************************************/
+#ifndef _WANPIPE_H
+#define _WANPIPE_H
+
+#include <linux/wanrouter.h>
+
+/* Defines */
+
+#ifndef PACKED
+#define PACKED  __attribute__((packed))
+#endif
+
+#define WANPIPE_MAGIC   0x414C4453L     /* signature: 'SDLA' reversed */
+
+/* IOCTL numbers (up to 16) */
+#define WANPIPE_DUMP    (ROUTER_USER+0) /* dump adapter's memory */
+#define WANPIPE_EXEC    (ROUTER_USER+1) /* execute firmware command */
+
+#define TRACE_ALL                       0x00
+#define TRACE_PROT                      0x01
+#define TRACE_DATA                      0x02
+
+/* values for request/reply byte */
+#define UDPMGMT_REQUEST 0x01
+#define UDPMGMT_REPLY   0x02
+#define UDP_OFFSET      12
+
+#define MAX_CMD_BUFF    10
+#define MAX_X25_LCN     255     /* Maximum number of x25 channels */
+#define MAX_LCN_NUM     4095    /* Maximum lcn number */
+#define MAX_FT1_RETRY   100
+
+#ifndef AF_WANPIPE
+        #define AF_WANPIPE 25
+        #ifndef PF_WANPIPE
+                #define PF_WANPIPE AF_WANPIPE
+        #endif
+#endif
+
+
+#define TX_TIMEOUT 5*HZ
+
+/* General Critical Flags */
+#define SEND_CRIT       0x00
+#define PERI_CRIT       0x01
+
+/* Chdlc and PPP polling critical flag */
+#define POLL_CRIT       0x03
+
+/* Frame Relay Tx IRQ send critical flag */
+#define SEND_TXIRQ_CRIT 0x02
+
+/* Frame Relay ARP critical flag */
+#define ARP_CRIT        0x03
+
+/* Bit maps for dynamic interface configuration
+ * DYN_OPT_ON : turns this option on/off 
+ * DEV_DOWN   : device was shutdown by the driver not
+ *              by user 
+ */
+#define DYN_OPT_ON      0x00
+#define DEV_DOWN        0x01
+
+/*
+ * Data structures for IOCTL calls.
+ */
+
+typedef struct sdla_dump        /* WANPIPE_DUMP */
+{
+        unsigned long magic;    /* for verification */
+        unsigned long offset;   /* absolute adapter memory address */
+        unsigned long length;   /* block length */
+        void* ptr;              /* -> buffer */
+} sdla_dump_t;
+
+typedef struct sdla_exec        /* WANPIPE_EXEC */
+{
+        unsigned long magic;    /* for verification */
+        void* cmd;              /* -> command structure */
+        void* data;             /* -> data buffer */
+} sdla_exec_t;
+
+/* UDP management stuff */
+
+typedef struct wum_header
+{
+        unsigned char signature[8];     /* 00h: signature */
+        unsigned char type;             /* 08h: request/reply */
+        unsigned char command;          /* 09h: commnand */
+        unsigned char reserved[6];      /* 0Ah: reserved */
+} wum_header_t;
+
+/*************************************************************************
+ Data Structure for global statistics
+*************************************************************************/
+
+typedef struct global_stats
+{
+        unsigned long isr_entry;
+        unsigned long isr_already_critical;             
+        unsigned long isr_rx;
+        unsigned long isr_tx;
+        unsigned long isr_intr_test;
+        unsigned long isr_spurious;
+        unsigned long isr_enable_tx_int;
+        unsigned long rx_intr_corrupt_rx_bfr;
+        unsigned long rx_intr_on_orphaned_DLCI;
+        unsigned long rx_intr_dev_not_started;
+        unsigned long tx_intr_dev_not_started;
+        unsigned long poll_entry;
+        unsigned long poll_already_critical;
+        unsigned long poll_processed;
+        unsigned long poll_tbusy_bad_status;
+        unsigned long poll_host_disable_irq;
+        unsigned long poll_host_enable_irq;
+
+} global_stats_t;
+
+
+typedef struct{
+        unsigned short  udp_src_port            PACKED;
+        unsigned short  udp_dst_port            PACKED;
+        unsigned short  udp_length              PACKED;
+        unsigned short  udp_checksum            PACKED;
+} udp_pkt_t;
+
+
+typedef struct {
+        unsigned char   ver_inet_hdr_length     PACKED;
+        unsigned char   service_type            PACKED;
+        unsigned short  total_length            PACKED;
+        unsigned short  identifier              PACKED;
+        unsigned short  flags_frag_offset       PACKED;
+        unsigned char   ttl                     PACKED;
+        unsigned char   protocol                PACKED;
+        unsigned short  hdr_checksum            PACKED;
+        unsigned long   ip_src_address          PACKED;
+        unsigned long   ip_dst_address          PACKED;
+} ip_pkt_t;
+
+
+typedef struct {
+        unsigned char           signature[8]    PACKED;
+        unsigned char           request_reply   PACKED;
+        unsigned char           id              PACKED;
+        unsigned char           reserved[6]     PACKED;
+} wp_mgmt_t;
+
+/*************************************************************************
+ Data Structure for if_send  statistics
+*************************************************************************/  
+typedef struct if_send_stat{
+        unsigned long if_send_entry;
+        unsigned long if_send_skb_null;
+        unsigned long if_send_broadcast;
+        unsigned long if_send_multicast;
+        unsigned long if_send_critical_ISR;
+        unsigned long if_send_critical_non_ISR;
+        unsigned long if_send_tbusy;
+        unsigned long if_send_tbusy_timeout;
+        unsigned long if_send_PIPE_request;
+        unsigned long if_send_wan_disconnected;
+        unsigned long if_send_dlci_disconnected;
+        unsigned long if_send_no_bfrs;
+        unsigned long if_send_adptr_bfrs_full;
+        unsigned long if_send_bfr_passed_to_adptr;
+        unsigned long if_send_protocol_error;
+        unsigned long if_send_bfr_not_passed_to_adptr;
+        unsigned long if_send_tx_int_enabled;
+        unsigned long if_send_consec_send_fail; 
+} if_send_stat_t;
+
+typedef struct rx_intr_stat{
+        unsigned long rx_intr_no_socket;
+        unsigned long rx_intr_dev_not_started;
+        unsigned long rx_intr_PIPE_request;
+        unsigned long rx_intr_bfr_not_passed_to_stack;
+        unsigned long rx_intr_bfr_passed_to_stack;
+} rx_intr_stat_t;       
+
+typedef struct pipe_mgmt_stat{
+        unsigned long UDP_PIPE_mgmt_kmalloc_err;
+        unsigned long UDP_PIPE_mgmt_direction_err;
+        unsigned long UDP_PIPE_mgmt_adptr_type_err;
+        unsigned long UDP_PIPE_mgmt_adptr_cmnd_OK;
+        unsigned long UDP_PIPE_mgmt_adptr_cmnd_timeout;
+        unsigned long UDP_PIPE_mgmt_adptr_send_passed;
+        unsigned long UDP_PIPE_mgmt_adptr_send_failed;
+        unsigned long UDP_PIPE_mgmt_not_passed_to_stack;
+        unsigned long UDP_PIPE_mgmt_passed_to_stack;
+        unsigned long UDP_PIPE_mgmt_no_socket;
+        unsigned long UDP_PIPE_mgmt_passed_to_adptr;
+} pipe_mgmt_stat_t;
+
+
+typedef struct {
+        struct sk_buff *skb;
+} bh_data_t, cmd_data_t;
+
+#define MAX_LGTH_UDP_MGNT_PKT 2000
+ 
+
+/* This is used for interrupt testing */
+#define INTR_TEST_MODE  0x02
+
+#define WUM_SIGNATURE_L 0x50495046
+#define WUM_SIGNATURE_H 0x444E3845
+
+#define WUM_KILL        0x50
+#define WUM_EXEC        0x51
+
+#define WANPIPE         0x00
+#define API             0x01
+#define BRIDGE          0x02
+#define BRIDGE_NODE     0x03
+
+#ifdef  __KERNEL__
+/****** Kernel Interface ****************************************************/
+
+#include <linux/sdladrv.h>      /* SDLA support module API definitions */
+#include <linux/sdlasfm.h>      /* SDLA firmware module definitions */
+#include <linux/workqueue.h>
+#include <linux/serial.h>
+#include <linux/serialP.h>
+#include <linux/serial_reg.h>
+#include <asm/serial.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+
+
+#define is_digit(ch) (((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')?1:0)
+#define is_alpha(ch) ((((ch)>=(unsigned)'a'&&(ch)<=(unsigned)'z')||\
+                  ((ch)>=(unsigned)'A'&&(ch)<=(unsigned)'Z'))?1:0)
+#define is_hex_digit(ch) ((((ch)>=(unsigned)'0'&&(ch)<=(unsigned)'9')||\
+                  ((ch)>=(unsigned)'a'&&(ch)<=(unsigned)'f')||\
+                  ((ch)>=(unsigned)'A'&&(ch)<=(unsigned)'F'))?1:0)
+
+
+/****** Data Structures *****************************************************/
+
+/* Adapter Data Space.
+ * This structure is needed because we handle multiple cards, otherwise
+ * static data would do it.
+ */
+typedef struct sdla
+{
+        char devname[WAN_DRVNAME_SZ+1]; /* card name */
+        sdlahw_t hw;                    /* hardware configuration */
+        struct wan_device wandev;       /* WAN device data space */
+        
+        unsigned open_cnt;              /* number of open interfaces */
+        unsigned long state_tick;       /* link state timestamp */
+        unsigned intr_mode;             /* Type of Interrupt Mode */
+        char in_isr;                    /* interrupt-in-service flag */
+        char buff_int_mode_unbusy;      /* flag for carrying out dev_tint */  
+        char dlci_int_mode_unbusy;      /* flag for carrying out dev_tint */
+        long configured;                /* flag for previous configurations */
+        
+        unsigned short irq_dis_if_send_count; /* Disabling irqs in if_send*/
+        unsigned short irq_dis_poll_count;   /* Disabling irqs in poll routine*/
+        unsigned short force_enable_irq;
+        char TracingEnabled;            /* flag for enabling trace */
+        global_stats_t statistics;      /* global statistics */
+        void* mbox;                     /* -> mailbox */
+        void* rxmb;                     /* -> receive mailbox */
+        void* flags;                    /* -> adapter status flags */
+        void (*isr)(struct sdla* card); /* interrupt service routine */
+        void (*poll)(struct sdla* card); /* polling routine */
+        int (*exec)(struct sdla* card, void* u_cmd, void* u_data);
+                                        /* Used by the listen() system call */          
+        /* Wanpipe Socket Interface */
+        int   (*func) (struct sk_buff *, struct sock *);
+        struct sock *sk;
+
+        /* Shutdown function */
+        void (*disable_comm) (struct sdla *card);
+
+        /* Secondary Port Device: Piggibacking */
+        struct sdla *next;
+
+        /* TTY driver variables */
+        unsigned char tty_opt;
+        struct tty_struct *tty;
+        unsigned int tty_minor;
+        unsigned int tty_open;
+        unsigned char *tty_buf;
+        unsigned char *tty_rx;
+        struct work_struct tty_work;
+        
+        union
+        {
+                struct
+                {                       /****** X.25 specific data **********/
+                        u32 lo_pvc;
+                        u32 hi_pvc;
+                        u32 lo_svc;
+                        u32 hi_svc;
+                        struct net_device *svc_to_dev_map[MAX_X25_LCN];
+                        struct net_device *pvc_to_dev_map[MAX_X25_LCN];
+                        struct net_device *tx_dev;
+                        struct net_device *cmd_dev;
+                        u32 no_dev;
+                        volatile u8 *hdlc_buf_status;
+                        u32 tx_interrupts_pending;
+                        u16 timer_int_enabled;
+                        struct net_device *poll_device;
+                        atomic_t command_busy;
+
+                        u16 udp_pkt_lgth;
+                        u32 udp_type;
+                        u8  udp_pkt_src;
+                        u32 udp_lcn;
+                        struct net_device *udp_dev;
+                        s8 udp_pkt_data[MAX_LGTH_UDP_MGNT_PKT];
+
+                        u8 LAPB_hdlc;           /* Option to turn off X25 and run only LAPB */
+                        u8 logging;             /* Option to log call messages */
+                        u8 oob_on_modem;        /* Option to send modem status to the api */
+                        u16 num_of_ch;          /* Number of channels configured by the user */
+
+                        struct work_struct x25_poll_work;
+                        struct timer_list x25_timer;
+                } x;
+                struct
+                {                       /****** frame relay specific data ***/
+                        void* rxmb_base;        /* -> first Rx buffer */
+                        void* rxmb_last;        /* -> last Rx buffer */
+                        unsigned rx_base;       /* S508 receive buffer base */
+                        unsigned rx_top;        /* S508 receive buffer end */
+                        unsigned short node_dlci[100];
+                        unsigned short dlci_num;
+                        struct net_device *dlci_to_dev_map[991 + 1];
+                        unsigned tx_interrupts_pending;
+                        unsigned short timer_int_enabled;
+                        unsigned short udp_pkt_lgth;
+                        int udp_type;
+                        char udp_pkt_src;
+                        unsigned udp_dlci;
+                        char udp_pkt_data[MAX_LGTH_UDP_MGNT_PKT];
+                        void* trc_el_base;                      /* first trace element */
+                        void* trc_el_last;                      /* last trace element */
+                        void *curr_trc_el;                      /* current trace element */
+                        unsigned short trc_bfr_space;           /* trace buffer space */
+                        unsigned char  update_comms_stats;
+                        struct net_device *arp_dev;
+                        spinlock_t if_send_lock;
+                } f;
+                struct                  /****** PPP-specific data ***********/
+                {
+                        char if_name[WAN_IFNAME_SZ+1];  /* interface name */
+                        void* txbuf;            /* -> current Tx buffer */
+                        void* txbuf_base;       /* -> first Tx buffer */
+                        void* txbuf_last;       /* -> last Tx buffer */
+                        void* rxbuf_base;       /* -> first Rx buffer */
+                        void* rxbuf_last;       /* -> last Rx buffer */
+                        unsigned rx_base;       /* S508 receive buffer base */
+                        unsigned rx_top;        /* S508 receive buffer end */
+                        char ip_mode;           /* STATIC/HOST/PEER IP Mode */
+                        char authenticator;     /* Authenticator for PAP/CHAP */
+                        unsigned char comm_enabled; /* Is comm enabled or not */
+                        unsigned char peer_route;   /* Process Peer Route */    
+                        unsigned long *txbuf_next;  /* Next Tx buffer to use */ 
+                        unsigned long *rxbuf_next;  /* Next Rx buffer to use */
+                } p;
+                struct                  /* Cisco HDLC-specific data */
+                {
+                        char if_name[WAN_IFNAME_SZ+1];  /* interface name */
+                        unsigned char comm_port;/* Communication Port O or 1 */
+                        unsigned char usedby;  /* Used by WANPIPE or API */
+                        void* rxmb;             /* Receive mail box */
+                        void* flags;            /* flags */
+                        void* tx_status;        /* Tx status element */
+                        void* rx_status;        /* Rx status element */
+                        void* txbuf;            /* -> current Tx buffer */
+                        void* txbuf_base;       /* -> first Tx buffer */
+                        void* txbuf_last;       /* -> last Tx buffer */
+                        void* rxbuf_base;       /* -> first Rx buffer */
+                        void* rxbuf_last;       /* -> last Rx buffer */
+                        unsigned rx_base;       /* S508 receive buffer base */
+                        unsigned rx_top;        /* S508 receive buffer end */
+                        unsigned char receive_only; /* high speed receivers */
+                        unsigned short protocol_options;
+                        unsigned short kpalv_tx;        /* Tx kpalv timer */
+                        unsigned short kpalv_rx;        /* Rx kpalv timer */
+                        unsigned short kpalv_err;       /* Error tolerance */
+                        unsigned short slarp_timer;     /* SLARP req timer */
+                        unsigned state;                 /* state of the link */
+                        unsigned char api_status;
+                        unsigned char update_call_count;
+                        unsigned short api_options;     /* for async config */
+                        unsigned char  async_mode;
+                        unsigned short tx_bits_per_char;
+                        unsigned short rx_bits_per_char;
+                        unsigned short stop_bits;
+                        unsigned short parity;
+                        unsigned short break_timer;
+                        unsigned short inter_char_timer;
+                        unsigned short rx_complete_length;
+                        unsigned short xon_char;
+                        unsigned short xoff_char;
+                        unsigned char comm_enabled; /* Is comm enabled or not */
+                        unsigned char backup;
+                } c;
+                struct
+                {
+                        void* tx_status;        /* Tx status element */
+                        void* rx_status;        /* Rx status element */
+                        void* trace_status;     /* Trace status element */
+                        void* txbuf;            /* -> current Tx buffer */
+                        void* txbuf_base;       /* -> first Tx buffer */
+                        void* txbuf_last;       /* -> last Tx buffer */
+                        void* rxbuf_base;       /* -> first Rx buffer */
+                        void* rxbuf_last;       /* -> last Rx buffer */
+                        void* tracebuf;         /* -> current Trace buffer */
+                        void* tracebuf_base;    /* -> current Trace buffer */
+                        void* tracebuf_last;    /* -> current Trace buffer */
+                        unsigned rx_base;       /* receive buffer base */
+                        unsigned rx_end;        /* receive buffer end */
+                        unsigned trace_base;    /* trace buffer base */
+                        unsigned trace_end;     /* trace buffer end */
+
+                } h;
+        } u;
+} sdla_t;
+
+/****** Public Functions ****************************************************/
+
+void wanpipe_open      (sdla_t* card);                  /* wpmain.c */
+void wanpipe_close     (sdla_t* card);                  /* wpmain.c */
+void wanpipe_set_state (sdla_t* card, int state);       /* wpmain.c */
+
+int wpx_init (sdla_t* card, wandev_conf_t* conf);       /* wpx.c */
+int wpf_init (sdla_t* card, wandev_conf_t* conf);       /* wpf.c */
+int wpp_init (sdla_t* card, wandev_conf_t* conf);       /* wpp.c */
+int wpc_init (sdla_t* card, wandev_conf_t* conf); /* Cisco HDLC */
+int bsc_init (sdla_t* card, wandev_conf_t* conf);       /* BSC streaming */
+int hdlc_init(sdla_t* card, wandev_conf_t* conf);       /* HDLC support */
+int wpft1_init (sdla_t* card, wandev_conf_t* conf);     /* FT1 Config support */
+int wsppp_init (sdla_t* card, wandev_conf_t* conf);     /* Sync PPP on top of RAW CHDLC */
+
+extern sdla_t * wanpipe_find_card(char *);
+extern sdla_t * wanpipe_find_card_num (int);
+
+extern void wanpipe_queue_work (struct work_struct *);
+extern void wanpipe_mark_bh (void);
+extern void wakeup_sk_bh(struct net_device *dev);
+extern int change_dev_flags(struct net_device *dev, unsigned flags);
+extern unsigned long get_ip_address(struct net_device *dev, int option);
+extern void add_gateway(sdla_t *card, struct net_device *dev);
+
+
+#endif  /* __KERNEL__ */
+#endif  /* _WANPIPE_H */
+
diff --git a/include/linux/wanrouter.h b/include/linux/wanrouter.h
new file mode 100644
index 000000000000..3e89f0f15f49
--- /dev/null
+++ b/include/linux/wanrouter.h
@@ -0,0 +1,541 @@
+/*****************************************************************************
+* wanrouter.h   Definitions for the WAN Multiprotocol Router Module.
+*               This module provides API and common services for WAN Link
+*               Drivers and is completely hardware-independent.
+*
+* Author:       Nenad Corbic <ncorbic@sangoma.com>
+*               Gideon Hack     
+* Additions:    Arnaldo Melo
+*
+* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
+*
+*               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; either version
+*               2 of the License, or (at your option) any later version.
+* ============================================================================
+* Jul 21, 2000  Nenad Corbic    Added WAN_FT1_READY State
+* Feb 24, 2000  Nenad Corbic    Added support for socket based x25api
+* Jan 28, 2000  Nenad Corbic    Added support for the ASYNC protocol.
+* Oct 04, 1999  Nenad Corbic    Updated for 2.1.0 release
+* Jun 02, 1999  Gideon Hack     Added support for the S514 adapter.
+* May 23, 1999  Arnaldo Melo    Added local_addr to wanif_conf_t
+*                               WAN_DISCONNECTING state added
+* Jul 20, 1998  David Fong      Added Inverse ARP options to 'wanif_conf_t'
+* Jun 12, 1998  David Fong      Added Cisco HDLC support.
+* Dec 16, 1997  Jaspreet Singh  Moved 'enable_IPX' and 'network_number' to
+*                               'wanif_conf_t'
+* Dec 05, 1997  Jaspreet Singh  Added 'pap', 'chap' to 'wanif_conf_t'
+*                               Added 'authenticator' to 'wan_ppp_conf_t'
+* Nov 06, 1997  Jaspreet Singh  Changed Router Driver version to 1.1 from 1.0
+* Oct 20, 1997  Jaspreet Singh  Added 'cir','bc','be' and 'mc' to 'wanif_conf_t'
+*                               Added 'enable_IPX' and 'network_number' to 
+*                               'wan_device_t'.  Also added defines for
+*                               UDP PACKET TYPE, Interrupt test, critical values
+*                               for RACE conditions.
+* Oct 05, 1997  Jaspreet Singh  Added 'dlci_num' and 'dlci[100]' to 
+*                               'wan_fr_conf_t' to configure a list of dlci(s)
+*                               for a NODE 
+* Jul 07, 1997  Jaspreet Singh  Added 'ttl' to 'wandev_conf_t' & 'wan_device_t'
+* May 29, 1997  Jaspreet Singh  Added 'tx_int_enabled' to 'wan_device_t'
+* May 21, 1997  Jaspreet Singh  Added 'udp_port' to 'wan_device_t'
+* Apr 25, 1997  Farhan Thawar   Added 'udp_port' to 'wandev_conf_t'
+* Jan 16, 1997  Gene Kozin      router_devlist made public
+* Jan 02, 1997  Gene Kozin      Initial version (based on wanpipe.h).
+*****************************************************************************/
+
+#include <linux/spinlock.h>       /* Support for SMP Locking */
+
+#ifndef _ROUTER_H
+#define _ROUTER_H
+
+#define ROUTER_NAME     "wanrouter"     /* in case we ever change it */
+#define ROUTER_VERSION  1               /* version number */
+#define ROUTER_RELEASE  1               /* release (minor version) number */
+#define ROUTER_IOCTL    'W'             /* for IOCTL calls */
+#define ROUTER_MAGIC    0x524D4157L     /* signature: 'WANR' reversed */
+
+/* IOCTL codes for /proc/router/<device> entries (up to 255) */
+enum router_ioctls
+{
+        ROUTER_SETUP    = ROUTER_IOCTL<<8,      /* configure device */
+        ROUTER_DOWN,                            /* shut down device */
+        ROUTER_STAT,                            /* get device status */
+        ROUTER_IFNEW,                           /* add interface */
+        ROUTER_IFDEL,                           /* delete interface */
+        ROUTER_IFSTAT,                          /* get interface status */
+        ROUTER_USER     = (ROUTER_IOCTL<<8)+16, /* driver-specific calls */
+        ROUTER_USER_MAX = (ROUTER_IOCTL<<8)+31
+};
+
+/* identifiers for displaying proc file data for dual port adapters */
+#define PROC_DATA_PORT_0 0x8000 /* the data is for port 0 */
+#define PROC_DATA_PORT_1 0x8001 /* the data is for port 1 */
+
+/* NLPID for packet encapsulation (ISO/IEC TR 9577) */
+#define NLPID_IP        0xCC    /* Internet Protocol Datagram */
+#define NLPID_SNAP      0x80    /* IEEE Subnetwork Access Protocol */
+#define NLPID_CLNP      0x81    /* ISO/IEC 8473 */
+#define NLPID_ESIS      0x82    /* ISO/IEC 9542 */
+#define NLPID_ISIS      0x83    /* ISO/IEC ISIS */
+#define NLPID_Q933      0x08    /* CCITT Q.933 */
+
+/* Miscellaneous */
+#define WAN_IFNAME_SZ   15      /* max length of the interface name */
+#define WAN_DRVNAME_SZ  15      /* max length of the link driver name */
+#define WAN_ADDRESS_SZ  31      /* max length of the WAN media address */
+#define USED_BY_FIELD   8       /* max length of the used by field */
+
+/* Defines for UDP PACKET TYPE */
+#define UDP_PTPIPE_TYPE         0x01
+#define UDP_FPIPE_TYPE          0x02
+#define UDP_CPIPE_TYPE          0x03
+#define UDP_DRVSTATS_TYPE       0x04
+#define UDP_INVALID_TYPE        0x05
+
+/* Command return code */
+#define CMD_OK          0               /* normal firmware return code */
+#define CMD_TIMEOUT     0xFF            /* firmware command timed out */
+
+/* UDP Packet Management */
+#define UDP_PKT_FRM_STACK       0x00
+#define UDP_PKT_FRM_NETWORK     0x01
+
+/* Maximum interrupt test counter */
+#define MAX_INTR_TEST_COUNTER   100
+
+/* Critical Values for RACE conditions*/
+#define CRITICAL_IN_ISR         0xA1
+#define CRITICAL_INTR_HANDLED   0xB1
+
+/****** Data Types **********************************************************/
+
+/*----------------------------------------------------------------------------
+ * X.25-specific link-level configuration.
+ */
+typedef struct wan_x25_conf
+{
+        unsigned lo_pvc;        /* lowest permanent circuit number */
+        unsigned hi_pvc;        /* highest permanent circuit number */
+        unsigned lo_svc;        /* lowest switched circuit number */
+        unsigned hi_svc;        /* highest switched circuit number */
+        unsigned hdlc_window;   /* HDLC window size (1..7) */
+        unsigned pkt_window;    /* X.25 packet window size (1..7) */
+        unsigned t1;            /* HDLC timer T1, sec (1..30) */
+        unsigned t2;            /* HDLC timer T2, sec (0..29) */
+        unsigned t4;            /* HDLC supervisory frame timer = T4 * T1 */
+        unsigned n2;            /* HDLC retransmission limit (1..30) */
+        unsigned t10_t20;       /* X.25 RESTART timeout, sec (1..255) */
+        unsigned t11_t21;       /* X.25 CALL timeout, sec (1..255) */
+        unsigned t12_t22;       /* X.25 RESET timeout, sec (1..255) */
+        unsigned t13_t23;       /* X.25 CLEAR timeout, sec (1..255) */
+        unsigned t16_t26;       /* X.25 INTERRUPT timeout, sec (1..255) */
+        unsigned t28;           /* X.25 REGISTRATION timeout, sec (1..255) */
+        unsigned r10_r20;       /* RESTART retransmission limit (0..250) */
+        unsigned r12_r22;       /* RESET retransmission limit (0..250) */
+        unsigned r13_r23;       /* CLEAR retransmission limit (0..250) */
+        unsigned ccitt_compat;  /* compatibility mode: 1988/1984/1980 */
+        unsigned x25_conf_opt;   /* User defined x25 config optoins */
+        unsigned char LAPB_hdlc_only; /* Run in HDLC only mode */
+        unsigned char logging;   /* Control connection logging */  
+        unsigned char oob_on_modem; /* Whether to send modem status to the user app */
+} wan_x25_conf_t;
+
+/*----------------------------------------------------------------------------
+ * Frame relay specific link-level configuration.
+ */
+typedef struct wan_fr_conf
+{
+        unsigned signalling;    /* local in-channel signalling type */
+        unsigned t391;          /* link integrity verification timer */
+        unsigned t392;          /* polling verification timer */
+        unsigned n391;          /* full status polling cycle counter */
+        unsigned n392;          /* error threshold counter */
+        unsigned n393;          /* monitored events counter */
+        unsigned dlci_num;      /* number of DLCs (access node) */
+        unsigned  dlci[100];    /* List of all DLCIs */
+} wan_fr_conf_t;
+
+/*----------------------------------------------------------------------------
+ * PPP-specific link-level configuration.
+ */
+typedef struct wan_ppp_conf
+{
+        unsigned restart_tmr;   /* restart timer */
+        unsigned auth_rsrt_tmr; /* authentication timer */
+        unsigned auth_wait_tmr; /* authentication timer */
+        unsigned mdm_fail_tmr;  /* modem failure timer */
+        unsigned dtr_drop_tmr;  /* DTR drop timer */
+        unsigned connect_tmout; /* connection timeout */
+        unsigned conf_retry;    /* max. retry */
+        unsigned term_retry;    /* max. retry */
+        unsigned fail_retry;    /* max. retry */
+        unsigned auth_retry;    /* max. retry */
+        unsigned auth_options;  /* authentication opt. */
+        unsigned ip_options;    /* IP options */
+        char    authenticator;  /* AUTHENTICATOR or not */
+        char    ip_mode;        /* Static/Host/Peer */
+} wan_ppp_conf_t;
+
+/*----------------------------------------------------------------------------
+ * CHDLC-specific link-level configuration.
+ */
+typedef struct wan_chdlc_conf
+{
+        unsigned char ignore_dcd;       /* Protocol options:            */
+        unsigned char ignore_cts;       /*  Ignore these to determine   */
+        unsigned char ignore_keepalive; /*  link status (Yes or No)     */
+        unsigned char hdlc_streaming;   /*  hdlc_streaming mode (Y/N) */
+        unsigned char receive_only;     /*  no transmit buffering (Y/N) */
+        unsigned keepalive_tx_tmr;      /* transmit keepalive timer */
+        unsigned keepalive_rx_tmr;      /* receive  keepalive timer */
+        unsigned keepalive_err_margin;  /* keepalive_error_tolerance */
+        unsigned slarp_timer;           /* SLARP request timer */
+} wan_chdlc_conf_t;
+
+
+/*----------------------------------------------------------------------------
+ * WAN device configuration. Passed to ROUTER_SETUP IOCTL.
+ */
+typedef struct wandev_conf
+{
+        unsigned magic;         /* magic number (for verification) */
+        unsigned config_id;     /* configuration structure identifier */
+                                /****** hardware configuration ******/
+        unsigned ioport;        /* adapter I/O port base */
+        unsigned long maddr;    /* dual-port memory address */
+        unsigned msize;         /* dual-port memory size */
+        int irq;                /* interrupt request level */
+        int dma;                /* DMA request level */
+        char S514_CPU_no[1];    /* S514 PCI adapter CPU number ('A' or 'B') */
+        unsigned PCI_slot_no;   /* S514 PCI adapter slot number */
+        char auto_pci_cfg;      /* S515 PCI automatic slot detection */
+        char comm_port;         /* Communication Port (PRI=0, SEC=1) */ 
+        unsigned bps;           /* data transfer rate */
+        unsigned mtu;           /* maximum transmit unit size */
+        unsigned udp_port;      /* UDP port for management */
+        unsigned char ttl;      /* Time To Live for UDP security */
+        unsigned char ft1;      /* FT1 Configurator Option */
+        char interface;         /* RS-232/V.35, etc. */
+        char clocking;          /* external/internal */
+        char line_coding;       /* NRZ/NRZI/FM0/FM1, etc. */
+        char station;           /* DTE/DCE, primary/secondary, etc. */
+        char connection;        /* permanent/switched/on-demand */
+        char read_mode;         /* read mode: Polling or interrupt */
+        char receive_only;      /* disable tx buffers */
+        char tty;               /* Create a fake tty device */
+        unsigned tty_major;     /* Major number for wanpipe tty device */
+        unsigned tty_minor;     /* Minor number for wanpipe tty device */
+        unsigned tty_mode;      /* TTY operation mode SYNC or ASYNC */
+        char backup;            /* Backup Mode */
+        unsigned hw_opt[4];     /* other hardware options */
+        unsigned reserved[4];
+                                /****** arbitrary data ***************/
+        unsigned data_size;     /* data buffer size */
+        void* data;             /* data buffer, e.g. firmware */
+        union                   /****** protocol-specific ************/
+        {
+                wan_x25_conf_t x25;     /* X.25 configuration */
+                wan_ppp_conf_t ppp;     /* PPP configuration */
+                wan_fr_conf_t fr;       /* frame relay configuration */
+                wan_chdlc_conf_t chdlc; /* Cisco HDLC configuration */
+        } u;
+} wandev_conf_t;
+
+/* 'config_id' definitions */
+#define WANCONFIG_X25   101     /* X.25 link */
+#define WANCONFIG_FR    102     /* frame relay link */
+#define WANCONFIG_PPP   103     /* synchronous PPP link */
+#define WANCONFIG_CHDLC 104     /* Cisco HDLC Link */
+#define WANCONFIG_BSC   105     /* BiSync Streaming */
+#define WANCONFIG_HDLC  106     /* HDLC Support */
+#define WANCONFIG_MPPP  107     /* Multi Port PPP over RAW CHDLC */
+
+/*
+ * Configuration options defines.
+ */
+/* general options */
+#define WANOPT_OFF      0
+#define WANOPT_ON       1
+#define WANOPT_NO       0
+#define WANOPT_YES      1
+
+/* intercace options */
+#define WANOPT_RS232    0
+#define WANOPT_V35      1
+
+/* data encoding options */
+#define WANOPT_NRZ      0
+#define WANOPT_NRZI     1
+#define WANOPT_FM0      2
+#define WANOPT_FM1      3
+
+/* link type options */
+#define WANOPT_POINTTOPOINT     0       /* RTS always active */
+#define WANOPT_MULTIDROP        1       /* RTS is active when transmitting */
+
+/* clocking options */
+#define WANOPT_EXTERNAL 0
+#define WANOPT_INTERNAL 1
+
+/* station options */
+#define WANOPT_DTE              0
+#define WANOPT_DCE              1
+#define WANOPT_CPE              0
+#define WANOPT_NODE             1
+#define WANOPT_SECONDARY        0
+#define WANOPT_PRIMARY          1
+
+/* connection options */
+#define WANOPT_PERMANENT        0       /* DTR always active */
+#define WANOPT_SWITCHED         1       /* use DTR to setup link (dial-up) */
+#define WANOPT_ONDEMAND         2       /* activate DTR only before sending */
+
+/* frame relay in-channel signalling */
+#define WANOPT_FR_ANSI          1       /* ANSI T1.617 Annex D */
+#define WANOPT_FR_Q933          2       /* ITU Q.933A */
+#define WANOPT_FR_LMI           3       /* LMI */
+
+/* PPP IP Mode Options */
+#define WANOPT_PPP_STATIC       0
+#define WANOPT_PPP_HOST         1
+#define WANOPT_PPP_PEER         2
+
+/* ASY Mode Options */
+#define WANOPT_ONE              1
+#define WANOPT_TWO              2
+#define WANOPT_ONE_AND_HALF     3
+
+#define WANOPT_NONE     0
+#define WANOPT_ODD      1
+#define WANOPT_EVEN     2
+
+/* CHDLC Protocol Options */
+/* DF Commmented out for now.
+
+#define WANOPT_CHDLC_NO_DCD             IGNORE_DCD_FOR_LINK_STAT
+#define WANOPT_CHDLC_NO_CTS             IGNORE_CTS_FOR_LINK_STAT
+#define WANOPT_CHDLC_NO_KEEPALIVE       IGNORE_KPALV_FOR_LINK_STAT
+*/
+
+/* Port options */
+#define WANOPT_PRI 0
+#define WANOPT_SEC 1
+/* read mode */
+#define WANOPT_INTR     0
+#define WANOPT_POLL     1
+
+
+#define WANOPT_TTY_SYNC  0
+#define WANOPT_TTY_ASYNC 1
+/*----------------------------------------------------------------------------
+ * WAN Link Status Info (for ROUTER_STAT IOCTL).
+ */
+typedef struct wandev_stat
+{
+        unsigned state;         /* link state */
+        unsigned ndev;          /* number of configured interfaces */
+
+        /* link/interface configuration */
+        unsigned connection;    /* permanent/switched/on-demand */
+        unsigned media_type;    /* Frame relay/PPP/X.25/SDLC, etc. */
+        unsigned mtu;           /* max. transmit unit for this device */
+
+        /* physical level statistics */
+        unsigned modem_status;  /* modem status */
+        unsigned rx_frames;     /* received frames count */
+        unsigned rx_overruns;   /* receiver overrun error count */
+        unsigned rx_crc_err;    /* receive CRC error count */
+        unsigned rx_aborts;     /* received aborted frames count */
+        unsigned rx_bad_length; /* unexpetedly long/short frames count */
+        unsigned rx_dropped;    /* frames discarded at device level */
+        unsigned tx_frames;     /* transmitted frames count */
+        unsigned tx_underruns;  /* aborted transmissions (underruns) count */
+        unsigned tx_timeouts;   /* transmission timeouts */
+        unsigned tx_rejects;    /* other transmit errors */
+
+        /* media level statistics */
+        unsigned rx_bad_format; /* frames with invalid format */
+        unsigned rx_bad_addr;   /* frames with invalid media address */
+        unsigned tx_retries;    /* frames re-transmitted */
+        unsigned reserved[16];  /* reserved for future use */
+} wandev_stat_t;
+
+/* 'state' defines */
+enum wan_states
+{
+        WAN_UNCONFIGURED,       /* link/channel is not configured */
+        WAN_DISCONNECTED,       /* link/channel is disconnected */
+        WAN_CONNECTING,         /* connection is in progress */
+        WAN_CONNECTED,          /* link/channel is operational */
+        WAN_LIMIT,              /* for verification only */
+        WAN_DUALPORT,           /* for Dual Port cards */
+        WAN_DISCONNECTING,
+        WAN_FT1_READY           /* FT1 Configurator Ready */
+};
+
+enum {
+        WAN_LOCAL_IP,
+        WAN_POINTOPOINT_IP,
+        WAN_NETMASK_IP,
+        WAN_BROADCAST_IP
+};
+
+/* 'modem_status' masks */
+#define WAN_MODEM_CTS   0x0001  /* CTS line active */
+#define WAN_MODEM_DCD   0x0002  /* DCD line active */
+#define WAN_MODEM_DTR   0x0010  /* DTR line active */
+#define WAN_MODEM_RTS   0x0020  /* RTS line active */
+
+/*----------------------------------------------------------------------------
+ * WAN interface (logical channel) configuration (for ROUTER_IFNEW IOCTL).
+ */
+typedef struct wanif_conf
+{
+        unsigned magic;                 /* magic number */
+        unsigned config_id;             /* configuration identifier */
+        char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
+        char addr[WAN_ADDRESS_SZ+1];    /* media address, ASCIIZ */
+        char usedby[USED_BY_FIELD];     /* used by API or WANPIPE */
+        unsigned idle_timeout;          /* sec, before disconnecting */
+        unsigned hold_timeout;          /* sec, before re-connecting */
+        unsigned cir;                   /* Committed Information Rate fwd,bwd*/
+        unsigned bc;                    /* Committed Burst Size fwd, bwd */
+        unsigned be;                    /* Excess Burst Size fwd, bwd */ 
+        unsigned char enable_IPX;       /* Enable or Disable IPX */
+        unsigned char inarp;            /* Send Inverse ARP requests Y/N */
+        unsigned inarp_interval;        /* sec, between InARP requests */
+        unsigned long network_number;   /* Network Number for IPX */
+        char mc;                        /* Multicast on or off */
+        char local_addr[WAN_ADDRESS_SZ+1];/* local media address, ASCIIZ */
+        unsigned char port;             /* board port */
+        unsigned char protocol;         /* prococol used in this channel (TCPOX25 or X25) */
+        char pap;                       /* PAP enabled or disabled */
+        char chap;                      /* CHAP enabled or disabled */
+        unsigned char userid[511];      /* List of User Id */
+        unsigned char passwd[511];      /* List of passwords */
+        unsigned char sysname[31];      /* Name of the system */
+        unsigned char ignore_dcd;       /* Protocol options: */
+        unsigned char ignore_cts;       /*  Ignore these to determine */
+        unsigned char ignore_keepalive; /*  link status (Yes or No) */
+        unsigned char hdlc_streaming;   /*  Hdlc streaming mode (Y/N) */
+        unsigned keepalive_tx_tmr;      /* transmit keepalive timer */
+        unsigned keepalive_rx_tmr;      /* receive  keepalive timer */
+        unsigned keepalive_err_margin;  /* keepalive_error_tolerance */
+        unsigned slarp_timer;           /* SLARP request timer */
+        unsigned char ttl;              /* Time To Live for UDP security */
+        char interface;                 /* RS-232/V.35, etc. */
+        char clocking;                  /* external/internal */
+        unsigned bps;                   /* data transfer rate */
+        unsigned mtu;                   /* maximum transmit unit size */
+        unsigned char if_down;          /* brind down interface when disconnected */
+        unsigned char gateway;          /* Is this interface a gateway */
+        unsigned char true_if_encoding; /* Set the dev->type to true board protocol */
+
+        unsigned char asy_data_trans;     /* async API options */
+        unsigned char rts_hs_for_receive; /* async Protocol options */
+        unsigned char xon_xoff_hs_for_receive;
+        unsigned char xon_xoff_hs_for_transmit;
+        unsigned char dcd_hs_for_transmit;
+        unsigned char cts_hs_for_transmit;
+        unsigned char async_mode;
+        unsigned tx_bits_per_char;
+        unsigned rx_bits_per_char;
+        unsigned stop_bits;  
+        unsigned char parity;
+        unsigned break_timer;
+        unsigned inter_char_timer;
+        unsigned rx_complete_length;
+        unsigned xon_char;
+        unsigned xoff_char;
+        unsigned char receive_only;     /*  no transmit buffering (Y/N) */
+} wanif_conf_t;
+
+#ifdef  __KERNEL__
+/****** Kernel Interface ****************************************************/
+
+#include <linux/fs.h>           /* support for device drivers */
+#include <linux/proc_fs.h>      /* proc filesystem pragmatics */
+#include <linux/netdevice.h>    /* support for network drivers */
+/*----------------------------------------------------------------------------
+ * WAN device data space.
+ */
+struct wan_device {
+        unsigned magic;                 /* magic number */
+        char* name;                     /* -> WAN device name (ASCIIZ) */
+        void* private;                  /* -> driver private data */
+        unsigned config_id;             /* Configuration ID */
+                                        /****** hardware configuration ******/
+        unsigned ioport;                /* adapter I/O port base #1 */
+        char S514_cpu_no[1];            /* PCI CPU Number */
+        unsigned char S514_slot_no;     /* PCI Slot Number */
+        unsigned long maddr;            /* dual-port memory address */
+        unsigned msize;                 /* dual-port memory size */
+        int irq;                        /* interrupt request level */
+        int dma;                        /* DMA request level */
+        unsigned bps;                   /* data transfer rate */
+        unsigned mtu;                   /* max physical transmit unit size */
+        unsigned udp_port;              /* UDP port for management */
+        unsigned char ttl;              /* Time To Live for UDP security */
+        unsigned enable_tx_int;         /* Transmit Interrupt enabled or not */
+        char interface;                 /* RS-232/V.35, etc. */
+        char clocking;                  /* external/internal */
+        char line_coding;               /* NRZ/NRZI/FM0/FM1, etc. */
+        char station;                   /* DTE/DCE, primary/secondary, etc. */
+        char connection;                /* permanent/switched/on-demand */
+        char signalling;                /* Signalling RS232 or V35 */
+        char read_mode;                 /* read mode: Polling or interrupt */
+        char new_if_cnt;                /* Number of interfaces per wanpipe */ 
+        char del_if_cnt;                /* Number of times del_if() gets called */
+        unsigned char piggyback;        /* Piggibacking a port */
+        unsigned hw_opt[4];             /* other hardware options */
+                                        /****** status and statistics *******/
+        char state;                     /* device state */
+        char api_status;                /* device api status */
+        struct net_device_stats stats;  /* interface statistics */
+        unsigned reserved[16];          /* reserved for future use */
+        unsigned long critical;         /* critical section flag */
+        spinlock_t lock;                /* Support for SMP Locking */
+
+                                        /****** device management methods ***/
+        int (*setup) (struct wan_device *wandev, wandev_conf_t *conf);
+        int (*shutdown) (struct wan_device *wandev);
+        int (*update) (struct wan_device *wandev);
+        int (*ioctl) (struct wan_device *wandev, unsigned cmd,
+                unsigned long arg);
+        int (*new_if)(struct wan_device *wandev, struct net_device *dev,
+                      wanif_conf_t *conf);
+        int (*del_if)(struct wan_device *wandev, struct net_device *dev);
+                                        /****** maintained by the router ****/
+        struct wan_device* next;        /* -> next device */
+        struct net_device* dev;         /* list of network interfaces */
+        unsigned ndev;                  /* number of interfaces */
+        struct proc_dir_entry *dent;    /* proc filesystem entry */
+};
+
+/* Public functions available for device drivers */
+extern int register_wan_device(struct wan_device *wandev);
+extern int unregister_wan_device(char *name);
+unsigned short wanrouter_type_trans(struct sk_buff *skb,
+                                    struct net_device *dev);
+int wanrouter_encapsulate(struct sk_buff *skb, struct net_device *dev,
+                          unsigned short type);
+
+/* Proc interface functions. These must not be called by the drivers! */
+extern int wanrouter_proc_init(void);
+extern void wanrouter_proc_cleanup(void);
+extern int wanrouter_proc_add(struct wan_device *wandev);
+extern int wanrouter_proc_delete(struct wan_device *wandev);
+extern int wanrouter_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
+
+extern void lock_adapter_irq(spinlock_t *lock, unsigned long *smp_flags);
+extern void unlock_adapter_irq(spinlock_t *lock, unsigned long *smp_flags);
+
+
+
+/* Public Data */
+/* list of registered devices */
+extern struct wan_device *wanrouter_router_devlist;
+
+#endif  /* __KERNEL__ */
+#endif  /* _ROUTER_H */
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
new file mode 100644
index 000000000000..88ba0d29f8c8
--- /dev/null
+++ b/include/linux/watchdog.h
@@ -0,0 +1,50 @@
+/*
+ *      Generic watchdog defines. Derived from..
+ *
+ * Berkshire PC Watchdog Defines
+ * by Ken Hollis <khollis@bitgate.com>
+ *
+ */
+
+#ifndef _LINUX_WATCHDOG_H
+#define _LINUX_WATCHDOG_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#define WATCHDOG_IOCTL_BASE     'W'
+
+struct watchdog_info {
+        __u32 options;          /* Options the card/driver supports */
+        __u32 firmware_version; /* Firmware version of the card */
+        __u8  identity[32];     /* Identity of the board */
+};
+
+#define WDIOC_GETSUPPORT        _IOR(WATCHDOG_IOCTL_BASE, 0, struct watchdog_info)
+#define WDIOC_GETSTATUS         _IOR(WATCHDOG_IOCTL_BASE, 1, int)
+#define WDIOC_GETBOOTSTATUS     _IOR(WATCHDOG_IOCTL_BASE, 2, int)
+#define WDIOC_GETTEMP           _IOR(WATCHDOG_IOCTL_BASE, 3, int)
+#define WDIOC_SETOPTIONS        _IOR(WATCHDOG_IOCTL_BASE, 4, int)
+#define WDIOC_KEEPALIVE         _IOR(WATCHDOG_IOCTL_BASE, 5, int)
+#define WDIOC_SETTIMEOUT        _IOWR(WATCHDOG_IOCTL_BASE, 6, int)
+#define WDIOC_GETTIMEOUT        _IOR(WATCHDOG_IOCTL_BASE, 7, int)
+
+#define WDIOF_UNKNOWN           -1      /* Unknown flag error */
+#define WDIOS_UNKNOWN           -1      /* Unknown status error */
+
+#define WDIOF_OVERHEAT          0x0001  /* Reset due to CPU overheat */
+#define WDIOF_FANFAULT          0x0002  /* Fan failed */
+#define WDIOF_EXTERN1           0x0004  /* External relay 1 */
+#define WDIOF_EXTERN2           0x0008  /* External relay 2 */
+#define WDIOF_POWERUNDER        0x0010  /* Power bad/power fault */
+#define WDIOF_CARDRESET         0x0020  /* Card previously reset the CPU */
+#define WDIOF_POWEROVER         0x0040  /* Power over voltage */
+#define WDIOF_SETTIMEOUT        0x0080  /* Set timeout (in seconds) */
+#define WDIOF_MAGICCLOSE        0x0100  /* Supports magic close char */
+#define WDIOF_KEEPALIVEPING     0x8000  /* Keep alive ping reply */
+
+#define WDIOS_DISABLECARD       0x0001  /* Turn off the watchdog timer */
+#define WDIOS_ENABLECARD        0x0002  /* Turn on the watchdog timer */
+#define WDIOS_TEMPPANIC         0x0004  /* Kernel panic on temperature trip */
+
+#endif  /* ifndef _LINUX_WATCHDOG_H */
diff --git a/include/linux/wavefront.h b/include/linux/wavefront.h
new file mode 100644
index 000000000000..61bd0fd35240
--- /dev/null
+++ b/include/linux/wavefront.h
@@ -0,0 +1,675 @@
+#ifndef __wavefront_h__
+#define __wavefront_h__
+
+/* WaveFront header file.
+ *   
+ * Copyright (C) by Paul Barton-Davis 1998
+ *
+ * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
+ * Version 2 (June 1991). See the "COPYING" file distributed with this software
+ * for more info.  
+ */
+
+#if (!defined(__GNUC__) && !defined(__GNUG__))
+
+     You will not be able to compile this file correctly without gcc, because
+     it is necessary to pack the "wavefront_alias" structure to a size
+     of 22 bytes, corresponding to 16-bit alignment (as would have been
+     the case on the original platform, MS-DOS). If this is not done,
+     then WavePatch-format files cannot be read/written correctly.
+     The method used to do this here ("__attribute__((packed)") is
+     completely compiler dependent.
+     
+     All other wavefront_* types end up aligned to 32 bit values and
+     still have the same (correct) size.
+
+#else
+
+     /* However, note that as of G++ 2.7.3.2, g++ was unable to
+        correctly parse *type* __attribute__ tags. It will do the
+        right thing if we use the "packed" attribute on each struct
+        member, which has the same semantics anyway. 
+     */
+
+#endif /* __GNUC__ */
+
+/***************************** WARNING ********************************
+  PLEASE DO NOT MODIFY THIS FILE IN ANY WAY THAT AFFECTS ITS ABILITY TO 
+  BE USED WITH EITHER C *OR* C++.
+ **********************************************************************/
+
+#ifndef NUM_MIDIKEYS 
+#define NUM_MIDIKEYS 128
+#endif  /* NUM_MIDIKEYS */
+
+#ifndef NUM_MIDICHANNELS
+#define NUM_MIDICHANNELS 16
+#endif  /* NUM_MIDICHANNELS */
+
+/* These are very useful/important. the original wavefront interface
+   was developed on a 16 bit system, where sizeof(int) = 2
+   bytes. Defining things like this makes the code much more portable, and
+   easier to understand without having to toggle back and forth
+   between a 16-bit view of the world and a 32-bit one. 
+ */   
+
+typedef short INT16;
+typedef unsigned short UINT16;
+typedef int INT32;
+typedef unsigned int UINT32;
+typedef char CHAR8;
+typedef unsigned char UCHAR8;
+
+/* Pseudo-commands not part of the WaveFront command set.
+   These are used for various driver controls and direct
+   hardware control.
+ */
+
+#define WFC_DEBUG_DRIVER                0
+#define WFC_FX_IOCTL                    1
+#define WFC_PATCH_STATUS                2
+#define WFC_PROGRAM_STATUS              3
+#define WFC_SAMPLE_STATUS               4
+#define WFC_DISABLE_INTERRUPTS          5
+#define WFC_ENABLE_INTERRUPTS           6
+#define WFC_INTERRUPT_STATUS            7
+#define WFC_ROMSAMPLES_RDONLY           8
+#define WFC_IDENTIFY_SLOT_TYPE          9
+
+/* Wavefront synth commands
+ */
+
+#define WFC_DOWNLOAD_SAMPLE             0x80
+#define WFC_DOWNLOAD_BLOCK              0x81
+#define WFC_DOWNLOAD_MULTISAMPLE        0x82
+#define WFC_DOWNLOAD_SAMPLE_ALIAS       0x83
+#define WFC_DELETE_SAMPLE               0x84
+#define WFC_REPORT_FREE_MEMORY          0x85
+#define WFC_DOWNLOAD_PATCH              0x86
+#define WFC_DOWNLOAD_PROGRAM            0x87
+#define WFC_SET_SYNTHVOL                0x89
+#define WFC_SET_NVOICES                 0x8B
+#define WFC_DOWNLOAD_DRUM               0x90
+#define WFC_GET_SYNTHVOL                0x92
+#define WFC_GET_NVOICES                 0x94
+#define WFC_DISABLE_CHANNEL             0x9A
+#define WFC_ENABLE_CHANNEL              0x9B
+#define WFC_MISYNTH_OFF                 0x9D
+#define WFC_MISYNTH_ON                  0x9E
+#define WFC_FIRMWARE_VERSION            0x9F
+#define WFC_GET_NSAMPLES                0xA0
+#define WFC_DISABLE_DRUM_PROGRAM        0xA2
+#define WFC_UPLOAD_PATCH                0xA3
+#define WFC_UPLOAD_PROGRAM              0xA4
+#define WFC_SET_TUNING                  0xA6
+#define WFC_GET_TUNING                  0xA7
+#define WFC_VMIDI_ON                    0xA8
+#define WFC_VMIDI_OFF                   0xA9
+#define WFC_MIDI_STATUS                 0xAA
+#define WFC_GET_CHANNEL_STATUS          0xAB
+#define WFC_DOWNLOAD_SAMPLE_HEADER      0xAC
+#define WFC_UPLOAD_SAMPLE_HEADER        0xAD
+#define WFC_UPLOAD_MULTISAMPLE          0xAE
+#define WFC_UPLOAD_SAMPLE_ALIAS         0xAF
+#define WFC_IDENTIFY_SAMPLE_TYPE        0xB0
+#define WFC_DOWNLOAD_EDRUM_PROGRAM      0xB1
+#define WFC_UPLOAD_EDRUM_PROGRAM        0xB2
+#define WFC_SET_EDRUM_CHANNEL           0xB3
+#define WFC_INSTOUT_LEVELS              0xB4
+#define WFC_PEAKOUT_LEVELS              0xB5
+#define WFC_REPORT_CHANNEL_PROGRAMS     0xB6
+#define WFC_HARDWARE_VERSION            0xCF
+#define WFC_UPLOAD_SAMPLE_PARAMS        0xD7
+#define WFC_DOWNLOAD_OS                 0xF1
+#define WFC_NOOP                        0xFF
+
+#define WF_MAX_SAMPLE   512
+#define WF_MAX_PATCH    256
+#define WF_MAX_PROGRAM  128
+
+#define WF_SECTION_MAX  44   /* longest OS section length */
+
+/* # of bytes we send to the board when sending it various kinds of
+   substantive data, such as samples, patches and programs.
+*/
+
+#define WF_PROGRAM_BYTES 32
+#define WF_PATCH_BYTES 132
+#define WF_SAMPLE_BYTES 27
+#define WF_SAMPLE_HDR_BYTES 25
+#define WF_ALIAS_BYTES 25
+#define WF_DRUM_BYTES 9
+#define WF_MSAMPLE_BYTES 259 /* (MIDI_KEYS * 2) + 3 */
+
+#define WF_ACK     0x80
+#define WF_DMA_ACK 0x81
+
+/* OR-values for MIDI status bits */
+
+#define WF_MIDI_VIRTUAL_ENABLED 0x1
+#define WF_MIDI_VIRTUAL_IS_EXTERNAL 0x2
+#define WF_MIDI_IN_TO_SYNTH_DISABLED 0x4
+
+/* slot indexes for struct address_info: makes code a little more mnemonic */
+
+#define WF_SYNTH_SLOT         0
+#define WF_INTERNAL_MIDI_SLOT 1
+#define WF_EXTERNAL_MIDI_SLOT 2
+
+/* Magic MIDI bytes used to switch I/O streams on the ICS2115 MPU401
+   emulation. Note these NEVER show up in output from the device and
+   should NEVER be used in input unless Virtual MIDI mode has been 
+   disabled. If they do show up as input, the results are unpredictable.
+*/
+
+#define WF_EXTERNAL_SWITCH  0xFD
+#define WF_INTERNAL_SWITCH  0xF9
+
+/* Debugging flags */
+
+#define WF_DEBUG_CMD 0x1
+#define WF_DEBUG_DATA 0x2
+#define WF_DEBUG_LOAD_PATCH 0x4
+#define WF_DEBUG_IO 0x8
+
+/* WavePatch file format stuff */
+
+#define WF_WAVEPATCH_VERSION     120;  /*  Current version number (1.2)  */
+#define WF_MAX_COMMENT           64    /*  Comment length */
+#define WF_NUM_LAYERS            4
+#define WF_NAME_LENGTH           32
+#define WF_SOURCE_LENGTH         260
+
+#define BankFileID     "Bank"
+#define DrumkitFileID  "DrumKit"
+#define ProgramFileID  "Program"
+
+struct wf_envelope
+{
+    UCHAR8 attack_time:7;
+    UCHAR8 Unused1:1;
+
+    UCHAR8 decay1_time:7;
+    UCHAR8 Unused2:1;
+
+    UCHAR8 decay2_time:7;
+    UCHAR8 Unused3:1;
+
+    UCHAR8 sustain_time:7;
+    UCHAR8 Unused4:1;
+
+    UCHAR8 release_time:7;
+    UCHAR8 Unused5:1;
+
+    UCHAR8 release2_time:7;
+    UCHAR8 Unused6:1;
+
+    CHAR8 attack_level;
+    CHAR8 decay1_level;
+    CHAR8 decay2_level;
+    CHAR8 sustain_level;
+    CHAR8 release_level;
+
+    UCHAR8 attack_velocity:7;
+    UCHAR8 Unused7:1;
+
+    UCHAR8 volume_velocity:7;
+    UCHAR8 Unused8:1;
+
+    UCHAR8 keyboard_scaling:7;
+    UCHAR8 Unused9:1;
+};
+typedef struct wf_envelope wavefront_envelope;
+
+struct wf_lfo
+{
+    UCHAR8 sample_number;
+
+    UCHAR8 frequency:7;
+    UCHAR8 Unused1:1;
+
+    UCHAR8 am_src:4;
+    UCHAR8 fm_src:4;
+
+    CHAR8 fm_amount;
+    CHAR8 am_amount;
+    CHAR8 start_level;
+    CHAR8 end_level;
+
+    UCHAR8 ramp_delay:7;
+    UCHAR8 wave_restart:1; /* for LFO2 only */
+
+    UCHAR8 ramp_time:7;
+    UCHAR8 Unused2:1;
+};
+typedef struct wf_lfo wavefront_lfo;
+
+struct wf_patch
+{
+    INT16  frequency_bias;         /*  ** THIS IS IN MOTOROLA FORMAT!! ** */
+
+    UCHAR8 amplitude_bias:7;
+    UCHAR8 Unused1:1;
+
+    UCHAR8 portamento:7;
+    UCHAR8 Unused2:1;
+
+    UCHAR8 sample_number;
+
+    UCHAR8 pitch_bend:4;
+    UCHAR8 sample_msb:1;
+    UCHAR8 Unused3:3;
+
+    UCHAR8 mono:1;
+    UCHAR8 retrigger:1;
+    UCHAR8 nohold:1;
+    UCHAR8 restart:1;
+    UCHAR8 filterconfig:2; /* SDK says "not used" */
+    UCHAR8 reuse:1;
+    UCHAR8 reset_lfo:1;    
+
+    UCHAR8 fm_src2:4;
+    UCHAR8 fm_src1:4;   
+
+    CHAR8 fm_amount1;
+    CHAR8 fm_amount2;
+
+    UCHAR8 am_src:4;
+    UCHAR8 Unused4:4;
+
+    CHAR8 am_amount;
+
+    UCHAR8 fc1_mode:4;
+    UCHAR8 fc2_mode:4;
+
+    CHAR8 fc1_mod_amount;
+    CHAR8 fc1_keyboard_scaling;
+    CHAR8 fc1_bias;
+    CHAR8 fc2_mod_amount;
+    CHAR8 fc2_keyboard_scaling;
+    CHAR8 fc2_bias;
+
+    UCHAR8 randomizer:7;
+    UCHAR8 Unused5:1;
+
+    struct wf_envelope envelope1;
+    struct wf_envelope envelope2;
+    struct wf_lfo lfo1;
+    struct wf_lfo lfo2;
+};
+typedef struct wf_patch wavefront_patch;
+
+struct wf_layer
+{
+    UCHAR8 patch_number;
+
+    UCHAR8 mix_level:7;
+    UCHAR8 mute:1;
+
+    UCHAR8 split_point:7;
+    UCHAR8 play_below:1;
+
+    UCHAR8 pan_mod_src:2;
+    UCHAR8 pan_or_mod:1;
+    UCHAR8 pan:4;
+    UCHAR8 split_type:1;
+};
+typedef struct wf_layer wavefront_layer;
+
+struct wf_program
+{
+    struct wf_layer layer[WF_NUM_LAYERS];
+};
+typedef struct wf_program wavefront_program;
+
+struct wf_sample_offset
+{
+    INT32 Fraction:4;
+    INT32 Integer:20;
+    INT32 Unused:8;
+};
+typedef struct wf_sample_offset wavefront_sample_offset;          
+     
+/* Sample slot types */
+
+#define WF_ST_SAMPLE      0
+#define WF_ST_MULTISAMPLE 1
+#define WF_ST_ALIAS       2
+#define WF_ST_EMPTY       3
+
+/* pseudo's */
+
+#define WF_ST_DRUM        4
+#define WF_ST_PROGRAM     5
+#define WF_ST_PATCH       6
+#define WF_ST_SAMPLEHDR   7
+
+#define WF_ST_MASK        0xf
+
+/* Flags for slot status. These occupy the upper bits of the same byte
+   as a sample type.
+*/
+
+#define WF_SLOT_USED      0x80   /* XXX don't rely on this being accurate */
+#define WF_SLOT_FILLED    0x40
+#define WF_SLOT_ROM       0x20
+
+#define WF_SLOT_MASK      0xf0
+
+/* channel constants */
+
+#define WF_CH_MONO  0
+#define WF_CH_LEFT  1
+#define WF_CH_RIGHT 2
+
+/* Sample formats */
+
+#define LINEAR_16BIT 0
+#define WHITE_NOISE  1
+#define LINEAR_8BIT  2
+#define MULAW_8BIT   3
+
+#define WF_SAMPLE_IS_8BIT(smpl) ((smpl)->SampleResolution&2)
+
+
+/* 
+
+  Because most/all of the sample data we pass in via pointers has
+  never been copied (just mmap-ed into user space straight from the
+  disk), it would be nice to allow handling of multi-channel sample
+  data without forcing user-level extraction of the relevant bytes.
+  
+  So, we need a way of specifying which channel to use (the WaveFront
+  only handles mono samples in a given slot), and the only way to do
+  this without using some struct other than wavefront_sample as the
+  interface is the awful hack of using the unused bits in a
+  wavefront_sample:
+  
+  Val      Meaning
+  ---      -------
+  0        no channel selection (use channel 1, sample is MONO)
+  1        use first channel, and skip one
+  2        use second channel, and skip one
+  3        use third channel, and skip two
+  4        use fourth channel, skip three
+  5        use fifth channel, skip four
+  6        use six channel, skip five
+
+
+  This can handle up to 4 channels, and anyone downloading >4 channels
+  of sample data just to select one of them needs to find some tools
+  like sox ...
+
+  NOTE: values 0, 1 and 2 correspond to WF_CH_* above. This is 
+  important.
+
+*/
+
+#define WF_SET_CHANNEL(samp,chn) \
+ (samp)->Unused1 = chn & 0x1; \
+ (samp)->Unused2 = chn & 0x2; \
+ (samp)->Unused3 = chn & 0x4 
+  
+#define WF_GET_CHANNEL(samp) \
+  (((samp)->Unused3 << 2)|((samp)->Unused2<<1)|(samp)->Unused1)
+  
+typedef struct wf_sample {
+    struct wf_sample_offset sampleStartOffset;
+    struct wf_sample_offset loopStartOffset;
+    struct wf_sample_offset loopEndOffset;
+    struct wf_sample_offset sampleEndOffset;
+    INT16 FrequencyBias;
+    UCHAR8 SampleResolution:2;  /* sample_format */
+    UCHAR8 Unused1:1;
+    UCHAR8 Loop:1;
+    UCHAR8 Bidirectional:1;
+    UCHAR8 Unused2:1;
+    UCHAR8 Reverse:1;
+    UCHAR8 Unused3:1;
+} wavefront_sample;
+
+typedef struct wf_multisample {
+    INT16 NumberOfSamples;   /* log2 of the number of samples */
+    INT16 SampleNumber[NUM_MIDIKEYS];
+} wavefront_multisample;
+
+typedef struct wf_alias {
+    INT16 OriginalSample __attribute__ ((packed));
+
+    struct wf_sample_offset sampleStartOffset __attribute__ ((packed));
+    struct wf_sample_offset loopStartOffset __attribute__ ((packed));
+    struct wf_sample_offset sampleEndOffset __attribute__ ((packed));
+    struct wf_sample_offset loopEndOffset __attribute__ ((packed));
+
+    INT16  FrequencyBias __attribute__ ((packed));
+
+    UCHAR8 SampleResolution:2  __attribute__ ((packed));
+    UCHAR8 Unused1:1  __attribute__ ((packed));
+    UCHAR8 Loop:1 __attribute__ ((packed));
+    UCHAR8 Bidirectional:1  __attribute__ ((packed));
+    UCHAR8 Unused2:1 __attribute__ ((packed));
+    UCHAR8 Reverse:1 __attribute__ ((packed));
+    UCHAR8 Unused3:1 __attribute__ ((packed)); 
+    
+    /* This structure is meant to be padded only to 16 bits on their
+       original. Of course, whoever wrote their documentation didn't
+       realize that sizeof(struct) can be >=
+       sum(sizeof(struct-fields)) and so thought that giving a C level
+       description of the structs used in WavePatch files was
+       sufficient. I suppose it was, as long as you remember the 
+       standard 16->32 bit issues.
+    */
+
+    UCHAR8 sixteen_bit_padding __attribute__ ((packed));
+} wavefront_alias;
+
+typedef struct wf_drum {
+    UCHAR8 PatchNumber;
+    UCHAR8 MixLevel:7;
+    UCHAR8 Unmute:1;
+    UCHAR8 Group:4;
+    UCHAR8 Unused1:4;
+    UCHAR8 PanModSource:2;
+    UCHAR8 PanModulated:1;
+    UCHAR8 PanAmount:4;
+    UCHAR8 Unused2:1;
+} wavefront_drum;
+
+typedef struct wf_drumkit {
+    struct wf_drum drum[NUM_MIDIKEYS];
+} wavefront_drumkit;
+
+typedef struct wf_channel_programs {
+    UCHAR8 Program[NUM_MIDICHANNELS];
+} wavefront_channel_programs;
+
+/* How to get MIDI channel status from the data returned by
+   a WFC_GET_CHANNEL_STATUS command (a struct wf_channel_programs)
+*/
+
+#define WF_CHANNEL_STATUS(ch,wcp) (wcp)[(ch/7)] & (1<<((ch)%7))
+
+typedef union wf_any {
+    wavefront_sample s;
+    wavefront_multisample ms;
+    wavefront_alias a;
+    wavefront_program pr;
+    wavefront_patch p;
+    wavefront_drum d;
+} wavefront_any;
+
+/* Hannu Solvainen hoped that his "patch_info" struct in soundcard.h
+   might work for other wave-table based patch loading situations.
+   Alas, his fears were correct. The WaveFront doesn't even come with
+   just "patches", but several different kind of structures that
+   control the sound generation process.
+ */
+
+typedef struct wf_patch_info {
+    
+    /* the first two fields are used by the OSS "patch loading" interface
+       only, and are unused by the current user-level library.
+    */
+
+    INT16   key;               /* Use WAVEFRONT_PATCH here */
+    UINT16  devno;             /* fill in when sending */
+    UCHAR8  subkey;            /* WF_ST_{SAMPLE,ALIAS,etc.} */
+
+#define WAVEFRONT_FIND_FREE_SAMPLE_SLOT 999
+
+    UINT16  number;            /* patch/sample/prog number */
+
+    UINT32  size;              /* size of any data included in 
+                                  one of the fields in `hdrptr', or
+                                  as `dataptr'.
+
+                                  NOTE: for actual samples, this is
+                                  the size of the *SELECTED CHANNEL*
+                                  even if more data is actually available.
+                                  
+                                  So, a stereo sample (2 channels) of
+                                  6000 bytes total has `size' = 3000.
+
+                                  See the macros and comments for
+                                  WF_{GET,SET}_CHANNEL above.
+
+                               */
+    wavefront_any __user *hdrptr;      /* user-space ptr to hdr bytes */
+    UINT16 __user *dataptr;            /* actual sample data */
+
+    wavefront_any hdr;          /* kernel-space copy of hdr bytes */         
+} wavefront_patch_info;
+
+/* The maximum number of bytes we will ever move to or from user space
+   in response to a WFC_* command.  This obviously doesn't cover
+   actual sample data.
+*/
+
+#define WF_MAX_READ sizeof(wavefront_multisample)
+#define WF_MAX_WRITE sizeof(wavefront_multisample)
+
+/*
+   This allows us to execute any WF command except the download/upload
+   ones, which are handled differently due to copyin/copyout issues as
+   well as data-nybbling to/from the card.
+ */
+
+typedef struct wavefront_control {
+    int cmd;                           /* WFC_* */
+    char status;                       /* return status to user-space */
+    unsigned char rbuf[WF_MAX_READ];   /* bytes read from card */
+    unsigned char wbuf[WF_MAX_WRITE];  /* bytes written to card */
+} wavefront_control;
+
+#define WFCTL_WFCMD    0x1
+#define WFCTL_LOAD_SPP 0x2
+
+/* Modulator table */
+
+#define WF_MOD_LFO1      0
+#define WF_MOD_LFO2      1
+#define WF_MOD_ENV1      2
+#define WF_MOD_ENV2      3
+#define WF_MOD_KEYBOARD  4
+#define WF_MOD_LOGKEY    5
+#define WF_MOD_VELOCITY  6
+#define WF_MOD_LOGVEL    7
+#define WF_MOD_RANDOM    8
+#define WF_MOD_PRESSURE  9
+#define WF_MOD_MOD_WHEEL 10
+#define WF_MOD_1         WF_MOD_MOD_WHEEL 
+#define WF_MOD_BREATH    11
+#define WF_MOD_2         WF_MOD_BREATH
+#define WF_MOD_FOOT      12
+#define WF_MOD_4         WF_MOD_FOOT
+#define WF_MOD_VOLUME    13
+#define WF_MOD_7         WF_MOD_VOLUME
+#define WF_MOD_PAN       14
+#define WF_MOD_10        WF_MOD_PAN
+#define WF_MOD_EXPR      15
+#define WF_MOD_11        WF_MOD_EXPR
+
+/* FX-related material */
+
+typedef struct wf_fx_info {
+    int request;             /* see list below */
+    int data[4];             /* we don't need much */
+} wavefront_fx_info;
+
+/* support for each of these will be forthcoming once I or someone 
+   else has figured out which of the addresses on page 6 and page 7 of 
+   the YSS225 control each parameter. Incidentally, these come from
+   the Windows driver interface, but again, Turtle Beach didn't
+   document the API to use them.
+*/
+
+#define WFFX_SETOUTGAIN                 0
+#define WFFX_SETSTEREOOUTGAIN           1
+#define WFFX_SETREVERBIN1GAIN           2
+#define WFFX_SETREVERBIN2GAIN           3
+#define WFFX_SETREVERBIN3GAIN           4
+#define WFFX_SETCHORUSINPORT            5
+#define WFFX_SETREVERBIN1PORT           6
+#define WFFX_SETREVERBIN2PORT           7
+#define WFFX_SETREVERBIN3PORT           8
+#define WFFX_SETEFFECTPORT              9
+#define WFFX_SETAUXPORT                 10
+#define WFFX_SETREVERBTYPE              11
+#define WFFX_SETREVERBDELAY             12
+#define WFFX_SETCHORUSLFO               13
+#define WFFX_SETCHORUSPMD               14
+#define WFFX_SETCHORUSAMD               15
+#define WFFX_SETEFFECT                  16
+#define WFFX_SETBASEALL                 17
+#define WFFX_SETREVERBALL               18
+#define WFFX_SETCHORUSALL               20
+#define WFFX_SETREVERBDEF               22
+#define WFFX_SETCHORUSDEF               23
+#define WFFX_DELAYSETINGAIN             24
+#define WFFX_DELAYSETFBGAIN             25
+#define WFFX_DELAYSETFBLPF              26
+#define WFFX_DELAYSETGAIN               27
+#define WFFX_DELAYSETTIME               28
+#define WFFX_DELAYSETFBTIME             29
+#define WFFX_DELAYSETALL                30
+#define WFFX_DELAYSETDEF                32
+#define WFFX_SDELAYSETINGAIN            33
+#define WFFX_SDELAYSETFBGAIN            34
+#define WFFX_SDELAYSETFBLPF             35
+#define WFFX_SDELAYSETGAIN              36
+#define WFFX_SDELAYSETTIME              37
+#define WFFX_SDELAYSETFBTIME            38
+#define WFFX_SDELAYSETALL               39
+#define WFFX_SDELAYSETDEF               41
+#define WFFX_DEQSETINGAIN               42
+#define WFFX_DEQSETFILTER               43
+#define WFFX_DEQSETALL                  44
+#define WFFX_DEQSETDEF                  46
+#define WFFX_MUTE                       47
+#define WFFX_FLANGESETBALANCE           48      
+#define WFFX_FLANGESETDELAY             49
+#define WFFX_FLANGESETDWFFX_TH          50
+#define WFFX_FLANGESETFBGAIN            51
+#define WFFX_FLANGESETINGAIN            52
+#define WFFX_FLANGESETLFO               53
+#define WFFX_FLANGESETALL               54
+#define WFFX_FLANGESETDEF               56
+#define WFFX_PITCHSETSHIFT              57
+#define WFFX_PITCHSETBALANCE            58
+#define WFFX_PITCHSETALL                59
+#define WFFX_PITCHSETDEF                61
+#define WFFX_SRSSETINGAIN               62
+#define WFFX_SRSSETSPACE                63
+#define WFFX_SRSSETCENTER               64
+#define WFFX_SRSSETGAIN                 65
+#define WFFX_SRSSETMODE                 66
+#define WFFX_SRSSETDEF                  68
+
+/* Allow direct user-space control over FX memory/coefficient data.
+   In theory this could be used to download the FX microprogram,
+   but it would be a little slower, and involve some weird code.
+ */
+
+#define WFFX_MEMSET              69
+
+#endif /* __wavefront_h__ */
diff --git a/include/linux/wireless.h b/include/linux/wireless.h
new file mode 100644
index 000000000000..2f51f2b6562e
--- /dev/null
+++ b/include/linux/wireless.h
@@ -0,0 +1,773 @@
+/*
+ * This file define a set of standard wireless extensions
+ *
+ * Version :    17      21.6.04
+ *
+ * Authors :    Jean Tourrilhes - HPL - <jt@hpl.hp.com>
+ * Copyright (c) 1997-2004 Jean Tourrilhes, All Rights Reserved.
+ */
+
+#ifndef _LINUX_WIRELESS_H
+#define _LINUX_WIRELESS_H
+
+/************************** DOCUMENTATION **************************/
+/*
+ * Initial APIs (1996 -> onward) :
+ * -----------------------------
+ * Basically, the wireless extensions are for now a set of standard ioctl
+ * call + /proc/net/wireless
+ *
+ * The entry /proc/net/wireless give statistics and information on the
+ * driver.
+ * This is better than having each driver having its entry because
+ * its centralised and we may remove the driver module safely.
+ *
+ * Ioctl are used to configure the driver and issue commands.  This is
+ * better than command line options of insmod because we may want to
+ * change dynamically (while the driver is running) some parameters.
+ *
+ * The ioctl mechanimsm are copied from standard devices ioctl.
+ * We have the list of command plus a structure descibing the
+ * data exchanged...
+ * Note that to add these ioctl, I was obliged to modify :
+ *      # net/core/dev.c (two place + add include)
+ *      # net/ipv4/af_inet.c (one place + add include)
+ *
+ * /proc/net/wireless is a copy of /proc/net/dev.
+ * We have a structure for data passed from the driver to /proc/net/wireless
+ * Too add this, I've modified :
+ *      # net/core/dev.c (two other places)
+ *      # include/linux/netdevice.h (one place)
+ *      # include/linux/proc_fs.h (one place)
+ *
+ * New driver API (2002 -> onward) :
+ * -------------------------------
+ * This file is only concerned with the user space API and common definitions.
+ * The new driver API is defined and documented in :
+ *      # include/net/iw_handler.h
+ *
+ * Note as well that /proc/net/wireless implementation has now moved in :
+ *      # net/core/wireless.c
+ *
+ * Wireless Events (2002 -> onward) :
+ * --------------------------------
+ * Events are defined at the end of this file, and implemented in :
+ *      # net/core/wireless.c
+ *
+ * Other comments :
+ * --------------
+ * Do not add here things that are redundant with other mechanisms
+ * (drivers init, ifconfig, /proc/net/dev, ...) and with are not
+ * wireless specific.
+ *
+ * These wireless extensions are not magic : each driver has to provide
+ * support for them...
+ *
+ * IMPORTANT NOTE : As everything in the kernel, this is very much a
+ * work in progress. Contact me if you have ideas of improvements...
+ */
+
+/***************************** INCLUDES *****************************/
+
+/* To minimise problems in user space, I might remove those headers
+ * at some point. Jean II */
+#include <linux/types.h>                /* for "caddr_t" et al          */
+#include <linux/socket.h>               /* for "struct sockaddr" et al  */
+#include <linux/if.h>                   /* for IFNAMSIZ and co... */
+
+/***************************** VERSION *****************************/
+/*
+ * This constant is used to know the availability of the wireless
+ * extensions and to know which version of wireless extensions it is
+ * (there is some stuff that will be added in the future...)
+ * I just plan to increment with each new version.
+ */
+#define WIRELESS_EXT    17
+
+/*
+ * Changes :
+ *
+ * V2 to V3
+ * --------
+ *      Alan Cox start some incompatibles changes. I've integrated a bit more.
+ *      - Encryption renamed to Encode to avoid US regulation problems
+ *      - Frequency changed from float to struct to avoid problems on old 386
+ *
+ * V3 to V4
+ * --------
+ *      - Add sensitivity
+ *
+ * V4 to V5
+ * --------
+ *      - Missing encoding definitions in range
+ *      - Access points stuff
+ *
+ * V5 to V6
+ * --------
+ *      - 802.11 support (ESSID ioctls)
+ *
+ * V6 to V7
+ * --------
+ *      - define IW_ESSID_MAX_SIZE and IW_MAX_AP
+ *
+ * V7 to V8
+ * --------
+ *      - Changed my e-mail address
+ *      - More 802.11 support (nickname, rate, rts, frag)
+ *      - List index in frequencies
+ *
+ * V8 to V9
+ * --------
+ *      - Support for 'mode of operation' (ad-hoc, managed...)
+ *      - Support for unicast and multicast power saving
+ *      - Change encoding to support larger tokens (>64 bits)
+ *      - Updated iw_params (disable, flags) and use it for NWID
+ *      - Extracted iw_point from iwreq for clarity
+ *
+ * V9 to V10
+ * ---------
+ *      - Add PM capability to range structure
+ *      - Add PM modifier : MAX/MIN/RELATIVE
+ *      - Add encoding option : IW_ENCODE_NOKEY
+ *      - Add TxPower ioctls (work like TxRate)
+ *
+ * V10 to V11
+ * ----------
+ *      - Add WE version in range (help backward/forward compatibility)
+ *      - Add retry ioctls (work like PM)
+ *
+ * V11 to V12
+ * ----------
+ *      - Add SIOCSIWSTATS to get /proc/net/wireless programatically
+ *      - Add DEV PRIVATE IOCTL to avoid collisions in SIOCDEVPRIVATE space
+ *      - Add new statistics (frag, retry, beacon)
+ *      - Add average quality (for user space calibration)
+ *
+ * V12 to V13
+ * ----------
+ *      - Document creation of new driver API.
+ *      - Extract union iwreq_data from struct iwreq (for new driver API).
+ *      - Rename SIOCSIWNAME as SIOCSIWCOMMIT
+ *
+ * V13 to V14
+ * ----------
+ *      - Wireless Events support : define struct iw_event
+ *      - Define additional specific event numbers
+ *      - Add "addr" and "param" fields in union iwreq_data
+ *      - AP scanning stuff (SIOCSIWSCAN and friends)
+ *
+ * V14 to V15
+ * ----------
+ *      - Add IW_PRIV_TYPE_ADDR for struct sockaddr private arg
+ *      - Make struct iw_freq signed (both m & e), add explicit padding
+ *      - Add IWEVCUSTOM for driver specific event/scanning token
+ *      - Add IW_MAX_GET_SPY for driver returning a lot of addresses
+ *      - Add IW_TXPOW_RANGE for range of Tx Powers
+ *      - Add IWEVREGISTERED & IWEVEXPIRED events for Access Points
+ *      - Add IW_MODE_MONITOR for passive monitor
+ *
+ * V15 to V16
+ * ----------
+ *      - Increase the number of bitrates in iw_range to 32 (for 802.11g)
+ *      - Increase the number of frequencies in iw_range to 32 (for 802.11b+a)
+ *      - Reshuffle struct iw_range for increases, add filler
+ *      - Increase IW_MAX_AP to 64 for driver returning a lot of addresses
+ *      - Remove IW_MAX_GET_SPY because conflict with enhanced spy support
+ *      - Add SIOCSIWTHRSPY/SIOCGIWTHRSPY and "struct iw_thrspy"
+ *      - Add IW_ENCODE_TEMP and iw_range->encoding_login_index
+ *
+ * V16 to V17
+ * ----------
+ *      - Add flags to frequency -> auto/fixed
+ *      - Document (struct iw_quality *)->updated, add new flags (INVALID)
+ *      - Wireless Event capability in struct iw_range
+ *      - Add support for relative TxPower (yick !)
+ */
+
+/**************************** CONSTANTS ****************************/
+
+/* -------------------------- IOCTL LIST -------------------------- */
+
+/* Wireless Identification */
+#define SIOCSIWCOMMIT   0x8B00          /* Commit pending changes to driver */
+#define SIOCGIWNAME     0x8B01          /* get name == wireless protocol */
+/* SIOCGIWNAME is used to verify the presence of Wireless Extensions.
+ * Common values : "IEEE 802.11-DS", "IEEE 802.11-FH", "IEEE 802.11b"...
+ * Don't put the name of your driver there, it's useless. */
+
+/* Basic operations */
+#define SIOCSIWNWID     0x8B02          /* set network id (pre-802.11) */
+#define SIOCGIWNWID     0x8B03          /* get network id (the cell) */
+#define SIOCSIWFREQ     0x8B04          /* set channel/frequency (Hz) */
+#define SIOCGIWFREQ     0x8B05          /* get channel/frequency (Hz) */
+#define SIOCSIWMODE     0x8B06          /* set operation mode */
+#define SIOCGIWMODE     0x8B07          /* get operation mode */
+#define SIOCSIWSENS     0x8B08          /* set sensitivity (dBm) */
+#define SIOCGIWSENS     0x8B09          /* get sensitivity (dBm) */
+
+/* Informative stuff */
+#define SIOCSIWRANGE    0x8B0A          /* Unused */
+#define SIOCGIWRANGE    0x8B0B          /* Get range of parameters */
+#define SIOCSIWPRIV     0x8B0C          /* Unused */
+#define SIOCGIWPRIV     0x8B0D          /* get private ioctl interface info */
+#define SIOCSIWSTATS    0x8B0E          /* Unused */
+#define SIOCGIWSTATS    0x8B0F          /* Get /proc/net/wireless stats */
+/* SIOCGIWSTATS is strictly used between user space and the kernel, and
+ * is never passed to the driver (i.e. the driver will never see it). */
+
+/* Spy support (statistics per MAC address - used for Mobile IP support) */
+#define SIOCSIWSPY      0x8B10          /* set spy addresses */
+#define SIOCGIWSPY      0x8B11          /* get spy info (quality of link) */
+#define SIOCSIWTHRSPY   0x8B12          /* set spy threshold (spy event) */
+#define SIOCGIWTHRSPY   0x8B13          /* get spy threshold */
+
+/* Access Point manipulation */
+#define SIOCSIWAP       0x8B14          /* set access point MAC addresses */
+#define SIOCGIWAP       0x8B15          /* get access point MAC addresses */
+#define SIOCGIWAPLIST   0x8B17          /* Deprecated in favor of scanning */
+#define SIOCSIWSCAN     0x8B18          /* trigger scanning (list cells) */
+#define SIOCGIWSCAN     0x8B19          /* get scanning results */
+
+/* 802.11 specific support */
+#define SIOCSIWESSID    0x8B1A          /* set ESSID (network name) */
+#define SIOCGIWESSID    0x8B1B          /* get ESSID */
+#define SIOCSIWNICKN    0x8B1C          /* set node name/nickname */
+#define SIOCGIWNICKN    0x8B1D          /* get node name/nickname */
+/* As the ESSID and NICKN are strings up to 32 bytes long, it doesn't fit
+ * within the 'iwreq' structure, so we need to use the 'data' member to
+ * point to a string in user space, like it is done for RANGE... */
+
+/* Other parameters useful in 802.11 and some other devices */
+#define SIOCSIWRATE     0x8B20          /* set default bit rate (bps) */
+#define SIOCGIWRATE     0x8B21          /* get default bit rate (bps) */
+#define SIOCSIWRTS      0x8B22          /* set RTS/CTS threshold (bytes) */
+#define SIOCGIWRTS      0x8B23          /* get RTS/CTS threshold (bytes) */
+#define SIOCSIWFRAG     0x8B24          /* set fragmentation thr (bytes) */
+#define SIOCGIWFRAG     0x8B25          /* get fragmentation thr (bytes) */
+#define SIOCSIWTXPOW    0x8B26          /* set transmit power (dBm) */
+#define SIOCGIWTXPOW    0x8B27          /* get transmit power (dBm) */
+#define SIOCSIWRETRY    0x8B28          /* set retry limits and lifetime */
+#define SIOCGIWRETRY    0x8B29          /* get retry limits and lifetime */
+
+/* Encoding stuff (scrambling, hardware security, WEP...) */
+#define SIOCSIWENCODE   0x8B2A          /* set encoding token & mode */
+#define SIOCGIWENCODE   0x8B2B          /* get encoding token & mode */
+/* Power saving stuff (power management, unicast and multicast) */
+#define SIOCSIWPOWER    0x8B2C          /* set Power Management settings */
+#define SIOCGIWPOWER    0x8B2D          /* get Power Management settings */
+
+/* -------------------- DEV PRIVATE IOCTL LIST -------------------- */
+
+/* These 32 ioctl are wireless device private, for 16 commands.
+ * Each driver is free to use them for whatever purpose it chooses,
+ * however the driver *must* export the description of those ioctls
+ * with SIOCGIWPRIV and *must* use arguments as defined below.
+ * If you don't follow those rules, DaveM is going to hate you (reason :
+ * it make mixed 32/64bit operation impossible).
+ */
+#define SIOCIWFIRSTPRIV 0x8BE0
+#define SIOCIWLASTPRIV  0x8BFF
+/* Previously, we were using SIOCDEVPRIVATE, but we now have our
+ * separate range because of collisions with other tools such as
+ * 'mii-tool'.
+ * We now have 32 commands, so a bit more space ;-).
+ * Also, all 'odd' commands are only usable by root and don't return the
+ * content of ifr/iwr to user (but you are not obliged to use the set/get
+ * convention, just use every other two command). More details in iwpriv.c.
+ * And I repeat : you are not forced to use them with iwpriv, but you
+ * must be compliant with it.
+ */
+
+/* ------------------------- IOCTL STUFF ------------------------- */
+
+/* The first and the last (range) */
+#define SIOCIWFIRST     0x8B00
+#define SIOCIWLAST      SIOCIWLASTPRIV          /* 0x8BFF */
+
+/* Even : get (world access), odd : set (root access) */
+#define IW_IS_SET(cmd)  (!((cmd) & 0x1))
+#define IW_IS_GET(cmd)  ((cmd) & 0x1)
+
+/* ----------------------- WIRELESS EVENTS ----------------------- */
+/* Those are *NOT* ioctls, do not issue request on them !!! */
+/* Most events use the same identifier as ioctl requests */
+
+#define IWEVTXDROP      0x8C00          /* Packet dropped to excessive retry */
+#define IWEVQUAL        0x8C01          /* Quality part of statistics (scan) */
+#define IWEVCUSTOM      0x8C02          /* Driver specific ascii string */
+#define IWEVREGISTERED  0x8C03          /* Discovered a new node (AP mode) */
+#define IWEVEXPIRED     0x8C04          /* Expired a node (AP mode) */
+
+#define IWEVFIRST       0x8C00
+
+/* ------------------------- PRIVATE INFO ------------------------- */
+/*
+ * The following is used with SIOCGIWPRIV. It allow a driver to define
+ * the interface (name, type of data) for its private ioctl.
+ * Privates ioctl are SIOCIWFIRSTPRIV -> SIOCIWLASTPRIV
+ */
+
+#define IW_PRIV_TYPE_MASK       0x7000  /* Type of arguments */
+#define IW_PRIV_TYPE_NONE       0x0000
+#define IW_PRIV_TYPE_BYTE       0x1000  /* Char as number */
+#define IW_PRIV_TYPE_CHAR       0x2000  /* Char as character */
+#define IW_PRIV_TYPE_INT        0x4000  /* 32 bits int */
+#define IW_PRIV_TYPE_FLOAT      0x5000  /* struct iw_freq */
+#define IW_PRIV_TYPE_ADDR       0x6000  /* struct sockaddr */
+
+#define IW_PRIV_SIZE_FIXED      0x0800  /* Variable or fixed number of args */
+
+#define IW_PRIV_SIZE_MASK       0x07FF  /* Max number of those args */
+
+/*
+ * Note : if the number of args is fixed and the size < 16 octets,
+ * instead of passing a pointer we will put args in the iwreq struct...
+ */
+
+/* ----------------------- OTHER CONSTANTS ----------------------- */
+
+/* Maximum frequencies in the range struct */
+#define IW_MAX_FREQUENCIES      32
+/* Note : if you have something like 80 frequencies,
+ * don't increase this constant and don't fill the frequency list.
+ * The user will be able to set by channel anyway... */
+
+/* Maximum bit rates in the range struct */
+#define IW_MAX_BITRATES         32
+
+/* Maximum tx powers in the range struct */
+#define IW_MAX_TXPOWER          8
+/* Note : if you more than 8 TXPowers, just set the max and min or
+ * a few of them in the struct iw_range. */
+
+/* Maximum of address that you may set with SPY */
+#define IW_MAX_SPY              8
+
+/* Maximum of address that you may get in the
+   list of access points in range */
+#define IW_MAX_AP               64
+
+/* Maximum size of the ESSID and NICKN strings */
+#define IW_ESSID_MAX_SIZE       32
+
+/* Modes of operation */
+#define IW_MODE_AUTO    0       /* Let the driver decides */
+#define IW_MODE_ADHOC   1       /* Single cell network */
+#define IW_MODE_INFRA   2       /* Multi cell network, roaming, ... */
+#define IW_MODE_MASTER  3       /* Synchronisation master or Access Point */
+#define IW_MODE_REPEAT  4       /* Wireless Repeater (forwarder) */
+#define IW_MODE_SECOND  5       /* Secondary master/repeater (backup) */
+#define IW_MODE_MONITOR 6       /* Passive monitor (listen only) */
+
+/* Statistics flags (bitmask in updated) */
+#define IW_QUAL_QUAL_UPDATED    0x1     /* Value was updated since last read */
+#define IW_QUAL_LEVEL_UPDATED   0x2
+#define IW_QUAL_NOISE_UPDATED   0x4
+#define IW_QUAL_QUAL_INVALID    0x10    /* Driver doesn't provide value */
+#define IW_QUAL_LEVEL_INVALID   0x20
+#define IW_QUAL_NOISE_INVALID   0x40
+
+/* Frequency flags */
+#define IW_FREQ_AUTO            0x00    /* Let the driver decides */
+#define IW_FREQ_FIXED           0x01    /* Force a specific value */
+
+/* Maximum number of size of encoding token available
+ * they are listed in the range structure */
+#define IW_MAX_ENCODING_SIZES   8
+
+/* Maximum size of the encoding token in bytes */
+#define IW_ENCODING_TOKEN_MAX   32      /* 256 bits (for now) */
+
+/* Flags for encoding (along with the token) */
+#define IW_ENCODE_INDEX         0x00FF  /* Token index (if needed) */
+#define IW_ENCODE_FLAGS         0xFF00  /* Flags defined below */
+#define IW_ENCODE_MODE          0xF000  /* Modes defined below */
+#define IW_ENCODE_DISABLED      0x8000  /* Encoding disabled */
+#define IW_ENCODE_ENABLED       0x0000  /* Encoding enabled */
+#define IW_ENCODE_RESTRICTED    0x4000  /* Refuse non-encoded packets */
+#define IW_ENCODE_OPEN          0x2000  /* Accept non-encoded packets */
+#define IW_ENCODE_NOKEY         0x0800  /* Key is write only, so not present */
+#define IW_ENCODE_TEMP          0x0400  /* Temporary key */
+
+/* Power management flags available (along with the value, if any) */
+#define IW_POWER_ON             0x0000  /* No details... */
+#define IW_POWER_TYPE           0xF000  /* Type of parameter */
+#define IW_POWER_PERIOD         0x1000  /* Value is a period/duration of  */
+#define IW_POWER_TIMEOUT        0x2000  /* Value is a timeout (to go asleep) */
+#define IW_POWER_MODE           0x0F00  /* Power Management mode */
+#define IW_POWER_UNICAST_R      0x0100  /* Receive only unicast messages */
+#define IW_POWER_MULTICAST_R    0x0200  /* Receive only multicast messages */
+#define IW_POWER_ALL_R          0x0300  /* Receive all messages though PM */
+#define IW_POWER_FORCE_S        0x0400  /* Force PM procedure for sending unicast */
+#define IW_POWER_REPEATER       0x0800  /* Repeat broadcast messages in PM period */
+#define IW_POWER_MODIFIER       0x000F  /* Modify a parameter */
+#define IW_POWER_MIN            0x0001  /* Value is a minimum  */
+#define IW_POWER_MAX            0x0002  /* Value is a maximum */
+#define IW_POWER_RELATIVE       0x0004  /* Value is not in seconds/ms/us */
+
+/* Transmit Power flags available */
+#define IW_TXPOW_TYPE           0x00FF  /* Type of value */
+#define IW_TXPOW_DBM            0x0000  /* Value is in dBm */
+#define IW_TXPOW_MWATT          0x0001  /* Value is in mW */
+#define IW_TXPOW_RELATIVE       0x0002  /* Value is in arbitrary units */
+#define IW_TXPOW_RANGE          0x1000  /* Range of value between min/max */
+
+/* Retry limits and lifetime flags available */
+#define IW_RETRY_ON             0x0000  /* No details... */
+#define IW_RETRY_TYPE           0xF000  /* Type of parameter */
+#define IW_RETRY_LIMIT          0x1000  /* Maximum number of retries*/
+#define IW_RETRY_LIFETIME       0x2000  /* Maximum duration of retries in us */
+#define IW_RETRY_MODIFIER       0x000F  /* Modify a parameter */
+#define IW_RETRY_MIN            0x0001  /* Value is a minimum  */
+#define IW_RETRY_MAX            0x0002  /* Value is a maximum */
+#define IW_RETRY_RELATIVE       0x0004  /* Value is not in seconds/ms/us */
+
+/* Scanning request flags */
+#define IW_SCAN_DEFAULT         0x0000  /* Default scan of the driver */
+#define IW_SCAN_ALL_ESSID       0x0001  /* Scan all ESSIDs */
+#define IW_SCAN_THIS_ESSID      0x0002  /* Scan only this ESSID */
+#define IW_SCAN_ALL_FREQ        0x0004  /* Scan all Frequencies */
+#define IW_SCAN_THIS_FREQ       0x0008  /* Scan only this Frequency */
+#define IW_SCAN_ALL_MODE        0x0010  /* Scan all Modes */
+#define IW_SCAN_THIS_MODE       0x0020  /* Scan only this Mode */
+#define IW_SCAN_ALL_RATE        0x0040  /* Scan all Bit-Rates */
+#define IW_SCAN_THIS_RATE       0x0080  /* Scan only this Bit-Rate */
+/* Maximum size of returned data */
+#define IW_SCAN_MAX_DATA        4096    /* In bytes */
+
+/* Max number of char in custom event - use multiple of them if needed */
+#define IW_CUSTOM_MAX           256     /* In bytes */
+
+/* Event capability macros - in (struct iw_range *)->event_capa
+ * Because we have more than 32 possible events, we use an array of
+ * 32 bit bitmasks. Note : 32 bits = 0x20 = 2^5. */
+#define IW_EVENT_CAPA_BASE(cmd)         ((cmd >= SIOCIWFIRSTPRIV) ? \
+                                         (cmd - SIOCIWFIRSTPRIV + 0x60) : \
+                                         (cmd - SIOCSIWCOMMIT))
+#define IW_EVENT_CAPA_INDEX(cmd)        (IW_EVENT_CAPA_BASE(cmd) >> 5)
+#define IW_EVENT_CAPA_MASK(cmd)         (1 << (IW_EVENT_CAPA_BASE(cmd) & 0x1F))
+/* Event capability constants - event autogenerated by the kernel
+ * This list is valid for most 802.11 devices, customise as needed... */
+#define IW_EVENT_CAPA_K_0       (IW_EVENT_CAPA_MASK(0x8B04) | \
+                                 IW_EVENT_CAPA_MASK(0x8B06) | \
+                                 IW_EVENT_CAPA_MASK(0x8B1A))
+#define IW_EVENT_CAPA_K_1       (IW_EVENT_CAPA_MASK(0x8B2A))
+/* "Easy" macro to set events in iw_range (less efficient) */
+#define IW_EVENT_CAPA_SET(event_capa, cmd) (event_capa[IW_EVENT_CAPA_INDEX(cmd)] |= IW_EVENT_CAPA_MASK(cmd))
+#define IW_EVENT_CAPA_SET_KERNEL(event_capa) {event_capa[0] |= IW_EVENT_CAPA_K_0; event_capa[1] |= IW_EVENT_CAPA_K_1; }
+
+
+/****************************** TYPES ******************************/
+
+/* --------------------------- SUBTYPES --------------------------- */
+/*
+ *      Generic format for most parameters that fit in an int
+ */
+struct  iw_param
+{
+  __s32         value;          /* The value of the parameter itself */
+  __u8          fixed;          /* Hardware should not use auto select */
+  __u8          disabled;       /* Disable the feature */
+  __u16         flags;          /* Various specifc flags (if any) */
+};
+
+/*
+ *      For all data larger than 16 octets, we need to use a
+ *      pointer to memory allocated in user space.
+ */
+struct  iw_point
+{
+  void __user   *pointer;       /* Pointer to the data  (in user space) */
+  __u16         length;         /* number of fields or size in bytes */
+  __u16         flags;          /* Optional params */
+};
+
+/*
+ *      A frequency
+ *      For numbers lower than 10^9, we encode the number in 'm' and
+ *      set 'e' to 0
+ *      For number greater than 10^9, we divide it by the lowest power
+ *      of 10 to get 'm' lower than 10^9, with 'm'= f / (10^'e')...
+ *      The power of 10 is in 'e', the result of the division is in 'm'.
+ */
+struct  iw_freq
+{
+        __s32           m;              /* Mantissa */
+        __s16           e;              /* Exponent */
+        __u8            i;              /* List index (when in range struct) */
+        __u8            flags;          /* Flags (fixed/auto) */
+};
+
+/*
+ *      Quality of the link
+ */
+struct  iw_quality
+{
+        __u8            qual;           /* link quality (%retries, SNR,
+                                           %missed beacons or better...) */
+        __u8            level;          /* signal level (dBm) */
+        __u8            noise;          /* noise level (dBm) */
+        __u8            updated;        /* Flags to know if updated */
+};
+
+/*
+ *      Packet discarded in the wireless adapter due to
+ *      "wireless" specific problems...
+ *      Note : the list of counter and statistics in net_device_stats
+ *      is already pretty exhaustive, and you should use that first.
+ *      This is only additional stats...
+ */
+struct  iw_discarded
+{
+        __u32           nwid;           /* Rx : Wrong nwid/essid */
+        __u32           code;           /* Rx : Unable to code/decode (WEP) */
+        __u32           fragment;       /* Rx : Can't perform MAC reassembly */
+        __u32           retries;        /* Tx : Max MAC retries num reached */
+        __u32           misc;           /* Others cases */
+};
+
+/*
+ *      Packet/Time period missed in the wireless adapter due to
+ *      "wireless" specific problems...
+ */
+struct  iw_missed
+{
+        __u32           beacon;         /* Missed beacons/superframe */
+};
+
+/*
+ *      Quality range (for spy threshold)
+ */
+struct  iw_thrspy
+{
+        struct sockaddr         addr;           /* Source address (hw/mac) */
+        struct iw_quality       qual;           /* Quality of the link */
+        struct iw_quality       low;            /* Low threshold */
+        struct iw_quality       high;           /* High threshold */
+};
+
+/* ------------------------ WIRELESS STATS ------------------------ */
+/*
+ * Wireless statistics (used for /proc/net/wireless)
+ */
+struct  iw_statistics
+{
+        __u16           status;         /* Status
+                                         * - device dependent for now */
+
+        struct iw_quality       qual;           /* Quality of the link
+                                                 * (instant/mean/max) */
+        struct iw_discarded     discard;        /* Packet discarded counts */
+        struct iw_missed        miss;           /* Packet missed counts */
+};
+
+/* ------------------------ IOCTL REQUEST ------------------------ */
+/*
+ * This structure defines the payload of an ioctl, and is used 
+ * below.
+ *
+ * Note that this structure should fit on the memory footprint
+ * of iwreq (which is the same as ifreq), which mean a max size of
+ * 16 octets = 128 bits. Warning, pointers might be 64 bits wide...
+ * You should check this when increasing the structures defined
+ * above in this file...
+ */
+union   iwreq_data
+{
+        /* Config - generic */
+        char            name[IFNAMSIZ];
+        /* Name : used to verify the presence of  wireless extensions.
+         * Name of the protocol/provider... */
+
+        struct iw_point essid;          /* Extended network name */
+        struct iw_param nwid;           /* network id (or domain - the cell) */
+        struct iw_freq  freq;           /* frequency or channel :
+                                         * 0-1000 = channel
+                                         * > 1000 = frequency in Hz */
+
+        struct iw_param sens;           /* signal level threshold */
+        struct iw_param bitrate;        /* default bit rate */
+        struct iw_param txpower;        /* default transmit power */
+        struct iw_param rts;            /* RTS threshold threshold */
+        struct iw_param frag;           /* Fragmentation threshold */
+        __u32           mode;           /* Operation mode */
+        struct iw_param retry;          /* Retry limits & lifetime */
+
+        struct iw_point encoding;       /* Encoding stuff : tokens */
+        struct iw_param power;          /* PM duration/timeout */
+        struct iw_quality qual;         /* Quality part of statistics */
+
+        struct sockaddr ap_addr;        /* Access point address */
+        struct sockaddr addr;           /* Destination address (hw/mac) */
+
+        struct iw_param param;          /* Other small parameters */
+        struct iw_point data;           /* Other large parameters */
+};
+
+/*
+ * The structure to exchange data for ioctl.
+ * This structure is the same as 'struct ifreq', but (re)defined for
+ * convenience...
+ * Do I need to remind you about structure size (32 octets) ?
+ */
+struct  iwreq 
+{
+        union
+        {
+                char    ifrn_name[IFNAMSIZ];    /* if name, e.g. "eth0" */
+        } ifr_ifrn;
+
+        /* Data part (defined just above) */
+        union   iwreq_data      u;
+};
+
+/* -------------------------- IOCTL DATA -------------------------- */
+/*
+ *      For those ioctl which want to exchange mode data that what could
+ *      fit in the above structure...
+ */
+
+/*
+ *      Range of parameters
+ */
+
+struct  iw_range
+{
+        /* Informative stuff (to choose between different interface) */
+        __u32           throughput;     /* To give an idea... */
+        /* In theory this value should be the maximum benchmarked
+         * TCP/IP throughput, because with most of these devices the
+         * bit rate is meaningless (overhead an co) to estimate how
+         * fast the connection will go and pick the fastest one.
+         * I suggest people to play with Netperf or any benchmark...
+         */
+
+        /* NWID (or domain id) */
+        __u32           min_nwid;       /* Minimal NWID we are able to set */
+        __u32           max_nwid;       /* Maximal NWID we are able to set */
+
+        /* Old Frequency (backward compat - moved lower ) */
+        __u16           old_num_channels;
+        __u8            old_num_frequency;
+
+        /* Wireless event capability bitmasks */
+        __u32           event_capa[6];
+
+        /* signal level threshold range */
+        __s32           sensitivity;
+
+        /* Quality of link & SNR stuff */
+        /* Quality range (link, level, noise)
+         * If the quality is absolute, it will be in the range [0 ; max_qual],
+         * if the quality is dBm, it will be in the range [max_qual ; 0].
+         * Don't forget that we use 8 bit arithmetics... */
+        struct iw_quality       max_qual;       /* Quality of the link */
+        /* This should contain the average/typical values of the quality
+         * indicator. This should be the threshold between a "good" and
+         * a "bad" link (example : monitor going from green to orange).
+         * Currently, user space apps like quality monitors don't have any
+         * way to calibrate the measurement. With this, they can split
+         * the range between 0 and max_qual in different quality level
+         * (using a geometric subdivision centered on the average).
+         * I expect that people doing the user space apps will feedback
+         * us on which value we need to put in each driver... */
+        struct iw_quality       avg_qual;       /* Quality of the link */
+
+        /* Rates */
+        __u8            num_bitrates;   /* Number of entries in the list */
+        __s32           bitrate[IW_MAX_BITRATES];       /* list, in bps */
+
+        /* RTS threshold */
+        __s32           min_rts;        /* Minimal RTS threshold */
+        __s32           max_rts;        /* Maximal RTS threshold */
+
+        /* Frag threshold */
+        __s32           min_frag;       /* Minimal frag threshold */
+        __s32           max_frag;       /* Maximal frag threshold */
+
+        /* Power Management duration & timeout */
+        __s32           min_pmp;        /* Minimal PM period */
+        __s32           max_pmp;        /* Maximal PM period */
+        __s32           min_pmt;        /* Minimal PM timeout */
+        __s32           max_pmt;        /* Maximal PM timeout */
+        __u16           pmp_flags;      /* How to decode max/min PM period */
+        __u16           pmt_flags;      /* How to decode max/min PM timeout */
+        __u16           pm_capa;        /* What PM options are supported */
+
+        /* Encoder stuff */
+        __u16   encoding_size[IW_MAX_ENCODING_SIZES];   /* Different token sizes */
+        __u8    num_encoding_sizes;     /* Number of entry in the list */
+        __u8    max_encoding_tokens;    /* Max number of tokens */
+        /* For drivers that need a "login/passwd" form */
+        __u8    encoding_login_index;   /* token index for login token */
+
+        /* Transmit power */
+        __u16           txpower_capa;   /* What options are supported */
+        __u8            num_txpower;    /* Number of entries in the list */
+        __s32           txpower[IW_MAX_TXPOWER];        /* list, in bps */
+
+        /* Wireless Extension version info */
+        __u8            we_version_compiled;    /* Must be WIRELESS_EXT */
+        __u8            we_version_source;      /* Last update of source */
+
+        /* Retry limits and lifetime */
+        __u16           retry_capa;     /* What retry options are supported */
+        __u16           retry_flags;    /* How to decode max/min retry limit */
+        __u16           r_time_flags;   /* How to decode max/min retry life */
+        __s32           min_retry;      /* Minimal number of retries */
+        __s32           max_retry;      /* Maximal number of retries */
+        __s32           min_r_time;     /* Minimal retry lifetime */
+        __s32           max_r_time;     /* Maximal retry lifetime */
+
+        /* Frequency */
+        __u16           num_channels;   /* Number of channels [0; num - 1] */
+        __u8            num_frequency;  /* Number of entry in the list */
+        struct iw_freq  freq[IW_MAX_FREQUENCIES];       /* list */
+        /* Note : this frequency list doesn't need to fit channel numbers,
+         * because each entry contain its channel index */
+};
+
+/*
+ * Private ioctl interface information
+ */
+ 
+struct  iw_priv_args
+{
+        __u32           cmd;            /* Number of the ioctl to issue */
+        __u16           set_args;       /* Type and number of args */
+        __u16           get_args;       /* Type and number of args */
+        char            name[IFNAMSIZ]; /* Name of the extension */
+};
+
+/* ----------------------- WIRELESS EVENTS ----------------------- */
+/*
+ * Wireless events are carried through the rtnetlink socket to user
+ * space. They are encapsulated in the IFLA_WIRELESS field of
+ * a RTM_NEWLINK message.
+ */
+
+/*
+ * A Wireless Event. Contains basically the same data as the ioctl...
+ */
+struct iw_event
+{
+        __u16           len;                    /* Real lenght of this stuff */
+        __u16           cmd;                    /* Wireless IOCTL */
+        union iwreq_data        u;              /* IOCTL fixed payload */
+};
+
+/* Size of the Event prefix (including padding and alignement junk) */
+#define IW_EV_LCP_LEN   (sizeof(struct iw_event) - sizeof(union iwreq_data))
+/* Size of the various events */
+#define IW_EV_CHAR_LEN  (IW_EV_LCP_LEN + IFNAMSIZ)
+#define IW_EV_UINT_LEN  (IW_EV_LCP_LEN + sizeof(__u32))
+#define IW_EV_FREQ_LEN  (IW_EV_LCP_LEN + sizeof(struct iw_freq))
+#define IW_EV_POINT_LEN (IW_EV_LCP_LEN + sizeof(struct iw_point))
+#define IW_EV_PARAM_LEN (IW_EV_LCP_LEN + sizeof(struct iw_param))
+#define IW_EV_ADDR_LEN  (IW_EV_LCP_LEN + sizeof(struct sockaddr))
+#define IW_EV_QUAL_LEN  (IW_EV_LCP_LEN + sizeof(struct iw_quality))
+
+/* Note : in the case of iw_point, the extra data will come at the
+ * end of the event */
+
+#endif  /* _LINUX_WIRELESS_H */
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
new file mode 100644
index 000000000000..ff46f537ba9b
--- /dev/null
+++ b/include/linux/workqueue.h
@@ -0,0 +1,90 @@
+/*
+ * workqueue.h --- work queue handling for Linux.
+ */
+
+#ifndef _LINUX_WORKQUEUE_H
+#define _LINUX_WORKQUEUE_H
+
+#include <linux/timer.h>
+#include <linux/linkage.h>
+#include <linux/bitops.h>
+
+struct workqueue_struct;
+
+struct work_struct {
+        unsigned long pending;
+        struct list_head entry;
+        void (*func)(void *);
+        void *data;
+        void *wq_data;
+        struct timer_list timer;
+};
+
+#define __WORK_INITIALIZER(n, f, d) {                           \
+        .entry  = { &(n).entry, &(n).entry },                   \
+        .func = (f),                                            \
+        .data = (d),                                            \
+        .timer = TIMER_INITIALIZER(NULL, 0, 0),                 \
+        }
+
+#define DECLARE_WORK(n, f, d)                                   \
+        struct work_struct n = __WORK_INITIALIZER(n, f, d)
+
+/*
+ * initialize a work-struct's func and data pointers:
+ */
+#define PREPARE_WORK(_work, _func, _data)                       \
+        do {                                                    \
+                (_work)->func = _func;                          \
+                (_work)->data = _data;                          \
+        } while (0)
+
+/*
+ * initialize all of a work-struct:
+ */
+#define INIT_WORK(_work, _func, _data)                          \
+        do {                                                    \
+                INIT_LIST_HEAD(&(_work)->entry);                \
+                (_work)->pending = 0;                           \
+                PREPARE_WORK((_work), (_func), (_data));        \
+                init_timer(&(_work)->timer);                    \
+        } while (0)
+
+extern struct workqueue_struct *__create_workqueue(const char *name,
+                                                    int singlethread);
+#define create_workqueue(name) __create_workqueue((name), 0)
+#define create_singlethread_workqueue(name) __create_workqueue((name), 1)
+
+extern void destroy_workqueue(struct workqueue_struct *wq);
+
+extern int FASTCALL(queue_work(struct workqueue_struct *wq, struct work_struct *work));
+extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay));
+extern void FASTCALL(flush_workqueue(struct workqueue_struct *wq));
+
+extern int FASTCALL(schedule_work(struct work_struct *work));
+extern int FASTCALL(schedule_delayed_work(struct work_struct *work, unsigned long delay));
+
+extern int schedule_delayed_work_on(int cpu, struct work_struct *work, unsigned long delay);
+extern void flush_scheduled_work(void);
+extern int current_is_keventd(void);
+extern int keventd_up(void);
+
+extern void init_workqueues(void);
+void cancel_rearming_delayed_work(struct work_struct *work);
+
+/*
+ * Kill off a pending schedule_delayed_work().  Note that the work callback
+ * function may still be running on return from cancel_delayed_work().  Run
+ * flush_scheduled_work() to wait on it.
+ */
+static inline int cancel_delayed_work(struct work_struct *work)
+{
+        int ret;
+
+        ret = del_timer_sync(&work->timer);
+        if (ret)
+                clear_bit(0, &work->pending);
+        return ret;
+}
+
+#endif
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
new file mode 100644
index 000000000000..1262cb43c3ab
--- /dev/null
+++ b/include/linux/writeback.h
@@ -0,0 +1,118 @@
+/*
+ * include/linux/writeback.h.
+ */
+#ifndef WRITEBACK_H
+#define WRITEBACK_H
+
+struct backing_dev_info;
+
+extern spinlock_t inode_lock;
+extern struct list_head inode_in_use;
+extern struct list_head inode_unused;
+
+/*
+ * Yes, writeback.h requires sched.h
+ * No, sched.h is not included from here.
+ */
+static inline int current_is_pdflush(void)
+{
+        return current->flags & PF_FLUSHER;
+}
+
+/*
+ * fs/fs-writeback.c
+ */
+enum writeback_sync_modes {
+        WB_SYNC_NONE,   /* Don't wait on anything */
+        WB_SYNC_ALL,    /* Wait on every mapping */
+        WB_SYNC_HOLD,   /* Hold the inode on sb_dirty for sys_sync() */
+};
+
+/*
+ * A control structure which tells the writeback code what to do.  These are
+ * always on the stack, and hence need no locking.  They are always initialised
+ * in a manner such that unspecified fields are set to zero.
+ */
+struct writeback_control {
+        struct backing_dev_info *bdi;   /* If !NULL, only write back this
+                                           queue */
+        enum writeback_sync_modes sync_mode;
+        unsigned long *older_than_this; /* If !NULL, only write back inodes
+                                           older than this */
+        long nr_to_write;               /* Write this many pages, and decrement
+                                           this for each page written */
+        long pages_skipped;             /* Pages which were not written */
+
+        /*
+         * For a_ops->writepages(): is start or end are non-zero then this is
+         * a hint that the filesystem need only write out the pages inside that
+         * byterange.  The byte at `end' is included in the writeout request.
+         */
+        loff_t start;
+        loff_t end;
+
+        unsigned nonblocking:1;                 /* Don't get stuck on request queues */
+        unsigned encountered_congestion:1;      /* An output: a queue is full */
+        unsigned for_kupdate:1;                 /* A kupdate writeback */
+        unsigned for_reclaim:1;                 /* Invoked from the page allocator */
+};
+
+/*
+ * ->writepage() return values (make these much larger than a pagesize, in
+ * case some fs is returning number-of-bytes-written from writepage)
+ */
+#define WRITEPAGE_ACTIVATE      0x80000 /* IO was not started: activate page */
+
+/*
+ * fs/fs-writeback.c
+ */     
+void writeback_inodes(struct writeback_control *wbc);
+void wake_up_inode(struct inode *inode);
+int inode_wait(void *);
+void sync_inodes_sb(struct super_block *, int wait);
+void sync_inodes(int wait);
+
+/* writeback.h requires fs.h; it, too, is not included from here. */
+static inline void wait_on_inode(struct inode *inode)
+{
+        might_sleep();
+        wait_on_bit(&inode->i_state, __I_LOCK, inode_wait,
+                                                        TASK_UNINTERRUPTIBLE);
+}
+
+/*
+ * mm/page-writeback.c
+ */
+int wakeup_bdflush(long nr_pages);
+void laptop_io_completion(void);
+void laptop_sync_completion(void);
+void throttle_vm_writeout(void);
+
+/* These are exported to sysctl. */
+extern int dirty_background_ratio;
+extern int vm_dirty_ratio;
+extern int dirty_writeback_centisecs;
+extern int dirty_expire_centisecs;
+extern int block_dump;
+extern int laptop_mode;
+
+struct ctl_table;
+struct file;
+int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *,
+                                      void __user *, size_t *, loff_t *);
+
+void page_writeback_init(void);
+void balance_dirty_pages_ratelimited(struct address_space *mapping);
+int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
+int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
+int sync_page_range(struct inode *inode, struct address_space *mapping,
+                        loff_t pos, size_t count);
+int sync_page_range_nolock(struct inode *inode, struct address_space
+                *mapping, loff_t pos, size_t count);
+
+/* pdflush.c */
+extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
+                                   read-only. */
+
+
+#endif          /* WRITEBACK_H */
diff --git a/include/linux/x25.h b/include/linux/x25.h
new file mode 100644
index 000000000000..7531cfed5885
--- /dev/null
+++ b/include/linux/x25.h
@@ -0,0 +1,112 @@
+/*
+ * These are the public elements of the Linux kernel X.25 implementation.
+ *
+ *      History
+ *      mar/20/00       Daniela Squassoni Disabling/enabling of facilities 
+ *                                        negotiation.
+ */
+
+#ifndef X25_KERNEL_H
+#define X25_KERNEL_H
+
+#define SIOCX25GSUBSCRIP        (SIOCPROTOPRIVATE + 0)
+#define SIOCX25SSUBSCRIP        (SIOCPROTOPRIVATE + 1)
+#define SIOCX25GFACILITIES      (SIOCPROTOPRIVATE + 2)
+#define SIOCX25SFACILITIES      (SIOCPROTOPRIVATE + 3)
+#define SIOCX25GCALLUSERDATA    (SIOCPROTOPRIVATE + 4)
+#define SIOCX25SCALLUSERDATA    (SIOCPROTOPRIVATE + 5)
+#define SIOCX25GCAUSEDIAG       (SIOCPROTOPRIVATE + 6)
+
+/*
+ *      Values for {get,set}sockopt.
+ */
+#define X25_QBITINCL            1
+
+/*
+ *      X.25 Packet Size values.
+ */
+#define X25_PS16                4
+#define X25_PS32                5
+#define X25_PS64                6
+#define X25_PS128               7
+#define X25_PS256               8
+#define X25_PS512               9
+#define X25_PS1024              10
+#define X25_PS2048              11
+#define X25_PS4096              12
+
+/*
+ * An X.121 address, it is held as ASCII text, null terminated, up to 15
+ * digits and a null terminator.
+ */
+struct x25_address {
+        char x25_addr[16];
+};
+
+/*
+ *      Linux X.25 Address structure, used for bind, and connect mostly.
+ */
+struct sockaddr_x25 {
+        sa_family_t        sx25_family;         /* Must be AF_X25 */
+        struct x25_address sx25_addr;           /* X.121 Address */
+};
+
+/*
+ *      DTE/DCE subscription options.
+ *
+ *      As this is missing lots of options, user should expect major
+ *      changes of this structure in 2.5.x which might break compatibilty.
+ *      The somewhat ugly dimension 200-sizeof() is needed to maintain
+ *      backward compatibility.
+ */
+struct x25_subscrip_struct {
+        char device[200-sizeof(unsigned long)];
+        unsigned long   global_facil_mask;      /* 0 to disable negotiation */
+        unsigned int    extended;
+};
+
+/* values for above global_facil_mask */
+
+#define X25_MASK_REVERSE        0x01    
+#define X25_MASK_THROUGHPUT     0x02
+#define X25_MASK_PACKET_SIZE    0x04
+#define X25_MASK_WINDOW_SIZE    0x08
+
+
+
+/*
+ *      Routing table control structure.
+ */
+struct x25_route_struct {
+        struct x25_address address;
+        unsigned int       sigdigits;
+        char               device[200];
+};
+
+/*
+ *      Facilities structure.
+ */
+struct x25_facilities {
+        unsigned int    winsize_in, winsize_out;
+        unsigned int    pacsize_in, pacsize_out;
+        unsigned int    throughput;
+        unsigned int    reverse;
+};
+
+/*
+ *      Call User Data structure.
+ */
+struct x25_calluserdata {
+        unsigned int    cudlength;
+        unsigned char   cuddata[128];
+};
+
+/*
+ *      Call clearing Cause and Diagnostic structure.
+ */
+struct x25_causediag {
+        unsigned char   cause;
+        unsigned char   diagnostic;
+};
+
+#endif
diff --git a/include/linux/xattr.h b/include/linux/xattr.h
new file mode 100644
index 000000000000..23f9c61d9546
--- /dev/null
+++ b/include/linux/xattr.h
@@ -0,0 +1,33 @@
+/*
+  File: linux/xattr.h
+
+  Extended attributes handling.
+
+  Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
+  Copyright (c) 2001-2002 Silicon Graphics, Inc.  All Rights Reserved.
+  Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
+*/
+#ifndef _LINUX_XATTR_H
+#define _LINUX_XATTR_H
+
+#define XATTR_CREATE    0x1     /* set value, fail if attr already exists */
+#define XATTR_REPLACE   0x2     /* set value, fail if attr does not exist */
+
+#define XATTR_SECURITY_PREFIX   "security."
+
+struct xattr_handler {
+        char *prefix;
+        size_t (*list)(struct inode *inode, char *list, size_t list_size,
+                       const char *name, size_t name_len);
+        int (*get)(struct inode *inode, const char *name, void *buffer,
+                   size_t size);
+        int (*set)(struct inode *inode, const char *name, const void *buffer,
+                   size_t size, int flags);
+};
+
+ssize_t generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size);
+ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
+int generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags);
+int generic_removexattr(struct dentry *dentry, const char *name);
+
+#endif  /* _LINUX_XATTR_H */
diff --git a/include/linux/xattr_acl.h b/include/linux/xattr_acl.h
new file mode 100644
index 000000000000..7a1f9b93a45f
--- /dev/null
+++ b/include/linux/xattr_acl.h
@@ -0,0 +1,50 @@
+/*
+  File: linux/xattr_acl.h
+
+  (extended attribute representation of access control lists)
+
+  (C) 2000 Andreas Gruenbacher, <a.gruenbacher@computer.org>
+*/
+
+#ifndef _LINUX_XATTR_ACL_H
+#define _LINUX_XATTR_ACL_H
+
+#include <linux/posix_acl.h>
+
+#define XATTR_NAME_ACL_ACCESS   "system.posix_acl_access"
+#define XATTR_NAME_ACL_DEFAULT  "system.posix_acl_default"
+
+#define XATTR_ACL_VERSION       0x0002
+
+typedef struct {
+        __u16           e_tag;
+        __u16           e_perm;
+        __u32           e_id;
+} xattr_acl_entry;
+
+typedef struct {
+        __u32           a_version;
+        xattr_acl_entry a_entries[0];
+} xattr_acl_header;
+
+static inline size_t xattr_acl_size(int count)
+{
+        return sizeof(xattr_acl_header) + count * sizeof(xattr_acl_entry);
+}
+
+static inline int xattr_acl_count(size_t size)
+{
+        if (size < sizeof(xattr_acl_header))
+                return -1;
+        size -= sizeof(xattr_acl_header);
+        if (size % sizeof(xattr_acl_entry))
+                return -1;
+        return size / sizeof(xattr_acl_entry);
+}
+
+struct posix_acl * posix_acl_from_xattr(const void *value, size_t size);
+int posix_acl_to_xattr(const struct posix_acl *acl, void *buffer, size_t size);
+
+
+
+#endif /* _LINUX_XATTR_ACL_H */
diff --git a/include/linux/xfrm.h b/include/linux/xfrm.h
new file mode 100644
index 000000000000..f0df02ae68a4
--- /dev/null
+++ b/include/linux/xfrm.h
@@ -0,0 +1,258 @@
+#ifndef _LINUX_XFRM_H
+#define _LINUX_XFRM_H
+
+#include <linux/types.h>
+
+/* All of the structures in this file may not change size as they are
+ * passed into the kernel from userspace via netlink sockets.
+ */
+
+/* Structure to encapsulate addresses. I do not want to use
+ * "standard" structure. My apologies.
+ */
+typedef union
+{
+        __u32           a4;
+        __u32           a6[4];
+} xfrm_address_t;
+
+/* Ident of a specific xfrm_state. It is used on input to lookup
+ * the state by (spi,daddr,ah/esp) or to store information about
+ * spi, protocol and tunnel address on output.
+ */
+struct xfrm_id
+{
+        xfrm_address_t  daddr;
+        __u32           spi;
+        __u8            proto;
+};
+
+/* Selector, used as selector both on policy rules (SPD) and SAs. */
+
+struct xfrm_selector
+{
+        xfrm_address_t  daddr;
+        xfrm_address_t  saddr;
+        __u16   dport;
+        __u16   dport_mask;
+        __u16   sport;
+        __u16   sport_mask;
+        __u16   family;
+        __u8    prefixlen_d;
+        __u8    prefixlen_s;
+        __u8    proto;
+        int     ifindex;
+        uid_t   user;
+};
+
+#define XFRM_INF (~(__u64)0)
+
+struct xfrm_lifetime_cfg
+{
+        __u64   soft_byte_limit;
+        __u64   hard_byte_limit;
+        __u64   soft_packet_limit;
+        __u64   hard_packet_limit;
+        __u64   soft_add_expires_seconds;
+        __u64   hard_add_expires_seconds;
+        __u64   soft_use_expires_seconds;
+        __u64   hard_use_expires_seconds;
+};
+
+struct xfrm_lifetime_cur
+{
+        __u64   bytes;
+        __u64   packets;
+        __u64   add_time;
+        __u64   use_time;
+};
+
+struct xfrm_replay_state
+{
+        __u32   oseq;
+        __u32   seq;
+        __u32   bitmap;
+};
+
+struct xfrm_algo {
+        char    alg_name[64];
+        int     alg_key_len;    /* in bits */
+        char    alg_key[0];
+};
+
+struct xfrm_stats {
+        __u32   replay_window;
+        __u32   replay;
+        __u32   integrity_failed;
+};
+
+enum
+{
+        XFRM_POLICY_IN  = 0,
+        XFRM_POLICY_OUT = 1,
+        XFRM_POLICY_FWD = 2,
+        XFRM_POLICY_MAX = 3
+};
+
+enum
+{
+        XFRM_SHARE_ANY,         /* No limitations */
+        XFRM_SHARE_SESSION,     /* For this session only */
+        XFRM_SHARE_USER,        /* For this user only */
+        XFRM_SHARE_UNIQUE       /* Use once */
+};
+
+/* Netlink configuration messages.  */
+enum {
+        XFRM_MSG_BASE = 0x10,
+
+        XFRM_MSG_NEWSA = 0x10,
+#define XFRM_MSG_NEWSA XFRM_MSG_NEWSA
+        XFRM_MSG_DELSA,
+#define XFRM_MSG_DELSA XFRM_MSG_DELSA
+        XFRM_MSG_GETSA,
+#define XFRM_MSG_GETSA XFRM_MSG_GETSA
+
+        XFRM_MSG_NEWPOLICY,
+#define XFRM_MSG_NEWPOLICY XFRM_MSG_NEWPOLICY
+        XFRM_MSG_DELPOLICY,
+#define XFRM_MSG_DELPOLICY XFRM_MSG_DELPOLICY
+        XFRM_MSG_GETPOLICY,
+#define XFRM_MSG_GETPOLICY XFRM_MSG_GETPOLICY
+
+        XFRM_MSG_ALLOCSPI,
+#define XFRM_MSG_ALLOCSPI XFRM_MSG_ALLOCSPI
+        XFRM_MSG_ACQUIRE,
+#define XFRM_MSG_ACQUIRE XFRM_MSG_ACQUIRE
+        XFRM_MSG_EXPIRE,
+#define XFRM_MSG_EXPIRE XFRM_MSG_EXPIRE
+
+        XFRM_MSG_UPDPOLICY,
+#define XFRM_MSG_UPDPOLICY XFRM_MSG_UPDPOLICY
+        XFRM_MSG_UPDSA,
+#define XFRM_MSG_UPDSA XFRM_MSG_UPDSA
+
+        XFRM_MSG_POLEXPIRE,
+#define XFRM_MSG_POLEXPIRE XFRM_MSG_POLEXPIRE
+
+        XFRM_MSG_FLUSHSA,
+#define XFRM_MSG_FLUSHSA XFRM_MSG_FLUSHSA
+        XFRM_MSG_FLUSHPOLICY,
+#define XFRM_MSG_FLUSHPOLICY XFRM_MSG_FLUSHPOLICY
+
+        XFRM_MSG_MAX
+};
+
+struct xfrm_user_tmpl {
+        struct xfrm_id          id;
+        __u16                   family;
+        xfrm_address_t          saddr;
+        __u32                   reqid;
+        __u8                    mode;
+        __u8                    share;
+        __u8                    optional;
+        __u32                   aalgos;
+        __u32                   ealgos;
+        __u32                   calgos;
+};
+
+struct xfrm_encap_tmpl {
+        __u16           encap_type;
+        __u16           encap_sport;
+        __u16           encap_dport;
+        xfrm_address_t  encap_oa;
+};
+
+/* Netlink message attributes.  */
+enum xfrm_attr_type_t {
+        XFRMA_UNSPEC,
+        XFRMA_ALG_AUTH,         /* struct xfrm_algo */
+        XFRMA_ALG_CRYPT,        /* struct xfrm_algo */
+        XFRMA_ALG_COMP,         /* struct xfrm_algo */
+        XFRMA_ENCAP,            /* struct xfrm_algo + struct xfrm_encap_tmpl */
+        XFRMA_TMPL,             /* 1 or more struct xfrm_user_tmpl */
+        __XFRMA_MAX
+
+#define XFRMA_MAX (__XFRMA_MAX - 1)
+};
+
+struct xfrm_usersa_info {
+        struct xfrm_selector            sel;
+        struct xfrm_id                  id;
+        xfrm_address_t                  saddr;
+        struct xfrm_lifetime_cfg        lft;
+        struct xfrm_lifetime_cur        curlft;
+        struct xfrm_stats               stats;
+        __u32                           seq;
+        __u32                           reqid;
+        __u16                           family;
+        __u8                            mode; /* 0=transport,1=tunnel */
+        __u8                            replay_window;
+        __u8                            flags;
+#define XFRM_STATE_NOECN        1
+#define XFRM_STATE_DECAP_DSCP   2
+};
+
+struct xfrm_usersa_id {
+        xfrm_address_t                  daddr;
+        __u32                           spi;
+        __u16                           family;
+        __u8                            proto;
+};
+
+struct xfrm_userspi_info {
+        struct xfrm_usersa_info         info;
+        __u32                           min;
+        __u32                           max;
+};
+
+struct xfrm_userpolicy_info {
+        struct xfrm_selector            sel;
+        struct xfrm_lifetime_cfg        lft;
+        struct xfrm_lifetime_cur        curlft;
+        __u32                           priority;
+        __u32                           index;
+        __u8                            dir;
+        __u8                            action;
+#define XFRM_POLICY_ALLOW       0
+#define XFRM_POLICY_BLOCK       1
+        __u8                            flags;
+#define XFRM_POLICY_LOCALOK     1       /* Allow user to override global policy */
+        __u8                            share;
+};
+
+struct xfrm_userpolicy_id {
+        struct xfrm_selector            sel;
+        __u32                           index;
+        __u8                            dir;
+};
+
+struct xfrm_user_acquire {
+        struct xfrm_id                  id;
+        xfrm_address_t                  saddr;
+        struct xfrm_selector            sel;
+        struct xfrm_userpolicy_info     policy;
+        __u32                           aalgos;
+        __u32                           ealgos;
+        __u32                           calgos;
+        __u32                           seq;
+};
+
+struct xfrm_user_expire {
+        struct xfrm_usersa_info         state;
+        __u8                            hard;
+};
+
+struct xfrm_user_polexpire {
+        struct xfrm_userpolicy_info     pol;
+        __u8                            hard;
+};
+
+struct xfrm_usersa_flush {
+        __u8                            proto;
+};
+
+#define XFRMGRP_ACQUIRE         1
+#define XFRMGRP_EXPIRE          2
+
+#endif /* _LINUX_XFRM_H */
diff --git a/include/linux/yam.h b/include/linux/yam.h
new file mode 100644
index 000000000000..7fe28228b274
--- /dev/null
+++ b/include/linux/yam.h
@@ -0,0 +1,82 @@
+/*****************************************************************************/
+
+/*
+ *      yam.h  -- YAM radio modem driver.
+ *
+ *      Copyright (C) 1998 Frederic Rible F1OAT (frible@teaser.fr)
+ *      Adapted from baycom.c driver written by Thomas Sailer (sailer@ife.ee.ethz.ch)
+ *
+ *      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; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Please note that the GPL allows you to use the driver, NOT the radio.
+ *  In order to use the radio, you need a license from the communications
+ *  authority of your country.
+ *
+ *
+ */
+
+/*****************************************************************************/
+
+#define SIOCYAMRESERVED (0)
+#define SIOCYAMSCFG     (1)     /* Set configuration */
+#define SIOCYAMGCFG     (2)     /* Get configuration */
+#define SIOCYAMSMCS     (3)     /* Set mcs data */
+
+#define YAM_IOBASE   (1 << 0)
+#define YAM_IRQ      (1 << 1)
+#define YAM_BITRATE  (1 << 2) /* Bit rate of radio port ->57600 */
+#define YAM_MODE     (1 << 3) /* 0=simplex 1=duplex 2=duplex+tempo */
+#define YAM_HOLDDLY  (1 << 4) /* duplex tempo (sec) */
+#define YAM_TXDELAY  (1 << 5) /* Tx Delay (ms) */
+#define YAM_TXTAIL   (1 << 6) /* Tx Tail  (ms) */
+#define YAM_PERSIST  (1 << 7) /* Persist  (ms) */
+#define YAM_SLOTTIME (1 << 8) /* Slottime (ms) */
+#define YAM_BAUDRATE (1 << 9) /* Baud rate of rs232 port ->115200 */
+
+#define YAM_MAXBITRATE  57600
+#define YAM_MAXBAUDRATE 115200
+#define YAM_MAXMODE     2
+#define YAM_MAXHOLDDLY  99
+#define YAM_MAXTXDELAY  999
+#define YAM_MAXTXTAIL   999
+#define YAM_MAXPERSIST  255
+#define YAM_MAXSLOTTIME 999
+
+#define YAM_FPGA_SIZE   5302
+
+struct yamcfg {
+        unsigned int mask;              /* Mask of commands */
+        unsigned int iobase;    /* IO Base of COM port */
+        unsigned int irq;               /* IRQ of COM port */
+        unsigned int bitrate;   /* Bit rate of radio port */
+        unsigned int baudrate;  /* Baud rate of the RS232 port */
+        unsigned int txdelay;   /* TxDelay */
+        unsigned int txtail;    /* TxTail */
+        unsigned int persist;   /* Persistence */
+        unsigned int slottime;  /* Slottime */
+        unsigned int mode;              /* mode 0 (simp), 1(Dupl), 2(Dupl+delay) */
+        unsigned int holddly;   /* PTT delay in FullDuplex 2 mode */
+};
+
+struct yamdrv_ioctl_cfg {
+        int cmd;
+        struct yamcfg cfg;
+};
+
+struct yamdrv_ioctl_mcs {
+        int cmd;
+        int bitrate;
+        unsigned char bits[YAM_FPGA_SIZE];
+};
diff --git a/include/linux/zconf.h b/include/linux/zconf.h
new file mode 100644
index 000000000000..f1cfd66b9554
--- /dev/null
+++ b/include/linux/zconf.h
@@ -0,0 +1,45 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id$ */
+
+#ifndef _ZCONF_H
+#define _ZCONF_H
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  define MAX_MEM_LEVEL 8
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+                        /* Type declarations */
+
+typedef unsigned char  Byte;  /* 8 bits */
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+typedef void     *voidp;
+
+#endif /* _ZCONF_H */
diff --git a/include/linux/zftape.h b/include/linux/zftape.h
new file mode 100644
index 000000000000..b057c65366c6
--- /dev/null
+++ b/include/linux/zftape.h
@@ -0,0 +1,87 @@
+#ifndef _ZFTAPE_H
+#define _ZFTAPE_H
+
+/*
+ * Copyright (C) 1996, 1997 Claus-Justus Heine.
+
+ 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; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ *
+ * $Source: /homes/cvs/ftape-stacked/include/linux/zftape.h,v $
+ * $Revision: 1.12 $
+ * $Date: 1997/10/21 11:02:37 $
+ *
+ *      Special ioctl and other global info for the zftape VFS
+ *      interface for the QIC-40/80/3010/3020 floppy-tape driver for
+ *      Linux.
+ */
+
+#define ZFTAPE_VERSION  "zftape for " FTAPE_VERSION
+
+#include <linux/ftape.h>
+
+#define ZFTAPE_LABEL       "Ftape - The Linux Floppy Tape Project!"
+
+/* Bits of the minor device number that control the operation mode */
+#define ZFT_Q80_MODE            (1 << 3)
+#define ZFT_ZIP_MODE            (1 << 4)
+#define ZFT_RAW_MODE            (1 << 5)
+#define ZFT_MINOR_OP_MASK       (ZFT_Q80_MODE   |       \
+                                 ZFT_ZIP_MODE   |       \
+                                 ZFT_RAW_MODE)
+#define ZFT_MINOR_MASK          (FTAPE_SEL_MASK         |       \
+                                 ZFT_MINOR_OP_MASK      |       \
+                                 FTAPE_NO_REWIND)
+
+#ifdef ZFT_OBSOLETE
+struct mtblksz {
+        unsigned int mt_blksz;
+};
+#define MTIOC_ZFTAPE_GETBLKSZ _IOR('m', 104, struct mtblksz)
+#endif
+
+#ifdef __KERNEL__
+
+extern int zft_init(void);
+
+static inline __s64 zft_div_blksz(__s64 value, __u32 blk_sz)
+{
+        if (blk_sz == 1) {
+                return value;
+        } else {
+                return (__s64)(((__u32)(value >> 10) + (blk_sz >> 10) - 1) 
+                               / (blk_sz >> 10));
+        } 
+}
+
+static inline __s64 zft_mul_blksz(__s64 value, __u32 blk_sz)
+{
+        if (blk_sz == 1) {
+                return value;
+        } else {
+                /*  if blk_sz != 1, then it is a multiple of 1024. In
+                 *  this case, `value' will also fit into 32 bits.
+                 * 
+                 *  Actually, this limits the capacity to 42
+                 *  bits. This is (2^32)*1024, roughly a thousand
+                 *  times 2GB, or 3 Terabytes. Hopefully this is enough
+                 */
+                return(__s64)(((__u32)(value)*(blk_sz>>10))<<10);
+        }
+}
+
+#endif
+
+#endif
diff --git a/include/linux/zlib.h b/include/linux/zlib.h
new file mode 100644
index 000000000000..850076ea14d3
--- /dev/null
+++ b/include/linux/zlib.h
@@ -0,0 +1,637 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.3, July 9th, 1998
+
+  Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include <linux/zconf.h>
+
+#define ZLIB_VERSION "1.1.3"
+
+/* 
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Byte    *next_in;   /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Byte    *next_out;  /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state *state; /* not visible by applications */
+
+    void     *workspace; /* memory allocated for this stream */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_PACKET_FLUSH  2
+#define Z_SYNC_FLUSH    3
+#define Z_FULL_FLUSH    4
+#define Z_FINISH        5
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+                        /* basic functions */
+
+extern const char * zlib_zlibVersion (void);
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+extern int zlib_deflate_workspacesize (void);
+/*
+   Returns the number of bytes that needs to be allocated for a per-
+   stream workspace.  A pointer to this number of bytes should be
+   returned in stream->workspace before calling zlib_deflateInit().
+*/
+
+/* 
+extern int deflateInit (z_streamp strm, int level);
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+extern int zlib_deflate (z_streamp strm, int flush);
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+  
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+extern int zlib_deflateEnd (z_streamp strm);
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+extern int zlib_inflate_workspacesize (void);
+/*
+   Returns the number of bytes that needs to be allocated for a per-
+   stream workspace.  A pointer to this number of bytes should be
+   returned in stream->workspace before calling zlib_inflateInit().
+*/
+
+/* 
+extern int zlib_inflateInit (z_streamp strm);
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, and workspace must be initialized before by
+   the caller. If next_in is not NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+extern int zlib_inflate (z_streamp strm, int flush);
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+extern int zlib_inflateEnd (z_streamp strm);
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*   
+extern int deflateInit2 (z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy);
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+                            
+extern int zlib_deflateSetDictionary (z_streamp strm,
+                                                     const Byte *dictionary,
+                                                     uInt  dictLength);
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+extern int zlib_deflateCopy (z_streamp dest, z_streamp source);
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+extern int zlib_deflateReset (z_streamp strm);
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*   
+extern int inflateInit2 (z_streamp strm, int  windowBits);
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+extern int zlib_inflateSetDictionary (z_streamp strm,
+                                                     const Byte *dictionary,
+                                                     uInt  dictLength);
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+extern int zlib_inflateSync (z_streamp strm);
+/* 
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+extern int zlib_inflateReset (z_streamp strm);
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+extern int zlib_inflateIncomp (z_stream *strm);
+/*
+     This function adds the data at next_in (avail_in bytes) to the output
+   history without performing any output.  There must be no pending output,
+   and the decompressor must be expecting to see the start of a block.
+   Calling this function is equivalent to decompressing a stored block
+   containing the data at next_in (except that the data is not output).
+*/
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+extern int zlib_deflateInit_ (z_streamp strm, int level,
+                                     const char *version, int stream_size);
+extern int zlib_inflateInit_ (z_streamp strm,
+                                     const char *version, int stream_size);
+extern int zlib_deflateInit2_ (z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size);
+extern int zlib_inflateInit2_ (z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size);
+#define zlib_deflateInit(strm, level) \
+        zlib_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
+#define zlib_inflateInit(strm) \
+        zlib_inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
+#define zlib_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        zlib_deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy), ZLIB_VERSION, sizeof(z_stream))
+#define zlib_inflateInit2(strm, windowBits) \
+        zlib_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+extern const char  * zlib_zError           (int err);
+extern int           zlib_inflateSyncPoint (z_streamp z);
+extern const uLong * zlib_get_crc_table    (void);
+
+#endif /* _ZLIB_H */
diff --git a/include/linux/zorro.h b/include/linux/zorro.h
new file mode 100644
index 000000000000..ba5b72768bbe
--- /dev/null
+++ b/include/linux/zorro.h
@@ -0,0 +1,329 @@
+/*
+ *  linux/zorro.h -- Amiga AutoConfig (Zorro) Bus Definitions
+ *
+ *  Copyright (C) 1995--2003 Geert Uytterhoeven
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive
+ *  for more details.
+ */
+
+#ifndef _LINUX_ZORRO_H
+#define _LINUX_ZORRO_H
+
+#ifndef __ASSEMBLY__
+
+#include <linux/device.h>
+
+
+    /*
+     *  Each Zorro board has a 32-bit ID of the form
+     *
+     *      mmmmmmmmmmmmmmmmppppppppeeeeeeee
+     *
+     *  with
+     *
+     *      mmmmmmmmmmmmmmmm    16-bit Manufacturer ID (assigned by CBM (sigh))
+     *      pppppppp            8-bit Product ID (assigned by manufacturer)
+     *      eeeeeeee            8-bit Extended Product ID (currently only used
+     *                          for some GVP boards)
+     */
+
+
+#define ZORRO_MANUF(id)         ((id) >> 16)
+#define ZORRO_PROD(id)          (((id) >> 8) & 0xff)
+#define ZORRO_EPC(id)           ((id) & 0xff)
+
+#define ZORRO_ID(manuf, prod, epc) \
+    ((ZORRO_MANUF_##manuf << 16) | ((prod) << 8) | (epc))
+
+typedef __u32 zorro_id;
+
+
+#define ZORRO_WILDCARD          (0xffffffff)    /* not official */
+
+/* Include the ID list */
+#include <linux/zorro_ids.h>
+
+
+    /*
+     *  GVP identifies most of its products through the 'extended product code'
+     *  (epc). The epc has to be ANDed with the GVP_PRODMASK before the
+     *  identification.
+     */
+
+#define GVP_PRODMASK                    (0xf8)
+#define GVP_SCSICLKMASK                 (0x01)
+
+enum GVP_flags {
+    GVP_IO              = 0x01,
+    GVP_ACCEL           = 0x02,
+    GVP_SCSI            = 0x04,
+    GVP_24BITDMA        = 0x08,
+    GVP_25BITDMA        = 0x10,
+    GVP_NOBANK          = 0x20,
+    GVP_14MHZ           = 0x40,
+};
+
+
+struct Node {
+    struct  Node *ln_Succ;      /* Pointer to next (successor) */
+    struct  Node *ln_Pred;      /* Pointer to previous (predecessor) */
+    __u8    ln_Type;
+    __s8    ln_Pri;             /* Priority, for sorting */
+    __s8    *ln_Name;           /* ID string, null terminated */
+} __attribute__ ((packed));
+
+struct ExpansionRom {
+    /* -First 16 bytes of the expansion ROM */
+    __u8  er_Type;              /* Board type, size and flags */
+    __u8  er_Product;           /* Product number, assigned by manufacturer */
+    __u8  er_Flags;             /* Flags */
+    __u8  er_Reserved03;        /* Must be zero ($ff inverted) */
+    __u16 er_Manufacturer;      /* Unique ID, ASSIGNED BY COMMODORE-AMIGA! */
+    __u32 er_SerialNumber;      /* Available for use by manufacturer */
+    __u16 er_InitDiagVec;       /* Offset to optional "DiagArea" structure */
+    __u8  er_Reserved0c;
+    __u8  er_Reserved0d;
+    __u8  er_Reserved0e;
+    __u8  er_Reserved0f;
+} __attribute__ ((packed));
+
+/* er_Type board type bits */
+#define ERT_TYPEMASK    0xc0
+#define ERT_ZORROII     0xc0
+#define ERT_ZORROIII    0x80
+
+/* other bits defined in er_Type */
+#define ERTB_MEMLIST    5               /* Link RAM into free memory list */
+#define ERTF_MEMLIST    (1<<5)
+
+struct ConfigDev {
+    struct Node         cd_Node;
+    __u8                cd_Flags;       /* (read/write) */
+    __u8                cd_Pad;         /* reserved */
+    struct ExpansionRom cd_Rom;         /* copy of board's expansion ROM */
+    void                *cd_BoardAddr;  /* where in memory the board was placed */
+    __u32               cd_BoardSize;   /* size of board in bytes */
+    __u16               cd_SlotAddr;    /* which slot number (PRIVATE) */
+    __u16               cd_SlotSize;    /* number of slots (PRIVATE) */
+    void                *cd_Driver;     /* pointer to node of driver */
+    struct ConfigDev    *cd_NextCD;     /* linked list of drivers to config */
+    __u32               cd_Unused[4];   /* for whatever the driver wants */
+} __attribute__ ((packed));
+
+#else /* __ASSEMBLY__ */
+
+LN_Succ         = 0
+LN_Pred         = LN_Succ+4
+LN_Type         = LN_Pred+4
+LN_Pri          = LN_Type+1
+LN_Name         = LN_Pri+1
+LN_sizeof       = LN_Name+4
+
+ER_Type         = 0
+ER_Product      = ER_Type+1
+ER_Flags        = ER_Product+1
+ER_Reserved03   = ER_Flags+1
+ER_Manufacturer = ER_Reserved03+1
+ER_SerialNumber = ER_Manufacturer+2
+ER_InitDiagVec  = ER_SerialNumber+4
+ER_Reserved0c   = ER_InitDiagVec+2
+ER_Reserved0d   = ER_Reserved0c+1
+ER_Reserved0e   = ER_Reserved0d+1
+ER_Reserved0f   = ER_Reserved0e+1
+ER_sizeof       = ER_Reserved0f+1
+
+CD_Node         = 0
+CD_Flags        = CD_Node+LN_sizeof
+CD_Pad          = CD_Flags+1
+CD_Rom          = CD_Pad+1
+CD_BoardAddr    = CD_Rom+ER_sizeof
+CD_BoardSize    = CD_BoardAddr+4
+CD_SlotAddr     = CD_BoardSize+4
+CD_SlotSize     = CD_SlotAddr+2
+CD_Driver       = CD_SlotSize+2
+CD_NextCD       = CD_Driver+4
+CD_Unused       = CD_NextCD+4
+CD_sizeof       = CD_Unused+(4*4)
+
+#endif /* __ASSEMBLY__ */
+
+#ifndef __ASSEMBLY__
+
+#define ZORRO_NUM_AUTO          16
+
+#ifdef __KERNEL__
+
+#include <linux/init.h>
+#include <linux/ioport.h>
+
+#include <asm/zorro.h>
+
+
+    /*
+     *  Zorro devices
+     */
+
+struct zorro_dev {
+    struct ExpansionRom rom;
+    zorro_id id;
+    struct zorro_driver *driver;        /* which driver has allocated this device */
+    struct device dev;                  /* Generic device interface */
+    u16 slotaddr;
+    u16 slotsize;
+    char name[64];
+    struct resource resource;
+};
+
+#define to_zorro_dev(n) container_of(n, struct zorro_dev, dev)
+
+
+    /*
+     *  Zorro bus
+     */
+
+struct zorro_bus {
+    struct list_head devices;           /* list of devices on this bus */
+    unsigned int num_resources;         /* number of resources */
+    struct resource resources[4];       /* address space routed to this bus */
+    struct device dev;
+    char name[10];
+};
+
+extern struct zorro_bus zorro_bus;      /* single Zorro bus */
+extern struct bus_type zorro_bus_type;
+
+
+    /*
+     *  Zorro device IDs
+     */
+
+struct zorro_device_id {
+        zorro_id id;                    /* Device ID or ZORRO_WILDCARD */
+        unsigned long driver_data;      /* Data private to the driver */
+};
+
+
+    /*
+     *  Zorro device drivers
+     */
+
+struct zorro_driver {
+    struct list_head node;
+    char *name;
+    const struct zorro_device_id *id_table;     /* NULL if wants all devices */
+    int (*probe)(struct zorro_dev *z, const struct zorro_device_id *id);        /* New device inserted */
+    void (*remove)(struct zorro_dev *z);        /* Device removed (NULL if not a hot-plug capable driver) */
+    struct device_driver driver;
+};
+
+#define to_zorro_driver(drv)    container_of(drv, struct zorro_driver, driver)
+
+
+#define zorro_for_each_dev(dev) \
+        for (dev = &zorro_autocon[0]; dev < zorro_autocon+zorro_num_autocon; dev++)
+
+
+/* New-style probing */
+extern int zorro_register_driver(struct zorro_driver *);
+extern void zorro_unregister_driver(struct zorro_driver *);
+extern const struct zorro_device_id *zorro_match_device(const struct zorro_device_id *ids, const struct zorro_dev *z);
+static inline struct zorro_driver *zorro_dev_driver(const struct zorro_dev *z)
+{
+    return z->driver;
+}
+
+
+extern unsigned int zorro_num_autocon;  /* # of autoconfig devices found */
+extern struct zorro_dev zorro_autocon[ZORRO_NUM_AUTO];
+
+
+    /*
+     *  Zorro Functions
+     */
+
+extern struct zorro_dev *zorro_find_device(zorro_id id,
+                                           struct zorro_dev *from);
+
+#define zorro_resource_start(z) ((z)->resource.start)
+#define zorro_resource_end(z)   ((z)->resource.end)
+#define zorro_resource_len(z)   ((z)->resource.end-(z)->resource.start+1)
+#define zorro_resource_flags(z) ((z)->resource.flags)
+
+#define zorro_request_device(z, name) \
+    request_mem_region(zorro_resource_start(z), zorro_resource_len(z), name)
+#define zorro_release_device(z) \
+    release_mem_region(zorro_resource_start(z), zorro_resource_len(z))
+
+/* Similar to the helpers above, these manipulate per-zorro_dev
+ * driver-specific data.  They are really just a wrapper around
+ * the generic device structure functions of these calls.
+ */
+static inline void *zorro_get_drvdata (struct zorro_dev *z)
+{
+        return dev_get_drvdata(&z->dev);
+}
+
+static inline void zorro_set_drvdata (struct zorro_dev *z, void *data)
+{
+        dev_set_drvdata(&z->dev, data);
+}
+
+
+/*
+ * A helper function which helps ensure correct zorro_driver
+ * setup and cleanup for commonly-encountered hotplug/modular cases
+ *
+ * This MUST stay in a header, as it checks for -DMODULE
+ */
+static inline int zorro_module_init(struct zorro_driver *drv)
+{
+        int rc = zorro_register_driver(drv);
+
+        if (rc > 0)
+                return 0;
+
+        /* iff CONFIG_HOTPLUG and built into kernel, we should
+         * leave the driver around for future hotplug events.
+         * For the module case, a hotplug daemon of some sort
+         * should load a module in response to an insert event. */
+#if defined(CONFIG_HOTPLUG) && !defined(MODULE)
+        if (rc == 0)
+                return 0;
+#else
+        if (rc == 0)
+                rc = -ENODEV;
+#endif
+
+        /* if we get here, we need to clean up Zorro driver instance
+         * and return some sort of error */
+        zorro_unregister_driver(drv);
+
+        return rc;
+}
+
+
+    /*
+     *  Bitmask indicating portions of available Zorro II RAM that are unused
+     *  by the system. Every bit represents a 64K chunk, for a maximum of 8MB
+     *  (128 chunks, physical 0x00200000-0x009fffff).
+     *
+     *  If you want to use (= allocate) portions of this RAM, you should clear
+     *  the corresponding bits.
+     */
+
+extern DECLARE_BITMAP(zorro_unused_z2ram, 128);
+
+#define Z2RAM_START             (0x00200000)
+#define Z2RAM_END               (0x00a00000)
+#define Z2RAM_SIZE              (0x00800000)
+#define Z2RAM_CHUNKSIZE         (0x00010000)
+#define Z2RAM_CHUNKMASK         (0x0000ffff)
+#define Z2RAM_CHUNKSHIFT        (16)
+
+
+#endif /* !__ASSEMBLY__ */
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_ZORRO_H */
diff --git a/include/linux/zorro_ids.h b/include/linux/zorro_ids.h
new file mode 100644
index 000000000000..7e749088910d
--- /dev/null
+++ b/include/linux/zorro_ids.h
@@ -0,0 +1,552 @@
+/*
+ *  Zorro board IDs
+ *
+ *  Please keep sorted.
+ */
+
+
+#define ZORRO_MANUF_PACIFIC_PERIPHERALS                         0x00D3
+#define  ZORRO_PROD_PACIFIC_PERIPHERALS_SE_2000_A500            ZORRO_ID(PACIFIC_PERIPHERALS, 0x00, 0)
+#define  ZORRO_PROD_PACIFIC_PERIPHERALS_SCSI                    ZORRO_ID(PACIFIC_PERIPHERALS, 0x0A, 0)
+
+#define ZORRO_MANUF_MACROSYSTEMS_USA_2                          0x0100
+#define  ZORRO_PROD_MACROSYSTEMS_WARP_ENGINE                    ZORRO_ID(MACROSYSTEMS_USA_2, 0x13, 0)
+
+#define ZORRO_MANUF_KUPKE_1                                     0x00DD
+#define  ZORRO_PROD_KUPKE_GOLEM_RAM_BOX_2MB                     ZORRO_ID(KUPKE_1, 0x00, 0)
+
+#define ZORRO_MANUF_MEMPHIS                                     0x0100
+#define  ZORRO_PROD_MEMPHIS_STORMBRINGER                        ZORRO_ID(MEMPHIS, 0x00, 0)
+
+#define ZORRO_MANUF_3_STATE                                     0x0200
+#define  ZORRO_PROD_3_STATE_MEGAMIX_2000                        ZORRO_ID(3_STATE, 0x02, 0)
+
+#define ZORRO_MANUF_COMMODORE_BRAUNSCHWEIG                      0x0201
+#define  ZORRO_PROD_CBM_A2088_A2286                             ZORRO_ID(COMMODORE_BRAUNSCHWEIG, 0x01, 0)
+#define  ZORRO_PROD_CBM_A2286                                   ZORRO_ID(COMMODORE_BRAUNSCHWEIG, 0x02, 0)
+#define  ZORRO_PROD_CBM_A4091_1                                 ZORRO_ID(COMMODORE_BRAUNSCHWEIG, 0x54, 0)
+#define  ZORRO_PROD_CBM_A2386SX_1                               ZORRO_ID(COMMODORE_BRAUNSCHWEIG, 0x67, 0)
+
+#define ZORRO_MANUF_COMMODORE_WEST_CHESTER_1                    0x0202
+#define  ZORRO_PROD_CBM_A2090A                                  ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x01, 0)
+#define  ZORRO_PROD_CBM_A590_A2091_1                            ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x02, 0)
+#define  ZORRO_PROD_CBM_A590_A2091_2                            ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x03, 0)
+#define  ZORRO_PROD_CBM_A2090B                                  ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x04, 0)
+#define  ZORRO_PROD_CBM_A2060                                   ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x09, 0)
+#define  ZORRO_PROD_CBM_A590_A2052_A2058_A2091                  ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x0A, 0)
+#define  ZORRO_PROD_CBM_A560_RAM                                ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x20, 0)
+#define  ZORRO_PROD_CBM_A2232_PROTOTYPE                         ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x45, 0)
+#define  ZORRO_PROD_CBM_A2232                                   ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x46, 0)
+#define  ZORRO_PROD_CBM_A2620                                   ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x50, 0)
+#define  ZORRO_PROD_CBM_A2630                                   ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x51, 0)
+#define  ZORRO_PROD_CBM_A4091_2                                 ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x54, 0)
+#define  ZORRO_PROD_CBM_A2065_1                                 ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x5A, 0)
+#define  ZORRO_PROD_CBM_ROMULATOR                               ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x60, 0)
+#define  ZORRO_PROD_CBM_A3000_TEST_FIXTURE                      ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x61, 0)
+#define  ZORRO_PROD_CBM_A2386SX_2                               ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x67, 0)
+#define  ZORRO_PROD_CBM_A2065_2                                 ZORRO_ID(COMMODORE_WEST_CHESTER_1, 0x70, 0)
+
+#define ZORRO_MANUF_COMMODORE_WEST_CHESTER_2                    0x0203
+#define  ZORRO_PROD_CBM_A2090A_CM                               ZORRO_ID(COMMODORE_WEST_CHESTER_2, 0x03, 0)
+
+#define ZORRO_MANUF_PROGRESSIVE_PERIPHERALS_AND_SYSTEMS_2       0x02F4
+#define  ZORRO_PROD_PPS_EXP8000                                 ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS_2, 0x02, 0)
+
+#define ZORRO_MANUF_KOLFF_COMPUTER_SUPPLIES                     0x02FF
+#define  ZORRO_PROD_KCS_POWER_PC_BOARD                          ZORRO_ID(KOLFF_COMPUTER_SUPPLIES, 0x00, 0)
+
+#define ZORRO_MANUF_CARDCO_1                                    0x03EC
+#define  ZORRO_PROD_CARDCO_KRONOS_2000_1                        ZORRO_ID(CARDCO_1, 0x04, 0)
+#define  ZORRO_PROD_CARDCO_A1000_1                              ZORRO_ID(CARDCO_1, 0x0C, 0)
+#define  ZORRO_PROD_CARDCO_ESCORT                               ZORRO_ID(CARDCO_1, 0x0E, 0)
+#define  ZORRO_PROD_CARDCO_A2410                                ZORRO_ID(CARDCO_1, 0xF5, 0)
+
+#define ZORRO_MANUF_A_SQUARED                                   0x03ED
+#define  ZORRO_PROD_A_SQUARED_LIVE_2000                         ZORRO_ID(A_SQUARED, 0x01, 0)
+
+#define ZORRO_MANUF_COMSPEC_COMMUNICATIONS                      0x03EE
+#define  ZORRO_PROD_COMSPEC_COMMUNICATIONS_AX2000               ZORRO_ID(COMSPEC_COMMUNICATIONS, 0x01, 0)
+
+#define ZORRO_MANUF_ANAKIN_RESEARCH                             0x03F1
+#define  ZORRO_PROD_ANAKIN_RESEARCH_EASYL                       ZORRO_ID(ANAKIN_RESEARCH, 0x01, 0)
+
+#define ZORRO_MANUF_MICROBOTICS                                 0x03F2
+#define  ZORRO_PROD_MICROBOTICS_STARBOARD_II                    ZORRO_ID(MICROBOTICS, 0x00, 0)
+#define  ZORRO_PROD_MICROBOTICS_STARDRIVE                       ZORRO_ID(MICROBOTICS, 0x02, 0)
+#define  ZORRO_PROD_MICROBOTICS_8_UP_A                          ZORRO_ID(MICROBOTICS, 0x03, 0)
+#define  ZORRO_PROD_MICROBOTICS_8_UP_Z                          ZORRO_ID(MICROBOTICS, 0x04, 0)
+#define  ZORRO_PROD_MICROBOTICS_DELTA_RAM                       ZORRO_ID(MICROBOTICS, 0x20, 0)
+#define  ZORRO_PROD_MICROBOTICS_8_STAR_RAM                      ZORRO_ID(MICROBOTICS, 0x40, 0)
+#define  ZORRO_PROD_MICROBOTICS_8_STAR                          ZORRO_ID(MICROBOTICS, 0x41, 0)
+#define  ZORRO_PROD_MICROBOTICS_VXL_RAM_32                      ZORRO_ID(MICROBOTICS, 0x44, 0)
+#define  ZORRO_PROD_MICROBOTICS_VXL_68030                       ZORRO_ID(MICROBOTICS, 0x45, 0)
+#define  ZORRO_PROD_MICROBOTICS_DELTA                           ZORRO_ID(MICROBOTICS, 0x60, 0)
+#define  ZORRO_PROD_MICROBOTICS_MBX_1200_1200Z_RAM              ZORRO_ID(MICROBOTICS, 0x81, 0)
+#define  ZORRO_PROD_MICROBOTICS_HARDFRAME_2000_1                ZORRO_ID(MICROBOTICS, 0x96, 0)
+#define  ZORRO_PROD_MICROBOTICS_HARDFRAME_2000_2                ZORRO_ID(MICROBOTICS, 0x9E, 0)
+#define  ZORRO_PROD_MICROBOTICS_MBX_1200_1200Z                  ZORRO_ID(MICROBOTICS, 0xC1, 0)
+
+#define ZORRO_MANUF_ACCESS_ASSOCIATES_ALEGRA                    0x03F4
+
+#define ZORRO_MANUF_EXPANSION_TECHNOLOGIES                      0x03F6
+
+#define ZORRO_MANUF_ASDG                                        0x03FF
+#define  ZORRO_PROD_ASDG_MEMORY_1                               ZORRO_ID(ASDG, 0x01, 0)
+#define  ZORRO_PROD_ASDG_MEMORY_2                               ZORRO_ID(ASDG, 0x02, 0)
+#define  ZORRO_PROD_ASDG_EB920_LAN_ROVER                        ZORRO_ID(ASDG, 0xFE, 0)
+#define  ZORRO_PROD_ASDG_GPIB_DUALIEEE488_TWIN_X                ZORRO_ID(ASDG, 0xFF, 0)
+
+#define ZORRO_MANUF_IMTRONICS_1                                 0x0404
+#define  ZORRO_PROD_IMTRONICS_HURRICANE_2800_1                  ZORRO_ID(IMTRONICS_1, 0x39, 0)
+#define  ZORRO_PROD_IMTRONICS_HURRICANE_2800_2                  ZORRO_ID(IMTRONICS_1, 0x57, 0)
+
+#define ZORRO_MANUF_CBM_UNIVERSITY_OF_LOWELL                    0x0406
+#define  ZORRO_PROD_CBM_A2410                                   ZORRO_ID(CBM_UNIVERSITY_OF_LOWELL, 0x00, 0)
+
+#define ZORRO_MANUF_AMERISTAR                                   0x041D
+#define  ZORRO_PROD_AMERISTAR_A2065                             ZORRO_ID(AMERISTAR, 0x01, 0)
+#define  ZORRO_PROD_AMERISTAR_A560                              ZORRO_ID(AMERISTAR, 0x09, 0)
+#define  ZORRO_PROD_AMERISTAR_A4066                             ZORRO_ID(AMERISTAR, 0x0A, 0)
+
+#define ZORRO_MANUF_SUPRA                                       0x0420
+#define  ZORRO_PROD_SUPRA_SUPRADRIVE_4x4                        ZORRO_ID(SUPRA, 0x01, 0)
+#define  ZORRO_PROD_SUPRA_1000_RAM                              ZORRO_ID(SUPRA, 0x02, 0)
+#define  ZORRO_PROD_SUPRA_2000_DMA                              ZORRO_ID(SUPRA, 0x03, 0)
+#define  ZORRO_PROD_SUPRA_500                                   ZORRO_ID(SUPRA, 0x05, 0)
+#define  ZORRO_PROD_SUPRA_500_SCSI                              ZORRO_ID(SUPRA, 0x08, 0)
+#define  ZORRO_PROD_SUPRA_500XP_2000_RAM                        ZORRO_ID(SUPRA, 0x09, 0)
+#define  ZORRO_PROD_SUPRA_500RX_2000_RAM                        ZORRO_ID(SUPRA, 0x0A, 0)
+#define  ZORRO_PROD_SUPRA_2400ZI                                ZORRO_ID(SUPRA, 0x0B, 0)
+#define  ZORRO_PROD_SUPRA_500XP_SUPRADRIVE_WORDSYNC             ZORRO_ID(SUPRA, 0x0C, 0)
+#define  ZORRO_PROD_SUPRA_SUPRADRIVE_WORDSYNC_II                ZORRO_ID(SUPRA, 0x0D, 0)
+#define  ZORRO_PROD_SUPRA_2400ZIPLUS                            ZORRO_ID(SUPRA, 0x10, 0)
+
+#define ZORRO_MANUF_COMPUTER_SYSTEMS_ASSOCIATES                 0x0422
+#define  ZORRO_PROD_CSA_MAGNUM                                  ZORRO_ID(COMPUTER_SYSTEMS_ASSOCIATES, 0x11, 0)
+#define  ZORRO_PROD_CSA_12_GAUGE                                ZORRO_ID(COMPUTER_SYSTEMS_ASSOCIATES, 0x15, 0)
+
+#define ZORRO_MANUF_MARC_MICHAEL_GROTH                          0x0439
+
+#define ZORRO_MANUF_M_TECH                                      0x0502
+#define  ZORRO_PROD_MTEC_AT500_1                                ZORRO_ID(M_TECH, 0x03, 0)
+
+#define ZORRO_MANUF_GREAT_VALLEY_PRODUCTS_1                     0x06E1
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_I                         ZORRO_ID(GREAT_VALLEY_PRODUCTS_1, 0x08, 0)
+
+#define ZORRO_MANUF_BYTEBOX                                     0x07DA
+#define  ZORRO_PROD_BYTEBOX_A500                                ZORRO_ID(BYTEBOX, 0x00, 0)
+
+#define ZORRO_MANUF_DKB_POWER_COMPUTING                         0x07DC
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_SECUREKEY               ZORRO_ID(DKB_POWER_COMPUTING, 0x09, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_DKM_3128                ZORRO_ID(DKB_POWER_COMPUTING, 0x0E, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_RAPID_FIRE              ZORRO_ID(DKB_POWER_COMPUTING, 0x0F, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_DKM_1202                ZORRO_ID(DKB_POWER_COMPUTING, 0x10, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_COBRA_VIPER_II_68EC030  ZORRO_ID(DKB_POWER_COMPUTING, 0x12, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_WILDFIRE_060_1          ZORRO_ID(DKB_POWER_COMPUTING, 0x17, 0)
+#define  ZORRO_PROD_DKB_POWER_COMPUTING_WILDFIRE_060_2          ZORRO_ID(DKB_POWER_COMPUTING, 0xFF, 0)
+
+#define ZORRO_MANUF_GREAT_VALLEY_PRODUCTS_2                     0x07E1
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_I_4K                      ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x01, 0)
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_I_16K_2                   ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x02, 0)
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_I_16K_3                   ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x03, 0)
+#define  ZORRO_PROD_GVP_IMPACT_3001_IDE_1                       ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x08, 0)
+#define  ZORRO_PROD_GVP_IMPACT_3001_RAM                         ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x09, 0)
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_II_RAM_1                  ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0A, 0)
+#define  ZORRO_PROD_GVP_EPC_BASE                                ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0)
+#define  ZORRO_PROD_GVP_GFORCE_040_1                            ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x20)
+#define  ZORRO_PROD_GVP_GFORCE_040_SCSI_1                       ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x30)
+#define  ZORRO_PROD_GVP_A1291                                   ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x40)
+#define  ZORRO_PROD_GVP_COMBO_030_R4                            ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x60)
+#define  ZORRO_PROD_GVP_COMBO_030_R4_SCSI                       ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x70)
+#define  ZORRO_PROD_GVP_PHONEPAK                                ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x78)
+#define  ZORRO_PROD_GVP_IO_EXTENDER                             ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0x98)
+#define  ZORRO_PROD_GVP_GFORCE_030                              ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xa0)
+#define  ZORRO_PROD_GVP_GFORCE_030_SCSI                         ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xb0)
+#define  ZORRO_PROD_GVP_A530                                    ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xc0)
+#define  ZORRO_PROD_GVP_A530_SCSI                               ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xd0)
+#define  ZORRO_PROD_GVP_COMBO_030_R3                            ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xe0)
+#define  ZORRO_PROD_GVP_COMBO_030_R3_SCSI                       ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xf0)
+#define  ZORRO_PROD_GVP_SERIES_II                               ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0B, 0xf8)
+#define  ZORRO_PROD_GVP_IMPACT_3001_IDE_2                       ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0D, 0)
+/*#define  ZORRO_PROD_GVP_A2000_030                             ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0D, 0)*/
+/*#define  ZORRO_PROD_GVP_GFORCE_040_SCSI_2                     ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x0D, 0)*/
+#define  ZORRO_PROD_GVP_GFORCE_040_060                          ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x16, 0)
+#define  ZORRO_PROD_GVP_IMPACT_VISION_24                        ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0x20, 0)
+#define  ZORRO_PROD_GVP_GFORCE_040_2                            ZORRO_ID(GREAT_VALLEY_PRODUCTS_2, 0xFF, 0)
+
+#define ZORRO_MANUF_CALIFORNIA_ACCESS_SYNERGY                   0x07E5
+#define  ZORRO_PROD_CALIFORNIA_ACCESS_SYNERGY_MALIBU            ZORRO_ID(CALIFORNIA_ACCESS_SYNERGY, 0x01, 0)
+
+#define ZORRO_MANUF_XETEC                                       0x07E6
+#define  ZORRO_PROD_XETEC_FASTCARD                              ZORRO_ID(XETEC, 0x01, 0)
+#define  ZORRO_PROD_XETEC_FASTCARD_RAM                          ZORRO_ID(XETEC, 0x02, 0)
+#define  ZORRO_PROD_XETEC_FASTCARD_PLUS                         ZORRO_ID(XETEC, 0x03, 0)
+
+#define ZORRO_MANUF_PROGRESSIVE_PERIPHERALS_AND_SYSTEMS         0x07EA
+#define  ZORRO_PROD_PPS_MERCURY                                 ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS, 0x00, 0)
+#define  ZORRO_PROD_PPS_A3000_68040                             ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS, 0x01, 0)
+#define  ZORRO_PROD_PPS_A2000_68040                             ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS, 0x69, 0)
+#define  ZORRO_PROD_PPS_ZEUS                                    ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS, 0x96, 0)
+#define  ZORRO_PROD_PPS_A500_68040                              ZORRO_ID(PROGRESSIVE_PERIPHERALS_AND_SYSTEMS, 0xBB, 0)
+
+#define ZORRO_MANUF_XEBEC                                       0x07EC
+
+#define ZORRO_MANUF_SPIRIT_TECHNOLOGY                           0x07F2
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_INSIDER_IN1000            ZORRO_ID(SPIRIT_TECHNOLOGY, 0x01, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_INSIDER_IN500             ZORRO_ID(SPIRIT_TECHNOLOGY, 0x02, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_SIN500                    ZORRO_ID(SPIRIT_TECHNOLOGY, 0x03, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_HDA_506                   ZORRO_ID(SPIRIT_TECHNOLOGY, 0x04, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_AX_S                      ZORRO_ID(SPIRIT_TECHNOLOGY, 0x05, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_OCTABYTE                  ZORRO_ID(SPIRIT_TECHNOLOGY, 0x06, 0)
+#define  ZORRO_PROD_SPIRIT_TECHNOLOGY_INMATE                    ZORRO_ID(SPIRIT_TECHNOLOGY, 0x08, 0)
+
+#define ZORRO_MANUF_SPIRIT_TECHNOLOGY_2                         0x07F3
+
+#define ZORRO_MANUF_BSC_ALFADATA_1                              0x07FE
+#define  ZORRO_PROD_BSC_ALF_3_1                                 ZORRO_ID(BSC_ALFADATA_1, 0x03, 0)
+
+#define ZORRO_MANUF_BSC_ALFADATA_2                              0x0801
+#define  ZORRO_PROD_BSC_ALF_2_1                                 ZORRO_ID(BSC_ALFADATA_2, 0x01, 0)
+#define  ZORRO_PROD_BSC_ALF_2_2                                 ZORRO_ID(BSC_ALFADATA_2, 0x02, 0)
+#define  ZORRO_PROD_BSC_ALF_3_2                                 ZORRO_ID(BSC_ALFADATA_2, 0x03, 0)
+
+#define ZORRO_MANUF_CARDCO_2                                    0x0802
+#define  ZORRO_PROD_CARDCO_KRONOS_2000_2                        ZORRO_ID(CARDCO_2, 0x04, 0)
+#define  ZORRO_PROD_CARDCO_A1000_2                              ZORRO_ID(CARDCO_2, 0x0C, 0)
+
+#define ZORRO_MANUF_JOCHHEIM                                    0x0804
+#define  ZORRO_PROD_JOCHHEIM_RAM                                ZORRO_ID(JOCHHEIM, 0x01, 0)
+
+#define ZORRO_MANUF_CHECKPOINT_TECHNOLOGIES                     0x0807
+#define  ZORRO_PROD_CHECKPOINT_TECHNOLOGIES_SERIAL_SOLUTION     ZORRO_ID(CHECKPOINT_TECHNOLOGIES, 0x00, 0)
+
+#define ZORRO_MANUF_EDOTRONIK                                   0x0810
+#define  ZORRO_PROD_EDOTRONIK_IEEE_488                          ZORRO_ID(EDOTRONIK, 0x01, 0)
+#define  ZORRO_PROD_EDOTRONIK_8032                              ZORRO_ID(EDOTRONIK, 0x02, 0)
+#define  ZORRO_PROD_EDOTRONIK_MULTISERIAL                       ZORRO_ID(EDOTRONIK, 0x03, 0)
+#define  ZORRO_PROD_EDOTRONIK_VIDEODIGITIZER                    ZORRO_ID(EDOTRONIK, 0x04, 0)
+#define  ZORRO_PROD_EDOTRONIK_PARALLEL_IO                       ZORRO_ID(EDOTRONIK, 0x05, 0)
+#define  ZORRO_PROD_EDOTRONIK_PIC_PROTOYPING                    ZORRO_ID(EDOTRONIK, 0x06, 0)
+#define  ZORRO_PROD_EDOTRONIK_ADC                               ZORRO_ID(EDOTRONIK, 0x07, 0)
+#define  ZORRO_PROD_EDOTRONIK_VME                               ZORRO_ID(EDOTRONIK, 0x08, 0)
+#define  ZORRO_PROD_EDOTRONIK_DSP96000                          ZORRO_ID(EDOTRONIK, 0x09, 0)
+
+#define ZORRO_MANUF_NES_INC                                     0x0813
+#define  ZORRO_PROD_NES_INC_RAM                                 ZORRO_ID(NES_INC, 0x00, 0)
+
+#define ZORRO_MANUF_ICD                                         0x0817
+#define  ZORRO_PROD_ICD_ADVANTAGE_2000_SCSI                     ZORRO_ID(ICD, 0x01, 0)
+#define  ZORRO_PROD_ICD_ADVANTAGE_IDE                           ZORRO_ID(ICD, 0x03, 0)
+#define  ZORRO_PROD_ICD_ADVANTAGE_2080_RAM                      ZORRO_ID(ICD, 0x04, 0)
+
+#define ZORRO_MANUF_KUPKE_2                                     0x0819
+#define  ZORRO_PROD_KUPKE_OMTI                                  ZORRO_ID(KUPKE_2, 0x01, 0)
+#define  ZORRO_PROD_KUPKE_SCSI_II                               ZORRO_ID(KUPKE_2, 0x02, 0)
+#define  ZORRO_PROD_KUPKE_GOLEM_BOX                             ZORRO_ID(KUPKE_2, 0x03, 0)
+#define  ZORRO_PROD_KUPKE_030_882                               ZORRO_ID(KUPKE_2, 0x04, 0)
+#define  ZORRO_PROD_KUPKE_SCSI_AT                               ZORRO_ID(KUPKE_2, 0x05, 0)
+
+#define ZORRO_MANUF_GREAT_VALLEY_PRODUCTS_3                     0x081D
+#define  ZORRO_PROD_GVP_A2000_RAM8                              ZORRO_ID(GREAT_VALLEY_PRODUCTS_3, 0x09, 0)
+#define  ZORRO_PROD_GVP_IMPACT_SERIES_II_RAM_2                  ZORRO_ID(GREAT_VALLEY_PRODUCTS_3, 0x0A, 0)
+
+#define ZORRO_MANUF_INTERWORKS_NETWORK                          0x081E
+
+#define ZORRO_MANUF_HARDITAL_SYNTHESIS                          0x0820
+#define  ZORRO_PROD_HARDITAL_SYNTHESIS_TQM_68030_68882          ZORRO_ID(HARDITAL_SYNTHESIS, 0x14, 0)
+
+#define ZORRO_MANUF_APPLIED_ENGINEERING                         0x0828
+#define  ZORRO_PROD_APPLIED_ENGINEERING_DL2000                  ZORRO_ID(APPLIED_ENGINEERING, 0x10, 0)
+#define  ZORRO_PROD_APPLIED_ENGINEERING_RAM_WORKS               ZORRO_ID(APPLIED_ENGINEERING, 0xE0, 0)
+
+#define ZORRO_MANUF_BSC_ALFADATA_3                              0x082C
+#define  ZORRO_PROD_BSC_OKTAGON_2008                            ZORRO_ID(BSC_ALFADATA_3, 0x05, 0)
+#define  ZORRO_PROD_BSC_TANDEM_AT_2008_508                      ZORRO_ID(BSC_ALFADATA_3, 0x06, 0)
+#define  ZORRO_PROD_BSC_ALFA_RAM_1200                           ZORRO_ID(BSC_ALFADATA_3, 0x07, 0)
+#define  ZORRO_PROD_BSC_OKTAGON_2008_RAM                        ZORRO_ID(BSC_ALFADATA_3, 0x08, 0)
+#define  ZORRO_PROD_BSC_MULTIFACE_I                             ZORRO_ID(BSC_ALFADATA_3, 0x10, 0)
+#define  ZORRO_PROD_BSC_MULTIFACE_II                            ZORRO_ID(BSC_ALFADATA_3, 0x11, 0)
+#define  ZORRO_PROD_BSC_MULTIFACE_III                           ZORRO_ID(BSC_ALFADATA_3, 0x12, 0)
+#define  ZORRO_PROD_BSC_FRAMEMASTER_II                          ZORRO_ID(BSC_ALFADATA_3, 0x20, 0)
+#define  ZORRO_PROD_BSC_GRAFFITI_RAM                            ZORRO_ID(BSC_ALFADATA_3, 0x21, 0)
+#define  ZORRO_PROD_BSC_GRAFFITI_REG                            ZORRO_ID(BSC_ALFADATA_3, 0x22, 0)
+#define  ZORRO_PROD_BSC_ISDN_MASTERCARD                         ZORRO_ID(BSC_ALFADATA_3, 0x40, 0)
+#define  ZORRO_PROD_BSC_ISDN_MASTERCARD_II                      ZORRO_ID(BSC_ALFADATA_3, 0x41, 0)
+
+#define ZORRO_MANUF_PHOENIX                                     0x0835
+#define  ZORRO_PROD_PHOENIX_ST506                               ZORRO_ID(PHOENIX, 0x21, 0)
+#define  ZORRO_PROD_PHOENIX_SCSI                                ZORRO_ID(PHOENIX, 0x22, 0)
+#define  ZORRO_PROD_PHOENIX_RAM                                 ZORRO_ID(PHOENIX, 0xBE, 0)
+
+#define ZORRO_MANUF_ADVANCED_STORAGE_SYSTEMS                    0x0836
+#define  ZORRO_PROD_ADVANCED_STORAGE_SYSTEMS_NEXUS              ZORRO_ID(ADVANCED_STORAGE_SYSTEMS, 0x01, 0)
+#define  ZORRO_PROD_ADVANCED_STORAGE_SYSTEMS_NEXUS_RAM          ZORRO_ID(ADVANCED_STORAGE_SYSTEMS, 0x08, 0)
+
+#define ZORRO_MANUF_IMPULSE                                     0x0838
+#define  ZORRO_PROD_IMPULSE_FIRECRACKER_24                      ZORRO_ID(IMPULSE, 0x00, 0)
+
+#define ZORRO_MANUF_IVS                                         0x0840
+#define  ZORRO_PROD_IVS_GRANDSLAM_PIC_2                         ZORRO_ID(IVS, 0x02, 0)
+#define  ZORRO_PROD_IVS_GRANDSLAM_PIC_1                         ZORRO_ID(IVS, 0x04, 0)
+#define  ZORRO_PROD_IVS_OVERDRIVE                               ZORRO_ID(IVS, 0x10, 0)
+#define  ZORRO_PROD_IVS_TRUMPCARD_CLASSIC                       ZORRO_ID(IVS, 0x30, 0)
+#define  ZORRO_PROD_IVS_TRUMPCARD_PRO_GRANDSLAM                 ZORRO_ID(IVS, 0x34, 0)
+#define  ZORRO_PROD_IVS_META_4                                  ZORRO_ID(IVS, 0x40, 0)
+#define  ZORRO_PROD_IVS_WAVETOOLS                               ZORRO_ID(IVS, 0xBF, 0)
+#define  ZORRO_PROD_IVS_VECTOR_1                                ZORRO_ID(IVS, 0xF3, 0)
+#define  ZORRO_PROD_IVS_VECTOR_2                                ZORRO_ID(IVS, 0xF4, 0)
+
+#define ZORRO_MANUF_VECTOR_1                                    0x0841
+#define  ZORRO_PROD_VECTOR_CONNECTION_1                         ZORRO_ID(VECTOR_1, 0xE3, 0)
+
+#define ZORRO_MANUF_XPERT_PRODEV                                0x0845
+#define  ZORRO_PROD_XPERT_PRODEV_VISIONA_RAM                    ZORRO_ID(XPERT_PRODEV, 0x01, 0)
+#define  ZORRO_PROD_XPERT_PRODEV_VISIONA_REG                    ZORRO_ID(XPERT_PRODEV, 0x02, 0)
+#define  ZORRO_PROD_XPERT_PRODEV_MERLIN_RAM                     ZORRO_ID(XPERT_PRODEV, 0x03, 0)
+#define  ZORRO_PROD_XPERT_PRODEV_MERLIN_REG_1                   ZORRO_ID(XPERT_PRODEV, 0x04, 0)
+#define  ZORRO_PROD_XPERT_PRODEV_MERLIN_REG_2                   ZORRO_ID(XPERT_PRODEV, 0xC9, 0)
+
+#define ZORRO_MANUF_HYDRA_SYSTEMS                               0x0849
+#define  ZORRO_PROD_HYDRA_SYSTEMS_AMIGANET                      ZORRO_ID(HYDRA_SYSTEMS, 0x01, 0)
+
+#define ZORRO_MANUF_SUNRIZE_INDUSTRIES                          0x084F
+#define  ZORRO_PROD_SUNRIZE_INDUSTRIES_AD1012                   ZORRO_ID(SUNRIZE_INDUSTRIES, 0x01, 0)
+#define  ZORRO_PROD_SUNRIZE_INDUSTRIES_AD516                    ZORRO_ID(SUNRIZE_INDUSTRIES, 0x02, 0)
+#define  ZORRO_PROD_SUNRIZE_INDUSTRIES_DD512                    ZORRO_ID(SUNRIZE_INDUSTRIES, 0x03, 0)
+
+#define ZORRO_MANUF_TRICERATOPS                                 0x0850
+#define  ZORRO_PROD_TRICERATOPS_MULTI_IO                        ZORRO_ID(TRICERATOPS, 0x01, 0)
+
+#define ZORRO_MANUF_APPLIED_MAGIC                               0x0851
+#define  ZORRO_PROD_APPLIED_MAGIC_DMI_RESOLVER                  ZORRO_ID(APPLIED_MAGIC, 0x01, 0)
+#define  ZORRO_PROD_APPLIED_MAGIC_DIGITAL_BROADCASTER           ZORRO_ID(APPLIED_MAGIC, 0x06, 0)
+
+#define ZORRO_MANUF_GFX_BASE                                    0x085E
+#define  ZORRO_PROD_GFX_BASE_GDA_1_VRAM                         ZORRO_ID(GFX_BASE, 0x00, 0)
+#define  ZORRO_PROD_GFX_BASE_GDA_1                              ZORRO_ID(GFX_BASE, 0x01, 0)
+
+#define ZORRO_MANUF_ROCTEC                                      0x0860
+#define  ZORRO_PROD_ROCTEC_RH_800C                              ZORRO_ID(ROCTEC, 0x01, 0)
+#define  ZORRO_PROD_ROCTEC_RH_800C_RAM                          ZORRO_ID(ROCTEC, 0x01, 0)
+
+#define ZORRO_MANUF_KATO                                        0x0861
+#define  ZORRO_PROD_KATO_MELODY                                 ZORRO_ID(KATO, 0x80, 0)
+/* ID clash!! */
+#define ZORRO_MANUF_HELFRICH_1                                  0x0861
+#define  ZORRO_PROD_HELFRICH_RAINBOW_II                         ZORRO_ID(HELFRICH_1, 0x20, 0)
+#define  ZORRO_PROD_HELFRICH_RAINBOW_III                        ZORRO_ID(HELFRICH_1, 0x21, 0)
+
+#define ZORRO_MANUF_ATLANTIS                                    0x0862
+
+#define ZORRO_MANUF_PROTAR                                      0x0864
+
+#define ZORRO_MANUF_ACS                                         0x0865
+
+#define ZORRO_MANUF_SOFTWARE_RESULTS_ENTERPRISES                0x0866
+#define  ZORRO_PROD_SOFTWARE_RESULTS_ENTERPRISES_GOLDEN_GATE_2_BUS_PLUS ZORRO_ID(SOFTWARE_RESULTS_ENTERPRISES, 0x01, 0)
+
+#define ZORRO_MANUF_MASOBOSHI                                   0x086D
+#define  ZORRO_PROD_MASOBOSHI_MASTER_CARD_SC201                 ZORRO_ID(MASOBOSHI, 0x03, 0)
+#define  ZORRO_PROD_MASOBOSHI_MASTER_CARD_MC702                 ZORRO_ID(MASOBOSHI, 0x04, 0)
+#define  ZORRO_PROD_MASOBOSHI_MVD_819                           ZORRO_ID(MASOBOSHI, 0x07, 0)
+
+#define ZORRO_MANUF_MAINHATTAN_DATA                             0x086F
+#define  ZORRO_PROD_MAINHATTAN_DATA_IDE                         ZORRO_ID(MAINHATTAN_DATA, 0x01, 0)
+
+#define ZORRO_MANUF_VILLAGE_TRONIC                              0x0877
+#define  ZORRO_PROD_VILLAGE_TRONIC_DOMINO_RAM                   ZORRO_ID(VILLAGE_TRONIC, 0x01, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_DOMINO_REG                   ZORRO_ID(VILLAGE_TRONIC, 0x02, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_DOMINO_16M_PROTOTYPE         ZORRO_ID(VILLAGE_TRONIC, 0x03, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_RAM       ZORRO_ID(VILLAGE_TRONIC, 0x0B, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_REG       ZORRO_ID(VILLAGE_TRONIC, 0x0C, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_SEGMENTED_MODE    ZORRO_ID(VILLAGE_TRONIC, 0x0D, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z2_MEM1           ZORRO_ID(VILLAGE_TRONIC, 0x15, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z2_MEM2           ZORRO_ID(VILLAGE_TRONIC, 0x16, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z2_REG            ZORRO_ID(VILLAGE_TRONIC, 0x17, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z3                ZORRO_ID(VILLAGE_TRONIC, 0x18, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_ARIADNE                      ZORRO_ID(VILLAGE_TRONIC, 0xC9, 0)
+#define  ZORRO_PROD_VILLAGE_TRONIC_ARIADNE2                     ZORRO_ID(VILLAGE_TRONIC, 0xCA, 0)
+
+#define ZORRO_MANUF_UTILITIES_UNLIMITED                         0x087B
+#define  ZORRO_PROD_UTILITIES_UNLIMITED_EMPLANT_DELUXE          ZORRO_ID(UTILITIES_UNLIMITED, 0x15, 0)
+#define  ZORRO_PROD_UTILITIES_UNLIMITED_EMPLANT_DELUXE2         ZORRO_ID(UTILITIES_UNLIMITED, 0x20, 0)
+
+#define ZORRO_MANUF_AMITRIX                                     0x0880
+#define  ZORRO_PROD_AMITRIX_MULTI_IO                            ZORRO_ID(AMITRIX, 0x01, 0)
+#define  ZORRO_PROD_AMITRIX_CD_RAM                              ZORRO_ID(AMITRIX, 0x02, 0)
+
+#define ZORRO_MANUF_ARMAX                                       0x0885
+#define  ZORRO_PROD_ARMAX_OMNIBUS                               ZORRO_ID(ARMAX, 0x00, 0)
+
+#define ZORRO_MANUF_ZEUS                                        0x088D
+#define  ZORRO_PROD_ZEUS_SPIDER                                 ZORRO_ID(ZEUS, 0x04, 0)
+
+#define ZORRO_MANUF_NEWTEK                                      0x088F
+#define  ZORRO_PROD_NEWTEK_VIDEOTOASTER                         ZORRO_ID(NEWTEK, 0x00, 0)
+
+#define ZORRO_MANUF_M_TECH_GERMANY                              0x0890
+#define  ZORRO_PROD_MTEC_AT500_2                                ZORRO_ID(M_TECH_GERMANY, 0x01, 0)
+#define  ZORRO_PROD_MTEC_68030                                  ZORRO_ID(M_TECH_GERMANY, 0x03, 0)
+#define  ZORRO_PROD_MTEC_68020I                                 ZORRO_ID(M_TECH_GERMANY, 0x06, 0)
+#define  ZORRO_PROD_MTEC_A1200_T68030_RTC                       ZORRO_ID(M_TECH_GERMANY, 0x20, 0)
+#define  ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530                ZORRO_ID(M_TECH_GERMANY, 0x21, 0)
+#define  ZORRO_PROD_MTEC_8_MB_RAM                               ZORRO_ID(M_TECH_GERMANY, 0x22, 0)
+#define  ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE       ZORRO_ID(M_TECH_GERMANY, 0x24, 0)
+
+#define ZORRO_MANUF_GREAT_VALLEY_PRODUCTS_4                     0x0891
+#define  ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_RAM                  ZORRO_ID(GREAT_VALLEY_PRODUCTS_4, 0x01, 0)
+#define  ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_REG                  ZORRO_ID(GREAT_VALLEY_PRODUCTS_4, 0x02, 0)
+
+#define ZORRO_MANUF_APOLLO_1                                    0x0892
+#define  ZORRO_PROD_APOLLO_A1200                                ZORRO_ID(APOLLO_1, 0x01, 0)
+
+#define ZORRO_MANUF_HELFRICH_2                                  0x0893
+#define  ZORRO_PROD_HELFRICH_PICCOLO_RAM                        ZORRO_ID(HELFRICH_2, 0x05, 0)
+#define  ZORRO_PROD_HELFRICH_PICCOLO_REG                        ZORRO_ID(HELFRICH_2, 0x06, 0)
+#define  ZORRO_PROD_HELFRICH_PEGGY_PLUS_MPEG                    ZORRO_ID(HELFRICH_2, 0x07, 0)
+#define  ZORRO_PROD_HELFRICH_VIDEOCRUNCHER                      ZORRO_ID(HELFRICH_2, 0x08, 0)
+#define  ZORRO_PROD_HELFRICH_SD64_RAM                           ZORRO_ID(HELFRICH_2, 0x0A, 0)
+#define  ZORRO_PROD_HELFRICH_SD64_REG                           ZORRO_ID(HELFRICH_2, 0x0B, 0)
+
+#define ZORRO_MANUF_MACROSYSTEMS_USA                            0x089B
+#define  ZORRO_PROD_MACROSYSTEMS_WARP_ENGINE_40xx               ZORRO_ID(MACROSYSTEMS_USA, 0x13, 0)
+
+#define ZORRO_MANUF_ELBOX_COMPUTER                              0x089E
+#define  ZORRO_PROD_ELBOX_COMPUTER_1200_4                       ZORRO_ID(ELBOX_COMPUTER, 0x06, 0)
+
+#define ZORRO_MANUF_HARMS_PROFESSIONAL                          0x0A00
+#define  ZORRO_PROD_HARMS_PROFESSIONAL_030_PLUS                 ZORRO_ID(HARMS_PROFESSIONAL, 0x10, 0)
+#define  ZORRO_PROD_HARMS_PROFESSIONAL_3500                     ZORRO_ID(HARMS_PROFESSIONAL, 0xD0, 0)
+
+#define ZORRO_MANUF_MICRONIK                                    0x0A50
+#define  ZORRO_PROD_MICRONIK_RCA_120                            ZORRO_ID(MICRONIK, 0x0A, 0)
+
+#define ZORRO_MANUF_MICRONIK2                                   0x0F0F
+#define  ZORRO_PROD_MICRONIK2_Z3I                               ZORRO_ID(MICRONIK2, 0x01, 0)
+
+#define ZORRO_MANUF_MEGAMICRO                                   0x1000
+#define  ZORRO_PROD_MEGAMICRO_SCRAM_500                         ZORRO_ID(MEGAMICRO, 0x03, 0)
+#define  ZORRO_PROD_MEGAMICRO_SCRAM_500_RAM                     ZORRO_ID(MEGAMICRO, 0x04, 0)
+
+#define ZORRO_MANUF_IMTRONICS_2                                 0x1028
+#define  ZORRO_PROD_IMTRONICS_HURRICANE_2800_3                  ZORRO_ID(IMTRONICS_2, 0x39, 0)
+#define  ZORRO_PROD_IMTRONICS_HURRICANE_2800_4                  ZORRO_ID(IMTRONICS_2, 0x57, 0)
+
+/* unofficial ID */
+#define ZORRO_MANUF_INDIVIDUAL_COMPUTERS                        0x1212
+#define  ZORRO_PROD_INDIVIDUAL_COMPUTERS_BUDDHA                 ZORRO_ID(INDIVIDUAL_COMPUTERS, 0x00, 0)
+#define  ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF                 ZORRO_ID(INDIVIDUAL_COMPUTERS, 0x17, 0)
+#define  ZORRO_PROD_INDIVIDUAL_COMPUTERS_CATWEASEL              ZORRO_ID(INDIVIDUAL_COMPUTERS, 0x2A, 0)
+
+#define ZORRO_MANUF_KUPKE_3                                     0x1248
+#define  ZORRO_PROD_KUPKE_GOLEM_HD_3000                         ZORRO_ID(KUPKE_3, 0x01, 0)
+
+#define ZORRO_MANUF_ITH                                         0x1388
+#define  ZORRO_PROD_ITH_ISDN_MASTER_II                          ZORRO_ID(ITH, 0x01, 0)
+
+#define ZORRO_MANUF_VMC                                         0x1389
+#define  ZORRO_PROD_VMC_ISDN_BLASTER_Z2                         ZORRO_ID(VMC, 0x01, 0)
+#define  ZORRO_PROD_VMC_HYPERCOM_4                              ZORRO_ID(VMC, 0x02, 0)
+
+#define ZORRO_MANUF_INFORMATION                                 0x157C
+#define  ZORRO_PROD_INFORMATION_ISDN_ENGINE_I                   ZORRO_ID(INFORMATION, 0x64, 0)
+
+#define ZORRO_MANUF_VORTEX                                      0x2017
+#define  ZORRO_PROD_VORTEX_GOLDEN_GATE_80386SX                  ZORRO_ID(VORTEX, 0x07, 0)
+#define  ZORRO_PROD_VORTEX_GOLDEN_GATE_RAM                      ZORRO_ID(VORTEX, 0x08, 0)
+#define  ZORRO_PROD_VORTEX_GOLDEN_GATE_80486                    ZORRO_ID(VORTEX, 0x09, 0)
+
+#define ZORRO_MANUF_EXPANSION_SYSTEMS                           0x2062
+#define  ZORRO_PROD_EXPANSION_SYSTEMS_DATAFLYER_4000SX          ZORRO_ID(EXPANSION_SYSTEMS, 0x01, 0)
+#define  ZORRO_PROD_EXPANSION_SYSTEMS_DATAFLYER_4000SX_RAM      ZORRO_ID(EXPANSION_SYSTEMS, 0x02, 0)
+
+#define ZORRO_MANUF_READYSOFT                                   0x2100
+#define  ZORRO_PROD_READYSOFT_AMAX_II_IV                        ZORRO_ID(READYSOFT, 0x01, 0)
+
+#define ZORRO_MANUF_PHASE5                                      0x2140
+#define  ZORRO_PROD_PHASE5_BLIZZARD_RAM                         ZORRO_ID(PHASE5, 0x01, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD                             ZORRO_ID(PHASE5, 0x02, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_1220_IV                     ZORRO_ID(PHASE5, 0x06, 0)
+#define  ZORRO_PROD_PHASE5_FASTLANE_Z3_RAM                      ZORRO_ID(PHASE5, 0x0A, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_1230_II_FASTLANE_Z3_CYBERSCSI_CYBERSTORM060 ZORRO_ID(PHASE5, 0x0B, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_1220_CYBERSTORM             ZORRO_ID(PHASE5, 0x0C, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_1230                        ZORRO_ID(PHASE5, 0x0D, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_1230_IV_1260                ZORRO_ID(PHASE5, 0x11, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_2060                        ZORRO_ID(PHASE5, 0x18, 0)
+#define  ZORRO_PROD_PHASE5_CYBERSTORM_MK_II                     ZORRO_ID(PHASE5, 0x19, 0)
+#define  ZORRO_PROD_PHASE5_CYBERVISION64                        ZORRO_ID(PHASE5, 0x22, 0)
+#define  ZORRO_PROD_PHASE5_CYBERVISION64_3D_PROTOTYPE           ZORRO_ID(PHASE5, 0x32, 0)
+#define  ZORRO_PROD_PHASE5_CYBERVISION64_3D                     ZORRO_ID(PHASE5, 0x43, 0)
+#define  ZORRO_PROD_PHASE5_CYBERSTORM_MK_III                    ZORRO_ID(PHASE5, 0x64, 0)
+#define  ZORRO_PROD_PHASE5_BLIZZARD_603E_PLUS                   ZORRO_ID(PHASE5, 0x6e, 0)
+
+#define ZORRO_MANUF_DPS                                         0x2169
+#define  ZORRO_PROD_DPS_PERSONAL_ANIMATION_RECORDER             ZORRO_ID(DPS, 0x01, 0)
+
+#define ZORRO_MANUF_APOLLO_2                                    0x2200
+#define  ZORRO_PROD_APOLLO_A620_68020_1                         ZORRO_ID(APOLLO_2, 0x00, 0)
+#define  ZORRO_PROD_APOLLO_A620_68020_2                         ZORRO_ID(APOLLO_2, 0x01, 0)
+
+#define ZORRO_MANUF_APOLLO_3                                    0x2222
+#define  ZORRO_PROD_APOLLO_AT_APOLLO                            ZORRO_ID(APOLLO_3, 0x22, 0)
+#define  ZORRO_PROD_APOLLO_1230_1240_1260_2030_4040_4060        ZORRO_ID(APOLLO_3, 0x23, 0)
+
+#define ZORRO_MANUF_PETSOFF_LP                                  0x38A5
+#define  ZORRO_PROD_PETSOFF_LP_DELFINA                          ZORRO_ID(PETSOFF_LP, 0x00, 0)
+#define  ZORRO_PROD_PETSOFF_LP_DELFINA_LITE                     ZORRO_ID(PETSOFF_LP, 0x01, 0)
+
+#define ZORRO_MANUF_UWE_GERLACH                                 0x3FF7
+#define  ZORRO_PROD_UWE_GERLACH_RAM_ROM                         ZORRO_ID(UWE_GERLACH, 0xd4, 0)
+
+#define ZORRO_MANUF_ACT                                         0x4231
+#define  ZORRO_PROD_ACT_PRELUDE                                 ZORRO_ID(ACT, 0x01, 0)
+
+#define ZORRO_MANUF_MACROSYSTEMS_GERMANY                        0x4754
+#define  ZORRO_PROD_MACROSYSTEMS_MAESTRO                        ZORRO_ID(MACROSYSTEMS_GERMANY, 0x03, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_VLAB                           ZORRO_ID(MACROSYSTEMS_GERMANY, 0x04, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_MAESTRO_PRO                    ZORRO_ID(MACROSYSTEMS_GERMANY, 0x05, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_RETINA                         ZORRO_ID(MACROSYSTEMS_GERMANY, 0x06, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_MULTI_EVOLUTION                ZORRO_ID(MACROSYSTEMS_GERMANY, 0x08, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_TOCCATA                        ZORRO_ID(MACROSYSTEMS_GERMANY, 0x0C, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_RETINA_Z3                      ZORRO_ID(MACROSYSTEMS_GERMANY, 0x10, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_VLAB_MOTION                    ZORRO_ID(MACROSYSTEMS_GERMANY, 0x12, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_ALTAIS                         ZORRO_ID(MACROSYSTEMS_GERMANY, 0x13, 0)
+#define  ZORRO_PROD_MACROSYSTEMS_FALCON_040                     ZORRO_ID(MACROSYSTEMS_GERMANY, 0xFD, 0)
+
+#define ZORRO_MANUF_COMBITEC                                    0x6766
+
+#define ZORRO_MANUF_SKI_PERIPHERALS                             0x8000
+#define  ZORRO_PROD_SKI_PERIPHERALS_MAST_FIREBALL               ZORRO_ID(SKI_PERIPHERALS, 0x08, 0)
+#define  ZORRO_PROD_SKI_PERIPHERALS_SCSI_DUAL_SERIAL            ZORRO_ID(SKI_PERIPHERALS, 0x80, 0)
+
+#define ZORRO_MANUF_REIS_WARE_2                                 0xA9AD
+#define  ZORRO_PROD_REIS_WARE_SCAN_KING                         ZORRO_ID(REIS_WARE_2, 0x11, 0)
+
+#define ZORRO_MANUF_CAMERON                                     0xAA01
+#define  ZORRO_PROD_CAMERON_PERSONAL_A4                         ZORRO_ID(CAMERON, 0x10, 0)
+
+#define ZORRO_MANUF_REIS_WARE                                   0xAA11
+#define  ZORRO_PROD_REIS_WARE_HANDYSCANNER                      ZORRO_ID(REIS_WARE, 0x11, 0)
+
+#define ZORRO_MANUF_PHOENIX_2                                   0xB5A8
+#define  ZORRO_PROD_PHOENIX_ST506_2                             ZORRO_ID(PHOENIX_2, 0x21, 0)
+#define  ZORRO_PROD_PHOENIX_SCSI_2                              ZORRO_ID(PHOENIX_2, 0x22, 0)
+#define  ZORRO_PROD_PHOENIX_RAM_2                               ZORRO_ID(PHOENIX_2, 0xBE, 0)
+
+#define ZORRO_MANUF_COMBITEC_2                                  0xC008
+#define  ZORRO_PROD_COMBITEC_HD                                 ZORRO_ID(COMBITEC_2, 0x2A, 0)
+#define  ZORRO_PROD_COMBITEC_SRAM                               ZORRO_ID(COMBITEC_2, 0x2B, 0)
+
+
+    /*
+     *  Test and illegal Manufacturer IDs.
+     */
+
+#define ZORRO_MANUF_HACKER                                      0x07DB
+#define  ZORRO_PROD_GENERAL_PROTOTYPE                           ZORRO_ID(HACKER, 0x00, 0)
+#define  ZORRO_PROD_HACKER_SCSI                                 ZORRO_ID(HACKER, 0x01, 0)
+#define  ZORRO_PROD_RESOURCE_MANAGEMENT_FORCE_QUICKNET_QN2000   ZORRO_ID(HACKER, 0x02, 0)
+#define  ZORRO_PROD_VECTOR_CONNECTION_2                         ZORRO_ID(HACKER, 0xE0, 0)
+#define  ZORRO_PROD_VECTOR_CONNECTION_3                         ZORRO_ID(HACKER, 0xE1, 0)
+#define  ZORRO_PROD_VECTOR_CONNECTION_4                         ZORRO_ID(HACKER, 0xE2, 0)
+#define  ZORRO_PROD_VECTOR_CONNECTION_5                         ZORRO_ID(HACKER, 0xE3, 0)
diff --git a/include/linux/zutil.h b/include/linux/zutil.h
new file mode 100644
index 000000000000..fdfd5ed41ec4
--- /dev/null
+++ b/include/linux/zutil.h
@@ -0,0 +1,119 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: zutil.h,v 1.1 2000/01/01 03:32:23 davem Exp $ */
+
+#ifndef _Z_UTIL_H
+#define _Z_UTIL_H
+
+#include <linux/zlib.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+
+typedef unsigned char  uch;
+typedef unsigned short ush;
+typedef unsigned long  ulg;
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+        /* Common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+         /* functions */
+
+typedef uLong (*check_func) (uLong check, const Byte *buf,
+                                       uInt len);
+
+
+                        /* checksum functions */
+
+#define BASE 65521L /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* ========================================================================= */
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+static inline uLong zlib_adler32(uLong adler,
+                                 const Byte *buf,
+                                 uInt len)
+{
+    unsigned long s1 = adler & 0xffff;
+    unsigned long s2 = (adler >> 16) & 0xffff;
+    int k;
+
+    if (buf == NULL) return 1L;
+
+    while (len > 0) {
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+            buf += 16;
+            k -= 16;
+        }
+        if (k != 0) do {
+            s1 += *buf++;
+            s2 += s1;
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}
+
+#endif /* _Z_UTIL_H */