Merge master.kernel.org:/home/rmk/linux-2.6-arm
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 7 May 2009 17:54:32 +0000 (10:54 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 7 May 2009 17:54:32 +0000 (10:54 -0700)
* master.kernel.org:/home/rmk/linux-2.6-arm:
  [ARM] 5507/1: support R_ARM_MOVW_ABS_NC and MOVT_ABS relocation types
  [ARM] 5506/1: davinci: DMA_32BIT_MASK --> DMA_BIT_MASK(32)
  i.MX31: Disable CPU_32v6K in mx3_defconfig.
  mx3fb: Fix compilation with CONFIG_PM
  mx27ads: move PBC mapping out of vmalloc space
  MXC: remove BUG_ON in interrupt handler
  mx31: remove mx31moboard_defconfig
  ARM: ARCH_MXC should select HAVE_CLK
  mxc : BUG in imx_dma_request
  mxc : Clean up properly when imx_dma_free() used without imx_dma_disable()
  [ARM] mv78xx0: update defconfig
  [ARM] orion5x: update defconfig
  [ARM] Kirkwood: update defconfig
  [ARM] Kconfig typo fix:  "PXA930" -> "CPU_PXA930".
  [ARM] S3C2412: Add missing cache flush in suspend code
  [ARM] S3C: Add UDIVSLOT support for newer UARTS
  [ARM] S3C64XX: Add S3C64XX_PA_IIS{0,1} to <mach/map.h>

120 files changed:
Documentation/kernel-parameters.txt
Documentation/lockdep-design.txt
MAINTAINERS
arch/ia64/include/asm/idle.h [new file with mode: 0644]
arch/ia64/include/asm/xen/events.h
arch/ia64/xen/xensetup.S
arch/powerpc/kernel/cputable.c
arch/x86/kernel/amd_iommu_init.c
arch/x86/kernel/cpu/common.c
arch/x86/kernel/cpu/proc.c
arch/x86/mm/kmmio.c
arch/x86/vdso/vclock_gettime.c
drivers/base/iommu.c
drivers/char/vt_ioctl.c
drivers/gpu/drm/drm_crtc_helper.c
drivers/gpu/drm/drm_drv.c
drivers/gpu/drm/drm_stub.c
drivers/gpu/drm/drm_sysfs.c
drivers/gpu/drm/r128/r128_cce.c
drivers/gpu/drm/radeon/radeon_drv.h
drivers/i2c/algos/i2c-algo-bit.c
drivers/i2c/algos/i2c-algo-pca.c
drivers/i2c/busses/i2c-ali1535.c
drivers/i2c/busses/i2c-ali15x3.c
drivers/i2c/busses/i2c-amd756.c
drivers/i2c/busses/i2c-i801.c
drivers/i2c/busses/i2c-isch.c
drivers/i2c/busses/i2c-nforce2.c
drivers/i2c/busses/i2c-sis5595.c
drivers/i2c/busses/i2c-sis630.c
drivers/i2c/busses/i2c-sis96x.c
drivers/misc/isl29003.c
drivers/mmc/card/block.c
drivers/mmc/core/core.c
drivers/mmc/host/mmci.c
drivers/mmc/host/mvsdio.c
drivers/mmc/host/sdhci-pci.c
drivers/mmc/host/sdhci.h
drivers/net/bonding/bond_alb.c
drivers/net/bonding/bond_main.c
drivers/net/cxgb3/t3_hw.c
drivers/net/e1000/e1000_main.c
drivers/net/ehea/ehea.h
drivers/net/ehea/ehea_main.c
drivers/net/mv643xx_eth.c
drivers/net/ne2k-pci.c
drivers/net/netconsole.c
drivers/net/usb/Kconfig
drivers/net/usb/Makefile
drivers/net/usb/cdc_eem.c [new file with mode: 0644]
drivers/net/usb/smsc95xx.c
drivers/net/usb/smsc95xx.h
drivers/net/virtio_net.c
drivers/net/wireless/ath5k/debug.c
drivers/net/wireless/iwlwifi/iwl-scan.c
drivers/net/wireless/iwlwifi/iwl3945-base.c
drivers/net/wireless/rndis_wlan.c
drivers/serial/jsm/jsm.h
drivers/serial/jsm/jsm_driver.c
drivers/video/Makefile
drivers/video/cfbfillrect.c
drivers/video/fb_draw.h
drivers/video/sysfillrect.c
drivers/xen/balloon.c
fs/ioctl.c
fs/nfs/file.c
fs/notify/inotify/inotify_user.c
fs/proc/array.c
fs/proc/base.c
include/asm-generic/bug.h
include/linux/netfilter/x_tables.h
include/linux/usb/cdc.h
include/linux/virtio_net.h
include/net/9p/client.h
include/net/bluetooth/hci_core.h
include/net/tcp.h
init/initramfs.c
kernel/auditfilter.c
kernel/irq/handle.c
kernel/panic.c
kernel/posix-cpu-timers.c
kernel/sched.c
kernel/time/tick-common.c
kernel/trace/trace.c
lib/dma-debug.c
mm/Kconfig
mm/madvise.c
mm/nommu.c
mm/oom_kill.c
mm/page_alloc.c
mm/vmalloc.c
net/9p/client.c
net/9p/trans_fd.c
net/9p/trans_rdma.c
net/9p/trans_virtio.c
net/atm/br2684.c
net/bluetooth/hci_conn.c
net/bluetooth/hci_sysfs.c
net/core/dev.c
net/core/skbuff.c
net/ipv4/tcp_input.c
net/mac80211/main.c
net/netfilter/Kconfig
net/sched/cls_api.c
scripts/mod/modpost.c
security/selinux/hooks.c
sound/core/pcm_lib.c
sound/isa/msnd/msnd.c
sound/pci/bt87x.c
sound/pci/echoaudio/indigodjx.c
sound/pci/echoaudio/indigoiox.c
sound/pci/korg1212/korg1212.c
sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
sound/soc/au1x/dbdma2.c
sound/soc/codecs/twl4030.c
sound/soc/codecs/wm8350.c
sound/soc/fsl/mpc5200_psc_i2s.c
sound/soc/sh/dma-sh7760.c
sound/sparc/dbri.c
sound/usb/usx2y/usbusx2yaudio.c

index 90b3924071b6c35f69ece1feba26ae9f92c5ab37..e87bdbfbcc75e236124a526d4456ddf3c6afc4e3 100644 (file)
@@ -17,6 +17,12 @@ are specified on the kernel command line with the module name plus
 
        usbcore.blinkenlights=1
 
+Hyphens (dashes) and underscores are equivalent in parameter names, so
+       log_buf_len=1M print-fatal-signals=1
+can also be entered as
+       log-buf-len=1M print_fatal_signals=1
+
+
 This document may not be entirely up to date and comprehensive. The command
 "modinfo -p ${modulename}" shows a current list of all parameters of a loadable
 module. Loadable modules, after being loaded into the running kernel, also
@@ -345,7 +351,7 @@ and is between 256 and 4096 characters. It is defined in the file
                        not play well with APC CPU idle - disable it if you have
                        APC and your system crashes randomly.
 
-       apic=           [APIC,i386] Advanced Programmable Interrupt Controller
+       apic=           [APIC,X86-32] Advanced Programmable Interrupt Controller
                        Change the output verbosity whilst booting
                        Format: { quiet (default) | verbose | debug }
                        Change the amount of debugging information output
@@ -702,7 +708,7 @@ and is between 256 and 4096 characters. It is defined in the file
                        to discrete, to make X server driver able to add WB
                        entry later. This parameter enables that.
 
-       enable_timer_pin_1 [i386,x86-64]
+       enable_timer_pin_1 [X86]
                        Enable PIN 1 of APIC timer
                        Can be useful to work around chipset bugs
                        (in particular on some ATI chipsets).
@@ -775,7 +781,7 @@ and is between 256 and 4096 characters. It is defined in the file
 
        hashdist=       [KNL,NUMA] Large hashes allocated during boot
                        are distributed across NUMA nodes.  Defaults on
-                       for IA-64, off otherwise.
+                       for 64bit NUMA, off otherwise.
                        Format: 0 | 1 (for off | on)
 
        hcl=            [IA-64] SGI's Hardware Graph compatibility layer
index 938ea22f2cc096f6838a678217e463bf9ec0cd4d..e20d913d5914a29261d12f5fa4585164ed170c82 100644 (file)
@@ -54,9 +54,9 @@ locking error messages, inside curlies. A contrived example:
 The bit position indicates STATE, STATE-read, for each of the states listed
 above, and the character displayed in each indicates:
 
-   '.'  acquired while irqs disabled
-   '+'  acquired in irq context
-   '-'  acquired with irqs enabled
+   '.'  acquired while irqs disabled and not in irq context
+   '-'  acquired in irq context
+   '+'  acquired with irqs enabled
    '?'  acquired in irq context with irqs enabled.
 
 Unused mutexes cannot be part of the cause of an error.
index 9de961bd1214a14bafc1a05ac488bcca9d346dc8..2b349ba4add49640a52d55a66203fba46cf748e0 100644 (file)
@@ -3434,11 +3434,10 @@ L:      linuxppc-dev@ozlabs.org
 S:     Maintained
 
 LINUX FOR POWERPC EMBEDDED MPC5XXX
-P:     Sylvain Munaut
-M:     tnt@246tNt.com
 P:     Grant Likely
 M:     grant.likely@secretlab.ca
 L:     linuxppc-dev@ozlabs.org
+T:     git git://git.secretlab.ca/git/linux-2.6.git
 S:     Maintained
 
 LINUX FOR POWERPC EMBEDDED PPC4XX
@@ -3456,6 +3455,7 @@ P:        Grant Likely
 M:     grant.likely@secretlab.ca
 W:     http://wiki.secretlab.ca/index.php/Linux_on_Xilinx_Virtex
 L:     linuxppc-dev@ozlabs.org
+T:     git git://git.secretlab.ca/git/linux-2.6.git
 S:     Maintained
 
 LINUX FOR POWERPC EMBEDDED PPC8XX
diff --git a/arch/ia64/include/asm/idle.h b/arch/ia64/include/asm/idle.h
new file mode 100644 (file)
index 0000000..b768501
--- /dev/null
@@ -0,0 +1,7 @@
+#ifndef _ASM_IA64_IDLE_H
+#define _ASM_IA64_IDLE_H
+
+static inline void enter_idle(void) { }
+static inline void exit_idle(void) { }
+
+#endif /* _ASM_IA64_IDLE_H */
index 73248781fba87dcab065cfcc515153029bc0b0bf..b8370c8b61984554ab1816f015e2557086c74826 100644 (file)
@@ -36,14 +36,9 @@ static inline int xen_irqs_disabled(struct pt_regs *regs)
        return !(ia64_psr(regs)->i);
 }
 
-static inline void xen_do_IRQ(int irq, struct pt_regs *regs)
+static inline void handle_irq(int irq, struct pt_regs *regs)
 {
-       struct pt_regs *old_regs;
-       old_regs = set_irq_regs(regs);
-       irq_enter();
        __do_IRQ(irq);
-       irq_exit();
-       set_irq_regs(old_regs);
 }
 #define irq_ctx_init(cpu)      do { } while (0)
 
index 28fed1fcc079d2c213bbe42603cda35e7e0a500c..aff8346ea193536f035fe81f2c5490707256b537 100644 (file)
@@ -54,8 +54,6 @@ END(startup_xen)
 
 #define isBP   p3      // are we the Bootstrap Processor?
 
-       .text
-
 GLOBAL_ENTRY(xen_setup_hook)
        mov r8=XEN_PV_DOMAIN_ASM
 (isBP) movl r9=xen_domain_type;;
index cd1b687544f30e4d74b9cf5ebd76c4c10bcbb718..f9c40f869c6e8088abd17d01213377fe5538f985 100644 (file)
@@ -382,7 +382,8 @@ static struct cpu_spec __initdata cpu_specs[] = {
                .icache_bsize           = 128,
                .dcache_bsize           = 128,
                .machine_check          = machine_check_generic,
-               .oprofile_cpu_type      = "ppc64/compat-power5+",
+               .oprofile_cpu_type      = "ppc64/ibm-compat-v1",
+               .oprofile_type          = PPC_OPROFILE_POWER4,
                .platform               = "power5+",
        },
        {       /* Power6 */
@@ -416,7 +417,8 @@ static struct cpu_spec __initdata cpu_specs[] = {
                .icache_bsize           = 128,
                .dcache_bsize           = 128,
                .machine_check          = machine_check_generic,
-               .oprofile_cpu_type      = "ppc64/compat-power6",
+               .oprofile_cpu_type      = "ppc64/ibm-compat-v1",
+               .oprofile_type          = PPC_OPROFILE_POWER4,
                .platform               = "power6",
        },
        {       /* 2.06-compliant processor, i.e. Power7 "architected" mode */
@@ -429,7 +431,8 @@ static struct cpu_spec __initdata cpu_specs[] = {
                .icache_bsize           = 128,
                .dcache_bsize           = 128,
                .machine_check          = machine_check_generic,
-               .oprofile_cpu_type      = "ppc64/compat-power7",
+               .oprofile_type          = PPC_OPROFILE_POWER4,
+               .oprofile_cpu_type      = "ppc64/ibm-compat-v1",
                .platform               = "power7",
        },
        {       /* Power7 */
@@ -1833,8 +1836,10 @@ static void __init setup_cpu_spec(unsigned long offset, struct cpu_spec *s)
                 * and, in that case, keep the current value for
                 * oprofile_cpu_type.
                 */
-               if (old.oprofile_cpu_type == NULL)
-                       t->oprofile_cpu_type = s->oprofile_cpu_type;
+               if (old.oprofile_cpu_type == NULL) {
+                       t->oprofile_cpu_type = old.oprofile_cpu_type;
+                       t->oprofile_type = old.oprofile_type;
+               }
        }
 
        *PTRRELOC(&cur_cpu_spec) = &the_cpu_spec;
index 42c33cebf00f5c6cbc17b0394f94801a79d64d7e..8c0be0902dacb2cc4e766cbe851891bd889f08e7 100644 (file)
 #define IVHD_DEV_EXT_SELECT             0x46
 #define IVHD_DEV_EXT_SELECT_RANGE       0x47
 
-#define IVHD_FLAG_HT_TUN_EN             0x00
-#define IVHD_FLAG_PASSPW_EN             0x01
-#define IVHD_FLAG_RESPASSPW_EN          0x02
-#define IVHD_FLAG_ISOC_EN               0x03
+#define IVHD_FLAG_HT_TUN_EN_MASK        0x01
+#define IVHD_FLAG_PASSPW_EN_MASK        0x02
+#define IVHD_FLAG_RESPASSPW_EN_MASK     0x04
+#define IVHD_FLAG_ISOC_EN_MASK          0x08
 
 #define IVMD_FLAG_EXCL_RANGE            0x08
 #define IVMD_FLAG_UNITY_MAP             0x01
@@ -569,19 +569,19 @@ static void __init init_iommu_from_acpi(struct amd_iommu *iommu,
         * First set the recommended feature enable bits from ACPI
         * into the IOMMU control registers
         */
-       h->flags & IVHD_FLAG_HT_TUN_EN ?
+       h->flags & IVHD_FLAG_HT_TUN_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_HT_TUN_EN) :
                iommu_feature_disable(iommu, CONTROL_HT_TUN_EN);
 
-       h->flags & IVHD_FLAG_PASSPW_EN ?
+       h->flags & IVHD_FLAG_PASSPW_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_PASSPW_EN) :
                iommu_feature_disable(iommu, CONTROL_PASSPW_EN);
 
-       h->flags & IVHD_FLAG_RESPASSPW_EN ?
+       h->flags & IVHD_FLAG_RESPASSPW_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_RESPASSPW_EN) :
                iommu_feature_disable(iommu, CONTROL_RESPASSPW_EN);
 
-       h->flags & IVHD_FLAG_ISOC_EN ?
+       h->flags & IVHD_FLAG_ISOC_EN_MASK ?
                iommu_feature_enable(iommu, CONTROL_ISOC_EN) :
                iommu_feature_disable(iommu, CONTROL_ISOC_EN);
 
index c4f667896c28f1a3eb7e6ae33341f5ba98f74c98..c1caefc82e62512245f52b17251af69d2b2d2c2b 100644 (file)
@@ -1203,6 +1203,8 @@ void __cpuinit cpu_init(void)
        load_TR_desc();
        load_LDT(&init_mm.context);
 
+       t->x86_tss.io_bitmap_base = offsetof(struct tss_struct, io_bitmap);
+
 #ifdef CONFIG_DOUBLEFAULT
        /* Set up doublefault TSS pointer in the GDT */
        __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
