This is the 4.19.77 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl2YehoACgkQONu9yGCS
aT536hAA0w6XF1ogPi23xS5BQ386c3BjWaOJddu0PFkR9utguuZaDG5AKjnkHtm2
foxKeCGyChCc1h6qFD2wLavsQMephzLWXkMw1/uXfwAPXGWY1hquD46zrFO0IYOc
dsmKh5V8ZT70lmPTBHCDVowp1xUczNFhuNRHz1KzVQ3lsKMAhsRiy6vpsXWzIeOM
VCrayI4jxTVZvoA9Odm9fTXpau0Qb9k4pqGGU84dz/xWfGzrz/AOmp+kWuZRGepS
fQi+46HK3idmGGNBVGkJYkDdpkefdrYdjlVHkkoAZHlaB+QaOrre0trNArK+knRu
jJIl8R/M50yYbkn97vVIpwoh19rV0BI7KUFKO4C4NCByOOV+9vjJ5g1FuZ7c3pmj
XKZiBmFBJVqbI1uwgqEn+/Tv6DyEz4gUzo5GHOe2i/Bh2nSguHZzO+Yhat1U+J+Y
3QVfrIS10jICWBAqm147FepGtNxbCPP3plyqbJdrMwgM6GOMd83v+rY/5okB2YK4
SHhzuevQoxujjeoOgHKjIqTiCIaJMt5ZvlCFqODg8NgpjTNDAbCA/UUQWs7MlrqX
6uwH2QLwk3h+bEXUfGzsbsk5isTDpHr1ch6SI9T675JHRZCE461RoR82XpjLOyHD
90tBJk9pfKlLqSEyiaWPPpXErhoS5WCVKM5yuT/rSS/i2Ve4VH4=
=Q+c9
-----END PGP SIGNATURE-----
Merge 4.19.77 into android-4.19-q
Changes in 4.19.77
arcnet: provide a buffer big enough to actually receive packets
cdc_ncm: fix divide-by-zero caused by invalid wMaxPacketSize
macsec: drop skb sk before calling gro_cells_receive
net/phy: fix DP83865 10 Mbps HDX loopback disable function
net: qrtr: Stop rx_worker before freeing node
net/sched: act_sample: don't push mac header on ip6gre ingress
net_sched: add max len check for TCA_KIND
nfp: flower: fix memory leak in nfp_flower_spawn_vnic_reprs
openvswitch: change type of UPCALL_PID attribute to NLA_UNSPEC
ppp: Fix memory leak in ppp_write
sch_netem: fix a divide by zero in tabledist()
skge: fix checksum byte order
usbnet: ignore endpoints with invalid wMaxPacketSize
usbnet: sanity checking of packet sizes and device mtu
net: sched: fix possible crash in tcf_action_destroy()
tcp: better handle TCP_USER_TIMEOUT in SYN_SENT state
net/mlx5: Add device ID of upcoming BlueField-2
mISDN: enforce CAP_NET_RAW for raw sockets
appletalk: enforce CAP_NET_RAW for raw sockets
ax25: enforce CAP_NET_RAW for raw sockets
ieee802154: enforce CAP_NET_RAW for raw sockets
nfc: enforce CAP_NET_RAW for raw sockets
nfp: flower: prevent memory leak in nfp_flower_spawn_phy_reprs
ALSA: hda: Flush interrupts on disabling
regulator: lm363x: Fix off-by-one n_voltages for lm3632 ldo_vpos/ldo_vneg
ASoC: tlv320aic31xx: suppress error message for EPROBE_DEFER
ASoC: sgtl5000: Fix of unmute outputs on probe
ASoC: sgtl5000: Fix charge pump source assignment
firmware: qcom_scm: Use proper types for dma mappings
dmaengine: bcm2835: Print error in case setting DMA mask fails
leds: leds-lp5562 allow firmware files up to the maximum length
media: dib0700: fix link error for dibx000_i2c_set_speed
media: mtk-cir: lower de-glitch counter for rc-mm protocol
media: exynos4-is: fix leaked of_node references
media: hdpvr: Add device num check and handling
media: i2c: ov5640: Check for devm_gpiod_get_optional() error
time/tick-broadcast: Fix tick_broadcast_offline() lockdep complaint
sched/fair: Fix imbalance due to CPU affinity
sched/core: Fix CPU controller for !RT_GROUP_SCHED
x86/apic: Make apic_pending_intr_clear() more robust
sched/deadline: Fix bandwidth accounting at all levels after offline migration
x86/reboot: Always use NMI fallback when shutdown via reboot vector IPI fails
x86/apic: Soft disable APIC before initializing it
ALSA: hda - Show the fatal CORB/RIRB error more clearly
ALSA: i2c: ak4xxx-adda: Fix a possible null pointer dereference in build_adc_controls()
EDAC/mc: Fix grain_bits calculation
media: iguanair: add sanity checks
base: soc: Export soc_device_register/unregister APIs
ALSA: usb-audio: Skip bSynchAddress endpoint check if it is invalid
ia64:unwind: fix double free for mod->arch.init_unw_table
EDAC/altera: Use the proper type for the IRQ status bits
ASoC: rsnd: don't call clk_get_rate() under atomic context
arm64/prefetch: fix a -Wtype-limits warning
md/raid1: end bio when the device faulty
md: don't call spare_active in md_reap_sync_thread if all member devices can't work
md: don't set In_sync if array is frozen
media: media/platform: fsl-viu.c: fix build for MICROBLAZE
ACPI / processor: don't print errors for processorIDs == 0xff
loop: Add LOOP_SET_DIRECT_IO to compat ioctl
EDAC, pnd2: Fix ioremap() size in dnv_rd_reg()
efi: cper: print AER info of PCIe fatal error
firmware: arm_scmi: Check if platform has released shmem before using
sched/fair: Use rq_lock/unlock in online_fair_sched_group
idle: Prevent late-arriving interrupts from disrupting offline
media: gspca: zero usb_buf on error
perf config: Honour $PERF_CONFIG env var to specify alternate .perfconfig
perf test vfs_getname: Disable ~/.perfconfig to get default output
media: mtk-mdp: fix reference count on old device tree
media: fdp1: Reduce FCP not found message level to debug
media: em28xx: modules workqueue not inited for 2nd device
media: rc: imon: Allow iMON RC protocol for ffdc 7e device
dmaengine: iop-adma: use correct printk format strings
perf record: Support aarch64 random socket_id assignment
media: vsp1: fix memory leak of dl on error return path
media: i2c: ov5645: Fix power sequence
media: omap3isp: Don't set streaming state on random subdevs
media: imx: mipi csi-2: Don't fail if initial state times-out
net: lpc-enet: fix printk format strings
m68k: Prevent some compiler warnings in Coldfire builds
ARM: dts: imx7d: cl-som-imx7: make ethernet work again
ARM: dts: imx7-colibri: disable HS400
media: radio/si470x: kill urb on error
media: hdpvr: add terminating 0 at end of string
ASoC: uniphier: Fix double reset assersion when transitioning to suspend state
tools headers: Fixup bitsperlong per arch includes
ASoC: sun4i-i2s: Don't use the oversample to calculate BCLK
led: triggers: Fix a memory leak bug
nbd: add missing config put
media: mceusb: fix (eliminate) TX IR signal length limit
media: dvb-frontends: use ida for pll number
posix-cpu-timers: Sanitize bogus WARNONS
media: dvb-core: fix a memory leak bug
libperf: Fix alignment trap with xyarray contents in 'perf stat'
EDAC/amd64: Recognize DRAM device type ECC capability
EDAC/amd64: Decode syndrome before translating address
PM / devfreq: passive: Use non-devm notifiers
PM / devfreq: exynos-bus: Correct clock enable sequence
media: cec-notifier: clear cec_adap in cec_notifier_unregister
media: saa7146: add cleanup in hexium_attach()
media: cpia2_usb: fix memory leaks
media: saa7134: fix terminology around saa7134_i2c_eeprom_md7134_gate()
perf trace beauty ioctl: Fix off-by-one error in cmd->string table
media: ov9650: add a sanity check
ASoC: es8316: fix headphone mixer volume table
ACPI / CPPC: do not require the _PSD method
sched/cpufreq: Align trace event behavior of fast switching
x86/apic/vector: Warn when vector space exhaustion breaks affinity
arm64: kpti: ensure patched kernel text is fetched from PoU
x86/mm/pti: Do not invoke PTI functions when PTI is disabled
ASoC: fsl_ssi: Fix clock control issue in master mode
x86/mm/pti: Handle unaligned address gracefully in pti_clone_pagetable()
nvmet: fix data units read and written counters in SMART log
nvme-multipath: fix ana log nsid lookup when nsid is not found
ALSA: firewire-motu: add support for MOTU 4pre
iommu/amd: Silence warnings under memory pressure
libata/ahci: Drop PCS quirk for Denverton and beyond
iommu/iova: Avoid false sharing on fq_timer_on
libtraceevent: Change users plugin directory
ARM: dts: exynos: Mark LDO10 as always-on on Peach Pit/Pi Chromebooks
ACPI: custom_method: fix memory leaks
ACPI / PCI: fix acpi_pci_irq_enable() memory leak
closures: fix a race on wakeup from closure_sync
hwmon: (acpi_power_meter) Change log level for 'unsafe software power cap'
md/raid1: fail run raid1 array when active disk less than one
dmaengine: ti: edma: Do not reset reserved paRAM slots
kprobes: Prohibit probing on BUG() and WARN() address
s390/crypto: xts-aes-s390 fix extra run-time crypto self tests finding
x86/cpu: Add Tiger Lake to Intel family
platform/x86: intel_pmc_core: Do not ioremap RAM
ASoC: dmaengine: Make the pcm->name equal to pcm->id if the name is not set
raid5: don't set STRIPE_HANDLE to stripe which is in batch list
mmc: core: Clarify sdio_irq_pending flag for MMC_CAP2_SDIO_IRQ_NOTHREAD
mmc: sdhci: Fix incorrect switch to HS mode
mmc: core: Add helper function to indicate if SDIO IRQs is enabled
mmc: dw_mmc: Re-store SDIO IRQs mask at system resume
raid5: don't increment read_errors on EILSEQ return
libertas: Add missing sentinel at end of if_usb.c fw_table
e1000e: add workaround for possible stalled packet
ALSA: hda - Drop unsol event handler for Intel HDMI codecs
drm/amd/powerplay/smu7: enforce minimal VBITimeout (v2)
media: ttusb-dec: Fix info-leak in ttusb_dec_send_command()
ALSA: hda/realtek - Blacklist PC beep for Lenovo ThinkCentre M73/93
iommu/amd: Override wrong IVRS IOAPIC on Raven Ridge systems
btrfs: extent-tree: Make sure we only allocate extents from block groups with the same type
media: omap3isp: Set device on omap3isp subdevs
PM / devfreq: passive: fix compiler warning
iwlwifi: fw: don't send GEO_TX_POWER_LIMIT command to FW version 36
ALSA: firewire-tascam: handle error code when getting current source of clock
ALSA: firewire-tascam: check intermediate state of clock status and retry
scsi: scsi_dh_rdac: zero cdb in send_mode_select()
scsi: qla2xxx: Fix Relogin to prevent modifying scan_state flag
printk: Do not lose last line in kmsg buffer dump
IB/mlx5: Free mpi in mp_slave mode
IB/hfi1: Define variables as unsigned long to fix KASAN warning
randstruct: Check member structs in is_pure_ops_struct()
Revert "ceph: use ceph_evict_inode to cleanup inode's resource"
ceph: use ceph_evict_inode to cleanup inode's resource
ALSA: hda/realtek - PCI quirk for Medion E4254
blk-mq: add callback of .cleanup_rq
scsi: implement .cleanup_rq callback
powerpc/imc: Dont create debugfs files for cpu-less nodes
fuse: fix missing unlock_page in fuse_writepage()
parisc: Disable HP HSC-PCI Cards to prevent kernel crash
KVM: x86: always stop emulation on page fault
KVM: x86: set ctxt->have_exception in x86_decode_insn()
KVM: x86: Manually calculate reserved bits when loading PDPTRS
media: sn9c20x: Add MSI MS-1039 laptop to flip_dmi_table
media: don't drop front-end reference count for ->detach
binfmt_elf: Do not move brk for INTERP-less ET_EXEC
ASoC: Intel: NHLT: Fix debug print format
ASoC: Intel: Skylake: Use correct function to access iomem space
ASoC: Intel: Fix use of potentially uninitialized variable
ARM: samsung: Fix system restart on S3C6410
ARM: zynq: Use memcpy_toio instead of memcpy on smp bring-up
Revert "arm64: Remove unnecessary ISBs from set_{pte,pmd,pud}"
arm64: tlb: Ensure we execute an ISB following walk cache invalidation
arm64: dts: rockchip: limit clock rate of MMC controllers for RK3328
alarmtimer: Use EOPNOTSUPP instead of ENOTSUPP
regulator: Defer init completion for a while after late_initcall
efifb: BGRT: Improve efifb_bgrt_sanity_check
gfs2: clear buf_in_tr when ending a transaction in sweep_bh_for_rgrps
memcg, oom: don't require __GFP_FS when invoking memcg OOM killer
memcg, kmem: do not fail __GFP_NOFAIL charges
i40e: check __I40E_VF_DISABLE bit in i40e_sync_filters_subtask
block: fix null pointer dereference in blk_mq_rq_timed_out()
smb3: allow disabling requesting leases
ovl: Fix dereferencing possible ERR_PTR()
ovl: filter of trusted xattr results in audit
btrfs: fix allocation of free space cache v1 bitmap pages
Btrfs: fix use-after-free when using the tree modification log
btrfs: Relinquish CPUs in btrfs_compare_trees
btrfs: qgroup: Fix the wrong target io_tree when freeing reserved data space
btrfs: qgroup: Fix reserved data space leak if we have multiple reserve calls
Btrfs: fix race setting up and completing qgroup rescan workers
md/raid6: Set R5_ReadError when there is read failure on parity disk
md: don't report active array_state until after revalidate_disk() completes.
md: only call set_in_sync() when it is expected to succeed.
cfg80211: Purge frame registrations on iftype change
/dev/mem: Bail out upon SIGKILL.
ext4: fix warning inside ext4_convert_unwritten_extents_endio
ext4: fix punch hole for inline_data file systems
quota: fix wrong condition in is_quota_modification()
hwrng: core - don't wait on add_early_randomness()
i2c: riic: Clear NACK in tend isr
CIFS: fix max ea value size
CIFS: Fix oplock handling for SMB 2.1+ protocols
md/raid0: avoid RAID0 data corruption due to layout confusion.
fuse: fix deadlock with aio poll and fuse_iqueue::waitq.lock
mm/compaction.c: clear total_{migrate,free}_scanned before scanning a new zone
drm/amd/display: Restore backlight brightness after system resume
Linux 4.19.77
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: I024d8f764cd5910ba1210299375accb2e79f0abc
This commit is contained in:
Greg Kroah-Hartman
commit
cd1eb9f1b9
237 changed files with 1876 additions and 778 deletions
2
Makefile
2
Makefile
|
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 76
|
||||
SUBLEVEL = 77
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
|
|
|||
|
|
@ -437,6 +437,7 @@
|
|||
regulator-name = "vdd_ldo10";
|
||||
regulator-min-microvolt = <1800000>;
|
||||
regulator-max-microvolt = <1800000>;
|
||||
regulator-always-on;
|
||||
regulator-state-mem {
|
||||
regulator-off-in-suspend;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -437,6 +437,7 @@
|
|||
regulator-name = "vdd_ldo10";
|
||||
regulator-min-microvolt = <1800000>;
|
||||
regulator-max-microvolt = <1800000>;
|
||||
regulator-always-on;
|
||||
regulator-state-mem {
|
||||
regulator-off-in-suspend;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -323,6 +323,7 @@
|
|||
vmmc-supply = <®_module_3v3>;
|
||||
vqmmc-supply = <®_DCDC3>;
|
||||
non-removable;
|
||||
sdhci-caps-mask = <0x80000000 0x0>;
|
||||
};
|
||||
|
||||
&iomuxc {
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@
|
|||
<&clks IMX7D_ENET1_TIME_ROOT_CLK>;
|
||||
assigned-clock-parents = <&clks IMX7D_PLL_ENET_MAIN_100M_CLK>;
|
||||
assigned-clock-rates = <0>, <100000000>;
|
||||
phy-mode = "rgmii";
|
||||
phy-mode = "rgmii-id";
|
||||
phy-handle = <ðphy0>;
|
||||
fsl,magic-packet;
|
||||
status = "okay";
|
||||
|
|
@ -69,7 +69,7 @@
|
|||
<&clks IMX7D_ENET2_TIME_ROOT_CLK>;
|
||||
assigned-clock-parents = <&clks IMX7D_PLL_ENET_MAIN_100M_CLK>;
|
||||
assigned-clock-rates = <0>, <100000000>;
|
||||
phy-mode = "rgmii";
|
||||
phy-mode = "rgmii-id";
|
||||
phy-handle = <ðphy1>;
|
||||
fsl,magic-packet;
|
||||
status = "okay";
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ int zynq_cpun_start(u32 address, int cpu)
|
|||
* 0x4: Jump by mov instruction
|
||||
* 0x8: Jumping address
|
||||
*/
|
||||
memcpy((__force void *)zero, &zynq_secondary_trampoline,
|
||||
memcpy_toio(zero, &zynq_secondary_trampoline,
|
||||
trampoline_size);
|
||||
writel(address, zero + trampoline_size);
|
||||
|
||||
|
|
|
|||
|
|
@ -62,6 +62,7 @@ void samsung_wdt_reset(void)
|
|||
#ifdef CONFIG_OF
|
||||
static const struct of_device_id s3c2410_wdt_match[] = {
|
||||
{ .compatible = "samsung,s3c2410-wdt" },
|
||||
{ .compatible = "samsung,s3c6410-wdt" },
|
||||
{},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -708,6 +708,7 @@
|
|||
<&cru SCLK_SDMMC_DRV>, <&cru SCLK_SDMMC_SAMPLE>;
|
||||
clock-names = "biu", "ciu", "ciu-drive", "ciu-sample";
|
||||
fifo-depth = <0x100>;
|
||||
max-frequency = <150000000>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
|
@ -719,6 +720,7 @@
|
|||
<&cru SCLK_SDIO_DRV>, <&cru SCLK_SDIO_SAMPLE>;
|
||||
clock-names = "biu", "ciu", "ciu-drive", "ciu-sample";
|
||||
fifo-depth = <0x100>;
|
||||
max-frequency = <150000000>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
|
@ -730,6 +732,7 @@
|
|||
<&cru SCLK_EMMC_DRV>, <&cru SCLK_EMMC_SAMPLE>;
|
||||
clock-names = "biu", "ciu", "ciu-drive", "ciu-sample";
|
||||
fifo-depth = <0x100>;
|
||||
max-frequency = <150000000>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -62,14 +62,6 @@
|
|||
#define MIDR_CPU_MODEL_MASK (MIDR_IMPLEMENTOR_MASK | MIDR_PARTNUM_MASK | \
|
||||
MIDR_ARCHITECTURE_MASK)
|
||||
|
||||
#define MIDR_IS_CPU_MODEL_RANGE(midr, model, rv_min, rv_max) \
|
||||
({ \
|
||||
u32 _model = (midr) & MIDR_CPU_MODEL_MASK; \
|
||||
u32 rv = (midr) & (MIDR_REVISION_MASK | MIDR_VARIANT_MASK); \
|
||||
\
|
||||
_model == (model) && rv >= (rv_min) && rv <= (rv_max); \
|
||||
})
|
||||
|
||||
#define ARM_CPU_IMP_ARM 0x41
|
||||
#define ARM_CPU_IMP_APM 0x50
|
||||
#define ARM_CPU_IMP_CAVIUM 0x43
|
||||
|
|
@ -153,10 +145,19 @@ struct midr_range {
|
|||
|
||||
#define MIDR_ALL_VERSIONS(m) MIDR_RANGE(m, 0, 0, 0xf, 0xf)
|
||||
|
||||
static inline bool midr_is_cpu_model_range(u32 midr, u32 model, u32 rv_min,
|
||||
u32 rv_max)
|
||||
{
|
||||
u32 _model = midr & MIDR_CPU_MODEL_MASK;
|
||||
u32 rv = midr & (MIDR_REVISION_MASK | MIDR_VARIANT_MASK);
|
||||
|
||||
return _model == model && rv >= rv_min && rv <= rv_max;
|
||||
}
|
||||
|
||||
static inline bool is_midr_in_range(u32 midr, struct midr_range const *range)
|
||||
{
|
||||
return MIDR_IS_CPU_MODEL_RANGE(midr, range->model,
|
||||
range->rv_min, range->rv_max);
|
||||
return midr_is_cpu_model_range(midr, range->model,
|
||||
range->rv_min, range->rv_max);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
|
|
|
|||
|
|
@ -224,8 +224,10 @@ static inline void set_pte(pte_t *ptep, pte_t pte)
|
|||
* Only if the new pte is valid and kernel, otherwise TLB maintenance
|
||||
* or update_mmu_cache() have the necessary barriers.
|
||||
*/
|
||||
if (pte_valid_not_user(pte))
|
||||
if (pte_valid_not_user(pte)) {
|
||||
dsb(ishst);
|
||||
isb();
|
||||
}
|
||||
}
|
||||
|
||||
extern void __sync_icache_dcache(pte_t pteval);
|
||||
|
|
@ -432,6 +434,7 @@ static inline void set_pmd(pmd_t *pmdp, pmd_t pmd)
|
|||
{
|
||||
WRITE_ONCE(*pmdp, pmd);
|
||||
dsb(ishst);
|
||||
isb();
|
||||
}
|
||||
|
||||
static inline void pmd_clear(pmd_t *pmdp)
|
||||
|
|
@ -483,6 +486,7 @@ static inline void set_pud(pud_t *pudp, pud_t pud)
|
|||
{
|
||||
WRITE_ONCE(*pudp, pud);
|
||||
dsb(ishst);
|
||||
isb();
|
||||
}
|
||||
|
||||
static inline void pud_clear(pud_t *pudp)
|
||||
|
|
|
|||
|
|
@ -224,6 +224,7 @@ static inline void __flush_tlb_kernel_pgtable(unsigned long kaddr)
|
|||
|
||||
__tlbi(vaae1is, addr);
|
||||
dsb(ish);
|
||||
isb();
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -846,7 +846,7 @@ static bool has_no_hw_prefetch(const struct arm64_cpu_capabilities *entry, int _
|
|||
u32 midr = read_cpuid_id();
|
||||
|
||||
/* Cavium ThunderX pass 1.x and 2.x */
|
||||
return MIDR_IS_CPU_MODEL_RANGE(midr, MIDR_THUNDERX,
|
||||
return midr_is_cpu_model_range(midr, MIDR_THUNDERX,
|
||||
MIDR_CPU_VAR_REV(0, 0),
|
||||
MIDR_CPU_VAR_REV(1, MIDR_REVISION_MASK));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -294,6 +294,15 @@ skip_pgd:
|
|||
msr sctlr_el1, x18
|
||||
isb
|
||||
|
||||
/*
|
||||
* Invalidate the local I-cache so that any instructions fetched
|
||||
* speculatively from the PoC are discarded, since they may have
|
||||
* been dynamically patched at the PoU.
|
||||
*/
|
||||
ic iallu
|
||||
dsb nsh
|
||||
isb
|
||||
|
||||
/* Set the flag to zero to indicate that we're all done */
|
||||
str wzr, [flag_ptr]
|
||||
ret
|
||||
|
|
|
|||
|
|
@ -914,10 +914,14 @@ module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mo
|
|||
void
|
||||
module_arch_cleanup (struct module *mod)
|
||||
{
|
||||
if (mod->arch.init_unw_table)
|
||||
if (mod->arch.init_unw_table) {
|
||||
unw_remove_unwind_table(mod->arch.init_unw_table);
|
||||
if (mod->arch.core_unw_table)
|
||||
mod->arch.init_unw_table = NULL;
|
||||
}
|
||||
if (mod->arch.core_unw_table) {
|
||||
unw_remove_unwind_table(mod->arch.core_unw_table);
|
||||
mod->arch.core_unw_table = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void *dereference_module_function_descriptor(struct module *mod, void *ptr)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@
|
|||
|
||||
#include <linux/types.h>
|
||||
#include <asm/bootinfo-atari.h>
|
||||
#include <asm/raw_io.h>
|
||||
#include <asm/kmap.h>
|
||||
|
||||
extern u_long atari_mch_cookie;
|
||||
|
|
@ -126,14 +125,6 @@ extern struct atari_hw_present atari_hw_present;
|
|||
*/
|
||||
|
||||
|
||||
#define atari_readb raw_inb
|
||||
#define atari_writeb raw_outb
|
||||
|
||||
#define atari_inb_p raw_inb
|
||||
#define atari_outb_p raw_outb
|
||||
|
||||
|
||||
|
||||
#include <linux/mm.h>
|
||||
#include <asm/cacheflush.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,11 @@
|
|||
#include <asm-generic/iomap.h>
|
||||
|
||||
#ifdef CONFIG_ATARI
|
||||
#include <asm/atarihw.h>
|
||||
#define atari_readb raw_inb
|
||||
#define atari_writeb raw_outb
|
||||
|
||||
#define atari_inb_p raw_inb
|
||||
#define atari_outb_p raw_outb
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/irq.h>
|
||||
|
||||
#include <asm/bootinfo-mac.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -57,9 +57,9 @@ static void export_imc_mode_and_cmd(struct device_node *node,
|
|||
struct imc_pmu *pmu_ptr)
|
||||
{
|
||||
static u64 loc, *imc_mode_addr, *imc_cmd_addr;
|
||||
int chip = 0, nid;
|
||||
char mode[16], cmd[16];
|
||||
u32 cb_offset;
|
||||
struct imc_mem_info *ptr = pmu_ptr->mem_info;
|
||||
|
||||
imc_debugfs_parent = debugfs_create_dir("imc", powerpc_debugfs_root);
|
||||
|
||||
|
|
@ -73,20 +73,20 @@ static void export_imc_mode_and_cmd(struct device_node *node,
|
|||
if (of_property_read_u32(node, "cb_offset", &cb_offset))
|
||||
cb_offset = IMC_CNTL_BLK_OFFSET;
|
||||
|
||||
for_each_node(nid) {
|
||||
loc = (u64)(pmu_ptr->mem_info[chip].vbase) + cb_offset;
|
||||
while (ptr->vbase != NULL) {
|
||||
loc = (u64)(ptr->vbase) + cb_offset;
|
||||
imc_mode_addr = (u64 *)(loc + IMC_CNTL_BLK_MODE_OFFSET);
|
||||
sprintf(mode, "imc_mode_%d", nid);
|
||||
sprintf(mode, "imc_mode_%d", (u32)(ptr->id));
|
||||
if (!imc_debugfs_create_x64(mode, 0600, imc_debugfs_parent,
|
||||
imc_mode_addr))
|
||||
goto err;
|
||||
|
||||
imc_cmd_addr = (u64 *)(loc + IMC_CNTL_BLK_CMD_OFFSET);
|
||||
sprintf(cmd, "imc_cmd_%d", nid);
|
||||
sprintf(cmd, "imc_cmd_%d", (u32)(ptr->id));
|
||||
if (!imc_debugfs_create_x64(cmd, 0600, imc_debugfs_parent,
|
||||
imc_cmd_addr))
|
||||
goto err;
|
||||
chip++;
|
||||
ptr++;
|
||||
}
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -585,6 +585,9 @@ static int xts_aes_encrypt(struct blkcipher_desc *desc,
|
|||
struct s390_xts_ctx *xts_ctx = crypto_blkcipher_ctx(desc->tfm);
|
||||
struct blkcipher_walk walk;
|
||||
|
||||
if (!nbytes)
|
||||
return -EINVAL;
|
||||
|
||||
if (unlikely(!xts_ctx->fc))
|
||||
return xts_fallback_encrypt(desc, dst, src, nbytes);
|
||||
|
||||
|
|
@ -599,6 +602,9 @@ static int xts_aes_decrypt(struct blkcipher_desc *desc,
|
|||
struct s390_xts_ctx *xts_ctx = crypto_blkcipher_ctx(desc->tfm);
|
||||
struct blkcipher_walk walk;
|
||||
|
||||
if (!nbytes)
|
||||
return -EINVAL;
|
||||
|
||||
if (unlikely(!xts_ctx->fc))
|
||||
return xts_fallback_decrypt(desc, dst, src, nbytes);
|
||||
|
||||
|
|
|
|||
|
|
@ -58,6 +58,9 @@
|
|||
#define INTEL_FAM6_ICELAKE_MOBILE 0x7E
|
||||
#define INTEL_FAM6_ICELAKE_NNPI 0x9D
|
||||
|
||||
#define INTEL_FAM6_TIGERLAKE_L 0x8C
|
||||
#define INTEL_FAM6_TIGERLAKE 0x8D
|
||||
|
||||
/* "Small Core" Processors (Atom) */
|
||||
|
||||
#define INTEL_FAM6_ATOM_BONNELL 0x1C /* Diamondville, Pineview */
|
||||
|
|
|
|||
|
|
@ -1450,54 +1450,72 @@ static void lapic_setup_esr(void)
|
|||
oldvalue, value);
|
||||
}
|
||||
|
||||
#define APIC_IR_REGS APIC_ISR_NR
|
||||
#define APIC_IR_BITS (APIC_IR_REGS * 32)
|
||||
#define APIC_IR_MAPSIZE (APIC_IR_BITS / BITS_PER_LONG)
|
||||
|
||||
union apic_ir {
|
||||
unsigned long map[APIC_IR_MAPSIZE];
|
||||
u32 regs[APIC_IR_REGS];
|
||||
};
|
||||
|
||||
static bool apic_check_and_ack(union apic_ir *irr, union apic_ir *isr)
|
||||
{
|
||||
int i, bit;
|
||||
|
||||
/* Read the IRRs */
|
||||
for (i = 0; i < APIC_IR_REGS; i++)
|
||||
irr->regs[i] = apic_read(APIC_IRR + i * 0x10);
|
||||
|
||||
/* Read the ISRs */
|
||||
for (i = 0; i < APIC_IR_REGS; i++)
|
||||
isr->regs[i] = apic_read(APIC_ISR + i * 0x10);
|
||||
|
||||
/*
|
||||
* If the ISR map is not empty. ACK the APIC and run another round
|
||||
* to verify whether a pending IRR has been unblocked and turned
|
||||
* into a ISR.
|
||||
*/
|
||||
if (!bitmap_empty(isr->map, APIC_IR_BITS)) {
|
||||
/*
|
||||
* There can be multiple ISR bits set when a high priority
|
||||
* interrupt preempted a lower priority one. Issue an ACK
|
||||
* per set bit.
|
||||
*/
|
||||
for_each_set_bit(bit, isr->map, APIC_IR_BITS)
|
||||
ack_APIC_irq();
|
||||
return true;
|
||||
}
|
||||
|
||||
return !bitmap_empty(irr->map, APIC_IR_BITS);
|
||||
}
|
||||
|
||||
/*
|
||||
* After a crash, we no longer service the interrupts and a pending
|
||||
* interrupt from previous kernel might still have ISR bit set.
|
||||
*
|
||||
* Most probably by now the CPU has serviced that pending interrupt and it
|
||||
* might not have done the ack_APIC_irq() because it thought, interrupt
|
||||
* came from i8259 as ExtInt. LAPIC did not get EOI so it does not clear
|
||||
* the ISR bit and cpu thinks it has already serivced the interrupt. Hence
|
||||
* a vector might get locked. It was noticed for timer irq (vector
|
||||
* 0x31). Issue an extra EOI to clear ISR.
|
||||
*
|
||||
* If there are pending IRR bits they turn into ISR bits after a higher
|
||||
* priority ISR bit has been acked.
|
||||
*/
|
||||
static void apic_pending_intr_clear(void)
|
||||
{
|
||||
long long max_loops = cpu_khz ? cpu_khz : 1000000;
|
||||
unsigned long long tsc = 0, ntsc;
|
||||
unsigned int queued;
|
||||
unsigned long value;
|
||||
int i, j, acked = 0;
|
||||
union apic_ir irr, isr;
|
||||
unsigned int i;
|
||||
|
||||
if (boot_cpu_has(X86_FEATURE_TSC))
|
||||
tsc = rdtsc();
|
||||
/*
|
||||
* After a crash, we no longer service the interrupts and a pending
|
||||
* interrupt from previous kernel might still have ISR bit set.
|
||||
*
|
||||
* Most probably by now CPU has serviced that pending interrupt and
|
||||
* it might not have done the ack_APIC_irq() because it thought,
|
||||
* interrupt came from i8259 as ExtInt. LAPIC did not get EOI so it
|
||||
* does not clear the ISR bit and cpu thinks it has already serivced
|
||||
* the interrupt. Hence a vector might get locked. It was noticed
|
||||
* for timer irq (vector 0x31). Issue an extra EOI to clear ISR.
|
||||
*/
|
||||
do {
|
||||
queued = 0;
|
||||
for (i = APIC_ISR_NR - 1; i >= 0; i--)
|
||||
queued |= apic_read(APIC_IRR + i*0x10);
|
||||
|
||||
for (i = APIC_ISR_NR - 1; i >= 0; i--) {
|
||||
value = apic_read(APIC_ISR + i*0x10);
|
||||
for_each_set_bit(j, &value, 32) {
|
||||
ack_APIC_irq();
|
||||
acked++;
|
||||
}
|
||||
}
|
||||
if (acked > 256) {
|
||||
pr_err("LAPIC pending interrupts after %d EOI\n", acked);
|
||||
break;
|
||||
}
|
||||
if (queued) {
|
||||
if (boot_cpu_has(X86_FEATURE_TSC) && cpu_khz) {
|
||||
ntsc = rdtsc();
|
||||
max_loops = (long long)cpu_khz << 10;
|
||||
max_loops -= ntsc - tsc;
|
||||
} else {
|
||||
max_loops--;
|
||||
}
|
||||
}
|
||||
} while (queued && max_loops > 0);
|
||||
WARN_ON(max_loops <= 0);
|
||||
/* 512 loops are way oversized and give the APIC a chance to obey. */
|
||||
for (i = 0; i < 512; i++) {
|
||||
if (!apic_check_and_ack(&irr, &isr))
|
||||
return;
|
||||
}
|
||||
/* Dump the IRR/ISR content if that failed */
|
||||
pr_warn("APIC: Stale IRR: %256pb ISR: %256pb\n", irr.map, isr.map);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1520,6 +1538,14 @@ static void setup_local_APIC(void)
|
|||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* If this comes from kexec/kcrash the APIC might be enabled in
|
||||
* SPIV. Soft disable it before doing further initialization.
|
||||
*/
|
||||
value = apic_read(APIC_SPIV);
|
||||
value &= ~APIC_SPIV_APIC_ENABLED;
|
||||
apic_write(APIC_SPIV, value);
|
||||
|
||||
#ifdef CONFIG_X86_32
|
||||
/* Pound the ESR really hard over the head with a big hammer - mbligh */
|
||||
if (lapic_is_integrated() && apic->disable_esr) {
|
||||
|
|
@ -1565,6 +1591,7 @@ static void setup_local_APIC(void)
|
|||
value &= ~APIC_TPRI_MASK;
|
||||
apic_write(APIC_TASKPRI, value);
|
||||
|
||||
/* Clear eventually stale ISR/IRR bits */
|
||||
apic_pending_intr_clear();
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -400,6 +400,17 @@ static int activate_reserved(struct irq_data *irqd)
|
|||
if (!irqd_can_reserve(irqd))
|
||||
apicd->can_reserve = false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check to ensure that the effective affinity mask is a subset
|
||||
* the user supplied affinity mask, and warn the user if it is not
|
||||
*/
|
||||
if (!cpumask_subset(irq_data_get_effective_affinity_mask(irqd),
|
||||
irq_data_get_affinity_mask(irqd))) {
|
||||
pr_warn("irq %u: Affinity broken due to vector space exhaustion.\n",
|
||||
irqd->irq);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -181,6 +181,12 @@ asmlinkage __visible void smp_reboot_interrupt(void)
|
|||
irq_exit();
|
||||
}
|
||||
|
||||
static int register_stop_handler(void)
|
||||
{
|
||||
return register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback,
|
||||
NMI_FLAG_FIRST, "smp_stop");
|
||||
}
|
||||
|
||||
static void native_stop_other_cpus(int wait)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
|
@ -214,39 +220,41 @@ static void native_stop_other_cpus(int wait)
|
|||
apic->send_IPI_allbutself(REBOOT_VECTOR);
|
||||
|
||||
/*
|
||||
* Don't wait longer than a second if the caller
|
||||
* didn't ask us to wait.
|
||||
* Don't wait longer than a second for IPI completion. The
|
||||
* wait request is not checked here because that would
|
||||
* prevent an NMI shutdown attempt in case that not all
|
||||
* CPUs reach shutdown state.
|
||||
*/
|
||||
timeout = USEC_PER_SEC;
|
||||
while (num_online_cpus() > 1 && (wait || timeout--))
|
||||
while (num_online_cpus() > 1 && timeout--)
|
||||
udelay(1);
|
||||
}
|
||||
|
||||
|
||||
/* if the REBOOT_VECTOR didn't work, try with the NMI */
|
||||
if ((num_online_cpus() > 1) && (!smp_no_nmi_ipi)) {
|
||||
if (register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback,
|
||||
NMI_FLAG_FIRST, "smp_stop"))
|
||||
/* Note: we ignore failures here */
|
||||
/* Hope the REBOOT_IRQ is good enough */
|
||||
goto finish;
|
||||
|
||||
/* sync above data before sending IRQ */
|
||||
wmb();
|
||||
|
||||
pr_emerg("Shutting down cpus with NMI\n");
|
||||
|
||||
apic->send_IPI_allbutself(NMI_VECTOR);
|
||||
|
||||
if (num_online_cpus() > 1) {
|
||||
/*
|
||||
* Don't wait longer than a 10 ms if the caller
|
||||
* didn't ask us to wait.
|
||||
* If NMI IPI is enabled, try to register the stop handler
|
||||
* and send the IPI. In any case try to wait for the other
|
||||
* CPUs to stop.
|
||||
*/
|
||||
if (!smp_no_nmi_ipi && !register_stop_handler()) {
|
||||
/* Sync above data before sending IRQ */
|
||||
wmb();
|
||||
|
||||
pr_emerg("Shutting down cpus with NMI\n");
|
||||
|
||||
apic->send_IPI_allbutself(NMI_VECTOR);
|
||||
}
|
||||
/*
|
||||
* Don't wait longer than 10 ms if the caller didn't
|
||||
* reqeust it. If wait is true, the machine hangs here if
|
||||
* one or more CPUs do not reach shutdown state.
|
||||
*/
|
||||
timeout = USEC_PER_MSEC * 10;
|
||||
while (num_online_cpus() > 1 && (wait || timeout--))
|
||||
udelay(1);
|
||||
}
|
||||
|
||||
finish:
|
||||
local_irq_save(flags);
|
||||
disable_local_APIC();
|
||||
mcheck_cpu_clear(this_cpu_ptr(&cpu_info));
|
||||
|
|
|
|||
|
|
@ -5368,6 +5368,8 @@ done_prefixes:
|
|||
ctxt->memopp->addr.mem.ea + ctxt->_eip);
|
||||
|
||||
done:
|
||||
if (rc == X86EMUL_PROPAGATE_FAULT)
|
||||
ctxt->have_exception = true;
|
||||
return (rc != X86EMUL_CONTINUE) ? EMULATION_FAILED : EMULATION_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -581,8 +581,14 @@ static int kvm_read_nested_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn,
|
|||
data, offset, len, access);
|
||||
}
|
||||
|
||||
static inline u64 pdptr_rsvd_bits(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return rsvd_bits(cpuid_maxphyaddr(vcpu), 63) | rsvd_bits(5, 8) |
|
||||
rsvd_bits(1, 2);
|
||||
}
|
||||
|
||||
/*
|
||||
* Load the pae pdptrs. Return true is they are all valid.
|
||||
* Load the pae pdptrs. Return 1 if they are all valid, 0 otherwise.
|
||||
*/
|
||||
int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3)
|
||||
{
|
||||
|
|
@ -601,8 +607,7 @@ int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3)
|
|||
}
|
||||
for (i = 0; i < ARRAY_SIZE(pdpte); ++i) {
|
||||
if ((pdpte[i] & PT_PRESENT_MASK) &&
|
||||
(pdpte[i] &
|
||||
vcpu->arch.mmu.guest_rsvd_check.rsvd_bits_mask[0][2])) {
|
||||
(pdpte[i] & pdptr_rsvd_bits(vcpu))) {
|
||||
ret = 0;
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -6244,8 +6249,16 @@ int x86_emulate_instruction(struct kvm_vcpu *vcpu,
|
|||
if (reexecute_instruction(vcpu, cr2, write_fault_to_spt,
|
||||
emulation_type))
|
||||
return EMULATE_DONE;
|
||||
if (ctxt->have_exception && inject_emulated_exception(vcpu))
|
||||
if (ctxt->have_exception) {
|
||||
/*
|
||||
* #UD should result in just EMULATION_FAILED, and trap-like
|
||||
* exception should not be encountered during decode.
|
||||
*/
|
||||
WARN_ON_ONCE(ctxt->exception.vector == UD_VECTOR ||
|
||||
exception_type(ctxt->exception.vector) == EXCPT_TRAP);
|
||||
inject_emulated_exception(vcpu);
|
||||
return EMULATE_DONE;
|
||||
}
|
||||
if (emulation_type & EMULTYPE_SKIP)
|
||||
return EMULATE_FAIL;
|
||||
return handle_emulation_failure(vcpu, emulation_type);
|
||||
|
|
|
|||
|
|
@ -338,13 +338,15 @@ pti_clone_pgtable(unsigned long start, unsigned long end,
|
|||
|
||||
pud = pud_offset(p4d, addr);
|
||||
if (pud_none(*pud)) {
|
||||
addr += PUD_SIZE;
|
||||
WARN_ON_ONCE(addr & ~PUD_MASK);
|
||||
addr = round_up(addr + 1, PUD_SIZE);
|
||||
continue;
|
||||
}
|
||||
|
||||
pmd = pmd_offset(pud, addr);
|
||||
if (pmd_none(*pmd)) {
|
||||
addr += PMD_SIZE;
|
||||
WARN_ON_ONCE(addr & ~PMD_MASK);
|
||||
addr = round_up(addr + 1, PMD_SIZE);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -643,6 +645,8 @@ void __init pti_init(void)
|
|||
*/
|
||||
void pti_finalize(void)
|
||||
{
|
||||
if (!boot_cpu_has(X86_FEATURE_PTI))
|
||||
return;
|
||||
/*
|
||||
* We need to clone everything (again) that maps parts of the
|
||||
* kernel image.
|
||||
|
|
|
|||
|
|
@ -232,6 +232,16 @@ static void flush_end_io(struct request *flush_rq, blk_status_t error)
|
|||
|
||||
/* release the tag's ownership to the req cloned from */
|
||||
spin_lock_irqsave(&fq->mq_flush_lock, flags);
|
||||
|
||||
if (!refcount_dec_and_test(&flush_rq->ref)) {
|
||||
fq->rq_status = error;
|
||||
spin_unlock_irqrestore(&fq->mq_flush_lock, flags);
|
||||
return;
|
||||
}
|
||||
|
||||
if (fq->rq_status != BLK_STS_OK)
|
||||
error = fq->rq_status;
|
||||
|
||||
hctx = blk_mq_map_queue(q, flush_rq->mq_ctx->cpu);
|
||||
if (!q->elevator) {
|
||||
blk_mq_tag_set_rq(hctx, flush_rq->tag, fq->orig_rq);
|
||||
|
|
|
|||
|
|
@ -844,7 +844,10 @@ static void blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
|
|||
*/
|
||||
if (blk_mq_req_expired(rq, next))
|
||||
blk_mq_rq_timed_out(rq, reserved);
|
||||
if (refcount_dec_and_test(&rq->ref))
|
||||
|
||||
if (is_flush_rq(rq, hctx))
|
||||
rq->end_io(rq, 0);
|
||||
else if (refcount_dec_and_test(&rq->ref))
|
||||
__blk_mq_free_request(rq);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ struct blk_flush_queue {
|
|||
unsigned int flush_queue_delayed:1;
|
||||
unsigned int flush_pending_idx:1;
|
||||
unsigned int flush_running_idx:1;
|
||||
blk_status_t rq_status;
|
||||
unsigned long flush_pending_since;
|
||||
struct list_head flush_queue[2];
|
||||
struct list_head flush_data_in_flight;
|
||||
|
|
@ -123,6 +124,12 @@ static inline void __blk_get_queue(struct request_queue *q)
|
|||
kobject_get(&q->kobj);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
is_flush_rq(struct request *req, struct blk_mq_hw_ctx *hctx)
|
||||
{
|
||||
return hctx->fq->flush_rq == req;
|
||||
}
|
||||
|
||||
struct blk_flush_queue *blk_alloc_flush_queue(struct request_queue *q,
|
||||
int node, int cmd_size, gfp_t flags);
|
||||
void blk_free_flush_queue(struct blk_flush_queue *q);
|
||||
|
|
|
|||
|
|
@ -282,9 +282,13 @@ static int acpi_processor_get_info(struct acpi_device *device)
|
|||
}
|
||||
|
||||
if (acpi_duplicate_processor_id(pr->acpi_id)) {
|
||||
dev_err(&device->dev,
|
||||
"Failed to get unique processor _UID (0x%x)\n",
|
||||
pr->acpi_id);
|
||||
if (pr->acpi_id == 0xff)
|
||||
dev_info_once(&device->dev,
|
||||
"Entry not well-defined, consider updating BIOS\n");
|
||||
else
|
||||
dev_err(&device->dev,
|
||||
"Failed to get unique processor _UID (0x%x)\n",
|
||||
pr->acpi_id);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -369,8 +369,10 @@ static int acpi_get_psd(struct cpc_desc *cpc_ptr, acpi_handle handle)
|
|||
union acpi_object *psd = NULL;
|
||||
struct acpi_psd_package *pdomain;
|
||||
|
||||
status = acpi_evaluate_object_typed(handle, "_PSD", NULL, &buffer,
|
||||
ACPI_TYPE_PACKAGE);
|
||||
status = acpi_evaluate_object_typed(handle, "_PSD", NULL,
|
||||
&buffer, ACPI_TYPE_PACKAGE);
|
||||
if (status == AE_NOT_FOUND) /* _PSD is optional */
|
||||
return 0;
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
|
|
|
|||
|
|
@ -48,8 +48,10 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,
|
|||
if ((*ppos > max_size) ||
|
||||
(*ppos + count > max_size) ||
|
||||
(*ppos + count < count) ||
|
||||
(count > uncopied_bytes))
|
||||
(count > uncopied_bytes)) {
|
||||
kfree(buf);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user(buf + (*ppos), user_buf, count)) {
|
||||
kfree(buf);
|
||||
|
|
@ -69,6 +71,7 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,
|
|||
add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
|
||||
}
|
||||
|
||||
kfree(buf);
|
||||
return count;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -462,8 +462,10 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
|
|||
* No IRQ known to the ACPI subsystem - maybe the BIOS /
|
||||
* driver reported one, then use it. Exit in any case.
|
||||
*/
|
||||
if (!acpi_pci_irq_valid(dev, pin))
|
||||
if (!acpi_pci_irq_valid(dev, pin)) {
|
||||
kfree(entry);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (acpi_isa_register_gsi(dev))
|
||||
dev_warn(&dev->dev, "PCI INT %c: no GSI\n",
|
||||
|
|
|
|||
|
|
@ -81,6 +81,12 @@ enum board_ids {
|
|||
board_ahci_sb700, /* for SB700 and SB800 */
|
||||
board_ahci_vt8251,
|
||||
|
||||
/*
|
||||
* board IDs for Intel chipsets that support more than 6 ports
|
||||
* *and* end up needing the PCS quirk.
|
||||
*/
|
||||
board_ahci_pcs7,
|
||||
|
||||
/* aliases */
|
||||
board_ahci_mcp_linux = board_ahci_mcp65,
|
||||
board_ahci_mcp67 = board_ahci_mcp65,
|
||||
|
|
@ -236,6 +242,12 @@ static const struct ata_port_info ahci_port_info[] = {
|
|||
.udma_mask = ATA_UDMA6,
|
||||
.port_ops = &ahci_vt8251_ops,
|
||||
},
|
||||
[board_ahci_pcs7] = {
|
||||
.flags = AHCI_FLAG_COMMON,
|
||||
.pio_mask = ATA_PIO4,
|
||||
.udma_mask = ATA_UDMA6,
|
||||
.port_ops = &ahci_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static const struct pci_device_id ahci_pci_tbl[] = {
|
||||
|
|
@ -280,26 +292,26 @@ static const struct pci_device_id ahci_pci_tbl[] = {
|
|||
{ PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */
|
||||
{ PCI_VDEVICE(INTEL, 0x3b2c), board_ahci_mobile }, /* PCH M RAID */
|
||||
{ PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b0), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b1), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b2), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b3), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b4), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b5), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b6), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b7), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19bE), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19bF), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c0), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c1), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c2), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c3), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c4), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c5), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c6), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c7), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19cE), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19cF), board_ahci }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b0), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b1), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b2), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b3), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b4), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b5), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b6), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19b7), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19bE), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19bF), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c0), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c1), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c2), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c3), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c4), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c5), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c6), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19c7), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19cE), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x19cF), board_ahci_pcs7 }, /* DNV AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x1c02), board_ahci }, /* CPT AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x1c03), board_ahci_mobile }, /* CPT M AHCI */
|
||||
{ PCI_VDEVICE(INTEL, 0x1c04), board_ahci }, /* CPT RAID */
|
||||
|
|
@ -639,30 +651,6 @@ static void ahci_pci_save_initial_config(struct pci_dev *pdev,
|
|||
ahci_save_initial_config(&pdev->dev, hpriv);
|
||||
}
|
||||
|
||||
static int ahci_pci_reset_controller(struct ata_host *host)
|
||||
{
|
||||
struct pci_dev *pdev = to_pci_dev(host->dev);
|
||||
int rc;
|
||||
|
||||
rc = ahci_reset_controller(host);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
|
||||
struct ahci_host_priv *hpriv = host->private_data;
|
||||
u16 tmp16;
|
||||
|
||||
/* configure PCS */
|
||||
pci_read_config_word(pdev, 0x92, &tmp16);
|
||||
if ((tmp16 & hpriv->port_map) != hpriv->port_map) {
|
||||
tmp16 |= hpriv->port_map;
|
||||
pci_write_config_word(pdev, 0x92, tmp16);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ahci_pci_init_controller(struct ata_host *host)
|
||||
{
|
||||
struct ahci_host_priv *hpriv = host->private_data;
|
||||
|
|
@ -865,7 +853,7 @@ static int ahci_pci_device_runtime_resume(struct device *dev)
|
|||
struct ata_host *host = pci_get_drvdata(pdev);
|
||||
int rc;
|
||||
|
||||
rc = ahci_pci_reset_controller(host);
|
||||
rc = ahci_reset_controller(host);
|
||||
if (rc)
|
||||
return rc;
|
||||
ahci_pci_init_controller(host);
|
||||
|
|
@ -900,7 +888,7 @@ static int ahci_pci_device_resume(struct device *dev)
|
|||
ahci_mcp89_apple_enable(pdev);
|
||||
|
||||
if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
|
||||
rc = ahci_pci_reset_controller(host);
|
||||
rc = ahci_reset_controller(host);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
|
|
@ -1635,6 +1623,34 @@ update_policy:
|
|||
ap->target_lpm_policy = policy;
|
||||
}
|
||||
|
||||
static void ahci_intel_pcs_quirk(struct pci_dev *pdev, struct ahci_host_priv *hpriv)
|
||||
{
|
||||
const struct pci_device_id *id = pci_match_id(ahci_pci_tbl, pdev);
|
||||
u16 tmp16;
|
||||
|
||||
/*
|
||||
* Only apply the 6-port PCS quirk for known legacy platforms.
|
||||
*/
|
||||
if (!id || id->vendor != PCI_VENDOR_ID_INTEL)
|
||||
return;
|
||||
if (((enum board_ids) id->driver_data) < board_ahci_pcs7)
|
||||
return;
|
||||
|
||||
/*
|
||||
* port_map is determined from PORTS_IMPL PCI register which is
|
||||
* implemented as write or write-once register. If the register
|
||||
* isn't programmed, ahci automatically generates it from number
|
||||
* of ports, which is good enough for PCS programming. It is
|
||||
* otherwise expected that platform firmware enables the ports
|
||||
* before the OS boots.
|
||||
*/
|
||||
pci_read_config_word(pdev, PCS_6, &tmp16);
|
||||
if ((tmp16 & hpriv->port_map) != hpriv->port_map) {
|
||||
tmp16 |= hpriv->port_map;
|
||||
pci_write_config_word(pdev, PCS_6, tmp16);
|
||||
}
|
||||
}
|
||||
|
||||
static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
||||
{
|
||||
unsigned int board_id = ent->driver_data;
|
||||
|
|
@ -1747,6 +1763,12 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
/* save initial config */
|
||||
ahci_pci_save_initial_config(pdev, hpriv);
|
||||
|
||||
/*
|
||||
* If platform firmware failed to enable ports, try to enable
|
||||
* them here.
|
||||
*/
|
||||
ahci_intel_pcs_quirk(pdev, hpriv);
|
||||
|
||||
/* prepare host */
|
||||
if (hpriv->cap & HOST_CAP_NCQ) {
|
||||
pi.flags |= ATA_FLAG_NCQ;
|
||||
|
|
@ -1856,7 +1878,7 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
if (rc)
|
||||
return rc;
|
||||
|
||||
rc = ahci_pci_reset_controller(host);
|
||||
rc = ahci_reset_controller(host);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
|
|
|
|||
|
|
@ -261,6 +261,8 @@ enum {
|
|||
ATA_FLAG_ACPI_SATA | ATA_FLAG_AN,
|
||||
|
||||
ICH_MAP = 0x90, /* ICH MAP register */
|
||||
PCS_6 = 0x92, /* 6 port PCS */
|
||||
PCS_7 = 0x94, /* 7+ port PCS (Denverton) */
|
||||
|
||||
/* em constants */
|
||||
EM_MAX_SLOTS = 8,
|
||||
|
|
|
|||
|
|
@ -157,6 +157,7 @@ out2:
|
|||
out1:
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(soc_device_register);
|
||||
|
||||
/* Ensure soc_dev->attr is freed prior to calling soc_device_unregister. */
|
||||
void soc_device_unregister(struct soc_device *soc_dev)
|
||||
|
|
@ -166,6 +167,7 @@ void soc_device_unregister(struct soc_device *soc_dev)
|
|||
device_unregister(&soc_dev->dev);
|
||||
early_soc_dev_attr = NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(soc_device_unregister);
|
||||
|
||||
static int __init soc_bus_register(void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1719,6 +1719,7 @@ static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode,
|
|||
case LOOP_SET_FD:
|
||||
case LOOP_CHANGE_FD:
|
||||
case LOOP_SET_BLOCK_SIZE:
|
||||
case LOOP_SET_DIRECT_IO:
|
||||
err = lo_ioctl(bdev, mode, cmd, arg);
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -353,8 +353,10 @@ static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req,
|
|||
}
|
||||
config = nbd->config;
|
||||
|
||||
if (!mutex_trylock(&cmd->lock))
|
||||
if (!mutex_trylock(&cmd->lock)) {
|
||||
nbd_config_put(nbd);
|
||||
return BLK_EH_RESET_TIMER;
|
||||
}
|
||||
|
||||
if (config->num_connections > 1) {
|
||||
dev_err_ratelimited(nbd_to_dev(nbd),
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ static void add_early_randomness(struct hwrng *rng)
|
|||
size_t size = min_t(size_t, 16, rng_buffer_size());
|
||||
|
||||
mutex_lock(&reading_mutex);
|
||||
bytes_read = rng_get_data(rng, rng_buffer, size, 1);
|
||||
bytes_read = rng_get_data(rng, rng_buffer, size, 0);
|
||||
mutex_unlock(&reading_mutex);
|
||||
if (bytes_read > 0)
|
||||
add_device_randomness(rng_buffer, bytes_read);
|
||||
|
|
|
|||
|
|
@ -97,6 +97,13 @@ void __weak unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
|
|||
}
|
||||
#endif
|
||||
|
||||
static inline bool should_stop_iteration(void)
|
||||
{
|
||||
if (need_resched())
|
||||
cond_resched();
|
||||
return fatal_signal_pending(current);
|
||||
}
|
||||
|
||||
/*
|
||||
* This funcion reads the *physical* memory. The f_pos points directly to the
|
||||
* memory location.
|
||||
|
|
@ -175,6 +182,8 @@ static ssize_t read_mem(struct file *file, char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
read += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
kfree(bounce);
|
||||
|
||||
|
|
@ -251,6 +260,8 @@ static ssize_t write_mem(struct file *file, const char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
written += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
|
||||
*ppos += written;
|
||||
|
|
@ -468,6 +479,10 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
|
|||
read += sz;
|
||||
low_count -= sz;
|
||||
count -= sz;
|
||||
if (should_stop_iteration()) {
|
||||
count = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -492,6 +507,8 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
|
|||
buf += sz;
|
||||
read += sz;
|
||||
p += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
free_page((unsigned long)kbuf);
|
||||
}
|
||||
|
|
@ -544,6 +561,8 @@ static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
written += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
|
||||
*ppos += written;
|
||||
|
|
@ -595,6 +614,8 @@ static ssize_t write_kmem(struct file *file, const char __user *buf,
|
|||
buf += sz;
|
||||
virtr += sz;
|
||||
p += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
free_page((unsigned long)kbuf);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -194,11 +194,10 @@ static void exynos_bus_exit(struct device *dev)
|
|||
if (ret < 0)
|
||||
dev_warn(dev, "failed to disable the devfreq-event devices\n");
|
||||
|
||||
if (bus->regulator)
|
||||
regulator_disable(bus->regulator);
|
||||
|
||||
dev_pm_opp_of_remove_table(dev);
|
||||
clk_disable_unprepare(bus->clk);
|
||||
if (bus->regulator)
|
||||
regulator_disable(bus->regulator);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -386,6 +385,7 @@ static int exynos_bus_probe(struct platform_device *pdev)
|
|||
struct exynos_bus *bus;
|
||||
int ret, max_state;
|
||||
unsigned long min_freq, max_freq;
|
||||
bool passive = false;
|
||||
|
||||
if (!np) {
|
||||
dev_err(dev, "failed to find devicetree node\n");
|
||||
|
|
@ -399,27 +399,27 @@ static int exynos_bus_probe(struct platform_device *pdev)
|
|||
bus->dev = &pdev->dev;
|
||||
platform_set_drvdata(pdev, bus);
|
||||
|
||||
/* Parse the device-tree to get the resource information */
|
||||
ret = exynos_bus_parse_of(np, bus);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
profile = devm_kzalloc(dev, sizeof(*profile), GFP_KERNEL);
|
||||
if (!profile) {
|
||||
ret = -ENOMEM;
|
||||
goto err;
|
||||
}
|
||||
if (!profile)
|
||||
return -ENOMEM;
|
||||
|
||||
node = of_parse_phandle(dev->of_node, "devfreq", 0);
|
||||
if (node) {
|
||||
of_node_put(node);
|
||||
goto passive;
|
||||
passive = true;
|
||||
} else {
|
||||
ret = exynos_bus_parent_parse_of(np, bus);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Parse the device-tree to get the resource information */
|
||||
ret = exynos_bus_parse_of(np, bus);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
goto err_reg;
|
||||
|
||||
if (passive)
|
||||
goto passive;
|
||||
|
||||
/* Initialize the struct profile and governor data for parent device */
|
||||
profile->polling_ms = 50;
|
||||
|
|
@ -510,6 +510,9 @@ out:
|
|||
err:
|
||||
dev_pm_opp_of_remove_table(dev);
|
||||
clk_disable_unprepare(bus->clk);
|
||||
err_reg:
|
||||
if (!passive)
|
||||
regulator_disable(bus->regulator);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -152,7 +152,6 @@ static int devfreq_passive_notifier_call(struct notifier_block *nb,
|
|||
static int devfreq_passive_event_handler(struct devfreq *devfreq,
|
||||
unsigned int event, void *data)
|
||||
{
|
||||
struct device *dev = devfreq->dev.parent;
|
||||
struct devfreq_passive_data *p_data
|
||||
= (struct devfreq_passive_data *)devfreq->data;
|
||||
struct devfreq *parent = (struct devfreq *)p_data->parent;
|
||||
|
|
@ -168,12 +167,12 @@ static int devfreq_passive_event_handler(struct devfreq *devfreq,
|
|||
p_data->this = devfreq;
|
||||
|
||||
nb->notifier_call = devfreq_passive_notifier_call;
|
||||
ret = devm_devfreq_register_notifier(dev, parent, nb,
|
||||
ret = devfreq_register_notifier(parent, nb,
|
||||
DEVFREQ_TRANSITION_NOTIFIER);
|
||||
break;
|
||||
case DEVFREQ_GOV_STOP:
|
||||
devm_devfreq_unregister_notifier(dev, parent, nb,
|
||||
DEVFREQ_TRANSITION_NOTIFIER);
|
||||
WARN_ON(devfreq_unregister_notifier(parent, nb,
|
||||
DEVFREQ_TRANSITION_NOTIFIER));
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -898,8 +898,10 @@ static int bcm2835_dma_probe(struct platform_device *pdev)
|
|||
pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
|
||||
|
||||
rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
|
||||
if (rc)
|
||||
if (rc) {
|
||||
dev_err(&pdev->dev, "Unable to set DMA mask\n");
|
||||
return rc;
|
||||
}
|
||||
|
||||
od = devm_kzalloc(&pdev->dev, sizeof(*od), GFP_KERNEL);
|
||||
if (!od)
|
||||
|
|
|
|||
|
|
@ -125,9 +125,9 @@ static void __iop_adma_slot_cleanup(struct iop_adma_chan *iop_chan)
|
|||
list_for_each_entry_safe(iter, _iter, &iop_chan->chain,
|
||||
chain_node) {
|
||||
pr_debug("\tcookie: %d slot: %d busy: %d "
|
||||
"this_desc: %#x next_desc: %#x ack: %d\n",
|
||||
"this_desc: %#x next_desc: %#llx ack: %d\n",
|
||||
iter->async_tx.cookie, iter->idx, busy,
|
||||
iter->async_tx.phys, iop_desc_get_next_desc(iter),
|
||||
iter->async_tx.phys, (u64)iop_desc_get_next_desc(iter),
|
||||
async_tx_test_ack(&iter->async_tx));
|
||||
prefetch(_iter);
|
||||
prefetch(&_iter->async_tx);
|
||||
|
|
@ -315,9 +315,9 @@ retry:
|
|||
int i;
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"allocated slot: %d "
|
||||
"(desc %p phys: %#x) slots_per_op %d\n",
|
||||
"(desc %p phys: %#llx) slots_per_op %d\n",
|
||||
iter->idx, iter->hw_desc,
|
||||
iter->async_tx.phys, slots_per_op);
|
||||
(u64)iter->async_tx.phys, slots_per_op);
|
||||
|
||||
/* pre-ack all but the last descriptor */
|
||||
if (num_slots != slots_per_op)
|
||||
|
|
@ -525,7 +525,7 @@ iop_adma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dma_dest,
|
|||
return NULL;
|
||||
BUG_ON(len > IOP_ADMA_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s len: %zu\n",
|
||||
__func__, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
|
@ -558,7 +558,7 @@ iop_adma_prep_dma_xor(struct dma_chan *chan, dma_addr_t dma_dest,
|
|||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"%s src_cnt: %d len: %u flags: %lx\n",
|
||||
"%s src_cnt: %d len: %zu flags: %lx\n",
|
||||
__func__, src_cnt, len, flags);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
|
@ -591,7 +591,7 @@ iop_adma_prep_dma_xor_val(struct dma_chan *chan, dma_addr_t *dma_src,
|
|||
if (unlikely(!len))
|
||||
return NULL;
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %zu\n",
|
||||
__func__, src_cnt, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
|
@ -629,7 +629,7 @@ iop_adma_prep_dma_pq(struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,
|
|||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"%s src_cnt: %d len: %u flags: %lx\n",
|
||||
"%s src_cnt: %d len: %zu flags: %lx\n",
|
||||
__func__, src_cnt, len, flags);
|
||||
|
||||
if (dmaf_p_disabled_continue(flags))
|
||||
|
|
@ -692,7 +692,7 @@ iop_adma_prep_dma_pq_val(struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
|
|||
return NULL;
|
||||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %zu\n",
|
||||
__func__, src_cnt, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
|
|
|||
|
|
@ -2273,9 +2273,6 @@ static int edma_probe(struct platform_device *pdev)
|
|||
|
||||
ecc->default_queue = info->default_queue;
|
||||
|
||||
for (i = 0; i < ecc->num_slots; i++)
|
||||
edma_write_slot(ecc, i, &dummy_paramset);
|
||||
|
||||
if (info->rsv) {
|
||||
/* Set the reserved slots in inuse list */
|
||||
rsv_slots = info->rsv->rsv_slots;
|
||||
|
|
@ -2288,6 +2285,12 @@ static int edma_probe(struct platform_device *pdev)
|
|||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < ecc->num_slots; i++) {
|
||||
/* Reset only unused - not reserved - paRAM slots */
|
||||
if (!test_bit(i, ecc->slot_inuse))
|
||||
edma_write_slot(ecc, i, &dummy_paramset);
|
||||
}
|
||||
|
||||
/* Clear the xbar mapped channels in unused list */
|
||||
xbar_chans = info->xbar_chans;
|
||||
if (xbar_chans) {
|
||||
|
|
|
|||
|
|
@ -1956,6 +1956,7 @@ static void altr_edac_a10_irq_handler(struct irq_desc *desc)
|
|||
struct altr_arria10_edac *edac = irq_desc_get_handler_data(desc);
|
||||
struct irq_chip *chip = irq_desc_get_chip(desc);
|
||||
int irq = irq_desc_get_irq(desc);
|
||||
unsigned long bits;
|
||||
|
||||
dberr = (irq == edac->db_irq) ? 1 : 0;
|
||||
sm_offset = dberr ? A10_SYSMGR_ECC_INTSTAT_DERR_OFST :
|
||||
|
|
@ -1965,7 +1966,8 @@ static void altr_edac_a10_irq_handler(struct irq_desc *desc)
|
|||
|
||||
regmap_read(edac->ecc_mgr_map, sm_offset, &irq_status);
|
||||
|
||||
for_each_set_bit(bit, (unsigned long *)&irq_status, 32) {
|
||||
bits = irq_status;
|
||||
for_each_set_bit(bit, &bits, 32) {
|
||||
irq = irq_linear_revmap(edac->domain, dberr * 32 + bit);
|
||||
if (irq)
|
||||
generic_handle_irq(irq);
|
||||
|
|
|
|||
|
|
@ -2501,13 +2501,6 @@ static void decode_umc_error(int node_id, struct mce *m)
|
|||
goto log_error;
|
||||
}
|
||||
|
||||
if (umc_normaddr_to_sysaddr(m->addr, pvt->mc_node_id, err.channel, &sys_addr)) {
|
||||
err.err_code = ERR_NORM_ADDR;
|
||||
goto log_error;
|
||||
}
|
||||
|
||||
error_address_to_page_and_offset(sys_addr, &err);
|
||||
|
||||
if (!(m->status & MCI_STATUS_SYNDV)) {
|
||||
err.err_code = ERR_SYND;
|
||||
goto log_error;
|
||||
|
|
@ -2524,6 +2517,13 @@ static void decode_umc_error(int node_id, struct mce *m)
|
|||
|
||||
err.csrow = m->synd & 0x7;
|
||||
|
||||
if (umc_normaddr_to_sysaddr(m->addr, pvt->mc_node_id, err.channel, &sys_addr)) {
|
||||
err.err_code = ERR_NORM_ADDR;
|
||||
goto log_error;
|
||||
}
|
||||
|
||||
error_address_to_page_and_offset(sys_addr, &err);
|
||||
|
||||
log_error:
|
||||
__log_ecc_error(mci, &err, ecc_type);
|
||||
}
|
||||
|
|
@ -3101,12 +3101,15 @@ static bool ecc_enabled(struct pci_dev *F3, u16 nid)
|
|||
static inline void
|
||||
f17h_determine_edac_ctl_cap(struct mem_ctl_info *mci, struct amd64_pvt *pvt)
|
||||
{
|
||||
u8 i, ecc_en = 1, cpk_en = 1;
|
||||
u8 i, ecc_en = 1, cpk_en = 1, dev_x4 = 1, dev_x16 = 1;
|
||||
|
||||
for (i = 0; i < NUM_UMCS; i++) {
|
||||
if (pvt->umc[i].sdp_ctrl & UMC_SDP_INIT) {
|
||||
ecc_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_ENABLED);
|
||||
cpk_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_CHIPKILL_CAP);
|
||||
|
||||
dev_x4 &= !!(pvt->umc[i].dimm_cfg & BIT(6));
|
||||
dev_x16 &= !!(pvt->umc[i].dimm_cfg & BIT(7));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3114,8 +3117,15 @@ f17h_determine_edac_ctl_cap(struct mem_ctl_info *mci, struct amd64_pvt *pvt)
|
|||
if (ecc_en) {
|
||||
mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
|
||||
|
||||
if (cpk_en)
|
||||
if (!cpk_en)
|
||||
return;
|
||||
|
||||
if (dev_x4)
|
||||
mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
|
||||
else if (dev_x16)
|
||||
mci->edac_ctl_cap |= EDAC_FLAG_S16ECD16ED;
|
||||
else
|
||||
mci->edac_ctl_cap |= EDAC_FLAG_S8ECD8ED;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1246,9 +1246,13 @@ void edac_mc_handle_error(const enum hw_event_mc_err_type type,
|
|||
if (p > e->location)
|
||||
*(p - 1) = '\0';
|
||||
|
||||
/* Report the error via the trace interface */
|
||||
grain_bits = fls_long(e->grain) + 1;
|
||||
/* Sanity-check driver-supplied grain value. */
|
||||
if (WARN_ON_ONCE(!e->grain))
|
||||
e->grain = 1;
|
||||
|
||||
grain_bits = fls_long(e->grain - 1);
|
||||
|
||||
/* Report the error via the trace interface */
|
||||
if (IS_ENABLED(CONFIG_RAS))
|
||||
trace_mc_event(type, e->msg, e->label, e->error_count,
|
||||
mci->mc_idx, e->top_layer, e->mid_layer,
|
||||
|
|
|
|||
|
|
@ -268,11 +268,14 @@ static u64 get_sideband_reg_base_addr(void)
|
|||
}
|
||||
}
|
||||
|
||||
#define DNV_MCHBAR_SIZE 0x8000
|
||||
#define DNV_SB_PORT_SIZE 0x10000
|
||||
static int dnv_rd_reg(int port, int off, int op, void *data, size_t sz, char *name)
|
||||
{
|
||||
struct pci_dev *pdev;
|
||||
char *base;
|
||||
u64 addr;
|
||||
unsigned long size;
|
||||
|
||||
if (op == 4) {
|
||||
pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x1980, NULL);
|
||||
|
|
@ -287,15 +290,17 @@ static int dnv_rd_reg(int port, int off, int op, void *data, size_t sz, char *na
|
|||
addr = get_mem_ctrl_hub_base_addr();
|
||||
if (!addr)
|
||||
return -ENODEV;
|
||||
size = DNV_MCHBAR_SIZE;
|
||||
} else {
|
||||
/* MMIO via sideband register base address */
|
||||
addr = get_sideband_reg_base_addr();
|
||||
if (!addr)
|
||||
return -ENODEV;
|
||||
addr += (port << 16);
|
||||
size = DNV_SB_PORT_SIZE;
|
||||
}
|
||||
|
||||
base = ioremap((resource_size_t)addr, 0x10000);
|
||||
base = ioremap((resource_size_t)addr, size);
|
||||
if (!base)
|
||||
return -ENODEV;
|
||||
|
||||
|
|
|
|||
|
|
@ -271,6 +271,14 @@ static void scmi_tx_prepare(struct mbox_client *cl, void *m)
|
|||
struct scmi_chan_info *cinfo = client_to_scmi_chan_info(cl);
|
||||
struct scmi_shared_mem __iomem *mem = cinfo->payload;
|
||||
|
||||
/*
|
||||
* Ideally channel must be free by now unless OS timeout last
|
||||
* request and platform continued to process the same, wait
|
||||
* until it releases the shared memory, otherwise we may endup
|
||||
* overwriting its response with new message payload or vice-versa
|
||||
*/
|
||||
spin_until_cond(ioread32(&mem->channel_status) &
|
||||
SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
|
||||
/* Mark channel busy + clear error */
|
||||
iowrite32(0x0, &mem->channel_status);
|
||||
iowrite32(t->hdr.poll_completion ? 0 : SCMI_SHMEM_FLAG_INTR_ENABLED,
|
||||
|
|
|
|||
|
|
@ -402,6 +402,21 @@ static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie,
|
|||
printk(
|
||||
"%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n",
|
||||
pfx, pcie->bridge.secondary_status, pcie->bridge.control);
|
||||
|
||||
/* Fatal errors call __ghes_panic() before AER handler prints this */
|
||||
if ((pcie->validation_bits & CPER_PCIE_VALID_AER_INFO) &&
|
||||
(gdata->error_severity & CPER_SEV_FATAL)) {
|
||||
struct aer_capability_regs *aer;
|
||||
|
||||
aer = (struct aer_capability_regs *)pcie->aer_info;
|
||||
printk("%saer_uncor_status: 0x%08x, aer_uncor_mask: 0x%08x\n",
|
||||
pfx, aer->uncor_status, aer->uncor_mask);
|
||||
printk("%saer_uncor_severity: 0x%08x\n",
|
||||
pfx, aer->uncor_severity);
|
||||
printk("%sTLP Header: %08x %08x %08x %08x\n", pfx,
|
||||
aer->header_log.dw0, aer->header_log.dw1,
|
||||
aer->header_log.dw2, aer->header_log.dw3);
|
||||
}
|
||||
}
|
||||
|
||||
static void cper_print_tstamp(const char *pfx,
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@
|
|||
#include <linux/init.h>
|
||||
#include <linux/cpumask.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/dma-direct.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/types.h>
|
||||
|
|
@ -449,6 +450,7 @@ int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
|
|||
phys_addr_t mem_to_map_phys;
|
||||
phys_addr_t dest_phys;
|
||||
phys_addr_t ptr_phys;
|
||||
dma_addr_t ptr_dma;
|
||||
size_t mem_to_map_sz;
|
||||
size_t dest_sz;
|
||||
size_t src_sz;
|
||||
|
|
@ -466,9 +468,10 @@ int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
|
|||
ptr_sz = ALIGN(src_sz, SZ_64) + ALIGN(mem_to_map_sz, SZ_64) +
|
||||
ALIGN(dest_sz, SZ_64);
|
||||
|
||||
ptr = dma_alloc_coherent(__scm->dev, ptr_sz, &ptr_phys, GFP_KERNEL);
|
||||
ptr = dma_alloc_coherent(__scm->dev, ptr_sz, &ptr_dma, GFP_KERNEL);
|
||||
if (!ptr)
|
||||
return -ENOMEM;
|
||||
ptr_phys = dma_to_phys(__scm->dev, ptr_dma);
|
||||
|
||||
/* Fill source vmid detail */
|
||||
src = ptr;
|
||||
|
|
@ -498,7 +501,7 @@ int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
|
|||
|
||||
ret = __qcom_scm_assign_mem(__scm->dev, mem_to_map_phys, mem_to_map_sz,
|
||||
ptr_phys, src_sz, dest_phys, dest_sz);
|
||||
dma_free_coherent(__scm->dev, ALIGN(ptr_sz, SZ_64), ptr, ptr_phys);
|
||||
dma_free_coherent(__scm->dev, ptr_sz, ptr, ptr_dma);
|
||||
if (ret) {
|
||||
dev_err(__scm->dev,
|
||||
"Assign memory protection call failed %d.\n", ret);
|
||||
|
|
|
|||
|
|
@ -1462,6 +1462,7 @@ static int amdgpu_dm_backlight_get_brightness(struct backlight_device *bd)
|
|||
}
|
||||
|
||||
static const struct backlight_ops amdgpu_dm_backlight_ops = {
|
||||
.options = BL_CORE_SUSPENDRESUME,
|
||||
.get_brightness = amdgpu_dm_backlight_get_brightness,
|
||||
.update_status = amdgpu_dm_backlight_update_status,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -4052,6 +4052,11 @@ static int smu7_program_display_gap(struct pp_hwmgr *hwmgr)
|
|||
|
||||
data->frame_time_x2 = frame_time_in_us * 2 / 100;
|
||||
|
||||
if (data->frame_time_x2 < 280) {
|
||||
pr_debug("%s: enforce minimal VBITimeout: %d -> 280\n", __func__, data->frame_time_x2);
|
||||
data->frame_time_x2 = 280;
|
||||
}
|
||||
|
||||
display_gap2 = pre_vbi_time_in_us * (ref_clock / 100);
|
||||
|
||||
cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC, ixCG_DISPLAY_GAP_CNTL2, display_gap2);
|
||||
|
|
|
|||
|
|
@ -694,8 +694,8 @@ static int setup_attrs(struct acpi_power_meter_resource *resource)
|
|||
|
||||
if (resource->caps.flags & POWER_METER_CAN_CAP) {
|
||||
if (!can_cap_in_hardware()) {
|
||||
dev_err(&resource->acpi_dev->dev,
|
||||
"Ignoring unsafe software power cap!\n");
|
||||
dev_warn(&resource->acpi_dev->dev,
|
||||
"Ignoring unsafe software power cap!\n");
|
||||
goto skip_unsafe_cap;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -203,6 +203,7 @@ static irqreturn_t riic_tend_isr(int irq, void *data)
|
|||
if (readb(riic->base + RIIC_ICSR2) & ICSR2_NACKF) {
|
||||
/* We got a NACKIE */
|
||||
readb(riic->base + RIIC_ICDRR); /* dummy read */
|
||||
riic_clear_set_bit(riic, ICSR2_NACKF, 0, RIIC_ICSR2);
|
||||
riic->err = -ENXIO;
|
||||
} else if (riic->bytes_left) {
|
||||
return IRQ_NONE;
|
||||
|
|
|
|||
|
|
@ -2326,7 +2326,7 @@ struct opa_port_status_req {
|
|||
__be32 vl_select_mask;
|
||||
};
|
||||
|
||||
#define VL_MASK_ALL 0x000080ff
|
||||
#define VL_MASK_ALL 0x00000000000080ffUL
|
||||
|
||||
struct opa_port_status_rsp {
|
||||
__u8 port_num;
|
||||
|
|
@ -2625,15 +2625,14 @@ static int pma_get_opa_classportinfo(struct opa_pma_mad *pmp,
|
|||
}
|
||||
|
||||
static void a0_portstatus(struct hfi1_pportdata *ppd,
|
||||
struct opa_port_status_rsp *rsp, u32 vl_select_mask)
|
||||
struct opa_port_status_rsp *rsp)
|
||||
{
|
||||
if (!is_bx(ppd->dd)) {
|
||||
unsigned long vl;
|
||||
u64 sum_vl_xmit_wait = 0;
|
||||
u32 vl_all_mask = VL_MASK_ALL;
|
||||
unsigned long vl_all_mask = VL_MASK_ALL;
|
||||
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_all_mask),
|
||||
8 * sizeof(vl_all_mask)) {
|
||||
for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {
|
||||
u64 tmp = sum_vl_xmit_wait +
|
||||
read_port_cntr(ppd, C_TX_WAIT_VL,
|
||||
idx_from_vl(vl));
|
||||
|
|
@ -2730,12 +2729,12 @@ static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
(struct opa_port_status_req *)pmp->data;
|
||||
struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
|
||||
struct opa_port_status_rsp *rsp;
|
||||
u32 vl_select_mask = be32_to_cpu(req->vl_select_mask);
|
||||
unsigned long vl_select_mask = be32_to_cpu(req->vl_select_mask);
|
||||
unsigned long vl;
|
||||
size_t response_data_size;
|
||||
u32 nports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
|
||||
u8 port_num = req->port_num;
|
||||
u8 num_vls = hweight32(vl_select_mask);
|
||||
u8 num_vls = hweight64(vl_select_mask);
|
||||
struct _vls_pctrs *vlinfo;
|
||||
struct hfi1_ibport *ibp = to_iport(ibdev, port);
|
||||
struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
|
||||
|
|
@ -2771,7 +2770,7 @@ static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
|
||||
hfi1_read_link_quality(dd, &rsp->link_quality_indicator);
|
||||
|
||||
rsp->vl_select_mask = cpu_to_be32(vl_select_mask);
|
||||
rsp->vl_select_mask = cpu_to_be32((u32)vl_select_mask);
|
||||
rsp->port_xmit_data = cpu_to_be64(read_dev_cntr(dd, C_DC_XMIT_FLITS,
|
||||
CNTR_INVALID_VL));
|
||||
rsp->port_rcv_data = cpu_to_be64(read_dev_cntr(dd, C_DC_RCV_FLITS,
|
||||
|
|
@ -2842,8 +2841,7 @@ static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
* So in the for_each_set_bit() loop below, we don't need
|
||||
* any additional checks for vl.
|
||||
*/
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_select_mask),
|
||||
8 * sizeof(vl_select_mask)) {
|
||||
for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
|
||||
memset(vlinfo, 0, sizeof(*vlinfo));
|
||||
|
||||
tmp = read_dev_cntr(dd, C_DC_RX_FLIT_VL, idx_from_vl(vl));
|
||||
|
|
@ -2884,7 +2882,7 @@ static int pma_get_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
vfi++;
|
||||
}
|
||||
|
||||
a0_portstatus(ppd, rsp, vl_select_mask);
|
||||
a0_portstatus(ppd, rsp);
|
||||
|
||||
if (resp_len)
|
||||
*resp_len += response_data_size;
|
||||
|
|
@ -2931,16 +2929,14 @@ static u64 get_error_counter_summary(struct ib_device *ibdev, u8 port,
|
|||
return error_counter_summary;
|
||||
}
|
||||
|
||||
static void a0_datacounters(struct hfi1_pportdata *ppd, struct _port_dctrs *rsp,
|
||||
u32 vl_select_mask)
|
||||
static void a0_datacounters(struct hfi1_pportdata *ppd, struct _port_dctrs *rsp)
|
||||
{
|
||||
if (!is_bx(ppd->dd)) {
|
||||
unsigned long vl;
|
||||
u64 sum_vl_xmit_wait = 0;
|
||||
u32 vl_all_mask = VL_MASK_ALL;
|
||||
unsigned long vl_all_mask = VL_MASK_ALL;
|
||||
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_all_mask),
|
||||
8 * sizeof(vl_all_mask)) {
|
||||
for_each_set_bit(vl, &vl_all_mask, BITS_PER_LONG) {
|
||||
u64 tmp = sum_vl_xmit_wait +
|
||||
read_port_cntr(ppd, C_TX_WAIT_VL,
|
||||
idx_from_vl(vl));
|
||||
|
|
@ -2995,7 +2991,7 @@ static int pma_get_opa_datacounters(struct opa_pma_mad *pmp,
|
|||
u64 port_mask;
|
||||
u8 port_num;
|
||||
unsigned long vl;
|
||||
u32 vl_select_mask;
|
||||
unsigned long vl_select_mask;
|
||||
int vfi;
|
||||
u16 link_width;
|
||||
u16 link_speed;
|
||||
|
|
@ -3073,8 +3069,7 @@ static int pma_get_opa_datacounters(struct opa_pma_mad *pmp,
|
|||
* So in the for_each_set_bit() loop below, we don't need
|
||||
* any additional checks for vl.
|
||||
*/
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_select_mask),
|
||||
8 * sizeof(req->vl_select_mask)) {
|
||||
for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
|
||||
memset(vlinfo, 0, sizeof(*vlinfo));
|
||||
|
||||
rsp->vls[vfi].port_vl_xmit_data =
|
||||
|
|
@ -3122,7 +3117,7 @@ static int pma_get_opa_datacounters(struct opa_pma_mad *pmp,
|
|||
vfi++;
|
||||
}
|
||||
|
||||
a0_datacounters(ppd, rsp, vl_select_mask);
|
||||
a0_datacounters(ppd, rsp);
|
||||
|
||||
if (resp_len)
|
||||
*resp_len += response_data_size;
|
||||
|
|
@ -3217,7 +3212,7 @@ static int pma_get_opa_porterrors(struct opa_pma_mad *pmp,
|
|||
struct _vls_ectrs *vlinfo;
|
||||
unsigned long vl;
|
||||
u64 port_mask, tmp;
|
||||
u32 vl_select_mask;
|
||||
unsigned long vl_select_mask;
|
||||
int vfi;
|
||||
|
||||
req = (struct opa_port_error_counters64_msg *)pmp->data;
|
||||
|
|
@ -3276,8 +3271,7 @@ static int pma_get_opa_porterrors(struct opa_pma_mad *pmp,
|
|||
vlinfo = &rsp->vls[0];
|
||||
vfi = 0;
|
||||
vl_select_mask = be32_to_cpu(req->vl_select_mask);
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_select_mask),
|
||||
8 * sizeof(req->vl_select_mask)) {
|
||||
for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
|
||||
memset(vlinfo, 0, sizeof(*vlinfo));
|
||||
rsp->vls[vfi].port_vl_xmit_discards =
|
||||
cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD_VL,
|
||||
|
|
@ -3488,7 +3482,7 @@ static int pma_set_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
u32 nports = be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24;
|
||||
u64 portn = be64_to_cpu(req->port_select_mask[3]);
|
||||
u32 counter_select = be32_to_cpu(req->counter_select_mask);
|
||||
u32 vl_select_mask = VL_MASK_ALL; /* clear all per-vl cnts */
|
||||
unsigned long vl_select_mask = VL_MASK_ALL; /* clear all per-vl cnts */
|
||||
unsigned long vl;
|
||||
|
||||
if ((nports != 1) || (portn != 1 << port)) {
|
||||
|
|
@ -3582,8 +3576,7 @@ static int pma_set_opa_portstatus(struct opa_pma_mad *pmp,
|
|||
if (counter_select & CS_UNCORRECTABLE_ERRORS)
|
||||
write_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL, 0);
|
||||
|
||||
for_each_set_bit(vl, (unsigned long *)&(vl_select_mask),
|
||||
8 * sizeof(vl_select_mask)) {
|
||||
for_each_set_bit(vl, &vl_select_mask, BITS_PER_LONG) {
|
||||
if (counter_select & CS_PORT_XMIT_DATA)
|
||||
write_port_cntr(ppd, C_TX_FLIT_VL, idx_from_vl(vl), 0);
|
||||
|
||||
|
|
|
|||
|
|
@ -6370,6 +6370,7 @@ static void mlx5_ib_remove(struct mlx5_core_dev *mdev, void *context)
|
|||
mlx5_ib_unbind_slave_port(mpi->ibdev, mpi);
|
||||
list_del(&mpi->list);
|
||||
mutex_unlock(&mlx5_ib_multiport_mutex);
|
||||
kfree(mpi);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ obj-$(CONFIG_IOMMU_IO_PGTABLE_LPAE) += io-pgtable-arm.o
|
|||
obj-$(CONFIG_IOMMU_IOVA) += iova.o
|
||||
obj-$(CONFIG_OF_IOMMU) += of_iommu.o
|
||||
obj-$(CONFIG_MSM_IOMMU) += msm_iommu.o
|
||||
obj-$(CONFIG_AMD_IOMMU) += amd_iommu.o amd_iommu_init.o
|
||||
obj-$(CONFIG_AMD_IOMMU) += amd_iommu.o amd_iommu_init.o amd_iommu_quirks.o
|
||||
obj-$(CONFIG_AMD_IOMMU_DEBUGFS) += amd_iommu_debugfs.o
|
||||
obj-$(CONFIG_AMD_IOMMU_V2) += amd_iommu_v2.o
|
||||
obj-$(CONFIG_ARM_SMMU) += arm-smmu.o
|
||||
|
|
|
|||
|
|
@ -2563,7 +2563,9 @@ static int map_sg(struct device *dev, struct scatterlist *sglist,
|
|||
|
||||
bus_addr = address + s->dma_address + (j << PAGE_SHIFT);
|
||||
phys_addr = (sg_phys(s) & PAGE_MASK) + (j << PAGE_SHIFT);
|
||||
ret = iommu_map_page(domain, bus_addr, phys_addr, PAGE_SIZE, prot, GFP_ATOMIC);
|
||||
ret = iommu_map_page(domain, bus_addr, phys_addr,
|
||||
PAGE_SIZE, prot,
|
||||
GFP_ATOMIC | __GFP_NOWARN);
|
||||
if (ret)
|
||||
goto out_unmap;
|
||||
|
||||
|
|
|
|||
14
drivers/iommu/amd_iommu.h
Normal file
14
drivers/iommu/amd_iommu.h
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
|
||||
#ifndef AMD_IOMMU_H
|
||||
#define AMD_IOMMU_H
|
||||
|
||||
int __init add_special_device(u8 type, u8 id, u16 *devid, bool cmd_line);
|
||||
|
||||
#ifdef CONFIG_DMI
|
||||
void amd_iommu_apply_ivrs_quirks(void);
|
||||
#else
|
||||
static void amd_iommu_apply_ivrs_quirks(void) { }
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -39,6 +39,7 @@
|
|||
#include <asm/irq_remapping.h>
|
||||
|
||||
#include <linux/crash_dump.h>
|
||||
#include "amd_iommu.h"
|
||||
#include "amd_iommu_proto.h"
|
||||
#include "amd_iommu_types.h"
|
||||
#include "irq_remapping.h"
|
||||
|
|
@ -1002,7 +1003,7 @@ static void __init set_dev_entry_from_acpi(struct amd_iommu *iommu,
|
|||
set_iommu_for_device(iommu, devid);
|
||||
}
|
||||
|
||||
static int __init add_special_device(u8 type, u8 id, u16 *devid, bool cmd_line)
|
||||
int __init add_special_device(u8 type, u8 id, u16 *devid, bool cmd_line)
|
||||
{
|
||||
struct devid_map *entry;
|
||||
struct list_head *list;
|
||||
|
|
@ -1153,6 +1154,8 @@ static int __init init_iommu_from_acpi(struct amd_iommu *iommu,
|
|||
if (ret)
|
||||
return ret;
|
||||
|
||||
amd_iommu_apply_ivrs_quirks();
|
||||
|
||||
/*
|
||||
* First save the recommended feature enable bits from ACPI
|
||||
*/
|
||||
|
|
|
|||
92
drivers/iommu/amd_iommu_quirks.c
Normal file
92
drivers/iommu/amd_iommu_quirks.c
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
|
||||
/*
|
||||
* Quirks for AMD IOMMU
|
||||
*
|
||||
* Copyright (C) 2019 Kai-Heng Feng <kai.heng.feng@canonical.com>
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_DMI
|
||||
#include <linux/dmi.h>
|
||||
|
||||
#include "amd_iommu.h"
|
||||
|
||||
#define IVHD_SPECIAL_IOAPIC 1
|
||||
|
||||
struct ivrs_quirk_entry {
|
||||
u8 id;
|
||||
u16 devid;
|
||||
};
|
||||
|
||||
enum {
|
||||
DELL_INSPIRON_7375 = 0,
|
||||
DELL_LATITUDE_5495,
|
||||
LENOVO_IDEAPAD_330S_15ARR,
|
||||
};
|
||||
|
||||
static const struct ivrs_quirk_entry ivrs_ioapic_quirks[][3] __initconst = {
|
||||
/* ivrs_ioapic[4]=00:14.0 ivrs_ioapic[5]=00:00.2 */
|
||||
[DELL_INSPIRON_7375] = {
|
||||
{ .id = 4, .devid = 0xa0 },
|
||||
{ .id = 5, .devid = 0x2 },
|
||||
{}
|
||||
},
|
||||
/* ivrs_ioapic[4]=00:14.0 */
|
||||
[DELL_LATITUDE_5495] = {
|
||||
{ .id = 4, .devid = 0xa0 },
|
||||
{}
|
||||
},
|
||||
/* ivrs_ioapic[32]=00:14.0 */
|
||||
[LENOVO_IDEAPAD_330S_15ARR] = {
|
||||
{ .id = 32, .devid = 0xa0 },
|
||||
{}
|
||||
},
|
||||
{}
|
||||
};
|
||||
|
||||
static int __init ivrs_ioapic_quirk_cb(const struct dmi_system_id *d)
|
||||
{
|
||||
const struct ivrs_quirk_entry *i;
|
||||
|
||||
for (i = d->driver_data; i->id != 0 && i->devid != 0; i++)
|
||||
add_special_device(IVHD_SPECIAL_IOAPIC, i->id, (u16 *)&i->devid, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dmi_system_id ivrs_quirks[] __initconst = {
|
||||
{
|
||||
.callback = ivrs_ioapic_quirk_cb,
|
||||
.ident = "Dell Inspiron 7375",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7375"),
|
||||
},
|
||||
.driver_data = (void *)&ivrs_ioapic_quirks[DELL_INSPIRON_7375],
|
||||
},
|
||||
{
|
||||
.callback = ivrs_ioapic_quirk_cb,
|
||||
.ident = "Dell Latitude 5495",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "Latitude 5495"),
|
||||
},
|
||||
.driver_data = (void *)&ivrs_ioapic_quirks[DELL_LATITUDE_5495],
|
||||
},
|
||||
{
|
||||
.callback = ivrs_ioapic_quirk_cb,
|
||||
.ident = "Lenovo ideapad 330S-15ARR",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "81FB"),
|
||||
},
|
||||
.driver_data = (void *)&ivrs_ioapic_quirks[LENOVO_IDEAPAD_330S_15ARR],
|
||||
},
|
||||
{}
|
||||
};
|
||||
|
||||
void __init amd_iommu_apply_ivrs_quirks(void)
|
||||
{
|
||||
dmi_check_system(ivrs_quirks);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -580,7 +580,9 @@ void queue_iova(struct iova_domain *iovad,
|
|||
|
||||
spin_unlock_irqrestore(&fq->lock, flags);
|
||||
|
||||
if (atomic_cmpxchg(&iovad->fq_timer_on, 0, 1) == 0)
|
||||
/* Avoid false sharing as much as possible. */
|
||||
if (!atomic_read(&iovad->fq_timer_on) &&
|
||||
!atomic_cmpxchg(&iovad->fq_timer_on, 0, 1))
|
||||
mod_timer(&iovad->fq_timer,
|
||||
jiffies + msecs_to_jiffies(IOVA_FQ_TIMEOUT));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -764,6 +764,8 @@ base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
|
|||
|
||||
if (sock->type != SOCK_RAW)
|
||||
return -ESOCKTNOSUPPORT;
|
||||
if (!capable(CAP_NET_RAW))
|
||||
return -EPERM;
|
||||
|
||||
sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
|
||||
if (!sk)
|
||||
|
|
|
|||
|
|
@ -177,6 +177,7 @@ err_activate:
|
|||
list_del(&led_cdev->trig_list);
|
||||
write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, flags);
|
||||
led_set_brightness(led_cdev, LED_OFF);
|
||||
kfree(event);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -263,7 +263,11 @@ static void lp5562_firmware_loaded(struct lp55xx_chip *chip)
|
|||
{
|
||||
const struct firmware *fw = chip->fw;
|
||||
|
||||
if (fw->size > LP5562_PROGRAM_LENGTH) {
|
||||
/*
|
||||
* the firmware is encoded in ascii hex character, with 2 chars
|
||||
* per byte
|
||||
*/
|
||||
if (fw->size > (LP5562_PROGRAM_LENGTH * 2)) {
|
||||
dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
|
||||
fw->size);
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -105,8 +105,14 @@ struct closure_syncer {
|
|||
|
||||
static void closure_sync_fn(struct closure *cl)
|
||||
{
|
||||
cl->s->done = 1;
|
||||
wake_up_process(cl->s->task);
|
||||
struct closure_syncer *s = cl->s;
|
||||
struct task_struct *p;
|
||||
|
||||
rcu_read_lock();
|
||||
p = READ_ONCE(s->task);
|
||||
s->done = 1;
|
||||
wake_up_process(p);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
void __sched __closure_sync(struct closure *cl)
|
||||
|
|
|
|||
|
|
@ -505,6 +505,7 @@ check_again:
|
|||
ret = dm_dispatch_clone_request(clone, rq);
|
||||
if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE) {
|
||||
blk_rq_unprep_clone(clone);
|
||||
blk_mq_cleanup_rq(clone);
|
||||
tio->ti->type->release_clone_rq(clone, &tio->info);
|
||||
tio->clone = NULL;
|
||||
if (!rq->q->mq_ops)
|
||||
|
|
|
|||
|
|
@ -1770,8 +1770,15 @@ static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
|
|||
if (!(le32_to_cpu(sb->feature_map) &
|
||||
MD_FEATURE_RECOVERY_BITMAP))
|
||||
rdev->saved_raid_disk = -1;
|
||||
} else
|
||||
set_bit(In_sync, &rdev->flags);
|
||||
} else {
|
||||
/*
|
||||
* If the array is FROZEN, then the device can't
|
||||
* be in_sync with rest of array.
|
||||
*/
|
||||
if (!test_bit(MD_RECOVERY_FROZEN,
|
||||
&mddev->recovery))
|
||||
set_bit(In_sync, &rdev->flags);
|
||||
}
|
||||
rdev->raid_disk = role;
|
||||
break;
|
||||
}
|
||||
|
|
@ -4116,7 +4123,7 @@ array_state_show(struct mddev *mddev, char *page)
|
|||
{
|
||||
enum array_state st = inactive;
|
||||
|
||||
if (mddev->pers)
|
||||
if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags))
|
||||
switch(mddev->ro) {
|
||||
case 1:
|
||||
st = readonly;
|
||||
|
|
@ -5671,9 +5678,6 @@ int md_run(struct mddev *mddev)
|
|||
md_update_sb(mddev, 0);
|
||||
|
||||
md_new_event(mddev);
|
||||
sysfs_notify_dirent_safe(mddev->sysfs_state);
|
||||
sysfs_notify_dirent_safe(mddev->sysfs_action);
|
||||
sysfs_notify(&mddev->kobj, NULL, "degraded");
|
||||
return 0;
|
||||
|
||||
abort:
|
||||
|
|
@ -5687,6 +5691,7 @@ static int do_md_run(struct mddev *mddev)
|
|||
{
|
||||
int err;
|
||||
|
||||
set_bit(MD_NOT_READY, &mddev->flags);
|
||||
err = md_run(mddev);
|
||||
if (err)
|
||||
goto out;
|
||||
|
|
@ -5707,9 +5712,14 @@ static int do_md_run(struct mddev *mddev)
|
|||
|
||||
set_capacity(mddev->gendisk, mddev->array_sectors);
|
||||
revalidate_disk(mddev->gendisk);
|
||||
clear_bit(MD_NOT_READY, &mddev->flags);
|
||||
mddev->changed = 1;
|
||||
kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
|
||||
sysfs_notify_dirent_safe(mddev->sysfs_state);
|
||||
sysfs_notify_dirent_safe(mddev->sysfs_action);
|
||||
sysfs_notify(&mddev->kobj, NULL, "degraded");
|
||||
out:
|
||||
clear_bit(MD_NOT_READY, &mddev->flags);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -8797,6 +8807,7 @@ void md_check_recovery(struct mddev *mddev)
|
|||
|
||||
if (mddev_trylock(mddev)) {
|
||||
int spares = 0;
|
||||
bool try_set_sync = mddev->safemode != 0;
|
||||
|
||||
if (!mddev->external && mddev->safemode == 1)
|
||||
mddev->safemode = 0;
|
||||
|
|
@ -8842,7 +8853,7 @@ void md_check_recovery(struct mddev *mddev)
|
|||
}
|
||||
}
|
||||
|
||||
if (!mddev->external && !mddev->in_sync) {
|
||||
if (try_set_sync && !mddev->external && !mddev->in_sync) {
|
||||
spin_lock(&mddev->lock);
|
||||
set_in_sync(mddev);
|
||||
spin_unlock(&mddev->lock);
|
||||
|
|
@ -8948,7 +8959,8 @@ void md_reap_sync_thread(struct mddev *mddev)
|
|||
/* resync has finished, collect result */
|
||||
md_unregister_thread(&mddev->sync_thread);
|
||||
if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
|
||||
!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
|
||||
!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
|
||||
mddev->degraded != mddev->raid_disks) {
|
||||
/* success...*/
|
||||
/* activate any spares */
|
||||
if (mddev->pers->spare_active(mddev)) {
|
||||
|
|
|
|||
|
|
@ -243,6 +243,9 @@ enum mddev_flags {
|
|||
MD_UPDATING_SB, /* md_check_recovery is updating the metadata
|
||||
* without explicitly holding reconfig_mutex.
|
||||
*/
|
||||
MD_NOT_READY, /* do_md_run() is active, so 'array_state'
|
||||
* must not report that array is ready yet
|
||||
*/
|
||||
};
|
||||
|
||||
enum mddev_sb_flags {
|
||||
|
|
|
|||
|
|
@ -26,6 +26,9 @@
|
|||
#include "raid0.h"
|
||||
#include "raid5.h"
|
||||
|
||||
static int default_layout = 0;
|
||||
module_param(default_layout, int, 0644);
|
||||
|
||||
#define UNSUPPORTED_MDDEV_FLAGS \
|
||||
((1L << MD_HAS_JOURNAL) | \
|
||||
(1L << MD_JOURNAL_CLEAN) | \
|
||||
|
|
@ -146,6 +149,19 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
|
|||
}
|
||||
pr_debug("md/raid0:%s: FINAL %d zones\n",
|
||||
mdname(mddev), conf->nr_strip_zones);
|
||||
|
||||
if (conf->nr_strip_zones == 1) {
|
||||
conf->layout = RAID0_ORIG_LAYOUT;
|
||||
} else if (default_layout == RAID0_ORIG_LAYOUT ||
|
||||
default_layout == RAID0_ALT_MULTIZONE_LAYOUT) {
|
||||
conf->layout = default_layout;
|
||||
} else {
|
||||
pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",
|
||||
mdname(mddev));
|
||||
pr_err("md/raid0: please set raid.default_layout to 1 or 2\n");
|
||||
err = -ENOTSUPP;
|
||||
goto abort;
|
||||
}
|
||||
/*
|
||||
* now since we have the hard sector sizes, we can make sure
|
||||
* chunk size is a multiple of that sector size
|
||||
|
|
@ -555,10 +571,12 @@ static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)
|
|||
|
||||
static bool raid0_make_request(struct mddev *mddev, struct bio *bio)
|
||||
{
|
||||
struct r0conf *conf = mddev->private;
|
||||
struct strip_zone *zone;
|
||||
struct md_rdev *tmp_dev;
|
||||
sector_t bio_sector;
|
||||
sector_t sector;
|
||||
sector_t orig_sector;
|
||||
unsigned chunk_sects;
|
||||
unsigned sectors;
|
||||
|
||||
|
|
@ -592,8 +610,21 @@ static bool raid0_make_request(struct mddev *mddev, struct bio *bio)
|
|||
bio = split;
|
||||
}
|
||||
|
||||
orig_sector = sector;
|
||||
zone = find_zone(mddev->private, §or);
|
||||
tmp_dev = map_sector(mddev, zone, sector, §or);
|
||||
switch (conf->layout) {
|
||||
case RAID0_ORIG_LAYOUT:
|
||||
tmp_dev = map_sector(mddev, zone, orig_sector, §or);
|
||||
break;
|
||||
case RAID0_ALT_MULTIZONE_LAYOUT:
|
||||
tmp_dev = map_sector(mddev, zone, sector, §or);
|
||||
break;
|
||||
default:
|
||||
WARN("md/raid0:%s: Invalid layout\n", mdname(mddev));
|
||||
bio_io_error(bio);
|
||||
return true;
|
||||
}
|
||||
|
||||
bio_set_dev(bio, tmp_dev->bdev);
|
||||
bio->bi_iter.bi_sector = sector + zone->dev_start +
|
||||
tmp_dev->data_offset;
|
||||
|
|
|
|||
|
|
@ -8,11 +8,25 @@ struct strip_zone {
|
|||
int nb_dev; /* # of devices attached to the zone */
|
||||
};
|
||||
|
||||
/* Linux 3.14 (20d0189b101) made an unintended change to
|
||||
* the RAID0 layout for multi-zone arrays (where devices aren't all
|
||||
* the same size.
|
||||
* RAID0_ORIG_LAYOUT restores the original layout
|
||||
* RAID0_ALT_MULTIZONE_LAYOUT uses the altered layout
|
||||
* The layouts are identical when there is only one zone (all
|
||||
* devices the same size).
|
||||
*/
|
||||
|
||||
enum r0layout {
|
||||
RAID0_ORIG_LAYOUT = 1,
|
||||
RAID0_ALT_MULTIZONE_LAYOUT = 2,
|
||||
};
|
||||
struct r0conf {
|
||||
struct strip_zone *strip_zone;
|
||||
struct md_rdev **devlist; /* lists of rdevs, pointed to
|
||||
* by strip_zone->dev */
|
||||
int nr_strip_zones;
|
||||
enum r0layout layout;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -434,19 +434,21 @@ static void raid1_end_write_request(struct bio *bio)
|
|||
/* We never try FailFast to WriteMostly devices */
|
||||
!test_bit(WriteMostly, &rdev->flags)) {
|
||||
md_error(r1_bio->mddev, rdev);
|
||||
if (!test_bit(Faulty, &rdev->flags))
|
||||
/* This is the only remaining device,
|
||||
* We need to retry the write without
|
||||
* FailFast
|
||||
*/
|
||||
set_bit(R1BIO_WriteError, &r1_bio->state);
|
||||
else {
|
||||
/* Finished with this branch */
|
||||
r1_bio->bios[mirror] = NULL;
|
||||
to_put = bio;
|
||||
}
|
||||
} else
|
||||
}
|
||||
|
||||
/*
|
||||
* When the device is faulty, it is not necessary to
|
||||
* handle write error.
|
||||
* For failfast, this is the only remaining device,
|
||||
* We need to retry the write without FailFast.
|
||||
*/
|
||||
if (!test_bit(Faulty, &rdev->flags))
|
||||
set_bit(R1BIO_WriteError, &r1_bio->state);
|
||||
else {
|
||||
/* Finished with this branch */
|
||||
r1_bio->bios[mirror] = NULL;
|
||||
to_put = bio;
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* Set R1BIO_Uptodate in our master bio, so that we
|
||||
|
|
@ -3103,6 +3105,13 @@ static int raid1_run(struct mddev *mddev)
|
|||
!test_bit(In_sync, &conf->mirrors[i].rdev->flags) ||
|
||||
test_bit(Faulty, &conf->mirrors[i].rdev->flags))
|
||||
mddev->degraded++;
|
||||
/*
|
||||
* RAID1 needs at least one disk in active
|
||||
*/
|
||||
if (conf->raid_disks - mddev->degraded < 1) {
|
||||
ret = -EINVAL;
|
||||
goto abort;
|
||||
}
|
||||
|
||||
if (conf->raid_disks - mddev->degraded == 1)
|
||||
mddev->recovery_cp = MaxSector;
|
||||
|
|
@ -3136,8 +3145,12 @@ static int raid1_run(struct mddev *mddev)
|
|||
ret = md_integrity_register(mddev);
|
||||
if (ret) {
|
||||
md_unregister_thread(&mddev->thread);
|
||||
raid1_free(mddev, conf);
|
||||
goto abort;
|
||||
}
|
||||
return 0;
|
||||
|
||||
abort:
|
||||
raid1_free(mddev, conf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2540,7 +2540,8 @@ static void raid5_end_read_request(struct bio * bi)
|
|||
int set_bad = 0;
|
||||
|
||||
clear_bit(R5_UPTODATE, &sh->dev[i].flags);
|
||||
atomic_inc(&rdev->read_errors);
|
||||
if (!(bi->bi_status == BLK_STS_PROTECTION))
|
||||
atomic_inc(&rdev->read_errors);
|
||||
if (test_bit(R5_ReadRepl, &sh->dev[i].flags))
|
||||
pr_warn_ratelimited(
|
||||
"md/raid:%s: read error on replacement device (sector %llu on %s).\n",
|
||||
|
|
@ -2572,7 +2573,9 @@ static void raid5_end_read_request(struct bio * bi)
|
|||
&& !test_bit(R5_ReadNoMerge, &sh->dev[i].flags))
|
||||
retry = 1;
|
||||
if (retry)
|
||||
if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags)) {
|
||||
if (sh->qd_idx >= 0 && sh->pd_idx == i)
|
||||
set_bit(R5_ReadError, &sh->dev[i].flags);
|
||||
else if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags)) {
|
||||
set_bit(R5_ReadError, &sh->dev[i].flags);
|
||||
clear_bit(R5_ReadNoMerge, &sh->dev[i].flags);
|
||||
} else
|
||||
|
|
@ -5721,7 +5724,8 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
|
|||
do_flush = false;
|
||||
}
|
||||
|
||||
set_bit(STRIPE_HANDLE, &sh->state);
|
||||
if (!sh->batch_head)
|
||||
set_bit(STRIPE_HANDLE, &sh->state);
|
||||
clear_bit(STRIPE_DELAYED, &sh->state);
|
||||
if ((!sh->batch_head || sh == sh->batch_head) &&
|
||||
(bi->bi_opf & REQ_SYNC) &&
|
||||
|
|
|
|||
|
|
@ -123,6 +123,8 @@ void cec_notifier_unregister(struct cec_notifier *n)
|
|||
{
|
||||
mutex_lock(&n->lock);
|
||||
n->callback = NULL;
|
||||
n->cec_adap->notifier = NULL;
|
||||
n->cec_adap = NULL;
|
||||
mutex_unlock(&n->lock);
|
||||
cec_notifier_put(n);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -164,6 +164,9 @@ static void dvb_frontend_free(struct kref *ref)
|
|||
|
||||
static void dvb_frontend_put(struct dvb_frontend *fe)
|
||||
{
|
||||
/* call detach before dropping the reference count */
|
||||
if (fe->ops.detach)
|
||||
fe->ops.detach(fe);
|
||||
/*
|
||||
* Check if the frontend was registered, as otherwise
|
||||
* kref was not initialized yet.
|
||||
|
|
@ -3035,7 +3038,6 @@ void dvb_frontend_detach(struct dvb_frontend *fe)
|
|||
dvb_frontend_invoke_release(fe, fe->ops.release_sec);
|
||||
dvb_frontend_invoke_release(fe, fe->ops.tuner_ops.release);
|
||||
dvb_frontend_invoke_release(fe, fe->ops.analog_ops.release);
|
||||
dvb_frontend_invoke_release(fe, fe->ops.detach);
|
||||
dvb_frontend_put(fe);
|
||||
}
|
||||
EXPORT_SYMBOL(dvb_frontend_detach);
|
||||
|
|
|
|||
|
|
@ -339,8 +339,10 @@ static int dvb_create_media_entity(struct dvb_device *dvbdev,
|
|||
if (npads) {
|
||||
dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
|
||||
GFP_KERNEL);
|
||||
if (!dvbdev->pads)
|
||||
if (!dvbdev->pads) {
|
||||
kfree(dvbdev->entity);
|
||||
return -ENOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@
|
|||
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/idr.h>
|
||||
#include <linux/dvb/frontend.h>
|
||||
#include <asm/types.h>
|
||||
|
||||
|
|
@ -43,8 +44,7 @@ struct dvb_pll_priv {
|
|||
};
|
||||
|
||||
#define DVB_PLL_MAX 64
|
||||
|
||||
static unsigned int dvb_pll_devcount;
|
||||
static DEFINE_IDA(pll_ida);
|
||||
|
||||
static int debug;
|
||||
module_param(debug, int, 0644);
|
||||
|
|
@ -796,6 +796,7 @@ struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
|
|||
struct dvb_pll_priv *priv = NULL;
|
||||
int ret;
|
||||
const struct dvb_pll_desc *desc;
|
||||
int nr;
|
||||
|
||||
b1 = kmalloc(1, GFP_KERNEL);
|
||||
if (!b1)
|
||||
|
|
@ -804,9 +805,14 @@ struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
|
|||
b1[0] = 0;
|
||||
msg.buf = b1;
|
||||
|
||||
if ((id[dvb_pll_devcount] > DVB_PLL_UNDEFINED) &&
|
||||
(id[dvb_pll_devcount] < ARRAY_SIZE(pll_list)))
|
||||
pll_desc_id = id[dvb_pll_devcount];
|
||||
nr = ida_simple_get(&pll_ida, 0, DVB_PLL_MAX, GFP_KERNEL);
|
||||
if (nr < 0) {
|
||||
kfree(b1);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (id[nr] > DVB_PLL_UNDEFINED && id[nr] < ARRAY_SIZE(pll_list))
|
||||
pll_desc_id = id[nr];
|
||||
|
||||
BUG_ON(pll_desc_id < 1 || pll_desc_id >= ARRAY_SIZE(pll_list));
|
||||
|
||||
|
|
@ -817,24 +823,20 @@ struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
|
|||
fe->ops.i2c_gate_ctrl(fe, 1);
|
||||
|
||||
ret = i2c_transfer (i2c, &msg, 1);
|
||||
if (ret != 1) {
|
||||
kfree(b1);
|
||||
return NULL;
|
||||
}
|
||||
if (ret != 1)
|
||||
goto out;
|
||||
if (fe->ops.i2c_gate_ctrl)
|
||||
fe->ops.i2c_gate_ctrl(fe, 0);
|
||||
}
|
||||
|
||||
priv = kzalloc(sizeof(struct dvb_pll_priv), GFP_KERNEL);
|
||||
if (!priv) {
|
||||
kfree(b1);
|
||||
return NULL;
|
||||
}
|
||||
if (!priv)
|
||||
goto out;
|
||||
|
||||
priv->pll_i2c_address = pll_addr;
|
||||
priv->i2c = i2c;
|
||||
priv->pll_desc = desc;
|
||||
priv->nr = dvb_pll_devcount++;
|
||||
priv->nr = nr;
|
||||
|
||||
memcpy(&fe->ops.tuner_ops, &dvb_pll_tuner_ops,
|
||||
sizeof(struct dvb_tuner_ops));
|
||||
|
|
@ -867,6 +869,11 @@ struct dvb_frontend *dvb_pll_attach(struct dvb_frontend *fe, int pll_addr,
|
|||
kfree(b1);
|
||||
|
||||
return fe;
|
||||
out:
|
||||
kfree(b1);
|
||||
ida_simple_remove(&pll_ida, nr);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(dvb_pll_attach);
|
||||
|
||||
|
|
@ -903,9 +910,10 @@ dvb_pll_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
|||
|
||||
static int dvb_pll_remove(struct i2c_client *client)
|
||||
{
|
||||
struct dvb_frontend *fe;
|
||||
struct dvb_frontend *fe = i2c_get_clientdata(client);
|
||||
struct dvb_pll_priv *priv = fe->tuner_priv;
|
||||
|
||||
fe = i2c_get_clientdata(client);
|
||||
ida_simple_remove(&pll_ida, priv->nr);
|
||||
dvb_pll_release(fe);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2787,9 +2787,14 @@ static int ov5640_probe(struct i2c_client *client,
|
|||
/* request optional power down pin */
|
||||
sensor->pwdn_gpio = devm_gpiod_get_optional(dev, "powerdown",
|
||||
GPIOD_OUT_HIGH);
|
||||
if (IS_ERR(sensor->pwdn_gpio))
|
||||
return PTR_ERR(sensor->pwdn_gpio);
|
||||
|
||||
/* request optional reset pin */
|
||||
sensor->reset_gpio = devm_gpiod_get_optional(dev, "reset",
|
||||
GPIOD_OUT_HIGH);
|
||||
if (IS_ERR(sensor->reset_gpio))
|
||||
return PTR_ERR(sensor->reset_gpio);
|
||||
|
||||
v4l2_i2c_subdev_init(&sensor->sd, client, &ov5640_subdev_ops);
|
||||
|
||||
|
|
|
|||
|
|
@ -53,6 +53,8 @@
|
|||
#define OV5645_CHIP_ID_HIGH_BYTE 0x56
|
||||
#define OV5645_CHIP_ID_LOW 0x300b
|
||||
#define OV5645_CHIP_ID_LOW_BYTE 0x45
|
||||
#define OV5645_IO_MIPI_CTRL00 0x300e
|
||||
#define OV5645_PAD_OUTPUT00 0x3019
|
||||
#define OV5645_AWB_MANUAL_CONTROL 0x3406
|
||||
#define OV5645_AWB_MANUAL_ENABLE BIT(0)
|
||||
#define OV5645_AEC_PK_MANUAL 0x3503
|
||||
|
|
@ -63,6 +65,7 @@
|
|||
#define OV5645_ISP_VFLIP BIT(2)
|
||||
#define OV5645_TIMING_TC_REG21 0x3821
|
||||
#define OV5645_SENSOR_MIRROR BIT(1)
|
||||
#define OV5645_MIPI_CTRL00 0x4800
|
||||
#define OV5645_PRE_ISP_TEST_SETTING_1 0x503d
|
||||
#define OV5645_TEST_PATTERN_MASK 0x3
|
||||
#define OV5645_SET_TEST_PATTERN(x) ((x) & OV5645_TEST_PATTERN_MASK)
|
||||
|
|
@ -129,7 +132,6 @@ static const struct reg_value ov5645_global_init_setting[] = {
|
|||
{ 0x3503, 0x07 },
|
||||
{ 0x3002, 0x1c },
|
||||
{ 0x3006, 0xc3 },
|
||||
{ 0x300e, 0x45 },
|
||||
{ 0x3017, 0x00 },
|
||||
{ 0x3018, 0x00 },
|
||||
{ 0x302e, 0x0b },
|
||||
|
|
@ -358,7 +360,10 @@ static const struct reg_value ov5645_global_init_setting[] = {
|
|||
{ 0x3a1f, 0x14 },
|
||||
{ 0x0601, 0x02 },
|
||||
{ 0x3008, 0x42 },
|
||||
{ 0x3008, 0x02 }
|
||||
{ 0x3008, 0x02 },
|
||||
{ OV5645_IO_MIPI_CTRL00, 0x40 },
|
||||
{ OV5645_MIPI_CTRL00, 0x24 },
|
||||
{ OV5645_PAD_OUTPUT00, 0x70 }
|
||||
};
|
||||
|
||||
static const struct reg_value ov5645_setting_sxga[] = {
|
||||
|
|
@ -745,13 +750,9 @@ static int ov5645_s_power(struct v4l2_subdev *sd, int on)
|
|||
goto exit;
|
||||
}
|
||||
|
||||
ret = ov5645_write_reg(ov5645, OV5645_SYSTEM_CTRL0,
|
||||
OV5645_SYSTEM_CTRL0_STOP);
|
||||
if (ret < 0) {
|
||||
ov5645_set_power_off(ov5645);
|
||||
goto exit;
|
||||
}
|
||||
usleep_range(500, 1000);
|
||||
} else {
|
||||
ov5645_write_reg(ov5645, OV5645_IO_MIPI_CTRL00, 0x58);
|
||||
ov5645_set_power_off(ov5645);
|
||||
}
|
||||
}
|
||||
|
|
@ -1057,11 +1058,20 @@ static int ov5645_s_stream(struct v4l2_subdev *subdev, int enable)
|
|||
dev_err(ov5645->dev, "could not sync v4l2 controls\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = ov5645_write_reg(ov5645, OV5645_IO_MIPI_CTRL00, 0x45);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = ov5645_write_reg(ov5645, OV5645_SYSTEM_CTRL0,
|
||||
OV5645_SYSTEM_CTRL0_START);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
} else {
|
||||
ret = ov5645_write_reg(ov5645, OV5645_IO_MIPI_CTRL00, 0x40);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = ov5645_write_reg(ov5645, OV5645_SYSTEM_CTRL0,
|
||||
OV5645_SYSTEM_CTRL0_STOP);
|
||||
if (ret < 0)
|
||||
|
|
|
|||
|
|
@ -716,6 +716,11 @@ static int ov965x_set_gain(struct ov965x *ov965x, int auto_gain)
|
|||
for (m = 6; m >= 0; m--)
|
||||
if (gain >= (1 << m) * 16)
|
||||
break;
|
||||
|
||||
/* Sanity check: don't adjust the gain with a negative value */
|
||||
if (m < 0)
|
||||
return -EINVAL;
|
||||
|
||||
rgain = (gain - ((1 << m) * 16)) / (1 << m);
|
||||
rgain |= (((1 << m) - 1) << 4);
|
||||
|
||||
|
|
|
|||
|
|
@ -351,7 +351,11 @@ static const struct i2c_client saa7134_client_template = {
|
|||
|
||||
/* ----------------------------------------------------------- */
|
||||
|
||||
/* On Medion 7134 reading EEPROM needs DVB-T demod i2c gate open */
|
||||
/*
|
||||
* On Medion 7134 reading the SAA7134 chip config EEPROM needs DVB-T
|
||||
* demod i2c gate closed due to an address clash between this EEPROM
|
||||
* and the demod one.
|
||||
*/
|
||||
static void saa7134_i2c_eeprom_md7134_gate(struct saa7134_dev *dev)
|
||||
{
|
||||
u8 subaddr = 0x7, dmdregval;
|
||||
|
|
@ -368,14 +372,14 @@ static void saa7134_i2c_eeprom_md7134_gate(struct saa7134_dev *dev)
|
|||
|
||||
ret = i2c_transfer(&dev->i2c_adap, i2cgatemsg_r, 2);
|
||||
if ((ret == 2) && (dmdregval & 0x2)) {
|
||||
pr_debug("%s: DVB-T demod i2c gate was left closed\n",
|
||||
pr_debug("%s: DVB-T demod i2c gate was left open\n",
|
||||
dev->name);
|
||||
|
||||
data[0] = subaddr;
|
||||
data[1] = (dmdregval & ~0x2);
|
||||
if (i2c_transfer(&dev->i2c_adap, i2cgatemsg_w, 1) != 1)
|
||||
pr_err("%s: EEPROM i2c gate open failure\n",
|
||||
dev->name);
|
||||
pr_err("%s: EEPROM i2c gate close failure\n",
|
||||
dev->name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -304,6 +304,9 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d
|
|||
ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
|
||||
if (ret < 0) {
|
||||
pr_err("cannot register capture v4l2 device. skipping.\n");
|
||||
saa7146_vv_release(dev);
|
||||
i2c_del_adapter(&hexium->i2c_adapter);
|
||||
kfree(hexium);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -819,6 +819,7 @@ static int fimc_is_probe(struct platform_device *pdev)
|
|||
return -ENODEV;
|
||||
|
||||
is->pmu_regs = of_iomap(node, 0);
|
||||
of_node_put(node);
|
||||
if (!is->pmu_regs)
|
||||
return -ENOMEM;
|
||||
|
||||
|
|
|
|||
|
|
@ -498,6 +498,7 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
|
|||
continue;
|
||||
|
||||
ret = fimc_md_parse_port_node(fmd, port, index);
|
||||
of_node_put(port);
|
||||
if (ret < 0) {
|
||||
of_node_put(node);
|
||||
goto rpm_put;
|
||||
|
|
@ -531,6 +532,7 @@ static int __of_get_csis_id(struct device_node *np)
|
|||
if (!np)
|
||||
return -EINVAL;
|
||||
of_property_read_u32(np, "reg", ®);
|
||||
of_node_put(np);
|
||||
return reg - FIMC_INPUT_MIPI_CSI2_0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
#define VIU_VERSION "0.5.1"
|
||||
|
||||
/* Allow building this driver with COMPILE_TEST */
|
||||
#ifndef CONFIG_PPC
|
||||
#if !defined(CONFIG_PPC) && !defined(CONFIG_MICROBLAZE)
|
||||
#define out_be32(v, a) iowrite32be(a, (void __iomem *)v)
|
||||
#define in_be32(a) ioread32be((void __iomem *)a)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -118,7 +118,9 @@ static int mtk_mdp_probe(struct platform_device *pdev)
|
|||
mutex_init(&mdp->vpulock);
|
||||
|
||||
/* Old dts had the components as child nodes */
|
||||
if (of_get_next_child(dev->of_node, NULL)) {
|
||||
node = of_get_next_child(dev->of_node, NULL);
|
||||
if (node) {
|
||||
of_node_put(node);
|
||||
parent = dev->of_node;
|
||||
dev_warn(dev, "device tree is out of date\n");
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -722,6 +722,10 @@ static int isp_pipeline_enable(struct isp_pipeline *pipe,
|
|||
s_stream, mode);
|
||||
pipe->do_propagation = true;
|
||||
}
|
||||
|
||||
/* Stop at the first external sub-device. */
|
||||
if (subdev->dev != isp->dev)
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -836,6 +840,10 @@ static int isp_pipeline_disable(struct isp_pipeline *pipe)
|
|||
&subdev->entity);
|
||||
failure = -ETIMEDOUT;
|
||||
}
|
||||
|
||||
/* Stop at the first external sub-device. */
|
||||
if (subdev->dev != isp->dev)
|
||||
break;
|
||||
}
|
||||
|
||||
return failure;
|
||||
|
|
|
|||
|
|
@ -2605,6 +2605,7 @@ int omap3isp_ccdc_register_entities(struct isp_ccdc_device *ccdc,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video node. */
|
||||
ccdc->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &ccdc->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -1034,6 +1034,7 @@ int omap3isp_ccp2_register_entities(struct isp_ccp2_device *ccp2,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
ccp2->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &ccp2->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -1201,6 +1201,7 @@ int omap3isp_csi2_register_entities(struct isp_csi2_device *csi2,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
csi2->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &csi2->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -2228,6 +2228,7 @@ int omap3isp_preview_register_entities(struct isp_prev_device *prev,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
prev->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &prev->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -1684,6 +1684,7 @@ int omap3isp_resizer_register_entities(struct isp_res_device *res,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
res->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &res->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
|||
|
|
@ -1029,6 +1029,8 @@ void omap3isp_stat_unregister_entities(struct ispstat *stat)
|
|||
int omap3isp_stat_register_entities(struct ispstat *stat,
|
||||
struct v4l2_device *vdev)
|
||||
{
|
||||
stat->subdev.dev = vdev->mdev->dev;
|
||||
|
||||
return v4l2_device_register_subdev(vdev, &stat->subdev);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2306,7 +2306,7 @@ static int fdp1_probe(struct platform_device *pdev)
|
|||
fdp1->fcp = rcar_fcp_get(fcp_node);
|
||||
of_node_put(fcp_node);
|
||||
if (IS_ERR(fdp1->fcp)) {
|
||||
dev_err(&pdev->dev, "FCP not found (%ld)\n",
|
||||
dev_dbg(&pdev->dev, "FCP not found (%ld)\n",
|
||||
PTR_ERR(fdp1->fcp));
|
||||
return PTR_ERR(fdp1->fcp);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -557,8 +557,10 @@ static struct vsp1_dl_list *vsp1_dl_list_alloc(struct vsp1_dl_manager *dlm)
|
|||
|
||||
/* Get a default body for our list. */
|
||||
dl->body0 = vsp1_dl_body_get(dlm->pool);
|
||||
if (!dl->body0)
|
||||
if (!dl->body0) {
|
||||
kfree(dl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
header_offset = dl->body0->max_entries * sizeof(*dl->body0->entries);
|
||||
|
||||
|
|
|
|||
|
|
@ -743,7 +743,7 @@ static int si470x_usb_driver_probe(struct usb_interface *intf,
|
|||
/* start radio */
|
||||
retval = si470x_start_usb(radio);
|
||||
if (retval < 0)
|
||||
goto err_all;
|
||||
goto err_buf;
|
||||
|
||||
/* set initial frequency */
|
||||
si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
|
||||
|
|
@ -758,6 +758,8 @@ static int si470x_usb_driver_probe(struct usb_interface *intf,
|
|||
|
||||
return 0;
|
||||
err_all:
|
||||
usb_kill_urb(radio->int_in_urb);
|
||||
err_buf:
|
||||
kfree(radio->buffer);
|
||||
err_ctrl:
|
||||
v4l2_ctrl_handler_free(&radio->hdl);
|
||||
|
|
@ -831,6 +833,7 @@ static void si470x_usb_driver_disconnect(struct usb_interface *intf)
|
|||
mutex_lock(&radio->lock);
|
||||
v4l2_device_disconnect(&radio->v4l2_dev);
|
||||
video_unregister_device(&radio->videodev);
|
||||
usb_kill_urb(radio->int_in_urb);
|
||||
usb_set_intfdata(intf, NULL);
|
||||
mutex_unlock(&radio->lock);
|
||||
v4l2_device_put(&radio->v4l2_dev);
|
||||
|
|
|
|||
|
|
@ -424,6 +424,10 @@ static int iguanair_probe(struct usb_interface *intf,
|
|||
int ret, pipein, pipeout;
|
||||
struct usb_host_interface *idesc;
|
||||
|
||||
idesc = intf->altsetting;
|
||||
if (idesc->desc.bNumEndpoints < 2)
|
||||
return -ENODEV;
|
||||
|
||||
ir = kzalloc(sizeof(*ir), GFP_KERNEL);
|
||||
rc = rc_allocate_device(RC_DRIVER_IR_RAW);
|
||||
if (!ir || !rc) {
|
||||
|
|
@ -438,18 +442,13 @@ static int iguanair_probe(struct usb_interface *intf,
|
|||
ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
|
||||
ir->urb_out = usb_alloc_urb(0, GFP_KERNEL);
|
||||
|
||||
if (!ir->buf_in || !ir->packet || !ir->urb_in || !ir->urb_out) {
|
||||
if (!ir->buf_in || !ir->packet || !ir->urb_in || !ir->urb_out ||
|
||||
!usb_endpoint_is_int_in(&idesc->endpoint[0].desc) ||
|
||||
!usb_endpoint_is_int_out(&idesc->endpoint[1].desc)) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
idesc = intf->altsetting;
|
||||
|
||||
if (idesc->desc.bNumEndpoints < 2) {
|
||||
ret = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
ir->rc = rc;
|
||||
ir->dev = &intf->dev;
|
||||
ir->udev = udev;
|
||||
|
|
|
|||
|
|
@ -1835,12 +1835,17 @@ static void imon_get_ffdc_type(struct imon_context *ictx)
|
|||
break;
|
||||
/* iMON VFD, MCE IR */
|
||||
case 0x46:
|
||||
case 0x7e:
|
||||
case 0x9e:
|
||||
dev_info(ictx->dev, "0xffdc iMON VFD, MCE IR");
|
||||
detected_display_type = IMON_DISPLAY_TYPE_VFD;
|
||||
allowed_protos = RC_PROTO_BIT_RC6_MCE;
|
||||
break;
|
||||
/* iMON VFD, iMON or MCE IR */
|
||||
case 0x7e:
|
||||
dev_info(ictx->dev, "0xffdc iMON VFD, iMON or MCE IR");
|
||||
detected_display_type = IMON_DISPLAY_TYPE_VFD;
|
||||
allowed_protos |= RC_PROTO_BIT_RC6_MCE;
|
||||
break;
|
||||
/* iMON LCD, MCE IR */
|
||||
case 0x9f:
|
||||
dev_info(ictx->dev, "0xffdc iMON LCD, MCE IR");
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue