Changeset 19073


Ignore:
Timestamp:
04/20/12 12:40:43 (13 months ago)
Author:
BrainSlayer
Message:

kernel update

Location:
src/linux/universal/linux-3.3
Files:
78 edited

Legend:

Unmodified
Added
Removed

  • src/linux/universal/linux-3.3/Makefile

    r19028 r19073  
    11VERSION = 3 
    22PATCHLEVEL = 3 
    3 SUBLEVEL = 2 
    4 EXTRAVERSION = 
     3SUBLEVEL = 3 
     4EXTRAVERSION = -rc1 
    55NAME = Saber-toothed Squirrel 
    66 

  • src/linux/universal/linux-3.3/arch/arm/boot/compressed/head.S

    r18778 r19073  
    274274                mov     r1, r6 
    275275                sub     r2, sp, r6 
    276                 blne    atags_to_fdt 
     276                bleq    atags_to_fdt 
    277277 
    278278                ldmfd   sp!, {r0-r3, ip, lr} 

  • src/linux/universal/linux-3.3/arch/arm/mm/proc-v7.S

    r18778 r19073  
    256256        mcr     p15, 0, r6, c10, c2, 1          @ write NMRR 
    257257#endif 
     258#ifndef CONFIG_ARM_THUMBEE 
     259        mrc     p15, 0, r0, c0, c1, 0           @ read ID_PFR0 for ThumbEE 
     260        and     r0, r0, #(0xf << 12)            @ ThumbEE enabled field 
     261        teq     r0, #(1 << 12)                  @ check if ThumbEE is present 
     262        bne     1f 
     263        mov     r5, #0 
     264        mcr     p14, 6, r5, c1, c0, 0           @ Initialize TEEHBR to 0 
     265        mrc     p14, 6, r0, c0, c0, 0           @ load TEECR 
     266        orr     r0, r0, #1                      @ set the 1st bit in order to 
     267        mcr     p14, 6, r0, c0, c0, 0           @ stop userspace TEEHBR access 
     2681: 
     269#endif 
    258270        adr     r5, v7_crval 
    259271        ldmia   r5, {r5, r6} 

  • src/linux/universal/linux-3.3/arch/ia64/include/asm/futex.h

    r18778 r19073  
    108108 
    109109        { 
    110                 register unsigned long r8 __asm ("r8") = 0; 
     110                register unsigned long r8 __asm ("r8"); 
    111111                unsigned long prev; 
    112112                __asm__ __volatile__( 
    113113                        "       mf;;                                    \n" 
    114                         "       mov ar.ccv=%3;;                         \n" 
    115                         "[1:]   cmpxchg4.acq %0=[%1],%2,ar.ccv          \n" 
     114                        "       mov %0=r0                               \n" 
     115                        "       mov ar.ccv=%4;;                         \n" 
     116                        "[1:]   cmpxchg4.acq %1=[%2],%3,ar.ccv          \n" 
    116117                        "       .xdata4 \"__ex_table\", 1b-., 2f-.      \n" 
    117118                        "[2:]" 
    118                         : "=r" (prev) 
     119                        : "=r" (r8), "=r" (prev) 
    119120                        : "r" (uaddr), "r" (newval), 
    120121                          "rO" ((long) (unsigned) oldval) 

  • src/linux/universal/linux-3.3/arch/s390/Kconfig

    r18778 r19073  
    9090        select HAVE_ARCH_MUTEX_CPU_RELAX 
    9191        select HAVE_ARCH_JUMP_LABEL if !MARCH_G5 
    92         select HAVE_RCU_TABLE_FREE if SMP 
    9392        select ARCH_SAVE_PAGE_KEYS if HIBERNATION 
    9493        select HAVE_MEMBLOCK 

  • src/linux/universal/linux-3.3/arch/s390/include/asm/pgalloc.h

    r18778 r19073  
    2323unsigned long *page_table_alloc(struct mm_struct *, unsigned long); 
    2424void page_table_free(struct mm_struct *, unsigned long *); 
    25 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    2625void page_table_free_rcu(struct mmu_gather *, unsigned long *); 
    27 void __tlb_remove_table(void *_table); 
    28 #endif 
    2926 
    3027static inline void clear_table(unsigned long *s, unsigned long val, size_t n) 

  • src/linux/universal/linux-3.3/arch/s390/include/asm/tlb.h

    r18778 r19073  
    3131struct mmu_gather { 
    3232        struct mm_struct *mm; 
    33 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    3433        struct mmu_table_batch *batch; 
    35 #endif 
    3634        unsigned int fullmm; 
    37         unsigned int need_flush; 
    3835}; 
    3936 
    40 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    4137struct mmu_table_batch { 
    4238        struct rcu_head         rcu; 
    … …  
    5046extern void tlb_table_flush(struct mmu_gather *tlb); 
    5147extern void tlb_remove_table(struct mmu_gather *tlb, void *table); 
    52 #endif 
    5348 
    5449static inline void tlb_gather_mmu(struct mmu_gather *tlb, 
    … …  
    5853        tlb->mm = mm; 
    5954        tlb->fullmm = full_mm_flush; 
    60         tlb->need_flush = 0; 
    61 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    6255        tlb->batch = NULL; 
    63 #endif 
    6456        if (tlb->fullmm) 
    6557                __tlb_flush_mm(mm); 
    … …  
    6860static inline void tlb_flush_mmu(struct mmu_gather *tlb) 
    6961{ 
    70         if (!tlb->need_flush) 
    71                 return; 
    72         tlb->need_flush = 0; 
    73         __tlb_flush_mm(tlb->mm); 
    74 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    7562        tlb_table_flush(tlb); 
    76 #endif 
    7763} 
    7864 
    … …  
    8066                                  unsigned long start, unsigned long end) 
    8167{ 
    82         tlb_flush_mmu(tlb); 
     68        tlb_table_flush(tlb); 
    8369} 
    8470 
    … …  
    10692                                unsigned long address) 
    10793{ 
    108 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    10994        if (!tlb->fullmm) 
    11095                return page_table_free_rcu(tlb, (unsigned long *) pte); 
    111 #endif 
    11296        page_table_free(tlb->mm, (unsigned long *) pte); 
    11397} 
    … …  
    126110        if (tlb->mm->context.asce_limit <= (1UL << 31)) 
    127111                return; 
    128 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    129112        if (!tlb->fullmm) 
    130113                return tlb_remove_table(tlb, pmd); 
    131 #endif 
    132114        crst_table_free(tlb->mm, (unsigned long *) pmd); 
    133115#endif 
    … …  
    147129        if (tlb->mm->context.asce_limit <= (1UL << 42)) 
    148130                return; 
    149 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    150131        if (!tlb->fullmm) 
    151132                return tlb_remove_table(tlb, pud); 
    152 #endif 
    153133        crst_table_free(tlb->mm, (unsigned long *) pud); 
    154134#endif 

  • src/linux/universal/linux-3.3/arch/s390/mm/pgtable.c

    r18778 r19073  
    680680} 
    681681 
    682 #ifdef CONFIG_HAVE_RCU_TABLE_FREE 
    683  
    684682static void __page_table_free_rcu(void *table, unsigned bit) 
    685683{ 
    … …  
    735733} 
    736734 
    737 #endif 
     735static void tlb_remove_table_smp_sync(void *arg) 
     736{ 
     737        /* Simply deliver the interrupt */ 
     738} 
     739 
     740static void tlb_remove_table_one(void *table) 
     741{ 
     742        /* 
     743         * This isn't an RCU grace period and hence the page-tables cannot be 
     744         * assumed to be actually RCU-freed. 
     745         * 
     746         * It is however sufficient for software page-table walkers that rely 
     747         * on IRQ disabling. See the comment near struct mmu_table_batch. 
     748         */ 
     749        smp_call_function(tlb_remove_table_smp_sync, NULL, 1); 
     750        __tlb_remove_table(table); 
     751} 
     752 
     753static void tlb_remove_table_rcu(struct rcu_head *head) 
     754{ 
     755        struct mmu_table_batch *batch; 
     756        int i; 
     757 
     758        batch = container_of(head, struct mmu_table_batch, rcu); 
     759 
     760        for (i = 0; i < batch->nr; i++) 
     761                __tlb_remove_table(batch->tables[i]); 
     762 
     763        free_page((unsigned long)batch); 
     764} 
     765 
     766void tlb_table_flush(struct mmu_gather *tlb) 
     767{ 
     768        struct mmu_table_batch **batch = &tlb->batch; 
     769 
     770        if (*batch) { 
     771                __tlb_flush_mm(tlb->mm); 
     772                call_rcu_sched(&(*batch)->rcu, tlb_remove_table_rcu); 
     773                *batch = NULL; 
     774        } 
     775} 
     776 
     777void tlb_remove_table(struct mmu_gather *tlb, void *table) 
     778{ 
     779        struct mmu_table_batch **batch = &tlb->batch; 
     780 
     781        if (*batch == NULL) { 
     782                *batch = (struct mmu_table_batch *) 
     783                        __get_free_page(GFP_NOWAIT | __GFP_NOWARN); 
     784                if (*batch == NULL) { 
     785                        __tlb_flush_mm(tlb->mm); 
     786                        tlb_remove_table_one(table); 
     787                        return; 
     788                } 
     789                (*batch)->nr = 0; 
     790        } 
     791        (*batch)->tables[(*batch)->nr++] = table; 
     792        if ((*batch)->nr == MAX_TABLE_BATCH) 
     793                tlb_table_flush(tlb); 
     794} 
    738795 
    739796/* 

  • src/linux/universal/linux-3.3/arch/sparc/kernel/ds.c

    r18778 r19073  
    12681268} 
    12691269 
    1270 subsys_initcall(ds_init); 
     1270fs_initcall(ds_init); 

  • src/linux/universal/linux-3.3/arch/sparc/kernel/rtrap_64.S

    r18778 r19073  
    2121                .text 
    2222                .align                  32 
    23 __handle_softirq: 
    24                 call                    do_softirq 
    25                  nop 
    26                 ba,a,pt                 %xcc, __handle_softirq_continue 
    27                  nop 
    2823__handle_preemption: 
    2924                call                    schedule 
    … …  
    9085 
    9186                /* mm/ultra.S:xcall_report_regs KNOWS about this load. */ 
    92                 bne,pn                  %icc, __handle_softirq 
    9387                 ldx                    [%sp + PTREGS_OFF + PT_V9_TSTATE], %l1 
    94 __handle_softirq_continue: 
    9588rtrap_xcall: 
    9689                sethi                   %hi(0xf << 20), %l4 

  • src/linux/universal/linux-3.3/arch/x86/include/asm/cmpxchg.h

    r18778 r19073  
    4444                case __X86_CASE_B:                                      \ 
    4545                        asm volatile (lock #op "b %b0, %1\n"            \ 
    46                                       : "+r" (__ret), "+m" (*(ptr))     \ 
     46                                      : "+q" (__ret), "+m" (*(ptr))     \ 
    4747                                      : : "memory", "cc");              \ 
    4848                        break;                                          \ 
    … …  
    174174                case __X86_CASE_B:                                      \ 
    175175                        asm volatile (lock "addb %b1, %0\n"             \ 
    176                                       : "+m" (*(ptr)) : "ri" (inc)      \ 
     176                                      : "+m" (*(ptr)) : "qi" (inc)      \ 
    177177                                      : "memory", "cc");                \ 
    178178                        break;                                          \ 

  • src/linux/universal/linux-3.3/drivers/block/cciss_scsi.c

    r18778 r19073  
    867867        sh->sg_tablesize = h->maxsgentries; 
    868868        sh->max_cmd_len = MAX_COMMAND_SIZE; 
     869        sh->max_sectors = h->cciss_max_sectors; 
    869870 
    870871        ((struct cciss_scsi_adapter_data_t *)  
    … …  
    14111412        if (request_nsgs > h->maxSG) 
    14121413                h->maxSG = request_nsgs; 
    1413         c->Header.SGTotal = (__u8) request_nsgs + chained; 
     1414        c->Header.SGTotal = (u16) request_nsgs + chained; 
    14141415        if (request_nsgs > h->max_cmd_sgentries) 
    14151416                c->Header.SGList = h->max_cmd_sgentries; 

  • src/linux/universal/linux-3.3/drivers/bluetooth/ath3k.c

    r18879 r19073  
    7373        /* Atheros AR3012 with sflash firmware*/ 
    7474        { USB_DEVICE(0x0CF3, 0x3004) }, 
     75        { USB_DEVICE(0x0CF3, 0x311D) }, 
     76        { USB_DEVICE(0x13d3, 0x3375) }, 
    7577 
    7678        /* Atheros AR5BBU12 with sflash firmware */ 
    … …  
    8991        /* Atheros AR3012 with sflash firmware*/ 
    9092        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 }, 
     93        { USB_DEVICE(0x0cf3, 0x311D), .driver_info = BTUSB_ATH3012 }, 
     94        { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 }, 
    9195 
    9296        { }     /* Terminating entry */ 

  • src/linux/universal/linux-3.3/drivers/bluetooth/btusb.c

    r18879 r19073  
    129129        /* Atheros 3012 with sflash firmware */ 
    130130        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 }, 
     131        { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 }, 
     132        { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 }, 
    131133 
    132134        /* Atheros AR5BBU12 with sflash firmware */ 

  • src/linux/universal/linux-3.3/drivers/bluetooth/hci_ldisc.c

    r18778 r19073  
    238238 
    239239        BT_DBG("%s", hdev->name); 
    240         kfree(hdev->driver_data); 
    241240} 
    242241 
    … …  
    311310 
    312311                if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) { 
    313                         hu->proto->close(hu); 
    314312                        if (hdev) { 
    315313                                hci_unregister_dev(hdev); 
    316314                                hci_free_dev(hdev); 
    317315                        } 
     316                        hu->proto->close(hu); 
    318317                } 
     318                kfree(hu); 
    319319        } 
    320320} 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/i915/i915_drv.c

    r19019 r19073  
    6565 
    6666int i915_enable_rc6 __read_mostly = -1; 
    67 module_param_named(i915_enable_rc6, i915_enable_rc6, int, 0600); 
     67module_param_named(i915_enable_rc6, i915_enable_rc6, int, 0400); 
    6868MODULE_PARM_DESC(i915_enable_rc6, 
    6969                "Enable power-saving render C-state 6 (default: -1 (use per-chip default)"); 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/i915/intel_dp.c

    r18778 r19073  
    220220} 
    221221 
     222static bool 
     223intel_dp_adjust_dithering(struct intel_dp *intel_dp, 
     224                          struct drm_display_mode *mode, 
     225                          struct drm_display_mode *adjusted_mode) 
     226{ 
     227        int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_dp)); 
     228        int max_lanes = intel_dp_max_lane_count(intel_dp); 
     229        int max_rate, mode_rate; 
     230 
     231        mode_rate = intel_dp_link_required(mode->clock, 24); 
     232        max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes); 
     233 
     234        if (mode_rate > max_rate) { 
     235                mode_rate = intel_dp_link_required(mode->clock, 18); 
     236                if (mode_rate > max_rate) 
     237                        return false; 
     238 
     239                if (adjusted_mode) 
     240                        adjusted_mode->private_flags 
     241                                |= INTEL_MODE_DP_FORCE_6BPC; 
     242 
     243                return true; 
     244        } 
     245 
     246        return true; 
     247} 
     248 
    222249static int 
    223250intel_dp_mode_valid(struct drm_connector *connector, 
    … …  
    225252{ 
    226253        struct intel_dp *intel_dp = intel_attached_dp(connector); 
    227         int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_dp)); 
    228         int max_lanes = intel_dp_max_lane_count(intel_dp); 
    229         int max_rate, mode_rate; 
    230254 
    231255        if (is_edp(intel_dp) && intel_dp->panel_fixed_mode) { 
    … …  
    237261        } 
    238262 
    239         mode_rate = intel_dp_link_required(mode->clock, 24); 
    240         max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes); 
    241  
    242         if (mode_rate > max_rate) { 
    243                         mode_rate = intel_dp_link_required(mode->clock, 18); 
    244                         if (mode_rate > max_rate) 
    245                                 return MODE_CLOCK_HIGH; 
    246                         else 
    247                                 mode->private_flags |= INTEL_MODE_DP_FORCE_6BPC; 
    248         } 
     263        if (!intel_dp_adjust_dithering(intel_dp, mode, NULL)) 
     264                return MODE_CLOCK_HIGH; 
    249265 
    250266        if (mode->clock < 10000) 
    … …  
    674690        int max_lane_count = intel_dp_max_lane_count(intel_dp); 
    675691        int max_clock = intel_dp_max_link_bw(intel_dp) == DP_LINK_BW_2_7 ? 1 : 0; 
    676         int bpp = mode->private_flags & INTEL_MODE_DP_FORCE_6BPC ? 18 : 24; 
     692        int bpp; 
    677693        static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 }; 
    678694 
    … …  
    687703                mode->clock = intel_dp->panel_fixed_mode->clock; 
    688704        } 
     705 
     706        if (!intel_dp_adjust_dithering(intel_dp, mode, adjusted_mode)) 
     707                return false; 
     708 
     709        bpp = adjusted_mode->private_flags & INTEL_MODE_DP_FORCE_6BPC ? 18 : 24; 
    689710 
    690711        for (lane_count = 1; lane_count <= max_lane_count; lane_count <<= 1) { 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/i915/intel_fb.c

    r18879 r19073  
    284284        struct drm_plane *plane; 
    285285 
     286        mutex_lock(&dev->mode_config.mutex); 
     287 
    286288        ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper); 
    287289        if (ret) 
    … …  
    291293        list_for_each_entry(plane, &config->plane_list, head) 
    292294                plane->funcs->disable_plane(plane); 
    293 } 
     295 
     296        mutex_unlock(&dev->mode_config.mutex); 
     297} 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/i915/intel_ringbuffer.c

    r18778 r19073  
    10581058         */ 
    10591059        ring->effective_size = ring->size; 
    1060         if (IS_I830(ring->dev)) 
     1060        if (IS_I830(ring->dev) || IS_845G(ring->dev)) 
    10611061                ring->effective_size -= 128; 
    10621062 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/i915/intel_sprite.c

    r19019 r19073  
    9696        sprctl |= SPRITE_TRICKLE_FEED_DISABLE; 
    9797        sprctl |= SPRITE_ENABLE; 
    98         sprctl |= SPRITE_DEST_KEY; 
    9998 
    10099        /* Sizes are 0 based */ 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/radeon/atombios_encoders.c

    r18879 r19073  
    230230        if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev)) 
    231231                return; 
     232 
     233        /* some R4xx chips have the wrong frev */ 
     234        if (rdev->family <= CHIP_RV410) 
     235                frev = 1; 
    232236 
    233237        switch (frev) { 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/radeon/radeon_connectors.c

    r18879 r19073  
    947947                        encoder = obj_to_encoder(obj); 
    948948 
    949                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC || 
     949                        if (encoder->encoder_type != DRM_MODE_ENCODER_DAC && 
    950950                            encoder->encoder_type != DRM_MODE_ENCODER_TVDAC) 
    951951                                continue; 
    … …  
    977977         * processor. 
    978978         */ 
     979out: 
    979980        if ((!rdev->is_atom_bios) && 
    980981            (ret == connector_status_disconnected) && 
    … …  
    984985        } 
    985986 
    986 out: 
    987987        /* updated in get modes as well since we need to know if it's analog or digital */ 
    988988        radeon_connector_update_scratch_regs(connector, ret); 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/radeon/radeon_i2c.c

    r18778 r19073  
    891891        int ret; 
    892892 
     893        /* don't add the mm_i2c bus unless hw_i2c is enabled */ 
     894        if (rec->mm_i2c && (radeon_hw_i2c == 0)) 
     895                return NULL; 
     896 
    893897        i2c = kzalloc(sizeof(struct radeon_i2c_chan), GFP_KERNEL); 
    894898        if (i2c == NULL) 

  • src/linux/universal/linux-3.3/drivers/gpu/drm/radeon/radeon_irq_kms.c

    r18778 r19073  
    148148                return true; 
    149149 
     150        /* RV515 seems to have MSI issues where it loses 
     151         * MSI rearms occasionally. This leads to lockups and freezes. 
     152         * disable it by default. 
     153         */ 
     154        if (rdev->family == CHIP_RV515) 
     155                return false; 
    150156        if (rdev->flags & RADEON_IS_IGP) { 
    151157                /* APUs work fine with MSIs */ 

  • src/linux/universal/linux-3.3/drivers/infiniband/ulp/srpt/ib_srpt.c

    r18879 r19073  
    32263226        srq_attr.attr.max_sge = 1; 
    32273227        srq_attr.attr.srq_limit = 0; 
     3228        srq_attr.srq_type = IB_SRQT_BASIC; 
    32283229 
    32293230        sdev->srq = ib_create_srq(sdev->pd, &srq_attr); 

  • src/linux/universal/linux-3.3/drivers/md/bitmap.c

    r18879 r19073  
    18201820                start = mddev->recovery_cp; 
    18211821 
     1822        mutex_lock(&mddev->bitmap_info.mutex); 
    18221823        err = bitmap_init_from_disk(bitmap, start); 
     1824        mutex_unlock(&mddev->bitmap_info.mutex); 
    18231825 
    18241826        if (err) 

  • src/linux/universal/linux-3.3/drivers/md/raid1.c

    r18879 r19073  
    16701670        int primary; 
    16711671        int i; 
     1672        int vcnt; 
    16721673 
    16731674        for (primary = 0; primary < conf->raid_disks * 2; primary++) 
    … …  
    16791680                } 
    16801681        r1_bio->read_disk = primary; 
     1682        vcnt = (r1_bio->sectors + PAGE_SIZE / 512 - 1) >> (PAGE_SHIFT - 9); 
    16811683        for (i = 0; i < conf->raid_disks * 2; i++) { 
    16821684                int j; 
    1683                 int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9); 
    16841685                struct bio *pbio = r1_bio->bios[primary]; 
    16851686                struct bio *sbio = r1_bio->bios[i]; 

  • src/linux/universal/linux-3.3/drivers/md/raid10.c

    r18879 r19073  
    17431743        int i, first; 
    17441744        struct bio *tbio, *fbio; 
     1745        int vcnt; 
    17451746 
    17461747        atomic_set(&r10_bio->remaining, 1); 
    … …  
    17571758        fbio = r10_bio->devs[i].bio; 
    17581759 
     1760        vcnt = (r10_bio->sectors + (PAGE_SIZE >> 9) - 1) >> (PAGE_SHIFT - 9); 
    17591761        /* now find blocks with errors */ 
    17601762        for (i=0 ; i < conf->copies ; i++) { 
    17611763                int  j, d; 
    1762                 int vcnt = r10_bio->sectors >> (PAGE_SHIFT-9); 
    17631764 
    17641765                tbio = r10_bio->devs[i].bio; 
    … …  
    18261827        for (i = 0; i < conf->copies; i++) { 
    18271828                int j, d; 
    1828                 int vcnt = r10_bio->sectors >> (PAGE_SHIFT-9); 
    18291829 
    18301830                tbio = r10_bio->devs[i].repl_bio; 

  • src/linux/universal/linux-3.3/drivers/net/wireless/rtlwifi/pci.c

    r18879 r19073  
    922922        ring = &rtlpci->tx_ring[BEACON_QUEUE]; 
    923923        pskb = __skb_dequeue(&ring->queue); 
    924         if (pskb) 
     924        if (pskb) { 
     925                struct rtl_tx_desc *entry = &ring->desc[ring->idx]; 
     926                pci_unmap_single(rtlpci->pdev, rtlpriv->cfg->ops->get_desc( 
     927                                 (u8 *) entry, true, HW_DESC_TXBUFF_ADDR), 
     928                                 pskb->len, PCI_DMA_TODEVICE); 
    925929                kfree_skb(pskb); 
     930        } 
    926931 
    927932        /*NB: the beacon data buffer must be 32-bit aligned. */ 

  • src/linux/universal/linux-3.3/drivers/net/wireless/rtlwifi/usb.c

    r18879 r19073  
    128128} 
    129129 
    130 static u32 _usb_read_sync(struct usb_device *udev, u32 addr, u16 len) 
    131 { 
     130static u32 _usb_read_sync(struct rtl_priv *rtlpriv, u32 addr, u16 len) 
     131{ 
     132        struct device *dev = rtlpriv->io.dev; 
     133        struct usb_device *udev = to_usb_device(dev); 
    132134        u8 request; 
    133135        u16 wvalue; 
    134136        u16 index; 
    135         u32 *data; 
    136         u32 ret; 
    137  
    138         data = kmalloc(sizeof(u32), GFP_KERNEL); 
    139         if (!data) 
    140                 return -ENOMEM; 
     137        __le32 *data = &rtlpriv->usb_data[rtlpriv->usb_data_index]; 
     138 
    141139        request = REALTEK_USB_VENQT_CMD_REQ; 
    142140        index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */ 
    … …  
    144142        wvalue = (u16)addr; 
    145143        _usbctrl_vendorreq_sync_read(udev, request, wvalue, index, data, len); 
    146         ret = le32_to_cpu(*data); 
    147         kfree(data); 
    148         return ret; 
     144        if (++rtlpriv->usb_data_index >= RTL_USB_MAX_RX_COUNT) 
     145                rtlpriv->usb_data_index = 0; 
     146        return le32_to_cpu(*data); 
    149147} 
    150148 
    151149static u8 _usb_read8_sync(struct rtl_priv *rtlpriv, u32 addr) 
    152150{ 
    153         struct device *dev = rtlpriv->io.dev; 
    154  
    155         return (u8)_usb_read_sync(to_usb_device(dev), addr, 1); 
     151        return (u8)_usb_read_sync(rtlpriv, addr, 1); 
    156152} 
    157153 
    158154static u16 _usb_read16_sync(struct rtl_priv *rtlpriv, u32 addr) 
    159155{ 
    160         struct device *dev = rtlpriv->io.dev; 
    161  
    162         return (u16)_usb_read_sync(to_usb_device(dev), addr, 2); 
     156        return (u16)_usb_read_sync(rtlpriv, addr, 2); 
    163157} 
    164158 
    165159static u32 _usb_read32_sync(struct rtl_priv *rtlpriv, u32 addr) 
    166160{ 
    167         struct device *dev = rtlpriv->io.dev; 
    168  
    169         return _usb_read_sync(to_usb_device(dev), addr, 4); 
     161        return _usb_read_sync(rtlpriv, addr, 4); 
    170162} 
    171163 
    … …  
    955947        } 
    956948        rtlpriv = hw->priv; 
     949        rtlpriv->usb_data = kzalloc(RTL_USB_MAX_RX_COUNT * sizeof(u32), 
     950                                    GFP_KERNEL); 
     951        if (!rtlpriv->usb_data) 
     952                return -ENOMEM; 
     953        rtlpriv->usb_data_index = 0; 
    957954        init_completion(&rtlpriv->firmware_loading_complete); 
    958955        SET_IEEE80211_DEV(hw, &intf->dev); 
    … …  
    10241021        rtl_usb_deinit(hw); 
    10251022        rtl_deinit_core(hw); 
     1023        kfree(rtlpriv->usb_data); 
    10261024        rtlpriv->cfg->ops->deinit_sw_leds(hw); 
    10271025        rtlpriv->cfg->ops->deinit_sw_vars(hw); 

  • src/linux/universal/linux-3.3/drivers/net/wireless/rtlwifi/wifi.h

    r18879 r19073  
    6666#define RTL_MAC80211_NUM_QUEUE                  5 
    6767#define REALTEK_USB_VENQT_MAX_BUF_SIZE          254 
    68  
     68#define RTL_USB_MAX_RX_COUNT                    100 
    6969#define QBSS_LOAD_SIZE                          5 
    7070#define MAX_WMMELE_LENGTH                       64 
    … …  
    16281628        unsigned long status; 
    16291629 
     1630        /* data buffer pointer for USB reads */ 
     1631        __le32 *usb_data; 
     1632        int usb_data_index; 
     1633 
    16301634        /*This must be the last item so 
    16311635           that it points to the data allocated 

  • src/linux/universal/linux-3.3/drivers/rtc/rtc-pl031.c

    r18778 r19073  
    340340 
    341341        /* Enable the clockwatch on ST Variants */ 
    342         if ((ldata->hw_designer == AMBA_VENDOR_ST) && 
    343             (ldata->hw_revision > 1)) 
     342        if (ldata->hw_designer == AMBA_VENDOR_ST) 
    344343                writel(readl(ldata->base + RTC_CR) | RTC_CR_CWEN, 
    345344                       ldata->base + RTC_CR); 

  • src/linux/universal/linux-3.3/drivers/spi/spi-topcliff-pch.c

    r18778 r19073  
    319319                data->rx_index = rx_index; 
    320320 
    321         } 
    322  
    323         /* if transfer complete interrupt */ 
    324         if (reg_spsr_val & SPSR_FI_BIT) { 
    325                 if ((tx_index == bpw_len) && (rx_index == tx_index)) { 
    326                         /* disable interrupts */ 
    327                         pch_spi_setclr_reg(data->master, PCH_SPCR, 0, PCH_ALL); 
    328  
    329                         /* transfer is completed; 
    330                            inform pch_spi_process_messages */ 
    331                         data->transfer_complete = true; 
    332                         data->transfer_active = false; 
    333                         wake_up(&data->wait); 
    334                 } else { 
    335                         dev_err(&data->master->dev, 
    336                                 "%s : Transfer is not completed", __func__); 
     321                /* if transfer complete interrupt */ 
     322                if (reg_spsr_val & SPSR_FI_BIT) { 
     323                        if ((tx_index == bpw_len) && (rx_index == tx_index)) { 
     324                                /* disable interrupts */ 
     325                                pch_spi_setclr_reg(data->master, PCH_SPCR, 0, 
     326                                                   PCH_ALL); 
     327 
     328                                /* transfer is completed; 
     329                                   inform pch_spi_process_messages */ 
     330                                data->transfer_complete = true; 
     331                                data->transfer_active = false; 
     332                                wake_up(&data->wait); 
     333                        } else { 
     334                                dev_err(&data->master->dev, 
     335                                        "%s : Transfer is not completed", 
     336                                        __func__); 
     337                        } 
    337338                } 
    338339        } 

  • src/linux/universal/linux-3.3/drivers/staging/iio/magnetometer/hmc5843.c

    r18778 r19073  
    522522static void hmc5843_init_client(struct i2c_client *client) 
    523523{ 
    524         struct hmc5843_data *data = i2c_get_clientdata(client); 
     524        struct iio_dev *indio_dev = i2c_get_clientdata(client); 
     525        struct hmc5843_data *data = iio_priv(indio_dev); 
     526 
    525527        hmc5843_set_meas_conf(client, data->meas_conf); 
    526528        hmc5843_set_rate(client, data->rate); 

  • src/linux/universal/linux-3.3/drivers/tty/serial/8250/8250.c

    r18778 r19073  
    16101610                struct uart_8250_port *up; 
    16111611                struct uart_port *port; 
    1612                 bool skip; 
    16131612 
    16141613                up = list_entry(l, struct uart_8250_port, list); 
    16151614                port = &up->port; 
    1616                 skip = pass_counter && up->port.flags & UPF_IIR_ONCE; 
    1617  
    1618                 if (!skip && port->handle_irq(port)) { 
     1615 
     1616                if (port->handle_irq(port)) { 
    16191617                        handled = 1; 
    16201618                        end = NULL; 
    … …  
    20772075 
    20782076                /* 
    2079                  * If the interrupt is not reasserted, setup a timer to 
    2080                  * kick the UART on a regular basis. 
     2077                 * If the interrupt is not reasserted, or we otherwise 
     2078                 * don't trust the iir, setup a timer to kick the UART 
     2079                 * on a regular basis. 
    20812080                 */ 
    2082                 if (!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) { 
     2081                if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) || 
     2082                    up->port.flags & UPF_BUG_THRE) { 
    20832083                        up->bugs |= UART_BUG_THRE; 
    20842084                        pr_debug("ttyS%d - using backup timer\n", 

  • src/linux/universal/linux-3.3/drivers/tty/serial/8250/8250_pci.c

    r18778 r19073  
    10971097                           struct uart_port *port, int idx) 
    10981098{ 
    1099         port->flags |= UPF_IIR_ONCE; 
     1099        port->flags |= UPF_BUG_THRE; 
    11001100        return skip_tx_en_setup(priv, board, port, idx); 
    11011101} 
    … …  
    11171117        port->flags |= UPF_EXAR_EFR; 
    11181118        return pci_default_setup(priv, board, port, idx); 
    1119 } 
    1120  
    1121 static int try_enable_msi(struct pci_dev *dev) 
    1122 { 
    1123         /* use msi if available, but fallback to legacy otherwise */ 
    1124         pci_enable_msi(dev); 
    1125         return 0; 
    1126 } 
    1127  
    1128 static void disable_msi(struct pci_dev *dev) 
    1129 { 
    1130         pci_disable_msi(dev); 
    11311119} 
    11321120 
    … …  
    12501238                .subvendor      = PCI_ANY_ID, 
    12511239                .subdevice      = PCI_ANY_ID, 
    1252                 .init           = try_enable_msi, 
    12531240                .setup          = kt_serial_setup, 
    1254                 .exit           = disable_msi, 
    12551241        }, 
    12561242        /* 

  • src/linux/universal/linux-3.3/drivers/tty/serial/altera_uart.c

    r18778 r19073  
    556556        if (res_mem) 
    557557                port->mapbase = res_mem->start; 
    558         else if (platp->mapbase) 
     558        else if (platp) 
    559559                port->mapbase = platp->mapbase; 
    560560        else 
    … …  
    564564        if (res_irq) 
    565565                port->irq = res_irq->start; 
    566         else if (platp->irq) 
     566        else if (platp) 
    567567                port->irq = platp->irq; 
    568568 

  • src/linux/universal/linux-3.3/drivers/tty/serial/amba-pl011.c

    r18889 r19073  
    13821382        uap->port.uartclk = clk_get_rate(uap->clk); 
    13831383 
     1384        /* Clear pending error and receive interrupts */ 
     1385        writew(UART011_OEIS | UART011_BEIS | UART011_PEIS | UART011_FEIS | 
     1386               UART011_RTIS | UART011_RXIS, uap->port.membase + UART011_ICR); 
     1387 
    13841388        /* 
    13851389         * Allocate the IRQ 
    … …  
    14181422        writew(cr, uap->port.membase + UART011_CR); 
    14191423 
    1420         /* Clear pending error interrupts */ 
    1421         writew(UART011_OEIS | UART011_BEIS | UART011_PEIS | UART011_FEIS, 
    1422                uap->port.membase + UART011_ICR); 
    1423  
    14241424        /* 
    14251425         * initialise the old status of the modem signals 
    … …  
    14361436         */ 
    14371437        spin_lock_irq(&uap->port.lock); 
     1438        /* Clear out any spuriously appearing RX interrupts */ 
     1439         writew(UART011_RTIS | UART011_RXIS, 
     1440                uap->port.membase + UART011_ICR); 
    14381441        uap->im = UART011_RTIM; 
    14391442        if (!pl011_dma_rx_running(uap)) 
    … …  
    19451948        pl011_dma_probe(uap); 
    19461949 
     1950        /* Ensure interrupts from this UART are masked and cleared */ 
     1951        writew(0, uap->port.membase + UART011_IMSC); 
     1952        writew(0xffff, uap->port.membase + UART011_ICR); 
     1953 
    19471954        snprintf(uap->type, sizeof(uap->type), "PL011 rev%u", amba_rev(dev)); 
    19481955 

  • src/linux/universal/linux-3.3/drivers/tty/serial/pch_uart.c

    r18778 r19073  
    15871587 
    15881588        pci_enable_msi(pdev); 
     1589        pci_set_master(pdev); 
    15891590 
    15901591        iobase = pci_resource_start(pdev, 0); 

  • src/linux/universal/linux-3.3/drivers/tty/serial/samsung.c

    r18778 r19073  
    983983        ucon &= ucon_mask; 
    984984        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon); 
     985        wr_regl(port, S3C2410_ULCON, cfg->ulcon); 
    985986 
    986987        /* reset both fifos */ 

  • src/linux/universal/linux-3.3/drivers/usb/core/driver.c

    r18778 r19073  
    11911191                status = usb_suspend_device(udev, msg); 
    11921192 
    1193                 /* Again, ignore errors during system sleep transitions */ 
    1194                 if (!PMSG_IS_AUTO(msg)) 
     1193                /* 
     1194                 * Ignore errors from non-root-hub devices during 
     1195                 * system sleep transitions.  For the most part, 
     1196                 * these devices should go to low power anyway when 
     1197                 * the entire bus is suspended. 
     1198                 */ 
     1199                if (udev->parent && !PMSG_IS_AUTO(msg)) 
    11951200                        status = 0; 
    11961201        } 

  • src/linux/universal/linux-3.3/drivers/usb/core/hub.c

    r18778 r19073  
    30873087                goto fail; 
    30883088 
     3089        /* 
     3090         * Some superspeed devices have finished the link training process 
     3091         * and attached to a superspeed hub port, but the device descriptor 
     3092         * got from those devices show they aren't superspeed devices. Warm 
     3093         * reset the port attached by the devices can fix them. 
     3094         */ 
     3095        if ((udev->speed == USB_SPEED_SUPER) && 
     3096                        (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) { 
     3097                dev_err(&udev->dev, "got a wrong device descriptor, " 
     3098                                "warm reset device\n"); 
     3099                hub_port_reset(hub, port1, udev, 
     3100                                HUB_BH_RESET_TIME, true); 
     3101                retval = -EINVAL; 
     3102                goto fail; 
     3103        } 
     3104 
    30893105        if (udev->descriptor.bMaxPacketSize0 == 0xff || 
    30903106                        udev->speed == USB_SPEED_SUPER) 

  • src/linux/universal/linux-3.3/drivers/usb/core/message.c

    r18778 r19073  
    309309                                if (retval != -EINPROGRESS && 
    310310                                    retval != -ENODEV && 
    311                                     retval != -EBUSY) 
     311                                    retval != -EBUSY && 
     312                                    retval != -EIDRM) 
    312313                                        dev_err(&io->dev->dev, 
    313314                                                "%s, unlink --> %d\n", 
    … …  
    318319                spin_lock(&io->lock); 
    319320        } 
    320         urb->dev = NULL; 
    321321 
    322322        /* on the last completion, signal usb_sg_wait() */ 
    … …  
    525525                case -EAGAIN: 
    526526                case -ENOMEM: 
    527                         io->urbs[i]->dev = NULL; 
    528527                        retval = 0; 
    529528                        yield(); 
    … …  
    543542                        /* fail any uncompleted urbs */ 
    544543                default: 
    545                         io->urbs[i]->dev = NULL; 
    546544                        io->urbs[i]->status = retval; 
    547545                        dev_dbg(&io->dev->dev, "%s, submit --> %d\n", 
    … …  
    594592                                continue; 
    595593                        retval = usb_unlink_urb(io->urbs [i]); 
    596                         if (retval != -EINPROGRESS && retval != -EBUSY) 
     594                        if (retval != -EINPROGRESS 
     595                                        && retval != -ENODEV 
     596                                        && retval != -EBUSY 
     597                                        && retval != -EIDRM) 
    597598                                dev_warn(&io->dev->dev, "%s, unlink --> %d\n", 
    598599                                        __func__, retval); 

  • src/linux/universal/linux-3.3/drivers/usb/gadget/pch_udc.c

    r18879 r19073  
    312312 * @suspended:          driver in suspended state 
    313313 * @connected:          gadget driver associated 
     314 * @vbus_session:       required vbus_session state 
    314315 * @set_cfg_not_acked:  pending acknowledgement 4 setup 
    315316 * @waiting_zlp_ack:    pending acknowledgement 4 ZLP 
    … …  
    338339                        suspended:1, 
    339340                        connected:1, 
     341                        vbus_session:1, 
    340342                        set_cfg_not_acked:1, 
    341343                        waiting_zlp_ack:1; 
    … …  
    555557 
    556558/** 
     559 * pch_udc_reconnect() - This API initializes usb device controller, 
     560 *                                              and clear the disconnect status. 
     561 * @dev:                Reference to pch_udc_regs structure 
     562 */ 
     563static void pch_udc_init(struct pch_udc_dev *dev); 
     564static void pch_udc_reconnect(struct pch_udc_dev *dev) 
     565{ 
     566        pch_udc_init(dev); 
     567 
     568        /* enable device interrupts */ 
     569        /* pch_udc_enable_interrupts() */ 
     570        pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR, 
     571                        UDC_DEVINT_UR | UDC_DEVINT_ENUM); 
     572 
     573        /* Clear the disconnect */ 
     574        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES); 
     575        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD); 
     576        mdelay(1); 
     577        /* Resume USB signalling */ 
     578        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES); 
     579} 
     580 
     581/** 
    557582 * pch_udc_vbus_session() - set or clearr the disconnect status. 
    558583 * @dev:        Reference to pch_udc_regs structure 
    … …  
    564589                                          int is_active) 
    565590{ 
    566         if (is_active) 
    567                 pch_udc_clear_disconnect(dev); 
    568         else 
     591        if (is_active) { 
     592                pch_udc_reconnect(dev); 
     593                dev->vbus_session = 1; 
     594        } else { 
     595                if (dev->driver && dev->driver->disconnect) { 
     596                        spin_unlock(&dev->lock); 
     597                        dev->driver->disconnect(&dev->gadget); 
     598                        spin_lock(&dev->lock); 
     599                } 
    569600                pch_udc_set_disconnect(dev); 
     601                dev->vbus_session = 0; 
     602        } 
    570603} 
    571604 
    … …  
    11271160                return -EINVAL; 
    11281161        dev = container_of(gadget, struct pch_udc_dev, gadget); 
    1129         pch_udc_vbus_session(dev, is_on); 
     1162        if (is_on) { 
     1163                pch_udc_reconnect(dev); 
     1164        } else { 
     1165                if (dev->driver && dev->driver->disconnect) { 
     1166                        spin_unlock(&dev->lock); 
     1167                        dev->driver->disconnect(&dev->gadget); 
     1168                        spin_lock(&dev->lock); 
     1169                } 
     1170                pch_udc_set_disconnect(dev); 
     1171        } 
     1172 
    11301173        return 0; 
    11311174} 
    … …  
    23372380                empty_req_queue(ep); 
    23382381        } 
    2339         if (dev->driver && dev->driver->disconnect) 
     2382        if (dev->driver && dev->driver->disconnect) { 
     2383                spin_unlock(&dev->lock); 
    23402384                dev->driver->disconnect(&dev->gadget); 
     2385                spin_lock(&dev->lock); 
     2386        } 
    23412387} 
    23422388 
    … …  
    23732419        pch_udc_set_dma(dev, DMA_DIR_RX); 
    23742420        pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX])); 
     2421 
     2422        /* enable device interrupts */ 
     2423        pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US | 
     2424                                        UDC_DEVINT_ES | UDC_DEVINT_ENUM | 
     2425                                        UDC_DEVINT_SI | UDC_DEVINT_SC); 
    23752426} 
    23762427 
    … …  
    24742525                pch_udc_svc_cfg_interrupt(dev); 
    24752526        /* USB Suspend interrupt */ 
    2476         if (dev_intr & UDC_DEVINT_US) 
     2527        if (dev_intr & UDC_DEVINT_US) { 
     2528                if (dev->driver 
     2529                        && dev->driver->suspend) { 
     2530                        spin_unlock(&dev->lock); 
     2531                        dev->driver->suspend(&dev->gadget); 
     2532                        spin_lock(&dev->lock); 
     2533                } 
     2534 
     2535                if (dev->vbus_session == 0) { 
     2536                        if (dev->driver && dev->driver->disconnect) { 
     2537                                spin_unlock(&dev->lock); 
     2538                                dev->driver->disconnect(&dev->gadget); 
     2539                                spin_lock(&dev->lock); 
     2540                        } 
     2541                        pch_udc_reconnect(dev); 
     2542                } 
    24772543                dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n"); 
     2544        } 
    24782545        /* Clear the SOF interrupt, if enabled */ 
    24792546        if (dev_intr & UDC_DEVINT_SOF) 
    … …  
    25012568        ep_intr = pch_udc_read_ep_interrupts(dev); 
    25022569 
     2570        /* For a hot plug, this find that the controller is hung up. */ 
     2571        if (dev_intr == ep_intr) 
     2572                if (dev_intr == pch_udc_readl(dev, UDC_DEVCFG_ADDR)) { 
     2573                        dev_dbg(&dev->pdev->dev, "UDC: Hung up\n"); 
     2574                        /* The controller is reset */ 
     2575                        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR); 
     2576                        return IRQ_HANDLED; 
     2577                } 
    25032578        if (dev_intr) 
    25042579                /* Clear device interrupts */ 
    … …  
    29142989        pch_udc = dev; 
    29152990        /* initialize the hardware */ 
    2916         if (pch_udc_pcd_init(dev)) 
     2991        if (pch_udc_pcd_init(dev)) { 
     2992                retval = -ENODEV; 
    29172993                goto finished; 
     2994        } 
    29182995        if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME, 
    29192996                        dev)) { 

  • src/linux/universal/linux-3.3/drivers/usb/host/pci-quirks.c

    r18778 r19073  
    828828        } 
    829829 
    830         /* Disable any BIOS SMIs */ 
    831         writel(XHCI_LEGACY_DISABLE_SMI, 
    832                         base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET); 
     830        val = readl(base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET); 
     831        /* Mask off (turn off) any enabled SMIs */ 
     832        val &= XHCI_LEGACY_DISABLE_SMI; 
     833        /* Mask all SMI events bits, RW1C */ 
     834        val |= XHCI_LEGACY_SMI_EVENTS; 
     835        /* Disable any BIOS SMIs and clear all SMI events*/ 
     836        writel(val, base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET); 
    833837 
    834838        if (usb_is_intel_switchable_xhci(pdev)) 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci-ext-caps.h

    r18778 r19073  
    6363/* Add this offset, plus the value of xECP in HCCPARAMS to the base address */ 
    6464#define XHCI_LEGACY_CONTROL_OFFSET      (0x04) 
    65 /* bits 1:2, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */ 
    66 #define XHCI_LEGACY_DISABLE_SMI         ((0x3 << 1) + (0xff << 5) + (0x7 << 17)) 
     65/* bits 1:3, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */ 
     66#define XHCI_LEGACY_DISABLE_SMI         ((0x7 << 1) + (0xff << 5) + (0x7 << 17)) 
     67#define XHCI_LEGACY_SMI_EVENTS          (0x7 << 29) 
    6768 
    6869/* USB 2.0 xHCI 0.96 L1C capability - section 7.2.2.1.3.2 */ 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci-mem.c

    r18778 r19073  
    16911691 
    16921692        /* Free the Event Ring Segment Table and the actual Event Ring */ 
    1693         if (xhci->ir_set) { 
    1694                 xhci_writel(xhci, 0, &xhci->ir_set->erst_size); 
    1695                 xhci_write_64(xhci, 0, &xhci->ir_set->erst_base); 
    1696                 xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue); 
    1697         } 
    16981693        size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); 
    16991694        if (xhci->erst.entries) 
    … …  
    17071702        xhci_dbg(xhci, "Freed event ring\n"); 
    17081703 
    1709         xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); 
    17101704        if (xhci->cmd_ring) 
    17111705                xhci_ring_free(xhci, xhci->cmd_ring); 
    … …  
    17361730        xhci_dbg(xhci, "Freed medium stream array pool\n"); 
    17371731 
    1738         xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr); 
    17391732        if (xhci->dcbaa) 
    17401733                dma_free_coherent(&pdev->dev, sizeof(*xhci->dcbaa), 
    … …  
    23452338fail: 
    23462339        xhci_warn(xhci, "Couldn't initialize memory\n"); 
     2340        xhci_halt(xhci); 
     2341        xhci_reset(xhci); 
    23472342        xhci_mem_cleanup(xhci); 
    23482343        return -ENOMEM; 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci-pci.c

    r18778 r19073  
    9696                xhci_dbg(xhci, "QUIRK: Resetting on resume\n"); 
    9797        } 
     98        if (pdev->vendor == PCI_VENDOR_ID_VIA) 
     99                xhci->quirks |= XHCI_RESET_ON_RESUME; 
    98100} 
    99101 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci-ring.c

    r18778 r19073  
    23512351                /* Acknowledge the PCI interrupt */ 
    23522352                irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending); 
    2353                 irq_pending |= 0x3; 
     2353                irq_pending |= IMAN_IP; 
    23542354                xhci_writel(xhci, irq_pending, &xhci->ir_set->irq_pending); 
    23552355        } 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci.c

    r18778 r19073  
    665665        xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr); 
    666666        xhci->s3.config_reg = xhci_readl(xhci, &xhci->op_regs->config_reg); 
    667         xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending); 
    668         xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control); 
    669667        xhci->s3.erst_size = xhci_readl(xhci, &xhci->ir_set->erst_size); 
    670668        xhci->s3.erst_base = xhci_read_64(xhci, &xhci->ir_set->erst_base); 
    671669        xhci->s3.erst_dequeue = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue); 
     670        xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending); 
     671        xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control); 
    672672} 
    673673 
    … …  
    678678        xhci_write_64(xhci, xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr); 
    679679        xhci_writel(xhci, xhci->s3.config_reg, &xhci->op_regs->config_reg); 
     680        xhci_writel(xhci, xhci->s3.erst_size, &xhci->ir_set->erst_size); 
     681        xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base); 
     682        xhci_write_64(xhci, xhci->s3.erst_dequeue, &xhci->ir_set->erst_dequeue); 
    680683        xhci_writel(xhci, xhci->s3.irq_pending, &xhci->ir_set->irq_pending); 
    681684        xhci_writel(xhci, xhci->s3.irq_control, &xhci->ir_set->irq_control); 
    682         xhci_writel(xhci, xhci->s3.erst_size, &xhci->ir_set->erst_size); 
    683         xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base); 
    684685} 
    685686 

  • src/linux/universal/linux-3.3/drivers/usb/host/xhci.h

    r18778 r19073  
    205205#define CMD_PM_INDEX    (1 << 11) 
    206206/* bits 12:31 are reserved (and should be preserved on writes). */ 
     207 
     208/* IMAN - Interrupt Management Register */ 
     209#define IMAN_IP         (1 << 1) 
     210#define IMAN_IE         (1 << 0) 
    207211 
    208212/* USBSTS - USB status - status bitmasks */ 

  • src/linux/universal/linux-3.3/drivers/usb/serial/ftdi_sio.c

    r18879 r19073  
    7676        struct async_icount     icount; 
    7777        wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */ 
    78         char prev_status, diff_status;        /* Used for TIOCMIWAIT */ 
     78        char prev_status;        /* Used for TIOCMIWAIT */ 
     79        bool dev_gone;        /* Used to abort TIOCMIWAIT */ 
    7980        char transmit_empty;    /* If transmitter is empty or not */ 
    8081        struct usb_serial_port *port; 
    … …  
    16801681 
    16811682        priv->flags = ASYNC_LOW_LATENCY; 
     1683        priv->dev_gone = false; 
    16821684 
    16831685        if (quirk && quirk->port_probe) 
    … …  
    18361838 
    18371839        dbg("%s", __func__); 
     1840 
     1841        priv->dev_gone = true; 
     1842        wake_up_interruptible_all(&priv->delta_msr_wait); 
    18381843 
    18391844        remove_sysfs_attrs(port); 
    … …  
    19801985           are only processed once.  */ 
    19811986        status = packet[0] & FTDI_STATUS_B0_MASK; 
    1982         if (status & FTDI_RS0_CTS) 
    1983                 priv->icount.cts++; 
    1984         if (status & FTDI_RS0_DSR) 
    1985                 priv->icount.dsr++; 
    1986         if (status & FTDI_RS0_RI) 
    1987                 priv->icount.rng++; 
    1988         if (status & FTDI_RS0_RLSD) 
    1989                 priv->icount.dcd++; 
    19901987        if (status != priv->prev_status) { 
    1991                 priv->diff_status |= status ^ priv->prev_status; 
    1992                 wake_up_interruptible(&priv->delta_msr_wait); 
     1988                char diff_status = status ^ priv->prev_status; 
     1989 
     1990                if (diff_status & FTDI_RS0_CTS) 
     1991                        priv->icount.cts++; 
     1992                if (diff_status & FTDI_RS0_DSR) 
     1993                        priv->icount.dsr++; 
     1994                if (diff_status & FTDI_RS0_RI) 
     1995                        priv->icount.rng++; 
     1996                if (diff_status & FTDI_RS0_RLSD) 
     1997                        priv->icount.dcd++; 
     1998 
     1999                wake_up_interruptible_all(&priv->delta_msr_wait); 
    19932000                priv->prev_status = status; 
    19942001        } 
    … …  
    23932400        case TIOCMIWAIT: 
    23942401                cprev = priv->icount; 
    2395                 while (1) { 
     2402                while (!priv->dev_gone) { 
    23962403                        interruptible_sleep_on(&priv->delta_msr_wait); 
    23972404                        /* see if a signal did it */ 
    … …  
    23992406                                return -ERESTARTSYS; 
    24002407                        cnow = priv->icount; 
    2401                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
    2402                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 
    2403                                 return -EIO; /* no change => error */ 
    24042408                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 
    24052409                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 
    … …  
    24102414                        cprev = cnow; 
    24112415                } 
    2412                 /* not reached */ 
     2416                return -EIO; 
    24132417                break; 
    24142418        case TIOCSERGETLSR: 

  • src/linux/universal/linux-3.3/drivers/usb/serial/option.c

    r18879 r19073  
    718718        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED) }, 
    719719        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_HIGHSPEED) }, 
     720        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED) }, 
    720721        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED3) }, 
    721722        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_HIGHSPEED4) }, 

  • src/linux/universal/linux-3.3/drivers/usb/serial/pl2303.c

    r18778 r19073  
    422422        if ((cflag & CBAUD) == B0) 
    423423                priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 
    424         else 
     424        else if ((old_termios->c_cflag & CBAUD) == B0) 
    425425                priv->line_control |= (CONTROL_DTR | CONTROL_RTS); 
    426426        if (control != priv->line_control) { 

  • src/linux/universal/linux-3.3/drivers/usb/serial/sierra.c

    r18778 r19073  
    290290        { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */ 
    291291        { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */ 
     292        { USB_DEVICE(0x1199, 0x68A2) }, /* Sierra Wireless MC7710 */ 
    292293        /* Sierra Wireless C885 */ 
    293294        { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)}, 

  • src/linux/universal/linux-3.3/drivers/usb/serial/usb-serial.c

    r18778 r19073  
    10651065        } 
    10661066 
     1067        /* Avoid race with tty_open and serial_install by setting the 
     1068         * disconnected flag and not clearing it until all ports have been 
     1069         * registered. 
     1070         */ 
     1071        serial->disconnected = 1; 
     1072 
    10671073        if (get_free_serial(serial, num_ports, &minor) == NULL) { 
    10681074                dev_err(&interface->dev, "No more free serial devices\n"); 
    … …  
    10881094                } 
    10891095        } 
     1096 
     1097        serial->disconnected = 0; 
    10901098 
    10911099        usb_serial_console_init(debug, minor); 

  • src/linux/universal/linux-3.3/drivers/video/uvesafb.c

    r18778 r19073  
    816816        par->ypan = ypan; 
    817817 
    818         if (par->pmi_setpal || par->ypan) 
    819                 uvesafb_vbe_getpmi(task, par); 
     818        if (par->pmi_setpal || par->ypan) { 
     819                if (__supported_pte_mask & _PAGE_NX) { 
     820                        par->pmi_setpal = par->ypan = 0; 
     821                        printk(KERN_WARNING "uvesafb: NX protection is actively." 
     822                                "We have better not to use the PMI.\n"); 
     823                } else { 
     824                        uvesafb_vbe_getpmi(task, par); 
     825                } 
     826        } 
    820827#else 
    821828        /* The protected mode interface is not available on non-x86. */ 

  • src/linux/universal/linux-3.3/fs/btrfs/backref.c

    r18778 r19073  
    117117 */ 
    118118static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
     119                                        int search_commit_root, 
    119120                                        struct __prelim_ref *ref, 
    120121                                        struct ulist *parents) 
    … …  
    132133        if (!path) 
    133134                return -ENOMEM; 
     135        path->search_commit_root = !!search_commit_root; 
    134136 
    135137        root_key.objectid = ref->root_id; 
    … …  
    189191 */ 
    190192static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info, 
     193                                   int search_commit_root, 
    191194                                   struct list_head *head) 
    192195{ 
    … …  
    213216                if (ref->count == 0) 
    214217                        continue; 
    215                 err = __resolve_indirect_ref(fs_info, ref, parents); 
     218                err = __resolve_indirect_ref(fs_info, search_commit_root, 
     219                                             ref, parents); 
    216220                if (err) { 
    217221                        if (ret == 0) 
    … …  
    587591        int info_level = 0; 
    588592        int ret; 
     593        int search_commit_root = (trans == BTRFS_BACKREF_SEARCH_COMMIT_ROOT); 
    589594        struct list_head prefs_delayed; 
    590595        struct list_head prefs; 
    … …  
    601606        if (!path) 
    602607                return -ENOMEM; 
     608        path->search_commit_root = !!search_commit_root; 
    603609 
    604610        /* 
    … …  
    615621        BUG_ON(ret == 0); 
    616622 
    617         /* 
    618          * look if there are updates for this ref queued and lock the head 
    619          */ 
    620         delayed_refs = &trans->transaction->delayed_refs; 
    621         spin_lock(&delayed_refs->lock); 
    622         head = btrfs_find_delayed_ref_head(trans, bytenr); 
    623         if (head) { 
    624                 if (!mutex_trylock(&head->mutex)) { 
    625                         atomic_inc(&head->node.refs); 
    626                         spin_unlock(&delayed_refs->lock); 
    627  
    628                         btrfs_release_path(path); 
    629  
    630                         /* 
    631                          * Mutex was contended, block until it's 
    632                          * released and try again 
    633                          */ 
    634                         mutex_lock(&head->mutex); 
    635                         mutex_unlock(&head->mutex); 
    636                         btrfs_put_delayed_ref(&head->node); 
    637                         goto again; 
    638                 } 
    639                 ret = __add_delayed_refs(head, seq, &info_key, &prefs_delayed); 
    640                 if (ret) { 
    641                         spin_unlock(&delayed_refs->lock); 
    642                         goto out; 
    643                 } 
    644         } 
    645         spin_unlock(&delayed_refs->lock); 
     623        if (trans != BTRFS_BACKREF_SEARCH_COMMIT_ROOT) { 
     624                /* 
     625                 * look if there are updates for this ref queued and lock the 
     626                 * head 
     627                 */ 
     628                delayed_refs = &trans->transaction->delayed_refs; 
     629                spin_lock(&delayed_refs->lock); 
     630                head = btrfs_find_delayed_ref_head(trans, bytenr); 
     631                if (head) { 
     632                        if (!mutex_trylock(&head->mutex)) { 
     633                                atomic_inc(&head->node.refs); 
     634                                spin_unlock(&delayed_refs->lock); 
     635 
     636                                btrfs_release_path(path); 
     637 
     638                                /* 
     639                                 * Mutex was contended, block until it's 
     640                                 * released and try again 
     641                                 */ 
     642                                mutex_lock(&head->mutex); 
     643                                mutex_unlock(&head->mutex); 
     644                                btrfs_put_delayed_ref(&head->node); 
     645                                goto again; 
     646                        } 
     647                        ret = __add_delayed_refs(head, seq, &info_key, 
     648                                                 &prefs_delayed); 
     649                        if (ret) { 
     650                                spin_unlock(&delayed_refs->lock); 
     651                                goto out; 
     652                        } 
     653                } 
     654                spin_unlock(&delayed_refs->lock); 
     655        } 
    646656 
    647657        if (path->slots[0]) { 
    … …  
    680690                goto out; 
    681691 
    682         ret = __resolve_indirect_refs(fs_info, &prefs); 
     692        ret = __resolve_indirect_refs(fs_info, search_commit_root, &prefs); 
    683693        if (ret) 
    684694                goto out; 
    … …  
    10751085} 
    10761086 
    1077 static int iterate_leaf_refs(struct btrfs_fs_info *fs_info, 
    1078                                 struct btrfs_path *path, u64 logical, 
     1087static int iterate_leaf_refs(struct btrfs_fs_info *fs_info, u64 logical, 
    10791088                                u64 orig_extent_item_objectid, 
    10801089                                u64 extent_item_pos, u64 root, 
    … …  
    11441153 * the given parameters. 
    11451154 * when the iterator function returns a non-zero value, iteration stops. 
    1146  * path is guaranteed to be in released state when iterate() is called. 
    11471155 */ 
    11481156int iterate_extent_inodes(struct btrfs_fs_info *fs_info, 
    1149                                 struct btrfs_path *path, 
    11501157                                u64 extent_item_objectid, u64 extent_item_pos, 
     1158                                int search_commit_root, 
    11511159                                iterate_extent_inodes_t *iterate, void *ctx) 
    11521160{ 
    … …  
    11551163        struct list_head shared_refs = LIST_HEAD_INIT(shared_refs); 
    11561164        struct btrfs_trans_handle *trans; 
    1157         struct ulist *refs; 
    1158         struct ulist *roots; 
     1165        struct ulist *refs = NULL; 
     1166        struct ulist *roots = NULL; 
    11591167        struct ulist_node *ref_node = NULL; 
    11601168        struct ulist_node *root_node = NULL; 
    11611169        struct seq_list seq_elem; 
    1162         struct btrfs_delayed_ref_root *delayed_refs; 
    1163  
    1164         trans = btrfs_join_transaction(fs_info->extent_root); 
    1165         if (IS_ERR(trans)) 
    1166                 return PTR_ERR(trans); 
     1170        struct btrfs_delayed_ref_root *delayed_refs = NULL; 
    11671171 
    11681172        pr_debug("resolving all inodes for extent %llu\n", 
    11691173                        extent_item_objectid); 
    11701174 
    1171         delayed_refs = &trans->transaction->delayed_refs; 
    1172         spin_lock(&delayed_refs->lock); 
    1173         btrfs_get_delayed_seq(delayed_refs, &seq_elem); 
    1174         spin_unlock(&delayed_refs->lock); 
     1175        if (search_commit_root) { 
     1176                trans = BTRFS_BACKREF_SEARCH_COMMIT_ROOT; 
     1177        } else { 
     1178                trans = btrfs_join_transaction(fs_info->extent_root); 
     1179                if (IS_ERR(trans)) 
     1180                        return PTR_ERR(trans); 
     1181 
     1182                delayed_refs = &trans->transaction->delayed_refs; 
     1183                spin_lock(&delayed_refs->lock); 
     1184                btrfs_get_delayed_seq(delayed_refs, &seq_elem); 
     1185                spin_unlock(&delayed_refs->lock); 
     1186        } 
    11751187 
    11761188        ret = btrfs_find_all_leafs(trans, fs_info, extent_item_objectid, 
    … …  
    11891201                        pr_debug("root %llu references leaf %llu\n", 
    11901202                                        root_node->val, ref_node->val); 
    1191                         ret = iterate_leaf_refs(fs_info, path, ref_node->val, 
     1203                        ret = iterate_leaf_refs(fs_info, ref_node->val, 
    11921204                                                extent_item_objectid, 
    11931205                                                extent_item_pos, root_node->val, 
    … …  
    11991211        ulist_free(roots); 
    12001212out: 
    1201         btrfs_put_delayed_seq(delayed_refs, &seq_elem); 
    1202         btrfs_end_transaction(trans, fs_info->extent_root); 
     1213        if (!search_commit_root) { 
     1214                btrfs_put_delayed_seq(delayed_refs, &seq_elem); 
     1215                btrfs_end_transaction(trans, fs_info->extent_root); 
     1216        } 
     1217 
    12031218        return ret; 
    12041219} 
    … …  
    12111226        u64 extent_item_pos; 
    12121227        struct btrfs_key found_key; 
     1228        int search_commit_root = path->search_commit_root; 
    12131229 
    12141230        ret = extent_from_logical(fs_info, logical, path, 
    … …  
    12211237 
    12221238        extent_item_pos = logical - found_key.objectid; 
    1223         ret = iterate_extent_inodes(fs_info, path, found_key.objectid, 
    1224                                         extent_item_pos, iterate, ctx); 
     1239        ret = iterate_extent_inodes(fs_info, found_key.objectid, 
     1240                                        extent_item_pos, search_commit_root, 
     1241                                        iterate, ctx); 
    12251242 
    12261243        return ret; 

  • src/linux/universal/linux-3.3/fs/btrfs/backref.h

    r18778 r19073  
    2323#include "ulist.h" 
    2424 
     25#define BTRFS_BACKREF_SEARCH_COMMIT_ROOT ((struct btrfs_trans_handle *)0) 
     26 
    2527struct inode_fs_paths { 
    2628        struct btrfs_path               *btrfs_path; 
    … …  
    4547 
    4648int iterate_extent_inodes(struct btrfs_fs_info *fs_info, 
    47                                 struct btrfs_path *path, 
    4849                                u64 extent_item_objectid, 
    49                                 u64 extent_offset, 
     50                                u64 extent_offset, int search_commit_root, 
    5051                                iterate_extent_inodes_t *iterate, void *ctx); 
    5152 

  • src/linux/universal/linux-3.3/fs/btrfs/extent-tree.c

    r18778 r19073  
    41114111 
    41124112        if (num_bytes * 3 > meta_used) 
    4113                 num_bytes = div64_u64(meta_used, 3) * 2; 
     4113                num_bytes = div64_u64(meta_used, 3); 
    41144114 
    41154115        return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10); 

  • src/linux/universal/linux-3.3/fs/btrfs/ioctl.c

    r18778 r19073  
    30673067 
    30683068        extent_item_pos = loi->logical - key.objectid; 
    3069         ret = iterate_extent_inodes(root->fs_info, path, key.objectid, 
    3070                                         extent_item_pos, build_ino_list, 
     3069        ret = iterate_extent_inodes(root->fs_info, key.objectid, 
     3070                                        extent_item_pos, 0, build_ino_list, 
    30713071                                        inodes); 
    30723072 

  • src/linux/universal/linux-3.3/fs/btrfs/scrub.c

    r18778 r19073  
    353353        } else { 
    354354                swarn.path = path; 
    355                 iterate_extent_inodes(fs_info, path, found_key.objectid, 
    356                                         extent_item_pos, 
     355                iterate_extent_inodes(fs_info, found_key.objectid, 
     356                                        extent_item_pos, 1, 
    357357                                        scrub_print_warning_inode, &swarn); 
    358358        } 

  • src/linux/universal/linux-3.3/fs/ext4/ext4.h

    r18879 r19073  
    11961196        unsigned long s_ext_extents; 
    11971197#endif 
    1198         /* ext4 extent cache stats */ 
    1199         unsigned long extent_cache_hits; 
    1200         unsigned long extent_cache_misses; 
    12011198 
    12021199        /* for buddy allocator */ 

  • src/linux/universal/linux-3.3/fs/ext4/extents.c

    r18879 r19073  
    20522052        } 
    20532053errout: 
    2054         if (!ret) 
    2055                 sbi->extent_cache_misses++; 
    2056         else 
    2057                 sbi->extent_cache_hits++; 
    20582054        trace_ext4_ext_in_cache(inode, block, ret); 
    20592055        spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 

  • src/linux/universal/linux-3.3/fs/ext4/super.c

    r18778 r19073  
    25042504} 
    25052505 
    2506 static ssize_t extent_cache_hits_show(struct ext4_attr *a, 
    2507                                       struct ext4_sb_info *sbi, char *buf) 
    2508 { 
    2509         return snprintf(buf, PAGE_SIZE, "%lu\n", sbi->extent_cache_hits); 
    2510 } 
    2511  
    2512 static ssize_t extent_cache_misses_show(struct ext4_attr *a, 
    2513                                         struct ext4_sb_info *sbi, char *buf) 
    2514 { 
    2515         return snprintf(buf, PAGE_SIZE, "%lu\n", sbi->extent_cache_misses); 
    2516 } 
    2517  
    25182506static ssize_t inode_readahead_blks_store(struct ext4_attr *a, 
    25192507                                          struct ext4_sb_info *sbi, 
    … …  
    25732561EXT4_RO_ATTR(session_write_kbytes); 
    25742562EXT4_RO_ATTR(lifetime_write_kbytes); 
    2575 EXT4_RO_ATTR(extent_cache_hits); 
    2576 EXT4_RO_ATTR(extent_cache_misses); 
    25772563EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show, 
    25782564                 inode_readahead_blks_store, s_inode_readahead_blks); 
    … …  
    25902576        ATTR_LIST(session_write_kbytes), 
    25912577        ATTR_LIST(lifetime_write_kbytes), 
    2592         ATTR_LIST(extent_cache_hits), 
    2593         ATTR_LIST(extent_cache_misses), 
    25942578        ATTR_LIST(inode_readahead_blks), 
    25952579        ATTR_LIST(inode_goal), 

  • src/linux/universal/linux-3.3/include/linux/serial_core.h

    r18778 r19073  
    360360#define UPF_SHARE_IRQ           ((__force upf_t) (1 << 24)) 
    361361#define UPF_EXAR_EFR            ((__force upf_t) (1 << 25)) 
    362 #define UPF_IIR_ONCE            ((__force upf_t) (1 << 26)) 
     362#define UPF_BUG_THRE            ((__force upf_t) (1 << 26)) 
    363363/* The exact UART type is known and should not be probed.  */ 
    364364#define UPF_FIXED_TYPE          ((__force upf_t) (1 << 27)) 

  • src/linux/universal/linux-3.3/include/net/bluetooth/hci.h

    r18778 r19073  
    8585        HCI_LINK_KEYS, 
    8686        HCI_DEBUG_KEYS, 
     87        HCI_UNREGISTER, 
    8788 
    8889        HCI_RESET, 

  • src/linux/universal/linux-3.3/kernel/futex.c

    r18879 r19073  
    6060#include <linux/pid.h> 
    6161#include <linux/nsproxy.h> 
     62#include <linux/ptrace.h> 
    6263 
    6364#include <asm/futex.h> 
    … …  
    24442445        struct robust_list_head __user *head; 
    24452446        unsigned long ret; 
    2446         const struct cred *cred = current_cred(), *pcred; 
     2447        struct task_struct *p; 
    24472448 
    24482449        if (!futex_cmpxchg_enabled) 
    24492450                return -ENOSYS; 
    24502451 
     2452        rcu_read_lock(); 
     2453 
     2454        ret = -ESRCH; 
    24512455        if (!pid) 
    2452                 head = current->robust_list; 
     2456                p = current; 
    24532457        else { 
    2454                 struct task_struct *p; 
    2455  
    2456                 ret = -ESRCH; 
    2457                 rcu_read_lock(); 
    24582458                p = find_task_by_vpid(pid); 
    24592459                if (!p) 
    24602460                        goto err_unlock; 
    2461                 ret = -EPERM; 
    2462                 pcred = __task_cred(p); 
    2463                 /* If victim is in different user_ns, then uids are not 
    2464                    comparable, so we must have CAP_SYS_PTRACE */ 
    2465                 if (cred->user->user_ns != pcred->user->user_ns) { 
    2466                         if (!ns_capable(pcred->user->user_ns, CAP_SYS_PTRACE)) 
    2467                                 goto err_unlock; 
    2468                         goto ok; 
    2469                 } 
    2470                 /* If victim is in same user_ns, then uids are comparable */ 
    2471                 if (cred->euid != pcred->euid && 
    2472                     cred->euid != pcred->uid && 
    2473                     !ns_capable(pcred->user->user_ns, CAP_SYS_PTRACE)) 
    2474                         goto err_unlock; 
    2475 ok: 
    2476                 head = p->robust_list; 
    2477                 rcu_read_unlock(); 
    2478         } 
     2461        } 
     2462 
     2463        ret = -EPERM; 
     2464        if (!ptrace_may_access(p, PTRACE_MODE_READ)) 
     2465                goto err_unlock; 
     2466 
     2467        head = p->robust_list; 
     2468        rcu_read_unlock(); 
    24792469 
    24802470        if (put_user(sizeof(*head), len_ptr)) 

  • src/linux/universal/linux-3.3/kernel/futex_compat.c

    r18778 r19073  
    1111#include <linux/nsproxy.h> 
    1212#include <linux/futex.h> 
     13#include <linux/ptrace.h> 
    1314 
    1415#include <asm/uaccess.h> 
    … …  
    137138        struct compat_robust_list_head __user *head; 
    138139        unsigned long ret; 
    139         const struct cred *cred = current_cred(), *pcred; 
     140        struct task_struct *p; 
    140141 
    141142        if (!futex_cmpxchg_enabled) 
    142143                return -ENOSYS; 
    143144 
     145        rcu_read_lock(); 
     146 
     147        ret = -ESRCH; 
    144148        if (!pid) 
    145                 head = current->compat_robust_list; 
     149                p = current; 
    146150        else { 
    147                 struct task_struct *p; 
    148  
    149                 ret = -ESRCH; 
    150                 rcu_read_lock(); 
    151151                p = find_task_by_vpid(pid); 
    152152                if (!p) 
    153153                        goto err_unlock; 
    154                 ret = -EPERM; 
    155                 pcred = __task_cred(p); 
    156                 /* If victim is in different user_ns, then uids are not 
    157                    comparable, so we must have CAP_SYS_PTRACE */ 
    158                 if (cred->user->user_ns != pcred->user->user_ns) { 
    159                         if (!ns_capable(pcred->user->user_ns, CAP_SYS_PTRACE)) 
    160                                 goto err_unlock; 
    161                         goto ok; 
    162                 } 
    163                 /* If victim is in same user_ns, then uids are comparable */ 
    164                 if (cred->euid != pcred->euid && 
    165                     cred->euid != pcred->uid && 
    166                     !ns_capable(pcred->user->user_ns, CAP_SYS_PTRACE)) 
    167                         goto err_unlock; 
    168 ok: 
    169                 head = p->compat_robust_list; 
    170                 rcu_read_unlock(); 
    171         } 
     154        } 
     155 
     156        ret = -EPERM; 
     157        if (!ptrace_may_access(p, PTRACE_MODE_READ)) 
     158                goto err_unlock; 
     159 
     160        head = p->compat_robust_list; 
     161        rcu_read_unlock(); 
    172162 
    173163        if (put_user(sizeof(*head), len_ptr)) 

  • src/linux/universal/linux-3.3/kernel/panic.c

    r18778 r19073  
    9898         * Avoid nested stack-dumping if a panic occurs during oops processing 
    9999         */ 
    100         if (!oops_in_progress) 
     100        if (!test_taint(TAINT_DIE) && oops_in_progress <= 1) 
    101101                dump_stack(); 
    102102#endif 

  • src/linux/universal/linux-3.3/kernel/time/tick-sched.c

    r18778 r19073  
    539539                                break; 
    540540                } 
    541                 /* Update jiffies and reread time */ 
     541                /* Reread time and update jiffies */ 
     542                now = ktime_get(); 
    542543                tick_do_update_jiffies64(now); 
    543                 now = ktime_get(); 
    544544        } 
    545545} 

  • src/linux/universal/linux-3.3/mm/hugetlb.c

    r18778 r19073  
    27012701         */ 
    27022702        page = pte_page(entry); 
     2703        get_page(page); 
    27032704        if (page != pagecache_page) 
    27042705                lock_page(page); 
    … …  
    27322733        if (page != pagecache_page) 
    27332734                unlock_page(page); 
     2735        put_page(page); 
    27342736 
    27352737out_mutex: 

  • src/linux/universal/linux-3.3/mm/memcontrol.c

    r18879 r19073  
    33513351         * LRU while we overwrite pc->mem_cgroup. 
    33523352         */ 
     3353        pc = lookup_page_cgroup(newpage); 
    33533354        __mem_cgroup_commit_charge(memcg, newpage, 1, pc, type, true); 
    33543355} 

  • src/linux/universal/linux-3.3/net/bluetooth/hci_conn.c

    r18778 r19073  
    280280        struct hci_conn *conn = container_of(work, struct hci_conn, 
    281281                                                        disc_work.work); 
    282         struct hci_dev *hdev = conn->hdev; 
    283282        __u8 reason; 
    284283 
    … …  
    287286        if (atomic_read(&conn->refcnt)) 
    288287                return; 
    289  
    290         hci_dev_lock(hdev); 
    291288 
    292289        switch (conn->state) { 
    … …  
    309306                break; 
    310307        } 
    311  
    312         hci_dev_unlock(hdev); 
    313308} 
    314309 

  • src/linux/universal/linux-3.3/net/bluetooth/hci_core.c

    r18778 r19073  
    526526        hci_req_lock(hdev); 
    527527 
     528        if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 
     529                ret = -ENODEV; 
     530                goto done; 
     531        } 
     532 
    528533        if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 
    529534                ret = -ERFKILL; 
    … …  
    15771582 
    15781583        BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 
     1584 
     1585        set_bit(HCI_UNREGISTER, &hdev->dev_flags); 
    15791586 
    15801587        write_lock(&hci_dev_list_lock); 

  • src/linux/universal/linux-3.3/security/commoncap.c

    r18778 r19073  
    2929#include <linux/securebits.h> 
    3030#include <linux/user_namespace.h> 
     31#include <linux/personality.h> 
    3132 
    3233/* 
    … …  
    504505        } 
    505506skip: 
     507 
     508        /* if we have fs caps, clear dangerous personality flags */ 
     509        if (!cap_issubset(new->cap_permitted, old->cap_permitted)) 
     510                bprm->per_clear |= PER_CLEAR_ON_SETID; 
     511 
    506512 
    507513        /* Don't let someone trace a set[ug]id/setpcap binary with the revised 

  • src/linux/universal/linux-3.3/sound/pci/hda/patch_realtek.c

    r19019 r19073  
    46504650        SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 
    46514651        SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 
     4652        SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 
    46524653        SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 
    46534654        SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 

  • src/linux/universal/linux-3.3/tools/perf/util/hist.c

    r18778 r19073  
    231231                        he->period += period; 
    232232                        ++he->nr_events; 
     233 
     234                        /* If the map of an existing hist_entry has 
     235                         * become out-of-date due to an exec() or 
     236                         * similar, update it.  Otherwise we will 
     237                         * mis-adjust symbol addresses when computing 
     238                         * the history counter to increment. 
     239                         */ 
     240                        if (he->ms.map != entry->ms.map) { 
     241                                he->ms.map = entry->ms.map; 
     242                                if (he->ms.map) 
     243                                        he->ms.map->referenced = true; 
     244                        } 
    233245                        goto out; 
    234246                } 
Note: See TracChangeset for help on using the changeset viewer.