Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-4.19/0141-4.19.42-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-4.19/0141-4.19.42-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3420 - (show annotations) (download)
    Fri Aug 2 11:47:50 2019 UTC (4 years, 9 months ago) by niro
    File size: 163046 byte(s) 
    -linux-4.19.42
    1 diff --git a/Makefile b/Makefile
    2 index ba3b8504b689..914d69b9e3fd 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,7 +1,7 @@
    6 # SPDX-License-Identifier: GPL-2.0
    7 VERSION = 4
    8 PATCHLEVEL = 19
    9 -SUBLEVEL = 41
    10 +SUBLEVEL = 42
    11 EXTRAVERSION =
    12 NAME = "People's Front"
    13
    14 diff --git a/arch/arm64/include/asm/futex.h b/arch/arm64/include/asm/futex.h
    15 index fd1e722f3821..c7e30a6ed56e 100644
    16 --- a/arch/arm64/include/asm/futex.h
    17 +++ b/arch/arm64/include/asm/futex.h
    18 @@ -23,26 +23,34 @@
    19
    20 #include <asm/errno.h>
    21
    22 +#define FUTEX_MAX_LOOPS 128 /* What's the largest number you can think of? */
    23 +
    24 #define __futex_atomic_op(insn, ret, oldval, uaddr, tmp, oparg) \
    25 do { \
    26 + unsigned int loops = FUTEX_MAX_LOOPS; \
    27 + \
    28 uaccess_enable(); \
    29 asm volatile( \
    30 " prfm pstl1strm, %2\n" \
    31 "1: ldxr %w1, %2\n" \
    32 insn "\n" \
    33 "2: stlxr %w0, %w3, %2\n" \
    34 -" cbnz %w0, 1b\n" \
    35 -" dmb ish\n" \
    36 +" cbz %w0, 3f\n" \
    37 +" sub %w4, %w4, %w0\n" \
    38 +" cbnz %w4, 1b\n" \
    39 +" mov %w0, %w7\n" \
    40 "3:\n" \
    41 +" dmb ish\n" \
    42 " .pushsection .fixup,\"ax\"\n" \
    43 " .align 2\n" \
    44 -"4: mov %w0, %w5\n" \
    45 +"4: mov %w0, %w6\n" \
    46 " b 3b\n" \
    47 " .popsection\n" \
    48 _ASM_EXTABLE(1b, 4b) \
    49 _ASM_EXTABLE(2b, 4b) \
    50 - : "=&r" (ret), "=&r" (oldval), "+Q" (*uaddr), "=&r" (tmp) \
    51 - : "r" (oparg), "Ir" (-EFAULT) \
    52 + : "=&r" (ret), "=&r" (oldval), "+Q" (*uaddr), "=&r" (tmp), \
    53 + "+r" (loops) \
    54 + : "r" (oparg), "Ir" (-EFAULT), "Ir" (-EAGAIN) \
    55 : "memory"); \
    56 uaccess_disable(); \
    57 } while (0)
    58 @@ -57,23 +65,23 @@ arch_futex_atomic_op_inuser(int op, int oparg, int *oval, u32 __user *_uaddr)
    59
    60 switch (op) {
    61 case FUTEX_OP_SET:
    62 - __futex_atomic_op("mov %w3, %w4",
    63 + __futex_atomic_op("mov %w3, %w5",
    64 ret, oldval, uaddr, tmp, oparg);
    65 break;
    66 case FUTEX_OP_ADD:
    67 - __futex_atomic_op("add %w3, %w1, %w4",
    68 + __futex_atomic_op("add %w3, %w1, %w5",
    69 ret, oldval, uaddr, tmp, oparg);
    70 break;
    71 case FUTEX_OP_OR:
    72 - __futex_atomic_op("orr %w3, %w1, %w4",
    73 + __futex_atomic_op("orr %w3, %w1, %w5",
    74 ret, oldval, uaddr, tmp, oparg);
    75 break;
    76 case FUTEX_OP_ANDN:
    77 - __futex_atomic_op("and %w3, %w1, %w4",
    78 + __futex_atomic_op("and %w3, %w1, %w5",
    79 ret, oldval, uaddr, tmp, ~oparg);
    80 break;
    81 case FUTEX_OP_XOR:
    82 - __futex_atomic_op("eor %w3, %w1, %w4",
    83 + __futex_atomic_op("eor %w3, %w1, %w5",
    84 ret, oldval, uaddr, tmp, oparg);
    85 break;
    86 default:
    87 @@ -93,6 +101,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *_uaddr,
    88 u32 oldval, u32 newval)
    89 {
    90 int ret = 0;
    91 + unsigned int loops = FUTEX_MAX_LOOPS;
    92 u32 val, tmp;
    93 u32 __user *uaddr;
    94
    95 @@ -104,20 +113,24 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *_uaddr,
    96 asm volatile("// futex_atomic_cmpxchg_inatomic\n"
    97 " prfm pstl1strm, %2\n"
    98 "1: ldxr %w1, %2\n"
    99 -" sub %w3, %w1, %w4\n"
    100 -" cbnz %w3, 3f\n"
    101 -"2: stlxr %w3, %w5, %2\n"
    102 -" cbnz %w3, 1b\n"
    103 -" dmb ish\n"
    104 +" sub %w3, %w1, %w5\n"
    105 +" cbnz %w3, 4f\n"
    106 +"2: stlxr %w3, %w6, %2\n"
    107 +" cbz %w3, 3f\n"
    108 +" sub %w4, %w4, %w3\n"
    109 +" cbnz %w4, 1b\n"
    110 +" mov %w0, %w8\n"
    111 "3:\n"
    112 +" dmb ish\n"
    113 +"4:\n"
    114 " .pushsection .fixup,\"ax\"\n"
    115 -"4: mov %w0, %w6\n"
    116 -" b 3b\n"
    117 +"5: mov %w0, %w7\n"
    118 +" b 4b\n"
    119 " .popsection\n"
    120 - _ASM_EXTABLE(1b, 4b)
    121 - _ASM_EXTABLE(2b, 4b)
    122 - : "+r" (ret), "=&r" (val), "+Q" (*uaddr), "=&r" (tmp)
    123 - : "r" (oldval), "r" (newval), "Ir" (-EFAULT)
    124 + _ASM_EXTABLE(1b, 5b)
    125 + _ASM_EXTABLE(2b, 5b)
    126 + : "+r" (ret), "=&r" (val), "+Q" (*uaddr), "=&r" (tmp), "+r" (loops)
    127 + : "r" (oldval), "r" (newval), "Ir" (-EFAULT), "Ir" (-EAGAIN)
    128 : "memory");
    129 uaccess_disable();
    130
    131 diff --git a/arch/mips/kernel/kgdb.c b/arch/mips/kernel/kgdb.c
    132 index eb6c0d582626..2c1e30ca7ee4 100644
    133 --- a/arch/mips/kernel/kgdb.c
    134 +++ b/arch/mips/kernel/kgdb.c
    135 @@ -33,6 +33,7 @@
    136 #include <asm/processor.h>
    137 #include <asm/sigcontext.h>
    138 #include <linux/uaccess.h>
    139 +#include <asm/irq_regs.h>
    140
    141 static struct hard_trap_info {
    142 unsigned char tt; /* Trap type code for MIPS R3xxx and R4xxx */
    143 @@ -214,7 +215,7 @@ static void kgdb_call_nmi_hook(void *ignored)
    144 old_fs = get_fs();
    145 set_fs(get_ds());
    146
    147 - kgdb_nmicallback(raw_smp_processor_id(), NULL);
    148 + kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
    149
    150 set_fs(old_fs);
    151 }
    152 diff --git a/arch/x86/events/intel/core.c b/arch/x86/events/intel/core.c
    153 index 3dd204d1dd19..f9958ad4d335 100644
    154 --- a/arch/x86/events/intel/core.c
    155 +++ b/arch/x86/events/intel/core.c
    156 @@ -3068,7 +3068,7 @@ static int intel_pmu_hw_config(struct perf_event *event)
    157 return ret;
    158
    159 if (event->attr.precise_ip) {
    160 - if (!event->attr.freq) {
    161 + if (!(event->attr.freq || event->attr.wakeup_events)) {
    162 event->hw.flags |= PERF_X86_EVENT_AUTO_RELOAD;
    163 if (!(event->attr.sample_type &
    164 ~intel_pmu_large_pebs_flags(event)))
    165 @@ -3447,6 +3447,12 @@ static void intel_pmu_cpu_starting(int cpu)
    166
    167 cpuc->lbr_sel = NULL;
    168
    169 + if (x86_pmu.flags & PMU_FL_TFA) {
    170 + WARN_ON_ONCE(cpuc->tfa_shadow);
    171 + cpuc->tfa_shadow = ~0ULL;
    172 + intel_set_tfa(cpuc, false);
    173 + }
    174 +
    175 if (x86_pmu.version > 1)
    176 flip_smm_bit(&x86_pmu.attr_freeze_on_smi);
    177
    178 diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
    179 index 23752dc99b00..dd64f586679e 100644
    180 --- a/drivers/block/virtio_blk.c
    181 +++ b/drivers/block/virtio_blk.c
    182 @@ -446,6 +446,8 @@ static int init_vq(struct virtio_blk *vblk)
    183 if (err)
    184 num_vqs = 1;
    185
    186 + num_vqs = min_t(unsigned int, nr_cpu_ids, num_vqs);
    187 +
    188 vblk->vqs = kmalloc_array(num_vqs, sizeof(*vblk->vqs), GFP_KERNEL);
    189 if (!vblk->vqs)
    190 return -ENOMEM;
    191 diff --git a/drivers/clk/meson/gxbb.c b/drivers/clk/meson/gxbb.c
    192 index 6628ffa31383..4d4f6d842c31 100644
    193 --- a/drivers/clk/meson/gxbb.c
    194 +++ b/drivers/clk/meson/gxbb.c
    195 @@ -1571,6 +1571,7 @@ static struct clk_regmap gxbb_vdec_1_div = {
    196 .offset = HHI_VDEC_CLK_CNTL,
    197 .shift = 0,
    198 .width = 7,
    199 + .flags = CLK_DIVIDER_ROUND_CLOSEST,
    200 },
    201 .hw.init = &(struct clk_init_data){
    202 .name = "vdec_1_div",
    203 @@ -1616,6 +1617,7 @@ static struct clk_regmap gxbb_vdec_hevc_div = {
    204 .offset = HHI_VDEC2_CLK_CNTL,
    205 .shift = 16,
    206 .width = 7,
    207 + .flags = CLK_DIVIDER_ROUND_CLOSEST,
    208 },
    209 .hw.init = &(struct clk_init_data){
    210 .name = "vdec_hevc_div",
    211 diff --git a/drivers/cpufreq/armada-37xx-cpufreq.c b/drivers/cpufreq/armada-37xx-cpufreq.c
    212 index 75491fc841a6..0df16eb1eb3c 100644
    213 --- a/drivers/cpufreq/armada-37xx-cpufreq.c
    214 +++ b/drivers/cpufreq/armada-37xx-cpufreq.c
    215 @@ -359,11 +359,11 @@ static int __init armada37xx_cpufreq_driver_init(void)
    216 struct armada_37xx_dvfs *dvfs;
    217 struct platform_device *pdev;
    218 unsigned long freq;
    219 - unsigned int cur_frequency;
    220 + unsigned int cur_frequency, base_frequency;
    221 struct regmap *nb_pm_base, *avs_base;
    222 struct device *cpu_dev;
    223 int load_lvl, ret;
    224 - struct clk *clk;
    225 + struct clk *clk, *parent;
    226
    227 nb_pm_base =
    228 syscon_regmap_lookup_by_compatible("marvell,armada-3700-nb-pm");
    229 @@ -399,6 +399,22 @@ static int __init armada37xx_cpufreq_driver_init(void)
    230 return PTR_ERR(clk);
    231 }
    232
    233 + parent = clk_get_parent(clk);
    234 + if (IS_ERR(parent)) {
    235 + dev_err(cpu_dev, "Cannot get parent clock for CPU0\n");
    236 + clk_put(clk);
    237 + return PTR_ERR(parent);
    238 + }
    239 +
    240 + /* Get parent CPU frequency */
    241 + base_frequency = clk_get_rate(parent);
    242 +
    243 + if (!base_frequency) {
    244 + dev_err(cpu_dev, "Failed to get parent clock rate for CPU\n");
    245 + clk_put(clk);
    246 + return -EINVAL;
    247 + }
    248 +
    249 /* Get nominal (current) CPU frequency */
    250 cur_frequency = clk_get_rate(clk);
    251 if (!cur_frequency) {
    252 @@ -431,7 +447,7 @@ static int __init armada37xx_cpufreq_driver_init(void)
    253 for (load_lvl = ARMADA_37XX_DVFS_LOAD_0; load_lvl < LOAD_LEVEL_NR;
    254 load_lvl++) {
    255 unsigned long u_volt = avs_map[dvfs->avs[load_lvl]] * 1000;
    256 - freq = cur_frequency / dvfs->divider[load_lvl];
    257 + freq = base_frequency / dvfs->divider[load_lvl];
    258 ret = dev_pm_opp_add(cpu_dev, freq, u_volt);
    259 if (ret)
    260 goto remove_opp;
    261 diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    262 index 2b8b892eb846..76ee2de43ea6 100644
    263 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    264 +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    265 @@ -4028,6 +4028,7 @@ static void handle_cursor_update(struct drm_plane *plane,
    266 amdgpu_crtc->cursor_width = plane->state->crtc_w;
    267 amdgpu_crtc->cursor_height = plane->state->crtc_h;
    268
    269 + memset(&attributes, 0, sizeof(attributes));
    270 attributes.address.high_part = upper_32_bits(address);
    271 attributes.address.low_part = lower_32_bits(address);
    272 attributes.width = plane->state->crtc_w;
    273 diff --git a/drivers/gpu/drm/mediatek/mtk_hdmi.c b/drivers/gpu/drm/mediatek/mtk_hdmi.c
    274 index 643f5edd68fe..62444a3a5742 100644
    275 --- a/drivers/gpu/drm/mediatek/mtk_hdmi.c
    276 +++ b/drivers/gpu/drm/mediatek/mtk_hdmi.c
    277 @@ -1473,7 +1473,6 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi,
    278 if (IS_ERR(regmap))
    279 ret = PTR_ERR(regmap);
    280 if (ret) {
    281 - ret = PTR_ERR(regmap);
    282 dev_err(dev,
    283 "Failed to get system configuration registers: %d\n",
    284 ret);
    285 @@ -1509,6 +1508,7 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi,
    286 of_node_put(remote);
    287
    288 hdmi->ddc_adpt = of_find_i2c_adapter_by_node(i2c_np);
    289 + of_node_put(i2c_np);
    290 if (!hdmi->ddc_adpt) {
    291 dev_err(dev, "Failed to get ddc i2c adapter by node\n");
    292 return -EINVAL;
    293 diff --git a/drivers/gpu/drm/omapdrm/dss/hdmi4_cec.c b/drivers/gpu/drm/omapdrm/dss/hdmi4_cec.c
    294 index 340383150fb9..ebf9c96d43ee 100644
    295 --- a/drivers/gpu/drm/omapdrm/dss/hdmi4_cec.c
    296 +++ b/drivers/gpu/drm/omapdrm/dss/hdmi4_cec.c
    297 @@ -175,6 +175,7 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
    298 REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0, 3, 3);
    299 hdmi_wp_clear_irqenable(core->wp, HDMI_IRQ_CORE);
    300 hdmi_wp_set_irqstatus(core->wp, HDMI_IRQ_CORE);
    301 + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
    302 hdmi4_core_disable(core);
    303 return 0;
    304 }
    305 @@ -182,16 +183,24 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
    306 if (err)
    307 return err;
    308
    309 + /*
    310 + * Initialize CEC clock divider: CEC needs 2MHz clock hence
    311 + * set the divider to 24 to get 48/24=2MHz clock
    312 + */
    313 + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
    314 +
    315 /* Clear TX FIFO */
    316 if (!hdmi_cec_clear_tx_fifo(adap)) {
    317 pr_err("cec-%s: could not clear TX FIFO\n", adap->name);
    318 - return -EIO;
    319 + err = -EIO;
    320 + goto err_disable_clk;
    321 }
    322
    323 /* Clear RX FIFO */
    324 if (!hdmi_cec_clear_rx_fifo(adap)) {
    325 pr_err("cec-%s: could not clear RX FIFO\n", adap->name);
    326 - return -EIO;
    327 + err = -EIO;
    328 + goto err_disable_clk;
    329 }
    330
    331 /* Clear CEC interrupts */
    332 @@ -236,6 +245,12 @@ static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
    333 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, temp);
    334 }
    335 return 0;
    336 +
    337 +err_disable_clk:
    338 + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
    339 + hdmi4_core_disable(core);
    340 +
    341 + return err;
    342 }
    343
    344 static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
    345 @@ -333,11 +348,8 @@ int hdmi4_cec_init(struct platform_device *pdev, struct hdmi_core_data *core,
    346 return ret;
    347 core->wp = wp;
    348
    349 - /*
    350 - * Initialize CEC clock divider: CEC needs 2MHz clock hence
    351 - * set the devider to 24 to get 48/24=2MHz clock
    352 - */
    353 - REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
    354 + /* Disable clock initially, hdmi_cec_adap_enable() manages it */
    355 + REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
    356
    357 ret = cec_register_adapter(core->adap, &pdev->dev);
    358 if (ret < 0) {
    359 diff --git a/drivers/gpu/drm/sun4i/sun8i_tcon_top.c b/drivers/gpu/drm/sun4i/sun8i_tcon_top.c
    360 index adcdf946c365..dfbcd1ad81a5 100644
    361 --- a/drivers/gpu/drm/sun4i/sun8i_tcon_top.c
    362 +++ b/drivers/gpu/drm/sun4i/sun8i_tcon_top.c
    363 @@ -217,7 +217,7 @@ static int sun8i_tcon_top_bind(struct device *dev, struct device *master,
    364
    365 err_unregister_gates:
    366 for (i = 0; i < CLK_NUM; i++)
    367 - if (clk_data->hws[i])
    368 + if (!IS_ERR_OR_NULL(clk_data->hws[i]))
    369 clk_hw_unregister_gate(clk_data->hws[i]);
    370 clk_disable_unprepare(tcon_top->bus);
    371 err_assert_reset:
    372 @@ -235,7 +235,8 @@ static void sun8i_tcon_top_unbind(struct device *dev, struct device *master,
    373
    374 of_clk_del_provider(dev->of_node);
    375 for (i = 0; i < CLK_NUM; i++)
    376 - clk_hw_unregister_gate(clk_data->hws[i]);
    377 + if (clk_data->hws[i])
    378 + clk_hw_unregister_gate(clk_data->hws[i]);
    379
    380 clk_disable_unprepare(tcon_top->bus);
    381 reset_control_assert(tcon_top->rst);
    382 diff --git a/drivers/hv/hv.c b/drivers/hv/hv.c
    383 index 748a1c4172a6..8e923e70e594 100644
    384 --- a/drivers/hv/hv.c
    385 +++ b/drivers/hv/hv.c
    386 @@ -402,7 +402,6 @@ int hv_synic_cleanup(unsigned int cpu)
    387
    388 clockevents_unbind_device(hv_cpu->clk_evt, cpu);
    389 hv_ce_shutdown(hv_cpu->clk_evt);
    390 - put_cpu_ptr(hv_cpu);
    391 }
    392
    393 hv_get_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
    394 diff --git a/drivers/hwtracing/intel_th/pci.c b/drivers/hwtracing/intel_th/pci.c
    395 index 1cf6290d6435..70f2cb90adc5 100644
    396 --- a/drivers/hwtracing/intel_th/pci.c
    397 +++ b/drivers/hwtracing/intel_th/pci.c
    398 @@ -165,6 +165,11 @@ static const struct pci_device_id intel_th_pci_id_table[] = {
    399 PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x34a6),
    400 .driver_data = (kernel_ulong_t)&intel_th_2x,
    401 },
    402 + {
    403 + /* Comet Lake */
    404 + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x02a6),
    405 + .driver_data = (kernel_ulong_t)&intel_th_2x,
    406 + },
    407 { 0 },
    408 };
    409
    410 diff --git a/drivers/infiniband/hw/hfi1/chip.c b/drivers/infiniband/hw/hfi1/chip.c
    411 index 902d12d6d88b..b12c8ff8ed66 100644
    412 --- a/drivers/infiniband/hw/hfi1/chip.c
    413 +++ b/drivers/infiniband/hw/hfi1/chip.c
    414 @@ -13388,7 +13388,7 @@ static int set_up_context_variables(struct hfi1_devdata *dd)
    415 int total_contexts;
    416 int ret;
    417 unsigned ngroups;
    418 - int qos_rmt_count;
    419 + int rmt_count;
    420 int user_rmt_reduced;
    421 u32 n_usr_ctxts;
    422 u32 send_contexts = chip_send_contexts(dd);
    423 @@ -13450,10 +13450,20 @@ static int set_up_context_variables(struct hfi1_devdata *dd)
    424 n_usr_ctxts = rcv_contexts - total_contexts;
    425 }
    426
    427 - /* each user context requires an entry in the RMT */
    428 - qos_rmt_count = qos_rmt_entries(dd, NULL, NULL);
    429 - if (qos_rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) {
    430 - user_rmt_reduced = NUM_MAP_ENTRIES - qos_rmt_count;
    431 + /*
    432 + * The RMT entries are currently allocated as shown below:
    433 + * 1. QOS (0 to 128 entries);
    434 + * 2. FECN for PSM (num_user_contexts + num_vnic_contexts);
    435 + * 3. VNIC (num_vnic_contexts).
    436 + * It should be noted that PSM FECN oversubscribe num_vnic_contexts
    437 + * entries of RMT because both VNIC and PSM could allocate any receive
    438 + * context between dd->first_dyn_alloc_text and dd->num_rcv_contexts,
    439 + * and PSM FECN must reserve an RMT entry for each possible PSM receive
    440 + * context.
    441 + */
    442 + rmt_count = qos_rmt_entries(dd, NULL, NULL) + (num_vnic_contexts * 2);
    443 + if (rmt_count + n_usr_ctxts > NUM_MAP_ENTRIES) {
    444 + user_rmt_reduced = NUM_MAP_ENTRIES - rmt_count;
    445 dd_dev_err(dd,
    446 "RMT size is reducing the number of user receive contexts from %u to %d\n",
    447 n_usr_ctxts,
    448 @@ -14441,9 +14451,11 @@ static void init_user_fecn_handling(struct hfi1_devdata *dd,
    449 u64 reg;
    450 int i, idx, regoff, regidx;
    451 u8 offset;
    452 + u32 total_cnt;
    453
    454 /* there needs to be enough room in the map table */
    455 - if (rmt->used + dd->num_user_contexts >= NUM_MAP_ENTRIES) {
    456 + total_cnt = dd->num_rcv_contexts - dd->first_dyn_alloc_ctxt;
    457 + if (rmt->used + total_cnt >= NUM_MAP_ENTRIES) {
    458 dd_dev_err(dd, "User FECN handling disabled - too many user contexts allocated\n");
    459 return;
    460 }
    461 @@ -14497,7 +14509,7 @@ static void init_user_fecn_handling(struct hfi1_devdata *dd,
    462 /* add rule 1 */
    463 add_rsm_rule(dd, RSM_INS_FECN, &rrd);
    464
    465 - rmt->used += dd->num_user_contexts;
    466 + rmt->used += total_cnt;
    467 }
    468
    469 /* Initialize RSM for VNIC */
    470 diff --git a/drivers/infiniband/hw/hfi1/rc.c b/drivers/infiniband/hw/hfi1/rc.c
    471 index 6f013a565353..770c78c65730 100644
    472 --- a/drivers/infiniband/hw/hfi1/rc.c
    473 +++ b/drivers/infiniband/hw/hfi1/rc.c
    474 @@ -2303,7 +2303,7 @@ send_last:
    475 update_ack_queue(qp, next);
    476 }
    477 e = &qp->s_ack_queue[qp->r_head_ack_queue];
    478 - if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {
    479 + if (e->rdma_sge.mr) {
    480 rvt_put_mr(e->rdma_sge.mr);
    481 e->rdma_sge.mr = NULL;
    482 }
    483 @@ -2377,7 +2377,7 @@ send_last:
    484 update_ack_queue(qp, next);
    485 }
    486 e = &qp->s_ack_queue[qp->r_head_ack_queue];
    487 - if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {
    488 + if (e->rdma_sge.mr) {
    489 rvt_put_mr(e->rdma_sge.mr);
    490 e->rdma_sge.mr = NULL;
    491 }
    492 diff --git a/drivers/infiniband/hw/hns/hns_roce_hem.c b/drivers/infiniband/hw/hns/hns_roce_hem.c
    493 index f6faefed96e8..a73d388b7093 100644
    494 --- a/drivers/infiniband/hw/hns/hns_roce_hem.c
    495 +++ b/drivers/infiniband/hw/hns/hns_roce_hem.c
    496 @@ -745,6 +745,8 @@ void *hns_roce_table_find(struct hns_roce_dev *hr_dev,
    497 idx_offset = (obj & (table->num_obj - 1)) % obj_per_chunk;
    498 dma_offset = offset = idx_offset * table->obj_size;
    499 } else {
    500 + u32 seg_size = 64; /* 8 bytes per BA and 8 BA per segment */
    501 +
    502 hns_roce_calc_hem_mhop(hr_dev, table, &mhop_obj, &mhop);
    503 /* mtt mhop */
    504 i = mhop.l0_idx;
    505 @@ -756,8 +758,8 @@ void *hns_roce_table_find(struct hns_roce_dev *hr_dev,
    506 hem_idx = i;
    507
    508 hem = table->hem[hem_idx];
    509 - dma_offset = offset = (obj & (table->num_obj - 1)) *
    510 - table->obj_size % mhop.bt_chunk_size;
    511 + dma_offset = offset = (obj & (table->num_obj - 1)) * seg_size %
    512 + mhop.bt_chunk_size;
    513 if (mhop.hop_num == 2)
    514 dma_offset = offset = 0;
    515 }
    516 diff --git a/drivers/infiniband/hw/hns/hns_roce_mr.c b/drivers/infiniband/hw/hns/hns_roce_mr.c
    517 index eb26a5f6fc58..41a538d23b80 100644
    518 --- a/drivers/infiniband/hw/hns/hns_roce_mr.c
    519 +++ b/drivers/infiniband/hw/hns/hns_roce_mr.c
    520 @@ -707,7 +707,6 @@ static int hns_roce_write_mtt_chunk(struct hns_roce_dev *hr_dev,
    521 struct hns_roce_hem_table *table;
    522 dma_addr_t dma_handle;
    523 __le64 *mtts;
    524 - u32 s = start_index * sizeof(u64);
    525 u32 bt_page_size;
    526 u32 i;
    527
    528 @@ -730,7 +729,8 @@ static int hns_roce_write_mtt_chunk(struct hns_roce_dev *hr_dev,
    529 table = &hr_dev->mr_table.mtt_cqe_table;
    530
    531 mtts = hns_roce_table_find(hr_dev, table,
    532 - mtt->first_seg + s / hr_dev->caps.mtt_entry_sz,
    533 + mtt->first_seg +
    534 + start_index / HNS_ROCE_MTT_ENTRY_PER_SEG,
    535 &dma_handle);
    536 if (!mtts)
    537 return -ENOMEM;
    538 diff --git a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
    539 index a5719899f49a..ed99f0a08dc4 100644
    540 --- a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
    541 +++ b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
    542 @@ -1123,6 +1123,8 @@ static void pvrdma_pci_remove(struct pci_dev *pdev)
    543 pvrdma_page_dir_cleanup(dev, &dev->cq_pdir);
    544 pvrdma_page_dir_cleanup(dev, &dev->async_pdir);
    545 pvrdma_free_slots(dev);
    546 + dma_free_coherent(&pdev->dev, sizeof(*dev->dsr), dev->dsr,
    547 + dev->dsrbase);
    548
    549 iounmap(dev->regs);
    550 kfree(dev->sgid_tbl);
    551 diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
    552 index be3801d43d48..3a1d30304f7e 100644
    553 --- a/drivers/iommu/amd_iommu_init.c
    554 +++ b/drivers/iommu/amd_iommu_init.c
    555 @@ -356,7 +356,7 @@ static void iommu_write_l2(struct amd_iommu *iommu, u8 address, u32 val)
    556 static void iommu_set_exclusion_range(struct amd_iommu *iommu)
    557 {
    558 u64 start = iommu->exclusion_start & PAGE_MASK;
    559 - u64 limit = (start + iommu->exclusion_length) & PAGE_MASK;
    560 + u64 limit = (start + iommu->exclusion_length - 1) & PAGE_MASK;
    561 u64 entry;
    562
    563 if (!iommu->exclusion_start)
    564 diff --git a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
    565 index b7dd4e3c760d..6d690678c20e 100644
    566 --- a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
    567 +++ b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
    568 @@ -140,7 +140,7 @@ static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode,
    569 p->des0 |= cpu_to_le32(RDES0_OWN);
    570
    571 bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1);
    572 - p->des1 |= cpu_to_le32(bfsize & RDES1_BUFFER1_SIZE_MASK);
    573 + p->des1 |= cpu_to_le32(bfsize1 & RDES1_BUFFER1_SIZE_MASK);
    574
    575 if (mode == STMMAC_CHAIN_MODE)
    576 ndesc_rx_set_on_chain(p, end);
    577 diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c
    578 index 9375fa705d82..67dec8860bf3 100644
    579 --- a/drivers/nvme/host/fc.c
    580 +++ b/drivers/nvme/host/fc.c
    581 @@ -1844,7 +1844,7 @@ nvme_fc_init_queue(struct nvme_fc_ctrl *ctrl, int idx)
    582 memset(queue, 0, sizeof(*queue));
    583 queue->ctrl = ctrl;
    584 queue->qnum = idx;
    585 - atomic_set(&queue->csn, 1);
    586 + atomic_set(&queue->csn, 0);
    587 queue->dev = ctrl->dev;
    588
    589 if (idx > 0)
    590 @@ -1886,7 +1886,7 @@ nvme_fc_free_queue(struct nvme_fc_queue *queue)
    591 */
    592
    593 queue->connection_id = 0;
    594 - atomic_set(&queue->csn, 1);
    595 + atomic_set(&queue->csn, 0);
    596 }
    597
    598 static void
    599 @@ -2182,7 +2182,6 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,
    600 {
    601 struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;
    602 struct nvme_command *sqe = &cmdiu->sqe;
    603 - u32 csn;
    604 int ret, opstate;
    605
    606 /*
    607 @@ -2197,8 +2196,6 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,
    608
    609 /* format the FC-NVME CMD IU and fcp_req */
    610 cmdiu->connection_id = cpu_to_be64(queue->connection_id);
    611 - csn = atomic_inc_return(&queue->csn);
    612 - cmdiu->csn = cpu_to_be32(csn);
    613 cmdiu->data_len = cpu_to_be32(data_len);
    614 switch (io_dir) {
    615 case NVMEFC_FCP_WRITE:
    616 @@ -2256,11 +2253,24 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,
    617 if (!(op->flags & FCOP_FLAGS_AEN))
    618 blk_mq_start_request(op->rq);
    619
    620 + cmdiu->csn = cpu_to_be32(atomic_inc_return(&queue->csn));
    621 ret = ctrl->lport->ops->fcp_io(&ctrl->lport->localport,
    622 &ctrl->rport->remoteport,
    623 queue->lldd_handle, &op->fcp_req);
    624
    625 if (ret) {
    626 + /*
    627 + * If the lld fails to send the command is there an issue with
    628 + * the csn value? If the command that fails is the Connect,
    629 + * no - as the connection won't be live. If it is a command
    630 + * post-connect, it's possible a gap in csn may be created.
    631 + * Does this matter? As Linux initiators don't send fused
    632 + * commands, no. The gap would exist, but as there's nothing
    633 + * that depends on csn order to be delivered on the target
    634 + * side, it shouldn't hurt. It would be difficult for a
    635 + * target to even detect the csn gap as it has no idea when the
    636 + * cmd with the csn was supposed to arrive.
    637 + */
    638 opstate = atomic_xchg(&op->state, FCPOP_STATE_COMPLETE);
    639 __nvme_fc_fcpop_chk_teardowns(ctrl, op, opstate);
    640
    641 diff --git a/drivers/platform/x86/pmc_atom.c b/drivers/platform/x86/pmc_atom.c
    642 index eaec2d306481..c7039f52ad51 100644
    643 --- a/drivers/platform/x86/pmc_atom.c
    644 +++ b/drivers/platform/x86/pmc_atom.c
    645 @@ -396,7 +396,7 @@ static int pmc_dbgfs_register(struct pmc_dev *pmc)
    646 * Some systems need one or more of their pmc_plt_clks to be
    647 * marked as critical.
    648 */
    649 -static const struct dmi_system_id critclk_systems[] __initconst = {
    650 +static const struct dmi_system_id critclk_systems[] = {
    651 {
    652 .ident = "MPL CEC1x",
    653 .matches = {
    654 diff --git a/drivers/scsi/csiostor/csio_scsi.c b/drivers/scsi/csiostor/csio_scsi.c
    655 index dab0d3f9bee1..e09c7f360dbd 100644
    656 --- a/drivers/scsi/csiostor/csio_scsi.c
    657 +++ b/drivers/scsi/csiostor/csio_scsi.c
    658 @@ -1713,8 +1713,11 @@ csio_scsi_err_handler(struct csio_hw *hw, struct csio_ioreq *req)
    659 }
    660
    661 out:
    662 - if (req->nsge > 0)
    663 + if (req->nsge > 0) {
    664 scsi_dma_unmap(cmnd);
    665 + if (req->dcopy && (host_status == DID_OK))
    666 + host_status = csio_scsi_copy_to_sgl(hw, req);
    667 + }
    668
    669 cmnd->result = (((host_status) << 16) | scsi_status);
    670 cmnd->scsi_done(cmnd);
    671 diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
    672 index a1551ab33616..e9ecc667e3fb 100644
    673 --- a/drivers/scsi/libsas/sas_expander.c
    674 +++ b/drivers/scsi/libsas/sas_expander.c
    675 @@ -48,17 +48,16 @@ static void smp_task_timedout(struct timer_list *t)
    676 unsigned long flags;
    677
    678 spin_lock_irqsave(&task->task_state_lock, flags);
    679 - if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
    680 + if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
    681 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
    682 + complete(&task->slow_task->completion);
    683 + }
    684 spin_unlock_irqrestore(&task->task_state_lock, flags);
    685 -
    686 - complete(&task->slow_task->completion);
    687 }
    688
    689 static void smp_task_done(struct sas_task *task)
    690 {
    691 - if (!del_timer(&task->slow_task->timer))
    692 - return;
    693 + del_timer(&task->slow_task->timer);
    694 complete(&task->slow_task->completion);
    695 }
    696
    697 diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
    698 index 1a6ed9b0a249..cb19b12e7211 100644
    699 --- a/drivers/scsi/lpfc/lpfc_attr.c
    700 +++ b/drivers/scsi/lpfc/lpfc_attr.c
    701 @@ -117,7 +117,7 @@ static ssize_t
    702 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
    703 char *buf)
    704 {
    705 - return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
    706 + return scnprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
    707 }
    708
    709 /**
    710 @@ -137,9 +137,9 @@ lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
    711 struct lpfc_hba *phba = vport->phba;
    712
    713 if (phba->hba_flag & HBA_FIP_SUPPORT)
    714 - return snprintf(buf, PAGE_SIZE, "1\n");
    715 + return scnprintf(buf, PAGE_SIZE, "1\n");
    716 else
    717 - return snprintf(buf, PAGE_SIZE, "0\n");
    718 + return scnprintf(buf, PAGE_SIZE, "0\n");
    719 }
    720
    721 static ssize_t
    722 @@ -517,14 +517,15 @@ lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
    723 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    724 struct lpfc_hba *phba = vport->phba;
    725
    726 - if (phba->cfg_enable_bg)
    727 + if (phba->cfg_enable_bg) {
    728 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
    729 - return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
    730 + return scnprintf(buf, PAGE_SIZE,
    731 + "BlockGuard Enabled\n");
    732 else
    733 - return snprintf(buf, PAGE_SIZE,
    734 + return scnprintf(buf, PAGE_SIZE,
    735 "BlockGuard Not Supported\n");
    736 - else
    737 - return snprintf(buf, PAGE_SIZE,
    738 + } else
    739 + return scnprintf(buf, PAGE_SIZE,
    740 "BlockGuard Disabled\n");
    741 }
    742
    743 @@ -536,7 +537,7 @@ lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
    744 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    745 struct lpfc_hba *phba = vport->phba;
    746
    747 - return snprintf(buf, PAGE_SIZE, "%llu\n",
    748 + return scnprintf(buf, PAGE_SIZE, "%llu\n",
    749 (unsigned long long)phba->bg_guard_err_cnt);
    750 }
    751
    752 @@ -548,7 +549,7 @@ lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
    753 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    754 struct lpfc_hba *phba = vport->phba;
    755
    756 - return snprintf(buf, PAGE_SIZE, "%llu\n",
    757 + return scnprintf(buf, PAGE_SIZE, "%llu\n",
    758 (unsigned long long)phba->bg_apptag_err_cnt);
    759 }
    760
    761 @@ -560,7 +561,7 @@ lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
    762 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    763 struct lpfc_hba *phba = vport->phba;
    764
    765 - return snprintf(buf, PAGE_SIZE, "%llu\n",
    766 + return scnprintf(buf, PAGE_SIZE, "%llu\n",
    767 (unsigned long long)phba->bg_reftag_err_cnt);
    768 }
    769
    770 @@ -578,7 +579,7 @@ lpfc_info_show(struct device *dev, struct device_attribute *attr,
    771 {
    772 struct Scsi_Host *host = class_to_shost(dev);
    773
    774 - return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
    775 + return scnprintf(buf, PAGE_SIZE, "%s\n", lpfc_info(host));
    776 }
    777
    778 /**
    779 @@ -597,7 +598,7 @@ lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
    780 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    781 struct lpfc_hba *phba = vport->phba;
    782
    783 - return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
    784 + return scnprintf(buf, PAGE_SIZE, "%s\n", phba->SerialNumber);
    785 }
    786
    787 /**
    788 @@ -619,7 +620,7 @@ lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
    789 struct Scsi_Host *shost = class_to_shost(dev);
    790 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    791 struct lpfc_hba *phba = vport->phba;
    792 - return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
    793 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->temp_sensor_support);
    794 }
    795
    796 /**
    797 @@ -638,7 +639,7 @@ lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
    798 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    799 struct lpfc_hba *phba = vport->phba;
    800
    801 - return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
    802 + return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelDesc);
    803 }
    804
    805 /**
    806 @@ -657,7 +658,7 @@ lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
    807 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    808 struct lpfc_hba *phba = vport->phba;
    809
    810 - return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
    811 + return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelName);
    812 }
    813
    814 /**
    815 @@ -676,7 +677,7 @@ lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
    816 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    817 struct lpfc_hba *phba = vport->phba;
    818
    819 - return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
    820 + return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ProgramType);
    821 }
    822
    823 /**
    824 @@ -694,7 +695,7 @@ lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
    825 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
    826 struct lpfc_hba *phba = vport->phba;
    827
    828 - return snprintf(buf, PAGE_SIZE, "%d\n",
    829 + return scnprintf(buf, PAGE_SIZE, "%d\n",
    830 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
    831 }
    832
    833 @@ -714,7 +715,7 @@ lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
    834 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    835 struct lpfc_hba *phba = vport->phba;
    836
    837 - return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
    838 + return scnprintf(buf, PAGE_SIZE, "%s\n", phba->Port);
    839 }
    840
    841 /**
    842 @@ -742,10 +743,10 @@ lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
    843 sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
    844
    845 if (phba->sli_rev < LPFC_SLI_REV4)
    846 - len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
    847 + len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
    848 fwrev, phba->sli_rev);
    849 else
    850 - len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
    851 + len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
    852 fwrev, phba->sli_rev, if_type, sli_family);
    853
    854 return len;
    855 @@ -769,7 +770,7 @@ lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
    856 lpfc_vpd_t *vp = &phba->vpd;
    857
    858 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
    859 - return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
    860 + return scnprintf(buf, PAGE_SIZE, "%s\n", hdw);
    861 }
    862
    863 /**
    864 @@ -790,10 +791,11 @@ lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
    865 char fwrev[FW_REV_STR_SIZE];
    866
    867 if (phba->sli_rev < LPFC_SLI_REV4)
    868 - return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
    869 + return scnprintf(buf, PAGE_SIZE, "%s\n",
    870 + phba->OptionROMVersion);
    871
    872 lpfc_decode_firmware_rev(phba, fwrev, 1);
    873 - return snprintf(buf, PAGE_SIZE, "%s\n", fwrev);
    874 + return scnprintf(buf, PAGE_SIZE, "%s\n", fwrev);
    875 }
    876
    877 /**
    878 @@ -824,20 +826,20 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
    879 case LPFC_LINK_DOWN:
    880 case LPFC_HBA_ERROR:
    881 if (phba->hba_flag & LINK_DISABLED)
    882 - len += snprintf(buf + len, PAGE_SIZE-len,
    883 + len += scnprintf(buf + len, PAGE_SIZE-len,
    884 "Link Down - User disabled\n");
    885 else
    886 - len += snprintf(buf + len, PAGE_SIZE-len,
    887 + len += scnprintf(buf + len, PAGE_SIZE-len,
    888 "Link Down\n");
    889 break;
    890 case LPFC_LINK_UP:
    891 case LPFC_CLEAR_LA:
    892 case LPFC_HBA_READY:
    893 - len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
    894 + len += scnprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
    895
    896 switch (vport->port_state) {
    897 case LPFC_LOCAL_CFG_LINK:
    898 - len += snprintf(buf + len, PAGE_SIZE-len,
    899 + len += scnprintf(buf + len, PAGE_SIZE-len,
    900 "Configuring Link\n");
    901 break;
    902 case LPFC_FDISC:
    903 @@ -847,38 +849,40 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
    904 case LPFC_NS_QRY:
    905 case LPFC_BUILD_DISC_LIST:
    906 case LPFC_DISC_AUTH:
    907 - len += snprintf(buf + len, PAGE_SIZE - len,
    908 + len += scnprintf(buf + len, PAGE_SIZE - len,
    909 "Discovery\n");
    910 break;
    911 case LPFC_VPORT_READY:
    912 - len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
    913 + len += scnprintf(buf + len, PAGE_SIZE - len,
    914 + "Ready\n");
    915 break;
    916
    917 case LPFC_VPORT_FAILED:
    918 - len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
    919 + len += scnprintf(buf + len, PAGE_SIZE - len,
    920 + "Failed\n");
    921 break;
    922
    923 case LPFC_VPORT_UNKNOWN:
    924 - len += snprintf(buf + len, PAGE_SIZE - len,
    925 + len += scnprintf(buf + len, PAGE_SIZE - len,
    926 "Unknown\n");
    927 break;
    928 }
    929 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
    930 - len += snprintf(buf + len, PAGE_SIZE-len,
    931 + len += scnprintf(buf + len, PAGE_SIZE-len,
    932 " Menlo Maint Mode\n");
    933 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
    934 if (vport->fc_flag & FC_PUBLIC_LOOP)
    935 - len += snprintf(buf + len, PAGE_SIZE-len,
    936 + len += scnprintf(buf + len, PAGE_SIZE-len,
    937 " Public Loop\n");
    938 else
    939 - len += snprintf(buf + len, PAGE_SIZE-len,
    940 + len += scnprintf(buf + len, PAGE_SIZE-len,
    941 " Private Loop\n");
    942 } else {
    943 if (vport->fc_flag & FC_FABRIC)
    944 - len += snprintf(buf + len, PAGE_SIZE-len,
    945 + len += scnprintf(buf + len, PAGE_SIZE-len,
    946 " Fabric\n");
    947 else
    948 - len += snprintf(buf + len, PAGE_SIZE-len,
    949 + len += scnprintf(buf + len, PAGE_SIZE-len,
    950 " Point-2-Point\n");
    951 }
    952 }
    953 @@ -903,15 +907,15 @@ lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
    954 struct lpfc_hba *phba = vport->phba;
    955
    956 if (phba->sli_rev < LPFC_SLI_REV4)
    957 - return snprintf(buf, PAGE_SIZE, "fc\n");
    958 + return scnprintf(buf, PAGE_SIZE, "fc\n");
    959
    960 if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
    961 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
    962 - return snprintf(buf, PAGE_SIZE, "fcoe\n");
    963 + return scnprintf(buf, PAGE_SIZE, "fcoe\n");
    964 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
    965 - return snprintf(buf, PAGE_SIZE, "fc\n");
    966 + return scnprintf(buf, PAGE_SIZE, "fc\n");
    967 }
    968 - return snprintf(buf, PAGE_SIZE, "unknown\n");
    969 + return scnprintf(buf, PAGE_SIZE, "unknown\n");
    970 }
    971
    972 /**
    973 @@ -931,7 +935,7 @@ lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
    974 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
    975 struct lpfc_hba *phba = vport->phba;
    976
    977 - return snprintf(buf, PAGE_SIZE, "%d\n",
    978 + return scnprintf(buf, PAGE_SIZE, "%d\n",
    979 phba->sli4_hba.pc_sli4_params.oas_supported);
    980 }
    981
    982 @@ -989,7 +993,7 @@ lpfc_num_discovered_ports_show(struct device *dev,
    983 struct Scsi_Host *shost = class_to_shost(dev);
    984 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    985
    986 - return snprintf(buf, PAGE_SIZE, "%d\n",
    987 + return scnprintf(buf, PAGE_SIZE, "%d\n",
    988 vport->fc_map_cnt + vport->fc_unmap_cnt);
    989 }
    990
    991 @@ -1427,7 +1431,7 @@ lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
    992 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    993 struct lpfc_hba *phba = vport->phba;
    994
    995 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
    996 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
    997 }
    998
    999 /**
    1000 @@ -1456,7 +1460,7 @@ lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
    1001 else
    1002 state = "online";
    1003
    1004 - return snprintf(buf, PAGE_SIZE, "%s\n", state);
    1005 + return scnprintf(buf, PAGE_SIZE, "%s\n", state);
    1006 }
    1007
    1008 /**
    1009 @@ -1669,8 +1673,8 @@ lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
    1010 uint32_t cnt;
    1011
    1012 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
    1013 - return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1014 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1015 + return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1016 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1017 }
    1018
    1019 /**
    1020 @@ -1697,8 +1701,8 @@ lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
    1021 uint32_t cnt, acnt;
    1022
    1023 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
    1024 - return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1025 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1026 + return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1027 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1028 }
    1029
    1030 /**
    1031 @@ -1725,8 +1729,8 @@ lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
    1032 uint32_t cnt;
    1033
    1034 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
    1035 - return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1036 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1037 + return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1038 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1039 }
    1040
    1041 /**
    1042 @@ -1753,8 +1757,8 @@ lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
    1043 uint32_t cnt, acnt;
    1044
    1045 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
    1046 - return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1047 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1048 + return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1049 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1050 }
    1051
    1052 /**
    1053 @@ -1781,8 +1785,8 @@ lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
    1054 uint32_t cnt;
    1055
    1056 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
    1057 - return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1058 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1059 + return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
    1060 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1061 }
    1062
    1063 /**
    1064 @@ -1809,8 +1813,8 @@ lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
    1065 uint32_t cnt, acnt;
    1066
    1067 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
    1068 - return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1069 - return snprintf(buf, PAGE_SIZE, "Unknown\n");
    1070 + return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
    1071 + return scnprintf(buf, PAGE_SIZE, "Unknown\n");
    1072 }
    1073
    1074 /**
    1075 @@ -1835,10 +1839,10 @@ lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
    1076 struct lpfc_hba *phba = vport->phba;
    1077
    1078 if (!(phba->max_vpi))
    1079 - return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
    1080 + return scnprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
    1081 if (vport->port_type == LPFC_PHYSICAL_PORT)
    1082 - return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
    1083 - return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
    1084 + return scnprintf(buf, PAGE_SIZE, "NPIV Physical\n");
    1085 + return scnprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
    1086 }
    1087
    1088 /**
    1089 @@ -1860,7 +1864,7 @@ lpfc_poll_show(struct device *dev, struct device_attribute *attr,
    1090 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1091 struct lpfc_hba *phba = vport->phba;
    1092
    1093 - return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
    1094 + return scnprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
    1095 }
    1096
    1097 /**
    1098 @@ -1964,7 +1968,7 @@ lpfc_fips_level_show(struct device *dev, struct device_attribute *attr,
    1099 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1100 struct lpfc_hba *phba = vport->phba;
    1101
    1102 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
    1103 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
    1104 }
    1105
    1106 /**
    1107 @@ -1983,7 +1987,7 @@ lpfc_fips_rev_show(struct device *dev, struct device_attribute *attr,
    1108 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1109 struct lpfc_hba *phba = vport->phba;
    1110
    1111 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
    1112 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
    1113 }
    1114
    1115 /**
    1116 @@ -2002,7 +2006,7 @@ lpfc_dss_show(struct device *dev, struct device_attribute *attr,
    1117 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1118 struct lpfc_hba *phba = vport->phba;
    1119
    1120 - return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
    1121 + return scnprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
    1122 (phba->cfg_enable_dss) ? "Enabled" : "Disabled",
    1123 (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
    1124 "" : "Not ");
    1125 @@ -2031,7 +2035,7 @@ lpfc_sriov_hw_max_virtfn_show(struct device *dev,
    1126 uint16_t max_nr_virtfn;
    1127
    1128 max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
    1129 - return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
    1130 + return scnprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
    1131 }
    1132
    1133 static inline bool lpfc_rangecheck(uint val, uint min, uint max)
    1134 @@ -2091,7 +2095,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
    1135 struct Scsi_Host *shost = class_to_shost(dev);\
    1136 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
    1137 struct lpfc_hba *phba = vport->phba;\
    1138 - return snprintf(buf, PAGE_SIZE, "%d\n",\
    1139 + return scnprintf(buf, PAGE_SIZE, "%d\n",\
    1140 phba->cfg_##attr);\
    1141 }
    1142
    1143 @@ -2119,7 +2123,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
    1144 struct lpfc_hba *phba = vport->phba;\
    1145 uint val = 0;\
    1146 val = phba->cfg_##attr;\
    1147 - return snprintf(buf, PAGE_SIZE, "%#x\n",\
    1148 + return scnprintf(buf, PAGE_SIZE, "%#x\n",\
    1149 phba->cfg_##attr);\
    1150 }
    1151
    1152 @@ -2255,7 +2259,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
    1153 { \
    1154 struct Scsi_Host *shost = class_to_shost(dev);\
    1155 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
    1156 - return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
    1157 + return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
    1158 }
    1159
    1160 /**
    1161 @@ -2280,7 +2284,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
    1162 { \
    1163 struct Scsi_Host *shost = class_to_shost(dev);\
    1164 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
    1165 - return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
    1166 + return scnprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
    1167 }
    1168
    1169 /**
    1170 @@ -2551,7 +2555,7 @@ lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
    1171 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1172 struct lpfc_hba *phba = vport->phba;
    1173
    1174 - return snprintf(buf, PAGE_SIZE, "0x%llx\n",
    1175 + return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
    1176 (unsigned long long)phba->cfg_soft_wwpn);
    1177 }
    1178
    1179 @@ -2648,7 +2652,7 @@ lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
    1180 {
    1181 struct Scsi_Host *shost = class_to_shost(dev);
    1182 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
    1183 - return snprintf(buf, PAGE_SIZE, "0x%llx\n",
    1184 + return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
    1185 (unsigned long long)phba->cfg_soft_wwnn);
    1186 }
    1187
    1188 @@ -2714,7 +2718,7 @@ lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
    1189 struct Scsi_Host *shost = class_to_shost(dev);
    1190 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
    1191
    1192 - return snprintf(buf, PAGE_SIZE, "0x%llx\n",
    1193 + return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
    1194 wwn_to_u64(phba->cfg_oas_tgt_wwpn));
    1195 }
    1196
    1197 @@ -2782,7 +2786,7 @@ lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
    1198 struct Scsi_Host *shost = class_to_shost(dev);
    1199 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
    1200
    1201 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
    1202 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
    1203 }
    1204
    1205 /**
    1206 @@ -2845,7 +2849,7 @@ lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
    1207 struct Scsi_Host *shost = class_to_shost(dev);
    1208 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
    1209
    1210 - return snprintf(buf, PAGE_SIZE, "0x%llx\n",
    1211 + return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
    1212 wwn_to_u64(phba->cfg_oas_vpt_wwpn));
    1213 }
    1214
    1215 @@ -2916,7 +2920,7 @@ lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
    1216 struct Scsi_Host *shost = class_to_shost(dev);
    1217 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
    1218
    1219 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
    1220 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
    1221 }
    1222
    1223 /**
    1224 @@ -2980,7 +2984,7 @@ lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
    1225 if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
    1226 return -EFAULT;
    1227
    1228 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
    1229 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
    1230 }
    1231 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
    1232 lpfc_oas_lun_status_show, NULL);
    1233 @@ -3132,7 +3136,7 @@ lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
    1234 if (oas_lun != NOT_OAS_ENABLED_LUN)
    1235 phba->cfg_oas_flags |= OAS_LUN_VALID;
    1236
    1237 - len += snprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
    1238 + len += scnprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
    1239
    1240 return len;
    1241 }
    1242 @@ -3266,7 +3270,7 @@ lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
    1243 struct Scsi_Host *shost = class_to_shost(dev);
    1244 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
    1245
    1246 - return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
    1247 + return scnprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
    1248 }
    1249
    1250 static DEVICE_ATTR(iocb_hw, S_IRUGO,
    1251 @@ -3278,7 +3282,7 @@ lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
    1252 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
    1253 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
    1254
    1255 - return snprintf(buf, PAGE_SIZE, "%d\n",
    1256 + return scnprintf(buf, PAGE_SIZE, "%d\n",
    1257 pring ? pring->txq_max : 0);
    1258 }
    1259
    1260 @@ -3292,7 +3296,7 @@ lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
    1261 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
    1262 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
    1263
    1264 - return snprintf(buf, PAGE_SIZE, "%d\n",
    1265 + return scnprintf(buf, PAGE_SIZE, "%d\n",
    1266 pring ? pring->txcmplq_max : 0);
    1267 }
    1268
    1269 @@ -3328,7 +3332,7 @@ lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
    1270 struct Scsi_Host *shost = class_to_shost(dev);
    1271 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
    1272
    1273 - return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
    1274 + return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
    1275 }
    1276
    1277 /**
    1278 @@ -4830,19 +4834,19 @@ lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
    1279
    1280 switch (phba->cfg_fcp_cpu_map) {
    1281 case 0:
    1282 - len += snprintf(buf + len, PAGE_SIZE-len,
    1283 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1284 "fcp_cpu_map: No mapping (%d)\n",
    1285 phba->cfg_fcp_cpu_map);
    1286 return len;
    1287 case 1:
    1288 - len += snprintf(buf + len, PAGE_SIZE-len,
    1289 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1290 "fcp_cpu_map: HBA centric mapping (%d): "
    1291 "%d online CPUs\n",
    1292 phba->cfg_fcp_cpu_map,
    1293 phba->sli4_hba.num_online_cpu);
    1294 break;
    1295 case 2:
    1296 - len += snprintf(buf + len, PAGE_SIZE-len,
    1297 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1298 "fcp_cpu_map: Driver centric mapping (%d): "
    1299 "%d online CPUs\n",
    1300 phba->cfg_fcp_cpu_map,
    1301 @@ -4855,14 +4859,14 @@ lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
    1302
    1303 /* margin should fit in this and the truncated message */
    1304 if (cpup->irq == LPFC_VECTOR_MAP_EMPTY)
    1305 - len += snprintf(buf + len, PAGE_SIZE-len,
    1306 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1307 "CPU %02d io_chan %02d "
    1308 "physid %d coreid %d\n",
    1309 phba->sli4_hba.curr_disp_cpu,
    1310 cpup->channel_id, cpup->phys_id,
    1311 cpup->core_id);
    1312 else
    1313 - len += snprintf(buf + len, PAGE_SIZE-len,
    1314 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1315 "CPU %02d io_chan %02d "
    1316 "physid %d coreid %d IRQ %d\n",
    1317 phba->sli4_hba.curr_disp_cpu,
    1318 @@ -4875,7 +4879,7 @@ lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
    1319 if (phba->sli4_hba.curr_disp_cpu <
    1320 phba->sli4_hba.num_present_cpu &&
    1321 (len >= (PAGE_SIZE - 64))) {
    1322 - len += snprintf(buf + len, PAGE_SIZE-len, "more...\n");
    1323 + len += scnprintf(buf + len, PAGE_SIZE-len, "more...\n");
    1324 break;
    1325 }
    1326 }
    1327 @@ -6296,7 +6300,7 @@ lpfc_show_rport_##field (struct device *dev, \
    1328 { \
    1329 struct fc_rport *rport = transport_class_to_rport(dev); \
    1330 struct lpfc_rport_data *rdata = rport->hostdata; \
    1331 - return snprintf(buf, sz, format_string, \
    1332 + return scnprintf(buf, sz, format_string, \
    1333 (rdata->target) ? cast rdata->target->field : 0); \
    1334 }
    1335
    1336 diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
    1337 index 1cbdc892ff95..1a964e71582f 100644
    1338 --- a/drivers/scsi/lpfc/lpfc_ct.c
    1339 +++ b/drivers/scsi/lpfc/lpfc_ct.c
    1340 @@ -1220,7 +1220,7 @@ lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
    1341 * Name object. NPIV is not in play so this integer
    1342 * value is sufficient and unique per FC-ID.
    1343 */
    1344 - n = snprintf(symbol, size, "%d", vport->phba->brd_no);
    1345 + n = scnprintf(symbol, size, "%d", vport->phba->brd_no);
    1346 return n;
    1347 }
    1348
    1349 @@ -1234,26 +1234,26 @@ lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
    1350
    1351 lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
    1352
    1353 - n = snprintf(symbol, size, "Emulex %s", vport->phba->ModelName);
    1354 + n = scnprintf(symbol, size, "Emulex %s", vport->phba->ModelName);
    1355 if (size < n)
    1356 return n;
    1357
    1358 - n += snprintf(symbol + n, size - n, " FV%s", fwrev);
    1359 + n += scnprintf(symbol + n, size - n, " FV%s", fwrev);
    1360 if (size < n)
    1361 return n;
    1362
    1363 - n += snprintf(symbol + n, size - n, " DV%s.",
    1364 + n += scnprintf(symbol + n, size - n, " DV%s.",
    1365 lpfc_release_version);
    1366 if (size < n)
    1367 return n;
    1368
    1369 - n += snprintf(symbol + n, size - n, " HN:%s.",
    1370 + n += scnprintf(symbol + n, size - n, " HN:%s.",
    1371 init_utsname()->nodename);
    1372 if (size < n)
    1373 return n;
    1374
    1375 /* Note :- OS name is "Linux" */
    1376 - n += snprintf(symbol + n, size - n, " OS:%s\n",
    1377 + n += scnprintf(symbol + n, size - n, " OS:%s\n",
    1378 init_utsname()->sysname);
    1379 return n;
    1380 }
    1381 diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
    1382 index ca6c3982548d..f1951c432766 100644
    1383 --- a/drivers/scsi/lpfc/lpfc_debugfs.c
    1384 +++ b/drivers/scsi/lpfc/lpfc_debugfs.c
    1385 @@ -170,7 +170,7 @@ lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
    1386 snprintf(buffer,
    1387 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    1388 dtp->seq_cnt, ms, dtp->fmt);
    1389 - len += snprintf(buf+len, size-len, buffer,
    1390 + len += scnprintf(buf+len, size-len, buffer,
    1391 dtp->data1, dtp->data2, dtp->data3);
    1392 }
    1393 for (i = 0; i < index; i++) {
    1394 @@ -181,7 +181,7 @@ lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
    1395 snprintf(buffer,
    1396 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    1397 dtp->seq_cnt, ms, dtp->fmt);
    1398 - len += snprintf(buf+len, size-len, buffer,
    1399 + len += scnprintf(buf+len, size-len, buffer,
    1400 dtp->data1, dtp->data2, dtp->data3);
    1401 }
    1402
    1403 @@ -236,7 +236,7 @@ lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
    1404 snprintf(buffer,
    1405 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    1406 dtp->seq_cnt, ms, dtp->fmt);
    1407 - len += snprintf(buf+len, size-len, buffer,
    1408 + len += scnprintf(buf+len, size-len, buffer,
    1409 dtp->data1, dtp->data2, dtp->data3);
    1410 }
    1411 for (i = 0; i < index; i++) {
    1412 @@ -247,7 +247,7 @@ lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
    1413 snprintf(buffer,
    1414 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
    1415 dtp->seq_cnt, ms, dtp->fmt);
    1416 - len += snprintf(buf+len, size-len, buffer,
    1417 + len += scnprintf(buf+len, size-len, buffer,
    1418 dtp->data1, dtp->data2, dtp->data3);
    1419 }
    1420
    1421 @@ -307,7 +307,7 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    1422
    1423 i = lpfc_debugfs_last_hbq;
    1424
    1425 - len += snprintf(buf+len, size-len, "HBQ %d Info\n", i);
    1426 + len += scnprintf(buf+len, size-len, "HBQ %d Info\n", i);
    1427
    1428 hbqs = &phba->hbqs[i];
    1429 posted = 0;
    1430 @@ -315,21 +315,21 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    1431 posted++;
    1432
    1433 hip = lpfc_hbq_defs[i];
    1434 - len += snprintf(buf+len, size-len,
    1435 + len += scnprintf(buf+len, size-len,
    1436 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
    1437 hip->hbq_index, hip->profile, hip->rn,
    1438 hip->buffer_count, hip->init_count, hip->add_count, posted);
    1439
    1440 raw_index = phba->hbq_get[i];
    1441 getidx = le32_to_cpu(raw_index);
    1442 - len += snprintf(buf+len, size-len,
    1443 + len += scnprintf(buf+len, size-len,
    1444 "entries:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
    1445 hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx,
    1446 hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx);
    1447
    1448 hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
    1449 for (j=0; j<hbqs->entry_count; j++) {
    1450 - len += snprintf(buf+len, size-len,
    1451 + len += scnprintf(buf+len, size-len,
    1452 "%03d: %08x %04x %05x ", j,
    1453 le32_to_cpu(hbqe->bde.addrLow),
    1454 le32_to_cpu(hbqe->bde.tus.w),
    1455 @@ -341,14 +341,16 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    1456 low = hbqs->hbqPutIdx - posted;
    1457 if (low >= 0) {
    1458 if ((j >= hbqs->hbqPutIdx) || (j < low)) {
    1459 - len += snprintf(buf+len, size-len, "Unused\n");
    1460 + len += scnprintf(buf + len, size - len,
    1461 + "Unused\n");
    1462 goto skipit;
    1463 }
    1464 }
    1465 else {
    1466 if ((j >= hbqs->hbqPutIdx) &&
    1467 (j < (hbqs->entry_count+low))) {
    1468 - len += snprintf(buf+len, size-len, "Unused\n");
    1469 + len += scnprintf(buf + len, size - len,
    1470 + "Unused\n");
    1471 goto skipit;
    1472 }
    1473 }
    1474 @@ -358,7 +360,7 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    1475 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
    1476 phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
    1477 if (phys == le32_to_cpu(hbqe->bde.addrLow)) {
    1478 - len += snprintf(buf+len, size-len,
    1479 + len += scnprintf(buf+len, size-len,
    1480 "Buf%d: %p %06x\n", i,
    1481 hbq_buf->dbuf.virt, hbq_buf->tag);
    1482 found = 1;
    1483 @@ -367,7 +369,7 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
    1484 i++;
    1485 }
    1486 if (!found) {
    1487 - len += snprintf(buf+len, size-len, "No DMAinfo?\n");
    1488 + len += scnprintf(buf+len, size-len, "No DMAinfo?\n");
    1489 }
    1490 skipit:
    1491 hbqe++;
    1492 @@ -413,7 +415,7 @@ lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
    1493 off = 0;
    1494 spin_lock_irq(&phba->hbalock);
    1495
    1496 - len += snprintf(buf+len, size-len, "HBA SLIM\n");
    1497 + len += scnprintf(buf+len, size-len, "HBA SLIM\n");
    1498 lpfc_memcpy_from_slim(buffer,
    1499 phba->MBslimaddr + lpfc_debugfs_last_hba_slim_off, 1024);
    1500
    1501 @@ -427,7 +429,7 @@ lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
    1502
    1503 i = 1024;
    1504 while (i > 0) {
    1505 - len += snprintf(buf+len, size-len,
    1506 + len += scnprintf(buf+len, size-len,
    1507 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    1508 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    1509 *(ptr+5), *(ptr+6), *(ptr+7));
    1510 @@ -471,11 +473,11 @@ lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
    1511 off = 0;
    1512 spin_lock_irq(&phba->hbalock);
    1513
    1514 - len += snprintf(buf+len, size-len, "SLIM Mailbox\n");
    1515 + len += scnprintf(buf+len, size-len, "SLIM Mailbox\n");
    1516 ptr = (uint32_t *)phba->slim2p.virt;
    1517 i = sizeof(MAILBOX_t);
    1518 while (i > 0) {
    1519 - len += snprintf(buf+len, size-len,
    1520 + len += scnprintf(buf+len, size-len,
    1521 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    1522 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    1523 *(ptr+5), *(ptr+6), *(ptr+7));
    1524 @@ -484,11 +486,11 @@ lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
    1525 off += (8 * sizeof(uint32_t));
    1526 }
    1527
    1528 - len += snprintf(buf+len, size-len, "SLIM PCB\n");
    1529 + len += scnprintf(buf+len, size-len, "SLIM PCB\n");
    1530 ptr = (uint32_t *)phba->pcb;
    1531 i = sizeof(PCB_t);
    1532 while (i > 0) {
    1533 - len += snprintf(buf+len, size-len,
    1534 + len += scnprintf(buf+len, size-len,
    1535 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
    1536 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
    1537 *(ptr+5), *(ptr+6), *(ptr+7));
    1538 @@ -501,7 +503,7 @@ lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
    1539 for (i = 0; i < 4; i++) {
    1540 pgpp = &phba->port_gp[i];
    1541 pring = &psli->sli3_ring[i];
    1542 - len += snprintf(buf+len, size-len,
    1543 + len += scnprintf(buf+len, size-len,
    1544 "Ring %d: CMD GetInx:%d "
    1545 "(Max:%d Next:%d "
    1546 "Local:%d flg:x%x) "
    1547 @@ -518,7 +520,7 @@ lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
    1548 word1 = readl(phba->CAregaddr);
    1549 word2 = readl(phba->HSregaddr);
    1550 word3 = readl(phba->HCregaddr);
    1551 - len += snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
    1552 + len += scnprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
    1553 "HC:%08x\n", word0, word1, word2, word3);
    1554 }
    1555 spin_unlock_irq(&phba->hbalock);
    1556 @@ -557,12 +559,12 @@ lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    1557 cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
    1558 outio = 0;
    1559
    1560 - len += snprintf(buf+len, size-len, "\nFCP Nodelist Entries ...\n");
    1561 + len += scnprintf(buf+len, size-len, "\nFCP Nodelist Entries ...\n");
    1562 spin_lock_irq(shost->host_lock);
    1563 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
    1564 iocnt = 0;
    1565 if (!cnt) {
    1566 - len += snprintf(buf+len, size-len,
    1567 + len += scnprintf(buf+len, size-len,
    1568 "Missing Nodelist Entries\n");
    1569 break;
    1570 }
    1571 @@ -600,62 +602,62 @@ lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    1572 default:
    1573 statep = "UNKNOWN";
    1574 }
    1575 - len += snprintf(buf+len, size-len, "%s DID:x%06x ",
    1576 + len += scnprintf(buf+len, size-len, "%s DID:x%06x ",
    1577 statep, ndlp->nlp_DID);
    1578 - len += snprintf(buf+len, size-len,
    1579 + len += scnprintf(buf+len, size-len,
    1580 "WWPN x%llx ",
    1581 wwn_to_u64(ndlp->nlp_portname.u.wwn));
    1582 - len += snprintf(buf+len, size-len,
    1583 + len += scnprintf(buf+len, size-len,
    1584 "WWNN x%llx ",
    1585 wwn_to_u64(ndlp->nlp_nodename.u.wwn));
    1586 if (ndlp->nlp_flag & NLP_RPI_REGISTERED)
    1587 - len += snprintf(buf+len, size-len, "RPI:%03d ",
    1588 + len += scnprintf(buf+len, size-len, "RPI:%03d ",
    1589 ndlp->nlp_rpi);
    1590 else
    1591 - len += snprintf(buf+len, size-len, "RPI:none ");
    1592 - len += snprintf(buf+len, size-len, "flag:x%08x ",
    1593 + len += scnprintf(buf+len, size-len, "RPI:none ");
    1594 + len += scnprintf(buf+len, size-len, "flag:x%08x ",
    1595 ndlp->nlp_flag);
    1596 if (!ndlp->nlp_type)
    1597 - len += snprintf(buf+len, size-len, "UNKNOWN_TYPE ");
    1598 + len += scnprintf(buf+len, size-len, "UNKNOWN_TYPE ");
    1599 if (ndlp->nlp_type & NLP_FC_NODE)
    1600 - len += snprintf(buf+len, size-len, "FC_NODE ");
    1601 + len += scnprintf(buf+len, size-len, "FC_NODE ");
    1602 if (ndlp->nlp_type & NLP_FABRIC) {
    1603 - len += snprintf(buf+len, size-len, "FABRIC ");
    1604 + len += scnprintf(buf+len, size-len, "FABRIC ");
    1605 iocnt = 0;
    1606 }
    1607 if (ndlp->nlp_type & NLP_FCP_TARGET)
    1608 - len += snprintf(buf+len, size-len, "FCP_TGT sid:%d ",
    1609 + len += scnprintf(buf+len, size-len, "FCP_TGT sid:%d ",
    1610 ndlp->nlp_sid);
    1611 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
    1612 - len += snprintf(buf+len, size-len, "FCP_INITIATOR ");
    1613 + len += scnprintf(buf+len, size-len, "FCP_INITIATOR ");
    1614 if (ndlp->nlp_type & NLP_NVME_TARGET)
    1615 - len += snprintf(buf + len,
    1616 + len += scnprintf(buf + len,
    1617 size - len, "NVME_TGT sid:%d ",
    1618 NLP_NO_SID);
    1619 if (ndlp->nlp_type & NLP_NVME_INITIATOR)
    1620 - len += snprintf(buf + len,
    1621 + len += scnprintf(buf + len,
    1622 size - len, "NVME_INITIATOR ");
    1623 - len += snprintf(buf+len, size-len, "usgmap:%x ",
    1624 + len += scnprintf(buf+len, size-len, "usgmap:%x ",
    1625 ndlp->nlp_usg_map);
    1626 - len += snprintf(buf+len, size-len, "refcnt:%x",
    1627 + len += scnprintf(buf+len, size-len, "refcnt:%x",
    1628 kref_read(&ndlp->kref));
    1629 if (iocnt) {
    1630 i = atomic_read(&ndlp->cmd_pending);
    1631 - len += snprintf(buf + len, size - len,
    1632 + len += scnprintf(buf + len, size - len,
    1633 " OutIO:x%x Qdepth x%x",
    1634 i, ndlp->cmd_qdepth);
    1635 outio += i;
    1636 }
    1637 - len += snprintf(buf+len, size-len, "\n");
    1638 + len += scnprintf(buf+len, size-len, "\n");
    1639 }
    1640 spin_unlock_irq(shost->host_lock);
    1641
    1642 - len += snprintf(buf + len, size - len,
    1643 + len += scnprintf(buf + len, size - len,
    1644 "\nOutstanding IO x%x\n", outio);
    1645
    1646 if (phba->nvmet_support && phba->targetport && (vport == phba->pport)) {
    1647 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
    1648 - len += snprintf(buf + len, size - len,
    1649 + len += scnprintf(buf + len, size - len,
    1650 "\nNVME Targetport Entry ...\n");
    1651
    1652 /* Port state is only one of two values for now. */
    1653 @@ -663,18 +665,18 @@ lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    1654 statep = "REGISTERED";
    1655 else
    1656 statep = "INIT";
    1657 - len += snprintf(buf + len, size - len,
    1658 + len += scnprintf(buf + len, size - len,
    1659 "TGT WWNN x%llx WWPN x%llx State %s\n",
    1660 wwn_to_u64(vport->fc_nodename.u.wwn),
    1661 wwn_to_u64(vport->fc_portname.u.wwn),
    1662 statep);
    1663 - len += snprintf(buf + len, size - len,
    1664 + len += scnprintf(buf + len, size - len,
    1665 " Targetport DID x%06x\n",
    1666 phba->targetport->port_id);
    1667 goto out_exit;
    1668 }
    1669
    1670 - len += snprintf(buf + len, size - len,
    1671 + len += scnprintf(buf + len, size - len,
    1672 "\nNVME Lport/Rport Entries ...\n");
    1673
    1674 localport = vport->localport;
    1675 @@ -689,11 +691,11 @@ lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    1676 else
    1677 statep = "UNKNOWN ";
    1678
    1679 - len += snprintf(buf + len, size - len,
    1680 + len += scnprintf(buf + len, size - len,
    1681 "Lport DID x%06x PortState %s\n",
    1682 localport->port_id, statep);
    1683
    1684 - len += snprintf(buf + len, size - len, "\tRport List:\n");
    1685 + len += scnprintf(buf + len, size - len, "\tRport List:\n");
    1686 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
    1687 /* local short-hand pointer. */
    1688 spin_lock(&phba->hbalock);
    1689 @@ -720,32 +722,32 @@ lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
    1690 }
    1691
    1692 /* Tab in to show lport ownership. */
    1693 - len += snprintf(buf + len, size - len,
    1694 + len += scnprintf(buf + len, size - len,
    1695 "\t%s Port ID:x%06x ",
    1696 statep, nrport->port_id);
    1697 - len += snprintf(buf + len, size - len, "WWPN x%llx ",
    1698 + len += scnprintf(buf + len, size - len, "WWPN x%llx ",
    1699 nrport->port_name);
    1700 - len += snprintf(buf + len, size - len, "WWNN x%llx ",
    1701 + len += scnprintf(buf + len, size - len, "WWNN x%llx ",
    1702 nrport->node_name);
    1703
    1704 /* An NVME rport can have multiple roles. */
    1705 if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR)
    1706 - len += snprintf(buf + len, size - len,
    1707 + len += scnprintf(buf + len, size - len,
    1708 "INITIATOR ");
    1709 if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET)
    1710 - len += snprintf(buf + len, size - len,
    1711 + len += scnprintf(buf + len, size - len,
    1712 "TARGET ");
    1713 if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY)
    1714 - len += snprintf(buf + len, size - len,
    1715 + len += scnprintf(buf + len, size - len,
    1716 "DISCSRVC ");
    1717 if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
    1718 FC_PORT_ROLE_NVME_TARGET |
    1719 FC_PORT_ROLE_NVME_DISCOVERY))
    1720 - len += snprintf(buf + len, size - len,
    1721 + len += scnprintf(buf + len, size - len,
    1722 "UNKNOWN ROLE x%x",
    1723 nrport->port_role);
    1724 /* Terminate the string. */
    1725 - len += snprintf(buf + len, size - len, "\n");
    1726 + len += scnprintf(buf + len, size - len, "\n");
    1727 }
    1728
    1729 spin_unlock_irq(shost->host_lock);
    1730 @@ -784,35 +786,35 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1731 if (!phba->targetport)
    1732 return len;
    1733 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
    1734 - len += snprintf(buf + len, size - len,
    1735 + len += scnprintf(buf + len, size - len,
    1736 "\nNVME Targetport Statistics\n");
    1737
    1738 - len += snprintf(buf + len, size - len,
    1739 + len += scnprintf(buf + len, size - len,
    1740 "LS: Rcv %08x Drop %08x Abort %08x\n",
    1741 atomic_read(&tgtp->rcv_ls_req_in),
    1742 atomic_read(&tgtp->rcv_ls_req_drop),
    1743 atomic_read(&tgtp->xmt_ls_abort));
    1744 if (atomic_read(&tgtp->rcv_ls_req_in) !=
    1745 atomic_read(&tgtp->rcv_ls_req_out)) {
    1746 - len += snprintf(buf + len, size - len,
    1747 + len += scnprintf(buf + len, size - len,
    1748 "Rcv LS: in %08x != out %08x\n",
    1749 atomic_read(&tgtp->rcv_ls_req_in),
    1750 atomic_read(&tgtp->rcv_ls_req_out));
    1751 }
    1752
    1753 - len += snprintf(buf + len, size - len,
    1754 + len += scnprintf(buf + len, size - len,
    1755 "LS: Xmt %08x Drop %08x Cmpl %08x\n",
    1756 atomic_read(&tgtp->xmt_ls_rsp),
    1757 atomic_read(&tgtp->xmt_ls_drop),
    1758 atomic_read(&tgtp->xmt_ls_rsp_cmpl));
    1759
    1760 - len += snprintf(buf + len, size - len,
    1761 + len += scnprintf(buf + len, size - len,
    1762 "LS: RSP Abort %08x xb %08x Err %08x\n",
    1763 atomic_read(&tgtp->xmt_ls_rsp_aborted),
    1764 atomic_read(&tgtp->xmt_ls_rsp_xb_set),
    1765 atomic_read(&tgtp->xmt_ls_rsp_error));
    1766
    1767 - len += snprintf(buf + len, size - len,
    1768 + len += scnprintf(buf + len, size - len,
    1769 "FCP: Rcv %08x Defer %08x Release %08x "
    1770 "Drop %08x\n",
    1771 atomic_read(&tgtp->rcv_fcp_cmd_in),
    1772 @@ -822,13 +824,13 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1773
    1774 if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
    1775 atomic_read(&tgtp->rcv_fcp_cmd_out)) {
    1776 - len += snprintf(buf + len, size - len,
    1777 + len += scnprintf(buf + len, size - len,
    1778 "Rcv FCP: in %08x != out %08x\n",
    1779 atomic_read(&tgtp->rcv_fcp_cmd_in),
    1780 atomic_read(&tgtp->rcv_fcp_cmd_out));
    1781 }
    1782
    1783 - len += snprintf(buf + len, size - len,
    1784 + len += scnprintf(buf + len, size - len,
    1785 "FCP Rsp: read %08x readrsp %08x "
    1786 "write %08x rsp %08x\n",
    1787 atomic_read(&tgtp->xmt_fcp_read),
    1788 @@ -836,31 +838,31 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1789 atomic_read(&tgtp->xmt_fcp_write),
    1790 atomic_read(&tgtp->xmt_fcp_rsp));
    1791
    1792 - len += snprintf(buf + len, size - len,
    1793 + len += scnprintf(buf + len, size - len,
    1794 "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
    1795 atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
    1796 atomic_read(&tgtp->xmt_fcp_rsp_error),
    1797 atomic_read(&tgtp->xmt_fcp_rsp_drop));
    1798
    1799 - len += snprintf(buf + len, size - len,
    1800 + len += scnprintf(buf + len, size - len,
    1801 "FCP Rsp Abort: %08x xb %08x xricqe %08x\n",
    1802 atomic_read(&tgtp->xmt_fcp_rsp_aborted),
    1803 atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
    1804 atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
    1805
    1806 - len += snprintf(buf + len, size - len,
    1807 + len += scnprintf(buf + len, size - len,
    1808 "ABORT: Xmt %08x Cmpl %08x\n",
    1809 atomic_read(&tgtp->xmt_fcp_abort),
    1810 atomic_read(&tgtp->xmt_fcp_abort_cmpl));
    1811
    1812 - len += snprintf(buf + len, size - len,
    1813 + len += scnprintf(buf + len, size - len,
    1814 "ABORT: Sol %08x Usol %08x Err %08x Cmpl %08x",
    1815 atomic_read(&tgtp->xmt_abort_sol),
    1816 atomic_read(&tgtp->xmt_abort_unsol),
    1817 atomic_read(&tgtp->xmt_abort_rsp),
    1818 atomic_read(&tgtp->xmt_abort_rsp_error));
    1819
    1820 - len += snprintf(buf + len, size - len, "\n");
    1821 + len += scnprintf(buf + len, size - len, "\n");
    1822
    1823 cnt = 0;
    1824 spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock);
    1825 @@ -871,7 +873,7 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1826 }
    1827 spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock);
    1828 if (cnt) {
    1829 - len += snprintf(buf + len, size - len,
    1830 + len += scnprintf(buf + len, size - len,
    1831 "ABORT: %d ctx entries\n", cnt);
    1832 spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock);
    1833 list_for_each_entry_safe(ctxp, next_ctxp,
    1834 @@ -879,7 +881,7 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1835 list) {
    1836 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ))
    1837 break;
    1838 - len += snprintf(buf + len, size - len,
    1839 + len += scnprintf(buf + len, size - len,
    1840 "Entry: oxid %x state %x "
    1841 "flag %x\n",
    1842 ctxp->oxid, ctxp->state,
    1843 @@ -893,7 +895,7 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1844 tot += atomic_read(&tgtp->xmt_fcp_release);
    1845 tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
    1846
    1847 - len += snprintf(buf + len, size - len,
    1848 + len += scnprintf(buf + len, size - len,
    1849 "IO_CTX: %08x WAIT: cur %08x tot %08x\n"
    1850 "CTX Outstanding %08llx\n",
    1851 phba->sli4_hba.nvmet_xri_cnt,
    1852 @@ -911,10 +913,10 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1853 if (!lport)
    1854 return len;
    1855
    1856 - len += snprintf(buf + len, size - len,
    1857 + len += scnprintf(buf + len, size - len,
    1858 "\nNVME Lport Statistics\n");
    1859
    1860 - len += snprintf(buf + len, size - len,
    1861 + len += scnprintf(buf + len, size - len,
    1862 "LS: Xmt %016x Cmpl %016x\n",
    1863 atomic_read(&lport->fc4NvmeLsRequests),
    1864 atomic_read(&lport->fc4NvmeLsCmpls));
    1865 @@ -938,20 +940,20 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1866 if (i >= 32)
    1867 continue;
    1868
    1869 - len += snprintf(buf + len, PAGE_SIZE - len,
    1870 + len += scnprintf(buf + len, PAGE_SIZE - len,
    1871 "FCP (%d): Rd %016llx Wr %016llx "
    1872 "IO %016llx ",
    1873 i, data1, data2, data3);
    1874 - len += snprintf(buf + len, PAGE_SIZE - len,
    1875 + len += scnprintf(buf + len, PAGE_SIZE - len,
    1876 "Cmpl %016llx OutIO %016llx\n",
    1877 tot, ((data1 + data2 + data3) - tot));
    1878 }
    1879 - len += snprintf(buf + len, PAGE_SIZE - len,
    1880 + len += scnprintf(buf + len, PAGE_SIZE - len,
    1881 "Total FCP Cmpl %016llx Issue %016llx "
    1882 "OutIO %016llx\n",
    1883 totin, totout, totout - totin);
    1884
    1885 - len += snprintf(buf + len, size - len,
    1886 + len += scnprintf(buf + len, size - len,
    1887 "LS Xmt Err: Abrt %08x Err %08x "
    1888 "Cmpl Err: xb %08x Err %08x\n",
    1889 atomic_read(&lport->xmt_ls_abort),
    1890 @@ -959,7 +961,7 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1891 atomic_read(&lport->cmpl_ls_xb),
    1892 atomic_read(&lport->cmpl_ls_err));
    1893
    1894 - len += snprintf(buf + len, size - len,
    1895 + len += scnprintf(buf + len, size - len,
    1896 "FCP Xmt Err: noxri %06x nondlp %06x "
    1897 "qdepth %06x wqerr %06x err %06x Abrt %06x\n",
    1898 atomic_read(&lport->xmt_fcp_noxri),
    1899 @@ -969,7 +971,7 @@ lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
    1900 atomic_read(&lport->xmt_fcp_err),
    1901 atomic_read(&lport->xmt_fcp_abort));
    1902
    1903 - len += snprintf(buf + len, size - len,
    1904 + len += scnprintf(buf + len, size - len,
    1905 "FCP Cmpl Err: xb %08x Err %08x\n",
    1906 atomic_read(&lport->cmpl_fcp_xb),
    1907 atomic_read(&lport->cmpl_fcp_err));
    1908 @@ -1001,58 +1003,58 @@ lpfc_debugfs_nvmektime_data(struct lpfc_vport *vport, char *buf, int size)
    1909
    1910 if (phba->nvmet_support == 0) {
    1911 /* NVME Initiator */
    1912 - len += snprintf(buf + len, PAGE_SIZE - len,
    1913 + len += scnprintf(buf + len, PAGE_SIZE - len,
    1914 "ktime %s: Total Samples: %lld\n",
    1915 (phba->ktime_on ? "Enabled" : "Disabled"),
    1916 phba->ktime_data_samples);
    1917 if (phba->ktime_data_samples == 0)
    1918 return len;
    1919
    1920 - len += snprintf(
    1921 + len += scnprintf(
    1922 buf + len, PAGE_SIZE - len,
    1923 "Segment 1: Last NVME Cmd cmpl "
    1924 "done -to- Start of next NVME cnd (in driver)\n");
    1925 - len += snprintf(
    1926 + len += scnprintf(
    1927 buf + len, PAGE_SIZE - len,
    1928 "avg:%08lld min:%08lld max %08lld\n",
    1929 div_u64(phba->ktime_seg1_total,
    1930 phba->ktime_data_samples),
    1931 phba->ktime_seg1_min,
    1932 phba->ktime_seg1_max);
    1933 - len += snprintf(
    1934 + len += scnprintf(
    1935 buf + len, PAGE_SIZE - len,
    1936 "Segment 2: Driver start of NVME cmd "
    1937 "-to- Firmware WQ doorbell\n");
    1938 - len += snprintf(
    1939 + len += scnprintf(
    1940 buf + len, PAGE_SIZE - len,
    1941 "avg:%08lld min:%08lld max %08lld\n",
    1942 div_u64(phba->ktime_seg2_total,
    1943 phba->ktime_data_samples),
    1944 phba->ktime_seg2_min,
    1945 phba->ktime_seg2_max);
    1946 - len += snprintf(
    1947 + len += scnprintf(
    1948 buf + len, PAGE_SIZE - len,
    1949 "Segment 3: Firmware WQ doorbell -to- "
    1950 "MSI-X ISR cmpl\n");
    1951 - len += snprintf(
    1952 + len += scnprintf(
    1953 buf + len, PAGE_SIZE - len,
    1954 "avg:%08lld min:%08lld max %08lld\n",
    1955 div_u64(phba->ktime_seg3_total,
    1956 phba->ktime_data_samples),
    1957 phba->ktime_seg3_min,
    1958 phba->ktime_seg3_max);
    1959 - len += snprintf(
    1960 + len += scnprintf(
    1961 buf + len, PAGE_SIZE - len,
    1962 "Segment 4: MSI-X ISR cmpl -to- "
    1963 "NVME cmpl done\n");
    1964 - len += snprintf(
    1965 + len += scnprintf(
    1966 buf + len, PAGE_SIZE - len,
    1967 "avg:%08lld min:%08lld max %08lld\n",
    1968 div_u64(phba->ktime_seg4_total,
    1969 phba->ktime_data_samples),
    1970 phba->ktime_seg4_min,
    1971 phba->ktime_seg4_max);
    1972 - len += snprintf(
    1973 + len += scnprintf(
    1974 buf + len, PAGE_SIZE - len,
    1975 "Total IO avg time: %08lld\n",
    1976 div_u64(phba->ktime_seg1_total +
    1977 @@ -1064,7 +1066,7 @@ lpfc_debugfs_nvmektime_data(struct lpfc_vport *vport, char *buf, int size)
    1978 }
    1979
    1980 /* NVME Target */
    1981 - len += snprintf(buf + len, PAGE_SIZE-len,
    1982 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1983 "ktime %s: Total Samples: %lld %lld\n",
    1984 (phba->ktime_on ? "Enabled" : "Disabled"),
    1985 phba->ktime_data_samples,
    1986 @@ -1072,46 +1074,46 @@ lpfc_debugfs_nvmektime_data(struct lpfc_vport *vport, char *buf, int size)
    1987 if (phba->ktime_data_samples == 0)
    1988 return len;
    1989
    1990 - len += snprintf(buf + len, PAGE_SIZE-len,
    1991 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1992 "Segment 1: MSI-X ISR Rcv cmd -to- "
    1993 "cmd pass to NVME Layer\n");
    1994 - len += snprintf(buf + len, PAGE_SIZE-len,
    1995 + len += scnprintf(buf + len, PAGE_SIZE-len,
    1996 "avg:%08lld min:%08lld max %08lld\n",
    1997 div_u64(phba->ktime_seg1_total,
    1998 phba->ktime_data_samples),
    1999 phba->ktime_seg1_min,
    2000 phba->ktime_seg1_max);
    2001 - len += snprintf(buf + len, PAGE_SIZE-len,
    2002 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2003 "Segment 2: cmd pass to NVME Layer- "
    2004 "-to- Driver rcv cmd OP (action)\n");
    2005 - len += snprintf(buf + len, PAGE_SIZE-len,
    2006 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2007 "avg:%08lld min:%08lld max %08lld\n",
    2008 div_u64(phba->ktime_seg2_total,
    2009 phba->ktime_data_samples),
    2010 phba->ktime_seg2_min,
    2011 phba->ktime_seg2_max);
    2012 - len += snprintf(buf + len, PAGE_SIZE-len,
    2013 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2014 "Segment 3: Driver rcv cmd OP -to- "
    2015 "Firmware WQ doorbell: cmd\n");
    2016 - len += snprintf(buf + len, PAGE_SIZE-len,
    2017 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2018 "avg:%08lld min:%08lld max %08lld\n",
    2019 div_u64(phba->ktime_seg3_total,
    2020 phba->ktime_data_samples),
    2021 phba->ktime_seg3_min,
    2022 phba->ktime_seg3_max);
    2023 - len += snprintf(buf + len, PAGE_SIZE-len,
    2024 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2025 "Segment 4: Firmware WQ doorbell: cmd "
    2026 "-to- MSI-X ISR for cmd cmpl\n");
    2027 - len += snprintf(buf + len, PAGE_SIZE-len,
    2028 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2029 "avg:%08lld min:%08lld max %08lld\n",
    2030 div_u64(phba->ktime_seg4_total,
    2031 phba->ktime_data_samples),
    2032 phba->ktime_seg4_min,
    2033 phba->ktime_seg4_max);
    2034 - len += snprintf(buf + len, PAGE_SIZE-len,
    2035 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2036 "Segment 5: MSI-X ISR for cmd cmpl "
    2037 "-to- NVME layer passed cmd done\n");
    2038 - len += snprintf(buf + len, PAGE_SIZE-len,
    2039 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2040 "avg:%08lld min:%08lld max %08lld\n",
    2041 div_u64(phba->ktime_seg5_total,
    2042 phba->ktime_data_samples),
    2043 @@ -1119,10 +1121,10 @@ lpfc_debugfs_nvmektime_data(struct lpfc_vport *vport, char *buf, int size)
    2044 phba->ktime_seg5_max);
    2045
    2046 if (phba->ktime_status_samples == 0) {
    2047 - len += snprintf(buf + len, PAGE_SIZE-len,
    2048 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2049 "Total: cmd received by MSI-X ISR "
    2050 "-to- cmd completed on wire\n");
    2051 - len += snprintf(buf + len, PAGE_SIZE-len,
    2052 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2053 "avg:%08lld min:%08lld "
    2054 "max %08lld\n",
    2055 div_u64(phba->ktime_seg10_total,
    2056 @@ -1132,46 +1134,46 @@ lpfc_debugfs_nvmektime_data(struct lpfc_vport *vport, char *buf, int size)
    2057 return len;
    2058 }
    2059
    2060 - len += snprintf(buf + len, PAGE_SIZE-len,
    2061 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2062 "Segment 6: NVME layer passed cmd done "
    2063 "-to- Driver rcv rsp status OP\n");
    2064 - len += snprintf(buf + len, PAGE_SIZE-len,
    2065 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2066 "avg:%08lld min:%08lld max %08lld\n",
    2067 div_u64(phba->ktime_seg6_total,
    2068 phba->ktime_status_samples),
    2069 phba->ktime_seg6_min,
    2070 phba->ktime_seg6_max);
    2071 - len += snprintf(buf + len, PAGE_SIZE-len,
    2072 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2073 "Segment 7: Driver rcv rsp status OP "
    2074 "-to- Firmware WQ doorbell: status\n");
    2075 - len += snprintf(buf + len, PAGE_SIZE-len,
    2076 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2077 "avg:%08lld min:%08lld max %08lld\n",
    2078 div_u64(phba->ktime_seg7_total,
    2079 phba->ktime_status_samples),
    2080 phba->ktime_seg7_min,
    2081 phba->ktime_seg7_max);
    2082 - len += snprintf(buf + len, PAGE_SIZE-len,
    2083 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2084 "Segment 8: Firmware WQ doorbell: status"
    2085 " -to- MSI-X ISR for status cmpl\n");
    2086 - len += snprintf(buf + len, PAGE_SIZE-len,
    2087 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2088 "avg:%08lld min:%08lld max %08lld\n",
    2089 div_u64(phba->ktime_seg8_total,
    2090 phba->ktime_status_samples),
    2091 phba->ktime_seg8_min,
    2092 phba->ktime_seg8_max);
    2093 - len += snprintf(buf + len, PAGE_SIZE-len,
    2094 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2095 "Segment 9: MSI-X ISR for status cmpl "
    2096 "-to- NVME layer passed status done\n");
    2097 - len += snprintf(buf + len, PAGE_SIZE-len,
    2098 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2099 "avg:%08lld min:%08lld max %08lld\n",
    2100 div_u64(phba->ktime_seg9_total,
    2101 phba->ktime_status_samples),
    2102 phba->ktime_seg9_min,
    2103 phba->ktime_seg9_max);
    2104 - len += snprintf(buf + len, PAGE_SIZE-len,
    2105 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2106 "Total: cmd received by MSI-X ISR -to- "
    2107 "cmd completed on wire\n");
    2108 - len += snprintf(buf + len, PAGE_SIZE-len,
    2109 + len += scnprintf(buf + len, PAGE_SIZE-len,
    2110 "avg:%08lld min:%08lld max %08lld\n",
    2111 div_u64(phba->ktime_seg10_total,
    2112 phba->ktime_status_samples),
    2113 @@ -1206,7 +1208,7 @@ lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
    2114 (phba->nvmeio_trc_size - 1);
    2115 skip = phba->nvmeio_trc_output_idx;
    2116
    2117 - len += snprintf(buf + len, size - len,
    2118 + len += scnprintf(buf + len, size - len,
    2119 "%s IO Trace %s: next_idx %d skip %d size %d\n",
    2120 (phba->nvmet_support ? "NVME" : "NVMET"),
    2121 (state ? "Enabled" : "Disabled"),
    2122 @@ -1228,18 +1230,18 @@ lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
    2123 if (!dtp->fmt)
    2124 continue;
    2125
    2126 - len += snprintf(buf + len, size - len, dtp->fmt,
    2127 + len += scnprintf(buf + len, size - len, dtp->fmt,
    2128 dtp->data1, dtp->data2, dtp->data3);
    2129
    2130 if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
    2131 phba->nvmeio_trc_output_idx = 0;
    2132 - len += snprintf(buf + len, size - len,
    2133 + len += scnprintf(buf + len, size - len,
    2134 "Trace Complete\n");
    2135 goto out;
    2136 }
    2137
    2138 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
    2139 - len += snprintf(buf + len, size - len,
    2140 + len += scnprintf(buf + len, size - len,
    2141 "Trace Continue (%d of %d)\n",
    2142 phba->nvmeio_trc_output_idx,
    2143 phba->nvmeio_trc_size);
    2144 @@ -1257,18 +1259,18 @@ lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
    2145 if (!dtp->fmt)
    2146 continue;
    2147
    2148 - len += snprintf(buf + len, size - len, dtp->fmt,
    2149 + len += scnprintf(buf + len, size - len, dtp->fmt,
    2150 dtp->data1, dtp->data2, dtp->data3);
    2151
    2152 if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
    2153 phba->nvmeio_trc_output_idx = 0;
    2154 - len += snprintf(buf + len, size - len,
    2155 + len += scnprintf(buf + len, size - len,
    2156 "Trace Complete\n");
    2157 goto out;
    2158 }
    2159
    2160 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
    2161 - len += snprintf(buf + len, size - len,
    2162 + len += scnprintf(buf + len, size - len,
    2163 "Trace Continue (%d of %d)\n",
    2164 phba->nvmeio_trc_output_idx,
    2165 phba->nvmeio_trc_size);
    2166 @@ -1276,7 +1278,7 @@ lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
    2167 }
    2168 }
    2169
    2170 - len += snprintf(buf + len, size - len,
    2171 + len += scnprintf(buf + len, size - len,
    2172 "Trace Done\n");
    2173 out:
    2174 return len;
    2175 @@ -1308,39 +1310,39 @@ lpfc_debugfs_cpucheck_data(struct lpfc_vport *vport, char *buf, int size)
    2176
    2177 if (phba->nvmet_support == 0) {
    2178 /* NVME Initiator */
    2179 - len += snprintf(buf + len, PAGE_SIZE - len,
    2180 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2181 "CPUcheck %s\n",
    2182 (phba->cpucheck_on & LPFC_CHECK_NVME_IO ?
    2183 "Enabled" : "Disabled"));
    2184 for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
    2185 if (i >= LPFC_CHECK_CPU_CNT)
    2186 break;
    2187 - len += snprintf(buf + len, PAGE_SIZE - len,
    2188 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2189 "%02d: xmit x%08x cmpl x%08x\n",
    2190 i, phba->cpucheck_xmt_io[i],
    2191 phba->cpucheck_cmpl_io[i]);
    2192 tot_xmt += phba->cpucheck_xmt_io[i];
    2193 tot_cmpl += phba->cpucheck_cmpl_io[i];
    2194 }
    2195 - len += snprintf(buf + len, PAGE_SIZE - len,
    2196 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2197 "tot:xmit x%08x cmpl x%08x\n",
    2198 tot_xmt, tot_cmpl);
    2199 return len;
    2200 }
    2201
    2202 /* NVME Target */
    2203 - len += snprintf(buf + len, PAGE_SIZE - len,
    2204 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2205 "CPUcheck %s ",
    2206 (phba->cpucheck_on & LPFC_CHECK_NVMET_IO ?
    2207 "IO Enabled - " : "IO Disabled - "));
    2208 - len += snprintf(buf + len, PAGE_SIZE - len,
    2209 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2210 "%s\n",
    2211 (phba->cpucheck_on & LPFC_CHECK_NVMET_RCV ?
    2212 "Rcv Enabled\n" : "Rcv Disabled\n"));
    2213 for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
    2214 if (i >= LPFC_CHECK_CPU_CNT)
    2215 break;
    2216 - len += snprintf(buf + len, PAGE_SIZE - len,
    2217 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2218 "%02d: xmit x%08x ccmpl x%08x "
    2219 "cmpl x%08x rcv x%08x\n",
    2220 i, phba->cpucheck_xmt_io[i],
    2221 @@ -1352,7 +1354,7 @@ lpfc_debugfs_cpucheck_data(struct lpfc_vport *vport, char *buf, int size)
    2222 tot_cmpl += phba->cpucheck_cmpl_io[i];
    2223 tot_ccmpl += phba->cpucheck_ccmpl_io[i];
    2224 }
    2225 - len += snprintf(buf + len, PAGE_SIZE - len,
    2226 + len += scnprintf(buf + len, PAGE_SIZE - len,
    2227 "tot:xmit x%08x ccmpl x%08x cmpl x%08x rcv x%08x\n",
    2228 tot_xmt, tot_ccmpl, tot_cmpl, tot_rcv);
    2229 return len;
    2230 @@ -1797,28 +1799,29 @@ lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
    2231 int cnt = 0;
    2232
    2233 if (dent == phba->debug_writeGuard)
    2234 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wgrd_cnt);
    2235 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wgrd_cnt);
    2236 else if (dent == phba->debug_writeApp)
    2237 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wapp_cnt);
    2238 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wapp_cnt);
    2239 else if (dent == phba->debug_writeRef)
    2240 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wref_cnt);
    2241 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wref_cnt);
    2242 else if (dent == phba->debug_readGuard)
    2243 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rgrd_cnt);
    2244 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rgrd_cnt);
    2245 else if (dent == phba->debug_readApp)
    2246 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rapp_cnt);
    2247 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rapp_cnt);
    2248 else if (dent == phba->debug_readRef)
    2249 - cnt = snprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rref_cnt);
    2250 + cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rref_cnt);
    2251 else if (dent == phba->debug_InjErrNPortID)
    2252 - cnt = snprintf(cbuf, 32, "0x%06x\n", phba->lpfc_injerr_nportid);
    2253 + cnt = scnprintf(cbuf, 32, "0x%06x\n",
    2254 + phba->lpfc_injerr_nportid);
    2255 else if (dent == phba->debug_InjErrWWPN) {
    2256 memcpy(&tmp, &phba->lpfc_injerr_wwpn, sizeof(struct lpfc_name));
    2257 tmp = cpu_to_be64(tmp);
    2258 - cnt = snprintf(cbuf, 32, "0x%016llx\n", tmp);
    2259 + cnt = scnprintf(cbuf, 32, "0x%016llx\n", tmp);
    2260 } else if (dent == phba->debug_InjErrLBA) {
    2261 if (phba->lpfc_injerr_lba == (sector_t)(-1))
    2262 - cnt = snprintf(cbuf, 32, "off\n");
    2263 + cnt = scnprintf(cbuf, 32, "off\n");
    2264 else
    2265 - cnt = snprintf(cbuf, 32, "0x%llx\n",
    2266 + cnt = scnprintf(cbuf, 32, "0x%llx\n",
    2267 (uint64_t) phba->lpfc_injerr_lba);
    2268 } else
    2269 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
    2270 @@ -2624,17 +2627,17 @@ lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
    2271 switch (count) {
    2272 case SIZE_U8: /* byte (8 bits) */
    2273 pci_read_config_byte(pdev, where, &u8val);
    2274 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2275 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2276 "%03x: %02x\n", where, u8val);
    2277 break;
    2278 case SIZE_U16: /* word (16 bits) */
    2279 pci_read_config_word(pdev, where, &u16val);
    2280 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2281 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2282 "%03x: %04x\n", where, u16val);
    2283 break;
    2284 case SIZE_U32: /* double word (32 bits) */
    2285 pci_read_config_dword(pdev, where, &u32val);
    2286 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2287 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2288 "%03x: %08x\n", where, u32val);
    2289 break;
    2290 case LPFC_PCI_CFG_BROWSE: /* browse all */
    2291 @@ -2654,25 +2657,25 @@ pcicfg_browse:
    2292 offset = offset_label;
    2293
    2294 /* Read PCI config space */
    2295 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2296 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2297 "%03x: ", offset_label);
    2298 while (index > 0) {
    2299 pci_read_config_dword(pdev, offset, &u32val);
    2300 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2301 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2302 "%08x ", u32val);
    2303 offset += sizeof(uint32_t);
    2304 if (offset >= LPFC_PCI_CFG_SIZE) {
    2305 - len += snprintf(pbuffer+len,
    2306 + len += scnprintf(pbuffer+len,
    2307 LPFC_PCI_CFG_SIZE-len, "\n");
    2308 break;
    2309 }
    2310 index -= sizeof(uint32_t);
    2311 if (!index)
    2312 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2313 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2314 "\n");
    2315 else if (!(index % (8 * sizeof(uint32_t)))) {
    2316 offset_label += (8 * sizeof(uint32_t));
    2317 - len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2318 + len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
    2319 "\n%03x: ", offset_label);
    2320 }
    2321 }
    2322 @@ -2943,7 +2946,7 @@ lpfc_idiag_baracc_read(struct file *file, char __user *buf, size_t nbytes,
    2323 if (acc_range == SINGLE_WORD) {
    2324 offset_run = offset;
    2325 u32val = readl(mem_mapped_bar + offset_run);
    2326 - len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2327 + len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2328 "%05x: %08x\n", offset_run, u32val);
    2329 } else
    2330 goto baracc_browse;
    2331 @@ -2957,35 +2960,35 @@ baracc_browse:
    2332 offset_run = offset_label;
    2333
    2334 /* Read PCI bar memory mapped space */
    2335 - len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2336 + len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2337 "%05x: ", offset_label);
    2338 index = LPFC_PCI_BAR_RD_SIZE;
    2339 while (index > 0) {
    2340 u32val = readl(mem_mapped_bar + offset_run);
    2341 - len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2342 + len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2343 "%08x ", u32val);
    2344 offset_run += sizeof(uint32_t);
    2345 if (acc_range == LPFC_PCI_BAR_BROWSE) {
    2346 if (offset_run >= bar_size) {
    2347 - len += snprintf(pbuffer+len,
    2348 + len += scnprintf(pbuffer+len,
    2349 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
    2350 break;
    2351 }
    2352 } else {
    2353 if (offset_run >= offset +
    2354 (acc_range * sizeof(uint32_t))) {
    2355 - len += snprintf(pbuffer+len,
    2356 + len += scnprintf(pbuffer+len,
    2357 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
    2358 break;
    2359 }
    2360 }
    2361 index -= sizeof(uint32_t);
    2362 if (!index)
    2363 - len += snprintf(pbuffer+len,
    2364 + len += scnprintf(pbuffer+len,
    2365 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
    2366 else if (!(index % (8 * sizeof(uint32_t)))) {
    2367 offset_label += (8 * sizeof(uint32_t));
    2368 - len += snprintf(pbuffer+len,
    2369 + len += scnprintf(pbuffer+len,
    2370 LPFC_PCI_BAR_RD_BUF_SIZE-len,
    2371 "\n%05x: ", offset_label);
    2372 }
    2373 @@ -3158,19 +3161,19 @@ __lpfc_idiag_print_wq(struct lpfc_queue *qp, char *wqtype,
    2374 if (!qp)
    2375 return len;
    2376
    2377 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2378 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2379 "\t\t%s WQ info: ", wqtype);
    2380 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2381 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2382 "AssocCQID[%04d]: WQ-STAT[oflow:x%x posted:x%llx]\n",
    2383 qp->assoc_qid, qp->q_cnt_1,
    2384 (unsigned long long)qp->q_cnt_4);
    2385 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2386 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2387 "\t\tWQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
    2388 "HST-IDX[%04d], PRT-IDX[%04d], PST[%03d]",
    2389 qp->queue_id, qp->entry_count,
    2390 qp->entry_size, qp->host_index,
    2391 qp->hba_index, qp->entry_repost);
    2392 - len += snprintf(pbuffer + len,
    2393 + len += scnprintf(pbuffer + len,
    2394 LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
    2395 return len;
    2396 }
    2397 @@ -3208,21 +3211,21 @@ __lpfc_idiag_print_cq(struct lpfc_queue *qp, char *cqtype,
    2398 if (!qp)
    2399 return len;
    2400
    2401 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2402 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2403 "\t%s CQ info: ", cqtype);
    2404 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2405 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2406 "AssocEQID[%02d]: CQ STAT[max:x%x relw:x%x "
    2407 "xabt:x%x wq:x%llx]\n",
    2408 qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
    2409 qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
    2410 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2411 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2412 "\tCQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
    2413 "HST-IDX[%04d], PRT-IDX[%04d], PST[%03d]",
    2414 qp->queue_id, qp->entry_count,
    2415 qp->entry_size, qp->host_index,
    2416 qp->hba_index, qp->entry_repost);
    2417
    2418 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
    2419 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
    2420
    2421 return len;
    2422 }
    2423 @@ -3234,19 +3237,19 @@ __lpfc_idiag_print_rqpair(struct lpfc_queue *qp, struct lpfc_queue *datqp,
    2424 if (!qp || !datqp)
    2425 return len;
    2426
    2427 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2428 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2429 "\t\t%s RQ info: ", rqtype);
    2430 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2431 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2432 "AssocCQID[%02d]: RQ-STAT[nopost:x%x nobuf:x%x "
    2433 "posted:x%x rcv:x%llx]\n",
    2434 qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
    2435 qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
    2436 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2437 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2438 "\t\tHQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
    2439 "HST-IDX[%04d], PRT-IDX[%04d], PST[%03d]\n",
    2440 qp->queue_id, qp->entry_count, qp->entry_size,
    2441 qp->host_index, qp->hba_index, qp->entry_repost);
    2442 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2443 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2444 "\t\tDQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
    2445 "HST-IDX[%04d], PRT-IDX[%04d], PST[%03d]\n",
    2446 datqp->queue_id, datqp->entry_count,
    2447 @@ -3331,17 +3334,17 @@ __lpfc_idiag_print_eq(struct lpfc_queue *qp, char *eqtype,
    2448 if (!qp)
    2449 return len;
    2450
    2451 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2452 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2453 "\n%s EQ info: EQ-STAT[max:x%x noE:x%x "
    2454 "cqe_proc:x%x eqe_proc:x%llx eqd %d]\n",
    2455 eqtype, qp->q_cnt_1, qp->q_cnt_2, qp->q_cnt_3,
    2456 (unsigned long long)qp->q_cnt_4, qp->q_mode);
    2457 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2458 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2459 "EQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
    2460 "HST-IDX[%04d], PRT-IDX[%04d], PST[%03d]",
    2461 qp->queue_id, qp->entry_count, qp->entry_size,
    2462 qp->host_index, qp->hba_index, qp->entry_repost);
    2463 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
    2464 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
    2465
    2466 return len;
    2467 }
    2468 @@ -3399,7 +3402,7 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
    2469 if (phba->cfg_fof == 0)
    2470 phba->lpfc_idiag_last_eq = 0;
    2471
    2472 - len += snprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2473 + len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
    2474 "EQ %d out of %d HBA EQs\n",
    2475 x, phba->io_channel_irqs);
    2476
    2477 @@ -3512,7 +3515,7 @@ fof:
    2478 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
    2479
    2480 too_big:
    2481 - len += snprintf(pbuffer + len,
    2482 + len += scnprintf(pbuffer + len,
    2483 LPFC_QUE_INFO_GET_BUF_SIZE - len, "Truncated ...\n");
    2484 out:
    2485 spin_unlock_irq(&phba->hbalock);
    2486 @@ -3568,22 +3571,22 @@ lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque,
    2487 return 0;
    2488
    2489 esize = pque->entry_size;
    2490 - len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
    2491 + len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
    2492 "QE-INDEX[%04d]:\n", index);
    2493
    2494 offset = 0;
    2495 pentry = pque->qe[index].address;
    2496 while (esize > 0) {
    2497 - len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
    2498 + len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
    2499 "%08x ", *pentry);
    2500 pentry++;
    2501 offset += sizeof(uint32_t);
    2502 esize -= sizeof(uint32_t);
    2503 if (esize > 0 && !(offset % (4 * sizeof(uint32_t))))
    2504 - len += snprintf(pbuffer+len,
    2505 + len += scnprintf(pbuffer+len,
    2506 LPFC_QUE_ACC_BUF_SIZE-len, "\n");
    2507 }
    2508 - len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
    2509 + len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
    2510
    2511 return len;
    2512 }
    2513 @@ -3989,27 +3992,27 @@ lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
    2514
    2515 switch (drbregid) {
    2516 case LPFC_DRB_EQ:
    2517 - len += snprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE-len,
    2518 + len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE-len,
    2519 "EQ-DRB-REG: 0x%08x\n",
    2520 readl(phba->sli4_hba.EQDBregaddr));
    2521 break;
    2522 case LPFC_DRB_CQ:
    2523 - len += snprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE - len,
    2524 + len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE - len,
    2525 "CQ-DRB-REG: 0x%08x\n",
    2526 readl(phba->sli4_hba.CQDBregaddr));
    2527 break;
    2528 case LPFC_DRB_MQ:
    2529 - len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2530 + len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2531 "MQ-DRB-REG: 0x%08x\n",
    2532 readl(phba->sli4_hba.MQDBregaddr));
    2533 break;
    2534 case LPFC_DRB_WQ:
    2535 - len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2536 + len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2537 "WQ-DRB-REG: 0x%08x\n",
    2538 readl(phba->sli4_hba.WQDBregaddr));
    2539 break;
    2540 case LPFC_DRB_RQ:
    2541 - len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2542 + len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
    2543 "RQ-DRB-REG: 0x%08x\n",
    2544 readl(phba->sli4_hba.RQDBregaddr));
    2545 break;
    2546 @@ -4199,37 +4202,37 @@ lpfc_idiag_ctlacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
    2547
    2548 switch (ctlregid) {
    2549 case LPFC_CTL_PORT_SEM:
    2550 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2551 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2552 "Port SemReg: 0x%08x\n",
    2553 readl(phba->sli4_hba.conf_regs_memmap_p +
    2554 LPFC_CTL_PORT_SEM_OFFSET));
    2555 break;
    2556 case LPFC_CTL_PORT_STA:
    2557 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2558 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2559 "Port StaReg: 0x%08x\n",
    2560 readl(phba->sli4_hba.conf_regs_memmap_p +
    2561 LPFC_CTL_PORT_STA_OFFSET));
    2562 break;
    2563 case LPFC_CTL_PORT_CTL:
    2564 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2565 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2566 "Port CtlReg: 0x%08x\n",
    2567 readl(phba->sli4_hba.conf_regs_memmap_p +
    2568 LPFC_CTL_PORT_CTL_OFFSET));
    2569 break;
    2570 case LPFC_CTL_PORT_ER1:
    2571 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2572 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2573 "Port Er1Reg: 0x%08x\n",
    2574 readl(phba->sli4_hba.conf_regs_memmap_p +
    2575 LPFC_CTL_PORT_ER1_OFFSET));
    2576 break;
    2577 case LPFC_CTL_PORT_ER2:
    2578 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2579 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2580 "Port Er2Reg: 0x%08x\n",
    2581 readl(phba->sli4_hba.conf_regs_memmap_p +
    2582 LPFC_CTL_PORT_ER2_OFFSET));
    2583 break;
    2584 case LPFC_CTL_PDEV_CTL:
    2585 - len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2586 + len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
    2587 "PDev CtlReg: 0x%08x\n",
    2588 readl(phba->sli4_hba.conf_regs_memmap_p +
    2589 LPFC_CTL_PDEV_CTL_OFFSET));
    2590 @@ -4422,13 +4425,13 @@ lpfc_idiag_mbxacc_get_setup(struct lpfc_hba *phba, char *pbuffer)
    2591 mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
    2592 mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
    2593
    2594 - len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2595 + len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2596 "mbx_dump_map: 0x%08x\n", mbx_dump_map);
    2597 - len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2598 + len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2599 "mbx_dump_cnt: %04d\n", mbx_dump_cnt);
    2600 - len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2601 + len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2602 "mbx_word_cnt: %04d\n", mbx_word_cnt);
    2603 - len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2604 + len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
    2605 "mbx_mbox_cmd: 0x%02x\n", mbx_mbox_cmd);
    2606
    2607 return len;
    2608 @@ -4577,35 +4580,35 @@ lpfc_idiag_extacc_avail_get(struct lpfc_hba *phba, char *pbuffer, int len)
    2609 {
    2610 uint16_t ext_cnt, ext_size;
    2611
    2612 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2613 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2614 "\nAvailable Extents Information:\n");
    2615
    2616 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2617 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2618 "\tPort Available VPI extents: ");
    2619 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VPI,
    2620 &ext_cnt, &ext_size);
    2621 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2622 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2623 "Count %3d, Size %3d\n", ext_cnt, ext_size);
    2624
    2625 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2626 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2627 "\tPort Available VFI extents: ");
    2628 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VFI,
    2629 &ext_cnt, &ext_size);
    2630 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2631 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2632 "Count %3d, Size %3d\n", ext_cnt, ext_size);
    2633
    2634 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2635 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2636 "\tPort Available RPI extents: ");
    2637 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_RPI,
    2638 &ext_cnt, &ext_size);
    2639 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2640 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2641 "Count %3d, Size %3d\n", ext_cnt, ext_size);
    2642
    2643 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2644 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2645 "\tPort Available XRI extents: ");
    2646 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_XRI,
    2647 &ext_cnt, &ext_size);
    2648 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2649 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2650 "Count %3d, Size %3d\n", ext_cnt, ext_size);
    2651
    2652 return len;
    2653 @@ -4629,55 +4632,55 @@ lpfc_idiag_extacc_alloc_get(struct lpfc_hba *phba, char *pbuffer, int len)
    2654 uint16_t ext_cnt, ext_size;
    2655 int rc;
    2656
    2657 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2658 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2659 "\nAllocated Extents Information:\n");
    2660
    2661 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2662 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2663 "\tHost Allocated VPI extents: ");
    2664 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VPI,
    2665 &ext_cnt, &ext_size);
    2666 if (!rc)
    2667 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2668 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2669 "Port %d Extent %3d, Size %3d\n",
    2670 phba->brd_no, ext_cnt, ext_size);
    2671 else
    2672 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2673 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2674 "N/A\n");
    2675
    2676 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2677 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2678 "\tHost Allocated VFI extents: ");
    2679 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VFI,
    2680 &ext_cnt, &ext_size);
    2681 if (!rc)
    2682 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2683 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2684 "Port %d Extent %3d, Size %3d\n",
    2685 phba->brd_no, ext_cnt, ext_size);
    2686 else
    2687 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2688 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2689 "N/A\n");
    2690
    2691 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2692 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2693 "\tHost Allocated RPI extents: ");
    2694 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_RPI,
    2695 &ext_cnt, &ext_size);
    2696 if (!rc)
    2697 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2698 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2699 "Port %d Extent %3d, Size %3d\n",
    2700 phba->brd_no, ext_cnt, ext_size);
    2701 else
    2702 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2703 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2704 "N/A\n");
    2705
    2706 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2707 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2708 "\tHost Allocated XRI extents: ");
    2709 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_XRI,
    2710 &ext_cnt, &ext_size);
    2711 if (!rc)
    2712 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2713 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2714 "Port %d Extent %3d, Size %3d\n",
    2715 phba->brd_no, ext_cnt, ext_size);
    2716 else
    2717 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2718 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2719 "N/A\n");
    2720
    2721 return len;
    2722 @@ -4701,49 +4704,49 @@ lpfc_idiag_extacc_drivr_get(struct lpfc_hba *phba, char *pbuffer, int len)
    2723 struct lpfc_rsrc_blks *rsrc_blks;
    2724 int index;
    2725
    2726 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2727 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2728 "\nDriver Extents Information:\n");
    2729
    2730 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2731 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2732 "\tVPI extents:\n");
    2733 index = 0;
    2734 list_for_each_entry(rsrc_blks, &phba->lpfc_vpi_blk_list, list) {
    2735 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2736 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2737 "\t\tBlock %3d: Start %4d, Count %4d\n",
    2738 index, rsrc_blks->rsrc_start,
    2739 rsrc_blks->rsrc_size);
    2740 index++;
    2741 }
    2742 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2743 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2744 "\tVFI extents:\n");
    2745 index = 0;
    2746 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_vfi_blk_list,
    2747 list) {
    2748 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2749 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2750 "\t\tBlock %3d: Start %4d, Count %4d\n",
    2751 index, rsrc_blks->rsrc_start,
    2752 rsrc_blks->rsrc_size);
    2753 index++;
    2754 }
    2755
    2756 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2757 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2758 "\tRPI extents:\n");
    2759 index = 0;
    2760 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_rpi_blk_list,
    2761 list) {
    2762 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2763 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2764 "\t\tBlock %3d: Start %4d, Count %4d\n",
    2765 index, rsrc_blks->rsrc_start,
    2766 rsrc_blks->rsrc_size);
    2767 index++;
    2768 }
    2769
    2770 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2771 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2772 "\tXRI extents:\n");
    2773 index = 0;
    2774 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_xri_blk_list,
    2775 list) {
    2776 - len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2777 + len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
    2778 "\t\tBlock %3d: Start %4d, Count %4d\n",
    2779 index, rsrc_blks->rsrc_start,
    2780 rsrc_blks->rsrc_size);
    2781 @@ -5137,11 +5140,11 @@ lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp,
    2782 if (i != 0)
    2783 pr_err("%s\n", line_buf);
    2784 len = 0;
    2785 - len += snprintf(line_buf+len,
    2786 + len += scnprintf(line_buf+len,
    2787 LPFC_MBX_ACC_LBUF_SZ-len,
    2788 "%03d: ", i);
    2789 }
    2790 - len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
    2791 + len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
    2792 "%08x ", (uint32_t)*pword);
    2793 pword++;
    2794 }
    2795 @@ -5204,11 +5207,11 @@ lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
    2796 pr_err("%s\n", line_buf);
    2797 len = 0;
    2798 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
    2799 - len += snprintf(line_buf+len,
    2800 + len += scnprintf(line_buf+len,
    2801 LPFC_MBX_ACC_LBUF_SZ-len,
    2802 "%03d: ", i);
    2803 }
    2804 - len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
    2805 + len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
    2806 "%08x ",
    2807 ((uint32_t)*pword) & 0xffffffff);
    2808 pword++;
    2809 @@ -5227,18 +5230,18 @@ lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
    2810 pr_err("%s\n", line_buf);
    2811 len = 0;
    2812 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
    2813 - len += snprintf(line_buf+len,
    2814 + len += scnprintf(line_buf+len,
    2815 LPFC_MBX_ACC_LBUF_SZ-len,
    2816 "%03d: ", i);
    2817 }
    2818 for (j = 0; j < 4; j++) {
    2819 - len += snprintf(line_buf+len,
    2820 + len += scnprintf(line_buf+len,
    2821 LPFC_MBX_ACC_LBUF_SZ-len,
    2822 "%02x",
    2823 ((uint8_t)*pbyte) & 0xff);
    2824 pbyte++;
    2825 }
    2826 - len += snprintf(line_buf+len,
    2827 + len += scnprintf(line_buf+len,
    2828 LPFC_MBX_ACC_LBUF_SZ-len, " ");
    2829 }
    2830 if ((i - 1) % 8)
    2831 diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
    2832 index 30efc7bf91bd..824de3e410ca 100644
    2833 --- a/drivers/scsi/lpfc/lpfc_debugfs.h
    2834 +++ b/drivers/scsi/lpfc/lpfc_debugfs.h
    2835 @@ -342,7 +342,7 @@ lpfc_debug_dump_qe(struct lpfc_queue *q, uint32_t idx)
    2836 pword = q->qe[idx].address;
    2837
    2838 len = 0;
    2839 - len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "QE[%04d]: ", idx);
    2840 + len += scnprintf(line_buf+len, LPFC_LBUF_SZ-len, "QE[%04d]: ", idx);
    2841 if (qe_word_cnt > 8)
    2842 printk(KERN_ERR "%s\n", line_buf);
    2843
    2844 @@ -353,11 +353,11 @@ lpfc_debug_dump_qe(struct lpfc_queue *q, uint32_t idx)
    2845 if (qe_word_cnt > 8) {
    2846 len = 0;
    2847 memset(line_buf, 0, LPFC_LBUF_SZ);
    2848 - len += snprintf(line_buf+len, LPFC_LBUF_SZ-len,
    2849 + len += scnprintf(line_buf+len, LPFC_LBUF_SZ-len,
    2850 "%03d: ", i);
    2851 }
    2852 }
    2853 - len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "%08x ",
    2854 + len += scnprintf(line_buf+len, LPFC_LBUF_SZ-len, "%08x ",
    2855 ((uint32_t)*pword) & 0xffffffff);
    2856 pword++;
    2857 }
    2858 diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
    2859 index 4888b999e82f..f8f4d3ea67f3 100644
    2860 --- a/drivers/scsi/qla2xxx/qla_attr.c
    2861 +++ b/drivers/scsi/qla2xxx/qla_attr.c
    2862 @@ -345,7 +345,7 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
    2863 }
    2864
    2865 ha->optrom_region_start = start;
    2866 - ha->optrom_region_size = start + size;
    2867 + ha->optrom_region_size = size;
    2868
    2869 ha->optrom_state = QLA_SREADING;
    2870 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
    2871 @@ -418,7 +418,7 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
    2872 }
    2873
    2874 ha->optrom_region_start = start;
    2875 - ha->optrom_region_size = start + size;
    2876 + ha->optrom_region_size = size;
    2877
    2878 ha->optrom_state = QLA_SWRITING;
    2879 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
    2880 diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
    2881 index d2888b30a8a3..a8c67cd17625 100644
    2882 --- a/drivers/scsi/qla2xxx/qla_target.c
    2883 +++ b/drivers/scsi/qla2xxx/qla_target.c
    2884 @@ -981,6 +981,8 @@ void qlt_free_session_done(struct work_struct *work)
    2885 sess->send_els_logo);
    2886
    2887 if (!IS_SW_RESV_ADDR(sess->d_id)) {
    2888 + qla2x00_mark_device_lost(vha, sess, 0, 0);
    2889 +
    2890 if (sess->send_els_logo) {
    2891 qlt_port_logo_t logo;
    2892
    2893 @@ -1161,8 +1163,6 @@ void qlt_unreg_sess(struct fc_port *sess)
    2894 if (sess->se_sess)
    2895 vha->hw->tgt.tgt_ops->clear_nacl_from_fcport_map(sess);
    2896
    2897 - qla2x00_mark_device_lost(vha, sess, 0, 0);
    2898 -
    2899 sess->deleted = QLA_SESS_DELETION_IN_PROGRESS;
    2900 sess->disc_state = DSC_DELETE_PEND;
    2901 sess->last_rscn_gen = sess->rscn_gen;
    2902 diff --git a/drivers/soc/sunxi/Kconfig b/drivers/soc/sunxi/Kconfig
    2903 index 353b07e40176..e84eb4e59f58 100644
    2904 --- a/drivers/soc/sunxi/Kconfig
    2905 +++ b/drivers/soc/sunxi/Kconfig
    2906 @@ -4,6 +4,7 @@
    2907 config SUNXI_SRAM
    2908 bool
    2909 default ARCH_SUNXI
    2910 + select REGMAP_MMIO
    2911 help
    2912 Say y here to enable the SRAM controller support. This
    2913 device is responsible on mapping the SRAM in the sunXi SoCs
    2914 diff --git a/drivers/staging/greybus/power_supply.c b/drivers/staging/greybus/power_supply.c
    2915 index 0529e5628c24..ae5c0285a942 100644
    2916 --- a/drivers/staging/greybus/power_supply.c
    2917 +++ b/drivers/staging/greybus/power_supply.c
    2918 @@ -520,7 +520,7 @@ static int gb_power_supply_prop_descriptors_get(struct gb_power_supply *gbpsy)
    2919
    2920 op = gb_operation_create(connection,
    2921 GB_POWER_SUPPLY_TYPE_GET_PROP_DESCRIPTORS,
    2922 - sizeof(req), sizeof(*resp) + props_count *
    2923 + sizeof(*req), sizeof(*resp) + props_count *
    2924 sizeof(struct gb_power_supply_props_desc),
    2925 GFP_KERNEL);
    2926 if (!op)
    2927 diff --git a/drivers/staging/most/cdev/cdev.c b/drivers/staging/most/cdev/cdev.c
    2928 index 4569838f27a0..0b48677fa958 100644
    2929 --- a/drivers/staging/most/cdev/cdev.c
    2930 +++ b/drivers/staging/most/cdev/cdev.c
    2931 @@ -546,7 +546,7 @@ static void __exit mod_exit(void)
    2932 destroy_cdev(c);
    2933 destroy_channel(c);
    2934 }
    2935 - unregister_chrdev_region(comp.devno, 1);
    2936 + unregister_chrdev_region(comp.devno, CHRDEV_REGION_SIZE);
    2937 ida_destroy(&comp.minor_id);
    2938 class_destroy(comp.class);
    2939 }
    2940 diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
    2941 index 32da5a4182ac..5b442bc68a76 100644
    2942 --- a/drivers/usb/class/cdc-acm.c
    2943 +++ b/drivers/usb/class/cdc-acm.c
    2944 @@ -470,12 +470,12 @@ static void acm_read_bulk_callback(struct urb *urb)
    2945 struct acm *acm = rb->instance;
    2946 unsigned long flags;
    2947 int status = urb->status;
    2948 + bool stopped = false;
    2949 + bool stalled = false;
    2950
    2951 dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
    2952 rb->index, urb->actual_length, status);
    2953
    2954 - set_bit(rb->index, &acm->read_urbs_free);
    2955 -
    2956 if (!acm->dev) {
    2957 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
    2958 return;
    2959 @@ -488,15 +488,16 @@ static void acm_read_bulk_callback(struct urb *urb)
    2960 break;
    2961 case -EPIPE:
    2962 set_bit(EVENT_RX_STALL, &acm->flags);
    2963 - schedule_work(&acm->work);
    2964 - return;
    2965 + stalled = true;
    2966 + break;
    2967 case -ENOENT:
    2968 case -ECONNRESET:
    2969 case -ESHUTDOWN:
    2970 dev_dbg(&acm->data->dev,
    2971 "%s - urb shutting down with status: %d\n",
    2972 __func__, status);
    2973 - return;
    2974 + stopped = true;
    2975 + break;
    2976 default:
    2977 dev_dbg(&acm->data->dev,
    2978 "%s - nonzero urb status received: %d\n",
    2979 @@ -505,10 +506,24 @@ static void acm_read_bulk_callback(struct urb *urb)
    2980 }
    2981
    2982 /*
    2983 - * Unthrottle may run on another CPU which needs to see events
    2984 - * in the same order. Submission has an implict barrier
    2985 + * Make sure URB processing is done before marking as free to avoid
    2986 + * racing with unthrottle() on another CPU. Matches the barriers
    2987 + * implied by the test_and_clear_bit() in acm_submit_read_urb().
    2988 */
    2989 smp_mb__before_atomic();
    2990 + set_bit(rb->index, &acm->read_urbs_free);
    2991 + /*
    2992 + * Make sure URB is marked as free before checking the throttled flag
    2993 + * to avoid racing with unthrottle() on another CPU. Matches the
    2994 + * smp_mb() in unthrottle().
    2995 + */
    2996 + smp_mb__after_atomic();
    2997 +
    2998 + if (stopped || stalled) {
    2999 + if (stalled)
    3000 + schedule_work(&acm->work);
    3001 + return;
    3002 + }
    3003
    3004 /* throttle device if requested by tty */
    3005 spin_lock_irqsave(&acm->read_lock, flags);
    3006 @@ -842,6 +857,9 @@ static void acm_tty_unthrottle(struct tty_struct *tty)
    3007 acm->throttle_req = 0;
    3008 spin_unlock_irq(&acm->read_lock);
    3009
    3010 + /* Matches the smp_mb__after_atomic() in acm_read_bulk_callback(). */
    3011 + smp_mb();
    3012 +
    3013 if (was_throttled)
    3014 acm_submit_read_urbs(acm, GFP_KERNEL);
    3015 }
    3016 diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
    3017 index fec97465ccac..4d5c7dda8f54 100644
    3018 --- a/drivers/usb/dwc3/core.c
    3019 +++ b/drivers/usb/dwc3/core.c
    3020 @@ -1214,7 +1214,7 @@ static void dwc3_get_properties(struct dwc3 *dwc)
    3021 u8 tx_max_burst_prd;
    3022
    3023 /* default to highest possible threshold */
    3024 - lpm_nyet_threshold = 0xff;
    3025 + lpm_nyet_threshold = 0xf;
    3026
    3027 /* default to -3.5dB de-emphasis */
    3028 tx_de_emphasis = 1;
    3029 diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
    3030 index ad08895e78f9..c3dae7d5cb6e 100644
    3031 --- a/drivers/usb/musb/Kconfig
    3032 +++ b/drivers/usb/musb/Kconfig
    3033 @@ -66,7 +66,7 @@ config USB_MUSB_SUNXI
    3034 depends on NOP_USB_XCEIV
    3035 depends on PHY_SUN4I_USB
    3036 depends on EXTCON
    3037 - depends on GENERIC_PHY
    3038 + select GENERIC_PHY
    3039 select SUNXI_SRAM
    3040
    3041 config USB_MUSB_DAVINCI
    3042 diff --git a/drivers/usb/serial/f81232.c b/drivers/usb/serial/f81232.c
    3043 index 96036f87b1de..087e5f1656f8 100644
    3044 --- a/drivers/usb/serial/f81232.c
    3045 +++ b/drivers/usb/serial/f81232.c
    3046 @@ -556,9 +556,12 @@ static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port)
    3047
    3048 static void f81232_close(struct usb_serial_port *port)
    3049 {
    3050 + struct f81232_private *port_priv = usb_get_serial_port_data(port);
    3051 +
    3052 f81232_port_disable(port);
    3053 usb_serial_generic_close(port);
    3054 usb_kill_urb(port->interrupt_in_urb);
    3055 + flush_work(&port_priv->interrupt_work);
    3056 }
    3057
    3058 static void f81232_dtr_rts(struct usb_serial_port *port, int on)
    3059 @@ -652,6 +655,40 @@ static int f81232_port_remove(struct usb_serial_port *port)
    3060 return 0;
    3061 }
    3062
    3063 +static int f81232_suspend(struct usb_serial *serial, pm_message_t message)
    3064 +{
    3065 + struct usb_serial_port *port = serial->port[0];
    3066 + struct f81232_private *port_priv = usb_get_serial_port_data(port);
    3067 + int i;
    3068 +
    3069 + for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
    3070 + usb_kill_urb(port->read_urbs[i]);
    3071 +
    3072 + usb_kill_urb(port->interrupt_in_urb);
    3073 +
    3074 + if (port_priv)
    3075 + flush_work(&port_priv->interrupt_work);
    3076 +
    3077 + return 0;
    3078 +}
    3079 +
    3080 +static int f81232_resume(struct usb_serial *serial)
    3081 +{
    3082 + struct usb_serial_port *port = serial->port[0];
    3083 + int result;
    3084 +
    3085 + if (tty_port_initialized(&port->port)) {
    3086 + result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
    3087 + if (result) {
    3088 + dev_err(&port->dev, "submit interrupt urb failed: %d\n",
    3089 + result);
    3090 + return result;
    3091 + }
    3092 + }
    3093 +
    3094 + return usb_serial_generic_resume(serial);
    3095 +}
    3096 +
    3097 static struct usb_serial_driver f81232_device = {
    3098 .driver = {
    3099 .owner = THIS_MODULE,
    3100 @@ -675,6 +712,8 @@ static struct usb_serial_driver f81232_device = {
    3101 .read_int_callback = f81232_read_int_callback,
    3102 .port_probe = f81232_port_probe,
    3103 .port_remove = f81232_port_remove,
    3104 + .suspend = f81232_suspend,
    3105 + .resume = f81232_resume,
    3106 };
    3107
    3108 static struct usb_serial_driver * const serial_drivers[] = {
    3109 diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
    3110 index 101ebac43c87..59d82b45e758 100644
    3111 --- a/drivers/usb/storage/scsiglue.c
    3112 +++ b/drivers/usb/storage/scsiglue.c
    3113 @@ -65,6 +65,7 @@ static const char* host_info(struct Scsi_Host *host)
    3114 static int slave_alloc (struct scsi_device *sdev)
    3115 {
    3116 struct us_data *us = host_to_us(sdev->host);
    3117 + int maxp;
    3118
    3119 /*
    3120 * Set the INQUIRY transfer length to 36. We don't use any of
    3121 @@ -74,20 +75,17 @@ static int slave_alloc (struct scsi_device *sdev)
    3122 sdev->inquiry_len = 36;
    3123
    3124 /*
    3125 - * USB has unusual DMA-alignment requirements: Although the
    3126 - * starting address of each scatter-gather element doesn't matter,
    3127 - * the length of each element except the last must be divisible
    3128 - * by the Bulk maxpacket value. There's currently no way to
    3129 - * express this by block-layer constraints, so we'll cop out
    3130 - * and simply require addresses to be aligned at 512-byte
    3131 - * boundaries. This is okay since most block I/O involves
    3132 - * hardware sectors that are multiples of 512 bytes in length,
    3133 - * and since host controllers up through USB 2.0 have maxpacket
    3134 - * values no larger than 512.
    3135 - *
    3136 - * But it doesn't suffice for Wireless USB, where Bulk maxpacket
    3137 - * values can be as large as 2048. To make that work properly
    3138 - * will require changes to the block layer.
    3139 + * USB has unusual scatter-gather requirements: the length of each
    3140 + * scatterlist element except the last must be divisible by the
    3141 + * Bulk maxpacket value. Fortunately this value is always a
    3142 + * power of 2. Inform the block layer about this requirement.
    3143 + */
    3144 + maxp = usb_maxpacket(us->pusb_dev, us->recv_bulk_pipe, 0);
    3145 + blk_queue_virt_boundary(sdev->request_queue, maxp - 1);
    3146 +
    3147 + /*
    3148 + * Some host controllers may have alignment requirements.
    3149 + * We'll play it safe by requiring 512-byte alignment always.
    3150 */
    3151 blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
    3152
    3153 diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
    3154 index 1f7b401c4d04..5b1d09367475 100644
    3155 --- a/drivers/usb/storage/uas.c
    3156 +++ b/drivers/usb/storage/uas.c
    3157 @@ -796,24 +796,33 @@ static int uas_slave_alloc(struct scsi_device *sdev)
    3158 {
    3159 struct uas_dev_info *devinfo =
    3160 (struct uas_dev_info *)sdev->host->hostdata;
    3161 + int maxp;
    3162
    3163 sdev->hostdata = devinfo;
    3164
    3165 /*
    3166 - * USB has unusual DMA-alignment requirements: Although the
    3167 - * starting address of each scatter-gather element doesn't matter,
    3168 - * the length of each element except the last must be divisible
    3169 - * by the Bulk maxpacket value. There's currently no way to
    3170 - * express this by block-layer constraints, so we'll cop out
    3171 - * and simply require addresses to be aligned at 512-byte
    3172 - * boundaries. This is okay since most block I/O involves
    3173 - * hardware sectors that are multiples of 512 bytes in length,
    3174 - * and since host controllers up through USB 2.0 have maxpacket
    3175 - * values no larger than 512.
    3176 + * We have two requirements here. We must satisfy the requirements
    3177 + * of the physical HC and the demands of the protocol, as we
    3178 + * definitely want no additional memory allocation in this path
    3179 + * ruling out using bounce buffers.
    3180 *
    3181 - * But it doesn't suffice for Wireless USB, where Bulk maxpacket
    3182 - * values can be as large as 2048. To make that work properly
    3183 - * will require changes to the block layer.
    3184 + * For a transmission on USB to continue we must never send
    3185 + * a package that is smaller than maxpacket. Hence the length of each
    3186 + * scatterlist element except the last must be divisible by the
    3187 + * Bulk maxpacket value.
    3188 + * If the HC does not ensure that through SG,
    3189 + * the upper layer must do that. We must assume nothing
    3190 + * about the capabilities off the HC, so we use the most
    3191 + * pessimistic requirement.
    3192 + */
    3193 +
    3194 + maxp = usb_maxpacket(devinfo->udev, devinfo->data_in_pipe, 0);
    3195 + blk_queue_virt_boundary(sdev->request_queue, maxp - 1);
    3196 +
    3197 + /*
    3198 + * The protocol has no requirements on alignment in the strict sense.
    3199 + * Controllers may or may not have alignment restrictions.
    3200 + * As this is not exported, we use an extremely conservative guess.
    3201 */
    3202 blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
    3203
    3204 diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
    3205 index 465a6f5142cc..45b04bc91f24 100644
    3206 --- a/drivers/virtio/virtio_pci_common.c
    3207 +++ b/drivers/virtio/virtio_pci_common.c
    3208 @@ -255,9 +255,11 @@ void vp_del_vqs(struct virtio_device *vdev)
    3209 for (i = 0; i < vp_dev->msix_used_vectors; ++i)
    3210 free_irq(pci_irq_vector(vp_dev->pci_dev, i), vp_dev);
    3211
    3212 - for (i = 0; i < vp_dev->msix_vectors; i++)
    3213 - if (vp_dev->msix_affinity_masks[i])
    3214 - free_cpumask_var(vp_dev->msix_affinity_masks[i]);
    3215 + if (vp_dev->msix_affinity_masks) {
    3216 + for (i = 0; i < vp_dev->msix_vectors; i++)
    3217 + if (vp_dev->msix_affinity_masks[i])
    3218 + free_cpumask_var(vp_dev->msix_affinity_masks[i]);
    3219 + }
    3220
    3221 if (vp_dev->msix_enabled) {
    3222 /* Disable the vector used for configuration */
    3223 diff --git a/include/linux/kernel.h b/include/linux/kernel.h
    3224 index d6aac75b51ba..3d83ebb302cf 100644
    3225 --- a/include/linux/kernel.h
    3226 +++ b/include/linux/kernel.h
    3227 @@ -73,8 +73,8 @@
    3228
    3229 #define u64_to_user_ptr(x) ( \
    3230 { \
    3231 - typecheck(u64, x); \
    3232 - (void __user *)(uintptr_t)x; \
    3233 + typecheck(u64, (x)); \
    3234 + (void __user *)(uintptr_t)(x); \
    3235 } \
    3236 )
    3237
    3238 diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
    3239 index 1dfb75057580..cc2d0c3b475b 100644
    3240 --- a/include/net/bluetooth/hci_core.h
    3241 +++ b/include/net/bluetooth/hci_core.h
    3242 @@ -182,6 +182,9 @@ struct adv_info {
    3243
    3244 #define HCI_MAX_SHORT_NAME_LENGTH 10
    3245
    3246 +/* Min encryption key size to match with SMP */
    3247 +#define HCI_MIN_ENC_KEY_SIZE 7
    3248 +
    3249 /* Default LE RPA expiry time, 15 minutes */
    3250 #define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
    3251
    3252 diff --git a/kernel/events/core.c b/kernel/events/core.c
    3253 index 87bd96399d1c..171b83ebed4a 100644
    3254 --- a/kernel/events/core.c
    3255 +++ b/kernel/events/core.c
    3256 @@ -2007,8 +2007,8 @@ event_sched_out(struct perf_event *event,
    3257 event->pmu->del(event, 0);
    3258 event->oncpu = -1;
    3259
    3260 - if (event->pending_disable) {
    3261 - event->pending_disable = 0;
    3262 + if (READ_ONCE(event->pending_disable) >= 0) {
    3263 + WRITE_ONCE(event->pending_disable, -1);
    3264 state = PERF_EVENT_STATE_OFF;
    3265 }
    3266 perf_event_set_state(event, state);
    3267 @@ -2196,7 +2196,8 @@ EXPORT_SYMBOL_GPL(perf_event_disable);
    3268
    3269 void perf_event_disable_inatomic(struct perf_event *event)
    3270 {
    3271 - event->pending_disable = 1;
    3272 + WRITE_ONCE(event->pending_disable, smp_processor_id());
    3273 + /* can fail, see perf_pending_event_disable() */
    3274 irq_work_queue(&event->pending);
    3275 }
    3276
    3277 @@ -5803,10 +5804,45 @@ void perf_event_wakeup(struct perf_event *event)
    3278 }
    3279 }
    3280
    3281 +static void perf_pending_event_disable(struct perf_event *event)
    3282 +{
    3283 + int cpu = READ_ONCE(event->pending_disable);
    3284 +
    3285 + if (cpu < 0)
    3286 + return;
    3287 +
    3288 + if (cpu == smp_processor_id()) {
    3289 + WRITE_ONCE(event->pending_disable, -1);
    3290 + perf_event_disable_local(event);
    3291 + return;
    3292 + }
    3293 +
    3294 + /*
    3295 + * CPU-A CPU-B
    3296 + *
    3297 + * perf_event_disable_inatomic()
    3298 + * @pending_disable = CPU-A;
    3299 + * irq_work_queue();
    3300 + *
    3301 + * sched-out
    3302 + * @pending_disable = -1;
    3303 + *
    3304 + * sched-in
    3305 + * perf_event_disable_inatomic()
    3306 + * @pending_disable = CPU-B;
    3307 + * irq_work_queue(); // FAILS
    3308 + *
    3309 + * irq_work_run()
    3310 + * perf_pending_event()
    3311 + *
    3312 + * But the event runs on CPU-B and wants disabling there.
    3313 + */
    3314 + irq_work_queue_on(&event->pending, cpu);
    3315 +}
    3316 +
    3317 static void perf_pending_event(struct irq_work *entry)
    3318 {
    3319 - struct perf_event *event = container_of(entry,
    3320 - struct perf_event, pending);
    3321 + struct perf_event *event = container_of(entry, struct perf_event, pending);
    3322 int rctx;
    3323
    3324 rctx = perf_swevent_get_recursion_context();
    3325 @@ -5815,10 +5851,7 @@ static void perf_pending_event(struct irq_work *entry)
    3326 * and we won't recurse 'further'.
    3327 */
    3328
    3329 - if (event->pending_disable) {
    3330 - event->pending_disable = 0;
    3331 - perf_event_disable_local(event);
    3332 - }
    3333 + perf_pending_event_disable(event);
    3334
    3335 if (event->pending_wakeup) {
    3336 event->pending_wakeup = 0;
    3337 @@ -9969,6 +10002,7 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
    3338
    3339
    3340 init_waitqueue_head(&event->waitq);
    3341 + event->pending_disable = -1;
    3342 init_irq_work(&event->pending, perf_pending_event);
    3343
    3344 mutex_init(&event->mmap_mutex);
    3345 diff --git a/kernel/events/ring_buffer.c b/kernel/events/ring_buffer.c
    3346 index 474b2ccdbe69..99c7f199f2d4 100644
    3347 --- a/kernel/events/ring_buffer.c
    3348 +++ b/kernel/events/ring_buffer.c
    3349 @@ -393,7 +393,7 @@ void *perf_aux_output_begin(struct perf_output_handle *handle,
    3350 * store that will be enabled on successful return
    3351 */
    3352 if (!handle->size) { /* A, matches D */
    3353 - event->pending_disable = 1;
    3354 + event->pending_disable = smp_processor_id();
    3355 perf_output_wakeup(handle);
    3356 local_set(&rb->aux_nest, 0);
    3357 goto err_put;
    3358 @@ -471,7 +471,7 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size)
    3359
    3360 if (wakeup) {
    3361 if (handle->aux_flags & PERF_AUX_FLAG_TRUNCATED)
    3362 - handle->event->pending_disable = 1;
    3363 + handle->event->pending_disable = smp_processor_id();
    3364 perf_output_wakeup(handle);
    3365 }
    3366
    3367 diff --git a/kernel/futex.c b/kernel/futex.c
    3368 index 5a26d843a015..afdc5eadce6e 100644
    3369 --- a/kernel/futex.c
    3370 +++ b/kernel/futex.c
    3371 @@ -1306,13 +1306,15 @@ static int lookup_pi_state(u32 __user *uaddr, u32 uval,
    3372
    3373 static int lock_pi_update_atomic(u32 __user *uaddr, u32 uval, u32 newval)
    3374 {
    3375 + int err;
    3376 u32 uninitialized_var(curval);
    3377
    3378 if (unlikely(should_fail_futex(true)))
    3379 return -EFAULT;
    3380
    3381 - if (unlikely(cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)))
    3382 - return -EFAULT;
    3383 + err = cmpxchg_futex_value_locked(&curval, uaddr, uval, newval);
    3384 + if (unlikely(err))
    3385 + return err;
    3386
    3387 /* If user space value changed, let the caller retry */
    3388 return curval != uval ? -EAGAIN : 0;
    3389 @@ -1498,10 +1500,8 @@ static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_pi_state *pi_
    3390 if (unlikely(should_fail_futex(true)))
    3391 ret = -EFAULT;
    3392
    3393 - if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval)) {
    3394 - ret = -EFAULT;
    3395 -
    3396 - } else if (curval != uval) {
    3397 + ret = cmpxchg_futex_value_locked(&curval, uaddr, uval, newval);
    3398 + if (!ret && (curval != uval)) {
    3399 /*
    3400 * If a unconditional UNLOCK_PI operation (user space did not
    3401 * try the TID->0 transition) raced with a waiter setting the
    3402 @@ -1696,32 +1696,32 @@ retry_private:
    3403 double_lock_hb(hb1, hb2);
    3404 op_ret = futex_atomic_op_inuser(op, uaddr2);
    3405 if (unlikely(op_ret < 0)) {
    3406 -
    3407 double_unlock_hb(hb1, hb2);
    3408
    3409 -#ifndef CONFIG_MMU
    3410 - /*
    3411 - * we don't get EFAULT from MMU faults if we don't have an MMU,
    3412 - * but we might get them from range checking
    3413 - */
    3414 - ret = op_ret;
    3415 - goto out_put_keys;
    3416 -#endif
    3417 -
    3418 - if (unlikely(op_ret != -EFAULT)) {
    3419 + if (!IS_ENABLED(CONFIG_MMU) ||
    3420 + unlikely(op_ret != -EFAULT && op_ret != -EAGAIN)) {
    3421 + /*
    3422 + * we don't get EFAULT from MMU faults if we don't have
    3423 + * an MMU, but we might get them from range checking
    3424 + */
    3425 ret = op_ret;
    3426 goto out_put_keys;
    3427 }
    3428
    3429 - ret = fault_in_user_writeable(uaddr2);
    3430 - if (ret)
    3431 - goto out_put_keys;
    3432 + if (op_ret == -EFAULT) {
    3433 + ret = fault_in_user_writeable(uaddr2);
    3434 + if (ret)
    3435 + goto out_put_keys;
    3436 + }
    3437
    3438 - if (!(flags & FLAGS_SHARED))
    3439 + if (!(flags & FLAGS_SHARED)) {
    3440 + cond_resched();
    3441 goto retry_private;
    3442 + }
    3443
    3444 put_futex_key(&key2);
    3445 put_futex_key(&key1);
    3446 + cond_resched();
    3447 goto retry;
    3448 }
    3449
    3450 @@ -2346,7 +2346,7 @@ static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
    3451 u32 uval, uninitialized_var(curval), newval;
    3452 struct task_struct *oldowner, *newowner;
    3453 u32 newtid;
    3454 - int ret;
    3455 + int ret, err = 0;
    3456
    3457 lockdep_assert_held(q->lock_ptr);
    3458
    3459 @@ -2417,14 +2417,17 @@ retry:
    3460 if (!pi_state->owner)
    3461 newtid |= FUTEX_OWNER_DIED;
    3462
    3463 - if (get_futex_value_locked(&uval, uaddr))
    3464 - goto handle_fault;
    3465 + err = get_futex_value_locked(&uval, uaddr);
    3466 + if (err)
    3467 + goto handle_err;
    3468
    3469 for (;;) {
    3470 newval = (uval & FUTEX_OWNER_DIED) | newtid;
    3471
    3472 - if (cmpxchg_futex_value_locked(&curval, uaddr, uval, newval))
    3473 - goto handle_fault;
    3474 + err = cmpxchg_futex_value_locked(&curval, uaddr, uval, newval);
    3475 + if (err)
    3476 + goto handle_err;
    3477 +
    3478 if (curval == uval)
    3479 break;
    3480 uval = curval;
    3481 @@ -2452,23 +2455,37 @@ retry:
    3482 return 0;
    3483
    3484 /*
    3485 - * To handle the page fault we need to drop the locks here. That gives
    3486 - * the other task (either the highest priority waiter itself or the
    3487 - * task which stole the rtmutex) the chance to try the fixup of the
    3488 - * pi_state. So once we are back from handling the fault we need to
    3489 - * check the pi_state after reacquiring the locks and before trying to
    3490 - * do another fixup. When the fixup has been done already we simply
    3491 - * return.
    3492 + * In order to reschedule or handle a page fault, we need to drop the
    3493 + * locks here. In the case of a fault, this gives the other task
    3494 + * (either the highest priority waiter itself or the task which stole
    3495 + * the rtmutex) the chance to try the fixup of the pi_state. So once we
    3496 + * are back from handling the fault we need to check the pi_state after
    3497 + * reacquiring the locks and before trying to do another fixup. When
    3498 + * the fixup has been done already we simply return.
    3499 *
    3500 * Note: we hold both hb->lock and pi_mutex->wait_lock. We can safely
    3501 * drop hb->lock since the caller owns the hb -> futex_q relation.
    3502 * Dropping the pi_mutex->wait_lock requires the state revalidate.
    3503 */
    3504 -handle_fault:
    3505 +handle_err:
    3506 raw_spin_unlock_irq(&pi_state->pi_mutex.wait_lock);
    3507 spin_unlock(q->lock_ptr);
    3508
    3509 - ret = fault_in_user_writeable(uaddr);
    3510 + switch (err) {
    3511 + case -EFAULT:
    3512 + ret = fault_in_user_writeable(uaddr);
    3513 + break;
    3514 +
    3515 + case -EAGAIN:
    3516 + cond_resched();
    3517 + ret = 0;
    3518 + break;
    3519 +
    3520 + default:
    3521 + WARN_ON_ONCE(1);
    3522 + ret = err;
    3523 + break;
    3524 + }
    3525
    3526 spin_lock(q->lock_ptr);
    3527 raw_spin_lock_irq(&pi_state->pi_mutex.wait_lock);
    3528 @@ -3037,10 +3054,8 @@ retry:
    3529 * A unconditional UNLOCK_PI op raced against a waiter
    3530 * setting the FUTEX_WAITERS bit. Try again.
    3531 */
    3532 - if (ret == -EAGAIN) {
    3533 - put_futex_key(&key);
    3534 - goto retry;
    3535 - }
    3536 + if (ret == -EAGAIN)
    3537 + goto pi_retry;
    3538 /*
    3539 * wake_futex_pi has detected invalid state. Tell user
    3540 * space.
    3541 @@ -3055,9 +3070,19 @@ retry:
    3542 * preserve the WAITERS bit not the OWNER_DIED one. We are the
    3543 * owner.
    3544 */
    3545 - if (cmpxchg_futex_value_locked(&curval, uaddr, uval, 0)) {
    3546 + if ((ret = cmpxchg_futex_value_locked(&curval, uaddr, uval, 0))) {
    3547 spin_unlock(&hb->lock);
    3548 - goto pi_faulted;
    3549 + switch (ret) {
    3550 + case -EFAULT:
    3551 + goto pi_faulted;
    3552 +
    3553 + case -EAGAIN:
    3554 + goto pi_retry;
    3555 +
    3556 + default:
    3557 + WARN_ON_ONCE(1);
    3558 + goto out_putkey;
    3559 + }
    3560 }
    3561
    3562 /*
    3563 @@ -3071,6 +3096,11 @@ out_putkey:
    3564 put_futex_key(&key);
    3565 return ret;
    3566
    3567 +pi_retry:
    3568 + put_futex_key(&key);
    3569 + cond_resched();
    3570 + goto retry;
    3571 +
    3572 pi_faulted:
    3573 put_futex_key(&key);
    3574
    3575 @@ -3431,6 +3461,7 @@ err_unlock:
    3576 int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
    3577 {
    3578 u32 uval, uninitialized_var(nval), mval;
    3579 + int err;
    3580
    3581 /* Futex address must be 32bit aligned */
    3582 if ((((unsigned long)uaddr) % sizeof(*uaddr)) != 0)
    3583 @@ -3440,42 +3471,57 @@ retry:
    3584 if (get_user(uval, uaddr))
    3585 return -1;
    3586
    3587 - if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
    3588 - /*
    3589 - * Ok, this dying thread is truly holding a futex
    3590 - * of interest. Set the OWNER_DIED bit atomically
    3591 - * via cmpxchg, and if the value had FUTEX_WAITERS
    3592 - * set, wake up a waiter (if any). (We have to do a
    3593 - * futex_wake() even if OWNER_DIED is already set -
    3594 - * to handle the rare but possible case of recursive
    3595 - * thread-death.) The rest of the cleanup is done in
    3596 - * userspace.
    3597 - */
    3598 - mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
    3599 - /*
    3600 - * We are not holding a lock here, but we want to have
    3601 - * the pagefault_disable/enable() protection because
    3602 - * we want to handle the fault gracefully. If the
    3603 - * access fails we try to fault in the futex with R/W
    3604 - * verification via get_user_pages. get_user() above
    3605 - * does not guarantee R/W access. If that fails we
    3606 - * give up and leave the futex locked.
    3607 - */
    3608 - if (cmpxchg_futex_value_locked(&nval, uaddr, uval, mval)) {
    3609 + if ((uval & FUTEX_TID_MASK) != task_pid_vnr(curr))
    3610 + return 0;
    3611 +
    3612 + /*
    3613 + * Ok, this dying thread is truly holding a futex
    3614 + * of interest. Set the OWNER_DIED bit atomically
    3615 + * via cmpxchg, and if the value had FUTEX_WAITERS
    3616 + * set, wake up a waiter (if any). (We have to do a
    3617 + * futex_wake() even if OWNER_DIED is already set -
    3618 + * to handle the rare but possible case of recursive
    3619 + * thread-death.) The rest of the cleanup is done in
    3620 + * userspace.
    3621 + */
    3622 + mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
    3623 +
    3624 + /*
    3625 + * We are not holding a lock here, but we want to have
    3626 + * the pagefault_disable/enable() protection because
    3627 + * we want to handle the fault gracefully. If the
    3628 + * access fails we try to fault in the futex with R/W
    3629 + * verification via get_user_pages. get_user() above
    3630 + * does not guarantee R/W access. If that fails we
    3631 + * give up and leave the futex locked.
    3632 + */
    3633 + if ((err = cmpxchg_futex_value_locked(&nval, uaddr, uval, mval))) {
    3634 + switch (err) {
    3635 + case -EFAULT:
    3636 if (fault_in_user_writeable(uaddr))
    3637 return -1;
    3638 goto retry;
    3639 - }
    3640 - if (nval != uval)
    3641 +
    3642 + case -EAGAIN:
    3643 + cond_resched();
    3644 goto retry;
    3645
    3646 - /*
    3647 - * Wake robust non-PI futexes here. The wakeup of
    3648 - * PI futexes happens in exit_pi_state():
    3649 - */
    3650 - if (!pi && (uval & FUTEX_WAITERS))
    3651 - futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
    3652 + default:
    3653 + WARN_ON_ONCE(1);
    3654 + return err;
    3655 + }
    3656 }
    3657 +
    3658 + if (nval != uval)
    3659 + goto retry;
    3660 +
    3661 + /*
    3662 + * Wake robust non-PI futexes here. The wakeup of
    3663 + * PI futexes happens in exit_pi_state():
    3664 + */
    3665 + if (!pi && (uval & FUTEX_WAITERS))
    3666 + futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
    3667 +
    3668 return 0;
    3669 }
    3670
    3671 diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
    3672 index 5c0ba5ca5930..cd4f9f3e8345 100644
    3673 --- a/kernel/irq/manage.c
    3674 +++ b/kernel/irq/manage.c
    3675 @@ -356,8 +356,10 @@ irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
    3676 desc->affinity_notify = notify;
    3677 raw_spin_unlock_irqrestore(&desc->lock, flags);
    3678
    3679 - if (old_notify)
    3680 + if (old_notify) {
    3681 + cancel_work_sync(&old_notify->work);
    3682 kref_put(&old_notify->kref, old_notify->release);
    3683 + }
    3684
    3685 return 0;
    3686 }
    3687 diff --git a/lib/ubsan.c b/lib/ubsan.c
    3688 index e4162f59a81c..1e9e2ab25539 100644
    3689 --- a/lib/ubsan.c
    3690 +++ b/lib/ubsan.c
    3691 @@ -86,11 +86,13 @@ static bool is_inline_int(struct type_descriptor *type)
    3692 return bits <= inline_bits;
    3693 }
    3694
    3695 -static s_max get_signed_val(struct type_descriptor *type, unsigned long val)
    3696 +static s_max get_signed_val(struct type_descriptor *type, void *val)
    3697 {
    3698 if (is_inline_int(type)) {
    3699 unsigned extra_bits = sizeof(s_max)*8 - type_bit_width(type);
    3700 - return ((s_max)val) << extra_bits >> extra_bits;
    3701 + unsigned long ulong_val = (unsigned long)val;
    3702 +
    3703 + return ((s_max)ulong_val) << extra_bits >> extra_bits;
    3704 }
    3705
    3706 if (type_bit_width(type) == 64)
    3707 @@ -99,15 +101,15 @@ static s_max get_signed_val(struct type_descriptor *type, unsigned long val)
    3708 return *(s_max *)val;
    3709 }
    3710
    3711 -static bool val_is_negative(struct type_descriptor *type, unsigned long val)
    3712 +static bool val_is_negative(struct type_descriptor *type, void *val)
    3713 {
    3714 return type_is_signed(type) && get_signed_val(type, val) < 0;
    3715 }
    3716
    3717 -static u_max get_unsigned_val(struct type_descriptor *type, unsigned long val)
    3718 +static u_max get_unsigned_val(struct type_descriptor *type, void *val)
    3719 {
    3720 if (is_inline_int(type))
    3721 - return val;
    3722 + return (unsigned long)val;
    3723
    3724 if (type_bit_width(type) == 64)
    3725 return *(u64 *)val;
    3726 @@ -116,7 +118,7 @@ static u_max get_unsigned_val(struct type_descriptor *type, unsigned long val)
    3727 }
    3728
    3729 static void val_to_string(char *str, size_t size, struct type_descriptor *type,
    3730 - unsigned long value)
    3731 + void *value)
    3732 {
    3733 if (type_is_int(type)) {
    3734 if (type_bit_width(type) == 128) {
    3735 @@ -163,8 +165,8 @@ static void ubsan_epilogue(unsigned long *flags)
    3736 current->in_ubsan--;
    3737 }
    3738
    3739 -static void handle_overflow(struct overflow_data *data, unsigned long lhs,
    3740 - unsigned long rhs, char op)
    3741 +static void handle_overflow(struct overflow_data *data, void *lhs,
    3742 + void *rhs, char op)
    3743 {
    3744
    3745 struct type_descriptor *type = data->type;
    3746 @@ -191,8 +193,7 @@ static void handle_overflow(struct overflow_data *data, unsigned long lhs,
    3747 }
    3748
    3749 void __ubsan_handle_add_overflow(struct overflow_data *data,
    3750 - unsigned long lhs,
    3751 - unsigned long rhs)
    3752 + void *lhs, void *rhs)
    3753 {
    3754
    3755 handle_overflow(data, lhs, rhs, '+');
    3756 @@ -200,23 +201,21 @@ void __ubsan_handle_add_overflow(struct overflow_data *data,
    3757 EXPORT_SYMBOL(__ubsan_handle_add_overflow);
    3758
    3759 void __ubsan_handle_sub_overflow(struct overflow_data *data,
    3760 - unsigned long lhs,
    3761 - unsigned long rhs)
    3762 + void *lhs, void *rhs)
    3763 {
    3764 handle_overflow(data, lhs, rhs, '-');
    3765 }
    3766 EXPORT_SYMBOL(__ubsan_handle_sub_overflow);
    3767
    3768 void __ubsan_handle_mul_overflow(struct overflow_data *data,
    3769 - unsigned long lhs,
    3770 - unsigned long rhs)
    3771 + void *lhs, void *rhs)
    3772 {
    3773 handle_overflow(data, lhs, rhs, '*');
    3774 }
    3775 EXPORT_SYMBOL(__ubsan_handle_mul_overflow);
    3776
    3777 void __ubsan_handle_negate_overflow(struct overflow_data *data,
    3778 - unsigned long old_val)
    3779 + void *old_val)
    3780 {
    3781 unsigned long flags;
    3782 char old_val_str[VALUE_LENGTH];
    3783 @@ -237,8 +236,7 @@ EXPORT_SYMBOL(__ubsan_handle_negate_overflow);
    3784
    3785
    3786 void __ubsan_handle_divrem_overflow(struct overflow_data *data,
    3787 - unsigned long lhs,
    3788 - unsigned long rhs)
    3789 + void *lhs, void *rhs)
    3790 {
    3791 unsigned long flags;
    3792 char rhs_val_str[VALUE_LENGTH];
    3793 @@ -323,7 +321,7 @@ static void ubsan_type_mismatch_common(struct type_mismatch_data_common *data,
    3794 }
    3795
    3796 void __ubsan_handle_type_mismatch(struct type_mismatch_data *data,
    3797 - unsigned long ptr)
    3798 + void *ptr)
    3799 {
    3800 struct type_mismatch_data_common common_data = {
    3801 .location = &data->location,
    3802 @@ -332,12 +330,12 @@ void __ubsan_handle_type_mismatch(struct type_mismatch_data *data,
    3803 .type_check_kind = data->type_check_kind
    3804 };
    3805
    3806 - ubsan_type_mismatch_common(&common_data, ptr);
    3807 + ubsan_type_mismatch_common(&common_data, (unsigned long)ptr);
    3808 }
    3809 EXPORT_SYMBOL(__ubsan_handle_type_mismatch);
    3810
    3811 void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1 *data,
    3812 - unsigned long ptr)
    3813 + void *ptr)
    3814 {
    3815
    3816 struct type_mismatch_data_common common_data = {
    3817 @@ -347,12 +345,12 @@ void __ubsan_handle_type_mismatch_v1(struct type_mismatch_data_v1 *data,
    3818 .type_check_kind = data->type_check_kind
    3819 };
    3820
    3821 - ubsan_type_mismatch_common(&common_data, ptr);
    3822 + ubsan_type_mismatch_common(&common_data, (unsigned long)ptr);
    3823 }
    3824 EXPORT_SYMBOL(__ubsan_handle_type_mismatch_v1);
    3825
    3826 void __ubsan_handle_vla_bound_not_positive(struct vla_bound_data *data,
    3827 - unsigned long bound)
    3828 + void *bound)
    3829 {
    3830 unsigned long flags;
    3831 char bound_str[VALUE_LENGTH];
    3832 @@ -369,8 +367,7 @@ void __ubsan_handle_vla_bound_not_positive(struct vla_bound_data *data,
    3833 }
    3834 EXPORT_SYMBOL(__ubsan_handle_vla_bound_not_positive);
    3835
    3836 -void __ubsan_handle_out_of_bounds(struct out_of_bounds_data *data,
    3837 - unsigned long index)
    3838 +void __ubsan_handle_out_of_bounds(struct out_of_bounds_data *data, void *index)
    3839 {
    3840 unsigned long flags;
    3841 char index_str[VALUE_LENGTH];
    3842 @@ -388,7 +385,7 @@ void __ubsan_handle_out_of_bounds(struct out_of_bounds_data *data,
    3843 EXPORT_SYMBOL(__ubsan_handle_out_of_bounds);
    3844
    3845 void __ubsan_handle_shift_out_of_bounds(struct shift_out_of_bounds_data *data,
    3846 - unsigned long lhs, unsigned long rhs)
    3847 + void *lhs, void *rhs)
    3848 {
    3849 unsigned long flags;
    3850 struct type_descriptor *rhs_type = data->rhs_type;
    3851 @@ -439,7 +436,7 @@ void __ubsan_handle_builtin_unreachable(struct unreachable_data *data)
    3852 EXPORT_SYMBOL(__ubsan_handle_builtin_unreachable);
    3853
    3854 void __ubsan_handle_load_invalid_value(struct invalid_value_data *data,
    3855 - unsigned long val)
    3856 + void *val)
    3857 {
    3858 unsigned long flags;
    3859 char val_str[VALUE_LENGTH];
    3860 diff --git a/mm/slab.c b/mm/slab.c
    3861 index b8e0ec74330f..018d32496e8d 100644
    3862 --- a/mm/slab.c
    3863 +++ b/mm/slab.c
    3864 @@ -4305,7 +4305,8 @@ static void show_symbol(struct seq_file *m, unsigned long address)
    3865
    3866 static int leaks_show(struct seq_file *m, void *p)
    3867 {
    3868 - struct kmem_cache *cachep = list_entry(p, struct kmem_cache, list);
    3869 + struct kmem_cache *cachep = list_entry(p, struct kmem_cache,
    3870 + root_caches_node);
    3871 struct page *page;
    3872 struct kmem_cache_node *n;
    3873 const char *name;
    3874 diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
    3875 index bd4978ce8c45..3cf0764d5793 100644
    3876 --- a/net/bluetooth/hci_conn.c
    3877 +++ b/net/bluetooth/hci_conn.c
    3878 @@ -1276,6 +1276,14 @@ int hci_conn_check_link_mode(struct hci_conn *conn)
    3879 !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
    3880 return 0;
    3881
    3882 + /* The minimum encryption key size needs to be enforced by the
    3883 + * host stack before establishing any L2CAP connections. The
    3884 + * specification in theory allows a minimum of 1, but to align
    3885 + * BR/EDR and LE transports, a minimum of 7 is chosen.
    3886 + */
    3887 + if (conn->enc_key_size < HCI_MIN_ENC_KEY_SIZE)
    3888 + return 0;
    3889 +
    3890 return 1;
    3891 }
    3892
    3893 diff --git a/net/bluetooth/hidp/sock.c b/net/bluetooth/hidp/sock.c
    3894 index 1eaac01f85de..7f36fa73ffee 100644
    3895 --- a/net/bluetooth/hidp/sock.c
    3896 +++ b/net/bluetooth/hidp/sock.c
    3897 @@ -76,6 +76,7 @@ static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long
    3898 sockfd_put(csock);
    3899 return err;
    3900 }
    3901 + ca.name[sizeof(ca.name)-1] = 0;
    3902
    3903 err = hidp_connection_add(&ca, csock, isock);
    3904 if (!err && copy_to_user(argp, &ca, sizeof(ca)))
    3905 diff --git a/sound/soc/codecs/cs35l35.c b/sound/soc/codecs/cs35l35.c
    3906 index bd6226bde45f..17e0101081ef 100644
    3907 --- a/sound/soc/codecs/cs35l35.c
    3908 +++ b/sound/soc/codecs/cs35l35.c
    3909 @@ -1634,6 +1634,16 @@ err:
    3910 return ret;
    3911 }
    3912
    3913 +static int cs35l35_i2c_remove(struct i2c_client *i2c_client)
    3914 +{
    3915 + struct cs35l35_private *cs35l35 = i2c_get_clientdata(i2c_client);
    3916 +
    3917 + regulator_bulk_disable(cs35l35->num_supplies, cs35l35->supplies);
    3918 + gpiod_set_value_cansleep(cs35l35->reset_gpio, 0);
    3919 +
    3920 + return 0;
    3921 +}
    3922 +
    3923 static const struct of_device_id cs35l35_of_match[] = {
    3924 {.compatible = "cirrus,cs35l35"},
    3925 {},
    3926 @@ -1654,6 +1664,7 @@ static struct i2c_driver cs35l35_i2c_driver = {
    3927 },
    3928 .id_table = cs35l35_id,
    3929 .probe = cs35l35_i2c_probe,
    3930 + .remove = cs35l35_i2c_remove,
    3931 };
    3932
    3933 module_i2c_driver(cs35l35_i2c_driver);
    3934 diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c
    3935 index 3c266eeb89bf..007ce9f48e44 100644
    3936 --- a/sound/soc/codecs/cs4270.c
    3937 +++ b/sound/soc/codecs/cs4270.c
    3938 @@ -642,6 +642,7 @@ static const struct regmap_config cs4270_regmap = {
    3939 .reg_defaults = cs4270_reg_defaults,
    3940 .num_reg_defaults = ARRAY_SIZE(cs4270_reg_defaults),
    3941 .cache_type = REGCACHE_RBTREE,
    3942 + .write_flag_mask = CS4270_I2C_INCR,
    3943
    3944 .readable_reg = cs4270_reg_is_readable,
    3945 .volatile_reg = cs4270_reg_is_volatile,
    3946 diff --git a/sound/soc/codecs/hdmi-codec.c b/sound/soc/codecs/hdmi-codec.c
    3947 index e5b6769b9797..d5f73c837281 100644
    3948 --- a/sound/soc/codecs/hdmi-codec.c
    3949 +++ b/sound/soc/codecs/hdmi-codec.c
    3950 @@ -529,73 +529,71 @@ static int hdmi_codec_set_fmt(struct snd_soc_dai *dai,
    3951 {
    3952 struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
    3953 struct hdmi_codec_daifmt cf = { 0 };
    3954 - int ret = 0;
    3955
    3956 dev_dbg(dai->dev, "%s()\n", __func__);
    3957
    3958 - if (dai->id == DAI_ID_SPDIF) {
    3959 - cf.fmt = HDMI_SPDIF;
    3960 - } else {
    3961 - switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
    3962 - case SND_SOC_DAIFMT_CBM_CFM:
    3963 - cf.bit_clk_master = 1;
    3964 - cf.frame_clk_master = 1;
    3965 - break;
    3966 - case SND_SOC_DAIFMT_CBS_CFM:
    3967 - cf.frame_clk_master = 1;
    3968 - break;
    3969 - case SND_SOC_DAIFMT_CBM_CFS:
    3970 - cf.bit_clk_master = 1;
    3971 - break;
    3972 - case SND_SOC_DAIFMT_CBS_CFS:
    3973 - break;
    3974 - default:
    3975 - return -EINVAL;
    3976 - }
    3977 + if (dai->id == DAI_ID_SPDIF)
    3978 + return 0;
    3979 +
    3980 + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
    3981 + case SND_SOC_DAIFMT_CBM_CFM:
    3982 + cf.bit_clk_master = 1;
    3983 + cf.frame_clk_master = 1;
    3984 + break;
    3985 + case SND_SOC_DAIFMT_CBS_CFM:
    3986 + cf.frame_clk_master = 1;
    3987 + break;
    3988 + case SND_SOC_DAIFMT_CBM_CFS:
    3989 + cf.bit_clk_master = 1;
    3990 + break;
    3991 + case SND_SOC_DAIFMT_CBS_CFS:
    3992 + break;
    3993 + default:
    3994 + return -EINVAL;
    3995 + }
    3996
    3997 - switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
    3998 - case SND_SOC_DAIFMT_NB_NF:
    3999 - break;
    4000 - case SND_SOC_DAIFMT_NB_IF:
    4001 - cf.frame_clk_inv = 1;
    4002 - break;
    4003 - case SND_SOC_DAIFMT_IB_NF:
    4004 - cf.bit_clk_inv = 1;
    4005 - break;
    4006 - case SND_SOC_DAIFMT_IB_IF:
    4007 - cf.frame_clk_inv = 1;
    4008 - cf.bit_clk_inv = 1;
    4009 - break;
    4010 - }
    4011 + switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
    4012 + case SND_SOC_DAIFMT_NB_NF:
    4013 + break;
    4014 + case SND_SOC_DAIFMT_NB_IF:
    4015 + cf.frame_clk_inv = 1;
    4016 + break;
    4017 + case SND_SOC_DAIFMT_IB_NF:
    4018 + cf.bit_clk_inv = 1;
    4019 + break;
    4020 + case SND_SOC_DAIFMT_IB_IF:
    4021 + cf.frame_clk_inv = 1;
    4022 + cf.bit_clk_inv = 1;
    4023 + break;
    4024 + }
    4025
    4026 - switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
    4027 - case SND_SOC_DAIFMT_I2S:
    4028 - cf.fmt = HDMI_I2S;
    4029 - break;
    4030 - case SND_SOC_DAIFMT_DSP_A:
    4031 - cf.fmt = HDMI_DSP_A;
    4032 - break;
    4033 - case SND_SOC_DAIFMT_DSP_B:
    4034 - cf.fmt = HDMI_DSP_B;
    4035 - break;
    4036 - case SND_SOC_DAIFMT_RIGHT_J:
    4037 - cf.fmt = HDMI_RIGHT_J;
    4038 - break;
    4039 - case SND_SOC_DAIFMT_LEFT_J:
    4040 - cf.fmt = HDMI_LEFT_J;
    4041 - break;
    4042 - case SND_SOC_DAIFMT_AC97:
    4043 - cf.fmt = HDMI_AC97;
    4044 - break;
    4045 - default:
    4046 - dev_err(dai->dev, "Invalid DAI interface format\n");
    4047 - return -EINVAL;
    4048 - }
    4049 + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
    4050 + case SND_SOC_DAIFMT_I2S:
    4051 + cf.fmt = HDMI_I2S;
    4052 + break;
    4053 + case SND_SOC_DAIFMT_DSP_A:
    4054 + cf.fmt = HDMI_DSP_A;
    4055 + break;
    4056 + case SND_SOC_DAIFMT_DSP_B:
    4057 + cf.fmt = HDMI_DSP_B;
    4058 + break;
    4059 + case SND_SOC_DAIFMT_RIGHT_J:
    4060 + cf.fmt = HDMI_RIGHT_J;
    4061 + break;
    4062 + case SND_SOC_DAIFMT_LEFT_J:
    4063 + cf.fmt = HDMI_LEFT_J;
    4064 + break;
    4065 + case SND_SOC_DAIFMT_AC97:
    4066 + cf.fmt = HDMI_AC97;
    4067 + break;
    4068 + default:
    4069 + dev_err(dai->dev, "Invalid DAI interface format\n");
    4070 + return -EINVAL;
    4071 }
    4072
    4073 hcp->daifmt[dai->id] = cf;
    4074
    4075 - return ret;
    4076 + return 0;
    4077 }
    4078
    4079 static int hdmi_codec_digital_mute(struct snd_soc_dai *dai, int mute)
    4080 @@ -792,8 +790,10 @@ static int hdmi_codec_probe(struct platform_device *pdev)
    4081 i++;
    4082 }
    4083
    4084 - if (hcd->spdif)
    4085 + if (hcd->spdif) {
    4086 hcp->daidrv[i] = hdmi_spdif_dai;
    4087 + hcp->daifmt[DAI_ID_SPDIF].fmt = HDMI_SPDIF;
    4088 + }
    4089
    4090 dev_set_drvdata(dev, hcp);
    4091
    4092 diff --git a/sound/soc/codecs/nau8810.c b/sound/soc/codecs/nau8810.c
    4093 index bfd74b86c9d2..645aa0794123 100644
    4094 --- a/sound/soc/codecs/nau8810.c
    4095 +++ b/sound/soc/codecs/nau8810.c
    4096 @@ -411,9 +411,9 @@ static const struct snd_soc_dapm_widget nau8810_dapm_widgets[] = {
    4097 SND_SOC_DAPM_MIXER("Mono Mixer", NAU8810_REG_POWER3,
    4098 NAU8810_MOUTMX_EN_SFT, 0, &nau8810_mono_mixer_controls[0],
    4099 ARRAY_SIZE(nau8810_mono_mixer_controls)),
    4100 - SND_SOC_DAPM_DAC("DAC", "HiFi Playback", NAU8810_REG_POWER3,
    4101 + SND_SOC_DAPM_DAC("DAC", "Playback", NAU8810_REG_POWER3,
    4102 NAU8810_DAC_EN_SFT, 0),
    4103 - SND_SOC_DAPM_ADC("ADC", "HiFi Capture", NAU8810_REG_POWER2,
    4104 + SND_SOC_DAPM_ADC("ADC", "Capture", NAU8810_REG_POWER2,
    4105 NAU8810_ADC_EN_SFT, 0),
    4106 SND_SOC_DAPM_PGA("SpkN Out", NAU8810_REG_POWER3,
    4107 NAU8810_NSPK_EN_SFT, 0, NULL, 0),
    4108 diff --git a/sound/soc/codecs/nau8824.c b/sound/soc/codecs/nau8824.c
    4109 index 468d5143e2c4..663a208c2f78 100644
    4110 --- a/sound/soc/codecs/nau8824.c
    4111 +++ b/sound/soc/codecs/nau8824.c
    4112 @@ -681,8 +681,8 @@ static const struct snd_soc_dapm_widget nau8824_dapm_widgets[] = {
    4113 SND_SOC_DAPM_ADC("ADCR", NULL, NAU8824_REG_ANALOG_ADC_2,
    4114 NAU8824_ADCR_EN_SFT, 0),
    4115
    4116 - SND_SOC_DAPM_AIF_OUT("AIFTX", "HiFi Capture", 0, SND_SOC_NOPM, 0, 0),
    4117 - SND_SOC_DAPM_AIF_IN("AIFRX", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
    4118 + SND_SOC_DAPM_AIF_OUT("AIFTX", "Capture", 0, SND_SOC_NOPM, 0, 0),
    4119 + SND_SOC_DAPM_AIF_IN("AIFRX", "Playback", 0, SND_SOC_NOPM, 0, 0),
    4120
    4121 SND_SOC_DAPM_DAC("DACL", NULL, NAU8824_REG_RDAC,
    4122 NAU8824_DACL_EN_SFT, 0),
    4123 @@ -831,6 +831,36 @@ static void nau8824_int_status_clear_all(struct regmap *regmap)
    4124 }
    4125 }
    4126
    4127 +static void nau8824_dapm_disable_pin(struct nau8824 *nau8824, const char *pin)
    4128 +{
    4129 + struct snd_soc_dapm_context *dapm = nau8824->dapm;
    4130 + const char *prefix = dapm->component->name_prefix;
    4131 + char prefixed_pin[80];
    4132 +
    4133 + if (prefix) {
    4134 + snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s",
    4135 + prefix, pin);
    4136 + snd_soc_dapm_disable_pin(dapm, prefixed_pin);
    4137 + } else {
    4138 + snd_soc_dapm_disable_pin(dapm, pin);
    4139 + }
    4140 +}
    4141 +
    4142 +static void nau8824_dapm_enable_pin(struct nau8824 *nau8824, const char *pin)
    4143 +{
    4144 + struct snd_soc_dapm_context *dapm = nau8824->dapm;
    4145 + const char *prefix = dapm->component->name_prefix;
    4146 + char prefixed_pin[80];
    4147 +
    4148 + if (prefix) {
    4149 + snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s",
    4150 + prefix, pin);
    4151 + snd_soc_dapm_force_enable_pin(dapm, prefixed_pin);
    4152 + } else {
    4153 + snd_soc_dapm_force_enable_pin(dapm, pin);
    4154 + }
    4155 +}
    4156 +
    4157 static void nau8824_eject_jack(struct nau8824 *nau8824)
    4158 {
    4159 struct snd_soc_dapm_context *dapm = nau8824->dapm;
    4160 @@ -839,8 +869,8 @@ static void nau8824_eject_jack(struct nau8824 *nau8824)
    4161 /* Clear all interruption status */
    4162 nau8824_int_status_clear_all(regmap);
    4163
    4164 - snd_soc_dapm_disable_pin(dapm, "SAR");
    4165 - snd_soc_dapm_disable_pin(dapm, "MICBIAS");
    4166 + nau8824_dapm_disable_pin(nau8824, "SAR");
    4167 + nau8824_dapm_disable_pin(nau8824, "MICBIAS");
    4168 snd_soc_dapm_sync(dapm);
    4169
    4170 /* Enable the insertion interruption, disable the ejection
    4171 @@ -870,8 +900,8 @@ static void nau8824_jdet_work(struct work_struct *work)
    4172 struct regmap *regmap = nau8824->regmap;
    4173 int adc_value, event = 0, event_mask = 0;
    4174
    4175 - snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
    4176 - snd_soc_dapm_force_enable_pin(dapm, "SAR");
    4177 + nau8824_dapm_enable_pin(nau8824, "MICBIAS");
    4178 + nau8824_dapm_enable_pin(nau8824, "SAR");
    4179 snd_soc_dapm_sync(dapm);
    4180
    4181 msleep(100);
    4182 @@ -882,8 +912,8 @@ static void nau8824_jdet_work(struct work_struct *work)
    4183 if (adc_value < HEADSET_SARADC_THD) {
    4184 event |= SND_JACK_HEADPHONE;
    4185
    4186 - snd_soc_dapm_disable_pin(dapm, "SAR");
    4187 - snd_soc_dapm_disable_pin(dapm, "MICBIAS");
    4188 + nau8824_dapm_disable_pin(nau8824, "SAR");
    4189 + nau8824_dapm_disable_pin(nau8824, "MICBIAS");
    4190 snd_soc_dapm_sync(dapm);
    4191 } else {
    4192 event |= SND_JACK_HEADSET;
    4193 diff --git a/sound/soc/codecs/rt5682.c b/sound/soc/codecs/rt5682.c
    4194 index 79ebcc239786..6f5dac09cede 100644
    4195 --- a/sound/soc/codecs/rt5682.c
    4196 +++ b/sound/soc/codecs/rt5682.c
    4197 @@ -1196,7 +1196,7 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w,
    4198 struct snd_soc_component *component =
    4199 snd_soc_dapm_to_component(w->dapm);
    4200 struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);
    4201 - int ref, val, reg, sft, mask, idx = -EINVAL;
    4202 + int ref, val, reg, idx = -EINVAL;
    4203 static const int div_f[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48};
    4204 static const int div_o[] = {1, 2, 4, 6, 8, 12, 16, 24, 32, 48};
    4205
    4206 @@ -1210,15 +1210,10 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w,
    4207
    4208 idx = rt5682_div_sel(rt5682, ref, div_f, ARRAY_SIZE(div_f));
    4209
    4210 - if (w->shift == RT5682_PWR_ADC_S1F_BIT) {
    4211 + if (w->shift == RT5682_PWR_ADC_S1F_BIT)
    4212 reg = RT5682_PLL_TRACK_3;
    4213 - sft = RT5682_ADC_OSR_SFT;
    4214 - mask = RT5682_ADC_OSR_MASK;
    4215 - } else {
    4216 + else
    4217 reg = RT5682_PLL_TRACK_2;
    4218 - sft = RT5682_DAC_OSR_SFT;
    4219 - mask = RT5682_DAC_OSR_MASK;
    4220 - }
    4221
    4222 snd_soc_component_update_bits(component, reg,
    4223 RT5682_FILTER_CLK_DIV_MASK, idx << RT5682_FILTER_CLK_DIV_SFT);
    4224 @@ -1230,7 +1225,8 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w,
    4225 }
    4226
    4227 snd_soc_component_update_bits(component, RT5682_ADDA_CLK_1,
    4228 - mask, idx << sft);
    4229 + RT5682_ADC_OSR_MASK | RT5682_DAC_OSR_MASK,
    4230 + (idx << RT5682_ADC_OSR_SFT) | (idx << RT5682_DAC_OSR_SFT));
    4231
    4232 return 0;
    4233 }
    4234 diff --git a/sound/soc/codecs/tlv320aic32x4.c b/sound/soc/codecs/tlv320aic32x4.c
    4235 index f03195d2ab2e..45d9f4a09044 100644
    4236 --- a/sound/soc/codecs/tlv320aic32x4.c
    4237 +++ b/sound/soc/codecs/tlv320aic32x4.c
    4238 @@ -462,6 +462,8 @@ static const struct snd_soc_dapm_widget aic32x4_dapm_widgets[] = {
    4239 SND_SOC_DAPM_INPUT("IN2_R"),
    4240 SND_SOC_DAPM_INPUT("IN3_L"),
    4241 SND_SOC_DAPM_INPUT("IN3_R"),
    4242 + SND_SOC_DAPM_INPUT("CM_L"),
    4243 + SND_SOC_DAPM_INPUT("CM_R"),
    4244 };
    4245
    4246 static const struct snd_soc_dapm_route aic32x4_dapm_routes[] = {
    4247 diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
    4248 index 6a271e6e6b8f..6c0a3dad44b8 100644
    4249 --- a/sound/soc/codecs/tlv320aic3x.c
    4250 +++ b/sound/soc/codecs/tlv320aic3x.c
    4251 @@ -1599,7 +1599,6 @@ static int aic3x_probe(struct snd_soc_component *component)
    4252 struct aic3x_priv *aic3x = snd_soc_component_get_drvdata(component);
    4253 int ret, i;
    4254
    4255 - INIT_LIST_HEAD(&aic3x->list);
    4256 aic3x->component = component;
    4257
    4258 for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++) {
    4259 @@ -1682,7 +1681,6 @@ static void aic3x_remove(struct snd_soc_component *component)
    4260 struct aic3x_priv *aic3x = snd_soc_component_get_drvdata(component);
    4261 int i;
    4262
    4263 - list_del(&aic3x->list);
    4264 for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++)
    4265 regulator_unregister_notifier(aic3x->supplies[i].consumer,
    4266 &aic3x->disable_nb[i].nb);
    4267 @@ -1880,6 +1878,7 @@ static int aic3x_i2c_probe(struct i2c_client *i2c,
    4268 if (ret != 0)
    4269 goto err_gpio;
    4270
    4271 + INIT_LIST_HEAD(&aic3x->list);
    4272 list_add(&aic3x->list, &reset_list);
    4273
    4274 return 0;
    4275 @@ -1896,6 +1895,8 @@ static int aic3x_i2c_remove(struct i2c_client *client)
    4276 {
    4277 struct aic3x_priv *aic3x = i2c_get_clientdata(client);
    4278
    4279 + list_del(&aic3x->list);
    4280 +
    4281 if (gpio_is_valid(aic3x->gpio_reset) &&
    4282 !aic3x_is_shared_reset(aic3x)) {
    4283 gpio_set_value(aic3x->gpio_reset, 0);
    4284 diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c
    4285 index a651fed62a27..ee85056a8577 100644
    4286 --- a/sound/soc/codecs/wm_adsp.c
    4287 +++ b/sound/soc/codecs/wm_adsp.c
    4288 @@ -3819,11 +3819,13 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp)
    4289 struct regmap *regmap = dsp->regmap;
    4290 int ret = 0;
    4291
    4292 + mutex_lock(&dsp->pwr_lock);
    4293 +
    4294 ret = regmap_read(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL, &val);
    4295 if (ret) {
    4296 adsp_err(dsp,
    4297 "Failed to read Region Lock Ctrl register: %d\n", ret);
    4298 - return IRQ_HANDLED;
    4299 + goto error;
    4300 }
    4301
    4302 if (val & ADSP2_WDT_TIMEOUT_STS_MASK) {
    4303 @@ -3842,7 +3844,7 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp)
    4304 adsp_err(dsp,
    4305 "Failed to read Bus Err Addr register: %d\n",
    4306 ret);
    4307 - return IRQ_HANDLED;
    4308 + goto error;
    4309 }
    4310
    4311 adsp_err(dsp, "bus error address = 0x%x\n",
    4312 @@ -3855,7 +3857,7 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp)
    4313 adsp_err(dsp,
    4314 "Failed to read Pmem Xmem Err Addr register: %d\n",
    4315 ret);
    4316 - return IRQ_HANDLED;
    4317 + goto error;
    4318 }
    4319
    4320 adsp_err(dsp, "xmem error address = 0x%x\n",
    4321 @@ -3868,6 +3870,9 @@ irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp)
    4322 regmap_update_bits(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL,
    4323 ADSP2_CTRL_ERR_EINT, ADSP2_CTRL_ERR_EINT);
    4324
    4325 +error:
    4326 + mutex_unlock(&dsp->pwr_lock);
    4327 +
    4328 return IRQ_HANDLED;
    4329 }
    4330 EXPORT_SYMBOL_GPL(wm_adsp2_bus_error);
    4331 diff --git a/sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c b/sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c
    4332 index a892b37eab7c..b8a03f58ac8c 100644
    4333 --- a/sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c
    4334 +++ b/sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c
    4335 @@ -406,7 +406,7 @@ static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
    4336 };
    4337
    4338 static const unsigned int dmic_2ch[] = {
    4339 - 4,
    4340 + 2,
    4341 };
    4342
    4343 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {
    4344 diff --git a/sound/soc/intel/common/sst-firmware.c b/sound/soc/intel/common/sst-firmware.c
    4345 index 11041aedea31..6cfcc1042989 100644
    4346 --- a/sound/soc/intel/common/sst-firmware.c
    4347 +++ b/sound/soc/intel/common/sst-firmware.c
    4348 @@ -1251,11 +1251,15 @@ struct sst_dsp *sst_dsp_new(struct device *dev,
    4349 goto irq_err;
    4350
    4351 err = sst_dma_new(sst);
    4352 - if (err)
    4353 - dev_warn(dev, "sst_dma_new failed %d\n", err);
    4354 + if (err) {
    4355 + dev_err(dev, "sst_dma_new failed %d\n", err);
    4356 + goto dma_err;
    4357 + }
    4358
    4359 return sst;
    4360
    4361 +dma_err:
    4362 + free_irq(sst->irq, sst);
    4363 irq_err:
    4364 if (sst->ops->free)
    4365 sst->ops->free(sst);
    4366 diff --git a/sound/soc/intel/skylake/skl-pcm.c b/sound/soc/intel/skylake/skl-pcm.c
    4367 index 823e39103edd..6b2c8c6e7a00 100644
    4368 --- a/sound/soc/intel/skylake/skl-pcm.c
    4369 +++ b/sound/soc/intel/skylake/skl-pcm.c
    4370 @@ -180,6 +180,7 @@ int skl_pcm_link_dma_prepare(struct device *dev, struct skl_pipe_params *params)
    4371 struct hdac_stream *hstream;
    4372 struct hdac_ext_stream *stream;
    4373 struct hdac_ext_link *link;
    4374 + unsigned char stream_tag;
    4375
    4376 hstream = snd_hdac_get_stream(bus, params->stream,
    4377 params->link_dma_id + 1);
    4378 @@ -198,10 +199,13 @@ int skl_pcm_link_dma_prepare(struct device *dev, struct skl_pipe_params *params)
    4379
    4380 snd_hdac_ext_link_stream_setup(stream, format_val);
    4381
    4382 - list_for_each_entry(link, &bus->hlink_list, list) {
    4383 - if (link->index == params->link_index)
    4384 - snd_hdac_ext_link_set_stream_id(link,
    4385 - hstream->stream_tag);
    4386 + stream_tag = hstream->stream_tag;
    4387 + if (stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK) {
    4388 + list_for_each_entry(link, &bus->hlink_list, list) {
    4389 + if (link->index == params->link_index)
    4390 + snd_hdac_ext_link_set_stream_id(link,
    4391 + stream_tag);
    4392 + }
    4393 }
    4394
    4395 stream->link_prepared = 1;
    4396 @@ -640,6 +644,7 @@ static int skl_link_hw_free(struct snd_pcm_substream *substream,
    4397 struct hdac_ext_stream *link_dev =
    4398 snd_soc_dai_get_dma_data(dai, substream);
    4399 struct hdac_ext_link *link;
    4400 + unsigned char stream_tag;
    4401
    4402 dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
    4403
    4404 @@ -649,7 +654,11 @@ static int skl_link_hw_free(struct snd_pcm_substream *substream,
    4405 if (!link)
    4406 return -EINVAL;
    4407
    4408 - snd_hdac_ext_link_clear_stream_id(link, hdac_stream(link_dev)->stream_tag);
    4409 + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
    4410 + stream_tag = hdac_stream(link_dev)->stream_tag;
    4411 + snd_hdac_ext_link_clear_stream_id(link, stream_tag);
    4412 + }
    4413 +
    4414 snd_hdac_ext_stream_release(link_dev, HDAC_EXT_STREAM_TYPE_LINK);
    4415 return 0;
    4416 }
    4417 diff --git a/sound/soc/rockchip/rockchip_pdm.c b/sound/soc/rockchip/rockchip_pdm.c
    4418 index 400e29edb1c9..8a2e3bbce3a1 100644
    4419 --- a/sound/soc/rockchip/rockchip_pdm.c
    4420 +++ b/sound/soc/rockchip/rockchip_pdm.c
    4421 @@ -208,7 +208,9 @@ static int rockchip_pdm_set_fmt(struct snd_soc_dai *cpu_dai,
    4422 return -EINVAL;
    4423 }
    4424
    4425 + pm_runtime_get_sync(cpu_dai->dev);
    4426 regmap_update_bits(pdm->regmap, PDM_CLK_CTRL, mask, val);
    4427 + pm_runtime_put(cpu_dai->dev);
    4428
    4429 return 0;
    4430 }
    4431 diff --git a/sound/soc/samsung/odroid.c b/sound/soc/samsung/odroid.c
    4432 index e7b371b07230..45c6d7396785 100644
    4433 --- a/sound/soc/samsung/odroid.c
    4434 +++ b/sound/soc/samsung/odroid.c
    4435 @@ -64,11 +64,11 @@ static int odroid_card_hw_params(struct snd_pcm_substream *substream,
    4436 return ret;
    4437
    4438 /*
    4439 - * We add 1 to the rclk_freq value in order to avoid too low clock
    4440 + * We add 2 to the rclk_freq value in order to avoid too low clock
    4441 * frequency values due to the EPLL output frequency not being exact
    4442 * multiple of the audio sampling rate.
    4443 */
    4444 - rclk_freq = params_rate(params) * rfs + 1;
    4445 + rclk_freq = params_rate(params) * rfs + 2;
    4446
    4447 ret = clk_set_rate(priv->sclk_i2s, rclk_freq);
    4448 if (ret < 0)
    4449 diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
    4450 index 9b78fb3daa7b..2257b1b0151c 100644
    4451 --- a/sound/soc/soc-dapm.c
    4452 +++ b/sound/soc/soc-dapm.c
    4453 @@ -3847,6 +3847,10 @@ snd_soc_dapm_free_kcontrol(struct snd_soc_card *card,
    4454 int count;
    4455
    4456 devm_kfree(card->dev, (void *)*private_value);
    4457 +
    4458 + if (!w_param_text)
    4459 + return;
    4460 +
    4461 for (count = 0 ; count < num_params; count++)
    4462 devm_kfree(card->dev, (void *)w_param_text[count]);
    4463 devm_kfree(card->dev, w_param_text);
    4464 diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
    4465 index e8b98bfd4cf1..33060af18b5a 100644
    4466 --- a/sound/soc/soc-pcm.c
    4467 +++ b/sound/soc/soc-pcm.c
    4468 @@ -957,10 +957,13 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
    4469 codec_params = *params;
    4470
    4471 /* fixup params based on TDM slot masks */
    4472 - if (codec_dai->tx_mask)
    4473 + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
    4474 + codec_dai->tx_mask)
    4475 soc_pcm_codec_params_fixup(&codec_params,
    4476 codec_dai->tx_mask);
    4477 - if (codec_dai->rx_mask)
    4478 +
    4479 + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
    4480 + codec_dai->rx_mask)
    4481 soc_pcm_codec_params_fixup(&codec_params,
    4482 codec_dai->rx_mask);
    4483
    4484 diff --git a/sound/soc/stm/stm32_adfsdm.c b/sound/soc/stm/stm32_adfsdm.c
    4485 index 706ff005234f..24948b95eb19 100644
    4486 --- a/sound/soc/stm/stm32_adfsdm.c
    4487 +++ b/sound/soc/stm/stm32_adfsdm.c
    4488 @@ -9,6 +9,7 @@
    4489
    4490 #include <linux/clk.h>
    4491 #include <linux/module.h>
    4492 +#include <linux/mutex.h>
    4493 #include <linux/platform_device.h>
    4494 #include <linux/slab.h>
    4495
    4496 @@ -37,6 +38,8 @@ struct stm32_adfsdm_priv {
    4497 /* PCM buffer */
    4498 unsigned char *pcm_buff;
    4499 unsigned int pos;
    4500 +
    4501 + struct mutex lock; /* protect against race condition on iio state */
    4502 };
    4503
    4504 static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = {
    4505 @@ -62,10 +65,12 @@ static void stm32_adfsdm_shutdown(struct snd_pcm_substream *substream,
    4506 {
    4507 struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
    4508
    4509 + mutex_lock(&priv->lock);
    4510 if (priv->iio_active) {
    4511 iio_channel_stop_all_cb(priv->iio_cb);
    4512 priv->iio_active = false;
    4513 }
    4514 + mutex_unlock(&priv->lock);
    4515 }
    4516
    4517 static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
    4518 @@ -74,13 +79,19 @@ static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
    4519 struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
    4520 int ret;
    4521
    4522 + mutex_lock(&priv->lock);
    4523 + if (priv->iio_active) {
    4524 + iio_channel_stop_all_cb(priv->iio_cb);
    4525 + priv->iio_active = false;
    4526 + }
    4527 +
    4528 ret = iio_write_channel_attribute(priv->iio_ch,
    4529 substream->runtime->rate, 0,
    4530 IIO_CHAN_INFO_SAMP_FREQ);
    4531 if (ret < 0) {
    4532 dev_err(dai->dev, "%s: Failed to set %d sampling rate\n",
    4533 __func__, substream->runtime->rate);
    4534 - return ret;
    4535 + goto out;
    4536 }
    4537
    4538 if (!priv->iio_active) {
    4539 @@ -92,6 +103,9 @@ static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
    4540 __func__, ret);
    4541 }
    4542
    4543 +out:
    4544 + mutex_unlock(&priv->lock);
    4545 +
    4546 return ret;
    4547 }
    4548
    4549 @@ -290,6 +304,7 @@ MODULE_DEVICE_TABLE(of, stm32_adfsdm_of_match);
    4550 static int stm32_adfsdm_probe(struct platform_device *pdev)
    4551 {
    4552 struct stm32_adfsdm_priv *priv;
    4553 + struct snd_soc_component *component;
    4554 int ret;
    4555
    4556 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    4557 @@ -298,6 +313,7 @@ static int stm32_adfsdm_probe(struct platform_device *pdev)
    4558
    4559 priv->dev = &pdev->dev;
    4560 priv->dai_drv = stm32_adfsdm_dai;
    4561 + mutex_init(&priv->lock);
    4562
    4563 dev_set_drvdata(&pdev->dev, priv);
    4564
    4565 @@ -316,9 +332,15 @@ static int stm32_adfsdm_probe(struct platform_device *pdev)
    4566 if (IS_ERR(priv->iio_cb))
    4567 return PTR_ERR(priv->iio_cb);
    4568
    4569 - ret = devm_snd_soc_register_component(&pdev->dev,
    4570 - &stm32_adfsdm_soc_platform,
    4571 - NULL, 0);
    4572 + component = devm_kzalloc(&pdev->dev, sizeof(*component), GFP_KERNEL);
    4573 + if (!component)
    4574 + return -ENOMEM;
    4575 +#ifdef CONFIG_DEBUG_FS
    4576 + component->debugfs_prefix = "pcm";
    4577 +#endif
    4578 +
    4579 + ret = snd_soc_add_component(&pdev->dev, component,
    4580 + &stm32_adfsdm_soc_platform, NULL, 0);
    4581 if (ret < 0)
    4582 dev_err(&pdev->dev, "%s: Failed to register PCM platform\n",
    4583 __func__);
    4584 @@ -326,12 +348,20 @@ static int stm32_adfsdm_probe(struct platform_device *pdev)
    4585 return ret;
    4586 }
    4587
    4588 +static int stm32_adfsdm_remove(struct platform_device *pdev)
    4589 +{
    4590 + snd_soc_unregister_component(&pdev->dev);
    4591 +
    4592 + return 0;
    4593 +}
    4594 +
    4595 static struct platform_driver stm32_adfsdm_driver = {
    4596 .driver = {
    4597 .name = STM32_ADFSDM_DRV_NAME,
    4598 .of_match_table = stm32_adfsdm_of_match,
    4599 },
    4600 .probe = stm32_adfsdm_probe,
    4601 + .remove = stm32_adfsdm_remove,
    4602 };
    4603
    4604 module_platform_driver(stm32_adfsdm_driver);
    4605 diff --git a/sound/soc/stm/stm32_sai_sub.c b/sound/soc/stm/stm32_sai_sub.c
    4606 index 85c4b6d8e89d..2fb2b914e78b 100644
    4607 --- a/sound/soc/stm/stm32_sai_sub.c
    4608 +++ b/sound/soc/stm/stm32_sai_sub.c
    4609 @@ -96,7 +96,7 @@
    4610 * @slot_mask: rx or tx active slots mask. set at init or at runtime
    4611 * @data_size: PCM data width. corresponds to PCM substream width.
    4612 * @spdif_frm_cnt: S/PDIF playback frame counter
    4613 - * @snd_aes_iec958: iec958 data
    4614 + * @iec958: iec958 data
    4615 * @ctrl_lock: control lock
    4616 */
    4617 struct stm32_sai_sub_data {
    4618 @@ -498,6 +498,14 @@ static int stm32_sai_startup(struct snd_pcm_substream *substream,
    4619
    4620 sai->substream = substream;
    4621
    4622 + if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
    4623 + snd_pcm_hw_constraint_mask64(substream->runtime,
    4624 + SNDRV_PCM_HW_PARAM_FORMAT,
    4625 + SNDRV_PCM_FMTBIT_S32_LE);
    4626 + snd_pcm_hw_constraint_single(substream->runtime,
    4627 + SNDRV_PCM_HW_PARAM_CHANNELS, 2);
    4628 + }
    4629 +
    4630 ret = clk_prepare_enable(sai->sai_ck);
    4631 if (ret < 0) {
    4632 dev_err(cpu_dai->dev, "Failed to enable clock: %d\n", ret);
    4633 @@ -888,11 +896,12 @@ static int stm32_sai_pcm_new(struct snd_soc_pcm_runtime *rtd,
    4634 struct snd_soc_dai *cpu_dai)
    4635 {
    4636 struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
    4637 + struct snd_kcontrol_new knew = iec958_ctls;
    4638
    4639 if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
    4640 dev_dbg(&sai->pdev->dev, "%s: register iec controls", __func__);
    4641 - return snd_ctl_add(rtd->pcm->card,
    4642 - snd_ctl_new1(&iec958_ctls, sai));
    4643 + knew.device = rtd->pcm->device;
    4644 + return snd_ctl_add(rtd->pcm->card, snd_ctl_new1(&knew, sai));
    4645 }
    4646
    4647 return 0;
    4648 diff --git a/tools/objtool/check.c b/tools/objtool/check.c
    4649 index 550f17611bd7..ef152daccc33 100644
    4650 --- a/tools/objtool/check.c
    4651 +++ b/tools/objtool/check.c
    4652 @@ -165,6 +165,7 @@ static int __dead_end_function(struct objtool_file *file, struct symbol *func,
    4653 "fortify_panic",
    4654 "usercopy_abort",
    4655 "machine_real_restart",
    4656 + "rewind_stack_do_exit",
    4657 };
    4658
    4659 if (func->bind == STB_WEAK)