Merge master.kernel.org:/home/rmk/linux-2.6-arm
authorLinus Torvalds <torvalds@linux-foundation.org>
Fri, 29 May 2009 23:07:39 +0000 (16:07 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Fri, 29 May 2009 23:07:39 +0000 (16:07 -0700)
* master.kernel.org:/home/rmk/linux-2.6-arm:
  [ARM] update mach-types
  [ARM] Add cmpxchg support for ARMv6+ systems (v5)
  [ARM] barriers: improve xchg, bitops and atomic SMP barriers
  Gemini: Fix SRAM/ROM location after memory swap
  MAINTAINER: Add F: entries for Gemini and FA526
  [ARM] disable NX support for OABI-supporting kernels
  [ARM] add coherent DMA mask for mv643xx_eth
  [ARM] pxa/palm: fix PalmLD/T5/TX AC97 MFP
  [ARM] pxa: add parameter to clksrc_read() for pxa168/910
  [ARM] pxa: fix the incorrectly defined drive strength macros for pxa{168,910}
  [ARM] Orion: Remove explicit name for platform device resources
  [ARM] Kirkwood: Correct MPP for SATA activity/presence LEDs of QNAP TS-119/TS-219.
  [ARM] pxa/ezx: fix pin configuration for low power mode
  [ARM] pxa/spitz: provide spitz_ohci_exit() that unregisters USB_HOST GPIO
  [ARM] pxa: enable GPIO receivers after configuring pins
  [ARM] pxa: allow gpio_reset drive high during normal work
  [ARM] pxa: save/restore PGSR on suspend/resume.

62 files changed:
Documentation/input/multi-touch-protocol.txt
Documentation/sound/alsa/Procfile.txt
MAINTAINERS
arch/arm/include/asm/flat.h
arch/blackfin/include/asm/flat.h
arch/h8300/include/asm/flat.h
arch/m32r/include/asm/flat.h
arch/m68k/include/asm/flat.h
arch/sh/include/asm/flat.h
arch/x86/mm/hugetlbpage.c
drivers/base/bus.c
drivers/base/core.c
drivers/base/driver.c
drivers/edac/Kconfig
drivers/edac/Makefile
drivers/edac/amd8111_edac.c
drivers/edac/amd8131_edac.c
drivers/gpu/drm/i915/i915_gem.c
drivers/gpu/drm/i915/i915_gem_tiling.c
drivers/gpu/drm/i915/i915_reg.h
drivers/input/input.c
drivers/input/serio/libps2.c
drivers/input/touchscreen/ucb1400_ts.c
drivers/mtd/nand/mxc_nand.c
drivers/parport/parport_gsc.c
drivers/pci/hotplug/acpiphp.h
drivers/pci/hotplug/acpiphp_glue.c
drivers/serial/8250.c
drivers/serial/8250_gsc.c
drivers/serial/mpc52xx_uart.c
drivers/usb/Makefile
drivers/usb/class/cdc-acm.c
drivers/usb/gadget/atmel_usba_udc.c
drivers/usb/host/isp1760-hcd.c
drivers/usb/serial/usb-serial.c
drivers/video/atmel_lcdfb.c
drivers/video/s3c-fb.c
fs/binfmt_flat.c
fs/jffs2/erase.c
fs/nfsd/vfs.c
fs/proc/base.c
fs/sysfs/file.c
include/linux/cred.h
include/linux/input.h
include/linux/swap.h
mm/filemap.c
mm/hugetlb.c
mm/memcontrol.c
mm/oom_kill.c
mm/swap_state.c
mm/truncate.c
mm/vmscan.c
net/sunrpc/svcsock.c
net/sunrpc/xprtrdma/svc_rdma_sendto.c
net/sunrpc/xprtrdma/svc_rdma_transport.c
sound/core/pcm_lib.c
sound/core/pcm_native.c
sound/pci/hda/patch_conexant.c
sound/usb/usbaudio.c
sound/usb/usbaudio.h
sound/usb/usbmidi.c
sound/usb/usbquirks.h

index 9f09557aea39c5e80b6b9810ab170fddd32b1c91..a12ea3b586e6e15ecb66322c78bf5d6cb3e03f79 100644 (file)
@@ -18,8 +18,12 @@ Usage
 Anonymous finger details are sent sequentially as separate packets of ABS
 events. Only the ABS_MT events are recognized as part of a finger
 packet. The end of a packet is marked by calling the input_mt_sync()
-function, which generates a SYN_MT_REPORT event. The end of multi-touch
-transfer is marked by calling the usual input_sync() function.
+function, which generates a SYN_MT_REPORT event. This instructs the
+receiver to accept the data for the current finger and prepare to receive
+another. The end of a multi-touch transfer is marked by calling the usual
+input_sync() function. This instructs the receiver to act upon events
+accumulated since last EV_SYN/SYN_REPORT and prepare to receive a new
+set of events/packets.
 
 A set of ABS_MT events with the desired properties is defined. The events
 are divided into categories, to allow for partial implementation.  The
@@ -27,11 +31,26 @@ minimum set consists of ABS_MT_TOUCH_MAJOR, ABS_MT_POSITION_X and
 ABS_MT_POSITION_Y, which allows for multiple fingers to be tracked.  If the
 device supports it, the ABS_MT_WIDTH_MAJOR may be used to provide the size
 of the approaching finger. Anisotropy and direction may be specified with
-ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MINOR and ABS_MT_ORIENTATION. Devices with
-more granular information may specify general shapes as blobs, i.e., as a
-sequence of rectangular shapes grouped together by an
-ABS_MT_BLOB_ID. Finally, the ABS_MT_TOOL_TYPE may be used to specify
-whether the touching tool is a finger or a pen or something else.
+ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MINOR and ABS_MT_ORIENTATION.  The
+ABS_MT_TOOL_TYPE may be used to specify whether the touching tool is a
+finger or a pen or something else.  Devices with more granular information
+may specify general shapes as blobs, i.e., as a sequence of rectangular
+shapes grouped together by an ABS_MT_BLOB_ID. Finally, for the few devices
+that currently support it, the ABS_MT_TRACKING_ID event may be used to
+report finger tracking from hardware [5].
+
+Here is what a minimal event sequence for a two-finger touch would look
+like:
+
+   ABS_MT_TOUCH_MAJOR
+   ABS_MT_POSITION_X
+   ABS_MT_POSITION_Y
+   SYN_MT_REPORT
+   ABS_MT_TOUCH_MAJOR
+   ABS_MT_POSITION_X
+   ABS_MT_POSITION_Y
+   SYN_MT_REPORT
+   SYN_REPORT
 
 
 Event Semantics
@@ -44,24 +63,24 @@ ABS_MT_TOUCH_MAJOR
 
 The length of the major axis of the contact. The length should be given in
 surface units. If the surface has an X times Y resolution, the largest
-possible value of ABS_MT_TOUCH_MAJOR is sqrt(X^2 + Y^2), the diagonal.
+possible value of ABS_MT_TOUCH_MAJOR is sqrt(X^2 + Y^2), the diagonal [4].
 
 ABS_MT_TOUCH_MINOR
 
 The length, in surface units, of the minor axis of the contact. If the
-contact is circular, this event can be omitted.
+contact is circular, this event can be omitted [4].
 
 ABS_MT_WIDTH_MAJOR
 
 The length, in surface units, of the major axis of the approaching
 tool. This should be understood as the size of the tool itself. The
 orientation of the contact and the approaching tool are assumed to be the
-same.
+same [4].
 
 ABS_MT_WIDTH_MINOR
 
 The length, in surface units, of the minor axis of the approaching
-tool. Omit if circular.
+tool. Omit if circular [4].
 
 The above four values can be used to derive additional information about
 the contact. The ratio ABS_MT_TOUCH_MAJOR / ABS_MT_WIDTH_MAJOR approximates
@@ -70,14 +89,17 @@ different characteristic widths [1].
 
 ABS_MT_ORIENTATION
 
-The orientation of the ellipse. The value should describe half a revolution
-clockwise around the touch center. The scale of the value is arbitrary, but
-zero should be returned for an ellipse aligned along the Y axis of the
-surface. As an example, an index finger placed straight onto the axis could
-return zero orientation, something negative when twisted to the left, and
-something positive when twisted to the right. This value can be omitted if
-the touching object is circular, or if the information is not available in
-the kernel driver.
+The orientation of the ellipse. The value should describe a signed quarter
+of a revolution clockwise around the touch center. The signed value range
+is arbitrary, but zero should be returned for a finger aligned along the Y
+axis of the surface, a negative value when finger is turned to the left, and
+a positive value when finger turned to the right. When completely aligned with
+the X axis, the range max should be returned.  Orientation can be omitted
+if the touching object is circular, or if the information is not available
+in the kernel driver. Partial orientation support is possible if the device
+can distinguish between the two axis, but not (uniquely) any values in
+between. In such cases, the range of ABS_MT_ORIENTATION should be [0, 1]
+[4].
 
 ABS_MT_POSITION_X
 
@@ -98,8 +120,35 @@ ABS_MT_BLOB_ID
 
 The BLOB_ID groups several packets together into one arbitrarily shaped
 contact. This is a low-level anonymous grouping, and should not be confused
-with the high-level contactID, explained below. Most kernel drivers will
-not have this capability, and can safely omit the event.
+with the high-level trackingID [5]. Most kernel drivers will not have blob
+capability, and can safely omit the event.
+
+ABS_MT_TRACKING_ID
+
+The TRACKING_ID identifies an initiated contact throughout its life cycle
+[5]. There are currently only a few devices that support it, so this event
+should normally be omitted.
+
+
+Event Computation
+-----------------
+
+The flora of different hardware unavoidably leads to some devices fitting
+better to the MT protocol than others. To simplify and unify the mapping,
+this section gives recipes for how to compute certain events.
+
+For devices reporting contacts as rectangular shapes, signed orientation
+cannot be obtained. Assuming X and Y are the lengths of the sides of the
+touching rectangle, here is a simple formula that retains the most
+information possible:
+
+   ABS_MT_TOUCH_MAJOR := max(X, Y)
+   ABS_MT_TOUCH_MINOR := min(X, Y)
+   ABS_MT_ORIENTATION := bool(X > Y)
+
+The range of ABS_MT_ORIENTATION should be set to [0, 1], to indicate that
+the device can distinguish between a finger along the Y axis (0) and a
+finger along the X axis (1).
 
 
 Finger Tracking
@@ -109,14 +158,18 @@ The kernel driver should generate an arbitrary enumeration of the set of
 anonymous contacts currently on the surface. The order in which the packets
 appear in the event stream is not important.
 
-The process of finger tracking, i.e., to assign a unique contactID to each
+The process of finger tracking, i.e., to assign a unique trackingID to each
 initiated contact on the surface, is left to user space; preferably the
-multi-touch X driver [3]. In that driver, the contactID stays the same and
+multi-touch X driver [3]. In that driver, the trackingID stays the same and
 unique until the contact vanishes (when the finger leaves the surface). The
 problem of assigning a set of anonymous fingers to a set of identified
 fingers is a euclidian bipartite matching problem at each event update, and
 relies on a sufficiently rapid update rate.
 
+There are a few devices that support trackingID in hardware. User space can
+make use of these native identifiers to reduce bandwidth and cpu usage.
+
+
 Notes
 -----
 
@@ -136,5 +189,7 @@ could be used to derive tilt.
 time of writing (April 2009), the MT protocol is not yet merged, and the
 prototype implements finger matching, basic mouse support and two-finger
 scrolling. The project aims at improving the quality of current multi-touch
-functionality available in the synaptics X driver, and in addition
+functionality available in the Synaptics X driver, and in addition
 implement more advanced gestures.
+[4] See the section on event computation.
+[5] See the section on finger tracking.
index bba2dbb79d81c10d71bbc5b0879f6d3745d1543d..cfac20cf9e33fa150a6cf69f4e6d624e8116caa9 100644 (file)
@@ -104,6 +104,11 @@ card*/pcm*/xrun_debug
        When this value is greater than 1, the driver will show the
        stack trace additionally.  This may help the debugging.
 
+       Since 2.6.30, this option also enables the hwptr check using
+       jiffies.  This detects spontaneous invalid pointer callback
+       values, but can be lead to too much corrections for a (mostly
+       buggy) hardware that doesn't give smooth pointer updates.
+
 card*/pcm*/sub*/info
        The general information of this PCM sub-stream.
 
index 42c53ab6b9faa4320ee0c829e5590e883b9b8bb1..196f72d241d04244d75052776d40a171d9354d63 100644 (file)
@@ -434,7 +434,7 @@ F:  arch/alpha/
 
 AMD GEODE CS5536 USB DEVICE CONTROLLER DRIVER
 P:     Thomas Dahlmann
-M:     thomas.dahlmann@amd.com
+M:     dahlmann.thomas@arcor.de
 L:     linux-geode@lists.infradead.org (moderated for non-subscribers)
 S:     Supported
 F:     drivers/usb/gadget/amd5536udc.*
@@ -1973,8 +1973,8 @@ F:        include/linux/edac.h
 
 EDAC-E752X
 P:     Mark Gross
-P:     Doug Thompson
 M:     mark.gross@intel.com
+P:     Doug Thompson
 M:     dougthompson@xmission.com
 L:     bluesmoke-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:     bluesmoke.sourceforge.net
index 1d77e51907f6ddb70f5aa8123583827bffaa676c..59426a4595c9cb90bcb765843f89295bd20f6797 100644 (file)
@@ -5,9 +5,6 @@
 #ifndef __ARM_FLAT_H__
 #define __ARM_FLAT_H__
 
-/* An odd number of words will be pushed after this alignment, so
-   deliberately misalign the value.  */
-#define        flat_stack_align(sp)    sp = (void *)(((unsigned long)(sp) - 4) | 4)
 #define        flat_argvp_envp_on_stack()              1
 #define        flat_old_ram_flag(flags)                (flags)
 #define        flat_reloc_valid(reloc, size)           ((reloc) <= (size))
index e70074e05f4ef095e33beb1cf28ede8ae817f980..733a178d782d0dd8e77e2c619f7b67d3271d2500 100644 (file)
@@ -10,7 +10,6 @@
 
 #include <asm/unaligned.h>
 
-#define        flat_stack_align(sp)    /* nothing needed */
 #define        flat_argvp_envp_on_stack()              0
 #define        flat_old_ram_flag(flags)                (flags)
 
index 2a873508a9a101b359483ebbf086f84aa769f0f0..bd12b31b90e60b3df56b0d8080e4bd86df98ce79 100644 (file)
@@ -5,7 +5,6 @@
 #ifndef __H8300_FLAT_H__
 #define __H8300_FLAT_H__
 
-#define        flat_stack_align(sp)                    /* nothing needed */
 #define        flat_argvp_envp_on_stack()              1
 #define        flat_old_ram_flag(flags)                1
 #define        flat_reloc_valid(reloc, size)           ((reloc) <= (size))
index d851cf0c4aa5ecff7902da7a54fdab618eccdad4..5d711c4688fb9f8162fd017a7e35451ad4c41da6 100644 (file)
@@ -12,7 +12,6 @@
 #ifndef __ASM_M32R_FLAT_H
 #define __ASM_M32R_FLAT_H
 
-#define        flat_stack_align(sp)            (*sp += (*sp & 3 ? (4 - (*sp & 3)): 0))
 #define        flat_argvp_envp_on_stack()              0
 #define        flat_old_ram_flag(flags)                (flags)
 #define        flat_set_persistent(relval, p)          0
index 814b5174a8e0ffb623aa96e65f9b2a1b52a4ddad..a0e290793978b35dd89586eba50c4e1f7950f1ca 100644 (file)
@@ -5,7 +5,6 @@
 #ifndef __M68KNOMMU_FLAT_H__
 #define __M68KNOMMU_FLAT_H__
 
-#define        flat_stack_align(sp)                    /* nothing needed */
 #define        flat_argvp_envp_on_stack()              1
 #define        flat_old_ram_flag(flags)                (flags)
 #define        flat_reloc_valid(reloc, size)           ((reloc) <= (size))
index d3b2b4f109e36ec68a61c7244ef7d4d48e9c335f..5d84df5e27f658972bf9b3acc3c9dd2267bf0176 100644 (file)
@@ -12,7 +12,6 @@
 #ifndef __ASM_SH_FLAT_H
 #define __ASM_SH_FLAT_H
 
-#define        flat_stack_align(sp)                    /* nothing needed */
 #define        flat_argvp_envp_on_stack()              0
 #define        flat_old_ram_flag(flags)                (flags)
 #define        flat_reloc_valid(reloc, size)           ((reloc) <= (size))
index 8f307d914c2ec860c3b9093796362e9c4719ab41..f46c340727b8be21fb8270618ff9d03962667409 100644 (file)
@@ -26,12 +26,16 @@ static unsigned long page_table_shareable(struct vm_area_struct *svma,
        unsigned long sbase = saddr & PUD_MASK;
        unsigned long s_end = sbase + PUD_SIZE;
 
+       /* Allow segments to share if only one is marked locked */
+       unsigned long vm_flags = vma->vm_flags & ~VM_LOCKED;
+       unsigned long svm_flags = svma->vm_flags & ~VM_LOCKED;
+
        /*
         * match the virtual addresses, permission and the alignment of the
         * page table page.
         */
        if (pmd_index(addr) != pmd_index(saddr) ||
-           vma->vm_flags != svma->vm_flags ||
+           vm_flags != svm_flags ||
            sbase < svma->vm_start || svma->vm_end < s_end)
                return 0;
 
index dc030f1f00f19706a4c5e5d0a077a085b0885187..c6599618523e7fc265daf265880c9c1e7c0fe056 100644 (file)
@@ -700,8 +700,10 @@ int bus_add_driver(struct device_driver *drv)
        }
 
        kobject_uevent(&priv->kobj, KOBJ_ADD);
-       return error;
+       return 0;
 out_unregister:
+       kfree(drv->p);
+       drv->p = NULL;
        kobject_put(&priv->kobj);
 out_put_bus:
        bus_put(bus);
index 4aa527b8a91381289eb175b33f46e3e418d10374..1977d4beb89e0012290a567c850f6a59dd3da1b0 100644 (file)
@@ -879,7 +879,7 @@ int device_add(struct device *dev)
        }
 
        if (!dev_name(dev))
