Merge branch 'timers-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
authorLinus Torvalds <torvalds@linux-foundation.org>
Fri, 21 Jul 2017 18:18:09 +0000 (11:18 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Fri, 21 Jul 2017 18:18:09 +0000 (11:18 -0700)
Pull timer fix from Ingo Molnar:
 "A timer_irq_init() clocksource API robustness fix"

* 'timers-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  clocksource/drivers/timer-of: Handle of_irq_get_byname() result correctly

231 files changed:
Documentation/devicetree/bindings/net/brcm,amac.txt
Documentation/devicetree/bindings/net/brcm,bgmac-nsp.txt [deleted file]
Documentation/devicetree/bindings/ptp/brcm,ptp-dte.txt
MAINTAINERS
arch/arm/include/asm/bug.h
arch/arm/include/asm/cacheflush.h
arch/arm64/include/asm/bug.h
arch/blackfin/include/asm/bug.h
arch/mn10300/include/asm/bug.h
arch/parisc/include/asm/bug.h
arch/powerpc/include/asm/bug.h
arch/s390/include/asm/bug.h
arch/sh/include/asm/bug.h
arch/sparc/include/asm/trap_block.h
arch/sparc/kernel/pci_sun4v.c
arch/sparc/kernel/smp_64.c
arch/sparc/kernel/sun4v_ivec.S
arch/sparc/kernel/traps_64.c
arch/x86/events/intel/core.c
arch/x86/events/intel/cstate.c
arch/x86/events/intel/ds.c
arch/x86/events/intel/lbr.c
arch/x86/events/perf_event.h
arch/x86/include/asm/bug.h
arch/x86/include/asm/kprobes.h
arch/x86/include/asm/paravirt_types.h
arch/x86/include/asm/processor.h
drivers/acpi/nfit/core.c
drivers/atm/zatm.c
drivers/base/power/domain.c
drivers/cpufreq/intel_pstate.c
drivers/dax/device-dax.h
drivers/dax/device.c
drivers/dax/pmem.c
drivers/hid/hid-logitech-hidpp.c
drivers/hid/hid-multitouch.c
drivers/ide/ide-timings.c
drivers/infiniband/core/addr.c
drivers/infiniband/core/cma.c
drivers/infiniband/core/roce_gid_mgmt.c
drivers/infiniband/core/uverbs_cmd.c
drivers/infiniband/core/verbs.c
drivers/infiniband/hw/hfi1/chip.c
drivers/infiniband/hw/hfi1/qp.c
drivers/infiniband/hw/hfi1/qp.h
drivers/infiniband/hw/hns/hns_roce_hw_v1.c
drivers/infiniband/hw/hns/hns_roce_main.c
drivers/infiniband/hw/mlx4/cq.c
drivers/infiniband/hw/mlx4/main.c
drivers/infiniband/hw/mlx4/mcg.c
drivers/infiniband/hw/mlx4/mlx4_ib.h
drivers/infiniband/hw/mlx4/qp.c
drivers/infiniband/hw/mlx4/srq.c
drivers/infiniband/hw/mlx5/mr.c
drivers/infiniband/hw/nes/nes_hw.c
drivers/infiniband/hw/qib/qib_qp.c
drivers/infiniband/hw/qib/qib_verbs.h
drivers/infiniband/sw/rdmavt/qp.c
drivers/infiniband/sw/rxe/rxe_net.c
drivers/infiniband/sw/rxe/rxe_verbs.c
drivers/infiniband/ulp/ipoib/ipoib_cm.c
drivers/infiniband/ulp/ipoib/ipoib_ib.c
drivers/infiniband/ulp/ipoib/ipoib_main.c
drivers/infiniband/ulp/iser/iscsi_iser.c
drivers/infiniband/ulp/iser/iser_verbs.c
drivers/irqchip/irq-digicolor.c
drivers/irqchip/irq-gic-realview.c
drivers/irqchip/irq-mips-cpu.c
drivers/irqchip/irq-mips-gic.c
drivers/isdn/divert/isdn_divert.c
drivers/isdn/hardware/avm/c4.c
drivers/isdn/hardware/eicon/divasmain.c
drivers/isdn/hardware/mISDN/avmfritz.c
drivers/isdn/hardware/mISDN/hfcmulti.c
drivers/isdn/hardware/mISDN/hfcpci.c
drivers/isdn/hardware/mISDN/netjet.c
drivers/isdn/hardware/mISDN/w6692.c
drivers/isdn/hisax/config.c
drivers/isdn/hisax/hfc4s8s_l1.c
drivers/isdn/hisax/hisax_fcpcipnp.c
drivers/md/bitmap.c
drivers/md/md.h
drivers/md/raid5-ppl.c
drivers/md/raid5.c
drivers/net/bonding/bond_main.c
drivers/net/dsa/b53/b53_common.c
drivers/net/dsa/mv88e6xxx/chip.c
drivers/net/ethernet/apm/xgene/xgene_enet_main.c
drivers/net/ethernet/broadcom/bgmac-platform.c
drivers/net/ethernet/broadcom/bgmac.c
drivers/net/ethernet/broadcom/bgmac.h
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
drivers/net/ethernet/broadcom/genet/bcmgenet.c
drivers/net/ethernet/broadcom/genet/bcmgenet.h
drivers/net/ethernet/cavium/liquidio/lio_ethtool.c
drivers/net/ethernet/cavium/thunder/thunder_bgx.c
drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c
drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
drivers/net/ethernet/mellanox/mlx4/alloc.c
drivers/net/ethernet/mellanox/mlx4/cq.c
drivers/net/ethernet/mellanox/mlx4/en_rx.c
drivers/net/ethernet/mellanox/mlx4/en_tx.c
drivers/net/ethernet/mellanox/mlx4/icm.c
drivers/net/ethernet/mellanox/mlx4/icm.h
drivers/net/ethernet/mellanox/mlx4/mlx4.h
drivers/net/ethernet/mellanox/mlx4/mr.c
drivers/net/ethernet/mellanox/mlx4/qp.c
drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
drivers/net/ethernet/mellanox/mlx4/srq.c
drivers/net/ethernet/qualcomm/emac/emac.c
drivers/net/ethernet/sgi/ioc3-eth.c
drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
drivers/net/ethernet/sun/niu.c
drivers/net/ethernet/tehuti/tehuti.c
drivers/net/ethernet/ti/cpsw.c
drivers/net/phy/mdio-mux.c
drivers/net/ppp/ppp_generic.c
drivers/net/usb/cdc_ncm.c
drivers/net/usb/huawei_cdc_ncm.c
drivers/net/usb/smsc95xx.c
drivers/net/vmxnet3/vmxnet3_int.h
drivers/net/wireless/ralink/rt2x00/rt2800lib.c
drivers/nvdimm/core.c
fs/ceph/dir.c
fs/ext2/acl.c
fs/f2fs/acl.c
fs/f2fs/checkpoint.c
fs/f2fs/file.c
fs/f2fs/sysfs.c
fs/hfsplus/posix_acl.c
fs/isofs/inode.c
fs/mount.h
fs/namei.c
fs/nfsd/nfs4callback.c
fs/proc/internal.h
fs/reiserfs/xattr_acl.c
include/linux/binfmts.h
include/linux/bpf-cgroup.h
include/linux/bpf_verifier.h
include/linux/cdev.h
include/linux/ceph/ceph_features.h
include/linux/compiler-gcc.h
include/linux/compiler.h
include/linux/cred.h
include/linux/dcache.h
include/linux/fs.h
include/linux/fs_struct.h
include/linux/ipc.h
include/linux/ipc_namespace.h
include/linux/jhash.h
include/linux/key-type.h
include/linux/kmod.h
include/linux/kobject.h
include/linux/llist.h
include/linux/lsm_hooks.h
include/linux/mlx4/device.h
include/linux/mm_types.h
include/linux/module.h
include/linux/mount.h
include/linux/msg.h
include/linux/netfilter.h
include/linux/path.h
include/linux/pid_namespace.h
include/linux/proc_ns.h
include/linux/sched.h
include/linux/sched/signal.h
include/linux/sem.h
include/linux/shm.h
include/linux/sysctl.h
include/linux/tty.h
include/linux/tty_driver.h
include/linux/usb/cdc_ncm.h
include/linux/user_namespace.h
include/linux/utsname.h
include/net/af_unix.h
include/net/neighbour.h
include/net/net_namespace.h
include/net/netlink.h
include/net/sctp/sctp.h
include/net/sock.h
include/rdma/ib_verbs.h
include/rdma/rdma_vt.h
kernel/audit.c
kernel/bpf/verifier.c
kernel/events/core.c
kernel/futex.c
kernel/irq/chip.c
kernel/irq/internals.h
kernel/irq/pm.c
kernel/locking/rtmutex.c
kernel/sched/cputime.c
kernel/sched/deadline.c
net/bridge/br_device.c
net/bridge/br_input.c
net/ceph/messenger.c
net/ceph/osd_client.c
net/ceph/osdmap.c
net/core/dev_ioctl.c
net/core/fib_rules.c
net/core/filter.c
net/core/netpoll.c
net/core/rtnetlink.c
net/dccp/input.c
net/ipv4/fib_frontend.c
net/ipv4/ip_output.c
net/ipv4/netfilter/nf_tables_arp.c
net/ipv4/syncookies.c
net/ipv4/tcp_bbr.c
net/ipv4/udp.c
net/ipv6/output_core.c
net/ipv6/syncookies.c
net/netfilter/core.c
net/netfilter/nf_conntrack_expect.c
net/netfilter/nf_nat_core.c
net/netfilter/nfnetlink.c
net/openvswitch/conntrack.c
net/packet/af_packet.c
net/rds/send.c
net/sched/act_api.c
net/sctp/sm_make_chunk.c
security/keys/internal.h
tools/lib/bpf/bpf.c
tools/lib/bpf/bpf.h
tools/perf/ui/browser.c
tools/perf/util/evsel.c
tools/perf/util/machine.c
tools/testing/selftests/bpf/test_align.c
tools/testing/selftests/bpf/test_verifier.c

index 2fefa1a44afd4472f75a8fd74b73d7ae6c9083b9..ad16c1f481f77fed199e1c24bc3450aa75fbb970 100644 (file)
@@ -11,6 +11,7 @@ Required properties:
  - reg-names:  Names of the registers.
                "amac_base":    Address and length of the GMAC registers
                "idm_base":     Address and length of the GMAC IDM registers
+                               (required for NSP and Northstar2)
                "nicpm_base":   Address and length of the NIC Port Manager
                                registers (required for Northstar2)
  - interrupts: Interrupt number
diff --git a/Documentation/devicetree/bindings/net/brcm,bgmac-nsp.txt b/Documentation/devicetree/bindings/net/brcm,bgmac-nsp.txt
deleted file mode 100644 (file)
index 022946c..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-Broadcom GMAC Ethernet Controller Device Tree Bindings
--------------------------------------------------------------
-
-Required properties:
- - compatible: "brcm,bgmac-nsp"
- - reg:                Address and length of the GMAC registers,
-               Address and length of the GMAC IDM registers
- - reg-names:  Names of the registers.  Must have both "gmac_base" and
-               "idm_base"
- - interrupts: Interrupt number
-
-Optional properties:
-- mac-address: See ethernet.txt file in the same directory
-
-Examples:
-
-gmac0: ethernet@18022000 {
-       compatible = "brcm,bgmac-nsp";
-       reg = <0x18022000 0x1000>,
-             <0x18110000 0x1000>;
-       reg-names = "gmac_base", "idm_base";
-       interrupts = <GIC_SPI 147 IRQ_TYPE_LEVEL_HIGH>;
-       status = "disabled";
-};
index 07590bcdad15a9bb4f66455b29363245ac3039c4..7c04e22a5d6af016fe8198d2d6d955011abc2173 100644 (file)
@@ -1,13 +1,20 @@
-* Broadcom Digital Timing Engine(DTE) based PTP clock driver
+* Broadcom Digital Timing Engine(DTE) based PTP clock
 
 Required properties:
-- compatible: should be "brcm,ptp-dte"
+- compatible: should contain the core compatibility string
+              and the SoC compatibility string. The SoC
+              compatibility string is to handle SoC specific
+              hardware differences.
+              Core compatibility string:
+                 "brcm,ptp-dte"
+              SoC compatibility strings:
+                 "brcm,iproc-ptp-dte" - for iproc based SoC's
 - reg: address and length of the DTE block's NCO registers
 
 Example:
 
-ptp_dte: ptp_dte@180af650 {
-       compatible = "brcm,ptp-dte";
+ptp: ptp-dte@180af650 {
+       compatible = "brcm,iproc-ptp-dte", "brcm,ptp-dte";
        reg = <0x180af650 0x10>;
        status = "okay";
 };
index 205d3977ac46e1a3bf58d95b46df5db29eabc70f..2784ac59801d19b64f7c22bd5278d2e0aedb9990 100644 (file)
@@ -7730,6 +7730,7 @@ Q:        https://patchwork.kernel.org/project/linux-nvdimm/list/
 T:     git git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm.git
 S:     Supported
 F:     drivers/nvdimm/*
+F:     drivers/acpi/nfit/*
 F:     include/linux/nd.h
 F:     include/linux/libnvdimm.h
 F:     include/uapi/linux/ndctl.h
@@ -7741,7 +7742,6 @@ Q:        https://patchwork.kernel.org/project/linux-nvdimm/list/
 S:     Supported
 F:     drivers/nvdimm/blk.c
 F:     drivers/nvdimm/region_devs.c
-F:     drivers/acpi/nfit*
 
 LIBNVDIMM BTT: BLOCK TRANSLATION TABLE
 M:     Vishal Verma <vishal.l.verma@intel.com>
@@ -10684,7 +10684,6 @@ F:      drivers/ptp/*
 F:     include/linux/ptp_cl*
 
 PTRACE SUPPORT
-M:     Roland McGrath <roland@hack.frob.com>
 M:     Oleg Nesterov <oleg@redhat.com>
 S:     Maintained
 F:     include/asm-generic/syscall.h
@@ -10692,7 +10691,12 @@ F:     include/linux/ptrace.h
 F:     include/linux/regset.h
 F:     include/linux/tracehook.h
 F:     include/uapi/linux/ptrace.h
+F:     include/uapi/linux/ptrace.h
+F:     include/asm-generic/ptrace.h
 F:     kernel/ptrace.c
+F:     arch/*/ptrace*.c
+F:     arch/*/*/ptrace*.c
+F:     arch/*/include/asm/ptrace*.h
 
 PULSE8-CEC DRIVER
 M:     Hans Verkuil <hverkuil@xs4all.nl>
@@ -10868,6 +10872,14 @@ L:     linux-scsi@vger.kernel.org
 S:     Supported
 F:     drivers/scsi/qedf/
 
+QLOGIC QL4xxx RDMA DRIVER
+M:     Ram Amrani <Ram.Amrani@cavium.com>
+M:     Ariel Elior <Ariel.Elior@cavium.com>
+L:     linux-rdma@vger.kernel.org
+S:     Supported
+F:     drivers/infiniband/hw/qedr/
+F:     include/uapi/rdma/qedr-abi.h
+
 QNX4 FILESYSTEM
 M:     Anders Larsen <al@alarsen.net>
 W:     http://www.alarsen.net/linux/qnx4fs/
index 4e6e88a6b2f4ba36bcc3a0167b684a24cc58b7e9..2244a94ed9c9d30af84c2ac220c8f3c2abeb7e2b 100644 (file)
@@ -37,7 +37,7 @@ do {                                                          \
                ".pushsection .rodata.str, \"aMS\", %progbits, 1\n" \
                "2:\t.asciz " #__file "\n"                      \
                ".popsection\n"                                 \
-               ".pushsection __bug_table,\"a\"\n"              \
+               ".pushsection __bug_table,\"aw\"\n"             \
                ".align 2\n"                                    \
                "3:\t.word 1b, 2b\n"                            \
                "\t.hword " #__line ", 0\n"                     \
index d69bebf697e76d2003bb671645290c938a156abd..74504b154256e36ff4897ed1c7df43eb4d91bdef 100644 (file)
@@ -116,7 +116,7 @@ struct cpu_cache_fns {
        void (*dma_unmap_area)(const void *, size_t, int);
 
        void (*dma_flush_range)(const void *, const void *);
-};
+} __no_randomize_layout;
 
 /*
  * Select the calling method
index 366448eb0fb7ad093d1e85eec0e84126cb32aa3d..a02a57186f5689b7a3d99869d6770f7705332957 100644 (file)
@@ -36,7 +36,7 @@
 #ifdef CONFIG_GENERIC_BUG
 
 #define __BUG_ENTRY(flags)                             \
-               ".pushsection __bug_table,\"a\"\n\t"    \
+               ".pushsection __bug_table,\"aw\"\n\t"   \
                ".align 2\n\t"                          \
        "0:     .long 1f - 0b\n\t"                      \
 _BUGVERBOSE_LOCATION(__FILE__, __LINE__)               \
index 8d9b1eba89c48ad57a1437c0e19716082266cc69..76b2e82ee73095e049cb7b305e32ba659cb8b831 100644 (file)
@@ -21,7 +21,7 @@
 #define _BUG_OR_WARN(flags)                                            \
        asm volatile(                                                   \
                "1:     .hword  %0\n"                                   \
-               "       .section __bug_table,\"a\",@progbits\n"         \
+               "       .section __bug_table,\"aw\",@progbits\n"        \
                "2:     .long   1b\n"                                   \
                "       .long   %1\n"                                   \
                "       .short  %2\n"                                   \
@@ -38,7 +38,7 @@
 #define _BUG_OR_WARN(flags)                                            \
        asm volatile(                                                   \
                "1:     .hword  %0\n"                                   \
-               "       .section __bug_table,\"a\",@progbits\n"         \
+               "       .section __bug_table,\"aw\",@progbits\n"        \
                "2:     .long   1b\n"                                   \
                "       .short  %1\n"                                   \
                "       .org    2b + %2\n"                              \
index aa6a3888639144a758e88e9e157943ebd7282569..811414fb002dec95e2e2fb17251fb67934d31f50 100644 (file)
@@ -21,7 +21,7 @@ do {                                                          \
        asm volatile(                                           \
                "       syscall 15                      \n"     \
                "0:                                     \n"     \
-               "       .section __bug_table,\"a\"      \n"     \
+               "       .section __bug_table,\"aw\"     \n"     \
                "       .long 0b,%0,%1                  \n"     \
                "       .previous                       \n"     \
                :                                               \
index d2742273a685df2d243a14fd19a7b47b5a1b94a7..07ea467f22fcd50f5e6721db491e9165d417666f 100644 (file)
@@ -27,7 +27,7 @@
        do {                                                            \
                asm volatile("\n"                                       \
                             "1:\t" PARISC_BUG_BREAK_ASM "\n"           \
-                            "\t.pushsection __bug_table,\"a\"\n"       \
+                            "\t.pushsection __bug_table,\"aw\"\n"      \
                             "2:\t" ASM_WORD_INSN "1b, %c0\n"           \
                             "\t.short %c1, %c2\n"                      \
                             "\t.org 2b+%c3\n"                          \
@@ -50,7 +50,7 @@
        do {                                                            \
                asm volatile("\n"                                       \
                             "1:\t" PARISC_BUG_BREAK_ASM "\n"           \
-                            "\t.pushsection __bug_table,\"a\"\n"       \
+                            "\t.pushsection __bug_table,\"aw\"\n"      \
                             "2:\t" ASM_WORD_INSN "1b, %c0\n"           \
                             "\t.short %c1, %c2\n"                      \
                             "\t.org 2b+%c3\n"                          \
@@ -64,7 +64,7 @@
        do {                                                            \
                asm volatile("\n"                                       \
                             "1:\t" PARISC_BUG_BREAK_ASM "\n"           \
-                            "\t.pushsection __bug_table,\"a\"\n"       \
+                            "\t.pushsection __bug_table,\"aw\"\n"      \
                             "2:\t" ASM_WORD_INSN "1b\n"                \
                             "\t.short %c0\n"                           \
                             "\t.org 2b+%c1\n"                          \
index 0151af6c2a505a77c512110271e73f0c9c3fcd6e..87fcc19488177e6e15b79e1a7e5487edabe4b408 100644 (file)
@@ -18,7 +18,7 @@
 #include <asm/asm-offsets.h>
 #ifdef CONFIG_DEBUG_BUGVERBOSE
 .macro EMIT_BUG_ENTRY addr,file,line,flags
-        .section __bug_table,"a"
+        .section __bug_table,"aw"
 5001:   PPC_LONG \addr, 5002f
         .short \line, \flags
         .org 5001b+BUG_ENTRY_SIZE
@@ -29,7 +29,7 @@
 .endm
 #else
 .macro EMIT_BUG_ENTRY addr,file,line,flags
-        .section __bug_table,"a"
+        .section __bug_table,"aw"
 5001:   PPC_LONG \addr
         .short \flags
         .org 5001b+BUG_ENTRY_SIZE
    sizeof(struct bug_entry), respectively */
 #ifdef CONFIG_DEBUG_BUGVERBOSE
 #define _EMIT_BUG_ENTRY                                \
-       ".section __bug_table,\"a\"\n"          \
+       ".section __bug_table,\"aw\"\n"         \
        "2:\t" PPC_LONG "1b, %0\n"              \
        "\t.short %1, %2\n"                     \
        ".org 2b+%3\n"                          \
        ".previous\n"
 #else
 #define _EMIT_BUG_ENTRY                                \
-       ".section __bug_table,\"a\"\n"          \
+       ".section __bug_table,\"aw\"\n"         \
        "2:\t" PPC_LONG "1b\n"                  \
        "\t.short %2\n"                         \
        ".org 2b+%3\n"                          \
index 1bbd9dbfe4e0a2baac12f5a83ac4538bc8a6ca8f..ce9cc123988b975b3bf6766926b2f4f7b158e1a8 100644 (file)
@@ -14,7 +14,7 @@
                ".section .rodata.str,\"aMS\",@progbits,1\n"    \
                "2:     .asciz  \""__FILE__"\"\n"               \
                ".previous\n"                                   \
-               ".section __bug_table,\"a\"\n"                  \
+               ".section __bug_table,\"aw\"\n"                 \
                "3:     .long   1b-3b,2b-3b\n"                  \
                "       .short  %0,%1\n"                        \
                "       .org    3b+%2\n"                        \
@@ -30,7 +30,7 @@
        asm volatile(                                   \
                "0:     j       0b+2\n"                 \
                "1:\n"                                  \
-               ".section __bug_table,\"a\"\n"          \
+               ".section __bug_table,\"aw\"\n"         \
                "2:     .long   1b-2b\n"                \
                "       .short  %0\n"                   \
                "       .org    2b+%1\n"                \
index c9828f785ca0bce1f3e49a73def335bfc67eafc7..5b5086367639f0f103edd9d5f3adae0c46ba73f7 100644 (file)
  */
 #ifdef CONFIG_DEBUG_BUGVERBOSE
 #define _EMIT_BUG_ENTRY                                \
-       "\t.pushsection __bug_table,\"a\"\n"    \
+       "\t.pushsection __bug_table,\"aw\"\n"   \
        "2:\t.long 1b, %O1\n"                   \
        "\t.short %O2, %O3\n"                   \
        "\t.org 2b+%O4\n"                       \
        "\t.popsection\n"
 #else
 #define _EMIT_BUG_ENTRY                                \
-       "\t.pushsection __bug_table,\"a\"\n"    \
+       "\t.pushsection __bug_table,\"aw\"\n"   \
        "2:\t.long 1b\n"                        \
        "\t.short %O3\n"                        \
        "\t.org 2b+%O4\n"                       \
index ec9c04de3664910d81b7a55bbb09084d5e235d39..ff05992dae7a352597bf99fcd2d83500ad0c2995 100644 (file)
@@ -54,6 +54,7 @@ extern struct trap_per_cpu trap_block[NR_CPUS];
 void init_cur_cpu_trap(struct thread_info *);
 void setup_tba(void);
 extern int ncpus_probed;
+extern u64 cpu_mondo_counter[NR_CPUS];
 
 unsigned long real_hard_smp_processor_id(void);
 
index 24f21c726dfad7474da03d6a4a80f329843ff8e4..f10e2f7123949dedc8904ea37895d402ed097d2b 100644 (file)
@@ -673,12 +673,14 @@ static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist,
 static int dma_4v_supported(struct device *dev, u64 device_mask)
 {
        struct iommu *iommu = dev->archdata.iommu;
-       u64 dma_addr_mask;
+       u64 dma_addr_mask = iommu->dma_addr_mask;
 
-       if (device_mask > DMA_BIT_MASK(32) && iommu->atu)
-               dma_addr_mask = iommu->atu->dma_addr_mask;
-       else
-               dma_addr_mask = iommu->dma_addr_mask;
+       if (device_mask > DMA_BIT_MASK(32)) {
+               if (iommu->atu)
+                       dma_addr_mask = iommu->atu->dma_addr_mask;
+               else
+                       return 0;
+       }
 
        if ((device_mask & dma_addr_mask) == dma_addr_mask)
                return 1;
index fdf31040a7dc5cc460de6d60c9724a60933b38dc..3218bc43302e1cbbfc48420d868f5148a8d61085 100644 (file)
@@ -622,22 +622,48 @@ retry:
        }
 }
 
-/* Multi-cpu list version.  */
+#define        CPU_MONDO_COUNTER(cpuid)        (cpu_mondo_counter[cpuid])
+#define        MONDO_USEC_WAIT_MIN             2
+#define        MONDO_USEC_WAIT_MAX             100
+#define        MONDO_RETRY_LIMIT               500000
+
+/* Multi-cpu list version.
+ *
+ * Deliver xcalls to 'cnt' number of cpus in 'cpu_list'.
+ * Sometimes not all cpus receive the mondo, requiring us to re-send
+ * the mondo until all cpus have received, or cpus are truly stuck
+ * unable to receive mondo, and we timeout.
+ * Occasionally a target cpu strand is borrowed briefly by hypervisor to
+ * perform guest service, such as PCIe error handling. Consider the
+ * service time, 1 second overall wait is reasonable for 1 cpu.
+ * Here two in-between mondo check wait time are defined: 2 usec for
+ * single cpu quick turn around and up to 100usec for large cpu count.
+ * Deliver mondo to large number of cpus could take longer, we adjusts
+ * the retry count as long as target cpus are making forward progress.
+ */
 static void hypervisor_xcall_deliver(struct trap_per_cpu *tb, int cnt)
 {
-       int retries, this_cpu, prev_sent, i, saw_cpu_error;
+       int this_cpu, tot_cpus, prev_sent, i, rem;
+       int usec_wait, retries, tot_retries;
+       u16 first_cpu = 0xffff;
+       unsigned long xc_rcvd = 0;
        unsigned long status;
+       int ecpuerror_id = 0;
+       int enocpu_id = 0;
        u16 *cpu_list;
+       u16 cpu;
 
        this_cpu = smp_processor_id();
-
        cpu_list = __va(tb->cpu_list_pa);
-
-       saw_cpu_error = 0;
-       retries = 0;
+       usec_wait = cnt * MONDO_USEC_WAIT_MIN;
+       if (usec_wait > MONDO_USEC_WAIT_MAX)
+               usec_wait = MONDO_USEC_WAIT_MAX;
+       retries = tot_retries = 0;
+       tot_cpus = cnt;
        prev_sent = 0;
+
        do {
-               int forward_progress, n_sent;
+               int n_sent, mondo_delivered, target_cpu_busy;
 
                status = sun4v_cpu_mondo_send(cnt,
                                              tb->cpu_list_pa,
@@ -645,94 +671,113 @@ static void hypervisor_xcall_deliver(struct trap_per_cpu *tb, int cnt)
 
                /* HV_EOK means all cpus received the xcall, we're done.  */
                if (likely(status == HV_EOK))
-                       break;
+                       goto xcall_done;
+
+               /* If not these non-fatal errors, panic */
+               if (unlikely((status != HV_EWOULDBLOCK) &&
+                       (status != HV_ECPUERROR) &&
+                       (status != HV_ENOCPU)))
+                       goto fatal_errors;
 
                /* First, see if we made any forward progress.
+                *
+                * Go through the cpu_list, count the target cpus that have
+                * received our mondo (n_sent), and those that did not (rem).
+                * Re-pack cpu_list with the cpus remain to be retried in the
+                * front - this simplifies tracking the truly stalled cpus.
                 *
                 * The hypervisor indicates successful sends by setting
                 * cpu list entries to the value 0xffff.
+                *
+                * EWOULDBLOCK means some target cpus did not receive the
+                * mondo and retry usually helps.
+                *
+                * ECPUERROR means at least one target cpu is in error state,
+                * it's usually safe to skip the faulty cpu and retry.
+                *
+                * ENOCPU means one of the target cpu doesn't belong to the
+                * domain, perhaps offlined which is unexpected, but not
+                * fatal and it's okay to skip the offlined cpu.
                 */
+               rem = 0;
                n_sent = 0;
                for (i = 0; i < cnt; i++) {
-                       if (likely(cpu_list[i] == 0xffff))
+                       cpu = cpu_list[i];
+                       if (likely(cpu == 0xffff)) {
                                n_sent++;
+                       } else if ((status == HV_ECPUERROR) &&
+                               (sun4v_cpu_state(cpu) == HV_CPU_STATE_ERROR)) {
+                               ecpuerror_id = cpu + 1;
+                       } else if (status == HV_ENOCPU && !cpu_online(cpu)) {
+                               enocpu_id = cpu + 1;
+                       } else {
+                               cpu_list[rem++] = cpu;
+                       }
                }
 
-               forward_progress = 0;
-               if (n_sent > prev_sent)
-                       forward_progress = 1;
+               /* No cpu remained, we're done. */
+               if (rem == 0)
+                       break;
 
-               prev_sent = n_sent;
+               /* Otherwise, update the cpu count for retry. */
+               cnt = rem;
 
-               /* If we get a HV_ECPUERROR, then one or more of the cpus
-                * in the list are in error state.  Use the cpu_state()
-                * hypervisor call to find out which cpus are in error state.
+               /* Record the overall number of mondos received by the
+                * first of the remaining cpus.
                 */
-               if (unlikely(status == HV_ECPUERROR)) {
-                       for (i = 0; i < cnt; i++) {
-                               long err;
-                               u16 cpu;
+               if (first_cpu != cpu_list[0]) {
+                       first_cpu = cpu_list[0];
+                       xc_rcvd = CPU_MONDO_COUNTER(first_cpu);
+               }
 
-                               cpu = cpu_list[i];
-                               if (cpu == 0xffff)
-                                       continue;
+               /* Was any mondo delivered successfully? */
+               mondo_delivered = (n_sent > prev_sent);
+               prev_sent = n_sent;
 
-                               err = sun4v_cpu_state(cpu);
-                               if (err == HV_CPU_STATE_ERROR) {
-                                       saw_cpu_error = (cpu + 1);
-                                       cpu_list[i] = 0xffff;
-                               }
-                       }
-               } else if (unlikely(status != HV_EWOULDBLOCK))
-                       goto fatal_mondo_error;
+               /* or, was any target cpu busy processing other mondos? */
+               target_cpu_busy = (xc_rcvd < CPU_MONDO_COUNTER(first_cpu));
+               xc_rcvd = CPU_MONDO_COUNTER(first_cpu);
 
-               /* Don't bother rewriting the CPU list, just leave the
-                * 0xffff and non-0xffff entries in there and the
-                * hypervisor will do the right thing.
-                *
-                * Only advance timeout state if we didn't make any
-                * forward progress.
+               /* Retry count is for no progress. If we're making progress,
+                * reset the retry count.
                 */
-               if (unlikely(!forward_progress)) {
-                       if (unlikely(++retries > 10000))
-                               goto fatal_mondo_timeout;
-
-                       /* Delay a little bit to let other cpus catch up
-                        * on their cpu mondo queue work.
-                        */
-                       udelay(2 * cnt);
+               if (likely(mondo_delivered || target_cpu_busy)) {
+                       tot_retries += retries;
+                       retries = 0;
+               } else if (unlikely(retries > MONDO_RETRY_LIMIT)) {
+                       goto fatal_mondo_timeout;
                }
-       } while (1);
 
-       if (unlikely(saw_cpu_error))
-               goto fatal_mondo_cpu_error;
+               /* Delay a little bit to let other cpus catch up on
+                * their cpu mondo queue work.
+                */
+               if (!mondo_delivered)
+                       udelay(usec_wait);
 
-       return;
+               retries++;
+       } while (1);
 
-fatal_mondo_cpu_error:
-       printk(KERN_CRIT "CPU[%d]: SUN4V mondo cpu error, some target cpus "
-              "(including %d) were in error state\n",
-              this_cpu, saw_cpu_error - 1);
+xcall_done:
+       if (unlikely(ecpuerror_id > 0)) {
+               pr_crit("CPU[%d]: SUN4V mondo cpu error, target cpu(%d) was in error state\n",
+                      this_cpu, ecpuerror_id - 1);
+       } else if (unlikely(enocpu_id > 0)) {
+               pr_crit("CPU[%d]: SUN4V mondo cpu error, target cpu(%d) does not belong to the domain\n",
+                      this_cpu, enocpu_id - 1);
+       }
        return;
 
+fatal_errors:
+       /* fatal errors include bad alignment, etc */
+       pr_crit("CPU[%d]: Args were cnt(%d) cpulist_pa(%lx) mondo_block_pa(%lx)\n",
+              this_cpu, tot_cpus, tb->cpu_list_pa, tb->cpu_mondo_block_pa);
+       panic("Unexpected SUN4V mondo error %lu\n", status);
+
 fatal_mondo_timeout:
-       printk(KERN_CRIT "CPU[%d]: SUN4V mondo timeout, no forward "
-              " progress after %d retries.\n",
-              this_cpu, retries);
-       goto dump_cpu_list_and_out;
-
-fatal_mondo_error:
-       printk(KERN_CRIT "CPU[%d]: Unexpected SUN4V mondo error %lu\n",
-              this_cpu, status);
-       printk(KERN_CRIT "CPU[%d]: Args were cnt(%d) cpulist_pa(%lx) "
-              "mondo_block_pa(%lx)\n",
-              this_cpu, cnt, tb->cpu_list_pa, tb->cpu_mondo_block_pa);
-
-dump_cpu_list_and_out:
-       printk(KERN_CRIT "CPU[%d]: CPU list [ ", this_cpu);
-       for (i = 0; i < cnt; i++)
-               printk("%u ", cpu_list[i]);
-       printk("]\n");
+       /* some cpus being non-responsive to the cpu mondo */
+       pr_crit("CPU[%d]: SUN4V mondo timeout, cpu(%d) made no forward progress after %d retries. Total target cpus(%d).\n",
+              this_cpu, first_cpu, (tot_retries + retries), tot_cpus);
+       panic("SUN4V mondo timeout panic\n");
 }
 
 static void (*xcall_deliver_impl)(struct trap_per_cpu *, int);
index 559bc5e9c199232d092ec425d705a016b639db9a..34631995859afb2c273f3087796ff550371bc634 100644 (file)
@@ -26,6 +26,21 @@ sun4v_cpu_mondo:
        ldxa    [%g0] ASI_SCRATCHPAD, %g4
        sub     %g4, TRAP_PER_CPU_FAULT_INFO, %g4
 
+       /* Get smp_processor_id() into %g3 */
+       sethi   %hi(trap_block), %g5
+       or      %g5, %lo(trap_block), %g5
+       sub     %g4, %g5, %g3
+       srlx    %g3, TRAP_BLOCK_SZ_SHIFT, %g3
+
+       /* Increment cpu_mondo_counter[smp_processor_id()] */
+       sethi   %hi(cpu_mondo_counter), %g5
+       or      %g5, %lo(cpu_mondo_counter), %g5
+       sllx    %g3, 3, %g3
+       add     %g5, %g3, %g5
+       ldx     [%g5], %g3
+       add     %g3, 1, %g3
+       stx     %g3, [%g5]
+
        /* Get CPU mondo queue base phys address into %g7.  */
        ldx     [%g4 + TRAP_PER_CPU_CPU_MONDO_PA], %g7
 
index 196ee5eb4d489b156d677f079f545e6ff792289d..ad31af1dd726575986c87bba514b345f291342ec 100644 (file)
@@ -2733,6 +2733,7 @@ void do_getpsr(struct pt_regs *regs)
        }
 }
 
+u64 cpu_mondo_counter[NR_CPUS] = {0};
 struct trap_per_cpu trap_block[NR_CPUS];
 EXPORT_SYMBOL(trap_block);
 
index aa62437d1aa142a3960804d44ad48e6f08e44eb8..98b0f072952735da9928970093ac1857bb9a932a 100644 (file)
@@ -1708,6 +1708,120 @@ static __initconst const u64 glm_hw_cache_extra_regs
        },
 };
 
