162 files changed, 11193 insertions, 3734 deletions

diff --git a/drivers/acorn/char/Makefile b/drivers/acorn/char/Makefile
deleted file mode 100644
index d006c9f168d2..000000000000
--- a/drivers/acorn/char/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-#
-# Makefile for the acorn character device drivers.
-#
-
-obj-$(CONFIG_L7200_KEYB)        += defkeymap-l7200.o keyb_l7200.o
diff --git a/drivers/acorn/char/defkeymap-l7200.c b/drivers/acorn/char/defkeymap-l7200.c
deleted file mode 100644
index 93d80a1c36f9..000000000000
--- a/drivers/acorn/char/defkeymap-l7200.c
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
- * linux/drivers/acorn/char/defkeymap-l7200.c
- *
- * Default keyboard maps for LinkUp Systems L7200 board
- *
- * Copyright (C) 2000 Steve Hill (sjhill@cotw.com)
- *
- * Changelog:
- *   08-04-2000 SJH     Created file
- */
-
-#include <linux/types.h>
-#include <linux/keyboard.h>
-#include <linux/kd.h>
-
-/* Normal (maps 1:1 with no processing) */
-#define KTn     0xF0
-/* Function keys */
-#define KTf     0xF1
-/* Special (Performs special house-keeping funcs) */
-#define KTs     0xF2
-#define KIGNORE         K(KTs, 0)       /* Ignore */
-#define KENTER          K(KTs, 1)       /* Enter */
-#define KREGS           K(KTs, 2)       /* Regs */
-#define KMEM            K(KTs, 3)       /* Mem */
-#define KSTAT           K(KTs, 4)       /* State */
-#define KINTR           K(KTs, 5)       /* Intr */
-#define Ksl     6       /* Last console */
-#define KCAPSLK         K(KTs, 7)       /* Caps lock */
-#define KNUMLK          K(KTs, 8)       /* Num-lock */
-#define KSCRLLK         K(KTs, 9)       /* Scroll-lock */
-#define KSCRLFOR        K(KTs,10)       /* Scroll forward */
-#define KSCRLBAK        K(KTs,11)       /* Scroll back */
-#define KREBOOT         K(KTs,12)       /* Reboot */
-#define KCAPSON         K(KTs,13)       /* Caps on */
-#define KCOMPOSE        K(KTs,14)       /* Compose */
-#define KSAK            K(KTs,15)       /* SAK */
-#define CONS_DEC        K(KTs,16)       /* Dec console */
-#define CONS_INC        K(KTs,17)       /* Incr console */
-#define KFLOPPY         K(KTs,18)       /* Floppy */
-/* Key pad (0-9 = digits, 10=+, 11=-, 12=*, 13=/, 14=enter, 16=., 17=# */
-#define KTp     0xF3
-#define KPAD_0          K(KTp, 0 )
-#define KPAD_1          K(KTp, 1 )
-#define KPAD_2          K(KTp, 2 )
-#define KPAD_3          K(KTp, 3 )
-#define KPAD_4          K(KTp, 4 )
-#define KPAD_5          K(KTp, 5 )
-#define KPAD_6          K(KTp, 6 )
-#define KPAD_7          K(KTp, 7 )
-#define KPAD_8          K(KTp, 8 )
-#define KPAD_9          K(KTp, 9 )
-#define KPAD_PL         K(KTp,10 )
-#define KPAD_MI         K(KTp,11 )
-#define KPAD_ML         K(KTp,12 )
-#define KPAD_DV         K(KTp,13 )
-#define KPAD_EN         K(KTp,14 )
-#define KPAD_DT         K(KTp,16 )
-#define KPAD_HS         K(KTp,20 )
-/* Console switching */
-#define KCn     0xF5
-/* Cursor */
-#define KTc     0xF6
-#define Kcd     0       /* Cursor down */
-#define Kcl     1       /* Cursor left */
-#define Kcr     2       /* Cursor right */
-#define Kcu     3       /* Cursor up */
-/* Shift/alt modifiers etc */
-#define KMd     0xF7
-#define KSHIFT          K(KMd, 0 )
-#define KALTGR          K(KMd, 1 )
-#define KCTRL           K(KMd, 2 )
-#define KALT            K(KMd, 3 )
-/* Meta */
-#define KMt     0xF8
-#define KAs     0xF9
-#define KPADA_0         K(KAs, 0 )
-#define KPADA_1         K(KAs, 1 )
-#define KPADA_2         K(KAs, 2 )
-#define KPADA_3         K(KAs, 3 )
-#define KPADA_4         K(KAs, 4 )
-#define KPADA_5         K(KAs, 5 )
-#define KPADA_6         K(KAs, 6 )
-#define KPADA_7         K(KAs, 7 )
-#define KPADA_8         K(KAs, 8 )
-#define KPADA_9         K(KAs, 9 )
-#define KPADB_0         K(KAs,10 )
-#define KPADB_1         K(KAs,11 )
-#define KPADB_2         K(KAs,12 )
-#define KPADB_3         K(KAs,13 )
-#define KPADB_4         K(KAs,14 )
-#define KPADB_5         K(KAs,15 )
-#define KPADB_6         K(KAs,16 )
-#define KPADB_7         K(KAs,17 )
-#define KPADB_8         K(KAs,18 )
-#define KPADB_9         K(KAs,19 )
-/* Locking keys */
-#define KLk     0xFA
-/* Letters */
-#define KTl     0xFB
-
-/*
- * Here is the layout of the keys for the Fujitsu QWERTY
- * style keyboard:
- *
- *      static char Fujitsu_Key_Table[] =
- *      {
- *        KALT, '`' , KNUL, KCTL, KFUN, KESC, '1' , '2' ,
- *        '9' , '0' , '-' , '=' , KNUL, KBSP, KNUL, KNUL,
- *        KNUL, KBSL, KSHF, KNUL, KNUL, KDEL, KNUL, 't' ,
- *        'y' , 'u' , 'i' , KRET, KSHF, KPGD, KNUL, KNUL,
- *        KNUL, KTAB, KNUL, KNUL, KNUL, 'q' , 'w' , 'e' ,
- *        'r' , 'o' , 'p' , '[' , KNUL, ']' , KNUL, KNUL,
- *        KNUL, 'z' , KNUL, KNUL, KNUL, KSHL, KNUL, KNUL,
- *        'k' , 'l' , ';' , KSQT, KNUL, KPGU, KNUL, KNUL,
- *        KNUL, 'a' , KNUL, KNUL, KNUL, 's' , 'd' , 'f' ,
- *        'g' , 'h' , 'j' , '/' , KNUL, KHME, KNUL, KNUL,
- *        KNUL, 'x' , KNUL, KNUL, KNUL, 'c' , 'v' , 'b' ,
- *        'n' , 'm' , ',' , '.' , KNUL, ' ' , KNUL, KNUL,
- *        KNUL, KNUL, KNUL, KNUL, KNUL, '3' , '4' , '5' ,
- *        '6' , '7' , '8' , KNUL, KPRG, KNUL, KEND, KNUL,
- *      };
- */
-
-u_short plain_map[NR_KEYS]=
-{
-        0xf703, 0xf060, 0xf200, 0xf702, 0xf200, 0xf01b, 0xf031, 0xf032,
-        0xf039, 0xf030, 0xf02d, 0xf03d, 0xf200, 0xf07f, 0xf200, 0xf200,
-        0xf200, 0xf05c, 0xf700, 0xf200, 0xf200, 0xf116, 0xf000, 0xfb74,
-        0xfb79, 0xfb75, 0xfb69, 0xf201, 0xf700, 0xf600, 0xf200, 0xf200,
-        0xf200, 0xf009, 0xf200, 0xf200, 0xf200, 0xfb71, 0xfb77, 0xfb65,
-        0xfb72, 0xfb6f, 0xfb70, 0xf05b, 0xf200, 0xf05d, 0xf200, 0xf200,
-        0xf200, 0xfb7a, 0xf200, 0xf200, 0xf200, 0xf207, 0xf200, 0xf200,
-        0xfb6b, 0xfb6c, 0xf03b, 0xf027, 0xf200, 0xf603, 0xf200, 0xf200,
-        0xf200, 0xfb61, 0xf200, 0xf200, 0xf200, 0xfb73, 0xfb64, 0xfb66,
-        0xfb67, 0xfb68, 0xfb6a, 0xf02f, 0xf200, 0xf601, 0xf200, 0xf200,
-        0xf200, 0xfb78, 0xf200, 0xf200, 0xf200, 0xfb63, 0xfb76, 0xfb62,
-        0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf200, 0xf020, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf033, 0xf034, 0xf035, 
-        0xf036, 0xf037, 0xf038, 0xf200, 0xf200, 0xf200, 0xf602, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 
-};
-
-u_short shift_map[NR_KEYS]=
-{
-        0xf703, 0xf07e, 0xf200, 0xf702, 0xf200, 0xf01b, 0xf021, 0xf040,
-        0xf028, 0xf029, 0xf05f, 0xf02b, 0xf200, 0xf07f, 0xf200, 0xf200,
-        0xf200, 0xf07c, 0xf700, 0xf200, 0xf200, 0xf116, 0xf000, 0xfb54,
-        0xfb59, 0xfb55, 0xfb49, 0xf201, 0xf700, 0xf600, 0xf200, 0xf200,
-        0xf200, 0xf009, 0xf200, 0xf200, 0xf200, 0xfb51, 0xfb57, 0xfb45,
-        0xfb52, 0xfb4f, 0xfb50, 0xf07b, 0xf200, 0xf07d, 0xf200, 0xf200,
-        0xf200, 0xfb5a, 0xf200, 0xf200, 0xf200, 0xf207, 0xf200, 0xf200,
-        0xfb4b, 0xfb4c, 0xf03a, 0xf022, 0xf200, 0xf603, 0xf200, 0xf200,
-        0xf200, 0xfb41, 0xf200, 0xf200, 0xf200, 0xfb53, 0xfb44, 0xfb46,
-        0xfb47, 0xfb48, 0xfb4a, 0xf03f, 0xf200, 0xf601, 0xf200, 0xf200,
-        0xf200, 0xfb58, 0xf200, 0xf200, 0xf200, 0xfb43, 0xfb56, 0xfb42,
-        0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf200, 0xf020, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf023, 0xf024, 0xf025, 
-        0xf05e, 0xf026, 0xf02a, 0xf200, 0xf200, 0xf200, 0xf602, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 
-};
-
-u_short altgr_map[NR_KEYS]=
-{
-  KIGNORE   ,K(KCn,12 ),K(KCn,13 ),K(KCn,14  ),K(KCn,15 ),K(KCn,16 ),K(KCn,17  ),K(KCn, 18),
-  K(KCn, 19),K(KCn,20 ),K(KCn,21 ),K(KCn,22  ),K(KCn,23 ),KIGNORE   ,KREGS      ,KINTR     ,
-  KIGNORE   ,KIGNORE   ,K(KTn,'@'),KIGNORE    ,K(KTn,'$'),KIGNORE   ,KIGNORE    ,K(KTn,'{'),
-  K(KTn,'['),K(KTn,']'),K(KTn,'}'),K(KTn,'\\'),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
-  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTl,'q'),
-  K(KTl,'w'),K(KTl,'e'),K(KTl,'r'),K(KTl,'t' ),K(KTl,'y'),K(KTl,'u'),K(KTl,'i' ),K(KTl,'o'),
-  K(KTl,'p'),KIGNORE   ,K(KTn,'~'),KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADB_7   ,
-  KPADB_8   ,KPADB_9   ,KPAD_MI   ,KCTRL      ,K(KAs,20 ),K(KTl,'s'),K(KAs,23  ),K(KAs,25 ),
-  K(KTl,'g'),K(KTl,'h'),K(KTl,'j'),K(KTl,'k' ),K(KTl,'l'),KIGNORE   ,KIGNORE    ,KENTER    ,
-  KPADB_4   ,KPADB_5   ,KPADB_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTl,'z' ),K(KTl,'x'),
-  K(KAs,22 ),K(KTl,'v'),K(KTl,21 ),K(KTl,'n' ),K(KTl,'m'),KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KSHIFT    ,K(KTc,Kcu),KPADB_1   ,KPADB_2    ,KPADB_3   ,KCAPSLK   ,KALT       ,KIGNORE   ,
-  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPADB_0   ,KPAD_DT    ,KPAD_EN   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-};
-
-u_short ctrl_map[NR_KEYS]=
-{
-        0xf703, 0xf200, 0xf200, 0xf702, 0xf200, 0xf200, 0xf001, 0xf002,
-        0xf009, 0xf000, 0xf031, 0xf200, 0xf200, 0xf07f, 0xf200, 0xf200,
-        0xf200, 0xf01c, 0xf700, 0xf200, 0xf200, 0xf116, 0xf000, 0xf020,
-        0xf019, 0xf015, 0xf009, 0xf201, 0xf700, 0xf600, 0xf200, 0xf200,
-        0xf200, 0xf009, 0xf200, 0xf200, 0xf200, 0xf011, 0xf017, 0xf005,
-        0xf012, 0xf00f, 0xf010, 0xf01b, 0xf200, 0xf01d, 0xf200, 0xf200,
-        0xf200, 0xf01a, 0xf200, 0xf200, 0xf200, 0xf207, 0xf200, 0xf200,
-        0xf00b, 0xf00c, 0xf200, 0xf007, 0xf200, 0xf603, 0xf200, 0xf200,
-        0xf200, 0xf001, 0xf200, 0xf200, 0xf200, 0xf001, 0xf013, 0xf006,
-        0xf007, 0xf008, 0xf00a, 0xf07f, 0xf200, 0xf601, 0xf200, 0xf200,
-        0xf200, 0xf018, 0xf200, 0xf200, 0xf200, 0xf003, 0xf016, 0xf002,
-        0xf00e, 0xf00d, 0xf200, 0xf200, 0xf200, 0xf000, 0xf200, 0xf200,
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf01b, 0xf01c, 0xf01d, 
-        0xf036, 0xf037, 0xf038, 0xf200, 0xf200, 0xf200, 0xf602, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 
-        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf602, 0xf200, 
-};
-
-u_short shift_ctrl_map[NR_KEYS]=
-{
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KFLOPPY    ,KINTR     ,
-  KIGNORE   ,KIGNORE   ,K(KTn, 0 ),KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,K(KTn,31  ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
-  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KTn,17 ),
-  K(KTn,23 ),K(KTn, 5 ),K(KTn,18 ),K(KTn,20  ),K(KTn,25 ),K(KTn,21 ),K(KTn, 9  ),K(KTn,15 ),
-  K(KTn,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
-  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KTn, 1 ),K(KTn,19 ),K(KTn, 4  ),K(KTn, 6 ),
-  K(KTn, 7 ),K(KTn, 8 ),K(KTn,10 ),K(KTn,11  ),K(KTn,12 ),KIGNORE   ,K(KTn, 7  ),KENTER    ,
-  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KTn,26  ),K(KTn,24 ),
-  K(KTn, 3 ),K(KTn,22 ),K(KTn, 2 ),K(KTn,14  ),K(KTn,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,K(KTn, 0 ),
-  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KPAD_DT    ,KPAD_EN   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-};
-
-u_short alt_map[NR_KEYS]=
-{
-  K(KMt,27 ),K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
-  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KSCRLLK    ,KINTR     ,
-  K(KMt,'`'),K(KMt,'1'),K(KMt,'2'),K(KMt,'3' ),K(KMt,'4'),K(KMt,'5'),K(KMt,'6' ),K(KMt,'7'),
-  K(KMt,'8'),K(KMt,'9'),K(KMt,'0'),K(KMt,'-' ),K(KMt,'='),K(KMt,'£'),K(KMt,127 ),K(KTf,21 ),
-  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,K(KMt, 9  ),K(KMt,'q'),
-  K(KMt,'w'),K(KMt,'e'),K(KMt,'r'),K(KMt,'t' ),K(KMt,'y'),K(KMt,'u'),K(KMt,'i' ),K(KMt,'o'),
-  K(KMt,'p'),K(KMt,'['),K(KMt,']'),K(KMt,'\\'),K(KTf,22 ),K(KTf,23 ),K(KTf,25  ),KPADA_7   ,
-  KPADA_8   ,KPADA_9   ,KPAD_MI   ,KCTRL      ,K(KMt,'a'),K(KMt,'s'),K(KMt,'d' ),K(KMt,'f'),
-  K(KMt,'g'),K(KMt,'h'),K(KMt,'j'),K(KMt,'k' ),K(KMt,'l'),K(KMt,';'),K(KMt,'\''),K(KMt,13 ),
-  KPADA_4   ,KPADA_5   ,KPADA_6   ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,'z' ),K(KMt,'x'),
-  K(KMt,'c'),K(KMt,'v'),K(KMt,'b'),K(KMt,'n' ),K(KMt,'m'),K(KMt,','),K(KMt,'.' ),KIGNORE   ,
-  KSHIFT    ,K(KTc,Kcu),KPADA_1   ,KPADA_2    ,KPADA_3   ,KCAPSLK   ,KALT       ,K(KMt,' '),
-  KALTGR    ,KCTRL     ,CONS_DEC  ,K(KTc,Kcd ),CONS_INC  ,KPADA_0   ,KPAD_DT    ,KPAD_EN   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-};
-
-u_short ctrl_alt_map[NR_KEYS]=
-{
-  KIGNORE   ,K(KCn, 0 ),K(KCn, 1 ),K(KCn, 2  ),K(KCn, 3 ),K(KCn, 4 ),K(KCn, 5  ),K(KCn, 6 ),
-  K(KCn, 7 ),K(KCn, 8 ),K(KCn, 9 ),K(KCn,10  ),K(KCn,11 ),KIGNORE   ,KIGNORE    ,KINTR     ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,K(KTf,21 ),
-  K(KTf,20 ),K(KTf,24 ),KNUMLK    ,KPAD_DV    ,KPAD_ML   ,KPAD_HS   ,KIGNORE    ,K(KMt,17 ),
-  K(KMt,23 ),K(KMt, 5 ),K(KMt,18 ),K(KMt,20  ),K(KMt,25 ),K(KMt,21 ),K(KMt, 9  ),K(KMt,15 ),
-  K(KMt,16 ),KIGNORE   ,KIGNORE   ,KIGNORE    ,KREBOOT   ,K(KTf,23 ),K(KTf,25  ),KPAD_7    ,
-  KPAD_8    ,KPAD_9    ,KPAD_MI   ,KCTRL      ,K(KMt, 1 ),K(KMt,19 ),K(KMt, 4  ),K(KMt, 6 ),
-  K(KMt, 7 ),K(KMt, 8 ),K(KMt,10 ),K(KMt,11  ),K(KMt,12 ),KIGNORE   ,KIGNORE    ,KENTER    ,
-  KPAD_4    ,KPAD_5    ,KPAD_6    ,KPAD_PL    ,KSHIFT    ,KIGNORE   ,K(KMt,26  ),K(KMt,24 ),
-  K(KMt, 3 ),K(KMt,22 ),K(KMt, 2 ),K(KMt,14  ),K(KMt,13 ),KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KSHIFT    ,K(KTc,Kcu),KPAD_1    ,KPAD_2     ,KPAD_3    ,KCAPSLK   ,KALT       ,KIGNORE   ,
-  KALTGR    ,KCTRL     ,K(KTc,Kcl),K(KTc,Kcd ),K(KTc,Kcr),KPAD_0    ,KREBOOT    ,KPAD_EN   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-  KIGNORE   ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,KIGNORE   ,KIGNORE    ,KIGNORE   ,
-};
-
-ushort *key_maps[MAX_NR_KEYMAPS] = {
-        plain_map, shift_map, altgr_map, 0,
-        ctrl_map, shift_ctrl_map, 0, 0,
-        alt_map, 0, 0, 0,
-        ctrl_alt_map,   0
-};
-
-unsigned int keymap_count = 7;
-
-/*
- * Philosophy: most people do not define more strings, but they who do
- * often want quite a lot of string space. So, we statically allocate
- * the default and allocate dynamically in chunks of 512 bytes.
- */
-
-char func_buf[] = {
-        '\033', '[', '[', 'A', 0,
-        '\033', '[', '[', 'B', 0,
-        '\033', '[', '[', 'C', 0,
-        '\033', '[', '[', 'D', 0,
-        '\033', '[', '[', 'E', 0,
-        '\033', '[', '1', '7', '~', 0,
-        '\033', '[', '1', '8', '~', 0,
-        '\033', '[', '1', '9', '~', 0,
-        '\033', '[', '2', '0', '~', 0,
-        '\033', '[', '2', '1', '~', 0,
-        '\033', '[', '2', '3', '~', 0,
-        '\033', '[', '2', '4', '~', 0,
-        '\033', '[', '2', '5', '~', 0,
-        '\033', '[', '2', '6', '~', 0,
-        '\033', '[', '2', '8', '~', 0,
-        '\033', '[', '2', '9', '~', 0,
-        '\033', '[', '3', '1', '~', 0,
-        '\033', '[', '3', '2', '~', 0,
-        '\033', '[', '3', '3', '~', 0,
-        '\033', '[', '3', '4', '~', 0,
-        '\033', '[', '1', '~', 0,
-        '\033', '[', '2', '~', 0,
-        '\033', '[', '3', '~', 0,
-        '\033', '[', '4', '~', 0,
-        '\033', '[', '5', '~', 0,
-        '\033', '[', '6', '~', 0,
-        '\033', '[', 'M', 0,
-        '\033', '[', 'P', 0,
-};
-
-char *funcbufptr = func_buf;
-int funcbufsize = sizeof(func_buf);
-int funcbufleft = 0;          /* space left */
-
-char *func_table[MAX_NR_FUNC] = {
-        func_buf + 0,
-        func_buf + 5,
-        func_buf + 10,
-        func_buf + 15,
-        func_buf + 20,
-        func_buf + 25,
-        func_buf + 31,
-        func_buf + 37,
-        func_buf + 43,
-        func_buf + 49,
-        func_buf + 55,
-        func_buf + 61,
-        func_buf + 67,
-        func_buf + 73,
-        func_buf + 79,
-        func_buf + 85,
-        func_buf + 91,
-        func_buf + 97,
-        func_buf + 103,
-        func_buf + 109,
-        func_buf + 115,
-        func_buf + 120,
-        func_buf + 125,
-        func_buf + 130,
-        func_buf + 135,
-        func_buf + 140,
-        func_buf + 145,
-        0,
-        0,
-        func_buf + 149,
-        0,
-};
-
-struct kbdiacruc accent_table[MAX_DIACR] = {
-        {'`', 'A', 0300},       {'`', 'a', 0340},
-        {'\'', 'A', 0301},      {'\'', 'a', 0341},
-        {'^', 'A', 0302},       {'^', 'a', 0342},
-        {'~', 'A', 0303},       {'~', 'a', 0343},
-        {'"', 'A', 0304},       {'"', 'a', 0344},
-        {'O', 'A', 0305},       {'o', 'a', 0345},
-        {'0', 'A', 0305},       {'0', 'a', 0345},
-        {'A', 'A', 0305},       {'a', 'a', 0345},
-        {'A', 'E', 0306},       {'a', 'e', 0346},
-        {',', 'C', 0307},       {',', 'c', 0347},
-        {'`', 'E', 0310},       {'`', 'e', 0350},
-        {'\'', 'E', 0311},      {'\'', 'e', 0351},
-        {'^', 'E', 0312},       {'^', 'e', 0352},
-        {'"', 'E', 0313},       {'"', 'e', 0353},
-        {'`', 'I', 0314},       {'`', 'i', 0354},
-        {'\'', 'I', 0315},      {'\'', 'i', 0355},
-        {'^', 'I', 0316},       {'^', 'i', 0356},
-        {'"', 'I', 0317},       {'"', 'i', 0357},
-        {'-', 'D', 0320},       {'-', 'd', 0360},
-        {'~', 'N', 0321},       {'~', 'n', 0361},
-        {'`', 'O', 0322},       {'`', 'o', 0362},
-        {'\'', 'O', 0323},      {'\'', 'o', 0363},
-        {'^', 'O', 0324},       {'^', 'o', 0364},
-        {'~', 'O', 0325},       {'~', 'o', 0365},
-        {'"', 'O', 0326},       {'"', 'o', 0366},
-        {'/', 'O', 0330},       {'/', 'o', 0370},
-        {'`', 'U', 0331},       {'`', 'u', 0371},
-        {'\'', 'U', 0332},      {'\'', 'u', 0372},
-        {'^', 'U', 0333},       {'^', 'u', 0373},
-        {'"', 'U', 0334},       {'"', 'u', 0374},
-        {'\'', 'Y', 0335},      {'\'', 'y', 0375},
-        {'T', 'H', 0336},       {'t', 'h', 0376},
-        {'s', 's', 0337},       {'"', 'y', 0377},
-        {'s', 'z', 0337},       {'i', 'j', 0377},
-};
-
-unsigned int accent_table_size = 68;
diff --git a/drivers/acpi/bay.c b/drivers/acpi/bay.c
index 26038c2a2a71..61b6c5beb2d3 100644
--- a/drivers/acpi/bay.c
+++ b/drivers/acpi/bay.c
@@ -377,6 +377,9 @@ static int __init bay_init(void)
 
         INIT_LIST_HEAD(&drive_bays);
 
+        if (acpi_disabled)
+                return -ENODEV;
+
         /* look for dockable drive bays */
         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                 ACPI_UINT32_MAX, find_bay, &bays, NULL);
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 96c542f7fded..bb7c51f712bd 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -917,6 +917,9 @@ static int __init dock_init(void)
 
         dock_station = NULL;
 
+        if (acpi_disabled)
+                return 0;
+
         /* look for a dock station */
         acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                             ACPI_UINT32_MAX, find_dock, &num, NULL);
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 2808dc60fd67..9b227d4dc9c9 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -333,6 +333,9 @@ static int __init acpi_rtc_init(void)
 {
         struct device *dev = get_rtc_dev();
 
+        if (acpi_disabled)
+                return 0;
+
         if (dev) {
                 rtc_wake_setup();
                 rtc_info.wake_on = rtc_wake_on;
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index f7f16e7a8bf3..df036118b8b1 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -62,11 +62,11 @@ static void i915_vblank_tasklet(struct drm_device *dev)
         u32 ropcpp = (0xcc << 16) | ((cpp - 1) << 24);
         RING_LOCALS;
 
-        if (sarea_priv->front_tiled) {
+        if (IS_I965G(dev) && sarea_priv->front_tiled) {
                 cmd |= XY_SRC_COPY_BLT_DST_TILED;
                 dst_pitch >>= 2;
         }
-        if (sarea_priv->back_tiled) {
+        if (IS_I965G(dev) && sarea_priv->back_tiled) {
                 cmd |= XY_SRC_COPY_BLT_SRC_TILED;
                 src_pitch >>= 2;
         }
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index e94bee032314..750131010af0 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -3322,7 +3322,7 @@ static int send_break(struct tty_struct *tty, unsigned int duration)
                 msleep_interruptible(duration);
         tty->ops->break_ctl(tty, 0);
         tty_write_unlock(tty);
-        if (!signal_pending(current))
+        if (signal_pending(current))
                 return -EINTR;
         return 0;
 }
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
index 85e2ba7fcfba..bf4830082a13 100644
--- a/drivers/connector/connector.c
+++ b/drivers/connector/connector.c
@@ -27,6 +27,8 @@
 #include <linux/moduleparam.h>
 #include <linux/connector.h>
 #include <linux/mutex.h>
+#include <linux/proc_fs.h>
+#include <linux/spinlock.h>
 
 #include <net/sock.h>
 
@@ -403,6 +405,40 @@ static void cn_callback(void *data)
         mutex_unlock(&notify_lock);
 }
 
+static int cn_proc_show(struct seq_file *m, void *v)
+{
+        struct cn_queue_dev *dev = cdev.cbdev;
+        struct cn_callback_entry *cbq;
+
+        seq_printf(m, "Name            ID\n");
+
+        spin_lock_bh(&dev->queue_lock);
+
+        list_for_each_entry(cbq, &dev->queue_list, callback_entry) {
+                seq_printf(m, "%-15s %u:%u\n",
+                           cbq->id.name,
+                           cbq->id.id.idx,
+                           cbq->id.id.val);
+        }
+
+        spin_unlock_bh(&dev->queue_lock);
+
+        return 0;
+}
+
+static int cn_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, cn_proc_show, NULL);
+}
+
+static const struct file_operations cn_file_ops = {
+        .owner   = THIS_MODULE,
+        .open    = cn_proc_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release
+};
+
 static int __devinit cn_init(void)
 {
         struct cn_dev *dev = &cdev;
@@ -434,6 +470,8 @@ static int __devinit cn_init(void)
                 return -EINVAL;
         }
 
+        proc_net_fops_create(&init_net, "connector", S_IRUGO, &cn_file_ops);
+
         return 0;
 }
 
@@ -443,6 +481,8 @@ static void __devexit cn_fini(void)
 
         cn_already_initialized = 0;
 
+        proc_net_remove(&init_net, "connector");
+
         cn_del_callback(&dev->id);
         cn_queue_free_dev(dev->cbdev);
         netlink_kernel_release(dev->nls);
diff --git a/drivers/firewire/fw-sbp2.c b/drivers/firewire/fw-sbp2.c
index b2458bb8e9ca..227d2e036cd8 100644
--- a/drivers/firewire/fw-sbp2.c
+++ b/drivers/firewire/fw-sbp2.c
@@ -1051,7 +1051,8 @@ static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
                         break;
 
                 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
-                        if (sbp2_scan_logical_unit_dir(tgt, ci.p + value) < 0)
+                        /* Adjust for the increment in the iterator */
+                        if (sbp2_scan_logical_unit_dir(tgt, ci.p - 1 + value) < 0)
                                 return -ENOMEM;
                         break;
                 }
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c
index 1305ef190fc1..9e8c875437be 100644
--- a/drivers/i2c/busses/i2c-s3c2410.c
+++ b/drivers/i2c/busses/i2c-s3c2410.c
@@ -290,12 +290,12 @@ static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
                  * bus, or started a new i2c message
                  */
                 
-                if (iicstat  & S3C2410_IICSTAT_LASTBIT &&
+                if (iicstat & S3C2410_IICSTAT_LASTBIT &&
                     !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
                         /* ack was not received... */
 
                         dev_dbg(i2c->dev, "ack was not received\n");
-                        s3c24xx_i2c_stop(i2c, -EREMOTEIO);
+                        s3c24xx_i2c_stop(i2c, -ENXIO);
                         goto out_ack;
                 }
 
@@ -305,7 +305,7 @@ static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
                         i2c->state = STATE_WRITE;
 
                 /* terminate the transfer if there is nothing to do
-                 * (used by the i2c probe to find devices */
+                 * as this is used by the i2c probe to find devices. */
 
                 if (is_lastmsg(i2c) && i2c->msg->len == 0) {
                         s3c24xx_i2c_stop(i2c, 0);
@@ -323,7 +323,17 @@ static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
                  * end of the message, and if so, work out what to do
                  */
 
+                if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
+                        if (iicstat & S3C2410_IICSTAT_LASTBIT) {
+                                dev_dbg(i2c->dev, "WRITE: No Ack\n");
+
+                                s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
+                                goto out_ack;
+                        }
+                }
+
         retry_write:
+
                 if (!is_msgend(i2c)) {
                         byte = i2c->msg->buf[i2c->msg_ptr++];
                         writeb(byte, i2c->regs + S3C2410_IICDS);
@@ -377,17 +387,6 @@ static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
                  * going to do any more read/write
                  */
 
-                if (!(i2c->msg->flags & I2C_M_IGNORE_NAK) &&
-                    !(is_msglast(i2c) && is_lastmsg(i2c))) {
-
-                        if (iicstat & S3C2410_IICSTAT_LASTBIT) {
-                                dev_dbg(i2c->dev, "READ: No Ack\n");
-
-                                s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
-                                goto out_ack;
-                        }
-                }
-
                 byte = readb(i2c->regs + S3C2410_IICDS);
                 i2c->msg->buf[i2c->msg_ptr++] = byte;
 
@@ -949,3 +948,4 @@ MODULE_DESCRIPTION("S3C24XX I2C Bus driver");
 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:s3c2410-i2c");
+MODULE_ALIAS("platform:s3c2440-i2c");
diff --git a/drivers/i2c/chips/isp1301_omap.c b/drivers/i2c/chips/isp1301_omap.c
index b1b45dddb17e..03a33f1b9cd3 100644
--- a/drivers/i2c/chips/isp1301_omap.c
+++ b/drivers/i2c/chips/isp1301_omap.c
@@ -72,7 +72,7 @@ struct isp1301 {
 };
 
 
-/* bits in OTG_CTRL_REG */
+/* bits in OTG_CTRL */
 
 #define OTG_XCEIV_OUTPUTS \
         (OTG_ASESSVLD|OTG_BSESSEND|OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
@@ -186,8 +186,8 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 
 /* operational registers */
 #define ISP1301_MODE_CONTROL_1          0x04    /* u8 read, set, +1 clear */
-#       define  MC1_SPEED_REG           (1 << 0)
-#       define  MC1_SUSPEND_REG         (1 << 1)
+#       define  MC1_SPEED               (1 << 0)
+#       define  MC1_SUSPEND             (1 << 1)
 #       define  MC1_DAT_SE0             (1 << 2)
 #       define  MC1_TRANSPARENT         (1 << 3)
 #       define  MC1_BDIS_ACON_EN        (1 << 4)
@@ -274,7 +274,7 @@ static void power_down(struct isp1301 *isp)
         isp->otg.state = OTG_STATE_UNDEFINED;
 
         // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
-        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND_REG);
+        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
 
         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_ID_PULLDOWN);
         isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
@@ -283,7 +283,7 @@ static void power_down(struct isp1301 *isp)
 static void power_up(struct isp1301 *isp)
 {
         // isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
-        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND_REG);
+        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
 
         /* do this only when cpu is driving transceiver,
          * so host won't see a low speed device...
@@ -360,6 +360,8 @@ isp1301_defer_work(struct isp1301 *isp, int work)
 /* called from irq handlers */
 static void a_idle(struct isp1301 *isp, const char *tag)
 {
+        u32 l;
+
         if (isp->otg.state == OTG_STATE_A_IDLE)
                 return;
 
@@ -373,13 +375,17 @@ static void a_idle(struct isp1301 *isp, const char *tag)
                 gadget_suspend(isp);
         }
         isp->otg.state = OTG_STATE_A_IDLE;
-        isp->last_otg_ctrl = OTG_CTRL_REG = OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+        isp->last_otg_ctrl = l;
         pr_debug("  --> %s/%s\n", state_name(isp), tag);
 }
 
 /* called from irq handlers */
 static void b_idle(struct isp1301 *isp, const char *tag)
 {
+        u32 l;
+
         if (isp->otg.state == OTG_STATE_B_IDLE)
                 return;
 
@@ -393,7 +399,9 @@ static void b_idle(struct isp1301 *isp, const char *tag)
                 gadget_suspend(isp);
         }
         isp->otg.state = OTG_STATE_B_IDLE;
-        isp->last_otg_ctrl = OTG_CTRL_REG = OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+        isp->last_otg_ctrl = l;
         pr_debug("  --> %s/%s\n", state_name(isp), tag);
 }
 
@@ -406,7 +414,7 @@ dump_regs(struct isp1301 *isp, const char *label)
         u8      src = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
 
         pr_debug("otg: %06x, %s %s, otg/%02x stat/%02x.%02x\n",
-                OTG_CTRL_REG, label, state_name(isp),
+                omap_readl(OTG_CTRL), label, state_name(isp),
                 ctrl, status, src);
         /* mode control and irq enables don't change much */
 #endif
@@ -429,7 +437,7 @@ dump_regs(struct isp1301 *isp, const char *label)
 static void check_state(struct isp1301 *isp, const char *tag)
 {
         enum usb_otg_state      state = OTG_STATE_UNDEFINED;
-        u8                      fsm = OTG_TEST_REG & 0x0ff;
+        u8                      fsm = omap_readw(OTG_TEST) & 0x0ff;
         unsigned                extra = 0;
 
         switch (fsm) {
@@ -494,7 +502,8 @@ static void check_state(struct isp1301 *isp, const char *tag)
         if (isp->otg.state == state && !extra)
                 return;
         pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
-                state_string(state), fsm, state_name(isp), OTG_CTRL_REG);
+                state_string(state), fsm, state_name(isp),
+                omap_readl(OTG_CTRL));
 }
 
 #else
@@ -508,10 +517,11 @@ static void update_otg1(struct isp1301 *isp, u8 int_src)
 {
         u32     otg_ctrl;
 
-        otg_ctrl = OTG_CTRL_REG
-                        & OTG_CTRL_MASK
-                        & ~OTG_XCEIV_INPUTS
-                        & ~(OTG_ID|OTG_ASESSVLD|OTG_VBUSVLD);
+        otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        otg_ctrl &= ~OTG_XCEIV_INPUTS;
+        otg_ctrl &= ~(OTG_ID|OTG_ASESSVLD|OTG_VBUSVLD);
+
+
         if (int_src & INTR_SESS_VLD)
                 otg_ctrl |= OTG_ASESSVLD;
         else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
@@ -534,7 +544,7 @@ static void update_otg1(struct isp1301 *isp, u8 int_src)
                         return;
                 }
         }
-        OTG_CTRL_REG = otg_ctrl;
+        omap_writel(otg_ctrl, OTG_CTRL);
 }
 
 /* outputs from ISP1301_OTG_STATUS */
@@ -542,15 +552,14 @@ static void update_otg2(struct isp1301 *isp, u8 otg_status)
 {
         u32     otg_ctrl;
 
-        otg_ctrl = OTG_CTRL_REG
-                        & OTG_CTRL_MASK
-                        & ~OTG_XCEIV_INPUTS
-                        & ~(OTG_BSESSVLD|OTG_BSESSEND);
+        otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        otg_ctrl &= ~OTG_XCEIV_INPUTS;
+        otg_ctrl &= ~(OTG_BSESSVLD | OTG_BSESSEND);
         if (otg_status & OTG_B_SESS_VLD)
                 otg_ctrl |= OTG_BSESSVLD;
         else if (otg_status & OTG_B_SESS_END)
                 otg_ctrl |= OTG_BSESSEND;
-        OTG_CTRL_REG = otg_ctrl;
+        omap_writel(otg_ctrl, OTG_CTRL);
 }
 
 /* inputs going to ISP1301 */
@@ -559,7 +568,7 @@ static void otg_update_isp(struct isp1301 *isp)
         u32     otg_ctrl, otg_change;
         u8      set = OTG1_DM_PULLDOWN, clr = OTG1_DM_PULLUP;
 
-        otg_ctrl = OTG_CTRL_REG;
+        otg_ctrl = omap_readl(OTG_CTRL);
         otg_change = otg_ctrl ^ isp->last_otg_ctrl;
         isp->last_otg_ctrl = otg_ctrl;
         otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
@@ -639,6 +648,8 @@ pulldown:
 
         /* HNP switch to host or peripheral; and SRP */
         if (otg_change & OTG_PULLUP) {
+                u32 l;
+
                 switch (isp->otg.state) {
                 case OTG_STATE_B_IDLE:
                         if (clr & OTG1_DP_PULLUP)
@@ -655,7 +666,9 @@ pulldown:
                 default:
                         break;
                 }
-                OTG_CTRL_REG |= OTG_PULLUP;
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_PULLUP;
+                omap_writel(l, OTG_CTRL);
         }
 
         check_state(isp, __func__);
@@ -664,20 +677,20 @@ pulldown:
 
 static irqreturn_t omap_otg_irq(int irq, void *_isp)
 {
-        u16             otg_irq = OTG_IRQ_SRC_REG;
+        u16             otg_irq = omap_readw(OTG_IRQ_SRC);
         u32             otg_ctrl;
         int             ret = IRQ_NONE;
         struct isp1301  *isp = _isp;
 
         /* update ISP1301 transciever from OTG controller */
         if (otg_irq & OPRT_CHG) {
-                OTG_IRQ_SRC_REG = OPRT_CHG;
+                omap_writew(OPRT_CHG, OTG_IRQ_SRC);
                 isp1301_defer_work(isp, WORK_UPDATE_ISP);
                 ret = IRQ_HANDLED;
 
         /* SRP to become b_peripheral failed */
         } else if (otg_irq & B_SRP_TMROUT) {
-                pr_debug("otg: B_SRP_TIMEOUT, %06x\n", OTG_CTRL_REG);
+                pr_debug("otg: B_SRP_TIMEOUT, %06x\n", omap_readl(OTG_CTRL));
                 notresponding(isp);
 
                 /* gadget drivers that care should monitor all kinds of
@@ -687,31 +700,31 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                 if (isp->otg.state == OTG_STATE_B_SRP_INIT)
                         b_idle(isp, "srp_timeout");
 
-                OTG_IRQ_SRC_REG = B_SRP_TMROUT;
+                omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
         /* HNP to become b_host failed */
         } else if (otg_irq & B_HNP_FAIL) {
                 pr_debug("otg: %s B_HNP_FAIL, %06x\n",
-                                state_name(isp), OTG_CTRL_REG);
+                                state_name(isp), omap_readl(OTG_CTRL));
                 notresponding(isp);
 
-                otg_ctrl = OTG_CTRL_REG;
+                otg_ctrl = omap_readl(OTG_CTRL);
                 otg_ctrl |= OTG_BUSDROP;
                 otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
-                OTG_CTRL_REG = otg_ctrl;
+                omap_writel(otg_ctrl, OTG_CTRL);
 
                 /* subset of b_peripheral()... */
                 isp->otg.state = OTG_STATE_B_PERIPHERAL;
                 pr_debug("  --> b_peripheral\n");
 
-                OTG_IRQ_SRC_REG = B_HNP_FAIL;
+                omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
         /* detect SRP from B-device ... */
         } else if (otg_irq & A_SRP_DETECT) {
                 pr_debug("otg: %s SRP_DETECT, %06x\n",
-                                state_name(isp), OTG_CTRL_REG);
+                                state_name(isp), omap_readl(OTG_CTRL));
 
                 isp1301_defer_work(isp, WORK_UPDATE_OTG);
                 switch (isp->otg.state) {
@@ -719,49 +732,49 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                         if (!isp->otg.host)
                                 break;
                         isp1301_defer_work(isp, WORK_HOST_RESUME);
-                        otg_ctrl = OTG_CTRL_REG;
+                        otg_ctrl = omap_readl(OTG_CTRL);
                         otg_ctrl |= OTG_A_BUSREQ;
                         otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
                                         & ~OTG_XCEIV_INPUTS
                                         & OTG_CTRL_MASK;
-                        OTG_CTRL_REG = otg_ctrl;
+                        omap_writel(otg_ctrl, OTG_CTRL);
                         break;
                 default:
                         break;
                 }
 
-                OTG_IRQ_SRC_REG = A_SRP_DETECT;
+                omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
         /* timer expired:  T(a_wait_bcon) and maybe T(a_wait_vrise)
          * we don't track them separately
          */
         } else if (otg_irq & A_REQ_TMROUT) {
-                otg_ctrl = OTG_CTRL_REG;
+                otg_ctrl = omap_readl(OTG_CTRL);
                 pr_info("otg: BCON_TMOUT from %s, %06x\n",
                                 state_name(isp), otg_ctrl);
                 notresponding(isp);
 
                 otg_ctrl |= OTG_BUSDROP;
                 otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
-                OTG_CTRL_REG = otg_ctrl;
+                omap_writel(otg_ctrl, OTG_CTRL);
                 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
 
-                OTG_IRQ_SRC_REG = A_REQ_TMROUT;
+                omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
         /* A-supplied voltage fell too low; overcurrent */
         } else if (otg_irq & A_VBUS_ERR) {
-                otg_ctrl = OTG_CTRL_REG;
+                otg_ctrl = omap_readl(OTG_CTRL);
                 printk(KERN_ERR "otg: %s, VBUS_ERR %04x ctrl %06x\n",
                         state_name(isp), otg_irq, otg_ctrl);
 
                 otg_ctrl |= OTG_BUSDROP;
                 otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
-                OTG_CTRL_REG = otg_ctrl;
+                omap_writel(otg_ctrl, OTG_CTRL);
                 isp->otg.state = OTG_STATE_A_VBUS_ERR;
 
-                OTG_IRQ_SRC_REG = A_VBUS_ERR;
+                omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
         /* switch driver; the transciever code activates it,
@@ -770,7 +783,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
         } else if (otg_irq & DRIVER_SWITCH) {
                 int     kick = 0;
 
-                otg_ctrl = OTG_CTRL_REG;
+                otg_ctrl = omap_readl(OTG_CTRL);
                 printk(KERN_NOTICE "otg: %s, SWITCH to %s, ctrl %06x\n",
                                 state_name(isp),
                                 (otg_ctrl & OTG_DRIVER_SEL)
@@ -793,7 +806,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                 } else {
                         if (!(otg_ctrl & OTG_ID)) {
                                 otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
-                                OTG_CTRL_REG = otg_ctrl | OTG_A_BUSREQ;
+                                omap_writel(otg_ctrl | OTG_A_BUSREQ, OTG_CTRL);
                         }
 
                         if (isp->otg.host) {
@@ -818,7 +831,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                         }
                 }
 
-                OTG_IRQ_SRC_REG = DRIVER_SWITCH;
+                omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
                 ret = IRQ_HANDLED;
 
                 if (kick)
@@ -834,12 +847,15 @@ static struct platform_device *otg_dev;
 
 static int otg_init(struct isp1301 *isp)
 {
+        u32 l;
+
         if (!otg_dev)
                 return -ENODEV;
 
         dump_regs(isp, __func__);
         /* some of these values are board-specific... */
-        OTG_SYSCON_2_REG |= OTG_EN
+        l = omap_readl(OTG_SYSCON_2);
+        l |= OTG_EN
                 /* for B-device: */
                 | SRP_GPDATA            /* 9msec Bdev D+ pulse */
                 | SRP_GPDVBUS           /* discharge after VBUS pulse */
@@ -849,18 +865,22 @@ static int otg_init(struct isp1301 *isp)
                 | SRP_DPW               /* detect 167+ns SRP pulses */
                 | SRP_DATA | SRP_VBUS   /* accept both kinds of SRP pulse */
                 ;
+        omap_writel(l, OTG_SYSCON_2);
 
         update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
         update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
 
         check_state(isp, __func__);
         pr_debug("otg: %s, %s %06x\n",
-                        state_name(isp), __func__, OTG_CTRL_REG);
+                        state_name(isp), __func__, omap_readl(OTG_CTRL));
 
-        OTG_IRQ_EN_REG = DRIVER_SWITCH | OPRT_CHG
+        omap_writew(DRIVER_SWITCH | OPRT_CHG
                         | B_SRP_TMROUT | B_HNP_FAIL
-                        | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT;
-        OTG_SYSCON_2_REG |= OTG_EN;
+                        | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT, OTG_IRQ_EN);
+
+        l = omap_readl(OTG_SYSCON_2);
+        l |= OTG_EN;
+        omap_writel(l, OTG_SYSCON_2);
 
         return 0;
 }
@@ -927,7 +947,11 @@ static void otg_unbind(struct isp1301 *isp)
 
 static void b_peripheral(struct isp1301 *isp)
 {
-        OTG_CTRL_REG = OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
+        u32 l;
+
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+
         usb_gadget_vbus_connect(isp->otg.gadget);
 
 #ifdef  CONFIG_USB_OTG
@@ -999,6 +1023,8 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                         isp_bstat = 0;
                 }
         } else {
+                u32 l;
+
                 /* if user unplugged mini-A end of cable,
                  * don't bypass A_WAIT_VFALL.
                  */
@@ -1019,8 +1045,9 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                                 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
                                                 MC1_BDIS_ACON_EN);
                                 isp->otg.state = OTG_STATE_B_IDLE;
-                                OTG_CTRL_REG &= OTG_CTRL_REG & OTG_CTRL_MASK
-                                                & ~OTG_CTRL_BITS;
+                                l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+                                l &= ~OTG_CTRL_BITS;
+                                omap_writel(l, OTG_CTRL);
                                 break;
                         case OTG_STATE_B_IDLE:
                                 break;
@@ -1046,7 +1073,8 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                         /* FALLTHROUGH */
                 case OTG_STATE_B_SRP_INIT:
                         b_idle(isp, __func__);
-                        OTG_CTRL_REG &= OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
+                        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+                        omap_writel(l, OTG_CTRL);
                         /* FALLTHROUGH */
                 case OTG_STATE_B_IDLE:
                         if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
@@ -1130,11 +1158,11 @@ isp1301_work(struct work_struct *work)
                         case OTG_STATE_A_WAIT_VRISE:
                                 isp->otg.state = OTG_STATE_A_HOST;
                                 pr_debug("  --> a_host\n");
-                                otg_ctrl = OTG_CTRL_REG;
+                                otg_ctrl = omap_readl(OTG_CTRL);
                                 otg_ctrl |= OTG_A_BUSREQ;
                                 otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
                                                 & OTG_CTRL_MASK;
-                                OTG_CTRL_REG = otg_ctrl;
+                                omap_writel(otg_ctrl, OTG_CTRL);
                                 break;
                         case OTG_STATE_B_WAIT_ACON:
                                 isp->otg.state = OTG_STATE_B_HOST;
@@ -1274,7 +1302,7 @@ isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
                 return -ENODEV;
 
         if (!host) {
-                OTG_IRQ_EN_REG = 0;
+                omap_writew(0, OTG_IRQ_EN);
                 power_down(isp);
                 isp->otg.host = 0;
                 return 0;
@@ -1325,12 +1353,13 @@ static int
 isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
 {
         struct isp1301  *isp = container_of(otg, struct isp1301, otg);
+        u32 l;
 
         if (!otg || isp != the_transceiver)
                 return -ENODEV;
 
         if (!gadget) {
-                OTG_IRQ_EN_REG = 0;
+                omap_writew(0, OTG_IRQ_EN);
                 if (!isp->otg.default_a)
                         enable_vbus_draw(isp, 0);
                 usb_gadget_vbus_disconnect(isp->otg.gadget);
@@ -1351,9 +1380,11 @@ isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
         isp->otg.gadget = gadget;
         // FIXME update its refcount
 
-        OTG_CTRL_REG = (OTG_CTRL_REG & OTG_CTRL_MASK
-                                & ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS))
-                        | OTG_ID;
+        l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        l &= ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS);
+        l |= OTG_ID;
+        omap_writel(l, OTG_CTRL);
+
         power_up(isp);
         isp->otg.state = OTG_STATE_B_IDLE;
 
@@ -1405,16 +1436,17 @@ isp1301_start_srp(struct otg_transceiver *dev)
                         || isp->otg.state != OTG_STATE_B_IDLE)
                 return -ENODEV;
 
-        otg_ctrl = OTG_CTRL_REG;
+        otg_ctrl = omap_readl(OTG_CTRL);
         if (!(otg_ctrl & OTG_BSESSEND))
                 return -EINVAL;
 
         otg_ctrl |= OTG_B_BUSREQ;
         otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK;
-        OTG_CTRL_REG = otg_ctrl;
+        omap_writel(otg_ctrl, OTG_CTRL);
         isp->otg.state = OTG_STATE_B_SRP_INIT;
 
-        pr_debug("otg: SRP, %s ... %06x\n", state_name(isp), OTG_CTRL_REG);
+        pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
+                        omap_readl(OTG_CTRL));
 #ifdef  CONFIG_USB_OTG
         check_state(isp, __func__);
 #endif
@@ -1426,6 +1458,7 @@ isp1301_start_hnp(struct otg_transceiver *dev)
 {
 #ifdef  CONFIG_USB_OTG
         struct isp1301  *isp = container_of(dev, struct isp1301, otg);
+        u32 l;
 
         if (!dev || isp != the_transceiver)
                 return -ENODEV;
@@ -1452,7 +1485,9 @@ isp1301_start_hnp(struct otg_transceiver *dev)
 #endif
                 /* caller must suspend then clear A_BUSREQ */
                 usb_gadget_vbus_connect(isp->otg.gadget);
-                OTG_CTRL_REG |= OTG_A_SETB_HNPEN;
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_A_SETB_HNPEN;
+                omap_writel(l, OTG_CTRL);
 
                 break;
         case OTG_STATE_A_PERIPHERAL:
@@ -1462,7 +1497,7 @@ isp1301_start_hnp(struct otg_transceiver *dev)
                 return -EILSEQ;
         }
         pr_debug("otg: HNP %s, %06x ...\n",
-                state_name(isp), OTG_CTRL_REG);
+                state_name(isp), omap_readl(OTG_CTRL));
         check_state(isp, __func__);
         return 0;
 #else
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 8e07de23d220..1607536ff5fb 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -823,6 +823,13 @@ config BLK_DEV_IDE_RAPIDE
           Say Y here if you want to support the Yellowstone RapIDE controller
           manufactured for use with Acorn computers.
 
+config BLK_DEV_IDE_BAST
+        tristate "Simtec BAST / Thorcom VR1000 IDE support"
+        depends on ARM && (ARCH_BAST || MACH_VR1000)
+        help
+          Say Y here if you want to support the onboard IDE channels on the
+          Simtec BAST or the Thorcom VR1000
+
 config IDE_H8300
         tristate "H8300 IDE support"
         depends on H8300
diff --git a/drivers/ide/arm/Makefile b/drivers/ide/arm/Makefile
index 5bc26053afa6..936e7b0237f5 100644
--- a/drivers/ide/arm/Makefile
+++ b/drivers/ide/arm/Makefile
@@ -1,6 +1,7 @@
 
 obj-$(CONFIG_BLK_DEV_IDE_ICSIDE)        += icside.o
 obj-$(CONFIG_BLK_DEV_IDE_RAPIDE)        += rapide.o
+obj-$(CONFIG_BLK_DEV_IDE_BAST)          += bast-ide.o
 obj-$(CONFIG_BLK_DEV_PALMCHIP_BK3710)   += palm_bk3710.o
 
 ifeq ($(CONFIG_IDE_ARM), m)
diff --git a/drivers/ide/arm/bast-ide.c b/drivers/ide/arm/bast-ide.c
new file mode 100644
index 000000000000..8e8c28104b45
--- /dev/null
+++ b/drivers/ide/arm/bast-ide.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2003-2004 Simtec Electronics
+ *  Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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/module.h>
+#include <linux/errno.h>
+#include <linux/ide.h>
+#include <linux/init.h>
+
+#include <asm/mach-types.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/arch/map.h>
+#include <asm/arch/bast-map.h>
+#include <asm/arch/bast-irq.h>
+
+#define DRV_NAME "bast-ide"
+
+static int __init bastide_register(unsigned int base, unsigned int aux, int irq)
+{
+        ide_hwif_t *hwif;
+        hw_regs_t hw;
+        int i;
+        u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
+
+        memset(&hw, 0, sizeof(hw));
+
+        base += BAST_IDE_CS;
+        aux  += BAST_IDE_CS;
+
+        for (i = 0; i <= 7; i++) {
+                hw.io_ports_array[i] = (unsigned long)base;
+                base += 0x20;
+        }
+
+        hw.io_ports.ctl_addr = aux + (6 * 0x20);
+        hw.irq = irq;
+        hw.chipset = ide_generic;
+
+        hwif = ide_find_port();
+        if (hwif == NULL)
+                goto out;
+
+        i = hwif->index;
+
+        ide_init_port_data(hwif, i);
+        ide_init_port_hw(hwif, &hw);
+        hwif->port_ops = NULL;
+
+        idx[0] = i;
+
+        ide_device_add(idx, NULL);
+out:
+        return 0;
+}
+
+static int __init bastide_init(void)
+{
+        unsigned long base = BAST_VA_IDEPRI + BAST_IDE_CS;
+
+        /* we can treat the VR1000 and the BAST the same */
+
+        if (!(machine_is_bast() || machine_is_vr1000()))
+                return 0;
+
+        printk("BAST: IDE driver, (c) 2003-2004 Simtec Electronics\n");
+
+        if (!request_mem_region(base, 0x400000, DRV_NAME)) {
+                printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
+                return -EBUSY;
+        }
+
+        bastide_register(BAST_VA_IDEPRI, BAST_VA_IDEPRIAUX, IRQ_IDE0);
+        bastide_register(BAST_VA_IDESEC, BAST_VA_IDESECAUX, IRQ_IDE1);
+
+        return 0;
+}
+
+module_init(bastide_init);
+
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Simtec BAST / Thorcom VR1000 IDE driver");
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index 55ec7f798772..8af88bf0969b 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -76,7 +76,7 @@ static int proc_ide_read_mate
         ide_hwif_t      *hwif = (ide_hwif_t *) data;
         int             len;
 
-        if (hwif && hwif->mate && hwif->mate->present)
+        if (hwif && hwif->mate)
                 len = sprintf(page, "%s\n", hwif->mate->name);
         else
                 len = sprintf(page, "(none)\n");
diff --git a/drivers/input/ff-core.c b/drivers/input/ff-core.c
index eebc72465fc9..72c63e5dd630 100644
--- a/drivers/input/ff-core.c
+++ b/drivers/input/ff-core.c
@@ -28,6 +28,7 @@
 #include <linux/input.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/sched.h>
 
 /*
  * Check that the effect_id is a valid effect and whether the user
@@ -166,8 +167,10 @@ int input_ff_upload(struct input_dev *dev, struct ff_effect *effect,
         if (ret)
                 goto out;
 
+        spin_lock_irq(&dev->event_lock);
         ff->effects[id] = *effect;
         ff->effect_owners[id] = file;
+        spin_unlock_irq(&dev->event_lock);
 
  out:
         mutex_unlock(&ff->mutex);
@@ -189,16 +192,22 @@ static int erase_effect(struct input_dev *dev, int effect_id,
         if (error)
                 return error;
 
+        spin_lock_irq(&dev->event_lock);
         ff->playback(dev, effect_id, 0);
+        ff->effect_owners[effect_id] = NULL;
+        spin_unlock_irq(&dev->event_lock);
 
         if (ff->erase) {
                 error = ff->erase(dev, effect_id);
-                if (error)
+                if (error) {
+                        spin_lock_irq(&dev->event_lock);
+                        ff->effect_owners[effect_id] = file;
+                        spin_unlock_irq(&dev->event_lock);
+
                         return error;
+                }
         }
 
-        ff->effect_owners[effect_id] = NULL;
-
         return 0;
 }
 
@@ -263,8 +272,6 @@ int input_ff_event(struct input_dev *dev, unsigned int type,
         if (type != EV_FF)
                 return 0;
 
-        mutex_lock(&ff->mutex);
-
         switch (code) {
         case FF_GAIN:
                 if (!test_bit(FF_GAIN, dev->ffbit) || value > 0xffff)
@@ -286,7 +293,6 @@ int input_ff_event(struct input_dev *dev, unsigned int type,
                 break;
         }
 
-        mutex_unlock(&ff->mutex);
         return 0;
 }
 EXPORT_SYMBOL_GPL(input_ff_event);
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 835def11419d..ab6a61db63ce 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -432,6 +432,7 @@ static int crypt_convert(struct crypt_config *cc,
                 case 0:
                         atomic_dec(&ctx->pending);
                         ctx->sector++;
+                        cond_resched();
                         continue;
 
                 /* error */
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 7cf512a34ccf..2580ac1b9b0f 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -3897,8 +3897,10 @@ static void autorun_devices(int part)
 
                 md_probe(dev, NULL, NULL);
                 mddev = mddev_find(dev);
-                if (!mddev) {
-                        printk(KERN_ERR 
+                if (!mddev || !mddev->gendisk) {
+                        if (mddev)
+                                mddev_put(mddev);
+                        printk(KERN_ERR
                                 "md: cannot allocate memory for md drive.\n");
                         break;
                 }
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 1de17da34a95..a71277b640ab 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2137,6 +2137,8 @@ static int run(mddev_t *mddev)
                     !test_bit(In_sync, &disk->rdev->flags)) {
                         disk->head_position = 0;
                         mddev->degraded++;
+                        if (disk->rdev)
+                                conf->fullsync = 1;
                 }
         }
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index c37e256b1176..54c8ee28fcc4 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2898,6 +2898,8 @@ static void handle_stripe5(struct stripe_head *sh)
 
                 for (i = conf->raid_disks; i--; ) {
                         set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                        set_bit(R5_LOCKED, &dev->flags);
+                        s.locked++;
                         if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
                                 sh->ops.count++;
                 }
@@ -2911,6 +2913,7 @@ static void handle_stripe5(struct stripe_head *sh)
                         conf->raid_disks);
                 s.locked += handle_write_operations5(sh, 1, 1);
         } else if (s.expanded &&
+                   s.locked == 0 &&
                 !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
                 clear_bit(STRIPE_EXPAND_READY, &sh->state);
                 atomic_dec(&conf->reshape_stripes);
@@ -4305,7 +4308,9 @@ static int run(mddev_t *mddev)
                                 " disk %d\n", bdevname(rdev->bdev,b),
                                 raid_disk);
                         working_disks++;
-                }
+                } else
+                        /* Cannot rely on bitmap to complete recovery */
+                        conf->fullsync = 1;
         }
 
         /*
diff --git a/drivers/media/common/ir-keymaps.c b/drivers/media/common/ir-keymaps.c
index a3485817e46c..8fa91f846d59 100644
--- a/drivers/media/common/ir-keymaps.c
+++ b/drivers/media/common/ir-keymaps.c
@@ -2201,3 +2201,41 @@ IR_KEYTAB_TYPE ir_codes_powercolor_real_angel[IR_KEYTAB_SIZE] = {
         [0x25] = KEY_POWER,             /* power */
 };
 EXPORT_SYMBOL_GPL(ir_codes_powercolor_real_angel);
+
+IR_KEYTAB_TYPE ir_codes_avermedia_a16d[IR_KEYTAB_SIZE] = {
+        [0x20] = KEY_LIST,
+        [0x00] = KEY_POWER,
+        [0x28] = KEY_1,
+        [0x18] = KEY_2,
+        [0x38] = KEY_3,
+        [0x24] = KEY_4,
+        [0x14] = KEY_5,
+        [0x34] = KEY_6,
+        [0x2c] = KEY_7,
+        [0x1c] = KEY_8,
+        [0x3c] = KEY_9,
+        [0x12] = KEY_SUBTITLE,
+        [0x22] = KEY_0,
+        [0x32] = KEY_REWIND,
+        [0x3a] = KEY_SHUFFLE,
+        [0x02] = KEY_PRINT,
+        [0x11] = KEY_CHANNELDOWN,
+        [0x31] = KEY_CHANNELUP,
+        [0x0c] = KEY_ZOOM,
+        [0x1e] = KEY_VOLUMEDOWN,
+        [0x3e] = KEY_VOLUMEUP,
+        [0x0a] = KEY_MUTE,
+        [0x04] = KEY_AUDIO,
+        [0x26] = KEY_RECORD,
+        [0x06] = KEY_PLAY,
+        [0x36] = KEY_STOP,
+        [0x16] = KEY_PAUSE,
+        [0x2e] = KEY_REWIND,
+        [0x0e] = KEY_FASTFORWARD,
+        [0x30] = KEY_TEXT,
+        [0x21] = KEY_GREEN,
+        [0x01] = KEY_BLUE,
+        [0x08] = KEY_EPG,
+        [0x2a] = KEY_MENU,
+};
+EXPORT_SYMBOL_GPL(ir_codes_avermedia_a16d);
diff --git a/drivers/media/common/tuners/tda18271-common.c b/drivers/media/common/tuners/tda18271-common.c
index f1894fec32b9..6fb5b4586569 100644
--- a/drivers/media/common/tuners/tda18271-common.c
+++ b/drivers/media/common/tuners/tda18271-common.c
@@ -649,9 +649,17 @@ int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq)
         u8 val;
 
         int ret = tda18271_lookup_map(fe, RF_CAL, freq, &val);
+        /* The TDA18271HD/C1 rf_cal map lookup is expected to go out of range
+         * for frequencies above 61.1 MHz.  In these cases, the internal RF
+         * tracking filters calibration mechanism is used.
+         *
+         * There is no need to warn the user about this.
+         */
+        if (ret < 0)
+                goto fail;
 
         regs[R_EB14] = val;
-
+fail:
         return ret;
 }
 
diff --git a/drivers/media/common/tuners/tda18271-fe.c b/drivers/media/common/tuners/tda18271-fe.c
index 89c01fb1f859..93063c6fbbf6 100644
--- a/drivers/media/common/tuners/tda18271-fe.c
+++ b/drivers/media/common/tuners/tda18271-fe.c
@@ -45,6 +45,21 @@ static inline int charge_pump_source(struct dvb_frontend *fe, int force)
                                            TDA18271_MAIN_PLL, force);
 }
 
+static inline void tda18271_set_if_notch(struct dvb_frontend *fe)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
+        unsigned char *regs = priv->tda18271_regs;
+
+        switch (priv->mode) {
+        case TDA18271_ANALOG:
+                regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
+                break;
+        case TDA18271_DIGITAL:
+                regs[R_MPD]  |= 0x80; /* IF notch = 1 */
+                break;
+        }
+}
+
 static int tda18271_channel_configuration(struct dvb_frontend *fe,
                                           struct tda18271_std_map_item *map,
                                           u32 freq, u32 bw)
@@ -60,25 +75,18 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
         regs[R_EP3]  &= ~0x1f; /* clear std bits */
         regs[R_EP3]  |= (map->agc_mode << 3) | map->std;
 
-        /* set rfagc to high speed mode */
-        regs[R_EP3] &= ~0x04;
+        if (priv->id == TDA18271HDC2) {
+                /* set rfagc to high speed mode */
+                regs[R_EP3] &= ~0x04;
+        }
 
         /* set cal mode to normal */
         regs[R_EP4]  &= ~0x03;
 
-        /* update IF output level & IF notch frequency */
+        /* update IF output level */
         regs[R_EP4]  &= ~0x1c; /* clear if level bits */
         regs[R_EP4]  |= (map->if_lvl << 2);
 
-        switch (priv->mode) {
-        case TDA18271_ANALOG:
-                regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
-                break;
-        case TDA18271_DIGITAL:
-                regs[R_MPD]  |= 0x80; /* IF notch = 1 */
-                break;
-        }
-
         /* update FM_RFn */
         regs[R_EP4]  &= ~0x80;
         regs[R_EP4]  |= map->fm_rfn << 7;
@@ -95,6 +103,9 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
         /* disable Power Level Indicator */
         regs[R_EP1]  |= 0x40;
 
+        /* make sure thermometer is off */
+        regs[R_TM]   &= ~0x10;
+
         /* frequency dependent parameters */
 
         tda18271_calc_ir_measure(fe, &freq);
@@ -135,6 +146,7 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
         switch (priv->role) {
         case TDA18271_MASTER:
                 tda18271_calc_main_pll(fe, N);
+                tda18271_set_if_notch(fe);
                 tda18271_write_regs(fe, R_MPD, 4);
                 break;
         case TDA18271_SLAVE:
@@ -142,6 +154,7 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
                 tda18271_write_regs(fe, R_CPD, 4);
 
                 regs[R_MPD] = regs[R_CPD] & 0x7f;
+                tda18271_set_if_notch(fe);
                 tda18271_write_regs(fe, R_MPD, 1);
                 break;
         }
@@ -160,12 +173,14 @@ static int tda18271_channel_configuration(struct dvb_frontend *fe,
 
         msleep(20);
 
-        /* set rfagc to normal speed mode */
-        if (map->fm_rfn)
-                regs[R_EP3] &= ~0x04;
-        else
-                regs[R_EP3] |= 0x04;
-        ret = tda18271_write_regs(fe, R_EP3, 1);
+        if (priv->id == TDA18271HDC2) {
+                /* set rfagc to normal speed mode */
+                if (map->fm_rfn)
+                        regs[R_EP3] &= ~0x04;
+                else
+                        regs[R_EP3] |= 0x04;
+                ret = tda18271_write_regs(fe, R_EP3, 1);
+        }
 fail:
         return ret;
 }
@@ -507,7 +522,7 @@ static int tda18271_powerscan_init(struct dvb_frontend *fe)
         /* set cal mode to normal */
         regs[R_EP4]  &= ~0x03;
 
-        /* update IF output level & IF notch frequency */
+        /* update IF output level */
         regs[R_EP4]  &= ~0x1c; /* clear if level bits */
 
         ret = tda18271_write_regs(fe, R_EP3, 2);
diff --git a/drivers/media/common/tuners/xc5000.c b/drivers/media/common/tuners/xc5000.c
index ceae6db901ec..7cf4f5bdb2ec 100644
--- a/drivers/media/common/tuners/xc5000.c
+++ b/drivers/media/common/tuners/xc5000.c
@@ -177,6 +177,7 @@ static XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
         {"FM Radio-INPUT1",   0x0208, 0x9002}
 };
 
+static int  xc5000_is_firmware_loaded(struct dvb_frontend *fe);
 static int  xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
 static int  xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
 static void xc5000_TunerReset(struct dvb_frontend *fe);
@@ -352,7 +353,7 @@ static int xc_SetTVStandard(struct xc5000_priv *priv,
 
 static int xc_shutdown(struct xc5000_priv *priv)
 {
-        return 0;
+        return XC_RESULT_SUCCESS;
         /* Fixme: cannot bring tuner back alive once shutdown
          *        without reloading the driver modules.
          *    return xc_write_reg(priv, XREG_POWER_DOWN, 0);
@@ -685,6 +686,25 @@ static int xc5000_set_params(struct dvb_frontend *fe,
         return 0;
 }
 
+static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
+{
+        struct xc5000_priv *priv = fe->tuner_priv;
+        int ret;
+        u16 id;
+
+        ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
+        if (ret == XC_RESULT_SUCCESS) {
+                if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
+                        ret = XC_RESULT_RESET_FAILURE;
+                else
+                        ret = XC_RESULT_SUCCESS;
+        }
+
+        dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
+                ret == XC_RESULT_SUCCESS ? "True" : "False", id);
+        return ret;
+}
+
 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
 
 static int xc5000_set_analog_params(struct dvb_frontend *fe,
@@ -693,7 +713,7 @@ static int xc5000_set_analog_params(struct dvb_frontend *fe,
         struct xc5000_priv *priv = fe->tuner_priv;
         int ret;
 
-        if(priv->fwloaded == 0)
+        if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
                 xc_load_fw_and_init_tuner(fe);
 
         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
@@ -808,11 +828,10 @@ static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
         struct xc5000_priv *priv = fe->tuner_priv;
         int ret = 0;
 
-        if (priv->fwloaded == 0) {
+        if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
                 ret = xc5000_fwupload(fe);
                 if (ret != XC_RESULT_SUCCESS)
                         return ret;
-                priv->fwloaded = 1;
         }
 
         /* Start the tuner self-calibration process */
@@ -852,7 +871,6 @@ static int xc5000_sleep(struct dvb_frontend *fe)
                 return -EREMOTEIO;
         }
         else {
-                /* priv->fwloaded = 0; */
                 return XC_RESULT_SUCCESS;
         }
 }
@@ -933,7 +951,6 @@ struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
                         cfg->i2c_address);
                 printk(KERN_INFO
                         "xc5000: Firmware has been loaded previously\n");
-                priv->fwloaded = 1;
                 break;
         case XC_PRODUCT_ID_FW_NOT_LOADED:
                 printk(KERN_INFO
@@ -941,7 +958,6 @@ struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
                         cfg->i2c_address);
                 printk(KERN_INFO
                         "xc5000: Firmware has not been loaded previously\n");
-                priv->fwloaded = 0;
                 break;
         default:
                 printk(KERN_ERR
diff --git a/drivers/media/common/tuners/xc5000_priv.h b/drivers/media/common/tuners/xc5000_priv.h
index ecebfe4745ad..a72a9887fe7f 100644
--- a/drivers/media/common/tuners/xc5000_priv.h
+++ b/drivers/media/common/tuners/xc5000_priv.h
@@ -30,7 +30,6 @@ struct xc5000_priv {
         u32 bandwidth;
         u8  video_standard;
         u8  rf_mode;
-        u8  fwloaded;
 
         void *devptr;
 };
diff --git a/drivers/media/dvb/dvb-usb/gl861.c b/drivers/media/dvb/dvb-usb/gl861.c
index 0a8ac64a4e33..037f7ffb47b2 100644
--- a/drivers/media/dvb/dvb-usb/gl861.c
+++ b/drivers/media/dvb/dvb-usb/gl861.c
@@ -47,6 +47,8 @@ static int gl861_i2c_msg(struct dvb_usb_device *d, u8 addr,
                 return -EINVAL;
         }
 
+        msleep(1); /* avoid I2C errors */
+
         return usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), req, type,
                                value, index, rbuf, rlen, 2000);
 }
@@ -92,16 +94,6 @@ static struct i2c_algorithm gl861_i2c_algo = {
 };
 
 /* Callbacks for DVB USB */
-static int gl861_identify_state(struct usb_device *udev,
-                                struct dvb_usb_device_properties *props,
-                                struct dvb_usb_device_description **desc,
-                                int *cold)
-{
-        *cold = 0;
-
-        return 0;
-}
-
 static struct zl10353_config gl861_zl10353_config = {
         .demod_address = 0x0f,
         .no_tuner = 1,
@@ -172,7 +164,6 @@ static struct dvb_usb_device_properties gl861_properties = {
 
         .size_of_priv     = 0,
 
-        .identify_state   = gl861_identify_state,
         .num_adapters = 1,
         .adapter = {{
 
@@ -194,13 +185,15 @@ static struct dvb_usb_device_properties gl861_properties = {
 
         .num_device_descs = 2,
         .devices = {
-                {   "MSI Mega Sky 55801 DVB-T USB2.0",
-                        { &gl861_table[0], NULL },
-                        { NULL },
+                {
+                        .name = "MSI Mega Sky 55801 DVB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &gl861_table[0], NULL },
                 },
-                {   "A-LINK DTU DVB-T USB2.0",
-                        { &gl861_table[1], NULL },
-                        { NULL },
+                {
+                        .name = "A-LINK DTU DVB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &gl861_table[1], NULL },
                 },
         }
 };
diff --git a/drivers/media/dvb/dvb-usb/umt-010.c b/drivers/media/dvb/dvb-usb/umt-010.c
index 9e7653bb3b66..118aab1a3e54 100644
--- a/drivers/media/dvb/dvb-usb/umt-010.c
+++ b/drivers/media/dvb/dvb-usb/umt-010.c
@@ -107,7 +107,7 @@ static struct dvb_usb_device_properties umt_properties = {
                         /* parameter for the MPEG2-data transfer */
                         .stream = {
                                 .type = USB_BULK,
-                                .count = 20,
+                                .count = MAX_NO_URBS_FOR_DATA_STREAM,
                                 .endpoint = 0x06,
                                 .u = {
                                         .bulk = {
diff --git a/drivers/media/dvb/frontends/au8522.c b/drivers/media/dvb/frontends/au8522.c
index 084a280c2d7f..03900d241a76 100644
--- a/drivers/media/dvb/frontends/au8522.c
+++ b/drivers/media/dvb/frontends/au8522.c
@@ -463,10 +463,13 @@ static int au8522_set_frontend(struct dvb_frontend *fe,
                                struct dvb_frontend_parameters *p)
 {
         struct au8522_state *state = fe->demodulator_priv;
+        int ret = -EINVAL;
 
         dprintk("%s(frequency=%d)\n", __func__, p->frequency);
 
-        state->current_frequency = p->frequency;
+        if ((state->current_frequency == p->frequency) &&
+            (state->current_modulation == p->u.vsb.modulation))
+                return 0;
 
         au8522_enable_modulation(fe, p->u.vsb.modulation);
 
@@ -476,11 +479,16 @@ static int au8522_set_frontend(struct dvb_frontend *fe,
         if (fe->ops.tuner_ops.set_params) {
                 if (fe->ops.i2c_gate_ctrl)
                         fe->ops.i2c_gate_ctrl(fe, 1);
-                fe->ops.tuner_ops.set_params(fe, p);
+                ret = fe->ops.tuner_ops.set_params(fe, p);
                 if (fe->ops.i2c_gate_ctrl)
                         fe->ops.i2c_gate_ctrl(fe, 0);
         }
 
+        if (ret < 0)
+                return ret;
+
+        state->current_frequency = p->frequency;
+
         return 0;
 }
 
@@ -498,6 +506,16 @@ static int au8522_init(struct dvb_frontend *fe)
         return 0;
 }
 
+static int au8522_sleep(struct dvb_frontend *fe)
+{
+        struct au8522_state *state = fe->demodulator_priv;
+        dprintk("%s()\n", __func__);
+
+        state->current_frequency = 0;
+
+        return 0;
+}
+
 static int au8522_read_status(struct dvb_frontend *fe, fe_status_t *status)
 {
         struct au8522_state *state = fe->demodulator_priv;
@@ -509,10 +527,8 @@ static int au8522_read_status(struct dvb_frontend *fe, fe_status_t *status)
         if (state->current_modulation == VSB_8) {
                 dprintk("%s() Checking VSB_8\n", __func__);
                 reg = au8522_readreg(state, 0x4088);
-                if (reg & 0x01)
-                        *status |= FE_HAS_VITERBI;
-                if (reg & 0x02)
-                        *status |= FE_HAS_LOCK | FE_HAS_SYNC;
+                if ((reg & 0x03) == 0x03)
+                        *status |= FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI;
         } else {
                 dprintk("%s() Checking QAM\n", __func__);
                 reg = au8522_readreg(state, 0x4541);
@@ -672,6 +688,7 @@ static struct dvb_frontend_ops au8522_ops = {
         },
 
         .init                 = au8522_init,
+        .sleep                = au8522_sleep,
         .i2c_gate_ctrl        = au8522_i2c_gate_ctrl,
         .set_frontend         = au8522_set_frontend,
         .get_frontend         = au8522_get_frontend,
diff --git a/drivers/media/dvb/frontends/stv0299.c b/drivers/media/dvb/frontends/stv0299.c
index 17556183e871..35435bef8e79 100644
--- a/drivers/media/dvb/frontends/stv0299.c
+++ b/drivers/media/dvb/frontends/stv0299.c
@@ -63,6 +63,7 @@ struct stv0299_state {
         u32 symbol_rate;
         fe_code_rate_t fec_inner;
         int errmode;
+        u32 ucblocks;
 };
 
 #define STATUS_BER 0
@@ -501,8 +502,10 @@ static int stv0299_read_ber(struct dvb_frontend* fe, u32* ber)
 {
         struct stv0299_state* state = fe->demodulator_priv;
 
-        if (state->errmode != STATUS_BER) return 0;
-        *ber = (stv0299_readreg (state, 0x1d) << 8) | stv0299_readreg (state, 0x1e);
+        if (state->errmode != STATUS_BER)
+                return -ENOSYS;
+
+        *ber = stv0299_readreg(state, 0x1e) | (stv0299_readreg(state, 0x1d) << 8);
 
         return 0;
 }
@@ -540,8 +543,12 @@ static int stv0299_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 {
         struct stv0299_state* state = fe->demodulator_priv;
 
-        if (state->errmode != STATUS_UCBLOCKS) *ucblocks = 0;
-        else *ucblocks = (stv0299_readreg (state, 0x1d) << 8) | stv0299_readreg (state, 0x1e);
+        if (state->errmode != STATUS_UCBLOCKS)
+                return -ENOSYS;
+
+        state->ucblocks += stv0299_readreg(state, 0x1e);
+        state->ucblocks += (stv0299_readreg(state, 0x1d) << 8);
+        *ucblocks = state->ucblocks;
 
         return 0;
 }
diff --git a/drivers/media/dvb/frontends/tda10023.c b/drivers/media/dvb/frontends/tda10023.c
index 0727b80bc4d2..c6ff5b82ff80 100644
--- a/drivers/media/dvb/frontends/tda10023.c
+++ b/drivers/media/dvb/frontends/tda10023.c
@@ -116,9 +116,12 @@ static u8 tda10023_readreg (struct tda10023_state* state, u8 reg)
         int ret;
 
         ret = i2c_transfer (state->i2c, msg, 2);
-        if (ret != 2)
-                printk("DVB: TDA10023: %s: readreg error (ret == %i)\n",
-                                 __func__, ret);
+        if (ret != 2) {
+                int num = state->frontend.dvb ? state->frontend.dvb->num : -1;
+                printk(KERN_ERR "DVB: TDA10023(%d): %s: readreg error "
+                        "(reg == 0x%02x, ret == %i)\n",
+                        num, __func__, reg, ret);
+        }
         return b1[0];
 }
 
@@ -129,11 +132,12 @@ static int tda10023_writereg (struct tda10023_state* state, u8 reg, u8 data)
         int ret;
 
         ret = i2c_transfer (state->i2c, &msg, 1);
-        if (ret != 1)
-                printk("DVB: TDA10023(%d): %s, writereg error "
+        if (ret != 1) {
+                int num = state->frontend.dvb ? state->frontend.dvb->num : -1;
+                printk(KERN_ERR "DVB: TDA10023(%d): %s, writereg error "
                         "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        state->frontend.dvb->num, __func__, reg, data, ret);
-
+                        num, __func__, reg, data, ret);
+        }
         return (ret != 1) ? -EREMOTEIO : 0;
 }
 
@@ -464,7 +468,7 @@ struct dvb_frontend* tda10023_attach(const struct tda1002x_config* config,
         int i;
 
         /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct tda10023_state), GFP_KERNEL);
+        state = kzalloc(sizeof(struct tda10023_state), GFP_KERNEL);
         if (state == NULL) goto error;
 
         /* setup the state */
diff --git a/drivers/media/dvb/frontends/tda1004x.c b/drivers/media/dvb/frontends/tda1004x.c
index 49973846373e..a0d638653567 100644
--- a/drivers/media/dvb/frontends/tda1004x.c
+++ b/drivers/media/dvb/frontends/tda1004x.c
@@ -1248,11 +1248,14 @@ struct dvb_frontend* tda10045_attach(const struct tda1004x_config* config,
                                      struct i2c_adapter* i2c)
 {
         struct tda1004x_state *state;
+        int id;
 
         /* allocate memory for the internal state */
         state = kmalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
-        if (!state)
+        if (!state) {
+                printk(KERN_ERR "Can't alocate memory for tda10045 state\n");
                 return NULL;
+        }
 
         /* setup the state */
         state->config = config;
@@ -1260,7 +1263,15 @@ struct dvb_frontend* tda10045_attach(const struct tda1004x_config* config,
         state->demod_type = TDA1004X_DEMOD_TDA10045;
 
         /* check if the demod is there */
-        if (tda1004x_read_byte(state, TDA1004X_CHIPID) != 0x25) {
+        id = tda1004x_read_byte(state, TDA1004X_CHIPID);
+        if (id < 0) {
+                printk(KERN_ERR "tda10045: chip is not answering. Giving up.\n");
+                kfree(state);
+                return NULL;
+        }
+
+        if (id != 0x25) {
+                printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
                 kfree(state);
                 return NULL;
         }
@@ -1307,11 +1318,14 @@ struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config,
                                      struct i2c_adapter* i2c)
 {
         struct tda1004x_state *state;
+        int id;
 
         /* allocate memory for the internal state */
         state = kmalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
-        if (!state)
+        if (!state) {
+                printk(KERN_ERR "Can't alocate memory for tda10046 state\n");
                 return NULL;
+        }
 
         /* setup the state */
         state->config = config;
@@ -1319,7 +1333,14 @@ struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config,
         state->demod_type = TDA1004X_DEMOD_TDA10046;
 
         /* check if the demod is there */
-        if (tda1004x_read_byte(state, TDA1004X_CHIPID) != 0x46) {
+        id = tda1004x_read_byte(state, TDA1004X_CHIPID);
+        if (id < 0) {
+                printk(KERN_ERR "tda10046: chip is not answering. Giving up.\n");
+                kfree(state);
+                return NULL;
+        }
+        if (id != 0x46) {
+                printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
                 kfree(state);
                 return NULL;
         }
diff --git a/drivers/media/dvb/ttpci/Kconfig b/drivers/media/dvb/ttpci/Kconfig
index d4339b1b3b68..07643e010093 100644
--- a/drivers/media/dvb/ttpci/Kconfig
+++ b/drivers/media/dvb/ttpci/Kconfig
@@ -101,6 +101,7 @@ config DVB_BUDGET
 config DVB_BUDGET_CI
         tristate "Budget cards with onboard CI connector"
         depends on DVB_BUDGET_CORE && I2C
+        depends on INPUT # due to IR
         select DVB_STV0297 if !DVB_FE_CUSTOMISE
         select DVB_STV0299 if !DVB_FE_CUSTOMISE
         select DVB_TDA1004X if !DVB_FE_CUSTOMISE
diff --git a/drivers/media/dvb/ttpci/av7110_hw.c b/drivers/media/dvb/ttpci/av7110_hw.c
index 9d81074b31df..3a3f5279e927 100644
--- a/drivers/media/dvb/ttpci/av7110_hw.c
+++ b/drivers/media/dvb/ttpci/av7110_hw.c
@@ -427,6 +427,7 @@ static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                         if (err) {
                                 printk(KERN_ERR "%s: timeout waiting on busy %s QUEUE\n",
                                         __func__, type);
+                                av7110->arm_errors++;
                                 return -ETIMEDOUT;
                         }
                         msleep(1);
@@ -853,10 +854,8 @@ static osd_raw_window_t bpp2bit[8] = {
 
 static inline int WaitUntilBmpLoaded(struct av7110 *av7110)
 {
-        int ret = wait_event_interruptible_timeout(av7110->bmpq,
+        int ret = wait_event_timeout(av7110->bmpq,
                                 av7110->bmp_state != BMP_LOADING, 10*HZ);
-        if (ret == -ERESTARTSYS)
-                return ret;
         if (ret == 0) {
                 printk("dvb-ttpci: warning: timeout waiting in LoadBitmap: %d, %d\n",
                        ret, av7110->bmp_state);
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 3b26fbd3e558..5ccb0aeca8cc 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -793,6 +793,14 @@ menuconfig V4L_USB_DRIVERS
 
 if V4L_USB_DRIVERS && USB
 
+config USB_VIDEO_CLASS
+        tristate "USB Video Class (UVC)"
+        ---help---
+          Support for the USB Video Class (UVC).  Currently only video
+          input devices, such as webcams, are supported.
+
+          For more information see: <http://linux-uvc.berlios.de/>
+
 source "drivers/media/video/pvrusb2/Kconfig"
 
 source "drivers/media/video/em28xx/Kconfig"
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index dff0d6abe917..ecbbfaab24d5 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -136,6 +136,8 @@ obj-$(CONFIG_SOC_CAMERA_MT9V022)	+= mt9v022.o
 
 obj-$(CONFIG_VIDEO_AU0828) += au0828/
 
+obj-$(CONFIG_USB_VIDEO_CLASS)   += uvc/
+
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 EXTRA_CFLAGS += -Idrivers/media/common/tuners
diff --git a/drivers/media/video/au0828/au0828-cards.c b/drivers/media/video/au0828/au0828-cards.c
index a2a6983444fa..898e12395e7c 100644
--- a/drivers/media/video/au0828/au0828-cards.c
+++ b/drivers/media/video/au0828/au0828-cards.c
@@ -77,8 +77,14 @@ static void hauppauge_eeprom(struct au0828_dev *dev, u8 *eeprom_data)
 
         /* Make sure we support the board model */
         switch (tv.model) {
+        case 72000: /* WinTV-HVR950q (Retail, IR, ATSC/QAM */
         case 72001: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and basic analog video */
+        case 72211: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and basic analog video */
+        case 72221: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and basic analog video */
+        case 72231: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and basic analog video */
+        case 72241: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and basic analog video */
         case 72301: /* WinTV-HVR850 (Retail, IR, ATSC and basic analog video */
+        case 72500: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM */
                 break;
         default:
                 printk(KERN_WARNING "%s: warning: "
@@ -175,6 +181,18 @@ struct usb_device_id au0828_usb_id_table [] = {
                 .driver_info = AU0828_BOARD_HAUPPAUGE_HVR850 },
         { USB_DEVICE(0x0fe9, 0xd620),
                 .driver_info = AU0828_BOARD_DVICO_FUSIONHDTV7 },
+        { USB_DEVICE(0x2040, 0x7210),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x2040, 0x7217),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x2040, 0x721b),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x2040, 0x721f),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x2040, 0x7280),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x0fd9, 0x0008),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
         { },
 };
 
diff --git a/drivers/media/video/cx18/Kconfig b/drivers/media/video/cx18/Kconfig
index 5f942690570c..9aefdc5ea79a 100644
--- a/drivers/media/video/cx18/Kconfig
+++ b/drivers/media/video/cx18/Kconfig
@@ -10,8 +10,8 @@ config VIDEO_CX18
         select VIDEO_TVEEPROM
         select VIDEO_CX2341X
         select VIDEO_CS5345
-        select DVB_S5H1409
-        select MEDIA_TUNER_MXL5005S
+        select DVB_S5H1409 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_MXL5005S if !DVB_FE_CUSTOMISE
         ---help---
           This is a video4linux driver for Conexant cx23418 based
           PCI combo video recorder devices.
diff --git a/drivers/media/video/cx18/cx18-av-core.c b/drivers/media/video/cx18/cx18-av-core.c
index 9a26751615c6..faca43eb940f 100644
--- a/drivers/media/video/cx18/cx18-av-core.c
+++ b/drivers/media/video/cx18/cx18-av-core.c
@@ -69,6 +69,58 @@ int cx18_av_and_or4(struct cx18 *cx, u16 addr, u32 and_mask,
                              or_value);
 }
 
+int cx18_av_write_no_acfg(struct cx18 *cx, u16 addr, u8 value, int no_acfg_mask)
+{
+        int retval;
+        u32 saved_reg[8] = {0};
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_AFE) {
+                saved_reg[0] = cx18_av_read4(cx, CXADEC_CHIP_CTRL);
+                saved_reg[1] = cx18_av_read4(cx, CXADEC_AFE_CTRL);
+        }
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_PLL) {
+                saved_reg[2] = cx18_av_read4(cx, CXADEC_PLL_CTRL1);
+                saved_reg[3] = cx18_av_read4(cx, CXADEC_VID_PLL_FRAC);
+        }
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_VID) {
+                saved_reg[4] = cx18_av_read4(cx, CXADEC_HORIZ_TIM_CTRL);
+                saved_reg[5] = cx18_av_read4(cx, CXADEC_VERT_TIM_CTRL);
+                saved_reg[6] = cx18_av_read4(cx, CXADEC_SRC_COMB_CFG);
+                saved_reg[7] = cx18_av_read4(cx, CXADEC_CHROMA_VBIOFF_CFG);
+        }
+
+        retval = cx18_av_write(cx, addr, value);
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_AFE) {
+                cx18_av_write4(cx, CXADEC_CHIP_CTRL, saved_reg[0]);
+                cx18_av_write4(cx, CXADEC_AFE_CTRL,  saved_reg[1]);
+        }
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_PLL) {
+                cx18_av_write4(cx, CXADEC_PLL_CTRL1,    saved_reg[2]);
+                cx18_av_write4(cx, CXADEC_VID_PLL_FRAC, saved_reg[3]);
+        }
+
+        if (no_acfg_mask & CXADEC_NO_ACFG_VID) {
+                cx18_av_write4(cx, CXADEC_HORIZ_TIM_CTRL,    saved_reg[4]);
+                cx18_av_write4(cx, CXADEC_VERT_TIM_CTRL,     saved_reg[5]);
+                cx18_av_write4(cx, CXADEC_SRC_COMB_CFG,      saved_reg[6]);
+                cx18_av_write4(cx, CXADEC_CHROMA_VBIOFF_CFG, saved_reg[7]);
+        }
+
+        return retval;
+}
+
+int cx18_av_and_or_no_acfg(struct cx18 *cx, u16 addr, unsigned and_mask,
+                           u8 or_value, int no_acfg_mask)
+{
+        return cx18_av_write_no_acfg(cx, addr,
+                                     (cx18_av_read(cx, addr) & and_mask) |
+                                     or_value, no_acfg_mask);
+}
+
 /* ----------------------------------------------------------------------- */
 
 static int set_input(struct cx18 *cx, enum cx18_av_video_input vid_input,
@@ -170,13 +222,15 @@ static void input_change(struct cx18 *cx)
 
         /* Follow step 8c and 8d of section 3.16 in the cx18_av datasheet */
         if (std & V4L2_STD_SECAM)
-                cx18_av_write(cx, 0x402, 0);
+                cx18_av_write_no_acfg(cx, 0x402, 0, CXADEC_NO_ACFG_ALL);
         else {
-                cx18_av_write(cx, 0x402, 0x04);
+                cx18_av_write_no_acfg(cx, 0x402, 0x04, CXADEC_NO_ACFG_ALL);
                 cx18_av_write(cx, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
         }
-        cx18_av_and_or(cx, 0x401, ~0x60, 0);
-        cx18_av_and_or(cx, 0x401, ~0x60, 0x60);
+        cx18_av_and_or_no_acfg(cx, 0x401, ~0x60, 0,
+                                CXADEC_NO_ACFG_PLL | CXADEC_NO_ACFG_VID);
+        cx18_av_and_or_no_acfg(cx, 0x401, ~0x60, 0x60,
+                                CXADEC_NO_ACFG_PLL | CXADEC_NO_ACFG_VID);
 
         if (std & V4L2_STD_525_60) {
                 if (std == V4L2_STD_NTSC_M_JP) {
@@ -228,7 +282,7 @@ static int set_input(struct cx18 *cx, enum cx18_av_video_input vid_input,
 
                 if ((vid_input & ~0xff0) ||
                     luma < CX18_AV_SVIDEO_LUMA1 ||
-                    luma > CX18_AV_SVIDEO_LUMA4 ||
+                    luma > CX18_AV_SVIDEO_LUMA8 ||
                     chroma < CX18_AV_SVIDEO_CHROMA4 ||
                     chroma > CX18_AV_SVIDEO_CHROMA8) {
                         CX18_ERR("0x%04x is not a valid video input!\n",
@@ -262,7 +316,8 @@ static int set_input(struct cx18 *cx, enum cx18_av_video_input vid_input,
 
         cx18_av_write(cx, 0x103, reg);
         /* Set INPUT_MODE to Composite (0) or S-Video (1) */
-        cx18_av_and_or(cx, 0x401, ~0x6, is_composite ? 0 : 0x02);
+        cx18_av_and_or_no_acfg(cx, 0x401, ~0x6, is_composite ? 0 : 0x02,
+                                CXADEC_NO_ACFG_PLL | CXADEC_NO_ACFG_VID);
         /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
         cx18_av_and_or(cx, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
         /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2 and CH3 */
@@ -318,12 +373,12 @@ static int set_v4lstd(struct cx18 *cx)
            This happens for example with the Yuan MPC622. */
         if (fmt >= 4 && fmt < 8) {
                 /* Set format to NTSC-M */
-                cx18_av_and_or(cx, 0x400, ~0xf, 1);
+                cx18_av_and_or_no_acfg(cx, 0x400, ~0xf, 1, CXADEC_NO_ACFG_AFE);
                 /* Turn off LCOMB */
                 cx18_av_and_or(cx, 0x47b, ~6, 0);
         }
-        cx18_av_and_or(cx, 0x400, ~0xf, fmt);
-        cx18_av_and_or(cx, 0x403, ~0x3, pal_m);
+        cx18_av_and_or_no_acfg(cx, 0x400, ~0xf, fmt, CXADEC_NO_ACFG_AFE);
+        cx18_av_and_or_no_acfg(cx, 0x403, ~0x3, pal_m, CXADEC_NO_ACFG_ALL);
         cx18_av_vbi_setup(cx);
         input_change(cx);
         return 0;
diff --git a/drivers/media/video/cx18/cx18-av-core.h b/drivers/media/video/cx18/cx18-av-core.h
index 786901d72e9a..c172823ce1d8 100644
--- a/drivers/media/video/cx18/cx18-av-core.h
+++ b/drivers/media/video/cx18/cx18-av-core.h
@@ -37,12 +37,16 @@ enum cx18_av_video_input {
         CX18_AV_COMPOSITE7,
         CX18_AV_COMPOSITE8,
 
-        /* S-Video inputs consist of one luma input (In1-In4) ORed with one
+        /* S-Video inputs consist of one luma input (In1-In8) ORed with one
            chroma input (In5-In8) */
         CX18_AV_SVIDEO_LUMA1 = 0x10,
         CX18_AV_SVIDEO_LUMA2 = 0x20,
         CX18_AV_SVIDEO_LUMA3 = 0x30,
         CX18_AV_SVIDEO_LUMA4 = 0x40,
+        CX18_AV_SVIDEO_LUMA5 = 0x50,
+        CX18_AV_SVIDEO_LUMA6 = 0x60,
+        CX18_AV_SVIDEO_LUMA7 = 0x70,
+        CX18_AV_SVIDEO_LUMA8 = 0x80,
         CX18_AV_SVIDEO_CHROMA4 = 0x400,
         CX18_AV_SVIDEO_CHROMA5 = 0x500,
         CX18_AV_SVIDEO_CHROMA6 = 0x600,
@@ -291,14 +295,24 @@ struct cx18_av_state {
 #define CXADEC_SELECT_AUDIO_STANDARD_FM    0xF9  /* FM radio */
 #define CXADEC_SELECT_AUDIO_STANDARD_AUTO  0xFF  /* Auto detect */
 
+/* Flags on what to preserve on write to 0x400-0x403 with cx18_av_.*_no_acfg()*/
+#define CXADEC_NO_ACFG_AFE      0x01 /* Preserve 0x100-0x107 */
+#define CXADEC_NO_ACFG_PLL      0x02 /* Preserve 0x108-0x10f */
+#define CXADEC_NO_ACFG_VID      0x04 /* Preserve 0x470-0x47f */
+#define CXADEC_NO_ACFG_ALL      0x07
+
 /* ----------------------------------------------------------------------- */
 /* cx18_av-core.c                                                          */
 int cx18_av_write(struct cx18 *cx, u16 addr, u8 value);
 int cx18_av_write4(struct cx18 *cx, u16 addr, u32 value);
+int cx18_av_write_no_acfg(struct cx18 *cx, u16 addr, u8 value,
+                                int no_acfg_mask);
 u8 cx18_av_read(struct cx18 *cx, u16 addr);
 u32 cx18_av_read4(struct cx18 *cx, u16 addr);
 int cx18_av_and_or(struct cx18 *cx, u16 addr, unsigned mask, u8 value);
 int cx18_av_and_or4(struct cx18 *cx, u16 addr, u32 mask, u32 value);
+int cx18_av_and_or_no_acfg(struct cx18 *cx, u16 addr, unsigned mask, u8 value,
+                                int no_acfg_mask);
 int cx18_av_cmd(struct cx18 *cx, unsigned int cmd, void *arg);
 
 /* ----------------------------------------------------------------------- */
diff --git a/drivers/media/video/cx18/cx18-cards.c b/drivers/media/video/cx18/cx18-cards.c
index baccd079243d..c26e0ef5b075 100644
--- a/drivers/media/video/cx18/cx18-cards.c
+++ b/drivers/media/video/cx18/cx18-cards.c
@@ -23,6 +23,7 @@
 
 #include "cx18-driver.h"
 #include "cx18-cards.h"
+#include "cx18-av-core.h"
 #include "cx18-i2c.h"
 #include <media/cs5345.h>
 
@@ -54,22 +55,22 @@ static const struct cx18_card cx18_card_hvr1600_esmt = {
         .hw_all = CX18_HW_TVEEPROM | CX18_HW_TUNER |
                   CX18_HW_CS5345 | CX18_HW_DVB,
         .video_inputs = {
-                { CX18_CARD_INPUT_VID_TUNER,  0, CX23418_COMPOSITE7 },
-                { CX18_CARD_INPUT_SVIDEO1,    1, CX23418_SVIDEO1    },
-                { CX18_CARD_INPUT_COMPOSITE1, 1, CX23418_COMPOSITE3 },
-                { CX18_CARD_INPUT_SVIDEO2,    2, CX23418_SVIDEO2    },
-                { CX18_CARD_INPUT_COMPOSITE2, 2, CX23418_COMPOSITE4 },
+                { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE7 },
+                { CX18_CARD_INPUT_SVIDEO1,    1, CX18_AV_SVIDEO1    },
+                { CX18_CARD_INPUT_COMPOSITE1, 1, CX18_AV_COMPOSITE3 },
+                { CX18_CARD_INPUT_SVIDEO2,    2, CX18_AV_SVIDEO2    },
+                { CX18_CARD_INPUT_COMPOSITE2, 2, CX18_AV_COMPOSITE4 },
         },
         .audio_inputs = {
                 { CX18_CARD_INPUT_AUD_TUNER,
-                  CX23418_AUDIO8, CS5345_IN_1 | CS5345_MCLK_1_5 },
+                  CX18_AV_AUDIO8, CS5345_IN_1 | CS5345_MCLK_1_5 },
                 { CX18_CARD_INPUT_LINE_IN1,
-                  CX23418_AUDIO_SERIAL, CS5345_IN_2 },
+                  CX18_AV_AUDIO_SERIAL, CS5345_IN_2 },
                 { CX18_CARD_INPUT_LINE_IN2,
-                  CX23418_AUDIO_SERIAL, CS5345_IN_2 },
+                  CX18_AV_AUDIO_SERIAL, CS5345_IN_3 },
         },
         .radio_input = { CX18_CARD_INPUT_AUD_TUNER,
-                         CX23418_AUDIO_SERIAL, 0 },
+                         CX18_AV_AUDIO_SERIAL, CS5345_IN_4 },
         .ddr = {
                 /* ESMT M13S128324A-5B memory */
                 .chip_config = 0x003,
@@ -81,6 +82,11 @@ static const struct cx18_card cx18_card_hvr1600_esmt = {
         },
         .gpio_init.initial_value = 0x3001,
         .gpio_init.direction = 0x3001,
+        .gpio_i2c_slave_reset = {
+                .active_lo_mask = 0x3001,
+                .msecs_asserted = 10,
+                .msecs_recovery = 40,
+        },
         .i2c = &cx18_i2c_std,
 };
 
@@ -94,22 +100,22 @@ static const struct cx18_card cx18_card_hvr1600_samsung = {
         .hw_all = CX18_HW_TVEEPROM | CX18_HW_TUNER |
                   CX18_HW_CS5345 | CX18_HW_DVB,
         .video_inputs = {
-                { CX18_CARD_INPUT_VID_TUNER,  0, CX23418_COMPOSITE7 },
-                { CX18_CARD_INPUT_SVIDEO1,    1, CX23418_SVIDEO1    },
-                { CX18_CARD_INPUT_COMPOSITE1, 1, CX23418_COMPOSITE3 },
-                { CX18_CARD_INPUT_SVIDEO2,    2, CX23418_SVIDEO2    },
-                { CX18_CARD_INPUT_COMPOSITE2, 2, CX23418_COMPOSITE4 },
+                { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE7 },
+                { CX18_CARD_INPUT_SVIDEO1,    1, CX18_AV_SVIDEO1    },
+                { CX18_CARD_INPUT_COMPOSITE1, 1, CX18_AV_COMPOSITE3 },
+                { CX18_CARD_INPUT_SVIDEO2,    2, CX18_AV_SVIDEO2    },
+                { CX18_CARD_INPUT_COMPOSITE2, 2, CX18_AV_COMPOSITE4 },
         },
         .audio_inputs = {
                 { CX18_CARD_INPUT_AUD_TUNER,
-                  CX23418_AUDIO8, CS5345_IN_1 | CS5345_MCLK_1_5 },
+                  CX18_AV_AUDIO8, CS5345_IN_1 | CS5345_MCLK_1_5 },
                 { CX18_CARD_INPUT_LINE_IN1,
-                  CX23418_AUDIO_SERIAL, CS5345_IN_2 },
+                  CX18_AV_AUDIO_SERIAL, CS5345_IN_2 },
                 { CX18_CARD_INPUT_LINE_IN2,
-                  CX23418_AUDIO_SERIAL, CS5345_IN_2 },
+                  CX18_AV_AUDIO_SERIAL, CS5345_IN_3 },
         },
         .radio_input = { CX18_CARD_INPUT_AUD_TUNER,
-                         CX23418_AUDIO_SERIAL, 0 },
+                         CX18_AV_AUDIO_SERIAL, CS5345_IN_4 },
         .ddr = {
                 /* Samsung K4D263238G-VC33 memory */
                 .chip_config = 0x003,
@@ -121,6 +127,11 @@ static const struct cx18_card cx18_card_hvr1600_samsung = {
         },
         .gpio_init.initial_value = 0x3001,
         .gpio_init.direction = 0x3001,
+        .gpio_i2c_slave_reset = {
+                .active_lo_mask = 0x3001,
+                .msecs_asserted = 10,
+                .msecs_recovery = 40,
+        },
         .i2c = &cx18_i2c_std,
 };
 
@@ -141,19 +152,19 @@ static const struct cx18_card cx18_card_h900 = {
         .hw_audio_ctrl = CX18_HW_CX23418,
         .hw_all = CX18_HW_TUNER,
         .video_inputs = {
-                { CX18_CARD_INPUT_VID_TUNER,  0, CX23418_COMPOSITE2 },
+                { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE2 },
                 { CX18_CARD_INPUT_SVIDEO1,    1,
-                        CX23418_SVIDEO_LUMA3 | CX23418_SVIDEO_CHROMA4 },
-                { CX18_CARD_INPUT_COMPOSITE1, 1, CX23418_COMPOSITE1 },
+                        CX18_AV_SVIDEO_LUMA3 | CX18_AV_SVIDEO_CHROMA4 },
+                { CX18_CARD_INPUT_COMPOSITE1, 1, CX18_AV_COMPOSITE1 },
         },
         .audio_inputs = {
                 { CX18_CARD_INPUT_AUD_TUNER,
-                  CX23418_AUDIO8, 0 },
+                  CX18_AV_AUDIO8, 0 },
                 { CX18_CARD_INPUT_LINE_IN1,
-                  CX23418_AUDIO_SERIAL, 0 },
+                  CX18_AV_AUDIO_SERIAL, 0 },
         },
         .radio_input = { CX18_CARD_INPUT_AUD_TUNER,
-                         CX23418_AUDIO_SERIAL, 0 },
+                         CX18_AV_AUDIO_SERIAL, 0 },
         .tuners = {
                 { .std = V4L2_STD_ALL, .tuner = TUNER_XC2028 },
         },
@@ -183,23 +194,26 @@ static const struct cx18_card_pci_info cx18_pci_mpc718[] = {
 static const struct cx18_card cx18_card_mpc718 = {
         .type = CX18_CARD_YUAN_MPC718,
         .name = "Yuan MPC718",
-        .comment = "Not yet supported!\n",
-        .v4l2_capabilities = 0,
+        .comment = "Some Composite and S-Video inputs are currently working.\n",
+        .v4l2_capabilities = CX18_CAP_ENCODER,
         .hw_audio_ctrl = CX18_HW_CX23418,
         .hw_all = CX18_HW_TUNER,
         .video_inputs = {
-                { CX18_CARD_INPUT_VID_TUNER,  0, CX23418_COMPOSITE7 },
-                { CX18_CARD_INPUT_SVIDEO1,    1, CX23418_SVIDEO1    },
-                { CX18_CARD_INPUT_COMPOSITE1, 1, CX23418_COMPOSITE3 },
+                { CX18_CARD_INPUT_VID_TUNER,  0, CX18_AV_COMPOSITE2 },
+                { CX18_CARD_INPUT_SVIDEO1,    1,
+                                CX18_AV_SVIDEO_LUMA3 | CX18_AV_SVIDEO_CHROMA4 },
+                { CX18_CARD_INPUT_COMPOSITE1, 1, CX18_AV_COMPOSITE1 },
+                { CX18_CARD_INPUT_SVIDEO2,    2,
+                                CX18_AV_SVIDEO_LUMA7 | CX18_AV_SVIDEO_CHROMA8 },
+                { CX18_CARD_INPUT_COMPOSITE2, 2, CX18_AV_COMPOSITE6 },
+                { CX18_CARD_INPUT_COMPOSITE3, 2, CX18_AV_COMPOSITE3 },
         },
         .audio_inputs = {
-                { CX18_CARD_INPUT_AUD_TUNER,
-                  CX23418_AUDIO8, 0 },
-                { CX18_CARD_INPUT_LINE_IN1,
-                  CX23418_AUDIO_SERIAL, 0 },
+                { CX18_CARD_INPUT_AUD_TUNER, CX18_AV_AUDIO5,       0 },
+                { CX18_CARD_INPUT_LINE_IN1,  CX18_AV_AUDIO_SERIAL, 0 },
+                { CX18_CARD_INPUT_LINE_IN2,  CX18_AV_AUDIO_SERIAL, 0 },
         },
-        .radio_input = { CX18_CARD_INPUT_AUD_TUNER,
-                         CX23418_AUDIO_SERIAL, 0 },
+        .radio_input = { CX18_CARD_INPUT_AUD_TUNER, CX18_AV_AUDIO_SERIAL, 0 },
         .tuners = {
                 /* XC3028 tuner */
                 { .std = V4L2_STD_ALL, .tuner = TUNER_XC2028 },
diff --git a/drivers/media/video/cx18/cx18-cards.h b/drivers/media/video/cx18/cx18-cards.h
index bccb67f0db16..dc2dd945d4c3 100644
--- a/drivers/media/video/cx18/cx18-cards.h
+++ b/drivers/media/video/cx18/cx18-cards.h
@@ -36,36 +36,6 @@
 #define CX18_CARD_INPUT_COMPOSITE2      5
 #define CX18_CARD_INPUT_COMPOSITE3      6
 
-enum cx34180_video_input {
-        /* Composite video inputs In1-In8 */
-        CX23418_COMPOSITE1 = 1,
-        CX23418_COMPOSITE2,
-        CX23418_COMPOSITE3,
-        CX23418_COMPOSITE4,
-        CX23418_COMPOSITE5,
-        CX23418_COMPOSITE6,
-        CX23418_COMPOSITE7,
-        CX23418_COMPOSITE8,
-
-        /* S-Video inputs consist of one luma input (In1-In4) ORed with one
-           chroma input (In5-In8) */
-        CX23418_SVIDEO_LUMA1 = 0x10,
-        CX23418_SVIDEO_LUMA2 = 0x20,
-        CX23418_SVIDEO_LUMA3 = 0x30,
-        CX23418_SVIDEO_LUMA4 = 0x40,
-        CX23418_SVIDEO_CHROMA4 = 0x400,
-        CX23418_SVIDEO_CHROMA5 = 0x500,
-        CX23418_SVIDEO_CHROMA6 = 0x600,
-        CX23418_SVIDEO_CHROMA7 = 0x700,
-        CX23418_SVIDEO_CHROMA8 = 0x800,
-
-        /* S-Video aliases for common luma/chroma combinations */
-        CX23418_SVIDEO1 = 0x510,
-        CX23418_SVIDEO2 = 0x620,
-        CX23418_SVIDEO3 = 0x730,
-        CX23418_SVIDEO4 = 0x840,
-};
-
 /* audio inputs */
 #define CX18_CARD_INPUT_AUD_TUNER       1
 #define CX18_CARD_INPUT_LINE_IN1        2
@@ -75,16 +45,6 @@ enum cx34180_video_input {
 #define CX18_CARD_MAX_AUDIO_INPUTS 3
 #define CX18_CARD_MAX_TUNERS       2
 
-enum cx23418_audio_input {
-        /* Audio inputs: serial or In4-In8 */
-        CX23418_AUDIO_SERIAL,
-        CX23418_AUDIO4 = 4,
-        CX23418_AUDIO5,
-        CX23418_AUDIO6,
-        CX23418_AUDIO7,
-        CX23418_AUDIO8,
-};
-
 /* V4L2 capability aliases */
 #define CX18_CAP_ENCODER (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER | \
                           V4L2_CAP_AUDIO | V4L2_CAP_READWRITE)
@@ -118,6 +78,13 @@ struct cx18_gpio_init { /* set initial GPIO DIR and OUT values */
         u32 initial_value;
 };
 
+struct cx18_gpio_i2c_slave_reset {
+        u32 active_lo_mask; /* GPIO outputs that reset i2c chips when low */
+        u32 active_hi_mask; /* GPIO outputs that reset i2c chips when high */
+        int msecs_asserted; /* time period reset must remain asserted */
+        int msecs_recovery; /* time after deassert for chips to be ready */
+};
+
 struct cx18_card_tuner {
         v4l2_std_id std;        /* standard for which the tuner is suitable */
         int         tuner;      /* tuner ID (from tuner.h) */
@@ -154,7 +121,8 @@ struct cx18_card {
 
         /* GPIO card-specific settings */
         u8 xceive_pin;          /* XCeive tuner GPIO reset pin */
-        struct cx18_gpio_init           gpio_init;
+        struct cx18_gpio_init            gpio_init;
+        struct cx18_gpio_i2c_slave_reset gpio_i2c_slave_reset;
 
         struct cx18_card_tuner tuners[CX18_CARD_MAX_TUNERS];
         struct cx18_card_tuner_i2c *i2c;
diff --git a/drivers/media/video/cx18/cx18-dvb.c b/drivers/media/video/cx18/cx18-dvb.c
index c9744173f969..cae38985b131 100644
--- a/drivers/media/video/cx18/cx18-dvb.c
+++ b/drivers/media/video/cx18/cx18-dvb.c
@@ -69,11 +69,21 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
         struct dvb_demux *demux = feed->demux;
         struct cx18_stream *stream = (struct cx18_stream *) demux->priv;
         struct cx18 *cx = stream->cx;
-        int ret = -EINVAL;
+        int ret;
         u32 v;
 
         CX18_DEBUG_INFO("Start feed: pid = 0x%x index = %d\n",
                         feed->pid, feed->index);
+
+        mutex_lock(&cx->serialize_lock);
+        ret = cx18_init_on_first_open(cx);
+        mutex_unlock(&cx->serialize_lock);
+        if (ret) {
+                CX18_ERR("Failed to initialize firmware starting DVB feed\n");
+                return ret;
+        }
+        ret = -EINVAL;
+
         switch (cx->card->type) {
         case CX18_CARD_HVR_1600_ESMT:
         case CX18_CARD_HVR_1600_SAMSUNG:
@@ -101,6 +111,11 @@ static int cx18_dvb_start_feed(struct dvb_demux_feed *feed)
                 if (stream->dvb.feeding++ == 0) {
                         CX18_DEBUG_INFO("Starting Transport DMA\n");
                         ret = cx18_start_v4l2_encode_stream(stream);
+                        if (ret < 0) {
+                                CX18_DEBUG_INFO(
+                                        "Failed to start Transport DMA\n");
+                                stream->dvb.feeding--;
+                        }
                 } else
                         ret = 0;
                 mutex_unlock(&stream->dvb.feedlock);
diff --git a/drivers/media/video/cx18/cx18-gpio.c b/drivers/media/video/cx18/cx18-gpio.c
index ceb63653c926..b302833f6f9d 100644
--- a/drivers/media/video/cx18/cx18-gpio.c
+++ b/drivers/media/video/cx18/cx18-gpio.c
@@ -53,10 +53,34 @@ static void gpio_write(struct cx18 *cx)
         write_reg(((dir & 0xffff) << 16) | (val & 0xffff),
                         CX18_REG_GPIO_OUT1);
         write_reg(dir & 0xffff0000, CX18_REG_GPIO_DIR2);
-        write_reg((dir & 0xffff0000) | ((val & 0xffff0000) >> 16),
+        write_reg_sync((dir & 0xffff0000) | ((val & 0xffff0000) >> 16),
                         CX18_REG_GPIO_OUT2);
 }
 
+void cx18_reset_i2c_slaves_gpio(struct cx18 *cx)
+{
+        const struct cx18_gpio_i2c_slave_reset *p;
+
+        p = &cx->card->gpio_i2c_slave_reset;
+
+        if ((p->active_lo_mask | p->active_hi_mask) == 0)
+                return;
+
+        /* Assuming that the masks are a subset of the bits in gpio_dir */
+
+        /* Assert */
+        cx->gpio_val =
+                (cx->gpio_val | p->active_hi_mask) & ~(p->active_lo_mask);
+        gpio_write(cx);
+        schedule_timeout_uninterruptible(msecs_to_jiffies(p->msecs_asserted));
+
+        /* Deassert */
+        cx->gpio_val =
+                (cx->gpio_val | p->active_lo_mask) & ~(p->active_hi_mask);
+        gpio_write(cx);
+        schedule_timeout_uninterruptible(msecs_to_jiffies(p->msecs_recovery));
+}
+
 void cx18_gpio_init(struct cx18 *cx)
 {
         cx->gpio_dir = cx->card->gpio_init.direction;
diff --git a/drivers/media/video/cx18/cx18-gpio.h b/drivers/media/video/cx18/cx18-gpio.h
index 41bac8856b50..525c328f748a 100644
--- a/drivers/media/video/cx18/cx18-gpio.h
+++ b/drivers/media/video/cx18/cx18-gpio.h
@@ -21,4 +21,5 @@
  */
 
 void cx18_gpio_init(struct cx18 *cx);
+void cx18_reset_i2c_slaves_gpio(struct cx18 *cx);
 int cx18_reset_tuner_gpio(void *dev, int cmd, int value);
diff --git a/drivers/media/video/cx18/cx18-i2c.c b/drivers/media/video/cx18/cx18-i2c.c
index 1d6c51a75313..680bc4e35b79 100644
--- a/drivers/media/video/cx18/cx18-i2c.c
+++ b/drivers/media/video/cx18/cx18-i2c.c
@@ -405,6 +405,8 @@ int init_cx18_i2c(struct cx18 *cx)
         cx18_setscl(&cx->i2c_algo_cb_data[1], 1);
         cx18_setsda(&cx->i2c_algo_cb_data[1], 1);
 
+        cx18_reset_i2c_slaves_gpio(cx);
+
         return i2c_bit_add_bus(&cx->i2c_adap[0]) ||
                 i2c_bit_add_bus(&cx->i2c_adap[1]);
 }
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index 607efdcd22f8..1da6f134888d 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -433,7 +433,7 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                 int chroma = vid_input & 0xf00;
 
                 if ((vid_input & ~0xff0) ||
-                    luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA4 ||
+                    luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
                     chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
                         v4l_err(client, "0x%04x is not a valid video input!\n",
                                 vid_input);
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index e976fc6bef7c..80c8883e54b5 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -332,6 +332,12 @@ static int snd_cx88_pcm_open(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
 
+        if (!chip) {
+                printk(KERN_ERR "BUG: cx88 can't find device struct."
+                                " Can't proceed with open\n");
+                return -ENODEV;
+        }
+
         err = snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS);
         if (err < 0)
                 goto _error;
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
index 92b2a6db4fdc..3c006103c1eb 100644
--- a/drivers/media/video/em28xx/em28xx-audio.c
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -268,6 +268,12 @@ static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
 
         dprintk("opening device and trying to acquire exclusive lock\n");
 
+        if (!dev) {
+                printk(KERN_ERR "BUG: em28xx can't find device struct."
+                                " Can't proceed with open\n");
+                return -ENODEV;
+        }
+
         /* Sets volume, mute, etc */
 
         dev->mute = 0;
@@ -415,6 +421,12 @@ static int em28xx_audio_init(struct em28xx *dev)
         static int          devnr;
         int                 ret, err;
 
+        if (dev->has_audio_class) {
+                /* This device does not support the extension (in this case
+                   the device is expecting the snd-usb-audio module */
+                return 0;
+        }
+
         printk(KERN_INFO "em28xx-audio.c: probing for em28x1 "
                          "non standard usbaudio\n");
         printk(KERN_INFO "em28xx-audio.c: Copyright (C) 2006 Markus "
@@ -458,6 +470,12 @@ static int em28xx_audio_fini(struct em28xx *dev)
         if (dev == NULL)
                 return 0;
 
+        if (dev->has_audio_class) {
+                /* This device does not support the extension (in this case
+                   the device is expecting the snd-usb-audio module */
+                return 0;
+        }
+
         if (dev->adev) {
                 snd_card_free(dev->adev->sndcard);
                 kfree(dev->adev);
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 3e4f3c7e92e7..8cbda43727c3 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -157,6 +157,7 @@ struct em28xx_board em28xx_boards[] = {
                 .tda9887_conf = TDA9887_PRESENT,
                 .tuner_type   = TUNER_XC2028,
                 .mts_firmware = 1,
+                .has_dvb        = 1,
                 .decoder      = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
@@ -524,6 +525,9 @@ void em28xx_pre_card_setup(struct em28xx *dev)
         rc = em28xx_read_reg(dev, EM28XX_R0A_CHIPID);
         if (rc > 0) {
                 switch (rc) {
+                case CHIP_ID_EM2860:
+                        em28xx_info("chip ID is em2860\n");
+                        break;
                 case CHIP_ID_EM2883:
                         em28xx_info("chip ID is em2882/em2883\n");
                         dev->wait_after_write = 0;
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index 8cf4983f0039..0b2333ee07f8 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -382,6 +382,11 @@ static int dvb_init(struct em28xx *dev)
         int result = 0;
         struct em28xx_dvb *dvb;
 
+        if (!dev->has_dvb) {
+                /* This device does not support the extension */
+                return 0;
+        }
+
         dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
 
         if (dvb == NULL) {
@@ -444,6 +449,11 @@ out_free:
 
 static int dvb_fini(struct em28xx *dev)
 {
+        if (!dev->has_dvb) {
+                /* This device does not support the extension */
+                return 0;
+        }
+
         if (dev->dvb) {
                 unregister_dvb(dev->dvb);
                 dev->dvb = NULL;
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
index 9058bed07953..fac1ab23f621 100644
--- a/drivers/media/video/em28xx/em28xx-reg.h
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -84,5 +84,6 @@
 
 /* FIXME: Need to be populated with the other chip ID's */
 enum em28xx_chip_id {
+        CHIP_ID_EM2860 = 34,
         CHIP_ID_EM2883 = 36,
 };
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index fb163ecd9216..285bc62bbe46 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -1848,32 +1848,28 @@ static DEFINE_MUTEX(em28xx_extension_devlist_lock);
 
 int em28xx_register_extension(struct em28xx_ops *ops)
 {
-        struct em28xx *h, *dev = NULL;
-
-        list_for_each_entry(h, &em28xx_devlist, devlist)
-                dev = h;
+        struct em28xx *dev = NULL;
 
         mutex_lock(&em28xx_extension_devlist_lock);
         list_add_tail(&ops->next, &em28xx_extension_devlist);
-        if (dev)
-                ops->init(dev);
-
+        list_for_each_entry(dev, &em28xx_devlist, devlist) {
+                if (dev)
+                        ops->init(dev);
+        }
         printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
         mutex_unlock(&em28xx_extension_devlist_lock);
-
         return 0;
 }
 EXPORT_SYMBOL(em28xx_register_extension);
 
 void em28xx_unregister_extension(struct em28xx_ops *ops)
 {
-        struct em28xx *h, *dev = NULL;
-
-        list_for_each_entry(h, &em28xx_devlist, devlist)
-                dev = h;
+        struct em28xx *dev = NULL;
 
-        if (dev)
-                ops->fini(dev);
+        list_for_each_entry(dev, &em28xx_devlist, devlist) {
+                if (dev)
+                        ops->fini(dev);
+        }
 
         mutex_lock(&em28xx_extension_devlist_lock);
         printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index 7cc8e9b19fb7..5ec5bb9a94d2 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -1019,12 +1019,12 @@ static int pxa_camera_probe(struct platform_device *pdev)
         struct pxa_camera_dev *pcdev;
         struct resource *res;
         void __iomem *base;
-        unsigned int irq;
+        int irq;
         int err = 0;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!res || !irq) {
+        if (!res || irq < 0) {
                 err = -ENODEV;
                 goto exit;
         }
diff --git a/drivers/media/video/saa7134/saa7134-alsa.c b/drivers/media/video/saa7134/saa7134-alsa.c
index ba3082422a01..f118de6e3672 100644
--- a/drivers/media/video/saa7134/saa7134-alsa.c
+++ b/drivers/media/video/saa7134/saa7134-alsa.c
@@ -613,9 +613,15 @@ static int snd_card_saa7134_capture_open(struct snd_pcm_substream * substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_card_saa7134_pcm_t *pcm;
         snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
-        struct saa7134_dev *dev = saa7134->dev;
+        struct saa7134_dev *dev;
         int amux, err;
 
+        if (!saa7134) {
+                printk(KERN_ERR "BUG: saa7134 can't find device struct."
+                                " Can't proceed with open\n");
+                return -ENODEV;
+        }
+        dev = saa7134->dev;
         mutex_lock(&dev->dmasound.lock);
 
         dev->dmasound.read_count  = 0;
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index b111903aa322..2618cfa592e7 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -4114,11 +4114,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
-                 /*
-                    TODO:
                  .mpeg           = SAA7134_MPEG_DVB,
-                 */
-
                  .inputs         = {{
                          .name = name_tv,
                          .vmux = 1,
@@ -4157,7 +4153,7 @@ struct saa7134_board saa7134_boards[] = {
                 } },
                 .radio = {
                         .name = name_radio,
-                        .amux = LINE1,
+                        .amux = TV,
                 },
         },
         [SAA7134_BOARD_AVERMEDIA_M115] = {
@@ -4167,6 +4163,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
+                .mpeg           = SAA7134_MPEG_DVB,
                 .inputs         = {{
                         .name = name_tv,
                         .vmux = 1,
@@ -5351,22 +5348,21 @@ static int saa7134_xc2028_callback(struct saa7134_dev *dev,
 {
         switch (command) {
         case XC2028_TUNER_RESET:
-                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x06e20000, 0x06e20000);
-                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x06a20000, 0x06a20000);
-                mdelay(250);
-                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x06e20000, 0);
-                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x06a20000, 0);
-                mdelay(250);
-                saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0x06e20000, 0x06e20000);
-                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x06a20000, 0x06a20000);
-                mdelay(250);
-                saa_andorl(SAA7133_ANALOG_IO_SELECT >> 2, 0x02, 0x02);
-                saa_andorl(SAA7134_ANALOG_IN_CTRL1 >> 2, 0x81, 0x81);
-                saa_andorl(SAA7134_AUDIO_CLOCK0 >> 2, 0x03187de7, 0x03187de7);
-                saa_andorl(SAA7134_AUDIO_PLL_CTRL >> 2, 0x03, 0x03);
-                saa_andorl(SAA7134_AUDIO_CLOCKS_PER_FIELD0 >> 2,
-                           0x0001e000, 0x0001e000);
-                return 0;
+                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00008000, 0x00000000);
+                saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00008000, 0x00008000);
+                switch (dev->board) {
+                case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
+                        saa7134_set_gpio(dev, 23, 0);
+                        msleep(10);
+                        saa7134_set_gpio(dev, 23, 1);
+                break;
+                case SAA7134_BOARD_AVERMEDIA_A16D:
+                        saa7134_set_gpio(dev, 21, 0);
+                        msleep(10);
+                        saa7134_set_gpio(dev, 21, 1);
+                break;
+                }
+        return 0;
         }
         return -EINVAL;
 }
@@ -5553,9 +5549,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x08000000, 0x00000000);
                 break;
         case SAA7134_BOARD_AVERMEDIA_CARDBUS:
-        case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
         case SAA7134_BOARD_AVERMEDIA_M115:
-        case SAA7134_BOARD_AVERMEDIA_A16D:
                 /* power-down tuner chip */
                 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0xffffffff, 0);
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0xffffffff, 0);
@@ -5565,6 +5559,18 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0xffffffff, 0xffffffff);
                 msleep(10);
                 break;
+        case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
+                saa7134_set_gpio(dev, 23, 0);
+                msleep(10);
+                saa7134_set_gpio(dev, 23, 1);
+                break;
+        case SAA7134_BOARD_AVERMEDIA_A16D:
+                saa7134_set_gpio(dev, 21, 0);
+                msleep(10);
+                saa7134_set_gpio(dev, 21, 1);
+                msleep(1);
+                dev->has_remote = SAA7134_REMOTE_GPIO;
+                break;
         case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
                 /* power-down tuner chip */
                 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x000A8004, 0x000A8004);
@@ -5615,7 +5621,8 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x80040100, 0x80040100);
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x80040100, 0x00040100);
                 printk("%s: %s: hybrid analog/dvb card\n"
-                       "%s: Sorry, only the analog inputs are supported for now.\n",
+                       "%s: Sorry, only analog s-video and composite input "
+                       "are supported for now.\n",
                         dev->name, card(dev).name, dev->name);
                 break;
         }
@@ -5675,6 +5682,7 @@ static void saa7134_tuner_setup(struct saa7134_dev *dev)
 
                 switch (dev->board) {
                 case SAA7134_BOARD_AVERMEDIA_A16D:
+                case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
                         ctl.demod = XC3028_FE_ZARLINK456;
                         break;
                 default:
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 469f93aac008..341b101b0357 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -153,12 +153,12 @@ static int mt352_aver777_init(struct dvb_frontend* fe)
         return 0;
 }
 
-static int mt352_aver_a16d_init(struct dvb_frontend *fe)
+static int mt352_avermedia_xc3028_init(struct dvb_frontend *fe)
 {
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x2d };
-        static u8 reset []         = { RESET,      0x80 };
-        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
-        static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0xa0 };
+        static u8 clock_config []  = { CLOCK_CTL, 0x38, 0x2d };
+        static u8 reset []         = { RESET, 0x80 };
+        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
+        static u8 agc_cfg []       = { AGC_TARGET, 0xe };
         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x33 };
 
         mt352_write(fe, clock_config,   sizeof(clock_config));
@@ -167,12 +167,9 @@ static int mt352_aver_a16d_init(struct dvb_frontend *fe)
         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
-
         return 0;
 }
 
-
-
 static int mt352_pinnacle_tuner_set_params(struct dvb_frontend* fe,
                                            struct dvb_frontend_parameters* params)
 {
@@ -215,14 +212,10 @@ static struct mt352_config avermedia_777 = {
         .demod_init    = mt352_aver777_init,
 };
 
-static struct mt352_config avermedia_16d = {
-        .demod_address = 0xf,
-        .demod_init    = mt352_aver_a16d_init,
-};
-
-static struct mt352_config avermedia_e506r_mt352_dev = {
+static struct mt352_config avermedia_xc3028_mt352_dev = {
         .demod_address   = (0x1e >> 1),
         .no_tuner        = 1,
+        .demod_init      = mt352_avermedia_xc3028_init,
 };
 
 /* ==================================================================
@@ -975,9 +968,10 @@ static int dvb_init(struct saa7134_dev *dev)
                 }
                 break;
         case SAA7134_BOARD_AVERMEDIA_A16D:
-                dprintk("avertv A16D dvb setup\n");
-                dev->dvb.frontend = dvb_attach(mt352_attach, &avermedia_16d,
-                                               &dev->i2c_adap);
+                dprintk("AverMedia A16D dvb setup\n");
+                dev->dvb.frontend = dvb_attach(mt352_attach,
+                                                &avermedia_xc3028_mt352_dev,
+                                                &dev->i2c_adap);
                 attach_xc3028 = 1;
                 break;
         case SAA7134_BOARD_MD7134:
@@ -1091,7 +1085,8 @@ static int dvb_init(struct saa7134_dev *dev)
                                         ads_tech_duo_config.tuner_address);
                                 goto dettach_frontend;
                         }
-                }
+                } else
+                        wprintk("failed to attach tda10046\n");
                 break;
         case SAA7134_BOARD_TEVION_DVBT_220RF:
                 if (configure_tda827x_fe(dev, &tevion_dvbt220rf_config,
@@ -1260,11 +1255,14 @@ static int dvb_init(struct saa7134_dev *dev)
                         goto dettach_frontend;
                 break;
         case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
+                dprintk("AverMedia E506R dvb setup\n");
+                saa7134_set_gpio(dev, 25, 0);
+                msleep(10);
+                saa7134_set_gpio(dev, 25, 1);
                 dev->dvb.frontend = dvb_attach(mt352_attach,
-                                               &avermedia_e506r_mt352_dev,
-                                               &dev->i2c_adap);
+                                                &avermedia_xc3028_mt352_dev,
+                                                &dev->i2c_adap);
                 attach_xc3028 = 1;
-                break;
         case SAA7134_BOARD_MD7134_BRIDGE_2:
                 dev->dvb.frontend = dvb_attach(tda10086_attach,
                                                 &sd1878_4m, &dev->i2c_adap);
@@ -1338,7 +1336,8 @@ static int dvb_init(struct saa7134_dev *dev)
         return ret;
 
 dettach_frontend:
-        dvb_frontend_detach(dev->dvb.frontend);
+        if (dev->dvb.frontend)
+                dvb_frontend_detach(dev->dvb.frontend);
         dev->dvb.frontend = NULL;
 
         return -1;
diff --git a/drivers/media/video/saa7134/saa7134-empress.c b/drivers/media/video/saa7134/saa7134-empress.c
index 81431ee41842..3ae71a340822 100644
--- a/drivers/media/video/saa7134/saa7134-empress.c
+++ b/drivers/media/video/saa7134/saa7134-empress.c
@@ -110,9 +110,10 @@ static int ts_release(struct inode *inode, struct file *file)
 {
         struct saa7134_dev *dev = file->private_data;
 
+        mutex_lock(&dev->empress_tsq.vb_lock);
+
         videobuf_stop(&dev->empress_tsq);
         videobuf_mmap_free(&dev->empress_tsq);
-        dev->empress_users--;
 
         /* stop the encoder */
         ts_reset_encoder(dev);
@@ -121,6 +122,10 @@ static int ts_release(struct inode *inode, struct file *file)
         saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
                 saa_readb(SAA7134_AUDIO_MUTE_CTRL) | (1 << 6));
 
+        dev->empress_users--;
+
+        mutex_unlock(&dev->empress_tsq.vb_lock);
+
         return 0;
 }
 
@@ -218,8 +223,7 @@ static int empress_enum_fmt_cap(struct file *file, void  *priv,
 static int empress_g_fmt_cap(struct file *file, void *priv,
                                 struct v4l2_format *f)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         saa7134_i2c_call_clients(dev, VIDIOC_G_FMT, f);
 
@@ -232,8 +236,7 @@ static int empress_g_fmt_cap(struct file *file, void *priv,
 static int empress_s_fmt_cap(struct file *file, void *priv,
                                 struct v4l2_format *f)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         saa7134_i2c_call_clients(dev, VIDIOC_S_FMT, f);
 
@@ -247,8 +250,7 @@ static int empress_s_fmt_cap(struct file *file, void *priv,
 static int empress_reqbufs(struct file *file, void *priv,
                                         struct v4l2_requestbuffers *p)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_reqbufs(&dev->empress_tsq, p);
 }
@@ -256,24 +258,21 @@ static int empress_reqbufs(struct file *file, void *priv,
 static int empress_querybuf(struct file *file, void *priv,
                                         struct v4l2_buffer *b)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_querybuf(&dev->empress_tsq, b);
 }
 
 static int empress_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_qbuf(&dev->empress_tsq, b);
 }
 
 static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_dqbuf(&dev->empress_tsq, b,
                                 file->f_flags & O_NONBLOCK);
@@ -282,8 +281,7 @@ static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 static int empress_streamon(struct file *file, void *priv,
                                         enum v4l2_buf_type type)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_streamon(&dev->empress_tsq);
 }
@@ -291,8 +289,7 @@ static int empress_streamon(struct file *file, void *priv,
 static int empress_streamoff(struct file *file, void *priv,
                                         enum v4l2_buf_type type)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         return videobuf_streamoff(&dev->empress_tsq);
 }
@@ -300,8 +297,7 @@ static int empress_streamoff(struct file *file, void *priv,
 static int empress_s_ext_ctrls(struct file *file, void *priv,
                                struct v4l2_ext_controls *ctrls)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         /* count == 0 is abused in saa6752hs.c, so that special
                 case is handled here explicitly. */
@@ -320,8 +316,7 @@ static int empress_s_ext_ctrls(struct file *file, void *priv,
 static int empress_g_ext_ctrls(struct file *file, void *priv,
                                struct v4l2_ext_controls *ctrls)
 {
-        struct saa7134_fh *fh = priv;
-        struct saa7134_dev *dev = fh->dev;
+        struct saa7134_dev *dev = file->private_data;
 
         if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
                 return -EINVAL;
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index 919632b10aae..76e6501d238d 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -323,6 +323,15 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                 saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
                 saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
                 break;
+        case SAA7134_BOARD_AVERMEDIA_A16D:
+                ir_codes     = ir_codes_avermedia_a16d;
+                mask_keycode = 0x02F200;
+                mask_keydown = 0x000400;
+                polling      = 50; /* ms */
+                /* Without this we won't receive key up events */
+                saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
+                saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
+                break;
         case SAA7134_BOARD_KWORLD_TERMINATOR:
                 ir_codes     = ir_codes_pixelview;
                 mask_keycode = 0x00001f;
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index a1b92446c8b4..d015bfe00950 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -763,15 +763,6 @@ static struct device_driver ic_drv = {
         .owner  = THIS_MODULE,
 };
 
-/*
- * Image capture host - this is a host device, not a bus device, so,
- * no bus reference, no probing.
- */
-static struct class soc_camera_host_class = {
-        .owner          = THIS_MODULE,
-        .name           = "camera_host",
-};
-
 static void dummy_release(struct device *dev)
 {
 }
@@ -801,7 +792,6 @@ int soc_camera_host_register(struct soc_camera_host *ici)
 
         /* Number might be equal to the platform device ID */
         sprintf(ici->dev.bus_id, "camera_host%d", ici->nr);
-        ici->dev.class = &soc_camera_host_class;
 
         mutex_lock(&list_lock);
         list_for_each_entry(ix, &hosts, list) {
@@ -1003,14 +993,9 @@ static int __init soc_camera_init(void)
         ret = driver_register(&ic_drv);
         if (ret)
                 goto edrvr;
-        ret = class_register(&soc_camera_host_class);
-        if (ret)
-                goto eclr;
 
         return 0;
 
-eclr:
-        driver_unregister(&ic_drv);
 edrvr:
         bus_unregister(&soc_camera_bus_type);
         return ret;
@@ -1018,7 +1003,6 @@ edrvr:
 
 static void __exit soc_camera_exit(void)
 {
-        class_unregister(&soc_camera_host_class);
         driver_unregister(&ic_drv);
         bus_unregister(&soc_camera_bus_type);
 }
diff --git a/drivers/media/video/uvc/Makefile b/drivers/media/video/uvc/Makefile
new file mode 100644
index 000000000000..968c1994eda0
--- /dev/null
+++ b/drivers/media/video/uvc/Makefile
@@ -0,0 +1,3 @@
+uvcvideo-objs  := uvc_driver.o uvc_queue.o uvc_v4l2.o uvc_video.o uvc_ctrl.o \
+                  uvc_status.o uvc_isight.o
+obj-$(CONFIG_USB_VIDEO_CLASS) += uvcvideo.o
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
new file mode 100644
index 000000000000..f0ee46d15540
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -0,0 +1,1256 @@
+/*
+ *      uvc_ctrl.c  --  USB Video Class driver - Controls
+ *
+ *      Copyright (C) 2005-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/usb.h>
+#include <linux/videodev2.h>
+#include <linux/vmalloc.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+
+#include "uvcvideo.h"
+
+#define UVC_CTRL_NDATA          2
+#define UVC_CTRL_DATA_CURRENT   0
+#define UVC_CTRL_DATA_BACKUP    1
+
+/* ------------------------------------------------------------------------
+ * Control, formats, ...
+ */
+
+static struct uvc_control_info uvc_ctrls[] = {
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_BRIGHTNESS_CONTROL,
+                .index          = 0,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_CONTRAST_CONTROL,
+                .index          = 1,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_HUE_CONTROL,
+                .index          = 2,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_SATURATION_CONTROL,
+                .index          = 3,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_SHARPNESS_CONTROL,
+                .index          = 4,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_GAMMA_CONTROL,
+                .index          = 5,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
+                .index          = 8,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_GAIN_CONTROL,
+                .index          = 9,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
+                .index          = 10,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_HUE_AUTO_CONTROL,
+                .index          = 11,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_AE_MODE_CONTROL,
+                .index          = 1,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_GET_RES
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_AE_PRIORITY_CONTROL,
+                .index          = 2,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
+                .index          = 3,
+                .size           = 4,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
+                .index          = 5,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_FOCUS_AUTO_CONTROL,
+                .index          = 17,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
+                .index          = 12,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
+                .index          = 6,
+                .size           = 2,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
+                .index          = 13,
+                .size           = 1,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
+                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
+        },
+        {
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .index          = 7,
+                .size           = 4,
+                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
+                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
+        },
+};
+
+static struct uvc_menu_info power_line_frequency_controls[] = {
+        { 0, "Disabled" },
+        { 1, "50 Hz" },
+        { 2, "60 Hz" },
+};
+
+static struct uvc_menu_info exposure_auto_controls[] = {
+        { 1, "Manual Mode" },
+        { 2, "Auto Mode" },
+        { 4, "Shutter Priority Mode" },
+        { 8, "Aperture Priority Mode" },
+};
+
+static struct uvc_control_mapping uvc_ctrl_mappings[] = {
+        {
+                .id             = V4L2_CID_BRIGHTNESS,
+                .name           = "Brightness",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_BRIGHTNESS_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
+        },
+        {
+                .id             = V4L2_CID_CONTRAST,
+                .name           = "Contrast",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_CONTRAST_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_HUE,
+                .name           = "Hue",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_HUE_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
+        },
+        {
+                .id             = V4L2_CID_SATURATION,
+                .name           = "Saturation",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_SATURATION_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_SHARPNESS,
+                .name           = "Sharpness",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_SHARPNESS_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_GAMMA,
+                .name           = "Gamma",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_GAMMA_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_BACKLIGHT_COMPENSATION,
+                .name           = "Backlight Compensation",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_GAIN,
+                .name           = "Gain",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_GAIN_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_POWER_LINE_FREQUENCY,
+                .name           = "Power Line Frequency",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
+                .size           = 2,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_MENU,
+                .data_type      = UVC_CTRL_DATA_TYPE_ENUM,
+                .menu_info      = power_line_frequency_controls,
+                .menu_count     = ARRAY_SIZE(power_line_frequency_controls),
+        },
+        {
+                .id             = V4L2_CID_HUE_AUTO,
+                .name           = "Hue, Auto",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_HUE_AUTO_CONTROL,
+                .size           = 1,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
+                .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
+        },
+        {
+                .id             = V4L2_CID_EXPOSURE_AUTO,
+                .name           = "Exposure, Auto",
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_AE_MODE_CONTROL,
+                .size           = 4,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_MENU,
+                .data_type      = UVC_CTRL_DATA_TYPE_BITMASK,
+                .menu_info      = exposure_auto_controls,
+                .menu_count     = ARRAY_SIZE(exposure_auto_controls),
+        },
+        {
+                .id             = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
+                .name           = "Exposure, Auto Priority",
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_AE_PRIORITY_CONTROL,
+                .size           = 1,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
+                .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
+        },
+        {
+                .id             = V4L2_CID_EXPOSURE_ABSOLUTE,
+                .name           = "Exposure (Absolute)",
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
+                .size           = 32,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                .name           = "White Balance Temperature, Auto",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
+                .size           = 1,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
+                .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
+        },
+        {
+                .id             = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
+                .name           = "White Balance Temperature",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                .name           = "White Balance Component, Auto",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
+                .size           = 1,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
+                .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
+        },
+        {
+                .id             = V4L2_CID_BLUE_BALANCE,
+                .name           = "White Balance Blue Component",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
+        },
+        {
+                .id             = V4L2_CID_RED_BALANCE,
+                .name           = "White Balance Red Component",
+                .entity         = UVC_GUID_UVC_PROCESSING,
+                .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
+                .size           = 16,
+                .offset         = 16,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
+        },
+        {
+                .id             = V4L2_CID_FOCUS_ABSOLUTE,
+                .name           = "Focus (absolute)",
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
+                .size           = 16,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
+                .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
+        },
+        {
+                .id             = V4L2_CID_FOCUS_AUTO,
+                .name           = "Focus, Auto",
+                .entity         = UVC_GUID_UVC_CAMERA,
+                .selector       = CT_FOCUS_AUTO_CONTROL,
+                .size           = 1,
+                .offset         = 0,
+                .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
+                .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
+        },
+};
+
+/* ------------------------------------------------------------------------
+ * Utility functions
+ */
+
+static inline __u8 *uvc_ctrl_data(struct uvc_control *ctrl, int id)
+{
+        return ctrl->data + id * ctrl->info->size;
+}
+
+static inline int uvc_get_bit(const __u8 *data, int bit)
+{
+        return (data[bit >> 3] >> (bit & 7)) & 1;
+}
+
+/* Extract the bit string specified by mapping->offset and mapping->size
+ * from the little-endian data stored at 'data' and return the result as
+ * a signed 32bit integer. Sign extension will be performed if the mapping
+ * references a signed data type.
+ */
+static __s32 uvc_get_le_value(const __u8 *data,
+        struct uvc_control_mapping *mapping)
+{
+        int bits = mapping->size;
+        int offset = mapping->offset;
+        __s32 value = 0;
+        __u8 mask;
+
+        data += offset / 8;
+        offset &= 7;
+        mask = ((1LL << bits) - 1) << offset;
+
+        for (; bits > 0; data++) {
+                __u8 byte = *data & mask;
+                value |= offset > 0 ? (byte >> offset) : (byte << (-offset));
+                bits -= 8 - (offset > 0 ? offset : 0);
+                offset -= 8;
+                mask = (1 << bits) - 1;
+        }
+
+        /* Sign-extend the value if needed */
+        if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
+                value |= -(value & (1 << (mapping->size - 1)));
+
+        return value;
+}
+
+/* Set the bit string specified by mapping->offset and mapping->size
+ * in the little-endian data stored at 'data' to the value 'value'.
+ */
+static void uvc_set_le_value(__s32 value, __u8 *data,
+        struct uvc_control_mapping *mapping)
+{
+        int bits = mapping->size;
+        int offset = mapping->offset;
+        __u8 mask;
+
+        data += offset / 8;
+        offset &= 7;
+
+        for (; bits > 0; data++) {
+                mask = ((1LL << bits) - 1) << offset;
+                *data = (*data & ~mask) | ((value << offset) & mask);
+                value >>= offset ? offset : 8;
+                bits -= 8 - offset;
+                offset = 0;
+        }
+}
+
+/* ------------------------------------------------------------------------
+ * Terminal and unit management
+ */
+
+static const __u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
+static const __u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
+static const __u8 uvc_media_transport_input_guid[16] =
+        UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
+
+static int uvc_entity_match_guid(struct uvc_entity *entity, __u8 guid[16])
+{
+        switch (UVC_ENTITY_TYPE(entity)) {
+        case ITT_CAMERA:
+                return memcmp(uvc_camera_guid, guid, 16) == 0;
+
+        case ITT_MEDIA_TRANSPORT_INPUT:
+                return memcmp(uvc_media_transport_input_guid, guid, 16) == 0;
+
+        case VC_PROCESSING_UNIT:
+                return memcmp(uvc_processing_guid, guid, 16) == 0;
+
+        case VC_EXTENSION_UNIT:
+                return memcmp(entity->extension.guidExtensionCode,
+                              guid, 16) == 0;
+
+        default:
+                return 0;
+        }
+}
+
+/* ------------------------------------------------------------------------
+ * UVC Controls
+ */
+
+static void __uvc_find_control(struct uvc_entity *entity, __u32 v4l2_id,
+        struct uvc_control_mapping **mapping, struct uvc_control **control,
+        int next)
+{
+        struct uvc_control *ctrl;
+        struct uvc_control_mapping *map;
+        unsigned int i;
+
+        if (entity == NULL)
+                return;
+
+        for (i = 0; i < entity->ncontrols; ++i) {
+                ctrl = &entity->controls[i];
+                if (ctrl->info == NULL)
+                        continue;
+
+                list_for_each_entry(map, &ctrl->info->mappings, list) {
+                        if ((map->id == v4l2_id) && !next) {
+                                *control = ctrl;
+                                *mapping = map;
+                                return;
+                        }
+
+                        if ((*mapping == NULL || (*mapping)->id > map->id) &&
+                            (map->id > v4l2_id) && next) {
+                                *control = ctrl;
+                                *mapping = map;
+                        }
+                }
+        }
+}
+
+struct uvc_control *uvc_find_control(struct uvc_video_device *video,
+        __u32 v4l2_id, struct uvc_control_mapping **mapping)
+{
+        struct uvc_control *ctrl = NULL;
+        struct uvc_entity *entity;
+        int next = v4l2_id & V4L2_CTRL_FLAG_NEXT_CTRL;
+
+        *mapping = NULL;
+
+        /* Mask the query flags. */
+        v4l2_id &= V4L2_CTRL_ID_MASK;
+
+        /* Find the control. */
+        __uvc_find_control(video->processing, v4l2_id, mapping, &ctrl, next);
+        if (ctrl && !next)
+                return ctrl;
+
+        list_for_each_entry(entity, &video->iterms, chain) {
+                __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
+                if (ctrl && !next)
+                        return ctrl;
+        }
+
+        list_for_each_entry(entity, &video->extensions, chain) {
+                __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
+                if (ctrl && !next)
+                        return ctrl;
+        }
+
+        if (ctrl == NULL && !next)
+                uvc_trace(UVC_TRACE_CONTROL, "Control 0x%08x not found.\n",
+                                v4l2_id);
+
+        return ctrl;
+}
+
+int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
+        struct v4l2_queryctrl *v4l2_ctrl)
+{
+        struct uvc_control *ctrl;
+        struct uvc_control_mapping *mapping;
+        struct uvc_menu_info *menu;
+        unsigned int i;
+        __u8 data[8];
+        int ret;
+
+        ctrl = uvc_find_control(video, v4l2_ctrl->id, &mapping);
+        if (ctrl == NULL)
+                return -EINVAL;
+
+        v4l2_ctrl->id = mapping->id;
+        v4l2_ctrl->type = mapping->v4l2_type;
+        strncpy(v4l2_ctrl->name, mapping->name, sizeof v4l2_ctrl->name);
+        v4l2_ctrl->flags = 0;
+
+        if (!(ctrl->info->flags & UVC_CONTROL_SET_CUR))
+                v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
+                if ((ret = uvc_query_ctrl(video->dev, GET_DEF, ctrl->entity->id,
+                                video->dev->intfnum, ctrl->info->selector,
+                                &data, ctrl->info->size)) < 0)
+                        return ret;
+                v4l2_ctrl->default_value = uvc_get_le_value(data, mapping);
+        }
+
+        if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
+                v4l2_ctrl->minimum = 0;
+                v4l2_ctrl->maximum = mapping->menu_count - 1;
+                v4l2_ctrl->step = 1;
+
+                menu = mapping->menu_info;
+                for (i = 0; i < mapping->menu_count; ++i, ++menu) {
+                        if (menu->value == v4l2_ctrl->default_value) {
+                                v4l2_ctrl->default_value = i;
+                                break;
+                        }
+                }
+
+                return 0;
+        }
+
+        if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
+                if ((ret = uvc_query_ctrl(video->dev, GET_MIN, ctrl->entity->id,
+                                video->dev->intfnum, ctrl->info->selector,
+                                &data, ctrl->info->size)) < 0)
+                        return ret;
+                v4l2_ctrl->minimum = uvc_get_le_value(data, mapping);
+        }
+        if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
+                if ((ret = uvc_query_ctrl(video->dev, GET_MAX, ctrl->entity->id,
+                                video->dev->intfnum, ctrl->info->selector,
+                                &data, ctrl->info->size)) < 0)
+                        return ret;
+                v4l2_ctrl->maximum = uvc_get_le_value(data, mapping);
+        }
+        if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
+                if ((ret = uvc_query_ctrl(video->dev, GET_RES, ctrl->entity->id,
+                                video->dev->intfnum, ctrl->info->selector,
+                                &data, ctrl->info->size)) < 0)
+                        return ret;
+                v4l2_ctrl->step = uvc_get_le_value(data, mapping);
+        }
+
+        return 0;
+}
+
+
+/* --------------------------------------------------------------------------
+ * Control transactions
+ *
+ * To make extended set operations as atomic as the hardware allows, controls
+ * are handled using begin/commit/rollback operations.
+ *
+ * At the beginning of a set request, uvc_ctrl_begin should be called to
+ * initialize the request. This function acquires the control lock.
+ *
+ * When setting a control, the new value is stored in the control data field
+ * at position UVC_CTRL_DATA_CURRENT. The control is then marked as dirty for
+ * later processing. If the UVC and V4L2 control sizes differ, the current
+ * value is loaded from the hardware before storing the new value in the data
+ * field.
+ *
+ * After processing all controls in the transaction, uvc_ctrl_commit or
+ * uvc_ctrl_rollback must be called to apply the pending changes to the
+ * hardware or revert them. When applying changes, all controls marked as
+ * dirty will be modified in the UVC device, and the dirty flag will be
+ * cleared. When reverting controls, the control data field
+ * UVC_CTRL_DATA_CURRENT is reverted to its previous value
+ * (UVC_CTRL_DATA_BACKUP) for all dirty controls. Both functions release the
+ * control lock.
+ */
+int uvc_ctrl_begin(struct uvc_video_device *video)
+{
+        return mutex_lock_interruptible(&video->ctrl_mutex) ? -ERESTARTSYS : 0;
+}
+
+static int uvc_ctrl_commit_entity(struct uvc_device *dev,
+        struct uvc_entity *entity, int rollback)
+{
+        struct uvc_control *ctrl;
+        unsigned int i;
+        int ret;
+
+        if (entity == NULL)
+                return 0;
+
+        for (i = 0; i < entity->ncontrols; ++i) {
+                ctrl = &entity->controls[i];
+                if (ctrl->info == NULL || !ctrl->dirty)
+                        continue;
+
+                if (!rollback)
+                        ret = uvc_query_ctrl(dev, SET_CUR, ctrl->entity->id,
+                                dev->intfnum, ctrl->info->selector,
+                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                                ctrl->info->size);
+                else
+                        ret = 0;
+
+                if (rollback || ret < 0)
+                        memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                               uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
+                               ctrl->info->size);
+
+                if ((ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0)
+                        ctrl->loaded = 0;
+
+                ctrl->dirty = 0;
+
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+int __uvc_ctrl_commit(struct uvc_video_device *video, int rollback)
+{
+        struct uvc_entity *entity;
+        int ret = 0;
+
+        /* Find the control. */
+        ret = uvc_ctrl_commit_entity(video->dev, video->processing, rollback);
+        if (ret < 0)
+                goto done;
+
+        list_for_each_entry(entity, &video->iterms, chain) {
+                ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
+                if (ret < 0)
+                        goto done;
+        }
+
+        list_for_each_entry(entity, &video->extensions, chain) {
+                ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
+                if (ret < 0)
+                        goto done;
+        }
+
+done:
+        mutex_unlock(&video->ctrl_mutex);
+        return ret;
+}
+
+int uvc_ctrl_get(struct uvc_video_device *video,
+        struct v4l2_ext_control *xctrl)
+{
+        struct uvc_control *ctrl;
+        struct uvc_control_mapping *mapping;
+        struct uvc_menu_info *menu;
+        unsigned int i;
+        int ret;
+
+        ctrl = uvc_find_control(video, xctrl->id, &mapping);
+        if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0)
+                return -EINVAL;
+
+        if (!ctrl->loaded) {
+                ret = uvc_query_ctrl(video->dev, GET_CUR, ctrl->entity->id,
+                                video->dev->intfnum, ctrl->info->selector,
+                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                                ctrl->info->size);
+                if (ret < 0)
+                        return ret;
+
+                if ((ctrl->info->flags & UVC_CONTROL_AUTO_UPDATE) == 0)
+                        ctrl->loaded = 1;
+        }
+
+        xctrl->value = uvc_get_le_value(
+                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT), mapping);
+
+        if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
+                menu = mapping->menu_info;
+                for (i = 0; i < mapping->menu_count; ++i, ++menu) {
+                        if (menu->value == xctrl->value) {
+                                xctrl->value = i;
+                                break;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+int uvc_ctrl_set(struct uvc_video_device *video,
+        struct v4l2_ext_control *xctrl)
+{
+        struct uvc_control *ctrl;
+        struct uvc_control_mapping *mapping;
+        s32 value = xctrl->value;
+        int ret;
+
+        ctrl = uvc_find_control(video, xctrl->id, &mapping);
+        if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_SET_CUR) == 0)
+                return -EINVAL;
+
+        if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
+                if (value < 0 || value >= mapping->menu_count)
+                        return -EINVAL;
+                value = mapping->menu_info[value].value;
+        }
+
+        if (!ctrl->loaded && (ctrl->info->size * 8) != mapping->size) {
+                if ((ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0) {
+                        memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                                0, ctrl->info->size);
+                } else {
+                        ret = uvc_query_ctrl(video->dev, GET_CUR,
+                                ctrl->entity->id, video->dev->intfnum,
+                                ctrl->info->selector,
+                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                                ctrl->info->size);
+                        if (ret < 0)
+                                return ret;
+                }
+
+                if ((ctrl->info->flags & UVC_CONTROL_AUTO_UPDATE) == 0)
+                        ctrl->loaded = 1;
+        }
+
+        if (!ctrl->dirty) {
+                memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
+                       uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                       ctrl->info->size);
+        }
+
+        uvc_set_le_value(value,
+                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT), mapping);
+
+        ctrl->dirty = 1;
+        ctrl->modified = 1;
+        return 0;
+}
+
+/* --------------------------------------------------------------------------
+ * Dynamic controls
+ */
+
+int uvc_xu_ctrl_query(struct uvc_video_device *video,
+        struct uvc_xu_control *xctrl, int set)
+{
+        struct uvc_entity *entity;
+        struct uvc_control *ctrl = NULL;
+        unsigned int i, found = 0;
+        __u8 *data;
+        int ret;
+
+        /* Find the extension unit. */
+        list_for_each_entry(entity, &video->extensions, chain) {
+                if (entity->id == xctrl->unit)
+                        break;
+        }
+
+        if (entity->id != xctrl->unit) {
+                uvc_trace(UVC_TRACE_CONTROL, "Extension unit %u not found.\n",
+                        xctrl->unit);
+                return -EINVAL;
+        }
+
+        /* Find the control. */
+        for (i = 0; i < entity->ncontrols; ++i) {
+                ctrl = &entity->controls[i];
+                if (ctrl->info == NULL)
+                        continue;
+
+                if (ctrl->info->selector == xctrl->selector) {
+                        found = 1;
+                        break;
+                }
+        }
+
+        if (!found) {
+                uvc_trace(UVC_TRACE_CONTROL,
+                        "Control " UVC_GUID_FORMAT "/%u not found.\n",
+                        UVC_GUID_ARGS(entity->extension.guidExtensionCode),
+                        xctrl->selector);
+                return -EINVAL;
+        }
+
+        /* Validate control data size. */
+        if (ctrl->info->size != xctrl->size)
+                return -EINVAL;
+
+        if ((set && !(ctrl->info->flags & UVC_CONTROL_SET_CUR)) ||
+            (!set && !(ctrl->info->flags & UVC_CONTROL_GET_CUR)))
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&video->ctrl_mutex))
+                return -ERESTARTSYS;
+
+        memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
+               uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+               xctrl->size);
+        data = uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT);
+
+        if (set && copy_from_user(data, xctrl->data, xctrl->size)) {
+                ret = -EFAULT;
+                goto out;
+        }
+
+        ret = uvc_query_ctrl(video->dev, set ? SET_CUR : GET_CUR, xctrl->unit,
+                             video->dev->intfnum, xctrl->selector, data,
+                             xctrl->size);
+        if (ret < 0)
+                goto out;
+
+        if (!set && copy_to_user(xctrl->data, data, xctrl->size)) {
+                ret = -EFAULT;
+                goto out;
+        }
+
+out:
+        if (ret)
+                memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+                       uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
+                       xctrl->size);
+
+        mutex_unlock(&video->ctrl_mutex);
+        return ret;
+}
+
+/* --------------------------------------------------------------------------
+ * Suspend/resume
+ */
+
+/*
+ * Restore control values after resume, skipping controls that haven't been
+ * changed.
+ *
+ * TODO
+ * - Don't restore modified controls that are back to their default value.
+ * - Handle restore order (Auto-Exposure Mode should be restored before
+ *   Exposure Time).
+ */
+int uvc_ctrl_resume_device(struct uvc_device *dev)
+{
+        struct uvc_control *ctrl;
+        struct uvc_entity *entity;
+        unsigned int i;
+        int ret;
+
+        /* Walk the entities list and restore controls when possible. */
+        list_for_each_entry(entity, &dev->entities, list) {
+
+                for (i = 0; i < entity->ncontrols; ++i) {
+                        ctrl = &entity->controls[i];
+
+                        if (ctrl->info == NULL || !ctrl->modified ||
+                            (ctrl->info->flags & UVC_CONTROL_RESTORE) == 0)
+                                continue;
+
+                        printk(KERN_INFO "restoring control " UVC_GUID_FORMAT
+                                "/%u/%u\n", UVC_GUID_ARGS(ctrl->info->entity),
+                                ctrl->info->index, ctrl->info->selector);
+                        ctrl->dirty = 1;
+                }
+
+                ret = uvc_ctrl_commit_entity(dev, entity, 0);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+/* --------------------------------------------------------------------------
+ * Control and mapping handling
+ */
+
+static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
+        struct uvc_control_info *info)
+{
+        struct uvc_entity *entity;
+        struct uvc_control *ctrl = NULL;
+        int ret, found = 0;
+        unsigned int i;
+
+        list_for_each_entry(entity, &dev->entities, list) {
+                if (!uvc_entity_match_guid(entity, info->entity))
+                        continue;
+
+                for (i = 0; i < entity->ncontrols; ++i) {
+                        ctrl = &entity->controls[i];
+                        if (ctrl->index == info->index) {
+                                found = 1;
+                                break;
+                        }
+                }
+
+                if (found)
+                        break;
+        }
+
+        if (!found)
+                return;
+
+        if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
+                /* Check if the device control information and length match
+                 * the user supplied information.
+                 */
+                __u32 flags;
+                __le16 size;
+                __u8 inf;
+
+                if ((ret = uvc_query_ctrl(dev, GET_LEN, ctrl->entity->id,
+                        dev->intfnum, info->selector, (__u8 *)&size, 2)) < 0) {
+                        uvc_trace(UVC_TRACE_CONTROL, "GET_LEN failed on "
+                                "control " UVC_GUID_FORMAT "/%u (%d).\n",
+                                UVC_GUID_ARGS(info->entity), info->selector,
+                                ret);
+                        return;
+                }
+
+                if (info->size != le16_to_cpu(size)) {
+                        uvc_trace(UVC_TRACE_CONTROL, "Control " UVC_GUID_FORMAT
+                                "/%u size doesn't match user supplied "
+                                "value.\n", UVC_GUID_ARGS(info->entity),
+                                info->selector);
+                        return;
+                }
+
+                if ((ret = uvc_query_ctrl(dev, GET_INFO, ctrl->entity->id,
+                        dev->intfnum, info->selector, &inf, 1)) < 0) {
+                        uvc_trace(UVC_TRACE_CONTROL, "GET_INFO failed on "
+                                "control " UVC_GUID_FORMAT "/%u (%d).\n",
+                                UVC_GUID_ARGS(info->entity), info->selector,
+                                ret);
+                        return;
+                }
+
+                flags = info->flags;
+                if (((flags & UVC_CONTROL_GET_CUR) && !(inf & (1 << 0))) ||
+                    ((flags & UVC_CONTROL_SET_CUR) && !(inf & (1 << 1)))) {
+                        uvc_trace(UVC_TRACE_CONTROL, "Control "
+                                UVC_GUID_FORMAT "/%u flags don't match "
+                                "supported operations.\n",
+                                UVC_GUID_ARGS(info->entity), info->selector);
+                        return;
+                }
+        }
+
+        ctrl->info = info;
+        ctrl->data = kmalloc(ctrl->info->size * UVC_CTRL_NDATA, GFP_KERNEL);
+        uvc_trace(UVC_TRACE_CONTROL, "Added control " UVC_GUID_FORMAT "/%u "
+                "to device %s entity %u\n", UVC_GUID_ARGS(ctrl->info->entity),
+                ctrl->info->selector, dev->udev->devpath, entity->id);
+}
+
+/*
+ * Add an item to the UVC control information list, and instantiate a control
+ * structure for each device that supports the control.
+ */
+int uvc_ctrl_add_info(struct uvc_control_info *info)
+{
+        struct uvc_control_info *ctrl;
+        struct uvc_device *dev;
+        int ret = 0;
+
+        /* Find matching controls by walking the devices, entities and
+         * controls list.
+         */
+        mutex_lock(&uvc_driver.ctrl_mutex);
+
+        /* First check if the list contains a control matching the new one.
+         * Bail out if it does.
+         */
+        list_for_each_entry(ctrl, &uvc_driver.controls, list) {
+                if (memcmp(ctrl->entity, info->entity, 16))
+                        continue;
+
+                if (ctrl->selector == info->selector) {
+                        uvc_trace(UVC_TRACE_CONTROL, "Control "
+                                UVC_GUID_FORMAT "/%u is already defined.\n",
+                                UVC_GUID_ARGS(info->entity), info->selector);
+                        ret = -EEXIST;
+                        goto end;
+                }
+                if (ctrl->index == info->index) {
+                        uvc_trace(UVC_TRACE_CONTROL, "Control "
+                                UVC_GUID_FORMAT "/%u would overwrite index "
+                                "%d.\n", UVC_GUID_ARGS(info->entity),
+                                info->selector, info->index);
+                        ret = -EEXIST;
+                        goto end;
+                }
+        }
+
+        list_for_each_entry(dev, &uvc_driver.devices, list)
+                uvc_ctrl_add_ctrl(dev, info);
+
+        INIT_LIST_HEAD(&info->mappings);
+        list_add_tail(&info->list, &uvc_driver.controls);
+end:
+        mutex_unlock(&uvc_driver.ctrl_mutex);
+        return ret;
+}
+
+int uvc_ctrl_add_mapping(struct uvc_control_mapping *mapping)
+{
+        struct uvc_control_info *info;
+        struct uvc_control_mapping *map;
+        int ret = -EINVAL;
+
+        if (mapping->id & ~V4L2_CTRL_ID_MASK) {
+                uvc_trace(UVC_TRACE_CONTROL, "Can't add mapping '%s' with "
+                        "invalid control id 0x%08x\n", mapping->name,
+                        mapping->id);
+                return -EINVAL;
+        }
+
+        mutex_lock(&uvc_driver.ctrl_mutex);
+        list_for_each_entry(info, &uvc_driver.controls, list) {
+                if (memcmp(info->entity, mapping->entity, 16) ||
+                        info->selector != mapping->selector)
+                        continue;
+
+                if (info->size * 8 < mapping->size + mapping->offset) {
+                        uvc_trace(UVC_TRACE_CONTROL, "Mapping '%s' would "
+                                "overflow control " UVC_GUID_FORMAT "/%u\n",
+                                mapping->name, UVC_GUID_ARGS(info->entity),
+                                info->selector);
+                        ret = -EOVERFLOW;
+                        goto end;
+                }
+
+                /* Check if the list contains a mapping matching the new one.
+                 * Bail out if it does.
+                 */
+                list_for_each_entry(map, &info->mappings, list) {
+                        if (map->id == mapping->id) {
+                                uvc_trace(UVC_TRACE_CONTROL, "Mapping '%s' is "
+                                        "already defined.\n", mapping->name);
+                                ret = -EEXIST;
+                                goto end;
+                        }
+                }
+
+                mapping->ctrl = info;
+                list_add_tail(&mapping->list, &info->mappings);
+                uvc_trace(UVC_TRACE_CONTROL, "Adding mapping %s to control "
+                        UVC_GUID_FORMAT "/%u.\n", mapping->name,
+                        UVC_GUID_ARGS(info->entity), info->selector);
+
+                ret = 0;
+                break;
+        }
+end:
+        mutex_unlock(&uvc_driver.ctrl_mutex);
+        return ret;
+}
+
+/*
+ * Initialize device controls.
+ */
+int uvc_ctrl_init_device(struct uvc_device *dev)
+{
+        struct uvc_control_info *info;
+        struct uvc_control *ctrl;
+        struct uvc_entity *entity;
+        unsigned int i;
+
+        /* Walk the entities list and instantiate controls */
+        list_for_each_entry(entity, &dev->entities, list) {
+                unsigned int bControlSize = 0, ncontrols = 0;
+                __u8 *bmControls = NULL;
+
+                if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
+                        bmControls = entity->extension.bmControls;
+                        bControlSize = entity->extension.bControlSize;
+                } else if (UVC_ENTITY_TYPE(entity) == VC_PROCESSING_UNIT) {
+                        bmControls = entity->processing.bmControls;
+                        bControlSize = entity->processing.bControlSize;
+                } else if (UVC_ENTITY_TYPE(entity) == ITT_CAMERA) {
+                        bmControls = entity->camera.bmControls;
+                        bControlSize = entity->camera.bControlSize;
+                }
+
+                for (i = 0; i < bControlSize; ++i)
+                        ncontrols += hweight8(bmControls[i]);
+
+                if (ncontrols == 0)
+                        continue;
+
+                entity->controls = kzalloc(ncontrols*sizeof *ctrl, GFP_KERNEL);
+                if (entity->controls == NULL)
+                        return -ENOMEM;
+
+                entity->ncontrols = ncontrols;
+
+                ctrl = entity->controls;
+                for (i = 0; i < bControlSize * 8; ++i) {
+                        if (uvc_get_bit(bmControls, i) == 0)
+                                continue;
+
+                        ctrl->entity = entity;
+                        ctrl->index = i;
+                        ctrl++;
+                }
+        }
+
+        /* Walk the controls info list and associate them with the device
+         * controls, then add the device to the global device list. This has
+         * to be done while holding the controls lock, to make sure
+         * uvc_ctrl_add_info() will not get called in-between.
+         */
+        mutex_lock(&uvc_driver.ctrl_mutex);
+        list_for_each_entry(info, &uvc_driver.controls, list)
+                uvc_ctrl_add_ctrl(dev, info);
+
+        list_add_tail(&dev->list, &uvc_driver.devices);
+        mutex_unlock(&uvc_driver.ctrl_mutex);
+
+        return 0;
+}
+
+/*
+ * Cleanup device controls.
+ */
+void uvc_ctrl_cleanup_device(struct uvc_device *dev)
+{
+        struct uvc_entity *entity;
+        unsigned int i;
+
+        /* Remove the device from the global devices list */
+        mutex_lock(&uvc_driver.ctrl_mutex);
+        if (dev->list.next != NULL)
+                list_del(&dev->list);
+        mutex_unlock(&uvc_driver.ctrl_mutex);
+
+        list_for_each_entry(entity, &dev->entities, list) {
+                for (i = 0; i < entity->ncontrols; ++i)
+                        kfree(entity->controls[i].data);
+
+                kfree(entity->controls);
+        }
+}
+
+void uvc_ctrl_init(void)
+{
+        struct uvc_control_info *ctrl = uvc_ctrls;
+        struct uvc_control_info *cend = ctrl + ARRAY_SIZE(uvc_ctrls);
+        struct uvc_control_mapping *mapping = uvc_ctrl_mappings;
+        struct uvc_control_mapping *mend =
+                mapping + ARRAY_SIZE(uvc_ctrl_mappings);
+
+        for (; ctrl < cend; ++ctrl)
+                uvc_ctrl_add_info(ctrl);
+
+        for (; mapping < mend; ++mapping)
+                uvc_ctrl_add_mapping(mapping);
+}
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
new file mode 100644
index 000000000000..60ced589f898
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -0,0 +1,1955 @@
+/*
+ *      uvc_driver.c  --  USB Video Class driver
+ *
+ *      Copyright (C) 2005-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+/*
+ * This driver aims to support video input devices compliant with the 'USB
+ * Video Class' specification.
+ *
+ * The driver doesn't support the deprecated v4l1 interface. It implements the
+ * mmap capture method only, and doesn't do any image format conversion in
+ * software. If your user-space application doesn't support YUYV or MJPEG, fix
+ * it :-). Please note that the MJPEG data have been stripped from their
+ * Huffman tables (DHT marker), you will need to add it back if your JPEG
+ * codec can't handle MJPEG data.
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/videodev2.h>
+#include <linux/vmalloc.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+
+#include <media/v4l2-common.h>
+
+#include "uvcvideo.h"
+
+#define DRIVER_AUTHOR           "Laurent Pinchart <laurent.pinchart@skynet.be>"
+#define DRIVER_DESC             "USB Video Class driver"
+#ifndef DRIVER_VERSION
+#define DRIVER_VERSION          "v0.1.0"
+#endif
+
+static unsigned int uvc_quirks_param;
+unsigned int uvc_trace_param;
+
+/* ------------------------------------------------------------------------
+ * Control, formats, ...
+ */
+
+static struct uvc_format_desc uvc_fmts[] = {
+        {
+                .name           = "YUV 4:2:2 (YUYV)",
+                .guid           = UVC_GUID_FORMAT_YUY2,
+                .fcc            = V4L2_PIX_FMT_YUYV,
+        },
+        {
+                .name           = "YUV 4:2:0 (NV12)",
+                .guid           = UVC_GUID_FORMAT_NV12,
+                .fcc            = V4L2_PIX_FMT_NV12,
+        },
+        {
+                .name           = "MJPEG",
+                .guid           = UVC_GUID_FORMAT_MJPEG,
+                .fcc            = V4L2_PIX_FMT_MJPEG,
+        },
+        {
+                .name           = "YVU 4:2:0 (YV12)",
+                .guid           = UVC_GUID_FORMAT_YV12,
+                .fcc            = V4L2_PIX_FMT_YVU420,
+        },
+        {
+                .name           = "YUV 4:2:0 (I420)",
+                .guid           = UVC_GUID_FORMAT_I420,
+                .fcc            = V4L2_PIX_FMT_YUV420,
+        },
+        {
+                .name           = "YUV 4:2:2 (UYVY)",
+                .guid           = UVC_GUID_FORMAT_UYVY,
+                .fcc            = V4L2_PIX_FMT_UYVY,
+        },
+        {
+                .name           = "Greyscale",
+                .guid           = UVC_GUID_FORMAT_Y800,
+                .fcc            = V4L2_PIX_FMT_GREY,
+        },
+        {
+                .name           = "RGB Bayer",
+                .guid           = UVC_GUID_FORMAT_BY8,
+                .fcc            = V4L2_PIX_FMT_SBGGR8,
+        },
+};
+
+/* ------------------------------------------------------------------------
+ * Utility functions
+ */
+
+struct usb_host_endpoint *uvc_find_endpoint(struct usb_host_interface *alts,
+                __u8 epaddr)
+{
+        struct usb_host_endpoint *ep;
+        unsigned int i;
+
+        for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
+                ep = &alts->endpoint[i];
+                if (ep->desc.bEndpointAddress == epaddr)
+                        return ep;
+        }
+
+        return NULL;
+}
+
+static struct uvc_format_desc *uvc_format_by_guid(const __u8 guid[16])
+{
+        unsigned int len = ARRAY_SIZE(uvc_fmts);
+        unsigned int i;
+
+        for (i = 0; i < len; ++i) {
+                if (memcmp(guid, uvc_fmts[i].guid, 16) == 0)
+                        return &uvc_fmts[i];
+        }
+
+        return NULL;
+}
+
+static __u32 uvc_colorspace(const __u8 primaries)
+{
+        static const __u8 colorprimaries[] = {
+                0,
+                V4L2_COLORSPACE_SRGB,
+                V4L2_COLORSPACE_470_SYSTEM_M,
+                V4L2_COLORSPACE_470_SYSTEM_BG,
+                V4L2_COLORSPACE_SMPTE170M,
+                V4L2_COLORSPACE_SMPTE240M,
+        };
+
+        if (primaries < ARRAY_SIZE(colorprimaries))
+                return colorprimaries[primaries];
+
+        return 0;
+}
+
+/* Simplify a fraction using a simple continued fraction decomposition. The
+ * idea here is to convert fractions such as 333333/10000000 to 1/30 using
+ * 32 bit arithmetic only. The algorithm is not perfect and relies upon two
+ * arbitrary parameters to remove non-significative terms from the simple
+ * continued fraction decomposition. Using 8 and 333 for n_terms and threshold
+ * respectively seems to give nice results.
+ */
+void uvc_simplify_fraction(uint32_t *numerator, uint32_t *denominator,
+                unsigned int n_terms, unsigned int threshold)
+{
+        uint32_t *an;
+        uint32_t x, y, r;
+        unsigned int i, n;
+
+        an = kmalloc(n_terms * sizeof *an, GFP_KERNEL);
+        if (an == NULL)
+                return;
+
+        /* Convert the fraction to a simple continued fraction. See
+         * http://mathforum.org/dr.math/faq/faq.fractions.html
+         * Stop if the current term is bigger than or equal to the given
+         * threshold.
+         */
+        x = *numerator;
+        y = *denominator;
+
+        for (n = 0; n < n_terms && y != 0; ++n) {
+                an[n] = x / y;
+                if (an[n] >= threshold) {
+                        if (n < 2)
+                                n++;
+                        break;
+                }
+
+                r = x - an[n] * y;
+                x = y;
+                y = r;
+        }
+
+        /* Expand the simple continued fraction back to an integer fraction. */
+        x = 0;
+        y = 1;
+
+        for (i = n; i > 0; --i) {
+                r = y;
+                y = an[i-1] * y + x;
+                x = r;
+        }
+
+        *numerator = y;
+        *denominator = x;
+        kfree(an);
+}
+
+/* Convert a fraction to a frame interval in 100ns multiples. The idea here is
+ * to compute numerator / denominator * 10000000 using 32 bit fixed point
+ * arithmetic only.
+ */
+uint32_t uvc_fraction_to_interval(uint32_t numerator, uint32_t denominator)
+{
+        uint32_t multiplier;
+
+        /* Saturate the result if the operation would overflow. */
+        if (denominator == 0 ||
+            numerator/denominator >= ((uint32_t)-1)/10000000)
+                return (uint32_t)-1;
+
+        /* Divide both the denominator and the multiplier by two until
+         * numerator * multiplier doesn't overflow. If anyone knows a better
+         * algorithm please let me know.
+         */
+        multiplier = 10000000;
+        while (numerator > ((uint32_t)-1)/multiplier) {
+                multiplier /= 2;
+                denominator /= 2;
+        }
+
+        return denominator ? numerator * multiplier / denominator : 0;
+}
+
+/* ------------------------------------------------------------------------
+ * Terminal and unit management
+ */
+
+static struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id)
+{
+        struct uvc_entity *entity;
+
+        list_for_each_entry(entity, &dev->entities, list) {
+                if (entity->id == id)
+                        return entity;
+        }
+
+        return NULL;
+}
+
+static struct uvc_entity *uvc_entity_by_reference(struct uvc_device *dev,
+        int id, struct uvc_entity *entity)
+{
+        unsigned int i;
+
+        if (entity == NULL)
+                entity = list_entry(&dev->entities, struct uvc_entity, list);
+
+        list_for_each_entry_continue(entity, &dev->entities, list) {
+                switch (UVC_ENTITY_TYPE(entity)) {
+                case TT_STREAMING:
+                        if (entity->output.bSourceID == id)
+                                return entity;
+                        break;
+
+                case VC_PROCESSING_UNIT:
+                        if (entity->processing.bSourceID == id)
+                                return entity;
+                        break;
+
+                case VC_SELECTOR_UNIT:
+                        for (i = 0; i < entity->selector.bNrInPins; ++i)
+                                if (entity->selector.baSourceID[i] == id)
+                                        return entity;
+                        break;
+
+                case VC_EXTENSION_UNIT:
+                        for (i = 0; i < entity->extension.bNrInPins; ++i)
+                                if (entity->extension.baSourceID[i] == id)
+                                        return entity;
+                        break;
+                }
+        }
+
+        return NULL;
+}
+
+/* ------------------------------------------------------------------------
+ * Descriptors handling
+ */
+
+static int uvc_parse_format(struct uvc_device *dev,
+        struct uvc_streaming *streaming, struct uvc_format *format,
+        __u32 **intervals, unsigned char *buffer, int buflen)
+{
+        struct usb_interface *intf = streaming->intf;
+        struct usb_host_interface *alts = intf->cur_altsetting;
+        struct uvc_format_desc *fmtdesc;
+        struct uvc_frame *frame;
+        const unsigned char *start = buffer;
+        unsigned int interval;
+        unsigned int i, n;
+        __u8 ftype;
+
+        format->type = buffer[2];
+        format->index = buffer[3];
+
+        switch (buffer[2]) {
+        case VS_FORMAT_UNCOMPRESSED:
+        case VS_FORMAT_FRAME_BASED:
+                if (buflen < 27) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d FORMAT error\n",
+                               dev->udev->devnum,
+                               alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                /* Find the format descriptor from its GUID. */
+                fmtdesc = uvc_format_by_guid(&buffer[5]);
+
+                if (fmtdesc != NULL) {
+                        strncpy(format->name, fmtdesc->name,
+                                sizeof format->name);
+                        format->fcc = fmtdesc->fcc;
+                } else {
+                        uvc_printk(KERN_INFO, "Unknown video format "
+                                UVC_GUID_FORMAT "\n",
+                                UVC_GUID_ARGS(&buffer[5]));
+                        snprintf(format->name, sizeof format->name,
+                                UVC_GUID_FORMAT, UVC_GUID_ARGS(&buffer[5]));
+                        format->fcc = 0;
+                }
+
+                format->bpp = buffer[21];
+                if (buffer[2] == VS_FORMAT_UNCOMPRESSED) {
+                        ftype = VS_FRAME_UNCOMPRESSED;
+                } else {
+                        ftype = VS_FRAME_FRAME_BASED;
+                        if (buffer[27])
+                                format->flags = UVC_FMT_FLAG_COMPRESSED;
+                }
+                break;
+
+        case VS_FORMAT_MJPEG:
+                if (buflen < 11) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d FORMAT error\n",
+                               dev->udev->devnum,
+                               alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                strncpy(format->name, "MJPEG", sizeof format->name);
+                format->fcc = V4L2_PIX_FMT_MJPEG;
+                format->flags = UVC_FMT_FLAG_COMPRESSED;
+                format->bpp = 0;
+                ftype = VS_FRAME_MJPEG;
+                break;
+
+        case VS_FORMAT_DV:
+                if (buflen < 9) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d FORMAT error\n",
+                               dev->udev->devnum,
+                               alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                switch (buffer[8] & 0x7f) {
+                case 0:
+                        strncpy(format->name, "SD-DV", sizeof format->name);
+                        break;
+                case 1:
+                        strncpy(format->name, "SDL-DV", sizeof format->name);
+                        break;
+                case 2:
+                        strncpy(format->name, "HD-DV", sizeof format->name);
+                        break;
+                default:
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d: unknown DV format %u\n",
+                               dev->udev->devnum,
+                               alts->desc.bInterfaceNumber, buffer[8]);
+                        return -EINVAL;
+                }
+
+                strncat(format->name, buffer[8] & (1 << 7) ? " 60Hz" : " 50Hz",
+                        sizeof format->name);
+
+                format->fcc = V4L2_PIX_FMT_DV;
+                format->flags = UVC_FMT_FLAG_COMPRESSED | UVC_FMT_FLAG_STREAM;
+                format->bpp = 0;
+                ftype = 0;
+
+                /* Create a dummy frame descriptor. */
+                frame = &format->frame[0];
+                memset(&format->frame[0], 0, sizeof format->frame[0]);
+                frame->bFrameIntervalType = 1;
+                frame->dwDefaultFrameInterval = 1;
+                frame->dwFrameInterval = *intervals;
+                *(*intervals)++ = 1;
+                format->nframes = 1;
+                break;
+
+        case VS_FORMAT_MPEG2TS:
+        case VS_FORMAT_STREAM_BASED:
+                /* Not supported yet. */
+        default:
+                uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                       "interface %d unsupported format %u\n",
+                       dev->udev->devnum, alts->desc.bInterfaceNumber,
+                       buffer[2]);
+                return -EINVAL;
+        }
+
+        uvc_trace(UVC_TRACE_DESCR, "Found format %s.\n", format->name);
+
+        buflen -= buffer[0];
+        buffer += buffer[0];
+
+        /* Parse the frame descriptors. Only uncompressed, MJPEG and frame
+         * based formats have frame descriptors.
+         */
+        while (buflen > 2 && buffer[2] == ftype) {
+                frame = &format->frame[format->nframes];
+
+                if (ftype != VS_FRAME_FRAME_BASED)
+                        n = buflen > 25 ? buffer[25] : 0;
+                else
+                        n = buflen > 21 ? buffer[21] : 0;
+
+                n = n ? n : 3;
+
+                if (buflen < 26 + 4*n) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d FRAME error\n", dev->udev->devnum,
+                               alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                frame->bFrameIndex = buffer[3];
+                frame->bmCapabilities = buffer[4];
+                frame->wWidth = le16_to_cpup((__le16 *)&buffer[5]);
+                frame->wHeight = le16_to_cpup((__le16 *)&buffer[7]);
+                frame->dwMinBitRate = le32_to_cpup((__le32 *)&buffer[9]);
+                frame->dwMaxBitRate = le32_to_cpup((__le32 *)&buffer[13]);
+                if (ftype != VS_FRAME_FRAME_BASED) {
+                        frame->dwMaxVideoFrameBufferSize =
+                                le32_to_cpup((__le32 *)&buffer[17]);
+                        frame->dwDefaultFrameInterval =
+                                le32_to_cpup((__le32 *)&buffer[21]);
+                        frame->bFrameIntervalType = buffer[25];
+                } else {
+                        frame->dwMaxVideoFrameBufferSize = 0;
+                        frame->dwDefaultFrameInterval =
+                                le32_to_cpup((__le32 *)&buffer[17]);
+                        frame->bFrameIntervalType = buffer[21];
+                }
+                frame->dwFrameInterval = *intervals;
+
+                /* Several UVC chipsets screw up dwMaxVideoFrameBufferSize
+                 * completely. Observed behaviours range from setting the
+                 * value to 1.1x the actual frame size of hardwiring the
+                 * 16 low bits to 0. This results in a higher than necessary
+                 * memory usage as well as a wrong image size information. For
+                 * uncompressed formats this can be fixed by computing the
+                 * value from the frame size.
+                 */
+                if (!(format->flags & UVC_FMT_FLAG_COMPRESSED))
+                        frame->dwMaxVideoFrameBufferSize = format->bpp
+                                * frame->wWidth * frame->wHeight / 8;
+
+                /* Some bogus devices report dwMinFrameInterval equal to
+                 * dwMaxFrameInterval and have dwFrameIntervalStep set to
+                 * zero. Setting all null intervals to 1 fixes the problem and
+                 * some other divisions by zero which could happen.
+                 */
+                for (i = 0; i < n; ++i) {
+                        interval = le32_to_cpup((__le32 *)&buffer[26+4*i]);
+                        *(*intervals)++ = interval ? interval : 1;
+                }
+
+                /* Make sure that the default frame interval stays between
+                 * the boundaries.
+                 */
+                n -= frame->bFrameIntervalType ? 1 : 2;
+                frame->dwDefaultFrameInterval =
+                        min(frame->dwFrameInterval[n],
+                            max(frame->dwFrameInterval[0],
+                                frame->dwDefaultFrameInterval));
+
+                uvc_trace(UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
+                        frame->wWidth, frame->wHeight,
+                        10000000/frame->dwDefaultFrameInterval,
+                        (100000000/frame->dwDefaultFrameInterval)%10);
+
+                format->nframes++;
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        if (buflen > 2 && buffer[2] == VS_STILL_IMAGE_FRAME) {
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        if (buflen > 2 && buffer[2] == VS_COLORFORMAT) {
+                if (buflen < 6) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming"
+                               "interface %d COLORFORMAT error\n",
+                               dev->udev->devnum,
+                               alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                format->colorspace = uvc_colorspace(buffer[3]);
+
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        return buffer - start;
+}
+
+static int uvc_parse_streaming(struct uvc_device *dev,
+        struct usb_interface *intf)
+{
+        struct uvc_streaming *streaming = NULL;
+        struct uvc_format *format;
+        struct uvc_frame *frame;
+        struct usb_host_interface *alts = &intf->altsetting[0];
+        unsigned char *_buffer, *buffer = alts->extra;
+        int _buflen, buflen = alts->extralen;
+        unsigned int nformats = 0, nframes = 0, nintervals = 0;
+        unsigned int size, i, n, p;
+        __u32 *interval;
+        __u16 psize;
+        int ret = -EINVAL;
+
+        if (intf->cur_altsetting->desc.bInterfaceSubClass
+                != SC_VIDEOSTREAMING) {
+                uvc_trace(UVC_TRACE_DESCR, "device %d interface %d isn't a "
+                        "video streaming interface\n", dev->udev->devnum,
+                        intf->altsetting[0].desc.bInterfaceNumber);
+                return -EINVAL;
+        }
+
+        if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
+                uvc_trace(UVC_TRACE_DESCR, "device %d interface %d is already "
+                        "claimed\n", dev->udev->devnum,
+                        intf->altsetting[0].desc.bInterfaceNumber);
+                return -EINVAL;
+        }
+
+        streaming = kzalloc(sizeof *streaming, GFP_KERNEL);
+        if (streaming == NULL) {
+                usb_driver_release_interface(&uvc_driver.driver, intf);
+                return -EINVAL;
+        }
+
+        mutex_init(&streaming->mutex);
+        streaming->intf = usb_get_intf(intf);
+        streaming->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
+
+        /* The Pico iMage webcam has its class-specific interface descriptors
+         * after the endpoint descriptors.
+         */
+        if (buflen == 0) {
+                for (i = 0; i < alts->desc.bNumEndpoints; ++i) {
+                        struct usb_host_endpoint *ep = &alts->endpoint[i];
+
+                        if (ep->extralen == 0)
+                                continue;
+
+                        if (ep->extralen > 2 &&
+                            ep->extra[1] == USB_DT_CS_INTERFACE) {
+                                uvc_trace(UVC_TRACE_DESCR, "trying extra data "
+                                        "from endpoint %u.\n", i);
+                                buffer = alts->endpoint[i].extra;
+                                buflen = alts->endpoint[i].extralen;
+                                break;
+                        }
+                }
+        }
+
+        /* Skip the standard interface descriptors. */
+        while (buflen > 2 && buffer[1] != USB_DT_CS_INTERFACE) {
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        if (buflen <= 2) {
+                uvc_trace(UVC_TRACE_DESCR, "no class-specific streaming "
+                        "interface descriptors found.\n");
+                goto error;
+        }
+
+        /* Parse the header descriptor. */
+        if (buffer[2] == VS_OUTPUT_HEADER) {
+                uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
+                        "%d OUTPUT HEADER descriptor is not supported.\n",
+                        dev->udev->devnum, alts->desc.bInterfaceNumber);
+                goto error;
+        } else if (buffer[2] == VS_INPUT_HEADER) {
+                p = buflen >= 5 ? buffer[3] : 0;
+                n = buflen >= 12 ? buffer[12] : 0;
+
+                if (buflen < 13 + p*n || buffer[2] != VS_INPUT_HEADER) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
+                                "interface %d INPUT HEADER descriptor is "
+                                "invalid.\n", dev->udev->devnum,
+                                alts->desc.bInterfaceNumber);
+                        goto error;
+                }
+
+                streaming->header.bNumFormats = p;
+                streaming->header.bEndpointAddress = buffer[6];
+                streaming->header.bmInfo = buffer[7];
+                streaming->header.bTerminalLink = buffer[8];
+                streaming->header.bStillCaptureMethod = buffer[9];
+                streaming->header.bTriggerSupport = buffer[10];
+                streaming->header.bTriggerUsage = buffer[11];
+                streaming->header.bControlSize = n;
+
+                streaming->header.bmaControls = kmalloc(p*n, GFP_KERNEL);
+                if (streaming->header.bmaControls == NULL) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+
+                memcpy(streaming->header.bmaControls, &buffer[13], p*n);
+        } else {
+                uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
+                        "%d HEADER descriptor not found.\n", dev->udev->devnum,
+                        alts->desc.bInterfaceNumber);
+                goto error;
+        }
+
+        buflen -= buffer[0];
+        buffer += buffer[0];
+
+        _buffer = buffer;
+        _buflen = buflen;
+
+        /* Count the format and frame descriptors. */
+        while (_buflen > 2) {
+                switch (_buffer[2]) {
+                case VS_FORMAT_UNCOMPRESSED:
+                case VS_FORMAT_MJPEG:
+                case VS_FORMAT_FRAME_BASED:
+                        nformats++;
+                        break;
+
+                case VS_FORMAT_DV:
+                        /* DV format has no frame descriptor. We will create a
+                         * dummy frame descriptor with a dummy frame interval.
+                         */
+                        nformats++;
+                        nframes++;
+                        nintervals++;
+                        break;
+
+                case VS_FORMAT_MPEG2TS:
+                case VS_FORMAT_STREAM_BASED:
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
+                                "interface %d FORMAT %u is not supported.\n",
+                                dev->udev->devnum,
+                                alts->desc.bInterfaceNumber, _buffer[2]);
+                        break;
+
+                case VS_FRAME_UNCOMPRESSED:
+                case VS_FRAME_MJPEG:
+                        nframes++;
+                        if (_buflen > 25)
+                                nintervals += _buffer[25] ? _buffer[25] : 3;
+                        break;
+
+                case VS_FRAME_FRAME_BASED:
+                        nframes++;
+                        if (_buflen > 21)
+                                nintervals += _buffer[21] ? _buffer[21] : 3;
+                        break;
+                }
+
+                _buflen -= _buffer[0];
+                _buffer += _buffer[0];
+        }
+
+        if (nformats == 0) {
+                uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
+                        "%d has no supported formats defined.\n",
+                        dev->udev->devnum, alts->desc.bInterfaceNumber);
+                goto error;
+        }
+
+        size = nformats * sizeof *format + nframes * sizeof *frame
+             + nintervals * sizeof *interval;
+        format = kzalloc(size, GFP_KERNEL);
+        if (format == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        frame = (struct uvc_frame *)&format[nformats];
+        interval = (__u32 *)&frame[nframes];
+
+        streaming->format = format;
+        streaming->nformats = nformats;
+
+        /* Parse the format descriptors. */
+        while (buflen > 2) {
+                switch (buffer[2]) {
+                case VS_FORMAT_UNCOMPRESSED:
+                case VS_FORMAT_MJPEG:
+                case VS_FORMAT_DV:
+                case VS_FORMAT_FRAME_BASED:
+                        format->frame = frame;
+                        ret = uvc_parse_format(dev, streaming, format,
+                                &interval, buffer, buflen);
+                        if (ret < 0)
+                                goto error;
+
+                        frame += format->nframes;
+                        format++;
+
+                        buflen -= ret;
+                        buffer += ret;
+                        continue;
+
+                default:
+                        break;
+                }
+
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        /* Parse the alternate settings to find the maximum bandwidth. */
+        for (i = 0; i < intf->num_altsetting; ++i) {
+                struct usb_host_endpoint *ep;
+                alts = &intf->altsetting[i];
+                ep = uvc_find_endpoint(alts,
+                                streaming->header.bEndpointAddress);
+                if (ep == NULL)
+                        continue;
+
+                psize = le16_to_cpu(ep->desc.wMaxPacketSize);
+                psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+                if (psize > streaming->maxpsize)
+                        streaming->maxpsize = psize;
+        }
+
+        list_add_tail(&streaming->list, &dev->streaming);
+        return 0;
+
+error:
+        usb_driver_release_interface(&uvc_driver.driver, intf);
+        usb_put_intf(intf);
+        kfree(streaming->format);
+        kfree(streaming->header.bmaControls);
+        kfree(streaming);
+        return ret;
+}
+
+/* Parse vendor-specific extensions. */
+static int uvc_parse_vendor_control(struct uvc_device *dev,
+        const unsigned char *buffer, int buflen)
+{
+        struct usb_device *udev = dev->udev;
+        struct usb_host_interface *alts = dev->intf->cur_altsetting;
+        struct uvc_entity *unit;
+        unsigned int n, p;
+        int handled = 0;
+
+        switch (le16_to_cpu(dev->udev->descriptor.idVendor)) {
+        case 0x046d:            /* Logitech */
+                if (buffer[1] != 0x41 || buffer[2] != 0x01)
+                        break;
+
+                /* Logitech implements several vendor specific functions
+                 * through vendor specific extension units (LXU).
+                 *
+                 * The LXU descriptors are similar to XU descriptors
+                 * (see "USB Device Video Class for Video Devices", section
+                 * 3.7.2.6 "Extension Unit Descriptor") with the following
+                 * differences:
+                 *
+                 * ----------------------------------------------------------
+                 * 0            bLength         1        Number
+                 *      Size of this descriptor, in bytes: 24+p+n*2
+                 * ----------------------------------------------------------
+                 * 23+p+n       bmControlsType  N       Bitmap
+                 *      Individual bits in the set are defined:
+                 *      0: Absolute
+                 *      1: Relative
+                 *
+                 *      This bitset is mapped exactly the same as bmControls.
+                 * ----------------------------------------------------------
+                 * 23+p+n*2     bReserved       1       Boolean
+                 * ----------------------------------------------------------
+                 * 24+p+n*2     iExtension      1       Index
+                 *      Index of a string descriptor that describes this
+                 *      extension unit.
+                 * ----------------------------------------------------------
+                 */
+                p = buflen >= 22 ? buffer[21] : 0;
+                n = buflen >= 25 + p ? buffer[22+p] : 0;
+
+                if (buflen < 25 + p + 2*n) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d EXTENSION_UNIT error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        break;
+                }
+
+                unit = kzalloc(sizeof *unit + p + 2*n, GFP_KERNEL);
+                if (unit == NULL)
+                        return -ENOMEM;
+
+                unit->id = buffer[3];
+                unit->type = VC_EXTENSION_UNIT;
+                memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
+                unit->extension.bNumControls = buffer[20];
+                unit->extension.bNrInPins =
+                        le16_to_cpup((__le16 *)&buffer[21]);
+                unit->extension.baSourceID = (__u8 *)unit + sizeof *unit;
+                memcpy(unit->extension.baSourceID, &buffer[22], p);
+                unit->extension.bControlSize = buffer[22+p];
+                unit->extension.bmControls = (__u8 *)unit + sizeof *unit + p;
+                unit->extension.bmControlsType = (__u8 *)unit + sizeof *unit
+                                               + p + n;
+                memcpy(unit->extension.bmControls, &buffer[23+p], 2*n);
+
+                if (buffer[24+p+2*n] != 0)
+                        usb_string(udev, buffer[24+p+2*n], unit->name,
+                                   sizeof unit->name);
+                else
+                        sprintf(unit->name, "Extension %u", buffer[3]);
+
+                list_add_tail(&unit->list, &dev->entities);
+                handled = 1;
+                break;
+        }
+
+        return handled;
+}
+
+static int uvc_parse_standard_control(struct uvc_device *dev,
+        const unsigned char *buffer, int buflen)
+{
+        struct usb_device *udev = dev->udev;
+        struct uvc_entity *unit, *term;
+        struct usb_interface *intf;
+        struct usb_host_interface *alts = dev->intf->cur_altsetting;
+        unsigned int i, n, p, len;
+        __u16 type;
+
+        switch (buffer[2]) {
+        case VC_HEADER:
+                n = buflen >= 12 ? buffer[11] : 0;
+
+                if (buflen < 12 || buflen < 12 + n) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d HEADER error\n", udev->devnum,
+                                alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                dev->uvc_version = le16_to_cpup((__le16 *)&buffer[3]);
+                dev->clock_frequency = le32_to_cpup((__le32 *)&buffer[7]);
+
+                /* Parse all USB Video Streaming interfaces. */
+                for (i = 0; i < n; ++i) {
+                        intf = usb_ifnum_to_if(udev, buffer[12+i]);
+                        if (intf == NULL) {
+                                uvc_trace(UVC_TRACE_DESCR, "device %d "
+                                        "interface %d doesn't exists\n",
+                                        udev->devnum, i);
+                                continue;
+                        }
+
+                        uvc_parse_streaming(dev, intf);
+                }
+                break;
+
+        case VC_INPUT_TERMINAL:
+                if (buflen < 8) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d INPUT_TERMINAL error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                /* Make sure the terminal type MSB is not null, otherwise it
+                 * could be confused with a unit.
+                 */
+                type = le16_to_cpup((__le16 *)&buffer[4]);
+                if ((type & 0xff00) == 0) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d INPUT_TERMINAL %d has invalid "
+                                "type 0x%04x, skipping\n", udev->devnum,
+                                alts->desc.bInterfaceNumber,
+                                buffer[3], type);
+                        return 0;
+                }
+
+                n = 0;
+                p = 0;
+                len = 8;
+
+                if (type == ITT_CAMERA) {
+                        n = buflen >= 15 ? buffer[14] : 0;
+                        len = 15;
+
+                } else if (type == ITT_MEDIA_TRANSPORT_INPUT) {
+                        n = buflen >= 9 ? buffer[8] : 0;
+                        p = buflen >= 10 + n ? buffer[9+n] : 0;
+                        len = 10;
+                }
+
+                if (buflen < len + n + p) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d INPUT_TERMINAL error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                term = kzalloc(sizeof *term + n + p, GFP_KERNEL);
+                if (term == NULL)
+                        return -ENOMEM;
+
+                term->id = buffer[3];
+                term->type = type | UVC_TERM_INPUT;
+
+                if (UVC_ENTITY_TYPE(term) == ITT_CAMERA) {
+                        term->camera.bControlSize = n;
+                        term->camera.bmControls = (__u8 *)term + sizeof *term;
+                        term->camera.wObjectiveFocalLengthMin =
+                                le16_to_cpup((__le16 *)&buffer[8]);
+                        term->camera.wObjectiveFocalLengthMax =
+                                le16_to_cpup((__le16 *)&buffer[10]);
+                        term->camera.wOcularFocalLength =
+                                le16_to_cpup((__le16 *)&buffer[12]);
+                        memcpy(term->camera.bmControls, &buffer[15], n);
+                } else if (UVC_ENTITY_TYPE(term) == ITT_MEDIA_TRANSPORT_INPUT) {
+                        term->media.bControlSize = n;
+                        term->media.bmControls = (__u8 *)term + sizeof *term;
+                        term->media.bTransportModeSize = p;
+                        term->media.bmTransportModes = (__u8 *)term
+                                                     + sizeof *term + n;
+                        memcpy(term->media.bmControls, &buffer[9], n);
+                        memcpy(term->media.bmTransportModes, &buffer[10+n], p);
+                }
+
+                if (buffer[7] != 0)
+                        usb_string(udev, buffer[7], term->name,
+                                   sizeof term->name);
+                else if (UVC_ENTITY_TYPE(term) == ITT_CAMERA)
+                        sprintf(term->name, "Camera %u", buffer[3]);
+                else if (UVC_ENTITY_TYPE(term) == ITT_MEDIA_TRANSPORT_INPUT)
+                        sprintf(term->name, "Media %u", buffer[3]);
+                else
+                        sprintf(term->name, "Input %u", buffer[3]);
+
+                list_add_tail(&term->list, &dev->entities);
+                break;
+
+        case VC_OUTPUT_TERMINAL:
+                if (buflen < 9) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d OUTPUT_TERMINAL error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                /* Make sure the terminal type MSB is not null, otherwise it
+                 * could be confused with a unit.
+                 */
+                type = le16_to_cpup((__le16 *)&buffer[4]);
+                if ((type & 0xff00) == 0) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d OUTPUT_TERMINAL %d has invalid "
+                                "type 0x%04x, skipping\n", udev->devnum,
+                                alts->desc.bInterfaceNumber, buffer[3], type);
+                        return 0;
+                }
+
+                term = kzalloc(sizeof *term, GFP_KERNEL);
+                if (term == NULL)
+                        return -ENOMEM;
+
+                term->id = buffer[3];
+                term->type = type | UVC_TERM_OUTPUT;
+                term->output.bSourceID = buffer[7];
+
+                if (buffer[8] != 0)
+                        usb_string(udev, buffer[8], term->name,
+                                   sizeof term->name);
+                else
+                        sprintf(term->name, "Output %u", buffer[3]);
+
+                list_add_tail(&term->list, &dev->entities);
+                break;
+
+        case VC_SELECTOR_UNIT:
+                p = buflen >= 5 ? buffer[4] : 0;
+
+                if (buflen < 5 || buflen < 6 + p) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d SELECTOR_UNIT error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                unit = kzalloc(sizeof *unit + p, GFP_KERNEL);
+                if (unit == NULL)
+                        return -ENOMEM;
+
+                unit->id = buffer[3];
+                unit->type = buffer[2];
+                unit->selector.bNrInPins = buffer[4];
+                unit->selector.baSourceID = (__u8 *)unit + sizeof *unit;
+                memcpy(unit->selector.baSourceID, &buffer[5], p);
+
+                if (buffer[5+p] != 0)
+                        usb_string(udev, buffer[5+p], unit->name,
+                                   sizeof unit->name);
+                else
+                        sprintf(unit->name, "Selector %u", buffer[3]);
+
+                list_add_tail(&unit->list, &dev->entities);
+                break;
+
+        case VC_PROCESSING_UNIT:
+                n = buflen >= 8 ? buffer[7] : 0;
+                p = dev->uvc_version >= 0x0110 ? 10 : 9;
+
+                if (buflen < p + n) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d PROCESSING_UNIT error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                unit = kzalloc(sizeof *unit + n, GFP_KERNEL);
+                if (unit == NULL)
+                        return -ENOMEM;
+
+                unit->id = buffer[3];
+                unit->type = buffer[2];
+                unit->processing.bSourceID = buffer[4];
+                unit->processing.wMaxMultiplier =
+                        le16_to_cpup((__le16 *)&buffer[5]);
+                unit->processing.bControlSize = buffer[7];
+                unit->processing.bmControls = (__u8 *)unit + sizeof *unit;
+                memcpy(unit->processing.bmControls, &buffer[8], n);
+                if (dev->uvc_version >= 0x0110)
+                        unit->processing.bmVideoStandards = buffer[9+n];
+
+                if (buffer[8+n] != 0)
+                        usb_string(udev, buffer[8+n], unit->name,
+                                   sizeof unit->name);
+                else
+                        sprintf(unit->name, "Processing %u", buffer[3]);
+
+                list_add_tail(&unit->list, &dev->entities);
+                break;
+
+        case VC_EXTENSION_UNIT:
+                p = buflen >= 22 ? buffer[21] : 0;
+                n = buflen >= 24 + p ? buffer[22+p] : 0;
+
+                if (buflen < 24 + p + n) {
+                        uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
+                                "interface %d EXTENSION_UNIT error\n",
+                                udev->devnum, alts->desc.bInterfaceNumber);
+                        return -EINVAL;
+                }
+
+                unit = kzalloc(sizeof *unit + p + n, GFP_KERNEL);
+                if (unit == NULL)
+                        return -ENOMEM;
+
+                unit->id = buffer[3];
+                unit->type = buffer[2];
+                memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
+                unit->extension.bNumControls = buffer[20];
+                unit->extension.bNrInPins =
+                        le16_to_cpup((__le16 *)&buffer[21]);
+                unit->extension.baSourceID = (__u8 *)unit + sizeof *unit;
+                memcpy(unit->extension.baSourceID, &buffer[22], p);
+                unit->extension.bControlSize = buffer[22+p];
+                unit->extension.bmControls = (__u8 *)unit + sizeof *unit + p;
+                memcpy(unit->extension.bmControls, &buffer[23+p], n);
+
+                if (buffer[23+p+n] != 0)
+                        usb_string(udev, buffer[23+p+n], unit->name,
+                                   sizeof unit->name);
+                else
+                        sprintf(unit->name, "Extension %u", buffer[3]);
+
+                list_add_tail(&unit->list, &dev->entities);
+                break;
+
+        default:
+                uvc_trace(UVC_TRACE_DESCR, "Found an unknown CS_INTERFACE "
+                        "descriptor (%u)\n", buffer[2]);
+                break;
+        }
+
+        return 0;
+}
+
+static int uvc_parse_control(struct uvc_device *dev)
+{
+        struct usb_host_interface *alts = dev->intf->cur_altsetting;
+        unsigned char *buffer = alts->extra;
+        int buflen = alts->extralen;
+        int ret;
+
+        /* Parse the default alternate setting only, as the UVC specification
+         * defines a single alternate setting, the default alternate setting
+         * zero.
+         */
+
+        while (buflen > 2) {
+                if (uvc_parse_vendor_control(dev, buffer, buflen) ||
+                    buffer[1] != USB_DT_CS_INTERFACE)
+                        goto next_descriptor;
+
+                if ((ret = uvc_parse_standard_control(dev, buffer, buflen)) < 0)
+                        return ret;
+
+next_descriptor:
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        /* Check if the optional status endpoint is present. */
+        if (alts->desc.bNumEndpoints == 1) {
+                struct usb_host_endpoint *ep = &alts->endpoint[0];
+                struct usb_endpoint_descriptor *desc = &ep->desc;
+
+                if (usb_endpoint_is_int_in(desc) &&
+                    le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
+                    desc->bInterval != 0) {
+                        uvc_trace(UVC_TRACE_DESCR, "Found a Status endpoint "
+                                "(addr %02x).\n", desc->bEndpointAddress);
+                        dev->int_ep = ep;
+                }
+        }
+
+        return 0;
+}
+
+/* ------------------------------------------------------------------------
+ * USB probe and disconnect
+ */
+
+/*
+ * Unregister the video devices.
+ */
+static void uvc_unregister_video(struct uvc_device *dev)
+{
+        if (dev->video.vdev) {
+                if (dev->video.vdev->minor == -1)
+                        video_device_release(dev->video.vdev);
+                else
+                        video_unregister_device(dev->video.vdev);
+                dev->video.vdev = NULL;
+        }
+}
+
+/*
+ * Scan the UVC descriptors to locate a chain starting at an Output Terminal
+ * and containing the following units:
+ *
+ * - a USB Streaming Output Terminal
+ * - zero or one Processing Unit
+ * - zero, one or mode single-input Selector Units
+ * - zero or one multiple-input Selector Units, provided all inputs are
+ *   connected to input terminals
+ * - zero, one or mode single-input Extension Units
+ * - one Camera Input Terminal, or one or more External terminals.
+ *
+ * A side forward scan is made on each detected entity to check for additional
+ * extension units.
+ */
+static int uvc_scan_chain_entity(struct uvc_video_device *video,
+        struct uvc_entity *entity)
+{
+        switch (UVC_ENTITY_TYPE(entity)) {
+        case VC_EXTENSION_UNIT:
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk(" <- XU %d", entity->id);
+
+                if (entity->extension.bNrInPins != 1) {
+                        uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has more "
+                                "than 1 input pin.\n", entity->id);
+                        return -1;
+                }
+
+                list_add_tail(&entity->chain, &video->extensions);
+                break;
+
+        case VC_PROCESSING_UNIT:
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk(" <- PU %d", entity->id);
+
+                if (video->processing != NULL) {
+                        uvc_trace(UVC_TRACE_DESCR, "Found multiple "
+                                "Processing Units in chain.\n");
+                        return -1;
+                }
+
+                video->processing = entity;
+                break;
+
+        case VC_SELECTOR_UNIT:
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk(" <- SU %d", entity->id);
+
+                /* Single-input selector units are ignored. */
+                if (entity->selector.bNrInPins == 1)
+                        break;
+
+                if (video->selector != NULL) {
+                        uvc_trace(UVC_TRACE_DESCR, "Found multiple Selector "
+                                "Units in chain.\n");
+                        return -1;
+                }
+
+                video->selector = entity;
+                break;
+
+        case ITT_VENDOR_SPECIFIC:
+        case ITT_CAMERA:
+        case ITT_MEDIA_TRANSPORT_INPUT:
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk(" <- IT %d\n", entity->id);
+
+                list_add_tail(&entity->chain, &video->iterms);
+                break;
+
+        default:
+                uvc_trace(UVC_TRACE_DESCR, "Unsupported entity type "
+                        "0x%04x found in chain.\n", UVC_ENTITY_TYPE(entity));
+                return -1;
+        }
+
+        return 0;
+}
+
+static int uvc_scan_chain_forward(struct uvc_video_device *video,
+        struct uvc_entity *entity, struct uvc_entity *prev)
+{
+        struct uvc_entity *forward;
+        int found;
+
+        /* Forward scan */
+        forward = NULL;
+        found = 0;
+
+        while (1) {
+                forward = uvc_entity_by_reference(video->dev, entity->id,
+                        forward);
+                if (forward == NULL)
+                        break;
+
+                if (UVC_ENTITY_TYPE(forward) != VC_EXTENSION_UNIT ||
+                    forward == prev)
+                        continue;
+
+                if (forward->extension.bNrInPins != 1) {
+                        uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has"
+                                "more than 1 input pin.\n", entity->id);
+                        return -1;
+                }
+
+                list_add_tail(&forward->chain, &video->extensions);
+                if (uvc_trace_param & UVC_TRACE_PROBE) {
+                        if (!found)
+                                printk(" (-> XU");
+
+                        printk(" %d", forward->id);
+                        found = 1;
+                }
+        }
+        if (found)
+                printk(")");
+
+        return 0;
+}
+
+static int uvc_scan_chain_backward(struct uvc_video_device *video,
+        struct uvc_entity *entity)
+{
+        struct uvc_entity *term;
+        int id = -1, i;
+
+        switch (UVC_ENTITY_TYPE(entity)) {
+        case VC_EXTENSION_UNIT:
+                id = entity->extension.baSourceID[0];
+                break;
+
+        case VC_PROCESSING_UNIT:
+                id = entity->processing.bSourceID;
+                break;
+
+        case VC_SELECTOR_UNIT:
+                /* Single-input selector units are ignored. */
+                if (entity->selector.bNrInPins == 1) {
+                        id = entity->selector.baSourceID[0];
+                        break;
+                }
+
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk(" <- IT");
+
+                video->selector = entity;
+                for (i = 0; i < entity->selector.bNrInPins; ++i) {
+                        id = entity->selector.baSourceID[i];
+                        term = uvc_entity_by_id(video->dev, id);
+                        if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
+                                uvc_trace(UVC_TRACE_DESCR, "Selector unit %d "
+                                        "input %d isn't connected to an "
+                                        "input terminal\n", entity->id, i);
+                                return -1;
+                        }
+
+                        if (uvc_trace_param & UVC_TRACE_PROBE)
+                                printk(" %d", term->id);
+
+                        list_add_tail(&term->chain, &video->iterms);
+                        uvc_scan_chain_forward(video, term, entity);
+                }
+
+                if (uvc_trace_param & UVC_TRACE_PROBE)
+                        printk("\n");
+
+                id = 0;
+                break;
+        }
+
+        return id;
+}
+
+static int uvc_scan_chain(struct uvc_video_device *video)
+{
+        struct uvc_entity *entity, *prev;
+        int id;
+
+        entity = video->oterm;
+        uvc_trace(UVC_TRACE_PROBE, "Scanning UVC chain: OT %d", entity->id);
+        id = entity->output.bSourceID;
+        while (id != 0) {
+                prev = entity;
+                entity = uvc_entity_by_id(video->dev, id);
+                if (entity == NULL) {
+                        uvc_trace(UVC_TRACE_DESCR, "Found reference to "
+                                "unknown entity %d.\n", id);
+                        return -1;
+                }
+
+                /* Process entity */
+                if (uvc_scan_chain_entity(video, entity) < 0)
+                        return -1;
+
+                /* Forward scan */
+                if (uvc_scan_chain_forward(video, entity, prev) < 0)
+                        return -1;
+
+                /* Stop when a terminal is found. */
+                if (!UVC_ENTITY_IS_UNIT(entity))
+                        break;
+
+                /* Backward scan */
+                id = uvc_scan_chain_backward(video, entity);
+                if (id < 0)
+                        return id;
+        }
+
+        /* Initialize the video buffers queue. */
+        uvc_queue_init(&video->queue);
+
+        return 0;
+}
+
+/*
+ * Register the video devices.
+ *
+ * The driver currently supports a single video device per control interface
+ * only. The terminal and units must match the following structure:
+ *
+ * ITT_CAMERA -> VC_PROCESSING_UNIT -> VC_EXTENSION_UNIT{0,n} -> TT_STREAMING
+ *
+ * The Extension Units, if present, must have a single input pin. The
+ * Processing Unit and Extension Units can be in any order. Additional
+ * Extension Units connected to the main chain as single-unit branches are
+ * also supported.
+ */
+static int uvc_register_video(struct uvc_device *dev)
+{
+        struct video_device *vdev;
+        struct uvc_entity *term;
+        int found = 0, ret;
+
+        /* Check if the control interface matches the structure we expect. */
+        list_for_each_entry(term, &dev->entities, list) {
+                struct uvc_streaming *streaming;
+
+                if (UVC_ENTITY_TYPE(term) != TT_STREAMING)
+                        continue;
+
+                memset(&dev->video, 0, sizeof dev->video);
+                mutex_init(&dev->video.ctrl_mutex);
+                INIT_LIST_HEAD(&dev->video.iterms);
+                INIT_LIST_HEAD(&dev->video.extensions);
+                dev->video.oterm = term;
+                dev->video.dev = dev;
+                if (uvc_scan_chain(&dev->video) < 0)
+                        continue;
+
+                list_for_each_entry(streaming, &dev->streaming, list) {
+                        if (streaming->header.bTerminalLink == term->id) {
+                                dev->video.streaming = streaming;
+                                found = 1;
+                                break;
+                        }
+                }
+
+                if (found)
+                        break;
+        }
+
+        if (!found) {
+                uvc_printk(KERN_INFO, "No valid video chain found.\n");
+                return -1;
+        }
+
+        if (uvc_trace_param & UVC_TRACE_PROBE) {
+                uvc_printk(KERN_INFO, "Found a valid video chain (");
+                list_for_each_entry(term, &dev->video.iterms, chain) {
+                        printk("%d", term->id);
+                        if (term->chain.next != &dev->video.iterms)
+                                printk(",");
+                }
+                printk(" -> %d).\n", dev->video.oterm->id);
+        }
+
+        /* Initialize the streaming interface with default streaming
+         * parameters.
+         */
+        if ((ret = uvc_video_init(&dev->video)) < 0) {
+                uvc_printk(KERN_ERR, "Failed to initialize the device "
+                        "(%d).\n", ret);
+                return ret;
+        }
+
+        /* Register the device with V4L. */
+        vdev = video_device_alloc();
+        if (vdev == NULL)
+                return -1;
+
+        /* We already hold a reference to dev->udev. The video device will be
+         * unregistered before the reference is released, so we don't need to
+         * get another one.
+         */
+        vdev->dev = &dev->intf->dev;
+        vdev->type = 0;
+        vdev->type2 = 0;
+        vdev->minor = -1;
+        vdev->fops = &uvc_fops;
+        vdev->release = video_device_release;
+        strncpy(vdev->name, dev->name, sizeof vdev->name);
+
+        /* Set the driver data before calling video_register_device, otherwise
+         * uvc_v4l2_open might race us.
+         *
+         * FIXME: usb_set_intfdata hasn't been called so far. Is that a
+         *        problem ? Does any function which could be called here get
+         *        a pointer to the usb_interface ?
+         */
+        dev->video.vdev = vdev;
+        video_set_drvdata(vdev, &dev->video);
+
+        if (video_register_device(vdev, VFL_TYPE_GRABBER, -1) < 0) {
+                dev->video.vdev = NULL;
+                video_device_release(vdev);
+                return -1;
+        }
+
+        return 0;
+}
+
+/*
+ * Delete the UVC device.
+ *
+ * Called by the kernel when the last reference to the uvc_device structure
+ * is released.
+ *
+ * Unregistering the video devices is done here because every opened instance
+ * must be closed before the device can be unregistered. An alternative would
+ * have been to use another reference count for uvc_v4l2_open/uvc_release, and
+ * unregister the video devices on disconnect when that reference count drops
+ * to zero.
+ *
+ * As this function is called after or during disconnect(), all URBs have
+ * already been canceled by the USB core. There is no need to kill the
+ * interrupt URB manually.
+ */
+void uvc_delete(struct kref *kref)
+{
+        struct uvc_device *dev = container_of(kref, struct uvc_device, kref);
+        struct list_head *p, *n;
+
+        /* Unregister the video device */
+        uvc_unregister_video(dev);
+        usb_put_intf(dev->intf);
+        usb_put_dev(dev->udev);
+
+        uvc_status_cleanup(dev);
+        uvc_ctrl_cleanup_device(dev);
+
+        list_for_each_safe(p, n, &dev->entities) {
+                struct uvc_entity *entity;
+                entity = list_entry(p, struct uvc_entity, list);
+                kfree(entity);
+        }
+
+        list_for_each_safe(p, n, &dev->streaming) {
+                struct uvc_streaming *streaming;
+                streaming = list_entry(p, struct uvc_streaming, list);
+                usb_driver_release_interface(&uvc_driver.driver,
+                        streaming->intf);
+                usb_put_intf(streaming->intf);
+                kfree(streaming->format);
+                kfree(streaming->header.bmaControls);
+                kfree(streaming);
+        }
+
+        kfree(dev);
+}
+
+static int uvc_probe(struct usb_interface *intf,
+                     const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct uvc_device *dev;
+        int ret;
+
+        if (id->idVendor && id->idProduct)
+                uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s "
+                                "(%04x:%04x)\n", udev->devpath, id->idVendor,
+                                id->idProduct);
+        else
+                uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n",
+                                udev->devpath);
+
+        /* Allocate memory for the device and initialize it */
+        if ((dev = kzalloc(sizeof *dev, GFP_KERNEL)) == NULL)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&dev->entities);
+        INIT_LIST_HEAD(&dev->streaming);
+        kref_init(&dev->kref);
+
+        dev->udev = usb_get_dev(udev);
+        dev->intf = usb_get_intf(intf);
+        dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;
+        dev->quirks = id->driver_info | uvc_quirks_param;
+
+        if (udev->product != NULL)
+                strncpy(dev->name, udev->product, sizeof dev->name);
+        else
+                snprintf(dev->name, sizeof dev->name,
+                        "UVC Camera (%04x:%04x)",
+                        le16_to_cpu(udev->descriptor.idVendor),
+                        le16_to_cpu(udev->descriptor.idProduct));
+
+        /* Parse the Video Class control descriptor */
+        if (uvc_parse_control(dev) < 0) {
+                uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "
+                        "descriptors.\n");
+                goto error;
+        }
+
+        uvc_printk(KERN_INFO, "Found UVC %u.%02u device %s (%04x:%04x)\n",
+                dev->uvc_version >> 8, dev->uvc_version & 0xff,
+                udev->product ? udev->product : "<unnamed>",
+                le16_to_cpu(udev->descriptor.idVendor),
+                le16_to_cpu(udev->descriptor.idProduct));
+
+        if (uvc_quirks_param != 0) {
+                uvc_printk(KERN_INFO, "Forcing device quirks 0x%x by module "
+                        "parameter for testing purpose.\n", uvc_quirks_param);
+                uvc_printk(KERN_INFO, "Please report required quirks to the "
+                        "linux-uvc-devel mailing list.\n");
+        }
+
+        /* Initialize controls */
+        if (uvc_ctrl_init_device(dev) < 0)
+                goto error;
+
+        /* Register the video devices */
+        if (uvc_register_video(dev) < 0)
+                goto error;
+
+        /* Save our data pointer in the interface data */
+        usb_set_intfdata(intf, dev);
+
+        /* Initialize the interrupt URB */
+        if ((ret = uvc_status_init(dev)) < 0) {
+                uvc_printk(KERN_INFO, "Unable to initialize the status "
+                        "endpoint (%d), status interrupt will not be "
+                        "supported.\n", ret);
+        }
+
+        uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
+        return 0;
+
+error:
+        kref_put(&dev->kref, uvc_delete);
+        return -ENODEV;
+}
+
+static void uvc_disconnect(struct usb_interface *intf)
+{
+        struct uvc_device *dev = usb_get_intfdata(intf);
+
+        /* Set the USB interface data to NULL. This can be done outside the
+         * lock, as there's no other reader.
+         */
+        usb_set_intfdata(intf, NULL);
+
+        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOSTREAMING)
+                return;
+
+        /* uvc_v4l2_open() might race uvc_disconnect(). A static driver-wide
+         * lock is needed to prevent uvc_disconnect from releasing its
+         * reference to the uvc_device instance after uvc_v4l2_open() received
+         * the pointer to the device (video_devdata) but before it got the
+         * chance to increase the reference count (kref_get).
+         */
+        mutex_lock(&uvc_driver.open_mutex);
+
+        dev->state |= UVC_DEV_DISCONNECTED;
+        kref_put(&dev->kref, uvc_delete);
+
+        mutex_unlock(&uvc_driver.open_mutex);
+}
+
+static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        struct uvc_device *dev = usb_get_intfdata(intf);
+
+        uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
+                intf->cur_altsetting->desc.bInterfaceNumber);
+
+        /* Controls are cached on the fly so they don't need to be saved. */
+        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL)
+                return uvc_status_suspend(dev);
+
+        if (dev->video.streaming->intf != intf) {
+                uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB "
+                                "interface mismatch.\n");
+                return -EINVAL;
+        }
+
+        return uvc_video_suspend(&dev->video);
+}
+
+static int uvc_resume(struct usb_interface *intf)
+{
+        struct uvc_device *dev = usb_get_intfdata(intf);
+        int ret;
+
+        uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
+                intf->cur_altsetting->desc.bInterfaceNumber);
+
+        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL) {
+                if ((ret = uvc_ctrl_resume_device(dev)) < 0)
+                        return ret;
+
+                return uvc_status_resume(dev);
+        }
+
+        if (dev->video.streaming->intf != intf) {
+                uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB "
+                                "interface mismatch.\n");
+                return -EINVAL;
+        }
+
+        return uvc_video_resume(&dev->video);
+}
+
+/* ------------------------------------------------------------------------
+ * Driver initialization and cleanup
+ */
+
+/*
+ * The Logitech cameras listed below have their interface class set to
+ * VENDOR_SPEC because they don't announce themselves as UVC devices, even
+ * though they are compliant.
+ */
+static struct usb_device_id uvc_ids[] = {
+        /* ALi M5606 (Clevo M540SR) */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x0402,
+          .idProduct            = 0x5606,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Creative Live! Optia */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x041e,
+          .idProduct            = 0x4057,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Microsoft Lifecam NX-6000 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x045e,
+          .idProduct            = 0x00f8,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Microsoft Lifecam VX-7000 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x045e,
+          .idProduct            = 0x0723,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Logitech Quickcam Fusion */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c1,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Logitech Quickcam Orbit MP */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c2,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Logitech Quickcam Pro for Notebook */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c3,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Logitech Quickcam Pro 5000 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c5,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Logitech Quickcam OEM Dell Notebook */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c6,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Logitech Quickcam OEM Cisco VT Camera II */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x046d,
+          .idProduct            = 0x08c7,
+          .bInterfaceClass      = USB_CLASS_VENDOR_SPEC,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0 },
+        /* Apple Built-In iSight */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x05ac,
+          .idProduct            = 0x8501,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX
+                                | UVC_QUIRK_BUILTIN_ISIGHT },
+        /* Genesys Logic USB 2.0 PC Camera */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x05e3,
+          .idProduct            = 0x0505,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_STREAM_NO_FID },
+        /* Silicon Motion SM371 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x090c,
+          .idProduct            = 0xb371,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* MT6227 */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x0e8d,
+          .idProduct            = 0x0004,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Syntek (HP Spartan) */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x174f,
+          .idProduct            = 0x5212,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_STREAM_NO_FID },
+        /* Syntek (Asus U3S) */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x174f,
+          .idProduct            = 0x8a33,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_STREAM_NO_FID },
+        /* Ecamm Pico iMage */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x18cd,
+          .idProduct            = 0xcafe,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_EXTRAFIELDS },
+        /* Bodelin ProScopeHR */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_DEV_HI
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x19ab,
+          .idProduct            = 0x1000,
+          .bcdDevice_hi         = 0x0126,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_STATUS_INTERVAL },
+        /* SiGma Micro USB Web Camera */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x1c4f,
+          .idProduct            = 0x3000,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX
+                                | UVC_QUIRK_IGNORE_SELECTOR_UNIT},
+        /* Acer OEM Webcam - Unknown vendor */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0100,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Packard Bell OEM Webcam */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0101,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Acer Crystal Eye webcam */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0102,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Acer OrbiCam - Unknown vendor */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0200,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Generic USB Video Class */
+        { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, uvc_ids);
+
+struct uvc_driver uvc_driver = {
+        .driver = {
+                .name           = "uvcvideo",
+                .probe          = uvc_probe,
+                .disconnect     = uvc_disconnect,
+                .suspend        = uvc_suspend,
+                .resume         = uvc_resume,
+                .id_table       = uvc_ids,
+                .supports_autosuspend = 1,
+        },
+};
+
+static int __init uvc_init(void)
+{
+        int result;
+
+        INIT_LIST_HEAD(&uvc_driver.devices);
+        INIT_LIST_HEAD(&uvc_driver.controls);
+        mutex_init(&uvc_driver.open_mutex);
+        mutex_init(&uvc_driver.ctrl_mutex);
+
+        uvc_ctrl_init();
+
+        result = usb_register(&uvc_driver.driver);
+        if (result == 0)
+                printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
+        return result;
+}
+
+static void __exit uvc_cleanup(void)
+{
+        usb_deregister(&uvc_driver.driver);
+}
+
+module_init(uvc_init);
+module_exit(uvc_cleanup);
+
+module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(quirks, "Forced device quirks");
+module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(trace, "Trace level bitmask");
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRIVER_VERSION);
diff --git a/drivers/media/video/uvc/uvc_isight.c b/drivers/media/video/uvc/uvc_isight.c
new file mode 100644
index 000000000000..37bdefdbead5
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_isight.c
@@ -0,0 +1,134 @@
+/*
+ *      uvc_isight.c  --  USB Video Class driver - iSight support
+ *
+ *      Copyright (C) 2006-2007
+ *              Ivan N. Zlatev <contact@i-nz.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.
+ *
+ */
+
+#include <linux/usb.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+
+#include "uvcvideo.h"
+
+/* Built-in iSight webcams implements most of UVC 1.0 except a
+ * different packet format. Instead of sending a header at the
+ * beginning of each isochronous transfer payload, the webcam sends a
+ * single header per image (on its own in a packet), followed by
+ * packets containing data only.
+ *
+ * Offset   Size (bytes)        Description
+ * ------------------------------------------------------------------
+ * 0x00         1       Header length
+ * 0x01         1       Flags (UVC-compliant)
+ * 0x02         4       Always equal to '11223344'
+ * 0x06         8       Always equal to 'deadbeefdeadface'
+ * 0x0e         16      Unknown
+ *
+ * The header can be prefixed by an optional, unknown-purpose byte.
+ */
+
+static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
+                const __u8 *data, unsigned int len)
+{
+        static const __u8 hdr[] = {
+                0x11, 0x22, 0x33, 0x44,
+                0xde, 0xad, 0xbe, 0xef,
+                0xde, 0xad, 0xfa, 0xce
+        };
+
+        unsigned int maxlen, nbytes;
+        __u8 *mem;
+        int is_header = 0;
+
+        if (buf == NULL)
+                return 0;
+
+        if ((len >= 14 && memcmp(&data[2], hdr, 12) == 0) ||
+            (len >= 15 && memcmp(&data[3], hdr, 12) == 0)) {
+                uvc_trace(UVC_TRACE_FRAME, "iSight header found\n");
+                is_header = 1;
+        }
+
+        /* Synchronize to the input stream by waiting for a header packet. */
+        if (buf->state != UVC_BUF_STATE_ACTIVE) {
+                if (!is_header) {
+                        uvc_trace(UVC_TRACE_FRAME, "Dropping packet (out of "
+                                  "sync).\n");
+                        return 0;
+                }
+
+                buf->state = UVC_BUF_STATE_ACTIVE;
+        }
+
+        /* Mark the buffer as done if we're at the beginning of a new frame.
+         *
+         * Empty buffers (bytesused == 0) don't trigger end of frame detection
+         * as it doesn't make sense to return an empty buffer.
+         */
+        if (is_header && buf->buf.bytesused != 0) {
+                buf->state = UVC_BUF_STATE_DONE;
+                return -EAGAIN;
+        }
+
+        /* Copy the video data to the buffer. Skip header packets, as they
+         * contain no data.
+         */
+        if (!is_header) {
+                maxlen = buf->buf.length - buf->buf.bytesused;
+                mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
+                nbytes = min(len, maxlen);
+                memcpy(mem, data, nbytes);
+                buf->buf.bytesused += nbytes;
+
+                if (len > maxlen || buf->buf.bytesused == buf->buf.length) {
+                        uvc_trace(UVC_TRACE_FRAME, "Frame complete "
+                                  "(overflow).\n");
+                        buf->state = UVC_BUF_STATE_DONE;
+                }
+        }
+
+        return 0;
+}
+
+void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
+                struct uvc_buffer *buf)
+{
+        int ret, i;
+
+        for (i = 0; i < urb->number_of_packets; ++i) {
+                if (urb->iso_frame_desc[i].status < 0) {
+                        uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
+                                  "lost (%d).\n",
+                                  urb->iso_frame_desc[i].status);
+                }
+
+                /* Decode the payload packet.
+                 * uvc_video_decode is entered twice when a frame transition
+                 * has been detected because the end of frame can only be
+                 * reliably detected when the first packet of the new frame
+                 * is processed. The first pass detects the transition and
+                 * closes the previous frame's buffer, the second pass
+                 * processes the data of the first payload of the new frame.
+                 */
+                do {
+                        ret = isight_decode(&video->queue, buf,
+                                        urb->transfer_buffer +
+                                        urb->iso_frame_desc[i].offset,
+                                        urb->iso_frame_desc[i].actual_length);
+
+                        if (buf == NULL)
+                                break;
+
+                        if (buf->state == UVC_BUF_STATE_DONE ||
+                            buf->state == UVC_BUF_STATE_ERROR)
+                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                } while (ret == -EAGAIN);
+        }
+}
diff --git a/drivers/media/video/uvc/uvc_queue.c b/drivers/media/video/uvc/uvc_queue.c
new file mode 100644
index 000000000000..0923f0e3b3d4
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_queue.c
@@ -0,0 +1,477 @@
+/*
+ *      uvc_queue.c  --  USB Video Class driver - Buffers management
+ *
+ *      Copyright (C) 2005-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/videodev2.h>
+#include <linux/vmalloc.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+
+#include "uvcvideo.h"
+
+/* ------------------------------------------------------------------------
+ * Video buffers queue management.
+ *
+ * Video queues is initialized by uvc_queue_init(). The function performs
+ * basic initialization of the uvc_video_queue struct and never fails.
+ *
+ * Video buffer allocation and freeing are performed by uvc_alloc_buffers and
+ * uvc_free_buffers respectively. The former acquires the video queue lock,
+ * while the later must be called with the lock held (so that allocation can
+ * free previously allocated buffers). Trying to free buffers that are mapped
+ * to user space will return -EBUSY.
+ *
+ * Video buffers are managed using two queues. However, unlike most USB video
+ * drivers which use an in queue and an out queue, we use a main queue which
+ * holds all queued buffers (both 'empty' and 'done' buffers), and an irq
+ * queue which holds empty buffers. This design (copied from video-buf)
+ * minimizes locking in interrupt, as only one queue is shared between
+ * interrupt and user contexts.
+ *
+ * Use cases
+ * ---------
+ *
+ * Unless stated otherwise, all operations which modify the irq buffers queue
+ * are protected by the irq spinlock.
+ *
+ * 1. The user queues the buffers, starts streaming and dequeues a buffer.
+ *
+ *    The buffers are added to the main and irq queues. Both operations are
+ *    protected by the queue lock, and the latert is protected by the irq
+ *    spinlock as well.
+ *
+ *    The completion handler fetches a buffer from the irq queue and fills it
+ *    with video data. If no buffer is available (irq queue empty), the handler
+ *    returns immediately.
+ *
+ *    When the buffer is full, the completion handler removes it from the irq
+ *    queue, marks it as ready (UVC_BUF_STATE_DONE) and wake its wait queue.
+ *    At that point, any process waiting on the buffer will be woken up. If a
+ *    process tries to dequeue a buffer after it has been marked ready, the
+ *    dequeing will succeed immediately.
+ *
+ * 2. Buffers are queued, user is waiting on a buffer and the device gets
+ *    disconnected.
+ *
+ *    When the device is disconnected, the kernel calls the completion handler
+ *    with an appropriate status code. The handler marks all buffers in the
+ *    irq queue as being erroneous (UVC_BUF_STATE_ERROR) and wakes them up so
+ *    that any process waiting on a buffer gets woken up.
+ *
+ *    Waking up up the first buffer on the irq list is not enough, as the
+ *    process waiting on the buffer might restart the dequeue operation
+ *    immediately.
+ *
+ */
+
+void uvc_queue_init(struct uvc_video_queue *queue)
+{
+        mutex_init(&queue->mutex);
+        spin_lock_init(&queue->irqlock);
+        INIT_LIST_HEAD(&queue->mainqueue);
+        INIT_LIST_HEAD(&queue->irqqueue);
+}
+
+/*
+ * Allocate the video buffers.
+ *
+ * Pages are reserved to make sure they will not be swaped, as they will be
+ * filled in URB completion handler.
+ *
+ * Buffers will be individually mapped, so they must all be page aligned.
+ */
+int uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,
+                unsigned int buflength)
+{
+        unsigned int bufsize = PAGE_ALIGN(buflength);
+        unsigned int i;
+        void *mem = NULL;
+        int ret;
+
+        if (nbuffers > UVC_MAX_VIDEO_BUFFERS)
+                nbuffers = UVC_MAX_VIDEO_BUFFERS;
+
+        mutex_lock(&queue->mutex);
+
+        if ((ret = uvc_free_buffers(queue)) < 0)
+                goto done;
+
+        /* Bail out if no buffers should be allocated. */
+        if (nbuffers == 0)
+                goto done;
+
+        /* Decrement the number of buffers until allocation succeeds. */
+        for (; nbuffers > 0; --nbuffers) {
+                mem = vmalloc_32(nbuffers * bufsize);
+                if (mem != NULL)
+                        break;
+        }
+
+        if (mem == NULL) {
+                ret = -ENOMEM;
+                goto done;
+        }
+
+        for (i = 0; i < nbuffers; ++i) {
+                memset(&queue->buffer[i], 0, sizeof queue->buffer[i]);
+                queue->buffer[i].buf.index = i;
+                queue->buffer[i].buf.m.offset = i * bufsize;
+                queue->buffer[i].buf.length = buflength;
+                queue->buffer[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                queue->buffer[i].buf.sequence = 0;
+                queue->buffer[i].buf.field = V4L2_FIELD_NONE;
+                queue->buffer[i].buf.memory = V4L2_MEMORY_MMAP;
+                queue->buffer[i].buf.flags = 0;
+                init_waitqueue_head(&queue->buffer[i].wait);
+        }
+
+        queue->mem = mem;
+        queue->count = nbuffers;
+        queue->buf_size = bufsize;
+        ret = nbuffers;
+
+done:
+        mutex_unlock(&queue->mutex);
+        return ret;
+}
+
+/*
+ * Free the video buffers.
+ *
+ * This function must be called with the queue lock held.
+ */
+int uvc_free_buffers(struct uvc_video_queue *queue)
+{
+        unsigned int i;
+
+        for (i = 0; i < queue->count; ++i) {
+                if (queue->buffer[i].vma_use_count != 0)
+                        return -EBUSY;
+        }
+
+        if (queue->count) {
+                vfree(queue->mem);
+                queue->count = 0;
+        }
+
+        return 0;
+}
+
+static void __uvc_query_buffer(struct uvc_buffer *buf,
+                struct v4l2_buffer *v4l2_buf)
+{
+        memcpy(v4l2_buf, &buf->buf, sizeof *v4l2_buf);
+
+        if (buf->vma_use_count)
+                v4l2_buf->flags |= V4L2_BUF_FLAG_MAPPED;
+
+        switch (buf->state) {
+        case UVC_BUF_STATE_ERROR:
+        case UVC_BUF_STATE_DONE:
+                v4l2_buf->flags |= V4L2_BUF_FLAG_DONE;
+                break;
+        case UVC_BUF_STATE_QUEUED:
+        case UVC_BUF_STATE_ACTIVE:
+                v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
+                break;
+        case UVC_BUF_STATE_IDLE:
+        default:
+                break;
+        }
+}
+
+int uvc_query_buffer(struct uvc_video_queue *queue,
+                struct v4l2_buffer *v4l2_buf)
+{
+        int ret = 0;
+
+        mutex_lock(&queue->mutex);
+        if (v4l2_buf->index >= queue->count) {
+                ret = -EINVAL;
+                goto done;
+        }
+
+        __uvc_query_buffer(&queue->buffer[v4l2_buf->index], v4l2_buf);
+
+done:
+       mutex_unlock(&queue->mutex);
+       return ret;
+}
+
+/*
+ * Queue a video buffer. Attempting to queue a buffer that has already been
+ * queued will return -EINVAL.
+ */
+int uvc_queue_buffer(struct uvc_video_queue *queue,
+        struct v4l2_buffer *v4l2_buf)
+{
+        struct uvc_buffer *buf;
+        unsigned long flags;
+        int ret = 0;
+
+        uvc_trace(UVC_TRACE_CAPTURE, "Queuing buffer %u.\n", v4l2_buf->index);
+
+        if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+            v4l2_buf->memory != V4L2_MEMORY_MMAP) {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer type (%u) "
+                        "and/or memory (%u).\n", v4l2_buf->type,
+                        v4l2_buf->memory);
+                return -EINVAL;
+        }
+
+        mutex_lock(&queue->mutex);
+        if (v4l2_buf->index >= queue->count)  {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Out of range index.\n");
+                ret = -EINVAL;
+                goto done;
+        }
+
+        buf = &queue->buffer[v4l2_buf->index];
+        if (buf->state != UVC_BUF_STATE_IDLE) {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer state "
+                        "(%u).\n", buf->state);
+                ret = -EINVAL;
+                goto done;
+        }
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        if (queue->flags & UVC_QUEUE_DISCONNECTED) {
+                spin_unlock_irqrestore(&queue->irqlock, flags);
+                ret = -ENODEV;
+                goto done;
+        }
+        buf->state = UVC_BUF_STATE_QUEUED;
+        buf->buf.bytesused = 0;
+        list_add_tail(&buf->stream, &queue->mainqueue);
+        list_add_tail(&buf->queue, &queue->irqqueue);
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+
+done:
+        mutex_unlock(&queue->mutex);
+        return ret;
+}
+
+static int uvc_queue_waiton(struct uvc_buffer *buf, int nonblocking)
+{
+        if (nonblocking) {
+                return (buf->state != UVC_BUF_STATE_QUEUED &&
+                        buf->state != UVC_BUF_STATE_ACTIVE)
+                        ? 0 : -EAGAIN;
+        }
+
+        return wait_event_interruptible(buf->wait,
+                buf->state != UVC_BUF_STATE_QUEUED &&
+                buf->state != UVC_BUF_STATE_ACTIVE);
+}
+
+/*
+ * Dequeue a video buffer. If nonblocking is false, block until a buffer is
+ * available.
+ */
+int uvc_dequeue_buffer(struct uvc_video_queue *queue,
+                struct v4l2_buffer *v4l2_buf, int nonblocking)
+{
+        struct uvc_buffer *buf;
+        int ret = 0;
+
+        if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+            v4l2_buf->memory != V4L2_MEMORY_MMAP) {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer type (%u) "
+                        "and/or memory (%u).\n", v4l2_buf->type,
+                        v4l2_buf->memory);
+                return -EINVAL;
+        }
+
+        mutex_lock(&queue->mutex);
+        if (list_empty(&queue->mainqueue)) {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Empty buffer queue.\n");
+                ret = -EINVAL;
+                goto done;
+        }
+
+        buf = list_first_entry(&queue->mainqueue, struct uvc_buffer, stream);
+        if ((ret = uvc_queue_waiton(buf, nonblocking)) < 0)
+                goto done;
+
+        uvc_trace(UVC_TRACE_CAPTURE, "Dequeuing buffer %u (%u, %u bytes).\n",
+                buf->buf.index, buf->state, buf->buf.bytesused);
+
+        switch (buf->state) {
+        case UVC_BUF_STATE_ERROR:
+                uvc_trace(UVC_TRACE_CAPTURE, "[W] Corrupted data "
+                        "(transmission error).\n");
+                ret = -EIO;
+        case UVC_BUF_STATE_DONE:
+                buf->state = UVC_BUF_STATE_IDLE;
+                break;
+
+        case UVC_BUF_STATE_IDLE:
+        case UVC_BUF_STATE_QUEUED:
+        case UVC_BUF_STATE_ACTIVE:
+        default:
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer state %u "
+                        "(driver bug?).\n", buf->state);
+                ret = -EINVAL;
+                goto done;
+        }
+
+        list_del(&buf->stream);
+        __uvc_query_buffer(buf, v4l2_buf);
+
+done:
+        mutex_unlock(&queue->mutex);
+        return ret;
+}
+
+/*
+ * Poll the video queue.
+ *
+ * This function implements video queue polling and is intended to be used by
+ * the device poll handler.
+ */
+unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
+                poll_table *wait)
+{
+        struct uvc_buffer *buf;
+        unsigned int mask = 0;
+
+        mutex_lock(&queue->mutex);
+        if (list_empty(&queue->mainqueue)) {
+                mask |= POLLERR;
+                goto done;
+        }
+        buf = list_first_entry(&queue->mainqueue, struct uvc_buffer, stream);
+
+        poll_wait(file, &buf->wait, wait);
+        if (buf->state == UVC_BUF_STATE_DONE ||
+            buf->state == UVC_BUF_STATE_ERROR)
+                mask |= POLLIN | POLLRDNORM;
+
+done:
+        mutex_unlock(&queue->mutex);
+        return mask;
+}
+
+/*
+ * Enable or disable the video buffers queue.
+ *
+ * The queue must be enabled before starting video acquisition and must be
+ * disabled after stopping it. This ensures that the video buffers queue
+ * state can be properly initialized before buffers are accessed from the
+ * interrupt handler.
+ *
+ * Enabling the video queue initializes parameters (such as sequence number,
+ * sync pattern, ...). If the queue is already enabled, return -EBUSY.
+ *
+ * Disabling the video queue cancels the queue and removes all buffers from
+ * the main queue.
+ *
+ * This function can't be called from interrupt context. Use
+ * uvc_queue_cancel() instead.
+ */
+int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
+{
+        unsigned int i;
+        int ret = 0;
+
+        mutex_lock(&queue->mutex);
+        if (enable) {
+                if (uvc_queue_streaming(queue)) {
+                        ret = -EBUSY;
+                        goto done;
+                }
+                queue->sequence = 0;
+                queue->flags |= UVC_QUEUE_STREAMING;
+        } else {
+                uvc_queue_cancel(queue, 0);
+                INIT_LIST_HEAD(&queue->mainqueue);
+
+                for (i = 0; i < queue->count; ++i)
+                        queue->buffer[i].state = UVC_BUF_STATE_IDLE;
+
+                queue->flags &= ~UVC_QUEUE_STREAMING;
+        }
+
+done:
+        mutex_unlock(&queue->mutex);
+        return ret;
+}
+
+/*
+ * Cancel the video buffers queue.
+ *
+ * Cancelling the queue marks all buffers on the irq queue as erroneous,
+ * wakes them up and remove them from the queue.
+ *
+ * If the disconnect parameter is set, further calls to uvc_queue_buffer will
+ * fail with -ENODEV.
+ *
+ * This function acquires the irq spinlock and can be called from interrupt
+ * context.
+ */
+void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
+{
+        struct uvc_buffer *buf;
+        unsigned long flags;
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        while (!list_empty(&queue->irqqueue)) {
+                buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
+                                       queue);
+                list_del(&buf->queue);
+                buf->state = UVC_BUF_STATE_ERROR;
+                wake_up(&buf->wait);
+        }
+        /* This must be protected by the irqlock spinlock to avoid race
+         * conditions between uvc_queue_buffer and the disconnection event that
+         * could result in an interruptible wait in uvc_dequeue_buffer. Do not
+         * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
+         * state outside the queue code.
+         */
+        if (disconnect)
+                queue->flags |= UVC_QUEUE_DISCONNECTED;
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+}
+
+struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
+                struct uvc_buffer *buf)
+{
+        struct uvc_buffer *nextbuf;
+        unsigned long flags;
+
+        if ((queue->flags & UVC_QUEUE_DROP_INCOMPLETE) &&
+            buf->buf.length != buf->buf.bytesused) {
+                buf->state = UVC_BUF_STATE_QUEUED;
+                buf->buf.bytesused = 0;
+                return buf;
+        }
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        list_del(&buf->queue);
+        if (!list_empty(&queue->irqqueue))
+                nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
+                                           queue);
+        else
+                nextbuf = NULL;
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+
+        buf->buf.sequence = queue->sequence++;
+        do_gettimeofday(&buf->buf.timestamp);
+
+        wake_up(&buf->wait);
+        return nextbuf;
+}
diff --git a/drivers/media/video/uvc/uvc_status.c b/drivers/media/video/uvc/uvc_status.c
new file mode 100644
index 000000000000..be9084e5eace
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_status.c
@@ -0,0 +1,207 @@
+/*
+ *      uvc_status.c  --  USB Video Class driver - Status endpoint
+ *
+ *      Copyright (C) 2007-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/input.h>
+#include <linux/usb.h>
+#include <linux/usb/input.h>
+
+#include "uvcvideo.h"
+
+/* --------------------------------------------------------------------------
+ * Input device
+ */
+static int uvc_input_init(struct uvc_device *dev)
+{
+        struct usb_device *udev = dev->udev;
+        struct input_dev *input;
+        char *phys = NULL;
+        int ret;
+
+        input = input_allocate_device();
+        if (input == NULL)
+                return -ENOMEM;
+
+        phys = kmalloc(6 + strlen(udev->bus->bus_name) + strlen(udev->devpath),
+                        GFP_KERNEL);
+        if (phys == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
+        sprintf(phys, "usb-%s-%s", udev->bus->bus_name, udev->devpath);
+
+        input->name = dev->name;
+        input->phys = phys;
+        usb_to_input_id(udev, &input->id);
+        input->dev.parent = &dev->intf->dev;
+
+        set_bit(EV_KEY, input->evbit);
+        set_bit(BTN_0, input->keybit);
+
+        if ((ret = input_register_device(input)) < 0)
+                goto error;
+
+        dev->input = input;
+        return 0;
+
+error:
+        input_free_device(input);
+        kfree(phys);
+        return ret;
+}
+
+static void uvc_input_cleanup(struct uvc_device *dev)
+{
+        if (dev->input)
+                input_unregister_device(dev->input);
+}
+
+/* --------------------------------------------------------------------------
+ * Status interrupt endpoint
+ */
+static void uvc_event_streaming(struct uvc_device *dev, __u8 *data, int len)
+{
+        if (len < 3) {
+                uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
+                                "received.\n");
+                return;
+        }
+
+        if (data[2] == 0) {
+                if (len < 4)
+                        return;
+                uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
+                        data[1], data[3] ? "pressed" : "released", len);
+                if (dev->input)
+                        input_report_key(dev->input, BTN_0, data[3]);
+        } else {
+                uvc_trace(UVC_TRACE_STATUS, "Stream %u error event %02x %02x "
+                        "len %d.\n", data[1], data[2], data[3], len);
+        }
+}
+
+static void uvc_event_control(struct uvc_device *dev, __u8 *data, int len)
+{
+        char *attrs[3] = { "value", "info", "failure" };
+
+        if (len < 6 || data[2] != 0 || data[4] > 2) {
+                uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
+                                "received.\n");
+                return;
+        }
+
+        uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
+                data[1], data[3], attrs[data[4]], len);
+}
+
+static void uvc_status_complete(struct urb *urb)
+{
+        struct uvc_device *dev = urb->context;
+        int len, ret;
+
+        switch (urb->status) {
+        case 0:
+                break;
+
+        case -ENOENT:           /* usb_kill_urb() called. */
+        case -ECONNRESET:       /* usb_unlink_urb() called. */
+        case -ESHUTDOWN:        /* The endpoint is being disabled. */
+        case -EPROTO:           /* Device is disconnected (reported by some
+                                 * host controller). */
+                return;
+
+        default:
+                uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
+                        "completion handler.\n", urb->status);
+                return;
+        }
+
+        len = urb->actual_length;
+        if (len > 0) {
+                switch (dev->status[0] & 0x0f) {
+                case UVC_STATUS_TYPE_CONTROL:
+                        uvc_event_control(dev, dev->status, len);
+                        break;
+
+                case UVC_STATUS_TYPE_STREAMING:
+                        uvc_event_streaming(dev, dev->status, len);
+                        break;
+
+                default:
+                        uvc_printk(KERN_INFO, "unknown event type %u.\n",
+                                dev->status[0]);
+                        break;
+                }
+        }
+
+        /* Resubmit the URB. */
+        urb->interval = dev->int_ep->desc.bInterval;
+        if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
+                uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
+                        ret);
+        }
+}
+
+int uvc_status_init(struct uvc_device *dev)
+{
+        struct usb_host_endpoint *ep = dev->int_ep;
+        unsigned int pipe;
+        int interval;
+
+        if (ep == NULL)
+                return 0;
+
+        uvc_input_init(dev);
+
+        dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (dev->int_urb == NULL)
+                return -ENOMEM;
+
+        pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);
+
+        /* For high-speed interrupt endpoints, the bInterval value is used as
+         * an exponent of two. Some developers forgot about it.
+         */
+        interval = ep->desc.bInterval;
+        if (interval > 16 && dev->udev->speed == USB_SPEED_HIGH &&
+            (dev->quirks & UVC_QUIRK_STATUS_INTERVAL))
+                interval = fls(interval) - 1;
+
+        usb_fill_int_urb(dev->int_urb, dev->udev, pipe,
+                dev->status, sizeof dev->status, uvc_status_complete,
+                dev, interval);
+
+        return usb_submit_urb(dev->int_urb, GFP_KERNEL);
+}
+
+void uvc_status_cleanup(struct uvc_device *dev)
+{
+        usb_kill_urb(dev->int_urb);
+        usb_free_urb(dev->int_urb);
+        uvc_input_cleanup(dev);
+}
+
+int uvc_status_suspend(struct uvc_device *dev)
+{
+        usb_kill_urb(dev->int_urb);
+        return 0;
+}
+
+int uvc_status_resume(struct uvc_device *dev)
+{
+        if (dev->int_urb == NULL)
+                return 0;
+
+        return usb_submit_urb(dev->int_urb, GFP_KERNEL);
+}
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
new file mode 100644
index 000000000000..2e0a66575bb4
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -0,0 +1,1105 @@
+/*
+ *      uvc_v4l2.c  --  USB Video Class driver - V4L2 API
+ *
+ *      Copyright (C) 2005-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/videodev2.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+
+#include <media/v4l2-common.h>
+
+#include "uvcvideo.h"
+
+/* ------------------------------------------------------------------------
+ * V4L2 interface
+ */
+
+/*
+ * Mapping V4L2 controls to UVC controls can be straighforward if done well.
+ * Most of the UVC controls exist in V4L2, and can be mapped directly. Some
+ * must be grouped (for instance the Red Balance, Blue Balance and Do White
+ * Balance V4L2 controls use the White Balance Component UVC control) or
+ * otherwise translated. The approach we take here is to use a translation
+ * table for the controls which can be mapped directly, and handle the others
+ * manually.
+ */
+static int uvc_v4l2_query_menu(struct uvc_video_device *video,
+        struct v4l2_querymenu *query_menu)
+{
+        struct uvc_menu_info *menu_info;
+        struct uvc_control_mapping *mapping;
+        struct uvc_control *ctrl;
+
+        ctrl = uvc_find_control(video, query_menu->id, &mapping);
+        if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU)
+                return -EINVAL;
+
+        if (query_menu->index >= mapping->menu_count)
+                return -EINVAL;
+
+        menu_info = &mapping->menu_info[query_menu->index];
+        strncpy(query_menu->name, menu_info->name, 32);
+        return 0;
+}
+
+/*
+ * Find the frame interval closest to the requested frame interval for the
+ * given frame format and size. This should be done by the device as part of
+ * the Video Probe and Commit negotiation, but some hardware don't implement
+ * that feature.
+ */
+static __u32 uvc_try_frame_interval(struct uvc_frame *frame, __u32 interval)
+{
+        unsigned int i;
+
+        if (frame->bFrameIntervalType) {
+                __u32 best = -1, dist;
+
+                for (i = 0; i < frame->bFrameIntervalType; ++i) {
+                        dist = interval > frame->dwFrameInterval[i]
+                             ? interval - frame->dwFrameInterval[i]
+                             : frame->dwFrameInterval[i] - interval;
+
+                        if (dist > best)
+                                break;
+
+                        best = dist;
+                }
+
+                interval = frame->dwFrameInterval[i-1];
+        } else {
+                const __u32 min = frame->dwFrameInterval[0];
+                const __u32 max = frame->dwFrameInterval[1];
+                const __u32 step = frame->dwFrameInterval[2];
+
+                interval = min + (interval - min + step/2) / step * step;
+                if (interval > max)
+                        interval = max;
+        }
+
+        return interval;
+}
+
+static int uvc_v4l2_try_format(struct uvc_video_device *video,
+        struct v4l2_format *fmt, struct uvc_streaming_control *probe,
+        struct uvc_format **uvc_format, struct uvc_frame **uvc_frame)
+{
+        struct uvc_format *format = NULL;
+        struct uvc_frame *frame = NULL;
+        __u16 rw, rh;
+        unsigned int d, maxd;
+        unsigned int i;
+        __u32 interval;
+        int ret = 0;
+        __u8 *fcc;
+
+        if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        fcc = (__u8 *)&fmt->fmt.pix.pixelformat;
+        uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
+                        fmt->fmt.pix.pixelformat,
+                        fcc[0], fcc[1], fcc[2], fcc[3],
+                        fmt->fmt.pix.width, fmt->fmt.pix.height);
+
+        /* Check if the hardware supports the requested format. */
+        for (i = 0; i < video->streaming->nformats; ++i) {
+                format = &video->streaming->format[i];
+                if (format->fcc == fmt->fmt.pix.pixelformat)
+                        break;
+        }
+
+        if (format == NULL || format->fcc != fmt->fmt.pix.pixelformat) {
+                uvc_trace(UVC_TRACE_FORMAT, "Unsupported format 0x%08x.\n",
+                                fmt->fmt.pix.pixelformat);
+                return -EINVAL;
+        }
+
+        /* Find the closest image size. The distance between image sizes is
+         * the size in pixels of the non-overlapping regions between the
+         * requested size and the frame-specified size.
+         */
+        rw = fmt->fmt.pix.width;
+        rh = fmt->fmt.pix.height;
+        maxd = (unsigned int)-1;
+
+        for (i = 0; i < format->nframes; ++i) {
+                __u16 w = format->frame[i].wWidth;
+                __u16 h = format->frame[i].wHeight;
+
+                d = min(w, rw) * min(h, rh);
+                d = w*h + rw*rh - 2*d;
+                if (d < maxd) {
+                        maxd = d;
+                        frame = &format->frame[i];
+                }
+
+                if (maxd == 0)
+                        break;
+        }
+
+        if (frame == NULL) {
+                uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.\n",
+                                fmt->fmt.pix.width, fmt->fmt.pix.height);
+                return -EINVAL;
+        }
+
+        /* Use the default frame interval. */
+        interval = frame->dwDefaultFrameInterval;
+        uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us "
+                "(%u.%u fps).\n", interval/10, interval%10, 10000000/interval,
+                (100000000/interval)%10);
+
+        /* Set the format index, frame index and frame interval. */
+        memset(probe, 0, sizeof *probe);
+        probe->bmHint = 1;      /* dwFrameInterval */
+        probe->bFormatIndex = format->index;
+        probe->bFrameIndex = frame->bFrameIndex;
+        probe->dwFrameInterval = uvc_try_frame_interval(frame, interval);
+        /* Some webcams stall the probe control set request when the
+         * dwMaxVideoFrameSize field is set to zero. The UVC specification
+         * clearly states that the field is read-only from the host, so this
+         * is a webcam bug. Set dwMaxVideoFrameSize to the value reported by
+         * the webcam to work around the problem.
+         *
+         * The workaround could probably be enabled for all webcams, so the
+         * quirk can be removed if needed. It's currently useful to detect
+         * webcam bugs and fix them before they hit the market (providing
+         * developers test their webcams with the Linux driver as well as with
+         * the Windows driver).
+         */
+        if (video->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
+                probe->dwMaxVideoFrameSize =
+                        video->streaming->ctrl.dwMaxVideoFrameSize;
+
+        /* Probe the device */
+        if ((ret = uvc_probe_video(video, probe)) < 0)
+                goto done;
+
+        fmt->fmt.pix.width = frame->wWidth;
+        fmt->fmt.pix.height = frame->wHeight;
+        fmt->fmt.pix.field = V4L2_FIELD_NONE;
+        fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
+        fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize;
+        fmt->fmt.pix.colorspace = format->colorspace;
+        fmt->fmt.pix.priv = 0;
+
+        if (uvc_format != NULL)
+                *uvc_format = format;
+        if (uvc_frame != NULL)
+                *uvc_frame = frame;
+
+done:
+        return ret;
+}
+
+static int uvc_v4l2_get_format(struct uvc_video_device *video,
+        struct v4l2_format *fmt)
+{
+        struct uvc_format *format = video->streaming->cur_format;
+        struct uvc_frame *frame = video->streaming->cur_frame;
+
+        if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        if (format == NULL || frame == NULL)
+                return -EINVAL;
+
+        fmt->fmt.pix.pixelformat = format->fcc;
+        fmt->fmt.pix.width = frame->wWidth;
+        fmt->fmt.pix.height = frame->wHeight;
+        fmt->fmt.pix.field = V4L2_FIELD_NONE;
+        fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
+        fmt->fmt.pix.sizeimage = video->streaming->ctrl.dwMaxVideoFrameSize;
+        fmt->fmt.pix.colorspace = format->colorspace;
+        fmt->fmt.pix.priv = 0;
+
+        return 0;
+}
+
+static int uvc_v4l2_set_format(struct uvc_video_device *video,
+        struct v4l2_format *fmt)
+{
+        struct uvc_streaming_control probe;
+        struct uvc_format *format;
+        struct uvc_frame *frame;
+        int ret;
+
+        if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        if (uvc_queue_streaming(&video->queue))
+                return -EBUSY;
+
+        ret = uvc_v4l2_try_format(video, fmt, &probe, &format, &frame);
+        if (ret < 0)
+                return ret;
+
+        if ((ret = uvc_set_video_ctrl(video, &probe, 0)) < 0)
+                return ret;
+
+        memcpy(&video->streaming->ctrl, &probe, sizeof probe);
+        video->streaming->cur_format = format;
+        video->streaming->cur_frame = frame;
+
+        return 0;
+}
+
+static int uvc_v4l2_get_streamparm(struct uvc_video_device *video,
+                struct v4l2_streamparm *parm)
+{
+        uint32_t numerator, denominator;
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        numerator = video->streaming->ctrl.dwFrameInterval;
+        denominator = 10000000;
+        uvc_simplify_fraction(&numerator, &denominator, 8, 333);
+
+        memset(parm, 0, sizeof *parm);
+        parm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
+        parm->parm.capture.capturemode = 0;
+        parm->parm.capture.timeperframe.numerator = numerator;
+        parm->parm.capture.timeperframe.denominator = denominator;
+        parm->parm.capture.extendedmode = 0;
+        parm->parm.capture.readbuffers = 0;
+
+        return 0;
+}
+
+static int uvc_v4l2_set_streamparm(struct uvc_video_device *video,
+                struct v4l2_streamparm *parm)
+{
+        struct uvc_frame *frame = video->streaming->cur_frame;
+        struct uvc_streaming_control probe;
+        uint32_t interval;
+        int ret;
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        if (uvc_queue_streaming(&video->queue))
+                return -EBUSY;
+
+        memcpy(&probe, &video->streaming->ctrl, sizeof probe);
+        interval = uvc_fraction_to_interval(
+                        parm->parm.capture.timeperframe.numerator,
+                        parm->parm.capture.timeperframe.denominator);
+
+        uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n",
+                        parm->parm.capture.timeperframe.numerator,
+                        parm->parm.capture.timeperframe.denominator,
+                        interval);
+        probe.dwFrameInterval = uvc_try_frame_interval(frame, interval);
+
+        /* Probe the device with the new settings. */
+        if ((ret = uvc_probe_video(video, &probe)) < 0)
+                return ret;
+
+        /* Commit the new settings. */
+        if ((ret = uvc_set_video_ctrl(video, &probe, 0)) < 0)
+                return ret;
+
+        memcpy(&video->streaming->ctrl, &probe, sizeof probe);
+
+        /* Return the actual frame period. */
+        parm->parm.capture.timeperframe.numerator = probe.dwFrameInterval;
+        parm->parm.capture.timeperframe.denominator = 10000000;
+        uvc_simplify_fraction(&parm->parm.capture.timeperframe.numerator,
+                                &parm->parm.capture.timeperframe.denominator,
+                                8, 333);
+
+        return 0;
+}
+
+/* ------------------------------------------------------------------------
+ * Privilege management
+ */
+
+/*
+ * Privilege management is the multiple-open implementation basis. The current
+ * implementation is completely transparent for the end-user and doesn't
+ * require explicit use of the VIDIOC_G_PRIORITY and VIDIOC_S_PRIORITY ioctls.
+ * Those ioctls enable finer control on the device (by making possible for a
+ * user to request exclusive access to a device), but are not mature yet.
+ * Switching to the V4L2 priority mechanism might be considered in the future
+ * if this situation changes.
+ *
+ * Each open instance of a UVC device can either be in a privileged or
+ * unprivileged state. Only a single instance can be in a privileged state at
+ * a given time. Trying to perform an operation which requires privileges will
+ * automatically acquire the required privileges if possible, or return -EBUSY
+ * otherwise. Privileges are dismissed when closing the instance.
+ *
+ * Operations which require privileges are:
+ *
+ * - VIDIOC_S_INPUT
+ * - VIDIOC_S_PARM
+ * - VIDIOC_S_FMT
+ * - VIDIOC_TRY_FMT
+ * - VIDIOC_REQBUFS
+ */
+static int uvc_acquire_privileges(struct uvc_fh *handle)
+{
+        int ret = 0;
+
+        /* Always succeed if the handle is already privileged. */
+        if (handle->state == UVC_HANDLE_ACTIVE)
+                return 0;
+
+        /* Check if the device already has a privileged handle. */
+        mutex_lock(&uvc_driver.open_mutex);
+        if (atomic_inc_return(&handle->device->active) != 1) {
+                atomic_dec(&handle->device->active);
+                ret = -EBUSY;
+                goto done;
+        }
+
+        handle->state = UVC_HANDLE_ACTIVE;
+
+done:
+        mutex_unlock(&uvc_driver.open_mutex);
+        return ret;
+}
+
+static void uvc_dismiss_privileges(struct uvc_fh *handle)
+{
+        if (handle->state == UVC_HANDLE_ACTIVE)
+                atomic_dec(&handle->device->active);
+
+        handle->state = UVC_HANDLE_PASSIVE;
+}
+
+static int uvc_has_privileges(struct uvc_fh *handle)
+{
+        return handle->state == UVC_HANDLE_ACTIVE;
+}
+
+/* ------------------------------------------------------------------------
+ * V4L2 file operations
+ */
+
+static int uvc_v4l2_open(struct inode *inode, struct file *file)
+{
+        struct video_device *vdev;
+        struct uvc_video_device *video;
+        struct uvc_fh *handle;
+        int ret = 0;
+
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
+        mutex_lock(&uvc_driver.open_mutex);
+        vdev = video_devdata(file);
+        video = video_get_drvdata(vdev);
+
+        if (video->dev->state & UVC_DEV_DISCONNECTED) {
+                ret = -ENODEV;
+                goto done;
+        }
+
+        ret = usb_autopm_get_interface(video->dev->intf);
+        if (ret < 0)
+                goto done;
+
+        /* Create the device handle. */
+        handle = kzalloc(sizeof *handle, GFP_KERNEL);
+        if (handle == NULL) {
+                usb_autopm_put_interface(video->dev->intf);
+                ret = -ENOMEM;
+                goto done;
+        }
+
+        handle->device = video;
+        handle->state = UVC_HANDLE_PASSIVE;
+        file->private_data = handle;
+
+        kref_get(&video->dev->kref);
+
+done:
+        mutex_unlock(&uvc_driver.open_mutex);
+        return ret;
+}
+
+static int uvc_v4l2_release(struct inode *inode, struct file *file)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_video_device *video = video_get_drvdata(vdev);
+        struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
+
+        /* Only free resources if this is a privileged handle. */
+        if (uvc_has_privileges(handle)) {
+                uvc_video_enable(video, 0);
+
+                mutex_lock(&video->queue.mutex);
+                if (uvc_free_buffers(&video->queue) < 0)
+                        uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to "
+                                        "free buffers.\n");
+                mutex_unlock(&video->queue.mutex);
+        }
+
+        /* Release the file handle. */
+        uvc_dismiss_privileges(handle);
+        kfree(handle);
+        file->private_data = NULL;
+
+        usb_autopm_put_interface(video->dev->intf);
+        kref_put(&video->dev->kref, uvc_delete);
+        return 0;
+}
+
+static int uvc_v4l2_do_ioctl(struct inode *inode, struct file *file,
+                     unsigned int cmd, void *arg)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_video_device *video = video_get_drvdata(vdev);
+        struct uvc_fh *handle = (struct uvc_fh *)file->private_data;
+        int ret = 0;
+
+        if (uvc_trace_param & UVC_TRACE_IOCTL)
+                v4l_printk_ioctl(cmd);
+
+        switch (cmd) {
+        /* Query capabilities */
+        case VIDIOC_QUERYCAP:
+        {
+                struct v4l2_capability *cap = arg;
+
+                memset(cap, 0, sizeof *cap);
+                strncpy(cap->driver, "uvcvideo", sizeof cap->driver);
+                strncpy(cap->card, vdev->name, 32);
+                strncpy(cap->bus_info, video->dev->udev->bus->bus_name,
+                        sizeof cap->bus_info);
+                cap->version = DRIVER_VERSION_NUMBER;
+                cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
+                                  | V4L2_CAP_STREAMING;
+                break;
+        }
+
+        /* Get, Set & Query control */
+        case VIDIOC_QUERYCTRL:
+                return uvc_query_v4l2_ctrl(video, arg);
+
+        case VIDIOC_G_CTRL:
+        {
+                struct v4l2_control *ctrl = arg;
+                struct v4l2_ext_control xctrl;
+
+                memset(&xctrl, 0, sizeof xctrl);
+                xctrl.id = ctrl->id;
+
+                uvc_ctrl_begin(video);
+                ret = uvc_ctrl_get(video, &xctrl);
+                uvc_ctrl_rollback(video);
+                if (ret >= 0)
+                        ctrl->value = xctrl.value;
+                break;
+        }
+
+        case VIDIOC_S_CTRL:
+        {
+                struct v4l2_control *ctrl = arg;
+                struct v4l2_ext_control xctrl;
+
+                memset(&xctrl, 0, sizeof xctrl);
+                xctrl.id = ctrl->id;
+                xctrl.value = ctrl->value;
+
+                uvc_ctrl_begin(video);
+                ret = uvc_ctrl_set(video, &xctrl);
+                if (ret < 0) {
+                        uvc_ctrl_rollback(video);
+                        return ret;
+                }
+                ret = uvc_ctrl_commit(video);
+                break;
+        }
+
+        case VIDIOC_QUERYMENU:
+                return uvc_v4l2_query_menu(video, arg);
+
+        case VIDIOC_G_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *ctrls = arg;
+                struct v4l2_ext_control *ctrl = ctrls->controls;
+                unsigned int i;
+
+                uvc_ctrl_begin(video);
+                for (i = 0; i < ctrls->count; ++ctrl, ++i) {
+                        ret = uvc_ctrl_get(video, ctrl);
+                        if (ret < 0) {
+                                uvc_ctrl_rollback(video);
+                                ctrls->error_idx = i;
+                                return ret;
+                        }
+                }
+                ctrls->error_idx = 0;
+                ret = uvc_ctrl_rollback(video);
+                break;
+        }
+
+        case VIDIOC_S_EXT_CTRLS:
+        case VIDIOC_TRY_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *ctrls = arg;
+                struct v4l2_ext_control *ctrl = ctrls->controls;
+                unsigned int i;
+
+                ret = uvc_ctrl_begin(video);
+                if (ret < 0)
+                        return ret;
+
+                for (i = 0; i < ctrls->count; ++ctrl, ++i) {
+                        ret = uvc_ctrl_set(video, ctrl);
+                        if (ret < 0) {
+                                uvc_ctrl_rollback(video);
+                                ctrls->error_idx = i;
+                                return ret;
+                        }
+                }
+
+                ctrls->error_idx = 0;
+
+                if (cmd == VIDIOC_S_EXT_CTRLS)
+                        ret = uvc_ctrl_commit(video);
+                else
+                        ret = uvc_ctrl_rollback(video);
+                break;
+        }
+
+        /* Get, Set & Enum input */
+        case VIDIOC_ENUMINPUT:
+        {
+                const struct uvc_entity *selector = video->selector;
+                struct v4l2_input *input = arg;
+                struct uvc_entity *iterm = NULL;
+                u32 index = input->index;
+                int pin = 0;
+
+                if (selector == NULL ||
+                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                        if (index != 0)
+                                return -EINVAL;
+                        iterm = list_first_entry(&video->iterms,
+                                        struct uvc_entity, chain);
+                        pin = iterm->id;
+                } else if (pin < selector->selector.bNrInPins) {
+                        pin = selector->selector.baSourceID[index];
+                        list_for_each_entry(iterm, video->iterms.next, chain) {
+                                if (iterm->id == pin)
+                                        break;
+                        }
+                }
+
+                if (iterm == NULL || iterm->id != pin)
+                        return -EINVAL;
+
+                memset(input, 0, sizeof *input);
+                input->index = index;
+                strncpy(input->name, iterm->name, sizeof input->name);
+                if (UVC_ENTITY_TYPE(iterm) == ITT_CAMERA)
+                        input->type = V4L2_INPUT_TYPE_CAMERA;
+                break;
+        }
+
+        case VIDIOC_G_INPUT:
+        {
+                u8 input;
+
+                if (video->selector == NULL ||
+                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                        *(int *)arg = 0;
+                        break;
+                }
+
+                ret = uvc_query_ctrl(video->dev, GET_CUR, video->selector->id,
+                        video->dev->intfnum, SU_INPUT_SELECT_CONTROL,
+                        &input, 1);
+                if (ret < 0)
+                        return ret;
+
+                *(int *)arg = input - 1;
+                break;
+        }
+
+        case VIDIOC_S_INPUT:
+        {
+                u8 input = *(u32 *)arg + 1;
+
+                if ((ret = uvc_acquire_privileges(handle)) < 0)
+                        return ret;
+
+                if (video->selector == NULL ||
+                    (video->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {
+                        if (input != 1)
+                                return -EINVAL;
+                        break;
+                }
+
+                if (input > video->selector->selector.bNrInPins)
+                        return -EINVAL;
+
+                return uvc_query_ctrl(video->dev, SET_CUR, video->selector->id,
+                        video->dev->intfnum, SU_INPUT_SELECT_CONTROL,
+                        &input, 1);
+        }
+
+        /* Try, Get, Set & Enum format */
+        case VIDIOC_ENUM_FMT:
+        {
+                struct v4l2_fmtdesc *fmt = arg;
+                struct uvc_format *format;
+
+                if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+                    fmt->index >= video->streaming->nformats)
+                        return -EINVAL;
+
+                format = &video->streaming->format[fmt->index];
+                fmt->flags = 0;
+                if (format->flags & UVC_FMT_FLAG_COMPRESSED)
+                        fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
+                strncpy(fmt->description, format->name,
+                        sizeof fmt->description);
+                fmt->description[sizeof fmt->description - 1] = 0;
+                fmt->pixelformat = format->fcc;
+                break;
+        }
+
+        case VIDIOC_TRY_FMT:
+        {
+                struct uvc_streaming_control probe;
+
+                if ((ret = uvc_acquire_privileges(handle)) < 0)
+                        return ret;
+
+                return uvc_v4l2_try_format(video, arg, &probe, NULL, NULL);
+        }
+
+        case VIDIOC_S_FMT:
+                if ((ret = uvc_acquire_privileges(handle)) < 0)
+                        return ret;
+
+                return uvc_v4l2_set_format(video, arg);
+
+        case VIDIOC_G_FMT:
+                return uvc_v4l2_get_format(video, arg);
+
+        /* Frame size enumeration */
+        case VIDIOC_ENUM_FRAMESIZES:
+        {
+                struct v4l2_frmsizeenum *fsize = arg;
+                struct uvc_format *format = NULL;
+                struct uvc_frame *frame;
+                int i;
+
+                /* Look for the given pixel format */
+                for (i = 0; i < video->streaming->nformats; i++) {
+                        if (video->streaming->format[i].fcc ==
+                                        fsize->pixel_format) {
+                                format = &video->streaming->format[i];
+                                break;
+                        }
+                }
+                if (format == NULL)
+                        return -EINVAL;
+
+                if (fsize->index >= format->nframes)
+                        return -EINVAL;
+
+                frame = &format->frame[fsize->index];
+                fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+                fsize->discrete.width = frame->wWidth;
+                fsize->discrete.height = frame->wHeight;
+                break;
+        }
+
+        /* Frame interval enumeration */
+        case VIDIOC_ENUM_FRAMEINTERVALS:
+        {
+                struct v4l2_frmivalenum *fival = arg;
+                struct uvc_format *format = NULL;
+                struct uvc_frame *frame = NULL;
+                int i;
+
+                /* Look for the given pixel format and frame size */
+                for (i = 0; i < video->streaming->nformats; i++) {
+                        if (video->streaming->format[i].fcc ==
+                                        fival->pixel_format) {
+                                format = &video->streaming->format[i];
+                                break;
+                        }
+                }
+                if (format == NULL)
+                        return -EINVAL;
+
+                for (i = 0; i < format->nframes; i++) {
+                        if (format->frame[i].wWidth == fival->width &&
+                            format->frame[i].wHeight == fival->height) {
+                                frame = &format->frame[i];
+                                break;
+                        }
+                }
+                if (frame == NULL)
+                        return -EINVAL;
+
+                if (frame->bFrameIntervalType) {
+                        if (fival->index >= frame->bFrameIntervalType)
+                                return -EINVAL;
+
+                        fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
+                        fival->discrete.numerator =
+                                frame->dwFrameInterval[fival->index];
+                        fival->discrete.denominator = 10000000;
+                        uvc_simplify_fraction(&fival->discrete.numerator,
+                                &fival->discrete.denominator, 8, 333);
+                } else {
+                        fival->type = V4L2_FRMIVAL_TYPE_STEPWISE;
+                        fival->stepwise.min.numerator =
+                                frame->dwFrameInterval[0];
+                        fival->stepwise.min.denominator = 10000000;
+                        fival->stepwise.max.numerator =
+                                frame->dwFrameInterval[1];
+                        fival->stepwise.max.denominator = 10000000;
+                        fival->stepwise.step.numerator =
+                                frame->dwFrameInterval[2];
+                        fival->stepwise.step.denominator = 10000000;
+                        uvc_simplify_fraction(&fival->stepwise.min.numerator,
+                                &fival->stepwise.min.denominator, 8, 333);
+                        uvc_simplify_fraction(&fival->stepwise.max.numerator,
+                                &fival->stepwise.max.denominator, 8, 333);
+                        uvc_simplify_fraction(&fival->stepwise.step.numerator,
+                                &fival->stepwise.step.denominator, 8, 333);
+                }
+                break;
+        }
+
+        /* Get & Set streaming parameters */
+        case VIDIOC_G_PARM:
+                return uvc_v4l2_get_streamparm(video, arg);
+
+        case VIDIOC_S_PARM:
+                if ((ret = uvc_acquire_privileges(handle)) < 0)
+                        return ret;
+
+                return uvc_v4l2_set_streamparm(video, arg);
+
+        /* Cropping and scaling */
+        case VIDIOC_CROPCAP:
+        {
+                struct v4l2_cropcap *ccap = arg;
+                struct uvc_frame *frame = video->streaming->cur_frame;
+
+                if (ccap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                        return -EINVAL;
+
+                ccap->bounds.left = 0;
+                ccap->bounds.top = 0;
+                ccap->bounds.width = frame->wWidth;
+                ccap->bounds.height = frame->wHeight;
+
+                ccap->defrect = ccap->bounds;
+
+                ccap->pixelaspect.numerator = 1;
+                ccap->pixelaspect.denominator = 1;
+                break;
+        }
+
+        case VIDIOC_G_CROP:
+        case VIDIOC_S_CROP:
+                return -EINVAL;
+
+        /* Buffers & streaming */
+        case VIDIOC_REQBUFS:
+        {
+                struct v4l2_requestbuffers *rb = arg;
+                unsigned int bufsize =
+                        video->streaming->ctrl.dwMaxVideoFrameSize;
+
+                if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+                    rb->memory != V4L2_MEMORY_MMAP)
+                        return -EINVAL;
+
+                if ((ret = uvc_acquire_privileges(handle)) < 0)
+                        return ret;
+
+                ret = uvc_alloc_buffers(&video->queue, rb->count, bufsize);
+                if (ret < 0)
+                        return ret;
+
+                if (!(video->streaming->cur_format->flags &
+                    UVC_FMT_FLAG_COMPRESSED))
+                        video->queue.flags |= UVC_QUEUE_DROP_INCOMPLETE;
+
+                rb->count = ret;
+                ret = 0;
+                break;
+        }
+
+        case VIDIOC_QUERYBUF:
+        {
+                struct v4l2_buffer *buf = arg;
+
+                if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                        return -EINVAL;
+
+                if (!uvc_has_privileges(handle))
+                        return -EBUSY;
+
+                return uvc_query_buffer(&video->queue, buf);
+        }
+
+        case VIDIOC_QBUF:
+                if (!uvc_has_privileges(handle))
+                        return -EBUSY;
+
+                return uvc_queue_buffer(&video->queue, arg);
+
+        case VIDIOC_DQBUF:
+                if (!uvc_has_privileges(handle))
+                        return -EBUSY;
+
+                return uvc_dequeue_buffer(&video->queue, arg,
+                        file->f_flags & O_NONBLOCK);
+
+        case VIDIOC_STREAMON:
+        {
+                int *type = arg;
+
+                if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                        return -EINVAL;
+
+                if (!uvc_has_privileges(handle))
+                        return -EBUSY;
+
+                if ((ret = uvc_video_enable(video, 1)) < 0)
+                        return ret;
+                break;
+        }
+
+        case VIDIOC_STREAMOFF:
+        {
+                int *type = arg;
+
+                if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                        return -EINVAL;
+
+                if (!uvc_has_privileges(handle))
+                        return -EBUSY;
+
+                return uvc_video_enable(video, 0);
+        }
+
+        /* Analog video standards make no sense for digital cameras. */
+        case VIDIOC_ENUMSTD:
+        case VIDIOC_QUERYSTD:
+        case VIDIOC_G_STD:
+        case VIDIOC_S_STD:
+
+        case VIDIOC_OVERLAY:
+
+        case VIDIOC_ENUMAUDIO:
+        case VIDIOC_ENUMAUDOUT:
+
+        case VIDIOC_ENUMOUTPUT:
+                uvc_trace(UVC_TRACE_IOCTL, "Unsupported ioctl 0x%08x\n", cmd);
+                return -EINVAL;
+
+        /* Dynamic controls. */
+        case UVCIOC_CTRL_ADD:
+        {
+                struct uvc_xu_control_info *xinfo = arg;
+                struct uvc_control_info *info;
+
+                if (!capable(CAP_SYS_ADMIN))
+                        return -EPERM;
+
+                info = kmalloc(sizeof *info, GFP_KERNEL);
+                if (info == NULL)
+                        return -ENOMEM;
+
+                memcpy(info->entity, xinfo->entity, sizeof info->entity);
+                info->index = xinfo->index;
+                info->selector = xinfo->selector;
+                info->size = xinfo->size;
+                info->flags = xinfo->flags;
+
+                info->flags |= UVC_CONTROL_GET_MIN | UVC_CONTROL_GET_MAX |
+                                UVC_CONTROL_GET_RES | UVC_CONTROL_GET_DEF;
+
+                ret = uvc_ctrl_add_info(info);
+                if (ret < 0)
+                        kfree(info);
+                break;
+        }
+
+        case UVCIOC_CTRL_MAP:
+        {
+                struct uvc_xu_control_mapping *xmap = arg;
+                struct uvc_control_mapping *map;
+
+                if (!capable(CAP_SYS_ADMIN))
+                        return -EPERM;
+
+                map = kmalloc(sizeof *map, GFP_KERNEL);
+                if (map == NULL)
+                        return -ENOMEM;
+
+                map->id = xmap->id;
+                memcpy(map->name, xmap->name, sizeof map->name);
+                memcpy(map->entity, xmap->entity, sizeof map->entity);
+                map->selector = xmap->selector;
+                map->size = xmap->size;
+                map->offset = xmap->offset;
+                map->v4l2_type = xmap->v4l2_type;
+                map->data_type = xmap->data_type;
+
+                ret = uvc_ctrl_add_mapping(map);
+                if (ret < 0)
+                        kfree(map);
+                break;
+        }
+
+        case UVCIOC_CTRL_GET:
+                return uvc_xu_ctrl_query(video, arg, 0);
+
+        case UVCIOC_CTRL_SET:
+                return uvc_xu_ctrl_query(video, arg, 1);
+
+        default:
+                if ((ret = v4l_compat_translate_ioctl(inode, file, cmd, arg,
+                        uvc_v4l2_do_ioctl)) == -ENOIOCTLCMD)
+                        uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n",
+                                  cmd);
+                return ret;
+        }
+
+        return ret;
+}
+
+static int uvc_v4l2_ioctl(struct inode *inode, struct file *file,
+                     unsigned int cmd, unsigned long arg)
+{
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_ioctl\n");
+        return video_usercopy(inode, file, cmd, arg, uvc_v4l2_do_ioctl);
+}
+
+static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
+                    size_t count, loff_t *ppos)
+{
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_read: not implemented.\n");
+        return -ENODEV;
+}
+
+/*
+ * VMA operations.
+ */
+static void uvc_vm_open(struct vm_area_struct *vma)
+{
+        struct uvc_buffer *buffer = vma->vm_private_data;
+        buffer->vma_use_count++;
+}
+
+static void uvc_vm_close(struct vm_area_struct *vma)
+{
+        struct uvc_buffer *buffer = vma->vm_private_data;
+        buffer->vma_use_count--;
+}
+
+static struct vm_operations_struct uvc_vm_ops = {
+        .open           = uvc_vm_open,
+        .close          = uvc_vm_close,
+};
+
+static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_video_device *video = video_get_drvdata(vdev);
+        struct uvc_buffer *buffer;
+        struct page *page;
+        unsigned long addr, start, size;
+        unsigned int i;
+        int ret = 0;
+
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n");
+
+        start = vma->vm_start;
+        size = vma->vm_end - vma->vm_start;
+
+        mutex_lock(&video->queue.mutex);
+
+        for (i = 0; i < video->queue.count; ++i) {
+                buffer = &video->queue.buffer[i];
+                if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
+                        break;
+        }
+
+        if (i == video->queue.count || size != video->queue.buf_size) {
+                ret = -EINVAL;
+                goto done;
+        }
+
+        /*
+         * VM_IO marks the area as being an mmaped region for I/O to a
+         * device. It also prevents the region from being core dumped.
+         */
+        vma->vm_flags |= VM_IO;
+
+        addr = (unsigned long)video->queue.mem + buffer->buf.m.offset;
+        while (size > 0) {
+                page = vmalloc_to_page((void *)addr);
+                if ((ret = vm_insert_page(vma, start, page)) < 0)
+                        goto done;
+
+                start += PAGE_SIZE;
+                addr += PAGE_SIZE;
+                size -= PAGE_SIZE;
+        }
+
+        vma->vm_ops = &uvc_vm_ops;
+        vma->vm_private_data = buffer;
+        uvc_vm_open(vma);
+
+done:
+        mutex_unlock(&video->queue.mutex);
+        return ret;
+}
+
+static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_video_device *video = video_get_drvdata(vdev);
+
+        uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n");
+
+        return uvc_queue_poll(&video->queue, file, wait);
+}
+
+struct file_operations uvc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = uvc_v4l2_open,
+        .release        = uvc_v4l2_release,
+        .ioctl          = uvc_v4l2_ioctl,
+        .compat_ioctl   = v4l_compat_ioctl32,
+        .llseek         = no_llseek,
+        .read           = uvc_v4l2_read,
+        .mmap           = uvc_v4l2_mmap,
+        .poll           = uvc_v4l2_poll,
+};
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
new file mode 100644
index 000000000000..6faf1fb21614
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -0,0 +1,934 @@
+/*
+ *      uvc_video.c  --  USB Video Class driver - Video handling
+ *
+ *      Copyright (C) 2005-2008
+ *          Laurent Pinchart (laurent.pinchart@skynet.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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/videodev2.h>
+#include <linux/vmalloc.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+#include <asm/unaligned.h>
+
+#include <media/v4l2-common.h>
+
+#include "uvcvideo.h"
+
+/* ------------------------------------------------------------------------
+ * UVC Controls
+ */
+
+static int __uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
+                        __u8 intfnum, __u8 cs, void *data, __u16 size,
+                        int timeout)
+{
+        __u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
+        unsigned int pipe;
+        int ret;
+
+        pipe = (query & 0x80) ? usb_rcvctrlpipe(dev->udev, 0)
+                              : usb_sndctrlpipe(dev->udev, 0);
+        type |= (query & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
+
+        ret = usb_control_msg(dev->udev, pipe, query, type, cs << 8,
+                        unit << 8 | intfnum, data, size, timeout);
+
+        if (ret != size) {
+                uvc_printk(KERN_ERR, "Failed to query (%u) UVC control %u "
+                        "(unit %u) : %d (exp. %u).\n", query, cs, unit, ret,
+                        size);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
+                        __u8 intfnum, __u8 cs, void *data, __u16 size)
+{
+        return __uvc_query_ctrl(dev, query, unit, intfnum, cs, data, size,
+                                UVC_CTRL_CONTROL_TIMEOUT);
+}
+
+static void uvc_fixup_buffer_size(struct uvc_video_device *video,
+        struct uvc_streaming_control *ctrl)
+{
+        struct uvc_format *format;
+        struct uvc_frame *frame;
+
+        if (ctrl->bFormatIndex <= 0 ||
+            ctrl->bFormatIndex > video->streaming->nformats)
+                return;
+
+        format = &video->streaming->format[ctrl->bFormatIndex - 1];
+
+        if (ctrl->bFrameIndex <= 0 ||
+            ctrl->bFrameIndex > format->nframes)
+                return;
+
+        frame = &format->frame[ctrl->bFrameIndex - 1];
+
+        if (!(format->flags & UVC_FMT_FLAG_COMPRESSED) ||
+             (ctrl->dwMaxVideoFrameSize == 0 &&
+              video->dev->uvc_version < 0x0110))
+                ctrl->dwMaxVideoFrameSize =
+                        frame->dwMaxVideoFrameBufferSize;
+}
+
+static int uvc_get_video_ctrl(struct uvc_video_device *video,
+        struct uvc_streaming_control *ctrl, int probe, __u8 query)
+{
+        __u8 data[34];
+        __u8 size;
+        int ret;
+
+        size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
+        ret = __uvc_query_ctrl(video->dev, query, 0, video->streaming->intfnum,
+                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, &data, size,
+                UVC_CTRL_STREAMING_TIMEOUT);
+
+        if (ret < 0)
+                return ret;
+
+        ctrl->bmHint = le16_to_cpup((__le16 *)&data[0]);
+        ctrl->bFormatIndex = data[2];
+        ctrl->bFrameIndex = data[3];
+        ctrl->dwFrameInterval = le32_to_cpup((__le32 *)&data[4]);
+        ctrl->wKeyFrameRate = le16_to_cpup((__le16 *)&data[8]);
+        ctrl->wPFrameRate = le16_to_cpup((__le16 *)&data[10]);
+        ctrl->wCompQuality = le16_to_cpup((__le16 *)&data[12]);
+        ctrl->wCompWindowSize = le16_to_cpup((__le16 *)&data[14]);
+        ctrl->wDelay = le16_to_cpup((__le16 *)&data[16]);
+        ctrl->dwMaxVideoFrameSize =
+                le32_to_cpu(get_unaligned((__le32 *)&data[18]));
+        ctrl->dwMaxPayloadTransferSize =
+                le32_to_cpu(get_unaligned((__le32 *)&data[22]));
+
+        if (size == 34) {
+                ctrl->dwClockFrequency =
+                        le32_to_cpu(get_unaligned((__le32 *)&data[26]));
+                ctrl->bmFramingInfo = data[30];
+                ctrl->bPreferedVersion = data[31];
+                ctrl->bMinVersion = data[32];
+                ctrl->bMaxVersion = data[33];
+        } else {
+                ctrl->dwClockFrequency = video->dev->clock_frequency;
+                ctrl->bmFramingInfo = 0;
+                ctrl->bPreferedVersion = 0;
+                ctrl->bMinVersion = 0;
+                ctrl->bMaxVersion = 0;
+        }
+
+        /* Some broken devices return a null or wrong dwMaxVideoFrameSize.
+         * Try to get the value from the format and frame descriptor.
+         */
+        uvc_fixup_buffer_size(video, ctrl);
+
+        return 0;
+}
+
+int uvc_set_video_ctrl(struct uvc_video_device *video,
+        struct uvc_streaming_control *ctrl, int probe)
+{
+        __u8 data[34];
+        __u8 size;
+
+        size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
+        memset(data, 0, sizeof data);
+
+        *(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
+        data[2] = ctrl->bFormatIndex;
+        data[3] = ctrl->bFrameIndex;
+        *(__le32 *)&data[4] = cpu_to_le32(ctrl->dwFrameInterval);
+        *(__le16 *)&data[8] = cpu_to_le16(ctrl->wKeyFrameRate);
+        *(__le16 *)&data[10] = cpu_to_le16(ctrl->wPFrameRate);
+        *(__le16 *)&data[12] = cpu_to_le16(ctrl->wCompQuality);
+        *(__le16 *)&data[14] = cpu_to_le16(ctrl->wCompWindowSize);
+        *(__le16 *)&data[16] = cpu_to_le16(ctrl->wDelay);
+        /* Note: Some of the fields below are not required for IN devices (see
+         * UVC spec, 4.3.1.1), but we still copy them in case support for OUT
+         * devices is added in the future. */
+        put_unaligned(cpu_to_le32(ctrl->dwMaxVideoFrameSize),
+                (__le32 *)&data[18]);
+        put_unaligned(cpu_to_le32(ctrl->dwMaxPayloadTransferSize),
+                (__le32 *)&data[22]);
+
+        if (size == 34) {
+                put_unaligned(cpu_to_le32(ctrl->dwClockFrequency),
+                        (__le32 *)&data[26]);
+                data[30] = ctrl->bmFramingInfo;
+                data[31] = ctrl->bPreferedVersion;
+                data[32] = ctrl->bMinVersion;
+                data[33] = ctrl->bMaxVersion;
+        }
+
+        return __uvc_query_ctrl(video->dev, SET_CUR, 0,
+                video->streaming->intfnum,
+                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, &data, size,
+                UVC_CTRL_STREAMING_TIMEOUT);
+}
+
+int uvc_probe_video(struct uvc_video_device *video,
+        struct uvc_streaming_control *probe)
+{
+        struct uvc_streaming_control probe_min, probe_max;
+        __u16 bandwidth;
+        unsigned int i;
+        int ret;
+
+        mutex_lock(&video->streaming->mutex);
+
+        /* Perform probing. The device should adjust the requested values
+         * according to its capabilities. However, some devices, namely the
+         * first generation UVC Logitech webcams, don't implement the Video
+         * Probe control properly, and just return the needed bandwidth. For
+         * that reason, if the needed bandwidth exceeds the maximum available
+         * bandwidth, try to lower the quality.
+         */
+        if ((ret = uvc_set_video_ctrl(video, probe, 1)) < 0)
+                goto done;
+
+        /* Get the minimum and maximum values for compression settings. */
+        if (!(video->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
+                ret = uvc_get_video_ctrl(video, &probe_min, 1, GET_MIN);
+                if (ret < 0)
+                        goto done;
+                ret = uvc_get_video_ctrl(video, &probe_max, 1, GET_MAX);
+                if (ret < 0)
+                        goto done;
+
+                probe->wCompQuality = probe_max.wCompQuality;
+        }
+
+        for (i = 0; i < 2; ++i) {
+                if ((ret = uvc_set_video_ctrl(video, probe, 1)) < 0 ||
+                    (ret = uvc_get_video_ctrl(video, probe, 1, GET_CUR)) < 0)
+                        goto done;
+
+                if (video->streaming->intf->num_altsetting == 1)
+                        break;
+
+                bandwidth = probe->dwMaxPayloadTransferSize;
+                if (bandwidth <= video->streaming->maxpsize)
+                        break;
+
+                if (video->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
+                        ret = -ENOSPC;
+                        goto done;
+                }
+
+                /* TODO: negotiate compression parameters */
+                probe->wKeyFrameRate = probe_min.wKeyFrameRate;
+                probe->wPFrameRate = probe_min.wPFrameRate;
+                probe->wCompQuality = probe_max.wCompQuality;
+                probe->wCompWindowSize = probe_min.wCompWindowSize;
+        }
+
+done:
+        mutex_unlock(&video->streaming->mutex);
+        return ret;
+}
+
+/* ------------------------------------------------------------------------
+ * Video codecs
+ */
+
+/* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
+#define UVC_STREAM_EOH  (1 << 7)
+#define UVC_STREAM_ERR  (1 << 6)
+#define UVC_STREAM_STI  (1 << 5)
+#define UVC_STREAM_RES  (1 << 4)
+#define UVC_STREAM_SCR  (1 << 3)
+#define UVC_STREAM_PTS  (1 << 2)
+#define UVC_STREAM_EOF  (1 << 1)
+#define UVC_STREAM_FID  (1 << 0)
+
+/* Video payload decoding is handled by uvc_video_decode_start(),
+ * uvc_video_decode_data() and uvc_video_decode_end().
+ *
+ * uvc_video_decode_start is called with URB data at the start of a bulk or
+ * isochronous payload. It processes header data and returns the header size
+ * in bytes if successful. If an error occurs, it returns a negative error
+ * code. The following error codes have special meanings.
+ *
+ * - EAGAIN informs the caller that the current video buffer should be marked
+ *   as done, and that the function should be called again with the same data
+ *   and a new video buffer. This is used when end of frame conditions can be
+ *   reliably detected at the beginning of the next frame only.
+ *
+ * If an error other than -EAGAIN is returned, the caller will drop the current
+ * payload. No call to uvc_video_decode_data and uvc_video_decode_end will be
+ * made until the next payload. -ENODATA can be used to drop the current
+ * payload if no other error code is appropriate.
+ *
+ * uvc_video_decode_data is called for every URB with URB data. It copies the
+ * data to the video buffer.
+ *
+ * uvc_video_decode_end is called with header data at the end of a bulk or
+ * isochronous payload. It performs any additional header data processing and
+ * returns 0 or a negative error code if an error occured. As header data have
+ * already been processed by uvc_video_decode_start, this functions isn't
+ * required to perform sanity checks a second time.
+ *
+ * For isochronous transfers where a payload is always transfered in a single
+ * URB, the three functions will be called in a row.
+ *
+ * To let the decoder process header data and update its internal state even
+ * when no video buffer is available, uvc_video_decode_start must be prepared
+ * to be called with a NULL buf parameter. uvc_video_decode_data and
+ * uvc_video_decode_end will never be called with a NULL buffer.
+ */
+static int uvc_video_decode_start(struct uvc_video_device *video,
+                struct uvc_buffer *buf, const __u8 *data, int len)
+{
+        __u8 fid;
+
+        /* Sanity checks:
+         * - packet must be at least 2 bytes long
+         * - bHeaderLength value must be at least 2 bytes (see above)
+         * - bHeaderLength value can't be larger than the packet size.
+         */
+        if (len < 2 || data[0] < 2 || data[0] > len)
+                return -EINVAL;
+
+        /* Skip payloads marked with the error bit ("error frames"). */
+        if (data[1] & UVC_STREAM_ERR) {
+                uvc_trace(UVC_TRACE_FRAME, "Dropping payload (error bit "
+                          "set).\n");
+                return -ENODATA;
+        }
+
+        fid = data[1] & UVC_STREAM_FID;
+
+        /* Store the payload FID bit and return immediately when the buffer is
+         * NULL.
+         */
+        if (buf == NULL) {
+                video->last_fid = fid;
+                return -ENODATA;
+        }
+
+        /* Synchronize to the input stream by waiting for the FID bit to be
+         * toggled when the the buffer state is not UVC_BUF_STATE_ACTIVE.
+         * queue->last_fid is initialized to -1, so the first isochronous
+         * frame will always be in sync.
+         *
+         * If the device doesn't toggle the FID bit, invert video->last_fid
+         * when the EOF bit is set to force synchronisation on the next packet.
+         */
+        if (buf->state != UVC_BUF_STATE_ACTIVE) {
+                if (fid == video->last_fid) {
+                        uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
+                                "sync).\n");
+                        if ((video->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
+                            (data[1] & UVC_STREAM_EOF))
+                                video->last_fid ^= UVC_STREAM_FID;
+                        return -ENODATA;
+                }
+
+                /* TODO: Handle PTS and SCR. */
+                buf->state = UVC_BUF_STATE_ACTIVE;
+        }
+
+        /* Mark the buffer as done if we're at the beginning of a new frame.
+         * End of frame detection is better implemented by checking the EOF
+         * bit (FID bit toggling is delayed by one frame compared to the EOF
+         * bit), but some devices don't set the bit at end of frame (and the
+         * last payload can be lost anyway). We thus must check if the FID has
+         * been toggled.
+         *
+         * queue->last_fid is initialized to -1, so the first isochronous
+         * frame will never trigger an end of frame detection.
+         *
+         * Empty buffers (bytesused == 0) don't trigger end of frame detection
+         * as it doesn't make sense to return an empty buffer. This also
+         * avoids detecting and of frame conditions at FID toggling if the
+         * previous payload had the EOF bit set.
+         */
+        if (fid != video->last_fid && buf->buf.bytesused != 0) {
+                uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
+                                "toggled).\n");
+                buf->state = UVC_BUF_STATE_DONE;
+                return -EAGAIN;
+        }
+
+        video->last_fid = fid;
+
+        return data[0];
+}
+
+static void uvc_video_decode_data(struct uvc_video_device *video,
+                struct uvc_buffer *buf, const __u8 *data, int len)
+{
+        struct uvc_video_queue *queue = &video->queue;
+        unsigned int maxlen, nbytes;
+        void *mem;
+
+        if (len <= 0)
+                return;
+
+        /* Copy the video data to the buffer. */
+        maxlen = buf->buf.length - buf->buf.bytesused;
+        mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
+        nbytes = min((unsigned int)len, maxlen);
+        memcpy(mem, data, nbytes);
+        buf->buf.bytesused += nbytes;
+
+        /* Complete the current frame if the buffer size was exceeded. */
+        if (len > maxlen) {
+                uvc_trace(UVC_TRACE_FRAME, "Frame complete (overflow).\n");
+                buf->state = UVC_BUF_STATE_DONE;
+        }
+}
+
+static void uvc_video_decode_end(struct uvc_video_device *video,
+                struct uvc_buffer *buf, const __u8 *data, int len)
+{
+        /* Mark the buffer as done if the EOF marker is set. */
+        if (data[1] & UVC_STREAM_EOF && buf->buf.bytesused != 0) {
+                uvc_trace(UVC_TRACE_FRAME, "Frame complete (EOF found).\n");
+                if (data[0] == len)
+                        uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
+                buf->state = UVC_BUF_STATE_DONE;
+                if (video->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
+                        video->last_fid ^= UVC_STREAM_FID;
+        }
+}
+
+/* ------------------------------------------------------------------------
+ * URB handling
+ */
+
+/*
+ * Completion handler for video URBs.
+ */
+static void uvc_video_decode_isoc(struct urb *urb,
+        struct uvc_video_device *video, struct uvc_buffer *buf)
+{
+        u8 *mem;
+        int ret, i;
+
+        for (i = 0; i < urb->number_of_packets; ++i) {
+                if (urb->iso_frame_desc[i].status < 0) {
+                        uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
+                                "lost (%d).\n", urb->iso_frame_desc[i].status);
+                        continue;
+                }
+
+                /* Decode the payload header. */
+                mem = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+                do {
+                        ret = uvc_video_decode_start(video, buf, mem,
+                                urb->iso_frame_desc[i].actual_length);
+                        if (ret == -EAGAIN)
+                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                } while (ret == -EAGAIN);
+
+                if (ret < 0)
+                        continue;
+
+                /* Decode the payload data. */
+                uvc_video_decode_data(video, buf, mem + ret,
+                        urb->iso_frame_desc[i].actual_length - ret);
+
+                /* Process the header again. */
+                uvc_video_decode_end(video, buf, mem, ret);
+
+                if (buf->state == UVC_BUF_STATE_DONE ||
+                    buf->state == UVC_BUF_STATE_ERROR)
+                        buf = uvc_queue_next_buffer(&video->queue, buf);
+        }
+}
+
+static void uvc_video_decode_bulk(struct urb *urb,
+        struct uvc_video_device *video, struct uvc_buffer *buf)
+{
+        u8 *mem;
+        int len, ret;
+
+        mem = urb->transfer_buffer;
+        len = urb->actual_length;
+        video->bulk.payload_size += len;
+
+        /* If the URB is the first of its payload, decode and save the
+         * header.
+         */
+        if (video->bulk.header_size == 0) {
+                do {
+                        ret = uvc_video_decode_start(video, buf, mem, len);
+                        if (ret == -EAGAIN)
+                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                } while (ret == -EAGAIN);
+
+                /* If an error occured skip the rest of the payload. */
+                if (ret < 0 || buf == NULL) {
+                        video->bulk.skip_payload = 1;
+                        return;
+                }
+
+                video->bulk.header_size = ret;
+                memcpy(video->bulk.header, mem, video->bulk.header_size);
+
+                mem += ret;
+                len -= ret;
+        }
+
+        /* The buffer queue might have been cancelled while a bulk transfer
+         * was in progress, so we can reach here with buf equal to NULL. Make
+         * sure buf is never dereferenced if NULL.
+         */
+
+        /* Process video data. */
+        if (!video->bulk.skip_payload && buf != NULL)
+                uvc_video_decode_data(video, buf, mem, len);
+
+        /* Detect the payload end by a URB smaller than the maximum size (or
+         * a payload size equal to the maximum) and process the header again.
+         */
+        if (urb->actual_length < urb->transfer_buffer_length ||
+            video->bulk.payload_size >= video->bulk.max_payload_size) {
+                if (!video->bulk.skip_payload && buf != NULL) {
+                        uvc_video_decode_end(video, buf, video->bulk.header,
+                                video->bulk.header_size);
+                        if (buf->state == UVC_BUF_STATE_DONE ||
+                            buf->state == UVC_BUF_STATE_ERROR)
+                                buf = uvc_queue_next_buffer(&video->queue, buf);
+                }
+
+                video->bulk.header_size = 0;
+                video->bulk.skip_payload = 0;
+                video->bulk.payload_size = 0;
+        }
+}
+
+static void uvc_video_complete(struct urb *urb)
+{
+        struct uvc_video_device *video = urb->context;
+        struct uvc_video_queue *queue = &video->queue;
+        struct uvc_buffer *buf = NULL;
+        unsigned long flags;
+        int ret;
+
+        switch (urb->status) {
+        case 0:
+                break;
+
+        default:
+                uvc_printk(KERN_WARNING, "Non-zero status (%d) in video "
+                        "completion handler.\n", urb->status);
+
+        case -ENOENT:           /* usb_kill_urb() called. */
+                if (video->frozen)
+                        return;
+
+        case -ECONNRESET:       /* usb_unlink_urb() called. */
+        case -ESHUTDOWN:        /* The endpoint is being disabled. */
+                uvc_queue_cancel(queue, urb->status == -ESHUTDOWN);
+                return;
+        }
+
+        spin_lock_irqsave(&queue->irqlock, flags);
+        if (!list_empty(&queue->irqqueue))
+                buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
+                                       queue);
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+
+        video->decode(urb, video, buf);
+
+        if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
+                uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
+                        ret);
+        }
+}
+
+/*
+ * Uninitialize isochronous/bulk URBs and free transfer buffers.
+ */
+static void uvc_uninit_video(struct uvc_video_device *video)
+{
+        struct urb *urb;
+        unsigned int i;
+
+        for (i = 0; i < UVC_URBS; ++i) {
+                if ((urb = video->urb[i]) == NULL)
+                        continue;
+
+                usb_kill_urb(urb);
+                /* urb->transfer_buffer_length is not touched by USB core, so
+                 * we can use it here as the buffer length.
+                 */
+                if (video->urb_buffer[i]) {
+                        usb_buffer_free(video->dev->udev,
+                                urb->transfer_buffer_length,
+                                video->urb_buffer[i], urb->transfer_dma);
+                        video->urb_buffer[i] = NULL;
+                }
+
+                usb_free_urb(urb);
+                video->urb[i] = NULL;
+        }
+}
+
+/*
+ * Initialize isochronous URBs and allocate transfer buffers. The packet size
+ * is given by the endpoint.
+ */
+static int uvc_init_video_isoc(struct uvc_video_device *video,
+        struct usb_host_endpoint *ep)
+{
+        struct urb *urb;
+        unsigned int npackets, i, j;
+        __u16 psize;
+        __u32 size;
+
+        /* Compute the number of isochronous packets to allocate by dividing
+         * the maximum video frame size by the packet size. Limit the result
+         * to UVC_MAX_ISO_PACKETS.
+         */
+        psize = le16_to_cpu(ep->desc.wMaxPacketSize);
+        psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+
+        size = video->streaming->ctrl.dwMaxVideoFrameSize;
+        if (size > UVC_MAX_FRAME_SIZE)
+                return -EINVAL;
+
+        npackets = (size + psize - 1) / psize;
+        if (npackets > UVC_MAX_ISO_PACKETS)
+                npackets = UVC_MAX_ISO_PACKETS;
+
+        size = npackets * psize;
+
+        for (i = 0; i < UVC_URBS; ++i) {
+                urb = usb_alloc_urb(npackets, GFP_KERNEL);
+                if (urb == NULL) {
+                        uvc_uninit_video(video);
+                        return -ENOMEM;
+                }
+
+                video->urb_buffer[i] = usb_buffer_alloc(video->dev->udev,
+                        size, GFP_KERNEL, &urb->transfer_dma);
+                if (video->urb_buffer[i] == NULL) {
+                        usb_free_urb(urb);
+                        uvc_uninit_video(video);
+                        return -ENOMEM;
+                }
+
+                urb->dev = video->dev->udev;
+                urb->context = video;
+                urb->pipe = usb_rcvisocpipe(video->dev->udev,
+                                ep->desc.bEndpointAddress);
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->interval = ep->desc.bInterval;
+                urb->transfer_buffer = video->urb_buffer[i];
+                urb->complete = uvc_video_complete;
+                urb->number_of_packets = npackets;
+                urb->transfer_buffer_length = size;
+
+                for (j = 0; j < npackets; ++j) {
+                        urb->iso_frame_desc[j].offset = j * psize;
+                        urb->iso_frame_desc[j].length = psize;
+                }
+
+                video->urb[i] = urb;
+        }
+
+        return 0;
+}
+
+/*
+ * Initialize bulk URBs and allocate transfer buffers. The packet size is
+ * given by the endpoint.
+ */
+static int uvc_init_video_bulk(struct uvc_video_device *video,
+        struct usb_host_endpoint *ep)
+{
+        struct urb *urb;
+        unsigned int pipe, i;
+        __u16 psize;
+        __u32 size;
+
+        /* Compute the bulk URB size. Some devices set the maximum payload
+         * size to a value too high for memory-constrained devices. We must
+         * then transfer the payload accross multiple URBs. To be consistant
+         * with isochronous mode, allocate maximum UVC_MAX_ISO_PACKETS per bulk
+         * URB.
+         */
+        psize = le16_to_cpu(ep->desc.wMaxPacketSize) & 0x07ff;
+        size = video->streaming->ctrl.dwMaxPayloadTransferSize;
+        video->bulk.max_payload_size = size;
+        if (size > psize * UVC_MAX_ISO_PACKETS)
+                size = psize * UVC_MAX_ISO_PACKETS;
+
+        pipe = usb_rcvbulkpipe(video->dev->udev, ep->desc.bEndpointAddress);
+
+        for (i = 0; i < UVC_URBS; ++i) {
+                urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (urb == NULL) {
+                        uvc_uninit_video(video);
+                        return -ENOMEM;
+                }
+
+                video->urb_buffer[i] = usb_buffer_alloc(video->dev->udev,
+                        size, GFP_KERNEL, &urb->transfer_dma);
+                if (video->urb_buffer[i] == NULL) {
+                        usb_free_urb(urb);
+                        uvc_uninit_video(video);
+                        return -ENOMEM;
+                }
+
+                usb_fill_bulk_urb(urb, video->dev->udev, pipe,
+                        video->urb_buffer[i], size, uvc_video_complete,
+                        video);
+                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+
+                video->urb[i] = urb;
+        }
+
+        return 0;
+}
+
+/*
+ * Initialize isochronous/bulk URBs and allocate transfer buffers.
+ */
+static int uvc_init_video(struct uvc_video_device *video)
+{
+        struct usb_interface *intf = video->streaming->intf;
+        struct usb_host_interface *alts;
+        struct usb_host_endpoint *ep = NULL;
+        int intfnum = video->streaming->intfnum;
+        unsigned int bandwidth, psize, i;
+        int ret;
+
+        video->last_fid = -1;
+        video->bulk.header_size = 0;
+        video->bulk.skip_payload = 0;
+        video->bulk.payload_size = 0;
+
+        if (intf->num_altsetting > 1) {
+                /* Isochronous endpoint, select the alternate setting. */
+                bandwidth = video->streaming->ctrl.dwMaxPayloadTransferSize;
+
+                if (bandwidth == 0) {
+                        uvc_printk(KERN_WARNING, "device %s requested null "
+                                "bandwidth, defaulting to lowest.\n",
+                                video->vdev->name);
+                        bandwidth = 1;
+                }
+
+                for (i = 0; i < intf->num_altsetting; ++i) {
+                        alts = &intf->altsetting[i];
+                        ep = uvc_find_endpoint(alts,
+                                video->streaming->header.bEndpointAddress);
+                        if (ep == NULL)
+                                continue;
+
+                        /* Check if the bandwidth is high enough. */
+                        psize = le16_to_cpu(ep->desc.wMaxPacketSize);
+                        psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+                        if (psize >= bandwidth)
+                                break;
+                }
+
+                if (i >= intf->num_altsetting)
+                        return -EIO;
+
+                if ((ret = usb_set_interface(video->dev->udev, intfnum, i)) < 0)
+                        return ret;
+
+                ret = uvc_init_video_isoc(video, ep);
+        } else {
+                /* Bulk endpoint, proceed to URB initialization. */
+                ep = uvc_find_endpoint(&intf->altsetting[0],
+                                video->streaming->header.bEndpointAddress);
+                if (ep == NULL)
+                        return -EIO;
+
+                ret = uvc_init_video_bulk(video, ep);
+        }
+
+        if (ret < 0)
+                return ret;
+
+        /* Submit the URBs. */
+        for (i = 0; i < UVC_URBS; ++i) {
+                if ((ret = usb_submit_urb(video->urb[i], GFP_KERNEL)) < 0) {
+                        uvc_printk(KERN_ERR, "Failed to submit URB %u "
+                                        "(%d).\n", i, ret);
+                        uvc_uninit_video(video);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+/* --------------------------------------------------------------------------
+ * Suspend/resume
+ */
+
+/*
+ * Stop streaming without disabling the video queue.
+ *
+ * To let userspace applications resume without trouble, we must not touch the
+ * video buffers in any way. We mark the device as frozen to make sure the URB
+ * completion handler won't try to cancel the queue when we kill the URBs.
+ */
+int uvc_video_suspend(struct uvc_video_device *video)
+{
+        if (!uvc_queue_streaming(&video->queue))
+                return 0;
+
+        video->frozen = 1;
+        uvc_uninit_video(video);
+        usb_set_interface(video->dev->udev, video->streaming->intfnum, 0);
+        return 0;
+}
+
+/*
+ * Reconfigure the video interface and restart streaming if it was enable
+ * before suspend.
+ *
+ * If an error occurs, disable the video queue. This will wake all pending
+ * buffers, making sure userspace applications are notified of the problem
+ * instead of waiting forever.
+ */
+int uvc_video_resume(struct uvc_video_device *video)
+{
+        int ret;
+
+        video->frozen = 0;
+
+        if ((ret = uvc_set_video_ctrl(video, &video->streaming->ctrl, 0)) < 0) {
+                uvc_queue_enable(&video->queue, 0);
+                return ret;
+        }
+
+        if (!uvc_queue_streaming(&video->queue))
+                return 0;
+
+        if ((ret = uvc_init_video(video)) < 0)
+                uvc_queue_enable(&video->queue, 0);
+
+        return ret;
+}
+
+/* ------------------------------------------------------------------------
+ * Video device
+ */
+
+/*
+ * Initialize the UVC video device by retrieving the default format and
+ * committing it.
+ *
+ * Some cameras (namely the Fuji Finepix) set the format and frame
+ * indexes to zero. The UVC standard doesn't clearly make this a spec
+ * violation, so try to silently fix the values if possible.
+ *
+ * This function is called before registering the device with V4L.
+ */
+int uvc_video_init(struct uvc_video_device *video)
+{
+        struct uvc_streaming_control *probe = &video->streaming->ctrl;
+        struct uvc_format *format = NULL;
+        struct uvc_frame *frame = NULL;
+        unsigned int i;
+        int ret;
+
+        if (video->streaming->nformats == 0) {
+                uvc_printk(KERN_INFO, "No supported video formats found.\n");
+                return -EINVAL;
+        }
+
+        /* Alternate setting 0 should be the default, yet the XBox Live Vision
+         * Cam (and possibly other devices) crash or otherwise misbehave if
+         * they don't receive a SET_INTERFACE request before any other video
+         * control request.
+         */
+        usb_set_interface(video->dev->udev, video->streaming->intfnum, 0);
+
+        /* Some webcams don't suport GET_DEF request on the probe control. We
+         * fall back to GET_CUR if GET_DEF fails.
+         */
+        if ((ret = uvc_get_video_ctrl(video, probe, 1, GET_DEF)) < 0 &&
+            (ret = uvc_get_video_ctrl(video, probe, 1, GET_CUR)) < 0)
+                return ret;
+
+        /* Check if the default format descriptor exists. Use the first
+         * available format otherwise.
+         */
+        for (i = video->streaming->nformats; i > 0; --i) {
+                format = &video->streaming->format[i-1];
+                if (format->index == probe->bFormatIndex)
+                        break;
+        }
+
+        if (format->nframes == 0) {
+                uvc_printk(KERN_INFO, "No frame descriptor found for the "
+                        "default format.\n");
+                return -EINVAL;
+        }
+
+        /* Zero bFrameIndex might be correct. Stream-based formats (including
+         * MPEG-2 TS and DV) do not support frames but have a dummy frame
+         * descriptor with bFrameIndex set to zero. If the default frame
+         * descriptor is not found, use the first avalable frame.
+         */
+        for (i = format->nframes; i > 0; --i) {
+                frame = &format->frame[i-1];
+                if (frame->bFrameIndex == probe->bFrameIndex)
+                        break;
+        }
+
+        /* Commit the default settings. */
+        probe->bFormatIndex = format->index;
+        probe->bFrameIndex = frame->bFrameIndex;
+        if ((ret = uvc_set_video_ctrl(video, probe, 0)) < 0)
+                return ret;
+
+        video->streaming->cur_format = format;
+        video->streaming->cur_frame = frame;
+        atomic_set(&video->active, 0);
+
+        /* Select the video decoding function */
+        if (video->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
+                video->decode = uvc_video_decode_isight;
+        else if (video->streaming->intf->num_altsetting > 1)
+                video->decode = uvc_video_decode_isoc;
+        else
+                video->decode = uvc_video_decode_bulk;
+
+        return 0;
+}
+
+/*
+ * Enable or disable the video stream.
+ */
+int uvc_video_enable(struct uvc_video_device *video, int enable)
+{
+        int ret;
+
+        if (!enable) {
+                uvc_uninit_video(video);
+                usb_set_interface(video->dev->udev,
+                        video->streaming->intfnum, 0);
+                uvc_queue_enable(&video->queue, 0);
+                return 0;
+        }
+
+        if ((ret = uvc_queue_enable(&video->queue, 1)) < 0)
+                return ret;
+
+        return uvc_init_video(video);
+}
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
new file mode 100644
index 000000000000..a995a780db1c
--- /dev/null
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -0,0 +1,796 @@
+#ifndef _USB_VIDEO_H_
+#define _USB_VIDEO_H_
+
+#include <linux/kernel.h>
+#include <linux/videodev2.h>
+
+
+/*
+ * Dynamic controls
+ */
+
+/* Data types for UVC control data */
+#define UVC_CTRL_DATA_TYPE_RAW          0
+#define UVC_CTRL_DATA_TYPE_SIGNED       1
+#define UVC_CTRL_DATA_TYPE_UNSIGNED     2
+#define UVC_CTRL_DATA_TYPE_BOOLEAN      3
+#define UVC_CTRL_DATA_TYPE_ENUM         4
+#define UVC_CTRL_DATA_TYPE_BITMASK      5
+
+/* Control flags */
+#define UVC_CONTROL_SET_CUR     (1 << 0)
+#define UVC_CONTROL_GET_CUR     (1 << 1)
+#define UVC_CONTROL_GET_MIN     (1 << 2)
+#define UVC_CONTROL_GET_MAX     (1 << 3)
+#define UVC_CONTROL_GET_RES     (1 << 4)
+#define UVC_CONTROL_GET_DEF     (1 << 5)
+/* Control should be saved at suspend and restored at resume. */
+#define UVC_CONTROL_RESTORE     (1 << 6)
+/* Control can be updated by the camera. */
+#define UVC_CONTROL_AUTO_UPDATE (1 << 7)
+
+#define UVC_CONTROL_GET_RANGE   (UVC_CONTROL_GET_CUR | UVC_CONTROL_GET_MIN | \
+                                 UVC_CONTROL_GET_MAX | UVC_CONTROL_GET_RES | \
+                                 UVC_CONTROL_GET_DEF)
+
+struct uvc_xu_control_info {
+        __u8 entity[16];
+        __u8 index;
+        __u8 selector;
+        __u16 size;
+        __u32 flags;
+};
+
+struct uvc_xu_control_mapping {
+        __u32 id;
+        __u8 name[32];
+        __u8 entity[16];
+        __u8 selector;
+
+        __u8 size;
+        __u8 offset;
+        enum v4l2_ctrl_type v4l2_type;
+        __u32 data_type;
+};
+
+struct uvc_xu_control {
+        __u8 unit;
+        __u8 selector;
+        __u16 size;
+        __u8 __user *data;
+};
+
+#define UVCIOC_CTRL_ADD         _IOW('U', 1, struct uvc_xu_control_info)
+#define UVCIOC_CTRL_MAP         _IOWR('U', 2, struct uvc_xu_control_mapping)
+#define UVCIOC_CTRL_GET         _IOWR('U', 3, struct uvc_xu_control)
+#define UVCIOC_CTRL_SET         _IOW('U', 4, struct uvc_xu_control)
+
+#ifdef __KERNEL__
+
+#include <linux/poll.h>
+
+/* --------------------------------------------------------------------------
+ * UVC constants
+ */
+
+#define SC_UNDEFINED                    0x00
+#define SC_VIDEOCONTROL                 0x01
+#define SC_VIDEOSTREAMING               0x02
+#define SC_VIDEO_INTERFACE_COLLECTION   0x03
+
+#define PC_PROTOCOL_UNDEFINED           0x00
+
+#define CS_UNDEFINED                    0x20
+#define CS_DEVICE                       0x21
+#define CS_CONFIGURATION                0x22
+#define CS_STRING                       0x23
+#define CS_INTERFACE                    0x24
+#define CS_ENDPOINT                     0x25
+
+/* VideoControl class specific interface descriptor */
+#define VC_DESCRIPTOR_UNDEFINED         0x00
+#define VC_HEADER                       0x01
+#define VC_INPUT_TERMINAL               0x02
+#define VC_OUTPUT_TERMINAL              0x03
+#define VC_SELECTOR_UNIT                0x04
+#define VC_PROCESSING_UNIT              0x05
+#define VC_EXTENSION_UNIT               0x06
+
+/* VideoStreaming class specific interface descriptor */
+#define VS_UNDEFINED                    0x00
+#define VS_INPUT_HEADER                 0x01
+#define VS_OUTPUT_HEADER                0x02
+#define VS_STILL_IMAGE_FRAME            0x03
+#define VS_FORMAT_UNCOMPRESSED          0x04
+#define VS_FRAME_UNCOMPRESSED           0x05
+#define VS_FORMAT_MJPEG                 0x06
+#define VS_FRAME_MJPEG                  0x07
+#define VS_FORMAT_MPEG2TS               0x0a
+#define VS_FORMAT_DV                    0x0c
+#define VS_COLORFORMAT                  0x0d
+#define VS_FORMAT_FRAME_BASED           0x10
+#define VS_FRAME_FRAME_BASED            0x11
+#define VS_FORMAT_STREAM_BASED          0x12
+
+/* Endpoint type */
+#define EP_UNDEFINED                    0x00
+#define EP_GENERAL                      0x01
+#define EP_ENDPOINT                     0x02
+#define EP_INTERRUPT                    0x03
+
+/* Request codes */
+#define RC_UNDEFINED                    0x00
+#define SET_CUR                         0x01
+#define GET_CUR                         0x81
+#define GET_MIN                         0x82
+#define GET_MAX                         0x83
+#define GET_RES                         0x84
+#define GET_LEN                         0x85
+#define GET_INFO                        0x86
+#define GET_DEF                         0x87
+
+/* VideoControl interface controls */
+#define VC_CONTROL_UNDEFINED            0x00
+#define VC_VIDEO_POWER_MODE_CONTROL     0x01
+#define VC_REQUEST_ERROR_CODE_CONTROL   0x02
+
+/* Terminal controls */
+#define TE_CONTROL_UNDEFINED            0x00
+
+/* Selector Unit controls */
+#define SU_CONTROL_UNDEFINED            0x00
+#define SU_INPUT_SELECT_CONTROL         0x01
+
+/* Camera Terminal controls */
+#define CT_CONTROL_UNDEFINED                            0x00
+#define CT_SCANNING_MODE_CONTROL                        0x01
+#define CT_AE_MODE_CONTROL                              0x02
+#define CT_AE_PRIORITY_CONTROL                          0x03
+#define CT_EXPOSURE_TIME_ABSOLUTE_CONTROL               0x04
+#define CT_EXPOSURE_TIME_RELATIVE_CONTROL               0x05
+#define CT_FOCUS_ABSOLUTE_CONTROL                       0x06
+#define CT_FOCUS_RELATIVE_CONTROL                       0x07
+#define CT_FOCUS_AUTO_CONTROL                           0x08
+#define CT_IRIS_ABSOLUTE_CONTROL                        0x09
+#define CT_IRIS_RELATIVE_CONTROL                        0x0a
+#define CT_ZOOM_ABSOLUTE_CONTROL                        0x0b
+#define CT_ZOOM_RELATIVE_CONTROL                        0x0c
+#define CT_PANTILT_ABSOLUTE_CONTROL                     0x0d
+#define CT_PANTILT_RELATIVE_CONTROL                     0x0e
+#define CT_ROLL_ABSOLUTE_CONTROL                        0x0f
+#define CT_ROLL_RELATIVE_CONTROL                        0x10
+#define CT_PRIVACY_CONTROL                              0x11
+
+/* Processing Unit controls */
+#define PU_CONTROL_UNDEFINED                            0x00
+#define PU_BACKLIGHT_COMPENSATION_CONTROL               0x01
+#define PU_BRIGHTNESS_CONTROL                           0x02
+#define PU_CONTRAST_CONTROL                             0x03
+#define PU_GAIN_CONTROL                                 0x04
+#define PU_POWER_LINE_FREQUENCY_CONTROL                 0x05
+#define PU_HUE_CONTROL                                  0x06
+#define PU_SATURATION_CONTROL                           0x07
+#define PU_SHARPNESS_CONTROL                            0x08
+#define PU_GAMMA_CONTROL                                0x09
+#define PU_WHITE_BALANCE_TEMPERATURE_CONTROL            0x0a
+#define PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL       0x0b
+#define PU_WHITE_BALANCE_COMPONENT_CONTROL              0x0c
+#define PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL         0x0d
+#define PU_DIGITAL_MULTIPLIER_CONTROL                   0x0e
+#define PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL             0x0f
+#define PU_HUE_AUTO_CONTROL                             0x10
+#define PU_ANALOG_VIDEO_STANDARD_CONTROL                0x11
+#define PU_ANALOG_LOCK_STATUS_CONTROL                   0x12
+
+#define LXU_MOTOR_PANTILT_RELATIVE_CONTROL              0x01
+#define LXU_MOTOR_PANTILT_RESET_CONTROL                 0x02
+#define LXU_MOTOR_FOCUS_MOTOR_CONTROL                   0x03
+
+/* VideoStreaming interface controls */
+#define VS_CONTROL_UNDEFINED            0x00
+#define VS_PROBE_CONTROL                0x01
+#define VS_COMMIT_CONTROL               0x02
+#define VS_STILL_PROBE_CONTROL          0x03
+#define VS_STILL_COMMIT_CONTROL         0x04
+#define VS_STILL_IMAGE_TRIGGER_CONTROL  0x05
+#define VS_STREAM_ERROR_CODE_CONTROL    0x06
+#define VS_GENERATE_KEY_FRAME_CONTROL   0x07
+#define VS_UPDATE_FRAME_SEGMENT_CONTROL 0x08
+#define VS_SYNC_DELAY_CONTROL           0x09
+
+#define TT_VENDOR_SPECIFIC              0x0100
+#define TT_STREAMING                    0x0101
+
+/* Input Terminal types */
+#define ITT_VENDOR_SPECIFIC             0x0200
+#define ITT_CAMERA                      0x0201
+#define ITT_MEDIA_TRANSPORT_INPUT       0x0202
+
+/* Output Terminal types */
+#define OTT_VENDOR_SPECIFIC             0x0300
+#define OTT_DISPLAY                     0x0301
+#define OTT_MEDIA_TRANSPORT_OUTPUT      0x0302
+
+/* External Terminal types */
+#define EXTERNAL_VENDOR_SPECIFIC        0x0400
+#define COMPOSITE_CONNECTOR             0x0401
+#define SVIDEO_CONNECTOR                0x0402
+#define COMPONENT_CONNECTOR             0x0403
+
+#define UVC_TERM_INPUT                  0x0000
+#define UVC_TERM_OUTPUT                 0x8000
+
+#define UVC_ENTITY_TYPE(entity)         ((entity)->type & 0x7fff)
+#define UVC_ENTITY_IS_UNIT(entity)      (((entity)->type & 0xff00) == 0)
+#define UVC_ENTITY_IS_TERM(entity)      (((entity)->type & 0xff00) != 0)
+#define UVC_ENTITY_IS_ITERM(entity) \
+        (((entity)->type & 0x8000) == UVC_TERM_INPUT)
+#define UVC_ENTITY_IS_OTERM(entity) \
+        (((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
+
+#define UVC_STATUS_TYPE_CONTROL         1
+#define UVC_STATUS_TYPE_STREAMING       2
+
+/* ------------------------------------------------------------------------
+ * GUIDs
+ */
+#define UVC_GUID_UVC_CAMERA \
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}
+#define UVC_GUID_UVC_OUTPUT \
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}
+#define UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT \
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}
+#define UVC_GUID_UVC_PROCESSING \
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01}
+#define UVC_GUID_UVC_SELECTOR \
+        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02}
+
+#define UVC_GUID_LOGITECH_DEV_INFO \
+        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
+         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1e}
+#define UVC_GUID_LOGITECH_USER_HW \
+        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
+         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1f}
+#define UVC_GUID_LOGITECH_VIDEO \
+        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
+         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x50}
+#define UVC_GUID_LOGITECH_MOTOR \
+        {0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
+         0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x56}
+
+#define UVC_GUID_FORMAT_MJPEG \
+        { 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YUY2 \
+        { 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_NV12 \
+        { 'N',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YV12 \
+        { 'Y',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_I420 \
+        { 'I',  '4',  '2',  '0', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_UYVY \
+        { 'U',  'Y',  'V',  'Y', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y800 \
+        { 'Y',  '8',  '0',  '0', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_BY8 \
+        { 'B',  'Y',  '8',  ' ', 0x00, 0x00, 0x10, 0x00, \
+         0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+
+
+/* ------------------------------------------------------------------------
+ * Driver specific constants.
+ */
+
+#define DRIVER_VERSION_NUMBER   KERNEL_VERSION(0, 1, 0)
+
+/* Number of isochronous URBs. */
+#define UVC_URBS                5
+/* Maximum number of packets per isochronous URB. */
+#define UVC_MAX_ISO_PACKETS     40
+/* Maximum frame size in bytes, for sanity checking. */
+#define UVC_MAX_FRAME_SIZE      (16*1024*1024)
+/* Maximum number of video buffers. */
+#define UVC_MAX_VIDEO_BUFFERS   32
+
+#define UVC_CTRL_CONTROL_TIMEOUT        300
+#define UVC_CTRL_STREAMING_TIMEOUT      1000
+
+/* Devices quirks */
+#define UVC_QUIRK_STATUS_INTERVAL       0x00000001
+#define UVC_QUIRK_PROBE_MINMAX          0x00000002
+#define UVC_QUIRK_PROBE_EXTRAFIELDS     0x00000004
+#define UVC_QUIRK_BUILTIN_ISIGHT        0x00000008
+#define UVC_QUIRK_STREAM_NO_FID         0x00000010
+#define UVC_QUIRK_IGNORE_SELECTOR_UNIT  0x00000020
+
+/* Format flags */
+#define UVC_FMT_FLAG_COMPRESSED         0x00000001
+#define UVC_FMT_FLAG_STREAM             0x00000002
+
+/* ------------------------------------------------------------------------
+ * Structures.
+ */
+
+struct uvc_device;
+
+/* TODO: Put the most frequently accessed fields at the beginning of
+ * structures to maximize cache efficiency.
+ */
+struct uvc_streaming_control {
+        __u16 bmHint;
+        __u8  bFormatIndex;
+        __u8  bFrameIndex;
+        __u32 dwFrameInterval;
+        __u16 wKeyFrameRate;
+        __u16 wPFrameRate;
+        __u16 wCompQuality;
+        __u16 wCompWindowSize;
+        __u16 wDelay;
+        __u32 dwMaxVideoFrameSize;
+        __u32 dwMaxPayloadTransferSize;
+        __u32 dwClockFrequency;
+        __u8  bmFramingInfo;
+        __u8  bPreferedVersion;
+        __u8  bMinVersion;
+        __u8  bMaxVersion;
+};
+
+struct uvc_menu_info {
+        __u32 value;
+        __u8 name[32];
+};
+
+struct uvc_control_info {
+        struct list_head list;
+        struct list_head mappings;
+
+        __u8 entity[16];
+        __u8 index;
+        __u8 selector;
+
+        __u16 size;
+        __u32 flags;
+};
+
+struct uvc_control_mapping {
+        struct list_head list;
+
+        struct uvc_control_info *ctrl;
+
+        __u32 id;
+        __u8 name[32];
+        __u8 entity[16];
+        __u8 selector;
+
+        __u8 size;
+        __u8 offset;
+        enum v4l2_ctrl_type v4l2_type;
+        __u32 data_type;
+
+        struct uvc_menu_info *menu_info;
+        __u32 menu_count;
+};
+
+struct uvc_control {
+        struct uvc_entity *entity;
+        struct uvc_control_info *info;
+
+        __u8 index;     /* Used to match the uvc_control entry with a
+                           uvc_control_info. */
+        __u8 dirty : 1,
+             loaded : 1,
+             modified : 1;
+
+        __u8 *data;
+};
+
+struct uvc_format_desc {
+        char *name;
+        __u8 guid[16];
+        __u32 fcc;
+};
+
+/* The term 'entity' refers to both UVC units and UVC terminals.
+ *
+ * The type field is either the terminal type (wTerminalType in the terminal
+ * descriptor), or the unit type (bDescriptorSubtype in the unit descriptor).
+ * As the bDescriptorSubtype field is one byte long, the type value will
+ * always have a null MSB for units. All terminal types defined by the UVC
+ * specification have a non-null MSB, so it is safe to use the MSB to
+ * differentiate between units and terminals as long as the descriptor parsing
+ * code makes sure terminal types have a non-null MSB.
+ *
+ * For terminals, the type's most significant bit stores the terminal
+ * direction (either UVC_TERM_INPUT or UVC_TERM_OUTPUT). The type field should
+ * always be accessed with the UVC_ENTITY_* macros and never directly.
+ */
+
+struct uvc_entity {
+        struct list_head list;          /* Entity as part of a UVC device. */
+        struct list_head chain;         /* Entity as part of a video device
+                                         * chain. */
+        __u8 id;
+        __u16 type;
+        char name[64];
+
+        union {
+                struct {
+                        __u16 wObjectiveFocalLengthMin;
+                        __u16 wObjectiveFocalLengthMax;
+                        __u16 wOcularFocalLength;
+                        __u8  bControlSize;
+                        __u8  *bmControls;
+                } camera;
+
+                struct {
+                        __u8  bControlSize;
+                        __u8  *bmControls;
+                        __u8  bTransportModeSize;
+                        __u8  *bmTransportModes;
+                } media;
+
+                struct {
+                        __u8  bSourceID;
+                } output;
+
+                struct {
+                        __u8  bSourceID;
+                        __u16 wMaxMultiplier;
+                        __u8  bControlSize;
+                        __u8  *bmControls;
+                        __u8  bmVideoStandards;
+                } processing;
+
+                struct {
+                        __u8  bNrInPins;
+                        __u8  *baSourceID;
+                } selector;
+
+                struct {
+                        __u8  guidExtensionCode[16];
+                        __u8  bNumControls;
+                        __u8  bNrInPins;
+                        __u8  *baSourceID;
+                        __u8  bControlSize;
+                        __u8  *bmControls;
+                        __u8  *bmControlsType;
+                } extension;
+        };
+
+        unsigned int ncontrols;
+        struct uvc_control *controls;
+};
+
+struct uvc_frame {
+        __u8  bFrameIndex;
+        __u8  bmCapabilities;
+        __u16 wWidth;
+        __u16 wHeight;
+        __u32 dwMinBitRate;
+        __u32 dwMaxBitRate;
+        __u32 dwMaxVideoFrameBufferSize;
+        __u8  bFrameIntervalType;
+        __u32 dwDefaultFrameInterval;
+        __u32 *dwFrameInterval;
+};
+
+struct uvc_format {
+        __u8 type;
+        __u8 index;
+        __u8 bpp;
+        __u8 colorspace;
+        __u32 fcc;
+        __u32 flags;
+
+        char name[32];
+
+        unsigned int nframes;
+        struct uvc_frame *frame;
+};
+
+struct uvc_streaming_header {
+        __u8 bNumFormats;
+        __u8 bEndpointAddress;
+        __u8 bTerminalLink;
+        __u8 bControlSize;
+        __u8 *bmaControls;
+        /* The following fields are used by input headers only. */
+        __u8 bmInfo;
+        __u8 bStillCaptureMethod;
+        __u8 bTriggerSupport;
+        __u8 bTriggerUsage;
+};
+
+struct uvc_streaming {
+        struct list_head list;
+
+        struct usb_interface *intf;
+        int intfnum;
+        __u16 maxpsize;
+
+        struct uvc_streaming_header header;
+
+        unsigned int nformats;
+        struct uvc_format *format;
+
+        struct uvc_streaming_control ctrl;
+        struct uvc_format *cur_format;
+        struct uvc_frame *cur_frame;
+
+        struct mutex mutex;
+};
+
+enum uvc_buffer_state {
+        UVC_BUF_STATE_IDLE       = 0,
+        UVC_BUF_STATE_QUEUED     = 1,
+        UVC_BUF_STATE_ACTIVE     = 2,
+        UVC_BUF_STATE_DONE       = 3,
+        UVC_BUF_STATE_ERROR      = 4,
+};
+
+struct uvc_buffer {
+        unsigned long vma_use_count;
+        struct list_head stream;
+
+        /* Touched by interrupt handler. */
+        struct v4l2_buffer buf;
+        struct list_head queue;
+        wait_queue_head_t wait;
+        enum uvc_buffer_state state;
+};
+
+#define UVC_QUEUE_STREAMING             (1 << 0)
+#define UVC_QUEUE_DISCONNECTED          (1 << 1)
+#define UVC_QUEUE_DROP_INCOMPLETE       (1 << 2)
+
+struct uvc_video_queue {
+        void *mem;
+        unsigned int flags;
+        __u32 sequence;
+
+        unsigned int count;
+        unsigned int buf_size;
+        struct uvc_buffer buffer[UVC_MAX_VIDEO_BUFFERS];
+        struct mutex mutex;     /* protects buffers and mainqueue */
+        spinlock_t irqlock;     /* protects irqqueue */
+
+        struct list_head mainqueue;
+        struct list_head irqqueue;
+};
+
+struct uvc_video_device {
+        struct uvc_device *dev;
+        struct video_device *vdev;
+        atomic_t active;
+        unsigned int frozen : 1;
+
+        struct list_head iterms;
+        struct uvc_entity *oterm;
+        struct uvc_entity *processing;
+        struct uvc_entity *selector;
+        struct list_head extensions;
+        struct mutex ctrl_mutex;
+
+        struct uvc_video_queue queue;
+
+        /* Video streaming object, must always be non-NULL. */
+        struct uvc_streaming *streaming;
+
+        void (*decode) (struct urb *urb, struct uvc_video_device *video,
+                        struct uvc_buffer *buf);
+
+        /* Context data used by the bulk completion handler. */
+        struct {
+                __u8 header[256];
+                unsigned int header_size;
+                int skip_payload;
+                __u32 payload_size;
+                __u32 max_payload_size;
+        } bulk;
+
+        struct urb *urb[UVC_URBS];
+        char *urb_buffer[UVC_URBS];
+
+        __u8 last_fid;
+};
+
+enum uvc_device_state {
+        UVC_DEV_DISCONNECTED = 1,
+};
+
+struct uvc_device {
+        struct usb_device *udev;
+        struct usb_interface *intf;
+        __u32 quirks;
+        int intfnum;
+        char name[32];
+
+        enum uvc_device_state state;
+        struct kref kref;
+        struct list_head list;
+
+        /* Video control interface */
+        __u16 uvc_version;
+        __u32 clock_frequency;
+
+        struct list_head entities;
+
+        struct uvc_video_device video;
+
+        /* Status Interrupt Endpoint */
+        struct usb_host_endpoint *int_ep;
+        struct urb *int_urb;
+        __u8 status[16];
+        struct input_dev *input;
+
+        /* Video Streaming interfaces */
+        struct list_head streaming;
+};
+
+enum uvc_handle_state {
+        UVC_HANDLE_PASSIVE      = 0,
+        UVC_HANDLE_ACTIVE       = 1,
+};
+
+struct uvc_fh {
+        struct uvc_video_device *device;
+        enum uvc_handle_state state;
+};
+
+struct uvc_driver {
+        struct usb_driver driver;
+
+        struct mutex open_mutex;        /* protects from open/disconnect race */
+
+        struct list_head devices;       /* struct uvc_device list */
+        struct list_head controls;      /* struct uvc_control_info list */
+        struct mutex ctrl_mutex;        /* protects controls and devices
+                                           lists */
+};
+
+/* ------------------------------------------------------------------------
+ * Debugging, printing and logging
+ */
+
+#define UVC_TRACE_PROBE         (1 << 0)
+#define UVC_TRACE_DESCR         (1 << 1)
+#define UVC_TRACE_CONTROL       (1 << 2)
+#define UVC_TRACE_FORMAT        (1 << 3)
+#define UVC_TRACE_CAPTURE       (1 << 4)
+#define UVC_TRACE_CALLS         (1 << 5)
+#define UVC_TRACE_IOCTL         (1 << 6)
+#define UVC_TRACE_FRAME         (1 << 7)
+#define UVC_TRACE_SUSPEND       (1 << 8)
+#define UVC_TRACE_STATUS        (1 << 9)
+
+extern unsigned int uvc_trace_param;
+
+#define uvc_trace(flag, msg...) \
+        do { \
+                if (uvc_trace_param & flag) \
+                        printk(KERN_DEBUG "uvcvideo: " msg); \
+        } while (0)
+
+#define uvc_printk(level, msg...) \
+        printk(level "uvcvideo: " msg)
+
+#define UVC_GUID_FORMAT "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-" \
+                        "%02x%02x%02x%02x%02x%02x"
+#define UVC_GUID_ARGS(guid) \
+        (guid)[3],  (guid)[2],  (guid)[1],  (guid)[0], \
+        (guid)[5],  (guid)[4], \
+        (guid)[7],  (guid)[6], \
+        (guid)[8],  (guid)[9], \
+        (guid)[10], (guid)[11], (guid)[12], \
+        (guid)[13], (guid)[14], (guid)[15]
+
+/* --------------------------------------------------------------------------
+ * Internal functions.
+ */
+
+/* Core driver */
+extern struct uvc_driver uvc_driver;
+extern void uvc_delete(struct kref *kref);
+
+/* Video buffers queue management. */
+extern void uvc_queue_init(struct uvc_video_queue *queue);
+extern int uvc_alloc_buffers(struct uvc_video_queue *queue,
+                unsigned int nbuffers, unsigned int buflength);
+extern int uvc_free_buffers(struct uvc_video_queue *queue);
+extern int uvc_query_buffer(struct uvc_video_queue *queue,
+                struct v4l2_buffer *v4l2_buf);
+extern int uvc_queue_buffer(struct uvc_video_queue *queue,
+                struct v4l2_buffer *v4l2_buf);
+extern int uvc_dequeue_buffer(struct uvc_video_queue *queue,
+                struct v4l2_buffer *v4l2_buf, int nonblocking);
+extern int uvc_queue_enable(struct uvc_video_queue *queue, int enable);
+extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect);
+extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
+                struct uvc_buffer *buf);
+extern unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
+                struct file *file, poll_table *wait);
+static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
+{
+        return queue->flags & UVC_QUEUE_STREAMING;
+}
+
+/* V4L2 interface */
+extern struct file_operations uvc_fops;
+
+/* Video */
+extern int uvc_video_init(struct uvc_video_device *video);
+extern int uvc_video_suspend(struct uvc_video_device *video);
+extern int uvc_video_resume(struct uvc_video_device *video);
+extern int uvc_video_enable(struct uvc_video_device *video, int enable);
+extern int uvc_probe_video(struct uvc_video_device *video,
+                struct uvc_streaming_control *probe);
+extern int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
+                __u8 intfnum, __u8 cs, void *data, __u16 size);
+extern int uvc_set_video_ctrl(struct uvc_video_device *video,
+                struct uvc_streaming_control *ctrl, int probe);
+
+/* Status */
+extern int uvc_status_init(struct uvc_device *dev);
+extern void uvc_status_cleanup(struct uvc_device *dev);
+extern int uvc_status_suspend(struct uvc_device *dev);
+extern int uvc_status_resume(struct uvc_device *dev);
+
+/* Controls */
+extern struct uvc_control *uvc_find_control(struct uvc_video_device *video,
+                __u32 v4l2_id, struct uvc_control_mapping **mapping);
+extern int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
+                struct v4l2_queryctrl *v4l2_ctrl);
+
+extern int uvc_ctrl_add_info(struct uvc_control_info *info);
+extern int uvc_ctrl_add_mapping(struct uvc_control_mapping *mapping);
+extern int uvc_ctrl_init_device(struct uvc_device *dev);
+extern void uvc_ctrl_cleanup_device(struct uvc_device *dev);
+extern int uvc_ctrl_resume_device(struct uvc_device *dev);
+extern void uvc_ctrl_init(void);
+
+extern int uvc_ctrl_begin(struct uvc_video_device *video);
+extern int __uvc_ctrl_commit(struct uvc_video_device *video, int rollback);
+static inline int uvc_ctrl_commit(struct uvc_video_device *video)
+{
+        return __uvc_ctrl_commit(video, 0);
+}
+static inline int uvc_ctrl_rollback(struct uvc_video_device *video)
+{
+        return __uvc_ctrl_commit(video, 1);
+}
+
+extern int uvc_ctrl_get(struct uvc_video_device *video,
+                struct v4l2_ext_control *xctrl);
+extern int uvc_ctrl_set(struct uvc_video_device *video,
+                struct v4l2_ext_control *xctrl);
+
+extern int uvc_xu_ctrl_query(struct uvc_video_device *video,
+                struct uvc_xu_control *ctrl, int set);
+
+/* Utility functions */
+extern void uvc_simplify_fraction(uint32_t *numerator, uint32_t *denominator,
+                unsigned int n_terms, unsigned int threshold);
+extern uint32_t uvc_fraction_to_interval(uint32_t numerator,
+                uint32_t denominator);
+extern struct usb_host_endpoint *uvc_find_endpoint(
+                struct usb_host_interface *alts, __u8 epaddr);
+
+/* Quirks support */
+void uvc_video_decode_isight(struct urb *urb, struct uvc_video_device *video,
+                struct uvc_buffer *buf);
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/drivers/media/video/videodev.c b/drivers/media/video/videodev.c
index 31e8af0ba278..67a661cf5219 100644
--- a/drivers/media/video/videodev.c
+++ b/drivers/media/video/videodev.c
@@ -51,12 +51,51 @@
 #define VIDEO_NUM_DEVICES       256
 #define VIDEO_NAME              "video4linux"
 
+struct std_descr {
+        v4l2_std_id std;
+        const char *descr;
+};
+
+static const struct std_descr standards[] = {
+        { V4L2_STD_NTSC,        "NTSC"      },
+        { V4L2_STD_NTSC_M,      "NTSC-M"    },
+        { V4L2_STD_NTSC_M_JP,   "NTSC-M-JP" },
+        { V4L2_STD_NTSC_M_KR,   "NTSC-M-KR" },
+        { V4L2_STD_NTSC_443,    "NTSC-443"  },
+        { V4L2_STD_PAL,         "PAL"       },
+        { V4L2_STD_PAL_BG,      "PAL-BG"    },
+        { V4L2_STD_PAL_B,       "PAL-B"     },
+        { V4L2_STD_PAL_B1,      "PAL-B1"    },
+        { V4L2_STD_PAL_G,       "PAL-G"     },
+        { V4L2_STD_PAL_H,       "PAL-H"     },
+        { V4L2_STD_PAL_I,       "PAL-I"     },
+        { V4L2_STD_PAL_DK,      "PAL-DK"    },
+        { V4L2_STD_PAL_D,       "PAL-D"     },
+        { V4L2_STD_PAL_D1,      "PAL-D1"    },
+        { V4L2_STD_PAL_K,       "PAL-K"     },
+        { V4L2_STD_PAL_M,       "PAL-M"     },
+        { V4L2_STD_PAL_N,       "PAL-N"     },
+        { V4L2_STD_PAL_Nc,      "PAL-Nc"    },
+        { V4L2_STD_PAL_60,      "PAL-60"    },
+        { V4L2_STD_SECAM,       "SECAM"     },
+        { V4L2_STD_SECAM_B,     "SECAM-B"   },
+        { V4L2_STD_SECAM_G,     "SECAM-G"   },
+        { V4L2_STD_SECAM_H,     "SECAM-H"   },
+        { V4L2_STD_SECAM_DK,    "SECAM-DK"  },
+        { V4L2_STD_SECAM_D,     "SECAM-D"   },
+        { V4L2_STD_SECAM_K,     "SECAM-K"   },
+        { V4L2_STD_SECAM_K1,    "SECAM-K1"  },
+        { V4L2_STD_SECAM_L,     "SECAM-L"   },
+        { V4L2_STD_SECAM_LC,    "SECAM-Lc"  },
+        { 0,                    "Unknown"   }
+};
+
 /* video4linux standard ID conversion to standard name
  */
-char *v4l2_norm_to_name(v4l2_std_id id)
+const char *v4l2_norm_to_name(v4l2_std_id id)
 {
-        char *name;
         u32 myid = id;
+        int i;
 
         /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
            64 bit comparations. So, on that architecture, with some gcc
@@ -64,110 +103,17 @@ char *v4l2_norm_to_name(v4l2_std_id id)
          */
         BUG_ON(myid != id);
 
-        switch (myid) {
-        case V4L2_STD_PAL:
-                name = "PAL";
-                break;
-        case V4L2_STD_PAL_BG:
-                name = "PAL-BG";
-                break;
-        case V4L2_STD_PAL_DK:
-                name = "PAL-DK";
-                break;
-        case V4L2_STD_PAL_B:
-                name = "PAL-B";
-                break;
-        case V4L2_STD_PAL_B1:
-                name = "PAL-B1";
-                break;
-        case V4L2_STD_PAL_G:
-                name = "PAL-G";
-                break;
-        case V4L2_STD_PAL_H:
-                name = "PAL-H";
-                break;
-        case V4L2_STD_PAL_I:
-                name = "PAL-I";
-                break;
-        case V4L2_STD_PAL_D:
-                name = "PAL-D";
-                break;
-        case V4L2_STD_PAL_D1:
-                name = "PAL-D1";
-                break;
-        case V4L2_STD_PAL_K:
-                name = "PAL-K";
-                break;
-        case V4L2_STD_PAL_M:
-                name = "PAL-M";
-                break;
-        case V4L2_STD_PAL_N:
-                name = "PAL-N";
-                break;
-        case V4L2_STD_PAL_Nc:
-                name = "PAL-Nc";
-                break;
-        case V4L2_STD_PAL_60:
-                name = "PAL-60";
-                break;
-        case V4L2_STD_NTSC:
-                name = "NTSC";
-                break;
-        case V4L2_STD_NTSC_M:
-                name = "NTSC-M";
-                break;
-        case V4L2_STD_NTSC_M_JP:
-                name = "NTSC-M-JP";
-                break;
-        case V4L2_STD_NTSC_443:
-                name = "NTSC-443";
-                break;
-        case V4L2_STD_NTSC_M_KR:
-                name = "NTSC-M-KR";
-                break;
-        case V4L2_STD_SECAM:
-                name = "SECAM";
-                break;
-        case V4L2_STD_SECAM_DK:
-                name = "SECAM-DK";
-                break;
-        case V4L2_STD_SECAM_B:
-                name = "SECAM-B";
-                break;
-        case V4L2_STD_SECAM_D:
-                name = "SECAM-D";
-                break;
-        case V4L2_STD_SECAM_G:
-                name = "SECAM-G";
-                break;
-        case V4L2_STD_SECAM_H:
-                name = "SECAM-H";
-                break;
-        case V4L2_STD_SECAM_K:
-                name = "SECAM-K";
-                break;
-        case V4L2_STD_SECAM_K1:
-                name = "SECAM-K1";
-                break;
-        case V4L2_STD_SECAM_L:
-                name = "SECAM-L";
-                break;
-        case V4L2_STD_SECAM_LC:
-                name = "SECAM-LC";
-                break;
-        default:
-                name = "Unknown";
-                break;
-        }
-
-        return name;
+        for (i = 0; standards[i].std; i++)
+                if (myid == standards[i].std)
+                        break;
+        return standards[i].descr;
 }
 EXPORT_SYMBOL(v4l2_norm_to_name);
 
 /* Fill in the fields of a v4l2_standard structure according to the
    'id' and 'transmission' parameters.  Returns negative on error.  */
 int v4l2_video_std_construct(struct v4l2_standard *vs,
-                             int id, char *name)
+                             int id, const char *name)
 {
         u32 index = vs->index;
 
@@ -1218,95 +1164,40 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
         case VIDIOC_ENUMSTD:
         {
                 struct v4l2_standard *p = arg;
-                v4l2_std_id id = vfd->tvnorms,curr_id=0;
-                unsigned int index = p->index,i;
-
-                if (index<0) {
-                        ret=-EINVAL;
-                        break;
-                }
-
-                /* Return norm array on a canonical way */
-                for (i=0;i<= index && id; i++) {
-                        if ( (id & V4L2_STD_PAL) == V4L2_STD_PAL) {
-                                curr_id = V4L2_STD_PAL;
-                        } else if ( (id & V4L2_STD_PAL_BG) == V4L2_STD_PAL_BG) {
-                                curr_id = V4L2_STD_PAL_BG;
-                        } else if ( (id & V4L2_STD_PAL_DK) == V4L2_STD_PAL_DK) {
-                                curr_id = V4L2_STD_PAL_DK;
-                        } else if ( (id & V4L2_STD_PAL_B) == V4L2_STD_PAL_B) {
-                                curr_id = V4L2_STD_PAL_B;
-                        } else if ( (id & V4L2_STD_PAL_B1) == V4L2_STD_PAL_B1) {
-                                curr_id = V4L2_STD_PAL_B1;
-                        } else if ( (id & V4L2_STD_PAL_G) == V4L2_STD_PAL_G) {
-                                curr_id = V4L2_STD_PAL_G;
-                        } else if ( (id & V4L2_STD_PAL_H) == V4L2_STD_PAL_H) {
-                                curr_id = V4L2_STD_PAL_H;
-                        } else if ( (id & V4L2_STD_PAL_I) == V4L2_STD_PAL_I) {
-                                curr_id = V4L2_STD_PAL_I;
-                        } else if ( (id & V4L2_STD_PAL_D) == V4L2_STD_PAL_D) {
-                                curr_id = V4L2_STD_PAL_D;
-                        } else if ( (id & V4L2_STD_PAL_D1) == V4L2_STD_PAL_D1) {
-                                curr_id = V4L2_STD_PAL_D1;
-                        } else if ( (id & V4L2_STD_PAL_K) == V4L2_STD_PAL_K) {
-                                curr_id = V4L2_STD_PAL_K;
-                        } else if ( (id & V4L2_STD_PAL_M) == V4L2_STD_PAL_M) {
-                                curr_id = V4L2_STD_PAL_M;
-                        } else if ( (id & V4L2_STD_PAL_N) == V4L2_STD_PAL_N) {
-                                curr_id = V4L2_STD_PAL_N;
-                        } else if ( (id & V4L2_STD_PAL_Nc) == V4L2_STD_PAL_Nc) {
-                                curr_id = V4L2_STD_PAL_Nc;
-                        } else if ( (id & V4L2_STD_PAL_60) == V4L2_STD_PAL_60) {
-                                curr_id = V4L2_STD_PAL_60;
-                        } else if ( (id & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
-                                curr_id = V4L2_STD_NTSC;
-                        } else if ( (id & V4L2_STD_NTSC_M) == V4L2_STD_NTSC_M) {
-                                curr_id = V4L2_STD_NTSC_M;
-                        } else if ( (id & V4L2_STD_NTSC_M_JP) == V4L2_STD_NTSC_M_JP) {
-                                curr_id = V4L2_STD_NTSC_M_JP;
-                        } else if ( (id & V4L2_STD_NTSC_443) == V4L2_STD_NTSC_443) {
-                                curr_id = V4L2_STD_NTSC_443;
-                        } else if ( (id & V4L2_STD_NTSC_M_KR) == V4L2_STD_NTSC_M_KR) {
-                                curr_id = V4L2_STD_NTSC_M_KR;
-                        } else if ( (id & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
-                                curr_id = V4L2_STD_SECAM;
-                        } else if ( (id & V4L2_STD_SECAM_DK) == V4L2_STD_SECAM_DK) {
-                                curr_id = V4L2_STD_SECAM_DK;
-                        } else if ( (id & V4L2_STD_SECAM_B) == V4L2_STD_SECAM_B) {
-                                curr_id = V4L2_STD_SECAM_B;
-                        } else if ( (id & V4L2_STD_SECAM_D) == V4L2_STD_SECAM_D) {
-                                curr_id = V4L2_STD_SECAM_D;
-                        } else if ( (id & V4L2_STD_SECAM_G) == V4L2_STD_SECAM_G) {
-                                curr_id = V4L2_STD_SECAM_G;
-                        } else if ( (id & V4L2_STD_SECAM_H) == V4L2_STD_SECAM_H) {
-                                curr_id = V4L2_STD_SECAM_H;
-                        } else if ( (id & V4L2_STD_SECAM_K) == V4L2_STD_SECAM_K) {
-                                curr_id = V4L2_STD_SECAM_K;
-                        } else if ( (id & V4L2_STD_SECAM_K1) == V4L2_STD_SECAM_K1) {
-                                curr_id = V4L2_STD_SECAM_K1;
-                        } else if ( (id & V4L2_STD_SECAM_L) == V4L2_STD_SECAM_L) {
-                                curr_id = V4L2_STD_SECAM_L;
-                        } else if ( (id & V4L2_STD_SECAM_LC) == V4L2_STD_SECAM_LC) {
-                                curr_id = V4L2_STD_SECAM_LC;
-                        } else {
+                v4l2_std_id id = vfd->tvnorms, curr_id = 0;
+                unsigned int index = p->index, i, j = 0;
+                const char *descr = "";
+
+                /* Return norm array in a canonical way */
+                for (i = 0; i <= index && id; i++) {
+                        /* last std value in the standards array is 0, so this
+                           while always ends there since (id & 0) == 0. */
+                        while ((id & standards[j].std) != standards[j].std)
+                                j++;
+                        curr_id = standards[j].std;
+                        descr = standards[j].descr;
+                        j++;
+                        if (curr_id == 0)
                                 break;
-                        }
-                        id &= ~curr_id;
+                        if (curr_id != V4L2_STD_PAL &&
+                            curr_id != V4L2_STD_SECAM &&
+                            curr_id != V4L2_STD_NTSC)
+                                id &= ~curr_id;
                 }
-                if (i<=index)
+                if (i <= index)
                         return -EINVAL;
 
-                v4l2_video_std_construct(p, curr_id,v4l2_norm_to_name(curr_id));
+                v4l2_video_std_construct(p, curr_id, descr);
                 p->index = index;
 
-                dbgarg (cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
+                dbgarg(cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
                                 "framelines=%d\n", p->index,
                                 (unsigned long long)p->id, p->name,
                                 p->frameperiod.numerator,
                                 p->frameperiod.denominator,
                                 p->framelines);
 
-                ret=0;
+                ret = 0;
                 break;
         }
         case VIDIOC_G_STD:
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index 845be1864f68..5ff9a58b6135 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -327,13 +327,14 @@ static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
         int hmax  = buf->vb.height;
         int wmax  = buf->vb.width;
         struct timeval ts;
-        char *tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
+        char *tmpbuf;
         void *vbuf = videobuf_to_vmalloc(&buf->vb);
 
-        if (!tmpbuf)
+        if (!vbuf)
                 return;
 
-        if (!vbuf)
+        tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
+        if (!tmpbuf)
                 return;
 
         for (h = 0; h < hmax; h++) {
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index 95f33e87a99c..eed211b2ac70 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -42,6 +42,7 @@
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/delay.h>
+#include <linux/clk.h>
 
 #include <asm/dma.h>
 #include <asm/io.h>
@@ -92,6 +93,8 @@ struct imxmci_host {
         unsigned char           actual_bus_width;
 
         int                     prev_cmd_code;
+
+        struct clk              *clk;
 };
 
 #define IMXMCI_PEND_IRQ_b       0
@@ -841,7 +844,7 @@ static void imxmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 /* The prescaler is 5 for PERCLK2 equal to 96MHz
                  * then 96MHz / 5 = 19.2 MHz
                  */
-                clk=imx_get_perclk2();
+                clk = clk_get_rate(host->clk);
                 prescaler=(clk+(CLK_RATE*7)/8)/CLK_RATE;
                 switch(prescaler) {
                 case 0:
@@ -994,6 +997,13 @@ static int imxmci_probe(struct platform_device *pdev)
         host->res = r;
         host->irq = irq;
 
+        host->clk = clk_get(&pdev->dev, "perclk2");
+        if (IS_ERR(host->clk)) {
+                ret = PTR_ERR(host->clk);
+                goto out;
+        }
+        clk_enable(host->clk);
+
         imx_gpio_mode(PB8_PF_SD_DAT0);
         imx_gpio_mode(PB9_PF_SD_DAT1);
         imx_gpio_mode(PB10_PF_SD_DAT2);
@@ -1017,8 +1027,8 @@ static int imxmci_probe(struct platform_device *pdev)
         host->imask = IMXMCI_INT_MASK_DEFAULT;
         MMC_INT_MASK = host->imask;
 
-
-        if(imx_dma_request_by_prio(&host->dma, DRIVER_NAME, DMA_PRIO_LOW)<0){
+        host->dma = imx_dma_request_by_prio(DRIVER_NAME, DMA_PRIO_LOW);
+        if(host->dma < 0) {
                 dev_err(mmc_dev(host->mmc), "imx_dma_request_by_prio failed\n");
                 ret = -EBUSY;
                 goto out;
@@ -1053,6 +1063,10 @@ out:
                         imx_dma_free(host->dma);
                         host->dma_allocated=0;
                 }
+                if (host->clk) {
+                        clk_disable(host->clk);
+                        clk_put(host->clk);
+                }
         }
         if (mmc)
                 mmc_free_host(mmc);
@@ -1082,6 +1096,9 @@ static int imxmci_remove(struct platform_device *pdev)
 
                 tasklet_kill(&host->tasklet);
 
+                clk_disable(host->clk);
+                clk_put(host->clk);
+
                 release_resource(host->res);
 
                 mmc_free_host(mmc);
diff --git a/drivers/mtd/maps/omap_nor.c b/drivers/mtd/maps/omap_nor.c
index c12d8056bebd..68eec6c6c517 100644
--- a/drivers/mtd/maps/omap_nor.c
+++ b/drivers/mtd/maps/omap_nor.c
@@ -60,13 +60,22 @@ struct omapflash_info {
 static void omap_set_vpp(struct map_info *map, int enable)
 {
         static int      count;
-
-        if (enable) {
-                if (count++ == 0)
-                        OMAP_EMIFS_CONFIG_REG |= OMAP_EMIFS_CONFIG_WP;
-        } else {
-                if (count && (--count == 0))
-                        OMAP_EMIFS_CONFIG_REG &= ~OMAP_EMIFS_CONFIG_WP;
+        u32 l;
+
+        if (cpu_class_is_omap1()) {
+                if (enable) {
+                        if (count++ == 0) {
+                                l = omap_readl(EMIFS_CONFIG);
+                                l |= OMAP_EMIFS_CONFIG_WP;
+                                omap_writel(l, EMIFS_CONFIG);
+                        }
+                } else {
+                        if (count && (--count == 0)) {
+                                l = omap_readl(EMIFS_CONFIG);
+                                l &= ~OMAP_EMIFS_CONFIG_WP;
+                                omap_writel(l, EMIFS_CONFIG);
+                        }
+                }
         }
 }
 
diff --git a/drivers/mtd/nand/orion_nand.c b/drivers/mtd/nand/orion_nand.c
index 59e05a1c50cf..ee2ac3948cd8 100644
--- a/drivers/mtd/nand/orion_nand.c
+++ b/drivers/mtd/nand/orion_nand.c
@@ -85,6 +85,9 @@ static int __init orion_nand_probe(struct platform_device *pdev)
         nc->cmd_ctrl = orion_nand_cmd_ctrl;
         nc->ecc.mode = NAND_ECC_SOFT;
 
+        if (board->chip_delay)
+                nc->chip_delay = board->chip_delay;
+
         if (board->width == 16)
                 nc->options |= NAND_BUSWIDTH_16;
 
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 2edda8cc7f99..aabad8ce7458 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -1768,9 +1768,10 @@ vortex_timer(unsigned long data)
         case XCVR_MII: case XCVR_NWAY:
                 {
                         ok = 1;
-                        spin_lock_bh(&vp->lock);
+                        /* Interrupts are already disabled */
+                        spin_lock(&vp->lock);
                         vortex_check_media(dev, 0);
-                        spin_unlock_bh(&vp->lock);
+                        spin_unlock(&vp->lock);
                 }
                 break;
           default:                                      /* Other media types handled by Tx timeouts. */
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index f4182cfffe9d..45a41b597da9 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -217,7 +217,7 @@ config MII
 
 config MACB
         tristate "Atmel MACB support"
-        depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91CAP9
+        depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91SAM9G20 || ARCH_AT91CAP9
         select PHYLIB
         help
           The Atmel MACB ethernet interface is found on many AT32 and AT91
diff --git a/drivers/net/arm/etherh.c b/drivers/net/arm/etherh.c
index 00081d2b9cd5..e9d15eccad08 100644
--- a/drivers/net/arm/etherh.c
+++ b/drivers/net/arm/etherh.c
@@ -647,7 +647,7 @@ etherh_probe(struct expansion_card *ec, const struct ecard_id *id)
         struct ei_device *ei_local;
         struct net_device *dev;
         struct etherh_priv *eh;
-        int i, ret;
+        int ret;
         DECLARE_MAC_BUF(mac);
 
         etherh_banner();
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index f3cba5e24ec5..1037b1332312 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -1803,6 +1803,8 @@ static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
         if (rx->prev->skb) {
                 struct rfd *prev_rfd = (struct rfd *)rx->prev->skb->data;
                 put_unaligned_le32(rx->dma_addr, &prev_rfd->link);
+                pci_dma_sync_single_for_device(nic->pdev, rx->prev->dma_addr,
+                        sizeof(struct rfd), PCI_DMA_TODEVICE);
         }
 
         return 0;
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index 701531e72e7b..a3f6a9c72ec8 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -347,7 +347,7 @@ e1000_set_tso(struct net_device *netdev, u32 data)
         else
                 netdev->features &= ~NETIF_F_TSO;
 
-        if (data)
+        if (data && (adapter->hw.mac_type > e1000_82547_rev_2))
                 netdev->features |= NETIF_F_TSO6;
         else
                 netdev->features &= ~NETIF_F_TSO6;
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index cab1835173cd..648a87bbf467 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -2535,7 +2535,8 @@ void e1000e_down(struct e1000_adapter *adapter)
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
 
-        e1000e_reset(adapter);
+        if (!pci_channel_offline(adapter->pdev))
+                e1000e_reset(adapter);
         e1000_clean_tx_ring(adapter);
         e1000_clean_rx_ring(adapter);
 
diff --git a/drivers/net/hamradio/dmascc.c b/drivers/net/hamradio/dmascc.c
index 0b94833e23f7..e8cfadefa4b6 100644
--- a/drivers/net/hamradio/dmascc.c
+++ b/drivers/net/hamradio/dmascc.c
@@ -1077,8 +1077,6 @@ static inline void rx_off(struct scc_priv *priv)
 
 static void start_timer(struct scc_priv *priv, int t, int r15)
 {
-        unsigned long flags;
-
         outb(priv->tmr_mode, priv->tmr_ctrl);
         if (t == 0) {
                 tm_isr(priv);
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index ae398f04c7b4..e79a26a886c8 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -718,7 +718,8 @@ void igb_down(struct igb_adapter *adapter)
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
 
-        igb_reset(adapter);
+        if (!pci_channel_offline(adapter->pdev))
+                igb_reset(adapter);
         igb_clean_all_tx_rings(adapter);
         igb_clean_all_rx_rings(adapter);
 }
diff --git a/drivers/net/ipg.c b/drivers/net/ipg.c
index 679a0826780e..2c03f4e2ccc4 100644
--- a/drivers/net/ipg.c
+++ b/drivers/net/ipg.c
@@ -1271,7 +1271,7 @@ static void ipg_nic_rx_with_end(struct net_device *dev,
 
                         framelen = le64_to_cpu(rxfd->rfs) & IPG_RFS_RXFRAMELEN;
 
-                        endframeLen = framelen - jumbo->current_size;
+                        endframelen = framelen - jumbo->current_size;
                         /*
                         if (framelen > IPG_RXFRAG_SIZE)
                                 framelen=IPG_RXFRAG_SIZE;
@@ -1279,8 +1279,8 @@ static void ipg_nic_rx_with_end(struct net_device *dev,
                         if (framelen > IPG_RXSUPPORT_SIZE)
                                 dev_kfree_skb_irq(jumbo->skb);
                         else {
-                                memcpy(skb_put(jumbo->skb, endframeLen),
-                                       skb->data, endframeLen);
+                                memcpy(skb_put(jumbo->skb, endframelen),
+                                       skb->data, endframelen);
 
                                 jumbo->skb->protocol =
                                     eth_type_trans(jumbo->skb, dev);
@@ -1352,16 +1352,16 @@ static int ipg_nic_rx(struct net_device *dev)
 
                 switch (ipg_nic_rx_check_frame_type(dev)) {
                 case FRAME_WITH_START_WITH_END:
-                        ipg_nic_rx_with_start_and_end(dev, tp, rxfd, entry);
+                        ipg_nic_rx_with_start_and_end(dev, sp, rxfd, entry);
                         break;
                 case FRAME_WITH_START:
-                        ipg_nic_rx_with_start(dev, tp, rxfd, entry);
+                        ipg_nic_rx_with_start(dev, sp, rxfd, entry);
                         break;
                 case FRAME_WITH_END:
-                        ipg_nic_rx_with_end(dev, tp, rxfd, entry);
+                        ipg_nic_rx_with_end(dev, sp, rxfd, entry);
                         break;
                 case FRAME_NO_START_NO_END:
-                        ipg_nic_rx_no_start_no_end(dev, tp, rxfd, entry);
+                        ipg_nic_rx_no_start_no_end(dev, sp, rxfd, entry);
                         break;
                 }
         }
@@ -1808,7 +1808,7 @@ static int ipg_nic_open(struct net_device *dev)
         /* initialize JUMBO Frame control variable */
         sp->jumbo.found_start = 0;
         sp->jumbo.current_size = 0;
-        sp->jumbo.skb = 0;
+        sp->jumbo.skb = NULL;
         dev->mtu = IPG_TXFRAG_SIZE;
 #endif
 
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 7b859220c255..8f0460901153 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1969,7 +1969,8 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
         netif_carrier_off(netdev);
         netif_stop_queue(netdev);
 
-        ixgbe_reset(adapter);
+        if (!pci_channel_offline(adapter->pdev))
+                ixgbe_reset(adapter);
         ixgbe_clean_all_tx_rings(adapter);
         ixgbe_clean_all_rx_rings(adapter);
 
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 6797ed069f1f..63cd67b931e7 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -71,14 +71,18 @@ static irqreturn_t netxen_intr(int irq, void *data);
 static irqreturn_t netxen_msi_intr(int irq, void *data);
 
 /*  PCI Device ID Table  */
+#define ENTRY(device) \
+        {PCI_DEVICE(0x4040, (device)), \
+        .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
+
 static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(0x4040, 0x0001), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0002), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0003), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0004), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0005), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0024), PCI_DEVICE_CLASS(0x020000, ~0)},
-        {PCI_DEVICE(0x4040, 0x0025), PCI_DEVICE_CLASS(0x020000, ~0)},
+        ENTRY(0x0001),
+        ENTRY(0x0002),
+        ENTRY(0x0003),
+        ENTRY(0x0004),
+        ENTRY(0x0005),
+        ENTRY(0x0024),
+        ENTRY(0x0025),
         {0,}
 };
 
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index ce95c5d168fe..70d012e90dcf 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -525,12 +525,14 @@ static int axnet_open(struct net_device *dev)
     int ret;
     axnet_dev_t *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
+    unsigned int nic_base = dev->base_addr;
     
     DEBUG(2, "axnet_open('%s')\n", dev->name);
 
     if (!pcmcia_dev_present(link))
         return -ENODEV;
 
+    outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
     ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, "axnet_cs", dev);
     if (ret)
             return ret;
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index fd8158a86f64..2d4c4ad89b8d 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -969,6 +969,7 @@ static int pcnet_open(struct net_device *dev)
     int ret;
     pcnet_dev_t *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
+    unsigned int nic_base = dev->base_addr;
 
     DEBUG(2, "pcnet_open('%s')\n", dev->name);
 
@@ -976,6 +977,8 @@ static int pcnet_open(struct net_device *dev)
         return -ENODEV;
 
     set_misc_reg(dev);
+
+    outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
     ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, dev_info, dev);
     if (ret)
             return ret;
diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index b7f7b2227d56..bccee68bd48a 100644
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -3701,7 +3701,9 @@ static int ql_cycle_adapter(struct ql3_adapter *qdev, int reset)
                 printk(KERN_ERR PFX
                                 "%s: Driver up/down cycle failed, "
                                 "closing device\n",qdev->ndev->name);
+                rtnl_lock();
                 dev_close(qdev->ndev);
+                rtnl_unlock();
                 return -1;
         }
         return 0;
diff --git a/drivers/net/r6040.c b/drivers/net/r6040.c
index 858b191517b3..504a48ff73c8 100644
--- a/drivers/net/r6040.c
+++ b/drivers/net/r6040.c
@@ -273,7 +273,7 @@ static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring,
         dma_addr_t mapping = desc_dma;
 
         while (size-- > 0) {
-                mapping += sizeof(sizeof(*desc));
+                mapping += sizeof(*desc);
                 desc->ndesc = cpu_to_le32(mapping);
                 desc->vndescp = desc + 1;
                 desc++;
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index b5c1e663417d..ae7b697456b4 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -2625,9 +2625,7 @@ static int fill_rx_buffers(struct ring_info *ring)
                         rxdp1->Buffer0_ptr = pci_map_single
                             (ring->pdev, skb->data, size - NET_IP_ALIGN,
                                 PCI_DMA_FROMDEVICE);
-                        if( (rxdp1->Buffer0_ptr == 0) ||
-                                (rxdp1->Buffer0_ptr ==
-                                DMA_ERROR_CODE))
+                        if(pci_dma_mapping_error(rxdp1->Buffer0_ptr))
                                 goto pci_map_failed;
 
                         rxdp->Control_2 =
@@ -2657,6 +2655,7 @@ static int fill_rx_buffers(struct ring_info *ring)
                         skb->data = (void *) (unsigned long)tmp;
                         skb_reset_tail_pointer(skb);
 
+                        /* AK: check is wrong. 0 can be valid dma address */
                         if (!(rxdp3->Buffer0_ptr))
                                 rxdp3->Buffer0_ptr =
                                    pci_map_single(ring->pdev, ba->ba_0,
@@ -2665,8 +2664,7 @@ static int fill_rx_buffers(struct ring_info *ring)
                                 pci_dma_sync_single_for_device(ring->pdev,
                                 (dma_addr_t) rxdp3->Buffer0_ptr,
                                     BUF0_LEN, PCI_DMA_FROMDEVICE);
-                        if( (rxdp3->Buffer0_ptr == 0) ||
-                                (rxdp3->Buffer0_ptr == DMA_ERROR_CODE))
+                        if (pci_dma_mapping_error(rxdp3->Buffer0_ptr))
                                 goto pci_map_failed;
 
                         rxdp->Control_2 = SET_BUFFER0_SIZE_3(BUF0_LEN);
@@ -2681,18 +2679,17 @@ static int fill_rx_buffers(struct ring_info *ring)
                                 (ring->pdev, skb->data, ring->mtu + 4,
                                                 PCI_DMA_FROMDEVICE);
 
-                                if( (rxdp3->Buffer2_ptr == 0) ||
-                                        (rxdp3->Buffer2_ptr == DMA_ERROR_CODE))
+                                if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
                                         goto pci_map_failed;
 
+                                /* AK: check is wrong */
                                 if (!rxdp3->Buffer1_ptr)
                                         rxdp3->Buffer1_ptr =
                                                 pci_map_single(ring->pdev,
                                                 ba->ba_1, BUF1_LEN,
                                                 PCI_DMA_FROMDEVICE);
 
-                                if( (rxdp3->Buffer1_ptr == 0) ||
-                                        (rxdp3->Buffer1_ptr == DMA_ERROR_CODE)) {
+                                if (pci_dma_mapping_error(rxdp3->Buffer1_ptr)) {
                                         pci_unmap_single
                                                 (ring->pdev,
                                                 (dma_addr_t)(unsigned long)
@@ -4264,16 +4261,14 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev)
                 txdp->Buffer_Pointer = pci_map_single(sp->pdev,
                                         fifo->ufo_in_band_v,
                                         sizeof(u64), PCI_DMA_TODEVICE);
-                if((txdp->Buffer_Pointer == 0) ||
-                        (txdp->Buffer_Pointer == DMA_ERROR_CODE))
+                if (pci_dma_mapping_error(txdp->Buffer_Pointer))
                         goto pci_map_failed;
                 txdp++;
         }
 
         txdp->Buffer_Pointer = pci_map_single
             (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE);
-        if((txdp->Buffer_Pointer == 0) ||
-                (txdp->Buffer_Pointer == DMA_ERROR_CODE))
+        if (pci_dma_mapping_error(txdp->Buffer_Pointer))
                 goto pci_map_failed;
 
         txdp->Host_Control = (unsigned long) skb;
@@ -6884,10 +6879,8 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                                 pci_map_single( sp->pdev, (*skb)->data,
                                         size - NET_IP_ALIGN,
                                         PCI_DMA_FROMDEVICE);
-                        if( (rxdp1->Buffer0_ptr == 0) ||
-                                (rxdp1->Buffer0_ptr == DMA_ERROR_CODE)) {
+                        if (pci_dma_mapping_error(rxdp1->Buffer0_ptr))
                                 goto memalloc_failed;
-                        }
                         rxdp->Host_Control = (unsigned long) (*skb);
                 }
         } else if ((sp->rxd_mode == RXD_MODE_3B) && (rxdp->Host_Control == 0)) {
@@ -6913,15 +6906,12 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                                 pci_map_single(sp->pdev, (*skb)->data,
                                                dev->mtu + 4,
                                                PCI_DMA_FROMDEVICE);
-                        if( (rxdp3->Buffer2_ptr == 0) ||
-                                (rxdp3->Buffer2_ptr == DMA_ERROR_CODE)) {
+                        if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
                                 goto memalloc_failed;
-                        }
                         rxdp3->Buffer0_ptr = *temp0 =
                                 pci_map_single( sp->pdev, ba->ba_0, BUF0_LEN,
                                                 PCI_DMA_FROMDEVICE);
-                        if( (rxdp3->Buffer0_ptr == 0) ||
-                                (rxdp3->Buffer0_ptr == DMA_ERROR_CODE)) {
+                        if (pci_dma_mapping_error(rxdp3->Buffer0_ptr)) {
                                 pci_unmap_single (sp->pdev,
                                         (dma_addr_t)rxdp3->Buffer2_ptr,
                                         dev->mtu + 4, PCI_DMA_FROMDEVICE);
@@ -6933,8 +6923,7 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                         rxdp3->Buffer1_ptr = *temp1 =
                                 pci_map_single(sp->pdev, ba->ba_1, BUF1_LEN,
                                                 PCI_DMA_FROMDEVICE);
-                        if( (rxdp3->Buffer1_ptr == 0) ||
-                                (rxdp3->Buffer1_ptr == DMA_ERROR_CODE)) {
+                        if (pci_dma_mapping_error(rxdp3->Buffer1_ptr)) {
                                 pci_unmap_single (sp->pdev,
                                         (dma_addr_t)rxdp3->Buffer0_ptr,
                                         BUF0_LEN, PCI_DMA_FROMDEVICE);
diff --git a/drivers/net/s2io.h b/drivers/net/s2io.h
index 4706f7f9acb6..1827b6686c98 100644
--- a/drivers/net/s2io.h
+++ b/drivers/net/s2io.h
@@ -75,10 +75,6 @@ static int debug_level = ERR_DBG;
 /* DEBUG message print. */
 #define DBG_PRINT(dbg_level, args...)  if(!(debug_level<dbg_level)) printk(args)
 
-#ifndef DMA_ERROR_CODE
-#define DMA_ERROR_CODE          (~(dma_addr_t)0x0)
-#endif
-
 /* Protocol assist features of the NIC */
 #define L3_CKSUM_OK 0xFFFF
 #define L4_CKSUM_OK 0xFFFF
diff --git a/drivers/net/tc35815.c b/drivers/net/tc35815.c
index 10e4e85da3fc..b07b8cbadeaf 100644
--- a/drivers/net/tc35815.c
+++ b/drivers/net/tc35815.c
@@ -1394,6 +1394,7 @@ tc35815_open(struct net_device *dev)
         tc35815_chip_init(dev);
         spin_unlock_irq(&lp->lock);
 
+        netif_carrier_off(dev);
         /* schedule a link state check */
         phy_start(lp->phy_dev);
 
@@ -1735,7 +1736,6 @@ tc35815_rx(struct net_device *dev)
                         skb = lp->rx_skbs[cur_bd].skb;
                         prefetch(skb->data);
                         lp->rx_skbs[cur_bd].skb = NULL;
-                        lp->fbl_count--;
                         pci_unmap_single(lp->pci_dev,
                                          lp->rx_skbs[cur_bd].skb_dma,
                                          RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
@@ -1791,6 +1791,7 @@ tc35815_rx(struct net_device *dev)
 #ifdef TC35815_USE_PACKEDBUFFER
                         while (lp->fbl_curid != id)
 #else
+                        lp->fbl_count--;
                         while (lp->fbl_count < RX_BUF_NUM)
 #endif
                         {
@@ -2453,6 +2454,7 @@ static int tc35815_resume(struct pci_dev *pdev)
                 return 0;
         pci_set_power_state(pdev, PCI_D0);
         tc35815_restart(dev);
+        netif_carrier_off(dev);
         if (lp->phy_dev)
                 phy_start(lp->phy_dev);
         netif_device_attach(dev);
diff --git a/drivers/net/wan/x25_asy.c b/drivers/net/wan/x25_asy.c
index 249e18053d5f..069f8bb0a99f 100644
--- a/drivers/net/wan/x25_asy.c
+++ b/drivers/net/wan/x25_asy.c
@@ -32,6 +32,7 @@
 #include <linux/x25.h>
 #include <linux/lapb.h>
 #include <linux/init.h>
+#include <linux/rtnetlink.h>
 #include "x25_asy.h"
 
 #include <net/x25device.h>
@@ -601,8 +602,10 @@ static void x25_asy_close_tty(struct tty_struct *tty)
         if (!sl || sl->magic != X25_ASY_MAGIC)
                 return;
 
+        rtnl_lock();
         if (sl->dev->flags & IFF_UP)
                 dev_close(sl->dev);
+        rtnl_unlock();
 
         tty->disc_data = NULL;
         sl->tty = NULL;
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 36a9c42df835..76f4c7bad8b8 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -72,6 +72,9 @@ static void b43_led_brightness_set(struct led_classdev *led_dev,
         struct b43_wldev *dev = led->dev;
         bool radio_enabled;
 
+        if (unlikely(b43_status(dev) < B43_STAT_INITIALIZED))
+                return;
+
         /* Checking the radio-enabled status here is slightly racy,
          * but we want to avoid the locking overhead and we don't care
          * whether the LED has the wrong state for a second. */
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index fa4b0d8b74a2..a70827793086 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2883,12 +2883,11 @@ static int b43_op_tx(struct ieee80211_hw *hw,
 
         if (unlikely(skb->len < 2 + 2 + 6)) {
                 /* Too short, this can't be a valid frame. */
-                dev_kfree_skb_any(skb);
-                return NETDEV_TX_OK;
+                goto drop_packet;
         }
         B43_WARN_ON(skb_shinfo(skb)->nr_frags);
         if (unlikely(!dev))
-                return NETDEV_TX_BUSY;
+                goto drop_packet;
 
         /* Transmissions on seperate queues can run concurrently. */
         read_lock_irqsave(&wl->tx_lock, flags);
@@ -2904,7 +2903,12 @@ static int b43_op_tx(struct ieee80211_hw *hw,
         read_unlock_irqrestore(&wl->tx_lock, flags);
 
         if (unlikely(err))
-                return NETDEV_TX_BUSY;
+                goto drop_packet;
+        return NETDEV_TX_OK;
+
+drop_packet:
+        /* We can not transmit this packet. Drop it. */
+        dev_kfree_skb_any(skb);
         return NETDEV_TX_OK;
 }
 
diff --git a/drivers/net/wireless/b43legacy/dma.c b/drivers/net/wireless/b43legacy/dma.c
index c990f87b107a..93ddc1cbcc8b 100644
--- a/drivers/net/wireless/b43legacy/dma.c
+++ b/drivers/net/wireless/b43legacy/dma.c
@@ -876,6 +876,7 @@ struct b43legacy_dmaring *b43legacy_setup_dmaring(struct b43legacy_wldev *dev,
         if (!ring)
                 goto out;
         ring->type = type;
+        ring->dev = dev;
 
         nr_slots = B43legacy_RXRING_SLOTS;
         if (for_tx)
@@ -922,7 +923,6 @@ struct b43legacy_dmaring *b43legacy_setup_dmaring(struct b43legacy_wldev *dev,
                                  DMA_TO_DEVICE);
         }
 
-        ring->dev = dev;
         ring->nr_slots = nr_slots;
         ring->mmio_base = b43legacy_dmacontroller_base(type, controller_index);
         ring->index = controller_index;
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index 204077c13870..3e612d0a13e8 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -2378,8 +2378,10 @@ static int b43legacy_op_tx(struct ieee80211_hw *hw,
         } else
                 err = b43legacy_dma_tx(dev, skb, ctl);
 out:
-        if (unlikely(err))
-                return NETDEV_TX_BUSY;
+        if (unlikely(err)) {
+                /* Drop the packet. */
+                dev_kfree_skb_any(skb);
+        }
         return NETDEV_TX_OK;
 }
 
diff --git a/drivers/net/wireless/hostap/hostap_80211_rx.c b/drivers/net/wireless/hostap/hostap_80211_rx.c
index 4fd73809602e..020f450e9dba 100644
--- a/drivers/net/wireless/hostap/hostap_80211_rx.c
+++ b/drivers/net/wireless/hostap/hostap_80211_rx.c
@@ -64,7 +64,7 @@ int prism2_rx_80211(struct net_device *dev, struct sk_buff *skb,
         int hdrlen, phdrlen, head_need, tail_need;
         u16 fc;
         int prism_header, ret;
-        struct ieee80211_hdr_4addr *hdr;
+        struct ieee80211_hdr_4addr *fhdr;
 
         iface = netdev_priv(dev);
         local = iface->local;
@@ -83,8 +83,8 @@ int prism2_rx_80211(struct net_device *dev, struct sk_buff *skb,
                 phdrlen = 0;
         }
 
-        hdr = (struct ieee80211_hdr_4addr *) skb->data;
-        fc = le16_to_cpu(hdr->frame_ctl);
+        fhdr = (struct ieee80211_hdr_4addr *) skb->data;
+        fc = le16_to_cpu(fhdr->frame_ctl);
 
         if (type == PRISM2_RX_MGMT && (fc & IEEE80211_FCTL_VERS)) {
                 printk(KERN_DEBUG "%s: dropped management frame with header "
@@ -551,7 +551,7 @@ hostap_rx_frame_wds(local_info_t *local, struct ieee80211_hdr_4addr *hdr,
              hdr->addr1[2] != 0xff || hdr->addr1[3] != 0xff ||
              hdr->addr1[4] != 0xff || hdr->addr1[5] != 0xff)) {
                 /* RA (or BSSID) is not ours - drop */
-                PDEBUG(DEBUG_EXTRA, "%s: received WDS frame with "
+                PDEBUG(DEBUG_EXTRA2, "%s: received WDS frame with "
                        "not own or broadcast %s=%s\n",
                        local->dev->name,
                        fc & IEEE80211_FCTL_FROMDS ? "RA" : "BSSID",
diff --git a/drivers/net/wireless/hostap/hostap_ap.c b/drivers/net/wireless/hostap/hostap_ap.c
index 0acd9589c48c..ab981afd481d 100644
--- a/drivers/net/wireless/hostap/hostap_ap.c
+++ b/drivers/net/wireless/hostap/hostap_ap.c
@@ -1930,7 +1930,7 @@ static void handle_pspoll(local_info_t *local,
                 PDEBUG(DEBUG_PS, "   PSPOLL and AID[15:14] not set\n");
                 return;
         }
-        aid &= ~BIT(15) & ~BIT(14);
+        aid &= ~(BIT(15) | BIT(14));
         if (aid == 0 || aid > MAX_AID_TABLE_SIZE) {
                 PDEBUG(DEBUG_PS, "   invalid aid=%d\n", aid);
                 return;
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index ed4317a17cbb..80039a0ae027 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -533,10 +533,10 @@ static void prism2_detach(struct pcmcia_device *link)
 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 
 #define CFG_CHECK2(fn, retf) \
-do { int ret = (retf); \
-if (ret != 0) { \
-        PDEBUG(DEBUG_EXTRA, "CardServices(" #fn ") returned %d\n", ret); \
-        cs_error(link, fn, ret); \
+do { int _ret = (retf); \
+if (_ret != 0) { \
+        PDEBUG(DEBUG_EXTRA, "CardServices(" #fn ") returned %d\n", _ret); \
+        cs_error(link, fn, _ret); \
         goto next_entry; \
 } \
 } while (0)
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index cdf90c40f11b..936f52e3d95c 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -2835,7 +2835,7 @@ static void hostap_passive_scan(unsigned long data)
 {
         local_info_t *local = (local_info_t *) data;
         struct net_device *dev = local->dev;
-        u16 channel;
+        u16 chan;
 
         if (local->passive_scan_interval <= 0)
                 return;
@@ -2872,11 +2872,11 @@ static void hostap_passive_scan(unsigned long data)
 
                 printk(KERN_DEBUG "%s: passive scan channel %d\n",
                        dev->name, local->passive_scan_channel);
-                channel = local->passive_scan_channel;
+                chan = local->passive_scan_channel;
                 local->passive_scan_state = PASSIVE_SCAN_WAIT;
                 local->passive_scan_timer.expires = jiffies + HZ / 10;
         } else {
-                channel = local->channel;
+                chan = local->channel;
                 local->passive_scan_state = PASSIVE_SCAN_LISTEN;
                 local->passive_scan_timer.expires = jiffies +
                         local->passive_scan_interval * HZ;
@@ -2884,9 +2884,9 @@ static void hostap_passive_scan(unsigned long data)
 
         if (hfa384x_cmd_callback(dev, HFA384X_CMDCODE_TEST |
                                  (HFA384X_TEST_CHANGE_CHANNEL << 8),
-                                 channel, NULL, 0))
+                                 chan, NULL, 0))
                 printk(KERN_ERR "%s: passive scan channel set %d "
-                       "failed\n", dev->name, channel);
+                       "failed\n", dev->name, chan);
 
         add_timer(&local->passive_scan_timer);
 }
diff --git a/drivers/net/wireless/hostap/hostap_main.c b/drivers/net/wireless/hostap/hostap_main.c
index f7aec9309d04..a38e85f334df 100644
--- a/drivers/net/wireless/hostap/hostap_main.c
+++ b/drivers/net/wireless/hostap/hostap_main.c
@@ -594,7 +594,8 @@ void hostap_dump_tx_header(const char *name, const struct hfa384x_tx_frame *tx)
 }
 
 
-int hostap_80211_header_parse(const struct sk_buff *skb, unsigned char *haddr)
+static int hostap_80211_header_parse(const struct sk_buff *skb,
+                                     unsigned char *haddr)
 {
         struct hostap_interface *iface = netdev_priv(skb->dev);
         local_info_t *local = iface->local;
@@ -857,7 +858,6 @@ const struct header_ops hostap_80211_ops = {
         .rebuild        = eth_rebuild_header,
         .cache          = eth_header_cache,
         .cache_update   = eth_header_cache_update,
-
         .parse          = hostap_80211_header_parse,
 };
 EXPORT_SYMBOL(hostap_80211_ops);
@@ -1150,7 +1150,6 @@ EXPORT_SYMBOL(hostap_set_roaming);
 EXPORT_SYMBOL(hostap_set_auth_algs);
 EXPORT_SYMBOL(hostap_dump_rx_header);
 EXPORT_SYMBOL(hostap_dump_tx_header);
-EXPORT_SYMBOL(hostap_80211_header_parse);
 EXPORT_SYMBOL(hostap_80211_get_hdrlen);
 EXPORT_SYMBOL(hostap_get_stats);
 EXPORT_SYMBOL(hostap_setup_dev);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 13925b627e3b..b1b3c523185d 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -2227,7 +2227,10 @@ static int iwl3945_scan_initiate(struct iwl3945_priv *priv)
         }
 
         IWL_DEBUG_INFO("Starting scan...\n");
-        priv->scan_bands = 2;
+        if (priv->cfg->sku & IWL_SKU_G)
+                priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ);
+        if (priv->cfg->sku & IWL_SKU_A)
+                priv->scan_bands |= BIT(IEEE80211_BAND_5GHZ);
         set_bit(STATUS_SCANNING, &priv->status);
         priv->scan_start = jiffies;
         priv->scan_pass_start = priv->scan_start;
@@ -3352,13 +3355,18 @@ static void iwl3945_rx_scan_complete_notif(struct iwl3945_priv *priv,
         cancel_delayed_work(&priv->scan_check);
 
         IWL_DEBUG_INFO("Scan pass on %sGHz took %dms\n",
-                       (priv->scan_bands == 2) ? "2.4" : "5.2",
+                       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
+                                                        "2.4" : "5.2",
                        jiffies_to_msecs(elapsed_jiffies
                                         (priv->scan_pass_start, jiffies)));
 
-        /* Remove this scanned band from the list
-         * of pending bands to scan */
-        priv->scan_bands--;
+        /* Remove this scanned band from the list of pending
+         * bands to scan, band G precedes A in order of scanning
+         * as seen in iwl3945_bg_request_scan */
+        if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ))
+                priv->scan_bands &= ~BIT(IEEE80211_BAND_2GHZ);
+        else if (priv->scan_bands &  BIT(IEEE80211_BAND_5GHZ))
+                priv->scan_bands &= ~BIT(IEEE80211_BAND_5GHZ);
 
         /* If a request to abort was given, or the scan did not succeed
          * then we reset the scan state machine and terminate,
@@ -4972,7 +4980,7 @@ static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
 
                 ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
                 if (!is_channel_valid(ch_info)) {
-                        IWL_DEBUG_SCAN("Channel %d is INVALID for this SKU.\n",
+                        IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
                                        scan_ch->channel);
                         continue;
                 }
@@ -6315,21 +6323,16 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
 
         /* flags + rate selection */
 
-        switch (priv->scan_bands) {
-        case 2:
+        if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
                 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
                 scan->tx_cmd.rate = IWL_RATE_1M_PLCP;
                 scan->good_CRC_th = 0;
                 band = IEEE80211_BAND_2GHZ;
-                break;
-
-        case 1:
+        } else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
                 scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
                 scan->good_CRC_th = IWL_GOOD_CRC_TH;
                 band = IEEE80211_BAND_5GHZ;
-                break;
-
-        default:
+        } else {
                 IWL_WARNING("Invalid scan band count\n");
                 goto done;
         }
@@ -6770,7 +6773,7 @@ static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *co
         ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
                                            conf->channel->hw_value);
         if (!is_channel_valid(ch_info)) {
-                IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this SKU.\n",
+                IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
                                conf->channel->hw_value, conf->channel->band);
                 IWL_DEBUG_MAC80211("leave - invalid channel\n");
                 spin_unlock_irqrestore(&priv->lock, flags);
diff --git a/drivers/net/wireless/iwlwifi/iwl4965-base.c b/drivers/net/wireless/iwlwifi/iwl4965-base.c
index 883b42f7e998..5ed16ce78468 100644
--- a/drivers/net/wireless/iwlwifi/iwl4965-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl4965-base.c
@@ -1774,7 +1774,10 @@ static int iwl4965_scan_initiate(struct iwl_priv *priv)
         }
 
         IWL_DEBUG_INFO("Starting scan...\n");
-        priv->scan_bands = 2;
+        if (priv->cfg->sku & IWL_SKU_G)
+                priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ);
+        if (priv->cfg->sku & IWL_SKU_A)
+                priv->scan_bands |= BIT(IEEE80211_BAND_5GHZ);
         set_bit(STATUS_SCANNING, &priv->status);
         priv->scan_start = jiffies;
         priv->scan_pass_start = priv->scan_start;
@@ -3023,8 +3026,9 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv,
 
         IWL_DEBUG_TX_REPLY("Tx queue reclaim %d\n", index);
         if (index != -1) {
-                int freed = iwl4965_tx_queue_reclaim(priv, txq_id, index);
 #ifdef CONFIG_IWL4965_HT
+                int freed = iwl4965_tx_queue_reclaim(priv, txq_id, index);
+
                 if (tid != MAX_TID_COUNT)
                         priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
                 if (iwl4965_queue_space(&txq->q) > txq->q.low_mark &&
@@ -3276,13 +3280,18 @@ static void iwl4965_rx_scan_complete_notif(struct iwl_priv *priv,
         cancel_delayed_work(&priv->scan_check);
 
         IWL_DEBUG_INFO("Scan pass on %sGHz took %dms\n",
-                       (priv->scan_bands == 2) ? "2.4" : "5.2",
+                       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
+                                                "2.4" : "5.2",
                        jiffies_to_msecs(elapsed_jiffies
                                         (priv->scan_pass_start, jiffies)));
 
-        /* Remove this scanned band from the list
-         * of pending bands to scan */
-        priv->scan_bands--;
+        /* Remove this scanned band from the list of pending
+         * bands to scan, band G precedes A in order of scanning
+         * as seen in iwl_bg_request_scan */
+        if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ))
+                priv->scan_bands &= ~BIT(IEEE80211_BAND_2GHZ);
+        else if (priv->scan_bands &  BIT(IEEE80211_BAND_5GHZ))
+                priv->scan_bands &= ~BIT(IEEE80211_BAND_5GHZ);
 
         /* If a request to abort was given, or the scan did not succeed
          * then we reset the scan state machine and terminate,
@@ -3292,7 +3301,7 @@ static void iwl4965_rx_scan_complete_notif(struct iwl_priv *priv,
                 clear_bit(STATUS_SCAN_ABORTING, &priv->status);
         } else {
                 /* If there are more bands on this scan pass reschedule */
-                if (priv->scan_bands > 0)
+                if (priv->scan_bands)
                         goto reschedule;
         }
 
@@ -4635,10 +4644,9 @@ static int iwl4965_get_channels_for_scan(struct iwl_priv *priv,
 
                 scan_ch->channel = ieee80211_frequency_to_channel(channels[i].center_freq);
 
-                ch_info = iwl_get_channel_info(priv, band,
-                                         scan_ch->channel);
+                ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
                 if (!is_channel_valid(ch_info)) {
-                        IWL_DEBUG_SCAN("Channel %d is INVALID for this SKU.\n",
+                        IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
                                        scan_ch->channel);
                         continue;
                 }
@@ -5830,8 +5838,7 @@ static void iwl4965_bg_request_scan(struct work_struct *data)
         scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 
 
-        switch (priv->scan_bands) {
-        case 2:
+        if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
                 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
                 scan->tx_cmd.rate_n_flags =
                                 iwl4965_hw_set_rate_n_flags(IWL_RATE_1M_PLCP,
@@ -5839,17 +5846,13 @@ static void iwl4965_bg_request_scan(struct work_struct *data)
 
                 scan->good_CRC_th = 0;
                 band = IEEE80211_BAND_2GHZ;
-                break;
-
-        case 1:
+        } else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
                 scan->tx_cmd.rate_n_flags =
                                 iwl4965_hw_set_rate_n_flags(IWL_RATE_6M_PLCP,
                                 RATE_MCS_ANT_B_MSK);
                 scan->good_CRC_th = IWL_GOOD_CRC_TH;
                 band = IEEE80211_BAND_5GHZ;
-                break;
-
-        default:
+        } else {
                 IWL_WARNING("Invalid scan band count\n");
                 goto done;
         }
diff --git a/drivers/net/wireless/prism54/islpci_eth.c b/drivers/net/wireless/prism54/islpci_eth.c
index 762e85bef55d..e43bae97ed8f 100644
--- a/drivers/net/wireless/prism54/islpci_eth.c
+++ b/drivers/net/wireless/prism54/islpci_eth.c
@@ -290,7 +290,7 @@ islpci_monitor_rx(islpci_private *priv, struct sk_buff **skb)
 
                 avs->version = cpu_to_be32(P80211CAPTURE_VERSION);
                 avs->length = cpu_to_be32(sizeof (struct avs_80211_1_header));
-                avs->mactime = cpu_to_be64(le64_to_cpu(clock));
+                avs->mactime = cpu_to_be64(clock);
                 avs->hosttime = cpu_to_be64(jiffies);
                 avs->phytype = cpu_to_be32(6);  /*OFDM: 6 for (g), 8 for (a) */
                 avs->channel = cpu_to_be32(channel_of_freq(freq));
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index fdbd0ef2be4b..61e59c17a60a 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -138,11 +138,8 @@ static void rt2500usb_bbp_write(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt2500usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR8 register busy. Write failed.\n");
-                mutex_unlock(&rt2x00dev->usb_cache_mutex);
-                return;
-        }
+        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY))
+                goto exit_fail;
 
         /*
          * Write the data into the BBP.
@@ -155,6 +152,13 @@ static void rt2500usb_bbp_write(struct rt2x00_dev *rt2x00dev,
         rt2500usb_register_write_lock(rt2x00dev, PHY_CSR7, reg);
 
         mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        return;
+
+exit_fail:
+        mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        ERROR(rt2x00dev, "PHY_CSR8 register busy. Write failed.\n");
 }
 
 static void rt2500usb_bbp_read(struct rt2x00_dev *rt2x00dev,
@@ -168,10 +172,8 @@ static void rt2500usb_bbp_read(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt2500usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR8 register busy. Read failed.\n");
-                return;
-        }
+        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY))
+                goto exit_fail;
 
         /*
          * Write the request into the BBP.
@@ -186,17 +188,21 @@ static void rt2500usb_bbp_read(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt2500usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR8 register busy. Read failed.\n");
-                *value = 0xff;
-                mutex_unlock(&rt2x00dev->usb_cache_mutex);
-                return;
-        }
+        if (rt2x00_get_field16(reg, PHY_CSR8_BUSY))
+                goto exit_fail;
 
         rt2500usb_register_read_lock(rt2x00dev, PHY_CSR7, &reg);
         *value = rt2x00_get_field16(reg, PHY_CSR7_DATA);
 
         mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        return;
+
+exit_fail:
+        mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        ERROR(rt2x00dev, "PHY_CSR8 register busy. Read failed.\n");
+        *value = 0xff;
 }
 
 static void rt2500usb_rf_write(struct rt2x00_dev *rt2x00dev,
diff --git a/drivers/net/wireless/rt2x00/rt2x00.h b/drivers/net/wireless/rt2x00/rt2x00.h
index 611d98320593..b4bf1e09cf9a 100644
--- a/drivers/net/wireless/rt2x00/rt2x00.h
+++ b/drivers/net/wireless/rt2x00/rt2x00.h
@@ -821,6 +821,7 @@ struct rt2x00_dev {
         /*
          * Scheduled work.
          */
+        struct workqueue_struct *workqueue;
         struct work_struct intf_work;
         struct work_struct filter_work;
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 2673d568bcac..c997d4f28ab3 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -75,7 +75,7 @@ static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
 
         rt2x00lib_reset_link_tuner(rt2x00dev);
 
-        queue_delayed_work(rt2x00dev->hw->workqueue,
+        queue_delayed_work(rt2x00dev->workqueue,
                            &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
 }
 
@@ -137,14 +137,6 @@ void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
                 return;
 
         /*
-         * Stop all scheduled work.
-         */
-        if (work_pending(&rt2x00dev->intf_work))
-                cancel_work_sync(&rt2x00dev->intf_work);
-        if (work_pending(&rt2x00dev->filter_work))
-                cancel_work_sync(&rt2x00dev->filter_work);
-
-        /*
          * Stop the TX queues.
          */
         ieee80211_stop_queues(rt2x00dev->hw);
@@ -398,8 +390,8 @@ static void rt2x00lib_link_tuner(struct work_struct *work)
          * Increase tuner counter, and reschedule the next link tuner run.
          */
         rt2x00dev->link.count++;
-        queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
-                           LINK_TUNE_INTERVAL);
+        queue_delayed_work(rt2x00dev->workqueue,
+                           &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
 }
 
 static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
@@ -433,6 +425,15 @@ static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
 
         spin_unlock(&intf->lock);
 
+        /*
+         * It is possible the radio was disabled while the work had been
+         * scheduled. If that happens we should return here immediately,
+         * note that in the spinlock protected area above the delayed_flags
+         * have been cleared correctly.
+         */
+        if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
+                return;
+
         if (delayed_flags & DELAYED_UPDATE_BEACON) {
                 skb = ieee80211_beacon_get(rt2x00dev->hw, vif, &control);
                 if (skb && rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw,
@@ -441,7 +442,7 @@ static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
         }
 
         if (delayed_flags & DELAYED_CONFIG_ERP)
-                rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
+                rt2x00lib_config_erp(rt2x00dev, intf, &conf);
 
         if (delayed_flags & DELAYED_LED_ASSOC)
                 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
@@ -487,7 +488,7 @@ void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
                                                    rt2x00lib_beacondone_iter,
                                                    rt2x00dev);
 
-        queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
+        queue_work(rt2x00dev->workqueue, &rt2x00dev->intf_work);
 }
 EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
 
@@ -1130,6 +1131,10 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
         /*
          * Initialize configuration work.
          */
+        rt2x00dev->workqueue = create_singlethread_workqueue("rt2x00lib");
+        if (!rt2x00dev->workqueue)
+                goto exit;
+
         INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
         INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
         INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
@@ -1190,6 +1195,13 @@ void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
         rt2x00leds_unregister(rt2x00dev);
 
         /*
+         * Stop all queued work. Note that most tasks will already be halted
+         * during rt2x00lib_disable_radio() and rt2x00lib_uninitialize().
+         */
+        flush_workqueue(rt2x00dev->workqueue);
+        destroy_workqueue(rt2x00dev->workqueue);
+
+        /*
          * Free ieee80211_hw memory.
          */
         rt2x00lib_remove_hw(rt2x00dev);
diff --git a/drivers/net/wireless/rt2x00/rt2x00mac.c b/drivers/net/wireless/rt2x00/rt2x00mac.c
index 87e280a21971..9cb023edd2e9 100644
--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
+++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
@@ -428,7 +428,7 @@ void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
         if (!test_bit(DRIVER_REQUIRE_SCHEDULED, &rt2x00dev->flags))
                 rt2x00dev->ops->lib->config_filter(rt2x00dev, *total_flags);
         else
-                queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->filter_work);
+                queue_work(rt2x00dev->workqueue, &rt2x00dev->filter_work);
 }
 EXPORT_SYMBOL_GPL(rt2x00mac_configure_filter);
 
@@ -509,7 +509,7 @@ void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
         memcpy(&intf->conf, bss_conf, sizeof(*bss_conf));
         if (delayed) {
                 intf->delayed_flags |= delayed;
-                queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
+                queue_work(rt2x00dev->workqueue, &rt2x00dev->intf_work);
         }
         spin_unlock(&intf->lock);
 }
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index fff8386e816b..83cc0147f698 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -134,11 +134,8 @@ static void rt73usb_bbp_write(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt73usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR3 register busy. Write failed.\n");
-                mutex_unlock(&rt2x00dev->usb_cache_mutex);
-                return;
-        }
+        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY))
+                goto exit_fail;
 
         /*
          * Write the data into the BBP.
@@ -151,6 +148,13 @@ static void rt73usb_bbp_write(struct rt2x00_dev *rt2x00dev,
 
         rt73usb_register_write_lock(rt2x00dev, PHY_CSR3, reg);
         mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        return;
+
+exit_fail:
+        mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        ERROR(rt2x00dev, "PHY_CSR3 register busy. Write failed.\n");
 }
 
 static void rt73usb_bbp_read(struct rt2x00_dev *rt2x00dev,
@@ -164,11 +168,8 @@ static void rt73usb_bbp_read(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt73usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR3 register busy. Read failed.\n");
-                mutex_unlock(&rt2x00dev->usb_cache_mutex);
-                return;
-        }
+        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY))
+                goto exit_fail;
 
         /*
          * Write the request into the BBP.
@@ -184,14 +185,19 @@ static void rt73usb_bbp_read(struct rt2x00_dev *rt2x00dev,
          * Wait until the BBP becomes ready.
          */
         reg = rt73usb_bbp_check(rt2x00dev);
-        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY)) {
-                ERROR(rt2x00dev, "PHY_CSR3 register busy. Read failed.\n");
-                *value = 0xff;
-                return;
-        }
+        if (rt2x00_get_field32(reg, PHY_CSR3_BUSY))
+                goto exit_fail;
 
         *value = rt2x00_get_field32(reg, PHY_CSR3_VALUE);
         mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        return;
+
+exit_fail:
+        mutex_unlock(&rt2x00dev->usb_cache_mutex);
+
+        ERROR(rt2x00dev, "PHY_CSR3 register busy. Read failed.\n");
+        *value = 0xff;
 }
 
 static void rt73usb_rf_write(struct rt2x00_dev *rt2x00dev,
diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index ec8f7002b09d..39bb96b413ef 100644
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -178,8 +178,7 @@ static int pci_vpd_pci22_read(struct pci_dev *dev, int pos, int size,
         int ret;
         int begin, end, i;
 
-        if (pos < 0 || pos > PCI_VPD_PCI22_SIZE ||
-            size > PCI_VPD_PCI22_SIZE  - pos)
+        if (pos < 0 || pos > vpd->base.len || size > vpd->base.len  - pos)
                 return -EINVAL;
         if (size == 0)
                 return 0;
@@ -223,8 +222,8 @@ static int pci_vpd_pci22_write(struct pci_dev *dev, int pos, int size,
         u32 val;
         int ret;
 
-        if (pos < 0 || pos > PCI_VPD_PCI22_SIZE || pos & 3 ||
-            size > PCI_VPD_PCI22_SIZE - pos || size < 4)
+        if (pos < 0 || pos > vpd->base.len || pos & 3 ||
+            size > vpd->base.len - pos || size < 4)
                 return -EINVAL;
 
         val = (u8) *buf++;
@@ -255,11 +254,6 @@ out:
         return 4;
 }
 
-static int pci_vpd_pci22_get_size(struct pci_dev *dev)
-{
-        return PCI_VPD_PCI22_SIZE;
-}
-
 static void pci_vpd_pci22_release(struct pci_dev *dev)
 {
         kfree(container_of(dev->vpd, struct pci_vpd_pci22, base));
@@ -268,7 +262,6 @@ static void pci_vpd_pci22_release(struct pci_dev *dev)
 static struct pci_vpd_ops pci_vpd_pci22_ops = {
         .read = pci_vpd_pci22_read,
         .write = pci_vpd_pci22_write,
-        .get_size = pci_vpd_pci22_get_size,
         .release = pci_vpd_pci22_release,
 };
 
@@ -284,6 +277,7 @@ int pci_vpd_pci22_init(struct pci_dev *dev)
         if (!vpd)
                 return -ENOMEM;
 
+        vpd->base.len = PCI_VPD_PCI22_SIZE;
         vpd->base.ops = &pci_vpd_pci22_ops;
         spin_lock_init(&vpd->lock);
         vpd->cap = cap;
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 648596d469f6..91156f85a926 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -700,9 +700,10 @@ cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
         acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
                                 cleanup_p2p_bridge, NULL, NULL);
 
-        if (!(bridge = acpiphp_handle_to_bridge(handle)))
-                return AE_OK;
-        cleanup_bridge(bridge);
+        bridge = acpiphp_handle_to_bridge(handle);
+        if (bridge)
+                cleanup_bridge(bridge);
+
         return AE_OK;
 }
 
@@ -715,9 +716,19 @@ static void remove_bridge(acpi_handle handle)
         acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
                                 (u32)1, cleanup_p2p_bridge, NULL, NULL);
 
+        /*
+         * On root bridges with hotplug slots directly underneath (ie,
+         * no p2p bridge inbetween), we call cleanup_bridge(). 
+         *
+         * The else clause cleans up root bridges that either had no
+         * hotplug slots at all, or had a p2p bridge underneath.
+         */
         bridge = acpiphp_handle_to_bridge(handle);
         if (bridge)
                 cleanup_bridge(bridge);
+        else
+                acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
+                                           handle_hotplug_event_bridge);
 }
 
 static struct pci_dev * get_apic_pci_info(acpi_handle handle)
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 6f3c7446c329..9c718583a237 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -736,9 +736,9 @@ int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
                 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
                 if (attr) {
                         pdev->vpd->attr = attr;
-                        attr->size = pdev->vpd->ops->get_size(pdev);
+                        attr->size = pdev->vpd->len;
                         attr->attr.name = "vpd";
-                        attr->attr.mode = S_IRUGO | S_IWUSR;
+                        attr->attr.mode = S_IRUSR | S_IWUSR;
                         attr->read = pci_read_vpd;
                         attr->write = pci_write_vpd;
                         retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 0a497c1b4227..00408c97e5fc 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -21,11 +21,11 @@ extern int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
 struct pci_vpd_ops {
         int (*read)(struct pci_dev *dev, int pos, int size, char *buf);
         int (*write)(struct pci_dev *dev, int pos, int size, const char *buf);
-        int (*get_size)(struct pci_dev *dev);
         void (*release)(struct pci_dev *dev);
 };
 
 struct pci_vpd {
+        unsigned int len;
         struct pci_vpd_ops *ops;
         struct bin_attribute *attr; /* descriptor for sysfs VPD entry */
 };
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index dabb563f51d9..a3497dc6ebcf 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -1670,6 +1670,48 @@ static void __devinit quirk_via_cx700_pci_parking_caching(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_VIA, 0x324e, quirk_via_cx700_pci_parking_caching);
 
+/*
+ * For Broadcom 5706, 5708, 5709 rev. A nics, any read beyond the
+ * VPD end tag will hang the device.  This problem was initially
+ * observed when a vpd entry was created in sysfs
+ * ('/sys/bus/pci/devices/<id>/vpd').   A read to this sysfs entry
+ * will dump 32k of data.  Reading a full 32k will cause an access
+ * beyond the VPD end tag causing the device to hang.  Once the device
+ * is hung, the bnx2 driver will not be able to reset the device.
+ * We believe that it is legal to read beyond the end tag and
+ * therefore the solution is to limit the read/write length.
+ */
+static void __devinit quirk_brcm_570x_limit_vpd(struct pci_dev *dev)
+{
+        /*  Only disable the VPD capability for 5706, 5708, and 5709 rev. A */
+        if ((dev->device == PCI_DEVICE_ID_NX2_5706) ||
+            (dev->device == PCI_DEVICE_ID_NX2_5708) ||
+            ((dev->device == PCI_DEVICE_ID_NX2_5709) &&
+             (dev->revision & 0xf0) == 0x0)) {
+                if (dev->vpd)
+                        dev->vpd->len = 0x80;
+        }
+}
+
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5706,
+                         quirk_brcm_570x_limit_vpd);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5706S,
+                         quirk_brcm_570x_limit_vpd);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5708,
+                         quirk_brcm_570x_limit_vpd);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5708S,
+                         quirk_brcm_570x_limit_vpd);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5709,
+                         quirk_brcm_570x_limit_vpd);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_BROADCOM,
+                         PCI_DEVICE_ID_NX2_5709S,
+                         quirk_brcm_570x_limit_vpd);
+
 #ifdef CONFIG_PCI_MSI
 /* Some chipsets do not support MSI. We cannot easily rely on setting
  * PCI_BUS_FLAGS_NO_MSI in its bus flags because there are actually
diff --git a/drivers/pcmcia/omap_cf.c b/drivers/pcmcia/omap_cf.c
index 46314b420765..569b746b5731 100644
--- a/drivers/pcmcia/omap_cf.c
+++ b/drivers/pcmcia/omap_cf.c
@@ -38,19 +38,19 @@
 #define CF_BASE 0xfffe2800
 
 /* status; read after IRQ */
-#define CF_STATUS_REG           __REG16(CF_BASE + 0x00)
+#define CF_STATUS                       (CF_BASE + 0x00)
 #       define  CF_STATUS_BAD_READ      (1 << 2)
 #       define  CF_STATUS_BAD_WRITE     (1 << 1)
 #       define  CF_STATUS_CARD_DETECT   (1 << 0)
 
 /* which chipselect (CS0..CS3) is used for CF (active low) */
-#define CF_CFG_REG              __REG16(CF_BASE + 0x02)
+#define CF_CFG                          (CF_BASE + 0x02)
 
 /* card reset */
-#define CF_CONTROL_REG          __REG16(CF_BASE + 0x04)
+#define CF_CONTROL                      (CF_BASE + 0x04)
 #       define  CF_CONTROL_RESET        (1 << 0)
 
-#define omap_cf_present() (!(CF_STATUS_REG & CF_STATUS_CARD_DETECT))
+#define omap_cf_present() (!(omap_readw(CF_STATUS) & CF_STATUS_CARD_DETECT))
 
 /*--------------------------------------------------------------------------*/
 
@@ -139,11 +139,11 @@ omap_cf_set_socket(struct pcmcia_socket *sock, struct socket_state_t *s)
                 return -EINVAL;
         }
 
-        control = CF_CONTROL_REG;
+        control = omap_readw(CF_CONTROL);
         if (s->flags & SS_RESET)
-                CF_CONTROL_REG = CF_CONTROL_RESET;
+                omap_writew(CF_CONTROL_RESET, CF_CONTROL);
         else
-                CF_CONTROL_REG = 0;
+                omap_writew(0, CF_CONTROL);
 
         pr_debug("%s: Vcc %d, io_irq %d, flags %04x csc %04x\n",
                 driver_name, s->Vcc, s->io_irq, s->flags, s->csc_mask);
@@ -270,7 +270,7 @@ static int __init omap_cf_probe(struct platform_device *pdev)
         omap_cfg_reg(V10_1610_CF_IREQ);
         omap_cfg_reg(W10_1610_CF_RESET);
 
-        CF_CFG_REG = ~(1 << seg);
+        omap_writew(~(1 << seg), CF_CFG);
 
         pr_info("%s: cs%d on irq %d\n", driver_name, seg, irq);
 
@@ -279,14 +279,15 @@ static int __init omap_cf_probe(struct platform_device *pdev)
          * CF/PCMCIA variants...
          */
         pr_debug("%s: cs%d, previous ccs %08x acs %08x\n", driver_name,
-                        seg, EMIFS_CCS(seg), EMIFS_ACS(seg));
-        EMIFS_CCS(seg) = 0x0004a1b3;    /* synch mode 4 etc */
-        EMIFS_ACS(seg) = 0x00000000;    /* OE hold/setup */
+                seg, omap_readl(EMIFS_CCS(seg)), omap_readl(EMIFS_ACS(seg)));
+        omap_writel(0x0004a1b3, EMIFS_CCS(seg));        /* synch mode 4 etc */
+        omap_writel(0x00000000, EMIFS_ACS(seg));        /* OE hold/setup */
 
         /* CF uses armxor_ck, which is "always" available */
 
         pr_debug("%s: sts %04x cfg %04x control %04x %s\n", driver_name,
-                CF_STATUS_REG, CF_CFG_REG, CF_CONTROL_REG,
+                omap_readw(CF_STATUS), omap_readw(CF_CFG),
+                omap_readw(CF_CONTROL),
                 omap_cf_present() ? "present" : "(not present)");
 
         cf->socket.owner = THIS_MODULE;
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 4949dc4859be..fc85bf2e4a97 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -469,6 +469,16 @@ config RTC_DRV_VR41XX
           To compile this driver as a module, choose M here: the
           module will be called rtc-vr41xx.
 
+config RTC_DRV_PL030
+        tristate "ARM AMBA PL030 RTC"
+        depends on ARM_AMBA
+        help
+          If you say Y here you will get access to ARM AMBA
+          PrimeCell PL030 RTC found on certain ARM SOCs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rtc-pl030.
+
 config RTC_DRV_PL031
         tristate "ARM AMBA PL031 RTC"
         depends on ARM_AMBA
@@ -495,12 +505,13 @@ config RTC_DRV_AT91RM9200
           this is powered by the backup power supply.
 
 config RTC_DRV_AT91SAM9
-        tristate "AT91SAM9x"
+        tristate "AT91SAM9x/AT91CAP9"
         depends on ARCH_AT91 && !(ARCH_AT91RM9200 || ARCH_AT91X40)
         help
-          RTC driver for the Atmel AT91SAM9x internal RTT (Real Time Timer).
-          These timers are powered by the backup power supply (such as a
-          small coin cell battery), but do not need to be used as RTCs.
+          RTC driver for the Atmel AT91SAM9x and AT91CAP9 internal RTT
+          (Real Time Timer). These timers are powered by the backup power
+          supply (such as a small coin cell battery), but do not need to
+          be used as RTCs.
 
           (On AT91SAM9rl chips you probably want to use the dedicated RTC
           module and leave the RTT available for other uses.)
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index b6e14d51670b..b5d9d67df887 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_RTC_DRV_MAX6902)	+= rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
 obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
+obj-$(CONFIG_RTC_DRV_PL030)     += rtc-pl030.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
 obj-$(CONFIG_RTC_DRV_PPC)       += rtc-ppc.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 39e64ab1ecb7..9c3db934cc24 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -29,10 +29,6 @@
 #include <linux/completion.h>
 
 #include <asm/uaccess.h>
-#include <asm/rtc.h>
-
-#include <asm/mach/time.h>
-
 #include <asm/arch/at91_rtc.h>
 
 
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 38d8742a4bdf..f0246ef413a4 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -19,7 +19,6 @@
 #include <linux/interrupt.h>
 #include <linux/ioctl.h>
 
-#include <asm/mach/time.h>
 #include <asm/arch/board.h>
 #include <asm/arch/at91_rtt.h>
 
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 58f81c774943..eb23d8423f42 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -22,7 +22,6 @@
 #include <linux/platform_device.h>
 
 #include <asm/io.h>
-#include <asm/mach/time.h>
 
 
 /* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
diff --git a/drivers/rtc/rtc-pl030.c b/drivers/rtc/rtc-pl030.c
new file mode 100644
index 000000000000..8448eeb9d675
--- /dev/null
+++ b/drivers/rtc/rtc-pl030.c
@@ -0,0 +1,217 @@
+/*
+ *  linux/drivers/rtc/rtc-pl030.c
+ *
+ *  Copyright (C) 2000-2001 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 version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/amba/bus.h>
+#include <linux/io.h>
+
+#define RTC_DR          (0)
+#define RTC_MR          (4)
+#define RTC_STAT        (8)
+#define RTC_EOI         (8)
+#define RTC_LR          (12)
+#define RTC_CR          (16)
+#define RTC_CR_MIE      (1 << 0)
+
+struct pl030_rtc {
+        struct rtc_device       *rtc;
+        void __iomem            *base;
+};
+
+static irqreturn_t pl030_interrupt(int irq, void *dev_id)
+{
+        struct pl030_rtc *rtc = dev_id;
+        writel(0, rtc->base + RTC_EOI);
+        return IRQ_HANDLED;
+}
+
+static int pl030_open(struct device *dev)
+{
+        return 0;
+}
+
+static void pl030_release(struct device *dev)
+{
+}
+
+static int pl030_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        return -ENOIOCTLCMD;
+}
+
+static int pl030_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pl030_rtc *rtc = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(readl(rtc->base + RTC_MR), &alrm->time);
+        return 0;
+}
+
+static int pl030_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pl030_rtc *rtc = dev_get_drvdata(dev);
+        unsigned long time;
+        int ret;
+
+        /*
+         * At the moment, we can only deal with non-wildcarded alarm times.
+         */
+        ret = rtc_valid_tm(&alrm->time);
+        if (ret == 0)
+                ret = rtc_tm_to_time(&alrm->time, &time);
+        if (ret == 0)
+                writel(time, rtc->base + RTC_MR);
+        return ret;
+}
+
+static int pl030_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pl030_rtc *rtc = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(readl(rtc->base + RTC_DR), tm);
+
+        return 0;
+}
+
+/*
+ * Set the RTC time.  Unfortunately, we can't accurately set
+ * the point at which the counter updates.
+ *
+ * Also, since RTC_LR is transferred to RTC_CR on next rising
+ * edge of the 1Hz clock, we must write the time one second
+ * in advance.
+ */
+static int pl030_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pl030_rtc *rtc = dev_get_drvdata(dev);
+        unsigned long time;
+        int ret;
+
+        ret = rtc_tm_to_time(tm, &time);
+        if (ret == 0)
+                writel(time + 1, rtc->base + RTC_LR);
+
+        return ret;
+}
+
+static const struct rtc_class_ops pl030_ops = {
+        .open           = pl030_open,
+        .release        = pl030_release,
+        .ioctl          = pl030_ioctl,
+        .read_time      = pl030_read_time,
+        .set_time       = pl030_set_time,
+        .read_alarm     = pl030_read_alarm,
+        .set_alarm      = pl030_set_alarm,
+};
+
+static int pl030_probe(struct amba_device *dev, void *id)
+{
+        struct pl030_rtc *rtc;
+        int ret;
+
+        ret = amba_request_regions(dev, NULL);
+        if (ret)
+                goto err_req;
+
+        rtc = kmalloc(sizeof(*rtc), GFP_KERNEL);
+        if (!rtc) {
+                ret = -ENOMEM;
+                goto err_rtc;
+        }
+
+        rtc->base = ioremap(dev->res.start, SZ_4K);
+        if (!rtc->base) {
+                ret = -ENOMEM;
+                goto err_map;
+        }
+
+        __raw_writel(0, rtc->base + RTC_CR);
+        __raw_writel(0, rtc->base + RTC_EOI);
+
+        amba_set_drvdata(dev, rtc);
+
+        ret = request_irq(dev->irq[0], pl030_interrupt, IRQF_DISABLED,
+                          "rtc-pl030", rtc);
+        if (ret)
+                goto err_irq;
+
+        rtc->rtc = rtc_device_register("pl030", &dev->dev, &pl030_ops,
+                                       THIS_MODULE);
+        if (IS_ERR(rtc->rtc)) {
+                ret = PTR_ERR(rtc->rtc);
+                goto err_reg;
+        }
+
+        return 0;
+
+ err_reg:
+        free_irq(dev->irq[0], rtc);
+ err_irq:
+        iounmap(rtc->base);
+ err_map:
+        kfree(rtc);
+ err_rtc:
+        amba_release_regions(dev);
+ err_req:
+        return ret;
+}
+
+static int pl030_remove(struct amba_device *dev)
+{
+        struct pl030_rtc *rtc = amba_get_drvdata(dev);
+
+        amba_set_drvdata(dev, NULL);
+
+        writel(0, rtc->base + RTC_CR);
+
+        free_irq(dev->irq[0], rtc);
+        rtc_device_unregister(rtc->rtc);
+        iounmap(rtc->base);
+        kfree(rtc);
+        amba_release_regions(dev);
+
+        return 0;
+}
+
+static struct amba_id pl030_ids[] = {
+        {
+                .id     = 0x00041030,
+                .mask   = 0x000fffff,
+        },
+        { 0, 0 },
+};
+
+static struct amba_driver pl030_driver = {
+        .drv            = {
+                .name   = "rtc-pl030",
+        },
+        .probe          = pl030_probe,
+        .remove         = pl030_remove,
+        .id_table       = pl030_ids,
+};
+
+static int __init pl030_init(void)
+{
+        return amba_driver_register(&pl030_driver);
+}
+
+static void __exit pl030_exit(void)
+{
+        amba_driver_unregister(&pl030_driver);
+}
+
+module_init(pl030_init);
+module_exit(pl030_exit);
+
+MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
+MODULE_DESCRIPTION("ARM AMBA PL030 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 2fd49edcc712..08b4610ec5a6 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -12,23 +12,12 @@
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
-
-#include <linux/platform_device.h>
 #include <linux/module.h>
 #include <linux/rtc.h>
 #include <linux/init.h>
-#include <linux/fs.h>
 #include <linux/interrupt.h>
-#include <linux/string.h>
-#include <linux/pm.h>
-#include <linux/bitops.h>
-
 #include <linux/amba/bus.h>
-
-#include <asm/io.h>
-#include <asm/hardware.h>
-#include <asm/irq.h>
-#include <asm/rtc.h>
+#include <linux/io.h>
 
 /*
  * Register definitions
@@ -142,13 +131,12 @@ static int pl031_remove(struct amba_device *adev)
 {
         struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
 
-        if (ldata) {
-                dev_set_drvdata(&adev->dev, NULL);
-                free_irq(adev->irq[0], ldata->rtc);
-                rtc_device_unregister(ldata->rtc);
-                iounmap(ldata->base);
-                kfree(ldata);
-        }
+        amba_set_drvdata(adev, NULL);
+        free_irq(adev->irq[0], ldata->rtc);
+        rtc_device_unregister(ldata->rtc);
+        iounmap(ldata->base);
+        kfree(ldata);
+        amba_release_regions(adev);
 
         return 0;
 }
@@ -158,13 +146,15 @@ static int pl031_probe(struct amba_device *adev, void *id)
         int ret;
         struct pl031_local *ldata;
 
+        ret = amba_request_regions(adev, NULL);
+        if (ret)
+                goto err_req;
 
         ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
         if (!ldata) {
                 ret = -ENOMEM;
                 goto out;
         }
-        dev_set_drvdata(&adev->dev, ldata);
 
         ldata->base = ioremap(adev->res.start,
                               adev->res.end - adev->res.start + 1);
@@ -173,6 +163,8 @@ static int pl031_probe(struct amba_device *adev, void *id)
                 goto out_no_remap;
         }
 
+        amba_set_drvdata(adev, ldata);
+
         if (request_irq(adev->irq[0], pl031_interrupt, IRQF_DISABLED,
                         "rtc-pl031", ldata->rtc)) {
                 ret = -EIO;
@@ -192,10 +184,12 @@ out_no_rtc:
         free_irq(adev->irq[0], ldata->rtc);
 out_no_irq:
         iounmap(ldata->base);
+        amba_set_drvdata(adev, NULL);
 out_no_remap:
-        dev_set_drvdata(&adev->dev, NULL);
         kfree(ldata);
 out:
+        amba_release_regions(adev);
+err_req:
         return ret;
 }
 
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index f26e0cad8f16..fed86e507fdf 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -26,10 +26,6 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/rtc.h>
-
-#include <asm/mach/time.h>
-
 #include <asm/plat-s3c/regs-rtc.h>
 
 /* I have yet to find an S3C implementation with more than one
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 82f62d25f921..f47294c60148 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -33,7 +33,6 @@
 
 #include <asm/hardware.h>
 #include <asm/irq.h>
-#include <asm/rtc.h>
 
 #ifdef CONFIG_ARCH_PXA
 #include <asm/arch/pxa-regs.h>
@@ -47,6 +46,42 @@ static unsigned long rtc_freq = 1024;
 static struct rtc_time rtc_alarm;
 static DEFINE_SPINLOCK(sa1100_rtc_lock);
 
+static inline int rtc_periodic_alarm(struct rtc_time *tm)
+{
+        return  (tm->tm_year == -1) ||
+                ((unsigned)tm->tm_mon >= 12) ||
+                ((unsigned)(tm->tm_mday - 1) >= 31) ||
+                ((unsigned)tm->tm_hour > 23) ||
+                ((unsigned)tm->tm_min > 59) ||
+                ((unsigned)tm->tm_sec > 59);
+}
+
+/*
+ * Calculate the next alarm time given the requested alarm time mask
+ * and the current time.
+ */
+static void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, struct rtc_time *alrm)
+{
+        unsigned long next_time;
+        unsigned long now_time;
+
+        next->tm_year = now->tm_year;
+        next->tm_mon = now->tm_mon;
+        next->tm_mday = now->tm_mday;
+        next->tm_hour = alrm->tm_hour;
+        next->tm_min = alrm->tm_min;
+        next->tm_sec = alrm->tm_sec;
+
+        rtc_tm_to_time(now, &now_time);
+        rtc_tm_to_time(next, &next_time);
+
+        if (next_time < now_time) {
+                /* Advance one day */
+                next_time += 60 * 60 * 24;
+                rtc_time_to_tm(next_time, next);
+        }
+}
+
 static int rtc_update_alarm(struct rtc_time *alrm)
 {
         struct rtc_time alarm_tm, now_tm;
@@ -331,14 +366,14 @@ static int sa1100_rtc_probe(struct platform_device *pdev)
                 RCNR = 0;
         }
 
+        device_init_wakeup(&pdev->dev, 1);
+
         rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
                                 THIS_MODULE);
 
         if (IS_ERR(rtc))
                 return PTR_ERR(rtc);
 
-        device_init_wakeup(&pdev->dev, 1);
-
         platform_set_drvdata(pdev, rtc);
 
         return 0;
diff --git a/drivers/scsi/arm/Kconfig b/drivers/scsi/arm/Kconfig
index 7236143941f3..a8587f1f5e7e 100644
--- a/drivers/scsi/arm/Kconfig
+++ b/drivers/scsi/arm/Kconfig
@@ -3,7 +3,7 @@
 #
 config SCSI_ACORNSCSI_3
         tristate "Acorn SCSI card (aka30) support"
-        depends on ARCH_ACORN && SCSI && BROKEN
+        depends on ARCH_ACORN && SCSI
         select SCSI_SPI_ATTRS
         help
           This enables support for the Acorn SCSI card (aka30). If you have an
diff --git a/drivers/scsi/arm/acornscsi-io.S b/drivers/scsi/arm/acornscsi-io.S
index 93467e6ac923..5cebe3105260 100644
--- a/drivers/scsi/arm/acornscsi-io.S
+++ b/drivers/scsi/arm/acornscsi-io.S
@@ -10,17 +10,10 @@
 #include <asm/assembler.h>
 #include <asm/hardware.h>
 
-#if (IO_BASE == (PCIO_BASE & 0xff000000))
-#define ADDR(off,reg)                                           \
-                tst     off, $0x80000000                        ;\
-                mov     reg, $IO_BASE                           ;\
-                orreq   reg, reg, $(PCIO_BASE & 0x00ff0000)
-#else
-#define ADDR(off,reg)                                           \
-                tst     off, $0x80000000                        ;\
-                movne   reg, $IO_BASE                           ;\
-                moveq   reg, $(PCIO_BASE & 0xff000000)          ;\
-                orreq   reg, reg, $(PCIO_BASE & 0x00ff0000)
+#if defined(__APCS_32__)
+#define LOADREGS(t,r,l...)      ldm##t  r, l
+#elif defined(__APCS_26__)
+#define LOADREGS(t,r,l...)      ldm##t  r, l##^
 #endif
 
 @ Purpose: transfer a block of data from the acorn scsi card to memory
diff --git a/drivers/scsi/arm/acornscsi.c b/drivers/scsi/arm/acornscsi.c
index 8e53f02cc311..918ccf818757 100644
--- a/drivers/scsi/arm/acornscsi.c
+++ b/drivers/scsi/arm/acornscsi.c
@@ -123,12 +123,6 @@
 #define DBG(cmd,xxx...) xxx
 #endif
 
-#ifndef STRINGIFY
-#define STRINGIFY(x) #x
-#endif
-#define STRx(x) STRINGIFY(x)
-#define NO_WRITE_STR STRx(NO_WRITE)
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
@@ -141,9 +135,10 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/stringify.h>
+#include <linux/io.h>
 
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/ecard.h>
 
 #include "../scsi.h"
@@ -203,44 +198,46 @@ static void acornscsi_abortcmd(AS_Host *host, unsigned char tag);
  * Miscellaneous
  */
 
-static inline void
-sbic_arm_write(unsigned int io_port, int reg, int value)
+/* Offsets from MEMC base */
+#define SBIC_REGIDX     0x2000
+#define SBIC_REGVAL     0x2004
+#define DMAC_OFFSET     0x3000
+
+/* Offsets from FAST IOC base */
+#define INT_REG         0x2000
+#define PAGE_REG        0x3000
+
+static inline void sbic_arm_write(AS_Host *host, unsigned int reg, unsigned int value)
 {
-    __raw_writeb(reg, io_port);
-    __raw_writeb(value, io_port + 4);
+    writeb(reg, host->base + SBIC_REGIDX);
+    writeb(value, host->base + SBIC_REGVAL);
 }
 
-#define sbic_arm_writenext(io,val) \
-        __raw_writeb((val), (io) + 4)
-
-static inline
-int sbic_arm_read(unsigned int io_port, int reg)
+static inline int sbic_arm_read(AS_Host *host, unsigned int reg)
 {
     if(reg == SBIC_ASR)
-           return __raw_readl(io_port) & 255;
-    __raw_writeb(reg, io_port);
-    return __raw_readl(io_port + 4) & 255;
+           return readl(host->base + SBIC_REGIDX) & 255;
+    writeb(reg, host->base + SBIC_REGIDX);
+    return readl(host->base + SBIC_REGVAL) & 255;
 }
 
-#define sbic_arm_readnext(io) \
-        __raw_readb((io) + 4)
+#define sbic_arm_writenext(host, val)   writeb((val), (host)->base + SBIC_REGVAL)
+#define sbic_arm_readnext(host)         readb((host)->base + SBIC_REGVAL)
 
 #ifdef USE_DMAC
-#define dmac_read(io_port,reg) \
-        inb((io_port) + (reg))
+#define dmac_read(host,reg) \
+        readb((host)->base + DMAC_OFFSET + ((reg) << 2))
 
-#define dmac_write(io_port,reg,value) \
-        ({ outb((value), (io_port) + (reg)); })
+#define dmac_write(host,reg,value) \
+        ({ writeb((value), (host)->base + DMAC_OFFSET + ((reg) << 2)); })
 
-#define dmac_clearintr(io_port) \
-        ({ outb(0, (io_port)); })
+#define dmac_clearintr(host)    writeb(0, (host)->fast + INT_REG)
 
-static inline
-unsigned int dmac_address(unsigned int io_port)
+static inline unsigned int dmac_address(AS_Host *host)
 {
-    return dmac_read(io_port, DMAC_TXADRHI) << 16 |
-           dmac_read(io_port, DMAC_TXADRMD) << 8 |
-           dmac_read(io_port, DMAC_TXADRLO);
+    return dmac_read(host, DMAC_TXADRHI) << 16 |
+           dmac_read(host, DMAC_TXADRMD) << 8 |
+           dmac_read(host, DMAC_TXADRLO);
 }
 
 static
@@ -248,15 +245,15 @@ void acornscsi_dumpdma(AS_Host *host, char *where)
 {
         unsigned int mode, addr, len;
 
-        mode = dmac_read(host->dma.io_port, DMAC_MODECON);
-        addr = dmac_address(host->dma.io_port);
-        len  = dmac_read(host->dma.io_port, DMAC_TXCNTHI) << 8 |
-               dmac_read(host->dma.io_port, DMAC_TXCNTLO);
+        mode = dmac_read(host, DMAC_MODECON);
+        addr = dmac_address(host);
+        len  = dmac_read(host, DMAC_TXCNTHI) << 8 |
+               dmac_read(host, DMAC_TXCNTLO);
 
         printk("scsi%d: %s: DMAC %02x @%06x+%04x msk %02x, ",
                 host->host->host_no, where,
                 mode, addr, (len + 1) & 0xffff,
-                dmac_read(host->dma.io_port, DMAC_MASKREG));
+                dmac_read(host, DMAC_MASKREG));
 
         printk("DMA @%06x, ", host->dma.start_addr);
         printk("BH @%p +%04x, ", host->scsi.SCp.ptr,
@@ -272,9 +269,9 @@ unsigned long acornscsi_sbic_xfcount(AS_Host *host)
 {
     unsigned long length;
 
-    length = sbic_arm_read(host->scsi.io_port, SBIC_TRANSCNTH) << 16;
-    length |= sbic_arm_readnext(host->scsi.io_port) << 8;
-    length |= sbic_arm_readnext(host->scsi.io_port);
+    length = sbic_arm_read(host, SBIC_TRANSCNTH) << 16;
+    length |= sbic_arm_readnext(host) << 8;
+    length |= sbic_arm_readnext(host);
 
     return length;
 }
@@ -285,7 +282,7 @@ acornscsi_sbic_wait(AS_Host *host, int stat_mask, int stat, int timeout, char *m
         int asr;
 
         do {
-                asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
+                asr = sbic_arm_read(host, SBIC_ASR);
 
                 if ((asr & stat_mask) == stat)
                         return 0;
@@ -304,7 +301,7 @@ int acornscsi_sbic_issuecmd(AS_Host *host, int command)
     if (acornscsi_sbic_wait(host, ASR_CIP, 0, 1000, "issuing command"))
         return -1;
 
-    sbic_arm_write(host->scsi.io_port, SBIC_CMND, command);
+    sbic_arm_write(host, SBIC_CMND, command);
 
     return 0;
 }
@@ -331,20 +328,20 @@ void acornscsi_resetcard(AS_Host *host)
 
     /* assert reset line */
     host->card.page_reg = 0x80;
-    outb(host->card.page_reg, host->card.io_page);
+    writeb(host->card.page_reg, host->fast + PAGE_REG);
 
     /* wait 3 cs.  SCSI standard says 25ms. */
     acornscsi_csdelay(3);
 
     host->card.page_reg = 0;
-    outb(host->card.page_reg, host->card.io_page);
+    writeb(host->card.page_reg, host->fast + PAGE_REG);
 
     /*
      * Should get a reset from the card
      */
     timeout = 1000;
     do {
-        if (inb(host->card.io_intr) & 8)
+        if (readb(host->fast + INT_REG) & 8)
             break;
         udelay(1);
     } while (--timeout);
@@ -353,19 +350,19 @@ void acornscsi_resetcard(AS_Host *host)
         printk("scsi%d: timeout while resetting card\n",
                 host->host->host_no);
 
-    sbic_arm_read(host->scsi.io_port, SBIC_ASR);
-    sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+    sbic_arm_read(host, SBIC_ASR);
+    sbic_arm_read(host, SBIC_SSR);
 
     /* setup sbic - WD33C93A */
-    sbic_arm_write(host->scsi.io_port, SBIC_OWNID, OWNID_EAF | host->host->this_id);
-    sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_RESET);
+    sbic_arm_write(host, SBIC_OWNID, OWNID_EAF | host->host->this_id);
+    sbic_arm_write(host, SBIC_CMND, CMND_RESET);
 
     /*
      * Command should cause a reset interrupt
      */
     timeout = 1000;
     do {
-        if (inb(host->card.io_intr) & 8)
+        if (readb(host->fast + INT_REG) & 8)
             break;
         udelay(1);
     } while (--timeout);
@@ -374,26 +371,26 @@ void acornscsi_resetcard(AS_Host *host)
         printk("scsi%d: timeout while resetting card\n",
                 host->host->host_no);
 
-    sbic_arm_read(host->scsi.io_port, SBIC_ASR);
-    if (sbic_arm_read(host->scsi.io_port, SBIC_SSR) != 0x01)
+    sbic_arm_read(host, SBIC_ASR);
+    if (sbic_arm_read(host, SBIC_SSR) != 0x01)
         printk(KERN_CRIT "scsi%d: WD33C93A didn't give enhanced reset interrupt\n",
                 host->host->host_no);
 
-    sbic_arm_write(host->scsi.io_port, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
-    sbic_arm_write(host->scsi.io_port, SBIC_TIMEOUT, TIMEOUT_TIME);
-    sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
-    sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
+    sbic_arm_write(host, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
+    sbic_arm_write(host, SBIC_TIMEOUT, TIMEOUT_TIME);
+    sbic_arm_write(host, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
+    sbic_arm_write(host, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
 
     host->card.page_reg = 0x40;
-    outb(host->card.page_reg, host->card.io_page);
+    writeb(host->card.page_reg, host->fast + PAGE_REG);
 
     /* setup dmac - uPC71071 */
-    dmac_write(host->dma.io_port, DMAC_INIT, 0);
+    dmac_write(host, DMAC_INIT, 0);
 #ifdef USE_DMAC
-    dmac_write(host->dma.io_port, DMAC_INIT, INIT_8BIT);
-    dmac_write(host->dma.io_port, DMAC_CHANNEL, CHANNEL_0);
-    dmac_write(host->dma.io_port, DMAC_DEVCON0, INIT_DEVCON0);
-    dmac_write(host->dma.io_port, DMAC_DEVCON1, INIT_DEVCON1);
+    dmac_write(host, DMAC_INIT, INIT_8BIT);
+    dmac_write(host, DMAC_CHANNEL, CHANNEL_0);
+    dmac_write(host, DMAC_DEVCON0, INIT_DEVCON0);
+    dmac_write(host, DMAC_DEVCON1, INIT_DEVCON1);
 #endif
 
     host->SCpnt = NULL;
@@ -741,9 +738,9 @@ intr_ret_t acornscsi_kick(AS_Host *host)
      * If we have an interrupt pending, then we may have been reselected.
      * In this case, we don't want to write to the registers
      */
-    if (!(sbic_arm_read(host->scsi.io_port, SBIC_ASR) & (ASR_INT|ASR_BSY|ASR_CIP))) {
-        sbic_arm_write(host->scsi.io_port, SBIC_DESTID, SCpnt->device->id);
-        sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_SELWITHATN);
+    if (!(sbic_arm_read(host, SBIC_ASR) & (ASR_INT|ASR_BSY|ASR_CIP))) {
+        sbic_arm_write(host, SBIC_DESTID, SCpnt->device->id);
+        sbic_arm_write(host, SBIC_CMND, CMND_SELWITHATN);
     }
 
     /*
@@ -807,7 +804,7 @@ static void acornscsi_done(AS_Host *host, struct scsi_cmnd **SCpntp,
         struct scsi_cmnd *SCpnt = *SCpntp;
 
     /* clean up */
-    sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
+    sbic_arm_write(host, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
 
     host->stats.fins += 1;
 
@@ -918,13 +915,13 @@ static
 void acornscsi_data_read(AS_Host *host, char *ptr,
                                  unsigned int start_addr, unsigned int length)
 {
-    extern void __acornscsi_in(int port, char *buf, int len);
+    extern void __acornscsi_in(void __iomem *, char *buf, int len);
     unsigned int page, offset, len = length;
 
     page = (start_addr >> 12);
     offset = start_addr & ((1 << 12) - 1);
 
-    outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
+    writeb((page & 0x3f) | host->card.page_reg, host->fast + PAGE_REG);
 
     while (len > 0) {
         unsigned int this_len;
@@ -934,7 +931,7 @@ void acornscsi_data_read(AS_Host *host, char *ptr,
         else
             this_len = len;
 
-        __acornscsi_in(host->card.io_ram + (offset << 1), ptr, this_len);
+        __acornscsi_in(host->base + (offset << 1), ptr, this_len);
 
         offset += this_len;
         ptr += this_len;
@@ -943,10 +940,10 @@ void acornscsi_data_read(AS_Host *host, char *ptr,
         if (offset == (1 << 12)) {
             offset = 0;
             page ++;
-            outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
+            writeb((page & 0x3f) | host->card.page_reg, host->fast + PAGE_REG);
         }
     }
-    outb(host->card.page_reg, host->card.io_page);
+    writeb(host->card.page_reg, host->fast + PAGE_REG);
 }
 
 /*
@@ -963,13 +960,13 @@ static
 void acornscsi_data_write(AS_Host *host, char *ptr,
                                  unsigned int start_addr, unsigned int length)
 {
-    extern void __acornscsi_out(int port, char *buf, int len);
+    extern void __acornscsi_out(void __iomem *, char *buf, int len);
     unsigned int page, offset, len = length;
 
     page = (start_addr >> 12);
     offset = start_addr & ((1 << 12) - 1);
 
-    outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
+    writeb((page & 0x3f) | host->card.page_reg, host->fast + PAGE_REG);
 
     while (len > 0) {
         unsigned int this_len;
@@ -979,7 +976,7 @@ void acornscsi_data_write(AS_Host *host, char *ptr,
         else
             this_len = len;
 
-        __acornscsi_out(host->card.io_ram + (offset << 1), ptr, this_len);
+        __acornscsi_out(host->base + (offset << 1), ptr, this_len);
 
         offset += this_len;
         ptr += this_len;
@@ -988,10 +985,10 @@ void acornscsi_data_write(AS_Host *host, char *ptr,
         if (offset == (1 << 12)) {
             offset = 0;
             page ++;
-            outb((page & 0x3f) | host->card.page_reg, host->card.io_page);
+            writeb((page & 0x3f) | host->card.page_reg, host->fast + PAGE_REG);
         }
     }
-    outb(host->card.page_reg, host->card.io_page);
+    writeb(host->card.page_reg, host->fast + PAGE_REG);
 }
 
 /* =========================================================================================
@@ -1008,8 +1005,8 @@ void acornscsi_data_write(AS_Host *host, char *ptr,
 static inline
 void acornscsi_dma_stop(AS_Host *host)
 {
-    dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
-    dmac_clearintr(host->dma.io_intr_clear);
+    dmac_write(host, DMAC_MASKREG, MASK_ON);
+    dmac_clearintr(host);
 
 #if (DEBUG & DEBUG_DMA)
     DBG(host->SCpnt, acornscsi_dumpdma(host, "stop"));
@@ -1031,7 +1028,7 @@ void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
 
     host->dma.direction = direction;
 
-    dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
+    dmac_write(host, DMAC_MASKREG, MASK_ON);
 
     if (direction == DMA_OUT) {
 #if (DEBUG & DEBUG_NO_WRITE)
@@ -1062,13 +1059,13 @@ void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
                                 length);
 
         length -= 1;
-        dmac_write(host->dma.io_port, DMAC_TXCNTLO, length);
-        dmac_write(host->dma.io_port, DMAC_TXCNTHI, length >> 8);
-        dmac_write(host->dma.io_port, DMAC_TXADRLO, address);
-        dmac_write(host->dma.io_port, DMAC_TXADRMD, address >> 8);
-        dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
-        dmac_write(host->dma.io_port, DMAC_MODECON, mode);
-        dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
+        dmac_write(host, DMAC_TXCNTLO, length);
+        dmac_write(host, DMAC_TXCNTHI, length >> 8);
+        dmac_write(host, DMAC_TXADRLO, address);
+        dmac_write(host, DMAC_TXADRMD, address >> 8);
+        dmac_write(host, DMAC_TXADRHI, 0);
+        dmac_write(host, DMAC_MODECON, mode);
+        dmac_write(host, DMAC_MASKREG, MASK_OFF);
 
 #if (DEBUG & DEBUG_DMA)
         DBG(host->SCpnt, acornscsi_dumpdma(host, "strt"));
@@ -1088,8 +1085,8 @@ void acornscsi_dma_setup(AS_Host *host, dmadir_t direction)
 static
 void acornscsi_dma_cleanup(AS_Host *host)
 {
-    dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
-    dmac_clearintr(host->dma.io_intr_clear);
+    dmac_write(host, DMAC_MASKREG, MASK_ON);
+    dmac_clearintr(host);
 
     /*
      * Check for a pending transfer
@@ -1116,7 +1113,7 @@ void acornscsi_dma_cleanup(AS_Host *host)
         /*
          * Calculate number of bytes transferred from DMA.
          */
-        transferred = dmac_address(host->dma.io_port) - host->dma.start_addr;
+        transferred = dmac_address(host) - host->dma.start_addr;
         host->dma.transferred += transferred;
 
         if (host->dma.direction == DMA_IN)
@@ -1152,13 +1149,13 @@ void acornscsi_dma_intr(AS_Host *host)
     DBG(host->SCpnt, acornscsi_dumpdma(host, "inti"));
 #endif
 
-    dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_ON);
-    dmac_clearintr(host->dma.io_intr_clear);
+    dmac_write(host, DMAC_MASKREG, MASK_ON);
+    dmac_clearintr(host);
 
     /*
      * Calculate amount transferred via DMA
      */
-    transferred = dmac_address(host->dma.io_port) - host->dma.start_addr;
+    transferred = dmac_address(host) - host->dma.start_addr;
     host->dma.transferred += transferred;
 
     /*
@@ -1190,12 +1187,12 @@ void acornscsi_dma_intr(AS_Host *host)
                                 length);
 
         length -= 1;
-        dmac_write(host->dma.io_port, DMAC_TXCNTLO, length);
-        dmac_write(host->dma.io_port, DMAC_TXCNTHI, length >> 8);
-        dmac_write(host->dma.io_port, DMAC_TXADRLO, address);
-        dmac_write(host->dma.io_port, DMAC_TXADRMD, address >> 8);
-        dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
-        dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
+        dmac_write(host, DMAC_TXCNTLO, length);
+        dmac_write(host, DMAC_TXCNTHI, length >> 8);
+        dmac_write(host, DMAC_TXADRLO, address);
+        dmac_write(host, DMAC_TXADRMD, address >> 8);
+        dmac_write(host, DMAC_TXADRHI, 0);
+        dmac_write(host, DMAC_MASKREG, MASK_OFF);
 
 #if (DEBUG & DEBUG_DMA)
         DBG(host->SCpnt, acornscsi_dumpdma(host, "into"));
@@ -1209,15 +1206,15 @@ void acornscsi_dma_intr(AS_Host *host)
          * attention condition.  We continue giving one byte until
          * the device recognises the attention.
          */
-        if (dmac_read(host->dma.io_port, DMAC_STATUS) & STATUS_RQ0) {
+        if (dmac_read(host, DMAC_STATUS) & STATUS_RQ0) {
             acornscsi_abortcmd(host, host->SCpnt->tag);
 
-            dmac_write(host->dma.io_port, DMAC_TXCNTLO, 0);
-            dmac_write(host->dma.io_port, DMAC_TXCNTHI, 0);
-            dmac_write(host->dma.io_port, DMAC_TXADRLO, 0);
-            dmac_write(host->dma.io_port, DMAC_TXADRMD, 0);
-            dmac_write(host->dma.io_port, DMAC_TXADRHI, 0);
-            dmac_write(host->dma.io_port, DMAC_MASKREG, MASK_OFF);
+            dmac_write(host, DMAC_TXCNTLO, 0);
+            dmac_write(host, DMAC_TXCNTHI, 0);
+            dmac_write(host, DMAC_TXADRLO, 0);
+            dmac_write(host, DMAC_TXADRMD, 0);
+            dmac_write(host, DMAC_TXADRHI, 0);
+            dmac_write(host, DMAC_MASKREG, MASK_OFF);
         }
 #endif
     }
@@ -1271,9 +1268,9 @@ void acornscsi_dma_adjust(AS_Host *host)
             host->dma.xfer_setup = 0;
         else {
             transferred += host->dma.start_addr;
-            dmac_write(host->dma.io_port, DMAC_TXADRLO, transferred);
-            dmac_write(host->dma.io_port, DMAC_TXADRMD, transferred >> 8);
-            dmac_write(host->dma.io_port, DMAC_TXADRHI, transferred >> 16);
+            dmac_write(host, DMAC_TXADRLO, transferred);
+            dmac_write(host, DMAC_TXADRMD, transferred >> 8);
+            dmac_write(host, DMAC_TXADRHI, transferred >> 16);
 #if (DEBUG & (DEBUG_DMA|DEBUG_WRITE))
             DBG(host->SCpnt, acornscsi_dumpdma(host, "adjo"));
 #endif
@@ -1292,12 +1289,12 @@ acornscsi_write_pio(AS_Host *host, char *bytes, int *ptr, int len, unsigned int
         int my_ptr = *ptr;
 
         while (my_ptr < len) {
-                asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
+                asr = sbic_arm_read(host, SBIC_ASR);
 
                 if (asr & ASR_DBR) {
                         timeout = max_timeout;
 
-                        sbic_arm_write(host->scsi.io_port, SBIC_DATA, bytes[my_ptr++]);
+                        sbic_arm_write(host, SBIC_DATA, bytes[my_ptr++]);
                 } else if (asr & ASR_INT)
                         break;
                 else if (--timeout == 0)
@@ -1320,9 +1317,9 @@ acornscsi_sendcommand(AS_Host *host)
 {
         struct scsi_cmnd *SCpnt = host->SCpnt;
 
-    sbic_arm_write(host->scsi.io_port, SBIC_TRANSCNTH, 0);
-    sbic_arm_writenext(host->scsi.io_port, 0);
-    sbic_arm_writenext(host->scsi.io_port, SCpnt->cmd_len - host->scsi.SCp.sent_command);
+    sbic_arm_write(host, SBIC_TRANSCNTH, 0);
+    sbic_arm_writenext(host, 0);
+    sbic_arm_writenext(host, SCpnt->cmd_len - host->scsi.SCp.sent_command);
 
     acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
 
@@ -1351,7 +1348,7 @@ void acornscsi_sendmessage(AS_Host *host)
 
         acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "sending message 1");
 
-        sbic_arm_write(host->scsi.io_port, SBIC_DATA, NOP);
+        sbic_arm_write(host, SBIC_DATA, NOP);
 
         host->scsi.last_message = NOP;
 #if (DEBUG & DEBUG_MESSAGES)
@@ -1365,7 +1362,7 @@ void acornscsi_sendmessage(AS_Host *host)
 
         acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "sending message 2");
 
-        sbic_arm_write(host->scsi.io_port, SBIC_DATA, msg->msg[0]);
+        sbic_arm_write(host, SBIC_DATA, msg->msg[0]);
 
         host->scsi.last_message = msg->msg[0];
 #if (DEBUG & DEBUG_MESSAGES)
@@ -1382,9 +1379,9 @@ void acornscsi_sendmessage(AS_Host *host)
          *  initiator.  This provides an interlock so that the
          *  initiator can determine which message byte is rejected.
          */
-        sbic_arm_write(host->scsi.io_port, SBIC_TRANSCNTH, 0);
-        sbic_arm_writenext(host->scsi.io_port, 0);
-        sbic_arm_writenext(host->scsi.io_port, message_length);
+        sbic_arm_write(host, SBIC_TRANSCNTH, 0);
+        sbic_arm_writenext(host, 0);
+        sbic_arm_writenext(host, message_length);
         acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
 
         msgnr = 0;
@@ -1421,7 +1418,7 @@ void acornscsi_readstatusbyte(AS_Host *host)
 {
     acornscsi_sbic_issuecmd(host, CMND_XFERINFO|CMND_SBT);
     acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "reading status byte");
-    host->scsi.SCp.Status = sbic_arm_read(host->scsi.io_port, SBIC_DATA);
+    host->scsi.SCp.Status = sbic_arm_read(host, SBIC_DATA);
 }
 
 /*
@@ -1438,12 +1435,12 @@ unsigned char acornscsi_readmessagebyte(AS_Host *host)
 
     acornscsi_sbic_wait(host, ASR_DBR, ASR_DBR, 1000, "for message byte");
 
-    message = sbic_arm_read(host->scsi.io_port, SBIC_DATA);
+    message = sbic_arm_read(host, SBIC_DATA);
 
     /* wait for MSGIN-XFER-PAUSED */
     acornscsi_sbic_wait(host, ASR_INT, ASR_INT, 1000, "for interrupt after message byte");
 
-    sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+    sbic_arm_read(host, SBIC_SSR);
 
     return message;
 }
@@ -1480,7 +1477,7 @@ void acornscsi_message(AS_Host *host)
 
             /* wait for next msg-in */
             acornscsi_sbic_wait(host, ASR_INT, ASR_INT, 1000, "for interrupt after negate ack");
-            sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+            sbic_arm_read(host, SBIC_SSR);
         }
     } while (msgidx < msglen);
 
@@ -1602,7 +1599,7 @@ void acornscsi_message(AS_Host *host)
                     host->host->host_no, acornscsi_target(host));
             host->device[host->SCpnt->device->id].sync_xfer = SYNCHTRANSFER_2DBA;
             host->device[host->SCpnt->device->id].sync_state = SYNC_ASYNCHRONOUS;
-            sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
+            sbic_arm_write(host, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
             break;
 
         default:
@@ -1652,7 +1649,7 @@ void acornscsi_message(AS_Host *host)
                 host->device[host->SCpnt->device->id].sync_xfer =
                         calc_sync_xfer(period * 4, length);
             }
-            sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
+            sbic_arm_write(host, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
             break;
 #else
             /* We do not accept synchronous transfers.  Respond with a
@@ -1792,10 +1789,10 @@ int acornscsi_starttransfer(AS_Host *host)
 
     residual = scsi_bufflen(host->SCpnt) - host->scsi.SCp.scsi_xferred;
 
-    sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
-    sbic_arm_writenext(host->scsi.io_port, residual >> 16);
-    sbic_arm_writenext(host->scsi.io_port, residual >> 8);
-    sbic_arm_writenext(host->scsi.io_port, residual);
+    sbic_arm_write(host, SBIC_SYNCHTRANSFER, host->device[host->SCpnt->device->id].sync_xfer);
+    sbic_arm_writenext(host, residual >> 16);
+    sbic_arm_writenext(host, residual >> 8);
+    sbic_arm_writenext(host, residual);
     acornscsi_sbic_issuecmd(host, CMND_XFERINFO);
     return 1;
 }
@@ -1816,7 +1813,7 @@ int acornscsi_reconnect(AS_Host *host)
 {
     unsigned int target, lun, ok = 0;
 
-    target = sbic_arm_read(host->scsi.io_port, SBIC_SOURCEID);
+    target = sbic_arm_read(host, SBIC_SOURCEID);
 
     if (!(target & 8))
         printk(KERN_ERR "scsi%d: invalid source id after reselection "
@@ -1832,7 +1829,7 @@ int acornscsi_reconnect(AS_Host *host)
         host->SCpnt = NULL;
     }
 
-    lun = sbic_arm_read(host->scsi.io_port, SBIC_DATA) & 7;
+    lun = sbic_arm_read(host, SBIC_DATA) & 7;
 
     host->scsi.reconnected.target = target;
     host->scsi.reconnected.lun = lun;
@@ -1952,7 +1949,7 @@ static
 void acornscsi_abortcmd(AS_Host *host, unsigned char tag)
 {
     host->scsi.phase = PHASE_ABORTED;
-    sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_ASSERTATN);
+    sbic_arm_write(host, SBIC_CMND, CMND_ASSERTATN);
 
     msgqueue_flush(&host->scsi.msgs);
 #ifdef CONFIG_SCSI_ACORNSCSI_TAGGED_QUEUE
@@ -1979,11 +1976,11 @@ intr_ret_t acornscsi_sbicintr(AS_Host *host, int in_irq)
 {
     unsigned int asr, ssr;
 
-    asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
+    asr = sbic_arm_read(host, SBIC_ASR);
     if (!(asr & ASR_INT))
         return INTR_IDLE;
 
-    ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+    ssr = sbic_arm_read(host, SBIC_SSR);
 
 #if (DEBUG & DEBUG_PHASES)
     print_sbic_status(asr, ssr, host->scsi.phase);
@@ -1999,15 +1996,15 @@ intr_ret_t acornscsi_sbicintr(AS_Host *host, int in_irq)
         printk(KERN_ERR "scsi%d: reset in standard mode but wanted advanced mode.\n",
                 host->host->host_no);
         /* setup sbic - WD33C93A */
-        sbic_arm_write(host->scsi.io_port, SBIC_OWNID, OWNID_EAF | host->host->this_id);
-        sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_RESET);
+        sbic_arm_write(host, SBIC_OWNID, OWNID_EAF | host->host->this_id);
+        sbic_arm_write(host, SBIC_CMND, CMND_RESET);
         return INTR_IDLE;
 
     case 0x01:                          /* reset state - advanced                       */
-        sbic_arm_write(host->scsi.io_port, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
-        sbic_arm_write(host->scsi.io_port, SBIC_TIMEOUT, TIMEOUT_TIME);
-        sbic_arm_write(host->scsi.io_port, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
-        sbic_arm_write(host->scsi.io_port, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
+        sbic_arm_write(host, SBIC_CTRL, INIT_SBICDMA | CTRL_IDI);
+        sbic_arm_write(host, SBIC_TIMEOUT, TIMEOUT_TIME);
+        sbic_arm_write(host, SBIC_SYNCHTRANSFER, SYNCHTRANSFER_2DBA);
+        sbic_arm_write(host, SBIC_SOURCEID, SOURCEID_ER | SOURCEID_DSP);
         msgqueue_flush(&host->scsi.msgs);
         return INTR_IDLE;
 
@@ -2025,10 +2022,10 @@ intr_ret_t acornscsi_sbicintr(AS_Host *host, int in_irq)
             msgqueue_flush(&host->scsi.msgs);
             host->dma.transferred = host->scsi.SCp.scsi_xferred;
             /* 33C93 gives next interrupt indicating bus phase */
-            asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
+            asr = sbic_arm_read(host, SBIC_ASR);
             if (!(asr & ASR_INT))
                 break;
-            ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+            ssr = sbic_arm_read(host, SBIC_SSR);
             ADD_STATUS(8, ssr, host->scsi.phase, 1);
             ADD_STATUS(host->SCpnt->device->id, ssr, host->scsi.phase, 1);
             goto connected;
@@ -2476,11 +2473,11 @@ acornscsi_intr(int irq, void *dev_id)
     do {
         ret = INTR_IDLE;
 
-        iostatus = inb(host->card.io_intr);
+        iostatus = readb(host->fast + INT_REG);
 
         if (iostatus & 2) {
             acornscsi_dma_intr(host);
-            iostatus = inb(host->card.io_intr);
+            iostatus = readb(host->fast + INT_REG);
         }
 
         if (iostatus & 8)
@@ -2655,7 +2652,7 @@ static enum res_abort acornscsi_do_abort(AS_Host *host, struct scsi_cmnd *SCpnt)
                  * busylun bit.
                  */
                 case PHASE_CONNECTED:
-                        sbic_arm_write(host->scsi.io_port, SBIC_CMND, CMND_DISCONNECT);
+                        sbic_arm_write(host, SBIC_CMND, CMND_DISCONNECT);
                         host->SCpnt = NULL;
                         res = res_success_clear;
                         break;
@@ -2699,8 +2696,8 @@ int acornscsi_abort(struct scsi_cmnd *SCpnt)
 #if (DEBUG & DEBUG_ABORT)
         {
                 int asr, ssr;
-                asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
-                ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+                asr = sbic_arm_read(host, SBIC_ASR);
+                ssr = sbic_arm_read(host, SBIC_SSR);
 
                 printk(KERN_WARNING "acornscsi_abort: ");
                 print_sbic_status(asr, ssr, host->scsi.phase);
@@ -2731,9 +2728,7 @@ int acornscsi_abort(struct scsi_cmnd *SCpnt)
 //#if (DEBUG & DEBUG_ABORT)
                 printk("success\n");
 //#endif
-                SCpnt->result = DID_ABORT << 16;
-                SCpnt->scsi_done(SCpnt);
-                result = SCSI_ABORT_SUCCESS;
+                result = SUCCESS;
                 break;
 
         /*
@@ -2745,7 +2740,7 @@ int acornscsi_abort(struct scsi_cmnd *SCpnt)
 //#if (DEBUG & DEBUG_ABORT)
                 printk("snooze\n");
 //#endif
-                result = SCSI_ABORT_SNOOZE;
+                result = FAILED;
                 break;
 
         /*
@@ -2755,11 +2750,7 @@ int acornscsi_abort(struct scsi_cmnd *SCpnt)
         default:
         case res_not_running:
                 acornscsi_dumplog(host, SCpnt->device->id);
-#if (DEBUG & DEBUG_ABORT)
-                result = SCSI_ABORT_SNOOZE;
-#else
-                result = SCSI_ABORT_NOT_RUNNING;
-#endif
+                result = FAILED;
 //#if (DEBUG & DEBUG_ABORT)
                 printk("not running\n");
 //#endif
@@ -2770,13 +2761,12 @@ int acornscsi_abort(struct scsi_cmnd *SCpnt)
 }
 
 /*
- * Prototype: int acornscsi_reset(struct scsi_cmnd *SCpnt, unsigned int reset_flags)
+ * Prototype: int acornscsi_reset(struct scsi_cmnd *SCpnt)
  * Purpose  : reset a command on this host/reset this host
  * Params   : SCpnt  - command causing reset
- *            result - what type of reset to perform
  * Returns  : one of SCSI_RESET_ macros
  */
-int acornscsi_reset(struct scsi_cmnd *SCpnt, unsigned int reset_flags)
+int acornscsi_bus_reset(struct scsi_cmnd *SCpnt)
 {
         AS_Host *host = (AS_Host *)SCpnt->device->host->hostdata;
         struct scsi_cmnd *SCptr;
@@ -2787,8 +2777,8 @@ int acornscsi_reset(struct scsi_cmnd *SCpnt, unsigned int reset_flags)
     {
         int asr, ssr;
 
-        asr = sbic_arm_read(host->scsi.io_port, SBIC_ASR);
-        ssr = sbic_arm_read(host->scsi.io_port, SBIC_SSR);
+        asr = sbic_arm_read(host, SBIC_ASR);
+        ssr = sbic_arm_read(host, SBIC_SSR);
 
         printk(KERN_WARNING "acornscsi_reset: ");
         print_sbic_status(asr, ssr, host->scsi.phase);
@@ -2798,28 +2788,16 @@ int acornscsi_reset(struct scsi_cmnd *SCpnt, unsigned int reset_flags)
 
     acornscsi_dma_stop(host);
 
-    SCptr = host->SCpnt;
-
     /*
      * do hard reset.  This resets all devices on this host, and so we
      * must set the reset status on all commands.
      */
     acornscsi_resetcard(host);
 
-    /*
-     * report reset on commands current connected/disconnected
-     */
-    acornscsi_reportstatus(&host->SCpnt, &SCptr, DID_RESET);
-
     while ((SCptr = queue_remove(&host->queues.disconnected)) != NULL)
-        acornscsi_reportstatus(&SCptr, &SCpnt, DID_RESET);
-
-    if (SCpnt) {
-        SCpnt->result = DID_RESET << 16;
-        SCpnt->scsi_done(SCpnt);
-    }
+        ;
 
-    return SCSI_RESET_BUS_RESET | SCSI_RESET_HOST_RESET | SCSI_RESET_SUCCESS;
+    return SUCCESS;
 }
 
 /*==============================================================================================
@@ -2850,7 +2828,7 @@ char *acornscsi_info(struct Scsi_Host *host)
     " LINK"
 #endif
 #if (DEBUG & DEBUG_NO_WRITE)
-    " NOWRITE ("NO_WRITE_STR")"
+    " NOWRITE (" __stringify(NO_WRITE) ")"
 #endif
                 , host->hostt->name, host->io_port, host->irq,
                 VER_MAJOR, VER_MINOR, VER_PATCH);
@@ -2881,15 +2859,15 @@ int acornscsi_proc_info(struct Scsi_Host *instance, char *buffer, char **start,
     " LINK"
 #endif
 #if (DEBUG & DEBUG_NO_WRITE)
-    " NOWRITE ("NO_WRITE_STR")"
+    " NOWRITE (" __stringify(NO_WRITE) ")"
 #endif
                 "\n\n", VER_MAJOR, VER_MINOR, VER_PATCH);
 
-    p += sprintf(p,     "SBIC: WD33C93A  Address: %08X  IRQ : %d\n",
-                        host->scsi.io_port, host->scsi.irq);
+    p += sprintf(p,     "SBIC: WD33C93A  Address: %p    IRQ : %d\n",
+                        host->base + SBIC_REGIDX, host->scsi.irq);
 #ifdef USE_DMAC
-    p += sprintf(p,     "DMAC: uPC71071  Address: %08X  IRQ : %d\n\n",
-                        host->dma.io_port, host->scsi.irq);
+    p += sprintf(p,     "DMAC: uPC71071  Address: %p  IRQ : %d\n\n",
+                        host->base + DMAC_OFFSET, host->scsi.irq);
 #endif
 
     p += sprintf(p,     "Statistics:\n"
@@ -2976,9 +2954,8 @@ static struct scsi_host_template acornscsi_template = {
         .name                   = "AcornSCSI",
         .info                   = acornscsi_info,
         .queuecommand           = acornscsi_queuecmd,
-#warning fixme
-        .abort                  = acornscsi_abort,
-        .reset                  = acornscsi_reset,
+        .eh_abort_handler       = acornscsi_abort,
+        .eh_bus_reset_handler   = acornscsi_bus_reset,
         .can_queue              = 16,
         .this_id                = 7,
         .sg_tablesize           = SG_ALL,
@@ -2992,48 +2969,37 @@ acornscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
 {
         struct Scsi_Host *host;
         AS_Host *ashost;
-        int ret = -ENOMEM;
+        int ret;
 
-        host = scsi_host_alloc(&acornscsi_template, sizeof(AS_Host));
-        if (!host)
+        ret = ecard_request_resources(ec);
+        if (ret)
                 goto out;
 
+        host = scsi_host_alloc(&acornscsi_template, sizeof(AS_Host));
+        if (!host) {
+                ret = -ENOMEM;
+                goto out_release;
+        }
+
         ashost = (AS_Host *)host->hostdata;
 
-        host->io_port = ecard_address(ec, ECARD_MEMC, 0);
-        host->irq = ec->irq;
+        ashost->base = ecardm_iomap(ec, ECARD_RES_MEMC, 0, 0);
+        ashost->fast = ecardm_iomap(ec, ECARD_RES_IOCFAST, 0, 0);
+        if (!ashost->base || !ashost->fast)
+                goto out_put;
 
-        ashost->host            = host;
-        ashost->scsi.io_port    = ioaddr(host->io_port + 0x800);
-        ashost->scsi.irq        = host->irq;
-        ashost->card.io_intr    = POD_SPACE(host->io_port) + 0x800;
-        ashost->card.io_page    = POD_SPACE(host->io_port) + 0xc00;
-        ashost->card.io_ram     = ioaddr(host->io_port);
-        ashost->dma.io_port     = host->io_port + 0xc00;
-        ashost->dma.io_intr_clear = POD_SPACE(host->io_port) + 0x800;
+        host->irq = ec->irq;
+        ashost->host = host;
+        ashost->scsi.irq = host->irq;
 
-        ec->irqaddr     = (char *)ioaddr(ashost->card.io_intr);
+        ec->irqaddr     = ashost->fast + INT_REG;
         ec->irqmask     = 0x0a;
 
-        ret = -EBUSY;
-        if (!request_region(host->io_port + 0x800, 2, "acornscsi(sbic)"))
-                goto err_1;
-        if (!request_region(ashost->card.io_intr, 1, "acornscsi(intr)"))
-                goto err_2;
-        if (!request_region(ashost->card.io_page, 1, "acornscsi(page)"))
-                goto err_3;
-#ifdef USE_DMAC
-        if (!request_region(ashost->dma.io_port, 256, "acornscsi(dmac)"))
-                goto err_4;
-#endif
-        if (!request_region(host->io_port, 2048, "acornscsi(ram)"))
-                goto err_5;
-
         ret = request_irq(host->irq, acornscsi_intr, IRQF_DISABLED, "acornscsi", ashost);
         if (ret) {
                 printk(KERN_CRIT "scsi%d: IRQ%d not free: %d\n",
                         host->host_no, ashost->scsi.irq, ret);
-                goto err_6;
+                goto out_put;
         }
 
         memset(&ashost->stats, 0, sizeof (ashost->stats));
@@ -3045,27 +3011,22 @@ acornscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
 
         ret = scsi_add_host(host, &ec->dev);
         if (ret)
-                goto err_7;
+                goto out_irq;
 
         scsi_scan_host(host);
         goto out;
 
- err_7:
+ out_irq:
         free_irq(host->irq, ashost);
- err_6:
-        release_region(host->io_port, 2048);
- err_5:
-#ifdef USE_DMAC
-        release_region(ashost->dma.io_port, 256);
-#endif
- err_4:
-        release_region(ashost->card.io_page, 1);
- err_3:
-        release_region(ashost->card.io_intr, 1);    
- err_2:
-        release_region(host->io_port + 0x800, 2);
- err_1:
+        msgqueue_free(&ashost->scsi.msgs);
+        queue_free(&ashost->queues.disconnected);
+        queue_free(&ashost->queues.issue);
+ out_put:
+        ecardm_iounmap(ec, ashost->fast);
+        ecardm_iounmap(ec, ashost->base);
         scsi_host_put(host);
+ out_release:
+        ecard_release_resources(ec);
  out:
         return ret;
 }
@@ -3081,20 +3042,17 @@ static void __devexit acornscsi_remove(struct expansion_card *ec)
         /*
          * Put card into RESET state
          */
-        outb(0x80, ashost->card.io_page);
+        writeb(0x80, ashost->fast + PAGE_REG);
 
         free_irq(host->irq, ashost);
 
-        release_region(host->io_port + 0x800, 2);
-        release_region(ashost->card.io_intr, 1);
-        release_region(ashost->card.io_page, 1);
-        release_region(ashost->dma.io_port, 256);
-        release_region(host->io_port, 2048);
-
         msgqueue_free(&ashost->scsi.msgs);
         queue_free(&ashost->queues.disconnected);
         queue_free(&ashost->queues.issue);
+        ecardm_iounmap(ec, ashost->fast);
+        ecardm_iounmap(ec, ashost->base);
         scsi_host_put(host);
+        ecard_release_resources(ec);
 }
 
 static const struct ecard_id acornscsi_cids[] = {
diff --git a/drivers/scsi/arm/acornscsi.h b/drivers/scsi/arm/acornscsi.h
index d11424b89f42..8d2172a0b351 100644
--- a/drivers/scsi/arm/acornscsi.h
+++ b/drivers/scsi/arm/acornscsi.h
@@ -179,7 +179,6 @@
 
 /* miscellaneous internal variables */
 
-#define POD_SPACE(x)    ((x) + 0xd0000)
 #define MASK_ON         (MASKREG_M3|MASKREG_M2|MASKREG_M1|MASKREG_M0)
 #define MASK_OFF        (MASKREG_M3|MASKREG_M2|MASKREG_M1)
 
@@ -279,10 +278,11 @@ typedef struct acornscsi_hostdata {
     struct Scsi_Host    *host;                  /* host                                 */
     struct scsi_cmnd    *SCpnt;                 /* currently processing command         */
     struct scsi_cmnd    *origSCpnt;             /* original connecting command          */
+    void __iomem        *base;                  /* memc base address                    */
+    void __iomem        *fast;                  /* fast ioc base address                */
 
     /* driver information */
     struct {
-        unsigned int    io_port;                /* base address of WD33C93              */
         unsigned int    irq;                    /* interrupt                            */
         phase_t         phase;                  /* current phase                        */
 
@@ -329,8 +329,6 @@ typedef struct acornscsi_hostdata {
 
     /* DMA info */
     struct {
-        unsigned int    io_port;                /* base address of DMA controller       */
-        unsigned int    io_intr_clear;          /* address of DMA interrupt clear       */
         unsigned int    free_addr;              /* next free address                    */
         unsigned int    start_addr;             /* start address of current transfer    */
         dmadir_t        direction;              /* dma direction                        */
@@ -345,9 +343,6 @@ typedef struct acornscsi_hostdata {
 
     /* card info */
     struct {
-        unsigned int    io_intr;                /* base address of interrupt id reg     */
-        unsigned int    io_page;                /* base address of page reg             */
-        unsigned int    io_ram;                 /* base address of RAM access           */
         unsigned char   page_reg;               /* current setting of page reg          */
     } card;
 
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index a0b6d414953d..59fbef08d690 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -2359,6 +2359,24 @@ void scsi_esp_unregister(struct esp *esp)
 }
 EXPORT_SYMBOL(scsi_esp_unregister);
 
+static int esp_target_alloc(struct scsi_target *starget)
+{
+        struct esp *esp = shost_priv(dev_to_shost(&starget->dev));
+        struct esp_target_data *tp = &esp->target[starget->id];
+
+        tp->starget = starget;
+
+        return 0;
+}
+
+static void esp_target_destroy(struct scsi_target *starget)
+{
+        struct esp *esp = shost_priv(dev_to_shost(&starget->dev));
+        struct esp_target_data *tp = &esp->target[starget->id];
+
+        tp->starget = NULL;
+}
+
 static int esp_slave_alloc(struct scsi_device *dev)
 {
         struct esp *esp = shost_priv(dev->host);
@@ -2370,8 +2388,6 @@ static int esp_slave_alloc(struct scsi_device *dev)
                 return -ENOMEM;
         dev->hostdata = lp;
 
-        tp->starget = dev->sdev_target;
-
         spi_min_period(tp->starget) = esp->min_period;
         spi_max_offset(tp->starget) = 15;
 
@@ -2608,6 +2624,8 @@ struct scsi_host_template scsi_esp_template = {
         .name                   = "esp",
         .info                   = esp_info,
         .queuecommand           = esp_queuecommand,
+        .target_alloc           = esp_target_alloc,
+        .target_destroy         = esp_target_destroy,
         .slave_alloc            = esp_slave_alloc,
         .slave_configure        = esp_slave_configure,
         .slave_destroy          = esp_slave_destroy,
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 45df83b9d847..0fe031f003e7 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -61,7 +61,7 @@ static int ses_probe(struct device *dev)
         return err;
 }
 
-#define SES_TIMEOUT 30
+#define SES_TIMEOUT (30 * HZ)
 #define SES_RETRIES 3
 
 static int ses_recv_diag(struct scsi_device *sdev, int page_code,
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 9bc42763623c..18ca9075e131 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -448,22 +448,27 @@ config SERIAL_CLPS711X_CONSOLE
           your boot loader (lilo or loadlin) about how to pass options to the
           kernel at boot time.)
 
-config SERIAL_S3C2410
-        tristate "Samsung S3C2410/S3C2440/S3C2442/S3C2412 Serial port support"
-        depends on ARM && ARCH_S3C2410
-        select SERIAL_CORE
+config SERIAL_SAMSUNG
+        tristate "Samsung SoC serial support"
+        depends on ARM && PLAT_S3C24XX
         help
           Support for the on-chip UARTs on the Samsung S3C24XX series CPUs,
           providing /dev/ttySAC0, 1 and 2 (note, some machines may not
           provide all of these ports, depending on how the serial port
           pins are configured.
 
-          Currently this driver supports the UARTS on the S3C2410, S3C2440,
-          S3C2442, S3C2412 and S3C2413 CPUs.
+config SERIAL_SAMSUNG_DEBUG
+        bool "Samsung SoC serial debug"
+        depends on SERIAL_SAMSUNG
+        help
+          Add support for debugging the serial driver. Since this is
+          generally being used as a console, we use our own output
+          routines that go via the low-level debug printascii()
+          function.
 
-config SERIAL_S3C2410_CONSOLE
-        bool "Support for console on S3C2410 serial port"
-        depends on SERIAL_S3C2410=y
+config SERIAL_SAMSUNG_CONSOLE
+        bool "Support for console on Samsung SoC serial port"
+        depends on SERIAL_SAMSUNG=y
         select SERIAL_CORE_CONSOLE
         help
           Allow selection of the S3C24XX on-board serial ports for use as
@@ -476,6 +481,37 @@ config SERIAL_S3C2410_CONSOLE
           your boot loader about how to pass options to the kernel at
           boot time.)
 
+config SERIAL_S3C2400
+        tristate "Samsung S3C2410 Serial port support"
+        depends on ARM && SERIAL_SAMSUNG && CPU_S3C2400
+        default y if CPU_S3C2400
+        help
+          Serial port support for the Samsung S3C2400 SoC
+
+config SERIAL_S3C2410
+        tristate "Samsung S3C2410 Serial port support"
+        depends on SERIAL_SAMSUNG && CPU_S3C2410
+        default y if CPU_S3C2410
+        help
+          Serial port support for the Samsung S3C2410 SoC
+
+config SERIAL_S3C2412
+        tristate "Samsung S3C2412/S3C2413 Serial port support"
+        depends on SERIAL_SAMSUNG && CPU_S3C2412
+        default y if CPU_S3C2412
+        help
+          Serial port support for the Samsung S3C2412 and S3C2413 SoC
+
+config SERIAL_S3C2440
+        tristate "Samsung S3C2440/S3C2442 Serial port support"
+        depends on SERIAL_SAMSUNG && (CPU_S3C2440 || CPU_S3C2442)
+        default y if CPU_S3C2440
+        default y if CPU_S3C2442
+        help
+          Serial port support for the Samsung S3C2440 and S3C2442 SoC
+
+
+
 config SERIAL_DZ
         bool "DECstation DZ serial driver"
         depends on MACH_DECSTATION && 32BIT
@@ -753,7 +789,7 @@ config BFIN_UART3_CTSRTS
 
 config SERIAL_IMX
         bool "IMX serial port support"
-        depends on ARM && ARCH_IMX
+        depends on ARM && (ARCH_IMX || ARCH_MXC)
         select SERIAL_CORE
         help
           If you have a machine based on a Motorola IMX CPU you
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 0d9c09b1e836..7d85c1fbe7e0 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -28,7 +28,11 @@ obj-$(CONFIG_SERIAL_PNX8XXX) += pnx8xxx_uart.o
 obj-$(CONFIG_SERIAL_SA1100) += sa1100.o
 obj-$(CONFIG_SERIAL_BFIN) += bfin_5xx.o
 obj-$(CONFIG_SERIAL_BFIN_SPORT) += bfin_sport_uart.o
+obj-$(CONFIG_SERIAL_SAMSUNG) += samsung.o
+obj-$(CONFIG_SERIAL_S3C2400) += s3c2400.o
 obj-$(CONFIG_SERIAL_S3C2410) += s3c2410.o
+obj-$(CONFIG_SERIAL_S3C2412) += s3c2412.o
+obj-$(CONFIG_SERIAL_S3C2440) += s3c2440.o
 obj-$(CONFIG_SERIAL_SUNCORE) += suncore.o
 obj-$(CONFIG_SERIAL_SUNHV) += sunhv.o
 obj-$(CONFIG_SERIAL_SUNZILOG) += sunzilog.o
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 5a375bf0ebf4..64acb39a51ba 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -40,6 +40,7 @@
 #include <linux/tty_flip.h>
 #include <linux/serial_core.h>
 #include <linux/serial.h>
+#include <linux/clk.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -61,6 +62,11 @@
 #define UBIR  0xa4 /* BRM Incremental Register */
 #define UBMR  0xa8 /* BRM Modulator Register */
 #define UBRC  0xac /* Baud Rate Count Register */
+#if defined CONFIG_ARCH_MX3 || defined CONFIG_ARCH_MX2
+#define ONEMS 0xb0 /* One Millisecond register */
+#define UTS   0xb4 /* UART Test Register */
+#endif
+#ifdef CONFIG_ARCH_IMX
 #define BIPR1 0xb0 /* Incremental Preset Register 1 */
 #define BIPR2 0xb4 /* Incremental Preset Register 2 */
 #define BIPR3 0xb8 /* Incremental Preset Register 3 */
@@ -70,6 +76,7 @@
 #define BMPR3 0xc8 /* BRM Modulator Register 3 */
 #define BMPR4 0xcc /* BRM Modulator Register 4 */
 #define UTS   0xd0 /* UART Test Register */
+#endif
 
 /* UART Control Register Bit Fields.*/
 #define  URXD_CHARRDY    (1<<15)
@@ -89,7 +96,12 @@
 #define  UCR1_RTSDEN     (1<<5)  /* RTS delta interrupt enable */
 #define  UCR1_SNDBRK     (1<<4)  /* Send break */
 #define  UCR1_TDMAEN     (1<<3)  /* Transmitter ready DMA enable */
+#ifdef CONFIG_ARCH_IMX
 #define  UCR1_UARTCLKEN  (1<<2)  /* UART clock enabled */
+#endif
+#if defined CONFIG_ARCH_MX3 || defined CONFIG_ARCH_MX2
+#define  UCR1_UARTCLKEN  (0)     /* not present on mx2/mx3 */
+#endif
 #define  UCR1_DOZE       (1<<1)  /* Doze */
 #define  UCR1_UARTEN     (1<<0)  /* UART enabled */
 #define  UCR2_ESCI       (1<<15) /* Escape seq interrupt enable */
@@ -163,8 +175,19 @@
 #define  UTS_SOFTRST     (1<<0)  /* Software reset */
 
 /* We've been assigned a range on the "Low-density serial ports" major */
+#ifdef CONFIG_ARCH_IMX
 #define SERIAL_IMX_MAJOR        204
 #define MINOR_START             41
+#define DEV_NAME                "ttySMX"
+#define MAX_INTERNAL_IRQ        IMX_IRQS
+#endif
+
+#if defined CONFIG_ARCH_MX3 || defined CONFIG_ARCH_MX2
+#define SERIAL_IMX_MAJOR        207
+#define MINOR_START             16
+#define DEV_NAME                "ttymxc"
+#define MAX_INTERNAL_IRQ        MXC_MAX_INT_LINES
+#endif
 
 /*
  * This determines how often we check the modem status signals
@@ -176,12 +199,15 @@
 
 #define DRIVER_NAME "IMX-uart"
 
+#define UART_NR 8
+
 struct imx_port {
         struct uart_port        port;
         struct timer_list       timer;
         unsigned int            old_status;
         int                     txirq,rxirq,rtsirq;
         int                     have_rtscts:1;
+        struct clk              *clk;
 };
 
 /*
@@ -405,6 +431,26 @@ out:
         return IRQ_HANDLED;
 }
 
+static irqreturn_t imx_int(int irq, void *dev_id)
+{
+        struct imx_port *sport = dev_id;
+        unsigned int sts;
+
+        sts = readl(sport->port.membase + USR1);
+
+        if (sts & USR1_RRDY)
+                imx_rxint(irq, dev_id);
+
+        if (sts & USR1_TRDY &&
+                        readl(sport->port.membase + UCR1) & UCR1_TXMPTYEN)
+                imx_txint(irq, dev_id);
+
+        if (sts & USR1_RTSS)
+                imx_rtsint(irq, dev_id);
+
+        return IRQ_HANDLED;
+}
+
 /*
  * Return TIOCSER_TEMT when transmitter is not busy.
  */
@@ -477,7 +523,8 @@ static int imx_setup_ufcr(struct imx_port *sport, unsigned int mode)
          * RFDIV is set such way to satisfy requested uartclk value
          */
         val = TXTL << 10 | RXTL;
-        ufcr_rfdiv = (imx_get_perclk1() + sport->port.uartclk / 2) / sport->port.uartclk;
+        ufcr_rfdiv = (clk_get_rate(sport->clk) + sport->port.uartclk / 2)
+                        / sport->port.uartclk;
 
         if(!ufcr_rfdiv)
                 ufcr_rfdiv = 1;
@@ -509,21 +556,34 @@ static int imx_startup(struct uart_port *port)
         writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
 
         /*
-         * Allocate the IRQ
+         * Allocate the IRQ(s) i.MX1 has three interrupts whereas later
+         * chips only have one interrupt.
          */
-        retval = request_irq(sport->rxirq, imx_rxint, 0,
-                             DRIVER_NAME, sport);
-        if (retval) goto error_out1;
-
-        retval = request_irq(sport->txirq, imx_txint, 0,
-                             DRIVER_NAME, sport);
-        if (retval) goto error_out2;
-
-        retval = request_irq(sport->rtsirq, imx_rtsint,
-                             (sport->rtsirq < IMX_IRQS) ? 0 :
+        if (sport->txirq > 0) {
+                retval = request_irq(sport->rxirq, imx_rxint, 0,
+                                DRIVER_NAME, sport);
+                if (retval)
+                        goto error_out1;
+
+                retval = request_irq(sport->txirq, imx_txint, 0,
+                                DRIVER_NAME, sport);
+                if (retval)
+                        goto error_out2;
+
+                retval = request_irq(sport->rtsirq, imx_rtsint,
+                             (sport->rtsirq < MAX_INTERNAL_IRQ) ? 0 :
                                IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
-                             DRIVER_NAME, sport);
-        if (retval) goto error_out3;
+                                DRIVER_NAME, sport);
+                if (retval)
+                        goto error_out3;
+        } else {
+                retval = request_irq(sport->port.irq, imx_int, 0,
+                                DRIVER_NAME, sport);
+                if (retval) {
+                        free_irq(sport->port.irq, sport);
+                        goto error_out1;
+                }
+        }
 
         /*
          * Finally, clear and enable interrupts
@@ -548,9 +608,11 @@ static int imx_startup(struct uart_port *port)
         return 0;
 
 error_out3:
-        free_irq(sport->txirq, sport);
+        if (sport->txirq)
+                free_irq(sport->txirq, sport);
 error_out2:
-        free_irq(sport->rxirq, sport);
+        if (sport->rxirq)
+                free_irq(sport->rxirq, sport);
 error_out1:
         return retval;
 }
@@ -568,9 +630,12 @@ static void imx_shutdown(struct uart_port *port)
         /*
          * Free the interrupts
          */
-        free_irq(sport->rtsirq, sport);
-        free_irq(sport->txirq, sport);
-        free_irq(sport->rxirq, sport);
+        if (sport->txirq > 0) {
+                free_irq(sport->rtsirq, sport);
+                free_irq(sport->txirq, sport);
+                free_irq(sport->rxirq, sport);
+        } else
+                free_irq(sport->port.irq, sport);
 
         /*
          * Disable all interrupts, port and break condition.
@@ -589,6 +654,7 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
         unsigned long flags;
         unsigned int ucr2, old_ucr1, old_txrxen, baud, quot;
         unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8;
+        unsigned int div, num, denom, ufcr;
 
         /*
          * If we don't support modem control lines, don't allow
@@ -634,7 +700,7 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
         /*
          * Ask the core to calculate the divisor for us.
          */
-        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
+        baud = uart_get_baud_rate(port, termios, old, 50, port->uartclk / 16);
         quot = uart_get_divisor(port, baud);
 
         spin_lock_irqsave(&sport->port.lock, flags);
@@ -684,14 +750,41 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
                         sport->port.membase + UCR2);
         old_txrxen &= (UCR2_TXEN | UCR2_RXEN);
 
-        /* set the baud rate. We assume uartclk = 16 MHz
-         *
-         * baud * 16   UBIR - 1
-         * --------- = --------
-         *  uartclk    UBMR - 1
-         */
-        writel((baud / 100) - 1, sport->port.membase + UBIR);
-        writel(10000 - 1, sport->port.membase + UBMR);
+        div = sport->port.uartclk / (baud * 16);
+        if (div > 7)
+                div = 7;
+        if (!div)
+                div = 1;
+
+        num = baud;
+        denom = port->uartclk / div / 16;
+
+        /* shift num and denom right until they fit into 16 bits */
+        while (num > 0x10000 || denom > 0x10000) {
+                num >>= 1;
+                denom >>= 1;
+        }
+        if (num > 0)
+                num -= 1;
+        if (denom > 0)
+                denom -= 1;
+
+        writel(num, sport->port.membase + UBIR);
+        writel(denom, sport->port.membase + UBMR);
+
+        if (div == 7)
+                div = 6; /* 6 in RFDIV means divide by 7 */
+        else
+                div = 6 - div;
+
+        ufcr = readl(sport->port.membase + UFCR);
+        ufcr = (ufcr & (~UFCR_RFDIV)) |
+            (div << 7);
+        writel(ufcr, sport->port.membase + UFCR);
+
+#ifdef ONEMS
+        writel(sport->port.uartclk / div / 1000, sport->port.membase + ONEMS);
+#endif
 
         writel(old_ucr1, sport->port.membase + UCR1);
 
@@ -801,65 +894,7 @@ static struct uart_ops imx_pops = {
         .verify_port    = imx_verify_port,
 };
 
-static struct imx_port imx_ports[] = {
-        {
-        .txirq  = UART1_MINT_TX,
-        .rxirq  = UART1_MINT_RX,
-        .rtsirq = UART1_MINT_RTS,
-        .port   = {
-                .type           = PORT_IMX,
-                .iotype         = UPIO_MEM,
-                .membase        = (void *)IMX_UART1_BASE,
-                .mapbase        = 0x00206000,
-                .irq            = UART1_MINT_RX,
-                .uartclk        = 16000000,
-                .fifosize       = 32,
-                .flags          = UPF_BOOT_AUTOCONF,
-                .ops            = &imx_pops,
-                .line           = 0,
-        },
-        }, {
-        .txirq  = UART2_MINT_TX,
-        .rxirq  = UART2_MINT_RX,
-        .rtsirq = UART2_MINT_RTS,
-        .port   = {
-                .type           = PORT_IMX,
-                .iotype         = UPIO_MEM,
-                .membase        = (void *)IMX_UART2_BASE,
-                .mapbase        = 0x00207000,
-                .irq            = UART2_MINT_RX,
-                .uartclk        = 16000000,
-                .fifosize       = 32,
-                .flags          = UPF_BOOT_AUTOCONF,
-                .ops            = &imx_pops,
-                .line           = 1,
-        },
-        }
-};
-
-/*
- * Setup the IMX serial ports.
- * Note also that we support "console=ttySMXx" where "x" is either 0 or 1.
- * Which serial port this ends up being depends on the machine you're
- * running this kernel on.  I'm not convinced that this is a good idea,
- * but that's the way it traditionally works.
- *
- */
-static void __init imx_init_ports(void)
-{
-        static int first = 1;
-        int i;
-
-        if (!first)
-                return;
-        first = 0;
-
-        for (i = 0; i < ARRAY_SIZE(imx_ports); i++) {
-                init_timer(&imx_ports[i].timer);
-                imx_ports[i].timer.function = imx_timeout;
-                imx_ports[i].timer.data     = (unsigned long)&imx_ports[i];
-        }
-}
+static struct imx_port *imx_ports[UART_NR];
 
 #ifdef CONFIG_SERIAL_IMX_CONSOLE
 static void imx_console_putchar(struct uart_port *port, int ch)
@@ -878,7 +913,7 @@ static void imx_console_putchar(struct uart_port *port, int ch)
 static void
 imx_console_write(struct console *co, const char *s, unsigned int count)
 {
-        struct imx_port *sport = &imx_ports[co->index];
+        struct imx_port *sport = imx_ports[co->index];
         unsigned int old_ucr1, old_ucr2;
 
         /*
@@ -944,7 +979,7 @@ imx_console_get_options(struct imx_port *sport, int *baud,
                 else
                         ucfr_rfdiv = 6 - ucfr_rfdiv;
 
-                uartclk = imx_get_perclk1();
+                uartclk = clk_get_rate(sport->clk);
                 uartclk /= ucfr_rfdiv;
 
                 {       /*
@@ -984,7 +1019,7 @@ imx_console_setup(struct console *co, char *options)
          */
         if (co->index == -1 || co->index >= ARRAY_SIZE(imx_ports))
                 co->index = 0;
-        sport = &imx_ports[co->index];
+        sport = imx_ports[co->index];
 
         if (options)
                 uart_parse_options(options, &baud, &parity, &bits, &flow);
@@ -998,7 +1033,7 @@ imx_console_setup(struct console *co, char *options)
 
 static struct uart_driver imx_reg;
 static struct console imx_console = {
-        .name           = "ttySMX",
+        .name           = DEV_NAME,
         .write          = imx_console_write,
         .device         = uart_console_device,
         .setup          = imx_console_setup,
@@ -1007,14 +1042,6 @@ static struct console imx_console = {
         .data           = &imx_reg,
 };
 
-static int __init imx_rs_console_init(void)
-{
-        imx_init_ports();
-        register_console(&imx_console);
-        return 0;
-}
-console_initcall(imx_rs_console_init);
-
 #define IMX_CONSOLE     &imx_console
 #else
 #define IMX_CONSOLE     NULL
@@ -1023,7 +1050,7 @@ console_initcall(imx_rs_console_init);
 static struct uart_driver imx_reg = {
         .owner          = THIS_MODULE,
         .driver_name    = DRIVER_NAME,
-        .dev_name       = "ttySMX",
+        .dev_name       = DEV_NAME,
         .major          = SERIAL_IMX_MAJOR,
         .minor          = MINOR_START,
         .nr             = ARRAY_SIZE(imx_ports),
@@ -1050,29 +1077,98 @@ static int serial_imx_resume(struct platform_device *dev)
         return 0;
 }
 
-static int serial_imx_probe(struct platform_device *dev)
+static int serial_imx_probe(struct platform_device *pdev)
 {
+        struct imx_port *sport;
         struct imxuart_platform_data *pdata;
+        void __iomem *base;
+        int ret = 0;
+        struct resource *res;
+
+        sport = kzalloc(sizeof(*sport), GFP_KERNEL);
+        if (!sport)
+                return -ENOMEM;
 
-        imx_ports[dev->id].port.dev = &dev->dev;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENODEV;
+                goto free;
+        }
+
+        base = ioremap(res->start, PAGE_SIZE);
+        if (!base) {
+                ret = -ENOMEM;
+                goto free;
+        }
+
+        sport->port.dev = &pdev->dev;
+        sport->port.mapbase = res->start;
+        sport->port.membase = base;
+        sport->port.type = PORT_IMX,
+        sport->port.iotype = UPIO_MEM;
+        sport->port.irq = platform_get_irq(pdev, 0);
+        sport->rxirq = platform_get_irq(pdev, 0);
+        sport->txirq = platform_get_irq(pdev, 1);
+        sport->rtsirq = platform_get_irq(pdev, 2);
+        sport->port.fifosize = 32;
+        sport->port.ops = &imx_pops;
+        sport->port.flags = UPF_BOOT_AUTOCONF;
+        sport->port.line = pdev->id;
+        init_timer(&sport->timer);
+        sport->timer.function = imx_timeout;
+        sport->timer.data     = (unsigned long)sport;
+
+        sport->clk = clk_get(&pdev->dev, "uart_clk");
+        if (IS_ERR(sport->clk)) {
+                ret = PTR_ERR(sport->clk);
+                goto unmap;
+        }
+        clk_enable(sport->clk);
 
-        pdata = (struct imxuart_platform_data *)dev->dev.platform_data;
+        sport->port.uartclk = clk_get_rate(sport->clk);
+
+        imx_ports[pdev->id] = sport;
+
+        pdata = pdev->dev.platform_data;
         if(pdata && (pdata->flags & IMXUART_HAVE_RTSCTS))
-                imx_ports[dev->id].have_rtscts = 1;
+                sport->have_rtscts = 1;
+
+        if (pdata->init)
+                pdata->init(pdev);
+
+        uart_add_one_port(&imx_reg, &sport->port);
+        platform_set_drvdata(pdev, &sport->port);
 
-        uart_add_one_port(&imx_reg, &imx_ports[dev->id].port);
-        platform_set_drvdata(dev, &imx_ports[dev->id]);
         return 0;
+unmap:
+        iounmap(sport->port.membase);
+free:
+        kfree(sport);
+
+        return ret;
 }
 
-static int serial_imx_remove(struct platform_device *dev)
+static int serial_imx_remove(struct platform_device *pdev)
 {
-        struct imx_port *sport = platform_get_drvdata(dev);
+        struct imxuart_platform_data *pdata;
+        struct imx_port *sport = platform_get_drvdata(pdev);
 
-        platform_set_drvdata(dev, NULL);
+        pdata = pdev->dev.platform_data;
 
-        if (sport)
+        platform_set_drvdata(pdev, NULL);
+
+        if (sport) {
                 uart_remove_one_port(&imx_reg, &sport->port);
+                clk_put(sport->clk);
+        }
+
+        clk_disable(sport->clk);
+
+        if (pdata->exit)
+                pdata->exit(pdev);
+
+        iounmap(sport->port.membase);
+        kfree(sport);
 
         return 0;
 }
@@ -1095,8 +1191,6 @@ static int __init imx_serial_init(void)
 
         printk(KERN_INFO "Serial: IMX driver\n");
 
-        imx_init_ports();
-
         ret = uart_register_driver(&imx_reg);
         if (ret)
                 return ret;
diff --git a/drivers/serial/s3c2400.c b/drivers/serial/s3c2400.c
new file mode 100644
index 000000000000..a1102053e553
--- /dev/null
+++ b/drivers/serial/s3c2400.c
@@ -0,0 +1,106 @@
+/* linux/drivers/serial/s3c240.c
+ *
+ * Driver for Samsung SoC onboard UARTs.
+ *
+ * Ben Dooks, Copyright (c) 2003-2005 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *
+ * 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/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include <asm/irq.h>
+
+#include <asm/hardware.h>
+
+#include <asm/plat-s3c/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "samsung.h"
+
+static int s3c2400_serial_getsource(struct uart_port *port,
+                                    struct s3c24xx_uart_clksrc *clk)
+{
+        clk->divisor = 1;
+        clk->name = "pclk";
+
+        return 0;
+}
+
+static int s3c2400_serial_setsource(struct uart_port *port,
+                                    struct s3c24xx_uart_clksrc *clk)
+{
+        return 0;
+}
+
+static int s3c2400_serial_resetport(struct uart_port *port,
+                                    struct s3c2410_uartcfg *cfg)
+{
+        dbg("s3c2400_serial_resetport: port=%p (%08lx), cfg=%p\n",
+            port, port->mapbase, cfg);
+
+        wr_regl(port, S3C2410_UCON,  cfg->ucon);
+        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
+
+        /* reset both fifos */
+
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
+
+        return 0;
+}
+
+static struct s3c24xx_uart_info s3c2400_uart_inf = {
+        .name           = "Samsung S3C2400 UART",
+        .type           = PORT_S3C2400,
+        .fifosize       = 16,
+        .rx_fifomask    = S3C2410_UFSTAT_RXMASK,
+        .rx_fifoshift   = S3C2410_UFSTAT_RXSHIFT,
+        .rx_fifofull    = S3C2410_UFSTAT_RXFULL,
+        .tx_fifofull    = S3C2410_UFSTAT_TXFULL,
+        .tx_fifomask    = S3C2410_UFSTAT_TXMASK,
+        .tx_fifoshift   = S3C2410_UFSTAT_TXSHIFT,
+        .get_clksrc     = s3c2400_serial_getsource,
+        .set_clksrc     = s3c2400_serial_setsource,
+        .reset_port     = s3c2400_serial_resetport,
+};
+
+static int s3c2400_serial_probe(struct platform_device *dev)
+{
+        return s3c24xx_serial_probe(dev, &s3c2400_uart_inf);
+}
+
+static struct platform_driver s3c2400_serial_drv = {
+        .probe          = s3c2400_serial_probe,
+        .remove         = s3c24xx_serial_remove,
+        .driver         = {
+                .name   = "s3c2400-uart",
+                .owner  = THIS_MODULE,
+        },
+};
+
+s3c24xx_console_init(&s3c2400_serial_drv, &s3c2400_uart_inf);
+
+static inline int s3c2400_serial_init(void)
+{
+        return s3c24xx_serial_init(&s3c2400_serial_drv, &s3c2400_uart_inf);
+}
+
+static inline void s3c2400_serial_exit(void)
+{
+        platform_driver_unregister(&s3c2400_serial_drv);
+}
+
+module_init(s3c2400_serial_init);
+module_exit(s3c2400_serial_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_DESCRIPTION("Samsung S3C2400 SoC Serial port driver");
+MODULE_ALIAS("platform:s3c2400-uart");
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index 2b6a013639e6..c5f03f41686f 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -1,1270 +1,30 @@
-/*
- * linux/drivers/serial/s3c2410.c
+/* linux/drivers/serial/s3c2410.c
  *
- * Driver for onboard UARTs on the Samsung S3C24XX
+ * Driver for Samsung S3C2410 SoC onboard UARTs.
  *
- * Based on drivers/char/serial.c and drivers/char/21285.c
+ * Ben Dooks, Copyright (c) 2003-2005,2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
  *
- * Ben Dooks, (c) 2003-2005 Simtec Electronics
- *      http://www.simtec.co.uk/products/SWLINUX/
- *
- * Changelog:
- *
- * 22-Jul-2004  BJD  Finished off device rewrite
- *
- * 21-Jul-2004  BJD  Thanks to <herbet@13thfloor.at> for pointing out
- *                   problems with baud rate and loss of IR settings. Update
- *                   to add configuration via platform_device structure
- *
- * 28-Sep-2004  BJD  Re-write for the following items
- *                   - S3C2410 and S3C2440 serial support
- *                   - Power Management support
- *                   - Fix console via IrDA devices
- *                   - SysReq (Herbert Pötzl)
- *                   - Break character handling (Herbert Pötzl)
- *                   - spin-lock initialisation (Dimitry Andric)
- *                   - added clock control
- *                   - updated init code to use platform_device info
- *
- * 06-Mar-2005  BJD  Add s3c2440 fclk clock source
- *
- * 09-Mar-2005  BJD  Add s3c2400 support
- *
- * 10-Mar-2005  LCVR Changed S3C2410_VA_UART to S3C24XX_VA_UART
-*/
-
-/* Note on 2440 fclk clock source handling
- *
- * Whilst it is possible to use the fclk as clock source, the method
- * of properly switching too/from this is currently un-implemented, so
- * whichever way is configured at startup is the one that will be used.
-*/
-
-/* Hote on 2410 error handling
- *
- * The s3c2410 manual has a love/hate affair with the contents of the
- * UERSTAT register in the UART blocks, and keeps marking some of the
- * error bits as reserved. Having checked with the s3c2410x01,
- * it copes with BREAKs properly, so I am happy to ignore the RESERVED
- * feature from the latter versions of the manual.
- *
- * If it becomes aparrent that latter versions of the 2410 remove these
- * bits, then action will have to be taken to differentiate the versions
- * and change the policy on BREAK
- *
- * BJD, 04-Nov-2004
+ * 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.
 */
 
-
-#if defined(CONFIG_SERIAL_S3C2410_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
-#define SUPPORT_SYSRQ
-#endif
-
 #include <linux/module.h>
 #include <linux/ioport.h>
+#include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/init.h>
-#include <linux/sysrq.h>
-#include <linux/console.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
 #include <linux/serial_core.h>
 #include <linux/serial.h>
-#include <linux/delay.h>
-#include <linux/clk.h>
 
-#include <asm/io.h>
 #include <asm/irq.h>
-
 #include <asm/hardware.h>
 
 #include <asm/plat-s3c/regs-serial.h>
 #include <asm/arch/regs-gpio.h>
 
-/* structures */
-
-struct s3c24xx_uart_info {
-        char                    *name;
-        unsigned int            type;
-        unsigned int            fifosize;
-        unsigned long           rx_fifomask;
-        unsigned long           rx_fifoshift;
-        unsigned long           rx_fifofull;
-        unsigned long           tx_fifomask;
-        unsigned long           tx_fifoshift;
-        unsigned long           tx_fifofull;
-
-        /* clock source control */
-
-        int (*get_clksrc)(struct uart_port *, struct s3c24xx_uart_clksrc *clk);
-        int (*set_clksrc)(struct uart_port *, struct s3c24xx_uart_clksrc *clk);
-
-        /* uart controls */
-        int (*reset_port)(struct uart_port *, struct s3c2410_uartcfg *);
-};
-
-struct s3c24xx_uart_port {
-        unsigned char                   rx_claimed;
-        unsigned char                   tx_claimed;
-
-        struct s3c24xx_uart_info        *info;
-        struct s3c24xx_uart_clksrc      *clksrc;
-        struct clk                      *clk;
-        struct clk                      *baudclk;
-        struct uart_port                port;
-};
-
-
-/* configuration defines */
-
-#if 0
-#if 1
-/* send debug to the low-level output routines */
-
-extern void printascii(const char *);
-
-static void
-s3c24xx_serial_dbg(const char *fmt, ...)
-{
-        va_list va;
-        char buff[256];
-
-        va_start(va, fmt);
-        vsprintf(buff, fmt, va);
-        va_end(va);
-
-        printascii(buff);
-}
-
-#define dbg(x...) s3c24xx_serial_dbg(x)
-
-#else
-#define dbg(x...) printk(KERN_DEBUG "s3c24xx: ");
-#endif
-#else /* no debug */
-#define dbg(x...) do {} while(0)
-#endif
-
-/* UART name and device definitions */
-
-#define S3C24XX_SERIAL_NAME     "ttySAC"
-#define S3C24XX_SERIAL_MAJOR    204
-#define S3C24XX_SERIAL_MINOR    64
-
-
-/* conversion functions */
-
-#define s3c24xx_dev_to_port(__dev) (struct uart_port *)dev_get_drvdata(__dev)
-#define s3c24xx_dev_to_cfg(__dev) (struct s3c2410_uartcfg *)((__dev)->platform_data)
-
-/* we can support 3 uarts, but not always use them */
-
-#ifdef CONFIG_CPU_S3C2400
-#define NR_PORTS (2)
-#else
-#define NR_PORTS (3)
-#endif
-
-/* port irq numbers */
-
-#define TX_IRQ(port) ((port)->irq + 1)
-#define RX_IRQ(port) ((port)->irq)
-
-/* register access controls */
-
-#define portaddr(port, reg) ((port)->membase + (reg))
-
-#define rd_regb(port, reg) (__raw_readb(portaddr(port, reg)))
-#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg)))
-
-#define wr_regb(port, reg, val) \
-  do { __raw_writeb(val, portaddr(port, reg)); } while(0)
-
-#define wr_regl(port, reg, val) \
-  do { __raw_writel(val, portaddr(port, reg)); } while(0)
-
-/* macros to change one thing to another */
-
-#define tx_enabled(port) ((port)->unused[0])
-#define rx_enabled(port) ((port)->unused[1])
-
-/* flag to ignore all characters comming in */
-#define RXSTAT_DUMMY_READ (0x10000000)
-
-static inline struct s3c24xx_uart_port *to_ourport(struct uart_port *port)
-{
-        return container_of(port, struct s3c24xx_uart_port, port);
-}
-
-/* translate a port to the device name */
-
-static inline const char *s3c24xx_serial_portname(struct uart_port *port)
-{
-        return to_platform_device(port->dev)->name;
-}
-
-static int s3c24xx_serial_txempty_nofifo(struct uart_port *port)
-{
-        return (rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE);
-}
-
-static void s3c24xx_serial_rx_enable(struct uart_port *port)
-{
-        unsigned long flags;
-        unsigned int ucon, ufcon;
-        int count = 10000;
-
-        spin_lock_irqsave(&port->lock, flags);
-
-        while (--count && !s3c24xx_serial_txempty_nofifo(port))
-                udelay(100);
-
-        ufcon = rd_regl(port, S3C2410_UFCON);
-        ufcon |= S3C2410_UFCON_RESETRX;
-        wr_regl(port, S3C2410_UFCON, ufcon);
-
-        ucon = rd_regl(port, S3C2410_UCON);
-        ucon |= S3C2410_UCON_RXIRQMODE;
-        wr_regl(port, S3C2410_UCON, ucon);
-
-        rx_enabled(port) = 1;
-        spin_unlock_irqrestore(&port->lock, flags);
-}
-
-static void s3c24xx_serial_rx_disable(struct uart_port *port)
-{
-        unsigned long flags;
-        unsigned int ucon;
-
-        spin_lock_irqsave(&port->lock, flags);
-
-        ucon = rd_regl(port, S3C2410_UCON);
-        ucon &= ~S3C2410_UCON_RXIRQMODE;
-        wr_regl(port, S3C2410_UCON, ucon);
-
-        rx_enabled(port) = 0;
-        spin_unlock_irqrestore(&port->lock, flags);
-}
-
-static void s3c24xx_serial_stop_tx(struct uart_port *port)
-{
-        if (tx_enabled(port)) {
-                disable_irq(TX_IRQ(port));
-                tx_enabled(port) = 0;
-                if (port->flags & UPF_CONS_FLOW)
-                        s3c24xx_serial_rx_enable(port);
-        }
-}
-
-static void s3c24xx_serial_start_tx(struct uart_port *port)
-{
-        if (!tx_enabled(port)) {
-                if (port->flags & UPF_CONS_FLOW)
-                        s3c24xx_serial_rx_disable(port);
-
-                enable_irq(TX_IRQ(port));
-                tx_enabled(port) = 1;
-        }
-}
-
-
-static void s3c24xx_serial_stop_rx(struct uart_port *port)
-{
-        if (rx_enabled(port)) {
-                dbg("s3c24xx_serial_stop_rx: port=%p\n", port);
-                disable_irq(RX_IRQ(port));
-                rx_enabled(port) = 0;
-        }
-}
-
-static void s3c24xx_serial_enable_ms(struct uart_port *port)
-{
-}
-
-static inline struct s3c24xx_uart_info *s3c24xx_port_to_info(struct uart_port *port)
-{
-        return to_ourport(port)->info;
-}
-
-static inline struct s3c2410_uartcfg *s3c24xx_port_to_cfg(struct uart_port *port)
-{
-        if (port->dev == NULL)
-                return NULL;
-
-        return (struct s3c2410_uartcfg *)port->dev->platform_data;
-}
-
-static int s3c24xx_serial_rx_fifocnt(struct s3c24xx_uart_port *ourport,
-                                     unsigned long ufstat)
-{
-        struct s3c24xx_uart_info *info = ourport->info;
-
-        if (ufstat & info->rx_fifofull)
-                return info->fifosize;
-
-        return (ufstat & info->rx_fifomask) >> info->rx_fifoshift;
-}
-
-
-/* ? - where has parity gone?? */
-#define S3C2410_UERSTAT_PARITY (0x1000)
-
-static irqreturn_t
-s3c24xx_serial_rx_chars(int irq, void *dev_id)
-{
-        struct s3c24xx_uart_port *ourport = dev_id;
-        struct uart_port *port = &ourport->port;
-        struct tty_struct *tty = port->info->tty;
-        unsigned int ufcon, ch, flag, ufstat, uerstat;
-        int max_count = 64;
-
-        while (max_count-- > 0) {
-                ufcon = rd_regl(port, S3C2410_UFCON);
-                ufstat = rd_regl(port, S3C2410_UFSTAT);
-
-                if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)
-                        break;
-
-                uerstat = rd_regl(port, S3C2410_UERSTAT);
-                ch = rd_regb(port, S3C2410_URXH);
-
-                if (port->flags & UPF_CONS_FLOW) {
-                        int txe = s3c24xx_serial_txempty_nofifo(port);
-
-                        if (rx_enabled(port)) {
-                                if (!txe) {
-                                        rx_enabled(port) = 0;
-                                        continue;
-                                }
-                        } else {
-                                if (txe) {
-                                        ufcon |= S3C2410_UFCON_RESETRX;
-                                        wr_regl(port, S3C2410_UFCON, ufcon);
-                                        rx_enabled(port) = 1;
-                                        goto out;
-                                }
-                                continue;
-                        }
-                }
-
-                /* insert the character into the buffer */
-
-                flag = TTY_NORMAL;
-                port->icount.rx++;
-
-                if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {
-                        dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",
-                            ch, uerstat);
-
-                        /* check for break */
-                        if (uerstat & S3C2410_UERSTAT_BREAK) {
-                                dbg("break!\n");
-                                port->icount.brk++;
-                                if (uart_handle_break(port))
-                                    goto ignore_char;
-                        }
-
-                        if (uerstat & S3C2410_UERSTAT_FRAME)
-                                port->icount.frame++;
-                        if (uerstat & S3C2410_UERSTAT_OVERRUN)
-                                port->icount.overrun++;
-
-                        uerstat &= port->read_status_mask;
-
-                        if (uerstat & S3C2410_UERSTAT_BREAK)
-                                flag = TTY_BREAK;
-                        else if (uerstat & S3C2410_UERSTAT_PARITY)
-                                flag = TTY_PARITY;
-                        else if (uerstat & ( S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_OVERRUN))
-                                flag = TTY_FRAME;
-                }
-
-                if (uart_handle_sysrq_char(port, ch))
-                        goto ignore_char;
-
-                uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN, ch, flag);
-
-        ignore_char:
-                continue;
-        }
-        tty_flip_buffer_push(tty);
-
- out:
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)
-{
-        struct s3c24xx_uart_port *ourport = id;
-        struct uart_port *port = &ourport->port;
-        struct circ_buf *xmit = &port->info->xmit;
-        int count = 256;
-
-        if (port->x_char) {
-                wr_regb(port, S3C2410_UTXH, port->x_char);
-                port->icount.tx++;
-                port->x_char = 0;
-                goto out;
-        }
-
-        /* if there isnt anything more to transmit, or the uart is now
-         * stopped, disable the uart and exit
-        */
-
-        if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
-                s3c24xx_serial_stop_tx(port);
-                goto out;
-        }
-
-        /* try and drain the buffer... */
-
-        while (!uart_circ_empty(xmit) && count-- > 0) {
-                if (rd_regl(port, S3C2410_UFSTAT) & ourport->info->tx_fifofull)
-                        break;
-
-                wr_regb(port, S3C2410_UTXH, xmit->buf[xmit->tail]);
-                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
-                port->icount.tx++;
-        }
-
-        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
-                uart_write_wakeup(port);
-
-        if (uart_circ_empty(xmit))
-                s3c24xx_serial_stop_tx(port);
-
- out:
-        return IRQ_HANDLED;
-}
-
-static unsigned int s3c24xx_serial_tx_empty(struct uart_port *port)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-        unsigned long ufstat = rd_regl(port, S3C2410_UFSTAT);
-        unsigned long ufcon = rd_regl(port, S3C2410_UFCON);
-
-        if (ufcon & S3C2410_UFCON_FIFOMODE) {
-                if ((ufstat & info->tx_fifomask) != 0 ||
-                    (ufstat & info->tx_fifofull))
-                        return 0;
-
-                return 1;
-        }
-
-        return s3c24xx_serial_txempty_nofifo(port);
-}
-
-/* no modem control lines */
-static unsigned int s3c24xx_serial_get_mctrl(struct uart_port *port)
-{
-        unsigned int umstat = rd_regb(port,S3C2410_UMSTAT);
-
-        if (umstat & S3C2410_UMSTAT_CTS)
-                return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
-        else
-                return TIOCM_CAR | TIOCM_DSR;
-}
-
-static void s3c24xx_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
-{
-        /* todo - possibly remove AFC and do manual CTS */
-}
-
-static void s3c24xx_serial_break_ctl(struct uart_port *port, int break_state)
-{
-        unsigned long flags;
-        unsigned int ucon;
-
-        spin_lock_irqsave(&port->lock, flags);
-
-        ucon = rd_regl(port, S3C2410_UCON);
-
-        if (break_state)
-                ucon |= S3C2410_UCON_SBREAK;
-        else
-                ucon &= ~S3C2410_UCON_SBREAK;
-
-        wr_regl(port, S3C2410_UCON, ucon);
-
-        spin_unlock_irqrestore(&port->lock, flags);
-}
-
-static void s3c24xx_serial_shutdown(struct uart_port *port)
-{
-        struct s3c24xx_uart_port *ourport = to_ourport(port);
-
-        if (ourport->tx_claimed) {
-                free_irq(TX_IRQ(port), ourport);
-                tx_enabled(port) = 0;
-                ourport->tx_claimed = 0;
-        }
-
-        if (ourport->rx_claimed) {
-                free_irq(RX_IRQ(port), ourport);
-                ourport->rx_claimed = 0;
-                rx_enabled(port) = 0;
-        }
-}
-
-
-static int s3c24xx_serial_startup(struct uart_port *port)
-{
-        struct s3c24xx_uart_port *ourport = to_ourport(port);
-        int ret;
-
-        dbg("s3c24xx_serial_startup: port=%p (%08lx,%p)\n",
-            port->mapbase, port->membase);
-
-        rx_enabled(port) = 1;
-
-        ret = request_irq(RX_IRQ(port),
-                          s3c24xx_serial_rx_chars, 0,
-                          s3c24xx_serial_portname(port), ourport);
-
-        if (ret != 0) {
-                printk(KERN_ERR "cannot get irq %d\n", RX_IRQ(port));
-                return ret;
-        }
-
-        ourport->rx_claimed = 1;
-
-        dbg("requesting tx irq...\n");
-
-        tx_enabled(port) = 1;
-
-        ret = request_irq(TX_IRQ(port),
-                          s3c24xx_serial_tx_chars, 0,
-                          s3c24xx_serial_portname(port), ourport);
-
-        if (ret) {
-                printk(KERN_ERR "cannot get irq %d\n", TX_IRQ(port));
-                goto err;
-        }
-
-        ourport->tx_claimed = 1;
-
-        dbg("s3c24xx_serial_startup ok\n");
-
-        /* the port reset code should have done the correct
-         * register setup for the port controls */
-
-        return ret;
-
- err:
-        s3c24xx_serial_shutdown(port);
-        return ret;
-}
-
-/* power power management control */
-
-static void s3c24xx_serial_pm(struct uart_port *port, unsigned int level,
-                              unsigned int old)
-{
-        struct s3c24xx_uart_port *ourport = to_ourport(port);
-
-        switch (level) {
-        case 3:
-                if (!IS_ERR(ourport->baudclk) && ourport->baudclk != NULL)
-                        clk_disable(ourport->baudclk);
-
-                clk_disable(ourport->clk);
-                break;
-
-        case 0:
-                clk_enable(ourport->clk);
-
-                if (!IS_ERR(ourport->baudclk) && ourport->baudclk != NULL)
-                        clk_enable(ourport->baudclk);
-
-                break;
-        default:
-                printk(KERN_ERR "s3c24xx_serial: unknown pm %d\n", level);
-        }
-}
-
-/* baud rate calculation
- *
- * The UARTs on the S3C2410/S3C2440 can take their clocks from a number
- * of different sources, including the peripheral clock ("pclk") and an
- * external clock ("uclk"). The S3C2440 also adds the core clock ("fclk")
- * with a programmable extra divisor.
- *
- * The following code goes through the clock sources, and calculates the
- * baud clocks (and the resultant actual baud rates) and then tries to
- * pick the closest one and select that.
- *
-*/
-
-
-#define MAX_CLKS (8)
-
-static struct s3c24xx_uart_clksrc tmp_clksrc = {
-        .name           = "pclk",
-        .min_baud       = 0,
-        .max_baud       = 0,
-        .divisor        = 1,
-};
-
-static inline int
-s3c24xx_serial_getsource(struct uart_port *port, struct s3c24xx_uart_clksrc *c)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-
-        return (info->get_clksrc)(port, c);
-}
-
-static inline int
-s3c24xx_serial_setsource(struct uart_port *port, struct s3c24xx_uart_clksrc *c)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-
-        return (info->set_clksrc)(port, c);
-}
-
-struct baud_calc {
-        struct s3c24xx_uart_clksrc      *clksrc;
-        unsigned int                     calc;
-        unsigned int                     quot;
-        struct clk                      *src;
-};
-
-static int s3c24xx_serial_calcbaud(struct baud_calc *calc,
-                                   struct uart_port *port,
-                                   struct s3c24xx_uart_clksrc *clksrc,
-                                   unsigned int baud)
-{
-        unsigned long rate;
-
-        calc->src = clk_get(port->dev, clksrc->name);
-        if (calc->src == NULL || IS_ERR(calc->src))
-                return 0;
-
-        rate = clk_get_rate(calc->src);
-        rate /= clksrc->divisor;
-
-        calc->clksrc = clksrc;
-        calc->quot = (rate + (8 * baud)) / (16 * baud);
-        calc->calc = (rate / (calc->quot * 16));
-
-        calc->quot--;
-        return 1;
-}
-
-static unsigned int s3c24xx_serial_getclk(struct uart_port *port,
-                                          struct s3c24xx_uart_clksrc **clksrc,
-                                          struct clk **clk,
-                                          unsigned int baud)
-{
-        struct s3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);
-        struct s3c24xx_uart_clksrc *clkp;
-        struct baud_calc res[MAX_CLKS];
-        struct baud_calc *resptr, *best, *sptr;
-        int i;
-
-        clkp = cfg->clocks;
-        best = NULL;
-
-        if (cfg->clocks_size < 2) {
-                if (cfg->clocks_size == 0)
-                        clkp = &tmp_clksrc;
-
-                /* check to see if we're sourcing fclk, and if so we're
-                 * going to have to update the clock source
-                 */
-
-                if (strcmp(clkp->name, "fclk") == 0) {
-                        struct s3c24xx_uart_clksrc src;
-
-                        s3c24xx_serial_getsource(port, &src);
-
-                        /* check that the port already using fclk, and if
-                         * not, then re-select fclk
-                         */
-
-                        if (strcmp(src.name, clkp->name) == 0) {
-                                s3c24xx_serial_setsource(port, clkp);
-                                s3c24xx_serial_getsource(port, &src);
-                        }
-
-                        clkp->divisor = src.divisor;
-                }
-
-                s3c24xx_serial_calcbaud(res, port, clkp, baud);
-                best = res;
-                resptr = best + 1;
-        } else {
-                resptr = res;
-
-                for (i = 0; i < cfg->clocks_size; i++, clkp++) {
-                        if (s3c24xx_serial_calcbaud(resptr, port, clkp, baud))
-                                resptr++;
-                }
-        }
-
-        /* ok, we now need to select the best clock we found */
-
-        if (!best) {
-                unsigned int deviation = (1<<30)|((1<<30)-1);
-                int calc_deviation;
-
-                for (sptr = res; sptr < resptr; sptr++) {
-                        printk(KERN_DEBUG
-                               "found clk %p (%s) quot %d, calc %d\n",
-                               sptr->clksrc, sptr->clksrc->name,
-                               sptr->quot, sptr->calc);
-
-                        calc_deviation = baud - sptr->calc;
-                        if (calc_deviation < 0)
-                                calc_deviation = -calc_deviation;
-
-                        if (calc_deviation < deviation) {
-                                best = sptr;
-                                deviation = calc_deviation;
-                        }
-                }
-
-                printk(KERN_DEBUG "best %p (deviation %d)\n", best, deviation);
-        }
-
-        printk(KERN_DEBUG "selected clock %p (%s) quot %d, calc %d\n",
-               best->clksrc, best->clksrc->name, best->quot, best->calc);
-
-        /* store results to pass back */
-
-        *clksrc = best->clksrc;
-        *clk    = best->src;
-
-        return best->quot;
-}
-
-static void s3c24xx_serial_set_termios(struct uart_port *port,
-                                       struct ktermios *termios,
-                                       struct ktermios *old)
-{
-        struct s3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);
-        struct s3c24xx_uart_port *ourport = to_ourport(port);
-        struct s3c24xx_uart_clksrc *clksrc = NULL;
-        struct clk *clk = NULL;
-        unsigned long flags;
-        unsigned int baud, quot;
-        unsigned int ulcon;
-        unsigned int umcon;
-
-        /*
-         * We don't support modem control lines.
-         */
-        termios->c_cflag &= ~(HUPCL | CMSPAR);
-        termios->c_cflag |= CLOCAL;
-
-        /*
-         * Ask the core to calculate the divisor for us.
-         */
-
-        baud = uart_get_baud_rate(port, termios, old, 0, 115200*8);
-
-        if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
-                quot = port->custom_divisor;
-        else
-                quot = s3c24xx_serial_getclk(port, &clksrc, &clk, baud);
-
-        /* check to see if we need  to change clock source */
-
-        if (ourport->clksrc != clksrc || ourport->baudclk != clk) {
-                s3c24xx_serial_setsource(port, clksrc);
-
-                if (ourport->baudclk != NULL && !IS_ERR(ourport->baudclk)) {
-                        clk_disable(ourport->baudclk);
-                        ourport->baudclk  = NULL;
-                }
-
-                clk_enable(clk);
-
-                ourport->clksrc = clksrc;
-                ourport->baudclk = clk;
-        }
-
-        switch (termios->c_cflag & CSIZE) {
-        case CS5:
-                dbg("config: 5bits/char\n");
-                ulcon = S3C2410_LCON_CS5;
-                break;
-        case CS6:
-                dbg("config: 6bits/char\n");
-                ulcon = S3C2410_LCON_CS6;
-                break;
-        case CS7:
-                dbg("config: 7bits/char\n");
-                ulcon = S3C2410_LCON_CS7;
-                break;
-        case CS8:
-        default:
-                dbg("config: 8bits/char\n");
-                ulcon = S3C2410_LCON_CS8;
-                break;
-        }
-
-        /* preserve original lcon IR settings */
-        ulcon |= (cfg->ulcon & S3C2410_LCON_IRM);
-
-        if (termios->c_cflag & CSTOPB)
-                ulcon |= S3C2410_LCON_STOPB;
-
-        umcon = (termios->c_cflag & CRTSCTS) ? S3C2410_UMCOM_AFC : 0;
-
-        if (termios->c_cflag & PARENB) {
-                if (termios->c_cflag & PARODD)
-                        ulcon |= S3C2410_LCON_PODD;
-                else
-                        ulcon |= S3C2410_LCON_PEVEN;
-        } else {
-                ulcon |= S3C2410_LCON_PNONE;
-        }
-
-        spin_lock_irqsave(&port->lock, flags);
-
-        dbg("setting ulcon to %08x, brddiv to %d\n", ulcon, quot);
-
-        wr_regl(port, S3C2410_ULCON, ulcon);
-        wr_regl(port, S3C2410_UBRDIV, quot);
-        wr_regl(port, S3C2410_UMCON, umcon);
-
-        dbg("uart: ulcon = 0x%08x, ucon = 0x%08x, ufcon = 0x%08x\n",
-            rd_regl(port, S3C2410_ULCON),
-            rd_regl(port, S3C2410_UCON),
-            rd_regl(port, S3C2410_UFCON));
-
-        /*
-         * Update the per-port timeout.
-         */
-        uart_update_timeout(port, termios->c_cflag, baud);
-
-        /*
-         * Which character status flags are we interested in?
-         */
-        port->read_status_mask = S3C2410_UERSTAT_OVERRUN;
-        if (termios->c_iflag & INPCK)
-                port->read_status_mask |= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;
-
-        /*
-         * Which character status flags should we ignore?
-         */
-        port->ignore_status_mask = 0;
-        if (termios->c_iflag & IGNPAR)
-                port->ignore_status_mask |= S3C2410_UERSTAT_OVERRUN;
-        if (termios->c_iflag & IGNBRK && termios->c_iflag & IGNPAR)
-                port->ignore_status_mask |= S3C2410_UERSTAT_FRAME;
-
-        /*
-         * Ignore all characters if CREAD is not set.
-         */
-        if ((termios->c_cflag & CREAD) == 0)
-                port->ignore_status_mask |= RXSTAT_DUMMY_READ;
-
-        spin_unlock_irqrestore(&port->lock, flags);
-}
-
-static const char *s3c24xx_serial_type(struct uart_port *port)
-{
-        switch (port->type) {
-        case PORT_S3C2410:
-                return "S3C2410";
-        case PORT_S3C2440:
-                return "S3C2440";
-        case PORT_S3C2412:
-                return "S3C2412";
-        default:
-                return NULL;
-        }
-}
-
-#define MAP_SIZE (0x100)
-
-static void s3c24xx_serial_release_port(struct uart_port *port)
-{
-        release_mem_region(port->mapbase, MAP_SIZE);
-}
-
-static int s3c24xx_serial_request_port(struct uart_port *port)
-{
-        const char *name = s3c24xx_serial_portname(port);
-        return request_mem_region(port->mapbase, MAP_SIZE, name) ? 0 : -EBUSY;
-}
-
-static void s3c24xx_serial_config_port(struct uart_port *port, int flags)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-
-        if (flags & UART_CONFIG_TYPE &&
-            s3c24xx_serial_request_port(port) == 0)
-                port->type = info->type;
-}
-
-/*
- * verify the new serial_struct (for TIOCSSERIAL).
- */
-static int
-s3c24xx_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-
-        if (ser->type != PORT_UNKNOWN && ser->type != info->type)
-                return -EINVAL;
-
-        return 0;
-}
-
-
-#ifdef CONFIG_SERIAL_S3C2410_CONSOLE
-
-static struct console s3c24xx_serial_console;
-
-#define S3C24XX_SERIAL_CONSOLE &s3c24xx_serial_console
-#else
-#define S3C24XX_SERIAL_CONSOLE NULL
-#endif
-
-static struct uart_ops s3c24xx_serial_ops = {
-        .pm             = s3c24xx_serial_pm,
-        .tx_empty       = s3c24xx_serial_tx_empty,
-        .get_mctrl      = s3c24xx_serial_get_mctrl,
-        .set_mctrl      = s3c24xx_serial_set_mctrl,
-        .stop_tx        = s3c24xx_serial_stop_tx,
-        .start_tx       = s3c24xx_serial_start_tx,
-        .stop_rx        = s3c24xx_serial_stop_rx,
-        .enable_ms      = s3c24xx_serial_enable_ms,
-        .break_ctl      = s3c24xx_serial_break_ctl,
-        .startup        = s3c24xx_serial_startup,
-        .shutdown       = s3c24xx_serial_shutdown,
-        .set_termios    = s3c24xx_serial_set_termios,
-        .type           = s3c24xx_serial_type,
-        .release_port   = s3c24xx_serial_release_port,
-        .request_port   = s3c24xx_serial_request_port,
-        .config_port    = s3c24xx_serial_config_port,
-        .verify_port    = s3c24xx_serial_verify_port,
-};
-
-
-static struct uart_driver s3c24xx_uart_drv = {
-        .owner          = THIS_MODULE,
-        .dev_name       = "s3c2410_serial",
-        .nr             = 3,
-        .cons           = S3C24XX_SERIAL_CONSOLE,
-        .driver_name    = S3C24XX_SERIAL_NAME,
-        .major          = S3C24XX_SERIAL_MAJOR,
-        .minor          = S3C24XX_SERIAL_MINOR,
-};
-
-static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {
-        [0] = {
-                .port = {
-                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),
-                        .iotype         = UPIO_MEM,
-                        .irq            = IRQ_S3CUART_RX0,
-                        .uartclk        = 0,
-                        .fifosize       = 16,
-                        .ops            = &s3c24xx_serial_ops,
-                        .flags          = UPF_BOOT_AUTOCONF,
-                        .line           = 0,
-                }
-        },
-        [1] = {
-                .port = {
-                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),
-                        .iotype         = UPIO_MEM,
-                        .irq            = IRQ_S3CUART_RX1,
-                        .uartclk        = 0,
-                        .fifosize       = 16,
-                        .ops            = &s3c24xx_serial_ops,
-                        .flags          = UPF_BOOT_AUTOCONF,
-                        .line           = 1,
-                }
-        },
-#if NR_PORTS > 2
-
-        [2] = {
-                .port = {
-                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),
-                        .iotype         = UPIO_MEM,
-                        .irq            = IRQ_S3CUART_RX2,
-                        .uartclk        = 0,
-                        .fifosize       = 16,
-                        .ops            = &s3c24xx_serial_ops,
-                        .flags          = UPF_BOOT_AUTOCONF,
-                        .line           = 2,
-                }
-        }
-#endif
-};
-
-/* s3c24xx_serial_resetport
- *
- * wrapper to call the specific reset for this port (reset the fifos
- * and the settings)
-*/
-
-static inline int s3c24xx_serial_resetport(struct uart_port * port,
-                                           struct s3c2410_uartcfg *cfg)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-
-        return (info->reset_port)(port, cfg);
-}
-
-/* s3c24xx_serial_init_port
- *
- * initialise a single serial port from the platform device given
- */
-
-static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
-                                    struct s3c24xx_uart_info *info,
-                                    struct platform_device *platdev)
-{
-        struct uart_port *port = &ourport->port;
-        struct s3c2410_uartcfg *cfg;
-        struct resource *res;
-        int ret;
-
-        dbg("s3c24xx_serial_init_port: port=%p, platdev=%p\n", port, platdev);
-
-        if (platdev == NULL)
-                return -ENODEV;
-
-        cfg = s3c24xx_dev_to_cfg(&platdev->dev);
-
-        if (port->mapbase != 0)
-                return 0;
-
-        if (cfg->hwport > 3)
-                return -EINVAL;
-
-        /* setup info for port */
-        port->dev       = &platdev->dev;
-        ourport->info   = info;
-
-        /* copy the info in from provided structure */
-        ourport->port.fifosize = info->fifosize;
-
-        dbg("s3c24xx_serial_init_port: %p (hw %d)...\n", port, cfg->hwport);
-
-        port->uartclk = 1;
-
-        if (cfg->uart_flags & UPF_CONS_FLOW) {
-                dbg("s3c24xx_serial_init_port: enabling flow control\n");
-                port->flags |= UPF_CONS_FLOW;
-        }
-
-        /* sort our the physical and virtual addresses for each UART */
-
-        res = platform_get_resource(platdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
-                printk(KERN_ERR "failed to find memory resource for uart\n");
-                return -EINVAL;
-        }
-
-        dbg("resource %p (%lx..%lx)\n", res, res->start, res->end);
-
-        port->mapbase   = res->start;
-        port->membase   = S3C24XX_VA_UART + (res->start - S3C24XX_PA_UART);
-        ret = platform_get_irq(platdev, 0);
-        if (ret < 0)
-                port->irq = 0;
-        else
-                port->irq = ret;
-
-        ourport->clk    = clk_get(&platdev->dev, "uart");
-
-        dbg("port: map=%08x, mem=%08x, irq=%d, clock=%ld\n",
-            port->mapbase, port->membase, port->irq, port->uartclk);
-
-        /* reset the fifos (and setup the uart) */
-        s3c24xx_serial_resetport(port, cfg);
-        return 0;
-}
-
-/* Device driver serial port probe */
-
-static int probe_index = 0;
-
-static int s3c24xx_serial_probe(struct platform_device *dev,
-                                struct s3c24xx_uart_info *info)
-{
-        struct s3c24xx_uart_port *ourport;
-        int ret;
-
-        dbg("s3c24xx_serial_probe(%p, %p) %d\n", dev, info, probe_index);
-
-        ourport = &s3c24xx_serial_ports[probe_index];
-        probe_index++;
-
-        dbg("%s: initialising port %p...\n", __func__, ourport);
-
-        ret = s3c24xx_serial_init_port(ourport, info, dev);
-        if (ret < 0)
-                goto probe_err;
-
-        dbg("%s: adding port\n", __func__);
-        uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
-        platform_set_drvdata(dev, &ourport->port);
-
-        return 0;
-
- probe_err:
-        return ret;
-}
-
-static int s3c24xx_serial_remove(struct platform_device *dev)
-{
-        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
-
-        if (port)
-                uart_remove_one_port(&s3c24xx_uart_drv, port);
-
-        return 0;
-}
-
-/* UART power management code */
-
-#ifdef CONFIG_PM
-
-static int s3c24xx_serial_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
-
-        if (port)
-                uart_suspend_port(&s3c24xx_uart_drv, port);
-
-        return 0;
-}
-
-static int s3c24xx_serial_resume(struct platform_device *dev)
-{
-        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
-        struct s3c24xx_uart_port *ourport = to_ourport(port);
-
-        if (port) {
-                clk_enable(ourport->clk);
-                s3c24xx_serial_resetport(port, s3c24xx_port_to_cfg(port));
-                clk_disable(ourport->clk);
-
-                uart_resume_port(&s3c24xx_uart_drv, port);
-        }
-
-        return 0;
-}
-
-#else
-#define s3c24xx_serial_suspend NULL
-#define s3c24xx_serial_resume  NULL
-#endif
-
-static int s3c24xx_serial_init(struct platform_driver *drv,
-                               struct s3c24xx_uart_info *info)
-{
-        dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
-        return platform_driver_register(drv);
-}
-
-
-/* now comes the code to initialise either the s3c2410 or s3c2440 serial
- * port information
-*/
-
-/* cpu specific variations on the serial port support */
-
-#ifdef CONFIG_CPU_S3C2400
-
-static int s3c2400_serial_getsource(struct uart_port *port,
-                                    struct s3c24xx_uart_clksrc *clk)
-{
-        clk->divisor = 1;
-        clk->name = "pclk";
-
-        return 0;
-}
-
-static int s3c2400_serial_setsource(struct uart_port *port,
-                                    struct s3c24xx_uart_clksrc *clk)
-{
-        return 0;
-}
-
-static int s3c2400_serial_resetport(struct uart_port *port,
-                                    struct s3c2410_uartcfg *cfg)
-{
-        dbg("s3c2400_serial_resetport: port=%p (%08lx), cfg=%p\n",
-            port, port->mapbase, cfg);
-
-        wr_regl(port, S3C2410_UCON,  cfg->ucon);
-        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
-
-        /* reset both fifos */
-
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
-
-        return 0;
-}
-
-static struct s3c24xx_uart_info s3c2400_uart_inf = {
-        .name           = "Samsung S3C2400 UART",
-        .type           = PORT_S3C2400,
-        .fifosize       = 16,
-        .rx_fifomask    = S3C2410_UFSTAT_RXMASK,
-        .rx_fifoshift   = S3C2410_UFSTAT_RXSHIFT,
-        .rx_fifofull    = S3C2410_UFSTAT_RXFULL,
-        .tx_fifofull    = S3C2410_UFSTAT_TXFULL,
-        .tx_fifomask    = S3C2410_UFSTAT_TXMASK,
-        .tx_fifoshift   = S3C2410_UFSTAT_TXSHIFT,
-        .get_clksrc     = s3c2400_serial_getsource,
-        .set_clksrc     = s3c2400_serial_setsource,
-        .reset_port     = s3c2400_serial_resetport,
-};
-
-static int s3c2400_serial_probe(struct platform_device *dev)
-{
-        return s3c24xx_serial_probe(dev, &s3c2400_uart_inf);
-}
-
-static struct platform_driver s3c2400_serial_drv = {
-        .probe          = s3c2400_serial_probe,
-        .remove         = s3c24xx_serial_remove,
-        .suspend        = s3c24xx_serial_suspend,
-        .resume         = s3c24xx_serial_resume,
-        .driver         = {
-                .name   = "s3c2400-uart",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static inline int s3c2400_serial_init(void)
-{
-        return s3c24xx_serial_init(&s3c2400_serial_drv, &s3c2400_uart_inf);
-}
-
-static inline void s3c2400_serial_exit(void)
-{
-        platform_driver_unregister(&s3c2400_serial_drv);
-}
-
-#define s3c2400_uart_inf_at &s3c2400_uart_inf
-#else
-
-static inline int s3c2400_serial_init(void)
-{
-        return 0;
-}
-
-static inline void s3c2400_serial_exit(void)
-{
-}
-
-#define s3c2400_uart_inf_at NULL
-
-#endif /* CONFIG_CPU_S3C2400 */
-
-/* S3C2410 support */
-
-#ifdef CONFIG_CPU_S3C2410
+#include "samsung.h"
 
 static int s3c2410_serial_setsource(struct uart_port *port,
                                     struct s3c24xx_uart_clksrc *clk)
@@ -1323,8 +83,6 @@ static struct s3c24xx_uart_info s3c2410_uart_inf = {
         .reset_port     = s3c2410_serial_resetport,
 };
 
-/* device management */
-
 static int s3c2410_serial_probe(struct platform_device *dev)
 {
         return s3c24xx_serial_probe(dev, &s3c2410_uart_inf);
@@ -1333,612 +91,28 @@ static int s3c2410_serial_probe(struct platform_device *dev)
 static struct platform_driver s3c2410_serial_drv = {
         .probe          = s3c2410_serial_probe,
         .remove         = s3c24xx_serial_remove,
-        .suspend        = s3c24xx_serial_suspend,
-        .resume         = s3c24xx_serial_resume,
         .driver         = {
                 .name   = "s3c2410-uart",
                 .owner  = THIS_MODULE,
         },
 };
 
-static inline int s3c2410_serial_init(void)
+s3c24xx_console_init(&s3c2410_serial_drv, &s3c2410_uart_inf);
+
+static int __init s3c2410_serial_init(void)
 {
         return s3c24xx_serial_init(&s3c2410_serial_drv, &s3c2410_uart_inf);
 }
 
-static inline void s3c2410_serial_exit(void)
+static void __exit s3c2410_serial_exit(void)
 {
         platform_driver_unregister(&s3c2410_serial_drv);
 }
 
-#define s3c2410_uart_inf_at &s3c2410_uart_inf
-#else
-
-static inline int s3c2410_serial_init(void)
-{
-        return 0;
-}
-
-static inline void s3c2410_serial_exit(void)
-{
-}
-
-#define s3c2410_uart_inf_at NULL
-
-#endif /* CONFIG_CPU_S3C2410 */
-
-#if defined(CONFIG_CPU_S3C2440) || defined(CONFIG_CPU_S3C2442)
-
-static int s3c2440_serial_setsource(struct uart_port *port,
-                                     struct s3c24xx_uart_clksrc *clk)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-
-        // todo - proper fclk<>nonfclk switch //
-
-        ucon &= ~S3C2440_UCON_CLKMASK;
-
-        if (strcmp(clk->name, "uclk") == 0)
-                ucon |= S3C2440_UCON_UCLK;
-        else if (strcmp(clk->name, "pclk") == 0)
-                ucon |= S3C2440_UCON_PCLK;
-        else if (strcmp(clk->name, "fclk") == 0)
-                ucon |= S3C2440_UCON_FCLK;
-        else {
-                printk(KERN_ERR "unknown clock source %s\n", clk->name);
-                return -EINVAL;
-        }
-
-        wr_regl(port, S3C2410_UCON, ucon);
-        return 0;
-}
-
-
-static int s3c2440_serial_getsource(struct uart_port *port,
-                                    struct s3c24xx_uart_clksrc *clk)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-        unsigned long ucon0, ucon1, ucon2;
-
-        switch (ucon & S3C2440_UCON_CLKMASK) {
-        case S3C2440_UCON_UCLK:
-                clk->divisor = 1;
-                clk->name = "uclk";
-                break;
-
-        case S3C2440_UCON_PCLK:
-        case S3C2440_UCON_PCLK2:
-                clk->divisor = 1;
-                clk->name = "pclk";
-                break;
-
-        case S3C2440_UCON_FCLK:
-                /* the fun of calculating the uart divisors on
-                 * the s3c2440 */
-
-                ucon0 = __raw_readl(S3C24XX_VA_UART0 + S3C2410_UCON);
-                ucon1 = __raw_readl(S3C24XX_VA_UART1 + S3C2410_UCON);
-                ucon2 = __raw_readl(S3C24XX_VA_UART2 + S3C2410_UCON);
-
-                printk("ucons: %08lx, %08lx, %08lx\n", ucon0, ucon1, ucon2);
-
-                ucon0 &= S3C2440_UCON0_DIVMASK;
-                ucon1 &= S3C2440_UCON1_DIVMASK;
-                ucon2 &= S3C2440_UCON2_DIVMASK;
-
-                if (ucon0 != 0) {
-                        clk->divisor = ucon0 >> S3C2440_UCON_DIVSHIFT;
-                        clk->divisor += 6;
-                } else if (ucon1 != 0) {
-                        clk->divisor = ucon1 >> S3C2440_UCON_DIVSHIFT;
-                        clk->divisor += 21;
-                } else if (ucon2 != 0) {
-                        clk->divisor = ucon2 >> S3C2440_UCON_DIVSHIFT;
-                        clk->divisor += 36;
-                } else {
-                        /* manual calims 44, seems to be 9 */
-                        clk->divisor = 9;
-                }
-
-                clk->name = "fclk";
-                break;
-        }
-
-        return 0;
-}
-
-static int s3c2440_serial_resetport(struct uart_port *port,
-                                    struct s3c2410_uartcfg *cfg)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-
-        dbg("s3c2440_serial_resetport: port=%p (%08lx), cfg=%p\n",
-            port, port->mapbase, cfg);
-
-        /* ensure we don't change the clock settings... */
-
-        ucon &= (S3C2440_UCON0_DIVMASK | (3<<10));
-
-        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon);
-        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
-
-        /* reset both fifos */
-
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
-
-        return 0;
-}
-
-static struct s3c24xx_uart_info s3c2440_uart_inf = {
-        .name           = "Samsung S3C2440 UART",
-        .type           = PORT_S3C2440,
-        .fifosize       = 64,
-        .rx_fifomask    = S3C2440_UFSTAT_RXMASK,
-        .rx_fifoshift   = S3C2440_UFSTAT_RXSHIFT,
-        .rx_fifofull    = S3C2440_UFSTAT_RXFULL,
-        .tx_fifofull    = S3C2440_UFSTAT_TXFULL,
-        .tx_fifomask    = S3C2440_UFSTAT_TXMASK,
-        .tx_fifoshift   = S3C2440_UFSTAT_TXSHIFT,
-        .get_clksrc     = s3c2440_serial_getsource,
-        .set_clksrc     = s3c2440_serial_setsource,
-        .reset_port     = s3c2440_serial_resetport,
-};
-
-/* device management */
-
-static int s3c2440_serial_probe(struct platform_device *dev)
-{
-        dbg("s3c2440_serial_probe: dev=%p\n", dev);
-        return s3c24xx_serial_probe(dev, &s3c2440_uart_inf);
-}
-
-static struct platform_driver s3c2440_serial_drv = {
-        .probe          = s3c2440_serial_probe,
-        .remove         = s3c24xx_serial_remove,
-        .suspend        = s3c24xx_serial_suspend,
-        .resume         = s3c24xx_serial_resume,
-        .driver         = {
-                .name   = "s3c2440-uart",
-                .owner  = THIS_MODULE,
-        },
-};
-
-
-static inline int s3c2440_serial_init(void)
-{
-        return s3c24xx_serial_init(&s3c2440_serial_drv, &s3c2440_uart_inf);
-}
-
-static inline void s3c2440_serial_exit(void)
-{
-        platform_driver_unregister(&s3c2440_serial_drv);
-}
-
-#define s3c2440_uart_inf_at &s3c2440_uart_inf
-#else
-
-static inline int s3c2440_serial_init(void)
-{
-        return 0;
-}
-
-static inline void s3c2440_serial_exit(void)
-{
-}
-
-#define s3c2440_uart_inf_at NULL
-#endif /* CONFIG_CPU_S3C2440 */
-
-#if defined(CONFIG_CPU_S3C2412)
-
-static int s3c2412_serial_setsource(struct uart_port *port,
-                                     struct s3c24xx_uart_clksrc *clk)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-
-        ucon &= ~S3C2412_UCON_CLKMASK;
-
-        if (strcmp(clk->name, "uclk") == 0)
-                ucon |= S3C2440_UCON_UCLK;
-        else if (strcmp(clk->name, "pclk") == 0)
-                ucon |= S3C2440_UCON_PCLK;
-        else if (strcmp(clk->name, "usysclk") == 0)
-                ucon |= S3C2412_UCON_USYSCLK;
-        else {
-                printk(KERN_ERR "unknown clock source %s\n", clk->name);
-                return -EINVAL;
-        }
-
-        wr_regl(port, S3C2410_UCON, ucon);
-        return 0;
-}
-
-
-static int s3c2412_serial_getsource(struct uart_port *port,
-                                    struct s3c24xx_uart_clksrc *clk)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-
-        switch (ucon & S3C2412_UCON_CLKMASK) {
-        case S3C2412_UCON_UCLK:
-                clk->divisor = 1;
-                clk->name = "uclk";
-                break;
-
-        case S3C2412_UCON_PCLK:
-        case S3C2412_UCON_PCLK2:
-                clk->divisor = 1;
-                clk->name = "pclk";
-                break;
-
-        case S3C2412_UCON_USYSCLK:
-                clk->divisor = 1;
-                clk->name = "usysclk";
-                break;
-        }
-
-        return 0;
-}
-
-static int s3c2412_serial_resetport(struct uart_port *port,
-                                    struct s3c2410_uartcfg *cfg)
-{
-        unsigned long ucon = rd_regl(port, S3C2410_UCON);
-
-        dbg("%s: port=%p (%08lx), cfg=%p\n",
-            __func__, port, port->mapbase, cfg);
-
-        /* ensure we don't change the clock settings... */
-
-        ucon &= S3C2412_UCON_CLKMASK;
-
-        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon);
-        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
-
-        /* reset both fifos */
-
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
-        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
-
-        return 0;
-}
-
-static struct s3c24xx_uart_info s3c2412_uart_inf = {
-        .name           = "Samsung S3C2412 UART",
-        .type           = PORT_S3C2412,
-        .fifosize       = 64,
-        .rx_fifomask    = S3C2440_UFSTAT_RXMASK,
-        .rx_fifoshift   = S3C2440_UFSTAT_RXSHIFT,
-        .rx_fifofull    = S3C2440_UFSTAT_RXFULL,
-        .tx_fifofull    = S3C2440_UFSTAT_TXFULL,
-        .tx_fifomask    = S3C2440_UFSTAT_TXMASK,
-        .tx_fifoshift   = S3C2440_UFSTAT_TXSHIFT,
-        .get_clksrc     = s3c2412_serial_getsource,
-        .set_clksrc     = s3c2412_serial_setsource,
-        .reset_port     = s3c2412_serial_resetport,
-};
-
-/* device management */
-
-static int s3c2412_serial_probe(struct platform_device *dev)
-{
-        dbg("s3c2440_serial_probe: dev=%p\n", dev);
-        return s3c24xx_serial_probe(dev, &s3c2412_uart_inf);
-}
-
-static struct platform_driver s3c2412_serial_drv = {
-        .probe          = s3c2412_serial_probe,
-        .remove         = s3c24xx_serial_remove,
-        .suspend        = s3c24xx_serial_suspend,
-        .resume         = s3c24xx_serial_resume,
-        .driver         = {
-                .name   = "s3c2412-uart",
-                .owner  = THIS_MODULE,
-        },
-};
-
-
-static inline int s3c2412_serial_init(void)
-{
-        return s3c24xx_serial_init(&s3c2412_serial_drv, &s3c2412_uart_inf);
-}
-
-static inline void s3c2412_serial_exit(void)
-{
-        platform_driver_unregister(&s3c2412_serial_drv);
-}
-
-#define s3c2412_uart_inf_at &s3c2412_uart_inf
-#else
-
-static inline int s3c2412_serial_init(void)
-{
-        return 0;
-}
-
-static inline void s3c2412_serial_exit(void)
-{
-}
-
-#define s3c2412_uart_inf_at NULL
-#endif /* CONFIG_CPU_S3C2440 */
-
-
-/* module initialisation code */
-
-static int __init s3c24xx_serial_modinit(void)
-{
-        int ret;
-
-        ret = uart_register_driver(&s3c24xx_uart_drv);
-        if (ret < 0) {
-                printk(KERN_ERR "failed to register UART driver\n");
-                return -1;
-        }
-
-        s3c2400_serial_init();
-        s3c2410_serial_init();
-        s3c2412_serial_init();
-        s3c2440_serial_init();
-
-        return 0;
-}
-
-static void __exit s3c24xx_serial_modexit(void)
-{
-        s3c2400_serial_exit();
-        s3c2410_serial_exit();
-        s3c2412_serial_exit();
-        s3c2440_serial_exit();
-
-        uart_unregister_driver(&s3c24xx_uart_drv);
-}
-
-
-module_init(s3c24xx_serial_modinit);
-module_exit(s3c24xx_serial_modexit);
-
-/* Console code */
-
-#ifdef CONFIG_SERIAL_S3C2410_CONSOLE
-
-static struct uart_port *cons_uart;
-
-static int
-s3c24xx_serial_console_txrdy(struct uart_port *port, unsigned int ufcon)
-{
-        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
-        unsigned long ufstat, utrstat;
-
-        if (ufcon & S3C2410_UFCON_FIFOMODE) {
-                /* fifo mode - check ammount of data in fifo registers... */
-
-                ufstat = rd_regl(port, S3C2410_UFSTAT);
-                return (ufstat & info->tx_fifofull) ? 0 : 1;
-        }
-
-        /* in non-fifo mode, we go and use the tx buffer empty */
-
-        utrstat = rd_regl(port, S3C2410_UTRSTAT);
-        return (utrstat & S3C2410_UTRSTAT_TXE) ? 1 : 0;
-}
-
-static void
-s3c24xx_serial_console_putchar(struct uart_port *port, int ch)
-{
-        unsigned int ufcon = rd_regl(cons_uart, S3C2410_UFCON);
-        while (!s3c24xx_serial_console_txrdy(port, ufcon))
-                barrier();
-        wr_regb(cons_uart, S3C2410_UTXH, ch);
-}
-
-static void
-s3c24xx_serial_console_write(struct console *co, const char *s,
-                             unsigned int count)
-{
-        uart_console_write(cons_uart, s, count, s3c24xx_serial_console_putchar);
-}
-
-static void __init
-s3c24xx_serial_get_options(struct uart_port *port, int *baud,
-                           int *parity, int *bits)
-{
-        struct s3c24xx_uart_clksrc clksrc;
-        struct clk *clk;
-        unsigned int ulcon;
-        unsigned int ucon;
-        unsigned int ubrdiv;
-        unsigned long rate;
-
-        ulcon  = rd_regl(port, S3C2410_ULCON);
-        ucon   = rd_regl(port, S3C2410_UCON);
-        ubrdiv = rd_regl(port, S3C2410_UBRDIV);
-
-        dbg("s3c24xx_serial_get_options: port=%p\n"
-            "registers: ulcon=%08x, ucon=%08x, ubdriv=%08x\n",
-            port, ulcon, ucon, ubrdiv);
-
-        if ((ucon & 0xf) != 0) {
-                /* consider the serial port configured if the tx/rx mode set */
-
-                switch (ulcon & S3C2410_LCON_CSMASK) {
-                case S3C2410_LCON_CS5:
-                        *bits = 5;
-                        break;
-                case S3C2410_LCON_CS6:
-                        *bits = 6;
-                        break;
-                case S3C2410_LCON_CS7:
-                        *bits = 7;
-                        break;
-                default:
-                case S3C2410_LCON_CS8:
-                        *bits = 8;
-                        break;
-                }
-
-                switch (ulcon & S3C2410_LCON_PMASK) {
-                case S3C2410_LCON_PEVEN:
-                        *parity = 'e';
-                        break;
-
-                case S3C2410_LCON_PODD:
-                        *parity = 'o';
-                        break;
-
-                case S3C2410_LCON_PNONE:
-                default:
-                        *parity = 'n';
-                }
-
-                /* now calculate the baud rate */
-
-                s3c24xx_serial_getsource(port, &clksrc);
-
-                clk = clk_get(port->dev, clksrc.name);
-                if (!IS_ERR(clk) && clk != NULL)
-                        rate = clk_get_rate(clk) / clksrc.divisor;
-                else
-                        rate = 1;
-
-
-                *baud = rate / ( 16 * (ubrdiv + 1));
-                dbg("calculated baud %d\n", *baud);
-        }
-
-}
-
-/* s3c24xx_serial_init_ports
- *
- * initialise the serial ports from the machine provided initialisation
- * data.
-*/
-
-static int s3c24xx_serial_init_ports(struct s3c24xx_uart_info *info)
-{
-        struct s3c24xx_uart_port *ptr = s3c24xx_serial_ports;
-        struct platform_device **platdev_ptr;
-        int i;
-
-        dbg("s3c24xx_serial_init_ports: initialising ports...\n");
-
-        platdev_ptr = s3c24xx_uart_devs;
-
-        for (i = 0; i < NR_PORTS; i++, ptr++, platdev_ptr++) {
-                s3c24xx_serial_init_port(ptr, info, *platdev_ptr);
-        }
-
-        return 0;
-}
-
-static int __init
-s3c24xx_serial_console_setup(struct console *co, char *options)
-{
-        struct uart_port *port;
-        int baud = 9600;
-        int bits = 8;
-        int parity = 'n';
-        int flow = 'n';
-
-        dbg("s3c24xx_serial_console_setup: co=%p (%d), %s\n",
-            co, co->index, options);
-
-        /* is this a valid port */
-
-        if (co->index == -1 || co->index >= NR_PORTS)
-                co->index = 0;
-
-        port = &s3c24xx_serial_ports[co->index].port;
-
-        /* is the port configured? */
-
-        if (port->mapbase == 0x0) {
-                co->index = 0;
-                port = &s3c24xx_serial_ports[co->index].port;
-        }
-
-        cons_uart = port;
-
-        dbg("s3c24xx_serial_console_setup: port=%p (%d)\n", port, co->index);
-
-        /*
-         * Check whether an invalid uart number has been specified, and
-         * if so, search for the first available port that does have
-         * console support.
-         */
-        if (options)
-                uart_parse_options(options, &baud, &parity, &bits, &flow);
-        else
-                s3c24xx_serial_get_options(port, &baud, &parity, &bits);
-
-        dbg("s3c24xx_serial_console_setup: baud %d\n", baud);
-
-        return uart_set_options(port, co, baud, parity, bits, flow);
-}
-
-/* s3c24xx_serial_initconsole
- *
- * initialise the console from one of the uart drivers
-*/
-
-static struct console s3c24xx_serial_console =
-{
-        .name           = S3C24XX_SERIAL_NAME,
-        .device         = uart_console_device,
-        .flags          = CON_PRINTBUFFER,
-        .index          = -1,
-        .write          = s3c24xx_serial_console_write,
-        .setup          = s3c24xx_serial_console_setup
-};
-
-static int s3c24xx_serial_initconsole(void)
-{
-        struct s3c24xx_uart_info *info;
-        struct platform_device *dev = s3c24xx_uart_devs[0];
-
-        dbg("s3c24xx_serial_initconsole\n");
-
-        /* select driver based on the cpu */
-
-        if (dev == NULL) {
-                printk(KERN_ERR "s3c24xx: no devices for console init\n");
-                return 0;
-        }
-
-        if (strcmp(dev->name, "s3c2400-uart") == 0) {
-                info = s3c2400_uart_inf_at;
-        } else if (strcmp(dev->name, "s3c2410-uart") == 0) {
-                info = s3c2410_uart_inf_at;
-        } else if (strcmp(dev->name, "s3c2440-uart") == 0) {
-                info = s3c2440_uart_inf_at;
-        } else if (strcmp(dev->name, "s3c2412-uart") == 0) {
-                info = s3c2412_uart_inf_at;
-        } else {
-                printk(KERN_ERR "s3c24xx: no driver for %s\n", dev->name);
-                return 0;
-        }
-
-        if (info == NULL) {
-                printk(KERN_ERR "s3c24xx: no driver for console\n");
-                return 0;
-        }
-
-        s3c24xx_serial_console.data = &s3c24xx_uart_drv;
-        s3c24xx_serial_init_ports(info);
-
-        register_console(&s3c24xx_serial_console);
-        return 0;
-}
-
-console_initcall(s3c24xx_serial_initconsole);
-
-#endif /* CONFIG_SERIAL_S3C2410_CONSOLE */
+module_init(s3c2410_serial_init);
+module_exit(s3c2410_serial_exit);
 
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
-MODULE_DESCRIPTION("Samsung S3C2410/S3C2440/S3C2412 Serial port driver");
-MODULE_ALIAS("platform:s3c2400-uart");
+MODULE_DESCRIPTION("Samsung S3C2410 SoC Serial port driver");
 MODULE_ALIAS("platform:s3c2410-uart");
-MODULE_ALIAS("platform:s3c2412-uart");
-MODULE_ALIAS("platform:s3c2440-uart");
diff --git a/drivers/serial/s3c2412.c b/drivers/serial/s3c2412.c
new file mode 100644
index 000000000000..ce0c220e3e92
--- /dev/null
+++ b/drivers/serial/s3c2412.c
@@ -0,0 +1,151 @@
+/* linux/drivers/serial/s3c2412.c
+ *
+ * Driver for Samsung S3C2412 and S3C2413 SoC onboard UARTs.
+ *
+ * Ben Dooks, Copyright (c) 2003-2005,2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *
+ * 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/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/serial_core.h>
+#include <linux/serial.h>
+
+#include <asm/irq.h>
+#include <asm/hardware.h>
+
+#include <asm/plat-s3c/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "samsung.h"
+
+static int s3c2412_serial_setsource(struct uart_port *port,
+                                     struct s3c24xx_uart_clksrc *clk)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        ucon &= ~S3C2412_UCON_CLKMASK;
+
+        if (strcmp(clk->name, "uclk") == 0)
+                ucon |= S3C2440_UCON_UCLK;
+        else if (strcmp(clk->name, "pclk") == 0)
+                ucon |= S3C2440_UCON_PCLK;
+        else if (strcmp(clk->name, "usysclk") == 0)
+                ucon |= S3C2412_UCON_USYSCLK;
+        else {
+                printk(KERN_ERR "unknown clock source %s\n", clk->name);
+                return -EINVAL;
+        }
+
+        wr_regl(port, S3C2410_UCON, ucon);
+        return 0;
+}
+
+
+static int s3c2412_serial_getsource(struct uart_port *port,
+                                    struct s3c24xx_uart_clksrc *clk)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        switch (ucon & S3C2412_UCON_CLKMASK) {
+        case S3C2412_UCON_UCLK:
+                clk->divisor = 1;
+                clk->name = "uclk";
+                break;
+
+        case S3C2412_UCON_PCLK:
+        case S3C2412_UCON_PCLK2:
+                clk->divisor = 1;
+                clk->name = "pclk";
+                break;
+
+        case S3C2412_UCON_USYSCLK:
+                clk->divisor = 1;
+                clk->name = "usysclk";
+                break;
+        }
+
+        return 0;
+}
+
+static int s3c2412_serial_resetport(struct uart_port *port,
+                                    struct s3c2410_uartcfg *cfg)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        dbg("%s: port=%p (%08lx), cfg=%p\n",
+            __func__, port, port->mapbase, cfg);
+
+        /* ensure we don't change the clock settings... */
+
+        ucon &= S3C2412_UCON_CLKMASK;
+
+        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon);
+        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
+
+        /* reset both fifos */
+
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
+
+        return 0;
+}
+
+static struct s3c24xx_uart_info s3c2412_uart_inf = {
+        .name           = "Samsung S3C2412 UART",
+        .type           = PORT_S3C2412,
+        .fifosize       = 64,
+        .rx_fifomask    = S3C2440_UFSTAT_RXMASK,
+        .rx_fifoshift   = S3C2440_UFSTAT_RXSHIFT,
+        .rx_fifofull    = S3C2440_UFSTAT_RXFULL,
+        .tx_fifofull    = S3C2440_UFSTAT_TXFULL,
+        .tx_fifomask    = S3C2440_UFSTAT_TXMASK,
+        .tx_fifoshift   = S3C2440_UFSTAT_TXSHIFT,
+        .get_clksrc     = s3c2412_serial_getsource,
+        .set_clksrc     = s3c2412_serial_setsource,
+        .reset_port     = s3c2412_serial_resetport,
+};
+
+/* device management */
+
+static int s3c2412_serial_probe(struct platform_device *dev)
+{
+        dbg("s3c2440_serial_probe: dev=%p\n", dev);
+        return s3c24xx_serial_probe(dev, &s3c2412_uart_inf);
+}
+
+static struct platform_driver s3c2412_serial_drv = {
+        .probe          = s3c2412_serial_probe,
+        .remove         = s3c24xx_serial_remove,
+        .driver         = {
+                .name   = "s3c2412-uart",
+                .owner  = THIS_MODULE,
+        },
+};
+
+s3c24xx_console_init(&s3c2412_serial_drv, &s3c2412_uart_inf);
+
+static inline int s3c2412_serial_init(void)
+{
+        return s3c24xx_serial_init(&s3c2412_serial_drv, &s3c2412_uart_inf);
+}
+
+static inline void s3c2412_serial_exit(void)
+{
+        platform_driver_unregister(&s3c2412_serial_drv);
+}
+
+module_init(s3c2412_serial_init);
+module_exit(s3c2412_serial_exit);
+
+MODULE_DESCRIPTION("Samsung S3C2412,S3C2413 SoC Serial port driver");
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:s3c2412-uart");
diff --git a/drivers/serial/s3c2440.c b/drivers/serial/s3c2440.c
new file mode 100644
index 000000000000..38f954bd39c6
--- /dev/null
+++ b/drivers/serial/s3c2440.c
@@ -0,0 +1,181 @@
+/* linux/drivers/serial/s3c2440.c
+ *
+ * Driver for Samsung S3C2440 and S3C2442 SoC onboard UARTs.
+ *
+ * Ben Dooks, Copyright (c) 2003-2005,2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *
+ * 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/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/serial_core.h>
+#include <linux/serial.h>
+
+#include <asm/irq.h>
+#include <asm/hardware.h>
+
+#include <asm/plat-s3c/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "samsung.h"
+
+
+static int s3c2440_serial_setsource(struct uart_port *port,
+                                     struct s3c24xx_uart_clksrc *clk)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        /* todo - proper fclk<>nonfclk switch. */
+
+        ucon &= ~S3C2440_UCON_CLKMASK;
+
+        if (strcmp(clk->name, "uclk") == 0)
+                ucon |= S3C2440_UCON_UCLK;
+        else if (strcmp(clk->name, "pclk") == 0)
+                ucon |= S3C2440_UCON_PCLK;
+        else if (strcmp(clk->name, "fclk") == 0)
+                ucon |= S3C2440_UCON_FCLK;
+        else {
+                printk(KERN_ERR "unknown clock source %s\n", clk->name);
+                return -EINVAL;
+        }
+
+        wr_regl(port, S3C2410_UCON, ucon);
+        return 0;
+}
+
+
+static int s3c2440_serial_getsource(struct uart_port *port,
+                                    struct s3c24xx_uart_clksrc *clk)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+        unsigned long ucon0, ucon1, ucon2;
+
+        switch (ucon & S3C2440_UCON_CLKMASK) {
+        case S3C2440_UCON_UCLK:
+                clk->divisor = 1;
+                clk->name = "uclk";
+                break;
+
+        case S3C2440_UCON_PCLK:
+        case S3C2440_UCON_PCLK2:
+                clk->divisor = 1;
+                clk->name = "pclk";
+                break;
+
+        case S3C2440_UCON_FCLK:
+                /* the fun of calculating the uart divisors on
+                 * the s3c2440 */
+
+                ucon0 = __raw_readl(S3C24XX_VA_UART0 + S3C2410_UCON);
+                ucon1 = __raw_readl(S3C24XX_VA_UART1 + S3C2410_UCON);
+                ucon2 = __raw_readl(S3C24XX_VA_UART2 + S3C2410_UCON);
+
+                printk("ucons: %08lx, %08lx, %08lx\n", ucon0, ucon1, ucon2);
+
+                ucon0 &= S3C2440_UCON0_DIVMASK;
+                ucon1 &= S3C2440_UCON1_DIVMASK;
+                ucon2 &= S3C2440_UCON2_DIVMASK;
+
+                if (ucon0 != 0) {
+                        clk->divisor = ucon0 >> S3C2440_UCON_DIVSHIFT;
+                        clk->divisor += 6;
+                } else if (ucon1 != 0) {
+                        clk->divisor = ucon1 >> S3C2440_UCON_DIVSHIFT;
+                        clk->divisor += 21;
+                } else if (ucon2 != 0) {
+                        clk->divisor = ucon2 >> S3C2440_UCON_DIVSHIFT;
+                        clk->divisor += 36;
+                } else {
+                        /* manual calims 44, seems to be 9 */
+                        clk->divisor = 9;
+                }
+
+                clk->name = "fclk";
+                break;
+        }
+
+        return 0;
+}
+
+static int s3c2440_serial_resetport(struct uart_port *port,
+                                    struct s3c2410_uartcfg *cfg)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        dbg("s3c2440_serial_resetport: port=%p (%08lx), cfg=%p\n",
+            port, port->mapbase, cfg);
+
+        /* ensure we don't change the clock settings... */
+
+        ucon &= (S3C2440_UCON0_DIVMASK | (3<<10));
+
+        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon);
+        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
+
+        /* reset both fifos */
+
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
+
+        return 0;
+}
+
+static struct s3c24xx_uart_info s3c2440_uart_inf = {
+        .name           = "Samsung S3C2440 UART",
+        .type           = PORT_S3C2440,
+        .fifosize       = 64,
+        .rx_fifomask    = S3C2440_UFSTAT_RXMASK,
+        .rx_fifoshift   = S3C2440_UFSTAT_RXSHIFT,
+        .rx_fifofull    = S3C2440_UFSTAT_RXFULL,
+        .tx_fifofull    = S3C2440_UFSTAT_TXFULL,
+        .tx_fifomask    = S3C2440_UFSTAT_TXMASK,
+        .tx_fifoshift   = S3C2440_UFSTAT_TXSHIFT,
+        .get_clksrc     = s3c2440_serial_getsource,
+        .set_clksrc     = s3c2440_serial_setsource,
+        .reset_port     = s3c2440_serial_resetport,
+};
+
+/* device management */
+
+static int s3c2440_serial_probe(struct platform_device *dev)
+{
+        dbg("s3c2440_serial_probe: dev=%p\n", dev);
+        return s3c24xx_serial_probe(dev, &s3c2440_uart_inf);
+}
+
+static struct platform_driver s3c2440_serial_drv = {
+        .probe          = s3c2440_serial_probe,
+        .remove         = s3c24xx_serial_remove,
+        .driver         = {
+                .name   = "s3c2440-uart",
+                .owner  = THIS_MODULE,
+        },
+};
+
+s3c24xx_console_init(&s3c2440_serial_drv, &s3c2440_uart_inf);
+
+static int __init s3c2440_serial_init(void)
+{
+        return s3c24xx_serial_init(&s3c2440_serial_drv, &s3c2440_uart_inf);
+}
+
+static void __exit s3c2440_serial_exit(void)
+{
+        platform_driver_unregister(&s3c2440_serial_drv);
+}
+
+module_init(s3c2440_serial_init);
+module_exit(s3c2440_serial_exit);
+
+MODULE_DESCRIPTION("Samsung S3C2440,S3C2442 SoC Serial port driver");
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_LICENSE("GPLi v2");
+MODULE_ALIAS("platform:s3c2440-uart");
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
new file mode 100644
index 000000000000..4a3ecaa629e6
--- /dev/null
+++ b/drivers/serial/samsung.c
@@ -0,0 +1,1317 @@
+/* linux/drivers/serial/samsuing.c
+ *
+ * Driver core for Samsung SoC onboard UARTs.
+ *
+ * Ben Dooks, Copyright (c) 2003-2005,2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *
+ * 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.
+*/
+
+/* Hote on 2410 error handling
+ *
+ * The s3c2410 manual has a love/hate affair with the contents of the
+ * UERSTAT register in the UART blocks, and keeps marking some of the
+ * error bits as reserved. Having checked with the s3c2410x01,
+ * it copes with BREAKs properly, so I am happy to ignore the RESERVED
+ * feature from the latter versions of the manual.
+ *
+ * If it becomes aparrent that latter versions of the 2410 remove these
+ * bits, then action will have to be taken to differentiate the versions
+ * and change the policy on BREAK
+ *
+ * BJD, 04-Nov-2004
+*/
+
+#if defined(CONFIG_SERIAL_SAMSUNG_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+#define SUPPORT_SYSRQ
+#endif
+
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/sysrq.h>
+#include <linux/console.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial_core.h>
+#include <linux/serial.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+
+#include <asm/irq.h>
+
+#include <asm/hardware.h>
+
+#include <asm/plat-s3c/regs-serial.h>
+#include <asm/arch/regs-gpio.h>
+
+#include "samsung.h"
+
+/* UART name and device definitions */
+
+#define S3C24XX_SERIAL_NAME     "ttySAC"
+#define S3C24XX_SERIAL_MAJOR    204
+#define S3C24XX_SERIAL_MINOR    64
+
+/* we can support 3 uarts, but not always use them */
+
+#ifdef CONFIG_CPU_S3C2400
+#define NR_PORTS (2)
+#else
+#define NR_PORTS (3)
+#endif
+
+/* port irq numbers */
+
+#define TX_IRQ(port) ((port)->irq + 1)
+#define RX_IRQ(port) ((port)->irq)
+
+/* macros to change one thing to another */
+
+#define tx_enabled(port) ((port)->unused[0])
+#define rx_enabled(port) ((port)->unused[1])
+
+/* flag to ignore all characters comming in */
+#define RXSTAT_DUMMY_READ (0x10000000)
+
+static inline struct s3c24xx_uart_port *to_ourport(struct uart_port *port)
+{
+        return container_of(port, struct s3c24xx_uart_port, port);
+}
+
+/* translate a port to the device name */
+
+static inline const char *s3c24xx_serial_portname(struct uart_port *port)
+{
+        return to_platform_device(port->dev)->name;
+}
+
+static int s3c24xx_serial_txempty_nofifo(struct uart_port *port)
+{
+        return (rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE);
+}
+
+static void s3c24xx_serial_rx_enable(struct uart_port *port)
+{
+        unsigned long flags;
+        unsigned int ucon, ufcon;
+        int count = 10000;
+
+        spin_lock_irqsave(&port->lock, flags);
+
+        while (--count && !s3c24xx_serial_txempty_nofifo(port))
+                udelay(100);
+
+        ufcon = rd_regl(port, S3C2410_UFCON);
+        ufcon |= S3C2410_UFCON_RESETRX;
+        wr_regl(port, S3C2410_UFCON, ufcon);
+
+        ucon = rd_regl(port, S3C2410_UCON);
+        ucon |= S3C2410_UCON_RXIRQMODE;
+        wr_regl(port, S3C2410_UCON, ucon);
+
+        rx_enabled(port) = 1;
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static void s3c24xx_serial_rx_disable(struct uart_port *port)
+{
+        unsigned long flags;
+        unsigned int ucon;
+
+        spin_lock_irqsave(&port->lock, flags);
+
+        ucon = rd_regl(port, S3C2410_UCON);
+        ucon &= ~S3C2410_UCON_RXIRQMODE;
+        wr_regl(port, S3C2410_UCON, ucon);
+
+        rx_enabled(port) = 0;
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static void s3c24xx_serial_stop_tx(struct uart_port *port)
+{
+        if (tx_enabled(port)) {
+                disable_irq(TX_IRQ(port));
+                tx_enabled(port) = 0;
+                if (port->flags & UPF_CONS_FLOW)
+                        s3c24xx_serial_rx_enable(port);
+        }
+}
+
+static void s3c24xx_serial_start_tx(struct uart_port *port)
+{
+        if (!tx_enabled(port)) {
+                if (port->flags & UPF_CONS_FLOW)
+                        s3c24xx_serial_rx_disable(port);
+
+                enable_irq(TX_IRQ(port));
+                tx_enabled(port) = 1;
+        }
+}
+
+
+static void s3c24xx_serial_stop_rx(struct uart_port *port)
+{
+        if (rx_enabled(port)) {
+                dbg("s3c24xx_serial_stop_rx: port=%p\n", port);
+                disable_irq(RX_IRQ(port));
+                rx_enabled(port) = 0;
+        }
+}
+
+static void s3c24xx_serial_enable_ms(struct uart_port *port)
+{
+}
+
+static inline struct s3c24xx_uart_info *s3c24xx_port_to_info(struct uart_port *port)
+{
+        return to_ourport(port)->info;
+}
+
+static inline struct s3c2410_uartcfg *s3c24xx_port_to_cfg(struct uart_port *port)
+{
+        if (port->dev == NULL)
+                return NULL;
+
+        return (struct s3c2410_uartcfg *)port->dev->platform_data;
+}
+
+static int s3c24xx_serial_rx_fifocnt(struct s3c24xx_uart_port *ourport,
+                                     unsigned long ufstat)
+{
+        struct s3c24xx_uart_info *info = ourport->info;
+
+        if (ufstat & info->rx_fifofull)
+                return info->fifosize;
+
+        return (ufstat & info->rx_fifomask) >> info->rx_fifoshift;
+}
+
+
+/* ? - where has parity gone?? */
+#define S3C2410_UERSTAT_PARITY (0x1000)
+
+static irqreturn_t
+s3c24xx_serial_rx_chars(int irq, void *dev_id)
+{
+        struct s3c24xx_uart_port *ourport = dev_id;
+        struct uart_port *port = &ourport->port;
+        struct tty_struct *tty = port->info->tty;
+        unsigned int ufcon, ch, flag, ufstat, uerstat;
+        int max_count = 64;
+
+        while (max_count-- > 0) {
+                ufcon = rd_regl(port, S3C2410_UFCON);
+                ufstat = rd_regl(port, S3C2410_UFSTAT);
+
+                if (s3c24xx_serial_rx_fifocnt(ourport, ufstat) == 0)
+                        break;
+
+                uerstat = rd_regl(port, S3C2410_UERSTAT);
+                ch = rd_regb(port, S3C2410_URXH);
+
+                if (port->flags & UPF_CONS_FLOW) {
+                        int txe = s3c24xx_serial_txempty_nofifo(port);
+
+                        if (rx_enabled(port)) {
+                                if (!txe) {
+                                        rx_enabled(port) = 0;
+                                        continue;
+                                }
+                        } else {
+                                if (txe) {
+                                        ufcon |= S3C2410_UFCON_RESETRX;
+                                        wr_regl(port, S3C2410_UFCON, ufcon);
+                                        rx_enabled(port) = 1;
+                                        goto out;
+                                }
+                                continue;
+                        }
+                }
+
+                /* insert the character into the buffer */
+
+                flag = TTY_NORMAL;
+                port->icount.rx++;
+
+                if (unlikely(uerstat & S3C2410_UERSTAT_ANY)) {
+                        dbg("rxerr: port ch=0x%02x, rxs=0x%08x\n",
+                            ch, uerstat);
+
+                        /* check for break */
+                        if (uerstat & S3C2410_UERSTAT_BREAK) {
+                                dbg("break!\n");
+                                port->icount.brk++;
+                                if (uart_handle_break(port))
+                                    goto ignore_char;
+                        }
+
+                        if (uerstat & S3C2410_UERSTAT_FRAME)
+                                port->icount.frame++;
+                        if (uerstat & S3C2410_UERSTAT_OVERRUN)
+                                port->icount.overrun++;
+
+                        uerstat &= port->read_status_mask;
+
+                        if (uerstat & S3C2410_UERSTAT_BREAK)
+                                flag = TTY_BREAK;
+                        else if (uerstat & S3C2410_UERSTAT_PARITY)
+                                flag = TTY_PARITY;
+                        else if (uerstat & (S3C2410_UERSTAT_FRAME |
+                                            S3C2410_UERSTAT_OVERRUN))
+                                flag = TTY_FRAME;
+                }
+
+                if (uart_handle_sysrq_char(port, ch))
+                        goto ignore_char;
+
+                uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,
+                                 ch, flag);
+
+ ignore_char:
+                continue;
+        }
+        tty_flip_buffer_push(tty);
+
+ out:
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)
+{
+        struct s3c24xx_uart_port *ourport = id;
+        struct uart_port *port = &ourport->port;
+        struct circ_buf *xmit = &port->info->xmit;
+        int count = 256;
+
+        if (port->x_char) {
+                wr_regb(port, S3C2410_UTXH, port->x_char);
+                port->icount.tx++;
+                port->x_char = 0;
+                goto out;
+        }
+
+        /* if there isnt anything more to transmit, or the uart is now
+         * stopped, disable the uart and exit
+        */
+
+        if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
+                s3c24xx_serial_stop_tx(port);
+                goto out;
+        }
+
+        /* try and drain the buffer... */
+
+        while (!uart_circ_empty(xmit) && count-- > 0) {
+                if (rd_regl(port, S3C2410_UFSTAT) & ourport->info->tx_fifofull)
+                        break;
+
+                wr_regb(port, S3C2410_UTXH, xmit->buf[xmit->tail]);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                port->icount.tx++;
+        }
+
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(port);
+
+        if (uart_circ_empty(xmit))
+                s3c24xx_serial_stop_tx(port);
+
+ out:
+        return IRQ_HANDLED;
+}
+
+static unsigned int s3c24xx_serial_tx_empty(struct uart_port *port)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+        unsigned long ufstat = rd_regl(port, S3C2410_UFSTAT);
+        unsigned long ufcon = rd_regl(port, S3C2410_UFCON);
+
+        if (ufcon & S3C2410_UFCON_FIFOMODE) {
+                if ((ufstat & info->tx_fifomask) != 0 ||
+                    (ufstat & info->tx_fifofull))
+                        return 0;
+
+                return 1;
+        }
+
+        return s3c24xx_serial_txempty_nofifo(port);
+}
+
+/* no modem control lines */
+static unsigned int s3c24xx_serial_get_mctrl(struct uart_port *port)
+{
+        unsigned int umstat = rd_regb(port, S3C2410_UMSTAT);
+
+        if (umstat & S3C2410_UMSTAT_CTS)
+                return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
+        else
+                return TIOCM_CAR | TIOCM_DSR;
+}
+
+static void s3c24xx_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+        /* todo - possibly remove AFC and do manual CTS */
+}
+
+static void s3c24xx_serial_break_ctl(struct uart_port *port, int break_state)
+{
+        unsigned long flags;
+        unsigned int ucon;
+
+        spin_lock_irqsave(&port->lock, flags);
+
+        ucon = rd_regl(port, S3C2410_UCON);
+
+        if (break_state)
+                ucon |= S3C2410_UCON_SBREAK;
+        else
+                ucon &= ~S3C2410_UCON_SBREAK;
+
+        wr_regl(port, S3C2410_UCON, ucon);
+
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static void s3c24xx_serial_shutdown(struct uart_port *port)
+{
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+
+        if (ourport->tx_claimed) {
+                free_irq(TX_IRQ(port), ourport);
+                tx_enabled(port) = 0;
+                ourport->tx_claimed = 0;
+        }
+
+        if (ourport->rx_claimed) {
+                free_irq(RX_IRQ(port), ourport);
+                ourport->rx_claimed = 0;
+                rx_enabled(port) = 0;
+        }
+}
+
+
+static int s3c24xx_serial_startup(struct uart_port *port)
+{
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+        int ret;
+
+        dbg("s3c24xx_serial_startup: port=%p (%08lx,%p)\n",
+            port->mapbase, port->membase);
+
+        rx_enabled(port) = 1;
+
+        ret = request_irq(RX_IRQ(port),
+                          s3c24xx_serial_rx_chars, 0,
+                          s3c24xx_serial_portname(port), ourport);
+
+        if (ret != 0) {
+                printk(KERN_ERR "cannot get irq %d\n", RX_IRQ(port));
+                return ret;
+        }
+
+        ourport->rx_claimed = 1;
+
+        dbg("requesting tx irq...\n");
+
+        tx_enabled(port) = 1;
+
+        ret = request_irq(TX_IRQ(port),
+                          s3c24xx_serial_tx_chars, 0,
+                          s3c24xx_serial_portname(port), ourport);
+
+        if (ret) {
+                printk(KERN_ERR "cannot get irq %d\n", TX_IRQ(port));
+                goto err;
+        }
+
+        ourport->tx_claimed = 1;
+
+        dbg("s3c24xx_serial_startup ok\n");
+
+        /* the port reset code should have done the correct
+         * register setup for the port controls */
+
+        return ret;
+
+ err:
+        s3c24xx_serial_shutdown(port);
+        return ret;
+}
+
+/* power power management control */
+
+static void s3c24xx_serial_pm(struct uart_port *port, unsigned int level,
+                              unsigned int old)
+{
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+
+        switch (level) {
+        case 3:
+                if (!IS_ERR(ourport->baudclk) && ourport->baudclk != NULL)
+                        clk_disable(ourport->baudclk);
+
+                clk_disable(ourport->clk);
+                break;
+
+        case 0:
+                clk_enable(ourport->clk);
+
+                if (!IS_ERR(ourport->baudclk) && ourport->baudclk != NULL)
+                        clk_enable(ourport->baudclk);
+
+                break;
+        default:
+                printk(KERN_ERR "s3c24xx_serial: unknown pm %d\n", level);
+        }
+}
+
+/* baud rate calculation
+ *
+ * The UARTs on the S3C2410/S3C2440 can take their clocks from a number
+ * of different sources, including the peripheral clock ("pclk") and an
+ * external clock ("uclk"). The S3C2440 also adds the core clock ("fclk")
+ * with a programmable extra divisor.
+ *
+ * The following code goes through the clock sources, and calculates the
+ * baud clocks (and the resultant actual baud rates) and then tries to
+ * pick the closest one and select that.
+ *
+*/
+
+
+#define MAX_CLKS (8)
+
+static struct s3c24xx_uart_clksrc tmp_clksrc = {
+        .name           = "pclk",
+        .min_baud       = 0,
+        .max_baud       = 0,
+        .divisor        = 1,
+};
+
+static inline int
+s3c24xx_serial_getsource(struct uart_port *port, struct s3c24xx_uart_clksrc *c)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+
+        return (info->get_clksrc)(port, c);
+}
+
+static inline int
+s3c24xx_serial_setsource(struct uart_port *port, struct s3c24xx_uart_clksrc *c)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+
+        return (info->set_clksrc)(port, c);
+}
+
+struct baud_calc {
+        struct s3c24xx_uart_clksrc      *clksrc;
+        unsigned int                     calc;
+        unsigned int                     quot;
+        struct clk                      *src;
+};
+
+static int s3c24xx_serial_calcbaud(struct baud_calc *calc,
+                                   struct uart_port *port,
+                                   struct s3c24xx_uart_clksrc *clksrc,
+                                   unsigned int baud)
+{
+        unsigned long rate;
+
+        calc->src = clk_get(port->dev, clksrc->name);
+        if (calc->src == NULL || IS_ERR(calc->src))
+                return 0;
+
+        rate = clk_get_rate(calc->src);
+        rate /= clksrc->divisor;
+
+        calc->clksrc = clksrc;
+        calc->quot = (rate + (8 * baud)) / (16 * baud);
+        calc->calc = (rate / (calc->quot * 16));
+
+        calc->quot--;
+        return 1;
+}
+
+static unsigned int s3c24xx_serial_getclk(struct uart_port *port,
+                                          struct s3c24xx_uart_clksrc **clksrc,
+                                          struct clk **clk,
+                                          unsigned int baud)
+{
+        struct s3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);
+        struct s3c24xx_uart_clksrc *clkp;
+        struct baud_calc res[MAX_CLKS];
+        struct baud_calc *resptr, *best, *sptr;
+        int i;
+
+        clkp = cfg->clocks;
+        best = NULL;
+
+        if (cfg->clocks_size < 2) {
+                if (cfg->clocks_size == 0)
+                        clkp = &tmp_clksrc;
+
+                /* check to see if we're sourcing fclk, and if so we're
+                 * going to have to update the clock source
+                 */
+
+                if (strcmp(clkp->name, "fclk") == 0) {
+                        struct s3c24xx_uart_clksrc src;
+
+                        s3c24xx_serial_getsource(port, &src);
+
+                        /* check that the port already using fclk, and if
+                         * not, then re-select fclk
+                         */
+
+                        if (strcmp(src.name, clkp->name) == 0) {
+                                s3c24xx_serial_setsource(port, clkp);
+                                s3c24xx_serial_getsource(port, &src);
+                        }
+
+                        clkp->divisor = src.divisor;
+                }
+
+                s3c24xx_serial_calcbaud(res, port, clkp, baud);
+                best = res;
+                resptr = best + 1;
+        } else {
+                resptr = res;
+
+                for (i = 0; i < cfg->clocks_size; i++, clkp++) {
+                        if (s3c24xx_serial_calcbaud(resptr, port, clkp, baud))
+                                resptr++;
+                }
+        }
+
+        /* ok, we now need to select the best clock we found */
+
+        if (!best) {
+                unsigned int deviation = (1<<30)|((1<<30)-1);
+                int calc_deviation;
+
+                for (sptr = res; sptr < resptr; sptr++) {
+                        calc_deviation = baud - sptr->calc;
+                        if (calc_deviation < 0)
+                                calc_deviation = -calc_deviation;
+
+                        if (calc_deviation < deviation) {
+                                best = sptr;
+                                deviation = calc_deviation;
+                        }
+                }
+        }
+
+        /* store results to pass back */
+
+        *clksrc = best->clksrc;
+        *clk    = best->src;
+
+        return best->quot;
+}
+
+static void s3c24xx_serial_set_termios(struct uart_port *port,
+                                       struct ktermios *termios,
+                                       struct ktermios *old)
+{
+        struct s3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+        struct s3c24xx_uart_clksrc *clksrc = NULL;
+        struct clk *clk = NULL;
+        unsigned long flags;
+        unsigned int baud, quot;
+        unsigned int ulcon;
+        unsigned int umcon;
+
+        /*
+         * We don't support modem control lines.
+         */
+        termios->c_cflag &= ~(HUPCL | CMSPAR);
+        termios->c_cflag |= CLOCAL;
+
+        /*
+         * Ask the core to calculate the divisor for us.
+         */
+
+        baud = uart_get_baud_rate(port, termios, old, 0, 115200*8);
+
+        if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
+                quot = port->custom_divisor;
+        else
+                quot = s3c24xx_serial_getclk(port, &clksrc, &clk, baud);
+
+        /* check to see if we need  to change clock source */
+
+        if (ourport->clksrc != clksrc || ourport->baudclk != clk) {
+                s3c24xx_serial_setsource(port, clksrc);
+
+                if (ourport->baudclk != NULL && !IS_ERR(ourport->baudclk)) {
+                        clk_disable(ourport->baudclk);
+                        ourport->baudclk  = NULL;
+                }
+
+                clk_enable(clk);
+
+                ourport->clksrc = clksrc;
+                ourport->baudclk = clk;
+        }
+
+        switch (termios->c_cflag & CSIZE) {
+        case CS5:
+                dbg("config: 5bits/char\n");
+                ulcon = S3C2410_LCON_CS5;
+                break;
+        case CS6:
+                dbg("config: 6bits/char\n");
+                ulcon = S3C2410_LCON_CS6;
+                break;
+        case CS7:
+                dbg("config: 7bits/char\n");
+                ulcon = S3C2410_LCON_CS7;
+                break;
+        case CS8:
+        default:
+                dbg("config: 8bits/char\n");
+                ulcon = S3C2410_LCON_CS8;
+                break;
+        }
+
+        /* preserve original lcon IR settings */
+        ulcon |= (cfg->ulcon & S3C2410_LCON_IRM);
+
+        if (termios->c_cflag & CSTOPB)
+                ulcon |= S3C2410_LCON_STOPB;
+
+        umcon = (termios->c_cflag & CRTSCTS) ? S3C2410_UMCOM_AFC : 0;
+
+        if (termios->c_cflag & PARENB) {
+                if (termios->c_cflag & PARODD)
+                        ulcon |= S3C2410_LCON_PODD;
+                else
+                        ulcon |= S3C2410_LCON_PEVEN;
+        } else {
+                ulcon |= S3C2410_LCON_PNONE;
+        }
+
+        spin_lock_irqsave(&port->lock, flags);
+
+        dbg("setting ulcon to %08x, brddiv to %d\n", ulcon, quot);
+
+        wr_regl(port, S3C2410_ULCON, ulcon);
+        wr_regl(port, S3C2410_UBRDIV, quot);
+        wr_regl(port, S3C2410_UMCON, umcon);
+
+        dbg("uart: ulcon = 0x%08x, ucon = 0x%08x, ufcon = 0x%08x\n",
+            rd_regl(port, S3C2410_ULCON),
+            rd_regl(port, S3C2410_UCON),
+            rd_regl(port, S3C2410_UFCON));
+
+        /*
+         * Update the per-port timeout.
+         */
+        uart_update_timeout(port, termios->c_cflag, baud);
+
+        /*
+         * Which character status flags are we interested in?
+         */
+        port->read_status_mask = S3C2410_UERSTAT_OVERRUN;
+        if (termios->c_iflag & INPCK)
+                port->read_status_mask |= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;
+
+        /*
+         * Which character status flags should we ignore?
+         */
+        port->ignore_status_mask = 0;
+        if (termios->c_iflag & IGNPAR)
+                port->ignore_status_mask |= S3C2410_UERSTAT_OVERRUN;
+        if (termios->c_iflag & IGNBRK && termios->c_iflag & IGNPAR)
+                port->ignore_status_mask |= S3C2410_UERSTAT_FRAME;
+
+        /*
+         * Ignore all characters if CREAD is not set.
+         */
+        if ((termios->c_cflag & CREAD) == 0)
+                port->ignore_status_mask |= RXSTAT_DUMMY_READ;
+
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static const char *s3c24xx_serial_type(struct uart_port *port)
+{
+        switch (port->type) {
+        case PORT_S3C2410:
+                return "S3C2410";
+        case PORT_S3C2440:
+                return "S3C2440";
+        case PORT_S3C2412:
+                return "S3C2412";
+        default:
+                return NULL;
+        }
+}
+
+#define MAP_SIZE (0x100)
+
+static void s3c24xx_serial_release_port(struct uart_port *port)
+{
+        release_mem_region(port->mapbase, MAP_SIZE);
+}
+
+static int s3c24xx_serial_request_port(struct uart_port *port)
+{
+        const char *name = s3c24xx_serial_portname(port);
+        return request_mem_region(port->mapbase, MAP_SIZE, name) ? 0 : -EBUSY;
+}
+
+static void s3c24xx_serial_config_port(struct uart_port *port, int flags)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+
+        if (flags & UART_CONFIG_TYPE &&
+            s3c24xx_serial_request_port(port) == 0)
+                port->type = info->type;
+}
+
+/*
+ * verify the new serial_struct (for TIOCSSERIAL).
+ */
+static int
+s3c24xx_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+
+        if (ser->type != PORT_UNKNOWN && ser->type != info->type)
+                return -EINVAL;
+
+        return 0;
+}
+
+
+#ifdef CONFIG_SERIAL_SAMSUNG_CONSOLE
+
+static struct console s3c24xx_serial_console;
+
+#define S3C24XX_SERIAL_CONSOLE &s3c24xx_serial_console
+#else
+#define S3C24XX_SERIAL_CONSOLE NULL
+#endif
+
+static struct uart_ops s3c24xx_serial_ops = {
+        .pm             = s3c24xx_serial_pm,
+        .tx_empty       = s3c24xx_serial_tx_empty,
+        .get_mctrl      = s3c24xx_serial_get_mctrl,
+        .set_mctrl      = s3c24xx_serial_set_mctrl,
+        .stop_tx        = s3c24xx_serial_stop_tx,
+        .start_tx       = s3c24xx_serial_start_tx,
+        .stop_rx        = s3c24xx_serial_stop_rx,
+        .enable_ms      = s3c24xx_serial_enable_ms,
+        .break_ctl      = s3c24xx_serial_break_ctl,
+        .startup        = s3c24xx_serial_startup,
+        .shutdown       = s3c24xx_serial_shutdown,
+        .set_termios    = s3c24xx_serial_set_termios,
+        .type           = s3c24xx_serial_type,
+        .release_port   = s3c24xx_serial_release_port,
+        .request_port   = s3c24xx_serial_request_port,
+        .config_port    = s3c24xx_serial_config_port,
+        .verify_port    = s3c24xx_serial_verify_port,
+};
+
+
+static struct uart_driver s3c24xx_uart_drv = {
+        .owner          = THIS_MODULE,
+        .dev_name       = "s3c2410_serial",
+        .nr             = 3,
+        .cons           = S3C24XX_SERIAL_CONSOLE,
+        .driver_name    = S3C24XX_SERIAL_NAME,
+        .major          = S3C24XX_SERIAL_MAJOR,
+        .minor          = S3C24XX_SERIAL_MINOR,
+};
+
+static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {
+        [0] = {
+                .port = {
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),
+                        .iotype         = UPIO_MEM,
+                        .irq            = IRQ_S3CUART_RX0,
+                        .uartclk        = 0,
+                        .fifosize       = 16,
+                        .ops            = &s3c24xx_serial_ops,
+                        .flags          = UPF_BOOT_AUTOCONF,
+                        .line           = 0,
+                }
+        },
+        [1] = {
+                .port = {
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),
+                        .iotype         = UPIO_MEM,
+                        .irq            = IRQ_S3CUART_RX1,
+                        .uartclk        = 0,
+                        .fifosize       = 16,
+                        .ops            = &s3c24xx_serial_ops,
+                        .flags          = UPF_BOOT_AUTOCONF,
+                        .line           = 1,
+                }
+        },
+#if NR_PORTS > 2
+
+        [2] = {
+                .port = {
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),
+                        .iotype         = UPIO_MEM,
+                        .irq            = IRQ_S3CUART_RX2,
+                        .uartclk        = 0,
+                        .fifosize       = 16,
+                        .ops            = &s3c24xx_serial_ops,
+                        .flags          = UPF_BOOT_AUTOCONF,
+                        .line           = 2,
+                }
+        }
+#endif
+};
+
+/* s3c24xx_serial_resetport
+ *
+ * wrapper to call the specific reset for this port (reset the fifos
+ * and the settings)
+*/
+
+static inline int s3c24xx_serial_resetport(struct uart_port *port,
+                                           struct s3c2410_uartcfg *cfg)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+
+        return (info->reset_port)(port, cfg);
+}
+
+/* s3c24xx_serial_init_port
+ *
+ * initialise a single serial port from the platform device given
+ */
+
+static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
+                                    struct s3c24xx_uart_info *info,
+                                    struct platform_device *platdev)
+{
+        struct uart_port *port = &ourport->port;
+        struct s3c2410_uartcfg *cfg;
+        struct resource *res;
+        int ret;
+
+        dbg("s3c24xx_serial_init_port: port=%p, platdev=%p\n", port, platdev);
+
+        if (platdev == NULL)
+                return -ENODEV;
+
+        cfg = s3c24xx_dev_to_cfg(&platdev->dev);
+
+        if (port->mapbase != 0)
+                return 0;
+
+        if (cfg->hwport > 3)
+                return -EINVAL;
+
+        /* setup info for port */
+        port->dev       = &platdev->dev;
+        ourport->info   = info;
+
+        /* copy the info in from provided structure */
+        ourport->port.fifosize = info->fifosize;
+
+        dbg("s3c24xx_serial_init_port: %p (hw %d)...\n", port, cfg->hwport);
+
+        port->uartclk = 1;
+
+        if (cfg->uart_flags & UPF_CONS_FLOW) {
+                dbg("s3c24xx_serial_init_port: enabling flow control\n");
+                port->flags |= UPF_CONS_FLOW;
+        }
+
+        /* sort our the physical and virtual addresses for each UART */
+
+        res = platform_get_resource(platdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                printk(KERN_ERR "failed to find memory resource for uart\n");
+                return -EINVAL;
+        }
+
+        dbg("resource %p (%lx..%lx)\n", res, res->start, res->end);
+
+        port->mapbase   = res->start;
+        port->membase   = S3C24XX_VA_UART + (res->start - S3C24XX_PA_UART);
+        ret = platform_get_irq(platdev, 0);
+        if (ret < 0)
+                port->irq = 0;
+        else
+                port->irq = ret;
+
+        ourport->clk    = clk_get(&platdev->dev, "uart");
+
+        dbg("port: map=%08x, mem=%08x, irq=%d, clock=%ld\n",
+            port->mapbase, port->membase, port->irq, port->uartclk);
+
+        /* reset the fifos (and setup the uart) */
+        s3c24xx_serial_resetport(port, cfg);
+        return 0;
+}
+
+static ssize_t s3c24xx_serial_show_clksrc(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
+{
+        struct uart_port *port = s3c24xx_dev_to_port(dev);
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+
+        return snprintf(buf, PAGE_SIZE, "* %s\n", ourport->clksrc->name);
+}
+
+static DEVICE_ATTR(clock_source, S_IRUGO, s3c24xx_serial_show_clksrc, NULL);
+
+/* Device driver serial port probe */
+
+static int probe_index;
+
+int s3c24xx_serial_probe(struct platform_device *dev,
+                         struct s3c24xx_uart_info *info)
+{
+        struct s3c24xx_uart_port *ourport;
+        int ret;
+
+        dbg("s3c24xx_serial_probe(%p, %p) %d\n", dev, info, probe_index);
+
+        ourport = &s3c24xx_serial_ports[probe_index];
+        probe_index++;
+
+        dbg("%s: initialising port %p...\n", __func__, ourport);
+
+        ret = s3c24xx_serial_init_port(ourport, info, dev);
+        if (ret < 0)
+                goto probe_err;
+
+        dbg("%s: adding port\n", __func__);
+        uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
+        platform_set_drvdata(dev, &ourport->port);
+
+        ret = device_create_file(&dev->dev, &dev_attr_clock_source);
+        if (ret < 0)
+                printk(KERN_ERR "%s: failed to add clksrc attr.\n", __func__);
+
+        return 0;
+
+ probe_err:
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(s3c24xx_serial_probe);
+
+int s3c24xx_serial_remove(struct platform_device *dev)
+{
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
+
+        if (port) {
+                device_remove_file(&dev->dev, &dev_attr_clock_source);
+                uart_remove_one_port(&s3c24xx_uart_drv, port);
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(s3c24xx_serial_remove);
+
+/* UART power management code */
+
+#ifdef CONFIG_PM
+
+static int s3c24xx_serial_suspend(struct platform_device *dev, pm_message_t state)
+{
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
+
+        if (port)
+                uart_suspend_port(&s3c24xx_uart_drv, port);
+
+        return 0;
+}
+
+static int s3c24xx_serial_resume(struct platform_device *dev)
+{
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
+        struct s3c24xx_uart_port *ourport = to_ourport(port);
+
+        if (port) {
+                clk_enable(ourport->clk);
+                s3c24xx_serial_resetport(port, s3c24xx_port_to_cfg(port));
+                clk_disable(ourport->clk);
+
+                uart_resume_port(&s3c24xx_uart_drv, port);
+        }
+
+        return 0;
+}
+#endif
+
+int s3c24xx_serial_init(struct platform_driver *drv,
+                        struct s3c24xx_uart_info *info)
+{
+        dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
+
+#ifdef CONFIG_PM
+        drv->suspend = s3c24xx_serial_suspend;
+        drv->resume = s3c24xx_serial_resume;
+#endif
+
+        return platform_driver_register(drv);
+}
+
+EXPORT_SYMBOL_GPL(s3c24xx_serial_init);
+
+/* module initialisation code */
+
+static int __init s3c24xx_serial_modinit(void)
+{
+        int ret;
+
+        ret = uart_register_driver(&s3c24xx_uart_drv);
+        if (ret < 0) {
+                printk(KERN_ERR "failed to register UART driver\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static void __exit s3c24xx_serial_modexit(void)
+{
+        uart_unregister_driver(&s3c24xx_uart_drv);
+}
+
+module_init(s3c24xx_serial_modinit);
+module_exit(s3c24xx_serial_modexit);
+
+/* Console code */
+
+#ifdef CONFIG_SERIAL_SAMSUNG_CONSOLE
+
+static struct uart_port *cons_uart;
+
+static int
+s3c24xx_serial_console_txrdy(struct uart_port *port, unsigned int ufcon)
+{
+        struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
+        unsigned long ufstat, utrstat;
+
+        if (ufcon & S3C2410_UFCON_FIFOMODE) {
+                /* fifo mode - check ammount of data in fifo registers... */
+
+                ufstat = rd_regl(port, S3C2410_UFSTAT);
+                return (ufstat & info->tx_fifofull) ? 0 : 1;
+        }
+
+        /* in non-fifo mode, we go and use the tx buffer empty */
+
+        utrstat = rd_regl(port, S3C2410_UTRSTAT);
+        return (utrstat & S3C2410_UTRSTAT_TXE) ? 1 : 0;
+}
+
+static void
+s3c24xx_serial_console_putchar(struct uart_port *port, int ch)
+{
+        unsigned int ufcon = rd_regl(cons_uart, S3C2410_UFCON);
+        while (!s3c24xx_serial_console_txrdy(port, ufcon))
+                barrier();
+        wr_regb(cons_uart, S3C2410_UTXH, ch);
+}
+
+static void
+s3c24xx_serial_console_write(struct console *co, const char *s,
+                             unsigned int count)
+{
+        uart_console_write(cons_uart, s, count, s3c24xx_serial_console_putchar);
+}
+
+static void __init
+s3c24xx_serial_get_options(struct uart_port *port, int *baud,
+                           int *parity, int *bits)
+{
+        struct s3c24xx_uart_clksrc clksrc;
+        struct clk *clk;
+        unsigned int ulcon;
+        unsigned int ucon;
+        unsigned int ubrdiv;
+        unsigned long rate;
+
+        ulcon  = rd_regl(port, S3C2410_ULCON);
+        ucon   = rd_regl(port, S3C2410_UCON);
+        ubrdiv = rd_regl(port, S3C2410_UBRDIV);
+
+        dbg("s3c24xx_serial_get_options: port=%p\n"
+            "registers: ulcon=%08x, ucon=%08x, ubdriv=%08x\n",
+            port, ulcon, ucon, ubrdiv);
+
+        if ((ucon & 0xf) != 0) {
+                /* consider the serial port configured if the tx/rx mode set */
+
+                switch (ulcon & S3C2410_LCON_CSMASK) {
+                case S3C2410_LCON_CS5:
+                        *bits = 5;
+                        break;
+                case S3C2410_LCON_CS6:
+                        *bits = 6;
+                        break;
+                case S3C2410_LCON_CS7:
+                        *bits = 7;
+                        break;
+                default:
+                case S3C2410_LCON_CS8:
+                        *bits = 8;
+                        break;
+                }
+
+                switch (ulcon & S3C2410_LCON_PMASK) {
+                case S3C2410_LCON_PEVEN:
+                        *parity = 'e';
+                        break;
+
+                case S3C2410_LCON_PODD:
+                        *parity = 'o';
+                        break;
+
+                case S3C2410_LCON_PNONE:
+                default:
+                        *parity = 'n';
+                }
+
+                /* now calculate the baud rate */
+
+                s3c24xx_serial_getsource(port, &clksrc);
+
+                clk = clk_get(port->dev, clksrc.name);
+                if (!IS_ERR(clk) && clk != NULL)
+                        rate = clk_get_rate(clk) / clksrc.divisor;
+                else
+                        rate = 1;
+
+
+                *baud = rate / (16 * (ubrdiv + 1));
+                dbg("calculated baud %d\n", *baud);
+        }
+
+}
+
+/* s3c24xx_serial_init_ports
+ *
+ * initialise the serial ports from the machine provided initialisation
+ * data.
+*/
+
+static int s3c24xx_serial_init_ports(struct s3c24xx_uart_info *info)
+{
+        struct s3c24xx_uart_port *ptr = s3c24xx_serial_ports;
+        struct platform_device **platdev_ptr;
+        int i;
+
+        dbg("s3c24xx_serial_init_ports: initialising ports...\n");
+
+        platdev_ptr = s3c24xx_uart_devs;
+
+        for (i = 0; i < NR_PORTS; i++, ptr++, platdev_ptr++) {
+                s3c24xx_serial_init_port(ptr, info, *platdev_ptr);
+        }
+
+        return 0;
+}
+
+static int __init
+s3c24xx_serial_console_setup(struct console *co, char *options)
+{
+        struct uart_port *port;
+        int baud = 9600;
+        int bits = 8;
+        int parity = 'n';
+        int flow = 'n';
+
+        dbg("s3c24xx_serial_console_setup: co=%p (%d), %s\n",
+            co, co->index, options);
+
+        /* is this a valid port */
+
+        if (co->index == -1 || co->index >= NR_PORTS)
+                co->index = 0;
+
+        port = &s3c24xx_serial_ports[co->index].port;
+
+        /* is the port configured? */
+
+        if (port->mapbase == 0x0) {
+                co->index = 0;
+                port = &s3c24xx_serial_ports[co->index].port;
+        }
+
+        cons_uart = port;
+
+        dbg("s3c24xx_serial_console_setup: port=%p (%d)\n", port, co->index);
+
+        /*
+         * Check whether an invalid uart number has been specified, and
+         * if so, search for the first available port that does have
+         * console support.
+         */
+        if (options)
+                uart_parse_options(options, &baud, &parity, &bits, &flow);
+        else
+                s3c24xx_serial_get_options(port, &baud, &parity, &bits);
+
+        dbg("s3c24xx_serial_console_setup: baud %d\n", baud);
+
+        return uart_set_options(port, co, baud, parity, bits, flow);
+}
+
+/* s3c24xx_serial_initconsole
+ *
+ * initialise the console from one of the uart drivers
+*/
+
+static struct console s3c24xx_serial_console = {
+        .name           = S3C24XX_SERIAL_NAME,
+        .device         = uart_console_device,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+        .write          = s3c24xx_serial_console_write,
+        .setup          = s3c24xx_serial_console_setup
+};
+
+int s3c24xx_serial_initconsole(struct platform_driver *drv,
+                               struct s3c24xx_uart_info *info)
+
+{
+        struct platform_device *dev = s3c24xx_uart_devs[0];
+
+        dbg("s3c24xx_serial_initconsole\n");
+
+        /* select driver based on the cpu */
+
+        if (dev == NULL) {
+                printk(KERN_ERR "s3c24xx: no devices for console init\n");
+                return 0;
+        }
+
+        if (strcmp(dev->name, drv->driver.name) != 0)
+                return 0;
+
+        s3c24xx_serial_console.data = &s3c24xx_uart_drv;
+        s3c24xx_serial_init_ports(info);
+
+        register_console(&s3c24xx_serial_console);
+        return 0;
+}
+
+#endif /* CONFIG_SERIAL_SAMSUNG_CONSOLE */
+
+MODULE_DESCRIPTION("Samsung SoC Serial port driver");
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/serial/samsung.h b/drivers/serial/samsung.h
new file mode 100644
index 000000000000..5c92ebbe7d9e
--- /dev/null
+++ b/drivers/serial/samsung.h
@@ -0,0 +1,102 @@
+/* linux/drivers/serial/samsung.h
+ *
+ * Driver for Samsung SoC onboard UARTs.
+ *
+ * Ben Dooks, Copyright (c) 2003-2005,2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *
+ * 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.
+*/
+
+struct s3c24xx_uart_info {
+        char                    *name;
+        unsigned int            type;
+        unsigned int            fifosize;
+        unsigned long           rx_fifomask;
+        unsigned long           rx_fifoshift;
+        unsigned long           rx_fifofull;
+        unsigned long           tx_fifomask;
+        unsigned long           tx_fifoshift;
+        unsigned long           tx_fifofull;
+
+        /* clock source control */
+
+        int (*get_clksrc)(struct uart_port *, struct s3c24xx_uart_clksrc *clk);
+        int (*set_clksrc)(struct uart_port *, struct s3c24xx_uart_clksrc *clk);
+
+        /* uart controls */
+        int (*reset_port)(struct uart_port *, struct s3c2410_uartcfg *);
+};
+
+struct s3c24xx_uart_port {
+        unsigned char                   rx_claimed;
+        unsigned char                   tx_claimed;
+
+        struct s3c24xx_uart_info        *info;
+        struct s3c24xx_uart_clksrc      *clksrc;
+        struct clk                      *clk;
+        struct clk                      *baudclk;
+        struct uart_port                port;
+};
+
+/* conversion functions */
+
+#define s3c24xx_dev_to_port(__dev) (struct uart_port *)dev_get_drvdata(__dev)
+#define s3c24xx_dev_to_cfg(__dev) (struct s3c2410_uartcfg *)((__dev)->platform_data)
+
+/* register access controls */
+
+#define portaddr(port, reg) ((port)->membase + (reg))
+
+#define rd_regb(port, reg) (__raw_readb(portaddr(port, reg)))
+#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg)))
+
+#define wr_regb(port, reg, val) __raw_writeb(val, portaddr(port, reg))
+#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg))
+
+extern int s3c24xx_serial_probe(struct platform_device *dev,
+                                struct s3c24xx_uart_info *uart);
+
+extern int s3c24xx_serial_remove(struct platform_device *dev);
+
+extern int s3c24xx_serial_initconsole(struct platform_driver *drv,
+                                      struct s3c24xx_uart_info *uart);
+
+extern int s3c24xx_serial_init(struct platform_driver *drv,
+                               struct s3c24xx_uart_info *info);
+
+#ifdef CONFIG_SERIAL_SAMSUNG_CONSOLE
+
+#define s3c24xx_console_init(__drv, __inf)                      \
+static int __init s3c_serial_console_init(void)                 \
+{                                                               \
+        return s3c24xx_serial_initconsole(__drv, __inf);        \
+}                                                               \
+                                                                \
+console_initcall(s3c_serial_console_init)
+
+#else
+#define s3c24xx_console_init(drv, inf) extern void no_console(void)
+#endif
+
+#ifdef CONFIG_SERIAL_SAMSUNG_DEBUG
+
+extern void printascii(const char *);
+
+static void dbg(const char *fmt, ...)
+{
+        va_list va;
+        char buff[256];
+
+        va_start(va, fmt);
+        vsprintf(buff, fmt, va);
+        va_end(va);
+
+        printascii(buff);
+}
+
+#else
+#define dbg(x...) do { } while (0)
+#endif
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index c730d05bfeb6..54ac7bea5f8c 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -29,6 +29,7 @@
 #include <linux/spi/spi.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
+#include <linux/clk.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -250,6 +251,8 @@ struct driver_data {
         int tx_dma_needs_unmap;
         size_t tx_map_len;
         u32 dummy_dma_buf ____cacheline_aligned;
+
+        struct clk *clk;
 };
 
 /* Runtime state */
@@ -855,15 +858,15 @@ static irqreturn_t spi_int(int irq, void *dev_id)
         return drv_data->transfer_handler(drv_data);
 }
 
-static inline u32 spi_speed_hz(u32 data_rate)
+static inline u32 spi_speed_hz(struct driver_data *drv_data, u32 data_rate)
 {
-        return imx_get_perclk2() / (4 << ((data_rate) >> 13));
+        return clk_get_rate(drv_data->clk) / (4 << ((data_rate) >> 13));
 }
 
-static u32 spi_data_rate(u32 speed_hz)
+static u32 spi_data_rate(struct driver_data *drv_data, u32 speed_hz)
 {
         u32 div;
-        u32 quantized_hz = imx_get_perclk2() >> 2;
+        u32 quantized_hz = clk_get_rate(drv_data->clk) >> 2;
 
         for (div = SPI_PERCLK2_DIV_MIN;
                 div <= SPI_PERCLK2_DIV_MAX;
@@ -947,7 +950,7 @@ static void pump_transfers(unsigned long data)
         tmp = transfer->speed_hz;
         if (tmp == 0)
                 tmp = chip->max_speed_hz;
-        tmp = spi_data_rate(tmp);
+        tmp = spi_data_rate(drv_data, tmp);
         u32_EDIT(control, SPI_CONTROL_DATARATE, tmp);
 
         writel(control, regs + SPI_CONTROL);
@@ -1109,7 +1112,7 @@ static int transfer(struct spi_device *spi, struct spi_message *msg)
         msg->actual_length = 0;
 
         /* Per transfer setup check */
-        min_speed_hz = spi_speed_hz(SPI_CONTROL_DATARATE_MIN);
+        min_speed_hz = spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN);
         max_speed_hz = spi->max_speed_hz;
         list_for_each_entry(trans, &msg->transfers, transfer_list) {
                 tmp = trans->bits_per_word;
@@ -1176,6 +1179,7 @@ msg_rejected:
    applied and notified to the calling driver. */
 static int setup(struct spi_device *spi)
 {
+        struct driver_data *drv_data = spi_master_get_devdata(spi->master);
         struct spi_imx_chip *chip_info;
         struct chip_data *chip;
         int first_setup = 0;
@@ -1304,14 +1308,14 @@ static int setup(struct spi_device *spi)
         chip->n_bytes = (tmp <= 8) ? 1 : 2;
 
         /* SPI datarate */
-        tmp = spi_data_rate(spi->max_speed_hz);
+        tmp = spi_data_rate(drv_data, spi->max_speed_hz);
         if (tmp == SPI_CONTROL_DATARATE_BAD) {
                 status = -EINVAL;
                 dev_err(&spi->dev,
                         "setup - "
                         "HW min speed (%d Hz) exceeds required "
                         "max speed (%d Hz)\n",
-                        spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
+                        spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN),
                         spi->max_speed_hz);
                 if (first_setup)
                         goto err_first_setup;
@@ -1321,7 +1325,7 @@ static int setup(struct spi_device *spi)
         } else {
                 u32_EDIT(chip->control, SPI_CONTROL_DATARATE, tmp);
                 /* Actual rounded max_speed_hz */
-                tmp = spi_speed_hz(tmp);
+                tmp = spi_speed_hz(drv_data, tmp);
                 spi->max_speed_hz = tmp;
                 chip->max_speed_hz = tmp;
         }
@@ -1352,7 +1356,7 @@ static int setup(struct spi_device *spi)
                 chip->period & SPI_PERIOD_WAIT,
                 spi->mode,
                 spi->bits_per_word,
-                spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
+                spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN),
                 spi->max_speed_hz);
         return status;
 
@@ -1465,6 +1469,14 @@ static int __init spi_imx_probe(struct platform_device *pdev)
                 goto err_no_pdata;
         }
 
+        drv_data->clk = clk_get(&pdev->dev, "perclk2");
+        if (IS_ERR(drv_data->clk)) {
+                dev_err(&pdev->dev, "probe - cannot get get\n");
+                status = PTR_ERR(drv_data->clk);
+                goto err_no_clk;
+        }
+        clk_enable(drv_data->clk);
+
         /* Allocate master with space for drv_data */
         master = spi_alloc_master(dev, sizeof(struct driver_data));
         if (!master) {
@@ -1526,24 +1538,24 @@ static int __init spi_imx_probe(struct platform_device *pdev)
         drv_data->rx_channel = -1;
         if (platform_info->enable_dma) {
                 /* Get rx DMA channel */
-                status = imx_dma_request_by_prio(&drv_data->rx_channel,
-                        "spi_imx_rx", DMA_PRIO_HIGH);
-                if (status < 0) {
+                drv_data->rx_channel = imx_dma_request_by_prio("spi_imx_rx",
+                                                               DMA_PRIO_HIGH);
+                if (drv_data->rx_channel < 0) {
                         dev_err(dev,
                                 "probe - problem (%d) requesting rx channel\n",
-                                status);
+                                drv_data->rx_channel);
                         goto err_no_rxdma;
                 } else
                         imx_dma_setup_handlers(drv_data->rx_channel, NULL,
                                                 dma_err_handler, drv_data);
 
                 /* Get tx DMA channel */
-                status = imx_dma_request_by_prio(&drv_data->tx_channel,
-                                                "spi_imx_tx", DMA_PRIO_MEDIUM);
-                if (status < 0) {
+                drv_data->tx_channel = imx_dma_request_by_prio("spi_imx_tx",
+                                                               DMA_PRIO_MEDIUM);
+                if (drv_data->tx_channel < 0) {
                         dev_err(dev,
                                 "probe - problem (%d) requesting tx channel\n",
-                                status);
+                                drv_data->tx_channel);
                         imx_dma_free(drv_data->rx_channel);
                         goto err_no_txdma;
                 } else
@@ -1623,6 +1635,9 @@ err_no_iores:
         spi_master_put(master);
 
 err_no_pdata:
+        clk_disable(drv_data->clk);
+        clk_put(drv_data->clk);
+err_no_clk:
 err_no_mem:
         return status;
 }
@@ -1662,6 +1677,9 @@ static int __exit spi_imx_remove(struct platform_device *pdev)
         if (irq >= 0)
                 free_irq(irq, drv_data);
 
+        clk_disable(drv_data->clk);
+        clk_put(drv_data->clk);
+
         /* Release map resources */
         iounmap(drv_data->regs);
         release_resource(drv_data->ioarea);
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index 4b628526df09..a86e952ed4ca 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -12,3 +12,12 @@ menuconfig THERMAL
           cooling devices.
           All platforms with ACPI thermal support can use this driver.
           If you want this support, you should say Y or M here.
+
+config THERMAL_HWMON
+        bool "Hardware monitoring support"
+        depends on HWMON=y || HWMON=THERMAL
+        help
+          The generic thermal sysfs driver's hardware monitoring support
+          requires a 2.10.7/3.0.2 or later lm-sensors userspace.
+
+          Say Y if your user-space is new enough.
diff --git a/drivers/thermal/thermal_sys.c b/drivers/thermal/thermal_sys.c
index 6098787341f3..fe07462d5947 100644
--- a/drivers/thermal/thermal_sys.c
+++ b/drivers/thermal/thermal_sys.c
@@ -295,8 +295,8 @@ thermal_cooling_device_trip_point_show(struct device *dev,
 
 /* Device management */
 
-#if defined(CONFIG_HWMON) ||    \
-        (defined(CONFIG_HWMON_MODULE) && defined(CONFIG_THERMAL_MODULE))
+#if defined(CONFIG_THERMAL_HWMON)
+
 /* hwmon sys I/F */
 #include <linux/hwmon.h>
 static LIST_HEAD(thermal_hwmon_list);
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 63c34043b4d9..c3201affa0b6 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1125,9 +1125,6 @@ static void stop_data_traffic(struct acm *acm)
         for (i = 0; i < acm->rx_buflimit; i++)
                 usb_kill_urb(acm->ru[i].urb);
 
-        INIT_LIST_HEAD(&acm->filled_read_bufs);
-        INIT_LIST_HEAD(&acm->spare_read_bufs);
-
         tasklet_enable(&acm->urb_task);
 
         cancel_work_sync(&acm->work);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 09a53e7f3327..7158dbb6e4b4 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1684,19 +1684,30 @@ EXPORT_SYMBOL_GPL(usb_bus_start_enum);
 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
 {
         struct usb_hcd          *hcd = __hcd;
-        int                     start = hcd->state;
+        unsigned long           flags;
+        irqreturn_t             rc;
 
-        if (unlikely(start == HC_STATE_HALT ||
-            !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
-                return IRQ_NONE;
-        if (hcd->driver->irq (hcd) == IRQ_NONE)
-                return IRQ_NONE;
+        /* IRQF_DISABLED doesn't work correctly with shared IRQs
+         * when the first handler doesn't use it.  So let's just
+         * assume it's never used.
+         */
+        local_irq_save(flags);
 
-        set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+        if (unlikely(hcd->state == HC_STATE_HALT ||
+                     !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
+                rc = IRQ_NONE;
+        } else if (hcd->driver->irq(hcd) == IRQ_NONE) {
+                rc = IRQ_NONE;
+        } else {
+                set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 
-        if (unlikely(hcd->state == HC_STATE_HALT))
-                usb_hc_died (hcd);
-        return IRQ_HANDLED;
+                if (unlikely(hcd->state == HC_STATE_HALT))
+                        usb_hc_died(hcd);
+                rc = IRQ_HANDLED;
+        }
+
+        local_irq_restore(flags);
+        return rc;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1860,6 +1871,13 @@ int usb_add_hcd(struct usb_hcd *hcd,
 
         /* enable irqs just before we start the controller */
         if (hcd->driver->irq) {
+
+                /* IRQF_DISABLED doesn't work as advertised when used together
+                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
+                 * interrupts we can remove it here.
+                 */
+                irqflags &= ~IRQF_DISABLED;
+
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 94789be54ca3..512d2d57d41e 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -713,18 +713,11 @@ static void hub_restart(struct usb_hub *hub, int type)
                 }
 
                 /* Was the power session lost while we were suspended? */
-                switch (type) {
-                case HUB_RESET_RESUME:
-                        portstatus = 0;
-                        portchange = USB_PORT_STAT_C_CONNECTION;
-                        break;
+                status = hub_port_status(hub, port1, &portstatus, &portchange);
 
-                case HUB_RESET:
-                case HUB_RESUME:
-                        status = hub_port_status(hub, port1,
-                                        &portstatus, &portchange);
-                        break;
-                }
+                /* If the device is gone, khubd will handle it later */
+                if (status == 0 && !(portstatus & USB_PORT_STAT_CONNECTION))
+                        continue;
 
                 /* For "USB_PERSIST"-enabled children we must
                  * mark the child device for reset-resume and
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 13dcec30457e..d6bab0d5f453 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -118,10 +118,10 @@ config USB_AMD5536UDC
 config USB_GADGET_ATMEL_USBA
         boolean "Atmel USBA"
         select USB_GADGET_DUALSPEED
-        depends on AVR32 || ARCH_AT91CAP9
+        depends on AVR32 || ARCH_AT91CAP9 || ARCH_AT91SAM9RL
         help
           USBA is the integrated high-speed USB Device controller on
-          the AT32AP700x and AT91CAP9 processors from Atmel.
+          the AT32AP700x, some AT91SAM9 and AT91CAP9 processors from Atmel.
 
 config USB_ATMEL_USBA
         tristate
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 274c60a970cd..b6b2a0a5ba37 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -888,7 +888,7 @@ static void pullup(struct at91_udc *udc, int is_on)
                 at91_udp_write(udc, AT91_UDP_TXVC, 0);
                 if (cpu_is_at91rm9200())
                         gpio_set_value(udc->board.pullup_pin, active);
-                else if (cpu_is_at91sam9260() || cpu_is_at91sam9263()) {
+                else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
                         u32     txvc = at91_udp_read(udc, AT91_UDP_TXVC);
 
                         txvc |= AT91_UDP_TXVC_PUON;
@@ -906,7 +906,7 @@ static void pullup(struct at91_udc *udc, int is_on)
                 at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
                 if (cpu_is_at91rm9200())
                         gpio_set_value(udc->board.pullup_pin, !active);
-                else if (cpu_is_at91sam9260() || cpu_is_at91sam9263()) {
+                else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
                         u32     txvc = at91_udp_read(udc, AT91_UDP_TXVC);
 
                         txvc &= ~AT91_UDP_TXVC_PUON;
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 881d74c3d964..03a7f49d207d 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -135,13 +135,17 @@ static void use_ep(struct omap_ep *ep, u16 select)
 
         if (ep->bEndpointAddress & USB_DIR_IN)
                 num |= UDC_EP_DIR;
-        UDC_EP_NUM_REG = num | select;
+        omap_writew(num | select, UDC_EP_NUM);
         /* when select, MUST deselect later !! */
 }
 
 static inline void deselect_ep(void)
 {
-        UDC_EP_NUM_REG &= ~UDC_EP_SEL;
+        u16 w;
+
+        w = omap_readw(UDC_EP_NUM);
+        w &= ~UDC_EP_SEL;
+        omap_writew(w, UDC_EP_NUM);
         /* 6 wait states before TX will happen */
 }
 
@@ -216,7 +220,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
         ep->has_dma = 0;
         ep->lch = -1;
         use_ep(ep, UDC_EP_SEL);
-        UDC_CTRL_REG = udc->clr_halt;
+        omap_writew(udc->clr_halt, UDC_CTRL);
         ep->ackwait = 0;
         deselect_ep();
 
@@ -232,7 +236,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
         if (desc->bmAttributes != USB_ENDPOINT_XFER_ISOC
                         && !ep->has_dma
                         && !(ep->bEndpointAddress & USB_DIR_IN)) {
-                UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                 ep->ackwait = 1 + ep->double_buf;
         }
 
@@ -259,7 +263,7 @@ static int omap_ep_disable(struct usb_ep *_ep)
         nuke (ep, -ESHUTDOWN);
         ep->ep.maxpacket = ep->maxpacket;
         ep->has_dma = 0;
-        UDC_CTRL_REG = UDC_SET_HALT;
+        omap_writew(UDC_SET_HALT, UDC_CTRL);
         list_del_init(&ep->iso);
         del_timer(&ep->timer);
 
@@ -360,13 +364,13 @@ write_packet(u8 *buf, struct omap_req *req, unsigned max)
         if (likely((((int)buf) & 1) == 0)) {
                 wp = (u16 *)buf;
                 while (max >= 2) {
-                        UDC_DATA_REG = *wp++;
+                        omap_writew(*wp++, UDC_DATA);
                         max -= 2;
                 }
                 buf = (u8 *)wp;
         }
         while (max--)
-                *(volatile u8 *)&UDC_DATA_REG = *buf++;
+                omap_writeb(*buf++, UDC_DATA);
         return len;
 }
 
@@ -385,13 +389,13 @@ static int write_fifo(struct omap_ep *ep, struct omap_req *req)
         prefetch(buf);
 
         /* PIO-IN isn't double buffered except for iso */
-        ep_stat = UDC_STAT_FLG_REG;
+        ep_stat = omap_readw(UDC_STAT_FLG);
         if (ep_stat & UDC_FIFO_UNWRITABLE)
                 return 0;
 
         count = ep->ep.maxpacket;
         count = write_packet(buf, req, count);
-        UDC_CTRL_REG = UDC_SET_FIFO_EN;
+        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
         ep->ackwait = 1;
 
         /* last packet is often short (sometimes a zlp) */
@@ -425,13 +429,13 @@ read_packet(u8 *buf, struct omap_req *req, unsigned avail)
         if (likely((((int)buf) & 1) == 0)) {
                 wp = (u16 *)buf;
                 while (avail >= 2) {
-                        *wp++ = UDC_DATA_REG;
+                        *wp++ = omap_readw(UDC_DATA);
                         avail -= 2;
                 }
                 buf = (u8 *)wp;
         }
         while (avail--)
-                *buf++ = *(volatile u8 *)&UDC_DATA_REG;
+                *buf++ = omap_readb(UDC_DATA);
         return len;
 }
 
@@ -446,7 +450,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
         prefetchw(buf);
 
         for (;;) {
-                u16     ep_stat = UDC_STAT_FLG_REG;
+                u16     ep_stat = omap_readw(UDC_STAT_FLG);
 
                 is_last = 0;
                 if (ep_stat & FIFO_EMPTY) {
@@ -460,7 +464,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
                 if (ep_stat & UDC_FIFO_FULL)
                         avail = ep->ep.maxpacket;
                 else  {
-                        avail = UDC_RXFSTAT_REG;
+                        avail = omap_readw(UDC_RXFSTAT);
                         ep->fnf = ep->double_buf;
                 }
                 count = read_packet(buf, req, avail);
@@ -473,7 +477,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
                                 req->req.status = -EOVERFLOW;
                                 avail -= count;
                                 while (avail--)
-                                        (void) *(volatile u8 *)&UDC_DATA_REG;
+                                        omap_readw(UDC_DATA);
                         }
                 } else if (req->req.length == req->req.actual)
                         is_last = 1;
@@ -491,32 +495,6 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
 
 /*-------------------------------------------------------------------------*/
 
-static inline dma_addr_t dma_csac(unsigned lch)
-{
-        dma_addr_t      csac;
-
-        /* omap 3.2/3.3 erratum: sometimes 0 is returned if CSAC/CDAC is
-         * read before the DMA controller finished disabling the channel.
-         */
-        csac = OMAP_DMA_CSAC_REG(lch);
-        if (csac == 0)
-                csac = OMAP_DMA_CSAC_REG(lch);
-        return csac;
-}
-
-static inline dma_addr_t dma_cdac(unsigned lch)
-{
-        dma_addr_t      cdac;
-
-        /* omap 3.2/3.3 erratum: sometimes 0 is returned if CSAC/CDAC is
-         * read before the DMA controller finished disabling the channel.
-         */
-        cdac = OMAP_DMA_CDAC_REG(lch);
-        if (cdac == 0)
-                cdac = OMAP_DMA_CDAC_REG(lch);
-        return cdac;
-}
-
 static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
 {
         dma_addr_t      end;
@@ -527,7 +505,7 @@ static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
         if (cpu_is_omap15xx())
                 return 0;
 
-        end = dma_csac(ep->lch);
+        end = omap_get_dma_src_pos(ep->lch);
         if (end == ep->dma_counter)
                 return 0;
 
@@ -537,15 +515,11 @@ static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
         return end - start;
 }
 
-#define DMA_DEST_LAST(x) (cpu_is_omap15xx() \
-                ? OMAP_DMA_CSAC_REG(x) /* really: CPC */ \
-                : dma_cdac(x))
-
 static u16 dma_dest_len(struct omap_ep *ep, dma_addr_t start)
 {
         dma_addr_t      end;
 
-        end = DMA_DEST_LAST(ep->lch);
+        end = omap_get_dma_dst_pos(ep->lch);
         if (end == ep->dma_counter)
                 return 0;
 
@@ -565,7 +539,7 @@ static u16 dma_dest_len(struct omap_ep *ep, dma_addr_t start)
 
 static void next_in_dma(struct omap_ep *ep, struct omap_req *req)
 {
-        u16             txdma_ctrl;
+        u16             txdma_ctrl, w;
         unsigned        length = req->req.length - req->req.actual;
         const int       sync_mode = cpu_is_omap15xx()
                                 ? OMAP_DMA_SYNC_FRAME
@@ -596,14 +570,18 @@ static void next_in_dma(struct omap_ep *ep, struct omap_req *req)
                 0, 0);
 
         omap_start_dma(ep->lch);
-        ep->dma_counter = dma_csac(ep->lch);
-        UDC_DMA_IRQ_EN_REG |= UDC_TX_DONE_IE(ep->dma_channel);
-        UDC_TXDMA_REG(ep->dma_channel) = UDC_TXN_START | txdma_ctrl;
+        ep->dma_counter = omap_get_dma_src_pos(ep->lch);
+        w = omap_readw(UDC_DMA_IRQ_EN);
+        w |= UDC_TX_DONE_IE(ep->dma_channel);
+        omap_writew(w, UDC_DMA_IRQ_EN);
+        omap_writew(UDC_TXN_START | txdma_ctrl, UDC_TXDMA(ep->dma_channel));
         req->dma_bytes = length;
 }
 
 static void finish_in_dma(struct omap_ep *ep, struct omap_req *req, int status)
 {
+        u16 w;
+
         if (status == 0) {
                 req->req.actual += req->dma_bytes;
 
@@ -620,7 +598,9 @@ static void finish_in_dma(struct omap_ep *ep, struct omap_req *req, int status)
 
         /* tx completion */
         omap_stop_dma(ep->lch);
-        UDC_DMA_IRQ_EN_REG &= ~UDC_TX_DONE_IE(ep->dma_channel);
+        w = omap_readw(UDC_DMA_IRQ_EN);
+        w &= ~UDC_TX_DONE_IE(ep->dma_channel);
+        omap_writew(w, UDC_DMA_IRQ_EN);
         done(ep, req, status);
 }
 
@@ -628,6 +608,7 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
 {
         unsigned packets = req->req.length - req->req.actual;
         int dma_trigger = 0;
+        u16 w;
 
         if (cpu_is_omap24xx())
                 dma_trigger = OMAP24XX_DMA(USB_W2FC_RX0, ep->dma_channel);
@@ -654,12 +635,14 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
         omap_set_dma_dest_params(ep->lch, OMAP_DMA_PORT_EMIFF,
                 OMAP_DMA_AMODE_POST_INC, req->req.dma + req->req.actual,
                 0, 0);
-        ep->dma_counter = DMA_DEST_LAST(ep->lch);
+        ep->dma_counter = omap_get_dma_dst_pos(ep->lch);
 
-        UDC_RXDMA_REG(ep->dma_channel) = UDC_RXN_STOP | (packets - 1);
-        UDC_DMA_IRQ_EN_REG |= UDC_RX_EOT_IE(ep->dma_channel);
-        UDC_EP_NUM_REG = (ep->bEndpointAddress & 0xf);
-        UDC_CTRL_REG = UDC_SET_FIFO_EN;
+        omap_writew(UDC_RXN_STOP | (packets - 1), UDC_RXDMA(ep->dma_channel));
+        w = omap_readw(UDC_DMA_IRQ_EN);
+        w |= UDC_RX_EOT_IE(ep->dma_channel);
+        omap_writew(w, UDC_DMA_IRQ_EN);
+        omap_writew(ep->bEndpointAddress & 0xf, UDC_EP_NUM);
+        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
 
         omap_start_dma(ep->lch);
 }
@@ -667,7 +650,7 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
 static void
 finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status, int one)
 {
-        u16     count;
+        u16     count, w;
 
         if (status == 0)
                 ep->dma_counter = (u16) (req->req.dma + req->req.actual);
@@ -686,13 +669,15 @@ finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status, int one)
                 return;
 
         /* rx completion */
-        UDC_DMA_IRQ_EN_REG &= ~UDC_RX_EOT_IE(ep->dma_channel);
+        w = omap_readw(UDC_DMA_IRQ_EN);
+        w &= ~UDC_RX_EOT_IE(ep->dma_channel);
+        omap_writew(w, UDC_DMA_IRQ_EN);
         done(ep, req, status);
 }
 
 static void dma_irq(struct omap_udc *udc, u16 irq_src)
 {
-        u16             dman_stat = UDC_DMAN_STAT_REG;
+        u16             dman_stat = omap_readw(UDC_DMAN_STAT);
         struct omap_ep  *ep;
         struct omap_req *req;
 
@@ -706,7 +691,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
                                                 struct omap_req, queue);
                         finish_in_dma(ep, req, 0);
                 }
-                UDC_IRQ_SRC_REG = UDC_TXN_DONE;
+                omap_writew(UDC_TXN_DONE, UDC_IRQ_SRC);
 
                 if (!list_empty (&ep->queue)) {
                         req = container_of(ep->queue.next,
@@ -725,7 +710,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
                                         struct omap_req, queue);
                         finish_out_dma(ep, req, 0, dman_stat & UDC_DMA_RX_SB);
                 }
-                UDC_IRQ_SRC_REG = UDC_RXN_EOT;
+                omap_writew(UDC_RXN_EOT, UDC_IRQ_SRC);
 
                 if (!list_empty (&ep->queue)) {
                         req = container_of(ep->queue.next,
@@ -739,7 +724,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
                 ep->irqs++;
                 /* omap15xx does this unasked... */
                 VDBG("%s, RX_CNT irq?\n", ep->ep.name);
-                UDC_IRQ_SRC_REG = UDC_RXN_CNT;
+                omap_writew(UDC_RXN_CNT, UDC_IRQ_SRC);
         }
 }
 
@@ -762,9 +747,9 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
 
         is_in = ep->bEndpointAddress & USB_DIR_IN;
         if (is_in)
-                reg = UDC_TXDMA_CFG_REG;
+                reg = omap_readw(UDC_TXDMA_CFG);
         else
-                reg = UDC_RXDMA_CFG_REG;
+                reg = omap_readw(UDC_RXDMA_CFG);
         reg |= UDC_DMA_REQ;             /* "pulse" activated */
 
         ep->dma_channel = 0;
@@ -792,7 +777,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
                 status = omap_request_dma(dma_channel,
                         ep->ep.name, dma_error, ep, &ep->lch);
                 if (status == 0) {
-                        UDC_TXDMA_CFG_REG = reg;
+                        omap_writew(reg, UDC_TXDMA_CFG);
                         /* EMIFF or SDRC */
                         omap_set_dma_src_burst_mode(ep->lch,
                                                 OMAP_DMA_DATA_BURST_4);
@@ -801,7 +786,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
                         omap_set_dma_dest_params(ep->lch,
                                 OMAP_DMA_PORT_TIPB,
                                 OMAP_DMA_AMODE_CONSTANT,
-                                (unsigned long) io_v2p((u32)&UDC_DATA_DMA_REG),
+                                (unsigned long) io_v2p(UDC_DATA_DMA),
                                 0, 0);
                 }
         } else {
@@ -813,12 +798,12 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
                 status = omap_request_dma(dma_channel,
                         ep->ep.name, dma_error, ep, &ep->lch);
                 if (status == 0) {
-                        UDC_RXDMA_CFG_REG = reg;
+                        omap_writew(reg, UDC_RXDMA_CFG);
                         /* TIPB */
                         omap_set_dma_src_params(ep->lch,
                                 OMAP_DMA_PORT_TIPB,
                                 OMAP_DMA_AMODE_CONSTANT,
-                                (unsigned long) io_v2p((u32)&UDC_DATA_DMA_REG),
+                                (unsigned long) io_v2p(UDC_DATA_DMA),
                                 0, 0);
                         /* EMIFF or SDRC */
                         omap_set_dma_dest_burst_mode(ep->lch,
@@ -834,7 +819,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
 
                 /* channel type P: hw synch (fifo) */
                 if (cpu_class_is_omap1() && !cpu_is_omap15xx())
-                        OMAP1_DMA_LCH_CTRL_REG(ep->lch) = 2;
+                        omap_set_dma_channel_mode(ep->lch, OMAP_DMA_LCH_P);
         }
 
 just_restart:
@@ -860,7 +845,7 @@ just_restart:
                         (is_in ? write_fifo : read_fifo)(ep, req);
                         deselect_ep();
                         if (!is_in) {
-                                UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                                 ep->ackwait = 1 + ep->double_buf;
                         }
                         /* IN: 6 wait states before it'll tx */
@@ -881,7 +866,7 @@ static void dma_channel_release(struct omap_ep *ep)
         else
                 req = NULL;
 
-        active = ((1 << 7) & OMAP_DMA_CCR_REG(ep->lch)) != 0;
+        active = omap_get_dma_active_status(ep->lch);
 
         DBG("%s release %s %cxdma%d %p\n", ep->ep.name,
                         active ? "active" : "idle",
@@ -894,23 +879,25 @@ static void dma_channel_release(struct omap_ep *ep)
 
         /* wait till current packet DMA finishes, and fifo empties */
         if (ep->bEndpointAddress & USB_DIR_IN) {
-                UDC_TXDMA_CFG_REG = (UDC_TXDMA_CFG_REG & ~mask) | UDC_DMA_REQ;
+                omap_writew((omap_readw(UDC_TXDMA_CFG) & ~mask) | UDC_DMA_REQ,
+                                        UDC_TXDMA_CFG);
 
                 if (req) {
                         finish_in_dma(ep, req, -ECONNRESET);
 
                         /* clear FIFO; hosts probably won't empty it */
                         use_ep(ep, UDC_EP_SEL);
-                        UDC_CTRL_REG = UDC_CLR_EP;
+                        omap_writew(UDC_CLR_EP, UDC_CTRL);
                         deselect_ep();
                 }
-                while (UDC_TXDMA_CFG_REG & mask)
+                while (omap_readw(UDC_TXDMA_CFG) & mask)
                         udelay(10);
         } else {
-                UDC_RXDMA_CFG_REG = (UDC_RXDMA_CFG_REG & ~mask) | UDC_DMA_REQ;
+                omap_writew((omap_readw(UDC_RXDMA_CFG) & ~mask) | UDC_DMA_REQ,
+                                        UDC_RXDMA_CFG);
 
                 /* dma empties the fifo */
-                while (UDC_RXDMA_CFG_REG & mask)
+                while (omap_readw(UDC_RXDMA_CFG) & mask)
                         udelay(10);
                 if (req)
                         finish_out_dma(ep, req, -ECONNRESET, 0);
@@ -997,9 +984,13 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         req->req.actual = 0;
 
         /* maybe kickstart non-iso i/o queues */
-        if (is_iso)
-                UDC_IRQ_EN_REG |= UDC_SOF_IE;
-        else if (list_empty(&ep->queue) && !ep->stopped && !ep->ackwait) {
+        if (is_iso) {
+                u16 w;
+
+                w = omap_readw(UDC_IRQ_EN);
+                w |= UDC_SOF_IE;
+                omap_writew(w, UDC_IRQ_EN);
+        } else if (list_empty(&ep->queue) && !ep->stopped && !ep->ackwait) {
                 int     is_in;
 
                 if (ep->bEndpointAddress == 0) {
@@ -1017,23 +1008,23 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                                  * requests to non-control endpoints
                                  */
                                 if (udc->ep0_set_config) {
-                                        u16     irq_en = UDC_IRQ_EN_REG;
+                                        u16     irq_en = omap_readw(UDC_IRQ_EN);
 
                                         irq_en |= UDC_DS_CHG_IE | UDC_EP0_IE;
                                         if (!udc->ep0_reset_config)
                                                 irq_en |= UDC_EPN_RX_IE
                                                         | UDC_EPN_TX_IE;
-                                        UDC_IRQ_EN_REG = irq_en;
+                                        omap_writew(irq_en, UDC_IRQ_EN);
                                 }
 
                                 /* STATUS for zero length DATA stages is
                                  * always an IN ... even for IN transfers,
                                  * a weird case which seem to stall OMAP.
                                  */
-                                UDC_EP_NUM_REG = (UDC_EP_SEL|UDC_EP_DIR);
-                                UDC_CTRL_REG = UDC_CLR_EP;
-                                UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                                UDC_EP_NUM_REG = UDC_EP_DIR;
+                                omap_writew(UDC_EP_SEL | UDC_EP_DIR, UDC_EP_NUM);
+                                omap_writew(UDC_CLR_EP, UDC_CTRL);
+                                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                                omap_writew(UDC_EP_DIR, UDC_EP_NUM);
 
                                 /* cleanup */
                                 udc->ep0_pending = 0;
@@ -1042,11 +1033,11 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 
                         /* non-empty DATA stage */
                         } else if (is_in) {
-                                UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
+                                omap_writew(UDC_EP_SEL | UDC_EP_DIR, UDC_EP_NUM);
                         } else {
                                 if (udc->ep0_setup)
                                         goto irq_wait;
-                                UDC_EP_NUM_REG = UDC_EP_SEL;
+                                omap_writew(UDC_EP_SEL, UDC_EP_NUM);
                         }
                 } else {
                         is_in = ep->bEndpointAddress & USB_DIR_IN;
@@ -1062,7 +1053,7 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                                 req = NULL;
                         deselect_ep();
                         if (!is_in) {
-                                UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                                 ep->ackwait = 1 + ep->double_buf;
                         }
                         /* IN: 6 wait states before it'll tx */
@@ -1130,9 +1121,9 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
                 else if (value) {
                         if (ep->udc->ep0_set_config) {
                                 WARN("error changing config?\n");
-                                UDC_SYSCON2_REG = UDC_CLR_CFG;
+                                omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
                         }
-                        UDC_SYSCON2_REG = UDC_STALL_CMD;
+                        omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
                         ep->udc->ep0_pending = 0;
                         status = 0;
                 } else /* NOP */
@@ -1159,8 +1150,8 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
                                 channel = 0;
 
                         use_ep(ep, UDC_EP_SEL);
-                        if (UDC_STAT_FLG_REG & UDC_NON_ISO_FIFO_EMPTY) {
-                                UDC_CTRL_REG = UDC_SET_HALT;
+                        if (omap_readw(UDC_STAT_FLG) & UDC_NON_ISO_FIFO_EMPTY) {
+                                omap_writew(UDC_SET_HALT, UDC_CTRL);
                                 status = 0;
                         } else
                                 status = -EAGAIN;
@@ -1170,10 +1161,10 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
                                 dma_channel_claim(ep, channel);
                 } else {
                         use_ep(ep, 0);
-                        UDC_CTRL_REG = ep->udc->clr_halt;
+                        omap_writew(ep->udc->clr_halt, UDC_CTRL);
                         ep->ackwait = 0;
                         if (!(ep->bEndpointAddress & USB_DIR_IN)) {
-                                UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                                 ep->ackwait = 1 + ep->double_buf;
                         }
                 }
@@ -1205,7 +1196,7 @@ static struct usb_ep_ops omap_ep_ops = {
 
 static int omap_get_frame(struct usb_gadget *gadget)
 {
-        u16     sof = UDC_SOF_REG;
+        u16     sof = omap_readw(UDC_SOF);
         return (sof & UDC_TS_OK) ? (sof & UDC_TS) : -EL2NSYNC;
 }
 
@@ -1224,7 +1215,7 @@ static int omap_wakeup(struct usb_gadget *gadget)
                  */
                 if (udc->devstat & (UDC_B_HNP_ENABLE|UDC_R_WK_OK)) {
                         DBG("remote wakeup...\n");
-                        UDC_SYSCON2_REG = UDC_RMT_WKP;
+                        omap_writew(UDC_RMT_WKP, UDC_SYSCON2);
                         retval = 0;
                 }
 
@@ -1247,12 +1238,12 @@ omap_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered)
 
         udc = container_of(gadget, struct omap_udc, gadget);
         spin_lock_irqsave(&udc->lock, flags);
-        syscon1 = UDC_SYSCON1_REG;
+        syscon1 = omap_readw(UDC_SYSCON1);
         if (is_selfpowered)
                 syscon1 |= UDC_SELF_PWR;
         else
                 syscon1 &= ~UDC_SELF_PWR;
-        UDC_SYSCON1_REG = syscon1;
+        omap_writew(syscon1, UDC_SYSCON1);
         spin_unlock_irqrestore(&udc->lock, flags);
 
         return 0;
@@ -1265,18 +1256,36 @@ static int can_pullup(struct omap_udc *udc)
 
 static void pullup_enable(struct omap_udc *udc)
 {
-        UDC_SYSCON1_REG |= UDC_PULLUP_EN;
-        if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx())
-                OTG_CTRL_REG |= OTG_BSESSVLD;
-        UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
+        u16 w;
+
+        w = omap_readw(UDC_SYSCON1);
+        w |= UDC_PULLUP_EN;
+        omap_writew(w, UDC_SYSCON1);
+        if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx()) {
+                u32 l;
+
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_BSESSVLD;
+                omap_writel(l, OTG_CTRL);
+        }
+        omap_writew(UDC_DS_CHG_IE, UDC_IRQ_EN);
 }
 
 static void pullup_disable(struct omap_udc *udc)
 {
-        if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx())
-                OTG_CTRL_REG &= ~OTG_BSESSVLD;
-        UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
-        UDC_SYSCON1_REG &= ~UDC_PULLUP_EN;
+        u16 w;
+
+        if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx()) {
+                u32 l;
+
+                l = omap_readl(OTG_CTRL);
+                l &= ~OTG_BSESSVLD;
+                omap_writel(l, OTG_CTRL);
+        }
+        omap_writew(UDC_DS_CHG_IE, UDC_IRQ_EN);
+        w = omap_readw(UDC_SYSCON1);
+        w &= ~UDC_PULLUP_EN;
+        omap_writew(w, UDC_SYSCON1);
 }
 
 static struct omap_udc *udc;
@@ -1304,6 +1313,7 @@ static int omap_vbus_session(struct usb_gadget *gadget, int is_active)
 {
         struct omap_udc *udc;
         unsigned long   flags;
+        u32 l;
 
         udc = container_of(gadget, struct omap_udc, gadget);
         spin_lock_irqsave(&udc->lock, flags);
@@ -1311,10 +1321,12 @@ static int omap_vbus_session(struct usb_gadget *gadget, int is_active)
         udc->vbus_active = (is_active != 0);
         if (cpu_is_omap15xx()) {
                 /* "software" detect, ignored if !VBUS_MODE_1510 */
+                l = omap_readl(FUNC_MUX_CTRL_0);
                 if (is_active)
-                        FUNC_MUX_CTRL_0_REG |= VBUS_CTRL_1510;
+                        l |= VBUS_CTRL_1510;
                 else
-                        FUNC_MUX_CTRL_0_REG &= ~VBUS_CTRL_1510;
+                        l &= ~VBUS_CTRL_1510;
+                omap_writel(l, FUNC_MUX_CTRL_0);
         }
         if (udc->dc_clk != NULL && is_active) {
                 if (!udc->clk_requested) {
@@ -1384,9 +1396,9 @@ static void nuke(struct omap_ep *ep, int status)
                 dma_channel_release(ep);
 
         use_ep(ep, 0);
-        UDC_CTRL_REG = UDC_CLR_EP;
+        omap_writew(UDC_CLR_EP, UDC_CTRL);
         if (ep->bEndpointAddress && ep->bmAttributes != USB_ENDPOINT_XFER_ISOC)
-                UDC_CTRL_REG = UDC_SET_HALT;
+                omap_writew(UDC_SET_HALT, UDC_CTRL);
 
         while (!list_empty(&ep->queue)) {
                 req = list_entry(ep->queue.next, struct omap_req, queue);
@@ -1414,8 +1426,8 @@ static void update_otg(struct omap_udc *udc)
         if (!gadget_is_otg(&udc->gadget))
                 return;
 
-        if (OTG_CTRL_REG & OTG_ID)
-                devstat = UDC_DEVSTAT_REG;
+        if (omap_readl(OTG_CTRL) & OTG_ID)
+                devstat = omap_readw(UDC_DEVSTAT);
         else
                 devstat = 0;
 
@@ -1426,9 +1438,14 @@ static void update_otg(struct omap_udc *udc)
         /* Enable HNP early, avoiding races on suspend irq path.
          * ASSUMES OTG state machine B_BUS_REQ input is true.
          */
-        if (udc->gadget.b_hnp_enable)
-                OTG_CTRL_REG = (OTG_CTRL_REG | OTG_B_HNPEN | OTG_B_BUSREQ)
-                                & ~OTG_PULLUP;
+        if (udc->gadget.b_hnp_enable) {
+                u32 l;
+
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_B_HNPEN | OTG_B_BUSREQ;
+                l &= ~OTG_PULLUP;
+                omap_writel(l, OTG_CTRL);
+        }
 }
 
 static void ep0_irq(struct omap_udc *udc, u16 irq_src)
@@ -1446,7 +1463,7 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
 
                 nuke(ep0, 0);
                 if (ack) {
-                        UDC_IRQ_SRC_REG = ack;
+                        omap_writew(ack, UDC_IRQ_SRC);
                         irq_src = UDC_SETUP;
                 }
         }
@@ -1466,9 +1483,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
         if (irq_src & UDC_EP0_TX) {
                 int     stat;
 
-                UDC_IRQ_SRC_REG = UDC_EP0_TX;
-                UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
-                stat = UDC_STAT_FLG_REG;
+                omap_writew(UDC_EP0_TX, UDC_IRQ_SRC);
+                omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
+                stat = omap_readw(UDC_STAT_FLG);
                 if (stat & UDC_ACK) {
                         if (udc->ep0_in) {
                                 /* write next IN packet from response,
@@ -1476,26 +1493,26 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                                  */
                                 if (req)
                                         stat = write_fifo(ep0, req);
-                                UDC_EP_NUM_REG = UDC_EP_DIR;
+                                omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                                 if (!req && udc->ep0_pending) {
-                                        UDC_EP_NUM_REG = UDC_EP_SEL;
-                                        UDC_CTRL_REG = UDC_CLR_EP;
-                                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                                        UDC_EP_NUM_REG = 0;
+                                        omap_writew(UDC_EP_SEL, UDC_EP_NUM);
+                                        omap_writew(UDC_CLR_EP, UDC_CTRL);
+                                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                                        omap_writew(0, UDC_EP_NUM);
                                         udc->ep0_pending = 0;
                                 } /* else:  6 wait states before it'll tx */
                         } else {
                                 /* ack status stage of OUT transfer */
-                                UDC_EP_NUM_REG = UDC_EP_DIR;
+                                omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                                 if (req)
                                         done(ep0, req, 0);
                         }
                         req = NULL;
                 } else if (stat & UDC_STALL) {
-                        UDC_CTRL_REG = UDC_CLR_HALT;
-                        UDC_EP_NUM_REG = UDC_EP_DIR;
+                        omap_writew(UDC_CLR_HALT, UDC_CTRL);
+                        omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                 } else {
-                        UDC_EP_NUM_REG = UDC_EP_DIR;
+                        omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                 }
         }
 
@@ -1503,9 +1520,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
         if (irq_src & UDC_EP0_RX) {
                 int     stat;
 
-                UDC_IRQ_SRC_REG = UDC_EP0_RX;
-                UDC_EP_NUM_REG = UDC_EP_SEL;
-                stat = UDC_STAT_FLG_REG;
+                omap_writew(UDC_EP0_RX, UDC_IRQ_SRC);
+                omap_writew(UDC_EP_SEL, UDC_EP_NUM);
+                stat = omap_readw(UDC_STAT_FLG);
                 if (stat & UDC_ACK) {
                         if (!udc->ep0_in) {
                                 stat = 0;
@@ -1513,34 +1530,35 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                                  * reactiviting the fifo; stall on errors.
                                  */
                                 if (!req || (stat = read_fifo(ep0, req)) < 0) {
-                                        UDC_SYSCON2_REG = UDC_STALL_CMD;
+                                        omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
                                         udc->ep0_pending = 0;
                                         stat = 0;
                                 } else if (stat == 0)
-                                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                                UDC_EP_NUM_REG = 0;
+                                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                                omap_writew(0, UDC_EP_NUM);
 
                                 /* activate status stage */
                                 if (stat == 1) {
                                         done(ep0, req, 0);
                                         /* that may have STALLed ep0... */
-                                        UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
-                                        UDC_CTRL_REG = UDC_CLR_EP;
-                                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                                        UDC_EP_NUM_REG = UDC_EP_DIR;
+                                        omap_writew(UDC_EP_SEL | UDC_EP_DIR,
+                                                        UDC_EP_NUM);
+                                        omap_writew(UDC_CLR_EP, UDC_CTRL);
+                                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                                        omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                                         udc->ep0_pending = 0;
                                 }
                         } else {
                                 /* ack status stage of IN transfer */
-                                UDC_EP_NUM_REG = 0;
+                                omap_writew(0, UDC_EP_NUM);
                                 if (req)
                                         done(ep0, req, 0);
                         }
                 } else if (stat & UDC_STALL) {
-                        UDC_CTRL_REG = UDC_CLR_HALT;
-                        UDC_EP_NUM_REG = 0;
+                        omap_writew(UDC_CLR_HALT, UDC_CTRL);
+                        omap_writew(0, UDC_EP_NUM);
                 } else {
-                        UDC_EP_NUM_REG = 0;
+                        omap_writew(0, UDC_EP_NUM);
                 }
         }
 
@@ -1555,14 +1573,14 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
 
                 /* read the (latest) SETUP message */
                 do {
-                        UDC_EP_NUM_REG = UDC_SETUP_SEL;
+                        omap_writew(UDC_SETUP_SEL, UDC_EP_NUM);
                         /* two bytes at a time */
-                        u.word[0] = UDC_DATA_REG;
-                        u.word[1] = UDC_DATA_REG;
-                        u.word[2] = UDC_DATA_REG;
-                        u.word[3] = UDC_DATA_REG;
-                        UDC_EP_NUM_REG = 0;
-                } while (UDC_IRQ_SRC_REG & UDC_SETUP);
+                        u.word[0] = omap_readw(UDC_DATA);
+                        u.word[1] = omap_readw(UDC_DATA);
+                        u.word[2] = omap_readw(UDC_DATA);
+                        u.word[3] = omap_readw(UDC_DATA);
+                        omap_writew(0, UDC_EP_NUM);
+                } while (omap_readw(UDC_IRQ_SRC) & UDC_SETUP);
 
 #define w_value         le16_to_cpu(u.r.wValue)
 #define w_index         le16_to_cpu(u.r.wIndex)
@@ -1593,9 +1611,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                          * later if it fails the request.
                          */
                         if (udc->ep0_reset_config)
-                                UDC_SYSCON2_REG = UDC_CLR_CFG;
+                                omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
                         else
-                                UDC_SYSCON2_REG = UDC_DEV_CFG;
+                                omap_writew(UDC_DEV_CFG, UDC_SYSCON2);
                         update_otg(udc);
                         goto delegate;
                 case USB_REQ_CLEAR_FEATURE:
@@ -1613,10 +1631,10 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                                                 || !ep->desc)
                                         goto do_stall;
                                 use_ep(ep, 0);
-                                UDC_CTRL_REG = udc->clr_halt;
+                                omap_writew(udc->clr_halt, UDC_CTRL);
                                 ep->ackwait = 0;
                                 if (!(ep->bEndpointAddress & USB_DIR_IN)) {
-                                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                                         ep->ackwait = 1 + ep->double_buf;
                                 }
                                 /* NOTE:  assumes the host behaves sanely,
@@ -1649,15 +1667,15 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
                         }
                         use_ep(ep, 0);
                         /* can't halt if fifo isn't empty... */
-                        UDC_CTRL_REG = UDC_CLR_EP;
-                        UDC_CTRL_REG = UDC_SET_HALT;
+                        omap_writew(UDC_CLR_EP, UDC_CTRL);
+                        omap_writew(UDC_SET_HALT, UDC_CTRL);
                         VDBG("%s halted by host\n", ep->name);
 ep0out_status_stage:
                         status = 0;
-                        UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
-                        UDC_CTRL_REG = UDC_CLR_EP;
-                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                        UDC_EP_NUM_REG = UDC_EP_DIR;
+                        omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
+                        omap_writew(UDC_CLR_EP, UDC_CTRL);
+                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                        omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                         udc->ep0_pending = 0;
                         break;
                 case USB_REQ_GET_STATUS:
@@ -1694,10 +1712,10 @@ intf_status:
 
 zero_status:
                         /* return two zero bytes */
-                        UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
-                        UDC_DATA_REG = 0;
-                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
-                        UDC_EP_NUM_REG = UDC_EP_DIR;
+                        omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
+                        omap_writew(0, UDC_DATA);
+                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+                        omap_writew(UDC_EP_DIR, UDC_EP_NUM);
                         status = 0;
                         VDBG("GET_STATUS, interface %d\n", w_index);
                         /* next, status stage */
@@ -1706,8 +1724,8 @@ zero_status:
 delegate:
                         /* activate the ep0out fifo right away */
                         if (!udc->ep0_in && w_length) {
-                                UDC_EP_NUM_REG = 0;
-                                UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                                omap_writew(0, UDC_EP_NUM);
+                                omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                         }
 
                         /* gadget drivers see class/vendor specific requests,
@@ -1748,9 +1766,9 @@ do_stall:
                                 if (udc->ep0_reset_config)
                                         WARN("error resetting config?\n");
                                 else
-                                        UDC_SYSCON2_REG = UDC_CLR_CFG;
+                                        omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
                         }
-                        UDC_SYSCON2_REG = UDC_STALL_CMD;
+                        omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
                         udc->ep0_pending = 0;
                 }
         }
@@ -1764,7 +1782,7 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
 {
         u16     devstat, change;
 
-        devstat = UDC_DEVSTAT_REG;
+        devstat = omap_readw(UDC_DEVSTAT);
         change = devstat ^ udc->devstat;
         udc->devstat = devstat;
 
@@ -1804,7 +1822,8 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
                                 INFO("USB reset done, gadget %s\n",
                                         udc->driver->driver.name);
                                 /* ep0 traffic is legal from now on */
-                                UDC_IRQ_EN_REG = UDC_DS_CHG_IE | UDC_EP0_IE;
+                                omap_writew(UDC_DS_CHG_IE | UDC_EP0_IE,
+                                                UDC_IRQ_EN);
                         }
                         change &= ~UDC_USB_RESET;
                 }
@@ -1848,7 +1867,7 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
                 VDBG("devstat %03x, ignore change %03x\n",
                         devstat,  change);
 
-        UDC_IRQ_SRC_REG = UDC_DS_CHG;
+        omap_writew(UDC_DS_CHG, UDC_IRQ_SRC);
 }
 
 static irqreturn_t omap_udc_irq(int irq, void *_udc)
@@ -1859,7 +1878,7 @@ static irqreturn_t omap_udc_irq(int irq, void *_udc)
         unsigned long   flags;
 
         spin_lock_irqsave(&udc->lock, flags);
-        irq_src = UDC_IRQ_SRC_REG;
+        irq_src = omap_readw(UDC_IRQ_SRC);
 
         /* Device state change (usb ch9 stuff) */
         if (irq_src & UDC_DS_CHG) {
@@ -1882,7 +1901,7 @@ static irqreturn_t omap_udc_irq(int irq, void *_udc)
                 irq_src &= ~(UDC_TXN_DONE|UDC_RXN_CNT|UDC_RXN_EOT);
         }
 
-        irq_src &= ~(UDC_SOF|UDC_EPN_TX|UDC_EPN_RX);
+        irq_src &= ~(UDC_IRQ_SOF | UDC_EPN_TX|UDC_EPN_RX);
         if (irq_src)
                 DBG("udc_irq, unhandled %03x\n", irq_src);
         spin_unlock_irqrestore(&udc->lock, flags);
@@ -1903,7 +1922,7 @@ static void pio_out_timer(unsigned long _ep)
         spin_lock_irqsave(&ep->udc->lock, flags);
         if (!list_empty(&ep->queue) && ep->ackwait) {
                 use_ep(ep, UDC_EP_SEL);
-                stat_flg = UDC_STAT_FLG_REG;
+                stat_flg = omap_readw(UDC_STAT_FLG);
 
                 if ((stat_flg & UDC_ACK) && (!(stat_flg & UDC_FIFO_EN)
                                 || (ep->double_buf && HALF_FULL(stat_flg)))) {
@@ -1913,8 +1932,8 @@ static void pio_out_timer(unsigned long _ep)
                         req = container_of(ep->queue.next,
                                         struct omap_req, queue);
                         (void) read_fifo(ep, req);
-                        UDC_EP_NUM_REG = ep->bEndpointAddress;
-                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                        omap_writew(ep->bEndpointAddress, UDC_EP_NUM);
+                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                         ep->ackwait = 1 + ep->double_buf;
                 } else
                         deselect_ep();
@@ -1934,20 +1953,20 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
         unsigned long   flags;
 
         spin_lock_irqsave(&udc->lock, flags);
-        epn_stat = UDC_EPN_STAT_REG;
-        irq_src = UDC_IRQ_SRC_REG;
+        epn_stat = omap_readw(UDC_EPN_STAT);
+        irq_src = omap_readw(UDC_IRQ_SRC);
 
         /* handle OUT first, to avoid some wasteful NAKs */
         if (irq_src & UDC_EPN_RX) {
                 epnum = (epn_stat >> 8) & 0x0f;
-                UDC_IRQ_SRC_REG = UDC_EPN_RX;
+                omap_writew(UDC_EPN_RX, UDC_IRQ_SRC);
                 status = IRQ_HANDLED;
                 ep = &udc->ep[epnum];
                 ep->irqs++;
 
-                UDC_EP_NUM_REG = epnum | UDC_EP_SEL;
+                omap_writew(epnum | UDC_EP_SEL, UDC_EP_NUM);
                 ep->fnf = 0;
-                if ((UDC_STAT_FLG_REG & UDC_ACK)) {
+                if (omap_readw(UDC_STAT_FLG) & UDC_ACK) {
                         ep->ackwait--;
                         if (!list_empty(&ep->queue)) {
                                 int stat;
@@ -1959,15 +1978,15 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
                         }
                 }
                 /* min 6 clock delay before clearing EP_SEL ... */
-                epn_stat = UDC_EPN_STAT_REG;
-                epn_stat = UDC_EPN_STAT_REG;
-                UDC_EP_NUM_REG = epnum;
+                epn_stat = omap_readw(UDC_EPN_STAT);
+                epn_stat = omap_readw(UDC_EPN_STAT);
+                omap_writew(epnum, UDC_EP_NUM);
 
                 /* enabling fifo _after_ clearing ACK, contrary to docs,
                  * reduces lossage; timer still needed though (sigh).
                  */
                 if (ep->fnf) {
-                        UDC_CTRL_REG = UDC_SET_FIFO_EN;
+                        omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
                         ep->ackwait = 1 + ep->double_buf;
                 }
                 mod_timer(&ep->timer, PIO_OUT_TIMEOUT);
@@ -1976,13 +1995,13 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
         /* then IN transfers */
         else if (irq_src & UDC_EPN_TX) {
                 epnum = epn_stat & 0x0f;
-                UDC_IRQ_SRC_REG = UDC_EPN_TX;
+                omap_writew(UDC_EPN_TX, UDC_IRQ_SRC);
                 status = IRQ_HANDLED;
                 ep = &udc->ep[16 + epnum];
                 ep->irqs++;
 
-                UDC_EP_NUM_REG = epnum | UDC_EP_DIR | UDC_EP_SEL;
-                if ((UDC_STAT_FLG_REG & UDC_ACK)) {
+                omap_writew(epnum | UDC_EP_DIR | UDC_EP_SEL, UDC_EP_NUM);
+                if (omap_readw(UDC_STAT_FLG) & UDC_ACK) {
                         ep->ackwait = 0;
                         if (!list_empty(&ep->queue)) {
                                 req = container_of(ep->queue.next,
@@ -1991,9 +2010,9 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
                         }
                 }
                 /* min 6 clock delay before clearing EP_SEL ... */
-                epn_stat = UDC_EPN_STAT_REG;
-                epn_stat = UDC_EPN_STAT_REG;
-                UDC_EP_NUM_REG = epnum | UDC_EP_DIR;
+                epn_stat = omap_readw(UDC_EPN_STAT);
+                epn_stat = omap_readw(UDC_EPN_STAT);
+                omap_writew(epnum | UDC_EP_DIR, UDC_EP_NUM);
                 /* then 6 clocks before it'd tx */
         }
 
@@ -2021,7 +2040,7 @@ static irqreturn_t omap_udc_iso_irq(int irq, void *_dev)
                 req = list_entry(ep->queue.next, struct omap_req, queue);
 
                 use_ep(ep, UDC_EP_SEL);
-                stat = UDC_STAT_FLG_REG;
+                stat = omap_readw(UDC_STAT_FLG);
 
                 /* NOTE: like the other controller drivers, this isn't
                  * currently reporting lost or damaged frames.
@@ -2053,9 +2072,14 @@ static irqreturn_t omap_udc_iso_irq(int irq, void *_dev)
                 if (!list_empty(&ep->queue))
                         pending = 1;
         }
-        if (!pending)
-                UDC_IRQ_EN_REG &= ~UDC_SOF_IE;
-        UDC_IRQ_SRC_REG = UDC_SOF;
+        if (!pending) {
+                u16 w;
+
+                w = omap_readw(UDC_IRQ_EN);
+                w &= ~UDC_SOF_IE;
+                omap_writew(w, UDC_IRQ_EN);
+        }
+        omap_writew(UDC_IRQ_SOF, UDC_IRQ_SRC);
 
         spin_unlock_irqrestore(&udc->lock, flags);
         return IRQ_HANDLED;
@@ -2104,7 +2128,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
                 if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
                         continue;
                 use_ep(ep, 0);
-                UDC_CTRL_REG = UDC_SET_HALT;
+                omap_writew(UDC_SET_HALT, UDC_CTRL);
         }
         udc->ep0_pending = 0;
         udc->ep[0].irqs = 0;
@@ -2128,7 +2152,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
         }
         DBG("bound to driver %s\n", driver->driver.name);
 
-        UDC_IRQ_SRC_REG = UDC_IRQ_SRC_MASK;
+        omap_writew(UDC_IRQ_SRC_MASK, UDC_IRQ_SRC);
 
         /* connect to bus through transceiver */
         if (udc->transceiver) {
@@ -2225,7 +2249,7 @@ static void proc_ep_show(struct seq_file *s, struct omap_ep *ep)
         else
                 buf[0] = 0;
 
-        stat_flg = UDC_STAT_FLG_REG;
+        stat_flg = omap_readw(UDC_STAT_FLG);
         seq_printf(s,
                 "\n%s %s%s%sirqs %ld stat %04x " EIGHTBITS FOURBITS "%s\n",
                 ep->name, buf,
@@ -2292,11 +2316,11 @@ static int proc_otg_show(struct seq_file *s)
                 trans = CONTROL_DEVCONF_REG;
         } else {
                 ctrl_name = "tranceiver_ctrl";
-                trans = USB_TRANSCEIVER_CTRL_REG;
+                trans = omap_readw(USB_TRANSCEIVER_CTRL);
         }
         seq_printf(s, "\nOTG rev %d.%d, %s %05x\n",
                 tmp >> 4, tmp & 0xf, ctrl_name, trans);
-        tmp = OTG_SYSCON_1_REG;
+        tmp = omap_readw(OTG_SYSCON_1);
         seq_printf(s, "otg_syscon1 %08x usb2 %s, usb1 %s, usb0 %s,"
                         FOURBITS "\n", tmp,
                 trx_mode(USB2_TRX_MODE(tmp), trans & CONF_USB2_UNI_R),
@@ -2308,7 +2332,7 @@ static int proc_otg_show(struct seq_file *s)
                 (tmp & HST_IDLE_EN) ? " !host" : "",
                 (tmp & DEV_IDLE_EN) ? " !dev" : "",
                 (tmp & OTG_RESET_DONE) ? " reset_done" : " reset_active");
-        tmp = OTG_SYSCON_2_REG;
+        tmp = omap_readl(OTG_SYSCON_2);
         seq_printf(s, "otg_syscon2 %08x%s" EIGHTBITS
                         " b_ase_brst=%d hmc=%d\n", tmp,
                 (tmp & OTG_EN) ? " otg_en" : "",
@@ -2323,7 +2347,7 @@ static int proc_otg_show(struct seq_file *s)
                 (tmp & HMC_TLLATTACH) ? " tllattach" : "",
                 B_ASE_BRST(tmp),
                 OTG_HMC(tmp));
-        tmp = OTG_CTRL_REG;
+        tmp = omap_readl(OTG_CTRL);
         seq_printf(s, "otg_ctrl    %06x" EIGHTBITS EIGHTBITS "%s\n", tmp,
                 (tmp & OTG_ASESSVLD) ? " asess" : "",
                 (tmp & OTG_BSESSEND) ? " bsess_end" : "",
@@ -2343,13 +2367,13 @@ static int proc_otg_show(struct seq_file *s)
                 (tmp & OTG_PU_VBUS) ? " pu_vb" : "",
                 (tmp & OTG_PU_ID) ? " pu_id" : ""
                 );
-        tmp = OTG_IRQ_EN_REG;
+        tmp = omap_readw(OTG_IRQ_EN);
         seq_printf(s, "otg_irq_en  %04x" "\n", tmp);
-        tmp = OTG_IRQ_SRC_REG;
+        tmp = omap_readw(OTG_IRQ_SRC);
         seq_printf(s, "otg_irq_src %04x" "\n", tmp);
-        tmp = OTG_OUTCTRL_REG;
+        tmp = omap_readw(OTG_OUTCTRL);
         seq_printf(s, "otg_outctrl %04x" "\n", tmp);
-        tmp = OTG_TEST_REG;
+        tmp = omap_readw(OTG_TEST);
         seq_printf(s, "otg_test    %04x" "\n", tmp);
         return 0;
 }
@@ -2370,7 +2394,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
                 driver_desc,
                 use_dma ?  " (dma)" : "");
 
-        tmp = UDC_REV_REG & 0xff;
+        tmp = omap_readw(UDC_REV) & 0xff;
         seq_printf(s,
                 "UDC rev %d.%d, fifo mode %d, gadget %s\n"
                 "hmc %d, transceiver %s\n",
@@ -2384,16 +2408,16 @@ static int proc_udc_show(struct seq_file *s, void *_)
                                 ? "external" : "(none)"));
         if (cpu_class_is_omap1()) {
                 seq_printf(s, "ULPD control %04x req %04x status %04x\n",
-                        __REG16(ULPD_CLOCK_CTRL),
-                        __REG16(ULPD_SOFT_REQ),
-                        __REG16(ULPD_STATUS_REQ));
+                        omap_readw(ULPD_CLOCK_CTRL),
+                        omap_readw(ULPD_SOFT_REQ),
+                        omap_readw(ULPD_STATUS_REQ));
         }
 
         /* OTG controller registers */
         if (!cpu_is_omap15xx())
                 proc_otg_show(s);
 
-        tmp = UDC_SYSCON1_REG;
+        tmp = omap_readw(UDC_SYSCON1);
         seq_printf(s, "\nsyscon1     %04x" EIGHTBITS "\n", tmp,
                 (tmp & UDC_CFG_LOCK) ? " cfg_lock" : "",
                 (tmp & UDC_DATA_ENDIAN) ? " data_endian" : "",
@@ -2412,7 +2436,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
                 return 0;
         }
 
-        tmp = UDC_DEVSTAT_REG;
+        tmp = omap_readw(UDC_DEVSTAT);
         seq_printf(s, "devstat     %04x" EIGHTBITS "%s%s\n", tmp,
                 (tmp & UDC_B_HNP_ENABLE) ? " b_hnp" : "",
                 (tmp & UDC_A_HNP_SUPPORT) ? " a_hnp" : "",
@@ -2424,20 +2448,20 @@ static int proc_udc_show(struct seq_file *s, void *_)
                 (tmp & UDC_ADD) ? " ADD" : "",
                 (tmp & UDC_DEF) ? " DEF" : "",
                 (tmp & UDC_ATT) ? " ATT" : "");
-        seq_printf(s, "sof         %04x\n", UDC_SOF_REG);
-        tmp = UDC_IRQ_EN_REG;
+        seq_printf(s, "sof         %04x\n", omap_readw(UDC_SOF));
+        tmp = omap_readw(UDC_IRQ_EN);
         seq_printf(s, "irq_en      %04x" FOURBITS "%s\n", tmp,
                 (tmp & UDC_SOF_IE) ? " sof" : "",
                 (tmp & UDC_EPN_RX_IE) ? " epn_rx" : "",
                 (tmp & UDC_EPN_TX_IE) ? " epn_tx" : "",
                 (tmp & UDC_DS_CHG_IE) ? " ds_chg" : "",
                 (tmp & UDC_EP0_IE) ? " ep0" : "");
-        tmp = UDC_IRQ_SRC_REG;
+        tmp = omap_readw(UDC_IRQ_SRC);
         seq_printf(s, "irq_src     %04x" EIGHTBITS "%s%s\n", tmp,
                 (tmp & UDC_TXN_DONE) ? " txn_done" : "",
                 (tmp & UDC_RXN_CNT) ? " rxn_cnt" : "",
                 (tmp & UDC_RXN_EOT) ? " rxn_eot" : "",
-                (tmp & UDC_SOF) ? " sof" : "",
+                (tmp & UDC_IRQ_SOF) ? " sof" : "",
                 (tmp & UDC_EPN_RX) ? " epn_rx" : "",
                 (tmp & UDC_EPN_TX) ? " epn_tx" : "",
                 (tmp & UDC_DS_CHG) ? " ds_chg" : "",
@@ -2447,7 +2471,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
         if (use_dma) {
                 unsigned i;
 
-                tmp = UDC_DMA_IRQ_EN_REG;
+                tmp = omap_readw(UDC_DMA_IRQ_EN);
                 seq_printf(s, "dma_irq_en  %04x%s" EIGHTBITS "\n", tmp,
                         (tmp & UDC_TX_DONE_IE(3)) ? " tx2_done" : "",
                         (tmp & UDC_RX_CNT_IE(3)) ? " rx2_cnt" : "",
@@ -2461,29 +2485,29 @@ static int proc_udc_show(struct seq_file *s, void *_)
                         (tmp & UDC_RX_CNT_IE(1)) ? " rx0_cnt" : "",
                         (tmp & UDC_RX_EOT_IE(1)) ? " rx0_eot" : "");
 
-                tmp = UDC_RXDMA_CFG_REG;
+                tmp = omap_readw(UDC_RXDMA_CFG);
                 seq_printf(s, "rxdma_cfg   %04x\n", tmp);
                 if (tmp) {
                         for (i = 0; i < 3; i++) {
                                 if ((tmp & (0x0f << (i * 4))) == 0)
                                         continue;
                                 seq_printf(s, "rxdma[%d]    %04x\n", i,
-                                                UDC_RXDMA_REG(i + 1));
+                                                omap_readw(UDC_RXDMA(i + 1)));
                         }
                 }
-                tmp = UDC_TXDMA_CFG_REG;
+                tmp = omap_readw(UDC_TXDMA_CFG);
                 seq_printf(s, "txdma_cfg   %04x\n", tmp);
                 if (tmp) {
                         for (i = 0; i < 3; i++) {
                                 if (!(tmp & (0x0f << (i * 4))))
                                         continue;
                                 seq_printf(s, "txdma[%d]    %04x\n", i,
-                                                UDC_TXDMA_REG(i + 1));
+                                                omap_readw(UDC_TXDMA(i + 1)));
                         }
                 }
         }
 
-        tmp = UDC_DEVSTAT_REG;
+        tmp = omap_readw(UDC_DEVSTAT);
         if (tmp & UDC_ATT) {
                 proc_ep_show(s, &udc->ep[0]);
                 if (tmp & UDC_ADD) {
@@ -2535,7 +2559,7 @@ static inline void remove_proc_file(void) {}
  * buffer space among the endpoints we'll be operating.
  *
  * NOTE: as of OMAP 1710 ES2.0, writing a new endpoint config when
- * UDC_SYSCON_1_REG.CFG_LOCK is set can now work.  We won't use that
+ * UDC_SYSCON_1.CFG_LOCK is set can now work.  We won't use that
  * capability yet though.
  */
 static unsigned __init
@@ -2597,9 +2621,9 @@ omap_ep_setup(char *name, u8 addr, u8 type,
                 name, addr, epn_rxtx, maxp, dbuf ? "x2" : "", buf);
 
         if (addr & USB_DIR_IN)
-                UDC_EP_TX_REG(addr & 0xf) = epn_rxtx;
+                omap_writew(epn_rxtx, UDC_EP_TX(addr & 0xf));
         else
-                UDC_EP_RX_REG(addr) = epn_rxtx;
+                omap_writew(epn_rxtx, UDC_EP_RX(addr));
 
         /* next endpoint's buffer starts after this one's */
         buf += maxp;
@@ -2638,15 +2662,15 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
         unsigned        tmp, buf;
 
         /* abolish any previous hardware state */
-        UDC_SYSCON1_REG = 0;
-        UDC_IRQ_EN_REG = 0;
-        UDC_IRQ_SRC_REG = UDC_IRQ_SRC_MASK;
-        UDC_DMA_IRQ_EN_REG = 0;
-        UDC_RXDMA_CFG_REG = 0;
-        UDC_TXDMA_CFG_REG = 0;
+        omap_writew(0, UDC_SYSCON1);
+        omap_writew(0, UDC_IRQ_EN);
+        omap_writew(UDC_IRQ_SRC_MASK, UDC_IRQ_SRC);
+        omap_writew(0, UDC_DMA_IRQ_EN);
+        omap_writew(0, UDC_RXDMA_CFG);
+        omap_writew(0, UDC_TXDMA_CFG);
 
         /* UDC_PULLUP_EN gates the chip clock */
-        // OTG_SYSCON_1_REG |= DEV_IDLE_EN;
+        // OTG_SYSCON_1 |= DEV_IDLE_EN;
 
         udc = kzalloc(sizeof(*udc), GFP_KERNEL);
         if (!udc)
@@ -2677,8 +2701,8 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
 
         /* initially disable all non-ep0 endpoints */
         for (tmp = 1; tmp < 15; tmp++) {
-                UDC_EP_RX_REG(tmp) = 0;
-                UDC_EP_TX_REG(tmp) = 0;
+                omap_writew(0, UDC_EP_RX(tmp));
+                omap_writew(0, UDC_EP_TX(tmp));
         }
 
 #define OMAP_BULK_EP(name,addr) \
@@ -2763,7 +2787,7 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
                 ERR("unsupported fifo_mode #%d\n", fifo_mode);
                 return -ENODEV;
         }
-        UDC_SYSCON1_REG = UDC_CFG_LOCK|UDC_SELF_PWR;
+        omap_writew(UDC_CFG_LOCK|UDC_SELF_PWR, UDC_SYSCON1);
         INFO("fifo mode %d, %d bytes not used\n", fifo_mode, 2048 - buf);
         return 0;
 }
@@ -2807,7 +2831,7 @@ static int __init omap_udc_probe(struct platform_device *pdev)
         }
 
         INFO("OMAP UDC rev %d.%d%s\n",
-                UDC_REV_REG >> 4, UDC_REV_REG & 0xf,
+                omap_readw(UDC_REV) >> 4, omap_readw(UDC_REV) & 0xf,
                 config->otg ? ", Mini-AB" : "");
 
         /* use the mode given to us by board init code */
@@ -2822,12 +2846,12 @@ static int __init omap_udc_probe(struct platform_device *pdev)
                          * know when to turn PULLUP_EN on/off; and that
                          * means we always "need" the 48MHz clock.
                          */
-                        u32 tmp = FUNC_MUX_CTRL_0_REG;
-
-                        FUNC_MUX_CTRL_0_REG &= ~VBUS_CTRL_1510;
+                        u32 tmp = omap_readl(FUNC_MUX_CTRL_0);
+                        tmp &= ~VBUS_CTRL_1510;
+                        omap_writel(tmp, FUNC_MUX_CTRL_0);
                         tmp |= VBUS_MODE_1510;
                         tmp &= ~VBUS_CTRL_1510;
-                        FUNC_MUX_CTRL_0_REG = tmp;
+                        omap_writel(tmp, FUNC_MUX_CTRL_0);
                 }
         } else {
                 /* The transceiver may package some GPIO logic or handle
@@ -2907,7 +2931,7 @@ known:
 #endif
 
         /* starting with omap1710 es2.0, clear toggle is a separate bit */
-        if (UDC_REV_REG >= 0x61)
+        if (omap_readw(UDC_REV) >= 0x61)
                 udc->clr_halt = UDC_RESET_EP | UDC_CLRDATA_TOGGLE;
         else
                 udc->clr_halt = UDC_RESET_EP;
@@ -3005,7 +3029,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
                 put_device(udc->transceiver->dev);
                 udc->transceiver = NULL;
         }
-        UDC_SYSCON1_REG = 0;
+        omap_writew(0, UDC_SYSCON1);
 
         remove_proc_file();
 
@@ -3036,7 +3060,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
  *
  * REVISIT we should probably reject suspend requests when there's a host
  * session active, rather than disconnecting, at least on boards that can
- * report VBUS irqs (UDC_DEVSTAT_REG.UDC_ATT).  And in any case, we need to
+ * report VBUS irqs (UDC_DEVSTAT.UDC_ATT).  And in any case, we need to
  * make host resumes and VBUS detection trigger OMAP wakeup events; that
  * may involve talking to an external transceiver (e.g. isp1301).
  */
@@ -3045,7 +3069,7 @@ static int omap_udc_suspend(struct platform_device *dev, pm_message_t message)
 {
         u32     devstat;
 
-        devstat = UDC_DEVSTAT_REG;
+        devstat = omap_readw(UDC_DEVSTAT);
 
         /* we're requesting 48 MHz clock if the pullup is enabled
          * (== we're attached to the host) and we're not suspended,
diff --git a/drivers/usb/gadget/omap_udc.h b/drivers/usb/gadget/omap_udc.h
index c6b9cbc7230a..8522bbb12278 100644
--- a/drivers/usb/gadget/omap_udc.h
+++ b/drivers/usb/gadget/omap_udc.h
@@ -8,23 +8,22 @@
 /*
  * USB device/endpoint management registers
  */
-#define UDC_REG(offset)              __REG16(UDC_BASE + (offset))
 
-#define UDC_REV_REG                     UDC_REG(0x0)    /* Revision */
-#define UDC_EP_NUM_REG                  UDC_REG(0x4)    /* Which endpoint */
+#define UDC_REV                         (UDC_BASE + 0x0)        /* Revision */
+#define UDC_EP_NUM                      (UDC_BASE + 0x4)        /* Which endpoint */
 #       define  UDC_SETUP_SEL           (1 << 6)
 #       define  UDC_EP_SEL              (1 << 5)
 #       define  UDC_EP_DIR              (1 << 4)
         /* low 4 bits for endpoint number */
-#define UDC_DATA_REG                    UDC_REG(0x08)   /* Endpoint FIFO */
-#define UDC_CTRL_REG                    UDC_REG(0x0C)   /* Endpoint control */
+#define UDC_DATA                        (UDC_BASE + 0x08)       /* Endpoint FIFO */
+#define UDC_CTRL                        (UDC_BASE + 0x0C)       /* Endpoint control */
 #       define  UDC_CLR_HALT            (1 << 7)
 #       define  UDC_SET_HALT            (1 << 6)
 #       define  UDC_CLRDATA_TOGGLE      (1 << 3)
 #       define  UDC_SET_FIFO_EN         (1 << 2)
 #       define  UDC_CLR_EP              (1 << 1)
 #       define  UDC_RESET_EP            (1 << 0)
-#define UDC_STAT_FLG_REG                UDC_REG(0x10)   /* Endpoint status */
+#define UDC_STAT_FLG                    (UDC_BASE + 0x10)       /* Endpoint status */
 #       define  UDC_NO_RXPACKET         (1 << 15)
 #       define  UDC_MISS_IN             (1 << 14)
 #       define  UDC_DATA_FLUSH          (1 << 13)
@@ -38,8 +37,8 @@
 #       define  UDC_FIFO_EN             (1 << 2)
 #       define  UDC_NON_ISO_FIFO_EMPTY  (1 << 1)
 #       define  UDC_NON_ISO_FIFO_FULL   (1 << 0)
-#define UDC_RXFSTAT_REG                 UDC_REG(0x14)   /* OUT bytecount */
-#define UDC_SYSCON1_REG                 UDC_REG(0x18)   /* System config 1 */
+#define UDC_RXFSTAT                     (UDC_BASE + 0x14)       /* OUT bytecount */
+#define UDC_SYSCON1                     (UDC_BASE + 0x18)       /* System config 1 */
 #       define  UDC_CFG_LOCK            (1 << 8)
 #       define  UDC_DATA_ENDIAN         (1 << 7)
 #       define  UDC_DMA_ENDIAN          (1 << 6)
@@ -48,12 +47,12 @@
 #       define  UDC_SELF_PWR            (1 << 2)
 #       define  UDC_SOFF_DIS            (1 << 1)
 #       define  UDC_PULLUP_EN           (1 << 0)
-#define UDC_SYSCON2_REG                 UDC_REG(0x1C)   /* System config 2 */
+#define UDC_SYSCON2                     (UDC_BASE + 0x1C)       /* System config 2 */
 #       define  UDC_RMT_WKP             (1 << 6)
 #       define  UDC_STALL_CMD           (1 << 5)
 #       define  UDC_DEV_CFG             (1 << 3)
 #       define  UDC_CLR_CFG             (1 << 2)
-#define UDC_DEVSTAT_REG                 UDC_REG(0x20)   /* Device status */
+#define UDC_DEVSTAT                     (UDC_BASE + 0x20)       /* Device status */
 #       define  UDC_B_HNP_ENABLE        (1 << 9)
 #       define  UDC_A_HNP_SUPPORT       (1 << 8)
 #       define  UDC_A_ALT_HNP_SUPPORT   (1 << 7)
@@ -64,26 +63,26 @@
 #       define  UDC_ADD                 (1 << 2)
 #       define  UDC_DEF                 (1 << 1)
 #       define  UDC_ATT                 (1 << 0)
-#define UDC_SOF_REG                     UDC_REG(0x24)   /* Start of frame */
+#define UDC_SOF                         (UDC_BASE + 0x24)       /* Start of frame */
 #       define  UDC_FT_LOCK             (1 << 12)
 #       define  UDC_TS_OK               (1 << 11)
 #       define  UDC_TS                  0x03ff
-#define UDC_IRQ_EN_REG                  UDC_REG(0x28)   /* Interrupt enable */
+#define UDC_IRQ_EN                      (UDC_BASE + 0x28)       /* Interrupt enable */
 #       define  UDC_SOF_IE              (1 << 7)
 #       define  UDC_EPN_RX_IE           (1 << 5)
 #       define  UDC_EPN_TX_IE           (1 << 4)
 #       define  UDC_DS_CHG_IE           (1 << 3)
 #       define  UDC_EP0_IE              (1 << 0)
-#define UDC_DMA_IRQ_EN_REG              UDC_REG(0x2C)   /* DMA irq enable */
+#define UDC_DMA_IRQ_EN                  (UDC_BASE + 0x2C)       /* DMA irq enable */
         /* rx/tx dma channels numbered 1-3 not 0-2 */
 #       define  UDC_TX_DONE_IE(n)       (1 << (4 * (n) - 2))
 #       define  UDC_RX_CNT_IE(n)        (1 << (4 * (n) - 3))
 #       define  UDC_RX_EOT_IE(n)        (1 << (4 * (n) - 4))
-#define UDC_IRQ_SRC_REG                 UDC_REG(0x30)   /* Interrupt source */
+#define UDC_IRQ_SRC                     (UDC_BASE + 0x30)       /* Interrupt source */
 #       define  UDC_TXN_DONE            (1 << 10)
 #       define  UDC_RXN_CNT             (1 << 9)
 #       define  UDC_RXN_EOT             (1 << 8)
-#       define  UDC_SOF                 (1 << 7)
+#       define  UDC_IRQ_SOF             (1 << 7)
 #       define  UDC_EPN_RX              (1 << 5)
 #       define  UDC_EPN_TX              (1 << 4)
 #       define  UDC_DS_CHG              (1 << 3)
@@ -91,41 +90,41 @@
 #       define  UDC_EP0_RX              (1 << 1)
 #       define  UDC_EP0_TX              (1 << 0)
 #       define  UDC_IRQ_SRC_MASK        0x7bf
-#define UDC_EPN_STAT_REG                UDC_REG(0x34)   /* EP irq status */
-#define UDC_DMAN_STAT_REG               UDC_REG(0x38)   /* DMA irq status */
+#define UDC_EPN_STAT                    (UDC_BASE + 0x34)       /* EP irq status */
+#define UDC_DMAN_STAT                   (UDC_BASE + 0x38)       /* DMA irq status */
 #       define  UDC_DMA_RX_SB           (1 << 12)
 #       define  UDC_DMA_RX_SRC(x)       (((x)>>8) & 0xf)
 #       define  UDC_DMA_TX_SRC(x)       (((x)>>0) & 0xf)
 
 
 /* DMA configuration registers:  up to three channels in each direction.  */
-#define UDC_RXDMA_CFG_REG               UDC_REG(0x40)   /* 3 eps for RX DMA */
+#define UDC_RXDMA_CFG                   (UDC_BASE + 0x40)       /* 3 eps for RX DMA */
 #       define  UDC_DMA_REQ             (1 << 12)
-#define UDC_TXDMA_CFG_REG               UDC_REG(0x44)   /* 3 eps for TX DMA */
-#define UDC_DATA_DMA_REG                UDC_REG(0x48)   /* rx/tx fifo addr */
+#define UDC_TXDMA_CFG                   (UDC_BASE + 0x44)       /* 3 eps for TX DMA */
+#define UDC_DATA_DMA                    (UDC_BASE + 0x48)       /* rx/tx fifo addr */
 
 /* rx/tx dma control, numbering channels 1-3 not 0-2 */
-#define UDC_TXDMA_REG(chan)             UDC_REG(0x50 - 4 + 4 * (chan))
+#define UDC_TXDMA(chan)                 (UDC_BASE + 0x50 - 4 + 4 * (chan))
 #       define UDC_TXN_EOT              (1 << 15)       /* bytes vs packets */
 #       define UDC_TXN_START            (1 << 14)       /* start transfer */
 #       define UDC_TXN_TSC              0x03ff          /* units in xfer */
-#define UDC_RXDMA_REG(chan)             UDC_REG(0x60 - 4 + 4 * (chan))
+#define UDC_RXDMA(chan)                 (UDC_BASE + 0x60 - 4 + 4 * (chan))
 #       define UDC_RXN_STOP             (1 << 15)       /* enable EOT irq */
 #       define UDC_RXN_TC               0x00ff          /* packets in xfer */
 
 
 /*
  * Endpoint configuration registers (used before CFG_LOCK is set)
- * UDC_EP_TX_REG(0) is unused
+ * UDC_EP_TX(0) is unused
  */
-#define UDC_EP_RX_REG(endpoint)         UDC_REG(0x80 + (endpoint)*4)
+#define UDC_EP_RX(endpoint)             (UDC_BASE + 0x80 + (endpoint)*4)
 #       define  UDC_EPN_RX_VALID        (1 << 15)
 #       define  UDC_EPN_RX_DB           (1 << 14)
         /* buffer size in bits 13, 12 */
 #       define  UDC_EPN_RX_ISO          (1 << 11)
         /* buffer pointer in low 11 bits */
-#define UDC_EP_TX_REG(endpoint)         UDC_REG(0xc0 + (endpoint)*4)
-        /* same bitfields as in RX_REG */
+#define UDC_EP_TX(endpoint)             (UDC_BASE + 0xc0 + (endpoint)*4)
+        /* same bitfields as in RX */
 
 /*-------------------------------------------------------------------------*/
 
@@ -195,14 +194,14 @@ struct omap_udc {
 
 /*-------------------------------------------------------------------------*/
 
-#define MOD_CONF_CTRL_0_REG     __REG32(MOD_CONF_CTRL_0)
-#define VBUS_W2FC_1510          (1 << 17)       /* 0 gpio0, 1 dvdd2 pin */
+/* MOD_CONF_CTRL_0 */
+#define VBUS_W2FC_1510          (1 << 17)       /* 0 gpio0, 1 dvdd2 pin */
 
-#define FUNC_MUX_CTRL_0_REG     __REG32(FUNC_MUX_CTRL_0)
+/* FUNC_MUX_CTRL_0 */
 #define VBUS_CTRL_1510          (1 << 19)       /* 1 connected (software) */
 #define VBUS_MODE_1510          (1 << 18)       /* 0 hardware, 1 software */
 
-#define HMC_1510        ((MOD_CONF_CTRL_0_REG >> 1) & 0x3f)
-#define HMC_1610        (OTG_SYSCON_2_REG & 0x3f)
+#define HMC_1510        ((omap_readl(MOD_CONF_CTRL_0) >> 1) & 0x3f)
+#define HMC_1610        (omap_readl(OTG_SYSCON_2) & 0x3f)
 #define HMC             (cpu_is_omap15xx() ? HMC_1510 : HMC_1610)
 
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 35a03095757e..90245fd8bac4 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -177,6 +177,15 @@ timer_action_done (struct ehci_hcd *ehci, enum ehci_timer_action action)
 static inline void
 timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
 {
+        /* Don't override timeouts which shrink or (later) disable
+         * the async ring; just the I/O watchdog.  Note that if a
+         * SHRINK were pending, OFF would never be requested.
+         */
+        if (timer_pending(&ehci->watchdog)
+                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                                & ehci->actions))
+                return;
+
         if (!test_and_set_bit (action, &ehci->actions)) {
                 unsigned long t;
 
@@ -192,15 +201,7 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
                         t = EHCI_SHRINK_JIFFIES;
                         break;
                 }
-                t += jiffies;
-                // all timings except IAA watchdog can be overridden.
-                // async queue SHRINK often precedes IAA.  while it's ready
-                // to go OFF neither can matter, and afterwards the IO
-                // watchdog stops unless there's still periodic traffic.
-                if (time_before_eq(t, ehci->watchdog.expires)
-                                && timer_pending (&ehci->watchdog))
-                        return;
-                mod_timer (&ehci->watchdog, t);
+                mod_timer(&ehci->watchdog, t + jiffies);
         }
 }
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 33f1c1c32edf..a8160d65f32b 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1054,7 +1054,7 @@ MODULE_LICENSE ("GPL");
 
 #ifdef CONFIG_MFD_SM501
 #include "ohci-sm501.c"
-#define PLATFORM_DRIVER         ohci_hcd_sm501_driver
+#define SM501_OHCI_DRIVER       ohci_hcd_sm501_driver
 #endif
 
 #if     !defined(PCI_DRIVER) &&         \
@@ -1062,6 +1062,7 @@ MODULE_LICENSE ("GPL");
         !defined(OF_PLATFORM_DRIVER) && \
         !defined(SA1111_DRIVER) &&      \
         !defined(PS3_SYSTEM_BUS_DRIVER) && \
+        !defined(SM501_OHCI_DRIVER) && \
         !defined(SSB_OHCI_DRIVER)
 #error "missing bus glue for ohci-hcd"
 #endif
@@ -1121,9 +1122,18 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_ssb;
 #endif
 
+#ifdef SM501_OHCI_DRIVER
+        retval = platform_driver_register(&SM501_OHCI_DRIVER);
+        if (retval < 0)
+                goto error_sm501;
+#endif
+
         return retval;
 
         /* Error path */
+#ifdef SM501_OHCI_DRIVER
+ error_sm501:
+#endif
 #ifdef SSB_OHCI_DRIVER
  error_ssb:
 #endif
@@ -1159,6 +1169,9 @@ module_init(ohci_hcd_mod_init);
 
 static void __exit ohci_hcd_mod_exit(void)
 {
+#ifdef SM501_OHCI_DRIVER
+        platform_driver_unregister(&SM501_OHCI_DRIVER);
+#endif
 #ifdef SSB_OHCI_DRIVER
         ssb_driver_unregister(&SSB_OHCI_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 6859fb5f1d6f..2b7c04079d56 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -169,13 +169,16 @@ static void start_hnp(struct ohci_hcd *ohci)
 {
         const unsigned  port = ohci_to_hcd(ohci)->self.otg_port - 1;
         unsigned long   flags;
+        u32 l;
 
         otg_start_hnp(ohci->transceiver);
 
         local_irq_save(flags);
         ohci->transceiver->state = OTG_STATE_A_SUSPEND;
         writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]);
-        OTG_CTRL_REG &= ~OTG_A_BUSREQ;
+        l = omap_readl(OTG_CTRL);
+        l &= ~OTG_A_BUSREQ;
+        omap_writel(l, OTG_CTRL);
         local_irq_restore(flags);
 }
 
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 9c9f3b59186f..9b547407c934 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -952,6 +952,7 @@ rescan_this:
                         struct urb      *urb;
                         urb_priv_t      *urb_priv;
                         __hc32          savebits;
+                        u32             tdINFO;
 
                         td = list_entry (entry, struct td, td_list);
                         urb = td->urb;
@@ -966,6 +967,17 @@ rescan_this:
                         savebits = *prev & ~cpu_to_hc32 (ohci, TD_MASK);
                         *prev = td->hwNextTD | savebits;
 
+                        /* If this was unlinked, the TD may not have been
+                         * retired ... so manually save the data toggle.
+                         * The controller ignores the value we save for
+                         * control and ISO endpoints.
+                         */
+                        tdINFO = hc32_to_cpup(ohci, &td->hwINFO);
+                        if ((tdINFO & TD_T) == TD_T_DATA0)
+                                ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_C);
+                        else if ((tdINFO & TD_T) == TD_T_DATA1)
+                                ed->hwHeadP |= cpu_to_hc32(ohci, ED_C);
+
                         /* HC may have partly processed this TD */
                         td_done (ohci, urb, td);
                         urb_priv->td_cnt++;
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index cb7fa0eaf3ae..33182f4c2267 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -3264,8 +3264,6 @@ static void sisusb_disconnect(struct usb_interface *intf)
 
         /* decrement our usage count */
         kref_put(&sisusb->kref, sisusb_delete);
-
-        dev_info(&sisusb->sisusb_dev->dev, "Disconnected\n");
 }
 
 static struct usb_device_id sisusb_table [] = {
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 5234e7a3bd2c..0ff4a3971e45 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -637,6 +637,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+        { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 06e0ecabb3eb..8302eca893ea 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -828,6 +828,9 @@
 /* Propox devices */
 #define FTDI_PROPOX_JTAGCABLEII_PID     0xD738
 
+/* Rig Expert Ukraine devices */
+#define FTDI_REU_TINY_PID               0xED22  /* RigExpert Tiny */
+
 /* Commands */
 #define FTDI_SIO_RESET          0 /* Reset the port */
 #define FTDI_SIO_MODEM_CTRL     1 /* Set the modem control register */
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index ea924dc48496..d9fb3768a2d7 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -570,7 +570,12 @@ static struct usb_serial_driver ipaq_device = {
         .description =          "PocketPC PDA",
         .usb_driver =           &ipaq_driver,
         .id_table =             ipaq_id_table,
-        .num_ports =            2,
+        /*
+         * some devices have an extra endpoint, which
+         * must be ignored as it would make the core
+         * create a second port which oopses when used
+         */
+        .num_ports =            1,
         .open =                 ipaq_open,
         .close =                ipaq_close,
         .attach =               ipaq_startup,
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 43cfde83a93b..a73420dd052a 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -306,6 +306,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
         { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
+        { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6000)}, /* ZTE AC8700 */
         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
         { USB_DEVICE(MAXON_VENDOR_ID, 0x6280) }, /* BP3-USB & BP3-EXT HSDPA */
         { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 103195abd417..2a0dd1b50dc4 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -57,6 +57,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
+        { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index cff160abb130..6ac3bbcf7a22 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -15,6 +15,7 @@
 #define PL2303_PRODUCT_ID_RSAQ3         0xaaa2
 #define PL2303_PRODUCT_ID_ALDIGA        0x0611
 #define PL2303_PRODUCT_ID_MMX           0x0612
+#define PL2303_PRODUCT_ID_GPRS          0x0609
 
 #define ATEN_VENDOR_ID          0x0557
 #define ATEN_VENDOR_ID2         0x0547
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 45fe3663fa7f..39a7c11795c4 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -402,11 +402,19 @@ UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
                 US_FL_IGNORE_RESIDUE ),
 
 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
+/* CY7C68300 : support atacb */
 UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
                 "Cypress",
                 "Cypress AT2LP",
                 US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
                 0),
+
+/* CY7C68310 : support atacb and atacb2 */
+UNUSUAL_DEV(  0x04b4, 0x6831, 0x0000, 0x9999,
+                "Cypress",
+                "Cypress ISD-300LP",
+                US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
+                0),
 #endif
 
 /* Reported by Simon Levitt <simon@whattf.com>
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 5cc1b8073726..bb2514369507 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -1304,7 +1304,7 @@ static int pxafb_resume(struct platform_device *dev)
  *      cache.  Once this area is remapped, all virtual memory
  *      access to the video memory should occur at the new region.
  */
-static int __init pxafb_map_video_memory(struct pxafb_info *fbi)
+static int __devinit pxafb_map_video_memory(struct pxafb_info *fbi)
 {
         /*
          * We reserve one page for the palette, plus the size
@@ -1406,7 +1406,7 @@ decode_mode:
         pxafb_decode_mode_info(fbi, inf->modes, inf->num_modes);
 }
 
-static struct pxafb_info * __init pxafb_init_fbinfo(struct device *dev)
+static struct pxafb_info * __devinit pxafb_init_fbinfo(struct device *dev)
 {
         struct pxafb_info *fbi;
         void *addr;
@@ -1468,7 +1468,7 @@ static struct pxafb_info * __init pxafb_init_fbinfo(struct device *dev)
 }
 
 #ifdef CONFIG_FB_PXA_PARAMETERS
-static int __init parse_opt_mode(struct device *dev, const char *this_opt)
+static int __devinit parse_opt_mode(struct device *dev, const char *this_opt)
 {
         struct pxafb_mach_info *inf = dev->platform_data;
 
@@ -1527,7 +1527,7 @@ done:
         return 0;
 }
 
-static int __init parse_opt(struct device *dev, char *this_opt)
+static int __devinit parse_opt(struct device *dev, char *this_opt)
 {
         struct pxafb_mach_info *inf = dev->platform_data;
         struct pxafb_mode_info *mode = &inf->modes[0];
@@ -1625,7 +1625,7 @@ static int __init parse_opt(struct device *dev, char *this_opt)
         return 0;
 }
 
-static int __init pxafb_parse_options(struct device *dev, char *options)
+static int __devinit pxafb_parse_options(struct device *dev, char *options)
 {
         char *this_opt;
         int ret;
@@ -1646,8 +1646,8 @@ static int __init pxafb_parse_options(struct device *dev, char *options)
 
 static char g_options[256] __devinitdata = "";
 
-#ifndef CONFIG_MODULES
-static int __devinit pxafb_setup_options(void)
+#ifndef MODULE
+static int __init pxafb_setup_options(void)
 {
         char *options = NULL;
 
@@ -1671,7 +1671,7 @@ MODULE_PARM_DESC(options, "LCD parameters (see Documentation/fb/pxafb.txt)");
 #define pxafb_setup_options()           (0)
 #endif
 
-static int __init pxafb_probe(struct platform_device *dev)
+static int __devinit pxafb_probe(struct platform_device *dev)
 {
         struct pxafb_info *fbi;
         struct pxafb_mach_info *inf;
@@ -1743,14 +1743,14 @@ static int __init pxafb_probe(struct platform_device *dev)
         if (r == NULL) {
                 dev_err(&dev->dev, "no I/O memory resource defined\n");
                 ret = -ENODEV;
-                goto failed;
+                goto failed_fbi;
         }
 
         r = request_mem_region(r->start, r->end - r->start + 1, dev->name);
         if (r == NULL) {
                 dev_err(&dev->dev, "failed to request I/O memory\n");
                 ret = -EBUSY;
-                goto failed;
+                goto failed_fbi;
         }
 
         fbi->mmio_base = ioremap(r->start, r->end - r->start + 1);
@@ -1793,8 +1793,17 @@ static int __init pxafb_probe(struct platform_device *dev)
          * This makes sure that our colour bitfield
          * descriptors are correctly initialised.
          */
-        pxafb_check_var(&fbi->fb.var, &fbi->fb);
-        pxafb_set_par(&fbi->fb);
+        ret = pxafb_check_var(&fbi->fb.var, &fbi->fb);
+        if (ret) {
+                dev_err(&dev->dev, "failed to get suitable mode\n");
+                goto failed_free_irq;
+        }
+
+        ret = pxafb_set_par(&fbi->fb);
+        if (ret) {
+                dev_err(&dev->dev, "Failed to set parameters\n");
+                goto failed_free_irq;
+        }
 
         platform_set_drvdata(dev, fbi);
 
@@ -1802,7 +1811,7 @@ static int __init pxafb_probe(struct platform_device *dev)
         if (ret < 0) {
                 dev_err(&dev->dev,
                         "Failed to register framebuffer device: %d\n", ret);
-                goto failed_free_irq;
+                goto failed_free_cmap;
         }
 
 #ifdef CONFIG_CPU_FREQ
@@ -1821,18 +1830,23 @@ static int __init pxafb_probe(struct platform_device *dev)
 
         return 0;
 
+failed_free_cmap:
+        if (fbi->fb.cmap.len)
+                fb_dealloc_cmap(&fbi->fb.cmap);
 failed_free_irq:
         free_irq(irq, fbi);
-failed_free_res:
-        release_mem_region(r->start, r->end - r->start + 1);
-failed_free_io:
-        iounmap(fbi->mmio_base);
 failed_free_mem:
         dma_free_writecombine(&dev->dev, fbi->map_size,
                         fbi->map_cpu, fbi->map_dma);
-failed:
+failed_free_io:
+        iounmap(fbi->mmio_base);
+failed_free_res:
+        release_mem_region(r->start, r->end - r->start + 1);
+failed_fbi:
+        clk_put(fbi->clk);
         platform_set_drvdata(dev, NULL);
         kfree(fbi);
+failed:
         return ret;
 }
 
@@ -1883,7 +1897,7 @@ static struct platform_driver pxafb_driver = {
         },
 };
 
-static int __devinit pxafb_init(void)
+static int __init pxafb_init(void)
 {
         if (pxafb_setup_options())
                 return -EINVAL;