-               goto done;
+               goto name_error;
 
        pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 
@@ -978,6 +978,9 @@ done:
        cleanup_device_parent(dev);
        if (parent)
                put_device(parent);
+name_error:
+       kfree(dev->p);
+       dev->p = NULL;
        goto done;
 }
 
index c51f11bb29ae2bdd0a13077147e6db357da8be27..8ae0f63602e0730a71647cb571cbf933d76ceec8 100644 (file)
@@ -257,6 +257,10 @@ EXPORT_SYMBOL_GPL(driver_register);
  */
 void driver_unregister(struct device_driver *drv)
 {
+       if (!drv || !drv->p) {
+               WARN(1, "Unexpected driver unregister!\n");
+               return;
+       }
        driver_remove_groups(drv, drv->groups);
        bus_remove_driver(drv);
 }
index e5f5c5a8ba6c9bf61616a01afde3bbfe22ac25c1..956982f8739b372d05c1f3dec73ad4735884b0e0 100644 (file)
@@ -192,16 +192,20 @@ config EDAC_PPC4XX
 
 config EDAC_AMD8131
        tristate "AMD8131 HyperTransport PCI-X Tunnel"
-       depends on EDAC_MM_EDAC && PCI
+       depends on EDAC_MM_EDAC && PCI && PPC_MAPLE
        help
          Support for error detection and correction on the
          AMD8131 HyperTransport PCI-X Tunnel chip.
+         Note, add more Kconfig dependency if it's adopted
+         on some machine other than Maple.
 
 config EDAC_AMD8111
        tristate "AMD8111 HyperTransport I/O Hub"
-       depends on EDAC_MM_EDAC && PCI
+       depends on EDAC_MM_EDAC && PCI && PPC_MAPLE
        help
          Support for error detection and correction on the
          AMD8111 HyperTransport I/O Hub chip.
+         Note, add more Kconfig dependency if it's adopted
+         on some machine other than Maple.
 
 endif # EDAC
index a5fdcf02f591d586a33c37bd1d9337798d99bd42..59076819135d2bca280f0b60ead4a1160177d549 100644 (file)
@@ -35,3 +35,5 @@ obj-$(CONFIG_EDAC_MPC85XX)            += mpc85xx_edac.o
 obj-$(CONFIG_EDAC_MV64X60)             += mv64x60_edac.o
 obj-$(CONFIG_EDAC_CELL)                        += cell_edac.o
 obj-$(CONFIG_EDAC_PPC4XX)              += ppc4xx_edac.o
