Merge android-4.4-p.195 (4af3204
) into msm-4.4
* refs/heads/tmp-4af3204 Linux 4.4.195 Btrfs: fix race setting up and completing qgroup rescan workers btrfs: Relinquish CPUs in btrfs_compare_trees Btrfs: fix use-after-free when using the tree modification log ovl: filter of trusted xattr results in audit CIFS: Fix oplock handling for SMB 2.1+ protocols i2c: riic: Clear NACK in tend isr hwrng: core - don't wait on add_early_randomness() quota: fix wrong condition in is_quota_modification() ext4: fix punch hole for inline_data file systems /dev/mem: Bail out upon SIGKILL. cfg80211: Purge frame registrations on iftype change md/raid6: Set R5_ReadError when there is read failure on parity disk alarmtimer: Use EOPNOTSUPP instead of ENOTSUPP ARM: zynq: Use memcpy_toio instead of memcpy on smp bring-up ASoC: Intel: Fix use of potentially uninitialized variable media: sn9c20x: Add MSI MS-1039 laptop to flip_dmi_table KVM: x86: Manually calculate reserved bits when loading PDPTRS KVM: x86: set ctxt->have_exception in x86_decode_insn() KVM: x86: always stop emulation on page fault parisc: Disable HP HSC-PCI Cards to prevent kernel crash fuse: fix missing unlock_page in fuse_writepage() printk: Do not lose last line in kmsg buffer dump ALSA: firewire-tascam: check intermediate state of clock status and retry ALSA: firewire-tascam: handle error code when getting current source of clock media: omap3isp: Set device on omap3isp subdevs btrfs: extent-tree: Make sure we only allocate extents from block groups with the same type ALSA: hda/realtek - Blacklist PC beep for Lenovo ThinkCentre M73/93 media: ttusb-dec: Fix info-leak in ttusb_dec_send_command() libertas: Add missing sentinel at end of if_usb.c fw_table mmc: sdhci: Fix incorrect switch to HS mode ASoC: dmaengine: Make the pcm->name equal to pcm->id if the name is not set kprobes: Prohibit probing on BUG() and WARN() address dmaengine: ti: edma: Do not reset reserved paRAM slots md/raid1: fail run raid1 array when active disk less than one hwmon: (acpi_power_meter) Change log level for 'unsafe software power cap' ACPI: custom_method: fix memory leaks libtraceevent: Change users plugin directory ACPI / CPPC: do not require the _PSD method media: ov9650: add a sanity check media: saa7134: fix terminology around saa7134_i2c_eeprom_md7134_gate() media: cpia2_usb: fix memory leaks media: saa7146: add cleanup in hexium_attach() media: hdpvr: add terminating 0 at end of string media: radio/si470x: kill urb on error net: lpc-enet: fix printk format strings media: omap3isp: Don't set streaming state on random subdevs dmaengine: iop-adma: use correct printk format strings media: gspca: zero usb_buf on error efi: cper: print AER info of PCIe fatal error md: don't set In_sync if array is frozen md: don't call spare_active in md_reap_sync_thread if all member devices can't work ia64:unwind: fix double free for mod->arch.init_unw_table ALSA: usb-audio: Skip bSynchAddress endpoint check if it is invalid base: soc: Export soc_device_register/unregister APIs media: iguanair: add sanity checks ALSA: i2c: ak4xxx-adda: Fix a possible null pointer dereference in build_adc_controls() ALSA: hda - Show the fatal CORB/RIRB error more clearly x86/apic: Soft disable APIC before initializing it x86/reboot: Always use NMI fallback when shutdown via reboot vector IPI fails sched/core: Fix CPU controller for !RT_GROUP_SCHED sched/fair: Fix imbalance due to CPU affinity media: hdpvr: Add device num check and handling media: dib0700: fix link error for dibx000_i2c_set_speed leds: leds-lp5562 allow firmware files up to the maximum length dmaengine: bcm2835: Print error in case setting DMA mask fails ASoC: sgtl5000: Fix charge pump source assignment ALSA: hda: Flush interrupts on disabling nfc: enforce CAP_NET_RAW for raw sockets ieee802154: enforce CAP_NET_RAW for raw sockets ax25: enforce CAP_NET_RAW for raw sockets appletalk: enforce CAP_NET_RAW for raw sockets mISDN: enforce CAP_NET_RAW for raw sockets usbnet: sanity checking of packet sizes and device mtu usbnet: ignore endpoints with invalid wMaxPacketSize skge: fix checksum byte order sch_netem: fix a divide by zero in tabledist() openvswitch: change type of UPCALL_PID attribute to NLA_UNSPEC net/phy: fix DP83865 10 Mbps HDX loopback disable function cdc_ncm: fix divide-by-zero caused by invalid wMaxPacketSize arcnet: provide a buffer big enough to actually receive packets Bluetooth: btrtl: Additional Realtek 8822CE Bluetooth devices drm: Flush output polling on shutdown f2fs: fix to do sanity check on segment bitmap of LFS curseg Revert "f2fs: avoid out-of-range memory access" f2fs: check all the data segments against all node ones irqchip/gic-v3-its: Fix LPI release for Multi-MSI devices locking/lockdep: Add debug_locks check in __lock_downgrade() mac80211: handle deauthentication/disassociation from TDLS peer mac80211: Print text for disassociation reason ALSA: hda - Add laptop imic fixup for ASUS M9V laptop ASoC: fsl: Fix of-node refcount unbalance in fsl_ssi_probe_from_dt() net: rds: Fix NULL ptr use in rds_tcp_kill_sock crypto: talitos - fix missing break in switch statement mtd: cfi_cmdset_0002: Use chip_good() to retry in do_write_oneword() HID: hidraw: Fix invalid read in hidraw_ioctl HID: logitech: Fix general protection fault caused by Logitech driver HID: lg: make transfer buffers DMA capable HID: prodikeys: Fix general protection fault during probe Revert "Bluetooth: validate BLE connection interval updates" ANDROID: usb: gadget: Fix dependency for f_accessory Remove taskname from lowmemorykiller kill reports ANDROID: Fixes to locking around handle_lmk_event Conflicts: drivers/staging/android/lowmemorykiller.c fs/f2fs/segment.c fs/f2fs/super.c Change-Id: Id4b74ec2b0512aa13bc4392d61d5092f633fed0e Signed-off-by: Srinivasarao P <spathi@codeaurora.org>
This commit is contained in:
commit
ae145f3c29
118 changed files with 650 additions and 218 deletions
2
Makefile
2
Makefile
|
@ -1,6 +1,6 @@
|
|||
VERSION = 4
|
||||
PATCHLEVEL = 4
|
||||
SUBLEVEL = 194
|
||||
SUBLEVEL = 195
|
||||
EXTRAVERSION =
|
||||
NAME = Blurry Fish Butt
|
||||
|
||||
|
|
|
@ -65,7 +65,7 @@ int zynq_cpun_start(u32 address, int cpu)
|
|||
* 0x4: Jump by mov instruction
|
||||
* 0x8: Jumping address
|
||||
*/
|
||||
memcpy((__force void *)zero, &zynq_secondary_trampoline,
|
||||
memcpy_toio(zero, &zynq_secondary_trampoline,
|
||||
trampoline_size);
|
||||
writel(address, zero + trampoline_size);
|
||||
|
||||
|
|
|
@ -912,8 +912,12 @@ module_finalize (const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mo
|
|||
void
|
||||
module_arch_cleanup (struct module *mod)
|
||||
{
|
||||
if (mod->arch.init_unw_table)
|
||||
if (mod->arch.init_unw_table) {
|
||||
unw_remove_unwind_table(mod->arch.init_unw_table);
|
||||
if (mod->arch.core_unw_table)
|
||||
mod->arch.init_unw_table = NULL;
|
||||
}
|
||||
if (mod->arch.core_unw_table) {
|
||||
unw_remove_unwind_table(mod->arch.core_unw_table);
|
||||
mod->arch.core_unw_table = NULL;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1265,6 +1265,14 @@ void setup_local_APIC(void)
|
|||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* If this comes from kexec/kcrash the APIC might be enabled in
|
||||
* SPIV. Soft disable it before doing further initialization.
|
||||
*/
|
||||
value = apic_read(APIC_SPIV);
|
||||
value &= ~APIC_SPIV_APIC_ENABLED;
|
||||
apic_write(APIC_SPIV, value);
|
||||
|
||||
#ifdef CONFIG_X86_32
|
||||
/* Pound the ESR really hard over the head with a big hammer - mbligh */
|
||||
if (lapic_is_integrated() && apic->disable_esr) {
|
||||
|
|
|
@ -176,6 +176,12 @@ asmlinkage __visible void smp_reboot_interrupt(void)
|
|||
irq_exit();
|
||||
}
|
||||
|
||||
static int register_stop_handler(void)
|
||||
{
|
||||
return register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback,
|
||||
NMI_FLAG_FIRST, "smp_stop");
|
||||
}
|
||||
|
||||
static void native_stop_other_cpus(int wait)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
@ -209,39 +215,41 @@ static void native_stop_other_cpus(int wait)
|
|||
apic->send_IPI_allbutself(REBOOT_VECTOR);
|
||||
|
||||
/*
|
||||
* Don't wait longer than a second if the caller
|
||||
* didn't ask us to wait.
|
||||
* Don't wait longer than a second for IPI completion. The
|
||||
* wait request is not checked here because that would
|
||||
* prevent an NMI shutdown attempt in case that not all
|
||||
* CPUs reach shutdown state.
|
||||
*/
|
||||
timeout = USEC_PER_SEC;
|
||||
while (num_online_cpus() > 1 && (wait || timeout--))
|
||||
while (num_online_cpus() > 1 && timeout--)
|
||||
udelay(1);
|
||||
}
|
||||
|
||||
|
||||
/* if the REBOOT_VECTOR didn't work, try with the NMI */
|
||||
if ((num_online_cpus() > 1) && (!smp_no_nmi_ipi)) {
|
||||
if (register_nmi_handler(NMI_LOCAL, smp_stop_nmi_callback,
|
||||
NMI_FLAG_FIRST, "smp_stop"))
|
||||
/* Note: we ignore failures here */
|
||||
/* Hope the REBOOT_IRQ is good enough */
|
||||
goto finish;
|
||||
|
||||
/* sync above data before sending IRQ */
|
||||
wmb();
|
||||
|
||||
pr_emerg("Shutting down cpus with NMI\n");
|
||||
|
||||
apic->send_IPI_allbutself(NMI_VECTOR);
|
||||
|
||||
if (num_online_cpus() > 1) {
|
||||
/*
|
||||
* Don't wait longer than a 10 ms if the caller
|
||||
* didn't ask us to wait.
|
||||
* If NMI IPI is enabled, try to register the stop handler
|
||||
* and send the IPI. In any case try to wait for the other
|
||||
* CPUs to stop.
|
||||
*/
|
||||
if (!smp_no_nmi_ipi && !register_stop_handler()) {
|
||||
/* Sync above data before sending IRQ */
|
||||
wmb();
|
||||
|
||||
pr_emerg("Shutting down cpus with NMI\n");
|
||||
|
||||
apic->send_IPI_allbutself(NMI_VECTOR);
|
||||
}
|
||||
/*
|
||||
* Don't wait longer than 10 ms if the caller didn't
|
||||
* reqeust it. If wait is true, the machine hangs here if
|
||||
* one or more CPUs do not reach shutdown state.
|
||||
*/
|
||||
timeout = USEC_PER_MSEC * 10;
|
||||
while (num_online_cpus() > 1 && (wait || timeout--))
|
||||
udelay(1);
|
||||
}
|
||||
|
||||
finish:
|
||||
local_irq_save(flags);
|
||||
disable_local_APIC();
|
||||
mcheck_cpu_clear(this_cpu_ptr(&cpu_info));
|
||||
|
|
|
@ -5245,6 +5245,8 @@ done_prefixes:
|
|||
ctxt->memopp->addr.mem.ea + ctxt->_eip);
|
||||
|
||||
done:
|
||||
if (rc == X86EMUL_PROPAGATE_FAULT)
|
||||
ctxt->have_exception = true;
|
||||
return (rc != X86EMUL_CONTINUE) ? EMULATION_FAILED : EMULATION_OK;
|
||||
}
|
||||
|
||||
|
|
|
@ -523,8 +523,14 @@ static int kvm_read_nested_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn,
|
|||
data, offset, len, access);
|
||||
}
|
||||
|
||||
static inline u64 pdptr_rsvd_bits(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
return rsvd_bits(cpuid_maxphyaddr(vcpu), 63) | rsvd_bits(5, 8) |
|
||||
rsvd_bits(1, 2);
|
||||
}
|
||||
|
||||
/*
|
||||
* Load the pae pdptrs. Return true is they are all valid.
|
||||
* Load the pae pdptrs. Return 1 if they are all valid, 0 otherwise.
|
||||
*/
|
||||
int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3)
|
||||
{
|
||||
|
@ -543,8 +549,7 @@ int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3)
|
|||
}
|
||||
for (i = 0; i < ARRAY_SIZE(pdpte); ++i) {
|
||||
if (is_present_gpte(pdpte[i]) &&
|
||||
(pdpte[i] &
|
||||
vcpu->arch.mmu.guest_rsvd_check.rsvd_bits_mask[0][2])) {
|
||||
(pdpte[i] & pdptr_rsvd_bits(vcpu))) {
|
||||
ret = 0;
|
||||
goto out;
|
||||
}
|
||||
|
@ -5486,8 +5491,16 @@ int x86_emulate_instruction(struct kvm_vcpu *vcpu,
|
|||
if (reexecute_instruction(vcpu, cr2, write_fault_to_spt,
|
||||
emulation_type))
|
||||
return EMULATE_DONE;
|
||||
if (ctxt->have_exception && inject_emulated_exception(vcpu))
|
||||
if (ctxt->have_exception) {
|
||||
/*
|
||||
* #UD should result in just EMULATION_FAILED, and trap-like
|
||||
* exception should not be encountered during decode.
|
||||
*/
|
||||
WARN_ON_ONCE(ctxt->exception.vector == UD_VECTOR ||
|
||||
exception_type(ctxt->exception.vector) == EXCPT_TRAP);
|
||||
inject_emulated_exception(vcpu);
|
||||
return EMULATE_DONE;
|
||||
}
|
||||
if (emulation_type & EMULTYPE_SKIP)
|
||||
return EMULATE_FAIL;
|
||||
return handle_emulation_failure(vcpu);
|
||||
|
|
|
@ -137,8 +137,10 @@ static int acpi_get_psd(struct cpc_desc *cpc_ptr, acpi_handle handle)
|
|||
union acpi_object *psd = NULL;
|
||||
struct acpi_psd_package *pdomain;
|
||||
|
||||
status = acpi_evaluate_object_typed(handle, "_PSD", NULL, &buffer,
|
||||
ACPI_TYPE_PACKAGE);
|
||||
status = acpi_evaluate_object_typed(handle, "_PSD", NULL,
|
||||
&buffer, ACPI_TYPE_PACKAGE);
|
||||
if (status == AE_NOT_FOUND) /* _PSD is optional */
|
||||
return 0;
|
||||
if (ACPI_FAILURE(status))
|
||||
return -ENODEV;
|
||||
|
||||
|
|
|
@ -48,8 +48,10 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,
|
|||
if ((*ppos > max_size) ||
|
||||
(*ppos + count > max_size) ||
|
||||
(*ppos + count < count) ||
|
||||
(count > uncopied_bytes))
|
||||
(count > uncopied_bytes)) {
|
||||
kfree(buf);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user(buf + (*ppos), user_buf, count)) {
|
||||
kfree(buf);
|
||||
|
@ -69,6 +71,7 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,
|
|||
add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
|
||||
}
|
||||
|
||||
kfree(buf);
|
||||
return count;
|
||||
}
|
||||
|
||||
|
|
|
@ -146,6 +146,7 @@ out2:
|
|||
out1:
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(soc_device_register);
|
||||
|
||||
/* Ensure soc_dev->attr is freed prior to calling soc_device_unregister. */
|
||||
void soc_device_unregister(struct soc_device *soc_dev)
|
||||
|
@ -154,6 +155,7 @@ void soc_device_unregister(struct soc_device *soc_dev)
|
|||
|
||||
device_unregister(&soc_dev->dev);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(soc_device_unregister);
|
||||
|
||||
static int __init soc_bus_register(void)
|
||||
{
|
||||
|
|
|
@ -353,6 +353,9 @@ static const struct usb_device_id blacklist_table[] = {
|
|||
/* Additional Realtek 8822BE Bluetooth devices */
|
||||
{ USB_DEVICE(0x0b05, 0x185c), .driver_info = BTUSB_REALTEK },
|
||||
|
||||
/* Additional Realtek 8822CE Bluetooth devices */
|
||||
{ USB_DEVICE(0x04ca, 0x4005), .driver_info = BTUSB_REALTEK },
|
||||
|
||||
/* Silicon Wave based devices */
|
||||
{ USB_DEVICE(0x0c10, 0x0000), .driver_info = BTUSB_SWAVE },
|
||||
|
||||
|
|
|
@ -88,7 +88,7 @@ static void add_early_randomness(struct hwrng *rng)
|
|||
size_t size = min_t(size_t, 16, rng_buffer_size());
|
||||
|
||||
mutex_lock(&reading_mutex);
|
||||
bytes_read = rng_get_data(rng, rng_buffer, size, 1);
|
||||
bytes_read = rng_get_data(rng, rng_buffer, size, 0);
|
||||
mutex_unlock(&reading_mutex);
|
||||
if (bytes_read > 0)
|
||||
add_device_randomness(rng_buffer, bytes_read);
|
||||
|
|
|
@ -95,6 +95,13 @@ void __weak unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
|
|||
}
|
||||
#endif
|
||||
|
||||
static inline bool should_stop_iteration(void)
|
||||
{
|
||||
if (need_resched())
|
||||
cond_resched();
|
||||
return fatal_signal_pending(current);
|
||||
}
|
||||
|
||||
/*
|
||||
* This funcion reads the *physical* memory. The f_pos points directly to the
|
||||
* memory location.
|
||||
|
@ -161,6 +168,8 @@ static ssize_t read_mem(struct file *file, char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
read += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
|
||||
*ppos += read;
|
||||
|
@ -232,6 +241,8 @@ static ssize_t write_mem(struct file *file, const char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
written += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
|
||||
*ppos += written;
|
||||
|
@ -443,6 +454,10 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
|
|||
read += sz;
|
||||
low_count -= sz;
|
||||
count -= sz;
|
||||
if (should_stop_iteration()) {
|
||||
count = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -467,6 +482,8 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
|
|||
buf += sz;
|
||||
read += sz;
|
||||
p += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
free_page((unsigned long)kbuf);
|
||||
}
|
||||
|
@ -517,6 +534,8 @@ static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
|
|||
p += sz;
|
||||
count -= sz;
|
||||
written += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
|
||||
*ppos += written;
|
||||
|
@ -568,6 +587,8 @@ static ssize_t write_kmem(struct file *file, const char __user *buf,
|
|||
buf += sz;
|
||||
virtr += sz;
|
||||
p += sz;
|
||||
if (should_stop_iteration())
|
||||
break;
|
||||
}
|
||||
free_page((unsigned long)kbuf);
|
||||
}
|
||||
|
|
|
@ -2730,6 +2730,7 @@ static int talitos_remove(struct platform_device *ofdev)
|
|||
break;
|
||||
case CRYPTO_ALG_TYPE_AEAD:
|
||||
crypto_unregister_aead(&t_alg->algt.alg.aead);
|
||||
break;
|
||||
case CRYPTO_ALG_TYPE_AHASH:
|
||||
crypto_unregister_ahash(&t_alg->algt.alg.hash);
|
||||
break;
|
||||
|
|
|
@ -595,8 +595,10 @@ static int bcm2835_dma_probe(struct platform_device *pdev)
|
|||
pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
|
||||
|
||||
rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
|
||||
if (rc)
|
||||
if (rc) {
|
||||
dev_err(&pdev->dev, "Unable to set DMA mask\n");
|
||||
return rc;
|
||||
}
|
||||
|
||||
od = devm_kzalloc(&pdev->dev, sizeof(*od), GFP_KERNEL);
|
||||
if (!od)
|
||||
|
|
|
@ -2218,9 +2218,6 @@ static int edma_probe(struct platform_device *pdev)
|
|||
|
||||
ecc->default_queue = info->default_queue;
|
||||
|
||||
for (i = 0; i < ecc->num_slots; i++)
|
||||
edma_write_slot(ecc, i, &dummy_paramset);
|
||||
|
||||
if (info->rsv) {
|
||||
/* Set the reserved slots in inuse list */
|
||||
rsv_slots = info->rsv->rsv_slots;
|
||||
|
@ -2233,6 +2230,12 @@ static int edma_probe(struct platform_device *pdev)
|
|||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < ecc->num_slots; i++) {
|
||||
/* Reset only unused - not reserved - paRAM slots */
|
||||
if (!test_bit(i, ecc->slot_inuse))
|
||||
edma_write_slot(ecc, i, &dummy_paramset);
|
||||
}
|
||||
|
||||
/* Clear the xbar mapped channels in unused list */
|
||||
xbar_chans = info->xbar_chans;
|
||||
if (xbar_chans) {
|
||||
|
|
|
@ -126,9 +126,9 @@ static void __iop_adma_slot_cleanup(struct iop_adma_chan *iop_chan)
|
|||
list_for_each_entry_safe(iter, _iter, &iop_chan->chain,
|
||||
chain_node) {
|
||||
pr_debug("\tcookie: %d slot: %d busy: %d "
|
||||
"this_desc: %#x next_desc: %#x ack: %d\n",
|
||||
"this_desc: %#x next_desc: %#llx ack: %d\n",
|
||||
iter->async_tx.cookie, iter->idx, busy,
|
||||
iter->async_tx.phys, iop_desc_get_next_desc(iter),
|
||||
iter->async_tx.phys, (u64)iop_desc_get_next_desc(iter),
|
||||
async_tx_test_ack(&iter->async_tx));
|
||||
prefetch(_iter);
|
||||
prefetch(&_iter->async_tx);
|
||||
|
@ -316,9 +316,9 @@ retry:
|
|||
int i;
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"allocated slot: %d "
|
||||
"(desc %p phys: %#x) slots_per_op %d\n",
|
||||
"(desc %p phys: %#llx) slots_per_op %d\n",
|
||||
iter->idx, iter->hw_desc,
|
||||
iter->async_tx.phys, slots_per_op);
|
||||
(u64)iter->async_tx.phys, slots_per_op);
|
||||
|
||||
/* pre-ack all but the last descriptor */
|
||||
if (num_slots != slots_per_op)
|
||||
|
@ -526,7 +526,7 @@ iop_adma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dma_dest,
|
|||
return NULL;
|
||||
BUG_ON(len > IOP_ADMA_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s len: %zu\n",
|
||||
__func__, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
@ -559,7 +559,7 @@ iop_adma_prep_dma_xor(struct dma_chan *chan, dma_addr_t dma_dest,
|
|||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"%s src_cnt: %d len: %u flags: %lx\n",
|
||||
"%s src_cnt: %d len: %zu flags: %lx\n",
|
||||
__func__, src_cnt, len, flags);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
@ -592,7 +592,7 @@ iop_adma_prep_dma_xor_val(struct dma_chan *chan, dma_addr_t *dma_src,
|
|||
if (unlikely(!len))
|
||||
return NULL;
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %zu\n",
|
||||
__func__, src_cnt, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
@ -630,7 +630,7 @@ iop_adma_prep_dma_pq(struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,
|
|||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev,
|
||||
"%s src_cnt: %d len: %u flags: %lx\n",
|
||||
"%s src_cnt: %d len: %zu flags: %lx\n",
|
||||
__func__, src_cnt, len, flags);
|
||||
|
||||
if (dmaf_p_disabled_continue(flags))
|
||||
|
@ -693,7 +693,7 @@ iop_adma_prep_dma_pq_val(struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
|
|||
return NULL;
|
||||
BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
|
||||
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %u\n",
|
||||
dev_dbg(iop_chan->device->common.dev, "%s src_cnt: %d len: %zu\n",
|
||||
__func__, src_cnt, len);
|
||||
|
||||
spin_lock_bh(&iop_chan->lock);
|
||||
|
|
|
@ -384,6 +384,21 @@ static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie,
|
|||
printk(
|
||||
"%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n",
|
||||
pfx, pcie->bridge.secondary_status, pcie->bridge.control);
|
||||
|
||||
/* Fatal errors call __ghes_panic() before AER handler prints this */
|
||||
if ((pcie->validation_bits & CPER_PCIE_VALID_AER_INFO) &&
|
||||
(gdata->error_severity & CPER_SEV_FATAL)) {
|
||||
struct aer_capability_regs *aer;
|
||||
|
||||
aer = (struct aer_capability_regs *)pcie->aer_info;
|
||||
printk("%saer_uncor_status: 0x%08x, aer_uncor_mask: 0x%08x\n",
|
||||
pfx, aer->uncor_status, aer->uncor_mask);
|
||||
printk("%saer_uncor_severity: 0x%08x\n",
|
||||
pfx, aer->uncor_severity);
|
||||
printk("%sTLP Header: %08x %08x %08x %08x\n", pfx,
|
||||
aer->header_log.dw0, aer->header_log.dw1,
|
||||
aer->header_log.dw2, aer->header_log.dw3);
|
||||
}
|
||||
}
|
||||
|
||||
static void cper_estatus_print_section(
|
||||
|
|
|
@ -326,6 +326,9 @@ static void output_poll_execute(struct work_struct *work)
|
|||
enum drm_connector_status old_status;
|
||||
bool repoll = false, changed;
|
||||
|
||||
if (!dev->mode_config.poll_enabled)
|
||||
return;
|
||||
|
||||
/* Pick up any changes detected by the probe functions. */
|
||||
changed = dev->mode_config.delayed_event;
|
||||
dev->mode_config.delayed_event = false;
|
||||
|
@ -489,7 +492,11 @@ EXPORT_SYMBOL(drm_kms_helper_poll_init);
|
|||
*/
|
||||
void drm_kms_helper_poll_fini(struct drm_device *dev)
|
||||
{
|
||||
drm_kms_helper_poll_disable(dev);
|
||||
if (!dev->mode_config.poll_enabled)
|
||||
return;
|
||||
|
||||
dev->mode_config.poll_enabled = false;
|
||||
cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
|
||||
}
|
||||
EXPORT_SYMBOL(drm_kms_helper_poll_fini);
|
||||
|
||||
|
|
|
@ -701,11 +701,16 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
|||
|
||||
/* Setup wireless link with Logitech Wii wheel */
|
||||
if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
|
||||
unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
const unsigned char cbuf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
u8 *buf = kmemdup(cbuf, sizeof(cbuf), GFP_KERNEL);
|
||||
|
||||
ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
|
||||
if (!buf) {
|
||||
ret = -ENOMEM;
|
||||
goto err_stop;
|
||||
}
|
||||
|
||||
ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(cbuf),
|
||||
HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
|
||||
|
||||
if (ret >= 0) {
|
||||
/* insert a little delay of 10 jiffies ~ 40ms */
|
||||
wait_queue_head_t wait;
|
||||
|
@ -717,9 +722,10 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
|||
buf[1] = 0xB2;
|
||||
get_random_bytes(&buf[2], 2);
|
||||
|
||||
ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
|
||||
ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(cbuf),
|
||||
HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
|
||||
}
|
||||
kfree(buf);
|
||||
}
|
||||
|
||||
if (drv_data->quirks & LG_FF)
|
||||
|
@ -732,9 +738,12 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
|||
ret = lg4ff_init(hdev);
|
||||
|
||||
if (ret)
|
||||
goto err_free;
|
||||
goto err_stop;
|
||||
|
||||
return 0;
|
||||
|
||||
err_stop:
|
||||
hid_hw_stop(hdev);
|
||||
err_free:
|
||||
kfree(drv_data);
|
||||
return ret;
|
||||
|
@ -745,8 +754,7 @@ static void lg_remove(struct hid_device *hdev)
|
|||
struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
|
||||
if (drv_data->quirks & LG_FF4)
|
||||
lg4ff_deinit(hdev);
|
||||
else
|
||||
hid_hw_stop(hdev);
|
||||
hid_hw_stop(hdev);
|
||||
kfree(drv_data);
|
||||
}
|
||||
|
||||
|
|
|
@ -1378,7 +1378,6 @@ int lg4ff_deinit(struct hid_device *hid)
|
|||
}
|
||||
}
|
||||
#endif
|
||||
hid_hw_stop(hid);
|
||||
drv_data->device_props = NULL;
|
||||
|
||||
kfree(entry);
|
||||
|
|
|
@ -556,10 +556,14 @@ static void pcmidi_setup_extra_keys(
|
|||
|
||||
static int pcmidi_set_operational(struct pcmidi_snd *pm)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (pm->ifnum != 1)
|
||||
return 0; /* only set up ONCE for interace 1 */
|
||||
|
||||
pcmidi_get_output_report(pm);
|
||||
rc = pcmidi_get_output_report(pm);
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
pcmidi_submit_output_report(pm, 0xc1);
|
||||
return 0;
|
||||
}
|
||||
|
@ -688,7 +692,11 @@ static int pcmidi_snd_initialise(struct pcmidi_snd *pm)
|
|||
spin_lock_init(&pm->rawmidi_in_lock);
|
||||
|
||||
init_sustain_timers(pm);
|
||||
pcmidi_set_operational(pm);
|
||||
err = pcmidi_set_operational(pm);
|
||||
if (err < 0) {
|
||||
pk_error("failed to find output report\n");
|
||||
goto fail_register;
|
||||
}
|
||||
|
||||
/* register it */
|
||||
err = snd_card_register(card);
|
||||
|
|
|
@ -383,7 +383,7 @@ static long hidraw_ioctl(struct file *file, unsigned int cmd,
|
|||
|
||||
mutex_lock(&minors_lock);
|
||||
dev = hidraw_table[minor];
|
||||
if (!dev) {
|
||||
if (!dev || !dev->exist) {
|
||||
ret = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
|
|
@ -693,8 +693,8 @@ static int setup_attrs(struct acpi_power_meter_resource *resource)
|
|||
|
||||
if (resource->caps.flags & POWER_METER_CAN_CAP) {
|
||||
if (!can_cap_in_hardware()) {
|
||||
dev_err(&resource->acpi_dev->dev,
|
||||
"Ignoring unsafe software power cap!\n");
|
||||
dev_warn(&resource->acpi_dev->dev,
|
||||
"Ignoring unsafe software power cap!\n");
|
||||
goto skip_unsafe_cap;
|
||||
}
|
||||
|
||||
|
|
|
@ -212,6 +212,7 @@ static irqreturn_t riic_tend_isr(int irq, void *data)
|
|||
if (readb(riic->base + RIIC_ICSR2) & ICSR2_NACKF) {
|
||||
/* We got a NACKIE */
|
||||
readb(riic->base + RIIC_ICDRR); /* dummy read */
|
||||
riic_clear_set_bit(riic, ICSR2_NACKF, 0, RIIC_ICSR2);
|
||||
riic->err = -ENXIO;
|
||||
} else if (riic->bytes_left) {
|
||||
return IRQ_NONE;
|
||||
|
|
|
@ -1372,14 +1372,13 @@ static void its_irq_domain_free(struct irq_domain *domain, unsigned int virq,
|
|||
struct its_device *its_dev = irq_data_get_irq_chip_data(d);
|
||||
int i;
|
||||
|
||||
bitmap_release_region(its_dev->event_map.lpi_map,
|
||||
its_get_event_id(irq_domain_get_irq_data(domain, virq)),
|
||||
get_count_order(nr_irqs));
|
||||
|
||||
for (i = 0; i < nr_irqs; i++) {
|
||||
struct irq_data *data = irq_domain_get_irq_data(domain,
|
||||
virq + i);
|
||||
u32 event = its_get_event_id(data);
|
||||
|
||||
/* Mark interrupt index as unused */
|
||||
clear_bit(event, its_dev->event_map.lpi_map);
|
||||
|
||||
/* Nuke the entry in the domain */
|
||||
irq_domain_reset_irq_data(data);
|
||||
}
|
||||
|
|
|
@ -763,6 +763,8 @@ base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
|
|||
|
||||
if (sock->type != SOCK_RAW)
|
||||
return -ESOCKTNOSUPPORT;
|
||||
if (!capable(CAP_NET_RAW))
|
||||
return -EPERM;
|
||||
|
||||
sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
|
||||
if (!sk)
|
||||
|
|
|
@ -263,7 +263,11 @@ static void lp5562_firmware_loaded(struct lp55xx_chip *chip)
|
|||
{
|
||||
const struct firmware *fw = chip->fw;
|
||||
|
||||
if (fw->size > LP5562_PROGRAM_LENGTH) {
|
||||
/*
|
||||
* the firmware is encoded in ascii hex character, with 2 chars
|
||||
* per byte
|
||||
*/
|
||||
if (fw->size > (LP5562_PROGRAM_LENGTH * 2)) {
|
||||
dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
|
||||
fw->size);
|
||||
return;
|
||||
|
|
|
@ -1667,8 +1667,15 @@ static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
|
|||
if (!(le32_to_cpu(sb->feature_map) &
|
||||
MD_FEATURE_RECOVERY_BITMAP))
|
||||
rdev->saved_raid_disk = -1;
|
||||
} else
|
||||
set_bit(In_sync, &rdev->flags);
|
||||
} else {
|
||||
/*
|
||||
* If the array is FROZEN, then the device can't
|
||||
* be in_sync with rest of array.
|
||||
*/
|
||||
if (!test_bit(MD_RECOVERY_FROZEN,
|
||||
&mddev->recovery))
|
||||
set_bit(In_sync, &rdev->flags);
|
||||
}
|
||||
rdev->raid_disk = role;
|
||||
break;
|
||||
}
|
||||
|
@ -8445,7 +8452,8 @@ void md_reap_sync_thread(struct mddev *mddev)
|
|||
/* resync has finished, collect result */
|
||||
md_unregister_thread(&mddev->sync_thread);
|
||||
if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
|
||||
!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
|
||||
!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
|
||||
mddev->degraded != mddev->raid_disks) {
|
||||
/* success...*/
|
||||
/* activate any spares */
|
||||
if (mddev->pers->spare_active(mddev)) {
|
||||
|
|
|
@ -2958,6 +2958,13 @@ static int run(struct mddev *mddev)
|
|||
!test_bit(In_sync, &conf->mirrors[i].rdev->flags) ||
|
||||
test_bit(Faulty, &conf->mirrors[i].rdev->flags))
|
||||
mddev->degraded++;
|
||||
/*
|
||||
* RAID1 needs at least one disk in active
|
||||
*/
|
||||
if (conf->raid_disks - mddev->degraded < 1) {
|
||||
ret = -EINVAL;
|
||||
goto abort;
|
||||
}
|
||||
|
||||
if (conf->raid_disks - mddev->degraded == 1)
|
||||
mddev->recovery_cp = MaxSector;
|
||||
|
@ -2992,8 +2999,12 @@ static int run(struct mddev *mddev)
|
|||
ret = md_integrity_register(mddev);
|
||||
if (ret) {
|
||||
md_unregister_thread(&mddev->thread);
|
||||
raid1_free(mddev, conf);
|
||||
goto abort;
|
||||
}
|
||||
return 0;
|
||||
|
||||
abort:
|
||||
raid1_free(mddev, conf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -2394,7 +2394,9 @@ static void raid5_end_read_request(struct bio * bi)
|
|||
&& !test_bit(R5_ReadNoMerge, &sh->dev[i].flags))
|
||||
retry = 1;
|
||||
if (retry)
|
||||
if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags)) {
|
||||
if (sh->qd_idx >= 0 && sh->pd_idx == i)
|
||||
set_bit(R5_ReadError, &sh->dev[i].flags);
|
||||
else if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags)) {
|
||||
set_bit(R5_ReadError, &sh->dev[i].flags);
|
||||
clear_bit(R5_ReadNoMerge, &sh->dev[i].flags);
|
||||
} else
|
||||
|
|
|
@ -707,6 +707,11 @@ static int ov965x_set_gain(struct ov965x *ov965x, int auto_gain)
|
|||
for (m = 6; m >= 0; m--)
|
||||
if (gain >= (1 << m) * 16)
|
||||
break;
|
||||
|
||||
/* Sanity check: don't adjust the gain with a negative value */
|
||||
if (m < 0)
|
||||
return -EINVAL;
|
||||
|
||||
rgain = (gain - ((1 << m) * 16)) / (1 << m);
|
||||
rgain |= (((1 << m) - 1) << 4);
|
||||
|
||||
|
|
|
@ -355,7 +355,11 @@ static struct i2c_client saa7134_client_template = {
|
|||
|
||||
/* ----------------------------------------------------------- */
|
||||
|
||||
/* On Medion 7134 reading EEPROM needs DVB-T demod i2c gate open */
|
||||
/*
|
||||
* On Medion 7134 reading the SAA7134 chip config EEPROM needs DVB-T
|
||||
* demod i2c gate closed due to an address clash between this EEPROM
|
||||
* and the demod one.
|
||||
*/
|
||||
static void saa7134_i2c_eeprom_md7134_gate(struct saa7134_dev *dev)
|
||||
{
|
||||
u8 subaddr = 0x7, dmdregval;
|
||||
|
@ -372,14 +376,14 @@ static void saa7134_i2c_eeprom_md7134_gate(struct saa7134_dev *dev)
|
|||
|
||||
ret = i2c_transfer(&dev->i2c_adap, i2cgatemsg_r, 2);
|
||||
if ((ret == 2) && (dmdregval & 0x2)) {
|
||||
pr_debug("%s: DVB-T demod i2c gate was left closed\n",
|
||||
pr_debug("%s: DVB-T demod i2c gate was left open\n",
|
||||
dev->name);
|
||||
|
||||
data[0] = subaddr;
|
||||
data[1] = (dmdregval & ~0x2);
|
||||
if (i2c_transfer(&dev->i2c_adap, i2cgatemsg_w, 1) != 1)
|
||||
pr_err("%s: EEPROM i2c gate open failure\n",
|
||||
dev->name);
|
||||
pr_err("%s: EEPROM i2c gate close failure\n",
|
||||
dev->name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -304,6 +304,9 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d
|
|||
ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
|
||||
if (ret < 0) {
|
||||
pr_err("cannot register capture v4l2 device. skipping.\n");
|
||||
saa7146_vv_release(dev);
|
||||
i2c_del_adapter(&hexium->i2c_adapter);
|
||||
kfree(hexium);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -917,6 +917,10 @@ static int isp_pipeline_enable(struct isp_pipeline *pipe,
|
|||
s_stream, mode);
|
||||
pipe->do_propagation = true;
|
||||
}
|
||||
|
||||
/* Stop at the first external sub-device. */
|
||||
if (subdev->dev != isp->dev)
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -1031,6 +1035,10 @@ static int isp_pipeline_disable(struct isp_pipeline *pipe)
|
|||
isp->crashed |= 1U << subdev->entity.id;
|
||||
failure = -ETIMEDOUT;
|
||||
}
|
||||
|
||||
/* Stop at the first external sub-device. */
|
||||
if (subdev->dev != isp->dev)
|
||||
break;
|
||||
}
|
||||
|
||||
return failure;
|
||||
|
|
|
@ -2603,6 +2603,7 @@ int omap3isp_ccdc_register_entities(struct isp_ccdc_device *ccdc,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video node. */
|
||||
ccdc->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &ccdc->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
@ -1025,6 +1025,7 @@ int omap3isp_ccp2_register_entities(struct isp_ccp2_device *ccp2,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
ccp2->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &ccp2->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
@ -1201,6 +1201,7 @@ int omap3isp_csi2_register_entities(struct isp_csi2_device *csi2,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
csi2->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &csi2->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
@ -2223,6 +2223,7 @@ int omap3isp_preview_register_entities(struct isp_prev_device *prev,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
prev->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &prev->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
@ -1679,6 +1679,7 @@ int omap3isp_resizer_register_entities(struct isp_res_device *res,
|
|||
int ret;
|
||||
|
||||
/* Register the subdev and video nodes. */
|
||||
res->subdev.dev = vdev->mdev->dev;
|
||||
ret = v4l2_device_register_subdev(vdev, &res->subdev);
|
||||
if (ret < 0)
|
||||
goto error;
|
||||
|
|
|
@ -1010,6 +1010,8 @@ void omap3isp_stat_unregister_entities(struct ispstat *stat)
|
|||
int omap3isp_stat_register_entities(struct ispstat *stat,
|
||||
struct v4l2_device *vdev)
|
||||
{
|
||||
stat->subdev.dev = vdev->mdev->dev;
|
||||
|
||||
return v4l2_device_register_subdev(vdev, &stat->subdev);
|
||||
}
|
||||
|
||||
|
|
|
@ -743,7 +743,7 @@ static int si470x_usb_driver_probe(struct usb_interface *intf,
|
|||
/* start radio */
|
||||
retval = si470x_start_usb(radio);
|
||||
if (retval < 0)
|
||||
goto err_all;
|
||||
goto err_buf;
|
||||
|
||||
/* set initial frequency */
|
||||
si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */
|
||||
|
@ -758,6 +758,8 @@ static int si470x_usb_driver_probe(struct usb_interface *intf,
|
|||
|
||||
return 0;
|
||||
err_all:
|
||||
usb_kill_urb(radio->int_in_urb);
|
||||
err_buf:
|
||||
kfree(radio->buffer);
|
||||
err_ctrl:
|
||||
v4l2_ctrl_handler_free(&radio->hdl);
|
||||
|
@ -831,6 +833,7 @@ static void si470x_usb_driver_disconnect(struct usb_interface *intf)
|
|||
mutex_lock(&radio->lock);
|
||||
v4l2_device_disconnect(&radio->v4l2_dev);
|
||||
video_unregister_device(&radio->videodev);
|
||||
usb_kill_urb(radio->int_in_urb);
|
||||
usb_set_intfdata(intf, NULL);
|
||||
mutex_unlock(&radio->lock);
|
||||
v4l2_device_put(&radio->v4l2_dev);
|
||||
|
|
|
@ -430,6 +430,10 @@ static int iguanair_probe(struct usb_interface *intf,
|
|||
int ret, pipein, pipeout;
|
||||
struct usb_host_interface *idesc;
|
||||
|
||||
idesc = intf->altsetting;
|
||||
if (idesc->desc.bNumEndpoints < 2)
|
||||
return -ENODEV;
|
||||
|
||||
ir = kzalloc(sizeof(*ir), GFP_KERNEL);
|
||||
rc = rc_allocate_device();
|
||||
if (!ir || !rc) {
|
||||
|
@ -444,18 +448,13 @@ static int iguanair_probe(struct usb_interface *intf,
|
|||
ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
|
||||
ir->urb_out = usb_alloc_urb(0, GFP_KERNEL);
|
||||
|
||||
if (!ir->buf_in || !ir->packet || !ir->urb_in || !ir->urb_out) {
|
||||
if (!ir->buf_in || !ir->packet || !ir->urb_in || !ir->urb_out ||
|
||||
!usb_endpoint_is_int_in(&idesc->endpoint[0].desc) ||
|
||||
!usb_endpoint_is_int_out(&idesc->endpoint[1].desc)) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
idesc = intf->altsetting;
|
||||
|
||||
if (idesc->desc.bNumEndpoints < 2) {
|
||||
ret = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
ir->rc = rc;
|
||||
ir->dev = &intf->dev;
|
||||
ir->udev = udev;
|
||||
|
|
|
@ -665,6 +665,10 @@ static int submit_urbs(struct camera_data *cam)
|
|||
ERR("%s: usb_alloc_urb error!\n", __func__);
|
||||
for (j = 0; j < i; j++)
|
||||
usb_free_urb(cam->sbuf[j].urb);
|
||||
for (j = 0; j < NUM_SBUF; j++) {
|
||||
kfree(cam->sbuf[j].data);
|
||||
cam->sbuf[j].data = NULL;
|
||||
}
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
|
|
@ -2418,9 +2418,13 @@ static int dib9090_tuner_attach(struct dvb_usb_adapter *adap)
|
|||
8, 0x0486,
|
||||
};
|
||||
|
||||
if (!IS_ENABLED(CONFIG_DVB_DIB9000))
|
||||
return -ENODEV;
|
||||
if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &dib9090_dib0090_config) == NULL)
|
||||
return -ENODEV;
|
||||
i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
|
||||
if (!i2c)
|
||||
return -ENODEV;
|
||||
if (dib01x0_pmu_update(i2c, data_dib190, 10) != 0)
|
||||
return -ENODEV;
|
||||
dib0700_set_i2c_speed(adap->dev, 1500);
|
||||
|
@ -2496,10 +2500,14 @@ static int nim9090md_tuner_attach(struct dvb_usb_adapter *adap)
|
|||
0, 0x00ef,
|
||||
8, 0x0406,
|
||||
};
|
||||
if (!IS_ENABLED(CONFIG_DVB_DIB9000))
|
||||
return -ENODEV;
|
||||
i2c = dib9000_get_tuner_interface(adap->fe_adap[0].fe);
|
||||
if (dvb_attach(dib0090_fw_register, adap->fe_adap[0].fe, i2c, &nim9090md_dib0090_config[0]) == NULL)
|
||||
return -ENODEV;
|
||||
i2c = dib9000_get_i2c_master(adap->fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
|
||||
if (!i2c)
|
||||
return -ENODEV;
|
||||
if (dib01x0_pmu_update(i2c, data_dib190, 10) < 0)
|
||||
return -ENODEV;
|
||||
|
||||
|
|
|
@ -127,6 +127,11 @@ static void reg_r(struct gspca_dev *gspca_dev, u16 value, u16 index)
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, 2);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1584,6 +1584,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
return;
|
||||
}
|
||||
if (len == 1)
|
||||
|
|
|
@ -2116,6 +2116,11 @@ static int reg_r(struct sd *sd, u16 index)
|
|||
} else {
|
||||
PERR("reg_r %02x failed %d\n", index, ret);
|
||||
sd->gspca_dev.usb_err = ret;
|
||||
/*
|
||||
* Make sure the result is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
gspca_dev->usb_buf[0] = 0;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
@ -2142,6 +2147,11 @@ static int reg_r8(struct sd *sd,
|
|||
} else {
|
||||
PERR("reg_r8 %02x failed %d\n", index, ret);
|
||||
sd->gspca_dev.usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, 8);
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -644,6 +644,11 @@ static u8 ov534_reg_read(struct gspca_dev *gspca_dev, u16 reg)
|
|||
if (ret < 0) {
|
||||
pr_err("read failed %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the result is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
gspca_dev->usb_buf[0] = 0;
|
||||
}
|
||||
return gspca_dev->usb_buf[0];
|
||||
}
|
||||
|
|
|
@ -1157,6 +1157,7 @@ static u8 reg_r(struct gspca_dev *gspca_dev, u16 reg)
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
return 0;
|
||||
}
|
||||
return gspca_dev->usb_buf[0];
|
||||
}
|
||||
|
|
|
@ -115,6 +115,11 @@ static void se401_read_req(struct gspca_dev *gspca_dev, u16 req, int silent)
|
|||
pr_err("read req failed req %#04x error %d\n",
|
||||
req, err);
|
||||
gspca_dev->usb_err = err;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, READ_REQ_SIZE);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -138,6 +138,13 @@ static const struct dmi_system_id flip_dmi_table[] = {
|
|||
DMI_MATCH(DMI_PRODUCT_VERSION, "0341")
|
||||
}
|
||||
},
|
||||
{
|
||||
.ident = "MSI MS-1039",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "MS-1039"),
|
||||
}
|
||||
},
|
||||
{
|
||||
.ident = "MSI MS-1632",
|
||||
.matches = {
|
||||
|
@ -924,6 +931,11 @@ static void reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length)
|
|||
if (unlikely(result < 0 || result != length)) {
|
||||
pr_err("Read register %02x failed %d\n", reg, result);
|
||||
gspca_dev->usb_err = result;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -466,6 +466,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
dev_err(gspca_dev->v4l2_dev.dev,
|
||||
"Error reading register %02x: %d\n", value, res);
|
||||
gspca_dev->usb_err = res;
|
||||
/*
|
||||
* Make sure the result is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
gspca_dev->usb_buf[0] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1175,6 +1175,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -84,6 +84,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -438,6 +438,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r %04x failed %d\n", value, ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -268,6 +268,11 @@ static void reg_r(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -2919,6 +2919,11 @@ static void reg_r_i(struct gspca_dev *gspca_dev,
|
|||
if (ret < 0) {
|
||||
pr_err("reg_r err %d\n", ret);
|
||||
gspca_dev->usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
|
||||
}
|
||||
}
|
||||
static void reg_r(struct gspca_dev *gspca_dev,
|
||||
|
|
|
@ -139,6 +139,11 @@ static int w9968cf_read_sb(struct sd *sd)
|
|||
} else {
|
||||
pr_err("Read SB reg [01] failed\n");
|
||||
sd->gspca_dev.usb_err = ret;
|
||||
/*
|
||||
* Make sure the buffer is zeroed to avoid uninitialized
|
||||
* values.
|
||||
*/
|
||||
memset(sd->gspca_dev.usb_buf, 0, 2);
|
||||
}
|
||||
|
||||
udelay(W9968CF_I2C_BUS_DELAY);
|
||||
|
|
|
@ -143,6 +143,7 @@ static int device_authorization(struct hdpvr_device *dev)
|
|||
|
||||
dev->fw_ver = dev->usbc_buf[1];
|
||||
|
||||
dev->usbc_buf[46] = '\0';
|
||||
v4l2_info(&dev->v4l2_dev, "firmware version 0x%x dated %s\n",
|
||||
dev->fw_ver, &dev->usbc_buf[2]);
|
||||
|
||||
|
@ -278,6 +279,7 @@ static int hdpvr_probe(struct usb_interface *interface,
|
|||
#endif
|
||||
size_t buffer_size;
|
||||
int i;
|
||||
int dev_num;
|
||||
int retval = -ENOMEM;
|
||||
|
||||
/* allocate memory for our device state and initialize it */
|
||||
|
@ -386,8 +388,17 @@ static int hdpvr_probe(struct usb_interface *interface,
|
|||
}
|
||||
#endif
|
||||
|
||||
dev_num = atomic_inc_return(&dev_nr);
|
||||
if (dev_num >= HDPVR_MAX) {
|
||||
v4l2_err(&dev->v4l2_dev,
|
||||
"max device number reached, device register failed\n");
|
||||
atomic_dec(&dev_nr);
|
||||
retval = -ENODEV;
|
||||
goto reg_fail;
|
||||
}
|
||||
|
||||
retval = hdpvr_register_videodev(dev, &interface->dev,
|
||||
video_nr[atomic_inc_return(&dev_nr)]);
|
||||
video_nr[dev_num]);
|
||||
if (retval < 0) {
|
||||
v4l2_err(&dev->v4l2_dev, "registering videodev failed\n");
|
||||
goto reg_fail;
|
||||
|
|
|
@ -272,7 +272,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
|
|||
|
||||
dprintk("%s\n", __func__);
|
||||
|
||||
b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
|
||||
b = kzalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
|
||||
if (!b)
|
||||
return -ENOMEM;
|
||||
|
||||
|
|
|
@ -1845,7 +1845,9 @@ void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing)
|
|||
ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
|
||||
else if (timing == MMC_TIMING_UHS_SDR12)
|
||||
ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
|
||||
else if (timing == MMC_TIMING_UHS_SDR25)
|
||||
else if (timing == MMC_TIMING_SD_HS ||
|
||||
timing == MMC_TIMING_MMC_HS ||
|
||||
timing == MMC_TIMING_UHS_SDR25)
|
||||
ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
|
||||
else if (timing == MMC_TIMING_UHS_SDR50)
|
||||
ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
|
||||
|
|
|
@ -1626,29 +1626,35 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
|
|||
continue;
|
||||
}
|
||||
|
||||
if (time_after(jiffies, timeo) && !chip_ready(map, adr)){
|
||||
/*
|
||||
* We check "time_after" and "!chip_good" before checking
|
||||
* "chip_good" to avoid the failure due to scheduling.
|
||||
*/
|
||||
if (time_after(jiffies, timeo) && !chip_good(map, adr, datum)) {
|
||||
xip_enable(map, chip, adr);
|
||||
printk(KERN_WARNING "MTD %s(): software timeout\n", __func__);
|
||||
xip_disable(map, chip, adr);
|
||||
ret = -EIO;
|
||||
break;
|
||||
}
|
||||
|
||||
if (chip_ready(map, adr))
|
||||
if (chip_good(map, adr, datum))
|
||||
break;
|
||||
|
||||
/* Latency issues. Drop the lock, wait a while and retry */
|
||||
UDELAY(map, chip, adr, 1);
|
||||
}
|
||||
|
||||
/* Did we succeed? */
|
||||
if (!chip_good(map, adr, datum)) {
|
||||
if (ret) {
|
||||
/* reset on all failures. */
|
||||
map_write( map, CMD(0xF0), chip->start );
|
||||
/* FIXME - should have reset delay before continuing */
|
||||
|
||||
if (++retry_cnt <= MAX_RETRIES)
|
||||
if (++retry_cnt <= MAX_RETRIES) {
|
||||
ret = 0;
|
||||
goto retry;
|
||||
|
||||
ret = -EIO;
|
||||
}
|
||||
}
|
||||
xip_enable(map, chip, adr);
|
||||
op_done:
|
||||
|
|
|
@ -1009,31 +1009,34 @@ EXPORT_SYMBOL(arcnet_interrupt);
|
|||
static void arcnet_rx(struct net_device *dev, int bufnum)
|
||||
{
|
||||
struct arcnet_local *lp = netdev_priv(dev);
|
||||
struct archdr pkt;
|
||||
union {
|
||||
struct archdr pkt;
|
||||
char buf[512];
|
||||
} rxdata;
|
||||
struct arc_rfc1201 *soft;
|
||||
int length, ofs;
|
||||
|
||||
soft = &pkt.soft.rfc1201;
|
||||
soft = &rxdata.pkt.soft.rfc1201;
|
||||
|
||||
lp->hw.copy_from_card(dev, bufnum, 0, &pkt, ARC_HDR_SIZE);
|
||||
if (pkt.hard.offset[0]) {
|
||||
ofs = pkt.hard.offset[0];
|
||||
lp->hw.copy_from_card(dev, bufnum, 0, &rxdata.pkt, ARC_HDR_SIZE);
|
||||
if (rxdata.pkt.hard.offset[0]) {
|
||||
ofs = rxdata.pkt.hard.offset[0];
|
||||
length = 256 - ofs;
|
||||
} else {
|
||||
ofs = pkt.hard.offset[1];
|
||||
ofs = rxdata.pkt.hard.offset[1];
|
||||
length = 512 - ofs;
|
||||
}
|
||||
|
||||
/* get the full header, if possible */
|
||||
if (sizeof(pkt.soft) <= length) {
|
||||
lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft));
|
||||
if (sizeof(rxdata.pkt.soft) <= length) {
|
||||
lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(rxdata.pkt.soft));
|
||||
} else {
|
||||
memset(&pkt.soft, 0, sizeof(pkt.soft));
|
||||
memset(&rxdata.pkt.soft, 0, sizeof(rxdata.pkt.soft));
|
||||
lp->hw.copy_from_card(dev, bufnum, ofs, soft, length);
|
||||
}
|
||||
|
||||
arc_printk(D_DURING, dev, "Buffer #%d: received packet from %02Xh to %02Xh (%d+4 bytes)\n",
|
||||
bufnum, pkt.hard.source, pkt.hard.dest, length);
|
||||
bufnum, rxdata.pkt.hard.source, rxdata.pkt.hard.dest, length);
|
||||
|
||||
dev->stats.rx_packets++;
|
||||
dev->stats.rx_bytes += length + ARC_HDR_SIZE;
|
||||
|
@ -1042,13 +1045,13 @@ static void arcnet_rx(struct net_device *dev, int bufnum)
|
|||
if (arc_proto_map[soft->proto]->is_ip) {
|
||||
if (BUGLVL(D_PROTO)) {
|
||||
struct ArcProto
|
||||
*oldp = arc_proto_map[lp->default_proto[pkt.hard.source]],
|
||||
*oldp = arc_proto_map[lp->default_proto[rxdata.pkt.hard.source]],
|
||||
*newp = arc_proto_map[soft->proto];
|
||||
|
||||
if (oldp != newp) {
|
||||
arc_printk(D_PROTO, dev,
|
||||
"got protocol %02Xh; encap for host %02Xh is now '%c' (was '%c')\n",
|
||||
soft->proto, pkt.hard.source,
|
||||
soft->proto, rxdata.pkt.hard.source,
|
||||
newp->suffix, oldp->suffix);
|
||||
}
|
||||
}
|
||||
|
@ -1057,10 +1060,10 @@ static void arcnet_rx(struct net_device *dev, int bufnum)
|
|||
lp->default_proto[0] = soft->proto;
|
||||
|
||||
/* in striking contrast, the following isn't a hack. */
|
||||
lp->default_proto[pkt.hard.source] = soft->proto;
|
||||
lp->default_proto[rxdata.pkt.hard.source] = soft->proto;
|
||||
}
|
||||
/* call the protocol-specific receiver. */
|
||||
arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length);
|
||||
arc_proto_map[soft->proto]->rx(dev, bufnum, &rxdata.pkt, length);
|
||||
}
|
||||
|
||||
static void null_rx(struct net_device *dev, int bufnum,
|
||||
|
|
|
@ -3114,7 +3114,7 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
|
|||
skb_put(skb, len);
|
||||
|
||||
if (dev->features & NETIF_F_RXCSUM) {
|
||||
skb->csum = csum;
|
||||
skb->csum = le16_to_cpu(csum);
|
||||
skb->ip_summed = CHECKSUM_COMPLETE;
|
||||
}
|
||||
|
||||
|
|
|
@ -1417,13 +1417,14 @@ static int lpc_eth_drv_probe(struct platform_device *pdev)
|
|||
pldat->dma_buff_base_p = dma_handle;
|
||||
|
||||
netdev_dbg(ndev, "IO address space :%pR\n", res);
|
||||
netdev_dbg(ndev, "IO address size :%d\n", resource_size(res));
|
||||
netdev_dbg(ndev, "IO address size :%zd\n",
|
||||
(size_t)resource_size(res));
|
||||
netdev_dbg(ndev, "IO address (mapped) :0x%p\n",
|
||||
pldat->net_base);
|
||||
netdev_dbg(ndev, "IRQ number :%d\n", ndev->irq);
|
||||
netdev_dbg(ndev, "DMA buffer size :%d\n", pldat->dma_buff_size);
|
||||
netdev_dbg(ndev, "DMA buffer P address :0x%08x\n",
|
||||
pldat->dma_buff_base_p);
|
||||
netdev_dbg(ndev, "DMA buffer size :%zd\n", pldat->dma_buff_size);
|
||||
netdev_dbg(ndev, "DMA buffer P address :%pad\n",
|
||||
&pldat->dma_buff_base_p);
|
||||
netdev_dbg(ndev, "DMA buffer V address :0x%p\n",
|
||||
pldat->dma_buff_base_v);
|
||||
|
||||
|
@ -1470,8 +1471,8 @@ static int lpc_eth_drv_probe(struct platform_device *pdev)
|
|||
if (ret)
|
||||
goto err_out_unregister_netdev;
|
||||
|
||||
netdev_info(ndev, "LPC mac at 0x%08x irq %d\n",
|
||||
res->start, ndev->irq);
|
||||
netdev_info(ndev, "LPC mac at 0x%08lx irq %d\n",
|
||||
(unsigned long)res->start, ndev->irq);
|
||||
|
||||
phydev = pldat->phy_dev;
|
||||
|
||||
|
|
|
@ -110,14 +110,17 @@ static void ns_giga_speed_fallback(struct phy_device *phydev, int mode)
|
|||
|
||||
static void ns_10_base_t_hdx_loopack(struct phy_device *phydev, int disable)
|
||||
{
|
||||
u16 lb_dis = BIT(1);
|
||||
|
||||
if (disable)
|
||||
ns_exp_write(phydev, 0x1c0, ns_exp_read(phydev, 0x1c0) | 1);
|
||||
ns_exp_write(phydev, 0x1c0,
|
||||
ns_exp_read(phydev, 0x1c0) | lb_dis);
|
||||
else
|
||||
ns_exp_write(phydev, 0x1c0,
|
||||
ns_exp_read(phydev, 0x1c0) & 0xfffe);
|
||||
ns_exp_read(phydev, 0x1c0) & ~lb_dis);
|
||||
|
||||
pr_debug("10BASE-T HDX loopback %s\n",
|
||||
(ns_exp_read(phydev, 0x1c0) & 0x0001) ? "off" : "on");
|
||||
(ns_exp_read(phydev, 0x1c0) & lb_dis) ? "off" : "on");
|
||||
}
|
||||
|
||||
static int ns_config_init(struct phy_device *phydev)
|
||||
|
|
|
@ -636,8 +636,12 @@ cdc_ncm_find_endpoints(struct usbnet *dev, struct usb_interface *intf)
|
|||
u8 ep;
|
||||
|
||||
for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) {
|
||||
|
||||
e = intf->cur_altsetting->endpoint + ep;
|
||||
|
||||
/* ignore endpoints which cannot transfer data */
|
||||
if (!usb_endpoint_maxp(&e->desc))
|
||||
continue;
|
||||
|
||||
switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
|
||||
case USB_ENDPOINT_XFER_INT:
|
||||
if (usb_endpoint_dir_in(&e->desc)) {
|
||||
|
|
|
@ -114,6 +114,11 @@ int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
|
|||
int intr = 0;
|
||||
|
||||
e = alt->endpoint + ep;
|
||||
|
||||
/* ignore endpoints which cannot transfer data */
|
||||
if (!usb_endpoint_maxp(&e->desc))
|
||||
continue;
|
||||
|
||||
switch (e->desc.bmAttributes) {
|
||||
case USB_ENDPOINT_XFER_INT:
|
||||
if (!usb_endpoint_dir_in(&e->desc))
|
||||
|
@ -349,6 +354,8 @@ void usbnet_update_max_qlen(struct usbnet *dev)
|
|||
{
|
||||
enum usb_device_speed speed = dev->udev->speed;
|
||||
|
||||
if (!dev->rx_urb_size || !dev->hard_mtu)
|
||||
goto insanity;
|
||||
switch (speed) {
|
||||
case USB_SPEED_HIGH:
|
||||
dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
|
||||
|
@ -364,6 +371,7 @@ void usbnet_update_max_qlen(struct usbnet *dev)
|
|||
dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
|
||||
break;
|
||||
default:
|
||||
insanity:
|
||||
dev->rx_qlen = dev->tx_qlen = 4;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -49,7 +49,8 @@ static const struct lbs_fw_table fw_table[] = {
|
|||
{ MODEL_8388, "libertas/usb8388_v5.bin", NULL },
|
||||
{ MODEL_8388, "libertas/usb8388.bin", NULL },
|
||||
{ MODEL_8388, "usb8388.bin", NULL },
|
||||
{ MODEL_8682, "libertas/usb8682.bin", NULL }
|
||||
{ MODEL_8682, "libertas/usb8682.bin", NULL },
|
||||
{ 0, NULL, NULL }
|
||||
};
|
||||
|
||||
static struct usb_device_id if_usb_table[] = {
|
||||
|
|
|
@ -160,6 +160,15 @@ struct dino_device
|
|||
(struct dino_device *)__pdata; })
|
||||
|
||||
|
||||
/* Check if PCI device is behind a Card-mode Dino. */
|
||||
static int pci_dev_is_behind_card_dino(struct pci_dev *dev)
|
||||
{
|
||||
struct dino_device *dino_dev;
|
||||
|
||||
dino_dev = DINO_DEV(parisc_walk_tree(dev->bus->bridge));
|
||||
return is_card_dino(&dino_dev->hba.dev->id);
|
||||
}
|
||||
|
||||
/*
|
||||
* Dino Configuration Space Accessor Functions
|
||||
*/
|
||||
|
@ -442,6 +451,21 @@ static void quirk_cirrus_cardbus(struct pci_dev *dev)
|
|||
}
|
||||
DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_6832, quirk_cirrus_cardbus );
|
||||
|
||||
#ifdef CONFIG_TULIP
|
||||
static void pci_fixup_tulip(struct pci_dev *dev)
|
||||
{
|
||||
if (!pci_dev_is_behind_card_dino(dev))
|
||||
return;
|
||||
if (!(pci_resource_flags(dev, 1) & IORESOURCE_MEM))
|
||||
return;
|
||||
pr_warn("%s: HP HSC-PCI Cards with card-mode Dino not yet supported.\n",
|
||||
pci_name(dev));
|
||||
/* Disable this card by zeroing the PCI resources */
|
||||
memset(&dev->resource[0], 0, sizeof(dev->resource[0]));
|
||||
memset(&dev->resource[1], 0, sizeof(dev->resource[1]));
|
||||
}
|
||||
DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_DEC, PCI_ANY_ID, pci_fixup_tulip);
|
||||
#endif /* CONFIG_TULIP */
|
||||
|
||||
static void __init
|
||||
dino_bios_init(void)
|
||||
|
|
|
@ -119,19 +119,6 @@ void handle_lmk_event(struct task_struct *selected, int selected_tasksize,
|
|||
int tail;
|
||||
struct lmk_event *events;
|
||||
struct lmk_event *event;
|
||||
int res;
|
||||
char taskname[MAX_TASKNAME];
|
||||
|
||||
res = get_cmdline(selected, taskname, MAX_TASKNAME - 1);
|
||||
|
||||
/* No valid process name means this is definitely not associated with a
|
||||
* userspace activity.
|
||||
*/
|
||||
|
||||
if (res <= 0 || res >= MAX_TASKNAME)
|
||||
return;
|
||||
|
||||
taskname[res] = '\0';
|
||||
|
||||
spin_lock(&lmk_event_lock);
|
||||
|
||||
|
@ -147,7 +134,7 @@ void handle_lmk_event(struct task_struct *selected, int selected_tasksize,
|
|||
events = (struct lmk_event *) event_buffer.buf;
|
||||
event = &events[head];
|
||||
|
||||
memcpy(event->taskname, taskname, res + 1);
|
||||
strncpy(event->taskname, selected->comm, MAX_TASKNAME);
|
||||
|
||||
event->pid = selected->pid;
|
||||
event->uid = from_kuid_munged(current_user_ns(), task_uid(selected));
|
||||
|
|
|
@ -441,6 +441,7 @@ config USB_CONFIGFS_F_PTP
|
|||
config USB_CONFIGFS_F_ACC
|
||||
boolean "Accessory gadget"
|
||||
depends on USB_CONFIGFS
|
||||
depends on HID=y
|
||||
select USB_F_ACC
|
||||
help
|
||||
USB gadget Accessory support
|
||||
|
|
|
@ -1418,6 +1418,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
|
|||
struct tree_mod_elem *tm;
|
||||
struct extent_buffer *eb = NULL;
|
||||
struct extent_buffer *eb_root;
|
||||
u64 eb_root_owner = 0;
|
||||
struct extent_buffer *old;
|
||||
struct tree_mod_root *old_root = NULL;
|
||||
u64 old_generation = 0;
|
||||
|
@ -1451,6 +1452,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
|
|||
free_extent_buffer(old);
|
||||
}
|
||||
} else if (old_root) {
|
||||
eb_root_owner = btrfs_header_owner(eb_root);
|
||||
btrfs_tree_read_unlock(eb_root);
|
||||
free_extent_buffer(eb_root);
|
||||
eb = alloc_dummy_extent_buffer(root->fs_info, logical);
|
||||
|
@ -1468,7 +1470,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
|
|||
if (old_root) {
|
||||
btrfs_set_header_bytenr(eb, eb->start);
|
||||
btrfs_set_header_backref_rev(eb, BTRFS_MIXED_BACKREF_REV);
|
||||
btrfs_set_header_owner(eb, btrfs_header_owner(eb_root));
|
||||
btrfs_set_header_owner(eb, eb_root_owner);
|
||||
btrfs_set_header_level(eb, old_root->level);
|
||||
btrfs_set_header_generation(eb, old_generation);
|
||||
}
|
||||
|
@ -5433,6 +5435,7 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
|
|||
advance_left = advance_right = 0;
|
||||
|
||||
while (1) {
|
||||
cond_resched();
|
||||
if (advance_left && !left_end_reached) {
|
||||
ret = tree_advance(left_root, left_path, &left_level,
|
||||
left_root_level,
|
||||
|
|
|
@ -7168,6 +7168,14 @@ search:
|
|||
*/
|
||||
if ((flags & extra) && !(block_group->flags & extra))
|
||||
goto loop;
|
||||
|
||||
/*
|
||||
* This block group has different flags than we want.
|
||||
* It's possible that we have MIXED_GROUP flag but no
|
||||
* block group is mixed. Just skip such block group.
|
||||
*/
|
||||
btrfs_release_block_group(block_group, delalloc);
|
||||
continue;
|
||||
}
|
||||
|
||||
have_block_group:
|
||||
|
|
|
@ -2328,9 +2328,6 @@ out:
|
|||
btrfs_free_path(path);
|
||||
|
||||
mutex_lock(&fs_info->qgroup_rescan_lock);
|
||||
if (!btrfs_fs_closing(fs_info))
|
||||
fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
|
||||
|
||||
if (err > 0 &&
|
||||
fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) {
|
||||
fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
|
||||
|
@ -2346,16 +2343,30 @@ out:
|
|||
trans = btrfs_start_transaction(fs_info->quota_root, 1);
|
||||
if (IS_ERR(trans)) {
|
||||
err = PTR_ERR(trans);
|
||||
trans = NULL;
|
||||
btrfs_err(fs_info,
|
||||
"fail to start transaction for status update: %d\n",
|
||||
err);
|
||||
goto done;
|
||||
}
|
||||
ret = update_qgroup_status_item(trans, fs_info, fs_info->quota_root);
|
||||
if (ret < 0) {
|
||||
err = ret;
|
||||
btrfs_err(fs_info, "fail to update qgroup status: %d\n", err);
|
||||
|
||||
mutex_lock(&fs_info->qgroup_rescan_lock);
|
||||
if (!btrfs_fs_closing(fs_info))
|
||||
fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
|
||||
if (trans) {
|
||||
ret = update_qgroup_status_item(trans, fs_info, fs_info->quota_root);
|
||||
if (ret < 0) {
|
||||
err = ret;
|
||||
btrfs_err(fs_info, "fail to update qgroup status: %d",
|
||||
err);
|
||||
}
|
||||
}
|
||||
fs_info->qgroup_rescan_running = false;
|
||||
complete_all(&fs_info->qgroup_rescan_completion);
|
||||
mutex_unlock(&fs_info->qgroup_rescan_lock);
|
||||
|
||||
if (!trans)
|
||||
return;
|
||||
|
||||
btrfs_end_transaction(trans, fs_info->quota_root);
|
||||
|
||||
if (btrfs_fs_closing(fs_info)) {
|
||||
|
@ -2366,12 +2377,6 @@ out:
|
|||
} else {
|
||||
btrfs_err(fs_info, "qgroup scan failed with %d", err);
|
||||
}
|
||||
|
||||
done:
|
||||
mutex_lock(&fs_info->qgroup_rescan_lock);
|
||||
fs_info->qgroup_rescan_running = false;
|
||||
mutex_unlock(&fs_info->qgroup_rescan_lock);
|
||||
complete_all(&fs_info->qgroup_rescan_completion);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -1335,6 +1335,11 @@ smb21_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
|
|||
if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE)
|
||||
return;
|
||||
|
||||
/* Check if the server granted an oplock rather than a lease */
|
||||
if (oplock & SMB2_OPLOCK_LEVEL_EXCLUSIVE)
|
||||
return smb2_set_oplock_level(cinode, oplock, epoch,
|
||||
purge_cache);
|
||||
|
||||
if (oplock & SMB2_LEASE_READ_CACHING_HE) {
|
||||
new_oplock |= CIFS_CACHE_READ_FLG;
|
||||
strcat(message, "R");
|
||||
|
|
|
@ -3772,6 +3772,15 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
|
|||
|
||||
trace_ext4_punch_hole(inode, offset, length, 0);
|
||||
|
||||
ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
|
||||
if (ext4_has_inline_data(inode)) {
|
||||
down_write(&EXT4_I(inode)->i_mmap_sem);
|
||||
ret = ext4_convert_inline_data(inode);
|
||||
up_write(&EXT4_I(inode)->i_mmap_sem);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write out all dirty pages to avoid race conditions
|
||||
* Then release them.
|
||||
|
|
|
@ -4389,7 +4389,9 @@ static int sanity_check_curseg(struct f2fs_sb_info *sbi)
|
|||
continue;
|
||||
out:
|
||||
f2fs_err(sbi,
|
||||
"Current segment's next free block offset is inconsistent with bitmap, logtype:%u, segno:%u, type:%u, next_blkoff:%u, blkofs:%u",
|
||||
"Current segment's next free block offset is "
|
||||
"inconsistent with bitmap, logtype:%u, "
|
||||
"segno:%u, type:%u, next_blkoff:%u, blkofs:%u",
|
||||
i, curseg->segno, curseg->alloc_type,
|
||||
curseg->next_blkoff, blkofs);
|
||||
return -EFSCORRUPTED;
|
||||
|
|
|
@ -2670,12 +2670,13 @@ int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)
|
|||
}
|
||||
}
|
||||
for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
|
||||
for (j = i; j < NR_CURSEG_DATA_TYPE; j++) {
|
||||
for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {
|
||||
if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
|
||||
le32_to_cpu(ckpt->cur_data_segno[j])) {
|
||||
f2fs_err(sbi, "Data segment (%u) and Data segment (%u) has the same segno: %u",
|
||||
i, j,
|
||||
le32_to_cpu(ckpt->cur_node_segno[i]));
|
||||
f2fs_err(sbi,
|
||||
"Node segment (%u) and Data segment (%u)"
|
||||
" has the same segno: %u", i, j,
|
||||
le32_to_cpu(ckpt->cur_node_segno[i]));
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1775,6 +1775,7 @@ static int fuse_writepage(struct page *page, struct writeback_control *wbc)
|
|||
WARN_ON(wbc->sync_mode == WB_SYNC_ALL);
|
||||
|
||||
redirty_page_for_writepage(wbc, page);
|
||||
unlock_page(page);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -292,7 +292,8 @@ static bool ovl_can_list(const char *s)
|
|||
return true;
|
||||
|
||||
/* Never list trusted.overlay, list other trusted for superuser only */
|
||||
return !ovl_is_private_xattr(s) && capable(CAP_SYS_ADMIN);
|
||||
return !ovl_is_private_xattr(s) &&
|
||||
ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN);
|
||||
}
|
||||
|
||||
ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
|
||||
|
|
|
@ -102,6 +102,11 @@ int is_valid_bugaddr(unsigned long addr);
|
|||
|
||||
#else /* !CONFIG_GENERIC_BUG */
|
||||
|
||||
static inline void *find_bug(unsigned long bugaddr)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline enum bug_trap_type report_bug(unsigned long bug_addr,
|
||||
struct pt_regs *regs)
|
||||
{
|
||||
|
|
|
@ -21,7 +21,7 @@ static inline struct quota_info *sb_dqopt(struct super_block *sb)
|
|||
/* i_mutex must being held */
|
||||
static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
|
||||
{
|
||||
return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
|
||||
return (ia->ia_valid & ATTR_SIZE) ||
|
||||
(ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
|
||||
(ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
|
||||
}
|
||||
|
|
|
@ -1454,7 +1454,8 @@ static int check_kprobe_address_safe(struct kprobe *p,
|
|||
/* Ensure it is not in reserved area nor out of text */
|
||||
if (!kernel_text_address((unsigned long) p->addr) ||
|
||||
within_kprobe_blacklist((unsigned long) p->addr) ||
|
||||
jump_label_text_reserved(p->addr, p->addr)) {
|
||||
jump_label_text_reserved(p->addr, p->addr) ||
|
||||
find_bug((unsigned long)p->addr)) {
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
|
|
@ -3314,6 +3314,9 @@ __lock_set_class(struct lockdep_map *lock, const char *name,
|
|||
unsigned int depth;
|
||||
int i;
|
||||
|
||||
if (unlikely(!debug_locks))
|
||||
return 0;
|
||||
|
||||
depth = curr->lockdep_depth;
|
||||
/*
|
||||
* This function is about (re)setting the class of a held lock,
|
||||
|
|
|
@ -3066,7 +3066,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
|
|||
seq = dumper->cur_seq;
|
||||
idx = dumper->cur_idx;
|
||||
prev = 0;
|
||||
while (l > size && seq < dumper->next_seq) {
|
||||
while (l >= size && seq < dumper->next_seq) {
|
||||
struct printk_log *msg = log_from_idx(idx);
|
||||
|
||||
l -= msg_print_text(msg, prev, true, NULL, 0);
|
||||
|
|
|
@ -9339,10 +9339,6 @@ static int cpu_cgroup_can_attach(struct cgroup_taskset *tset)
|
|||
#ifdef CONFIG_RT_GROUP_SCHED
|
||||
if (!sched_rt_can_attach(css_tg(css), task))
|
||||
return -EINVAL;
|
||||
#else
|
||||
/* We don't support RT-tasks being in separate groups */
|
||||
if (task->sched_class != &fair_sched_class)
|
||||
return -EINVAL;
|
||||
#endif
|
||||
/*
|
||||
* Serialize against wake_up_new_task() such that if its
|
||||
|
|
|
@ -10729,9 +10729,10 @@ no_move:
|
|||
out_balanced:
|
||||
/*
|
||||
* We reach balance although we may have faced some affinity
|
||||
* constraints. Clear the imbalance flag if it was set.
|
||||
* constraints. Clear the imbalance flag only if other tasks got
|
||||
* a chance to move and fix the imbalance.
|
||||
*/
|
||||
if (sd_parent) {
|
||||
if (sd_parent && !(env.flags & LBF_ALL_PINNED)) {
|
||||
int *group_imbalance = &sd_parent->groups->sgc->imbalance;
|
||||
|
||||
if (*group_imbalance)
|
||||
|
|
|
@ -640,7 +640,7 @@ static int alarm_timer_create(struct k_itimer *new_timer)
|
|||
struct alarm_base *base;
|
||||
|
||||
if (!alarmtimer_get_rtcdev())
|
||||
return -ENOTSUPP;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (!capable(CAP_WAKE_ALARM))
|
||||
return -EPERM;
|
||||
|
@ -869,7 +869,7 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
|
|||
struct restart_block *restart;
|
||||
|
||||
if (!alarmtimer_get_rtcdev())
|
||||
return -ENOTSUPP;
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (flags & ~TIMER_ABSTIME)
|
||||
return -EINVAL;
|
||||
|
|
|
@ -1029,6 +1029,11 @@ static int atalk_create(struct net *net, struct socket *sock, int protocol,
|
|||
*/
|
||||
if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
|
||||
goto out;
|
||||
|
||||
rc = -EPERM;
|
||||
if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
|
||||
goto out;
|
||||
|
||||
rc = -ENOMEM;
|
||||
sk = sk_alloc(net, PF_APPLETALK, GFP_KERNEL, &ddp_proto, kern);
|
||||
if (!sk)
|
||||
|
|
|
@ -859,6 +859,8 @@ static int ax25_create(struct net *net, struct socket *sock, int protocol,
|
|||
break;
|
||||
|
||||
case SOCK_RAW:
|
||||
if (!capable(CAP_NET_RAW))
|
||||
return -EPERM;
|
||||
break;
|
||||
default:
|
||||
return -ESOCKTNOSUPPORT;
|
||||
|
|
|
@ -5062,11 +5062,6 @@ static void hci_le_remote_conn_param_req_evt(struct hci_dev *hdev,
|
|||
return send_conn_param_neg_reply(hdev, handle,
|
||||
HCI_ERROR_UNKNOWN_CONN_ID);
|
||||
|
||||
if (min < hcon->le_conn_min_interval ||
|
||||
max > hcon->le_conn_max_interval)
|
||||
return send_conn_param_neg_reply(hdev, handle,
|
||||
HCI_ERROR_INVALID_LL_PARAMS);
|
||||
|
||||
if (hci_check_conn_params(min, max, latency, timeout))
|
||||
return send_conn_param_neg_reply(hdev, handle,
|
||||
HCI_ERROR_INVALID_LL_PARAMS);
|
||||
|
|
|
@ -5267,14 +5267,7 @@ static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn,
|
|||
|
||||
memset(&rsp, 0, sizeof(rsp));
|
||||
|
||||
if (min < hcon->le_conn_min_interval ||
|
||||
max > hcon->le_conn_max_interval) {
|
||||
BT_DBG("requested connection interval exceeds current bounds.");
|
||||
err = -EINVAL;
|
||||
} else {
|
||||
err = hci_check_conn_params(min, max, latency, to_multiplier);
|
||||
}
|
||||
|
||||
err = hci_check_conn_params(min, max, latency, to_multiplier);
|
||||
if (err)
|
||||
rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_REJECTED);
|
||||
else
|
||||
|
|
|
@ -999,6 +999,9 @@ static int ieee802154_create(struct net *net, struct socket *sock,
|
|||
|
||||
switch (sock->type) {
|
||||
case SOCK_RAW:
|
||||
rc = -EPERM;
|
||||
if (!capable(CAP_NET_RAW))
|
||||
goto out;
|
||||
proto = &ieee802154_raw_prot;
|
||||
ops = &ieee802154_raw_ops;
|
||||
break;
|
||||
|
|
|
@ -2060,6 +2060,9 @@ void ieee80211_tdls_cancel_channel_switch(struct wiphy *wiphy,
|
|||
const u8 *addr);
|
||||
void ieee80211_teardown_tdls_peers(struct ieee80211_sub_if_data *sdata);
|
||||
void ieee80211_tdls_chsw_work(struct work_struct *wk);
|
||||
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
||||
const u8 *peer, u16 reason);
|
||||
const char *ieee80211_get_reason_code_string(u16 reason_code);
|
||||
|
||||
extern const struct ethtool_ops ieee80211_ethtool_ops;
|
||||
|
||||
|
|
|
@ -2743,7 +2743,7 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
|
|||
#define case_WLAN(type) \
|
||||
case WLAN_REASON_##type: return #type
|
||||
|
||||
static const char *ieee80211_get_reason_code_string(u16 reason_code)
|
||||
const char *ieee80211_get_reason_code_string(u16 reason_code)
|
||||
{
|
||||
switch (reason_code) {
|
||||
case_WLAN(UNSPECIFIED);
|
||||
|
@ -2808,6 +2808,11 @@ static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
|
|||
if (len < 24 + 2)
|
||||
return;
|
||||
|
||||
if (!ether_addr_equal(mgmt->bssid, mgmt->sa)) {
|
||||
ieee80211_tdls_handle_disconnect(sdata, mgmt->sa, reason_code);
|
||||
return;
|
||||
}
|
||||
|
||||
if (ifmgd->associated &&
|
||||
ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid)) {
|
||||
const u8 *bssid = ifmgd->associated->bssid;
|
||||
|
@ -2857,8 +2862,14 @@ static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
|
|||
|
||||
reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
|
||||
|
||||
sdata_info(sdata, "disassociated from %pM (Reason: %u)\n",
|
||||
mgmt->sa, reason_code);
|
||||
if (!ether_addr_equal(mgmt->bssid, mgmt->sa)) {
|
||||
ieee80211_tdls_handle_disconnect(sdata, mgmt->sa, reason_code);
|
||||
return;
|
||||
}
|
||||
|
||||
sdata_info(sdata, "disassociated from %pM (Reason: %u=%s)\n",
|
||||
mgmt->sa, reason_code,
|
||||
ieee80211_get_reason_code_string(reason_code));
|
||||
|
||||
ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
|
||||
|
||||
|
|
|
@ -1963,3 +1963,26 @@ void ieee80211_tdls_chsw_work(struct work_struct *wk)
|
|||
}
|
||||
rtnl_unlock();
|
||||
}
|
||||
|
||||
void ieee80211_tdls_handle_disconnect(struct ieee80211_sub_if_data *sdata,
|
||||
const u8 *peer, u16 reason)
|
||||
{
|
||||
struct ieee80211_sta *sta;
|
||||
|
||||
rcu_read_lock();
|
||||
sta = ieee80211_find_sta(&sdata->vif, peer);
|
||||
if (!sta || !sta->tdls) {
|
||||
rcu_read_unlock();
|
||||
return;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
||||
tdls_dbg(sdata, "disconnected from TDLS peer %pM (Reason: %u=%s)\n",
|
||||
peer, reason,
|
||||
ieee80211_get_reason_code_string(reason));
|
||||
|
||||
ieee80211_tdls_oper_request(&sdata->vif, peer,
|
||||
NL80211_TDLS_TEARDOWN,
|
||||
WLAN_REASON_TDLS_TEARDOWN_UNREACHABLE,
|
||||
GFP_ATOMIC);
|
||||
}
|
||||
|
|
|
@ -1005,10 +1005,13 @@ static int llcp_sock_create(struct net *net, struct socket *sock,
|
|||
sock->type != SOCK_RAW)
|
||||
return -ESOCKTNOSUPPORT;
|
||||
|
||||
if (sock->type == SOCK_RAW)
|
||||
if (sock->type == SOCK_RAW) {
|
||||
if (!capable(CAP_NET_RAW))
|
||||
return -EPERM;
|
||||
sock->ops = &llcp_rawsock_ops;
|
||||
else
|
||||
} else {
|
||||
sock->ops = &llcp_sock_ops;
|
||||
}
|
||||
|
||||
sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC, kern);
|
||||
if (sk == NULL)
|
||||
|
|
|
@ -2152,7 +2152,7 @@ static const struct nla_policy vport_policy[OVS_VPORT_ATTR_MAX + 1] = {
|
|||
[OVS_VPORT_ATTR_STATS] = { .len = sizeof(struct ovs_vport_stats) },
|
||||
[OVS_VPORT_ATTR_PORT_NO] = { .type = NLA_U32 },
|
||||
[OVS_VPORT_ATTR_TYPE] = { .type = NLA_U32 },
|
||||
[OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_U32 },
|
||||
[OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_UNSPEC },
|
||||
[OVS_VPORT_ATTR_OPTIONS] = { .type = NLA_NESTED },
|
||||
};
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue