Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...

* 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev:
  libata: blacklist Seagate drives which time out FLUSH_CACHE when used with NCQ
  [libata] pata_rb532_cf: fix signature of the xfer function
  [libata] pata_rb532_cf: fix and rename register definitions
  ata_piix: add borked Tecra M4 to broken suspend list

diff --git a/arch/powerpc/kernel/sysfs.c b/arch/powerpc/kernel/sysfs.c
index 86a2ffccef2592066ece036093a4e0b73858f7da..20885a38237aa0ab5f028aa67537b365b340aad0 100644 (file)
--- a/arch/powerpc/kernel/sysfs.c
+++ b/arch/powerpc/kernel/sysfs.c
@@ -717,9 +717,11 @@ static void unregister_cpu_online(unsigned int cpu)
 
        BUG_ON(!c->hotpluggable);
 
+#ifdef CONFIG_PPC64
        if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
                        cpu_has_feature(CPU_FTR_SMT))
                sysdev_remove_file(s, &attr_smt_snooze_delay);
+#endif
 
        /* PMC stuff */
        switch (cur_cpu_spec->pmc_type) {

diff --git a/arch/sparc64/kernel/pci_fire.c b/arch/sparc64/kernel/pci_fire.c
index fcbbac66e141003e1806476cab9dd847f8452b6d..9462b68f489415f631702baaeef8935246def172 100644 (file)
--- a/arch/sparc64/kernel/pci_fire.c
+++ b/arch/sparc64/kernel/pci_fire.c
@@ -455,7 +455,7 @@ static int __init pci_fire_pbm_init(struct pci_pbm_info *pbm,
        return 0;
 }
 
-static int __init fire_probe(struct of_device *op,
+static int __devinit fire_probe(struct of_device *op,
                                const struct of_device_id *match)
 {
        struct device_node *dp = op->node;

diff --git a/arch/sparc64/kernel/pci_psycho.c b/arch/sparc64/kernel/pci_psycho.c
index 56605adbb5b3f9c43d57bc91e7f8b185f42ba704..dfb3ec892987ec8cca3900693d76f1df3ed2b234 100644 (file)
--- a/arch/sparc64/kernel/pci_psycho.c
+++ b/arch/sparc64/kernel/pci_psycho.c
@@ -493,7 +493,7 @@ static void __init psycho_pbm_init(struct pci_pbm_info *pbm,
        psycho_scan_bus(pbm, &op->dev);
 }
 
-static struct pci_pbm_info * __init psycho_find_sibling(u32 upa_portid)
+static struct pci_pbm_info * __devinit psycho_find_sibling(u32 upa_portid)
 {
        struct pci_pbm_info *pbm;
 
@@ -506,7 +506,7 @@ static struct pci_pbm_info * __init psycho_find_sibling(u32 upa_portid)
 
 #define PSYCHO_CONFIGSPACE     0x001000000UL
 
-static int __init psycho_probe(struct of_device *op,
+static int __devinit psycho_probe(struct of_device *op,
                                  const struct of_device_id *match)
 {
        const struct linux_prom64_registers *pr_regs;

diff --git a/arch/sparc64/kernel/pci_sun4v.c b/arch/sparc64/kernel/pci_sun4v.c
index 4b27b0e10ce78baa287691d04c695dfcce293751..34a1fded39415cbbc863f39babe56bacd39d489a 100644 (file)
--- a/arch/sparc64/kernel/pci_sun4v.c
+++ b/arch/sparc64/kernel/pci_sun4v.c
@@ -929,7 +929,7 @@ static int __init pci_sun4v_pbm_init(struct pci_pbm_info *pbm,
        return 0;
 }
 
-static int __init pci_sun4v_probe(struct of_device *op,
+static int __devinit pci_sun4v_probe(struct of_device *op,
                                     const struct of_device_id *match)
 {
        const struct linux_prom64_registers *regs;

diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 59f472143f087d9486d62bd9f3842c2a9aee7eb6..1412a8d1e58de75059b5687b533e77e4667f44a3 100644 (file)
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -1795,12 +1795,15 @@ retry_open:
        }
 #endif
        if (device == MKDEV(TTYAUX_MAJOR, 1)) {
-               driver = tty_driver_kref_get(console_device(&index));
-               if (driver) {
-                       /* Don't let /dev/console block */
-                       filp->f_flags |= O_NONBLOCK;
-                       noctty = 1;
-                       goto got_driver;
+               struct tty_driver *console_driver = console_device(&index);
+               if (console_driver) {
+                       driver = tty_driver_kref_get(console_driver);
+                       if (driver) {
+                               /* Don't let /dev/console block */
+                               filp->f_flags |= O_NONBLOCK;
+                               noctty = 1;
+                               goto got_driver;
+                       }
                }
                mutex_unlock(&tty_mutex);
                return -ENODEV;

diff --git a/drivers/firewire/fw-sbp2.c b/drivers/firewire/fw-sbp2.c
index 97df6dac3a821c250dbf068e0e11b33d13affb6f..e54403ee59e7f3f715f587f804d68d7cad21a5c6 100644 (file)
--- a/drivers/firewire/fw-sbp2.c
+++ b/drivers/firewire/fw-sbp2.c
@@ -370,6 +370,11 @@ static const struct {
                .model                  = 0x000021,
                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
        },
+       /* iPod mini */ {
+               .firmware_revision      = 0x0a2700,
+               .model                  = 0x000022,
+               .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
+       },
        /* iPod mini */ {
                .firmware_revision      = 0x0a2700,
                .model                  = 0x000023,

diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index 9b97795e45ad71dd604d55fe8ddd7f5ca460b3ee..aa28aed0e46cb4d400cdd8f419cfbb8cedefa877 100644 (file)
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -400,12 +400,12 @@ static const struct hid_device_id apple_devices[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
                        APPLE_RDESC_JIS },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
                        APPLE_ISO_KEYBOARD },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
                .driver_data = APPLE_HAS_FN },

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 147ec591a8061df0b57e0741428cc46c046cfaeb..40df3e1b4bd11ef54f838d6a07645e8b03b8df26 100644 (file)
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1241,9 +1241,9 @@ static const struct hid_device_id hid_blacklist[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
+       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
@@ -1266,6 +1266,9 @@ static const struct hid_device_id hid_blacklist[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) },
        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GENERIC_13BA, USB_DEVICE_ID_GENERIC_13BA_KBD_MOUSE) },
+       { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
+       { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
+       { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
@@ -1420,7 +1423,6 @@ static const struct hid_device_id hid_ignore_list[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
        { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
@@ -1436,7 +1438,6 @@ static const struct hid_device_id hid_ignore_list[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
@@ -1576,9 +1577,6 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
        { }

diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index d70075dd3d81579e21e704acc1556b33cf874310..39289699c32fbd5b640e5bd9c440990bf5f2a97c 100644 (file)
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -163,6 +163,7 @@
 
 #define USB_VENDOR_ID_GAMERON          0x0810
 #define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR 0x0001
+#define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR 0x0002
 
 #define USB_VENDOR_ID_GENERAL_TOUCH    0x0dfc
 

diff --git a/drivers/hid/hid-pl.c b/drivers/hid/hid-pl.c
index acd81558618285ffd25f0ec1c5b01c9ec1de5d01..46941f979b9d058202f9ce71f8b70e341457c62a 100644 (file)
--- a/drivers/hid/hid-pl.c
+++ b/drivers/hid/hid-pl.c
@@ -178,6 +178,8 @@ err:
 static const struct hid_device_id pl_devices[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR),
                .driver_data = 1 }, /* Twin USB Joystick */
+       { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR),
+               .driver_data = 1 }, /* Twin USB Joystick */
        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003), }, /* GreenAsia Inc. USB Joystick */
        { }
 };

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index d746bf8284dd31994999916a72cab2f2c753b8a0..606369ea24ca038e36704f6b9c14d415e5fd5d36 100644 (file)
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -796,7 +796,6 @@ static int usbhid_start(struct hid_device *hid)
        if (insize > HID_MAX_BUFFER_SIZE)
                insize = HID_MAX_BUFFER_SIZE;
 
-       mutex_lock(&usbhid->setup);
        if (hid_alloc_buffers(dev, hid)) {
                ret = -ENOMEM;
                goto fail;
@@ -876,7 +875,6 @@ static int usbhid_start(struct hid_device *hid)
        hid_dump_device(hid);
 
        set_bit(HID_STARTED, &usbhid->iofl);
-       mutex_unlock(&usbhid->setup);
 
        return 0;
 
@@ -888,7 +886,6 @@ fail:
        usbhid->urbout = NULL;
        usbhid->urbctrl = NULL;
        hid_free_buffers(dev, hid);
-       mutex_unlock(&usbhid->setup);
        return ret;
 }
 
@@ -899,7 +896,6 @@ static void usbhid_stop(struct hid_device *hid)
        if (WARN_ON(!usbhid))
                return;
 
-       mutex_lock(&usbhid->setup);
        clear_bit(HID_STARTED, &usbhid->iofl);
        spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
        set_bit(HID_DISCONNECTED, &usbhid->iofl);
@@ -928,7 +924,6 @@ static void usbhid_stop(struct hid_device *hid)
        usbhid->urbout = NULL;
 
        hid_free_buffers(hid_to_usb_dev(hid), hid);
-       mutex_unlock(&usbhid->setup);
 }
 
 static struct hid_ll_driver usb_hid_driver = {
@@ -1016,7 +1011,6 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
 
        hid->driver_data = usbhid;
        usbhid->hid = hid;
-       mutex_init(&usbhid->setup); /* needed on suspend/resume */
 
        ret = hid_add_device(hid);
        if (ret) {
@@ -1051,18 +1045,14 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
        struct hid_device *hid = usb_get_intfdata (intf);
        struct usbhid_device *usbhid = hid->driver_data;
 
-       mutex_lock(&usbhid->setup);
-       if (!test_bit(HID_STARTED, &usbhid->iofl)) {
-               mutex_unlock(&usbhid->setup);
+       if (!test_bit(HID_STARTED, &usbhid->iofl))
                return 0;
-       }
 
        spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
        set_bit(HID_SUSPENDED, &usbhid->iofl);
        spin_unlock_irq(&usbhid->inlock);
        del_timer_sync(&usbhid->io_retry);
        usb_kill_urb(usbhid->urbin);
-       mutex_unlock(&usbhid->setup);
        dev_dbg(&intf->dev, "suspend\n");
        return 0;
 }
@@ -1073,16 +1063,12 @@ static int hid_resume(struct usb_interface *intf)
        struct usbhid_device *usbhid = hid->driver_data;
        int status;
 
-       mutex_lock(&usbhid->setup);
-       if (!test_bit(HID_STARTED, &usbhid->iofl)) {
-               mutex_unlock(&usbhid->setup);
+       if (!test_bit(HID_STARTED, &usbhid->iofl))
                return 0;
-       }
 
        clear_bit(HID_SUSPENDED, &usbhid->iofl);
        usbhid->retry_delay = 0;
        status = hid_start_in(hid);
-       mutex_unlock(&usbhid->setup);
        dev_dbg(&intf->dev, "resume status %d\n", status);
        return status;
 }

diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 55973ff54008f36e6c2381275a1c26e08db25f47..332abcdf9956468ebf9b3aec792a716125b62f6c 100644 (file)
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -74,7 +74,6 @@ struct usbhid_device {
        dma_addr_t outbuf_dma;                                          /* Output buffer dma */
        spinlock_t outlock;                                             /* Output fifo spinlock */
 
-       struct mutex setup;
        unsigned long iofl;                                             /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
        struct timer_list io_retry;                                     /* Retry timer */
        unsigned long stop_retry;                                       /* Time to give up, in jiffies */

diff --git a/drivers/ieee1394/highlevel.c b/drivers/ieee1394/highlevel.c
index 918ffc4fc8ace2923f660d452d6f389a488c8b25..272543a42a43b0478caf4879c3664782790bafc2 100644 (file)
--- a/drivers/ieee1394/highlevel.c
+++ b/drivers/ieee1394/highlevel.c
@@ -46,10 +46,6 @@ static DEFINE_RWLOCK(hl_irqs_lock);
 
 static DEFINE_RWLOCK(addr_space_lock);
 
-/* addr_space list will have zero and max already included as bounds */
-static struct hpsb_address_ops dummy_ops = { NULL, NULL, NULL, NULL };
-static struct hpsb_address_serve dummy_zero_addr, dummy_max_addr;
-
 
 static struct hl_host_info *hl_get_hostinfo(struct hpsb_highlevel *hl,
                                            struct hpsb_host *host)
@@ -481,20 +477,23 @@ int hpsb_unregister_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
        return retval;
 }
 
+static struct hpsb_address_ops dummy_ops;
+
+/* dummy address spaces as lower and upper bounds of the host's a.s. list */
 static void init_hpsb_highlevel(struct hpsb_host *host)
 {
-       INIT_LIST_HEAD(&dummy_zero_addr.host_list);
-       INIT_LIST_HEAD(&dummy_zero_addr.hl_list);
-       INIT_LIST_HEAD(&dummy_max_addr.host_list);
-       INIT_LIST_HEAD(&dummy_max_addr.hl_list);
+       INIT_LIST_HEAD(&host->dummy_zero_addr.host_list);
+       INIT_LIST_HEAD(&host->dummy_zero_addr.hl_list);
+       INIT_LIST_HEAD(&host->dummy_max_addr.host_list);
+       INIT_LIST_HEAD(&host->dummy_max_addr.hl_list);
 
-       dummy_zero_addr.op = dummy_max_addr.op = &dummy_ops;
+       host->dummy_zero_addr.op = host->dummy_max_addr.op = &dummy_ops;
 
-       dummy_zero_addr.start = dummy_zero_addr.end = 0;
-       dummy_max_addr.start = dummy_max_addr.end = ((u64) 1) << 48;
+       host->dummy_zero_addr.start = host->dummy_zero_addr.end = 0;
+       host->dummy_max_addr.start = host->dummy_max_addr.end = ((u64) 1) << 48;
 
-       list_add_tail(&dummy_zero_addr.host_list, &host->addr_space);
-       list_add_tail(&dummy_max_addr.host_list, &host->addr_space);
+       list_add_tail(&host->dummy_zero_addr.host_list, &host->addr_space);
+       list_add_tail(&host->dummy_max_addr.host_list, &host->addr_space);
 }
 
 void highlevel_add_host(struct hpsb_host *host)

diff --git a/drivers/ieee1394/hosts.h b/drivers/ieee1394/hosts.h
index e4e8aeb4d7788d2caf2ef7d5821dbf77a038c27d..dd229950acca4633b3f1d2952d8d40fed2e3ebd5 100644 (file)
--- a/drivers/ieee1394/hosts.h
+++ b/drivers/ieee1394/hosts.h
@@ -13,6 +13,7 @@ struct module;
 
 #include "ieee1394_types.h"
 #include "csr.h"
+#include "highlevel.h"
 
 struct hpsb_packet;
 struct hpsb_iso;
@@ -72,6 +73,9 @@ struct hpsb_host {
        struct { DECLARE_BITMAP(map, 64); } tl_pool[ALL_NODES];
 
        struct csr_control csr;
+
+       struct hpsb_address_serve dummy_zero_addr;
+       struct hpsb_address_serve dummy_max_addr;
 };
 
 enum devctl_cmd {

diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index c52f6e6e8af2a8bacac026e4f9974652ee794661..a373c18cf7b8fe8bd077c47b0808abea743e573f 100644 (file)
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -400,6 +400,11 @@ static const struct {
                .model_id               = 0x000021,
                .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
        },
+       /* iPod mini */ {
+               .firmware_revision      = 0x0a2700,
+               .model_id               = 0x000022,
+               .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
+       },
        /* iPod mini */ {
                .firmware_revision      = 0x0a2700,
                .model_id               = 0x000023,
@@ -890,12 +895,13 @@ static void sbp2_host_reset(struct hpsb_host *host)
                return;
 
        read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
+
        list_for_each_entry(lu, &hi->logical_units, lu_list)
-               if (likely(atomic_read(&lu->state) !=
-                          SBP2LU_STATE_IN_SHUTDOWN)) {
-                       atomic_set(&lu->state, SBP2LU_STATE_IN_RESET);
+               if (atomic_cmpxchg(&lu->state,
+                                  SBP2LU_STATE_RUNNING, SBP2LU_STATE_IN_RESET)
+                   == SBP2LU_STATE_RUNNING)
                        scsi_block_requests(lu->shost);
-               }
+
        read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
 }
 

diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 4df887af66a527156a4ad9688e319bb308f36ebc..7fc35cf0cddf35285cd91586e6d1aa02145a6a00 100644 (file)
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -163,7 +163,8 @@ struct ehca_mod_qp_parm {
 /* struct for tracking if cqes have been reported to the application */
 struct ehca_qmap_entry {
        u16 app_wr_id;
-       u16 reported;
+       u8 reported;
+       u8 cqe_req;
 };
 
 struct ehca_queue_map {
@@ -171,6 +172,7 @@ struct ehca_queue_map {
        unsigned int entries;
        unsigned int tail;
        unsigned int left_to_poll;
+       unsigned int next_wqe_idx;   /* Idx to first wqe to be flushed */
 };
 
 struct ehca_qp {

diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index bb02a86aa5269d7b3c22a85aa23d1caaf0411e7e..bec7e0249358f6cb876729d9070c51d94f6e29e7 100644 (file)
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -994,8 +994,7 @@ static int ehca_mem_notifier(struct notifier_block *nb,
                        if (printk_timed_ratelimit(&ehca_dmem_warn_time,
                                                   30 * 1000))
                                ehca_gen_err("DMEM operations are not allowed"
-                                            "as long as an ehca adapter is"
-                                            "attached to the LPAR");
+                                            "in conjunction with eHCA");
                        return NOTIFY_BAD;
                }
        }

diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 9e05ee2db39baab87389049d7d2f479e8efe1a6a..cadbf0cdd910e996ddca5029e6a66dcbe27382a9 100644 (file)
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -435,9 +435,13 @@ static void reset_queue_map(struct ehca_queue_map *qmap)
 {
        int i;
 
-       qmap->tail = 0;
-       for (i = 0; i < qmap->entries; i++)
+       qmap->tail = qmap->entries - 1;
+       qmap->left_to_poll = 0;
+       qmap->next_wqe_idx = 0;
+       for (i = 0; i < qmap->entries; i++) {
                qmap->map[i].reported = 1;
+               qmap->map[i].cqe_req = 0;
+       }
 }
 
 /*
@@ -1121,6 +1125,7 @@ static int calc_left_cqes(u64 wqe_p, struct ipz_queue *ipz_queue,
        void *wqe_v;
        u64 q_ofs;
        u32 wqe_idx;
+       unsigned int tail_idx;
 
        /* convert real to abs address */
        wqe_p = wqe_p & (~(1UL << 63));
@@ -1133,12 +1138,17 @@ static int calc_left_cqes(u64 wqe_p, struct ipz_queue *ipz_queue,
                return -EFAULT;
        }
 
+       tail_idx = (qmap->tail + 1) % qmap->entries;
        wqe_idx = q_ofs / ipz_queue->qe_size;
-       if (wqe_idx < qmap->tail)
-               qmap->left_to_poll = (qmap->entries - qmap->tail) + wqe_idx;
-       else
-               qmap->left_to_poll = wqe_idx - qmap->tail;
 
+       /* check all processed wqes, whether a cqe is requested or not */
+       while (tail_idx != wqe_idx) {
+               if (qmap->map[tail_idx].cqe_req)
+                       qmap->left_to_poll++;
+               tail_idx = (tail_idx + 1) % qmap->entries;
+       }
+       /* save index in queue, where we have to start flushing */
+       qmap->next_wqe_idx = wqe_idx;
        return 0;
 }
 
@@ -1185,10 +1195,14 @@ static int check_for_left_cqes(struct ehca_qp *my_qp, struct ehca_shca *shca)
        } else {
                spin_lock_irqsave(&my_qp->send_cq->spinlock, flags);
                my_qp->sq_map.left_to_poll = 0;
+               my_qp->sq_map.next_wqe_idx = (my_qp->sq_map.tail + 1) %
+                                               my_qp->sq_map.entries;
                spin_unlock_irqrestore(&my_qp->send_cq->spinlock, flags);
 
                spin_lock_irqsave(&my_qp->recv_cq->spinlock, flags);
                my_qp->rq_map.left_to_poll = 0;
+               my_qp->rq_map.next_wqe_idx = (my_qp->rq_map.tail + 1) %
+                                               my_qp->rq_map.entries;
                spin_unlock_irqrestore(&my_qp->recv_cq->spinlock, flags);
        }
 

diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index 64928079eafa93bc3a73b13aed73bd6ee57b80bb..00a648f4316c66b0f4585cfbf63db7792fee2c3d 100644 (file)
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -179,6 +179,7 @@ static inline int ehca_write_swqe(struct ehca_qp *qp,
 
        qmap_entry->app_wr_id = get_app_wr_id(send_wr->wr_id);
        qmap_entry->reported = 0;
+       qmap_entry->cqe_req = 0;
 
        switch (send_wr->opcode) {
        case IB_WR_SEND:
@@ -203,8 +204,10 @@ static inline int ehca_write_swqe(struct ehca_qp *qp,
 
        if ((send_wr->send_flags & IB_SEND_SIGNALED ||
            qp->init_attr.sq_sig_type == IB_SIGNAL_ALL_WR)
-           && !hidden)
+           && !hidden) {
                wqe_p->wr_flag |= WQE_WRFLAG_REQ_SIGNAL_COM;
+               qmap_entry->cqe_req = 1;
+       }
 
        if (send_wr->opcode == IB_WR_SEND_WITH_IMM ||
            send_wr->opcode == IB_WR_RDMA_WRITE_WITH_IMM) {
@@ -569,6 +572,7 @@ static int internal_post_recv(struct ehca_qp *my_qp,
                qmap_entry = &my_qp->rq_map.map[rq_map_idx];
                qmap_entry->app_wr_id = get_app_wr_id(cur_recv_wr->wr_id);
                qmap_entry->reported = 0;
+               qmap_entry->cqe_req = 1;
 
                wqe_cnt++;
        } /* eof for cur_recv_wr */
@@ -706,27 +710,34 @@ repoll:
                goto repoll;
        wc->qp = &my_qp->ib_qp;
 
+       qmap_tail_idx = get_app_wr_id(cqe->work_request_id);
+       if (!(cqe->w_completion_flags & WC_SEND_RECEIVE_BIT))
+               /* We got a send completion. */
+               qmap = &my_qp->sq_map;
+       else
+               /* We got a receive completion. */
+               qmap = &my_qp->rq_map;
+
+       /* advance the tail pointer */
+       qmap->tail = qmap_tail_idx;
+
        if (is_error) {
                /*
                 * set left_to_poll to 0 because in error state, we will not
                 * get any additional CQEs
                 */
-               ehca_add_to_err_list(my_qp, 1);
+               my_qp->sq_map.next_wqe_idx = (my_qp->sq_map.tail + 1) %
+                                               my_qp->sq_map.entries;
                my_qp->sq_map.left_to_poll = 0;
+               ehca_add_to_err_list(my_qp, 1);
 
+               my_qp->rq_map.next_wqe_idx = (my_qp->rq_map.tail + 1) %
+                                               my_qp->rq_map.entries;
+               my_qp->rq_map.left_to_poll = 0;
                if (HAS_RQ(my_qp))
                        ehca_add_to_err_list(my_qp, 0);
-               my_qp->rq_map.left_to_poll = 0;
        }
 
-       qmap_tail_idx = get_app_wr_id(cqe->work_request_id);
-       if (!(cqe->w_completion_flags & WC_SEND_RECEIVE_BIT))
-               /* We got a send completion. */
-               qmap = &my_qp->sq_map;
-       else
-               /* We got a receive completion. */
-               qmap = &my_qp->rq_map;
-
        qmap_entry = &qmap->map[qmap_tail_idx];
        if (qmap_entry->reported) {
                ehca_warn(cq->device, "Double cqe on qp_num=%#x",
@@ -738,10 +749,6 @@ repoll:
        wc->wr_id = replace_wr_id(cqe->work_request_id, qmap_entry->app_wr_id);
        qmap_entry->reported = 1;
 
-       /* this is a proper completion, we need to advance the tail pointer */
-       if (++qmap->tail == qmap->entries)
-               qmap->tail = 0;
-
        /* if left_to_poll is decremented to 0, add the QP to the error list */
        if (qmap->left_to_poll > 0) {
                qmap->left_to_poll--;
@@ -805,13 +812,14 @@ static int generate_flush_cqes(struct ehca_qp *my_qp, struct ib_cq *cq,
        else
                qmap = &my_qp->rq_map;
 
-       qmap_entry = &qmap->map[qmap->tail];
+       qmap_entry = &qmap->map[qmap->next_wqe_idx];
 
        while ((nr < num_entries) && (qmap_entry->reported == 0)) {
                /* generate flush CQE */
+
                memset(wc, 0, sizeof(*wc));
 
-               offset = qmap->tail * ipz_queue->qe_size;
+               offset = qmap->next_wqe_idx * ipz_queue->qe_size;
                wqe = (struct ehca_wqe *)ipz_qeit_calc(ipz_queue, offset);
                if (!wqe) {
                        ehca_err(cq->device, "Invalid wqe offset=%#lx on "
@@ -850,11 +858,12 @@ static int generate_flush_cqes(struct ehca_qp *my_qp, struct ib_cq *cq,
 
                wc->qp = &my_qp->ib_qp;
 
-               /* mark as reported and advance tail pointer */
+               /* mark as reported and advance next_wqe pointer */
                qmap_entry->reported = 1;
-               if (++qmap->tail == qmap->entries)
-                       qmap->tail = 0;
-               qmap_entry = &qmap->map[qmap->tail];
+               qmap->next_wqe_idx++;
+               if (qmap->next_wqe_idx == qmap->entries)
+                       qmap->next_wqe_idx = 0;
+               qmap_entry = &qmap->map[qmap->next_wqe_idx];
 
                wc++; nr++;
        }

diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index d0866a3636e257b402427588346bb9be28f35fbb..18308494a195bb0d4af1a068ddfd319a3f7b3488 100644 (file)
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -343,6 +343,7 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
 {
        struct mlx4_ib_dev *dev = to_mdev(ibcq->device);
        struct mlx4_ib_cq *cq = to_mcq(ibcq);
+       struct mlx4_mtt mtt;
        int outst_cqe;
        int err;
 
@@ -376,10 +377,13 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
                        goto out;
        }
 
+       mtt = cq->buf.mtt;
+
        err = mlx4_cq_resize(dev->dev, &cq->mcq, entries, &cq->resize_buf->buf.mtt);
        if (err)
                goto err_buf;
 
+       mlx4_mtt_cleanup(dev->dev, &mtt);
        if (ibcq->uobject) {
                cq->buf      = cq->resize_buf->buf;
                cq->ibcq.cqe = cq->resize_buf->cqe;
@@ -406,6 +410,7 @@ int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
        goto out;
 
 err_buf:
+       mlx4_mtt_cleanup(dev->dev, &cq->resize_buf->buf.mtt);
        if (!ibcq->uobject)
                mlx4_ib_free_cq_buf(dev, &cq->resize_buf->buf,
                                    cq->resize_buf->cqe);

diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index 468921b8f4b68a047abdf2f247e4a1c3e0ed5d41..90a0281d15ea22d96ce788107dee88d0deb77aff 100644 (file)
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -753,6 +753,7 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
        struct mlx4_priv *priv = mlx4_priv(dev);
        int err;
        int port;
+       __be32 ib_port_default_caps;
 
        err = mlx4_init_uar_table(dev);
        if (err) {
@@ -852,6 +853,13 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
        }
 
        for (port = 1; port <= dev->caps.num_ports; port++) {
+               ib_port_default_caps = 0;
+               err = mlx4_get_port_ib_caps(dev, port, &ib_port_default_caps);
+               if (err)
+                       mlx4_warn(dev, "failed to get port %d default "
+                                 "ib capabilities (%d). Continuing with "
+                                 "caps = 0\n", port, err);
+               dev->caps.ib_port_def_cap[port] = ib_port_default_caps;
                err = mlx4_SET_PORT(dev, port);
                if (err) {
                        mlx4_err(dev, "Failed to set port %d, aborting\n",

diff --git a/drivers/net/mlx4/mlx4.h b/drivers/net/mlx4/mlx4.h
index 56a2e213fe626870d23211c62916d6610aac5e63..34c909deaff325e9e90573065fa4d4efb45044b8 100644 (file)
--- a/drivers/net/mlx4/mlx4.h
+++ b/drivers/net/mlx4/mlx4.h
@@ -385,5 +385,6 @@ void mlx4_init_mac_table(struct mlx4_dev *dev, struct mlx4_mac_table *table);
 void mlx4_init_vlan_table(struct mlx4_dev *dev, struct mlx4_vlan_table *table);
 
 int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port);
+int mlx4_get_port_ib_caps(struct mlx4_dev *dev, u8 port, __be32 *caps);
 
 #endif /* MLX4_H */

diff --git a/drivers/net/mlx4/port.c b/drivers/net/mlx4/port.c
index e2fdab42c4ceabee3f5eb02c5cd5b53ed8fdce28..0a057e5dc63ba0ed32d0fac4ad6f306d77a8c715 100644 (file)
--- a/drivers/net/mlx4/port.c
+++ b/drivers/net/mlx4/port.c
@@ -258,6 +258,42 @@ out:
 }
 EXPORT_SYMBOL_GPL(mlx4_unregister_vlan);
 
+int mlx4_get_port_ib_caps(struct mlx4_dev *dev, u8 port, __be32 *caps)
+{
+       struct mlx4_cmd_mailbox *inmailbox, *outmailbox;
+       u8 *inbuf, *outbuf;
+       int err;
+
+       inmailbox = mlx4_alloc_cmd_mailbox(dev);
+       if (IS_ERR(inmailbox))
+               return PTR_ERR(inmailbox);
+
+       outmailbox = mlx4_alloc_cmd_mailbox(dev);
+       if (IS_ERR(outmailbox)) {
+               mlx4_free_cmd_mailbox(dev, inmailbox);
+               return PTR_ERR(outmailbox);
+       }
+
+       inbuf = inmailbox->buf;
+       outbuf = outmailbox->buf;
+       memset(inbuf, 0, 256);
+       memset(outbuf, 0, 256);
+       inbuf[0] = 1;
+       inbuf[1] = 1;
+       inbuf[2] = 1;
+       inbuf[3] = 1;
+       *(__be16 *) (&inbuf[16]) = cpu_to_be16(0x0015);
+       *(__be32 *) (&inbuf[20]) = cpu_to_be32(port);
+
+       err = mlx4_cmd_box(dev, inmailbox->dma, outmailbox->dma, port, 3,
+                          MLX4_CMD_MAD_IFC, MLX4_CMD_TIME_CLASS_C);
+       if (!err)
+               *caps = *(__be32 *) (outbuf + 84);
+       mlx4_free_cmd_mailbox(dev, inmailbox);
+       mlx4_free_cmd_mailbox(dev, outmailbox);
+       return err;
+}
+
 int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port)
 {
        struct mlx4_cmd_mailbox *mailbox;
@@ -273,7 +309,8 @@ int mlx4_SET_PORT(struct mlx4_dev *dev, u8 port)
                ((u8 *) mailbox->buf)[3] = 6;
                ((__be16 *) mailbox->buf)[4] = cpu_to_be16(1 << 15);
                ((__be16 *) mailbox->buf)[6] = cpu_to_be16(1 << 15);
-       }
+       } else
+               ((__be32 *) mailbox->buf)[1] = dev->caps.ib_port_def_cap[port];
        err = mlx4_cmd(dev, mailbox->dma, port, is_eth, MLX4_CMD_SET_PORT,
                       MLX4_CMD_TIME_CLASS_B);
 

diff --git a/drivers/sbus/char/bbc_i2c.c b/drivers/sbus/char/bbc_i2c.c
index 054f5dd58931dfb7fcaf68ed89bc29056e1de91c..f08e169ba1b51a150372753672741df102818591 100644 (file)
--- a/drivers/sbus/char/bbc_i2c.c
+++ b/drivers/sbus/char/bbc_i2c.c
@@ -361,7 +361,7 @@ fail:
 extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
 
-static int __init bbc_i2c_probe(struct of_device *op,
+static int __devinit bbc_i2c_probe(struct of_device *op,
                                   const struct of_device_id *match)
 {
        struct bbc_i2c_bus *bp;
@@ -386,7 +386,7 @@ static int __init bbc_i2c_probe(struct of_device *op,
        return err;
 }
 
-static int __exit bbc_i2c_remove(struct of_device *op)
+static int __devexit bbc_i2c_remove(struct of_device *op)
 {
        struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
 
@@ -417,7 +417,7 @@ static struct of_platform_driver bbc_i2c_driver = {
        .name           = "bbc_i2c",
        .match_table    = bbc_i2c_match,
        .probe          = bbc_i2c_probe,
-       .remove         = __exit_p(bbc_i2c_remove),
+       .remove         = __devexit_p(bbc_i2c_remove),
 };
 
 static int __init bbc_i2c_init(void)

diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 1fe8b44787b332c93e4b8261243c08e3816b2d27..b3408ff39fba07d8e289a9d69f28cc2b6b296512 100644 (file)
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -2363,6 +2363,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
                nuke(loop_ep, -ESHUTDOWN);
        spin_unlock_irqrestore(&udc_controller->lock, flags);
 
+       /* report disconnect; the controller is already quiesced */
+       driver->disconnect(&udc_controller->gadget);
+
        /* unbind gadget and unhook driver. */
        driver->unbind(&udc_controller->gadget);
        udc_controller->gadget.dev.driver = NULL;

diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index 091bb55c9aa7abaee80930e9e79bb955a9f47bf3..f3c6703cffda3c700399f8352f2ed5bf76530b6f 100644 (file)
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -1836,6 +1836,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
                nuke(loop_ep, -ESHUTDOWN);
        spin_unlock_irqrestore(&udc_controller->lock, flags);
 
+       /* report disconnect; the controller is already quiesced */
+       driver->disconnect(&udc_controller->gadget);
+
        /* unbind gadget and unhook driver. */
        driver->unbind(&udc_controller->gadget);
        udc_controller->gadget.dev.driver = NULL;

diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 9d0ea573aef60c3e45afb3dec145c5f0f4ed843b..36864f9584445a41cf8bea70155c50b76f888cc2 100644 (file)
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -169,18 +169,21 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                }
                break;
        case PCI_VENDOR_ID_ATI:
-               /* SB700 old version has a bug in EHCI controller,
+               /* SB600 and old version of SB700 have a bug in EHCI controller,
                 * which causes usb devices lose response in some cases.
                 */
-               if (pdev->device == 0x4396) {
+               if ((pdev->device == 0x4386) || (pdev->device == 0x4396)) {
                        p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
                                                 PCI_DEVICE_ID_ATI_SBX00_SMBUS,
                                                 NULL);
                        if (!p_smbus)
                                break;
                        rev = p_smbus->revision;
-                       if ((rev == 0x3a) || (rev == 0x3b)) {
+                       if ((pdev->device == 0x4386) || (rev == 0x3a)
+                           || (rev == 0x3b)) {
                                u8 tmp;
+                               ehci_info(ehci, "applying AMD SB600/SB700 USB "
+                                       "freeze workaround\n");
                                pci_read_config_byte(pdev, 0x53, &tmp);
                                pci_write_config_byte(pdev, 0x53, tmp | (1<<3));
                        }

diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index b11798d17ae56f1e69233db67e916e681b9351eb..c7d4b5a06bdb049e424228560a9d0b51f4baf7fd 100644 (file)
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -183,16 +183,14 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
         * the async ring; just the I/O watchdog.  Note that if a
         * SHRINK were pending, OFF would never be requested.
         */
-       enum ehci_timer_action oldactions = ehci->actions;
+       if (timer_pending(&ehci->watchdog)
+                       && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                               & ehci->actions))
+               return;
 
        if (!test_and_set_bit (action, &ehci->actions)) {
                unsigned long t;
 
-               if (timer_pending(&ehci->watchdog)
-                       && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
-                               & oldactions))
-                       return;
-
                switch (action) {
                case TIMER_IO_WATCHDOG:
                        t = EHCI_IO_JIFFIES;
@@ -208,7 +206,7 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
                        break;
                }
-               mod_timer(&ehci->watchdog, round_jiffies(t + jiffies));
+               mod_timer(&ehci->watchdog, t + jiffies);
        }
 }
 

diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 5b20de130e08399045e3134dff18bfb8543af5f4..5b95009d2fbb104d28065010dc857da2eace6c42 100644 (file)
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -135,6 +135,7 @@ static int usb_console_setup(struct console *co, char *options)
                                err("no more memory");
                                goto reset_open_count;
                        }
+                       kref_init(&tty->kref);
                        termios = kzalloc(sizeof(*termios), GFP_KERNEL);
                        if (!termios) {
                                retval = -ENOMEM;

diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 6fa1ec441b618d12575adf9bec5ee67a327fde6f..809697b3c7fcbed04a9d3a4e2eeac5d412a92adc 100644 (file)
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -224,6 +224,7 @@ static int  option_send_setup(struct tty_struct *tty, struct usb_serial_port *po
 #define ONDA_VENDOR_ID                         0x19d2
 #define ONDA_PRODUCT_MSA501HS                  0x0001
 #define ONDA_PRODUCT_ET502HS                   0x0002
+#define ONDA_PRODUCT_MT503HS                   0x0200
 
 #define BANDRICH_VENDOR_ID                     0x1A8D
 #define BANDRICH_PRODUCT_C100_1                        0x1002
@@ -413,6 +414,40 @@ static struct usb_device_id option_ids[] = {
        { USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
        { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_MSA501HS) },
        { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_ET502HS) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0003) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0004) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0005) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0006) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0007) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0008) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0009) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000a) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000b) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000c) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000d) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000e) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x000f) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0010) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0011) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0012) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0013) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0014) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0015) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0016) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0017) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0018) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0019) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0020) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0021) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0022) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0023) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0024) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0025) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0026) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0027) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0028) },