+static __initconst const u64 glp_hw_cache_event_ids
+                               [PERF_COUNT_HW_CACHE_MAX]
+                               [PERF_COUNT_HW_CACHE_OP_MAX]
+                               [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
+       [C(L1D)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x81d0,       /* MEM_UOPS_RETIRED.ALL_LOADS */
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = 0x82d0,       /* MEM_UOPS_RETIRED.ALL_STORES */
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = 0x0,
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+       },
+       [C(L1I)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x0380,       /* ICACHE.ACCESSES */
+                       [C(RESULT_MISS)]        = 0x0280,       /* ICACHE.MISSES */
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = -1,
+                       [C(RESULT_MISS)]        = -1,
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = 0x0,
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+       },
+       [C(LL)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x1b7,        /* OFFCORE_RESPONSE */
+                       [C(RESULT_MISS)]        = 0x1b7,        /* OFFCORE_RESPONSE */
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = 0x1b7,        /* OFFCORE_RESPONSE */
+                       [C(RESULT_MISS)]        = 0x1b7,        /* OFFCORE_RESPONSE */
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = 0x0,
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+       },
+       [C(DTLB)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x81d0,       /* MEM_UOPS_RETIRED.ALL_LOADS */
+                       [C(RESULT_MISS)]        = 0xe08,        /* DTLB_LOAD_MISSES.WALK_COMPLETED */
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = 0x82d0,       /* MEM_UOPS_RETIRED.ALL_STORES */
+                       [C(RESULT_MISS)]        = 0xe49,        /* DTLB_STORE_MISSES.WALK_COMPLETED */
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = 0x0,
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+       },
+       [C(ITLB)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x00c0,       /* INST_RETIRED.ANY_P */
+                       [C(RESULT_MISS)]        = 0x0481,       /* ITLB.MISS */
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = -1,
+                       [C(RESULT_MISS)]        = -1,
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = -1,
+                       [C(RESULT_MISS)]        = -1,
+               },
+       },
+       [C(BPU)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = 0x00c4,       /* BR_INST_RETIRED.ALL_BRANCHES */
+                       [C(RESULT_MISS)]        = 0x00c5,       /* BR_MISP_RETIRED.ALL_BRANCHES */
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = -1,
+                       [C(RESULT_MISS)]        = -1,
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = -1,
+                       [C(RESULT_MISS)]        = -1,
+               },
+       },
+};
+
+static __initconst const u64 glp_hw_cache_extra_regs
+                               [PERF_COUNT_HW_CACHE_MAX]
+                               [PERF_COUNT_HW_CACHE_OP_MAX]
+                               [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
+       [C(LL)] = {
+               [C(OP_READ)] = {
+                       [C(RESULT_ACCESS)]      = GLM_DEMAND_READ|
+                                                 GLM_LLC_ACCESS,
+                       [C(RESULT_MISS)]        = GLM_DEMAND_READ|
+                                                 GLM_LLC_MISS,
+               },
+               [C(OP_WRITE)] = {
+                       [C(RESULT_ACCESS)]      = GLM_DEMAND_WRITE|
+                                                 GLM_LLC_ACCESS,
+                       [C(RESULT_MISS)]        = GLM_DEMAND_WRITE|
+                                                 GLM_LLC_MISS,
+               },
+               [C(OP_PREFETCH)] = {
+                       [C(RESULT_ACCESS)]      = 0x0,
+                       [C(RESULT_MISS)]        = 0x0,
+               },
+       },
+};
+
 #define KNL_OT_L2_HITE         BIT_ULL(19) /* Other Tile L2 Hit */
 #define KNL_OT_L2_HITF         BIT_ULL(20) /* Other Tile L2 Hit */
 #define KNL_MCDRAM_LOCAL       BIT_ULL(21)
@@ -3016,6 +3130,9 @@ static int hsw_hw_config(struct perf_event *event)
        return 0;
 }
 
+static struct event_constraint counter0_constraint =
+                       INTEL_ALL_EVENT_CONSTRAINT(0, 0x1);
+
 static struct event_constraint counter2_constraint =
                        EVENT_CONSTRAINT(0, 0x4, 0);
 
@@ -3037,6 +3154,21 @@ hsw_get_event_constraints(struct cpu_hw_events *cpuc, int idx,
        return c;
 }
 
+static struct event_constraint *
+glp_get_event_constraints(struct cpu_hw_events *cpuc, int idx,
+                         struct perf_event *event)
+{
+       struct event_constraint *c;
+
+       /* :ppp means to do reduced skid PEBS which is PMC0 only. */
+       if (event->attr.precise_ip == 3)
+               return &counter0_constraint;
+
+       c = intel_get_event_constraints(cpuc, idx, event);
+
+       return c;
+}
+
 /*
  * Broadwell:
  *
@@ -3265,10 +3397,8 @@ static void intel_pmu_cpu_dying(int cpu)
 static void intel_pmu_sched_task(struct perf_event_context *ctx,
                                 bool sched_in)
 {
-       if (x86_pmu.pebs_active)
-               intel_pmu_pebs_sched_task(ctx, sched_in);
-       if (x86_pmu.lbr_nr)
-               intel_pmu_lbr_sched_task(ctx, sched_in);
+       intel_pmu_pebs_sched_task(ctx, sched_in);
+       intel_pmu_lbr_sched_task(ctx, sched_in);
 }
 
 PMU_FORMAT_ATTR(offcore_rsp, "config1:0-63");
@@ -3838,6 +3968,32 @@ __init int intel_pmu_init(void)
                pr_cont("Goldmont events, ");
                break;
 
+       case INTEL_FAM6_ATOM_GEMINI_LAKE:
+               memcpy(hw_cache_event_ids, glp_hw_cache_event_ids,
+                      sizeof(hw_cache_event_ids));
+               memcpy(hw_cache_extra_regs, glp_hw_cache_extra_regs,
+                      sizeof(hw_cache_extra_regs));
+
+               intel_pmu_lbr_init_skl();
+
+               x86_pmu.event_constraints = intel_slm_event_constraints;
+               x86_pmu.pebs_constraints = intel_glp_pebs_event_constraints;
+               x86_pmu.extra_regs = intel_glm_extra_regs;
+               /*
+                * It's recommended to use CPU_CLK_UNHALTED.CORE_P + NPEBS
+                * for precise cycles.
+                */
+               x86_pmu.pebs_aliases = NULL;
+               x86_pmu.pebs_prec_dist = true;
+               x86_pmu.lbr_pt_coexist = true;
+               x86_pmu.flags |= PMU_FL_HAS_RSP_1;
+               x86_pmu.get_event_constraints = glp_get_event_constraints;
+               x86_pmu.cpu_events = glm_events_attrs;
+               /* Goldmont Plus has 4-wide pipeline */
+               event_attr_td_total_slots_scale_glm.event_str = "4";
+               pr_cont("Goldmont plus events, ");
+               break;
+
        case INTEL_FAM6_WESTMERE:
        case INTEL_FAM6_WESTMERE_EP:
        case INTEL_FAM6_WESTMERE_EX:
index 238ae3248ba5594265f14ef37ee6fde5c320675a..4cf100ff2a3746f440049dd5c27c254e4dcc1776 100644 (file)
  * Model specific counters:
  *     MSR_CORE_C1_RES: CORE C1 Residency Counter
  *                      perf code: 0x00
- *                      Available model: SLM,AMT
+ *                      Available model: SLM,AMT,GLM
  *                      Scope: Core (each processor core has a MSR)
  *     MSR_CORE_C3_RESIDENCY: CORE C3 Residency Counter
  *                            perf code: 0x01
- *                            Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL
+ *                            Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,GLM
  *                            Scope: Core
  *     MSR_CORE_C6_RESIDENCY: CORE C6 Residency Counter
  *                            perf code: 0x02
  *                            Available model: SLM,AMT,NHM,WSM,SNB,IVB,HSW,BDW
- *                                             SKL,KNL
+ *                                             SKL,KNL,GLM
  *                            Scope: Core
  *     MSR_CORE_C7_RESIDENCY: CORE C7 Residency Counter
  *                            perf code: 0x03
  *                            Scope: Core
  *     MSR_PKG_C2_RESIDENCY:  Package C2 Residency Counter.
  *                            perf code: 0x00
- *                            Available model: SNB,IVB,HSW,BDW,SKL,KNL
+ *                            Available model: SNB,IVB,HSW,BDW,SKL,KNL,GLM
  *                            Scope: Package (physical package)
  *     MSR_PKG_C3_RESIDENCY:  Package C3 Residency Counter.
  *                            perf code: 0x01
  *                            Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,KNL
+ *                                             GLM
  *                            Scope: Package (physical package)
  *     MSR_PKG_C6_RESIDENCY:  Package C6 Residency Counter.
  *                            perf code: 0x02
  *                            Available model: SLM,AMT,NHM,WSM,SNB,IVB,HSW,BDW
- *                                             SKL,KNL
+ *                                             SKL,KNL,GLM
  *                            Scope: Package (physical package)
  *     MSR_PKG_C7_RESIDENCY:  Package C7 Residency Counter.
  *                            perf code: 0x03
@@ -82,7 +83,7 @@
  *                            Scope: Package (physical package)
  *     MSR_PKG_C10_RESIDENCY: Package C10 Residency Counter.
  *                            perf code: 0x06
- *                            Available model: HSW ULT only
+ *                            Available model: HSW ULT, GLM
  *                            Scope: Package (physical package)
  *
  */
@@ -504,6 +505,17 @@ static const struct cstate_model knl_cstates __initconst = {
 };
 
 
+static const struct cstate_model glm_cstates __initconst = {
+       .core_events            = BIT(PERF_CSTATE_CORE_C1_RES) |
+                                 BIT(PERF_CSTATE_CORE_C3_RES) |
+                                 BIT(PERF_CSTATE_CORE_C6_RES),
+
+       .pkg_events             = BIT(PERF_CSTATE_PKG_C2_RES) |
+                                 BIT(PERF_CSTATE_PKG_C3_RES) |
+                                 BIT(PERF_CSTATE_PKG_C6_RES) |
+                                 BIT(PERF_CSTATE_PKG_C10_RES),
+};
+
 
 #define X86_CSTATES_MODEL(model, states)                               \
        { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, (unsigned long) &(states) }
@@ -546,6 +558,8 @@ static const struct x86_cpu_id intel_cstates_match[] __initconst = {
 
        X86_CSTATES_MODEL(INTEL_FAM6_XEON_PHI_KNL, knl_cstates),
        X86_CSTATES_MODEL(INTEL_FAM6_XEON_PHI_KNM, knl_cstates),
+
+       X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT, glm_cstates),
        { },
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_cstates_match);
index c6d23ffe422d110bf91483427a6198e6dd0eaad4..a322fed5f8edcab18401e2745438c362f80e0851 100644 (file)
@@ -606,12 +606,6 @@ static inline void intel_pmu_drain_pebs_buffer(void)
        x86_pmu.drain_pebs(&regs);
 }
 
-void intel_pmu_pebs_sched_task(struct perf_event_context *ctx, bool sched_in)
-{
-       if (!sched_in)
-               intel_pmu_drain_pebs_buffer();
-}
-
 /*
  * PEBS
  */
@@ -651,6 +645,12 @@ struct event_constraint intel_glm_pebs_event_constraints[] = {
        EVENT_CONSTRAINT_END
 };
 
+struct event_constraint intel_glp_pebs_event_constraints[] = {
+       /* Allow all events as PEBS with no flags */
+       INTEL_ALL_EVENT_CONSTRAINT(0, 0xf),
+       EVENT_CONSTRAINT_END
+};
+
 struct event_constraint intel_nehalem_pebs_event_constraints[] = {
        INTEL_PLD_CONSTRAINT(0x100b, 0xf),      /* MEM_INST_RETIRED.* */
        INTEL_FLAGS_EVENT_CONSTRAINT(0x0f, 0xf),    /* MEM_UNCORE_RETIRED.* */
@@ -816,6 +816,14 @@ static inline bool pebs_needs_sched_cb(struct cpu_hw_events *cpuc)
        return cpuc->n_pebs && (cpuc->n_pebs == cpuc->n_large_pebs);
 }
 
+void intel_pmu_pebs_sched_task(struct perf_event_context *ctx, bool sched_in)
+{
+       struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
+
+       if (!sched_in && pebs_needs_sched_cb(cpuc))
+               intel_pmu_drain_pebs_buffer();
+}
+
 static inline void pebs_update_threshold(struct cpu_hw_events *cpuc)
 {
        struct debug_store *ds = cpuc->ds;
@@ -889,6 +897,8 @@ void intel_pmu_pebs_enable(struct perf_event *event)
        if (hwc->flags & PERF_X86_EVENT_AUTO_RELOAD) {
                ds->pebs_event_reset[hwc->idx] =
                        (u64)(-hwc->sample_period) & x86_pmu.cntval_mask;
+       } else {
+               ds->pebs_event_reset[hwc->idx] = 0;
        }
 }
 
index eb261656a320d52cd428e7ecdac34b62474ba20a..955457a30197e8be224f0304ec83f14365b3fba9 100644 (file)
@@ -380,8 +380,12 @@ static void __intel_pmu_lbr_save(struct x86_perf_task_context *task_ctx)
 
 void intel_pmu_lbr_sched_task(struct perf_event_context *ctx, bool sched_in)
 {
+       struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
        struct x86_perf_task_context *task_ctx;
 
+       if (!cpuc->lbr_users)
+               return;
+
        /*
         * If LBR callstack feature is enabled and the stack was saved when
         * the task was scheduled out, restore the stack. Otherwise flush
index 53728eea1bedea1562715228404d2efaa7f030a4..476aec3a4cabd3852be09731a69f6c5f3c28948b 100644 (file)
@@ -879,6 +879,8 @@ extern struct event_constraint intel_slm_pebs_event_constraints[];
 
 extern struct event_constraint intel_glm_pebs_event_constraints[];
 
+extern struct event_constraint intel_glp_pebs_event_constraints[];
+
 extern struct event_constraint intel_nehalem_pebs_event_constraints[];
 
 extern struct event_constraint intel_westmere_pebs_event_constraints[];
index 39e702d90cdbdda8df0b42349d9f8d262b08bf4d..aa6b2023d8f8bc104e0b30a086a4c981ed47abb1 100644 (file)
@@ -35,7 +35,7 @@
 #define _BUG_FLAGS(ins, flags)                                         \
 do {                                                                   \
        asm volatile("1:\t" ins "\n"                                    \
-                    ".pushsection __bug_table,\"a\"\n"                 \
+                    ".pushsection __bug_table,\"aw\"\n"                \
                     "2:\t" __BUG_REL(1b) "\t# bug_entry::bug_addr\n"   \
                     "\t"  __BUG_REL(%c0) "\t# bug_entry::file\n"       \
                     "\t.word %c1"        "\t# bug_entry::line\n"       \
@@ -52,7 +52,7 @@ do {                                                                  \
 #define _BUG_FLAGS(ins, flags)                                         \
 do {                                                                   \
        asm volatile("1:\t" ins "\n"                                    \
-                    ".pushsection __bug_table,\"a\"\n"                 \
+                    ".pushsection __bug_table,\"aw\"\n"                \
                     "2:\t" __BUG_REL(1b) "\t# bug_entry::bug_addr\n"   \
                     "\t.word %c0"        "\t# bug_entry::flags\n"      \
                     "\t.org 2b+%c1\n"                                  \
index 34b984c607903751f867b85d962457f7ea04776b..6cf65437b5e502194c9f4a354f755ee7b2a39102 100644 (file)
@@ -52,10 +52,10 @@ typedef u8 kprobe_opcode_t;
 #define flush_insn_slot(p)     do { } while (0)
 
 /* optinsn template addresses */
-extern __visible kprobe_opcode_t optprobe_template_entry;
-extern __visible kprobe_opcode_t optprobe_template_val;
-extern __visible kprobe_opcode_t optprobe_template_call;
-extern __visible kprobe_opcode_t optprobe_template_end;
+extern __visible kprobe_opcode_t optprobe_template_entry[];
+extern __visible kprobe_opcode_t optprobe_template_val[];
+extern __visible kprobe_opcode_t optprobe_template_call[];
+extern __visible kprobe_opcode_t optprobe_template_end[];
 #define MAX_OPTIMIZED_LENGTH (MAX_INSN_SIZE + RELATIVE_ADDR_SIZE)
 #define MAX_OPTINSN_SIZE                               \
        (((unsigned long)&optprobe_template_end -       \
index cb976bab62996332f8b808ebaa18315d35005679..9ffc36bfe4cddfb96a019ceea43c074a9be682de 100644 (file)
@@ -84,7 +84,7 @@ struct pv_init_ops {
         */
        unsigned (*patch)(u8 type, u16 clobber, void *insnbuf,
                          unsigned long addr, unsigned len);
-};
+} __no_randomize_layout;
 
 
 struct pv_lazy_ops {
@@ -92,12 +92,12 @@ struct pv_lazy_ops {
        void (*enter)(void);
        void (*leave)(void);
        void (*flush)(void);
-};
+} __no_randomize_layout;
 
 struct pv_time_ops {
        unsigned long long (*sched_clock)(void);
        unsigned long long (*steal_clock)(int cpu);
-};
+} __no_randomize_layout;
 
 struct pv_cpu_ops {
        /* hooks for various privileged instructions */
@@ -176,7 +176,7 @@ struct pv_cpu_ops {
 
        void (*start_context_switch)(struct task_struct *prev);
        void (*end_context_switch)(struct task_struct *next);
-};
+} __no_randomize_layout;
 
 struct pv_irq_ops {
        /*
@@ -199,7 +199,7 @@ struct pv_irq_ops {
 #ifdef CONFIG_X86_64
        void (*adjust_exception_frame)(void);
 #endif
-};
+} __no_randomize_layout;
 
 struct pv_mmu_ops {
        unsigned long (*read_cr2)(void);
@@ -305,7 +305,7 @@ struct pv_mmu_ops {
           an mfn.  We can tell which is which from the index. */
        void (*set_fixmap)(unsigned /* enum fixed_addresses */ idx,
                           phys_addr_t phys, pgprot_t flags);
-};
+} __no_randomize_layout;
 
 struct arch_spinlock;
 #ifdef CONFIG_SMP