+obj-$(CONFIG_EDAC_AMD8111)             += amd8111_edac.o
+obj-$(CONFIG_EDAC_AMD8131)             += amd8131_edac.o
index 614692181120b86a1106e9f5906a961601377bcf..2cb58ef743e03b79cc2e9d35460699f644e69d56 100644 (file)
@@ -389,7 +389,7 @@ static int amd8111_dev_probe(struct pci_dev *dev,
        dev_info->edac_dev->dev = &dev_info->dev->dev;
        dev_info->edac_dev->mod_name = AMD8111_EDAC_MOD_STR;
        dev_info->edac_dev->ctl_name = dev_info->ctl_name;
-       dev_info->edac_dev->dev_name = dev_info->dev->dev.bus_id;
+       dev_info->edac_dev->dev_name = dev_name(&dev_info->dev->dev);
 
        if (edac_op_state == EDAC_OPSTATE_POLL)
                dev_info->edac_dev->edac_check = dev_info->check;
@@ -473,7 +473,7 @@ static int amd8111_pci_probe(struct pci_dev *dev,
        pci_info->edac_dev->dev = &pci_info->dev->dev;
        pci_info->edac_dev->mod_name = AMD8111_EDAC_MOD_STR;
        pci_info->edac_dev->ctl_name = pci_info->ctl_name;
-       pci_info->edac_dev->dev_name = pci_info->dev->dev.bus_id;
+       pci_info->edac_dev->dev_name = dev_name(&pci_info->dev->dev);
 
        if (edac_op_state == EDAC_OPSTATE_POLL)
                pci_info->edac_dev->edac_check = pci_info->check;
index c083b31cac5a40c19a5393b15414267933e863a8..b432d60c622a5bc52f951bde2983d0e325bea2b4 100644 (file)
@@ -287,7 +287,7 @@ static int amd8131_probe(struct pci_dev *dev, const struct pci_device_id *id)
        dev_info->edac_dev->dev = &dev_info->dev->dev;
        dev_info->edac_dev->mod_name = AMD8131_EDAC_MOD_STR;
        dev_info->edac_dev->ctl_name = dev_info->ctl_name;
-       dev_info->edac_dev->dev_name = dev_info->dev->dev.bus_id;
+       dev_info->edac_dev->dev_name = dev_name(&dev_info->dev->dev);
 
        if (edac_op_state == EDAC_OPSTATE_POLL)
                dev_info->edac_dev->edac_check = amd8131_chipset.check;
index 717b6a854bcdf75f0f1d68459d33c32b8c626663..670d12881468297e8e0af0fe40222c3f54f5cb2f 100644 (file)
@@ -1145,6 +1145,13 @@ int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
                        mutex_unlock(&dev->struct_mutex);
                        return VM_FAULT_SIGBUS;
                }
+
+               ret = i915_gem_object_set_to_gtt_domain(obj, write);
+               if (ret) {
+                       mutex_unlock(&dev->struct_mutex);
+                       return VM_FAULT_SIGBUS;
+               }
+
                list_add_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
        }
 
@@ -2128,8 +2135,10 @@ static void i830_write_fence_reg(struct drm_i915_fence_reg *reg)
                return;
        }
 
-       pitch_val = (obj_priv->stride / 128) - 1;
-       WARN_ON(pitch_val & ~0x0000000f);
+       pitch_val = obj_priv->stride / 128;
+       pitch_val = ffs(pitch_val) - 1;
+       WARN_ON(pitch_val > I830_FENCE_MAX_PITCH_VAL);
+
        val = obj_priv->gtt_offset;
        if (obj_priv->tiling_mode == I915_TILING_Y)
                val |= 1 << I830_FENCE_TILING_Y_SHIFT;
@@ -2421,6 +2430,16 @@ i915_gem_clflush_object(struct drm_gem_object *obj)
        if (obj_priv->pages == NULL)
                return;
 
+       /* XXX: The 865 in particular appears to be weird in how it handles
+        * cache flushing.  We haven't figured it out, but the
+        * clflush+agp_chipset_flush doesn't appear to successfully get the
+        * data visible to the PGU, while wbinvd + agp_chipset_flush does.
+        */
+       if (IS_I865G(obj->dev)) {
+               wbinvd();
+               return;
+       }
+
        drm_clflush_pages(obj_priv->pages, obj->size / PAGE_SIZE);
 }
 
index 52a059354e83a7397c96dd8401434e6134cceee5..540dd336e6ec682ade96cc0c56f9f7078a2e97ac 100644 (file)
@@ -213,7 +213,8 @@ i915_tiling_ok(struct drm_device *dev, int stride, int size, int tiling_mode)
        if (tiling_mode == I915_TILING_NONE)
                return true;
 
-       if (tiling_mode == I915_TILING_Y && HAS_128_BYTE_Y_TILING(dev))
+       if (!IS_I9XX(dev) ||
+           (tiling_mode == I915_TILING_Y && HAS_128_BYTE_Y_TILING(dev)))
                tile_width = 128;
        else
                tile_width = 512;
@@ -225,11 +226,18 @@ i915_tiling_ok(struct drm_device *dev, int stride, int size, int tiling_mode)
                if (stride / 128 > I965_FENCE_MAX_PITCH_VAL)
                        return false;
        } else if (IS_I9XX(dev)) {
-               if (stride / tile_width > I830_FENCE_MAX_PITCH_VAL ||
+               uint32_t pitch_val = ffs(stride / tile_width) - 1;
+
+               /* XXX: For Y tiling, FENCE_MAX_PITCH_VAL is actually 6 (8KB)
+                * instead of 4 (2KB) on 945s.
+                */
+               if (pitch_val > I915_FENCE_MAX_PITCH_VAL ||
                    size > (I830_FENCE_MAX_SIZE_VAL << 20))
                        return false;
        } else {
-               if (stride / 128 > I830_FENCE_MAX_PITCH_VAL ||
+               uint32_t pitch_val = ffs(stride / tile_width) - 1;
+
+               if (pitch_val > I830_FENCE_MAX_PITCH_VAL ||
                    size > (I830_FENCE_MAX_SIZE_VAL << 19))
                        return false;
        }
index 9668cc0d7f4ec07da42c96a1d9f0741d4eb7f1da..375569d01d011fc00be4b94dbae0db06668af6de 100644 (file)
 #define   I830_FENCE_SIZE_BITS(size)   ((ffs((size) >> 19) - 1) << 8)
 #define   I830_FENCE_PITCH_SHIFT       4
 #define   I830_FENCE_REG_VALID         (1<<0)
-#define   I830_FENCE_MAX_PITCH_VAL     0x10
+#define   I915_FENCE_MAX_PITCH_VAL     0x10
+#define   I830_FENCE_MAX_PITCH_VAL     6
 #define   I830_FENCE_MAX_SIZE_VAL      (1<<8)
 
 #define   I915_FENCE_START_MASK                0x0ff00000
index e54e002665b0c7d697ae9dc5cc0750747bde9069..5d445f48789b899528c1f30d1f1115f324d553a5 100644 (file)
@@ -42,6 +42,7 @@ static unsigned int input_abs_bypass_init_data[] __initdata = {
        ABS_MT_POSITION_Y,
        ABS_MT_TOOL_TYPE,
        ABS_MT_BLOB_ID,
+       ABS_MT_TRACKING_ID,
        0
 };
 static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
index 67248c31e19a06ab17ba7980bfd3c04fb54d7a52..be5bbbb8ae4ee5105439fc074af9a779654920eb 100644 (file)
@@ -210,7 +210,7 @@ int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
        timeout = wait_event_timeout(ps2dev->wait,
                                     !(ps2dev->flags & PS2_FLAG_CMD1), timeout);
 
-       if (ps2dev->cmdcnt && timeout > 0) {
+       if (ps2dev->cmdcnt && !(ps2dev->flags & PS2_FLAG_CMD1)) {
 
                timeout = ps2_adjust_timeout(ps2dev, command, timeout);
                wait_event_timeout(ps2dev->wait,
index f100c7f4c1dbf2ea72ad771f0775e39d666dd3ed..6954f55001080d29b337a37c9398b6c8f867ec1a 100644 (file)
@@ -419,7 +419,7 @@ static int ucb1400_ts_remove(struct platform_device *dev)
 #ifdef CONFIG_PM
 static int ucb1400_ts_resume(struct platform_device *dev)
 {
-       struct ucb1400_ts *ucb = platform_get_drvdata(dev);
+       struct ucb1400_ts *ucb = dev->dev.platform_data;
 
        if (ucb->ts_task) {
                /*
index f3548d0480142cb5fa8c5e599ff3b8add7b91e97..40c26080ecdaab563e8cacfd63e716d7f34f172f 100644 (file)
@@ -831,6 +831,7 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                break;
 
        case NAND_CMD_READID:
+               host->col_addr = 0;
                send_read_id(host);
                break;
 
@@ -867,6 +868,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
        mtd->priv = this;
        mtd->owner = THIS_MODULE;
        mtd->dev.parent = &pdev->dev;
+       mtd->name = "mxc_nand";
 
        /* 50 us command delay time */
        this->chip_delay = 5;
@@ -882,8 +884,10 @@ static int __init mxcnd_probe(struct platform_device *pdev)
        this->verify_buf = mxc_nand_verify_buf;
 
        host->clk = clk_get(&pdev->dev, "nfc");
-       if (IS_ERR(host->clk))
+       if (IS_ERR(host->clk)) {
+               err = PTR_ERR(host->clk);
                goto eclk;
+       }
 
        clk_enable(host->clk);
        host->clk_act = 1;
@@ -896,7 +900,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
 
        host->regs = ioremap(res->start, res->end - res->start + 1);
        if (!host->regs) {
-               err = -EIO;
+               err = -ENOMEM;
                goto eres;
        }
 
@@ -1011,30 +1015,35 @@ static int __devexit mxcnd_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int mxcnd_suspend(struct platform_device *pdev, pm_message_t state)
 {
-       struct mtd_info *info = platform_get_drvdata(pdev);
+       struct mtd_info *mtd = platform_get_drvdata(pdev);
+       struct nand_chip *nand_chip = mtd->priv;
+       struct mxc_nand_host *host = nand_chip->priv;
        int ret = 0;
 
        DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND suspend\n");
-       if (info)
-               ret = info->suspend(info);
-
-       /* Disable the NFC clock */
-       clk_disable(nfc_clk);   /* FIXME */
+       if (mtd) {
+               ret = mtd->suspend(mtd);
+               /* Disable the NFC clock */
+               clk_disable(host->clk);
+       }
 
        return ret;
 }
 
 static int mxcnd_resume(struct platform_device *pdev)
 {
-       struct mtd_info *info = platform_get_drvdata(pdev);
+       struct mtd_info *mtd = platform_get_drvdata(pdev);
+       struct nand_chip *nand_chip = mtd->priv;
+       struct mxc_nand_host *host = nand_chip->priv;
        int ret = 0;
 
        DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND resume\n");
-       /* Enable the NFC clock */
-       clk_enable(nfc_clk);    /* FIXME */
 
-       if (info)
-               info->resume(info);
+       if (mtd) {
+               /* Enable the NFC clock */
+               clk_enable(host->clk);
+               mtd->resume(mtd);
+       }
 
        return ret;
 }
@@ -1055,13 +1064,7 @@ static struct platform_driver mxcnd_driver = {
 
 static int __init mxc_nd_init(void)
 {
-       /* Register the device driver structure. */
-       pr_info("MXC MTD nand Driver\n");
-       if (platform_driver_probe(&mxcnd_driver, mxcnd_probe) != 0) {
-               printk(KERN_ERR "Driver register failed for mxcnd_driver\n");
-               return -ENODEV;
-       }
-       return 0;
+       return platform_driver_probe(&mxcnd_driver, mxcnd_probe);
 }
 
 static void __exit mxc_nd_cleanup(void)
index e6a7e847ee805cbdd24384c08bc532560097c398..ea31a452b153e55e8ce378000e02ee952a5e8991 100644 (file)
@@ -352,8 +352,8 @@ static int __devinit parport_init_chip(struct parisc_device *dev)
        unsigned long port;
 
        if (!dev->irq) {
-               printk(KERN_WARNING "IRQ not found for parallel device at 0x%lx\n",
-                       dev->hpa.start);
+               printk(KERN_WARNING "IRQ not found for parallel device at 0x%llx\n",
+                       (unsigned long long)dev->hpa.start);
                return -ENODEV;
        }
 
index 4fc168b70095bcd0b76646411429a8dcf4920a1c..e68d5f20ffb3fb8198560dfb414fe126ecbeda6d 100644 (file)
@@ -129,7 +129,6 @@ struct acpiphp_func {
        struct acpiphp_bridge *bridge;  /* Ejectable PCI-to-PCI bridge */
 
        struct list_head sibling;
-       struct pci_dev *pci_dev;
        struct notifier_block nb;
        acpi_handle     handle;
 
index a33794d9e0dce60d3ae57948122e1e53efa57aa5..3a6064bce5614a84ba16e1411a50bcfc7afddce3 100644 (file)
@@ -32,9 +32,6 @@
 
 /*
  * Lifetime rules for pci_dev:
- *  - The one in acpiphp_func has its refcount elevated by pci_get_slot()
- *    when the driver is loaded or when an insertion event occurs.  It loses
- *    a refcount when its ejected or the driver unloads.
  *  - The one in acpiphp_bridge has its refcount elevated by pci_get_slot()
  *    when the bridge is scanned and it loses a refcount when the bridge
  *    is removed.
@@ -130,6 +127,7 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
        unsigned long long adr, sun;
        int device, function, retval;
        struct pci_bus *pbus = bridge->pci_bus;
+       struct pci_dev *pdev;
 
        if (!acpi_pci_check_ejectable(pbus, handle) && !is_dock_device(handle))
                return AE_OK;
@@ -213,10 +211,10 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
        newfunc->slot = slot;
        list_add_tail(&newfunc->sibling, &slot->funcs);
 
-       /* associate corresponding pci_dev */
-       newfunc->pci_dev = pci_get_slot(pbus, PCI_DEVFN(device, function));
-       if (newfunc->pci_dev) {
+       pdev = pci_get_slot(pbus, PCI_DEVFN(device, function));
+       if (pdev) {
                slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
+               pci_dev_put(pdev);
        }
 
        if (is_dock_device(handle)) {
@@ -617,7 +615,6 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
                                if (ACPI_FAILURE(status))
                                        err("failed to remove notify handler\n");
                        }
-                       pci_dev_put(func->pci_dev);
                        list_del(list);
                        kfree(func);
                }
@@ -1101,22 +1098,24 @@ static int __ref enable_device(struct acpiphp_slot *slot)
        pci_enable_bridges(bus);
        pci_bus_add_devices(bus);
 
-       /* associate pci_dev to our representation */
        list_for_each (l, &slot->funcs) {
                func = list_entry(l, struct acpiphp_func, sibling);
-               func->pci_dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
-                                                       func->function));
-               if (!func->pci_dev)
+               dev = pci_get_slot(bus, PCI_DEVFN(slot->device,
+                                                 func->function));
+               if (!dev)
                        continue;
 
-               if (func->pci_dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
-                   func->pci_dev->hdr_type != PCI_HEADER_TYPE_CARDBUS)
+               if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE &&
+                   dev->hdr_type != PCI_HEADER_TYPE_CARDBUS) {
+                       pci_dev_put(dev);
                        continue;
+               }
 
                status = find_p2p_bridge(func->handle, (u32)1, bus, NULL);
                if (ACPI_FAILURE(status))
                        warn("find_p2p_bridge failed (error code = 0x%x)\n",
                                status);
+               pci_dev_put(dev);
        }
 
        slot->flags |= SLOT_ENABLED;
@@ -1142,17 +1141,14 @@ static void disable_bridges(struct pci_bus *bus)
  */
 static int disable_device(struct acpiphp_slot *slot)
 {
-       int retval = 0;
        struct acpiphp_func *func;
-       struct list_head *l;
+       struct pci_dev *pdev;
 
        /* is this slot already disabled? */
        if (!(slot->flags & SLOT_ENABLED))
                goto err_exit;
 
-       list_for_each (l, &slot->funcs) {
-               func = list_entry(l, struct acpiphp_func, sibling);
-
+       list_for_each_entry(func, &slot->funcs, sibling) {
                if (func->bridge) {
                        /* cleanup p2p bridges under this P2P bridge */
                        cleanup_p2p_bridge(func->bridge->handle,
@@ -1160,35 +1156,28 @@ static int disable_device(struct acpiphp_slot *slot)
                        func->bridge = NULL;
                }
 
-               if (func->pci_dev) {
-                       pci_stop_bus_device(func->pci_dev);
-                       if (func->pci_dev->subordinate) {
-                               disable_bridges(func->pci_dev->subordinate);
-                               pci_disable_device(func->pci_dev);
+               pdev = pci_get_slot(slot->bridge->pci_bus,
+                                   PCI_DEVFN(slot->device, func->function));
+               if (pdev) {
+                       pci_stop_bus_device(pdev);
+                       if (pdev->subordinate) {
+                               disable_bridges(pdev->subordinate);
+                               pci_disable_device(pdev);
                        }
+                       pci_remove_bus_device(pdev);
+                       pci_dev_put(pdev);
                }
        }
 
-       list_for_each (l, &slot->funcs) {
-               func = list_entry(l, struct acpiphp_func, sibling);
-
+       list_for_each_entry(func, &slot->funcs, sibling) {
                acpiphp_unconfigure_ioapics(func->handle);
                acpiphp_bus_trim(func->handle);
-               /* try to remove anyway.
-                * acpiphp_bus_add might have been failed */
-
-               if (!func->pci_dev)
-                       continue;
-
-               pci_remove_bus_device(func->pci_dev);
-               pci_dev_put(func->pci_dev);
-               func->pci_dev = NULL;
        }
 
        slot->flags &= (~SLOT_ENABLED);
 
- err_exit:
-       return retval;
+err_exit:
+       return 0;
 }
 
 
index b4b39811b44544cc76a4c71e00c5c02567a765c2..a0127e93ade0a424c6125383150dd342e61710fc 100644 (file)
@@ -137,6 +137,7 @@ struct uart_8250_port {
        unsigned char           mcr;
        unsigned char           mcr_mask;       /* mask of user bits */
        unsigned char           mcr_force;      /* mask of forced bits */
+       unsigned char           cur_iotype;     /* Running I/O type */
 
        /*
         * Some bits in registers are cleared on a read, so they must
@@ -471,6 +472,7 @@ static void io_serial_out(struct uart_port *p, int offset, int value)
 
 static void set_io_from_upio(struct uart_port *p)
 {
+       struct uart_8250_port *up = (struct uart_8250_port *)p;
        switch (p->iotype) {
        case UPIO_HUB6:
                p->serial_in = hub6_serial_in;
@@ -509,6 +511,8 @@ static void set_io_from_upio(struct uart_port *p)
                p->serial_out = io_serial_out;
                break;
        }
+       /* Remember loaded iotype */
+       up->cur_iotype = p->iotype;
 }
 
 static void
@@ -1937,6 +1941,9 @@ static int serial8250_startup(struct uart_port *port)
        up->capabilities = uart_config[up->port.type].flags;
        up->mcr = 0;
 
+       if (up->port.iotype != up->cur_iotype)
+               set_io_from_upio(port);
+
        if (up->port.type == PORT_16C950) {
                /* Wake up and initialize UART */
                up->acr = 0;
@@ -2563,6 +2570,9 @@ static void serial8250_config_port(struct uart_port *port, int flags)
        if (ret < 0)
                probeflags &= ~PROBE_RSA;
 
+       if (up->port.iotype != up->cur_iotype)
+               set_io_from_upio(port);
+
        if (flags & UART_CONFIG_TYPE)
                autoconfig(up, probeflags);
        if (up->port.type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
@@ -2671,6 +2681,11 @@ serial8250_register_ports(struct uart_driver *drv, struct device *dev)
 {
        int i;
 
+       for (i = 0; i < nr_uarts; i++) {
+               struct uart_8250_port *up = &serial8250_ports[i];
+               up->cur_iotype = 0xFF;
+       }
+
        serial8250_isa_init_ports();
 
        for (i = 0; i < nr_uarts; i++) {
index 418b4fe9a0a1f40cbf3403974ebe2fab935802cf..33149d982e82a3e6329e811d9a8e2440f0a86858 100644 (file)
@@ -39,9 +39,9 @@ static int __init serial_init_chip(struct parisc_device *dev)
                 */
                if (parisc_parent(dev)->id.hw_type != HPHW_IOA)
                        printk(KERN_INFO
-                               "Serial: device 0x%lx not configured.\n"
+                               "Serial: device 0x%llx not configured.\n"
                                "Enable support for Wax, Lasi, Asp or Dino.\n",
-                               dev->hpa.start);
+                               (unsigned long long)dev->hpa.start);
                return -ENODEV;
        }
 
index 7f72f8ceaa6f0ace5bbfac731662999081b4ebc5..b3feb6198d57171b30edcf4d3a51cada259af29b 100644 (file)
@@ -988,7 +988,7 @@ mpc52xx_console_setup(struct console *co, char *options)
        pr_debug("mpc52xx_console_setup co=%p, co->index=%i, options=%s\n",
                 co, co->index, options);
 
-       if ((co->index < 0) || (co->index > MPC52xx_PSC_MAXNUM)) {
+       if ((co->index < 0) || (co->index >= MPC52xx_PSC_MAXNUM)) {
                pr_debug("PSC%x out of range\n", co->index);
                return -EINVAL;
        }
index 0716cdb44cd86e51d630f6bf9e08518af5bb33ed..0a3dc5ece634ba641167a738a1aed2cbe793e269 100644 (file)
@@ -11,7 +11,6 @@ obj-$(CONFIG_USB_MON)         += mon/
 obj-$(CONFIG_PCI)              += host/
 obj-$(CONFIG_USB_EHCI_HCD)     += host/
 obj-$(CONFIG_USB_ISP116X_HCD)  += host/
-obj-$(CONFIG_USB_ISP1760_HCD)  += host/
 obj-$(CONFIG_USB_OHCI_HCD)     += host/
 obj-$(CONFIG_USB_UHCI_HCD)     += host/
 obj-$(CONFIG_USB_FHCI_HCD)     += host/
index 0a69c0977e3f3f372f337b996732e341d07637e3..7a1164dd1d37f4bf115b236ef088fe8c90a82f50 100644 (file)
@@ -1375,6 +1375,9 @@ static struct usb_device_id acm_ids[] = {
        { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
        .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
        },
+       { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
+       .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+       },
        { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
        },
        { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
index 563d5727544849c46d9b6996cbe686996cdad44e..05c913cc3658f0389ab0ace117a8f50c8a166785 100644 (file)
@@ -794,7 +794,8 @@ usba_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
        if (ep->desc) {
                list_add_tail(&req->queue, &ep->queue);
 
-               if (ep->is_in || (ep_is_control(ep)
+               if ((!ep_is_control(ep) && ep->is_in) ||
+                       (ep_is_control(ep)
                                && (ep->state == DATA_STAGE_IN
                                        || ep->state == STATUS_STAGE_IN)))
                        usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
@@ -1940,7 +1941,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
        clk_disable(pclk);
 
-       usba_ep = kmalloc(sizeof(struct usba_ep) * pdata->num_ep,
+       usba_ep = kzalloc(sizeof(struct usba_ep) * pdata->num_ep,
                          GFP_KERNEL);
        if (!usba_ep)
                goto err_alloc_ep;
index cd07ea3f0c6332444013aae444dcbf3e0bcdfc4a..15438469f21aae35b49543c5bd95d6c6a6c086d6 100644 (file)
@@ -1658,6 +1658,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
        u32 reg_base, or_reg, skip_reg;
        unsigned long flags;
        struct ptd ptd;
+       packet_enqueue *pe;
 
        switch (usb_pipetype(urb->pipe)) {
        case PIPE_ISOCHRONOUS:
@@ -1669,6 +1670,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                reg_base = INT_REGS_OFFSET;
                or_reg = HC_INT_IRQ_MASK_OR_REG;
                skip_reg = HC_INT_PTD_SKIPMAP_REG;
+               pe = enqueue_an_INT_packet;
                break;
 
        default:
@@ -1676,6 +1678,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                reg_base = ATL_REGS_OFFSET;
                or_reg = HC_ATL_IRQ_MASK_OR_REG;
                skip_reg = HC_ATL_PTD_SKIPMAP_REG;
+               pe =  enqueue_an_ATL_packet;
                break;
        }
 
@@ -1687,6 +1690,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                        u32 skip_map;
                        u32 or_map;
                        struct isp1760_qtd *qtd;
+                       struct isp1760_qh *qh = ints->qh;
 
                        skip_map = isp1760_readl(hcd->regs + skip_reg);
                        skip_map |= 1 << i;
@@ -1699,8 +1703,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + reg_base
                                        + i * sizeof(ptd), sizeof(ptd));
                        qtd = ints->qtd;
-
-                       clean_up_qtdlist(qtd);
+                       qtd = clean_up_qtdlist(qtd);
 
                        free_mem(priv, ints->payload);
 
@@ -1711,7 +1714,24 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
                        ints->payload = 0;
 
                        isp1760_urb_done(priv, urb, status);
+                       if (qtd)
+                               pe(hcd, qh, qtd);
                        break;
+
+               } else if (ints->qtd) {
+                       struct isp1760_qtd *qtd, *prev_qtd = ints->qtd;
+
+                       for (qtd = ints->qtd->hw_next; qtd; qtd = qtd->hw_next) {
+                               if (qtd->urb == urb) {
+                                       prev_qtd->hw_next = clean_up_qtdlist(qtd);
+                                       isp1760_urb_done(priv, urb, status);
+                                       break;
+                               }
+                               prev_qtd = qtd;
+                       }
+                       /* we found the urb before the end of the list */
+                       if (qtd)
+                               break;
                }
                ints++;
        }
index 0a566eea49c02e193fcdca270488ab029742c264..f331e2bde88acbb0c2b4e36fee01eff68ffc9b5c 100644 (file)
@@ -974,6 +974,7 @@ int usb_serial_probe(struct usb_interface *interface,
                if (retval > 0) {
                        /* quietly accept this device, but don't bind to a
                           serial port as it's about to disappear */
+                       serial->num_ports = 0;
                        goto exit;
                }
        }
index 9a577a800db5a05b0d0fc87ef5d775c26e55fcb2..2fb63f6ea2f167fcdc1d5148e896fff00f415127 100644 (file)
 
 /* configurable parameters */
 #define ATMEL_LCDC_CVAL_DEFAULT                0xc8
-#define ATMEL_LCDC_DMA_BURST_LEN       8
-
-#if defined(CONFIG_ARCH_AT91SAM9263) || defined(CONFIG_ARCH_AT91CAP9) || \
-       defined(CONFIG_ARCH_AT91SAM9RL)
-#define ATMEL_LCDC_FIFO_SIZE           2048
-#else
-#define ATMEL_LCDC_FIFO_SIZE           512
-#endif
+#define ATMEL_LCDC_DMA_BURST_LEN       8       /* words */
+#define ATMEL_LCDC_FIFO_SIZE           512     /* words */
 
 #if defined(CONFIG_ARCH_AT91)
 #define        ATMEL_LCDFB_FBINFO_DEFAULT      (FBINFO_DEFAULT \
index 5e9c6302433b430e0965bc6bb2cb145f8c26c3b7..d3a568e6b169c4d1a0a122880dfb4a0b3a5bb9ac 100644 (file)
@@ -947,7 +947,8 @@ static int __devexit s3c_fb_remove(struct platform_device *pdev)
        int win;
 
        for (win = 0; win <= S3C_FB_MAX_WIN; win++)
-               s3c_fb_release_win(sfb, sfb->windows[win]);
+               if (sfb->windows[win])
+                       s3c_fb_release_win(sfb, sfb->windows[win]);
 
        iounmap(sfb->regs);
 
@@ -985,11 +986,20 @@ static int s3c_fb_suspend(struct platform_device *pdev, pm_message_t state)
 static int s3c_fb_resume(struct platform_device *pdev)
 {
        struct s3c_fb *sfb = platform_get_drvdata(pdev);
+       struct s3c_fb_platdata *pd = sfb->pdata;
        struct s3c_fb_win *win;
        int win_no;
 
        clk_enable(sfb->bus_clk);
 
+       /* setup registers */
+       writel(pd->vidcon1, sfb->regs + VIDCON1);
+
+       /* zero all windows before we do anything */
+       for (win_no = 0; win_no < S3C_FB_MAX_WIN; win_no++)
+               s3c_fb_clear_win(sfb, win_no);
+
+       /* restore framebuffers */
        for (win_no = 0; win_no < S3C_FB_MAX_WIN; win_no++) {
                win = sfb->windows[win_no];
                if (!win)
index 5cebf0b37798422ff097260f657dc128ee2b0b58..697f6b5f13139ac5ea95a3f7456687299f26775e 100644 (file)
@@ -41,6 +41,7 @@
 #include <asm/uaccess.h>
 #include <asm/unaligned.h>
 #include <asm/cacheflush.h>
+#include <asm/page.h>
 
 /****************************************************************************/
 
 #define        DBG_FLT(a...)
 #endif
 
+/*
+ * User data (stack, data section and bss) needs to be aligned
+ * for the same reasons as SLAB memory is, and to the same amount.
+ * Avoid duplicating architecture specific code by using the same
+ * macro as with SLAB allocation:
+ */
+#ifdef ARCH_SLAB_MINALIGN
+#define FLAT_DATA_ALIGN        (ARCH_SLAB_MINALIGN)
+#else
+#define FLAT_DATA_ALIGN        (sizeof(void *))
+#endif
+
 #define RELOC_FAILED 0xff00ff01                /* Relocation incorrect somewhere */
 #define UNLOADED_LIB 0x7ff000ff                /* Placeholder for unused library */
 
@@ -114,20 +127,18 @@ static unsigned long create_flat_tables(
        int envc = bprm->envc;
        char uninitialized_var(dummy);
 
-       sp = (unsigned long *) ((-(unsigned long)sizeof(char *))&(unsigned long) p);
+       sp = (unsigned long *)p;
+       sp -= (envc + argc + 2) + 1 + (flat_argvp_envp_on_stack() ? 2 : 0);
+       sp = (unsigned long *) ((unsigned long)sp & -FLAT_DATA_ALIGN);
+       argv = sp + 1 + (flat_argvp_envp_on_stack() ? 2 : 0);
+       envp = argv + (argc + 1);
 
-       sp -= envc+1;
-       envp = sp;
-       sp -= argc+1;
-       argv = sp;
-
-       flat_stack_align(sp);
        if (flat_argvp_envp_on_stack()) {
-               --sp; put_user((unsigned long) envp, sp);
-               --sp; put_user((unsigned long) argv, sp);
+               put_user((unsigned long) envp, sp + 2);
+               put_user((unsigned long) argv, sp + 1);
        }
 
-       put_user(argc,--sp);
+       put_user(argc, sp);
        current->mm->arg_start = (unsigned long) p;
        while (argc-->0) {
                put_user((unsigned long) p, argv++);
@@ -558,7 +569,9 @@ static int load_flat_file(struct linux_binprm * bprm,
                        ret = realdatastart;
                        goto err;
                }
-               datapos = realdatastart + MAX_SHARED_LIBS * sizeof(unsigned long);
+               datapos = ALIGN(realdatastart +
+                               MAX_SHARED_LIBS * sizeof(unsigned long),
+                               FLAT_DATA_ALIGN);
 
                DBG_FLT("BINFMT_FLAT: Allocated data+bss+stack (%d bytes): %x\n",
                                (int)(data_len + bss_len + stack_len), (int)datapos);
@@ -604,9 +617,12 @@ static int load_flat_file(struct linux_binprm * bprm,
                }
 
                realdatastart = textpos + ntohl(hdr->data_start);
-               datapos = realdatastart + MAX_SHARED_LIBS * sizeof(unsigned long);
-               reloc = (unsigned long *) (textpos + ntohl(hdr->reloc_start) +
-                               MAX_SHARED_LIBS * sizeof(unsigned long));
+               datapos = ALIGN(realdatastart +
+                               MAX_SHARED_LIBS * sizeof(unsigned long),
+                               FLAT_DATA_ALIGN);
+
+               reloc = (unsigned long *)
+                       (datapos + (ntohl(hdr->reloc_start) - text_len));
                memp = textpos;
                memp_size = len;
 #ifdef CONFIG_BINFMT_ZFLAT
@@ -854,7 +870,7 @@ static int load_flat_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        stack_len = TOP_OF_ARGS - bprm->p;             /* the strings */
        stack_len += (bprm->argc + 1) * sizeof(char *); /* the argv array */
        stack_len += (bprm->envc + 1) * sizeof(char *); /* the envp array */
-
+       stack_len += FLAT_DATA_ALIGN - 1;  /* reserve for upcoming alignment */
        
        res = load_flat_file(bprm, &libinfo, 0, &stack_len);
        if (res > (unsigned long)-4096)
index c32b4a1ad6cf6ddbdb5243fab9191986195c9395..a0244740b75a4d9aa04eff4beb8cacb147a63ab2 100644 (file)
@@ -480,13 +480,6 @@ static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseb
        return;
 
 filebad:
-       mutex_lock(&c->erase_free_sem);
-       spin_lock(&c->erase_completion_lock);
-       /* Stick it on a list (any list) so erase_failed can take it
-          right off again.  Silly, but shouldn't happen often. */
-       list_move(&jeb->list, &c->erasing_list);
-       spin_unlock(&c->erase_completion_lock);
-       mutex_unlock(&c->erase_free_sem);
        jffs2_erase_failed(c, jeb, bad_offset);
        return;
 
index 6c68ffd6b4bb01c21174c7294e37635a945cd295..b660435978d288de89bf42070b3a6e83399b2356 100644 (file)
@@ -1015,6 +1015,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
        host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &offset);
        set_fs(oldfs);
        if (host_err >= 0) {
+               *cnt = host_err;
                nfsdstats.io_write += host_err;
                fsnotify_modify(file->f_path.dentry);
        }
@@ -1060,10 +1061,9 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
        }
 
        dprintk("nfsd: write complete host_err=%d\n", host_err);
-       if (host_err >= 0) {
+       if (host_err >= 0)
                err = 0;
-               *cnt = host_err;
-       } else
+       else
                err = nfserrno(host_err);
 out:
        return err;
index fb45615943c2adba5e630fd1ea14a1d9e1c31fff..3326bbf9ab95222dbc2466a846650c7935e58cf5 100644 (file)
@@ -1956,7 +1956,7 @@ static struct dentry *proc_pident_instantiate(struct inode *dir,
        const struct pid_entry *p = ptr;
        struct inode *inode;
        struct proc_inode *ei;
-       struct dentry *error = ERR_PTR(-EINVAL);
+       struct dentry *error = ERR_PTR(-ENOENT);
 
        inode = proc_pid_make_inode(dir->i_sb, task);
        if (!inode)
index b1606e07b7a3445ca7e58f79bcd6fa7c3939d496..561a9c050cef687ebc48649af895f163572c2476 100644 (file)
@@ -723,7 +723,7 @@ int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
        mutex_unlock(&sysfs_workq_mutex);
 
        if (sysfs_workqueue == NULL) {
-               sysfs_workqueue = create_workqueue("sysfsd");
+               sysfs_workqueue = create_singlethread_workqueue("sysfsd");
                if (sysfs_workqueue == NULL) {
                        module_put(owner);
                        return -ENOMEM;
index 3282ee4318e7b98791fae49bac5510114d8f1420..4fa9996963109dcc44edcfda3cce8100dd48f29e 100644 (file)
@@ -13,6 +13,7 @@
 #define _LINUX_CRED_H
 
 #include <linux/capability.h>
+#include <linux/init.h>
 #include <linux/key.h>
 #include <asm/atomic.h>
 
index 0e6ff5de35884b6dbd749be01d5b2d681a2aa1ba..6fed4f6a9c9ea4f890afb20a1618131f95a2557b 100644 (file)
@@ -656,6 +656,7 @@ struct input_absinfo {
 #define ABS_MT_POSITION_Y      0x36    /* Center Y ellipse position */
 #define ABS_MT_TOOL_TYPE       0x37    /* Type of touching device */
 #define ABS_MT_BLOB_ID         0x38    /* Group a set of packets as a blob */
+#define ABS_MT_TRACKING_ID     0x39    /* Unique ID of initiated contact */
 
 #define ABS_MAX                        0x3f
 #define ABS_CNT                        (ABS_MAX+1)
index 62d81435347a7e2a7fa212fd9ae2b17e3e43224c..d476aad3ff577faf4fe7883dc7b33a3aea99b38a 100644 (file)
@@ -437,6 +437,11 @@ static inline int mem_cgroup_cache_charge_swapin(struct page *page,
        return 0;
 }
 
+static inline void
+mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
+{
+}
+
 #endif /* CONFIG_SWAP */
 #endif /* __KERNEL__*/
 #endif /* _LINUX_SWAP_H */
index 379ff0bcbf6e88eb98e13550853fa215cbc25789..1b60f30cebfa88aa135c17173ec9ce831612fa90 100644 (file)
@@ -121,7 +121,6 @@ void __remove_from_page_cache(struct page *page)
        mapping->nrpages--;
        __dec_zone_page_state(page, NR_FILE_PAGES);
        BUG_ON(page_mapped(page));
-       mem_cgroup_uncharge_cache_page(page);
 
        /*
         * Some filesystems seem to re-dirty the page even after
@@ -145,6 +144,7 @@ void remove_from_page_cache(struct page *page)
        spin_lock_irq(&mapping->tree_lock);
        __remove_from_page_cache(page);
        spin_unlock_irq(&mapping->tree_lock);
+       mem_cgroup_uncharge_cache_page(page);
 }
 
 static int sync_page(void *word)
@@ -476,13 +476,13 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
                if (likely(!error)) {
                        mapping->nrpages++;
                        __inc_zone_page_state(page, NR_FILE_PAGES);
+                       spin_unlock_irq(&mapping->tree_lock);
                } else {
                        page->mapping = NULL;
+                       spin_unlock_irq(&mapping->tree_lock);
                        mem_cgroup_uncharge_cache_page(page);
                        page_cache_release(page);
                }
-
-               spin_unlock_irq(&mapping->tree_lock);
                radix_tree_preload_end();
        } else
                mem_cgroup_uncharge_cache_page(page);
index 28c655ba935396bb14a73957cb07ac58cb5e63fa..e83ad2c9228c1242a582920c3a03b691f5dd56f9 100644 (file)
@@ -316,7 +316,7 @@ static void resv_map_release(struct kref *ref)
 static struct resv_map *vma_resv_map(struct vm_area_struct *vma)
 {
        VM_BUG_ON(!is_vm_hugetlb_page(vma));
-       if (!(vma->vm_flags & VM_SHARED))
+       if (!(vma->vm_flags & VM_MAYSHARE))
                return (struct resv_map *)(get_vma_private_data(vma) &
                                                        ~HPAGE_RESV_MASK);
        return NULL;
@@ -325,7 +325,7 @@ static struct resv_map *vma_resv_map(struct vm_area_struct *vma)
 static void set_vma_resv_map(struct vm_area_struct *vma, struct resv_map *map)
 {
        VM_BUG_ON(!is_vm_hugetlb_page(vma));
-       VM_BUG_ON(vma->vm_flags & VM_SHARED);
+       VM_BUG_ON(vma->vm_flags & VM_MAYSHARE);
 
        set_vma_private_data(vma, (get_vma_private_data(vma) &
                                HPAGE_RESV_MASK) | (unsigned long)map);
@@ -334,7 +334,7 @@ static void set_vma_resv_map(struct vm_area_struct *vma, struct resv_map *map)
 static void set_vma_resv_flags(struct vm_area_struct *vma, unsigned long flags)
 {
        VM_BUG_ON(!is_vm_hugetlb_page(vma));
-       VM_BUG_ON(vma->vm_flags & VM_SHARED);
+       VM_BUG_ON(vma->vm_flags & VM_MAYSHARE);
 
        set_vma_private_data(vma, get_vma_private_data(vma) | flags);
 }
@@ -353,7 +353,7 @@ static void decrement_hugepage_resv_vma(struct hstate *h,
        if (vma->vm_flags & VM_NORESERVE)
                return;
 
-       if (vma->vm_flags & VM_SHARED) {
+       if (vma->vm_flags & VM_MAYSHARE) {
                /* Shared mappings always use reserves */
                h->resv_huge_pages--;
        } else if (is_vma_resv_set(vma, HPAGE_RESV_OWNER)) {
@@ -369,14 +369,14 @@ static void decrement_hugepage_resv_vma(struct hstate *h,
 void reset_vma_resv_huge_pages(struct vm_area_struct *vma)
 {
        VM_BUG_ON(!is_vm_hugetlb_page(vma));
-       if (!(vma->vm_flags & VM_SHARED))
+       if (!(vma->vm_flags & VM_MAYSHARE))
                vma->vm_private_data = (void *)0;
 }
 
 /* Returns true if the VMA has associated reserve pages */
 static int vma_has_reserves(struct vm_area_struct *vma)
 {
-       if (vma->vm_flags & VM_SHARED)
+       if (vma->vm_flags & VM_MAYSHARE)
                return 1;
        if (is_vma_resv_set(vma, HPAGE_RESV_OWNER))
                return 1;
@@ -924,7 +924,7 @@ static long vma_needs_reservation(struct hstate *h,
        struct address_space *mapping = vma->vm_file->f_mapping;
        struct inode *inode = mapping->host;
 
-       if (vma->vm_flags & VM_SHARED) {
+       if (vma->vm_flags & VM_MAYSHARE) {
                pgoff_t idx = vma_hugecache_offset(h, vma, addr);
                return region_chg(&inode->i_mapping->private_list,
                                                        idx, idx + 1);
@@ -949,7 +949,7 @@ static void vma_commit_reservation(struct hstate *h,
        struct address_space *mapping = vma->vm_file->f_mapping;
        struct inode *inode = mapping->host;
 
-       if (vma->vm_flags & VM_SHARED) {
+       if (vma->vm_flags & VM_MAYSHARE) {
                pgoff_t idx = vma_hugecache_offset(h, vma, addr);
                region_add(&inode->i_mapping->private_list, idx, idx + 1);
 
@@ -1893,7 +1893,7 @@ retry_avoidcopy:
         * at the time of fork() could consume its reserves on COW instead
         * of the full address range.
         */
-       if (!(vma->vm_flags & VM_SHARED) &&
+       if (!(vma->vm_flags & VM_MAYSHARE) &&
                        is_vma_resv_set(vma, HPAGE_RESV_OWNER) &&
                        old_page != pagecache_page)
                outside_reserve = 1;
@@ -2000,7 +2000,7 @@ retry:
                clear_huge_page(page, address, huge_page_size(h));
                __SetPageUptodate(page);
 
-               if (vma->vm_flags & VM_SHARED) {
+               if (vma->vm_flags & VM_MAYSHARE) {
                        int err;
                        struct inode *inode = mapping->host;
 
@@ -2104,7 +2104,7 @@ int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                        goto out_mutex;
                }
 
-               if (!(vma->vm_flags & VM_SHARED))
+               if (!(vma->vm_flags & VM_MAYSHARE))
                        pagecache_page = hugetlbfs_pagecache_page(h,
                                                                vma, address);
        }
@@ -2289,7 +2289,7 @@ int hugetlb_reserve_pages(struct inode *inode,
         * to reserve the full area even if read-only as mprotect() may be
         * called to make the mapping read-write. Assume !vma is a shm mapping
         */
-       if (!vma || vma->vm_flags & VM_SHARED)
+       if (!vma || vma->vm_flags & VM_MAYSHARE)
                chg = region_chg(&inode->i_mapping->private_list, from, to);
        else {
                struct resv_map *resv_map = resv_map_alloc();
@@ -2330,7 +2330,7 @@ int hugetlb_reserve_pages(struct inode *inode,
         * consumed reservations are stored in the map. Hence, nothing
         * else has to be done for private mappings here
         */
-       if (!vma || vma->vm_flags & VM_SHARED)
+       if (!vma || vma->vm_flags & VM_MAYSHARE)
                region_add(&inode->i_mapping->private_list, from, to);
        return 0;
 }
index 01c2d8f146851bb5c3a80c506a6d53359de04217..78eb8552818b6b94d4add7ec06ecdc881add1f67 100644 (file)
@@ -314,14 +314,6 @@ static struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
        return mem;
 }
 
-static bool mem_cgroup_is_obsolete(struct mem_cgroup *mem)
-{
-       if (!mem)
-               return true;
-       return css_is_removed(&mem->css);
-}
-
-
 /*
  * Call callback function against all cgroup under hierarchy tree.
  */
@@ -932,7 +924,7 @@ static int __mem_cgroup_try_charge(struct mm_struct *mm,
        if (unlikely(!mem))
                return 0;
 
-       VM_BUG_ON(!mem || mem_cgroup_is_obsolete(mem));
+       VM_BUG_ON(css_is_removed(&mem->css));
 
        while (1) {
                int ret;
@@ -1488,8 +1480,9 @@ void mem_cgroup_uncharge_cache_page(struct page *page)
        __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_CACHE);
 }
 
+#ifdef CONFIG_SWAP
 /*
- * called from __delete_from_swap_cache() and drop "page" account.
+ * called after __delete_from_swap_cache() and drop "page" account.
  * memcg information is recorded to swap_cgroup of "ent"
  */
 void mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
@@ -1506,6 +1499,7 @@ void mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
        if (memcg)
                css_put(&memcg->css);
 }
+#endif
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 /*
index 92bcf1db16b24ea2c9b4d9f6c93043118c021615..a7b2460e922b779252ebcc225cecaf6060b0e964 100644 (file)
@@ -284,22 +284,28 @@ static void dump_tasks(const struct mem_cgroup *mem)
        printk(KERN_INFO "[ pid ]   uid  tgid total_vm      rss cpu oom_adj "
               "name\n");
        do_each_thread(g, p) {
-               /*
-                * total_vm and rss sizes do not exist for tasks with a
-                * detached mm so there's no need to report them.
-                */
-               if (!p->mm)
-                       continue;
+               struct mm_struct *mm;
+
                if (mem && !task_in_mem_cgroup(p, mem))
                        continue;
                if (!thread_group_leader(p))
                        continue;
 
                task_lock(p);
+               mm = p->mm;
+               if (!mm) {
+                       /*
+                        * total_vm and rss sizes do not exist for tasks with no
+                        * mm so there's no need to report them; they can't be
+                        * oom killed anyway.
+                        */
+                       task_unlock(p);
+                       continue;
+               }
                printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3d     %3d %s\n",
-                      p->pid, __task_cred(p)->uid, p->tgid,
-                      p->mm->total_vm, get_mm_rss(p->mm), (int)task_cpu(p),
-                      p->oomkilladj, p->comm);
+                      p->pid, __task_cred(p)->uid, p->tgid, mm->total_vm,
+                      get_mm_rss(mm), (int)task_cpu(p), p->oomkilladj,
+                      p->comm);
                task_unlock(p);
        } while_each_thread(g, p);
 }
index 3ecea98ecb459e779e68ed0a68899599045de0f9..1416e7e9e02db3b5da60fe3a270e98e7b84024bb 100644 (file)
@@ -109,8 +109,6 @@ int add_to_swap_cache(struct page *page, swp_entry_t entry, gfp_t gfp_mask)
  */
 void __delete_from_swap_cache(struct page *page)
 {
-       swp_entry_t ent = {.val = page_private(page)};
-
        VM_BUG_ON(!PageLocked(page));
        VM_BUG_ON(!PageSwapCache(page));
        VM_BUG_ON(PageWriteback(page));
@@ -121,7 +119,6 @@ void __delete_from_swap_cache(struct page *page)
        total_swapcache_pages--;
        __dec_zone_page_state(page, NR_FILE_PAGES);
        INC_CACHE_INFO(del_total);
-       mem_cgroup_uncharge_swapcache(page, ent);
 }
 
 /**
@@ -191,6 +188,7 @@ void delete_from_swap_cache(struct page *page)
        __delete_from_swap_cache(page);
        spin_unlock_irq(&swapper_space.tree_lock);
 
+       mem_cgroup_uncharge_swapcache(page, entry);
        swap_free(entry);
        page_cache_release(page);
 }
index 55206fab7b994e18fb026ca36269e3feeb2705a1..12e1579f916546db1933998f4f655a8c1f8e2d34 100644 (file)
@@ -359,6 +359,7 @@ invalidate_complete_page2(struct address_space *mapping, struct page *page)
        BUG_ON(page_has_private(page));
        __remove_from_page_cache(page);
        spin_unlock_irq(&mapping->tree_lock);
+       mem_cgroup_uncharge_cache_page(page);
        page_cache_release(page);       /* pagecache ref */
        return 1;
 failed:
index 5fa3eda1f03fccb6626f08c8e7bdad53326bce84..d254306562cda93af097d60ed024a71479c9da4d 100644 (file)
@@ -470,10 +470,12 @@ static int __remove_mapping(struct address_space *mapping, struct page *page)
                swp_entry_t swap = { .val = page_private(page) };
                __delete_from_swap_cache(page);
                spin_unlock_irq(&mapping->tree_lock);
+               mem_cgroup_uncharge_swapcache(page, swap);
                swap_free(swap);
        } else {
                __remove_from_page_cache(page);
                spin_unlock_irq(&mapping->tree_lock);
+               mem_cgroup_uncharge_cache_page(page);
        }
 
        return 1;
index af3198814c154756daa50f2c58819272795df95c..9d504234af4a664f5f116171b9d6e02825d1ac4f 100644 (file)
@@ -345,6 +345,7 @@ static void svc_sock_setbufsize(struct socket *sock, unsigned int snd,
        lock_sock(sock->sk);
        sock->sk->sk_sndbuf = snd * 2;
        sock->sk->sk_rcvbuf = rcv * 2;
+       sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
        release_sock(sock->sk);
 #endif
 }
@@ -796,6 +797,23 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
                test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags),
                test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
 
+       if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
+               /* sndbuf needs to have room for one request
+                * per thread, otherwise we can stall even when the
+                * network isn't a bottleneck.
+                *
+                * We count all threads rather than threads in a
+                * particular pool, which provides an upper bound
+                * on the number of threads which will access the socket.
+                *
+                * rcvbuf just needs to be able to hold a few requests.
+                * Normally they will be removed from the queue
+                * as soon a a complete request arrives.
+                */
+               svc_sock_setbufsize(svsk->sk_sock,
+                                   (serv->sv_nrthreads+3) * serv->sv_max_mesg,
+                                   3 * serv->sv_max_mesg);
+
        clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
 
        /* Receive data. If we haven't got the record length yet, get
@@ -1043,6 +1061,15 @@ static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
 
                tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
 
+               /* initialise setting must have enough space to
+                * receive and respond to one request.
+                * svc_tcp_recvfrom will re-adjust if necessary
+                */
+               svc_sock_setbufsize(svsk->sk_sock,
+                                   3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
+                                   3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
+
+               set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
                set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
                if (sk->sk_state != TCP_ESTABLISHED)
                        set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
@@ -1112,14 +1139,8 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
        /* Initialize the socket */
        if (sock->type == SOCK_DGRAM)
                svc_udp_init(svsk, serv);
-       else {
-               /* initialise setting must have enough space to
-                * receive and respond to one request.
-                */
-               svc_sock_setbufsize(svsk->sk_sock, 4 * serv->sv_max_mesg,
-                                       4 * serv->sv_max_mesg);
+       else
                svc_tcp_init(svsk, serv);
-       }
 
        dprintk("svc: svc_setup_socket created %p (inet %p)\n",
                                svsk, svsk->sk_sk);
index 8b510c5e877752e876795c326f8f6381b44c770f..f11be72a1a80a1f8cc1876d23c5cce7cb5bc9ea6 100644 (file)
@@ -128,7 +128,8 @@ static int fast_reg_xdr(struct svcxprt_rdma *xprt,
                page_bytes -= sge_bytes;
 
                frmr->page_list->page_list[page_no] =
-                       ib_dma_map_page(xprt->sc_cm_id->device, page, 0,
+                       ib_dma_map_single(xprt->sc_cm_id->device,
+                                         page_address(page),
                                          PAGE_SIZE, DMA_TO_DEVICE);
                if (ib_dma_mapping_error(xprt->sc_cm_id->device,
                                         frmr->page_list->page_list[page_no]))
@@ -532,18 +533,17 @@ static int send_reply(struct svcxprt_rdma *rdma,
                clear_bit(RDMACTXT_F_FAST_UNREG, &ctxt->flags);
 
        /* Prepare the SGE for the RPCRDMA Header */
+       ctxt->sge[0].lkey = rdma->sc_dma_lkey;
+       ctxt->sge[0].length = svc_rdma_xdr_get_reply_hdr_len(rdma_resp);
        ctxt->sge[0].addr =
-               ib_dma_map_page(rdma->sc_cm_id->device,
-                               page, 0, PAGE_SIZE, DMA_TO_DEVICE);
+               ib_dma_map_single(rdma->sc_cm_id->device, page_address(page),
+                                 ctxt->sge[0].length, DMA_TO_DEVICE);
        if (ib_dma_mapping_error(rdma->sc_cm_id->device, ctxt->sge[0].addr))
                goto err;
        atomic_inc(&rdma->sc_dma_used);
 
        ctxt->direction = DMA_TO_DEVICE;
 
-       ctxt->sge[0].length = svc_rdma_xdr_get_reply_hdr_len(rdma_resp);
-       ctxt->sge[0].lkey = rdma->sc_dma_lkey;
-
        /* Determine how many of our SGE are to be transmitted */
        for (sge_no = 1; byte_count && sge_no < vec->count; sge_no++) {
                sge_bytes = min_t(size_t, vec->sge[sge_no].iov_len, byte_count);
index 4b0c2fa15e0b6cd0526fdfd72a831cd9e42879bd..5151f9f6c5731b168dc22ac63657fd84fed8866c 100644 (file)
@@ -500,8 +500,8 @@ int svc_rdma_post_recv(struct svcxprt_rdma *xprt)
                BUG_ON(sge_no >= xprt->sc_max_sge);
                page = svc_rdma_get_page();
                ctxt->pages[sge_no] = page;
-               pa = ib_dma_map_page(xprt->sc_cm_id->device,
-                                    page, 0, PAGE_SIZE,
+               pa = ib_dma_map_single(xprt->sc_cm_id->device,
+                                    page_address(page), PAGE_SIZE,
                                     DMA_FROM_DEVICE);
                if (ib_dma_mapping_error(xprt->sc_cm_id->device, pa))
                        goto err_put_ctxt;
@@ -1315,8 +1315,8 @@ void svc_rdma_send_error(struct svcxprt_rdma *xprt, struct rpcrdma_msg *rmsgp,
        length = svc_rdma_xdr_encode_error(xprt, rmsgp, err, va);
 
        /* Prepare SGE for local address */
-       sge.addr = ib_dma_map_page(xprt->sc_cm_id->device,
-                                  p, 0, PAGE_SIZE, DMA_FROM_DEVICE);
+       sge.addr = ib_dma_map_single(xprt->sc_cm_id->device,
+                                  page_address(p), PAGE_SIZE, DMA_FROM_DEVICE);
        if (ib_dma_mapping_error(xprt->sc_cm_id->device, sge.addr)) {
                put_page(p);
                return;
@@ -1343,7 +1343,7 @@ void svc_rdma_send_error(struct svcxprt_rdma *xprt, struct rpcrdma_msg *rmsgp,
        if (ret) {
                dprintk("svcrdma: Error %d posting send for protocol error\n",
                        ret);
-               ib_dma_unmap_page(xprt->sc_cm_id->device,
+               ib_dma_unmap_single(xprt->sc_cm_id->device,
                                  sge.addr, PAGE_SIZE,
                                  DMA_FROM_DEVICE);
                svc_rdma_put_context(ctxt, 1);
index a2a792c18c40e18412ac7e9e015d22c6035b2958..d659995ac3ac7be2f20e488c71b7b3fe405a879e 100644 (file)
@@ -249,6 +249,11 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                        new_hw_ptr = hw_base + pos;
                }
        }
+
+       /* Do jiffies check only in xrun_debug mode */
+       if (!xrun_debug(substream))
+               goto no_jiffies_check;
+
        /* Skip the jiffies check for hardwares with BATCH flag.
         * Such hardware usually just increases the position at each IRQ,
         * thus it can't give any strange position.
@@ -336,7 +341,9 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
                        hw_base = 0;
                new_hw_ptr = hw_base + pos;
        }
-       if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
+       /* Do jiffies check only in xrun_debug mode */
+       if (xrun_debug(substream) &&
+           ((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
                hw_ptr_error(substream,
                             "hw_ptr skipping! "
                             "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu)\n",
@@ -1478,7 +1485,6 @@ static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
                runtime->status->hw_ptr %= runtime->buffer_size;
        else
                runtime->status->hw_ptr = 0;
-       runtime->hw_ptr_jiffies = jiffies;
        snd_pcm_stream_unlock_irqrestore(substream, flags);
        return 0;
 }
index fc6f98e257df5e27d67a71a092eaa85fd6765ca1..b5da656d1ececa2e41b13dc55ea57b662bcc1b2e 100644 (file)
@@ -848,6 +848,7 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_trigger_tstamp(substream);
+       runtime->hw_ptr_jiffies = jiffies;
        runtime->status->state = state;
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
            runtime->silence_size > 0)
@@ -961,6 +962,11 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
 {
        if (substream->runtime->trigger_master != substream)
                return 0;
+       /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
+        * a delta betwen the current jiffies, this gives a large enough
+        * delta, effectively to skip the check once.
+        */
+       substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
        return substream->ops->trigger(substream,
                                       push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
                                              SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
index 56ce19e68cb5838a24e675828bb990f296717a24..4fcbe21829abfe27104f7dabeed8fb801a301537 100644 (file)
@@ -1848,6 +1848,7 @@ static const char *cxt5051_models[CXT5051_MODELS] = {
 
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
        SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
+       SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP),
        SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
                      CXT5051_LAPTOP),
        SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
index 823296d7d5781cbebb7d2ff4ab37cb8ecfefe74c..a6b88482637be9fbdc9b3c0fa56e2293a73ce0ab 100644 (file)
@@ -3347,7 +3347,7 @@ static int snd_usb_create_quirk(struct snd_usb_audio *chip,
                [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
                [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
                [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
-               [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
+               [QUIRK_MIDI_FASTLANE] = snd_usb_create_midi_interface,
                [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
                [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
                [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
index 36e4f7a29adc5548b05b5366fa0191f13466145b..8e7f78941ba6589407ac5074907ba6217734af60 100644 (file)
@@ -153,7 +153,7 @@ enum quirk_type {
        QUIRK_MIDI_YAMAHA,
        QUIRK_MIDI_MIDIMAN,
        QUIRK_MIDI_NOVATION,
-       QUIRK_MIDI_RAW,
+       QUIRK_MIDI_FASTLANE,
        QUIRK_MIDI_EMAGIC,
        QUIRK_MIDI_CME,
        QUIRK_MIDI_US122L,
index 26bad373fe65c012de152ac4f753076951390330..2fb35cc22a3030b687d1623546196cd6e8e2de27 100644 (file)
@@ -1778,8 +1778,18 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
                umidi->usb_protocol_ops = &snd_usbmidi_novation_ops;
                err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
                break;
-       case QUIRK_MIDI_RAW:
+       case QUIRK_MIDI_FASTLANE:
                umidi->usb_protocol_ops = &snd_usbmidi_raw_ops;
+               /*
+                * Interface 1 contains isochronous endpoints, but with the same
+                * numbers as in interface 0.  Since it is interface 1 that the
+                * USB core has most recently seen, these descriptors are now
+                * associated with the endpoint numbers.  This will foul up our
+                * attempts to submit bulk/interrupt URBs to the endpoints in
+                * interface 0, so we have to make sure that the USB core looks
+                * again at interface 0 by calling usb_set_interface() on it.
+                */
+               usb_set_interface(umidi->chip->dev, 0, 0);
                err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
                break;
        case QUIRK_MIDI_EMAGIC:
index 647ef502965179ec6f1eec15c042990a950aedf6..5d955aaad85f9a5d2ac96a990e97972a00e48905 100644 (file)
@@ -1868,7 +1868,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                .data = & (const struct snd_usb_audio_quirk[]) {
                        {
                                .ifnum = 0,
-                               .type = QUIRK_MIDI_RAW
+                               .type = QUIRK_MIDI_FASTLANE
                        },
                        {
                                .ifnum = 1,