122 files changed, 3410 insertions, 1780 deletions
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index 879250d3d069..ff8c4beaace4 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -51,6 +51,8 @@ config CRYPTO_DEV_PADLOCK_SHA
          If unsure say M. The compiled module will be
          called padlock-sha.ko
+source "arch/s390/crypto/Kconfig"
 config CRYPTO_DEV_GEODE
        tristate "Support for the Geode LX AES engine"
        depends on CRYPTO && X86_32 && PCI
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index ec796ad087df..850788f4dd2e 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -22,5 +22,19 @@ config HID
          If unsure, say Y
+config HID_DEBUG
+        bool "HID debugging support"
+        depends on HID
+        ---help---
+        This option lets the HID layer output diagnostics about its internal
+        state, resolve HID usages, dump HID fields, etc. Individual HID drivers
+        use this debugging facility to output information about individual HID
+        devices, etc.
+        This feature is useful for those who are either debugging the HID parser
+        or any HID hardware device.
+        If unsure, say N
 endmenu
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 6432392110bf..52e97d8f3c95 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -1,15 +1,8 @@
 #
 # Makefile for the HID driver
 #
+hid-objs                        := hid-core.o hid-input.o
-# Multipart objects.
-hid-objs        := hid-core.o hid-input.o
-# Optional parts of multipart objects.
 obj-$(CONFIG_HID)               += hid.o
+hid-$(CONFIG_HID_DEBUG)         += hid-debug.o
-ifeq ($(CONFIG_INPUT_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 49f18f5b2514..8c7d48eff7b7 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -28,11 +28,9 @@
 #include <linux/input.h>
 #include <linux/wait.h>
-#undef DEBUG
-#undef DEBUG_DATA
 #include <linux/hid.h>
 #include <linux/hiddev.h>
+#include <linux/hid-debug.h>
 /*
 * Version Information
@@ -951,7 +949,7 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                return -1;
        }
-#ifdef DEBUG_DATA
+#ifdef CONFIG_HID_DEBUG
        printk(KERN_DEBUG __FILE__ ": report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
 #endif
@@ -961,7 +959,7 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                size--;
        }
-#ifdef DEBUG_DATA
+#ifdef CONFIG_HID_DEBUG
        {
                int i;
                printk(KERN_DEBUG __FILE__ ": report %d (size %u) = ", n, size);
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
new file mode 100644
index 000000000000..89241be4ec9b
--- /dev/null
+++ b/drivers/hid/hid-debug.c
@@ -0,0 +1,764 @@
+/*
+ * $Id: hid-debug.h,v 1.8 2001/09/25 09:37:57 vojtech Exp $
+ *
+ *  (c) 1999 Andreas Gal                <gal@cs.uni-magdeburg.de>
+ *  (c) 2000-2001 Vojtech Pavlik        <vojtech@ucw.cz>
+ *  (c) 2007 Jiri Kosina
+ *
+ *  Some debug stuff for the HID parser.
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Should you need to contact me, the author, you can do so either by
+ * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
+ * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
+ */
+#include <linux/hid.h>
+struct hid_usage_entry {
+        unsigned  page;
+        unsigned  usage;
+        char     *description;
+};
+static const struct hid_usage_entry hid_usage_table[] = {
+  {  0,      0, "Undefined" },
+  {  1,      0, "GenericDesktop" },
+    {0, 0x01, "Pointer"},
+    {0, 0x02, "Mouse"},
+    {0, 0x04, "Joystick"},
+    {0, 0x05, "GamePad"},
+    {0, 0x06, "Keyboard"},
+    {0, 0x07, "Keypad"},
+    {0, 0x08, "MultiAxis"},
+      {0, 0x30, "X"},
+      {0, 0x31, "Y"},
+      {0, 0x32, "Z"},
+      {0, 0x33, "Rx"},
+      {0, 0x34, "Ry"},
+      {0, 0x35, "Rz"},
+      {0, 0x36, "Slider"},
+      {0, 0x37, "Dial"},
+      {0, 0x38, "Wheel"},
+      {0, 0x39, "HatSwitch"},
+    {0, 0x3a, "CountedBuffer"},
+      {0, 0x3b, "ByteCount"},
+      {0, 0x3c, "MotionWakeup"},
+      {0, 0x3d, "Start"},
+      {0, 0x3e, "Select"},
+      {0, 0x40, "Vx"},
+      {0, 0x41, "Vy"},
+      {0, 0x42, "Vz"},
+      {0, 0x43, "Vbrx"},
+      {0, 0x44, "Vbry"},
+      {0, 0x45, "Vbrz"},
+      {0, 0x46, "Vno"},
+    {0, 0x80, "SystemControl"},
+      {0, 0x81, "SystemPowerDown"},
+      {0, 0x82, "SystemSleep"},
+      {0, 0x83, "SystemWakeUp"},
+      {0, 0x84, "SystemContextMenu"},
+      {0, 0x85, "SystemMainMenu"},
+      {0, 0x86, "SystemAppMenu"},
+      {0, 0x87, "SystemMenuHelp"},
+      {0, 0x88, "SystemMenuExit"},
+      {0, 0x89, "SystemMenuSelect"},
+      {0, 0x8a, "SystemMenuRight"},
+      {0, 0x8b, "SystemMenuLeft"},
+      {0, 0x8c, "SystemMenuUp"},
+      {0, 0x8d, "SystemMenuDown"},
+      {0, 0x90, "D-PadUp"},
+      {0, 0x91, "D-PadDown"},
+      {0, 0x92, "D-PadRight"},
+      {0, 0x93, "D-PadLeft"},
+  {  2, 0, "Simulation" },
+      {0, 0xb0, "Aileron"},
+      {0, 0xb1, "AileronTrim"},
+      {0, 0xb2, "Anti-Torque"},
+      {0, 0xb3, "Autopilot"},
+      {0, 0xb4, "Chaff"},
+      {0, 0xb5, "Collective"},
+      {0, 0xb6, "DiveBrake"},
+      {0, 0xb7, "ElectronicCountermeasures"},
+      {0, 0xb8, "Elevator"},
+      {0, 0xb9, "ElevatorTrim"},
+      {0, 0xba, "Rudder"},
+      {0, 0xbb, "Throttle"},
+      {0, 0xbc, "FlightCommunications"},
+      {0, 0xbd, "FlareRelease"},
+      {0, 0xbe, "LandingGear"},
+      {0, 0xbf, "ToeBrake"},
+  {  7, 0, "Keyboard" },
+  {  8, 0, "LED" },
+      {0, 0x01, "NumLock"},
+      {0, 0x02, "CapsLock"},
+      {0, 0x03, "ScrollLock"},
+      {0, 0x04, "Compose"},
+      {0, 0x05, "Kana"},
+      {0, 0x4b, "GenericIndicator"},
+  {  9, 0, "Button" },
+  { 10, 0, "Ordinal" },
+  { 12, 0, "Consumer" },
+      {0, 0x238, "HorizontalWheel"},
+  { 13, 0, "Digitizers" },
+    {0, 0x01, "Digitizer"},
+    {0, 0x02, "Pen"},
+    {0, 0x03, "LightPen"},
+    {0, 0x04, "TouchScreen"},
+    {0, 0x05, "TouchPad"},
+    {0, 0x20, "Stylus"},
+    {0, 0x21, "Puck"},
+    {0, 0x22, "Finger"},
+    {0, 0x30, "TipPressure"},
+    {0, 0x31, "BarrelPressure"},
+    {0, 0x32, "InRange"},
+    {0, 0x33, "Touch"},
+    {0, 0x34, "UnTouch"},
+    {0, 0x35, "Tap"},
+    {0, 0x39, "TabletFunctionKey"},
+    {0, 0x3a, "ProgramChangeKey"},
+    {0, 0x3c, "Invert"},
+    {0, 0x42, "TipSwitch"},
+    {0, 0x43, "SecondaryTipSwitch"},
+    {0, 0x44, "BarrelSwitch"},
+    {0, 0x45, "Eraser"},
+    {0, 0x46, "TabletPick"},
+  { 15, 0, "PhysicalInterfaceDevice" },
+    {0, 0x00, "Undefined"},
+    {0, 0x01, "Physical_Interface_Device"},
+      {0, 0x20, "Normal"},
+    {0, 0x21, "Set_Effect_Report"},
+      {0, 0x22, "Effect_Block_Index"},
+      {0, 0x23, "Parameter_Block_Offset"},
+      {0, 0x24, "ROM_Flag"},
+      {0, 0x25, "Effect_Type"},
+        {0, 0x26, "ET_Constant_Force"},
+        {0, 0x27, "ET_Ramp"},
+        {0, 0x28, "ET_Custom_Force_Data"},
+        {0, 0x30, "ET_Square"},
+        {0, 0x31, "ET_Sine"},
+        {0, 0x32, "ET_Triangle"},
+        {0, 0x33, "ET_Sawtooth_Up"},
+        {0, 0x34, "ET_Sawtooth_Down"},
+        {0, 0x40, "ET_Spring"},
+        {0, 0x41, "ET_Damper"},
+        {0, 0x42, "ET_Inertia"},
+        {0, 0x43, "ET_Friction"},
+      {0, 0x50, "Duration"},
+      {0, 0x51, "Sample_Period"},
+      {0, 0x52, "Gain"},
+      {0, 0x53, "Trigger_Button"},
+      {0, 0x54, "Trigger_Repeat_Interval"},
+      {0, 0x55, "Axes_Enable"},
+        {0, 0x56, "Direction_Enable"},
+      {0, 0x57, "Direction"},
+      {0, 0x58, "Type_Specific_Block_Offset"},
+        {0, 0x59, "Block_Type"},
+        {0, 0x5A, "Set_Envelope_Report"},
+          {0, 0x5B, "Attack_Level"},
+          {0, 0x5C, "Attack_Time"},
+          {0, 0x5D, "Fade_Level"},
+          {0, 0x5E, "Fade_Time"},
+        {0, 0x5F, "Set_Condition_Report"},
+        {0, 0x60, "CP_Offset"},
+        {0, 0x61, "Positive_Coefficient"},
+        {0, 0x62, "Negative_Coefficient"},
+        {0, 0x63, "Positive_Saturation"},
+        {0, 0x64, "Negative_Saturation"},
+        {0, 0x65, "Dead_Band"},
+      {0, 0x66, "Download_Force_Sample"},
+      {0, 0x67, "Isoch_Custom_Force_Enable"},
+      {0, 0x68, "Custom_Force_Data_Report"},
+        {0, 0x69, "Custom_Force_Data"},
+        {0, 0x6A, "Custom_Force_Vendor_Defined_Data"},
+      {0, 0x6B, "Set_Custom_Force_Report"},
+        {0, 0x6C, "Custom_Force_Data_Offset"},
+        {0, 0x6D, "Sample_Count"},
+      {0, 0x6E, "Set_Periodic_Report"},
+        {0, 0x6F, "Offset"},
+        {0, 0x70, "Magnitude"},
+        {0, 0x71, "Phase"},
+        {0, 0x72, "Period"},
+      {0, 0x73, "Set_Constant_Force_Report"},
+        {0, 0x74, "Set_Ramp_Force_Report"},
+        {0, 0x75, "Ramp_Start"},
+        {0, 0x76, "Ramp_End"},
+      {0, 0x77, "Effect_Operation_Report"},
+        {0, 0x78, "Effect_Operation"},
+          {0, 0x79, "Op_Effect_Start"},
+          {0, 0x7A, "Op_Effect_Start_Solo"},
+          {0, 0x7B, "Op_Effect_Stop"},
+          {0, 0x7C, "Loop_Count"},
+      {0, 0x7D, "Device_Gain_Report"},
+        {0, 0x7E, "Device_Gain"},
+    {0, 0x7F, "PID_Pool_Report"},
+      {0, 0x80, "RAM_Pool_Size"},
+      {0, 0x81, "ROM_Pool_Size"},
+      {0, 0x82, "ROM_Effect_Block_Count"},
+      {0, 0x83, "Simultaneous_Effects_Max"},
+      {0, 0x84, "Pool_Alignment"},
+    {0, 0x85, "PID_Pool_Move_Report"},
+      {0, 0x86, "Move_Source"},
+      {0, 0x87, "Move_Destination"},
+      {0, 0x88, "Move_Length"},
+    {0, 0x89, "PID_Block_Load_Report"},
+      {0, 0x8B, "Block_Load_Status"},
+      {0, 0x8C, "Block_Load_Success"},
+      {0, 0x8D, "Block_Load_Full"},
+      {0, 0x8E, "Block_Load_Error"},
+      {0, 0x8F, "Block_Handle"},
+      {0, 0x90, "PID_Block_Free_Report"},
+      {0, 0x91, "Type_Specific_Block_Handle"},
+    {0, 0x92, "PID_State_Report"},
+      {0, 0x94, "Effect_Playing"},
+      {0, 0x95, "PID_Device_Control_Report"},
+        {0, 0x96, "PID_Device_Control"},
+        {0, 0x97, "DC_Enable_Actuators"},
+        {0, 0x98, "DC_Disable_Actuators"},
+        {0, 0x99, "DC_Stop_All_Effects"},
+        {0, 0x9A, "DC_Device_Reset"},
+        {0, 0x9B, "DC_Device_Pause"},
+        {0, 0x9C, "DC_Device_Continue"},
+      {0, 0x9F, "Device_Paused"},
+      {0, 0xA0, "Actuators_Enabled"},
+      {0, 0xA4, "Safety_Switch"},
+      {0, 0xA5, "Actuator_Override_Switch"},
+      {0, 0xA6, "Actuator_Power"},
+    {0, 0xA7, "Start_Delay"},
+    {0, 0xA8, "Parameter_Block_Size"},
+    {0, 0xA9, "Device_Managed_Pool"},
+    {0, 0xAA, "Shared_Parameter_Blocks"},
+    {0, 0xAB, "Create_New_Effect_Report"},
+    {0, 0xAC, "RAM_Pool_Available"},
+  { 0x84, 0, "Power Device" },
+    { 0x84, 0x02, "PresentStatus" },
+    { 0x84, 0x03, "ChangeStatus" },
+    { 0x84, 0x04, "UPS" },
+    { 0x84, 0x05, "PowerSupply" },
+    { 0x84, 0x10, "BatterySystem" },
+    { 0x84, 0x11, "BatterySystemID" },
+    { 0x84, 0x12, "Battery" },
+    { 0x84, 0x13, "BatteryID" },
+    { 0x84, 0x14, "Charger" },
+    { 0x84, 0x15, "ChargerID" },
+    { 0x84, 0x16, "PowerConverter" },
+    { 0x84, 0x17, "PowerConverterID" },
+    { 0x84, 0x18, "OutletSystem" },
+    { 0x84, 0x19, "OutletSystemID" },
+    { 0x84, 0x1a, "Input" },
+    { 0x84, 0x1b, "InputID" },
+    { 0x84, 0x1c, "Output" },
+    { 0x84, 0x1d, "OutputID" },
+    { 0x84, 0x1e, "Flow" },
+    { 0x84, 0x1f, "FlowID" },
+    { 0x84, 0x20, "Outlet" },
+    { 0x84, 0x21, "OutletID" },
+    { 0x84, 0x22, "Gang" },
+    { 0x84, 0x24, "PowerSummary" },
+    { 0x84, 0x25, "PowerSummaryID" },
+    { 0x84, 0x30, "Voltage" },
+    { 0x84, 0x31, "Current" },
+    { 0x84, 0x32, "Frequency" },
+    { 0x84, 0x33, "ApparentPower" },
+    { 0x84, 0x35, "PercentLoad" },
+    { 0x84, 0x40, "ConfigVoltage" },
+    { 0x84, 0x41, "ConfigCurrent" },
+    { 0x84, 0x43, "ConfigApparentPower" },
+    { 0x84, 0x53, "LowVoltageTransfer" },
+    { 0x84, 0x54, "HighVoltageTransfer" },
+    { 0x84, 0x56, "DelayBeforeStartup" },
+    { 0x84, 0x57, "DelayBeforeShutdown" },
+    { 0x84, 0x58, "Test" },
+    { 0x84, 0x5a, "AudibleAlarmControl" },
+    { 0x84, 0x60, "Present" },
+    { 0x84, 0x61, "Good" },
+    { 0x84, 0x62, "InternalFailure" },
+    { 0x84, 0x65, "Overload" },
+    { 0x84, 0x66, "OverCharged" },
+    { 0x84, 0x67, "OverTemperature" },
+    { 0x84, 0x68, "ShutdownRequested" },
+    { 0x84, 0x69, "ShutdownImminent" },
+    { 0x84, 0x6b, "SwitchOn/Off" },
+    { 0x84, 0x6c, "Switchable" },
+    { 0x84, 0x6d, "Used" },
+    { 0x84, 0x6e, "Boost" },
+    { 0x84, 0x73, "CommunicationLost" },
+    { 0x84, 0xfd, "iManufacturer" },
+    { 0x84, 0xfe, "iProduct" },
+    { 0x84, 0xff, "iSerialNumber" },
+  { 0x85, 0, "Battery System" },
+    { 0x85, 0x01, "SMBBatteryMode" },
+    { 0x85, 0x02, "SMBBatteryStatus" },
+    { 0x85, 0x03, "SMBAlarmWarning" },
+    { 0x85, 0x04, "SMBChargerMode" },
+    { 0x85, 0x05, "SMBChargerStatus" },
+    { 0x85, 0x06, "SMBChargerSpecInfo" },
+    { 0x85, 0x07, "SMBSelectorState" },
+    { 0x85, 0x08, "SMBSelectorPresets" },
+    { 0x85, 0x09, "SMBSelectorInfo" },
+    { 0x85, 0x29, "RemainingCapacityLimit" },
+    { 0x85, 0x2c, "CapacityMode" },
+    { 0x85, 0x42, "BelowRemainingCapacityLimit" },
+    { 0x85, 0x44, "Charging" },
+    { 0x85, 0x45, "Discharging" },
+    { 0x85, 0x4b, "NeedReplacement" },
+    { 0x85, 0x66, "RemainingCapacity" },
+    { 0x85, 0x68, "RunTimeToEmpty" },
+    { 0x85, 0x6a, "AverageTimeToFull" },
+    { 0x85, 0x83, "DesignCapacity" },
+    { 0x85, 0x85, "ManufacturerDate" },
+    { 0x85, 0x89, "iDeviceChemistry" },
+    { 0x85, 0x8b, "Rechargable" },
+    { 0x85, 0x8f, "iOEMInformation" },
+    { 0x85, 0x8d, "CapacityGranularity1" },
+    { 0x85, 0xd0, "ACPresent" },
+  /* pages 0xff00 to 0xffff are vendor-specific */
+  { 0xffff, 0, "Vendor-specific-FF" },
+  { 0, 0, NULL }
+};
+static void resolv_usage_page(unsigned page) {
+        const struct hid_usage_entry *p;
+        for (p = hid_usage_table; p->description; p++)
+                if (p->page == page) {
+                        printk("%s", p->description);
+                        return;
+                }
+        printk("%04x", page);
+}
+void hid_resolv_usage(unsigned usage) {
+        const struct hid_usage_entry *p;
+        resolv_usage_page(usage >> 16);
+        printk(".");
+        for (p = hid_usage_table; p->description; p++)
+                if (p->page == (usage >> 16)) {
+                        for(++p; p->description && p->usage != 0; p++)
+                                if (p->usage == (usage & 0xffff)) {
+                                        printk("%s", p->description);
+                                        return;
+                                }
+                        break;
+                }
+        printk("%04x", usage & 0xffff);
+}
+EXPORT_SYMBOL_GPL(hid_resolv_usage);
+__inline__ static void tab(int n) {
+        while (n--) printk(" ");
+}
+void hid_dump_field(struct hid_field *field, int n) {
+        int j;
+        if (field->physical) {
+                tab(n);
+                printk("Physical(");
+                hid_resolv_usage(field->physical); printk(")\n");
+        }
+        if (field->logical) {
+                tab(n);
+                printk("Logical(");
+                hid_resolv_usage(field->logical); printk(")\n");
+        }
+        tab(n); printk("Usage(%d)\n", field->maxusage);
+        for (j = 0; j < field->maxusage; j++) {
+                tab(n+2); hid_resolv_usage(field->usage[j].hid); printk("\n");
+        }
+        if (field->logical_minimum != field->logical_maximum) {
+                tab(n); printk("Logical Minimum(%d)\n", field->logical_minimum);
+                tab(n); printk("Logical Maximum(%d)\n", field->logical_maximum);
+        }
+        if (field->physical_minimum != field->physical_maximum) {
+                tab(n); printk("Physical Minimum(%d)\n", field->physical_minimum);
+                tab(n); printk("Physical Maximum(%d)\n", field->physical_maximum);
+        }
+        if (field->unit_exponent) {
+                tab(n); printk("Unit Exponent(%d)\n", field->unit_exponent);
+        }
+        if (field->unit) {
+                char *systems[5] = { "None", "SI Linear", "SI Rotation", "English Linear", "English Rotation" };
+                char *units[5][8] = {
+                        { "None", "None", "None", "None", "None", "None", "None", "None" },
+                        { "None", "Centimeter", "Gram", "Seconds", "Kelvin",     "Ampere", "Candela", "None" },
+                        { "None", "Radians",    "Gram", "Seconds", "Kelvin",     "Ampere", "Candela", "None" },
+                        { "None", "Inch",       "Slug", "Seconds", "Fahrenheit", "Ampere", "Candela", "None" },
+                        { "None", "Degrees",    "Slug", "Seconds", "Fahrenheit", "Ampere", "Candela", "None" }
+                };
+                int i;
+                int sys;
+                __u32 data = field->unit;
+                /* First nibble tells us which system we're in. */
+                sys = data & 0xf;
+                data >>= 4;
+                if(sys > 4) {
+                        tab(n); printk("Unit(Invalid)\n");
+                }
+                else {
+                        int earlier_unit = 0;
+                        tab(n); printk("Unit(%s : ", systems[sys]);
+                        for (i=1 ; i<sizeof(__u32)*2 ; i++) {
+                                char nibble = data & 0xf;
+                                data >>= 4;
+                                if (nibble != 0) {
+                                        if(earlier_unit++ > 0)
+                                                printk("*");
+                                        printk("%s", units[sys][i]);
+                                        if(nibble != 1) {
+                                                /* This is a _signed_ nibble(!) */
+                                                int val = nibble & 0x7;
+                                                if(nibble & 0x08)
+                                                        val = -((0x7 & ~val) +1);
+                                                printk("^%d", val);
+                                        }
+                                }
+                        }
+                        printk(")\n");
+                }
+        }
+        tab(n); printk("Report Size(%u)\n", field->report_size);
+        tab(n); printk("Report Count(%u)\n", field->report_count);
+        tab(n); printk("Report Offset(%u)\n", field->report_offset);
+        tab(n); printk("Flags( ");
+        j = field->flags;
+        printk("%s", HID_MAIN_ITEM_CONSTANT & j ? "Constant " : "");
+        printk("%s", HID_MAIN_ITEM_VARIABLE & j ? "Variable " : "Array ");
+        printk("%s", HID_MAIN_ITEM_RELATIVE & j ? "Relative " : "Absolute ");
+        printk("%s", HID_MAIN_ITEM_WRAP & j ? "Wrap " : "");
+        printk("%s", HID_MAIN_ITEM_NONLINEAR & j ? "NonLinear " : "");
+        printk("%s", HID_MAIN_ITEM_NO_PREFERRED & j ? "NoPrefferedState " : "");
+        printk("%s", HID_MAIN_ITEM_NULL_STATE & j ? "NullState " : "");
+        printk("%s", HID_MAIN_ITEM_VOLATILE & j ? "Volatile " : "");
+        printk("%s", HID_MAIN_ITEM_BUFFERED_BYTE & j ? "BufferedByte " : "");
+        printk(")\n");
+}
+EXPORT_SYMBOL_GPL(hid_dump_field);
+void hid_dump_device(struct hid_device *device) {
+        struct hid_report_enum *report_enum;
+        struct hid_report *report;
+        struct list_head *list;
+        unsigned i,k;
+        static char *table[] = {"INPUT", "OUTPUT", "FEATURE"};
+        for (i = 0; i < HID_REPORT_TYPES; i++) {
+                report_enum = device->report_enum + i;
+                list = report_enum->report_list.next;
+                while (list != &report_enum->report_list) {
+                        report = (struct hid_report *) list;
+                        tab(2);
+                        printk("%s", table[i]);
+                        if (report->id)
+                                printk("(%d)", report->id);
+                        printk("[%s]", table[report->type]);
+                        printk("\n");
+                        for (k = 0; k < report->maxfield; k++) {
+                                tab(4);
+                                printk("Field(%d)\n", k);
+                                hid_dump_field(report->field[k], 6);
+                        }
+                        list = list->next;
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(hid_dump_device);
+void hid_dump_input(struct hid_usage *usage, __s32 value) {
+        printk("hid-debug: input ");
+        hid_resolv_usage(usage->hid);
+        printk(" = %d\n", value);
+}
+EXPORT_SYMBOL_GPL(hid_dump_input);
+static char *events[EV_MAX + 1] = {
+        [EV_SYN] = "Sync",                      [EV_KEY] = "Key",
+        [EV_REL] = "Relative",                  [EV_ABS] = "Absolute",
+        [EV_MSC] = "Misc",                      [EV_LED] = "LED",
+        [EV_SND] = "Sound",                     [EV_REP] = "Repeat",
+        [EV_FF] = "ForceFeedback",              [EV_PWR] = "Power",
+        [EV_FF_STATUS] = "ForceFeedbackStatus",
+};
+static char *syncs[2] = {
+        [SYN_REPORT] = "Report",                [SYN_CONFIG] = "Config",
+};
+static char *keys[KEY_MAX + 1] = {
+        [KEY_RESERVED] = "Reserved",            [KEY_ESC] = "Esc",
+        [KEY_1] = "1",                          [KEY_2] = "2",
+        [KEY_3] = "3",                          [KEY_4] = "4",
+        [KEY_5] = "5",                          [KEY_6] = "6",
+        [KEY_7] = "7",                          [KEY_8] = "8",
+        [KEY_9] = "9",                          [KEY_0] = "0",
+        [KEY_MINUS] = "Minus",                  [KEY_EQUAL] = "Equal",
+        [KEY_BACKSPACE] = "Backspace",          [KEY_TAB] = "Tab",
+        [KEY_Q] = "Q",                          [KEY_W] = "W",
+        [KEY_E] = "E",                          [KEY_R] = "R",
+        [KEY_T] = "T",                          [KEY_Y] = "Y",
+        [KEY_U] = "U",                          [KEY_I] = "I",
+        [KEY_O] = "O",                          [KEY_P] = "P",
+        [KEY_LEFTBRACE] = "LeftBrace",          [KEY_RIGHTBRACE] = "RightBrace",
+        [KEY_ENTER] = "Enter",                  [KEY_LEFTCTRL] = "LeftControl",
+        [KEY_A] = "A",                          [KEY_S] = "S",
+        [KEY_D] = "D",                          [KEY_F] = "F",
+        [KEY_G] = "G",                          [KEY_H] = "H",
+        [KEY_J] = "J",                          [KEY_K] = "K",
+        [KEY_L] = "L",                          [KEY_SEMICOLON] = "Semicolon",
+        [KEY_APOSTROPHE] = "Apostrophe",        [KEY_GRAVE] = "Grave",
+        [KEY_LEFTSHIFT] = "LeftShift",          [KEY_BACKSLASH] = "BackSlash",
+        [KEY_Z] = "Z",                          [KEY_X] = "X",
+        [KEY_C] = "C",                          [KEY_V] = "V",
+        [KEY_B] = "B",                          [KEY_N] = "N",
+        [KEY_M] = "M",                          [KEY_COMMA] = "Comma",
+        [KEY_DOT] = "Dot",                      [KEY_SLASH] = "Slash",
+        [KEY_RIGHTSHIFT] = "RightShift",        [KEY_KPASTERISK] = "KPAsterisk",
+        [KEY_LEFTALT] = "LeftAlt",              [KEY_SPACE] = "Space",
+        [KEY_CAPSLOCK] = "CapsLock",            [KEY_F1] = "F1",
+        [KEY_F2] = "F2",                        [KEY_F3] = "F3",
+        [KEY_F4] = "F4",                        [KEY_F5] = "F5",
+        [KEY_F6] = "F6",                        [KEY_F7] = "F7",
+        [KEY_F8] = "F8",                        [KEY_F9] = "F9",
+        [KEY_F10] = "F10",                      [KEY_NUMLOCK] = "NumLock",
+        [KEY_SCROLLLOCK] = "ScrollLock",        [KEY_KP7] = "KP7",
+        [KEY_KP8] = "KP8",                      [KEY_KP9] = "KP9",
+        [KEY_KPMINUS] = "KPMinus",              [KEY_KP4] = "KP4",
+        [KEY_KP5] = "KP5",                      [KEY_KP6] = "KP6",
+        [KEY_KPPLUS] = "KPPlus",                [KEY_KP1] = "KP1",
+        [KEY_KP2] = "KP2",                      [KEY_KP3] = "KP3",
+        [KEY_KP0] = "KP0",                      [KEY_KPDOT] = "KPDot",
+        [KEY_ZENKAKUHANKAKU] = "Zenkaku/Hankaku", [KEY_102ND] = "102nd",
+        [KEY_F11] = "F11",                      [KEY_F12] = "F12",
+        [KEY_RO] = "RO",                        [KEY_KATAKANA] = "Katakana",
+        [KEY_HIRAGANA] = "HIRAGANA",            [KEY_HENKAN] = "Henkan",
+        [KEY_KATAKANAHIRAGANA] = "Katakana/Hiragana", [KEY_MUHENKAN] = "Muhenkan",
+        [KEY_KPJPCOMMA] = "KPJpComma",          [KEY_KPENTER] = "KPEnter",
+        [KEY_RIGHTCTRL] = "RightCtrl",          [KEY_KPSLASH] = "KPSlash",
+        [KEY_SYSRQ] = "SysRq",                  [KEY_RIGHTALT] = "RightAlt",
+        [KEY_LINEFEED] = "LineFeed",            [KEY_HOME] = "Home",
+        [KEY_UP] = "Up",                        [KEY_PAGEUP] = "PageUp",
+        [KEY_LEFT] = "Left",                    [KEY_RIGHT] = "Right",
+        [KEY_END] = "End",                      [KEY_DOWN] = "Down",
+        [KEY_PAGEDOWN] = "PageDown",            [KEY_INSERT] = "Insert",
+        [KEY_DELETE] = "Delete",                [KEY_MACRO] = "Macro",
+        [KEY_MUTE] = "Mute",                    [KEY_VOLUMEDOWN] = "VolumeDown",
+        [KEY_VOLUMEUP] = "VolumeUp",            [KEY_POWER] = "Power",
+        [KEY_KPEQUAL] = "KPEqual",              [KEY_KPPLUSMINUS] = "KPPlusMinus",
+        [KEY_PAUSE] = "Pause",                  [KEY_KPCOMMA] = "KPComma",
+        [KEY_HANGUEL] = "Hangeul",              [KEY_HANJA] = "Hanja",
+        [KEY_YEN] = "Yen",                      [KEY_LEFTMETA] = "LeftMeta",
+        [KEY_RIGHTMETA] = "RightMeta",          [KEY_COMPOSE] = "Compose",
+        [KEY_STOP] = "Stop",                    [KEY_AGAIN] = "Again",
+        [KEY_PROPS] = "Props",                  [KEY_UNDO] = "Undo",
+        [KEY_FRONT] = "Front",                  [KEY_COPY] = "Copy",
+        [KEY_OPEN] = "Open",                    [KEY_PASTE] = "Paste",
+        [KEY_FIND] = "Find",                    [KEY_CUT] = "Cut",
+        [KEY_HELP] = "Help",                    [KEY_MENU] = "Menu",
+        [KEY_CALC] = "Calc",                    [KEY_SETUP] = "Setup",
+        [KEY_SLEEP] = "Sleep",                  [KEY_WAKEUP] = "WakeUp",
+        [KEY_FILE] = "File",                    [KEY_SENDFILE] = "SendFile",
+        [KEY_DELETEFILE] = "DeleteFile",        [KEY_XFER] = "X-fer",
+        [KEY_PROG1] = "Prog1",                  [KEY_PROG2] = "Prog2",
+        [KEY_WWW] = "WWW",                      [KEY_MSDOS] = "MSDOS",
+        [KEY_COFFEE] = "Coffee",                [KEY_DIRECTION] = "Direction",
+        [KEY_CYCLEWINDOWS] = "CycleWindows",    [KEY_MAIL] = "Mail",
+        [KEY_BOOKMARKS] = "Bookmarks",          [KEY_COMPUTER] = "Computer",
+        [KEY_BACK] = "Back",                    [KEY_FORWARD] = "Forward",
+        [KEY_CLOSECD] = "CloseCD",              [KEY_EJECTCD] = "EjectCD",
+        [KEY_EJECTCLOSECD] = "EjectCloseCD",    [KEY_NEXTSONG] = "NextSong",
+        [KEY_PLAYPAUSE] = "PlayPause",          [KEY_PREVIOUSSONG] = "PreviousSong",
+        [KEY_STOPCD] = "StopCD",                [KEY_RECORD] = "Record",
+        [KEY_REWIND] = "Rewind",                [KEY_PHONE] = "Phone",
+        [KEY_ISO] = "ISOKey",                   [KEY_CONFIG] = "Config",
+        [KEY_HOMEPAGE] = "HomePage",            [KEY_REFRESH] = "Refresh",
+        [KEY_EXIT] = "Exit",                    [KEY_MOVE] = "Move",
+        [KEY_EDIT] = "Edit",                    [KEY_SCROLLUP] = "ScrollUp",
+        [KEY_SCROLLDOWN] = "ScrollDown",        [KEY_KPLEFTPAREN] = "KPLeftParenthesis",
+        [KEY_KPRIGHTPAREN] = "KPRightParenthesis", [KEY_NEW] = "New",
+        [KEY_REDO] = "Redo",                    [KEY_F13] = "F13",
+        [KEY_F14] = "F14",                      [KEY_F15] = "F15",
+        [KEY_F16] = "F16",                      [KEY_F17] = "F17",
+        [KEY_F18] = "F18",                      [KEY_F19] = "F19",
+        [KEY_F20] = "F20",                      [KEY_F21] = "F21",
+        [KEY_F22] = "F22",                      [KEY_F23] = "F23",
+        [KEY_F24] = "F24",                      [KEY_PLAYCD] = "PlayCD",
+        [KEY_PAUSECD] = "PauseCD",              [KEY_PROG3] = "Prog3",
+        [KEY_PROG4] = "Prog4",                  [KEY_SUSPEND] = "Suspend",
+        [KEY_CLOSE] = "Close",                  [KEY_PLAY] = "Play",
+        [KEY_FASTFORWARD] = "FastForward",      [KEY_BASSBOOST] = "BassBoost",
+        [KEY_PRINT] = "Print",                  [KEY_HP] = "HP",
+        [KEY_CAMERA] = "Camera",                [KEY_SOUND] = "Sound",
+        [KEY_QUESTION] = "Question",            [KEY_EMAIL] = "Email",
+        [KEY_CHAT] = "Chat",                    [KEY_SEARCH] = "Search",
+        [KEY_CONNECT] = "Connect",              [KEY_FINANCE] = "Finance",
+        [KEY_SPORT] = "Sport",                  [KEY_SHOP] = "Shop",
+        [KEY_ALTERASE] = "AlternateErase",      [KEY_CANCEL] = "Cancel",
+        [KEY_BRIGHTNESSDOWN] = "BrightnessDown", [KEY_BRIGHTNESSUP] = "BrightnessUp",
+        [KEY_MEDIA] = "Media",                  [KEY_UNKNOWN] = "Unknown",
+        [BTN_0] = "Btn0",                       [BTN_1] = "Btn1",
+        [BTN_2] = "Btn2",                       [BTN_3] = "Btn3",
+        [BTN_4] = "Btn4",                       [BTN_5] = "Btn5",
+        [BTN_6] = "Btn6",                       [BTN_7] = "Btn7",
+        [BTN_8] = "Btn8",                       [BTN_9] = "Btn9",
+        [BTN_LEFT] = "LeftBtn",                 [BTN_RIGHT] = "RightBtn",
+        [BTN_MIDDLE] = "MiddleBtn",             [BTN_SIDE] = "SideBtn",
+        [BTN_EXTRA] = "ExtraBtn",               [BTN_FORWARD] = "ForwardBtn",
+        [BTN_BACK] = "BackBtn",                 [BTN_TASK] = "TaskBtn",
+        [BTN_TRIGGER] = "Trigger",              [BTN_THUMB] = "ThumbBtn",
+        [BTN_THUMB2] = "ThumbBtn2",             [BTN_TOP] = "TopBtn",
+        [BTN_TOP2] = "TopBtn2",                 [BTN_PINKIE] = "PinkieBtn",
+        [BTN_BASE] = "BaseBtn",                 [BTN_BASE2] = "BaseBtn2",
+        [BTN_BASE3] = "BaseBtn3",               [BTN_BASE4] = "BaseBtn4",
+        [BTN_BASE5] = "BaseBtn5",               [BTN_BASE6] = "BaseBtn6",
+        [BTN_DEAD] = "BtnDead",                 [BTN_A] = "BtnA",
+        [BTN_B] = "BtnB",                       [BTN_C] = "BtnC",
+        [BTN_X] = "BtnX",                       [BTN_Y] = "BtnY",
+        [BTN_Z] = "BtnZ",                       [BTN_TL] = "BtnTL",
+        [BTN_TR] = "BtnTR",                     [BTN_TL2] = "BtnTL2",
+        [BTN_TR2] = "BtnTR2",                   [BTN_SELECT] = "BtnSelect",
+        [BTN_START] = "BtnStart",               [BTN_MODE] = "BtnMode",
+        [BTN_THUMBL] = "BtnThumbL",             [BTN_THUMBR] = "BtnThumbR",
+        [BTN_TOOL_PEN] = "ToolPen",             [BTN_TOOL_RUBBER] = "ToolRubber",
+        [BTN_TOOL_BRUSH] = "ToolBrush",         [BTN_TOOL_PENCIL] = "ToolPencil",
+        [BTN_TOOL_AIRBRUSH] = "ToolAirbrush",   [BTN_TOOL_FINGER] = "ToolFinger",
+        [BTN_TOOL_MOUSE] = "ToolMouse",         [BTN_TOOL_LENS] = "ToolLens",
+        [BTN_TOUCH] = "Touch",                  [BTN_STYLUS] = "Stylus",
+        [BTN_STYLUS2] = "Stylus2",              [BTN_TOOL_DOUBLETAP] = "ToolDoubleTap",
+        [BTN_TOOL_TRIPLETAP] = "ToolTripleTap", [BTN_GEAR_DOWN] = "WheelBtn",
+        [BTN_GEAR_UP] = "Gear up",              [KEY_OK] = "Ok",
+        [KEY_SELECT] = "Select",                [KEY_GOTO] = "Goto",
+        [KEY_CLEAR] = "Clear",                  [KEY_POWER2] = "Power2",
+        [KEY_OPTION] = "Option",                [KEY_INFO] = "Info",
+        [KEY_TIME] = "Time",                    [KEY_VENDOR] = "Vendor",
+        [KEY_ARCHIVE] = "Archive",              [KEY_PROGRAM] = "Program",
+        [KEY_CHANNEL] = "Channel",              [KEY_FAVORITES] = "Favorites",
+        [KEY_EPG] = "EPG",                      [KEY_PVR] = "PVR",
+        [KEY_MHP] = "MHP",                      [KEY_LANGUAGE] = "Language",
+        [KEY_TITLE] = "Title",                  [KEY_SUBTITLE] = "Subtitle",
+        [KEY_ANGLE] = "Angle",                  [KEY_ZOOM] = "Zoom",
+        [KEY_MODE] = "Mode",                    [KEY_KEYBOARD] = "Keyboard",
+        [KEY_SCREEN] = "Screen",                [KEY_PC] = "PC",
+        [KEY_TV] = "TV",                        [KEY_TV2] = "TV2",
+        [KEY_VCR] = "VCR",                      [KEY_VCR2] = "VCR2",
+        [KEY_SAT] = "Sat",                      [KEY_SAT2] = "Sat2",
+        [KEY_CD] = "CD",                        [KEY_TAPE] = "Tape",
+        [KEY_RADIO] = "Radio",                  [KEY_TUNER] = "Tuner",
+        [KEY_PLAYER] = "Player",                [KEY_TEXT] = "Text",
+        [KEY_DVD] = "DVD",                      [KEY_AUX] = "Aux",
+        [KEY_MP3] = "MP3",                      [KEY_AUDIO] = "Audio",
+        [KEY_VIDEO] = "Video",                  [KEY_DIRECTORY] = "Directory",
+        [KEY_LIST] = "List",                    [KEY_MEMO] = "Memo",
+        [KEY_CALENDAR] = "Calendar",            [KEY_RED] = "Red",
+        [KEY_GREEN] = "Green",                  [KEY_YELLOW] = "Yellow",
+        [KEY_BLUE] = "Blue",                    [KEY_CHANNELUP] = "ChannelUp",
+        [KEY_CHANNELDOWN] = "ChannelDown",      [KEY_FIRST] = "First",
+        [KEY_LAST] = "Last",                    [KEY_AB] = "AB",
+        [KEY_NEXT] = "Next",                    [KEY_RESTART] = "Restart",
+        [KEY_SLOW] = "Slow",                    [KEY_SHUFFLE] = "Shuffle",
+        [KEY_BREAK] = "Break",                  [KEY_PREVIOUS] = "Previous",
+        [KEY_DIGITS] = "Digits",                [KEY_TEEN] = "TEEN",
+        [KEY_TWEN] = "TWEN",                    [KEY_DEL_EOL] = "DeleteEOL",
+        [KEY_DEL_EOS] = "DeleteEOS",            [KEY_INS_LINE] = "InsertLine",
+        [KEY_DEL_LINE] = "DeleteLine",
+        [KEY_SEND] = "Send",                    [KEY_REPLY] = "Reply",
+        [KEY_FORWARDMAIL] = "ForwardMail",      [KEY_SAVE] = "Save",
+        [KEY_DOCUMENTS] = "Documents",
+        [KEY_FN] = "Fn",                        [KEY_FN_ESC] = "Fn+ESC",
+        [KEY_FN_1] = "Fn+1",                    [KEY_FN_2] = "Fn+2",
+        [KEY_FN_B] = "Fn+B",                    [KEY_FN_D] = "Fn+D",
+        [KEY_FN_E] = "Fn+E",                    [KEY_FN_F] = "Fn+F",
+        [KEY_FN_S] = "Fn+S",
+        [KEY_FN_F1] = "Fn+F1",                  [KEY_FN_F2] = "Fn+F2",
+        [KEY_FN_F3] = "Fn+F3",                  [KEY_FN_F4] = "Fn+F4",
+        [KEY_FN_F5] = "Fn+F5",                  [KEY_FN_F6] = "Fn+F6",
+        [KEY_FN_F7] = "Fn+F7",                  [KEY_FN_F8] = "Fn+F8",
+        [KEY_FN_F9] = "Fn+F9",                  [KEY_FN_F10] = "Fn+F10",
+        [KEY_FN_F11] = "Fn+F11",                [KEY_FN_F12] = "Fn+F12",
+        [KEY_KBDILLUMTOGGLE] = "KbdIlluminationToggle",
+        [KEY_KBDILLUMDOWN] = "KbdIlluminationDown",
+        [KEY_KBDILLUMUP] = "KbdIlluminationUp",
+        [KEY_SWITCHVIDEOMODE] = "SwitchVideoMode",
+};
+static char *relatives[REL_MAX + 1] = {
+        [REL_X] = "X",                  [REL_Y] = "Y",
+        [REL_Z] = "Z",                  [REL_RX] = "Rx",
+        [REL_RY] = "Ry",                [REL_RZ] = "Rz",
+        [REL_HWHEEL] = "HWheel",        [REL_DIAL] = "Dial",
+        [REL_WHEEL] = "Wheel",          [REL_MISC] = "Misc",
+};
+static char *absolutes[ABS_MAX + 1] = {
+        [ABS_X] = "X",                  [ABS_Y] = "Y",
+        [ABS_Z] = "Z",                  [ABS_RX] = "Rx",
+        [ABS_RY] = "Ry",                [ABS_RZ] = "Rz",
+        [ABS_THROTTLE] = "Throttle",    [ABS_RUDDER] = "Rudder",
+        [ABS_WHEEL] = "Wheel",          [ABS_GAS] = "Gas",
+        [ABS_BRAKE] = "Brake",          [ABS_HAT0X] = "Hat0X",
+        [ABS_HAT0Y] = "Hat0Y",          [ABS_HAT1X] = "Hat1X",
+        [ABS_HAT1Y] = "Hat1Y",          [ABS_HAT2X] = "Hat2X",
+        [ABS_HAT2Y] = "Hat2Y",          [ABS_HAT3X] = "Hat3X",
+        [ABS_HAT3Y] = "Hat 3Y",         [ABS_PRESSURE] = "Pressure",
+        [ABS_DISTANCE] = "Distance",    [ABS_TILT_X] = "XTilt",
+        [ABS_TILT_Y] = "YTilt",         [ABS_TOOL_WIDTH] = "Tool Width",
+        [ABS_VOLUME] = "Volume",        [ABS_MISC] = "Misc",
+};
+static char *misc[MSC_MAX + 1] = {
+        [MSC_SERIAL] = "Serial",        [MSC_PULSELED] = "Pulseled",
+        [MSC_GESTURE] = "Gesture",      [MSC_RAW] = "RawData"
+};
+static char *leds[LED_MAX + 1] = {
+        [LED_NUML] = "NumLock",         [LED_CAPSL] = "CapsLock",
+        [LED_SCROLLL] = "ScrollLock",   [LED_COMPOSE] = "Compose",
+        [LED_KANA] = "Kana",            [LED_SLEEP] = "Sleep",
+        [LED_SUSPEND] = "Suspend",      [LED_MUTE] = "Mute",
+        [LED_MISC] = "Misc",
+};
+static char *repeats[REP_MAX + 1] = {
+        [REP_DELAY] = "Delay",          [REP_PERIOD] = "Period"
+};
+static char *sounds[SND_MAX + 1] = {
+        [SND_CLICK] = "Click",          [SND_BELL] = "Bell",
+        [SND_TONE] = "Tone"
+};
+static char **names[EV_MAX + 1] = {
+        [EV_SYN] = syncs,                       [EV_KEY] = keys,
+        [EV_REL] = relatives,                   [EV_ABS] = absolutes,
+        [EV_MSC] = misc,                        [EV_LED] = leds,
+        [EV_SND] = sounds,                      [EV_REP] = repeats,
+};
+void hid_resolv_event(__u8 type, __u16 code) {
+        printk("%s.%s", events[type] ? events[type] : "?",
+                names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
+}
+EXPORT_SYMBOL_GPL(hid_resolv_event);
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index c7a6833f6821..25d180a24fc4 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -31,9 +31,8 @@
 #include <linux/slab.h>
 #include <linux/kernel.h>
-#undef DEBUG
 #include <linux/hid.h>
+#include <linux/hid-debug.h>
 static int hid_pb_fnmode = 1;
 module_param_named(pb_fnmode, hid_pb_fnmode, int, 0644);
@@ -252,9 +251,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
        field->hidinput = hidinput;
-#ifdef DEBUG
+#ifdef CONFIG_HID_DEBUG
        printk(KERN_DEBUG "Mapping: ");
-        resolv_usage(usage->hid);
+        hid_resolv_usage(usage->hid);
        printk(" ---> ");
 #endif
@@ -682,14 +681,14 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                        field->dpad = usage->code;
        }
-#ifdef DEBUG
+        hid_resolv_event(usage->type, usage->code);
-        resolv_event(usage->type, usage->code);
+#ifdef CONFIG_HID_DEBUG
        printk("\n");
 #endif
        return;
 ignore:
-#ifdef DEBUG
+#ifdef CONFIG_HID_DEBUG
        printk("IGNORED\n");
 #endif
        return;
@@ -804,6 +803,18 @@ int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int
 }
 EXPORT_SYMBOL_GPL(hidinput_find_field);
+static int hidinput_open(struct input_dev *dev)
+{
+        struct hid_device *hid = dev->private;
+        return hid->hid_open(hid);
+}
+static void hidinput_close(struct input_dev *dev)
+{
+        struct hid_device *hid = dev->private;
+        hid->hid_close(hid);
+}
 /*
 * Register the input device; print a message.
 * Configure the input layer interface
@@ -816,6 +827,7 @@ int hidinput_connect(struct hid_device *hid)
        struct hid_input *hidinput = NULL;
        struct input_dev *input_dev;
        int i, j, k;
+        int max_report_type = HID_OUTPUT_REPORT;
        INIT_LIST_HEAD(&hid->inputs);
@@ -828,7 +840,10 @@ int hidinput_connect(struct hid_device *hid)
        if (i == hid->maxcollection)
                return -1;
-        for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++)
+        if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
+                max_report_type = HID_INPUT_REPORT;
+        for (k = HID_INPUT_REPORT; k <= max_report_type; k++)
                list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
                        if (!report->maxfield)
@@ -846,8 +861,8 @@ int hidinput_connect(struct hid_device *hid)
                                input_dev->private = hid;
                                input_dev->event = hid->hidinput_input_event;
-                                input_dev->open = hid->hidinput_open;
+                                input_dev->open = hidinput_open;
-                                input_dev->close = hid->hidinput_close;
+                                input_dev->close = hidinput_close;
                                input_dev->name = hid->name;
                                input_dev->phys = hid->phys;
diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c
index af939796750d..d2bb5a9a303f 100644
--- a/drivers/infiniband/core/addr.c
+++ b/drivers/infiniband/core/addr.c
@@ -360,8 +360,7 @@ static int netevent_callback(struct notifier_block *self, unsigned long event,
        if (event == NETEVENT_NEIGH_UPDATE) {
                struct neighbour *neigh = ctx;
-                if (neigh->dev->type == ARPHRD_INFINIBAND &&
+                if (neigh->nud_state & NUD_VALID) {
-                    (neigh->nud_state & NUD_VALID)) {
                        set_timeout(jiffies);
                }
        }
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index 5ed141ebd1c8..13efd4170349 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -642,7 +642,8 @@ static void snoop_recv(struct ib_mad_qp_info *qp_info,
        spin_unlock_irqrestore(&qp_info->snoop_lock, flags);
 }
-static void build_smp_wc(u64 wr_id, u16 slid, u16 pkey_index, u8 port_num,
+static void build_smp_wc(struct ib_qp *qp,
+                         u64 wr_id, u16 slid, u16 pkey_index, u8 port_num,
                         struct ib_wc *wc)
 {
        memset(wc, 0, sizeof *wc);
@@ -652,7 +653,7 @@ static void build_smp_wc(u64 wr_id, u16 slid, u16 pkey_index, u8 port_num,
        wc->pkey_index = pkey_index;
        wc->byte_len = sizeof(struct ib_mad) + sizeof(struct ib_grh);
        wc->src_qp = IB_QP0;
-        wc->qp_num = IB_QP0;
+        wc->qp = qp;
        wc->slid = slid;
        wc->sl = 0;
        wc->dlid_path_bits = 0;
@@ -713,7 +714,8 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
                goto out;
        }
-        build_smp_wc(send_wr->wr_id, be16_to_cpu(smp->dr_slid),
+        build_smp_wc(mad_agent_priv->agent.qp,
+                     send_wr->wr_id, be16_to_cpu(smp->dr_slid),
                     send_wr->wr.ud.pkey_index,
                     send_wr->wr.ud.port_num, &mad_wc);
@@ -2355,7 +2357,8 @@ static void local_completions(struct work_struct *work)
                         * Defined behavior is to complete response
                         * before request
                         */
-                        build_smp_wc((unsigned long) local->mad_send_wr,
+                        build_smp_wc(recv_mad_agent->agent.qp,
+                                     (unsigned long) local->mad_send_wr,
                                     be16_to_cpu(IB_LID_PERMISSIVE),
                                     0, recv_mad_agent->agent.port_num, &wc);
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index 743247ec065e..df1efbc10882 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -933,7 +933,7 @@ ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file,
                resp->wc[i].vendor_err     = wc[i].vendor_err;
                resp->wc[i].byte_len       = wc[i].byte_len;
                resp->wc[i].imm_data       = (__u32 __force) wc[i].imm_data;
-                resp->wc[i].qp_num         = wc[i].qp_num;
+                resp->wc[i].qp_num         = wc[i].qp->qp_num;
                resp->wc[i].src_qp         = wc[i].src_qp;
                resp->wc[i].wc_flags       = wc[i].wc_flags;
                resp->wc[i].pkey_index     = wc[i].pkey_index;
diff --git a/drivers/infiniband/hw/amso1100/c2_cq.c b/drivers/infiniband/hw/amso1100/c2_cq.c
index 05c9154d46f4..5175c99ee586 100644
--- a/drivers/infiniband/hw/amso1100/c2_cq.c
+++ b/drivers/infiniband/hw/amso1100/c2_cq.c
@@ -153,7 +153,7 @@ static inline int c2_poll_one(struct c2_dev *c2dev,
        entry->status = c2_cqe_status_to_openib(c2_wr_get_result(ce));
        entry->wr_id = ce->hdr.context;
-        entry->qp_num = ce->handle;
+        entry->qp = &qp->ibqp;
        entry->wc_flags = 0;
        entry->slid = 0;
        entry->sl = 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 1c722032319c..cf95ee474b0f 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -119,13 +119,14 @@ struct ehca_qp {
        struct ipz_qp_handle ipz_qp_handle;
        struct ehca_pfqp pf;
        struct ib_qp_init_attr init_attr;
-        u64 uspace_squeue;
-        u64 uspace_rqueue;
-        u64 uspace_fwh;
        struct ehca_cq *send_cq;
        struct ehca_cq *recv_cq;
        unsigned int sqerr_purgeflag;
        struct hlist_node list_entries;
+        /* mmap counter for resources mapped into user space */
+        u32 mm_count_squeue;
+        u32 mm_count_rqueue;
+        u32 mm_count_galpa;
 };
 /* must be power of 2 */
@@ -142,13 +143,14 @@ struct ehca_cq {
        struct ipz_cq_handle ipz_cq_handle;
        struct ehca_pfcq pf;
        spinlock_t cb_lock;
-        u64 uspace_queue;
-        u64 uspace_fwh;
        struct hlist_head qp_hashtab[QP_HASHTAB_LEN];
        struct list_head entry;
        u32 nr_callbacks;
        spinlock_t task_lock;
        u32 ownpid;
+        /* mmap counter for resources mapped into user space */
+        u32 mm_count_queue;
+        u32 mm_count_galpa;
 };
 enum ehca_mr_flag {
@@ -248,20 +250,6 @@ struct ehca_ucontext {
        struct ib_ucontext ib_ucontext;
 };
-struct ehca_module *ehca_module_new(void);
-int ehca_module_delete(struct ehca_module *me);
-int ehca_eq_ctor(struct ehca_eq *eq);
-int ehca_eq_dtor(struct ehca_eq *eq);
-struct ehca_shca *ehca_shca_new(void);
-int ehca_shca_delete(struct ehca_shca *me);
-struct ehca_sport *ehca_sport_new(struct ehca_shca *anchor);
 int ehca_init_pd_cache(void);
 void ehca_cleanup_pd_cache(void);
 int ehca_init_cq_cache(void);
@@ -283,7 +271,6 @@ extern int ehca_port_act_time;
 extern int ehca_use_hp_mr;
 struct ipzu_queue_resp {
-        u64 queue;        /* points to first queue entry */
        u32 qe_size;      /* queue entry size */
        u32 act_nr_of_sg;
        u32 queue_length; /* queue length allocated in bytes */
@@ -296,7 +283,6 @@ struct ehca_create_cq_resp {
        u32 cq_number;
        u32 token;
        struct ipzu_queue_resp ipz_queue;
-        struct h_galpas galpas;
 };
 struct ehca_create_qp_resp {
@@ -309,7 +295,6 @@ struct ehca_create_qp_resp {
        u32 dummy; /* padding for 8 byte alignment */
        struct ipzu_queue_resp ipz_squeue;
        struct ipzu_queue_resp ipz_rqueue;
-        struct h_galpas galpas;
 };
 struct ehca_alloc_cq_parms {
diff --git a/drivers/infiniband/hw/ehca/ehca_cq.c b/drivers/infiniband/hw/ehca/ehca_cq.c
index 6074c897f51c..9291a86ca053 100644
--- a/drivers/infiniband/hw/ehca/ehca_cq.c
+++ b/drivers/infiniband/hw/ehca/ehca_cq.c
@@ -267,7 +267,6 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe,
        if (context) {
                struct ipz_queue *ipz_queue = &my_cq->ipz_queue;
                struct ehca_create_cq_resp resp;
-                struct vm_area_struct *vma;
                memset(&resp, 0, sizeof(resp));
                resp.cq_number = my_cq->cq_number;
                resp.token = my_cq->token;
@@ -276,40 +275,14 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe,
                resp.ipz_queue.queue_length = ipz_queue->queue_length;
                resp.ipz_queue.pagesize = ipz_queue->pagesize;
                resp.ipz_queue.toggle_state = ipz_queue->toggle_state;
-                ret = ehca_mmap_nopage(((u64)(my_cq->token) << 32) | 0x12000000,
-                                       ipz_queue->queue_length,
-                                       (void**)&resp.ipz_queue.queue,
-                                       &vma);
-                if (ret) {
-                        ehca_err(device, "Could not mmap queue pages");
-                        cq = ERR_PTR(ret);
-                        goto create_cq_exit4;
-                }
-                my_cq->uspace_queue = resp.ipz_queue.queue;
-                resp.galpas = my_cq->galpas;
-                ret = ehca_mmap_register(my_cq->galpas.user.fw_handle,
-                                         (void**)&resp.galpas.kernel.fw_handle,
-                                         &vma);
-                if (ret) {
-                        ehca_err(device, "Could not mmap fw_handle");
-                        cq = ERR_PTR(ret);
-                        goto create_cq_exit5;
-                }
-                my_cq->uspace_fwh = (u64)resp.galpas.kernel.fw_handle;
                if (ib_copy_to_udata(udata, &resp, sizeof(resp))) {
                        ehca_err(device, "Copy to udata failed.");
-                        goto create_cq_exit6;
+                        goto create_cq_exit4;
                }
        }
        return cq;
-create_cq_exit6:
-        ehca_munmap(my_cq->uspace_fwh, EHCA_PAGESIZE);
-create_cq_exit5:
-        ehca_munmap(my_cq->uspace_queue, my_cq->ipz_queue.queue_length);
 create_cq_exit4:
        ipz_queue_dtor(&my_cq->ipz_queue);
@@ -333,7 +306,6 @@ create_cq_exit1:
 int ehca_destroy_cq(struct ib_cq *cq)
 {
        u64 h_ret;
-        int ret;
        struct ehca_cq *my_cq = container_of(cq, struct ehca_cq, ib_cq);
        int cq_num = my_cq->cq_number;
        struct ib_device *device = cq->device;
@@ -343,6 +315,20 @@ int ehca_destroy_cq(struct ib_cq *cq)
        u32 cur_pid = current->tgid;
        unsigned long flags;
+        if (cq->uobject) {
+                if (my_cq->mm_count_galpa || my_cq->mm_count_queue) {
+                        ehca_err(device, "Resources still referenced in "
+                                 "user space cq_num=%x", my_cq->cq_number);
+                        return -EINVAL;
+                }
+                if (my_cq->ownpid != cur_pid) {
+                        ehca_err(device, "Invalid caller pid=%x ownpid=%x "
+                                 "cq_num=%x",
+                                 cur_pid, my_cq->ownpid, my_cq->cq_number);
+                        return -EINVAL;
+                }
+        }
        spin_lock_irqsave(&ehca_cq_idr_lock, flags);
        while (my_cq->nr_callbacks) {
                spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);
@@ -353,25 +339,6 @@ int ehca_destroy_cq(struct ib_cq *cq)
        idr_remove(&ehca_cq_idr, my_cq->token);
        spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);
-        if (my_cq->uspace_queue && my_cq->ownpid != cur_pid) {
-                ehca_err(device, "Invalid caller pid=%x ownpid=%x",
-                         cur_pid, my_cq->ownpid);
-                return -EINVAL;
-        }
-        /* un-mmap if vma alloc */
-        if (my_cq->uspace_queue ) {
-                ret = ehca_munmap(my_cq->uspace_queue,
-                                  my_cq->ipz_queue.queue_length);
-                if (ret)
-                        ehca_err(device, "Could not munmap queue ehca_cq=%p "
-                                 "cq_num=%x", my_cq, cq_num);
-                ret = ehca_munmap(my_cq->uspace_fwh, EHCA_PAGESIZE);
-                if (ret)
-                        ehca_err(device, "Could not munmap fwh ehca_cq=%p "
-                                 "cq_num=%x", my_cq, cq_num);
-        }
        h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 0);
        if (h_ret == H_R_STATE) {
                /* cq in err: read err data and destroy it forcibly */
@@ -400,7 +367,7 @@ int ehca_resize_cq(struct ib_cq *cq, int cqe, struct ib_udata *udata)
        struct ehca_cq *my_cq = container_of(cq, struct ehca_cq, ib_cq);
        u32 cur_pid = current->tgid;
-        if (my_cq->uspace_queue && my_cq->ownpid != cur_pid) {
+        if (cq->uobject && my_cq->ownpid != cur_pid) {
                ehca_err(cq->device, "Invalid caller pid=%x ownpid=%x",
                         cur_pid, my_cq->ownpid);
                return -EINVAL;
diff --git a/drivers/infiniband/hw/ehca/ehca_iverbs.h b/drivers/infiniband/hw/ehca/ehca_iverbs.h
index cd7789f0d08e..95fd59fb4528 100644
--- a/drivers/infiniband/hw/ehca/ehca_iverbs.h
+++ b/drivers/infiniband/hw/ehca/ehca_iverbs.h
@@ -171,14 +171,6 @@ int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma);
 void ehca_poll_eqs(unsigned long data);
-int ehca_mmap_nopage(u64 foffset,u64 length,void **mapped,
-                     struct vm_area_struct **vma);
-int ehca_mmap_register(u64 physical,void **mapped,
-                       struct vm_area_struct **vma);
-int ehca_munmap(unsigned long addr, size_t len);
 #ifdef CONFIG_PPC_64K_PAGES
 void *ehca_alloc_fw_ctrlblock(gfp_t flags);
 void ehca_free_fw_ctrlblock(void *ptr);
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index 6574fbbaead5..1155bcf48212 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -52,7 +52,7 @@
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
 MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver");
-MODULE_VERSION("SVNEHCA_0019");
+MODULE_VERSION("SVNEHCA_0020");
 int ehca_open_aqp1     = 0;
 int ehca_debug_level   = 0;
@@ -288,7 +288,7 @@ int ehca_init_device(struct ehca_shca *shca)
        strlcpy(shca->ib_device.name, "ehca%d", IB_DEVICE_NAME_MAX);
        shca->ib_device.owner               = THIS_MODULE;
-        shca->ib_device.uverbs_abi_ver      = 5;
+        shca->ib_device.uverbs_abi_ver      = 6;
        shca->ib_device.uverbs_cmd_mask     =
                (1ull << IB_USER_VERBS_CMD_GET_CONTEXT)         |
                (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)        |
@@ -790,7 +790,7 @@ int __init ehca_module_init(void)
        int ret;
        printk(KERN_INFO "eHCA Infiniband Device Driver "
-                         "(Rel.: SVNEHCA_0019)\n");
+                         "(Rel.: SVNEHCA_0020)\n");
        idr_init(&ehca_qp_idr);
        idr_init(&ehca_cq_idr);
        spin_lock_init(&ehca_qp_idr_lock);
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 34b85556d01e..95efef921f1d 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -637,7 +637,6 @@ struct ib_qp *ehca_create_qp(struct ib_pd *pd,
                struct ipz_queue *ipz_rqueue = &my_qp->ipz_rqueue;
                struct ipz_queue *ipz_squeue = &my_qp->ipz_squeue;
                struct ehca_create_qp_resp resp;
-                struct vm_area_struct * vma;
                memset(&resp, 0, sizeof(resp));
                resp.qp_num = my_qp->real_qp_num;
@@ -651,59 +650,21 @@ struct ib_qp *ehca_create_qp(struct ib_pd *pd,
                resp.ipz_rqueue.queue_length = ipz_rqueue->queue_length;
                resp.ipz_rqueue.pagesize = ipz_rqueue->pagesize;
                resp.ipz_rqueue.toggle_state = ipz_rqueue->toggle_state;
-                ret = ehca_mmap_nopage(((u64)(my_qp->token) << 32) | 0x22000000,
-                                       ipz_rqueue->queue_length,
-                                       (void**)&resp.ipz_rqueue.queue,
-                                       &vma);
-                if (ret) {
-                        ehca_err(pd->device, "Could not mmap rqueue pages");
-                        goto create_qp_exit3;
-                }
-                my_qp->uspace_rqueue = resp.ipz_rqueue.queue;
                /* squeue properties */
                resp.ipz_squeue.qe_size = ipz_squeue->qe_size;
                resp.ipz_squeue.act_nr_of_sg = ipz_squeue->act_nr_of_sg;
                resp.ipz_squeue.queue_length = ipz_squeue->queue_length;
                resp.ipz_squeue.pagesize = ipz_squeue->pagesize;
                resp.ipz_squeue.toggle_state = ipz_squeue->toggle_state;
-                ret = ehca_mmap_nopage(((u64)(my_qp->token) << 32) | 0x23000000,
-                                       ipz_squeue->queue_length,
-                                       (void**)&resp.ipz_squeue.queue,
-                                       &vma);
-                if (ret) {
-                        ehca_err(pd->device, "Could not mmap squeue pages");
-                        goto create_qp_exit4;
-                }
-                my_qp->uspace_squeue = resp.ipz_squeue.queue;
-                /* fw_handle */
-                resp.galpas = my_qp->galpas;
-                ret = ehca_mmap_register(my_qp->galpas.user.fw_handle,
-                                         (void**)&resp.galpas.kernel.fw_handle,
-                                         &vma);
-                if (ret) {
-                        ehca_err(pd->device, "Could not mmap fw_handle");
-                        goto create_qp_exit5;
-                }
-                my_qp->uspace_fwh = (u64)resp.galpas.kernel.fw_handle;
                if (ib_copy_to_udata(udata, &resp, sizeof resp)) {
                        ehca_err(pd->device, "Copy to udata failed");
                        ret = -EINVAL;
-                        goto create_qp_exit6;
+                        goto create_qp_exit3;
                }
        }
        return &my_qp->ib_qp;
-create_qp_exit6:
-        ehca_munmap(my_qp->uspace_fwh, EHCA_PAGESIZE);
-create_qp_exit5:
-        ehca_munmap(my_qp->uspace_squeue, my_qp->ipz_squeue.queue_length);
-create_qp_exit4:
-        ehca_munmap(my_qp->uspace_rqueue, my_qp->ipz_rqueue.queue_length);
 create_qp_exit3:
        ipz_queue_dtor(&my_qp->ipz_rqueue);
        ipz_queue_dtor(&my_qp->ipz_squeue);
@@ -931,7 +892,7 @@ static int internal_modify_qp(struct ib_qp *ibqp,
             my_qp->qp_type == IB_QPT_SMI) &&
            statetrans == IB_QPST_SQE2RTS) {
                /* mark next free wqe if kernel */
-                if (my_qp->uspace_squeue == 0) {
+                if (!ibqp->uobject) {
                        struct ehca_wqe *wqe;
                        /* lock send queue */
                        spin_lock_irqsave(&my_qp->spinlock_s, spl_flags);
@@ -1417,11 +1378,18 @@ int ehca_destroy_qp(struct ib_qp *ibqp)
        enum ib_qp_type qp_type;
        unsigned long flags;
-        if (my_pd->ib_pd.uobject && my_pd->ib_pd.uobject->context &&
+        if (ibqp->uobject) {
-            my_pd->ownpid != cur_pid) {
+                if (my_qp->mm_count_galpa ||
-                ehca_err(ibqp->device, "Invalid caller pid=%x ownpid=%x",
+                    my_qp->mm_count_rqueue || my_qp->mm_count_squeue) {
-                         cur_pid, my_pd->ownpid);
+                        ehca_err(ibqp->device, "Resources still referenced in "
-                return -EINVAL;
+                                 "user space qp_num=%x", ibqp->qp_num);
+                        return -EINVAL;
+                }
+                if (my_pd->ownpid != cur_pid) {
+                        ehca_err(ibqp->device, "Invalid caller pid=%x ownpid=%x",
+                                 cur_pid, my_pd->ownpid);
+                        return -EINVAL;
+                }
        }
        if (my_qp->send_cq) {
@@ -1439,24 +1407,6 @@ int ehca_destroy_qp(struct ib_qp *ibqp)
        idr_remove(&ehca_qp_idr, my_qp->token);
        spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);
-        /* un-mmap if vma alloc */
-        if (my_qp->uspace_rqueue) {
-                ret = ehca_munmap(my_qp->uspace_rqueue,
-                                  my_qp->ipz_rqueue.queue_length);
-                if (ret)
-                        ehca_err(ibqp->device, "Could not munmap rqueue "
-                                 "qp_num=%x", qp_num);
-                ret = ehca_munmap(my_qp->uspace_squeue,
-                                  my_qp->ipz_squeue.queue_length);
-                if (ret)
-                        ehca_err(ibqp->device, "Could not munmap squeue "
-                                 "qp_num=%x", qp_num);
-                ret = ehca_munmap(my_qp->uspace_fwh, EHCA_PAGESIZE);
-                if (ret)
-                        ehca_err(ibqp->device, "Could not munmap fwh qp_num=%x",
-                                 qp_num);
-        }
        h_ret = hipz_h_destroy_qp(shca->ipz_hca_handle, my_qp);
        if (h_ret != H_SUCCESS) {
                ehca_err(ibqp->device, "hipz_h_destroy_qp() failed rc=%lx "
diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index b46bda1bf85d..08d3f892d9f3 100644
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -579,7 +579,7 @@ poll_cq_one_read_cqe:
        } else
                wc->status = IB_WC_SUCCESS;
-        wc->qp_num = cqe->local_qp_number;
+        wc->qp = NULL;
        wc->byte_len = cqe->nr_bytes_transferred;
        wc->pkey_index = cqe->pkey_index;
        wc->slid = cqe->rlid;
diff --git a/drivers/infiniband/hw/ehca/ehca_uverbs.c b/drivers/infiniband/hw/ehca/ehca_uverbs.c
index e08764e4aef2..73db920b6945 100644
--- a/drivers/infiniband/hw/ehca/ehca_uverbs.c
+++ b/drivers/infiniband/hw/ehca/ehca_uverbs.c
@@ -68,105 +68,183 @@ int ehca_dealloc_ucontext(struct ib_ucontext *context)
        return 0;
 }
-struct page *ehca_nopage(struct vm_area_struct *vma,
+static void ehca_mm_open(struct vm_area_struct *vma)
-                         unsigned long address, int *type)
 {
-        struct page *mypage = NULL;
+        u32 *count = (u32*)vma->vm_private_data;
-        u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
+        if (!count) {
-        u32 idr_handle = fileoffset >> 32;
+                ehca_gen_err("Invalid vma struct vm_start=%lx vm_end=%lx",
-        u32 q_type = (fileoffset >> 28) & 0xF;    /* CQ, QP,...        */
+                             vma->vm_start, vma->vm_end);
-        u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
+                return;
-        u32 cur_pid = current->tgid;
+        }
-        unsigned long flags;
+        (*count)++;
-        struct ehca_cq *cq;
+        if (!(*count))
-        struct ehca_qp *qp;
+                ehca_gen_err("Use count overflow vm_start=%lx vm_end=%lx",
-        struct ehca_pd *pd;
+                             vma->vm_start, vma->vm_end);
-        u64 offset;
+        ehca_gen_dbg("vm_start=%lx vm_end=%lx count=%x",
-        void *vaddr;
+                     vma->vm_start, vma->vm_end, *count);
+}
-        switch (q_type) {
+static void ehca_mm_close(struct vm_area_struct *vma)
-        case 1: /* CQ */
+{
-                spin_lock_irqsave(&ehca_cq_idr_lock, flags);
+        u32 *count = (u32*)vma->vm_private_data;
-                cq = idr_find(&ehca_cq_idr, idr_handle);
+        if (!count) {
-                spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);
+                ehca_gen_err("Invalid vma struct vm_start=%lx vm_end=%lx",
+                             vma->vm_start, vma->vm_end);
+                return;
+        }
+        (*count)--;
+        ehca_gen_dbg("vm_start=%lx vm_end=%lx count=%x",
+                     vma->vm_start, vma->vm_end, *count);
+}
-                /* make sure this mmap really belongs to the authorized user */
+static struct vm_operations_struct vm_ops = {
-                if (!cq) {
+        .open = ehca_mm_open,
-                        ehca_gen_err("cq is NULL ret=NOPAGE_SIGBUS");
+        .close = ehca_mm_close,
-                        return NOPAGE_SIGBUS;
+};
+static int ehca_mmap_fw(struct vm_area_struct *vma, struct h_galpas *galpas,
+                        u32 *mm_count)
+{
+        int ret;
+        u64 vsize, physical;
+        vsize = vma->vm_end - vma->vm_start;
+        if (vsize != EHCA_PAGESIZE) {
+                ehca_gen_err("invalid vsize=%lx", vma->vm_end - vma->vm_start);
+                return -EINVAL;
+        }
+        physical = galpas->user.fw_handle;
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        ehca_gen_dbg("vsize=%lx physical=%lx", vsize, physical);
+        /* VM_IO | VM_RESERVED are set by remap_pfn_range() */
+        ret = remap_pfn_range(vma, vma->vm_start, physical >> PAGE_SHIFT,
+                              vsize, vma->vm_page_prot);
+        if (unlikely(ret)) {
+                ehca_gen_err("remap_pfn_range() failed ret=%x", ret);
+                return -ENOMEM;
+        }
+        vma->vm_private_data = mm_count;
+        (*mm_count)++;
+        vma->vm_ops = &vm_ops;
+        return 0;
+}
+static int ehca_mmap_queue(struct vm_area_struct *vma, struct ipz_queue *queue,
+                           u32 *mm_count)
+{
+        int ret;
+        u64 start, ofs;
+        struct page *page;
+        vma->vm_flags |= VM_RESERVED;
+        start = vma->vm_start;
+        for (ofs = 0; ofs < queue->queue_length; ofs += PAGE_SIZE) {
+                u64 virt_addr = (u64)ipz_qeit_calc(queue, ofs);
+                page = virt_to_page(virt_addr);
+                ret = vm_insert_page(vma, start, page);
+                if (unlikely(ret)) {
+                        ehca_gen_err("vm_insert_page() failed rc=%x", ret);
+                        return ret;
                }
+                start +=  PAGE_SIZE;
+        }
+        vma->vm_private_data = mm_count;
+        (*mm_count)++;
+        vma->vm_ops = &vm_ops;
-                if (cq->ownpid != cur_pid) {
+        return 0;
+}
+static int ehca_mmap_cq(struct vm_area_struct *vma, struct ehca_cq *cq,
+                        u32 rsrc_type)
+{
+        int ret;
+        switch (rsrc_type) {
+        case 1: /* galpa fw handle */
+                ehca_dbg(cq->ib_cq.device, "cq_num=%x fw", cq->cq_number);
+                ret = ehca_mmap_fw(vma, &cq->galpas, &cq->mm_count_galpa);
+                if (unlikely(ret)) {
                        ehca_err(cq->ib_cq.device,
-                                 "Invalid caller pid=%x ownpid=%x",
+                                 "ehca_mmap_fw() failed rc=%x cq_num=%x",
-                                 cur_pid, cq->ownpid);
+                                 ret, cq->cq_number);
-                        return NOPAGE_SIGBUS;
+                        return ret;
                }
+                break;
-                if (rsrc_type == 2) {
+        case 2: /* cq queue_addr */
-                        ehca_dbg(cq->ib_cq.device, "cq=%p cq queuearea", cq);
+                ehca_dbg(cq->ib_cq.device, "cq_num=%x queue", cq->cq_number);
-                        offset = address - vma->vm_start;
+                ret = ehca_mmap_queue(vma, &cq->ipz_queue, &cq->mm_count_queue);
-                        vaddr = ipz_qeit_calc(&cq->ipz_queue, offset);
+                if (unlikely(ret)) {
-                        ehca_dbg(cq->ib_cq.device, "offset=%lx vaddr=%p",
+                        ehca_err(cq->ib_cq.device,
-                                 offset, vaddr);
+                                 "ehca_mmap_queue() failed rc=%x cq_num=%x",
-                        mypage = virt_to_page(vaddr);
+                                 ret, cq->cq_number);
+                        return ret;
                }
                break;
-        case 2: /* QP */
+        default:
-                spin_lock_irqsave(&ehca_qp_idr_lock, flags);
+                ehca_err(cq->ib_cq.device, "bad resource type=%x cq_num=%x",
-                qp = idr_find(&ehca_qp_idr, idr_handle);
+                         rsrc_type, cq->cq_number);
-                spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);
+                return -EINVAL;
+        }
-                /* make sure this mmap really belongs to the authorized user */
+        return 0;
-                if (!qp) {
+}
-                        ehca_gen_err("qp is NULL ret=NOPAGE_SIGBUS");
-                        return NOPAGE_SIGBUS;
+static int ehca_mmap_qp(struct vm_area_struct *vma, struct ehca_qp *qp,
+                        u32 rsrc_type)
+{
+        int ret;
+        switch (rsrc_type) {
+        case 1: /* galpa fw handle */
+                ehca_dbg(qp->ib_qp.device, "qp_num=%x fw", qp->ib_qp.qp_num);
+                ret = ehca_mmap_fw(vma, &qp->galpas, &qp->mm_count_galpa);
+                if (unlikely(ret)) {
+                        ehca_err(qp->ib_qp.device,
+                                 "remap_pfn_range() failed ret=%x qp_num=%x",
+                                 ret, qp->ib_qp.qp_num);
+                        return -ENOMEM;
                }
+                break;
-                pd = container_of(qp->ib_qp.pd, struct ehca_pd, ib_pd);
+        case 2: /* qp rqueue_addr */
-                if (pd->ownpid != cur_pid) {
+                ehca_dbg(qp->ib_qp.device, "qp_num=%x rqueue",
+                         qp->ib_qp.qp_num);
+                ret = ehca_mmap_queue(vma, &qp->ipz_rqueue, &qp->mm_count_rqueue);
+                if (unlikely(ret)) {
                        ehca_err(qp->ib_qp.device,
-                                 "Invalid caller pid=%x ownpid=%x",
+                                 "ehca_mmap_queue(rq) failed rc=%x qp_num=%x",
-                                 cur_pid, pd->ownpid);
+                                 ret, qp->ib_qp.qp_num);
-                        return NOPAGE_SIGBUS;
+                        return ret;
                }
+                break;
-                if (rsrc_type == 2) {   /* rqueue */
+        case 3: /* qp squeue_addr */
-                        ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueuearea", qp);
+                ehca_dbg(qp->ib_qp.device, "qp_num=%x squeue",
-                        offset = address - vma->vm_start;
+                         qp->ib_qp.qp_num);
-                        vaddr = ipz_qeit_calc(&qp->ipz_rqueue, offset);
+                ret = ehca_mmap_queue(vma, &qp->ipz_squeue, &qp->mm_count_squeue);
-                        ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
+                if (unlikely(ret)) {
-                                 offset, vaddr);
+                        ehca_err(qp->ib_qp.device,
-                        mypage = virt_to_page(vaddr);
+                                 "ehca_mmap_queue(sq) failed rc=%x qp_num=%x",
-                } else if (rsrc_type == 3) {    /* squeue */
+                                 ret, qp->ib_qp.qp_num);
-                        ehca_dbg(qp->ib_qp.device, "qp=%p qp squeuearea", qp);
+                        return ret;
-                        offset = address - vma->vm_start;
-                        vaddr = ipz_qeit_calc(&qp->ipz_squeue, offset);
-                        ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
-                                 offset, vaddr);
-                        mypage = virt_to_page(vaddr);
                }
                break;
        default:
-                ehca_gen_err("bad queue type %x", q_type);
+                ehca_err(qp->ib_qp.device, "bad resource type=%x qp=num=%x",
-                return NOPAGE_SIGBUS;
+                         rsrc_type, qp->ib_qp.qp_num);
-        }
+                return -EINVAL;
-        if (!mypage) {
-                ehca_gen_err("Invalid page adr==NULL ret=NOPAGE_SIGBUS");
-                return NOPAGE_SIGBUS;
        }
-        get_page(mypage);
-        return mypage;
+        return 0;
 }
-static struct vm_operations_struct ehcau_vm_ops = {
-        .nopage = ehca_nopage,
-};
 int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
 {
        u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
@@ -175,7 +253,6 @@ int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
        u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
        u32 cur_pid = current->tgid;
        u32 ret;
-        u64 vsize, physical;
        unsigned long flags;
        struct ehca_cq *cq;
        struct ehca_qp *qp;
@@ -201,44 +278,12 @@ int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
                if (!cq->ib_cq.uobject || cq->ib_cq.uobject->context != context)
                        return -EINVAL;
-                switch (rsrc_type) {
+                ret = ehca_mmap_cq(vma, cq, rsrc_type);
-                case 1: /* galpa fw handle */
+                if (unlikely(ret)) {
-                        ehca_dbg(cq->ib_cq.device, "cq=%p cq triggerarea", cq);
+                        ehca_err(cq->ib_cq.device,
-                        vma->vm_flags |= VM_RESERVED;
+                                 "ehca_mmap_cq() failed rc=%x cq_num=%x",
-                        vsize = vma->vm_end - vma->vm_start;
+                                 ret, cq->cq_number);
-                        if (vsize != EHCA_PAGESIZE) {
+                        return ret;
-                                ehca_err(cq->ib_cq.device, "invalid vsize=%lx",
-                                         vma->vm_end - vma->vm_start);
-                                return -EINVAL;
-                        }
-                        physical = cq->galpas.user.fw_handle;
-                        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-                        vma->vm_flags |= VM_IO | VM_RESERVED;
-                        ehca_dbg(cq->ib_cq.device,
-                                 "vsize=%lx physical=%lx", vsize, physical);
-                        ret = remap_pfn_range(vma, vma->vm_start,
-                                              physical >> PAGE_SHIFT, vsize,
-                                              vma->vm_page_prot);
-                        if (ret) {
-                                ehca_err(cq->ib_cq.device,
-                                         "remap_pfn_range() failed ret=%x",
-                                         ret);
-                                return -ENOMEM;
-                        }
-                        break;
-                case 2: /* cq queue_addr */
-                        ehca_dbg(cq->ib_cq.device, "cq=%p cq q_addr", cq);
-                        vma->vm_flags |= VM_RESERVED;
-                        vma->vm_ops = &ehcau_vm_ops;
-                        break;
-                default:
-                        ehca_err(cq->ib_cq.device, "bad resource type %x",
-                                 rsrc_type);
-                        return -EINVAL;
                }
                break;
@@ -262,50 +307,12 @@ int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
                if (!qp->ib_qp.uobject || qp->ib_qp.uobject->context != context)
                        return -EINVAL;
-                switch (rsrc_type) {
+                ret = ehca_mmap_qp(vma, qp, rsrc_type);
-                case 1: /* galpa fw handle */
+                if (unlikely(ret)) {
-                        ehca_dbg(qp->ib_qp.device, "qp=%p qp triggerarea", qp);
+                        ehca_err(qp->ib_qp.device,
-                        vma->vm_flags |= VM_RESERVED;
+                                 "ehca_mmap_qp() failed rc=%x qp_num=%x",
-                        vsize = vma->vm_end - vma->vm_start;
+                                 ret, qp->ib_qp.qp_num);
-                        if (vsize != EHCA_PAGESIZE) {
+                        return ret;
-                                ehca_err(qp->ib_qp.device, "invalid vsize=%lx",
-                                         vma->vm_end - vma->vm_start);
-                                return -EINVAL;
-                        }
-                        physical = qp->galpas.user.fw_handle;
-                        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-                        vma->vm_flags |= VM_IO | VM_RESERVED;
-                        ehca_dbg(qp->ib_qp.device, "vsize=%lx physical=%lx",
-                                 vsize, physical);
-                        ret = remap_pfn_range(vma, vma->vm_start,
-                                              physical >> PAGE_SHIFT, vsize,
-                                              vma->vm_page_prot);
-                        if (ret) {
-                                ehca_err(qp->ib_qp.device,
-                                         "remap_pfn_range() failed ret=%x",
-                                         ret);
-                                return -ENOMEM;
-                        }
-                        break;
-                case 2: /* qp rqueue_addr */
-                        ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueue_addr", qp);
-                        vma->vm_flags |= VM_RESERVED;
-                        vma->vm_ops = &ehcau_vm_ops;
-                        break;
-                case 3: /* qp squeue_addr */
-                        ehca_dbg(qp->ib_qp.device, "qp=%p qp squeue_addr", qp);
-                        vma->vm_flags |= VM_RESERVED;
-                        vma->vm_ops = &ehcau_vm_ops;
-                        break;
-                default:
-                        ehca_err(qp->ib_qp.device, "bad resource type %x",
-                                 rsrc_type);
-                        return -EINVAL;
                }
                break;
@@ -316,77 +323,3 @@ int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
        return 0;
 }
-int ehca_mmap_nopage(u64 foffset, u64 length, void **mapped,
-                     struct vm_area_struct **vma)
-{
-        down_write(&current->mm->mmap_sem);
-        *mapped = (void*)do_mmap(NULL,0, length, PROT_WRITE,
-                                 MAP_SHARED | MAP_ANONYMOUS,
-                                 foffset);
-        up_write(&current->mm->mmap_sem);
-        if (!(*mapped)) {
-                ehca_gen_err("couldn't mmap foffset=%lx length=%lx",
-                             foffset, length);
-                return -EINVAL;
-        }
-        *vma = find_vma(current->mm, (u64)*mapped);
-        if (!(*vma)) {
-                down_write(&current->mm->mmap_sem);
-                do_munmap(current->mm, 0, length);
-                up_write(&current->mm->mmap_sem);
-                ehca_gen_err("couldn't find vma queue=%p", *mapped);
-                return -EINVAL;
-        }
-        (*vma)->vm_flags |= VM_RESERVED;
-        (*vma)->vm_ops = &ehcau_vm_ops;
-        return 0;
-}
-int ehca_mmap_register(u64 physical, void **mapped,
-                       struct vm_area_struct **vma)
-{
-        int ret;
-        unsigned long vsize;
-        /* ehca hw supports only 4k page */
-        ret = ehca_mmap_nopage(0, EHCA_PAGESIZE, mapped, vma);
-        if (ret) {
-                ehca_gen_err("could'nt mmap physical=%lx", physical);
-                return ret;
-        }
-        (*vma)->vm_flags |= VM_RESERVED;
-        vsize = (*vma)->vm_end - (*vma)->vm_start;
-        if (vsize != EHCA_PAGESIZE) {
-                ehca_gen_err("invalid vsize=%lx",
-                             (*vma)->vm_end - (*vma)->vm_start);
-                return -EINVAL;
-        }
-        (*vma)->vm_page_prot = pgprot_noncached((*vma)->vm_page_prot);
-        (*vma)->vm_flags |= VM_IO | VM_RESERVED;
-        ret = remap_pfn_range((*vma), (*vma)->vm_start,
-                              physical >> PAGE_SHIFT, vsize,
-                              (*vma)->vm_page_prot);
-        if (ret) {
-                ehca_gen_err("remap_pfn_range() failed ret=%x", ret);
-                return -ENOMEM;
-        }
-        return 0;
-}
-int ehca_munmap(unsigned long addr, size_t len) {
-        int ret = 0;
-        struct mm_struct *mm = current->mm;
-        if (mm) {
-                down_write(&mm->mmap_sem);
-                ret = do_munmap(mm, addr, len);
-                up_write(&mm->mmap_sem);
-        }
-        return ret;
-}
diff --git a/drivers/infiniband/hw/ipath/ipath_qp.c b/drivers/infiniband/hw/ipath/ipath_qp.c
index 46c1c89bf6ae..64f07b19349f 100644
--- a/drivers/infiniband/hw/ipath/ipath_qp.c
+++ b/drivers/infiniband/hw/ipath/ipath_qp.c
@@ -379,7 +379,7 @@ void ipath_error_qp(struct ipath_qp *qp, enum ib_wc_status err)
        wc.vendor_err = 0;
        wc.byte_len = 0;
        wc.imm_data = 0;
-        wc.qp_num = qp->ibqp.qp_num;
+        wc.qp = &qp->ibqp;
        wc.src_qp = 0;
        wc.wc_flags = 0;
        wc.pkey_index = 0;
diff --git a/drivers/infiniband/hw/ipath/ipath_rc.c b/drivers/infiniband/hw/ipath/ipath_rc.c
index ce6038743c5c..5ff20cb04494 100644
--- a/drivers/infiniband/hw/ipath/ipath_rc.c
+++ b/drivers/infiniband/hw/ipath/ipath_rc.c
@@ -702,7 +702,7 @@ void ipath_restart_rc(struct ipath_qp *qp, u32 psn, struct ib_wc *wc)
                wc->opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                wc->vendor_err = 0;
                wc->byte_len = 0;
-                wc->qp_num = qp->ibqp.qp_num;
+                wc->qp = &qp->ibqp;
                wc->src_qp = qp->remote_qpn;
                wc->pkey_index = 0;
                wc->slid = qp->remote_ah_attr.dlid;
@@ -836,7 +836,7 @@ static int do_rc_ack(struct ipath_qp *qp, u32 aeth, u32 psn, int opcode)
                        wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                        wc.vendor_err = 0;
                        wc.byte_len = wqe->length;
-                        wc.qp_num = qp->ibqp.qp_num;
+                        wc.qp = &qp->ibqp;
                        wc.src_qp = qp->remote_qpn;
                        wc.pkey_index = 0;
                        wc.slid = qp->remote_ah_attr.dlid;
@@ -951,7 +951,7 @@ static int do_rc_ack(struct ipath_qp *qp, u32 aeth, u32 psn, int opcode)
                        wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                        wc.vendor_err = 0;
                        wc.byte_len = 0;
-                        wc.qp_num = qp->ibqp.qp_num;
+                        wc.qp = &qp->ibqp;
                        wc.src_qp = qp->remote_qpn;
                        wc.pkey_index = 0;
                        wc.slid = qp->remote_ah_attr.dlid;
@@ -1511,7 +1511,7 @@ void ipath_rc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
                wc.status = IB_WC_SUCCESS;
                wc.opcode = IB_WC_RECV;
                wc.vendor_err = 0;
-                wc.qp_num = qp->ibqp.qp_num;
+                wc.qp = &qp->ibqp;
                wc.src_qp = qp->remote_qpn;
                wc.pkey_index = 0;
                wc.slid = qp->remote_ah_attr.dlid;
diff --git a/drivers/infiniband/hw/ipath/ipath_ruc.c b/drivers/infiniband/hw/ipath/ipath_ruc.c
index f7530512045d..e86cb171872e 100644
--- a/drivers/infiniband/hw/ipath/ipath_ruc.c
+++ b/drivers/infiniband/hw/ipath/ipath_ruc.c
@@ -137,7 +137,7 @@ bad_lkey:
        wc.vendor_err = 0;
        wc.byte_len = 0;
        wc.imm_data = 0;
-        wc.qp_num = qp->ibqp.qp_num;
+        wc.qp = &qp->ibqp;
        wc.src_qp = 0;
        wc.wc_flags = 0;
        wc.pkey_index = 0;
@@ -336,7 +336,7 @@ again:
                        wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                        wc.vendor_err = 0;
                        wc.byte_len = 0;
-                        wc.qp_num = sqp->ibqp.qp_num;
+                        wc.qp = &sqp->ibqp;
                        wc.src_qp = sqp->remote_qpn;
                        wc.pkey_index = 0;
                        wc.slid = sqp->remote_ah_attr.dlid;
@@ -426,7 +426,7 @@ again:
        wc.status = IB_WC_SUCCESS;
        wc.vendor_err = 0;
        wc.byte_len = wqe->length;
-        wc.qp_num = qp->ibqp.qp_num;
+        wc.qp = &qp->ibqp;
        wc.src_qp = qp->remote_qpn;
        /* XXX do we know which pkey matched? Only needed for GSI. */
        wc.pkey_index = 0;
@@ -447,7 +447,7 @@ send_comp:
                wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                wc.vendor_err = 0;
                wc.byte_len = wqe->length;
-                wc.qp_num = sqp->ibqp.qp_num;
+                wc.qp = &sqp->ibqp;
                wc.src_qp = 0;
                wc.pkey_index = 0;
                wc.slid = 0;
diff --git a/drivers/infiniband/hw/ipath/ipath_uc.c b/drivers/infiniband/hw/ipath/ipath_uc.c
index e636cfd67a82..325d6634ff53 100644
--- a/drivers/infiniband/hw/ipath/ipath_uc.c
+++ b/drivers/infiniband/hw/ipath/ipath_uc.c
@@ -49,7 +49,7 @@ static void complete_last_send(struct ipath_qp *qp, struct ipath_swqe *wqe,
                wc->opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
                wc->vendor_err = 0;
                wc->byte_len = wqe->length;
-                wc->qp_num = qp->ibqp.qp_num;
+                wc->qp = &qp->ibqp;
                wc->src_qp = qp->remote_qpn;
                wc->pkey_index = 0;
                wc->slid = qp->remote_ah_attr.dlid;
@@ -411,7 +411,7 @@ void ipath_uc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
                wc.status = IB_WC_SUCCESS;
                wc.opcode = IB_WC_RECV;
                wc.vendor_err = 0;
-                wc.qp_num = qp->ibqp.qp_num;
+                wc.qp = &qp->ibqp;
                wc.src_qp = qp->remote_qpn;
                wc.pkey_index = 0;
                wc.slid = qp->remote_ah_attr.dlid;
diff --git a/drivers/infiniband/hw/ipath/ipath_ud.c b/drivers/infiniband/hw/ipath/ipath_ud.c
index 49f1102af8b3..9a3e54664ee4 100644
--- a/drivers/infiniband/hw/ipath/ipath_ud.c
+++ b/drivers/infiniband/hw/ipath/ipath_ud.c
@@ -66,7 +66,7 @@ bad_lkey:
        wc.vendor_err = 0;
        wc.byte_len = 0;
        wc.imm_data = 0;
-        wc.qp_num = qp->ibqp.qp_num;
+        wc.qp = &qp->ibqp;
        wc.src_qp = 0;
        wc.wc_flags = 0;
        wc.pkey_index = 0;
@@ -255,7 +255,7 @@ static void ipath_ud_loopback(struct ipath_qp *sqp,
        wc->status = IB_WC_SUCCESS;
        wc->opcode = IB_WC_RECV;
        wc->vendor_err = 0;
-        wc->qp_num = qp->ibqp.qp_num;
+        wc->qp = &qp->ibqp;
        wc->src_qp = sqp->ibqp.qp_num;
        /* XXX do we know which pkey matched? Only needed for GSI. */
        wc->pkey_index = 0;
@@ -474,7 +474,7 @@ done:
                wc.vendor_err = 0;
                wc.opcode = IB_WC_SEND;
                wc.byte_len = len;
-                wc.qp_num = qp->ibqp.qp_num;
+                wc.qp = &qp->ibqp;
                wc.src_qp = 0;
                wc.wc_flags = 0;
                /* XXX initialize other fields? */
@@ -651,7 +651,7 @@ void ipath_ud_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
        wc.status = IB_WC_SUCCESS;
        wc.opcode = IB_WC_RECV;
        wc.vendor_err = 0;
-        wc.qp_num = qp->ibqp.qp_num;
+        wc.qp = &qp->ibqp;
        wc.src_qp = src_qp;
        /* XXX do we know which pkey matched? Only needed for GSI. */
        wc.pkey_index = 0;
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.c b/drivers/infiniband/hw/mthca/mthca_cmd.c
index 768df7265b81..968d1519761c 100644
--- a/drivers/infiniband/hw/mthca/mthca_cmd.c
+++ b/drivers/infiniband/hw/mthca/mthca_cmd.c
@@ -1854,7 +1854,7 @@ int mthca_MAD_IFC(struct mthca_dev *dev, int ignore_mkey, int ignore_bkey,
                memset(inbox + 256, 0, 256);
-                MTHCA_PUT(inbox, in_wc->qp_num,     MAD_IFC_MY_QPN_OFFSET);
+                MTHCA_PUT(inbox, in_wc->qp->qp_num, MAD_IFC_MY_QPN_OFFSET);
                MTHCA_PUT(inbox, in_wc->src_qp,     MAD_IFC_RQPN_OFFSET);
                val = in_wc->sl << 4;
diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c
index 1159c8a0f2c5..efd79ef109a6 100644
--- a/drivers/infiniband/hw/mthca/mthca_cq.c
+++ b/drivers/infiniband/hw/mthca/mthca_cq.c
@@ -534,7 +534,7 @@ static inline int mthca_poll_one(struct mthca_dev *dev,
                }
        }
-        entry->qp_num = (*cur_qp)->qpn;
+        entry->qp = &(*cur_qp)->ibqp;
        if (is_send) {
                wq = &(*cur_qp)->sq;
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 72611fd15103..5e8ac577f0ad 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -548,6 +548,7 @@ static int srp_reconnect_target(struct srp_target_port *target)
        target->tx_head  = 0;
        target->tx_tail  = 0;
+        target->qp_in_error = 0;
        ret = srp_connect_target(target);
        if (ret)
                goto err;
@@ -878,6 +879,7 @@ static void srp_completion(struct ib_cq *cq, void *target_ptr)
                        printk(KERN_ERR PFX "failed %s status %d\n",
                               wc.wr_id & SRP_OP_RECV ? "receive" : "send",
                               wc.status);
+                        target->qp_in_error = 1;
                        break;
                }
@@ -1337,6 +1339,8 @@ static int srp_abort(struct scsi_cmnd *scmnd)
        printk(KERN_ERR "SRP abort called\n");
+        if (target->qp_in_error)
+                return FAILED;
        if (srp_find_req(target, scmnd, &req))
                return FAILED;
        if (srp_send_tsk_mgmt(target, req, SRP_TSK_ABORT_TASK))
@@ -1365,6 +1369,8 @@ static int srp_reset_device(struct scsi_cmnd *scmnd)
        printk(KERN_ERR "SRP reset_device called\n");
+        if (target->qp_in_error)
+                return FAILED;
        if (srp_find_req(target, scmnd, &req))
                return FAILED;
        if (srp_send_tsk_mgmt(target, req, SRP_TSK_LUN_RESET))
@@ -1801,6 +1807,7 @@ static ssize_t srp_create_target(struct class_device *class_dev,
                goto err_free;
        }
+        target->qp_in_error = 0;
        ret = srp_connect_target(target);
        if (ret) {
                printk(KERN_ERR PFX "Connection failed\n");
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index c21772317b86..2f3319c719a5 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -158,6 +158,7 @@ struct srp_target_port {
        struct completion       done;
        int                     status;
        enum srp_target_state   state;
+        int                     qp_in_error;
 };
 struct srp_iu {
diff --git a/drivers/misc/tifm_7xx1.c b/drivers/misc/tifm_7xx1.c
index 2ab7add78f94..e21e490fedb0 100644
--- a/drivers/misc/tifm_7xx1.c
+++ b/drivers/misc/tifm_7xx1.c
@@ -11,66 +11,25 @@
 #include <linux/tifm.h>
 #include <linux/dma-mapping.h>
+#include <linux/freezer.h>
 #define DRIVER_NAME "tifm_7xx1"
-#define DRIVER_VERSION "0.6"
+#define DRIVER_VERSION "0.7"
 static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
 {
-        int cnt;
-        unsigned long flags;
-        spin_lock_irqsave(&fm->lock, flags);
-        if (!fm->inhibit_new_cards) {
-                for (cnt = 0; cnt < fm->max_sockets; cnt++) {
-                        if (fm->sockets[cnt] == sock) {
-                                fm->remove_mask |= (1 << cnt);
-                                queue_work(fm->wq, &fm->media_remover);
-                                break;
-                        }
-                }
-        }
-        spin_unlock_irqrestore(&fm->lock, flags);
-}
-static void tifm_7xx1_remove_media(struct work_struct *work)
-{
-        struct tifm_adapter *fm =
-                container_of(work, struct tifm_adapter, media_remover);
        unsigned long flags;
-        int cnt;
-        struct tifm_dev *sock;
-        if (!class_device_get(&fm->cdev))
-                return;
        spin_lock_irqsave(&fm->lock, flags);
-        for (cnt = 0; cnt < fm->max_sockets; cnt++) {
+        fm->socket_change_set |= 1 << sock->socket_id;
-                if (fm->sockets[cnt] && (fm->remove_mask & (1 << cnt))) {
+        wake_up_all(&fm->change_set_notify);
-                        printk(KERN_INFO DRIVER_NAME
-                               ": demand removing card from socket %d\n", cnt);
-                        sock = fm->sockets[cnt];
-                        fm->sockets[cnt] = NULL;
-                        fm->remove_mask &= ~(1 << cnt);
-                        writel(0x0e00, sock->addr + SOCK_CONTROL);
-                        writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
-                                fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-                        writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
-                                fm->addr + FM_SET_INTERRUPT_ENABLE);
-                        spin_unlock_irqrestore(&fm->lock, flags);
-                        device_unregister(&sock->dev);
-                        spin_lock_irqsave(&fm->lock, flags);
-                }
-        }
        spin_unlock_irqrestore(&fm->lock, flags);
-        class_device_put(&fm->cdev);
 }
 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id)
 {
        struct tifm_adapter *fm = dev_id;
+        struct tifm_dev *sock;
        unsigned int irq_status;
        unsigned int sock_irq_status, cnt;
@@ -84,42 +43,32 @@ static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id)
        if (irq_status & TIFM_IRQ_ENABLE) {
                writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-                for (cnt = 0; cnt <  fm->max_sockets; cnt++) {
+                for (cnt = 0; cnt < fm->num_sockets; cnt++) {
-                        sock_irq_status = (irq_status >> cnt) &
+                        sock = fm->sockets[cnt];
-                                        (TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK);
+                        sock_irq_status = (irq_status >> cnt)
+                                          & (TIFM_IRQ_FIFOMASK(1)
-                        if (fm->sockets[cnt]) {
+                                             | TIFM_IRQ_CARDMASK(1));
-                                if (sock_irq_status &&
-                                                fm->sockets[cnt]->signal_irq)
-                                        sock_irq_status = fm->sockets[cnt]->
-                                                signal_irq(fm->sockets[cnt],
-                                                        sock_irq_status);
-                                if (irq_status & (1 << cnt))
+                        if (sock && sock_irq_status)
-                                        fm->remove_mask |= 1 << cnt;
+                                sock->signal_irq(sock, sock_irq_status);
-                        } else {
-                                if (irq_status & (1 << cnt))
-                                        fm->insert_mask |= 1 << cnt;
-                        }
                }
+                fm->socket_change_set |= irq_status
+                                         & ((1 << fm->num_sockets) - 1);
        }
        writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
-        if (!fm->inhibit_new_cards) {
+        if (!fm->socket_change_set)
-                if (!fm->remove_mask && !fm->insert_mask) {
+                writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
-                        writel(TIFM_IRQ_ENABLE,
+        else
-                                fm->addr + FM_SET_INTERRUPT_ENABLE);
+                wake_up_all(&fm->change_set_notify);
-                } else {
-                        queue_work(fm->wq, &fm->media_remover);
-                        queue_work(fm->wq, &fm->media_inserter);
-                }
-        }
        spin_unlock(&fm->lock);
        return IRQ_HANDLED;
 }
-static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr, int is_x2)
+static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr,
+                                                 int is_x2)
 {
        unsigned int s_state;
        int cnt;
@@ -127,8 +76,8 @@ static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr, int is
        writel(0x0e00, sock_addr + SOCK_CONTROL);
        for (cnt = 0; cnt < 100; cnt++) {
-                if (!(TIFM_SOCK_STATE_POWERED &
+                if (!(TIFM_SOCK_STATE_POWERED
-                                readl(sock_addr + SOCK_PRESENT_STATE)))
+                      & readl(sock_addr + SOCK_PRESENT_STATE)))
                        break;
                msleep(10);
        }
@@ -151,8 +100,8 @@ static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr, int is
        }
        for (cnt = 0; cnt < 100; cnt++) {
-                if ((TIFM_SOCK_STATE_POWERED &
+                if ((TIFM_SOCK_STATE_POWERED
-                                readl(sock_addr + SOCK_PRESENT_STATE)))
+                     & readl(sock_addr + SOCK_PRESENT_STATE)))
                        break;
                msleep(10);
        }
@@ -170,130 +119,209 @@ tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num)
        return base_addr + ((sock_num + 1) << 10);
 }
-static void tifm_7xx1_insert_media(struct work_struct *work)
+static int tifm_7xx1_switch_media(void *data)
 {
-        struct tifm_adapter *fm =
+        struct tifm_adapter *fm = data;
-                container_of(work, struct tifm_adapter, media_inserter);
        unsigned long flags;
        tifm_media_id media_id;
        char *card_name = "xx";
-        int cnt, ok_to_register;
+        int cnt, rc;
-        unsigned int insert_mask;
+        struct tifm_dev *sock;
-        struct tifm_dev *new_sock = NULL;
+        unsigned int socket_change_set;
-        if (!class_device_get(&fm->cdev))
+        while (1) {
-                return;
+                rc = wait_event_interruptible(fm->change_set_notify,
-        spin_lock_irqsave(&fm->lock, flags);
+                                              fm->socket_change_set);
-        insert_mask = fm->insert_mask;
+                if (rc == -ERESTARTSYS)
-        fm->insert_mask = 0;
+                        try_to_freeze();
-        if (fm->inhibit_new_cards) {
+                spin_lock_irqsave(&fm->lock, flags);
+                socket_change_set = fm->socket_change_set;
+                fm->socket_change_set = 0;
+                dev_dbg(fm->dev, "checking media set %x\n",
+                        socket_change_set);
+                if (kthread_should_stop())
+                        socket_change_set = (1 << fm->num_sockets) - 1;
                spin_unlock_irqrestore(&fm->lock, flags);
-                class_device_put(&fm->cdev);
-                return;
-        }
-        spin_unlock_irqrestore(&fm->lock, flags);
-        for (cnt = 0; cnt < fm->max_sockets; cnt++) {
+                if (!socket_change_set)
-                if (!(insert_mask & (1 << cnt)))
                        continue;
-                media_id = tifm_7xx1_toggle_sock_power(tifm_7xx1_sock_addr(fm->addr, cnt),
+                spin_lock_irqsave(&fm->lock, flags);
-                                                       fm->max_sockets == 2);
+                for (cnt = 0; cnt < fm->num_sockets; cnt++) {
-                if (media_id) {
+                        if (!(socket_change_set & (1 << cnt)))
-                        ok_to_register = 0;
+                                continue;
-                        new_sock = tifm_alloc_device(fm, cnt);
+                        sock = fm->sockets[cnt];
-                        if (new_sock) {
+                        if (sock) {
-                                new_sock->addr = tifm_7xx1_sock_addr(fm->addr,
-                                                                        cnt);
-                                new_sock->media_id = media_id;
-                                switch (media_id) {
-                                case 1:
-                                        card_name = "xd";
-                                        break;
-                                case 2:
-                                        card_name = "ms";
-                                        break;
-                                case 3:
-                                        card_name = "sd";
-                                        break;
-                                default:
-                                        break;
-                                }
-                                snprintf(new_sock->dev.bus_id, BUS_ID_SIZE,
-                                        "tifm_%s%u:%u", card_name, fm->id, cnt);
                                printk(KERN_INFO DRIVER_NAME
-                                        ": %s card detected in socket %d\n",
+                                       ": demand removing card from socket %d\n",
-                                        card_name, cnt);
+                                       cnt);
+                                fm->sockets[cnt] = NULL;
+                                spin_unlock_irqrestore(&fm->lock, flags);
+                                device_unregister(&sock->dev);
                                spin_lock_irqsave(&fm->lock, flags);
-                                if (!fm->sockets[cnt]) {
+                                writel(0x0e00,
-                                        fm->sockets[cnt] = new_sock;
+                                       tifm_7xx1_sock_addr(fm->addr, cnt)
-                                        ok_to_register = 1;
+                                       + SOCK_CONTROL);
+                        }
+                        if (kthread_should_stop())
+                                continue;
+                        spin_unlock_irqrestore(&fm->lock, flags);
+                        media_id = tifm_7xx1_toggle_sock_power(
+                                        tifm_7xx1_sock_addr(fm->addr, cnt),
+                                        fm->num_sockets == 2);
+                        if (media_id) {
+                                sock = tifm_alloc_device(fm);
+                                if (sock) {
+                                        sock->addr = tifm_7xx1_sock_addr(fm->addr,
+                                                                         cnt);
+                                        sock->media_id = media_id;
+                                        sock->socket_id = cnt;
+                                        switch (media_id) {
+                                        case 1:
+                                                card_name = "xd";
+                                                break;
+                                        case 2:
+                                                card_name = "ms";
+                                                break;
+                                        case 3:
+                                                card_name = "sd";
+                                                break;
+                                        default:
+                                                tifm_free_device(&sock->dev);
+                                                spin_lock_irqsave(&fm->lock, flags);
+                                                continue;
+                                        }
+                                        snprintf(sock->dev.bus_id, BUS_ID_SIZE,
+                                                 "tifm_%s%u:%u", card_name,
+                                                 fm->id, cnt);
+                                        printk(KERN_INFO DRIVER_NAME
+                                               ": %s card detected in socket %d\n",
+                                               card_name, cnt);
+                                        if (!device_register(&sock->dev)) {
+                                                spin_lock_irqsave(&fm->lock, flags);
+                                                if (!fm->sockets[cnt]) {
+                                                        fm->sockets[cnt] = sock;
+                                                        sock = NULL;
+                                                }
+                                                spin_unlock_irqrestore(&fm->lock, flags);
+                                        }
+                                        if (sock)
+                                                tifm_free_device(&sock->dev);
                                }
+                                spin_lock_irqsave(&fm->lock, flags);
+                        }
+                }
+                if (!kthread_should_stop()) {
+                        writel(TIFM_IRQ_FIFOMASK(socket_change_set)
+                               | TIFM_IRQ_CARDMASK(socket_change_set),
+                               fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+                        writel(TIFM_IRQ_FIFOMASK(socket_change_set)
+                               | TIFM_IRQ_CARDMASK(socket_change_set),
+                               fm->addr + FM_SET_INTERRUPT_ENABLE);
+                        writel(TIFM_IRQ_ENABLE,
+                               fm->addr + FM_SET_INTERRUPT_ENABLE);
+                        spin_unlock_irqrestore(&fm->lock, flags);
+                } else {
+                        for (cnt = 0; cnt < fm->num_sockets; cnt++) {
+                                if (fm->sockets[cnt])
+                                        fm->socket_change_set |= 1 << cnt;
+                        }
+                        if (!fm->socket_change_set) {
+                                spin_unlock_irqrestore(&fm->lock, flags);
+                                return 0;
+                        } else {
                                spin_unlock_irqrestore(&fm->lock, flags);
-                                if (!ok_to_register ||
-                                            device_register(&new_sock->dev)) {
-                                        spin_lock_irqsave(&fm->lock, flags);
-                                        fm->sockets[cnt] = NULL;
-                                        spin_unlock_irqrestore(&fm->lock,
-                                                                flags);
-                                        tifm_free_device(&new_sock->dev);
-                                }
                        }
                }
-                writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
-                       fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-                writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
-                       fm->addr + FM_SET_INTERRUPT_ENABLE);
        }
+        return 0;
-        writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
-        class_device_put(&fm->cdev);
 }
+#ifdef CONFIG_PM
 static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
 {
-        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        dev_dbg(&dev->dev, "suspending host\n");
-        unsigned long flags;
-        spin_lock_irqsave(&fm->lock, flags);
+        pci_save_state(dev);
-        fm->inhibit_new_cards = 1;
+        pci_enable_wake(dev, pci_choose_state(dev, state), 0);
-        fm->remove_mask = 0xf;
+        pci_disable_device(dev);
-        fm->insert_mask = 0;
+        pci_set_power_state(dev, pci_choose_state(dev, state));
-        writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-        spin_unlock_irqrestore(&fm->lock, flags);
-        flush_workqueue(fm->wq);
-        tifm_7xx1_remove_media(&fm->media_remover);
-        pci_set_power_state(dev, PCI_D3hot);
-        pci_disable_device(dev);
-        pci_save_state(dev);
        return 0;
 }
 static int tifm_7xx1_resume(struct pci_dev *dev)
 {
        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        int cnt, rc;
        unsigned long flags;
+        tifm_media_id new_ids[fm->num_sockets];
+        pci_set_power_state(dev, PCI_D0);
        pci_restore_state(dev);
-        pci_enable_device(dev);
+        rc = pci_enable_device(dev);
-        pci_set_power_state(dev, PCI_D0);
+        if (rc)
-        pci_set_master(dev);
+                return rc;
+        pci_set_master(dev);
+        dev_dbg(&dev->dev, "resuming host\n");
+        for (cnt = 0; cnt < fm->num_sockets; cnt++)
+                new_ids[cnt] = tifm_7xx1_toggle_sock_power(
+                                        tifm_7xx1_sock_addr(fm->addr, cnt),
+                                        fm->num_sockets == 2);
        spin_lock_irqsave(&fm->lock, flags);
-        fm->inhibit_new_cards = 0;
+        fm->socket_change_set = 0;
-        writel(TIFM_IRQ_SETALL, fm->addr + FM_INTERRUPT_STATUS);
+        for (cnt = 0; cnt < fm->num_sockets; cnt++) {
-        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+                if (fm->sockets[cnt]) {
-        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
+                        if (fm->sockets[cnt]->media_id == new_ids[cnt])
-                fm->addr + FM_SET_INTERRUPT_ENABLE);
+                                fm->socket_change_set |= 1 << cnt;
-        fm->insert_mask = 0xf;
+                        fm->sockets[cnt]->media_id = new_ids[cnt];
+                }
+        }
+        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
+               fm->addr + FM_SET_INTERRUPT_ENABLE);
+        if (!fm->socket_change_set) {
+                spin_unlock_irqrestore(&fm->lock, flags);
+                return 0;
+        } else {
+                fm->socket_change_set = 0;
+                spin_unlock_irqrestore(&fm->lock, flags);
+        }
+        wait_event_timeout(fm->change_set_notify, fm->socket_change_set, HZ);
+        spin_lock_irqsave(&fm->lock, flags);
+        writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
+               | TIFM_IRQ_CARDMASK(fm->socket_change_set),
+               fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
+               | TIFM_IRQ_CARDMASK(fm->socket_change_set),
+               fm->addr + FM_SET_INTERRUPT_ENABLE);
+        writel(TIFM_IRQ_ENABLE,
+               fm->addr + FM_SET_INTERRUPT_ENABLE);
+        fm->socket_change_set = 0;
        spin_unlock_irqrestore(&fm->lock, flags);
        return 0;
 }
+#else
+#define tifm_7xx1_suspend NULL
+#define tifm_7xx1_resume NULL
+#endif /* CONFIG_PM */
 static int tifm_7xx1_probe(struct pci_dev *dev,
-                        const struct pci_device_id *dev_id)
+                           const struct pci_device_id *dev_id)
 {
        struct tifm_adapter *fm;
        int pci_dev_busy = 0;
@@ -324,19 +352,18 @@ static int tifm_7xx1_probe(struct pci_dev *dev,
        }
        fm->dev = &dev->dev;
-        fm->max_sockets = (dev->device == 0x803B) ? 2 : 4;
+        fm->num_sockets = (dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM)
-        fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->max_sockets,
+                          ? 4 : 2;
-                                GFP_KERNEL);
+        fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->num_sockets,
+                              GFP_KERNEL);
        if (!fm->sockets)
                goto err_out_free;
-        INIT_WORK(&fm->media_inserter, tifm_7xx1_insert_media);
-        INIT_WORK(&fm->media_remover, tifm_7xx1_remove_media);
        fm->eject = tifm_7xx1_eject;
        pci_set_drvdata(dev, fm);
        fm->addr = ioremap(pci_resource_start(dev, 0),
-                                pci_resource_len(dev, 0));
+                           pci_resource_len(dev, 0));
        if (!fm->addr)
                goto err_out_free;
@@ -344,16 +371,15 @@ static int tifm_7xx1_probe(struct pci_dev *dev,
        if (rc)
                goto err_out_unmap;
-        rc = tifm_add_adapter(fm);
+        init_waitqueue_head(&fm->change_set_notify);
+        rc = tifm_add_adapter(fm, tifm_7xx1_switch_media);
        if (rc)
                goto err_out_irq;
        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
+        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
-                fm->addr + FM_SET_INTERRUPT_ENABLE);
+               fm->addr + FM_SET_INTERRUPT_ENABLE);
+        wake_up_process(fm->media_switcher);
-        fm->insert_mask = 0xf;
        return 0;
 err_out_irq:
@@ -377,19 +403,15 @@ static void tifm_7xx1_remove(struct pci_dev *dev)
        struct tifm_adapter *fm = pci_get_drvdata(dev);
        unsigned long flags;
+        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        mmiowb();
+        free_irq(dev->irq, fm);
        spin_lock_irqsave(&fm->lock, flags);
-        fm->inhibit_new_cards = 1;
+        fm->socket_change_set = (1 << fm->num_sockets) - 1;
-        fm->remove_mask = 0xf;
-        fm->insert_mask = 0;
-        writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
        spin_unlock_irqrestore(&fm->lock, flags);
-        flush_workqueue(fm->wq);
+        kthread_stop(fm->media_switcher);
-        tifm_7xx1_remove_media(&fm->media_remover);
-        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
-        free_irq(dev->irq, fm);
        tifm_remove_adapter(fm);
@@ -404,10 +426,12 @@ static void tifm_7xx1_remove(struct pci_dev *dev)
 }
 static struct pci_device_id tifm_7xx1_pci_tbl [] = {
-        { PCI_VENDOR_ID_TI, 0x8033, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11_FM, PCI_ANY_ID,
-          0 }, /* xx21 - the one I have */
+          PCI_ANY_ID, 0, 0, 0 }, /* xx21 - the one I have */
-        { PCI_VENDOR_ID_TI, 0x803B, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12_FM, PCI_ANY_ID,
-          0 }, /* xx12 - should be also supported */
+          PCI_ANY_ID, 0, 0, 0 },
+        { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX20_FM, PCI_ANY_ID,
+          PCI_ANY_ID, 0, 0, 0 },
        { }
 };
diff --git a/drivers/misc/tifm_core.c b/drivers/misc/tifm_core.c
index d61df5c3ac36..6b10ebe9d936 100644
--- a/drivers/misc/tifm_core.c
+++ b/drivers/misc/tifm_core.c
@@ -14,7 +14,7 @@
 #include <linux/idr.h>
 #define DRIVER_NAME "tifm_core"
-#define DRIVER_VERSION "0.6"
+#define DRIVER_VERSION "0.7"
 static DEFINE_IDR(tifm_adapter_idr);
 static DEFINE_SPINLOCK(tifm_adapter_lock);
@@ -60,10 +60,41 @@ static int tifm_uevent(struct device *dev, char **envp, int num_envp,
        return 0;
 }
+#ifdef CONFIG_PM
+static int tifm_device_suspend(struct device *dev, pm_message_t state)
+{
+        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
+        struct tifm_driver *drv = fm_dev->drv;
+        if (drv && drv->suspend)
+                return drv->suspend(fm_dev, state);
+        return 0;
+}
+static int tifm_device_resume(struct device *dev)
+{
+        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
+        struct tifm_driver *drv = fm_dev->drv;
+        if (drv && drv->resume)
+                return drv->resume(fm_dev);
+        return 0;
+}
+#else
+#define tifm_device_suspend NULL
+#define tifm_device_resume NULL
+#endif /* CONFIG_PM */
 static struct bus_type tifm_bus_type = {
        .name    = "tifm",
        .match   = tifm_match,
        .uevent  = tifm_uevent,
+        .suspend = tifm_device_suspend,
+        .resume  = tifm_device_resume
 };
 static void tifm_free(struct class_device *cdev)
@@ -71,8 +102,6 @@ static void tifm_free(struct class_device *cdev)
        struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);
        kfree(fm->sockets);
-        if (fm->wq)
-                destroy_workqueue(fm->wq);
        kfree(fm);
 }
@@ -101,7 +130,8 @@ void tifm_free_adapter(struct tifm_adapter *fm)
 }
 EXPORT_SYMBOL(tifm_free_adapter);
-int tifm_add_adapter(struct tifm_adapter *fm)
+int tifm_add_adapter(struct tifm_adapter *fm,
+                     int (*mediathreadfn)(void *data))
 {
        int rc;
@@ -113,10 +143,10 @@ int tifm_add_adapter(struct tifm_adapter *fm)
        spin_unlock(&tifm_adapter_lock);
        if (!rc) {
                snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
-                strncpy(fm->wq_name, fm->cdev.class_id, KOBJ_NAME_LEN);
+                fm->media_switcher = kthread_create(mediathreadfn,
+                                                    fm, "tifm/%u", fm->id);
-                fm->wq = create_singlethread_workqueue(fm->wq_name);
+                if (!IS_ERR(fm->media_switcher))
-                if (fm->wq)
                        return class_device_add(&fm->cdev);
                spin_lock(&tifm_adapter_lock);
@@ -141,27 +171,27 @@ EXPORT_SYMBOL(tifm_remove_adapter);
 void tifm_free_device(struct device *dev)
 {
        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
-        if (fm_dev->wq)
-                destroy_workqueue(fm_dev->wq);
        kfree(fm_dev);
 }
 EXPORT_SYMBOL(tifm_free_device);
-struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id)
+static void tifm_dummy_signal_irq(struct tifm_dev *sock,
+                                  unsigned int sock_irq_status)
+{
+        return;
+}
+struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm)
 {
        struct tifm_dev *dev = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);
        if (dev) {
                spin_lock_init(&dev->lock);
-                snprintf(dev->wq_name, KOBJ_NAME_LEN, "tifm%u:%u", fm->id, id);
-                dev->wq = create_singlethread_workqueue(dev->wq_name);
-                if (!dev->wq) {
-                        kfree(dev);
-                        return NULL;
-                }
                dev->dev.parent = fm->dev;
                dev->dev.bus = &tifm_bus_type;
                dev->dev.release = tifm_free_device;
+                dev->signal_irq = tifm_dummy_signal_irq;
        }
        return dev;
 }
@@ -219,6 +249,7 @@ static int tifm_device_remove(struct device *dev)
        struct tifm_driver *drv = fm_dev->drv;
        if (drv) {
+                fm_dev->signal_irq = tifm_dummy_signal_irq;
                if (drv->remove)
                        drv->remove(fm_dev);
                fm_dev->drv = NULL;
@@ -233,6 +264,8 @@ int tifm_register_driver(struct tifm_driver *drv)
        drv->driver.bus = &tifm_bus_type;
        drv->driver.probe = tifm_device_probe;
        drv->driver.remove = tifm_device_remove;
+        drv->driver.suspend = tifm_device_suspend;
+        drv->driver.resume = tifm_device_resume;
        return driver_register(&drv->driver);
 }
diff --git a/drivers/mmc/at91_mci.c b/drivers/mmc/at91_mci.c
index aa152f31851e..2ce50f38e3c7 100644
--- a/drivers/mmc/at91_mci.c
+++ b/drivers/mmc/at91_mci.c
@@ -823,6 +823,9 @@ static int __init at91_mci_probe(struct platform_device *pdev)
        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
        mmc->caps = MMC_CAP_BYTEBLOCK;
+        mmc->max_blk_size = 4095;
+        mmc->max_blk_count = mmc->max_req_size;
        host = mmc_priv(mmc);
        host->mmc = mmc;
        host->buffer = NULL;
diff --git a/drivers/mmc/au1xmmc.c b/drivers/mmc/au1xmmc.c
index 800527cf40d5..b834be261ab7 100644
--- a/drivers/mmc/au1xmmc.c
+++ b/drivers/mmc/au1xmmc.c
@@ -152,8 +152,9 @@ static inline int au1xmmc_card_inserted(struct au1xmmc_host *host)
                ? 1 : 0;
 }
-static inline int au1xmmc_card_readonly(struct au1xmmc_host *host)
+static int au1xmmc_card_readonly(struct mmc_host *mmc)
 {
+        struct au1xmmc_host *host = mmc_priv(mmc);
        return (bcsr->status & au1xmmc_card_table[host->id].wpstatus)
                ? 1 : 0;
 }
@@ -193,6 +194,8 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
        u32 mmccmd = (cmd->opcode << SD_CMD_CI_SHIFT);
        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE:
+                break;
        case MMC_RSP_R1:
                mmccmd |= SD_CMD_RT_1;
                break;
@@ -205,6 +208,10 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
        case MMC_RSP_R3:
                mmccmd |= SD_CMD_RT_3;
                break;
+        default:
+                printk(KERN_INFO "au1xmmc: unhandled response type %02x\n",
+                        mmc_resp_type(cmd));
+                return MMC_ERR_INVALID;
        }
        switch(cmd->opcode) {
@@ -878,6 +885,7 @@ static void au1xmmc_init_dma(struct au1xmmc_host *host)
 static const struct mmc_host_ops au1xmmc_ops = {
        .request        = au1xmmc_request,
        .set_ios        = au1xmmc_set_ios,
+        .get_ro         = au1xmmc_card_readonly,
 };
 static int __devinit au1xmmc_probe(struct platform_device *pdev)
@@ -914,6 +922,9 @@ static int __devinit au1xmmc_probe(struct platform_device *pdev)
                mmc->max_seg_size = AU1XMMC_DESCRIPTOR_SIZE;
                mmc->max_phys_segs = AU1XMMC_DESCRIPTOR_COUNT;
+                mmc->max_blk_size = 2048;
+                mmc->max_blk_count = 512;
                mmc->ocr_avail = AU1XMMC_OCR;
                host = mmc_priv(mmc);
diff --git a/drivers/mmc/imxmmc.c b/drivers/mmc/imxmmc.c
index bfb9ff693208..b060d4bfba29 100644
--- a/drivers/mmc/imxmmc.c
+++ b/drivers/mmc/imxmmc.c
@@ -958,8 +958,10 @@ static int imxmci_probe(struct platform_device *pdev)
        /* MMC core transfer sizes tunable parameters */
        mmc->max_hw_segs = 64;
        mmc->max_phys_segs = 64;
-        mmc->max_sectors = 64;          /* default 1 << (PAGE_CACHE_SHIFT - 9) */
        mmc->max_seg_size = 64*512;     /* default PAGE_CACHE_SIZE */
+        mmc->max_req_size = 64*512;     /* default PAGE_CACHE_SIZE */
+        mmc->max_blk_size = 2048;
+        mmc->max_blk_count = 65535;
        host = mmc_priv(mmc);
        host->mmc = mmc;
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 6f2a282e2b97..5046a1661342 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -103,11 +103,16 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                 mmc_hostname(host), mrq->cmd->opcode,
                 mrq->cmd->arg, mrq->cmd->flags);
-        WARN_ON(host->card_busy == NULL);
+        WARN_ON(!host->claimed);
        mrq->cmd->error = 0;
        mrq->cmd->mrq = mrq;
        if (mrq->data) {
+                BUG_ON(mrq->data->blksz > host->max_blk_size);
+                BUG_ON(mrq->data->blocks > host->max_blk_count);
+                BUG_ON(mrq->data->blocks * mrq->data->blksz >
+                        host->max_req_size);
                mrq->cmd->data = mrq->data;
                mrq->data->error = 0;
                mrq->data->mrq = mrq;
@@ -157,7 +162,7 @@ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries
 {
        struct mmc_request mrq;
-        BUG_ON(host->card_busy == NULL);
+        BUG_ON(!host->claimed);
        memset(&mrq, 0, sizeof(struct mmc_request));
@@ -195,7 +200,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, unsigned int rca,
        int i, err;
-        BUG_ON(host->card_busy == NULL);
+        BUG_ON(!host->claimed);
        BUG_ON(retries < 0);
        err = MMC_ERR_INVALID;
@@ -289,7 +294,10 @@ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card,
                else
                        limit_us = 100000;
-                if (timeout_us > limit_us) {
+                /*
+                 * SDHC cards always use these fixed values.
+                 */
+                if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
                        data->timeout_ns = limit_us * 1000;
                        data->timeout_clks = 0;
                }
@@ -320,14 +328,14 @@ int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card)
        spin_lock_irqsave(&host->lock, flags);
        while (1) {
                set_current_state(TASK_UNINTERRUPTIBLE);
-                if (host->card_busy == NULL)
+                if (!host->claimed)
                        break;
                spin_unlock_irqrestore(&host->lock, flags);
                schedule();
                spin_lock_irqsave(&host->lock, flags);
        }
        set_current_state(TASK_RUNNING);
-        host->card_busy = card;
+        host->claimed = 1;
        spin_unlock_irqrestore(&host->lock, flags);
        remove_wait_queue(&host->wq, &wait);
@@ -353,10 +361,10 @@ void mmc_release_host(struct mmc_host *host)
 {
        unsigned long flags;
-        BUG_ON(host->card_busy == NULL);
+        BUG_ON(!host->claimed);
        spin_lock_irqsave(&host->lock, flags);
-        host->card_busy = NULL;
+        host->claimed = 0;
        spin_unlock_irqrestore(&host->lock, flags);
        wake_up(&host->wq);
@@ -372,7 +380,7 @@ static inline void mmc_set_ios(struct mmc_host *host)
                 mmc_hostname(host), ios->clock, ios->bus_mode,
                 ios->power_mode, ios->chip_select, ios->vdd,
                 ios->bus_width);
-        
        host->ops->set_ios(host, ios);
 }
@@ -381,7 +389,7 @@ static int mmc_select_card(struct mmc_host *host, struct mmc_card *card)
        int err;
        struct mmc_command cmd;
-        BUG_ON(host->card_busy == NULL);
+        BUG_ON(!host->claimed);
        if (host->card_selected == card)
                return MMC_ERR_NONE;
@@ -588,34 +596,65 @@ static void mmc_decode_csd(struct mmc_card *card)
        if (mmc_card_sd(card)) {
                csd_struct = UNSTUFF_BITS(resp, 126, 2);
-                if (csd_struct != 0) {
+                switch (csd_struct) {
+                case 0:
+                        m = UNSTUFF_BITS(resp, 115, 4);
+                        e = UNSTUFF_BITS(resp, 112, 3);
+                        csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
+                        csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+                        m = UNSTUFF_BITS(resp, 99, 4);
+                        e = UNSTUFF_BITS(resp, 96, 3);
+                        csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                        csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+                        e = UNSTUFF_BITS(resp, 47, 3);
+                        m = UNSTUFF_BITS(resp, 62, 12);
+                        csd->capacity     = (1 + m) << (e + 2);
+                        csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
+                        csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
+                        csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
+                        csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
+                        csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
+                        csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
+                        csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
+                        break;
+                case 1:
+                        /*
+                         * This is a block-addressed SDHC card. Most
+                         * interesting fields are unused and have fixed
+                         * values. To avoid getting tripped by buggy cards,
+                         * we assume those fixed values ourselves.
+                         */
+                        mmc_card_set_blockaddr(card);
+                        csd->tacc_ns     = 0; /* Unused */
+                        csd->tacc_clks   = 0; /* Unused */
+                        m = UNSTUFF_BITS(resp, 99, 4);
+                        e = UNSTUFF_BITS(resp, 96, 3);
+                        csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                        csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+                        m = UNSTUFF_BITS(resp, 48, 22);
+                        csd->capacity     = (1 + m) << 10;
+                        csd->read_blkbits = 9;
+                        csd->read_partial = 0;
+                        csd->write_misalign = 0;
+                        csd->read_misalign = 0;
+                        csd->r2w_factor = 4; /* Unused */
+                        csd->write_blkbits = 9;
+                        csd->write_partial = 0;
+                        break;
+                default:
                        printk("%s: unrecognised CSD structure version %d\n",
                                mmc_hostname(card->host), csd_struct);
                        mmc_card_set_bad(card);
                        return;
                }
-                m = UNSTUFF_BITS(resp, 115, 4);
-                e = UNSTUFF_BITS(resp, 112, 3);
-                csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
-                csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
-                m = UNSTUFF_BITS(resp, 99, 4);
-                e = UNSTUFF_BITS(resp, 96, 3);
-                csd->max_dtr      = tran_exp[e] * tran_mant[m];
-                csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
-                e = UNSTUFF_BITS(resp, 47, 3);
-                m = UNSTUFF_BITS(resp, 62, 12);
-                csd->capacity     = (1 + m) << (e + 2);
-                csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
-                csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
-                csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
-                csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
-                csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
-                csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
-                csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
        } else {
                /*
                 * We only understand CSD structure v1.1 and v1.2.
@@ -848,6 +887,41 @@ static int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
        return err;
 }
+static int mmc_send_if_cond(struct mmc_host *host, u32 ocr, int *rsd2)
+{
+        struct mmc_command cmd;
+        int err, sd2;
+        static const u8 test_pattern = 0xAA;
+        /*
+        * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
+        * before SD_APP_OP_COND. This command will harmlessly fail for
+        * SD 1.0 cards.
+        */
+        cmd.opcode = SD_SEND_IF_COND;
+        cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
+        cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
+        err = mmc_wait_for_cmd(host, &cmd, 0);
+        if (err == MMC_ERR_NONE) {
+                if ((cmd.resp[0] & 0xFF) == test_pattern) {
+                        sd2 = 1;
+                } else {
+                        sd2 = 0;
+                        err = MMC_ERR_FAILED;
+                }
+        } else {
+                /*
+                 * Treat errors as SD 1.0 card.
+                 */
+                sd2 = 0;
+                err = MMC_ERR_NONE;
+        }
+        if (rsd2)
+                *rsd2 = sd2;
+        return err;
+}
 /*
 * Discover cards by requesting their CID.  If this command
 * times out, it is not an error; there are no further cards
@@ -1018,7 +1092,8 @@ static void mmc_process_ext_csds(struct mmc_host *host)
                mmc_wait_for_req(host, &mrq);
                if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE) {
-                        mmc_card_set_dead(card);
+                        printk("%s: unable to read EXT_CSD, performance "
+                                "might suffer.\n", mmc_hostname(card->host));
                        continue;
                }
@@ -1034,7 +1109,6 @@ static void mmc_process_ext_csds(struct mmc_host *host)
                        printk("%s: card is mmc v4 but doesn't support "
                               "any high-speed modes.\n",
                                mmc_hostname(card->host));
-                        mmc_card_set_bad(card);
                        continue;
                }
@@ -1215,7 +1289,9 @@ static void mmc_read_switch_caps(struct mmc_host *host)
                mmc_wait_for_req(host, &mrq);
                if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE) {
-                        mmc_card_set_dead(card);
+                        printk("%s: unable to read switch capabilities, "
+                                "performance might suffer.\n",
+                                mmc_hostname(card->host));
                        continue;
                }
@@ -1247,12 +1323,8 @@ static void mmc_read_switch_caps(struct mmc_host *host)
                mmc_wait_for_req(host, &mrq);
-                if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE) {
+                if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE ||
-                        mmc_card_set_dead(card);
+                        (status[16] & 0xF) != 1) {
-                        continue;
-                }
-                if ((status[16] & 0xF) != 1) {
                        printk(KERN_WARNING "%s: Problem switching card "
                                "into high-speed mode!\n",
                                mmc_hostname(host));
@@ -1334,6 +1406,10 @@ static void mmc_setup(struct mmc_host *host)
                mmc_power_up(host);
                mmc_idle_cards(host);
+                err = mmc_send_if_cond(host, host->ocr_avail, NULL);
+                if (err != MMC_ERR_NONE) {
+                        return;
+                }
                err = mmc_send_app_op_cond(host, 0, &ocr);
                /*
@@ -1386,10 +1462,21 @@ static void mmc_setup(struct mmc_host *host)
         * all get the idea that they should be ready for CMD2.
         * (My SanDisk card seems to need this.)
         */
-        if (host->mode == MMC_MODE_SD)
+        if (host->mode == MMC_MODE_SD) {
-                mmc_send_app_op_cond(host, host->ocr, NULL);
+                int err, sd2;
-        else
+                err = mmc_send_if_cond(host, host->ocr, &sd2);
+                if (err == MMC_ERR_NONE) {
+                        /*
+                        * If SD_SEND_IF_COND indicates an SD 2.0
+                        * compliant card and we should set bit 30
+                        * of the ocr to indicate that we can handle
+                        * block-addressed SDHC cards.
+                        */
+                        mmc_send_app_op_cond(host, host->ocr | (sd2 << 30), NULL);
+                }
+        } else {
                mmc_send_op_cond(host, host->ocr, NULL);
+        }
        mmc_discover_cards(host);
@@ -1519,8 +1606,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
                 */
                host->max_hw_segs = 1;
                host->max_phys_segs = 1;
-                host->max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
                host->max_seg_size = PAGE_CACHE_SIZE;
+                host->max_req_size = PAGE_CACHE_SIZE;
+                host->max_blk_size = 512;
+                host->max_blk_count = PAGE_CACHE_SIZE / 512;
        }
        return host;
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index 87713572293f..05ba8ace70e7 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -237,13 +237,17 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                brq.mrq.cmd = &brq.cmd;
                brq.mrq.data = &brq.data;
-                brq.cmd.arg = req->sector << 9;
+                brq.cmd.arg = req->sector;
+                if (!mmc_card_blockaddr(card))
+                        brq.cmd.arg <<= 9;
                brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
                brq.data.blksz = 1 << md->block_bits;
-                brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
                brq.stop.opcode = MMC_STOP_TRANSMISSION;
                brq.stop.arg = 0;
                brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
+                brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
+                if (brq.data.blocks > card->host->max_blk_count)
+                        brq.data.blocks = card->host->max_blk_count;
                mmc_set_data_timeout(&brq.data, card, rq_data_dir(req) != READ);
@@ -375,9 +379,10 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                spin_unlock_irq(&md->lock);
        }
+flush_queue:
        mmc_card_release_host(card);
-flush_queue:
        spin_lock_irq(&md->lock);
        while (ret) {
                ret = end_that_request_chunk(req, 0,
@@ -494,6 +499,10 @@ mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
        struct mmc_command cmd;
        int err;
+        /* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
+        if (mmc_card_blockaddr(card))
+                return 0;
        mmc_card_claim_host(card);
        cmd.opcode = MMC_SET_BLOCKLEN;
        cmd.arg = 1 << md->block_bits;
diff --git a/drivers/mmc/mmc_queue.c b/drivers/mmc/mmc_queue.c
index 3e35a43819fb..c27e42645cdb 100644
--- a/drivers/mmc/mmc_queue.c
+++ b/drivers/mmc/mmc_queue.c
@@ -147,7 +147,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
        blk_queue_prep_rq(mq->queue, mmc_prep_request);
        blk_queue_bounce_limit(mq->queue, limit);
-        blk_queue_max_sectors(mq->queue, host->max_sectors);
+        blk_queue_max_sectors(mq->queue, host->max_req_size / 512);
        blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
        blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
        blk_queue_max_segment_size(mq->queue, host->max_seg_size);
diff --git a/drivers/mmc/mmc_sysfs.c b/drivers/mmc/mmc_sysfs.c
index e334acd045bc..d32698b02d7f 100644
--- a/drivers/mmc/mmc_sysfs.c
+++ b/drivers/mmc/mmc_sysfs.c
@@ -199,7 +199,7 @@ void mmc_init_card(struct mmc_card *card, struct mmc_host *host)
        memset(card, 0, sizeof(struct mmc_card));
        card->host = host;
        device_initialize(&card->dev);
-        card->dev.parent = mmc_dev(host);
+        card->dev.parent = mmc_classdev(host);
        card->dev.bus = &mmc_bus_type;
        card->dev.release = mmc_release_card;
 }
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index ccfe6561be24..5941dd951e82 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -524,15 +524,24 @@ static int mmci_probe(struct amba_device *dev, void *id)
        /*
         * Since we only have a 16-bit data length register, we must
         * ensure that we don't exceed 2^16-1 bytes in a single request.
-         * Choose 64 (512-byte) sectors as the limit.
         */
-        mmc->max_sectors = 64;
+        mmc->max_req_size = 65535;
        /*
         * Set the maximum segment size.  Since we aren't doing DMA
         * (yet) we are only limited by the data length register.
         */
-        mmc->max_seg_size = mmc->max_sectors << 9;
+        mmc->max_seg_size = mmc->max_req_size;
+        /*
+         * Block size can be up to 2048 bytes, but must be a power of two.
+         */
+        mmc->max_blk_size = 2048;
+        /*
+         * No limit on the number of blocks transferred.
+         */
+        mmc->max_blk_count = mmc->max_req_size;
        spin_lock_init(&host->lock);
diff --git a/drivers/mmc/omap.c b/drivers/mmc/omap.c
index d30540b27614..1e96a2f65022 100644
--- a/drivers/mmc/omap.c
+++ b/drivers/mmc/omap.c
@@ -1099,8 +1099,10 @@ static int __init mmc_omap_probe(struct platform_device *pdev)
         */
        mmc->max_phys_segs = 32;
        mmc->max_hw_segs = 32;
-        mmc->max_sectors = 256; /* NBLK max 11-bits, OMAP also limited by DMA */
+        mmc->max_blk_size = 2048;       /* BLEN is 11 bits (+1) */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_blk_count = 2048;      /* NBLK is 11 bits (+1) */
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
        if (host->power_pin >= 0) {
                if ((ret = omap_request_gpio(host->power_pin)) != 0) {
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index 6073d998b11f..9774fc68b61a 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -450,6 +450,16 @@ static int pxamci_probe(struct platform_device *pdev)
         */
        mmc->max_seg_size = PAGE_SIZE;
+        /*
+         * Block length register is 10 bits.
+         */
+        mmc->max_blk_size = 1023;
+        /*
+         * Block count register is 16 bits.
+         */
+        mmc->max_blk_count = 65535;
        host = mmc_priv(mmc);
        host->mmc = mmc;
        host->dma = -1;
diff --git a/drivers/mmc/sdhci.c b/drivers/mmc/sdhci.c
index c2d13d7e9911..4bf1fea5e2c4 100644
--- a/drivers/mmc/sdhci.c
+++ b/drivers/mmc/sdhci.c
@@ -37,6 +37,7 @@ static unsigned int debug_quirks = 0;
 #define SDHCI_QUIRK_FORCE_DMA                           (1<<1)
 /* Controller doesn't like some resets when there is no card inserted. */
 #define SDHCI_QUIRK_NO_CARD_NO_RESET                    (1<<2)
+#define SDHCI_QUIRK_SINGLE_POWER_WRITE                  (1<<3)
 static const struct pci_device_id pci_ids[] __devinitdata = {
        {
@@ -65,6 +66,14 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                .driver_data    = SDHCI_QUIRK_FORCE_DMA,
        },
+        {
+                .vendor         = PCI_VENDOR_ID_ENE,
+                .device         = PCI_DEVICE_ID_ENE_CB712_SD,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = SDHCI_QUIRK_SINGLE_POWER_WRITE,
+        },
        {       /* Generic SD host controller */
                PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)
        },
@@ -197,15 +206,9 @@ static void sdhci_deactivate_led(struct sdhci_host *host)
 *                                                                           *
 \*****************************************************************************/
-static inline char* sdhci_kmap_sg(struct sdhci_host* host)
+static inline char* sdhci_sg_to_buffer(struct sdhci_host* host)
 {
-        host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ);
+        return page_address(host->cur_sg->page) + host->cur_sg->offset;
-        return host->mapped_sg + host->cur_sg->offset;
-}
-static inline void sdhci_kunmap_sg(struct sdhci_host* host)
-{
-        kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
 }
 static inline int sdhci_next_sg(struct sdhci_host* host)
@@ -240,7 +243,7 @@ static void sdhci_read_block_pio(struct sdhci_host *host)
        chunk_remain = 0;
        data = 0;
-        buffer = sdhci_kmap_sg(host) + host->offset;
+        buffer = sdhci_sg_to_buffer(host) + host->offset;
        while (blksize) {
                if (chunk_remain == 0) {
@@ -264,16 +267,13 @@ static void sdhci_read_block_pio(struct sdhci_host *host)
                }
                if (host->remain == 0) {
-                        sdhci_kunmap_sg(host);
                        if (sdhci_next_sg(host) == 0) {
                                BUG_ON(blksize != 0);
                                return;
                        }
-                        buffer = sdhci_kmap_sg(host);
+                        buffer = sdhci_sg_to_buffer(host);
                }
        }
-        sdhci_kunmap_sg(host);
 }
 static void sdhci_write_block_pio(struct sdhci_host *host)
@@ -290,7 +290,7 @@ static void sdhci_write_block_pio(struct sdhci_host *host)
        data = 0;
        bytes = 0;
-        buffer = sdhci_kmap_sg(host) + host->offset;
+        buffer = sdhci_sg_to_buffer(host) + host->offset;
        while (blksize) {
                size = min(host->size, host->remain);
@@ -314,16 +314,13 @@ static void sdhci_write_block_pio(struct sdhci_host *host)
                }
                if (host->remain == 0) {
-                        sdhci_kunmap_sg(host);
                        if (sdhci_next_sg(host) == 0) {
                                BUG_ON(blksize != 0);
                                return;
                        }
-                        buffer = sdhci_kmap_sg(host);
+                        buffer = sdhci_sg_to_buffer(host);
                }
        }
-        sdhci_kunmap_sg(host);
 }
 static void sdhci_transfer_pio(struct sdhci_host *host)
@@ -372,7 +369,7 @@ static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
        /* Sanity checks */
        BUG_ON(data->blksz * data->blocks > 524288);
-        BUG_ON(data->blksz > host->max_block);
+        BUG_ON(data->blksz > host->mmc->max_blk_size);
        BUG_ON(data->blocks > 65535);
        /* timeout in us */
@@ -674,10 +671,17 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
        if (host->power == power)
                return;
-        writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
+        if (power == (unsigned short)-1) {
+                writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
-        if (power == (unsigned short)-1)
                goto out;
+        }
+        /*
+         * Spec says that we should clear the power reg before setting
+         * a new value. Some controllers don't seem to like this though.
+         */
+        if (!(host->chip->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
+                writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
        pwr = SDHCI_POWER_ON;
@@ -1109,7 +1113,9 @@ static int sdhci_resume (struct pci_dev *pdev)
        pci_set_power_state(pdev, PCI_D0);
        pci_restore_state(pdev);
-        pci_enable_device(pdev);
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
        for (i = 0;i < chip->num_slots;i++) {
                if (!chip->hosts[i])
@@ -1274,15 +1280,6 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
        if (caps & SDHCI_TIMEOUT_CLK_UNIT)
                host->timeout_clk *= 1000;
-        host->max_block = (caps & SDHCI_MAX_BLOCK_MASK) >> SDHCI_MAX_BLOCK_SHIFT;
-        if (host->max_block >= 3) {
-                printk(KERN_ERR "%s: Invalid maximum block size.\n",
-                        host->slot_descr);
-                ret = -ENODEV;
-                goto unmap;
-        }
-        host->max_block = 512 << host->max_block;
        /*
         * Set host parameters.
         */
@@ -1294,9 +1291,9 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
        mmc->ocr_avail = 0;
        if (caps & SDHCI_CAN_VDD_330)
                mmc->ocr_avail |= MMC_VDD_32_33|MMC_VDD_33_34;
-        else if (caps & SDHCI_CAN_VDD_300)
+        if (caps & SDHCI_CAN_VDD_300)
                mmc->ocr_avail |= MMC_VDD_29_30|MMC_VDD_30_31;
-        else if (caps & SDHCI_CAN_VDD_180)
+        if (caps & SDHCI_CAN_VDD_180)
                mmc->ocr_avail |= MMC_VDD_17_18|MMC_VDD_18_19;
        if ((host->max_clk > 25000000) && !(caps & SDHCI_CAN_DO_HISPD)) {
@@ -1326,15 +1323,33 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
        /*
         * Maximum number of sectors in one transfer. Limited by DMA boundary
-         * size (512KiB), which means (512 KiB/512=) 1024 entries.
+         * size (512KiB).
         */
-        mmc->max_sectors = 1024;
+        mmc->max_req_size = 524288;
        /*
         * Maximum segment size. Could be one segment with the maximum number
-         * of sectors.
+         * of bytes.
+         */
+        mmc->max_seg_size = mmc->max_req_size;
+        /*
+         * Maximum block size. This varies from controller to controller and
+         * is specified in the capabilities register.
+         */
+        mmc->max_blk_size = (caps & SDHCI_MAX_BLOCK_MASK) >> SDHCI_MAX_BLOCK_SHIFT;
+        if (mmc->max_blk_size >= 3) {
+                printk(KERN_ERR "%s: Invalid maximum block size.\n",
+                        host->slot_descr);
+                ret = -ENODEV;
+                goto unmap;
+        }
+        mmc->max_blk_size = 512 << mmc->max_blk_size;
+        /*
+         * Maximum block count.
         */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_blk_count = 65535;
        /*
         * Init tasklets.
diff --git a/drivers/mmc/sdhci.h b/drivers/mmc/sdhci.h
index f9d1a0a6f03a..e324f0a623dc 100644
--- a/drivers/mmc/sdhci.h
+++ b/drivers/mmc/sdhci.h
@@ -174,7 +174,6 @@ struct sdhci_host {
        unsigned int            max_clk;        /* Max possible freq (MHz) */
        unsigned int            timeout_clk;    /* Timeout freq (KHz) */
-        unsigned int            max_block;      /* Max block size (bytes) */
        unsigned int            clock;          /* Current clock (MHz) */
        unsigned short          power;          /* Current voltage */
@@ -184,7 +183,6 @@ struct sdhci_host {
        struct mmc_data         *data;          /* Current data request */
        struct scatterlist      *cur_sg;        /* We're working on this */
-        char                    *mapped_sg;     /* This is where it's mapped */
        int                     num_sg;         /* Entries left */
        int                     offset;         /* Offset into current sg */
        int                     remain;         /* Bytes left in current */
diff --git a/drivers/mmc/tifm_sd.c b/drivers/mmc/tifm_sd.c
index fa4a52886b97..e65f8a0a9349 100644
--- a/drivers/mmc/tifm_sd.c
+++ b/drivers/mmc/tifm_sd.c
@@ -17,7 +17,7 @@
 #include <asm/io.h>
 #define DRIVER_NAME "tifm_sd"
-#define DRIVER_VERSION "0.6"
+#define DRIVER_VERSION "0.7"
 static int no_dma = 0;
 static int fixed_timeout = 0;
@@ -79,7 +79,6 @@ typedef enum {
 enum {
        FIFO_RDY   = 0x0001,     /* hardware dependent value */
-        HOST_REG   = 0x0002,
        EJECT      = 0x0004,
        EJECT_DONE = 0x0008,
        CARD_BUSY  = 0x0010,
@@ -95,46 +94,53 @@ struct tifm_sd {
        card_state_t        state;
        unsigned int        clk_freq;
        unsigned int        clk_div;
-        unsigned long       timeout_jiffies; // software timeout - 2 sec
+        unsigned long       timeout_jiffies;
+        struct tasklet_struct finish_tasklet;
+        struct timer_list     timer;
        struct mmc_request    *req;
-        struct work_struct    cmd_handler;
+        wait_queue_head_t     notify;
-        struct delayed_work   abort_handler;
-        wait_queue_head_t     can_eject;
        size_t                written_blocks;
-        char                  *buffer;
        size_t                buffer_size;
        size_t                buffer_pos;
 };
+static char* tifm_sd_data_buffer(struct mmc_data *data)
+{
+        return page_address(data->sg->page) + data->sg->offset;
+}
 static int tifm_sd_transfer_data(struct tifm_dev *sock, struct tifm_sd *host,
-                                        unsigned int host_status)
+                                 unsigned int host_status)
 {
        struct mmc_command *cmd = host->req->cmd;
        unsigned int t_val = 0, cnt = 0;
+        char *buffer;
        if (host_status & TIFM_MMCSD_BRS) {
                /* in non-dma rx mode BRS fires when fifo is still not empty */
-                if (host->buffer && (cmd->data->flags & MMC_DATA_READ)) {
+                if (no_dma && (cmd->data->flags & MMC_DATA_READ)) {
+                        buffer = tifm_sd_data_buffer(host->req->data);
                        while (host->buffer_size > host->buffer_pos) {
                                t_val = readl(sock->addr + SOCK_MMCSD_DATA);
-                                host->buffer[host->buffer_pos++] = t_val & 0xff;
+                                buffer[host->buffer_pos++] = t_val & 0xff;
-                                host->buffer[host->buffer_pos++] =
+                                buffer[host->buffer_pos++] =
                                                        (t_val >> 8) & 0xff;
                        }
                }
                return 1;
-        } else if (host->buffer) {
+        } else if (no_dma) {
+                buffer = tifm_sd_data_buffer(host->req->data);
                if ((cmd->data->flags & MMC_DATA_READ) &&
                                (host_status & TIFM_MMCSD_AF)) {
                        for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
                                t_val = readl(sock->addr + SOCK_MMCSD_DATA);
                                if (host->buffer_size > host->buffer_pos) {
-                                        host->buffer[host->buffer_pos++] =
+                                        buffer[host->buffer_pos++] =
                                                        t_val & 0xff;
-                                        host->buffer[host->buffer_pos++] =
+                                        buffer[host->buffer_pos++] =
                                                        (t_val >> 8) & 0xff;
                                }
                        }
@@ -142,11 +148,12 @@ static int tifm_sd_transfer_data(struct tifm_dev *sock, struct tifm_sd *host,
                           && (host_status & TIFM_MMCSD_AE)) {
                        for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
                                if (host->buffer_size > host->buffer_pos) {
-                                        t_val = host->buffer[host->buffer_pos++] & 0x00ff;
+                                        t_val = buffer[host->buffer_pos++]
-                                        t_val |= ((host->buffer[host->buffer_pos++]) << 8)
+                                                & 0x00ff;
-                                                 & 0xff00;
+                                        t_val |= ((buffer[host->buffer_pos++])
+                                                  << 8) & 0xff00;
                                        writel(t_val,
-                                                sock->addr + SOCK_MMCSD_DATA);
+                                               sock->addr + SOCK_MMCSD_DATA);
                                }
                        }
                }
@@ -206,7 +213,7 @@ static void tifm_sd_exec(struct tifm_sd *host, struct mmc_command *cmd)
                cmd_mask |= TIFM_MMCSD_READ;
        dev_dbg(&sock->dev, "executing opcode 0x%x, arg: 0x%x, mask: 0x%x\n",
-                                cmd->opcode, cmd->arg, cmd_mask);
+                cmd->opcode, cmd->arg, cmd_mask);
        writel((cmd->arg >> 16) & 0xffff, sock->addr + SOCK_MMCSD_ARG_HIGH);
        writel(cmd->arg & 0xffff, sock->addr + SOCK_MMCSD_ARG_LOW);
@@ -239,65 +246,78 @@ change_state:
                        tifm_sd_fetch_resp(cmd, sock);
                        if (cmd->data) {
                                host->state = BRS;
-                        } else
+                        } else {
                                host->state = READY;
+                        }
                        goto change_state;
                }
                break;
        case BRS:
                if (tifm_sd_transfer_data(sock, host, host_status)) {
-                        if (!host->req->stop) {
+                        if (cmd->data->flags & MMC_DATA_WRITE) {
-                                if (cmd->data->flags & MMC_DATA_WRITE) {
+                                host->state = CARD;
-                                        host->state = CARD;
+                        } else {
+                                if (no_dma) {
+                                        if (host->req->stop) {
+                                                tifm_sd_exec(host, host->req->stop);
+                                                host->state = SCMD;
+                                        } else {
+                                                host->state = READY;
+                                        }
                                } else {
-                                        host->state =
+                                        host->state = FIFO;
-                                                host->buffer ? READY : FIFO;
                                }
-                                goto change_state;
                        }
-                        tifm_sd_exec(host, host->req->stop);
+                        goto change_state;
-                        host->state = SCMD;
                }
                break;
        case SCMD:
                if (host_status & TIFM_MMCSD_EOC) {
                        tifm_sd_fetch_resp(host->req->stop, sock);
-                        if (cmd->error) {
+                        host->state = READY;
-                                host->state = READY;
-                        } else if (cmd->data->flags & MMC_DATA_WRITE) {
-                                host->state = CARD;
-                        } else {
-                                host->state = host->buffer ? READY : FIFO;
-                        }
                        goto change_state;
                }
                break;
        case CARD:
+                dev_dbg(&sock->dev, "waiting for CARD, have %zd blocks\n",
+                        host->written_blocks);
                if (!(host->flags & CARD_BUSY)
                    && (host->written_blocks == cmd->data->blocks)) {
-                        host->state = host->buffer ? READY : FIFO;
+                        if (no_dma) {
+                                if (host->req->stop) {
+                                        tifm_sd_exec(host, host->req->stop);
+                                        host->state = SCMD;
+                                } else {
+                                        host->state = READY;
+                                }
+                        } else {
+                                host->state = FIFO;
+                        }
                        goto change_state;
                }
                break;
        case FIFO:
                if (host->flags & FIFO_RDY) {
-                        host->state = READY;
                        host->flags &= ~FIFO_RDY;
+                        if (host->req->stop) {
+                                tifm_sd_exec(host, host->req->stop);
+                                host->state = SCMD;
+                        } else {
+                                host->state = READY;
+                        }
                        goto change_state;
                }
                break;
        case READY:
-                queue_work(sock->wq, &host->cmd_handler);
+                tasklet_schedule(&host->finish_tasklet);
                return;
        }
-        queue_delayed_work(sock->wq, &host->abort_handler,
-                                host->timeout_jiffies);
 }
 /* Called from interrupt handler */
-static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
+static void tifm_sd_signal_irq(struct tifm_dev *sock,
-                                        unsigned int sock_irq_status)
+                               unsigned int sock_irq_status)
 {
        struct tifm_sd *host;
        unsigned int host_status = 0, fifo_status = 0;
@@ -305,7 +325,6 @@ static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
        spin_lock(&sock->lock);
        host = mmc_priv((struct mmc_host*)tifm_get_drvdata(sock));
-        cancel_delayed_work(&host->abort_handler);
        if (sock_irq_status & FIFO_EVENT) {
                fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
@@ -318,19 +337,17 @@ static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
                host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
                writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
-                if (!(host->flags & HOST_REG))
-                        queue_work(sock->wq, &host->cmd_handler);
                if (!host->req)
                        goto done;
                if (host_status & TIFM_MMCSD_ERRMASK) {
                        if (host_status & TIFM_MMCSD_CERR)
                                error_code = MMC_ERR_FAILED;
-                        else if (host_status &
+                        else if (host_status
-                                        (TIFM_MMCSD_CTO | TIFM_MMCSD_DTO))
+                                 & (TIFM_MMCSD_CTO | TIFM_MMCSD_DTO))
                                error_code = MMC_ERR_TIMEOUT;
-                        else if (host_status &
+                        else if (host_status
-                                        (TIFM_MMCSD_CCRC | TIFM_MMCSD_DCRC))
+                                 & (TIFM_MMCSD_CCRC | TIFM_MMCSD_DCRC))
                                error_code = MMC_ERR_BADCRC;
                        writel(TIFM_FIFO_INT_SETALL,
@@ -340,12 +357,11 @@ static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
                        if (host->req->stop) {
                                if (host->state == SCMD) {
                                        host->req->stop->error = error_code;
-                                } else if(host->state == BRS) {
+                                } else if (host->state == BRS
+                                           || host->state == CARD
+                                           || host->state == FIFO) {
                                        host->req->cmd->error = error_code;
                                        tifm_sd_exec(host, host->req->stop);
-                                        queue_delayed_work(sock->wq,
-                                                &host->abort_handler,
-                                                host->timeout_jiffies);
                                        host->state = SCMD;
                                        goto done;
                                } else {
@@ -359,8 +375,8 @@ static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
                if (host_status & TIFM_MMCSD_CB)
                        host->flags |= CARD_BUSY;
-                if ((host_status & TIFM_MMCSD_EOFB) &&
+                if ((host_status & TIFM_MMCSD_EOFB)
-                                (host->flags & CARD_BUSY)) {
+                    && (host->flags & CARD_BUSY)) {
                        host->written_blocks++;
                        host->flags &= ~CARD_BUSY;
                }
@@ -370,22 +386,22 @@ static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
                tifm_sd_process_cmd(sock, host, host_status);
 done:
        dev_dbg(&sock->dev, "host_status %x, fifo_status %x\n",
-                        host_status, fifo_status);
+                host_status, fifo_status);
        spin_unlock(&sock->lock);
-        return sock_irq_status;
 }
-static void tifm_sd_prepare_data(struct tifm_sd *card, struct mmc_command *cmd)
+static void tifm_sd_prepare_data(struct tifm_sd *host, struct mmc_command *cmd)
 {
-        struct tifm_dev *sock = card->dev;
+        struct tifm_dev *sock = host->dev;
        unsigned int dest_cnt;
        /* DMA style IO */
+        dev_dbg(&sock->dev, "setting dma for %d blocks\n",
+                cmd->data->blocks);
        writel(TIFM_FIFO_INT_SETALL,
-                sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
+               sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
        writel(ilog2(cmd->data->blksz) - 2,
-                        sock->addr + SOCK_FIFO_PAGE_SIZE);
+               sock->addr + SOCK_FIFO_PAGE_SIZE);
        writel(TIFM_FIFO_ENABLE, sock->addr + SOCK_FIFO_CONTROL);
        writel(TIFM_FIFO_INTMASK, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
@@ -399,7 +415,7 @@ static void tifm_sd_prepare_data(struct tifm_sd *card, struct mmc_command *cmd)
        if (cmd->data->flags & MMC_DATA_WRITE) {
                writel(TIFM_MMCSD_TXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
                writel(dest_cnt | TIFM_DMA_TX | TIFM_DMA_EN,
-                        sock->addr + SOCK_DMA_CONTROL);
+                       sock->addr + SOCK_DMA_CONTROL);
        } else {
                writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
                writel(dest_cnt | TIFM_DMA_EN, sock->addr + SOCK_DMA_CONTROL);
@@ -407,7 +423,7 @@ static void tifm_sd_prepare_data(struct tifm_sd *card, struct mmc_command *cmd)
 }
 static void tifm_sd_set_data_timeout(struct tifm_sd *host,
-                                        struct mmc_data *data)
+                                     struct mmc_data *data)
 {
        struct tifm_dev *sock = host->dev;
        unsigned int data_timeout = data->timeout_clks;
@@ -416,22 +432,21 @@ static void tifm_sd_set_data_timeout(struct tifm_sd *host,
                return;
        data_timeout += data->timeout_ns /
-                        ((1000000000 / host->clk_freq) * host->clk_div);
+                        ((1000000000UL / host->clk_freq) * host->clk_div);
-        data_timeout *= 10; // call it fudge factor for now
        if (data_timeout < 0xffff) {
-                writel((~TIFM_MMCSD_DPE) &
-                                readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
-                       sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
                writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
+                writel((~TIFM_MMCSD_DPE)
+                       & readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
+                       sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
        } else {
-                writel(TIFM_MMCSD_DPE |
-                                readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
-                        sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
                data_timeout = (data_timeout >> 10) + 1;
-                if(data_timeout > 0xffff)
+                if (data_timeout > 0xffff)
                        data_timeout = 0;       /* set to unlimited */
                writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
+                writel(TIFM_MMCSD_DPE
+                       | readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
+                       sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
        }
 }
@@ -474,11 +489,10 @@ static void tifm_sd_request(struct mmc_host *mmc, struct mmc_request *mrq)
        }
        host->req = mrq;
+        mod_timer(&host->timer, jiffies + host->timeout_jiffies);
        host->state = CMD;
-        queue_delayed_work(sock->wq, &host->abort_handler,
-                                host->timeout_jiffies);
        writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
-                sock->addr + SOCK_CONTROL);
+               sock->addr + SOCK_CONTROL);
        tifm_sd_exec(host, mrq->cmd);
        spin_unlock_irqrestore(&sock->lock, flags);
        return;
@@ -493,9 +507,9 @@ err_out:
        mmc_request_done(mmc, mrq);
 }
-static void tifm_sd_end_cmd(struct work_struct *work)
+static void tifm_sd_end_cmd(unsigned long data)
 {
-        struct tifm_sd *host = container_of(work, struct tifm_sd, cmd_handler);
+        struct tifm_sd *host = (struct tifm_sd*)data;
        struct tifm_dev *sock = host->dev;
        struct mmc_host *mmc = tifm_get_drvdata(sock);
        struct mmc_request *mrq;
@@ -504,6 +518,7 @@ static void tifm_sd_end_cmd(struct work_struct *work)
        spin_lock_irqsave(&sock->lock, flags);
+        del_timer(&host->timer);
        mrq = host->req;
        host->req = NULL;
        host->state = IDLE;
@@ -517,8 +532,8 @@ static void tifm_sd_end_cmd(struct work_struct *work)
        r_data = mrq->cmd->data;
        if (r_data) {
                if (r_data->flags & MMC_DATA_WRITE) {
-                        r_data->bytes_xfered = host->written_blocks *
+                        r_data->bytes_xfered = host->written_blocks
-                                                r_data->blksz;
+                                               * r_data->blksz;
                } else {
                        r_data->bytes_xfered = r_data->blocks -
                                readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
@@ -532,7 +547,7 @@ static void tifm_sd_end_cmd(struct work_struct *work)
        }
        writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
-                        sock->addr + SOCK_CONTROL);
+               sock->addr + SOCK_CONTROL);
        spin_unlock_irqrestore(&sock->lock, flags);
        mmc_request_done(mmc, mrq);
@@ -544,15 +559,6 @@ static void tifm_sd_request_nodma(struct mmc_host *mmc, struct mmc_request *mrq)
        struct tifm_dev *sock = host->dev;
        unsigned long flags;
        struct mmc_data *r_data = mrq->cmd->data;
-        char *t_buffer = NULL;
-        if (r_data) {
-                t_buffer = kmap(r_data->sg->page);
-                if (!t_buffer) {
-                        printk(KERN_ERR DRIVER_NAME ": kmap failed\n");
-                        goto err_out;
-                }
-        }
        spin_lock_irqsave(&sock->lock, flags);
        if (host->flags & EJECT) {
@@ -569,15 +575,14 @@ static void tifm_sd_request_nodma(struct mmc_host *mmc, struct mmc_request *mrq)
        if (r_data) {
                tifm_sd_set_data_timeout(host, r_data);
-                host->buffer = t_buffer + r_data->sg->offset;
+                host->buffer_size = mrq->cmd->data->blocks
-                host->buffer_size = mrq->cmd->data->blocks *
+                                    * mrq->cmd->data->blksz;
-                                        mrq->cmd->data->blksz;
-                writel(TIFM_MMCSD_BUFINT |
+                writel(TIFM_MMCSD_BUFINT
-                                readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
+                       | readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
                       sock->addr + SOCK_MMCSD_INT_ENABLE);
-                writel(((TIFM_MMCSD_FIFO_SIZE - 1) << 8) |
+                writel(((TIFM_MMCSD_FIFO_SIZE - 1) << 8)
-                                (TIFM_MMCSD_FIFO_SIZE - 1),
+                       | (TIFM_MMCSD_FIFO_SIZE - 1),
                       sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
                host->written_blocks = 0;
@@ -588,26 +593,22 @@ static void tifm_sd_request_nodma(struct mmc_host *mmc, struct mmc_request *mrq)
        }
        host->req = mrq;
+        mod_timer(&host->timer, jiffies + host->timeout_jiffies);
        host->state = CMD;
-        queue_delayed_work(sock->wq, &host->abort_handler,
-                                host->timeout_jiffies);
        writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
-                sock->addr + SOCK_CONTROL);
+               sock->addr + SOCK_CONTROL);
        tifm_sd_exec(host, mrq->cmd);
        spin_unlock_irqrestore(&sock->lock, flags);
        return;
 err_out:
-        if (t_buffer)
-                kunmap(r_data->sg->page);
        mrq->cmd->error = MMC_ERR_TIMEOUT;
        mmc_request_done(mmc, mrq);
 }
-static void tifm_sd_end_cmd_nodma(struct work_struct *work)
+static void tifm_sd_end_cmd_nodma(unsigned long data)
 {
-        struct tifm_sd *host = container_of(work, struct tifm_sd, cmd_handler);
+        struct tifm_sd *host = (struct tifm_sd*)data;
        struct tifm_dev *sock = host->dev;
        struct mmc_host *mmc = tifm_get_drvdata(sock);
        struct mmc_request *mrq;
@@ -616,6 +617,7 @@ static void tifm_sd_end_cmd_nodma(struct work_struct *work)
        spin_lock_irqsave(&sock->lock, flags);
+        del_timer(&host->timer);
        mrq = host->req;
        host->req = NULL;
        host->state = IDLE;
@@ -633,8 +635,8 @@ static void tifm_sd_end_cmd_nodma(struct work_struct *work)
                        sock->addr + SOCK_MMCSD_INT_ENABLE);
                if (r_data->flags & MMC_DATA_WRITE) {
-                        r_data->bytes_xfered = host->written_blocks *
+                        r_data->bytes_xfered = host->written_blocks
-                                                r_data->blksz;
+                                               * r_data->blksz;
                } else {
                        r_data->bytes_xfered = r_data->blocks -
                                readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
@@ -642,29 +644,44 @@ static void tifm_sd_end_cmd_nodma(struct work_struct *work)
                        r_data->bytes_xfered += r_data->blksz -
                                readl(sock->addr + SOCK_MMCSD_BLOCK_LEN) + 1;
                }
-                host->buffer = NULL;
                host->buffer_pos = 0;
                host->buffer_size = 0;
        }
        writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
-                        sock->addr + SOCK_CONTROL);
+               sock->addr + SOCK_CONTROL);
        spin_unlock_irqrestore(&sock->lock, flags);
-        if (r_data)
-                kunmap(r_data->sg->page);
        mmc_request_done(mmc, mrq);
 }
-static void tifm_sd_abort(struct work_struct *work)
+static void tifm_sd_terminate(struct tifm_sd *host)
+{
+        struct tifm_dev *sock = host->dev;
+        unsigned long flags;
+        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
+        mmiowb();
+        spin_lock_irqsave(&sock->lock, flags);
+        host->flags |= EJECT;
+        if (host->req) {
+                writel(TIFM_FIFO_INT_SETALL,
+                       sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
+                writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
+                tasklet_schedule(&host->finish_tasklet);
+        }
+        spin_unlock_irqrestore(&sock->lock, flags);
+}
+static void tifm_sd_abort(unsigned long data)
 {
-        struct tifm_sd *host =
+        struct tifm_sd *host = (struct tifm_sd*)data;
-                container_of(work, struct tifm_sd, abort_handler.work);
        printk(KERN_ERR DRIVER_NAME
-                ": card failed to respond for a long period of time");
+               ": card failed to respond for a long period of time");
+        tifm_sd_terminate(host);
        tifm_eject(host->dev);
 }
@@ -683,9 +700,9 @@ static void tifm_sd_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                writel(TIFM_MMCSD_4BBUS | readl(sock->addr + SOCK_MMCSD_CONFIG),
                       sock->addr + SOCK_MMCSD_CONFIG);
        } else {
-                writel((~TIFM_MMCSD_4BBUS) &
+                writel((~TIFM_MMCSD_4BBUS)
-                                readl(sock->addr + SOCK_MMCSD_CONFIG),
+                       & readl(sock->addr + SOCK_MMCSD_CONFIG),
-                        sock->addr + SOCK_MMCSD_CONFIG);
+                       sock->addr + SOCK_MMCSD_CONFIG);
        }
        if (ios->clock) {
@@ -704,23 +721,24 @@ static void tifm_sd_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                if ((20000000 / clk_div1) > (24000000 / clk_div2)) {
                        host->clk_freq = 20000000;
                        host->clk_div = clk_div1;
-                        writel((~TIFM_CTRL_FAST_CLK) &
+                        writel((~TIFM_CTRL_FAST_CLK)
-                                        readl(sock->addr + SOCK_CONTROL),
+                               & readl(sock->addr + SOCK_CONTROL),
-                                sock->addr + SOCK_CONTROL);
+                               sock->addr + SOCK_CONTROL);
                } else {
                        host->clk_freq = 24000000;
                        host->clk_div = clk_div2;
-                        writel(TIFM_CTRL_FAST_CLK |
+                        writel(TIFM_CTRL_FAST_CLK
-                                        readl(sock->addr + SOCK_CONTROL),
+                               | readl(sock->addr + SOCK_CONTROL),
-                                sock->addr + SOCK_CONTROL);
+                               sock->addr + SOCK_CONTROL);
                }
        } else {
                host->clk_div = 0;
        }
        host->clk_div &= TIFM_MMCSD_CLKMASK;
-        writel(host->clk_div | ((~TIFM_MMCSD_CLKMASK) &
+        writel(host->clk_div
-                        readl(sock->addr + SOCK_MMCSD_CONFIG)),
+               | ((~TIFM_MMCSD_CLKMASK)
-                sock->addr + SOCK_MMCSD_CONFIG);
+                  & readl(sock->addr + SOCK_MMCSD_CONFIG)),
+               sock->addr + SOCK_MMCSD_CONFIG);
        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
                host->flags |= OPENDRAIN;
@@ -734,7 +752,7 @@ static void tifm_sd_ios(struct mmc_host *mmc, struct mmc_ios *ios)
        // allow removal.
        if ((host->flags & EJECT) && ios->power_mode == MMC_POWER_OFF) {
                host->flags |= EJECT_DONE;
-                wake_up_all(&host->can_eject);
+                wake_up_all(&host->notify);
        }
        spin_unlock_irqrestore(&sock->lock, flags);
@@ -762,20 +780,67 @@ static struct mmc_host_ops tifm_sd_ops = {
        .get_ro  = tifm_sd_ro
 };
-static void tifm_sd_register_host(struct work_struct *work)
+static int tifm_sd_initialize_host(struct tifm_sd *host)
 {
-        struct tifm_sd *host = container_of(work, struct tifm_sd, cmd_handler);
+        int rc;
+        unsigned int host_status = 0;
        struct tifm_dev *sock = host->dev;
-        struct mmc_host *mmc = tifm_get_drvdata(sock);
-        unsigned long flags;
-        spin_lock_irqsave(&sock->lock, flags);
+        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
-        host->flags |= HOST_REG;
+        mmiowb();
-        PREPARE_WORK(&host->cmd_handler,
+        host->clk_div = 61;
-                        no_dma ? tifm_sd_end_cmd_nodma : tifm_sd_end_cmd);
+        host->clk_freq = 20000000;
-        spin_unlock_irqrestore(&sock->lock, flags);
+        writel(TIFM_MMCSD_RESET, sock->addr + SOCK_MMCSD_SYSTEM_CONTROL);
-        dev_dbg(&sock->dev, "adding host\n");
+        writel(host->clk_div | TIFM_MMCSD_POWER,
-        mmc_add_host(mmc);
+               sock->addr + SOCK_MMCSD_CONFIG);
+        /* wait up to 0.51 sec for reset */
+        for (rc = 2; rc <= 256; rc <<= 1) {
+                if (1 & readl(sock->addr + SOCK_MMCSD_SYSTEM_STATUS)) {
+                        rc = 0;
+                        break;
+                }
+                msleep(rc);
+        }
+        if (rc) {
+                printk(KERN_ERR DRIVER_NAME
+                       ": controller failed to reset\n");
+                return -ENODEV;
+        }
+        writel(0, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
+        writel(host->clk_div | TIFM_MMCSD_POWER,
+               sock->addr + SOCK_MMCSD_CONFIG);
+        writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+        // command timeout fixed to 64 clocks for now
+        writel(64, sock->addr + SOCK_MMCSD_COMMAND_TO);
+        writel(TIFM_MMCSD_INAB, sock->addr + SOCK_MMCSD_COMMAND);
+        /* INAB should take much less than reset */
+        for (rc = 1; rc <= 16; rc <<= 1) {
+                host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
+                writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
+                if (!(host_status & TIFM_MMCSD_ERRMASK)
+                    && (host_status & TIFM_MMCSD_EOC)) {
+                        rc = 0;
+                        break;
+                }
+                msleep(rc);
+        }
+        if (rc) {
+                printk(KERN_ERR DRIVER_NAME
+                       ": card not ready - probe failed on initialization\n");
+                return -ENODEV;
+        }
+        writel(TIFM_MMCSD_DATAMASK | TIFM_MMCSD_ERRMASK,
+               sock->addr + SOCK_MMCSD_INT_ENABLE);
+        mmiowb();
+        return 0;
 }
 static int tifm_sd_probe(struct tifm_dev *sock)
@@ -784,8 +849,8 @@ static int tifm_sd_probe(struct tifm_dev *sock)
        struct tifm_sd *host;
        int rc = -EIO;
-        if (!(TIFM_SOCK_STATE_OCCUPIED &
+        if (!(TIFM_SOCK_STATE_OCCUPIED
-                        readl(sock->addr + SOCK_PRESENT_STATE))) {
+              & readl(sock->addr + SOCK_PRESENT_STATE))) {
                printk(KERN_WARNING DRIVER_NAME ": card gone, unexpectedly\n");
                return rc;
        }
@@ -795,109 +860,99 @@ static int tifm_sd_probe(struct tifm_dev *sock)
                return -ENOMEM;
        host = mmc_priv(mmc);
-        host->dev = sock;
-        host->clk_div = 61;
-        init_waitqueue_head(&host->can_eject);
-        INIT_WORK(&host->cmd_handler, tifm_sd_register_host);
-        INIT_DELAYED_WORK(&host->abort_handler, tifm_sd_abort);
        tifm_set_drvdata(sock, mmc);
-        sock->signal_irq = tifm_sd_signal_irq;
+        host->dev = sock;
-        host->clk_freq = 20000000;
        host->timeout_jiffies = msecs_to_jiffies(1000);
+        init_waitqueue_head(&host->notify);
+        tasklet_init(&host->finish_tasklet,
+                     no_dma ? tifm_sd_end_cmd_nodma : tifm_sd_end_cmd,
+                     (unsigned long)host);
+        setup_timer(&host->timer, tifm_sd_abort, (unsigned long)host);
        tifm_sd_ops.request = no_dma ? tifm_sd_request_nodma : tifm_sd_request;
        mmc->ops = &tifm_sd_ops;
        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
-        mmc->caps = MMC_CAP_4_BIT_DATA;
+        mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE;
        mmc->f_min = 20000000 / 60;
        mmc->f_max = 24000000;
        mmc->max_hw_segs = 1;
        mmc->max_phys_segs = 1;
-        mmc->max_sectors = 127;
+        // limited by DMA counter - it's safer to stick with
-        mmc->max_seg_size = mmc->max_sectors << 11; //2k maximum hw block length
+        // block counter has 11 bits though
+        mmc->max_blk_count = 256;
-        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
+        // 2k maximum hw block length
-        writel(TIFM_MMCSD_RESET, sock->addr + SOCK_MMCSD_SYSTEM_CONTROL);
+        mmc->max_blk_size = 2048;
-        writel(host->clk_div | TIFM_MMCSD_POWER,
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
-                        sock->addr + SOCK_MMCSD_CONFIG);
+        mmc->max_seg_size = mmc->max_req_size;
+        sock->signal_irq = tifm_sd_signal_irq;
+        rc = tifm_sd_initialize_host(host);
-        for (rc = 0; rc < 50; rc++) {
+        if (!rc)
-                /* Wait for reset ack */
+                rc = mmc_add_host(mmc);
-                if (1 & readl(sock->addr + SOCK_MMCSD_SYSTEM_STATUS)) {
+        if (rc)
-                        rc = 0;
+                goto out_free_mmc;
-                        break;
-                }
-                msleep(10);
-        }
-        if (rc) {
+        return 0;
-                printk(KERN_ERR DRIVER_NAME
+out_free_mmc:
-                        ": card not ready - probe failed\n");
+        mmc_free_host(mmc);
-                mmc_free_host(mmc);
+        return rc;
-                return -ENODEV;
+}
-        }
-        writel(0, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
+static void tifm_sd_remove(struct tifm_dev *sock)
-        writel(host->clk_div | TIFM_MMCSD_POWER,
+{
-                        sock->addr + SOCK_MMCSD_CONFIG);
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
-        writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+        struct tifm_sd *host = mmc_priv(mmc);
-        writel(TIFM_MMCSD_DATAMASK | TIFM_MMCSD_ERRMASK,
-                        sock->addr + SOCK_MMCSD_INT_ENABLE);
-        writel(64, sock->addr + SOCK_MMCSD_COMMAND_TO); // command timeout 64 clocks for now
+        del_timer_sync(&host->timer);
-        writel(TIFM_MMCSD_INAB, sock->addr + SOCK_MMCSD_COMMAND);
+        tifm_sd_terminate(host);
-        writel(host->clk_div | TIFM_MMCSD_POWER,
+        wait_event_timeout(host->notify, host->flags & EJECT_DONE,
-                        sock->addr + SOCK_MMCSD_CONFIG);
+                           host->timeout_jiffies);
+        tasklet_kill(&host->finish_tasklet);
+        mmc_remove_host(mmc);
-        queue_delayed_work(sock->wq, &host->abort_handler,
+        /* The meaning of the bit majority in this constant is unknown. */
-                        host->timeout_jiffies);
+        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
+               sock->addr + SOCK_CONTROL);
-        return 0;
+        tifm_set_drvdata(sock, NULL);
+        mmc_free_host(mmc);
 }
-static int tifm_sd_host_is_down(struct tifm_dev *sock)
+#ifdef CONFIG_PM
+static int tifm_sd_suspend(struct tifm_dev *sock, pm_message_t state)
 {
        struct mmc_host *mmc = tifm_get_drvdata(sock);
-        struct tifm_sd *host = mmc_priv(mmc);
+        int rc;
-        unsigned long flags;
-        int rc = 0;
-        spin_lock_irqsave(&sock->lock, flags);
+        rc = mmc_suspend_host(mmc, state);
-        rc = (host->flags & EJECT_DONE);
+        /* The meaning of the bit majority in this constant is unknown. */
-        spin_unlock_irqrestore(&sock->lock, flags);
+        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
+               sock->addr + SOCK_CONTROL);
        return rc;
 }
-static void tifm_sd_remove(struct tifm_dev *sock)
+static int tifm_sd_resume(struct tifm_dev *sock)
 {
        struct mmc_host *mmc = tifm_get_drvdata(sock);
        struct tifm_sd *host = mmc_priv(mmc);
-        unsigned long flags;
-        spin_lock_irqsave(&sock->lock, flags);
+        if (sock->media_id != FM_SD
-        host->flags |= EJECT;
+            || tifm_sd_initialize_host(host)) {
-        if (host->req)
+                tifm_eject(sock);
-                queue_work(sock->wq, &host->cmd_handler);
+                return 0;
-        spin_unlock_irqrestore(&sock->lock, flags);
+        } else {
-        wait_event_timeout(host->can_eject, tifm_sd_host_is_down(sock),
+                return mmc_resume_host(mmc);
-                                host->timeout_jiffies);
+        }
+}
-        if (host->flags & HOST_REG)
+#else
-                mmc_remove_host(mmc);
-        /* The meaning of the bit majority in this constant is unknown. */
+#define tifm_sd_suspend NULL
-        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
+#define tifm_sd_resume NULL
-                sock->addr + SOCK_CONTROL);
-        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
-        writel(TIFM_FIFO_INT_SETALL,
-                sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
-        writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
-        tifm_set_drvdata(sock, NULL);
+#endif /* CONFIG_PM */
-        mmc_free_host(mmc);
-}
 static tifm_media_id tifm_sd_id_tbl[] = {
        FM_SD, 0
@@ -910,7 +965,9 @@ static struct tifm_driver tifm_sd_driver = {
        },
        .id_table = tifm_sd_id_tbl,
        .probe    = tifm_sd_probe,
-        .remove   = tifm_sd_remove
+        .remove   = tifm_sd_remove,
+        .suspend  = tifm_sd_suspend,
+        .resume   = tifm_sd_resume
 };
 static int __init tifm_sd_init(void)
diff --git a/drivers/mmc/wbsd.c b/drivers/mmc/wbsd.c
index 7a282672f8e9..a44d8777ab9f 100644
--- a/drivers/mmc/wbsd.c
+++ b/drivers/mmc/wbsd.c
@@ -1,7 +1,7 @@
 /*
 *  linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
 *
- *  Copyright (C) 2004-2005 Pierre Ossman, All Rights Reserved.
+ *  Copyright (C) 2004-2006 Pierre Ossman, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -272,16 +272,9 @@ static inline int wbsd_next_sg(struct wbsd_host *host)
        return host->num_sg;
 }
-static inline char *wbsd_kmap_sg(struct wbsd_host *host)
+static inline char *wbsd_sg_to_buffer(struct wbsd_host *host)
 {
-        host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ) +
+        return page_address(host->cur_sg->page) + host->cur_sg->offset;
-                host->cur_sg->offset;
-        return host->mapped_sg;
-}
-static inline void wbsd_kunmap_sg(struct wbsd_host *host)
-{
-        kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
 }
 static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
@@ -302,12 +295,11 @@ static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
         * we do not transfer too much.
         */
        for (i = 0; i < len; i++) {
-                sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
+                sgbuf = page_address(sg[i].page) + sg[i].offset;
                if (size < sg[i].length)
                        memcpy(dmabuf, sgbuf, size);
                else
                        memcpy(dmabuf, sgbuf, sg[i].length);
-                kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
                dmabuf += sg[i].length;
                if (size < sg[i].length)
@@ -347,7 +339,7 @@ static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data)
         * we do not transfer too much.
         */
        for (i = 0; i < len; i++) {
-                sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
+                sgbuf = page_address(sg[i].page) + sg[i].offset;
                if (size < sg[i].length)
                        memcpy(sgbuf, dmabuf, size);
                else
@@ -497,7 +489,7 @@ static void wbsd_empty_fifo(struct wbsd_host *host)
        if (data->bytes_xfered == host->size)
                return;
-        buffer = wbsd_kmap_sg(host) + host->offset;
+        buffer = wbsd_sg_to_buffer(host) + host->offset;
        /*
         * Drain the fifo. This has a tendency to loop longer
@@ -526,17 +518,13 @@ static void wbsd_empty_fifo(struct wbsd_host *host)
                        /*
                         * Transfer done?
                         */
-                        if (data->bytes_xfered == host->size) {
+                        if (data->bytes_xfered == host->size)
-                                wbsd_kunmap_sg(host);
                                return;
-                        }
                        /*
                         * End of scatter list entry?
                         */
                        if (host->remain == 0) {
-                                wbsd_kunmap_sg(host);
                                /*
                                 * Get next entry. Check if last.
                                 */
@@ -554,13 +542,11 @@ static void wbsd_empty_fifo(struct wbsd_host *host)
                                        return;
                                }
-                                buffer = wbsd_kmap_sg(host);
+                                buffer = wbsd_sg_to_buffer(host);
                        }
                }
        }
-        wbsd_kunmap_sg(host);
        /*
         * This is a very dirty hack to solve a
         * hardware problem. The chip doesn't trigger
@@ -583,7 +569,7 @@ static void wbsd_fill_fifo(struct wbsd_host *host)
        if (data->bytes_xfered == host->size)
                return;
-        buffer = wbsd_kmap_sg(host) + host->offset;
+        buffer = wbsd_sg_to_buffer(host) + host->offset;
        /*
         * Fill the fifo. This has a tendency to loop longer
@@ -612,17 +598,13 @@ static void wbsd_fill_fifo(struct wbsd_host *host)
                        /*
                         * Transfer done?
                         */
-                        if (data->bytes_xfered == host->size) {
+                        if (data->bytes_xfered == host->size)
-                                wbsd_kunmap_sg(host);
                                return;
-                        }
                        /*
                         * End of scatter list entry?
                         */
                        if (host->remain == 0) {
-                                wbsd_kunmap_sg(host);
                                /*
                                 * Get next entry. Check if last.
                                 */
@@ -640,13 +622,11 @@ static void wbsd_fill_fifo(struct wbsd_host *host)
                                        return;
                                }
-                                buffer = wbsd_kmap_sg(host);
+                                buffer = wbsd_sg_to_buffer(host);
                        }
                }
        }
-        wbsd_kunmap_sg(host);
        /*
         * The controller stops sending interrupts for
         * 'FIFO empty' under certain conditions. So we
@@ -910,6 +890,45 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
         */
        if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
                /*
+                 * The hardware is so delightfully stupid that it has a list
+                 * of "data" commands. If a command isn't on this list, it'll
+                 * just go back to the idle state and won't send any data
+                 * interrupts.
+                 */
+                switch (cmd->opcode) {
+                case 11:
+                case 17:
+                case 18:
+                case 20:
+                case 24:
+                case 25:
+                case 26:
+                case 27:
+                case 30:
+                case 42:
+                case 56:
+                        break;
+                /* ACMDs. We don't keep track of state, so we just treat them
+                 * like any other command. */
+                case 51:
+                        break;
+                default:
+#ifdef CONFIG_MMC_DEBUG
+                        printk(KERN_WARNING "%s: Data command %d is not "
+                                "supported by this controller.\n",
+                                mmc_hostname(host->mmc), cmd->opcode);
+#endif
+                        cmd->data->error = MMC_ERR_INVALID;
+                        if (cmd->data->stop)
+                                wbsd_send_command(host, cmd->data->stop);
+                        goto done;
+                };
+                /*
                 * Dirty fix for hardware bug.
                 */
                if (host->dma == -1)
@@ -1343,16 +1362,27 @@ static int __devinit wbsd_alloc_mmc(struct device *dev)
        mmc->max_phys_segs = 128;
        /*
-         * Maximum number of sectors in one transfer. Also limited by 64kB
+         * Maximum request size. Also limited by 64KiB buffer.
-         * buffer.
         */
-        mmc->max_sectors = 128;
+        mmc->max_req_size = 65536;
        /*
         * Maximum segment size. Could be one segment with the maximum number
-         * of segments.
+         * of bytes.
+         */
+        mmc->max_seg_size = mmc->max_req_size;
+        /*
+         * Maximum block size. We have 12 bits (= 4095) but have to subtract
+         * space for CRC. So the maximum is 4095 - 4*2 = 4087.
+         */
+        mmc->max_blk_size = 4087;
+        /*
+         * Maximum block count. There is no real limit so the maximum
+         * request size will be the only restriction.
         */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_blk_count = mmc->max_req_size;
        dev_set_drvdata(dev, mmc);
diff --git a/drivers/mmc/wbsd.h b/drivers/mmc/wbsd.h
index 6072993f01e3..d06718b0e2ab 100644
--- a/drivers/mmc/wbsd.h
+++ b/drivers/mmc/wbsd.h
@@ -154,7 +154,6 @@ struct wbsd_host
        struct scatterlist*     cur_sg;         /* Current SG entry */
        unsigned int            num_sg;         /* Number of entries left */
-        void*                   mapped_sg;      /* vaddr of mapped sg */
        unsigned int            offset;         /* Offset into current entry */
        unsigned int            remain;         /* Data left in curren entry */
diff --git a/drivers/s390/Kconfig b/drivers/s390/Kconfig
index ae89b9b88743..165af398fdea 100644
--- a/drivers/s390/Kconfig
+++ b/drivers/s390/Kconfig
@@ -103,14 +103,8 @@ config CCW_CONSOLE
        depends on TN3215_CONSOLE || TN3270_CONSOLE
        default y
 
-config SCLP
-        bool "Support for SCLP"
-        help
-          Include support for the SCLP interface to the service element.
 config SCLP_TTY
        bool "Support for SCLP line mode terminal"
-        depends on SCLP
        help
          Include support for IBM SCLP line-mode terminals.
@@ -123,7 +117,6 @@ config SCLP_CONSOLE
 config SCLP_VT220_TTY
        bool "Support for SCLP VT220-compatible terminal"
-        depends on SCLP
        help
          Include support for an IBM SCLP VT220-compatible terminal.
@@ -136,7 +129,6 @@ config SCLP_VT220_CONSOLE
 config SCLP_CPI
        tristate "Control-Program Identification"
-        depends on SCLP
        help
          This option enables the hardware console interface for system
          identification. This is commonly used for workload management and
diff --git a/drivers/s390/Makefile b/drivers/s390/Makefile
index 9803c9352d78..5a888704a8d0 100644
--- a/drivers/s390/Makefile
+++ b/drivers/s390/Makefile
@@ -2,6 +2,8 @@
 # Makefile for the S/390 specific device drivers
 #
+CFLAGS_sysinfo.o += -Iinclude/math-emu -Iarch/s390/math-emu -w
 obj-y += s390mach.o sysinfo.o s390_rdev.o
 obj-y += cio/ block/ char/ crypto/ net/ scsi/
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 492b68bcd7cc..eb5dc62f0d9c 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -37,6 +37,7 @@
 */
 debug_info_t *dasd_debug_area;
 struct dasd_discipline *dasd_diag_discipline_pointer;
+void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
 MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
@@ -51,7 +52,6 @@ static int  dasd_alloc_queue(struct dasd_device * device);
 static void dasd_setup_queue(struct dasd_device * device);
 static void dasd_free_queue(struct dasd_device * device);
 static void dasd_flush_request_queue(struct dasd_device *);
-static void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
 static int dasd_flush_ccw_queue(struct dasd_device *, int);
 static void dasd_tasklet(struct dasd_device *);
 static void do_kick_device(struct work_struct *);
@@ -483,7 +483,7 @@ unsigned int dasd_profile_level = DASD_PROFILE_OFF;
 /*
 * Add profiling information for cqr before execution.
 */
-static inline void
+static void
 dasd_profile_start(struct dasd_device *device, struct dasd_ccw_req * cqr,
                   struct request *req)
 {
@@ -505,7 +505,7 @@ dasd_profile_start(struct dasd_device *device, struct dasd_ccw_req * cqr,
 /*
 * Add profiling information for cqr after execution.
 */
-static inline void
+static void
 dasd_profile_end(struct dasd_device *device, struct dasd_ccw_req * cqr,
                 struct request *req)
 {
@@ -1022,8 +1022,6 @@ dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
                 irb->scsw.cstat == 0 &&
                 !irb->esw.esw0.erw.cons)
                era = dasd_era_none;
-        else if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags))
-                era = dasd_era_fatal; /* don't recover this request */
        else if (irb->esw.esw0.erw.cons)
                era = device->discipline->examine_error(cqr, irb);
        else
@@ -1104,7 +1102,7 @@ __dasd_process_erp(struct dasd_device *device, struct dasd_ccw_req *cqr)
 /*
 * Process ccw request queue.
 */
-static inline void
+static void
 __dasd_process_ccw_queue(struct dasd_device * device,
                         struct list_head *final_queue)
 {
@@ -1127,7 +1125,9 @@ restart:
                                cqr->status = DASD_CQR_FAILED;
                                cqr->stopclk = get_clock();
                        } else {
-                                if (cqr->irb.esw.esw0.erw.cons) {
+                                if (cqr->irb.esw.esw0.erw.cons &&
+                                    test_bit(DASD_CQR_FLAGS_USE_ERP,
+                                             &cqr->flags)) {
                                        erp_fn = device->discipline->
                                                erp_action(cqr);
                                        erp_fn(cqr);
@@ -1181,7 +1181,7 @@ dasd_end_request_cb(struct dasd_ccw_req * cqr, void *data)
 /*
 * Fetch requests from the block device queue.
 */
-static inline void
+static void
 __dasd_process_blk_queue(struct dasd_device * device)
 {
        request_queue_t *queue;
@@ -1232,6 +1232,19 @@ __dasd_process_blk_queue(struct dasd_device * device)
                if (IS_ERR(cqr)) {
                        if (PTR_ERR(cqr) == -ENOMEM)
                                break;  /* terminate request queue loop */
+                        if (PTR_ERR(cqr) == -EAGAIN) {
+                                /*
+                                 * The current request cannot be build right
+                                 * now, we have to try later. If this request
+                                 * is the head-of-queue we stop the device
+                                 * for 1/2 second.
+                                 */
+                                if (!list_empty(&device->ccw_queue))
+                                        break;
+                                device->stopped |= DASD_STOPPED_PENDING;
+                                dasd_set_timer(device, HZ/2);
+                                break;
+                        }
                        DBF_DEV_EVENT(DBF_ERR, device,
                                      "CCW creation failed (rc=%ld) "
                                      "on request %p",
@@ -1254,7 +1267,7 @@ __dasd_process_blk_queue(struct dasd_device * device)
 * Take a look at the first request on the ccw queue and check
 * if it reached its expire time. If so, terminate the IO.
 */
-static inline void
+static void
 __dasd_check_expire(struct dasd_device * device)
 {
        struct dasd_ccw_req *cqr;
@@ -1285,7 +1298,7 @@ __dasd_check_expire(struct dasd_device * device)
 * Take a look at the first request on the ccw queue and check
 * if it needs to be started.
 */
-static inline void
+static void
 __dasd_start_head(struct dasd_device * device)
 {
        struct dasd_ccw_req *cqr;
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index 4d01040c2c63..8b9d68f6e016 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -170,7 +170,6 @@ dasd_3990_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
        /* log the erp chain if fatal error occurred */
        if ((era == dasd_era_fatal) && (device->state >= DASD_STATE_READY)) {
                dasd_log_sense(cqr, irb);
-                dasd_log_ccw(cqr, 0, irb->scsw.cpa);
        }
        return era;
@@ -2640,7 +2639,6 @@ dasd_3990_erp_action(struct dasd_ccw_req * cqr)
        struct dasd_ccw_req *erp = NULL;
        struct dasd_device *device = cqr->device;
-        __u32 cpa = cqr->irb.scsw.cpa;
        struct dasd_ccw_req *temp_erp = NULL;
        if (device->features & DASD_FEATURE_ERPLOG) {
@@ -2706,9 +2704,6 @@ dasd_3990_erp_action(struct dasd_ccw_req * cqr)
                }
        }
-        if (erp->status == DASD_CQR_FAILED)
-                dasd_log_ccw(erp, 1, cpa);
        /* enqueue added ERP request */
        if (erp->status == DASD_CQR_FILLED) {
                erp->status = DASD_CQR_QUEUED;
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 5943266152f5..ed70852cc915 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -136,7 +136,7 @@ __setup ("dasd=", dasd_call_setup);
 /*
 * Read a device busid/devno from a string.
 */
-static inline int
+static int
 dasd_busid(char **str, int *id0, int *id1, int *devno)
 {
        int val, old_style;
@@ -182,7 +182,7 @@ dasd_busid(char **str, int *id0, int *id1, int *devno)
 * only one: "ro" for read-only devices. The default feature set
 * is empty (value 0).
 */
-static inline int
+static int
 dasd_feature_list(char *str, char **endp)
 {
        int features, len, rc;
@@ -341,7 +341,7 @@ dasd_parse_range( char *parsestring ) {
        return ERR_PTR(-EINVAL);
 }
-static inline char *
+static char *
 dasd_parse_next_element( char *parsestring ) {
        char * residual_str;
        residual_str = dasd_parse_keyword(parsestring);
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 53db58a68617..ab782bb46ac1 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -43,7 +43,7 @@ MODULE_LICENSE("GPL");
 #define DIAG_MAX_RETRIES        32
 #define DIAG_TIMEOUT            50 * HZ
-struct dasd_discipline dasd_diag_discipline;
+static struct dasd_discipline dasd_diag_discipline;
 struct dasd_diag_private {
        struct dasd_diag_characteristics rdc_data;
@@ -90,7 +90,7 @@ static inline int dia250(void *iob, int cmd)
 * block offset. On success, return zero and set end_block to contain the
 * number of blocks on the device minus the specified offset. Return non-zero
 * otherwise. */
-static __inline__ int
+static inline int
 mdsk_init_io(struct dasd_device *device, unsigned int blocksize,
             blocknum_t offset, blocknum_t *end_block)
 {
@@ -117,7 +117,7 @@ mdsk_init_io(struct dasd_device *device, unsigned int blocksize,
 /* Remove block I/O environment for device. Return zero on success, non-zero
 * otherwise. */
-static __inline__ int
+static inline int
 mdsk_term_io(struct dasd_device * device)
 {
        struct dasd_diag_private *private;
@@ -576,7 +576,7 @@ dasd_diag_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
                    "dump sense not available for DIAG data");
 }
-struct dasd_discipline dasd_diag_discipline = {
+static struct dasd_discipline dasd_diag_discipline = {
        .owner = THIS_MODULE,
        .name = "DIAG",
        .ebcname = "DIAG",
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index fdaa471e845f..cecab2274a6e 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -134,44 +134,7 @@ ceil_quot(unsigned int d1, unsigned int d2)
        return (d1 + (d2 - 1)) / d2;
 }
-static inline int
+static unsigned int
-bytes_per_record(struct dasd_eckd_characteristics *rdc, int kl, int dl)
-{
-        unsigned int fl1, fl2, int1, int2;
-        int bpr;
-        switch (rdc->formula) {
-        case 0x01:
-                fl1 = round_up_multiple(ECKD_F2(rdc) + dl, ECKD_F1(rdc));
-                fl2 = round_up_multiple(kl ? ECKD_F2(rdc) + kl : 0,
-                                        ECKD_F1(rdc));
-                bpr = fl1 + fl2;
-                break;
-        case 0x02:
-                int1 = ceil_quot(dl + ECKD_F6(rdc), ECKD_F5(rdc) << 1);
-                int2 = ceil_quot(kl + ECKD_F6(rdc), ECKD_F5(rdc) << 1);
-                fl1 = round_up_multiple(ECKD_F1(rdc) * ECKD_F2(rdc) + dl +
-                                        ECKD_F6(rdc) + ECKD_F4(rdc) * int1,
-                                        ECKD_F1(rdc));
-                fl2 = round_up_multiple(ECKD_F1(rdc) * ECKD_F3(rdc) + kl +
-                                        ECKD_F6(rdc) + ECKD_F4(rdc) * int2,
-                                        ECKD_F1(rdc));
-                bpr = fl1 + fl2;
-                break;
-        default:
-                bpr = 0;
-                break;
-        }
-        return bpr;
-}
-static inline unsigned int
-bytes_per_track(struct dasd_eckd_characteristics *rdc)
-{
-        return *(unsigned int *) (rdc->byte_per_track) >> 8;
-}
-static inline unsigned int
 recs_per_track(struct dasd_eckd_characteristics * rdc,
               unsigned int kl, unsigned int dl)
 {
@@ -204,37 +167,39 @@ recs_per_track(struct dasd_eckd_characteristics * rdc,
        return 0;
 }
-static inline void
+static int
 check_XRC (struct ccw1         *de_ccw,
           struct DE_eckd_data *data,
           struct dasd_device  *device)
 {
        struct dasd_eckd_private *private;
+        int rc;
        private = (struct dasd_eckd_private *) device->private;
+        if (!private->rdc_data.facilities.XRC_supported)
+                return 0;
        /* switch on System Time Stamp - needed for XRC Support */
-        if (private->rdc_data.facilities.XRC_supported) {
+        data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid'   */
+        data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */
-                data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid'   */
-                data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */
-                data->ep_sys_time = get_clock ();
-                de_ccw->count = sizeof (struct DE_eckd_data);
-                de_ccw->flags |= CCW_FLAG_SLI;
-        }
-        return;
+        rc = get_sync_clock(&data->ep_sys_time);
+        /* Ignore return code if sync clock is switched off. */
+        if (rc == -ENOSYS || rc == -EACCES)
+                rc = 0;
-} /* end check_XRC */
+        de_ccw->count = sizeof (struct DE_eckd_data);
+        de_ccw->flags |= CCW_FLAG_SLI;
+        return rc;
+}
-static inline void
+static int
 define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
              int totrk, int cmd, struct dasd_device * device)
 {
        struct dasd_eckd_private *private;
        struct ch_t geo, beg, end;
+        int rc = 0;
        private = (struct dasd_eckd_private *) device->private;
@@ -263,12 +228,12 @@ define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
        case DASD_ECKD_CCW_WRITE_KD_MT:
                data->mask.perm = 0x02;
                data->attributes.operation = private->attrib.operation;
-                check_XRC (ccw, data, device);
+                rc = check_XRC (ccw, data, device);
                break;
        case DASD_ECKD_CCW_WRITE_CKD:
        case DASD_ECKD_CCW_WRITE_CKD_MT:
                data->attributes.operation = DASD_BYPASS_CACHE;
-                check_XRC (ccw, data, device);
+                rc = check_XRC (ccw, data, device);
                break;
        case DASD_ECKD_CCW_ERASE:
        case DASD_ECKD_CCW_WRITE_HOME_ADDRESS:
@@ -276,7 +241,7 @@ define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
                data->mask.perm = 0x3;
                data->mask.auth = 0x1;
                data->attributes.operation = DASD_BYPASS_CACHE;
-                check_XRC (ccw, data, device);
+                rc = check_XRC (ccw, data, device);
                break;
        default:
                DEV_MESSAGE(KERN_ERR, device, "unknown opcode 0x%x", cmd);
@@ -312,9 +277,10 @@ define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
        data->beg_ext.head = beg.head;
        data->end_ext.cyl = end.cyl;
        data->end_ext.head = end.head;
+        return rc;
 }
-static inline void
+static void
 locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, int trk,
              int rec_on_trk, int no_rec, int cmd,
              struct dasd_device * device, int reclen)
@@ -548,7 +514,7 @@ dasd_eckd_read_conf(struct dasd_device *device)
 /*
 * Build CP for Perform Subsystem Function - SSC.
 */
-struct dasd_ccw_req *
+static struct dasd_ccw_req *
 dasd_eckd_build_psf_ssc(struct dasd_device *device)
 {
       struct dasd_ccw_req *cqr;
@@ -1200,7 +1166,12 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
                return cqr;
        ccw = cqr->cpaddr;
        /* First ccw is define extent. */
-        define_extent(ccw++, cqr->data, first_trk, last_trk, cmd, device);
+        if (define_extent(ccw++, cqr->data, first_trk,
+                          last_trk, cmd, device) == -EAGAIN) {
+                /* Clock not in sync and XRC is enabled. Try again later. */
+                dasd_sfree_request(cqr, device);
+                return ERR_PTR(-EAGAIN);
+        }
        /* Build locate_record+read/write/ccws. */
        idaws = (unsigned long *) (cqr->data + sizeof(struct DE_eckd_data));
        LO_data = (struct LO_eckd_data *) (idaws + cidaw);
@@ -1380,7 +1351,7 @@ dasd_eckd_release(struct dasd_device *device)
        cqr->device = device;
        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
        set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
-        cqr->retries = 0;
+        cqr->retries = 2;       /* set retry counter to enable basic ERP */
        cqr->expires = 2 * HZ;
        cqr->buildclk = get_clock();
        cqr->status = DASD_CQR_FILLED;
@@ -1420,7 +1391,7 @@ dasd_eckd_reserve(struct dasd_device *device)
        cqr->device = device;
        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
        set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
-        cqr->retries = 0;
+        cqr->retries = 2;       /* set retry counter to enable basic ERP */
        cqr->expires = 2 * HZ;
        cqr->buildclk = get_clock();
        cqr->status = DASD_CQR_FILLED;
@@ -1459,7 +1430,7 @@ dasd_eckd_steal_lock(struct dasd_device *device)
        cqr->device = device;
        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
        set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
-        cqr->retries = 0;
+        cqr->retries = 2;       /* set retry counter to enable basic ERP */
        cqr->expires = 2 * HZ;
        cqr->buildclk = get_clock();
        cqr->status = DASD_CQR_FILLED;
@@ -1609,7 +1580,7 @@ dasd_eckd_ioctl(struct dasd_device *device, unsigned int cmd, void __user *argp)
 * Dump the range of CCWs into 'page' buffer
 * and return number of printed chars.
 */
-static inline int
+static int
 dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page)
 {
        int len, count;
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
index e0bf30ebb215..6cedc914077e 100644
--- a/drivers/s390/block/dasd_eer.c
+++ b/drivers/s390/block/dasd_eer.c
@@ -658,18 +658,24 @@ static struct file_operations dasd_eer_fops = {
        .owner          = THIS_MODULE,
 };
-static struct miscdevice dasd_eer_dev = {
+static struct miscdevice *dasd_eer_dev = NULL;
-        .minor      = MISC_DYNAMIC_MINOR,
-        .name       = "dasd_eer",
-        .fops       = &dasd_eer_fops,
-};
 int __init dasd_eer_init(void)
 {
        int rc;
-        rc = misc_register(&dasd_eer_dev);
+        dasd_eer_dev = kzalloc(sizeof(*dasd_eer_dev), GFP_KERNEL);
+        if (!dasd_eer_dev)
+                return -ENOMEM;
+        dasd_eer_dev->minor = MISC_DYNAMIC_MINOR;
+        dasd_eer_dev->name  = "dasd_eer";
+        dasd_eer_dev->fops  = &dasd_eer_fops;
+        rc = misc_register(dasd_eer_dev);
        if (rc) {
+                kfree(dasd_eer_dev);
+                dasd_eer_dev = NULL;
                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
                       "register misc device");
                return rc;
@@ -680,5 +686,9 @@ int __init dasd_eer_init(void)
 void dasd_eer_exit(void)
 {
-        WARN_ON(misc_deregister(&dasd_eer_dev) != 0);
+        if (dasd_eer_dev) {
+                WARN_ON(misc_deregister(dasd_eer_dev) != 0);
+                kfree(dasd_eer_dev);
+                dasd_eer_dev = NULL;
+        }
 }
diff --git a/drivers/s390/block/dasd_erp.c b/drivers/s390/block/dasd_erp.c
index 58a65097922b..caa5d91420f8 100644
--- a/drivers/s390/block/dasd_erp.c
+++ b/drivers/s390/block/dasd_erp.c
@@ -152,25 +152,6 @@ dasd_default_erp_postaction(struct dasd_ccw_req * cqr)
 }                               /* end default_erp_postaction */
-/*
- * Print the hex dump of the memory used by a request. This includes
- * all error recovery ccws that have been chained in from of the
- * real request.
- */
-static inline void
-hex_dump_memory(struct dasd_device *device, void *data, int len)
-{
-        int *pint;
-        pint = (int *) data;
-        while (len > 0) {
-                DEV_MESSAGE(KERN_ERR, device, "%p: %08x %08x %08x %08x",
-                            pint, pint[0], pint[1], pint[2], pint[3]);
-                pint += 4;
-                len -= 16;
-        }
-}
 void
 dasd_log_sense(struct dasd_ccw_req *cqr, struct irb *irb)
 {
@@ -182,69 +163,8 @@ dasd_log_sense(struct dasd_ccw_req *cqr, struct irb *irb)
                device->discipline->dump_sense(device, cqr, irb);
 }
-void
-dasd_log_ccw(struct dasd_ccw_req * cqr, int caller, __u32 cpa)
-{
-        struct dasd_device *device;
-        struct dasd_ccw_req *lcqr;
-        struct ccw1 *ccw;
-        int cplength;
-        device = cqr->device;
-        /* log the channel program */
-        for (lcqr = cqr; lcqr != NULL; lcqr = lcqr->refers) {
-                DEV_MESSAGE(KERN_ERR, device,
-                            "(%s) ERP chain report for req: %p",
-                            caller == 0 ? "EXAMINE" : "ACTION", lcqr);
-                hex_dump_memory(device, lcqr, sizeof(struct dasd_ccw_req));
-                cplength = 1;
-                ccw = lcqr->cpaddr;
-                while (ccw++->flags & (CCW_FLAG_DC | CCW_FLAG_CC))
-                        cplength++;
-                if (cplength > 40) {    /* log only parts of the CP */
-                        DEV_MESSAGE(KERN_ERR, device, "%s",
-                                    "Start of channel program:");
-                        hex_dump_memory(device, lcqr->cpaddr,
-                                        40*sizeof(struct ccw1));
-                        DEV_MESSAGE(KERN_ERR, device, "%s",
-                                    "End of channel program:");
-                        hex_dump_memory(device, lcqr->cpaddr + cplength - 10,
-                                        10*sizeof(struct ccw1));
-                } else {        /* log the whole CP */
-                        DEV_MESSAGE(KERN_ERR, device, "%s",
-                                    "Channel program (complete):");
-                        hex_dump_memory(device, lcqr->cpaddr,
-                                        cplength*sizeof(struct ccw1));
-                }
-                if (lcqr != cqr)
-                        continue;
-                /*
-                 * Log bytes arround failed CCW but only if we did
-                 * not log the whole CP of the CCW is outside the
-                 * logged CP.
-                 */
-                if (cplength > 40 ||
-                    ((addr_t) cpa < (addr_t) lcqr->cpaddr &&
-                     (addr_t) cpa > (addr_t) (lcqr->cpaddr + cplength + 4))) {
-                        DEV_MESSAGE(KERN_ERR, device,
-                                    "Failed CCW (%p) (area):",
-                                    (void *) (long) cpa);
-                        hex_dump_memory(device, cqr->cpaddr - 10,
-                                        20*sizeof(struct ccw1));
-                }
-        }
-}                               /* end log_erp_chain */
 EXPORT_SYMBOL(dasd_default_erp_action);
 EXPORT_SYMBOL(dasd_default_erp_postaction);
 EXPORT_SYMBOL(dasd_alloc_erp_request);
 EXPORT_SYMBOL(dasd_free_erp_request);
 EXPORT_SYMBOL(dasd_log_sense);
-EXPORT_SYMBOL(dasd_log_ccw);
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index b857fd5893fd..be0909e39226 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -75,7 +75,7 @@ static struct ccw_driver dasd_fba_driver = {
        .notify      = dasd_generic_notify,
 };
-static inline void
+static void
 define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw,
              int blksize, int beg, int nr)
 {
@@ -95,7 +95,7 @@ define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw,
        data->ext_end = nr - 1;
 }
-static inline void
+static void
 locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw,
              int block_nr, int block_ct)
 {
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index d163632101d2..47ba4462708d 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -147,7 +147,7 @@ dasd_destroy_partitions(struct dasd_device * device)
         */
        memset(&bpart, 0, sizeof(struct blkpg_partition));
        memset(&barg, 0, sizeof(struct blkpg_ioctl_arg));
-        barg.data = (void __user *) &bpart;
+        barg.data = (void __force __user *) &bpart;
        barg.op = BLKPG_DEL_PARTITION;
        for (bpart.pno = device->gdp->minors - 1; bpart.pno > 0; bpart.pno--)
                ioctl_by_bdev(bdev, BLKPG, (unsigned long) &barg);
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index fb725e3b08fe..a2cc69e11410 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -559,7 +559,6 @@ struct dasd_ccw_req *dasd_alloc_erp_request(char *, int, int,
                                            struct dasd_device *);
 void dasd_free_erp_request(struct dasd_ccw_req *, struct dasd_device *);
 void dasd_log_sense(struct dasd_ccw_req *, struct irb *);
-void dasd_log_ccw(struct dasd_ccw_req *, int, __u32);
 /* externals in dasd_3370_erp.c */
 dasd_era_t dasd_3370_erp_examine(struct dasd_ccw_req *, struct irb *);
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index bfa010f6dab2..8b7e11815d70 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -28,7 +28,7 @@ static struct proc_dir_entry *dasd_proc_root_entry = NULL;
 static struct proc_dir_entry *dasd_devices_entry = NULL;
 static struct proc_dir_entry *dasd_statistics_entry = NULL;
-static inline char *
+static char *
 dasd_get_user_string(const char __user *user_buf, size_t user_len)
 {
        char *buffer;
@@ -154,7 +154,7 @@ static struct file_operations dasd_devices_file_ops = {
        .release        = seq_release,
 };
-static inline int
+static int
 dasd_calc_metrics(char *page, char **start, off_t off,
                  int count, int *eof, int len)
 {
@@ -167,8 +167,8 @@ dasd_calc_metrics(char *page, char **start, off_t off,
        return len;
 }
-static inline char *
+static char *
-dasd_statistics_array(char *str, int *array, int shift)
+dasd_statistics_array(char *str, unsigned int *array, int shift)
 {
        int i;
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index be9b05347b4f..1340451ea408 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -102,7 +102,7 @@ dcssblk_release_segment(struct device *dev)
 * device needs to be enqueued before the semaphore is
 * freed.
 */
-static inline int
+static int
 dcssblk_assign_free_minor(struct dcssblk_dev_info *dev_info)
 {
        int minor, found;
@@ -230,7 +230,7 @@ dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const ch
                                           SEGMENT_SHARED);
                if (rc < 0) {
                        BUG_ON(rc == -EINVAL);
-                        if (rc == -EIO || rc == -ENOENT)
+                        if (rc != -EAGAIN)
                                goto removeseg;
                } else {
                        dev_info->is_shared = 1;
@@ -253,7 +253,7 @@ dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const ch
                                           SEGMENT_EXCLUSIVE);
                if (rc < 0) {
                        BUG_ON(rc == -EINVAL);
-                        if (rc == -EIO || rc == -ENOENT)
+                        if (rc != -EAGAIN)
                                goto removeseg;
                } else {
                        dev_info->is_shared = 0;
diff --git a/drivers/s390/char/Makefile b/drivers/s390/char/Makefile
index c3e97b4fc186..293e667b50f2 100644
--- a/drivers/s390/char/Makefile
+++ b/drivers/s390/char/Makefile
@@ -2,7 +2,8 @@
 # S/390 character devices
 #
-obj-y += ctrlchar.o keyboard.o defkeymap.o
+obj-y += ctrlchar.o keyboard.o defkeymap.o sclp.o sclp_rw.o sclp_quiesce.o \
+         sclp_info.o
 obj-$(CONFIG_TN3270) += raw3270.o
 obj-$(CONFIG_TN3270_CONSOLE) += con3270.o
@@ -11,7 +12,6 @@ obj-$(CONFIG_TN3270_FS) += fs3270.o
 obj-$(CONFIG_TN3215) += con3215.o
-obj-$(CONFIG_SCLP) += sclp.o sclp_rw.o sclp_quiesce.o
 obj-$(CONFIG_SCLP_TTY) += sclp_tty.o
 obj-$(CONFIG_SCLP_CONSOLE) += sclp_con.o
 obj-$(CONFIG_SCLP_VT220_TTY) += sclp_vt220.o
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 25b5d7a66417..9a328f14a641 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -1121,7 +1121,7 @@ static const struct tty_operations tty3215_ops = {
 * 3215 tty registration code called from tty_init().
 * Most kernel services (incl. kmalloc) are available at this poimt.
 */
-int __init
+static int __init
 tty3215_init(void)
 {
        struct tty_driver *driver;
diff --git a/drivers/s390/char/con3270.c b/drivers/s390/char/con3270.c
index 7566be890688..8e7f2d7633d6 100644
--- a/drivers/s390/char/con3270.c
+++ b/drivers/s390/char/con3270.c
@@ -69,8 +69,7 @@ static void con3270_update(struct con3270 *);
 /*
 * Setup timeout for a device. On timeout trigger an update.
 */
-void
+static void con3270_set_timer(struct con3270 *cp, int expires)
-con3270_set_timer(struct con3270 *cp, int expires)
 {
        if (expires == 0) {
                if (timer_pending(&cp->timer))
diff --git a/drivers/s390/char/defkeymap.c b/drivers/s390/char/defkeymap.c
index 17027d918cf7..564baca01b7c 100644
--- a/drivers/s390/char/defkeymap.c
+++ b/drivers/s390/char/defkeymap.c
@@ -5,6 +5,8 @@
 #include <linux/types.h>
 #include <linux/keyboard.h>
 #include <linux/kd.h>
+#include <linux/kbd_kern.h>
+#include <linux/kbd_diacr.h>
 u_short plain_map[NR_KEYS] = {
        0xf000, 0xf000, 0xf000, 0xf000, 0xf000, 0xf000, 0xf000, 0xf000,
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 0893d306ae80..e1a746269c4c 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -23,7 +23,7 @@
 #include "raw3270.h"
 #include "ctrlchar.h"
-struct raw3270_fn fs3270_fn;
+static struct raw3270_fn fs3270_fn;
 struct fs3270 {
        struct raw3270_view view;
@@ -401,7 +401,7 @@ fs3270_release(struct raw3270_view *view)
 }
 /* View to a 3270 device. Can be console, tty or fullscreen. */
-struct raw3270_fn fs3270_fn = {
+static struct raw3270_fn fs3270_fn = {
        .activate = fs3270_activate,
        .deactivate = fs3270_deactivate,
        .intv = (void *) fs3270_irq,
diff --git a/drivers/s390/char/keyboard.c b/drivers/s390/char/keyboard.c
index 3e86fd1756e5..f62f9a4e8950 100644
--- a/drivers/s390/char/keyboard.c
+++ b/drivers/s390/char/keyboard.c
@@ -148,6 +148,7 @@ kbd_ascebc(struct kbd_data *kbd, unsigned char *ascebc)
        }
 }
+#if 0
 /*
 * Generate ebcdic -> ascii translation table from kbd_data.
 */
@@ -173,6 +174,7 @@ kbd_ebcasc(struct kbd_data *kbd, unsigned char *ebcasc)
                }
        }
 }
+#endif
 /*
 * We have a combining character DIACR here, followed by the character CH.
diff --git a/drivers/s390/char/monwriter.c b/drivers/s390/char/monwriter.c
index cdb24f528112..9e451acc6491 100644
--- a/drivers/s390/char/monwriter.c
+++ b/drivers/s390/char/monwriter.c
@@ -67,8 +67,8 @@ static int monwrite_diag(struct monwrite_hdr *myhdr, char *buffer, int fcn)
        return -EINVAL;
 }
-static inline struct mon_buf *monwrite_find_hdr(struct mon_private *monpriv,
+static struct mon_buf *monwrite_find_hdr(struct mon_private *monpriv,
-                                                struct monwrite_hdr *monhdr)
+                                         struct monwrite_hdr *monhdr)
 {
        struct mon_buf *entry, *next;
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 7a84014f2037..8facd14adb7c 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -29,7 +29,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
-struct class *class3270;
+static struct class *class3270;
 /* The main 3270 data structure. */
 struct raw3270 {
@@ -86,7 +86,7 @@ DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
 /*
 * Encode array for 12 bit 3270 addresses.
 */
-unsigned char raw3270_ebcgraf[64] =     {
+static unsigned char raw3270_ebcgraf[64] =      {
        0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
        0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
        0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index 8a056df09d6b..f171de3b0b11 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -59,7 +59,8 @@ static volatile enum sclp_init_state_t {
 /* Internal state: is a request active at the sclp? */
 static volatile enum sclp_running_state_t {
        sclp_running_state_idle,
-        sclp_running_state_running
+        sclp_running_state_running,
+        sclp_running_state_reset_pending
 } sclp_running_state = sclp_running_state_idle;
 /* Internal state: is a read request pending? */
@@ -88,15 +89,15 @@ static volatile enum sclp_mask_state_t {
 /* Timeout intervals in seconds.*/
 #define SCLP_BUSY_INTERVAL      10
-#define SCLP_RETRY_INTERVAL     15
+#define SCLP_RETRY_INTERVAL     30
 static void sclp_process_queue(void);
 static int sclp_init_mask(int calculate);
 static int sclp_init(void);
 /* Perform service call. Return 0 on success, non-zero otherwise. */
-static int
+int
-service_call(sclp_cmdw_t command, void *sccb)
+sclp_service_call(sclp_cmdw_t command, void *sccb)
 {
        int cc;
@@ -113,19 +114,17 @@ service_call(sclp_cmdw_t command, void *sccb)
        return 0;
 }
-/* Request timeout handler. Restart the request queue. If DATA is non-zero,
+static inline void __sclp_make_read_req(void);
- * force restart of running request. */
 static void
-sclp_request_timeout(unsigned long data)
+__sclp_queue_read_req(void)
 {
-        unsigned long flags;
+        if (sclp_reading_state == sclp_reading_state_idle) {
+                sclp_reading_state = sclp_reading_state_reading;
-        if (data) {
+                __sclp_make_read_req();
-                spin_lock_irqsave(&sclp_lock, flags);
+                /* Add request to head of queue */
-                sclp_running_state = sclp_running_state_idle;
+                list_add(&sclp_read_req.list, &sclp_req_queue);
-                spin_unlock_irqrestore(&sclp_lock, flags);
        }
-        sclp_process_queue();
 }
 /* Set up request retry timer. Called while sclp_lock is locked. */
@@ -140,6 +139,29 @@ __sclp_set_request_timer(unsigned long time, void (*function)(unsigned long),
        add_timer(&sclp_request_timer);
 }
+/* Request timeout handler. Restart the request queue. If DATA is non-zero,
+ * force restart of running request. */
+static void
+sclp_request_timeout(unsigned long data)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&sclp_lock, flags);
+        if (data) {
+                if (sclp_running_state == sclp_running_state_running) {
+                        /* Break running state and queue NOP read event request
+                         * to get a defined interface state. */
+                        __sclp_queue_read_req();
+                        sclp_running_state = sclp_running_state_idle;
+                }
+        } else {
+                __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
+                                         sclp_request_timeout, 0);
+        }
+        spin_unlock_irqrestore(&sclp_lock, flags);
+        sclp_process_queue();
+}
 /* Try to start a request. Return zero if the request was successfully
 * started or if it will be started at a later time. Return non-zero otherwise.
 * Called while sclp_lock is locked. */
@@ -151,7 +173,7 @@ __sclp_start_request(struct sclp_req *req)
        if (sclp_running_state != sclp_running_state_idle)
                return 0;
        del_timer(&sclp_request_timer);
-        rc = service_call(req->command, req->sccb);
+        rc = sclp_service_call(req->command, req->sccb);
        req->start_count++;
        if (rc == 0) {
@@ -191,7 +213,15 @@ sclp_process_queue(void)
                rc = __sclp_start_request(req);
                if (rc == 0)
                        break;
-                /* Request failed. */
+                /* Request failed */
+                if (req->start_count > 1) {
+                        /* Cannot abort already submitted request - could still
+                         * be active at the SCLP */
+                        __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
+                                                 sclp_request_timeout, 0);
+                        break;
+                }
+                /* Post-processing for aborted request */
                list_del(&req->list);
                if (req->callback) {
                        spin_unlock_irqrestore(&sclp_lock, flags);
@@ -221,7 +251,8 @@ sclp_add_request(struct sclp_req *req)
        list_add_tail(&req->list, &sclp_req_queue);
        rc = 0;
        /* Start if request is first in list */
-        if (req->list.prev == &sclp_req_queue) {
+        if (sclp_running_state == sclp_running_state_idle &&
+            req->list.prev == &sclp_req_queue) {
                rc = __sclp_start_request(req);
                if (rc)
                        list_del(&req->list);
@@ -294,7 +325,7 @@ __sclp_make_read_req(void)
        sccb = (struct sccb_header *) sclp_read_sccb;
        clear_page(sccb);
        memset(&sclp_read_req, 0, sizeof(struct sclp_req));
-        sclp_read_req.command = SCLP_CMDW_READDATA;
+        sclp_read_req.command = SCLP_CMDW_READ_EVENT_DATA;
        sclp_read_req.status = SCLP_REQ_QUEUED;
        sclp_read_req.start_count = 0;
        sclp_read_req.callback = sclp_read_cb;
@@ -334,6 +365,8 @@ sclp_interrupt_handler(__u16 code)
        finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
        evbuf_pending = S390_lowcore.ext_params & 0x3;
        if (finished_sccb) {
+                del_timer(&sclp_request_timer);
+                sclp_running_state = sclp_running_state_reset_pending;
                req = __sclp_find_req(finished_sccb);
                if (req) {
                        /* Request post-processing */
@@ -348,13 +381,8 @@ sclp_interrupt_handler(__u16 code)
                sclp_running_state = sclp_running_state_idle;
        }
        if (evbuf_pending && sclp_receive_mask != 0 &&
-            sclp_reading_state == sclp_reading_state_idle &&
+            sclp_activation_state == sclp_activation_state_active)
-            sclp_activation_state == sclp_activation_state_active ) {
+                __sclp_queue_read_req();
-                sclp_reading_state = sclp_reading_state_reading;
-                __sclp_make_read_req();
-                /* Add request to head of queue */
-                list_add(&sclp_read_req.list, &sclp_req_queue);
-        }
        spin_unlock(&sclp_lock);
        sclp_process_queue();
 }
@@ -374,6 +402,7 @@ sclp_sync_wait(void)
        unsigned long flags;
        unsigned long cr0, cr0_sync;
        u64 timeout;
+        int irq_context;
        /* We'll be disabling timer interrupts, so we need a custom timeout
         * mechanism */
@@ -386,7 +415,9 @@ sclp_sync_wait(void)
        }
        local_irq_save(flags);
        /* Prevent bottom half from executing once we force interrupts open */
-        local_bh_disable();
+        irq_context = in_interrupt();
+        if (!irq_context)
+                local_bh_disable();
        /* Enable service-signal interruption, disable timer interrupts */
        trace_hardirqs_on();
        __ctl_store(cr0, 0, 0);
@@ -402,19 +433,19 @@ sclp_sync_wait(void)
                    get_clock() > timeout &&
                    del_timer(&sclp_request_timer))
                        sclp_request_timer.function(sclp_request_timer.data);
-                barrier();
                cpu_relax();
        }
        local_irq_disable();
        __ctl_load(cr0, 0, 0);
-        _local_bh_enable();
+        if (!irq_context)
+                _local_bh_enable();
        local_irq_restore(flags);
 }
 EXPORT_SYMBOL(sclp_sync_wait);
 /* Dispatch changes in send and receive mask to registered listeners. */
-static inline void
+static void
 sclp_dispatch_state_change(void)
 {
        struct list_head *l;
@@ -597,7 +628,7 @@ __sclp_make_init_req(u32 receive_mask, u32 send_mask)
        sccb = (struct init_sccb *) sclp_init_sccb;
        clear_page(sccb);
        memset(&sclp_init_req, 0, sizeof(struct sclp_req));
-        sclp_init_req.command = SCLP_CMDW_WRITEMASK;
+        sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
        sclp_init_req.status = SCLP_REQ_FILLED;
        sclp_init_req.start_count = 0;
        sclp_init_req.callback = NULL;
@@ -800,7 +831,7 @@ sclp_check_interface(void)
        for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
                __sclp_make_init_req(0, 0);
                sccb = (struct init_sccb *) sclp_init_req.sccb;
-                rc = service_call(sclp_init_req.command, sccb);
+                rc = sclp_service_call(sclp_init_req.command, sccb);
                if (rc == -EIO)
                        break;
                sclp_init_req.status = SCLP_REQ_RUNNING;
diff --git a/drivers/s390/char/sclp.h b/drivers/s390/char/sclp.h
index 2c71d6ee7b5b..7d29ab45a6ed 100644
--- a/drivers/s390/char/sclp.h
+++ b/drivers/s390/char/sclp.h
@@ -12,7 +12,7 @@
 #include <linux/types.h>
 #include <linux/list.h>
+#include <asm/sclp.h>
 #include <asm/ebcdic.h>
 /* maximum number of pages concerning our own memory management */
@@ -49,9 +49,11 @@
 typedef unsigned int sclp_cmdw_t;
-#define SCLP_CMDW_READDATA      0x00770005
+#define SCLP_CMDW_READ_EVENT_DATA       0x00770005
-#define SCLP_CMDW_WRITEDATA     0x00760005
+#define SCLP_CMDW_WRITE_EVENT_DATA      0x00760005
-#define SCLP_CMDW_WRITEMASK     0x00780005
+#define SCLP_CMDW_WRITE_EVENT_MASK      0x00780005
+#define SCLP_CMDW_READ_SCP_INFO         0x00020001
+#define SCLP_CMDW_READ_SCP_INFO_FORCED  0x00120001
 #define GDS_ID_MDSMU            0x1310
 #define GDS_ID_MDSRouteInfo     0x1311
@@ -66,13 +68,6 @@ typedef unsigned int sclp_cmdw_t;
 typedef u32 sccb_mask_t;        /* ATTENTION: assumes 32bit mask !!! */
-struct sccb_header {
-        u16     length;
-        u8      function_code;
-        u8      control_mask[3];
-        u16     response_code;
-} __attribute__((packed));
 struct gds_subvector {
        u8      length;
        u8      key;
@@ -131,6 +126,7 @@ void sclp_unregister(struct sclp_register *reg);
 int sclp_remove_processed(struct sccb_header *sccb);
 int sclp_deactivate(void);
 int sclp_reactivate(void);
+int sclp_service_call(sclp_cmdw_t command, void *sccb);
 /* useful inlines */
diff --git a/drivers/s390/char/sclp_con.c b/drivers/s390/char/sclp_con.c
index 86864f641716..ead1043d788e 100644
--- a/drivers/s390/char/sclp_con.c
+++ b/drivers/s390/char/sclp_con.c
@@ -66,7 +66,7 @@ sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)
        } while (buffer && sclp_emit_buffer(buffer, sclp_conbuf_callback));
 }
-static inline void
+static void
 sclp_conbuf_emit(void)
 {
        struct sclp_buffer* buffer;
diff --git a/drivers/s390/char/sclp_cpi.c b/drivers/s390/char/sclp_cpi.c
index 4f873ae148b7..65aa2c85737f 100644
--- a/drivers/s390/char/sclp_cpi.c
+++ b/drivers/s390/char/sclp_cpi.c
@@ -169,7 +169,7 @@ cpi_prepare_req(void)
        }
        /* prepare request data structure presented to SCLP driver */
-        req->command = SCLP_CMDW_WRITEDATA;
+        req->command = SCLP_CMDW_WRITE_EVENT_DATA;
        req->sccb = sccb;
        req->status = SCLP_REQ_FILLED;
        req->callback = cpi_callback;
diff --git a/drivers/s390/char/sclp_info.c b/drivers/s390/char/sclp_info.c
new file mode 100644
index 000000000000..7bcbe643b087
--- /dev/null
+++ b/drivers/s390/char/sclp_info.c
@@ -0,0 +1,57 @@
+/*
+ *  drivers/s390/char/sclp_info.c
+ *
+ *    Copyright IBM Corp. 2007
+ *    Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
+ */
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <asm/sclp.h>
+#include "sclp.h"
+struct sclp_readinfo_sccb s390_readinfo_sccb;
+void __init sclp_readinfo_early(void)
+{
+        sclp_cmdw_t command;
+        struct sccb_header *sccb;
+        int ret;
+        __ctl_set_bit(0, 9); /* enable service signal subclass mask */
+        sccb = &s390_readinfo_sccb.header;
+        command = SCLP_CMDW_READ_SCP_INFO_FORCED;
+        while (1) {
+                u16 response;
+                memset(&s390_readinfo_sccb, 0, sizeof(s390_readinfo_sccb));
+                sccb->length = sizeof(s390_readinfo_sccb);
+                sccb->control_mask[2] = 0x80;
+                ret = sclp_service_call(command, &s390_readinfo_sccb);
+                if (ret == -EIO)
+                        goto out;
+                if (ret == -EBUSY)
+                        continue;
+                __load_psw_mask(PSW_BASE_BITS | PSW_MASK_EXT |
+                                PSW_MASK_WAIT | PSW_DEFAULT_KEY);
+                local_irq_disable();
+                barrier();
+                response = sccb->response_code;
+                if (response == 0x10)
+                        break;
+                if (response != 0x1f0 || command == SCLP_CMDW_READ_SCP_INFO)
+                        break;
+                command = SCLP_CMDW_READ_SCP_INFO;
+        }
+out:
+        __ctl_clear_bit(0, 9); /* disable service signal subclass mask */
+}
diff --git a/drivers/s390/char/sclp_rw.c b/drivers/s390/char/sclp_rw.c
index 0c92d3909cca..2486783ea58e 100644
--- a/drivers/s390/char/sclp_rw.c
+++ b/drivers/s390/char/sclp_rw.c
@@ -460,7 +460,7 @@ sclp_emit_buffer(struct sclp_buffer *buffer,
                sccb->msg_buf.header.type = EvTyp_PMsgCmd;
        else
                return -ENOSYS;
-        buffer->request.command = SCLP_CMDW_WRITEDATA;
+        buffer->request.command = SCLP_CMDW_WRITE_EVENT_DATA;
        buffer->request.status = SCLP_REQ_FILLED;
        buffer->request.callback = sclp_writedata_callback;
        buffer->request.callback_data = buffer;
diff --git a/drivers/s390/char/sclp_tty.c b/drivers/s390/char/sclp_tty.c
index 2d173e5c8a09..90536f60bf50 100644
--- a/drivers/s390/char/sclp_tty.c
+++ b/drivers/s390/char/sclp_tty.c
@@ -721,7 +721,7 @@ static const struct tty_operations sclp_ops = {
        .ioctl = sclp_tty_ioctl,
 };
-int __init
+static int __init
 sclp_tty_init(void)
 {
        struct tty_driver *driver;
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index 723bf4191bfe..544f137d70d7 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -207,7 +207,7 @@ __sclp_vt220_emit(struct sclp_vt220_request *request)
                request->sclp_req.status = SCLP_REQ_FAILED;
                return -EIO;
        }
-        request->sclp_req.command = SCLP_CMDW_WRITEDATA;
+        request->sclp_req.command = SCLP_CMDW_WRITE_EVENT_DATA;
        request->sclp_req.status = SCLP_REQ_FILLED;
        request->sclp_req.callback = sclp_vt220_callback;
        request->sclp_req.callback_data = (void *) request;
@@ -669,7 +669,7 @@ static const struct tty_operations sclp_vt220_ops = {
 /*
 * Register driver with SCLP and Linux and initialize internal tty structures.
 */
-int __init
+static int __init
 sclp_vt220_tty_init(void)
 {
        struct tty_driver *driver;
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index c9f1c4c8bb13..bb4ff537729d 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -3,7 +3,7 @@
 *    tape device driver for 3480/3490E/3590 tapes.
 *
 *  S390 and zSeries version
- *    Copyright (C) 2001,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright IBM Corp. 2001,2006
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
 *               Martin Schwidefsky <schwidefsky@de.ibm.com>
@@ -99,7 +99,11 @@ enum tape_op {
        TO_DIS,         /* Tape display */
        TO_ASSIGN,      /* Assign tape to channel path */
        TO_UNASSIGN,    /* Unassign tape from channel path */
-        TO_SIZE         /* #entries in tape_op_t */
+        TO_CRYPT_ON,    /* Enable encrpytion */
+        TO_CRYPT_OFF,   /* Disable encrpytion */
+        TO_KEKL_SET,    /* Set KEK label */
+        TO_KEKL_QUERY,  /* Query KEK label */
+        TO_SIZE,        /* #entries in tape_op_t */
 };
 /* Forward declaration */
@@ -112,6 +116,7 @@ enum tape_request_status {
        TAPE_REQUEST_IN_IO,     /* request is currently in IO */
        TAPE_REQUEST_DONE,      /* request is completed. */
        TAPE_REQUEST_CANCEL,    /* request should be canceled. */
+        TAPE_REQUEST_LONG_BUSY, /* request has to be restarted after long busy */
 };
 /* Tape CCW request */
@@ -164,10 +169,11 @@ struct tape_discipline {
 * The discipline irq function either returns an error code (<0) which
 * means that the request has failed with an error or one of the following:
 */
-#define TAPE_IO_SUCCESS 0       /* request successful */
+#define TAPE_IO_SUCCESS         0       /* request successful */
-#define TAPE_IO_PENDING 1       /* request still running */
+#define TAPE_IO_PENDING         1       /* request still running */
-#define TAPE_IO_RETRY   2       /* retry to current request */
+#define TAPE_IO_RETRY           2       /* retry to current request */
-#define TAPE_IO_STOP    3       /* stop the running request */
+#define TAPE_IO_STOP            3       /* stop the running request */
+#define TAPE_IO_LONG_BUSY       4       /* delay the running request */
 /* Char Frontend Data */
 struct tape_char_data {
@@ -242,6 +248,10 @@ struct tape_device {
        /* Function to start or stop the next request later. */
        struct delayed_work             tape_dnr;
+        /* Timer for long busy */
+        struct timer_list               lb_timeout;
 };
 /* Externals from tape_core.c */
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
index 9df912f63188..50f5edab83d7 100644
--- a/drivers/s390/char/tape_3590.c
+++ b/drivers/s390/char/tape_3590.c
@@ -2,7 +2,7 @@
 *  drivers/s390/char/tape_3590.c
 *    tape device discipline for 3590 tapes.
 *
- *    Copyright (C) IBM Corp. 2001,2006
+ *    Copyright IBM Corp. 2001,2006
 *    Author(s): Stefan Bader <shbader@de.ibm.com>
 *               Michael Holzheu <holzheu@de.ibm.com>
 *               Martin Schwidefsky <schwidefsky@de.ibm.com>
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bio.h>
+#include <asm/ebcdic.h>
 #define TAPE_DBF_AREA   tape_3590_dbf
@@ -30,7 +31,7 @@ EXPORT_SYMBOL(TAPE_DBF_AREA);
 * - Read Device (buffered) log: BRA
 * - Read Library log:           BRA
 * - Swap Devices:               BRA
- * - Long Busy:                  BRA
+ * - Long Busy:                  implemented
 * - Special Intercept:          BRA
 * - Read Alternate:             implemented
 *******************************************************************/
@@ -94,6 +95,332 @@ static const char *tape_3590_msg[TAPE_3590_MAX_MSG] = {
        [0xae] = "Subsystem environmental alert",
 };
+static int crypt_supported(struct tape_device *device)
+{
+        return TAPE390_CRYPT_SUPPORTED(TAPE_3590_CRYPT_INFO(device));
+}
+static int crypt_enabled(struct tape_device *device)
+{
+        return TAPE390_CRYPT_ON(TAPE_3590_CRYPT_INFO(device));
+}
+static void ext_to_int_kekl(struct tape390_kekl *in,
+                            struct tape3592_kekl *out)
+{
+        int i;
+        memset(out, 0, sizeof(*out));
+        if (in->type == TAPE390_KEKL_TYPE_HASH)
+                out->flags |= 0x40;
+        if (in->type_on_tape == TAPE390_KEKL_TYPE_HASH)
+                out->flags |= 0x80;
+        strncpy(out->label, in->label, 64);
+        for (i = strlen(in->label); i < sizeof(out->label); i++)
+                out->label[i] = ' ';
+        ASCEBC(out->label, sizeof(out->label));
+}
+static void int_to_ext_kekl(struct tape3592_kekl *in,
+                            struct tape390_kekl *out)
+{
+        memset(out, 0, sizeof(*out));
+        if(in->flags & 0x40)
+                out->type = TAPE390_KEKL_TYPE_HASH;
+        else
+                out->type = TAPE390_KEKL_TYPE_LABEL;
+        if(in->flags & 0x80)
+                out->type_on_tape = TAPE390_KEKL_TYPE_HASH;
+        else
+                out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
+        memcpy(out->label, in->label, sizeof(in->label));
+        EBCASC(out->label, sizeof(in->label));
+        strstrip(out->label);
+}
+static void int_to_ext_kekl_pair(struct tape3592_kekl_pair *in,
+                                 struct tape390_kekl_pair *out)
+{
+        if (in->count == 0) {
+                out->kekl[0].type = TAPE390_KEKL_TYPE_NONE;
+                out->kekl[0].type_on_tape = TAPE390_KEKL_TYPE_NONE;
+                out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
+                out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
+        } else if (in->count == 1) {
+                int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
+                out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
+                out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
+        } else if (in->count == 2) {
+                int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
+                int_to_ext_kekl(&in->kekl[1], &out->kekl[1]);
+        } else {
+                printk("Invalid KEKL number: %d\n", in->count);
+                BUG();
+        }
+}
+static int check_ext_kekl(struct tape390_kekl *kekl)
+{
+        if (kekl->type == TAPE390_KEKL_TYPE_NONE)
+                goto invalid;
+        if (kekl->type > TAPE390_KEKL_TYPE_HASH)
+                goto invalid;
+        if (kekl->type_on_tape == TAPE390_KEKL_TYPE_NONE)
+                goto invalid;
+        if (kekl->type_on_tape > TAPE390_KEKL_TYPE_HASH)
+                goto invalid;
+        if ((kekl->type == TAPE390_KEKL_TYPE_HASH) &&
+            (kekl->type_on_tape == TAPE390_KEKL_TYPE_LABEL))
+                goto invalid;
+        return 0;
+invalid:
+        return -EINVAL;
+}
+static int check_ext_kekl_pair(struct tape390_kekl_pair *kekls)
+{
+        if (check_ext_kekl(&kekls->kekl[0]))
+                goto invalid;
+        if (check_ext_kekl(&kekls->kekl[1]))
+                goto invalid;
+        return 0;
+invalid:
+        return -EINVAL;
+}
+/*
+ * Query KEKLs
+ */
+static int tape_3592_kekl_query(struct tape_device *device,
+                                struct tape390_kekl_pair *ext_kekls)
+{
+        struct tape_request *request;
+        struct tape3592_kekl_query_order *order;
+        struct tape3592_kekl_query_data *int_kekls;
+        int rc;
+        DBF_EVENT(6, "tape3592_kekl_query\n");
+        int_kekls = kmalloc(sizeof(*int_kekls), GFP_KERNEL|GFP_DMA);
+        if (!int_kekls)
+                return -ENOMEM;
+        request = tape_alloc_request(2, sizeof(*order));
+        if (IS_ERR(request)) {
+                rc = PTR_ERR(request);
+                goto fail_malloc;
+        }
+        order = request->cpdata;
+        memset(order,0,sizeof(*order));
+        order->code = 0xe2;
+        order->max_count = 2;
+        request->op = TO_KEKL_QUERY;
+        tape_ccw_cc(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
+        tape_ccw_end(request->cpaddr + 1, READ_SS_DATA, sizeof(*int_kekls),
+                     int_kekls);
+        rc = tape_do_io(device, request);
+        if (rc)
+                goto fail_request;
+        int_to_ext_kekl_pair(&int_kekls->kekls, ext_kekls);
+        rc = 0;
+fail_request:
+        tape_free_request(request);
+fail_malloc:
+        kfree(int_kekls);
+        return rc;
+}
+/*
+ * IOCTL: Query KEKLs
+ */
+static int tape_3592_ioctl_kekl_query(struct tape_device *device,
+                                      unsigned long arg)
+{
+        int rc;
+        struct tape390_kekl_pair *ext_kekls;
+        DBF_EVENT(6, "tape_3592_ioctl_kekl_query\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        if (!crypt_enabled(device))
+                return -EUNATCH;
+        ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
+        if (!ext_kekls)
+                return -ENOMEM;
+        rc = tape_3592_kekl_query(device, ext_kekls);
+        if (rc != 0)
+                goto fail;
+        if (copy_to_user((char __user *) arg, ext_kekls, sizeof(*ext_kekls))) {
+                rc = -EFAULT;
+                goto fail;
+        }
+        rc = 0;
+fail:
+        kfree(ext_kekls);
+        return rc;
+}
+static int tape_3590_mttell(struct tape_device *device, int mt_count);
+/*
+ * Set KEKLs
+ */
+static int tape_3592_kekl_set(struct tape_device *device,
+                              struct tape390_kekl_pair *ext_kekls)
+{
+        struct tape_request *request;
+        struct tape3592_kekl_set_order *order;
+        DBF_EVENT(6, "tape3592_kekl_set\n");
+        if (check_ext_kekl_pair(ext_kekls)) {
+                DBF_EVENT(6, "invalid kekls\n");
+                return -EINVAL;
+        }
+        if (tape_3590_mttell(device, 0) != 0)
+                return -EBADSLT;
+        request = tape_alloc_request(1, sizeof(*order));
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        order = request->cpdata;
+        memset(order, 0, sizeof(*order));
+        order->code = 0xe3;
+        order->kekls.count = 2;
+        ext_to_int_kekl(&ext_kekls->kekl[0], &order->kekls.kekl[0]);
+        ext_to_int_kekl(&ext_kekls->kekl[1], &order->kekls.kekl[1]);
+        request->op = TO_KEKL_SET;
+        tape_ccw_end(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
+        return tape_do_io_free(device, request);
+}
+/*
+ * IOCTL: Set KEKLs
+ */
+static int tape_3592_ioctl_kekl_set(struct tape_device *device,
+                                    unsigned long arg)
+{
+        int rc;
+        struct tape390_kekl_pair *ext_kekls;
+        DBF_EVENT(6, "tape_3592_ioctl_kekl_set\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        if (!crypt_enabled(device))
+                return -EUNATCH;
+        ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
+        if (!ext_kekls)
+                return -ENOMEM;
+        if (copy_from_user(ext_kekls, (char __user *)arg, sizeof(*ext_kekls))) {
+                rc = -EFAULT;
+                goto out;
+        }
+        rc = tape_3592_kekl_set(device, ext_kekls);
+out:
+        kfree(ext_kekls);
+        return rc;
+}
+/*
+ * Enable encryption
+ */
+static int tape_3592_enable_crypt(struct tape_device *device)
+{
+        struct tape_request *request;
+        char *data;
+        DBF_EVENT(6, "tape_3592_enable_crypt\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        request = tape_alloc_request(2, 72);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        data = request->cpdata;
+        memset(data,0,72);
+        data[0]       = 0x05;
+        data[36 + 0]  = 0x03;
+        data[36 + 1]  = 0x03;
+        data[36 + 4]  = 0x40;
+        data[36 + 6]  = 0x01;
+        data[36 + 14] = 0x2f;
+        data[36 + 18] = 0xc3;
+        data[36 + 35] = 0x72;
+        request->op = TO_CRYPT_ON;
+        tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
+        tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
+        return tape_do_io_free(device, request);
+}
+/*
+ * Disable encryption
+ */
+static int tape_3592_disable_crypt(struct tape_device *device)
+{
+        struct tape_request *request;
+        char *data;
+        DBF_EVENT(6, "tape_3592_disable_crypt\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        request = tape_alloc_request(2, 72);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        data = request->cpdata;
+        memset(data,0,72);
+        data[0]       = 0x05;
+        data[36 + 0]  = 0x03;
+        data[36 + 1]  = 0x03;
+        data[36 + 35] = 0x32;
+        request->op = TO_CRYPT_OFF;
+        tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
+        tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
+        return tape_do_io_free(device, request);
+}
+/*
+ * IOCTL: Set encryption status
+ */
+static int tape_3592_ioctl_crypt_set(struct tape_device *device,
+                                     unsigned long arg)
+{
+        struct tape390_crypt_info info;
+        DBF_EVENT(6, "tape_3592_ioctl_crypt_set\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        if (copy_from_user(&info, (char __user *)arg, sizeof(info)))
+                return -EFAULT;
+        if (info.status & ~TAPE390_CRYPT_ON_MASK)
+                return -EINVAL;
+        if (info.status & TAPE390_CRYPT_ON_MASK)
+                return tape_3592_enable_crypt(device);
+        else
+                return tape_3592_disable_crypt(device);
+}
+static int tape_3590_sense_medium(struct tape_device *device);
+/*
+ * IOCTL: Query enryption status
+ */
+static int tape_3592_ioctl_crypt_query(struct tape_device *device,
+                                       unsigned long arg)
+{
+        DBF_EVENT(6, "tape_3592_ioctl_crypt_query\n");
+        if (!crypt_supported(device))
+                return -ENOSYS;
+        tape_3590_sense_medium(device);
+        if (copy_to_user((char __user *) arg, &TAPE_3590_CRYPT_INFO(device),
+                sizeof(TAPE_3590_CRYPT_INFO(device))))
+                return -EFAULT;
+        else
+                return 0;
+}
 /*
 * 3590 IOCTL Overload
 */
@@ -109,6 +436,14 @@ tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
                return tape_std_display(device, &disp);
        }
+        case TAPE390_KEKL_SET:
+                return tape_3592_ioctl_kekl_set(device, arg);
+        case TAPE390_KEKL_QUERY:
+                return tape_3592_ioctl_kekl_query(device, arg);
+        case TAPE390_CRYPT_SET:
+                return tape_3592_ioctl_crypt_set(device, arg);
+        case TAPE390_CRYPT_QUERY:
+                return tape_3592_ioctl_crypt_query(device, arg);
        default:
                return -EINVAL; /* no additional ioctls */
        }
@@ -248,6 +583,12 @@ tape_3590_work_handler(struct work_struct *work)
        case TO_READ_ATTMSG:
                tape_3590_read_attmsg(p->device);
                break;
+        case TO_CRYPT_ON:
+                tape_3592_enable_crypt(p->device);
+                break;
+        case TO_CRYPT_OFF:
+                tape_3592_disable_crypt(p->device);
+                break;
        default:
                DBF_EVENT(3, "T3590: work handler undefined for "
                          "operation 0x%02x\n", p->op);
@@ -365,6 +706,33 @@ tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
 }
 #endif
+static void tape_3590_med_state_set(struct tape_device *device,
+                                    struct tape_3590_med_sense *sense)
+{
+        struct tape390_crypt_info *c_info;
+        c_info = &TAPE_3590_CRYPT_INFO(device);
+        if (sense->masst == MSENSE_UNASSOCIATED) {
+                tape_med_state_set(device, MS_UNLOADED);
+                TAPE_3590_CRYPT_INFO(device).medium_status = 0;
+                return;
+        }
+        if (sense->masst != MSENSE_ASSOCIATED_MOUNT) {
+                PRINT_ERR("Unknown medium state: %x\n", sense->masst);
+                return;
+        }
+        tape_med_state_set(device, MS_LOADED);
+        c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
+        if (sense->flags & MSENSE_CRYPT_MASK) {
+                PRINT_INFO("Medium is encrypted (%04x)\n", sense->flags);
+                c_info->medium_status |= TAPE390_MEDIUM_ENCRYPTED_MASK;
+        } else  {
+                DBF_EVENT(6, "Medium is not encrypted %04x\n", sense->flags);
+                c_info->medium_status &= ~TAPE390_MEDIUM_ENCRYPTED_MASK;
+        }
+}
 /*
 * The done handler is called at device/channel end and wakes up the sleeping
 * process
@@ -372,9 +740,10 @@ tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
 static int
 tape_3590_done(struct tape_device *device, struct tape_request *request)
 {
-        struct tape_3590_med_sense *sense;
+        struct tape_3590_disc_data *disc_data;
        DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
+        disc_data = device->discdata;
        switch (request->op) {
        case TO_BSB:
@@ -394,13 +763,20 @@ tape_3590_done(struct tape_device *device, struct tape_request *request)
                break;
        case TO_RUN:
                tape_med_state_set(device, MS_UNLOADED);
+                tape_3590_schedule_work(device, TO_CRYPT_OFF);
                break;
        case TO_MSEN:
-                sense = (struct tape_3590_med_sense *) request->cpdata;
+                tape_3590_med_state_set(device, request->cpdata);
-                if (sense->masst == MSENSE_UNASSOCIATED)
+                break;
-                        tape_med_state_set(device, MS_UNLOADED);
+        case TO_CRYPT_ON:
-                if (sense->masst == MSENSE_ASSOCIATED_MOUNT)
+                TAPE_3590_CRYPT_INFO(device).status
-                        tape_med_state_set(device, MS_LOADED);
+                        |= TAPE390_CRYPT_ON_MASK;
+                *(device->modeset_byte) |= 0x03;
+                break;
+        case TO_CRYPT_OFF:
+                TAPE_3590_CRYPT_INFO(device).status
+                        &= ~TAPE390_CRYPT_ON_MASK;
+                *(device->modeset_byte) &= ~0x03;
                break;
        case TO_RBI:    /* RBI seems to succeed even without medium loaded. */
        case TO_NOP:    /* Same to NOP. */
@@ -409,8 +785,9 @@ tape_3590_done(struct tape_device *device, struct tape_request *request)
        case TO_DIS:
        case TO_ASSIGN:
        case TO_UNASSIGN:
-                break;
        case TO_SIZE:
+        case TO_KEKL_SET:
+        case TO_KEKL_QUERY:
                break;
        }
        return TAPE_IO_SUCCESS;
@@ -540,10 +917,8 @@ static int
 tape_3590_erp_long_busy(struct tape_device *device,
                        struct tape_request *request, struct irb *irb)
 {
-        /* FIXME: how about WAITING for a minute ? */
+        DBF_EVENT(6, "Device is busy\n");
-        PRINT_WARN("(%s): Device is busy! Please wait a minute!\n",
+        return TAPE_IO_LONG_BUSY;
-                   device->cdev->dev.bus_id);
-        return tape_3590_erp_basic(device, request, irb, -EBUSY);
 }
 /*
@@ -951,6 +1326,34 @@ tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
                   device->cdev->dev.bus_id, sense->mc);
 }
+static int tape_3590_crypt_error(struct tape_device *device,
+                                 struct tape_request *request, struct irb *irb)
+{
+        u8 cu_rc, ekm_rc1;
+        u16 ekm_rc2;
+        u32 drv_rc;
+        char *bus_id, *sense;
+        sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
+        bus_id = device->cdev->dev.bus_id;
+        cu_rc = sense[0];
+        drv_rc = *((u32*) &sense[5]) & 0xffffff;
+        ekm_rc1 = sense[9];
+        ekm_rc2 = *((u16*) &sense[10]);
+        if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
+                /* key not defined on EKM */
+                return tape_3590_erp_basic(device, request, irb, -EKEYREJECTED);
+        if ((cu_rc == 1) || (cu_rc == 2))
+                /* No connection to EKM */
+                return tape_3590_erp_basic(device, request, irb, -ENOTCONN);
+        PRINT_ERR("(%s): Unable to get encryption key from EKM\n", bus_id);
+        PRINT_ERR("(%s): CU=%02X DRIVE=%06X EKM=%02X:%04X\n", bus_id, cu_rc,
+                drv_rc, ekm_rc1, ekm_rc2);
+        return tape_3590_erp_basic(device, request, irb, -ENOKEY);
+}
 /*
 *  3590 error Recovery routine:
 *  If possible, it tries to recover from the error. If this is not possible,
@@ -979,6 +1382,8 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
        sense = (struct tape_3590_sense *) irb->ecw;
+        DBF_EVENT(6, "Unit Check: RQC = %x\n", sense->rc_rqc);
        /*
         * First check all RC-QRCs where we want to do something special
         *   - "break":     basic error recovery is done
@@ -999,6 +1404,8 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
        case 0x2231:
                tape_3590_print_era_msg(device, irb);
                return tape_3590_erp_special_interrupt(device, request, irb);
+        case 0x2240:
+                return tape_3590_crypt_error(device, request, irb);
        case 0x3010:
                DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
@@ -1020,6 +1427,7 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
                DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
                          device->cdev_id);
                tape_med_state_set(device, MS_UNLOADED);
+                tape_3590_schedule_work(device, TO_CRYPT_OFF);
                return tape_3590_erp_basic(device, request, irb, 0);
        case 0x4010:
@@ -1030,9 +1438,15 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
                PRINT_WARN("(%s): Tape operation when medium not loaded\n",
                           device->cdev->dev.bus_id);
                tape_med_state_set(device, MS_UNLOADED);
+                tape_3590_schedule_work(device, TO_CRYPT_OFF);
                return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
        case 0x4012:            /* Device Long Busy */
+                /* XXX: Also use long busy handling here? */
+                DBF_EVENT(6, "(%08x): LONG BUSY\n", device->cdev_id);
                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_basic(device, request, irb, -EBUSY);
+        case 0x4014:
+                DBF_EVENT(6, "(%08x): Crypto LONG BUSY\n", device->cdev_id);
                return tape_3590_erp_long_busy(device, request, irb);
        case 0x5010:
@@ -1064,6 +1478,7 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
        case 0x5120:
        case 0x1120:
                tape_med_state_set(device, MS_UNLOADED);
+                tape_3590_schedule_work(device, TO_CRYPT_OFF);
                return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
        case 0x6020:
@@ -1142,21 +1557,47 @@ tape_3590_setup_device(struct tape_device *device)
 {
        int rc;
        struct tape_3590_disc_data *data;
+        char *rdc_data;
        DBF_EVENT(6, "3590 device setup\n");
-        data = kmalloc(sizeof(struct tape_3590_disc_data),
+        data = kzalloc(sizeof(struct tape_3590_disc_data), GFP_KERNEL | GFP_DMA);
-                       GFP_KERNEL | GFP_DMA);
        if (data == NULL)
                return -ENOMEM;
        data->read_back_op = READ_PREVIOUS;
        device->discdata = data;
-        if ((rc = tape_std_assign(device)) == 0) {
+        rdc_data = kmalloc(64, GFP_KERNEL | GFP_DMA);
-                /* Try to find out if medium is loaded */
+        if (!rdc_data) {
-                if ((rc = tape_3590_sense_medium(device)) != 0)
+                rc = -ENOMEM;
-                        DBF_LH(3, "3590 medium sense returned %d\n", rc);
+                goto fail_kmalloc;
+        }
+        rc = read_dev_chars(device->cdev, (void**)&rdc_data, 64);
+        if (rc) {
+                DBF_LH(3, "Read device characteristics failed!\n");
+                goto fail_kmalloc;
+        }
+        rc = tape_std_assign(device);
+        if (rc)
+                goto fail_rdc_data;
+        if (rdc_data[31] == 0x13) {
+                PRINT_INFO("Device has crypto support\n");
+                data->crypt_info.capability |= TAPE390_CRYPT_SUPPORTED_MASK;
+                tape_3592_disable_crypt(device);
+        } else {
+                DBF_EVENT(6, "Device has NO crypto support\n");
        }
+        /* Try to find out if medium is loaded */
+        rc = tape_3590_sense_medium(device);
+        if (rc) {
+                DBF_LH(3, "3590 medium sense returned %d\n", rc);
+                goto fail_rdc_data;
+        }
+        return 0;
+fail_rdc_data:
+        kfree(rdc_data);
+fail_kmalloc:
+        kfree(data);
        return rc;
 }
diff --git a/drivers/s390/char/tape_3590.h b/drivers/s390/char/tape_3590.h
index cf274b9445a6..aa5138807af1 100644
--- a/drivers/s390/char/tape_3590.h
+++ b/drivers/s390/char/tape_3590.h
@@ -2,7 +2,7 @@
 *  drivers/s390/char/tape_3590.h
 *    tape device discipline for 3590 tapes.
 *
- *    Copyright (C) IBM Corp. 2001,2006
+ *    Copyright IBM Corp. 2001,2006
 *    Author(s): Stefan Bader <shbader@de.ibm.com>
 *               Michael Holzheu <holzheu@de.ibm.com>
 *               Martin Schwidefsky <schwidefsky@de.ibm.com>
@@ -38,16 +38,22 @@
 #define MSENSE_UNASSOCIATED      0x00
 #define MSENSE_ASSOCIATED_MOUNT  0x01
 #define MSENSE_ASSOCIATED_UMOUNT 0x02
+#define MSENSE_CRYPT_MASK        0x00000010
 #define TAPE_3590_MAX_MSG        0xb0
 /* Datatypes */
 struct tape_3590_disc_data {
-        unsigned char modeset_byte;
+        struct tape390_crypt_info crypt_info;
        int read_back_op;
 };
+#define TAPE_3590_CRYPT_INFO(device) \
+        ((struct tape_3590_disc_data*)(device->discdata))->crypt_info
+#define TAPE_3590_READ_BACK_OP(device) \
+        ((struct tape_3590_disc_data*)(device->discdata))->read_back_op
 struct tape_3590_sense {
        unsigned int command_rej:1;
@@ -118,7 +124,48 @@ struct tape_3590_sense {
 struct tape_3590_med_sense {
        unsigned int macst:4;
        unsigned int masst:4;
-        char pad[127];
+        char pad1[7];
+        unsigned int flags;
+        char pad2[116];
+} __attribute__ ((packed));
+/* Datastructures for 3592 encryption support */
+struct tape3592_kekl {
+        __u8 flags;
+        char label[64];
+} __attribute__ ((packed));
+struct tape3592_kekl_pair {
+        __u8 count;
+        struct tape3592_kekl kekl[2];
+} __attribute__ ((packed));
+struct tape3592_kekl_query_data {
+        __u16 len;
+        __u8  fmt;
+        __u8  mc;
+        __u32 id;
+        __u8  flags;
+        struct tape3592_kekl_pair kekls;
+        char reserved[116];
+} __attribute__ ((packed));
+struct tape3592_kekl_query_order {
+        __u8 code;
+        __u8 flags;
+        char reserved1[2];
+        __u8 max_count;
+        char reserved2[35];
+} __attribute__ ((packed));
+struct tape3592_kekl_set_order {
+        __u8 code;
+        __u8 flags;
+        char reserved1[2];
+        __u8 op;
+        struct tape3592_kekl_pair kekls;
+        char reserved2[120];
 } __attribute__ ((packed));
 #endif /* _TAPE_3590_H */
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index c8a89b3b87d4..dd0ecaed592e 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -73,7 +73,7 @@ tapeblock_trigger_requeue(struct tape_device *device)
 /*
 * Post finished request.
 */
-static inline void
+static void
 tapeblock_end_request(struct request *req, int uptodate)
 {
        if (end_that_request_first(req, uptodate, req->hard_nr_sectors))
@@ -108,7 +108,7 @@ __tapeblock_end_request(struct tape_request *ccw_req, void *data)
 /*
 * Feed the tape device CCW queue with requests supplied in a list.
 */
-static inline int
+static int
 tapeblock_start_request(struct tape_device *device, struct request *req)
 {
        struct tape_request *   ccw_req;
diff --git a/drivers/s390/char/tape_char.c b/drivers/s390/char/tape_char.c
index 31198c8f2718..9faea04e11e9 100644
--- a/drivers/s390/char/tape_char.c
+++ b/drivers/s390/char/tape_char.c
@@ -3,7 +3,7 @@
 *    character device frontend for tape device driver
 *
 *  S390 and zSeries version
- *    Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright IBM Corp. 2001,2006
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Michael Holzheu <holzheu@de.ibm.com>
 *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
@@ -89,22 +89,7 @@ tapechar_cleanup_device(struct tape_device *device)
        device->nt = NULL;
 }
-/*
+static int
- * Terminate write command (we write two TMs and skip backward over last)
- * This ensures that the tape is always correctly terminated.
- * When the user writes afterwards a new file, he will overwrite the
- * second TM and therefore one TM will remain to separate the
- * two files on the tape...
- */
-static inline void
-tapechar_terminate_write(struct tape_device *device)
-{
-        if (tape_mtop(device, MTWEOF, 1) == 0 &&
-            tape_mtop(device, MTWEOF, 1) == 0)
-                tape_mtop(device, MTBSR, 1);
-}
-static inline int
 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
 {
        struct idal_buffer *new;
@@ -137,7 +122,7 @@ tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
 /*
 * Tape device read function
 */
-ssize_t
+static ssize_t
 tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
 {
        struct tape_device *device;
@@ -201,7 +186,7 @@ tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
 /*
 * Tape device write function
 */
-ssize_t
+static ssize_t
 tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
 {
        struct tape_device *device;
@@ -291,7 +276,7 @@ tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t
 /*
 * Character frontend tape device open function.
 */
-int
+static int
 tapechar_open (struct inode *inode, struct file *filp)
 {
        struct tape_device *device;
@@ -326,7 +311,7 @@ tapechar_open (struct inode *inode, struct file *filp)
 * Character frontend tape device release function.
 */
-int
+static int
 tapechar_release(struct inode *inode, struct file *filp)
 {
        struct tape_device *device;
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index c6c2e918b990..e2a8a1a04bab 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -3,7 +3,7 @@
 *    basic function of the tape device driver
 *
 *  S390 and zSeries version
- *    Copyright (C) 2001,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright IBM Corp. 2001,2006
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Michael Holzheu <holzheu@de.ibm.com>
 *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
@@ -26,9 +26,11 @@
 #include "tape_std.h"
 #define PRINTK_HEADER "TAPE_CORE: "
+#define LONG_BUSY_TIMEOUT 180 /* seconds */
 static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
 static void tape_delayed_next_request(struct work_struct *);
+static void tape_long_busy_timeout(unsigned long data);
 /*
 * One list to contain all tape devices of all disciplines, so
@@ -69,10 +71,12 @@ const char *tape_op_verbose[TO_SIZE] =
        [TO_LOAD] = "LOA",      [TO_READ_CONFIG] = "RCF",
        [TO_READ_ATTMSG] = "RAT",
        [TO_DIS] = "DIS",       [TO_ASSIGN] = "ASS",
-        [TO_UNASSIGN] = "UAS"
+        [TO_UNASSIGN] = "UAS",  [TO_CRYPT_ON] = "CON",
+        [TO_CRYPT_OFF] = "COF", [TO_KEKL_SET] = "KLS",
+        [TO_KEKL_QUERY] = "KLQ",
 };
-static inline int
+static int
 busid_to_int(char *bus_id)
 {
        int     dec;
@@ -252,7 +256,7 @@ tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
 /*
 * Stop running ccw. Has to be called with the device lock held.
 */
-static inline int
+static int
 __tape_cancel_io(struct tape_device *device, struct tape_request *request)
 {
        int retries;
@@ -346,6 +350,9 @@ tape_generic_online(struct tape_device *device,
                return -EINVAL;
        }
+        init_timer(&device->lb_timeout);
+        device->lb_timeout.function = tape_long_busy_timeout;
        /* Let the discipline have a go at the device. */
        device->discipline = discipline;
        if (!try_module_get(discipline->owner)) {
@@ -385,7 +392,7 @@ out:
        return rc;
 }
-static inline void
+static void
 tape_cleanup_device(struct tape_device *device)
 {
        tapeblock_cleanup_device(device);
@@ -563,7 +570,7 @@ tape_generic_probe(struct ccw_device *cdev)
        return ret;
 }
-static inline void
+static void
 __tape_discard_requests(struct tape_device *device)
 {
        struct tape_request *   request;
@@ -703,7 +710,7 @@ tape_free_request (struct tape_request * request)
        kfree(request);
 }
-static inline int
+static int
 __tape_start_io(struct tape_device *device, struct tape_request *request)
 {
        int rc;
@@ -733,7 +740,7 @@ __tape_start_io(struct tape_device *device, struct tape_request *request)
        return rc;
 }
-static inline void
+static void
 __tape_start_next_request(struct tape_device *device)
 {
        struct list_head *l, *n;
@@ -801,7 +808,23 @@ tape_delayed_next_request(struct work_struct *work)
        spin_unlock_irq(get_ccwdev_lock(device->cdev));
 }
-static inline void
+static void tape_long_busy_timeout(unsigned long data)
+{
+        struct tape_request *request;
+        struct tape_device *device;
+        device = (struct tape_device *) data;
+        spin_lock_irq(get_ccwdev_lock(device->cdev));
+        request = list_entry(device->req_queue.next, struct tape_request, list);
+        if (request->status != TAPE_REQUEST_LONG_BUSY)
+                BUG();
+        DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
+        __tape_start_next_request(device);
+        device->lb_timeout.data = (unsigned long) tape_put_device(device);
+        spin_unlock_irq(get_ccwdev_lock(device->cdev));
+}
+static void
 __tape_end_request(
        struct tape_device *    device,
        struct tape_request *   request,
@@ -878,7 +901,7 @@ tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
 * and starts it if the tape is idle. Has to be called with
 * the device lock held.
 */
-static inline int
+static int
 __tape_start_request(struct tape_device *device, struct tape_request *request)
 {
        int rc;
@@ -1094,7 +1117,22 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
        /* May be an unsolicited irq */
        if(request != NULL)
                request->rescnt = irb->scsw.count;
+        else if ((irb->scsw.dstat == 0x85 || irb->scsw.dstat == 0x80) &&
+                 !list_empty(&device->req_queue)) {
+                /* Not Ready to Ready after long busy ? */
+                struct tape_request *req;
+                req = list_entry(device->req_queue.next,
+                                 struct tape_request, list);
+                if (req->status == TAPE_REQUEST_LONG_BUSY) {
+                        DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
+                        if (del_timer(&device->lb_timeout)) {
+                                device->lb_timeout.data = (unsigned long)
+                                        tape_put_device(device);
+                                __tape_start_next_request(device);
+                        }
+                        return;
+                }
+        }
        if (irb->scsw.dstat != 0x0c) {
                /* Set the 'ONLINE' flag depending on sense byte 1 */
                if(*(((__u8 *) irb->ecw) + 1) & SENSE_DRIVE_ONLINE)
@@ -1142,6 +1180,15 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                        break;
                case TAPE_IO_PENDING:
                        break;
+                case TAPE_IO_LONG_BUSY:
+                        device->lb_timeout.data =
+                                (unsigned long)tape_get_device_reference(device);
+                        device->lb_timeout.expires = jiffies +
+                                LONG_BUSY_TIMEOUT * HZ;
+                        DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
+                        add_timer(&device->lb_timeout);
+                        request->status = TAPE_REQUEST_LONG_BUSY;
+                        break;
                case TAPE_IO_RETRY:
                        rc = __tape_start_io(device, request);
                        if (rc)
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 09844621edc0..bc33068b9ce2 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -36,7 +36,7 @@
 struct tty_driver *tty3270_driver;
 static int tty3270_max_index;
-struct raw3270_fn tty3270_fn;
+static struct raw3270_fn tty3270_fn;
 struct tty3270_cell {
        unsigned char character;
@@ -119,8 +119,7 @@ static void tty3270_update(struct tty3270 *);
 /*
 * Setup timeout for a device. On timeout trigger an update.
 */
-void
+static void tty3270_set_timer(struct tty3270 *tp, int expires)
-tty3270_set_timer(struct tty3270 *tp, int expires)
 {
        if (expires == 0) {
                if (timer_pending(&tp->timer) && del_timer(&tp->timer))
@@ -841,7 +840,7 @@ tty3270_del_views(void)
        }
 }
-struct raw3270_fn tty3270_fn = {
+static struct raw3270_fn tty3270_fn = {
        .activate = tty3270_activate,
        .deactivate = tty3270_deactivate,
        .intv = (void *) tty3270_irq,
@@ -1754,8 +1753,7 @@ static const struct tty_operations tty3270_ops = {
        .set_termios = tty3270_set_termios
 };
-void
+static void tty3270_notifier(int index, int active)
-tty3270_notifier(int index, int active)
 {
        if (active)
                tty_register_device(tty3270_driver, index, NULL);
@@ -1767,8 +1765,7 @@ tty3270_notifier(int index, int active)
 * 3270 tty registration code called from tty_init().
 * Most kernel services (incl. kmalloc) are available at this poimt.
 */
-int __init
+static int __init tty3270_init(void)
-tty3270_init(void)
 {
        struct tty_driver *driver;
        int ret;
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index 6cb23040954b..4f894dc2373b 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -128,9 +128,8 @@ static iucv_interrupt_ops_t vmlogrdr_iucvops = {
        .MessagePending     = vmlogrdr_iucv_MessagePending,
 };
+static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
-DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
+static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
-DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
 /*
 * pointer to system service private structure
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index 12c2d6b746e6..aa65df4dfced 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -43,7 +43,7 @@ typedef enum {add, free} range_action;
 * Function: blacklist_range
 * (Un-)blacklist the devices from-to
 */
-static inline void
+static void
 blacklist_range (range_action action, unsigned int from, unsigned int to,
                 unsigned int ssid)
 {
@@ -69,7 +69,7 @@ blacklist_range (range_action action, unsigned int from, unsigned int to,
 * Get devno/busid from given string.
 * Shamelessly grabbed from dasd_devmap.c.
 */
-static inline int
+static int
 blacklist_busid(char **str, int *id0, int *ssid, int *devno)
 {
        int val, old_style;
@@ -123,10 +123,10 @@ confused:
        return 1;
 }
-static inline int
+static int
 blacklist_parse_parameters (char *str, range_action action)
 {
-        unsigned int from, to, from_id0, to_id0, from_ssid, to_ssid;
+        int from, to, from_id0, to_id0, from_ssid, to_ssid;
        while (*str != 0 && *str != '\n') {
                range_action ra = action;
@@ -227,7 +227,7 @@ is_blacklisted (int ssid, int devno)
 * Function: blacklist_parse_proc_parameters
 * parse the stuff which is piped to /proc/cio_ignore
 */
-static inline void
+static void
 blacklist_parse_proc_parameters (char *buf)
 {
        if (strncmp (buf, "free ", 5) == 0) {
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 38954f5cd14c..d48e3ca4752c 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -53,7 +53,7 @@ ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer,
 static struct bus_type ccwgroup_bus_type;
-static inline void
+static void
 __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
 {
        int i;
@@ -104,7 +104,7 @@ ccwgroup_release (struct device *dev)
        kfree(gdev);
 }
-static inline int
+static int
 __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
 {
        char str[8];
@@ -424,7 +424,7 @@ ccwgroup_probe_ccwdev(struct ccw_device *cdev)
        return 0;
 }
-static inline struct ccwgroup_device *
+static struct ccwgroup_device *
 __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
 {
        struct ccwgroup_device *gdev;
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index cbab8d2ce5cf..6f05a44e3817 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -93,7 +93,7 @@ chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
                u16 sch;          /* subchannel */
                u8 chpid[8];      /* chpids 0-7 */
                u16 fla[8];       /* full link addresses 0-7 */
-        } *ssd_area;
+        } __attribute__ ((packed)) *ssd_area;
        ssd_area = page;
@@ -277,7 +277,7 @@ out_unreg:
        return 0;
 }
-static inline void
+static void
 s390_set_chpid_offline( __u8 chpid)
 {
        char dbf_txt[15];
@@ -338,7 +338,7 @@ s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch)
        return 0x80 >> chp;
 }
-static inline int
+static int
 s390_process_res_acc_new_sch(struct subchannel_id schid)
 {
        struct schib schib;
@@ -444,7 +444,7 @@ __get_chpid_from_lir(void *data)
                u32 andesc[28];
                /* incident-specific information */
                u32 isinfo[28];
-        } *lir;
+        } __attribute__ ((packed)) *lir;
        lir = data;
        if (!(lir->iq&0x80))
@@ -461,154 +461,146 @@ __get_chpid_from_lir(void *data)
        return (u16) (lir->indesc[0]&0x000000ff);
 }
-int
+struct chsc_sei_area {
-chsc_process_crw(void)
+        struct chsc_header request;
+        u32 reserved1;
+        u32 reserved2;
+        u32 reserved3;
+        struct chsc_header response;
+        u32 reserved4;
+        u8  flags;
+        u8  vf;         /* validity flags */
+        u8  rs;         /* reporting source */
+        u8  cc;         /* content code */
+        u16 fla;        /* full link address */
+        u16 rsid;       /* reporting source id */
+        u32 reserved5;
+        u32 reserved6;
+        u8 ccdf[4096 - 16 - 24];        /* content-code dependent field */
+        /* ccdf has to be big enough for a link-incident record */
+} __attribute__ ((packed));
+static int chsc_process_sei_link_incident(struct chsc_sei_area *sei_area)
+{
+        int chpid;
+        CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n",
+                      sei_area->rs, sei_area->rsid);
+        if (sei_area->rs != 4)
+                return 0;
+        chpid = __get_chpid_from_lir(sei_area->ccdf);
+        if (chpid < 0)
+                CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n");
+        else
+                s390_set_chpid_offline(chpid);
+        return 0;
+}
+static int chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)
 {
-        int chpid, ret;
        struct res_acc_data res_data;
-        struct {
+        struct device *dev;
-                struct chsc_header request;
+        int status;
-                u32 reserved1;
+        int rc;
-                u32 reserved2;
-                u32 reserved3;
+        CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
-                struct chsc_header response;
+                      "rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
-                u32 reserved4;
+        if (sei_area->rs != 4)
-                u8  flags;
+                return 0;
-                u8  vf;         /* validity flags */
+        /* allocate a new channel path structure, if needed */
-                u8  rs;         /* reporting source */
+        status = get_chp_status(sei_area->rsid);
-                u8  cc;         /* content code */
+        if (status < 0)
-                u16 fla;        /* full link address */
+                new_channel_path(sei_area->rsid);
-                u16 rsid;       /* reporting source id */
+        else if (!status)
-                u32 reserved5;
+                return 0;
-                u32 reserved6;
+        dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
-                u32 ccdf[96];   /* content-code dependent field */
+        memset(&res_data, 0, sizeof(struct res_acc_data));
-                /* ccdf has to be big enough for a link-incident record */
+        res_data.chp = to_channelpath(dev);
-        } *sei_area;
+        if ((sei_area->vf & 0xc0) != 0) {
+                res_data.fla = sei_area->fla;
+                if ((sei_area->vf & 0xc0) == 0xc0)
+                        /* full link address */
+                        res_data.fla_mask = 0xffff;
+                else
+                        /* link address */
+                        res_data.fla_mask = 0xff00;
+        }
+        rc = s390_process_res_acc(&res_data);
+        put_device(dev);
+        return rc;
+}
+static int chsc_process_sei(struct chsc_sei_area *sei_area)
+{
+        int rc;
+        /* Check if we might have lost some information. */
+        if (sei_area->flags & 0x40)
+                CIO_CRW_EVENT(2, "chsc: event overflow\n");
+        /* which kind of information was stored? */
+        rc = 0;
+        switch (sei_area->cc) {
+        case 1: /* link incident*/
+                rc = chsc_process_sei_link_incident(sei_area);
+                break;
+        case 2: /* i/o resource accessibiliy */
+                rc = chsc_process_sei_res_acc(sei_area);
+                break;
+        default: /* other stuff */
+                CIO_CRW_EVENT(4, "chsc: unhandled sei content code %d\n",
+                              sei_area->cc);
+                break;
+        }
+        return rc;
+}
+int chsc_process_crw(void)
+{
+        struct chsc_sei_area *sei_area;
+        int ret;
+        int rc;
        if (!sei_page)
                return 0;
-        /*
+        /* Access to sei_page is serialized through machine check handler
-         * build the chsc request block for store event information
+         * thread, so no need for locking. */
-         * and do the call
-         * This function is only called by the machine check handler thread,
-         * so we don't need locking for the sei_page.
-         */
        sei_area = sei_page;
        CIO_TRACE_EVENT( 2, "prcss");
        ret = 0;
        do {
-                int ccode, status;
-                struct device *dev;
                memset(sei_area, 0, sizeof(*sei_area));
-                memset(&res_data, 0, sizeof(struct res_acc_data));
                sei_area->request.length = 0x0010;
                sei_area->request.code = 0x000e;
+                if (chsc(sei_area))
+                        break;
-                ccode = chsc(sei_area);
+                if (sei_area->response.code == 0x0001) {
-                if (ccode > 0)
+                        CIO_CRW_EVENT(4, "chsc: sei successful\n");
-                        return 0;
+                        rc = chsc_process_sei(sei_area);
+                        if (rc)
-                switch (sei_area->response.code) {
+                                ret = rc;
-                        /* for debug purposes, check for problems */
+                } else {
-                case 0x0001:
+                        CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n",
-                        CIO_CRW_EVENT(4, "chsc_process_crw: event information "
-                                        "successfully stored\n");
-                        break; /* everything ok */
-                case 0x0002:
-                        CIO_CRW_EVENT(2,
-                                      "chsc_process_crw: invalid command!\n");
-                        return 0;
-                case 0x0003:
-                        CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
-                                      "request block!\n");
-                        return 0;
-                case 0x0005:
-                        CIO_CRW_EVENT(2, "chsc_process_crw: no event "
-                                      "information stored\n");
-                        return 0;
-                default:
-                        CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
                                      sei_area->response.code);
-                        return 0;
+                        ret = 0;
-                }
-                /* Check if we might have lost some information. */
-                if (sei_area->flags & 0x40)
-                        CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
-                                       "has been lost due to overflow!\n");
-                if (sei_area->rs != 4) {
-                        CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
-                                      "(%04X) isn't a chpid!\n",
-                                      sei_area->rsid);
-                        continue;
-                }
-                /* which kind of information was stored? */
-                switch (sei_area->cc) {
-                case 1: /* link incident*/
-                        CIO_CRW_EVENT(4, "chsc_process_crw: "
-                                      "channel subsystem reports link incident,"
-                                      " reporting source is chpid %x\n",
-                                      sei_area->rsid);
-                        chpid = __get_chpid_from_lir(sei_area->ccdf);
-                        if (chpid < 0)
-                                CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
-                                              __FUNCTION__);
-                        else
-                                s390_set_chpid_offline(chpid);
-                        break;
-                        
-                case 2: /* i/o resource accessibiliy */
-                        CIO_CRW_EVENT(4, "chsc_process_crw: "
-                                      "channel subsystem reports some I/O "
-                                      "devices may have become accessible\n");
-                        pr_debug("Data received after sei: \n");
-                        pr_debug("Validity flags: %x\n", sei_area->vf);
-                        
-                        /* allocate a new channel path structure, if needed */
-                        status = get_chp_status(sei_area->rsid);
-                        if (status < 0)
-                                new_channel_path(sei_area->rsid);
-                        else if (!status)
-                                break;
-                        dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
-                        res_data.chp = to_channelpath(dev);
-                        pr_debug("chpid: %x", sei_area->rsid);
-                        if ((sei_area->vf & 0xc0) != 0) {
-                                res_data.fla = sei_area->fla;
-                                if ((sei_area->vf & 0xc0) == 0xc0) {
-                                        pr_debug(" full link addr: %x",
-                                                 sei_area->fla);
-                                        res_data.fla_mask = 0xffff;
-                                } else {
-                                        pr_debug(" link addr: %x",
-                                                 sei_area->fla);
-                                        res_data.fla_mask = 0xff00;
-                                }
-                        }
-                        ret = s390_process_res_acc(&res_data);
-                        pr_debug("\n\n");
-                        put_device(dev);
-                        break;
-                        
-                default: /* other stuff */
-                        CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
-                                      sei_area->cc);
                        break;
                }
        } while (sei_area->flags & 0x80);
        return ret;
 }
-static inline int
+static int
 __chp_add_new_sch(struct subchannel_id schid)
 {
        struct schib schib;
        int ret;
-        if (stsch(schid, &schib))
+        if (stsch_err(schid, &schib))
                /* We're through */
                return need_rescan ? -EAGAIN : -ENXIO;
@@ -709,7 +701,7 @@ chp_process_crw(int chpid, int on)
        return chp_add(chpid);
 }
-static inline int check_for_io_on_path(struct subchannel *sch, int index)
+static int check_for_io_on_path(struct subchannel *sch, int index)
 {
        int cc;
@@ -741,7 +733,7 @@ static void terminate_internal_io(struct subchannel *sch)
                sch->driver->termination(&sch->dev);
 }
-static inline void
+static void
 __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on)
 {
        int chp, old_lpm;
@@ -967,8 +959,8 @@ static struct bin_attribute chp_measurement_attr = {
 static void
 chsc_remove_chp_cmg_attr(struct channel_path *chp)
 {
-        sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr);
+        device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
-        sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr);
+        device_remove_bin_file(&chp->dev, &chp_measurement_attr);
 }
 static int
@@ -976,14 +968,12 @@ chsc_add_chp_cmg_attr(struct channel_path *chp)
 {
        int ret;
-        ret = sysfs_create_bin_file(&chp->dev.kobj,
+        ret = device_create_bin_file(&chp->dev, &chp_measurement_chars_attr);
-                                    &chp_measurement_chars_attr);
        if (ret)
                return ret;
-        ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr);
+        ret = device_create_bin_file(&chp->dev, &chp_measurement_attr);
        if (ret)
-                sysfs_remove_bin_file(&chp->dev.kobj,
+                device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
-                                      &chp_measurement_chars_attr);
        return ret;
 }
@@ -1042,7 +1032,7 @@ __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
                u32 : 4;
                u32 fmt : 4;
                u32 : 16;
-        } *secm_area;
+        } __attribute__ ((packed)) *secm_area;
        int ret, ccode;
        secm_area = page;
@@ -1253,7 +1243,7 @@ chsc_determine_channel_path_description(int chpid,
                struct chsc_header response;
                u32 zeroes2;
                struct channel_path_desc desc;
-        } *scpd_area;
+        } __attribute__ ((packed)) *scpd_area;
        scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
        if (!scpd_area)
@@ -1350,7 +1340,7 @@ chsc_get_channel_measurement_chars(struct channel_path *chp)
                u32 cmg : 8;
                u32 zeroes3;
                u32 data[NR_MEASUREMENT_CHARS];
-        } *scmc_area;
+        } __attribute__ ((packed)) *scmc_area;
        scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
        if (!scmc_area)
@@ -1517,7 +1507,7 @@ chsc_enable_facility(int operation_code)
                u32 reserved5:4;
                u32 format2:4;
                u32 reserved6:24;
-        } *sda_area;
+        } __attribute__ ((packed)) *sda_area;
        sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
        if (!sda_area)
@@ -1569,7 +1559,7 @@ chsc_determine_css_characteristics(void)
                u32 reserved4;
                u32 general_char[510];
                u32 chsc_char[518];
-        } *scsc_area;
+        } __attribute__ ((packed)) *scsc_area;
        scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
        if (!scsc_area) {
diff --git a/drivers/s390/cio/chsc.h b/drivers/s390/cio/chsc.h
index a259245780ae..0fb2b024208f 100644
--- a/drivers/s390/cio/chsc.h
+++ b/drivers/s390/cio/chsc.h
@@ -10,17 +10,17 @@
 struct chsc_header {
        u16 length;
        u16 code;
-};
+} __attribute__ ((packed));
 #define NR_MEASUREMENT_CHARS 5
 struct cmg_chars {
        u32 values[NR_MEASUREMENT_CHARS];
-};
+} __attribute__ ((packed));
 #define NR_MEASUREMENT_ENTRIES 8
 struct cmg_entry {
        u32 values[NR_MEASUREMENT_ENTRIES];
-};
+} __attribute__ ((packed));
 struct channel_path_desc {
        u8 flags;
@@ -31,7 +31,7 @@ struct channel_path_desc {
        u8 zeroes;
        u8 chla;
        u8 chpp;
-};
+} __attribute__ ((packed));
 struct channel_path {
        int id;
@@ -47,6 +47,9 @@ struct channel_path {
 extern void s390_process_css( void );
 extern void chsc_validate_chpids(struct subchannel *);
 extern void chpid_is_actually_online(int);
+extern int css_get_ssd_info(struct subchannel *);
+extern int chsc_process_crw(void);
+extern int chp_process_crw(int, int);
 struct css_general_char {
        u64 : 41;
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index ae1bf231d089..b3a56dc5f68a 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -122,7 +122,7 @@ cio_get_options (struct subchannel *sch)
 * Use tpi to get a pending interrupt, call the interrupt handler and
 * return a pointer to the subchannel structure.
 */
-static inline int
+static int
 cio_tpi(void)
 {
        struct tpi_info *tpi_info;
@@ -152,7 +152,7 @@ cio_tpi(void)
        return 1;
 }
-static inline int
+static int
 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
 {
        char dbf_text[15];
@@ -585,7 +585,7 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
                 * This device must not be known to Linux. So we simply
                 * say that there is no device and return ENODEV.
                 */
-                CIO_MSG_EVENT(0, "Blacklisted device detected "
+                CIO_MSG_EVENT(4, "Blacklisted device detected "
                              "at devno %04X, subchannel set %x\n",
                              sch->schib.pmcw.dev, sch->schid.ssid);
                err = -ENODEV;
@@ -646,7 +646,7 @@ do_IRQ (struct pt_regs *regs)
                 * Make sure that the i/o interrupt did not "overtake"
                 * the last HZ timer interrupt.
                 */
-                account_ticks();
+                account_ticks(S390_lowcore.int_clock);
        /*
         * Get interrupt information from lowcore
         */
@@ -832,7 +832,7 @@ cio_get_console_subchannel(void)
 }
 #endif
-static inline int
+static int
 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
 {
        int retry, cc;
@@ -850,7 +850,20 @@ __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
        return -EBUSY; /* uhm... */
 }
-static inline int
+/* we can't use the normal udelay here, since it enables external interrupts */
+static void udelay_reset(unsigned long usecs)
+{
+        uint64_t start_cc, end_cc;
+        asm volatile ("STCK %0" : "=m" (start_cc));
+        do {
+                cpu_relax();
+                asm volatile ("STCK %0" : "=m" (end_cc));
+        } while (((end_cc - start_cc)/4096) < usecs);
+}
+static int
 __clear_subchannel_easy(struct subchannel_id schid)
 {
        int retry;
@@ -865,7 +878,7 @@ __clear_subchannel_easy(struct subchannel_id schid)
                        if (schid_equal(&ti.schid, &schid))
                                return 0;
                }
-                udelay(100);
+                udelay_reset(100);
        }
        return -EBUSY;
 }
@@ -882,11 +895,11 @@ static int stsch_reset(struct subchannel_id schid, volatile struct schib *addr)
        int rc;
        pgm_check_occured = 0;
-        s390_reset_pgm_handler = cio_reset_pgm_check_handler;
+        s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
        rc = stsch(schid, addr);
-        s390_reset_pgm_handler = NULL;
+        s390_base_pgm_handler_fn = NULL;
-        /* The program check handler could have changed pgm_check_occured */
+        /* The program check handler could have changed pgm_check_occured. */
        barrier();
        if (pgm_check_occured)
@@ -944,7 +957,7 @@ static void css_reset(void)
        /* Reset subchannels. */
        for_each_subchannel(__shutdown_subchannel_easy,  NULL);
        /* Reset channel paths. */
-        s390_reset_mcck_handler = s390_reset_chpids_mcck_handler;
+        s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
        /* Enable channel report machine checks. */
        __ctl_set_bit(14, 28);
        /* Temporarily reenable machine checks. */
@@ -969,7 +982,7 @@ static void css_reset(void)
        local_mcck_disable();
        /* Disable channel report machine checks. */
        __ctl_clear_bit(14, 28);
-        s390_reset_mcck_handler = NULL;
+        s390_base_mcck_handler_fn = NULL;
 }
 static struct reset_call css_reset_call = {
diff --git a/drivers/s390/cio/cmf.c b/drivers/s390/cio/cmf.c
index 828b2d334f0a..90b22faabbf7 100644
--- a/drivers/s390/cio/cmf.c
+++ b/drivers/s390/cio/cmf.c
@@ -519,8 +519,8 @@ struct cmb {
 /* insert a single device into the cmb_area list
 * called with cmb_area.lock held from alloc_cmb
 */
-static inline int alloc_cmb_single (struct ccw_device *cdev,
+static int alloc_cmb_single(struct ccw_device *cdev,
-                                    struct cmb_data *cmb_data)
+                            struct cmb_data *cmb_data)
 {
        struct cmb *cmb;
        struct ccw_device_private *node;
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 9d6c02446863..fe0ace7aece8 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -30,7 +30,7 @@ struct channel_subsystem *css[__MAX_CSSID + 1];
 int css_characteristics_avail = 0;
-inline int
+int
 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
 {
        struct subchannel_id schid;
@@ -108,9 +108,6 @@ css_subchannel_release(struct device *dev)
        }
 }
-extern int css_get_ssd_info(struct subchannel *sch);
 int css_sch_device_register(struct subchannel *sch)
 {
        int ret;
@@ -187,7 +184,7 @@ get_subchannel_by_schid(struct subchannel_id schid)
        return dev ? to_subchannel(dev) : NULL;
 }
-static inline int css_get_subchannel_status(struct subchannel *sch)
+static int css_get_subchannel_status(struct subchannel *sch)
 {
        struct schib schib;
@@ -299,7 +296,7 @@ static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
                /* Will be done on the slow path. */
                return -EAGAIN;
        }
-        if (stsch(schid, &schib) || !schib.pmcw.dnv) {
+        if (stsch_err(schid, &schib) || !schib.pmcw.dnv) {
                /* Unusable - ignore. */
                return 0;
        }
@@ -417,7 +414,7 @@ static void reprobe_all(struct work_struct *unused)
                      need_reprobe);
 }
-DECLARE_WORK(css_reprobe_work, reprobe_all);
+static DECLARE_WORK(css_reprobe_work, reprobe_all);
 /* Schedule reprobing of all unregistered subchannels. */
 void css_schedule_reprobe(void)
@@ -578,7 +575,7 @@ css_cm_enable_store(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
-static inline int __init setup_css(int nr)
+static int __init setup_css(int nr)
 {
        u32 tod_high;
        int ret;
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 3464c5b875c4..ca2bab932a8a 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -143,6 +143,8 @@ extern void css_sch_device_unregister(struct subchannel *);
 extern struct subchannel * get_subchannel_by_schid(struct subchannel_id);
 extern int css_init_done;
 extern int for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *);
+extern int css_process_crw(int, int);
+extern void css_reiterate_subchannels(void);
 #define __MAX_SUBCHANNEL 65535
 #define __MAX_SSID 3
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 803579053c2f..e322111fb369 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -138,7 +138,6 @@ struct bus_type ccw_bus_type;
 static int io_subchannel_probe (struct subchannel *);
 static int io_subchannel_remove (struct subchannel *);
-void io_subchannel_irq (struct device *);
 static int io_subchannel_notify(struct device *, int);
 static void io_subchannel_verify(struct device *);
 static void io_subchannel_ioterm(struct device *);
@@ -235,11 +234,8 @@ chpids_show (struct device * dev, struct device_attribute *attr, char * buf)
        ssize_t ret = 0;
        int chp;
-        if (ssd)
+        for (chp = 0; chp < 8; chp++)
-                for (chp = 0; chp < 8; chp++)
+                ret += sprintf (buf+ret, "%02x ", ssd->chpid[chp]);
-                        ret += sprintf (buf+ret, "%02x ", ssd->chpid[chp]);
-        else
-                ret += sprintf (buf, "n/a");
        ret += sprintf (buf+ret, "\n");
        return min((ssize_t)PAGE_SIZE, ret);
 }
@@ -552,13 +548,13 @@ static struct attribute_group ccwdev_attr_group = {
        .attrs = ccwdev_attrs,
 };
-static inline int
+static int
 device_add_files (struct device *dev)
 {
        return sysfs_create_group(&dev->kobj, &ccwdev_attr_group);
 }
-static inline void
+static void
 device_remove_files(struct device *dev)
 {
        sysfs_remove_group(&dev->kobj, &ccwdev_attr_group);
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index 29db6341d632..b66338b76579 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -74,6 +74,7 @@ extern struct workqueue_struct *ccw_device_notify_work;
 extern wait_queue_head_t ccw_device_init_wq;
 extern atomic_t ccw_device_init_count;
+void io_subchannel_irq (struct device *pdev);
 void io_subchannel_recog_done(struct ccw_device *cdev);
 int ccw_device_cancel_halt_clear(struct ccw_device *);
@@ -118,6 +119,7 @@ int ccw_device_stlck(struct ccw_device *);
 /* qdio needs this. */
 void ccw_device_set_timeout(struct ccw_device *, int);
 extern struct subchannel_id ccw_device_get_subchannel_id(struct ccw_device *);
+extern struct bus_type ccw_bus_type;
 /* Channel measurement facility related */
 void retry_set_schib(struct ccw_device *cdev);
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index eed14572fc3b..51238e7555bb 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -206,7 +206,7 @@ ccw_device_handle_oper(struct ccw_device *cdev)
 * been varied online on the SE so we have to find out by magic (i. e. driving
 * the channel subsystem to device selection and updating our path masks).
 */
-static inline void
+static void
 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
 {
        int mask, i;
@@ -387,7 +387,7 @@ ccw_device_done(struct ccw_device *cdev, int state)
                put_device (&cdev->dev);
 }
-static inline int cmp_pgid(struct pgid *p1, struct pgid *p2)
+static int cmp_pgid(struct pgid *p1, struct pgid *p2)
 {
        char *c1;
        char *c2;
@@ -842,6 +842,8 @@ ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
 call_handler_unsol:
                if (cdev->handler)
                        cdev->handler (cdev, 0, irb);
+                if (cdev->private->flags.doverify)
+                        ccw_device_online_verify(cdev, 0);
                return;
        }
        /* Accumulate status and find out if a basic sense is needed. */
@@ -892,7 +894,7 @@ ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 /*
 * Got an interrupt for a basic sense.
 */
-void
+static void
 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
 {
        struct irb *irb;
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index d269607336ec..d7b25b8f71d2 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -302,7 +302,7 @@ ccw_device_wake_up(struct ccw_device *cdev, unsigned long ip, struct irb *irb)
        wake_up(&cdev->private->wait_q);
 }
-static inline int
+static int
 __ccw_device_retry_loop(struct ccw_device *cdev, struct ccw1 *ccw, long magic, __u8 lpm)
 {
        int ret;
diff --git a/drivers/s390/cio/device_status.c b/drivers/s390/cio/device_status.c
index bdcf930f7beb..6b1caea622ea 100644
--- a/drivers/s390/cio/device_status.c
+++ b/drivers/s390/cio/device_status.c
@@ -25,7 +25,7 @@
 * Check for any kind of channel or interface control check but don't
 * issue the message for the console device
 */
-static inline void
+static void
 ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb)
 {
        if (!(irb->scsw.cstat & (SCHN_STAT_CHN_DATA_CHK |
@@ -72,7 +72,7 @@ ccw_device_path_notoper(struct ccw_device *cdev)
 /*
 * Copy valid bits from the extended control word to device irb.
 */
-static inline void
+static void
 ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb)
 {
        /*
@@ -94,7 +94,7 @@ ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb)
 /*
 * Check if extended status word is valid.
 */
-static inline int
+static int
 ccw_device_accumulate_esw_valid(struct irb *irb)
 {
        if (!irb->scsw.eswf && irb->scsw.stctl == SCSW_STCTL_STATUS_PEND)
@@ -109,7 +109,7 @@ ccw_device_accumulate_esw_valid(struct irb *irb)
 /*
 * Copy valid bits from the extended status word to device irb.
 */
-static inline void
+static void
 ccw_device_accumulate_esw(struct ccw_device *cdev, struct irb *irb)
 {
        struct irb *cdev_irb;
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 6fd1940842eb..d726cd5777de 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -66,7 +66,6 @@ MODULE_LICENSE("GPL");
 /******************** HERE WE GO ***********************************/
 static const char version[] = "QDIO base support version 2";
-extern struct bus_type ccw_bus_type;
 static int qdio_performance_stats = 0;
 static int proc_perf_file_registration;
@@ -138,7 +137,7 @@ qdio_release_q(struct qdio_q *q)
 }
 /*check ccq  */
-static inline int
+static int
 qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
 {
        char dbf_text[15];
@@ -153,7 +152,7 @@ qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
        return -EIO;
 }
 /* EQBS: extract buffer states */
-static inline int
+static int
 qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
             unsigned int *start, unsigned int *cnt)
 {
@@ -188,7 +187,7 @@ again:
 }
 /* SQBS: set buffer states */
-static inline int
+static int
 qdio_do_sqbs(struct qdio_q *q, unsigned char state,
             unsigned int *start, unsigned int *cnt)
 {
@@ -315,7 +314,7 @@ __do_siga_output(struct qdio_q *q, unsigned int *busy_bit)
 * returns QDIO_SIGA_ERROR_ACCESS_EXCEPTION as cc, when SIGA returns
 * an access exception 
 */
-static inline int 
+static int
 qdio_siga_output(struct qdio_q *q)
 {
        int cc;
@@ -349,7 +348,7 @@ qdio_siga_output(struct qdio_q *q)
        return cc;
 }
-static inline int 
+static int
 qdio_siga_input(struct qdio_q *q)
 {
        int cc;
@@ -421,7 +420,7 @@ tiqdio_sched_tl(void)
        tasklet_hi_schedule(&tiqdio_tasklet);
 }
-static inline void
+static void
 qdio_mark_tiq(struct qdio_q *q)
 {
        unsigned long flags;
@@ -471,7 +470,7 @@ qdio_mark_q(struct qdio_q *q)
        tasklet_schedule(&q->tasklet);
 }
-static inline int
+static int
 qdio_stop_polling(struct qdio_q *q)
 {
 #ifdef QDIO_USE_PROCESSING_STATE
@@ -525,7 +524,7 @@ qdio_stop_polling(struct qdio_q *q)
 * sophisticated locking outside of unmark_q, so that we don't need to
 * disable the interrupts :-) 
 */
-static inline void
+static void
 qdio_unmark_q(struct qdio_q *q)
 {
        unsigned long flags;
@@ -691,7 +690,7 @@ qdio_qebsm_get_inbound_buffer_frontier(struct qdio_q *q)
        return q->first_to_check;
 }
-static inline int
+static int
 qdio_get_outbound_buffer_frontier(struct qdio_q *q)
 {
        struct qdio_irq *irq;
@@ -774,7 +773,7 @@ out:
 }
 /* all buffers are processed */
-static inline int
+static int
 qdio_is_outbound_q_done(struct qdio_q *q)
 {
        int no_used;
@@ -796,7 +795,7 @@ qdio_is_outbound_q_done(struct qdio_q *q)
        return (no_used==0);
 }
-static inline int
+static int
 qdio_has_outbound_q_moved(struct qdio_q *q)
 {
        int i;
@@ -816,7 +815,7 @@ qdio_has_outbound_q_moved(struct qdio_q *q)
        }
 }
-static inline void
+static void
 qdio_kick_outbound_q(struct qdio_q *q)
 {
        int result;
@@ -905,7 +904,7 @@ qdio_kick_outbound_q(struct qdio_q *q)
        }
 }
-static inline void
+static void
 qdio_kick_outbound_handler(struct qdio_q *q)
 {
        int start, end, real_end, count;
@@ -942,7 +941,7 @@ qdio_kick_outbound_handler(struct qdio_q *q)
        q->error_status_flags=0;
 }
-static inline void
+static void
 __qdio_outbound_processing(struct qdio_q *q)
 {
        int siga_attempts;
@@ -1002,7 +1001,7 @@ qdio_outbound_processing(struct qdio_q *q)
 /************************* INBOUND ROUTINES *******************************/
-static inline int
+static int
 qdio_get_inbound_buffer_frontier(struct qdio_q *q)
 {
        struct qdio_irq *irq;
@@ -1133,7 +1132,7 @@ out:
        return q->first_to_check;
 }
-static inline int
+static int
 qdio_has_inbound_q_moved(struct qdio_q *q)
 {
        int i;
@@ -1167,7 +1166,7 @@ qdio_has_inbound_q_moved(struct qdio_q *q)
 }
 /* means, no more buffers to be filled */
-static inline int
+static int
 tiqdio_is_inbound_q_done(struct qdio_q *q)
 {
        int no_used;
@@ -1228,7 +1227,7 @@ tiqdio_is_inbound_q_done(struct qdio_q *q)
        return 0;
 }
-static inline int
+static int
 qdio_is_inbound_q_done(struct qdio_q *q)
 {
        int no_used;
@@ -1296,7 +1295,7 @@ qdio_is_inbound_q_done(struct qdio_q *q)
        }
 }
-static inline void
+static void
 qdio_kick_inbound_handler(struct qdio_q *q)
 {
        int count, start, end, real_end, i;
@@ -1343,7 +1342,7 @@ qdio_kick_inbound_handler(struct qdio_q *q)
        }
 }
-static inline void
+static void
 __tiqdio_inbound_processing(struct qdio_q *q, int spare_ind_was_set)
 {
        struct qdio_irq *irq_ptr;
@@ -1442,7 +1441,7 @@ tiqdio_inbound_processing(struct qdio_q *q)
        __tiqdio_inbound_processing(q, atomic_read(&spare_indicator_usecount));
 }
-static inline void
+static void
 __qdio_inbound_processing(struct qdio_q *q)
 {
        int q_laps=0;
@@ -1493,7 +1492,7 @@ qdio_inbound_processing(struct qdio_q *q)
 /************************* MAIN ROUTINES *******************************/
 #ifdef QDIO_USE_PROCESSING_STATE
-static inline int
+static int
 tiqdio_reset_processing_state(struct qdio_q *q, int q_laps)
 {
        if (!q) {
@@ -1545,7 +1544,7 @@ tiqdio_reset_processing_state(struct qdio_q *q, int q_laps)
 }
 #endif /* QDIO_USE_PROCESSING_STATE */
-static inline void
+static void
 tiqdio_inbound_checks(void)
 {
        struct qdio_q *q;
@@ -1949,7 +1948,7 @@ qdio_set_state(struct qdio_irq *irq_ptr, enum qdio_irq_states state)
        mb();
 }
-static inline void
+static void
 qdio_irq_check_sense(struct subchannel_id schid, struct irb *irb)
 {
        char dbf_text[15];
@@ -1966,7 +1965,7 @@ qdio_irq_check_sense(struct subchannel_id schid, struct irb *irb)
                
 }
-static inline void
+static void
 qdio_handle_pci(struct qdio_irq *irq_ptr)
 {
        int i;
@@ -2002,7 +2001,7 @@ qdio_handle_pci(struct qdio_irq *irq_ptr)
 static void qdio_establish_handle_irq(struct ccw_device*, int, int);
-static inline void
+static void
 qdio_handle_activate_check(struct ccw_device *cdev, unsigned long intparm,
                           int cstat, int dstat)
 {
@@ -2229,7 +2228,7 @@ qdio_synchronize(struct ccw_device *cdev, unsigned int flags,
        return cc;
 }
-static inline void
+static void
 qdio_check_subchannel_qebsm(struct qdio_irq *irq_ptr, unsigned char qdioac,
                            unsigned long token)
 {
@@ -2740,7 +2739,7 @@ qdio_free(struct ccw_device *cdev)
        return 0;
 }
-static inline void
+static void
 qdio_allocate_do_dbf(struct qdio_initialize *init_data)
 {
        char dbf_text[20]; /* if a printf printed out more than 8 chars */
@@ -2773,7 +2772,7 @@ qdio_allocate_do_dbf(struct qdio_initialize *init_data)
        QDIO_DBF_HEX0(0,setup,&init_data->output_sbal_addr_array,sizeof(void*));
 }
-static inline void
+static void
 qdio_allocate_fill_input_desc(struct qdio_irq *irq_ptr, int i, int iqfmt)
 {
        irq_ptr->input_qs[i]->is_iqdio_q = iqfmt;
@@ -2792,7 +2791,7 @@ qdio_allocate_fill_input_desc(struct qdio_irq *irq_ptr, int i, int iqfmt)
        irq_ptr->qdr->qdf0[i].dkey=QDIO_STORAGE_KEY;
 }
-static inline void
+static void
 qdio_allocate_fill_output_desc(struct qdio_irq *irq_ptr, int i,
                               int j, int iqfmt)
 {
@@ -2813,7 +2812,7 @@ qdio_allocate_fill_output_desc(struct qdio_irq *irq_ptr, int i,
 }
-static inline void
+static void
 qdio_initialize_set_siga_flags_input(struct qdio_irq *irq_ptr)
 {
        int i;
@@ -2839,7 +2838,7 @@ qdio_initialize_set_siga_flags_input(struct qdio_irq *irq_ptr)
        }
 }
-static inline void
+static void
 qdio_initialize_set_siga_flags_output(struct qdio_irq *irq_ptr)
 {
        int i;
@@ -2865,7 +2864,7 @@ qdio_initialize_set_siga_flags_output(struct qdio_irq *irq_ptr)
        }
 }
-static inline int
+static int
 qdio_establish_irq_check_for_errors(struct ccw_device *cdev, int cstat,
                                    int dstat)
 {
@@ -3014,7 +3013,7 @@ qdio_allocate(struct qdio_initialize *init_data)
        return 0;
 }
-int qdio_fill_irq(struct qdio_initialize *init_data)
+static int qdio_fill_irq(struct qdio_initialize *init_data)
 {
        int i;
        char dbf_text[15];
@@ -3367,7 +3366,7 @@ qdio_activate(struct ccw_device *cdev, int flags)
 }
 /* buffers filled forwards again to make Rick happy */
-static inline void
+static void
 qdio_do_qdio_fill_input(struct qdio_q *q, unsigned int qidx,
                        unsigned int count, struct qdio_buffer *buffers)
 {
@@ -3386,7 +3385,7 @@ qdio_do_qdio_fill_input(struct qdio_q *q, unsigned int qidx,
        }
 }
-static inline void
+static void
 qdio_do_qdio_fill_output(struct qdio_q *q, unsigned int qidx,
                         unsigned int count, struct qdio_buffer *buffers)
 {
@@ -3407,7 +3406,7 @@ qdio_do_qdio_fill_output(struct qdio_q *q, unsigned int qidx,
        }
 }
-static inline void
+static void
 do_qdio_handle_inbound(struct qdio_q *q, unsigned int callflags,
                       unsigned int qidx, unsigned int count,
                       struct qdio_buffer *buffers)
@@ -3443,7 +3442,7 @@ do_qdio_handle_inbound(struct qdio_q *q, unsigned int callflags,
        qdio_mark_q(q);
 }
-static inline void
+static void
 do_qdio_handle_outbound(struct qdio_q *q, unsigned int callflags,
                        unsigned int qidx, unsigned int count,
                        struct qdio_buffer *buffers)
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index 81b5899f4010..c7d1355237b6 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -465,7 +465,7 @@ static int ap_device_probe(struct device *dev)
 * Flush all requests from the request/pending queue of an AP device.
 * @ap_dev: pointer to the AP device.
 */
-static inline void __ap_flush_queue(struct ap_device *ap_dev)
+static void __ap_flush_queue(struct ap_device *ap_dev)
 {
        struct ap_message *ap_msg, *next;
@@ -587,7 +587,7 @@ static struct bus_attribute *const ap_bus_attrs[] = {
 /**
 * Pick one of the 16 ap domains.
 */
-static inline int ap_select_domain(void)
+static int ap_select_domain(void)
 {
        int queue_depth, device_type, count, max_count, best_domain;
        int rc, i, j;
@@ -825,7 +825,7 @@ static inline void ap_schedule_poll_timer(void)
 *         required, bit 2^1 is set if the poll timer needs to get armed
 * Returns 0 if the device is still present, -ENODEV if not.
 */
-static inline int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
+static int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
 {
        struct ap_queue_status status;
        struct ap_message *ap_msg;
@@ -872,7 +872,7 @@ static inline int ap_poll_read(struct ap_device *ap_dev, unsigned long *flags)
 *         required, bit 2^1 is set if the poll timer needs to get armed
 * Returns 0 if the device is still present, -ENODEV if not.
 */
-static inline int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
+static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
 {
        struct ap_queue_status status;
        struct ap_message *ap_msg;
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index 1edc10a7a6f2..b9e59bc9435a 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -791,7 +791,7 @@ static long trans_xcRB32(struct file *filp, unsigned int cmd,
        return rc;
 }
-long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd,
+static long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd,
                         unsigned long arg)
 {
        if (cmd == ICARSAMODEXPO)
@@ -833,8 +833,8 @@ static struct miscdevice zcrypt_misc_device = {
 */
 static struct proc_dir_entry *zcrypt_entry;
-static inline int sprintcl(unsigned char *outaddr, unsigned char *addr,
+static int sprintcl(unsigned char *outaddr, unsigned char *addr,
-                           unsigned int len)
+                    unsigned int len)
 {
        int hl, i;
@@ -845,8 +845,8 @@ static inline int sprintcl(unsigned char *outaddr, unsigned char *addr,
        return hl;
 }
-static inline int sprintrw(unsigned char *outaddr, unsigned char *addr,
+static int sprintrw(unsigned char *outaddr, unsigned char *addr,
-                           unsigned int len)
+                    unsigned int len)
 {
        int hl, inl, c, cx;
@@ -865,8 +865,8 @@ static inline int sprintrw(unsigned char *outaddr, unsigned char *addr,
        return hl;
 }
-static inline int sprinthx(unsigned char *title, unsigned char *outaddr,
+static int sprinthx(unsigned char *title, unsigned char *outaddr,
-                           unsigned char *addr, unsigned int len)
+                    unsigned char *addr, unsigned int len)
 {
        int hl, inl, r, rx;
@@ -885,8 +885,8 @@ static inline int sprinthx(unsigned char *title, unsigned char *outaddr,
        return hl;
 }
-static inline int sprinthx4(unsigned char *title, unsigned char *outaddr,
+static int sprinthx4(unsigned char *title, unsigned char *outaddr,
-                            unsigned int *array, unsigned int len)
+                     unsigned int *array, unsigned int len)
 {
        int hl, r;
@@ -943,7 +943,7 @@ static int zcrypt_status_read(char *resp_buff, char **start, off_t offset,
        zcrypt_qdepth_mask(workarea);
        len += sprinthx("Waiting work element counts",
                        resp_buff+len, workarea, AP_DEVICES);
-        zcrypt_perdev_reqcnt((unsigned int *) workarea);
+        zcrypt_perdev_reqcnt((int *) workarea);
        len += sprinthx4("Per-device successfully completed request counts",
                         resp_buff+len,(unsigned int *) workarea, AP_DEVICES);
        *eof = 1;
diff --git a/drivers/s390/crypto/zcrypt_pcica.c b/drivers/s390/crypto/zcrypt_pcica.c
index 32e37014345c..818ffe05ac00 100644
--- a/drivers/s390/crypto/zcrypt_pcica.c
+++ b/drivers/s390/crypto/zcrypt_pcica.c
@@ -191,10 +191,10 @@ static int ICACRT_msg_to_type4CRT_msg(struct zcrypt_device *zdev,
 *
 * Returns 0 on success or -EFAULT.
 */
-static inline int convert_type84(struct zcrypt_device *zdev,
+static int convert_type84(struct zcrypt_device *zdev,
-                                 struct ap_message *reply,
+                          struct ap_message *reply,
-                                 char __user *outputdata,
+                          char __user *outputdata,
-                                 unsigned int outputdatalength)
+                          unsigned int outputdatalength)
 {
        struct type84_hdr *t84h = reply->message;
        char *data;
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index b7153c1e15cd..252443b6bd1b 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -709,7 +709,8 @@ out_free:
 *        PCIXCC/CEX2C device to the request distributor
 * @xcRB: pointer to the send_cprb request buffer
 */
-long zcrypt_pcixcc_send_cprb(struct zcrypt_device *zdev, struct ica_xcRB *xcRB)
+static long zcrypt_pcixcc_send_cprb(struct zcrypt_device *zdev,
+                                    struct ica_xcRB *xcRB)
 {
        struct ap_message ap_msg;
        struct response_type resp_type = {
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index 95f4e105cb96..7809a79feec7 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -121,7 +121,7 @@ MODULE_LICENSE("GPL");
 #define DEBUG
 #endif
- char debug_buffer[255];
+static char debug_buffer[255];
 /**
 * Debug Facility Stuff
 */
@@ -223,16 +223,14 @@ static void claw_timer ( struct chbk * p_ch );
 /* Functions */
 static int add_claw_reads(struct net_device *dev,
        struct ccwbk* p_first, struct ccwbk* p_last);
-static void inline ccw_check_return_code (struct ccw_device *cdev,
+static void ccw_check_return_code (struct ccw_device *cdev, int return_code);
-        int return_code);
+static void ccw_check_unit_check (struct chbk * p_ch, unsigned char sense );
-static void inline ccw_check_unit_check (struct chbk * p_ch,
-        unsigned char sense );
 static int find_link(struct net_device *dev, char *host_name, char *ws_name );
 static int claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid);
 static int init_ccw_bk(struct net_device *dev);
 static void probe_error( struct ccwgroup_device *cgdev);
 static struct net_device_stats *claw_stats(struct net_device *dev);
-static int inline pages_to_order_of_mag(int num_of_pages);
+static int pages_to_order_of_mag(int num_of_pages);
 static struct sk_buff *claw_pack_skb(struct claw_privbk *privptr);
 #ifdef DEBUG
 static void dumpit (char *buf, int len);
@@ -1310,7 +1308,7 @@ claw_timer ( struct chbk * p_ch )
 *    of magnitude get_free_pages() has an upper order of 9           *
 *--------------------------------------------------------------------*/
-static int inline
+static int
 pages_to_order_of_mag(int num_of_pages)
 {
        int     order_of_mag=1;         /* assume 2 pages */
@@ -1482,7 +1480,7 @@ add_claw_reads(struct net_device *dev, struct ccwbk* p_first,
 *                                                                   *
 *-------------------------------------------------------------------*/
-static void inline
+static void
 ccw_check_return_code(struct ccw_device *cdev, int return_code)
 {
 #ifdef FUNCTRACE
@@ -1529,7 +1527,7 @@ ccw_check_return_code(struct ccw_device *cdev, int return_code)
 *       ccw_check_unit_check                                         *
 *--------------------------------------------------------------------*/
-static void inline
+static void
 ccw_check_unit_check(struct chbk * p_ch, unsigned char sense )
 {
        struct net_device *dev = p_ch->ndev;
diff --git a/drivers/s390/net/ctcmain.c b/drivers/s390/net/ctcmain.c
index 03cc263fe0da..5a84fbbc6611 100644
--- a/drivers/s390/net/ctcmain.c
+++ b/drivers/s390/net/ctcmain.c
@@ -369,7 +369,7 @@ ctc_dump_skb(struct sk_buff *skb, int offset)
 * @param ch The channel where this skb has been received.
 * @param pskb The received skb.
 */
-static __inline__ void
+static void
 ctc_unpack_skb(struct channel *ch, struct sk_buff *pskb)
 {
        struct net_device *dev = ch->netdev;
@@ -512,7 +512,7 @@ ctc_unpack_skb(struct channel *ch, struct sk_buff *pskb)
 * @param ch          The channel, the error belongs to.
 * @param return_code The error code to inspect.
 */
-static void inline
+static void
 ccw_check_return_code(struct channel *ch, int return_code, char *msg)
 {
        DBF_TEXT(trace, 5, __FUNCTION__);
@@ -547,7 +547,7 @@ ccw_check_return_code(struct channel *ch, int return_code, char *msg)
 * @param ch    The channel, the sense code belongs to.
 * @param sense The sense code to inspect.
 */
-static void inline
+static void
 ccw_unit_check(struct channel *ch, unsigned char sense)
 {
        DBF_TEXT(trace, 5, __FUNCTION__);
@@ -603,7 +603,7 @@ ctc_purge_skb_queue(struct sk_buff_head *q)
        }
 }
-static __inline__ int
+static int
 ctc_checkalloc_buffer(struct channel *ch, int warn)
 {
        DBF_TEXT(trace, 5, __FUNCTION__);
diff --git a/drivers/s390/net/cu3088.c b/drivers/s390/net/cu3088.c
index e965f03a7291..76728ae4b843 100644
--- a/drivers/s390/net/cu3088.c
+++ b/drivers/s390/net/cu3088.c
@@ -57,7 +57,7 @@ static struct ccw_device_id cu3088_ids[] = {
 static struct ccw_driver cu3088_driver;
-struct device *cu3088_root_dev;
+static struct device *cu3088_root_dev;
 static ssize_t
 group_write(struct device_driver *drv, const char *buf, size_t count)
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index e5665b6743a1..b97dd15bdb9a 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -828,7 +828,7 @@ lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 /**
 * Emit buffer of a lan comand.
 */
-void
+static void
 lcs_lancmd_timeout(unsigned long data)
 {
        struct lcs_reply *reply, *list_reply, *r;
@@ -1360,7 +1360,7 @@ lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
        return 0;
 }
-void
+static void
 lcs_schedule_recovery(struct lcs_card *card)
 {
        LCS_DBF_TEXT(2, trace, "startrec");
@@ -1990,7 +1990,7 @@ lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char
 }
-DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
+static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
 static ssize_t
 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index d7d1cc0a5c8e..3346088f47e0 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -2053,7 +2053,7 @@ out_free_ndev:
        return ret;
 }
-DRIVER_ATTR(connection, 0200, NULL, conn_write);
+static DRIVER_ATTR(connection, 0200, NULL, conn_write);
 static ssize_t
 remove_write (struct device_driver *drv, const char *buf, size_t count)
@@ -2112,7 +2112,7 @@ remove_write (struct device_driver *drv, const char *buf, size_t count)
        return -EINVAL;
 }
-DRIVER_ATTR(remove, 0200, NULL, remove_write);
+static DRIVER_ATTR(remove, 0200, NULL, remove_write);
 static void
 netiucv_banner(void)
diff --git a/drivers/s390/net/qeth_eddp.c b/drivers/s390/net/qeth_eddp.c
index 6bb558a9a032..7c735e1fe063 100644
--- a/drivers/s390/net/qeth_eddp.c
+++ b/drivers/s390/net/qeth_eddp.c
@@ -49,7 +49,7 @@ qeth_eddp_check_buffers_for_context(struct qeth_qdio_out_q *queue,
        return buffers_needed;
 }
-static inline void
+static void
 qeth_eddp_free_context(struct qeth_eddp_context *ctx)
 {
        int i;
@@ -91,7 +91,7 @@ qeth_eddp_buf_release_contexts(struct qeth_qdio_out_buffer *buf)
        }
 }
-static inline int
+static int
 qeth_eddp_buf_ref_context(struct qeth_qdio_out_buffer *buf,
                          struct qeth_eddp_context *ctx)
 {
@@ -196,7 +196,7 @@ out:
        return flush_cnt;
 }
-static inline void
+static void
 qeth_eddp_create_segment_hdrs(struct qeth_eddp_context *ctx,
                              struct qeth_eddp_data *eddp, int data_len)
 {
@@ -256,7 +256,7 @@ qeth_eddp_create_segment_hdrs(struct qeth_eddp_context *ctx,
        ctx->offset += eddp->thl;
 }
-static inline void
+static void
 qeth_eddp_copy_data_tcp(char *dst, struct qeth_eddp_data *eddp, int len,
                        __wsum *hcsum)
 {
@@ -302,7 +302,7 @@ qeth_eddp_copy_data_tcp(char *dst, struct qeth_eddp_data *eddp, int len,
        }
 }
-static inline void
+static void
 qeth_eddp_create_segment_data_tcp(struct qeth_eddp_context *ctx,
                                  struct qeth_eddp_data *eddp, int data_len,
                                  __wsum hcsum)
@@ -349,7 +349,7 @@ qeth_eddp_create_segment_data_tcp(struct qeth_eddp_context *ctx,
        ((struct tcphdr *)eddp->th_in_ctx)->check = csum_fold(hcsum);
 }
-static inline __wsum
+static __wsum
 qeth_eddp_check_tcp4_hdr(struct qeth_eddp_data *eddp, int data_len)
 {
        __wsum phcsum; /* pseudo header checksum */
@@ -363,7 +363,7 @@ qeth_eddp_check_tcp4_hdr(struct qeth_eddp_data *eddp, int data_len)
        return csum_partial((u8 *)&eddp->th, eddp->thl, phcsum);
 }
-static inline __wsum
+static __wsum
 qeth_eddp_check_tcp6_hdr(struct qeth_eddp_data *eddp, int data_len)
 {
        __be32 proto;
@@ -381,7 +381,7 @@ qeth_eddp_check_tcp6_hdr(struct qeth_eddp_data *eddp, int data_len)
        return phcsum;
 }
-static inline struct qeth_eddp_data *
+static struct qeth_eddp_data *
 qeth_eddp_create_eddp_data(struct qeth_hdr *qh, u8 *nh, u8 nhl, u8 *th, u8 thl)
 {
        struct qeth_eddp_data *eddp;
@@ -399,7 +399,7 @@ qeth_eddp_create_eddp_data(struct qeth_hdr *qh, u8 *nh, u8 nhl, u8 *th, u8 thl)
        return eddp;
 }
-static inline void
+static void
 __qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
                             struct qeth_eddp_data *eddp)
 {
@@ -464,7 +464,7 @@ __qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
        }
 }
-static inline int
+static int
 qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
                           struct sk_buff *skb, struct qeth_hdr *qhdr)
 {
@@ -505,7 +505,7 @@ qeth_eddp_fill_context_tcp(struct qeth_eddp_context *ctx,
        return 0;
 }
-static inline void
+static void
 qeth_eddp_calc_num_pages(struct qeth_eddp_context *ctx, struct sk_buff *skb,
                         int hdr_len)
 {
@@ -529,7 +529,7 @@ qeth_eddp_calc_num_pages(struct qeth_eddp_context *ctx, struct sk_buff *skb,
                            (skb_shinfo(skb)->gso_segs + 1);
 }
-static inline struct qeth_eddp_context *
+static struct qeth_eddp_context *
 qeth_eddp_create_context_generic(struct qeth_card *card, struct sk_buff *skb,
                                 int hdr_len)
 {
@@ -581,7 +581,7 @@ qeth_eddp_create_context_generic(struct qeth_card *card, struct sk_buff *skb,
        return ctx;
 }
-static inline struct qeth_eddp_context *
+static struct qeth_eddp_context *
 qeth_eddp_create_context_tcp(struct qeth_card *card, struct sk_buff *skb,
                             struct qeth_hdr *qhdr)
 {
@@ -625,5 +625,3 @@ qeth_eddp_create_context(struct qeth_card *card, struct sk_buff *skb,
        }
        return NULL;
 }
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index d2efa5ff125d..2257e45594b3 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -651,7 +651,7 @@ __qeth_ref_ip_on_card(struct qeth_card *card, struct qeth_ipaddr *todo,
                return 0;
 }
-static inline int
+static int
 __qeth_address_exists_in_list(struct list_head *list, struct qeth_ipaddr *addr,
                              int same_type)
 {
@@ -795,7 +795,7 @@ qeth_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
        return rc;
 }
-static inline void
+static void
 __qeth_delete_all_mc(struct qeth_card *card, unsigned long *flags)
 {
        struct qeth_ipaddr *addr, *tmp;
@@ -882,7 +882,7 @@ static void qeth_layer2_add_multicast(struct qeth_card *);
 static void qeth_add_multicast_ipv6(struct qeth_card *);
 #endif
-static inline int
+static int
 qeth_set_thread_start_bit(struct qeth_card *card, unsigned long thread)
 {
        unsigned long flags;
@@ -920,7 +920,7 @@ qeth_clear_thread_running_bit(struct qeth_card *card, unsigned long thread)
        wake_up(&card->wait_q);
 }
-static inline int
+static int
 __qeth_do_run_thread(struct qeth_card *card, unsigned long thread)
 {
        unsigned long flags;
@@ -1764,9 +1764,9 @@ out:
        qeth_release_buffer(channel,iob);
 }
-static inline void
+static void
 qeth_prepare_control_data(struct qeth_card *card, int len,
-struct qeth_cmd_buffer *iob)
+                          struct qeth_cmd_buffer *iob)
 {
        qeth_setup_ccw(&card->write,iob->data,len);
        iob->callback = qeth_release_buffer;
@@ -2160,7 +2160,7 @@ qeth_check_qdio_errors(struct qdio_buffer *buf, unsigned int qdio_error,
        return 0;
 }
-static inline struct sk_buff *
+static struct sk_buff *
 qeth_get_skb(unsigned int length, struct qeth_hdr *hdr)
 {
        struct sk_buff* skb;
@@ -2179,7 +2179,7 @@ qeth_get_skb(unsigned int length, struct qeth_hdr *hdr)
        return skb;
 }
-static inline struct sk_buff *
+static struct sk_buff *
 qeth_get_next_skb(struct qeth_card *card, struct qdio_buffer *buffer,
                  struct qdio_buffer_element **__element, int *__offset,
                  struct qeth_hdr **hdr)
@@ -2264,7 +2264,7 @@ no_mem:
        return NULL;
 }
-static inline __be16
+static __be16
 qeth_type_trans(struct sk_buff *skb, struct net_device *dev)
 {
        struct qeth_card *card;
@@ -2297,7 +2297,7 @@ qeth_type_trans(struct sk_buff *skb, struct net_device *dev)
        return htons(ETH_P_802_2);
 }
-static inline void
+static void
 qeth_rebuild_skb_fake_ll_tr(struct qeth_card *card, struct sk_buff *skb,
                         struct qeth_hdr *hdr)
 {
@@ -2351,7 +2351,7 @@ qeth_rebuild_skb_fake_ll_tr(struct qeth_card *card, struct sk_buff *skb,
        fake_llc->ethertype = ETH_P_IP;
 }
-static inline void
+static void
 qeth_rebuild_skb_fake_ll_eth(struct qeth_card *card, struct sk_buff *skb,
                         struct qeth_hdr *hdr)
 {
@@ -2420,7 +2420,7 @@ qeth_layer2_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
        *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
 }
-static inline __u16
+static __u16
 qeth_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
                 struct qeth_hdr *hdr)
 {
@@ -2476,7 +2476,7 @@ qeth_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
        return vlan_id;
 }
-static inline void
+static void
 qeth_process_inbound_buffer(struct qeth_card *card,
                            struct qeth_qdio_buffer *buf, int index)
 {
@@ -2528,7 +2528,7 @@ qeth_process_inbound_buffer(struct qeth_card *card,
        }
 }
-static inline struct qeth_buffer_pool_entry *
+static struct qeth_buffer_pool_entry *
 qeth_get_buffer_pool_entry(struct qeth_card *card)
 {
        struct qeth_buffer_pool_entry *entry;
@@ -2543,7 +2543,7 @@ qeth_get_buffer_pool_entry(struct qeth_card *card)
        return NULL;
 }
-static inline void
+static void
 qeth_init_input_buffer(struct qeth_card *card, struct qeth_qdio_buffer *buf)
 {
        struct qeth_buffer_pool_entry *pool_entry;
@@ -2570,7 +2570,7 @@ qeth_init_input_buffer(struct qeth_card *card, struct qeth_qdio_buffer *buf)
        buf->state = QETH_QDIO_BUF_EMPTY;
 }
-static inline void
+static void
 qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
                         struct qeth_qdio_out_buffer *buf)
 {
@@ -2595,7 +2595,7 @@ qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
        atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);
 }
-static inline void
+static void
 qeth_queue_input_buffer(struct qeth_card *card, int index)
 {
        struct qeth_qdio_q *queue = card->qdio.in_q;
@@ -2699,7 +2699,7 @@ qeth_qdio_input_handler(struct ccw_device * ccwdev, unsigned int status,
                        card->perf_stats.inbound_start_time;
 }
-static inline int
+static int
 qeth_handle_send_error(struct qeth_card *card,
                       struct qeth_qdio_out_buffer *buffer,
                       unsigned int qdio_err, unsigned int siga_err)
@@ -2821,7 +2821,7 @@ qeth_flush_buffers(struct qeth_qdio_out_q *queue, int under_int,
 * Switched to packing state if the number of used buffers on a queue
 * reaches a certain limit.
 */
-static inline void
+static void
 qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q *queue)
 {
        if (!queue->do_pack) {
@@ -2842,7 +2842,7 @@ qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q *queue)
 * In that case 1 is returned to inform the caller. If no buffer
 * has to be flushed, zero is returned.
 */
-static inline int
+static int
 qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q *queue)
 {
        struct qeth_qdio_out_buffer *buffer;
@@ -2877,7 +2877,7 @@ qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q *queue)
 * Checks if there is a packing buffer and prepares it to be flushed.
 * In that case returns 1, otherwise zero.
 */
-static inline int
+static int
 qeth_flush_buffers_on_no_pci(struct qeth_qdio_out_q *queue)
 {
        struct qeth_qdio_out_buffer *buffer;
@@ -2894,7 +2894,7 @@ qeth_flush_buffers_on_no_pci(struct qeth_qdio_out_q *queue)
        return 0;
 }
-static inline void
+static void
 qeth_check_outbound_queue(struct qeth_qdio_out_q *queue)
 {
        int index;
@@ -3594,7 +3594,7 @@ qeth_fake_header(struct sk_buff *skb, struct net_device *dev,
        }
 }
-static inline int
+static int
 qeth_send_packet(struct qeth_card *, struct sk_buff *);
 static int
@@ -3759,7 +3759,7 @@ qeth_stop(struct net_device *dev)
        return 0;
 }
-static inline int
+static int
 qeth_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
 {
        int cast_type = RTN_UNSPEC;
@@ -3806,7 +3806,7 @@ qeth_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
        return cast_type;
 }
-static inline int
+static int
 qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb,
                        int ipv, int cast_type)
 {
@@ -3853,7 +3853,7 @@ qeth_get_ip_version(struct sk_buff *skb)
        }
 }
-static inline struct qeth_hdr *
+static struct qeth_hdr *
 __qeth_prepare_skb(struct qeth_card *card, struct sk_buff *skb, int ipv)
 {
 #ifdef CONFIG_QETH_VLAN
@@ -3882,14 +3882,14 @@ __qeth_prepare_skb(struct qeth_card *card, struct sk_buff *skb, int ipv)
                qeth_push_skb(card, skb, sizeof(struct qeth_hdr)));
 }
-static inline void
+static void
 __qeth_free_new_skb(struct sk_buff *orig_skb, struct sk_buff *new_skb)
 {
        if (orig_skb != new_skb)
                dev_kfree_skb_any(new_skb);
 }
-static inline struct sk_buff *
+static struct sk_buff *
 qeth_prepare_skb(struct qeth_card *card, struct sk_buff *skb,
                 struct qeth_hdr **hdr, int ipv)
 {
@@ -3940,7 +3940,7 @@ qeth_get_qeth_hdr_flags6(int cast_type)
        return ct | QETH_CAST_UNICAST;
 }
-static inline void
+static void
 qeth_layer2_get_packet_type(struct qeth_card *card, struct qeth_hdr *hdr,
                            struct sk_buff *skb)
 {
@@ -3977,7 +3977,7 @@ qeth_layer2_get_packet_type(struct qeth_card *card, struct qeth_hdr *hdr,
        }
 }
-static inline void
+static void
 qeth_layer2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
                        struct sk_buff *skb, int cast_type)
 {
@@ -4068,7 +4068,7 @@ qeth_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
        }
 }
-static inline void
+static void
 __qeth_fill_buffer(struct sk_buff *skb, struct qdio_buffer *buffer,
                   int is_tso, int *next_element_to_fill)
 {
@@ -4112,7 +4112,7 @@ __qeth_fill_buffer(struct sk_buff *skb, struct qdio_buffer *buffer,
        *next_element_to_fill = element;
 }
-static inline int
+static int
 qeth_fill_buffer(struct qeth_qdio_out_q *queue,
                 struct qeth_qdio_out_buffer *buf,
                 struct sk_buff *skb)
@@ -4171,7 +4171,7 @@ qeth_fill_buffer(struct qeth_qdio_out_q *queue,
        return flush_cnt;
 }
-static inline int
+static int
 qeth_do_send_packet_fast(struct qeth_card *card, struct qeth_qdio_out_q *queue,
                         struct sk_buff *skb, struct qeth_hdr *hdr,
                         int elements_needed,
@@ -4222,7 +4222,7 @@ out:
        return -EBUSY;
 }
-static inline int
+static int
 qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue,
                    struct sk_buff *skb, struct qeth_hdr *hdr,
                    int elements_needed, struct qeth_eddp_context *ctx)
@@ -4328,7 +4328,7 @@ out:
        return rc;
 }
-static inline int
+static int
 qeth_get_elements_no(struct qeth_card *card, void *hdr,
                     struct sk_buff *skb, int elems)
 {
@@ -4349,7 +4349,7 @@ qeth_get_elements_no(struct qeth_card *card, void *hdr,
 }
-static inline int
+static int
 qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
 {
        int ipv = 0;
@@ -4536,7 +4536,7 @@ qeth_mdio_read(struct net_device *dev, int phy_id, int regnum)
 }
-static inline const char *
+static const char *
 qeth_arp_get_error_cause(int *rc)
 {
        switch (*rc) {
@@ -4597,7 +4597,7 @@ qeth_arp_set_no_entries(struct qeth_card *card, int no_entries)
        return rc;
 }
-static inline void
+static void
 qeth_copy_arp_entries_stripped(struct qeth_arp_query_info *qinfo,
                               struct qeth_arp_query_data *qdata,
                               int entry_size, int uentry_size)
@@ -5214,7 +5214,7 @@ qeth_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
        spin_unlock_irqrestore(&card->vlanlock, flags);
 }
-static inline void
+static void
 qeth_free_vlan_buffer(struct qeth_card *card, struct qeth_qdio_out_buffer *buf,
                      unsigned short vid)
 {
@@ -5625,7 +5625,7 @@ qeth_delete_mc_addresses(struct qeth_card *card)
        spin_unlock_irqrestore(&card->ip_lock, flags);
 }
-static inline void
+static void
 qeth_add_mc(struct qeth_card *card, struct in_device *in4_dev)
 {
        struct qeth_ipaddr *ipm;
@@ -5711,7 +5711,7 @@ qeth_layer2_add_multicast(struct qeth_card *card)
 }
 #ifdef CONFIG_QETH_IPV6
-static inline void
+static void
 qeth_add_mc6(struct qeth_card *card, struct inet6_dev *in6_dev)
 {
        struct qeth_ipaddr *ipm;
@@ -6022,7 +6022,7 @@ qeth_send_setdelmc(struct qeth_card *card, struct qeth_ipaddr *addr, int ipacmd)
        return rc;
 }
-static inline void
+static void
 qeth_fill_netmask(u8 *netmask, unsigned int len)
 {
        int i,j;
@@ -6626,7 +6626,7 @@ qeth_send_setadp_mode(struct qeth_card *card, __u32 command, __u32 mode)
        return rc;
 }
-static inline int
+static int
 qeth_setadapter_hstr(struct qeth_card *card)
 {
        int rc;
@@ -6889,7 +6889,7 @@ qeth_send_simple_setassparms(struct qeth_card *card,
        return rc;
 }
-static inline int
+static int
 qeth_start_ipa_arp_processing(struct qeth_card *card)
 {
        int rc;
@@ -7529,7 +7529,7 @@ qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads,
        wake_up(&card->wait_q);
 }
-static inline int
+static int
 qeth_threads_running(struct qeth_card *card, unsigned long threads)
 {
        unsigned long flags;
@@ -8118,7 +8118,7 @@ qeth_del_ipato_entry(struct qeth_card *card, enum qeth_prot_versions proto,
        spin_unlock_irqrestore(&card->ip_lock, flags);
 }
-static inline void
+static void
 qeth_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
 {
        int i, j;
diff --git a/drivers/s390/net/qeth_sys.c b/drivers/s390/net/qeth_sys.c
index 5836737ac58f..d518419cd0c6 100644
--- a/drivers/s390/net/qeth_sys.c
+++ b/drivers/s390/net/qeth_sys.c
@@ -328,7 +328,7 @@ qeth_dev_bufcnt_store(struct device *dev, struct device_attribute *attr, const c
 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
                qeth_dev_bufcnt_store);
-static inline ssize_t
+static ssize_t
 qeth_dev_route_show(struct qeth_card *card, struct qeth_routing_info *route,
                    char *buf)
 {
@@ -368,7 +368,7 @@ qeth_dev_route4_show(struct device *dev, struct device_attribute *attr, char *bu
        return qeth_dev_route_show(card, &card->options.route4, buf);
 }
-static inline ssize_t
+static ssize_t
 qeth_dev_route_store(struct qeth_card *card, struct qeth_routing_info *route,
                enum qeth_prot_versions prot, const char *buf, size_t count)
 {
@@ -998,7 +998,7 @@ struct device_attribute dev_attr_##_id = {				     \
        .store  = _store,                                                    \
 };
-int
+static int
 qeth_check_layer2(struct qeth_card *card)
 {
        if (card->options.layer2)
@@ -1100,7 +1100,7 @@ static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
                        qeth_dev_ipato_invert4_show,
                        qeth_dev_ipato_invert4_store);
-static inline ssize_t
+static ssize_t
 qeth_dev_ipato_add_show(char *buf, struct qeth_card *card,
                        enum qeth_prot_versions proto)
 {
@@ -1146,7 +1146,7 @@ qeth_dev_ipato_add4_show(struct device *dev, struct device_attribute *attr, char
        return qeth_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
 }
-static inline int
+static int
 qeth_parse_ipatoe(const char* buf, enum qeth_prot_versions proto,
                  u8 *addr, int *mask_bits)
 {
@@ -1178,7 +1178,7 @@ qeth_parse_ipatoe(const char* buf, enum qeth_prot_versions proto,
        return 0;
 }
-static inline ssize_t
+static ssize_t
 qeth_dev_ipato_add_store(const char *buf, size_t count,
                         struct qeth_card *card, enum qeth_prot_versions proto)
 {
@@ -1223,7 +1223,7 @@ static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
                        qeth_dev_ipato_add4_show,
                        qeth_dev_ipato_add4_store);
-static inline ssize_t
+static ssize_t
 qeth_dev_ipato_del_store(const char *buf, size_t count,
                         struct qeth_card *card, enum qeth_prot_versions proto)
 {
@@ -1361,7 +1361,7 @@ static struct attribute_group qeth_device_ipato_group = {
        .attrs = (struct attribute **)qeth_ipato_device_attrs,
 };
-static inline ssize_t
+static ssize_t
 qeth_dev_vipa_add_show(char *buf, struct qeth_card *card,
                        enum qeth_prot_versions proto)
 {
@@ -1407,7 +1407,7 @@ qeth_dev_vipa_add4_show(struct device *dev, struct device_attribute *attr, char
        return qeth_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
 }
-static inline int
+static int
 qeth_parse_vipae(const char* buf, enum qeth_prot_versions proto,
                 u8 *addr)
 {
@@ -1418,7 +1418,7 @@ qeth_parse_vipae(const char* buf, enum qeth_prot_versions proto,
        return 0;
 }
-static inline ssize_t
+static ssize_t
 qeth_dev_vipa_add_store(const char *buf, size_t count,
                         struct qeth_card *card, enum qeth_prot_versions proto)
 {
@@ -1451,7 +1451,7 @@ static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
                        qeth_dev_vipa_add4_show,
                        qeth_dev_vipa_add4_store);
-static inline ssize_t
+static ssize_t
 qeth_dev_vipa_del_store(const char *buf, size_t count,
                         struct qeth_card *card, enum qeth_prot_versions proto)
 {
@@ -1542,7 +1542,7 @@ static struct attribute_group qeth_device_vipa_group = {
        .attrs = (struct attribute **)qeth_vipa_device_attrs,
 };
-static inline ssize_t
+static ssize_t
 qeth_dev_rxip_add_show(char *buf, struct qeth_card *card,
                       enum qeth_prot_versions proto)
 {
@@ -1588,7 +1588,7 @@ qeth_dev_rxip_add4_show(struct device *dev, struct device_attribute *attr, char
        return qeth_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
 }
-static inline int
+static int
 qeth_parse_rxipe(const char* buf, enum qeth_prot_versions proto,
                 u8 *addr)
 {
@@ -1599,7 +1599,7 @@ qeth_parse_rxipe(const char* buf, enum qeth_prot_versions proto,
        return 0;
 }
-static inline ssize_t
+static ssize_t
 qeth_dev_rxip_add_store(const char *buf, size_t count,
                        struct qeth_card *card, enum qeth_prot_versions proto)
 {
@@ -1632,7 +1632,7 @@ static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
                        qeth_dev_rxip_add4_show,
                        qeth_dev_rxip_add4_store);
-static inline ssize_t
+static ssize_t
 qeth_dev_rxip_del_store(const char *buf, size_t count,
                        struct qeth_card *card, enum qeth_prot_versions proto)
 {
diff --git a/drivers/s390/s390mach.c b/drivers/s390/s390mach.c
index e088b5e28711..806bb1a921eb 100644
--- a/drivers/s390/s390mach.c
+++ b/drivers/s390/s390mach.c
@@ -13,22 +13,18 @@
 #include <linux/errno.h>
 #include <linux/workqueue.h>
 #include <linux/time.h>
+#include <linux/device.h>
 #include <linux/kthread.h>
+#include <asm/etr.h>
 #include <asm/lowcore.h>
+#include <asm/cio.h>
+#include "cio/cio.h"
+#include "cio/chsc.h"
+#include "cio/css.h"
 #include "s390mach.h"
 static struct semaphore m_sem;
-extern int css_process_crw(int, int);
-extern int chsc_process_crw(void);
-extern int chp_process_crw(int, int);
-extern void css_reiterate_subchannels(void);
-extern struct workqueue_struct *slow_path_wq;
-extern struct work_struct slow_path_work;
 static NORET_TYPE void
 s390_handle_damage(char *msg)
 {
@@ -470,6 +466,19 @@ s390_do_machine_check(struct pt_regs *regs)
                        s390_handle_damage("unable to revalidate registers.");
        }
+        if (mci->cd) {
+                /* Timing facility damage */
+                s390_handle_damage("TOD clock damaged");
+        }
+        if (mci->ed && mci->ec) {
+                /* External damage */
+                if (S390_lowcore.external_damage_code & (1U << ED_ETR_SYNC))
+                        etr_sync_check();
+                if (S390_lowcore.external_damage_code & (1U << ED_ETR_SWITCH))
+                        etr_switch_to_local();
+        }
        if (mci->se)
                /* Storage error uncorrected */
                s390_handle_damage("received storage error uncorrected "
@@ -508,7 +517,7 @@ static int
 machine_check_init(void)
 {
        init_MUTEX_LOCKED(&m_sem);
-        ctl_clear_bit(14, 25);  /* disable external damage MCH */
+        ctl_set_bit(14, 25);    /* enable external damage MCH */
        ctl_set_bit(14, 27);    /* enable system recovery MCH */
 #ifdef CONFIG_MACHCHK_WARNING
        ctl_set_bit(14, 24);    /* enable warning MCH */
@@ -529,7 +538,11 @@ arch_initcall(machine_check_init);
 static int __init
 machine_check_crw_init (void)
 {
-        kthread_run(s390_collect_crw_info, &m_sem, "kmcheck");
+        struct task_struct *task;
+        task = kthread_run(s390_collect_crw_info, &m_sem, "kmcheck");
+        if (IS_ERR(task))
+                return PTR_ERR(task);
        ctl_set_bit(14, 28);    /* enable channel report MCH */
        return 0;
 }
diff --git a/drivers/s390/s390mach.h b/drivers/s390/s390mach.h
index 7abb42a09ae2..d3ca4281a494 100644
--- a/drivers/s390/s390mach.h
+++ b/drivers/s390/s390mach.h
@@ -102,4 +102,7 @@ static inline int stcrw(struct crw *pcrw )
        return ccode;
 }
+#define ED_ETR_SYNC     12      /* External damage ETR sync check */
+#define ED_ETR_SWITCH   13      /* External damage ETR switch to local */
 #endif /* __s390mach */
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 85093b71f9fa..39a885266790 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -47,13 +47,12 @@ static int __init  zfcp_module_init(void);
 static void zfcp_ns_gid_pn_handler(unsigned long);
 /* miscellaneous */
-static inline int zfcp_sg_list_alloc(struct zfcp_sg_list *, size_t);
+static int zfcp_sg_list_alloc(struct zfcp_sg_list *, size_t);
-static inline void zfcp_sg_list_free(struct zfcp_sg_list *);
+static void zfcp_sg_list_free(struct zfcp_sg_list *);
-static inline int zfcp_sg_list_copy_from_user(struct zfcp_sg_list *,
+static int zfcp_sg_list_copy_from_user(struct zfcp_sg_list *,
-                                              void __user *, size_t);
+                                       void __user *, size_t);
-static inline int zfcp_sg_list_copy_to_user(void __user *,
+static int zfcp_sg_list_copy_to_user(void __user *,
-                                            struct zfcp_sg_list *, size_t);
+                                     struct zfcp_sg_list *, size_t);
 static long zfcp_cfdc_dev_ioctl(struct file *, unsigned int, unsigned long);
 #define ZFCP_CFDC_IOC_MAGIC                     0xDD
@@ -605,7 +604,7 @@ zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
 * elements of the scatter-gather list. The maximum size of a single element
 * in the scatter-gather list is PAGE_SIZE.
 */
-static inline int
+static int
 zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size)
 {
        struct scatterlist *sg;
@@ -652,7 +651,7 @@ zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size)
 * Memory for each element in the scatter-gather list is freed.
 * Finally sg_list->sg is freed itself and sg_list->count is reset.
 */
-static inline void
+static void
 zfcp_sg_list_free(struct zfcp_sg_list *sg_list)
 {
        struct scatterlist *sg;
@@ -697,7 +696,7 @@ zfcp_sg_size(struct scatterlist *sg, unsigned int sg_count)
 * @size: number of bytes to be copied
 * Return: 0 on success, -EFAULT if copy_from_user fails.
 */
-static inline int
+static int
 zfcp_sg_list_copy_from_user(struct zfcp_sg_list *sg_list,
                            void __user *user_buffer,
                            size_t size)
@@ -735,7 +734,7 @@ zfcp_sg_list_copy_from_user(struct zfcp_sg_list *sg_list,
 * @size: number of bytes to be copied
 * Return: 0 on success, -EFAULT if copy_to_user fails
 */
-static inline int
+static int
 zfcp_sg_list_copy_to_user(void __user  *user_buffer,
                          struct zfcp_sg_list *sg_list,
                          size_t size)
@@ -1799,7 +1798,7 @@ static const struct zfcp_rc_entry zfcp_p_rjt_rc[] = {
 * @code: reason code
 * @rc_table: table of reason codes and descriptions
 */
-static inline const char *
+static const char *
 zfcp_rc_description(u8 code, const struct zfcp_rc_entry *rc_table)
 {
        const char *descr = "unknown reason code";
@@ -1847,7 +1846,7 @@ zfcp_check_ct_response(struct ct_hdr *rjt)
 * @rjt_par: reject parameter acc. to FC-PH/FC-FS
 * @rc_table: table of reason codes and descriptions
 */
-static inline void
+static void
 zfcp_print_els_rjt(struct zfcp_ls_rjt_par *rjt_par,
                   const struct zfcp_rc_entry *rc_table)
 {
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 0aa3b1ac76af..d8191d115c14 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -31,7 +31,7 @@ MODULE_PARM_DESC(dbfsize,
 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_OTHER
-static inline int
+static int
 zfcp_dbf_stck(char *out_buf, const char *label, unsigned long long stck)
 {
        unsigned long long sec;
@@ -106,7 +106,7 @@ zfcp_dbf_view_dump(char *out_buf, const char *label,
        return len;
 }
-static inline int
+static int
 zfcp_dbf_view_header(debug_info_t * id, struct debug_view *view, int area,
                     debug_entry_t * entry, char *out_buf)
 {
@@ -130,7 +130,7 @@ zfcp_dbf_view_header(debug_info_t * id, struct debug_view *view, int area,
        return len;
 }
-inline void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req)
+void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_adapter *adapter = fsf_req->adapter;
        struct fsf_qtcb *qtcb = fsf_req->qtcb;
@@ -241,7 +241,7 @@ inline void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *fsf_req)
        spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
 }
-inline void
+void
 zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter,
                             struct fsf_status_read_buffer *status_buffer)
 {
@@ -295,7 +295,7 @@ zfcp_hba_dbf_event_fsf_unsol(const char *tag, struct zfcp_adapter *adapter,
        spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
 }
-inline void
+void
 zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter, unsigned int status,
                        unsigned int qdio_error, unsigned int siga_error,
                        int sbal_index, int sbal_count)
@@ -316,7 +316,7 @@ zfcp_hba_dbf_event_qdio(struct zfcp_adapter *adapter, unsigned int status,
        spin_unlock_irqrestore(&adapter->hba_dbf_lock, flags);
 }
-static inline int
+static int
 zfcp_hba_dbf_view_response(char *out_buf,
                           struct zfcp_hba_dbf_record_response *rec)
 {
@@ -403,7 +403,7 @@ zfcp_hba_dbf_view_response(char *out_buf,
        return len;
 }
-static inline int
+static int
 zfcp_hba_dbf_view_status(char *out_buf, struct zfcp_hba_dbf_record_status *rec)
 {
        int len = 0;
@@ -424,7 +424,7 @@ zfcp_hba_dbf_view_status(char *out_buf, struct zfcp_hba_dbf_record_status *rec)
        return len;
 }
-static inline int
+static int
 zfcp_hba_dbf_view_qdio(char *out_buf, struct zfcp_hba_dbf_record_qdio *rec)
 {
        int len = 0;
@@ -469,7 +469,7 @@ zfcp_hba_dbf_view_format(debug_info_t * id, struct debug_view *view,
        return len;
 }
-struct debug_view zfcp_hba_dbf_view = {
+static struct debug_view zfcp_hba_dbf_view = {
        "structured",
        NULL,
        &zfcp_dbf_view_header,
@@ -478,7 +478,7 @@ struct debug_view zfcp_hba_dbf_view = {
        NULL
 };
-inline void
+void
 _zfcp_san_dbf_event_common_ct(const char *tag, struct zfcp_fsf_req *fsf_req,
                              u32 s_id, u32 d_id, void *buffer, int buflen)
 {
@@ -519,7 +519,7 @@ _zfcp_san_dbf_event_common_ct(const char *tag, struct zfcp_fsf_req *fsf_req,
        spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
 }
-inline void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
+void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
        struct zfcp_port *port = ct->port;
@@ -531,7 +531,7 @@ inline void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)
                                      ct->req->length);
 }
-inline void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
+void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
        struct zfcp_port *port = ct->port;
@@ -543,7 +543,7 @@ inline void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)
                                      ct->resp->length);
 }
-static inline void
+static void
 _zfcp_san_dbf_event_common_els(const char *tag, int level,
                               struct zfcp_fsf_req *fsf_req, u32 s_id,
                               u32 d_id, u8 ls_code, void *buffer, int buflen)
@@ -585,7 +585,7 @@ _zfcp_san_dbf_event_common_els(const char *tag, int level,
        spin_unlock_irqrestore(&adapter->san_dbf_lock, flags);
 }
-inline void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req)
+void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
@@ -597,7 +597,7 @@ inline void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *fsf_req)
                                       els->req->length);
 }
-inline void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req)
+void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
@@ -608,7 +608,7 @@ inline void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *fsf_req)
                                       els->resp->length);
 }
-inline void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req)
+void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *fsf_req)
 {
        struct zfcp_adapter *adapter = fsf_req->adapter;
        struct fsf_status_read_buffer *status_buffer =
@@ -693,7 +693,7 @@ zfcp_san_dbf_view_format(debug_info_t * id, struct debug_view *view,
        return len;
 }
-struct debug_view zfcp_san_dbf_view = {
+static struct debug_view zfcp_san_dbf_view = {
        "structured",
        NULL,
        &zfcp_dbf_view_header,
@@ -702,7 +702,7 @@ struct debug_view zfcp_san_dbf_view = {
        NULL
 };
-static inline void
+static void
 _zfcp_scsi_dbf_event_common(const char *tag, const char *tag2, int level,
                            struct zfcp_adapter *adapter,
                            struct scsi_cmnd *scsi_cmnd,
@@ -786,7 +786,7 @@ _zfcp_scsi_dbf_event_common(const char *tag, const char *tag2, int level,
        spin_unlock_irqrestore(&adapter->scsi_dbf_lock, flags);
 }
-inline void
+void
 zfcp_scsi_dbf_event_result(const char *tag, int level,
                           struct zfcp_adapter *adapter,
                           struct scsi_cmnd *scsi_cmnd,
@@ -796,7 +796,7 @@ zfcp_scsi_dbf_event_result(const char *tag, int level,
                        adapter, scsi_cmnd, fsf_req, 0);
 }
-inline void
+void
 zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter,
                          struct scsi_cmnd *scsi_cmnd,
                          struct zfcp_fsf_req *new_fsf_req,
@@ -806,7 +806,7 @@ zfcp_scsi_dbf_event_abort(const char *tag, struct zfcp_adapter *adapter,
                        adapter, scsi_cmnd, new_fsf_req, old_req_id);
 }
-inline void
+void
 zfcp_scsi_dbf_event_devreset(const char *tag, u8 flag, struct zfcp_unit *unit,
                             struct scsi_cmnd *scsi_cmnd)
 {
@@ -884,7 +884,7 @@ zfcp_scsi_dbf_view_format(debug_info_t * id, struct debug_view *view,
        return len;
 }
-struct debug_view zfcp_scsi_dbf_view = {
+static struct debug_view zfcp_scsi_dbf_view = {
        "structured",
        NULL,
        &zfcp_dbf_view_header,
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index c88babce9bca..88642dec080c 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -200,7 +200,7 @@ void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, unsigned long timeout)
 * returns:     0       - initiated action successfully
 *              <0      - failed to initiate action
 */
-int
+static int
 zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask)
 {
        int retval;
@@ -295,7 +295,7 @@ zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask)
 * zfcp_erp_adisc - send ADISC ELS command
 * @port: port structure
 */
-int
+static int
 zfcp_erp_adisc(struct zfcp_port *port)
 {
        struct zfcp_adapter *adapter = port->adapter;
@@ -380,7 +380,7 @@ zfcp_erp_adisc(struct zfcp_port *port)
 *
 * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered.
 */
-void
+static void
 zfcp_erp_adisc_handler(unsigned long data)
 {
        struct zfcp_send_els *send_els;
@@ -3141,7 +3141,6 @@ zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
                break;
        case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
                if (result != ZFCP_ERP_SUCCEEDED) {
-                        struct zfcp_port *port;
                        list_for_each_entry(port, &adapter->port_list_head, list)
                                if (port->rport &&
                                    !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index b8794d77285d..cda0cc095ad1 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -119,8 +119,8 @@ extern int  zfcp_adapter_scsi_register(struct zfcp_adapter *);
 extern void zfcp_adapter_scsi_unregister(struct zfcp_adapter *);
 extern void zfcp_set_fcp_dl(struct fcp_cmnd_iu *, fcp_dl_t);
 extern char *zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu *);
-extern void set_host_byte(u32 *, char);
+extern void set_host_byte(int *, char);
-extern void set_driver_byte(u32 *, char);
+extern void set_driver_byte(int *, char);
 extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);
 extern fcp_dl_t zfcp_get_fcp_dl(struct fcp_cmnd_iu *);
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 067f1519eb04..4b3ae3f22e78 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -4563,7 +4563,7 @@ zfcp_fsf_req_sbal_check(unsigned long *flags,
 /*
 * set qtcb pointer in fsf_req and initialize QTCB
 */
-static inline void
+static void
 zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req *fsf_req)
 {
        if (likely(fsf_req->qtcb != NULL)) {
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index dbd9f48e863e..1e12a78e8edd 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -21,22 +21,22 @@
 #include "zfcp_ext.h"
-static inline void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
+static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_get
        (struct zfcp_qdio_queue *, int, int);
 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_resp
        (struct zfcp_fsf_req *, int, int);
-static inline volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
+static volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
        (struct zfcp_fsf_req *, unsigned long);
-static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
+static volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
        (struct zfcp_fsf_req *, unsigned long);
-static inline int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
+static int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
 static inline int zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *);
-static inline void zfcp_qdio_sbale_fill
+static void zfcp_qdio_sbale_fill
        (struct zfcp_fsf_req *, unsigned long, void *, int);
-static inline int zfcp_qdio_sbals_from_segment
+static int zfcp_qdio_sbals_from_segment
        (struct zfcp_fsf_req *, unsigned long, void *, unsigned long);
-static inline int zfcp_qdio_sbals_from_buffer
+static int zfcp_qdio_sbals_from_buffer
        (struct zfcp_fsf_req *, unsigned long, void *, unsigned long, int);
 static qdio_handler_t zfcp_qdio_request_handler;
@@ -201,7 +201,7 @@ zfcp_qdio_allocate(struct zfcp_adapter *adapter)
 * returns:     error flag
 *
 */
-static inline int
+static int
 zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, unsigned int status,
                              unsigned int qdio_error, unsigned int siga_error,
                              int first_element, int elements_processed)
@@ -462,7 +462,7 @@ zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale)
 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for
 *      a struct zfcp_fsf_req
 */
-inline volatile struct qdio_buffer_element *
+volatile struct qdio_buffer_element *
 zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
 {
        return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue,
@@ -484,7 +484,7 @@ zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for
 *      a struct zfcp_fsf_req
 */
-inline volatile struct qdio_buffer_element *
+volatile struct qdio_buffer_element *
 zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
 {
        return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr,
@@ -499,7 +499,7 @@ zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
 *
 * Note: We can assume at least one free SBAL in the request_queue when called.
 */
-static inline void
+static void
 zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
 {
        int count = atomic_read(&fsf_req->adapter->request_queue.free_count);
@@ -517,7 +517,7 @@ zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
 *
 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req.
 */
-static inline volatile struct qdio_buffer_element *
+static volatile struct qdio_buffer_element *
 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
 {
        volatile struct qdio_buffer_element *sbale;
@@ -554,7 +554,7 @@ zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
 /**
 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed
 */
-static inline volatile struct qdio_buffer_element *
+static volatile struct qdio_buffer_element *
 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
 {
        if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
@@ -569,7 +569,7 @@ zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue
 *      with zero from
 */
-static inline int
+static int
 zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last)
 {
        struct qdio_buffer **buf = queue->buffer;
@@ -603,7 +603,7 @@ zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req)
 * zfcp_qdio_sbale_fill - set address and lenght in current SBALE
 *      on request_queue
 */
-static inline void
+static void
 zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
                     void *addr, int length)
 {
@@ -624,7 +624,7 @@ zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
 * Alignment and length of the segment determine how many SBALEs are needed
 * for the memory segment.
 */
-static inline int
+static int
 zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
                             void *start_addr, unsigned long total_length)
 {
@@ -659,7 +659,7 @@ zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
 * @sg_count: number of elements in scatter-gather list
 * @max_sbals: upper bound for number of SBALs to be used
 */
-inline int
+int
 zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
                        struct scatterlist *sg, int sg_count, int max_sbals)
 {
@@ -707,7 +707,7 @@ out:
 * @length: length of buffer
 * @max_sbals: upper bound for number of SBALs to be used
 */
-static inline int
+static int
 zfcp_qdio_sbals_from_buffer(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
                            void *buffer, unsigned long length, int max_sbals)
 {
@@ -728,7 +728,7 @@ zfcp_qdio_sbals_from_buffer(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used
 *      to fill SBALs
 */
-inline int
+int
 zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req,
                              unsigned long sbtype, struct scsi_cmnd *scsi_cmnd)
 {
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 452d96f92a14..99db02062c3b 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -90,7 +90,7 @@ zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
        return fcp_sns_info_ptr;
 }
-fcp_dl_t *
+static fcp_dl_t *
 zfcp_get_fcp_dl_ptr(struct fcp_cmnd_iu * fcp_cmd)
 {
        int additional_length = fcp_cmd->add_fcp_cdb_length << 2;
@@ -124,19 +124,19 @@ zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl)
 * regarding the specified byte
 */
 static inline void
-set_byte(u32 * result, char status, char pos)
+set_byte(int *result, char status, char pos)
 {
        *result |= status << (pos * 8);
 }
 void
-set_host_byte(u32 * result, char status)
+set_host_byte(int *result, char status)
 {
        set_byte(result, status, 2);
 }
 void
-set_driver_byte(u32 * result, char status)
+set_driver_byte(int *result, char status)
 {
        set_byte(result, status, 3);
 }
@@ -280,7 +280,7 @@ out:
        return retval;
 }
-void
+static void
 zfcp_scsi_command_sync_handler(struct scsi_cmnd *scpnt)
 {
        struct completion *wait = (struct completion *) scpnt->SCp.ptr;
@@ -324,7 +324,7 @@ zfcp_scsi_command_sync(struct zfcp_unit *unit, struct scsi_cmnd *scpnt,
 * returns:     0 - success, SCSI command enqueued
 *              !0 - failure
 */
-int
+static int
 zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
                       void (*done) (struct scsi_cmnd *))
 {
@@ -380,7 +380,7 @@ zfcp_unit_lookup(struct zfcp_adapter *adapter, int channel, unsigned int id,
 * will handle late commands.  (Usually, the normal completion of late
 * commands is ignored with respect to the running abort operation.)
 */
-int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
+static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
 {
        struct Scsi_Host *scsi_host;
        struct zfcp_adapter *adapter;
@@ -445,7 +445,7 @@ int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
        return retval;
 }
-int
+static int
 zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
 {
        int retval;
@@ -541,7 +541,7 @@ zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags,
 /**
 * zfcp_scsi_eh_host_reset_handler - handler for host and bus reset
 */
-int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
+static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
 {
        struct zfcp_unit *unit;
        struct zfcp_adapter *adapter;
diff --git a/drivers/s390/sysinfo.c b/drivers/s390/sysinfo.c
index 1e788e815ce7..090743d2f914 100644
--- a/drivers/s390/sysinfo.c
+++ b/drivers/s390/sysinfo.c
@@ -9,8 +9,14 @@
 #include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/init.h>
+#include <linux/delay.h>
 #include <asm/ebcdic.h>
+/* Sigh, math-emu. Don't ask. */
+#include <asm/sfp-util.h>
+#include <math-emu/soft-fp.h>
+#include <math-emu/single.h>
 struct sysinfo_1_1_1 {
        char reserved_0[32];
        char manufacturer[16];
@@ -198,7 +204,7 @@ static int stsi_1_2_2(struct sysinfo_1_2_2 *info, char *page, int len)
                 * if the higher order 8 bits are not zero. Printing
                 * a floating point number in the kernel is a no-no,
                 * always print the number as 32 bit unsigned integer.
-                 * The user-space needs to know about the stange
+                 * The user-space needs to know about the strange
                 * encoding of the alternate cpu capability.
                 */
                len += sprintf(page + len, "Capability:           %u %u\n",
@@ -351,3 +357,58 @@ static __init int create_proc_sysinfo(void)
 __initcall(create_proc_sysinfo);
+/*
+ * CPU capability might have changed. Therefore recalculate loops_per_jiffy.
+ */
+void s390_adjust_jiffies(void)
+{
+        struct sysinfo_1_2_2 *info;
+        const unsigned int fmil = 0x4b189680;   /* 1e7 as 32-bit float. */
+        FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
+        FP_DECL_EX;
+        unsigned int capability;
+        info = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!info)
+                return;
+        if (stsi(info, 1, 2, 2) != -ENOSYS) {
+                /*
+                 * Major sigh. The cpu capability encoding is "special".
+                 * If the first 9 bits of info->capability are 0 then it
+                 * is a 32 bit unsigned integer in the range 0 .. 2^23.
+                 * If the first 9 bits are != 0 then it is a 32 bit float.
+                 * In addition a lower value indicates a proportionally
+                 * higher cpu capacity. Bogomips are the other way round.
+                 * To get to a halfway suitable number we divide 1e7
+                 * by the cpu capability number. Yes, that means a floating
+                 * point division .. math-emu here we come :-)
+                 */
+                FP_UNPACK_SP(SA, &fmil);
+                if ((info->capability >> 23) == 0)
+                        FP_FROM_INT_S(SB, info->capability, 32, int);
+                else
+                        FP_UNPACK_SP(SB, &info->capability);
+                FP_DIV_S(SR, SA, SB);
+                FP_TO_INT_S(capability, SR, 32, 0);
+        } else
+                /*
+                 * Really old machine without stsi block for basic
+                 * cpu information. Report 42.0 bogomips.
+                 */
+                capability = 42;
+        loops_per_jiffy = capability * (500000/HZ);
+        free_page((unsigned long) info);
+}
+/*
+ * calibrate the delay loop
+ */
+void __init calibrate_delay(void)
+{
+        s390_adjust_jiffies();
+        /* Print the good old Bogomips line .. */
+        printk(KERN_DEBUG "Calibrating delay loop (skipped)... "
+               "%lu.%02lu BogoMIPS preset\n", loops_per_jiffy/(500000/HZ),
+               (loops_per_jiffy/(5000/HZ)) % 100);
+}
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index c7d887540d8d..aa6a620c162f 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -69,6 +69,14 @@ config LOGITECH_FF
          Note: if you say N here, this device will still be supported, but without
          force feedback.
+config PANTHERLORD_FF
+        bool "PantherLord USB/PS2 2in1 Adapter support"
+        depends on HID_FF
+        select INPUT_FF_MEMLESS if USB_HID
+        help
+          Say Y here if you have a PantherLord USB/PS2 2in1 Adapter and want
+          to enable force feedback support for it.
 config THRUSTMASTER_FF
        bool "ThrustMaster FireStorm Dual Power 2 support (EXPERIMENTAL)"
        depends on HID_FF && EXPERIMENTAL
diff --git a/drivers/usb/input/Makefile b/drivers/usb/input/Makefile
index 1a24b5bfa05f..a06024e5cd56 100644
--- a/drivers/usb/input/Makefile
+++ b/drivers/usb/input/Makefile
@@ -17,6 +17,9 @@ endif
 ifeq ($(CONFIG_LOGITECH_FF),y)
        usbhid-objs     += hid-lgff.o
 endif
+ifeq ($(CONFIG_PANTHERLORD_FF),y)
+        usbhid-objs     += hid-plff.o
+endif
 ifeq ($(CONFIG_THRUSTMASTER_FF),y)
        usbhid-objs     += hid-tmff.o
 endif
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index c6c9e72e5fd9..e07a30490726 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -35,6 +35,7 @@
 #include <linux/hid.h>
 #include <linux/hiddev.h>
+#include <linux/hid-debug.h>
 #include "usbhid.h"
 /*
@@ -220,23 +221,6 @@ static void hid_irq_in(struct urb *urb)
        }
 }
-/*
- * Find a report field with a specified HID usage.
- */
-#if 0
-struct hid_field *hid_find_field_by_usage(struct hid_device *hid, __u32 wanted_usage, int type)
-{
-        struct hid_report *report;
-        int i;
-        list_for_each_entry(report, &hid->report_enum[type].report_list, list)
-                for (i = 0; i < report->maxfield; i++)
-                        if (report->field[i]->logical == wanted_usage)
-                                return report->field[i];
-        return NULL;
-}
-#endif  /*  0  */
 static int hid_submit_out(struct hid_device *hid)
 {
        struct hid_report *report;
@@ -501,7 +485,7 @@ static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
 {
        int result, retries = 4;
-        memset(buf,0,size);     // Make sure we parse really received data
+        memset(buf, 0, size);
        do {
                result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
@@ -528,18 +512,6 @@ void usbhid_close(struct hid_device *hid)
                usb_kill_urb(usbhid->urbin);
 }
-static int hidinput_open(struct input_dev *dev)
-{
-        struct hid_device *hid = dev->private;
-        return usbhid_open(hid);
-}
-static void hidinput_close(struct input_dev *dev)
-{
-        struct hid_device *hid = dev->private;
-        usbhid_close(hid);
-}
 #define USB_VENDOR_ID_PANJIT            0x134c
 #define USB_VENDOR_ID_TURBOX            0x062a
@@ -770,6 +742,7 @@ void usbhid_init_reports(struct hid_device *hid)
 #define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
 #define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
+#define USB_DEVICE_ID_APPLE_IR          0x8240
 #define USB_VENDOR_ID_CHERRY            0x046a
 #define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
@@ -792,6 +765,9 @@ void usbhid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_IMATION           0x0718
 #define USB_DEVICE_ID_DISC_STAKKA       0xd000
+#define USB_VENDOR_ID_PANTHERLORD       0x0810
+#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
 /*
 * Alphabetically sorted blacklist by quirk type.
 */
@@ -946,19 +922,21 @@ static const struct hid_blacklist {
        { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_CYMOTION },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IR, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE },
@@ -969,6 +947,8 @@ static const struct hid_blacklist {
        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_USB_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS },
+        { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
        { 0, 0 }
 };
@@ -1064,6 +1044,11 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        if (quirks & HID_QUIRK_IGNORE)
                return NULL;
+        if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
+                (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
+                        return NULL;
        if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
            (!interface->desc.bNumEndpoints ||
             usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
@@ -1235,8 +1220,8 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
        usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
        hid->hidinput_input_event = usb_hidinput_input_event;
-        hid->hidinput_open = hidinput_open;
+        hid->hid_open = usbhid_open;
-        hid->hidinput_close = hidinput_close;
+        hid->hid_close = usbhid_close;
 #ifdef CONFIG_USB_HIDDEV
        hid->hiddev_hid_event = hiddev_hid_event;
        hid->hiddev_report_event = hiddev_report_event;
@@ -1315,11 +1300,7 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
                return -ENODEV;
        }
-        /* This only gets called when we are a single-input (most of the
+        if ((hid->claimed & HID_CLAIMED_INPUT))
-         * time). IOW, not a HID_QUIRK_MULTI_INPUT. The hid_ff_init() is
-         * only useful in this case, and not for multi-input quirks. */
-        if ((hid->claimed & HID_CLAIMED_INPUT) &&
-                        !(hid->quirks & HID_QUIRK_MULTI_INPUT))
                hid_ff_init(hid);
        printk(KERN_INFO);
diff --git a/drivers/usb/input/hid-ff.c b/drivers/usb/input/hid-ff.c
index 59ed65e7a621..5d145058a5cb 100644
--- a/drivers/usb/input/hid-ff.c
+++ b/drivers/usb/input/hid-ff.c
@@ -58,6 +58,9 @@ static struct hid_ff_initializer inits[] = {
        { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */
        { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */
 #endif
+#ifdef CONFIG_PANTHERLORD_FF
+        { 0x810, 0x0001, hid_plff_init },
+#endif
 #ifdef CONFIG_THRUSTMASTER_FF
        { 0x44f, 0xb304, hid_tmff_init },
 #endif
diff --git a/drivers/usb/input/hid-plff.c b/drivers/usb/input/hid-plff.c
new file mode 100644
index 000000000000..76d2e6e14db4
--- /dev/null
+++ b/drivers/usb/input/hid-plff.c
@@ -0,0 +1,129 @@
+/*
+ *  Force feedback support for PantherLord USB/PS2 2in1 Adapter devices
+ *
+ *  Copyright (c) 2007 Anssi Hannula <anssi.hannula@gmail.com>
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+/* #define DEBUG */
+#define debug(format, arg...) pr_debug("hid-plff: " format "\n" , ## arg)
+#include <linux/input.h>
+#include <linux/usb.h>
+#include <linux/hid.h>
+#include "usbhid.h"
+struct plff_device {
+        struct hid_report *report;
+};
+static int hid_plff_play(struct input_dev *dev, void *data,
+                         struct ff_effect *effect)
+{
+        struct hid_device *hid = dev->private;
+        struct plff_device *plff = data;
+        int left, right;
+        left = effect->u.rumble.strong_magnitude;
+        right = effect->u.rumble.weak_magnitude;
+        debug("called with 0x%04x 0x%04x", left, right);
+        left = left * 0x7f / 0xffff;
+        right = right * 0x7f / 0xffff;
+        plff->report->field[0]->value[2] = left;
+        plff->report->field[0]->value[3] = right;
+        debug("running with 0x%02x 0x%02x", left, right);
+        usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
+        return 0;
+}
+int hid_plff_init(struct hid_device *hid)
+{
+        struct plff_device *plff;
+        struct hid_report *report;
+        struct hid_input *hidinput;
+        struct list_head *report_list =
+                        &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct list_head *report_ptr = report_list;
+        struct input_dev *dev;
+        int error;
+        /* The device contains 2 output reports (one for each
+           HID_QUIRK_MULTI_INPUT device), both containing 1 field, which
+           contains 4 ff00.0002 usages and 4 16bit absolute values.
+           The 2 input reports also contain a field which contains
+           8 ff00.0001 usages and 8 boolean values. Their meaning is
+           currently unknown. */
+        if (list_empty(report_list)) {
+                printk(KERN_ERR "hid-plff: no output reports found\n");
+                return -ENODEV;
+        }
+        list_for_each_entry(hidinput, &hid->inputs, list) {
+                report_ptr = report_ptr->next;
+                if (report_ptr == report_list) {
+                        printk(KERN_ERR "hid-plff: required output report is missing\n");
+                        return -ENODEV;
+                }
+                report = list_entry(report_ptr, struct hid_report, list);
+                if (report->maxfield < 1) {
+                        printk(KERN_ERR "hid-plff: no fields in the report\n");
+                        return -ENODEV;
+                }
+                if (report->field[0]->report_count < 4) {
+                        printk(KERN_ERR "hid-plff: not enough values in the field\n");
+                        return -ENODEV;
+                }
+                plff = kzalloc(sizeof(struct plff_device), GFP_KERNEL);
+                if (!plff)
+                        return -ENOMEM;
+                dev = hidinput->input;
+                set_bit(FF_RUMBLE, dev->ffbit);
+                error = input_ff_create_memless(dev, plff, hid_plff_play);
+                if (error) {
+                        kfree(plff);
+                        return error;
+                }
+                plff->report = report;
+                plff->report->field[0]->value[0] = 0x00;
+                plff->report->field[0]->value[1] = 0x00;
+                plff->report->field[0]->value[2] = 0x00;
+                plff->report->field[0]->value[3] = 0x00;
+                usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
+        }
+        printk(KERN_INFO "hid-plff: Force feedback for PantherLord USB/PS2 "
+               "2in1 Adapters by Anssi Hannula <anssi.hannula@gmail.com>\n");
+        return 0;
+}