Merge branch 'drm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied...
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 22 Jul 2010 18:45:57 +0000 (11:45 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 22 Jul 2010 18:45:57 +0000 (11:45 -0700)
* 'drm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6:
  drm/radeon/kms: add quirk to make HP DV5000 laptop resume
  drm/radeon/kms: fix RADEON_INFO_CRTC_FROM_ID info ioctl
  Fix ttm_page_alloc.c build breakage
  drm/radeon/kms: fix legacy LVDS dpms sequence
  drm/radeon/kms: drop taking lock around crtc lookup.

238 files changed:
Documentation/00-INDEX
Documentation/bus-virt-phys-mapping.txt [moved from Documentation/IO-mapping.txt with 100% similarity]
Documentation/kernel-parameters.txt
MAINTAINERS
arch/arm/include/asm/atomic.h
arch/arm/kernel/entry-armv.S
arch/arm/kernel/kprobes-decode.c
arch/arm/kernel/process.c
arch/arm/mach-ux500/clock.c
arch/arm/mach-ux500/cpu-db5500.c
arch/arm/mm/cache-l2x0.c
arch/arm/tools/mach-types
arch/microblaze/Kconfig
arch/microblaze/include/asm/memblock.h [moved from arch/microblaze/include/asm/lmb.h with 57% similarity]
arch/microblaze/kernel/prom.c
arch/microblaze/mm/init.c
arch/powerpc/Kconfig
arch/powerpc/include/asm/abs_addr.h
arch/powerpc/include/asm/cpm.h
arch/powerpc/include/asm/cpm1.h
arch/powerpc/include/asm/lmb.h [deleted file]
arch/powerpc/include/asm/memblock.h [new file with mode: 0644]
arch/powerpc/kernel/btext.c
arch/powerpc/kernel/crash.c
arch/powerpc/kernel/crash_dump.c
arch/powerpc/kernel/dma-swiotlb.c
arch/powerpc/kernel/dma.c
arch/powerpc/kernel/fsl_booke_entry_mapping.S
arch/powerpc/kernel/machine_kexec.c
arch/powerpc/kernel/paca.c
arch/powerpc/kernel/prom.c
arch/powerpc/kernel/rtas.c
arch/powerpc/kernel/setup-common.c
arch/powerpc/kernel/setup_32.c
arch/powerpc/kernel/setup_64.c
arch/powerpc/kernel/vdso.c
arch/powerpc/mm/40x_mmu.c
arch/powerpc/mm/hash_utils_64.c
arch/powerpc/mm/init_32.c
arch/powerpc/mm/init_64.c
arch/powerpc/mm/mem.c
arch/powerpc/mm/numa.c
arch/powerpc/mm/pgtable_32.c
arch/powerpc/mm/pgtable_64.c
arch/powerpc/mm/ppc_mmu_32.c
arch/powerpc/mm/stab.c
arch/powerpc/mm/tlb_nohash.c
arch/powerpc/platforms/85xx/corenet_ds.c
arch/powerpc/platforms/85xx/mpc8536_ds.c
arch/powerpc/platforms/85xx/mpc85xx_ds.c
arch/powerpc/platforms/85xx/mpc85xx_mds.c
arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
arch/powerpc/platforms/cell/iommu.c
arch/powerpc/platforms/embedded6xx/wii.c
arch/powerpc/platforms/maple/setup.c
arch/powerpc/platforms/pasemi/iommu.c
arch/powerpc/platforms/powermac/setup.c
arch/powerpc/platforms/ps3/htab.c
arch/powerpc/platforms/ps3/mm.c
arch/powerpc/platforms/ps3/os-area.c
arch/powerpc/platforms/pseries/hotplug-memory.c
arch/powerpc/platforms/pseries/iommu.c
arch/powerpc/platforms/pseries/phyp_dump.c
arch/powerpc/sysdev/dart_iommu.c
arch/powerpc/sysdev/fsl_pci.c
arch/powerpc/sysdev/micropatch.c
arch/sh/Kconfig
arch/sh/include/asm/lmb.h [deleted file]
arch/sh/include/asm/memblock.h [new file with mode: 0644]
arch/sh/kernel/machine_kexec.c
arch/sh/kernel/setup.c
arch/sh/mm/init.c
arch/sh/mm/numa.c
arch/sparc/Kconfig
arch/sparc/configs/sparc64_defconfig
arch/sparc/include/asm/cache.h
arch/sparc/include/asm/lmb.h [deleted file]
arch/sparc/include/asm/memblock.h [new file with mode: 0644]
arch/sparc/include/asm/pgtable_32.h
arch/sparc/kernel/mdesc.c
arch/sparc/kernel/perf_event.c
arch/sparc/kernel/prom_64.c
arch/sparc/kernel/sun4d_irq.c
arch/sparc/kernel/ttable.S
arch/sparc/mm/init_64.c
arch/sparc/mm/srmmu.c
arch/sparc/mm/sun4c.c
arch/x86/include/asm/x86_init.h
arch/x86/kernel/apic/apic.c
arch/x86/kernel/early-quirks.c
arch/x86/kernel/entry_64.S
arch/x86/kernel/kprobes.c
arch/x86/kernel/mrst.c
arch/x86/kernel/quirks.c
arch/x86/kernel/setup_percpu.c
arch/x86/kernel/x86_init.c
arch/x86/kvm/mmu.c
arch/x86/kvm/vmx.c
arch/x86/pci/i386.c
arch/x86/pci/mrst.c
crypto/ablkcipher.c
drivers/char/sysrq.c
drivers/clocksource/cs5535-clockevt.c
drivers/crypto/talitos.c
drivers/edac/Kconfig
drivers/edac/mpc85xx_edac.c
drivers/gpio/cs5535-gpio.c
drivers/gpu/drm/i915/i915_gem.c
drivers/gpu/drm/ttm/ttm_page_alloc.c
drivers/input/keyboard/Kconfig
drivers/input/mouse/Kconfig
drivers/input/mouse/synaptics.c
drivers/input/serio/Kconfig
drivers/input/serio/i8042-x86ia64io.h
drivers/input/touchscreen/w90p910_ts.c
drivers/misc/cs5535-mfgpt.c
drivers/mmc/host/sdhci-s3c.c
drivers/net/ibmveth.c
drivers/net/pcmcia/axnet_cs.c
drivers/net/r8169.c
drivers/net/wireless/ath/ath9k/hif_usb.c
drivers/net/wireless/hostap/hostap_pci.c
drivers/net/wireless/iwlwifi/iwl-sta.h
drivers/net/wireless/rt2x00/rt2x00dev.c
drivers/pci/setup-res.c
drivers/pcmcia/pcmcia_resource.c
drivers/platform/x86/intel_scu_ipc.c
drivers/power/ds2782_battery.c
drivers/s390/block/dasd_devmap.c
drivers/s390/cio/chsc.c
drivers/sbus/char/openprom.c
drivers/serial/suncore.c
drivers/serial/sunsu.c
drivers/spi/spi_mpc8xxx.c
drivers/usb/gadget/f_fs.c
drivers/vhost/net.c
drivers/video/aty/radeon_pm.c
fs/btrfs/ctree.c
fs/btrfs/ioctl.c
fs/ceph/auth_x.c
fs/ceph/mds_client.c
fs/ceph/mds_client.h
fs/ceph/messenger.c
fs/ceph/osdmap.c
fs/cifs/cifsfs.c
fs/cifs/dns_resolve.c
fs/cifs/dns_resolve.h
fs/dcache.c
fs/gfs2/bmap.c
fs/gfs2/dir.c
fs/gfs2/glock.c
fs/gfs2/inode.c
fs/gfs2/quota.c
fs/gfs2/quota.h
fs/inode.c
fs/jbd2/journal.c
fs/jbd2/transaction.c
fs/jffs2/xattr.c
fs/mbcache.c
fs/nfs/dir.c
fs/nfs/internal.h
fs/ocfs2/aops.c
fs/ocfs2/dlm/dlmdomain.c
fs/ocfs2/dlm/dlmmaster.c
fs/ocfs2/dlm/dlmrecovery.c
fs/ocfs2/file.c
fs/ocfs2/file.h
fs/ocfs2/journal.c
fs/ocfs2/localalloc.c
fs/ocfs2/quota_global.c
fs/ocfs2/quota_local.c
fs/ocfs2/refcounttree.c
fs/ocfs2/suballoc.c
fs/ocfs2/xattr.c
fs/partitions/ibm.c
fs/quota/dquot.c
fs/ubifs/shrinker.c
fs/ubifs/ubifs.h
fs/xfs/linux-2.6/xfs_buf.c
fs/xfs/linux-2.6/xfs_super.c
fs/xfs/linux-2.6/xfs_sync.c
fs/xfs/linux-2.6/xfs_sync.h
fs/xfs/linux-2.6/xfs_trace.h
fs/xfs/quota/xfs_qm.c
fs/xfs/xfs_mount.h
include/linux/fdtable.h
include/linux/i8042.h
include/linux/jbd2.h
include/linux/lmb.h [deleted file]
include/linux/memblock.h [new file with mode: 0644]
include/linux/mm.h
include/linux/pci.h
include/linux/syscalls.h
include/linux/sysrq.h
include/math-emu/op-common.h
include/net/sock.h
ipc/sem.c
kernel/debug/debug_core.c
kernel/debug/gdbstub.c
kernel/debug/kdb/kdb_main.c
kernel/early_res.c
lib/Kconfig
lib/Makefile
lib/lmb.c [deleted file]
mm/Kconfig
mm/Makefile
mm/bootmem.c
mm/memblock.c [new file with mode: 0644]
mm/page_alloc.c
mm/page_cgroup.c
mm/vmscan.c
net/bluetooth/hci_conn.c
net/bluetooth/hci_event.c
net/bluetooth/l2cap.c
net/bridge/br_device.c
net/bridge/br_forward.c
net/core/dev.c
net/core/neighbour.c
net/dsa/Kconfig
net/ipv4/ipmr.c
net/ipv4/tcp.c
net/ipv4/tcp_output.c
net/ipv6/mip6.c
net/phonet/pep.c
net/sched/act_nat.c
net/sunrpc/auth.c
net/xfrm/xfrm_policy.c
sound/soc/codecs/Kconfig
sound/soc/codecs/wm8727.c
sound/soc/codecs/wm8776.c
sound/soc/codecs/wm8988.c
sound/soc/sh/fsi.c
tools/perf/arch/sparc/Makefile [new file with mode: 0644]
tools/perf/arch/sparc/util/dwarf-regs.c [new file with mode: 0644]
tools/perf/builtin-report.c
tools/perf/util/PERF-VERSION-GEN
tools/perf/util/callchain.c
tools/perf/util/callchain.h

index dd10b51b4e652570df9a6575ac2df654bbaca15d..5405f7aecefc334b7d16c0f2764a8757e845ad43 100644 (file)
@@ -32,8 +32,6 @@ DocBook/
        - directory with DocBook templates etc. for kernel documentation.
 HOWTO
        - the process and procedures of how to do Linux kernel development.
-IO-mapping.txt
-       - how to access I/O mapped memory from within device drivers.
 IPMI.txt
        - info on Linux Intelligent Platform Management Interface (IPMI) Driver.
 IRQ-affinity.txt
@@ -84,6 +82,8 @@ blockdev/
        - info on block devices & drivers
 btmrvl.txt
        - info on Marvell Bluetooth driver usage.
+bus-virt-phys-mapping.txt
+       - how to access I/O mapped memory from within device drivers.
 cachetlb.txt
        - describes the cache/TLB flushing interfaces Linux uses.
 cdrom/
@@ -168,6 +168,8 @@ initrd.txt
        - how to use the RAM disk as an initial/temporary root filesystem.
 input/
        - info on Linux input device support.
+io-mapping.txt
+       - description of io_mapping functions in linux/io-mapping.h
 io_ordering.txt
        - info on ordering I/O writes to memory-mapped addresses.
 ioctl/
index 82d6aeb5228ff62d71a64e04519c24f35a6116e0..4ddb58df081e360311e22cafe40273d3176de46d 100644 (file)
@@ -1265,7 +1265,7 @@ and is between 256 and 4096 characters. It is defined in the file
                        If there are multiple matching configurations changing
                        the same attribute, the last one is used.
 
-       lmb=debug       [KNL] Enable lmb debug messages.
+       memblock=debug  [KNL] Enable memblock debug messages.
 
        load_ramdisk=   [RAM] List of ramdisks to load from floppy
                        See Documentation/blockdev/ramdisk.txt.
index 58848125b8bfadcc70f9b37ac68d77d6aee0794b..db3d0f5061f9c42e301e420878b0dc5cbe31e6e1 100644 (file)
@@ -5336,6 +5336,7 @@ T:        git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6.git
 T:     git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6.git
 S:     Maintained
 F:     arch/sparc/
+F:     drivers/sbus
 
 SPARC SERIAL DRIVERS
 M:     "David S. Miller" <davem@davemloft.net>
index a0162fa9456496662adb28898fcb44776e628414..7e79503ab89b5d395e634fda206e1e97d6262d04 100644 (file)
@@ -40,12 +40,12 @@ static inline void atomic_add(int i, atomic_t *v)
        int result;
 
        __asm__ __volatile__("@ atomic_add\n"
-"1:    ldrex   %0, [%2]\n"
-"      add     %0, %0, %3\n"
-"      strex   %1, %0, [%2]\n"
+"1:    ldrex   %0, [%3]\n"
+"      add     %0, %0, %4\n"
+"      strex   %1, %0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "Ir" (i)
        : "cc");
 }
@@ -58,12 +58,12 @@ static inline int atomic_add_return(int i, atomic_t *v)
        smp_mb();
 
        __asm__ __volatile__("@ atomic_add_return\n"
-"1:    ldrex   %0, [%2]\n"
-"      add     %0, %0, %3\n"
-"      strex   %1, %0, [%2]\n"
+"1:    ldrex   %0, [%3]\n"
+"      add     %0, %0, %4\n"
+"      strex   %1, %0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "Ir" (i)
        : "cc");
 
@@ -78,12 +78,12 @@ static inline void atomic_sub(int i, atomic_t *v)
        int result;
 
        __asm__ __volatile__("@ atomic_sub\n"
-"1:    ldrex   %0, [%2]\n"
-"      sub     %0, %0, %3\n"
-"      strex   %1, %0, [%2]\n"
+"1:    ldrex   %0, [%3]\n"
+"      sub     %0, %0, %4\n"
+"      strex   %1, %0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "Ir" (i)
        : "cc");
 }
@@ -96,12 +96,12 @@ static inline int atomic_sub_return(int i, atomic_t *v)
        smp_mb();
 
        __asm__ __volatile__("@ atomic_sub_return\n"
-"1:    ldrex   %0, [%2]\n"
-"      sub     %0, %0, %3\n"
-"      strex   %1, %0, [%2]\n"
+"1:    ldrex   %0, [%3]\n"
+"      sub     %0, %0, %4\n"
+"      strex   %1, %0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "Ir" (i)
        : "cc");
 
@@ -118,11 +118,11 @@ static inline int atomic_cmpxchg(atomic_t *ptr, int old, int new)
 
        do {
                __asm__ __volatile__("@ atomic_cmpxchg\n"
-               "ldrex  %1, [%2]\n"
+               "ldrex  %1, [%3]\n"
                "mov    %0, #0\n"
-               "teq    %1, %3\n"
-               "strexeq %0, %4, [%2]\n"
-                   : "=&r" (res), "=&r" (oldval)
+               "teq    %1, %4\n"
+               "strexeq %0, %5, [%3]\n"
+                   : "=&r" (res), "=&r" (oldval), "+Qo" (ptr->counter)
                    : "r" (&ptr->counter), "Ir" (old), "r" (new)
                    : "cc");
        } while (res);
@@ -137,12 +137,12 @@ static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr)
        unsigned long tmp, tmp2;
 
        __asm__ __volatile__("@ atomic_clear_mask\n"
-"1:    ldrex   %0, [%2]\n"
-"      bic     %0, %0, %3\n"
-"      strex   %1, %0, [%2]\n"
+"1:    ldrex   %0, [%3]\n"
+"      bic     %0, %0, %4\n"
+"      strex   %1, %0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (tmp), "=&r" (tmp2)
+       : "=&r" (tmp), "=&r" (tmp2), "+Qo" (*addr)
        : "r" (addr), "Ir" (mask)
        : "cc");
 }
@@ -249,7 +249,7 @@ static inline u64 atomic64_read(atomic64_t *v)
        __asm__ __volatile__("@ atomic64_read\n"
 "      ldrexd  %0, %H0, [%1]"
        : "=&r" (result)
-       : "r" (&v->counter)
+       : "r" (&v->counter), "Qo" (v->counter)
        );
 
        return result;
@@ -260,11 +260,11 @@ static inline void atomic64_set(atomic64_t *v, u64 i)
        u64 tmp;
 
        __asm__ __volatile__("@ atomic64_set\n"
-"1:    ldrexd  %0, %H0, [%1]\n"
-"      strexd  %0, %2, %H2, [%1]\n"
+"1:    ldrexd  %0, %H0, [%2]\n"
+"      strexd  %0, %3, %H3, [%2]\n"
 "      teq     %0, #0\n"
 "      bne     1b"
-       : "=&r" (tmp)
+       : "=&r" (tmp), "=Qo" (v->counter)
        : "r" (&v->counter), "r" (i)
        : "cc");
 }
@@ -275,13 +275,13 @@ static inline void atomic64_add(u64 i, atomic64_t *v)
        unsigned long tmp;
 
        __asm__ __volatile__("@ atomic64_add\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
-"      adds    %0, %0, %3\n"
-"      adc     %H0, %H0, %H3\n"
-"      strexd  %1, %0, %H0, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
+"      adds    %0, %0, %4\n"
+"      adc     %H0, %H0, %H4\n"
+"      strexd  %1, %0, %H0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "r" (i)
        : "cc");
 }
@@ -294,13 +294,13 @@ static inline u64 atomic64_add_return(u64 i, atomic64_t *v)
        smp_mb();
 
        __asm__ __volatile__("@ atomic64_add_return\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
-"      adds    %0, %0, %3\n"
-"      adc     %H0, %H0, %H3\n"
-"      strexd  %1, %0, %H0, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
+"      adds    %0, %0, %4\n"
+"      adc     %H0, %H0, %H4\n"
+"      strexd  %1, %0, %H0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "r" (i)
        : "cc");
 
@@ -315,13 +315,13 @@ static inline void atomic64_sub(u64 i, atomic64_t *v)
        unsigned long tmp;
 
        __asm__ __volatile__("@ atomic64_sub\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
-"      subs    %0, %0, %3\n"
-"      sbc     %H0, %H0, %H3\n"
-"      strexd  %1, %0, %H0, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
+"      subs    %0, %0, %4\n"
+"      sbc     %H0, %H0, %H4\n"
+"      strexd  %1, %0, %H0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "r" (i)
        : "cc");
 }
@@ -334,13 +334,13 @@ static inline u64 atomic64_sub_return(u64 i, atomic64_t *v)
        smp_mb();
 
        __asm__ __volatile__("@ atomic64_sub_return\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
-"      subs    %0, %0, %3\n"
-"      sbc     %H0, %H0, %H3\n"
-"      strexd  %1, %0, %H0, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
+"      subs    %0, %0, %4\n"
+"      sbc     %H0, %H0, %H4\n"
+"      strexd  %1, %0, %H0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "r" (i)
        : "cc");
 
@@ -358,12 +358,12 @@ static inline u64 atomic64_cmpxchg(atomic64_t *ptr, u64 old, u64 new)
 
        do {
                __asm__ __volatile__("@ atomic64_cmpxchg\n"
-               "ldrexd         %1, %H1, [%2]\n"
+               "ldrexd         %1, %H1, [%3]\n"
                "mov            %0, #0\n"
-               "teq            %1, %3\n"
-               "teqeq          %H1, %H3\n"
-               "strexdeq       %0, %4, %H4, [%2]"
-               : "=&r" (res), "=&r" (oldval)
+               "teq            %1, %4\n"
+               "teqeq          %H1, %H4\n"
+               "strexdeq       %0, %5, %H5, [%3]"
+               : "=&r" (res), "=&r" (oldval), "+Qo" (ptr->counter)
                : "r" (&ptr->counter), "r" (old), "r" (new)
                : "cc");
        } while (res);
@@ -381,11 +381,11 @@ static inline u64 atomic64_xchg(atomic64_t *ptr, u64 new)
        smp_mb();
 
        __asm__ __volatile__("@ atomic64_xchg\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
-"      strexd  %1, %3, %H3, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
+"      strexd  %1, %4, %H4, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (ptr->counter)
        : "r" (&ptr->counter), "r" (new)
        : "cc");
 
@@ -402,16 +402,16 @@ static inline u64 atomic64_dec_if_positive(atomic64_t *v)
        smp_mb();
 
        __asm__ __volatile__("@ atomic64_dec_if_positive\n"
-"1:    ldrexd  %0, %H0, [%2]\n"
+"1:    ldrexd  %0, %H0, [%3]\n"
 "      subs    %0, %0, #1\n"
 "      sbc     %H0, %H0, #0\n"
 "      teq     %H0, #0\n"
 "      bmi     2f\n"
-"      strexd  %1, %0, %H0, [%2]\n"
+"      strexd  %1, %0, %H0, [%3]\n"
 "      teq     %1, #0\n"
 "      bne     1b\n"
 "2:"
-       : "=&r" (result), "=&r" (tmp)
+       : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter)
        : "cc");
 
@@ -429,18 +429,18 @@ static inline int atomic64_add_unless(atomic64_t *v, u64 a, u64 u)
        smp_mb();
 
        __asm__ __volatile__("@ atomic64_add_unless\n"
-"1:    ldrexd  %0, %H0, [%3]\n"
-"      teq     %0, %4\n"
-"      teqeq   %H0, %H4\n"
+"1:    ldrexd  %0, %H0, [%4]\n"
+"      teq     %0, %5\n"
+"      teqeq   %H0, %H5\n"
 "      moveq   %1, #0\n"
 "      beq     2f\n"
-"      adds    %0, %0, %5\n"
-"      adc     %H0, %H0, %H5\n"
-"      strexd  %2, %0, %H0, [%3]\n"
+"      adds    %0, %0, %6\n"
+"      adc     %H0, %H0, %H6\n"
+"      strexd  %2, %0, %H0, [%4]\n"
 "      teq     %2, #0\n"
 "      bne     1b\n"
 "2:"
-       : "=&r" (val), "=&r" (ret), "=&r" (tmp)
+       : "=&r" (val), "+r" (ret), "=&r" (tmp), "+Qo" (v->counter)
        : "r" (&v->counter), "r" (u), "r" (a)
        : "cc");
 
index 7ee48e7f8f318a7b453e12849b60a6832bb85770..3fd7861de4d16c508ee424e52281de0dc39a4db7 100644 (file)
@@ -162,8 +162,6 @@ ENDPROC(__und_invalid)
        @  r4 - orig_r0 (see pt_regs definition in ptrace.h)
        @
        stmia   r5, {r0 - r4}
-
-       asm_trace_hardirqs_off
        .endm
 
        .align  5
@@ -204,7 +202,7 @@ __dabt_svc:
        @
        @ IRQs off again before pulling preserved data off the stack
        @
-       disable_irq
+       disable_irq_notrace
 
        @
        @ restore SPSR and restart the instruction
@@ -218,6 +216,9 @@ ENDPROC(__dabt_svc)
 __irq_svc:
        svc_entry
 