+       { USB_DEVICE(ONDA_VENDOR_ID, 0x0029) },
+       { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_MT503HS) },
        { USB_DEVICE(YISO_VENDOR_ID, YISO_PRODUCT_U893) },
        { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
        { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },

diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 6da9a7a962a8a2790b30dd3f25fa952aec763ec8..e61f2bfc64add77ab938367c45c08db542c589e0 100644 (file)
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -318,6 +318,18 @@ UNUSUAL_DEV(  0x045a, 0x5210, 0x0101, 0x0101,
                US_SC_SCSI, US_PR_KARMA, rio_karma_init, 0),
 #endif
 
+/* Reported by Tamas Kerecsen <kerecsen@bigfoot.com>
+ * Obviously the PROM has not been customized by the VAR;
+ * the Vendor and Product string descriptors are:
+ *     Generic Mass Storage (PROTOTYPE--Remember to change idVendor)
+ *     Generic Manufacturer (PROTOTYPE--Remember to change idVendor)
+ */
+UNUSUAL_DEV(  0x045e, 0xffff, 0x0000, 0x0000,
+               "Mitac",
+               "GPS",
+               US_SC_DEVICE, US_PR_DEVICE, NULL,
+               US_FL_MAX_SECTORS_64 ),
+
 /*
  * This virtual floppy is found in Sun equipment (x4600, x4200m2, etc.)
  * Reported by Pete Zaitcev <zaitcev@redhat.com>
@@ -377,6 +389,13 @@ UNUSUAL_DEV(  0x04b0, 0x0401, 0x0200, 0x0200,
                US_SC_DEVICE, US_PR_DEVICE, NULL,
                US_FL_FIX_CAPACITY),
 
+/* Reported by Tobias Kunze Briseno <t-linux@fictive.com> */
+UNUSUAL_DEV(  0x04b0, 0x0403, 0x0200, 0x0200,
+               "NIKON",
+               "NIKON DSC D2H",
+               US_SC_DEVICE, US_PR_DEVICE, NULL,
+               US_FL_FIX_CAPACITY),
+
 /* Reported by Milinevsky Dmitry <niam.niam@gmail.com> */
 UNUSUAL_DEV(  0x04b0, 0x0409, 0x0100, 0x0100,
                "NIKON",

diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index bd9977b894907f294b06817a01a42b3c29dd25bc..371086fd946f3f13a7cbeecab10354caae5cb15f 100644 (file)
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -179,6 +179,7 @@ struct mlx4_caps {
        int                     num_ports;
        int                     vl_cap[MLX4_MAX_PORTS + 1];
        int                     ib_mtu_cap[MLX4_MAX_PORTS + 1];
+       __be32                  ib_port_def_cap[MLX4_MAX_PORTS + 1];
        u64                     def_mac[MLX4_MAX_PORTS + 1];
        int                     eth_mtu_cap[MLX4_MAX_PORTS + 1];
        int                     gid_table_len[MLX4_MAX_PORTS + 1];

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 7ea1440b53db23350112cb1a46c592542807e4ac..62e7f62fb559c7a09b5b15b4d7a0b3a7b5b4c5e5 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1248,6 +1248,7 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
                list_add(&page->lru, &l_inactive);
        }
 
+       spin_lock_irq(&zone->lru_lock);
        /*
         * Count referenced pages from currently used mappings as
         * rotated, even though they are moved to the inactive list.
@@ -1263,7 +1264,6 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
 
        pgmoved = 0;
        lru = LRU_BASE + file * LRU_FILE;
-       spin_lock_irq(&zone->lru_lock);
        while (!list_empty(&l_inactive)) {
                page = lru_to_page(&l_inactive);
                prefetchw_prev_lru_page(page, &l_inactive, flags);

diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index 6c427bbac3269edc98e552e43f7490b96edf1aef..d44bf98e965e6a5bd020f6d085dbcc2b763db670 100644 (file)
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -1856,7 +1856,7 @@ static int __init snd_cs4231_sbus_create(struct snd_card *card,
        return 0;
 }
 
-static int __init cs4231_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
        struct resource *rp = &op->resource[0];
        struct snd_card *card;
@@ -2048,7 +2048,7 @@ static int __init snd_cs4231_ebus_create(struct snd_card *card,
        return 0;
 }
 
-static int __init cs4231_ebus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_device_id *match)
 {
        struct snd_card *card;
        int err;
@@ -2072,7 +2072,7 @@ static int __init cs4231_ebus_probe(struct of_device *op, const struct of_device
 }
 #endif
 
-static int __init cs4231_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_probe(struct of_device *op, const struct of_device_id *match)
 {
 #ifdef EBUS_SUPPORT
        if (!strcmp(op->node->parent->name, "ebus"))
@@ -2086,7 +2086,7 @@ static int __init cs4231_probe(struct of_device *op, const struct of_device_id *
        return -ENODEV;
 }
 
-static int __exit cs4231_remove(struct of_device *op)
+static int __devexit cs4231_remove(struct of_device *op)
 {
        struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
 
@@ -2112,7 +2112,7 @@ static struct of_platform_driver cs4231_driver = {
        .name           = "audio",
        .match_table    = cs4231_match,
        .probe          = cs4231_probe,
-       .remove         = __exit_p(cs4231_remove),
+       .remove         = __devexit_p(cs4231_remove),
 };
 
 static int __init cs4231_init(void)