index f93047fed79128cebc7d00e081e7108ef24b1c03..d5e30397246bfe5f986559aef6dbf483f89dcd28 100644 (file)
@@ -14,7 +14,7 @@ static void show_cpuinfo_core(struct seq_file *m, struct cpuinfo_x86 *c,
        if (c->x86_max_cores * smp_num_siblings > 1) {
                seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
                seq_printf(m, "siblings\t: %d\n",
-                          cpumask_weight(cpu_sibling_mask(cpu)));
+                          cpumask_weight(cpu_core_mask(cpu)));
                seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
                seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
                seq_printf(m, "apicid\t\t: %d\n", c->apicid);
index 4f115e00486bc1fe50fc8c1987298df3b8ac1266..50dc802a1c469b904154be3901f5fc87ebd7da93 100644 (file)
@@ -87,7 +87,7 @@ static struct kmmio_probe *get_kmmio_probe(unsigned long addr)
 {
        struct kmmio_probe *p;
        list_for_each_entry_rcu(p, &kmmio_probes, list) {
-               if (addr >= p->addr && addr <= (p->addr + p->len))
+               if (addr >= p->addr && addr < (p->addr + p->len))
                        return p;
        }
        return NULL;
index d9d35824c56f30e56266445cdf9ed5877f94bf52..6a40b78b46aafae8273ad7ed12ebbfd44187733a 100644 (file)
@@ -104,11 +104,13 @@ notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
 {
        long ret;
        if (likely(gtod->sysctl_enabled && gtod->clock.vread)) {
-               BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
-                            offsetof(struct timespec, tv_nsec) ||
-                            sizeof(*tv) != sizeof(struct timespec));
-               do_realtime((struct timespec *)tv);
-               tv->tv_usec /= 1000;
+               if (likely(tv != NULL)) {
+                       BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
+                                    offsetof(struct timespec, tv_nsec) ||
+                                    sizeof(*tv) != sizeof(struct timespec));
+                       do_realtime((struct timespec *)tv);
+                       tv->tv_usec /= 1000;
+               }
                if (unlikely(tz != NULL)) {
                        /* Avoid memcpy. Some old compilers fail to inline it */
                        tz->tz_minuteswest = gtod->sys_tz.tz_minuteswest;
index 9f0e672f4be84ff35489b8f5e8724898ec3d9f12..8ad4ffea6920429e0185dd2b7675bd468ed5c354 100644 (file)
@@ -18,6 +18,8 @@
 
 #include <linux/bug.h>
 #include <linux/types.h>
+#include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/iommu.h>
 
index a2dee0eb6dadb5f39b05a9361c37d95b1383faaa..e6ce632a393ee720d5715fae7664e7025f30ae58 100644 (file)
@@ -400,6 +400,9 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
        case KIOCSOUND:
                if (!perm)
                        goto eperm;
+               /* FIXME: This is an old broken API but we need to keep it
+                  supported and somehow separate the historic advertised
+                  tick rate from any real one */
                if (arg)
                        arg = CLOCK_TICK_RATE / arg;
                kd_mksound(arg, 0);
@@ -417,6 +420,9 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 */
                ticks = HZ * ((arg >> 16) & 0xffff) / 1000;
                count = ticks ? (arg & 0xffff) : 0;
+               /* FIXME: This is an old broken API but we need to keep it
+                  supported and somehow separate the historic advertised
+                  tick rate from any real one */
                if (count)
                        count = CLOCK_TICK_RATE / count;
                kd_mksound(count, ticks);
index a04639dc633dcbed29b950e660deab8b37ba8cea..45890447feecf26910f6b6d4dc9854c20c3b454d 100644 (file)
@@ -561,7 +561,6 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
        int saved_x, saved_y;
        struct drm_encoder *encoder;
        bool ret = true;
-       bool depth_changed, bpp_changed;
 
        adjusted_mode = drm_mode_duplicate(dev, mode);
 
@@ -570,15 +569,6 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
        if (!crtc->enabled)
                return true;
 
-       if (old_fb && crtc->fb) {
-               depth_changed = (old_fb->depth != crtc->fb->depth);
-               bpp_changed = (old_fb->bits_per_pixel !=
-                              crtc->fb->bits_per_pixel);
-       } else {
-               depth_changed = true;
-               bpp_changed = true;
-       }
-
        saved_mode = crtc->mode;
        saved_x = crtc->x;
        saved_y = crtc->y;
@@ -590,15 +580,6 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
        crtc->x = x;
        crtc->y = y;
 
-       if (drm_mode_equal(&saved_mode, &crtc->mode)) {
-               if (saved_x != crtc->x || saved_y != crtc->y ||
-                   depth_changed || bpp_changed) {
-                       ret = !crtc_funcs->mode_set_base(crtc, crtc->x, crtc->y,
-                                                        old_fb);
-                       goto done;
-               }
-       }
-
        /* Pass our mode to the connectors and the CRTC to give them a chance to
         * adjust it according to limitations or connector properties, and also
         * a chance to reject the mode entirely.
index c4ada8b6295be28ab60b3edc6f3958fd68e6f66b..f01def16a669bbadfa2a44b4493b74eb0891220c 100644 (file)
@@ -456,7 +456,8 @@ int drm_ioctl(struct inode *inode, struct file *filp,
                retcode = -EINVAL;
        } else if (((ioctl->flags & DRM_ROOT_ONLY) && !capable(CAP_SYS_ADMIN)) ||
                   ((ioctl->flags & DRM_AUTH) && !file_priv->authenticated) ||
-                  ((ioctl->flags & DRM_MASTER) && !file_priv->is_master)) {
+                  ((ioctl->flags & DRM_MASTER) && !file_priv->is_master) ||
+                  (!(ioctl->flags & DRM_CONTROL_ALLOW) && (file_priv->minor->type == DRM_MINOR_CONTROL))) {
                retcode = -EACCES;
        } else {
                if (cmd & (IOC_IN | IOC_OUT)) {
index ef878615c49f65d33c47f2bb6397eb0e34d6cd3b..b9631e3a1ea69f421177cfead3e1c2ce3be9993b 100644 (file)
@@ -402,14 +402,14 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
        if (dev->driver->load) {
                ret = dev->driver->load(dev, ent->driver_data);
                if (ret)
-                       goto err_g3;
+                       goto err_g4;
        }
 
         /* setup the grouping for the legacy output */
        if (drm_core_check_feature(dev, DRIVER_MODESET)) {
                ret = drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group);
                if (ret)
-                       goto err_g3;
+                       goto err_g4;
        }
 
        list_add_tail(&dev->driver_item, &driver->device_list);
@@ -420,8 +420,11 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
 
        return 0;
 
-err_g3:
+err_g4:
        drm_put_minor(&dev->primary);
+err_g3:
+       if (drm_core_check_feature(dev, DRIVER_MODESET))
+               drm_put_minor(&dev->control);
 err_g2:
        pci_disable_device(pdev);
 err_g1:
@@ -502,11 +505,11 @@ void drm_put_dev(struct drm_device *dev)
                dev->agp = NULL;
        }
 
-       drm_ht_remove(&dev->map_hash);
-       drm_ctxbitmap_cleanup(dev);
-
        list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
                drm_rmmap(dev, r_list->map);
+       drm_ht_remove(&dev->map_hash);
+
+       drm_ctxbitmap_cleanup(dev);
 
        if (drm_core_check_feature(dev, DRIVER_MODESET))
                drm_put_minor(&dev->control);
index 022876ae34f07f72b5906d50eabb936586d01e8d..8f9372921f8296cc0fe9961ad5afda7165215bfa 100644 (file)
@@ -489,9 +489,7 @@ int drm_sysfs_device_add(struct drm_minor *minor)
 
        return 0;
 
-       device_unregister(&minor->kdev);
 err_out:
-
        return err;
 }
 
index 32de4cedc3631e7c2d3419b5f9a8f5fc977321fb..077c0455a6b93ac10c4cf14ef4ce7911ee41eacd 100644 (file)
@@ -511,9 +511,9 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
 
 #if __OS_HAS_AGP
        if (!dev_priv->is_pci) {
-               drm_core_ioremap(dev_priv->cce_ring, dev);
-               drm_core_ioremap(dev_priv->ring_rptr, dev);
-               drm_core_ioremap(dev->agp_buffer_map, dev);
+               drm_core_ioremap_wc(dev_priv->cce_ring, dev);
+               drm_core_ioremap_wc(dev_priv->ring_rptr, dev);
+               drm_core_ioremap_wc(dev->agp_buffer_map, dev);
                if (!dev_priv->cce_ring->handle ||
                    !dev_priv->ring_rptr->handle ||
                    !dev->agp_buffer_map->handle) {
index ed4d27e6ee6f14a30cfc5c860c40f730630c9655..8071d965f1428871b98df31bc68440bdd40b4ba3 100644 (file)
  * 1.27- Add support for IGP GART
  * 1.28- Add support for VBL on CRTC2
  * 1.29- R500 3D cmd buffer support
+ * 1.30- Add support for occlusion queries
  */
 #define DRIVER_MAJOR           1
-#define DRIVER_MINOR           29
+#define DRIVER_MINOR           30
 #define DRIVER_PATCHLEVEL      0
 
 /*
index d420cc5f563313d81f1b0d2e816a9d44c98819ca..e25e13980af3543a7dea3b9a60ec61a64877631b 100644 (file)
@@ -104,7 +104,7 @@ static int sclhi(struct i2c_algo_bit_data *adap)
                 * chips may hold it low ("clock stretching") while they
                 * are processing data internally.
                 */
-               if (time_after_eq(jiffies, start + adap->timeout))
+               if (time_after(jiffies, start + adap->timeout))
                        return -ETIMEDOUT;
                cond_resched();
        }
index 6318f7ddc1d44d95189d6e18fe8b4ee627033349..78d42aae0089282efb3385f7c6c47963c8574366 100644 (file)
@@ -287,10 +287,21 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
 
                case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */
                        DEB2("NOT ACK received after data byte\n");
+                       pca_stop(adap);
                        goto out;
 
                case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */
                        DEB2("Arbitration lost\n");
+                       /*
+                        * The PCA9564 data sheet (2006-09-01) says "A
+                        * START condition will be transmitted when the
+                        * bus becomes free (STOP or SCL and SDA high)"
+                        * when the STA bit is set (p. 11).
+                        *
+                        * In case this won't work, try pca_reset()
+                        * instead.
+                        */
+                       pca_start(adap);
                        goto out;
 
                case 0x58: /* Data byte has been received; NOT ACK has been returned */
index 981e080b32aee0508e2fceb9e654ccf31cdfee9b..d108450df064552b56f5886200231f3e53e8c57b 100644 (file)
@@ -284,7 +284,7 @@ static int ali1535_transaction(struct i2c_adapter *adap)
                 && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                result = -ETIMEDOUT;
                dev_err(&adap->dev, "SMBus Timeout!\n");
        }
index 39066dee46e3552a3ffee94ccfcfabb80521e1f1..d627fceb790b9e16c3fb2b15c1e544a653e1a46d 100644 (file)
@@ -306,7 +306,7 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
                 && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                result = -ETIMEDOUT;
                dev_err(&adap->dev, "SMBus Timeout!\n");
        }
index 220f4a1eee1dc55460d686777736b6d22c2a6018..f7d6fe9c49baa3724c38463448acbcb5a4384cb4 100644 (file)
@@ -126,7 +126,7 @@ static int amd756_transaction(struct i2c_adapter *adap)
                } while ((temp & (GS_HST_STS | GS_SMB_STS)) &&
                         (timeout++ < MAX_TIMEOUT));
                /* If the SMBus is still busy, we give up */
-               if (timeout >= MAX_TIMEOUT) {
+               if (timeout > MAX_TIMEOUT) {
                        dev_dbg(&adap->dev, "Busy wait timeout (%04x)\n", temp);
                        goto abort;
                }
@@ -143,7 +143,7 @@ static int amd756_transaction(struct i2c_adapter *adap)
        } while ((temp & GS_HST_STS) && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "Completion timeout!\n");
                goto abort;
        }
index 10411848fd704f58e790cc3587a92e07bd6f22c6..9d2c5adf5d4fbbcf06c8baf68d98cb01c5b93706 100644 (file)
@@ -237,7 +237,7 @@ static int i801_transaction(int xact)
                status = inb_p(SMBHSTSTS);
        } while ((status & SMBHSTSTS_HOST_BUSY) && (timeout++ < MAX_TIMEOUT));
 
-       result = i801_check_post(status, timeout >= MAX_TIMEOUT);
+       result = i801_check_post(status, timeout > MAX_TIMEOUT);
        if (result < 0)
                return result;
 
@@ -257,9 +257,9 @@ static void i801_wait_hwpec(void)
        } while ((!(status & SMBHSTSTS_INTR))
                 && (timeout++ < MAX_TIMEOUT));
 
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT)
                dev_dbg(&I801_dev->dev, "PEC Timeout!\n");
-       }
+
        outb_p(status, SMBHSTSTS);
 }
 
@@ -344,7 +344,7 @@ static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
                while ((!(status & SMBHSTSTS_BYTE_DONE))
                       && (timeout++ < MAX_TIMEOUT));
 
-               result = i801_check_post(status, timeout >= MAX_TIMEOUT);
+               result = i801_check_post(status, timeout > MAX_TIMEOUT);
                if (result < 0)
                        return result;
 
index b9c01aa90036d49eb30fa841ca0e2924f98ddb82..9f6b8e0f8632af44c2eb4c49667277e0656bec7b 100644 (file)
@@ -112,7 +112,7 @@ static int sch_transaction(void)
        } while ((temp & 0x08) && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_err(&sch_adapter.dev, "SMBus Timeout!\n");
                result = -ETIMEDOUT;
        }
index 2ff4683703a8ddfc9871040d0a9c79406e71bd41..ec11d1c4e77bdbcd79e45e337ce05dffa0894bb8 100644 (file)
@@ -173,7 +173,7 @@ static int nforce2_check_status(struct i2c_adapter *adap)
                temp = inb_p(NVIDIA_SMB_STS);
        } while ((!temp) && (timeout++ < MAX_TIMEOUT));
 
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
                if (smbus->can_abort)
                        nforce2_abort(adap);
index f320ab27da463ae26b4d2ed078d250fa7c72d2c9..139f0c7f12a406db35d9b73f08ce4ab2f47132a3 100644 (file)
@@ -256,7 +256,7 @@ static int sis5595_transaction(struct i2c_adapter *adap)
        } while (!(temp & 0x40) && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
                result = -ETIMEDOUT;
        }
index 50c3610e60288d0cd123d52b7040b5ad3217cb70..70ca41e90e58741d9e0a1cce9088e380f69fa48c 100644 (file)
@@ -173,7 +173,7 @@ static int sis630_transaction_wait(struct i2c_adapter *adap, int size)
        } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
                result = -ETIMEDOUT;
        }
index 7e1594b40579f78561814070eb71a5a20c66bcd2..8295885b2fdb9417c18f19becc3a3ce045240d18 100644 (file)
@@ -132,7 +132,7 @@ static int sis96x_transaction(int size)
        } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
 
        /* If the SMBus is still busy, we give up */
-       if (timeout >= MAX_TIMEOUT) {
+       if (timeout > MAX_TIMEOUT) {
                dev_dbg(&sis96x_adapter.dev, "SMBus Timeout! (0x%02x)\n", temp);
                result = -ETIMEDOUT;
        }
index 2e2a5923d4c2128b2233b3f1aebc469dca5c337c..a71e245801eec7ffa5183f59d28d9ef8c01576b9 100644 (file)
@@ -64,6 +64,7 @@ struct isl29003_data {
        struct i2c_client *client;
        struct mutex lock;
        u8 reg_cache[ISL29003_NUM_CACHABLE_REGS];
+       u8 power_state_before_suspend;
 };
 
 static int gain_range[] = {
@@ -411,6 +412,9 @@ static int __devexit isl29003_remove(struct i2c_client *client)
 #ifdef CONFIG_PM
 static int isl29003_suspend(struct i2c_client *client, pm_message_t mesg)
 {
+       struct isl29003_data *data = i2c_get_clientdata(client);
+
+       data->power_state_before_suspend = isl29003_get_power_state(client);
        return isl29003_set_power_state(client, 0);
 }
 
@@ -421,10 +425,11 @@ static int isl29003_resume(struct i2c_client *client)
 
        /* restore registers from cache */
        for (i = 0; i < ARRAY_SIZE(data->reg_cache); i++)
-               if (!i2c_smbus_write_byte_data(client, i, data->reg_cache[i]))
+               if (i2c_smbus_write_byte_data(client, i, data->reg_cache[i]))
                        return -EIO;
 
-       return 0;
+       return isl29003_set_power_state(client,
+               data->power_state_before_suspend);
 }
 
 #else
index fe8041e619eabec7029a12c8f7c0983e2a56346c..b25e9b6516ae6942d6e9a0c34fc3f0dba0f9556a 100644 (file)
@@ -253,6 +253,14 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
                brq.data.blocks = req->nr_sectors;
 
+               /*
+                * The block layer doesn't support all sector count
+                * restrictions, so we need to be prepared for too big
+                * requests.
+                */
+               if (brq.data.blocks > card->host->max_blk_count)
+                       brq.data.blocks = card->host->max_blk_count;
+
                /*
                 * After a read error, we redo the request one sector at a time
                 * in order to accurately determine which sectors can be read
index fa073ab3fa34f9d906ecfae588cc023409b78b59..26491173275619fa75544a1992ba79eaf1ed963a 100644 (file)
@@ -706,7 +706,7 @@ static void mmc_power_up(struct mmc_host *host)
         * This delay should be sufficient to allow the power supply
         * to reach the minimum voltage.
         */
-       mmc_delay(2);
+       mmc_delay(10);
 
        host->ios.clock = host->f_min;
        host->ios.power_mode = MMC_POWER_ON;
@@ -716,7 +716,7 @@ static void mmc_power_up(struct mmc_host *host)
         * This delay must be at least 74 clock sizes, or 1 ms, or the
         * time required to reach a stable voltage.
         */
-       mmc_delay(2);
+       mmc_delay(10);
 }
 
 static void mmc_power_off(struct mmc_host *host)
index a663429b3d5530243841b0da1627d002cbe26d50..36875dcfa492450a3137b97fe59bdc1865bc35d4 100644 (file)
@@ -514,6 +514,7 @@ static int __devinit mmci_probe(struct amba_device *dev, void *id)
        }
 
        host = mmc_priv(mmc);
+       host->mmc = mmc;
        /* Bits 12 thru 19 is the designer */
        host->hw_designer = (dev->periphid >> 12) & 0xff;
        /* Bits 20 thru 23 is the revison */
@@ -545,7 +546,6 @@ static int __devinit mmci_probe(struct amba_device *dev, void *id)
                host->mclk = clk_get_rate(host->clk);
                DBG(host, "eventual mclk rate: %u Hz\n", host->mclk);
        }
-       host->mmc = mmc;
        host->base = ioremap(dev->res.start, SZ_4K);
        if (!host->base) {
                ret = -ENOMEM;
index b5c375d94ab344b38cf9ebbc90dd2cab711bb4cb..c643d0fe118f1369dc63439bba6aa1e4dbbf9021 100644 (file)
@@ -825,24 +825,23 @@ static int __exit mvsd_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int mvsd_suspend(struct platform_device *dev, pm_message_t state,
-                          u32 level)
+static int mvsd_suspend(struct platform_device *dev, pm_message_t state)
 {
        struct mmc_host *mmc = platform_get_drvdata(dev);
        int ret = 0;
 
-       if (mmc && level == SUSPEND_DISABLE)
+       if (mmc)
                ret = mmc_suspend_host(mmc, state);
 
        return ret;
 }
 
-static int mvsd_resume(struct platform_device *dev, u32 level)
+static int mvsd_resume(struct platform_device *dev)
 {
-       struct mmc_host *mmc = platform_dev_get_drvdata(dev);
+       struct mmc_host *mmc = platform_get_drvdata(dev);
        int ret = 0;
 
-       if (mmc && level == RESUME_ENABLE)
+       if (mmc)
                ret = mmc_resume_host(mmc);
 
        return ret;
index cd37962ec44fd997d4e8ec76820d0dcf607f83e9..65be27995d5cbe7d9ec1aaeaa7dbb79f91a65967 100644 (file)
@@ -522,8 +522,8 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
 
        host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pci_slot));
        if (IS_ERR(host)) {
-               ret = PTR_ERR(host);
-               goto unmap;
+               dev_err(&pdev->dev, "cannot allocate host\n");
+               return ERR_PTR(PTR_ERR(host));
        }
 
        slot = sdhci_priv(host);
@@ -541,7 +541,7 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
        ret = pci_request_region(pdev, bar, mmc_hostname(host->mmc));
        if (ret) {
                dev_err(&pdev->dev, "cannot request region\n");
-               return ERR_PTR(ret);
+               goto free;
        }
 
        addr = pci_resource_start(pdev, bar);
@@ -572,6 +572,8 @@ unmap:
 
 release:
        pci_release_region(pdev, bar);
+
+free:
        sdhci_free_host(host);
 
        return ERR_PTR(ret);
