mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
Merge branch 'master' of /Volumes/CaseSensitiveDisk/linux
This commit is contained in:
commit
0afa1b62e3
65 changed files with 473 additions and 466 deletions
|
@ -78,7 +78,8 @@
|
|||
| CF_PAGE_READABLE \
|
||||
| CF_PAGE_WRITABLE \
|
||||
| CF_PAGE_EXEC \
|
||||
| CF_PAGE_SYSTEM)
|
||||
| CF_PAGE_SYSTEM \
|
||||
| CF_PAGE_SHARED)
|
||||
|
||||
#define PAGE_COPY __pgprot(CF_PAGE_VALID \
|
||||
| CF_PAGE_ACCESSED \
|
||||
|
|
|
@ -87,7 +87,7 @@ void __init paging_init(void)
|
|||
|
||||
int cf_tlb_miss(struct pt_regs *regs, int write, int dtlb, int extension_word)
|
||||
{
|
||||
unsigned long flags, mmuar;
|
||||
unsigned long flags, mmuar, mmutr;
|
||||
struct mm_struct *mm;
|
||||
pgd_t *pgd;
|
||||
pmd_t *pmd;
|
||||
|
@ -137,9 +137,10 @@ int cf_tlb_miss(struct pt_regs *regs, int write, int dtlb, int extension_word)
|
|||
if (!pte_dirty(*pte) && !KMAPAREA(mmuar))
|
||||
set_pte(pte, pte_wrprotect(*pte));
|
||||
|
||||
mmu_write(MMUTR, (mmuar & PAGE_MASK) | (asid << MMUTR_IDN) |
|
||||
(((int)(pte->pte) & (int)CF_PAGE_MMUTR_MASK)
|
||||
>> CF_PAGE_MMUTR_SHIFT) | MMUTR_V);
|
||||
mmutr = (mmuar & PAGE_MASK) | (asid << MMUTR_IDN) | MMUTR_V;
|
||||
if ((mmuar < TASK_UNMAPPED_BASE) || (mmuar >= TASK_SIZE))
|
||||
mmutr |= (pte->pte & CF_PAGE_MMUTR_MASK) >> CF_PAGE_MMUTR_SHIFT;
|
||||
mmu_write(MMUTR, mmutr);
|
||||
|
||||
mmu_write(MMUDR, (pte_val(*pte) & PAGE_MASK) |
|
||||
((pte->pte) & CF_PAGE_MMUDR_MASK) | MMUDR_SZ_8KB | MMUDR_X);
|
||||
|
|
|
@ -136,7 +136,7 @@ Luser_return:
|
|||
movel %sp,%d1 /* get thread_info pointer */
|
||||
andl #-THREAD_SIZE,%d1 /* at base of kernel stack */
|
||||
movel %d1,%a0
|
||||
movel %a0@(TINFO_FLAGS),%d1 /* get thread_info->flags */
|
||||
moveb %a0@(TINFO_FLAGS+3),%d1 /* thread_info->flags (low 8 bits) */
|
||||
jne Lwork_to_do /* still work to do */
|
||||
|
||||
Lreturn:
|
||||
|
@ -148,8 +148,6 @@ Lwork_to_do:
|
|||
btst #TIF_NEED_RESCHED,%d1
|
||||
jne reschedule
|
||||
|
||||
/* GERG: do we need something here for TRACEing?? */
|
||||
|
||||
Lsignal_return:
|
||||
subql #4,%sp /* dummy return address */
|
||||
SAVE_SWITCH_STACK
|
||||
|
|
|
@ -1213,7 +1213,7 @@ do_user_signal: /* r10 contains MSR_KERNEL here */
|
|||
stw r3,_TRAP(r1)
|
||||
2: addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
mr r4,r9
|
||||
bl do_signal
|
||||
bl do_notify_resume
|
||||
REST_NVGPRS(r1)
|
||||
b recheck
|
||||
|
||||
|
|
|
@ -751,12 +751,16 @@ user_work:
|
|||
|
||||
andi. r0,r4,_TIF_NEED_RESCHED
|
||||
beq 1f
|
||||
li r5,1
|
||||
TRACE_AND_RESTORE_IRQ(r5);
|
||||
bl .schedule
|
||||
b .ret_from_except_lite
|
||||
|
||||
1: bl .save_nvgprs
|
||||
li r5,1
|
||||
TRACE_AND_RESTORE_IRQ(r5);
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
bl .do_signal
|
||||
bl .do_notify_resume
|
||||
b .ret_from_except
|
||||
|
||||
unrecov_restore:
|
||||
|
|
|
@ -774,8 +774,8 @@ alignment_common:
|
|||
program_check_common:
|
||||
EXCEPTION_PROLOG_COMMON(0x700, PACA_EXGEN)
|
||||
bl .save_nvgprs
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
DISABLE_INTS
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
bl .program_check_exception
|
||||
b .ret_from_except
|
||||
|
||||
|
|
|
@ -11,6 +11,7 @@
|
|||
|
||||
#include <linux/tracehook.h>
|
||||
#include <linux/signal.h>
|
||||
#include <linux/key.h>
|
||||
#include <asm/hw_breakpoint.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/unistd.h>
|
||||
|
@ -113,8 +114,9 @@ static void check_syscall_restart(struct pt_regs *regs, struct k_sigaction *ka,
|
|||
}
|
||||
}
|
||||
|
||||
static int do_signal_pending(sigset_t *oldset, struct pt_regs *regs)
|
||||
static int do_signal(struct pt_regs *regs)
|
||||
{
|
||||
sigset_t *oldset;
|
||||
siginfo_t info;
|
||||
int signr;
|
||||
struct k_sigaction ka;
|
||||
|
@ -123,7 +125,7 @@ static int do_signal_pending(sigset_t *oldset, struct pt_regs *regs)
|
|||
|
||||
if (current_thread_info()->local_flags & _TLF_RESTORE_SIGMASK)
|
||||
oldset = ¤t->saved_sigmask;
|
||||
else if (!oldset)
|
||||
else
|
||||
oldset = ¤t->blocked;
|
||||
|
||||
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
||||
|
@ -191,14 +193,16 @@ static int do_signal_pending(sigset_t *oldset, struct pt_regs *regs)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void do_signal(struct pt_regs *regs, unsigned long thread_info_flags)
|
||||
void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
|
||||
{
|
||||
if (thread_info_flags & _TIF_SIGPENDING)
|
||||
do_signal_pending(NULL, regs);
|
||||
do_signal(regs);
|
||||
|
||||
if (thread_info_flags & _TIF_NOTIFY_RESUME) {
|
||||
clear_thread_flag(TIF_NOTIFY_RESUME);
|
||||
tracehook_notify_resume(regs);
|
||||
if (current->replacement_session_keyring)
|
||||
key_replace_session_keyring();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
|
||||
|
||||
extern void do_signal(struct pt_regs *regs, unsigned long thread_info_flags);
|
||||
extern void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags);
|
||||
|
||||
extern void __user * get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
|
||||
size_t frame_size, int is_32);
|
||||
|
|
|
@ -71,7 +71,7 @@ int __devinit smp_a2_kick_cpu(int nr)
|
|||
|
||||
static int __init smp_a2_probe(void)
|
||||
{
|
||||
return cpus_weight(cpu_possible_map);
|
||||
return num_possible_cpus();
|
||||
}
|
||||
|
||||
static struct smp_ops_t a2_smp_ops = {
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
config CPU_IDLE
|
||||
bool "CPU idle PM support"
|
||||
default ACPI
|
||||
default y if ACPI || PPC_PSERIES
|
||||
help
|
||||
CPU idle is a generic framework for supporting software-controlled
|
||||
idle processor power management. It includes modular cross-platform
|
||||
|
|
|
@ -193,6 +193,9 @@ int exynos_drm_subdrv_register(struct exynos_drm_subdrv *subdrv)
|
|||
return err;
|
||||
}
|
||||
|
||||
/* setup possible_clones. */
|
||||
exynos_drm_encoder_setup(drm_dev);
|
||||
|
||||
/*
|
||||
* if any specific driver such as fimd or hdmi driver called
|
||||
* exynos_drm_subdrv_register() later than drm_load(),
|
||||
|
|
|
@ -307,9 +307,6 @@ static int exynos_drm_crtc_page_flip(struct drm_crtc *crtc,
|
|||
*/
|
||||
event->pipe = exynos_crtc->pipe;
|
||||
|
||||
list_add_tail(&event->base.link,
|
||||
&dev_priv->pageflip_event_list);
|
||||
|
||||
ret = drm_vblank_get(dev, exynos_crtc->pipe);
|
||||
if (ret) {
|
||||
DRM_DEBUG("failed to acquire vblank counter\n");
|
||||
|
@ -318,6 +315,9 @@ static int exynos_drm_crtc_page_flip(struct drm_crtc *crtc,
|
|||
goto out;
|
||||
}
|
||||
|
||||
list_add_tail(&event->base.link,
|
||||
&dev_priv->pageflip_event_list);
|
||||
|
||||
crtc->fb = fb;
|
||||
ret = exynos_drm_crtc_update(crtc);
|
||||
if (ret) {
|
||||
|
|
|
@ -33,6 +33,7 @@
|
|||
|
||||
#include "exynos_drm_drv.h"
|
||||
#include "exynos_drm_crtc.h"
|
||||
#include "exynos_drm_encoder.h"
|
||||
#include "exynos_drm_fbdev.h"
|
||||
#include "exynos_drm_fb.h"
|
||||
#include "exynos_drm_gem.h"
|
||||
|
@ -99,6 +100,9 @@ static int exynos_drm_load(struct drm_device *dev, unsigned long flags)
|
|||
if (ret)
|
||||
goto err_vblank;
|
||||
|
||||
/* setup possible_clones. */
|
||||
exynos_drm_encoder_setup(dev);
|
||||
|
||||
/*
|
||||
* create and configure fb helper and also exynos specific
|
||||
* fbdev object.
|
||||
|
@ -141,16 +145,21 @@ static int exynos_drm_unload(struct drm_device *dev)
|
|||
}
|
||||
|
||||
static void exynos_drm_preclose(struct drm_device *dev,
|
||||
struct drm_file *file_priv)
|
||||
struct drm_file *file)
|
||||
{
|
||||
struct exynos_drm_private *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG_DRIVER("%s\n", __FILE__);
|
||||
|
||||
/*
|
||||
* drm framework frees all events at release time,
|
||||
* so private event list should be cleared.
|
||||
*/
|
||||
if (!list_empty(&dev_priv->pageflip_event_list))
|
||||
INIT_LIST_HEAD(&dev_priv->pageflip_event_list);
|
||||
}
|
||||
|
||||
static void exynos_drm_postclose(struct drm_device *dev, struct drm_file *file)
|
||||
{
|
||||
DRM_DEBUG_DRIVER("%s\n", __FILE__);
|
||||
|
||||
if (!file->driver_priv)
|
||||
return;
|
||||
|
||||
kfree(file->driver_priv);
|
||||
file->driver_priv = NULL;
|
||||
}
|
||||
|
||||
static void exynos_drm_lastclose(struct drm_device *dev)
|
||||
|
@ -195,6 +204,7 @@ static struct drm_driver exynos_drm_driver = {
|
|||
.unload = exynos_drm_unload,
|
||||
.preclose = exynos_drm_preclose,
|
||||
.lastclose = exynos_drm_lastclose,
|
||||
.postclose = exynos_drm_postclose,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.enable_vblank = exynos_drm_crtc_enable_vblank,
|
||||
.disable_vblank = exynos_drm_crtc_disable_vblank,
|
||||
|
|
|
@ -195,6 +195,40 @@ static struct drm_encoder_funcs exynos_encoder_funcs = {
|
|||
.destroy = exynos_drm_encoder_destroy,
|
||||
};
|
||||
|
||||
static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
|
||||
{
|
||||
struct drm_encoder *clone;
|
||||
struct drm_device *dev = encoder->dev;
|
||||
struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
|
||||
struct exynos_drm_display_ops *display_ops =
|
||||
exynos_encoder->manager->display_ops;
|
||||
unsigned int clone_mask = 0;
|
||||
int cnt = 0;
|
||||
|
||||
list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
|
||||
switch (display_ops->type) {
|
||||
case EXYNOS_DISPLAY_TYPE_LCD:
|
||||
case EXYNOS_DISPLAY_TYPE_HDMI:
|
||||
clone_mask |= (1 << (cnt++));
|
||||
break;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return clone_mask;
|
||||
}
|
||||
|
||||
void exynos_drm_encoder_setup(struct drm_device *dev)
|
||||
{
|
||||
struct drm_encoder *encoder;
|
||||
|
||||
DRM_DEBUG_KMS("%s\n", __FILE__);
|
||||
|
||||
list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
|
||||
encoder->possible_clones = exynos_drm_encoder_clones(encoder);
|
||||
}
|
||||
|
||||
struct drm_encoder *
|
||||
exynos_drm_encoder_create(struct drm_device *dev,
|
||||
struct exynos_drm_manager *manager,
|
||||
|
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
struct exynos_drm_manager;
|
||||
|
||||
void exynos_drm_encoder_setup(struct drm_device *dev);
|
||||
struct drm_encoder *exynos_drm_encoder_create(struct drm_device *dev,
|
||||
struct exynos_drm_manager *mgr,
|
||||
unsigned int possible_crtcs);
|
||||
|
|
|
@ -195,66 +195,6 @@ static int exynos_drm_fbdev_create(struct drm_fb_helper *helper,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static bool
|
||||
exynos_drm_fbdev_is_samefb(struct drm_framebuffer *fb,
|
||||
struct drm_fb_helper_surface_size *sizes)
|
||||
{
|
||||
if (fb->width != sizes->surface_width)
|
||||
return false;
|
||||
if (fb->height != sizes->surface_height)
|
||||
return false;
|
||||
if (fb->bits_per_pixel != sizes->surface_bpp)
|
||||
return false;
|
||||
if (fb->depth != sizes->surface_depth)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int exynos_drm_fbdev_recreate(struct drm_fb_helper *helper,
|
||||
struct drm_fb_helper_surface_size *sizes)
|
||||
{
|
||||
struct drm_device *dev = helper->dev;
|
||||
struct exynos_drm_fbdev *exynos_fbdev = to_exynos_fbdev(helper);
|
||||
struct exynos_drm_gem_obj *exynos_gem_obj;
|
||||
struct drm_framebuffer *fb = helper->fb;
|
||||
struct drm_mode_fb_cmd2 mode_cmd = { 0 };
|
||||
unsigned long size;
|
||||
|
||||
DRM_DEBUG_KMS("%s\n", __FILE__);
|
||||
|
||||
if (exynos_drm_fbdev_is_samefb(fb, sizes))
|
||||
return 0;
|
||||
|
||||
mode_cmd.width = sizes->surface_width;
|
||||
mode_cmd.height = sizes->surface_height;
|
||||
mode_cmd.pitches[0] = sizes->surface_width * (sizes->surface_bpp >> 3);
|
||||
mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
|
||||
sizes->surface_depth);
|
||||
|
||||
if (exynos_fbdev->exynos_gem_obj)
|
||||
exynos_drm_gem_destroy(exynos_fbdev->exynos_gem_obj);
|
||||
|
||||
if (fb->funcs->destroy)
|
||||
fb->funcs->destroy(fb);
|
||||
|
||||
size = mode_cmd.pitches[0] * mode_cmd.height;
|
||||
exynos_gem_obj = exynos_drm_gem_create(dev, size);
|
||||
if (IS_ERR(exynos_gem_obj))
|
||||
return PTR_ERR(exynos_gem_obj);
|
||||
|
||||
exynos_fbdev->exynos_gem_obj = exynos_gem_obj;
|
||||
|
||||
helper->fb = exynos_drm_framebuffer_init(dev, &mode_cmd,
|
||||
&exynos_gem_obj->base);
|
||||
if (IS_ERR_OR_NULL(helper->fb)) {
|
||||
DRM_ERROR("failed to create drm framebuffer.\n");
|
||||
return PTR_ERR(helper->fb);
|
||||
}
|
||||
|
||||
return exynos_drm_fbdev_update(helper, helper->fb);
|
||||
}
|
||||
|
||||
static int exynos_drm_fbdev_probe(struct drm_fb_helper *helper,
|
||||
struct drm_fb_helper_surface_size *sizes)
|
||||
{
|
||||
|
@ -262,6 +202,10 @@ static int exynos_drm_fbdev_probe(struct drm_fb_helper *helper,
|
|||
|
||||
DRM_DEBUG_KMS("%s\n", __FILE__);
|
||||
|
||||
/*
|
||||
* with !helper->fb, it means that this funcion is called first time
|
||||
* and after that, the helper->fb would be used as clone mode.
|
||||
*/
|
||||
if (!helper->fb) {
|
||||
ret = exynos_drm_fbdev_create(helper, sizes);
|
||||
if (ret < 0) {
|
||||
|
@ -274,12 +218,6 @@ static int exynos_drm_fbdev_probe(struct drm_fb_helper *helper,
|
|||
* because register_framebuffer() should be called.
|
||||
*/
|
||||
ret = 1;
|
||||
} else {
|
||||
ret = exynos_drm_fbdev_recreate(helper, sizes);
|
||||
if (ret < 0) {
|
||||
DRM_ERROR("failed to reconfigure fbdev\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -604,7 +604,12 @@ static void fimd_finish_pageflip(struct drm_device *drm_dev, int crtc)
|
|||
}
|
||||
|
||||
if (is_checked) {
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
/*
|
||||
* call drm_vblank_put only in case that drm_vblank_get was
|
||||
* called.
|
||||
*/
|
||||
if (atomic_read(&drm_dev->vblank_refcount[crtc]) > 0)
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
|
||||
/*
|
||||
* don't off vblank if vblank_disable_allowed is 1,
|
||||
|
|
|
@ -712,7 +712,12 @@ static void mixer_finish_pageflip(struct drm_device *drm_dev, int crtc)
|
|||
}
|
||||
|
||||
if (is_checked)
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
/*
|
||||
* call drm_vblank_put only in case that drm_vblank_get was
|
||||
* called.
|
||||
*/
|
||||
if (atomic_read(&drm_dev->vblank_refcount[crtc]) > 0)
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
|
||||
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
||||
}
|
||||
|
@ -779,15 +784,15 @@ static void mixer_win_reset(struct mixer_context *ctx)
|
|||
mixer_reg_writemask(res, MXR_STATUS, MXR_STATUS_16_BURST,
|
||||
MXR_STATUS_BURST_MASK);
|
||||
|
||||
/* setting default layer priority: layer1 > video > layer0
|
||||
/* setting default layer priority: layer1 > layer0 > video
|
||||
* because typical usage scenario would be
|
||||
* layer1 - OSD
|
||||
* layer0 - framebuffer
|
||||
* video - video overlay
|
||||
* layer1 - OSD
|
||||
*/
|
||||
val = MXR_LAYER_CFG_GRP0_VAL(1);
|
||||
val |= MXR_LAYER_CFG_VP_VAL(2);
|
||||
val |= MXR_LAYER_CFG_GRP1_VAL(3);
|
||||
val = MXR_LAYER_CFG_GRP1_VAL(3);
|
||||
val |= MXR_LAYER_CFG_GRP0_VAL(2);
|
||||
val |= MXR_LAYER_CFG_VP_VAL(1);
|
||||
mixer_reg_write(res, MXR_LAYER_CFG, val);
|
||||
|
||||
/* setting background color */
|
||||
|
@ -1044,7 +1049,7 @@ static int mixer_remove(struct platform_device *pdev)
|
|||
platform_get_drvdata(pdev);
|
||||
struct mixer_context *ctx = (struct mixer_context *)drm_hdmi_ctx->ctx;
|
||||
|
||||
dev_info(dev, "remove sucessful\n");
|
||||
dev_info(dev, "remove successful\n");
|
||||
|
||||
mixer_resource_poweroff(ctx);
|
||||
mixer_resources_cleanup(ctx);
|
||||
|
|
|
@ -3028,6 +3028,20 @@
|
|||
#define DISP_TILE_SURFACE_SWIZZLING (1<<13)
|
||||
#define DISP_FBC_WM_DIS (1<<15)
|
||||
|
||||
/* GEN7 chicken */
|
||||
#define GEN7_COMMON_SLICE_CHICKEN1 0x7010
|
||||
# define GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC ((1<<10) | (1<<26))
|
||||
|
||||
#define GEN7_L3CNTLREG1 0xB01C
|
||||
#define GEN7_WA_FOR_GEN7_L3_CONTROL 0x3C4FFF8C
|
||||
|
||||
#define GEN7_L3_CHICKEN_MODE_REGISTER 0xB030
|
||||
#define GEN7_WA_L3_CHICKEN_MODE 0x20000000
|
||||
|
||||
/* WaCatErrorRejectionIssue */
|
||||
#define GEN7_SQ_CHICKEN_MBCUNIT_CONFIG 0x9030
|
||||
#define GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB (1<<11)
|
||||
|
||||
/* PCH */
|
||||
|
||||
/* south display engine interrupt */
|
||||
|
@ -3618,6 +3632,7 @@
|
|||
#define GT_FIFO_NUM_RESERVED_ENTRIES 20
|
||||
|
||||
#define GEN6_UCGCTL2 0x9404
|
||||
# define GEN6_RCZUNIT_CLOCK_GATE_DISABLE (1 << 13)
|
||||
# define GEN6_RCPBUNIT_CLOCK_GATE_DISABLE (1 << 12)
|
||||
# define GEN6_RCCUNIT_CLOCK_GATE_DISABLE (1 << 11)
|
||||
|
||||
|
|
|
@ -8184,8 +8184,8 @@ void gen6_enable_rps(struct drm_i915_private *dev_priv)
|
|||
I915_WRITE(GEN6_RC6pp_THRESHOLD, 64000); /* unused */
|
||||
|
||||
if (intel_enable_rc6(dev_priv->dev))
|
||||
rc6_mask = GEN6_RC_CTL_RC6p_ENABLE |
|
||||
GEN6_RC_CTL_RC6_ENABLE;
|
||||
rc6_mask = GEN6_RC_CTL_RC6_ENABLE |
|
||||
(IS_GEN7(dev_priv->dev)) ? GEN6_RC_CTL_RC6p_ENABLE : 0;
|
||||
|
||||
I915_WRITE(GEN6_RC_CONTROL,
|
||||
rc6_mask |
|
||||
|
@ -8463,12 +8463,32 @@ static void ivybridge_init_clock_gating(struct drm_device *dev)
|
|||
I915_WRITE(WM2_LP_ILK, 0);
|
||||
I915_WRITE(WM1_LP_ILK, 0);
|
||||
|
||||
/* According to the spec, bit 13 (RCZUNIT) must be set on IVB.
|
||||
* This implements the WaDisableRCZUnitClockGating workaround.
|
||||
*/
|
||||
I915_WRITE(GEN6_UCGCTL2, GEN6_RCZUNIT_CLOCK_GATE_DISABLE);
|
||||
|
||||
I915_WRITE(ILK_DSPCLK_GATE, IVB_VRHUNIT_CLK_GATE);
|
||||
|
||||
I915_WRITE(IVB_CHICKEN3,
|
||||
CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE |
|
||||
CHICKEN3_DGMG_DONE_FIX_DISABLE);
|
||||
|
||||
/* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */
|
||||
I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1,
|
||||
GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC);
|
||||
|
||||
/* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */
|
||||
I915_WRITE(GEN7_L3CNTLREG1,
|
||||
GEN7_WA_FOR_GEN7_L3_CONTROL);
|
||||
I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER,
|
||||
GEN7_WA_L3_CHICKEN_MODE);
|
||||
|
||||
/* This is required by WaCatErrorRejectionIssue */
|
||||
I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG,
|
||||
I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) |
|
||||
GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB);
|
||||
|
||||
for_each_pipe(pipe) {
|
||||
I915_WRITE(DSPCNTR(pipe),
|
||||
I915_READ(DSPCNTR(pipe)) |
|
||||
|
|
|
@ -3223,6 +3223,7 @@ int evergreen_resume(struct radeon_device *rdev)
|
|||
r = evergreen_startup(rdev);
|
||||
if (r) {
|
||||
DRM_ERROR("evergreen startup failed on resume\n");
|
||||
rdev->accel_working = false;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
|
@ -1547,6 +1547,7 @@ int cayman_resume(struct radeon_device *rdev)
|
|||
r = cayman_startup(rdev);
|
||||
if (r) {
|
||||
DRM_ERROR("cayman startup failed on resume\n");
|
||||
rdev->accel_working = false;
|
||||
return r;
|
||||
}
|
||||
return r;
|
||||
|
|
|
@ -3928,6 +3928,8 @@ static int r100_startup(struct radeon_device *rdev)
|
|||
|
||||
int r100_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
if (rdev->flags & RADEON_IS_PCI)
|
||||
r100_pci_gart_disable(rdev);
|
||||
|
@ -3947,7 +3949,11 @@ int r100_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return r100_startup(rdev);
|
||||
r = r100_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int r100_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -1431,6 +1431,8 @@ static int r300_startup(struct radeon_device *rdev)
|
|||
|
||||
int r300_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
if (rdev->flags & RADEON_IS_PCIE)
|
||||
rv370_pcie_gart_disable(rdev);
|
||||
|
@ -1452,7 +1454,11 @@ int r300_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return r300_startup(rdev);
|
||||
r = r300_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int r300_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -291,6 +291,8 @@ static int r420_startup(struct radeon_device *rdev)
|
|||
|
||||
int r420_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
if (rdev->flags & RADEON_IS_PCIE)
|
||||
rv370_pcie_gart_disable(rdev);
|
||||
|
@ -316,7 +318,11 @@ int r420_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return r420_startup(rdev);
|
||||
r = r420_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int r420_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -218,6 +218,8 @@ static int r520_startup(struct radeon_device *rdev)
|
|||
|
||||
int r520_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
if (rdev->flags & RADEON_IS_PCIE)
|
||||
rv370_pcie_gart_disable(rdev);
|
||||
|
@ -237,7 +239,11 @@ int r520_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return r520_startup(rdev);
|
||||
r = r520_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int r520_init(struct radeon_device *rdev)
|
||||
|
|
|
@ -2529,6 +2529,7 @@ int r600_resume(struct radeon_device *rdev)
|
|||
r = r600_startup(rdev);
|
||||
if (r) {
|
||||
DRM_ERROR("r600 startup failed on resume\n");
|
||||
rdev->accel_working = false;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
|
@ -3020,6 +3020,9 @@ radeon_atombios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on)
|
|||
struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
|
||||
uint32_t bios_2_scratch;
|
||||
|
||||
if (ASIC_IS_DCE4(rdev))
|
||||
return;
|
||||
|
||||
if (rdev->family >= CHIP_R600)
|
||||
bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
|
||||
else
|
||||
|
|
|
@ -453,6 +453,10 @@ int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
|
|||
int r;
|
||||
|
||||
radeon_mutex_lock(&rdev->cs_mutex);
|
||||
if (!rdev->accel_working) {
|
||||
radeon_mutex_unlock(&rdev->cs_mutex);
|
||||
return -EBUSY;
|
||||
}
|
||||
/* initialize parser */
|
||||
memset(&parser, 0, sizeof(struct radeon_cs_parser));
|
||||
parser.filp = filp;
|
||||
|
|
|
@ -500,8 +500,11 @@ static char radeon_debugfs_ib_names[RADEON_IB_POOL_SIZE][32];
|
|||
int radeon_debugfs_ring_init(struct radeon_device *rdev)
|
||||
{
|
||||
#if defined(CONFIG_DEBUG_FS)
|
||||
return radeon_debugfs_add_files(rdev, radeon_debugfs_ring_info_list,
|
||||
ARRAY_SIZE(radeon_debugfs_ring_info_list));
|
||||
if (rdev->family >= CHIP_CAYMAN)
|
||||
return radeon_debugfs_add_files(rdev, radeon_debugfs_ring_info_list,
|
||||
ARRAY_SIZE(radeon_debugfs_ring_info_list));
|
||||
else
|
||||
return radeon_debugfs_add_files(rdev, radeon_debugfs_ring_info_list, 1);
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
|
|
|
@ -442,6 +442,8 @@ static int rs400_startup(struct radeon_device *rdev)
|
|||
|
||||
int rs400_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
rs400_gart_disable(rdev);
|
||||
/* Resume clock before doing reset */
|
||||
|
@ -462,7 +464,11 @@ int rs400_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return rs400_startup(rdev);
|
||||
r = rs400_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int rs400_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -876,6 +876,8 @@ static int rs600_startup(struct radeon_device *rdev)
|
|||
|
||||
int rs600_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
rs600_gart_disable(rdev);
|
||||
/* Resume clock before doing reset */
|
||||
|
@ -894,7 +896,11 @@ int rs600_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return rs600_startup(rdev);
|
||||
r = rs600_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int rs600_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -659,6 +659,8 @@ static int rs690_startup(struct radeon_device *rdev)
|
|||
|
||||
int rs690_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
rs400_gart_disable(rdev);
|
||||
/* Resume clock before doing reset */
|
||||
|
@ -677,7 +679,11 @@ int rs690_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return rs690_startup(rdev);
|
||||
r = rs690_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int rs690_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -424,6 +424,8 @@ static int rv515_startup(struct radeon_device *rdev)
|
|||
|
||||
int rv515_resume(struct radeon_device *rdev)
|
||||
{
|
||||
int r;
|
||||
|
||||
/* Make sur GART are not working */
|
||||
if (rdev->flags & RADEON_IS_PCIE)
|
||||
rv370_pcie_gart_disable(rdev);
|
||||
|
@ -443,7 +445,11 @@ int rv515_resume(struct radeon_device *rdev)
|
|||
radeon_surface_init(rdev);
|
||||
|
||||
rdev->accel_working = true;
|
||||
return rv515_startup(rdev);
|
||||
r = rv515_startup(rdev);
|
||||
if (r) {
|
||||
rdev->accel_working = false;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int rv515_suspend(struct radeon_device *rdev)
|
||||
|
|
|
@ -1139,6 +1139,7 @@ int rv770_resume(struct radeon_device *rdev)
|
|||
r = rv770_startup(rdev);
|
||||
if (r) {
|
||||
DRM_ERROR("r600 startup failed on resume\n");
|
||||
rdev->accel_working = false;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
|
@ -187,7 +187,10 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
|||
return -ENODEV;
|
||||
dev->current_state = PCI_D0;
|
||||
|
||||
if (!dev->irq) {
|
||||
/* The xHCI driver supports MSI and MSI-X,
|
||||
* so don't fail if the BIOS doesn't provide a legacy IRQ.
|
||||
*/
|
||||
if (!dev->irq && (driver->flags & HCD_MASK) != HCD_USB3) {
|
||||
dev_err(&dev->dev,
|
||||
"Found HC with no IRQ. Check BIOS/PCI %s setup!\n",
|
||||
pci_name(dev));
|
||||
|
|
|
@ -2447,8 +2447,10 @@ int usb_add_hcd(struct usb_hcd *hcd,
|
|||
&& device_can_wakeup(&hcd->self.root_hub->dev))
|
||||
dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
|
||||
|
||||
/* enable irqs just before we start the controller */
|
||||
if (usb_hcd_is_primary_hcd(hcd)) {
|
||||
/* enable irqs just before we start the controller,
|
||||
* if the BIOS provides legacy PCI irqs.
|
||||
*/
|
||||
if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
|
||||
retval = usb_hcd_request_irqs(hcd, irqnum, irqflags);
|
||||
if (retval)
|
||||
goto err_request_irq;
|
||||
|
|
|
@ -705,10 +705,26 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
|
|||
if (type == HUB_INIT3)
|
||||
goto init3;
|
||||
|
||||
/* After a resume, port power should still be on.
|
||||
/* The superspeed hub except for root hub has to use Hub Depth
|
||||
* value as an offset into the route string to locate the bits
|
||||
* it uses to determine the downstream port number. So hub driver
|
||||
* should send a set hub depth request to superspeed hub after
|
||||
* the superspeed hub is set configuration in initialization or
|
||||
* reset procedure.
|
||||
*
|
||||
* After a resume, port power should still be on.
|
||||
* For any other type of activation, turn it on.
|
||||
*/
|
||||
if (type != HUB_RESUME) {
|
||||
if (hdev->parent && hub_is_superspeed(hdev)) {
|
||||
ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
||||
HUB_SET_DEPTH, USB_RT_HUB,
|
||||
hdev->level - 1, 0, NULL, 0,
|
||||
USB_CTRL_SET_TIMEOUT);
|
||||
if (ret < 0)
|
||||
dev_err(hub->intfdev,
|
||||
"set hub depth failed\n");
|
||||
}
|
||||
|
||||
/* Speed up system boot by using a delayed_work for the
|
||||
* hub's initial power-up delays. This is pretty awkward
|
||||
|
@ -987,18 +1003,6 @@ static int hub_configure(struct usb_hub *hub,
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (hub_is_superspeed(hdev) && (hdev->parent != NULL)) {
|
||||
ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
||||
HUB_SET_DEPTH, USB_RT_HUB,
|
||||
hdev->level - 1, 0, NULL, 0,
|
||||
USB_CTRL_SET_TIMEOUT);
|
||||
|
||||
if (ret < 0) {
|
||||
message = "can't set hub depth";
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Request the entire hub descriptor.
|
||||
* hub->descriptor can handle USB_MAXCHILDREN ports,
|
||||
* but the hub can/will return fewer bytes here.
|
||||
|
|
|
@ -872,7 +872,17 @@ static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev)
|
|||
*/
|
||||
if (pdev->vendor == 0x184e) /* vendor Netlogic */
|
||||
return;
|
||||
if (pdev->class != PCI_CLASS_SERIAL_USB_UHCI &&
|
||||
pdev->class != PCI_CLASS_SERIAL_USB_OHCI &&
|
||||
pdev->class != PCI_CLASS_SERIAL_USB_EHCI &&
|
||||
pdev->class != PCI_CLASS_SERIAL_USB_XHCI)
|
||||
return;
|
||||
|
||||
if (pci_enable_device(pdev) < 0) {
|
||||
dev_warn(&pdev->dev, "Can't enable PCI device, "
|
||||
"BIOS handoff failed.\n");
|
||||
return;
|
||||
}
|
||||
if (pdev->class == PCI_CLASS_SERIAL_USB_UHCI)
|
||||
quirk_usb_handoff_uhci(pdev);
|
||||
else if (pdev->class == PCI_CLASS_SERIAL_USB_OHCI)
|
||||
|
@ -881,5 +891,6 @@ static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev)
|
|||
quirk_usb_disable_ehci(pdev);
|
||||
else if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI)
|
||||
quirk_usb_handoff_xhci(pdev);
|
||||
pci_disable_device(pdev);
|
||||
}
|
||||
DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff);
|
||||
|
|
|
@ -93,7 +93,7 @@ static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
|
|||
*/
|
||||
memset(port_removable, 0, sizeof(port_removable));
|
||||
for (i = 0; i < ports; i++) {
|
||||
portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
|
||||
portsc = xhci_readl(xhci, xhci->usb2_ports[i]);
|
||||
/* If a device is removable, PORTSC reports a 0, same as in the
|
||||
* hub descriptor DeviceRemovable bits.
|
||||
*/
|
||||
|
|
|
@ -1126,26 +1126,42 @@ static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
|
|||
}
|
||||
|
||||
/*
|
||||
* Convert bInterval expressed in frames (in 1-255 range) to exponent of
|
||||
* Convert bInterval expressed in microframes (in 1-255 range) to exponent of
|
||||
* microframes, rounded down to nearest power of 2.
|
||||
*/
|
||||
static unsigned int xhci_parse_frame_interval(struct usb_device *udev,
|
||||
struct usb_host_endpoint *ep)
|
||||
static unsigned int xhci_microframes_to_exponent(struct usb_device *udev,
|
||||
struct usb_host_endpoint *ep, unsigned int desc_interval,
|
||||
unsigned int min_exponent, unsigned int max_exponent)
|
||||
{
|
||||
unsigned int interval;
|
||||
|
||||
interval = fls(8 * ep->desc.bInterval) - 1;
|
||||
interval = clamp_val(interval, 3, 10);
|
||||
if ((1 << interval) != 8 * ep->desc.bInterval)
|
||||
interval = fls(desc_interval) - 1;
|
||||
interval = clamp_val(interval, min_exponent, max_exponent);
|
||||
if ((1 << interval) != desc_interval)
|
||||
dev_warn(&udev->dev,
|
||||
"ep %#x - rounding interval to %d microframes, ep desc says %d microframes\n",
|
||||
ep->desc.bEndpointAddress,
|
||||
1 << interval,
|
||||
8 * ep->desc.bInterval);
|
||||
desc_interval);
|
||||
|
||||
return interval;
|
||||
}
|
||||
|
||||
static unsigned int xhci_parse_microframe_interval(struct usb_device *udev,
|
||||
struct usb_host_endpoint *ep)
|
||||
{
|
||||
return xhci_microframes_to_exponent(udev, ep,
|
||||
ep->desc.bInterval, 0, 15);
|
||||
}
|
||||
|
||||
|
||||
static unsigned int xhci_parse_frame_interval(struct usb_device *udev,
|
||||
struct usb_host_endpoint *ep)
|
||||
{
|
||||
return xhci_microframes_to_exponent(udev, ep,
|
||||
ep->desc.bInterval * 8, 3, 10);
|
||||
}
|
||||
|
||||
/* Return the polling or NAK interval.
|
||||
*
|
||||
* The polling interval is expressed in "microframes". If xHCI's Interval field
|
||||
|
@ -1164,7 +1180,7 @@ static unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
|
|||
/* Max NAK rate */
|
||||
if (usb_endpoint_xfer_control(&ep->desc) ||
|
||||
usb_endpoint_xfer_bulk(&ep->desc)) {
|
||||
interval = ep->desc.bInterval;
|
||||
interval = xhci_parse_microframe_interval(udev, ep);
|
||||
break;
|
||||
}
|
||||
/* Fall through - SS and HS isoc/int have same decoding */
|
||||
|
|
|
@ -352,6 +352,11 @@ static int xhci_try_enable_msi(struct usb_hcd *hcd)
|
|||
/* hcd->irq is -1, we have MSI */
|
||||
return 0;
|
||||
|
||||
if (!pdev->irq) {
|
||||
xhci_err(xhci, "No msi-x/msi found and no IRQ in BIOS\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* fall back to legacy interrupt*/
|
||||
ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
|
||||
hcd->irq_descr, hcd);
|
||||
|
|
|
@ -136,6 +136,8 @@ static const struct usb_device_id id_table[] = {
|
|||
{ USB_DEVICE(0x16DC, 0x0011) }, /* W-IE-NE-R Plein & Baus GmbH RCM Remote Control for MARATON Power Supply */
|
||||
{ USB_DEVICE(0x16DC, 0x0012) }, /* W-IE-NE-R Plein & Baus GmbH MPOD Multi Channel Power Supply */
|
||||
{ USB_DEVICE(0x16DC, 0x0015) }, /* W-IE-NE-R Plein & Baus GmbH CML Control, Monitoring and Data Logger */
|
||||
{ USB_DEVICE(0x17A8, 0x0001) }, /* Kamstrup Optical Eye/3-wire */
|
||||
{ USB_DEVICE(0x17A8, 0x0005) }, /* Kamstrup M-Bus Master MultiPort 250D */
|
||||
{ USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
|
||||
{ USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
|
||||
{ USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
|
||||
|
|
|
@ -788,7 +788,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0012, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0013, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0016, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0017, 0xff, 0xff, 0xff),
|
||||
|
@ -803,7 +802,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0024, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0025, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
|
||||
/* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0026, 0xff, 0xff, 0xff) }, */
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0028, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0029, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0030, 0xff, 0xff, 0xff) },
|
||||
|
@ -828,7 +826,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0051, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0052, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
|
||||
/* { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0053, 0xff, 0xff, 0xff) }, */
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0054, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0055, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf1_blacklist },
|
||||
|
@ -836,7 +833,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0057, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0058, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0061, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0062, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0063, 0xff, 0xff, 0xff),
|
||||
|
@ -846,7 +842,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0066, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0067, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0069, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0076, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0077, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0078, 0xff, 0xff, 0xff) },
|
||||
|
@ -865,8 +860,6 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0095, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0096, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0097, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0098, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0099, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0104, 0xff, 0xff, 0xff),
|
||||
.driver_info = (kernel_ulong_t)&net_intf4_blacklist },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0105, 0xff, 0xff, 0xff) },
|
||||
|
@ -887,28 +880,18 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0143, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0144, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0145, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0146, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0147, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0148, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0149, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0150, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0151, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0152, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0153, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0155, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0156, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0157, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0158, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0159, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0160, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0161, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0162, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0164, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0165, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0168, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0170, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0176, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0178, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1008, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1010, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1012, 0xff, 0xff, 0xff) },
|
||||
|
@ -1083,127 +1066,27 @@ static const struct usb_device_id option_ids[] = {
|
|||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1298, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1299, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1300, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1401, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1402, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1403, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1404, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1405, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1406, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1407, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1408, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1409, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1410, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1411, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1412, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1413, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1414, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1415, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1416, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1417, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1418, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1419, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1420, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1421, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1422, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1423, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1424, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1425, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1426, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1427, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1428, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1429, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1430, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1431, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1432, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1433, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1434, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1435, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1436, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1437, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1438, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1439, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1440, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1441, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1442, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1443, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1444, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1445, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1446, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1447, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1448, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1449, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1450, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1451, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1452, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1453, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1454, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1455, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1456, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1457, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1458, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1459, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1460, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1461, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1462, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1463, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1464, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1465, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1466, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1467, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1468, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1469, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1470, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1471, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1472, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1473, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1474, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1475, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1476, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1477, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1478, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1479, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1480, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1481, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1482, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1483, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1484, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1485, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1486, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1487, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1488, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1489, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1490, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1491, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1492, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1493, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1494, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1495, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1496, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1497, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1498, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1499, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1500, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1501, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1502, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1503, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1504, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1505, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1506, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1507, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1508, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1509, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1510, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
|
||||
0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
|
||||
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) }, /* ZTE CDMA products */
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0027, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0060, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0094, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0133, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
|
||||
0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0147, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0152, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0168, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0170, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0176, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0178, 0xff, 0xff, 0xff) },
|
||||
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
|
||||
|
|
|
@ -165,7 +165,7 @@ static unsigned int product_5052_count;
|
|||
/* the array dimension is the number of default entries plus */
|
||||
/* TI_EXTRA_VID_PID_COUNT user defined entries plus 1 terminating */
|
||||
/* null entry */
|
||||
static struct usb_device_id ti_id_table_3410[13+TI_EXTRA_VID_PID_COUNT+1] = {
|
||||
static struct usb_device_id ti_id_table_3410[14+TI_EXTRA_VID_PID_COUNT+1] = {
|
||||
{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
|
||||
{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
|
||||
{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
|
||||
|
@ -179,6 +179,7 @@ static struct usb_device_id ti_id_table_3410[13+TI_EXTRA_VID_PID_COUNT+1] = {
|
|||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_4543_PRODUCT_ID) },
|
||||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
|
||||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
|
||||
{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_PRODUCT_ID) },
|
||||
};
|
||||
|
||||
static struct usb_device_id ti_id_table_5052[5+TI_EXTRA_VID_PID_COUNT+1] = {
|
||||
|
@ -188,7 +189,7 @@ static struct usb_device_id ti_id_table_5052[5+TI_EXTRA_VID_PID_COUNT+1] = {
|
|||
{ USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
|
||||
};
|
||||
|
||||
static struct usb_device_id ti_id_table_combined[17+2*TI_EXTRA_VID_PID_COUNT+1] = {
|
||||
static struct usb_device_id ti_id_table_combined[18+2*TI_EXTRA_VID_PID_COUNT+1] = {
|
||||
{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
|
||||
{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
|
||||
{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
|
||||
|
@ -206,6 +207,7 @@ static struct usb_device_id ti_id_table_combined[17+2*TI_EXTRA_VID_PID_COUNT+1]
|
|||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_4543_PRODUCT_ID) },
|
||||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
|
||||
{ USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
|
||||
{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_PRODUCT_ID) },
|
||||
{ }
|
||||
};
|
||||
|
||||
|
|
|
@ -49,6 +49,10 @@
|
|||
#define MTS_MT9234ZBA_PRODUCT_ID 0xF115
|
||||
#define MTS_MT9234ZBAOLD_PRODUCT_ID 0x0319
|
||||
|
||||
/* Abbott Diabetics vendor and product ids */
|
||||
#define ABBOTT_VENDOR_ID 0x1a61
|
||||
#define ABBOTT_PRODUCT_ID 0x3410
|
||||
|
||||
/* Commands */
|
||||
#define TI_GET_VERSION 0x01
|
||||
#define TI_GET_PORT_STATUS 0x02
|
||||
|
|
|
@ -788,15 +788,19 @@ static void quiesce_and_remove_host(struct us_data *us)
|
|||
struct Scsi_Host *host = us_to_host(us);
|
||||
|
||||
/* If the device is really gone, cut short reset delays */
|
||||
if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
|
||||
if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
|
||||
set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
|
||||
wake_up(&us->delay_wait);
|
||||
}
|
||||
|
||||
/* Prevent SCSI-scanning (if it hasn't started yet)
|
||||
* and wait for the SCSI-scanning thread to stop.
|
||||
/* Prevent SCSI scanning (if it hasn't started yet)
|
||||
* or wait for the SCSI-scanning routine to stop.
|
||||
*/
|
||||
set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
|
||||
wake_up(&us->delay_wait);
|
||||
wait_for_completion(&us->scanning_done);
|
||||
cancel_delayed_work_sync(&us->scan_dwork);
|
||||
|
||||
/* Balance autopm calls if scanning was cancelled */
|
||||
if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
|
||||
usb_autopm_put_interface_no_suspend(us->pusb_intf);
|
||||
|
||||
/* Removing the host will perform an orderly shutdown: caches
|
||||
* synchronized, disks spun down, etc.
|
||||
|
@ -823,53 +827,28 @@ static void release_everything(struct us_data *us)
|
|||
scsi_host_put(us_to_host(us));
|
||||
}
|
||||
|
||||
/* Thread to carry out delayed SCSI-device scanning */
|
||||
static int usb_stor_scan_thread(void * __us)
|
||||
/* Delayed-work routine to carry out SCSI-device scanning */
|
||||
static void usb_stor_scan_dwork(struct work_struct *work)
|
||||
{
|
||||
struct us_data *us = (struct us_data *)__us;
|
||||
struct us_data *us = container_of(work, struct us_data,
|
||||
scan_dwork.work);
|
||||
struct device *dev = &us->pusb_intf->dev;
|
||||
|
||||
dev_dbg(dev, "device found\n");
|
||||
dev_dbg(dev, "starting scan\n");
|
||||
|
||||
set_freezable();
|
||||
|
||||
/*
|
||||
* Wait for the timeout to expire or for a disconnect
|
||||
*
|
||||
* We can't freeze in this thread or we risk causing khubd to
|
||||
* fail to freeze, but we can't be non-freezable either. Nor can
|
||||
* khubd freeze while waiting for scanning to complete as it may
|
||||
* hold the device lock, causing a hang when suspending devices.
|
||||
* So instead of using wait_event_freezable(), explicitly test
|
||||
* for (DONT_SCAN || freezing) in interruptible wait and proceed
|
||||
* if any of DONT_SCAN, freezing or timeout has happened.
|
||||
*/
|
||||
if (delay_use > 0) {
|
||||
dev_dbg(dev, "waiting for device to settle "
|
||||
"before scanning\n");
|
||||
wait_event_interruptible_timeout(us->delay_wait,
|
||||
test_bit(US_FLIDX_DONT_SCAN, &us->dflags) ||
|
||||
freezing(current), delay_use * HZ);
|
||||
/* For bulk-only devices, determine the max LUN value */
|
||||
if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
|
||||
mutex_lock(&us->dev_mutex);
|
||||
us->max_lun = usb_stor_Bulk_max_lun(us);
|
||||
mutex_unlock(&us->dev_mutex);
|
||||
}
|
||||
scsi_scan_host(us_to_host(us));
|
||||
dev_dbg(dev, "scan complete\n");
|
||||
|
||||
/* If the device is still connected, perform the scanning */
|
||||
if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
|
||||
|
||||
/* For bulk-only devices, determine the max LUN value */
|
||||
if (us->protocol == USB_PR_BULK &&
|
||||
!(us->fflags & US_FL_SINGLE_LUN)) {
|
||||
mutex_lock(&us->dev_mutex);
|
||||
us->max_lun = usb_stor_Bulk_max_lun(us);
|
||||
mutex_unlock(&us->dev_mutex);
|
||||
}
|
||||
scsi_scan_host(us_to_host(us));
|
||||
dev_dbg(dev, "scan complete\n");
|
||||
|
||||
/* Should we unbind if no devices were detected? */
|
||||
}
|
||||
/* Should we unbind if no devices were detected? */
|
||||
|
||||
usb_autopm_put_interface(us->pusb_intf);
|
||||
complete_and_exit(&us->scanning_done, 0);
|
||||
clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
|
||||
}
|
||||
|
||||
static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
|
||||
|
@ -916,7 +895,7 @@ int usb_stor_probe1(struct us_data **pus,
|
|||
init_completion(&us->cmnd_ready);
|
||||
init_completion(&(us->notify));
|
||||
init_waitqueue_head(&us->delay_wait);
|
||||
init_completion(&us->scanning_done);
|
||||
INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
|
||||
|
||||
/* Associate the us_data structure with the USB device */
|
||||
result = associate_dev(us, intf);
|
||||
|
@ -947,7 +926,6 @@ EXPORT_SYMBOL_GPL(usb_stor_probe1);
|
|||
/* Second part of general USB mass-storage probing */
|
||||
int usb_stor_probe2(struct us_data *us)
|
||||
{
|
||||
struct task_struct *th;
|
||||
int result;
|
||||
struct device *dev = &us->pusb_intf->dev;
|
||||
|
||||
|
@ -988,20 +966,14 @@ int usb_stor_probe2(struct us_data *us)
|
|||
goto BadDevice;
|
||||
}
|
||||
|
||||
/* Start up the thread for delayed SCSI-device scanning */
|
||||
th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
|
||||
if (IS_ERR(th)) {
|
||||
dev_warn(dev,
|
||||
"Unable to start the device-scanning thread\n");
|
||||
complete(&us->scanning_done);
|
||||
quiesce_and_remove_host(us);
|
||||
result = PTR_ERR(th);
|
||||
goto BadDevice;
|
||||
}
|
||||
|
||||
/* Submit the delayed_work for SCSI-device scanning */
|
||||
usb_autopm_get_interface_no_resume(us->pusb_intf);
|
||||
wake_up_process(th);
|
||||
set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
|
||||
|
||||
if (delay_use > 0)
|
||||
dev_dbg(dev, "waiting for device to settle before scanning\n");
|
||||
queue_delayed_work(system_freezable_wq, &us->scan_dwork,
|
||||
delay_use * HZ);
|
||||
return 0;
|
||||
|
||||
/* We come here if there are any problems */
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#include <linux/blkdev.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <scsi/scsi_host.h>
|
||||
|
||||
struct us_data;
|
||||
|
@ -72,7 +73,7 @@ struct us_unusual_dev {
|
|||
#define US_FLIDX_DISCONNECTING 3 /* disconnect in progress */
|
||||
#define US_FLIDX_RESETTING 4 /* device reset in progress */
|
||||
#define US_FLIDX_TIMED_OUT 5 /* SCSI midlayer timed out */
|
||||
#define US_FLIDX_DONT_SCAN 6 /* don't scan (disconnect) */
|
||||
#define US_FLIDX_SCAN_PENDING 6 /* scanning not yet done */
|
||||
#define US_FLIDX_REDO_READ10 7 /* redo READ(10) command */
|
||||
#define US_FLIDX_READ10_WORKED 8 /* previous READ(10) succeeded */
|
||||
|
||||
|
@ -147,8 +148,8 @@ struct us_data {
|
|||
/* mutual exclusion and synchronization structures */
|
||||
struct completion cmnd_ready; /* to sleep thread on */
|
||||
struct completion notify; /* thread begin/end */
|
||||
wait_queue_head_t delay_wait; /* wait during scan, reset */
|
||||
struct completion scanning_done; /* wait for scan thread */
|
||||
wait_queue_head_t delay_wait; /* wait during reset */
|
||||
struct delayed_work scan_dwork; /* for async scanning */
|
||||
|
||||
/* subdriver information */
|
||||
void *extra; /* Any extra data */
|
||||
|
|
|
@ -3575,8 +3575,8 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
|
|||
}
|
||||
if (npages > 1) {
|
||||
/* for decoding across pages */
|
||||
args.acl_scratch = alloc_page(GFP_KERNEL);
|
||||
if (!args.acl_scratch)
|
||||
res.acl_scratch = alloc_page(GFP_KERNEL);
|
||||
if (!res.acl_scratch)
|
||||
goto out_free;
|
||||
}
|
||||
args.acl_len = npages * PAGE_SIZE;
|
||||
|
@ -3612,8 +3612,8 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
|
|||
for (i = 0; i < npages; i++)
|
||||
if (pages[i])
|
||||
__free_page(pages[i]);
|
||||
if (args.acl_scratch)
|
||||
__free_page(args.acl_scratch);
|
||||
if (res.acl_scratch)
|
||||
__free_page(res.acl_scratch);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -4883,8 +4883,10 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
|
|||
clp->cl_rpcclient->cl_auth->au_flavor);
|
||||
|
||||
res.server_scope = kzalloc(sizeof(struct server_scope), GFP_KERNEL);
|
||||
if (unlikely(!res.server_scope))
|
||||
return -ENOMEM;
|
||||
if (unlikely(!res.server_scope)) {
|
||||
status = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
|
||||
if (!status)
|
||||
|
@ -4901,12 +4903,13 @@ int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
|
|||
clp->server_scope = NULL;
|
||||
}
|
||||
|
||||
if (!clp->server_scope)
|
||||
if (!clp->server_scope) {
|
||||
clp->server_scope = res.server_scope;
|
||||
else
|
||||
kfree(res.server_scope);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
kfree(res.server_scope);
|
||||
out:
|
||||
dprintk("<-- %s status= %d\n", __func__, status);
|
||||
return status;
|
||||
}
|
||||
|
@ -5008,37 +5011,53 @@ int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
|
|||
return status;
|
||||
}
|
||||
|
||||
static struct nfs4_slot *nfs4_alloc_slots(u32 max_slots, gfp_t gfp_flags)
|
||||
{
|
||||
return kcalloc(max_slots, sizeof(struct nfs4_slot), gfp_flags);
|
||||
}
|
||||
|
||||
static void nfs4_add_and_init_slots(struct nfs4_slot_table *tbl,
|
||||
struct nfs4_slot *new,
|
||||
u32 max_slots,
|
||||
u32 ivalue)
|
||||
{
|
||||
struct nfs4_slot *old = NULL;
|
||||
u32 i;
|
||||
|
||||
spin_lock(&tbl->slot_tbl_lock);
|
||||
if (new) {
|
||||
old = tbl->slots;
|
||||
tbl->slots = new;
|
||||
tbl->max_slots = max_slots;
|
||||
}
|
||||
tbl->highest_used_slotid = -1; /* no slot is currently used */
|
||||
for (i = 0; i < tbl->max_slots; i++)
|
||||
tbl->slots[i].seq_nr = ivalue;
|
||||
spin_unlock(&tbl->slot_tbl_lock);
|
||||
kfree(old);
|
||||
}
|
||||
|
||||
/*
|
||||
* Reset a slot table
|
||||
* (re)Initialise a slot table
|
||||
*/
|
||||
static int nfs4_reset_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs,
|
||||
int ivalue)
|
||||
static int nfs4_realloc_slot_table(struct nfs4_slot_table *tbl, u32 max_reqs,
|
||||
u32 ivalue)
|
||||
{
|
||||
struct nfs4_slot *new = NULL;
|
||||
int i;
|
||||
int ret = 0;
|
||||
int ret = -ENOMEM;
|
||||
|
||||
dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,
|
||||
max_reqs, tbl->max_slots);
|
||||
|
||||
/* Does the newly negotiated max_reqs match the existing slot table? */
|
||||
if (max_reqs != tbl->max_slots) {
|
||||
ret = -ENOMEM;
|
||||
new = kmalloc(max_reqs * sizeof(struct nfs4_slot),
|
||||
GFP_NOFS);
|
||||
new = nfs4_alloc_slots(max_reqs, GFP_NOFS);
|
||||
if (!new)
|
||||
goto out;
|
||||
ret = 0;
|
||||
kfree(tbl->slots);
|
||||
}
|
||||
spin_lock(&tbl->slot_tbl_lock);
|
||||
if (new) {
|
||||
tbl->slots = new;
|
||||
tbl->max_slots = max_reqs;
|
||||
}
|
||||
for (i = 0; i < tbl->max_slots; ++i)
|
||||
tbl->slots[i].seq_nr = ivalue;
|
||||
spin_unlock(&tbl->slot_tbl_lock);
|
||||
ret = 0;
|
||||
|
||||
nfs4_add_and_init_slots(tbl, new, max_reqs, ivalue);
|
||||
dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
|
||||
tbl, tbl->slots, tbl->max_slots);
|
||||
out:
|
||||
|
@ -5060,36 +5079,6 @@ static void nfs4_destroy_slot_tables(struct nfs4_session *session)
|
|||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize slot table
|
||||
*/
|
||||
static int nfs4_init_slot_table(struct nfs4_slot_table *tbl,
|
||||
int max_slots, int ivalue)
|
||||
{
|
||||
struct nfs4_slot *slot;
|
||||
int ret = -ENOMEM;
|
||||
|
||||
BUG_ON(max_slots > NFS4_MAX_SLOT_TABLE);
|
||||
|
||||
dprintk("--> %s: max_reqs=%u\n", __func__, max_slots);
|
||||
|
||||
slot = kcalloc(max_slots, sizeof(struct nfs4_slot), GFP_NOFS);
|
||||
if (!slot)
|
||||
goto out;
|
||||
ret = 0;
|
||||
|
||||
spin_lock(&tbl->slot_tbl_lock);
|
||||
tbl->max_slots = max_slots;
|
||||
tbl->slots = slot;
|
||||
tbl->highest_used_slotid = -1; /* no slot is currently used */
|
||||
spin_unlock(&tbl->slot_tbl_lock);
|
||||
dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
|
||||
tbl, tbl->slots, tbl->max_slots);
|
||||
out:
|
||||
dprintk("<-- %s: return %d\n", __func__, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize or reset the forechannel and backchannel tables
|
||||
*/
|
||||
|
@ -5101,25 +5090,16 @@ static int nfs4_setup_session_slot_tables(struct nfs4_session *ses)
|
|||
dprintk("--> %s\n", __func__);
|
||||
/* Fore channel */
|
||||
tbl = &ses->fc_slot_table;
|
||||
if (tbl->slots == NULL) {
|
||||
status = nfs4_init_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
|
||||
if (status) /* -ENOMEM */
|
||||
return status;
|
||||
} else {
|
||||
status = nfs4_reset_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
|
||||
if (status)
|
||||
return status;
|
||||
}
|
||||
status = nfs4_realloc_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
|
||||
if (status) /* -ENOMEM */
|
||||
return status;
|
||||
/* Back channel */
|
||||
tbl = &ses->bc_slot_table;
|
||||
if (tbl->slots == NULL) {
|
||||
status = nfs4_init_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
|
||||
if (status)
|
||||
/* Fore and back channel share a connection so get
|
||||
* both slot tables or neither */
|
||||
nfs4_destroy_slot_tables(ses);
|
||||
} else
|
||||
status = nfs4_reset_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
|
||||
status = nfs4_realloc_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
|
||||
if (status && tbl->slots == NULL)
|
||||
/* Fore and back channel share a connection so get
|
||||
* both slot tables or neither */
|
||||
nfs4_destroy_slot_tables(ses);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
|
|
@ -1132,6 +1132,8 @@ void nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4
|
|||
{
|
||||
struct nfs_client *clp = server->nfs_client;
|
||||
|
||||
if (test_and_clear_bit(NFS_DELEGATED_STATE, &state->flags))
|
||||
nfs_async_inode_return_delegation(state->inode, &state->stateid);
|
||||
nfs4_state_mark_reclaim_nograce(clp, state);
|
||||
nfs4_schedule_state_manager(clp);
|
||||
}
|
||||
|
|
|
@ -2522,7 +2522,6 @@ static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
|
|||
|
||||
xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
|
||||
args->acl_pages, args->acl_pgbase, args->acl_len);
|
||||
xdr_set_scratch_buffer(xdr, page_address(args->acl_scratch), PAGE_SIZE);
|
||||
|
||||
encode_nops(&hdr);
|
||||
}
|
||||
|
@ -6032,6 +6031,10 @@ nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
|
|||
struct compound_hdr hdr;
|
||||
int status;
|
||||
|
||||
if (res->acl_scratch != NULL) {
|
||||
void *p = page_address(res->acl_scratch);
|
||||
xdr_set_scratch_buffer(xdr, p, PAGE_SIZE);
|
||||
}
|
||||
status = decode_compound_hdr(xdr, &hdr);
|
||||
if (status)
|
||||
goto out;
|
||||
|
|
|
@ -139,10 +139,10 @@ xfs_qm_adjust_dqtimers(
|
|||
|
||||
if (!d->d_btimer) {
|
||||
if ((d->d_blk_softlimit &&
|
||||
(be64_to_cpu(d->d_bcount) >=
|
||||
(be64_to_cpu(d->d_bcount) >
|
||||
be64_to_cpu(d->d_blk_softlimit))) ||
|
||||
(d->d_blk_hardlimit &&
|
||||
(be64_to_cpu(d->d_bcount) >=
|
||||
(be64_to_cpu(d->d_bcount) >
|
||||
be64_to_cpu(d->d_blk_hardlimit)))) {
|
||||
d->d_btimer = cpu_to_be32(get_seconds() +
|
||||
mp->m_quotainfo->qi_btimelimit);
|
||||
|
@ -151,10 +151,10 @@ xfs_qm_adjust_dqtimers(
|
|||
}
|
||||
} else {
|
||||
if ((!d->d_blk_softlimit ||
|
||||
(be64_to_cpu(d->d_bcount) <
|
||||
(be64_to_cpu(d->d_bcount) <=
|
||||
be64_to_cpu(d->d_blk_softlimit))) &&
|
||||
(!d->d_blk_hardlimit ||
|
||||
(be64_to_cpu(d->d_bcount) <
|
||||
(be64_to_cpu(d->d_bcount) <=
|
||||
be64_to_cpu(d->d_blk_hardlimit)))) {
|
||||
d->d_btimer = 0;
|
||||
}
|
||||
|
@ -162,10 +162,10 @@ xfs_qm_adjust_dqtimers(
|
|||
|
||||
if (!d->d_itimer) {
|
||||
if ((d->d_ino_softlimit &&
|
||||
(be64_to_cpu(d->d_icount) >=
|
||||
(be64_to_cpu(d->d_icount) >
|
||||
be64_to_cpu(d->d_ino_softlimit))) ||
|
||||
(d->d_ino_hardlimit &&
|
||||
(be64_to_cpu(d->d_icount) >=
|
||||
(be64_to_cpu(d->d_icount) >
|
||||
be64_to_cpu(d->d_ino_hardlimit)))) {
|
||||
d->d_itimer = cpu_to_be32(get_seconds() +
|
||||
mp->m_quotainfo->qi_itimelimit);
|
||||
|
@ -174,10 +174,10 @@ xfs_qm_adjust_dqtimers(
|
|||
}
|
||||
} else {
|
||||
if ((!d->d_ino_softlimit ||
|
||||
(be64_to_cpu(d->d_icount) <
|
||||
(be64_to_cpu(d->d_icount) <=
|
||||
be64_to_cpu(d->d_ino_softlimit))) &&
|
||||
(!d->d_ino_hardlimit ||
|
||||
(be64_to_cpu(d->d_icount) <
|
||||
(be64_to_cpu(d->d_icount) <=
|
||||
be64_to_cpu(d->d_ino_hardlimit)))) {
|
||||
d->d_itimer = 0;
|
||||
}
|
||||
|
@ -185,10 +185,10 @@ xfs_qm_adjust_dqtimers(
|
|||
|
||||
if (!d->d_rtbtimer) {
|
||||
if ((d->d_rtb_softlimit &&
|
||||
(be64_to_cpu(d->d_rtbcount) >=
|
||||
(be64_to_cpu(d->d_rtbcount) >
|
||||
be64_to_cpu(d->d_rtb_softlimit))) ||
|
||||
(d->d_rtb_hardlimit &&
|
||||
(be64_to_cpu(d->d_rtbcount) >=
|
||||
(be64_to_cpu(d->d_rtbcount) >
|
||||
be64_to_cpu(d->d_rtb_hardlimit)))) {
|
||||
d->d_rtbtimer = cpu_to_be32(get_seconds() +
|
||||
mp->m_quotainfo->qi_rtbtimelimit);
|
||||
|
@ -197,10 +197,10 @@ xfs_qm_adjust_dqtimers(
|
|||
}
|
||||
} else {
|
||||
if ((!d->d_rtb_softlimit ||
|
||||
(be64_to_cpu(d->d_rtbcount) <
|
||||
(be64_to_cpu(d->d_rtbcount) <=
|
||||
be64_to_cpu(d->d_rtb_softlimit))) &&
|
||||
(!d->d_rtb_hardlimit ||
|
||||
(be64_to_cpu(d->d_rtbcount) <
|
||||
(be64_to_cpu(d->d_rtbcount) <=
|
||||
be64_to_cpu(d->d_rtb_hardlimit)))) {
|
||||
d->d_rtbtimer = 0;
|
||||
}
|
||||
|
|
|
@ -1981,7 +1981,7 @@ xfs_qm_dqcheck(
|
|||
|
||||
if (!errs && ddq->d_id) {
|
||||
if (ddq->d_blk_softlimit &&
|
||||
be64_to_cpu(ddq->d_bcount) >=
|
||||
be64_to_cpu(ddq->d_bcount) >
|
||||
be64_to_cpu(ddq->d_blk_softlimit)) {
|
||||
if (!ddq->d_btimer) {
|
||||
if (flags & XFS_QMOPT_DOWARN)
|
||||
|
@ -1992,7 +1992,7 @@ xfs_qm_dqcheck(
|
|||
}
|
||||
}
|
||||
if (ddq->d_ino_softlimit &&
|
||||
be64_to_cpu(ddq->d_icount) >=
|
||||
be64_to_cpu(ddq->d_icount) >
|
||||
be64_to_cpu(ddq->d_ino_softlimit)) {
|
||||
if (!ddq->d_itimer) {
|
||||
if (flags & XFS_QMOPT_DOWARN)
|
||||
|
@ -2003,7 +2003,7 @@ xfs_qm_dqcheck(
|
|||
}
|
||||
}
|
||||
if (ddq->d_rtb_softlimit &&
|
||||
be64_to_cpu(ddq->d_rtbcount) >=
|
||||
be64_to_cpu(ddq->d_rtbcount) >
|
||||
be64_to_cpu(ddq->d_rtb_softlimit)) {
|
||||
if (!ddq->d_rtbtimer) {
|
||||
if (flags & XFS_QMOPT_DOWARN)
|
||||
|
|
|
@ -813,11 +813,11 @@ xfs_qm_export_dquot(
|
|||
(XFS_IS_OQUOTA_ENFORCED(mp) &&
|
||||
(dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) &&
|
||||
dst->d_id != 0) {
|
||||
if (((int) dst->d_bcount >= (int) dst->d_blk_softlimit) &&
|
||||
if (((int) dst->d_bcount > (int) dst->d_blk_softlimit) &&
|
||||
(dst->d_blk_softlimit > 0)) {
|
||||
ASSERT(dst->d_btimer != 0);
|
||||
}
|
||||
if (((int) dst->d_icount >= (int) dst->d_ino_softlimit) &&
|
||||
if (((int) dst->d_icount > (int) dst->d_ino_softlimit) &&
|
||||
(dst->d_ino_softlimit > 0)) {
|
||||
ASSERT(dst->d_itimer != 0);
|
||||
}
|
||||
|
|
|
@ -1151,8 +1151,8 @@ xfs_trans_add_item(
|
|||
{
|
||||
struct xfs_log_item_desc *lidp;
|
||||
|
||||
ASSERT(lip->li_mountp = tp->t_mountp);
|
||||
ASSERT(lip->li_ailp = tp->t_mountp->m_ail);
|
||||
ASSERT(lip->li_mountp == tp->t_mountp);
|
||||
ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
|
||||
|
||||
lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
|
||||
|
||||
|
|
|
@ -649,12 +649,12 @@ xfs_trans_dqresv(
|
|||
* nblks.
|
||||
*/
|
||||
if (hardlimit > 0ULL &&
|
||||
hardlimit <= nblks + *resbcountp) {
|
||||
hardlimit < nblks + *resbcountp) {
|
||||
xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
|
||||
goto error_return;
|
||||
}
|
||||
if (softlimit > 0ULL &&
|
||||
softlimit <= nblks + *resbcountp) {
|
||||
softlimit < nblks + *resbcountp) {
|
||||
if ((timer != 0 && get_seconds() > timer) ||
|
||||
(warns != 0 && warns >= warnlimit)) {
|
||||
xfs_quota_warn(mp, dqp,
|
||||
|
@ -677,11 +677,13 @@ xfs_trans_dqresv(
|
|||
if (!softlimit)
|
||||
softlimit = q->qi_isoftlimit;
|
||||
|
||||
if (hardlimit > 0ULL && count >= hardlimit) {
|
||||
if (hardlimit > 0ULL &&
|
||||
hardlimit < ninos + count) {
|
||||
xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
|
||||
goto error_return;
|
||||
}
|
||||
if (softlimit > 0ULL && count >= softlimit) {
|
||||
if (softlimit > 0ULL &&
|
||||
softlimit < ninos + count) {
|
||||
if ((timer != 0 && get_seconds() > timer) ||
|
||||
(warns != 0 && warns >= warnlimit)) {
|
||||
xfs_quota_warn(mp, dqp,
|
||||
|
|
|
@ -614,7 +614,6 @@ struct nfs_getaclargs {
|
|||
size_t acl_len;
|
||||
unsigned int acl_pgbase;
|
||||
struct page ** acl_pages;
|
||||
struct page * acl_scratch;
|
||||
struct nfs4_sequence_args seq_args;
|
||||
};
|
||||
|
||||
|
@ -624,6 +623,7 @@ struct nfs_getaclres {
|
|||
size_t acl_len;
|
||||
size_t acl_data_offset;
|
||||
int acl_flags;
|
||||
struct page * acl_scratch;
|
||||
struct nfs4_sequence_res seq_res;
|
||||
};
|
||||
|
||||
|
|
|
@ -61,12 +61,6 @@
|
|||
#define USB_PORT_FEAT_TEST 21
|
||||
#define USB_PORT_FEAT_INDICATOR 22
|
||||
#define USB_PORT_FEAT_C_PORT_L1 23
|
||||
#define USB_PORT_FEAT_C_PORT_LINK_STATE 25
|
||||
#define USB_PORT_FEAT_C_PORT_CONFIG_ERROR 26
|
||||
#define USB_PORT_FEAT_PORT_REMOTE_WAKE_MASK 27
|
||||
#define USB_PORT_FEAT_BH_PORT_RESET 28
|
||||
#define USB_PORT_FEAT_C_BH_PORT_RESET 29
|
||||
#define USB_PORT_FEAT_FORCE_LINKPM_ACCEPT 30
|
||||
|
||||
/*
|
||||
* Port feature selectors added by USB 3.0 spec.
|
||||
|
@ -75,8 +69,8 @@
|
|||
#define USB_PORT_FEAT_LINK_STATE 5
|
||||
#define USB_PORT_FEAT_U1_TIMEOUT 23
|
||||
#define USB_PORT_FEAT_U2_TIMEOUT 24
|
||||
#define USB_PORT_FEAT_C_LINK_STATE 25
|
||||
#define USB_PORT_FEAT_C_CONFIG_ERR 26
|
||||
#define USB_PORT_FEAT_C_PORT_LINK_STATE 25
|
||||
#define USB_PORT_FEAT_C_PORT_CONFIG_ERROR 26
|
||||
#define USB_PORT_FEAT_REMOTE_WAKE_MASK 27
|
||||
#define USB_PORT_FEAT_BH_PORT_RESET 28
|
||||
#define USB_PORT_FEAT_C_BH_PORT_RESET 29
|
||||
|
|
|
@ -80,6 +80,8 @@ enum {
|
|||
ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
|
||||
};
|
||||
|
||||
#define MAX_VOL_NIDS 0x40
|
||||
|
||||
struct alc_spec {
|
||||
/* codec parameterization */
|
||||
const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
|
||||
|
@ -118,8 +120,8 @@ struct alc_spec {
|
|||
const hda_nid_t *capsrc_nids;
|
||||
hda_nid_t dig_in_nid; /* digital-in NID; optional */
|
||||
hda_nid_t mixer_nid; /* analog-mixer NID */
|
||||
DECLARE_BITMAP(vol_ctls, 0x20 << 1);
|
||||
DECLARE_BITMAP(sw_ctls, 0x20 << 1);
|
||||
DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
|
||||
DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
|
||||
|
||||
/* capture setup for dynamic dual-adc switch */
|
||||
hda_nid_t cur_adc;
|
||||
|
@ -3149,7 +3151,10 @@ static int alc_auto_fill_dac_nids(struct hda_codec *codec)
|
|||
static inline unsigned int get_ctl_pos(unsigned int data)
|
||||
{
|
||||
hda_nid_t nid = get_amp_nid_(data);
|
||||
unsigned int dir = get_amp_direction_(data);
|
||||
unsigned int dir;
|
||||
if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
|
||||
return 0;
|
||||
dir = get_amp_direction_(data);
|
||||
return (nid << 1) | dir;
|
||||
}
|
||||
|
||||
|
@ -4436,12 +4441,20 @@ static void alc889_fixup_dac_route(struct hda_codec *codec,
|
|||
const struct alc_fixup *fix, int action)
|
||||
{
|
||||
if (action == ALC_FIXUP_ACT_PRE_PROBE) {
|
||||
/* fake the connections during parsing the tree */
|
||||
hda_nid_t conn1[2] = { 0x0c, 0x0d };
|
||||
hda_nid_t conn2[2] = { 0x0e, 0x0f };
|
||||
snd_hda_override_conn_list(codec, 0x14, 2, conn1);
|
||||
snd_hda_override_conn_list(codec, 0x15, 2, conn1);
|
||||
snd_hda_override_conn_list(codec, 0x18, 2, conn2);
|
||||
snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
|
||||
} else if (action == ALC_FIXUP_ACT_PROBE) {
|
||||
/* restore the connections */
|
||||
hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
|
||||
snd_hda_override_conn_list(codec, 0x14, 5, conn);
|
||||
snd_hda_override_conn_list(codec, 0x15, 5, conn);
|
||||
snd_hda_override_conn_list(codec, 0x18, 5, conn);
|
||||
snd_hda_override_conn_list(codec, 0x1a, 5, conn);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -146,13 +146,10 @@ static const struct snd_kcontrol_new ak4642_snd_controls[] = {
|
|||
|
||||
SOC_DOUBLE_R_TLV("Digital Playback Volume", L_DVC, R_DVC,
|
||||
0, 0xFF, 1, out_tlv),
|
||||
|
||||
SOC_SINGLE("Headphone Switch", PW_MGMT2, 6, 1, 0),
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new ak4642_hpout_mixer_controls[] = {
|
||||
SOC_DAPM_SINGLE("DACH", MD_CTL4, 0, 1, 0),
|
||||
};
|
||||
static const struct snd_kcontrol_new ak4642_headphone_control =
|
||||
SOC_DAPM_SINGLE("Switch", PW_MGMT2, 6, 1, 0);
|
||||
|
||||
static const struct snd_kcontrol_new ak4642_lout_mixer_controls[] = {
|
||||
SOC_DAPM_SINGLE("DACL", SG_SL1, 4, 1, 0),
|
||||
|
@ -165,13 +162,12 @@ static const struct snd_soc_dapm_widget ak4642_dapm_widgets[] = {
|
|||
SND_SOC_DAPM_OUTPUT("HPOUTR"),
|
||||
SND_SOC_DAPM_OUTPUT("LINEOUT"),
|
||||
|
||||
SND_SOC_DAPM_MIXER("HPOUTL Mixer", PW_MGMT2, 5, 0,
|
||||
&ak4642_hpout_mixer_controls[0],
|
||||
ARRAY_SIZE(ak4642_hpout_mixer_controls)),
|
||||
SND_SOC_DAPM_PGA("HPL Out", PW_MGMT2, 5, 0, NULL, 0),
|
||||
SND_SOC_DAPM_PGA("HPR Out", PW_MGMT2, 4, 0, NULL, 0),
|
||||
SND_SOC_DAPM_SWITCH("Headphone Enable", SND_SOC_NOPM, 0, 0,
|
||||
&ak4642_headphone_control),
|
||||
|
||||
SND_SOC_DAPM_MIXER("HPOUTR Mixer", PW_MGMT2, 4, 0,
|
||||
&ak4642_hpout_mixer_controls[0],
|
||||
ARRAY_SIZE(ak4642_hpout_mixer_controls)),
|
||||
SND_SOC_DAPM_PGA("DACH", MD_CTL4, 0, 0, NULL, 0),
|
||||
|
||||
SND_SOC_DAPM_MIXER("LINEOUT Mixer", PW_MGMT1, 3, 0,
|
||||
&ak4642_lout_mixer_controls[0],
|
||||
|
@ -184,12 +180,17 @@ static const struct snd_soc_dapm_widget ak4642_dapm_widgets[] = {
|
|||
static const struct snd_soc_dapm_route ak4642_intercon[] = {
|
||||
|
||||
/* Outputs */
|
||||
{"HPOUTL", NULL, "HPOUTL Mixer"},
|
||||
{"HPOUTR", NULL, "HPOUTR Mixer"},
|
||||
{"HPOUTL", NULL, "HPL Out"},
|
||||
{"HPOUTR", NULL, "HPR Out"},
|
||||
{"LINEOUT", NULL, "LINEOUT Mixer"},
|
||||
|
||||
{"HPOUTL Mixer", "DACH", "DAC"},
|
||||
{"HPOUTR Mixer", "DACH", "DAC"},
|
||||
{"HPL Out", NULL, "Headphone Enable"},
|
||||
{"HPR Out", NULL, "Headphone Enable"},
|
||||
|
||||
{"Headphone Enable", "Switch", "DACH"},
|
||||
|
||||
{"DACH", NULL, "DAC"},
|
||||
|
||||
{"LINEOUT Mixer", "DACL", "DAC"},
|
||||
};
|
||||
|
||||
|
|
|
@ -2564,7 +2564,7 @@ static int dsp2_event(struct snd_soc_dapm_widget *w,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static const char *st_text[] = { "None", "Right", "Left" };
|
||||
static const char *st_text[] = { "None", "Left", "Right" };
|
||||
|
||||
static const struct soc_enum str_enum =
|
||||
SOC_ENUM_SINGLE(WM8962_DAC_DSP_MIXING_1, 2, 3, st_text);
|
||||
|
|
|
@ -311,8 +311,10 @@ snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
|
|||
|
||||
spin_lock(&dev->spinlock);
|
||||
|
||||
if (dev->input_panic || dev->output_panic)
|
||||
if (dev->input_panic || dev->output_panic) {
|
||||
ptr = SNDRV_PCM_POS_XRUN;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
||||
ptr = bytes_to_frames(sub->runtime,
|
||||
|
@ -321,6 +323,7 @@ snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
|
|||
ptr = bytes_to_frames(sub->runtime,
|
||||
dev->audio_in_buf_pos[index]);
|
||||
|
||||
unlock:
|
||||
spin_unlock(&dev->spinlock);
|
||||
return ptr;
|
||||
}
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef __USBAUDIO_CARD_H
|
||||
#define __USBAUDIO_CARD_H
|
||||
|
||||
#define MAX_NR_RATES 1024
|
||||
#define MAX_PACKS 20
|
||||
#define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */
|
||||
#define MAX_URBS 8
|
||||
|
|
|
@ -209,8 +209,6 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define MAX_UAC2_NR_RATES 1024
|
||||
|
||||
/*
|
||||
* Helper function to walk the array of sample rate triplets reported by
|
||||
* the device. The problem is that we need to parse whole array first to
|
||||
|
@ -255,7 +253,7 @@ static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
|
|||
fp->rates |= snd_pcm_rate_to_rate_bit(rate);
|
||||
|
||||
nr_rates++;
|
||||
if (nr_rates >= MAX_UAC2_NR_RATES) {
|
||||
if (nr_rates >= MAX_NR_RATES) {
|
||||
snd_printk(KERN_ERR "invalid uac2 rates\n");
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -132,10 +132,14 @@ static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
|
|||
unsigned *rate_table = NULL;
|
||||
|
||||
fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
|
||||
if (! fp) {
|
||||
if (!fp) {
|
||||
snd_printk(KERN_ERR "cannot memdup\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (fp->nr_rates > MAX_NR_RATES) {
|
||||
kfree(fp);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (fp->nr_rates > 0) {
|
||||
rate_table = kmemdup(fp->rate_table,
|
||||
sizeof(int) * fp->nr_rates, GFP_KERNEL);
|
||||
|
|
Loading…
Reference in a new issue