+#ifdef CONFIG_TRACE_IRQFLAGS
+       bl      trace_hardirqs_off
+#endif
 #ifdef CONFIG_PREEMPT
        get_thread_info tsk
        ldr     r8, [tsk, #TI_PREEMPT]          @ get preempt count
@@ -291,7 +292,7 @@ __und_svc:
        @
        @ IRQs off again before pulling preserved data off the stack
        @
-1:     disable_irq
+1:     disable_irq_notrace
 
        @
        @ restore SPSR and restart the instruction
@@ -327,7 +328,7 @@ __pabt_svc:
        @
        @ IRQs off again before pulling preserved data off the stack
        @
-       disable_irq
+       disable_irq_notrace
 
        @
        @ restore SPSR and restart the instruction
@@ -393,8 +394,6 @@ ENDPROC(__pabt_svc)
        @ Clear FP to mark the first stack frame
        @
        zero_fp
-
-       asm_trace_hardirqs_off
        .endm
 
        .macro  kuser_cmpxchg_check
@@ -465,9 +464,6 @@ __irq_usr:
  THUMB(        movne   r0, #0          )
  THUMB(        strne   r0, [r0]        )
 #endif
-#ifdef CONFIG_TRACE_IRQFLAGS
-       bl      trace_hardirqs_on
-#endif
 
        mov     why, #0
        b       ret_to_user
index da1f94906a4e2a35881bde99510760180bdba9e2..8bccbfa693ffc359dc55d6004837d2a149e2c5cd 100644 (file)
@@ -583,13 +583,14 @@ static void __kprobes emulate_ldr(struct kprobe *p, struct pt_regs *regs)
 {
        insn_llret_3arg_fn_t *i_fn = (insn_llret_3arg_fn_t *)&p->ainsn.insn[0];
        kprobe_opcode_t insn = p->opcode;
+       long ppc = (long)p->addr + 8;
        union reg_pair fnr;
        int rd = (insn >> 12) & 0xf;
        int rn = (insn >> 16) & 0xf;
        int rm = insn & 0xf;
        long rdv;
-       long rnv  = regs->uregs[rn];
-       long rmv  = regs->uregs[rm]; /* rm/rmv may be invalid, don't care. */
+       long rnv = (rn == 15) ? ppc : regs->uregs[rn];
+       long rmv = (rm == 15) ? ppc : regs->uregs[rm];
        long cpsr = regs->ARM_cpsr;
 
        fnr.dr = insnslot_llret_3arg_rflags(rnv, 0, rmv, cpsr, i_fn);
index acf5e6fdb6dcbe991d7bed5d63c7a77f38c16e34..a4a9cc88bec73a525a9edd4bdc7db94cea370ce9 100644 (file)
@@ -351,17 +351,21 @@ EXPORT_SYMBOL(dump_fpu);
 
 /*
  * Shuffle the argument into the correct register before calling the
- * thread function.  r1 is the thread argument, r2 is the pointer to
- * the thread function, and r3 points to the exit function.
+ * thread function.  r4 is the thread argument, r5 is the pointer to
+ * the thread function, and r6 points to the exit function.
  */
 extern void kernel_thread_helper(void);
 asm(   ".pushsection .text\n"
 "      .align\n"
 "      .type   kernel_thread_helper, #function\n"
 "kernel_thread_helper:\n"
-"      mov     r0, r1\n"
-"      mov     lr, r3\n"
-"      mov     pc, r2\n"
+#ifdef CONFIG_TRACE_IRQFLAGS
+"      bl      trace_hardirqs_on\n"
+#endif
+"      msr     cpsr_c, r7\n"
+"      mov     r0, r4\n"
+"      mov     lr, r6\n"
+"      mov     pc, r5\n"
 "      .size   kernel_thread_helper, . - kernel_thread_helper\n"
 "      .popsection");
 
@@ -391,11 +395,12 @@ pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 
        memset(&regs, 0, sizeof(regs));
 
-       regs.ARM_r1 = (unsigned long)arg;
-       regs.ARM_r2 = (unsigned long)fn;
-       regs.ARM_r3 = (unsigned long)kernel_thread_exit;
+       regs.ARM_r4 = (unsigned long)arg;
+       regs.ARM_r5 = (unsigned long)fn;
+       regs.ARM_r6 = (unsigned long)kernel_thread_exit;
+       regs.ARM_r7 = SVC_MODE | PSR_ENDSTATE | PSR_ISETSTATE;
        regs.ARM_pc = (unsigned long)kernel_thread_helper;
-       regs.ARM_cpsr = SVC_MODE | PSR_ENDSTATE | PSR_ISETSTATE;
+       regs.ARM_cpsr = regs.ARM_r7 | PSR_I_BIT;
 
        return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
 }
index fe84b9021c7adee213fdb94c7639c7f77e2dfaa5..0a1318fc8e2bd6c29774bcf1ab8cc48f6a5cfa0c 100644 (file)
@@ -131,7 +131,7 @@ EXPORT_SYMBOL(clk_disable);
  */
 static unsigned long clk_mtu_get_rate(struct clk *clk)
 {
-       void __iomem *addr = __io_address(U8500_PRCMU_BASE)
+       void __iomem *addr = __io_address(UX500_PRCMU_BASE)
                + PRCM_TCR;
        u32 tcr = readl(addr);
        int mtu = (int) clk->data;
index 6a3ac4539f164e23f7109896e8bab431ff9392bf..e9278f6d67aa7529f2408fd15fd5eab1bfecdb20 100644 (file)
@@ -21,6 +21,7 @@ static struct map_desc u5500_io_desc[] __initdata = {
        __IO_DEV_DESC(U5500_GPIO2_BASE, SZ_4K),
        __IO_DEV_DESC(U5500_GPIO3_BASE, SZ_4K),
        __IO_DEV_DESC(U5500_GPIO4_BASE, SZ_4K),
+       __IO_DEV_DESC(U5500_PRCMU_BASE, SZ_4K),
 };
 
 static struct platform_device *u5500_platform_devs[] __initdata = {
index 9819869d2bc90954967a5a1ca0e636c883c09e2f..df4955885b21d412ede58df0a8c26a4fcb8ca0fb 100644 (file)
@@ -218,6 +218,9 @@ void __init l2x0_init(void __iomem *base, __u32 aux_val, __u32 aux_mask)
        cache_id = readl(l2x0_base + L2X0_CACHE_ID);
        aux = readl(l2x0_base + L2X0_AUX_CTRL);
 
+       aux &= aux_mask;
+       aux |= aux_val;
+
        /* Determine the number of ways */
        switch (cache_id & L2X0_CACHE_ID_PART_MASK) {
        case L2X0_CACHE_ID_PART_L310:
@@ -248,8 +251,6 @@ void __init l2x0_init(void __iomem *base, __u32 aux_val, __u32 aux_mask)
        if (!(readl(l2x0_base + L2X0_CTRL) & 1)) {
 
                /* l2x0 controller is disabled */
-               aux &= aux_mask;
-               aux |= aux_val;
                writel(aux, l2x0_base + L2X0_AUX_CTRL);
 
                l2x0_inv_all();
index 8f10d24ae62540c5460eaf4b8e249c6ccd4ceac8..48cbdcb6bbd4288929f31bef94da3691b160a489 100644 (file)
@@ -12,7 +12,7 @@
 #
 #   http://www.arm.linux.org.uk/developer/machines/?action=new
 #
-# Last update: Sat May 1 10:36:42 2010
+# Last update: Mon Jul 12 21:10:14 2010
 #
 # machine_is_xxx       CONFIG_xxxx             MACH_TYPE_xxx           number
 #
@@ -1994,7 +1994,7 @@ spark                     MACH_SPARK              SPARK                   2002
 benzina                        MACH_BENZINA            BENZINA                 2003
 blaze                  MACH_BLAZE              BLAZE                   2004
 linkstation_ls_hgl     MACH_LINKSTATION_LS_HGL LINKSTATION_LS_HGL      2005
-htckovsky              MACH_HTCVENUS           HTCVENUS                2006
+htckovsky              MACH_HTCKOVSKY          HTCKOVSKY               2006
 sony_prs505            MACH_SONY_PRS505        SONY_PRS505             2007
 hanlin_v3              MACH_HANLIN_V3          HANLIN_V3               2008
 sapphira               MACH_SAPPHIRA           SAPPHIRA                2009
@@ -2609,7 +2609,7 @@ fujitsu_tvstbsoc1 MACH_FUJITSU_TVSTBSOC1  FUJITSU_TVSTBSOC1       2621
 lexikon                        MACH_LEXIKON            LEXIKON                 2622
 mini2440v2             MACH_MINI2440V2         MINI2440V2              2623
 icontrol               MACH_ICONTROL           ICONTROL                2624
-sheevad                        MACH_SHEEVAD            SHEEVAD                 2625
+gplugd                 MACH_SHEEVAD            SHEEVAD                 2625
 qsd8x50a_st1_1         MACH_QSD8X50A_ST1_1     QSD8X50A_ST1_1          2626
 qsd8x50a_st1_5         MACH_QSD8X50A_ST1_5     QSD8X50A_ST1_5          2627
 bee                    MACH_BEE                BEE                     2628
@@ -2804,3 +2804,149 @@ teton_bga               MACH_TETON_BGA          TETON_BGA               2816
 snapper9g45            MACH_SNAPPER9G45        SNAPPER9G45             2817
 tam3517                        MACH_TAM3517            TAM3517                 2818
 pdc100                 MACH_PDC100             PDC100                  2819
+eukrea_cpuimx25sd      MACH_EUKREA_CPUIMX25    EUKREA_CPUIMX25         2820
+eukrea_cpuimx35sd      MACH_EUKREA_CPUIMX35    EUKREA_CPUIMX35         2821
+eukrea_cpuimx51sd      MACH_EUKREA_CPUIMX51SD  EUKREA_CPUIMX51SD       2822
+eukrea_cpuimx51                MACH_EUKREA_CPUIMX51    EUKREA_CPUIMX51         2823
+p565                   MACH_P565               P565                    2824
+acer_a4                        MACH_ACER_A4            ACER_A4                 2825
+davinci_dm368_bip      MACH_DAVINCI_DM368_BIP  DAVINCI_DM368_BIP       2826
+eshare                 MACH_ESHARE             ESHARE                  2827
+hw_omapl138_europa     MACH_HW_OMAPL138_EUROPA HW_OMAPL138_EUROPA      2828
+wlbargn                        MACH_WLBARGN            WLBARGN                 2829
+bm170                  MACH_BM170              BM170                   2830
+netspace_mini_v2       MACH_NETSPACE_MINI_V2   NETSPACE_MINI_V2        2831
+netspace_plug_v2       MACH_NETSPACE_PLUG_V2   NETSPACE_PLUG_V2        2832
+siemens_l1             MACH_SIEMENS_L1         SIEMENS_L1              2833
+elv_lcu1               MACH_ELV_LCU1           ELV_LCU1                2834
+mcu1                   MACH_MCU1               MCU1                    2835
+omap3_tao3530          MACH_OMAP3_TAO3530      OMAP3_TAO3530           2836
+omap3_pcutouch         MACH_OMAP3_PCUTOUCH     OMAP3_PCUTOUCH          2837
+smdkc210               MACH_SMDKC210           SMDKC210                2838
+omap3_braillo          MACH_OMAP3_BRAILLO      OMAP3_BRAILLO           2839
+spyplug                        MACH_SPYPLUG            SPYPLUG                 2840
+ginger                 MACH_GINGER             GINGER                  2841
+tny_t3530              MACH_TNY_T3530          TNY_T3530               2842
+pca102                 MACH_PCA102             PCA102                  2843
+spade                  MACH_SPADE              SPADE                   2844
+mxc25_topaz            MACH_MXC25_TOPAZ        MXC25_TOPAZ             2845
+t5325                  MACH_T5325              T5325                   2846
+gw2361                 MACH_GW2361             GW2361                  2847
+elog                   MACH_ELOG               ELOG                    2848
+income                 MACH_INCOME             INCOME                  2849
+bcm589x                        MACH_BCM589X            BCM589X                 2850
+etna                   MACH_ETNA               ETNA                    2851
+hawks                  MACH_HAWKS              HAWKS                   2852
+meson                  MACH_MESON              MESON                   2853
+xsbase255              MACH_XSBASE255          XSBASE255               2854
+pvm2030                        MACH_PVM2030            PVM2030                 2855
+mioa502                        MACH_MIOA502            MIOA502                 2856
+vvbox_sdorig2          MACH_VVBOX_SDORIG2      VVBOX_SDORIG2           2857
+vvbox_sdlite2          MACH_VVBOX_SDLITE2      VVBOX_SDLITE2           2858
+vvbox_sdpro4           MACH_VVBOX_SDPRO4       VVBOX_SDPRO4            2859
+htc_spv_m700           MACH_HTC_SPV_M700       HTC_SPV_M700            2860
+mx257sx                        MACH_MX257SX            MX257SX                 2861
+goni                   MACH_GONI               GONI                    2862
+msm8x55_svlte_ffa      MACH_MSM8X55_SVLTE_FFA  MSM8X55_SVLTE_FFA       2863
+msm8x55_svlte_surf     MACH_MSM8X55_SVLTE_SURF MSM8X55_SVLTE_SURF      2864
+quickstep              MACH_QUICKSTEP          QUICKSTEP               2865
+dmw96                  MACH_DMW96              DMW96                   2866
+hammerhead             MACH_HAMMERHEAD         HAMMERHEAD              2867
+trident                        MACH_TRIDENT            TRIDENT                 2868
+lightning              MACH_LIGHTNING          LIGHTNING               2869
+iconnect               MACH_ICONNECT           ICONNECT                2870
+autobot                        MACH_AUTOBOT            AUTOBOT                 2871
+coconut                        MACH_COCONUT            COCONUT                 2872
+durian                 MACH_DURIAN             DURIAN                  2873
+cayenne                        MACH_CAYENNE            CAYENNE                 2874
+fuji                   MACH_FUJI               FUJI                    2875
+synology_6282          MACH_SYNOLOGY_6282      SYNOLOGY_6282           2876
+em1sy                  MACH_EM1SY              EM1SY                   2877
+m502                   MACH_M502               M502                    2878
+matrix518              MACH_MATRIX518          MATRIX518               2879
+tiny_gurnard           MACH_TINY_GURNARD       TINY_GURNARD            2880
+spear1310              MACH_SPEAR1310          SPEAR1310               2881
+bv07                   MACH_BV07               BV07                    2882
+mxt_td61               MACH_MXT_TD61           MXT_TD61                2883
+openrd_ultimate                MACH_OPENRD_ULTIMATE    OPENRD_ULTIMATE         2884
+devixp                 MACH_DEVIXP             DEVIXP                  2885
+miccpt                 MACH_MICCPT             MICCPT                  2886
+mic256                 MACH_MIC256             MIC256                  2887
+as1167                 MACH_AS1167             AS1167                  2888
+omap3_ibiza            MACH_OMAP3_IBIZA        OMAP3_IBIZA             2889
+u5500                  MACH_U5500              U5500                   2890
+davinci_picto          MACH_DAVINCI_PICTO      DAVINCI_PICTO           2891
+mecha                  MACH_MECHA              MECHA                   2892
+bubba3                 MACH_BUBBA3             BUBBA3                  2893
+pupitre                        MACH_PUPITRE            PUPITRE                 2894
+tegra_harmony          MACH_TEGRA_HARMONY      TEGRA_HARMONY           2895
+tegra_vogue            MACH_TEGRA_VOGUE        TEGRA_VOGUE             2896
+tegra_e1165            MACH_TEGRA_E1165        TEGRA_E1165             2897
+simplenet              MACH_SIMPLENET          SIMPLENET               2898
+ec4350tbm              MACH_EC4350TBM          EC4350TBM               2899
+pec_tc                 MACH_PEC_TC             PEC_TC                  2900
+pec_hc2                        MACH_PEC_HC2            PEC_HC2                 2901
+esl_mobilis_a          MACH_ESL_MOBILIS_A      ESL_MOBILIS_A           2902
+esl_mobilis_b          MACH_ESL_MOBILIS_B      ESL_MOBILIS_B           2903
+esl_wave_a             MACH_ESL_WAVE_A         ESL_WAVE_A              2904
+esl_wave_b             MACH_ESL_WAVE_B         ESL_WAVE_B              2905
+unisense_mmm           MACH_UNISENSE_MMM       UNISENSE_MMM            2906
+blueshark              MACH_BLUESHARK          BLUESHARK               2907
+e10                    MACH_E10                E10                     2908
+app3k_robin            MACH_APP3K_ROBIN        APP3K_ROBIN             2909
+pov15hd                        MACH_POV15HD            POV15HD                 2910
+stella                 MACH_STELLA             STELLA                  2911
+linkstation_lschl      MACH_LINKSTATION_LSCHL  LINKSTATION_LSCHL       2913
+netwalker              MACH_NETWALKER          NETWALKER               2914
+acsx106                        MACH_ACSX106            ACSX106                 2915
+atlas5_c1              MACH_ATLAS5_C1          ATLAS5_C1               2916
+nsb3ast                        MACH_NSB3AST            NSB3AST                 2917
+gnet_slc               MACH_GNET_SLC           GNET_SLC                2918
+af4000                 MACH_AF4000             AF4000                  2919
+ark9431                        MACH_ARK9431            ARK9431                 2920
+fs_s5pc100             MACH_FS_S5PC100         FS_S5PC100              2921
+omap3505nova8          MACH_OMAP3505NOVA8      OMAP3505NOVA8           2922
+omap3621_edp1          MACH_OMAP3621_EDP1      OMAP3621_EDP1           2923
+oratisaes              MACH_ORATISAES          ORATISAES               2924
+smdkv310               MACH_SMDKV310           SMDKV310                2925
+siemens_l0             MACH_SIEMENS_L0         SIEMENS_L0              2926
+ventana                        MACH_VENTANA            VENTANA                 2927
+wm8505_7in_netbook     MACH_WM8505_7IN_NETBOOK WM8505_7IN_NETBOOK      2928
+ec4350sdb              MACH_EC4350SDB          EC4350SDB               2929
+mimas                  MACH_MIMAS              MIMAS                   2930
+titan                  MACH_TITAN              TITAN                   2931
+craneboard             MACH_CRANEBOARD         CRANEBOARD              2932
+es2440                 MACH_ES2440             ES2440                  2933
+najay_a9263            MACH_NAJAY_A9263        NAJAY_A9263             2934
+htctornado             MACH_HTCTORNADO         HTCTORNADO              2935
+dimm_mx257             MACH_DIMM_MX257         DIMM_MX257              2936
+jigen301               MACH_JIGEN              JIGEN                   2937
+smdk6450               MACH_SMDK6450           SMDK6450                2938
+meno_qng               MACH_MENO_QNG           MENO_QNG                2939
+ns2416                 MACH_NS2416             NS2416                  2940
+rpc353                 MACH_RPC353             RPC353                  2941
+tq6410                 MACH_TQ6410             TQ6410                  2942
+sky6410                        MACH_SKY6410            SKY6410                 2943
+dynasty                        MACH_DYNASTY            DYNASTY                 2944
+vivo                   MACH_VIVO               VIVO                    2945
+bury_bl7582            MACH_BURY_BL7582        BURY_BL7582             2946
+bury_bps5270           MACH_BURY_BPS5270       BURY_BPS5270            2947
+basi                   MACH_BASI               BASI                    2948
+tn200                  MACH_TN200              TN200                   2949
+c2mmi                  MACH_C2MMI              C2MMI                   2950
+meson_6236m            MACH_MESON_6236M        MESON_6236M             2951
+meson_8626m            MACH_MESON_8626M        MESON_8626M             2952
+tube                   MACH_TUBE               TUBE                    2953
+messina                        MACH_MESSINA            MESSINA                 2954
+mx50_arm2              MACH_MX50_ARM2          MX50_ARM2               2955
+cetus9263              MACH_CETUS9263          CETUS9263               2956
+brownstone             MACH_BROWNSTONE         BROWNSTONE              2957
+vmx25                  MACH_VMX25              VMX25                   2958
+vmx51                  MACH_VMX51              VMX51                   2959
+abacus                 MACH_ABACUS             ABACUS                  2960
+cm4745                 MACH_CM4745             CM4745                  2961
+oratislink             MACH_ORATISLINK         ORATISLINK              2962
+davinci_dm365_dvr      MACH_DAVINCI_DM365_DVR  DAVINCI_DM365_DVR       2963
+netviz                 MACH_NETVIZ             NETVIZ                  2964
+flexibity              MACH_FLEXIBITY          FLEXIBITY               2965
+wlan_computer          MACH_WLAN_COMPUTER      WLAN_COMPUTER           2966
index 76818f926539bf444c8aa577d12dc1af1296d665..505a08592423dbd17b7168a2782247c2d401f52e 100644 (file)
@@ -5,7 +5,7 @@ mainmenu "Linux/Microblaze Kernel Configuration"
 
 config MICROBLAZE
        def_bool y
-       select HAVE_LMB
+       select HAVE_MEMBLOCK
        select HAVE_FUNCTION_TRACER
        select HAVE_FUNCTION_TRACE_MCOUNT_TEST
        select HAVE_FUNCTION_GRAPH_TRACER
similarity index 57%
rename from arch/microblaze/include/asm/lmb.h
rename to arch/microblaze/include/asm/memblock.h
index a0a0a929c293b8fd4df06d3e9563b718a08d2725..f9c2fa331d2ad92e675aad399befb989cc575fbc 100644 (file)
@@ -6,12 +6,12 @@
  * for more details.
  */
 
-#ifndef _ASM_MICROBLAZE_LMB_H
-#define _ASM_MICROBLAZE_LMB_H
+#ifndef _ASM_MICROBLAZE_MEMBLOCK_H
+#define _ASM_MICROBLAZE_MEMBLOCK_H
 
-/* LMB limit is OFF */
-#define LMB_REAL_LIMIT 0xFFFFFFFF
+/* MEMBLOCK limit is OFF */
+#define MEMBLOCK_REAL_LIMIT    0xFFFFFFFF
 
-#endif /* _ASM_MICROBLAZE_LMB_H */
+#endif /* _ASM_MICROBLAZE_MEMBLOCK_H */
 
 
index a15ef6d67ca92e037628f1c9808db4f5cd55e5ad..427b13b4740f822c95362f10a2510359e75fbd0a 100644 (file)
@@ -29,7 +29,7 @@
 #include <linux/kexec.h>
 #include <linux/debugfs.h>
 #include <linux/irq.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/prom.h>
 #include <asm/page.h>
@@ -49,12 +49,12 @@ void __init early_init_dt_scan_chosen_arch(unsigned long node)
 
 void __init early_init_dt_add_memory_arch(u64 base, u64 size)
 {
-       lmb_add(base, size);
+       memblock_add(base, size);
 }
 
 u64 __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
 {
-       return lmb_alloc(size, align);
+       return memblock_alloc(size, align);
 }
 
 #ifdef CONFIG_EARLY_PRINTK
@@ -104,8 +104,8 @@ void __init early_init_devtree(void *params)
         */
        of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
 
-       /* Scan memory nodes and rebuild LMBs */
-       lmb_init();
+       /* Scan memory nodes and rebuild MEMBLOCKs */
+       memblock_init();
        of_scan_flat_dt(early_init_dt_scan_root, NULL);
        of_scan_flat_dt(early_init_dt_scan_memory, NULL);
 
@@ -113,9 +113,9 @@ void __init early_init_devtree(void *params)
        strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
        parse_early_param();
 
-       lmb_analyze();
+       memblock_analyze();
 
-       pr_debug("Phys. mem: %lx\n", (unsigned long) lmb_phys_mem_size());
+       pr_debug("Phys. mem: %lx\n", (unsigned long) memblock_phys_mem_size());
 
        pr_debug(" <- early_init_devtree()\n");
 }
index cca3579d4268d07aab1910a463180f9dd271a4e6..db5934989926d583d837ec51c752ac90eccba6ff 100644 (file)
@@ -10,7 +10,7 @@
 #include <linux/bootmem.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/mm.h> /* mem_init */
 #include <linux/initrd.h>
 #include <linux/pagemap.h>
@@ -76,10 +76,10 @@ void __init setup_memory(void)
        u32 kernel_align_start, kernel_align_size;
 
        /* Find main memory where is the kernel */
-       for (i = 0; i < lmb.memory.cnt; i++) {
-               memory_start = (u32) lmb.memory.region[i].base;
-               memory_end = (u32) lmb.memory.region[i].base
-                               + (u32) lmb.memory.region[i].size;
+       for (i = 0; i < memblock.memory.cnt; i++) {
+               memory_start = (u32) memblock.memory.region[i].base;
+               memory_end = (u32) memblock.memory.region[i].base
+                               + (u32) memblock.memory.region[i].size;
                if ((memory_start <= (u32)_text) &&
                                        ((u32)_text <= memory_end)) {
                        memory_size = memory_end - memory_start;
@@ -100,7 +100,7 @@ void __init setup_memory(void)
        kernel_align_start = PAGE_DOWN((u32)_text);
        /* ALIGN can be remove because _end in vmlinux.lds.S is align */
        kernel_align_size = PAGE_UP((u32)klimit) - kernel_align_start;
-       lmb_reserve(kernel_align_start, kernel_align_size);
+       memblock_reserve(kernel_align_start, kernel_align_size);
        printk(KERN_INFO "%s: kernel addr=0x%08x-0x%08x size=0x%08x\n",
                __func__, kernel_align_start, kernel_align_start
                        + kernel_align_size, kernel_align_size);
@@ -141,18 +141,18 @@ void __init setup_memory(void)
        map_size = init_bootmem_node(&contig_page_data,
                PFN_UP(TOPHYS((u32)klimit)), min_low_pfn, max_low_pfn);
 #endif
-       lmb_reserve(PFN_UP(TOPHYS((u32)klimit)) << PAGE_SHIFT, map_size);
+       memblock_reserve(PFN_UP(TOPHYS((u32)klimit)) << PAGE_SHIFT, map_size);
 
        /* free bootmem is whole main memory */
        free_bootmem(memory_start, memory_size);
 
        /* reserve allocate blocks */
-       for (i = 0; i < lmb.reserved.cnt; i++) {
+       for (i = 0; i < memblock.reserved.cnt; i++) {
                pr_debug("reserved %d - 0x%08x-0x%08x\n", i,
-                       (u32) lmb.reserved.region[i].base,
-                       (u32) lmb_size_bytes(&lmb.reserved, i));
-               reserve_bootmem(lmb.reserved.region[i].base,
-                       lmb_size_bytes(&lmb.reserved, i) - 1, BOOTMEM_DEFAULT);
+                       (u32) memblock.reserved.region[i].base,
+                       (u32) memblock_size_bytes(&memblock.reserved, i));
+               reserve_bootmem(memblock.reserved.region[i].base,
+                       memblock_size_bytes(&memblock.reserved, i) - 1, BOOTMEM_DEFAULT);
        }
 #ifdef CONFIG_MMU
        init_bootmem_done = 1;
@@ -235,7 +235,7 @@ static void mm_cmdline_setup(void)
                if (maxmem && memory_size > maxmem) {
                        memory_size = maxmem;
                        memory_end = memory_start + memory_size;
-                       lmb.memory.region[0].size = memory_size;
+                       memblock.memory.region[0].size = memory_size;
                }
        }
 }
@@ -273,19 +273,19 @@ asmlinkage void __init mmu_init(void)
 {
        unsigned int kstart, ksize;
 
-       if (!lmb.reserved.cnt) {
+       if (!memblock.reserved.cnt) {
                printk(KERN_EMERG "Error memory count\n");
                machine_restart(NULL);
        }
 
-       if ((u32) lmb.memory.region[0].size < 0x1000000) {
+       if ((u32) memblock.memory.region[0].size < 0x1000000) {
                printk(KERN_EMERG "Memory must be greater than 16MB\n");
                machine_restart(NULL);
        }
        /* Find main memory where the kernel is */
-       memory_start = (u32) lmb.memory.region[0].base;
-       memory_end = (u32) lmb.memory.region[0].base +
-                               (u32) lmb.memory.region[0].size;
+       memory_start = (u32) memblock.memory.region[0].base;
+       memory_end = (u32) memblock.memory.region[0].base +
+                               (u32) memblock.memory.region[0].size;
        memory_size = memory_end - memory_start;
 
        mm_cmdline_setup(); /* FIXME parse args from command line - not used */
@@ -297,7 +297,7 @@ asmlinkage void __init mmu_init(void)
        kstart = __pa(CONFIG_KERNEL_START); /* kernel start */
        /* kernel size */
        ksize = PAGE_ALIGN(((u32)_end - (u32)CONFIG_KERNEL_START));
-       lmb_reserve(kstart, ksize);
+       memblock_reserve(kstart, ksize);
 
 #if defined(CONFIG_BLK_DEV_INITRD)
        /* Remove the init RAM disk from the available memory. */
@@ -335,7 +335,7 @@ void __init *early_get_page(void)
                 * Mem start + 32MB -> here is limit
                 * because of mem mapping from head.S
                 */
-               p = __va(lmb_alloc_base(PAGE_SIZE, PAGE_SIZE,
+               p = __va(memblock_alloc_base(PAGE_SIZE, PAGE_SIZE,
                                        memory_start + 0x2000000));
        }
        return p;
index 6506bf4fbff13d82d1c66b629638efe435882b3d..2031a2846865e51bb3889742fe3fc60125532a4c 100644 (file)
@@ -132,7 +132,7 @@ config PPC
        select HAVE_ARCH_KGDB
        select HAVE_KRETPROBES
        select HAVE_ARCH_TRACEHOOK
-       select HAVE_LMB
+       select HAVE_MEMBLOCK
        select HAVE_DMA_ATTRS
        select HAVE_DMA_API_DEBUG
        select USE_GENERIC_SMP_HELPERS if SMP
index 98324c5a82867cfa5ace5179de635220ab5d01a4..9a846efe6382026d3f093988ac1b64be76894809 100644 (file)
@@ -12,7 +12,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/types.h>
 #include <asm/page.h>
index 0835eb977ba9c31b5536e3e714545d2528f7a876..e50323fe941f96d92e68ce246dad172fa58507c3 100644 (file)
@@ -6,6 +6,30 @@
 #include <linux/errno.h>
 #include <linux/of.h>
 
+/*
+ * SPI Parameter RAM common to QE and CPM.
+ */
+struct spi_pram {
+       __be16  rbase;  /* Rx Buffer descriptor base address */
+       __be16  tbase;  /* Tx Buffer descriptor base address */
+       u8      rfcr;   /* Rx function code */
+       u8      tfcr;   /* Tx function code */
+       __be16  mrblr;  /* Max receive buffer length */
+       __be32  rstate; /* Internal */
+       __be32  rdp;    /* Internal */
+       __be16  rbptr;  /* Internal */
+       __be16  rbc;    /* Internal */
+       __be32  rxtmp;  /* Internal */
+       __be32  tstate; /* Internal */
+       __be32  tdp;    /* Internal */
+       __be16  tbptr;  /* Internal */
+       __be16  tbc;    /* Internal */
+       __be32  txtmp;  /* Internal */
+       __be32  res;    /* Tx temp. */
+       __be16  rpbase; /* Relocation pointer (CPM1 only) */
+       __be16  res1;   /* Reserved */
+};
+
 /*
  * USB Controller pram common to QE and CPM.
  */
index 81b01192f4408f01c7da9553a49c5fb01ee31c10..bd07650dca56b0489b5518ccaaaa6eaf5f6de73a 100644 (file)
@@ -17,6 +17,7 @@
 #ifndef __CPM1__
 #define __CPM1__
 
+#include <linux/init.h>
 #include <asm/8xx_immap.h>
 #include <asm/ptrace.h>
 #include <asm/cpm.h>
@@ -54,7 +55,7 @@ extern cpm8xx_t __iomem *cpmp; /* Pointer to comm processor */
 
 extern void cpm_setbrg(uint brg, uint rate);
 
-extern void cpm_load_patch(cpm8xx_t *cp);
+extern void __init cpm_load_patch(cpm8xx_t *cp);
 
 extern void cpm_reset(void);
 
diff --git a/arch/powerpc/include/asm/lmb.h b/arch/powerpc/include/asm/lmb.h
deleted file mode 100644 (file)
index 6f5fdf0..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef _ASM_POWERPC_LMB_H
-#define _ASM_POWERPC_LMB_H
-
-#include <asm/udbg.h>
-
-#define LMB_DBG(fmt...) udbg_printf(fmt)
-
-#ifdef CONFIG_PPC32
-extern phys_addr_t lowmem_end_addr;
-#define LMB_REAL_LIMIT lowmem_end_addr
-#else
-#define LMB_REAL_LIMIT 0
-#endif
-
-#endif /* _ASM_POWERPC_LMB_H */
diff --git a/arch/powerpc/include/asm/memblock.h b/arch/powerpc/include/asm/memblock.h
new file mode 100644 (file)
index 0000000..3c29728
--- /dev/null
@@ -0,0 +1,15 @@
+#ifndef _ASM_POWERPC_MEMBLOCK_H
+#define _ASM_POWERPC_MEMBLOCK_H
+
+#include <asm/udbg.h>
+
+#define MEMBLOCK_DBG(fmt...) udbg_printf(fmt)
+
+#ifdef CONFIG_PPC32
+extern phys_addr_t lowmem_end_addr;
+#define MEMBLOCK_REAL_LIMIT    lowmem_end_addr
+#else
+#define MEMBLOCK_REAL_LIMIT    0
+#endif
+
+#endif /* _ASM_POWERPC_MEMBLOCK_H */
index 26e58630ed7bf3d2f618abae3f6a74d7f4350e4b..625942ae55856f8788011bc88f35781b3f178a1b 100644 (file)
@@ -7,7 +7,7 @@
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/sections.h>
 #include <asm/prom.h>
index 29df48f2b61a45d27f33301fe350439a94e384f4..417f7b05a9cebc6e10acfaf41eec88d17a2f7e89 100644 (file)
@@ -24,7 +24,7 @@
 #include <linux/init.h>
 #include <linux/irq.h>
 #include <linux/types.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/processor.h>
 #include <asm/machdep.h>
index 5fb667a60894dd6238b51db9c13b1caf93fc0253..40f524643ba6f76ed7aa3065ebc053e96f1ad27f 100644 (file)
@@ -13,7 +13,7 @@
 
 #include <linux/crash_dump.h>
 #include <linux/bootmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <asm/code-patching.h>
 #include <asm/kdump.h>
 #include <asm/prom.h>
@@ -33,7 +33,7 @@ unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
 #ifndef CONFIG_RELOCATABLE
 void __init reserve_kdump_trampoline(void)
 {
-       lmb_reserve(0, KDUMP_RESERVE_LIMIT);
+       memblock_reserve(0, KDUMP_RESERVE_LIMIT);
 }
 
 static void __init create_trampoline(unsigned long addr)
index e7fe218b86978e52b2ff50f9d34c6efbd4b64790..02f724f367533ee60f6512a7453cb0f0e3024fbc 100644 (file)
@@ -71,7 +71,7 @@ static int ppc_swiotlb_bus_notify(struct notifier_block *nb,
        sd->max_direct_dma_addr = 0;
 
        /* May need to bounce if the device can't address all of DRAM */
-       if ((dma_get_mask(dev) + 1) < lmb_end_of_DRAM())
+       if ((dma_get_mask(dev) + 1) < memblock_end_of_DRAM())
                set_dma_ops(dev, &swiotlb_dma_ops);
 
        return NOTIFY_DONE;
index 8d1de6f31d5a6befad3d93715d4ddf338b027b55..84d6367ec0030c6611782902321d39871b9fe278 100644 (file)
@@ -9,7 +9,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/dma-debug.h>
 #include <linux/gfp.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <asm/bug.h>
 #include <asm/abs_addr.h>
 
@@ -89,7 +89,7 @@ static int dma_direct_dma_supported(struct device *dev, u64 mask)
        /* Could be improved so platforms can set the limit in case
         * they have limited DMA windows
         */
-       return mask >= (lmb_end_of_DRAM() - 1);
+       return mask >= (memblock_end_of_DRAM() - 1);
 #else
        return 1;
 #endif
index beb4d78a23049603a7806b1ad2bdbd0c0787226b..a92c79be2728e97bb54433e6c7d49b5917a2dcde 100644 (file)
@@ -205,8 +205,7 @@ next_tlb_setup:
        bdnz+   next_tlb_setup
 
 /* 7. Jump to our 1:1 mapping */
-       li      r6, 0
-
+       mr      r6, r25
 #else
        #error You need to specify the mapping or not use this at all.
 #endif
@@ -217,7 +216,6 @@ next_tlb_setup:
 1:     mflr    r9
        rlwimi  r6,r9,0,20,31
        addi    r6,r6,(2f - 1b)
-       add     r6, r6, r25
        mtspr   SPRN_SRR0,r6
        mtspr   SPRN_SRR1,r7
        rfi                             /* start execution out of TLB1[0] entry */
index bb3d893a8353e99ea751c48a5f369e3f33b74413..89f005116aac941aa28b2792fc212ba95e2122d7 100644 (file)
@@ -12,7 +12,7 @@
 #include <linux/kexec.h>
 #include <linux/reboot.h>
 #include <linux/threads.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/of.h>
 #include <asm/machdep.h>
 #include <asm/prom.h>
@@ -66,11 +66,11 @@ void __init reserve_crashkernel(void)
        unsigned long long crash_size, crash_base;
        int ret;
 
-       /* this is necessary because of lmb_phys_mem_size() */
-       lmb_analyze();
+       /* this is necessary because of memblock_phys_mem_size() */
+       memblock_analyze();
 
        /* use common parsing */
-       ret = parse_crashkernel(boot_command_line, lmb_phys_mem_size(),
+       ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(),
                        &crash_size, &crash_base);
        if (ret == 0 && crash_size > 0) {
                crashk_res.start = crash_base;
@@ -133,9 +133,9 @@ void __init reserve_crashkernel(void)
                        "for crashkernel (System RAM: %ldMB)\n",
                        (unsigned long)(crash_size >> 20),
                        (unsigned long)(crashk_res.start >> 20),
-                       (unsigned long)(lmb_phys_mem_size() >> 20));
+                       (unsigned long)(memblock_phys_mem_size() >> 20));
 
-       lmb_reserve(crashk_res.start, crash_size);
+       memblock_reserve(crashk_res.start, crash_size);
 }
 
 int overlaps_crashkernel(unsigned long start, unsigned long size)
index f88acf0218dbfdbe30dc0f65f20326ae5a38ee7d..139a773853f408dddefffc96b1c6f41debdd421d 100644 (file)
@@ -9,7 +9,7 @@
 
 #include <linux/threads.h>
 #include <linux/module.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/firmware.h>
 #include <asm/lppaca.h>
@@ -117,7 +117,7 @@ void __init allocate_pacas(void)
         * the first segment. On iSeries they must be within the area mapped
         * by the HV, which is HvPagesToMap * HVPAGESIZE bytes.
         */
-       limit = min(0x10000000ULL, lmb.rmo_size);
+       limit = min(0x10000000ULL, memblock.rmo_size);
        if (firmware_has_feature(FW_FEATURE_ISERIES))
                limit = min(limit, HvPagesToMap * HVPAGESIZE);
 
@@ -128,7 +128,7 @@ void __init allocate_pacas(void)
 
        paca_size = PAGE_ALIGN(sizeof(struct paca_struct) * nr_cpus);
 
-       paca = __va(lmb_alloc_base(paca_size, PAGE_SIZE, limit));
+       paca = __va(memblock_alloc_base(paca_size, PAGE_SIZE, limit));
        memset(paca, 0, paca_size);
 
        printk(KERN_DEBUG "Allocated %u bytes for %d pacas at %p\n",
@@ -148,7 +148,7 @@ void __init free_unused_pacas(void)
        if (new_size >= paca_size)
                return;
 
-       lmb_free(__pa(paca) + new_size, paca_size - new_size);
+       memblock_free(__pa(paca) + new_size, paca_size - new_size);
 
        printk(KERN_DEBUG "Freed %u bytes for unused pacas\n",
                paca_size - new_size);
index 05131d634e7395c6ba4d9599a4f7b68734fe174d..9d3953983fb74759a2ab2bfbb2a5f7dd316e62ca 100644 (file)
@@ -31,7 +31,7 @@
 #include <linux/kexec.h>
 #include <linux/debugfs.h>
 #include <linux/irq.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/prom.h>
 #include <asm/rtas.h>
@@ -98,7 +98,7 @@ static void __init move_device_tree(void)
 
        if ((memory_limit && (start + size) > memory_limit) ||
                        overlaps_crashkernel(start, size)) {
-               p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
+               p = __va(memblock_alloc_base(size, PAGE_SIZE, memblock.rmo_size));
                memcpy(p, initial_boot_params, size);
                initial_boot_params = (struct boot_param_header *)p;
                DBG("Moved device tree to 0x%p\n", p);
@@ -411,13 +411,13 @@ static int __init early_init_dt_scan_drconf_memory(unsigned long node)
 {
        __be32 *dm, *ls, *usm;
        unsigned long l, n, flags;
-       u64 base, size, lmb_size;
+       u64 base, size, memblock_size;
        unsigned int is_kexec_kdump = 0, rngs;
 
-       ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
+       ls = of_get_flat_dt_prop(node, "ibm,memblock-size", &l);
        if (ls == NULL || l < dt_root_size_cells * sizeof(__be32))
                return 0;
-       lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
+       memblock_size = dt_mem_next_cell(dt_root_size_cells, &ls);
 
        dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
        if (dm == NULL || l < sizeof(__be32))
@@ -442,11 +442,11 @@ static int __init early_init_dt_scan_drconf_memory(unsigned long node)
                   or if the block is not assigned to this partition (0x8) */
                if ((flags & 0x80) || !(flags & 0x8))
                        continue;
-               size = lmb_size;
+               size = memblock_size;
                rngs = 1;
                if (is_kexec_kdump) {
                        /*
-                        * For each lmb in ibm,dynamic-memory, a corresponding
+                        * For each memblock in ibm,dynamic-memory, a corresponding
                         * entry in linux,drconf-usable-memory property contains
                         * a counter 'p' followed by 'p' (base, size) duple.
                         * Now read the counter from
@@ -469,10 +469,10 @@ static int __init early_init_dt_scan_drconf_memory(unsigned long node)
                                if ((base + size) > 0x80000000ul)
                                        size = 0x80000000ul - base;
                        }
-                       lmb_add(base, size);
+                       memblock_add(base, size);
                } while (--rngs);
        }
-       lmb_dump_all();
+       memblock_dump_all();
        return 0;
 }
 #else
@@ -501,14 +501,14 @@ void __init early_init_dt_add_memory_arch(u64 base, u64 size)
        }
 #endif
 
-       lmb_add(base, size);
+       memblock_add(base, size);
 
        memstart_addr = min((u64)memstart_addr, base);
 }
 
 u64 __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
 {
-       return lmb_alloc(size, align);
+       return memblock_alloc(size, align);
 }
 
 #ifdef CONFIG_BLK_DEV_INITRD
@@ -534,12 +534,12 @@ static void __init early_reserve_mem(void)
        /* before we do anything, lets reserve the dt blob */
        self_base = __pa((unsigned long)initial_boot_params);
        self_size = initial_boot_params->totalsize;
-       lmb_reserve(self_base, self_size);
+       memblock_reserve(self_base, self_size);
 
 #ifdef CONFIG_BLK_DEV_INITRD
        /* then reserve the initrd, if any */
        if (initrd_start && (initrd_end > initrd_start))
-               lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
+               memblock_reserve(__pa(initrd_start), initrd_end - initrd_start);
 #endif /* CONFIG_BLK_DEV_INITRD */
 
 #ifdef CONFIG_PPC32
@@ -560,7 +560,7 @@ static void __init early_reserve_mem(void)
                        if (base_32 == self_base && size_32 == self_size)
                                continue;
                        DBG("reserving: %x -> %x\n", base_32, size_32);
-                       lmb_reserve(base_32, size_32);
+                       memblock_reserve(base_32, size_32);
                }
                return;
        }
@@ -571,7 +571,7 @@ static void __init early_reserve_mem(void)
                if (size == 0)
                        break;
                DBG("reserving: %llx -> %llx\n", base, size);
-               lmb_reserve(base, size);
+               memblock_reserve(base, size);
        }
 }
 
@@ -594,7 +594,7 @@ static inline unsigned long phyp_dump_calculate_reserve_size(void)
                return phyp_dump_info->reserve_bootvar;
 
        /* divide by 20 to get 5% of value */
-       tmp = lmb_end_of_DRAM();
+       tmp = memblock_end_of_DRAM();
        do_div(tmp, 20);
 
        /* round it down in multiples of 256 */
@@ -633,11 +633,11 @@ static void __init phyp_dump_reserve_mem(void)
        if (phyp_dump_info->phyp_dump_is_active) {
                /* Reserve *everything* above RMR.Area freed by userland tools*/
                base = variable_reserve_size;
-               size = lmb_end_of_DRAM() - base;
+               size = memblock_end_of_DRAM() - base;
 
                /* XXX crashed_ram_end is wrong, since it may be beyond
                 * the memory_limit, it will need to be adjusted. */
-               lmb_reserve(base, size);
+               memblock_reserve(base, size);
 
                phyp_dump_info->init_reserve_start = base;
                phyp_dump_info->init_reserve_size = size;
@@ -645,8 +645,8 @@ static void __init phyp_dump_reserve_mem(void)
                size = phyp_dump_info->cpu_state_size +
                        phyp_dump_info->hpte_region_size +
                        variable_reserve_size;
-               base = lmb_end_of_DRAM() - size;
-               lmb_reserve(base, size);
+               base = memblock_end_of_DRAM() - size;
+               memblock_reserve(base, size);
                phyp_dump_info->init_reserve_start = base;
                phyp_dump_info->init_reserve_size = size;
        }
@@ -681,8 +681,8 @@ void __init early_init_devtree(void *params)
         */
        of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
 
-       /* Scan memory nodes and rebuild LMBs */
-       lmb_init();
+       /* Scan memory nodes and rebuild MEMBLOCKs */
+       memblock_init();
        of_scan_flat_dt(early_init_dt_scan_root, NULL);
        of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL);
 
@@ -690,11 +690,11 @@ void __init early_init_devtree(void *params)
        strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
        parse_early_param();
 
-       /* Reserve LMB regions used by kernel, initrd, dt, etc... */
-       lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
+       /* Reserve MEMBLOCK regions used by kernel, initrd, dt, etc... */
+       memblock_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
        /* If relocatable, reserve first 32k for interrupt vectors etc. */
        if (PHYSICAL_START > MEMORY_START)
-               lmb_reserve(MEMORY_START, 0x8000);
+               memblock_reserve(MEMORY_START, 0x8000);
        reserve_kdump_trampoline();
        reserve_crashkernel();
        early_reserve_mem();
@@ -706,17 +706,17 @@ void __init early_init_devtree(void *params)
 
                /* Ensure that total memory size is page-aligned, because
                 * otherwise mark_bootmem() gets upset. */
-               lmb_analyze();
-               memsize = lmb_phys_mem_size();
+               memblock_analyze();
+               memsize = memblock_phys_mem_size();
                if ((memsize & PAGE_MASK) != memsize)
                        limit = memsize & PAGE_MASK;
        }
-       lmb_enforce_memory_limit(limit);
+       memblock_enforce_memory_limit(limit);
 
-       lmb_analyze();
-       lmb_dump_all();
+       memblock_analyze();
+       memblock_dump_all();
 
-       DBG("Phys. mem: %llx\n", lmb_phys_mem_size());
+       DBG("Phys. mem: %llx\n", memblock_phys_mem_size());
 
        /* We may need to relocate the flat tree, do it now.
         * FIXME .. and the initrd too? */
index 0e1ec6f746f653d568e4b00999ec4453c0e4bc5d..d0516dbee7621a2374f5d34131a74673d17e8a24 100644 (file)
@@ -22,7 +22,7 @@
 #include <linux/smp.h>
 #include <linux/completion.h>
 #include <linux/cpumask.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/slab.h>
 
 #include <asm/prom.h>
@@ -934,11 +934,11 @@ void __init rtas_initialize(void)
         */
 #ifdef CONFIG_PPC64
        if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR)) {
-               rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
+               rtas_region = min(memblock.rmo_size, RTAS_INSTANTIATE_MAX);
                ibm_suspend_me_token = rtas_token("ibm,suspend-me");
        }
 #endif
-       rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
+       rtas_rmo_buf = memblock_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
 
 #ifdef CONFIG_RTAS_ERROR_LOGGING
        rtas_last_error_token = rtas_token("rtas-last-error");
index 5e4d852f640c7f5c6535b9e420ae74da94e942cb..b7e6c7e193ae9141cc0aa6b1c7beb3394240c937 100644 (file)
@@ -33,7 +33,7 @@
 #include <linux/serial_8250.h>
 #include <linux/debugfs.h>
 #include <linux/percpu.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/of_platform.h>
 #include <asm/io.h>
 #include <asm/paca.h>
index 7d84b210f1680de8a41fb23d0ad09a7e19ce905b..a10ffc85ada77cfa802f371725a8d1b86bc7475b 100644 (file)
@@ -16,7 +16,7 @@
 #include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/console.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/io.h>
 #include <asm/prom.h>
@@ -246,12 +246,12 @@ static void __init irqstack_early_init(void)
        unsigned int i;
 
        /* interrupt stacks must be in lowmem, we get that for free on ppc32
-        * as the lmb is limited to lowmem by LMB_REAL_LIMIT */
+        * as the memblock is limited to lowmem by MEMBLOCK_REAL_LIMIT */
        for_each_possible_cpu(i) {
                softirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
                hardirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
        }
 }
 
@@ -261,15 +261,15 @@ static void __init exc_lvl_early_init(void)
        unsigned int i;
 
        /* interrupt stacks must be in lowmem, we get that for free on ppc32
-        * as the lmb is limited to lowmem by LMB_REAL_LIMIT */
+        * as the memblock is limited to lowmem by MEMBLOCK_REAL_LIMIT */
        for_each_possible_cpu(i) {
                critirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
 #ifdef CONFIG_BOOKE
                dbgirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
                mcheckirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
 #endif
        }
 }
index 643dcac40fcbc56c8cc3102a74e76a6aae4381eb..d135f93cb0f63b5d6f52350c4252a94b103f6018 100644 (file)
@@ -34,7 +34,7 @@
 #include <linux/bootmem.h>
 #include <linux/pci.h>
 #include <linux/lockdep.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <asm/io.h>
 #include <asm/kdump.h>
 #include <asm/prom.h>
@@ -158,7 +158,7 @@ static void __init setup_paca(struct paca_struct *new_paca)
  * the CPU that ignores the top 2 bits of the address in real
  * mode so we can access kernel globals normally provided we
  * only toy with things in the RMO region. From here, we do
- * some early parsing of the device-tree to setup out LMB
+ * some early parsing of the device-tree to setup out MEMBLOCK
  * data structures, and allocate & initialize the hash table
  * and segment tables so we can start running with translation
  * enabled.
@@ -404,7 +404,7 @@ void __init setup_system(void)
 
        printk("-----------------------------------------------------\n");
        printk("ppc64_pft_size                = 0x%llx\n", ppc64_pft_size);
-       printk("physicalMemorySize            = 0x%llx\n", lmb_phys_mem_size());
+       printk("physicalMemorySize            = 0x%llx\n", memblock_phys_mem_size());
        if (ppc64_caches.dline_size != 0x80)
                printk("ppc64_caches.dcache_line_size = 0x%x\n",
                       ppc64_caches.dline_size);
@@ -443,10 +443,10 @@ static void __init irqstack_early_init(void)
         */
        for_each_possible_cpu(i) {
                softirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc_base(THREAD_SIZE,
+                       __va(memblock_alloc_base(THREAD_SIZE,
                                            THREAD_SIZE, limit));
                hardirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc_base(THREAD_SIZE,
+                       __va(memblock_alloc_base(THREAD_SIZE,
                                            THREAD_SIZE, limit));
        }
 }
@@ -458,11 +458,11 @@ static void __init exc_lvl_early_init(void)
 
        for_each_possible_cpu(i) {
                critirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
                dbgirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
                mcheckirq_ctx[i] = (struct thread_info *)
-                       __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+                       __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
        }
 }
 #else
@@ -487,11 +487,11 @@ static void __init emergency_stack_init(void)
         * bringup, we need to get at them in real mode. This means they
         * must also be within the RMO region.
         */
-       limit = min(slb0_limit(), lmb.rmo_size);
+       limit = min(slb0_limit(), memblock.rmo_size);
 
        for_each_possible_cpu(i) {
                unsigned long sp;
-               sp  = lmb_alloc_base(THREAD_SIZE, THREAD_SIZE, limit);
+               sp  = memblock_alloc_base(THREAD_SIZE, THREAD_SIZE, limit);
                sp += THREAD_SIZE;
                paca[i].emergency_sp = __va(sp);
        }
index d84d19224a95d1338a11fd389ad47acfbfb7f248..13002fe206e7ce16ed79f5ad31e5aec58bc329cb 100644 (file)
@@ -22,7 +22,7 @@
 #include <linux/elf.h>
 #include <linux/security.h>
 #include <linux/bootmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/pgtable.h>
 #include <asm/system.h>
@@ -734,7 +734,7 @@ static int __init vdso_init(void)
        vdso_data->platform = machine_is(iseries) ? 0x200 : 0x100;
        if (firmware_has_feature(FW_FEATURE_LPAR))
                vdso_data->platform |= 1;
-       vdso_data->physicalMemorySize = lmb_phys_mem_size();
+       vdso_data->physicalMemorySize = memblock_phys_mem_size();
        vdso_data->dcache_size = ppc64_caches.dsize;
        vdso_data->dcache_line_size = ppc64_caches.dline_size;
        vdso_data->icache_size = ppc64_caches.isize;
index 65abfcfaaa9e72be187902357b3d29577fd06d28..1dc2fa5ce1bda72b05df8db2e4d249cfcc8642ab 100644 (file)
@@ -135,7 +135,7 @@ unsigned long __init mmu_mapin_ram(unsigned long top)
        /* If the size of RAM is not an exact power of two, we may not
         * have covered RAM in its entirety with 16 and 4 MiB
         * pages. Consequently, restrict the top end of RAM currently
-        * allocable so that calls to the LMB to allocate PTEs for "tail"
+        * allocable so that calls to the MEMBLOCK to allocate PTEs for "tail"
         * coverage with normal-sized pages (or other reasons) do not
         * attempt to allocate outside the allowed range.
         */
index 3ecdcec0a39e11403c792b66740c5a87648bb765..98f262de558526899fa5c58fe6802654bb0a5833 100644 (file)
@@ -31,7 +31,7 @@
 #include <linux/cache.h>
 #include <linux/init.h>
 #include <linux/signal.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/processor.h>
 #include <asm/pgtable.h>
@@ -384,8 +384,8 @@ static int __init htab_dt_scan_hugepage_blocks(unsigned long node,
        printk(KERN_INFO "Huge page(16GB) memory: "
                        "addr = 0x%lX size = 0x%lX pages = %d\n",
                        phys_addr, block_size, expected_pages);
-       if (phys_addr + (16 * GB) <= lmb_end_of_DRAM()) {
-               lmb_reserve(phys_addr, block_size * expected_pages);
+       if (phys_addr + (16 * GB) <= memblock_end_of_DRAM()) {
+               memblock_reserve(phys_addr, block_size * expected_pages);
                add_gpage(phys_addr, block_size, expected_pages);
        }
        return 0;
@@ -458,7 +458,7 @@ static void __init htab_init_page_sizes(void)
         * and we have at least 1G of RAM at boot
         */
        if (mmu_psize_defs[MMU_PAGE_16M].shift &&
-           lmb_phys_mem_size() >= 0x40000000)
+           memblock_phys_mem_size() >= 0x40000000)
                mmu_vmemmap_psize = MMU_PAGE_16M;
        else if (mmu_psize_defs[MMU_PAGE_64K].shift)
                mmu_vmemmap_psize = MMU_PAGE_64K;
@@ -520,7 +520,7 @@ static unsigned long __init htab_get_table_size(void)
                return 1UL << ppc64_pft_size;
 
        /* round mem_size up to next power of 2 */
-       mem_size = lmb_phys_mem_size();
+       mem_size = memblock_phys_mem_size();
        rnd_mem_size = 1UL << __ilog2(mem_size);
        if (rnd_mem_size < mem_size)
                rnd_mem_size <<= 1;
@@ -627,7 +627,7 @@ static void __init htab_initialize(void)
                else
                        limit = 0;
 
-               table = lmb_alloc_base(htab_size_bytes, htab_size_bytes, limit);
+               table = memblock_alloc_base(htab_size_bytes, htab_size_bytes, limit);
 
                DBG("Hash table allocated at %lx, size: %lx\n", table,
                    htab_size_bytes);
@@ -647,9 +647,9 @@ static void __init htab_initialize(void)
        prot = pgprot_val(PAGE_KERNEL);
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
-       linear_map_hash_count = lmb_end_of_DRAM() >> PAGE_SHIFT;
-       linear_map_hash_slots = __va(lmb_alloc_base(linear_map_hash_count,
-                                                   1, lmb.rmo_size));
+       linear_map_hash_count = memblock_end_of_DRAM() >> PAGE_SHIFT;
+       linear_map_hash_slots = __va(memblock_alloc_base(linear_map_hash_count,
+                                                   1, memblock.rmo_size));
        memset(linear_map_hash_slots, 0, linear_map_hash_count);
 #endif /* CONFIG_DEBUG_PAGEALLOC */
 
@@ -659,16 +659,16 @@ static void __init htab_initialize(void)
         */
 
        /* create bolted the linear mapping in the hash table */
-       for (i=0; i < lmb.memory.cnt; i++) {
-               base = (unsigned long)__va(lmb.memory.region[i].base);
-               size = lmb.memory.region[i].size;
+       for (i=0; i < memblock.memory.cnt; i++) {
+               base = (unsigned long)__va(memblock.memory.region[i].base);
+               size = memblock.memory.region[i].size;
 
                DBG("creating mapping for region: %lx..%lx (prot: %lx)\n",
                    base, size, prot);
 
 #ifdef CONFIG_U3_DART
                /* Do not map the DART space. Fortunately, it will be aligned
-                * in such a way that it will not cross two lmb regions and
+                * in such a way that it will not cross two memblock regions and
                 * will fit within a single 16Mb page.
                 * The DART space is assumed to be a full 16Mb region even if
                 * we only use 2Mb of that space. We will use more of it later
index 767333005eb46e1d1075dbfe6674d5ef7eca3fbe..6a6975dc265427bf39c15979374c52501755aa3c 100644 (file)
@@ -30,7 +30,7 @@
 #include <linux/highmem.h>
 #include <linux/initrd.h>
 #include <linux/pagemap.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/gfp.h>
 
 #include <asm/pgalloc.h>
@@ -136,17 +136,17 @@ void __init MMU_init(void)
        /* parse args from command line */
        MMU_setup();
 
-       if (lmb.memory.cnt > 1) {
+       if (memblock.memory.cnt > 1) {
 #ifndef CONFIG_WII
-               lmb.memory.cnt = 1;
-               lmb_analyze();
+               memblock.memory.cnt = 1;
+               memblock_analyze();
                printk(KERN_WARNING "Only using first contiguous memory region");
 #else
                wii_memory_fixups();
 #endif
        }
 
-       total_lowmem = total_memory = lmb_end_of_DRAM() - memstart_addr;
+       total_lowmem = total_memory = memblock_end_of_DRAM() - memstart_addr;
        lowmem_end_addr = memstart_addr + total_lowmem;
 
 #ifdef CONFIG_FSL_BOOKE
@@ -161,8 +161,8 @@ void __init MMU_init(void)
                lowmem_end_addr = memstart_addr + total_lowmem;
 #ifndef CONFIG_HIGHMEM
                total_memory = total_lowmem;
-               lmb_enforce_memory_limit(lowmem_end_addr);
-               lmb_analyze();
+               memblock_enforce_memory_limit(lowmem_end_addr);
+               memblock_analyze();
 #endif /* CONFIG_HIGHMEM */
        }
 
@@ -200,7 +200,7 @@ void __init *early_get_page(void)
        if (init_bootmem_done) {
                p = alloc_bootmem_pages(PAGE_SIZE);
        } else {
-               p = __va(lmb_alloc_base(PAGE_SIZE, PAGE_SIZE,
+               p = __va(memblock_alloc_base(PAGE_SIZE, PAGE_SIZE,
                                        __initial_memory_limit_addr));
        }
        return p;
index e267f223fdffbb42f83511bb8da6f878b3382821..71f1415e2472399049a2273eded9c4fb8d173265 100644 (file)
@@ -40,7 +40,7 @@
 #include <linux/nodemask.h>
 #include <linux/module.h>
 #include <linux/poison.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/hugetlb.h>
 #include <linux/slab.h>
 
index 0f594d774bf7c034975ab4f20bcdf7199981aba3..1a84a8d0000503b495ff2d79355f4f756e80591a 100644 (file)
@@ -32,7 +32,7 @@
 #include <linux/initrd.h>
 #include <linux/pagemap.h>
 #include <linux/suspend.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/hugetlb.h>
 
 #include <asm/pgalloc.h>
@@ -83,13 +83,13 @@ int page_is_ram(unsigned long pfn)
 #else
        unsigned long paddr = (pfn << PAGE_SHIFT);
        int i;
-       for (i=0; i < lmb.memory.cnt; i++) {
+       for (i=0; i < memblock.memory.cnt; i++) {
                unsigned long base;
 
-               base = lmb.memory.region[i].base;
+               base = memblock.memory.region[i].base;
 
                if ((paddr >= base) &&
-                       (paddr < (base + lmb.memory.region[i].size))) {
+                       (paddr < (base + memblock.memory.region[i].size))) {
                        return 1;
                }
        }
@@ -142,14 +142,14 @@ int arch_add_memory(int nid, u64 start, u64 size)
 /*
  * walk_memory_resource() needs to make sure there is no holes in a given
  * memory range.  PPC64 does not maintain the memory layout in /proc/iomem.
- * Instead it maintains it in lmb.memory structures.  Walk through the
+ * Instead it maintains it in memblock.memory structures.  Walk through the
  * memory regions, find holes and callback for contiguous regions.
  */
 int
 walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
                void *arg, int (*func)(unsigned long, unsigned long, void *))
 {
-       struct lmb_property res;
+       struct memblock_property res;
        unsigned long pfn, len;
        u64 end;
        int ret = -1;
@@ -158,7 +158,7 @@ walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
        res.size = (u64) nr_pages << PAGE_SHIFT;
 
        end = res.base + res.size - 1;
-       while ((res.base < end) && (lmb_find(&res) >= 0)) {
+       while ((res.base < end) && (memblock_find(&res) >= 0)) {
                pfn = (unsigned long)(res.base >> PAGE_SHIFT);
                len = (unsigned long)(res.size >> PAGE_SHIFT);
                ret = (*func)(pfn, len, arg);
@@ -184,8 +184,8 @@ void __init do_init_bootmem(void)
        unsigned long total_pages;
        int boot_mapsize;
 
-       max_low_pfn = max_pfn = lmb_end_of_DRAM() >> PAGE_SHIFT;
-       total_pages = (lmb_end_of_DRAM() - memstart_addr) >> PAGE_SHIFT;
+       max_low_pfn = max_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
+       total_pages = (memblock_end_of_DRAM() - memstart_addr) >> PAGE_SHIFT;
 #ifdef CONFIG_HIGHMEM
        total_pages = total_lowmem >> PAGE_SHIFT;
        max_low_pfn = lowmem_end_addr >> PAGE_SHIFT;
@@ -198,16 +198,16 @@ void __init do_init_bootmem(void)
         */
        bootmap_pages = bootmem_bootmap_pages(total_pages);
 
-       start = lmb_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE);
+       start = memblock_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE);
 
        min_low_pfn = MEMORY_START >> PAGE_SHIFT;
        boot_mapsize = init_bootmem_node(NODE_DATA(0), start >> PAGE_SHIFT, min_low_pfn, max_low_pfn);
 
        /* Add active regions with valid PFNs */
-       for (i = 0; i < lmb.memory.cnt; i++) {
+       for (i = 0; i < memblock.memory.cnt; i++) {
                unsigned long start_pfn, end_pfn;
-               start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
-               end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
+               start_pfn = memblock.memory.region[i].base >> PAGE_SHIFT;
+               end_pfn = start_pfn + memblock_size_pages(&memblock.memory, i);
                add_active_range(0, start_pfn, end_pfn);
        }
 
@@ -218,17 +218,17 @@ void __init do_init_bootmem(void)
        free_bootmem_with_active_regions(0, lowmem_end_addr >> PAGE_SHIFT);
 
        /* reserve the sections we're already using */
-       for (i = 0; i < lmb.reserved.cnt; i++) {
-               unsigned long addr = lmb.reserved.region[i].base +
-                                    lmb_size_bytes(&lmb.reserved, i) - 1;
+       for (i = 0; i < memblock.reserved.cnt; i++) {
+               unsigned long addr = memblock.reserved.region[i].base +
+                                    memblock_size_bytes(&memblock.reserved, i) - 1;
                if (addr < lowmem_end_addr)
-                       reserve_bootmem(lmb.reserved.region[i].base,
-                                       lmb_size_bytes(&lmb.reserved, i),
+                       reserve_bootmem(memblock.reserved.region[i].base,
+                                       memblock_size_bytes(&memblock.reserved, i),
                                        BOOTMEM_DEFAULT);
-               else if (lmb.reserved.region[i].base < lowmem_end_addr) {
+               else if (memblock.reserved.region[i].base < lowmem_end_addr) {
                        unsigned long adjusted_size = lowmem_end_addr -
-                                     lmb.reserved.region[i].base;
-                       reserve_bootmem(lmb.reserved.region[i].base,
+                                     memblock.reserved.region[i].base;
+                       reserve_bootmem(memblock.reserved.region[i].base,
                                        adjusted_size, BOOTMEM_DEFAULT);
                }
        }
@@ -236,9 +236,9 @@ void __init do_init_bootmem(void)
        free_bootmem_with_active_regions(0, max_pfn);
 
        /* reserve the sections we're already using */
-       for (i = 0; i < lmb.reserved.cnt; i++)
-               reserve_bootmem(lmb.reserved.region[i].base,
-                               lmb_size_bytes(&lmb.reserved, i),
+       for (i = 0; i < memblock.reserved.cnt; i++)
+               reserve_bootmem(memblock.reserved.region[i].base,
+                               memblock_size_bytes(&memblock.reserved, i),
                                BOOTMEM_DEFAULT);
 
 #endif
@@ -251,20 +251,20 @@ void __init do_init_bootmem(void)
 /* mark pages that don't exist as nosave */
 static int __init mark_nonram_nosave(void)
 {
-       unsigned long lmb_next_region_start_pfn,
-                     lmb_region_max_pfn;
+       unsigned long memblock_next_region_start_pfn,
+                     memblock_region_max_pfn;
        int i;
 
-       for (i = 0; i < lmb.memory.cnt - 1; i++) {
-               lmb_region_max_pfn =
-                       (lmb.memory.region[i].base >> PAGE_SHIFT) +
-                       (lmb.memory.region[i].size >> PAGE_SHIFT);
-               lmb_next_region_start_pfn =
-                       lmb.memory.region[i+1].base >> PAGE_SHIFT;
+       for (i = 0; i < memblock.memory.cnt - 1; i++) {
+               memblock_region_max_pfn =
+                       (memblock.memory.region[i].base >> PAGE_SHIFT) +
+                       (memblock.memory.region[i].size >> PAGE_SHIFT);
+               memblock_next_region_start_pfn =
+                       memblock.memory.region[i+1].base >> PAGE_SHIFT;
 
-               if (lmb_region_max_pfn < lmb_next_region_start_pfn)
-                       register_nosave_region(lmb_region_max_pfn,
-                                              lmb_next_region_start_pfn);
+               if (memblock_region_max_pfn < memblock_next_region_start_pfn)
+                       register_nosave_region(memblock_region_max_pfn,
+                                              memblock_next_region_start_pfn);
        }
 
        return 0;
@@ -275,8 +275,8 @@ static int __init mark_nonram_nosave(void)
  */
 void __init paging_init(void)
 {
-       unsigned long total_ram = lmb_phys_mem_size();
-       phys_addr_t top_of_ram = lmb_end_of_DRAM();
+       unsigned long total_ram = memblock_phys_mem_size();
+       phys_addr_t top_of_ram = memblock_end_of_DRAM();
        unsigned long max_zone_pfns[MAX_NR_ZONES];
 
 #ifdef CONFIG_PPC32
@@ -327,7 +327,7 @@ void __init mem_init(void)
                swiotlb_init(1);
 #endif
 
-       num_physpages = lmb.memory.size >> PAGE_SHIFT;
+       num_physpages = memblock.memory.size >> PAGE_SHIFT;
        high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
 
 #ifdef CONFIG_NEED_MULTIPLE_NODES
@@ -364,7 +364,7 @@ void __init mem_init(void)
                highmem_mapnr = lowmem_end_addr >> PAGE_SHIFT;
                for (pfn = highmem_mapnr; pfn < max_mapnr; ++pfn) {
                        struct page *page = pfn_to_page(pfn);
-                       if (lmb_is_reserved(pfn << PAGE_SHIFT))
+                       if (memblock_is_reserved(pfn << PAGE_SHIFT))
                                continue;
                        ClearPageReserved(page);
                        init_page_count(page);
index 80d110635d24a106d7c6f0ee204438abaf56025e..f47364585ecd0bce3df61a5397fa3f9d0ccf7feb 100644 (file)
@@ -17,7 +17,7 @@
 #include <linux/nodemask.h>
 #include <linux/cpu.h>
 #include <linux/notifier.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/of.h>
 #include <linux/pfn.h>
 #include <asm/sparsemem.h>
@@ -351,7 +351,7 @@ struct of_drconf_cell {
 #define DRCONF_MEM_RESERVED    0x00000080
 
 /*
- * Read the next lmb list entry from the ibm,dynamic-memory property
+ * Read the next memblock list entry from the ibm,dynamic-memory property
  * and return the information in the provided of_drconf_cell structure.
  */
 static void read_drconf_cell(struct of_drconf_cell *drmem, const u32 **cellp)
@@ -372,8 +372,8 @@ static void read_drconf_cell(struct of_drconf_cell *drmem, const u32 **cellp)
 /*
  * Retreive and validate the ibm,dynamic-memory property of the device tree.
  *
- * The layout of the ibm,dynamic-memory property is a number N of lmb
- * list entries followed by N lmb list entries.  Each lmb list entry
+ * The layout of the ibm,dynamic-memory property is a number N of memblock
+ * list entries followed by N memblock list entries.  Each memblock list entry
  * contains information as layed out in the of_drconf_cell struct above.
  */
 static int of_get_drconf_memory(struct device_node *memory, const u32 **dm)
@@ -398,15 +398,15 @@ static int of_get_drconf_memory(struct device_node *memory, const u32 **dm)
 }
 
 /*
- * Retreive and validate the ibm,lmb-size property for drconf memory
+ * Retreive and validate the ibm,memblock-size property for drconf memory
  * from the device tree.
  */
-static u64 of_get_lmb_size(struct device_node *memory)
+static u64 of_get_memblock_size(struct device_node *memory)
 {
        const u32 *prop;
        u32 len;
 
-       prop = of_get_property(memory, "ibm,lmb-size", &len);
+       prop = of_get_property(memory, "ibm,memblock-size", &len);
        if (!prop || len < sizeof(unsigned int))
                return 0;
 
@@ -540,19 +540,19 @@ static unsigned long __init numa_enforce_memory_limit(unsigned long start,
                                                      unsigned long size)
 {
        /*
-        * We use lmb_end_of_DRAM() in here instead of memory_limit because
+        * We use memblock_end_of_DRAM() in here instead of memory_limit because
         * we've already adjusted it for the limit and it takes care of
         * having memory holes below the limit.  Also, in the case of
         * iommu_is_off, memory_limit is not set but is implicitly enforced.
         */
 
-       if (start + size <= lmb_end_of_DRAM())
+       if (start + size <= memblock_end_of_DRAM())
                return size;
 
-       if (start >= lmb_end_of_DRAM())
+       if (start >= memblock_end_of_DRAM())
                return 0;
 
-       return lmb_end_of_DRAM() - start;
+       return memblock_end_of_DRAM() - start;
 }
 
 /*
@@ -562,7 +562,7 @@ static unsigned long __init numa_enforce_memory_limit(unsigned long start,
 static inline int __init read_usm_ranges(const u32 **usm)
 {
        /*
-        * For each lmb in ibm,dynamic-memory a corresponding
+        * For each memblock in ibm,dynamic-memory a corresponding
         * entry in linux,drconf-usable-memory property contains
         * a counter followed by that many (base, size) duple.
         * read the counter from linux,drconf-usable-memory
@@ -578,7 +578,7 @@ static void __init parse_drconf_memory(struct device_node *memory)
 {
        const u32 *dm, *usm;
        unsigned int n, rc, ranges, is_kexec_kdump = 0;
-       unsigned long lmb_size, base, size, sz;
+       unsigned long memblock_size, base, size, sz;
        int nid;
        struct assoc_arrays aa;
 
@@ -586,8 +586,8 @@ static void __init parse_drconf_memory(struct device_node *memory)
        if (!n)
                return;
 
-       lmb_size = of_get_lmb_size(memory);
-       if (!lmb_size)
+       memblock_size = of_get_memblock_size(memory);
+       if (!memblock_size)
                return;
 
        rc = of_get_assoc_arrays(memory, &aa);
@@ -611,7 +611,7 @@ static void __init parse_drconf_memory(struct device_node *memory)
                        continue;
 
                base = drmem.base_addr;
-               size = lmb_size;
+               size = memblock_size;
                ranges = 1;
 
                if (is_kexec_kdump) {
@@ -731,7 +731,7 @@ new_range:
        }
 
        /*
-        * Now do the same thing for each LMB listed in the ibm,dynamic-memory
+        * Now do the same thing for each MEMBLOCK listed in the ibm,dynamic-memory
         * property in the ibm,dynamic-reconfiguration-memory node.
         */
        memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
@@ -743,8 +743,8 @@ new_range:
 
 static void __init setup_nonnuma(void)
 {
-       unsigned long top_of_ram = lmb_end_of_DRAM();
-       unsigned long total_ram = lmb_phys_mem_size();
+       unsigned long top_of_ram = memblock_end_of_DRAM();
+       unsigned long total_ram = memblock_phys_mem_size();
        unsigned long start_pfn, end_pfn;
        unsigned int i, nid = 0;
 
@@ -753,9 +753,9 @@ static void __init setup_nonnuma(void)
        printk(KERN_DEBUG "Memory hole size: %ldMB\n",
               (top_of_ram - total_ram) >> 20);
 
-       for (i = 0; i < lmb.memory.cnt; ++i) {
-               start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
-               end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
+       for (i = 0; i < memblock.memory.cnt; ++i) {
+               start_pfn = memblock.memory.region[i].base >> PAGE_SHIFT;
+               end_pfn = start_pfn + memblock_size_pages(&memblock.memory, i);
 
                fake_numa_create_new_node(end_pfn, &nid);
                add_active_range(nid, start_pfn, end_pfn);
@@ -813,7 +813,7 @@ static void __init dump_numa_memory_topology(void)
 
                count = 0;
 
-               for (i = 0; i < lmb_end_of_DRAM();
+               for (i = 0; i < memblock_end_of_DRAM();
                     i += (1 << SECTION_SIZE_BITS)) {
                        if (early_pfn_to_nid(i >> PAGE_SHIFT) == node) {
                                if (count == 0)
@@ -833,7 +833,7 @@ static void __init dump_numa_memory_topology(void)
 }
 
 /*
- * Allocate some memory, satisfying the lmb or bootmem allocator where
+ * Allocate some memory, satisfying the memblock or bootmem allocator where
  * required. nid is the preferred node and end is the physical address of
  * the highest address in the node.
  *
@@ -847,11 +847,11 @@ static void __init *careful_zallocation(int nid, unsigned long size,
        int new_nid;
        unsigned long ret_paddr;
 
-       ret_paddr = __lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT);
+       ret_paddr = __memblock_alloc_base(size, align, end_pfn << PAGE_SHIFT);
 
        /* retry over all memory */
        if (!ret_paddr)
-               ret_paddr = __lmb_alloc_base(size, align, lmb_end_of_DRAM());
+               ret_paddr = __memblock_alloc_base(size, align, memblock_end_of_DRAM());
 
        if (!ret_paddr)
                panic("numa.c: cannot allocate %lu bytes for node %d",
@@ -861,14 +861,14 @@ static void __init *careful_zallocation(int nid, unsigned long size,
 
        /*
         * We initialize the nodes in numeric order: 0, 1, 2...
-        * and hand over control from the LMB allocator to the
+        * and hand over control from the MEMBLOCK allocator to the
         * bootmem allocator.  If this function is called for
         * node 5, then we know that all nodes <5 are using the
-        * bootmem allocator instead of the LMB allocator.
+        * bootmem allocator instead of the MEMBLOCK allocator.
         *
         * So, check the nid from which this allocation came
         * and double check to see if we need to use bootmem
-        * instead of the LMB.  We don't free the LMB memory
+        * instead of the MEMBLOCK.  We don't free the MEMBLOCK memory
         * since it would be useless.
         */
        new_nid = early_pfn_to_nid(ret_paddr >> PAGE_SHIFT);
@@ -893,9 +893,9 @@ static void mark_reserved_regions_for_nid(int nid)
        struct pglist_data *node = NODE_DATA(nid);
        int i;
 
-       for (i = 0; i < lmb.reserved.cnt; i++) {
-               unsigned long physbase = lmb.reserved.region[i].base;
-               unsigned long size = lmb.reserved.region[i].size;
+       for (i = 0; i < memblock.reserved.cnt; i++) {
+               unsigned long physbase = memblock.reserved.region[i].base;
+               unsigned long size = memblock.reserved.region[i].size;
                unsigned long start_pfn = physbase >> PAGE_SHIFT;
                unsigned long end_pfn = PFN_UP(physbase + size);
                struct node_active_region node_ar;
@@ -903,7 +903,7 @@ static void mark_reserved_regions_for_nid(int nid)
                                             node->node_spanned_pages;
 
                /*
-                * Check to make sure that this lmb.reserved area is
+                * Check to make sure that this memblock.reserved area is
                 * within the bounds of the node that we care about.
                 * Checking the nid of the start and end points is not
                 * sufficient because the reserved area could span the
@@ -961,7 +961,7 @@ void __init do_init_bootmem(void)
        int nid;
 
        min_low_pfn = 0;
-       max_low_pfn = lmb_end_of_DRAM() >> PAGE_SHIFT;
+       max_low_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
        max_pfn = max_low_pfn;
 
        if (parse_numa_properties())
@@ -1038,7 +1038,7 @@ void __init paging_init(void)
 {
        unsigned long max_zone_pfns[MAX_NR_ZONES];
        memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
-       max_zone_pfns[ZONE_DMA] = lmb_end_of_DRAM() >> PAGE_SHIFT;
+       max_zone_pfns[ZONE_DMA] = memblock_end_of_DRAM() >> PAGE_SHIFT;
        free_area_init_nodes(max_zone_pfns);
 }
 
@@ -1072,7 +1072,7 @@ static int hot_add_drconf_scn_to_nid(struct device_node *memory,
 {
        const u32 *dm;
        unsigned int drconf_cell_cnt, rc;
-       unsigned long lmb_size;
+       unsigned long memblock_size;
        struct assoc_arrays aa;
        int nid = -1;
 
@@ -1080,8 +1080,8 @@ static int hot_add_drconf_scn_to_nid(struct device_node *memory,
        if (!drconf_cell_cnt)
                return -1;
 
-       lmb_size = of_get_lmb_size(memory);
-       if (!lmb_size)
+       memblock_size = of_get_memblock_size(memory);
+       if (!memblock_size)
                return -1;
 
        rc = of_get_assoc_arrays(memory, &aa);
@@ -1100,7 +1100,7 @@ static int hot_add_drconf_scn_to_nid(struct device_node *memory,
                        continue;
 
                if ((scn_addr < drmem.base_addr)
-                   || (scn_addr >= (drmem.base_addr + lmb_size)))
+                   || (scn_addr >= (drmem.base_addr + memblock_size)))
                        continue;
 
                nid = of_drconf_to_nid_single(&drmem, &aa);
@@ -1113,7 +1113,7 @@ static int hot_add_drconf_scn_to_nid(struct device_node *memory,
 /*
  * Find the node associated with a hot added memory section for memory
  * represented in the device tree as a node (i.e. memory@XXXX) for
- * each lmb.
+ * each memblock.
  */
 int hot_add_node_scn_to_nid(unsigned long scn_addr)
 {
@@ -1154,8 +1154,8 @@ int hot_add_node_scn_to_nid(unsigned long scn_addr)
 
 /*
  * Find the node associated with a hot added memory section.  Section
- * corresponds to a SPARSEMEM section, not an LMB.  It is assumed that
- * sections are fully contained within a single LMB.
+ * corresponds to a SPARSEMEM section, not an MEMBLOCK.  It is assumed that
+ * sections are fully contained within a single MEMBLOCK.
  */
 int hot_add_scn_to_nid(unsigned long scn_addr)
 {
index 34347b2e7e313995c803d34c847034dff7a9c1cf..a87ead0138b45b3203128b81718be17c4a7158bf 100644 (file)
@@ -26,7 +26,7 @@
 #include <linux/vmalloc.h>
 #include <linux/init.h>
 #include <linux/highmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/slab.h>
 
 #include <asm/pgtable.h>
@@ -198,7 +198,7 @@ __ioremap_caller(phys_addr_t addr, unsigned long size, unsigned long flags,
         * mem_init() sets high_memory so only do the check after that.
         */
        if (mem_init_done && (p < virt_to_phys(high_memory)) &&
-           !(__allow_ioremap_reserved && lmb_is_region_reserved(p, size))) {
+           !(__allow_ioremap_reserved && memblock_is_region_reserved(p, size))) {
                printk("__ioremap(): phys addr 0x%llx is RAM lr %p\n",
                       (unsigned long long)p, __builtin_return_address(0));
                return NULL;
@@ -331,7 +331,7 @@ void __init mapin_ram(void)
                s = mmu_mapin_ram(top);
                __mapin_ram_chunk(s, top);
 
-               top = lmb_end_of_DRAM();
+               top = memblock_end_of_DRAM();
                s = wii_mmu_mapin_mem2(top);
                __mapin_ram_chunk(s, top);
        }
index d050fc8d9714830ce3cea027465f794864a8a830..21d6dfab7942f73e345a22c418ec4a5ee526edc6 100644 (file)
@@ -34,7 +34,7 @@
 #include <linux/vmalloc.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/slab.h>
 
 #include <asm/pgalloc.h>
@@ -67,7 +67,7 @@ static void *early_alloc_pgtable(unsigned long size)
        if (init_bootmem_done)
                pt = __alloc_bootmem(size, size, __pa(MAX_DMA_ADDRESS));
        else
-               pt = __va(lmb_alloc_base(size, size,
+               pt = __va(memblock_alloc_base(size, size,
                                         __pa(MAX_DMA_ADDRESS)));
        memset(pt, 0, size);
 
index f11c2cdcb0fedd9a1afb89222ed4e6f6a9037116..f8a01829d64fd4820921f3148a17c32b98e74b67 100644 (file)
@@ -26,7 +26,7 @@
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/highmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/prom.h>
 #include <asm/mmu.h>
@@ -223,7 +223,7 @@ void __init MMU_init_hw(void)
         * Find some memory for the hash table.
         */
        if ( ppc_md.progress ) ppc_md.progress("hash:find piece", 0x322);
-       Hash = __va(lmb_alloc_base(Hash_size, Hash_size,
+       Hash = __va(memblock_alloc_base(Hash_size, Hash_size,
                                   __initial_memory_limit_addr));
        cacheable_memzero(Hash, Hash_size);
        _SDR1 = __pa(Hash) | SDR1_LOW_BITS;
index 687fddaa24c564fb19491b146525ba2ffc58ac67..446a01842a73eff71046e558bd71ea37677ce254 100644 (file)
@@ -12,7 +12,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/pgtable.h>
 #include <asm/mmu.h>
@@ -252,7 +252,7 @@ void __init stabs_alloc(void)
                if (cpu == 0)
                        continue; /* stab for CPU 0 is statically allocated */
 
-               newstab = lmb_alloc_base(HW_PAGE_SIZE, HW_PAGE_SIZE,
+               newstab = memblock_alloc_base(HW_PAGE_SIZE, HW_PAGE_SIZE,
                                         1<<SID_SHIFT);
                newstab = (unsigned long)__va(newstab);
 
index e81d5d67f834021c9304e9c35ab2030864a027a9..d8695b02a96895fbad4c002224d0e4c25c316aa0 100644 (file)
@@ -34,7 +34,7 @@
 #include <linux/pagemap.h>
 #include <linux/preempt.h>
 #include <linux/spinlock.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/tlbflush.h>
 #include <asm/tlb.h>
@@ -426,7 +426,7 @@ static void __early_init_mmu(int boot_cpu)
        /* Set the global containing the top of the linear mapping
         * for use by the TLB miss code
         */
-       linear_map_top = lmb_end_of_DRAM();
+       linear_map_top = memblock_end_of_DRAM();
 
        /* A sync won't hurt us after mucking around with
         * the MMU configuration
index 534c2ecc89d904dfeff5448009f24405624522d4..2ab338c9ac37fb7cfdd6ba4554877e17ec0552c5 100644 (file)
@@ -16,7 +16,7 @@
 #include <linux/kdev_t.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/system.h>
 #include <asm/time.h>
@@ -100,7 +100,7 @@ void __init corenet_ds_setup_arch(void)
 #endif
 
 #ifdef CONFIG_SWIOTLB
-       if (lmb_end_of_DRAM() > max) {
+       if (memblock_end_of_DRAM() > max) {
                ppc_swiotlb_enable = 1;
                set_pci_dma_ops(&swiotlb_dma_ops);
                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
index 004b7d36cdb7512e33b8b774b25057d0b6230e2c..f79f2f1021416c5a4e1f6a97ebe4cab9ff02d57b 100644 (file)
@@ -17,7 +17,7 @@
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
 #include <linux/of_platform.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/system.h>
 #include <asm/time.h>
@@ -94,7 +94,7 @@ static void __init mpc8536_ds_setup_arch(void)
 #endif
 
 #ifdef CONFIG_SWIOTLB
-       if (lmb_end_of_DRAM() > max) {
+       if (memblock_end_of_DRAM() > max) {
                ppc_swiotlb_enable = 1;
                set_pci_dma_ops(&swiotlb_dma_ops);
                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
index 544011a562fb283c64b864b295fe17ff046d4f40..8190bc25bf27327e762e798e0902cf83c20c3c8d 100644 (file)
@@ -20,7 +20,7 @@
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
 #include <linux/of_platform.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/system.h>
 #include <asm/time.h>
@@ -190,7 +190,7 @@ static void __init mpc85xx_ds_setup_arch(void)
 #endif
 
 #ifdef CONFIG_SWIOTLB
-       if (lmb_end_of_DRAM() > max) {
+       if (memblock_end_of_DRAM() > max) {
                ppc_swiotlb_enable = 1;
                set_pci_dma_ops(&swiotlb_dma_ops);
                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
index 8fe87fc61485bdc1c48c4bf430ed626933ce8b22..494513682d708d3356ea376339be8bf577f2333a 100644 (file)
@@ -33,7 +33,7 @@
 #include <linux/of_platform.h>
 #include <linux/of_device.h>
 #include <linux/phy.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/system.h>
 #include <asm/atomic.h>
@@ -325,7 +325,7 @@ static void __init mpc85xx_mds_setup_arch(void)
 #endif /* CONFIG_QUICC_ENGINE */
 
 #ifdef CONFIG_SWIOTLB
-       if (lmb_end_of_DRAM() > max) {
+       if (memblock_end_of_DRAM() > max) {
                ppc_swiotlb_enable = 1;
                set_pci_dma_ops(&swiotlb_dma_ops);
                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
index 2aa69a69bcc8b3147e7c16b82b5a74ea35777316..b11c3535f3509cac28e2baf7fd5e999001ab0709 100644 (file)
@@ -19,7 +19,7 @@
 #include <linux/delay.h>
 #include <linux/seq_file.h>
 #include <linux/of_platform.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/system.h>
 #include <asm/time.h>
@@ -103,7 +103,7 @@ mpc86xx_hpcn_setup_arch(void)
 #endif
 
 #ifdef CONFIG_SWIOTLB
-       if (lmb_end_of_DRAM() > max) {
+       if (memblock_end_of_DRAM() > max) {
                ppc_swiotlb_enable = 1;
                set_pci_dma_ops(&swiotlb_dma_ops);
                ppc_md.pci_dma_dev_setup = pci_dma_dev_setup_swiotlb;
index 4326b737d913e02d4541320c5bb3cecc45f7220b..3712900471ba2e9033419ab31d620ab8d2a983b2 100644 (file)
@@ -29,7 +29,7 @@
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/slab.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/prom.h>
 #include <asm/iommu.h>
@@ -845,10 +845,10 @@ static int __init cell_iommu_init_disabled(void)
        /* If we found a DMA window, we check if it's big enough to enclose
         * all of physical memory. If not, we force enable IOMMU
         */
-       if (np && size < lmb_end_of_DRAM()) {
+       if (np && size < memblock_end_of_DRAM()) {
                printk(KERN_WARNING "iommu: force-enabled, dma window"
                       " (%ldMB) smaller than total memory (%lldMB)\n",
-                      size >> 20, lmb_end_of_DRAM() >> 20);
+                      size >> 20, memblock_end_of_DRAM() >> 20);
                return -ENODEV;
        }
 
@@ -1064,7 +1064,7 @@ static int __init cell_iommu_fixed_mapping_init(void)
        }
 
        fbase = _ALIGN_UP(fbase, 1 << IO_SEGMENT_SHIFT);
-       fsize = lmb_phys_mem_size();
+       fsize = memblock_phys_mem_size();
 
        if ((fbase + fsize) <= 0x800000000ul)
                hbase = 0; /* use the device tree window */
@@ -1169,7 +1169,7 @@ static int __init cell_iommu_init(void)
         * Note: should we make sure we have the IOMMU actually disabled ?
         */
        if (iommu_is_off ||
-           (!iommu_force_on && lmb_end_of_DRAM() <= 0x80000000ull))
+           (!iommu_force_on && memblock_end_of_DRAM() <= 0x80000000ull))
                if (cell_iommu_init_disabled() == 0)
                        goto bail;
 
index 174a04ac4806e714e49e8895f0f4180363d838b7..5cdcc7c8d9738416a8055840235ca5954d33abd2 100644 (file)
@@ -20,7 +20,7 @@
 #include <linux/seq_file.h>
 #include <linux/kexec.h>
 #include <linux/of_platform.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <mm/mmu_decl.h>
 
 #include <asm/io.h>
@@ -65,7 +65,7 @@ static int __init page_aligned(unsigned long x)
 
 void __init wii_memory_fixups(void)
 {
-       struct lmb_property *p = lmb.memory.region;
+       struct memblock_property *p = memblock.memory.region;
 
        /*
         * This is part of a workaround to allow the use of two
@@ -77,7 +77,7 @@ void __init wii_memory_fixups(void)
         * between both ranges.
         */
 
-       BUG_ON(lmb.memory.cnt != 2);
+       BUG_ON(memblock.memory.cnt != 2);
        BUG_ON(!page_aligned(p[0].base) || !page_aligned(p[1].base));
 
        p[0].size = _ALIGN_DOWN(p[0].size, PAGE_SIZE);
@@ -92,11 +92,11 @@ void __init wii_memory_fixups(void)
 
        p[0].size += wii_hole_size + p[1].size;
 
-       lmb.memory.cnt = 1;
-       lmb_analyze();
+       memblock.memory.cnt = 1;
+       memblock_analyze();
 
        /* reserve the hole */
-       lmb_reserve(wii_hole_start, wii_hole_size);
+       memblock_reserve(wii_hole_start, wii_hole_size);
 
        /* allow ioremapping the address space in the hole */
        __allow_ioremap_reserved = 1;
index 39df70529d292d594a0f52fad57b5e19425a78c9..3fff8d979b41a809743ca28e4234fcaa28e81400 100644 (file)
@@ -41,7 +41,7 @@
 #include <linux/smp.h>
 #include <linux/bitops.h>
 #include <linux/of_device.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/processor.h>
 #include <asm/sections.h>
index 7b1d608ea3c828c5fe195e77a2e1aa2f8a70e1e2..1f9fb2c577613c64335f4c61b348efc6701de3a2 100644 (file)
@@ -204,7 +204,7 @@ int __init iob_init(struct device_node *dn)
        pr_debug(" -> %s\n", __func__);
 
        /* Allocate a spare page to map all invalid IOTLB pages. */
-       tmp = lmb_alloc(IOBMAP_PAGE_SIZE, IOBMAP_PAGE_SIZE);
+       tmp = memblock_alloc(IOBMAP_PAGE_SIZE, IOBMAP_PAGE_SIZE);
        if (!tmp)
                panic("IOBMAP: Cannot allocate spare page!");
        /* Empty l1 is marked invalid */
@@ -275,7 +275,7 @@ void __init alloc_iobmap_l2(void)
        return;
 #endif
        /* For 2G space, 8x64 pages (2^21 bytes) is max total l2 size */
-       iob_l2_base = (u32 *)abs_to_virt(lmb_alloc_base(1UL<<21, 1UL<<21, 0x80000000));
+       iob_l2_base = (u32 *)abs_to_virt(memblock_alloc_base(1UL<<21, 1UL<<21, 0x80000000));
 
        printk(KERN_INFO "IOBMAP L2 allocated at: %p\n", iob_l2_base);
 }
index f1d0132ebcc770f0d7fe8e05ebe08ff5b22e449d..9deb274841f1198d52eb6b2cc4029a374cd1c7fc 100644 (file)
@@ -51,7 +51,7 @@
 #include <linux/suspend.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/reg.h>
 #include <asm/sections.h>
@@ -619,7 +619,7 @@ static int __init pmac_probe(void)
         * driver needs that. We have to allocate it now. We allocate 4k
         * (1 small page) for now.
         */
-       smu_cmdbuf_abs = lmb_alloc_base(4096, 4096, 0x80000000UL);
+       smu_cmdbuf_abs = memblock_alloc_base(4096, 4096, 0x80000000UL);
 #endif /* CONFIG_PMAC_SMU */
 
        return 1;
index 1e8a1e39dfe816abc4e97cd1c33f12463edaf267..2c0ed87f20244c88e4feea8c79aca1a29c4115a0 100644 (file)
@@ -19,7 +19,7 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 
 #include <asm/machdep.h>
 #include <asm/prom.h>
index 7925751e464acd2941ce5dce7caa037fc210a755..c2045880e674afc91a5295711042f4722c6aa510 100644 (file)
@@ -21,7 +21,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/memory_hotplug.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/slab.h>
 
 #include <asm/cell-regs.h>
@@ -318,8 +318,8 @@ static int __init ps3_mm_add_memory(void)
                return result;
        }
 
-       lmb_add(start_addr, map.r1.size);
-       lmb_analyze();
+       memblock_add(start_addr, map.r1.size);
+       memblock_analyze();
 
        result = online_pages(start_pfn, nr_pages);
 
index dd521a181f23bdb5237607e65fabbe7df6d2988a..5b759b66959833d60d1fe0f3cc524d0a3b023e2a 100644 (file)
@@ -24,7 +24,7 @@
 #include <linux/fs.h>
 #include <linux/syscalls.h>
 #include <linux/ctype.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/of.h>
 #include <linux/slab.h>
 
@@ -723,7 +723,7 @@ static void os_area_queue_work(void)
  * flash to a high address in the boot memory region and then puts that RAM
  * address and the byte count into the repository for retrieval by the guest.
  * We copy the data we want into a static variable and allow the memory setup
- * by the HV to be claimed by the lmb manager.
+ * by the HV to be claimed by the memblock manager.
  *
  * The os area mirror will not be available to a second stage kernel, and
  * the header verify will fail.  In this case, the saved_params values will
index 01e7b5bb3c1d3853469694bf00235555108321f6..deab5f9460907891a3134a1d7f6bcdb459796dcf 100644 (file)
  */
 
 #include <linux/of.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/vmalloc.h>
 #include <asm/firmware.h>
 #include <asm/machdep.h>
 #include <asm/pSeries_reconfig.h>
 #include <asm/sparsemem.h>
 
-static int pseries_remove_lmb(unsigned long base, unsigned int lmb_size)
+static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size)
 {
        unsigned long start, start_pfn;
        struct zone *zone;
@@ -26,7 +26,7 @@ static int pseries_remove_lmb(unsigned long base, unsigned int lmb_size)
        start_pfn = base >> PAGE_SHIFT;
 
        if (!pfn_valid(start_pfn)) {
-               lmb_remove(base, lmb_size);
+               memblock_remove(base, memblock_size);
                return 0;
        }
 
@@ -41,20 +41,20 @@ static int pseries_remove_lmb(unsigned long base, unsigned int lmb_size)
         * to sysfs "state" file and we can't remove sysfs entries
         * while writing to it. So we have to defer it to here.
         */
-       ret = __remove_pages(zone, start_pfn, lmb_size >> PAGE_SHIFT);
+       ret = __remove_pages(zone, start_pfn, memblock_size >> PAGE_SHIFT);
        if (ret)
                return ret;
 
        /*
         * Update memory regions for memory remove
         */
-       lmb_remove(base, lmb_size);
+       memblock_remove(base, memblock_size);
 
        /*
         * Remove htab bolted mappings for this section of memory
         */
        start = (unsigned long)__va(base);
-       ret = remove_section_mapping(start, start + lmb_size);
+       ret = remove_section_mapping(start, start + memblock_size);
 
        /* Ensure all vmalloc mappings are flushed in case they also
         * hit that section of memory
@@ -69,7 +69,7 @@ static int pseries_remove_memory(struct device_node *np)
        const char *type;
        const unsigned int *regs;
        unsigned long base;
-       unsigned int lmb_size;
+       unsigned int memblock_size;
        int ret = -EINVAL;
 
        /*
@@ -80,16 +80,16 @@ static int pseries_remove_memory(struct device_node *np)
                return 0;
 
        /*
-        * Find the bae address and size of the lmb
+        * Find the bae address and size of the memblock
         */
        regs = of_get_property(np, "reg", NULL);
        if (!regs)
                return ret;
 
        base = *(unsigned long *)regs;
-       lmb_size = regs[3];
+       memblock_size = regs[3];
 
-       ret = pseries_remove_lmb(base, lmb_size);
+       ret = pseries_remove_memblock(base, memblock_size);
        return ret;
 }
 
@@ -98,7 +98,7 @@ static int pseries_add_memory(struct device_node *np)
        const char *type;
        const unsigned int *regs;
        unsigned long base;
-       unsigned int lmb_size;
+       unsigned int memblock_size;
        int ret = -EINVAL;
 
        /*
@@ -109,43 +109,43 @@ static int pseries_add_memory(struct device_node *np)
                return 0;
 
        /*
-        * Find the base and size of the lmb
+        * Find the base and size of the memblock
         */
        regs = of_get_property(np, "reg", NULL);
        if (!regs)
                return ret;
 
        base = *(unsigned long *)regs;
-       lmb_size = regs[3];
+       memblock_size = regs[3];
 
        /*
         * Update memory region to represent the memory add
         */
-       ret = lmb_add(base, lmb_size);
+       ret = memblock_add(base, memblock_size);
        return (ret < 0) ? -EINVAL : 0;
 }
 
 static int pseries_drconf_memory(unsigned long *base, unsigned int action)
 {
        struct device_node *np;
-       const unsigned long *lmb_size;
+       const unsigned long *memblock_size;
        int rc;
 
        np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
        if (!np)
                return -EINVAL;
 
-       lmb_size = of_get_property(np, "ibm,lmb-size", NULL);
-       if (!lmb_size) {
+       memblock_size = of_get_property(np, "ibm,memblock-size", NULL);
+       if (!memblock_size) {
                of_node_put(np);
                return -EINVAL;
        }
 
        if (action == PSERIES_DRCONF_MEM_ADD) {
-               rc = lmb_add(*base, *lmb_size);
+               rc = memblock_add(*base, *memblock_size);
                rc = (rc < 0) ? -EINVAL : 0;
        } else if (action == PSERIES_DRCONF_MEM_REMOVE) {
-               rc = pseries_remove_lmb(*base, *lmb_size);
+               rc = pseries_remove_memblock(*base, *memblock_size);
        } else {
                rc = -EINVAL;
        }
index d26182d42cbfb5a712fb6803dfdf056f560e0c33..395848e30c523b36f7b31bbd258610777e87b4dd 100644 (file)
@@ -66,7 +66,7 @@ static int tce_build_pSeries(struct iommu_table *tbl, long index,
        tcep = ((u64 *)tbl->it_base) + index;
 
        while (npages--) {
-               /* can't move this out since we might cross LMB boundary */
+               /* can't move this out since we might cross MEMBLOCK boundary */
                rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
                *tcep = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
 
index 7ebd9e88d369c242b63dd48b0bd7a02a95f94449..6e7742da0072a521be908d6ded562a3af89b2db0 100644 (file)
@@ -255,12 +255,12 @@ void invalidate_last_dump(struct phyp_dump_header *ph, unsigned long addr)
 
 /* ------------------------------------------------- */
 /**
- * release_memory_range -- release memory previously lmb_reserved
+ * release_memory_range -- release memory previously memblock_reserved
  * @start_pfn: starting physical frame number
  * @nr_pages: number of pages to free.
  *
  * This routine will release memory that had been previously
- * lmb_reserved in early boot. The released memory becomes
+ * memblock_reserved in early boot. The released memory becomes
  * available for genreal use.
  */
 static void release_memory_range(unsigned long start_pfn,
index c8b96ed7c0158a81137777b050fbfd745d2dab0a..559db2b846a9dcd4428d4feb0467ff14bdd4cdbc 100644 (file)
@@ -36,7 +36,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/vmalloc.h>
 #include <linux/suspend.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/gfp.h>
 #include <asm/io.h>
 #include <asm/prom.h>
@@ -232,7 +232,7 @@ static int __init dart_init(struct device_node *dart_node)
         * that to work around what looks like a problem with the HT bridge
         * prefetching into invalid pages and corrupting data
         */
-       tmp = lmb_alloc(DART_PAGE_SIZE, DART_PAGE_SIZE);
+       tmp = memblock_alloc(DART_PAGE_SIZE, DART_PAGE_SIZE);
        dart_emptyval = DARTMAP_VALID | ((tmp >> DART_PAGE_SHIFT) &
                                         DARTMAP_RPNMASK);
 
@@ -407,7 +407,7 @@ void __init alloc_dart_table(void)
        if (iommu_is_off)
                return;
 
-       if (!iommu_force_on && lmb_end_of_DRAM() <= 0x40000000ull)
+       if (!iommu_force_on && memblock_end_of_DRAM() <= 0x40000000ull)
                return;
 
        /* 512 pages (2MB) is max DART tablesize. */
@@ -416,7 +416,7 @@ void __init alloc_dart_table(void)
         * will blow up an entire large page anyway in the kernel mapping
         */
        dart_tablebase = (unsigned long)
-               abs_to_virt(lmb_alloc_base(1UL<<24, 1UL<<24, 0x80000000L));
+               abs_to_virt(memblock_alloc_base(1UL<<24, 1UL<<24, 0x80000000L));
 
        printk(KERN_INFO "DART table allocated at: %lx\n", dart_tablebase);
 }
index a14760fe513a6bc7d5bcbc9780470b1b64e84516..356c6a0e1b2367768e17354f57b6369b604e32bb 100644 (file)
@@ -23,7 +23,7 @@
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/log2.h>
 #include <linux/slab.h>
 
@@ -190,7 +190,7 @@ static void __init setup_pci_atmu(struct pci_controller *hose,
        pr_info("%s: PCICSRBAR @ 0x%x\n", name, pcicsrbar);
 
        /* Setup inbound mem window */
-       mem = lmb_end_of_DRAM();
+       mem = memblock_end_of_DRAM();
        sz = min(mem, paddr_lo);
        mem_log = __ilog2_u64(sz);
 
index d8d602840757cad9301fd5a2a38f2ed7ee6dec6b..c0bb76ef724206061551938dbddd1749b89fa814 100644 (file)
@@ -4,6 +4,7 @@
  * also relocates SMC2, but this would require additional changes
  * to uart.c, so I am holding off on that for a moment.
  */
+#include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
@@ -16,6 +17,7 @@
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/8xx_immap.h>
+#include <asm/cpm.h>
 #include <asm/cpm1.h>
 
 /*
@@ -24,7 +26,7 @@
 
 #ifdef CONFIG_I2C_SPI_UCODE_PATCH
 
-uint patch_2000[] = {
+static uint patch_2000[] __initdata = {
        0x7FFFEFD9,
        0x3FFD0000,
        0x7FFB49F7,
@@ -143,7 +145,7 @@ uint patch_2000[] = {
        0x5F8247F8
 };
 
-uint patch_2f00[] = {
+static uint patch_2f00[] __initdata = {
        0x3E303430,
        0x34343737,
        0xABF7BF9B,
@@ -182,7 +184,7 @@ uint patch_2f00[] = {
 
 #ifdef CONFIG_I2C_SPI_SMC1_UCODE_PATCH
 
-uint patch_2000[] = {
+static uint patch_2000[] __initdata = {
        0x3fff0000,
        0x3ffd0000,
        0x3ffb0000,
@@ -505,7 +507,7 @@ uint patch_2000[] = {
        0x6079e2bb
 };
 
-uint patch_2f00[] = {
+static uint patch_2f00[] __initdata = {
        0x30303030,
        0x3e3e3434,
        0xabbf9b99,
@@ -572,7 +574,7 @@ uint patch_2f00[] = {
        0xf22f3f23
 };
 
-uint patch_2e00[] = {
+static uint patch_2e00[] __initdata = {
        0x27eeeeee,
        0xeeeeeeee,
        0xeeeeeeee,
@@ -598,7 +600,7 @@ uint patch_2e00[] = {
 
 #ifdef CONFIG_USB_SOF_UCODE_PATCH
 
-uint patch_2000[] = {
+static uint patch_2000[] __initdata = {
        0x7fff0000,
        0x7ffd0000,
        0x7ffb0000,
@@ -613,21 +615,25 @@ uint patch_2000[] = {
        0x60750000
 };
 
-uint patch_2f00[] = {
+static uint patch_2f00[] __initdata = {
        0x3030304c,
        0xcab9e441,
        0xa1aaf220
 };
 #endif
 
-void
-cpm_load_patch(cpm8xx_t        *cp)
+void __init cpm_load_patch(cpm8xx_t *cp)
 {
        volatile uint           *dp;            /* Dual-ported RAM. */
        volatile cpm8xx_t       *commproc;
+#if defined(CONFIG_I2C_SPI_UCODE_PATCH) || \
+    defined(CONFIG_I2C_SPI_SMC1_UCODE_PATCH)
        volatile iic_t          *iip;
-       volatile spi_t          *spp;
+       volatile struct spi_pram *spp;
+#ifdef CONFIG_I2C_SPI_SMC1_UCODE_PATCH
        volatile smc_uart_t     *smp;
+#endif
+#endif
        int     i;
 
        commproc = cp;
@@ -668,8 +674,8 @@ cpm_load_patch(cpm8xx_t     *cp)
        /* Put SPI above the IIC, also 32-byte aligned.
        */
        i = (RPBASE + sizeof(iic_t) + 31) & ~31;
-       spp = (spi_t *)&commproc->cp_dparam[PROFF_SPI];
-       spp->spi_rpbase = i;
+       spp = (struct spi_pram *)&commproc->cp_dparam[PROFF_SPI];
+       spp->rpbase = i;
 
 # if defined(CONFIG_I2C_SPI_UCODE_PATCH)
        commproc->cp_cpmcr1 = 0x802a;
index 573fca1fbd9b699d7beff90a4d162af8a01652cd..82868fee21fdbed9f670edde147032253f82f459 100644 (file)
@@ -10,7 +10,7 @@ config SUPERH
        select EMBEDDED
        select HAVE_CLK
        select HAVE_IDE if HAS_IOPORT
-       select HAVE_LMB
+       select HAVE_MEMBLOCK
        select HAVE_OPROFILE
        select HAVE_GENERIC_DMA_COHERENT
        select HAVE_ARCH_TRACEHOOK
diff --git a/arch/sh/include/asm/lmb.h b/arch/sh/include/asm/lmb.h
deleted file mode 100644 (file)
index 9b437f6..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef __ASM_SH_LMB_H
-#define __ASM_SH_LMB_H
-
-#define LMB_REAL_LIMIT 0
-
-#endif /* __ASM_SH_LMB_H */
diff --git a/arch/sh/include/asm/memblock.h b/arch/sh/include/asm/memblock.h
new file mode 100644 (file)
index 0000000..dfe683b
--- /dev/null
@@ -0,0 +1,6 @@
+#ifndef __ASM_SH_MEMBLOCK_H
+#define __ASM_SH_MEMBLOCK_H
+
+#define MEMBLOCK_REAL_LIMIT    0
+
+#endif /* __ASM_SH_MEMBLOCK_H */
index 5a559e666eb352ec2da5418a5fcbd969babbf6a1..e2a3af31ff9930b534c5b1ee7e5bce9721905ba1 100644 (file)
@@ -15,7 +15,7 @@
 #include <linux/numa.h>
 #include <linux/ftrace.h>
 #include <linux/suspend.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/mmu_context.h>
@@ -157,10 +157,10 @@ void __init reserve_crashkernel(void)
        unsigned long long crash_size, crash_base;
        int ret;
 
-       /* this is necessary because of lmb_phys_mem_size() */
-       lmb_analyze();
+       /* this is necessary because of memblock_phys_mem_size() */
+       memblock_analyze();
 
-       ret = parse_crashkernel(boot_command_line, lmb_phys_mem_size(),
+       ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(),
                        &crash_size, &crash_base);
        if (ret == 0 && crash_size > 0) {
                crashk_res.start = crash_base;
@@ -172,14 +172,14 @@ void __init reserve_crashkernel(void)
 
        crash_size = PAGE_ALIGN(crashk_res.end - crashk_res.start + 1);
        if (!crashk_res.start) {
-               unsigned long max = lmb_end_of_DRAM() - memory_limit;
-               crashk_res.start = __lmb_alloc_base(crash_size, PAGE_SIZE, max);
+               unsigned long max = memblock_end_of_DRAM() - memory_limit;
+               crashk_res.start = __memblock_alloc_base(crash_size, PAGE_SIZE, max);
                if (!crashk_res.start) {
                        pr_err("crashkernel allocation failed\n");
                        goto disable;
                }
        } else {
-               ret = lmb_reserve(crashk_res.start, crash_size);
+               ret = memblock_reserve(crashk_res.start, crash_size);
                if (unlikely(ret < 0)) {
                        pr_err("crashkernel reservation failed - "
                               "memory is in use\n");
@@ -192,7 +192,7 @@ void __init reserve_crashkernel(void)
        /*
         * Crash kernel trumps memory limit
         */
-       if ((lmb_end_of_DRAM() - memory_limit) <= crashk_res.end) {
+       if ((memblock_end_of_DRAM() - memory_limit) <= crashk_res.end) {
                memory_limit = 0;
                pr_info("Disabled memory limit for crashkernel\n");
        }
@@ -201,7 +201,7 @@ void __init reserve_crashkernel(void)
                "for crashkernel (System RAM: %ldMB)\n",
                (unsigned long)(crash_size >> 20),
                (unsigned long)(crashk_res.start),
-               (unsigned long)(lmb_phys_mem_size() >> 20));
+               (unsigned long)(memblock_phys_mem_size() >> 20));
 
        return;
 
index 272734681d29dd6262772a467735a04cd91ab88a..e769401a78ba3218946620d62ad2a83875448ea7 100644 (file)
@@ -30,7 +30,7 @@
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/page.h>
@@ -141,10 +141,10 @@ void __init check_for_initrd(void)
                goto disable;
        }
 
-       if (unlikely(end > lmb_end_of_DRAM())) {
+       if (unlikely(end > memblock_end_of_DRAM())) {
                pr_err("initrd extends beyond end of memory "
                       "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
-                      end, (unsigned long)lmb_end_of_DRAM());
+                      end, (unsigned long)memblock_end_of_DRAM());
                goto disable;
        }
 
@@ -161,7 +161,7 @@ void __init check_for_initrd(void)
        initrd_start = (unsigned long)__va(__pa(start));
        initrd_end = initrd_start + INITRD_SIZE;
 
-       lmb_reserve(__pa(initrd_start), INITRD_SIZE);
+       memblock_reserve(__pa(initrd_start), INITRD_SIZE);
 
        return;
 
index 46f84de6246901e5704942d2fa8bea3ae4d9b87f..d0e249100e98d044b804414b80d725a0ebd7e43d 100644 (file)
@@ -16,7 +16,7 @@
 #include <linux/pagemap.h>
 #include <linux/percpu.h>
 #include <linux/io.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/dma-mapping.h>
 #include <asm/mmu_context.h>
 #include <asm/mmzone.h>
@@ -33,7 +33,7 @@ pgd_t swapper_pg_dir[PTRS_PER_PGD];
 
 void __init generic_mem_init(void)
 {
-       lmb_add(__MEMORY_START, __MEMORY_SIZE);
+       memblock_add(__MEMORY_START, __MEMORY_SIZE);
 }
 
 void __init __weak plat_mem_setup(void)
@@ -176,12 +176,12 @@ void __init allocate_pgdat(unsigned int nid)
        get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
 
 #ifdef CONFIG_NEED_MULTIPLE_NODES
-       phys = __lmb_alloc_base(sizeof(struct pglist_data),
+       phys = __memblock_alloc_base(sizeof(struct pglist_data),
                                SMP_CACHE_BYTES, end_pfn << PAGE_SHIFT);
        /* Retry with all of system memory */
        if (!phys)
-               phys = __lmb_alloc_base(sizeof(struct pglist_data),
-                                       SMP_CACHE_BYTES, lmb_end_of_DRAM());
+               phys = __memblock_alloc_base(sizeof(struct pglist_data),
+                                       SMP_CACHE_BYTES, memblock_end_of_DRAM());
        if (!phys)
                panic("Can't allocate pgdat for node %d\n", nid);
 
@@ -212,7 +212,7 @@ static void __init bootmem_init_one_node(unsigned int nid)
 
        total_pages = bootmem_bootmap_pages(p->node_spanned_pages);
 
-       paddr = lmb_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
+       paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
        if (!paddr)
                panic("Can't allocate bootmap for nid[%d]\n", nid);
 
@@ -227,9 +227,9 @@ static void __init bootmem_init_one_node(unsigned int nid)
         */
        if (nid == 0) {
                /* Reserve the sections we're already using. */
-               for (i = 0; i < lmb.reserved.cnt; i++)
-                       reserve_bootmem(lmb.reserved.region[i].base,
-                                       lmb_size_bytes(&lmb.reserved, i),
+               for (i = 0; i < memblock.reserved.cnt; i++)
+                       reserve_bootmem(memblock.reserved.region[i].base,
+                                       memblock_size_bytes(&memblock.reserved, i),
                                        BOOTMEM_DEFAULT);
        }
 
@@ -241,10 +241,10 @@ static void __init do_init_bootmem(void)
        int i;
 
        /* Add active regions with valid PFNs. */
-       for (i = 0; i < lmb.memory.cnt; i++) {
+       for (i = 0; i < memblock.memory.cnt; i++) {
                unsigned long start_pfn, end_pfn;
-               start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
-               end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
+               start_pfn = memblock.memory.region[i].base >> PAGE_SHIFT;
+               end_pfn = start_pfn + memblock_size_pages(&memblock.memory, i);
                __add_active_range(0, start_pfn, end_pfn);
        }
 
@@ -276,7 +276,7 @@ static void __init early_reserve_mem(void)
         * this catches the (definitely buggy) case of us accidentally
         * initializing the bootmem allocator with an invalid RAM area.
         */
-       lmb_reserve(__MEMORY_START + CONFIG_ZERO_PAGE_OFFSET,
+       memblock_reserve(__MEMORY_START + CONFIG_ZERO_PAGE_OFFSET,
                    (PFN_PHYS(start_pfn) + PAGE_SIZE - 1) -
                    (__MEMORY_START + CONFIG_ZERO_PAGE_OFFSET));
 
@@ -284,7 +284,7 @@ static void __init early_reserve_mem(void)
         * Reserve physical pages below CONFIG_ZERO_PAGE_OFFSET.
         */
        if (CONFIG_ZERO_PAGE_OFFSET != 0)
-               lmb_reserve(__MEMORY_START, CONFIG_ZERO_PAGE_OFFSET);
+               memblock_reserve(__MEMORY_START, CONFIG_ZERO_PAGE_OFFSET);
 
        /*
         * Handle additional early reservations
@@ -299,27 +299,27 @@ void __init paging_init(void)
        unsigned long vaddr, end;
        int nid;
 
-       lmb_init();
+       memblock_init();
 
        sh_mv.mv_mem_init();
 
        early_reserve_mem();
 
-       lmb_enforce_memory_limit(memory_limit);
-       lmb_analyze();
+       memblock_enforce_memory_limit(memory_limit);
+       memblock_analyze();
 
-       lmb_dump_all();
+       memblock_dump_all();
 
        /*
         * Determine low and high memory ranges:
         */
-       max_low_pfn = max_pfn = lmb_end_of_DRAM() >> PAGE_SHIFT;
+       max_low_pfn = max_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
        min_low_pfn = __MEMORY_START >> PAGE_SHIFT;
 
        nodes_clear(node_online_map);
 
        memory_start = (unsigned long)__va(__MEMORY_START);
-       memory_end = memory_start + (memory_limit ?: lmb_phys_mem_size());
+       memory_end = memory_start + (memory_limit ?: memblock_phys_mem_size());
 
        uncached_init();
        pmb_init();
index a2e645f64a371a04a625893cb0c5d484ad7c045e..3d85225b9e953aa68af579d7300f90119f5e694a 100644 (file)
@@ -9,7 +9,7 @@
  */
 #include <linux/module.h>
 #include <linux/bootmem.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/mm.h>
 #include <linux/numa.h>
 #include <linux/pfn.h>
@@ -39,12 +39,12 @@ void __init setup_bootmem_node(int nid, unsigned long start, unsigned long end)
        pmb_bolt_mapping((unsigned long)__va(start), start, end - start,
                         PAGE_KERNEL);
 
-       lmb_add(start, end - start);
+       memblock_add(start, end - start);
 
        __add_active_range(nid, start_pfn, end_pfn);
 
        /* Node-local pgdat */
-       NODE_DATA(nid) = __va(lmb_alloc_base(sizeof(struct pglist_data),
+       NODE_DATA(nid) = __va(memblock_alloc_base(sizeof(struct pglist_data),
                                             SMP_CACHE_BYTES, end));
        memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
 
@@ -54,7 +54,7 @@ void __init setup_bootmem_node(int nid, unsigned long start, unsigned long end)
 
        /* Node-local bootmap */
        bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
-       bootmem_paddr = lmb_alloc_base(bootmap_pages << PAGE_SHIFT,
+       bootmem_paddr = memblock_alloc_base(bootmap_pages << PAGE_SHIFT,
                                       PAGE_SIZE, end);
        init_bootmem_node(NODE_DATA(nid), bootmem_paddr >> PAGE_SHIFT,
                          start_pfn, end_pfn);
index 6f1470baa314e8787213efedb78e0a3f9d6f9e56..c0015db247ba46ed787b4b16b47f402a3de1152a 100644 (file)
@@ -42,7 +42,7 @@ config SPARC64
        select HAVE_FUNCTION_TRACE_MCOUNT_TEST
        select HAVE_KRETPROBES
        select HAVE_KPROBES
-       select HAVE_LMB
+       select HAVE_MEMBLOCK
        select HAVE_SYSCALL_WRAPPERS
        select HAVE_DYNAMIC_FTRACE
        select HAVE_FTRACE_MCOUNT_RECORD
index 259e3fd50993a95a2970f404a9c7a4a5224a1b5d..1dc07a0014c17b22bc2af459c581e3fc216d0948 100644 (file)
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.34-rc3
-# Sat Apr  3 15:49:56 2010
+# Linux kernel version: 2.6.34
+# Wed May 26 21:14:01 2010
 #
 CONFIG_64BIT=y
 CONFIG_SPARC=y
@@ -107,10 +107,9 @@ CONFIG_PERF_COUNTERS=y
 # CONFIG_DEBUG_PERF_USE_VMALLOC is not set
 CONFIG_VM_EVENT_COUNTERS=y
 CONFIG_PCI_QUIRKS=y
-CONFIG_SLUB_DEBUG=y
 # CONFIG_COMPAT_BRK is not set
-# CONFIG_SLAB is not set
-CONFIG_SLUB=y
+CONFIG_SLAB=y
+# CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
 CONFIG_TRACEPOINTS=y
@@ -239,6 +238,7 @@ CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
 CONFIG_SPARSEMEM_VMEMMAP=y
 CONFIG_PAGEFLAGS_EXTENDED=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
+# CONFIG_COMPACTION is not set
 CONFIG_MIGRATION=y
 CONFIG_PHYS_ADDR_T_64BIT=y
 CONFIG_ZONE_DMA_FLAG=0
@@ -351,6 +351,7 @@ CONFIG_IPV6_TUNNEL=m
 # CONFIG_RDS is not set
 # CONFIG_TIPC is not set
 # CONFIG_ATM is not set
+# CONFIG_L2TP is not set
 # CONFIG_BRIDGE is not set
 # CONFIG_NET_DSA is not set
 CONFIG_VLAN_8021Q=m
@@ -367,6 +368,7 @@ CONFIG_VLAN_8021Q=m
 # CONFIG_IEEE802154 is not set
 # CONFIG_NET_SCHED is not set
 # CONFIG_DCB is not set
+CONFIG_RPS=y
 
 #
 # Network testing
@@ -386,9 +388,14 @@ CONFIG_WIRELESS=y
 #
 # CFG80211 needs to be enabled for MAC80211
 #
+
+#
+# Some wireless drivers require a rate control algorithm
+#
 # CONFIG_WIMAX is not set
 # CONFIG_RFKILL is not set
 # CONFIG_NET_9P is not set
+# CONFIG_CAIF is not set
 
 #
 # Device Drivers
@@ -658,6 +665,7 @@ CONFIG_PHYLIB=m
 # CONFIG_NATIONAL_PHY is not set
 # CONFIG_STE10XP is not set
 # CONFIG_LSI_ET1011C_PHY is not set
+# CONFIG_MICREL_PHY is not set
 # CONFIG_MDIO_BITBANG is not set
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=m
@@ -734,6 +742,8 @@ CONFIG_NETDEV_10000=y
 # CONFIG_CHELSIO_T1 is not set
 CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_CHELSIO_T3 is not set
+CONFIG_CHELSIO_T4_DEPENDS=y
+# CONFIG_CHELSIO_T4 is not set
 # CONFIG_ENIC is not set
 # CONFIG_IXGBE is not set
 # CONFIG_IXGBEVF is not set
@@ -766,6 +776,7 @@ CONFIG_NIU=m
 # CONFIG_USB_PEGASUS is not set
 # CONFIG_USB_RTL8150 is not set
 # CONFIG_USB_USBNET is not set
+# CONFIG_USB_IPHETH is not set
 # CONFIG_WAN is not set
 # CONFIG_FDDI is not set
 # CONFIG_HIPPI is not set
@@ -778,7 +789,6 @@ CONFIG_PPP_DEFLATE=m
 CONFIG_PPP_BSDCOMP=m
 CONFIG_PPP_MPPE=m
 CONFIG_PPPOE=m
-# CONFIG_PPPOL2TP is not set
 # CONFIG_SLIP is not set
 CONFIG_SLHC=m
 # CONFIG_NET_FC is not set
@@ -816,6 +826,7 @@ CONFIG_INPUT_KEYBOARD=y
 CONFIG_KEYBOARD_ATKBD=y
 # CONFIG_QT2160 is not set
 CONFIG_KEYBOARD_LKKBD=m
+# CONFIG_KEYBOARD_TCA6416 is not set
 # CONFIG_KEYBOARD_MAX7359 is not set
 # CONFIG_KEYBOARD_NEWTON is not set
 # CONFIG_KEYBOARD_OPENCORES is not set
@@ -840,6 +851,7 @@ CONFIG_MOUSE_SERIAL=y
 # CONFIG_INPUT_TABLET is not set
 # CONFIG_INPUT_TOUCHSCREEN is not set
 CONFIG_INPUT_MISC=y
+# CONFIG_INPUT_AD714X is not set
 CONFIG_INPUT_SPARCSPKR=y
 # CONFIG_INPUT_ATI_REMOTE is not set
 # CONFIG_INPUT_ATI_REMOTE2 is not set
@@ -848,6 +860,7 @@ CONFIG_INPUT_SPARCSPKR=y
 # CONFIG_INPUT_YEALINK is not set
 # CONFIG_INPUT_CM109 is not set
 # CONFIG_INPUT_UINPUT is not set
+# CONFIG_INPUT_PCF8574 is not set
 
 #
 # Hardware I/O ports
@@ -871,6 +884,7 @@ CONFIG_HW_CONSOLE=y
 # CONFIG_VT_HW_CONSOLE_BINDING is not set
 # CONFIG_DEVKMEM is not set
 # CONFIG_SERIAL_NONSTANDARD is not set
+# CONFIG_N_GSM is not set
 # CONFIG_NOZOMI is not set
 
 #
@@ -893,6 +907,8 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 # CONFIG_SERIAL_TIMBERDALE is not set
 # CONFIG_SERIAL_GRLIB_GAISLER_APBUART is not set
+# CONFIG_SERIAL_ALTERA_JTAGUART is not set
+# CONFIG_SERIAL_ALTERA_UART is not set
 CONFIG_UNIX98_PTYS=y
 # CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set
 # CONFIG_LEGACY_PTYS is not set
@@ -1306,11 +1322,14 @@ CONFIG_USB_HIDDEV=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
+# CONFIG_HID_CANDO is not set
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
+# CONFIG_HID_PRODIKEYS is not set
 CONFIG_HID_CYPRESS=y
 CONFIG_HID_DRAGONRISE=y
 # CONFIG_DRAGONRISE_FF is not set
+# CONFIG_HID_EGALAX is not set
 CONFIG_HID_EZKEY=y
 CONFIG_HID_KYE=y
 CONFIG_HID_GYRATION=y
@@ -1328,7 +1347,9 @@ CONFIG_HID_ORTEK=y
 CONFIG_HID_PANTHERLORD=y
 # CONFIG_PANTHERLORD_FF is not set
 CONFIG_HID_PETALYNX=y
+# CONFIG_HID_PICOLCD is not set
 # CONFIG_HID_QUANTA is not set
+# CONFIG_HID_ROCCAT_KONE is not set
 CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 # CONFIG_HID_STANTUM is not set
@@ -1342,6 +1363,7 @@ CONFIG_HID_THRUSTMASTER=y
 # CONFIG_THRUSTMASTER_FF is not set
 CONFIG_HID_ZEROPLUS=y
 # CONFIG_ZEROPLUS_FF is not set
+# CONFIG_HID_ZYDACRON is not set
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1356,7 +1378,6 @@ CONFIG_USB=y
 # CONFIG_USB_DEVICEFS is not set
 # CONFIG_USB_DEVICE_CLASS is not set
 # CONFIG_USB_DYNAMIC_MINORS is not set
-# CONFIG_USB_OTG is not set
 # CONFIG_USB_MON is not set
 # CONFIG_USB_WUSB is not set
 # CONFIG_USB_WUSB_CBAF is not set
@@ -1521,10 +1542,6 @@ CONFIG_RTC_DRV_STARFIRE=y
 # CONFIG_DMADEVICES is not set
 # CONFIG_AUXDISPLAY is not set
 # CONFIG_UIO is not set
-
-#
-# TI VLYNQ
-#
 # CONFIG_STAGING is not set
 
 #
@@ -1706,8 +1723,8 @@ CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHEDSTATS=y
 # CONFIG_TIMER_STATS is not set
 # CONFIG_DEBUG_OBJECTS is not set
-# CONFIG_SLUB_DEBUG_ON is not set
-# CONFIG_SLUB_STATS is not set
+# CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_KMEMLEAK is not set
 # CONFIG_DEBUG_RT_MUTEXES is not set
 # CONFIG_RT_MUTEX_TESTER is not set
 # CONFIG_DEBUG_SPINLOCK is not set
@@ -1742,6 +1759,9 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 # CONFIG_DEBUG_PAGEALLOC is not set
 CONFIG_NOP_TRACER=y
 CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
+CONFIG_HAVE_FUNCTION_GRAPH_FP_TEST=y
+CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
@@ -1769,12 +1789,12 @@ CONFIG_BLK_DEV_IO_TRACE=y
 # CONFIG_RING_BUFFER_BENCHMARK is not set
 # CONFIG_DYNAMIC_DEBUG is not set
 # CONFIG_DMA_API_DEBUG is not set
+# CONFIG_ATOMIC64_SELFTEST is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_DCFLUSH is not set
-# CONFIG_STACK_DEBUG is not set
 # CONFIG_DEBUG_STRICT_USER_COPY_CHECKS is not set
 
 #
@@ -1895,6 +1915,7 @@ CONFIG_CRYPTO_DEFLATE=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_CRYPTO_DEV_NIAGARA2 is not set
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
 CONFIG_BINARY_PRINTF=y
 
index 0588b8c7faa26b5eb596a1c52a1bcbf77a53bc92..69358b590c9156953ee3c45deb471e4833c7d370 100644 (file)
@@ -11,7 +11,6 @@
 
 #define L1_CACHE_SHIFT 5
 #define L1_CACHE_BYTES 32
-#define L1_CACHE_ALIGN(x) ((((x)+(L1_CACHE_BYTES-1))&~(L1_CACHE_BYTES-1)))
 
 #ifdef CONFIG_SPARC32
 #define SMP_CACHE_BYTES_SHIFT 5
diff --git a/arch/sparc/include/asm/lmb.h b/arch/sparc/include/asm/lmb.h
deleted file mode 100644 (file)
index 6a352cb..0000000
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef _SPARC64_LMB_H
-#define _SPARC64_LMB_H
-
-#include <asm/oplib.h>
-
-#define LMB_DBG(fmt...) prom_printf(fmt)
-
-#define LMB_REAL_LIMIT 0
-
-#endif /* !(_SPARC64_LMB_H) */
diff --git a/arch/sparc/include/asm/memblock.h b/arch/sparc/include/asm/memblock.h
new file mode 100644 (file)
index 0000000..f12af88
--- /dev/null
@@ -0,0 +1,10 @@
+#ifndef _SPARC64_MEMBLOCK_H
+#define _SPARC64_MEMBLOCK_H
+
+#include <asm/oplib.h>
+
+#define MEMBLOCK_DBG(fmt...) prom_printf(fmt)
+
+#define MEMBLOCK_REAL_LIMIT    0
+
+#endif /* !(_SPARC64_MEMBLOCK_H) */
index 77f906d8cc21f3874ee079aa731edf49f02dea75..0ece77f477536b773a9bd310515008c3b152055c 100644 (file)
@@ -142,13 +142,12 @@ BTFIXUPDEF_CALL_CONST(unsigned long, pgd_page_vaddr, pgd_t)
 #define pmd_page(pmd) BTFIXUP_CALL(pmd_page)(pmd)
 #define pgd_page_vaddr(pgd) BTFIXUP_CALL(pgd_page_vaddr)(pgd)
 
-BTFIXUPDEF_SETHI(none_mask)
 BTFIXUPDEF_CALL_CONST(int, pte_present, pte_t)
 BTFIXUPDEF_CALL(void, pte_clear, pte_t *)
 
 static inline int pte_none(pte_t pte)
 {
-       return !(pte_val(pte) & ~BTFIXUP_SETHI(none_mask));
+       return !pte_val(pte);
 }
 
 #define pte_present(pte) BTFIXUP_CALL(pte_present)(pte)
@@ -160,7 +159,7 @@ BTFIXUPDEF_CALL(void, pmd_clear, pmd_t *)
 
 static inline int pmd_none(pmd_t pmd)
 {
-       return !(pmd_val(pmd) & ~BTFIXUP_SETHI(none_mask));
+       return !pmd_val(pmd);
 }
 
 #define pmd_bad(pmd) BTFIXUP_CALL(pmd_bad)(pmd)
index cdc91d919e93c36219e19b8a58d9ea32de721e3b..83e85c2e802ad6a075b08d0d0e5dfccb50e81108 100644 (file)
@@ -4,7 +4,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/types.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/log2.h>
 #include <linux/list.h>
 #include <linux/slab.h>
@@ -86,7 +86,7 @@ static void mdesc_handle_init(struct mdesc_handle *hp,
        hp->handle_size = handle_size;
 }
 
-static struct mdesc_handle * __init mdesc_lmb_alloc(unsigned int mdesc_size)
+static struct mdesc_handle * __init mdesc_memblock_alloc(unsigned int mdesc_size)
 {
        unsigned int handle_size, alloc_size;
        struct mdesc_handle *hp;
@@ -97,7 +97,7 @@ static struct mdesc_handle * __init mdesc_lmb_alloc(unsigned int mdesc_size)
                       mdesc_size);
        alloc_size = PAGE_ALIGN(handle_size);
 
-       paddr = lmb_alloc(alloc_size, PAGE_SIZE);
+       paddr = memblock_alloc(alloc_size, PAGE_SIZE);
 
        hp = NULL;
        if (paddr) {
@@ -107,7 +107,7 @@ static struct mdesc_handle * __init mdesc_lmb_alloc(unsigned int mdesc_size)
        return hp;
 }
 
-static void mdesc_lmb_free(struct mdesc_handle *hp)
+static void mdesc_memblock_free(struct mdesc_handle *hp)
 {
        unsigned int alloc_size;
        unsigned long start;
@@ -120,9 +120,9 @@ static void mdesc_lmb_free(struct mdesc_handle *hp)
        free_bootmem_late(start, alloc_size);
 }
 
-static struct mdesc_mem_ops lmb_mdesc_ops = {
-       .alloc = mdesc_lmb_alloc,
-       .free  = mdesc_lmb_free,
+static struct mdesc_mem_ops memblock_mdesc_ops = {
+       .alloc = mdesc_memblock_alloc,
+       .free  = mdesc_memblock_free,
 };
 
 static struct mdesc_handle *mdesc_kmalloc(unsigned int mdesc_size)
@@ -914,7 +914,7 @@ void __init sun4v_mdesc_init(void)
 
        printk("MDESC: Size is %lu bytes.\n", len);
 
-       hp = mdesc_alloc(len, &lmb_mdesc_ops);
+       hp = mdesc_alloc(len, &memblock_mdesc_ops);
        if (hp == NULL) {
                prom_printf("MDESC: alloc of %lu bytes failed.\n", len);
                prom_halt();
index 0ec92c8861dd3a68fe0465b71ccf8007ad6e40a7..44faabc3c02c920bba1b9f12272d1a907895161e 100644 (file)
@@ -657,6 +657,7 @@ static u64 maybe_change_configuration(struct cpu_hw_events *cpuc, u64 pcr)
                cpuc->current_idx[i] = idx;
 
                enc = perf_event_get_enc(cpuc->events[i]);
+               pcr &= ~mask_for_index(idx);
                pcr |= event_encoding(enc, idx);
        }
 out:
index fb06ac2bd38ffbb198080dc9006775fdab0b55f1..466a32763ea82fbe0bd644fb5468459a7fe4196f 100644 (file)
@@ -20,7 +20,7 @@
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/module.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/of_device.h>
 
 #include <asm/prom.h>
@@ -34,7 +34,7 @@
 
 void * __init prom_early_alloc(unsigned long size)
 {
-       unsigned long paddr = lmb_alloc(size, SMP_CACHE_BYTES);
+       unsigned long paddr = memblock_alloc(size, SMP_CACHE_BYTES);
        void *ret;
 
        if (!paddr) {
index ab036a72de5a16460cdb8b548dbcf15bb2e04db6..e11b4612dabb32df7cd0155ed6aed40515c038ad 100644 (file)
@@ -183,7 +183,7 @@ void sun4d_free_irq(unsigned int irq, void *dev_id)
                goto out_unlock;
        }
        
-       if (action && tmp)
+       if (tmp)
                tmp->next = action->next;
        else
                *actionp = action->next;
index 76d837fc47d3fdd498c0b2fdb276c9b25abe1c0b..c6dfdaa29e208994fab3b1942cd24878d0bd2d98 100644 (file)
@@ -64,7 +64,7 @@ tl0_irq6:     TRAP_IRQ(smp_call_function_single_client, 6)
 tl0_irq6:      BTRAP(0x46)
 #endif
 tl0_irq7:      TRAP_IRQ(deferred_pcr_work_irq, 7)
-#ifdef CONFIG_KGDB
+#if defined(CONFIG_KGDB) && defined(CONFIG_SMP)
 tl0_irq8:      TRAP_IRQ(smp_kgdb_capture_client, 8)
 #else
 tl0_irq8:      BTRAP(0x48)
index b2831dc3c121c135a0ed41fe09aaf975f1aa678f..f0434513df159301da052662442b281bea30b5c5 100644 (file)
@@ -23,7 +23,7 @@
 #include <linux/cache.h>
 #include <linux/sort.h>
 #include <linux/percpu.h>
-#include <linux/lmb.h>
+#include <linux/memblock.h>
 #include <linux/mmzone.h>
 #include <linux/gfp.h>
 
@@ -726,7 +726,7 @@ static void __init find_ramdisk(unsigned long phys_base)
                initrd_start = ramdisk_image;
                initrd_end = ramdisk_image + sparc_ramdisk_size;
 
-               lmb_reserve(initrd_start, sparc_ramdisk_size);
+               memblock_reserve(initrd_start, sparc_ramdisk_size);
 
                initrd_start += PAGE_OFFSET;
                initrd_end += PAGE_OFFSET;
@@ -822,7 +822,7 @@ static void __init allocate_node_data(int nid)
        struct pglist_data *p;
 
 #ifdef CONFIG_NEED_MULTIPLE_NODES
-       paddr = lmb_alloc_nid(sizeof(struct pglist_data),
+       paddr = memblock_alloc_nid(sizeof(struct pglist_data),
                              SMP_CACHE_BYTES, nid, nid_range);
        if (!paddr) {
                prom_printf("Cannot allocate pglist_data for nid[%d]\n", nid);
@@ -843,7 +843,7 @@ static void __init allocate_node_data(int nid)
        if (p->node_spanned_pages) {
                num_pages = bootmem_bootmap_pages(p->node_spanned_pages);
 
-               paddr = lmb_alloc_nid(num_pages << PAGE_SHIFT, PAGE_SIZE, nid,
+               paddr = memblock_alloc_nid(num_pages << PAGE_SHIFT, PAGE_SIZE, nid,
                                      nid_range);
                if (!paddr) {
                        prom_printf("Cannot allocate bootmap for nid[%d]\n",
@@ -974,11 +974,11 @@ static void __init add_node_ranges(void)
 {
        int i;
 
-       for (i = 0; i < lmb.memory.cnt; i++) {
-               unsigned long size = lmb_size_bytes(&lmb.memory, i);
+       for (i = 0; i < memblock.memory.cnt; i++) {
+               unsigned long size = memblock_size_bytes(&memblock.memory, i);
                unsigned long start, end;
 
-               start = lmb.memory.region[i].base;
+               start = memblock.memory.region[i].base;
                end = start + size;
                while (start < end) {
                        unsigned long this_end;
@@ -1010,7 +1010,7 @@ static int __init grab_mlgroups(struct mdesc_handle *md)
        if (!count)
                return -ENOENT;
 
-       paddr = lmb_alloc(count * sizeof(struct mdesc_mlgroup),
+       paddr = memblock_alloc(count * sizeof(struct mdesc_mlgroup),
                          SMP_CACHE_BYTES);
        if (!paddr)
                return -ENOMEM;
@@ -1051,7 +1051,7 @@ static int __init grab_mblocks(struct mdesc_handle *md)
        if (!count)
                return -ENOENT;
 
-       paddr = lmb_alloc(count * sizeof(struct mdesc_mblock),
+       paddr = memblock_alloc(count * sizeof(struct mdesc_mblock),
                          SMP_CACHE_BYTES);
        if (!paddr)
                return -ENOMEM;
@@ -1279,8 +1279,8 @@ static int bootmem_init_numa(void)
 
 static void __init bootmem_init_nonnuma(void)
 {
-       unsigned long top_of_ram = lmb_end_of_DRAM();
-       unsigned long total_ram = lmb_phys_mem_size();
+       unsigned long top_of_ram = memblock_end_of_DRAM();
+       unsigned long total_ram = memblock_phys_mem_size();
        unsigned int i;
 
        numadbg("bootmem_init_nonnuma()\n");
@@ -1292,15 +1292,15 @@ static void __init bootmem_init_nonnuma(void)
 
        init_node_masks_nonnuma();
 
-       for (i = 0; i < lmb.memory.cnt; i++) {
-               unsigned long size = lmb_size_bytes(&lmb.memory, i);
+       for (i = 0; i < memblock.memory.cnt; i++) {
+               unsigned long size = memblock_size_bytes(&memblock.memory, i);
                unsigned long start_pfn, end_pfn;
 
                if (!size)
                        continue;
 
-               start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
-               end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
+               start_pfn = memblock.memory.region[i].base >> PAGE_SHIFT;
+               end_pfn = start_pfn + memblock_size_pages(&memblock.memory, i);
                add_active_range(0, start_pfn, end_pfn);
        }
 
@@ -1338,9 +1338,9 @@ static void __init trim_reserved_in_node(int nid)
 
        numadbg("  trim_reserved_in_node(%d)\n", nid);
 
-       for (i = 0; i < lmb.reserved.cnt; i++) {
-               unsigned long start = lmb.reserved.region[i].base;
-               unsigned long size = lmb_size_bytes(&lmb.reserved, i);
+       for (i = 0; i < memblock.reserved.cnt; i++) {
+               unsigned long start = memblock.reserved.region[i].base;
+               unsigned long size = memblock_size_bytes(&memblock.reserved, i);
                unsigned long end = start + size;
 
                reserve_range_in_node(nid, start, end);
@@ -1384,7 +1384,7 @@ static unsigned long __init bootmem_init(unsigned long phys_base)
        unsigned long end_pfn;
        int nid;
 
-       end_pfn = lmb_end_of_DRAM() >> PAGE_SHIFT;
+       end_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT;
        max_pfn = max_low_pfn = end_pfn;
        min_low_pfn = (phys_base >> PAGE_SHIFT);
 
@@ -1734,7 +1734,7 @@ void __init paging_init(void)
                sun4v_ktsb_init();
        }
 
-       lmb_init();
+       memblock_init();
 
        /* Find available physical memory...
         *
@@ -1752,17 +1752,17 @@ void __init paging_init(void)
        phys_base = 0xffffffffffffffffUL;
        for (i = 0; i < pavail_ents; i++) {
                phys_base = min(phys_base, pavail[i].phys_addr);
-               lmb_add(pavail[i].phys_addr, pavail[i].reg_size);
+               memblock_add(pavail[i].phys_addr, pavail[i].reg_size);
        }
 
-       lmb_reserve(kern_base, kern_size);
+       memblock_reserve(kern_base, kern_size);
 
        find_ramdisk(phys_base);
 
-       lmb_enforce_memory_limit(cmdline_memory_size);
+       memblock_enforce_memory_limit(cmdline_memory_size);
 
-       lmb_analyze();
-       lmb_dump_all();
+       memblock_analyze();
+       memblock_dump_all();
 
        set_bit(0, mmu_context_bmap);
 
@@ -1816,8 +1816,8 @@ void __init paging_init(void)
         */
        for_each_possible_cpu(i) {
                /* XXX Use node local allocations... XXX */
-               softirq_stack[i] = __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
-               hardirq_stack[i] = __va(lmb_alloc(THREAD_SIZE, THREAD_SIZE));
+               softirq_stack[i] = __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
+               hardirq_stack[i] = __va(memblock_alloc(THREAD_SIZE, THREAD_SIZE));
        }
 
        /* Setup bootmem... */
index f5f75a58e0b3cc7077f78a610f6cc6107c75bcb8..b0b43aa5e45a483984b0acd7a4641c0765eb8859 100644 (file)
@@ -2215,8 +2215,6 @@ void __init ld_mmu_srmmu(void)
        BTFIXUPSET_CALL(pmd_page, srmmu_pmd_page, BTFIXUPCALL_NORM);
        BTFIXUPSET_CALL(pgd_page_vaddr, srmmu_pgd_page, BTFIXUPCALL_NORM);
 
-       BTFIXUPSET_SETHI(none_mask, 0xF0000000);
-
        BTFIXUPSET_CALL(pte_present, srmmu_pte_present, BTFIXUPCALL_NORM);
        BTFIXUPSET_CALL(pte_clear, srmmu_pte_clear, BTFIXUPCALL_SWAPO0G0);
 
index cf38846753dd55c3ece5d7be244b23d9ca3fbda3..4289f90f86972f6020318bf002162fccf5a968e8 100644 (file)
@@ -2087,9 +2087,6 @@ void __init ld_mmu_sun4c(void)
 
        BTFIXUPSET_CALL(set_pte, sun4c_set_pte, BTFIXUPCALL_STO1O0);
 
-       /* The 2.4.18 code does not set this on sun4c, how does it work? XXX */
-       /* BTFIXUPSET_SETHI(none_mask, 0x00000000); */  /* Defaults to zero? */
-
        BTFIXUPSET_CALL(pte_pfn, sun4c_pte_pfn, BTFIXUPCALL_NORM);
 #if 0 /* PAGE_SHIFT <= 12 */ /* Eek. Investigate. XXX */
        BTFIXUPSET_CALL(pmd_page, sun4c_pmd_page, BTFIXUPCALL_ANDNINT(PAGE_SIZE - 1));
index 519b54327d750f5e3580ed45cc68e78272c1ba81..baa579c8e03839cbb8d54fb7b2b4d3b7d700742c 100644 (file)
@@ -142,6 +142,7 @@ struct x86_cpuinit_ops {
  * @set_wallclock:             set time back to HW clock
  * @is_untracked_pat_range     exclude from PAT logic
  * @nmi_init                   enable NMI on cpus
+ * @i8042_detect               pre-detect if i8042 controller exists
  */
 struct x86_platform_ops {
        unsigned long (*calibrate_tsc)(void);
@@ -150,6 +151,7 @@ struct x86_platform_ops {
        void (*iommu_shutdown)(void);
        bool (*is_untracked_pat_range)(u64 start, u64 end);
        void (*nmi_init)(void);
+       int (*i8042_detect)(void);
 };
 
 extern struct x86_init_ops x86_init;
index c02cc692985c13b902f1a9c914535170f9670d01..a96489ee6cabf04a53664300f87141c4bbffc293 100644 (file)
@@ -921,7 +921,7 @@ void disable_local_APIC(void)
        unsigned int value;
 
        /* APIC hasn't been mapped yet */
-       if (!apic_phys)
+       if (!x2apic_mode && !apic_phys)
                return;
 
        clear_local_APIC();
index ebdb85cf2686fa36702cd4d50b657f22de85b3bd..e5cc7e82e60ddbf1bd1ca2871fdb7d7fc7628e34 100644 (file)
@@ -18,6 +18,7 @@
 #include <asm/apic.h>
 #include <asm/iommu.h>
 #include <asm/gart.h>
+#include <asm/hpet.h>
 
 static void __init fix_hypertransport_config(int num, int slot, int func)
 {
@@ -191,6 +192,21 @@ static void __init ati_bugs_contd(int num, int slot, int func)
 }
 #endif
 
+/*
+ * Force the read back of the CMP register in hpet_next_event()
+ * to work around the problem that the CMP register write seems to be
+ * delayed. See hpet_next_event() for details.
+ *
+ * We do this on all SMBUS incarnations for now until we have more
+ * information about the affected chipsets.
+ */
+static void __init ati_hpet_bugs(int num, int slot, int func)
+{
+#ifdef CONFIG_HPET_TIMER
+       hpet_readback_cmp = 1;
+#endif
+}
+
 #define QFLAG_APPLY_ONCE       0x1
 #define QFLAG_APPLIED          0x2
 #define QFLAG_DONE             (QFLAG_APPLY_ONCE|QFLAG_APPLIED)
@@ -220,6 +236,8 @@ static struct chipset early_qrk[] __initdata = {
          PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs },
        { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS,
          PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_bugs_contd },
+       { PCI_VENDOR_ID_ATI, PCI_ANY_ID,
+         PCI_CLASS_SERIAL_SMBUS, PCI_ANY_ID, 0, ati_hpet_bugs },
        {}
 };
 
index 0697ff139837644f170f032ae525d9e112c71681..4db7c4d12ffacb0ac5bdfe8d26c2ee1c181e52fc 100644 (file)
@@ -571,8 +571,8 @@ auditsys:
         * masked off.
         */
 sysret_audit:
-       movq %rax,%rsi          /* second arg, syscall return value */
-       cmpq $0,%rax            /* is it < 0? */
+       movq RAX-ARGOFFSET(%rsp),%rsi   /* second arg, syscall return value */
+       cmpq $0,%rsi            /* is it < 0? */
        setl %al                /* 1 if so, 0 if not */
        movzbl %al,%edi         /* zero-extend that into %edi */
        inc %edi /* first arg, 0->1(AUDITSC_SUCCESS), 1->2(AUDITSC_FAILURE) */
index 345a4b1fe1446812d65e25fd424886d05aeb1fe4..675879b65ce666c91b868c96972ea35f107810f4 100644 (file)
@@ -640,8 +640,8 @@ static int __kprobes kprobe_handler(struct pt_regs *regs)
        /* Skip cs, ip, orig_ax and gs. */      \
        "       subl $16, %esp\n"       \
        "       pushl %fs\n"            \
-       "       pushl %ds\n"            \
        "       pushl %es\n"            \
+       "       pushl %ds\n"            \
        "       pushl %eax\n"           \
        "       pushl %ebp\n"           \
        "       pushl %edi\n"           \
index e796448f0eb5e7a156600d690a32807e3b7b39fa..5915e0b333033471fa27c8056a6dae2795bbe6ee 100644 (file)
@@ -216,6 +216,12 @@ static void __init mrst_setup_boot_clock(void)
                setup_boot_APIC_clock();
 };
 
+/* MID systems don't have i8042 controller */
+static int mrst_i8042_detect(void)
+{
+       return 0;
+}
+
 /*
  * Moorestown specific x86_init function overrides and early setup
  * calls.
@@ -233,6 +239,7 @@ void __init x86_mrst_early_setup(void)
        x86_cpuinit.setup_percpu_clockev = mrst_setup_secondary_clock;
 
        x86_platform.calibrate_tsc = mrst_calibrate_tsc;
+       x86_platform.i8042_detect = mrst_i8042_detect;
        x86_init.pci.init = pci_mrst_init;
        x86_init.pci.fixup_irqs = x86_init_noop;
 
index e72d3fc6547d6fe767785e869deb90ea683d8cdc..939b9e98245f733262cdee8198daa08498abf87e 100644 (file)
@@ -498,15 +498,10 @@ void force_hpet_resume(void)
  * See erratum #27 (Misinterpreted MSI Requests May Result in
  * Corrupted LPC DMA Data) in AMD Publication #46837,
  * "SB700 Family Product Errata", Rev. 1.0, March 2010.
- *
- * Also force the read back of the CMP register in hpet_next_event()
- * to work around the problem that the CMP register write seems to be
- * delayed. See hpet_next_event() for details.
  */
 static void force_disable_hpet_msi(struct pci_dev *unused)
 {
        hpet_msi_disable = 1;
-       hpet_readback_cmp = 1;
 }
 
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS,
index de3b63ae3da26300297e315a6f7a9b5157d429ee..a60df9ae645440789181acd318e12bd4c450aeff 100644 (file)
@@ -238,6 +238,15 @@ void __init setup_per_cpu_areas(void)
 #ifdef CONFIG_NUMA
                per_cpu(x86_cpu_to_node_map, cpu) =
                        early_per_cpu_map(x86_cpu_to_node_map, cpu);
+               /*
+                * Ensure that the boot cpu numa_node is correct when the boot
+                * cpu is on a node that doesn't have memory installed.
+                * Also cpu_up() will call cpu_to_node() for APs when
+                * MEMORY_HOTPLUG is defined, before per_cpu(numa_node) is set
+                * up later with c_init aka intel_init/amd_init.
+                * So set them all (boot cpu and all APs).
+                */
+               set_cpu_numa_node(cpu, early_cpu_to_node(cpu));
 #endif
 #endif
                /*
@@ -257,14 +266,6 @@ void __init setup_per_cpu_areas(void)
        early_per_cpu_ptr(x86_cpu_to_node_map) = NULL;
 #endif
 
-#if defined(CONFIG_X86_64) && defined(CONFIG_NUMA)
-       /*
-        * make sure boot cpu numa_node is right, when boot cpu is on the
-        * node that doesn't have mem installed
-        */
-       set_cpu_numa_node(boot_cpu_id, early_cpu_to_node(boot_cpu_id));
-#endif
-
        /* Setup node to cpumask map */
        setup_node_to_cpumask_map();
 
index 61a1e8c7e19f8169e736bd329e9b2b72c87c3cce..cd6da6bf3ecaf7c24b9b9848c31d313c741d0f16 100644 (file)
@@ -5,6 +5,7 @@
  */
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/module.h>
 
 #include <asm/bios_ebda.h>
 #include <asm/paravirt.h>
@@ -85,6 +86,7 @@ struct x86_cpuinit_ops x86_cpuinit __cpuinitdata = {
 };
 
 static void default_nmi_init(void) { };
+static int default_i8042_detect(void) { return 1; };
 
 struct x86_platform_ops x86_platform = {
        .calibrate_tsc                  = native_calibrate_tsc,
@@ -92,5 +94,8 @@ struct x86_platform_ops x86_platform = {
        .set_wallclock                  = mach_set_rtc_mmss,
        .iommu_shutdown                 = iommu_shutdown_noop,
        .is_untracked_pat_range         = is_ISA_range,
-       .nmi_init                       = default_nmi_init
+       .nmi_init                       = default_nmi_init,
+       .i8042_detect                   = default_i8042_detect
 };
+
+EXPORT_SYMBOL_GPL(x86_platform);
index a6f695d76928675008a99f2030b00299856840c4..b1ed0a1a591338c801d49268c2f784477fd4a0a1 100644 (file)
@@ -1879,6 +1879,8 @@ static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *sptep,
                        pgprintk("hfn old %lx new %lx\n",
                                 spte_to_pfn(*sptep), pfn);
                        rmap_remove(vcpu->kvm, sptep);
+                       __set_spte(sptep, shadow_trap_nonpresent_pte);
+                       kvm_flush_remote_tlbs(vcpu->kvm);
                } else
                        was_rmapped = 1;
        }
@@ -2924,7 +2926,7 @@ static int kvm_mmu_remove_some_alloc_mmu_pages(struct kvm *kvm)
        return kvm_mmu_zap_page(kvm, page) + 1;
 }
 
-static int mmu_shrink(int nr_to_scan, gfp_t gfp_mask)
+static int mmu_shrink(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask)
 {
        struct kvm *kvm;
        struct kvm *kvm_freed = NULL;
index 859a01a07dbfb2937b8f0792e4a4aa0bbe50767b..ee03679efe788d61e73d76f818931d8c1a45fad2 100644 (file)
@@ -1744,18 +1744,15 @@ static void enter_lmode(struct kvm_vcpu *vcpu)
                             (guest_tr_ar & ~AR_TYPE_MASK)
                             | AR_TYPE_BUSY_64_TSS);
        }
-       vcpu->arch.efer |= EFER_LMA;
-       vmx_set_efer(vcpu, vcpu->arch.efer);
+       vmx_set_efer(vcpu, vcpu->arch.efer | EFER_LMA);
 }
 
 static void exit_lmode(struct kvm_vcpu *vcpu)
 {
-       vcpu->arch.efer &= ~EFER_LMA;
-
        vmcs_write32(VM_ENTRY_CONTROLS,
                     vmcs_read32(VM_ENTRY_CONTROLS)
                     & ~VM_ENTRY_IA32E_MODE);
-       vmx_set_efer(vcpu, vcpu->arch.efer);
+       vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA);
 }
 
 #endif
index 6fdb3ec30c3197e15fc54e18c91291f5eb403450..55253095be84c66d37c5dcaaba63bd4ebaee6df2 100644 (file)
@@ -184,6 +184,7 @@ static void __init pcibios_allocate_resources(int pass)
                                        idx, r, disabled, pass);
                                if (pci_claim_resource(dev, idx) < 0) {
                                        /* We'll assign a new address later */
+                                       dev->fw_addr[idx] = r->start;
                                        r->end -= r->start;
                                        r->start = 0;
                                }
index 7ef3a2735df39f2fdfbd4624a440e22d3e169879..cb29191cee5877824391a33de0cea9c5255f2c55 100644 (file)
@@ -66,8 +66,9 @@ static int fixed_bar_cap(struct pci_bus *bus, unsigned int devfn)
                                          devfn, pos, 4, &pcie_cap))
                        return 0;
 
-               if (pcie_cap == 0xffffffff)
-                       return 0;
+               if (PCI_EXT_CAP_ID(pcie_cap) == 0x0000 ||
+                       PCI_EXT_CAP_ID(pcie_cap) == 0xffff)
+                       break;
 
                if (PCI_EXT_CAP_ID(pcie_cap) == PCI_EXT_CAP_ID_VNDR) {
                        raw_pci_ext_ops->read(pci_domain_nr(bus), bus->number,
@@ -76,7 +77,7 @@ static int fixed_bar_cap(struct pci_bus *bus, unsigned int devfn)
                                return pos;
                }
 
-               pos = pcie_cap >> 20;
+               pos = PCI_EXT_CAP_NEXT(pcie_cap);
        }
 
        return 0;
index 98a66103f4f23b1aafaec67e66116e74e1bf0c8c..a854df2a5a4b860b223d6ad49f45255b0678e970 100644 (file)
@@ -165,7 +165,7 @@ static inline int ablkcipher_next_slow(struct ablkcipher_request *req,
 
        p = kmalloc(n, GFP_ATOMIC);
        if (!p)
-               ablkcipher_walk_done(req, walk, -ENOMEM);
+               return ablkcipher_walk_done(req, walk, -ENOMEM);
 
        base = p + 1;
 
index 5d64e3acb000ef62b08921d7f946f9fdfc2d2182..878ac0c2cc6864a84c7df230c5c12efee1944607 100644 (file)
@@ -493,7 +493,7 @@ static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
                 sysrq_key_table[i] = op_p;
 }
 
-static void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
+void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
 {
        struct sysrq_key_op *op_p;
        int orig_log_level;
index d7be69f131546b02a1784ac750e4f3dc042e10d1..b7dab32ce63cd883974ac0e9b3646d301460cc7e 100644 (file)
@@ -194,6 +194,6 @@ err_timer:
 
 module_init(cs5535_mfgpt_init);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("CS5535/CS5536 MFGPT clock event driver");
 MODULE_LICENSE("GPL");
index 637c105f53d262f904230c77b5bc5a5a5234fda7..bd78acf3c365aa1910a467f3fce882fa26c84841 100644 (file)
@@ -1183,10 +1183,14 @@ static size_t sg_copy_end_to_buffer(struct scatterlist *sgl, unsigned int nents,
                                /* Copy part of this segment */
                                ignore = skip - offset;
                                len = miter.length - ignore;
+                               if (boffset + len > buflen)
+                                       len = buflen - boffset;
                                memcpy(buf + boffset, miter.addr + ignore, len);
                        } else {
-                               /* Copy all of this segment */
+                               /* Copy all of this segment (up to buflen) */
                                len = miter.length;
+                               if (boffset + len > buflen)
+                                       len = buflen - boffset;
                                memcpy(buf + boffset, miter.addr, len);
                        }
                        boffset += len;
index aedef7941b22855f17c892f73d370ae10f17632c..0d2f9dbb47e4fa6d3d3a4440b8427fe544407af3 100644 (file)
@@ -209,7 +209,7 @@ config EDAC_I5100
 
 config EDAC_MPC85XX
        tristate "Freescale MPC83xx / MPC85xx"
-       depends on EDAC_MM_EDAC && FSL_SOC && (PPC_83xx || MPC85xx)
+       depends on EDAC_MM_EDAC && FSL_SOC && (PPC_83xx || PPC_85xx)
        help
          Support for error detection and correction on the Freescale
          MPC8349, MPC8560, MPC8540, MPC8548
index 52ca09bf4726ae9cb5984d38c79d86705c5b51f8..f39b00a46eda36c1d6e6d265e7aa02245d012556 100644 (file)
@@ -1120,6 +1120,7 @@ static struct of_device_id mpc85xx_mc_err_of_match[] = {
        { .compatible = "fsl,mpc8555-memory-controller", },
        { .compatible = "fsl,mpc8560-memory-controller", },
        { .compatible = "fsl,mpc8568-memory-controller", },
+       { .compatible = "fsl,mpc8569-memory-controller", },
        { .compatible = "fsl,mpc8572-memory-controller", },
        { .compatible = "fsl,mpc8349-memory-controller", },
        { .compatible = "fsl,p2020-memory-controller", },
index f73a1555e49d7d92fad5da024c4face448a8e114..e23c06893d19f62195247220075aafce1cfa75c0 100644 (file)
@@ -352,6 +352,6 @@ static void __exit cs5535_gpio_exit(void)
 module_init(cs5535_gpio_init);
 module_exit(cs5535_gpio_exit);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO driver");
 MODULE_LICENSE("GPL");
index 43ce3809ef6419bdefa31e8731dae359e30836ca..51bd301cf10d9002555177d95b28e86703145d67 100644 (file)
@@ -2241,6 +2241,7 @@ i915_gem_object_get_pages(struct drm_gem_object *obj,
                page = read_cache_page_gfp(mapping, i,
                                           GFP_HIGHUSER |
                                           __GFP_COLD |
+                                          __GFP_RECLAIMABLE |
                                           gfpmask);
                if (IS_ERR(page))
                        goto err_pages;
@@ -4987,7 +4988,7 @@ i915_gpu_is_active(struct drm_device *dev)
 }
 
 static int
-i915_gem_shrink(int nr_to_scan, gfp_t gfp_mask)
+i915_gem_shrink(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask)
 {
        drm_i915_private_t *dev_priv, *next_dev;
        struct drm_i915_gem_object *obj_priv, *next_obj;
index f394b3b2fadf91fd5caa088d5204ea57882579a9..ca904799f018a6e3ae23c80933bd1e007aec8f7f 100644 (file)
@@ -394,7 +394,7 @@ static int ttm_pool_get_num_unused_pages(void)
 /**
  * Callback for mm to request pool to reduce number of page held.
  */
-static int ttm_pool_mm_shrink(int shrink_pages, gfp_t gfp_mask)
+static int ttm_pool_mm_shrink(struct shrinker *shrink, int shrink_pages, gfp_t gfp_mask)
 {
        static atomic_t start_pool = ATOMIC_INIT(0);
        unsigned i;
index 0f9a4785d7980feca1cc65d5b7504906535ea5f2..3525f533e186d3f3cf0e7990d9efa4af90a66d85 100644 (file)
@@ -69,11 +69,11 @@ config KEYBOARD_ATARI
          module will be called atakbd.
 
 config KEYBOARD_ATKBD
-       tristate "AT keyboard" if EMBEDDED || !X86 || X86_MRST
+       tristate "AT keyboard" if EMBEDDED || !X86
        default y
        select SERIO
        select SERIO_LIBPS2
-       select SERIO_I8042 if X86 && !X86_MRST
+       select SERIO_I8042 if X86
        select SERIO_GSCPS2 if GSC
        help
          Say Y here if you want to use a standard AT or PS/2 keyboard. Usually
index eeb58c1cac164a65b6d2c0a15f7e40981aec16cd..c714ca2407f8a190d247f3f8eb21d96edb577ac3 100644 (file)
@@ -17,7 +17,7 @@ config MOUSE_PS2
        default y
        select SERIO
        select SERIO_LIBPS2
-       select SERIO_I8042 if X86 && !X86_MRST
+       select SERIO_I8042 if X86
        select SERIO_GSCPS2 if GSC
        help
          Say Y here if you have a PS/2 mouse connected to your system. This
index 40cea334ad13f8159d0f71057680496e42150791..9ba9c4a17e1541a48a5f8a5a90606d6d3aecb02e 100644 (file)
@@ -206,6 +206,7 @@ static int synaptics_resolution(struct psmouse *psmouse)
        unsigned char max[3];
 
        if (SYN_ID_MAJOR(priv->identity) < 4)
+               return 0;
 
        if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
                if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
index 256b9e9394dc805b2062f1e70f3f7abd24814647..3bfe8fafc6adac421577bc17c4da964537a4145f 100644 (file)
@@ -22,7 +22,7 @@ config SERIO_I8042
        tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86
        default y
        depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
-                  (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN && !X86_MRST
+                  (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN
        help
          i8042 is the chip over which the standard AT keyboard and PS/2
          mouse are connected to the computer. If you use these devices,
index 6168469ad1a69167c5fe77c5ef4ce8afedbf4be7..81003c4739f4f32351566759b9225fdfb974a7b7 100644 (file)
@@ -7,6 +7,10 @@
  * the Free Software Foundation.
  */
 
+#ifdef CONFIG_X86
+#include <asm/x86_init.h>
+#endif
+
 /*
  * Names.
  */
@@ -840,6 +844,12 @@ static int __init i8042_platform_init(void)
 {
        int retval;
 
+#ifdef CONFIG_X86
+       /* Just return if pre-detection shows no i8042 controller exist */
+       if (!x86_platform.i8042_detect())
+               return -ENODEV;
+#endif
+
 /*
  * On ix86 platforms touching the i8042 data register region can do really
  * bad things. Because of this the region is always reserved on ix86 boxes.
index cc18265be1a8f2266480f93841c0530d3e180cea..7a45d68c35166d62d2e2404d3f65644b32cea42c 100644 (file)
@@ -233,7 +233,7 @@ static int __devinit w90x900ts_probe(struct platform_device *pdev)
        w90p910_ts->state = TS_IDLE;
        spin_lock_init(&w90p910_ts->lock);
        setup_timer(&w90p910_ts->timer, w90p910_check_pen_up,
-                   (unsigned long)&w90p910_ts);
+                   (unsigned long)w90p910_ts);
 
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
index 9bec24db4d41385efe8a1c891f0a6e9daf072488..2d44b3300104eb183f902212bf281849dce00186 100644 (file)
@@ -366,6 +366,6 @@ static int __init cs5535_mfgpt_init(void)
 
 module_init(cs5535_mfgpt_init);
 
-MODULE_AUTHOR("Andres Salomon <dilinger@collabora.co.uk>");
+MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
 MODULE_DESCRIPTION("CS5535/CS5536 MFGPT timer driver");
 MODULE_LICENSE("GPL");
index af217924a76eb94511fddf7789d5d1a458a2c21b..ad30f074ee151eead0ebe435037fde70055f1d20 100644 (file)
@@ -365,6 +365,26 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
 
 static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
 {
+       struct sdhci_host *host =  platform_get_drvdata(pdev);
+       struct sdhci_s3c *sc = sdhci_priv(host);
+       int ptr;
+
+       sdhci_remove_host(host, 1);
+
+       for (ptr = 0; ptr < 3; ptr++) {
+               clk_disable(sc->clk_bus[ptr]);
+               clk_put(sc->clk_bus[ptr]);
+       }
+       clk_disable(sc->clk_io);
+       clk_put(sc->clk_io);
+
+       iounmap(host->ioaddr);
+       release_resource(sc->ioarea);
+       kfree(sc->ioarea);
+
+       sdhci_free_host(host);
+       platform_set_drvdata(pdev, NULL);
+
        return 0;
 }
 
index 7acb3edc47ef88ba62a2de614213a85518b98274..2602852cc55a6037c5160575f3620632397fcd2c 100644 (file)
@@ -677,7 +677,7 @@ static int ibmveth_close(struct net_device *netdev)
        if (!adapter->pool_config)
                netif_stop_queue(netdev);
 
-       free_irq(netdev->irq, netdev);
+       h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
 
        do {
                lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
@@ -689,6 +689,8 @@ static int ibmveth_close(struct net_device *netdev)
                                     lpar_rc);
        }
 
+       free_irq(netdev->irq, netdev);
+
        adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
 
        ibmveth_cleanup(adapter);
index 5b3dfb4ab27985cd8823c08035dd066da36e4d1c..33525bf2a3d3e87f6769ac24c65861441c375dd3 100644 (file)
@@ -1168,6 +1168,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
        int interrupts, nr_serviced = 0, i;
        struct ei_device *ei_local;
        int handled = 0;
+       unsigned long flags;
 
        e8390_base = dev->base_addr;
        ei_local = netdev_priv(dev);
@@ -1176,7 +1177,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
         *      Protect the irq test too.
         */
         
-       spin_lock(&ei_local->page_lock);
+       spin_lock_irqsave(&ei_local->page_lock, flags);
 
        if (ei_local->irqlock) 
        {
@@ -1188,7 +1189,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
                           dev->name, inb_p(e8390_base + EN0_ISR),
                           inb_p(e8390_base + EN0_IMR));
 #endif
-               spin_unlock(&ei_local->page_lock);
+               spin_unlock_irqrestore(&ei_local->page_lock, flags);
                return IRQ_NONE;
        }
     
@@ -1261,7 +1262,7 @@ static irqreturn_t ax_interrupt(int irq, void *dev_id)
        ei_local->irqlock = 0;
        outb_p(ENISR_ALL, e8390_base + EN0_IMR);
 
-       spin_unlock(&ei_local->page_lock);
+       spin_unlock_irqrestore(&ei_local->page_lock, flags);
        return IRQ_RETVAL(handled);
 }
 
index 96b6cfbf0a3a682b14216fa23a9e737a48973aaa..cdc6a5c2e70d81955efec9d3c633a593ef943b16 100644 (file)
@@ -1316,7 +1316,7 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
                { 0x7c800000, 0x28000000,       RTL_GIGA_MAC_VER_26 },
 
                /* 8168C family. */
-               { 0x7cf00000, 0x3ca00000,       RTL_GIGA_MAC_VER_24 },
+               { 0x7cf00000, 0x3cb00000,       RTL_GIGA_MAC_VER_24 },
                { 0x7cf00000, 0x3c900000,       RTL_GIGA_MAC_VER_23 },
                { 0x7cf00000, 0x3c800000,       RTL_GIGA_MAC_VER_18 },
                { 0x7c800000, 0x3c800000,       RTL_GIGA_MAC_VER_24 },
index 77b359162d6cad0a408754fff4cc8b9af64d3063..23c15aa9fbd5167c51e80601eb5213c0dd144283 100644 (file)
@@ -730,13 +730,17 @@ static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev)
 
        /* RX */
        if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0)
-               goto err;
+               goto err_rx;
 
        /* Register Read */
        if (ath9k_hif_usb_alloc_reg_in_urb(hif_dev) < 0)
-               goto err;
+               goto err_reg;
 
        return 0;
+err_reg:
+       ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
+err_rx:
+       ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
 err:
        return -ENOMEM;
 }
index d24dc7dc072328fcecab649193ed4cbad0c17caa..972a9c3af39e5e7ad11dafa354b5f7314083a985 100644 (file)
@@ -330,6 +330,7 @@ static int prism2_pci_probe(struct pci_dev *pdev,
 
         dev->irq = pdev->irq;
         hw_priv->mem_start = mem;
+       dev->base_addr = (unsigned long) mem;
 
        prism2_pci_cor_sreset(local);
 
index c2a453a1a9917e4e6bb9124b4af0318416ff0f34..dc43ebd1f1fd2eb3012c900456ec30b35b9fbbb5 100644 (file)
@@ -97,6 +97,17 @@ static inline void iwl_clear_driver_stations(struct iwl_priv *priv)
        spin_lock_irqsave(&priv->sta_lock, flags);
        memset(priv->stations, 0, sizeof(priv->stations));
        priv->num_stations = 0;
+
+       /*
+        * Remove all key information that is not stored as part of station
+        * information since mac80211 may not have had a
+        * chance to remove all the keys. When device is reconfigured by
+        * mac80211 after an error all keys will be reconfigured.
+        */
+       priv->ucode_key_table = 0;
+       priv->key_mapping_key = 0;
+       memset(priv->wep_keys, 0, sizeof(priv->wep_keys));
+
        spin_unlock_irqrestore(&priv->sta_lock, flags);
 }
 
index 3ae468c4d7604b3b8e82eac570445bdbf098ab7a..f20d3eeeea7fe0ee4001bf3597255bab1ad9856e 100644 (file)
@@ -853,6 +853,11 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
                    BIT(NL80211_IFTYPE_MESH_POINT) |
                    BIT(NL80211_IFTYPE_WDS);
 
+       /*
+        * Initialize configuration work.
+        */
+       INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
+
        /*
         * Let the driver probe the device to detect the capabilities.
         */
@@ -862,11 +867,6 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
                goto exit;
        }
 
-       /*
-        * Initialize configuration work.
-        */
-       INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
-
        /*
         * Allocate queue array.
         */
index 92379e2d37e77ed4797dba23b7402f795dec80e2..2aaa13150de3ba40fd0a65cbb569f1fe96b9a49f 100644 (file)
@@ -156,6 +156,38 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
                                             pcibios_align_resource, dev);
        }
 
+       if (ret < 0 && dev->fw_addr[resno]) {
+               struct resource *root, *conflict;
+               resource_size_t start, end;
+
+               /*
+                * If we failed to assign anything, let's try the address
+                * where firmware left it.  That at least has a chance of
+                * working, which is better than just leaving it disabled.
+                */
+
+               if (res->flags & IORESOURCE_IO)
+                       root = &ioport_resource;
+               else
+                       root = &iomem_resource;
+
+               start = res->start;
+               end = res->end;
+               res->start = dev->fw_addr[resno];
+               res->end = res->start + size - 1;
+               dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
+                        resno, res);
+               conflict = request_resource_conflict(root, res);
+               if (conflict) {
+                       dev_info(&dev->dev,
+                                "BAR %d: %pR conflicts with %s %pR\n", resno,
+                                res, conflict->name, conflict);
+                       res->start = start;
+                       res->end = end;
+               } else
+                       ret = 0;
+       }
+
        if (!ret) {
                res->flags &= ~IORESOURCE_STARTALIGN;
                dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
index 29f91fac1dff81238616a076821191e8c273e01d..a4cd9adfcbc0a543462158b76a796a7f96aa811a 100644 (file)
@@ -857,8 +857,10 @@ void pcmcia_disable_device(struct pcmcia_device *p_dev)
 {
        pcmcia_release_configuration(p_dev);
        pcmcia_release_io(p_dev, &p_dev->io);
-       if (p_dev->_irq)
+       if (p_dev->_irq) {
                free_irq(p_dev->irq, p_dev->priv);
+               p_dev->_irq = 0;
+       }
        if (p_dev->win)
                pcmcia_release_window(p_dev, p_dev->win);
 }
index 40658e3385b45346ddc91132816e28ccfee4dd84..bb2f1fba637b36ec041909a26dd176be6f472c0a 100644 (file)
@@ -489,7 +489,7 @@ int intel_scu_ipc_simple_command(int cmd, int sub)
                mutex_unlock(&ipclock);
                return -ENODEV;
        }
-       ipc_command(cmd << 12 | sub);
+       ipc_command(sub << 12 | cmd);
        err = busy_loop();
        mutex_unlock(&ipclock);
        return err;
@@ -501,9 +501,9 @@ EXPORT_SYMBOL(intel_scu_ipc_simple_command);
  *     @cmd: command
  *     @sub: sub type
  *     @in: input data
- *     @inlen: input length
+ *     @inlen: input length in dwords
  *     @out: output data
- *     @outlein: output length
+ *     @outlein: output length in dwords
  *
  *     Issue a command to the SCU which involves data transfers. Do the
  *     data copies under the lock but leave it for the caller to interpret
@@ -524,7 +524,7 @@ int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
        for (i = 0; i < inlen; i++)
                ipc_data_writel(*in++, 4 * i);
 
-       ipc_command((cmd << 12) | sub | (inlen << 18));
+       ipc_command((sub << 12) | cmd | (inlen << 18));
        err = busy_loop();
 
        for (i = 0; i < outlen; i++)
@@ -556,6 +556,10 @@ int intel_scu_ipc_i2c_cntrl(u32 addr, u32 *data)
        u32 cmd = 0;
 
        mutex_lock(&ipclock);
+       if (ipcdev.pdev == NULL) {
+               mutex_unlock(&ipclock);
+               return -ENODEV;
+       }
        cmd = (addr >> 24) & 0xFF;
        if (cmd == IPC_I2C_READ) {
                writel(addr, ipcdev.i2c_base + IPC_I2C_CNTRL_ADDR);
index d762a0cbc6af40b2c4aa58bde75e18e514fcd658..2afbeec8b7913f504a04beed44fc9ddee703c51b 100644 (file)
@@ -163,7 +163,7 @@ static int ds2782_get_capacity(struct ds278x_info *info, int *capacity)
        if (err)
                return err;
        *capacity = raw;
-       return raw;
+       return 0;
 }
 
 static int ds2786_get_current(struct ds278x_info *info, int *current_uA)
index 34d51dd4c53902d79ef3c21434db61923ee79fc8..bed7b4634ccd4648f42c188d8e5e2937534b1f8e 100644 (file)
@@ -948,8 +948,10 @@ static ssize_t dasd_alias_show(struct device *dev,
        if (device->discipline && device->discipline->get_uid &&
            !device->discipline->get_uid(device, &uid)) {
                if (uid.type == UA_BASE_PAV_ALIAS ||
-                   uid.type == UA_HYPER_PAV_ALIAS)
+                   uid.type == UA_HYPER_PAV_ALIAS) {
+                       dasd_put_device(device);
                        return sprintf(buf, "1\n");
+               }
        }
        dasd_put_device(device);
 
index ce7cb87479fe3b8aed786eeea182549da7352b35..407d0e9adfaf96a0d4362f8e56c986f0c17700fa 100644 (file)