index f20a834f430925827d9b8490ab481f058ff97696..65c6f996bbd31cc7e9851ac781c69241c68c3fa5 100644 (file)
 #define  SDHCI_INT_DATA_MASK   (SDHCI_INT_DATA_END | SDHCI_INT_DMA_END | \
                SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL | \
                SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_DATA_CRC | \
-               SDHCI_INT_DATA_END_BIT)
+               SDHCI_INT_DATA_END_BIT | SDHCI_ADMA_ERROR)
 #define SDHCI_INT_ALL_MASK     ((unsigned int)-1)
 
 #define SDHCI_ACMD12_ERR       0x3C
index 553a8991977807ebe5c9edc34b2945da4876053b..46d312bedfb8ce027d246a33c483a70047932023 100644 (file)
@@ -1706,10 +1706,8 @@ void bond_alb_handle_active_change(struct bonding *bond, struct slave *new_slave
  * Called with RTNL
  */
 int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
-       __releases(&bond->curr_slave_lock)
-       __releases(&bond->lock)
        __acquires(&bond->lock)
-       __acquires(&bond->curr_slave_lock)
+       __releases(&bond->lock)
 {
        struct bonding *bond = netdev_priv(bond_dev);
        struct sockaddr *sa = addr;
@@ -1745,9 +1743,6 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
                }
        }
 
-       write_unlock_bh(&bond->curr_slave_lock);
-       read_unlock(&bond->lock);
-
        if (swap_slave) {
                alb_swap_mac_addr(bond, swap_slave, bond->curr_active_slave);
                alb_fasten_mac_swap(bond, swap_slave, bond->curr_active_slave);
@@ -1755,16 +1750,15 @@ int bond_alb_set_mac_address(struct net_device *bond_dev, void *addr)
                alb_set_slave_mac_addr(bond->curr_active_slave, bond_dev->dev_addr,
                                       bond->alb_info.rlb_enabled);
 
+               read_lock(&bond->lock);
                alb_send_learning_packets(bond->curr_active_slave, bond_dev->dev_addr);
                if (bond->alb_info.rlb_enabled) {
                        /* inform clients mac address has changed */
                        rlb_req_update_slave_clients(bond, bond->curr_active_slave);
                }
+               read_unlock(&bond->lock);
        }
 
-       read_lock(&bond->lock);
-       write_lock_bh(&bond->curr_slave_lock);
-
        return 0;
 }
 
index 63369b6b14d4f17ef7b756d81ebf89db3d73e896..2188a96fc090a644594ca17406acd8d041566982 100644 (file)
@@ -2213,33 +2213,24 @@ static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *in
 {
        struct bonding *bond = netdev_priv(bond_dev);
        struct slave *slave;
-       int i, found = 0;
-
-       if (info->slave_id < 0) {
-               return -ENODEV;
-       }
+       int i, res = -ENODEV;
 
        read_lock(&bond->lock);
 
        bond_for_each_slave(bond, slave, i) {
                if (i == (int)info->slave_id) {
-                       found = 1;
+                       res = 0;
+                       strcpy(info->slave_name, slave->dev->name);
+                       info->link = slave->link;
+                       info->state = slave->state;
+                       info->link_failure_count = slave->link_failure_count;
                        break;
                }
        }
 
        read_unlock(&bond->lock);
 
-       if (found) {
-               strcpy(info->slave_name, slave->dev->name);
-               info->link = slave->link;
-               info->state = slave->state;
-               info->link_failure_count = slave->link_failure_count;
-       } else {
-               return -ENODEV;
-       }
-
-       return 0;
+       return res;
 }
 
 /*-------------------------------- Monitoring -------------------------------*/
@@ -5167,16 +5158,15 @@ int bond_create(char *name, struct bond_params *params)
        up_write(&bonding_rwsem);
        rtnl_unlock(); /* allows sysfs registration of net device */
        res = bond_create_sysfs_entry(netdev_priv(bond_dev));
-       if (res < 0) {
-               rtnl_lock();
-               down_write(&bonding_rwsem);
-               bond_deinit(bond_dev);
-               unregister_netdevice(bond_dev);
-               goto out_rtnl;
-       }
+       if (res < 0)
+               goto out_unreg;
 
        return 0;
 
+out_unreg:
+       rtnl_lock();
+       down_write(&bonding_rwsem);
+       unregister_netdevice(bond_dev);
 out_bond:
        bond_deinit(bond_dev);
 out_netdev:
index e1bd690ff831baa9fb85d52a1532a78284222d47..4f68aeb2679adcbf0f11a617ab815fa06a6bb9f5 100644 (file)
@@ -3779,7 +3779,7 @@ int t3_prep_adapter(struct adapter *adapter, const struct adapter_info *ai,
 
        adapter->params.info = ai;
        adapter->params.nports = ai->nports0 + ai->nports1;
-       adapter->params.chan_map = !!ai->nports0 | (!!ai->nports1 << 1);
+       adapter->params.chan_map = (!!ai->nports0) | (!!ai->nports1 << 1);
        adapter->params.rev = t3_read_reg(adapter, A_PL_REV);
        /*
         * We used to only run the "adapter check task" once a second if
index 6a46ceed9436cce43087bb7d33cfd24ec3c71603..b1419e21b46b44b930c2ec974952ed2509363e09 100644 (file)
@@ -3738,7 +3738,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
        struct e1000_hw *hw = &adapter->hw;
        u32 rctl, icr = er32(ICR);
 
-       if (unlikely((!icr) || test_bit(__E1000_RESETTING, &adapter->flags)))
+       if (unlikely((!icr) || test_bit(__E1000_DOWN, &adapter->flags)))
                return IRQ_NONE;  /* Not our interrupt */
 
        /* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
index 6e317caf429c98efc00b8e21acda3864946599d3..16a41389575aeb5f510f30b7f8343e67ff392ed4 100644 (file)
@@ -40,7 +40,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME       "ehea"
-#define DRV_VERSION    "EHEA_0100"
+#define DRV_VERSION    "EHEA_0101"
 
 /* eHEA capability flags */
 #define DLPAR_PORT_ADD_REM 1
index 604c844d07693c0670521d3d26acf236499b9ec5..b22dab9153f67788f8292ecfe877726cb7a0505d 100644 (file)
@@ -545,14 +545,17 @@ static inline struct sk_buff *get_skb_by_index(struct sk_buff **skb_array,
        x &= (arr_len - 1);
 
        pref = skb_array[x];
-       prefetchw(pref);
-       prefetchw(pref + EHEA_CACHE_LINE);
-
-       pref = (skb_array[x]->data);
-       prefetch(pref);
-       prefetch(pref + EHEA_CACHE_LINE);
-       prefetch(pref + EHEA_CACHE_LINE * 2);
-       prefetch(pref + EHEA_CACHE_LINE * 3);
+       if (pref) {
+               prefetchw(pref);
+               prefetchw(pref + EHEA_CACHE_LINE);
+
+               pref = (skb_array[x]->data);
+               prefetch(pref);
+               prefetch(pref + EHEA_CACHE_LINE);
+               prefetch(pref + EHEA_CACHE_LINE * 2);
+               prefetch(pref + EHEA_CACHE_LINE * 3);
+       }
+
        skb = skb_array[skb_index];
        skb_array[skb_index] = NULL;
        return skb;
@@ -569,12 +572,14 @@ static inline struct sk_buff *get_skb_by_index_ll(struct sk_buff **skb_array,
        x &= (arr_len - 1);
 
        pref = skb_array[x];
-       prefetchw(pref);
-       prefetchw(pref + EHEA_CACHE_LINE);
+       if (pref) {
+               prefetchw(pref);
+               prefetchw(pref + EHEA_CACHE_LINE);
 
-       pref = (skb_array[x]->data);
-       prefetchw(pref);
-       prefetchw(pref + EHEA_CACHE_LINE);
+               pref = (skb_array[x]->data);
+               prefetchw(pref);
+               prefetchw(pref + EHEA_CACHE_LINE);
+       }
 
        skb = skb_array[wqe_index];
        skb_array[wqe_index] = NULL;
index b3185bf2c158b41b02ad4efd6b862775c9a37637..a400d7115f78ce94f8a03f31f9631ed170b9cb81 100644 (file)
@@ -393,12 +393,12 @@ struct mv643xx_eth_private {
        struct work_struct tx_timeout_task;
 
        struct napi_struct napi;
+       u8 oom;
        u8 work_link;
        u8 work_tx;
        u8 work_tx_end;
        u8 work_rx;
        u8 work_rx_refill;
-       u8 work_rx_oom;
 
        int skb_size;
        struct sk_buff_head rx_recycle;
@@ -661,7 +661,7 @@ static int rxq_refill(struct rx_queue *rxq, int budget)
                                            dma_get_cache_alignment() - 1);
 
                if (skb == NULL) {
-                       mp->work_rx_oom |= 1 << rxq->index;
+                       mp->oom = 1;
                        goto oom;
                }
 
@@ -1255,7 +1255,6 @@ static void mib_counters_update(struct mv643xx_eth_private *mp)
 
        spin_lock_bh(&mp->mib_counters_lock);
        p->good_octets_received += mib_read(mp, 0x00);
-       p->good_octets_received += (u64)mib_read(mp, 0x04) << 32;
        p->bad_octets_received += mib_read(mp, 0x08);
        p->internal_mac_transmit_err += mib_read(mp, 0x0c);
        p->good_frames_received += mib_read(mp, 0x10);
@@ -1269,7 +1268,6 @@ static void mib_counters_update(struct mv643xx_eth_private *mp)
        p->frames_512_to_1023_octets += mib_read(mp, 0x30);
        p->frames_1024_to_max_octets += mib_read(mp, 0x34);
        p->good_octets_sent += mib_read(mp, 0x38);
-       p->good_octets_sent += (u64)mib_read(mp, 0x3c) << 32;
        p->good_frames_sent += mib_read(mp, 0x40);
        p->excessive_collision += mib_read(mp, 0x44);
        p->multicast_frames_sent += mib_read(mp, 0x48);
@@ -2167,8 +2165,10 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
 
        mp = container_of(napi, struct mv643xx_eth_private, napi);
 
-       mp->work_rx_refill |= mp->work_rx_oom;
-       mp->work_rx_oom = 0;
+       if (unlikely(mp->oom)) {
+               mp->oom = 0;
+               del_timer(&mp->rx_oom);
+       }
 
        work_done = 0;
        while (work_done < budget) {
@@ -2182,8 +2182,10 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
                        continue;
                }
 
-               queue_mask = mp->work_tx | mp->work_tx_end |
-                               mp->work_rx | mp->work_rx_refill;
+               queue_mask = mp->work_tx | mp->work_tx_end | mp->work_rx;
+               if (likely(!mp->oom))
+                       queue_mask |= mp->work_rx_refill;
+
                if (!queue_mask) {
                        if (mv643xx_eth_collect_events(mp))
                                continue;
@@ -2204,7 +2206,7 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
                        txq_maybe_wake(mp->txq + queue);
                } else if (mp->work_rx & queue_mask) {
                        work_done += rxq_process(mp->rxq + queue, work_tbd);
-               } else if (mp->work_rx_refill & queue_mask) {
+               } else if (!mp->oom && (mp->work_rx_refill & queue_mask)) {
                        work_done += rxq_refill(mp->rxq + queue, work_tbd);
                } else {
                        BUG();
@@ -2212,7 +2214,7 @@ static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
        }
 
        if (work_done < budget) {
-               if (mp->work_rx_oom)
+               if (mp->oom)
                        mod_timer(&mp->rx_oom, jiffies + (HZ / 10));
                napi_complete(napi);
                wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
@@ -2372,7 +2374,7 @@ static int mv643xx_eth_open(struct net_device *dev)
                rxq_refill(mp->rxq + i, INT_MAX);
        }
 
-       if (mp->work_rx_oom) {
+       if (mp->oom) {
                mp->rx_oom.expires = jiffies + (HZ / 10);
                add_timer(&mp->rx_oom);
        }
index eb66f658f9d1bec889f271d457a6f285a236cbad..7d83896b8c2614a1289a10526e5875f0fb388f3c 100644 (file)
@@ -374,18 +374,17 @@ static int __devinit ne2k_pci_init_one (struct pci_dev *pdev,
        dev->ethtool_ops = &ne2k_pci_ethtool_ops;
        NS8390_init(dev, 0);
 
+       memcpy(dev->dev_addr, SA_prom, 6);
+       memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
+
        i = register_netdev(dev);
        if (i)
                goto err_out_free_netdev;
 
-       for(i = 0; i < 6; i++)
-               dev->dev_addr[i] = SA_prom[i];
        printk("%s: %s found at %#lx, IRQ %d, %pM.\n",
               dev->name, pci_clone_list[chip_idx].name, ioaddr, dev->irq,
               dev->dev_addr);
 
-       memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
-
        return 0;
 
 err_out_free_netdev:
index eceadf787a67d5762cad157b5104a033f952a063..bf4af5248cb75549a46415f21ab7685c948e1b42 100644 (file)
@@ -664,7 +664,7 @@ static int netconsole_netdev_event(struct notifier_block *this,
        struct netconsole_target *nt;
        struct net_device *dev = ptr;
 
-       if (!(event == NETDEV_CHANGENAME))
+       if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER))
                goto done;
 
        spin_lock_irqsave(&target_list_lock, flags);
@@ -675,6 +675,15 @@ static int netconsole_netdev_event(struct notifier_block *this,
                        case NETDEV_CHANGENAME:
                                strlcpy(nt->np.dev_name, dev->name, IFNAMSIZ);
                                break;
+                       case NETDEV_UNREGISTER:
+                               if (!nt->enabled)
+                                       break;
+                               netpoll_cleanup(&nt->np);
+                               nt->enabled = 0;
+                               printk(KERN_INFO "netconsole: network logging stopped"
+                                       ", interface %s unregistered\n",
+                                       dev->name);
+                               break;
                        }
                }
                netconsole_target_put(nt);
index 8ee21030e9ac8db040e75f006950e4b7b16c66ee..dfc6cf765fbdf77e5081679c9a2ac2d14e8d99a0 100644 (file)
@@ -180,6 +180,20 @@ config USB_NET_CDCETHER
          IEEE 802 "local assignment" bit is set in the address, a "usbX"
          name is used instead.
 
+config USB_NET_CDC_EEM
+       tristate "CDC EEM support"
+       depends on USB_USBNET && EXPERIMENTAL
+       help
+         This option supports devices conforming to the Communication Device
+         Class (CDC) Ethernet Emulation Model, a specification that's easy to
+         implement in device firmware.  The CDC EEM specifications are available
+         from <http://www.usb.org/>.
+
+         This driver creates an interface named "ethX", where X depends on
+         what other networking devices you have in use.  However, if the
+         IEEE 802 "local assignment" bit is set in the address, a "usbX"
+         name is used instead.
+
 config USB_NET_DM9601
        tristate "Davicom DM9601 based USB 1.1 10/100 ethernet devices"
        depends on USB_USBNET
index 88a87eeb376afd81879e8ff03180987f02f09f0f..c8aef62cf2b74a90f332068be027bbe5a7eaf92d 100644 (file)
@@ -9,6 +9,7 @@ obj-$(CONFIG_USB_RTL8150)       += rtl8150.o
 obj-$(CONFIG_USB_HSO)          += hso.o
 obj-$(CONFIG_USB_NET_AX8817X)  += asix.o
 obj-$(CONFIG_USB_NET_CDCETHER) += cdc_ether.o
+obj-$(CONFIG_USB_NET_CDC_EEM)  += cdc_eem.o
 obj-$(CONFIG_USB_NET_DM9601)   += dm9601.o
 obj-$(CONFIG_USB_NET_SMSC95XX) += smsc95xx.o
 obj-$(CONFIG_USB_NET_GL620A)   += gl620a.o
diff --git a/drivers/net/usb/cdc_eem.c b/drivers/net/usb/cdc_eem.c
new file mode 100644 (file)
index 0000000..80e0177
--- /dev/null
@@ -0,0 +1,381 @@
+/*
+ * USB CDC EEM network interface driver
+ * Copyright (C) 2009 Oberthur Technologies
+ * by Omar Laazimani, Olivier Condemine
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ctype.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/crc32.h>
+#include <linux/usb/cdc.h>
+#include <linux/usb/usbnet.h>
+
+
+/*
+ * This driver is an implementation of the CDC "Ethernet Emulation
+ * Model" (EEM) specification, which encapsulates Ethernet frames
+ * for transport over USB using a simpler USB device model than the
+ * previous CDC "Ethernet Control Model" (ECM, or "CDC Ethernet").
+ *
+ * For details, see www.usb.org/developers/devclass_docs/CDC_EEM10.pdf
+ *
+ * This version has been tested with GIGAntIC WuaoW SIM Smart Card on 2.6.24,
+ * 2.6.27 and 2.6.30rc2 kernel.
+ * It has also been validated on Openmoko Om 2008.12 (based on 2.6.24 kernel).
+ * build on 23-April-2009
+ */
+
+#define EEM_HEAD       2               /* 2 byte header */
+
+/*-------------------------------------------------------------------------*/
+
+static void eem_linkcmd_complete(struct urb *urb)
+{
+       dev_kfree_skb(urb->context);
+       usb_free_urb(urb);
+}
+
+static void eem_linkcmd(struct usbnet *dev, struct sk_buff *skb)
+{
+       struct urb              *urb;
+       int                     status;
+
+       urb = usb_alloc_urb(0, GFP_ATOMIC);
+       if (!urb)
+               goto fail;
+
+       usb_fill_bulk_urb(urb, dev->udev, dev->out,
+                       skb->data, skb->len, eem_linkcmd_complete, skb);
+
+       status = usb_submit_urb(urb, GFP_ATOMIC);
+       if (status) {
+               usb_free_urb(urb);
+fail:
+               dev_kfree_skb(skb);
+               devwarn(dev, "link cmd failure\n");
+               return;
+       }
+}
+
+static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+       int status = 0;
+
+       status = usbnet_get_endpoints(dev, intf);
+       if (status < 0) {
+               usb_set_intfdata(intf, NULL);
+               usb_driver_release_interface(driver_of(intf), intf);
+               return status;
+       }
+
+       /* no jumbogram (16K) support for now */
+
+       dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN;
+
+       return 0;
+}
+
+/*
+ * EEM permits packing multiple Ethernet frames into USB transfers
+ * (a "bundle"), but for TX we don't try to do that.
+ */
+static struct sk_buff *eem_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
+                                      gfp_t flags)
+{
+       struct sk_buff  *skb2 = NULL;
+       u16             len = skb->len;
+       u32             crc = 0;
+       int             padlen = 0;
+
+       /* When ((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket) is
+        * zero, stick two bytes of zero length EEM packet on the end.
+        * Else the framework would add invalid single byte padding,
+        * since it can't know whether ZLPs will be handled right by
+        * all the relevant hardware and software.
+        */
+       if (!((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket))
+               padlen += 2;
+
+       if (!skb_cloned(skb)) {
+               int     headroom = skb_headroom(skb);
+               int     tailroom = skb_tailroom(skb);
+
+               if ((tailroom >= ETH_FCS_LEN + padlen)
+                               && (headroom >= EEM_HEAD))
+                       goto done;
+
+               if ((headroom + tailroom)
+                               > (EEM_HEAD + ETH_FCS_LEN + padlen)) {
+                       skb->data = memmove(skb->head +
+                                       EEM_HEAD,
+                                       skb->data,
+                                       skb->len);
+                       skb_set_tail_pointer(skb, len);
+                       goto done;
+               }
+       }
+
+       skb2 = skb_copy_expand(skb, EEM_HEAD, ETH_FCS_LEN + padlen, flags);
+       if (!skb2)
+               return NULL;
+
+       dev_kfree_skb_any(skb);
+       skb = skb2;
+
+done:
+       /* we don't use the "no Ethernet CRC" option */
+       crc = crc32_le(~0, skb->data, skb->len);
+       crc = ~crc;
+
+       put_unaligned_le32(crc, skb_put(skb, 4));
+
+       /* EEM packet header format:
+        * b0..13:      length of ethernet frame
+        * b14:         bmCRC (1 == valid Ethernet CRC)
+        * b15:         bmType (0 == data)
+        */
+       len = skb->len;
+       put_unaligned_le16(BIT(14) | len, skb_push(skb, 2));
+
+       /* Bundle a zero length EEM packet if needed */
+       if (padlen)
+               put_unaligned_le16(0, skb_put(skb, 2));
+
+       return skb;
+}
+
+static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+       /*
+        * Our task here is to strip off framing, leaving skb with one
+        * data frame for the usbnet framework code to process.  But we
+        * may have received multiple EEM payloads, or command payloads.
+        * So we must process _everything_ as if it's a header, except
+        * maybe the last data payload
+        *
+        * REVISIT the framework needs updating so that when we consume
+        * all payloads (the last or only message was a command, or a
+        * zero length EEM packet) that is not accounted as an rx_error.
+        */
+       do {
+               struct sk_buff  *skb2 = NULL;
+               u16             header;
+               u16             len = 0;
+
+               /* incomplete EEM header? */
+               if (skb->len < EEM_HEAD)
+                       return 0;
+
+               /*
+                * EEM packet header format:
+                * b0..14:      EEM type dependant (Data or Command)
+                * b15:         bmType
+                */
+               header = get_unaligned_le16(skb->data);
+               skb_pull(skb, EEM_HEAD);
+
+               /*
+                * The bmType bit helps to denote when EEM
+                * packet is data or command :
+                *      bmType = 0      : EEM data payload
+                *      bmType = 1      : EEM (link) command
+                */
+               if (header & BIT(15)) {
+                       u16     bmEEMCmd;
+
+                       /*
+                        * EEM (link) command packet:
+                        * b0..10:      bmEEMCmdParam
+                        * b11..13:     bmEEMCmd
+                        * b14:         bmReserved (must be 0)
+                        * b15:         1 (EEM command)
+                        */
+                       if (header & BIT(14)) {
+                               devdbg(dev, "reserved command %04x\n", header);
+                               continue;
+                       }
+
+                       bmEEMCmd = (header >> 11) & 0x7;
+                       switch (bmEEMCmd) {
+
+                       /* Responding to echo requests is mandatory. */
+                       case 0:         /* Echo command */
+                               len = header & 0x7FF;
+
+                               /* bogus command? */
+                               if (skb->len < len)
+                                       return 0;
+
+                               skb2 = skb_clone(skb, GFP_ATOMIC);
+                               if (unlikely(!skb2))
+                                       goto next;
+                               skb_trim(skb2, len);
+                               put_unaligned_le16(BIT(15) | (1 << 11) | len,
+                                               skb_push(skb2, 2));
+                               eem_linkcmd(dev, skb2);
+                               break;
+
+                       /*
+                        * Host may choose to ignore hints.
+                        *  - suspend: peripheral ready to suspend
+                        *  - response: suggest N millisec polling
+                        *  - response complete: suggest N sec polling
+                        */
+                       case 2:         /* Suspend hint */
+                       case 3:         /* Response hint */
+                       case 4:         /* Response complete hint */
+                               continue;
+
+                       /*
+                        * Hosts should never receive host-to-peripheral
+                        * or reserved command codes; or responses to an
+                        * echo command we didn't send.
+                        */
+                       case 1:         /* Echo response */
+                       case 5:         /* Tickle */
+                       default:        /* reserved */
+                               devwarn(dev, "unexpected link command %d\n",
+                                               bmEEMCmd);
+                               continue;
+                       }
+
+               } else {
+                       u32     crc, crc2;
+                       int     is_last;
+
+                       /* zero length EEM packet? */
+                       if (header == 0)
+                               continue;
+
+                       /*
+                        * EEM data packet header :
+                        * b0..13:      length of ethernet frame
+                        * b14:         bmCRC
+                        * b15:         0 (EEM data)
+                        */
+                       len = header & 0x3FFF;
+
+                       /* bogus EEM payload? */
+                       if (skb->len < len)
+                               return 0;
+
+                       /* bogus ethernet frame? */
+                       if (len < (ETH_HLEN + ETH_FCS_LEN))
+                               goto next;
+
+                       /*
+                        * Treat the last payload differently: framework
+                        * code expects our "fixup" to have stripped off
+                        * headers, so "skb" is a data packet (or error).
+                        * Else if it's not the last payload, keep "skb"
+                        * for further processing.
+                        */
+                       is_last = (len == skb->len);
+                       if (is_last)
+                               skb2 = skb;
+                       else {
+                               skb2 = skb_clone(skb, GFP_ATOMIC);
+                               if (unlikely(!skb2))
+                                       return 0;
+                       }
+
+                       crc = get_unaligned_le32(skb2->data
+                                       + len - ETH_FCS_LEN);
+                       skb_trim(skb2, len - ETH_FCS_LEN);
+
+                       /*
+                        * The bmCRC helps to denote when the CRC field in
+                        * the Ethernet frame contains a calculated CRC:
+                        *      bmCRC = 1       : CRC is calculated
+                        *      bmCRC = 0       : CRC = 0xDEADBEEF
+                        */
+                       if (header & BIT(14))
+                               crc2 = ~crc32_le(~0, skb2->data, len);
+                       else
+                               crc2 = 0xdeadbeef;
+
+                       if (is_last)
+                               return crc == crc2;
+
+                       if (unlikely(crc != crc2)) {
+                               dev->stats.rx_errors++;
+                               dev_kfree_skb_any(skb2);
+                       } else
+                               usbnet_skb_return(dev, skb2);
+               }
+
+next:
+               skb_pull(skb, len);
+       } while (skb->len);
+
+       return 1;
+}
+
+static const struct driver_info eem_info = {
+       .description =  "CDC EEM Device",
+       .flags =        FLAG_ETHER,
+       .bind =         eem_bind,
+       .rx_fixup =     eem_rx_fixup,
+       .tx_fixup =     eem_tx_fixup,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static const struct usb_device_id products[] = {
+{
+       USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_EEM,
+                       USB_CDC_PROTO_EEM),
+       .driver_info = (unsigned long) &eem_info,
+},
+{
+       /* EMPTY == end of list */
+},
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver eem_driver = {
+       .name =         "cdc_eem",
+       .id_table =     products,
+       .probe =        usbnet_probe,
+       .disconnect =   usbnet_disconnect,
+       .suspend =      usbnet_suspend,
+       .resume =       usbnet_resume,
+};
+
+
+static int __init eem_init(void)
+{
+       return usb_register(&eem_driver);
+}
+module_init(eem_init);
+
+static void __exit eem_exit(void)
+{
+       usb_deregister(&eem_driver);
+}
+module_exit(eem_exit);
+
+MODULE_AUTHOR("Omar Laazimani <omar.oberthur@gmail.com>");
+MODULE_DESCRIPTION("USB CDC EEM");
+MODULE_LICENSE("GPL");
index dc1665326592703ce0f7bf6ff3d2e91caa560632..5a7283372b53d09c9c4d39d6332fef471fde1875 100644 (file)
@@ -941,6 +941,16 @@ static int smsc95xx_reset(struct usbnet *dev)
        if (netif_msg_ifup(dev))
                devdbg(dev, "ID_REV = 0x%08x", read_buf);
 
+       /* Configure GPIO pins as LED outputs */
+       write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
+               LED_GPIO_CFG_FDX_LED;
+       ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
+       if (ret < 0) {
+               devwarn(dev, "Failed to write LED_GPIO_CFG register, ret=%d",
+                       ret);
+               return ret;
+       }
+
        /* Init Tx */
        write_buf = 0;
        ret = smsc95xx_write_reg(dev, FLOW, write_buf);
@@ -1231,6 +1241,11 @@ static const struct usb_device_id products[] = {
                USB_DEVICE(0x0424, 0x9500),
                .driver_info = (unsigned long) &smsc95xx_info,
        },
+       {
+               /* SMSC9512/9514 USB Hub & Ethernet Device */
+               USB_DEVICE(0x0424, 0xec00),
+               .driver_info = (unsigned long) &smsc95xx_info,
+       },
        { },            /* END */
 };
 MODULE_DEVICE_TABLE(usb, products);
index 66b5c84f302e1336a1aa1910d13687b24394f2e1..86bc44977fbd98372844b622cf171153a4c60d32 100644 (file)
@@ -99,6 +99,9 @@
 #define PM_CTL_WUPS_MULTI_             (0x00000003)
 
 #define LED_GPIO_CFG                   (0x24)
+#define LED_GPIO_CFG_SPD_LED           (0x01000000)
+#define LED_GPIO_CFG_LNK_LED           (0x00100000)
+#define LED_GPIO_CFG_FDX_LED           (0x00010000)
 
 #define GPIO_CFG                       (0x28)
 
index 9c82a39497e5f9f3aae73b8df04c78cbaf8311df..4d1d47953fc6e4d780c538b5ffd00c901ffc06bf 100644 (file)
@@ -616,10 +616,11 @@ static int virtnet_open(struct net_device *dev)
 static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
                                 struct scatterlist *data, int out, int in)
 {
-       struct scatterlist sg[VIRTNET_SEND_COMMAND_SG_MAX + 2];
+       struct scatterlist *s, sg[VIRTNET_SEND_COMMAND_SG_MAX + 2];
        struct virtio_net_ctrl_hdr ctrl;
        virtio_net_ctrl_ack status = ~0;
        unsigned int tmp;
+       int i;
 
        if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ)) {
                BUG();  /* Caller should know better */
@@ -637,7 +638,8 @@ static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
        sg_init_table(sg, out + in);
 
        sg_set_buf(&sg[0], &ctrl, sizeof(ctrl));
-       memcpy(&sg[1], data, sizeof(struct scatterlist) * (out + in - 2));
+       for_each_sg(data, s, out + in - 2, i)
+               sg_set_buf(&sg[i + 1], sg_virt(s), s->length);
        sg_set_buf(&sg[out + in - 1], &status, sizeof(status));
 
        if (vi->cvq->vq_ops->add_buf(vi->cvq, sg, out, in, vi) != 0)
@@ -692,7 +694,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
        promisc = ((dev->flags & IFF_PROMISC) != 0);
        allmulti = ((dev->flags & IFF_ALLMULTI) != 0);
 
-       sg_set_buf(sg, &promisc, sizeof(promisc));
+       sg_init_one(sg, &promisc, sizeof(promisc));
 
        if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
                                  VIRTIO_NET_CTRL_RX_PROMISC,
@@ -700,7 +702,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
                dev_warn(&dev->dev, "Failed to %sable promisc mode.\n",
                         promisc ? "en" : "dis");
 
-       sg_set_buf(sg, &allmulti, sizeof(allmulti));
+       sg_init_one(sg, &allmulti, sizeof(allmulti));
 
        if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
                                  VIRTIO_NET_CTRL_RX_ALLMULTI,
@@ -716,6 +718,8 @@ static void virtnet_set_rx_mode(struct net_device *dev)
                return;
        }
 
