merge linus into test branch

30 files changed, 330 insertions, 103 deletions

diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 984ab284382a..b34e0a958d0f 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -40,9 +40,9 @@ config ATA_PIIX
         tristate "Intel PIIX/ICH SATA support"
         depends on PCI
         help
-          This option enables support for ICH5/6/7/8 Serial ATA.
-          If PATA support was enabled previously, this enables
-          support for select Intel PIIX/ICH PATA host controllers.
+          This option enables support for ICH5/6/7/8 Serial ATA
+          and support for PATA on the Intel PIIX3/PIIX4/ICH series
+          PATA host controllers.
 
           If unsure, say N.
 
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index f36da488a2c1..dbae6d971041 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -645,8 +645,6 @@ static int ahci_reset_controller(void __iomem *mmio, struct pci_dev *pdev)
         u32 cap_save, impl_save, tmp;
 
         cap_save = readl(mmio + HOST_CAP);
-        cap_save &= ( (1<<28) | (1<<17) );
-        cap_save |= (1 << 27);
         impl_save = readl(mmio + HOST_PORTS_IMPL);
 
         /* global controller reset */
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index c7de0bb1591f..47701b286f8b 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -226,14 +226,26 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x27c0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci },
         /* 2801GBM/GHM (ICH7M, identical to ICH6M) */
         { 0x8086, 0x27c4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6m_sata_ahci },
-        /* Enterprise Southbridge 2 (where's the datasheet?) */
+        /* Enterprise Southbridge 2 (631xESB/632xESB) */
         { 0x8086, 0x2680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci },
-        /* SATA Controller 1 IDE (ICH8, no datasheet yet) */
+        /* SATA Controller 1 IDE (ICH8) */
         { 0x8086, 0x2820, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
-        /* SATA Controller 2 IDE (ICH8, ditto) */
+        /* SATA Controller 2 IDE (ICH8) */
         { 0x8086, 0x2825, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
-        /* Mobile SATA Controller IDE (ICH8M, ditto) */
+        /* Mobile SATA Controller IDE (ICH8M) */
         { 0x8086, 0x2828, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9) */
+        { 0x8086, 0x2920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9) */
+        { 0x8086, 0x2921, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9) */
+        { 0x8086, 0x2926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9M) */
+        { 0x8086, 0x2928, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9M) */
+        { 0x8086, 0x292d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
+        /* SATA Controller IDE (ICH9M) */
+        { 0x8086, 0x292e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata_ahci },
 
         { }     /* terminate list */
 };
@@ -330,7 +342,7 @@ static const struct ata_port_operations ich_pata_ops = {
 
         .port_start             = ata_port_start,
         .port_stop              = ata_port_stop,
-        .host_stop              = ata_host_stop,
+        .host_stop              = piix_host_stop,
 };
 
 static const struct ata_port_operations piix_sata_ops = {
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 011c0a8a2dcc..0d51d13b16bf 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -1332,7 +1332,7 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
 }
 
 /**
- *      ata_exec_internal_sg - execute libata internal command
+ *      ata_exec_internal - execute libata internal command
  *      @dev: Device to which the command is sent
  *      @tf: Taskfile registers for the command and the result
  *      @cdb: CDB for packet command
@@ -1353,11 +1353,17 @@ unsigned ata_exec_internal(struct ata_device *dev,
                            struct ata_taskfile *tf, const u8 *cdb,
                            int dma_dir, void *buf, unsigned int buflen)
 {
-        struct scatterlist sg;
+        struct scatterlist *psg = NULL, sg;
+        unsigned int n_elem = 0;
 
-        sg_init_one(&sg, buf, buflen);
+        if (dma_dir != DMA_NONE) {
+                WARN_ON(!buf);
+                sg_init_one(&sg, buf, buflen);
+                psg = &sg;
+                n_elem++;
+        }
 
-        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, &sg, 1);
+        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem);
 }
 
 /**
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 664e1377b54c..a4790be41d1c 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1539,7 +1539,7 @@ static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
                 struct scatterlist *sg;
 
                 sg = (struct scatterlist *) cmd->request_buffer;
-                buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
+                buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
                 buflen = sg->length;
         } else {
                 buf = cmd->request_buffer;
@@ -1567,7 +1567,7 @@ static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
                 struct scatterlist *sg;
 
                 sg = (struct scatterlist *) cmd->request_buffer;
-                kunmap_atomic(buf - sg->offset, KM_USER0);
+                kunmap_atomic(buf - sg->offset, KM_IRQ0);
         }
 }
 
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index c7d1738e4e69..e7bf9d89c8ee 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -698,8 +698,10 @@ static __init int legacy_init_one(int port, unsigned long io, unsigned long ctrl
                 goto fail_io;
 
         pdev = platform_device_register_simple(DRV_NAME, nr_legacy_host, NULL, 0);
-        if (pdev == NULL)
+        if (IS_ERR(pdev)) {
+                ret = PTR_ERR(pdev);
                 goto fail_dev;
+        }
 
         if (ht6560a & mask) {
                 ops = &ht6560a_port_ops;
diff --git a/drivers/ata/pata_qdi.c b/drivers/ata/pata_qdi.c
index 36f621abc390..afc0d990e7d6 100644
--- a/drivers/ata/pata_qdi.c
+++ b/drivers/ata/pata_qdi.c
@@ -247,8 +247,8 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
          */
 
         pdev = platform_device_register_simple(DRV_NAME, nr_qdi_host, NULL, 0);
-        if (pdev == NULL)
-                return -ENOMEM;
+        if (IS_ERR(pdev))
+                return PTR_ERR(pdev);
 
         memset(&ae, 0, sizeof(struct ata_probe_ent));
         INIT_LIST_HEAD(&ae.node);
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 3677c642c9f9..adf4cc134f25 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -105,8 +105,6 @@ static struct ata_port_operations rz1000_port_ops = {
         .exec_command   = ata_exec_command,
         .dev_select     = ata_std_dev_select,
 
-        .error_handler  = rz1000_error_handler,
-
         .bmdma_setup    = ata_bmdma_setup,
         .bmdma_start    = ata_bmdma_start,
         .bmdma_stop     = ata_bmdma_stop,
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index cc09d47fb927..ff93e8f71cf8 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -161,10 +161,15 @@ static int via_pre_reset(struct ata_port *ap)
                         return -ENOENT;
         }
 
-        if ((config->flags & VIA_UDMA) >= VIA_UDMA_66)
+        if ((config->flags & VIA_UDMA) >= VIA_UDMA_100)
                 ap->cbl = via_cable_detect(ap);
-        else
+        /* The UDMA66 series has no cable detect so do drive side detect */
+        else if ((config->flags & VIA_UDMA) < VIA_UDMA_66)
                 ap->cbl = ATA_CBL_PATA40;
+        else
+                ap->cbl = ATA_CBL_PATA_UNK;
+                
+
         return ata_std_prereset(ap);
 }
 
diff --git a/drivers/ata/pata_winbond.c b/drivers/ata/pata_winbond.c
index 3ea345cde52e..5d1f518e1cc7 100644
--- a/drivers/ata/pata_winbond.c
+++ b/drivers/ata/pata_winbond.c
@@ -206,8 +206,8 @@ static __init int winbond_init_one(unsigned long port)
                          */
 
                         pdev = platform_device_register_simple(DRV_NAME, nr_winbond_host, NULL, 0);
-                        if (pdev == NULL)
-                                return -ENOMEM;
+                        if (IS_ERR(pdev))
+                                return PTR_ERR(pdev);
 
                         memset(&ae, 0, sizeof(struct ata_probe_ent));
                         INIT_LIST_HEAD(&ae.node);
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index db32d15b7fa1..d89c9590b845 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -56,6 +56,8 @@
 #define DRV_VERSION     "2.0"
 
 enum {
+        K2_FLAG_NO_ATAPI_DMA            = (1 << 29),
+
         /* Taskfile registers offsets */
         K2_SATA_TF_CMD_OFFSET           = 0x00,
         K2_SATA_TF_DATA_OFFSET          = 0x00,
@@ -83,11 +85,33 @@ enum {
 
         /* Port stride */
         K2_SATA_PORT_OFFSET             = 0x100,
+
+        board_svw4                      = 0,
+        board_svw8                      = 1,
+};
+
+static const struct k2_board_info {
+        unsigned int            n_ports;
+        unsigned long           port_flags;
+} k2_board_info[] = {
+        /* board_svw4 */
+        { 4, K2_FLAG_NO_ATAPI_DMA },
+
+        /* board_svw8 */
+        { 8, K2_FLAG_NO_ATAPI_DMA },
 };
 
 static u8 k2_stat_check_status(struct ata_port *ap);
 
 
+static int k2_sata_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        if (qc->ap->flags & K2_FLAG_NO_ATAPI_DMA)
+                return -1;      /* ATAPI DMA not supported */
+
+        return 0;
+}
+
 static u32 k2_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
         if (sc_reg > SCR_CONTROL)
@@ -313,6 +337,7 @@ static const struct ata_port_operations k2_sata_ops = {
         .check_status           = k2_stat_check_status,
         .exec_command           = ata_exec_command,
         .dev_select             = ata_std_dev_select,
+        .check_atapi_dma        = k2_sata_check_atapi_dma,
         .bmdma_setup            = k2_bmdma_setup_mmio,
         .bmdma_start            = k2_bmdma_start_mmio,
         .bmdma_stop             = ata_bmdma_stop,
@@ -359,6 +384,8 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
         void __iomem *mmio_base;
+        const struct k2_board_info *board_info =
+                        &k2_board_info[ent->driver_data];
         int pci_dev_busy = 0;
         int rc;
         int i;
@@ -424,7 +451,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 
         probe_ent->sht = &k2_sata_sht;
         probe_ent->port_flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                ATA_FLAG_MMIO;
+                                ATA_FLAG_MMIO | board_info->port_flags;
         probe_ent->port_ops = &k2_sata_ops;
         probe_ent->n_ports = 4;
         probe_ent->irq = pdev->irq;
@@ -441,7 +468,7 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         /* different controllers have different number of ports - currently 4 or 8 */
         /* All ports are on the same function. Multi-function device is no
          * longer available. This should not be seen in any system. */
-        for (i = 0; i < ent->driver_data; i++)
+        for (i = 0; i < board_info->n_ports; i++)
                 k2_sata_setup_port(&probe_ent->port[i], base + i * K2_SATA_PORT_OFFSET);
 
         pci_set_master(pdev);
@@ -469,11 +496,11 @@ err_out:
  * controller
  * */
 static const struct pci_device_id k2_sata_pci_tbl[] = {
-        { PCI_VDEVICE(SERVERWORKS, 0x0240), 4 },
-        { PCI_VDEVICE(SERVERWORKS, 0x0241), 4 },
-        { PCI_VDEVICE(SERVERWORKS, 0x0242), 8 },
-        { PCI_VDEVICE(SERVERWORKS, 0x024a), 4 },
-        { PCI_VDEVICE(SERVERWORKS, 0x024b), 4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0240), board_svw4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0241), board_svw4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0242), board_svw8 },
+        { PCI_VDEVICE(SERVERWORKS, 0x024a), board_svw4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x024b), board_svw4 },
 
         { }
 };
