Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-4.4/0124-4.4.25-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-4.4/0124-4.4.25-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2860 - (show annotations) (download)
    Mon Mar 27 13:49:06 2017 UTC (7 years, 1 month ago) by niro
    File size: 39769 byte(s) 
    linux-4.4.25
    1 diff --git a/Makefile b/Makefile
    2 index cdbc185c3539..578a82554923 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,6 +1,6 @@
    6 VERSION = 4
    7 PATCHLEVEL = 4
    8 -SUBLEVEL = 24
    9 +SUBLEVEL = 25
    10 EXTRAVERSION =
    11 NAME = Blurry Fish Butt
    12
    13 diff --git a/arch/arm/boot/dts/armada-390.dtsi b/arch/arm/boot/dts/armada-390.dtsi
    14 index 094e39c66039..6cd18d8aaac7 100644
    15 --- a/arch/arm/boot/dts/armada-390.dtsi
    16 +++ b/arch/arm/boot/dts/armada-390.dtsi
    17 @@ -47,6 +47,8 @@
    18 #include "armada-39x.dtsi"
    19
    20 / {
    21 + compatible = "marvell,armada390";
    22 +
    23 soc {
    24 internal-regs {
    25 pinctrl@18000 {
    26 @@ -54,4 +56,5 @@
    27 reg = <0x18000 0x20>;
    28 };
    29 };
    30 + };
    31 };
    32 diff --git a/arch/arm/boot/dts/qcom-apq8064.dtsi b/arch/arm/boot/dts/qcom-apq8064.dtsi
    33 index a4c1762b53ea..e00d50ef678f 100644
    34 --- a/arch/arm/boot/dts/qcom-apq8064.dtsi
    35 +++ b/arch/arm/boot/dts/qcom-apq8064.dtsi
    36 @@ -5,6 +5,7 @@
    37 #include <dt-bindings/reset/qcom,gcc-msm8960.h>
    38 #include <dt-bindings/clock/qcom,mmcc-msm8960.h>
    39 #include <dt-bindings/soc/qcom,gsbi.h>
    40 +#include <dt-bindings/interrupt-controller/irq.h>
    41 #include <dt-bindings/interrupt-controller/arm-gic.h>
    42 / {
    43 model = "Qualcomm APQ8064";
    44 @@ -354,22 +355,50 @@
    45
    46 compatible = "qcom,pm8921-gpio";
    47 reg = <0x150>;
    48 - interrupts = <192 1>, <193 1>, <194 1>,
    49 - <195 1>, <196 1>, <197 1>,
    50 - <198 1>, <199 1>, <200 1>,
    51 - <201 1>, <202 1>, <203 1>,
    52 - <204 1>, <205 1>, <206 1>,
    53 - <207 1>, <208 1>, <209 1>,
    54 - <210 1>, <211 1>, <212 1>,
    55 - <213 1>, <214 1>, <215 1>,
    56 - <216 1>, <217 1>, <218 1>,
    57 - <219 1>, <220 1>, <221 1>,
    58 - <222 1>, <223 1>, <224 1>,
    59 - <225 1>, <226 1>, <227 1>,
    60 - <228 1>, <229 1>, <230 1>,
    61 - <231 1>, <232 1>, <233 1>,
    62 - <234 1>, <235 1>;
    63 -
    64 + interrupts = <192 IRQ_TYPE_NONE>,
    65 + <193 IRQ_TYPE_NONE>,
    66 + <194 IRQ_TYPE_NONE>,
    67 + <195 IRQ_TYPE_NONE>,
    68 + <196 IRQ_TYPE_NONE>,
    69 + <197 IRQ_TYPE_NONE>,
    70 + <198 IRQ_TYPE_NONE>,
    71 + <199 IRQ_TYPE_NONE>,
    72 + <200 IRQ_TYPE_NONE>,
    73 + <201 IRQ_TYPE_NONE>,
    74 + <202 IRQ_TYPE_NONE>,
    75 + <203 IRQ_TYPE_NONE>,
    76 + <204 IRQ_TYPE_NONE>,
    77 + <205 IRQ_TYPE_NONE>,
    78 + <206 IRQ_TYPE_NONE>,
    79 + <207 IRQ_TYPE_NONE>,
    80 + <208 IRQ_TYPE_NONE>,
    81 + <209 IRQ_TYPE_NONE>,
    82 + <210 IRQ_TYPE_NONE>,
    83 + <211 IRQ_TYPE_NONE>,
    84 + <212 IRQ_TYPE_NONE>,
    85 + <213 IRQ_TYPE_NONE>,
    86 + <214 IRQ_TYPE_NONE>,
    87 + <215 IRQ_TYPE_NONE>,
    88 + <216 IRQ_TYPE_NONE>,
    89 + <217 IRQ_TYPE_NONE>,
    90 + <218 IRQ_TYPE_NONE>,
    91 + <219 IRQ_TYPE_NONE>,
    92 + <220 IRQ_TYPE_NONE>,
    93 + <221 IRQ_TYPE_NONE>,
    94 + <222 IRQ_TYPE_NONE>,
    95 + <223 IRQ_TYPE_NONE>,
    96 + <224 IRQ_TYPE_NONE>,
    97 + <225 IRQ_TYPE_NONE>,
    98 + <226 IRQ_TYPE_NONE>,
    99 + <227 IRQ_TYPE_NONE>,
    100 + <228 IRQ_TYPE_NONE>,
    101 + <229 IRQ_TYPE_NONE>,
    102 + <230 IRQ_TYPE_NONE>,
    103 + <231 IRQ_TYPE_NONE>,
    104 + <232 IRQ_TYPE_NONE>,
    105 + <233 IRQ_TYPE_NONE>,
    106 + <234 IRQ_TYPE_NONE>,
    107 + <235 IRQ_TYPE_NONE>;
    108 gpio-controller;
    109 #gpio-cells = <2>;
    110
    111 @@ -381,9 +410,18 @@
    112 gpio-controller;
    113 #gpio-cells = <2>;
    114 interrupts =
    115 - <128 1>, <129 1>, <130 1>, <131 1>,
    116 - <132 1>, <133 1>, <134 1>, <135 1>,
    117 - <136 1>, <137 1>, <138 1>, <139 1>;
    118 + <128 IRQ_TYPE_NONE>,
    119 + <129 IRQ_TYPE_NONE>,
    120 + <130 IRQ_TYPE_NONE>,
    121 + <131 IRQ_TYPE_NONE>,
    122 + <132 IRQ_TYPE_NONE>,
    123 + <133 IRQ_TYPE_NONE>,
    124 + <134 IRQ_TYPE_NONE>,
    125 + <135 IRQ_TYPE_NONE>,
    126 + <136 IRQ_TYPE_NONE>,
    127 + <137 IRQ_TYPE_NONE>,
    128 + <138 IRQ_TYPE_NONE>,
    129 + <139 IRQ_TYPE_NONE>;
    130 };
    131
    132 rtc@11d {
    133 diff --git a/arch/mips/kvm/emulate.c b/arch/mips/kvm/emulate.c
    134 index d6476d11212e..3251b206e55a 100644
    135 --- a/arch/mips/kvm/emulate.c
    136 +++ b/arch/mips/kvm/emulate.c
    137 @@ -807,6 +807,47 @@ enum emulation_result kvm_mips_emul_tlbr(struct kvm_vcpu *vcpu)
    138 return EMULATE_FAIL;
    139 }
    140
    141 +/**
    142 + * kvm_mips_invalidate_guest_tlb() - Indicates a change in guest MMU map.
    143 + * @vcpu: VCPU with changed mappings.
    144 + * @tlb: TLB entry being removed.
    145 + *
    146 + * This is called to indicate a single change in guest MMU mappings, so that we
    147 + * can arrange TLB flushes on this and other CPUs.
    148 + */
    149 +static void kvm_mips_invalidate_guest_tlb(struct kvm_vcpu *vcpu,
    150 + struct kvm_mips_tlb *tlb)
    151 +{
    152 + int cpu, i;
    153 + bool user;
    154 +
    155 + /* No need to flush for entries which are already invalid */
    156 + if (!((tlb->tlb_lo[0] | tlb->tlb_lo[1]) & ENTRYLO_V))
    157 + return;
    158 + /* User address space doesn't need flushing for KSeg2/3 changes */
    159 + user = tlb->tlb_hi < KVM_GUEST_KSEG0;
    160 +
    161 + preempt_disable();
    162 +
    163 + /*
    164 + * Probe the shadow host TLB for the entry being overwritten, if one
    165 + * matches, invalidate it
    166 + */
    167 + kvm_mips_host_tlb_inv(vcpu, tlb->tlb_hi);
    168 +
    169 + /* Invalidate the whole ASID on other CPUs */
    170 + cpu = smp_processor_id();
    171 + for_each_possible_cpu(i) {
    172 + if (i == cpu)
    173 + continue;
    174 + if (user)
    175 + vcpu->arch.guest_user_asid[i] = 0;
    176 + vcpu->arch.guest_kernel_asid[i] = 0;
    177 + }
    178 +
    179 + preempt_enable();
    180 +}
    181 +
    182 /* Write Guest TLB Entry @ Index */
    183 enum emulation_result kvm_mips_emul_tlbwi(struct kvm_vcpu *vcpu)
    184 {
    185 @@ -826,11 +867,8 @@ enum emulation_result kvm_mips_emul_tlbwi(struct kvm_vcpu *vcpu)
    186 }
    187
    188 tlb = &vcpu->arch.guest_tlb[index];
    189 - /*
    190 - * Probe the shadow host TLB for the entry being overwritten, if one
    191 - * matches, invalidate it
    192 - */
    193 - kvm_mips_host_tlb_inv(vcpu, tlb->tlb_hi);
    194 +
    195 + kvm_mips_invalidate_guest_tlb(vcpu, tlb);
    196
    197 tlb->tlb_mask = kvm_read_c0_guest_pagemask(cop0);
    198 tlb->tlb_hi = kvm_read_c0_guest_entryhi(cop0);
    199 @@ -859,11 +897,7 @@ enum emulation_result kvm_mips_emul_tlbwr(struct kvm_vcpu *vcpu)
    200
    201 tlb = &vcpu->arch.guest_tlb[index];
    202
    203 - /*
    204 - * Probe the shadow host TLB for the entry being overwritten, if one
    205 - * matches, invalidate it
    206 - */
    207 - kvm_mips_host_tlb_inv(vcpu, tlb->tlb_hi);
    208 + kvm_mips_invalidate_guest_tlb(vcpu, tlb);
    209
    210 tlb->tlb_mask = kvm_read_c0_guest_pagemask(cop0);
    211 tlb->tlb_hi = kvm_read_c0_guest_entryhi(cop0);
    212 @@ -982,6 +1016,7 @@ enum emulation_result kvm_mips_emulate_CP0(uint32_t inst, uint32_t *opc,
    213 int32_t rt, rd, copz, sel, co_bit, op;
    214 uint32_t pc = vcpu->arch.pc;
    215 unsigned long curr_pc;
    216 + int cpu, i;
    217
    218 /*
    219 * Update PC and hold onto current PC in case there is
    220 @@ -1089,8 +1124,16 @@ enum emulation_result kvm_mips_emulate_CP0(uint32_t inst, uint32_t *opc,
    221 vcpu->arch.gprs[rt]
    222 & ASID_MASK);
    223
    224 + preempt_disable();
    225 /* Blow away the shadow host TLBs */
    226 kvm_mips_flush_host_tlb(1);
    227 + cpu = smp_processor_id();
    228 + for_each_possible_cpu(i)
    229 + if (i != cpu) {
    230 + vcpu->arch.guest_user_asid[i] = 0;
    231 + vcpu->arch.guest_kernel_asid[i] = 0;
    232 + }
    233 + preempt_enable();
    234 }
    235 kvm_write_c0_guest_entryhi(cop0,
    236 vcpu->arch.gprs[rt]);
    237 diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h
    238 index 070fa8552051..627d129d7fcb 100644
    239 --- a/arch/powerpc/include/asm/reg.h
    240 +++ b/arch/powerpc/include/asm/reg.h
    241 @@ -708,6 +708,7 @@
    242 #define MMCR0_FCHV 0x00000001UL /* freeze conditions in hypervisor mode */
    243 #define SPRN_MMCR1 798
    244 #define SPRN_MMCR2 785
    245 +#define SPRN_UMMCR2 769
    246 #define SPRN_MMCRA 0x312
    247 #define MMCRA_SDSYNC 0x80000000UL /* SDAR synced with SIAR */
    248 #define MMCRA_SDAR_DCACHE_MISS 0x40000000UL
    249 diff --git a/arch/powerpc/kvm/book3s_emulate.c b/arch/powerpc/kvm/book3s_emulate.c
    250 index 2afdb9c0937d..729f8faa95c5 100644
    251 --- a/arch/powerpc/kvm/book3s_emulate.c
    252 +++ b/arch/powerpc/kvm/book3s_emulate.c
    253 @@ -498,6 +498,7 @@ int kvmppc_core_emulate_mtspr_pr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val)
    254 case SPRN_MMCR0:
    255 case SPRN_MMCR1:
    256 case SPRN_MMCR2:
    257 + case SPRN_UMMCR2:
    258 #endif
    259 break;
    260 unprivileged:
    261 @@ -640,6 +641,7 @@ int kvmppc_core_emulate_mfspr_pr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val
    262 case SPRN_MMCR0:
    263 case SPRN_MMCR1:
    264 case SPRN_MMCR2:
    265 + case SPRN_UMMCR2:
    266 case SPRN_TIR:
    267 #endif
    268 *spr_val = 0;
    269 diff --git a/arch/powerpc/kvm/booke.c b/arch/powerpc/kvm/booke.c
    270 index fd5875179e5c..6d63cd67b09b 100644
    271 --- a/arch/powerpc/kvm/booke.c
    272 +++ b/arch/powerpc/kvm/booke.c
    273 @@ -2033,7 +2033,7 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
    274 if (type == KVMPPC_DEBUG_NONE)
    275 continue;
    276
    277 - if (type & !(KVMPPC_DEBUG_WATCH_READ |
    278 + if (type & ~(KVMPPC_DEBUG_WATCH_READ |
    279 KVMPPC_DEBUG_WATCH_WRITE |
    280 KVMPPC_DEBUG_BREAKPOINT))
    281 return -EINVAL;
    282 diff --git a/arch/x86/kernel/apic/vector.c b/arch/x86/kernel/apic/vector.c
    283 index df6b4eeac0bd..0988e204f1e3 100644
    284 --- a/arch/x86/kernel/apic/vector.c
    285 +++ b/arch/x86/kernel/apic/vector.c
    286 @@ -659,11 +659,28 @@ void irq_complete_move(struct irq_cfg *cfg)
    287 */
    288 void irq_force_complete_move(struct irq_desc *desc)
    289 {
    290 - struct irq_data *irqdata = irq_desc_get_irq_data(desc);
    291 - struct apic_chip_data *data = apic_chip_data(irqdata);
    292 - struct irq_cfg *cfg = data ? &data->cfg : NULL;
    293 + struct irq_data *irqdata;
    294 + struct apic_chip_data *data;
    295 + struct irq_cfg *cfg;
    296 unsigned int cpu;
    297
    298 + /*
    299 + * The function is called for all descriptors regardless of which
    300 + * irqdomain they belong to. For example if an IRQ is provided by
    301 + * an irq_chip as part of a GPIO driver, the chip data for that
    302 + * descriptor is specific to the irq_chip in question.
    303 + *
    304 + * Check first that the chip_data is what we expect
    305 + * (apic_chip_data) before touching it any further.
    306 + */
    307 + irqdata = irq_domain_get_irq_data(x86_vector_domain,
    308 + irq_desc_get_irq(desc));
    309 + if (!irqdata)
    310 + return;
    311 +
    312 + data = apic_chip_data(irqdata);
    313 + cfg = data ? &data->cfg : NULL;
    314 +
    315 if (!cfg)
    316 return;
    317
    318 diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
    319 index 569c1e4f96fe..38b3ead7222d 100644
    320 --- a/arch/x86/kernel/e820.c
    321 +++ b/arch/x86/kernel/e820.c
    322 @@ -347,7 +347,7 @@ int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map,
    323 * continue building up new bios map based on this
    324 * information
    325 */
    326 - if (current_type != last_type || current_type == E820_PRAM) {
    327 + if (current_type != last_type) {
    328 if (last_type != 0) {
    329 new_bios[new_bios_entry].size =
    330 change_point[chgidx]->addr - last_addr;
    331 @@ -753,7 +753,7 @@ u64 __init early_reserve_e820(u64 size, u64 align)
    332 /*
    333 * Find the highest page frame number we have available
    334 */
    335 -static unsigned long __init e820_end_pfn(unsigned long limit_pfn)
    336 +static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)
    337 {
    338 int i;
    339 unsigned long last_pfn = 0;
    340 @@ -764,11 +764,7 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn)
    341 unsigned long start_pfn;
    342 unsigned long end_pfn;
    343
    344 - /*
    345 - * Persistent memory is accounted as ram for purposes of
    346 - * establishing max_pfn and mem_map.
    347 - */
    348 - if (ei->type != E820_RAM && ei->type != E820_PRAM)
    349 + if (ei->type != type)
    350 continue;
    351
    352 start_pfn = ei->addr >> PAGE_SHIFT;
    353 @@ -793,12 +789,12 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn)
    354 }
    355 unsigned long __init e820_end_of_ram_pfn(void)
    356 {
    357 - return e820_end_pfn(MAX_ARCH_PFN);
    358 + return e820_end_pfn(MAX_ARCH_PFN, E820_RAM);
    359 }
    360
    361 unsigned long __init e820_end_of_low_ram_pfn(void)
    362 {
    363 - return e820_end_pfn(1UL << (32-PAGE_SHIFT));
    364 + return e820_end_pfn(1UL << (32 - PAGE_SHIFT), E820_RAM);
    365 }
    366
    367 static void early_panic(char *msg)
    368 diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
    369 index 558f50edebca..479a409ddac8 100644
    370 --- a/arch/x86/kernel/ptrace.c
    371 +++ b/arch/x86/kernel/ptrace.c
    372 @@ -188,8 +188,8 @@ unsigned long kernel_stack_pointer(struct pt_regs *regs)
    373 return sp;
    374
    375 prev_esp = (u32 *)(context);
    376 - if (prev_esp)
    377 - return (unsigned long)prev_esp;
    378 + if (*prev_esp)
    379 + return (unsigned long)*prev_esp;
    380
    381 return (unsigned long)regs;
    382 }
    383 diff --git a/drivers/char/tpm/tpm-dev.c b/drivers/char/tpm/tpm-dev.c
    384 index de0337ebd658..4f3137d9a35e 100644
    385 --- a/drivers/char/tpm/tpm-dev.c
    386 +++ b/drivers/char/tpm/tpm-dev.c
    387 @@ -139,7 +139,7 @@ static ssize_t tpm_write(struct file *file, const char __user *buf,
    388
    389 /* atomic tpm command send and result receive */
    390 out_size = tpm_transmit(priv->chip, priv->data_buffer,
    391 - sizeof(priv->data_buffer));
    392 + sizeof(priv->data_buffer), 0);
    393 if (out_size < 0) {
    394 mutex_unlock(&priv->buffer_mutex);
    395 return out_size;
    396 diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c
    397 index c50637db3a8a..17abe52e6365 100644
    398 --- a/drivers/char/tpm/tpm-interface.c
    399 +++ b/drivers/char/tpm/tpm-interface.c
    400 @@ -328,8 +328,8 @@ EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
    401 /*
    402 * Internal kernel interface to transmit TPM commands
    403 */
    404 -ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
    405 - size_t bufsiz)
    406 +ssize_t tpm_transmit(struct tpm_chip *chip, const u8 *buf, size_t bufsiz,
    407 + unsigned int flags)
    408 {
    409 ssize_t rc;
    410 u32 count, ordinal;
    411 @@ -348,7 +348,8 @@ ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
    412 return -E2BIG;
    413 }
    414
    415 - mutex_lock(&chip->tpm_mutex);
    416 + if (!(flags & TPM_TRANSMIT_UNLOCKED))
    417 + mutex_lock(&chip->tpm_mutex);
    418
    419 rc = chip->ops->send(chip, (u8 *) buf, count);
    420 if (rc < 0) {
    421 @@ -391,20 +392,21 @@ out_recv:
    422 dev_err(chip->pdev,
    423 "tpm_transmit: tpm_recv: error %zd\n", rc);
    424 out:
    425 - mutex_unlock(&chip->tpm_mutex);
    426 + if (!(flags & TPM_TRANSMIT_UNLOCKED))
    427 + mutex_unlock(&chip->tpm_mutex);
    428 return rc;
    429 }
    430
    431 #define TPM_DIGEST_SIZE 20
    432 #define TPM_RET_CODE_IDX 6
    433
    434 -ssize_t tpm_transmit_cmd(struct tpm_chip *chip, void *cmd,
    435 - int len, const char *desc)
    436 +ssize_t tpm_transmit_cmd(struct tpm_chip *chip, const void *cmd,
    437 + int len, unsigned int flags, const char *desc)
    438 {
    439 - struct tpm_output_header *header;
    440 + const struct tpm_output_header *header;
    441 int err;
    442
    443 - len = tpm_transmit(chip, (u8 *) cmd, len);
    444 + len = tpm_transmit(chip, (const u8 *)cmd, len, flags);
    445 if (len < 0)
    446 return len;
    447 else if (len < TPM_HEADER_SIZE)
    448 @@ -452,7 +454,8 @@ ssize_t tpm_getcap(struct device *dev, __be32 subcap_id, cap_t *cap,
    449 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
    450 tpm_cmd.params.getcap_in.subcap = subcap_id;
    451 }
    452 - rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc);
    453 + rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 0,
    454 + desc);
    455 if (!rc)
    456 *cap = tpm_cmd.params.getcap_out.cap;
    457 return rc;
    458 @@ -468,7 +471,7 @@ void tpm_gen_interrupt(struct tpm_chip *chip)
    459 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
    460 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
    461
    462 - rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
    463 + rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 0,
    464 "attempting to determine the timeouts");
    465 }
    466 EXPORT_SYMBOL_GPL(tpm_gen_interrupt);
    467 @@ -489,7 +492,7 @@ static int tpm_startup(struct tpm_chip *chip, __be16 startup_type)
    468 start_cmd.header.in = tpm_startup_header;
    469
    470 start_cmd.params.startup_in.startup_type = startup_type;
    471 - return tpm_transmit_cmd(chip, &start_cmd, TPM_INTERNAL_RESULT_SIZE,
    472 + return tpm_transmit_cmd(chip, &start_cmd, TPM_INTERNAL_RESULT_SIZE, 0,
    473 "attempting to start the TPM");
    474 }
    475
    476 @@ -505,7 +508,8 @@ int tpm_get_timeouts(struct tpm_chip *chip)
    477 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
    478 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
    479 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
    480 - rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, NULL);
    481 + rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 0,
    482 + NULL);
    483
    484 if (rc == TPM_ERR_INVALID_POSTINIT) {
    485 /* The TPM is not started, we are the first to talk to it.
    486 @@ -519,7 +523,7 @@ int tpm_get_timeouts(struct tpm_chip *chip)
    487 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
    488 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
    489 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
    490 - NULL);
    491 + 0, NULL);
    492 }
    493 if (rc) {
    494 dev_err(chip->pdev,
    495 @@ -580,7 +584,7 @@ duration:
    496 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
    497 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION;
    498
    499 - rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
    500 + rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, 0,
    501 "attempting to determine the durations");
    502 if (rc)
    503 return rc;
    504 @@ -636,7 +640,7 @@ static int tpm_continue_selftest(struct tpm_chip *chip)
    505 struct tpm_cmd_t cmd;
    506
    507 cmd.header.in = continue_selftest_header;
    508 - rc = tpm_transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
    509 + rc = tpm_transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE, 0,
    510 "continue selftest");
    511 return rc;
    512 }
    513 @@ -656,7 +660,7 @@ int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
    514
    515 cmd.header.in = pcrread_header;
    516 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
    517 - rc = tpm_transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE,
    518 + rc = tpm_transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE, 0,
    519 "attempting to read a pcr value");
    520
    521 if (rc == 0)
    522 @@ -754,7 +758,7 @@ int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)
    523 cmd.header.in = pcrextend_header;
    524 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx);
    525 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE);
    526 - rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
    527 + rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 0,
    528 "attempting extend a PCR value");
    529
    530 tpm_chip_put(chip);
    531 @@ -793,7 +797,7 @@ int tpm_do_selftest(struct tpm_chip *chip)
    532 /* Attempt to read a PCR value */
    533 cmd.header.in = pcrread_header;
    534 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(0);
    535 - rc = tpm_transmit(chip, (u8 *) &cmd, READ_PCR_RESULT_SIZE);
    536 + rc = tpm_transmit(chip, (u8 *) &cmd, READ_PCR_RESULT_SIZE, 0);
    537 /* Some buggy TPMs will not respond to tpm_tis_ready() for
    538 * around 300ms while the self test is ongoing, keep trying
    539 * until the self test duration expires. */
    540 @@ -834,7 +838,7 @@ int tpm_send(u32 chip_num, void *cmd, size_t buflen)
    541 if (chip == NULL)
    542 return -ENODEV;
    543
    544 - rc = tpm_transmit_cmd(chip, cmd, buflen, "attempting tpm_cmd");
    545 + rc = tpm_transmit_cmd(chip, cmd, buflen, 0, "attempting tpm_cmd");
    546
    547 tpm_chip_put(chip);
    548 return rc;
    549 @@ -936,14 +940,15 @@ int tpm_pm_suspend(struct device *dev)
    550 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr);
    551 memcpy(cmd.params.pcrextend_in.hash, dummy_hash,
    552 TPM_DIGEST_SIZE);
    553 - rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
    554 + rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE, 0,
    555 "extending dummy pcr before suspend");
    556 }
    557
    558 /* now do the actual savestate */
    559 for (try = 0; try < TPM_RETRY; try++) {
    560 cmd.header.in = savestate_header;
    561 - rc = tpm_transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE, NULL);
    562 + rc = tpm_transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE, 0,
    563 + NULL);
    564
    565 /*
    566 * If the TPM indicates that it is too busy to respond to
    567 @@ -1027,8 +1032,8 @@ int tpm_get_random(u32 chip_num, u8 *out, size_t max)
    568 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
    569
    570 err = tpm_transmit_cmd(chip, &tpm_cmd,
    571 - TPM_GETRANDOM_RESULT_SIZE + num_bytes,
    572 - "attempting get random");
    573 + TPM_GETRANDOM_RESULT_SIZE + num_bytes,
    574 + 0, "attempting get random");
    575 if (err)
    576 break;
    577
    578 diff --git a/drivers/char/tpm/tpm-sysfs.c b/drivers/char/tpm/tpm-sysfs.c
    579 index ee66fd4673f3..f880856aa75e 100644
    580 --- a/drivers/char/tpm/tpm-sysfs.c
    581 +++ b/drivers/char/tpm/tpm-sysfs.c
    582 @@ -39,7 +39,7 @@ static ssize_t pubek_show(struct device *dev, struct device_attribute *attr,
    583 struct tpm_chip *chip = dev_get_drvdata(dev);
    584
    585 tpm_cmd.header.in = tpm_readpubek_header;
    586 - err = tpm_transmit_cmd(chip, &tpm_cmd, READ_PUBEK_RESULT_SIZE,
    587 + err = tpm_transmit_cmd(chip, &tpm_cmd, READ_PUBEK_RESULT_SIZE, 0,
    588 "attempting to read the PUBEK");
    589 if (err)
    590 goto out;
    591 diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
    592 index a4257a32964f..2216861f89f1 100644
    593 --- a/drivers/char/tpm/tpm.h
    594 +++ b/drivers/char/tpm/tpm.h
    595 @@ -498,11 +498,15 @@ extern struct class *tpm_class;
    596 extern dev_t tpm_devt;
    597 extern const struct file_operations tpm_fops;
    598
    599 +enum tpm_transmit_flags {
    600 + TPM_TRANSMIT_UNLOCKED = BIT(0),
    601 +};
    602 +
    603 +ssize_t tpm_transmit(struct tpm_chip *chip, const u8 *buf, size_t bufsiz,
    604 + unsigned int flags);
    605 +ssize_t tpm_transmit_cmd(struct tpm_chip *chip, const void *cmd, int len,
    606 + unsigned int flags, const char *desc);
    607 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *);
    608 -ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
    609 - size_t bufsiz);
    610 -ssize_t tpm_transmit_cmd(struct tpm_chip *chip, void *cmd, int len,
    611 - const char *desc);
    612 extern int tpm_get_timeouts(struct tpm_chip *);
    613 extern void tpm_gen_interrupt(struct tpm_chip *);
    614 extern int tpm_do_selftest(struct tpm_chip *);
    615 diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c
    616 index 678af51fb29e..cb7e4f6b70ba 100644
    617 --- a/drivers/char/tpm/tpm2-cmd.c
    618 +++ b/drivers/char/tpm/tpm2-cmd.c
    619 @@ -264,7 +264,7 @@ int tpm2_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
    620 sizeof(cmd.params.pcrread_in.pcr_select));
    621 cmd.params.pcrread_in.pcr_select[pcr_idx >> 3] = 1 << (pcr_idx & 0x7);
    622
    623 - rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd),
    624 + rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0,
    625 "attempting to read a pcr value");
    626 if (rc == 0) {
    627 buf = cmd.params.pcrread_out.digest;
    628 @@ -312,7 +312,7 @@ int tpm2_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash)
    629 cmd.params.pcrextend_in.hash_alg = cpu_to_be16(TPM2_ALG_SHA1);
    630 memcpy(cmd.params.pcrextend_in.digest, hash, TPM_DIGEST_SIZE);
    631
    632 - rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd),
    633 + rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0,
    634 "attempting extend a PCR value");
    635
    636 return rc;
    637 @@ -358,7 +358,7 @@ int tpm2_get_random(struct tpm_chip *chip, u8 *out, size_t max)
    638 cmd.header.in = tpm2_getrandom_header;
    639 cmd.params.getrandom_in.size = cpu_to_be16(num_bytes);
    640
    641 - err = tpm_transmit_cmd(chip, &cmd, sizeof(cmd),
    642 + err = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0,
    643 "attempting get random");
    644 if (err)
    645 break;
    646 @@ -416,12 +416,12 @@ static void tpm2_buf_append_auth(struct tpm_buf *buf, u32 session_handle,
    647 }
    648
    649 /**
    650 - * tpm2_seal_trusted() - seal a trusted key
    651 - * @chip_num: A specific chip number for the request or TPM_ANY_NUM
    652 - * @options: authentication values and other options
    653 + * tpm2_seal_trusted() - seal the payload of a trusted key
    654 + * @chip_num: TPM chip to use
    655 * @payload: the key data in clear and encrypted form
    656 + * @options: authentication values and other options
    657 *
    658 - * Returns < 0 on error and 0 on success.
    659 + * Return: < 0 on error and 0 on success.
    660 */
    661 int tpm2_seal_trusted(struct tpm_chip *chip,
    662 struct trusted_key_payload *payload,
    663 @@ -472,7 +472,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip,
    664 goto out;
    665 }
    666
    667 - rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, "sealing data");
    668 + rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, 0, "sealing data");
    669 if (rc)
    670 goto out;
    671
    672 @@ -494,10 +494,18 @@ out:
    673 return rc;
    674 }
    675
    676 -static int tpm2_load(struct tpm_chip *chip,
    677 - struct trusted_key_payload *payload,
    678 - struct trusted_key_options *options,
    679 - u32 *blob_handle)
    680 +/**
    681 + * tpm2_load_cmd() - execute a TPM2_Load command
    682 + * @chip_num: TPM chip to use
    683 + * @payload: the key data in clear and encrypted form
    684 + * @options: authentication values and other options
    685 + *
    686 + * Return: same as with tpm_transmit_cmd
    687 + */
    688 +static int tpm2_load_cmd(struct tpm_chip *chip,
    689 + struct trusted_key_payload *payload,
    690 + struct trusted_key_options *options,
    691 + u32 *blob_handle, unsigned int flags)
    692 {
    693 struct tpm_buf buf;
    694 unsigned int private_len;
    695 @@ -532,7 +540,7 @@ static int tpm2_load(struct tpm_chip *chip,
    696 goto out;
    697 }
    698
    699 - rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, "loading blob");
    700 + rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, flags, "loading blob");
    701 if (!rc)
    702 *blob_handle = be32_to_cpup(
    703 (__be32 *) &buf.data[TPM_HEADER_SIZE]);
    704 @@ -546,7 +554,16 @@ out:
    705 return rc;
    706 }
    707
    708 -static void tpm2_flush_context(struct tpm_chip *chip, u32 handle)
    709 +/**
    710 + * tpm2_flush_context_cmd() - execute a TPM2_FlushContext command
    711 + * @chip_num: TPM chip to use
    712 + * @payload: the key data in clear and encrypted form
    713 + * @options: authentication values and other options
    714 + *
    715 + * Return: same as with tpm_transmit_cmd
    716 + */
    717 +static void tpm2_flush_context_cmd(struct tpm_chip *chip, u32 handle,
    718 + unsigned int flags)
    719 {
    720 struct tpm_buf buf;
    721 int rc;
    722 @@ -560,7 +577,8 @@ static void tpm2_flush_context(struct tpm_chip *chip, u32 handle)
    723
    724 tpm_buf_append_u32(&buf, handle);
    725
    726 - rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, "flushing context");
    727 + rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, flags,
    728 + "flushing context");
    729 if (rc)
    730 dev_warn(chip->pdev, "0x%08x was not flushed, rc=%d\n", handle,
    731 rc);
    732 @@ -568,10 +586,18 @@ static void tpm2_flush_context(struct tpm_chip *chip, u32 handle)
    733 tpm_buf_destroy(&buf);
    734 }
    735
    736 -static int tpm2_unseal(struct tpm_chip *chip,
    737 - struct trusted_key_payload *payload,
    738 - struct trusted_key_options *options,
    739 - u32 blob_handle)
    740 +/**
    741 + * tpm2_unseal_cmd() - execute a TPM2_Unload command
    742 + * @chip_num: TPM chip to use
    743 + * @payload: the key data in clear and encrypted form
    744 + * @options: authentication values and other options
    745 + *
    746 + * Return: same as with tpm_transmit_cmd
    747 + */
    748 +static int tpm2_unseal_cmd(struct tpm_chip *chip,
    749 + struct trusted_key_payload *payload,
    750 + struct trusted_key_options *options,
    751 + u32 blob_handle, unsigned int flags)
    752 {
    753 struct tpm_buf buf;
    754 u16 data_len;
    755 @@ -589,7 +615,7 @@ static int tpm2_unseal(struct tpm_chip *chip,
    756 options->blobauth /* hmac */,
    757 TPM_DIGEST_SIZE);
    758
    759 - rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, "unsealing");
    760 + rc = tpm_transmit_cmd(chip, buf.data, PAGE_SIZE, flags, "unsealing");
    761 if (rc > 0)
    762 rc = -EPERM;
    763
    764 @@ -608,12 +634,12 @@ static int tpm2_unseal(struct tpm_chip *chip,
    765 }
    766
    767 /**
    768 - * tpm_unseal_trusted() - unseal a trusted key
    769 - * @chip_num: A specific chip number for the request or TPM_ANY_NUM
    770 - * @options: authentication values and other options
    771 + * tpm_unseal_trusted() - unseal the payload of a trusted key
    772 + * @chip_num: TPM chip to use
    773 * @payload: the key data in clear and encrypted form
    774 + * @options: authentication values and other options
    775 *
    776 - * Returns < 0 on error and 0 on success.
    777 + * Return: < 0 on error and 0 on success.
    778 */
    779 int tpm2_unseal_trusted(struct tpm_chip *chip,
    780 struct trusted_key_payload *payload,
    781 @@ -622,14 +648,17 @@ int tpm2_unseal_trusted(struct tpm_chip *chip,
    782 u32 blob_handle;
    783 int rc;
    784
    785 - rc = tpm2_load(chip, payload, options, &blob_handle);
    786 + mutex_lock(&chip->tpm_mutex);
    787 + rc = tpm2_load_cmd(chip, payload, options, &blob_handle,
    788 + TPM_TRANSMIT_UNLOCKED);
    789 if (rc)
    790 - return rc;
    791 -
    792 - rc = tpm2_unseal(chip, payload, options, blob_handle);
    793 -
    794 - tpm2_flush_context(chip, blob_handle);
    795 + goto out;
    796
    797 + rc = tpm2_unseal_cmd(chip, payload, options, blob_handle,
    798 + TPM_TRANSMIT_UNLOCKED);
    799 + tpm2_flush_context_cmd(chip, blob_handle, TPM_TRANSMIT_UNLOCKED);
    800 +out:
    801 + mutex_unlock(&chip->tpm_mutex);
    802 return rc;
    803 }
    804
    805 @@ -655,7 +684,7 @@ ssize_t tpm2_get_tpm_pt(struct tpm_chip *chip, u32 property_id, u32 *value,
    806 cmd.params.get_tpm_pt_in.property_id = cpu_to_be32(property_id);
    807 cmd.params.get_tpm_pt_in.property_cnt = cpu_to_be32(1);
    808
    809 - rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), desc);
    810 + rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0, desc);
    811 if (!rc)
    812 *value = be32_to_cpu(cmd.params.get_tpm_pt_out.value);
    813
    814 @@ -689,7 +718,7 @@ int tpm2_startup(struct tpm_chip *chip, u16 startup_type)
    815 cmd.header.in = tpm2_startup_header;
    816
    817 cmd.params.startup_in.startup_type = cpu_to_be16(startup_type);
    818 - return tpm_transmit_cmd(chip, &cmd, sizeof(cmd),
    819 + return tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0,
    820 "attempting to start the TPM");
    821 }
    822 EXPORT_SYMBOL_GPL(tpm2_startup);
    823 @@ -718,7 +747,7 @@ void tpm2_shutdown(struct tpm_chip *chip, u16 shutdown_type)
    824 cmd.header.in = tpm2_shutdown_header;
    825 cmd.params.startup_in.startup_type = cpu_to_be16(shutdown_type);
    826
    827 - rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), "stopping the TPM");
    828 + rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0, "stopping the TPM");
    829
    830 /* In places where shutdown command is sent there's no much we can do
    831 * except print the error code on a system failure.
    832 @@ -784,7 +813,7 @@ static int tpm2_start_selftest(struct tpm_chip *chip, bool full)
    833 cmd.header.in = tpm2_selftest_header;
    834 cmd.params.selftest_in.full_test = full;
    835
    836 - rc = tpm_transmit_cmd(chip, &cmd, TPM2_SELF_TEST_IN_SIZE,
    837 + rc = tpm_transmit_cmd(chip, &cmd, TPM2_SELF_TEST_IN_SIZE, 0,
    838 "continue selftest");
    839
    840 /* At least some prototype chips seem to give RC_TESTING error
    841 @@ -836,7 +865,7 @@ int tpm2_do_selftest(struct tpm_chip *chip)
    842 cmd.params.pcrread_in.pcr_select[1] = 0x00;
    843 cmd.params.pcrread_in.pcr_select[2] = 0x00;
    844
    845 - rc = tpm_transmit_cmd(chip, (u8 *) &cmd, sizeof(cmd), NULL);
    846 + rc = tpm_transmit_cmd(chip, &cmd, sizeof(cmd), 0, NULL);
    847 if (rc < 0)
    848 break;
    849
    850 @@ -885,7 +914,7 @@ int tpm2_probe(struct tpm_chip *chip)
    851 cmd.params.get_tpm_pt_in.property_id = cpu_to_be32(0x100);
    852 cmd.params.get_tpm_pt_in.property_cnt = cpu_to_be32(1);
    853
    854 - rc = tpm_transmit(chip, (const char *) &cmd, sizeof(cmd));
    855 + rc = tpm_transmit(chip, (const u8 *)&cmd, sizeof(cmd), 0);
    856 if (rc < 0)
    857 return rc;
    858 else if (rc < TPM_HEADER_SIZE)
    859 diff --git a/drivers/char/tpm/tpm_crb.c b/drivers/char/tpm/tpm_crb.c
    860 index 61e64293b765..2b21398c3adc 100644
    861 --- a/drivers/char/tpm/tpm_crb.c
    862 +++ b/drivers/char/tpm/tpm_crb.c
    863 @@ -149,6 +149,11 @@ static int crb_send(struct tpm_chip *chip, u8 *buf, size_t len)
    864 struct crb_priv *priv = chip->vendor.priv;
    865 int rc = 0;
    866
    867 + /* Zero the cancel register so that the next command will not get
    868 + * canceled.
    869 + */
    870 + iowrite32(0, &priv->cca->cancel);
    871 +
    872 if (len > le32_to_cpu(ioread32(&priv->cca->cmd_size))) {
    873 dev_err(&chip->dev,
    874 "invalid command count value %x %zx\n",
    875 @@ -182,8 +187,6 @@ static void crb_cancel(struct tpm_chip *chip)
    876
    877 if ((priv->flags & CRB_FL_ACPI_START) && crb_do_acpi_start(chip))
    878 dev_err(&chip->dev, "ACPI Start failed\n");
    879 -
    880 - iowrite32(0, &priv->cca->cancel);
    881 }
    882
    883 static bool crb_req_canceled(struct tpm_chip *chip, u8 status)
    884 diff --git a/drivers/cpuidle/cpuidle-arm.c b/drivers/cpuidle/cpuidle-arm.c
    885 index e342565e8715..1855b9ee807f 100644
    886 --- a/drivers/cpuidle/cpuidle-arm.c
    887 +++ b/drivers/cpuidle/cpuidle-arm.c
    888 @@ -135,6 +135,7 @@ static int __init arm_idle_init(void)
    889 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    890 if (!dev) {
    891 pr_err("Failed to allocate cpuidle device\n");
    892 + ret = -ENOMEM;
    893 goto out_fail;
    894 }
    895 dev->cpu = cpu;
    896 diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
    897 index 4d92df6ef9fe..7398262a2fab 100644
    898 --- a/drivers/mfd/Kconfig
    899 +++ b/drivers/mfd/Kconfig
    900 @@ -1460,6 +1460,7 @@ config MFD_WM8350
    901 config MFD_WM8350_I2C
    902 bool "Wolfson Microelectronics WM8350 with I2C"
    903 select MFD_WM8350
    904 + select REGMAP_I2C
    905 depends on I2C=y
    906 help
    907 The WM8350 is an integrated audio and power management
    908 diff --git a/drivers/mfd/atmel-hlcdc.c b/drivers/mfd/atmel-hlcdc.c
    909 index 06c205868573..c216c3a55793 100644
    910 --- a/drivers/mfd/atmel-hlcdc.c
    911 +++ b/drivers/mfd/atmel-hlcdc.c
    912 @@ -50,8 +50,9 @@ static int regmap_atmel_hlcdc_reg_write(void *context, unsigned int reg,
    913 if (reg <= ATMEL_HLCDC_DIS) {
    914 u32 status;
    915
    916 - readl_poll_timeout(hregmap->regs + ATMEL_HLCDC_SR, status,
    917 - !(status & ATMEL_HLCDC_SIP), 1, 100);
    918 + readl_poll_timeout_atomic(hregmap->regs + ATMEL_HLCDC_SR,
    919 + status, !(status & ATMEL_HLCDC_SIP),
    920 + 1, 100);
    921 }
    922
    923 writel(val, hregmap->regs + reg);
    924 diff --git a/drivers/mfd/rtsx_usb.c b/drivers/mfd/rtsx_usb.c
    925 index dbd907d7170e..691dab791f7a 100644
    926 --- a/drivers/mfd/rtsx_usb.c
    927 +++ b/drivers/mfd/rtsx_usb.c
    928 @@ -46,9 +46,6 @@ static void rtsx_usb_sg_timed_out(unsigned long data)
    929
    930 dev_dbg(&ucr->pusb_intf->dev, "%s: sg transfer timed out", __func__);
    931 usb_sg_cancel(&ucr->current_sg);
    932 -
    933 - /* we know the cancellation is caused by time-out */
    934 - ucr->current_sg.status = -ETIMEDOUT;
    935 }
    936
    937 static int rtsx_usb_bulk_transfer_sglist(struct rtsx_ucr *ucr,
    938 @@ -67,12 +64,15 @@ static int rtsx_usb_bulk_transfer_sglist(struct rtsx_ucr *ucr,
    939 ucr->sg_timer.expires = jiffies + msecs_to_jiffies(timeout);
    940 add_timer(&ucr->sg_timer);
    941 usb_sg_wait(&ucr->current_sg);
    942 - del_timer_sync(&ucr->sg_timer);
    943 + if (!del_timer_sync(&ucr->sg_timer))
    944 + ret = -ETIMEDOUT;
    945 + else
    946 + ret = ucr->current_sg.status;
    947
    948 if (act_len)
    949 *act_len = ucr->current_sg.bytes;
    950
    951 - return ucr->current_sg.status;
    952 + return ret;
    953 }
    954
    955 int rtsx_usb_transfer_data(struct rtsx_ucr *ucr, unsigned int pipe,
    956 diff --git a/include/linux/mfd/88pm80x.h b/include/linux/mfd/88pm80x.h
    957 index d409ceb2231e..c118a7ec94d6 100644
    958 --- a/include/linux/mfd/88pm80x.h
    959 +++ b/include/linux/mfd/88pm80x.h
    960 @@ -350,7 +350,7 @@ static inline int pm80x_dev_suspend(struct device *dev)
    961 int irq = platform_get_irq(pdev, 0);
    962
    963 if (device_may_wakeup(dev))
    964 - set_bit((1 << irq), &chip->wu_flag);
    965 + set_bit(irq, &chip->wu_flag);
    966
    967 return 0;
    968 }
    969 @@ -362,7 +362,7 @@ static inline int pm80x_dev_resume(struct device *dev)
    970 int irq = platform_get_irq(pdev, 0);
    971
    972 if (device_may_wakeup(dev))
    973 - clear_bit((1 << irq), &chip->wu_flag);
    974 + clear_bit(irq, &chip->wu_flag);
    975
    976 return 0;
    977 }
    978 diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
    979 index 4ff237dbc006..445601c580d6 100644
    980 --- a/kernel/time/timekeeping.c
    981 +++ b/kernel/time/timekeeping.c
    982 @@ -298,17 +298,34 @@ u32 (*arch_gettimeoffset)(void) = default_arch_gettimeoffset;
    983 static inline u32 arch_gettimeoffset(void) { return 0; }
    984 #endif
    985
    986 +static inline s64 timekeeping_delta_to_ns(struct tk_read_base *tkr,
    987 + cycle_t delta)
    988 +{
    989 + s64 nsec;
    990 +
    991 + nsec = delta * tkr->mult + tkr->xtime_nsec;
    992 + nsec >>= tkr->shift;
    993 +
    994 + /* If arch requires, add in get_arch_timeoffset() */
    995 + return nsec + arch_gettimeoffset();
    996 +}
    997 +
    998 static inline s64 timekeeping_get_ns(struct tk_read_base *tkr)
    999 {
    1000 cycle_t delta;
    1001 - s64 nsec;
    1002
    1003 delta = timekeeping_get_delta(tkr);
    1004 + return timekeeping_delta_to_ns(tkr, delta);
    1005 +}
    1006
    1007 - nsec = (delta * tkr->mult + tkr->xtime_nsec) >> tkr->shift;
    1008 +static inline s64 timekeeping_cycles_to_ns(struct tk_read_base *tkr,
    1009 + cycle_t cycles)
    1010 +{
    1011 + cycle_t delta;
    1012
    1013 - /* If arch requires, add in get_arch_timeoffset() */
    1014 - return nsec + arch_gettimeoffset();
    1015 + /* calculate the delta since the last update_wall_time */
    1016 + delta = clocksource_delta(cycles, tkr->cycle_last, tkr->mask);
    1017 + return timekeeping_delta_to_ns(tkr, delta);
    1018 }
    1019
    1020 /**
    1021 @@ -385,8 +402,11 @@ static __always_inline u64 __ktime_get_fast_ns(struct tk_fast *tkf)
    1022 tkr = tkf->base + (seq & 0x01);
    1023 now = ktime_to_ns(tkr->base);
    1024
    1025 - now += clocksource_delta(tkr->read(tkr->clock),
    1026 - tkr->cycle_last, tkr->mask);
    1027 + now += timekeeping_delta_to_ns(tkr,
    1028 + clocksource_delta(
    1029 + tkr->read(tkr->clock),
    1030 + tkr->cycle_last,
    1031 + tkr->mask));
    1032 } while (read_seqcount_retry(&tkf->seq, seq));
    1033
    1034 return now;
    1035 diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
    1036 index 1d950fbb2aec..2d1fe34781fa 100644
    1037 --- a/security/integrity/ima/ima_api.c
    1038 +++ b/security/integrity/ima/ima_api.c
    1039 @@ -202,7 +202,7 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
    1040 } hash;
    1041
    1042 if (xattr_value)
    1043 - *xattr_len = ima_read_xattr(file->f_path.dentry, xattr_value);
    1044 + *xattr_len = ima_read_xattr(file_dentry(file), xattr_value);
    1045
    1046 if (!(iint->flags & IMA_COLLECTED)) {
    1047 u64 i_version = file_inode(file)->i_version;
    1048 diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
    1049 index 1873b5536f80..ed5a9c110b3a 100644
    1050 --- a/security/integrity/ima/ima_appraise.c
    1051 +++ b/security/integrity/ima/ima_appraise.c
    1052 @@ -189,7 +189,7 @@ int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
    1053 {
    1054 static const char op[] = "appraise_data";
    1055 char *cause = "unknown";
    1056 - struct dentry *dentry = file->f_path.dentry;
    1057 + struct dentry *dentry = file_dentry(file);
    1058 struct inode *inode = d_backing_inode(dentry);
    1059 enum integrity_status status = INTEGRITY_UNKNOWN;
    1060 int rc = xattr_len, hash_start = 0;
    1061 @@ -289,7 +289,7 @@ out:
    1062 */
    1063 void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file)
    1064 {
    1065 - struct dentry *dentry = file->f_path.dentry;
    1066 + struct dentry *dentry = file_dentry(file);
    1067 int rc = 0;
    1068
    1069 /* do not collect and update hash for digital signatures */
    1070 diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
    1071 index 36470af7eda7..92b819e4f729 100644
    1072 --- a/sound/pci/ali5451/ali5451.c
    1073 +++ b/sound/pci/ali5451/ali5451.c
    1074 @@ -1408,6 +1408,7 @@ snd_ali_playback_pointer(struct snd_pcm_substream *substream)
    1075 spin_unlock(&codec->reg_lock);
    1076 dev_dbg(codec->card->dev, "playback pointer returned cso=%xh.\n", cso);
    1077
    1078 + cso %= runtime->buffer_size;
    1079 return cso;
    1080 }
    1081
    1082 @@ -1428,6 +1429,7 @@ static snd_pcm_uframes_t snd_ali_pointer(struct snd_pcm_substream *substream)
    1083 cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2));
    1084 spin_unlock(&codec->reg_lock);
    1085
    1086 + cso %= runtime->buffer_size;
    1087 return cso;
    1088 }
    1089
    1090 diff --git a/sound/usb/line6/driver.c b/sound/usb/line6/driver.c
    1091 index 81b7da8e56d3..183311cb849e 100644
    1092 --- a/sound/usb/line6/driver.c
    1093 +++ b/sound/usb/line6/driver.c
    1094 @@ -29,7 +29,7 @@
    1095 /*
    1096 This is Line 6's MIDI manufacturer ID.
    1097 */
    1098 -const unsigned char line6_midi_id[] = {
    1099 +const unsigned char line6_midi_id[3] = {
    1100 0x00, 0x01, 0x0c
    1101 };
    1102 EXPORT_SYMBOL_GPL(line6_midi_id);
    1103 diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
    1104 index f6c3bf79af9a..04991b009132 100644
    1105 --- a/sound/usb/mixer_quirks.c
    1106 +++ b/sound/usb/mixer_quirks.c
    1107 @@ -1831,6 +1831,7 @@ void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
    1108 }
    1109
    1110 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
    1111 + struct usb_mixer_elem_info *cval,
    1112 struct snd_kcontrol *kctl)
    1113 {
    1114 /* Approximation using 10 ranges based on output measurement on hw v1.2.
    1115 @@ -1848,10 +1849,19 @@ static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
    1116 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
    1117 );
    1118
    1119 - usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk\n");
    1120 - kctl->tlv.p = scale;
    1121 - kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
    1122 - kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
    1123 + if (cval->min == 0 && cval->max == 50) {
    1124 + usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
    1125 + kctl->tlv.p = scale;
    1126 + kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
    1127 + kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
    1128 +
    1129 + } else if (cval->min == 0 && cval->max <= 1000) {
    1130 + /* Some other clearly broken DragonFly variant.
    1131 + * At least a 0..53 variant (hw v1.0) exists.
    1132 + */
    1133 + usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
    1134 + kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
    1135 + }
    1136 }
    1137
    1138 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
    1139 @@ -1860,8 +1870,8 @@ void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
    1140 {
    1141 switch (mixer->chip->usb_id) {
    1142 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
    1143 - if (unitid == 7 && cval->min == 0 && cval->max == 50)
    1144 - snd_dragonfly_quirk_db_scale(mixer, kctl);
    1145 + if (unitid == 7 && cval->control == UAC_FU_VOLUME)
    1146 + snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
    1147 break;
    1148 }
    1149 }