+       sg_init_table(sg, 2);
+
        /* Store the unicast list and count in the front of the buffer */
        mac_data->entries = dev->uc_count;
        addr = dev->uc_list;
@@ -744,24 +748,24 @@ static void virtnet_set_rx_mode(struct net_device *dev)
        kfree(buf);
 }
 
-static void virnet_vlan_rx_add_vid(struct net_device *dev, u16 vid)
+static void virtnet_vlan_rx_add_vid(struct net_device *dev, u16 vid)
 {
        struct virtnet_info *vi = netdev_priv(dev);
        struct scatterlist sg;
 
-       sg_set_buf(&sg, &vid, sizeof(vid));
+       sg_init_one(&sg, &vid, sizeof(vid));
 
        if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
                                  VIRTIO_NET_CTRL_VLAN_ADD, &sg, 1, 0))
                dev_warn(&dev->dev, "Failed to add VLAN ID %d.\n", vid);
 }
 
-static void virnet_vlan_rx_kill_vid(struct net_device *dev, u16 vid)
+static void virtnet_vlan_rx_kill_vid(struct net_device *dev, u16 vid)
 {
        struct virtnet_info *vi = netdev_priv(dev);
        struct scatterlist sg;
 
-       sg_set_buf(&sg, &vid, sizeof(vid));
+       sg_init_one(&sg, &vid, sizeof(vid));
 
        if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
                                  VIRTIO_NET_CTRL_VLAN_DEL, &sg, 1, 0))
@@ -794,8 +798,8 @@ static const struct net_device_ops virtnet_netdev = {
        .ndo_set_mac_address = virtnet_set_mac_address,
        .ndo_set_rx_mode     = virtnet_set_rx_mode,
        .ndo_change_mtu      = virtnet_change_mtu,
-       .ndo_vlan_rx_add_vid = virnet_vlan_rx_add_vid,
-       .ndo_vlan_rx_kill_vid = virnet_vlan_rx_kill_vid,
+       .ndo_vlan_rx_add_vid = virtnet_vlan_rx_add_vid,
+       .ndo_vlan_rx_kill_vid = virtnet_vlan_rx_kill_vid,
 #ifdef CONFIG_NET_POLL_CONTROLLER
        .ndo_poll_controller = virtnet_netpoll,
 #endif
index 9770bb3d40f997a75b256d40785b85c6d61fcc6d..4904a07e4b59b5fd15723a68d5fa012344179586 100644 (file)
@@ -424,7 +424,7 @@ ath5k_debug_dump_bands(struct ath5k_softc *sc)
 
        for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
                struct ieee80211_supported_band *band = &sc->sbands[b];
-               char bname[5];
+               char bname[6];
                switch (band->band) {
                case IEEE80211_BAND_2GHZ:
                        strcpy(bname, "2 GHz");
index 23644cf884f12d2ddf596ca0a8f690312b01303a..e7c65c4f741bfb0be178586d4e8c908de347c653 100644 (file)
@@ -925,11 +925,11 @@ void iwl_bg_scan_completed(struct work_struct *work)
 
        IWL_DEBUG_SCAN(priv, "SCAN complete scan\n");
 
+       ieee80211_scan_completed(priv->hw, false);
+
        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
                return;
 
-       ieee80211_scan_completed(priv->hw, false);
-
        /* Since setting the TXPOWER may have been deferred while
         * performing the scan, fire one off */
        mutex_lock(&priv->mutex);
index 617c4235d97127777ad23d1675072004b6e88c7b..70a00c8ee42eeb5a05de6f7f96ff06108370e70f 100644 (file)
@@ -1694,7 +1694,6 @@ void iwl3945_rx_queue_reset(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
        rxq->free_count = 0;
        spin_unlock_irqrestore(&rxq->lock, flags);
 }
-EXPORT_SYMBOL(iwl3945_rx_queue_reset);
 
 /*
  * this should be called while priv->lock is locked
index db91db776508420f9b766204baa26fee346038ed..bebf735cd4bd3f22ba8ea21d5c7313f44d262c6b 100644 (file)
@@ -2558,6 +2558,11 @@ static int rndis_wext_bind(struct usbnet *usbdev, struct usb_interface *intf)
        mutex_init(&priv->command_lock);
        spin_lock_init(&priv->stats_lock);
 
+       /* because rndis_command() sleeps we need to use workqueue */
+       priv->workqueue = create_singlethread_workqueue("rndis_wlan");
+       INIT_WORK(&priv->work, rndis_wext_worker);
+       INIT_DELAYED_WORK(&priv->stats_work, rndis_update_wireless_stats);
+
        /* try bind rndis_host */
        retval = generic_rndis_bind(usbdev, intf, FLAG_RNDIS_PHYM_WIRELESS);
        if (retval < 0)
@@ -2603,16 +2608,17 @@ static int rndis_wext_bind(struct usbnet *usbdev, struct usb_interface *intf)
        disassociate(usbdev, 1);
        netif_carrier_off(usbdev->net);
 
-       /* because rndis_command() sleeps we need to use workqueue */
-       priv->workqueue = create_singlethread_workqueue("rndis_wlan");
-       INIT_DELAYED_WORK(&priv->stats_work, rndis_update_wireless_stats);
        queue_delayed_work(priv->workqueue, &priv->stats_work,
                round_jiffies_relative(STATS_UPDATE_JIFFIES));
-       INIT_WORK(&priv->work, rndis_wext_worker);
 
        return 0;
 
 fail:
+       cancel_delayed_work_sync(&priv->stats_work);
+       cancel_work_sync(&priv->work);
+       flush_workqueue(priv->workqueue);
+       destroy_workqueue(priv->workqueue);
+
        kfree(priv);
        return retval;
 }
index 8871aaa3dba677350f519280a5d75b8ff915316d..c0a3e2734e240c02dd6e5a0b4da8a2f66800df86 100644 (file)
@@ -130,8 +130,6 @@ struct jsm_board
        struct pci_dev  *pci_dev;
        u32             maxports;       /* MAX ports this board can handle */
 
-       spinlock_t      bd_lock;        /* Used to protect board */
-
        spinlock_t      bd_intr_lock;   /* Used to protect the poller tasklet and
                                         * the interrupt routine from each other.
                                         */
index d2d32a19862961a06e6ecd0738d5e3877ade07a0..b3604aa322a46ed5f7801f728c209cd67ce6c7ab 100644 (file)
@@ -88,7 +88,6 @@ static int __devinit jsm_probe_one(struct pci_dev *pdev, const struct pci_device
        else
                brd->maxports = 2;
 
-       spin_lock_init(&brd->bd_lock);
        spin_lock_init(&brd->bd_intr_lock);
 
        /* store which revision we have */
index 0dbd6c68d76bc50a3b984819aec83178ce5adba6..d8d0be5151e37f43ac11e86935d95f39e5beadf4 100644 (file)
@@ -56,7 +56,6 @@ obj-$(CONFIG_FB_CT65550)          += chipsfb.o
 obj-$(CONFIG_FB_IMSTT)            += imsttfb.o
 obj-$(CONFIG_FB_FM2)              += fm2fb.o
 obj-$(CONFIG_FB_VT8623)           += vt8623fb.o
-obj-$(CONFIG_FB_CYBLA)            += cyblafb.o
 obj-$(CONFIG_FB_TRIDENT)          += tridentfb.o
 obj-$(CONFIG_FB_LE80578)          += vermilion/
 obj-$(CONFIG_FB_S3)               += s3fb.o
index 64b35766b2a26bf28ccb1cfb55990c159008ca45..ba9f58b2a5e86e65a29aa3cabc67d45087b933b9 100644 (file)
@@ -9,10 +9,6 @@
  *
  * NOTES:
  *
- *  The code for depths like 24 that don't have integer number of pixels per
- *  long is broken and needs to be fixed. For now I turned these types of
- *  mode off.
- *
  *  Also need to add code to deal with cards endians that are different than
  *  the native cpu endians. I also need to deal with MSB position in the word.
  *
@@ -139,7 +135,7 @@ bitfill_unaligned(struct fb_info *p, unsigned long __iomem *dst, int dst_idx,
 
                // Trailing bits
                if (last)
-                       FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
+                       FB_WRITEL(comp(pat, FB_READL(dst), last), dst);
        }
 }
 
@@ -281,7 +277,7 @@ bitfill_unaligned_rev(struct fb_info *p, unsigned long __iomem *dst,
 
 void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
 {
-       unsigned long pat, fg;
+       unsigned long pat, pat2, fg;
        unsigned long width = rect->width, height = rect->height;
        int bits = BITS_PER_LONG, bytes = bits >> 3;
        u32 bpp = p->var.bits_per_pixel;
@@ -297,7 +293,7 @@ void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
        else
                fg = rect->color;
 
-       pat = pixel_to_pat( bpp, fg);
+       pat = pixel_to_pat(bpp, fg);
 
        dst = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
        dst_idx = ((unsigned long)p->screen_base & (bytes - 1))*8;
@@ -333,17 +329,16 @@ void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
                        dst_idx += p->fix.line_length*8;
                }
        } else {
-               int right;
-               int r;
-               int rot = (left-dst_idx) % bpp;
+               int right, r;
                void (*fill_op)(struct fb_info *p, unsigned long __iomem *dst,
                                int dst_idx, unsigned long pat, int left,
                                int right, unsigned n, int bits) = NULL;
-
-               /* rotate pattern to correct start position */
-               pat = pat << rot | pat >> (bpp-rot);
-
-               right = bpp-left;
+#ifdef __LITTLE_ENDIAN
+               right = left;
+               left = bpp - right;
+#else
+               right = bpp - left;
+#endif
                switch (rect->rop) {
                case ROP_XOR:
                        fill_op = bitfill_unaligned_rev;
@@ -352,17 +347,18 @@ void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
                        fill_op = bitfill_unaligned;
                        break;
                default:
-                       printk( KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
+                       printk(KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
                        fill_op = bitfill_unaligned;
                        break;
                }
                while (height--) {
-                       dst += dst_idx >> (ffs(bits) - 1);
+                       dst += dst_idx / bits;
                        dst_idx &= (bits - 1);
-                       fill_op(p, dst, dst_idx, pat, left, right,
+                       r = dst_idx % bpp;
+                       /* rotate pattern to the correct start position */
+                       pat2 = le_long_to_cpu(rolx(cpu_to_le_long(pat), r, bpp));
+                       fill_op(p, dst, dst_idx, pat2, left, right,
                                width*bpp, bits);
-                       r = (p->fix.line_length*8) % bpp;
-                       pat = pat << (bpp-r) | pat >> r;
                        dst_idx += p->fix.line_length*8;
                }
        }
index 1db622192bde2252553eb91ce69123d6fc69512f..04c01faaf7721b71041461f56c6b2032d3085d81 100644 (file)
@@ -33,11 +33,11 @@ pixel_to_pat( u32 bpp, u32 pixel)
        case 8:
                return 0x0101010101010101ul*pixel;
        case 12:
-               return 0x0001001001001001ul*pixel;
+               return 0x1001001001001001ul*pixel;
        case 16:
                return 0x0001000100010001ul*pixel;
        case 24:
-               return 0x0000000001000001ul*pixel;
+               return 0x0001000001000001ul*pixel;
        case 32:
                return 0x0000000100000001ul*pixel;
        default:
@@ -58,11 +58,11 @@ pixel_to_pat( u32 bpp, u32 pixel)
        case 8:
                return 0x01010101ul*pixel;
        case 12:
-               return 0x00001001ul*pixel;
+               return 0x01001001ul*pixel;
        case 16:
                return 0x00010001ul*pixel;
        case 24:
-               return 0x00000001ul*pixel;
+               return 0x01000001ul*pixel;
        case 32:
                return 0x00000001ul*pixel;
        default:
@@ -167,4 +167,17 @@ static inline unsigned long fb_rev_pixels_in_long(unsigned long val,
 
 #endif  /* CONFIG_FB_CFB_REV_PIXELS_IN_BYTE */
 
+#define cpu_to_le_long _cpu_to_le_long(BITS_PER_LONG)
+#define _cpu_to_le_long(x) __cpu_to_le_long(x)
+#define __cpu_to_le_long(x) cpu_to_le##x
+
+#define le_long_to_cpu _le_long_to_cpu(BITS_PER_LONG)
+#define _le_long_to_cpu(x) __le_long_to_cpu(x)
+#define __le_long_to_cpu(x) le##x##_to_cpu
+
+static inline unsigned long rolx(unsigned long word, unsigned int shift, unsigned int x)
+{
+       return (word << shift) | (word >> (x - shift));
+}
+
 #endif /* FB_DRAW_H */
index f94d6b6e29eeb9f57c4082f6a09190ca055d3278..33ee3d34f9d24004c85002ff9be86cbc25d62eef 100644 (file)
@@ -124,7 +124,7 @@ bitfill_unaligned(struct fb_info *p, unsigned long *dst, int dst_idx,
 
                /* Trailing bits */
                if (last)
-                       *dst = comp(pat, *dst, first);
+                       *dst = comp(pat, *dst, last);
        }
 }
 
@@ -242,7 +242,7 @@ bitfill_unaligned_rev(struct fb_info *p, unsigned long *dst, int dst_idx,
 
 void sys_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
 {
-       unsigned long pat, fg;
+       unsigned long pat, pat2, fg;
        unsigned long width = rect->width, height = rect->height;
        int bits = BITS_PER_LONG, bytes = bits >> 3;
        u32 bpp = p->var.bits_per_pixel;
@@ -292,17 +292,16 @@ void sys_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
                        dst_idx += p->fix.line_length*8;
                }
        } else {
-               int right;
-               int r;
-               int rot = (left-dst_idx) % bpp;
+               int right, r;
                void (*fill_op)(struct fb_info *p, unsigned long *dst,
                                int dst_idx, unsigned long pat, int left,
                                int right, unsigned n, int bits) = NULL;
-
-               /* rotate pattern to correct start position */
-               pat = pat << rot | pat >> (bpp-rot);
-
-               right = bpp-left;
+#ifdef __LITTLE_ENDIAN
+               right = left;
+               left = bpp - right;
+#else
+               right = bpp - left;
+#endif
                switch (rect->rop) {
                case ROP_XOR:
                        fill_op = bitfill_unaligned_rev;
@@ -311,18 +310,19 @@ void sys_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
                        fill_op = bitfill_unaligned;
                        break;
                default:
-                       printk(KERN_ERR "cfb_fillrect(): unknown rop, "
+                       printk(KERN_ERR "sys_fillrect(): unknown rop, "
                                "defaulting to ROP_COPY\n");
                        fill_op = bitfill_unaligned;
                        break;
                }
                while (height--) {
-                       dst += dst_idx >> (ffs(bits) - 1);
+                       dst += dst_idx / bits;
                        dst_idx &= (bits - 1);
-                       fill_op(p, dst, dst_idx, pat, left, right,
+                       r = dst_idx % bpp;
+                       /* rotate pattern to the correct start position */
+                       pat2 = le_long_to_cpu(rolx(cpu_to_le_long(pat), r, bpp));
+                       fill_op(p, dst, dst_idx, pat2, left, right,
                                width*bpp, bits);
-                       r = (p->fix.line_length*8) % bpp;
-                       pat = pat << (bpp-r) | pat >> r;
                        dst_idx += p->fix.line_length*8;
                }
        }
index efa4b363ce72ae9527ece6351bb172b568f98880..f5bbd9e8341660a6d4f5195d1b42350db0288d5d 100644 (file)
@@ -513,7 +513,8 @@ static ssize_t show_target(struct sys_device *dev, struct sysdev_attribute *attr
                              char *buf)
 {
        return sprintf(buf, "%llu\n",
-                      (u64)balloon_stats.target_pages << PAGE_SHIFT);
+                      (unsigned long long)balloon_stats.target_pages
+                      << PAGE_SHIFT);
 }
 
 static ssize_t store_target(struct sys_device *dev,
index ac2d47e439265c1622199ed17b00315c475a4a4f..82d9c42b8bac951f54fe0a09298eb90a0627f667 100644 (file)
@@ -258,7 +258,7 @@ int __generic_block_fiemap(struct inode *inode,
        long long length = 0, map_len = 0;
        u64 logical = 0, phys = 0, size = 0;
        u32 flags = FIEMAP_EXTENT_MERGED;
-       int ret = 0;
+       int ret = 0, past_eof = 0, whole_file = 0;
 
        if ((ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC)))
                return ret;
@@ -266,6 +266,9 @@ int __generic_block_fiemap(struct inode *inode,
        start_blk = logical_to_blk(inode, start);
 
        length = (long long)min_t(u64, len, i_size_read(inode));
+       if (length < len)
+               whole_file = 1;
+
        map_len = length;
 
        do {
@@ -282,11 +285,26 @@ int __generic_block_fiemap(struct inode *inode,
 
                /* HOLE */
                if (!buffer_mapped(&tmp)) {
+                       length -= blk_to_logical(inode, 1);
+                       start_blk++;
+
+                       /*
+                        * we want to handle the case where there is an
+                        * allocated block at the front of the file, and then
+                        * nothing but holes up to the end of the file properly,
+                        * to make sure that extent at the front gets properly
+                        * marked with FIEMAP_EXTENT_LAST
+                        */
+                       if (!past_eof &&
+                           blk_to_logical(inode, start_blk) >=
+                           blk_to_logical(inode, 0)+i_size_read(inode))
+                               past_eof = 1;
+
                        /*
                         * first hole after going past the EOF, this is our
                         * last extent
                         */
-                       if (length <= 0) {
+                       if (past_eof && size) {
                                flags = FIEMAP_EXTENT_MERGED|FIEMAP_EXTENT_LAST;
                                ret = fiemap_fill_next_extent(fieinfo, logical,
                                                              phys, size,
@@ -294,15 +312,37 @@ int __generic_block_fiemap(struct inode *inode,
                                break;
                        }
 
-                       length -= blk_to_logical(inode, 1);
-
                        /* if we have holes up to/past EOF then we're done */
-                       if (length <= 0)
+                       if (length <= 0 || past_eof)
                                break;
-
-                       start_blk++;
                } else {
-                       if (length <= 0 && size) {
+                       /*
+                        * we have gone over the length of what we wanted to
+                        * map, and it wasn't the entire file, so add the extent
+                        * we got last time and exit.
+                        *
+                        * This is for the case where say we want to map all the
+                        * way up to the second to the last block in a file, but
+                        * the last block is a hole, making the second to last
+                        * block FIEMAP_EXTENT_LAST.  In this case we want to
+                        * see if there is a hole after the second to last block
+                        * so we can mark it properly.  If we found data after
+                        * we exceeded the length we were requesting, then we
+                        * are good to go, just add the extent to the fieinfo
+                        * and break
+                        */
+                       if (length <= 0 && !whole_file) {
+                               ret = fiemap_fill_next_extent(fieinfo, logical,
+                                                             phys, size,
+                                                             flags);
+                               break;
+                       }
+
+                       /*
+                        * if size != 0 then we know we already have an extent
+                        * to add, so add it.
+                        */
+                       if (size) {
                                ret = fiemap_fill_next_extent(fieinfo, logical,
                                                              phys, size,
                                                              flags);
@@ -319,19 +359,14 @@ int __generic_block_fiemap(struct inode *inode,
                        start_blk += logical_to_blk(inode, size);
 
                        /*
-                        * if we are past the EOF we need to loop again to see
-                        * if there is a hole so we can mark this extent as the
-                        * last one, and if not keep mapping things until we
-                        * find a hole, or we run out of slots in the extent
-                        * array
+                        * If we are past the EOF, then we need to make sure as
+                        * soon as we find a hole that the last extent we found
+                        * is marked with FIEMAP_EXTENT_LAST
                         */
-                       if (length <= 0)
-                               continue;
-
-                       ret = fiemap_fill_next_extent(fieinfo, logical, phys,
-                                                     size, flags);
-                       if (ret)
-                               break;
+                       if (!past_eof &&
+                           logical+size >=
+                           blk_to_logical(inode, 0)+i_size_read(inode))
+                               past_eof = 1;
                }
                cond_resched();
        } while (1);
index 5a97bcfe03e5e0d25b78d8122a6695f8d1c66acc..ec7e27d00bc6878a1b9ba6f8f2c4ba24c4cd9b28 100644 (file)
@@ -517,10 +517,10 @@ static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 
        ret = nfs_updatepage(filp, page, 0, pagelen);
 out_unlock:
+       if (!ret)
+               return VM_FAULT_LOCKED;
        unlock_page(page);
-       if (ret)
-               ret = VM_FAULT_SIGBUS;
-       return ret;
+       return VM_FAULT_SIGBUS;
 }
 
 static struct vm_operations_struct nfs_file_vm_ops = {
index bed766e435b5c7dc35ad30be6fe616808b17e643..1634319e2404d2a02de2aa2de2b9ffea0559e5c5 100644 (file)
@@ -220,7 +220,7 @@ static struct inotify_kernel_event * kernel_event(s32 wd, u32 mask, u32 cookie,
                                rem = 0;
                }
 
-               kevent->name = kmalloc(len + rem, GFP_KERNEL);
+               kevent->name = kmalloc(len + rem, GFP_NOFS);
                if (unlikely(!kevent->name)) {
                        kmem_cache_free(event_cachep, kevent);
                        return NULL;
index 7e4877d9dcb58b71720cb6cd79a690b3149d44bb..725a650bbbb8bf3c1e90d1c84a6a7e1701f1ea96 100644 (file)
@@ -80,6 +80,7 @@
 #include <linux/delayacct.h>
 #include <linux/seq_file.h>
 #include <linux/pid_namespace.h>
+#include <linux/ptrace.h>
 #include <linux/tracehook.h>
 
 #include <asm/pgtable.h>
@@ -352,6 +353,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
        char state;
        pid_t ppid = 0, pgid = -1, sid = -1;
        int num_threads = 0;
+       int permitted;
        struct mm_struct *mm;
        unsigned long long start_time;
        unsigned long cmin_flt = 0, cmaj_flt = 0;
@@ -364,11 +366,14 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
 
        state = *get_task_state(task);
        vsize = eip = esp = 0;
+       permitted = ptrace_may_access(task, PTRACE_MODE_READ);
        mm = get_task_mm(task);
        if (mm) {
                vsize = task_vsize(mm);
-               eip = KSTK_EIP(task);
-               esp = KSTK_ESP(task);
+               if (permitted) {
+                       eip = KSTK_EIP(task);
+                       esp = KSTK_ESP(task);
+               }
        }
 
        get_task_comm(tcomm, task);
@@ -424,7 +429,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                unlock_task_sighand(task, &flags);
        }
 
-       if (!whole || num_threads < 2)
+       if (permitted && (!whole || num_threads < 2))
                wchan = get_wchan(task);
        if (!whole) {
                min_flt = task->min_flt;
@@ -476,7 +481,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                rsslim,
                mm ? mm->start_code : 0,
                mm ? mm->end_code : 0,
-               mm ? mm->start_stack : 0,
+               (permitted && mm) ? mm->start_stack : 0,
                esp,
                eip,
                /* The signal information here is obsolete.
index aa763ab007775f7c7da2a477e8df148dfad5f940..fb45615943c2adba5e630fd1ea14a1d9e1c31fff 100644 (file)
@@ -322,7 +322,10 @@ static int proc_pid_wchan(struct task_struct *task, char *buffer)
        wchan = get_wchan(task);
 
        if (lookup_symbol_name(wchan, symname) < 0)
-               return sprintf(buffer, "%lu", wchan);
+               if (!ptrace_may_access(task, PTRACE_MODE_READ))
+                       return 0;
+               else
+                       return sprintf(buffer, "%lu", wchan);
        else
                return sprintf(buffer, "%s", symname);
 }
index e727fe0d145107f48ae5699364f390e3d3298bd5..4b6755984d241261941334dcf5f8c8431a5c6e54 100644 (file)
@@ -58,12 +58,13 @@ struct bug_entry {
  */
 #ifndef __WARN
 #ifndef __ASSEMBLY__
-extern void warn_slowpath(const char *file, const int line,
+extern void warn_slowpath_fmt(const char *file, const int line,
                const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+extern void warn_slowpath_null(const char *file, const int line);
 #define WANT_WARN_ON_SLOWPATH
 #endif
-#define __WARN()               warn_slowpath(__FILE__, __LINE__, NULL)
-#define __WARN_printf(arg...)  warn_slowpath(__FILE__, __LINE__, arg)
+#define __WARN()               warn_slowpath_null(__FILE__, __LINE__)
+#define __WARN_printf(arg...)  warn_slowpath_fmt(__FILE__, __LINE__, arg)
 #else
 #define __WARN_printf(arg...)  do { printk(arg); __WARN(); } while (0)
 #endif
index 1b2e43502ef77b63e50a428a3b61dcfa956da967..c9efe039dc57c4e2c2dce6ec11751a3d6d1c9819 100644 (file)
@@ -472,7 +472,7 @@ static inline void xt_info_rdlock_bh(void)
 
        local_bh_disable();
        lock = &__get_cpu_var(xt_info_locks);
-       if (!lock->readers++)
+       if (likely(!lock->readers++))
                spin_lock(&lock->lock);
 }
 
@@ -480,7 +480,7 @@ static inline void xt_info_rdunlock_bh(void)
 {
        struct xt_info_lock *lock = &__get_cpu_var(xt_info_locks);
 
-       if (!--lock->readers)
+       if (likely(!--lock->readers))
                spin_unlock(&lock->lock);
        local_bh_enable();
 }
index 3c86ed25a04ca53dfbe1ceb278c3ac33a125a973..c24124a42ce5925bfd313525881311d0155dbdc5 100644 (file)
@@ -17,6 +17,7 @@
 #define USB_CDC_SUBCLASS_DMM                   0x09
 #define USB_CDC_SUBCLASS_MDLM                  0x0a
 #define USB_CDC_SUBCLASS_OBEX                  0x0b
+#define USB_CDC_SUBCLASS_EEM                   0x0c
 
 #define USB_CDC_PROTO_NONE                     0
 
@@ -28,6 +29,8 @@
 #define USB_CDC_ACM_PROTO_AT_CDMA              6
 #define USB_CDC_ACM_PROTO_VENDOR               0xff
 
+#define USB_CDC_PROTO_EEM                      7
+
 /*-------------------------------------------------------------------------*/
 
 /*
index 242348bb3766a69e45d0255575bf108a7eb4a744..cec79adbe3ea60934ad69f3ef00484f12b97b065 100644 (file)
@@ -4,6 +4,7 @@
  * compatible drivers/servers. */
 #include <linux/types.h>
 #include <linux/virtio_config.h>
+#include <linux/if_ether.h>
 
 /* The ID for virtio_net */
 #define VIRTIO_ID_NET  1
index 4012e07162e51e772081ad6af9261f52bd9a88cd..e26812274b757f0355293a15f33a776dd78348d0 100644 (file)
@@ -98,7 +98,6 @@ enum p9_req_status_t {
 struct p9_req_t {
        int status;
        int t_err;
-       u16 flush_tag;
        wait_queue_head_t *wq;
        struct p9_fcall *tc;
        struct p9_fcall *rc;
index be5bd713d2c98ab97205b3a7824c755e1afd8ee1..73aead222b32cb202ca626da891a4721a6b5a24a 100644 (file)
@@ -457,6 +457,7 @@ int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
 
 int hci_register_sysfs(struct hci_dev *hdev);
 void hci_unregister_sysfs(struct hci_dev *hdev);
+void hci_conn_init_sysfs(struct hci_conn *conn);
 void hci_conn_add_sysfs(struct hci_conn *conn);
 void hci_conn_del_sysfs(struct hci_conn *conn);
 
index 1b94b9bfe2dc13754d4c2f6f4c9e26efd8b8c130..646dbe3962eab7ae3832c9e8641549ef9e9d95f9 100644 (file)
@@ -41,6 +41,7 @@
 #include <net/ip.h>
 #include <net/tcp_states.h>
 #include <net/inet_ecn.h>
+#include <net/dst.h>
 
 #include <linux/seq_file.h>
 
@@ -530,6 +531,17 @@ static inline void tcp_fast_path_check(struct sock *sk)
                tcp_fast_path_on(tp);
 }
 
+/* Compute the actual rto_min value */
+static inline u32 tcp_rto_min(struct sock *sk)
+{
+       struct dst_entry *dst = __sk_dst_get(sk);
+       u32 rto_min = TCP_RTO_MIN;
+
+       if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
+               rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
+       return rto_min;
+}
+
 /* Compute the actual receive window we are currently advertising.
  * Rcv_nxt can be after the window if our peer push more data
  * than the offered window.
@@ -895,7 +907,7 @@ static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
                        wake_up_interruptible(sk->sk_sleep);
                        if (!inet_csk_ack_scheduled(sk))
                                inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
-                                                         (3 * TCP_RTO_MIN) / 4,
+                                                         (3 * tcp_rto_min(sk)) / 4,
                                                          TCP_RTO_MAX);
                }
                return 1;
index 9ee7b78104175e107cb4ce5084f089a674ad71f9..4c00edc59689034895ad6728c9b5b4505a8386b3 100644 (file)
@@ -574,11 +574,10 @@ static int __init populate_rootfs(void)
        if (initrd_start) {
 #ifdef CONFIG_BLK_DEV_RAM
                int fd;
-               printk(KERN_INFO "checking if image is initramfs...\n");
+               printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n");
                err = unpack_to_rootfs((char *)initrd_start,
                        initrd_end - initrd_start);
                if (!err) {
-                       printk(KERN_INFO "rootfs image is initramfs; unpacking...\n");
                        free_initrd();
                        return 0;
                } else {
@@ -596,15 +595,11 @@ static int __init populate_rootfs(void)
                        free_initrd();
                }
 #else
-               printk(KERN_INFO "Unpacking initramfs...");
+               printk(KERN_INFO "Unpacking initramfs...\n");
                err = unpack_to_rootfs((char *)initrd_start,
                        initrd_end - initrd_start);
-               if (err) {
-                       printk(" failed!\n");
-                       printk(KERN_EMERG "%s\n", err);
-               } else {
-                       printk(" done\n");
-               }
+               if (err)
+                       printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
                free_initrd();
 #endif
        }
index a6fe71fd5d1b96487370e8ee275cbff7fa0e2a87..713098ee5a0243c61a30e946f6c34be44de653ca 100644 (file)
@@ -1028,7 +1028,7 @@ static void audit_update_watch(struct audit_parent *parent,
 
                if (audit_enabled) {
                        struct audit_buffer *ab;
-                       ab = audit_log_start(NULL, GFP_KERNEL,
+                       ab = audit_log_start(NULL, GFP_NOFS,
                                AUDIT_CONFIG_CHANGE);
                        audit_log_format(ab, "auid=%u ses=%u",
                                audit_get_loginuid(current),
@@ -1067,7 +1067,7 @@ static void audit_remove_parent_watches(struct audit_parent *parent)
                        e = container_of(r, struct audit_entry, rule);
                        if (audit_enabled) {
                                struct audit_buffer *ab;
-                               ab = audit_log_start(NULL, GFP_KERNEL,
+                               ab = audit_log_start(NULL, GFP_NOFS,
                                        AUDIT_CONFIG_CHANGE);
                                audit_log_format(ab, "auid=%u ses=%u",
                                        audit_get_loginuid(current),
index d82142be8dd2c8fddc340058ff9cd73373f6a31b..26e08754744fa13dd9da3e919be6adb3976b2b04 100644 (file)
@@ -363,8 +363,6 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
        irqreturn_t ret, retval = IRQ_NONE;
        unsigned int status = 0;
 
-       WARN_ONCE(!in_irq(), "BUG: IRQ handler called from non-hardirq context!");
-
        if (!(action->flags & IRQF_DISABLED))
                local_irq_enable_in_hardirq();
 
index 3dcaa1661357809bb1605779f625d9c9a92594f4..874ecf1307aee212e1208289ea300865dca18385 100644 (file)
@@ -340,7 +340,7 @@ void oops_exit(void)
 }
 
 #ifdef WANT_WARN_ON_SLOWPATH
-void warn_slowpath(const char *file, int line, const char *fmt, ...)
+void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
 {
        va_list args;
        char function[KSYM_SYMBOL_LEN];
@@ -356,7 +356,7 @@ void warn_slowpath(const char *file, int line, const char *fmt, ...)
        if (board)
                printk(KERN_WARNING "Hardware name: %s\n", board);
 
-       if (fmt) {
+       if (*fmt) {
                va_start(args, fmt);
                vprintk(fmt, args);
                va_end(args);
@@ -367,7 +367,14 @@ void warn_slowpath(const char *file, int line, const char *fmt, ...)
        print_oops_end_marker();
        add_taint(TAINT_WARN);
 }
-EXPORT_SYMBOL(warn_slowpath);
+EXPORT_SYMBOL(warn_slowpath_fmt);
+
+void warn_slowpath_null(const char *file, int line)
+{
+       static const char *empty = "";
+       warn_slowpath_fmt(file, line, empty);
+}
+EXPORT_SYMBOL(warn_slowpath_null);
 #endif
 
 #ifdef CONFIG_CC_STACKPROTECTOR
index c9dcf98b44633398217e3a7829ace3bf7791403d..bece7c0b67b29d42c3c425d053bd76087b7684f3 100644 (file)
@@ -1420,19 +1420,19 @@ void run_posix_cpu_timers(struct task_struct *tsk)
         * timer call will interfere.
         */
        list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
-               int firing;
+               int cpu_firing;
+
                spin_lock(&timer->it_lock);
                list_del_init(&timer->it.cpu.entry);
-               firing = timer->it.cpu.firing;
+               cpu_firing = timer->it.cpu.firing;
                timer->it.cpu.firing = 0;
                /*
                 * The firing flag is -1 if we collided with a reset
                 * of the timer, which already reported this
                 * almost-firing as an overrun.  So don't generate an event.
                 */
-               if (likely(firing >= 0)) {
+               if (likely(cpu_firing >= 0))
                        cpu_timer_fire(timer);
-               }
                spin_unlock(&timer->it_lock);
        }
 }
index b902e587a3a03e32a3e26f676e419f692ba79145..26efa475bdc143f6e4459067c18ce57e71608764 100644 (file)
@@ -4732,7 +4732,7 @@ void account_process_tick(struct task_struct *p, int user_tick)
 
        if (user_tick)
                account_user_time(p, one_jiffy, one_jiffy_scaled);
-       else if (p != rq->idle)
+       else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
                account_system_time(p, HARDIRQ_OFFSET, one_jiffy,
                                    one_jiffy_scaled);
        else
index 21a5ca849514b40b689c5b34e2c9caaf9cbf051b..83c4417b6a3cccd734c8f7f9386670641babd0c8 100644 (file)
@@ -93,7 +93,17 @@ void tick_handle_periodic(struct clock_event_device *dev)
        for (;;) {
                if (!clockevents_program_event(dev, next, ktime_get()))
                        return;
-               tick_periodic(cpu);
+               /*
+                * Have to be careful here. If we're in oneshot mode,
+                * before we call tick_periodic() in a loop, we need
+                * to be sure we're using a real hardware clocksource.
+                * Otherwise we could get trapped in an infinite
+                * loop, as the tick_periodic() increments jiffies,
+                * when then will increment time, posibly causing
+                * the loop to trigger again and again.
+                */
+               if (timekeeping_valid_for_hres())
+                       tick_periodic(cpu);
                next = ktime_add(next, tick_period);
        }
 }
index 1ce5dc6372b8fcc617bcb37722f22fdf95620e0a..a884c09006c4d2141248ff04848cca86dff56d64 100644 (file)
@@ -3448,6 +3448,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                if (!ref)
                        break;
 
+               ref->ref = 1;
                ref->buffer = info->tr->buffer;
                ref->page = ring_buffer_alloc_read_page(ref->buffer);
                if (!ref->page) {
index d3da7edc034f7c60496056332850458b849a4f61..69da09a085a1943ea6a70f4871fd2df1683110fb 100644 (file)
@@ -400,60 +400,9 @@ out_err:
        return -ENOMEM;
 }
 
-static int device_dma_allocations(struct device *dev)
-{
-       struct dma_debug_entry *entry;
-       unsigned long flags;
-       int count = 0, i;
-
-       for (i = 0; i < HASH_SIZE; ++i) {
-               spin_lock_irqsave(&dma_entry_hash[i].lock, flags);
-               list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
-                       if (entry->dev == dev)
-                               count += 1;
-               }
-               spin_unlock_irqrestore(&dma_entry_hash[i].lock, flags);
-       }
-
-       return count;
-}
-
-static int dma_debug_device_change(struct notifier_block *nb,
-                                   unsigned long action, void *data)
-{
-       struct device *dev = data;
-       int count;
-
-
-       switch (action) {
-       case BUS_NOTIFY_UNBIND_DRIVER:
-               count = device_dma_allocations(dev);
-               if (count == 0)
-                       break;
-               err_printk(dev, NULL, "DMA-API: device driver has pending "
-                               "DMA allocations while released from device "
-                               "[count=%d]\n", count);
-               break;
-       default:
-               break;
-       }
-
-       return 0;
-}
-
 void dma_debug_add_bus(struct bus_type *bus)
 {
-       struct notifier_block *nb;
-
-       nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
-       if (nb == NULL) {
-               printk(KERN_ERR "dma_debug_add_bus: out of memory\n");
-               return;
-       }
-
-       nb->notifier_call = dma_debug_device_change;
-
-       bus_register_notifier(bus, nb);
+       /* FIXME: register notifier */
 }
 
 /*
index 57971d2ab848fc96c4eb3621a923af603619281b..c2b57d81e153077bec9bc8be39af8bb658537065 100644 (file)
@@ -225,3 +225,31 @@ config HAVE_MLOCKED_PAGE_BIT
 
 config MMU_NOTIFIER
        bool
+
+config NOMMU_INITIAL_TRIM_EXCESS
+       int "Turn on mmap() excess space trimming before booting"
+       depends on !MMU
+       default 1
+       help
+         The NOMMU mmap() frequently needs to allocate large contiguous chunks
+         of memory on which to store mappings, but it can only ask the system
+         allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
+         more than it requires.  To deal with this, mmap() is able to trim off
+         the excess and return it to the allocator.
+
+         If trimming is enabled, the excess is trimmed off and returned to the
+         system allocator, which can cause extra fragmentation, particularly
+         if there are a lot of transient processes.
+
+         If trimming is disabled, the excess is kept, but not used, which for
+         long-term mappings means that the space is wasted.
+
+         Trimming can be dynamically controlled through a sysctl option
+         (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
+         excess pages there must be before trimming should occur, or zero if
+         no trimming is to occur.
+
+         This option specifies the initial value of this option.  The default
+         of 1 says that all excess pages should be trimmed.
+
+         See Documentation/nommu-mmap.txt for more information.
index b9ce574827c8a2a48b972f0261decc234edf9e27..36d6ea2b63405a8bd682b1e225bb3f748de2eda5 100644 (file)
@@ -112,6 +112,14 @@ static long madvise_willneed(struct vm_area_struct * vma,
        if (!file)
                return -EBADF;
 
+       /*
+        * Page cache readahead assumes page cache pages are order-0 which
+        * is not the case for hugetlbfs. Do not give a bad return value
+        * but ignore the advice.
+        */
+       if (vma->vm_flags & VM_HUGETLB)
+               return 0;
+
        if (file->f_mapping->a_ops->get_xip_mem) {
                /* no bad return value, but ignore advice */
                return 0;
index 809998aa7b509dd072862def05f420a14e1185cf..67cd1a487ee63ee11ca0f372c0f76c6f1f61fcc7 100644 (file)
@@ -66,7 +66,7 @@ struct percpu_counter vm_committed_as;
 int sysctl_overcommit_memory = OVERCOMMIT_GUESS; /* heuristic overcommit */
 int sysctl_overcommit_ratio = 50; /* default is 50% */
 int sysctl_max_map_count = DEFAULT_MAX_MAP_COUNT;
-int sysctl_nr_trim_pages = 1; /* page trimming behaviour */
+int sysctl_nr_trim_pages = CONFIG_NOMMU_INITIAL_TRIM_EXCESS;
 int heap_stack_gap = 0;
 
 atomic_long_t mmap_pages_allocated;
index 2f3166e308d9713378d6a37b6a54e6272abf0f1f..92bcf1db16b24ea2c9b4d9f6c93043118c021615 100644 (file)
@@ -514,34 +514,32 @@ void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask)
  */
 static void __out_of_memory(gfp_t gfp_mask, int order)
 {
-       if (sysctl_oom_kill_allocating_task) {
-               oom_kill_process(current, gfp_mask, order, 0, NULL,
-                               "Out of memory (oom_kill_allocating_task)");
-
-       } else {
-               unsigned long points;
-               struct task_struct *p;
-
-retry:
-               /*
-                * Rambo mode: Shoot down a process and hope it solves whatever
-                * issues we may have.
-                */
-               p = select_bad_process(&points, NULL);
+       struct task_struct *p;
+       unsigned long points;
 
-               if (PTR_ERR(p) == -1UL)
+       if (sysctl_oom_kill_allocating_task)
+               if (!oom_kill_process(current, gfp_mask, order, 0, NULL,
+                               "Out of memory (oom_kill_allocating_task)"))
                        return;
+retry:
+       /*
+        * Rambo mode: Shoot down a process and hope it solves whatever
+        * issues we may have.
+        */
+       p = select_bad_process(&points, NULL);
 
-               /* Found nothing?!?! Either we hang forever, or we panic. */
-               if (!p) {
-                       read_unlock(&tasklist_lock);
-                       panic("Out of memory and no killable processes...\n");
-               }
+       if (PTR_ERR(p) == -1UL)
+               return;
 
-               if (oom_kill_process(p, gfp_mask, order, points, NULL,
-                                    "Out of memory"))
-                       goto retry;
+       /* Found nothing?!?! Either we hang forever, or we panic. */
+       if (!p) {
+               read_unlock(&tasklist_lock);
+               panic("Out of memory and no killable processes...\n");
        }
+
+       if (oom_kill_process(p, gfp_mask, order, points, NULL,
+                            "Out of memory"))
+               goto retry;
 }
 
 /*
index e2f26991fff136ed40438f3b07cdaffec78aa90a..fe753ecf2aa5fd234dedb6916c333055bcfe8b36 100644 (file)
@@ -2681,6 +2681,7 @@ static void __meminit zone_init_free_lists(struct zone *zone)
 
 static int zone_batchsize(struct zone *zone)
 {
+#ifdef CONFIG_MMU
        int batch;
 
        /*
@@ -2706,9 +2707,26 @@ static int zone_batchsize(struct zone *zone)
         * of pages of one half of the possible page colors
         * and the other with pages of the other colors.
         */
-       batch = (1 << (fls(batch + batch/2)-1)) - 1;
+       batch = rounddown_pow_of_two(batch + batch/2) - 1;
 
        return batch;
+
+#else
+       /* The deferral and batching of frees should be suppressed under NOMMU
+        * conditions.
+        *
+        * The problem is that NOMMU needs to be able to allocate large chunks
+        * of contiguous memory as there's no hardware page translation to
+        * assemble apparent contiguous memory from discontiguous pages.
+        *
+        * Queueing large contiguous runs of pages for batching, however,
+        * causes the pages to actually be freed in smaller chunks.  As there
+        * can be a significant delay between the individual batches being
+        * recycled, this leads to the once large chunks of space being
+        * fragmented and becoming unavailable for high-order allocations.
+        */
+       return 0;
+#endif
 }
 
 static void setup_pageset(struct per_cpu_pageset *p, unsigned long batch)
index fab19876b4d178986979c2b5d2cb353285507b46..083716ea38c9f7ba636cababe6859cd8e3c14106 100644 (file)
@@ -402,6 +402,7 @@ overflow:
                        printk(KERN_WARNING
                                "vmap allocation for size %lu failed: "
                                "use vmalloc=<size> to increase size.\n", size);
+               kfree(va);
                return ERR_PTR(-EBUSY);
        }
 
index 1eb580c38fbbcf63ca5d0bc08ff4ba8a3f3ceb94..dd43a8289b0d9ecaf74aadc205063d2e2eaf8b3a 100644 (file)
@@ -203,7 +203,6 @@ static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
        p9pdu_reset(req->tc);
        p9pdu_reset(req->rc);
 
-       req->flush_tag = 0;
        req->tc->tag = tag-1;
        req->status = REQ_STATUS_ALLOC;
 
@@ -324,35 +323,9 @@ static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
  */
 void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
 {
-       struct p9_req_t *other_req;
-       unsigned long flags;
-
        P9_DPRINTK(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
-
-       if (req->status == REQ_STATUS_ERROR)
-               wake_up(req->wq);
-
-       if (req->flush_tag) {                   /* flush receive path */
-               P9_DPRINTK(P9_DEBUG_9P, "<<< RFLUSH %d\n", req->tc->tag);
-               spin_lock_irqsave(&c->lock, flags);
-               other_req = p9_tag_lookup(c, req->flush_tag);
-               if (other_req->status != REQ_STATUS_FLSH) /* stale flush */
-                       spin_unlock_irqrestore(&c->lock, flags);
-               else {
-                       other_req->status = REQ_STATUS_FLSHD;
-                       spin_unlock_irqrestore(&c->lock, flags);
-                       wake_up(other_req->wq);
-               }
-               p9_free_req(c, req);
-       } else {                                /* normal receive path */
-               P9_DPRINTK(P9_DEBUG_MUX, "normal: tag %d\n", req->tc->tag);
-               spin_lock_irqsave(&c->lock, flags);
-               if (req->status != REQ_STATUS_FLSHD)
-                       req->status = REQ_STATUS_RCVD;
-               spin_unlock_irqrestore(&c->lock, flags);
-               wake_up(req->wq);
-               P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
-       }
+       wake_up(req->wq);
+       P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
 }
 EXPORT_SYMBOL(p9_client_cb);
 
@@ -486,9 +459,15 @@ static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
        if (IS_ERR(req))
                return PTR_ERR(req);
 
-       req->flush_tag = oldtag;
 
-       /* we don't free anything here because RPC isn't complete */
+       /* if we haven't received a response for oldreq,
+          remove it from the list. */
+       spin_lock(&c->lock);
+       if (oldreq->status == REQ_STATUS_FLSH)
+               list_del(&oldreq->req_list);
+       spin_unlock(&c->lock);
+
+       p9_free_req(c, req);
        return 0;
 }
 
@@ -509,7 +488,6 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
        struct p9_req_t *req;
        unsigned long flags;
        int sigpending;
-       int flushed = 0;
 
        P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
 
@@ -546,42 +524,28 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
                goto reterr;
        }
 
-       /* if it was a flush we just transmitted, return our tag */
-       if (type == P9_TFLUSH)
-               return req;
-again:
        P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d\n", req->wq, tag);
        err = wait_event_interruptible(*req->wq,
                                                req->status >= REQ_STATUS_RCVD);
-       P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d (flushed=%d)\n",
-                                               req->wq, tag, err, flushed);
+       P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d\n",
+                                               req->wq, tag, err);
 
        if (req->status == REQ_STATUS_ERROR) {
                P9_DPRINTK(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
                err = req->t_err;
-       } else if (err == -ERESTARTSYS && flushed) {
-               P9_DPRINTK(P9_DEBUG_MUX, "flushed - going again\n");
-               goto again;
-       } else if (req->status == REQ_STATUS_FLSHD) {
-               P9_DPRINTK(P9_DEBUG_MUX, "flushed - erestartsys\n");
-               err = -ERESTARTSYS;
        }
 
-       if ((err == -ERESTARTSYS) && (c->status == Connected) && (!flushed)) {
+       if ((err == -ERESTARTSYS) && (c->status == Connected)) {
                P9_DPRINTK(P9_DEBUG_MUX, "flushing\n");
-               spin_lock_irqsave(&c->lock, flags);
-               if (req->status == REQ_STATUS_SENT)
-                       req->status = REQ_STATUS_FLSH;
-               spin_unlock_irqrestore(&c->lock, flags);
                sigpending = 1;
-               flushed = 1;
                clear_thread_flag(TIF_SIGPENDING);
 
-               if (c->trans_mod->cancel(c, req)) {
-                       err = p9_client_flush(c, req);
-                       if (err == 0)
-                               goto again;
-               }
+               if (c->trans_mod->cancel(c, req))
+                       p9_client_flush(c, req);
+
+               /* if we received the response anyway, don't signal error */
+               if (req->status == REQ_STATUS_RCVD)
+                       err = 0;
        }
 
        if (sigpending) {
@@ -1244,19 +1208,53 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
                ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
                ret->n_uid, ret->n_gid, ret->n_muid);
 
+       p9_free_req(clnt, req);
+       return ret;
+
 free_and_error:
        p9_free_req(clnt, req);
 error:
-       return ret;
+       kfree(ret);
+       return ERR_PTR(err);
 }
 EXPORT_SYMBOL(p9_client_stat);
 
+static int p9_client_statsize(struct p9_wstat *wst, int optional)
+{
+       int ret;
+
+       /* size[2] type[2] dev[4] qid[13] */
+       /* mode[4] atime[4] mtime[4] length[8]*/
+       /* name[s] uid[s] gid[s] muid[s] */
+       ret = 2+2+4+13+4+4+4+8+2+2+2+2;
+
+       if (wst->name)
+               ret += strlen(wst->name);
+       if (wst->uid)
+               ret += strlen(wst->uid);
+       if (wst->gid)
+               ret += strlen(wst->gid);
+       if (wst->muid)
+               ret += strlen(wst->muid);
+
+       if (optional) {
+               ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
+               if (wst->extension)
+                       ret += strlen(wst->extension);
+       }
+
+       return ret;
+}
+
 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
 {
        int err;
        struct p9_req_t *req;
        struct p9_client *clnt;
 
+       err = 0;
+       clnt = fid->clnt;
+       wst->size = p9_client_statsize(wst, clnt->dotu);
        P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
        P9_DPRINTK(P9_DEBUG_9P,
                "     sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
@@ -1268,10 +1266,8 @@ int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
                wst->atime, wst->mtime, (unsigned long long)wst->length,
                wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
                wst->n_uid, wst->n_gid, wst->n_muid);
-       err = 0;
-       clnt = fid->clnt;
 
-       req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, 0, wst);
+       req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size, wst);
        if (IS_ERR(req)) {
                err = PTR_ERR(req);
                goto error;
index c613ed08a5ee345d723bac311c76ee191137437e..a2a1814c7a8d639d6ccd76e9fdd966b7a6431fa6 100644 (file)
@@ -213,8 +213,8 @@ static void p9_conn_cancel(struct p9_conn *m, int err)
        spin_unlock_irqrestore(&m->client->lock, flags);
 
        list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
-               list_del(&req->req_list);
                P9_DPRINTK(P9_DEBUG_ERROR, "call back req %p\n", req);
+               list_del(&req->req_list);
                p9_client_cb(m->client, req);
        }
 }
@@ -336,7 +336,8 @@ static void p9_read_work(struct work_struct *work)
                        "mux %p pkt: size: %d bytes tag: %d\n", m, n, tag);
 
                m->req = p9_tag_lookup(m->client, tag);
-               if (!m->req) {
+               if (!m->req || (m->req->status != REQ_STATUS_SENT &&
+                                       m->req->status != REQ_STATUS_FLSH)) {
                        P9_DPRINTK(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
                                                                 tag);
                        err = -EIO;
@@ -361,10 +362,11 @@ static void p9_read_work(struct work_struct *work)
        if ((m->req) && (m->rpos == m->rsize)) { /* packet is read in */
                P9_DPRINTK(P9_DEBUG_TRANS, "got new packet\n");
                spin_lock(&m->client->lock);
+               if (m->req->status != REQ_STATUS_ERROR)
+                       m->req->status = REQ_STATUS_RCVD;
                list_del(&m->req->req_list);
                spin_unlock(&m->client->lock);
                p9_client_cb(m->client, m->req);
-
                m->rbuf = NULL;
                m->rpos = 0;
                m->rsize = 0;
@@ -454,6 +456,7 @@ static void p9_write_work(struct work_struct *work)
                req = list_entry(m->unsent_req_list.next, struct p9_req_t,
                               req_list);
                req->status = REQ_STATUS_SENT;
+               P9_DPRINTK(P9_DEBUG_TRANS, "move req %p\n", req);
                list_move_tail(&req->req_list, &m->req_list);
 
                m->wbuf = req->tc->sdata;
@@ -683,12 +686,13 @@ static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
        P9_DPRINTK(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
 
        spin_lock(&client->lock);
-       list_del(&req->req_list);
 
        if (req->status == REQ_STATUS_UNSENT) {
+               list_del(&req->req_list);
                req->status = REQ_STATUS_FLSHD;
                ret = 0;
-       }
+       } else if (req->status == REQ_STATUS_SENT)
+               req->status = REQ_STATUS_FLSH;
 
        spin_unlock(&client->lock);
 
index 7fa0eb20b2f6e7912299b35d6cc720203396e420..ac4990041ebb94d9935126f4cd76430fb7fa7201 100644 (file)
@@ -295,6 +295,7 @@ handle_recv(struct p9_client *client, struct p9_trans_rdma *rdma,
                goto err_out;
 
        req->rc = c->rc;
+       req->status = REQ_STATUS_RCVD;
        p9_client_cb(client, req);
 
        return;
index 2d7781ec663ba18425e2bbd57d6340955a3d7de4..bb8579a141a86c584db61993a86104316ba4cb43 100644 (file)
@@ -134,6 +134,7 @@ static void req_done(struct virtqueue *vq)
                P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
                P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
                req = p9_tag_lookup(chan->client, rc->tag);
+               req->status = REQ_STATUS_RCVD;
                p9_client_cb(chan->client, req);
        }
 }
index 334fcd4a4ea469c26ecdc958b40ffa5b74d35f1e..3100a8940afce8f38ca59e8fe27917ab480f7dfd 100644 (file)
@@ -549,6 +549,7 @@ static void br2684_setup(struct net_device *netdev)
        struct br2684_dev *brdev = BRPRIV(netdev);
 
        ether_setup(netdev);
+       brdev->net_dev = netdev;
 
        netdev->netdev_ops = &br2684_netdev_ops;
 
index 375f4b4f7f79a25c328523227ba17679b8b29092..61309b26f2715cf26464151ab549830919457bd2 100644 (file)
@@ -248,6 +248,8 @@ struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
        if (hdev->notify)
                hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 
+       hci_conn_init_sysfs(conn);
+
        tasklet_enable(&hdev->tx_task);
 
        return conn;
index b7c51082ddeb58c2fe47a0617e8d0842f787c36e..582d8877078c9894876bf448561fe17804874711 100644 (file)
@@ -9,7 +9,7 @@
 struct class *bt_class = NULL;
 EXPORT_SYMBOL_GPL(bt_class);
 
-static struct workqueue_struct *bluetooth;
+static struct workqueue_struct *bt_workq;
 
 static inline char *link_typetostr(int type)
 {
@@ -89,8 +89,8 @@ static void add_conn(struct work_struct *work)
 {
        struct hci_conn *conn = container_of(work, struct hci_conn, work_add);
 
-       /* ensure previous add/del is complete */
-       flush_workqueue(bluetooth);
+       /* ensure previous del is complete */
+       flush_work(&conn->work_del);
 
        if (device_add(&conn->dev) < 0) {
                BT_ERR("Failed to register connection device");
@@ -98,27 +98,6 @@ static void add_conn(struct work_struct *work)
        }
 }
 
-void hci_conn_add_sysfs(struct hci_conn *conn)
-{
-       struct hci_dev *hdev = conn->hdev;
-
-       BT_DBG("conn %p", conn);
-
-       conn->dev.type = &bt_link;
-       conn->dev.class = bt_class;
-       conn->dev.parent = &hdev->dev;
-
-       dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
-
-       dev_set_drvdata(&conn->dev, conn);
-
-       device_initialize(&conn->dev);
-
-       INIT_WORK(&conn->work_add, add_conn);
-
-       queue_work(bluetooth, &conn->work_add);
-}
-
 /*
  * The rfcomm tty device will possibly retain even when conn
  * is down, and sysfs doesn't support move zombie device,
@@ -134,8 +113,11 @@ static void del_conn(struct work_struct *work)
        struct hci_conn *conn = container_of(work, struct hci_conn, work_del);
        struct hci_dev *hdev = conn->hdev;
 
-       /* ensure previous add/del is complete */
-       flush_workqueue(bluetooth);
+       /* ensure previous add is complete */
+       flush_work(&conn->work_add);
+
+       if (!device_is_registered(&conn->dev))
+               return;
 
        while (1) {
                struct device *dev;
@@ -152,16 +134,40 @@ static void del_conn(struct work_struct *work)
        hci_dev_put(hdev);
 }
 
-void hci_conn_del_sysfs(struct hci_conn *conn)
+void hci_conn_init_sysfs(struct hci_conn *conn)
 {
+       struct hci_dev *hdev = conn->hdev;
+
        BT_DBG("conn %p", conn);
 
-       if (!device_is_registered(&conn->dev))
-               return;
+       conn->dev.type = &bt_link;
+       conn->dev.class = bt_class;
+       conn->dev.parent = &hdev->dev;
+
+       dev_set_drvdata(&conn->dev, conn);
 
+       device_initialize(&conn->dev);
+
+       INIT_WORK(&conn->work_add, add_conn);
        INIT_WORK(&conn->work_del, del_conn);
+}
+
+void hci_conn_add_sysfs(struct hci_conn *conn)
+{
+       struct hci_dev *hdev = conn->hdev;
+
+       BT_DBG("conn %p", conn);
+
+       dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
+
+       queue_work(bt_workq, &conn->work_add);
+}
+
+void hci_conn_del_sysfs(struct hci_conn *conn)
+{
+       BT_DBG("conn %p", conn);
 
-       queue_work(bluetooth, &conn->work_del);
+       queue_work(bt_workq, &conn->work_del);
 }
 
 static inline char *host_typetostr(int type)
@@ -438,13 +444,13 @@ void hci_unregister_sysfs(struct hci_dev *hdev)
 
 int __init bt_sysfs_init(void)
 {
-       bluetooth = create_singlethread_workqueue("bluetooth");
-       if (!bluetooth)
+       bt_workq = create_singlethread_workqueue("bluetooth");
+       if (!bt_workq)
                return -ENOMEM;
 
        bt_class = class_create(THIS_MODULE, "bluetooth");
        if (IS_ERR(bt_class)) {
-               destroy_workqueue(bluetooth);
+               destroy_workqueue(bt_workq);
                return PTR_ERR(bt_class);
        }
 
@@ -453,7 +459,7 @@ int __init bt_sysfs_init(void)
 
 void bt_sysfs_cleanup(void)
 {
-       destroy_workqueue(bluetooth);
+       destroy_workqueue(bt_workq);
 
        class_destroy(bt_class);
 }
index 308a7d0c277f97a1f87662b8c2b97af44db7fd36..e2e9e4af3ace6c2975ebab961f20c5bbf3aa0157 100644 (file)
@@ -1735,11 +1735,12 @@ u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
 {
        u32 hash;
 
-       if (skb_rx_queue_recorded(skb)) {
-               hash = skb_get_rx_queue(skb);
-       } else if (skb->sk && skb->sk->sk_hash) {
+       if (skb_rx_queue_recorded(skb))
+               return skb_get_rx_queue(skb) % dev->real_num_tx_queues;
+
+       if (skb->sk && skb->sk->sk_hash)
                hash = skb->sk->sk_hash;
-       else
+       else
                hash = skb->protocol;
 
        hash = jhash_1word(hash, skb_tx_hashrnd);
index ce6356cd9f71c76bad3cf9a0ec5fbb774c0a427a..f091a5a845c11c332ee408e452e4e1b89da251e2 100644 (file)
@@ -1365,9 +1365,8 @@ static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i)
 
 static inline struct page *linear_to_page(struct page *page, unsigned int *len,
                                          unsigned int *offset,
-                                         struct sk_buff *skb)
+                                         struct sk_buff *skb, struct sock *sk)
 {
-       struct sock *sk = skb->sk;
        struct page *p = sk->sk_sndmsg_page;
        unsigned int off;
 
@@ -1405,13 +1404,14 @@ new_page:
  */
 static inline int spd_fill_page(struct splice_pipe_desc *spd, struct page *page,
                                unsigned int *len, unsigned int offset,
-                               struct sk_buff *skb, int linear)
+                               struct sk_buff *skb, int linear,
+                               struct sock *sk)
 {
        if (unlikely(spd->nr_pages == PIPE_BUFFERS))
                return 1;
 
        if (linear) {
-               page = linear_to_page(page, len, &offset, skb);
+               page = linear_to_page(page, len, &offset, skb, sk);
                if (!page)
                        return 1;
        } else
@@ -1442,7 +1442,8 @@ static inline void __segment_seek(struct page **page, unsigned int *poff,
 static inline int __splice_segment(struct page *page, unsigned int poff,
                                   unsigned int plen, unsigned int *off,
                                   unsigned int *len, struct sk_buff *skb,
-                                  struct splice_pipe_desc *spd, int linear)
+                                  struct splice_pipe_desc *spd, int linear,
+                                  struct sock *sk)
 {
        if (!*len)
                return 1;
@@ -1465,7 +1466,7 @@ static inline int __splice_segment(struct page *page, unsigned int poff,
                /* the linear region may spread across several pages  */
                flen = min_t(unsigned int, flen, PAGE_SIZE - poff);
 
-               if (spd_fill_page(spd, page, &flen, poff, skb, linear))
+               if (spd_fill_page(spd, page, &flen, poff, skb, linear, sk))
                        return 1;
 
                __segment_seek(&page, &poff, &plen, flen);
@@ -1481,8 +1482,8 @@ static inline int __splice_segment(struct page *page, unsigned int poff,
  * pipe is full or if we already spliced the requested length.
  */
 static int __skb_splice_bits(struct sk_buff *skb, unsigned int *offset,
-                     unsigned int *len,
-                     struct splice_pipe_desc *spd)
+                            unsigned int *len, struct splice_pipe_desc *spd,
+                            struct sock *sk)
 {
        int seg;
 
@@ -1492,7 +1493,7 @@ static int __skb_splice_bits(struct sk_buff *skb, unsigned int *offset,
        if (__splice_segment(virt_to_page(skb->data),
                             (unsigned long) skb->data & (PAGE_SIZE - 1),
                             skb_headlen(skb),
-                            offset, len, skb, spd, 1))
+                            offset, len, skb, spd, 1, sk))
                return 1;
 
        /*
@@ -1502,7 +1503,7 @@ static int __skb_splice_bits(struct sk_buff *skb, unsigned int *offset,
                const skb_frag_t *f = &skb_shinfo(skb)->frags[seg];
 
                if (__splice_segment(f->page, f->page_offset, f->size,
-                                    offset, len, skb, spd, 0))
+                                    offset, len, skb, spd, 0, sk))
                        return 1;
        }
 
@@ -1528,12 +1529,13 @@ int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
                .ops = &sock_pipe_buf_ops,
                .spd_release = sock_spd_release,
        };
+       struct sock *sk = skb->sk;
 
        /*
         * __skb_splice_bits() only fails if the output has no room left,
         * so no point in going over the frag_list for the error case.
         */
-       if (__skb_splice_bits(skb, &offset, &tlen, &spd))
+       if (__skb_splice_bits(skb, &offset, &tlen, &spd, sk))
                goto done;
        else if (!tlen)
                goto done;
@@ -1545,14 +1547,13 @@ int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
                struct sk_buff *list = skb_shinfo(skb)->frag_list;
 
                for (; list && tlen; list = list->next) {
-                       if (__skb_splice_bits(list, &offset, &tlen, &spd))
+                       if (__skb_splice_bits(list, &offset, &tlen, &spd, sk))
                                break;
                }
        }
 
 done:
        if (spd.nr_pages) {
-               struct sock *sk = skb->sk;
                int ret;
 
                /*
index c96a6bb254302543288fdae9509205c0bb94947d..eec3e6f9956cad798b6cc930cf7b799a64fca911 100644 (file)
@@ -597,16 +597,6 @@ static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
                tcp_grow_window(sk, skb);
 }
 
-static u32 tcp_rto_min(struct sock *sk)
-{
-       struct dst_entry *dst = __sk_dst_get(sk);
-       u32 rto_min = TCP_RTO_MIN;
-
-       if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
-               rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
-       return rto_min;
-}
-
 /* Called to compute a smoothed rtt estimate. The data fed to this
  * routine either comes from timestamps, or from segments that were
  * known _not_ to have been retransmitted [see Karn/Partridge
index fbcbed6cad017ec6596bf4546d9142493b70a25d..14134193cd17120e60b4960283ae3782eb2af0c8 100644 (file)
@@ -757,6 +757,7 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
        local->hw.conf.long_frame_max_tx_count = 4;
        local->hw.conf.short_frame_max_tx_count = 7;
        local->hw.conf.radio_enabled = true;
+       local->user_power_level = -1;
 
        INIT_LIST_HEAD(&local->interfaces);
        mutex_init(&local->iflist_mtx);
@@ -909,6 +910,13 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
        if (result < 0)
                goto fail_sta_info;
 
+       result = ieee80211_wep_init(local);
+       if (result < 0) {
+               printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
+                      wiphy_name(local->hw.wiphy), result);
+               goto fail_wep;
+       }
+
        rtnl_lock();
        result = dev_alloc_name(local->mdev, local->mdev->name);
        if (result < 0)
@@ -930,14 +938,6 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
                goto fail_rate;
        }
 
-       result = ieee80211_wep_init(local);
-
-       if (result < 0) {
-               printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
-                      wiphy_name(local->hw.wiphy), result);
-               goto fail_wep;
-       }
-
        /* add one default STA interface if supported */
        if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
                result = ieee80211_if_add(local, "wlan%d", NULL,
@@ -967,13 +967,13 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
 
        return 0;
 
-fail_wep:
-       rate_control_deinitialize(local);
 fail_rate:
        unregister_netdevice(local->mdev);
        local->mdev = NULL;
 fail_dev:
        rtnl_unlock();
+       ieee80211_wep_free(local);
+fail_wep:
        sta_info_stop(local);
 fail_sta_info:
        debugfs_hw_del(local);
index 881203c4a142738bbf6e090272f853c7999e389c..cb3ad741ebf878f2131e557b84d055a0bfbbe4ac 100644 (file)
@@ -837,6 +837,7 @@ config NETFILTER_XT_MATCH_SOCKET
        depends on NETFILTER_TPROXY
        depends on NETFILTER_XTABLES
        depends on NETFILTER_ADVANCED
+       depends on !NF_CONNTRACK || NF_CONNTRACK
        select NF_DEFRAG_IPV4
        help
          This option adds a `socket' match, which can be used to match
index 173fcc4b050ddac8b4470c9616216974312bc121..0759f32e9dcaba9c45f5c880b4516aab38e5081c 100644 (file)
@@ -254,7 +254,7 @@ replay:
                }
                tp->ops = tp_ops;
                tp->protocol = protocol;
-               tp->prio = nprio ? : tcf_auto_prio(*back);
+               tp->prio = nprio ? : TC_H_MAJ(tcf_auto_prio(*back));
                tp->q = q;
                tp->classify = tp_ops->classify;
                tp->classid = parent;
index 936b6f8e46ff2fc6663852a5f19e697d41e41296..161b7846733e5ee5988ef42d5bf114cd8f0eef4d 100644 (file)
@@ -384,11 +384,19 @@ static int parse_elf(struct elf_info *info, const char *filename)
                return 0;
        }
        /* Fix endianness in ELF header */
-       hdr->e_shoff    = TO_NATIVE(hdr->e_shoff);
-       hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
-       hdr->e_shnum    = TO_NATIVE(hdr->e_shnum);
-       hdr->e_machine  = TO_NATIVE(hdr->e_machine);
-       hdr->e_type     = TO_NATIVE(hdr->e_type);
+       hdr->e_type      = TO_NATIVE(hdr->e_type);
+       hdr->e_machine   = TO_NATIVE(hdr->e_machine);
+       hdr->e_version   = TO_NATIVE(hdr->e_version);
+       hdr->e_entry     = TO_NATIVE(hdr->e_entry);
+       hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
+       hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
+       hdr->e_flags     = TO_NATIVE(hdr->e_flags);
+       hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
+       hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
+       hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
+       hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
+       hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
+       hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
        sechdrs = (void *)hdr + hdr->e_shoff;
        info->sechdrs = sechdrs;
 
@@ -402,13 +410,16 @@ static int parse_elf(struct elf_info *info, const char *filename)
 
        /* Fix endianness in section headers */
        for (i = 0; i < hdr->e_shnum; i++) {
-               sechdrs[i].sh_type   = TO_NATIVE(sechdrs[i].sh_type);
-               sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
-               sechdrs[i].sh_size   = TO_NATIVE(sechdrs[i].sh_size);
-               sechdrs[i].sh_link   = TO_NATIVE(sechdrs[i].sh_link);
-               sechdrs[i].sh_name   = TO_NATIVE(sechdrs[i].sh_name);
-               sechdrs[i].sh_info   = TO_NATIVE(sechdrs[i].sh_info);
-               sechdrs[i].sh_addr   = TO_NATIVE(sechdrs[i].sh_addr);
+               sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
+               sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
+               sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
+               sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
+               sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
+               sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
+               sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
+               sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
+               sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
+               sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
        }
        /* Find symbol table. */
        for (i = 1; i < hdr->e_shnum; i++) {
@@ -716,7 +727,17 @@ int match(const char *sym, const char * const pat[])
 
 /* sections that we do not want to do full section mismatch check on */
 static const char *section_white_list[] =
-       { ".comment", ".debug*", ".stab*", ".note*", ".got*", ".toc*", NULL };
+{
+       ".comment*",
+       ".debug*",
+       ".mdebug*",        /* alpha, score, mips etc. */
+       ".pdr",            /* alpha, score, mips etc. */
+       ".stab*",
+       ".note*",
+       ".got*",
+       ".toc*",
+       NULL
+};
 
 /*
  * This is used to find sections missing the SHF_ALLOC flag.
index ba808ef6babb58799f615aa4ec615824cfb20f66..2fcad7c33eafd43a5e67beef49aea5f7cd020a89 100644 (file)
@@ -3153,7 +3153,7 @@ static int selinux_file_send_sigiotask(struct task_struct *tsk,
                                       struct fown_struct *fown, int signum)
 {
        struct file *file;
-       u32 sid = current_sid();
+       u32 sid = task_sid(tsk);
        u32 perm;
        struct file_security_struct *fsec;
 
index 63d088f2265f5c33ce8a26d707ff220bd61c2a1e..a2a792c18c40e18412ac7e9e015d22c6035b2958 100644 (file)
@@ -249,6 +249,12 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                        new_hw_ptr = hw_base + pos;
                }
        }
+       /* 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.
+        */
+       if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
+               goto no_jiffies_check;
        hdelta = new_hw_ptr - old_hw_ptr;
        jdelta = jiffies - runtime->hw_ptr_jiffies;
        if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
@@ -272,6 +278,7 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                hw_base -= hw_base % runtime->buffer_size;
                delta = 0;
        }
+ no_jiffies_check:
        if (delta > runtime->period_size + runtime->period_size / 2) {
                hw_ptr_error(substream,
                             "Lost interrupts? "
index 906454413ed21618f6bb8b162a69bf5a3bafe9ee..3a1526ae1729ace425a340b11a5cc1aa015d507c 100644 (file)
@@ -438,7 +438,8 @@ static void snd_msnd_capture_reset_queue(struct snd_msnd *chip,
 static struct snd_pcm_hardware snd_msnd_playback = {
        .info =                 SNDRV_PCM_INFO_MMAP |
                                SNDRV_PCM_INFO_INTERLEAVED |
-                               SNDRV_PCM_INFO_MMAP_VALID,
+                               SNDRV_PCM_INFO_MMAP_VALID |
+                               SNDRV_PCM_INFO_BATCH,
        .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
        .rates =                SNDRV_PCM_RATE_8000_48000,
        .rate_min =             8000,
@@ -456,7 +457,8 @@ static struct snd_pcm_hardware snd_msnd_playback = {
 static struct snd_pcm_hardware snd_msnd_capture = {
        .info =                 SNDRV_PCM_INFO_MMAP |
                                SNDRV_PCM_INFO_INTERLEAVED |
-                               SNDRV_PCM_INFO_MMAP_VALID,
+                               SNDRV_PCM_INFO_MMAP_VALID |
+                               SNDRV_PCM_INFO_BATCH,
        .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
        .rates =                SNDRV_PCM_RATE_8000_48000,
        .rate_min =             8000,
index a299340519dfab53f07e3991124ca18223753c32..ce3f2e90f4d7545ac350b5a00fdb29bc0ef5d31a 100644 (file)
@@ -349,7 +349,8 @@ static struct snd_pcm_hardware snd_bt87x_digital_hw = {
        .info = SNDRV_PCM_INFO_MMAP |
                SNDRV_PCM_INFO_INTERLEAVED |
                SNDRV_PCM_INFO_BLOCK_TRANSFER |
-               SNDRV_PCM_INFO_MMAP_VALID,
+               SNDRV_PCM_INFO_MMAP_VALID |
+               SNDRV_PCM_INFO_BATCH,
        .formats = SNDRV_PCM_FMTBIT_S16_LE,
        .rates = 0, /* set at runtime */
        .channels_min = 2,
@@ -365,7 +366,8 @@ static struct snd_pcm_hardware snd_bt87x_analog_hw = {
        .info = SNDRV_PCM_INFO_MMAP |
                SNDRV_PCM_INFO_INTERLEAVED |
                SNDRV_PCM_INFO_BLOCK_TRANSFER |
-               SNDRV_PCM_INFO_MMAP_VALID,
+               SNDRV_PCM_INFO_MMAP_VALID |
+               SNDRV_PCM_INFO_BATCH,
        .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
        .rates = SNDRV_PCM_RATE_KNOT,
        .rate_min = ANALOG_CLOCK / CLOCK_DIV_MAX,
index 3482ef69f4912451fd51a8109594cc9aff4b63a0..2e44316530a298d39e1295df8d1f3f9edc585ef0 100644 (file)
@@ -88,6 +88,7 @@ static struct snd_pcm_hardware pcm_hardware_skel = {
        .rates =        SNDRV_PCM_RATE_32000 |
                        SNDRV_PCM_RATE_44100 |
                        SNDRV_PCM_RATE_48000 |
+                       SNDRV_PCM_RATE_64000 |
                        SNDRV_PCM_RATE_88200 |
                        SNDRV_PCM_RATE_96000,
        .rate_min = 32000,
index aebee27a40ff703c84402cb06f02ab699294f81e..eb3819f9654a6630184b06436f9f9d1f5f9e7c9b 100644 (file)
@@ -89,6 +89,7 @@ static struct snd_pcm_hardware pcm_hardware_skel = {
        .rates =        SNDRV_PCM_RATE_32000 |
                        SNDRV_PCM_RATE_44100 |
                        SNDRV_PCM_RATE_48000 |
+                       SNDRV_PCM_RATE_64000 |
                        SNDRV_PCM_RATE_88200 |
                        SNDRV_PCM_RATE_96000,
        .rate_min = 32000,
index 8b79969034be24853b57afda72a88566ed316d10..7cc38a11e9978c683f96fc55be8014754d694a34 100644 (file)
@@ -1238,7 +1238,8 @@ static struct snd_pcm_hardware snd_korg1212_playback_info =
 {
        .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                             SNDRV_PCM_INFO_INTERLEAVED |
+                             SNDRV_PCM_INFO_BATCH),
        .formats =            SNDRV_PCM_FMTBIT_S16_LE,
         .rates =              (SNDRV_PCM_RATE_44100 |
                               SNDRV_PCM_RATE_48000),
@@ -1258,7 +1259,8 @@ static struct snd_pcm_hardware snd_korg1212_capture_info =
 {
         .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                             SNDRV_PCM_INFO_INTERLEAVED |
+                             SNDRV_PCM_INFO_BATCH),
         .formats =           SNDRV_PCM_FMTBIT_S16_LE,
         .rates =             (SNDRV_PCM_RATE_44100 |
                               SNDRV_PCM_RATE_48000),
index 01066c95580e806b2ba83841e5edb52765e4a444..d057e648964389a53c7905a68311ecf35aff552a 100644 (file)
@@ -240,7 +240,8 @@ static int pdacf_pcm_prepare(struct snd_pcm_substream *subs)
 static struct snd_pcm_hardware pdacf_pcm_capture_hw = {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME |
-                                SNDRV_PCM_INFO_MMAP_VALID),
+                                SNDRV_PCM_INFO_MMAP_VALID |
+                                SNDRV_PCM_INFO_BATCH),
        .formats =              SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
                                SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE |
                                SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
index 30490a2591487e724c40c3b42fed27238281ac5d..594c6c5b7838174d168b9a0e1833584bb38a1b97 100644 (file)
@@ -82,7 +82,7 @@ static struct au1xpsc_audio_dmadata *au1xpsc_audio_pcmdma[2];
 /* PCM hardware DMA capabilities - platform specific */
 static const struct snd_pcm_hardware au1xpsc_pcm_hardware = {
        .info             = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                           SNDRV_PCM_INFO_INTERLEAVED,
+                           SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BATCH,
        .formats          = AU1XPSC_PCM_FMTS,
        .period_bytes_min = AU1XPSC_PERIOD_MIN_BYTES,
        .period_bytes_max = 4096 * 1024 - 1,
index 921b205de28ab51ef5239dd7e07fe01cfaac2066..df7c8c281d2f8bec0aff69307bb7f1a5985fe1d3 100644 (file)
@@ -835,6 +835,12 @@ static DECLARE_TLV_DB_SCALE(analog_tlv, -2400, 200, 0);
  */
 static DECLARE_TLV_DB_SCALE(output_tvl, -1200, 600, 1);
 
+/*
+ * Gain control for earpiece amplifier
+ * 0 dB to 12 dB in 6 dB steps (mute instead of -6)
+ */
+static DECLARE_TLV_DB_SCALE(output_ear_tvl, -600, 600, 1);
+
 /*
  * Capture gain after the ADCs
  * from 0 dB to 31 dB in 1 dB steps
@@ -900,7 +906,7 @@ static const struct snd_kcontrol_new twl4030_snd_controls[] = {
                4, 3, 0, output_tvl),
 
        SOC_SINGLE_TLV_TWL4030("Earpiece Playback Volume",
-               TWL4030_REG_EAR_CTL, 4, 3, 0, output_tvl),
+               TWL4030_REG_EAR_CTL, 4, 3, 0, output_ear_tvl),
 
        /* Common capture gain controls */
        SOC_DOUBLE_R_TLV("TX1 Digital Capture Volume",
index 3b1d0993bed947fa815c559b0cd8db1aa144f24f..0275321ff8ab29840c994bb107c3b54d8529f1aa 100644 (file)
@@ -968,7 +968,7 @@ static int wm8350_pcm_trigger(struct snd_pcm_substream *substream,
         * required for LRC in master mode. The DACs or ADCs need a
         * valid audio path i.e. pin -> ADC or DAC -> pin before
         * the LRC will be enabled in master mode. */
-       if (!master && cmd != SNDRV_PCM_TRIGGER_START)
+       if (!master || cmd != SNDRV_PCM_TRIGGER_START)
                return 0;
 
        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
index 3aa729df27b58cddea053c96f655d518d73ef694..1111c710118a2b8bd84fd6796d9c26a096437fa5 100644 (file)
@@ -504,7 +504,8 @@ static struct snd_soc_dai psc_i2s_dai_template = {
 
 static const struct snd_pcm_hardware psc_i2s_pcm_hardware = {
        .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-               SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER,
+               SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
+               SNDRV_PCM_INFO_BATCH,
        .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE |
                   SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S32_BE,
        .rate_min = 8000,
index 0dad3a0bb92018751b9101d5020cf32f1f0d2db2..baddb1242c715d26dfdfe08aeec0557a6f22fe7e 100644 (file)
@@ -103,7 +103,8 @@ static struct snd_pcm_hardware camelot_pcm_hardware = {
        .info = (SNDRV_PCM_INFO_MMAP |
                SNDRV_PCM_INFO_INTERLEAVED |
                SNDRV_PCM_INFO_BLOCK_TRANSFER |
-               SNDRV_PCM_INFO_MMAP_VALID),
+               SNDRV_PCM_INFO_MMAP_VALID |
+               SNDRV_PCM_INFO_BATCH),
        .formats =      DMABRG_FMTS,
        .rates =        DMABRG_RATES,
        .rate_min =             8000,
index af95ff1e126cc39a83d0e833fb0d126c334e6278..1d2e51b3f9184cc66881e370d73b8452ae42266c 100644 (file)
@@ -1975,7 +1975,8 @@ static struct snd_pcm_hardware snd_dbri_pcm_hw = {
        .info           = SNDRV_PCM_INFO_MMAP |
                          SNDRV_PCM_INFO_INTERLEAVED |
                          SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                         SNDRV_PCM_INFO_MMAP_VALID,
+                         SNDRV_PCM_INFO_MMAP_VALID |
+                         SNDRV_PCM_INFO_BATCH,
        .formats        = SNDRV_PCM_FMTBIT_MU_LAW |
                          SNDRV_PCM_FMTBIT_A_LAW |
                          SNDRV_PCM_FMTBIT_U8 |
index 9a608fa85155c530019efcc56d8ca86cfb0195fa..dd1ab6177840b039437d3b516794d23dd096fe23 100644 (file)
@@ -870,7 +870,8 @@ static struct snd_pcm_hardware snd_usX2Y_2c =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                SNDRV_PCM_INFO_MMAP_VALID),
+                                SNDRV_PCM_INFO_MMAP_VALID |
+                                SNDRV_PCM_INFO_BATCH),
        .formats =                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
        .rates =                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
        .rate_min =                44100,