@@ -322,7 +322,7 @@ struct pv_lock_ops {
        void (*kick)(int cpu);
 
        struct paravirt_callee_save vcpu_is_preempted;
-};
+} __no_randomize_layout;
 
 /* This contains all the paravirt structures: we get a convenient
  * number for each function using the offset which we use to indicate
@@ -334,7 +334,7 @@ struct paravirt_patch_template {
        struct pv_irq_ops pv_irq_ops;
        struct pv_mmu_ops pv_mmu_ops;
        struct pv_lock_ops pv_lock_ops;
-};
+} __no_randomize_layout;
 
 extern struct pv_info pv_info;
 extern struct pv_init_ops pv_init_ops;
index 6a79547e8ee01e06a84cc948f0d9a61002cdda82..028245e1c42b23d1498643427ebb73be25ded661 100644 (file)
@@ -129,7 +129,7 @@ struct cpuinfo_x86 {
        /* Index into per_cpu list: */
        u16                     cpu_index;
        u32                     microcode;
-};
+} __randomize_layout;
 
 struct cpuid_regs {
        u32 eax, ebx, ecx, edx;
index b75b734ee73addc621c26710d8dfed1cbbe05fba..19182d091587382e0b94e9354f9c442ea90624a3 100644 (file)
@@ -3160,6 +3160,8 @@ static struct acpi_driver acpi_nfit_driver = {
 
 static __init int nfit_init(void)
 {
+       int ret;
+
        BUILD_BUG_ON(sizeof(struct acpi_table_nfit) != 40);
        BUILD_BUG_ON(sizeof(struct acpi_nfit_system_address) != 56);
        BUILD_BUG_ON(sizeof(struct acpi_nfit_memory_map) != 48);
@@ -3187,8 +3189,14 @@ static __init int nfit_init(void)
                return -ENOMEM;
 
        nfit_mce_register();
+       ret = acpi_bus_register_driver(&acpi_nfit_driver);
+       if (ret) {
+               nfit_mce_unregister();
+               destroy_workqueue(nfit_wq);
+       }
+
+       return ret;
 
-       return acpi_bus_register_driver(&acpi_nfit_driver);
 }
 
 static __exit void nfit_exit(void)
index 292dec18ffb87acf57842f3a0c2490b326488e12..07bdd51b3b9aab2e82e79346f52f6eb1bf4d9cbe 100644 (file)
@@ -1613,7 +1613,7 @@ static int zatm_init_one(struct pci_dev *pci_dev,
 
        ret = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32));
        if (ret < 0)
-               goto out_disable;
+               goto out_release;
 
        zatm_dev->pci_dev = pci_dev;
        dev->dev_data = zatm_dev;
index 3b8210ebb50ebfd1844622a883193fecdacaa282..60303aa28587b9079317a8fc3500ef1aa70ec247 100644 (file)
@@ -1222,8 +1222,6 @@ static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,
 
        spin_unlock_irq(&dev->power.lock);
 
-       dev_pm_domain_set(dev, &genpd->domain);
-
        return gpd_data;
 
  err_free:
@@ -1237,8 +1235,6 @@ static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,
 static void genpd_free_dev_data(struct device *dev,
                                struct generic_pm_domain_data *gpd_data)
 {
-       dev_pm_domain_set(dev, NULL);
-
        spin_lock_irq(&dev->power.lock);
 
        dev->power.subsys_data->domain_data = NULL;
@@ -1275,6 +1271,8 @@ static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
        if (ret)
                goto out;
 
+       dev_pm_domain_set(dev, &genpd->domain);
+
        genpd->device_count++;
        genpd->max_off_time_changed = true;
 
@@ -1336,6 +1334,8 @@ static int genpd_remove_device(struct generic_pm_domain *genpd,
        if (genpd->detach_dev)
                genpd->detach_dev(genpd, dev);
 
+       dev_pm_domain_set(dev, NULL);
+
        list_del_init(&pdd->list_node);
 
        genpd_unlock(genpd);
index b7fb8b7c980dc5d2eb2001e4790910cb5b399514..6cd50352563894bea24866d2d36d6b815d0abc20 100644 (file)
@@ -225,6 +225,9 @@ struct global_params {
  * @vid:               Stores VID limits for this CPU
  * @pid:               Stores PID parameters for this CPU
  * @last_sample_time:  Last Sample time
+ * @aperf_mperf_shift: Number of clock cycles after aperf, merf is incremented
+ *                     This shift is a multiplier to mperf delta to
+ *                     calculate CPU busy.
  * @prev_aperf:                Last APERF value read from APERF MSR
  * @prev_mperf:                Last MPERF value read from MPERF MSR
  * @prev_tsc:          Last timestamp counter (TSC) value
@@ -259,6 +262,7 @@ struct cpudata {
 
        u64     last_update;
        u64     last_sample_time;
+       u64     aperf_mperf_shift;
        u64     prev_aperf;
        u64     prev_mperf;
        u64     prev_tsc;
@@ -321,6 +325,7 @@ struct pstate_funcs {
        int (*get_min)(void);
        int (*get_turbo)(void);
        int (*get_scaling)(void);
+       int (*get_aperf_mperf_shift)(void);
        u64 (*get_val)(struct cpudata*, int pstate);
        void (*get_vid)(struct cpudata *);
        void (*update_util)(struct update_util_data *data, u64 time,
@@ -1486,6 +1491,11 @@ static u64 core_get_val(struct cpudata *cpudata, int pstate)
        return val;
 }
 
+static int knl_get_aperf_mperf_shift(void)
+{
+       return 10;
+}
+
 static int knl_get_turbo_pstate(void)
 {
        u64 value;
@@ -1543,6 +1553,9 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
        cpu->pstate.max_freq = cpu->pstate.max_pstate * cpu->pstate.scaling;
        cpu->pstate.turbo_freq = cpu->pstate.turbo_pstate * cpu->pstate.scaling;
 
+       if (pstate_funcs.get_aperf_mperf_shift)
+               cpu->aperf_mperf_shift = pstate_funcs.get_aperf_mperf_shift();
+
        if (pstate_funcs.get_vid)
                pstate_funcs.get_vid(cpu);
 
@@ -1616,7 +1629,8 @@ static inline int32_t get_target_pstate_use_cpu_load(struct cpudata *cpu)
        int32_t busy_frac, boost;
        int target, avg_pstate;
 
-       busy_frac = div_fp(sample->mperf, sample->tsc);
+       busy_frac = div_fp(sample->mperf << cpu->aperf_mperf_shift,
+                          sample->tsc);
 
        boost = cpu->iowait_boost;
        cpu->iowait_boost >>= 1;
@@ -1675,7 +1689,8 @@ static inline int32_t get_target_pstate_use_performance(struct cpudata *cpu)
                sample_ratio = div_fp(pid_params.sample_rate_ns, duration_ns);
                perf_scaled = mul_fp(perf_scaled, sample_ratio);
        } else {
-               sample_ratio = div_fp(100 * cpu->sample.mperf, cpu->sample.tsc);
+               sample_ratio = div_fp(100 * (cpu->sample.mperf << cpu->aperf_mperf_shift),
+                                     cpu->sample.tsc);
                if (sample_ratio < int_tofp(1))
                        perf_scaled = 0;
        }
@@ -1807,6 +1822,7 @@ static const struct pstate_funcs knl_funcs = {
        .get_max_physical = core_get_max_pstate_physical,
        .get_min = core_get_min_pstate,
        .get_turbo = knl_get_turbo_pstate,
+       .get_aperf_mperf_shift = knl_get_aperf_mperf_shift,
        .get_scaling = core_get_scaling,
        .get_val = core_get_val,
        .update_util = intel_pstate_update_util_pid,
@@ -2403,6 +2419,7 @@ static void __init copy_cpu_funcs(struct pstate_funcs *funcs)
        pstate_funcs.get_val   = funcs->get_val;
        pstate_funcs.get_vid   = funcs->get_vid;
        pstate_funcs.update_util = funcs->update_util;
+       pstate_funcs.get_aperf_mperf_shift = funcs->get_aperf_mperf_shift;
 
        intel_pstate_use_acpi_profile();
 }
index fdcd9769ffded4eb4885bf20735e4fd60ca761e8..688b051750bd7cc615849491605bc0ecf50d9101 100644 (file)
@@ -21,5 +21,5 @@ struct dax_region *alloc_dax_region(struct device *parent,
                int region_id, struct resource *res, unsigned int align,
                void *addr, unsigned long flags);
 struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
-               struct resource *res, int count);
+               int id, struct resource *res, int count);
 #endif /* __DEVICE_DAX_H__ */
index 12943d19bfc43ea17e6f2f92419c5a52ffa35f44..e9f3b3e4bbf45805d5288ad0d3ee03243c2a1af0 100644 (file)
@@ -529,7 +529,8 @@ static void dev_dax_release(struct device *dev)
        struct dax_region *dax_region = dev_dax->region;
        struct dax_device *dax_dev = dev_dax->dax_dev;
 
-       ida_simple_remove(&dax_region->ida, dev_dax->id);
+       if (dev_dax->id >= 0)
+               ida_simple_remove(&dax_region->ida, dev_dax->id);
        dax_region_put(dax_region);
        put_dax(dax_dev);
        kfree(dev_dax);
@@ -559,7 +560,7 @@ static void unregister_dev_dax(void *dev)
 }
 
 struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
-               struct resource *res, int count)
+               int id, struct resource *res, int count)
 {
        struct device *parent = dax_region->dev;
        struct dax_device *dax_dev;
@@ -567,7 +568,10 @@ struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
        struct inode *inode;
        struct device *dev;
        struct cdev *cdev;
-       int rc = 0, i;
+       int rc, i;
+
+       if (!count)
+               return ERR_PTR(-EINVAL);
 
        dev_dax = kzalloc(sizeof(*dev_dax) + sizeof(*res) * count, GFP_KERNEL);
        if (!dev_dax)
@@ -587,10 +591,16 @@ struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
        if (i < count)
                goto err_id;
 
-       dev_dax->id = ida_simple_get(&dax_region->ida, 0, 0, GFP_KERNEL);
-       if (dev_dax->id < 0) {
-               rc = dev_dax->id;
-               goto err_id;
+       if (id < 0) {
+               id = ida_simple_get(&dax_region->ida, 0, 0, GFP_KERNEL);
+               dev_dax->id = id;
+               if (id < 0) {
+                       rc = id;
+                       goto err_id;
+               }
+       } else {
+               /* region provider owns @id lifetime */
+               dev_dax->id = -1;
        }
 
        /*
@@ -598,8 +608,10 @@ struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
         * device outside of mmap of the resulting character device.
         */
        dax_dev = alloc_dax(dev_dax, NULL, NULL);
-       if (!dax_dev)
+       if (!dax_dev) {
+               rc = -ENOMEM;
                goto err_dax;
+       }
 
        /* from here on we're committed to teardown via dax_dev_release() */
        dev = &dev_dax->dev;
@@ -620,7 +632,7 @@ struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
        dev->parent = parent;
        dev->groups = dax_attribute_groups;
        dev->release = dev_dax_release;
-       dev_set_name(dev, "dax%d.%d", dax_region->id, dev_dax->id);
+       dev_set_name(dev, "dax%d.%d", dax_region->id, id);
 
        rc = cdev_device_add(cdev, dev);
        if (rc) {
@@ -636,7 +648,8 @@ struct dev_dax *devm_create_dev_dax(struct dax_region *dax_region,
        return dev_dax;
 
  err_dax:
-       ida_simple_remove(&dax_region->ida, dev_dax->id);
+       if (dev_dax->id >= 0)
+               ida_simple_remove(&dax_region->ida, dev_dax->id);
  err_id:
        kfree(dev_dax);
 
index 9f2a0b4fd8012c05b79a561ee4c2711e64c17fa5..8d8c852ba8f209c5118987aa2dbb98cf3290d213 100644 (file)
@@ -58,13 +58,12 @@ static void dax_pmem_percpu_kill(void *data)
 
 static int dax_pmem_probe(struct device *dev)
 {
-       int rc;
        void *addr;
        struct resource res;
+       int rc, id, region_id;
        struct nd_pfn_sb *pfn_sb;
        struct dev_dax *dev_dax;
        struct dax_pmem *dax_pmem;
-       struct nd_region *nd_region;
        struct nd_namespace_io *nsio;
        struct dax_region *dax_region;
        struct nd_namespace_common *ndns;
@@ -123,14 +122,17 @@ static int dax_pmem_probe(struct device *dev)
        /* adjust the dax_region resource to the start of data */
        res.start += le64_to_cpu(pfn_sb->dataoff);
 
-       nd_region = to_nd_region(dev->parent);
-       dax_region = alloc_dax_region(dev, nd_region->id, &res,
+       rc = sscanf(dev_name(&ndns->dev), "namespace%d.%d", &region_id, &id);
+       if (rc != 2)
+               return -EINVAL;
+
+       dax_region = alloc_dax_region(dev, region_id, &res,
                        le32_to_cpu(pfn_sb->align), addr, PFN_DEV|PFN_MAP);
        if (!dax_region)
                return -ENOMEM;
 
        /* TODO: support for subdividing a dax region... */
-       dev_dax = devm_create_dev_dax(dax_region, &res, 1);
+       dev_dax = devm_create_dev_dax(dax_region, id, &res, 1);
 
        /* child dev_dax instances now own the lifetime of the dax_region */
        dax_region_put(dax_region);
index 41b39464ded87f6ee3a4b0b302e0df52feddc520..501e16a9227dc001df41d993aafb6fb092116752 100644 (file)
@@ -2732,6 +2732,9 @@ static int hidpp_initialize_battery(struct hidpp_device *hidpp)
                                     hidpp_battery_props,
                                     sizeof(hidpp_battery_props),
                                     GFP_KERNEL);
+       if (!battery_props)
+               return -ENOMEM;
+
        num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 2;
 
        if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
index f3e35e7a189d30aba1b6619ddba328cbec75a836..aff20f4b6d97ead09453b303eaf4ac3ac94e1628 100644 (file)
@@ -620,16 +620,6 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
        return 0;
 }
 
-static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi,
-               struct hid_field *field, struct hid_usage *usage,
-               unsigned long **bit, int *max)
-{
-       if (usage->type == EV_KEY || usage->type == EV_ABS)
-               set_bit(usage->type, hi->input->evbit);
-
-       return -1;
-}
-
 static int mt_compute_slot(struct mt_device *td, struct input_dev *input)
 {
        __s32 quirks = td->mtclass.quirks;
@@ -969,8 +959,10 @@ static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
                return 0;
 
        if (field->application == HID_DG_TOUCHSCREEN ||
-           field->application == HID_DG_TOUCHPAD)
-               return mt_touch_input_mapped(hdev, hi, field, usage, bit, max);
+           field->application == HID_DG_TOUCHPAD) {
+               /* We own these mappings, tell hid-input to ignore them */
+               return -1;
+       }
 
        /* let hid-core decide for the others */
        return 0;
index 0e05f75934c98c7fccb73286d6270a1011c215c6..1858e3ce3993ac35424f005193a6542c3a1ac346 100644 (file)
@@ -104,19 +104,19 @@ u16 ide_pio_cycle_time(ide_drive_t *drive, u8 pio)
 EXPORT_SYMBOL_GPL(ide_pio_cycle_time);
 
 #define ENOUGH(v, unit)                (((v) - 1) / (unit) + 1)
-#define EZ(v, unit)            ((v) ? ENOUGH(v, unit) : 0)
+#define EZ(v, unit)            ((v) ? ENOUGH((v) * 1000, unit) : 0)
 
 static void ide_timing_quantize(struct ide_timing *t, struct ide_timing *q,
                                int T, int UT)
 {
-       q->setup   = EZ(t->setup   * 1000,  T);
-       q->act8b   = EZ(t->act8b   * 1000,  T);
-       q->rec8b   = EZ(t->rec8b   * 1000,  T);
-       q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
-       q->active  = EZ(t->active  * 1000,  T);
-       q->recover = EZ(t->recover * 1000,  T);
-       q->cycle   = EZ(t->cycle   * 1000,  T);
-       q->udma    = EZ(t->udma    * 1000, UT);
+       q->setup   = EZ(t->setup  T);
+       q->act8b   = EZ(t->act8b  T);
+       q->rec8b   = EZ(t->rec8b  T);
+       q->cyc8b   = EZ(t->cyc8b  T);
+       q->active  = EZ(t->active,  T);
+       q->recover = EZ(t->recover, T);
+       q->cycle   = EZ(t->cycle  T);
+       q->udma    = EZ(t->udma,    UT);
 }
 
 void ide_timing_merge(struct ide_timing *a, struct ide_timing *b,
index a6cb379a4ebcb3060c93eb959aa3071d45f78b37..01236cef7bfb1affe07e4214cf6d8baf6ca2a2a1 100644 (file)
@@ -268,6 +268,7 @@ int rdma_translate_ip(const struct sockaddr *addr,
                        return ret;
 
                ret = rdma_copy_addr(dev_addr, dev, NULL);
+               dev_addr->bound_dev_if = dev->ifindex;
                if (vlan_id)
                        *vlan_id = rdma_vlan_dev_vlan_id(dev);
                dev_put(dev);
@@ -280,6 +281,7 @@ int rdma_translate_ip(const struct sockaddr *addr,
                                          &((const struct sockaddr_in6 *)addr)->sin6_addr,
                                          dev, 1)) {
                                ret = rdma_copy_addr(dev_addr, dev, NULL);
+                               dev_addr->bound_dev_if = dev->ifindex;
                                if (vlan_id)
                                        *vlan_id = rdma_vlan_dev_vlan_id(dev);
                                break;
@@ -405,10 +407,10 @@ static int addr4_resolve(struct sockaddr_in *src_in,
        fl4.saddr = src_ip;
        fl4.flowi4_oif = addr->bound_dev_if;
        rt = ip_route_output_key(addr->net, &fl4);
-       if (IS_ERR(rt)) {
-               ret = PTR_ERR(rt);
-               goto out;
-       }
+       ret = PTR_ERR_OR_ZERO(rt);
+       if (ret)
+               return ret;
+
        src_in->sin_family = AF_INET;
        src_in->sin_addr.s_addr = fl4.saddr;
 
@@ -423,8 +425,6 @@ static int addr4_resolve(struct sockaddr_in *src_in,
 
        *prt = rt;
        return 0;
-out:
-       return ret;
 }
 
 #if IS_ENABLED(CONFIG_IPV6)
@@ -509,6 +509,11 @@ static int addr_resolve(struct sockaddr *src_in,
        struct dst_entry *dst;
        int ret;
 
+       if (!addr->net) {
+               pr_warn_ratelimited("%s: missing namespace\n", __func__);
+               return -EINVAL;
+       }
+
        if (src_in->sa_family == AF_INET) {
                struct rtable *rt = NULL;
                const struct sockaddr_in *dst_in4 =
@@ -522,8 +527,12 @@ static int addr_resolve(struct sockaddr *src_in,
                if (resolve_neigh)
                        ret = addr_resolve_neigh(&rt->dst, dst_in, addr, seq);
 
-               ndev = rt->dst.dev;
-               dev_hold(ndev);
+               if (addr->bound_dev_if) {
+                       ndev = dev_get_by_index(addr->net, addr->bound_dev_if);
+               } else {
+                       ndev = rt->dst.dev;
+                       dev_hold(ndev);
+               }
 
                ip_rt_put(rt);
        } else {
@@ -539,14 +548,27 @@ static int addr_resolve(struct sockaddr *src_in,
                if (resolve_neigh)
                        ret = addr_resolve_neigh(dst, dst_in, addr, seq);
 
-               ndev = dst->dev;
-               dev_hold(ndev);
+               if (addr->bound_dev_if) {
+                       ndev = dev_get_by_index(addr->net, addr->bound_dev_if);
+               } else {
+                       ndev = dst->dev;
+                       dev_hold(ndev);
+               }
 
                dst_release(dst);
        }
 
-       addr->bound_dev_if = ndev->ifindex;
-       addr->net = dev_net(ndev);
+       if (ndev->flags & IFF_LOOPBACK) {
+               ret = rdma_translate_ip(dst_in, addr, NULL);
+               /*
+                * Put the loopback device and get the translated
+                * device instead.
+                */
+               dev_put(ndev);
+               ndev = dev_get_by_index(addr->net, addr->bound_dev_if);
+       } else {
+               addr->bound_dev_if = ndev->ifindex;
+       }
        dev_put(ndev);
 
        return ret;
index 31bb82d8ecd7f19bbee90bd95a83cec7fe5abca7..11aff923b633f9eb5329993dab8e5db445d31aa8 100644 (file)
@@ -623,22 +623,11 @@ static inline int cma_validate_port(struct ib_device *device, u8 port,
        if ((dev_type != ARPHRD_INFINIBAND) && rdma_protocol_ib(device, port))
                return ret;
 
-       if (dev_type == ARPHRD_ETHER && rdma_protocol_roce(device, port)) {
+       if (dev_type == ARPHRD_ETHER && rdma_protocol_roce(device, port))
                ndev = dev_get_by_index(&init_net, bound_if_index);
-               if (ndev && ndev->flags & IFF_LOOPBACK) {
-                       pr_info("detected loopback device\n");
-                       dev_put(ndev);
-
-                       if (!device->get_netdev)
-                               return -EOPNOTSUPP;
-
-                       ndev = device->get_netdev(device, port);
-                       if (!ndev)
-                               return -ENODEV;
-               }
-       } else {
+       else
                gid_type = IB_GID_TYPE_IB;
-       }
+
 
        ret = ib_find_cached_gid_by_port(device, gid, gid_type, port,
                                         ndev, NULL);
@@ -2569,21 +2558,6 @@ static int cma_resolve_iboe_route(struct rdma_id_private *id_priv)
                        goto err2;
                }
 
-               if (ndev->flags & IFF_LOOPBACK) {
-                       dev_put(ndev);
-                       if (!id_priv->id.device->get_netdev) {
-                               ret = -EOPNOTSUPP;
-                               goto err2;
-                       }
-
-                       ndev = id_priv->id.device->get_netdev(id_priv->id.device,
-                                                             id_priv->id.port_num);
-                       if (!ndev) {
-                               ret = -ENODEV;
-                               goto err2;
-                       }
-               }
-
                supported_gids = roce_gid_type_mask_support(id_priv->id.device,
                                                            id_priv->id.port_num);
                gid_type = cma_route_gid_type(addr->dev_addr.network,
index db958d3207efc9e13aa1ae2d05fbadce2732c0cd..94a9eefb3cfcad894d13b400a9d3a2281773b5b0 100644 (file)
@@ -42,6 +42,8 @@
 #include <rdma/ib_cache.h>
 #include <rdma/ib_addr.h>
 
+static struct workqueue_struct *gid_cache_wq;
+
 enum gid_op_type {
        GID_DEL = 0,
        GID_ADD
@@ -560,7 +562,7 @@ static int netdevice_queue_work(struct netdev_event_work_cmd *cmds,
        }
        INIT_WORK(&ndev_work->work, netdevice_event_work_handler);
 
-       queue_work(ib_wq, &ndev_work->work);
+       queue_work(gid_cache_wq, &ndev_work->work);
 
        return NOTIFY_DONE;
 }
@@ -693,7 +695,7 @@ static int addr_event(struct notifier_block *this, unsigned long event,
        dev_hold(ndev);
        work->gid_attr.ndev   = ndev;
 
-       queue_work(ib_wq, &work->work);
+       queue_work(gid_cache_wq, &work->work);
 
        return NOTIFY_DONE;
 }
@@ -740,6 +742,10 @@ static struct notifier_block nb_inet6addr = {
 
 int __init roce_gid_mgmt_init(void)
 {
+       gid_cache_wq = alloc_ordered_workqueue("gid-cache-wq", 0);
+       if (!gid_cache_wq)
+               return -ENOMEM;
+
        register_inetaddr_notifier(&nb_inetaddr);
        if (IS_ENABLED(CONFIG_IPV6))
                register_inet6addr_notifier(&nb_inet6addr);
@@ -764,4 +770,5 @@ void __exit roce_gid_mgmt_cleanup(void)
         * ib-core is removed, all physical devices have been removed,
         * so no issue with remaining hardware contexts.
         */
+       destroy_workqueue(gid_cache_wq);
 }
index 8ba9bfb073d17c3025206fe66995547433c6a9a8..3f55d18a379145a45ef624e03b8ca2b8cbe5343f 100644 (file)
@@ -2005,28 +2005,13 @@ static int modify_qp(struct ib_uverbs_file *file,
        rdma_ah_set_port_num(&attr->alt_ah_attr,
                             cmd->base.alt_dest.port_num);
 
-       if (qp->real_qp == qp) {
-               if (cmd->base.attr_mask & IB_QP_AV) {
-                       ret = ib_resolve_eth_dmac(qp->device, &attr->ah_attr);
-                       if (ret)
-                               goto release_qp;
-               }
-               ret = ib_security_modify_qp(qp,
-                                           attr,
-                                           modify_qp_mask(qp->qp_type,
-                                                          cmd->base.attr_mask),
-                                           udata);
-       } else {
-               ret = ib_security_modify_qp(qp,
-                                           attr,
-                                           modify_qp_mask(qp->qp_type,
-                                                          cmd->base.attr_mask),
-                                           NULL);
-       }
+       ret = ib_modify_qp_with_udata(qp, attr,
+                                     modify_qp_mask(qp->qp_type,
+                                                    cmd->base.attr_mask),
+                                     udata);
 
 release_qp:
        uobj_put_obj_read(qp);
-
 out:
        kfree(attr);
 
index c973a83c898b487710600f4e4f6441c99595ca6c..fb98ed67d5bc684b8cc0b941d7140986b95aa99b 100644 (file)
@@ -452,6 +452,19 @@ int ib_get_gids_from_rdma_hdr(const union rdma_network_hdr *hdr,
 }
 EXPORT_SYMBOL(ib_get_gids_from_rdma_hdr);
 
+/*
+ * This function creates ah from the incoming packet.
+ * Incoming packet has dgid of the receiver node on which this code is
+ * getting executed and, sgid contains the GID of the sender.
+ *
+ * When resolving mac address of destination, the arrived dgid is used
+ * as sgid and, sgid is used as dgid because sgid contains destinations
+ * GID whom to respond to.
+ *
+ * This is why when calling rdma_addr_find_l2_eth_by_grh() function, the
+ * position of arguments dgid and sgid do not match the order of the
+ * parameters.
+ */
 int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
                       const struct ib_wc *wc, const struct ib_grh *grh,
                       struct rdma_ah_attr *ah_attr)
@@ -507,11 +520,6 @@ int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
                }
 
                resolved_dev = dev_get_by_index(&init_net, if_index);
-               if (resolved_dev->flags & IFF_LOOPBACK) {
-                       dev_put(resolved_dev);
-                       resolved_dev = idev;
-                       dev_hold(resolved_dev);
-               }
                rcu_read_lock();
                if (resolved_dev != idev && !rdma_is_upper_dev_rcu(idev,
                                                                   resolved_dev))
@@ -887,6 +895,7 @@ static const struct {
 } qp_state_table[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = {
        [IB_QPS_RESET] = {
                [IB_QPS_RESET] = { .valid = 1 },
+               [IB_QPS_ERR] =   { .valid = 1 },
                [IB_QPS_INIT]  = {
                        .valid = 1,
                        .req_param = {
@@ -1268,20 +1277,36 @@ out:
 }
 EXPORT_SYMBOL(ib_resolve_eth_dmac);
 
-int ib_modify_qp(struct ib_qp *qp,
-                struct ib_qp_attr *qp_attr,
-                int qp_attr_mask)
+/**
+ * ib_modify_qp_with_udata - Modifies the attributes for the specified QP.
+ * @qp: The QP to modify.
+ * @attr: On input, specifies the QP attributes to modify.  On output,
+ *   the current values of selected QP attributes are returned.
+ * @attr_mask: A bit-mask used to specify which attributes of the QP
+ *   are being modified.
+ * @udata: pointer to user's input output buffer information
+ *   are being modified.
+ * It returns 0 on success and returns appropriate error code on error.
+ */
+int ib_modify_qp_with_udata(struct ib_qp *qp, struct ib_qp_attr *attr,
+                           int attr_mask, struct ib_udata *udata)
 {
+       int ret;
 
-       if (qp_attr_mask & IB_QP_AV) {
-               int ret;
-
-               ret = ib_resolve_eth_dmac(qp->device, &qp_attr->ah_attr);
+       if (attr_mask & IB_QP_AV) {
+               ret = ib_resolve_eth_dmac(qp->device, &attr->ah_attr);
                if (ret)
                        return ret;
        }
+       return ib_security_modify_qp(qp, attr, attr_mask, udata);
+}
+EXPORT_SYMBOL(ib_modify_qp_with_udata);
 
-       return ib_security_modify_qp(qp->real_qp, qp_attr, qp_attr_mask, NULL);
+int ib_modify_qp(struct ib_qp *qp,
+                struct ib_qp_attr *qp_attr,
+                int qp_attr_mask)
+{
+       return ib_modify_qp_with_udata(qp, qp_attr, qp_attr_mask, NULL);
 }
 EXPORT_SYMBOL(ib_modify_qp);
 
index 2ba00b89df6a046bba536cfe889c373d9063ced0..94b54850ec75b7273eb63b961ffe7ebfbc0ee5c5 100644 (file)
@@ -12847,7 +12847,12 @@ static void remap_intr(struct hfi1_devdata *dd, int isrc, int msix_intr)
        /* clear from the handled mask of the general interrupt */
        m = isrc / 64;
        n = isrc % 64;
-       dd->gi_mask[m] &= ~((u64)1 << n);
+       if (likely(m < CCE_NUM_INT_CSRS)) {
+               dd->gi_mask[m] &= ~((u64)1 << n);
+       } else {
+               dd_dev_err(dd, "remap interrupt err\n");
+               return;
+       }
 
        /* direct the chip source to the given MSI-X interrupt */
        m = isrc / 8;
index 650305cc037306923e5e742c02f7977e672a70f9..1a7af9f60c137f916a125588318a182cf535ac01 100644 (file)
@@ -647,18 +647,17 @@ void qp_iter_print(struct seq_file *s, struct qp_iter *iter)
                   qp->pid);
 }
 
-void *qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp,
-                   gfp_t gfp)
+void *qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp)
 {
        struct hfi1_qp_priv *priv;
 
-       priv = kzalloc_node(sizeof(*priv), gfp, rdi->dparms.node);
+       priv = kzalloc_node(sizeof(*priv), GFP_KERNEL, rdi->dparms.node);
        if (!priv)
                return ERR_PTR(-ENOMEM);
 
        priv->owner = qp;
 
-       priv->s_ahg = kzalloc_node(sizeof(*priv->s_ahg), gfp,
+       priv->s_ahg = kzalloc_node(sizeof(*priv->s_ahg), GFP_KERNEL,
                                   rdi->dparms.node);
        if (!priv->s_ahg) {
                kfree(priv);
index 1eb9cd7b8c1973da834ed36ea42e7ae61a524c17..6fe542b6a92751863cd6385be0fe0654a346f08f 100644 (file)
@@ -123,8 +123,7 @@ void hfi1_migrate_qp(struct rvt_qp *qp);
 /*
  * Functions provided by hfi1 driver for rdmavt to use
  */
-void *qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp,
-                   gfp_t gfp);
+void *qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp);
 void qp_priv_free(struct rvt_dev_info *rdi, struct rvt_qp *qp);
 unsigned free_all_qps(struct rvt_dev_info *rdi);
 void notify_qp_reset(struct rvt_qp *qp);
index 37d5d29597a449d23bf34587024b83e4c55bb657..23fad6d969440bd2bd50a0c8b0dbafe8a92f4ae9 100644 (file)
@@ -228,14 +228,14 @@ int hns_roce_v1_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                        switch (wr->opcode) {
                        case IB_WR_RDMA_READ:
                                ps_opcode = HNS_ROCE_WQE_OPCODE_RDMA_READ;
-                               set_raddr_seg(wqe, atomic_wr(wr)->remote_addr,
-                                             atomic_wr(wr)->rkey);
+                               set_raddr_seg(wqe,  rdma_wr(wr)->remote_addr,
+                                              rdma_wr(wr)->rkey);
                                break;
                        case IB_WR_RDMA_WRITE:
                        case IB_WR_RDMA_WRITE_WITH_IMM:
                                ps_opcode = HNS_ROCE_WQE_OPCODE_RDMA_WRITE;
-                               set_raddr_seg(wqe, atomic_wr(wr)->remote_addr,
-                                             atomic_wr(wr)->rkey);
+                               set_raddr_seg(wqe,  rdma_wr(wr)->remote_addr,
+                                             rdma_wr(wr)->rkey);
                                break;
                        case IB_WR_SEND:
                        case IB_WR_SEND_WITH_INV:
@@ -661,9 +661,11 @@ static int hns_roce_v1_rsv_lp_qp(struct hns_roce_dev *hr_dev)
        union ib_gid dgid;
        u64 subnet_prefix;
        int attr_mask = 0;
-       int i;
+       int i, j;
        int ret;
+       u8 queue_en[HNS_ROCE_V1_RESV_QP] = { 0 };
        u8 phy_port;
+       u8 port = 0;
        u8 sl;
 
        priv = (struct hns_roce_v1_priv *)hr_dev->hw->priv;
@@ -709,11 +711,27 @@ static int hns_roce_v1_rsv_lp_qp(struct hns_roce_dev *hr_dev)
        attr.rnr_retry          = 7;
        attr.timeout            = 0x12;
        attr.path_mtu           = IB_MTU_256;
+       attr.ah_attr.type       = RDMA_AH_ATTR_TYPE_ROCE;
        rdma_ah_set_grh(&attr.ah_attr, NULL, 0, 0, 1, 0);
        rdma_ah_set_static_rate(&attr.ah_attr, 3);
 
        subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
        for (i = 0; i < HNS_ROCE_V1_RESV_QP; i++) {
+               phy_port = (i >= HNS_ROCE_MAX_PORTS) ? (i - 2) :
+                               (i % HNS_ROCE_MAX_PORTS);
+               sl = i / HNS_ROCE_MAX_PORTS;
+
+               for (j = 0; j < caps->num_ports; j++) {
+                       if (hr_dev->iboe.phy_port[j] == phy_port) {
+                               queue_en[i] = 1;
+                               port = j;
+                               break;
+                       }
+               }
+
+               if (!queue_en[i])
+                       continue;
+
                free_mr->mr_free_qp[i] = hns_roce_v1_create_lp_qp(hr_dev, pd);
                if (IS_ERR(free_mr->mr_free_qp[i])) {
                        dev_err(dev, "Create loop qp failed!\n");
@@ -721,15 +739,7 @@ static int hns_roce_v1_rsv_lp_qp(struct hns_roce_dev *hr_dev)
                }
                hr_qp = free_mr->mr_free_qp[i];
 
-               sl = i / caps->num_ports;
-
-               if (caps->num_ports == HNS_ROCE_MAX_PORTS)
-                       phy_port = (i >= HNS_ROCE_MAX_PORTS) ? (i - 2) :
-                               (i % caps->num_ports);
-               else
-                       phy_port = i % caps->num_ports;
-
-               hr_qp->port             = phy_port + 1;
+               hr_qp->port             = port;
                hr_qp->phy_port         = phy_port;
                hr_qp->ibqp.qp_type     = IB_QPT_RC;
                hr_qp->ibqp.device      = &hr_dev->ib_dev;
@@ -739,23 +749,22 @@ static int hns_roce_v1_rsv_lp_qp(struct hns_roce_dev *hr_dev)
                hr_qp->ibqp.recv_cq     = cq;
                hr_qp->ibqp.send_cq     = cq;
 
-               rdma_ah_set_port_num(&attr.ah_attr, phy_port + 1);
-               rdma_ah_set_sl(&attr.ah_attr, phy_port + 1);
-               attr.port_num           = phy_port + 1;
+               rdma_ah_set_port_num(&attr.ah_attr, port + 1);
+               rdma_ah_set_sl(&attr.ah_attr, sl);
+               attr.port_num           = port + 1;
 
                attr.dest_qp_num        = hr_qp->qpn;
                memcpy(rdma_ah_retrieve_dmac(&attr.ah_attr),
-                      hr_dev->dev_addr[phy_port],
+                      hr_dev->dev_addr[port],
                       MAC_ADDR_OCTET_NUM);
 
                memcpy(&dgid.raw, &subnet_prefix, sizeof(u64));
-               memcpy(&dgid.raw[8], hr_dev->dev_addr[phy_port], 3);
-               memcpy(&dgid.raw[13], hr_dev->dev_addr[phy_port] + 3, 3);
+               memcpy(&dgid.raw[8], hr_dev->dev_addr[port], 3);
+               memcpy(&dgid.raw[13], hr_dev->dev_addr[port] + 3, 3);
                dgid.raw[11] = 0xff;
                dgid.raw[12] = 0xfe;
                dgid.raw[8] ^= 2;
                rdma_ah_set_dgid_raw(&attr.ah_attr, dgid.raw);
-               attr_mask |= IB_QP_PORT;
 
                ret = hr_dev->hw->modify_qp(&hr_qp->ibqp, &attr, attr_mask,
                                            IB_QPS_RESET, IB_QPS_INIT);
@@ -812,6 +821,9 @@ static void hns_roce_v1_release_lp_qp(struct hns_roce_dev *hr_dev)
 
        for (i = 0; i < HNS_ROCE_V1_RESV_QP; i++) {
                hr_qp = free_mr->mr_free_qp[i];
+               if (!hr_qp)
+                       continue;
+
                ret = hns_roce_v1_destroy_qp(&hr_qp->ibqp);
                if (ret)
                        dev_err(dev, "Destroy qp %d for mr free failed(%d)!\n",
@@ -963,7 +975,7 @@ static void hns_roce_v1_mr_free_work_fn(struct work_struct *work)
                msecs_to_jiffies(HNS_ROCE_V1_FREE_MR_TIMEOUT_MSECS) + jiffies;
        int i;
        int ret;
-       int ne;
+       int ne = 0;
 
        mr_work = container_of(work, struct hns_roce_mr_free_work, work);
        hr_mr = (struct hns_roce_mr *)mr_work->mr;
@@ -976,6 +988,10 @@ static void hns_roce_v1_mr_free_work_fn(struct work_struct *work)
 
        for (i = 0; i < HNS_ROCE_V1_RESV_QP; i++) {
                hr_qp = free_mr->mr_free_qp[i];
+               if (!hr_qp)
+                       continue;
+               ne++;
+
                ret = hns_roce_v1_send_lp_wqe(hr_qp);
                if (ret) {
                        dev_err(dev,
@@ -985,7 +1001,6 @@ static void hns_roce_v1_mr_free_work_fn(struct work_struct *work)
                }
        }
 
-       ne = HNS_ROCE_V1_RESV_QP;
        do {
                ret = hns_roce_v1_poll_cq(&mr_free_cq->ib_cq, ne, wc);
                if (ret < 0) {
@@ -995,7 +1010,8 @@ static void hns_roce_v1_mr_free_work_fn(struct work_struct *work)
                        goto free_work;
                }
                ne -= ret;
-               msleep(HNS_ROCE_V1_FREE_MR_WAIT_VALUE);
+               usleep_range(HNS_ROCE_V1_FREE_MR_WAIT_VALUE * 1000,
+                            (1 + HNS_ROCE_V1_FREE_MR_WAIT_VALUE) * 1000);
        } while (ne && time_before_eq(jiffies, end));
 
        if (ne != 0)
@@ -2181,7 +2197,7 @@ static int hns_roce_v1_poll_one(struct hns_roce_cq *hr_cq,
                }
                wc->wr_id = wq->wrid[wq->tail & (wq->wqe_cnt - 1)];
                ++wq->tail;
-               } else {
+       } else {
                /* RQ conrespond to CQE */
                wc->byte_len = le32_to_cpu(cqe->byte_cnt);
                opcode = roce_get_field(cqe->cqe_byte_4,
@@ -3533,10 +3549,12 @@ static int check_qp_db_process_status(struct hns_roce_dev *hr_dev,
                                        old_cnt = roce_get_field(old_send,
                                        ROCEE_SDB_SEND_PTR_SDB_SEND_PTR_M,
                                        ROCEE_SDB_SEND_PTR_SDB_SEND_PTR_S);
-                                       if (cur_cnt - old_cnt > SDB_ST_CMP_VAL)
+                                       if (cur_cnt - old_cnt >
+                                           SDB_ST_CMP_VAL) {
                                                success_flags = 1;
-                                       else {
-                                           send_ptr = roce_get_field(old_send,
+                                       } else {
+                                               send_ptr =
+                                                       roce_get_field(old_send,
                                            ROCEE_SDB_SEND_PTR_SDB_SEND_PTR_M,
                                            ROCEE_SDB_SEND_PTR_SDB_SEND_PTR_S) +
                                            roce_get_field(sdb_retry_cnt,
@@ -3641,6 +3659,7 @@ static void hns_roce_v1_destroy_qp_work_fn(struct work_struct *work)
        struct hns_roce_dev *hr_dev;
        struct hns_roce_qp *hr_qp;
        struct device *dev;
+       unsigned long qpn;
        int ret;
 
        qp_work_entry = container_of(work, struct hns_roce_qp_work, work);
@@ -3648,8 +3667,9 @@ static void hns_roce_v1_destroy_qp_work_fn(struct work_struct *work)
        dev = &hr_dev->pdev->dev;
        priv = (struct hns_roce_v1_priv *)hr_dev->hw->priv;
        hr_qp = qp_work_entry->qp;
+       qpn = hr_qp->qpn;
 
-       dev_dbg(dev, "Schedule destroy QP(0x%lx) work.\n", hr_qp->qpn);
+       dev_dbg(dev, "Schedule destroy QP(0x%lx) work.\n", qpn);
 
        qp_work_entry->sche_cnt++;
 
@@ -3660,7 +3680,7 @@ static void hns_roce_v1_destroy_qp_work_fn(struct work_struct *work)
                                         &qp_work_entry->db_wait_stage);
        if (ret) {
                dev_err(dev, "Check QP(0x%lx) db process status failed!\n",
-                       hr_qp->qpn);
+                       qpn);
                return;
        }
 
@@ -3674,7 +3694,7 @@ static void hns_roce_v1_destroy_qp_work_fn(struct work_struct *work)
        ret = hns_roce_v1_modify_qp(&hr_qp->ibqp, NULL, 0, hr_qp->state,
                                    IB_QPS_RESET);
        if (ret) {
-               dev_err(dev, "Modify QP(0x%lx) to RST failed!\n", hr_qp->qpn);
+               dev_err(dev, "Modify QP(0x%lx) to RST failed!\n", qpn);
                return;
        }
 
@@ -3683,14 +3703,14 @@ static void hns_roce_v1_destroy_qp_work_fn(struct work_struct *work)
 
        if (hr_qp->ibqp.qp_type == IB_QPT_RC) {
                /* RC QP, release QPN */
-               hns_roce_release_range_qp(hr_dev, hr_qp->qpn, 1);
+               hns_roce_release_range_qp(hr_dev, qpn, 1);
                kfree(hr_qp);
        } else
                kfree(hr_to_hr_sqp(hr_qp));
 
        kfree(qp_work_entry);
 
-       dev_dbg(dev, "Accomplished destroy QP(0x%lx) work.\n", hr_qp->qpn);
+       dev_dbg(dev, "Accomplished destroy QP(0x%lx) work.\n", qpn);
 }
 
 int hns_roce_v1_destroy_qp(struct ib_qp *ibqp)
index c3b41f95e70a5f1c39e89d91e48653fc05e2b20a..d9777b662eba94ed6d917b262f073f911b073059 100644 (file)
@@ -125,8 +125,6 @@ static int handle_en_event(struct hns_roce_dev *hr_dev, u8 port,
                return -ENODEV;
        }
 
-       spin_lock_bh(&hr_dev->iboe.lock);
-
        switch (event) {
        case NETDEV_UP:
        case NETDEV_CHANGE:
@@ -144,7 +142,6 @@ static int handle_en_event(struct hns_roce_dev *hr_dev, u8 port,
                break;
        }
 
-       spin_unlock_bh(&hr_dev->iboe.lock);
        return 0;
 }
 
index 4f5a143fc0a7229a703d0ba99a6fdd1cddb00313..ff931c580557b18cdecab6d86d00297e6c7993ff 100644 (file)
@@ -102,7 +102,7 @@ static int mlx4_ib_alloc_cq_buf(struct mlx4_ib_dev *dev, struct mlx4_ib_cq_buf *
        int err;
 
        err = mlx4_buf_alloc(dev->dev, nent * dev->dev->caps.cqe_size,
-                            PAGE_SIZE * 2, &buf->buf, GFP_KERNEL);
+                            PAGE_SIZE * 2, &buf->buf);
 
        if (err)
                goto out;
@@ -113,7 +113,7 @@ static int mlx4_ib_alloc_cq_buf(struct mlx4_ib_dev *dev, struct mlx4_ib_cq_buf *
        if (err)
                goto err_buf;
 
-       err = mlx4_buf_write_mtt(dev->dev, &buf->mtt, &buf->buf, GFP_KERNEL);
+       err = mlx4_buf_write_mtt(dev->dev, &buf->mtt, &buf->buf);
        if (err)
                goto err_mtt;
 
@@ -219,7 +219,7 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev,
 
                uar = &to_mucontext(context)->uar;
        } else {
-               err = mlx4_db_alloc(dev->dev, &cq->db, 1, GFP_KERNEL);
+               err = mlx4_db_alloc(dev->dev, &cq->db, 1);
                if (err)
                        goto err_cq;
 
index 75b2f7d4cd95577814a3b9031aff4c0cebf56fa4..d1b43cbbfea7795418d4e2dffb5acaf454552c85 100644 (file)
@@ -1155,7 +1155,7 @@ static void mlx4_ib_disassociate_ucontext(struct ib_ucontext *ibcontext)
                         * call to mlx4_ib_vma_close.
                         */
                        put_task_struct(owning_process);
-                       msleep(1);
+                       usleep_range(1000, 2000);
                        owning_process = get_pid_task(ibcontext->tgid,
                                                      PIDTYPE_PID);
                        if (!owning_process ||
index 3405e947dc1ebb420b2e2aa3104e1a2ea92485f8..b73f89700ef9eaee928487b374491e863eb4444e 100644 (file)
@@ -1091,7 +1091,7 @@ static void _mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy
                if (!count)
                        break;
 
-               msleep(1);
+               usleep_range(1000, 2000);
        } while (time_after(end, jiffies));
 
        flush_workqueue(ctx->mcg_wq);
index c2b9cbf4da050e22afee4251079f7eece418416a..9db82e67e9591a5f56a540da8b8c96984714cbae 100644 (file)
@@ -185,7 +185,6 @@ enum mlx4_ib_qp_flags {
        MLX4_IB_QP_LSO = IB_QP_CREATE_IPOIB_UD_LSO,
        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK = IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK,
        MLX4_IB_QP_NETIF = IB_QP_CREATE_NETIF_QP,
-       MLX4_IB_QP_CREATE_USE_GFP_NOIO = IB_QP_CREATE_USE_GFP_NOIO,
 
        /* Mellanox specific flags start from IB_QP_CREATE_RESERVED_START */
        MLX4_IB_ROCE_V2_GSI_QP = MLX4_IB_QP_CREATE_ROCE_V2_GSI,
index 996e9058e515adf924eb23fd9ef10606ab74342a..75c0e6c5dd5691a2d57f21a80be80e29fb07b706 100644 (file)
@@ -634,8 +634,8 @@ static void mlx4_ib_free_qp_counter(struct mlx4_ib_dev *dev,
 
 static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                            struct ib_qp_init_attr *init_attr,
-                           struct ib_udata *udata, int sqpn, struct mlx4_ib_qp **caller_qp,
-                           gfp_t gfp)
+                           struct ib_udata *udata, int sqpn,
+                           struct mlx4_ib_qp **caller_qp)
 {
        int qpn;
        int err;
@@ -691,14 +691,14 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                if (qp_type == MLX4_IB_QPT_SMI || qp_type == MLX4_IB_QPT_GSI ||
                    (qp_type & (MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_SMI_OWNER |
                                MLX4_IB_QPT_PROXY_GSI | MLX4_IB_QPT_TUN_SMI_OWNER))) {
-                       sqp = kzalloc(sizeof (struct mlx4_ib_sqp), gfp);
+                       sqp = kzalloc(sizeof(struct mlx4_ib_sqp), GFP_KERNEL);
                        if (!sqp)
                                return -ENOMEM;
                        qp = &sqp->qp;
                        qp->pri.vid = 0xFFFF;
                        qp->alt.vid = 0xFFFF;
                } else {
-                       qp = kzalloc(sizeof (struct mlx4_ib_qp), gfp);
+                       qp = kzalloc(sizeof(struct mlx4_ib_qp), GFP_KERNEL);
                        if (!qp)
                                return -ENOMEM;
                        qp->pri.vid = 0xFFFF;
@@ -780,7 +780,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                        goto err;
 
                if (qp_has_rq(init_attr)) {
-                       err = mlx4_db_alloc(dev->dev, &qp->db, 0, gfp);
+                       err = mlx4_db_alloc(dev->dev, &qp->db, 0);
                        if (err)
                                goto err;
 
@@ -788,7 +788,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                }
 
                if (mlx4_buf_alloc(dev->dev, qp->buf_size, qp->buf_size,
-                                  &qp->buf, gfp)) {
+                                  &qp->buf)) {
                        memcpy(&init_attr->cap, &backup_cap,
                               sizeof(backup_cap));
                        err = set_kernel_sq_size(dev, &init_attr->cap, qp_type,
@@ -797,7 +797,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                                goto err_db;
 
                        if (mlx4_buf_alloc(dev->dev, qp->buf_size,
-                                          PAGE_SIZE * 2, &qp->buf, gfp)) {
+                                          PAGE_SIZE * 2, &qp->buf)) {
                                err = -ENOMEM;
                                goto err_db;
                        }
@@ -808,20 +808,20 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                if (err)
                        goto err_buf;
 
-               err = mlx4_buf_write_mtt(dev->dev, &qp->mtt, &qp->buf, gfp);
+               err = mlx4_buf_write_mtt(dev->dev, &qp->mtt, &qp->buf);
                if (err)
                        goto err_mtt;
 
                qp->sq.wrid = kmalloc_array(qp->sq.wqe_cnt, sizeof(u64),
-                                       gfp | __GFP_NOWARN);
+                                       GFP_KERNEL | __GFP_NOWARN);
                if (!qp->sq.wrid)
                        qp->sq.wrid = __vmalloc(qp->sq.wqe_cnt * sizeof(u64),
-                                               gfp, PAGE_KERNEL);
+                                               GFP_KERNEL, PAGE_KERNEL);
                qp->rq.wrid = kmalloc_array(qp->rq.wqe_cnt, sizeof(u64),
-                                       gfp | __GFP_NOWARN);
+                                       GFP_KERNEL | __GFP_NOWARN);
                if (!qp->rq.wrid)
                        qp->rq.wrid = __vmalloc(qp->rq.wqe_cnt * sizeof(u64),
-                                               gfp, PAGE_KERNEL);
+                                               GFP_KERNEL, PAGE_KERNEL);
                if (!qp->sq.wrid || !qp->rq.wrid) {
                        err = -ENOMEM;
                        goto err_wrid;
@@ -859,7 +859,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
        if (init_attr->create_flags & IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK)
                qp->flags |= MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK;
 
-       err = mlx4_qp_alloc(dev->dev, qpn, &qp->mqp, gfp);
+       err = mlx4_qp_alloc(dev->dev, qpn, &qp->mqp);
        if (err)
                goto err_qpn;
 
@@ -1127,10 +1127,7 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
        int err;
        int sup_u_create_flags = MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK;
        u16 xrcdn = 0;
-       gfp_t gfp;
 
-       gfp = (init_attr->create_flags & MLX4_IB_QP_CREATE_USE_GFP_NOIO) ?
-               GFP_NOIO : GFP_KERNEL;
        /*
         * We only support LSO, vendor flag1, and multicast loopback blocking,
         * and only for kernel UD QPs.
@@ -1140,8 +1137,7 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
                                        MLX4_IB_SRIOV_TUNNEL_QP |
                                        MLX4_IB_SRIOV_SQP |
                                        MLX4_IB_QP_NETIF |
-                                       MLX4_IB_QP_CREATE_ROCE_V2_GSI |
-                                       MLX4_IB_QP_CREATE_USE_GFP_NOIO))
+                                       MLX4_IB_QP_CREATE_ROCE_V2_GSI))
                return ERR_PTR(-EINVAL);
 
        if (init_attr->create_flags & IB_QP_CREATE_NETIF_QP) {
@@ -1154,7 +1150,6 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
                        return ERR_PTR(-EINVAL);
 
                if ((init_attr->create_flags & ~(MLX4_IB_SRIOV_SQP |
-                                                MLX4_IB_QP_CREATE_USE_GFP_NOIO |
                                                 MLX4_IB_QP_CREATE_ROCE_V2_GSI  |
                                                 MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK) &&
                     init_attr->qp_type != IB_QPT_UD) ||
@@ -1179,7 +1174,7 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
        case IB_QPT_RC:
        case IB_QPT_UC:
        case IB_QPT_RAW_PACKET:
-               qp = kzalloc(sizeof *qp, gfp);
+               qp = kzalloc(sizeof(*qp), GFP_KERNEL);
                if (!qp)
                        return ERR_PTR(-ENOMEM);
                qp->pri.vid = 0xFFFF;
@@ -1188,7 +1183,7 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
        case IB_QPT_UD:
        {
                err = create_qp_common(to_mdev(pd->device), pd, init_attr,
-                                      udata, 0, &qp, gfp);
+                                      udata, 0, &qp);
                if (err) {
                        kfree(qp);
                        return ERR_PTR(err);
@@ -1217,8 +1212,7 @@ static struct ib_qp *_mlx4_ib_create_qp(struct ib_pd *pd,
                }
 
                err = create_qp_common(to_mdev(pd->device), pd, init_attr, udata,
-                                      sqpn,
-                                      &qp, gfp);
+                                      sqpn, &qp);
                if (err)
                        return ERR_PTR(err);
 
index e32dd58937a821a914c3e7d79d2d4482b158db47..0facaf5f6d2376d395a739726b740b1d6f352435 100644 (file)
@@ -135,14 +135,14 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
                if (err)
                        goto err_mtt;
        } else {
-               err = mlx4_db_alloc(dev->dev, &srq->db, 0, GFP_KERNEL);
+               err = mlx4_db_alloc(dev->dev, &srq->db, 0);
                if (err)
                        goto err_srq;
 
                *srq->db.db = 0;
 
-               if (mlx4_buf_alloc(dev->dev, buf_size, PAGE_SIZE * 2, &srq->buf,
-                                  GFP_KERNEL)) {
+               if (mlx4_buf_alloc(dev->dev, buf_size, PAGE_SIZE * 2,
+                                  &srq->buf)) {
                        err = -ENOMEM;
                        goto err_db;
                }
@@ -167,7 +167,7 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
                if (err)
                        goto err_buf;
 
-               err = mlx4_buf_write_mtt(dev->dev, &srq->mtt, &srq->buf, GFP_KERNEL);
+               err = mlx4_buf_write_mtt(dev->dev, &srq->mtt, &srq->buf);
                if (err)
                        goto err_mtt;
 
index 763bb5b36144be84c9ba2eafa7b3ade06fa57f44..8ab2f1360a4564f6477420b6ab1b03811d360f19 100644 (file)
@@ -582,6 +582,15 @@ static void clean_keys(struct mlx5_ib_dev *dev, int c)
        }
 }
 
+static void mlx5_mr_cache_debugfs_cleanup(struct mlx5_ib_dev *dev)
+{
+       if (!mlx5_debugfs_root)
+               return;
+
+       debugfs_remove_recursive(dev->cache.root);
+       dev->cache.root = NULL;
+}
+
 static int mlx5_mr_cache_debugfs_init(struct mlx5_ib_dev *dev)
 {
        struct mlx5_mr_cache *cache = &dev->cache;
@@ -600,38 +609,34 @@ static int mlx5_mr_cache_debugfs_init(struct mlx5_ib_dev *dev)
                sprintf(ent->name, "%d", ent->order);
                ent->dir = debugfs_create_dir(ent->name,  cache->root);
                if (!ent->dir)
-                       return -ENOMEM;
+                       goto err;
 
                ent->fsize = debugfs_create_file("size", 0600, ent->dir, ent,
                                                 &size_fops);
                if (!ent->fsize)
-                       return -ENOMEM;
+                       goto err;
 
                ent->flimit = debugfs_create_file("limit", 0600, ent->dir, ent,
                                                  &limit_fops);
                if (!ent->flimit)
-                       return -ENOMEM;
+                       goto err;
 
                ent->fcur = debugfs_create_u32("cur", 0400, ent->dir,
                                               &ent->cur);
                if (!ent->fcur)
-                       return -ENOMEM;
+                       goto err;
 
                ent->fmiss = debugfs_create_u32("miss", 0600, ent->dir,
                                                &ent->miss);
                if (!ent->fmiss)
-                       return -ENOMEM;
+                       goto err;
        }
 
        return 0;
-}
-
-static void mlx5_mr_cache_debugfs_cleanup(struct mlx5_ib_dev *dev)
-{
-       if (!mlx5_debugfs_root)
-               return;
+err:
+       mlx5_mr_cache_debugfs_cleanup(dev);
 
-       debugfs_remove_recursive(dev->cache.root);
+       return -ENOMEM;
 }
 
 static void delay_time_func(unsigned long ctx)
@@ -692,6 +697,11 @@ int mlx5_mr_cache_init(struct mlx5_ib_dev *dev)
        if (err)
                mlx5_ib_warn(dev, "cache debugfs failure\n");
 
+       /*
+        * We don't want to fail driver if debugfs failed to initialize,
+        * so we are not forwarding error to the user.
+        */
+
        return 0;
 }
 
@@ -1779,7 +1789,7 @@ mlx5_ib_sg_to_klms(struct mlx5_ib_mr *mr,
        mr->ndescs = sg_nents;
 
        for_each_sg(sgl, sg, sg_nents, i) {
-               if (unlikely(i > mr->max_descs))
+               if (unlikely(i >= mr->max_descs))
                        break;
                klms[i].va = cpu_to_be64(sg_dma_address(sg) + sg_offset);
                klms[i].bcount = cpu_to_be32(sg_dma_len(sg) - sg_offset);
index 8f9d8b4ad583918dc4a2785b1df33d6eee3b6921..b0adf65e4bdbf4c1e19f4b75c1b805b9d42ef622 100644 (file)
@@ -551,7 +551,7 @@ struct nes_adapter *nes_init_adapter(struct nes_device *nesdev, u8 hw_rev) {
                        if ((0x0F000100 == (pcs_control_status0 & 0x0F000100))
                            || (0x0F000100 == (pcs_control_status1 & 0x0F000100)))
                                int_cnt++;
-                       msleep(1);
+                       usleep_range(1000, 2000);
                }
                if (int_cnt > 1) {
                        spin_lock_irqsave(&nesadapter->phy_lock, flags);
@@ -592,7 +592,7 @@ struct nes_adapter *nes_init_adapter(struct nes_device *nesdev, u8 hw_rev) {
                                                break;
                                        }
                                }
-                               msleep(1);
+                               usleep_range(1000, 2000);
                        }
                }
        }
index 5984981e7dd41b9c681e44bd275e230d19f29bd5..a343e3b5d4cbf1188db5801b0856b13ad08ff72e 100644 (file)
@@ -104,10 +104,9 @@ const struct rvt_operation_params qib_post_parms[RVT_OPERATION_MAX] = {
 
 };
 
-static void get_map_page(struct rvt_qpn_table *qpt, struct rvt_qpn_map *map,
-                        gfp_t gfp)
+static void get_map_page(struct rvt_qpn_table *qpt, struct rvt_qpn_map *map)
 {
-       unsigned long page = get_zeroed_page(gfp);
+       unsigned long page = get_zeroed_page(GFP_KERNEL);
 
        /*
         * Free the page if someone raced with us installing it.
@@ -126,7 +125,7 @@ static void get_map_page(struct rvt_qpn_table *qpt, struct rvt_qpn_map *map,
  * zero/one for QP type IB_QPT_SMI/IB_QPT_GSI.
  */
 int qib_alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
-                 enum ib_qp_type type, u8 port, gfp_t gfp)
+                 enum ib_qp_type type, u8 port)
 {
        u32 i, offset, max_scan, qpn;
        struct rvt_qpn_map *map;
@@ -160,7 +159,7 @@ int qib_alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
        max_scan = qpt->nmaps - !offset;
        for (i = 0;;) {
                if (unlikely(!map->page)) {
-                       get_map_page(qpt, map, gfp);
+                       get_map_page(qpt, map);
                        if (unlikely(!map->page))
                                break;
                }
@@ -317,16 +316,16 @@ u32 qib_mtu_from_qp(struct rvt_dev_info *rdi, struct rvt_qp *qp, u32 pmtu)
        return ib_mtu_enum_to_int(pmtu);
 }
 
-void *qib_qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp, gfp_t gfp)
+void *qib_qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp)
 {
        struct qib_qp_priv *priv;
 
-       priv = kzalloc(sizeof(*priv), gfp);
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return ERR_PTR(-ENOMEM);
        priv->owner = qp;
 
-       priv->s_hdr = kzalloc(sizeof(*priv->s_hdr), gfp);
+       priv->s_hdr = kzalloc(sizeof(*priv->s_hdr), GFP_KERNEL);
        if (!priv->s_hdr) {
                kfree(priv);
                return ERR_PTR(-ENOMEM);
index da0db5485ddc7129151c10e8ec66cf7aa6332594..a52fc67b40d73ab3e7e3c6659bf050cd16a0035d 100644 (file)
@@ -274,11 +274,11 @@ int qib_get_counters(struct qib_pportdata *ppd,
  * Functions provided by qib driver for rdmavt to use
  */
 unsigned qib_free_all_qps(struct rvt_dev_info *rdi);
-void *qib_qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp, gfp_t gfp);
+void *qib_qp_priv_alloc(struct rvt_dev_info *rdi, struct rvt_qp *qp);
 void qib_qp_priv_free(struct rvt_dev_info *rdi, struct rvt_qp *qp);
 void qib_notify_qp_reset(struct rvt_qp *qp);
 int qib_alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
-                 enum ib_qp_type type, u8 port, gfp_t gfp);
+                 enum ib_qp_type type, u8 port);
 void qib_restart_rc(struct rvt_qp *qp, u32 psn, int wait);
 #ifdef CONFIG_DEBUG_FS
 
index 727e81cc2c8f6ad71b66b486c9b3d581e66e47d0..459865439a0bf50affcd8300237e135fb03e9faa 100644 (file)
@@ -118,10 +118,9 @@ const int ib_rvt_state_ops[IB_QPS_ERR + 1] = {
 EXPORT_SYMBOL(ib_rvt_state_ops);
 
 static void get_map_page(struct rvt_qpn_table *qpt,
-                        struct rvt_qpn_map *map,
-                        gfp_t gfp)
+                        struct rvt_qpn_map *map)
 {
-       unsigned long page = get_zeroed_page(gfp);
+       unsigned long page = get_zeroed_page(GFP_KERNEL);
 
        /*
         * Free the page if someone raced with us installing it.
@@ -173,7 +172,7 @@ static int init_qpn_table(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt)
                    rdi->dparms.qpn_res_start, rdi->dparms.qpn_res_end);
        for (i = rdi->dparms.qpn_res_start; i <= rdi->dparms.qpn_res_end; i++) {
                if (!map->page) {
-                       get_map_page(qpt, map, GFP_KERNEL);
+                       get_map_page(qpt, map);
                        if (!map->page) {
                                ret = -ENOMEM;
                                break;
@@ -342,14 +341,14 @@ static inline unsigned mk_qpn(struct rvt_qpn_table *qpt,
  * Return: The queue pair number
  */
 static int alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
-                    enum ib_qp_type type, u8 port_num, gfp_t gfp)
+                    enum ib_qp_type type, u8 port_num)
 {
        u32 i, offset, max_scan, qpn;
        struct rvt_qpn_map *map;
        u32 ret;
 
        if (rdi->driver_f.alloc_qpn)
-               return rdi->driver_f.alloc_qpn(rdi, qpt, type, port_num, gfp);
+               return rdi->driver_f.alloc_qpn(rdi, qpt, type, port_num);
 
        if (type == IB_QPT_SMI || type == IB_QPT_GSI) {
                unsigned n;
@@ -374,7 +373,7 @@ static int alloc_qpn(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
        max_scan = qpt->nmaps - !offset;
        for (i = 0;;) {
                if (unlikely(!map->page)) {
-                       get_map_page(qpt, map, gfp);
+                       get_map_page(qpt, map);
                        if (unlikely(!map->page))
                                break;
                }
@@ -672,7 +671,6 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
        struct ib_qp *ret = ERR_PTR(-ENOMEM);
        struct rvt_dev_info *rdi = ib_to_rvt(ibpd->device);
        void *priv = NULL;
-       gfp_t gfp;
        size_t sqsize;
 
        if (!rdi)
@@ -680,18 +678,9 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
 
        if (init_attr->cap.max_send_sge > rdi->dparms.props.max_sge ||
            init_attr->cap.max_send_wr > rdi->dparms.props.max_qp_wr ||
-           init_attr->create_flags & ~(IB_QP_CREATE_USE_GFP_NOIO))
+           init_attr->create_flags)
                return ERR_PTR(-EINVAL);
 
-       /* GFP_NOIO is applicable to RC QP's only */
-
-       if (init_attr->create_flags & IB_QP_CREATE_USE_GFP_NOIO &&
-           init_attr->qp_type != IB_QPT_RC)
-               return ERR_PTR(-EINVAL);
-
-       gfp = init_attr->create_flags & IB_QP_CREATE_USE_GFP_NOIO ?
-                                               GFP_NOIO : GFP_KERNEL;
-
        /* Check receive queue parameters if no SRQ is specified. */
        if (!init_attr->srq) {
                if (init_attr->cap.max_recv_sge > rdi->dparms.props.max_sge ||
@@ -719,14 +708,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                sz = sizeof(struct rvt_sge) *
                        init_attr->cap.max_send_sge +
                        sizeof(struct rvt_swqe);
-               if (gfp == GFP_NOIO)
-                       swq = __vmalloc(
-                               sqsize * sz,
-                               gfp | __GFP_ZERO, PAGE_KERNEL);
-               else
-                       swq = vzalloc_node(
-                               sqsize * sz,
-                               rdi->dparms.node);
+               swq = vzalloc_node(sqsize * sz, rdi->dparms.node);
                if (!swq)
                        return ERR_PTR(-ENOMEM);
 
@@ -741,7 +723,8 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                } else if (init_attr->cap.max_recv_sge > 1)
                        sg_list_sz = sizeof(*qp->r_sg_list) *
                                (init_attr->cap.max_recv_sge - 1);
-               qp = kzalloc_node(sz + sg_list_sz, gfp, rdi->dparms.node);
+               qp = kzalloc_node(sz + sg_list_sz, GFP_KERNEL,
+                                 rdi->dparms.node);
                if (!qp)
                        goto bail_swq;
 
@@ -751,7 +734,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                                kzalloc_node(
                                        sizeof(*qp->s_ack_queue) *
                                         rvt_max_atomic(rdi),
-                                       gfp,
+                                       GFP_KERNEL,
                                        rdi->dparms.node);
                        if (!qp->s_ack_queue)
                                goto bail_qp;
@@ -766,7 +749,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                 * Driver needs to set up it's private QP structure and do any
                 * initialization that is needed.
                 */
-               priv = rdi->driver_f.qp_priv_alloc(rdi, qp, gfp);
+               priv = rdi->driver_f.qp_priv_alloc(rdi, qp);
                if (IS_ERR(priv)) {
                        ret = priv;
                        goto bail_qp;
@@ -786,11 +769,6 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
                                qp->r_rq.wq = vmalloc_user(
                                                sizeof(struct rvt_rwq) +
                                                qp->r_rq.size * sz);
-                       else if (gfp == GFP_NOIO)
-                               qp->r_rq.wq = __vmalloc(
-                                               sizeof(struct rvt_rwq) +
-                                               qp->r_rq.size * sz,
-                                               gfp | __GFP_ZERO, PAGE_KERNEL);
                        else
                                qp->r_rq.wq = vzalloc_node(
                                                sizeof(struct rvt_rwq) +
@@ -824,7 +802,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
 
                err = alloc_qpn(rdi, &rdi->qp_dev->qpn_table,
                                init_attr->qp_type,
-                               init_attr->port_num, gfp);
+                               init_attr->port_num);
                if (err < 0) {
                        ret = ERR_PTR(err);
                        goto bail_rq_wq;
index c3a140ed4df27a0abf33ce0a032774d250883faa..08f3f90d29123e9f6840b34f72b8aa56b7054b7d 100644 (file)
@@ -441,6 +441,8 @@ static void rxe_skb_tx_dtor(struct sk_buff *skb)
        if (unlikely(qp->need_req_skb &&
                     skb_out < RXE_INFLIGHT_SKBS_PER_QP_LOW))
                rxe_run_task(&qp->req.task, 1);
+
+       rxe_drop_ref(qp);
 }
 
 int rxe_send(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, struct sk_buff *skb)
@@ -473,6 +475,7 @@ int rxe_send(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, struct sk_buff *skb)
                return -EAGAIN;
        }
 
+       rxe_add_ref(pkt->qp);
        atomic_inc(&pkt->qp->skb_out);
        kfree_skb(skb);
 
index 073e66783f1dd8a4b62f9fc59a84319b507b51b8..07511718d98d8cd88da3b5dff46affbc21671c0e 100644 (file)
@@ -1240,6 +1240,8 @@ int rxe_register_device(struct rxe_dev *rxe)
        addrconf_addr_eui48((unsigned char *)&dev->node_guid,
                            rxe->ndev->dev_addr);
        dev->dev.dma_ops = &dma_virt_ops;
+       dma_coerce_mask_and_coherent(&dev->dev,
+                                    dma_get_required_mask(dev->dev.parent));
 
        dev->uverbs_abi_ver = RXE_UVERBS_ABI_VERSION;
        dev->uverbs_cmd_mask = BIT_ULL(IB_USER_VERBS_CMD_GET_CONTEXT)
index 7cbcfdac6529cc5a93f43212a3d05744985f814c..f87d104837dcfab7f0e35b5b7fcae1e021599bfc 100644 (file)
@@ -39,6 +39,7 @@
 #include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
 #include <linux/sched/signal.h>
+#include <linux/sched/mm.h>
 
 #include "ipoib.h"
 
@@ -954,7 +955,7 @@ void ipoib_cm_dev_stop(struct net_device *dev)
                        break;
                }
                spin_unlock_irq(&priv->lock);
-               msleep(1);
+               usleep_range(1000, 2000);
                ipoib_drain_cq(dev);
                spin_lock_irq(&priv->lock);
        }
@@ -1047,9 +1048,8 @@ static struct ib_qp *ipoib_cm_create_tx_qp(struct net_device *dev, struct ipoib_
                .sq_sig_type            = IB_SIGNAL_ALL_WR,
                .qp_type                = IB_QPT_RC,
                .qp_context             = tx,
-               .create_flags           = IB_QP_CREATE_USE_GFP_NOIO
+               .create_flags           = 0
        };
-
        struct ib_qp *tx_qp;
 
        if (dev->features & NETIF_F_SG)
@@ -1057,10 +1057,6 @@ static struct ib_qp *ipoib_cm_create_tx_qp(struct net_device *dev, struct ipoib_
                        min_t(u32, priv->ca->attrs.max_sge, MAX_SKB_FRAGS + 1);
 
        tx_qp = ib_create_qp(priv->pd, &attr);
-       if (PTR_ERR(tx_qp) == -EINVAL) {
-               attr.create_flags &= ~IB_QP_CREATE_USE_GFP_NOIO;
-               tx_qp = ib_create_qp(priv->pd, &attr);
-       }
        tx->max_send_sge = attr.cap.max_send_sge;
        return tx_qp;
 }
@@ -1131,10 +1127,11 @@ static int ipoib_cm_tx_init(struct ipoib_cm_tx *p, u32 qpn,
                            struct sa_path_rec *pathrec)
 {
        struct ipoib_dev_priv *priv = ipoib_priv(p->dev);
+       unsigned int noio_flag;
        int ret;
 
-       p->tx_ring = __vmalloc(ipoib_sendq_size * sizeof *p->tx_ring,
-                              GFP_NOIO, PAGE_KERNEL);
+       noio_flag = memalloc_noio_save();
+       p->tx_ring = vzalloc(ipoib_sendq_size * sizeof(*p->tx_ring));
        if (!p->tx_ring) {
                ret = -ENOMEM;
                goto err_tx;
@@ -1142,9 +1139,10 @@ static int ipoib_cm_tx_init(struct ipoib_cm_tx *p, u32 qpn,
        memset(p->tx_ring, 0, ipoib_sendq_size * sizeof *p->tx_ring);
 
        p->qp = ipoib_cm_create_tx_qp(p->dev, p);
+       memalloc_noio_restore(noio_flag);
        if (IS_ERR(p->qp)) {
                ret = PTR_ERR(p->qp);
-               ipoib_warn(priv, "failed to allocate tx qp: %d\n", ret);
+               ipoib_warn(priv, "failed to create tx qp: %d\n", ret);
                goto err_qp;
        }
 
@@ -1206,7 +1204,7 @@ static void ipoib_cm_tx_destroy(struct ipoib_cm_tx *p)
                                goto timeout;
                        }
 
-                       msleep(1);
+                       usleep_range(1000, 2000);
                }
        }
 
index efe7402f48852195efae4fc70cf843d0398dda30..57a9655e844deb1cc2eb57d9485f98e195368ac5 100644 (file)
@@ -770,7 +770,7 @@ int ipoib_ib_dev_stop_default(struct net_device *dev)
 
                ipoib_drain_cq(dev);
 
-               msleep(1);
+               usleep_range(1000, 2000);
        }
 
        ipoib_dbg(priv, "All sends and receives done.\n");
index 6e86eeee370e86602977bbf3f3949bf2d5ac26ef..70dacaf9044ecdd7b6c0be0ba20cd913cb66a4d4 100644 (file)
@@ -233,6 +233,7 @@ static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_featu
 static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
 {
        struct ipoib_dev_priv *priv = ipoib_priv(dev);
+       int ret = 0;
 
        /* dev->mtu > 2K ==> connected mode */
        if (ipoib_cm_admin_enabled(dev)) {
@@ -256,9 +257,34 @@ static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
                ipoib_dbg(priv, "MTU must be smaller than the underlying "
                                "link layer MTU - 4 (%u)\n", priv->mcast_mtu);
 
-       dev->mtu = min(priv->mcast_mtu, priv->admin_mtu);
+       new_mtu = min(priv->mcast_mtu, priv->admin_mtu);
 
-       return 0;
+       if (priv->rn_ops->ndo_change_mtu) {
+               bool carrier_status = netif_carrier_ok(dev);
+
+               netif_carrier_off(dev);
+
+               /* notify lower level on the real mtu */
+               ret = priv->rn_ops->ndo_change_mtu(dev, new_mtu);
+
+               if (carrier_status)
+                       netif_carrier_on(dev);
+       } else {
+               dev->mtu = new_mtu;
+       }
+
+       return ret;
+}
+
+static void ipoib_get_stats(struct net_device *dev,
+                           struct rtnl_link_stats64 *stats)
+{
+       struct ipoib_dev_priv *priv = ipoib_priv(dev);
+
+       if (priv->rn_ops->ndo_get_stats64)
+               priv->rn_ops->ndo_get_stats64(dev, stats);
+       else
+               netdev_stats_to_stats64(stats, &dev->stats);
 }
 
 /* Called with an RCU read lock taken */
@@ -1808,6 +1834,7 @@ static const struct net_device_ops ipoib_netdev_ops_pf = {
        .ndo_get_vf_stats        = ipoib_get_vf_stats,
        .ndo_set_vf_guid         = ipoib_set_vf_guid,
        .ndo_set_mac_address     = ipoib_set_mac,
+       .ndo_get_stats64         = ipoib_get_stats,
 };
 
 static const struct net_device_ops ipoib_netdev_ops_vf = {
index 5a887efb4bdf1b6405d3fc4342918084ae420b57..37b33d708c2dd5aecfa9bcc0328fb60876e9c310 100644 (file)
@@ -83,6 +83,7 @@ static struct scsi_host_template iscsi_iser_sht;
 static struct iscsi_transport iscsi_iser_transport;
 static struct scsi_transport_template *iscsi_iser_scsi_transport;
 static struct workqueue_struct *release_wq;
+static DEFINE_MUTEX(unbind_iser_conn_mutex);
 struct iser_global ig;
 
 int iser_debug_level = 0;
@@ -550,12 +551,14 @@ iscsi_iser_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         */
        if (iser_conn) {
                mutex_lock(&iser_conn->state_mutex);
+               mutex_lock(&unbind_iser_conn_mutex);
                iser_conn_terminate(iser_conn);
                iscsi_conn_stop(cls_conn, flag);
 
                /* unbind */
                iser_conn->iscsi_conn = NULL;
                conn->dd_data = NULL;
+               mutex_unlock(&unbind_iser_conn_mutex);
 
                complete(&iser_conn->stop_completion);
                mutex_unlock(&iser_conn->state_mutex);
@@ -977,13 +980,21 @@ static int iscsi_iser_slave_alloc(struct scsi_device *sdev)
        struct iser_conn *iser_conn;
        struct ib_device *ib_dev;
 
+       mutex_lock(&unbind_iser_conn_mutex);
+
        session = starget_to_session(scsi_target(sdev))->dd_data;
        iser_conn = session->leadconn->dd_data;
+       if (!iser_conn) {
+               mutex_unlock(&unbind_iser_conn_mutex);
+               return -ENOTCONN;
+       }
        ib_dev = iser_conn->ib_conn.device->ib_device;
 
        if (!(ib_dev->attrs.device_cap_flags & IB_DEVICE_SG_GAPS_REG))
                blk_queue_virt_boundary(sdev->request_queue, ~MASK_4K);
 
+       mutex_unlock(&unbind_iser_conn_mutex);
+
        return 0;
 }
 
index c538a38c91ce95acf8e00fcdf43fa28588ad2f49..26a004e97ae0fc3d4f7d257e725313f4b75ed82e 100644 (file)
@@ -708,8 +708,14 @@ iser_calc_scsi_params(struct iser_conn *iser_conn,
        unsigned short sg_tablesize, sup_sg_tablesize;
 
        sg_tablesize = DIV_ROUND_UP(max_sectors * 512, SIZE_4K);
-       sup_sg_tablesize = min_t(unsigned, ISCSI_ISER_MAX_SG_TABLESIZE,
-                                device->ib_device->attrs.max_fast_reg_page_list_len);
+       if (device->ib_device->attrs.device_cap_flags &
+                       IB_DEVICE_MEM_MGT_EXTENSIONS)
+               sup_sg_tablesize =
+                       min_t(
+                        uint, ISCSI_ISER_MAX_SG_TABLESIZE,
+                        device->ib_device->attrs.max_fast_reg_page_list_len);
+       else
+               sup_sg_tablesize = ISCSI_ISER_MAX_SG_TABLESIZE;
 
        iser_conn->scsi_sg_tablesize = min(sg_tablesize, sup_sg_tablesize);
 }
index dad85e74c37c051c02ea1b859db6aa5e66047731..3aae015469a5189a2592087fc40f27767c754316 100644 (file)
@@ -71,7 +71,7 @@ static void __init digicolor_set_gc(void __iomem *reg_base, unsigned irq_base,
 static int __init digicolor_of_init(struct device_node *node,
                                struct device_node *parent)
 {
-       static void __iomem *reg_base;
+       void __iomem *reg_base;
        unsigned int clr = IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
        struct regmap *ucregs;
        int ret;
index 54c296401525c1a97df216c2cd045f64c7ce0d60..18d58d2b4ffeb8b50e2df2179e95e15f3185d033 100644 (file)
@@ -43,7 +43,7 @@ static const struct of_device_id syscon_pldset_of_match[] = {
 static int __init
 realview_gic_of_init(struct device_node *node, struct device_node *parent)
 {
-       static struct regmap *map;
+       struct regmap *map;
        struct device_node *np;
        const struct of_device_id *gic_id;
        u32 pld1_ctrl;
index 0a8ed1c05518a9f7c2b08761338c9bcc56258985..14461cbfab2fa234d365a947cc4e3d68e90378ed 100644 (file)
@@ -154,7 +154,7 @@ asmlinkage void __weak plat_irq_dispatch(void)
 static int mips_cpu_intc_map(struct irq_domain *d, unsigned int irq,
                             irq_hw_number_t hw)
 {
-       static struct irq_chip *chip;
+       struct irq_chip *chip;
 
        if (hw < 2 && cpu_has_mipsmt) {
                /* Software interrupts are used for MT/CMT IPI */
index 832ebf4062f7016ae5a808325b7199021f3e6e47..6ab1d3afec02b39f4d8b26e9e30c280b316de156 100644 (file)
@@ -950,7 +950,6 @@ static void __init __gic_init(unsigned long gic_base_addr,
                                               &gic_irq_domain_ops, NULL);
        if (!gic_irq_domain)
                panic("Failed to add GIC IRQ domain");
-       gic_irq_domain->name = "mips-gic-irq";
 
        gic_ipi_domain = irq_domain_add_hierarchy(gic_irq_domain,
                                                  IRQ_DOMAIN_FLAG_IPI_PER_CPU,
@@ -959,7 +958,6 @@ static void __init __gic_init(unsigned long gic_base_addr,
        if (!gic_ipi_domain)
                panic("Failed to add GIC IPI domain");
 
-       gic_ipi_domain->name = "mips-gic-ipi";
        irq_domain_update_bus_token(gic_ipi_domain, DOMAIN_BUS_IPI);
 
        if (node &&
index 060d357f107f8c7720b08e6791dc352893c08fff..6f423bc49d0dcfa0a0bd4ef9321213dbd14de07e 100644 (file)
@@ -485,18 +485,19 @@ static int isdn_divert_icall(isdn_ctrl *ic)
                                cs->deflect_dest[0] = '\0';
                                retval = 4; /* only proceed */
                        }
-                       sprintf(cs->info, "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
-                               cs->akt_state,
-                               cs->divert_id,
-                               divert_if.drv_to_name(cs->ics.driver),
-                               (ic->command == ISDN_STAT_ICALLW) ? "1" : "0",
-                               cs->ics.parm.setup.phone,
-                               cs->ics.parm.setup.eazmsn,
-                               cs->ics.parm.setup.si1,
-                               cs->ics.parm.setup.si2,
-                               cs->ics.parm.setup.screen,
-                               dv->rule.waittime,
-                               cs->deflect_dest);
+                       snprintf(cs->info, sizeof(cs->info),
+                                "%d 0x%lx %s %s %s %s 0x%x 0x%x %d %d %s\n",
+                                cs->akt_state,
+                                cs->divert_id,
+                                divert_if.drv_to_name(cs->ics.driver),
+                                (ic->command == ISDN_STAT_ICALLW) ? "1" : "0",
+                                cs->ics.parm.setup.phone,
+                                cs->ics.parm.setup.eazmsn,
+                                cs->ics.parm.setup.si1,
+                                cs->ics.parm.setup.si2,
+                                cs->ics.parm.setup.screen,
+                                dv->rule.waittime,
+                                cs->deflect_dest);
                        if ((dv->rule.action == DEFLECT_REPORT) ||
                            (dv->rule.action == DEFLECT_REJECT)) {
                                put_info_buffer(cs->info);
index 40c7e2cf423bfeae548c484335cf9916d602fb38..034cabac699dc273d34653e73651ea3189483b62 100644 (file)
@@ -42,7 +42,7 @@ static char *revision = "$Revision: 1.1.2.2 $";
 
 static bool suppress_pollack;
 
-static struct pci_device_id c4_pci_tbl[] = {
+static const struct pci_device_id c4_pci_tbl[] = {
        { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21285, PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C4, 0, 0, (unsigned long)4 },
        { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21285, PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C2, 0, 0, (unsigned long)2 },
        { }                     /* Terminating entry */
index 8b7ad4f1ab0160aec609cdfb587b73c03d7c2b12..b2023e08dcd28b3c85783b7df51a3e3b35c0e2eb 100644 (file)
@@ -110,7 +110,7 @@ typedef struct _diva_os_thread_dpc {
 /*
   This table should be sorted by PCI device ID
 */
-static struct pci_device_id divas_pci_tbl[] = {
+static const struct pci_device_id divas_pci_tbl[] = {
        /* Diva Server BRI-2M PCI 0xE010 */
        { PCI_VDEVICE(EICON, PCI_DEVICE_ID_EICON_MAESTRA),
          CARDTYPE_MAESTRA_PCI },
index e3fa1cd64470ce48ba32ab797f4f063c62293f4b..dce6632daae1c4b5a0f43be11d80b99d995c5011 100644 (file)
@@ -1142,7 +1142,7 @@ fritz_remove_pci(struct pci_dev *pdev)
                        pr_info("%s: drvdata already removed\n", __func__);
 }
 
-static struct pci_device_id fcpci_ids[] = {
+static const struct pci_device_id fcpci_ids[] = {
        { PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_A1, PCI_ANY_ID, PCI_ANY_ID,
          0, 0, (unsigned long) "Fritz!Card PCI"},
        { PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_A1_V2, PCI_ANY_ID, PCI_ANY_ID,
index aea0c9616ea51cfac248e50958ac838fcf72f5a9..3cf07b8ced1c067c43c3aeae463e306ae1b22c99 100644 (file)
@@ -5348,7 +5348,7 @@ static const struct hm_map hfcm_map[] = {
 
 #undef H
 #define H(x)   ((unsigned long)&hfcm_map[x])
-static struct pci_device_id hfmultipci_ids[] = {
+static const struct pci_device_id hfmultipci_ids[] = {
 
        /* Cards with HFC-4S Chip */
        { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC4S, PCI_VENDOR_ID_CCD,
index 5dc246d71c167d5a69f449603cbd4a329a85fa9c..d2e401a8090e3dfde6969262a50a55fa0b1b7a9c 100644 (file)
@@ -2161,7 +2161,7 @@ static const struct _hfc_map hfc_map[] =
        {},
 };
 
-static struct pci_device_id hfc_ids[] =
+static const struct pci_device_id hfc_ids[] =
 {
        { PCI_VDEVICE(CCD, PCI_DEVICE_ID_CCD_2BD0),
          (unsigned long) &hfc_map[0] },
index afde4edef9ae895fa009fb5ad7305cc13af2c22e..6a6d848bd18eefc1d7400a49f64c02960a6b4592 100644 (file)
@@ -1137,7 +1137,7 @@ static void nj_remove(struct pci_dev *pdev)
 /* We cannot select cards with PCI_SUB... IDs, since here are cards with
  * SUB IDs set to PCI_ANY_ID, so we need to match all and reject
  * known other cards which not work with this driver - see probe function */
-static struct pci_device_id nj_pci_ids[] = {
+static const struct pci_device_id nj_pci_ids[] = {
        { PCI_VENDOR_ID_TIGERJET, PCI_DEVICE_ID_TIGERJET_300,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
        { }
index 3052c836b89f70bc441520e439635a6e91dd2248..d80072fef43415f2812169b2111391b3a6b5281e 100644 (file)
@@ -1398,7 +1398,7 @@ w6692_remove_pci(struct pci_dev *pdev)
                        pr_notice("%s: drvdata already removed\n", __func__);
 }
 
-static struct pci_device_id w6692_ids[] = {
+static const struct pci_device_id w6692_ids[] = {
        { PCI_VENDOR_ID_DYNALINK, PCI_DEVICE_ID_DYNALINK_IS64PH,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, (ulong)&w6692_map[0]},
        { PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_6692,
index c7d68675b02874e3661af07d1b8ad22ae8bcb887..7108bdb8742e7a41b5aac61ada26ad212211fe67 100644 (file)
@@ -1909,7 +1909,7 @@ static void EChannel_proc_rcv(struct hisax_d_if *d_if)
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
 
-static struct pci_device_id hisax_pci_tbl[] __used = {
+static const struct pci_device_id hisax_pci_tbl[] __used = {
 #ifdef CONFIG_HISAX_FRITZPCI
        {PCI_VDEVICE(AVM,      PCI_DEVICE_ID_AVM_A1)                    },
 #endif
index 90f051ce02590f3e70ee2e1227d7aa507441a24c..9090cc1e1f299a8b3a3296fa088b2f2cf33ef342 100644 (file)
@@ -86,7 +86,7 @@ typedef struct {
        char *device_name;
 } hfc4s8s_param;
 
-static struct pci_device_id hfc4s8s_ids[] = {
+static const struct pci_device_id hfc4s8s_ids[] = {
        {.vendor = PCI_VENDOR_ID_CCD,
         .device = PCI_DEVICE_ID_4S,
         .subvendor = 0x1397,
index 5a9f39ed1d5d97da6427e327786053f6f9ab5ecd..e4f7573ba9bf6777c5fcd8548e1fbdb298f3a499 100644 (file)
@@ -52,7 +52,7 @@ module_param(debug, int, 0);
 MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
 MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");
 
-static struct pci_device_id fcpci_ids[] = {
+static const struct pci_device_id fcpci_ids[] = {
        { .vendor      = PCI_VENDOR_ID_AVM,
          .device      = PCI_DEVICE_ID_AVM_A1,
          .subvendor   = PCI_ANY_ID,
index f4eace5ea184095eb0c170c4f3f1647f72b8c537..40f3cd7eab0fc69ef0ea3e79efa079a33fc78aaf 100644 (file)
@@ -156,7 +156,8 @@ static int read_sb_page(struct mddev *mddev, loff_t offset,
 
        rdev_for_each(rdev, mddev) {
                if (! test_bit(In_sync, &rdev->flags)
-                   || test_bit(Faulty, &rdev->flags))
+                   || test_bit(Faulty, &rdev->flags)
+                   || test_bit(Bitmap_sync, &rdev->flags))
                        continue;
 
                target = offset + index * (PAGE_SIZE/512);
index 991f0fe2dcc684a7f0cb2c5c51902b3dc9a19af8..b50eb4ac1b8291444e1af5196b44f5c7da368842 100644 (file)
@@ -134,7 +134,9 @@ enum flag_bits {
        Faulty,                 /* device is known to have a fault */
        In_sync,                /* device is in_sync with rest of array */
        Bitmap_sync,            /* ..actually, not quite In_sync.  Need a
-                                * bitmap-based recovery to get fully in sync
+                                * bitmap-based recovery to get fully in sync.
+                                * The bit is only meaningful before device
+                                * has been passed to pers->hot_add_disk.
                                 */
        WriteMostly,            /* Avoid reading if at all possible */
        AutoDetected,           /* added by auto-detect */
index 77cce3573aa85b40b6e2492ac458405426cdaf6e..44ad5baf320684e61b1aee1549d15b6e68c0a732 100644 (file)
@@ -1150,7 +1150,7 @@ int ppl_init_log(struct r5conf *conf)
                goto err;
        }
 
-       ppl_conf->bs = bioset_create(conf->raid_disks, 0, 0);
+       ppl_conf->bs = bioset_create(conf->raid_disks, 0, BIOSET_NEED_BVECS);
        if (!ppl_conf->bs) {
                ret = -ENOMEM;
                goto err;
index 2ceb338b094b2bd41c2a788ed5c9efe448bf1568..aeeb8d6854e2610dd2e006aa419264415d950da7 100644 (file)
@@ -7951,12 +7951,10 @@ static void end_reshape(struct r5conf *conf)
 {
 
        if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {
-               struct md_rdev *rdev;
 
                spin_lock_irq(&conf->device_lock);
                conf->previous_raid_disks = conf->raid_disks;
-               rdev_for_each(rdev, conf->mddev)
-                       rdev->data_offset = rdev->new_data_offset;
+               md_finish_reshape(conf->mddev);
                smp_wmb();
                conf->reshape_progress = MaxSector;
                conf->mddev->reshape_position = MaxSector;
index 14ff622190a5b90c827c1be8a0bd9ca54821ec4f..181839d6fbea44a8b6962f94703e4293645cc21c 100644 (file)
@@ -4596,7 +4596,7 @@ static int bond_check_params(struct bond_params *params)
        }
        ad_user_port_key = valptr->value;
 
-       if (bond_mode == BOND_MODE_TLB) {
+       if ((bond_mode == BOND_MODE_TLB) || (bond_mode == BOND_MODE_ALB)) {
                bond_opt_initstr(&newval, "default");
                valptr = bond_opt_parse(bond_opt_get(BOND_OPT_TLB_DYNAMIC_LB),
                                        &newval);
index e68d368e20ac84b636c9d62958c084ad80371787..7f36d3e3c98bc6727e765fef9fbc56bc8e695240 100644 (file)
@@ -1665,6 +1665,7 @@ static const struct b53_chip_data b53_switch_chips[] = {
                .dev_name = "BCM53125",
                .vlans = 4096,
                .enabled_ports = 0xff,
+               .arl_entries = 4,
                .cpu_port = B53_CPU_PORT,
                .vta_regs = B53_VTA_REGS,
                .duplex_reg = B53_DUPLEX_STAT_GE,
index 53b088166c28388d700e80a81df10d828f1edc90..5bcdd33101b00d0b492f87b2a3dc3e67bcf14f09 100644 (file)
@@ -3178,6 +3178,7 @@ static const struct mv88e6xxx_ops mv88e6390x_ops = {
        .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
        .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
        .port_pause_limit = mv88e6390_port_pause_limit,
+       .port_set_cmode = mv88e6390x_port_set_cmode,
        .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
        .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
        .stats_snapshot = mv88e6390_g1_stats_snapshot,
index d3906f6b01bd1f7e34f3182ebc14c9bdbbe672b7..86058a9f3417bc59613cb9c019638dc8a85a9731 100644 (file)
@@ -1785,16 +1785,18 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
 
        xgene_enet_gpiod_get(pdata);
 
-       pdata->clk = devm_clk_get(&pdev->dev, NULL);
-       if (IS_ERR(pdata->clk)) {
-               /* Abort if the clock is defined but couldn't be retrived.
-                * Always abort if the clock is missing on DT system as
-                * the driver can't cope with this case.
-                */
-               if (PTR_ERR(pdata->clk) != -ENOENT || dev->of_node)
-                       return PTR_ERR(pdata->clk);
-               /* Firmware may have set up the clock already. */
-               dev_info(dev, "clocks have been setup already\n");
+       if (pdata->phy_mode != PHY_INTERFACE_MODE_SGMII) {
+               pdata->clk = devm_clk_get(&pdev->dev, NULL);
+               if (IS_ERR(pdata->clk)) {
+                       /* Abort if the clock is defined but couldn't be
+                        * retrived. Always abort if the clock is missing on
+                        * DT system as the driver can't cope with this case.
+                        */
+                       if (PTR_ERR(pdata->clk) != -ENOENT || dev->of_node)
+                               return PTR_ERR(pdata->clk);
+                       /* Firmware may have set up the clock already. */
+                       dev_info(dev, "clocks have been setup already\n");
+               }
        }
 
        if (pdata->phy_mode != PHY_INTERFACE_MODE_XGMII)
index 73aca97a96bc70fb1e79f04ec2585589d0616cc5..d937083db9a4af74455156f389b50aee0b0fdf04 100644 (file)
@@ -50,11 +50,14 @@ static u32 platform_bgmac_idm_read(struct bgmac *bgmac, u16 offset)
 
 static void platform_bgmac_idm_write(struct bgmac *bgmac, u16 offset, u32 value)
 {
-       return writel(value, bgmac->plat.idm_base + offset);
+       writel(value, bgmac->plat.idm_base + offset);
 }
 
 static bool platform_bgmac_clk_enabled(struct bgmac *bgmac)
 {
+       if (!bgmac->plat.idm_base)
+               return true;
+
        if ((bgmac_idm_read(bgmac, BCMA_IOCTL) & BGMAC_CLK_EN) != BGMAC_CLK_EN)
                return false;
        if (bgmac_idm_read(bgmac, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET)
@@ -66,6 +69,9 @@ static void platform_bgmac_clk_enable(struct bgmac *bgmac, u32 flags)
 {
        u32 val;
 
+       if (!bgmac->plat.idm_base)
+               return;
+
        /* The Reset Control register only contains a single bit to show if the
         * controller is currently in reset.  Do a sanity check here, just in
         * case the bootloader happened to leave the device in reset.
@@ -180,6 +186,7 @@ static int bgmac_probe(struct platform_device *pdev)
        bgmac->feature_flags |= BGMAC_FEAT_CMDCFG_SR_REV4;
        bgmac->feature_flags |= BGMAC_FEAT_TX_MASK_SETUP;
        bgmac->feature_flags |= BGMAC_FEAT_RX_MASK_SETUP;
+       bgmac->feature_flags |= BGMAC_FEAT_IDM_MASK;
 
        bgmac->dev = &pdev->dev;
        bgmac->dma_dev = &pdev->dev;
@@ -207,15 +214,13 @@ static int bgmac_probe(struct platform_device *pdev)
                return PTR_ERR(bgmac->plat.base);
 
        regs = platform_get_resource_byname(pdev, IORESOURCE_MEM, "idm_base");
-       if (!regs) {
-               dev_err(&pdev->dev, "Unable to obtain idm resource\n");
-               return -EINVAL;
+       if (regs) {
+               bgmac->plat.idm_base = devm_ioremap_resource(&pdev->dev, regs);
+               if (IS_ERR(bgmac->plat.idm_base))
+                       return PTR_ERR(bgmac->plat.idm_base);
+               bgmac->feature_flags &= ~BGMAC_FEAT_IDM_MASK;
        }
 
-       bgmac->plat.idm_base = devm_ioremap_resource(&pdev->dev, regs);
-       if (IS_ERR(bgmac->plat.idm_base))
-               return PTR_ERR(bgmac->plat.idm_base);
-
        regs = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nicpm_base");
        if (regs) {
                bgmac->plat.nicpm_base = devm_ioremap_resource(&pdev->dev,
index ba4d2e145bb9bb81c32ade2e3855743e493c1c59..48d672b204a4847bc113635ed9534d8a3fd53066 100644 (file)
@@ -622,9 +622,11 @@ static int bgmac_dma_alloc(struct bgmac *bgmac)
        BUILD_BUG_ON(BGMAC_MAX_TX_RINGS > ARRAY_SIZE(ring_base));
        BUILD_BUG_ON(BGMAC_MAX_RX_RINGS > ARRAY_SIZE(ring_base));
 
-       if (!(bgmac_idm_read(bgmac, BCMA_IOST) & BCMA_IOST_DMA64)) {
-               dev_err(bgmac->dev, "Core does not report 64-bit DMA\n");
-               return -ENOTSUPP;
+       if (!(bgmac->feature_flags & BGMAC_FEAT_IDM_MASK)) {
+               if (!(bgmac_idm_read(bgmac, BCMA_IOST) & BCMA_IOST_DMA64)) {
+                       dev_err(bgmac->dev, "Core does not report 64-bit DMA\n");
+                       return -ENOTSUPP;
+               }
        }
 
        for (i = 0; i < BGMAC_MAX_TX_RINGS; i++) {
@@ -855,9 +857,11 @@ static void bgmac_mac_speed(struct bgmac *bgmac)
 static void bgmac_miiconfig(struct bgmac *bgmac)
 {
        if (bgmac->feature_flags & BGMAC_FEAT_FORCE_SPEED_2500) {
-               bgmac_idm_write(bgmac, BCMA_IOCTL,
-                               bgmac_idm_read(bgmac, BCMA_IOCTL) | 0x40 |
-                               BGMAC_BCMA_IOCTL_SW_CLKEN);
+               if (!(bgmac->feature_flags & BGMAC_FEAT_IDM_MASK)) {
+                       bgmac_idm_write(bgmac, BCMA_IOCTL,
+                                       bgmac_idm_read(bgmac, BCMA_IOCTL) |
+                                       0x40 | BGMAC_BCMA_IOCTL_SW_CLKEN);
+               }
                bgmac->mac_speed = SPEED_2500;
                bgmac->mac_duplex = DUPLEX_FULL;
                bgmac_mac_speed(bgmac);
@@ -874,11 +878,36 @@ static void bgmac_miiconfig(struct bgmac *bgmac)
        }
 }
 
+static void bgmac_chip_reset_idm_config(struct bgmac *bgmac)
+{
+       u32 iost;
+
+       iost = bgmac_idm_read(bgmac, BCMA_IOST);
+       if (bgmac->feature_flags & BGMAC_FEAT_IOST_ATTACHED)
+               iost &= ~BGMAC_BCMA_IOST_ATTACHED;
+
+       /* 3GMAC: for BCM4707 & BCM47094, only do core reset at bgmac_probe() */
+       if (!(bgmac->feature_flags & BGMAC_FEAT_NO_RESET)) {
+               u32 flags = 0;
+
+               if (iost & BGMAC_BCMA_IOST_ATTACHED) {
+                       flags = BGMAC_BCMA_IOCTL_SW_CLKEN;
+                       if (!bgmac->has_robosw)
+                               flags |= BGMAC_BCMA_IOCTL_SW_RESET;
+               }
+               bgmac_clk_enable(bgmac, flags);
+       }
+
+       if (iost & BGMAC_BCMA_IOST_ATTACHED && !bgmac->has_robosw)
+               bgmac_idm_write(bgmac, BCMA_IOCTL,
+                               bgmac_idm_read(bgmac, BCMA_IOCTL) &
+                               ~BGMAC_BCMA_IOCTL_SW_RESET);
+}
+
 /* http://bcm-v4.sipsolutions.net/mac-gbit/gmac/chipreset */
 static void bgmac_chip_reset(struct bgmac *bgmac)
 {
        u32 cmdcfg_sr;
-       u32 iost;
        int i;
 
        if (bgmac_clk_enabled(bgmac)) {
@@ -899,20 +928,8 @@ static void bgmac_chip_reset(struct bgmac *bgmac)
                /* TODO: Clear software multicast filter list */
        }
 
-       iost = bgmac_idm_read(bgmac, BCMA_IOST);
-       if (bgmac->feature_flags & BGMAC_FEAT_IOST_ATTACHED)
-               iost &= ~BGMAC_BCMA_IOST_ATTACHED;
-
-       /* 3GMAC: for BCM4707 & BCM47094, only do core reset at bgmac_probe() */
-       if (!(bgmac->feature_flags & BGMAC_FEAT_NO_RESET)) {
-               u32 flags = 0;
-               if (iost & BGMAC_BCMA_IOST_ATTACHED) {
-                       flags = BGMAC_BCMA_IOCTL_SW_CLKEN;
-                       if (!bgmac->has_robosw)
-                               flags |= BGMAC_BCMA_IOCTL_SW_RESET;
-               }
-               bgmac_clk_enable(bgmac, flags);
-       }
+       if (!(bgmac->feature_flags & BGMAC_FEAT_IDM_MASK))
+               bgmac_chip_reset_idm_config(bgmac);
 
        /* Request Misc PLL for corerev > 2 */
        if (bgmac->feature_flags & BGMAC_FEAT_MISC_PLL_REQ) {
@@ -970,11 +987,6 @@ static void bgmac_chip_reset(struct bgmac *bgmac)
                                      BGMAC_CHIPCTL_7_IF_TYPE_RGMII);
        }
 
-       if (iost & BGMAC_BCMA_IOST_ATTACHED && !bgmac->has_robosw)
-               bgmac_idm_write(bgmac, BCMA_IOCTL,
-                               bgmac_idm_read(bgmac, BCMA_IOCTL) &
-                               ~BGMAC_BCMA_IOCTL_SW_RESET);
-
        /* http://bcm-v4.sipsolutions.net/mac-gbit/gmac/gmac_reset
         * Specs don't say about using BGMAC_CMDCFG_SR, but in this routine
         * BGMAC_CMDCFG is read _after_ putting chip in a reset. So it has to
@@ -1497,8 +1509,10 @@ int bgmac_enet_probe(struct bgmac *bgmac)
        bgmac_clk_enable(bgmac, 0);
 
        /* This seems to be fixing IRQ by assigning OOB #6 to the core */
-       if (bgmac->feature_flags & BGMAC_FEAT_IRQ_ID_OOB_6)
-               bgmac_idm_write(bgmac, BCMA_OOB_SEL_OUT_A30, 0x86);
+       if (!(bgmac->feature_flags & BGMAC_FEAT_IDM_MASK)) {
+               if (bgmac->feature_flags & BGMAC_FEAT_IRQ_ID_OOB_6)
+                       bgmac_idm_write(bgmac, BCMA_OOB_SEL_OUT_A30, 0x86);
+       }
 
        bgmac_chip_reset(bgmac);
 
index c1818766c501f8a33b309495b02566c2c1a1cb5e..443d57b1026417b4feccbc79f562cc5462e90652 100644 (file)
 #define BGMAC_FEAT_CC4_IF_SW_TYPE      BIT(17)
 #define BGMAC_FEAT_CC4_IF_SW_TYPE_RGMII        BIT(18)
 #define BGMAC_FEAT_CC7_IF_TYPE_RGMII   BIT(19)
+#define BGMAC_FEAT_IDM_MASK            BIT(20)
 
 struct bgmac_slot_info {
        union {
index 43423744fdfa8151b2312bc84b41267965d6c92c..1e33abde4a3e8c833386df176896ad9684c9dc10 100644 (file)
@@ -2886,7 +2886,7 @@ static int bnx2x_test_nvram_tbl(struct bnx2x *bp,
 
 static int bnx2x_test_nvram(struct bnx2x *bp)
 {
-       const struct crc_pair nvram_tbl[] = {
+       static const struct crc_pair nvram_tbl[] = {
                {     0,  0x14 }, /* bootstrap */
                {  0x14,  0xec }, /* dir */
                { 0x100, 0x350 }, /* manuf_info */
@@ -2895,7 +2895,7 @@ static int bnx2x_test_nvram(struct bnx2x *bp)
                { 0x708,  0x70 }, /* manuf_key_info */
                {     0,     0 }
        };
-       const struct crc_pair nvram_tbl2[] = {
+       static const struct crc_pair nvram_tbl2[] = {
                { 0x7e8, 0x350 }, /* manuf_info2 */
                { 0xb38,  0xf0 }, /* feature_info */
                {     0,     0 }
@@ -3162,7 +3162,8 @@ static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
                if (is_multi(bp)) {
                        for_each_eth_queue(bp, i) {
                                memset(queue_name, 0, sizeof(queue_name));
-                               sprintf(queue_name, "%d", i);
+                               snprintf(queue_name, sizeof(queue_name),
+                                        "%d", i);
                                for (j = 0; j < BNX2X_NUM_Q_STATS; j++)
                                        snprintf(buf + (k + j)*ETH_GSTRING_LEN,
                                                ETH_GSTRING_LEN,
index daca1c9d254be4b4f2b513f1754c7534c104c757..7b0b399aaedd44778b96a38fe0fc5c7659494da5 100644 (file)
@@ -1202,12 +1202,21 @@ static struct enet_cb *bcmgenet_get_txcb(struct bcmgenet_priv *priv,
        return tx_cb_ptr;
 }
 
-/* Simple helper to free a control block's resources */
-static void bcmgenet_free_cb(struct enet_cb *cb)
+static struct enet_cb *bcmgenet_put_txcb(struct bcmgenet_priv *priv,
+                                        struct bcmgenet_tx_ring *ring)
 {
-       dev_kfree_skb_any(cb->skb);
-       cb->skb = NULL;
-       dma_unmap_addr_set(cb, dma_addr, 0);
+       struct enet_cb *tx_cb_ptr;
+
+       tx_cb_ptr = ring->cbs;
+       tx_cb_ptr += ring->write_ptr - ring->cb_ptr;
+
+       /* Rewinding local write pointer */
+       if (ring->write_ptr == ring->cb_ptr)
+               ring->write_ptr = ring->end_ptr;
+       else
+               ring->write_ptr--;
+
+       return tx_cb_ptr;
 }
 
 static inline void bcmgenet_rx_ring16_int_disable(struct bcmgenet_rx_ring *ring)
@@ -1260,18 +1269,72 @@ static inline void bcmgenet_tx_ring_int_disable(struct bcmgenet_tx_ring *ring)
                                 INTRL2_CPU_MASK_SET);
 }
 
+/* Simple helper to free a transmit control block's resources
+ * Returns an skb when the last transmit control block associated with the
+ * skb is freed.  The skb should be freed by the caller if necessary.
+ */
+static struct sk_buff *bcmgenet_free_tx_cb(struct device *dev,
+                                          struct enet_cb *cb)
+{
+       struct sk_buff *skb;
+
+       skb = cb->skb;
+
+       if (skb) {
+               cb->skb = NULL;
+               if (cb == GENET_CB(skb)->first_cb)
+                       dma_unmap_single(dev, dma_unmap_addr(cb, dma_addr),
+                                        dma_unmap_len(cb, dma_len),
+                                        DMA_TO_DEVICE);
+               else
+                       dma_unmap_page(dev, dma_unmap_addr(cb, dma_addr),
+                                      dma_unmap_len(cb, dma_len),
+                                      DMA_TO_DEVICE);
+               dma_unmap_addr_set(cb, dma_addr, 0);
+
+               if (cb == GENET_CB(skb)->last_cb)
+                       return skb;
+
+       } else if (dma_unmap_addr(cb, dma_addr)) {
+               dma_unmap_page(dev,
+                              dma_unmap_addr(cb, dma_addr),
+                              dma_unmap_len(cb, dma_len),
+                              DMA_TO_DEVICE);
+               dma_unmap_addr_set(cb, dma_addr, 0);
+       }
+
+       return 0;
+}
+
+/* Simple helper to free a receive control block's resources */
+static struct sk_buff *bcmgenet_free_rx_cb(struct device *dev,
+                                          struct enet_cb *cb)
+{
+       struct sk_buff *skb;
+
+       skb = cb->skb;
+       cb->skb = NULL;
+
+       if (dma_unmap_addr(cb, dma_addr)) {
+               dma_unmap_single(dev, dma_unmap_addr(cb, dma_addr),
+                                dma_unmap_len(cb, dma_len), DMA_FROM_DEVICE);
+               dma_unmap_addr_set(cb, dma_addr, 0);
+       }
+
+       return skb;
+}
+
 /* Unlocked version of the reclaim routine */
 static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
                                          struct bcmgenet_tx_ring *ring)
 {
        struct bcmgenet_priv *priv = netdev_priv(dev);
-       struct device *kdev = &priv->pdev->dev;
-       struct enet_cb *tx_cb_ptr;
-       unsigned int pkts_compl = 0;
+       unsigned int txbds_processed = 0;
        unsigned int bytes_compl = 0;
-       unsigned int c_index;
+       unsigned int pkts_compl = 0;
        unsigned int txbds_ready;
-       unsigned int txbds_processed = 0;
+       unsigned int c_index;
+       struct sk_buff *skb;
 
        /* Clear status before servicing to reduce spurious interrupts */
        if (ring->index == DESC_INDEX)
@@ -1292,21 +1355,12 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
 
        /* Reclaim transmitted buffers */
        while (txbds_processed < txbds_ready) {
-               tx_cb_ptr = &priv->tx_cbs[ring->clean_ptr];
-               if (tx_cb_ptr->skb) {
+               skb = bcmgenet_free_tx_cb(&priv->pdev->dev,
+                                         &priv->tx_cbs[ring->clean_ptr]);
+               if (skb) {
                        pkts_compl++;
-                       bytes_compl += GENET_CB(tx_cb_ptr->skb)->bytes_sent;
-                       dma_unmap_single(kdev,
-                                        dma_unmap_addr(tx_cb_ptr, dma_addr),
-                                        dma_unmap_len(tx_cb_ptr, dma_len),
-                                        DMA_TO_DEVICE);
-                       bcmgenet_free_cb(tx_cb_ptr);
-               } else if (dma_unmap_addr(tx_cb_ptr, dma_addr)) {
-                       dma_unmap_page(kdev,
-                                      dma_unmap_addr(tx_cb_ptr, dma_addr),
-                                      dma_unmap_len(tx_cb_ptr, dma_len),
-                                      DMA_TO_DEVICE);
-                       dma_unmap_addr_set(tx_cb_ptr, dma_addr, 0);
+                       bytes_compl += GENET_CB(skb)->bytes_sent;
+                       dev_kfree_skb_any(skb);
                }
 
                txbds_processed++;
@@ -1380,95 +1434,6 @@ static void bcmgenet_tx_reclaim_all(struct net_device *dev)
        bcmgenet_tx_reclaim(dev, &priv->tx_rings[DESC_INDEX]);
 }
 
-/* Transmits a single SKB (either head of a fragment or a single SKB)
- * caller must hold priv->lock
- */
-static int bcmgenet_xmit_single(struct net_device *dev,
-                               struct sk_buff *skb,
-                               u16 dma_desc_flags,
-                               struct bcmgenet_tx_ring *ring)
-{
-       struct bcmgenet_priv *priv = netdev_priv(dev);
-       struct device *kdev = &priv->pdev->dev;
-       struct enet_cb *tx_cb_ptr;
-       unsigned int skb_len;
-       dma_addr_t mapping;
-       u32 length_status;
-       int ret;
-
-       tx_cb_ptr = bcmgenet_get_txcb(priv, ring);
-
-       if (unlikely(!tx_cb_ptr))
-               BUG();
-
-       tx_cb_ptr->skb = skb;
-
-       skb_len = skb_headlen(skb);
-
-       mapping = dma_map_single(kdev, skb->data, skb_len, DMA_TO_DEVICE);
-       ret = dma_mapping_error(kdev, mapping);
-       if (ret) {
-               priv->mib.tx_dma_failed++;
-               netif_err(priv, tx_err, dev, "Tx DMA map failed\n");
-               dev_kfree_skb(skb);
-               return ret;
-       }
-
-       dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
-       dma_unmap_len_set(tx_cb_ptr, dma_len, skb_len);
-       length_status = (skb_len << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
-                       (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT) |
-                       DMA_TX_APPEND_CRC;
-
-       if (skb->ip_summed == CHECKSUM_PARTIAL)
-               length_status |= DMA_TX_DO_CSUM;
-
-       dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping, length_status);
-
-       return 0;
-}
-
-/* Transmit a SKB fragment */
-static int bcmgenet_xmit_frag(struct net_device *dev,
-                             skb_frag_t *frag,
-                             u16 dma_desc_flags,
-                             struct bcmgenet_tx_ring *ring)
-{
-       struct bcmgenet_priv *priv = netdev_priv(dev);
-       struct device *kdev = &priv->pdev->dev;
-       struct enet_cb *tx_cb_ptr;
-       unsigned int frag_size;
-       dma_addr_t mapping;
-       int ret;
-
-       tx_cb_ptr = bcmgenet_get_txcb(priv, ring);
-
-       if (unlikely(!tx_cb_ptr))
-               BUG();
-
-       tx_cb_ptr->skb = NULL;
-
-       frag_size = skb_frag_size(frag);
-
-       mapping = skb_frag_dma_map(kdev, frag, 0, frag_size, DMA_TO_DEVICE);
-       ret = dma_mapping_error(kdev, mapping);
-       if (ret) {
-               priv->mib.tx_dma_failed++;
-               netif_err(priv, tx_err, dev, "%s: Tx DMA map failed\n",
-                         __func__);
-               return ret;
-       }
-
-       dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
-       dma_unmap_len_set(tx_cb_ptr, dma_len, frag_size);
-
-       dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping,
-                   (frag_size << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
-                   (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT));
-
-       return 0;
-}
-
 /* Reallocate the SKB to put enough headroom in front of it and insert
  * the transmit checksum offsets in the descriptors
  */
@@ -1535,11 +1500,16 @@ static struct sk_buff *bcmgenet_put_tx_csum(struct net_device *dev,
 static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct bcmgenet_priv *priv = netdev_priv(dev);
+       struct device *kdev = &priv->pdev->dev;
        struct bcmgenet_tx_ring *ring = NULL;
+       struct enet_cb *tx_cb_ptr;
        struct netdev_queue *txq;
        unsigned long flags = 0;
        int nr_frags, index;
-       u16 dma_desc_flags;
+       dma_addr_t mapping;
+       unsigned int size;
+       skb_frag_t *frag;
+       u32 len_stat;
        int ret;
        int i;
 
@@ -1592,29 +1562,53 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
                }
        }
 
-       dma_desc_flags = DMA_SOP;
-       if (nr_frags == 0)
-               dma_desc_flags |= DMA_EOP;
+       for (i = 0; i <= nr_frags; i++) {
+               tx_cb_ptr = bcmgenet_get_txcb(priv, ring);
 
-       /* Transmit single SKB or head of fragment list */
-       ret = bcmgenet_xmit_single(dev, skb, dma_desc_flags, ring);
-       if (ret) {
-               ret = NETDEV_TX_OK;
-               goto out;
-       }
+               if (unlikely(!tx_cb_ptr))
+                       BUG();
+
+               if (!i) {
+                       /* Transmit single SKB or head of fragment list */
+                       GENET_CB(skb)->first_cb = tx_cb_ptr;
+                       size = skb_headlen(skb);
+                       mapping = dma_map_single(kdev, skb->data, size,
+                                                DMA_TO_DEVICE);
+               } else {
+                       /* xmit fragment */
+                       frag = &skb_shinfo(skb)->frags[i - 1];
+                       size = skb_frag_size(frag);
+                       mapping = skb_frag_dma_map(kdev, frag, 0, size,
+                                                  DMA_TO_DEVICE);
+               }
 
-       /* xmit fragment */
-       for (i = 0; i < nr_frags; i++) {
-               ret = bcmgenet_xmit_frag(dev,
-                                        &skb_shinfo(skb)->frags[i],
-                                        (i == nr_frags - 1) ? DMA_EOP : 0,
-                                        ring);
+               ret = dma_mapping_error(kdev, mapping);
                if (ret) {
+                       priv->mib.tx_dma_failed++;
+                       netif_err(priv, tx_err, dev, "Tx DMA map failed\n");
                        ret = NETDEV_TX_OK;
-                       goto out;
+                       goto out_unmap_frags;
+               }
+               dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
+               dma_unmap_len_set(tx_cb_ptr, dma_len, size);
+
+               tx_cb_ptr->skb = skb;
+
+               len_stat = (size << DMA_BUFLENGTH_SHIFT) |
+                          (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT);
+
+               if (!i) {
+                       len_stat |= DMA_TX_APPEND_CRC | DMA_SOP;
+                       if (skb->ip_summed == CHECKSUM_PARTIAL)
+                               len_stat |= DMA_TX_DO_CSUM;
                }
+               if (i == nr_frags)
+                       len_stat |= DMA_EOP;
+
+               dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping, len_stat);
        }
 
+       GENET_CB(skb)->last_cb = tx_cb_ptr;
        skb_tx_timestamp(skb);
 
        /* Decrement total BD count and advance our write pointer */
@@ -1635,6 +1629,19 @@ out:
        spin_unlock_irqrestore(&ring->lock, flags);
 
        return ret;
+
+out_unmap_frags:
+       /* Back up for failed control block mapping */
+       bcmgenet_put_txcb(priv, ring);
+
+       /* Unmap successfully mapped control blocks */
+       while (i-- > 0) {
+               tx_cb_ptr = bcmgenet_put_txcb(priv, ring);
+               bcmgenet_free_tx_cb(kdev, tx_cb_ptr);
+       }
+
+       dev_kfree_skb(skb);
+       goto out;
 }
 
 static struct sk_buff *bcmgenet_rx_refill(struct bcmgenet_priv *priv,
@@ -1666,14 +1673,12 @@ static struct sk_buff *bcmgenet_rx_refill(struct bcmgenet_priv *priv,
        }
 
        /* Grab the current Rx skb from the ring and DMA-unmap it */
-       rx_skb = cb->skb;
-       if (likely(rx_skb))
-               dma_unmap_single(kdev, dma_unmap_addr(cb, dma_addr),
-                                priv->rx_buf_len, DMA_FROM_DEVICE);
+       rx_skb = bcmgenet_free_rx_cb(kdev, cb);
 
        /* Put the new Rx skb on the ring */
        cb->skb = skb;
        dma_unmap_addr_set(cb, dma_addr, mapping);
+       dma_unmap_len_set(cb, dma_len, priv->rx_buf_len);
        dmadesc_set_addr(priv, cb->bd_addr, mapping);
 
        /* Return the current Rx skb to caller */
@@ -1880,22 +1885,16 @@ static int bcmgenet_alloc_rx_buffers(struct bcmgenet_priv *priv,
 
 static void bcmgenet_free_rx_buffers(struct bcmgenet_priv *priv)
 {
-       struct device *kdev = &priv->pdev->dev;
+       struct sk_buff *skb;
        struct enet_cb *cb;
        int i;
 
        for (i = 0; i < priv->num_rx_bds; i++) {
                cb = &priv->rx_cbs[i];
 
-               if (dma_unmap_addr(cb, dma_addr)) {
-                       dma_unmap_single(kdev,
-                                        dma_unmap_addr(cb, dma_addr),
-                                        priv->rx_buf_len, DMA_FROM_DEVICE);
-                       dma_unmap_addr_set(cb, dma_addr, 0);
-               }
-
-               if (cb->skb)
-                       bcmgenet_free_cb(cb);
+               skb = bcmgenet_free_rx_cb(&priv->pdev->dev, cb);
+               if (skb)
+                       dev_kfree_skb_any(skb);
        }
 }
 
@@ -2479,8 +2478,10 @@ static int bcmgenet_dma_teardown(struct bcmgenet_priv *priv)
 
 static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
 {
-       int i;
        struct netdev_queue *txq;
+       struct sk_buff *skb;
+       struct enet_cb *cb;
+       int i;
 
        bcmgenet_fini_rx_napi(priv);
        bcmgenet_fini_tx_napi(priv);
@@ -2489,10 +2490,10 @@ static void bcmgenet_fini_dma(struct bcmgenet_priv *priv)
        bcmgenet_dma_teardown(priv);
 
        for (i = 0; i < priv->num_tx_bds; i++) {
-               if (priv->tx_cbs[i].skb != NULL) {
-                       dev_kfree_skb(priv->tx_cbs[i].skb);
-                       priv->tx_cbs[i].skb = NULL;
-               }
+               cb = priv->tx_cbs + i;
+               skb = bcmgenet_free_tx_cb(&priv->pdev->dev, cb);
+               if (skb)
+                       dev_kfree_skb(skb);
        }
 
        for (i = 0; i < priv->hw_params->tx_queues; i++) {
index efd07020b89fc3a7bd3c68fce1bbd7fe406acfcf..b9344de669f84d2d1fa8e983c704b97ba09c7195 100644 (file)
@@ -544,6 +544,8 @@ struct bcmgenet_hw_params {
 };
 
 struct bcmgenet_skb_cb {
+       struct enet_cb *first_cb;       /* First control block of SKB */
+       struct enet_cb *last_cb;        /* Last control block of SKB */
        unsigned int bytes_sent;        /* bytes on the wire (no TSB) */
 };
 
index 28ecda3d34049342b6e58c108dd22679cb4ad8cc..ebd353bc78ffa1ea6ed3673d95b0cf365d8eb054 100644 (file)
@@ -335,7 +335,7 @@ lio_ethtool_get_channels(struct net_device *dev,
 
 static int lio_get_eeprom_len(struct net_device *netdev)
 {
-       u8 buf[128];
+       u8 buf[192];
        struct lio *lio = GET_LIO(netdev);
        struct octeon_device *oct_dev = lio->oct_dev;
        struct octeon_board_info *board_info;
index a0ca68ce3fbb164ea6e6a2c75a36a8c1ae54172d..79112563a25ae08db35bfb2de214c2b3e84a15a6 100644 (file)
@@ -1008,7 +1008,7 @@ static void bgx_print_qlm_mode(struct bgx *bgx, u8 lmacid)
 {
        struct device *dev = &bgx->pdev->dev;
        struct lmac *lmac;
-       char str[20];
+       char str[27];
 
        if (!bgx->is_dlm && lmacid)
                return;
index 50517cfd9671574c630b676ecec2892eb304b4d9..9f9d6cae39d555057ba63ac6ee874d0884c0c51d 100644 (file)
@@ -441,7 +441,8 @@ void cxgb4_ptp_init(struct adapter *adapter)
 
        adapter->ptp_clock = ptp_clock_register(&adapter->ptp_clock_info,
                                                &adapter->pdev->dev);
-       if (!adapter->ptp_clock) {
+       if (IS_ERR_OR_NULL(adapter->ptp_clock)) {
+               adapter->ptp_clock = NULL;
                dev_err(adapter->pdev_dev,
                        "PTP %s Clock registration has failed\n", __func__);
                return;
index 99987d8e437e2a09c3ddccffae916dd2804a0020..aa28299aef5f64d222f087f33965cf7ce8ffa008 100644 (file)
@@ -174,6 +174,8 @@ CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN
        CH_PCI_ID_TABLE_FENTRY(0x50a0), /* Custom T540-CR */
        CH_PCI_ID_TABLE_FENTRY(0x50a1), /* Custom T540-CR */
        CH_PCI_ID_TABLE_FENTRY(0x50a2), /* Custom T540-KR4 */
+       CH_PCI_ID_TABLE_FENTRY(0x50a3), /* Custom T580-KR4 */
+       CH_PCI_ID_TABLE_FENTRY(0x50a4), /* Custom 2x T540-CR */
 
        /* T6 adapters:
         */
index ff864a187d5a71fa277f2907659621b9f87ffdcf..a37166ee577b71f4fc2ea07e82d1097c19b4bf66 100644 (file)
@@ -776,8 +776,9 @@ void hns_ae_update_led_status(struct hnae_handle *handle)
 
        assert(handle);
        mac_cb = hns_get_mac_cb(handle);
-       if (!mac_cb->cpld_ctrl)
+       if (mac_cb->media_type != HNAE_MEDIA_TYPE_FIBER)
                return;
+
        hns_set_led_opt(mac_cb);
 }
 
index 7a8addda726e3937d3d8813c08e7555a2b9bb278..408b63faf9a81ac9d4bb3e78af3fbfdeb4dbc407 100644 (file)
@@ -53,6 +53,34 @@ static u32 dsaf_read_sub(struct dsaf_device *dsaf_dev, u32 reg)
        return ret;
 }
 
+static void hns_dsaf_acpi_ledctrl_by_port(struct hns_mac_cb *mac_cb, u8 op_type,
+                                      u32 link, u32 port, u32 act)
+{
+       union acpi_object *obj;
+       union acpi_object obj_args[3], argv4;
+
+       obj_args[0].integer.type = ACPI_TYPE_INTEGER;
+       obj_args[0].integer.value = link;
+       obj_args[1].integer.type = ACPI_TYPE_INTEGER;
+       obj_args[1].integer.value = port;
+       obj_args[2].integer.type = ACPI_TYPE_INTEGER;
+       obj_args[2].integer.value = act;
+
+       argv4.type = ACPI_TYPE_PACKAGE;
+       argv4.package.count = 3;
+       argv4.package.elements = obj_args;
+
+       obj = acpi_evaluate_dsm(ACPI_HANDLE(mac_cb->dev),
+                               &hns_dsaf_acpi_dsm_guid, 0, op_type, &argv4);
+       if (!obj) {
+               dev_warn(mac_cb->dev, "ledctrl fail, link:%d port:%d act:%d!\n",
+                        link, port, act);
+               return;
+       }
+
+       ACPI_FREE(obj);
+}
+
 static void hns_cpld_set_led(struct hns_mac_cb *mac_cb, int link_status,
                             u16 speed, int data)
 {
@@ -93,6 +121,18 @@ static void hns_cpld_set_led(struct hns_mac_cb *mac_cb, int link_status,
        }
 }
 
+static void hns_cpld_set_led_acpi(struct hns_mac_cb *mac_cb, int link_status,
+                            u16 speed, int data)
+{
+       if (!mac_cb) {
+               pr_err("cpld_led_set mac_cb is null!\n");
+               return;
+       }
+
+       hns_dsaf_acpi_ledctrl_by_port(mac_cb, HNS_OP_LED_SET_FUNC,
+               link_status, mac_cb->mac_id, data);
+}
+
 static void cpld_led_reset(struct hns_mac_cb *mac_cb)
 {
        if (!mac_cb || !mac_cb->cpld_ctrl)
@@ -103,6 +143,20 @@ static void cpld_led_reset(struct hns_mac_cb *mac_cb)
        mac_cb->cpld_led_value = CPLD_LED_DEFAULT_VALUE;
 }
 
+static void cpld_led_reset_acpi(struct hns_mac_cb *mac_cb)
+{
+       if (!mac_cb) {
+               pr_err("cpld_led_reset mac_cb is null!\n");
+               return;
+       }
+
+       if (mac_cb->media_type != HNAE_MEDIA_TYPE_FIBER)
+                return;
+
+       hns_dsaf_acpi_ledctrl_by_port(mac_cb, HNS_OP_LED_SET_FUNC,
+               0, mac_cb->mac_id, 0);
+}
+
 static int cpld_set_led_id(struct hns_mac_cb *mac_cb,
                           enum hnae_led_state status)
 {
@@ -604,8 +658,8 @@ struct dsaf_misc_op *hns_misc_op_get(struct dsaf_device *dsaf_dev)
 
                misc_op->cfg_serdes_loopback = hns_mac_config_sds_loopback;
        } else if (is_acpi_node(dsaf_dev->dev->fwnode)) {
-               misc_op->cpld_set_led = hns_cpld_set_led;
-               misc_op->cpld_reset_led = cpld_led_reset;
+               misc_op->cpld_set_led = hns_cpld_set_led_acpi;
+               misc_op->cpld_reset_led = cpld_led_reset_acpi;
                misc_op->cpld_set_led_id = cpld_set_led_id;
 
                misc_op->dsaf_reset = hns_dsaf_rst_acpi;
index 249a4584401ad487629c03b92a52f728d3318307..b651c1210555bfe02ec7393486dff9291651afb8 100644 (file)
@@ -283,7 +283,7 @@ int mlx4_zone_add_one(struct mlx4_zone_allocator *zone_alloc,
 }
 
 /* Should be called under a lock */
-static int __mlx4_zone_remove_one_entry(struct mlx4_zone_entry *entry)
+static void __mlx4_zone_remove_one_entry(struct mlx4_zone_entry *entry)
 {
        struct mlx4_zone_allocator *zone_alloc = entry->allocator;
 
@@ -315,8 +315,6 @@ static int __mlx4_zone_remove_one_entry(struct mlx4_zone_entry *entry)
                }
                zone_alloc->mask = mask;
        }
-
-       return 0;
 }
 
 void mlx4_zone_allocator_destroy(struct mlx4_zone_allocator *zone_alloc)
@@ -457,7 +455,7 @@ struct mlx4_bitmap *mlx4_zone_get_bitmap(struct mlx4_zone_allocator *zones, u32
 int mlx4_zone_remove_one(struct mlx4_zone_allocator *zones, u32 uid)
 {
        struct mlx4_zone_entry *zone;
-       int res;
+       int res = 0;
 
        spin_lock(&zones->lock);
 
@@ -468,7 +466,7 @@ int mlx4_zone_remove_one(struct mlx4_zone_allocator *zones, u32 uid)
                goto out;
        }
 
-       res = __mlx4_zone_remove_one_entry(zone);
+       __mlx4_zone_remove_one_entry(zone);
 
 out:
        spin_unlock(&zones->lock);
@@ -578,7 +576,7 @@ out:
 }
 
 static int mlx4_buf_direct_alloc(struct mlx4_dev *dev, int size,
-                                struct mlx4_buf *buf, gfp_t gfp)
+                                struct mlx4_buf *buf)
 {
        dma_addr_t t;
 
@@ -587,7 +585,7 @@ static int mlx4_buf_direct_alloc(struct mlx4_dev *dev, int size,
        buf->page_shift   = get_order(size) + PAGE_SHIFT;
        buf->direct.buf   =
                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                   size, &t, gfp);
+                                   size, &t, GFP_KERNEL);
        if (!buf->direct.buf)
                return -ENOMEM;
 
@@ -607,10 +605,10 @@ static int mlx4_buf_direct_alloc(struct mlx4_dev *dev, int size,
  *  multiple pages, so we don't require too much contiguous memory.
  */
 int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
-                  struct mlx4_buf *buf, gfp_t gfp)
+                  struct mlx4_buf *buf)
 {
        if (size <= max_direct) {
-               return mlx4_buf_direct_alloc(dev, size, buf, gfp);
+               return mlx4_buf_direct_alloc(dev, size, buf);
        } else {
                dma_addr_t t;
                int i;
@@ -620,14 +618,14 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
                buf->npages     = buf->nbufs;
                buf->page_shift  = PAGE_SHIFT;
                buf->page_list   = kcalloc(buf->nbufs, sizeof(*buf->page_list),
-                                          gfp);
+                                          GFP_KERNEL);
                if (!buf->page_list)
                        return -ENOMEM;
 
                for (i = 0; i < buf->nbufs; ++i) {
                        buf->page_list[i].buf =
                                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                                   PAGE_SIZE, &t, gfp);
+                                                   PAGE_SIZE, &t, GFP_KERNEL);
                        if (!buf->page_list[i].buf)
                                goto err_free;
 
@@ -663,12 +661,11 @@ void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
 }
 EXPORT_SYMBOL_GPL(mlx4_buf_free);
 
-static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device,
-                                                gfp_t gfp)
+static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device)
 {
        struct mlx4_db_pgdir *pgdir;
 
-       pgdir = kzalloc(sizeof *pgdir, gfp);
+       pgdir = kzalloc(sizeof(*pgdir), GFP_KERNEL);
        if (!pgdir)
                return NULL;
 
@@ -676,7 +673,7 @@ static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device,
        pgdir->bits[0] = pgdir->order0;
        pgdir->bits[1] = pgdir->order1;
        pgdir->db_page = dma_alloc_coherent(dma_device, PAGE_SIZE,
-                                           &pgdir->db_dma, gfp);
+                                           &pgdir->db_dma, GFP_KERNEL);
        if (!pgdir->db_page) {
                kfree(pgdir);
                return NULL;
@@ -716,7 +713,7 @@ found:
        return 0;
 }
 
-int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp)
+int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_db_pgdir *pgdir;
@@ -728,7 +725,7 @@ int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp
                if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
                        goto out;
 
-       pgdir = mlx4_alloc_db_pgdir(&dev->persist->pdev->dev, gfp);
+       pgdir = mlx4_alloc_db_pgdir(&dev->persist->pdev->dev);
        if (!pgdir) {
                ret = -ENOMEM;
                goto out;
@@ -780,13 +777,13 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
 {
        int err;
 
-       err = mlx4_db_alloc(dev, &wqres->db, 1, GFP_KERNEL);
+       err = mlx4_db_alloc(dev, &wqres->db, 1);
        if (err)
                return err;
 
        *wqres->db.db = 0;
 
-       err = mlx4_buf_direct_alloc(dev, size, &wqres->buf, GFP_KERNEL);
+       err = mlx4_buf_direct_alloc(dev, size, &wqres->buf);
        if (err)
                goto err_db;
 
@@ -795,7 +792,7 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
        if (err)
                goto err_buf;
 
-       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, GFP_KERNEL);
+       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf);
        if (err)
                goto err_mtt;
 
index fa6d2354a0e910ee160863e3cbe21a512d77bf03..c56a511b918e034e10fdb055c77785ea4a90b27a 100644 (file)
@@ -224,11 +224,11 @@ int __mlx4_cq_alloc_icm(struct mlx4_dev *dev, int *cqn)
        if (*cqn == -1)
                return -ENOMEM;
 
-       err = mlx4_table_get(dev, &cq_table->table, *cqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &cq_table->table, *cqn);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn);
        if (err)
                goto err_put;
        return 0;
index e5fb89505a134dbbfc54ee8af136432e9dfcf573..436f7689a03212943d5ea70a2214774d2c940d97 100644 (file)
@@ -1042,7 +1042,7 @@ static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn,
        if (!context)
                return -ENOMEM;
 
-       err = mlx4_qp_alloc(mdev->dev, qpn, qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, qpn, qp);
        if (err) {
                en_err(priv, "Failed to allocate qp #%x\n", qpn);
                goto out;
@@ -1086,7 +1086,7 @@ int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
                en_err(priv, "Failed reserving drop qpn\n");
                return err;
        }
-       err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp);
        if (err) {
                en_err(priv, "Failed allocating drop qp\n");
                mlx4_qp_release_range(priv->mdev->dev, qpn, 1);
@@ -1158,8 +1158,7 @@ int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
        }
 
        /* Configure RSS indirection qp */
-       err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, rss_map->indir_qp,
-                           GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, rss_map->indir_qp);
        if (err) {
                en_err(priv, "Failed to allocate RSS indirection QP\n");
                goto rss_err;
index 4f3a9b27ce4ad647a8a932001f5b2e16e3525b92..73faa3d779214d86d3c653f9065518375039c7ce 100644 (file)
@@ -111,7 +111,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
                goto err_hwq_res;
        }
 
-       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->sp_qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->sp_qp);
        if (err) {
                en_err(priv, "Failed allocating qp %d\n", ring->qpn);
                goto err_reserve;
index e1f9e7cebf8f7adcf0a095513086b949c246aab6..5a7816e7c7b4e1ad129f176ae148d217cb5e86e6 100644 (file)
@@ -251,8 +251,7 @@ int mlx4_UNMAP_ICM_AUX(struct mlx4_dev *dev)
                        MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
 }
 
-int mlx4_table_get(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj,
-                  gfp_t gfp)
+int mlx4_table_get(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj)
 {
        u32 i = (obj & (table->num_obj - 1)) /
                        (MLX4_TABLE_CHUNK_SIZE / table->obj_size);
@@ -266,7 +265,7 @@ int mlx4_table_get(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj,
        }
 
        table->icm[i] = mlx4_alloc_icm(dev, MLX4_TABLE_CHUNK_SIZE >> PAGE_SHIFT,
-                                      (table->lowmem ? gfp : GFP_HIGHUSER) |
+                                      (table->lowmem ? GFP_KERNEL : GFP_HIGHUSER) |
                                       __GFP_NOWARN, table->coherent);
        if (!table->icm[i]) {
                ret = -ENOMEM;
@@ -363,7 +362,7 @@ int mlx4_table_get_range(struct mlx4_dev *dev, struct mlx4_icm_table *table,
        u32 i;
 
        for (i = start; i <= end; i += inc) {
-               err = mlx4_table_get(dev, table, i, GFP_KERNEL);
+               err = mlx4_table_get(dev, table, i);
                if (err)
                        goto fail;
        }
index 0c73645501509d752f8316da7c72fefe8deb03f9..dee67fa39107f890508e158e56b680af6496d74a 100644 (file)
@@ -71,8 +71,7 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                                gfp_t gfp_mask, int coherent);
 void mlx4_free_icm(struct mlx4_dev *dev, struct mlx4_icm *icm, int coherent);
 
-int mlx4_table_get(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj,
-                  gfp_t gfp);
+int mlx4_table_get(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj);
 void mlx4_table_put(struct mlx4_dev *dev, struct mlx4_icm_table *table, u32 obj);
 int mlx4_table_get_range(struct mlx4_dev *dev, struct mlx4_icm_table *table,
                         u32 start, u32 end);
index 30616cd0140d573573f5f334b937522a9a7c0974..706d7f21ac5c10b439ca3f9398c855488604a50d 100644 (file)
@@ -969,7 +969,7 @@ void mlx4_cleanup_cq_table(struct mlx4_dev *dev);
 void mlx4_cleanup_qp_table(struct mlx4_dev *dev);
 void mlx4_cleanup_srq_table(struct mlx4_dev *dev);
 void mlx4_cleanup_mcg_table(struct mlx4_dev *dev);
-int __mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn, gfp_t gfp);
+int __mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn);
 void __mlx4_qp_free_icm(struct mlx4_dev *dev, int qpn);
 int __mlx4_cq_alloc_icm(struct mlx4_dev *dev, int *cqn);
 void __mlx4_cq_free_icm(struct mlx4_dev *dev, int cqn);
@@ -977,7 +977,7 @@ int __mlx4_srq_alloc_icm(struct mlx4_dev *dev, int *srqn);
 void __mlx4_srq_free_icm(struct mlx4_dev *dev, int srqn);
 int __mlx4_mpt_reserve(struct mlx4_dev *dev);
 void __mlx4_mpt_release(struct mlx4_dev *dev, u32 index);
-int __mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index, gfp_t gfp);
+int __mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index);
 void __mlx4_mpt_free_icm(struct mlx4_dev *dev, u32 index);
 u32 __mlx4_alloc_mtt_range(struct mlx4_dev *dev, int order);
 void __mlx4_free_mtt_range(struct mlx4_dev *dev, u32 first_seg, int order);
index ce852ca22a968673b46d3f92d3a1ab3e526864fa..24282cd017d37e32d1653b1c3cb0bde1cc1af80a 100644 (file)
@@ -479,14 +479,14 @@ static void mlx4_mpt_release(struct mlx4_dev *dev, u32 index)
        __mlx4_mpt_release(dev, index);
 }
 
-int __mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index, gfp_t gfp)
+int __mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index)
 {
        struct mlx4_mr_table *mr_table = &mlx4_priv(dev)->mr_table;
 
-       return mlx4_table_get(dev, &mr_table->dmpt_table, index, gfp);
+       return mlx4_table_get(dev, &mr_table->dmpt_table, index);
 }
 
-static int mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index, gfp_t gfp)
+static int mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index)
 {
        u64 param = 0;
 
@@ -497,7 +497,7 @@ static int mlx4_mpt_alloc_icm(struct mlx4_dev *dev, u32 index, gfp_t gfp)
                                                        MLX4_CMD_TIME_CLASS_A,
                                                        MLX4_CMD_WRAPPED);
        }
-       return __mlx4_mpt_alloc_icm(dev, index, gfp);
+       return __mlx4_mpt_alloc_icm(dev, index);
 }
 
 void __mlx4_mpt_free_icm(struct mlx4_dev *dev, u32 index)
@@ -629,7 +629,7 @@ int mlx4_mr_enable(struct mlx4_dev *dev, struct mlx4_mr *mr)
        struct mlx4_mpt_entry *mpt_entry;
        int err;
 
-       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mr->key), GFP_KERNEL);
+       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mr->key));
        if (err)
                return err;
 
@@ -787,14 +787,13 @@ int mlx4_write_mtt(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
 EXPORT_SYMBOL_GPL(mlx4_write_mtt);
 
 int mlx4_buf_write_mtt(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
-                      struct mlx4_buf *buf, gfp_t gfp)
+                      struct mlx4_buf *buf)
 {
        u64 *page_list;
        int err;
        int i;
 
-       page_list = kmalloc(buf->npages * sizeof *page_list,
-                           gfp);
+       page_list = kcalloc(buf->npages, sizeof(*page_list), GFP_KERNEL);
        if (!page_list)
                return -ENOMEM;
 
@@ -841,7 +840,7 @@ int mlx4_mw_enable(struct mlx4_dev *dev, struct mlx4_mw *mw)
        struct mlx4_mpt_entry *mpt_entry;
        int err;
 
-       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mw->key), GFP_KERNEL);
+       err = mlx4_mpt_alloc_icm(dev, key_to_hw_index(mw->key));
        if (err)
                return err;
 
index 5a310d313e94d08d035c265e6b538c27dcf957c3..26747212526b074ea0fd4f8c6a0a274b34bb5033 100644 (file)
@@ -301,29 +301,29 @@ void mlx4_qp_release_range(struct mlx4_dev *dev, int base_qpn, int cnt)
 }
 EXPORT_SYMBOL_GPL(mlx4_qp_release_range);
 
-int __mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn, gfp_t gfp)
+int __mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_qp_table *qp_table = &priv->qp_table;
        int err;
 
-       err = mlx4_table_get(dev, &qp_table->qp_table, qpn, gfp);
+       err = mlx4_table_get(dev, &qp_table->qp_table, qpn);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &qp_table->auxc_table, qpn, gfp);
+       err = mlx4_table_get(dev, &qp_table->auxc_table, qpn);
        if (err)
                goto err_put_qp;
 
-       err = mlx4_table_get(dev, &qp_table->altc_table, qpn, gfp);
+       err = mlx4_table_get(dev, &qp_table->altc_table, qpn);
        if (err)
                goto err_put_auxc;
 
-       err = mlx4_table_get(dev, &qp_table->rdmarc_table, qpn, gfp);
+       err = mlx4_table_get(dev, &qp_table->rdmarc_table, qpn);
        if (err)
                goto err_put_altc;
 
-       err = mlx4_table_get(dev, &qp_table->cmpt_table, qpn, gfp);
+       err = mlx4_table_get(dev, &qp_table->cmpt_table, qpn);
        if (err)
                goto err_put_rdmarc;
 
@@ -345,7 +345,7 @@ err_out:
        return err;
 }
 
-static int mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn, gfp_t gfp)
+static int mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn)
 {
        u64 param = 0;
 
@@ -355,7 +355,7 @@ static int mlx4_qp_alloc_icm(struct mlx4_dev *dev, int qpn, gfp_t gfp)
                                    MLX4_CMD_ALLOC_RES, MLX4_CMD_TIME_CLASS_A,
                                    MLX4_CMD_WRAPPED);
        }
-       return __mlx4_qp_alloc_icm(dev, qpn, gfp);
+       return __mlx4_qp_alloc_icm(dev, qpn);
 }
 
 void __mlx4_qp_free_icm(struct mlx4_dev *dev, int qpn)
@@ -397,7 +397,7 @@ struct mlx4_qp *mlx4_qp_lookup(struct mlx4_dev *dev, u32 qpn)
        return qp;
 }
 
-int mlx4_qp_alloc(struct mlx4_dev *dev, int qpn, struct mlx4_qp *qp, gfp_t gfp)
+int mlx4_qp_alloc(struct mlx4_dev *dev, int qpn, struct mlx4_qp *qp)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_qp_table *qp_table = &priv->qp_table;
@@ -408,7 +408,7 @@ int mlx4_qp_alloc(struct mlx4_dev *dev, int qpn, struct mlx4_qp *qp, gfp_t gfp)
 
        qp->qpn = qpn;
 
-       err = mlx4_qp_alloc_icm(dev, qpn, gfp);
+       err = mlx4_qp_alloc_icm(dev, qpn);
        if (err)
                return err;
 
index 812783865205715e8e88ad66d4ccbfe7172ec6e5..215e21c3dc8a8ac80bbf4e7fa0735bcb24c7df33 100644 (file)
@@ -1822,7 +1822,7 @@ static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
                        return err;
 
                if (!fw_reserved(dev, qpn)) {
-                       err = __mlx4_qp_alloc_icm(dev, qpn, GFP_KERNEL);
+                       err = __mlx4_qp_alloc_icm(dev, qpn);
                        if (err) {
                                res_abort_move(dev, slave, RES_QP, qpn);
                                return err;
@@ -1909,7 +1909,7 @@ static int mpt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
                if (err)
                        return err;
 
-               err = __mlx4_mpt_alloc_icm(dev, mpt->key, GFP_KERNEL);
+               err = __mlx4_mpt_alloc_icm(dev, mpt->key);
                if (err) {
                        res_abort_move(dev, slave, RES_MPT, id);
                        return err;
index f44d089e2ca607e8b18cf46fdf0f713424171fe5..bedf5212682464651fe51d2a12a6ed41a8777f6d 100644 (file)
@@ -100,11 +100,11 @@ int __mlx4_srq_alloc_icm(struct mlx4_dev *dev, int *srqn)
        if (*srqn == -1)
                return -ENOMEM;
 
-       err = mlx4_table_get(dev, &srq_table->table, *srqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &srq_table->table, *srqn);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &srq_table->cmpt_table, *srqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &srq_table->cmpt_table, *srqn);
        if (err)
                goto err_put;
        return 0;
index 746d94e28470f74a1b0e546fbce0eac6b344a281..60850bfa3d32e5d574bddacda871cb75da2076fd 100644 (file)
@@ -766,11 +766,13 @@ static void emac_shutdown(struct platform_device *pdev)
        struct emac_adapter *adpt = netdev_priv(netdev);
        struct emac_sgmii *sgmii = &adpt->phy;
 
-       /* Closing the SGMII turns off its interrupts */
-       sgmii->close(adpt);
+       if (netdev->flags & IFF_UP) {
+               /* Closing the SGMII turns off its interrupts */
+               sgmii->close(adpt);
 
-       /* Resetting the MAC turns off all DMA and its interrupts */
-       emac_mac_reset(adpt);
+               /* Resetting the MAC turns off all DMA and its interrupts */
+               emac_mac_reset(adpt);
+       }
 }
 
 static struct platform_driver emac_platform_driver = {
index b607936e1b3ec4ae93225106ac0eb53e15c892a6..9c0488e0f08ec2af6e075acd696c54900a648325 100644 (file)
@@ -90,17 +90,13 @@ struct ioc3_private {
        spinlock_t ioc3_lock;
        struct mii_if_info mii;
 
+       struct net_device *dev;
        struct pci_dev *pdev;
 
        /* Members used by autonegotiation  */
        struct timer_list ioc3_timer;
 };
 
-static inline struct net_device *priv_netdev(struct ioc3_private *dev)
-{
-       return (void *)dev - ((sizeof(struct net_device) + 31) & ~31);
-}
-
 static int ioc3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static void ioc3_set_multicast_list(struct net_device *dev);
 static int ioc3_start_xmit(struct sk_buff *skb, struct net_device *dev);
@@ -427,7 +423,7 @@ static void ioc3_get_eaddr_nic(struct ioc3_private *ip)
                nic[i] = nic_read_byte(ioc3);
 
        for (i = 2; i < 8; i++)
-               priv_netdev(ip)->dev_addr[i - 2] = nic[i];
+               ip->dev->dev_addr[i - 2] = nic[i];
 }
 
 /*
@@ -439,7 +435,7 @@ static void ioc3_get_eaddr(struct ioc3_private *ip)
 {
        ioc3_get_eaddr_nic(ip);
 
-       printk("Ethernet address is %pM.\n", priv_netdev(ip)->dev_addr);
+       printk("Ethernet address is %pM.\n", ip->dev->dev_addr);
 }
 
 static void __ioc3_set_mac_address(struct net_device *dev)
@@ -790,13 +786,12 @@ static void ioc3_timer(unsigned long data)
  */
 static int ioc3_mii_init(struct ioc3_private *ip)
 {
-       struct net_device *dev = priv_netdev(ip);
        int i, found = 0, res = 0;
        int ioc3_phy_workaround = 1;
        u16 word;
 
        for (i = 0; i < 32; i++) {
-               word = ioc3_mdio_read(dev, i, MII_PHYSID1);
+               word = ioc3_mdio_read(ip->dev, i, MII_PHYSID1);
 
                if (word != 0xffff && word != 0x0000) {
                        found = 1;
@@ -1276,6 +1271,7 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        SET_NETDEV_DEV(dev, &pdev->dev);
 
        ip = netdev_priv(dev);
+       ip->dev = dev;
 
        dev->irq = pdev->irq;
 
index f233bf8b4ebb844d9b27ca8cf01947f066e5ba03..c4407e8e39a35a523bda481a9cc1787ab24bc608 100644 (file)
@@ -117,7 +117,7 @@ static void dwmac4_tx_queue_routing(struct mac_device_info *hw,
        void __iomem *ioaddr = hw->pcsr;
        u32 value;
 
-       const struct stmmac_rx_routing route_possibilities[] = {
+       static const struct stmmac_rx_routing route_possibilities[] = {
                { GMAC_RXQCTRL_AVCPQ_MASK, GMAC_RXQCTRL_AVCPQ_SHIFT },
                { GMAC_RXQCTRL_PTPQ_MASK, GMAC_RXQCTRL_PTPQ_SHIFT },
                { GMAC_RXQCTRL_DCBCPQ_MASK, GMAC_RXQCTRL_DCBCPQ_SHIFT },
index 1853f7ff6657562cc95e78bdf7954aa8203a7ccd..1763e48c84e2090678f4ffc1b55cf1d7a62382e4 100644 (file)
@@ -4120,8 +4120,15 @@ int stmmac_dvr_probe(struct device *device,
        if ((phyaddr >= 0) && (phyaddr <= 31))
                priv->plat->phy_addr = phyaddr;
 
-       if (priv->plat->stmmac_rst)
+       if (priv->plat->stmmac_rst) {
+               ret = reset_control_assert(priv->plat->stmmac_rst);
                reset_control_deassert(priv->plat->stmmac_rst);
+               /* Some reset controllers have only reset callback instead of
+                * assert + deassert callbacks pair.
+                */
+               if (ret == -ENOTSUPP)
+                       reset_control_reset(priv->plat->stmmac_rst);
+       }
 
        /* Init MAC and get the capabilities */
        ret = stmmac_hw_init(priv);
index 46cb7f8955a22ebf9143f18f993e2bdfd2aaf752..4bb04aaf9650e3c1973dcd85eea57239477b419d 100644 (file)
@@ -9532,7 +9532,7 @@ static struct niu_parent *niu_get_parent(struct niu *np,
                p = niu_new_parent(np, id, ptype);
 
        if (p) {
-               char port_name[6];
+               char port_name[8];
                int err;
 
                sprintf(port_name, "port%d", port);
@@ -9553,7 +9553,7 @@ static void niu_put_parent(struct niu *np)
 {
        struct niu_parent *p = np->parent;
        u8 port = np->port;
-       char port_name[6];
+       char port_name[8];
 
        BUG_ON(!p || p->ports[port] != np);
 
index 711fbbbc4b1f724fcebdaec80eda2eec1eef8551..163d8d16bc245b48a10390d7706b21fd603489a4 100644 (file)
@@ -654,6 +654,8 @@ static int bdx_ioctl_priv(struct net_device *ndev, struct ifreq *ifr, int cmd)
                        RET(-EFAULT);
                }
                DBG("%d 0x%x 0x%x\n", data[0], data[1], data[2]);
+       } else {
+               return -EOPNOTSUPP;
        }
 
        if (!capable(CAP_SYS_RAWIO))
index 1850e348f5555b67f253c7a8fc9cb927d9694f16..badd0a8caeb9e85d26a16d48b0eb892123276aaf 100644 (file)
@@ -3089,6 +3089,31 @@ static int cpsw_probe(struct platform_device *pdev)
                        cpsw->quirk_irq = true;
        }
 
+       ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
+
+       ndev->netdev_ops = &cpsw_netdev_ops;
+       ndev->ethtool_ops = &cpsw_ethtool_ops;
+       netif_napi_add(ndev, &cpsw->napi_rx, cpsw_rx_poll, CPSW_POLL_WEIGHT);
+       netif_tx_napi_add(ndev, &cpsw->napi_tx, cpsw_tx_poll, CPSW_POLL_WEIGHT);
+       cpsw_split_res(ndev);
+
+       /* register the network device */
+       SET_NETDEV_DEV(ndev, &pdev->dev);
+       ret = register_netdev(ndev);