diff --git a/drivers/connector/cn_queue.c b/drivers/connector/cn_queue.c
index b418b16e910e..296f51002b55 100644
--- a/drivers/connector/cn_queue.c
+++ b/drivers/connector/cn_queue.c
@@ -34,7 +34,7 @@
 void cn_queue_wrapper(struct work_struct *work)
 {
         struct cn_callback_entry *cbq =
-                container_of(work, struct cn_callback_entry, work.work);
+                container_of(work, struct cn_callback_entry, work);
         struct cn_callback_data *d = &cbq->data;
 
         d->callback(d->callback_priv);
@@ -59,13 +59,12 @@ static struct cn_callback_entry *cn_queue_alloc_callback_entry(char *name, struc
         memcpy(&cbq->id.id, id, sizeof(struct cb_id));
         cbq->data.callback = callback;
         
-        INIT_DELAYED_WORK(&cbq->work, &cn_queue_wrapper);
+        INIT_WORK(&cbq->work, &cn_queue_wrapper);
         return cbq;
 }
 
 static void cn_queue_free_callback(struct cn_callback_entry *cbq)
 {
-        cancel_delayed_work(&cbq->work);
         flush_workqueue(cbq->pdev->cn_queue);
 
         kfree(cbq);
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
index 5e7cd45d10ee..a44db75bc25b 100644
--- a/drivers/connector/connector.c
+++ b/drivers/connector/connector.c
@@ -135,17 +135,15 @@ static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), v
         spin_lock_bh(&dev->cbdev->queue_lock);
         list_for_each_entry(__cbq, &dev->cbdev->queue_list, callback_entry) {
                 if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
-                        if (likely(!test_bit(WORK_STRUCT_PENDING,
-                                             &__cbq->work.work.management) &&
+                        if (likely(!work_pending(&__cbq->work) &&
                                         __cbq->data.ddata == NULL)) {
                                 __cbq->data.callback_priv = msg;
 
                                 __cbq->data.ddata = data;
                                 __cbq->data.destruct_data = destruct_data;
 
-                                if (queue_delayed_work(
-                                            dev->cbdev->cn_queue,
-                                            &__cbq->work, 0))
+                                if (queue_work(dev->cbdev->cn_queue,
+                                                        &__cbq->work))
                                         err = 0;
                         } else {
                                 struct cn_callback_data *d;
@@ -159,12 +157,11 @@ static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), v
                                         d->destruct_data = destruct_data;
                                         d->free = __cbq;
 
-                                        INIT_DELAYED_WORK(&__cbq->work,
-                                                          &cn_queue_wrapper);
+                                        INIT_WORK(&__cbq->work,
+                                                        &cn_queue_wrapper);
                                         
-                                        if (queue_delayed_work(
-                                                    dev->cbdev->cn_queue,
-                                                    &__cbq->work, 0))
+                                        if (queue_work(dev->cbdev->cn_queue,
+                                                    &__cbq->work))
                                                 err = 0;
                                         else {
                                                 kfree(__cbq);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 9fb2edf36611..d91330432ba2 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -959,7 +959,7 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
 
 
 /**
- * cpufreq_quick_get - get the CPU frequency (in kHz) frpm policy->cur
+ * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
  * @cpu: CPU number
  *
  * This is the last known freq, without actually getting it from the driver.
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 14cdf09316ce..998638020ea0 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -415,12 +415,31 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x000: goto ignore;
                                 case 0x034: map_key_clear(KEY_SLEEP);           break;
                                 case 0x036: map_key_clear(BTN_MISC);            break;
+                                case 0x040: map_key_clear(KEY_MENU);            break;
                                 case 0x045: map_key_clear(KEY_RADIO);           break;
+
+                                case 0x088: map_key_clear(KEY_PC);              break;
+                                case 0x089: map_key_clear(KEY_TV);              break;
                                 case 0x08a: map_key_clear(KEY_WWW);             break;
+                                case 0x08b: map_key_clear(KEY_DVD);             break;
+                                case 0x08c: map_key_clear(KEY_PHONE);           break;
                                 case 0x08d: map_key_clear(KEY_PROGRAM);         break;
+                                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
+                                case 0x08f: map_key_clear(KEY_GAMES);           break;
+                                case 0x090: map_key_clear(KEY_MEMO);            break;
+                                case 0x091: map_key_clear(KEY_CD);              break;
+                                case 0x092: map_key_clear(KEY_VCR);             break;
+                                case 0x093: map_key_clear(KEY_TUNER);           break;
+                                case 0x094: map_key_clear(KEY_EXIT);            break;
                                 case 0x095: map_key_clear(KEY_HELP);            break;
+                                case 0x096: map_key_clear(KEY_TAPE);            break;
+                                case 0x097: map_key_clear(KEY_TV2);             break;
+                                case 0x098: map_key_clear(KEY_SAT);             break;
+
                                 case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
                                 case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
+                                case 0x0a0: map_key_clear(KEY_VCR2);            break;
+
                                 case 0x0b0: map_key_clear(KEY_PLAY);            break;
                                 case 0x0b1: map_key_clear(KEY_PAUSE);           break;
                                 case 0x0b2: map_key_clear(KEY_RECORD);          break;
@@ -430,6 +449,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
                                 case 0x0b7: map_key_clear(KEY_STOPCD);          break;
                                 case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
+
                                 case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
                                 case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
                                 case 0x0e2: map_key_clear(KEY_MUTE);            break;
@@ -437,11 +457,30 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
                                 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
                                 case 0x183: map_key_clear(KEY_CONFIG);          break;
+                                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
+                                case 0x185: map_key_clear(KEY_EDITOR);          break;
+                                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
+                                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
+                                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
+                                case 0x189: map_key_clear(KEY_DATABASE);        break;
                                 case 0x18a: map_key_clear(KEY_MAIL);            break;
+                                case 0x18b: map_key_clear(KEY_NEWS);            break;
+                                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
+                                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
+                                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
+                                case 0x191: map_key_clear(KEY_FINANCE);         break;
                                 case 0x192: map_key_clear(KEY_CALC);            break;
                                 case 0x194: map_key_clear(KEY_FILE);            break;
+                                case 0x196: map_key_clear(KEY_WWW);             break;
+                                case 0x19e: map_key_clear(KEY_COFFEE);          break;
+                                case 0x1a6: map_key_clear(KEY_HELP);            break;
                                 case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
+                                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
+                                case 0x1bd: map_key_clear(KEY_INFO);            break;
                                 case 0x201: map_key_clear(KEY_NEW);             break;
+                                case 0x202: map_key_clear(KEY_OPEN);            break;
+                                case 0x203: map_key_clear(KEY_CLOSE);           break;
+                                case 0x204: map_key_clear(KEY_EXIT);            break;
                                 case 0x207: map_key_clear(KEY_SAVE);            break;
                                 case 0x208: map_key_clear(KEY_PRINT);           break;
                                 case 0x209: map_key_clear(KEY_PROPS);           break;
@@ -456,10 +495,15 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x226: map_key_clear(KEY_STOP);            break;
                                 case 0x227: map_key_clear(KEY_REFRESH);         break;
                                 case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
+                                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
+                                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
+                                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
                                 case 0x233: map_key_clear(KEY_SCROLLUP);        break;
                                 case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
                                 case 0x238: map_rel(REL_HWHEEL);                break;
+                                case 0x25f: map_key_clear(KEY_CANCEL);          break;
                                 case 0x279: map_key_clear(KEY_REDO);            break;
+
                                 case 0x289: map_key_clear(KEY_REPLY);           break;
                                 case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
                                 case 0x28c: map_key_clear(KEY_SEND);            break;
diff --git a/drivers/infiniband/hw/mthca/mthca_main.c b/drivers/infiniband/hw/mthca/mthca_main.c
index 0491ec7a7c0a..44bc6cc734ab 100644
--- a/drivers/infiniband/hw/mthca/mthca_main.c
+++ b/drivers/infiniband/hw/mthca/mthca_main.c
@@ -80,24 +80,61 @@ static int tune_pci = 0;
 module_param(tune_pci, int, 0444);
 MODULE_PARM_DESC(tune_pci, "increase PCI burst from the default set by BIOS if nonzero");
 
-struct mutex mthca_device_mutex;
+DEFINE_MUTEX(mthca_device_mutex);
+
+#define MTHCA_DEFAULT_NUM_QP            (1 << 16)
+#define MTHCA_DEFAULT_RDB_PER_QP        (1 << 2)
+#define MTHCA_DEFAULT_NUM_CQ            (1 << 16)
+#define MTHCA_DEFAULT_NUM_MCG           (1 << 13)
+#define MTHCA_DEFAULT_NUM_MPT           (1 << 17)
+#define MTHCA_DEFAULT_NUM_MTT           (1 << 20)
+#define MTHCA_DEFAULT_NUM_UDAV          (1 << 15)
+#define MTHCA_DEFAULT_NUM_RESERVED_MTTS (1 << 18)
+#define MTHCA_DEFAULT_NUM_UARC_SIZE     (1 << 18)
+
+static struct mthca_profile hca_profile = {
+        .num_qp             = MTHCA_DEFAULT_NUM_QP,
+        .rdb_per_qp         = MTHCA_DEFAULT_RDB_PER_QP,
+        .num_cq             = MTHCA_DEFAULT_NUM_CQ,
+        .num_mcg            = MTHCA_DEFAULT_NUM_MCG,
+        .num_mpt            = MTHCA_DEFAULT_NUM_MPT,
+        .num_mtt            = MTHCA_DEFAULT_NUM_MTT,
+        .num_udav           = MTHCA_DEFAULT_NUM_UDAV,          /* Tavor only */
+        .fmr_reserved_mtts  = MTHCA_DEFAULT_NUM_RESERVED_MTTS, /* Tavor only */
+        .uarc_size          = MTHCA_DEFAULT_NUM_UARC_SIZE,     /* Arbel only */
+};
+
+module_param_named(num_qp, hca_profile.num_qp, int, 0444);
+MODULE_PARM_DESC(num_qp, "maximum number of QPs per HCA");
+
+module_param_named(rdb_per_qp, hca_profile.rdb_per_qp, int, 0444);
+MODULE_PARM_DESC(rdb_per_qp, "number of RDB buffers per QP");
+
+module_param_named(num_cq, hca_profile.num_cq, int, 0444);
+MODULE_PARM_DESC(num_cq, "maximum number of CQs per HCA");
+
+module_param_named(num_mcg, hca_profile.num_mcg, int, 0444);
+MODULE_PARM_DESC(num_mcg, "maximum number of multicast groups per HCA");
+
+module_param_named(num_mpt, hca_profile.num_mpt, int, 0444);
+MODULE_PARM_DESC(num_mpt,
+                "maximum number of memory protection table entries per HCA");
+
+module_param_named(num_mtt, hca_profile.num_mtt, int, 0444);
+MODULE_PARM_DESC(num_mtt,
+                 "maximum number of memory translation table segments per HCA");
+
+module_param_named(num_udav, hca_profile.num_udav, int, 0444);
+MODULE_PARM_DESC(num_udav, "maximum number of UD address vectors per HCA");
+
+module_param_named(fmr_reserved_mtts, hca_profile.fmr_reserved_mtts, int, 0444);
+MODULE_PARM_DESC(fmr_reserved_mtts,
+                 "number of memory translation table segments reserved for FMR");
 
 static const char mthca_version[] __devinitdata =
         DRV_NAME ": Mellanox InfiniBand HCA driver v"
         DRV_VERSION " (" DRV_RELDATE ")\n";
 
-static struct mthca_profile default_profile = {
-        .num_qp            = 1 << 16,
-        .rdb_per_qp        = 4,
-        .num_cq            = 1 << 16,
-        .num_mcg           = 1 << 13,
-        .num_mpt           = 1 << 17,
-        .num_mtt           = 1 << 20,
-        .num_udav          = 1 << 15,   /* Tavor only */
-        .fmr_reserved_mtts = 1 << 18,   /* Tavor only */
-        .uarc_size         = 1 << 18,   /* Arbel only */
-};
-
 static int mthca_tune_pci(struct mthca_dev *mdev)
 {
         int cap;
@@ -303,7 +340,7 @@ static int mthca_init_tavor(struct mthca_dev *mdev)
                 goto err_disable;
         }
 
-        profile = default_profile;
+        profile = hca_profile;
         profile.num_uar   = dev_lim.uar_size / PAGE_SIZE;
         profile.uarc_size = 0;
         if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
@@ -621,7 +658,7 @@ static int mthca_init_arbel(struct mthca_dev *mdev)
                 goto err_stop_fw;
         }
 
-        profile = default_profile;
+        profile = hca_profile;
         profile.num_uar  = dev_lim.uar_size / PAGE_SIZE;
         profile.num_udav = 0;
         if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
@@ -1278,11 +1315,55 @@ static struct pci_driver mthca_driver = {
         .remove         = __devexit_p(mthca_remove_one)
 };
 
+static void __init __mthca_check_profile_val(const char *name, int *pval,
+                                             int pval_default)
+{
+        /* value must be positive and power of 2 */
+        int old_pval = *pval;
+
+        if (old_pval <= 0)
+                *pval = pval_default;
+        else
+                *pval = roundup_pow_of_two(old_pval);
+
+        if (old_pval != *pval) {
+                printk(KERN_WARNING PFX "Invalid value %d for %s in module parameter.\n",
+                       old_pval, name);
+                printk(KERN_WARNING PFX "Corrected %s to %d.\n", name, *pval);
+        }
+}
+
+#define mthca_check_profile_val(name, default)                          \
+        __mthca_check_profile_val(#name, &hca_profile.name, default)
+
+static void __init mthca_validate_profile(void)
+{
+        mthca_check_profile_val(num_qp,            MTHCA_DEFAULT_NUM_QP);
+        mthca_check_profile_val(rdb_per_qp,        MTHCA_DEFAULT_RDB_PER_QP);
+        mthca_check_profile_val(num_cq,            MTHCA_DEFAULT_NUM_CQ);
+        mthca_check_profile_val(num_mcg,           MTHCA_DEFAULT_NUM_MCG);
+        mthca_check_profile_val(num_mpt,           MTHCA_DEFAULT_NUM_MPT);
+        mthca_check_profile_val(num_mtt,           MTHCA_DEFAULT_NUM_MTT);
+        mthca_check_profile_val(num_udav,          MTHCA_DEFAULT_NUM_UDAV);
+        mthca_check_profile_val(fmr_reserved_mtts, MTHCA_DEFAULT_NUM_RESERVED_MTTS);
+
+        if (hca_profile.fmr_reserved_mtts >= hca_profile.num_mtt) {
+                printk(KERN_WARNING PFX "Invalid fmr_reserved_mtts module parameter %d.\n",
+                       hca_profile.fmr_reserved_mtts);
+                printk(KERN_WARNING PFX "(Must be smaller than num_mtt %d)\n",
+                       hca_profile.num_mtt);
+                hca_profile.fmr_reserved_mtts = hca_profile.num_mtt / 2;
+                printk(KERN_WARNING PFX "Corrected fmr_reserved_mtts to %d.\n",
+                       hca_profile.fmr_reserved_mtts);
+        }
+}
+
 static int __init mthca_init(void)
 {
         int ret;
 
-        mutex_init(&mthca_device_mutex);
+        mthca_validate_profile();
+
         ret = mthca_catas_init();
         if (ret)
                 return ret;
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index e9b6a6f07dd7..cdecbf5911c8 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -1898,7 +1898,7 @@ static void srp_add_one(struct ib_device *device)
          */
         srp_dev->fmr_page_shift = max(9, ffs(dev_attr->page_size_cap) - 1);
         srp_dev->fmr_page_size  = 1 << srp_dev->fmr_page_shift;
-        srp_dev->fmr_page_mask  = ~((unsigned long) srp_dev->fmr_page_size - 1);
+        srp_dev->fmr_page_mask  = ~((u64) srp_dev->fmr_page_size - 1);
 
         INIT_LIST_HEAD(&srp_dev->dev_list);
 
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index 868a540ef7cd..c21772317b86 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -87,7 +87,7 @@ struct srp_device {
         struct ib_fmr_pool     *fmr_pool;
         int                     fmr_page_shift;
         int                     fmr_page_size;
-        unsigned long           fmr_page_mask;
+        u64                     fmr_page_mask;
 };
 
 struct srp_host {
diff --git a/drivers/input/keyboard/amikbd.c b/drivers/input/keyboard/amikbd.c
index 16583d71753b..c67e84ec2d6a 100644
--- a/drivers/input/keyboard/amikbd.c
+++ b/drivers/input/keyboard/amikbd.c
@@ -187,7 +187,7 @@ static irqreturn_t amikbd_interrupt(int irq, void *dummy)
 
 static int __init amikbd_init(void)
 {
-        int i, j;
+        int i, j, err;
 
         if (!AMIGAHW_PRESENT(AMI_KEYBOARD))
                 return -ENODEV;
diff --git a/drivers/input/keyboard/sunkbd.c b/drivers/input/keyboard/sunkbd.c
index 3826db9403e6..cc0238366414 100644
--- a/drivers/input/keyboard/sunkbd.c
+++ b/drivers/input/keyboard/sunkbd.c
@@ -225,7 +225,7 @@ static void sunkbd_reinit(struct work_struct *work)
 static void sunkbd_enable(struct sunkbd *sunkbd, int enable)
 {
         serio_pause_rx(sunkbd->serio);
-        sunkbd->enabled = 1;
+        sunkbd->enabled = enable;
         serio_continue_rx(sunkbd->serio);
 }
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 7d824cf8ee2d..ada5e9b9988c 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -57,8 +57,8 @@
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.5.1"
-#define DRV_MODULE_RELDATE      "November 15, 2006"
+#define DRV_MODULE_VERSION      "1.5.2"
+#define DRV_MODULE_RELDATE      "December 13, 2006"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -217,9 +217,16 @@ static inline u32 bnx2_tx_avail(struct bnx2 *bp)
         u32 diff;
 
         smp_mb();
-        diff = TX_RING_IDX(bp->tx_prod) - TX_RING_IDX(bp->tx_cons);
-        if (diff > MAX_TX_DESC_CNT)
-                diff = (diff & MAX_TX_DESC_CNT) - 1;
+
+        /* The ring uses 256 indices for 255 entries, one of them
+         * needs to be skipped.
+         */
+        diff = bp->tx_prod - bp->tx_cons;
+        if (unlikely(diff >= TX_DESC_CNT)) {
+                diff &= 0xffff;
+                if (diff == TX_DESC_CNT)
+                        diff = MAX_TX_DESC_CNT;
+        }
         return (bp->tx_ring_size - diff);
 }
 
@@ -3089,7 +3096,7 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
 
         if ((align_start = (offset32 & 3))) {
                 offset32 &= ~3;
-                len32 += align_start;
+                len32 += (4 - align_start);
                 if ((rc = bnx2_nvram_read(bp, offset32, start, 4)))
                         return rc;
         }
@@ -3107,7 +3114,7 @@ bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
 
         if (align_start || align_end) {
                 buf = kmalloc(len32, GFP_KERNEL);
-                if (buf == 0)
+                if (buf == NULL)
                         return -ENOMEM;
                 if (align_start) {
                         memcpy(buf, start, 4);
@@ -3998,7 +4005,7 @@ bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
         if (!skb)
                 return -ENOMEM;
         packet = skb_put(skb, pkt_size);
-        memcpy(packet, bp->mac_addr, 6);
+        memcpy(packet, bp->dev->dev_addr, 6);
         memset(packet + 6, 0x0, 8);
         for (i = 14; i < pkt_size; i++)
                 packet[i] = (unsigned char) (i & 0xff);
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 571320ae87ab..4056ba1ff3c7 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -68,8 +68,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.70"
-#define DRV_MODULE_RELDATE      "December 1, 2006"
+#define DRV_MODULE_VERSION      "3.71"
+#define DRV_MODULE_RELDATE      "December 15, 2006"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -959,6 +959,13 @@ static int tg3_phy_reset(struct tg3 *tp)
         u32 phy_status;
         int err;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                u32 val;
+
+                val = tr32(GRC_MISC_CFG);
+                tw32_f(GRC_MISC_CFG, val & ~GRC_MISC_CFG_EPHY_IDDQ);
+                udelay(40);
+        }
         err  = tg3_readphy(tp, MII_BMSR, &phy_status);
         err |= tg3_readphy(tp, MII_BMSR, &phy_status);
         if (err != 0)
@@ -1170,7 +1177,15 @@ static void tg3_power_down_phy(struct tg3 *tp)
         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
                 return;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5906) {
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906) {
+                u32 val;
+
+                tg3_bmcr_reset(tp);
+                val = tr32(GRC_MISC_CFG);
+                tw32_f(GRC_MISC_CFG, val | GRC_MISC_CFG_EPHY_IDDQ);
+                udelay(40);
+                return;
+        } else {
                 tg3_writephy(tp, MII_TG3_EXT_CTRL,
                              MII_TG3_EXT_CTRL_FORCE_LED_OFF);
                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x01b2);
@@ -4426,7 +4441,7 @@ static void tg3_free_consistent(struct tg3 *tp)
  */
 static int tg3_alloc_consistent(struct tg3 *tp)
 {
-        tp->rx_std_buffers = kmalloc((sizeof(struct ring_info) *
+        tp->rx_std_buffers = kzalloc((sizeof(struct ring_info) *
                                       (TG3_RX_RING_SIZE +
                                        TG3_RX_JUMBO_RING_SIZE)) +
                                      (sizeof(struct tx_ring_info) *
@@ -4435,13 +4450,6 @@ static int tg3_alloc_consistent(struct tg3 *tp)
         if (!tp->rx_std_buffers)
                 return -ENOMEM;
 
-        memset(tp->rx_std_buffers, 0,
-               (sizeof(struct ring_info) *
-                (TG3_RX_RING_SIZE +
-                 TG3_RX_JUMBO_RING_SIZE)) +
-               (sizeof(struct tx_ring_info) *
-                TG3_TX_RING_SIZE));
-
         tp->rx_jumbo_buffers = &tp->rx_std_buffers[TG3_RX_RING_SIZE];
         tp->tx_buffers = (struct tx_ring_info *)
                 &tp->rx_jumbo_buffers[TG3_RX_JUMBO_RING_SIZE];
@@ -6988,6 +6996,8 @@ static int tg3_open(struct net_device *dev)
         struct tg3 *tp = netdev_priv(dev);
         int err;
 
+        netif_carrier_off(tp->dev);
+
         tg3_full_lock(tp, 0);
 
         err = tg3_set_power_state(tp, PCI_D0);
@@ -7981,6 +7991,10 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 tp->link_config.duplex = cmd->duplex;
         }
 
+        tp->link_config.orig_speed = tp->link_config.speed;
+        tp->link_config.orig_duplex = tp->link_config.duplex;
+        tp->link_config.orig_autoneg = tp->link_config.autoneg;
+
         if (netif_running(dev))
                 tg3_setup_phy(tp, 1);
 
@@ -11923,6 +11937,8 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
          */
         pci_save_state(tp->pdev);
 
+        pci_set_drvdata(pdev, dev);
+
         err = register_netdev(dev);
         if (err) {
                 printk(KERN_ERR PFX "Cannot register net device, "
@@ -11930,8 +11946,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                 goto err_out_iounmap;
         }
 
-        pci_set_drvdata(pdev, dev);
-
         printk(KERN_INFO "%s: Tigon3 [partno(%s) rev %04x PHY(%s)] (%s) %s Ethernet ",
                dev->name,
                tp->board_part_number,
@@ -11962,8 +11976,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                (pdev->dma_mask == DMA_32BIT_MASK) ? 32 :
                 (((u64) pdev->dma_mask == DMA_40BIT_MASK) ? 40 : 64));
 
-        netif_carrier_off(tp->dev);
-
         return 0;
 
 err_out_iounmap:
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index dfaf4ed127bd..cf78a7e5997b 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -1350,6 +1350,7 @@
 #define  GRC_MISC_CFG_BOARD_ID_5788     0x00010000
 #define  GRC_MISC_CFG_BOARD_ID_5788M    0x00018000
 #define  GRC_MISC_CFG_BOARD_ID_AC91002A1 0x00018000
+#define  GRC_MISC_CFG_EPHY_IDDQ         0x00200000
 #define  GRC_MISC_CFG_KEEP_GPHY_POWER   0x04000000
 #define GRC_LOCAL_CTRL                  0x00006808
 #define  GRC_LCLCTRL_INT_ACTIVE         0x00000001
diff --git a/drivers/s390/char/sclp_cpi.c b/drivers/s390/char/sclp_cpi.c
index f7c10d954ec6..4f873ae148b7 100644
--- a/drivers/s390/char/sclp_cpi.c
+++ b/drivers/s390/char/sclp_cpi.c
@@ -49,6 +49,8 @@ static struct sclp_register sclp_cpi_event =
         .send_mask = EvTyp_CtlProgIdent_Mask
 };
 
+MODULE_LICENSE("GPL");
+
 MODULE_AUTHOR(
         "Martin Peschke, IBM Deutschland Entwicklung GmbH "
         "<mpeschke@de.ibm.com>");
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 7835a714a405..3a403f195cf8 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -871,11 +871,32 @@ __clear_subchannel_easy(struct subchannel_id schid)
         return -EBUSY;
 }
 
+static int pgm_check_occured;
+
+static void cio_reset_pgm_check_handler(void)
+{
+        pgm_check_occured = 1;
+}
+
+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;
+        rc = stsch(schid, addr);
+        s390_reset_pgm_handler = NULL;
+        if (pgm_check_occured)
+                return -EIO;
+        else
+                return rc;
+}
+
 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
 {
         struct schib schib;
 
-        if (stsch_err(schid, &schib))
+        if (stsch_reset(schid, &schib))
                 return -ENXIO;
         if (!schib.pmcw.ena)
                 return 0;
@@ -972,7 +993,7 @@ static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
         struct schib schib;
         struct sch_match_id *match_id = data;
 
-        if (stsch_err(schid, &schib))
+        if (stsch_reset(schid, &schib))
                 return -ENXIO;
         if (schib.pmcw.dnv &&
             (schib.pmcw.dev == match_id->devid.devno) &&
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 4c81d890791e..9d6c02446863 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -139,6 +139,8 @@ css_register_subchannel(struct subchannel *sch)
         sch->dev.release = &css_subchannel_release;
         sch->dev.groups = subch_attr_groups;
 
+        css_get_ssd_info(sch);
+
         /* make it known to the system */
         ret = css_sch_device_register(sch);
         if (ret) {
@@ -146,7 +148,6 @@ css_register_subchannel(struct subchannel *sch)
                         __func__, sch->dev.bus_id);
                 return ret;
         }
-        css_get_ssd_info(sch);
         return ret;
 }
 
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 9d4ea449a608..6fd1940842eb 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -979,12 +979,11 @@ __qdio_outbound_processing(struct qdio_q *q)
 
         if (q->is_iqdio_q) {
                 /* 
-                 * for asynchronous queues, we better check, if the fill
-                 * level is too high. for synchronous queues, the fill
-                 * level will never be that high. 
+                 * for asynchronous queues, we better check, if the sent
+                 * buffer is already switched from PRIMED to EMPTY.
                  */
-                if (atomic_read(&q->number_of_buffers_used)>
-                    IQDIO_FILL_LEVEL_TO_POLL)
+                if ((q->queue_type == QDIO_IQDIO_QFMT_ASYNCH) &&
+                    !qdio_is_outbound_q_done(q))
                         qdio_mark_q(q);
 
         } else if (!q->hydra_gives_outbound_pcis)
@@ -1825,6 +1824,10 @@ qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
                         q->sbal[j]=*(outbound_sbals_array++);
 
                 q->queue_type=q_format;
+                if ((q->queue_type == QDIO_IQDIO_QFMT) &&
+                    (no_output_qs > 1) &&
+                    (i == no_output_qs-1))
+                        q->queue_type = QDIO_IQDIO_QFMT_ASYNCH;
                 q->int_parm=int_parm;
                 q->is_input_q=0;
                 q->schid = irq_ptr->schid;
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index ad60afe5dd11..81b5899f4010 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -1129,7 +1129,15 @@ static void ap_poll_thread_stop(void)
         mutex_unlock(&ap_poll_thread_mutex);
 }
 
-static void ap_reset(void)
+static void ap_reset_domain(void)
+{
+        int i;
+
+        for (i = 0; i < AP_DEVICES; i++)
+                ap_reset_queue(AP_MKQID(i, ap_domain_index));
+}
+
+static void ap_reset_all(void)
 {
         int i, j;
 
@@ -1139,7 +1147,7 @@ static void ap_reset(void)
 }
 
 static struct reset_call ap_reset_call = {
-        .fn = ap_reset,
+        .fn = ap_reset_all,
 };
 
 /**
@@ -1229,10 +1237,12 @@ void ap_module_exit(void)
         int i;
         struct device *dev;
 
+        ap_reset_domain();
         ap_poll_thread_stop();
         del_timer_sync(&ap_config_timer);
         del_timer_sync(&ap_poll_timer);
         destroy_workqueue(ap_work_queue);
+        tasklet_kill(&ap_tasklet);
         s390_root_dev_unregister(ap_root_device);
         while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
                     __ap_match_all)))
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index 43f5b6aa7dc4..98e3fe10c1dc 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -266,7 +266,7 @@ static struct scsi_host_template *the_template = NULL;
         (struct NCR5380_hostdata *)(in)->hostdata
 #define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
 
-#define NEXT(cmd)       ((struct scsi_cmnd *)((cmd)->host_scribble))
+#define NEXT(cmd)       (*(struct scsi_cmnd **)&((cmd)->host_scribble))
 #define NEXTADDR(cmd)   ((struct scsi_cmnd **)&((cmd)->host_scribble))
 
 #define HOSTNO          instance->host_no
@@ -650,7 +650,7 @@ __inline__ void NCR5380_print_phase(struct Scsi_Host *instance) { };
 #include <linux/interrupt.h>
 
 static volatile int main_running = 0;
-static DECLARE_WORK(NCR5380_tqueue, (void (*)(void*))NCR5380_main, NULL);
+static DECLARE_WORK(NCR5380_tqueue, NCR5380_main);
 
 static __inline__ void queue_main(void)
 {
@@ -1031,7 +1031,7 @@ static int NCR5380_queue_command(struct scsi_cmnd *cmd,
  *  reenable them.  This prevents reentrancy and kernel stack overflow.
  */     
     
-static void NCR5380_main (void *bl)
+static void NCR5380_main (struct work_struct *bl)
 {
     struct scsi_cmnd *tmp, *prev;
     struct Scsi_Host *instance = first_instance;
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index 8a62d4785755..e308f6dc2b87 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -7,7 +7,8 @@ comment "USB Input Devices"
 config USB_HID
         tristate "USB Human Interface Device (full HID) support"
         default y
-        depends on USB && HID
+        depends on USB
+        select HID
         ---help---
           Say Y here if you want full HID support to connect USB keyboards,
           mice, joysticks, graphic tablets, or any other HID based devices