This is the 4.4.181 stable release
-----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAlz/gVcACgkQONu9yGCS aT4kBQ//adwq+iNdyEF550hc8tWZny0dSLPRKflzTb4hPXnzGdImCSY6pO1KdXzK IhjtgLb8aeFpDSZyyAw+sqFxY/2Nd9GZ5pgetWedm218uX/Hr9ETRUe+QqfmXKfx sIeBfhSSCm2T8HV23SOL+MWqLaHLQFEXWjSDxJAPxB7ptzGiYJ4jmje0MBrN1xV8 22H5ijDR9SweZoR83AFtDAr9hKnpXz2ciQtJ/0xOjnVPGDQgD2uK3mpaO+F2r1hR kbLA2Hst3m4C3mtQZnns/SZWCKURkPk1hFYhKZyD0k757sRcSR4iHnqKdBBk29kR lFNfjVsAARCIj1ucYwwBbkiRJfBaCpT6TMphdtgT0f91zVMOCDTuVTN2couGSsJl 6wWmboyM20SKkHJ3VawvtZ4YcTUjut2B1mZC/iFBSQJsMyVPQkhFzSdAXUKO6VZ9 ZLrMTXNpPwlkYLL7VluIzdUr5crRmYj9sYIH1A/+pyzfM8WZO779jev/i2E4Eipt lU7ak2UMgSEZhv3GWmqPkFnJIpZwHyIsl5bGUWJ2b3wd69VasUjroVxRu1CyynXN CeDnqmJGLSoOlFD6/SF3MCqgvuavt3hgF+eKT2gbVti9zwLnxCxkQ7pgWMQpiMZs uIECSg9f1Zox/E+RpsyWc6Jx7r5yIkYHTlAyIpMuwgT+zwhWXaY= =sf4M -----END PGP SIGNATURE----- Merge 4.4.181 into android-4.4 Changes in 4.4.181 x86/speculation/mds: Revert CPU buffer clear on double fault exit x86/speculation/mds: Improve CPU buffer clear documentation ARM: exynos: Fix a leaked reference by adding missing of_node_put crypto: vmx - fix copy-paste error in CTR mode crypto: crct10dif-generic - fix use via crypto_shash_digest() crypto: x86/crct10dif-pcl - fix use via crypto_shash_digest() ALSA: usb-audio: Fix a memory leak bug ALSA: hda/hdmi - Consider eld_valid when reporting jack event ALSA: hda/realtek - EAPD turn on later ASoC: max98090: Fix restore of DAPM Muxes ASoC: RT5677-SPI: Disable 16Bit SPI Transfers mm/mincore.c: make mincore() more conservative ocfs2: fix ocfs2 read inode data panic in ocfs2_iget mfd: da9063: Fix OTP control register names to match datasheets for DA9063/63L tty/vt: fix write/write race in ioctl(KDSKBSENT) handler ext4: actually request zeroing of inode table after grow ext4: fix ext4_show_options for file systems w/o journal Btrfs: do not start a transaction at iterate_extent_inodes() bcache: fix a race between cache register and cacheset unregister bcache: never set KEY_PTRS of journal key to 0 in journal_reclaim() ipmi:ssif: compare block number correctly for multi-part return messages crypto: gcm - Fix error return code in crypto_gcm_create_common() crypto: gcm - fix incompatibility between "gcm" and "gcm_base" crypto: chacha20poly1305 - set cra_name correctly crypto: salsa20 - don't access already-freed walk.iv crypto: arm/aes-neonbs - don't access already-freed walk.iv writeback: synchronize sync(2) against cgroup writeback membership switches fs/writeback.c: use rcu_barrier() to wait for inflight wb switches going into workqueue when umount ext4: zero out the unused memory region in the extent tree block ALSA: hda/realtek - Fix for Lenovo B50-70 inverted internal microphone bug KVM: x86: Skip EFER vs. guest CPUID checks for host-initiated writes net: avoid weird emergency message net/mlx4_core: Change the error print to info print ppp: deflate: Fix possible crash in deflate_init tipc: switch order of device registration to fix a crash tipc: fix modprobe tipc failed after switch order of device registration stm class: Fix channel free in stm output free path md: add mddev->pers to avoid potential NULL pointer dereference intel_th: msu: Fix single mode with IOMMU of: fix clang -Wunsequenced for be32_to_cpu() cifs: fix strcat buffer overflow and reduce raciness in smb21_set_oplock_level() media: ov6650: Fix sensor possibly not detected on probe NFS4: Fix v4.0 client state corruption when mount clk: tegra: Fix PLLM programming on Tegra124+ when PMC overrides divider fuse: fix writepages on 32bit fuse: honor RLIMIT_FSIZE in fuse_file_fallocate iommu/tegra-smmu: Fix invalid ASID bits on Tegra30/114 ceph: flush dirty inodes before proceeding with remount tracing: Fix partial reading of trace event's id file memory: tegra: Fix integer overflow on tick value calculation perf intel-pt: Fix instructions sampling rate perf intel-pt: Fix improved sample timestamp perf intel-pt: Fix sample timestamp wrt non-taken branches fbdev: sm712fb: fix brightness control on reboot, don't set SR30 fbdev: sm712fb: fix VRAM detection, don't set SR70/71/74/75 fbdev: sm712fb: fix white screen of death on reboot, don't set CR3B-CR3F fbdev: sm712fb: fix boot screen glitch when sm712fb replaces VGA fbdev: sm712fb: fix crashes during framebuffer writes by correctly mapping VRAM fbdev: sm712fb: fix support for 1024x768-16 mode fbdev: sm712fb: use 1024x768 by default on non-MIPS, fix garbled display fbdev: sm712fb: fix crashes and garbled display during DPMS modesetting PCI: Mark Atheros AR9462 to avoid bus reset dm delay: fix a crash when invalid device is specified xfrm: policy: Fix out-of-bound array accesses in __xfrm_policy_unlink xfrm6_tunnel: Fix potential panic when unloading xfrm6_tunnel module vti4: ipip tunnel deregistration fixes. xfrm4: Fix uninitialized memory read in _decode_session4 KVM: arm/arm64: Ensure vcpu target is unset on reset failure power: supply: sysfs: prevent endless uevent loop with CONFIG_POWER_SUPPLY_DEBUG ufs: fix braino in ufs_get_inode_gid() for solaris UFS flavour perf bench numa: Add define for RUSAGE_THREAD if not present Revert "Don't jump to compute_result state from check_result state" md/raid: raid5 preserve the writeback action after the parity check btrfs: Honour FITRIM range constraints during free space trim fbdev: sm712fb: fix memory frequency by avoiding a switch/case fallthrough ext4: do not delete unlinked inode from orphan list on failed truncate KVM: x86: fix return value for reserved EFER bio: fix improper use of smp_mb__before_atomic() Revert "scsi: sd: Keep disk read-only when re-reading partition" crypto: vmx - CTR: always increment IV as quadword gfs2: Fix sign extension bug in gfs2_update_stats Btrfs: fix race between ranged fsync and writeback of adjacent ranges btrfs: sysfs: don't leak memory when failing add fsid fbdev: fix divide error in fb_var_to_videomode hugetlb: use same fault hash key for shared and private mappings fbdev: fix WARNING in __alloc_pages_nodemask bug media: cpia2: Fix use-after-free in cpia2_exit media: vivid: use vfree() instead of kfree() for dev->bitmap_cap ssb: Fix possible NULL pointer dereference in ssb_host_pcmcia_exit at76c50x-usb: Don't register led_trigger if usb_register_driver failed perf tools: No need to include bitops.h in util.h tools include: Adopt linux/bits.h gfs2: Fix lru_count going negative cxgb4: Fix error path in cxgb4_init_module mmc: core: Verify SD bus width powerpc/boot: Fix missing check of lseek() return value ASoC: imx: fix fiq dependencies spi: pxa2xx: fix SCR (divisor) calculation brcm80211: potential NULL dereference in brcmf_cfg80211_vndr_cmds_dcmd_handler() rtc: 88pm860x: prevent use-after-free on device remove w1: fix the resume command API dmaengine: pl330: _stop: clear interrupt status mac80211/cfg80211: update bss channel on channel switch ASoC: fsl_sai: Update is_slave_mode with correct value mwifiex: prevent an array overflow net: cw1200: fix a NULL pointer dereference bcache: return error immediately in bch_journal_replay() bcache: fix failure in journal relplay bcache: add failure check to run_cache_set() for journal replay bcache: avoid clang -Wunintialized warning x86/build: Move _etext to actual end of .text smpboot: Place the __percpu annotation correctly x86/mm: Remove in_nmi() warning from 64-bit implementation of vmalloc_fault() mm/uaccess: Use 'unsigned long' to placate UBSAN warnings on older GCC versions HID: logitech-hidpp: use RAP instead of FAP to get the protocol version pinctrl: pistachio: fix leaked of_node references dmaengine: at_xdmac: remove BUG_ON macro in tasklet media: coda: clear error return value before picture run media: ov6650: Move v4l2_clk_get() to ov6650_video_probe() helper media: au0828: stop video streaming only when last user stops media: ov2659: make S_FMT succeed even if requested format doesn't match audit: fix a memory leak bug media: au0828: Fix NULL pointer dereference in au0828_analog_stream_enable() media: pvrusb2: Prevent a buffer overflow powerpc/numa: improve control of topology updates sched/core: Check quota and period overflow at usec to nsec conversion sched/core: Handle overflow in cpu_shares_write_u64 USB: core: Don't unbind interfaces following device reset failure x86/irq/64: Limit IST stack overflow check to #DB stack i40e: don't allow changes to HW VLAN stripping on active port VLANs RDMA/cxgb4: Fix null pointer dereference on alloc_skb failure hwmon: (vt1211) Use request_muxed_region for Super-IO accesses hwmon: (smsc47m1) Use request_muxed_region for Super-IO accesses hwmon: (smsc47b397) Use request_muxed_region for Super-IO accesses hwmon: (pc87427) Use request_muxed_region for Super-IO accesses hwmon: (f71805f) Use request_muxed_region for Super-IO accesses scsi: libsas: Do discovery on empty PHY to update PHY info mmc_spi: add a status check for spi_sync_locked mmc: sdhci-of-esdhc: add erratum eSDHC5 support mmc: sdhci-of-esdhc: add erratum eSDHC-A001 and A-008358 support PM / core: Propagate dev->power.wakeup_path when no callbacks extcon: arizona: Disable mic detect if running when driver is removed s390: cio: fix cio_irb declaration cpufreq: ppc_cbe: fix possible object reference leak cpufreq/pasemi: fix possible object reference leak cpufreq: pmac32: fix possible object reference leak x86/build: Keep local relocations with ld.lld iio: ad_sigma_delta: Properly handle SPI bus locking vs CS assertion iio: hmc5843: fix potential NULL pointer dereferences iio: common: ssp_sensors: Initialize calculated_time in ssp_common_process_data rtlwifi: fix a potential NULL pointer dereference brcmfmac: fix missing checks for kmemdup b43: shut up clang -Wuninitialized variable warning brcmfmac: convert dev_init_lock mutex to completion brcmfmac: fix race during disconnect when USB completion is in progress scsi: ufs: Fix regulator load and icc-level configuration scsi: ufs: Avoid configuring regulator with undefined voltage range arm64: cpu_ops: fix a leaked reference by adding missing of_node_put x86/ia32: Fix ia32_restore_sigcontext() AC leak chardev: add additional check for minor range overlap HID: core: move Usage Page concatenation to Main item ASoC: eukrea-tlv320: fix a leaked reference by adding missing of_node_put ASoC: fsl_utils: fix a leaked reference by adding missing of_node_put cxgb3/l2t: Fix undefined behaviour spi: tegra114: reset controller on probe media: wl128x: prevent two potential buffer overflows virtio_console: initialize vtermno value for ports tty: ipwireless: fix missing checks for ioremap rcutorture: Fix cleanup path for invalid torture_type strings usb: core: Add PM runtime calls to usb_hcd_platform_shutdown scsi: qla4xxx: avoid freeing unallocated dma memory media: m88ds3103: serialize reset messages in m88ds3103_set_frontend media: go7007: avoid clang frame overflow warning with KASAN media: saa7146: avoid high stack usage with clang scsi: lpfc: Fix SLI3 commands being issued on SLI4 devices spi : spi-topcliff-pch: Fix to handle empty DMA buffers spi: rspi: Fix sequencer reset during initialization spi: Fix zero length xfer bug ASoC: davinci-mcasp: Fix clang warning without CONFIG_PM ipv6: Consider sk_bound_dev_if when binding a raw socket to an address llc: fix skb leak in llc_build_and_send_ui_pkt() net-gro: fix use-after-free read in napi_gro_frags() net: stmmac: fix reset gpio free missing usbnet: fix kernel crash after disconnect tipc: Avoid copying bytes beyond the supplied data bnxt_en: Fix aggregation buffer leak under OOM condition. net: mvpp2: fix bad MVPP2_TXQ_SCHED_TOKEN_CNTR_REG queue value crypto: vmx - ghash: do nosimd fallback manually xen/pciback: Don't disable PCI_COMMAND on PCI device reset. Revert "tipc: fix modprobe tipc failed after switch order of device registration" tipc: fix modprobe tipc failed after switch order of device registration -v2 sparc64: Fix regression in non-hypervisor TLB flush xcall include/linux/bitops.h: sanitize rotate primitives xhci: Convert xhci_handshake() to use readl_poll_timeout_atomic() usb: xhci: avoid null pointer deref when bos field is NULL USB: Fix slab-out-of-bounds write in usb_get_bos_descriptor USB: sisusbvga: fix oops in error path of sisusb_probe USB: Add LPM quirk for Surface Dock GigE adapter USB: rio500: refuse more than one device at a time USB: rio500: fix memory leak in close after disconnect media: usb: siano: Fix general protection fault in smsusb media: usb: siano: Fix false-positive "uninitialized variable" warning media: smsusb: better handle optional alignment scsi: zfcp: fix missing zfcp_port reference put on -EBUSY from port_remove scsi: zfcp: fix to prevent port_remove with pure auto scan LUNs (only sdevs) Btrfs: fix race updating log root item during fsync ALSA: hda/realtek - Set default power save node to 0 drm/nouveau/i2c: Disable i2c bus access after ->fini() tty: serial: msm_serial: Fix XON/XOFF tty: max310x: Fix external crystal register setup memcg: make it work on sparse non-0-node systems kernel/signal.c: trace_signal_deliver when signal_group_exit CIFS: cifs_read_allocate_pages: don't iterate through whole page array on ENOMEM binder: Replace "%p" with "%pK" for stable binder: replace "%p" with "%pK" net: create skb_gso_validate_mac_len() bnx2x: disable GSO where gso_size is too big for hardware brcmfmac: Add length checks on firmware events brcmfmac: screening firmware event packet brcmfmac: revise handling events in receive path brcmfmac: fix incorrect event channel deduction brcmfmac: add length checks in scheduled scan result handler brcmfmac: add subtype check for event handling in data path userfaultfd: don't pin the user memory in userfaultfd_file_create() Revert "x86/build: Move _etext to actual end of .text" net: cdc_ncm: GetNtbFormat endian fix usb: gadget: fix request length error for isoc transfer media: uvcvideo: Fix uvc_alloc_entity() allocation alignment ethtool: fix potential userspace buffer overflow neighbor: Call __ipv4_neigh_lookup_noref in neigh_xmit net/mlx4_en: ethtool, Remove unsupported SFP EEPROM high pages query net: rds: fix memory leak in rds_ib_flush_mr_pool pktgen: do not sleep with the thread lock held. rcu: locking and unlocking need to always be at least barriers parisc: Use implicit space register selection for loading the coherence index of I/O pdirs fuse: fallocate: fix return with locked inode MIPS: pistachio: Build uImage.gz by default genwqe: Prevent an integer overflow in the ioctl drm/gma500/cdv: Check vbt config bits when detecting lvds panels fs: stream_open - opener for stream-like files so that read and write can run simultaneously without deadlock fuse: Add FOPEN_STREAM to use stream_open() ipv4: Define __ipv4_neigh_lookup_noref when CONFIG_INET is disabled ethtool: check the return value of get_regs_len Linux 4.4.181 Change-Id: Ibadc58ab76330698ff36ffdc0ca8c9d52ce36f9e Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
bd858d7309
240 changed files with 2429 additions and 939 deletions
|
|
@ -142,45 +142,13 @@ Mitigation points
|
|||
mds_user_clear.
|
||||
|
||||
The mitigation is invoked in prepare_exit_to_usermode() which covers
|
||||
most of the kernel to user space transitions. There are a few exceptions
|
||||
which are not invoking prepare_exit_to_usermode() on return to user
|
||||
space. These exceptions use the paranoid exit code.
|
||||
all but one of the kernel to user space transitions. The exception
|
||||
is when we return from a Non Maskable Interrupt (NMI), which is
|
||||
handled directly in do_nmi().
|
||||
|
||||
- Non Maskable Interrupt (NMI):
|
||||
|
||||
Access to sensible data like keys, credentials in the NMI context is
|
||||
mostly theoretical: The CPU can do prefetching or execute a
|
||||
misspeculated code path and thereby fetching data which might end up
|
||||
leaking through a buffer.
|
||||
|
||||
But for mounting other attacks the kernel stack address of the task is
|
||||
already valuable information. So in full mitigation mode, the NMI is
|
||||
mitigated on the return from do_nmi() to provide almost complete
|
||||
coverage.
|
||||
|
||||
- Double fault (#DF):
|
||||
|
||||
A double fault is usually fatal, but the ESPFIX workaround, which can
|
||||
be triggered from user space through modify_ldt(2) is a recoverable
|
||||
double fault. #DF uses the paranoid exit path, so explicit mitigation
|
||||
in the double fault handler is required.
|
||||
|
||||
- Machine Check Exception (#MC):
|
||||
|
||||
Another corner case is a #MC which hits between the CPU buffer clear
|
||||
invocation and the actual return to user. As this still is in kernel
|
||||
space it takes the paranoid exit path which does not clear the CPU
|
||||
buffers. So the #MC handler repopulates the buffers to some
|
||||
extent. Machine checks are not reliably controllable and the window is
|
||||
extremly small so mitigation would just tick a checkbox that this
|
||||
theoretical corner case is covered. To keep the amount of special
|
||||
cases small, ignore #MC.
|
||||
|
||||
- Debug Exception (#DB):
|
||||
|
||||
This takes the paranoid exit path only when the INT1 breakpoint is in
|
||||
kernel space. #DB on a user space address takes the regular exit path,
|
||||
so no extra mitigation required.
|
||||
(The reason that NMI is special is that prepare_exit_to_usermode() can
|
||||
enable IRQs. In NMI context, NMIs are blocked, and we don't want to
|
||||
enable IRQs with NMIs blocked.)
|
||||
|
||||
|
||||
2. C-State transition
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -1,6 +1,6 @@
|
|||
VERSION = 4
|
||||
PATCHLEVEL = 4
|
||||
SUBLEVEL = 180
|
||||
SUBLEVEL = 181
|
||||
EXTRAVERSION =
|
||||
NAME = Blurry Fish Butt
|
||||
|
||||
|
|
|
|||
|
|
@ -259,6 +259,8 @@ static int aesbs_xts_encrypt(struct blkcipher_desc *desc,
|
|||
|
||||
blkcipher_walk_init(&walk, dst, src, nbytes);
|
||||
err = blkcipher_walk_virt_block(desc, &walk, 8 * AES_BLOCK_SIZE);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* generate the initial tweak */
|
||||
AES_encrypt(walk.iv, walk.iv, &ctx->twkey);
|
||||
|
|
@ -283,6 +285,8 @@ static int aesbs_xts_decrypt(struct blkcipher_desc *desc,
|
|||
|
||||
blkcipher_walk_init(&walk, dst, src, nbytes);
|
||||
err = blkcipher_walk_virt_block(desc, &walk, 8 * AES_BLOCK_SIZE);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* generate the initial tweak */
|
||||
AES_encrypt(walk.iv, walk.iv, &ctx->twkey);
|
||||
|
|
|
|||
|
|
@ -744,7 +744,7 @@ int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level,
|
|||
static int kvm_vcpu_set_target(struct kvm_vcpu *vcpu,
|
||||
const struct kvm_vcpu_init *init)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int i, ret;
|
||||
int phys_target = kvm_target_cpu();
|
||||
|
||||
if (init->target != phys_target)
|
||||
|
|
@ -779,9 +779,14 @@ static int kvm_vcpu_set_target(struct kvm_vcpu *vcpu,
|
|||
vcpu->arch.target = phys_target;
|
||||
|
||||
/* Now we know what it is, we can reset it. */
|
||||
return kvm_reset_vcpu(vcpu);
|
||||
}
|
||||
ret = kvm_reset_vcpu(vcpu);
|
||||
if (ret) {
|
||||
vcpu->arch.target = -1;
|
||||
bitmap_zero(vcpu->arch.features, KVM_VCPU_MAX_FEATURES);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int kvm_arch_vcpu_ioctl_vcpu_init(struct kvm_vcpu *vcpu,
|
||||
struct kvm_vcpu_init *init)
|
||||
|
|
|
|||
|
|
@ -207,6 +207,7 @@ void __init exynos_firmware_init(void)
|
|||
return;
|
||||
|
||||
addr = of_get_address(nd, 0, NULL, NULL);
|
||||
of_node_put(nd);
|
||||
if (!addr) {
|
||||
pr_err("%s: No address specified.\n", __func__);
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -725,8 +725,10 @@ void __init exynos_pm_init(void)
|
|||
|
||||
if (WARN_ON(!of_find_property(np, "interrupt-controller", NULL))) {
|
||||
pr_warn("Outdated DT detected, suspend/resume will NOT work\n");
|
||||
of_node_put(np);
|
||||
return;
|
||||
}
|
||||
of_node_put(np);
|
||||
|
||||
pm_data = (const struct exynos_pm_data *) match->data;
|
||||
|
||||
|
|
|
|||
|
|
@ -84,6 +84,7 @@ static const char *__init cpu_read_enable_method(int cpu)
|
|||
pr_err("%s: missing enable-method property\n",
|
||||
dn->full_name);
|
||||
}
|
||||
of_node_put(dn);
|
||||
} else {
|
||||
enable_method = acpi_get_enable_method(cpu);
|
||||
if (!enable_method) {
|
||||
|
|
|
|||
|
|
@ -6,3 +6,4 @@ cflags-$(CONFIG_MACH_PISTACHIO) += \
|
|||
-I$(srctree)/arch/mips/include/asm/mach-pistachio
|
||||
load-$(CONFIG_MACH_PISTACHIO) += 0xffffffff80400000
|
||||
zload-$(CONFIG_MACH_PISTACHIO) += 0xffffffff81000000
|
||||
all-$(CONFIG_MACH_PISTACHIO) := uImage.gz
|
||||
|
|
|
|||
|
|
@ -223,7 +223,11 @@ main(int ac, char **av)
|
|||
PUT_16(E_PHNUM, np + 2);
|
||||
|
||||
/* write back */
|
||||
lseek(fd, (long) 0, SEEK_SET);
|
||||
i = lseek(fd, (long) 0, SEEK_SET);
|
||||
if (i < 0) {
|
||||
perror("lseek");
|
||||
exit(1);
|
||||
}
|
||||
i = write(fd, buf, n);
|
||||
if (i < 0) {
|
||||
perror("write");
|
||||
|
|
|
|||
|
|
@ -1611,6 +1611,9 @@ int start_topology_update(void)
|
|||
{
|
||||
int rc = 0;
|
||||
|
||||
if (!topology_updates_enabled)
|
||||
return 0;
|
||||
|
||||
if (firmware_has_feature(FW_FEATURE_PRRN)) {
|
||||
if (!prrn_enabled) {
|
||||
prrn_enabled = 1;
|
||||
|
|
@ -1640,6 +1643,9 @@ int stop_topology_update(void)
|
|||
{
|
||||
int rc = 0;
|
||||
|
||||
if (!topology_updates_enabled)
|
||||
return 0;
|
||||
|
||||
if (prrn_enabled) {
|
||||
prrn_enabled = 0;
|
||||
#ifdef CONFIG_SMP
|
||||
|
|
@ -1685,11 +1691,13 @@ static ssize_t topology_write(struct file *file, const char __user *buf,
|
|||
|
||||
kbuf[read_len] = '\0';
|
||||
|
||||
if (!strncmp(kbuf, "on", 2))
|
||||
if (!strncmp(kbuf, "on", 2)) {
|
||||
topology_updates_enabled = true;
|
||||
start_topology_update();
|
||||
else if (!strncmp(kbuf, "off", 3))
|
||||
} else if (!strncmp(kbuf, "off", 3)) {
|
||||
stop_topology_update();
|
||||
else
|
||||
topology_updates_enabled = false;
|
||||
} else
|
||||
return -EINVAL;
|
||||
|
||||
return count;
|
||||
|
|
@ -1704,9 +1712,7 @@ static const struct file_operations topology_ops = {
|
|||
|
||||
static int topology_update_init(void)
|
||||
{
|
||||
/* Do not poll for changes if disabled at boot */
|
||||
if (topology_updates_enabled)
|
||||
start_topology_update();
|
||||
start_topology_update();
|
||||
|
||||
if (!proc_create("powerpc/topology_updates", 0644, NULL, &topology_ops))
|
||||
return -ENOMEM;
|
||||
|
|
|
|||
|
|
@ -586,7 +586,7 @@ xcall_flush_tlb_kernel_range: /* 44 insns */
|
|||
sub %g7, %g1, %g3
|
||||
srlx %g3, 18, %g2
|
||||
brnz,pn %g2, 2f
|
||||
add %g2, 1, %g2
|
||||
sethi %hi(PAGE_SIZE), %g2
|
||||
sub %g3, %g2, %g3
|
||||
or %g1, 0x20, %g1 ! Nucleus
|
||||
1: stxa %g0, [%g1 + %g3] ASI_DMMU_DEMAP
|
||||
|
|
@ -750,7 +750,7 @@ __cheetah_xcall_flush_tlb_kernel_range: /* 44 insns */
|
|||
sub %g7, %g1, %g3
|
||||
srlx %g3, 18, %g2
|
||||
brnz,pn %g2, 2f
|
||||
add %g2, 1, %g2
|
||||
sethi %hi(PAGE_SIZE), %g2
|
||||
sub %g3, %g2, %g3
|
||||
or %g1, 0x20, %g1 ! Nucleus
|
||||
1: stxa %g0, [%g1 + %g3] ASI_DMMU_DEMAP
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ export REALMODE_CFLAGS
|
|||
export BITS
|
||||
|
||||
ifdef CONFIG_X86_NEED_RELOCS
|
||||
LDFLAGS_vmlinux := --emit-relocs
|
||||
LDFLAGS_vmlinux := --emit-relocs --discard-none
|
||||
endif
|
||||
|
||||
#
|
||||
|
|
|
|||
|
|
@ -76,15 +76,14 @@ static int chksum_final(struct shash_desc *desc, u8 *out)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int __chksum_finup(__u16 *crcp, const u8 *data, unsigned int len,
|
||||
u8 *out)
|
||||
static int __chksum_finup(__u16 crc, const u8 *data, unsigned int len, u8 *out)
|
||||
{
|
||||
if (irq_fpu_usable()) {
|
||||
kernel_fpu_begin();
|
||||
*(__u16 *)out = crc_t10dif_pcl(*crcp, data, len);
|
||||
*(__u16 *)out = crc_t10dif_pcl(crc, data, len);
|
||||
kernel_fpu_end();
|
||||
} else
|
||||
*(__u16 *)out = crc_t10dif_generic(*crcp, data, len);
|
||||
*(__u16 *)out = crc_t10dif_generic(crc, data, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -93,15 +92,13 @@ static int chksum_finup(struct shash_desc *desc, const u8 *data,
|
|||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksum_finup(&ctx->crc, data, len, out);
|
||||
return __chksum_finup(ctx->crc, data, len, out);
|
||||
}
|
||||
|
||||
static int chksum_digest(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length, u8 *out)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksum_finup(&ctx->crc, data, length, out);
|
||||
return __chksum_finup(0, data, length, out);
|
||||
}
|
||||
|
||||
static struct shash_alg alg = {
|
||||
|
|
|
|||
|
|
@ -60,9 +60,8 @@
|
|||
} while (0)
|
||||
|
||||
#define RELOAD_SEG(seg) { \
|
||||
unsigned int pre = GET_SEG(seg); \
|
||||
unsigned int pre = (seg) | 3; \
|
||||
unsigned int cur = get_user_seg(seg); \
|
||||
pre |= 3; \
|
||||
if (pre != cur) \
|
||||
set_user_seg(seg, pre); \
|
||||
}
|
||||
|
|
@ -71,6 +70,7 @@ static int ia32_restore_sigcontext(struct pt_regs *regs,
|
|||
struct sigcontext_32 __user *sc)
|
||||
{
|
||||
unsigned int tmpflags, err = 0;
|
||||
u16 gs, fs, es, ds;
|
||||
void __user *buf;
|
||||
u32 tmp;
|
||||
|
||||
|
|
@ -78,16 +78,10 @@ static int ia32_restore_sigcontext(struct pt_regs *regs,
|
|||
current->restart_block.fn = do_no_restart_syscall;
|
||||
|
||||
get_user_try {
|
||||
/*
|
||||
* Reload fs and gs if they have changed in the signal
|
||||
* handler. This does not handle long fs/gs base changes in
|
||||
* the handler, but does not clobber them at least in the
|
||||
* normal case.
|
||||
*/
|
||||
RELOAD_SEG(gs);
|
||||
RELOAD_SEG(fs);
|
||||
RELOAD_SEG(ds);
|
||||
RELOAD_SEG(es);
|
||||
gs = GET_SEG(gs);
|
||||
fs = GET_SEG(fs);
|
||||
ds = GET_SEG(ds);
|
||||
es = GET_SEG(es);
|
||||
|
||||
COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
|
||||
COPY(dx); COPY(cx); COPY(ip); COPY(ax);
|
||||
|
|
@ -105,6 +99,17 @@ static int ia32_restore_sigcontext(struct pt_regs *regs,
|
|||
buf = compat_ptr(tmp);
|
||||
} get_user_catch(err);
|
||||
|
||||
/*
|
||||
* Reload fs and gs if they have changed in the signal
|
||||
* handler. This does not handle long fs/gs base changes in
|
||||
* the handler, but does not clobber them at least in the
|
||||
* normal case.
|
||||
*/
|
||||
RELOAD_SEG(gs);
|
||||
RELOAD_SEG(fs);
|
||||
RELOAD_SEG(ds);
|
||||
RELOAD_SEG(es);
|
||||
|
||||
err |= fpu__restore_sig(buf, 1);
|
||||
|
||||
force_iret();
|
||||
|
|
|
|||
|
|
@ -25,9 +25,18 @@ int sysctl_panic_on_stackoverflow;
|
|||
/*
|
||||
* Probabilistic stack overflow check:
|
||||
*
|
||||
* Only check the stack in process context, because everything else
|
||||
* runs on the big interrupt stacks. Checking reliably is too expensive,
|
||||
* so we just check from interrupts.
|
||||
* Regular device interrupts can enter on the following stacks:
|
||||
*
|
||||
* - User stack
|
||||
*
|
||||
* - Kernel task stack
|
||||
*
|
||||
* - Interrupt stack if a device driver reenables interrupts
|
||||
* which should only happen in really old drivers.
|
||||
*
|
||||
* - Debug IST stack
|
||||
*
|
||||
* All other contexts are invalid.
|
||||
*/
|
||||
static inline void stack_overflow_check(struct pt_regs *regs)
|
||||
{
|
||||
|
|
@ -53,8 +62,8 @@ static inline void stack_overflow_check(struct pt_regs *regs)
|
|||
return;
|
||||
|
||||
oist = this_cpu_ptr(&orig_ist);
|
||||
estack_top = (u64)oist->ist[0] - EXCEPTION_STKSZ + STACK_TOP_MARGIN;
|
||||
estack_bottom = (u64)oist->ist[N_EXCEPTION_STACKS - 1];
|
||||
estack_bottom = (u64)oist->ist[DEBUG_STACK];
|
||||
estack_top = estack_bottom - DEBUG_STKSZ + STACK_TOP_MARGIN;
|
||||
if (regs->sp >= estack_top && regs->sp <= estack_bottom)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -61,7 +61,6 @@
|
|||
#include <asm/alternative.h>
|
||||
#include <asm/fpu/xstate.h>
|
||||
#include <asm/trace/mpx.h>
|
||||
#include <asm/nospec-branch.h>
|
||||
#include <asm/mpx.h>
|
||||
#include <asm/vm86.h>
|
||||
|
||||
|
|
@ -338,13 +337,6 @@ dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code)
|
|||
regs->ip = (unsigned long)general_protection;
|
||||
regs->sp = (unsigned long)&normal_regs->orig_ax;
|
||||
|
||||
/*
|
||||
* This situation can be triggered by userspace via
|
||||
* modify_ldt(2) and the return does not take the regular
|
||||
* user space exit, so a CPU buffer clear is required when
|
||||
* MDS mitigation is enabled.
|
||||
*/
|
||||
mds_user_clear_cpu_buffers();
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -990,11 +990,8 @@ static u32 emulated_msrs[] = {
|
|||
|
||||
static unsigned num_emulated_msrs;
|
||||
|
||||
bool kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer)
|
||||
static bool __kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer)
|
||||
{
|
||||
if (efer & efer_reserved_bits)
|
||||
return false;
|
||||
|
||||
if (efer & EFER_FFXSR) {
|
||||
struct kvm_cpuid_entry2 *feat;
|
||||
|
||||
|
|
@ -1012,19 +1009,33 @@ bool kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer)
|
|||
}
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
bool kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer)
|
||||
{
|
||||
if (efer & efer_reserved_bits)
|
||||
return false;
|
||||
|
||||
return __kvm_valid_efer(vcpu, efer);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(kvm_valid_efer);
|
||||
|
||||
static int set_efer(struct kvm_vcpu *vcpu, u64 efer)
|
||||
static int set_efer(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
|
||||
{
|
||||
u64 old_efer = vcpu->arch.efer;
|
||||
u64 efer = msr_info->data;
|
||||
|
||||
if (!kvm_valid_efer(vcpu, efer))
|
||||
if (efer & efer_reserved_bits)
|
||||
return 1;
|
||||
|
||||
if (is_paging(vcpu)
|
||||
&& (vcpu->arch.efer & EFER_LME) != (efer & EFER_LME))
|
||||
return 1;
|
||||
if (!msr_info->host_initiated) {
|
||||
if (!__kvm_valid_efer(vcpu, efer))
|
||||
return 1;
|
||||
|
||||
if (is_paging(vcpu) &&
|
||||
(vcpu->arch.efer & EFER_LME) != (efer & EFER_LME))
|
||||
return 1;
|
||||
}
|
||||
|
||||
efer &= ~EFER_LMA;
|
||||
efer |= vcpu->arch.efer & EFER_LMA;
|
||||
|
|
@ -2055,7 +2066,7 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
|
|||
break;
|
||||
|
||||
case MSR_EFER:
|
||||
return set_efer(vcpu, data);
|
||||
return set_efer(vcpu, msr_info);
|
||||
case MSR_K7_HWCR:
|
||||
data &= ~(u64)0x40; /* ignore flush filter disable */
|
||||
data &= ~(u64)0x100; /* ignore ignne emulation enable */
|
||||
|
|
|
|||
|
|
@ -373,8 +373,6 @@ static noinline int vmalloc_fault(unsigned long address)
|
|||
if (!(address >= VMALLOC_START && address < VMALLOC_END))
|
||||
return -1;
|
||||
|
||||
WARN_ON_ONCE(in_nmi());
|
||||
|
||||
/*
|
||||
* Copy kernel mappings over when needed. This can also
|
||||
* happen within a race in page table update. In the later
|
||||
|
|
|
|||
|
|
@ -637,8 +637,8 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
|
|||
|
||||
err = -ENAMETOOLONG;
|
||||
if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
|
||||
"%s(%s,%s)", name, chacha_name,
|
||||
poly_name) >= CRYPTO_MAX_ALG_NAME)
|
||||
"%s(%s,%s)", name, chacha->cra_name,
|
||||
poly->cra_name) >= CRYPTO_MAX_ALG_NAME)
|
||||
goto out_drop_chacha;
|
||||
if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
|
||||
"%s(%s,%s)", name, chacha->cra_driver_name,
|
||||
|
|
|
|||
|
|
@ -65,10 +65,9 @@ static int chksum_final(struct shash_desc *desc, u8 *out)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int __chksum_finup(__u16 *crcp, const u8 *data, unsigned int len,
|
||||
u8 *out)
|
||||
static int __chksum_finup(__u16 crc, const u8 *data, unsigned int len, u8 *out)
|
||||
{
|
||||
*(__u16 *)out = crc_t10dif_generic(*crcp, data, len);
|
||||
*(__u16 *)out = crc_t10dif_generic(crc, data, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -77,15 +76,13 @@ static int chksum_finup(struct shash_desc *desc, const u8 *data,
|
|||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksum_finup(&ctx->crc, data, len, out);
|
||||
return __chksum_finup(ctx->crc, data, len, out);
|
||||
}
|
||||
|
||||
static int chksum_digest(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length, u8 *out)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksum_finup(&ctx->crc, data, length, out);
|
||||
return __chksum_finup(0, data, length, out);
|
||||
}
|
||||
|
||||
static struct shash_alg alg = {
|
||||
|
|
|
|||
36
crypto/gcm.c
36
crypto/gcm.c
|
|
@ -616,7 +616,6 @@ static void crypto_gcm_free(struct aead_instance *inst)
|
|||
|
||||
static int crypto_gcm_create_common(struct crypto_template *tmpl,
|
||||
struct rtattr **tb,
|
||||
const char *full_name,
|
||||
const char *ctr_name,
|
||||
const char *ghash_name)
|
||||
{
|
||||
|
|
@ -657,7 +656,8 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
|
|||
goto err_free_inst;
|
||||
|
||||
err = -EINVAL;
|
||||
if (ghash->digestsize != 16)
|
||||
if (strcmp(ghash->base.cra_name, "ghash") != 0 ||
|
||||
ghash->digestsize != 16)
|
||||
goto err_drop_ghash;
|
||||
|
||||
crypto_set_skcipher_spawn(&ctx->ctr, aead_crypto_instance(inst));
|
||||
|
|
@ -669,24 +669,24 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
|
|||
|
||||
ctr = crypto_skcipher_spawn_alg(&ctx->ctr);
|
||||
|
||||
/* We only support 16-byte blocks. */
|
||||
if (ctr->cra_ablkcipher.ivsize != 16)
|
||||
goto out_put_ctr;
|
||||
|
||||
/* Not a stream cipher? */
|
||||
/* The skcipher algorithm must be CTR mode, using 16-byte blocks. */
|
||||
err = -EINVAL;
|
||||
if (ctr->cra_blocksize != 1)
|
||||
if (strncmp(ctr->cra_name, "ctr(", 4) != 0 ||
|
||||
ctr->cra_ablkcipher.ivsize != 16 ||
|
||||
ctr->cra_blocksize != 1)
|
||||
goto out_put_ctr;
|
||||
|
||||
err = -ENAMETOOLONG;
|
||||
if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
|
||||
"gcm(%s", ctr->cra_name + 4) >= CRYPTO_MAX_ALG_NAME)
|
||||
goto out_put_ctr;
|
||||
|
||||
if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
|
||||
"gcm_base(%s,%s)", ctr->cra_driver_name,
|
||||
ghash_alg->cra_driver_name) >=
|
||||
CRYPTO_MAX_ALG_NAME)
|
||||
goto out_put_ctr;
|
||||
|
||||
memcpy(inst->alg.base.cra_name, full_name, CRYPTO_MAX_ALG_NAME);
|
||||
|
||||
inst->alg.base.cra_flags = (ghash->base.cra_flags | ctr->cra_flags) &
|
||||
CRYPTO_ALG_ASYNC;
|
||||
inst->alg.base.cra_priority = (ghash->base.cra_priority +
|
||||
|
|
@ -727,7 +727,6 @@ static int crypto_gcm_create(struct crypto_template *tmpl, struct rtattr **tb)
|
|||
{
|
||||
const char *cipher_name;
|
||||
char ctr_name[CRYPTO_MAX_ALG_NAME];
|
||||
char full_name[CRYPTO_MAX_ALG_NAME];
|
||||
|
||||
cipher_name = crypto_attr_alg_name(tb[1]);
|
||||
if (IS_ERR(cipher_name))
|
||||
|
|
@ -737,12 +736,7 @@ static int crypto_gcm_create(struct crypto_template *tmpl, struct rtattr **tb)
|
|||
CRYPTO_MAX_ALG_NAME)
|
||||
return -ENAMETOOLONG;
|
||||
|
||||
if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "gcm(%s)", cipher_name) >=
|
||||
CRYPTO_MAX_ALG_NAME)
|
||||
return -ENAMETOOLONG;
|
||||
|
||||
return crypto_gcm_create_common(tmpl, tb, full_name,
|
||||
ctr_name, "ghash");
|
||||
return crypto_gcm_create_common(tmpl, tb, ctr_name, "ghash");
|
||||
}
|
||||
|
||||
static struct crypto_template crypto_gcm_tmpl = {
|
||||
|
|
@ -756,7 +750,6 @@ static int crypto_gcm_base_create(struct crypto_template *tmpl,
|
|||
{
|
||||
const char *ctr_name;
|
||||
const char *ghash_name;
|
||||
char full_name[CRYPTO_MAX_ALG_NAME];
|
||||
|
||||
ctr_name = crypto_attr_alg_name(tb[1]);
|
||||
if (IS_ERR(ctr_name))
|
||||
|
|
@ -766,12 +759,7 @@ static int crypto_gcm_base_create(struct crypto_template *tmpl,
|
|||
if (IS_ERR(ghash_name))
|
||||
return PTR_ERR(ghash_name);
|
||||
|
||||
if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "gcm_base(%s,%s)",
|
||||
ctr_name, ghash_name) >= CRYPTO_MAX_ALG_NAME)
|
||||
return -ENAMETOOLONG;
|
||||
|
||||
return crypto_gcm_create_common(tmpl, tb, full_name,
|
||||
ctr_name, ghash_name);
|
||||
return crypto_gcm_create_common(tmpl, tb, ctr_name, ghash_name);
|
||||
}
|
||||
|
||||
static struct crypto_template crypto_gcm_base_tmpl = {
|
||||
|
|
|
|||
|
|
@ -186,7 +186,7 @@ static int encrypt(struct blkcipher_desc *desc,
|
|||
blkcipher_walk_init(&walk, dst, src, nbytes);
|
||||
err = blkcipher_walk_virt_block(desc, &walk, 64);
|
||||
|
||||
salsa20_ivsetup(ctx, walk.iv);
|
||||
salsa20_ivsetup(ctx, desc->info);
|
||||
|
||||
while (walk.nbytes >= 64) {
|
||||
salsa20_encrypt_bytes(ctx, walk.dst.virt.addr,
|
||||
|
|
|
|||
|
|
@ -1385,6 +1385,10 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
|
|||
if (dev->power.syscore)
|
||||
goto Complete;
|
||||
|
||||
/* Avoid direct_complete to let wakeup_path propagate. */
|
||||
if (device_may_wakeup(dev) || dev->power.wakeup_path)
|
||||
dev->power.direct_complete = false;
|
||||
|
||||
if (dev->power.direct_complete) {
|
||||
if (pm_runtime_status_suspended(dev)) {
|
||||
pm_runtime_disable(dev);
|
||||
|
|
|
|||
|
|
@ -695,12 +695,16 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
|
|||
/* End of read */
|
||||
len = ssif_info->multi_len;
|
||||
data = ssif_info->data;
|
||||
} else if (blocknum != ssif_info->multi_pos) {
|
||||
} else if (blocknum + 1 != ssif_info->multi_pos) {
|
||||
/*
|
||||
* Out of sequence block, just abort. Block
|
||||
* numbers start at zero for the second block,
|
||||
* but multi_pos starts at one, so the +1.
|
||||
*/
|
||||
if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
|
||||
dev_dbg(&ssif_info->client->dev,
|
||||
"Received message out of sequence, expected %u, got %u\n",
|
||||
ssif_info->multi_pos - 1, blocknum);
|
||||
result = -EIO;
|
||||
} else {
|
||||
ssif_inc_stat(ssif_info, received_message_parts);
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ struct ports_driver_data {
|
|||
/* All the console devices handled by this driver */
|
||||
struct list_head consoles;
|
||||
};
|
||||
static struct ports_driver_data pdrvdata;
|
||||
static struct ports_driver_data pdrvdata = { .next_vtermno = 1};
|
||||
|
||||
static DEFINE_SPINLOCK(pdrvdata_lock);
|
||||
static DECLARE_COMPLETION(early_console_added);
|
||||
|
|
@ -1419,6 +1419,7 @@ static int add_port(struct ports_device *portdev, u32 id)
|
|||
port->async_queue = NULL;
|
||||
|
||||
port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
|
||||
port->cons.vtermno = 0;
|
||||
|
||||
port->host_connected = port->guest_connected = false;
|
||||
port->stats = (struct port_stats) { 0 };
|
||||
|
|
|
|||
|
|
@ -492,8 +492,8 @@ static void _update_pll_mnp(struct tegra_clk_pll *pll,
|
|||
pll_override_writel(val, params->pmc_divp_reg, pll);
|
||||
|
||||
val = pll_override_readl(params->pmc_divnm_reg, pll);
|
||||
val &= ~(divm_mask(pll) << div_nmp->override_divm_shift) |
|
||||
~(divn_mask(pll) << div_nmp->override_divn_shift);
|
||||
val &= ~((divm_mask(pll) << div_nmp->override_divm_shift) |
|
||||
(divn_mask(pll) << div_nmp->override_divn_shift));
|
||||
val |= (cfg->m << div_nmp->override_divm_shift) |
|
||||
(cfg->n << div_nmp->override_divn_shift);
|
||||
pll_override_writel(val, params->pmc_divnm_reg, pll);
|
||||
|
|
|
|||
|
|
@ -146,6 +146,7 @@ static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
|
|||
|
||||
cpu = of_get_cpu_node(policy->cpu, NULL);
|
||||
|
||||
of_node_put(cpu);
|
||||
if (!cpu)
|
||||
goto out;
|
||||
|
||||
|
|
|
|||
|
|
@ -549,6 +549,7 @@ static int pmac_cpufreq_init_7447A(struct device_node *cpunode)
|
|||
volt_gpio_np = of_find_node_by_name(NULL, "cpu-vcore-select");
|
||||
if (volt_gpio_np)
|
||||
voltage_gpio = read_gpio(volt_gpio_np);
|
||||
of_node_put(volt_gpio_np);
|
||||
if (!voltage_gpio){
|
||||
printk(KERN_ERR "cpufreq: missing cpu-vcore-select gpio\n");
|
||||
return 1;
|
||||
|
|
@ -585,6 +586,7 @@ static int pmac_cpufreq_init_750FX(struct device_node *cpunode)
|
|||
if (volt_gpio_np)
|
||||
voltage_gpio = read_gpio(volt_gpio_np);
|
||||
|
||||
of_node_put(volt_gpio_np);
|
||||
pvr = mfspr(SPRN_PVR);
|
||||
has_cpu_l2lve = !((pvr & 0xf00) == 0x100);
|
||||
|
||||
|
|
|
|||
|
|
@ -86,6 +86,7 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
|
|||
if (!cbe_get_cpu_pmd_regs(policy->cpu) ||
|
||||
!cbe_get_cpu_mic_tm_regs(policy->cpu)) {
|
||||
pr_info("invalid CBE regs pointers for cpufreq\n");
|
||||
of_node_put(cpu);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1298,7 +1298,7 @@ Loop_ctr32_enc:
|
|||
addi $idx,$idx,16
|
||||
bdnz Loop_ctr32_enc
|
||||
|
||||
vadduwm $ivec,$ivec,$one
|
||||
vadduqm $ivec,$ivec,$one
|
||||
vmr $dat,$inptail
|
||||
lvx $inptail,0,$inp
|
||||
addi $inp,$inp,16
|
||||
|
|
@ -1795,7 +1795,7 @@ Lctr32_enc8x_three:
|
|||
stvx_u $out1,$x10,$out
|
||||
stvx_u $out2,$x20,$out
|
||||
addi $out,$out,0x30
|
||||
b Lcbc_dec8x_done
|
||||
b Lctr32_enc8x_done
|
||||
|
||||
.align 5
|
||||
Lctr32_enc8x_two:
|
||||
|
|
@ -1807,7 +1807,7 @@ Lctr32_enc8x_two:
|
|||
stvx_u $out0,$x00,$out
|
||||
stvx_u $out1,$x10,$out
|
||||
addi $out,$out,0x20
|
||||
b Lcbc_dec8x_done
|
||||
b Lctr32_enc8x_done
|
||||
|
||||
.align 5
|
||||
Lctr32_enc8x_one:
|
||||
|
|
|
|||
|
|
@ -1,22 +1,14 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/**
|
||||
* GHASH routines supporting VMX instructions on the Power 8
|
||||
*
|
||||
* Copyright (C) 2015 International Business Machines Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; version 2 only.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
* Copyright (C) 2015, 2019 International Business Machines Inc.
|
||||
*
|
||||
* Author: Marcelo Henrique Cerri <mhcerri@br.ibm.com>
|
||||
*
|
||||
* Extended by Daniel Axtens <dja@axtens.net> to replace the fallback
|
||||
* mechanism. The new approach is based on arm64 code, which is:
|
||||
* Copyright (C) 2014 - 2018 Linaro Ltd. <ard.biesheuvel@linaro.org>
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
|
|
@ -39,71 +31,25 @@ void gcm_ghash_p8(u64 Xi[2], const u128 htable[16],
|
|||
const u8 *in, size_t len);
|
||||
|
||||
struct p8_ghash_ctx {
|
||||
/* key used by vector asm */
|
||||
u128 htable[16];
|
||||
struct crypto_shash *fallback;
|
||||
/* key used by software fallback */
|
||||
be128 key;
|
||||
};
|
||||
|
||||
struct p8_ghash_desc_ctx {
|
||||
u64 shash[2];
|
||||
u8 buffer[GHASH_DIGEST_SIZE];
|
||||
int bytes;
|
||||
struct shash_desc fallback_desc;
|
||||
};
|
||||
|
||||
static int p8_ghash_init_tfm(struct crypto_tfm *tfm)
|
||||
{
|
||||
const char *alg = "ghash-generic";
|
||||
struct crypto_shash *fallback;
|
||||
struct crypto_shash *shash_tfm = __crypto_shash_cast(tfm);
|
||||
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(tfm);
|
||||
|
||||
fallback = crypto_alloc_shash(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
|
||||
if (IS_ERR(fallback)) {
|
||||
printk(KERN_ERR
|
||||
"Failed to allocate transformation for '%s': %ld\n",
|
||||
alg, PTR_ERR(fallback));
|
||||
return PTR_ERR(fallback);
|
||||
}
|
||||
|
||||
crypto_shash_set_flags(fallback,
|
||||
crypto_shash_get_flags((struct crypto_shash
|
||||
*) tfm));
|
||||
|
||||
/* Check if the descsize defined in the algorithm is still enough. */
|
||||
if (shash_tfm->descsize < sizeof(struct p8_ghash_desc_ctx)
|
||||
+ crypto_shash_descsize(fallback)) {
|
||||
printk(KERN_ERR
|
||||
"Desc size of the fallback implementation (%s) does not match the expected value: %lu vs %u\n",
|
||||
alg,
|
||||
shash_tfm->descsize - sizeof(struct p8_ghash_desc_ctx),
|
||||
crypto_shash_descsize(fallback));
|
||||
return -EINVAL;
|
||||
}
|
||||
ctx->fallback = fallback;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void p8_ghash_exit_tfm(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(tfm);
|
||||
|
||||
if (ctx->fallback) {
|
||||
crypto_free_shash(ctx->fallback);
|
||||
ctx->fallback = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int p8_ghash_init(struct shash_desc *desc)
|
||||
{
|
||||
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(crypto_shash_tfm(desc->tfm));
|
||||
struct p8_ghash_desc_ctx *dctx = shash_desc_ctx(desc);
|
||||
|
||||
dctx->bytes = 0;
|
||||
memset(dctx->shash, 0, GHASH_DIGEST_SIZE);
|
||||
dctx->fallback_desc.tfm = ctx->fallback;
|
||||
dctx->fallback_desc.flags = desc->flags;
|
||||
return crypto_shash_init(&dctx->fallback_desc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int p8_ghash_setkey(struct crypto_shash *tfm, const u8 *key,
|
||||
|
|
@ -122,7 +68,53 @@ static int p8_ghash_setkey(struct crypto_shash *tfm, const u8 *key,
|
|||
gcm_init_p8(ctx->htable, (const u64 *) key);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
return crypto_shash_setkey(ctx->fallback, key, keylen);
|
||||
|
||||
memcpy(&ctx->key, key, GHASH_BLOCK_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void __ghash_block(struct p8_ghash_ctx *ctx,
|
||||
struct p8_ghash_desc_ctx *dctx)
|
||||
{
|
||||
if (!IN_INTERRUPT) {
|
||||
preempt_disable();
|
||||
pagefault_disable();
|
||||
enable_kernel_altivec();
|
||||
enable_kernel_vsx();
|
||||
enable_kernel_fp();
|
||||
gcm_ghash_p8(dctx->shash, ctx->htable,
|
||||
dctx->buffer, GHASH_DIGEST_SIZE);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
} else {
|
||||
crypto_xor((u8 *)dctx->shash, dctx->buffer, GHASH_BLOCK_SIZE);
|
||||
gf128mul_lle((be128 *)dctx->shash, &ctx->key);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void __ghash_blocks(struct p8_ghash_ctx *ctx,
|
||||
struct p8_ghash_desc_ctx *dctx,
|
||||
const u8 *src, unsigned int srclen)
|
||||
{
|
||||
if (!IN_INTERRUPT) {
|
||||
preempt_disable();
|
||||
pagefault_disable();
|
||||
enable_kernel_altivec();
|
||||
enable_kernel_vsx();
|
||||
enable_kernel_fp();
|
||||
gcm_ghash_p8(dctx->shash, ctx->htable,
|
||||
src, srclen);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
} else {
|
||||
while (srclen >= GHASH_BLOCK_SIZE) {
|
||||
crypto_xor((u8 *)dctx->shash, src, GHASH_BLOCK_SIZE);
|
||||
gf128mul_lle((be128 *)dctx->shash, &ctx->key);
|
||||
srclen -= GHASH_BLOCK_SIZE;
|
||||
src += GHASH_BLOCK_SIZE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int p8_ghash_update(struct shash_desc *desc,
|
||||
|
|
@ -132,51 +124,33 @@ static int p8_ghash_update(struct shash_desc *desc,
|
|||
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(crypto_shash_tfm(desc->tfm));
|
||||
struct p8_ghash_desc_ctx *dctx = shash_desc_ctx(desc);
|
||||
|
||||
if (IN_INTERRUPT) {
|
||||
return crypto_shash_update(&dctx->fallback_desc, src,
|
||||
srclen);
|
||||
} else {
|
||||
if (dctx->bytes) {
|
||||
if (dctx->bytes + srclen < GHASH_DIGEST_SIZE) {
|
||||
memcpy(dctx->buffer + dctx->bytes, src,
|
||||
srclen);
|
||||
dctx->bytes += srclen;
|
||||
return 0;
|
||||
}
|
||||
if (dctx->bytes) {
|
||||
if (dctx->bytes + srclen < GHASH_DIGEST_SIZE) {
|
||||
memcpy(dctx->buffer + dctx->bytes, src,
|
||||
GHASH_DIGEST_SIZE - dctx->bytes);
|
||||
preempt_disable();
|
||||
pagefault_disable();
|
||||
enable_kernel_altivec();
|
||||
enable_kernel_vsx();
|
||||
enable_kernel_fp();
|
||||
gcm_ghash_p8(dctx->shash, ctx->htable,
|
||||
dctx->buffer, GHASH_DIGEST_SIZE);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
src += GHASH_DIGEST_SIZE - dctx->bytes;
|
||||
srclen -= GHASH_DIGEST_SIZE - dctx->bytes;
|
||||
dctx->bytes = 0;
|
||||
srclen);
|
||||
dctx->bytes += srclen;
|
||||
return 0;
|
||||
}
|
||||
len = srclen & ~(GHASH_DIGEST_SIZE - 1);
|
||||
if (len) {
|
||||
preempt_disable();
|
||||
pagefault_disable();
|
||||
enable_kernel_altivec();
|
||||
enable_kernel_vsx();
|
||||
enable_kernel_fp();
|
||||
gcm_ghash_p8(dctx->shash, ctx->htable, src, len);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
src += len;
|
||||
srclen -= len;
|
||||
}
|
||||
if (srclen) {
|
||||
memcpy(dctx->buffer, src, srclen);
|
||||
dctx->bytes = srclen;
|
||||
}
|
||||
return 0;
|
||||
memcpy(dctx->buffer + dctx->bytes, src,
|
||||
GHASH_DIGEST_SIZE - dctx->bytes);
|
||||
|
||||
__ghash_block(ctx, dctx);
|
||||
|
||||
src += GHASH_DIGEST_SIZE - dctx->bytes;
|
||||
srclen -= GHASH_DIGEST_SIZE - dctx->bytes;
|
||||
dctx->bytes = 0;
|
||||
}
|
||||
len = srclen & ~(GHASH_DIGEST_SIZE - 1);
|
||||
if (len) {
|
||||
__ghash_blocks(ctx, dctx, src, len);
|
||||
src += len;
|
||||
srclen -= len;
|
||||
}
|
||||
if (srclen) {
|
||||
memcpy(dctx->buffer, src, srclen);
|
||||
dctx->bytes = srclen;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int p8_ghash_final(struct shash_desc *desc, u8 *out)
|
||||
|
|
@ -185,26 +159,14 @@ static int p8_ghash_final(struct shash_desc *desc, u8 *out)
|
|||
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(crypto_shash_tfm(desc->tfm));
|
||||
struct p8_ghash_desc_ctx *dctx = shash_desc_ctx(desc);
|
||||
|
||||
if (IN_INTERRUPT) {
|
||||
return crypto_shash_final(&dctx->fallback_desc, out);
|
||||
} else {
|
||||
if (dctx->bytes) {
|
||||
for (i = dctx->bytes; i < GHASH_DIGEST_SIZE; i++)
|
||||
dctx->buffer[i] = 0;
|
||||
preempt_disable();
|
||||
pagefault_disable();
|
||||
enable_kernel_altivec();
|
||||
enable_kernel_vsx();
|
||||
enable_kernel_fp();
|
||||
gcm_ghash_p8(dctx->shash, ctx->htable,
|
||||
dctx->buffer, GHASH_DIGEST_SIZE);
|
||||
pagefault_enable();
|
||||
preempt_enable();
|
||||
dctx->bytes = 0;
|
||||
}
|
||||
memcpy(out, dctx->shash, GHASH_DIGEST_SIZE);
|
||||
return 0;
|
||||
if (dctx->bytes) {
|
||||
for (i = dctx->bytes; i < GHASH_DIGEST_SIZE; i++)
|
||||
dctx->buffer[i] = 0;
|
||||
__ghash_block(ctx, dctx);
|
||||
dctx->bytes = 0;
|
||||
}
|
||||
memcpy(out, dctx->shash, GHASH_DIGEST_SIZE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct shash_alg p8_ghash_alg = {
|
||||
|
|
@ -219,11 +181,9 @@ struct shash_alg p8_ghash_alg = {
|
|||
.cra_name = "ghash",
|
||||
.cra_driver_name = "p8_ghash",
|
||||
.cra_priority = 1000,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_SHASH | CRYPTO_ALG_NEED_FALLBACK,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_SHASH,
|
||||
.cra_blocksize = GHASH_BLOCK_SIZE,
|
||||
.cra_ctxsize = sizeof(struct p8_ghash_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = p8_ghash_init_tfm,
|
||||
.cra_exit = p8_ghash_exit_tfm,
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1608,7 +1608,11 @@ static void at_xdmac_tasklet(unsigned long data)
|
|||
struct at_xdmac_desc,
|
||||
xfer_node);
|
||||
dev_vdbg(chan2dev(&atchan->chan), "%s: desc 0x%p\n", __func__, desc);
|
||||
BUG_ON(!desc->active_xfer);
|
||||
if (!desc->active_xfer) {
|
||||
dev_err(chan2dev(&atchan->chan), "Xfer not active: exiting");
|
||||
spin_unlock_bh(&atchan->lock);
|
||||
return;
|
||||
}
|
||||
|
||||
txd = &desc->tx_dma_desc;
|
||||
|
||||
|
|
|
|||
|
|
@ -1006,6 +1006,7 @@ static void _stop(struct pl330_thread *thrd)
|
|||
{
|
||||
void __iomem *regs = thrd->dmac->base;
|
||||
u8 insn[6] = {0, 0, 0, 0, 0, 0};
|
||||
u32 inten = readl(regs + INTEN);
|
||||
|
||||
if (_state(thrd) == PL330_STATE_FAULT_COMPLETING)
|
||||
UNTIL(thrd, PL330_STATE_FAULTING | PL330_STATE_KILLING);
|
||||
|
|
@ -1018,10 +1019,13 @@ static void _stop(struct pl330_thread *thrd)
|
|||
|
||||
_emit_KILL(0, insn);
|
||||
|
||||
/* Stop generating interrupts for SEV */
|
||||
writel(readl(regs + INTEN) & ~(1 << thrd->ev), regs + INTEN);
|
||||
|
||||
_execute_DBGINSN(thrd, insn, is_manager(thrd));
|
||||
|
||||
/* clear the event */
|
||||
if (inten & (1 << thrd->ev))
|
||||
writel(1 << thrd->ev, regs + INTCLR);
|
||||
/* Stop generating interrupts for SEV */
|
||||
writel(inten & ~(1 << thrd->ev), regs + INTEN);
|
||||
}
|
||||
|
||||
/* Start doing req 'idx' of thread 'thrd' */
|
||||
|
|
|
|||
|
|
@ -1616,6 +1616,16 @@ static int arizona_extcon_remove(struct platform_device *pdev)
|
|||
struct arizona_extcon_info *info = platform_get_drvdata(pdev);
|
||||
struct arizona *arizona = info->arizona;
|
||||
int jack_irq_rise, jack_irq_fall;
|
||||
bool change;
|
||||
|
||||
regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
|
||||
ARIZONA_MICD_ENA, 0,
|
||||
&change);
|
||||
|
||||
if (change) {
|
||||
regulator_disable(info->micvdd);
|
||||
pm_runtime_put(info->dev);
|
||||
}
|
||||
|
||||
gpiod_put(info->micd_pol_gpio);
|
||||
|
||||
|
|
|
|||
|
|
@ -620,6 +620,9 @@ void cdv_intel_lvds_init(struct drm_device *dev,
|
|||
int pipe;
|
||||
u8 pin;
|
||||
|
||||
if (!dev_priv->lvds_enabled_in_vbt)
|
||||
return;
|
||||
|
||||
pin = GMBUS_PORT_PANEL;
|
||||
if (!lvds_is_present_in_vbt(dev, &pin)) {
|
||||
DRM_DEBUG_KMS("LVDS is not present in VBT\n");
|
||||
|
|
|
|||
|
|
@ -436,6 +436,9 @@ parse_driver_features(struct drm_psb_private *dev_priv,
|
|||
if (driver->lvds_config == BDB_DRIVER_FEATURE_EDP)
|
||||
dev_priv->edp.support = 1;
|
||||
|
||||
dev_priv->lvds_enabled_in_vbt = driver->lvds_config != 0;
|
||||
DRM_DEBUG_KMS("LVDS VBT config bits: 0x%x\n", driver->lvds_config);
|
||||
|
||||
/* This bit means to use 96Mhz for DPLL_A or not */
|
||||
if (driver->primary_lfp_id)
|
||||
dev_priv->dplla_96mhz = true;
|
||||
|
|
|
|||
|
|
@ -536,6 +536,7 @@ struct drm_psb_private {
|
|||
int lvds_ssc_freq;
|
||||
bool is_lvds_on;
|
||||
bool is_mipi_on;
|
||||
bool lvds_enabled_in_vbt;
|
||||
u32 mipi_ctrl_display;
|
||||
|
||||
unsigned int core_freq;
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ struct nvkm_i2c_bus {
|
|||
struct mutex mutex;
|
||||
struct list_head head;
|
||||
struct i2c_adapter i2c;
|
||||
u8 enabled;
|
||||
};
|
||||
|
||||
int nvkm_i2c_bus_acquire(struct nvkm_i2c_bus *);
|
||||
|
|
@ -56,6 +57,7 @@ struct nvkm_i2c_aux {
|
|||
struct mutex mutex;
|
||||
struct list_head head;
|
||||
struct i2c_adapter i2c;
|
||||
u8 enabled;
|
||||
|
||||
u32 intr;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -105,9 +105,15 @@ nvkm_i2c_aux_acquire(struct nvkm_i2c_aux *aux)
|
|||
{
|
||||
struct nvkm_i2c_pad *pad = aux->pad;
|
||||
int ret;
|
||||
|
||||
AUX_TRACE(aux, "acquire");
|
||||
mutex_lock(&aux->mutex);
|
||||
ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_AUX);
|
||||
|
||||
if (aux->enabled)
|
||||
ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_AUX);
|
||||
else
|
||||
ret = -EIO;
|
||||
|
||||
if (ret)
|
||||
mutex_unlock(&aux->mutex);
|
||||
return ret;
|
||||
|
|
@ -141,6 +147,24 @@ nvkm_i2c_aux_del(struct nvkm_i2c_aux **paux)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
nvkm_i2c_aux_init(struct nvkm_i2c_aux *aux)
|
||||
{
|
||||
AUX_TRACE(aux, "init");
|
||||
mutex_lock(&aux->mutex);
|
||||
aux->enabled = true;
|
||||
mutex_unlock(&aux->mutex);
|
||||
}
|
||||
|
||||
void
|
||||
nvkm_i2c_aux_fini(struct nvkm_i2c_aux *aux)
|
||||
{
|
||||
AUX_TRACE(aux, "fini");
|
||||
mutex_lock(&aux->mutex);
|
||||
aux->enabled = false;
|
||||
mutex_unlock(&aux->mutex);
|
||||
}
|
||||
|
||||
int
|
||||
nvkm_i2c_aux_ctor(const struct nvkm_i2c_aux_func *func,
|
||||
struct nvkm_i2c_pad *pad, int id,
|
||||
|
|
|
|||
|
|
@ -14,6 +14,8 @@ int nvkm_i2c_aux_ctor(const struct nvkm_i2c_aux_func *, struct nvkm_i2c_pad *,
|
|||
int nvkm_i2c_aux_new_(const struct nvkm_i2c_aux_func *, struct nvkm_i2c_pad *,
|
||||
int id, struct nvkm_i2c_aux **);
|
||||
void nvkm_i2c_aux_del(struct nvkm_i2c_aux **);
|
||||
void nvkm_i2c_aux_init(struct nvkm_i2c_aux *);
|
||||
void nvkm_i2c_aux_fini(struct nvkm_i2c_aux *);
|
||||
int nvkm_i2c_aux_xfer(struct nvkm_i2c_aux *, bool retry, u8 type,
|
||||
u32 addr, u8 *data, u8 size);
|
||||
|
||||
|
|
|
|||
|
|
@ -160,8 +160,18 @@ nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend)
|
|||
{
|
||||
struct nvkm_i2c *i2c = nvkm_i2c(subdev);
|
||||
struct nvkm_i2c_pad *pad;
|
||||
struct nvkm_i2c_bus *bus;
|
||||
struct nvkm_i2c_aux *aux;
|
||||
u32 mask;
|
||||
|
||||
list_for_each_entry(aux, &i2c->aux, head) {
|
||||
nvkm_i2c_aux_fini(aux);
|
||||
}
|
||||
|
||||
list_for_each_entry(bus, &i2c->bus, head) {
|
||||
nvkm_i2c_bus_fini(bus);
|
||||
}
|
||||
|
||||
if ((mask = (1 << i2c->func->aux) - 1), i2c->func->aux_stat) {
|
||||
i2c->func->aux_mask(i2c, NVKM_I2C_ANY, mask, 0);
|
||||
i2c->func->aux_stat(i2c, &mask, &mask, &mask, &mask);
|
||||
|
|
@ -180,6 +190,7 @@ nvkm_i2c_init(struct nvkm_subdev *subdev)
|
|||
struct nvkm_i2c *i2c = nvkm_i2c(subdev);
|
||||
struct nvkm_i2c_bus *bus;
|
||||
struct nvkm_i2c_pad *pad;
|
||||
struct nvkm_i2c_aux *aux;
|
||||
|
||||
list_for_each_entry(pad, &i2c->pad, head) {
|
||||
nvkm_i2c_pad_init(pad);
|
||||
|
|
@ -189,6 +200,10 @@ nvkm_i2c_init(struct nvkm_subdev *subdev)
|
|||
nvkm_i2c_bus_init(bus);
|
||||
}
|
||||
|
||||
list_for_each_entry(aux, &i2c->aux, head) {
|
||||
nvkm_i2c_aux_init(aux);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -110,6 +110,19 @@ nvkm_i2c_bus_init(struct nvkm_i2c_bus *bus)
|
|||
BUS_TRACE(bus, "init");
|
||||
if (bus->func->init)
|
||||
bus->func->init(bus);
|
||||
|
||||
mutex_lock(&bus->mutex);
|
||||
bus->enabled = true;
|
||||
mutex_unlock(&bus->mutex);
|
||||
}
|
||||
|
||||
void
|
||||
nvkm_i2c_bus_fini(struct nvkm_i2c_bus *bus)
|
||||
{
|
||||
BUS_TRACE(bus, "fini");
|
||||
mutex_lock(&bus->mutex);
|
||||
bus->enabled = false;
|
||||
mutex_unlock(&bus->mutex);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -126,9 +139,15 @@ nvkm_i2c_bus_acquire(struct nvkm_i2c_bus *bus)
|
|||
{
|
||||
struct nvkm_i2c_pad *pad = bus->pad;
|
||||
int ret;
|
||||
|
||||
BUS_TRACE(bus, "acquire");
|
||||
mutex_lock(&bus->mutex);
|
||||
ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_I2C);
|
||||
|
||||
if (bus->enabled)
|
||||
ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_I2C);
|
||||
else
|
||||
ret = -EIO;
|
||||
|
||||
if (ret)
|
||||
mutex_unlock(&bus->mutex);
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ int nvkm_i2c_bus_new_(const struct nvkm_i2c_bus_func *, struct nvkm_i2c_pad *,
|
|||
int id, struct nvkm_i2c_bus **);
|
||||
void nvkm_i2c_bus_del(struct nvkm_i2c_bus **);
|
||||
void nvkm_i2c_bus_init(struct nvkm_i2c_bus *);
|
||||
void nvkm_i2c_bus_fini(struct nvkm_i2c_bus *);
|
||||
|
||||
int nvkm_i2c_bit_xfer(struct nvkm_i2c_bus *, struct i2c_msg *, int);
|
||||
|
||||
|
|
|
|||
|
|
@ -200,13 +200,14 @@ static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
|
|||
* Add a usage to the temporary parser table.
|
||||
*/
|
||||
|
||||
static int hid_add_usage(struct hid_parser *parser, unsigned usage)
|
||||
static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
|
||||
{
|
||||
if (parser->local.usage_index >= HID_MAX_USAGES) {
|
||||
hid_err(parser->device, "usage index exceeded\n");
|
||||
return -1;
|
||||
}
|
||||
parser->local.usage[parser->local.usage_index] = usage;
|
||||
parser->local.usage_size[parser->local.usage_index] = size;
|
||||
parser->local.collection_index[parser->local.usage_index] =
|
||||
parser->collection_stack_ptr ?
|
||||
parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
|
||||
|
|
@ -463,10 +464,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (item->size <= 2)
|
||||
data = (parser->global.usage_page << 16) + data;
|
||||
|
||||
return hid_add_usage(parser, data);
|
||||
return hid_add_usage(parser, data, item->size);
|
||||
|
||||
case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
|
||||
|
||||
|
|
@ -475,9 +473,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (item->size <= 2)
|
||||
data = (parser->global.usage_page << 16) + data;
|
||||
|
||||
parser->local.usage_minimum = data;
|
||||
return 0;
|
||||
|
||||
|
|
@ -488,9 +483,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (item->size <= 2)
|
||||
data = (parser->global.usage_page << 16) + data;
|
||||
|
||||
count = data - parser->local.usage_minimum;
|
||||
if (count + parser->local.usage_index >= HID_MAX_USAGES) {
|
||||
/*
|
||||
|
|
@ -510,7 +502,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|||
}
|
||||
|
||||
for (n = parser->local.usage_minimum; n <= data; n++)
|
||||
if (hid_add_usage(parser, n)) {
|
||||
if (hid_add_usage(parser, n, item->size)) {
|
||||
dbg_hid("hid_add_usage failed\n");
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -524,6 +516,22 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Concatenate Usage Pages into Usages where relevant:
|
||||
* As per specification, 6.2.2.8: "When the parser encounters a main item it
|
||||
* concatenates the last declared Usage Page with a Usage to form a complete
|
||||
* usage value."
|
||||
*/
|
||||
|
||||
static void hid_concatenate_usage_page(struct hid_parser *parser)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < parser->local.usage_index; i++)
|
||||
if (parser->local.usage_size[i] <= 2)
|
||||
parser->local.usage[i] += parser->global.usage_page << 16;
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a main item.
|
||||
*/
|
||||
|
|
@ -533,6 +541,8 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
|
|||
__u32 data;
|
||||
int ret;
|
||||
|
||||
hid_concatenate_usage_page(parser);
|
||||
|
||||
data = item_udata(item);
|
||||
|
||||
switch (item->tag) {
|
||||
|
|
@ -746,6 +756,8 @@ static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
|
|||
__u32 data;
|
||||
int i;
|
||||
|
||||
hid_concatenate_usage_page(parser);
|
||||
|
||||
data = item_udata(item);
|
||||
|
||||
switch (item->tag) {
|
||||
|
|
|
|||
|
|
@ -414,13 +414,16 @@ static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
|
|||
|
||||
static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
|
||||
{
|
||||
const u8 ping_byte = 0x5a;
|
||||
u8 ping_data[3] = { 0, 0, ping_byte };
|
||||
struct hidpp_report response;
|
||||
int ret;
|
||||
|
||||
ret = hidpp_send_fap_command_sync(hidpp,
|
||||
ret = hidpp_send_rap_command_sync(hidpp,
|
||||
REPORT_ID_HIDPP_SHORT,
|
||||
HIDPP_PAGE_ROOT_IDX,
|
||||
CMD_ROOT_GET_PROTOCOL_VERSION,
|
||||
NULL, 0, &response);
|
||||
ping_data, sizeof(ping_data), &response);
|
||||
|
||||
if (ret == HIDPP_ERROR_INVALID_SUBID) {
|
||||
hidpp->protocol_major = 1;
|
||||
|
|
@ -440,8 +443,14 @@ static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
|
|||
if (ret)
|
||||
return ret;
|
||||
|
||||
hidpp->protocol_major = response.fap.params[0];
|
||||
hidpp->protocol_minor = response.fap.params[1];
|
||||
if (response.rap.params[2] != ping_byte) {
|
||||
hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
|
||||
__func__, response.rap.params[2], ping_byte);
|
||||
return -EPROTO;
|
||||
}
|
||||
|
||||
hidpp->protocol_major = response.rap.params[0];
|
||||
hidpp->protocol_minor = response.rap.params[1];
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -96,17 +96,23 @@ superio_select(int base, int ld)
|
|||
outb(ld, base + 1);
|
||||
}
|
||||
|
||||
static inline void
|
||||
static inline int
|
||||
superio_enter(int base)
|
||||
{
|
||||
if (!request_muxed_region(base, 2, DRVNAME))
|
||||
return -EBUSY;
|
||||
|
||||
outb(0x87, base);
|
||||
outb(0x87, base);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
superio_exit(int base)
|
||||
{
|
||||
outb(0xaa, base);
|
||||
release_region(base, 2);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1561,7 +1567,7 @@ exit:
|
|||
static int __init f71805f_find(int sioaddr, unsigned short *address,
|
||||
struct f71805f_sio_data *sio_data)
|
||||
{
|
||||
int err = -ENODEV;
|
||||
int err;
|
||||
u16 devid;
|
||||
|
||||
static const char * const names[] = {
|
||||
|
|
@ -1569,8 +1575,11 @@ static int __init f71805f_find(int sioaddr, unsigned short *address,
|
|||
"F71872F/FG or F71806F/FG",
|
||||
};
|
||||
|
||||
superio_enter(sioaddr);
|
||||
err = superio_enter(sioaddr);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = -ENODEV;
|
||||
devid = superio_inw(sioaddr, SIO_REG_MANID);
|
||||
if (devid != SIO_FINTEK_ID)
|
||||
goto exit;
|
||||
|
|
|
|||
|
|
@ -106,6 +106,13 @@ static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" };
|
|||
#define LD_IN 1
|
||||
#define LD_TEMP 1
|
||||
|
||||
static inline int superio_enter(int sioaddr)
|
||||
{
|
||||
if (!request_muxed_region(sioaddr, 2, DRVNAME))
|
||||
return -EBUSY;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void superio_outb(int sioaddr, int reg, int val)
|
||||
{
|
||||
outb(reg, sioaddr);
|
||||
|
|
@ -122,6 +129,7 @@ static inline void superio_exit(int sioaddr)
|
|||
{
|
||||
outb(0x02, sioaddr);
|
||||
outb(0x02, sioaddr + 1);
|
||||
release_region(sioaddr, 2);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1220,7 +1228,11 @@ static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
|
|||
{
|
||||
u16 val;
|
||||
u8 cfg, cfg_b;
|
||||
int i, err = 0;
|
||||
int i, err;
|
||||
|
||||
err = superio_enter(sioaddr);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Identify device */
|
||||
val = force_id ? force_id : superio_inb(sioaddr, SIOREG_DEVID);
|
||||
|
|
|
|||
|
|
@ -72,14 +72,19 @@ static inline void superio_select(int ld)
|
|||
superio_outb(0x07, ld);
|
||||
}
|
||||
|
||||
static inline void superio_enter(void)
|
||||
static inline int superio_enter(void)
|
||||
{
|
||||
if (!request_muxed_region(REG, 2, DRVNAME))
|
||||
return -EBUSY;
|
||||
|
||||
outb(0x55, REG);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void superio_exit(void)
|
||||
{
|
||||
outb(0xAA, REG);
|
||||
release_region(REG, 2);
|
||||
}
|
||||
|
||||
#define SUPERIO_REG_DEVID 0x20
|
||||
|
|
@ -300,8 +305,12 @@ static int __init smsc47b397_find(void)
|
|||
u8 id, rev;
|
||||
char *name;
|
||||
unsigned short addr;
|
||||
int err;
|
||||
|
||||
err = superio_enter();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
superio_enter();
|
||||
id = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
|
||||
|
||||
switch (id) {
|
||||
|
|
|
|||
|
|
@ -73,16 +73,21 @@ superio_inb(int reg)
|
|||
/* logical device for fans is 0x0A */
|
||||
#define superio_select() superio_outb(0x07, 0x0A)
|
||||
|
||||
static inline void
|
||||
static inline int
|
||||
superio_enter(void)
|
||||
{
|
||||
if (!request_muxed_region(REG, 2, DRVNAME))
|
||||
return -EBUSY;
|
||||
|
||||
outb(0x55, REG);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
superio_exit(void)
|
||||
{
|
||||
outb(0xAA, REG);
|
||||
release_region(REG, 2);
|
||||
}
|
||||
|
||||
#define SUPERIO_REG_ACT 0x30
|
||||
|
|
@ -531,8 +536,12 @@ static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data)
|
|||
{
|
||||
u8 val;
|
||||
unsigned short addr;
|
||||
int err;
|
||||
|
||||
err = superio_enter();
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
superio_enter();
|
||||
val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
|
||||
|
||||
/*
|
||||
|
|
@ -608,13 +617,14 @@ static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data)
|
|||
static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
|
||||
{
|
||||
if ((sio_data->activate & 0x01) == 0) {
|
||||
superio_enter();
|
||||
superio_select();
|
||||
|
||||
pr_info("Disabling device\n");
|
||||
superio_outb(SUPERIO_REG_ACT, sio_data->activate);
|
||||
|
||||
superio_exit();
|
||||
if (!superio_enter()) {
|
||||
superio_select();
|
||||
pr_info("Disabling device\n");
|
||||
superio_outb(SUPERIO_REG_ACT, sio_data->activate);
|
||||
superio_exit();
|
||||
} else {
|
||||
pr_warn("Failed to disable device\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -226,15 +226,21 @@ static inline void superio_select(int sio_cip, int ldn)
|
|||
outb(ldn, sio_cip + 1);
|
||||
}
|
||||
|
||||
static inline void superio_enter(int sio_cip)
|
||||
static inline int superio_enter(int sio_cip)
|
||||
{
|
||||
if (!request_muxed_region(sio_cip, 2, DRVNAME))
|
||||
return -EBUSY;
|
||||
|
||||
outb(0x87, sio_cip);
|
||||
outb(0x87, sio_cip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void superio_exit(int sio_cip)
|
||||
{
|
||||
outb(0xaa, sio_cip);
|
||||
release_region(sio_cip, 2);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------
|
||||
|
|
@ -1282,11 +1288,14 @@ EXIT:
|
|||
|
||||
static int __init vt1211_find(int sio_cip, unsigned short *address)
|
||||
{
|
||||
int err = -ENODEV;
|
||||
int err;
|
||||
int devid;
|
||||
|
||||
superio_enter(sio_cip);
|
||||
err = superio_enter(sio_cip);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = -ENODEV;
|
||||
devid = force_id ? force_id : superio_inb(sio_cip, SIO_VT1211_DEVID);
|
||||
if (devid != SIO_VT1211_ID)
|
||||
goto EXIT;
|
||||
|
|
|
|||
|
|
@ -90,6 +90,7 @@ struct msc_iter {
|
|||
* @reg_base: register window base address
|
||||
* @thdev: intel_th_device pointer
|
||||
* @win_list: list of windows in multiblock mode
|
||||
* @single_sgt: single mode buffer
|
||||
* @nr_pages: total number of pages allocated for this buffer
|
||||
* @single_sz: amount of data in single mode
|
||||
* @single_wrap: single mode wrap occurred
|
||||
|
|
@ -110,6 +111,7 @@ struct msc {
|
|||
struct intel_th_device *thdev;
|
||||
|
||||
struct list_head win_list;
|
||||
struct sg_table single_sgt;
|
||||
unsigned long nr_pages;
|
||||
unsigned long single_sz;
|
||||
unsigned int single_wrap : 1;
|
||||
|
|
@ -610,22 +612,45 @@ static void intel_th_msc_deactivate(struct intel_th_device *thdev)
|
|||
*/
|
||||
static int msc_buffer_contig_alloc(struct msc *msc, unsigned long size)
|
||||
{
|
||||
unsigned long nr_pages = size >> PAGE_SHIFT;
|
||||
unsigned int order = get_order(size);
|
||||
struct page *page;
|
||||
int ret;
|
||||
|
||||
if (!size)
|
||||
return 0;
|
||||
|
||||
ret = sg_alloc_table(&msc->single_sgt, 1, GFP_KERNEL);
|
||||
if (ret)
|
||||
goto err_out;
|
||||
|
||||
ret = -ENOMEM;
|
||||
page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
|
||||
if (!page)
|
||||
return -ENOMEM;
|
||||
goto err_free_sgt;
|
||||
|
||||
split_page(page, order);
|
||||
msc->nr_pages = size >> PAGE_SHIFT;
|
||||
sg_set_buf(msc->single_sgt.sgl, page_address(page), size);
|
||||
|
||||
ret = dma_map_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl, 1,
|
||||
DMA_FROM_DEVICE);
|
||||
if (ret < 0)
|
||||
goto err_free_pages;
|
||||
|
||||
msc->nr_pages = nr_pages;
|
||||
msc->base = page_address(page);
|
||||
msc->base_addr = page_to_phys(page);
|
||||
msc->base_addr = sg_dma_address(msc->single_sgt.sgl);
|
||||
|
||||
return 0;
|
||||
|
||||
err_free_pages:
|
||||
__free_pages(page, order);
|
||||
|
||||
err_free_sgt:
|
||||
sg_free_table(&msc->single_sgt);
|
||||
|
||||
err_out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -636,6 +661,10 @@ static void msc_buffer_contig_free(struct msc *msc)
|
|||
{
|
||||
unsigned long off;
|
||||
|
||||
dma_unmap_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl,
|
||||
1, DMA_FROM_DEVICE);
|
||||
sg_free_table(&msc->single_sgt);
|
||||
|
||||
for (off = 0; off < msc->nr_pages << PAGE_SHIFT; off += PAGE_SIZE) {
|
||||
struct page *page = virt_to_page(msc->base + off);
|
||||
|
||||
|
|
|
|||
|
|
@ -210,8 +210,8 @@ stm_output_disclaim(struct stm_device *stm, struct stm_output *output)
|
|||
bitmap_release_region(&master->chan_map[0], output->channel,
|
||||
ilog2(output->nr_chans));
|
||||
|
||||
output->nr_chans = 0;
|
||||
master->nr_free += output->nr_chans;
|
||||
output->nr_chans = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,
|
|||
struct spi_transfer t = {
|
||||
.tx_buf = data,
|
||||
.len = size + 1,
|
||||
.cs_change = sigma_delta->bus_locked,
|
||||
.cs_change = sigma_delta->keep_cs_asserted,
|
||||
};
|
||||
struct spi_message m;
|
||||
int ret;
|
||||
|
|
@ -217,6 +217,7 @@ static int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
|
|||
|
||||
spi_bus_lock(sigma_delta->spi->master);
|
||||
sigma_delta->bus_locked = true;
|
||||
sigma_delta->keep_cs_asserted = true;
|
||||
reinit_completion(&sigma_delta->completion);
|
||||
|
||||
ret = ad_sigma_delta_set_mode(sigma_delta, mode);
|
||||
|
|
@ -234,9 +235,10 @@ static int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
|
|||
ret = 0;
|
||||
}
|
||||
out:
|
||||
sigma_delta->keep_cs_asserted = false;
|
||||
ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
|
||||
sigma_delta->bus_locked = false;
|
||||
spi_bus_unlock(sigma_delta->spi->master);
|
||||
ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -288,6 +290,7 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
|
|||
|
||||
spi_bus_lock(sigma_delta->spi->master);
|
||||
sigma_delta->bus_locked = true;
|
||||
sigma_delta->keep_cs_asserted = true;
|
||||
reinit_completion(&sigma_delta->completion);
|
||||
|
||||
ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);
|
||||
|
|
@ -297,9 +300,6 @@ int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
|
|||
ret = wait_for_completion_interruptible_timeout(
|
||||
&sigma_delta->completion, HZ);
|
||||
|
||||
sigma_delta->bus_locked = false;
|
||||
spi_bus_unlock(sigma_delta->spi->master);
|
||||
|
||||
if (ret == 0)
|
||||
ret = -EIO;
|
||||
if (ret < 0)
|
||||
|
|
@ -315,7 +315,10 @@ out:
|
|||
sigma_delta->irq_dis = true;
|
||||
}
|
||||
|
||||
sigma_delta->keep_cs_asserted = false;
|
||||
ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
|
||||
sigma_delta->bus_locked = false;
|
||||
spi_bus_unlock(sigma_delta->spi->master);
|
||||
mutex_unlock(&indio_dev->mlock);
|
||||
|
||||
if (ret)
|
||||
|
|
@ -352,6 +355,8 @@ static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)
|
|||
|
||||
spi_bus_lock(sigma_delta->spi->master);
|
||||
sigma_delta->bus_locked = true;
|
||||
sigma_delta->keep_cs_asserted = true;
|
||||
|
||||
ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);
|
||||
if (ret)
|
||||
goto err_unlock;
|
||||
|
|
@ -380,6 +385,7 @@ static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev)
|
|||
sigma_delta->irq_dis = true;
|
||||
}
|
||||
|
||||
sigma_delta->keep_cs_asserted = false;
|
||||
ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
|
||||
|
||||
sigma_delta->bus_locked = false;
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ int ssp_common_process_data(struct iio_dev *indio_dev, void *buf,
|
|||
unsigned int len, int64_t timestamp)
|
||||
{
|
||||
__le32 time;
|
||||
int64_t calculated_time;
|
||||
int64_t calculated_time = 0;
|
||||
struct ssp_sensor_data *spd = iio_priv(indio_dev);
|
||||
|
||||
if (indio_dev->scan_bytes == 0)
|
||||
|
|
|
|||
|
|
@ -360,6 +360,8 @@ static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp)
|
|||
skb_reset_transport_header(skb);
|
||||
} else {
|
||||
skb = alloc_skb(len, gfp);
|
||||
if (!skb)
|
||||
return NULL;
|
||||
}
|
||||
t4_set_arp_err_handler(skb, NULL, NULL);
|
||||
return skb;
|
||||
|
|
|
|||
|
|
@ -91,7 +91,6 @@ static inline u32 smmu_readl(struct tegra_smmu *smmu, unsigned long offset)
|
|||
#define SMMU_TLB_FLUSH_VA_MATCH_ALL (0 << 0)
|
||||
#define SMMU_TLB_FLUSH_VA_MATCH_SECTION (2 << 0)
|
||||
#define SMMU_TLB_FLUSH_VA_MATCH_GROUP (3 << 0)
|
||||
#define SMMU_TLB_FLUSH_ASID(x) (((x) & 0x7f) << 24)
|
||||
#define SMMU_TLB_FLUSH_VA_SECTION(addr) ((((addr) & 0xffc00000) >> 12) | \
|
||||
SMMU_TLB_FLUSH_VA_MATCH_SECTION)
|
||||
#define SMMU_TLB_FLUSH_VA_GROUP(addr) ((((addr) & 0xffffc000) >> 12) | \
|
||||
|
|
@ -194,8 +193,12 @@ static inline void smmu_flush_tlb_asid(struct tegra_smmu *smmu,
|
|||
{
|
||||
u32 value;
|
||||
|
||||
value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
|
||||
SMMU_TLB_FLUSH_VA_MATCH_ALL;
|
||||
if (smmu->soc->num_asids == 4)
|
||||
value = (asid & 0x3) << 29;
|
||||
else
|
||||
value = (asid & 0x7f) << 24;
|
||||
|
||||
value |= SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_VA_MATCH_ALL;
|
||||
smmu_writel(smmu, value, SMMU_TLB_FLUSH);
|
||||
}
|
||||
|
||||
|
|
@ -205,8 +208,12 @@ static inline void smmu_flush_tlb_section(struct tegra_smmu *smmu,
|
|||
{
|
||||
u32 value;
|
||||
|
||||
value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
|
||||
SMMU_TLB_FLUSH_VA_SECTION(iova);
|
||||
if (smmu->soc->num_asids == 4)
|
||||
value = (asid & 0x3) << 29;
|
||||
else
|
||||
value = (asid & 0x7f) << 24;
|
||||
|
||||
value |= SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_VA_SECTION(iova);
|
||||
smmu_writel(smmu, value, SMMU_TLB_FLUSH);
|
||||
}
|
||||
|
||||
|
|
@ -216,8 +223,12 @@ static inline void smmu_flush_tlb_group(struct tegra_smmu *smmu,
|
|||
{
|
||||
u32 value;
|
||||
|
||||
value = SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_ASID(asid) |
|
||||
SMMU_TLB_FLUSH_VA_GROUP(iova);
|
||||
if (smmu->soc->num_asids == 4)
|
||||
value = (asid & 0x3) << 29;
|
||||
else
|
||||
value = (asid & 0x7f) << 24;
|
||||
|
||||
value |= SMMU_TLB_FLUSH_ASID_MATCH | SMMU_TLB_FLUSH_VA_GROUP(iova);
|
||||
smmu_writel(smmu, value, SMMU_TLB_FLUSH);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -324,10 +324,11 @@ static int bch_allocator_thread(void *arg)
|
|||
* possibly issue discards to them, then we add the bucket to
|
||||
* the free list:
|
||||
*/
|
||||
while (!fifo_empty(&ca->free_inc)) {
|
||||
while (1) {
|
||||
long bucket;
|
||||
|
||||
fifo_pop(&ca->free_inc, bucket);
|
||||
if (!fifo_pop(&ca->free_inc, bucket))
|
||||
break;
|
||||
|
||||
if (ca->discard) {
|
||||
mutex_unlock(&ca->set->bucket_lock);
|
||||
|
|
|
|||
|
|
@ -309,6 +309,18 @@ void bch_journal_mark(struct cache_set *c, struct list_head *list)
|
|||
}
|
||||
}
|
||||
|
||||
bool is_discard_enabled(struct cache_set *s)
|
||||
{
|
||||
struct cache *ca;
|
||||
unsigned int i;
|
||||
|
||||
for_each_cache(ca, s, i)
|
||||
if (ca->discard)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int bch_journal_replay(struct cache_set *s, struct list_head *list)
|
||||
{
|
||||
int ret = 0, keys = 0, entries = 0;
|
||||
|
|
@ -322,9 +334,17 @@ int bch_journal_replay(struct cache_set *s, struct list_head *list)
|
|||
list_for_each_entry(i, list, list) {
|
||||
BUG_ON(i->pin && atomic_read(i->pin) != 1);
|
||||
|
||||
cache_set_err_on(n != i->j.seq, s,
|
||||
"bcache: journal entries %llu-%llu missing! (replaying %llu-%llu)",
|
||||
n, i->j.seq - 1, start, end);
|
||||
if (n != i->j.seq) {
|
||||
if (n == start && is_discard_enabled(s))
|
||||
pr_info("bcache: journal entries %llu-%llu may be discarded! (replaying %llu-%llu)",
|
||||
n, i->j.seq - 1, start, end);
|
||||
else {
|
||||
pr_err("bcache: journal entries %llu-%llu missing! (replaying %llu-%llu)",
|
||||
n, i->j.seq - 1, start, end);
|
||||
ret = -EIO;
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
for (k = i->j.start;
|
||||
k < bset_bkey_last(&i->j);
|
||||
|
|
@ -513,11 +533,11 @@ static void journal_reclaim(struct cache_set *c)
|
|||
ca->sb.nr_this_dev);
|
||||
}
|
||||
|
||||
bkey_init(k);
|
||||
SET_KEY_PTRS(k, n);
|
||||
|
||||
if (n)
|
||||
if (n) {
|
||||
bkey_init(k);
|
||||
SET_KEY_PTRS(k, n);
|
||||
c->journal.blocks_free = c->sb.bucket_size >> c->block_bits;
|
||||
}
|
||||
out:
|
||||
if (!journal_full(&c->journal))
|
||||
__closure_wake_up(&c->journal.wait);
|
||||
|
|
@ -641,6 +661,9 @@ static void journal_write_unlocked(struct closure *cl)
|
|||
ca->journal.seq[ca->journal.cur_idx] = w->data->seq;
|
||||
}
|
||||
|
||||
/* If KEY_PTRS(k) == 0, this jset gets lost in air */
|
||||
BUG_ON(i == 0);
|
||||
|
||||
atomic_dec_bug(&fifo_back(&c->journal.pin));
|
||||
bch_journal_next(&c->journal);
|
||||
journal_reclaim(c);
|
||||
|
|
|
|||
|
|
@ -1355,6 +1355,7 @@ static void cache_set_free(struct closure *cl)
|
|||
bch_btree_cache_free(c);
|
||||
bch_journal_free(c);
|
||||
|
||||
mutex_lock(&bch_register_lock);
|
||||
for_each_cache(ca, c, i)
|
||||
if (ca) {
|
||||
ca->set = NULL;
|
||||
|
|
@ -1377,7 +1378,6 @@ static void cache_set_free(struct closure *cl)
|
|||
mempool_destroy(c->search);
|
||||
kfree(c->devices);
|
||||
|
||||
mutex_lock(&bch_register_lock);
|
||||
list_del(&c->list);
|
||||
mutex_unlock(&bch_register_lock);
|
||||
|
||||
|
|
@ -1558,7 +1558,7 @@ err:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static void run_cache_set(struct cache_set *c)
|
||||
static int run_cache_set(struct cache_set *c)
|
||||
{
|
||||
const char *err = "cannot allocate memory";
|
||||
struct cached_dev *dc, *t;
|
||||
|
|
@ -1650,7 +1650,9 @@ static void run_cache_set(struct cache_set *c)
|
|||
if (j->version < BCACHE_JSET_VERSION_UUID)
|
||||
__uuid_write(c);
|
||||
|
||||
bch_journal_replay(c, &journal);
|
||||
err = "bcache: replay journal failed";
|
||||
if (bch_journal_replay(c, &journal))
|
||||
goto err;
|
||||
} else {
|
||||
pr_notice("invalidating existing data");
|
||||
|
||||
|
|
@ -1718,11 +1720,13 @@ static void run_cache_set(struct cache_set *c)
|
|||
flash_devs_run(c);
|
||||
|
||||
set_bit(CACHE_SET_RUNNING, &c->flags);
|
||||
return;
|
||||
return 0;
|
||||
err:
|
||||
closure_sync(&cl);
|
||||
/* XXX: test this, it's broken */
|
||||
bch_cache_set_error(c, "%s", err);
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static bool can_attach_cache(struct cache *ca, struct cache_set *c)
|
||||
|
|
@ -1786,8 +1790,11 @@ found:
|
|||
ca->set->cache[ca->sb.nr_this_dev] = ca;
|
||||
c->cache_by_alloc[c->caches_loaded++] = ca;
|
||||
|
||||
if (c->caches_loaded == c->sb.nr_in_set)
|
||||
run_cache_set(c);
|
||||
if (c->caches_loaded == c->sb.nr_in_set) {
|
||||
err = "failed to run cache set";
|
||||
if (run_cache_set(c) < 0)
|
||||
goto err;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
err:
|
||||
|
|
|
|||
|
|
@ -222,7 +222,8 @@ static void delay_dtr(struct dm_target *ti)
|
|||
{
|
||||
struct delay_c *dc = ti->private;
|
||||
|
||||
destroy_workqueue(dc->kdelayd_wq);
|
||||
if (dc->kdelayd_wq)
|
||||
destroy_workqueue(dc->kdelayd_wq);
|
||||
|
||||
dm_put_device(ti, dc->dev_read);
|
||||
|
||||
|
|
|
|||
|
|
@ -2690,8 +2690,10 @@ state_store(struct md_rdev *rdev, const char *buf, size_t len)
|
|||
err = 0;
|
||||
}
|
||||
} else if (cmd_match(buf, "re-add")) {
|
||||
if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
|
||||
rdev->saved_raid_disk >= 0) {
|
||||
if (!rdev->mddev->pers)
|
||||
err = -EINVAL;
|
||||
else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
|
||||
rdev->saved_raid_disk >= 0) {
|
||||
/* clear_bit is performed _after_ all the devices
|
||||
* have their local Faulty bit cleared. If any writes
|
||||
* happen in the meantime in the local node, they
|
||||
|
|
|
|||
|
|
@ -3861,7 +3861,7 @@ static void handle_parity_checks6(struct r5conf *conf, struct stripe_head *sh,
|
|||
/* now write out any block on a failed drive,
|
||||
* or P or Q if they were recomputed
|
||||
*/
|
||||
BUG_ON(s->uptodate < disks - 1); /* We don't need Q to recover */
|
||||
dev = NULL;
|
||||
if (s->failed == 2) {
|
||||
dev = &sh->dev[s->failed_num[1]];
|
||||
s->locked++;
|
||||
|
|
@ -3886,6 +3886,14 @@ static void handle_parity_checks6(struct r5conf *conf, struct stripe_head *sh,
|
|||
set_bit(R5_LOCKED, &dev->flags);
|
||||
set_bit(R5_Wantwrite, &dev->flags);
|
||||
}
|
||||
if (WARN_ONCE(dev && !test_bit(R5_UPTODATE, &dev->flags),
|
||||
"%s: disk%td not up to date\n",
|
||||
mdname(conf->mddev),
|
||||
dev - (struct r5dev *) &sh->dev)) {
|
||||
clear_bit(R5_LOCKED, &dev->flags);
|
||||
clear_bit(R5_Wantwrite, &dev->flags);
|
||||
s->locked--;
|
||||
}
|
||||
clear_bit(STRIPE_DEGRADED, &sh->state);
|
||||
|
||||
set_bit(STRIPE_INSYNC, &sh->state);
|
||||
|
|
@ -3897,15 +3905,26 @@ static void handle_parity_checks6(struct r5conf *conf, struct stripe_head *sh,
|
|||
case check_state_check_result:
|
||||
sh->check_state = check_state_idle;
|
||||
|
||||
if (s->failed > 1)
|
||||
break;
|
||||
/* handle a successful check operation, if parity is correct
|
||||
* we are done. Otherwise update the mismatch count and repair
|
||||
* parity if !MD_RECOVERY_CHECK
|
||||
*/
|
||||
if (sh->ops.zero_sum_result == 0) {
|
||||
/* Any parity checked was correct */
|
||||
set_bit(STRIPE_INSYNC, &sh->state);
|
||||
/* both parities are correct */
|
||||
if (!s->failed)
|
||||
set_bit(STRIPE_INSYNC, &sh->state);
|
||||
else {
|
||||
/* in contrast to the raid5 case we can validate
|
||||
* parity, but still have a failure to write
|
||||
* back
|
||||
*/
|
||||
sh->check_state = check_state_compute_result;
|
||||
/* Returning at this point means that we may go
|
||||
* off and bring p and/or q uptodate again so
|
||||
* we make sure to check zero_sum_result again
|
||||
* to verify if p or q need writeback
|
||||
*/
|
||||
}
|
||||
} else {
|
||||
atomic64_add(STRIPE_SECTORS, &conf->mddev->resync_mismatches);
|
||||
if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
|
||||
|
|
|
|||
|
|
@ -309,6 +309,9 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
|
|||
u16 u16tmp, divide_ratio = 0;
|
||||
u32 tuner_frequency, target_mclk;
|
||||
s32 s32tmp;
|
||||
static const struct reg_sequence reset_buf[] = {
|
||||
{0x07, 0x80}, {0x07, 0x00}
|
||||
};
|
||||
|
||||
dev_dbg(&client->dev,
|
||||
"delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
|
||||
|
|
@ -321,11 +324,7 @@ static int m88ds3103_set_frontend(struct dvb_frontend *fe)
|
|||
}
|
||||
|
||||
/* reset */
|
||||
ret = regmap_write(dev->regmap, 0x07, 0x80);
|
||||
if (ret)
|
||||
goto err;
|
||||
|
||||
ret = regmap_write(dev->regmap, 0x07, 0x00);
|
||||
ret = regmap_multi_reg_write(dev->regmap, reset_buf, 2);
|
||||
if (ret)
|
||||
goto err;
|
||||
|
||||
|
|
|
|||
|
|
@ -1117,8 +1117,10 @@ static int ov2659_set_fmt(struct v4l2_subdev *sd,
|
|||
if (ov2659_formats[index].code == mf->code)
|
||||
break;
|
||||
|
||||
if (index < 0)
|
||||
return -EINVAL;
|
||||
if (index < 0) {
|
||||
index = 0;
|
||||
mf->code = ov2659_formats[index].code;
|
||||
}
|
||||
|
||||
mf->colorspace = V4L2_COLORSPACE_SRGB;
|
||||
mf->code = ov2659_formats[index].code;
|
||||
|
|
|
|||
|
|
@ -839,9 +839,18 @@ static int ov6650_video_probe(struct i2c_client *client)
|
|||
u8 pidh, pidl, midh, midl;
|
||||
int ret;
|
||||
|
||||
priv->clk = v4l2_clk_get(&client->dev, NULL);
|
||||
if (IS_ERR(priv->clk)) {
|
||||
ret = PTR_ERR(priv->clk);
|
||||
dev_err(&client->dev, "v4l2_clk request err: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = ov6650_s_power(&priv->subdev, 1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
goto eclkput;
|
||||
|
||||
msleep(20);
|
||||
|
||||
/*
|
||||
* check and show product ID and manufacturer ID
|
||||
|
|
@ -876,6 +885,11 @@ static int ov6650_video_probe(struct i2c_client *client)
|
|||
|
||||
done:
|
||||
ov6650_s_power(&priv->subdev, 0);
|
||||
if (!ret)
|
||||
return 0;
|
||||
eclkput:
|
||||
v4l2_clk_put(priv->clk);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -1033,18 +1047,9 @@ static int ov6650_probe(struct i2c_client *client,
|
|||
priv->code = MEDIA_BUS_FMT_YUYV8_2X8;
|
||||
priv->colorspace = V4L2_COLORSPACE_JPEG;
|
||||
|
||||
priv->clk = v4l2_clk_get(&client->dev, NULL);
|
||||
if (IS_ERR(priv->clk)) {
|
||||
ret = PTR_ERR(priv->clk);
|
||||
goto eclkget;
|
||||
}
|
||||
|
||||
ret = ov6650_video_probe(client);
|
||||
if (ret) {
|
||||
v4l2_clk_put(priv->clk);
|
||||
eclkget:
|
||||
if (ret)
|
||||
v4l2_ctrl_handler_free(&priv->hdl);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -270,9 +270,8 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d
|
|||
/* enable i2c-port pins */
|
||||
saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
|
||||
|
||||
hexium->i2c_adapter = (struct i2c_adapter) {
|
||||
.name = "hexium gemini",
|
||||
};
|
||||
strscpy(hexium->i2c_adapter.name, "hexium gemini",
|
||||
sizeof(hexium->i2c_adapter.name));
|
||||
saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
|
||||
if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
|
||||
DEB_S("cannot register i2c-device. skipping.\n");
|
||||
|
|
|
|||
|
|
@ -232,9 +232,8 @@ static int hexium_probe(struct saa7146_dev *dev)
|
|||
saa7146_write(dev, DD1_STREAM_B, 0x00000000);
|
||||
saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
|
||||
|
||||
hexium->i2c_adapter = (struct i2c_adapter) {
|
||||
.name = "hexium orion",
|
||||
};
|
||||
strscpy(hexium->i2c_adapter.name, "hexium orion",
|
||||
sizeof(hexium->i2c_adapter.name));
|
||||
saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
|
||||
if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
|
||||
DEB_S("cannot register i2c-device. skipping.\n");
|
||||
|
|
|
|||
|
|
@ -1829,6 +1829,9 @@ static int coda_prepare_decode(struct coda_ctx *ctx)
|
|||
/* Clear decode success flag */
|
||||
coda_write(dev, 0, CODA_RET_DEC_PIC_SUCCESS);
|
||||
|
||||
/* Clear error return value */
|
||||
coda_write(dev, 0, CODA_RET_DEC_PIC_ERR_MB);
|
||||
|
||||
trace_coda_dec_pic_run(ctx, meta);
|
||||
|
||||
coda_command_async(ctx, CODA_COMMAND_PIC_RUN);
|
||||
|
|
|
|||
|
|
@ -993,7 +993,7 @@ int vivid_vid_cap_s_selection(struct file *file, void *fh, struct v4l2_selection
|
|||
rect_map_inside(&s->r, &dev->fmt_cap_rect);
|
||||
if (dev->bitmap_cap && (compose->width != s->r.width ||
|
||||
compose->height != s->r.height)) {
|
||||
kfree(dev->bitmap_cap);
|
||||
vfree(dev->bitmap_cap);
|
||||
dev->bitmap_cap = NULL;
|
||||
}
|
||||
*compose = s->r;
|
||||
|
|
|
|||
|
|
@ -494,7 +494,8 @@ int fmc_send_cmd(struct fmdev *fmdev, u8 fm_op, u16 type, void *payload,
|
|||
return -EIO;
|
||||
}
|
||||
/* Send response data to caller */
|
||||
if (response != NULL && response_len != NULL && evt_hdr->dlen) {
|
||||
if (response != NULL && response_len != NULL && evt_hdr->dlen &&
|
||||
evt_hdr->dlen <= payload_len) {
|
||||
/* Skip header info and copy only response data */
|
||||
skb_pull(skb, sizeof(struct fm_event_msg_hdr));
|
||||
memcpy(response, skb->data, evt_hdr->dlen);
|
||||
|
|
@ -590,6 +591,8 @@ static void fm_irq_handle_flag_getcmd_resp(struct fmdev *fmdev)
|
|||
return;
|
||||
|
||||
fm_evt_hdr = (void *)skb->data;
|
||||
if (fm_evt_hdr->dlen > sizeof(fmdev->irq_info.flag))
|
||||
return;
|
||||
|
||||
/* Skip header info and copy only response data */
|
||||
skb_pull(skb, sizeof(struct fm_event_msg_hdr));
|
||||
|
|
@ -1315,7 +1318,7 @@ static int load_default_rx_configuration(struct fmdev *fmdev)
|
|||
static int fm_power_up(struct fmdev *fmdev, u8 mode)
|
||||
{
|
||||
u16 payload;
|
||||
__be16 asic_id, asic_ver;
|
||||
__be16 asic_id = 0, asic_ver = 0;
|
||||
int resp_len, ret;
|
||||
u8 fw_name[50];
|
||||
|
||||
|
|
|
|||
|
|
@ -711,6 +711,9 @@ static int au0828_analog_stream_enable(struct au0828_dev *d)
|
|||
|
||||
dprintk(1, "au0828_analog_stream_enable called\n");
|
||||
|
||||
if (test_bit(DEV_DISCONNECTED, &d->dev_state))
|
||||
return -ENODEV;
|
||||
|
||||
iface = usb_ifnum_to_if(d->usbdev, 0);
|
||||
if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) {
|
||||
dprintk(1, "Changing intf#0 to alt 5\n");
|
||||
|
|
@ -799,9 +802,9 @@ int au0828_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
|
|||
return rc;
|
||||
}
|
||||
|
||||
v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
|
||||
|
||||
if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
|
||||
v4l2_device_call_all(&dev->v4l2_dev, 0, video,
|
||||
s_stream, 1);
|
||||
dev->vid_timeout_running = 1;
|
||||
mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
|
||||
} else if (vq->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
|
||||
|
|
@ -821,10 +824,11 @@ static void au0828_stop_streaming(struct vb2_queue *vq)
|
|||
|
||||
dprintk(1, "au0828_stop_streaming called %d\n", dev->streaming_users);
|
||||
|
||||
if (dev->streaming_users-- == 1)
|
||||
if (dev->streaming_users-- == 1) {
|
||||
au0828_uninit_isoc(dev);
|
||||
v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
|
||||
}
|
||||
|
||||
v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
|
||||
dev->vid_timeout_running = 0;
|
||||
del_timer_sync(&dev->vid_timeout);
|
||||
|
||||
|
|
@ -853,8 +857,10 @@ void au0828_stop_vbi_streaming(struct vb2_queue *vq)
|
|||
dprintk(1, "au0828_stop_vbi_streaming called %d\n",
|
||||
dev->streaming_users);
|
||||
|
||||
if (dev->streaming_users-- == 1)
|
||||
if (dev->streaming_users-- == 1) {
|
||||
au0828_uninit_isoc(dev);
|
||||
v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&dev->slock, flags);
|
||||
if (dev->isoc_ctl.vbi_buf != NULL) {
|
||||
|
|
|
|||
|
|
@ -1248,8 +1248,7 @@ static int __init cpia2_init(void)
|
|||
LOG("%s v%s\n",
|
||||
ABOUT, CPIA_VERSION);
|
||||
check_parameters();
|
||||
cpia2_usb_init();
|
||||
return 0;
|
||||
return cpia2_usb_init();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1499,8 +1499,8 @@ static int modet_to_package(struct go7007 *go, __le16 *code, int space)
|
|||
return cnt;
|
||||
}
|
||||
|
||||
static int do_special(struct go7007 *go, u16 type, __le16 *code, int space,
|
||||
int *framelen)
|
||||
static noinline_for_stack int do_special(struct go7007 *go, u16 type,
|
||||
__le16 *code, int space, int *framelen)
|
||||
{
|
||||
switch (type) {
|
||||
case SPECIAL_FRM_HEAD:
|
||||
|
|
|
|||
|
|
@ -670,6 +670,8 @@ static int ctrl_get_input(struct pvr2_ctrl *cptr,int *vp)
|
|||
|
||||
static int ctrl_check_input(struct pvr2_ctrl *cptr,int v)
|
||||
{
|
||||
if (v < 0 || v > PVR2_CVAL_INPUT_MAX)
|
||||
return 0;
|
||||
return ((1 << v) & cptr->hdw->input_allowed_mask) != 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -54,6 +54,7 @@
|
|||
#define PVR2_CVAL_INPUT_COMPOSITE 2
|
||||
#define PVR2_CVAL_INPUT_SVIDEO 3
|
||||
#define PVR2_CVAL_INPUT_RADIO 4
|
||||
#define PVR2_CVAL_INPUT_MAX PVR2_CVAL_INPUT_RADIO
|
||||
|
||||
enum pvr2_config {
|
||||
pvr2_config_empty, /* No configuration */
|
||||
|
|
|
|||
|
|
@ -391,6 +391,7 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
|
|||
struct smsusb_device_t *dev;
|
||||
void *mdev;
|
||||
int i, rc;
|
||||
int align = 0;
|
||||
|
||||
/* create device object */
|
||||
dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
|
||||
|
|
@ -402,6 +403,24 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
|
|||
dev->udev = interface_to_usbdev(intf);
|
||||
dev->state = SMSUSB_DISCONNECTED;
|
||||
|
||||
for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
|
||||
struct usb_endpoint_descriptor *desc =
|
||||
&intf->cur_altsetting->endpoint[i].desc;
|
||||
|
||||
if (desc->bEndpointAddress & USB_DIR_IN) {
|
||||
dev->in_ep = desc->bEndpointAddress;
|
||||
align = usb_endpoint_maxp(desc) - sizeof(struct sms_msg_hdr);
|
||||
} else {
|
||||
dev->out_ep = desc->bEndpointAddress;
|
||||
}
|
||||
}
|
||||
|
||||
pr_debug("in_ep = %02x, out_ep = %02x\n", dev->in_ep, dev->out_ep);
|
||||
if (!dev->in_ep || !dev->out_ep || align < 0) { /* Missing endpoints? */
|
||||
smsusb_term_device(intf);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
params.device_type = sms_get_board(board_id)->type;
|
||||
|
||||
switch (params.device_type) {
|
||||
|
|
@ -416,24 +435,12 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
|
|||
/* fall-thru */
|
||||
default:
|
||||
dev->buffer_size = USB2_BUFFER_SIZE;
|
||||
dev->response_alignment =
|
||||
le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -
|
||||
sizeof(struct sms_msg_hdr);
|
||||
dev->response_alignment = align;
|
||||
|
||||
params.flags |= SMS_DEVICE_FAMILY2;
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
|
||||
if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)
|
||||
dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
|
||||
else
|
||||
dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
|
||||
}
|
||||
|
||||
pr_debug("in_ep = %02x, out_ep = %02x\n",
|
||||
dev->in_ep, dev->out_ep);
|
||||
|
||||
params.device = &dev->udev->dev;
|
||||
params.buffer_size = dev->buffer_size;
|
||||
params.num_buffers = MAX_BUFFERS;
|
||||
|
|
|
|||
|
|
@ -868,7 +868,7 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
|
|||
unsigned int size;
|
||||
unsigned int i;
|
||||
|
||||
extra_size = ALIGN(extra_size, sizeof(*entity->pads));
|
||||
extra_size = roundup(extra_size, sizeof(*entity->pads));
|
||||
num_inputs = (type & UVC_TERM_OUTPUT) ? num_pads : num_pads - 1;
|
||||
size = sizeof(*entity) + extra_size + sizeof(*entity->pads) * num_pads
|
||||
+ num_inputs;
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ static int tegra_mc_setup_latency_allowance(struct tegra_mc *mc)
|
|||
u32 value;
|
||||
|
||||
/* compute the number of MC clock cycles per tick */
|
||||
tick = mc->tick * clk_get_rate(mc->clk);
|
||||
tick = (unsigned long long)mc->tick * clk_get_rate(mc->clk);
|
||||
do_div(tick, NSEC_PER_SEC);
|
||||
|
||||
value = readl(mc->regs + MC_EMEM_ARB_CFG);
|
||||
|
|
|
|||
|
|
@ -782,6 +782,8 @@ static int genwqe_pin_mem(struct genwqe_file *cfile, struct genwqe_mem *m)
|
|||
|
||||
if ((m->addr == 0x0) || (m->size == 0))
|
||||
return -EINVAL;
|
||||
if (m->size > ULONG_MAX - PAGE_SIZE - (m->addr & ~PAGE_MASK))
|
||||
return -EINVAL;
|
||||
|
||||
map_addr = (m->addr & PAGE_MASK);
|
||||
map_size = round_up(m->size + (m->addr & ~PAGE_MASK), PAGE_SIZE);
|
||||
|
|
|
|||
|
|
@ -582,6 +582,10 @@ int genwqe_user_vmap(struct genwqe_dev *cd, struct dma_mapping *m, void *uaddr,
|
|||
/* determine space needed for page_list. */
|
||||
data = (unsigned long)uaddr;
|
||||
offs = offset_in_page(data);
|
||||
if (size > ULONG_MAX - PAGE_SIZE - offs) {
|
||||
m->size = 0; /* mark unused and not added */
|
||||
return -EINVAL;
|
||||
}
|
||||
m->nr_pages = DIV_ROUND_UP(offs + size, PAGE_SIZE);
|
||||
|
||||
m->page_list = kcalloc(m->nr_pages,
|
||||
|
|
|
|||
|
|
@ -216,6 +216,14 @@ static int mmc_decode_scr(struct mmc_card *card)
|
|||
|
||||
if (scr->sda_spec3)
|
||||
scr->cmds = UNSTUFF_BITS(resp, 32, 2);
|
||||
|
||||
/* SD Spec says: any SD Card shall set at least bits 0 and 2 */
|
||||
if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||
|
||||
!(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {
|
||||
pr_err("%s: invalid bus width\n", mmc_hostname(card->host));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -819,6 +819,10 @@ mmc_spi_readblock(struct mmc_spi_host *host, struct spi_transfer *t,
|
|||
}
|
||||
|
||||
status = spi_sync_locked(spi, &host->m);
|
||||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "read error %d\n", status);
|
||||
return status;
|
||||
}
|
||||
|
||||
if (host->dma_dev) {
|
||||
dma_sync_single_for_cpu(host->dma_dev,
|
||||
|
|
|
|||
|
|
@ -624,6 +624,11 @@ static int sdhci_esdhc_probe(struct platform_device *pdev)
|
|||
if (esdhc->vendor_ver > VENDOR_V_22)
|
||||
host->quirks &= ~SDHCI_QUIRK_NO_BUSY_IRQ;
|
||||
|
||||
if (of_find_compatible_node(NULL, NULL, "fsl,p2020-esdhc")) {
|
||||
host->quirks2 |= SDHCI_QUIRK_RESET_AFTER_REQUEST;
|
||||
host->quirks2 |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
|
||||
}
|
||||
|
||||
if (of_device_is_compatible(np, "fsl,p5040-esdhc") ||
|
||||
of_device_is_compatible(np, "fsl,p5020-esdhc") ||
|
||||
of_device_is_compatible(np, "fsl,p4080-esdhc") ||
|
||||
|
|
|
|||
|
|
@ -12824,6 +12824,24 @@ static netdev_features_t bnx2x_features_check(struct sk_buff *skb,
|
|||
struct net_device *dev,
|
||||
netdev_features_t features)
|
||||
{
|
||||
/*
|
||||
* A skb with gso_size + header length > 9700 will cause a
|
||||
* firmware panic. Drop GSO support.
|
||||
*
|
||||
* Eventually the upper layer should not pass these packets down.
|
||||
*
|
||||
* For speed, if the gso_size is <= 9000, assume there will
|
||||
* not be 700 bytes of headers and pass it through. Only do a
|
||||
* full (slow) validation if the gso_size is > 9000.
|
||||
*
|
||||
* (Due to the way SKB_BY_FRAGS works this will also do a full
|
||||
* validation in that case.)
|
||||
*/
|
||||
if (unlikely(skb_is_gso(skb) &&
|
||||
(skb_shinfo(skb)->gso_size > 9000) &&
|
||||
!skb_gso_validate_mac_len(skb, 9700)))
|
||||
features &= ~NETIF_F_GSO_MASK;
|
||||
|
||||
features = vlan_features_check(skb, features);
|
||||
return vxlan_features_check(skb, features);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1140,6 +1140,8 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_napi *bnapi, u32 *raw_cons,
|
|||
skb = bnxt_copy_skb(bnapi, data, len, dma_addr);
|
||||
bnxt_reuse_rx_data(rxr, cons, data);
|
||||
if (!skb) {
|
||||
if (agg_bufs)
|
||||
bnxt_reuse_rx_agg_bufs(bnapi, cp_cons, agg_bufs);
|
||||
rc = -ENOMEM;
|
||||
goto next_rx;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,8 +75,8 @@ struct l2t_data {
|
|||
struct l2t_entry *rover; /* starting point for next allocation */
|
||||
atomic_t nfree; /* number of free entries */
|
||||
rwlock_t lock;
|
||||
struct l2t_entry l2tab[0];
|
||||
struct rcu_head rcu_head; /* to handle rcu cleanup */
|
||||
struct l2t_entry l2tab[];
|
||||
};
|
||||
|
||||
typedef void (*arp_failure_handler_func)(struct t3cdev * dev,
|
||||
|
|
|
|||
|
|
@ -5061,15 +5061,24 @@ static int __init cxgb4_init_module(void)
|
|||
|
||||
ret = pci_register_driver(&cxgb4_driver);
|
||||
if (ret < 0)
|
||||
debugfs_remove(cxgb4_debugfs_root);
|
||||
goto err_pci;
|
||||
|
||||
#if IS_ENABLED(CONFIG_IPV6)
|
||||
if (!inet6addr_registered) {
|
||||
register_inet6addr_notifier(&cxgb4_inet6addr_notifier);
|
||||
inet6addr_registered = true;
|
||||
ret = register_inet6addr_notifier(&cxgb4_inet6addr_notifier);
|
||||
if (ret)
|
||||
pci_unregister_driver(&cxgb4_driver);
|
||||
else
|
||||
inet6addr_registered = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ret == 0)
|
||||
return ret;
|
||||
|
||||
err_pci:
|
||||
debugfs_remove(cxgb4_debugfs_root);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2263,6 +2263,10 @@ void i40e_vlan_stripping_enable(struct i40e_vsi *vsi)
|
|||
struct i40e_vsi_context ctxt;
|
||||
i40e_status ret;
|
||||
|
||||
/* Don't modify stripping options if a port VLAN is active */
|
||||
if (vsi->info.pvid)
|
||||
return;
|
||||
|
||||
if ((vsi->info.valid_sections &
|
||||
cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) &&
|
||||
((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_MODE_MASK) == 0))
|
||||
|
|
@ -2293,6 +2297,10 @@ void i40e_vlan_stripping_disable(struct i40e_vsi *vsi)
|
|||
struct i40e_vsi_context ctxt;
|
||||
i40e_status ret;
|
||||
|
||||
/* Don't modify stripping options if a port VLAN is active */
|
||||
if (vsi->info.pvid)
|
||||
return;
|
||||
|
||||
if ((vsi->info.valid_sections &
|
||||
cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) &&
|
||||
((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_EMOD_MASK) ==
|
||||
|
|
|
|||
|
|
@ -3940,7 +3940,7 @@ static inline void mvpp2_gmac_max_rx_size_set(struct mvpp2_port *port)
|
|||
/* Set defaults to the MVPP2 port */
|
||||
static void mvpp2_defaults_set(struct mvpp2_port *port)
|
||||
{
|
||||
int tx_port_num, val, queue, ptxq, lrxq;
|
||||
int tx_port_num, val, queue, lrxq;
|
||||
|
||||
/* Configure port to loopback if needed */
|
||||
if (port->flags & MVPP2_F_LOOPBACK)
|
||||
|
|
@ -3960,11 +3960,9 @@ static void mvpp2_defaults_set(struct mvpp2_port *port)
|
|||
mvpp2_write(port->priv, MVPP2_TXP_SCHED_CMD_1_REG, 0);
|
||||
|
||||
/* Close bandwidth for all queues */
|
||||
for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) {
|
||||
ptxq = mvpp2_txq_phys(port->id, queue);
|
||||
for (queue = 0; queue < MVPP2_MAX_TXQ; queue++)
|
||||
mvpp2_write(port->priv,
|
||||
MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0);
|
||||
}
|
||||
MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(queue), 0);
|
||||
|
||||
/* Set refill period to 1 usec, refill tokens
|
||||
* and bucket size to maximum
|
||||
|
|
@ -4722,7 +4720,7 @@ static void mvpp2_txq_deinit(struct mvpp2_port *port,
|
|||
txq->descs_phys = 0;
|
||||
|
||||
/* Set minimum bandwidth for disabled TXQs */
|
||||
mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0);
|
||||
mvpp2_write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->log_id), 0);
|
||||
|
||||
/* Set Tx descriptors queue starting address and size */
|
||||
mvpp2_write(port->priv, MVPP2_TXQ_NUM_REG, txq->id);
|
||||
|
|
|
|||
|
|
@ -1906,6 +1906,8 @@ static int mlx4_en_set_tunable(struct net_device *dev,
|
|||
return ret;
|
||||
}
|
||||
|
||||
#define MLX4_EEPROM_PAGE_LEN 256
|
||||
|
||||
static int mlx4_en_get_module_info(struct net_device *dev,
|
||||
struct ethtool_modinfo *modinfo)
|
||||
{
|
||||
|
|
@ -1940,7 +1942,7 @@ static int mlx4_en_get_module_info(struct net_device *dev,
|
|||
break;
|
||||
case MLX4_MODULE_ID_SFP:
|
||||
modinfo->type = ETH_MODULE_SFF_8472;
|
||||
modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
|
||||
modinfo->eeprom_len = MLX4_EEPROM_PAGE_LEN;
|
||||
break;
|
||||
default:
|
||||
return -ENOSYS;
|
||||
|
|
|
|||
|
|
@ -1485,7 +1485,7 @@ int mlx4_flow_steer_promisc_add(struct mlx4_dev *dev, u8 port,
|
|||
rule.port = port;
|
||||
rule.qpn = qpn;
|
||||
INIT_LIST_HEAD(&rule.list);
|
||||
mlx4_err(dev, "going promisc on %x\n", port);
|
||||
mlx4_info(dev, "going promisc on %x\n", port);
|
||||
|
||||
return mlx4_flow_attach(dev, &rule, regid_p);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1398,11 +1398,6 @@ int mlx4_get_module_info(struct mlx4_dev *dev, u8 port,
|
|||
size -= offset + size - I2C_PAGE_SIZE;
|
||||
|
||||
i2c_addr = I2C_ADDR_LOW;
|
||||
if (offset >= I2C_PAGE_SIZE) {
|
||||
/* Reset offset to high page */
|
||||
i2c_addr = I2C_ADDR_HIGH;
|
||||
offset -= I2C_PAGE_SIZE;
|
||||
}
|
||||
|
||||
cable_info = (struct mlx4_cable_info *)inmad->data;
|
||||
cable_info->dev_mem_address = cpu_to_be16(offset);
|
||||
|
|
|
|||
|
|
@ -154,7 +154,8 @@ int stmmac_mdio_reset(struct mii_bus *bus)
|
|||
of_property_read_u32_array(np,
|
||||
"snps,reset-delays-us", data->delays, 3);
|
||||
|
||||
if (gpio_request(data->reset_gpio, "mdio-reset"))
|
||||
if (devm_gpio_request(priv->device, data->reset_gpio,
|
||||
"mdio-reset"))
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -610,12 +610,20 @@ static struct compressor ppp_deflate_draft = {
|
|||
|
||||
static int __init deflate_init(void)
|
||||
{
|
||||
int answer = ppp_register_compressor(&ppp_deflate);
|
||||
if (answer == 0)
|
||||
printk(KERN_INFO
|
||||
"PPP Deflate Compression module registered\n");
|
||||
ppp_register_compressor(&ppp_deflate_draft);
|
||||
return answer;
|
||||
int rc;
|
||||
|
||||
rc = ppp_register_compressor(&ppp_deflate);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
rc = ppp_register_compressor(&ppp_deflate_draft);
|
||||
if (rc) {
|
||||
ppp_unregister_compressor(&ppp_deflate);
|
||||
return rc;
|
||||
}
|
||||
|
||||
pr_info("PPP Deflate Compression module registered\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit deflate_cleanup(void)
|
||||
|
|
|
|||
|
|
@ -727,7 +727,7 @@ int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_
|
|||
int err;
|
||||
u8 iface_no;
|
||||
struct usb_cdc_parsed_header hdr;
|
||||
u16 curr_ntb_format;
|
||||
__le16 curr_ntb_format;
|
||||
|
||||
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
||||
if (!ctx)
|
||||
|
|
@ -841,7 +841,7 @@ int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_
|
|||
goto error2;
|
||||
}
|
||||
|
||||
if (curr_ntb_format == USB_CDC_NCM_NTB32_FORMAT) {
|
||||
if (curr_ntb_format == cpu_to_le16(USB_CDC_NCM_NTB32_FORMAT)) {
|
||||
dev_info(&intf->dev, "resetting NTB format to 16-bit");
|
||||
err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_FORMAT,
|
||||
USB_TYPE_CLASS | USB_DIR_OUT
|
||||
|
|
|
|||
|
|
@ -499,6 +499,7 @@ static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
|
|||
|
||||
if (netif_running (dev->net) &&
|
||||
netif_device_present (dev->net) &&
|
||||
test_bit(EVENT_DEV_OPEN, &dev->flags) &&
|
||||
!test_bit (EVENT_RX_HALT, &dev->flags) &&
|
||||
!test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
|
||||
switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
|
||||
|
|
@ -1385,6 +1386,11 @@ netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
|
|||
spin_unlock_irqrestore(&dev->txq.lock, flags);
|
||||
goto drop;
|
||||
}
|
||||
if (netif_queue_stopped(net)) {
|
||||
usb_autopm_put_interface_async(dev->intf);
|
||||
spin_unlock_irqrestore(&dev->txq.lock, flags);
|
||||
goto drop;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
/* if this triggers the device is still a sleep */
|
||||
|
|
|
|||
|
|
@ -2582,8 +2582,8 @@ static int __init at76_mod_init(void)
|
|||
if (result < 0)
|
||||
printk(KERN_ERR DRIVER_NAME
|
||||
": usb_register failed (status %d)\n", result);
|
||||
|
||||
led_trigger_register_simple("at76_usb-tx", &ledtrig_tx);
|
||||
else
|
||||
led_trigger_register_simple("at76_usb-tx", &ledtrig_tx);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1834,7 +1834,7 @@ static void lpphy_papd_cal(struct b43_wldev *dev, struct lpphy_tx_gains gains,
|
|||
static void lpphy_papd_cal_txpwr(struct b43_wldev *dev)
|
||||
{
|
||||
struct b43_phy_lp *lpphy = dev->phy.lp;
|
||||
struct lpphy_tx_gains gains, oldgains;
|
||||
struct lpphy_tx_gains oldgains;
|
||||
int old_txpctl, old_afe_ovr, old_rf, old_bbmult;
|
||||
|
||||
lpphy_read_tx_pctl_mode_from_hardware(dev);
|
||||
|
|
@ -1848,9 +1848,9 @@ static void lpphy_papd_cal_txpwr(struct b43_wldev *dev)
|
|||
lpphy_set_tx_power_control(dev, B43_LPPHY_TXPCTL_OFF);
|
||||
|
||||
if (dev->dev->chip_id == 0x4325 && dev->dev->chip_rev == 0)
|
||||
lpphy_papd_cal(dev, gains, 0, 1, 30);
|
||||
lpphy_papd_cal(dev, oldgains, 0, 1, 30);
|
||||
else
|
||||
lpphy_papd_cal(dev, gains, 0, 1, 65);
|
||||
lpphy_papd_cal(dev, oldgains, 0, 1, 65);
|
||||
|
||||
if (old_afe_ovr)
|
||||
lpphy_set_tx_gains(dev, oldgains);
|
||||
|
|
|
|||
|
|
@ -214,7 +214,9 @@ bool brcmf_c_prec_enq(struct device *dev, struct pktq *q, struct sk_buff *pkt,
|
|||
int prec);
|
||||
|
||||
/* Receive frame for delivery to OS. Callee disposes of rxp. */
|
||||
void brcmf_rx_frame(struct device *dev, struct sk_buff *rxp);
|
||||
void brcmf_rx_frame(struct device *dev, struct sk_buff *rxp, bool handle_event);
|
||||
/* Receive async event packet from firmware. Callee disposes of rxp. */
|
||||
void brcmf_rx_event(struct device *dev, struct sk_buff *rxp);
|
||||
|
||||
/* Indication from bus module regarding presence/insertion of dongle. */
|
||||
int brcmf_attach(struct device *dev);
|
||||
|
|
|
|||
|
|
@ -3328,9 +3328,15 @@ brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
|
|||
struct brcmf_pno_scanresults_le *pfn_result;
|
||||
u32 result_count;
|
||||
u32 status;
|
||||
u32 datalen;
|
||||
|
||||
brcmf_dbg(SCAN, "Enter\n");
|
||||
|
||||
if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
|
||||
brcmf_dbg(SCAN, "Event data to small. Ignore\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (e->event_code == BRCMF_E_PFN_NET_LOST) {
|
||||
brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
|
||||
return 0;
|
||||
|
|
@ -3349,6 +3355,14 @@ brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
|
|||
if (result_count > 0) {
|
||||
int i;
|
||||
|
||||
data += sizeof(struct brcmf_pno_scanresults_le);
|
||||
netinfo_start = (struct brcmf_pno_net_info_le *)data;
|
||||
datalen = e->datalen - ((void *)netinfo_start - (void *)pfn_result);
|
||||
if (datalen < result_count * sizeof(*netinfo)) {
|
||||
brcmf_err("insufficient event data\n");
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
request = kzalloc(sizeof(*request), GFP_KERNEL);
|
||||
ssid = kcalloc(result_count, sizeof(*ssid), GFP_KERNEL);
|
||||
channel = kcalloc(result_count, sizeof(*channel), GFP_KERNEL);
|
||||
|
|
@ -3358,9 +3372,6 @@ brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
|
|||
}
|
||||
|
||||
request->wiphy = wiphy;
|
||||
data += sizeof(struct brcmf_pno_scanresults_le);
|
||||
netinfo_start = (struct brcmf_pno_net_info_le *)data;
|
||||
|
||||
for (i = 0; i < result_count; i++) {
|
||||
netinfo = &netinfo_start[i];
|
||||
if (!netinfo) {
|
||||
|
|
@ -3370,6 +3381,8 @@ brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
|
|||
goto out_err;
|
||||
}
|
||||
|
||||
if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN)
|
||||
netinfo->SSID_len = IEEE80211_MAX_SSID_LEN;
|
||||
brcmf_dbg(SCAN, "SSID:%s Channel:%d\n",
|
||||
netinfo->SSID, netinfo->channel);
|
||||
memcpy(ssid[i].ssid, netinfo->SSID, netinfo->SSID_len);
|
||||
|
|
@ -4836,6 +4849,8 @@ static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
|
|||
conn_info->req_ie =
|
||||
kmemdup(cfg->extra_buf, conn_info->req_ie_len,
|
||||
GFP_KERNEL);
|
||||
if (!conn_info->req_ie)
|
||||
conn_info->req_ie_len = 0;
|
||||
} else {
|
||||
conn_info->req_ie_len = 0;
|
||||
conn_info->req_ie = NULL;
|
||||
|
|
@ -4852,6 +4867,8 @@ static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
|
|||
conn_info->resp_ie =
|
||||
kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
|
||||
GFP_KERNEL);
|
||||
if (!conn_info->resp_ie)
|
||||
conn_info->resp_ie_len = 0;
|
||||
} else {
|
||||
conn_info->resp_ie_len = 0;
|
||||
conn_info->resp_ie = NULL;
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue