This is the 4.9.98 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAlro5ncACgkQONu9yGCS
aT4mDQ//U/INSIotnD9nahF/bYu4Ga4gWN3Wy8KsZKt3hH3ZeXi3iDx8dZyY5Cce
cjTWkx0ydpBX6l+hSl+5QRg+JsuYwbceR8CyftgluTz6/TdyfJVxzEQ+hLzHNAVh
ogazH9UVmjEMCXyvz75PWdYts0azVF6htym2XPSA46/JjH9n/Y6jXLS647QyDFf+
SnqN8bAmFd87AOPAhCVm59Es6FLX6SI/eDd6HCw/2V5nA4TtV70m/dUkLi6ZHtC5
8539CWnlrjBNj5ZLKIHutMqJQ+pXr//ZXLTI0cSiNO5dDyWhLaohNAezKU8GrN6C
phM86GkeBfDCeyZnDwygEVLXAcPbvN/tZCcQRuo7d9sI378w2/T+HHLqj5v7fi2E
fcmPlqlAq8DWYj2zWML+gYJwBfSdi+AzA/+67F3+nao7ckLyC1mUDZ+LPl4eoC5s
Ci1qwczB3C8STEhssbNh7YYzuhVqdBW/WiOIupE5fq5IehD1oGlHX3MnWt81v1Ro
zseeWewgnkkGlxIT0u5bTAVby3rFseAje8p4sszqwh5oTh0e57d/ptYoW9gIiEdX
DjVojcy3+lGGxJZKF7knE3ftqXQgrFd8SLo9zxE4W3/rM9fjBxgjPzdcix/GaPr2
lDKUu4R/ykD8JR9nLTRkGDbmFKh88eDehU7zzTFr3JsoIrLtcVU=
=adH3
-----END PGP SIGNATURE-----
Merge 4.9.98 into android-4.9
Changes in 4.9.98
ext4: prevent right-shifting extents beyond EXT_MAX_BLOCKS
ext4: set h_journal if there is a failure starting a reserved handle
ext4: add validity checks for bitmap block numbers
ext4: fix bitmap position validation
random: set up the NUMA crng instances after the CRNG is fully initialized
random: fix possible sleeping allocation from irq context
random: rate limit unseeded randomness warnings
usbip: usbip_event: fix to not print kernel pointer address
usbip: usbip_host: fix to hold parent lock for device_attach() calls
usbip: vhci_hcd: Fix usb device and sockfd leaks
USB: serial: simple: add libtransistor console
USB: serial: ftdi_sio: use jtag quirk for Arrow USB Blaster
USB: serial: cp210x: add ID for NI USB serial console
usb: core: Add quirk for HP v222w 16GB Mini
USB: Increment wakeup count on remote wakeup.
ALSA: usb-audio: Skip broken EU on Dell dock USB-audio
virtio: add ability to iterate over vqs
virtio_console: free buffers after reset
drm/virtio: fix vq wait_event condition
tty: Don't call panic() at tty_ldisc_init()
tty: n_gsm: Fix long delays with control frame timeouts in ADM mode
tty: n_gsm: Fix DLCI handling for ADM mode if debug & 2 is not set
tty: Use __GFP_NOFAIL for tty_ldisc_get()
ALSA: dice: fix OUI for TC group
ALSA: dice: fix error path to destroy initialized stream data
ALSA: opl3: Hardening for potential Spectre v1
ALSA: asihpi: Hardening for potential Spectre v1
ALSA: hdspm: Hardening for potential Spectre v1
ALSA: rme9652: Hardening for potential Spectre v1
ALSA: control: Hardening for potential Spectre v1
ALSA: core: Report audio_tstamp in snd_pcm_sync_ptr
ALSA: seq: oss: Fix unbalanced use lock for synth MIDI device
ALSA: seq: oss: Hardening for potential Spectre v1
ALSA: hda: Hardening for potential Spectre v1
ALSA: hda/realtek - Add some fixes for ALC233
mtd: cfi: cmdset_0001: Do not allow read/write to suspend erase block.
mtd: cfi: cmdset_0001: Workaround Micron Erase suspend bug.
mtd: cfi: cmdset_0002: Do not allow read/write to suspend erase block.
kobject: don't use WARN for registration failures
scsi: sd: Defer spinning up drive while SANITIZE is in progress
PCI: aardvark: Fix logic in advk_pcie_{rd,wr}_conf()
PCI: aardvark: Set PIO_ADDR_LS correctly in advk_pcie_rd_conf()
PCI: aardvark: Fix PCIe Max Read Request Size setting
ARM: amba: Make driver_override output consistent with other buses
ARM: amba: Fix race condition with driver_override
ARM: amba: Don't read past the end of sysfs "driver_override" buffer
crypto: drbg - set freed buffers to NULL
ASoC: fsl_esai: Fix divisor calculation failure at lower ratio
libceph: un-backoff on tick when we have a authenticated session
libceph: reschedule a tick in finish_hunting()
libceph: validate con->state at the top of try_write()
earlycon: Use a pointer table to fix __earlycon_table stride
cpufreq: powernv: Fix hardlockup due to synchronous smp_call in timer interrupt
rtc: opal: Fix OPAL RTC driver OPAL_BUSY loops
drm/amdgpu: set COMPUTE_PGM_RSRC1 for SGPR/VGPR clearing shaders
objtool, perf: Fix GCC 8 -Wrestrict error
tools/lib/subcmd/pager.c: do not alias select() params
x86/ipc: Fix x32 version of shmid64_ds and msqid64_ds
x86/smpboot: Don't use mwait_play_dead() on AMD systems
x86/microcode/intel: Save microcode patch unconditionally
powerpc/eeh: Fix race with driver un/bind
Linux 4.9.98
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
f679e4d9b7
65 changed files with 584 additions and 231 deletions
2
Makefile
2
Makefile
|
|
@ -1,6 +1,6 @@
|
|||
VERSION = 4
|
||||
PATCHLEVEL = 9
|
||||
SUBLEVEL = 97
|
||||
SUBLEVEL = 98
|
||||
EXTRAVERSION =
|
||||
NAME = Roaring Lionus
|
||||
|
||||
|
|
|
|||
|
|
@ -207,18 +207,18 @@ static void *eeh_report_error(void *data, void *userdata)
|
|||
|
||||
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
||||
return NULL;
|
||||
|
||||
device_lock(&dev->dev);
|
||||
dev->error_state = pci_channel_io_frozen;
|
||||
|
||||
driver = eeh_pcid_get(dev);
|
||||
if (!driver) return NULL;
|
||||
if (!driver) goto out_no_dev;
|
||||
|
||||
eeh_disable_irq(dev);
|
||||
|
||||
if (!driver->err_handler ||
|
||||
!driver->err_handler->error_detected) {
|
||||
eeh_pcid_put(dev);
|
||||
return NULL;
|
||||
}
|
||||
!driver->err_handler->error_detected)
|
||||
goto out;
|
||||
|
||||
rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
|
||||
|
||||
|
|
@ -227,7 +227,10 @@ static void *eeh_report_error(void *data, void *userdata)
|
|||
if (*res == PCI_ERS_RESULT_NONE) *res = rc;
|
||||
|
||||
edev->in_error = true;
|
||||
out:
|
||||
eeh_pcid_put(dev);
|
||||
out_no_dev:
|
||||
device_unlock(&dev->dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -250,15 +253,14 @@ static void *eeh_report_mmio_enabled(void *data, void *userdata)
|
|||
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
||||
return NULL;
|
||||
|
||||
device_lock(&dev->dev);
|
||||
driver = eeh_pcid_get(dev);
|
||||
if (!driver) return NULL;
|
||||
if (!driver) goto out_no_dev;
|
||||
|
||||
if (!driver->err_handler ||
|
||||
!driver->err_handler->mmio_enabled ||
|
||||
(edev->mode & EEH_DEV_NO_HANDLER)) {
|
||||
eeh_pcid_put(dev);
|
||||
return NULL;
|
||||
}
|
||||
(edev->mode & EEH_DEV_NO_HANDLER))
|
||||
goto out;
|
||||
|
||||
rc = driver->err_handler->mmio_enabled(dev);
|
||||
|
||||
|
|
@ -266,7 +268,10 @@ static void *eeh_report_mmio_enabled(void *data, void *userdata)
|
|||
if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
|
||||
if (*res == PCI_ERS_RESULT_NONE) *res = rc;
|
||||
|
||||
out:
|
||||
eeh_pcid_put(dev);
|
||||
out_no_dev:
|
||||
device_unlock(&dev->dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -289,20 +294,20 @@ static void *eeh_report_reset(void *data, void *userdata)
|
|||
|
||||
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
||||
return NULL;
|
||||
|
||||
device_lock(&dev->dev);
|
||||
dev->error_state = pci_channel_io_normal;
|
||||
|
||||
driver = eeh_pcid_get(dev);
|
||||
if (!driver) return NULL;
|
||||
if (!driver) goto out_no_dev;
|
||||
|
||||
eeh_enable_irq(dev);
|
||||
|
||||
if (!driver->err_handler ||
|
||||
!driver->err_handler->slot_reset ||
|
||||
(edev->mode & EEH_DEV_NO_HANDLER) ||
|
||||
(!edev->in_error)) {
|
||||
eeh_pcid_put(dev);
|
||||
return NULL;
|
||||
}
|
||||
(!edev->in_error))
|
||||
goto out;
|
||||
|
||||
rc = driver->err_handler->slot_reset(dev);
|
||||
if ((*res == PCI_ERS_RESULT_NONE) ||
|
||||
|
|
@ -310,7 +315,10 @@ static void *eeh_report_reset(void *data, void *userdata)
|
|||
if (*res == PCI_ERS_RESULT_DISCONNECT &&
|
||||
rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
|
||||
|
||||
out:
|
||||
eeh_pcid_put(dev);
|
||||
out_no_dev:
|
||||
device_unlock(&dev->dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -361,10 +369,12 @@ static void *eeh_report_resume(void *data, void *userdata)
|
|||
|
||||
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
||||
return NULL;
|
||||
|
||||
device_lock(&dev->dev);
|
||||
dev->error_state = pci_channel_io_normal;
|
||||
|
||||
driver = eeh_pcid_get(dev);
|
||||
if (!driver) return NULL;
|
||||
if (!driver) goto out_no_dev;
|
||||
|
||||
was_in_error = edev->in_error;
|
||||
edev->in_error = false;
|
||||
|
|
@ -374,13 +384,15 @@ static void *eeh_report_resume(void *data, void *userdata)
|
|||
!driver->err_handler->resume ||
|
||||
(edev->mode & EEH_DEV_NO_HANDLER) || !was_in_error) {
|
||||
edev->mode &= ~EEH_DEV_NO_HANDLER;
|
||||
eeh_pcid_put(dev);
|
||||
return NULL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
driver->err_handler->resume(dev);
|
||||
|
||||
out:
|
||||
eeh_pcid_put(dev);
|
||||
out_no_dev:
|
||||
device_unlock(&dev->dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -400,22 +412,25 @@ static void *eeh_report_failure(void *data, void *userdata)
|
|||
|
||||
if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
|
||||
return NULL;
|
||||
|
||||
device_lock(&dev->dev);
|
||||
dev->error_state = pci_channel_io_perm_failure;
|
||||
|
||||
driver = eeh_pcid_get(dev);
|
||||
if (!driver) return NULL;
|
||||
if (!driver) goto out_no_dev;
|
||||
|
||||
eeh_disable_irq(dev);
|
||||
|
||||
if (!driver->err_handler ||
|
||||
!driver->err_handler->error_detected) {
|
||||
eeh_pcid_put(dev);
|
||||
return NULL;
|
||||
}
|
||||
!driver->err_handler->error_detected)
|
||||
goto out;
|
||||
|
||||
driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
|
||||
|
||||
out:
|
||||
eeh_pcid_put(dev);
|
||||
out_no_dev:
|
||||
device_unlock(&dev->dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -48,10 +48,12 @@ unsigned long __init opal_get_boot_time(void)
|
|||
|
||||
while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
|
||||
rc = opal_rtc_read(&__y_m_d, &__h_m_s_ms);
|
||||
if (rc == OPAL_BUSY_EVENT)
|
||||
if (rc == OPAL_BUSY_EVENT) {
|
||||
mdelay(OPAL_BUSY_DELAY_MS);
|
||||
opal_poll_events(NULL);
|
||||
else if (rc == OPAL_BUSY)
|
||||
mdelay(10);
|
||||
} else if (rc == OPAL_BUSY) {
|
||||
mdelay(OPAL_BUSY_DELAY_MS);
|
||||
}
|
||||
}
|
||||
if (rc != OPAL_SUCCESS)
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -1 +1,32 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef __ASM_X64_MSGBUF_H
|
||||
#define __ASM_X64_MSGBUF_H
|
||||
|
||||
#if !defined(__x86_64__) || !defined(__ILP32__)
|
||||
#include <asm-generic/msgbuf.h>
|
||||
#else
|
||||
/*
|
||||
* The msqid64_ds structure for x86 architecture with x32 ABI.
|
||||
*
|
||||
* On x86-32 and x86-64 we can just use the generic definition, but
|
||||
* x32 uses the same binary layout as x86_64, which is differnet
|
||||
* from other 32-bit architectures.
|
||||
*/
|
||||
|
||||
struct msqid64_ds {
|
||||
struct ipc64_perm msg_perm;
|
||||
__kernel_time_t msg_stime; /* last msgsnd time */
|
||||
__kernel_time_t msg_rtime; /* last msgrcv time */
|
||||
__kernel_time_t msg_ctime; /* last change time */
|
||||
__kernel_ulong_t msg_cbytes; /* current number of bytes on queue */
|
||||
__kernel_ulong_t msg_qnum; /* number of messages in queue */
|
||||
__kernel_ulong_t msg_qbytes; /* max number of bytes on queue */
|
||||
__kernel_pid_t msg_lspid; /* pid of last msgsnd */
|
||||
__kernel_pid_t msg_lrpid; /* last receive pid */
|
||||
__kernel_ulong_t __unused4;
|
||||
__kernel_ulong_t __unused5;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __ASM_GENERIC_MSGBUF_H */
|
||||
|
|
|
|||
|
|
@ -1 +1,43 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef __ASM_X86_SHMBUF_H
|
||||
#define __ASM_X86_SHMBUF_H
|
||||
|
||||
#if !defined(__x86_64__) || !defined(__ILP32__)
|
||||
#include <asm-generic/shmbuf.h>
|
||||
#else
|
||||
/*
|
||||
* The shmid64_ds structure for x86 architecture with x32 ABI.
|
||||
*
|
||||
* On x86-32 and x86-64 we can just use the generic definition, but
|
||||
* x32 uses the same binary layout as x86_64, which is differnet
|
||||
* from other 32-bit architectures.
|
||||
*/
|
||||
|
||||
struct shmid64_ds {
|
||||
struct ipc64_perm shm_perm; /* operation perms */
|
||||
size_t shm_segsz; /* size of segment (bytes) */
|
||||
__kernel_time_t shm_atime; /* last attach time */
|
||||
__kernel_time_t shm_dtime; /* last detach time */
|
||||
__kernel_time_t shm_ctime; /* last change time */
|
||||
__kernel_pid_t shm_cpid; /* pid of creator */
|
||||
__kernel_pid_t shm_lpid; /* pid of last operator */
|
||||
__kernel_ulong_t shm_nattch; /* no. of current attaches */
|
||||
__kernel_ulong_t __unused4;
|
||||
__kernel_ulong_t __unused5;
|
||||
};
|
||||
|
||||
struct shminfo64 {
|
||||
__kernel_ulong_t shmmax;
|
||||
__kernel_ulong_t shmmin;
|
||||
__kernel_ulong_t shmmni;
|
||||
__kernel_ulong_t shmseg;
|
||||
__kernel_ulong_t shmall;
|
||||
__kernel_ulong_t __unused1;
|
||||
__kernel_ulong_t __unused2;
|
||||
__kernel_ulong_t __unused3;
|
||||
__kernel_ulong_t __unused4;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __ASM_X86_SHMBUF_H */
|
||||
|
|
|
|||
|
|
@ -474,7 +474,6 @@ static void show_saved_mc(void)
|
|||
*/
|
||||
static void save_mc_for_early(u8 *mc)
|
||||
{
|
||||
#ifdef CONFIG_HOTPLUG_CPU
|
||||
/* Synchronization during CPU hotplug. */
|
||||
static DEFINE_MUTEX(x86_cpu_microcode_mutex);
|
||||
|
||||
|
|
@ -521,7 +520,6 @@ static void save_mc_for_early(u8 *mc)
|
|||
|
||||
out:
|
||||
mutex_unlock(&x86_cpu_microcode_mutex);
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool __init load_builtin_intel_microcode(struct cpio_data *cp)
|
||||
|
|
|
|||
|
|
@ -1591,6 +1591,8 @@ static inline void mwait_play_dead(void)
|
|||
void *mwait_ptr;
|
||||
int i;
|
||||
|
||||
if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
|
||||
return;
|
||||
if (!this_cpu_has(X86_FEATURE_MWAIT))
|
||||
return;
|
||||
if (!this_cpu_has(X86_FEATURE_CLFLUSH))
|
||||
|
|
|
|||
|
|
@ -1134,8 +1134,10 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg)
|
|||
if (!drbg)
|
||||
return;
|
||||
kzfree(drbg->Vbuf);
|
||||
drbg->Vbuf = NULL;
|
||||
drbg->V = NULL;
|
||||
kzfree(drbg->Cbuf);
|
||||
drbg->Cbuf = NULL;
|
||||
drbg->C = NULL;
|
||||
kzfree(drbg->scratchpadbuf);
|
||||
drbg->scratchpadbuf = NULL;
|
||||
|
|
|
|||
|
|
@ -69,11 +69,12 @@ static ssize_t driver_override_show(struct device *_dev,
|
|||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct amba_device *dev = to_amba_device(_dev);
|
||||
ssize_t len;
|
||||
|
||||
if (!dev->driver_override)
|
||||
return 0;
|
||||
|
||||
return sprintf(buf, "%s\n", dev->driver_override);
|
||||
device_lock(_dev);
|
||||
len = sprintf(buf, "%s\n", dev->driver_override);
|
||||
device_unlock(_dev);
|
||||
return len;
|
||||
}
|
||||
|
||||
static ssize_t driver_override_store(struct device *_dev,
|
||||
|
|
@ -81,7 +82,7 @@ static ssize_t driver_override_store(struct device *_dev,
|
|||
const char *buf, size_t count)
|
||||
{
|
||||
struct amba_device *dev = to_amba_device(_dev);
|
||||
char *driver_override, *old = dev->driver_override, *cp;
|
||||
char *driver_override, *old, *cp;
|
||||
|
||||
/* We need to keep extra room for a newline */
|
||||
if (count >= (PAGE_SIZE - 1))
|
||||
|
|
@ -95,12 +96,15 @@ static ssize_t driver_override_store(struct device *_dev,
|
|||
if (cp)
|
||||
*cp = '\0';
|
||||
|
||||
device_lock(_dev);
|
||||
old = dev->driver_override;
|
||||
if (strlen(driver_override)) {
|
||||
dev->driver_override = driver_override;
|
||||
} else {
|
||||
kfree(driver_override);
|
||||
dev->driver_override = NULL;
|
||||
}
|
||||
device_unlock(_dev);
|
||||
|
||||
kfree(old);
|
||||
|
||||
|
|
|
|||
|
|
@ -259,6 +259,7 @@
|
|||
#include <linux/kmemcheck.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/ratelimit.h>
|
||||
#include <linux/syscalls.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/uuid.h>
|
||||
|
|
@ -444,6 +445,16 @@ static void _crng_backtrack_protect(struct crng_state *crng,
|
|||
__u8 tmp[CHACHA20_BLOCK_SIZE], int used);
|
||||
static void process_random_ready_list(void);
|
||||
|
||||
static struct ratelimit_state unseeded_warning =
|
||||
RATELIMIT_STATE_INIT("warn_unseeded_randomness", HZ, 3);
|
||||
static struct ratelimit_state urandom_warning =
|
||||
RATELIMIT_STATE_INIT("warn_urandom_randomness", HZ, 3);
|
||||
|
||||
static int ratelimit_disable __read_mostly;
|
||||
|
||||
module_param_named(ratelimit_disable, ratelimit_disable, int, 0644);
|
||||
MODULE_PARM_DESC(ratelimit_disable, "Disable random ratelimit suppression");
|
||||
|
||||
/**********************************************************************
|
||||
*
|
||||
* OS independent entropy store. Here are the functions which handle
|
||||
|
|
@ -819,6 +830,39 @@ static int crng_fast_load(const char *cp, size_t len)
|
|||
return 1;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_NUMA
|
||||
static void do_numa_crng_init(struct work_struct *work)
|
||||
{
|
||||
int i;
|
||||
struct crng_state *crng;
|
||||
struct crng_state **pool;
|
||||
|
||||
pool = kcalloc(nr_node_ids, sizeof(*pool), GFP_KERNEL|__GFP_NOFAIL);
|
||||
for_each_online_node(i) {
|
||||
crng = kmalloc_node(sizeof(struct crng_state),
|
||||
GFP_KERNEL | __GFP_NOFAIL, i);
|
||||
spin_lock_init(&crng->lock);
|
||||
crng_initialize(crng);
|
||||
pool[i] = crng;
|
||||
}
|
||||
mb();
|
||||
if (cmpxchg(&crng_node_pool, NULL, pool)) {
|
||||
for_each_node(i)
|
||||
kfree(pool[i]);
|
||||
kfree(pool);
|
||||
}
|
||||
}
|
||||
|
||||
static DECLARE_WORK(numa_crng_init_work, do_numa_crng_init);
|
||||
|
||||
static void numa_crng_init(void)
|
||||
{
|
||||
schedule_work(&numa_crng_init_work);
|
||||
}
|
||||
#else
|
||||
static void numa_crng_init(void) {}
|
||||
#endif
|
||||
|
||||
static void crng_reseed(struct crng_state *crng, struct entropy_store *r)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
|
@ -848,10 +892,23 @@ static void crng_reseed(struct crng_state *crng, struct entropy_store *r)
|
|||
memzero_explicit(&buf, sizeof(buf));
|
||||
crng->init_time = jiffies;
|
||||
if (crng == &primary_crng && crng_init < 2) {
|
||||
numa_crng_init();
|
||||
crng_init = 2;
|
||||
process_random_ready_list();
|
||||
wake_up_interruptible(&crng_init_wait);
|
||||
pr_notice("random: crng init done\n");
|
||||
if (unseeded_warning.missed) {
|
||||
pr_notice("random: %d get_random_xx warning(s) missed "
|
||||
"due to ratelimiting\n",
|
||||
unseeded_warning.missed);
|
||||
unseeded_warning.missed = 0;
|
||||
}
|
||||
if (urandom_warning.missed) {
|
||||
pr_notice("random: %d urandom warning(s) missed "
|
||||
"due to ratelimiting\n",
|
||||
urandom_warning.missed);
|
||||
urandom_warning.missed = 0;
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&crng->lock, flags);
|
||||
}
|
||||
|
|
@ -1661,29 +1718,14 @@ static void init_std_data(struct entropy_store *r)
|
|||
*/
|
||||
static int rand_initialize(void)
|
||||
{
|
||||
#ifdef CONFIG_NUMA
|
||||
int i;
|
||||
struct crng_state *crng;
|
||||
struct crng_state **pool;
|
||||
#endif
|
||||
|
||||
init_std_data(&input_pool);
|
||||
init_std_data(&blocking_pool);
|
||||
crng_initialize(&primary_crng);
|
||||
crng_global_init_time = jiffies;
|
||||
|
||||
#ifdef CONFIG_NUMA
|
||||
pool = kcalloc(nr_node_ids, sizeof(*pool), GFP_KERNEL|__GFP_NOFAIL);
|
||||
for_each_online_node(i) {
|
||||
crng = kmalloc_node(sizeof(struct crng_state),
|
||||
GFP_KERNEL | __GFP_NOFAIL, i);
|
||||
spin_lock_init(&crng->lock);
|
||||
crng_initialize(crng);
|
||||
pool[i] = crng;
|
||||
if (ratelimit_disable) {
|
||||
urandom_warning.interval = 0;
|
||||
unseeded_warning.interval = 0;
|
||||
}
|
||||
mb();
|
||||
crng_node_pool = pool;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
early_initcall(rand_initialize);
|
||||
|
|
@ -1751,9 +1793,10 @@ urandom_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
|
|||
|
||||
if (!crng_ready() && maxwarn > 0) {
|
||||
maxwarn--;
|
||||
printk(KERN_NOTICE "random: %s: uninitialized urandom read "
|
||||
"(%zd bytes read)\n",
|
||||
current->comm, nbytes);
|
||||
if (__ratelimit(&urandom_warning))
|
||||
printk(KERN_NOTICE "random: %s: uninitialized "
|
||||
"urandom read (%zd bytes read)\n",
|
||||
current->comm, nbytes);
|
||||
spin_lock_irqsave(&primary_crng.lock, flags);
|
||||
crng_init_cnt = 0;
|
||||
spin_unlock_irqrestore(&primary_crng.lock, flags);
|
||||
|
|
|
|||
|
|
@ -1405,7 +1405,6 @@ static int add_port(struct ports_device *portdev, u32 id)
|
|||
{
|
||||
char debugfs_name[16];
|
||||
struct port *port;
|
||||
struct port_buffer *buf;
|
||||
dev_t devt;
|
||||
unsigned int nr_added_bufs;
|
||||
int err;
|
||||
|
|
@ -1516,8 +1515,6 @@ static int add_port(struct ports_device *portdev, u32 id)
|
|||
return 0;
|
||||
|
||||
free_inbufs:
|
||||
while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
|
||||
free_buf(buf, true);
|
||||
free_device:
|
||||
device_destroy(pdrvdata.class, port->dev->devt);
|
||||
free_cdev:
|
||||
|
|
@ -1542,34 +1539,14 @@ static void remove_port(struct kref *kref)
|
|||
|
||||
static void remove_port_data(struct port *port)
|
||||
{
|
||||
struct port_buffer *buf;
|
||||
|
||||
spin_lock_irq(&port->inbuf_lock);
|
||||
/* Remove unused data this port might have received. */
|
||||
discard_port_data(port);
|
||||
spin_unlock_irq(&port->inbuf_lock);
|
||||
|
||||
/* Remove buffers we queued up for the Host to send us data in. */
|
||||
do {
|
||||
spin_lock_irq(&port->inbuf_lock);
|
||||
buf = virtqueue_detach_unused_buf(port->in_vq);
|
||||
spin_unlock_irq(&port->inbuf_lock);
|
||||
if (buf)
|
||||
free_buf(buf, true);
|
||||
} while (buf);
|
||||
|
||||
spin_lock_irq(&port->outvq_lock);
|
||||
reclaim_consumed_buffers(port);
|
||||
spin_unlock_irq(&port->outvq_lock);
|
||||
|
||||
/* Free pending buffers from the out-queue. */
|
||||
do {
|
||||
spin_lock_irq(&port->outvq_lock);
|
||||
buf = virtqueue_detach_unused_buf(port->out_vq);
|
||||
spin_unlock_irq(&port->outvq_lock);
|
||||
if (buf)
|
||||
free_buf(buf, true);
|
||||
} while (buf);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1794,13 +1771,24 @@ static void control_work_handler(struct work_struct *work)
|
|||
spin_unlock(&portdev->c_ivq_lock);
|
||||
}
|
||||
|
||||
static void flush_bufs(struct virtqueue *vq, bool can_sleep)
|
||||
{
|
||||
struct port_buffer *buf;
|
||||
unsigned int len;
|
||||
|
||||
while ((buf = virtqueue_get_buf(vq, &len)))
|
||||
free_buf(buf, can_sleep);
|
||||
}
|
||||
|
||||
static void out_intr(struct virtqueue *vq)
|
||||
{
|
||||
struct port *port;
|
||||
|
||||
port = find_port_by_vq(vq->vdev->priv, vq);
|
||||
if (!port)
|
||||
if (!port) {
|
||||
flush_bufs(vq, false);
|
||||
return;
|
||||
}
|
||||
|
||||
wake_up_interruptible(&port->waitqueue);
|
||||
}
|
||||
|
|
@ -1811,8 +1799,10 @@ static void in_intr(struct virtqueue *vq)
|
|||
unsigned long flags;
|
||||
|
||||
port = find_port_by_vq(vq->vdev->priv, vq);
|
||||
if (!port)
|
||||
if (!port) {
|
||||
flush_bufs(vq, false);
|
||||
return;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&port->inbuf_lock, flags);
|
||||
port->inbuf = get_inbuf(port);
|
||||
|
|
@ -1987,6 +1977,15 @@ static const struct file_operations portdev_fops = {
|
|||
|
||||
static void remove_vqs(struct ports_device *portdev)
|
||||
{
|
||||
struct virtqueue *vq;
|
||||
|
||||
virtio_device_for_each_vq(portdev->vdev, vq) {
|
||||
struct port_buffer *buf;
|
||||
|
||||
flush_bufs(vq, true);
|
||||
while ((buf = virtqueue_detach_unused_buf(vq)))
|
||||
free_buf(buf, true);
|
||||
}
|
||||
portdev->vdev->config->del_vqs(portdev->vdev);
|
||||
kfree(portdev->in_vqs);
|
||||
kfree(portdev->out_vqs);
|
||||
|
|
|
|||
|
|
@ -599,6 +599,16 @@ void gpstate_timer_handler(unsigned long data)
|
|||
|
||||
if (!spin_trylock(&gpstates->gpstate_lock))
|
||||
return;
|
||||
/*
|
||||
* If the timer has migrated to the different cpu then bring
|
||||
* it back to one of the policy->cpus
|
||||
*/
|
||||
if (!cpumask_test_cpu(raw_smp_processor_id(), policy->cpus)) {
|
||||
gpstates->timer.expires = jiffies + msecs_to_jiffies(1);
|
||||
add_timer_on(&gpstates->timer, cpumask_first(policy->cpus));
|
||||
spin_unlock(&gpstates->gpstate_lock);
|
||||
return;
|
||||
}
|
||||
|
||||
gpstates->last_sampled_time += time_diff;
|
||||
gpstates->elapsed_time += time_diff;
|
||||
|
|
@ -626,10 +636,8 @@ void gpstate_timer_handler(unsigned long data)
|
|||
gpstates->last_gpstate_idx = pstate_to_idx(freq_data.gpstate_id);
|
||||
gpstates->last_lpstate_idx = pstate_to_idx(freq_data.pstate_id);
|
||||
|
||||
set_pstate(&freq_data);
|
||||
spin_unlock(&gpstates->gpstate_lock);
|
||||
|
||||
/* Timer may get migrated to a different cpu on cpu hot unplug */
|
||||
smp_call_function_any(policy->cpus, set_pstate, &freq_data, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -1484,10 +1484,11 @@ static const u32 sgpr_init_compute_shader[] =
|
|||
static const u32 vgpr_init_regs[] =
|
||||
{
|
||||
mmCOMPUTE_STATIC_THREAD_MGMT_SE0, 0xffffffff,
|
||||
mmCOMPUTE_RESOURCE_LIMITS, 0,
|
||||
mmCOMPUTE_RESOURCE_LIMITS, 0x1000000, /* CU_GROUP_COUNT=1 */
|
||||
mmCOMPUTE_NUM_THREAD_X, 256*4,
|
||||
mmCOMPUTE_NUM_THREAD_Y, 1,
|
||||
mmCOMPUTE_NUM_THREAD_Z, 1,
|
||||
mmCOMPUTE_PGM_RSRC1, 0x100004f, /* VGPRS=15 (64 logical VGPRs), SGPRS=1 (16 SGPRs), BULKY=1 */
|
||||
mmCOMPUTE_PGM_RSRC2, 20,
|
||||
mmCOMPUTE_USER_DATA_0, 0xedcedc00,
|
||||
mmCOMPUTE_USER_DATA_1, 0xedcedc01,
|
||||
|
|
@ -1504,10 +1505,11 @@ static const u32 vgpr_init_regs[] =
|
|||
static const u32 sgpr1_init_regs[] =
|
||||
{
|
||||
mmCOMPUTE_STATIC_THREAD_MGMT_SE0, 0x0f,
|
||||
mmCOMPUTE_RESOURCE_LIMITS, 0x1000000,
|
||||
mmCOMPUTE_RESOURCE_LIMITS, 0x1000000, /* CU_GROUP_COUNT=1 */
|
||||
mmCOMPUTE_NUM_THREAD_X, 256*5,
|
||||
mmCOMPUTE_NUM_THREAD_Y, 1,
|
||||
mmCOMPUTE_NUM_THREAD_Z, 1,
|
||||
mmCOMPUTE_PGM_RSRC1, 0x240, /* SGPRS=9 (80 GPRS) */
|
||||
mmCOMPUTE_PGM_RSRC2, 20,
|
||||
mmCOMPUTE_USER_DATA_0, 0xedcedc00,
|
||||
mmCOMPUTE_USER_DATA_1, 0xedcedc01,
|
||||
|
|
@ -1528,6 +1530,7 @@ static const u32 sgpr2_init_regs[] =
|
|||
mmCOMPUTE_NUM_THREAD_X, 256*5,
|
||||
mmCOMPUTE_NUM_THREAD_Y, 1,
|
||||
mmCOMPUTE_NUM_THREAD_Z, 1,
|
||||
mmCOMPUTE_PGM_RSRC1, 0x240, /* SGPRS=9 (80 GPRS) */
|
||||
mmCOMPUTE_PGM_RSRC2, 20,
|
||||
mmCOMPUTE_USER_DATA_0, 0xedcedc00,
|
||||
mmCOMPUTE_USER_DATA_1, 0xedcedc01,
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ retry:
|
|||
ret = virtqueue_add_sgs(vq, sgs, outcnt, incnt, vbuf, GFP_ATOMIC);
|
||||
if (ret == -ENOSPC) {
|
||||
spin_unlock(&vgdev->ctrlq.qlock);
|
||||
wait_event(vgdev->ctrlq.ack_queue, vq->num_free);
|
||||
wait_event(vgdev->ctrlq.ack_queue, vq->num_free >= outcnt + incnt);
|
||||
spin_lock(&vgdev->ctrlq.qlock);
|
||||
goto retry;
|
||||
} else {
|
||||
|
|
@ -399,7 +399,7 @@ retry:
|
|||
ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC);
|
||||
if (ret == -ENOSPC) {
|
||||
spin_unlock(&vgdev->cursorq.qlock);
|
||||
wait_event(vgdev->cursorq.ack_queue, vq->num_free);
|
||||
wait_event(vgdev->cursorq.ack_queue, vq->num_free >= outcnt);
|
||||
spin_lock(&vgdev->cursorq.qlock);
|
||||
goto retry;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -45,6 +45,7 @@
|
|||
#define I82802AB 0x00ad
|
||||
#define I82802AC 0x00ac
|
||||
#define PF38F4476 0x881c
|
||||
#define M28F00AP30 0x8963
|
||||
/* STMicroelectronics chips */
|
||||
#define M50LPW080 0x002F
|
||||
#define M50FLW080A 0x0080
|
||||
|
|
@ -375,6 +376,17 @@ static void cfi_fixup_major_minor(struct cfi_private *cfi,
|
|||
extp->MinorVersion = '1';
|
||||
}
|
||||
|
||||
static int cfi_is_micron_28F00AP30(struct cfi_private *cfi, struct flchip *chip)
|
||||
{
|
||||
/*
|
||||
* Micron(was Numonyx) 1Gbit bottom boot are buggy w.r.t
|
||||
* Erase Supend for their small Erase Blocks(0x8000)
|
||||
*/
|
||||
if (cfi->mfr == CFI_MFR_INTEL && cfi->id == M28F00AP30)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline struct cfi_pri_intelext *
|
||||
read_pri_intelext(struct map_info *map, __u16 adr)
|
||||
{
|
||||
|
|
@ -831,21 +843,30 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
|
|||
(mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
|
||||
goto sleep;
|
||||
|
||||
/* Do not allow suspend iff read/write to EB address */
|
||||
if ((adr & chip->in_progress_block_mask) ==
|
||||
chip->in_progress_block_addr)
|
||||
goto sleep;
|
||||
|
||||
/* do not suspend small EBs, buggy Micron Chips */
|
||||
if (cfi_is_micron_28F00AP30(cfi, chip) &&
|
||||
(chip->in_progress_block_mask == ~(0x8000-1)))
|
||||
goto sleep;
|
||||
|
||||
/* Erase suspend */
|
||||
map_write(map, CMD(0xB0), adr);
|
||||
map_write(map, CMD(0xB0), chip->in_progress_block_addr);
|
||||
|
||||
/* If the flash has finished erasing, then 'erase suspend'
|
||||
* appears to make some (28F320) flash devices switch to
|
||||
* 'read' mode. Make sure that we switch to 'read status'
|
||||
* mode so we get the right data. --rmk
|
||||
*/
|
||||
map_write(map, CMD(0x70), adr);
|
||||
map_write(map, CMD(0x70), chip->in_progress_block_addr);
|
||||
chip->oldstate = FL_ERASING;
|
||||
chip->state = FL_ERASE_SUSPENDING;
|
||||
chip->erase_suspended = 1;
|
||||
for (;;) {
|
||||
status = map_read(map, adr);
|
||||
status = map_read(map, chip->in_progress_block_addr);
|
||||
if (map_word_andequal(map, status, status_OK, status_OK))
|
||||
break;
|
||||
|
||||
|
|
@ -1041,8 +1062,8 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
|
|||
sending the 0x70 (Read Status) command to an erasing
|
||||
chip and expecting it to be ignored, that's what we
|
||||
do. */
|
||||
map_write(map, CMD(0xd0), adr);
|
||||
map_write(map, CMD(0x70), adr);
|
||||
map_write(map, CMD(0xd0), chip->in_progress_block_addr);
|
||||
map_write(map, CMD(0x70), chip->in_progress_block_addr);
|
||||
chip->oldstate = FL_READY;
|
||||
chip->state = FL_ERASING;
|
||||
break;
|
||||
|
|
@ -1933,6 +1954,8 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
|
|||
map_write(map, CMD(0xD0), adr);
|
||||
chip->state = FL_ERASING;
|
||||
chip->erase_suspended = 0;
|
||||
chip->in_progress_block_addr = adr;
|
||||
chip->in_progress_block_mask = ~(len - 1);
|
||||
|
||||
ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
|
||||
adr, len,
|
||||
|
|
|
|||
|
|
@ -812,9 +812,10 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
|
|||
(mode == FL_WRITING && (cfip->EraseSuspend & 0x2))))
|
||||
goto sleep;
|
||||
|
||||
/* We could check to see if we're trying to access the sector
|
||||
* that is currently being erased. However, no user will try
|
||||
* anything like that so we just wait for the timeout. */
|
||||
/* Do not allow suspend iff read/write to EB address */
|
||||
if ((adr & chip->in_progress_block_mask) ==
|
||||
chip->in_progress_block_addr)
|
||||
goto sleep;
|
||||
|
||||
/* Erase suspend */
|
||||
/* It's harmless to issue the Erase-Suspend and Erase-Resume
|
||||
|
|
@ -2263,6 +2264,7 @@ static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
|
|||
chip->state = FL_ERASING;
|
||||
chip->erase_suspended = 0;
|
||||
chip->in_progress_block_addr = adr;
|
||||
chip->in_progress_block_mask = ~(map->size - 1);
|
||||
|
||||
INVALIDATE_CACHE_UDELAY(map, chip,
|
||||
adr, map->size,
|
||||
|
|
@ -2352,6 +2354,7 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
|
|||
chip->state = FL_ERASING;
|
||||
chip->erase_suspended = 0;
|
||||
chip->in_progress_block_addr = adr;
|
||||
chip->in_progress_block_mask = ~(len - 1);
|
||||
|
||||
INVALIDATE_CACHE_UDELAY(map, chip,
|
||||
adr, len,
|
||||
|
|
|
|||
|
|
@ -935,7 +935,7 @@ int __init early_init_dt_scan_chosen_stdout(void)
|
|||
int offset;
|
||||
const char *p, *q, *options = NULL;
|
||||
int l;
|
||||
const struct earlycon_id *match;
|
||||
const struct earlycon_id **p_match;
|
||||
const void *fdt = initial_boot_params;
|
||||
|
||||
offset = fdt_path_offset(fdt, "/chosen");
|
||||
|
|
@ -962,7 +962,10 @@ int __init early_init_dt_scan_chosen_stdout(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
for (match = __earlycon_table; match < __earlycon_table_end; match++) {
|
||||
for (p_match = __earlycon_table; p_match < __earlycon_table_end;
|
||||
p_match++) {
|
||||
const struct earlycon_id *match = *p_match;
|
||||
|
||||
if (!match->compatible[0])
|
||||
continue;
|
||||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
#define PCIE_CORE_DEV_CTRL_STATS_MAX_PAYLOAD_SZ_SHIFT 5
|
||||
#define PCIE_CORE_DEV_CTRL_STATS_SNOOP_DISABLE (0 << 11)
|
||||
#define PCIE_CORE_DEV_CTRL_STATS_MAX_RD_REQ_SIZE_SHIFT 12
|
||||
#define PCIE_CORE_DEV_CTRL_STATS_MAX_RD_REQ_SZ 0x2
|
||||
#define PCIE_CORE_LINK_CTRL_STAT_REG 0xd0
|
||||
#define PCIE_CORE_LINK_L0S_ENTRY BIT(0)
|
||||
#define PCIE_CORE_LINK_TRAINING BIT(5)
|
||||
|
|
@ -175,8 +176,6 @@
|
|||
#define PCIE_CONFIG_WR_TYPE0 0xa
|
||||
#define PCIE_CONFIG_WR_TYPE1 0xb
|
||||
|
||||
/* PCI_BDF shifts 8bit, so we need extra 4bit shift */
|
||||
#define PCIE_BDF(dev) (dev << 4)
|
||||
#define PCIE_CONF_BUS(bus) (((bus) & 0xff) << 20)
|
||||
#define PCIE_CONF_DEV(dev) (((dev) & 0x1f) << 15)
|
||||
#define PCIE_CONF_FUNC(fun) (((fun) & 0x7) << 12)
|
||||
|
|
@ -298,7 +297,8 @@ static void advk_pcie_setup_hw(struct advk_pcie *pcie)
|
|||
reg = PCIE_CORE_DEV_CTRL_STATS_RELAX_ORDER_DISABLE |
|
||||
(7 << PCIE_CORE_DEV_CTRL_STATS_MAX_PAYLOAD_SZ_SHIFT) |
|
||||
PCIE_CORE_DEV_CTRL_STATS_SNOOP_DISABLE |
|
||||
PCIE_CORE_DEV_CTRL_STATS_MAX_RD_REQ_SIZE_SHIFT;
|
||||
(PCIE_CORE_DEV_CTRL_STATS_MAX_RD_REQ_SZ <<
|
||||
PCIE_CORE_DEV_CTRL_STATS_MAX_RD_REQ_SIZE_SHIFT);
|
||||
advk_writel(pcie, reg, PCIE_CORE_DEV_CTRL_STATS_REG);
|
||||
|
||||
/* Program PCIe Control 2 to disable strict ordering */
|
||||
|
|
@ -439,7 +439,7 @@ static int advk_pcie_rd_conf(struct pci_bus *bus, u32 devfn,
|
|||
u32 reg;
|
||||
int ret;
|
||||
|
||||
if (PCI_SLOT(devfn) != 0) {
|
||||
if ((bus->number == pcie->root_bus_nr) && PCI_SLOT(devfn) != 0) {
|
||||
*val = 0xffffffff;
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
}
|
||||
|
|
@ -458,7 +458,7 @@ static int advk_pcie_rd_conf(struct pci_bus *bus, u32 devfn,
|
|||
advk_writel(pcie, reg, PIO_CTRL);
|
||||
|
||||
/* Program the address registers */
|
||||
reg = PCIE_BDF(devfn) | PCIE_CONF_REG(where);
|
||||
reg = PCIE_CONF_ADDR(bus->number, devfn, where);
|
||||
advk_writel(pcie, reg, PIO_ADDR_LS);
|
||||
advk_writel(pcie, 0, PIO_ADDR_MS);
|
||||
|
||||
|
|
@ -493,7 +493,7 @@ static int advk_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
|
|||
int offset;
|
||||
int ret;
|
||||
|
||||
if (PCI_SLOT(devfn) != 0)
|
||||
if ((bus->number == pcie->root_bus_nr) && PCI_SLOT(devfn) != 0)
|
||||
return PCIBIOS_DEVICE_NOT_FOUND;
|
||||
|
||||
if (where % size)
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ static void tm_to_opal(struct rtc_time *tm, u32 *y_m_d, u64 *h_m_s_ms)
|
|||
|
||||
static int opal_get_rtc_time(struct device *dev, struct rtc_time *tm)
|
||||
{
|
||||
long rc = OPAL_BUSY;
|
||||
s64 rc = OPAL_BUSY;
|
||||
int retries = 10;
|
||||
u32 y_m_d;
|
||||
u64 h_m_s_ms;
|
||||
|
|
@ -66,13 +66,17 @@ static int opal_get_rtc_time(struct device *dev, struct rtc_time *tm)
|
|||
|
||||
while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
|
||||
rc = opal_rtc_read(&__y_m_d, &__h_m_s_ms);
|
||||
if (rc == OPAL_BUSY_EVENT)
|
||||
if (rc == OPAL_BUSY_EVENT) {
|
||||
msleep(OPAL_BUSY_DELAY_MS);
|
||||
opal_poll_events(NULL);
|
||||
else if (retries-- && (rc == OPAL_HARDWARE
|
||||
|| rc == OPAL_INTERNAL_ERROR))
|
||||
msleep(10);
|
||||
else if (rc != OPAL_BUSY && rc != OPAL_BUSY_EVENT)
|
||||
break;
|
||||
} else if (rc == OPAL_BUSY) {
|
||||
msleep(OPAL_BUSY_DELAY_MS);
|
||||
} else if (rc == OPAL_HARDWARE || rc == OPAL_INTERNAL_ERROR) {
|
||||
if (retries--) {
|
||||
msleep(10); /* Wait 10ms before retry */
|
||||
rc = OPAL_BUSY; /* go around again */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (rc != OPAL_SUCCESS)
|
||||
|
|
@ -87,21 +91,26 @@ static int opal_get_rtc_time(struct device *dev, struct rtc_time *tm)
|
|||
|
||||
static int opal_set_rtc_time(struct device *dev, struct rtc_time *tm)
|
||||
{
|
||||
long rc = OPAL_BUSY;
|
||||
s64 rc = OPAL_BUSY;
|
||||
int retries = 10;
|
||||
u32 y_m_d = 0;
|
||||
u64 h_m_s_ms = 0;
|
||||
|
||||
tm_to_opal(tm, &y_m_d, &h_m_s_ms);
|
||||
|
||||
while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
|
||||
rc = opal_rtc_write(y_m_d, h_m_s_ms);
|
||||
if (rc == OPAL_BUSY_EVENT)
|
||||
if (rc == OPAL_BUSY_EVENT) {
|
||||
msleep(OPAL_BUSY_DELAY_MS);
|
||||
opal_poll_events(NULL);
|
||||
else if (retries-- && (rc == OPAL_HARDWARE
|
||||
|| rc == OPAL_INTERNAL_ERROR))
|
||||
msleep(10);
|
||||
else if (rc != OPAL_BUSY && rc != OPAL_BUSY_EVENT)
|
||||
break;
|
||||
} else if (rc == OPAL_BUSY) {
|
||||
msleep(OPAL_BUSY_DELAY_MS);
|
||||
} else if (rc == OPAL_HARDWARE || rc == OPAL_INTERNAL_ERROR) {
|
||||
if (retries--) {
|
||||
msleep(10); /* Wait 10ms before retry */
|
||||
rc = OPAL_BUSY; /* go around again */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return rc == OPAL_SUCCESS ? 0 : -EIO;
|
||||
|
|
|
|||
|
|
@ -1935,6 +1935,8 @@ sd_spinup_disk(struct scsi_disk *sdkp)
|
|||
break; /* standby */
|
||||
if (sshdr.asc == 4 && sshdr.ascq == 0xc)
|
||||
break; /* unavailable */
|
||||
if (sshdr.asc == 4 && sshdr.ascq == 0x1b)
|
||||
break; /* sanitize in progress */
|
||||
/*
|
||||
* Issue command to spin up drive when not ready
|
||||
*/
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue