Conflicts: arch/x86/kernel/module.c Merge reason: Resolve the conflict, pick up fixes.
Unified · Split
| @@ -3554,12 +3554,12 @@ E: cvance@nai.com · 3553 unmodified lines | ||
| 3554 | 3554 | D: portions of the Linux Security Module (LSM) framework and security modules |
| 3555 | 3555 | |
| 3556 | 3556 | N: Petr Vandrovec |
| 3557 | −E: vandrove@vc.cvut.cz | |
| 3557 | +E: petr@vandrovec.name | |
| 3558 | 3558 | D: Small contributions to ncpfs |
| 3559 | 3559 | D: Matrox framebuffer driver |
| 3560 | −S: Chudenicka 8 | |
| 3561 | −S: 10200 Prague 10, Hostivar | |
| 3562 | −S: Czech Republic | |
| 3560 | +S: 21513 Conradia Ct | |
| 3561 | +S: Cupertino, CA 95014 | |
| 3562 | +S: USA | |
| 3563 | 3563 | |
| 3564 | 3564 | N: Thibaut Varene |
| 3565 | 3565 | E: T-Bone@parisc-linux.org |
| @@ -962,6 +962,13 @@ W: http://www.fluff.org/ben/linux/ · 961 unmodified lines | ||
| 962 | 962 | S: Maintained |
| 963 | 963 | F: arch/arm/mach-s3c6410/ |
| 964 | 964 | |
| 965 | +ARM/S5P ARM ARCHITECTURES | |
| 966 | +M: Kukjin Kim <kgene.kim@samsung.com> | |
| 967 | +L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) | |
| 968 | +L: linux-samsung-soc@vger.kernel.org (moderated for non-subscribers) | |
| 969 | +S: Maintained | |
| 970 | +F: arch/arm/mach-s5p*/ | |
| 971 | + | |
| 965 | 972 | ARM/SHMOBILE ARM ARCHITECTURE |
| 966 | 973 | M: Paul Mundt <lethal@linux-sh.org> |
| 967 | 974 | M: Magnus Damm <magnus.damm@gmail.com> |
| @@ -1220,7 +1227,7 @@ F: drivers/auxdisplay/ · 252 unmodified lines | ||
| 1220 | 1227 | F: include/linux/cfag12864b.h |
| 1221 | 1228 | |
| 1222 | 1229 | AVR32 ARCHITECTURE |
| 1223 | −M: Haavard Skinnemoen <hskinnemoen@atmel.com> | |
| 1230 | +M: Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com> | |
| 1224 | 1231 | W: http://www.atmel.com/products/AVR32/ |
| 1225 | 1232 | W: http://avr32linux.org/ |
| 1226 | 1233 | W: http://avrfreaks.net/ |
| @@ -1228,7 +1235,7 @@ S: Supported · 1 unmodified line | ||
| 1228 | 1235 | F: arch/avr32/ |
| 1229 | 1236 | |
| 1230 | 1237 | AVR32/AT32AP MACHINE SUPPORT |
| 1231 | −M: Haavard Skinnemoen <hskinnemoen@atmel.com> | |
| 1238 | +M: Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com> | |
| 1232 | 1239 | S: Supported |
| 1233 | 1240 | F: arch/avr32/mach-at32ap/ |
| 1234 | 1241 | |
| @@ -2199,6 +2206,12 @@ W: http://acpi4asus.sf.net · 964 unmodified lines | ||
| 2199 | 2206 | S: Maintained |
| 2200 | 2207 | F: drivers/platform/x86/eeepc-laptop.c |
| 2201 | 2208 | |
| 2209 | +EFIFB FRAMEBUFFER DRIVER | |
| 2210 | +L: linux-fbdev@vger.kernel.org | |
| 2211 | +M: Peter Jones <pjones@redhat.com> | |
| 2212 | +S: Maintained | |
| 2213 | +F: drivers/video/efifb.c | |
| 2214 | + | |
| 2202 | 2215 | EFS FILESYSTEM |
| 2203 | 2216 | W: http://aeschi.ch.eu.org/efs/ |
| 2204 | 2217 | S: Orphan |
| @@ -2662,6 +2675,8 @@ M: Guenter Roeck <guenter.roeck@ericsson.com> · 457 unmodified lines | ||
| 2662 | 2675 | L: lm-sensors@lm-sensors.org |
| 2663 | 2676 | W: http://www.lm-sensors.org/ |
| 2664 | 2677 | T: quilt kernel.org/pub/linux/kernel/people/jdelvare/linux-2.6/jdelvare-hwmon/ |
| 2678 | +T: quilt kernel.org/pub/linux/kernel/people/groeck/linux-staging/ | |
| 2679 | +T: git git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git | |
| 2665 | 2680 | S: Maintained |
| 2666 | 2681 | F: Documentation/hwmon/ |
| 2667 | 2682 | F: drivers/hwmon/ |
| @@ -3773,9 +3788,8 @@ W: http://www.syskonnect.com · 1105 unmodified lines | ||
| 3773 | 3788 | S: Supported |
| 3774 | 3789 | |
| 3775 | 3790 | MATROX FRAMEBUFFER DRIVER |
| 3776 | −M: Petr Vandrovec <vandrove@vc.cvut.cz> | |
| 3777 | 3791 | L: linux-fbdev@vger.kernel.org |
| 3778 | −S: Maintained | |
| 3792 | +S: Orphan | |
| 3779 | 3793 | F: drivers/video/matrox/matroxfb_* |
| 3780 | 3794 | F: include/linux/matroxfb.h |
| 3781 | 3795 | |
| @@ -3899,10 +3913,8 @@ F: Documentation/serial/moxa-smartio · 117 unmodified lines | ||
| 3899 | 3913 | F: drivers/char/mxser.* |
| 3900 | 3914 | |
| 3901 | 3915 | MSI LAPTOP SUPPORT |
| 3902 | −M: Lennart Poettering <mzxreary@0pointer.de> | |
| 3916 | +M: Lee, Chun-Yi <jlee@novell.com> | |
| 3903 | 3917 | L: platform-driver-x86@vger.kernel.org |
| 3904 | −W: https://tango.0pointer.de/mailman/listinfo/s270-linux | |
| 3905 | −W: http://0pointer.de/lennart/tchibo.html | |
| 3906 | 3918 | S: Maintained |
| 3907 | 3919 | F: drivers/platform/x86/msi-laptop.c |
| 3908 | 3920 | |
| @@ -3919,8 +3931,10 @@ S: Supported · 10 unmodified lines | ||
| 3919 | 3931 | F: drivers/mfd/ |
| 3920 | 3932 | |
| 3921 | 3933 | MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND SDIO SUBSYSTEM |
| 3922 | −S: Orphan | |
| 3934 | +M: Chris Ball <cjb@laptop.org> | |
| 3923 | 3935 | L: linux-mmc@vger.kernel.org |
| 3936 | +T: git git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc.git | |
| 3937 | +S: Maintained | |
| 3924 | 3938 | F: drivers/mmc/ |
| 3925 | 3939 | F: include/linux/mmc/ |
| 3926 | 3940 | |
| @@ -3962,8 +3976,8 @@ S: Maintained · 35 unmodified lines | ||
| 3962 | 3976 | F: drivers/net/natsemi.c |
| 3963 | 3977 | |
| 3964 | 3978 | NCP FILESYSTEM |
| 3965 | −M: Petr Vandrovec <vandrove@vc.cvut.cz> | |
| 3966 | −S: Maintained | |
| 3979 | +M: Petr Vandrovec <petr@vandrovec.name> | |
| 3980 | +S: Odd Fixes | |
| 3967 | 3981 | F: fs/ncpfs/ |
| 3968 | 3982 | |
| 3969 | 3983 | NCR DUAL 700 SCSI DRIVER (MICROCHANNEL) |
| @@ -5091,8 +5105,10 @@ S: Maintained · 1121 unmodified lines | ||
| 5091 | 5105 | F: drivers/mmc/host/sdricoh_cs.c |
| 5092 | 5106 | |
| 5093 | 5107 | SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) DRIVER |
| 5094 | −S: Orphan | |
| 5108 | +M: Chris Ball <cjb@laptop.org> | |
| 5095 | 5109 | L: linux-mmc@vger.kernel.org |
| 5110 | +T: git git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc.git | |
| 5111 | +S: Maintained | |
| 5096 | 5112 | F: drivers/mmc/host/sdhci.* |
| 5097 | 5113 | |
| 5098 | 5114 | SECURE DIGITAL HOST CONTROLLER INTERFACE, OPEN FIRMWARE BINDINGS (SDHCI-OF) |
| @@ -1,7 +1,7 @@ | ||
| 1 | 1 | VERSION = 2 |
| 2 | 2 | PATCHLEVEL = 6 |
| 3 | 3 | SUBLEVEL = 36 |
| 4 | −EXTRAVERSION = -rc5 | |
| 4 | +EXTRAVERSION = -rc7 | |
| 5 | 5 | NAME = Sheep on Meth |
| 6 | 6 | |
| 7 | 7 | # *DOCUMENTATION* |
| @@ -73,8 +73,6 @@ · 72 unmodified lines | ||
| 73 | 73 | ldq $20, HAE_REG($19); \ |
| 74 | 74 | stq $21, HAE_CACHE($19); \ |
| 75 | 75 | stq $21, 0($20); \ |
| 76 | − ldq $0, 0($sp); \ | |
| 77 | − ldq $1, 8($sp); \ | |
| 78 | 76 | 99:; \ |
| 79 | 77 | ldq $19, 72($sp); \ |
| 80 | 78 | ldq $20, 80($sp); \ |
| @@ -316,7 +314,7 @@ ret_from_sys_call: · 235 unmodified lines | ||
| 316 | 314 | cmovne $26, 0, $19 /* $19 = 0 => non-restartable */ |
| 317 | 315 | ldq $0, SP_OFF($sp) |
| 318 | 316 | and $0, 8, $0 |
| 319 | − beq $0, restore_all | |
| 317 | + beq $0, ret_to_kernel | |
| 320 | 318 | ret_to_user: |
| 321 | 319 | /* Make sure need_resched and sigpending don't change between |
| 322 | 320 | sampling and the rti. */ |
| @@ -329,6 +327,11 @@ restore_all: · 6 unmodified lines | ||
| 329 | 327 | RESTORE_ALL |
| 330 | 328 | call_pal PAL_rti |
| 331 | 329 | |
| 330 | +ret_to_kernel: | |
| 331 | + lda $16, 7 | |
| 332 | + call_pal PAL_swpipl | |
| 333 | + br restore_all | |
| 334 | + | |
| 332 | 335 | .align 3 |
| 333 | 336 | $syscall_error: |
| 334 | 337 | /* |
| @@ -657,7 +660,7 @@ kernel_thread: · 322 unmodified lines | ||
| 657 | 660 | /* We don't actually care for a3 success widgetry in the kernel. |
| 658 | 661 | Not for positive errno values. */ |
| 659 | 662 | stq $0, 0($sp) /* $0 */ |
| 660 | − br restore_all | |
| 663 | + br ret_to_kernel | |
| 661 | 664 | .end kernel_thread |
| 662 | 665 | |
| 663 | 666 | /* |
| @@ -911,15 +914,6 @@ sys_execve: · 247 unmodified lines | ||
| 911 | 914 | jmp $31, do_sys_execve |
| 912 | 915 | .end sys_execve |
| 913 | 916 | |
| 914 | − .align 4 | |
| 915 | − .globl osf_sigprocmask | |
| 916 | − .ent osf_sigprocmask | |
| 917 | −osf_sigprocmask: | |
| 918 | − .prologue 0 | |
| 919 | − mov $sp, $18 | |
| 920 | − jmp $31, sys_osf_sigprocmask | |
| 921 | −.end osf_sigprocmask | |
| 922 | − | |
| 923 | 917 | .align 4 |
| 924 | 918 | .globl alpha_ni_syscall |
| 925 | 919 | .ent alpha_ni_syscall |
| @@ -356,7 +356,7 @@ dump_elf_thread(elf_greg_t *dest, struct pt_regs *pt, struct thread_info *ti) · 355 unmodified lines | ||
| 356 | 356 | dest[27] = pt->r27; |
| 357 | 357 | dest[28] = pt->r28; |
| 358 | 358 | dest[29] = pt->gp; |
| 359 | − dest[30] = rdusp(); | |
| 359 | + dest[30] = ti == current_thread_info() ? rdusp() : ti->pcb.usp; | |
| 360 | 360 | dest[31] = pt->pc; |
| 361 | 361 | |
| 362 | 362 | /* Once upon a time this was the PS value. Which is stupid |
| @@ -41,46 +41,20 @@ static void do_signal(struct pt_regs *, struct switch_stack *, · 40 unmodified lines | ||
| 41 | 41 | /* |
| 42 | 42 | * The OSF/1 sigprocmask calling sequence is different from the |
| 43 | 43 | * C sigprocmask() sequence.. |
| 44 | − * | |
| 45 | − * how: | |
| 46 | − * 1 - SIG_BLOCK | |
| 47 | − * 2 - SIG_UNBLOCK | |
| 48 | − * 3 - SIG_SETMASK | |
| 49 | − * | |
| 50 | − * We change the range to -1 .. 1 in order to let gcc easily | |
| 51 | − * use the conditional move instructions. | |
| 52 | − * | |
| 53 | − * Note that we don't need to acquire the kernel lock for SMP | |
| 54 | − * operation, as all of this is local to this thread. | |
| 55 | 44 | */ |
| 56 | −SYSCALL_DEFINE3(osf_sigprocmask, int, how, unsigned long, newmask, | |
| 57 | − struct pt_regs *, regs) | |
| 45 | +SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask) | |
| 58 | 46 | { |
| 59 | − unsigned long oldmask = -EINVAL; | |
| 60 | − | |
| 61 | − if ((unsigned long)how-1 <= 2) { | |
| 62 | − long sign = how-2; /* -1 .. 1 */ | |
| 63 | − unsigned long block, unblock; | |
| 64 | − | |
| 65 | − newmask &= _BLOCKABLE; | |
| 66 | − spin_lock_irq(¤t->sighand->siglock); | |
| 67 | − oldmask = current->blocked.sig[0]; | |
| 68 | − | |
| 69 | − unblock = oldmask & ~newmask; | |
| 70 | − block = oldmask | newmask; | |
| 71 | − if (!sign) | |
| 72 | − block = unblock; | |
| 73 | − if (sign <= 0) | |
| 74 | − newmask = block; | |
| 75 | − if (_NSIG_WORDS > 1 && sign > 0) | |
| 76 | − sigemptyset(¤t->blocked); | |
| 77 | − current->blocked.sig[0] = newmask; | |
| 78 | − recalc_sigpending(); | |
| 79 | − spin_unlock_irq(¤t->sighand->siglock); | |
| 80 | − | |
| 81 | − regs->r0 = 0; /* special no error return */ | |
| 47 | + sigset_t oldmask; | |
| 48 | + sigset_t mask; | |
| 49 | + unsigned long res; | |
| 50 | + | |
| 51 | + siginitset(&mask, newmask & _BLOCKABLE); | |
| 52 | + res = sigprocmask(how, &mask, &oldmask); | |
| 53 | + if (!res) { | |
| 54 | + force_successful_syscall_return(); | |
| 55 | + res = oldmask.sig[0]; | |
| 82 | 56 | } |
| 83 | − return oldmask; | |
| 57 | + return res; | |
| 84 | 58 | } |
| 85 | 59 | |
| 86 | 60 | SYSCALL_DEFINE3(osf_sigaction, int, sig, |
| @@ -94,9 +68,9 @@ SYSCALL_DEFINE3(osf_sigaction, int, sig, · 7 unmodified lines | ||
| 94 | 68 | old_sigset_t mask; |
| 95 | 69 | if (!access_ok(VERIFY_READ, act, sizeof(*act)) || |
| 96 | 70 | __get_user(new_ka.sa.sa_handler, &act->sa_handler) || |
| 97 | − __get_user(new_ka.sa.sa_flags, &act->sa_flags)) | |
| 71 | + __get_user(new_ka.sa.sa_flags, &act->sa_flags) || | |
| 72 | + __get_user(mask, &act->sa_mask)) | |
| 98 | 73 | return -EFAULT; |
| 99 | − __get_user(mask, &act->sa_mask); | |
| 100 | 74 | siginitset(&new_ka.sa.sa_mask, mask); |
| 101 | 75 | new_ka.ka_restorer = NULL; |
| 102 | 76 | } |
| @@ -106,9 +80,9 @@ SYSCALL_DEFINE3(osf_sigaction, int, sig, · 3 unmodified lines | ||
| 106 | 80 | if (!ret && oact) { |
| 107 | 81 | if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || |
| 108 | 82 | __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || |
| 109 | − __put_user(old_ka.sa.sa_flags, &oact->sa_flags)) | |
| 83 | + __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || | |
| 84 | + __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) | |
| 110 | 85 | return -EFAULT; |
| 111 | − __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); | |
| 112 | 86 | } |
| 113 | 87 | |
| 114 | 88 | return ret; |
| @@ -58,7 +58,7 @@ sys_call_table: · 57 unmodified lines | ||
| 58 | 58 | .quad sys_open /* 45 */ |
| 59 | 59 | .quad alpha_ni_syscall |
| 60 | 60 | .quad sys_getxgid |
| 61 | − .quad osf_sigprocmask | |
| 61 | + .quad sys_osf_sigprocmask | |
| 62 | 62 | .quad alpha_ni_syscall |
| 63 | 63 | .quad alpha_ni_syscall /* 50 */ |
| 64 | 64 | .quad sys_acct |
| @@ -271,7 +271,6 @@ config ARCH_AT91 · 270 unmodified lines | ||
| 271 | 271 | bool "Atmel AT91" |
| 272 | 272 | select ARCH_REQUIRE_GPIOLIB |
| 273 | 273 | select HAVE_CLK |
| 274 | − select ARCH_USES_GETTIMEOFFSET | |
| 275 | 274 | help |
| 276 | 275 | This enables support for systems based on the Atmel AT91RM9200, |
| 277 | 276 | AT91SAM9 and AT91CAP9 processors. |
| @@ -1051,6 +1050,32 @@ config ARM_ERRATA_460075 · 773 unmodified lines | ||
| 1051 | 1050 | ACTLR register. Note that setting specific bits in the ACTLR register |
| 1052 | 1051 | may not be available in non-secure mode. |
| 1053 | 1052 | |
| 1053 | +config ARM_ERRATA_742230 | |
| 1054 | + bool "ARM errata: DMB operation may be faulty" | |
| 1055 | + depends on CPU_V7 && SMP | |
| 1056 | + help | |
| 1057 | + This option enables the workaround for the 742230 Cortex-A9 | |
| 1058 | + (r1p0..r2p2) erratum. Under rare circumstances, a DMB instruction | |
| 1059 | + between two write operations may not ensure the correct visibility | |
| 1060 | + ordering of the two writes. This workaround sets a specific bit in | |
| 1061 | + the diagnostic register of the Cortex-A9 which causes the DMB | |
| 1062 | + instruction to behave as a DSB, ensuring the correct behaviour of | |
| 1063 | + the two writes. | |
| 1064 | + | |
| 1065 | +config ARM_ERRATA_742231 | |
| 1066 | + bool "ARM errata: Incorrect hazard handling in the SCU may lead to data corruption" | |
| 1067 | + depends on CPU_V7 && SMP | |
| 1068 | + help | |
| 1069 | + This option enables the workaround for the 742231 Cortex-A9 | |
| 1070 | + (r2p0..r2p2) erratum. Under certain conditions, specific to the | |
| 1071 | + Cortex-A9 MPCore micro-architecture, two CPUs working in SMP mode, | |
| 1072 | + accessing some data located in the same cache line, may get corrupted | |
| 1073 | + data due to bad handling of the address hazard when the line gets | |
| 1074 | + replaced from one of the CPUs at the same time as another CPU is | |
| 1075 | + accessing it. This workaround sets specific bits in the diagnostic | |
| 1076 | + register of the Cortex-A9 which reduces the linefill issuing | |
| 1077 | + capabilities of the processor. | |
| 1078 | + | |
| 1054 | 1079 | config PL310_ERRATA_588369 |
| 1055 | 1080 | bool "Clean & Invalidate maintenance operations do not invalidate clean lines" |
| 1056 | 1081 | depends on CACHE_L2X0 && ARCH_OMAP4 |
| @@ -116,5 +116,5 @@ CFLAGS_font.o := -Dstatic= · 115 unmodified lines | ||
| 116 | 116 | $(obj)/font.c: $(FONTC) |
| 117 | 117 | $(call cmd,shipped) |
| 118 | 118 | |
| 119 | −$(obj)/vmlinux.lds: $(obj)/vmlinux.lds.in arch/arm/boot/Makefile .config | |
| 119 | +$(obj)/vmlinux.lds: $(obj)/vmlinux.lds.in arch/arm/boot/Makefile $(KCONFIG_CONFIG) | |
| 120 | 120 | @sed "$(SEDFLAGS)" < $< > $@ |
| @@ -271,6 +271,14 @@ int dma_needs_bounce(struct device *dev, dma_addr_t dma_addr, size_t size) · 270 unmodified lines | ||
| 271 | 271 | ((dma_addr + size - PHYS_OFFSET) >= SZ_64M); |
| 272 | 272 | } |
| 273 | 273 | |
| 274 | +int dma_set_coherent_mask(struct device *dev, u64 mask) | |
| 275 | +{ | |
| 276 | + if (mask >= PHYS_OFFSET + SZ_64M - 1) | |
| 277 | + return 0; | |
| 278 | + | |
| 279 | + return -EIO; | |
| 280 | +} | |
| 281 | + | |
| 274 | 282 | int __init it8152_pci_setup(int nr, struct pci_sys_data *sys) |
| 275 | 283 | { |
| 276 | 284 | it8152_io.start = IT8152_IO_BASE + 0x12000; |
| @@ -317,6 +317,10 @@ static inline pte_t pte_mkspecial(pte_t pte) { return pte; } · 316 unmodified lines | ||
| 317 | 317 | #ifdef CONFIG_ARM_DMA_MEM_BUFFERABLE |
| 318 | 318 | #define pgprot_dmacoherent(prot) \ |
| 319 | 319 | __pgprot_modify(prot, L_PTE_MT_MASK|L_PTE_EXEC, L_PTE_MT_BUFFERABLE) |
| 320 | +#define __HAVE_PHYS_MEM_ACCESS_PROT | |
| 321 | +struct file; | |
| 322 | +extern pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, | |
| 323 | + unsigned long size, pgprot_t vma_prot); | |
| 320 | 324 | #else |
| 321 | 325 | #define pgprot_dmacoherent(prot) \ |
| 322 | 326 | __pgprot_modify(prot, L_PTE_MT_MASK|L_PTE_EXEC, L_PTE_MT_UNCACHED) |
| @@ -48,6 +48,8 @@ work_pending: · 47 unmodified lines | ||
| 48 | 48 | beq no_work_pending |
| 49 | 49 | mov r0, sp @ 'regs' |
| 50 | 50 | mov r2, why @ 'syscall' |
| 51 | + tst r1, #_TIF_SIGPENDING @ delivering a signal? | |
| 52 | + movne why, #0 @ prevent further restarts | |
| 51 | 53 | bl do_notify_resume |
| 52 | 54 | b ret_slow_syscall @ Check work again |
| 53 | 55 | |
| @@ -426,7 +426,7 @@ static struct i2c_gpio_platform_data pdata_i2c0 = { · 425 unmodified lines | ||
| 426 | 426 | .sda_is_open_drain = 1, |
| 427 | 427 | .scl_pin = AT91_PIN_PA21, |
| 428 | 428 | .scl_is_open_drain = 1, |
| 429 | − .udelay = 2, /* ~100 kHz */ | |
| 429 | + .udelay = 5, /* ~100 kHz */ | |
| 430 | 430 | }; |
| 431 | 431 | |
| 432 | 432 | static struct platform_device at91sam9g45_twi0_device = { |
| @@ -440,7 +440,7 @@ static struct i2c_gpio_platform_data pdata_i2c1 = { · 7 unmodified lines | ||
| 440 | 440 | .sda_is_open_drain = 1, |
| 441 | 441 | .scl_pin = AT91_PIN_PB11, |
| 442 | 442 | .scl_is_open_drain = 1, |
| 443 | − .udelay = 2, /* ~100 kHz */ | |
| 443 | + .udelay = 5, /* ~100 kHz */ | |
| 444 | 444 | }; |
| 445 | 445 | |
| 446 | 446 | static struct platform_device at91sam9g45_twi1_device = { |
| @@ -769,8 +769,7 @@ static struct map_desc dm355_io_desc[] = { · 768 unmodified lines | ||
| 769 | 769 | .virtual = SRAM_VIRT, |
| 770 | 770 | .pfn = __phys_to_pfn(0x00010000), |
| 771 | 771 | .length = SZ_32K, |
| 772 | − /* MT_MEMORY_NONCACHED requires supersection alignment */ | |
| 773 | − .type = MT_DEVICE, | |
| 772 | + .type = MT_MEMORY_NONCACHED, | |
| 774 | 773 | }, |
| 775 | 774 | }; |
| 776 | 775 | |
| @@ -969,8 +969,7 @@ static struct map_desc dm365_io_desc[] = { · 968 unmodified lines | ||
| 969 | 969 | .virtual = SRAM_VIRT, |
| 970 | 970 | .pfn = __phys_to_pfn(0x00010000), |
| 971 | 971 | .length = SZ_32K, |
| 972 | − /* MT_MEMORY_NONCACHED requires supersection alignment */ | |
| 973 | − .type = MT_DEVICE, | |
| 972 | + .type = MT_MEMORY_NONCACHED, | |
| 974 | 973 | }, |
| 975 | 974 | }; |
| 976 | 975 | |
| @@ -653,8 +653,7 @@ static struct map_desc dm644x_io_desc[] = { · 652 unmodified lines | ||
| 653 | 653 | .virtual = SRAM_VIRT, |
| 654 | 654 | .pfn = __phys_to_pfn(0x00008000), |
| 655 | 655 | .length = SZ_16K, |
| 656 | − /* MT_MEMORY_NONCACHED requires supersection alignment */ | |
| 657 | − .type = MT_DEVICE, | |
| 656 | + .type = MT_MEMORY_NONCACHED, | |
| 658 | 657 | }, |
| 659 | 658 | }; |
| 660 | 659 | |
| @@ -737,8 +737,7 @@ static struct map_desc dm646x_io_desc[] = { · 736 unmodified lines | ||
| 737 | 737 | .virtual = SRAM_VIRT, |
| 738 | 738 | .pfn = __phys_to_pfn(0x00010000), |
| 739 | 739 | .length = SZ_32K, |
| 740 | − /* MT_MEMORY_NONCACHED requires supersection alignment */ | |
| 741 | − .type = MT_DEVICE, | |
| 740 | + .type = MT_MEMORY_NONCACHED, | |
| 742 | 741 | }, |
| 743 | 742 | }; |
| 744 | 743 | |
| @@ -13,8 +13,8 @@ · 12 unmodified lines | ||
| 13 | 13 | |
| 14 | 14 | #define IO_SPACE_LIMIT 0xffffffff |
| 15 | 15 | |
| 16 | −#define __io(a) ((void __iomem *)(((a) - DOVE_PCIE0_IO_PHYS_BASE) +\ | |
| 17 | − DOVE_PCIE0_IO_VIRT_BASE)) | |
| 18 | −#define __mem_pci(a) (a) | |
| 16 | +#define __io(a) ((void __iomem *)(((a) - DOVE_PCIE0_IO_BUS_BASE) + \ | |
| 17 | + DOVE_PCIE0_IO_VIRT_BASE)) | |
| 18 | +#define __mem_pci(a) (a) | |
| 19 | 19 | |
| 20 | 20 | #endif |
| @@ -503,6 +503,14 @@ struct pci_bus * __devinit ixp4xx_scan_bus(int nr, struct pci_sys_data *sys) · 502 unmodified lines | ||
| 503 | 503 | return pci_scan_bus(sys->busnr, &ixp4xx_ops, sys); |
| 504 | 504 | } |
| 505 | 505 | |
| 506 | +int dma_set_coherent_mask(struct device *dev, u64 mask) | |
| 507 | +{ | |
| 508 | + if (mask >= SZ_64M - 1) | |
| 509 | + return 0; | |
| 510 | + | |
| 511 | + return -EIO; | |
| 512 | +} | |
| 513 | + | |
| 506 | 514 | EXPORT_SYMBOL(ixp4xx_pci_read); |
| 507 | 515 | EXPORT_SYMBOL(ixp4xx_pci_write); |
| 508 | 516 | |
| @@ -26,6 +26,8 @@ · 25 unmodified lines | ||
| 26 | 26 | #define PCIBIOS_MAX_MEM 0x4BFFFFFF |
| 27 | 27 | #endif |
| 28 | 28 | |
| 29 | +#define ARCH_HAS_DMA_SET_COHERENT_MASK | |
| 30 | + | |
| 29 | 31 | #define pcibios_assign_all_busses() 1 |
| 30 | 32 | |
| 31 | 33 | /* Register locations and bits */ |
| @@ -38,7 +38,7 @@ · 37 unmodified lines | ||
| 38 | 38 | |
| 39 | 39 | #define KIRKWOOD_PCIE1_IO_PHYS_BASE 0xf3000000 |
| 40 | 40 | #define KIRKWOOD_PCIE1_IO_VIRT_BASE 0xfef00000 |
| 41 | −#define KIRKWOOD_PCIE1_IO_BUS_BASE 0x00000000 | |
| 41 | +#define KIRKWOOD_PCIE1_IO_BUS_BASE 0x00100000 | |
| 42 | 42 | #define KIRKWOOD_PCIE1_IO_SIZE SZ_1M |
| 43 | 43 | |
| 44 | 44 | #define KIRKWOOD_PCIE_IO_PHYS_BASE 0xf2000000 |
| @@ -117,7 +117,7 @@ static void __init pcie0_ioresources_init(struct pcie_port *pp) · 116 unmodified lines | ||
| 117 | 117 | * IORESOURCE_IO |
| 118 | 118 | */ |
| 119 | 119 | pp->res[0].name = "PCIe 0 I/O Space"; |
| 120 | − pp->res[0].start = KIRKWOOD_PCIE_IO_PHYS_BASE; | |
| 120 | + pp->res[0].start = KIRKWOOD_PCIE_IO_BUS_BASE; | |
| 121 | 121 | pp->res[0].end = pp->res[0].start + KIRKWOOD_PCIE_IO_SIZE - 1; |
| 122 | 122 | pp->res[0].flags = IORESOURCE_IO; |
| 123 | 123 | |
| @@ -139,7 +139,7 @@ static void __init pcie1_ioresources_init(struct pcie_port *pp) · 15 unmodified lines | ||
| 139 | 139 | * IORESOURCE_IO |
| 140 | 140 | */ |
| 141 | 141 | pp->res[0].name = "PCIe 1 I/O Space"; |
| 142 | − pp->res[0].start = KIRKWOOD_PCIE1_IO_PHYS_BASE; | |
| 142 | + pp->res[0].start = KIRKWOOD_PCIE1_IO_BUS_BASE; | |
| 143 | 143 | pp->res[0].end = pp->res[0].start + KIRKWOOD_PCIE1_IO_SIZE - 1; |
| 144 | 144 | pp->res[0].flags = IORESOURCE_IO; |
| 145 | 145 | |
| @@ -9,6 +9,8 @@ · 8 unmodified lines | ||
| 9 | 9 | #ifndef __ASM_MACH_SYSTEM_H |
| 10 | 10 | #define __ASM_MACH_SYSTEM_H |
| 11 | 11 | |
| 12 | +#include <mach/cputype.h> | |
| 13 | + | |
| 12 | 14 | static inline void arch_idle(void) |
| 13 | 15 | { |
| 14 | 16 | cpu_do_idle(); |
| @@ -16,6 +18,9 @@ static inline void arch_idle(void) · 1 unmodified line | ||
| 16 | 18 | |
| 17 | 19 | static inline void arch_reset(char mode, const char *cmd) |
| 18 | 20 | { |
| 19 | − cpu_reset(0); | |
| 21 | + if (cpu_is_pxa168()) | |
| 22 | + cpu_reset(0xffff0000); | |
| 23 | + else | |
| 24 | + cpu_reset(0); | |
| 20 | 25 | } |
| 21 | 26 | #endif /* __ASM_MACH_SYSTEM_H */ |
| @@ -312,8 +312,7 @@ static int pxa_set_target(struct cpufreq_policy *policy, · 311 unmodified lines | ||
| 312 | 312 | freqs.cpu = policy->cpu; |
| 313 | 313 | |
| 314 | 314 | if (freq_debug) |
| 315 | − pr_debug(KERN_INFO "Changing CPU frequency to %d Mhz, " | |
| 316 | − "(SDRAM %d Mhz)\n", | |
| 315 | + pr_debug("Changing CPU frequency to %d Mhz, (SDRAM %d Mhz)\n", | |
| 317 | 316 | freqs.new / 1000, (pxa_freq_settings[idx].div2) ? |
| 318 | 317 | (new_freq_mem / 2000) : (new_freq_mem / 1000)); |
| 319 | 318 | |
| @@ -264,23 +264,35 @@ · 263 unmodified lines | ||
| 264 | 264 | * <= 0x2 for pxa21x/pxa25x/pxa26x/pxa27x |
| 265 | 265 | * == 0x3 for pxa300/pxa310/pxa320 |
| 266 | 266 | */ |
| 267 | +#if defined(CONFIG_PXA25x) || defined(CONFIG_PXA27x) | |
| 267 | 268 | #define __cpu_is_pxa2xx(id) \ |
| 268 | 269 | ({ \ |
| 269 | 270 | unsigned int _id = (id) >> 13 & 0x7; \ |
| 270 | 271 | _id <= 0x2; \ |
| 271 | 272 | }) |
| 273 | +#else | |
| 274 | +#define __cpu_is_pxa2xx(id) (0) | |
| 275 | +#endif | |
| 272 | 276 | |
| 277 | +#ifdef CONFIG_PXA3xx | |
| 273 | 278 | #define __cpu_is_pxa3xx(id) \ |
| 274 | 279 | ({ \ |
| 275 | 280 | unsigned int _id = (id) >> 13 & 0x7; \ |
| 276 | 281 | _id == 0x3; \ |
| 277 | 282 | }) |
| 283 | +#else | |
| 284 | +#define __cpu_is_pxa3xx(id) (0) | |
| 285 | +#endif | |
| 278 | 286 | |
| 287 | +#if defined(CONFIG_CPU_PXA930) || defined(CONFIG_CPU_PXA935) | |
| 279 | 288 | #define __cpu_is_pxa93x(id) \ |
| 280 | 289 | ({ \ |
| 281 | 290 | unsigned int _id = (id) >> 4 & 0xfff; \ |
| 282 | 291 | _id == 0x683 || _id == 0x693; \ |
| 283 | 292 | }) |
| 293 | +#else | |
| 294 | +#define __cpu_is_pxa93x(id) (0) | |
| 295 | +#endif | |
| 284 | 296 | |
| 285 | 297 | #define cpu_is_pxa2xx() \ |
| 286 | 298 | ({ \ |
| @@ -309,7 +321,7 @@ extern unsigned long get_clock_tick_rate(void); · 22 unmodified lines | ||
| 309 | 321 | #define PCIBIOS_MIN_IO 0 |
| 310 | 322 | #define PCIBIOS_MIN_MEM 0 |
| 311 | 323 | #define pcibios_assign_all_busses() 1 |
| 324 | +#define ARCH_HAS_DMA_SET_COHERENT_MASK | |
| 312 | 325 | #endif |
| 313 | 326 | |
| 314 | − | |
| 315 | 327 | #endif /* _ASM_ARCH_HARDWARE_H */ |
| @@ -6,6 +6,8 @@ · 5 unmodified lines | ||
| 6 | 6 | #ifndef __ASM_ARM_ARCH_IO_H |
| 7 | 7 | #define __ASM_ARM_ARCH_IO_H |
| 8 | 8 | |
| 9 | +#include <mach/hardware.h> | |
| 10 | + | |
| 9 | 11 | #define IO_SPACE_LIMIT 0xffffffff |
| 10 | 12 | |
| 11 | 13 | /* |
| @@ -469,9 +469,13 @@ static struct i2c_board_info __initdata palm27x_pi2c_board_info[] = { · 468 unmodified lines | ||
| 469 | 469 | }, |
| 470 | 470 | }; |
| 471 | 471 | |
| 472 | +static struct i2c_pxa_platform_data palm27x_i2c_power_info = { | |
| 473 | + .use_pio = 1, | |
| 474 | +}; | |
| 475 | + | |
| 472 | 476 | void __init palm27x_pmic_init(void) |
| 473 | 477 | { |
| 474 | 478 | i2c_register_board_info(1, ARRAY_AND_SIZE(palm27x_pi2c_board_info)); |
| 475 | − pxa27x_set_i2c_power_info(NULL); | |
| 479 | + pxa27x_set_i2c_power_info(&palm27x_i2c_power_info); | |
| 476 | 480 | } |
| 477 | 481 | #endif |
| @@ -240,6 +240,7 @@ static void __init vpac270_onenand_init(void) {} · 239 unmodified lines | ||
| 240 | 240 | #if defined(CONFIG_MMC_PXA) || defined(CONFIG_MMC_PXA_MODULE) |
| 241 | 241 | static struct pxamci_platform_data vpac270_mci_platform_data = { |
| 242 | 242 | .ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34, |
| 243 | + .gpio_power = -1, | |
| 243 | 244 | .gpio_card_detect = GPIO53_VPAC270_SD_DETECT_N, |
| 244 | 245 | .gpio_card_ro = GPIO52_VPAC270_SD_READONLY, |
| 245 | 246 | .detect_delay_ms = 200, |
| @@ -273,6 +273,9 @@ extern void gpio_pullup(unsigned gpio, int value); · 272 unmodified lines | ||
| 273 | 273 | extern int gpio_get_value(unsigned gpio); |
| 274 | 274 | extern void gpio_set_value(unsigned gpio, int value); |
| 275 | 275 | |
| 276 | +#define gpio_get_value_cansleep gpio_get_value | |
| 277 | +#define gpio_set_value_cansleep gpio_set_value | |
| 278 | + | |
| 276 | 279 | /* wrappers to sleep-enable the previous two functions */ |
| 277 | 280 | static inline unsigned gpio_to_irq(unsigned gpio) |
| 278 | 281 | { |
| @@ -227,7 +227,13 @@ static void ct_ca9x4_init(void) · 226 unmodified lines | ||
| 227 | 227 | int i; |
| 228 | 228 | |
| 229 | 229 | #ifdef CONFIG_CACHE_L2X0 |
| 230 | − l2x0_init(MMIO_P2V(CT_CA9X4_L2CC), 0x00000000, 0xfe0fffff); | |
| 230 | + void __iomem *l2x0_base = MMIO_P2V(CT_CA9X4_L2CC); | |
| 231 | + | |
| 232 | + /* set RAM latencies to 1 cycle for this core tile. */ | |
| 233 | + writel(0, l2x0_base + L2X0_TAG_LATENCY_CTRL); | |
| 234 | + writel(0, l2x0_base + L2X0_DATA_LATENCY_CTRL); | |
| 235 | + | |
| 236 | + l2x0_init(l2x0_base, 0x00400000, 0xfe0fffff); | |
| 231 | 237 | #endif |
| 232 | 238 | |
| 233 | 239 | clkdev_add_table(lookups, ARRAY_SIZE(lookups)); |
| @@ -885,8 +885,23 @@ do_alignment(unsigned long addr, unsigned int fsr, struct pt_regs *regs) · 884 unmodified lines | ||
| 885 | 885 | |
| 886 | 886 | if (ai_usermode & UM_SIGNAL) |
| 887 | 887 | force_sig(SIGBUS, current); |
| 888 | − else | |
| 889 | − set_cr(cr_no_alignment); | |
| 888 | + else { | |
| 889 | + /* | |
| 890 | + * We're about to disable the alignment trap and return to | |
| 891 | + * user space. But if an interrupt occurs before actually | |
| 892 | + * reaching user space, then the IRQ vector entry code will | |
| 893 | + * notice that we were still in kernel space and therefore | |
| 894 | + * the alignment trap won't be re-enabled in that case as it | |
| 895 | + * is presumed to be always on from kernel space. | |
| 896 | + * Let's prevent that race by disabling interrupts here (they | |
| 897 | + * are disabled on the way back to user space anyway in | |
| 898 | + * entry-common.S) and disable the alignment trap only if | |
| 899 | + * there is no work pending for this thread. | |
| 900 | + */ | |
| 901 | + raw_local_irq_disable(); | |
| 902 | + if (!(current_thread_info()->flags & _TIF_WORK_MASK)) | |
| 903 | + set_cr(cr_no_alignment); | |
| 904 | + } | |
| 890 | 905 | |
| 891 | 906 | return 0; |
| 892 | 907 | } |
| @@ -15,6 +15,7 @@ · 14 unmodified lines | ||
| 15 | 15 | #include <linux/nodemask.h> |
| 16 | 16 | #include <linux/memblock.h> |
| 17 | 17 | #include <linux/sort.h> |
| 18 | +#include <linux/fs.h> | |
| 18 | 19 | |
| 19 | 20 | #include <asm/cputype.h> |
| 20 | 21 | #include <asm/sections.h> |
| @@ -246,6 +247,9 @@ static struct mem_type mem_types[] = { · 225 unmodified lines | ||
| 246 | 247 | .domain = DOMAIN_USER, |
| 247 | 248 | }, |
| 248 | 249 | [MT_MEMORY] = { |
| 250 | + .prot_pte = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | | |
| 251 | + L_PTE_USER | L_PTE_EXEC, | |
| 252 | + .prot_l1 = PMD_TYPE_TABLE, | |
| 249 | 253 | .prot_sect = PMD_TYPE_SECT | PMD_SECT_AP_WRITE, |
| 250 | 254 | .domain = DOMAIN_KERNEL, |
| 251 | 255 | }, |
| @@ -254,6 +258,9 @@ static struct mem_type mem_types[] = { · 2 unmodified lines | ||
| 254 | 258 | .domain = DOMAIN_KERNEL, |
| 255 | 259 | }, |
| 256 | 260 | [MT_MEMORY_NONCACHED] = { |
| 261 | + .prot_pte = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | | |
| 262 | + L_PTE_USER | L_PTE_EXEC | L_PTE_MT_BUFFERABLE, | |
| 263 | + .prot_l1 = PMD_TYPE_TABLE, | |
| 257 | 264 | .prot_sect = PMD_TYPE_SECT | PMD_SECT_AP_WRITE, |
| 258 | 265 | .domain = DOMAIN_KERNEL, |
| 259 | 266 | }, |
| @@ -411,9 +418,12 @@ static void __init build_mem_type_table(void) · 151 unmodified lines | ||
| 411 | 418 | * Enable CPU-specific coherency if supported. |
| 412 | 419 | * (Only available on XSC3 at the moment.) |
| 413 | 420 | */ |
| 414 | − if (arch_is_coherent() && cpu_is_xsc3()) | |
| 421 | + if (arch_is_coherent() && cpu_is_xsc3()) { | |
| 415 | 422 | mem_types[MT_MEMORY].prot_sect |= PMD_SECT_S; |
| 416 | − | |
| 423 | + mem_types[MT_MEMORY].prot_pte |= L_PTE_SHARED; | |
| 424 | + mem_types[MT_MEMORY_NONCACHED].prot_sect |= PMD_SECT_S; | |
| 425 | + mem_types[MT_MEMORY_NONCACHED].prot_pte |= L_PTE_SHARED; | |
| 426 | + } | |
| 417 | 427 | /* |
| 418 | 428 | * ARMv6 and above have extended page tables. |
| 419 | 429 | */ |
| @@ -438,7 +448,9 @@ static void __init build_mem_type_table(void) · 18 unmodified lines | ||
| 438 | 448 | mem_types[MT_DEVICE_CACHED].prot_sect |= PMD_SECT_S; |
| 439 | 449 | mem_types[MT_DEVICE_CACHED].prot_pte |= L_PTE_SHARED; |
| 440 | 450 | mem_types[MT_MEMORY].prot_sect |= PMD_SECT_S; |
| 451 | + mem_types[MT_MEMORY].prot_pte |= L_PTE_SHARED; | |
| 441 | 452 | mem_types[MT_MEMORY_NONCACHED].prot_sect |= PMD_SECT_S; |
| 453 | + mem_types[MT_MEMORY_NONCACHED].prot_pte |= L_PTE_SHARED; | |
| 442 | 454 | #endif |
| 443 | 455 | } |
| 444 | 456 | |
| @@ -475,6 +487,8 @@ static void __init build_mem_type_table(void) · 30 unmodified lines | ||
| 475 | 487 | mem_types[MT_LOW_VECTORS].prot_l1 |= ecc_mask; |
| 476 | 488 | mem_types[MT_HIGH_VECTORS].prot_l1 |= ecc_mask; |
| 477 | 489 | mem_types[MT_MEMORY].prot_sect |= ecc_mask | cp->pmd; |
| 490 | + mem_types[MT_MEMORY].prot_pte |= kern_pgprot; | |
| 491 | + mem_types[MT_MEMORY_NONCACHED].prot_sect |= ecc_mask; | |
| 478 | 492 | mem_types[MT_ROM].prot_sect |= cp->pmd; |
| 479 | 493 | |
| 480 | 494 | switch (cp->pmd) { |
| @@ -498,6 +512,19 @@ static void __init build_mem_type_table(void) · 17 unmodified lines | ||
| 498 | 512 | } |
| 499 | 513 | } |
| 500 | 514 | |
| 515 | +#ifdef CONFIG_ARM_DMA_MEM_BUFFERABLE | |
| 516 | +pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, | |
| 517 | + unsigned long size, pgprot_t vma_prot) | |
| 518 | +{ | |
| 519 | + if (!pfn_valid(pfn)) | |
| 520 | + return pgprot_noncached(vma_prot); | |
| 521 | + else if (file->f_flags & O_SYNC) | |
| 522 | + return pgprot_writecombine(vma_prot); | |
| 523 | + return vma_prot; | |
| 524 | +} | |
| 525 | +EXPORT_SYMBOL(phys_mem_access_prot); | |
| 526 | +#endif | |
| 527 | + | |
| 501 | 528 | #define vectors_base() (vectors_high() ? 0xffff0000 : 0) |
| 502 | 529 | |
| 503 | 530 | static void __init *early_alloc(unsigned long sz) |
| @@ -186,13 +186,14 @@ cpu_v7_name: · 185 unmodified lines | ||
| 186 | 186 | * It is assumed that: |
| 187 | 187 | * - cache type register is implemented |
| 188 | 188 | */ |
| 189 | −__v7_setup: | |
| 189 | +__v7_ca9mp_setup: | |
| 190 | 190 | #ifdef CONFIG_SMP |
| 191 | 191 | mrc p15, 0, r0, c1, c0, 1 |
| 192 | 192 | tst r0, #(1 << 6) @ SMP/nAMP mode enabled? |
| 193 | 193 | orreq r0, r0, #(1 << 6) | (1 << 0) @ Enable SMP/nAMP mode and |
| 194 | 194 | mcreq p15, 0, r0, c1, c0, 1 @ TLB ops broadcasting |
| 195 | 195 | #endif |
| 196 | +__v7_setup: | |
| 196 | 197 | adr r12, __v7_setup_stack @ the local stack |
| 197 | 198 | stmia r12, {r0-r5, r7, r9, r11, lr} |
| 198 | 199 | bl v7_flush_dcache_all |
| @@ -201,11 +202,16 @@ __v7_setup: · 2 unmodified lines | ||
| 201 | 202 | mrc p15, 0, r0, c0, c0, 0 @ read main ID register |
| 202 | 203 | and r10, r0, #0xff000000 @ ARM? |
| 203 | 204 | teq r10, #0x41000000 |
| 204 | − bne 2f | |
| 205 | + bne 3f | |
| 205 | 206 | and r5, r0, #0x00f00000 @ variant |
| 206 | 207 | and r6, r0, #0x0000000f @ revision |
| 207 | − orr r0, r6, r5, lsr #20-4 @ combine variant and revision | |
| 208 | + orr r6, r6, r5, lsr #20-4 @ combine variant and revision | |
| 209 | + ubfx r0, r0, #4, #12 @ primary part number | |
| 208 | 210 | |
| 211 | + /* Cortex-A8 Errata */ | |
| 212 | + ldr r10, =0x00000c08 @ Cortex-A8 primary part number | |
| 213 | + teq r0, r10 | |
| 214 | + bne 2f | |
| 209 | 215 | #ifdef CONFIG_ARM_ERRATA_430973 |
| 210 | 216 | teq r5, #0x00100000 @ only present in r1p* |
| 211 | 217 | mrceq p15, 0, r10, c1, c0, 1 @ read aux control register |
| @@ -213,21 +219,42 @@ __v7_setup: · 1 unmodified line | ||
| 213 | 219 | mcreq p15, 0, r10, c1, c0, 1 @ write aux control register |
| 214 | 220 | #endif |
| 215 | 221 | #ifdef CONFIG_ARM_ERRATA_458693 |
| 216 | − teq r0, #0x20 @ only present in r2p0 | |
| 222 | + teq r6, #0x20 @ only present in r2p0 | |
| 217 | 223 | mrceq p15, 0, r10, c1, c0, 1 @ read aux control register |
| 218 | 224 | orreq r10, r10, #(1 << 5) @ set L1NEON to 1 |
| 219 | 225 | orreq r10, r10, #(1 << 9) @ set PLDNOP to 1 |
| 220 | 226 | mcreq p15, 0, r10, c1, c0, 1 @ write aux control register |
| 221 | 227 | #endif |
| 222 | 228 | #ifdef CONFIG_ARM_ERRATA_460075 |
| 223 | − teq r0, #0x20 @ only present in r2p0 | |
| 229 | + teq r6, #0x20 @ only present in r2p0 | |
| 224 | 230 | mrceq p15, 1, r10, c9, c0, 2 @ read L2 cache aux ctrl register |
| 225 | 231 | tsteq r10, #1 << 22 |
| 226 | 232 | orreq r10, r10, #(1 << 22) @ set the Write Allocate disable bit |
| 227 | 233 | mcreq p15, 1, r10, c9, c0, 2 @ write the L2 cache aux ctrl register |
| 228 | 234 | #endif |
| 235 | + b 3f | |
| 236 | + | |
| 237 | + /* Cortex-A9 Errata */ | |
| 238 | +2: ldr r10, =0x00000c09 @ Cortex-A9 primary part number | |
| 239 | + teq r0, r10 | |
| 240 | + bne 3f | |
| 241 | +#ifdef CONFIG_ARM_ERRATA_742230 | |
| 242 | + cmp r6, #0x22 @ only present up to r2p2 | |
| 243 | + mrcle p15, 0, r10, c15, c0, 1 @ read diagnostic register | |
| 244 | + orrle r10, r10, #1 << 4 @ set bit #4 | |
| 245 | + mcrle p15, 0, r10, c15, c0, 1 @ write diagnostic register | |
| 246 | +#endif | |
| 247 | +#ifdef CONFIG_ARM_ERRATA_742231 | |
| 248 | + teq r6, #0x20 @ present in r2p0 | |
| 249 | + teqne r6, #0x21 @ present in r2p1 | |
| 250 | + teqne r6, #0x22 @ present in r2p2 | |
| 251 | + mrceq p15, 0, r10, c15, c0, 1 @ read diagnostic register | |
| 252 | + orreq r10, r10, #1 << 12 @ set bit #12 | |
| 253 | + orreq r10, r10, #1 << 22 @ set bit #22 | |
| 254 | + mcreq p15, 0, r10, c15, c0, 1 @ write diagnostic register | |
| 255 | +#endif | |
| 229 | 256 | |
| 230 | −2: mov r10, #0 | |
| 257 | +3: mov r10, #0 | |
| 231 | 258 | #ifdef HARVARD_CACHE |
| 232 | 259 | mcr p15, 0, r10, c7, c5, 0 @ I+BTB cache invalidate |
| 233 | 260 | #endif |
| @@ -323,6 +350,29 @@ cpu_elf_name: · 89 unmodified lines | ||
| 323 | 350 | |
| 324 | 351 | .section ".proc.info.init", #alloc, #execinstr |
| 325 | 352 | |
| 353 | + .type __v7_ca9mp_proc_info, #object | |
| 354 | +__v7_ca9mp_proc_info: | |
| 355 | + .long 0x410fc090 @ Required ID value | |
| 356 | + .long 0xff0ffff0 @ Mask for ID | |
| 357 | + .long PMD_TYPE_SECT | \ | |
| 358 | + PMD_SECT_AP_WRITE | \ | |
| 359 | + PMD_SECT_AP_READ | \ | |
| 360 | + PMD_FLAGS | |
| 361 | + .long PMD_TYPE_SECT | \ | |
| 362 | + PMD_SECT_XN | \ | |
| 363 | + PMD_SECT_AP_WRITE | \ | |
| 364 | + PMD_SECT_AP_READ | |
| 365 | + b __v7_ca9mp_setup | |
| 366 | + .long cpu_arch_name | |
| 367 | + .long cpu_elf_name | |
| 368 | + .long HWCAP_SWP|HWCAP_HALF|HWCAP_THUMB|HWCAP_FAST_MULT|HWCAP_EDSP | |
| 369 | + .long cpu_v7_name | |
| 370 | + .long v7_processor_functions | |
| 371 | + .long v7wbi_tlb_fns | |
| 372 | + .long v6_user_fns | |
| 373 | + .long v7_cache_fns | |
| 374 | + .size __v7_ca9mp_proc_info, . - __v7_ca9mp_proc_info | |
| 375 | + | |
| 326 | 376 | /* |
| 327 | 377 | * Match any ARMv7 processor core. |
| 328 | 378 | */ |
| @@ -1,5 +1,5 @@ | ||
| 1 | 1 | /* |
| 2 | − * linux/arch/arm/mach-nomadik/timer.c | |
| 2 | + * linux/arch/arm/plat-nomadik/timer.c | |
| 3 | 3 | * |
| 4 | 4 | * Copyright (C) 2008 STMicroelectronics |
| 5 | 5 | * Copyright (C) 2010 Alessandro Rubini |
| @@ -75,7 +75,7 @@ static void nmdk_clkevt_mode(enum clock_event_mode mode, · 69 unmodified lines | ||
| 75 | 75 | cr = readl(mtu_base + MTU_CR(1)); |
| 76 | 76 | writel(0, mtu_base + MTU_LR(1)); |
| 77 | 77 | writel(cr | MTU_CRn_ENA, mtu_base + MTU_CR(1)); |
| 78 | − writel(0x2, mtu_base + MTU_IMSC); | |
| 78 | + writel(1 << 1, mtu_base + MTU_IMSC); | |
| 79 | 79 | break; |
| 80 | 80 | case CLOCK_EVT_MODE_SHUTDOWN: |
| 81 | 81 | case CLOCK_EVT_MODE_UNUSED: |
| @@ -131,25 +131,23 @@ void __init nmdk_timer_init(void) · 49 unmodified lines | ||
| 131 | 131 | { |
| 132 | 132 | unsigned long rate; |
| 133 | 133 | struct clk *clk0; |
| 134 | − struct clk *clk1; | |
| 135 | − u32 cr; | |
| 134 | + u32 cr = MTU_CRn_32BITS; | |
| 136 | 135 | |
| 137 | 136 | clk0 = clk_get_sys("mtu0", NULL); |
| 138 | 137 | BUG_ON(IS_ERR(clk0)); |
| 139 | 138 | |
| 140 | − clk1 = clk_get_sys("mtu1", NULL); | |
| 141 | − BUG_ON(IS_ERR(clk1)); | |
| 142 | − | |
| 143 | 139 | clk_enable(clk0); |
| 144 | − clk_enable(clk1); | |
| 145 | 140 | |
| 146 | 141 | /* |
| 147 | − * Tick rate is 2.4MHz for Nomadik and 110MHz for ux500: | |
| 148 | − * use a divide-by-16 counter if it's more than 16MHz | |
| 142 | + * Tick rate is 2.4MHz for Nomadik and 2.4Mhz, 100MHz or 133 MHz | |
| 143 | + * for ux500. | |
| 144 | + * Use a divide-by-16 counter if the tick rate is more than 32MHz. | |
| 145 | + * At 32 MHz, the timer (with 32 bit counter) can be programmed | |
| 146 | + * to wake-up at a max 127s a head in time. Dividing a 2.4 MHz timer | |
| 147 | + * with 16 gives too low timer resolution. | |
| 149 | 148 | */ |
| 150 | − cr = MTU_CRn_32BITS;; | |
| 151 | 149 | rate = clk_get_rate(clk0); |
| 152 | − if (rate > 16 << 20) { | |
| 150 | + if (rate > 32000000) { | |
| 153 | 151 | rate /= 16; |
| 154 | 152 | cr |= MTU_CRn_PRESCALE_16; |
| 155 | 153 | } else { |
| @@ -170,15 +168,8 @@ void __init nmdk_timer_init(void) · 14 unmodified lines | ||
| 170 | 168 | pr_err("timer: failed to initialize clock source %s\n", |
| 171 | 169 | nmdk_clksrc.name); |
| 172 | 170 | |
| 173 | − /* Timer 1 is used for events, fix according to rate */ | |
| 174 | − cr = MTU_CRn_32BITS; | |
| 175 | − rate = clk_get_rate(clk1); | |
| 176 | − if (rate > 16 << 20) { | |
| 177 | − rate /= 16; | |
| 178 | − cr |= MTU_CRn_PRESCALE_16; | |
| 179 | − } else { | |
| 180 | − cr |= MTU_CRn_PRESCALE_1; | |
| 181 | − } | |
| 171 | + /* Timer 1 is used for events */ | |
| 172 | + | |
| 182 | 173 | clockevents_calc_mult_shift(&nmdk_clkevt, rate, MTU_MIN_RANGE); |
| 183 | 174 | |
| 184 | 175 | writel(cr | MTU_CRn_ONESHOT, mtu_base + MTU_CR(1)); /* off, currently */ |
| @@ -33,7 +33,7 @@ config OMAP_DEBUG_DEVICES · 32 unmodified lines | ||
| 33 | 33 | config OMAP_DEBUG_LEDS |
| 34 | 34 | bool |
| 35 | 35 | depends on OMAP_DEBUG_DEVICES |
| 36 | − default y if LEDS | |
| 36 | + default y if LEDS_CLASS | |
| 37 | 37 | |
| 38 | 38 | config OMAP_RESET_CLOCKS |
| 39 | 39 | bool "Reset unused clocks during boot" |
| @@ -156,7 +156,7 @@ static irqreturn_t omap_mcbsp_rx_irq_handler(int irq, void *dev_id) · 155 unmodified lines | ||
| 156 | 156 | /* Writing zero to RSYNC_ERR clears the IRQ */ |
| 157 | 157 | MCBSP_WRITE(mcbsp_rx, SPCR1, MCBSP_READ_CACHE(mcbsp_rx, SPCR1)); |
| 158 | 158 | } else { |
| 159 | − complete(&mcbsp_rx->tx_irq_completion); | |
| 159 | + complete(&mcbsp_rx->rx_irq_completion); | |
| 160 | 160 | } |
| 161 | 161 | |
| 162 | 162 | return IRQ_HANDLED; |
| @@ -220,20 +220,7 @@ void __init omap_map_sram(void) · 219 unmodified lines | ||
| 220 | 220 | if (omap_sram_size == 0) |
| 221 | 221 | return; |
| 222 | 222 | |
| 223 | − if (cpu_is_omap24xx()) { | |
| 224 | − omap_sram_io_desc[0].virtual = OMAP2_SRAM_VA; | |
| 225 | − | |
| 226 | − base = OMAP2_SRAM_PA; | |
| 227 | − base = ROUND_DOWN(base, PAGE_SIZE); | |
| 228 | − omap_sram_io_desc[0].pfn = __phys_to_pfn(base); | |
| 229 | − } | |
| 230 | − | |
| 231 | 223 | if (cpu_is_omap34xx()) { |
| 232 | − omap_sram_io_desc[0].virtual = OMAP3_SRAM_VA; | |
| 233 | − base = OMAP3_SRAM_PA; | |
| 234 | − base = ROUND_DOWN(base, PAGE_SIZE); | |
| 235 | − omap_sram_io_desc[0].pfn = __phys_to_pfn(base); | |
| 236 | − | |
| 237 | 224 | /* |
| 238 | 225 | * SRAM must be marked as non-cached on OMAP3 since the |
| 239 | 226 | * CORE DPLL M2 divider change code (in SRAM) runs with the |
| @@ -244,13 +231,11 @@ void __init omap_map_sram(void) · 4 unmodified lines | ||
| 244 | 231 | omap_sram_io_desc[0].type = MT_MEMORY_NONCACHED; |
| 245 | 232 | } |
| 246 | 233 | |
| 247 | − if (cpu_is_omap44xx()) { | |
| 248 | − omap_sram_io_desc[0].virtual = OMAP4_SRAM_VA; | |
| 249 | − base = OMAP4_SRAM_PA; | |
| 250 | − base = ROUND_DOWN(base, PAGE_SIZE); | |
| 251 | − omap_sram_io_desc[0].pfn = __phys_to_pfn(base); | |
| 252 | − } | |
| 253 | − omap_sram_io_desc[0].length = 1024 * 1024; /* Use section desc */ | |
| 234 | + omap_sram_io_desc[0].virtual = omap_sram_base; | |
| 235 | + base = omap_sram_start; | |
| 236 | + base = ROUND_DOWN(base, PAGE_SIZE); | |
| 237 | + omap_sram_io_desc[0].pfn = __phys_to_pfn(base); | |
| 238 | + omap_sram_io_desc[0].length = ROUND_DOWN(omap_sram_size, PAGE_SIZE); | |
| 254 | 239 | iotable_init(omap_sram_io_desc, ARRAY_SIZE(omap_sram_io_desc)); |
| 255 | 240 | |
| 256 | 241 | printk(KERN_INFO "SRAM: Mapped pa 0x%08lx to va 0x%08lx size: 0x%lx\n", |
| @@ -314,10 +314,9 @@ int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, · 313 unmodified lines | ||
| 314 | 314 | vfree(module->arch.syminfo); |
| 315 | 315 | module->arch.syminfo = NULL; |
| 316 | 316 | |
| 317 | − return module_bug_finalize(hdr, sechdrs, module); | |
| 317 | + return 0; | |
| 318 | 318 | } |
| 319 | 319 | |
| 320 | 320 | void module_arch_cleanup(struct module *module) |
| 321 | 321 | { |
| 322 | − module_bug_cleanup(module); | |
| 323 | 322 | } |
| @@ -112,10 +112,9 @@ int module_finalize(const Elf_Ehdr *hdr, · 111 unmodified lines | ||
| 112 | 112 | const Elf_Shdr *sechdrs, |
| 113 | 113 | struct module *me) |
| 114 | 114 | { |
| 115 | − return module_bug_finalize(hdr, sechdrs, me); | |
| 115 | + return 0; | |
| 116 | 116 | } |
| 117 | 117 | |
| 118 | 118 | void module_arch_cleanup(struct module *mod) |
| 119 | 119 | { |
| 120 | − module_bug_cleanup(mod); | |
| 121 | 120 | } |
| @@ -157,7 +157,6 @@ typedef struct sigaltstack { · 156 unmodified lines | ||
| 157 | 157 | #undef __HAVE_ARCH_SIG_BITOPS |
| 158 | 158 | |
| 159 | 159 | struct pt_regs; |
| 160 | −extern int do_signal(struct pt_regs *regs, sigset_t *oldset); | |
| 161 | 160 | |
| 162 | 161 | #define ptrace_signal_deliver(regs, cookie) do { } while (0) |
| 163 | 162 | |
| @@ -351,6 +351,7 @@ · 350 unmodified lines | ||
| 351 | 351 | #define __ARCH_WANT_SYS_OLD_GETRLIMIT /*will be unused*/ |
| 352 | 352 | #define __ARCH_WANT_SYS_OLDUMOUNT |
| 353 | 353 | #define __ARCH_WANT_SYS_RT_SIGACTION |
| 354 | +#define __ARCH_WANT_SYS_RT_SIGSUSPEND | |
| 354 | 355 | |
| 355 | 356 | #define __IGNORE_lchown |
| 356 | 357 | #define __IGNORE_setuid |
| @@ -235,10 +235,9 @@ work_resched: · 234 unmodified lines | ||
| 235 | 235 | work_notifysig: ; deal with pending signals and |
| 236 | 236 | ; notify-resume requests |
| 237 | 237 | mv r0, sp ; arg1 : struct pt_regs *regs |
| 238 | − ldi r1, #0 ; arg2 : sigset_t *oldset | |
| 239 | − mv r2, r9 ; arg3 : __u32 thread_info_flags | |
| 238 | + mv r1, r9 ; arg2 : __u32 thread_info_flags | |
| 240 | 239 | bl do_notify_resume |
| 241 | − bra restore_all | |
| 240 | + bra resume_userspace | |
| 242 | 241 | |
| 243 | 242 | ; perform syscall exit tracing |
| 244 | 243 | ALIGN |
| @@ -592,16 +592,17 @@ void user_enable_single_step(struct task_struct *child) · 591 unmodified lines | ||
| 592 | 592 | |
| 593 | 593 | if (access_process_vm(child, pc&~3, &insn, sizeof(insn), 0) |
| 594 | 594 | != sizeof(insn)) |
| 595 | − break; | |
| 595 | + return -EIO; | |
| 596 | 596 | |
| 597 | 597 | compute_next_pc(insn, pc, &next_pc, child); |
| 598 | 598 | if (next_pc & 0x80000000) |
| 599 | − break; | |
| 599 | + return -EIO; | |
| 600 | 600 | |
| 601 | 601 | if (embed_debug_trap(child, next_pc)) |
| 602 | − break; | |
| 602 | + return -EIO; | |
| 603 | 603 | |
| 604 | 604 | invalidate_cache(); |
| 605 | + return 0; | |
| 605 | 606 | } |
| 606 | 607 | |
| 607 | 608 | void user_disable_single_step(struct task_struct *child) |
| @@ -28,37 +28,6 @@ · 27 unmodified lines | ||
| 28 | 28 | |
| 29 | 29 | #define DEBUG_SIG 0 |
| 30 | 30 | |
| 31 | −#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | |
| 32 | − | |
| 33 | −int do_signal(struct pt_regs *, sigset_t *); | |
| 34 | − | |
| 35 | −asmlinkage int | |
| 36 | −sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, | |
| 37 | − unsigned long r2, unsigned long r3, unsigned long r4, | |
| 38 | − unsigned long r5, unsigned long r6, struct pt_regs *regs) | |
| 39 | −{ | |
| 40 | − sigset_t newset; | |
| 41 | − | |
| 42 | − /* XXX: Don't preclude handling different sized sigset_t's. */ | |
| 43 | − if (sigsetsize != sizeof(sigset_t)) | |
| 44 | − return -EINVAL; | |
| 45 | − | |
| 46 | − if (copy_from_user(&newset, unewset, sizeof(newset))) | |
| 47 | − return -EFAULT; | |
| 48 | − sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP)); | |
| 49 | − | |
| 50 | − spin_lock_irq(¤t->sighand->siglock); | |
| 51 | − current->saved_sigmask = current->blocked; | |
| 52 | − current->blocked = newset; | |
| 53 | − recalc_sigpending(); | |
| 54 | − spin_unlock_irq(¤t->sighand->siglock); | |
| 55 | − | |
| 56 | − current->state = TASK_INTERRUPTIBLE; | |
| 57 | − schedule(); | |
| 58 | − set_thread_flag(TIF_RESTORE_SIGMASK); | |
| 59 | − return -ERESTARTNOHAND; | |
| 60 | −} | |
| 61 | − | |
| 62 | 31 | asmlinkage int |
| 63 | 32 | sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, |
| 64 | 33 | unsigned long r2, unsigned long r3, unsigned long r4, |
| @@ -218,7 +187,7 @@ get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) · 153 unmodified lines | ||
| 218 | 187 | return (void __user *)((sp - frame_size) & -8ul); |
| 219 | 188 | } |
| 220 | 189 | |
| 221 | −static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, | |
| 190 | +static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, | |
| 222 | 191 | sigset_t *set, struct pt_regs *regs) |
| 223 | 192 | { |
| 224 | 193 | struct rt_sigframe __user *frame; |
| @@ -275,22 +244,34 @@ static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, · 50 unmodified lines | ||
| 275 | 244 | current->comm, current->pid, frame, regs->pc); |
| 276 | 245 | #endif |
| 277 | 246 | |
| 278 | − return; | |
| 247 | + return 0; | |
| 279 | 248 | |
| 280 | 249 | give_sigsegv: |
| 281 | 250 | force_sigsegv(sig, current); |
| 251 | + return -EFAULT; | |
| 252 | +} | |
| 253 | + | |
| 254 | +static int prev_insn(struct pt_regs *regs) | |
| 255 | +{ | |
| 256 | + u16 inst; | |
| 257 | + if (get_user(&inst, (u16 __user *)(regs->bpc - 2))) | |
| 258 | + return -EFAULT; | |
| 259 | + if ((inst & 0xfff0) == 0x10f0) /* trap ? */ | |
| 260 | + regs->bpc -= 2; | |
| 261 | + else | |
| 262 | + regs->bpc -= 4; | |
| 263 | + regs->syscall_nr = -1; | |
| 264 | + return 0; | |
| 282 | 265 | } |
| 283 | 266 | |
| 284 | 267 | /* |
| 285 | 268 | * OK, we're invoking a handler |
| 286 | 269 | */ |
| 287 | 270 | |
| 288 | −static void | |
| 271 | +static int | |
| 289 | 272 | handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info, |
| 290 | 273 | sigset_t *oldset, struct pt_regs *regs) |
| 291 | 274 | { |
| 292 | − unsigned short inst; | |
| 293 | − | |
| 294 | 275 | /* Are we from a system call? */ |
| 295 | 276 | if (regs->syscall_nr >= 0) { |
| 296 | 277 | /* If so, check system call restarting.. */ |
| @@ -308,16 +289,14 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info, · 11 unmodified lines | ||
| 308 | 289 | /* fallthrough */ |
| 309 | 290 | case -ERESTARTNOINTR: |
| 310 | 291 | regs->r0 = regs->orig_r0; |
| 311 | − inst = *(unsigned short *)(regs->bpc - 2); | |
| 312 | − if ((inst & 0xfff0) == 0x10f0) /* trap ? */ | |
| 313 | − regs->bpc -= 2; | |
| 314 | − else | |
| 315 | − regs->bpc -= 4; | |
| 292 | + if (prev_insn(regs) < 0) | |
| 293 | + return -EFAULT; | |
| 316 | 294 | } |
| 317 | 295 | } |
| 318 | 296 | |
| 319 | 297 | /* Set up the stack frame */ |
| 320 | − setup_rt_frame(sig, ka, info, oldset, regs); | |
| 298 | + if (setup_rt_frame(sig, ka, info, oldset, regs)) | |
| 299 | + return -EFAULT; | |
| 321 | 300 | |
| 322 | 301 | spin_lock_irq(¤t->sighand->siglock); |
| 323 | 302 | sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); |
| @@ -325,6 +304,7 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info, · 1 unmodified line | ||
| 325 | 304 | sigaddset(¤t->blocked,sig); |
| 326 | 305 | recalc_sigpending(); |
| 327 | 306 | spin_unlock_irq(¤t->sighand->siglock); |
| 307 | + return 0; | |
| 328 | 308 | } |
| 329 | 309 | |
| 330 | 310 | /* |
| @@ -332,12 +312,12 @@ handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info, · 1 unmodified line | ||
| 332 | 312 | * want to handle. Thus you cannot kill init even with a SIGKILL even by |
| 333 | 313 | * mistake. |
| 334 | 314 | */ |
| 335 | −int do_signal(struct pt_regs *regs, sigset_t *oldset) | |
| 315 | +static void do_signal(struct pt_regs *regs) | |
| 336 | 316 | { |
| 337 | 317 | siginfo_t info; |
| 338 | 318 | int signr; |
| 339 | 319 | struct k_sigaction ka; |
| 340 | − unsigned short inst; | |
| 320 | + sigset_t *oldset; | |
| 341 | 321 | |
| 342 | 322 | /* |
| 343 | 323 | * We want the common case to go fast, which |
| @@ -346,12 +326,14 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset) · 2 unmodified lines | ||
| 346 | 326 | * if so. |
| 347 | 327 | */ |
| 348 | 328 | if (!user_mode(regs)) |
| 349 | − return 1; | |
| 329 | + return; | |
| 350 | 330 | |
| 351 | 331 | if (try_to_freeze()) |
| 352 | 332 | goto no_signal; |
| 353 | 333 | |
| 354 | − if (!oldset) | |
| 334 | + if (test_thread_flag(TIF_RESTORE_SIGMASK)) | |
| 335 | + oldset = ¤t->saved_sigmask; | |
| 336 | + else | |
| 355 | 337 | oldset = ¤t->blocked; |
| 356 | 338 | |
| 357 | 339 | signr = get_signal_to_deliver(&info, &ka, regs, NULL); |
| @@ -363,8 +345,10 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset) · 5 unmodified lines | ||
| 363 | 345 | */ |
| 364 | 346 | |
| 365 | 347 | /* Whee! Actually deliver the signal. */ |
| 366 | − handle_signal(signr, &ka, &info, oldset, regs); | |
| 367 | − return 1; | |
| 348 | + if (handle_signal(signr, &ka, &info, oldset, regs) == 0) | |
| 349 | + clear_thread_flag(TIF_RESTORE_SIGMASK); | |
| 350 | + | |
| 351 | + return; | |
| 368 | 352 | } |
| 369 | 353 | |
| 370 | 354 | no_signal: |
| @@ -375,31 +359,24 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset) · 4 unmodified lines | ||
| 375 | 359 | regs->r0 == -ERESTARTSYS || |
| 376 | 360 | regs->r0 == -ERESTARTNOINTR) { |
| 377 | 361 | regs->r0 = regs->orig_r0; |
| 378 | − inst = *(unsigned short *)(regs->bpc - 2); | |
| 379 | − if ((inst & 0xfff0) == 0x10f0) /* trap ? */ | |
| 380 | − regs->bpc -= 2; | |
| 381 | − else | |
| 382 | − regs->bpc -= 4; | |
| 383 | − } | |
| 384 | − if (regs->r0 == -ERESTART_RESTARTBLOCK){ | |
| 362 | + prev_insn(regs); | |
| 363 | + } else if (regs->r0 == -ERESTART_RESTARTBLOCK){ | |
| 385 | 364 | regs->r0 = regs->orig_r0; |
| 386 | 365 | regs->r7 = __NR_restart_syscall; |
| 387 | − inst = *(unsigned short *)(regs->bpc - 2); | |
| 388 | − if ((inst & 0xfff0) == 0x10f0) /* trap ? */ | |
| 389 | − regs->bpc -= 2; | |
| 390 | − else | |
| 391 | − regs->bpc -= 4; | |
| 366 | + prev_insn(regs); | |
| 392 | 367 | } |
| 393 | 368 | } |
| 394 | − return 0; | |
| 369 | + if (test_thread_flag(TIF_RESTORE_SIGMASK)) { | |
| 370 | + clear_thread_flag(TIF_RESTORE_SIGMASK); | |
| 371 | + sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); | |
| 372 | + } | |
| 395 | 373 | } |
| 396 | 374 | |
| 397 | 375 | /* |
| 398 | 376 | * notification of userspace execution resumption |
| 399 | 377 | * - triggered by current->work.notify_resume |
| 400 | 378 | */ |
| 401 | −void do_notify_resume(struct pt_regs *regs, sigset_t *oldset, | |
| 402 | − __u32 thread_info_flags) | |
| 379 | +void do_notify_resume(struct pt_regs *regs, __u32 thread_info_flags) | |
| 403 | 380 | { |
| 404 | 381 | /* Pending single-step? */ |
| 405 | 382 | if (thread_info_flags & _TIF_SINGLESTEP) |
| @@ -407,7 +384,7 @@ void do_notify_resume(struct pt_regs *regs, sigset_t *oldset, · 1 unmodified line | ||
| 407 | 384 | |
| 408 | 385 | /* deal with pending signal delivery */ |
| 409 | 386 | if (thread_info_flags & _TIF_SIGPENDING) |
| 410 | − do_signal(regs,oldset); | |
| 387 | + do_signal(regs); | |
| 411 | 388 | |
| 412 | 389 | if (thread_info_flags & _TIF_NOTIFY_RESUME) { |
| 413 | 390 | clear_thread_flag(TIF_NOTIFY_RESUME); |
| @@ -162,7 +162,7 @@ static void mac_init_asc( void ) · 161 unmodified lines | ||
| 162 | 162 | void mac_mksound( unsigned int freq, unsigned int length ) |
| 163 | 163 | { |
| 164 | 164 | __u32 cfreq = ( freq << 5 ) / 468; |
| 165 | − __u32 flags; | |
| 165 | + unsigned long flags; | |
| 166 | 166 | int i; |
| 167 | 167 | |
| 168 | 168 | if ( mac_special_bell == NULL ) |
| @@ -224,7 +224,7 @@ static void mac_nosound( unsigned long ignored ) · 55 unmodified lines | ||
| 224 | 224 | */ |
| 225 | 225 | static void mac_quadra_start_bell( unsigned int freq, unsigned int length, unsigned int volume ) |
| 226 | 226 | { |
| 227 | − __u32 flags; | |
| 227 | + unsigned long flags; | |
| 228 | 228 | |
| 229 | 229 | /* if the bell is already ringing, ring longer */ |
| 230 | 230 | if ( mac_bell_duration > 0 ) |
| @@ -271,7 +271,7 @@ static void mac_quadra_start_bell( unsigned int freq, unsigned int length, unsig · 40 unmodified lines | ||
| 271 | 271 | static void mac_quadra_ring_bell( unsigned long ignored ) |
| 272 | 272 | { |
| 273 | 273 | int i, count = mac_asc_samplespersec / HZ; |
| 274 | − __u32 flags; | |
| 274 | + unsigned long flags; | |
| 275 | 275 | |
| 276 | 276 | /* |
| 277 | 277 | * we neither want a sound buffer overflow nor underflow, so we need to match |
| @@ -13,6 +13,7 @@ config MIPS · 12 unmodified lines | ||
| 13 | 13 | select HAVE_KPROBES |
| 14 | 14 | select HAVE_KRETPROBES |
| 15 | 15 | select RTC_LIB if !MACH_LOONGSON |
| 16 | + select GENERIC_ATOMIC64 if !64BIT | |
| 16 | 17 | |
| 17 | 18 | mainmenu "Linux/MIPS Kernel Configuration" |
| 18 | 19 | |
| @@ -1646,8 +1647,16 @@ config MIPS_MT_SMP · 1627 unmodified lines | ||
| 1646 | 1647 | select SYS_SUPPORTS_SMP |
| 1647 | 1648 | select SMP_UP |
| 1648 | 1649 | help |
| 1649 | − This is a kernel model which is also known a VSMP or lately | |
| 1650 | − has been marketesed into SMVP. | |
| 1650 | + This is a kernel model which is known a VSMP but lately has been | |
| 1651 | + marketesed into SMVP. | |
| 1652 | + Virtual SMP uses the processor's VPEs to implement virtual | |
| 1653 | + processors. In currently available configuration of the 34K processor | |
| 1654 | + this allows for a dual processor. Both processors will share the same | |
| 1655 | + primary caches; each will obtain the half of the TLB for it's own | |
| 1656 | + exclusive use. For a layman this model can be described as similar to | |
| 1657 | + what Intel calls Hyperthreading. | |
| 1658 | + | |
| 1659 | + For further information see http://www.linux-mips.org/wiki/34K#VSMP | |
| 1651 | 1660 | |
| 1652 | 1661 | config MIPS_MT_SMTC |
| 1653 | 1662 | bool "SMTC: Use all TCs on all VPEs for SMP" |
| @@ -1664,6 +1673,14 @@ config MIPS_MT_SMTC · 10 unmodified lines | ||
| 1664 | 1673 | help |
| 1665 | 1674 | This is a kernel model which is known a SMTC or lately has been |
| 1666 | 1675 | marketesed into SMVP. |
| 1676 | + is presenting the available TC's of the core as processors to Linux. | |
| 1677 | + On currently available 34K processors this means a Linux system will | |
| 1678 | + see up to 5 processors. The implementation of the SMTC kernel differs | |
| 1679 | + significantly from VSMP and cannot efficiently coexist in the same | |
| 1680 | + kernel binary so the choice between VSMP and SMTC is a compile time | |
| 1681 | + decision. | |
| 1682 | + | |
| 1683 | + For further information see http://www.linux-mips.org/wiki/34K#SMTC | |
| 1667 | 1684 | |
| 1668 | 1685 | endchoice |
| 1669 | 1686 | |
| @@ -43,7 +43,7 @@ int prom_argc; · 42 unmodified lines | ||
| 43 | 43 | char **prom_argv; |
| 44 | 44 | char **prom_envp; |
| 45 | 45 | |
| 46 | −void prom_init_cmdline(void) | |
| 46 | +void __init prom_init_cmdline(void) | |
| 47 | 47 | { |
| 48 | 48 | int i; |
| 49 | 49 | |
| @@ -104,7 +104,7 @@ static inline void str2eaddr(unsigned char *ea, unsigned char *str) · 54 unmodified lines | ||
| 104 | 104 | } |
| 105 | 105 | } |
| 106 | 106 | |
| 107 | −int prom_get_ethernet_addr(char *ethernet_addr) | |
| 107 | +int __init prom_get_ethernet_addr(char *ethernet_addr) | |
| 108 | 108 | { |
| 109 | 109 | char *ethaddr_str; |
| 110 | 110 | |
| @@ -123,7 +123,6 @@ int prom_get_ethernet_addr(char *ethernet_addr) · 12 unmodified lines | ||
| 123 | 123 | |
| 124 | 124 | return 0; |
| 125 | 125 | } |
| 126 | −EXPORT_SYMBOL(prom_get_ethernet_addr); | |
| 127 | 126 | |
| 128 | 127 | void __init prom_free_prom_memory(void) |
| 129 | 128 | { |
| @@ -59,7 +59,7 @@ $(obj)/piggy.o: $(obj)/dummy.o $(obj)/vmlinux.bin.z FORCE · 58 unmodified lines | ||
| 59 | 59 | hostprogs-y := calc_vmlinuz_load_addr |
| 60 | 60 | |
| 61 | 61 | VMLINUZ_LOAD_ADDRESS = $(shell $(obj)/calc_vmlinuz_load_addr \ |
| 62 | − $(objtree)/$(KBUILD_IMAGE) $(VMLINUX_LOAD_ADDRESS)) | |
| 62 | + $(obj)/vmlinux.bin $(VMLINUX_LOAD_ADDRESS)) | |
| 63 | 63 | |
| 64 | 64 | vmlinuzobjs-y += $(obj)/piggy.o |
| 65 | 65 | |
| @@ -83,3 +83,7 @@ config ARCH_SPARSEMEM_ENABLE · 82 unmodified lines | ||
| 83 | 83 | def_bool y |
| 84 | 84 | select SPARSEMEM_STATIC |
| 85 | 85 | depends on CPU_CAVIUM_OCTEON |
| 86 | + | |
| 87 | +config CAVIUM_OCTEON_HELPER | |
| 88 | + def_bool y | |
| 89 | + depends on OCTEON_ETHERNET || PCI | |
| @@ -41,7 +41,7 @@ static int cnmips_cu2_call(struct notifier_block *nfb, unsigned long action, · 40 unmodified lines | ||
| 41 | 41 | return NOTIFY_OK; /* Let default notifier send signals */ |
| 42 | 42 | } |
| 43 | 43 | |
| 44 | −static int cnmips_cu2_setup(void) | |
| 44 | +static int __init cnmips_cu2_setup(void) | |
| 45 | 45 | { |
| 46 | 46 | return cu2_notifier(cnmips_cu2_call, 0); |
| 47 | 47 | } |
| @@ -11,4 +11,4 @@ · 10 unmodified lines | ||
| 11 | 11 | |
| 12 | 12 | obj-y += cvmx-bootmem.o cvmx-l2c.o cvmx-sysinfo.o octeon-model.o |
| 13 | 13 | |
| 14 | −obj-$(CONFIG_PCI) += cvmx-helper-errata.o cvmx-helper-jtag.o | |
| 14 | +obj-$(CONFIG_CAVIUM_OCTEON_HELPER) += cvmx-helper-errata.o cvmx-helper-jtag.o | |
| @@ -782,6 +782,10 @@ static __inline__ int atomic64_add_unless(atomic64_t *v, long a, long u) · 781 unmodified lines | ||
| 782 | 782 | */ |
| 783 | 783 | #define atomic64_add_negative(i, v) (atomic64_add_return(i, (v)) < 0) |
| 784 | 784 | |
| 785 | +#else /* !CONFIG_64BIT */ | |
| 786 | + | |
| 787 | +#include <asm-generic/atomic64.h> | |
| 788 | + | |
| 785 | 789 | #endif /* CONFIG_64BIT */ |
| 786 | 790 | |
| 787 | 791 | /* |
| @@ -24,7 +24,7 @@ extern int cu2_notifier_call_chain(unsigned long val, void *v); · 23 unmodified lines | ||
| 24 | 24 | |
| 25 | 25 | #define cu2_notifier(fn, pri) \ |
| 26 | 26 | ({ \ |
| 27 | − static struct notifier_block fn##_nb __cpuinitdata = { \ | |
| 27 | + static struct notifier_block fn##_nb = { \ | |
| 28 | 28 | .notifier_call = fn, \ |
| 29 | 29 | .priority = pri \ |
| 30 | 30 | }; \ |
| @@ -321,6 +321,7 @@ struct gic_intrmask_regs { · 320 unmodified lines | ||
| 321 | 321 | */ |
| 322 | 322 | struct gic_intr_map { |
| 323 | 323 | unsigned int cpunum; /* Directed to this CPU */ |
| 324 | +#define GIC_UNUSED 0xdead /* Dummy data */ | |
| 324 | 325 | unsigned int pin; /* Directed to this Pin */ |
| 325 | 326 | unsigned int polarity; /* Polarity : +/- */ |
| 326 | 327 | unsigned int trigtype; /* Trigger : Edge/Levl */ |
| @@ -1,6 +1,6 @@ | ||
| 1 | 1 | #ifndef __ASM_MACH_TX49XX_KMALLOC_H |
| 2 | 2 | #define __ASM_MACH_TX49XX_KMALLOC_H |
| 3 | 3 | |
| 4 | −#define ARCH_KMALLOC_MINALIGN L1_CACHE_BYTES | |
| 4 | +#define ARCH_DMA_MINALIGN L1_CACHE_BYTES | |
| 5 | 5 | |
| 6 | 6 | #endif /* __ASM_MACH_TX49XX_KMALLOC_H */ |
| @@ -88,9 +88,6 @@ · 87 unmodified lines | ||
| 88 | 88 | |
| 89 | 89 | #define GIC_EXT_INTR(x) x |
| 90 | 90 | |
| 91 | −/* Dummy data */ | |
| 92 | −#define X 0xdead | |
| 93 | − | |
| 94 | 91 | /* External Interrupts used for IPI */ |
| 95 | 92 | #define GIC_IPI_EXT_INTR_RESCHED_VPE0 16 |
| 96 | 93 | #define GIC_IPI_EXT_INTR_CALLFNC_VPE0 17 |
| @@ -150,6 +150,20 @@ typedef struct { unsigned long pgprot; } pgprot_t; · 149 unmodified lines | ||
| 150 | 150 | ((unsigned long)(x) - PAGE_OFFSET + PHYS_OFFSET) |
| 151 | 151 | #endif |
| 152 | 152 | #define __va(x) ((void *)((unsigned long)(x) + PAGE_OFFSET - PHYS_OFFSET)) |
| 153 | + | |
| 154 | +/* | |
| 155 | + * RELOC_HIDE was originally added by 6007b903dfe5f1d13e0c711ac2894bdd4a61b1ad | |
| 156 | + * (lmo) rsp. 8431fd094d625b94d364fe393076ccef88e6ce18 (kernel.org). The | |
| 157 | + * discussion can be found in lkml posting | |
| 158 | + * <a2ebde260608230500o3407b108hc03debb9da6e62c@mail.gmail.com> which is | |
| 159 | + * archived at http://lists.linuxcoding.com/kernel/2006-q3/msg17360.html | |
| 160 | + * | |
| 161 | + * It is unclear if the misscompilations mentioned in | |
| 162 | + * http://lkml.org/lkml/2010/8/8/138 also affect MIPS so we keep this one | |
| 163 | + * until GCC 3.x has been retired before we can apply | |
| 164 | + * https://patchwork.linux-mips.org/patch/1541/ | |
| 165 | + */ | |
| 166 | + | |
| 153 | 167 | #define __pa_symbol(x) __pa(RELOC_HIDE((unsigned long)(x), 0)) |
| 154 | 168 | |
| 155 | 169 | #define pfn_to_kaddr(pfn) __va((pfn) << PAGE_SHIFT) |
| @@ -146,7 +146,8 @@ register struct thread_info *__current_thread_info __asm__("$28"); · 145 unmodified lines | ||
| 146 | 146 | #define _TIF_LOAD_WATCH (1<<TIF_LOAD_WATCH) |
| 147 | 147 | |
| 148 | 148 | /* work to do on interrupt/exception return */ |
| 149 | −#define _TIF_WORK_MASK (0x0000ffef & ~_TIF_SECCOMP) | |
| 149 | +#define _TIF_WORK_MASK (0x0000ffef & \ | |
| 150 | + ~(_TIF_SECCOMP | _TIF_SYSCALL_AUDIT)) | |
| 150 | 151 | /* work to do on any return to u-space */ |
| 151 | 152 | #define _TIF_ALLWORK_MASK (0x8000ffff & ~_TIF_SECCOMP) |
| 152 | 153 | |
| @@ -356,16 +356,19 @@ · 355 unmodified lines | ||
| 356 | 356 | #define __NR_perf_event_open (__NR_Linux + 333) |
| 357 | 357 | #define __NR_accept4 (__NR_Linux + 334) |
| 358 | 358 | #define __NR_recvmmsg (__NR_Linux + 335) |
| 359 | +#define __NR_fanotify_init (__NR_Linux + 336) | |
| 360 | +#define __NR_fanotify_mark (__NR_Linux + 337) | |
| 361 | +#define __NR_prlimit64 (__NR_Linux + 338) | |
| 359 | 362 | |
| 360 | 363 | /* |
| 361 | 364 | * Offset of the last Linux o32 flavoured syscall |
| 362 | 365 | */ |
| 363 | −#define __NR_Linux_syscalls 335 | |
| 366 | +#define __NR_Linux_syscalls 338 | |
| 364 | 367 | |
| 365 | 368 | #endif /* _MIPS_SIM == _MIPS_SIM_ABI32 */ |
| 366 | 369 | |
| 367 | 370 | #define __NR_O32_Linux 4000 |
| 368 | −#define __NR_O32_Linux_syscalls 335 | |
| 371 | +#define __NR_O32_Linux_syscalls 338 | |
| 369 | 372 | |
| 370 | 373 | #if _MIPS_SIM == _MIPS_SIM_ABI64 |
| 371 | 374 | |
| @@ -668,16 +671,19 @@ · 296 unmodified lines | ||
| 668 | 671 | #define __NR_perf_event_open (__NR_Linux + 292) |
| 669 | 672 | #define __NR_accept4 (__NR_Linux + 293) |
| 670 | 673 | #define __NR_recvmmsg (__NR_Linux + 294) |
| 674 | +#define __NR_fanotify_init (__NR_Linux + 295) | |
| 675 | +#define __NR_fanotify_mark (__NR_Linux + 296) | |
| 676 | +#define __NR_prlimit64 (__NR_Linux + 297) | |
| 671 | 677 | |
| 672 | 678 | /* |
| 673 | 679 | * Offset of the last Linux 64-bit flavoured syscall |
| 674 | 680 | */ |
| 675 | −#define __NR_Linux_syscalls 294 | |
| 681 | +#define __NR_Linux_syscalls 297 | |
| 676 | 682 | |
| 677 | 683 | #endif /* _MIPS_SIM == _MIPS_SIM_ABI64 */ |
| 678 | 684 | |
| 679 | 685 | #define __NR_64_Linux 5000 |
| 680 | −#define __NR_64_Linux_syscalls 294 | |
| 686 | +#define __NR_64_Linux_syscalls 297 | |
| 681 | 687 | |
| 682 | 688 | #if _MIPS_SIM == _MIPS_SIM_NABI32 |
| 683 | 689 | |
| @@ -985,16 +991,19 @@ · 301 unmodified lines | ||
| 985 | 991 | #define __NR_accept4 (__NR_Linux + 297) |
| 986 | 992 | #define __NR_recvmmsg (__NR_Linux + 298) |
| 987 | 993 | #define __NR_getdents64 (__NR_Linux + 299) |
| 994 | +#define __NR_fanotify_init (__NR_Linux + 300) | |
| 995 | +#define __NR_fanotify_mark (__NR_Linux + 301) | |
| 996 | +#define __NR_prlimit64 (__NR_Linux + 302) | |
| 988 | 997 | |
| 989 | 998 | /* |
| 990 | 999 | * Offset of the last N32 flavoured syscall |
| 991 | 1000 | */ |
| 992 | −#define __NR_Linux_syscalls 299 | |
| 1001 | +#define __NR_Linux_syscalls 302 | |
| 993 | 1002 | |
| 994 | 1003 | #endif /* _MIPS_SIM == _MIPS_SIM_NABI32 */ |
| 995 | 1004 | |
| 996 | 1005 | #define __NR_N32_Linux 6000 |
| 997 | −#define __NR_N32_Linux_syscalls 299 | |
| 1006 | +#define __NR_N32_Linux_syscalls 302 | |
| 998 | 1007 | |
| 999 | 1008 | #ifdef __KERNEL__ |
| 1000 | 1009 | |
| @@ -7,7 +7,6 @@ · 6 unmodified lines | ||
| 7 | 7 | #include <asm/io.h> |
| 8 | 8 | #include <asm/gic.h> |
| 9 | 9 | #include <asm/gcmpregs.h> |
| 10 | −#include <asm/mips-boards/maltaint.h> | |
| 11 | 10 | #include <asm/irq.h> |
| 12 | 11 | #include <linux/hardirq.h> |
| 13 | 12 | #include <asm-generic/bitops/find.h> |
| @@ -131,7 +130,7 @@ static int gic_set_affinity(unsigned int irq, const struct cpumask *cpumask) · 117 unmodified lines | ||
| 131 | 130 | int i; |
| 132 | 131 | |
| 133 | 132 | irq -= _irqbase; |
| 134 | − pr_debug(KERN_DEBUG "%s(%d) called\n", __func__, irq); | |
| 133 | + pr_debug("%s(%d) called\n", __func__, irq); | |
| 135 | 134 | cpumask_and(&tmp, cpumask, cpu_online_mask); |
| 136 | 135 | if (cpus_empty(tmp)) |
| 137 | 136 | return -1; |
| @@ -222,7 +221,7 @@ static void __init gic_basic_init(int numintrs, int numvpes, · 84 unmodified lines | ||
| 222 | 221 | /* Setup specifics */ |
| 223 | 222 | for (i = 0; i < mapsize; i++) { |
| 224 | 223 | cpu = intrmap[i].cpunum; |
| 225 | − if (cpu == X) | |
| 224 | + if (cpu == GIC_UNUSED) | |
| 226 | 225 | continue; |
| 227 | 226 | if (cpu == 0 && i != 0 && intrmap[i].flags == 0) |
| 228 | 227 | continue; |
| @@ -283,7 +283,7 @@ static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd, · 282 unmodified lines | ||
| 283 | 283 | struct pt_regs *regs = args->regs; |
| 284 | 284 | int trap = (regs->cp0_cause & 0x7c) >> 2; |
| 285 | 285 | |
| 286 | − /* Userpace events, ignore. */ | |
| 286 | + /* Userspace events, ignore. */ | |
| 287 | 287 | if (user_mode(regs)) |
| 288 | 288 | return NOTIFY_DONE; |
| 289 | 289 | |
| @@ -251,7 +251,7 @@ void sp_work_handle_request(void) · 250 unmodified lines | ||
| 251 | 251 | memset(&tz, 0, sizeof(tz)); |
| 252 | 252 | if ((ret.retval = sp_syscall(__NR_gettimeofday, (int)&tv, |
| 253 | 253 | (int)&tz, 0, 0)) == 0) |
| 254 | − ret.retval = tv.tv_sec; | |
| 254 | + ret.retval = tv.tv_sec; | |
| 255 | 255 | break; |
| 256 | 256 | |
| 257 | 257 | case MTSP_SYSCALL_EXIT: |
| @@ -341,3 +341,10 @@ asmlinkage long sys32_lookup_dcookie(u32 a0, u32 a1, char __user *buf, · 340 unmodified lines | ||
| 341 | 341 | { |
| 342 | 342 | return sys_lookup_dcookie(merge_64(a0, a1), buf, len); |
| 343 | 343 | } |
| 344 | + | |
| 345 | +SYSCALL_DEFINE6(32_fanotify_mark, int, fanotify_fd, unsigned int, flags, | |
| 346 | + u64, a3, u64, a4, int, dfd, const char __user *, pathname) | |
| 347 | +{ | |
| 348 | + return sys_fanotify_mark(fanotify_fd, flags, merge_64(a3, a4), | |
| 349 | + dfd, pathname); | |
| 350 | +} | |
| @@ -583,7 +583,10 @@ einval: li v0, -ENOSYS · 582 unmodified lines | ||
| 583 | 583 | sys sys_rt_tgsigqueueinfo 4 |
| 584 | 584 | sys sys_perf_event_open 5 |
| 585 | 585 | sys sys_accept4 4 |
| 586 | − sys sys_recvmmsg 5 | |
| 586 | + sys sys_recvmmsg 5 /* 4335 */ | |
| 587 | + sys sys_fanotify_init 2 | |
| 588 | + sys sys_fanotify_mark 6 | |
| 589 | + sys sys_prlimit64 4 | |
| 587 | 590 | .endm |
| 588 | 591 | |
| 589 | 592 | /* We pre-compute the number of _instruction_ bytes needed to |
| @@ -416,9 +416,12 @@ sys_call_table: · 415 unmodified lines | ||
| 416 | 416 | PTR sys_pipe2 |
| 417 | 417 | PTR sys_inotify_init1 |
| 418 | 418 | PTR sys_preadv |
| 419 | − PTR sys_pwritev /* 5390 */ | |
| 419 | + PTR sys_pwritev /* 5290 */ | |
| 420 | 420 | PTR sys_rt_tgsigqueueinfo |
| 421 | 421 | PTR sys_perf_event_open |
| 422 | 422 | PTR sys_accept4 |
| 423 | − PTR sys_recvmmsg | |
| 423 | + PTR sys_recvmmsg | |
| 424 | + PTR sys_fanotify_init /* 5295 */ | |
| 425 | + PTR sys_fanotify_mark | |
| 426 | + PTR sys_prlimit64 | |
| 424 | 427 | .size sys_call_table,.-sys_call_table |
| @@ -419,5 +419,8 @@ EXPORT(sysn32_call_table) · 418 unmodified lines | ||
| 419 | 419 | PTR sys_perf_event_open |
| 420 | 420 | PTR sys_accept4 |
| 421 | 421 | PTR compat_sys_recvmmsg |
| 422 | − PTR sys_getdents | |
| 422 | + PTR sys_getdents64 | |
| 423 | + PTR sys_fanotify_init /* 6300 */ | |
| 424 | + PTR sys_fanotify_mark | |
| 425 | + PTR sys_prlimit64 | |
| 423 | 426 | .size sysn32_call_table,.-sysn32_call_table |
| @@ -538,5 +538,8 @@ sys_call_table: · 537 unmodified lines | ||
| 538 | 538 | PTR compat_sys_rt_tgsigqueueinfo |
| 539 | 539 | PTR sys_perf_event_open |
| 540 | 540 | PTR sys_accept4 |
| 541 | − PTR compat_sys_recvmmsg | |
| 541 | + PTR compat_sys_recvmmsg /* 4335 */ | |
| 542 | + PTR sys_fanotify_init | |
| 543 | + PTR sys_32_fanotify_mark | |
| 544 | + PTR sys_prlimit64 | |
| 542 | 545 | .size sys_call_table,.-sys_call_table |
| @@ -44,27 +44,39 @@ static inline int cpu_is_noncoherent_r10000(struct device *dev) · 43 unmodified lines | ||
| 44 | 44 | |
| 45 | 45 | static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp) |
| 46 | 46 | { |
| 47 | + gfp_t dma_flag; | |
| 48 | + | |
| 47 | 49 | /* ignore region specifiers */ |
| 48 | 50 | gfp &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM); |
| 49 | 51 | |
| 50 | −#ifdef CONFIG_ZONE_DMA | |
| 52 | +#ifdef CONFIG_ISA | |
| 51 | 53 | if (dev == NULL) |
| 52 | − gfp |= __GFP_DMA; | |
| 53 | − else if (dev->coherent_dma_mask < DMA_BIT_MASK(24)) | |
| 54 | − gfp |= __GFP_DMA; | |
| 54 | + dma_flag = __GFP_DMA; | |
| 55 | 55 | else |
| 56 | 56 | #endif |
| 57 | −#ifdef CONFIG_ZONE_DMA32 | |
| 57 | +#if defined(CONFIG_ZONE_DMA32) && defined(CONFIG_ZONE_DMA) | |
| 58 | 58 | if (dev->coherent_dma_mask < DMA_BIT_MASK(32)) |
| 59 | − gfp |= __GFP_DMA32; | |
| 59 | + dma_flag = __GFP_DMA; | |
| 60 | + else if (dev->coherent_dma_mask < DMA_BIT_MASK(64)) | |
| 61 | + dma_flag = __GFP_DMA32; | |
| 62 | + else | |
| 63 | +#endif | |
| 64 | +#if defined(CONFIG_ZONE_DMA32) && !defined(CONFIG_ZONE_DMA) | |
| 65 | + if (dev->coherent_dma_mask < DMA_BIT_MASK(64)) | |
| 66 | + dma_flag = __GFP_DMA32; | |
| 67 | + else | |
| 68 | +#endif | |
| 69 | +#if defined(CONFIG_ZONE_DMA) && !defined(CONFIG_ZONE_DMA32) | |
| 70 | + if (dev->coherent_dma_mask < DMA_BIT_MASK(64)) | |
| 71 | + dma_flag = __GFP_DMA; | |
| 60 | 72 | else |
| 61 | 73 | #endif |
| 62 | − ; | |
| 74 | + dma_flag = 0; | |
| 63 | 75 | |
| 64 | 76 | /* Don't invoke OOM killer */ |
| 65 | 77 | gfp |= __GFP_NORETRY; |
| 66 | 78 | |
| 67 | − return gfp; | |
| 79 | + return gfp | dma_flag; | |
| 68 | 80 | } |
| 69 | 81 | |
| 70 | 82 | void *dma_alloc_noncoherent(struct device *dev, size_t size, |
| @@ -30,7 +30,7 @@ · 29 unmodified lines | ||
| 30 | 30 | #define tc_lsize 32 |
| 31 | 31 | |
| 32 | 32 | extern unsigned long icache_way_size, dcache_way_size; |
| 33 | −unsigned long tcache_size; | |
| 33 | +static unsigned long tcache_size; | |
| 34 | 34 | |
| 35 | 35 | #include <asm/r4kcache.h> |
| 36 | 36 | |
| @@ -385,6 +385,8 @@ static int __initdata msc_nr_eicirqs = ARRAY_SIZE(msc_eicirqmap); · 384 unmodified lines | ||
| 385 | 385 | */ |
| 386 | 386 | |
| 387 | 387 | #define GIC_CPU_NMI GIC_MAP_TO_NMI_MSK |
| 388 | +#define X GIC_UNUSED | |
| 389 | + | |
| 388 | 390 | static struct gic_intr_map gic_intr_map[GIC_NUM_INTRS] = { |
| 389 | 391 | { X, X, X, X, 0 }, |
| 390 | 392 | { X, X, X, X, 0 }, |
| @@ -404,6 +406,7 @@ static struct gic_intr_map gic_intr_map[GIC_NUM_INTRS] = { · 13 unmodified lines | ||
| 404 | 406 | { X, X, X, X, 0 }, |
| 405 | 407 | /* The remainder of this table is initialised by fill_ipi_map */ |
| 406 | 408 | }; |
| 409 | +#undef X | |
| 407 | 410 | |
| 408 | 411 | /* |
| 409 | 412 | * GCMP needs to be detected before any SMP initialisation |
| @@ -118,7 +118,7 @@ static int __init rc32434_pcibridge_init(void) · 117 unmodified lines | ||
| 118 | 118 | if (!((pcicvalue == PCIM_H_EA) || |
| 119 | 119 | (pcicvalue == PCIM_H_IA_FIX) || |
| 120 | 120 | (pcicvalue == PCIM_H_IA_RR))) { |
| 121 | − pr_err(KERN_ERR "PCI init error!!!\n"); | |
| 121 | + pr_err("PCI init error!!!\n"); | |
| 122 | 122 | /* Not in Host Mode, return ERROR */ |
| 123 | 123 | return -1; |
| 124 | 124 | } |
| @@ -22,29 +22,19 @@ · 21 unmodified lines | ||
| 22 | 22 | */ |
| 23 | 23 | #include <linux/kernel.h> |
| 24 | 24 | |
| 25 | +#include <asm/processor.h> | |
| 25 | 26 | #include <asm/reboot.h> |
| 26 | 27 | #include <glb.h> |
| 27 | 28 | |
| 28 | 29 | void pnx8550_machine_restart(char *command) |
| 29 | 30 | { |
| 30 | − char head[] = "************* Machine restart *************"; | |
| 31 | − char foot[] = "*******************************************"; | |
| 32 | − | |
| 33 | − printk("\n\n"); | |
| 34 | − printk("%s\n", head); | |
| 35 | − if (command != NULL) | |
| 36 | − printk("* %s\n", command); | |
| 37 | − printk("%s\n", foot); | |
| 38 | − | |
| 39 | 31 | PNX8550_RST_CTL = PNX8550_RST_DO_SW_RST; |
| 40 | 32 | } |
| 41 | 33 | |
| 42 | 34 | void pnx8550_machine_halt(void) |
| 43 | 35 | { |
| 44 | − printk("*** Machine halt. (Not implemented) ***\n"); | |
| 45 | −} | |
| 46 | − | |
| 47 | −void pnx8550_machine_power_off(void) | |
| 48 | −{ | |
| 49 | − printk("*** Machine power off. (Not implemented) ***\n"); | |
| 36 | + while (1) { | |
| 37 | + if (cpu_wait) | |
| 38 | + cpu_wait(); | |
| 39 | + } | |
| 50 | 40 | } |
| @@ -44,7 +44,6 @@ · 43 unmodified lines | ||
| 44 | 44 | extern void __init board_setup(void); |
| 45 | 45 | extern void pnx8550_machine_restart(char *); |
| 46 | 46 | extern void pnx8550_machine_halt(void); |
| 47 | −extern void pnx8550_machine_power_off(void); | |
| 48 | 47 | extern struct resource ioport_resource; |
| 49 | 48 | extern struct resource iomem_resource; |
| 50 | 49 | extern char *prom_getcmdline(void); |
| @@ -100,7 +99,7 @@ void __init plat_mem_setup(void) · 49 unmodified lines | ||
| 100 | 99 | |
| 101 | 100 | _machine_restart = pnx8550_machine_restart; |
| 102 | 101 | _machine_halt = pnx8550_machine_halt; |
| 103 | − pm_power_off = pnx8550_machine_power_off; | |
| 102 | + pm_power_off = pnx8550_machine_halt; | |
| 104 | 103 | |
| 105 | 104 | /* Clear the Global 2 Register, PCI Inta Output Enable Registers |
| 106 | 105 | Bit 1:Enable DAC Powerdown |
| @@ -8,7 +8,6 @@ mainmenu "Linux Kernel Configuration" · 7 unmodified lines | ||
| 8 | 8 | config MN10300 |
| 9 | 9 | def_bool y |
| 10 | 10 | select HAVE_OPROFILE |
| 11 | − select HAVE_ARCH_TRACEHOOK | |
| 12 | 11 | |
| 13 | 12 | config AM33 |
| 14 | 13 | def_bool y |
| @@ -101,7 +101,7 @@ config GDBSTUB_DEBUG_BREAKPOINT · 100 unmodified lines | ||
| 101 | 101 | |
| 102 | 102 | choice |
| 103 | 103 | prompt "GDB stub port" |
| 104 | − default GDBSTUB_TTYSM0 | |
| 104 | + default GDBSTUB_ON_TTYSM0 | |
| 105 | 105 | depends on GDBSTUB |
| 106 | 106 | help |
| 107 | 107 | Select the serial port used for GDB-stub. |
| @@ -229,9 +229,9 @@ int ffs(int x) · 228 unmodified lines | ||
| 229 | 229 | #include <asm-generic/bitops/hweight.h> |
| 230 | 230 | |
| 231 | 231 | #define ext2_set_bit_atomic(lock, nr, addr) \ |
| 232 | − test_and_set_bit((nr) ^ 0x18, (addr)) | |
| 232 | + test_and_set_bit((nr), (addr)) | |
| 233 | 233 | #define ext2_clear_bit_atomic(lock, nr, addr) \ |
| 234 | − test_and_clear_bit((nr) ^ 0x18, (addr)) | |
| 234 | + test_and_clear_bit((nr), (addr)) | |
| 235 | 235 | |
| 236 | 236 | #include <asm-generic/bitops/ext2-non-atomic.h> |
| 237 | 237 | #include <asm-generic/bitops/minix-le.h> |
| @@ -78,7 +78,7 @@ typedef unsigned long sigset_t; · 77 unmodified lines | ||
| 78 | 78 | |
| 79 | 79 | /* These should not be considered constants from userland. */ |
| 80 | 80 | #define SIGRTMIN 32 |
| 81 | −#define SIGRTMAX (_NSIG-1) | |
| 81 | +#define SIGRTMAX _NSIG | |
| 82 | 82 | |
| 83 | 83 | /* |
| 84 | 84 | * SA_FLAGS values: |
| @@ -206,7 +206,7 @@ int module_finalize(const Elf_Ehdr *hdr, · 205 unmodified lines | ||
| 206 | 206 | const Elf_Shdr *sechdrs, |
| 207 | 207 | struct module *me) |
| 208 | 208 | { |
| 209 | − return module_bug_finalize(hdr, sechdrs, me); | |
| 209 | + return 0; | |
| 210 | 210 | } |
| 211 | 211 | |
| 212 | 212 | /* |
| @@ -214,5 +214,4 @@ int module_finalize(const Elf_Ehdr *hdr, · 1 unmodified line | ||
| 214 | 214 | */ |
| 215 | 215 | void module_arch_cleanup(struct module *mod) |
| 216 | 216 | { |
| 217 | − module_bug_cleanup(mod); | |
| 218 | 217 | } |
| @@ -65,10 +65,10 @@ asmlinkage long sys_sigaction(int sig, · 64 unmodified lines | ||
| 65 | 65 | old_sigset_t mask; |
| 66 | 66 | if (verify_area(VERIFY_READ, act, sizeof(*act)) || |
| 67 | 67 | __get_user(new_ka.sa.sa_handler, &act->sa_handler) || |
| 68 | − __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) | |
| 68 | + __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) || | |
| 69 | + __get_user(new_ka.sa.sa_flags, &act->sa_flags) || | |
| 70 | + __get_user(mask, &act->sa_mask)) | |
| 69 | 71 | return -EFAULT; |
| 70 | − __get_user(new_ka.sa.sa_flags, &act->sa_flags); | |
| 71 | − __get_user(mask, &act->sa_mask); | |
| 72 | 72 | siginitset(&new_ka.sa.sa_mask, mask); |
| 73 | 73 | } |
| 74 | 74 | |
| @@ -77,10 +77,10 @@ asmlinkage long sys_sigaction(int sig, · 2 unmodified lines | ||
| 77 | 77 | if (!ret && oact) { |
| 78 | 78 | if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) || |
| 79 | 79 | __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || |
| 80 | − __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) | |
| 80 | + __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) || | |
| 81 | + __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || | |
| 82 | + __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) | |
| 81 | 83 | return -EFAULT; |
| 82 | − __put_user(old_ka.sa.sa_flags, &oact->sa_flags); | |
| 83 | − __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); | |
| 84 | 84 | } |
| 85 | 85 | |
| 86 | 86 | return ret; |
| @@ -102,6 +102,9 @@ static int restore_sigcontext(struct pt_regs *regs, · 15 unmodified lines | ||
| 102 | 102 | { |
| 103 | 103 | unsigned int err = 0; |
| 104 | 104 | |
| 105 | + /* Always make any pending restarted system calls return -EINTR */ | |
| 106 | + current_thread_info()->restart_block.fn = do_no_restart_syscall; | |
| 107 | + | |
| 105 | 108 | if (is_using_fpu(current)) |
| 106 | 109 | fpu_kill_state(current); |
| 107 | 110 | |
| @@ -330,8 +333,6 @@ static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, · 222 unmodified lines | ||
| 330 | 333 | regs->d0 = sig; |
| 331 | 334 | regs->d1 = (unsigned long) &frame->sc; |
| 332 | 335 | |
| 333 | − set_fs(USER_DS); | |
| 334 | − | |
| 335 | 336 | /* the tracer may want to single-step inside the handler */ |
| 336 | 337 | if (test_thread_flag(TIF_SINGLESTEP)) |
| 337 | 338 | ptrace_notify(SIGTRAP); |
| @@ -345,7 +346,7 @@ static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, · 7 unmodified lines | ||
| 345 | 346 | return 0; |
| 346 | 347 | |
| 347 | 348 | give_sigsegv: |
| 348 | − force_sig(SIGSEGV, current); | |
| 349 | + force_sigsegv(sig, current); | |
| 349 | 350 | return -EFAULT; |
| 350 | 351 | } |
| 351 | 352 | |
| @@ -413,8 +414,6 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, · 61 unmodified lines | ||
| 413 | 414 | regs->d0 = sig; |
| 414 | 415 | regs->d1 = (long) &frame->info; |
| 415 | 416 | |
| 416 | − set_fs(USER_DS); | |
| 417 | − | |
| 418 | 417 | /* the tracer may want to single-step inside the handler */ |
| 419 | 418 | if (test_thread_flag(TIF_SINGLESTEP)) |
| 420 | 419 | ptrace_notify(SIGTRAP); |
| @@ -428,10 +427,16 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, · 7 unmodified lines | ||
| 428 | 427 | return 0; |
| 429 | 428 | |
| 430 | 429 | give_sigsegv: |
| 431 | − force_sig(SIGSEGV, current); | |
| 430 | + force_sigsegv(sig, current); | |
| 432 | 431 | return -EFAULT; |
| 433 | 432 | } |
| 434 | 433 | |
| 434 | +static inline void stepback(struct pt_regs *regs) | |
| 435 | +{ | |
| 436 | + regs->pc -= 2; | |
| 437 | + regs->orig_d0 = -1; | |
| 438 | +} | |
| 439 | + | |
| 435 | 440 | /* |
| 436 | 441 | * handle the actual delivery of a signal to userspace |
| 437 | 442 | */ |
| @@ -459,7 +464,7 @@ static int handle_signal(int sig, · 21 unmodified lines | ||
| 459 | 464 | /* fallthrough */ |
| 460 | 465 | case -ERESTARTNOINTR: |
| 461 | 466 | regs->d0 = regs->orig_d0; |
| 462 | − regs->pc -= 2; | |
| 467 | + stepback(regs); | |
| 463 | 468 | } |
| 464 | 469 | } |
| 465 | 470 | |
| @@ -527,12 +532,12 @@ static void do_signal(struct pt_regs *regs) · 61 unmodified lines | ||
| 527 | 532 | case -ERESTARTSYS: |
| 528 | 533 | case -ERESTARTNOINTR: |
| 529 | 534 | regs->d0 = regs->orig_d0; |
| 530 | − regs->pc -= 2; | |
| 535 | + stepback(regs); | |
| 531 | 536 | break; |
| 532 | 537 | |
| 533 | 538 | case -ERESTART_RESTARTBLOCK: |
| 534 | 539 | regs->d0 = __NR_restart_syscall; |
| 535 | − regs->pc -= 2; | |
| 540 | + stepback(regs); | |
| 536 | 541 | break; |
| 537 | 542 | } |
| 538 | 543 | } |
| @@ -2,13 +2,11 @@ · 1 unmodified line | ||
| 2 | 2 | # Makefile for the MN10300-specific memory management code |
| 3 | 3 | # |
| 4 | 4 | |
| 5 | +cacheflush-y := cache.o cache-mn10300.o | |
| 6 | +cacheflush-$(CONFIG_MN10300_CACHE_WBACK) += cache-flush-mn10300.o | |
| 7 | + | |
| 8 | +cacheflush-$(CONFIG_MN10300_CACHE_DISABLED) := cache-disabled.o | |
| 9 | + | |
| 5 | 10 | obj-y := \ |
| 6 | 11 | init.o fault.o pgtable.o extable.o tlb-mn10300.o mmu-context.o \ |
| 7 | − misalignment.o dma-alloc.o | |
| 8 | − | |
| 9 | −ifneq ($(CONFIG_MN10300_CACHE_DISABLED),y) | |
| 10 | −obj-y += cache.o cache-mn10300.o | |
| 11 | −ifeq ($(CONFIG_MN10300_CACHE_WBACK),y) | |
| 12 | −obj-y += cache-flush-mn10300.o | |
| 13 | −endif | |
| 14 | −endif | |
| 12 | + misalignment.o dma-alloc.o $(cacheflush-y) | |
| @@ -0,0 +1,21 @@ | ||
| 1 | +/* Handle the cache being disabled | |
| 2 | + * | |
| 3 | + * Copyright (C) 2010 Red Hat, Inc. All Rights Reserved. | |
| 4 | + * Written by David Howells (dhowells@redhat.com) | |
| 5 | + * | |
| 6 | + * This program is free software; you can redistribute it and/or | |
| 7 | + * modify it under the terms of the GNU General Public Licence | |
| 8 | + * as published by the Free Software Foundation; either version | |
| 9 | + * 2 of the Licence, or (at your option) any later version. | |
| 10 | + */ | |
| 11 | +#include <linux/mm.h> | |
| 12 | + | |
| 13 | +/* | |
| 14 | + * allow userspace to flush the instruction cache | |
| 15 | + */ | |
| 16 | +asmlinkage long sys_cacheflush(unsigned long start, unsigned long end) | |
| 17 | +{ | |
| 18 | + if (end < start) | |
| 19 | + return -EINVAL; | |
| 20 | + return 0; | |
| 21 | +} | |
| @@ -54,13 +54,30 @@ EXPORT_SYMBOL(flush_icache_page); · 53 unmodified lines | ||
| 54 | 54 | void flush_icache_range(unsigned long start, unsigned long end) |
| 55 | 55 | { |
| 56 | 56 | #ifdef CONFIG_MN10300_CACHE_WBACK |
| 57 | − unsigned long addr, size, off; | |
| 57 | + unsigned long addr, size, base, off; | |
| 58 | 58 | struct page *page; |
| 59 | 59 | pgd_t *pgd; |
| 60 | 60 | pud_t *pud; |
| 61 | 61 | pmd_t *pmd; |
| 62 | 62 | pte_t *ppte, pte; |
| 63 | 63 | |
| 64 | + if (end > 0x80000000UL) { | |
| 65 | + /* addresses above 0xa0000000 do not go through the cache */ | |
| 66 | + if (end > 0xa0000000UL) { | |
| 67 | + end = 0xa0000000UL; | |
| 68 | + if (start >= end) | |
| 69 | + return; | |
| 70 | + } | |
| 71 | + | |
| 72 | + /* kernel addresses between 0x80000000 and 0x9fffffff do not | |
| 73 | + * require page tables, so we just map such addresses directly */ | |
| 74 | + base = (start >= 0x80000000UL) ? start : 0x80000000UL; | |
| 75 | + mn10300_dcache_flush_range(base, end); | |
| 76 | + if (base == start) | |
| 77 | + goto invalidate; | |
| 78 | + end = base; | |
| 79 | + } | |
| 80 | + | |
| 64 | 81 | for (; start < end; start += size) { |
| 65 | 82 | /* work out how much of the page to flush */ |
| 66 | 83 | off = start & (PAGE_SIZE - 1); |
| @@ -104,6 +121,7 @@ void flush_icache_range(unsigned long start, unsigned long end) · 37 unmodified lines | ||
| 104 | 121 | } |
| 105 | 122 | #endif |
| 106 | 123 | |
| 124 | +invalidate: | |
| 107 | 125 | mn10300_icache_inv(); |
| 108 | 126 | } |
| 109 | 127 | EXPORT_SYMBOL(flush_icache_range); |
| @@ -941,11 +941,10 @@ int module_finalize(const Elf_Ehdr *hdr, · 940 unmodified lines | ||
| 941 | 941 | nsyms = newptr - (Elf_Sym *)symhdr->sh_addr; |
| 942 | 942 | DEBUGP("NEW num_symtab %lu\n", nsyms); |
| 943 | 943 | symhdr->sh_size = nsyms * sizeof(Elf_Sym); |
| 944 | − return module_bug_finalize(hdr, sechdrs, me); | |
| 944 | + return 0; | |
| 945 | 945 | } |
| 946 | 946 | |
| 947 | 947 | void module_arch_cleanup(struct module *mod) |
| 948 | 948 | { |
| 949 | 949 | deregister_unwind_table(mod); |
| 950 | − module_bug_cleanup(mod); | |
| 951 | 950 | } |
| @@ -63,11 +63,6 @@ int module_finalize(const Elf_Ehdr *hdr, · 62 unmodified lines | ||
| 63 | 63 | const Elf_Shdr *sechdrs, struct module *me) |
| 64 | 64 | { |
| 65 | 65 | const Elf_Shdr *sect; |
| 66 | − int err; | |
| 67 | − | |
| 68 | − err = module_bug_finalize(hdr, sechdrs, me); | |
| 69 | − if (err) | |
| 70 | − return err; | |
| 71 | 66 | |
| 72 | 67 | /* Apply feature fixups */ |
| 73 | 68 | sect = find_section(hdr, sechdrs, "__ftr_fixup"); |
| @@ -101,5 +96,4 @@ int module_finalize(const Elf_Ehdr *hdr, · 27 unmodified lines | ||
| 101 | 96 | |
| 102 | 97 | void module_arch_cleanup(struct module *mod) |
| 103 | 98 | { |
| 104 | − module_bug_cleanup(mod); | |
| 105 | 99 | } |
| @@ -57,7 +57,7 @@ static struct clk *mpc5121_clk_get(struct device *dev, const char *id) · 56 unmodified lines | ||
| 57 | 57 | int id_match = 0; |
| 58 | 58 | |
| 59 | 59 | if (dev == NULL || id == NULL) |
| 60 | − return NULL; | |
| 60 | + return clk; | |
| 61 | 61 | |
| 62 | 62 | mutex_lock(&clocks_mutex); |
| 63 | 63 | list_for_each_entry(p, &clocks, node) { |
| @@ -99,7 +99,7 @@ static void __init efika_pcisetup(void) · 98 unmodified lines | ||
| 99 | 99 | if (bus_range == NULL || len < 2 * sizeof(int)) { |
| 100 | 100 | printk(KERN_WARNING EFIKA_PLATFORM_NAME |
| 101 | 101 | ": Can't get bus-range for %s\n", pcictrl->full_name); |
| 102 | − return; | |
| 102 | + goto out_put; | |
| 103 | 103 | } |
| 104 | 104 | |
| 105 | 105 | if (bus_range[1] == bus_range[0]) |
| @@ -111,12 +111,12 @@ static void __init efika_pcisetup(void) · 5 unmodified lines | ||
| 111 | 111 | printk(" controlled by %s\n", pcictrl->full_name); |
| 112 | 112 | printk("\n"); |
| 113 | 113 | |
| 114 | − hose = pcibios_alloc_controller(of_node_get(pcictrl)); | |
| 114 | + hose = pcibios_alloc_controller(pcictrl); | |
| 115 | 115 | if (!hose) { |
| 116 | 116 | printk(KERN_WARNING EFIKA_PLATFORM_NAME |
| 117 | 117 | ": Can't allocate PCI controller structure for %s\n", |
| 118 | 118 | pcictrl->full_name); |
| 119 | − return; | |
| 119 | + goto out_put; | |
| 120 | 120 | } |
| 121 | 121 | |
| 122 | 122 | hose->first_busno = bus_range[0]; |
| @@ -124,6 +124,9 @@ static void __init efika_pcisetup(void) · 1 unmodified line | ||
| 124 | 124 | hose->ops = &rtas_pci_ops; |
| 125 | 125 | |
| 126 | 126 | pci_process_bridge_OF_ranges(hose, pcictrl, 0); |
| 127 | + return; | |
| 128 | +out_put: | |
| 129 | + of_node_put(pcictrl); | |
| 127 | 130 | } |
| 128 | 131 | |
| 129 | 132 | #else |
| @@ -325,12 +325,16 @@ int mpc5200_psc_ac97_gpio_reset(int psc_number) · 324 unmodified lines | ||
| 325 | 325 | clrbits32(&simple_gpio->simple_dvo, sync | out); |
| 326 | 326 | clrbits8(&wkup_gpio->wkup_dvo, reset); |
| 327 | 327 | |
| 328 | − /* wait at lease 1 us */ | |
| 329 | − udelay(2); | |
| 328 | + /* wait for 1 us */ | |
| 329 | + udelay(1); | |
| 330 | 330 | |
| 331 | 331 | /* Deassert reset */ |
| 332 | 332 | setbits8(&wkup_gpio->wkup_dvo, reset); |
| 333 | 333 | |
| 334 | + /* wait at least 200ns */ | |
| 335 | + /* 7 ~= (200ns * timebase) / ns2sec */ | |
| 336 | + __delay(7); | |
| 337 | + | |
| 334 | 338 | /* Restore pin-muxing */ |
| 335 | 339 | out_be32(&simple_gpio->port_config, mux); |
| 336 | 340 | |
| @@ -407,10 +407,9 @@ int module_finalize(const Elf_Ehdr *hdr, · 406 unmodified lines | ||
| 407 | 407 | { |
| 408 | 408 | vfree(me->arch.syminfo); |
| 409 | 409 | me->arch.syminfo = NULL; |
| 410 | − return module_bug_finalize(hdr, sechdrs, me); | |
| 410 | + return 0; | |
| 411 | 411 | } |
| 412 | 412 | |
| 413 | 413 | void module_arch_cleanup(struct module *mod) |
| 414 | 414 | { |
| 415 | − module_bug_cleanup(mod); | |
| 416 | 415 | } |
| @@ -149,13 +149,11 @@ int module_finalize(const Elf_Ehdr *hdr, · 148 unmodified lines | ||
| 149 | 149 | int ret = 0; |
| 150 | 150 | |
| 151 | 151 | ret |= module_dwarf_finalize(hdr, sechdrs, me); |
| 152 | − ret |= module_bug_finalize(hdr, sechdrs, me); | |
| 153 | 152 | |
| 154 | 153 | return ret; |
| 155 | 154 | } |
| 156 | 155 | |
| 157 | 156 | void module_arch_cleanup(struct module *mod) |
| 158 | 157 | { |
| 159 | − module_bug_cleanup(mod); | |
| 160 | 158 | module_dwarf_cleanup(mod); |
| 161 | 159 | } |
| @@ -1506,13 +1506,6 @@ handle_ill: · 1505 unmodified lines | ||
| 1506 | 1506 | } |
| 1507 | 1507 | STD_ENDPROC(handle_ill) |
| 1508 | 1508 | |
| 1509 | − .pushsection .rodata, "a" | |
| 1510 | − .align 8 | |
| 1511 | −bpt_code: | |
| 1512 | − bpt | |
| 1513 | − ENDPROC(bpt_code) | |
| 1514 | − .popsection | |
| 1515 | − | |
| 1516 | 1509 | /* Various stub interrupt handlers and syscall handlers */ |
| 1517 | 1510 | |
| 1518 | 1511 | STD_ENTRY_LOCAL(_kernel_double_fault) |
| @@ -255,18 +255,6 @@ static void uml_net_tx_timeout(struct net_device *dev) · 254 unmodified lines | ||
| 255 | 255 | netif_wake_queue(dev); |
| 256 | 256 | } |
| 257 | 257 | |
| 258 | −static int uml_net_set_mac(struct net_device *dev, void *addr) | |
| 259 | −{ | |
| 260 | − struct uml_net_private *lp = netdev_priv(dev); | |
| 261 | − struct sockaddr *hwaddr = addr; | |
| 262 | − | |
| 263 | − spin_lock_irq(&lp->lock); | |
| 264 | − eth_mac_addr(dev, hwaddr->sa_data); | |
| 265 | − spin_unlock_irq(&lp->lock); | |
| 266 | − | |
| 267 | − return 0; | |
| 268 | −} | |
| 269 | − | |
| 270 | 258 | static int uml_net_change_mtu(struct net_device *dev, int new_mtu) |
| 271 | 259 | { |
| 272 | 260 | dev->mtu = new_mtu; |
| @@ -373,7 +361,7 @@ static const struct net_device_ops uml_netdev_ops = { · 100 unmodified lines | ||
| 373 | 361 | .ndo_start_xmit = uml_net_start_xmit, |
| 374 | 362 | .ndo_set_multicast_list = uml_net_set_multicast_list, |
| 375 | 363 | .ndo_tx_timeout = uml_net_tx_timeout, |
| 376 | − .ndo_set_mac_address = uml_net_set_mac, | |
| 364 | + .ndo_set_mac_address = eth_mac_addr, | |
| 377 | 365 | .ndo_change_mtu = uml_net_change_mtu, |
| 378 | 366 | .ndo_validate_addr = eth_validate_addr, |
| 379 | 367 | }; |
| @@ -472,7 +460,8 @@ static void eth_configure(int n, void *init, char *mac, · 92 unmodified lines | ||
| 472 | 460 | ((*transport->user->init)(&lp->user, dev) != 0)) |
| 473 | 461 | goto out_unregister; |
| 474 | 462 | |
| 475 | − eth_mac_addr(dev, device->mac); | |
| 463 | + /* don't use eth_mac_addr, it will not work here */ | |
| 464 | + memcpy(dev->dev_addr, device->mac, ETH_ALEN); | |
| 476 | 465 | dev->mtu = transport->user->mtu; |
| 477 | 466 | dev->netdev_ops = ¨_netdev_ops; |
| 478 | 467 | dev->ethtool_ops = ¨_net_ethtool_ops; |
| @@ -62,7 +62,7 @@ static long execve1(const char *file, · 61 unmodified lines | ||
| 62 | 62 | return error; |
| 63 | 63 | } |
| 64 | 64 | |
| 65 | −long um_execve(const char *file, char __user *__user *argv, char __user *__user *env) | |
| 65 | +long um_execve(const char *file, const char __user *const __user *argv, const char __user *const __user *env) | |
| 66 | 66 | { |
| 67 | 67 | long err; |
| 68 | 68 | |
| @@ -72,8 +72,8 @@ long um_execve(const char *file, char __user *__user *argv, char __user *__user · 3 unmodified lines | ||
| 72 | 72 | return err; |
| 73 | 73 | } |
| 74 | 74 | |
| 75 | −long sys_execve(const char __user *file, char __user *__user *argv, | |
| 76 | − char __user *__user *env) | |
| 75 | +long sys_execve(const char __user *file, const char __user *const __user *argv, | |
| 76 | + const char __user *const __user *env) | |
| 77 | 77 | { |
| 78 | 78 | long error; |
| 79 | 79 | char *filename; |
| @@ -1 +1 @@ | ||
| 1 | −extern long um_execve(const char *file, char __user *__user *argv, char __user *__user *env); | |
| 1 | +extern long um_execve(const char *file, const char __user *const __user *argv, const char __user *const __user *env); | |
| @@ -60,8 +60,8 @@ int kernel_execve(const char *filename, · 59 unmodified lines | ||
| 60 | 60 | |
| 61 | 61 | fs = get_fs(); |
| 62 | 62 | set_fs(KERNEL_DS); |
| 63 | − ret = um_execve(filename, (char __user *__user *)argv, | |
| 64 | − (char __user *__user *) envp); | |
| 63 | + ret = um_execve(filename, (const char __user *const __user *)argv, | |
| 64 | + (const char __user *const __user *) envp); | |
| 65 | 65 | set_fs(fs); |
| 66 | 66 | |
| 67 | 67 | return ret; |
| @@ -58,7 +58,19 @@ static void parse_earlyprintk(void) · 57 unmodified lines | ||
| 58 | 58 | if (arg[pos] == ',') |
| 59 | 59 | pos++; |
| 60 | 60 | |
| 61 | − if (!strncmp(arg, "ttyS", 4)) { | |
| 61 | + /* | |
| 62 | + * make sure we have | |
| 63 | + * "serial,0x3f8,115200" | |
| 64 | + * "serial,ttyS0,115200" | |
| 65 | + * "ttyS0,115200" | |
| 66 | + */ | |
| 67 | + if (pos == 7 && !strncmp(arg + pos, "0x", 2)) { | |
| 68 | + port = simple_strtoull(arg + pos, &e, 16); | |
| 69 | + if (port == 0 || arg + pos == e) | |
| 70 | + port = DEFAULT_SERIAL_PORT; | |
| 71 | + else | |
| 72 | + pos = e - arg; | |
| 73 | + } else if (!strncmp(arg + pos, "ttyS", 4)) { | |
| 62 | 74 | static const int bases[] = { 0x3f8, 0x2f8 }; |
| 63 | 75 | int idx = 0; |
| 64 | 76 | |
| @@ -38,4 +38,10 @@ static inline void amd_iommu_stats_init(void) { } · 37 unmodified lines | ||
| 38 | 38 | |
| 39 | 39 | #endif /* !CONFIG_AMD_IOMMU_STATS */ |
| 40 | 40 | |
| 41 | +static inline bool is_rd890_iommu(struct pci_dev *pdev) | |
| 42 | +{ | |
| 43 | + return (pdev->vendor == PCI_VENDOR_ID_ATI) && | |
| 44 | + (pdev->device == PCI_DEVICE_ID_RD890_IOMMU); | |
| 45 | +} | |
| 46 | + | |
| 41 | 47 | #endif /* _ASM_X86_AMD_IOMMU_PROTO_H */ |
| @@ -368,6 +368,9 @@ struct amd_iommu { · 367 unmodified lines | ||
| 368 | 368 | /* capabilities of that IOMMU read from ACPI */ |
| 369 | 369 | u32 cap; |
| 370 | 370 | |
| 371 | + /* flags read from acpi table */ | |
| 372 | + u8 acpi_flags; | |
| 373 | + | |
| 371 | 374 | /* |
| 372 | 375 | * Capability pointer. There could be more than one IOMMU per PCI |
| 373 | 376 | * device function if there are more than one AMD IOMMU capability |
| @@ -411,6 +414,15 @@ struct amd_iommu { · 37 unmodified lines | ||
| 411 | 414 | |
| 412 | 415 | /* default dma_ops domain for that IOMMU */ |
| 413 | 416 | struct dma_ops_domain *default_dom; |
| 417 | + | |
| 418 | + /* | |
| 419 | + * This array is required to work around a potential BIOS bug. | |
| 420 | + * The BIOS may miss to restore parts of the PCI configuration | |
| 421 | + * space when the system resumes from S3. The result is that the | |
| 422 | + * IOMMU does not execute commands anymore which leads to system | |
| 423 | + * failure. | |
| 424 | + */ | |
| 425 | + u32 cache_cfg[4]; | |
| 414 | 426 | }; |
| 415 | 427 | |
| 416 | 428 | /* |
| @@ -309,7 +309,7 @@ static inline int test_and_change_bit(int nr, volatile unsigned long *addr) · 308 unmodified lines | ||
| 309 | 309 | static __always_inline int constant_test_bit(unsigned int nr, const volatile unsigned long *addr) |
| 310 | 310 | { |
| 311 | 311 | return ((1UL << (nr % BITS_PER_LONG)) & |
| 312 | − (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0; | |
| 312 | + (addr[nr / BITS_PER_LONG])) != 0; | |
| 313 | 313 | } |
| 314 | 314 | |
| 315 | 315 | static inline int variable_test_bit(int nr, volatile const unsigned long *addr) |
| @@ -168,6 +168,7 @@ · 167 unmodified lines | ||
| 168 | 168 | #define X86_FEATURE_XSAVEOPT (7*32+ 4) /* Optimized Xsave */ |
| 169 | 169 | #define X86_FEATURE_PLN (7*32+ 5) /* Intel Power Limit Notification */ |
| 170 | 170 | #define X86_FEATURE_PTS (7*32+ 6) /* Intel Package Thermal Status */ |
| 171 | +#define X86_FEATURE_DTS (7*32+ 7) /* Digital Thermal Sensor */ | |
| 171 | 172 | |
| 172 | 173 | /* Virtualization flags: Linux defined, word 8 */ |
| 173 | 174 | #define X86_FEATURE_TPR_SHADOW (8*32+ 0) /* Intel TPR Shadow */ |
| @@ -61,7 +61,7 @@ struct cstate_entry { · 60 unmodified lines | ||
| 61 | 61 | unsigned int ecx; |
| 62 | 62 | } states[ACPI_PROCESSOR_MAX_POWER]; |
| 63 | 63 | }; |
| 64 | −static struct cstate_entry *cpu_cstate_entry; /* per CPU ptr */ | |
| 64 | +static struct cstate_entry __percpu *cpu_cstate_entry; /* per CPU ptr */ | |
| 65 | 65 | |
| 66 | 66 | static short mwait_supported[ACPI_PROCESSOR_MAX_POWER]; |
| 67 | 67 | |
| @@ -1953,6 +1953,7 @@ static void __unmap_single(struct dma_ops_domain *dma_dom, · 1952 unmodified lines | ||
| 1953 | 1953 | size_t size, |
| 1954 | 1954 | int dir) |
| 1955 | 1955 | { |
| 1956 | + dma_addr_t flush_addr; | |
| 1956 | 1957 | dma_addr_t i, start; |
| 1957 | 1958 | unsigned int pages; |
| 1958 | 1959 | |
| @@ -1960,6 +1961,7 @@ static void __unmap_single(struct dma_ops_domain *dma_dom, · 1 unmodified line | ||
| 1960 | 1961 | (dma_addr + size > dma_dom->aperture_size)) |
| 1961 | 1962 | return; |
| 1962 | 1963 | |
| 1964 | + flush_addr = dma_addr; | |
| 1963 | 1965 | pages = iommu_num_pages(dma_addr, size, PAGE_SIZE); |
| 1964 | 1966 | dma_addr &= PAGE_MASK; |
| 1965 | 1967 | start = dma_addr; |
| @@ -1974,7 +1976,7 @@ static void __unmap_single(struct dma_ops_domain *dma_dom, · 8 unmodified lines | ||
| 1974 | 1976 | dma_ops_free_addresses(dma_dom, dma_addr, pages); |
| 1975 | 1977 | |
| 1976 | 1978 | if (amd_iommu_unmap_flush || dma_dom->need_flush) { |
| 1977 | − iommu_flush_pages(&dma_dom->domain, dma_addr, size); | |
| 1979 | + iommu_flush_pages(&dma_dom->domain, flush_addr, size); | |
| 1978 | 1980 | dma_dom->need_flush = false; |
| 1979 | 1981 | } |
| 1980 | 1982 | } |
| @@ -632,6 +632,13 @@ static void __init init_iommu_from_pci(struct amd_iommu *iommu) · 631 unmodified lines | ||
| 632 | 632 | iommu->last_device = calc_devid(MMIO_GET_BUS(range), |
| 633 | 633 | MMIO_GET_LD(range)); |
| 634 | 634 | iommu->evt_msi_num = MMIO_MSI_NUM(misc); |
| 635 | + | |
| 636 | + if (is_rd890_iommu(iommu->dev)) { | |
| 637 | + pci_read_config_dword(iommu->dev, 0xf0, &iommu->cache_cfg[0]); | |
| 638 | + pci_read_config_dword(iommu->dev, 0xf4, &iommu->cache_cfg[1]); | |
| 639 | + pci_read_config_dword(iommu->dev, 0xf8, &iommu->cache_cfg[2]); | |
| 640 | + pci_read_config_dword(iommu->dev, 0xfc, &iommu->cache_cfg[3]); | |
| 641 | + } | |
| 635 | 642 | } |
| 636 | 643 | |
| 637 | 644 | /* |
| @@ -649,29 +656,9 @@ static void __init init_iommu_from_acpi(struct amd_iommu *iommu, · 11 unmodified lines | ||
| 649 | 656 | struct ivhd_entry *e; |
| 650 | 657 | |
| 651 | 658 | /* |
| 652 | − * First set the recommended feature enable bits from ACPI | |
| 653 | − * into the IOMMU control registers | |
| 659 | + * First save the recommended feature enable bits from ACPI | |
| 654 | 660 | */ |
| 655 | − h->flags & IVHD_FLAG_HT_TUN_EN_MASK ? | |
| 656 | − iommu_feature_enable(iommu, CONTROL_HT_TUN_EN) : | |
| 657 | − iommu_feature_disable(iommu, CONTROL_HT_TUN_EN); | |
| 658 | − | |
| 659 | − h->flags & IVHD_FLAG_PASSPW_EN_MASK ? | |
| 660 | − iommu_feature_enable(iommu, CONTROL_PASSPW_EN) : | |
| 661 | − iommu_feature_disable(iommu, CONTROL_PASSPW_EN); | |
| 662 | − | |
| 663 | − h->flags & IVHD_FLAG_RESPASSPW_EN_MASK ? | |
| 664 | − iommu_feature_enable(iommu, CONTROL_RESPASSPW_EN) : | |
| 665 | − iommu_feature_disable(iommu, CONTROL_RESPASSPW_EN); | |
| 666 | − | |
| 667 | − h->flags & IVHD_FLAG_ISOC_EN_MASK ? | |
| 668 | − iommu_feature_enable(iommu, CONTROL_ISOC_EN) : | |
| 669 | − iommu_feature_disable(iommu, CONTROL_ISOC_EN); | |
| 670 | − | |
| 671 | − /* | |
| 672 | − * make IOMMU memory accesses cache coherent | |
| 673 | − */ | |
| 674 | − iommu_feature_enable(iommu, CONTROL_COHERENT_EN); | |
| 661 | + iommu->acpi_flags = h->flags; | |
| 675 | 662 | |
| 676 | 663 | /* |
| 677 | 664 | * Done. Now parse the device entries |
| @@ -1116,6 +1103,40 @@ static void init_device_table(void) · 438 unmodified lines | ||
| 1116 | 1103 | } |
| 1117 | 1104 | } |
| 1118 | 1105 | |
| 1106 | +static void iommu_init_flags(struct amd_iommu *iommu) | |
| 1107 | +{ | |
| 1108 | + iommu->acpi_flags & IVHD_FLAG_HT_TUN_EN_MASK ? | |
| 1109 | + iommu_feature_enable(iommu, CONTROL_HT_TUN_EN) : | |
| 1110 | + iommu_feature_disable(iommu, CONTROL_HT_TUN_EN); | |
| 1111 | + | |
| 1112 | + iommu->acpi_flags & IVHD_FLAG_PASSPW_EN_MASK ? | |
| 1113 | + iommu_feature_enable(iommu, CONTROL_PASSPW_EN) : | |
| 1114 | + iommu_feature_disable(iommu, CONTROL_PASSPW_EN); | |
| 1115 | + | |
| 1116 | + iommu->acpi_flags & IVHD_FLAG_RESPASSPW_EN_MASK ? | |
| 1117 | + iommu_feature_enable(iommu, CONTROL_RESPASSPW_EN) : | |
| 1118 | + iommu_feature_disable(iommu, CONTROL_RESPASSPW_EN); | |
| 1119 | + | |
| 1120 | + iommu->acpi_flags & IVHD_FLAG_ISOC_EN_MASK ? | |
| 1121 | + iommu_feature_enable(iommu, CONTROL_ISOC_EN) : | |
| 1122 | + iommu_feature_disable(iommu, CONTROL_ISOC_EN); | |
| 1123 | + | |
| 1124 | + /* | |
| 1125 | + * make IOMMU memory accesses cache coherent | |
| 1126 | + */ | |
| 1127 | + iommu_feature_enable(iommu, CONTROL_COHERENT_EN); | |
| 1128 | +} | |
| 1129 | + | |
| 1130 | +static void iommu_apply_quirks(struct amd_iommu *iommu) | |
| 1131 | +{ | |
| 1132 | + if (is_rd890_iommu(iommu->dev)) { | |
| 1133 | + pci_write_config_dword(iommu->dev, 0xf0, iommu->cache_cfg[0]); | |
| 1134 | + pci_write_config_dword(iommu->dev, 0xf4, iommu->cache_cfg[1]); | |
| 1135 | + pci_write_config_dword(iommu->dev, 0xf8, iommu->cache_cfg[2]); | |
| 1136 | + pci_write_config_dword(iommu->dev, 0xfc, iommu->cache_cfg[3]); | |
| 1137 | + } | |
| 1138 | +} | |
| 1139 | + | |
| 1119 | 1140 | /* |
| 1120 | 1141 | * This function finally enables all IOMMUs found in the system after |
| 1121 | 1142 | * they have been initialized |
| @@ -1126,6 +1147,8 @@ static void enable_iommus(void) · 4 unmodified lines | ||
| 1126 | 1147 | |
| 1127 | 1148 | for_each_iommu(iommu) { |
| 1128 | 1149 | iommu_disable(iommu); |
| 1150 | + iommu_apply_quirks(iommu); | |
| 1151 | + iommu_init_flags(iommu); | |
| 1129 | 1152 | iommu_set_device_table(iommu); |
| 1130 | 1153 | iommu_enable_command_buffer(iommu); |
| 1131 | 1154 | iommu_enable_event_buffer(iommu); |
| @@ -306,14 +306,19 @@ void arch_init_copy_chip_data(struct irq_desc *old_desc, · 305 unmodified lines | ||
| 306 | 306 | |
| 307 | 307 | old_cfg = old_desc->chip_data; |
| 308 | 308 | |
| 309 | − memcpy(cfg, old_cfg, sizeof(struct irq_cfg)); | |
| 309 | + cfg->vector = old_cfg->vector; | |
| 310 | + cfg->move_in_progress = old_cfg->move_in_progress; | |
| 311 | + cpumask_copy(cfg->domain, old_cfg->domain); | |
| 312 | + cpumask_copy(cfg->old_domain, old_cfg->old_domain); | |
| 310 | 313 | |
| 311 | 314 | init_copy_irq_2_pin(old_cfg, cfg, node); |
| 312 | 315 | } |
| 313 | 316 | |
| 314 | −static void free_irq_cfg(struct irq_cfg *old_cfg) | |
| 317 | +static void free_irq_cfg(struct irq_cfg *cfg) | |
| 315 | 318 | { |
| 316 | − kfree(old_cfg); | |
| 319 | + free_cpumask_var(cfg->domain); | |
| 320 | + free_cpumask_var(cfg->old_domain); | |
| 321 | + kfree(cfg); | |
| 317 | 322 | } |
| 318 | 323 | |
| 319 | 324 | void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc) |
| @@ -545,7 +545,7 @@ void __cpuinit cpu_detect(struct cpuinfo_x86 *c) · 544 unmodified lines | ||
| 545 | 545 | } |
| 546 | 546 | } |
| 547 | 547 | |
| 548 | −static void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c) | |
| 548 | +void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c) | |
| 549 | 549 | { |
| 550 | 550 | u32 tfms, xlvl; |
| 551 | 551 | u32 ebx; |
| @@ -33,5 +33,6 @@ extern const struct cpu_dev *const __x86_cpu_dev_start[], · 32 unmodified lines | ||
| 33 | 33 | *const __x86_cpu_dev_end[]; |
| 34 | 34 | |
| 35 | 35 | extern void cpu_detect_cache_sizes(struct cpuinfo_x86 *c); |
| 36 | +extern void get_cpu_cap(struct cpuinfo_x86 *c); | |
| 36 | 37 | |
| 37 | 38 | #endif |
| @@ -368,16 +368,22 @@ static int __init pcc_cpufreq_do_osc(acpi_handle *handle) · 367 unmodified lines | ||
| 368 | 368 | return -ENODEV; |
| 369 | 369 | |
| 370 | 370 | out_obj = output.pointer; |
| 371 | − if (out_obj->type != ACPI_TYPE_BUFFER) | |
| 372 | − return -ENODEV; | |
| 371 | + if (out_obj->type != ACPI_TYPE_BUFFER) { | |
| 372 | + ret = -ENODEV; | |
| 373 | + goto out_free; | |
| 374 | + } | |
| 373 | 375 | |
| 374 | 376 | errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0); |
| 375 | − if (errors) | |
| 376 | − return -ENODEV; | |
| 377 | + if (errors) { | |
| 378 | + ret = -ENODEV; | |
| 379 | + goto out_free; | |
| 380 | + } | |
| 377 | 381 | |
| 378 | 382 | supported = *((u32 *)(out_obj->buffer.pointer + 4)); |
| 379 | − if (!(supported & 0x1)) | |
| 380 | − return -ENODEV; | |
| 383 | + if (!(supported & 0x1)) { | |
| 384 | + ret = -ENODEV; | |
| 385 | + goto out_free; | |
| 386 | + } | |
| 381 | 387 | |
| 382 | 388 | out_free: |
| 383 | 389 | kfree(output.pointer); |
| @@ -39,6 +39,7 @@ static void __cpuinit early_init_intel(struct cpuinfo_x86 *c) · 38 unmodified lines | ||
| 39 | 39 | misc_enable &= ~MSR_IA32_MISC_ENABLE_LIMIT_CPUID; |
| 40 | 40 | wrmsrl(MSR_IA32_MISC_ENABLE, misc_enable); |
| 41 | 41 | c->cpuid_level = cpuid_eax(0); |
| 42 | + get_cpu_cap(c); | |
| 42 | 43 | } |
| 43 | 44 | } |
| 44 | 45 | |
| @@ -31,6 +31,7 @@ void __cpuinit init_scattered_cpuid_features(struct cpuinfo_x86 *c) · 30 unmodified lines | ||
| 31 | 31 | const struct cpuid_bit *cb; |
| 32 | 32 | |
| 33 | 33 | static const struct cpuid_bit __cpuinitconst cpuid_bits[] = { |
| 34 | + { X86_FEATURE_DTS, CR_EAX, 0, 0x00000006, 0 }, | |
| 34 | 35 | { X86_FEATURE_IDA, CR_EAX, 1, 0x00000006, 0 }, |
| 35 | 36 | { X86_FEATURE_ARAT, CR_EAX, 2, 0x00000006, 0 }, |
| 36 | 37 | { X86_FEATURE_PLN, CR_EAX, 4, 0x00000006, 0 }, |
| @@ -506,7 +506,7 @@ static int hpet_assign_irq(struct hpet_dev *dev) · 505 unmodified lines | ||
| 506 | 506 | { |
| 507 | 507 | unsigned int irq; |
| 508 | 508 | |
| 509 | − irq = create_irq(); | |
| 509 | + irq = create_irq_nr(0, -1); | |
| 510 | 510 | if (!irq) |
| 511 | 511 | return -EINVAL; |
| 512 | 512 | |
| @@ -242,11 +242,10 @@ int module_finalize(const Elf_Ehdr *hdr, · 241 unmodified lines | ||
| 242 | 242 | /* make jump label nops */ |
| 243 | 243 | jump_label_apply_nops(me); |
| 244 | 244 | |
| 245 | − return module_bug_finalize(hdr, sechdrs, me); | |
| 245 | + return 0; | |
| 246 | 246 | } |
| 247 | 247 | |
| 248 | 248 | void module_arch_cleanup(struct module *mod) |
| 249 | 249 | { |
| 250 | 250 | alternatives_smp_module_del(mod); |
| 251 | − module_bug_cleanup(mod); | |
| 252 | 251 | } |
| @@ -489,8 +489,9 @@ static void xen_hvm_setup_cpu_clockevents(void) · 488 unmodified lines | ||
| 489 | 489 | __init void xen_hvm_init_time_ops(void) |
| 490 | 490 | { |
| 491 | 491 | /* vector callback is needed otherwise we cannot receive interrupts |
| 492 | − * on cpu > 0 */ | |
| 493 | − if (!xen_have_vector_callback && num_present_cpus() > 1) | |
| 492 | + * on cpu > 0 and at this point we don't know how many cpus are | |
| 493 | + * available */ | |
| 494 | + if (!xen_have_vector_callback) | |
| 494 | 495 | return; |
| 495 | 496 | if (!xen_feature(XENFEAT_hvm_safe_pvclock)) { |
| 496 | 497 | printk(KERN_INFO "Xen doesn't support pvclock on HVM," |
| @@ -361,6 +361,18 @@ static int attempt_merge(struct request_queue *q, struct request *req, · 360 unmodified lines | ||
| 361 | 361 | if (!rq_mergeable(req) || !rq_mergeable(next)) |
| 362 | 362 | return 0; |
| 363 | 363 | |
| 364 | + /* | |
| 365 | + * Don't merge file system requests and discard requests | |
| 366 | + */ | |
| 367 | + if ((req->cmd_flags & REQ_DISCARD) != (next->cmd_flags & REQ_DISCARD)) | |
| 368 | + return 0; | |
| 369 | + | |
| 370 | + /* | |
| 371 | + * Don't merge discard requests and secure discard requests | |
| 372 | + */ | |
| 373 | + if ((req->cmd_flags & REQ_SECURE) != (next->cmd_flags & REQ_SECURE)) | |
| 374 | + return 0; | |
| 375 | + | |
| 364 | 376 | /* |
| 365 | 377 | * not contiguous |
| 366 | 378 | */ |
| @@ -105,7 +105,7 @@ config ACPI_EC_DEBUGFS · 104 unmodified lines | ||
| 105 | 105 | |
| 106 | 106 | Be aware that using this interface can confuse your Embedded |
| 107 | 107 | Controller in a way that a normal reboot is not enough. You then |
| 108 | − have to power of your system, and remove the laptop battery for | |
| 108 | + have to power off your system, and remove the laptop battery for | |
| 109 | 109 | some seconds. |
| 110 | 110 | An Embedded Controller typically is available on laptops and reads |
| 111 | 111 | sensor values like battery state and temperature. |
| @@ -382,31 +382,32 @@ static void acpi_pad_remove_sysfs(struct acpi_device *device) · 381 unmodified lines | ||
| 382 | 382 | device_remove_file(&device->dev, &dev_attr_rrtime); |
| 383 | 383 | } |
| 384 | 384 | |
| 385 | −/* Query firmware how many CPUs should be idle */ | |
| 386 | −static int acpi_pad_pur(acpi_handle handle, int *num_cpus) | |
| 385 | +/* | |
| 386 | + * Query firmware how many CPUs should be idle | |
| 387 | + * return -1 on failure | |
| 388 | + */ | |
| 389 | +static int acpi_pad_pur(acpi_handle handle) | |
| 387 | 390 | { |
| 388 | 391 | struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; |
| 389 | 392 | union acpi_object *package; |
| 390 | − int rev, num, ret = -EINVAL; | |
| 393 | + int num = -1; | |
| 391 | 394 | |
| 392 | 395 | if (ACPI_FAILURE(acpi_evaluate_object(handle, "_PUR", NULL, &buffer))) |
| 393 | − return -EINVAL; | |
| 396 | + return num; | |
| 394 | 397 | |
| 395 | 398 | if (!buffer.length || !buffer.pointer) |
| 396 | − return -EINVAL; | |
| 399 | + return num; | |
| 397 | 400 | |
| 398 | 401 | package = buffer.pointer; |
| 399 | − if (package->type != ACPI_TYPE_PACKAGE || package->package.count != 2) | |
| 400 | − goto out; | |
| 401 | − rev = package->package.elements[0].integer.value; | |
| 402 | − num = package->package.elements[1].integer.value; | |
| 403 | − if (rev != 1 || num < 0) | |
| 404 | − goto out; | |
| 405 | − *num_cpus = num; | |
| 406 | − ret = 0; | |
| 407 | −out: | |
| 402 | + | |
| 403 | + if (package->type == ACPI_TYPE_PACKAGE && | |
| 404 | + package->package.count == 2 && | |
| 405 | + package->package.elements[0].integer.value == 1) /* rev 1 */ | |
| 406 | + | |
| 407 | + num = package->package.elements[1].integer.value; | |
| 408 | + | |
| 408 | 409 | kfree(buffer.pointer); |
| 409 | − return ret; | |
| 410 | + return num; | |
| 410 | 411 | } |
| 411 | 412 | |
| 412 | 413 | /* Notify firmware how many CPUs are idle */ |
| @@ -433,7 +434,8 @@ static void acpi_pad_handle_notify(acpi_handle handle) · 20 unmodified lines | ||
| 433 | 434 | uint32_t idle_cpus; |
| 434 | 435 | |
| 435 | 436 | mutex_lock(&isolated_cpus_lock); |
| 436 | − if (acpi_pad_pur(handle, &num_cpus)) { | |
| 437 | + num_cpus = acpi_pad_pur(handle); | |
| 438 | + if (num_cpus < 0) { | |
| 437 | 439 | mutex_unlock(&isolated_cpus_lock); |
| 438 | 440 | return; |
| 439 | 441 | } |
| @@ -854,6 +854,7 @@ struct acpi_bit_register_info { · 853 unmodified lines | ||
| 854 | 854 | ACPI_BITMASK_POWER_BUTTON_STATUS | \ |
| 855 | 855 | ACPI_BITMASK_SLEEP_BUTTON_STATUS | \ |
| 856 | 856 | ACPI_BITMASK_RT_CLOCK_STATUS | \ |
| 857 | + ACPI_BITMASK_PCIEXP_WAKE_DISABLE | \ | |
| 857 | 858 | ACPI_BITMASK_WAKE_STATUS) |
| 858 | 859 | |
| 859 | 860 | #define ACPI_BITMASK_TIMER_ENABLE 0x0001 |
| @@ -109,7 +109,7 @@ void acpi_ex_enter_interpreter(void) · 108 unmodified lines | ||
| 109 | 109 | * |
| 110 | 110 | * DESCRIPTION: Reacquire the interpreter execution region from within the |
| 111 | 111 | * interpreter code. Failure to enter the interpreter region is a |
| 112 | − * fatal system error. Used in conjuction with | |
| 112 | + * fatal system error. Used in conjunction with | |
| 113 | 113 | * relinquish_interpreter |
| 114 | 114 | * |
| 115 | 115 | ******************************************************************************/ |
| @@ -149,7 +149,7 @@ acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type) · 148 unmodified lines | ||
| 149 | 149 | |
| 150 | 150 | /* |
| 151 | 151 | * 16-, 32-, and 64-bit cases must use the move macros that perform |
| 152 | − * endian conversion and/or accomodate hardware that cannot perform | |
| 152 | + * endian conversion and/or accommodate hardware that cannot perform | |
| 153 | 153 | * misaligned memory transfers |
| 154 | 154 | */ |
| 155 | 155 | case ACPI_RSC_MOVE16: |
| @@ -34,6 +34,6 @@ config ACPI_APEI_ERST_DEBUG · 33 unmodified lines | ||
| 34 | 34 | depends on ACPI_APEI |
| 35 | 35 | help |
| 36 | 36 | ERST is a way provided by APEI to save and retrieve hardware |
| 37 | − error infomation to and from a persistent store. Enable this | |
| 37 | + error information to and from a persistent store. Enable this | |
| 38 | 38 | if you want to debugging and testing the ERST kernel support |
| 39 | 39 | and firmware implementation. |
| @@ -445,11 +445,15 @@ EXPORT_SYMBOL_GPL(apei_resources_sub); · 444 unmodified lines | ||
| 445 | 445 | int apei_resources_request(struct apei_resources *resources, |
| 446 | 446 | const char *desc) |
| 447 | 447 | { |
| 448 | − struct apei_res *res, *res_bak; | |
| 448 | + struct apei_res *res, *res_bak = NULL; | |
| 449 | 449 | struct resource *r; |
| 450 | + int rc; | |
| 450 | 451 | |
| 451 | − apei_resources_sub(resources, &apei_resources_all); | |
| 452 | + rc = apei_resources_sub(resources, &apei_resources_all); | |
| 453 | + if (rc) | |
| 454 | + return rc; | |
| 452 | 455 | |
| 456 | + rc = -EINVAL; | |
| 453 | 457 | list_for_each_entry(res, &resources->iomem, list) { |
| 454 | 458 | r = request_mem_region(res->start, res->end - res->start, |
| 455 | 459 | desc); |
| @@ -475,7 +479,11 @@ int apei_resources_request(struct apei_resources *resources, · 19 unmodified lines | ||
| 475 | 479 | } |
| 476 | 480 | } |
| 477 | 481 | |
| 478 | − apei_resources_merge(&apei_resources_all, resources); | |
| 482 | + rc = apei_resources_merge(&apei_resources_all, resources); | |
| 483 | + if (rc) { | |
| 484 | + pr_err(APEI_PFX "Fail to merge resources!\n"); | |
| 485 | + goto err_unmap_ioport; | |
| 486 | + } | |
| 479 | 487 | |
| 480 | 488 | return 0; |
| 481 | 489 | err_unmap_ioport: |
| @@ -491,12 +499,13 @@ err_unmap_iomem: · 9 unmodified lines | ||
| 491 | 499 | break; |
| 492 | 500 | release_mem_region(res->start, res->end - res->start); |
| 493 | 501 | } |
| 494 | − return -EINVAL; | |
| 502 | + return rc; | |
| 495 | 503 | } |
| 496 | 504 | EXPORT_SYMBOL_GPL(apei_resources_request); |
| 497 | 505 | |
| 498 | 506 | void apei_resources_release(struct apei_resources *resources) |
| 499 | 507 | { |
| 508 | + int rc; | |
| 500 | 509 | struct apei_res *res; |
| 501 | 510 | |
| 502 | 511 | list_for_each_entry(res, &resources->iomem, list) |
| @@ -504,7 +513,9 @@ void apei_resources_release(struct apei_resources *resources) · 1 unmodified line | ||
| 504 | 513 | list_for_each_entry(res, &resources->ioport, list) |
| 505 | 514 | release_region(res->start, res->end - res->start); |
| 506 | 515 | |
| 507 | − apei_resources_sub(&apei_resources_all, resources); | |
| 516 | + rc = apei_resources_sub(&apei_resources_all, resources); | |
| 517 | + if (rc) | |
| 518 | + pr_err(APEI_PFX "Fail to sub resources!\n"); | |
| 508 | 519 | } |
| 509 | 520 | EXPORT_SYMBOL_GPL(apei_resources_release); |
| 510 | 521 | |
| @@ -426,7 +426,9 @@ DEFINE_SIMPLE_ATTRIBUTE(error_inject_fops, NULL, · 425 unmodified lines | ||
| 426 | 426 | |
| 427 | 427 | static int einj_check_table(struct acpi_table_einj *einj_tab) |
| 428 | 428 | { |
| 429 | − if (einj_tab->header_length != sizeof(struct acpi_table_einj)) | |
| 429 | + if ((einj_tab->header_length != | |
| 430 | + (sizeof(struct acpi_table_einj) - sizeof(einj_tab->header))) | |
| 431 | + && (einj_tab->header_length != sizeof(struct acpi_table_einj))) | |
| 430 | 432 | return -EINVAL; |
| 431 | 433 | if (einj_tab->header.length < sizeof(struct acpi_table_einj)) |
| 432 | 434 | return -EINVAL; |
| @@ -2,7 +2,7 @@ · 1 unmodified line | ||
| 2 | 2 | * APEI Error Record Serialization Table debug support |
| 3 | 3 | * |
| 4 | 4 | * ERST is a way provided by APEI to save and retrieve hardware error |
| 5 | − * infomation to and from a persistent store. This file provide the | |
| 5 | + * information to and from a persistent store. This file provide the | |
| 6 | 6 | * debugging/testing support for ERST kernel support and firmware |
| 7 | 7 | * implementation. |
| 8 | 8 | * |
| @@ -111,11 +111,13 @@ retry: · 102 unmodified lines | ||
| 111 | 111 | goto out; |
| 112 | 112 | } |
| 113 | 113 | if (len > erst_dbg_buf_len) { |
| 114 | − kfree(erst_dbg_buf); | |
| 114 | + void *p; | |
| 115 | 115 | rc = -ENOMEM; |
| 116 | − erst_dbg_buf = kmalloc(len, GFP_KERNEL); | |
| 117 | − if (!erst_dbg_buf) | |
| 116 | + p = kmalloc(len, GFP_KERNEL); | |
| 117 | + if (!p) | |
| 118 | 118 | goto out; |
| 119 | + kfree(erst_dbg_buf); | |
| 120 | + erst_dbg_buf = p; | |
| 119 | 121 | erst_dbg_buf_len = len; |
| 120 | 122 | goto retry; |
| 121 | 123 | } |
| @@ -150,11 +152,13 @@ static ssize_t erst_dbg_write(struct file *filp, const char __user *ubuf, · 28 unmodified lines | ||
| 150 | 152 | if (mutex_lock_interruptible(&erst_dbg_mutex)) |
| 151 | 153 | return -EINTR; |
| 152 | 154 | if (usize > erst_dbg_buf_len) { |
| 153 | − kfree(erst_dbg_buf); | |
| 155 | + void *p; | |
| 154 | 156 | rc = -ENOMEM; |
| 155 | − erst_dbg_buf = kmalloc(usize, GFP_KERNEL); | |
| 156 | − if (!erst_dbg_buf) | |
| 157 | + p = kmalloc(usize, GFP_KERNEL); | |
| 158 | + if (!p) | |
| 157 | 159 | goto out; |
| 160 | + kfree(erst_dbg_buf); | |
| 161 | + erst_dbg_buf = p; | |
| 158 | 162 | erst_dbg_buf_len = usize; |
| 159 | 163 | } |
| 160 | 164 | rc = copy_from_user(erst_dbg_buf, ubuf, usize); |
| @@ -2,7 +2,7 @@ · 1 unmodified line | ||
| 2 | 2 | * APEI Error Record Serialization Table support |
| 3 | 3 | * |
| 4 | 4 | * ERST is a way provided by APEI to save and retrieve hardware error |
| 5 | − * infomation to and from a persistent store. | |
| 5 | + * information to and from a persistent store. | |
| 6 | 6 | * |
| 7 | 7 | * For more information about ERST, please refer to ACPI Specification |
| 8 | 8 | * version 4.0, section 17.4. |
| @@ -266,13 +266,30 @@ static int erst_exec_move_data(struct apei_exec_context *ctx, · 257 unmodified lines | ||
| 266 | 266 | { |
| 267 | 267 | int rc; |
| 268 | 268 | u64 offset; |
| 269 | + void *src, *dst; | |
| 270 | + | |
| 271 | + /* ioremap does not work in interrupt context */ | |
| 272 | + if (in_interrupt()) { | |
| 273 | + pr_warning(ERST_PFX | |
| 274 | + "MOVE_DATA can not be used in interrupt context"); | |
| 275 | + return -EBUSY; | |
| 276 | + } | |
| 269 | 277 | |
| 270 | 278 | rc = __apei_exec_read_register(entry, &offset); |
| 271 | 279 | if (rc) |
| 272 | 280 | return rc; |
| 273 | − memmove((void *)ctx->dst_base + offset, | |
| 274 | − (void *)ctx->src_base + offset, | |
| 275 | − ctx->var2); | |
| 281 | + | |
| 282 | + src = ioremap(ctx->src_base + offset, ctx->var2); | |
| 283 | + if (!src) | |
| 284 | + return -ENOMEM; | |
| 285 | + dst = ioremap(ctx->dst_base + offset, ctx->var2); | |
| 286 | + if (!dst) | |
| 287 | + return -ENOMEM; | |
| 288 | + | |
| 289 | + memmove(dst, src, ctx->var2); | |
| 290 | + | |
| 291 | + iounmap(src); | |
| 292 | + iounmap(dst); | |
| 276 | 293 | |
| 277 | 294 | return 0; |
| 278 | 295 | } |
| @@ -750,7 +767,9 @@ __setup("erst_disable", setup_erst_disable); · 471 unmodified lines | ||
| 750 | 767 | |
| 751 | 768 | static int erst_check_table(struct acpi_table_erst *erst_tab) |
| 752 | 769 | { |
| 753 | − if (erst_tab->header_length != sizeof(struct acpi_table_erst)) | |
| 770 | + if ((erst_tab->header_length != | |
| 771 | + (sizeof(struct acpi_table_erst) - sizeof(erst_tab->header))) | |
| 772 | + && (erst_tab->header_length != sizeof(struct acpi_table_einj))) | |
| 754 | 773 | return -EINVAL; |
| 755 | 774 | if (erst_tab->header.length < sizeof(struct acpi_table_erst)) |
| 756 | 775 | return -EINVAL; |
| @@ -302,7 +302,7 @@ static int __devinit ghes_probe(struct platform_device *ghes_dev) · 301 unmodified lines | ||
| 302 | 302 | struct ghes *ghes = NULL; |
| 303 | 303 | int rc = -EINVAL; |
| 304 | 304 | |
| 305 | − generic = ghes_dev->dev.platform_data; | |
| 305 | + generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data; | |
| 306 | 306 | if (!generic->enabled) |
| 307 | 307 | return -ENODEV; |
| 308 | 308 | |
| @@ -137,20 +137,23 @@ static int hest_parse_ghes_count(struct acpi_hest_header *hest_hdr, void *data) · 136 unmodified lines | ||
| 137 | 137 | |
| 138 | 138 | static int hest_parse_ghes(struct acpi_hest_header *hest_hdr, void *data) |
| 139 | 139 | { |
| 140 | − struct acpi_hest_generic *generic; | |
| 141 | 140 | struct platform_device *ghes_dev; |
| 142 | 141 | struct ghes_arr *ghes_arr = data; |
| 143 | 142 | int rc; |
| 144 | 143 | |
| 145 | 144 | if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR) |
| 146 | 145 | return 0; |
| 147 | − generic = (struct acpi_hest_generic *)hest_hdr; | |
| 148 | − if (!generic->enabled) | |
| 146 | + | |
| 147 | + if (!((struct acpi_hest_generic *)hest_hdr)->enabled) | |
| 149 | 148 | return 0; |
| 150 | 149 | ghes_dev = platform_device_alloc("GHES", hest_hdr->source_id); |
| 151 | 150 | if (!ghes_dev) |
| 152 | 151 | return -ENOMEM; |
| 153 | − ghes_dev->dev.platform_data = generic; | |
| 152 | + | |
| 153 | + rc = platform_device_add_data(ghes_dev, &hest_hdr, sizeof(void *)); | |
| 154 | + if (rc) | |
| 155 | + goto err; | |
| 156 | + | |
| 154 | 157 | rc = platform_device_add(ghes_dev); |
| 155 | 158 | if (rc) |
| 156 | 159 | goto err; |
| @@ -142,7 +142,7 @@ static void __iomem *acpi_pre_map(phys_addr_t paddr, · 141 unmodified lines | ||
| 142 | 142 | list_add_tail_rcu(&map->list, &acpi_iomaps); |
| 143 | 143 | spin_unlock_irqrestore(&acpi_iomaps_lock, flags); |
| 144 | 144 | |
| 145 | − return vaddr + (paddr - pg_off); | |
| 145 | + return map->vaddr + (paddr - map->paddr); | |
| 146 | 146 | err_unmap: |
| 147 | 147 | iounmap(vaddr); |
| 148 | 148 | return NULL; |
| @@ -273,7 +273,6 @@ static enum power_supply_property energy_battery_props[] = { · 272 unmodified lines | ||
| 273 | 273 | POWER_SUPPLY_PROP_CYCLE_COUNT, |
| 274 | 274 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, |
| 275 | 275 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
| 276 | − POWER_SUPPLY_PROP_CURRENT_NOW, | |
| 277 | 276 | POWER_SUPPLY_PROP_POWER_NOW, |
| 278 | 277 | POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, |
| 279 | 278 | POWER_SUPPLY_PROP_ENERGY_FULL, |
| @@ -183,6 +183,8 @@ static int __init dmi_disable_osi_vista(const struct dmi_system_id *d) · 182 unmodified lines | ||
| 183 | 183 | { |
| 184 | 184 | printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident); |
| 185 | 185 | acpi_osi_setup("!Windows 2006"); |
| 186 | + acpi_osi_setup("!Windows 2006 SP1"); | |
| 187 | + acpi_osi_setup("!Windows 2006 SP2"); | |
| 186 | 188 | return 0; |
| 187 | 189 | } |
| 188 | 190 | static int __init dmi_disable_osi_win7(const struct dmi_system_id *d) |
| @@ -226,6 +228,14 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = { · 37 unmodified lines | ||
| 226 | 228 | }, |
| 227 | 229 | }, |
| 228 | 230 | { |
| 231 | + .callback = dmi_disable_osi_vista, | |
| 232 | + .ident = "Toshiba Satellite L355", | |
| 233 | + .matches = { | |
| 234 | + DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), | |
| 235 | + DMI_MATCH(DMI_PRODUCT_VERSION, "Satellite L355"), | |
| 236 | + }, | |
| 237 | + }, | |
| 238 | + { | |
| 229 | 239 | .callback = dmi_disable_osi_win7, |
| 230 | 240 | .ident = "ASUS K50IJ", |
| 231 | 241 | .matches = { |
| @@ -233,6 +243,14 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = { · 1 unmodified line | ||
| 233 | 243 | DMI_MATCH(DMI_PRODUCT_NAME, "K50IJ"), |
| 234 | 244 | }, |
| 235 | 245 | }, |
| 246 | + { | |
| 247 | + .callback = dmi_disable_osi_vista, | |
| 248 | + .ident = "Toshiba P305D", | |
| 249 | + .matches = { | |
| 250 | + DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), | |
| 251 | + DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P305D"), | |
| 252 | + }, | |
| 253 | + }, | |
| 236 | 254 | |
| 237 | 255 | /* |
| 238 | 256 | * BIOS invocation of _OSI(Linux) is almost always a BIOS bug. |
| @@ -55,7 +55,7 @@ EXPORT_SYMBOL(acpi_root_dir); · 54 unmodified lines | ||
| 55 | 55 | static int set_power_nocheck(const struct dmi_system_id *id) |
| 56 | 56 | { |
| 57 | 57 | printk(KERN_NOTICE PREFIX "%s detected - " |
| 58 | − "disable power check in power transistion\n", id->ident); | |
| 58 | + "disable power check in power transition\n", id->ident); | |
| 59 | 59 | acpi_power_nocheck = 1; |
| 60 | 60 | return 0; |
| 61 | 61 | } |
| @@ -80,23 +80,15 @@ static int set_copy_dsdt(const struct dmi_system_id *id) · 18 unmodified lines | ||
| 80 | 80 | |
| 81 | 81 | static struct dmi_system_id dsdt_dmi_table[] __initdata = { |
| 82 | 82 | /* |
| 83 | − * Insyde BIOS on some TOSHIBA machines corrupt the DSDT. | |
| 83 | + * Invoke DSDT corruption work-around on all Toshiba Satellite. | |
| 84 | 84 | * https://bugzilla.kernel.org/show_bug.cgi?id=14679 |
| 85 | 85 | */ |
| 86 | 86 | { |
| 87 | 87 | .callback = set_copy_dsdt, |
| 88 | − .ident = "TOSHIBA Satellite A505", | |
| 88 | + .ident = "TOSHIBA Satellite", | |
| 89 | 89 | .matches = { |
| 90 | 90 | DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), |
| 91 | − DMI_MATCH(DMI_PRODUCT_NAME, "Satellite A505"), | |
| 92 | − }, | |
| 93 | − }, | |
| 94 | − { | |
| 95 | − .callback = set_copy_dsdt, | |
| 96 | − .ident = "TOSHIBA Satellite L505D", | |
| 97 | − .matches = { | |
| 98 | − DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), | |
| 99 | − DMI_MATCH(DMI_PRODUCT_NAME, "Satellite L505D"), | |
| 91 | + DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"), | |
| 100 | 92 | }, |
| 101 | 93 | }, |
| 102 | 94 | {} |
| @@ -1027,7 +1019,7 @@ static int __init acpi_init(void) · 924 unmodified lines | ||
| 1027 | 1019 | |
| 1028 | 1020 | /* |
| 1029 | 1021 | * If the laptop falls into the DMI check table, the power state check |
| 1030 | − * will be disabled in the course of device power transistion. | |
| 1022 | + * will be disabled in the course of device power transition. | |
| 1031 | 1023 | */ |
| 1032 | 1024 | dmi_check_system(power_nocheck_dmi_table); |
| 1033 | 1025 | |
| @@ -369,7 +369,9 @@ static void __exit acpi_fan_exit(void) · 368 unmodified lines | ||
| 369 | 369 | |
| 370 | 370 | acpi_bus_unregister_driver(&acpi_fan_driver); |
| 371 | 371 | |
| 372 | +#ifdef CONFIG_ACPI_PROCFS | |
| 372 | 373 | remove_proc_entry(ACPI_FAN_CLASS, acpi_root_dir); |
| 374 | +#endif | |
| 373 | 375 | |
| 374 | 376 | return; |
| 375 | 377 | } |
| @@ -28,12 +28,6 @@ static int set_no_mwait(const struct dmi_system_id *id) · 27 unmodified lines | ||
| 28 | 28 | } |
| 29 | 29 | |
| 30 | 30 | static struct dmi_system_id __cpuinitdata processor_idle_dmi_table[] = { |
| 31 | − { | |
| 32 | − set_no_mwait, "IFL91 board", { | |
| 33 | − DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"), | |
| 34 | − DMI_MATCH(DMI_SYS_VENDOR, "ZEPTO"), | |
| 35 | − DMI_MATCH(DMI_PRODUCT_VERSION, "3215W"), | |
| 36 | − DMI_MATCH(DMI_BOARD_NAME, "IFL91") }, NULL}, | |
| 37 | 31 | { |
| 38 | 32 | set_no_mwait, "Extensa 5220", { |
| 39 | 33 | DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"), |
| @@ -850,7 +850,7 @@ static int __init acpi_processor_init(void) · 849 unmodified lines | ||
| 850 | 850 | printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n", |
| 851 | 851 | acpi_idle_driver.name); |
| 852 | 852 | } else { |
| 853 | − printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s", | |
| 853 | + printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s\n", | |
| 854 | 854 | cpuidle_get_driver()->name); |
| 855 | 855 | } |
| 856 | 856 | |
| @@ -447,8 +447,8 @@ int acpi_processor_notify_smm(struct module *calling_module) · 446 unmodified lines | ||
| 447 | 447 | if (!try_module_get(calling_module)) |
| 448 | 448 | return -EINVAL; |
| 449 | 449 | |
| 450 | − /* is_done is set to negative if an error occured, | |
| 451 | − * and to postitive if _no_ error occured, but SMM | |
| 450 | + /* is_done is set to negative if an error occurred, | |
| 451 | + * and to postitive if _no_ error occurred, but SMM | |
| 452 | 452 | * was already notified. This avoids double notification |
| 453 | 453 | * which might lead to unexpected results... |
| 454 | 454 | */ |
| @@ -363,6 +363,12 @@ static int __init init_old_suspend_ordering(const struct dmi_system_id *d) · 362 unmodified lines | ||
| 363 | 363 | return 0; |
| 364 | 364 | } |
| 365 | 365 | |
| 366 | +static int __init init_nvs_nosave(const struct dmi_system_id *d) | |
| 367 | +{ | |
| 368 | + acpi_nvs_nosave(); | |
| 369 | + return 0; | |
| 370 | +} | |
| 371 | + | |
| 366 | 372 | static struct dmi_system_id __initdata acpisleep_dmi_table[] = { |
| 367 | 373 | { |
| 368 | 374 | .callback = init_old_suspend_ordering, |
| @@ -397,6 +403,22 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = { · 28 unmodified lines | ||
| 397 | 403 | DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"), |
| 398 | 404 | }, |
| 399 | 405 | }, |
| 406 | + { | |
| 407 | + .callback = init_nvs_nosave, | |
| 408 | + .ident = "Sony Vaio VGN-SR11M", | |
| 409 | + .matches = { | |
| 410 | + DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), | |
| 411 | + DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"), | |
| 412 | + }, | |
| 413 | + }, | |
| 414 | + { | |
| 415 | + .callback = init_nvs_nosave, | |
| 416 | + .ident = "Everex StepNote Series", | |
| 417 | + .matches = { | |
| 418 | + DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."), | |
| 419 | + DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"), | |
| 420 | + }, | |
| 421 | + }, | |
| 400 | 422 | {}, |
| 401 | 423 | }; |
| 402 | 424 | #endif /* CONFIG_SUSPEND */ |
| @@ -100,7 +100,7 @@ static const struct acpi_dlevel acpi_debug_levels[] = { · 99 unmodified lines | ||
| 100 | 100 | ACPI_DEBUG_INIT(ACPI_LV_EVENTS), |
| 101 | 101 | }; |
| 102 | 102 | |
| 103 | −static int param_get_debug_layer(char *buffer, struct kernel_param *kp) | |
| 103 | +static int param_get_debug_layer(char *buffer, const struct kernel_param *kp) | |
| 104 | 104 | { |
| 105 | 105 | int result = 0; |
| 106 | 106 | int i; |
| @@ -128,7 +128,7 @@ static int param_get_debug_layer(char *buffer, struct kernel_param *kp) · 21 unmodified lines | ||
| 128 | 128 | return result; |
| 129 | 129 | } |
| 130 | 130 | |
| 131 | −static int param_get_debug_level(char *buffer, struct kernel_param *kp) | |
| 131 | +static int param_get_debug_level(char *buffer, const struct kernel_param *kp) | |
| 132 | 132 | { |
| 133 | 133 | int result = 0; |
| 134 | 134 | int i; |
| @@ -149,10 +149,18 @@ static int param_get_debug_level(char *buffer, struct kernel_param *kp) · 14 unmodified lines | ||
| 149 | 149 | return result; |
| 150 | 150 | } |
| 151 | 151 | |
| 152 | −module_param_call(debug_layer, param_set_uint, param_get_debug_layer, | |
| 153 | − &acpi_dbg_layer, 0644); | |
| 154 | −module_param_call(debug_level, param_set_uint, param_get_debug_level, | |
| 155 | − &acpi_dbg_level, 0644); | |
| 152 | +static struct kernel_param_ops param_ops_debug_layer = { | |
| 153 | + .set = param_set_uint, | |
| 154 | + .get = param_get_debug_layer, | |
| 155 | +}; | |
| 156 | + | |
| 157 | +static struct kernel_param_ops param_ops_debug_level = { | |
| 158 | + .set = param_set_uint, | |
| 159 | + .get = param_get_debug_level, | |
| 160 | +}; | |
| 161 | + | |
| 162 | +module_param_cb(debug_layer, ¶m_ops_debug_layer, &acpi_dbg_layer, 0644); | |
| 163 | +module_param_cb(debug_level, ¶m_ops_debug_level, &acpi_dbg_level, 0644); | |
| 156 | 164 | |
| 157 | 165 | static char trace_method_name[6]; |
| 158 | 166 | module_param_string(trace_method_name, trace_method_name, 6, 0644); |
| @@ -59,8 +59,8 @@ acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, · 58 unmodified lines | ||
| 59 | 59 | "support\n")); |
| 60 | 60 | *cap |= ACPI_VIDEO_BACKLIGHT; |
| 61 | 61 | if (ACPI_FAILURE(acpi_get_handle(handle, "_BQC", &h_dummy))) |
| 62 | − printk(KERN_WARNING FW_BUG PREFIX "ACPI brightness " | |
| 63 | − "control misses _BQC function\n"); | |
| 62 | + printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, " | |
| 63 | + "cannot determine initial brightness\n"); | |
| 64 | 64 | /* We have backlight support, no need to scan further */ |
| 65 | 65 | return AE_CTRL_TERMINATE; |
| 66 | 66 | } |
| @@ -90,6 +90,10 @@ static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg); · 89 unmodified lines | ||
| 90 | 90 | static int ahci_pci_device_resume(struct pci_dev *pdev); |
| 91 | 91 | #endif |
| 92 | 92 | |
| 93 | +static struct scsi_host_template ahci_sht = { | |
| 94 | + AHCI_SHT("ahci"), | |
| 95 | +}; | |
| 96 | + | |
| 93 | 97 | static struct ata_port_operations ahci_vt8251_ops = { |
| 94 | 98 | .inherits = &ahci_ops, |
| 95 | 99 | .hardreset = ahci_vt8251_hardreset, |
| @@ -298,7 +298,17 @@ struct ahci_host_priv { · 297 unmodified lines | ||
| 298 | 298 | |
| 299 | 299 | extern int ahci_ignore_sss; |
| 300 | 300 | |
| 301 | −extern struct scsi_host_template ahci_sht; | |
| 301 | +extern struct device_attribute *ahci_shost_attrs[]; | |
| 302 | +extern struct device_attribute *ahci_sdev_attrs[]; | |
| 303 | + | |
| 304 | +#define AHCI_SHT(drv_name) \ | |
| 305 | + ATA_NCQ_SHT(drv_name), \ | |
| 306 | + .can_queue = AHCI_MAX_CMDS - 1, \ | |
| 307 | + .sg_tablesize = AHCI_MAX_SG, \ | |
| 308 | + .dma_boundary = AHCI_DMA_BOUNDARY, \ | |
| 309 | + .shost_attrs = ahci_shost_attrs, \ | |
| 310 | + .sdev_attrs = ahci_sdev_attrs | |
| 311 | + | |
| 302 | 312 | extern struct ata_port_operations ahci_ops; |
| 303 | 313 | |
| 304 | 314 | void ahci_save_initial_config(struct device *dev, |
| @@ -23,6 +23,10 @@ · 22 unmodified lines | ||
| 23 | 23 | #include <linux/ahci_platform.h> |
| 24 | 24 | #include "ahci.h" |
| 25 | 25 | |
| 26 | +static struct scsi_host_template ahci_platform_sht = { | |
| 27 | + AHCI_SHT("ahci_platform"), | |
| 28 | +}; | |
| 29 | + | |
| 26 | 30 | static int __init ahci_probe(struct platform_device *pdev) |
| 27 | 31 | { |
| 28 | 32 | struct device *dev = &pdev->dev; |
| @@ -145,7 +149,7 @@ static int __init ahci_probe(struct platform_device *pdev) · 116 unmodified lines | ||
| 145 | 149 | ahci_print_info(host, "platform"); |
| 146 | 150 | |
| 147 | 151 | rc = ata_host_activate(host, irq, ahci_interrupt, IRQF_SHARED, |
| 148 | − &ahci_sht); | |
| 152 | + &ahci_platform_sht); | |
| 149 | 153 | if (rc) |
| 150 | 154 | goto err0; |
| 151 | 155 | |
| @@ -121,7 +121,7 @@ static DEVICE_ATTR(ahci_port_cmd, S_IRUGO, ahci_show_port_cmd, NULL); · 120 unmodified lines | ||
| 121 | 121 | static DEVICE_ATTR(em_buffer, S_IWUSR | S_IRUGO, |
| 122 | 122 | ahci_read_em_buffer, ahci_store_em_buffer); |
| 123 | 123 | |
| 124 | −static struct device_attribute *ahci_shost_attrs[] = { | |
| 124 | +struct device_attribute *ahci_shost_attrs[] = { | |
| 125 | 125 | &dev_attr_link_power_management_policy, |
| 126 | 126 | &dev_attr_em_message_type, |
| 127 | 127 | &dev_attr_em_message, |
| @@ -132,22 +132,14 @@ static struct device_attribute *ahci_shost_attrs[] = { · 4 unmodified lines | ||
| 132 | 132 | &dev_attr_em_buffer, |
| 133 | 133 | NULL |
| 134 | 134 | }; |
| 135 | +EXPORT_SYMBOL_GPL(ahci_shost_attrs); | |
| 135 | 136 | |
| 136 | −static struct device_attribute *ahci_sdev_attrs[] = { | |
| 137 | +struct device_attribute *ahci_sdev_attrs[] = { | |
| 137 | 138 | &dev_attr_sw_activity, |
| 138 | 139 | &dev_attr_unload_heads, |
| 139 | 140 | NULL |
| 140 | 141 | }; |
| 141 | − | |
| 142 | −struct scsi_host_template ahci_sht = { | |
| 143 | − ATA_NCQ_SHT("ahci"), | |
| 144 | − .can_queue = AHCI_MAX_CMDS - 1, | |
| 145 | − .sg_tablesize = AHCI_MAX_SG, | |
| 146 | − .dma_boundary = AHCI_DMA_BOUNDARY, | |
| 147 | − .shost_attrs = ahci_shost_attrs, | |
| 148 | − .sdev_attrs = ahci_sdev_attrs, | |
| 149 | −}; | |
| 150 | −EXPORT_SYMBOL_GPL(ahci_sht); | |
| 142 | +EXPORT_SYMBOL_GPL(ahci_sdev_attrs); | |
| 151 | 143 | |
| 152 | 144 | struct ata_port_operations ahci_ops = { |
| 153 | 145 | .inherits = &sata_pmp_port_ops, |
| @@ -2369,7 +2369,7 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush) · 2368 unmodified lines | ||
| 2369 | 2369 | pkt_shrink_pktlist(pd); |
| 2370 | 2370 | } |
| 2371 | 2371 | |
| 2372 | −static struct pktcdvd_device *pkt_find_dev_from_minor(int dev_minor) | |
| 2372 | +static struct pktcdvd_device *pkt_find_dev_from_minor(unsigned int dev_minor) | |
| 2373 | 2373 | { |
| 2374 | 2374 | if (dev_minor >= MAX_WRITERS) |
| 2375 | 2375 | return NULL; |
| @@ -305,6 +305,9 @@ static int num_force_kipmid; · 304 unmodified lines | ||
| 305 | 305 | #ifdef CONFIG_PCI |
| 306 | 306 | static int pci_registered; |
| 307 | 307 | #endif |
| 308 | +#ifdef CONFIG_ACPI | |
| 309 | +static int pnp_registered; | |
| 310 | +#endif | |
| 308 | 311 | #ifdef CONFIG_PPC_OF |
| 309 | 312 | static int of_registered; |
| 310 | 313 | #endif |
| @@ -2126,7 +2129,7 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev, · 1815 unmodified lines | ||
| 2126 | 2129 | { |
| 2127 | 2130 | struct acpi_device *acpi_dev; |
| 2128 | 2131 | struct smi_info *info; |
| 2129 | − struct resource *res; | |
| 2132 | + struct resource *res, *res_second; | |
| 2130 | 2133 | acpi_handle handle; |
| 2131 | 2134 | acpi_status status; |
| 2132 | 2135 | unsigned long long tmp; |
| @@ -2182,13 +2185,13 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev, · 49 unmodified lines | ||
| 2182 | 2185 | info->io.addr_data = res->start; |
| 2183 | 2186 | |
| 2184 | 2187 | info->io.regspacing = DEFAULT_REGSPACING; |
| 2185 | − res = pnp_get_resource(dev, | |
| 2188 | + res_second = pnp_get_resource(dev, | |
| 2186 | 2189 | (info->io.addr_type == IPMI_IO_ADDR_SPACE) ? |
| 2187 | 2190 | IORESOURCE_IO : IORESOURCE_MEM, |
| 2188 | 2191 | 1); |
| 2189 | − if (res) { | |
| 2190 | − if (res->start > info->io.addr_data) | |
| 2191 | − info->io.regspacing = res->start - info->io.addr_data; | |
| 2192 | + if (res_second) { | |
| 2193 | + if (res_second->start > info->io.addr_data) | |
| 2194 | + info->io.regspacing = res_second->start - info->io.addr_data; | |
| 2192 | 2195 | } |
| 2193 | 2196 | info->io.regsize = DEFAULT_REGSPACING; |
| 2194 | 2197 | info->io.regshift = 0; |
| @@ -3359,6 +3362,7 @@ static __devinit int init_ipmi_si(void) · 1164 unmodified lines | ||
| 3359 | 3362 | |
| 3360 | 3363 | #ifdef CONFIG_ACPI |
| 3361 | 3364 | pnp_register_driver(&ipmi_pnp_driver); |
| 3365 | + pnp_registered = 1; | |
| 3362 | 3366 | #endif |
| 3363 | 3367 | |
| 3364 | 3368 | #ifdef CONFIG_DMI |
| @@ -3526,7 +3530,8 @@ static __exit void cleanup_ipmi_si(void) · 161 unmodified lines | ||
| 3526 | 3530 | pci_unregister_driver(&ipmi_pci_driver); |
| 3527 | 3531 | #endif |
| 3528 | 3532 | #ifdef CONFIG_ACPI |
| 3529 | − pnp_unregister_driver(&ipmi_pnp_driver); | |
| 3533 | + if (pnp_registered) | |
| 3534 | + pnp_unregister_driver(&ipmi_pnp_driver); | |
| 3530 | 3535 | #endif |
| 3531 | 3536 | |
| 3532 | 3537 | #ifdef CONFIG_PPC_OF |
| @@ -80,7 +80,7 @@ · 79 unmodified lines | ||
| 80 | 80 | * Limiting Performance Impact |
| 81 | 81 | * --------------------------- |
| 82 | 82 | * C states, especially those with large exit latencies, can have a real |
| 83 | − * noticable impact on workloads, which is not acceptable for most sysadmins, | |
| 83 | + * noticeable impact on workloads, which is not acceptable for most sysadmins, | |
| 84 | 84 | * and in addition, less performance has a power price of its own. |
| 85 | 85 | * |
| 86 | 86 | * As a general rule of thumb, menu assumes that the following heuristic |
| @@ -162,7 +162,7 @@ static int mv_is_err_intr(u32 intr_cause) · 161 unmodified lines | ||
| 162 | 162 | |
| 163 | 163 | static void mv_xor_device_clear_eoc_cause(struct mv_xor_chan *chan) |
| 164 | 164 | { |
| 165 | − u32 val = (1 << (1 + (chan->idx * 16))); | |
| 165 | + u32 val = ~(1 << (chan->idx * 16)); | |
| 166 | 166 | dev_dbg(chan->device->common.dev, "%s, val 0x%08x\n", __func__, val); |
| 167 | 167 | __raw_writel(val, XOR_INTR_CAUSE(chan)); |
| 168 | 168 | } |
| @@ -580,7 +580,6 @@ static struct dma_async_tx_descriptor *sh_dmae_prep_slave_sg( · 579 unmodified lines | ||
| 580 | 580 | |
| 581 | 581 | sh_chan = to_sh_chan(chan); |
| 582 | 582 | param = chan->private; |
| 583 | − slave_addr = param->config->addr; | |
| 584 | 583 | |
| 585 | 584 | /* Someone calling slave DMA on a public channel? */ |
| 586 | 585 | if (!param || !sg_len) { |
| @@ -589,6 +588,8 @@ static struct dma_async_tx_descriptor *sh_dmae_prep_slave_sg( · 2 unmodified lines | ||
| 589 | 588 | return NULL; |
| 590 | 589 | } |
| 591 | 590 | |
| 591 | + slave_addr = param->config->addr; | |
| 592 | + | |
| 592 | 593 | /* |
| 593 | 594 | * if (param != NULL), this is a successfully requested slave channel, |
| 594 | 595 | * therefore param->config != NULL too. |
| @@ -339,6 +339,9 @@ static void edac_mc_workq_teardown(struct mem_ctl_info *mci) · 338 unmodified lines | ||
| 339 | 339 | { |
| 340 | 340 | int status; |
| 341 | 341 | |
| 342 | + if (mci->op_state != OP_RUNNING_POLL) | |
| 343 | + return; | |
| 344 | + | |
| 342 | 345 | status = cancel_delayed_work(&mci->work); |
| 343 | 346 | if (status == 0) { |
| 344 | 347 | debugf0("%s() not canceled, flush the queue\n", |
| @@ -1140,6 +1140,7 @@ static struct mcidev_sysfs_attribute i7core_udimm_counters_attrs[] = { · 1139 unmodified lines | ||
| 1140 | 1140 | ATTR_COUNTER(0), |
| 1141 | 1141 | ATTR_COUNTER(1), |
| 1142 | 1142 | ATTR_COUNTER(2), |
| 1143 | + { .attr = { .name = NULL } } | |
| 1143 | 1144 | }; |
| 1144 | 1145 | |
| 1145 | 1146 | static struct mcidev_sysfs_group i7core_udimm_counters = { |
| @@ -98,8 +98,8 @@ EXPORT_SYMBOL(drm_buffer_alloc); · 97 unmodified lines | ||
| 98 | 98 | * user_data: A pointer the data that is copied to the buffer. |
| 99 | 99 | * size: The Number of bytes to copy. |
| 100 | 100 | */ |
| 101 | −extern int drm_buffer_copy_from_user(struct drm_buffer *buf, | |
| 102 | − void __user *user_data, int size) | |
| 101 | +int drm_buffer_copy_from_user(struct drm_buffer *buf, | |
| 102 | + void __user *user_data, int size) | |
| 103 | 103 | { |
| 104 | 104 | int nr_pages = size / PAGE_SIZE + 1; |
| 105 | 105 | int idx; |
| @@ -163,7 +163,7 @@ void *drm_buffer_read_object(struct drm_buffer *buf, · 57 unmodified lines | ||
| 163 | 163 | { |
| 164 | 164 | int idx = drm_buffer_index(buf); |
| 165 | 165 | int page = drm_buffer_page(buf); |
| 166 | − void *obj = 0; | |
| 166 | + void *obj = NULL; | |
| 167 | 167 | |
| 168 | 168 | if (idx + objsize <= PAGE_SIZE) { |
| 169 | 169 | obj = &buf->data[page][idx]; |
| @@ -148,7 +148,7 @@ int drm_gem_object_init(struct drm_device *dev, · 147 unmodified lines | ||
| 148 | 148 | return -ENOMEM; |
| 149 | 149 | |
| 150 | 150 | kref_init(&obj->refcount); |
| 151 | − kref_init(&obj->handlecount); | |
| 151 | + atomic_set(&obj->handle_count, 0); | |
| 152 | 152 | obj->size = size; |
| 153 | 153 | |
| 154 | 154 | atomic_inc(&dev->object_count); |
| @@ -462,28 +462,6 @@ drm_gem_object_free(struct kref *kref) · 307 unmodified lines | ||
| 462 | 462 | } |
| 463 | 463 | EXPORT_SYMBOL(drm_gem_object_free); |
| 464 | 464 | |
| 465 | −/** | |
| 466 | − * Called after the last reference to the object has been lost. | |
| 467 | − * Must be called without holding struct_mutex | |
| 468 | − * | |
| 469 | − * Frees the object | |
| 470 | − */ | |
| 471 | −void | |
| 472 | −drm_gem_object_free_unlocked(struct kref *kref) | |
| 473 | −{ | |
| 474 | − struct drm_gem_object *obj = (struct drm_gem_object *) kref; | |
| 475 | − struct drm_device *dev = obj->dev; | |
| 476 | − | |
| 477 | − if (dev->driver->gem_free_object_unlocked != NULL) | |
| 478 | − dev->driver->gem_free_object_unlocked(obj); | |
| 479 | − else if (dev->driver->gem_free_object != NULL) { | |
| 480 | − mutex_lock(&dev->struct_mutex); | |
| 481 | − dev->driver->gem_free_object(obj); | |
| 482 | − mutex_unlock(&dev->struct_mutex); | |
| 483 | − } | |
| 484 | −} | |
| 485 | −EXPORT_SYMBOL(drm_gem_object_free_unlocked); | |
| 486 | − | |
| 487 | 465 | static void drm_gem_object_ref_bug(struct kref *list_kref) |
| 488 | 466 | { |
| 489 | 467 | BUG(); |
| @@ -496,12 +474,8 @@ static void drm_gem_object_ref_bug(struct kref *list_kref) · 6 unmodified lines | ||
| 496 | 474 | * called before drm_gem_object_free or we'll be touching |
| 497 | 475 | * freed memory |
| 498 | 476 | */ |
| 499 | −void | |
| 500 | −drm_gem_object_handle_free(struct kref *kref) | |
| 477 | +void drm_gem_object_handle_free(struct drm_gem_object *obj) | |
| 501 | 478 | { |
| 502 | − struct drm_gem_object *obj = container_of(kref, | |
| 503 | − struct drm_gem_object, | |
| 504 | − handlecount); | |
| 505 | 479 | struct drm_device *dev = obj->dev; |
| 506 | 480 | |
| 507 | 481 | /* Remove any name for this object */ |
| @@ -528,6 +502,10 @@ void drm_gem_vm_open(struct vm_area_struct *vma) · 20 unmodified lines | ||
| 528 | 502 | struct drm_gem_object *obj = vma->vm_private_data; |
| 529 | 503 | |
| 530 | 504 | drm_gem_object_reference(obj); |
| 505 | + | |
| 506 | + mutex_lock(&obj->dev->struct_mutex); | |
| 507 | + drm_vm_open_locked(vma); | |
| 508 | + mutex_unlock(&obj->dev->struct_mutex); | |
| 531 | 509 | } |
| 532 | 510 | EXPORT_SYMBOL(drm_gem_vm_open); |
| 533 | 511 | |
| @@ -535,7 +513,10 @@ void drm_gem_vm_close(struct vm_area_struct *vma) · 1 unmodified line | ||
| 535 | 513 | { |
| 536 | 514 | struct drm_gem_object *obj = vma->vm_private_data; |
| 537 | 515 | |
| 538 | − drm_gem_object_unreference_unlocked(obj); | |
| 516 | + mutex_lock(&obj->dev->struct_mutex); | |
| 517 | + drm_vm_close_locked(vma); | |
| 518 | + drm_gem_object_unreference(obj); | |
| 519 | + mutex_unlock(&obj->dev->struct_mutex); | |
| 539 | 520 | } |
| 540 | 521 | EXPORT_SYMBOL(drm_gem_vm_close); |
| 541 | 522 | |
| @@ -255,7 +255,7 @@ int drm_gem_one_name_info(int id, void *ptr, void *data) · 254 unmodified lines | ||
| 255 | 255 | |
| 256 | 256 | seq_printf(m, "%6d %8zd %7d %8d\n", |
| 257 | 257 | obj->name, obj->size, |
| 258 | − atomic_read(&obj->handlecount.refcount), | |
| 258 | + atomic_read(&obj->handle_count), | |
| 259 | 259 | atomic_read(&obj->refcount.refcount)); |
| 260 | 260 | return 0; |
| 261 | 261 | } |
| @@ -433,15 +433,7 @@ static void drm_vm_open(struct vm_area_struct *vma) · 432 unmodified lines | ||
| 433 | 433 | mutex_unlock(&dev->struct_mutex); |
| 434 | 434 | } |
| 435 | 435 | |
| 436 | −/** | |
| 437 | − * \c close method for all virtual memory types. | |
| 438 | − * | |
| 439 | − * \param vma virtual memory area. | |
| 440 | − * | |
| 441 | − * Search the \p vma private data entry in drm_device::vmalist, unlink it, and | |
| 442 | − * free it. | |
| 443 | − */ | |
| 444 | −static void drm_vm_close(struct vm_area_struct *vma) | |
| 436 | +void drm_vm_close_locked(struct vm_area_struct *vma) | |
| 445 | 437 | { |
| 446 | 438 | struct drm_file *priv = vma->vm_file->private_data; |
| 447 | 439 | struct drm_device *dev = priv->minor->dev; |
| @@ -451,7 +443,6 @@ static void drm_vm_close(struct vm_area_struct *vma) · 3 unmodified lines | ||
| 451 | 443 | vma->vm_start, vma->vm_end - vma->vm_start); |
| 452 | 444 | atomic_dec(&dev->vma_count); |
| 453 | 445 | |
| 454 | − mutex_lock(&dev->struct_mutex); | |
| 455 | 446 | list_for_each_entry_safe(pt, temp, &dev->vmalist, head) { |
| 456 | 447 | if (pt->vma == vma) { |
| 457 | 448 | list_del(&pt->head); |
| @@ -459,6 +450,23 @@ static void drm_vm_close(struct vm_area_struct *vma) · 1 unmodified line | ||
| 459 | 450 | break; |
| 460 | 451 | } |
| 461 | 452 | } |
| 453 | +} | |
| 454 | + | |
| 455 | +/** | |
| 456 | + * \c close method for all virtual memory types. | |
| 457 | + * | |
| 458 | + * \param vma virtual memory area. | |
| 459 | + * | |
| 460 | + * Search the \p vma private data entry in drm_device::vmalist, unlink it, and | |
| 461 | + * free it. | |
| 462 | + */ | |
| 463 | +static void drm_vm_close(struct vm_area_struct *vma) | |
| 464 | +{ | |
| 465 | + struct drm_file *priv = vma->vm_file->private_data; | |
| 466 | + struct drm_device *dev = priv->minor->dev; | |
| 467 | + | |
| 468 | + mutex_lock(&dev->struct_mutex); | |
| 469 | + drm_vm_close_locked(vma); | |
| 462 | 470 | mutex_unlock(&dev->struct_mutex); |
| 463 | 471 | } |
| 464 | 472 | |
| @@ -116,7 +116,7 @@ static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma) · 115 unmodified lines | ||
| 116 | 116 | static const struct file_operations i810_buffer_fops = { |
| 117 | 117 | .open = drm_open, |
| 118 | 118 | .release = drm_release, |
| 119 | − .unlocked_ioctl = drm_ioctl, | |
| 119 | + .unlocked_ioctl = i810_ioctl, | |
| 120 | 120 | .mmap = i810_mmap_buffers, |
| 121 | 121 | .fasync = drm_fasync, |
| 122 | 122 | }; |
| @@ -118,7 +118,7 @@ static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma) · 117 unmodified lines | ||
| 118 | 118 | static const struct file_operations i830_buffer_fops = { |
| 119 | 119 | .open = drm_open, |
| 120 | 120 | .release = drm_release, |
| 121 | − .unlocked_ioctl = drm_ioctl, | |
| 121 | + .unlocked_ioctl = i830_ioctl, | |
| 122 | 122 | .mmap = i830_mmap_buffers, |
| 123 | 123 | .fasync = drm_fasync, |
| 124 | 124 | }; |
| @@ -1787,9 +1787,9 @@ unsigned long i915_chipset_val(struct drm_i915_private *dev_priv) · 1786 unmodified lines | ||
| 1787 | 1787 | } |
| 1788 | 1788 | } |
| 1789 | 1789 | |
| 1790 | − div_u64(diff, diff1); | |
| 1790 | + diff = div_u64(diff, diff1); | |
| 1791 | 1791 | ret = ((m * diff) + c); |
| 1792 | − div_u64(ret, 10); | |
| 1792 | + ret = div_u64(ret, 10); | |
| 1793 | 1793 | |
| 1794 | 1794 | dev_priv->last_count1 = total_count; |
| 1795 | 1795 | dev_priv->last_time1 = now; |
| @@ -1858,7 +1858,7 @@ void i915_update_gfx_val(struct drm_i915_private *dev_priv) · 62 unmodified lines | ||
| 1858 | 1858 | |
| 1859 | 1859 | /* More magic constants... */ |
| 1860 | 1860 | diff = diff * 1181; |
| 1861 | − div_u64(diff, diffms * 10); | |
| 1861 | + diff = div_u64(diff, diffms * 10); | |
| 1862 | 1862 | dev_priv->gfx_power = diff; |
| 1863 | 1863 | } |
| 1864 | 1864 | |
| @@ -136,14 +136,12 @@ i915_gem_create_ioctl(struct drm_device *dev, void *data, · 135 unmodified lines | ||
| 136 | 136 | return -ENOMEM; |
| 137 | 137 | |
| 138 | 138 | ret = drm_gem_handle_create(file_priv, obj, &handle); |
| 139 | + /* drop reference from allocate - handle holds it now */ | |
| 140 | + drm_gem_object_unreference_unlocked(obj); | |
| 139 | 141 | if (ret) { |
| 140 | − drm_gem_object_unreference_unlocked(obj); | |
| 141 | 142 | return ret; |
| 142 | 143 | } |
| 143 | 144 | |
| 144 | − /* Sink the floating reference from kref_init(handlecount) */ | |
| 145 | − drm_gem_object_handle_unreference_unlocked(obj); | |
| 146 | − | |
| 147 | 145 | args->handle = handle; |
| 148 | 146 | return 0; |
| 149 | 147 | } |
| @@ -471,14 +469,17 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data, · 321 unmodified lines | ||
| 471 | 469 | return -ENOENT; |
| 472 | 470 | obj_priv = to_intel_bo(obj); |
| 473 | 471 | |
| 474 | − /* Bounds check source. | |
| 475 | − * | |
| 476 | − * XXX: This could use review for overflow issues... | |
| 477 | − */ | |
| 478 | − if (args->offset > obj->size || args->size > obj->size || | |
| 479 | − args->offset + args->size > obj->size) { | |
| 480 | − drm_gem_object_unreference_unlocked(obj); | |
| 481 | − return -EINVAL; | |
| 472 | + /* Bounds check source. */ | |
| 473 | + if (args->offset > obj->size || args->size > obj->size - args->offset) { | |
| 474 | + ret = -EINVAL; | |
| 475 | + goto err; | |
| 476 | + } | |
| 477 | + | |
| 478 | + if (!access_ok(VERIFY_WRITE, | |
| 479 | + (char __user *)(uintptr_t)args->data_ptr, | |
| 480 | + args->size)) { | |
| 481 | + ret = -EFAULT; | |
| 482 | + goto err; | |
| 482 | 483 | } |
| 483 | 484 | |
| 484 | 485 | if (i915_gem_object_needs_bit17_swizzle(obj)) { |
| @@ -490,8 +491,8 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data, · 5 unmodified lines | ||
| 490 | 491 | file_priv); |
| 491 | 492 | } |
| 492 | 493 | |
| 494 | +err: | |
| 493 | 495 | drm_gem_object_unreference_unlocked(obj); |
| 494 | − | |
| 495 | 496 | return ret; |
| 496 | 497 | } |
| 497 | 498 | |
| @@ -580,8 +581,6 @@ i915_gem_gtt_pwrite_fast(struct drm_device *dev, struct drm_gem_object *obj, · 82 unmodified lines | ||
| 580 | 581 | |
| 581 | 582 | user_data = (char __user *) (uintptr_t) args->data_ptr; |
| 582 | 583 | remain = args->size; |
| 583 | − if (!access_ok(VERIFY_READ, user_data, remain)) | |
| 584 | − return -EFAULT; | |
| 585 | 584 | |
| 586 | 585 | |
| 587 | 586 | mutex_lock(&dev->struct_mutex); |
| @@ -934,14 +933,17 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data, · 346 unmodified lines | ||
| 934 | 933 | return -ENOENT; |
| 935 | 934 | obj_priv = to_intel_bo(obj); |
| 936 | 935 | |
| 937 | − /* Bounds check destination. | |
| 938 | − * | |
| 939 | − * XXX: This could use review for overflow issues... | |
| 940 | − */ | |
| 941 | − if (args->offset > obj->size || args->size > obj->size || | |
| 942 | − args->offset + args->size > obj->size) { | |
| 943 | − drm_gem_object_unreference_unlocked(obj); | |
| 944 | − return -EINVAL; | |
| 936 | + /* Bounds check destination. */ | |
| 937 | + if (args->offset > obj->size || args->size > obj->size - args->offset) { | |
| 938 | + ret = -EINVAL; | |
| 939 | + goto err; | |
| 940 | + } | |
| 941 | + | |
| 942 | + if (!access_ok(VERIFY_READ, | |
| 943 | + (char __user *)(uintptr_t)args->data_ptr, | |
| 944 | + args->size)) { | |
| 945 | + ret = -EFAULT; | |
| 946 | + goto err; | |
| 945 | 947 | } |
| 946 | 948 | |
| 947 | 949 | /* We can only do the GTT pwrite on untiled buffers, as otherwise |
| @@ -975,8 +977,8 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data, · 27 unmodified lines | ||
| 975 | 977 | DRM_INFO("pwrite failed %d\n", ret); |
| 976 | 978 | #endif |
| 977 | 979 | |
| 980 | +err: | |
| 978 | 981 | drm_gem_object_unreference_unlocked(obj); |
| 979 | − | |
| 980 | 982 | return ret; |
| 981 | 983 | } |
| 982 | 984 | |
| @@ -2400,7 +2402,7 @@ i915_gem_clear_fence_reg(struct drm_gem_object *obj) · 1417 unmodified lines | ||
| 2400 | 2402 | I915_WRITE64(FENCE_REG_965_0 + (obj_priv->fence_reg * 8), 0); |
| 2401 | 2403 | break; |
| 2402 | 2404 | case 3: |
| 2403 | − if (obj_priv->fence_reg > 8) | |
| 2405 | + if (obj_priv->fence_reg >= 8) | |
| 2404 | 2406 | fence_reg = FENCE_REG_945_8 + (obj_priv->fence_reg - 8) * 4; |
| 2405 | 2407 | else |
| 2406 | 2408 | case 2: |
| @@ -3258,6 +3260,8 @@ i915_gem_object_pin_and_relocate(struct drm_gem_object *obj, · 851 unmodified lines | ||
| 3258 | 3260 | (int) reloc->offset, |
| 3259 | 3261 | reloc->read_domains, |
| 3260 | 3262 | reloc->write_domain); |
| 3263 | + drm_gem_object_unreference(target_obj); | |
| 3264 | + i915_gem_object_unpin(obj); | |
| 3261 | 3265 | return -EINVAL; |
| 3262 | 3266 | } |
| 3263 | 3267 | if (reloc->write_domain & I915_GEM_DOMAIN_CPU || |
| @@ -93,7 +93,7 @@ i915_gem_evict_something(struct drm_device *dev, int min_size, unsigned alignmen · 92 unmodified lines | ||
| 93 | 93 | { |
| 94 | 94 | drm_i915_private_t *dev_priv = dev->dev_private; |
| 95 | 95 | struct list_head eviction_list, unwind_list; |
| 96 | − struct drm_i915_gem_object *obj_priv, *tmp_obj_priv; | |
| 96 | + struct drm_i915_gem_object *obj_priv; | |
| 97 | 97 | struct list_head *render_iter, *bsd_iter; |
| 98 | 98 | int ret = 0; |
| 99 | 99 | |
| @@ -175,39 +175,34 @@ i915_gem_evict_something(struct drm_device *dev, int min_size, unsigned alignmen · 75 unmodified lines | ||
| 175 | 175 | return -ENOSPC; |
| 176 | 176 | |
| 177 | 177 | found: |
| 178 | + /* drm_mm doesn't allow any other other operations while | |
| 179 | + * scanning, therefore store to be evicted objects on a | |
| 180 | + * temporary list. */ | |
| 178 | 181 | INIT_LIST_HEAD(&eviction_list); |
| 179 | − list_for_each_entry_safe(obj_priv, tmp_obj_priv, | |
| 180 | − &unwind_list, evict_list) { | |
| 182 | + while (!list_empty(&unwind_list)) { | |
| 183 | + obj_priv = list_first_entry(&unwind_list, | |
| 184 | + struct drm_i915_gem_object, | |
| 185 | + evict_list); | |
| 181 | 186 | if (drm_mm_scan_remove_block(obj_priv->gtt_space)) { |
| 182 | − /* drm_mm doesn't allow any other other operations while | |
| 183 | − * scanning, therefore store to be evicted objects on a | |
| 184 | − * temporary list. */ | |
| 185 | 187 | list_move(&obj_priv->evict_list, &eviction_list); |
| 186 | − } else | |
| 187 | − drm_gem_object_unreference(&obj_priv->base); | |
| 188 | + continue; | |
| 189 | + } | |
| 190 | + list_del(&obj_priv->evict_list); | |
| 191 | + drm_gem_object_unreference(&obj_priv->base); | |
| 188 | 192 | } |
| 189 | 193 | |
| 190 | 194 | /* Unbinding will emit any required flushes */ |
| 191 | − list_for_each_entry_safe(obj_priv, tmp_obj_priv, | |
| 192 | − &eviction_list, evict_list) { | |
| 193 | −#if WATCH_LRU | |
| 194 | − DRM_INFO("%s: evicting %p\n", __func__, &obj_priv->base); | |
| 195 | −#endif | |
| 196 | − ret = i915_gem_object_unbind(&obj_priv->base); | |
| 197 | − if (ret) | |
| 198 | − return ret; | |
| 199 | − | |
| 195 | + while (!list_empty(&eviction_list)) { | |
| 196 | + obj_priv = list_first_entry(&eviction_list, | |
| 197 | + struct drm_i915_gem_object, | |
| 198 | + evict_list); | |
| 199 | + if (ret == 0) | |
| 200 | + ret = i915_gem_object_unbind(&obj_priv->base); | |
| 201 | + list_del(&obj_priv->evict_list); | |
| 200 | 202 | drm_gem_object_unreference(&obj_priv->base); |
| 201 | 203 | } |
| 202 | 204 | |
| 203 | − /* The just created free hole should be on the top of the free stack | |
| 204 | − * maintained by drm_mm, so this BUG_ON actually executes in O(1). | |
| 205 | − * Furthermore all accessed data has just recently been used, so it | |
| 206 | − * should be really fast, too. */ | |
| 207 | − BUG_ON(!drm_mm_search_free(&dev_priv->mm.gtt_space, min_size, | |
| 208 | − alignment, 0)); | |
| 209 | − | |
| 210 | − return 0; | |
| 205 | + return ret; | |
| 211 | 206 | } |
| 212 | 207 | |
| 213 | 208 | int |
| @@ -1013,8 +1013,8 @@ void intel_wait_for_vblank(struct drm_device *dev, int pipe) · 1012 unmodified lines | ||
| 1013 | 1013 | DRM_DEBUG_KMS("vblank wait timed out\n"); |
| 1014 | 1014 | } |
| 1015 | 1015 | |
| 1016 | −/** | |
| 1017 | − * intel_wait_for_vblank_off - wait for vblank after disabling a pipe | |
| 1016 | +/* | |
| 1017 | + * intel_wait_for_pipe_off - wait for pipe to turn off | |
| 1018 | 1018 | * @dev: drm device |
| 1019 | 1019 | * @pipe: pipe to wait for |
| 1020 | 1020 | * |
| @@ -1022,25 +1022,39 @@ void intel_wait_for_vblank(struct drm_device *dev, int pipe) · 1 unmodified line | ||
| 1022 | 1022 | * spinning on the vblank interrupt status bit, since we won't actually |
| 1023 | 1023 | * see an interrupt when the pipe is disabled. |
| 1024 | 1024 | * |
| 1025 | − * So this function waits for the display line value to settle (it | |
| 1026 | − * usually ends up stopping at the start of the next frame). | |
| 1025 | + * On Gen4 and above: | |
| 1026 | + * wait for the pipe register state bit to turn off | |
| 1027 | + * | |
| 1028 | + * Otherwise: | |
| 1029 | + * wait for the display line value to settle (it usually | |
| 1030 | + * ends up stopping at the start of the next frame). | |
| 1031 | + * | |
| 1027 | 1032 | */ |
| 1028 | −void intel_wait_for_vblank_off(struct drm_device *dev, int pipe) | |
| 1033 | +static void intel_wait_for_pipe_off(struct drm_device *dev, int pipe) | |
| 1029 | 1034 | { |
| 1030 | 1035 | struct drm_i915_private *dev_priv = dev->dev_private; |
| 1031 | − int pipedsl_reg = (pipe == 0 ? PIPEADSL : PIPEBDSL); | |
| 1032 | − unsigned long timeout = jiffies + msecs_to_jiffies(100); | |
| 1033 | − u32 last_line; | |
| 1034 | − | |
| 1035 | − /* Wait for the display line to settle */ | |
| 1036 | − do { | |
| 1037 | − last_line = I915_READ(pipedsl_reg) & DSL_LINEMASK; | |
| 1038 | − mdelay(5); | |
| 1039 | − } while (((I915_READ(pipedsl_reg) & DSL_LINEMASK) != last_line) && | |
| 1040 | − time_after(timeout, jiffies)); | |
| 1041 | − | |
| 1042 | − if (time_after(jiffies, timeout)) | |
| 1043 | − DRM_DEBUG_KMS("vblank wait timed out\n"); | |
| 1036 | + | |
| 1037 | + if (INTEL_INFO(dev)->gen >= 4) { | |
| 1038 | + int pipeconf_reg = (pipe == 0 ? PIPEACONF : PIPEBCONF); | |
| 1039 | + | |
| 1040 | + /* Wait for the Pipe State to go off */ | |
| 1041 | + if (wait_for((I915_READ(pipeconf_reg) & I965_PIPECONF_ACTIVE) == 0, | |
| 1042 | + 100, 0)) | |
| 1043 | + DRM_DEBUG_KMS("pipe_off wait timed out\n"); | |
| 1044 | + } else { | |
| 1045 | + u32 last_line; | |
| 1046 | + int pipedsl_reg = (pipe == 0 ? PIPEADSL : PIPEBDSL); | |
| 1047 | + unsigned long timeout = jiffies + msecs_to_jiffies(100); | |
| 1048 | + | |
| 1049 | + /* Wait for the display line to settle */ | |
| 1050 | + do { | |
| 1051 | + last_line = I915_READ(pipedsl_reg) & DSL_LINEMASK; | |
| 1052 | + mdelay(5); | |
| 1053 | + } while (((I915_READ(pipedsl_reg) & DSL_LINEMASK) != last_line) && | |
| 1054 | + time_after(timeout, jiffies)); | |
| 1055 | + if (time_after(jiffies, timeout)) | |
| 1056 | + DRM_DEBUG_KMS("pipe_off wait timed out\n"); | |
| 1057 | + } | |
| 1044 | 1058 | } |
| 1045 | 1059 | |
| 1046 | 1060 | /* Parameters have changed, update FBC info */ |
| @@ -2328,13 +2342,13 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode) · 1281 unmodified lines | ||
| 2328 | 2342 | I915_READ(dspbase_reg); |
| 2329 | 2343 | } |
| 2330 | 2344 | |
| 2331 | − /* Wait for vblank for the disable to take effect */ | |
| 2332 | − intel_wait_for_vblank_off(dev, pipe); | |
| 2333 | − | |
| 2334 | 2345 | /* Don't disable pipe A or pipe A PLLs if needed */ |
| 2335 | 2346 | if (pipeconf_reg == PIPEACONF && |
| 2336 | − (dev_priv->quirks & QUIRK_PIPEA_FORCE)) | |
| 2347 | + (dev_priv->quirks & QUIRK_PIPEA_FORCE)) { | |
| 2348 | + /* Wait for vblank for the disable to take effect */ | |
| 2349 | + intel_wait_for_vblank(dev, pipe); | |
| 2337 | 2350 | goto skip_pipe_off; |
| 2351 | + } | |
| 2338 | 2352 | |
| 2339 | 2353 | /* Next, disable display pipes */ |
| 2340 | 2354 | temp = I915_READ(pipeconf_reg); |
| @@ -2343,8 +2357,8 @@ static void i9xx_crtc_dpms(struct drm_crtc *crtc, int mode) · 2 unmodified lines | ||
| 2343 | 2357 | I915_READ(pipeconf_reg); |
| 2344 | 2358 | } |
| 2345 | 2359 | |
| 2346 | − /* Wait for vblank for the disable to take effect. */ | |
| 2347 | − intel_wait_for_vblank_off(dev, pipe); | |
| 2360 | + /* Wait for the pipe to turn off */ | |
| 2361 | + intel_wait_for_pipe_off(dev, pipe); | |
| 2348 | 2362 | |
| 2349 | 2363 | temp = I915_READ(dpll_reg); |
| 2350 | 2364 | if ((temp & DPLL_VCO_ENABLE) != 0) { |
| @@ -1138,18 +1138,14 @@ static bool · 1137 unmodified lines | ||
| 1138 | 1138 | intel_dp_set_link_train(struct intel_dp *intel_dp, |
| 1139 | 1139 | uint32_t dp_reg_value, |
| 1140 | 1140 | uint8_t dp_train_pat, |
| 1141 | − uint8_t train_set[4], | |
| 1142 | − bool first) | |
| 1141 | + uint8_t train_set[4]) | |
| 1143 | 1142 | { |
| 1144 | 1143 | struct drm_device *dev = intel_dp->base.enc.dev; |
| 1145 | 1144 | struct drm_i915_private *dev_priv = dev->dev_private; |
| 1146 | − struct intel_crtc *intel_crtc = to_intel_crtc(intel_dp->base.enc.crtc); | |
| 1147 | 1145 | int ret; |
| 1148 | 1146 | |
| 1149 | 1147 | I915_WRITE(intel_dp->output_reg, dp_reg_value); |
| 1150 | 1148 | POSTING_READ(intel_dp->output_reg); |
| 1151 | − if (first) | |
| 1152 | − intel_wait_for_vblank(dev, intel_crtc->pipe); | |
| 1153 | 1149 | |
| 1154 | 1150 | intel_dp_aux_native_write_1(intel_dp, |
| 1155 | 1151 | DP_TRAINING_PATTERN_SET, |
| @@ -1174,10 +1170,15 @@ intel_dp_link_train(struct intel_dp *intel_dp) · 18 unmodified lines | ||
| 1174 | 1170 | uint8_t voltage; |
| 1175 | 1171 | bool clock_recovery = false; |
| 1176 | 1172 | bool channel_eq = false; |
| 1177 | − bool first = true; | |
| 1178 | 1173 | int tries; |
| 1179 | 1174 | u32 reg; |
| 1180 | 1175 | uint32_t DP = intel_dp->DP; |
| 1176 | + struct intel_crtc *intel_crtc = to_intel_crtc(intel_dp->base.enc.crtc); | |
| 1177 | + | |
| 1178 | + /* Enable output, wait for it to become active */ | |
| 1179 | + I915_WRITE(intel_dp->output_reg, intel_dp->DP); | |
| 1180 | + POSTING_READ(intel_dp->output_reg); | |
| 1181 | + intel_wait_for_vblank(dev, intel_crtc->pipe); | |
| 1181 | 1182 | |
| 1182 | 1183 | /* Write the link configuration data */ |
| 1183 | 1184 | intel_dp_aux_native_write(intel_dp, DP_LINK_BW_SET, |
| @@ -1210,9 +1211,8 @@ intel_dp_link_train(struct intel_dp *intel_dp) · 26 unmodified lines | ||
| 1210 | 1211 | reg = DP | DP_LINK_TRAIN_PAT_1; |
| 1211 | 1212 | |
| 1212 | 1213 | if (!intel_dp_set_link_train(intel_dp, reg, |
| 1213 | − DP_TRAINING_PATTERN_1, train_set, first)) | |
| 1214 | + DP_TRAINING_PATTERN_1, train_set)) | |
| 1214 | 1215 | break; |
| 1215 | − first = false; | |
| 1216 | 1216 | /* Set training pattern 1 */ |
| 1217 | 1217 | |
| 1218 | 1218 | udelay(100); |
| @@ -1266,8 +1266,7 @@ intel_dp_link_train(struct intel_dp *intel_dp) · 47 unmodified lines | ||
| 1266 | 1266 | |
| 1267 | 1267 | /* channel eq pattern */ |
| 1268 | 1268 | if (!intel_dp_set_link_train(intel_dp, reg, |
| 1269 | − DP_TRAINING_PATTERN_2, train_set, | |
| 1270 | − false)) | |
| 1269 | + DP_TRAINING_PATTERN_2, train_set)) | |
| 1271 | 1270 | break; |
| 1272 | 1271 | |
| 1273 | 1272 | udelay(400); |
| @@ -229,7 +229,6 @@ extern struct drm_display_mode *intel_crtc_mode_get(struct drm_device *dev, · 228 unmodified lines | ||
| 229 | 229 | struct drm_crtc *crtc); |
| 230 | 230 | int intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data, |
| 231 | 231 | struct drm_file *file_priv); |
| 232 | −extern void intel_wait_for_vblank_off(struct drm_device *dev, int pipe); | |
| 233 | 232 | extern void intel_wait_for_vblank(struct drm_device *dev, int pipe); |
| 234 | 233 | extern struct drm_crtc *intel_get_crtc_from_pipe(struct drm_device *dev, int pipe); |
| 235 | 234 | extern struct drm_crtc *intel_get_load_detect_pipe(struct intel_encoder *intel_encoder, |
| @@ -237,8 +237,10 @@ int intel_fbdev_destroy(struct drm_device *dev, · 236 unmodified lines | ||
| 237 | 237 | drm_fb_helper_fini(&ifbdev->helper); |
| 238 | 238 | |
| 239 | 239 | drm_framebuffer_cleanup(&ifb->base); |
| 240 | − if (ifb->obj) | |
| 240 | + if (ifb->obj) { | |
| 241 | + drm_gem_object_handle_unreference(ifb->obj); | |
| 241 | 242 | drm_gem_object_unreference(ifb->obj); |
| 243 | + } | |
| 242 | 244 | |
| 243 | 245 | return 0; |
| 244 | 246 | } |
| @@ -2170,8 +2170,7 @@ intel_sdvo_tv_init(struct intel_sdvo *intel_sdvo, int type) · 2169 unmodified lines | ||
| 2170 | 2170 | return true; |
| 2171 | 2171 | |
| 2172 | 2172 | err: |
| 2173 | − intel_sdvo_destroy_enhance_property(connector); | |
| 2174 | − kfree(intel_sdvo_connector); | |
| 2173 | + intel_sdvo_destroy(connector); | |
| 2175 | 2174 | return false; |
| 2176 | 2175 | } |
| 2177 | 2176 | |
| @@ -2243,8 +2242,7 @@ intel_sdvo_lvds_init(struct intel_sdvo *intel_sdvo, int device) · 65 unmodified lines | ||
| 2243 | 2242 | return true; |
| 2244 | 2243 | |
| 2245 | 2244 | err: |
| 2246 | − intel_sdvo_destroy_enhance_property(connector); | |
| 2247 | − kfree(intel_sdvo_connector); | |
| 2245 | + intel_sdvo_destroy(connector); | |
| 2248 | 2246 | return false; |
| 2249 | 2247 | } |
| 2250 | 2248 | |
| @@ -2522,11 +2520,10 @@ static bool intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo, · 271 unmodified lines | ||
| 2522 | 2520 | uint16_t response; |
| 2523 | 2521 | } enhancements; |
| 2524 | 2522 | |
| 2525 | − if (!intel_sdvo_get_value(intel_sdvo, | |
| 2526 | − SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS, | |
| 2527 | − &enhancements, sizeof(enhancements))) | |
| 2528 | − return false; | |
| 2529 | − | |
| 2523 | + enhancements.response = 0; | |
| 2524 | + intel_sdvo_get_value(intel_sdvo, | |
| 2525 | + SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS, | |
| 2526 | + &enhancements, sizeof(enhancements)); | |
| 2530 | 2527 | if (enhancements.response == 0) { |
| 2531 | 2528 | DRM_DEBUG_KMS("No enhancement is supported\n"); |
| 2532 | 2529 | return true; |
| @@ -558,8 +558,10 @@ nouveau_connector_get_modes(struct drm_connector *connector) · 557 unmodified lines | ||
| 558 | 558 | if (nv_encoder->dcb->type == OUTPUT_LVDS && |
| 559 | 559 | (nv_encoder->dcb->lvdsconf.use_straps_for_mode || |
| 560 | 560 | dev_priv->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) { |
| 561 | − nv_connector->native_mode = drm_mode_create(dev); | |
| 562 | − nouveau_bios_fp_mode(dev, nv_connector->native_mode); | |
| 561 | + struct drm_display_mode mode; | |
| 562 | + | |
| 563 | + nouveau_bios_fp_mode(dev, &mode); | |
| 564 | + nv_connector->native_mode = drm_mode_duplicate(dev, &mode); | |
| 563 | 565 | } |
| 564 | 566 | |
| 565 | 567 | /* Find the native mode if this is a digital panel, if we didn't |
| @@ -352,6 +352,7 @@ nouveau_fbcon_destroy(struct drm_device *dev, struct nouveau_fbdev *nfbdev) · 351 unmodified lines | ||
| 352 | 352 | |
| 353 | 353 | if (nouveau_fb->nvbo) { |
| 354 | 354 | nouveau_bo_unmap(nouveau_fb->nvbo); |
| 355 | + drm_gem_object_handle_unreference_unlocked(nouveau_fb->nvbo->gem); | |
| 355 | 356 | drm_gem_object_unreference_unlocked(nouveau_fb->nvbo->gem); |
| 356 | 357 | nouveau_fb->nvbo = NULL; |
| 357 | 358 | } |
| @@ -167,11 +167,9 @@ nouveau_gem_ioctl_new(struct drm_device *dev, void *data, · 166 unmodified lines | ||
| 167 | 167 | goto out; |
| 168 | 168 | |
| 169 | 169 | ret = drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle); |
| 170 | + /* drop reference from allocate - handle holds it now */ | |
| 171 | + drm_gem_object_unreference_unlocked(nvbo->gem); | |
| 170 | 172 | out: |
| 171 | − drm_gem_object_handle_unreference_unlocked(nvbo->gem); | |
| 172 | − | |
| 173 | − if (ret) | |
| 174 | − drm_gem_object_unreference_unlocked(nvbo->gem); | |
| 175 | 173 | return ret; |
| 176 | 174 | } |
| 177 | 175 | |
| @@ -79,6 +79,7 @@ nouveau_notifier_takedown_channel(struct nouveau_channel *chan) · 78 unmodified lines | ||
| 79 | 79 | mutex_lock(&dev->struct_mutex); |
| 80 | 80 | nouveau_bo_unpin(chan->notifier_bo); |
| 81 | 81 | mutex_unlock(&dev->struct_mutex); |
| 82 | + drm_gem_object_handle_unreference_unlocked(chan->notifier_bo->gem); | |
| 82 | 83 | drm_gem_object_unreference_unlocked(chan->notifier_bo->gem); |
| 83 | 84 | drm_mm_takedown(&chan->notifier_heap); |
| 84 | 85 | } |
| @@ -4999,7 +4999,7 @@ typedef struct _SW_I2C_IO_DATA_PARAMETERS · 4998 unmodified lines | ||
| 4999 | 4999 | #define SW_I2C_CNTL_WRITE1BIT 6 |
| 5000 | 5000 | |
| 5001 | 5001 | //==============================VESA definition Portion=============================== |
| 5002 | −#define VESA_OEM_PRODUCT_REV '01.00' | |
| 5002 | +#define VESA_OEM_PRODUCT_REV "01.00" | |
| 5003 | 5003 | #define VESA_MODE_ATTRIBUTE_MODE_SUPPORT 0xBB //refer to VBE spec p.32, no TTY support |
| 5004 | 5004 | #define VESA_MODE_WIN_ATTRIBUTE 7 |
| 5005 | 5005 | #define VESA_WIN_SIZE 64 |
| @@ -2729,7 +2729,7 @@ int r600_ib_test(struct radeon_device *rdev) · 2728 unmodified lines | ||
| 2729 | 2729 | if (i < rdev->usec_timeout) { |
| 2730 | 2730 | DRM_INFO("ib test succeeded in %u usecs\n", i); |
| 2731 | 2731 | } else { |
| 2732 | − DRM_ERROR("radeon: ib test failed (sracth(0x%04X)=0x%08X)\n", | |
| 2732 | + DRM_ERROR("radeon: ib test failed (scratch(0x%04X)=0x%08X)\n", | |
| 2733 | 2733 | scratch, tmp); |
| 2734 | 2734 | r = -EINVAL; |
| 2735 | 2735 | } |
| @@ -3528,7 +3528,8 @@ void r600_ioctl_wait_idle(struct radeon_device *rdev, struct radeon_bo *bo) · 792 unmodified lines | ||
| 3528 | 3528 | /* r7xx hw bug. write to HDP_DEBUG1 followed by fb read |
| 3529 | 3529 | * rather than write to HDP_REG_COHERENCY_FLUSH_CNTL |
| 3530 | 3530 | */ |
| 3531 | − if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740)) { | |
| 3531 | + if ((rdev->family >= CHIP_RV770) && (rdev->family <= CHIP_RV740) && | |
| 3532 | + rdev->vram_scratch.ptr) { | |
| 3532 | 3533 | void __iomem *ptr = (void *)rdev->vram_scratch.ptr; |
| 3533 | 3534 | u32 tmp; |
| 3534 | 3535 | |
| @@ -317,6 +317,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev, · 316 unmodified lines | ||
| 317 | 317 | *connector_type = DRM_MODE_CONNECTOR_DVID; |
| 318 | 318 | } |
| 319 | 319 | |
| 320 | + /* MSI K9A2GM V2/V3 board has no HDMI or DVI */ | |
| 321 | + if ((dev->pdev->device == 0x796e) && | |
| 322 | + (dev->pdev->subsystem_vendor == 0x1462) && | |
| 323 | + (dev->pdev->subsystem_device == 0x7302)) { | |
| 324 | + if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) || | |
| 325 | + (supported_device == ATOM_DEVICE_DFP3_SUPPORT)) | |
| 326 | + return false; | |
| 327 | + } | |
| 328 | + | |
| 320 | 329 | /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */ |
| 321 | 330 | if ((dev->pdev->device == 0x7941) && |
| 322 | 331 | (dev->pdev->subsystem_vendor == 0x147b) && |
| @@ -349,6 +349,8 @@ static void radeon_print_display_setup(struct drm_device *dev) · 348 unmodified lines | ||
| 349 | 349 | DRM_INFO(" DFP4: %s\n", encoder_names[radeon_encoder->encoder_id]); |
| 350 | 350 | if (devices & ATOM_DEVICE_DFP5_SUPPORT) |
| 351 | 351 | DRM_INFO(" DFP5: %s\n", encoder_names[radeon_encoder->encoder_id]); |
| 352 | + if (devices & ATOM_DEVICE_DFP6_SUPPORT) | |
| 353 | + DRM_INFO(" DFP6: %s\n", encoder_names[radeon_encoder->encoder_id]); | |
| 352 | 354 | if (devices & ATOM_DEVICE_TV1_SUPPORT) |
| 353 | 355 | DRM_INFO(" TV1: %s\n", encoder_names[radeon_encoder->encoder_id]); |
| 354 | 356 | if (devices & ATOM_DEVICE_CV_SUPPORT) |
| @@ -841,8 +843,9 @@ static void radeon_user_framebuffer_destroy(struct drm_framebuffer *fb) · 486 unmodified lines | ||
| 841 | 843 | { |
| 842 | 844 | struct radeon_framebuffer *radeon_fb = to_radeon_framebuffer(fb); |
| 843 | 845 | |
| 844 | − if (radeon_fb->obj) | |
| 846 | + if (radeon_fb->obj) { | |
| 845 | 847 | drm_gem_object_unreference_unlocked(radeon_fb->obj); |
| 848 | + } | |
| 846 | 849 | drm_framebuffer_cleanup(fb); |
| 847 | 850 | kfree(radeon_fb); |
| 848 | 851 | } |
| @@ -94,8 +94,10 @@ static void radeonfb_destroy_pinned_object(struct drm_gem_object *gobj) · 93 unmodified lines | ||
| 94 | 94 | ret = radeon_bo_reserve(rbo, false); |
| 95 | 95 | if (likely(ret == 0)) { |
| 96 | 96 | radeon_bo_kunmap(rbo); |
| 97 | + radeon_bo_unpin(rbo); | |
| 97 | 98 | radeon_bo_unreserve(rbo); |
| 98 | 99 | } |
| 100 | + drm_gem_object_handle_unreference(gobj); | |
| 99 | 101 | drm_gem_object_unreference_unlocked(gobj); |
| 100 | 102 | } |
| 101 | 103 | |
| @@ -325,8 +327,6 @@ static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfb · 223 unmodified lines | ||
| 325 | 327 | { |
| 326 | 328 | struct fb_info *info; |
| 327 | 329 | struct radeon_framebuffer *rfb = &rfbdev->rfb; |
| 328 | − struct radeon_bo *rbo; | |
| 329 | − int r; | |
| 330 | 330 | |
| 331 | 331 | if (rfbdev->helper.fbdev) { |
| 332 | 332 | info = rfbdev->helper.fbdev; |
| @@ -338,14 +338,8 @@ static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfb · 5 unmodified lines | ||
| 338 | 338 | } |
| 339 | 339 | |
| 340 | 340 | if (rfb->obj) { |
| 341 | − rbo = rfb->obj->driver_private; | |
| 342 | − r = radeon_bo_reserve(rbo, false); | |
| 343 | − if (likely(r == 0)) { | |
| 344 | − radeon_bo_kunmap(rbo); | |
| 345 | − radeon_bo_unpin(rbo); | |
| 346 | − radeon_bo_unreserve(rbo); | |
| 347 | − } | |
| 348 | − drm_gem_object_unreference_unlocked(rfb->obj); | |
| 341 | + radeonfb_destroy_pinned_object(rfb->obj); | |
| 342 | + rfb->obj = NULL; | |
| 349 | 343 | } |
| 350 | 344 | drm_fb_helper_fini(&rfbdev->helper); |
| 351 | 345 | drm_framebuffer_cleanup(&rfb->base); |
| @@ -201,11 +201,11 @@ int radeon_gem_create_ioctl(struct drm_device *dev, void *data, · 200 unmodified lines | ||
| 201 | 201 | return r; |
| 202 | 202 | } |
| 203 | 203 | r = drm_gem_handle_create(filp, gobj, &handle); |
| 204 | + /* drop reference from allocate - handle holds it now */ | |
| 205 | + drm_gem_object_unreference_unlocked(gobj); | |
| 204 | 206 | if (r) { |
| 205 | − drm_gem_object_unreference_unlocked(gobj); | |
| 206 | 207 | return r; |
| 207 | 208 | } |
| 208 | − drm_gem_object_handle_unreference_unlocked(gobj); | |
| 209 | 209 | args->handle = handle; |
| 210 | 210 | return 0; |
| 211 | 211 | } |
| @@ -203,6 +203,10 @@ int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) · 202 unmodified lines | ||
| 203 | 203 | */ |
| 204 | 204 | int radeon_driver_firstopen_kms(struct drm_device *dev) |
| 205 | 205 | { |
| 206 | + struct radeon_device *rdev = dev->dev_private; | |
| 207 | + | |
| 208 | + if (rdev->powered_down) | |
| 209 | + return -EINVAL; | |
| 206 | 210 | return 0; |
| 207 | 211 | } |
| 208 | 212 | |
| @@ -351,6 +351,7 @@ static int ttm_buffer_object_transfer(struct ttm_buffer_object *bo, · 350 unmodified lines | ||
| 351 | 351 | INIT_LIST_HEAD(&fbo->lru); |
| 352 | 352 | INIT_LIST_HEAD(&fbo->swap); |
| 353 | 353 | fbo->vm_node = NULL; |
| 354 | + atomic_set(&fbo->cpu_writers, 0); | |
| 354 | 355 | |
| 355 | 356 | fbo->sync_obj = driver->sync_obj_ref(bo->sync_obj); |
| 356 | 357 | kref_init(&fbo->list_kref); |
| @@ -69,7 +69,7 @@ struct ttm_page_pool { · 68 unmodified lines | ||
| 69 | 69 | spinlock_t lock; |
| 70 | 70 | bool fill_lock; |
| 71 | 71 | struct list_head list; |
| 72 | − int gfp_flags; | |
| 72 | + gfp_t gfp_flags; | |
| 73 | 73 | unsigned npages; |
| 74 | 74 | char *name; |
| 75 | 75 | unsigned long nfrees; |
| @@ -475,7 +475,7 @@ static void ttm_handle_caching_state_failure(struct list_head *pages, · 399 unmodified lines | ||
| 475 | 475 | * This function is reentrant if caller updates count depending on number of |
| 476 | 476 | * pages returned in pages array. |
| 477 | 477 | */ |
| 478 | −static int ttm_alloc_new_pages(struct list_head *pages, int gfp_flags, | |
| 478 | +static int ttm_alloc_new_pages(struct list_head *pages, gfp_t gfp_flags, | |
| 479 | 479 | int ttm_flags, enum ttm_caching_state cstate, unsigned count) |
| 480 | 480 | { |
| 481 | 481 | struct page **caching_array; |
| @@ -666,7 +666,7 @@ int ttm_get_pages(struct list_head *pages, int flags, · 184 unmodified lines | ||
| 666 | 666 | { |
| 667 | 667 | struct ttm_page_pool *pool = ttm_get_pool(flags, cstate); |
| 668 | 668 | struct page *p = NULL; |
| 669 | − int gfp_flags = GFP_USER; | |
| 669 | + gfp_t gfp_flags = GFP_USER; | |
| 670 | 670 | int r; |
| 671 | 671 | |
| 672 | 672 | /* set zero flag for page allocation if required */ |
| @@ -818,7 +818,7 @@ int ttm_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages) · 145 unmodified lines | ||
| 818 | 818 | return 0; |
| 819 | 819 | } |
| 820 | 820 | |
| 821 | −void ttm_page_alloc_fini() | |
| 821 | +void ttm_page_alloc_fini(void) | |
| 822 | 822 | { |
| 823 | 823 | int i; |
| 824 | 824 | |
| @@ -148,13 +148,16 @@ static struct pci_device_id vmw_pci_id_list[] = { · 147 unmodified lines | ||
| 148 | 148 | {0, 0, 0} |
| 149 | 149 | }; |
| 150 | 150 | |
| 151 | −static char *vmw_devname = "vmwgfx"; | |
| 151 | +static int enable_fbdev; | |
| 152 | 152 | |
| 153 | 153 | static int vmw_probe(struct pci_dev *, const struct pci_device_id *); |
| 154 | 154 | static void vmw_master_init(struct vmw_master *); |
| 155 | 155 | static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val, |
| 156 | 156 | void *ptr); |
| 157 | 157 | |
| 158 | +MODULE_PARM_DESC(enable_fbdev, "Enable vmwgfx fbdev"); | |
| 159 | +module_param_named(enable_fbdev, enable_fbdev, int, 0600); | |
| 160 | + | |
| 158 | 161 | static void vmw_print_capabilities(uint32_t capabilities) |
| 159 | 162 | { |
| 160 | 163 | DRM_INFO("Capabilities:\n"); |
| @@ -192,8 +195,6 @@ static int vmw_request_device(struct vmw_private *dev_priv) · 31 unmodified lines | ||
| 192 | 195 | { |
| 193 | 196 | int ret; |
| 194 | 197 | |
| 195 | − vmw_kms_save_vga(dev_priv); | |
| 196 | − | |
| 197 | 198 | ret = vmw_fifo_init(dev_priv, &dev_priv->fifo); |
| 198 | 199 | if (unlikely(ret != 0)) { |
| 199 | 200 | DRM_ERROR("Unable to initialize FIFO.\n"); |
| @@ -206,9 +207,35 @@ static int vmw_request_device(struct vmw_private *dev_priv) · 6 unmodified lines | ||
| 206 | 207 | static void vmw_release_device(struct vmw_private *dev_priv) |
| 207 | 208 | { |
| 208 | 209 | vmw_fifo_release(dev_priv, &dev_priv->fifo); |
| 209 | − vmw_kms_restore_vga(dev_priv); | |
| 210 | 210 | } |
| 211 | 211 | |
| 212 | +int vmw_3d_resource_inc(struct vmw_private *dev_priv) | |
| 213 | +{ | |
| 214 | + int ret = 0; | |
| 215 | + | |
| 216 | + mutex_lock(&dev_priv->release_mutex); | |
| 217 | + if (unlikely(dev_priv->num_3d_resources++ == 0)) { | |
| 218 | + ret = vmw_request_device(dev_priv); | |
| 219 | + if (unlikely(ret != 0)) | |
| 220 | + --dev_priv->num_3d_resources; | |
| 221 | + } | |
| 222 | + mutex_unlock(&dev_priv->release_mutex); | |
| 223 | + return ret; | |
| 224 | +} | |
| 225 | + | |
| 226 | + | |
| 227 | +void vmw_3d_resource_dec(struct vmw_private *dev_priv) | |
| 228 | +{ | |
| 229 | + int32_t n3d; | |
| 230 | + | |
| 231 | + mutex_lock(&dev_priv->release_mutex); | |
| 232 | + if (unlikely(--dev_priv->num_3d_resources == 0)) | |
| 233 | + vmw_release_device(dev_priv); | |
| 234 | + n3d = (int32_t) dev_priv->num_3d_resources; | |
| 235 | + mutex_unlock(&dev_priv->release_mutex); | |
| 236 | + | |
| 237 | + BUG_ON(n3d < 0); | |
| 238 | +} | |
| 212 | 239 | |
| 213 | 240 | static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) |
| 214 | 241 | { |
| @@ -228,6 +255,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) · 13 unmodified lines | ||
| 228 | 255 | dev_priv->last_read_sequence = (uint32_t) -100; |
| 229 | 256 | mutex_init(&dev_priv->hw_mutex); |
| 230 | 257 | mutex_init(&dev_priv->cmdbuf_mutex); |
| 258 | + mutex_init(&dev_priv->release_mutex); | |
| 231 | 259 | rwlock_init(&dev_priv->resource_lock); |
| 232 | 260 | idr_init(&dev_priv->context_idr); |
| 233 | 261 | idr_init(&dev_priv->surface_idr); |
| @@ -244,6 +272,8 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) · 10 unmodified lines | ||
| 244 | 272 | dev_priv->vram_start = pci_resource_start(dev->pdev, 1); |
| 245 | 273 | dev_priv->mmio_start = pci_resource_start(dev->pdev, 2); |
| 246 | 274 | |
| 275 | + dev_priv->enable_fb = enable_fbdev; | |
| 276 | + | |
| 247 | 277 | mutex_lock(&dev_priv->hw_mutex); |
| 248 | 278 | |
| 249 | 279 | vmw_write(dev_priv, SVGA_REG_ID, SVGA_ID_2); |
| @@ -343,17 +373,6 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) · 93 unmodified lines | ||
| 343 | 373 | |
| 344 | 374 | dev->dev_private = dev_priv; |
| 345 | 375 | |
| 346 | − if (!dev->devname) | |
| 347 | − dev->devname = vmw_devname; | |
| 348 | − | |
| 349 | − if (dev_priv->capabilities & SVGA_CAP_IRQMASK) { | |
| 350 | − ret = drm_irq_install(dev); | |
| 351 | − if (unlikely(ret != 0)) { | |
| 352 | − DRM_ERROR("Failed installing irq: %d\n", ret); | |
| 353 | − goto out_no_irq; | |
| 354 | − } | |
| 355 | − } | |
| 356 | − | |
| 357 | 376 | ret = pci_request_regions(dev->pdev, "vmwgfx probe"); |
| 358 | 377 | dev_priv->stealth = (ret != 0); |
| 359 | 378 | if (dev_priv->stealth) { |
| @@ -369,26 +388,52 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) · 9 unmodified lines | ||
| 369 | 388 | goto out_no_device; |
| 370 | 389 | } |
| 371 | 390 | } |
| 372 | − ret = vmw_request_device(dev_priv); | |
| 391 | + ret = vmw_kms_init(dev_priv); | |
| 373 | 392 | if (unlikely(ret != 0)) |
| 374 | − goto out_no_device; | |
| 375 | − vmw_kms_init(dev_priv); | |
| 393 | + goto out_no_kms; | |
| 376 | 394 | vmw_overlay_init(dev_priv); |
| 377 | − vmw_fb_init(dev_priv); | |
| 395 | + if (dev_priv->enable_fb) { | |
| 396 | + ret = vmw_3d_resource_inc(dev_priv); | |
| 397 | + if (unlikely(ret != 0)) | |
| 398 | + goto out_no_fifo; | |
| 399 | + vmw_kms_save_vga(dev_priv); | |
| 400 | + vmw_fb_init(dev_priv); | |
| 401 | + DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ? | |
| 402 | + "Detected device 3D availability.\n" : | |
| 403 | + "Detected no device 3D availability.\n"); | |
| 404 | + } else { | |
| 405 | + DRM_INFO("Delayed 3D detection since we're not " | |
| 406 | + "running the device in SVGA mode yet.\n"); | |
| 407 | + } | |
| 408 | + | |
| 409 | + if (dev_priv->capabilities & SVGA_CAP_IRQMASK) { | |
| 410 | + ret = drm_irq_install(dev); | |
| 411 | + if (unlikely(ret != 0)) { | |
| 412 | + DRM_ERROR("Failed installing irq: %d\n", ret); | |
| 413 | + goto out_no_irq; | |
| 414 | + } | |
| 415 | + } | |
| 378 | 416 | |
| 379 | 417 | dev_priv->pm_nb.notifier_call = vmwgfx_pm_notifier; |
| 380 | 418 | register_pm_notifier(&dev_priv->pm_nb); |
| 381 | 419 | |
| 382 | − DRM_INFO("%s", vmw_fifo_have_3d(dev_priv) ? "Have 3D\n" : "No 3D\n"); | |
| 383 | − | |
| 384 | 420 | return 0; |
| 385 | 421 | |
| 386 | −out_no_device: | |
| 387 | − if (dev_priv->capabilities & SVGA_CAP_IRQMASK) | |
| 388 | − drm_irq_uninstall(dev_priv->dev); | |
| 389 | − if (dev->devname == vmw_devname) | |
| 390 | − dev->devname = NULL; | |
| 391 | 422 | out_no_irq: |
| 423 | + if (dev_priv->enable_fb) { | |
| 424 | + vmw_fb_close(dev_priv); | |
| 425 | + vmw_kms_restore_vga(dev_priv); | |
| 426 | + vmw_3d_resource_dec(dev_priv); | |
| 427 | + } | |
| 428 | +out_no_fifo: | |
| 429 | + vmw_overlay_close(dev_priv); | |
| 430 | + vmw_kms_close(dev_priv); | |
| 431 | +out_no_kms: | |
| 432 | + if (dev_priv->stealth) | |
| 433 | + pci_release_region(dev->pdev, 2); | |
| 434 | + else | |
| 435 | + pci_release_regions(dev->pdev); | |
| 436 | +out_no_device: | |
| 392 | 437 | ttm_object_device_release(&dev_priv->tdev); |
| 393 | 438 | out_err4: |
| 394 | 439 | iounmap(dev_priv->mmio_virt); |
| @@ -415,19 +460,20 @@ static int vmw_driver_unload(struct drm_device *dev) · 20 unmodified lines | ||
| 415 | 460 | |
| 416 | 461 | unregister_pm_notifier(&dev_priv->pm_nb); |
| 417 | 462 | |
| 418 | − vmw_fb_close(dev_priv); | |
| 463 | + if (dev_priv->capabilities & SVGA_CAP_IRQMASK) | |
| 464 | + drm_irq_uninstall(dev_priv->dev); | |
| 465 | + if (dev_priv->enable_fb) { | |
| 466 | + vmw_fb_close(dev_priv); | |
| 467 | + vmw_kms_restore_vga(dev_priv); | |
| 468 | + vmw_3d_resource_dec(dev_priv); | |
| 469 | + } | |
| 419 | 470 | vmw_kms_close(dev_priv); |
| 420 | 471 | vmw_overlay_close(dev_priv); |
| 421 | − vmw_release_device(dev_priv); | |
| 422 | 472 | if (dev_priv->stealth) |
| 423 | 473 | pci_release_region(dev->pdev, 2); |
| 424 | 474 | else |
| 425 | 475 | pci_release_regions(dev->pdev); |
| 426 | 476 | |
| 427 | − if (dev_priv->capabilities & SVGA_CAP_IRQMASK) | |
| 428 | − drm_irq_uninstall(dev_priv->dev); | |
| 429 | − if (dev->devname == vmw_devname) | |
| 430 | − dev->devname = NULL; | |
| 431 | 477 | ttm_object_device_release(&dev_priv->tdev); |
| 432 | 478 | iounmap(dev_priv->mmio_virt); |
| 433 | 479 | drm_mtrr_del(dev_priv->mmio_mtrr, dev_priv->mmio_start, |
| @@ -500,7 +546,7 @@ static long vmw_unlocked_ioctl(struct file *filp, unsigned int cmd, · 66 unmodified lines | ||
| 500 | 546 | struct drm_ioctl_desc *ioctl = |
| 501 | 547 | &vmw_ioctls[nr - DRM_COMMAND_BASE]; |
| 502 | 548 | |
| 503 | − if (unlikely(ioctl->cmd != cmd)) { | |
| 549 | + if (unlikely(ioctl->cmd_drv != cmd)) { | |
| 504 | 550 | DRM_ERROR("Invalid command format, ioctl %d\n", |
| 505 | 551 | nr - DRM_COMMAND_BASE); |
| 506 | 552 | return -EINVAL; |
| @@ -589,6 +635,16 @@ static int vmw_master_set(struct drm_device *dev, · 82 unmodified lines | ||
| 589 | 635 | struct vmw_master *vmaster = vmw_master(file_priv->master); |
| 590 | 636 | int ret = 0; |
| 591 | 637 | |
| 638 | + if (!dev_priv->enable_fb) { | |
| 639 | + ret = vmw_3d_resource_inc(dev_priv); | |
| 640 | + if (unlikely(ret != 0)) | |
| 641 | + return ret; | |
| 642 | + vmw_kms_save_vga(dev_priv); | |
| 643 | + mutex_lock(&dev_priv->hw_mutex); | |
| 644 | + vmw_write(dev_priv, SVGA_REG_TRACES, 0); | |
| 645 | + mutex_unlock(&dev_priv->hw_mutex); | |
| 646 | + } | |
| 647 | + | |
| 592 | 648 | if (active) { |
| 593 | 649 | BUG_ON(active != &dev_priv->fbdev_master); |
| 594 | 650 | ret = ttm_vt_lock(&active->lock, false, vmw_fp->tfile); |
| @@ -617,7 +673,13 @@ static int vmw_master_set(struct drm_device *dev, · 22 unmodified lines | ||
| 617 | 673 | return 0; |
| 618 | 674 | |
| 619 | 675 | out_no_active_lock: |
| 620 | − vmw_release_device(dev_priv); | |
| 676 | + if (!dev_priv->enable_fb) { | |
| 677 | + mutex_lock(&dev_priv->hw_mutex); | |
| 678 | + vmw_write(dev_priv, SVGA_REG_TRACES, 1); | |
| 679 | + mutex_unlock(&dev_priv->hw_mutex); | |
| 680 | + vmw_kms_restore_vga(dev_priv); | |
| 681 | + vmw_3d_resource_dec(dev_priv); | |
| 682 | + } | |
| 621 | 683 | return ret; |
| 622 | 684 | } |
| 623 | 685 | |
| @@ -645,11 +707,23 @@ static void vmw_master_drop(struct drm_device *dev, · 21 unmodified lines | ||
| 645 | 707 | |
| 646 | 708 | ttm_lock_set_kill(&vmaster->lock, true, SIGTERM); |
| 647 | 709 | |
| 710 | + if (!dev_priv->enable_fb) { | |
| 711 | + ret = ttm_bo_evict_mm(&dev_priv->bdev, TTM_PL_VRAM); | |
| 712 | + if (unlikely(ret != 0)) | |
| 713 | + DRM_ERROR("Unable to clean VRAM on master drop.\n"); | |
| 714 | + mutex_lock(&dev_priv->hw_mutex); | |
| 715 | + vmw_write(dev_priv, SVGA_REG_TRACES, 1); | |
| 716 | + mutex_unlock(&dev_priv->hw_mutex); | |
| 717 | + vmw_kms_restore_vga(dev_priv); | |
| 718 | + vmw_3d_resource_dec(dev_priv); | |
| 719 | + } | |
| 720 | + | |
| 648 | 721 | dev_priv->active_master = &dev_priv->fbdev_master; |
| 649 | 722 | ttm_lock_set_kill(&dev_priv->fbdev_master.lock, false, SIGTERM); |
| 650 | 723 | ttm_vt_unlock(&dev_priv->fbdev_master.lock); |
| 651 | 724 | |
| 652 | − vmw_fb_on(dev_priv); | |
| 725 | + if (dev_priv->enable_fb) | |
| 726 | + vmw_fb_on(dev_priv); | |
| 653 | 727 | } |
| 654 | 728 | |
| 655 | 729 | |
| @@ -722,6 +796,7 @@ static struct drm_driver driver = { · 66 unmodified lines | ||
| 722 | 796 | .irq_postinstall = vmw_irq_postinstall, |
| 723 | 797 | .irq_uninstall = vmw_irq_uninstall, |
| 724 | 798 | .irq_handler = vmw_irq_handler, |
| 799 | + .get_vblank_counter = vmw_get_vblank_counter, | |
| 725 | 800 | .reclaim_buffers_locked = NULL, |
| 726 | 801 | .get_map_ofs = drm_core_get_map_ofs, |
| 727 | 802 | .get_reg_ofs = drm_core_get_reg_ofs, |
| @@ -277,6 +277,7 @@ struct vmw_private { · 276 unmodified lines | ||
| 277 | 277 | |
| 278 | 278 | bool stealth; |
| 279 | 279 | bool is_opened; |
| 280 | + bool enable_fb; | |
| 280 | 281 | |
| 281 | 282 | /** |
| 282 | 283 | * Master management. |
| @@ -285,6 +286,9 @@ struct vmw_private { · 2 unmodified lines | ||
| 285 | 286 | struct vmw_master *active_master; |
| 286 | 287 | struct vmw_master fbdev_master; |
| 287 | 288 | struct notifier_block pm_nb; |
| 289 | + | |
| 290 | + struct mutex release_mutex; | |
| 291 | + uint32_t num_3d_resources; | |
| 288 | 292 | }; |
| 289 | 293 | |
| 290 | 294 | static inline struct vmw_private *vmw_priv(struct drm_device *dev) |
| @@ -319,6 +323,9 @@ static inline uint32_t vmw_read(struct vmw_private *dev_priv, · 28 unmodified lines | ||
| 319 | 323 | return val; |
| 320 | 324 | } |
| 321 | 325 | |
| 326 | +int vmw_3d_resource_inc(struct vmw_private *dev_priv); | |
| 327 | +void vmw_3d_resource_dec(struct vmw_private *dev_priv); | |
| 328 | + | |
| 322 | 329 | /** |
| 323 | 330 | * GMR utilities - vmwgfx_gmr.c |
| 324 | 331 | */ |
| @@ -511,6 +518,7 @@ void vmw_kms_write_svga(struct vmw_private *vmw_priv, · 186 unmodified lines | ||
| 511 | 518 | unsigned bbp, unsigned depth); |
| 512 | 519 | int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data, |
| 513 | 520 | struct drm_file *file_priv); |
| 521 | +u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc); | |
| 514 | 522 | |
| 515 | 523 | /** |
| 516 | 524 | * Overlay control - vmwgfx_overlay.c |
| @@ -615,6 +615,11 @@ int vmw_dmabuf_to_start_of_vram(struct vmw_private *vmw_priv, · 614 unmodified lines | ||
| 615 | 615 | if (unlikely(ret != 0)) |
| 616 | 616 | goto err_unlock; |
| 617 | 617 | |
| 618 | + if (bo->mem.mem_type == TTM_PL_VRAM && | |
| 619 | + bo->mem.mm_node->start < bo->num_pages) | |
| 620 | + (void) ttm_bo_validate(bo, &vmw_sys_placement, false, | |
| 621 | + false, false); | |
| 622 | + | |
| 618 | 623 | ret = ttm_bo_validate(bo, &ne_placement, false, false, false); |
| 619 | 624 | |
| 620 | 625 | /* Could probably bug on */ |
| @@ -106,6 +106,7 @@ int vmw_fifo_init(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo) · 105 unmodified lines | ||
| 106 | 106 | mutex_lock(&dev_priv->hw_mutex); |
| 107 | 107 | dev_priv->enable_state = vmw_read(dev_priv, SVGA_REG_ENABLE); |
| 108 | 108 | dev_priv->config_done_state = vmw_read(dev_priv, SVGA_REG_CONFIG_DONE); |
| 109 | + dev_priv->traces_state = vmw_read(dev_priv, SVGA_REG_TRACES); | |
| 109 | 110 | vmw_write(dev_priv, SVGA_REG_ENABLE, 1); |
| 110 | 111 | |
| 111 | 112 | min = 4; |
| @@ -175,6 +176,8 @@ void vmw_fifo_release(struct vmw_private *dev_priv, struct vmw_fifo_state *fifo) · 63 unmodified lines | ||
| 175 | 176 | dev_priv->config_done_state); |
| 176 | 177 | vmw_write(dev_priv, SVGA_REG_ENABLE, |
| 177 | 178 | dev_priv->enable_state); |
| 179 | + vmw_write(dev_priv, SVGA_REG_TRACES, | |
| 180 | + dev_priv->traces_state); | |
| 178 | 181 | |
| 179 | 182 | mutex_unlock(&dev_priv->hw_mutex); |
| 180 | 183 | vmw_fence_queue_takedown(&fifo->fence_queue); |
| @@ -898,7 +898,19 @@ int vmw_kms_save_vga(struct vmw_private *vmw_priv) · 897 unmodified lines | ||
| 898 | 898 | save->width = vmw_read(vmw_priv, SVGA_REG_DISPLAY_WIDTH); |
| 899 | 899 | save->height = vmw_read(vmw_priv, SVGA_REG_DISPLAY_HEIGHT); |
| 900 | 900 | vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, SVGA_ID_INVALID); |
| 901 | + if (i == 0 && vmw_priv->num_displays == 1 && | |
| 902 | + save->width == 0 && save->height == 0) { | |
| 903 | + | |
| 904 | + /* | |
| 905 | + * It should be fairly safe to assume that these | |
| 906 | + * values are uninitialized. | |
| 907 | + */ | |
| 908 | + | |
| 909 | + save->width = vmw_priv->vga_width - save->pos_x; | |
| 910 | + save->height = vmw_priv->vga_height - save->pos_y; | |
| 911 | + } | |
| 901 | 912 | } |
| 913 | + | |
| 902 | 914 | return 0; |
| 903 | 915 | } |
| 904 | 916 | |
| @@ -984,3 +996,8 @@ out_unlock: · 79 unmodified lines | ||
| 984 | 996 | ttm_read_unlock(&vmaster->lock); |
| 985 | 997 | return ret; |
| 986 | 998 | } |
| 999 | + | |
| 1000 | +u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc) | |
| 1001 | +{ | |
| 1002 | + return 0; | |
| 1003 | +} | |
| @@ -27,6 +27,8 @@ · 26 unmodified lines | ||
| 27 | 27 | |
| 28 | 28 | #include "vmwgfx_kms.h" |
| 29 | 29 | |
| 30 | +#define VMWGFX_LDU_NUM_DU 8 | |
| 31 | + | |
| 30 | 32 | #define vmw_crtc_to_ldu(x) \ |
| 31 | 33 | container_of(x, struct vmw_legacy_display_unit, base.crtc) |
| 32 | 34 | #define vmw_encoder_to_ldu(x) \ |
| @@ -536,6 +538,10 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit) · 503 unmodified lines | ||
| 536 | 538 | |
| 537 | 539 | int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv) |
| 538 | 540 | { |
| 541 | + struct drm_device *dev = dev_priv->dev; | |
| 542 | + int i; | |
| 543 | + int ret; | |
| 544 | + | |
| 539 | 545 | if (dev_priv->ldu_priv) { |
| 540 | 546 | DRM_INFO("ldu system already on\n"); |
| 541 | 547 | return -EINVAL; |
| @@ -553,23 +559,24 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv) · 11 unmodified lines | ||
| 553 | 559 | |
| 554 | 560 | drm_mode_create_dirty_info_property(dev_priv->dev); |
| 555 | 561 | |
| 556 | − vmw_ldu_init(dev_priv, 0); | |
| 557 | − /* for old hardware without multimon only enable one display */ | |
| 558 | 562 | if (dev_priv->capabilities & SVGA_CAP_MULTIMON) { |
| 559 | − vmw_ldu_init(dev_priv, 1); | |
| 560 | − vmw_ldu_init(dev_priv, 2); | |
| 561 | − vmw_ldu_init(dev_priv, 3); | |
| 562 | − vmw_ldu_init(dev_priv, 4); | |
| 563 | − vmw_ldu_init(dev_priv, 5); | |
| 564 | − vmw_ldu_init(dev_priv, 6); | |
| 565 | − vmw_ldu_init(dev_priv, 7); | |
| 563 | + for (i = 0; i < VMWGFX_LDU_NUM_DU; ++i) | |
| 564 | + vmw_ldu_init(dev_priv, i); | |
| 565 | + ret = drm_vblank_init(dev, VMWGFX_LDU_NUM_DU); | |
| 566 | + } else { | |
| 567 | + /* for old hardware without multimon only enable one display */ | |
| 568 | + vmw_ldu_init(dev_priv, 0); | |
| 569 | + ret = drm_vblank_init(dev, 1); | |
| 566 | 570 | } |
| 567 | 571 | |
| 568 | − return 0; | |
| 572 | + return ret; | |
| 569 | 573 | } |
| 570 | 574 | |
| 571 | 575 | int vmw_kms_close_legacy_display_system(struct vmw_private *dev_priv) |
| 572 | 576 | { |
| 577 | + struct drm_device *dev = dev_priv->dev; | |
| 578 | + | |
| 579 | + drm_vblank_cleanup(dev); | |
| 573 | 580 | if (!dev_priv->ldu_priv) |
| 574 | 581 | return -ENOSYS; |
| 575 | 582 | |
| @@ -211,6 +211,7 @@ static void vmw_hw_context_destroy(struct vmw_resource *res) · 210 unmodified lines | ||
| 211 | 211 | cmd->body.cid = cpu_to_le32(res->id); |
| 212 | 212 | |
| 213 | 213 | vmw_fifo_commit(dev_priv, sizeof(*cmd)); |
| 214 | + vmw_3d_resource_dec(dev_priv); | |
| 214 | 215 | } |
| 215 | 216 | |
| 216 | 217 | static int vmw_context_init(struct vmw_private *dev_priv, |
| @@ -247,6 +248,7 @@ static int vmw_context_init(struct vmw_private *dev_priv, · 30 unmodified lines | ||
| 247 | 248 | cmd->body.cid = cpu_to_le32(res->id); |
| 248 | 249 | |
| 249 | 250 | vmw_fifo_commit(dev_priv, sizeof(*cmd)); |
| 251 | + (void) vmw_3d_resource_inc(dev_priv); | |
| 250 | 252 | vmw_resource_activate(res, vmw_hw_context_destroy); |
| 251 | 253 | return 0; |
| 252 | 254 | } |
| @@ -406,6 +408,7 @@ static void vmw_hw_surface_destroy(struct vmw_resource *res) · 153 unmodified lines | ||
| 406 | 408 | cmd->body.sid = cpu_to_le32(res->id); |
| 407 | 409 | |
| 408 | 410 | vmw_fifo_commit(dev_priv, sizeof(*cmd)); |
| 411 | + vmw_3d_resource_dec(dev_priv); | |
| 409 | 412 | } |
| 410 | 413 | |
| 411 | 414 | void vmw_surface_res_free(struct vmw_resource *res) |
| @@ -473,6 +476,7 @@ int vmw_surface_init(struct vmw_private *dev_priv, · 61 unmodified lines | ||
| 473 | 476 | } |
| 474 | 477 | |
| 475 | 478 | vmw_fifo_commit(dev_priv, submit_size); |
| 479 | + (void) vmw_3d_resource_inc(dev_priv); | |
| 476 | 480 | vmw_resource_activate(res, vmw_hw_surface_destroy); |
| 477 | 481 | return 0; |
| 478 | 482 | } |
| @@ -598,7 +598,7 @@ static inline void vga_update_device_decodes(struct vga_device *vgadev, · 597 unmodified lines | ||
| 598 | 598 | pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count); |
| 599 | 599 | } |
| 600 | 600 | |
| 601 | −void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace) | |
| 601 | +static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace) | |
| 602 | 602 | { |
| 603 | 603 | struct vga_device *vgadev; |
| 604 | 604 | unsigned long flags; |
| @@ -409,7 +409,7 @@ config SENSORS_CORETEMP · 408 unmodified lines | ||
| 409 | 409 | |
| 410 | 410 | config SENSORS_PKGTEMP |
| 411 | 411 | tristate "Intel processor package temperature sensor" |
| 412 | − depends on X86 && PCI && EXPERIMENTAL | |
| 412 | + depends on X86 && EXPERIMENTAL | |
| 413 | 413 | help |
| 414 | 414 | If you say yes here you get support for the package level temperature |
| 415 | 415 | sensor inside your CPU. Check documentation/driver for details. |
| @@ -36,6 +36,7 @@ · 35 unmodified lines | ||
| 36 | 36 | #include <linux/pci.h> |
| 37 | 37 | #include <asm/msr.h> |
| 38 | 38 | #include <asm/processor.h> |
| 39 | +#include <asm/smp.h> | |
| 39 | 40 | |
| 40 | 41 | #define DRVNAME "coretemp" |
| 41 | 42 | |
| @@ -423,9 +424,18 @@ static int __cpuinit coretemp_device_add(unsigned int cpu) · 381 unmodified lines | ||
| 423 | 424 | int err; |
| 424 | 425 | struct platform_device *pdev; |
| 425 | 426 | struct pdev_entry *pdev_entry; |
| 426 | −#ifdef CONFIG_SMP | |
| 427 | 427 | struct cpuinfo_x86 *c = &cpu_data(cpu); |
| 428 | −#endif | |
| 428 | + | |
| 429 | + /* | |
| 430 | + * CPUID.06H.EAX[0] indicates whether the CPU has thermal | |
| 431 | + * sensors. We check this bit only, all the early CPUs | |
| 432 | + * without thermal sensors will be filtered out. | |
| 433 | + */ | |
| 434 | + if (!cpu_has(c, X86_FEATURE_DTS)) { | |
| 435 | + printk(KERN_INFO DRVNAME ": CPU (model=0x%x)" | |
| 436 | + " has no thermal sensor.\n", c->x86_model); | |
| 437 | + return 0; | |
| 438 | + } | |
| 429 | 439 | |
| 430 | 440 | mutex_lock(&pdev_list_mutex); |
| 431 | 441 | |
| @@ -482,14 +492,22 @@ exit: · 50 unmodified lines | ||
| 482 | 492 | |
| 483 | 493 | static void coretemp_device_remove(unsigned int cpu) |
| 484 | 494 | { |
| 485 | − struct pdev_entry *p, *n; | |
| 495 | + struct pdev_entry *p; | |
| 496 | + unsigned int i; | |
| 497 | + | |
| 486 | 498 | mutex_lock(&pdev_list_mutex); |
| 487 | − list_for_each_entry_safe(p, n, &pdev_list, list) { | |
| 488 | − if (p->cpu == cpu) { | |
| 489 | − platform_device_unregister(p->pdev); | |
| 490 | − list_del(&p->list); | |
| 491 | − kfree(p); | |
| 492 | − } | |
| 499 | + list_for_each_entry(p, &pdev_list, list) { | |
| 500 | + if (p->cpu != cpu) | |
| 501 | + continue; | |
| 502 | + | |
| 503 | + platform_device_unregister(p->pdev); | |
| 504 | + list_del(&p->list); | |
| 505 | + mutex_unlock(&pdev_list_mutex); | |
| 506 | + kfree(p); | |
| 507 | + for_each_cpu(i, cpu_sibling_mask(cpu)) | |
| 508 | + if (i != cpu && !coretemp_device_add(i)) | |
| 509 | + break; | |
| 510 | + return; | |
| 493 | 511 | } |
| 494 | 512 | mutex_unlock(&pdev_list_mutex); |
| 495 | 513 | } |
| @@ -527,30 +545,21 @@ static int __init coretemp_init(void) · 31 unmodified lines | ||
| 527 | 545 | if (err) |
| 528 | 546 | goto exit; |
| 529 | 547 | |
| 530 | − for_each_online_cpu(i) { | |
| 531 | − struct cpuinfo_x86 *c = &cpu_data(i); | |
| 532 | − /* | |
| 533 | − * CPUID.06H.EAX[0] indicates whether the CPU has thermal | |
| 534 | − * sensors. We check this bit only, all the early CPUs | |
| 535 | − * without thermal sensors will be filtered out. | |
| 536 | − */ | |
| 537 | − if (c->cpuid_level >= 6 && (cpuid_eax(0x06) & 0x01)) | |
| 538 | − coretemp_device_add(i); | |
| 539 | − else { | |
| 540 | − printk(KERN_INFO DRVNAME ": CPU (model=0x%x)" | |
| 541 | − " has no thermal sensor.\n", c->x86_model); | |
| 542 | − } | |
| 543 | − } | |
| 548 | + for_each_online_cpu(i) | |
| 549 | + coretemp_device_add(i); | |
| 550 | + | |
| 551 | +#ifndef CONFIG_HOTPLUG_CPU | |
| 544 | 552 | if (list_empty(&pdev_list)) { |
| 545 | 553 | err = -ENODEV; |
| 546 | 554 | goto exit_driver_unreg; |
| 547 | 555 | } |
| 556 | +#endif | |
| 548 | 557 | |
| 549 | 558 | register_hotcpu_notifier(&coretemp_cpu_notifier); |
| 550 | 559 | return 0; |
| 551 | 560 | |
| 552 | −exit_driver_unreg: | |
| 553 | 561 | #ifndef CONFIG_HOTPLUG_CPU |
| 562 | +exit_driver_unreg: | |
| 554 | 563 | platform_driver_unregister(&coretemp_driver); |
| 555 | 564 | #endif |
| 556 | 565 | exit: |
| @@ -111,7 +111,7 @@ static struct platform_device *f71882fg_pdev; · 110 unmodified lines | ||
| 111 | 111 | /* Super-I/O Function prototypes */ |
| 112 | 112 | static inline int superio_inb(int base, int reg); |
| 113 | 113 | static inline int superio_inw(int base, int reg); |
| 114 | −static inline void superio_enter(int base); | |
| 114 | +static inline int superio_enter(int base); | |
| 115 | 115 | static inline void superio_select(int base, int ld); |
| 116 | 116 | static inline void superio_exit(int base); |
| 117 | 117 | |
| @@ -861,11 +861,20 @@ static int superio_inw(int base, int reg) · 743 unmodified lines | ||
| 861 | 861 | return val; |
| 862 | 862 | } |
| 863 | 863 | |
| 864 | −static inline void superio_enter(int base) | |
| 864 | +static inline int superio_enter(int base) | |
| 865 | 865 | { |
| 866 | + /* Don't step on other drivers' I/O space by accident */ | |
| 867 | + if (!request_muxed_region(base, 2, DRVNAME)) { | |
| 868 | + printk(KERN_ERR DRVNAME ": I/O address 0x%04x already in use\n", | |
| 869 | + base); | |
| 870 | + return -EBUSY; | |
| 871 | + } | |
| 872 | + | |
| 866 | 873 | /* according to the datasheet the key must be send twice! */ |
| 867 | 874 | outb(SIO_UNLOCK_KEY, base); |
| 868 | 875 | outb(SIO_UNLOCK_KEY, base); |
| 876 | + | |
| 877 | + return 0; | |
| 869 | 878 | } |
| 870 | 879 | |
| 871 | 880 | static inline void superio_select(int base, int ld) |
| @@ -877,6 +886,7 @@ static inline void superio_select(int base, int ld) · 5 unmodified lines | ||
| 877 | 886 | static inline void superio_exit(int base) |
| 878 | 887 | { |
| 879 | 888 | outb(SIO_LOCK_KEY, base); |
| 889 | + release_region(base, 2); | |
| 880 | 890 | } |
| 881 | 891 | |
| 882 | 892 | static inline int fan_from_reg(u16 reg) |
| @@ -2175,21 +2185,15 @@ static int f71882fg_remove(struct platform_device *pdev) · 1292 unmodified lines | ||
| 2175 | 2185 | static int __init f71882fg_find(int sioaddr, unsigned short *address, |
| 2176 | 2186 | struct f71882fg_sio_data *sio_data) |
| 2177 | 2187 | { |
| 2178 | − int err = -ENODEV; | |
| 2179 | 2188 | u16 devid; |
| 2180 | − | |
| 2181 | − /* Don't step on other drivers' I/O space by accident */ | |
| 2182 | − if (!request_region(sioaddr, 2, DRVNAME)) { | |
| 2183 | − printk(KERN_ERR DRVNAME ": I/O address 0x%04x already in use\n", | |
| 2184 | − (int)sioaddr); | |
| 2185 | − return -EBUSY; | |
| 2186 | − } | |
| 2187 | − | |
| 2188 | − superio_enter(sioaddr); | |
| 2189 | + int err = superio_enter(sioaddr); | |
| 2190 | + if (err) | |
| 2191 | + return err; | |
| 2189 | 2192 | |
| 2190 | 2193 | devid = superio_inw(sioaddr, SIO_REG_MANID); |
| 2191 | 2194 | if (devid != SIO_FINTEK_ID) { |
| 2192 | 2195 | pr_debug(DRVNAME ": Not a Fintek device\n"); |
| 2196 | + err = -ENODEV; | |
| 2193 | 2197 | goto exit; |
| 2194 | 2198 | } |
| 2195 | 2199 | |
| @@ -2213,6 +2217,7 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address, · 17 unmodified lines | ||
| 2213 | 2217 | default: |
| 2214 | 2218 | printk(KERN_INFO DRVNAME ": Unsupported Fintek device: %04x\n", |
| 2215 | 2219 | (unsigned int)devid); |
| 2220 | + err = -ENODEV; | |
| 2216 | 2221 | goto exit; |
| 2217 | 2222 | } |
| 2218 | 2223 | |
| @@ -2223,12 +2228,14 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address, · 4 unmodified lines | ||
| 2223 | 2228 | |
| 2224 | 2229 | if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) { |
| 2225 | 2230 | printk(KERN_WARNING DRVNAME ": Device not activated\n"); |
| 2231 | + err = -ENODEV; | |
| 2226 | 2232 | goto exit; |
| 2227 | 2233 | } |
| 2228 | 2234 | |
| 2229 | 2235 | *address = superio_inw(sioaddr, SIO_REG_ADDR); |
| 2230 | 2236 | if (*address == 0) { |
| 2231 | 2237 | printk(KERN_WARNING DRVNAME ": Base address not set\n"); |
| 2238 | + err = -ENODEV; | |
| 2232 | 2239 | goto exit; |
| 2233 | 2240 | } |
| 2234 | 2241 | *address &= ~(REGION_LENGTH - 1); /* Ignore 3 LSB */ |
| @@ -2239,7 +2246,6 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address, · 4 unmodified lines | ||
| 2239 | 2246 | (int)superio_inb(sioaddr, SIO_REG_DEVREV)); |
| 2240 | 2247 | exit: |
| 2241 | 2248 | superio_exit(sioaddr); |
| 2242 | − release_region(sioaddr, 2); | |
| 2243 | 2249 | return err; |
| 2244 | 2250 | } |
| 2245 | 2251 | |
| @@ -277,7 +277,7 @@ static irqreturn_t lis302dl_interrupt(int irq, void *dummy) · 276 unmodified lines | ||
| 277 | 277 | wake_up_interruptible(&lis3_dev.misc_wait); |
| 278 | 278 | kill_fasync(&lis3_dev.async_queue, SIGIO, POLL_IN); |
| 279 | 279 | out: |
| 280 | − if (lis3_dev.whoami == WAI_8B && lis3_dev.idev && | |
| 280 | + if (lis3_dev.pdata && lis3_dev.whoami == WAI_8B && lis3_dev.idev && | |
| 281 | 281 | lis3_dev.idev->input->users) |
| 282 | 282 | return IRQ_WAKE_THREAD; |
| 283 | 283 | return IRQ_HANDLED; |
| @@ -718,7 +718,7 @@ int lis3lv02d_init_device(struct lis3lv02d *dev) · 434 unmodified lines | ||
| 718 | 718 | * io-apic is not configurable (and generates a warning) but I keep it |
| 719 | 719 | * in case of support for other hardware. |
| 720 | 720 | */ |
| 721 | − if (dev->whoami == WAI_8B) | |
| 721 | + if (dev->pdata && dev->whoami == WAI_8B) | |
| 722 | 722 | thread_fn = lis302dl_interrupt_thread1_8b; |
| 723 | 723 | else |
| 724 | 724 | thread_fn = NULL; |
| @@ -33,7 +33,6 @@ · 32 unmodified lines | ||
| 33 | 33 | #include <linux/list.h> |
| 34 | 34 | #include <linux/platform_device.h> |
| 35 | 35 | #include <linux/cpu.h> |
| 36 | −#include <linux/pci.h> | |
| 37 | 36 | #include <asm/msr.h> |
| 38 | 37 | #include <asm/processor.h> |
| 39 | 38 | |
| @@ -224,7 +223,7 @@ static int __devinit pkgtemp_probe(struct platform_device *pdev) · 184 unmodified lines | ||
| 224 | 223 | |
| 225 | 224 | err = sysfs_create_group(&pdev->dev.kobj, &pkgtemp_group); |
| 226 | 225 | if (err) |
| 227 | − goto exit_free; | |
| 226 | + goto exit_dev; | |
| 228 | 227 | |
| 229 | 228 | data->hwmon_dev = hwmon_device_register(&pdev->dev); |
| 230 | 229 | if (IS_ERR(data->hwmon_dev)) { |
| @@ -238,6 +237,8 @@ static int __devinit pkgtemp_probe(struct platform_device *pdev) · 7 unmodified lines | ||
| 238 | 237 | |
| 239 | 238 | exit_class: |
| 240 | 239 | sysfs_remove_group(&pdev->dev.kobj, &pkgtemp_group); |
| 240 | +exit_dev: | |
| 241 | + device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr); | |
| 241 | 242 | exit_free: |
| 242 | 243 | kfree(data); |
| 243 | 244 | exit: |
| @@ -250,6 +251,7 @@ static int __devexit pkgtemp_remove(struct platform_device *pdev) · 6 unmodified lines | ||
| 250 | 251 | |
| 251 | 252 | hwmon_device_unregister(data->hwmon_dev); |
| 252 | 253 | sysfs_remove_group(&pdev->dev.kobj, &pkgtemp_group); |
| 254 | + device_remove_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr); | |
| 253 | 255 | platform_set_drvdata(pdev, NULL); |
| 254 | 256 | kfree(data); |
| 255 | 257 | return 0; |
| @@ -281,9 +283,10 @@ static int __cpuinit pkgtemp_device_add(unsigned int cpu) · 25 unmodified lines | ||
| 281 | 283 | int err; |
| 282 | 284 | struct platform_device *pdev; |
| 283 | 285 | struct pdev_entry *pdev_entry; |
| 284 | −#ifdef CONFIG_SMP | |
| 285 | 286 | struct cpuinfo_x86 *c = &cpu_data(cpu); |
| 286 | −#endif | |
| 287 | + | |
| 288 | + if (!cpu_has(c, X86_FEATURE_PTS)) | |
| 289 | + return 0; | |
| 287 | 290 | |
| 288 | 291 | mutex_lock(&pdev_list_mutex); |
| 289 | 292 | |
| @@ -339,17 +342,18 @@ exit: · 49 unmodified lines | ||
| 339 | 342 | #ifdef CONFIG_HOTPLUG_CPU |
| 340 | 343 | static void pkgtemp_device_remove(unsigned int cpu) |
| 341 | 344 | { |
| 342 | − struct pdev_entry *p, *n; | |
| 345 | + struct pdev_entry *p; | |
| 343 | 346 | unsigned int i; |
| 344 | 347 | int err; |
| 345 | 348 | |
| 346 | 349 | mutex_lock(&pdev_list_mutex); |
| 347 | − list_for_each_entry_safe(p, n, &pdev_list, list) { | |
| 350 | + list_for_each_entry(p, &pdev_list, list) { | |
| 348 | 351 | if (p->cpu != cpu) |
| 349 | 352 | continue; |
| 350 | 353 | |
| 351 | 354 | platform_device_unregister(p->pdev); |
| 352 | 355 | list_del(&p->list); |
| 356 | + mutex_unlock(&pdev_list_mutex); | |
| 353 | 357 | kfree(p); |
| 354 | 358 | for_each_cpu(i, cpu_core_mask(cpu)) { |
| 355 | 359 | if (i != cpu) { |
| @@ -358,7 +362,7 @@ static void pkgtemp_device_remove(unsigned int cpu) · 2 unmodified lines | ||
| 358 | 362 | break; |
| 359 | 363 | } |
| 360 | 364 | } |
| 361 | − break; | |
| 365 | + return; | |
| 362 | 366 | } |
| 363 | 367 | mutex_unlock(&pdev_list_mutex); |
| 364 | 368 | } |
| @@ -399,11 +403,6 @@ static int __init pkgtemp_init(void) · 34 unmodified lines | ||
| 399 | 403 | goto exit; |
| 400 | 404 | |
| 401 | 405 | for_each_online_cpu(i) { |
| 402 | − struct cpuinfo_x86 *c = &cpu_data(i); | |
| 403 | − | |
| 404 | − if (!cpu_has(c, X86_FEATURE_PTS)) | |
| 405 | − continue; | |
| 406 | − | |
| 407 | 406 | err = pkgtemp_device_add(i); |
| 408 | 407 | if (err) |
| 409 | 408 | goto exit_devices_unreg; |
| @@ -357,9 +357,6 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop) · 356 unmodified lines | ||
| 357 | 357 | |
| 358 | 358 | dev->terminate = 0; |
| 359 | 359 | |
| 360 | − /* write the data into mode register */ | |
| 361 | − davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag); | |
| 362 | − | |
| 363 | 360 | /* |
| 364 | 361 | * First byte should be set here, not after interrupt, |
| 365 | 362 | * because transmit-data-ready interrupt can come before |
| @@ -371,6 +368,9 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop) · 5 unmodified lines | ||
| 371 | 368 | dev->buf_len--; |
| 372 | 369 | } |
| 373 | 370 | |
| 371 | + /* write the data into mode register; start transmitting */ | |
| 372 | + davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag); | |
| 373 | + | |
| 374 | 374 | r = wait_for_completion_interruptible_timeout(&dev->cmd_complete, |
| 375 | 375 | dev->adapter.timeout); |
| 376 | 376 | if (r == 0) { |
| @@ -218,7 +218,7 @@ static int octeon_i2c_wait(struct octeon_i2c *i2c) · 217 unmodified lines | ||
| 218 | 218 | return result; |
| 219 | 219 | } else if (result == 0) { |
| 220 | 220 | dev_dbg(i2c->dev, "%s: timeout\n", __func__); |
| 221 | − result = -ETIMEDOUT; | |
| 221 | + return -ETIMEDOUT; | |
| 222 | 222 | } |
| 223 | 223 | |
| 224 | 224 | return 0; |
| @@ -662,8 +662,8 @@ static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got) · 661 unmodified lines | ||
| 662 | 662 | unsigned long sda_delay; |
| 663 | 663 | |
| 664 | 664 | if (pdata->sda_delay) { |
| 665 | − sda_delay = (freq / 1000) * pdata->sda_delay; | |
| 666 | − sda_delay /= 1000000; | |
| 665 | + sda_delay = clkin * pdata->sda_delay; | |
| 666 | + sda_delay = DIV_ROUND_UP(sda_delay, 1000000); | |
| 667 | 667 | sda_delay = DIV_ROUND_UP(sda_delay, 5); |
| 668 | 668 | if (sda_delay > 3) |
| 669 | 669 | sda_delay = 3; |
| @@ -83,7 +83,7 @@ static unsigned int mwait_substates; · 82 unmodified lines | ||
| 83 | 83 | /* Reliable LAPIC Timer States, bit 1 for C1 etc. */ |
| 84 | 84 | static unsigned int lapic_timer_reliable_states; |
| 85 | 85 | |
| 86 | −static struct cpuidle_device *intel_idle_cpuidle_devices; | |
| 86 | +static struct cpuidle_device __percpu *intel_idle_cpuidle_devices; | |
| 87 | 87 | static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state); |
| 88 | 88 | |
| 89 | 89 | static struct cpuidle_state *cpuidle_state_table; |
| @@ -108,7 +108,7 @@ static struct cpuidle_state nehalem_cstates[MWAIT_MAX_NUM_CSTATES] = { · 18 unmodified lines | ||
| 108 | 108 | .name = "NHM-C3", |
| 109 | 109 | .desc = "MWAIT 0x10", |
| 110 | 110 | .driver_data = (void *) 0x10, |
| 111 | − .flags = CPUIDLE_FLAG_TIME_VALID, | |
| 111 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED, | |
| 112 | 112 | .exit_latency = 20, |
| 113 | 113 | .power_usage = 500, |
| 114 | 114 | .target_residency = 80, |
| @@ -117,7 +117,7 @@ static struct cpuidle_state nehalem_cstates[MWAIT_MAX_NUM_CSTATES] = { · 2 unmodified lines | ||
| 117 | 117 | .name = "NHM-C6", |
| 118 | 118 | .desc = "MWAIT 0x20", |
| 119 | 119 | .driver_data = (void *) 0x20, |
| 120 | − .flags = CPUIDLE_FLAG_TIME_VALID, | |
| 120 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED, | |
| 121 | 121 | .exit_latency = 200, |
| 122 | 122 | .power_usage = 350, |
| 123 | 123 | .target_residency = 800, |
| @@ -149,7 +149,7 @@ static struct cpuidle_state atom_cstates[MWAIT_MAX_NUM_CSTATES] = { · 25 unmodified lines | ||
| 149 | 149 | .name = "ATM-C4", |
| 150 | 150 | .desc = "MWAIT 0x30", |
| 151 | 151 | .driver_data = (void *) 0x30, |
| 152 | − .flags = CPUIDLE_FLAG_TIME_VALID, | |
| 152 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED, | |
| 153 | 153 | .exit_latency = 100, |
| 154 | 154 | .power_usage = 250, |
| 155 | 155 | .target_residency = 400, |
| @@ -159,7 +159,7 @@ static struct cpuidle_state atom_cstates[MWAIT_MAX_NUM_CSTATES] = { · 3 unmodified lines | ||
| 159 | 159 | .name = "ATM-C6", |
| 160 | 160 | .desc = "MWAIT 0x40", |
| 161 | 161 | .driver_data = (void *) 0x40, |
| 162 | − .flags = CPUIDLE_FLAG_TIME_VALID, | |
| 162 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED, | |
| 163 | 163 | .exit_latency = 200, |
| 164 | 164 | .power_usage = 150, |
| 165 | 165 | .target_residency = 800, |
| @@ -185,6 +185,16 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state) · 19 unmodified lines | ||
| 185 | 185 | |
| 186 | 186 | local_irq_disable(); |
| 187 | 187 | |
| 188 | + /* | |
| 189 | + * If the state flag indicates that the TLB will be flushed or if this | |
| 190 | + * is the deepest c-state supported, do a voluntary leave mm to avoid | |
| 191 | + * costly and mostly unnecessary wakeups for flushing the user TLB's | |
| 192 | + * associated with the active mm. | |
| 193 | + */ | |
| 194 | + if (state->flags & CPUIDLE_FLAG_TLB_FLUSHED || | |
| 195 | + (&dev->states[dev->state_count - 1] == state)) | |
| 196 | + leave_mm(cpu); | |
| 197 | + | |
| 188 | 198 | if (!(lapic_timer_reliable_states & (1 << (cstate)))) |
| 189 | 199 | clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu); |
| 190 | 200 | |
| @@ -463,7 +463,8 @@ static int send_connect(struct iwch_ep *ep) · 462 unmodified lines | ||
| 463 | 463 | V_MSS_IDX(mtu_idx) | |
| 464 | 464 | V_L2T_IDX(ep->l2t->idx) | V_TX_CHANNEL(ep->l2t->smt_idx); |
| 465 | 465 | opt0l = V_TOS((ep->tos >> 2) & M_TOS) | V_RCV_BUFSIZ(rcv_win>>10); |
| 466 | − opt2 = V_FLAVORS_VALID(1) | V_CONG_CONTROL_FLAVOR(cong_flavor); | |
| 466 | + opt2 = F_RX_COALESCE_VALID | V_RX_COALESCE(0) | V_FLAVORS_VALID(1) | | |
| 467 | + V_CONG_CONTROL_FLAVOR(cong_flavor); | |
| 467 | 468 | skb->priority = CPL_PRIORITY_SETUP; |
| 468 | 469 | set_arp_failure_handler(skb, act_open_req_arp_failure); |
| 469 | 470 | |
| @@ -1280,7 +1281,8 @@ static void accept_cr(struct iwch_ep *ep, __be32 peer_ip, struct sk_buff *skb) · 810 unmodified lines | ||
| 1280 | 1281 | V_MSS_IDX(mtu_idx) | |
| 1281 | 1282 | V_L2T_IDX(ep->l2t->idx) | V_TX_CHANNEL(ep->l2t->smt_idx); |
| 1282 | 1283 | opt0l = V_TOS((ep->tos >> 2) & M_TOS) | V_RCV_BUFSIZ(rcv_win>>10); |
| 1283 | − opt2 = V_FLAVORS_VALID(1) | V_CONG_CONTROL_FLAVOR(cong_flavor); | |
| 1284 | + opt2 = F_RX_COALESCE_VALID | V_RX_COALESCE(0) | V_FLAVORS_VALID(1) | | |
| 1285 | + V_CONG_CONTROL_FLAVOR(cong_flavor); | |
| 1284 | 1286 | |
| 1285 | 1287 | rpl = cplhdr(skb); |
| 1286 | 1288 | rpl->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); |
| @@ -81,7 +81,7 @@ static int ns2_led_get_mode(struct ns2_led_data *led_dat, · 80 unmodified lines | ||
| 81 | 81 | int cmd_level; |
| 82 | 82 | int slow_level; |
| 83 | 83 | |
| 84 | − read_lock(&led_dat->rw_lock); | |
| 84 | + read_lock_irq(&led_dat->rw_lock); | |
| 85 | 85 | |
| 86 | 86 | cmd_level = gpio_get_value(led_dat->cmd); |
| 87 | 87 | slow_level = gpio_get_value(led_dat->slow); |
| @@ -95,7 +95,7 @@ static int ns2_led_get_mode(struct ns2_led_data *led_dat, · 7 unmodified lines | ||
| 95 | 95 | } |
| 96 | 96 | } |
| 97 | 97 | |
| 98 | − read_unlock(&led_dat->rw_lock); | |
| 98 | + read_unlock_irq(&led_dat->rw_lock); | |
| 99 | 99 | |
| 100 | 100 | return ret; |
| 101 | 101 | } |
| @@ -104,8 +104,9 @@ static void ns2_led_set_mode(struct ns2_led_data *led_dat, · 2 unmodified lines | ||
| 104 | 104 | enum ns2_led_modes mode) |
| 105 | 105 | { |
| 106 | 106 | int i; |
| 107 | + unsigned long flags; | |
| 107 | 108 | |
| 108 | − write_lock(&led_dat->rw_lock); | |
| 109 | + write_lock_irqsave(&led_dat->rw_lock, flags); | |
| 109 | 110 | |
| 110 | 111 | for (i = 0; i < ARRAY_SIZE(ns2_led_modval); i++) { |
| 111 | 112 | if (mode == ns2_led_modval[i].mode) { |
| @@ -116,7 +117,7 @@ static void ns2_led_set_mode(struct ns2_led_data *led_dat, · 4 unmodified lines | ||
| 116 | 117 | } |
| 117 | 118 | } |
| 118 | 119 | |
| 119 | − write_unlock(&led_dat->rw_lock); | |
| 120 | + write_unlock_irqrestore(&led_dat->rw_lock, flags); | |
| 120 | 121 | } |
| 121 | 122 | |
| 122 | 123 | static void ns2_led_set(struct led_classdev *led_cdev, |
| @@ -429,24 +429,25 @@ static void max8925_irq_sync_unlock(unsigned int irq) · 428 unmodified lines | ||
| 429 | 429 | irq_tsc = cache_tsc; |
| 430 | 430 | for (i = 0; i < ARRAY_SIZE(max8925_irqs); i++) { |
| 431 | 431 | irq_data = &max8925_irqs[i]; |
| 432 | + /* 1 -- disable, 0 -- enable */ | |
| 432 | 433 | switch (irq_data->mask_reg) { |
| 433 | 434 | case MAX8925_CHG_IRQ1_MASK: |
| 434 | − irq_chg[0] &= irq_data->enable; | |
| 435 | + irq_chg[0] &= ~irq_data->enable; | |
| 435 | 436 | break; |
| 436 | 437 | case MAX8925_CHG_IRQ2_MASK: |
| 437 | − irq_chg[1] &= irq_data->enable; | |
| 438 | + irq_chg[1] &= ~irq_data->enable; | |
| 438 | 439 | break; |
| 439 | 440 | case MAX8925_ON_OFF_IRQ1_MASK: |
| 440 | − irq_on[0] &= irq_data->enable; | |
| 441 | + irq_on[0] &= ~irq_data->enable; | |
| 441 | 442 | break; |
| 442 | 443 | case MAX8925_ON_OFF_IRQ2_MASK: |
| 443 | − irq_on[1] &= irq_data->enable; | |
| 444 | + irq_on[1] &= ~irq_data->enable; | |
| 444 | 445 | break; |
| 445 | 446 | case MAX8925_RTC_IRQ_MASK: |
| 446 | − irq_rtc &= irq_data->enable; | |
| 447 | + irq_rtc &= ~irq_data->enable; | |
| 447 | 448 | break; |
| 448 | 449 | case MAX8925_TSC_IRQ_MASK: |
| 449 | − irq_tsc &= irq_data->enable; | |
| 450 | + irq_tsc &= ~irq_data->enable; | |
| 450 | 451 | break; |
| 451 | 452 | default: |
| 452 | 453 | dev_err(chip->dev, "wrong IRQ\n"); |
| @@ -394,8 +394,13 @@ static int wm831x_irq_set_type(unsigned int irq, unsigned int type) · 393 unmodified lines | ||
| 394 | 394 | |
| 395 | 395 | irq = irq - wm831x->irq_base; |
| 396 | 396 | |
| 397 | − if (irq < WM831X_IRQ_GPIO_1 || irq > WM831X_IRQ_GPIO_11) | |
| 398 | − return -EINVAL; | |
| 397 | + if (irq < WM831X_IRQ_GPIO_1 || irq > WM831X_IRQ_GPIO_11) { | |
| 398 | + /* Ignore internal-only IRQs */ | |
| 399 | + if (irq >= 0 && irq < WM831X_NUM_IRQS) | |
| 400 | + return 0; | |
| 401 | + else | |
| 402 | + return -EINVAL; | |
| 403 | + } | |
| 399 | 404 | |
| 400 | 405 | switch (type) { |
| 401 | 406 | case IRQ_TYPE_EDGE_BOTH: |
| @@ -368,7 +368,7 @@ config VMWARE_BALLOON · 367 unmodified lines | ||
| 368 | 368 | If unsure, say N. |
| 369 | 369 | |
| 370 | 370 | To compile this driver as a module, choose M here: the |
| 371 | − module will be called vmware_balloon. | |
| 371 | + module will be called vmw_balloon. | |
| 372 | 372 | |
| 373 | 373 | config ARM_CHARLCD |
| 374 | 374 | bool "ARM Ltd. Character LCD Driver" |
| @@ -33,5 +33,5 @@ obj-$(CONFIG_IWMC3200TOP) += iwmc3200top/ · 32 unmodified lines | ||
| 33 | 33 | obj-$(CONFIG_HMC6352) += hmc6352.o |
| 34 | 34 | obj-y += eeprom/ |
| 35 | 35 | obj-y += cb710/ |
| 36 | −obj-$(CONFIG_VMWARE_BALLOON) += vmware_balloon.o | |
| 36 | +obj-$(CONFIG_VMWARE_BALLOON) += vmw_balloon.o | |
| 37 | 37 | obj-$(CONFIG_ARM_CHARLCD) += arm-charlcd.o |
File renamed without changes.
| @@ -241,8 +241,10 @@ static struct sdhci_ops sdhci_s3c_ops = { · 240 unmodified lines | ||
| 241 | 241 | static void sdhci_s3c_notify_change(struct platform_device *dev, int state) |
| 242 | 242 | { |
| 243 | 243 | struct sdhci_host *host = platform_get_drvdata(dev); |
| 244 | + unsigned long flags; | |
| 245 | + | |
| 244 | 246 | if (host) { |
| 245 | − spin_lock(&host->lock); | |
| 247 | + spin_lock_irqsave(&host->lock, flags); | |
| 246 | 248 | if (state) { |
| 247 | 249 | dev_dbg(&dev->dev, "card inserted.\n"); |
| 248 | 250 | host->flags &= ~SDHCI_DEVICE_DEAD; |
| @@ -253,7 +255,7 @@ static void sdhci_s3c_notify_change(struct platform_device *dev, int state) · 4 unmodified lines | ||
| 253 | 255 | host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION; |
| 254 | 256 | } |
| 255 | 257 | tasklet_schedule(&host->card_tasklet); |
| 256 | − spin_unlock(&host->lock); | |
| 258 | + spin_unlock_irqrestore(&host->lock, flags); | |
| 257 | 259 | } |
| 258 | 260 | } |
| 259 | 261 | |
| @@ -481,8 +483,10 @@ static int __devexit sdhci_s3c_remove(struct platform_device *pdev) · 221 unmodified lines | ||
| 481 | 483 | sdhci_remove_host(host, 1); |
| 482 | 484 | |
| 483 | 485 | for (ptr = 0; ptr < 3; ptr++) { |
| 484 | − clk_disable(sc->clk_bus[ptr]); | |
| 485 | − clk_put(sc->clk_bus[ptr]); | |
| 486 | + if (sc->clk_bus[ptr]) { | |
| 487 | + clk_disable(sc->clk_bus[ptr]); | |
| 488 | + clk_put(sc->clk_bus[ptr]); | |
| 489 | + } | |
| 486 | 490 | } |
| 487 | 491 | clk_disable(sc->clk_io); |
| 488 | 492 | clk_put(sc->clk_io); |
| @@ -413,7 +413,7 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr, · 412 unmodified lines | ||
| 413 | 413 | prefetch_status = gpmc_read_status(GPMC_PREFETCH_COUNT); |
| 414 | 414 | } while (prefetch_status); |
| 415 | 415 | /* disable and stop the PFPW engine */ |
| 416 | − gpmc_prefetch_reset(); | |
| 416 | + gpmc_prefetch_reset(info->gpmc_cs); | |
| 417 | 417 | |
| 418 | 418 | dma_unmap_single(&info->pdev->dev, dma_addr, len, dir); |
| 419 | 419 | return 0; |
| @@ -2942,6 +2942,9 @@ static void vortex_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) · 2941 unmodified lines | ||
| 2942 | 2942 | { |
| 2943 | 2943 | struct vortex_private *vp = netdev_priv(dev); |
| 2944 | 2944 | |
| 2945 | + if (!VORTEX_PCI(vp)) | |
| 2946 | + return; | |
| 2947 | + | |
| 2945 | 2948 | wol->supported = WAKE_MAGIC; |
| 2946 | 2949 | |
| 2947 | 2950 | wol->wolopts = 0; |
| @@ -2952,6 +2955,10 @@ static void vortex_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) · 4 unmodified lines | ||
| 2952 | 2955 | static int vortex_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) |
| 2953 | 2956 | { |
| 2954 | 2957 | struct vortex_private *vp = netdev_priv(dev); |
| 2958 | + | |
| 2959 | + if (!VORTEX_PCI(vp)) | |
| 2960 | + return -EOPNOTSUPP; | |
| 2961 | + | |
| 2955 | 2962 | if (wol->wolopts & ~WAKE_MAGIC) |
| 2956 | 2963 | return -EINVAL; |
| 2957 | 2964 | |
| @@ -3201,6 +3208,9 @@ static void acpi_set_WOL(struct net_device *dev) · 243 unmodified lines | ||
| 3201 | 3208 | return; |
| 3202 | 3209 | } |
| 3203 | 3210 | |
| 3211 | + if (VORTEX_PCI(vp)->current_state < PCI_D3hot) | |
| 3212 | + return; | |
| 3213 | + | |
| 3204 | 3214 | /* Change the power state to D3; RxEnable doesn't take effect. */ |
| 3205 | 3215 | pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot); |
| 3206 | 3216 | } |
| @@ -1251,6 +1251,12 @@ static void atl1_free_ring_resources(struct atl1_adapter *adapter) · 1250 unmodified lines | ||
| 1251 | 1251 | |
| 1252 | 1252 | rrd_ring->desc = NULL; |
| 1253 | 1253 | rrd_ring->dma = 0; |
| 1254 | + | |
| 1255 | + adapter->cmb.dma = 0; | |
| 1256 | + adapter->cmb.cmb = NULL; | |
| 1257 | + | |
| 1258 | + adapter->smb.dma = 0; | |
| 1259 | + adapter->smb.smb = NULL; | |
| 1254 | 1260 | } |
| 1255 | 1261 | |
| 1256 | 1262 | static void atl1_setup_mac_ctrl(struct atl1_adapter *adapter) |
| @@ -2847,10 +2853,11 @@ static int atl1_resume(struct pci_dev *pdev) · 1590 unmodified lines | ||
| 2847 | 2853 | pci_enable_wake(pdev, PCI_D3cold, 0); |
| 2848 | 2854 | |
| 2849 | 2855 | atl1_reset_hw(&adapter->hw); |
| 2850 | − adapter->cmb.cmb->int_stats = 0; | |
| 2851 | 2856 | |
| 2852 | − if (netif_running(netdev)) | |
| 2857 | + if (netif_running(netdev)) { | |
| 2858 | + adapter->cmb.cmb->int_stats = 0; | |
| 2853 | 2859 | atl1_up(adapter); |
| 2860 | + } | |
| 2854 | 2861 | netif_device_attach(netdev); |
| 2855 | 2862 | |
| 2856 | 2863 | return 0; |
| @@ -57,6 +57,7 @@ enum e1e_registers { · 56 unmodified lines | ||
| 57 | 57 | E1000_SCTL = 0x00024, /* SerDes Control - RW */ |
| 58 | 58 | E1000_FCAL = 0x00028, /* Flow Control Address Low - RW */ |
| 59 | 59 | E1000_FCAH = 0x0002C, /* Flow Control Address High -RW */ |
| 60 | + E1000_FEXTNVM4 = 0x00024, /* Future Extended NVM 4 - RW */ | |
| 60 | 61 | E1000_FEXTNVM = 0x00028, /* Future Extended NVM - RW */ |
| 61 | 62 | E1000_FCT = 0x00030, /* Flow Control Type - RW */ |
| 62 | 63 | E1000_VET = 0x00038, /* VLAN Ether Type - RW */ |
| @@ -105,6 +105,10 @@ · 104 unmodified lines | ||
| 105 | 105 | #define E1000_FEXTNVM_SW_CONFIG 1 |
| 106 | 106 | #define E1000_FEXTNVM_SW_CONFIG_ICH8M (1 << 27) /* Bit redefined for ICH8M :/ */ |
| 107 | 107 | |
| 108 | +#define E1000_FEXTNVM4_BEACON_DURATION_MASK 0x7 | |
| 109 | +#define E1000_FEXTNVM4_BEACON_DURATION_8USEC 0x7 | |
| 110 | +#define E1000_FEXTNVM4_BEACON_DURATION_16USEC 0x3 | |
| 111 | + | |
| 108 | 112 | #define PCIE_ICH8_SNOOP_ALL PCIE_NO_SNOOP_ALL |
| 109 | 113 | |
| 110 | 114 | #define E1000_ICH_RAR_ENTRIES 7 |
| @@ -125,6 +129,7 @@ · 14 unmodified lines | ||
| 125 | 129 | |
| 126 | 130 | /* SMBus Address Phy Register */ |
| 127 | 131 | #define HV_SMB_ADDR PHY_REG(768, 26) |
| 132 | +#define HV_SMB_ADDR_MASK 0x007F | |
| 128 | 133 | #define HV_SMB_ADDR_PEC_EN 0x0200 |
| 129 | 134 | #define HV_SMB_ADDR_VALID 0x0080 |
| 130 | 135 | |
| @@ -237,6 +242,8 @@ static s32 e1000_k1_gig_workaround_hv(struct e1000_hw *hw, bool link); · 106 unmodified lines | ||
| 237 | 242 | static s32 e1000_set_mdio_slow_mode_hv(struct e1000_hw *hw); |
| 238 | 243 | static bool e1000_check_mng_mode_ich8lan(struct e1000_hw *hw); |
| 239 | 244 | static bool e1000_check_mng_mode_pchlan(struct e1000_hw *hw); |
| 245 | +static s32 e1000_k1_workaround_lv(struct e1000_hw *hw); | |
| 246 | +static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate); | |
| 240 | 247 | |
| 241 | 248 | static inline u16 __er16flash(struct e1000_hw *hw, unsigned long reg) |
| 242 | 249 | { |
| @@ -272,7 +279,7 @@ static inline void __ew32flash(struct e1000_hw *hw, unsigned long reg, u32 val) · 29 unmodified lines | ||
| 272 | 279 | static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw) |
| 273 | 280 | { |
| 274 | 281 | struct e1000_phy_info *phy = &hw->phy; |
| 275 | − u32 ctrl; | |
| 282 | + u32 ctrl, fwsm; | |
| 276 | 283 | s32 ret_val = 0; |
| 277 | 284 | |
| 278 | 285 | phy->addr = 1; |
| @@ -294,7 +301,8 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw) · 15 unmodified lines | ||
| 294 | 301 | * disabled, then toggle the LANPHYPC Value bit to force |
| 295 | 302 | * the interconnect to PCIe mode. |
| 296 | 303 | */ |
| 297 | − if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) { | |
| 304 | + fwsm = er32(FWSM); | |
| 305 | + if (!(fwsm & E1000_ICH_FWSM_FW_VALID)) { | |
| 298 | 306 | ctrl = er32(CTRL); |
| 299 | 307 | ctrl |= E1000_CTRL_LANPHYPC_OVERRIDE; |
| 300 | 308 | ctrl &= ~E1000_CTRL_LANPHYPC_VALUE; |
| @@ -303,6 +311,13 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw) · 2 unmodified lines | ||
| 303 | 311 | ctrl &= ~E1000_CTRL_LANPHYPC_OVERRIDE; |
| 304 | 312 | ew32(CTRL, ctrl); |
| 305 | 313 | msleep(50); |
| 314 | + | |
| 315 | + /* | |
| 316 | + * Gate automatic PHY configuration by hardware on | |
| 317 | + * non-managed 82579 | |
| 318 | + */ | |
| 319 | + if (hw->mac.type == e1000_pch2lan) | |
| 320 | + e1000_gate_hw_phy_config_ich8lan(hw, true); | |
| 306 | 321 | } |
| 307 | 322 | |
| 308 | 323 | /* |
| @@ -315,6 +330,13 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw) · 6 unmodified lines | ||
| 315 | 330 | if (ret_val) |
| 316 | 331 | goto out; |
| 317 | 332 | |
| 333 | + /* Ungate automatic PHY configuration on non-managed 82579 */ | |
| 334 | + if ((hw->mac.type == e1000_pch2lan) && | |
| 335 | + !(fwsm & E1000_ICH_FWSM_FW_VALID)) { | |
| 336 | + msleep(10); | |
| 337 | + e1000_gate_hw_phy_config_ich8lan(hw, false); | |
| 338 | + } | |
| 339 | + | |
| 318 | 340 | phy->id = e1000_phy_unknown; |
| 319 | 341 | ret_val = e1000e_get_phy_id(hw); |
| 320 | 342 | if (ret_val) |
| @@ -561,13 +583,10 @@ static s32 e1000_init_mac_params_ich8lan(struct e1000_adapter *adapter) · 240 unmodified lines | ||
| 561 | 583 | if (mac->type == e1000_ich8lan) |
| 562 | 584 | e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw, true); |
| 563 | 585 | |
| 564 | − /* Disable PHY configuration by hardware, config by software */ | |
| 565 | − if (mac->type == e1000_pch2lan) { | |
| 566 | − u32 extcnf_ctrl = er32(EXTCNF_CTRL); | |
| 567 | − | |
| 568 | − extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG; | |
| 569 | − ew32(EXTCNF_CTRL, extcnf_ctrl); | |
| 570 | − } | |
| 586 | + /* Gate automatic PHY configuration by hardware on managed 82579 */ | |
| 587 | + if ((mac->type == e1000_pch2lan) && | |
| 588 | + (er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) | |
| 589 | + e1000_gate_hw_phy_config_ich8lan(hw, true); | |
| 571 | 590 | |
| 572 | 591 | return 0; |
| 573 | 592 | } |
| @@ -652,6 +671,12 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw) · 78 unmodified lines | ||
| 652 | 671 | goto out; |
| 653 | 672 | } |
| 654 | 673 | |
| 674 | + if (hw->mac.type == e1000_pch2lan) { | |
| 675 | + ret_val = e1000_k1_workaround_lv(hw); | |
| 676 | + if (ret_val) | |
| 677 | + goto out; | |
| 678 | + } | |
| 679 | + | |
| 655 | 680 | /* |
| 656 | 681 | * Check if there was DownShift, must be checked |
| 657 | 682 | * immediately after link-up |
| @@ -894,6 +919,34 @@ static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw) · 236 unmodified lines | ||
| 894 | 919 | return (fwsm & E1000_ICH_FWSM_RSPCIPHY) ? 0 : E1000_BLK_PHY_RESET; |
| 895 | 920 | } |
| 896 | 921 | |
| 922 | +/** | |
| 923 | + * e1000_write_smbus_addr - Write SMBus address to PHY needed during Sx states | |
| 924 | + * @hw: pointer to the HW structure | |
| 925 | + * | |
| 926 | + * Assumes semaphore already acquired. | |
| 927 | + * | |
| 928 | + **/ | |
| 929 | +static s32 e1000_write_smbus_addr(struct e1000_hw *hw) | |
| 930 | +{ | |
| 931 | + u16 phy_data; | |
| 932 | + u32 strap = er32(STRAP); | |
| 933 | + s32 ret_val = 0; | |
| 934 | + | |
| 935 | + strap &= E1000_STRAP_SMBUS_ADDRESS_MASK; | |
| 936 | + | |
| 937 | + ret_val = e1000_read_phy_reg_hv_locked(hw, HV_SMB_ADDR, &phy_data); | |
| 938 | + if (ret_val) | |
| 939 | + goto out; | |
| 940 | + | |
| 941 | + phy_data &= ~HV_SMB_ADDR_MASK; | |
| 942 | + phy_data |= (strap >> E1000_STRAP_SMBUS_ADDRESS_SHIFT); | |
| 943 | + phy_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID; | |
| 944 | + ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR, phy_data); | |
| 945 | + | |
| 946 | +out: | |
| 947 | + return ret_val; | |
| 948 | +} | |
| 949 | + | |
| 897 | 950 | /** |
| 898 | 951 | * e1000_sw_lcd_config_ich8lan - SW-based LCD Configuration |
| 899 | 952 | * @hw: pointer to the HW structure |
| @@ -903,7 +956,6 @@ static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw) · 3 unmodified lines | ||
| 903 | 956 | **/ |
| 904 | 957 | static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw) |
| 905 | 958 | { |
| 906 | − struct e1000_adapter *adapter = hw->adapter; | |
| 907 | 959 | struct e1000_phy_info *phy = &hw->phy; |
| 908 | 960 | u32 i, data, cnf_size, cnf_base_addr, sw_cfg_mask; |
| 909 | 961 | s32 ret_val = 0; |
| @@ -921,7 +973,8 @@ static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw) · 11 unmodified lines | ||
| 921 | 973 | if (phy->type != e1000_phy_igp_3) |
| 922 | 974 | return ret_val; |
| 923 | 975 | |
| 924 | − if (adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) { | |
| 976 | + if ((hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_AMT) || | |
| 977 | + (hw->adapter->pdev->device == E1000_DEV_ID_ICH8_IGP_C)) { | |
| 925 | 978 | sw_cfg_mask = E1000_FEXTNVM_SW_CONFIG; |
| 926 | 979 | break; |
| 927 | 980 | } |
| @@ -961,21 +1014,16 @@ static s32 e1000_sw_lcd_config_ich8lan(struct e1000_hw *hw) · 33 unmodified lines | ||
| 961 | 1014 | cnf_base_addr = data & E1000_EXTCNF_CTRL_EXT_CNF_POINTER_MASK; |
| 962 | 1015 | cnf_base_addr >>= E1000_EXTCNF_CTRL_EXT_CNF_POINTER_SHIFT; |
| 963 | 1016 | |
| 964 | − if (!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) && | |
| 965 | − ((hw->mac.type == e1000_pchlan) || | |
| 966 | − (hw->mac.type == e1000_pch2lan))) { | |
| 1017 | + if ((!(data & E1000_EXTCNF_CTRL_OEM_WRITE_ENABLE) && | |
| 1018 | + (hw->mac.type == e1000_pchlan)) || | |
| 1019 | + (hw->mac.type == e1000_pch2lan)) { | |
| 967 | 1020 | /* |
| 968 | 1021 | * HW configures the SMBus address and LEDs when the |
| 969 | 1022 | * OEM and LCD Write Enable bits are set in the NVM. |
| 970 | 1023 | * When both NVM bits are cleared, SW will configure |
| 971 | 1024 | * them instead. |
| 972 | 1025 | */ |
| 973 | − data = er32(STRAP); | |
| 974 | − data &= E1000_STRAP_SMBUS_ADDRESS_MASK; | |
| 975 | − reg_data = data >> E1000_STRAP_SMBUS_ADDRESS_SHIFT; | |
| 976 | − reg_data |= HV_SMB_ADDR_PEC_EN | HV_SMB_ADDR_VALID; | |
| 977 | − ret_val = e1000_write_phy_reg_hv_locked(hw, HV_SMB_ADDR, | |
| 978 | − reg_data); | |
| 1026 | + ret_val = e1000_write_smbus_addr(hw); | |
| 979 | 1027 | if (ret_val) |
| 980 | 1028 | goto out; |
| 981 | 1029 | |
| @@ -1440,10 +1488,6 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) · 458 unmodified lines | ||
| 1440 | 1488 | goto out; |
| 1441 | 1489 | |
| 1442 | 1490 | /* Enable jumbo frame workaround in the PHY */ |
| 1443 | − e1e_rphy(hw, PHY_REG(769, 20), &data); | |
| 1444 | − ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14)); | |
| 1445 | − if (ret_val) | |
| 1446 | − goto out; | |
| 1447 | 1491 | e1e_rphy(hw, PHY_REG(769, 23), &data); |
| 1448 | 1492 | data &= ~(0x7F << 5); |
| 1449 | 1493 | data |= (0x37 << 5); |
| @@ -1452,7 +1496,6 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) · 2 unmodified lines | ||
| 1452 | 1496 | goto out; |
| 1453 | 1497 | e1e_rphy(hw, PHY_REG(769, 16), &data); |
| 1454 | 1498 | data &= ~(1 << 13); |
| 1455 | − data |= (1 << 12); | |
| 1456 | 1499 | ret_val = e1e_wphy(hw, PHY_REG(769, 16), data); |
| 1457 | 1500 | if (ret_val) |
| 1458 | 1501 | goto out; |
| @@ -1477,7 +1520,7 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) · 18 unmodified lines | ||
| 1477 | 1520 | |
| 1478 | 1521 | mac_reg = er32(RCTL); |
| 1479 | 1522 | mac_reg &= ~E1000_RCTL_SECRC; |
| 1480 | − ew32(FFLT_DBG, mac_reg); | |
| 1523 | + ew32(RCTL, mac_reg); | |
| 1481 | 1524 | |
| 1482 | 1525 | ret_val = e1000e_read_kmrn_reg(hw, |
| 1483 | 1526 | E1000_KMRNCTRLSTA_CTRL_OFFSET, |
| @@ -1503,17 +1546,12 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) · 19 unmodified lines | ||
| 1503 | 1546 | goto out; |
| 1504 | 1547 | |
| 1505 | 1548 | /* Write PHY register values back to h/w defaults */ |
| 1506 | − e1e_rphy(hw, PHY_REG(769, 20), &data); | |
| 1507 | − ret_val = e1e_wphy(hw, PHY_REG(769, 20), data & ~(1 << 14)); | |
| 1508 | − if (ret_val) | |
| 1509 | − goto out; | |
| 1510 | 1549 | e1e_rphy(hw, PHY_REG(769, 23), &data); |
| 1511 | 1550 | data &= ~(0x7F << 5); |
| 1512 | 1551 | ret_val = e1e_wphy(hw, PHY_REG(769, 23), data); |
| 1513 | 1552 | if (ret_val) |
| 1514 | 1553 | goto out; |
| 1515 | 1554 | e1e_rphy(hw, PHY_REG(769, 16), &data); |
| 1516 | − data &= ~(1 << 12); | |
| 1517 | 1555 | data |= (1 << 13); |
| 1518 | 1556 | ret_val = e1e_wphy(hw, PHY_REG(769, 16), data); |
| 1519 | 1557 | if (ret_val) |
| @@ -1558,6 +1596,69 @@ out: · 38 unmodified lines | ||
| 1558 | 1596 | return ret_val; |
| 1559 | 1597 | } |
| 1560 | 1598 | |
| 1599 | +/** | |
| 1600 | + * e1000_k1_gig_workaround_lv - K1 Si workaround | |
| 1601 | + * @hw: pointer to the HW structure | |
| 1602 | + * | |
| 1603 | + * Workaround to set the K1 beacon duration for 82579 parts | |
| 1604 | + **/ | |
| 1605 | +static s32 e1000_k1_workaround_lv(struct e1000_hw *hw) | |
| 1606 | +{ | |
| 1607 | + s32 ret_val = 0; | |
| 1608 | + u16 status_reg = 0; | |
| 1609 | + u32 mac_reg; | |
| 1610 | + | |
| 1611 | + if (hw->mac.type != e1000_pch2lan) | |
| 1612 | + goto out; | |
| 1613 | + | |
| 1614 | + /* Set K1 beacon duration based on 1Gbps speed or otherwise */ | |
| 1615 | + ret_val = e1e_rphy(hw, HV_M_STATUS, &status_reg); | |
| 1616 | + if (ret_val) | |
| 1617 | + goto out; | |
| 1618 | + | |
| 1619 | + if ((status_reg & (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE)) | |
| 1620 | + == (HV_M_STATUS_LINK_UP | HV_M_STATUS_AUTONEG_COMPLETE)) { | |
| 1621 | + mac_reg = er32(FEXTNVM4); | |
| 1622 | + mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK; | |
| 1623 | + | |
| 1624 | + if (status_reg & HV_M_STATUS_SPEED_1000) | |
| 1625 | + mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC; | |
| 1626 | + else | |
| 1627 | + mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC; | |
| 1628 | + | |
| 1629 | + ew32(FEXTNVM4, mac_reg); | |
| 1630 | + } | |
| 1631 | + | |
| 1632 | +out: | |
| 1633 | + return ret_val; | |
| 1634 | +} | |
| 1635 | + | |
| 1636 | +/** | |
| 1637 | + * e1000_gate_hw_phy_config_ich8lan - disable PHY config via hardware | |
| 1638 | + * @hw: pointer to the HW structure | |
| 1639 | + * @gate: boolean set to true to gate, false to ungate | |
| 1640 | + * | |
| 1641 | + * Gate/ungate the automatic PHY configuration via hardware; perform | |
| 1642 | + * the configuration via software instead. | |
| 1643 | + **/ | |
| 1644 | +static void e1000_gate_hw_phy_config_ich8lan(struct e1000_hw *hw, bool gate) | |
| 1645 | +{ | |
| 1646 | + u32 extcnf_ctrl; | |
| 1647 | + | |
| 1648 | + if (hw->mac.type != e1000_pch2lan) | |
| 1649 | + return; | |
| 1650 | + | |
| 1651 | + extcnf_ctrl = er32(EXTCNF_CTRL); | |
| 1652 | + | |
| 1653 | + if (gate) | |
| 1654 | + extcnf_ctrl |= E1000_EXTCNF_CTRL_GATE_PHY_CFG; | |
| 1655 | + else | |
| 1656 | + extcnf_ctrl &= ~E1000_EXTCNF_CTRL_GATE_PHY_CFG; | |
| 1657 | + | |
| 1658 | + ew32(EXTCNF_CTRL, extcnf_ctrl); | |
| 1659 | + return; | |
| 1660 | +} | |
| 1661 | + | |
| 1561 | 1662 | /** |
| 1562 | 1663 | * e1000_lan_init_done_ich8lan - Check for PHY config completion |
| 1563 | 1664 | * @hw: pointer to the HW structure |
| @@ -1602,6 +1703,9 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw) · 38 unmodified lines | ||
| 1602 | 1703 | if (e1000_check_reset_block(hw)) |
| 1603 | 1704 | goto out; |
| 1604 | 1705 | |
| 1706 | + /* Allow time for h/w to get to quiescent state after reset */ | |
| 1707 | + msleep(10); | |
| 1708 | + | |
| 1605 | 1709 | /* Perform any necessary post-reset workarounds */ |
| 1606 | 1710 | switch (hw->mac.type) { |
| 1607 | 1711 | case e1000_pchlan: |
| @@ -1630,6 +1734,13 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw) · 22 unmodified lines | ||
| 1630 | 1734 | /* Configure the LCD with the OEM bits in NVM */ |
| 1631 | 1735 | ret_val = e1000_oem_bits_config_ich8lan(hw, true); |
| 1632 | 1736 | |
| 1737 | + /* Ungate automatic PHY configuration on non-managed 82579 */ | |
| 1738 | + if ((hw->mac.type == e1000_pch2lan) && | |
| 1739 | + !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) { | |
| 1740 | + msleep(10); | |
| 1741 | + e1000_gate_hw_phy_config_ich8lan(hw, false); | |
| 1742 | + } | |
| 1743 | + | |
| 1633 | 1744 | out: |
| 1634 | 1745 | return ret_val; |
| 1635 | 1746 | } |
| @@ -1646,6 +1757,11 @@ static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw) · 10 unmodified lines | ||
| 1646 | 1757 | { |
| 1647 | 1758 | s32 ret_val = 0; |
| 1648 | 1759 | |
| 1760 | + /* Gate automatic PHY configuration by hardware on non-managed 82579 */ | |
| 1761 | + if ((hw->mac.type == e1000_pch2lan) && | |
| 1762 | + !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) | |
| 1763 | + e1000_gate_hw_phy_config_ich8lan(hw, true); | |
| 1764 | + | |
| 1649 | 1765 | ret_val = e1000e_phy_hw_reset_generic(hw); |
| 1650 | 1766 | if (ret_val) |
| 1651 | 1767 | goto out; |
| @@ -2910,6 +3026,14 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw) · 1258 unmodified lines | ||
| 2910 | 3026 | * external PHY is reset. |
| 2911 | 3027 | */ |
| 2912 | 3028 | ctrl |= E1000_CTRL_PHY_RST; |
| 3029 | + | |
| 3030 | + /* | |
| 3031 | + * Gate automatic PHY configuration by hardware on | |
| 3032 | + * non-managed 82579 | |
| 3033 | + */ | |
| 3034 | + if ((hw->mac.type == e1000_pch2lan) && | |
| 3035 | + !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) | |
| 3036 | + e1000_gate_hw_phy_config_ich8lan(hw, true); | |
| 2913 | 3037 | } |
| 2914 | 3038 | ret_val = e1000_acquire_swflag_ich8lan(hw); |
| 2915 | 3039 | e_dbg("Issuing a global reset to ich8lan\n"); |
| @@ -3460,13 +3584,20 @@ void e1000e_gig_downshift_workaround_ich8lan(struct e1000_hw *hw) · 544 unmodified lines | ||
| 3460 | 3584 | void e1000e_disable_gig_wol_ich8lan(struct e1000_hw *hw) |
| 3461 | 3585 | { |
| 3462 | 3586 | u32 phy_ctrl; |
| 3587 | + s32 ret_val; | |
| 3463 | 3588 | |
| 3464 | 3589 | phy_ctrl = er32(PHY_CTRL); |
| 3465 | 3590 | phy_ctrl |= E1000_PHY_CTRL_D0A_LPLU | E1000_PHY_CTRL_GBE_DISABLE; |
| 3466 | 3591 | ew32(PHY_CTRL, phy_ctrl); |
| 3467 | 3592 | |
| 3468 | − if (hw->mac.type >= e1000_pchlan) | |
| 3469 | − e1000_phy_hw_reset_ich8lan(hw); | |
| 3593 | + if (hw->mac.type >= e1000_pchlan) { | |
| 3594 | + e1000_oem_bits_config_ich8lan(hw, true); | |
| 3595 | + ret_val = hw->phy.ops.acquire(hw); | |
| 3596 | + if (ret_val) | |
| 3597 | + return; | |
| 3598 | + e1000_write_smbus_addr(hw); | |
| 3599 | + hw->phy.ops.release(hw); | |
| 3600 | + } | |
| 3470 | 3601 | } |
| 3471 | 3602 | |
| 3472 | 3603 | /** |
| @@ -2704,6 +2704,16 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter) · 2703 unmodified lines | ||
| 2704 | 2704 | u32 psrctl = 0; |
| 2705 | 2705 | u32 pages = 0; |
| 2706 | 2706 | |
| 2707 | + /* Workaround Si errata on 82579 - configure jumbo frame flow */ | |
| 2708 | + if (hw->mac.type == e1000_pch2lan) { | |
| 2709 | + s32 ret_val; | |
| 2710 | + | |
| 2711 | + if (adapter->netdev->mtu > ETH_DATA_LEN) | |
| 2712 | + ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true); | |
| 2713 | + else | |
| 2714 | + ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false); | |
| 2715 | + } | |
| 2716 | + | |
| 2707 | 2717 | /* Program MC offset vector base */ |
| 2708 | 2718 | rctl = er32(RCTL); |
| 2709 | 2719 | rctl &= ~(3 << E1000_RCTL_MO_SHIFT); |
| @@ -2744,16 +2754,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter) · 34 unmodified lines | ||
| 2744 | 2754 | e1e_wphy(hw, 22, phy_data); |
| 2745 | 2755 | } |
| 2746 | 2756 | |
| 2747 | − /* Workaround Si errata on 82579 - configure jumbo frame flow */ | |
| 2748 | − if (hw->mac.type == e1000_pch2lan) { | |
| 2749 | − s32 ret_val; | |
| 2750 | − | |
| 2751 | − if (rctl & E1000_RCTL_LPE) | |
| 2752 | − ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true); | |
| 2753 | − else | |
| 2754 | − ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false); | |
| 2755 | − } | |
| 2756 | − | |
| 2757 | 2757 | /* Setup buffer sizes */ |
| 2758 | 2758 | rctl &= ~E1000_RCTL_SZ_4096; |
| 2759 | 2759 | rctl |= E1000_RCTL_BSEX; |
| @@ -4833,6 +4833,15 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu) · 2073 unmodified lines | ||
| 4833 | 4833 | return -EINVAL; |
| 4834 | 4834 | } |
| 4835 | 4835 | |
| 4836 | + /* Jumbo frame workaround on 82579 requires CRC be stripped */ | |
| 4837 | + if ((adapter->hw.mac.type == e1000_pch2lan) && | |
| 4838 | + !(adapter->flags2 & FLAG2_CRC_STRIPPING) && | |
| 4839 | + (new_mtu > ETH_DATA_LEN)) { | |
| 4840 | + e_err("Jumbo Frames not supported on 82579 when CRC " | |
| 4841 | + "stripping is disabled.\n"); | |
| 4842 | + return -EINVAL; | |
| 4843 | + } | |
| 4844 | + | |
| 4836 | 4845 | /* 82573 Errata 17 */ |
| 4837 | 4846 | if (((adapter->hw.mac.type == e1000_82573) || |
| 4838 | 4847 | (adapter->hw.mac.type == e1000_82574)) && |
| @@ -2928,7 +2928,7 @@ static int __devinit emac_probe(struct platform_device *ofdev, · 2927 unmodified lines | ||
| 2928 | 2928 | if (dev->emac_irq != NO_IRQ) |
| 2929 | 2929 | irq_dispose_mapping(dev->emac_irq); |
| 2930 | 2930 | err_free: |
| 2931 | − kfree(ndev); | |
| 2931 | + free_netdev(ndev); | |
| 2932 | 2932 | err_gone: |
| 2933 | 2933 | /* if we were on the bootlist, remove us as we won't show up and |
| 2934 | 2934 | * wake up all waiters to notify them in case they were waiting |
| @@ -2971,7 +2971,7 @@ static int __devexit emac_remove(struct platform_device *ofdev) · 36 unmodified lines | ||
| 2971 | 2971 | if (dev->emac_irq != NO_IRQ) |
| 2972 | 2972 | irq_dispose_mapping(dev->emac_irq); |
| 2973 | 2973 | |
| 2974 | − kfree(dev->ndev); | |
| 2974 | + free_netdev(dev->ndev); | |
| 2975 | 2975 | |
| 2976 | 2976 | return 0; |
| 2977 | 2977 | } |
| @@ -1540,7 +1540,6 @@ netxen_process_rcv(struct netxen_adapter *adapter, · 1539 unmodified lines | ||
| 1540 | 1540 | if (pkt_offset) |
| 1541 | 1541 | skb_pull(skb, pkt_offset); |
| 1542 | 1542 | |
| 1543 | − skb->truesize = skb->len + sizeof(struct sk_buff); | |
| 1544 | 1543 | skb->protocol = eth_type_trans(skb, netdev); |
| 1545 | 1544 | |
| 1546 | 1545 | napi_gro_receive(&sds_ring->napi, skb); |
| @@ -1602,8 +1601,6 @@ netxen_process_lro(struct netxen_adapter *adapter, · 55 unmodified lines | ||
| 1602 | 1601 | |
| 1603 | 1602 | skb_put(skb, lro_length + data_offset); |
| 1604 | 1603 | |
| 1605 | − skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb); | |
| 1606 | − | |
| 1607 | 1604 | skb_pull(skb, l2_hdr_offset); |
| 1608 | 1605 | skb->protocol = eth_type_trans(skb, netdev); |
| 1609 | 1606 | |
| @@ -1316,7 +1316,7 @@ qlcnic_alloc_rx_skb(struct qlcnic_adapter *adapter, · 1315 unmodified lines | ||
| 1316 | 1316 | return -ENOMEM; |
| 1317 | 1317 | } |
| 1318 | 1318 | |
| 1319 | − skb_reserve(skb, 2); | |
| 1319 | + skb_reserve(skb, NET_IP_ALIGN); | |
| 1320 | 1320 | |
| 1321 | 1321 | dma = pci_map_single(pdev, skb->data, |
| 1322 | 1322 | rds_ring->dma_size, PCI_DMA_FROMDEVICE); |
| @@ -1404,7 +1404,6 @@ qlcnic_process_rcv(struct qlcnic_adapter *adapter, · 81 unmodified lines | ||
| 1404 | 1404 | if (pkt_offset) |
| 1405 | 1405 | skb_pull(skb, pkt_offset); |
| 1406 | 1406 | |
| 1407 | − skb->truesize = skb->len + sizeof(struct sk_buff); | |
| 1408 | 1407 | skb->protocol = eth_type_trans(skb, netdev); |
| 1409 | 1408 | |
| 1410 | 1409 | napi_gro_receive(&sds_ring->napi, skb); |
| @@ -1466,8 +1465,6 @@ qlcnic_process_lro(struct qlcnic_adapter *adapter, · 55 unmodified lines | ||
| 1466 | 1465 | |
| 1467 | 1466 | skb_put(skb, lro_length + data_offset); |
| 1468 | 1467 | |
| 1469 | − skb->truesize = skb->len + sizeof(struct sk_buff) + skb_headroom(skb); | |
| 1470 | − | |
| 1471 | 1468 | skb_pull(skb, l2_hdr_offset); |
| 1472 | 1469 | skb->protocol = eth_type_trans(skb, netdev); |
| 1473 | 1470 | |
| @@ -1700,8 +1697,6 @@ qlcnic_process_rcv_diag(struct qlcnic_adapter *adapter, · 226 unmodified lines | ||
| 1700 | 1697 | if (pkt_offset) |
| 1701 | 1698 | skb_pull(skb, pkt_offset); |
| 1702 | 1699 | |
| 1703 | − skb->truesize = skb->len + sizeof(struct sk_buff); | |
| 1704 | − | |
| 1705 | 1700 | if (!qlcnic_check_loopback_buff(skb->data)) |
| 1706 | 1701 | adapter->diag_cnt++; |
| 1707 | 1702 | |
| @@ -384,7 +384,7 @@ static void rionet_remove(struct rio_dev *rdev) · 383 unmodified lines | ||
| 384 | 384 | free_pages((unsigned long)rionet_active, rdev->net->hport->sys_size ? |
| 385 | 385 | __ilog2(sizeof(void *)) + 4 : 0); |
| 386 | 386 | unregister_netdev(ndev); |
| 387 | − kfree(ndev); | |
| 387 | + free_netdev(ndev); | |
| 388 | 388 | |
| 389 | 389 | list_for_each_entry_safe(peer, tmp, &rionet_peers, node) { |
| 390 | 390 | list_del(&peer->node); |
| @@ -804,7 +804,7 @@ static int __devinit sgiseeq_probe(struct platform_device *pdev) · 803 unmodified lines | ||
| 804 | 804 | err_out_free_page: |
| 805 | 805 | free_page((unsigned long) sp->srings); |
| 806 | 806 | err_out_free_dev: |
| 807 | − kfree(dev); | |
| 807 | + free_netdev(dev); | |
| 808 | 808 | |
| 809 | 809 | err_out: |
| 810 | 810 | return err; |
| @@ -58,6 +58,7 @@ · 57 unmodified lines | ||
| 58 | 58 | |
| 59 | 59 | MODULE_LICENSE("GPL"); |
| 60 | 60 | MODULE_VERSION(SMSC_DRV_VERSION); |
| 61 | +MODULE_ALIAS("platform:smsc911x"); | |
| 61 | 62 | |
| 62 | 63 | #if USE_DEBUG > 0 |
| 63 | 64 | static int debug = 16; |
| @@ -243,6 +243,7 @@ enum { · 242 unmodified lines | ||
| 243 | 243 | NWayState = (1 << 14) | (1 << 13) | (1 << 12), |
| 244 | 244 | NWayRestart = (1 << 12), |
| 245 | 245 | NonselPortActive = (1 << 9), |
| 246 | + SelPortActive = (1 << 8), | |
| 246 | 247 | LinkFailStatus = (1 << 2), |
| 247 | 248 | NetCxnErr = (1 << 1), |
| 248 | 249 | }; |
| @@ -363,7 +364,9 @@ static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, }; · 114 unmodified lines | ||
| 363 | 364 | |
| 364 | 365 | /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/ |
| 365 | 366 | static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, }; |
| 366 | −static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, }; | |
| 367 | +static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; | |
| 368 | +/* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */ | |
| 369 | +static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, }; | |
| 367 | 370 | static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, }; |
| 368 | 371 | |
| 369 | 372 | |
| @@ -1064,6 +1067,9 @@ static void de21041_media_timer (unsigned long data) · 694 unmodified lines | ||
| 1064 | 1067 | unsigned int carrier; |
| 1065 | 1068 | unsigned long flags; |
| 1066 | 1069 | |
| 1070 | + /* clear port active bits */ | |
| 1071 | + dw32(SIAStatus, NonselPortActive | SelPortActive); | |
| 1072 | + | |
| 1067 | 1073 | carrier = (status & NetCxnErr) ? 0 : 1; |
| 1068 | 1074 | |
| 1069 | 1075 | if (carrier) { |
| @@ -1158,14 +1164,29 @@ no_link_yet: · 88 unmodified lines | ||
| 1158 | 1164 | static void de_media_interrupt (struct de_private *de, u32 status) |
| 1159 | 1165 | { |
| 1160 | 1166 | if (status & LinkPass) { |
| 1167 | + /* Ignore if current media is AUI or BNC and we can't use TP */ | |
| 1168 | + if ((de->media_type == DE_MEDIA_AUI || | |
| 1169 | + de->media_type == DE_MEDIA_BNC) && | |
| 1170 | + (de->media_lock || | |
| 1171 | + !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))) | |
| 1172 | + return; | |
| 1173 | + /* If current media is not TP, change it to TP */ | |
| 1174 | + if ((de->media_type == DE_MEDIA_AUI || | |
| 1175 | + de->media_type == DE_MEDIA_BNC)) { | |
| 1176 | + de->media_type = DE_MEDIA_TP_AUTO; | |
| 1177 | + de_stop_rxtx(de); | |
| 1178 | + de_set_media(de); | |
| 1179 | + de_start_rxtx(de); | |
| 1180 | + } | |
| 1161 | 1181 | de_link_up(de); |
| 1162 | 1182 | mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK); |
| 1163 | 1183 | return; |
| 1164 | 1184 | } |
| 1165 | 1185 | |
| 1166 | 1186 | BUG_ON(!(status & LinkFail)); |
| 1167 | − | |
| 1168 | − if (netif_carrier_ok(de->dev)) { | |
| 1187 | + /* Mark the link as down only if current media is TP */ | |
| 1188 | + if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI && | |
| 1189 | + de->media_type != DE_MEDIA_BNC) { | |
| 1169 | 1190 | de_link_down(de); |
| 1170 | 1191 | mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); |
| 1171 | 1192 | } |
| @@ -1229,6 +1250,7 @@ static void de_adapter_sleep (struct de_private *de) · 57 unmodified lines | ||
| 1229 | 1250 | if (de->de21040) |
| 1230 | 1251 | return; |
| 1231 | 1252 | |
| 1253 | + dw32(CSR13, 0); /* Reset phy */ | |
| 1232 | 1254 | pci_read_config_dword(de->pdev, PCIPM, &pmctl); |
| 1233 | 1255 | pmctl |= PM_Sleep; |
| 1234 | 1256 | pci_write_config_dword(de->pdev, PCIPM, pmctl); |
| @@ -1574,12 +1596,15 @@ static int __de_set_settings(struct de_private *de, struct ethtool_cmd *ecmd) · 339 unmodified lines | ||
| 1574 | 1596 | return 0; /* nothing to change */ |
| 1575 | 1597 | |
| 1576 | 1598 | de_link_down(de); |
| 1599 | + mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK); | |
| 1577 | 1600 | de_stop_rxtx(de); |
| 1578 | 1601 | |
| 1579 | 1602 | de->media_type = new_media; |
| 1580 | 1603 | de->media_lock = media_lock; |
| 1581 | 1604 | de->media_advertise = ecmd->advertising; |
| 1582 | 1605 | de_set_media(de); |
| 1606 | + if (netif_running(de->dev)) | |
| 1607 | + de_start_rxtx(de); | |
| 1583 | 1608 | |
| 1584 | 1609 | return 0; |
| 1585 | 1610 | } |
| @@ -1911,8 +1936,14 @@ fill_defaults: · 325 unmodified lines | ||
| 1911 | 1936 | for (i = 0; i < DE_MAX_MEDIA; i++) { |
| 1912 | 1937 | if (de->media[i].csr13 == 0xffff) |
| 1913 | 1938 | de->media[i].csr13 = t21041_csr13[i]; |
| 1914 | − if (de->media[i].csr14 == 0xffff) | |
| 1915 | − de->media[i].csr14 = t21041_csr14[i]; | |
| 1939 | + if (de->media[i].csr14 == 0xffff) { | |
| 1940 | + /* autonegotiation is broken at least on some chip | |
| 1941 | + revisions - rev. 0x21 works, 0x11 does not */ | |
| 1942 | + if (de->pdev->revision < 0x20) | |
| 1943 | + de->media[i].csr14 = t21041_csr14_brk[i]; | |
| 1944 | + else | |
| 1945 | + de->media[i].csr14 = t21041_csr14[i]; | |
| 1946 | + } | |
| 1916 | 1947 | if (de->media[i].csr15 == 0xffff) |
| 1917 | 1948 | de->media[i].csr15 = t21041_csr15[i]; |
| 1918 | 1949 | } |
| @@ -2158,6 +2189,8 @@ static int de_resume (struct pci_dev *pdev) · 239 unmodified lines | ||
| 2158 | 2189 | dev_err(&dev->dev, "pci_enable_device failed in resume\n"); |
| 2159 | 2190 | goto out; |
| 2160 | 2191 | } |
| 2192 | + pci_set_master(pdev); | |
| 2193 | + de_init_rings(de); | |
| 2161 | 2194 | de_init_hw(de); |
| 2162 | 2195 | out_attach: |
| 2163 | 2196 | netif_device_attach(dev); |
| @@ -1411,7 +1411,7 @@ void iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif) · 1410 unmodified lines | ||
| 1411 | 1411 | clear_bit(STATUS_SCAN_HW, &priv->status); |
| 1412 | 1412 | clear_bit(STATUS_SCANNING, &priv->status); |
| 1413 | 1413 | /* inform mac80211 scan aborted */ |
| 1414 | − queue_work(priv->workqueue, &priv->scan_completed); | |
| 1414 | + queue_work(priv->workqueue, &priv->abort_scan); | |
| 1415 | 1415 | } |
| 1416 | 1416 | |
| 1417 | 1417 | int iwlagn_manage_ibss_station(struct iwl_priv *priv, |
| @@ -2613,6 +2613,11 @@ int iwl_force_reset(struct iwl_priv *priv, int mode, bool external) · 2612 unmodified lines | ||
| 2613 | 2613 | if (test_bit(STATUS_EXIT_PENDING, &priv->status)) |
| 2614 | 2614 | return -EINVAL; |
| 2615 | 2615 | |
| 2616 | + if (test_bit(STATUS_SCANNING, &priv->status)) { | |
| 2617 | + IWL_DEBUG_INFO(priv, "scan in progress.\n"); | |
| 2618 | + return -EINVAL; | |
| 2619 | + } | |
| 2620 | + | |
| 2616 | 2621 | if (mode >= IWL_MAX_FORCE_RESET) { |
| 2617 | 2622 | IWL_DEBUG_INFO(priv, "invalid reset request.\n"); |
| 2618 | 2623 | return -EINVAL; |
| @@ -3018,7 +3018,7 @@ void iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif) · 3017 unmodified lines | ||
| 3018 | 3018 | clear_bit(STATUS_SCANNING, &priv->status); |
| 3019 | 3019 | |
| 3020 | 3020 | /* inform mac80211 scan aborted */ |
| 3021 | − queue_work(priv->workqueue, &priv->scan_completed); | |
| 3021 | + queue_work(priv->workqueue, &priv->abort_scan); | |
| 3022 | 3022 | } |
| 3023 | 3023 | |
| 3024 | 3024 | static void iwl3945_bg_restart(struct work_struct *data) |
| @@ -71,6 +71,49 @@ · 70 unmodified lines | ||
| 71 | 71 | #define DMA_32BIT_PFN IOVA_PFN(DMA_BIT_MASK(32)) |
| 72 | 72 | #define DMA_64BIT_PFN IOVA_PFN(DMA_BIT_MASK(64)) |
| 73 | 73 | |
| 74 | +/* page table handling */ | |
| 75 | +#define LEVEL_STRIDE (9) | |
| 76 | +#define LEVEL_MASK (((u64)1 << LEVEL_STRIDE) - 1) | |
| 77 | + | |
| 78 | +static inline int agaw_to_level(int agaw) | |
| 79 | +{ | |
| 80 | + return agaw + 2; | |
| 81 | +} | |
| 82 | + | |
| 83 | +static inline int agaw_to_width(int agaw) | |
| 84 | +{ | |
| 85 | + return 30 + agaw * LEVEL_STRIDE; | |
| 86 | +} | |
| 87 | + | |
| 88 | +static inline int width_to_agaw(int width) | |
| 89 | +{ | |
| 90 | + return (width - 30) / LEVEL_STRIDE; | |
| 91 | +} | |
| 92 | + | |
| 93 | +static inline unsigned int level_to_offset_bits(int level) | |
| 94 | +{ | |
| 95 | + return (level - 1) * LEVEL_STRIDE; | |
| 96 | +} | |
| 97 | + | |
| 98 | +static inline int pfn_level_offset(unsigned long pfn, int level) | |
| 99 | +{ | |
| 100 | + return (pfn >> level_to_offset_bits(level)) & LEVEL_MASK; | |
| 101 | +} | |
| 102 | + | |
| 103 | +static inline unsigned long level_mask(int level) | |
| 104 | +{ | |
| 105 | + return -1UL << level_to_offset_bits(level); | |
| 106 | +} | |
| 107 | + | |
| 108 | +static inline unsigned long level_size(int level) | |
| 109 | +{ | |
| 110 | + return 1UL << level_to_offset_bits(level); | |
| 111 | +} | |
| 112 | + | |
| 113 | +static inline unsigned long align_to_level(unsigned long pfn, int level) | |
| 114 | +{ | |
| 115 | + return (pfn + level_size(level) - 1) & level_mask(level); | |
| 116 | +} | |
| 74 | 117 | |
| 75 | 118 | /* VT-d pages must always be _smaller_ than MM pages. Otherwise things |
| 76 | 119 | are never going to work. */ |
| @@ -434,8 +477,6 @@ void free_iova_mem(struct iova *iova) · 357 unmodified lines | ||
| 434 | 477 | } |
| 435 | 478 | |
| 436 | 479 | |
| 437 | −static inline int width_to_agaw(int width); | |
| 438 | − | |
| 439 | 480 | static int __iommu_calculate_agaw(struct intel_iommu *iommu, int max_gaw) |
| 440 | 481 | { |
| 441 | 482 | unsigned long sagaw; |
| @@ -646,51 +687,6 @@ out: · 204 unmodified lines | ||
| 646 | 687 | spin_unlock_irqrestore(&iommu->lock, flags); |
| 647 | 688 | } |
| 648 | 689 | |
| 649 | −/* page table handling */ | |
| 650 | −#define LEVEL_STRIDE (9) | |
| 651 | −#define LEVEL_MASK (((u64)1 << LEVEL_STRIDE) - 1) | |
| 652 | − | |
| 653 | −static inline int agaw_to_level(int agaw) | |
| 654 | −{ | |
| 655 | − return agaw + 2; | |
| 656 | −} | |
| 657 | − | |
| 658 | −static inline int agaw_to_width(int agaw) | |
| 659 | −{ | |
| 660 | − return 30 + agaw * LEVEL_STRIDE; | |
| 661 | − | |
| 662 | −} | |
| 663 | − | |
| 664 | −static inline int width_to_agaw(int width) | |
| 665 | −{ | |
| 666 | − return (width - 30) / LEVEL_STRIDE; | |
| 667 | −} | |
| 668 | − | |
| 669 | −static inline unsigned int level_to_offset_bits(int level) | |
| 670 | −{ | |
| 671 | − return (level - 1) * LEVEL_STRIDE; | |
| 672 | −} | |
| 673 | − | |
| 674 | −static inline int pfn_level_offset(unsigned long pfn, int level) | |
| 675 | −{ | |
| 676 | − return (pfn >> level_to_offset_bits(level)) & LEVEL_MASK; | |
| 677 | −} | |
| 678 | − | |
| 679 | −static inline unsigned long level_mask(int level) | |
| 680 | −{ | |
| 681 | − return -1UL << level_to_offset_bits(level); | |
| 682 | −} | |
| 683 | − | |
| 684 | −static inline unsigned long level_size(int level) | |
| 685 | −{ | |
| 686 | − return 1UL << level_to_offset_bits(level); | |
| 687 | −} | |
| 688 | − | |
| 689 | −static inline unsigned long align_to_level(unsigned long pfn, int level) | |
| 690 | −{ | |
| 691 | − return (pfn + level_size(level) - 1) & level_mask(level); | |
| 692 | −} | |
| 693 | − | |
| 694 | 690 | static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain, |
| 695 | 691 | unsigned long pfn) |
| 696 | 692 | { |
| @@ -3761,6 +3757,33 @@ static void __devinit quirk_iommu_rwbf(struct pci_dev *dev) · 3064 unmodified lines | ||
| 3761 | 3757 | |
| 3762 | 3758 | DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x2a40, quirk_iommu_rwbf); |
| 3763 | 3759 | |
| 3760 | +#define GGC 0x52 | |
| 3761 | +#define GGC_MEMORY_SIZE_MASK (0xf << 8) | |
| 3762 | +#define GGC_MEMORY_SIZE_NONE (0x0 << 8) | |
| 3763 | +#define GGC_MEMORY_SIZE_1M (0x1 << 8) | |
| 3764 | +#define GGC_MEMORY_SIZE_2M (0x3 << 8) | |
| 3765 | +#define GGC_MEMORY_VT_ENABLED (0x8 << 8) | |
| 3766 | +#define GGC_MEMORY_SIZE_2M_VT (0x9 << 8) | |
| 3767 | +#define GGC_MEMORY_SIZE_3M_VT (0xa << 8) | |
| 3768 | +#define GGC_MEMORY_SIZE_4M_VT (0xb << 8) | |
| 3769 | + | |
| 3770 | +static void __devinit quirk_calpella_no_shadow_gtt(struct pci_dev *dev) | |
| 3771 | +{ | |
| 3772 | + unsigned short ggc; | |
| 3773 | + | |
| 3774 | + if (pci_read_config_word(dev, GGC, &ggc)) | |
| 3775 | + return; | |
| 3776 | + | |
| 3777 | + if (!(ggc & GGC_MEMORY_VT_ENABLED)) { | |
| 3778 | + printk(KERN_INFO "DMAR: BIOS has allocated no shadow GTT; disabling IOMMU for graphics\n"); | |
| 3779 | + dmar_map_gfx = 0; | |
| 3780 | + } | |
| 3781 | +} | |
| 3782 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0040, quirk_calpella_no_shadow_gtt); | |
| 3783 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0044, quirk_calpella_no_shadow_gtt); | |
| 3784 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x0062, quirk_calpella_no_shadow_gtt); | |
| 3785 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x006a, quirk_calpella_no_shadow_gtt); | |
| 3786 | + | |
| 3764 | 3787 | /* On Tylersburg chipsets, some BIOSes have been known to enable the |
| 3765 | 3788 | ISOCH DMAR unit for the Azalia sound device, but not give it any |
| 3766 | 3789 | TLB entries, which causes it to deadlock. Check for that. We do |
| @@ -608,7 +608,7 @@ int pci_iov_resource_bar(struct pci_dev *dev, int resno, · 607 unmodified lines | ||
| 608 | 608 | * the VF BAR size multiplied by the number of VFs. The alignment |
| 609 | 609 | * is just the VF BAR size. |
| 610 | 610 | */ |
| 611 | −int pci_sriov_resource_alignment(struct pci_dev *dev, int resno) | |
| 611 | +resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno) | |
| 612 | 612 | { |
| 613 | 613 | struct resource tmp; |
| 614 | 614 | enum pci_bar_type type; |
| @@ -264,7 +264,8 @@ extern int pci_iov_init(struct pci_dev *dev); · 263 unmodified lines | ||
| 264 | 264 | extern void pci_iov_release(struct pci_dev *dev); |
| 265 | 265 | extern int pci_iov_resource_bar(struct pci_dev *dev, int resno, |
| 266 | 266 | enum pci_bar_type *type); |
| 267 | −extern int pci_sriov_resource_alignment(struct pci_dev *dev, int resno); | |
| 267 | +extern resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, | |
| 268 | + int resno); | |
| 268 | 269 | extern void pci_restore_iov_state(struct pci_dev *dev); |
| 269 | 270 | extern int pci_iov_bus_range(struct pci_bus *bus); |
| 270 | 271 | |
| @@ -320,7 +321,7 @@ static inline int pci_ats_enabled(struct pci_dev *dev) · 49 unmodified lines | ||
| 320 | 321 | } |
| 321 | 322 | #endif /* CONFIG_PCI_IOV */ |
| 322 | 323 | |
| 323 | −static inline int pci_resource_alignment(struct pci_dev *dev, | |
| 324 | +static inline resource_size_t pci_resource_alignment(struct pci_dev *dev, | |
| 324 | 325 | struct resource *res) |
| 325 | 326 | { |
| 326 | 327 | #ifdef CONFIG_PCI_IOV |
| @@ -162,6 +162,26 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_CBUS_1, quirk_isa_d · 161 unmodified lines | ||
| 162 | 162 | DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_CBUS_2, quirk_isa_dma_hangs); |
| 163 | 163 | DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_CBUS_3, quirk_isa_dma_hangs); |
| 164 | 164 | |
| 165 | +/* | |
| 166 | + * Intel NM10 "TigerPoint" LPC PM1a_STS.BM_STS must be clear | |
| 167 | + * for some HT machines to use C4 w/o hanging. | |
| 168 | + */ | |
| 169 | +static void __devinit quirk_tigerpoint_bm_sts(struct pci_dev *dev) | |
| 170 | +{ | |
| 171 | + u32 pmbase; | |
| 172 | + u16 pm1a; | |
| 173 | + | |
| 174 | + pci_read_config_dword(dev, 0x40, &pmbase); | |
| 175 | + pmbase = pmbase & 0xff80; | |
| 176 | + pm1a = inw(pmbase); | |
| 177 | + | |
| 178 | + if (pm1a & 0x10) { | |
| 179 | + dev_info(&dev->dev, FW_BUG "TigerPoint LPC.BM_STS cleared\n"); | |
| 180 | + outw(0x10, pmbase); | |
| 181 | + } | |
| 182 | +} | |
| 183 | +DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TGP_LPC, quirk_tigerpoint_bm_sts); | |
| 184 | + | |
| 165 | 185 | /* |
| 166 | 186 | * Chipsets where PCI->PCI transfers vanish or hang |
| 167 | 187 | */ |
| @@ -595,7 +595,13 @@ int pcmcia_request_io(struct pcmcia_device *p_dev) · 594 unmodified lines | ||
| 595 | 595 | if (c->io[1].end) { |
| 596 | 596 | ret = alloc_io_space(s, &c->io[1], p_dev->io_lines); |
| 597 | 597 | if (ret) { |
| 598 | + struct resource tmp = c->io[0]; | |
| 599 | + /* release the previously allocated resource */ | |
| 598 | 600 | release_io_space(s, &c->io[0]); |
| 601 | + /* but preserve the settings, for they worked... */ | |
| 602 | + c->io[0].end = resource_size(&tmp); | |
| 603 | + c->io[0].start = tmp.start; | |
| 604 | + c->io[0].flags = tmp.flags; | |
| 599 | 605 | goto out; |
| 600 | 606 | } |
| 601 | 607 | } else |
| @@ -646,7 +646,7 @@ static int __devinit pd6729_pci_probe(struct pci_dev *dev, · 645 unmodified lines | ||
| 646 | 646 | if (!pci_resource_start(dev, 0)) { |
| 647 | 647 | dev_warn(&dev->dev, "refusing to load the driver as the " |
| 648 | 648 | "io_base is NULL.\n"); |
| 649 | − goto err_out_free_mem; | |
| 649 | + goto err_out_disable; | |
| 650 | 650 | } |
| 651 | 651 | |
| 652 | 652 | dev_info(&dev->dev, "Cirrus PD6729 PCI to PCMCIA Bridge at 0x%llx " |
| @@ -3093,7 +3093,8 @@ static const struct tpacpi_quirk tpacpi_hotkey_qtable[] __initconst = { · 3092 unmodified lines | ||
| 3093 | 3093 | TPACPI_Q_IBM('1', 'D', TPACPI_HK_Q_INIMASK), /* X22, X23, X24 */ |
| 3094 | 3094 | }; |
| 3095 | 3095 | |
| 3096 | −typedef u16 tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN]; | |
| 3096 | +typedef u16 tpacpi_keymap_entry_t; | |
| 3097 | +typedef tpacpi_keymap_entry_t tpacpi_keymap_t[TPACPI_HOTKEY_MAP_LEN]; | |
| 3097 | 3098 | |
| 3098 | 3099 | static int __init hotkey_init(struct ibm_init_struct *iibm) |
| 3099 | 3100 | { |
| @@ -3230,7 +3231,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm) · 130 unmodified lines | ||
| 3230 | 3231 | }; |
| 3231 | 3232 | |
| 3232 | 3233 | #define TPACPI_HOTKEY_MAP_SIZE sizeof(tpacpi_keymap_t) |
| 3233 | −#define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_t[0]) | |
| 3234 | +#define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(tpacpi_keymap_entry_t) | |
| 3234 | 3235 | |
| 3235 | 3236 | int res, i; |
| 3236 | 3237 | int status; |
| @@ -700,7 +700,7 @@ static void print_constraints(struct regulator_dev *rdev) · 699 unmodified lines | ||
| 700 | 700 | constraints->min_uA != constraints->max_uA) { |
| 701 | 701 | ret = _regulator_get_current_limit(rdev); |
| 702 | 702 | if (ret > 0) |
| 703 | − count += sprintf(buf + count, "at %d uA ", ret / 1000); | |
| 703 | + count += sprintf(buf + count, "at %d mA ", ret / 1000); | |
| 704 | 704 | } |
| 705 | 705 | |
| 706 | 706 | if (constraints->valid_modes_mask & REGULATOR_MODE_FAST) |
| @@ -2302,8 +2302,10 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc, · 1595 unmodified lines | ||
| 2302 | 2302 | dev_set_name(&rdev->dev, "regulator.%d", |
| 2303 | 2303 | atomic_inc_return(®ulator_no) - 1); |
| 2304 | 2304 | ret = device_register(&rdev->dev); |
| 2305 | − if (ret != 0) | |
| 2305 | + if (ret != 0) { | |
| 2306 | + put_device(&rdev->dev); | |
| 2306 | 2307 | goto clean; |
| 2308 | + } | |
| 2307 | 2309 | |
| 2308 | 2310 | dev_set_drvdata(&rdev->dev, rdev); |
| 2309 | 2311 | |
| @@ -330,7 +330,7 @@ static int __devinit max8649_regulator_probe(struct i2c_client *client, · 329 unmodified lines | ||
| 330 | 330 | /* set external clock frequency */ |
| 331 | 331 | info->extclk_freq = pdata->extclk_freq; |
| 332 | 332 | max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK, |
| 333 | − info->extclk_freq); | |
| 333 | + info->extclk_freq << 6); | |
| 334 | 334 | } |
| 335 | 335 | |
| 336 | 336 | if (pdata->ramp_timing) { |
| @@ -235,6 +235,7 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev) · 234 unmodified lines | ||
| 235 | 235 | err = PTR_ERR(rtc); |
| 236 | 236 | return err; |
| 237 | 237 | } |
| 238 | + platform_set_drvdata(pdev, rtc); | |
| 238 | 239 | |
| 239 | 240 | return 0; |
| 240 | 241 | } |
| @@ -244,6 +245,7 @@ static int __exit ab3100_rtc_remove(struct platform_device *pdev) · 3 unmodified lines | ||
| 244 | 245 | struct rtc_device *rtc = platform_get_drvdata(pdev); |
| 245 | 246 | |
| 246 | 247 | rtc_device_unregister(rtc); |
| 248 | + platform_set_drvdata(pdev, NULL); | |
| 247 | 249 | return 0; |
| 248 | 250 | } |
| 249 | 251 | |
| @@ -310,11 +310,6 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) · 309 unmodified lines | ||
| 310 | 310 | |
| 311 | 311 | s3c_rtc_setaie(alrm->enabled); |
| 312 | 312 | |
| 313 | − if (alrm->enabled) | |
| 314 | − enable_irq_wake(s3c_rtc_alarmno); | |
| 315 | − else | |
| 316 | − disable_irq_wake(s3c_rtc_alarmno); | |
| 317 | − | |
| 318 | 313 | return 0; |
| 319 | 314 | } |
| 320 | 315 | |
| @@ -587,6 +582,10 @@ static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state) · 266 unmodified lines | ||
| 587 | 582 | ticnt_en_save &= S3C64XX_RTCCON_TICEN; |
| 588 | 583 | } |
| 589 | 584 | s3c_rtc_enable(pdev, 0); |
| 585 | + | |
| 586 | + if (device_may_wakeup(&pdev->dev)) | |
| 587 | + enable_irq_wake(s3c_rtc_alarmno); | |
| 588 | + | |
| 590 | 589 | return 0; |
| 591 | 590 | } |
| 592 | 591 | |
| @@ -600,6 +599,10 @@ static int s3c_rtc_resume(struct platform_device *pdev) · 7 unmodified lines | ||
| 600 | 599 | tmp = readb(s3c_rtc_base + S3C2410_RTCCON); |
| 601 | 600 | writeb(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON); |
| 602 | 601 | } |
| 602 | + | |
| 603 | + if (device_may_wakeup(&pdev->dev)) | |
| 604 | + disable_irq_wake(s3c_rtc_alarmno); | |
| 605 | + | |
| 603 | 606 | return 0; |
| 604 | 607 | } |
| 605 | 608 | #else |
| @@ -1154,7 +1154,7 @@ static struct net_device *ctcm_init_netdevice(struct ctcm_priv *priv) · 1153 unmodified lines | ||
| 1154 | 1154 | dev_fsm, dev_fsm_len, GFP_KERNEL); |
| 1155 | 1155 | if (priv->fsm == NULL) { |
| 1156 | 1156 | CTCMY_DBF_DEV(SETUP, dev, "init_fsm error"); |
| 1157 | − kfree(dev); | |
| 1157 | + free_netdev(dev); | |
| 1158 | 1158 | return NULL; |
| 1159 | 1159 | } |
| 1160 | 1160 | fsm_newstate(priv->fsm, DEV_STATE_STOPPED); |
| @@ -1165,7 +1165,7 @@ static struct net_device *ctcm_init_netdevice(struct ctcm_priv *priv) · 4 unmodified lines | ||
| 1165 | 1165 | grp = ctcmpc_init_mpc_group(priv); |
| 1166 | 1166 | if (grp == NULL) { |
| 1167 | 1167 | MPC_DBF_DEV(SETUP, dev, "init_mpc_group error"); |
| 1168 | − kfree(dev); | |
| 1168 | + free_netdev(dev); | |
| 1169 | 1169 | return NULL; |
| 1170 | 1170 | } |
| 1171 | 1171 | tasklet_init(&grp->mpc_tasklet2, |
| @@ -27,6 +27,7 @@ · 26 unmodified lines | ||
| 27 | 27 | #include <linux/init.h> |
| 28 | 28 | #include <linux/console.h> |
| 29 | 29 | #include <linux/sysrq.h> |
| 30 | +#include <linux/slab.h> | |
| 30 | 31 | #include <linux/serial_reg.h> |
| 31 | 32 | #include <linux/circ_buf.h> |
| 32 | 33 | #include <linux/delay.h> |
| @@ -29,6 +29,7 @@ · 28 unmodified lines | ||
| 29 | 29 | |
| 30 | 30 | #include <linux/module.h> |
| 31 | 31 | #include <linux/ioport.h> |
| 32 | +#include <linux/irq.h> | |
| 32 | 33 | #include <linux/init.h> |
| 33 | 34 | #include <linux/console.h> |
| 34 | 35 | #include <linux/sysrq.h> |
| @@ -23,6 +23,7 @@ · 22 unmodified lines | ||
| 23 | 23 | #include <linux/init.h> |
| 24 | 24 | #include <linux/cache.h> |
| 25 | 25 | #include <linux/mutex.h> |
| 26 | +#include <linux/of_device.h> | |
| 26 | 27 | #include <linux/slab.h> |
| 27 | 28 | #include <linux/mod_devicetable.h> |
| 28 | 29 | #include <linux/spi/spi.h> |
| @@ -86,6 +87,10 @@ static int spi_match_device(struct device *dev, struct device_driver *drv) · 57 unmodified lines | ||
| 86 | 87 | const struct spi_device *spi = to_spi_device(dev); |
| 87 | 88 | const struct spi_driver *sdrv = to_spi_driver(drv); |
| 88 | 89 | |
| 90 | + /* Attempt an OF style match */ | |
| 91 | + if (of_driver_match_device(dev, drv)) | |
| 92 | + return 1; | |
| 93 | + | |
| 89 | 94 | if (sdrv->id_table) |
| 90 | 95 | return !!spi_match_id(sdrv->id_table, spi); |
| 91 | 96 | |
| @@ -350,7 +350,7 @@ static int __init spi_gpio_probe(struct platform_device *pdev) · 349 unmodified lines | ||
| 350 | 350 | spi_gpio->bitbang.master = spi_master_get(master); |
| 351 | 351 | spi_gpio->bitbang.chipselect = spi_gpio_chipselect; |
| 352 | 352 | |
| 353 | − if ((master_flags & (SPI_MASTER_NO_RX | SPI_MASTER_NO_RX)) == 0) { | |
| 353 | + if ((master_flags & (SPI_MASTER_NO_TX | SPI_MASTER_NO_RX)) == 0) { | |
| 354 | 354 | spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0; |
| 355 | 355 | spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1; |
| 356 | 356 | spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2; |
| @@ -408,11 +408,17 @@ static void mpc8xxx_spi_cpm_bufs_start(struct mpc8xxx_spi *mspi) · 407 unmodified lines | ||
| 408 | 408 | |
| 409 | 409 | xfer_ofs = mspi->xfer_in_progress->len - mspi->count; |
| 410 | 410 | |
| 411 | − out_be32(&rx_bd->cbd_bufaddr, mspi->rx_dma + xfer_ofs); | |
| 411 | + if (mspi->rx_dma == mspi->dma_dummy_rx) | |
| 412 | + out_be32(&rx_bd->cbd_bufaddr, mspi->rx_dma); | |
| 413 | + else | |
| 414 | + out_be32(&rx_bd->cbd_bufaddr, mspi->rx_dma + xfer_ofs); | |
| 412 | 415 | out_be16(&rx_bd->cbd_datlen, 0); |
| 413 | 416 | out_be16(&rx_bd->cbd_sc, BD_SC_EMPTY | BD_SC_INTRPT | BD_SC_WRAP); |
| 414 | 417 | |
| 415 | − out_be32(&tx_bd->cbd_bufaddr, mspi->tx_dma + xfer_ofs); | |
| 418 | + if (mspi->tx_dma == mspi->dma_dummy_tx) | |
| 419 | + out_be32(&tx_bd->cbd_bufaddr, mspi->tx_dma); | |
| 420 | + else | |
| 421 | + out_be32(&tx_bd->cbd_bufaddr, mspi->tx_dma + xfer_ofs); | |
| 416 | 422 | out_be16(&tx_bd->cbd_datlen, xfer_len); |
| 417 | 423 | out_be16(&tx_bd->cbd_sc, BD_SC_READY | BD_SC_INTRPT | BD_SC_WRAP | |
| 418 | 424 | BD_SC_LAST); |
| @@ -80,5 +80,4 @@ struct st_proto_s { · 79 unmodified lines | ||
| 80 | 80 | extern long st_register(struct st_proto_s *); |
| 81 | 81 | extern long st_unregister(enum proto_type); |
| 82 | 82 | |
| 83 | −extern struct platform_device *st_get_plat_device(void); | |
| 84 | 83 | #endif /* ST_H */ |
| @@ -38,7 +38,6 @@ · 37 unmodified lines | ||
| 38 | 38 | #include "st_ll.h" |
| 39 | 39 | #include "st.h" |
| 40 | 40 | |
| 41 | −#define VERBOSE | |
| 42 | 41 | /* strings to be used for rfkill entries and by |
| 43 | 42 | * ST Core to be used for sysfs debug entry |
| 44 | 43 | */ |
| @@ -581,7 +580,7 @@ long st_register(struct st_proto_s *new_proto) · 536 unmodified lines | ||
| 581 | 580 | long err = 0; |
| 582 | 581 | unsigned long flags = 0; |
| 583 | 582 | |
| 584 | − st_kim_ref(&st_gdata); | |
| 583 | + st_kim_ref(&st_gdata, 0); | |
| 585 | 584 | pr_info("%s(%d) ", __func__, new_proto->type); |
| 586 | 585 | if (st_gdata == NULL || new_proto == NULL || new_proto->recv == NULL |
| 587 | 586 | || new_proto->reg_complete_cb == NULL) { |
| @@ -713,7 +712,7 @@ long st_unregister(enum proto_type type) · 125 unmodified lines | ||
| 713 | 712 | |
| 714 | 713 | pr_debug("%s: %d ", __func__, type); |
| 715 | 714 | |
| 716 | − st_kim_ref(&st_gdata); | |
| 715 | + st_kim_ref(&st_gdata, 0); | |
| 717 | 716 | if (type < ST_BT || type >= ST_MAX) { |
| 718 | 717 | pr_err(" protocol %d not supported", type); |
| 719 | 718 | return -EPROTONOSUPPORT; |
| @@ -767,7 +766,7 @@ long st_write(struct sk_buff *skb) · 47 unmodified lines | ||
| 767 | 766 | #endif |
| 768 | 767 | long len; |
| 769 | 768 | |
| 770 | − st_kim_ref(&st_gdata); | |
| 769 | + st_kim_ref(&st_gdata, 0); | |
| 771 | 770 | if (unlikely(skb == NULL || st_gdata == NULL |
| 772 | 771 | || st_gdata->tty == NULL)) { |
| 773 | 772 | pr_err("data/tty unavailable to perform write"); |
| @@ -818,7 +817,7 @@ static int st_tty_open(struct tty_struct *tty) · 44 unmodified lines | ||
| 818 | 817 | struct st_data_s *st_gdata; |
| 819 | 818 | pr_info("%s ", __func__); |
| 820 | 819 | |
| 821 | − st_kim_ref(&st_gdata); | |
| 820 | + st_kim_ref(&st_gdata, 0); | |
| 822 | 821 | st_gdata->tty = tty; |
| 823 | 822 | tty->disc_data = st_gdata; |
| 824 | 823 | |
| @@ -117,7 +117,7 @@ int st_core_init(struct st_data_s **); · 116 unmodified lines | ||
| 117 | 117 | void st_core_exit(struct st_data_s *); |
| 118 | 118 | |
| 119 | 119 | /* ask for reference from KIM */ |
| 120 | −void st_kim_ref(struct st_data_s **); | |
| 120 | +void st_kim_ref(struct st_data_s **, int); | |
| 121 | 121 | |
| 122 | 122 | #define GPS_STUB_TEST |
| 123 | 123 | #ifdef GPS_STUB_TEST |
| @@ -72,10 +72,25 @@ const unsigned char *protocol_names[] = { · 71 unmodified lines | ||
| 72 | 72 | PROTO_ENTRY(ST_GPS, "GPS"), |
| 73 | 73 | }; |
| 74 | 74 | |
| 75 | +#define MAX_ST_DEVICES 3 /* Imagine 1 on each UART for now */ | |
| 76 | +struct platform_device *st_kim_devices[MAX_ST_DEVICES]; | |
| 75 | 77 | |
| 76 | 78 | /**********************************************************************/ |
| 77 | 79 | /* internal functions */ |
| 78 | 80 | |
| 81 | +/** | |
| 82 | + * st_get_plat_device - | |
| 83 | + * function which returns the reference to the platform device | |
| 84 | + * requested by id. As of now only 1 such device exists (id=0) | |
| 85 | + * the context requesting for reference can get the id to be | |
| 86 | + * requested by a. The protocol driver which is registering or | |
| 87 | + * b. the tty device which is opened. | |
| 88 | + */ | |
| 89 | +static struct platform_device *st_get_plat_device(int id) | |
| 90 | +{ | |
| 91 | + return st_kim_devices[id]; | |
| 92 | +} | |
| 93 | + | |
| 79 | 94 | /** |
| 80 | 95 | * validate_firmware_response - |
| 81 | 96 | * function to return whether the firmware response was proper |
| @@ -353,7 +368,7 @@ void st_kim_chip_toggle(enum proto_type type, enum kim_gpio_state state) · 271 unmodified lines | ||
| 353 | 368 | struct kim_data_s *kim_gdata; |
| 354 | 369 | pr_info(" %s ", __func__); |
| 355 | 370 | |
| 356 | − kim_pdev = st_get_plat_device(); | |
| 371 | + kim_pdev = st_get_plat_device(0); | |
| 357 | 372 | kim_gdata = dev_get_drvdata(&kim_pdev->dev); |
| 358 | 373 | |
| 359 | 374 | if (kim_gdata->gpios[type] == -1) { |
| @@ -574,12 +589,12 @@ static int kim_toggle_radio(void *data, bool blocked) · 214 unmodified lines | ||
| 574 | 589 | * This would enable multiple such platform devices to exist |
| 575 | 590 | * on a given platform |
| 576 | 591 | */ |
| 577 | −void st_kim_ref(struct st_data_s **core_data) | |
| 592 | +void st_kim_ref(struct st_data_s **core_data, int id) | |
| 578 | 593 | { |
| 579 | 594 | struct platform_device *pdev; |
| 580 | 595 | struct kim_data_s *kim_gdata; |
| 581 | 596 | /* get kim_gdata reference from platform device */ |
| 582 | − pdev = st_get_plat_device(); | |
| 597 | + pdev = st_get_plat_device(id); | |
| 583 | 598 | kim_gdata = dev_get_drvdata(&pdev->dev); |
| 584 | 599 | *core_data = kim_gdata->core_data; |
| 585 | 600 | } |
| @@ -623,6 +638,7 @@ static int kim_probe(struct platform_device *pdev) · 37 unmodified lines | ||
| 623 | 638 | long *gpios = pdev->dev.platform_data; |
| 624 | 639 | struct kim_data_s *kim_gdata; |
| 625 | 640 | |
| 641 | + st_kim_devices[pdev->id] = pdev; | |
| 626 | 642 | kim_gdata = kzalloc(sizeof(struct kim_data_s), GFP_ATOMIC); |
| 627 | 643 | if (!kim_gdata) { |
| 628 | 644 | pr_err("no mem to allocate"); |
| @@ -91,12 +91,12 @@ config USB_DYNAMIC_MINORS · 90 unmodified lines | ||
| 91 | 91 | If you are unsure about this, say N here. |
| 92 | 92 | |
| 93 | 93 | config USB_SUSPEND |
| 94 | − bool "USB runtime power management (suspend/resume and wakeup)" | |
| 94 | + bool "USB runtime power management (autosuspend) and wakeup" | |
| 95 | 95 | depends on USB && PM_RUNTIME |
| 96 | 96 | help |
| 97 | 97 | If you say Y here, you can use driver calls or the sysfs |
| 98 | − "power/level" file to suspend or resume individual USB | |
| 99 | − peripherals and to enable or disable autosuspend (see | |
| 98 | + "power/control" file to enable or disable autosuspend for | |
| 99 | + individual USB peripherals (see | |
| 100 | 100 | Documentation/usb/power-management.txt for more details). |
| 101 | 101 | |
| 102 | 102 | Also, USB "remote wakeup" signaling is supported, whereby some |
| @@ -159,9 +159,9 @@ void usb_major_cleanup(void) · 158 unmodified lines | ||
| 159 | 159 | int usb_register_dev(struct usb_interface *intf, |
| 160 | 160 | struct usb_class_driver *class_driver) |
| 161 | 161 | { |
| 162 | − int retval = -EINVAL; | |
| 162 | + int retval; | |
| 163 | 163 | int minor_base = class_driver->minor_base; |
| 164 | − int minor = 0; | |
| 164 | + int minor; | |
| 165 | 165 | char name[20]; |
| 166 | 166 | char *temp; |
| 167 | 167 | |
| @@ -173,12 +173,17 @@ int usb_register_dev(struct usb_interface *intf, · 5 unmodified lines | ||
| 173 | 173 | */ |
| 174 | 174 | minor_base = 0; |
| 175 | 175 | #endif |
| 176 | − intf->minor = -1; | |
| 177 | − | |
| 178 | − dbg ("looking for a minor, starting at %d", minor_base); | |
| 179 | 176 | |
| 180 | 177 | if (class_driver->fops == NULL) |
| 181 | − goto exit; | |
| 178 | + return -EINVAL; | |
| 179 | + if (intf->minor >= 0) | |
| 180 | + return -EADDRINUSE; | |
| 181 | + | |
| 182 | + retval = init_usb_class(); | |
| 183 | + if (retval) | |
| 184 | + return retval; | |
| 185 | + | |
| 186 | + dev_dbg(&intf->dev, "looking for a minor, starting at %d", minor_base); | |
| 182 | 187 | |
| 183 | 188 | down_write(&minor_rwsem); |
| 184 | 189 | for (minor = minor_base; minor < MAX_USB_MINORS; ++minor) { |
| @@ -186,20 +191,12 @@ int usb_register_dev(struct usb_interface *intf, · 1 unmodified line | ||
| 186 | 191 | continue; |
| 187 | 192 | |
| 188 | 193 | usb_minors[minor] = class_driver->fops; |
| 189 | − | |
| 190 | − retval = 0; | |
| 194 | + intf->minor = minor; | |
| 191 | 195 | break; |
| 192 | 196 | } |
| 193 | 197 | up_write(&minor_rwsem); |
| 194 | − | |
| 195 | − if (retval) | |
| 196 | − goto exit; | |
| 197 | − | |
| 198 | − retval = init_usb_class(); | |
| 199 | − if (retval) | |
| 200 | − goto exit; | |
| 201 | − | |
| 202 | − intf->minor = minor; | |
| 198 | + if (intf->minor < 0) | |
| 199 | + return -EXFULL; | |
| 203 | 200 | |
| 204 | 201 | /* create a usb class device for this usb interface */ |
| 205 | 202 | snprintf(name, sizeof(name), class_driver->name, minor - minor_base); |
| @@ -213,11 +210,11 @@ int usb_register_dev(struct usb_interface *intf, · 7 unmodified lines | ||
| 213 | 210 | "%s", temp); |
| 214 | 211 | if (IS_ERR(intf->usb_dev)) { |
| 215 | 212 | down_write(&minor_rwsem); |
| 216 | − usb_minors[intf->minor] = NULL; | |
| 213 | + usb_minors[minor] = NULL; | |
| 214 | + intf->minor = -1; | |
| 217 | 215 | up_write(&minor_rwsem); |
| 218 | 216 | retval = PTR_ERR(intf->usb_dev); |
| 219 | 217 | } |
| 220 | −exit: | |
| 221 | 218 | return retval; |
| 222 | 219 | } |
| 223 | 220 | EXPORT_SYMBOL_GPL(usb_register_dev); |
| @@ -1802,6 +1802,7 @@ free_interfaces: · 1801 unmodified lines | ||
| 1802 | 1802 | intf->dev.groups = usb_interface_groups; |
| 1803 | 1803 | intf->dev.dma_mask = dev->dev.dma_mask; |
| 1804 | 1804 | INIT_WORK(&intf->reset_ws, __usb_queue_reset_device); |
| 1805 | + intf->minor = -1; | |
| 1805 | 1806 | device_initialize(&intf->dev); |
| 1806 | 1807 | dev_set_name(&intf->dev, "%d-%s:%d.%d", |
| 1807 | 1808 | dev->bus->busnum, dev->devpath, |
| @@ -322,6 +322,7 @@ cppi_channel_allocate(struct dma_controller *c, · 321 unmodified lines | ||
| 322 | 322 | index, transmit ? 'T' : 'R', cppi_ch); |
| 323 | 323 | cppi_ch->hw_ep = ep; |
| 324 | 324 | cppi_ch->channel.status = MUSB_DMA_STATUS_FREE; |
| 325 | + cppi_ch->channel.max_len = 0x7fffffff; | |
| 325 | 326 | |
| 326 | 327 | DBG(4, "Allocate CPPI%d %cX\n", index, transmit ? 'T' : 'R'); |
| 327 | 328 | return &cppi_ch->channel; |
| @@ -300,6 +300,11 @@ static void txstate(struct musb *musb, struct musb_request *req) · 299 unmodified lines | ||
| 300 | 300 | #ifndef CONFIG_MUSB_PIO_ONLY |
| 301 | 301 | if (is_dma_capable() && musb_ep->dma) { |
| 302 | 302 | struct dma_controller *c = musb->dma_controller; |
| 303 | + size_t request_size; | |
| 304 | + | |
| 305 | + /* setup DMA, then program endpoint CSR */ | |
| 306 | + request_size = min_t(size_t, request->length - request->actual, | |
| 307 | + musb_ep->dma->max_len); | |
| 303 | 308 | |
| 304 | 309 | use_dma = (request->dma != DMA_ADDR_INVALID); |
| 305 | 310 | |
| @@ -307,11 +312,6 @@ static void txstate(struct musb *musb, struct musb_request *req) · 1 unmodified line | ||
| 307 | 312 | |
| 308 | 313 | #ifdef CONFIG_USB_INVENTRA_DMA |
| 309 | 314 | { |
| 310 | − size_t request_size; | |
| 311 | − | |
| 312 | − /* setup DMA, then program endpoint CSR */ | |
| 313 | − request_size = min_t(size_t, request->length, | |
| 314 | − musb_ep->dma->max_len); | |
| 315 | 315 | if (request_size < musb_ep->packet_sz) |
| 316 | 316 | musb_ep->dma->desired_mode = 0; |
| 317 | 317 | else |
| @@ -373,8 +373,8 @@ static void txstate(struct musb *musb, struct musb_request *req) · 55 unmodified lines | ||
| 373 | 373 | use_dma = use_dma && c->channel_program( |
| 374 | 374 | musb_ep->dma, musb_ep->packet_sz, |
| 375 | 375 | 0, |
| 376 | − request->dma, | |
| 377 | − request->length); | |
| 376 | + request->dma + request->actual, | |
| 377 | + request_size); | |
| 378 | 378 | if (!use_dma) { |
| 379 | 379 | c->channel_release(musb_ep->dma); |
| 380 | 380 | musb_ep->dma = NULL; |
| @@ -386,8 +386,8 @@ static void txstate(struct musb *musb, struct musb_request *req) · 5 unmodified lines | ||
| 386 | 386 | use_dma = use_dma && c->channel_program( |
| 387 | 387 | musb_ep->dma, musb_ep->packet_sz, |
| 388 | 388 | request->zero, |
| 389 | − request->dma, | |
| 390 | − request->length); | |
| 389 | + request->dma + request->actual, | |
| 390 | + request_size); | |
| 391 | 391 | #endif |
| 392 | 392 | } |
| 393 | 393 | #endif |
| @@ -501,26 +501,14 @@ void musb_g_tx(struct musb *musb, u8 epnum) · 107 unmodified lines | ||
| 501 | 501 | request->zero = 0; |
| 502 | 502 | } |
| 503 | 503 | |
| 504 | − /* ... or if not, then complete it. */ | |
| 505 | − musb_g_giveback(musb_ep, request, 0); | |
| 506 | − | |
| 507 | − /* | |
| 508 | − * Kickstart next transfer if appropriate; | |
| 509 | − * the packet that just completed might not | |
| 510 | − * be transmitted for hours or days. | |
| 511 | − * REVISIT for double buffering... | |
| 512 | − * FIXME revisit for stalls too... | |
| 513 | − */ | |
| 514 | − musb_ep_select(mbase, epnum); | |
| 515 | − csr = musb_readw(epio, MUSB_TXCSR); | |
| 516 | − if (csr & MUSB_TXCSR_FIFONOTEMPTY) | |
| 517 | − return; | |
| 518 | − | |
| 519 | − request = musb_ep->desc ? next_request(musb_ep) : NULL; | |
| 520 | − if (!request) { | |
| 521 | − DBG(4, "%s idle now\n", | |
| 522 | − musb_ep->end_point.name); | |
| 523 | − return; | |
| 504 | + if (request->actual == request->length) { | |
| 505 | + musb_g_giveback(musb_ep, request, 0); | |
| 506 | + request = musb_ep->desc ? next_request(musb_ep) : NULL; | |
| 507 | + if (!request) { | |
| 508 | + DBG(4, "%s idle now\n", | |
| 509 | + musb_ep->end_point.name); | |
| 510 | + return; | |
| 511 | + } | |
| 524 | 512 | } |
| 525 | 513 | } |
| 526 | 514 | |
| @@ -568,11 +556,19 @@ static void rxstate(struct musb *musb, struct musb_request *req) · 41 unmodified lines | ||
| 568 | 556 | { |
| 569 | 557 | const u8 epnum = req->epnum; |
| 570 | 558 | struct usb_request *request = &req->request; |
| 571 | − struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out; | |
| 559 | + struct musb_ep *musb_ep; | |
| 572 | 560 | void __iomem *epio = musb->endpoints[epnum].regs; |
| 573 | 561 | unsigned fifo_count = 0; |
| 574 | − u16 len = musb_ep->packet_sz; | |
| 562 | + u16 len; | |
| 575 | 563 | u16 csr = musb_readw(epio, MUSB_RXCSR); |
| 564 | + struct musb_hw_ep *hw_ep = &musb->endpoints[epnum]; | |
| 565 | + | |
| 566 | + if (hw_ep->is_shared_fifo) | |
| 567 | + musb_ep = &hw_ep->ep_in; | |
| 568 | + else | |
| 569 | + musb_ep = &hw_ep->ep_out; | |
| 570 | + | |
| 571 | + len = musb_ep->packet_sz; | |
| 576 | 572 | |
| 577 | 573 | /* We shouldn't get here while DMA is active, but we do... */ |
| 578 | 574 | if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) { |
| @@ -647,8 +643,8 @@ static void rxstate(struct musb *musb, struct musb_request *req) · 68 unmodified lines | ||
| 647 | 643 | */ |
| 648 | 644 | |
| 649 | 645 | csr |= MUSB_RXCSR_DMAENAB; |
| 650 | −#ifdef USE_MODE1 | |
| 651 | 646 | csr |= MUSB_RXCSR_AUTOCLEAR; |
| 647 | +#ifdef USE_MODE1 | |
| 652 | 648 | /* csr |= MUSB_RXCSR_DMAMODE; */ |
| 653 | 649 | |
| 654 | 650 | /* this special sequence (enabling and then |
| @@ -663,10 +659,11 @@ static void rxstate(struct musb *musb, struct musb_request *req) · 8 unmodified lines | ||
| 663 | 659 | if (request->actual < request->length) { |
| 664 | 660 | int transfer_size = 0; |
| 665 | 661 | #ifdef USE_MODE1 |
| 666 | − transfer_size = min(request->length, | |
| 662 | + transfer_size = min(request->length - request->actual, | |
| 667 | 663 | channel->max_len); |
| 668 | 664 | #else |
| 669 | − transfer_size = len; | |
| 665 | + transfer_size = min(request->length - request->actual, | |
| 666 | + (unsigned)len); | |
| 670 | 667 | #endif |
| 671 | 668 | if (transfer_size <= musb_ep->packet_sz) |
| 672 | 669 | musb_ep->dma->desired_mode = 0; |
| @@ -740,9 +737,15 @@ void musb_g_rx(struct musb *musb, u8 epnum) · 67 unmodified lines | ||
| 740 | 737 | u16 csr; |
| 741 | 738 | struct usb_request *request; |
| 742 | 739 | void __iomem *mbase = musb->mregs; |
| 743 | − struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out; | |
| 740 | + struct musb_ep *musb_ep; | |
| 744 | 741 | void __iomem *epio = musb->endpoints[epnum].regs; |
| 745 | 742 | struct dma_channel *dma; |
| 743 | + struct musb_hw_ep *hw_ep = &musb->endpoints[epnum]; | |
| 744 | + | |
| 745 | + if (hw_ep->is_shared_fifo) | |
| 746 | + musb_ep = &hw_ep->ep_in; | |
| 747 | + else | |
| 748 | + musb_ep = &hw_ep->ep_out; | |
| 746 | 749 | |
| 747 | 750 | musb_ep_select(mbase, epnum); |
| 748 | 751 | |
| @@ -1081,7 +1084,7 @@ struct free_record { · 332 unmodified lines | ||
| 1081 | 1084 | /* |
| 1082 | 1085 | * Context: controller locked, IRQs blocked. |
| 1083 | 1086 | */ |
| 1084 | −static void musb_ep_restart(struct musb *musb, struct musb_request *req) | |
| 1087 | +void musb_ep_restart(struct musb *musb, struct musb_request *req) | |
| 1085 | 1088 | { |
| 1086 | 1089 | DBG(3, "<== %s request %p len %u on hw_ep%d\n", |
| 1087 | 1090 | req->tx ? "TX/IN" : "RX/OUT", |
| @@ -105,4 +105,6 @@ extern void musb_gadget_cleanup(struct musb *); · 104 unmodified lines | ||
| 105 | 105 | |
| 106 | 106 | extern void musb_g_giveback(struct musb_ep *, struct usb_request *, int); |
| 107 | 107 | |
| 108 | +extern void musb_ep_restart(struct musb *, struct musb_request *); | |
| 109 | + | |
| 108 | 110 | #endif /* __MUSB_GADGET_H */ |
| @@ -261,6 +261,7 @@ __acquires(musb->lock) · 260 unmodified lines | ||
| 261 | 261 | ctrlrequest->wIndex & 0x0f; |
| 262 | 262 | struct musb_ep *musb_ep; |
| 263 | 263 | struct musb_hw_ep *ep; |
| 264 | + struct musb_request *request; | |
| 264 | 265 | void __iomem *regs; |
| 265 | 266 | int is_in; |
| 266 | 267 | u16 csr; |
| @@ -302,6 +303,14 @@ __acquires(musb->lock) · 35 unmodified lines | ||
| 302 | 303 | musb_writew(regs, MUSB_RXCSR, csr); |
| 303 | 304 | } |
| 304 | 305 | |
| 306 | + /* Maybe start the first request in the queue */ | |
| 307 | + request = to_musb_request( | |
| 308 | + next_request(musb_ep)); | |
| 309 | + if (!musb_ep->busy && request) { | |
| 310 | + DBG(3, "restarting the request\n"); | |
| 311 | + musb_ep_restart(musb, request); | |
| 312 | + } | |
| 313 | + | |
| 305 | 314 | /* select ep0 again */ |
| 306 | 315 | musb_ep_select(mbase, 0); |
| 307 | 316 | } break; |
| @@ -660,6 +660,12 @@ static bool musb_tx_dma_program(struct dma_controller *dma, · 659 unmodified lines | ||
| 660 | 660 | |
| 661 | 661 | qh->segsize = length; |
| 662 | 662 | |
| 663 | + /* | |
| 664 | + * Ensure the data reaches to main memory before starting | |
| 665 | + * DMA transfer | |
| 666 | + */ | |
| 667 | + wmb(); | |
| 668 | + | |
| 663 | 669 | if (!dma->channel_program(channel, pkt_size, mode, |
| 664 | 670 | urb->transfer_dma + offset, length)) { |
| 665 | 671 | dma->channel_release(channel); |
| @@ -243,7 +243,7 @@ static int get_rx_bufs(struct vhost_virtqueue *vq, · 242 unmodified lines | ||
| 243 | 243 | int r, nlogs = 0; |
| 244 | 244 | |
| 245 | 245 | while (datalen > 0) { |
| 246 | − if (unlikely(headcount >= VHOST_NET_MAX_SG)) { | |
| 246 | + if (unlikely(seg >= VHOST_NET_MAX_SG)) { | |
| 247 | 247 | r = -ENOBUFS; |
| 248 | 248 | goto err; |
| 249 | 249 | } |
| @@ -858,11 +858,12 @@ int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log, · 857 unmodified lines | ||
| 858 | 858 | if (r < 0) |
| 859 | 859 | return r; |
| 860 | 860 | len -= l; |
| 861 | − if (!len) | |
| 861 | + if (!len) { | |
| 862 | + if (vq->log_ctx) | |
| 863 | + eventfd_signal(vq->log_ctx, 1); | |
| 862 | 864 | return 0; |
| 865 | + } | |
| 863 | 866 | } |
| 864 | − if (vq->log_ctx) | |
| 865 | − eventfd_signal(vq->log_ctx, 1); | |
| 866 | 867 | /* Length written exceeds what we have stored. This is a bug. */ |
| 867 | 868 | BUG(); |
| 868 | 869 | return 0; |
| @@ -3508,7 +3508,7 @@ static void fbcon_exit(void) · 3507 unmodified lines | ||
| 3508 | 3508 | softback_buf = 0UL; |
| 3509 | 3509 | |
| 3510 | 3510 | for (i = 0; i < FB_MAX; i++) { |
| 3511 | − int pending; | |
| 3511 | + int pending = 0; | |
| 3512 | 3512 | |
| 3513 | 3513 | mapped = 0; |
| 3514 | 3514 | info = registered_fb[i]; |
| @@ -3516,7 +3516,8 @@ static void fbcon_exit(void) · 1 unmodified line | ||
| 3516 | 3516 | if (info == NULL) |
| 3517 | 3517 | continue; |
| 3518 | 3518 | |
| 3519 | − pending = cancel_work_sync(&info->queue); | |
| 3519 | + if (info->queue.func) | |
| 3520 | + pending = cancel_work_sync(&info->queue); | |
| 3520 | 3521 | DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : |
| 3521 | 3522 | "no")); |
| 3522 | 3523 | |
| @@ -13,7 +13,7 @@ · 12 unmodified lines | ||
| 13 | 13 | #include <linux/platform_device.h> |
| 14 | 14 | #include <linux/screen_info.h> |
| 15 | 15 | #include <linux/dmi.h> |
| 16 | − | |
| 16 | +#include <linux/pci.h> | |
| 17 | 17 | #include <video/vga.h> |
| 18 | 18 | |
| 19 | 19 | static struct fb_var_screeninfo efifb_defined __devinitdata = { |
| @@ -39,17 +39,31 @@ enum { · 19 unmodified lines | ||
| 39 | 39 | M_I20, /* 20-Inch iMac */ |
| 40 | 40 | M_I20_SR, /* 20-Inch iMac (Santa Rosa) */ |
| 41 | 41 | M_I24, /* 24-Inch iMac */ |
| 42 | + M_I24_8_1, /* 24-Inch iMac, 8,1th gen */ | |
| 43 | + M_I24_10_1, /* 24-Inch iMac, 10,1th gen */ | |
| 44 | + M_I27_11_1, /* 27-Inch iMac, 11,1th gen */ | |
| 42 | 45 | M_MINI, /* Mac Mini */ |
| 46 | + M_MINI_3_1, /* Mac Mini, 3,1th gen */ | |
| 47 | + M_MINI_4_1, /* Mac Mini, 4,1th gen */ | |
| 43 | 48 | M_MB, /* MacBook */ |
| 44 | 49 | M_MB_2, /* MacBook, 2nd rev. */ |
| 45 | 50 | M_MB_3, /* MacBook, 3rd rev. */ |
| 51 | + M_MB_5_1, /* MacBook, 5th rev. */ | |
| 52 | + M_MB_6_1, /* MacBook, 6th rev. */ | |
| 53 | + M_MB_7_1, /* MacBook, 7th rev. */ | |
| 46 | 54 | M_MB_SR, /* MacBook, 2nd gen, (Santa Rosa) */ |
| 47 | 55 | M_MBA, /* MacBook Air */ |
| 48 | 56 | M_MBP, /* MacBook Pro */ |
| 49 | 57 | M_MBP_2, /* MacBook Pro 2nd gen */ |
| 58 | + M_MBP_2_2, /* MacBook Pro 2,2nd gen */ | |
| 50 | 59 | M_MBP_SR, /* MacBook Pro (Santa Rosa) */ |
| 51 | 60 | M_MBP_4, /* MacBook Pro, 4th gen */ |
| 52 | 61 | M_MBP_5_1, /* MacBook Pro, 5,1th gen */ |
| 62 | + M_MBP_5_2, /* MacBook Pro, 5,2th gen */ | |
| 63 | + M_MBP_5_3, /* MacBook Pro, 5,3rd gen */ | |
| 64 | + M_MBP_6_1, /* MacBook Pro, 6,1th gen */ | |
| 65 | + M_MBP_6_2, /* MacBook Pro, 6,2th gen */ | |
| 66 | + M_MBP_7_1, /* MacBook Pro, 7,1th gen */ | |
| 53 | 67 | M_UNKNOWN /* placeholder */ |
| 54 | 68 | }; |
| 55 | 69 | |
| @@ -64,14 +78,28 @@ static struct efifb_dmi_info { · 8 unmodified lines | ||
| 64 | 78 | [M_I20] = { "i20", 0x80010000, 1728 * 4, 1680, 1050 }, /* guess */ |
| 65 | 79 | [M_I20_SR] = { "imac7", 0x40010000, 1728 * 4, 1680, 1050 }, |
| 66 | 80 | [M_I24] = { "i24", 0x80010000, 2048 * 4, 1920, 1200 }, /* guess */ |
| 81 | + [M_I24_8_1] = { "imac8", 0xc0060000, 2048 * 4, 1920, 1200 }, | |
| 82 | + [M_I24_10_1] = { "imac10", 0xc0010000, 2048 * 4, 1920, 1080 }, | |
| 83 | + [M_I27_11_1] = { "imac11", 0xc0010000, 2560 * 4, 2560, 1440 }, | |
| 67 | 84 | [M_MINI]= { "mini", 0x80000000, 2048 * 4, 1024, 768 }, |
| 85 | + [M_MINI_3_1] = { "mini31", 0x40010000, 1024 * 4, 1024, 768 }, | |
| 86 | + [M_MINI_4_1] = { "mini41", 0xc0010000, 2048 * 4, 1920, 1200 }, | |
| 68 | 87 | [M_MB] = { "macbook", 0x80000000, 2048 * 4, 1280, 800 }, |
| 88 | + [M_MB_5_1] = { "macbook51", 0x80010000, 2048 * 4, 1280, 800 }, | |
| 89 | + [M_MB_6_1] = { "macbook61", 0x80010000, 2048 * 4, 1280, 800 }, | |
| 90 | + [M_MB_7_1] = { "macbook71", 0x80010000, 2048 * 4, 1280, 800 }, | |
| 69 | 91 | [M_MBA] = { "mba", 0x80000000, 2048 * 4, 1280, 800 }, |
| 70 | 92 | [M_MBP] = { "mbp", 0x80010000, 1472 * 4, 1440, 900 }, |
| 71 | 93 | [M_MBP_2] = { "mbp2", 0, 0, 0, 0 }, /* placeholder */ |
| 94 | + [M_MBP_2_2] = { "mbp22", 0x80010000, 1472 * 4, 1440, 900 }, | |
| 72 | 95 | [M_MBP_SR] = { "mbp3", 0x80030000, 2048 * 4, 1440, 900 }, |
| 73 | 96 | [M_MBP_4] = { "mbp4", 0xc0060000, 2048 * 4, 1920, 1200 }, |
| 74 | 97 | [M_MBP_5_1] = { "mbp51", 0xc0010000, 2048 * 4, 1440, 900 }, |
| 98 | + [M_MBP_5_2] = { "mbp52", 0xc0010000, 2048 * 4, 1920, 1200 }, | |
| 99 | + [M_MBP_5_3] = { "mbp53", 0xd0010000, 2048 * 4, 1440, 900 }, | |
| 100 | + [M_MBP_6_1] = { "mbp61", 0x90030000, 2048 * 4, 1920, 1200 }, | |
| 101 | + [M_MBP_6_2] = { "mbp62", 0x90030000, 2048 * 4, 1680, 1050 }, | |
| 102 | + [M_MBP_7_1] = { "mbp71", 0xc0010000, 2048 * 4, 1280, 800 }, | |
| 75 | 103 | [M_UNKNOWN] = { NULL, 0, 0, 0, 0 } |
| 76 | 104 | }; |
| 77 | 105 | |
| @@ -92,7 +120,12 @@ static const struct dmi_system_id dmi_system_table[] __initconst = { · 14 unmodified lines | ||
| 92 | 120 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "iMac6,1", M_I24), |
| 93 | 121 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "iMac6,1", M_I24), |
| 94 | 122 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "iMac7,1", M_I20_SR), |
| 123 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "iMac8,1", M_I24_8_1), | |
| 124 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "iMac10,1", M_I24_10_1), | |
| 125 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "iMac11,1", M_I27_11_1), | |
| 95 | 126 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "Macmini1,1", M_MINI), |
| 127 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "Macmini3,1", M_MINI_3_1), | |
| 128 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "Macmini4,1", M_MINI_4_1), | |
| 96 | 129 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBook1,1", M_MB), |
| 97 | 130 | /* At least one of these two will be right; maybe both? */ |
| 98 | 131 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBook2,1", M_MB), |
| @@ -101,14 +134,23 @@ static const struct dmi_system_id dmi_system_table[] __initconst = { · 2 unmodified lines | ||
| 101 | 134 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBook3,1", M_MB), |
| 102 | 135 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook3,1", M_MB), |
| 103 | 136 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook4,1", M_MB), |
| 137 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook5,1", M_MB_5_1), | |
| 138 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook6,1", M_MB_6_1), | |
| 139 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBook7,1", M_MB_7_1), | |
| 104 | 140 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookAir1,1", M_MBA), |
| 105 | 141 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro1,1", M_MBP), |
| 106 | 142 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro2,1", M_MBP_2), |
| 143 | + EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro2,2", M_MBP_2_2), | |
| 107 | 144 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro2,1", M_MBP_2), |
| 108 | 145 | EFIFB_DMI_SYSTEM_ID("Apple Computer, Inc.", "MacBookPro3,1", M_MBP_SR), |
| 109 | 146 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro3,1", M_MBP_SR), |
| 110 | 147 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro4,1", M_MBP_4), |
| 111 | 148 | EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro5,1", M_MBP_5_1), |
| 149 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro5,2", M_MBP_5_2), | |
| 150 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro5,3", M_MBP_5_3), | |
| 151 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro6,1", M_MBP_6_1), | |
| 152 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro6,2", M_MBP_6_2), | |
| 153 | + EFIFB_DMI_SYSTEM_ID("Apple Inc.", "MacBookPro7,1", M_MBP_7_1), | |
| 112 | 154 | {}, |
| 113 | 155 | }; |
| 114 | 156 | |
| @@ -116,7 +158,7 @@ static int set_system(const struct dmi_system_id *id) · 1 unmodified line | ||
| 116 | 158 | { |
| 117 | 159 | struct efifb_dmi_info *info = id->driver_data; |
| 118 | 160 | if (info->base == 0) |
| 119 | − return -ENODEV; | |
| 161 | + return 0; | |
| 120 | 162 | |
| 121 | 163 | printk(KERN_INFO "efifb: dmi detected %s - framebuffer at %p " |
| 122 | 164 | "(%dx%d, stride %d)\n", id->ident, |
| @@ -124,18 +166,55 @@ static int set_system(const struct dmi_system_id *id) · 1 unmodified line | ||
| 124 | 166 | info->stride); |
| 125 | 167 | |
| 126 | 168 | /* Trust the bootloader over the DMI tables */ |
| 127 | − if (screen_info.lfb_base == 0) | |
| 169 | + if (screen_info.lfb_base == 0) { | |
| 170 | +#if defined(CONFIG_PCI) | |
| 171 | + struct pci_dev *dev = NULL; | |
| 172 | + int found_bar = 0; | |
| 173 | +#endif | |
| 128 | 174 | screen_info.lfb_base = info->base; |
| 129 | − if (screen_info.lfb_linelength == 0) | |
| 130 | − screen_info.lfb_linelength = info->stride; | |
| 131 | − if (screen_info.lfb_width == 0) | |
| 132 | − screen_info.lfb_width = info->width; | |
| 133 | − if (screen_info.lfb_height == 0) | |
| 134 | − screen_info.lfb_height = info->height; | |
| 135 | − if (screen_info.orig_video_isVGA == 0) | |
| 136 | − screen_info.orig_video_isVGA = VIDEO_TYPE_EFI; | |
| 137 | 175 | |
| 138 | − return 0; | |
| 176 | +#if defined(CONFIG_PCI) | |
| 177 | + /* make sure that the address in the table is actually on a | |
| 178 | + * VGA device's PCI BAR */ | |
| 179 | + | |
| 180 | + for_each_pci_dev(dev) { | |
| 181 | + int i; | |
| 182 | + if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) | |
| 183 | + continue; | |
| 184 | + for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { | |
| 185 | + resource_size_t start, end; | |
| 186 | + | |
| 187 | + start = pci_resource_start(dev, i); | |
| 188 | + if (start == 0) | |
| 189 | + break; | |
| 190 | + end = pci_resource_end(dev, i); | |
| 191 | + if (screen_info.lfb_base >= start && | |
| 192 | + screen_info.lfb_base < end) { | |
| 193 | + found_bar = 1; | |
| 194 | + } | |
| 195 | + } | |
| 196 | + } | |
| 197 | + if (!found_bar) | |
| 198 | + screen_info.lfb_base = 0; | |
| 199 | +#endif | |
| 200 | + } | |
| 201 | + if (screen_info.lfb_base) { | |
| 202 | + if (screen_info.lfb_linelength == 0) | |
| 203 | + screen_info.lfb_linelength = info->stride; | |
| 204 | + if (screen_info.lfb_width == 0) | |
| 205 | + screen_info.lfb_width = info->width; | |
| 206 | + if (screen_info.lfb_height == 0) | |
| 207 | + screen_info.lfb_height = info->height; | |
| 208 | + if (screen_info.orig_video_isVGA == 0) | |
| 209 | + screen_info.orig_video_isVGA = VIDEO_TYPE_EFI; | |
| 210 | + } else { | |
| 211 | + screen_info.lfb_linelength = 0; | |
| 212 | + screen_info.lfb_width = 0; | |
| 213 | + screen_info.lfb_height = 0; | |
| 214 | + screen_info.orig_video_isVGA = 0; | |
| 215 | + return 0; | |
| 216 | + } | |
| 217 | + return 1; | |
| 139 | 218 | } |
| 140 | 219 | |
| 141 | 220 | static int efifb_setcolreg(unsigned regno, unsigned red, unsigned green, |
| @@ -298,8 +298,8 @@ static void set_dma_control0(struct pxa168fb_info *fbi) · 297 unmodified lines | ||
| 298 | 298 | * Set bit to enable graphics DMA. |
| 299 | 299 | */ |
| 300 | 300 | x = readl(fbi->reg_base + LCD_SPU_DMA_CTRL0); |
| 301 | − x |= fbi->active ? 0x00000100 : 0; | |
| 302 | − fbi->active = 0; | |
| 301 | + x &= ~CFG_GRA_ENA_MASK; | |
| 302 | + x |= fbi->active ? CFG_GRA_ENA(1) : CFG_GRA_ENA(0); | |
| 303 | 303 | |
| 304 | 304 | /* |
| 305 | 305 | * If we are in a pseudo-color mode, we need to enable |
| @@ -1701,6 +1701,9 @@ static int sisfb_ioctl(struct fb_info *info, unsigned int cmd, · 1700 unmodified lines | ||
| 1701 | 1701 | break; |
| 1702 | 1702 | |
| 1703 | 1703 | case FBIOGET_VBLANK: |
| 1704 | + | |
| 1705 | + memset(&sisvbblank, 0, sizeof(struct fb_vblank)); | |
| 1706 | + | |
| 1704 | 1707 | sisvbblank.count = 0; |
| 1705 | 1708 | sisvbblank.flags = sisfb_setupvbblankflags(ivideo, &sisvbblank.vcount, &sisvbblank.hcount); |
| 1706 | 1709 | |
| @@ -755,7 +755,10 @@ int register_xenstore_notifier(struct notifier_block *nb) · 754 unmodified lines | ||
| 755 | 755 | { |
| 756 | 756 | int ret = 0; |
| 757 | 757 | |
| 758 | − blocking_notifier_chain_register(&xenstore_chain, nb); | |
| 758 | + if (xenstored_ready > 0) | |
| 759 | + ret = nb->notifier_call(nb, 0, NULL); | |
| 760 | + else | |
| 761 | + blocking_notifier_chain_register(&xenstore_chain, nb); | |
| 759 | 762 | |
| 760 | 763 | return ret; |
| 761 | 764 | } |
| @@ -769,7 +772,7 @@ EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); · 7 unmodified lines | ||
| 769 | 772 | |
| 770 | 773 | void xenbus_probe(struct work_struct *unused) |
| 771 | 774 | { |
| 772 | − BUG_ON((xenstored_ready <= 0)); | |
| 775 | + xenstored_ready = 1; | |
| 773 | 776 | |
| 774 | 777 | /* Enumerate devices in xenstore and watch for changes. */ |
| 775 | 778 | xenbus_probe_devices(&xenbus_frontend); |
| @@ -835,8 +838,8 @@ static int __init xenbus_init(void) · 59 unmodified lines | ||
| 835 | 838 | xen_store_evtchn = xen_start_info->store_evtchn; |
| 836 | 839 | xen_store_mfn = xen_start_info->store_mfn; |
| 837 | 840 | xen_store_interface = mfn_to_virt(xen_store_mfn); |
| 841 | + xenstored_ready = 1; | |
| 838 | 842 | } |
| 839 | − xenstored_ready = 1; | |
| 840 | 843 | } |
| 841 | 844 | |
| 842 | 845 | /* Initialize the interface to xenstore. */ |
| @@ -712,8 +712,16 @@ static ssize_t aio_run_iocb(struct kiocb *iocb) · 711 unmodified lines | ||
| 712 | 712 | */ |
| 713 | 713 | ret = retry(iocb); |
| 714 | 714 | |
| 715 | − if (ret != -EIOCBRETRY && ret != -EIOCBQUEUED) | |
| 715 | + if (ret != -EIOCBRETRY && ret != -EIOCBQUEUED) { | |
| 716 | + /* | |
| 717 | + * There's no easy way to restart the syscall since other AIO's | |
| 718 | + * may be already running. Just fail this IO with EINTR. | |
| 719 | + */ | |
| 720 | + if (unlikely(ret == -ERESTARTSYS || ret == -ERESTARTNOINTR || | |
| 721 | + ret == -ERESTARTNOHAND || ret == -ERESTART_RESTARTBLOCK)) | |
| 722 | + ret = -EINTR; | |
| 716 | 723 | aio_complete(iocb, ret, 0); |
| 724 | + } | |
| 717 | 725 | out: |
| 718 | 726 | spin_lock_irq(&ctx->ctx_lock); |
| 719 | 727 | |
| @@ -232,7 +232,7 @@ static int · 231 unmodified lines | ||
| 232 | 232 | small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, |
| 233 | 233 | void **request_buf) |
| 234 | 234 | { |
| 235 | − int rc = 0; | |
| 235 | + int rc; | |
| 236 | 236 | |
| 237 | 237 | rc = cifs_reconnect_tcon(tcon, smb_command); |
| 238 | 238 | if (rc) |
| @@ -250,7 +250,7 @@ small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, · 11 unmodified lines | ||
| 250 | 250 | if (tcon != NULL) |
| 251 | 251 | cifs_stats_inc(&tcon->num_smbs_sent); |
| 252 | 252 | |
| 253 | − return rc; | |
| 253 | + return 0; | |
| 254 | 254 | } |
| 255 | 255 | |
| 256 | 256 | int |
| @@ -281,16 +281,9 @@ small_smb_init_no_tc(const int smb_command, const int wct, · 24 unmodified lines | ||
| 281 | 281 | |
| 282 | 282 | /* If the return code is zero, this function must fill in request_buf pointer */ |
| 283 | 283 | static int |
| 284 | −smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, | |
| 285 | − void **request_buf /* returned */ , | |
| 286 | − void **response_buf /* returned */ ) | |
| 284 | +__smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, | |
| 285 | + void **request_buf, void **response_buf) | |
| 287 | 286 | { |
| 288 | − int rc = 0; | |
| 289 | − | |
| 290 | − rc = cifs_reconnect_tcon(tcon, smb_command); | |
| 291 | − if (rc) | |
| 292 | − return rc; | |
| 293 | − | |
| 294 | 287 | *request_buf = cifs_buf_get(); |
| 295 | 288 | if (*request_buf == NULL) { |
| 296 | 289 | /* BB should we add a retry in here if not a writepage? */ |
| @@ -309,7 +302,31 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, · 12 unmodified lines | ||
| 309 | 302 | if (tcon != NULL) |
| 310 | 303 | cifs_stats_inc(&tcon->num_smbs_sent); |
| 311 | 304 | |
| 312 | − return rc; | |
| 305 | + return 0; | |
| 306 | +} | |
| 307 | + | |
| 308 | +/* If the return code is zero, this function must fill in request_buf pointer */ | |
| 309 | +static int | |
| 310 | +smb_init(int smb_command, int wct, struct cifsTconInfo *tcon, | |
| 311 | + void **request_buf, void **response_buf) | |
| 312 | +{ | |
| 313 | + int rc; | |
| 314 | + | |
| 315 | + rc = cifs_reconnect_tcon(tcon, smb_command); | |
| 316 | + if (rc) | |
| 317 | + return rc; | |
| 318 | + | |
| 319 | + return __smb_init(smb_command, wct, tcon, request_buf, response_buf); | |
| 320 | +} | |
| 321 | + | |
| 322 | +static int | |
| 323 | +smb_init_no_reconnect(int smb_command, int wct, struct cifsTconInfo *tcon, | |
| 324 | + void **request_buf, void **response_buf) | |
| 325 | +{ | |
| 326 | + if (tcon->ses->need_reconnect || tcon->need_reconnect) | |
| 327 | + return -EHOSTDOWN; | |
| 328 | + | |
| 329 | + return __smb_init(smb_command, wct, tcon, request_buf, response_buf); | |
| 313 | 330 | } |
| 314 | 331 | |
| 315 | 332 | static int validate_t2(struct smb_t2_rsp *pSMB) |
| @@ -4534,8 +4551,8 @@ CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon) · 4218 unmodified lines | ||
| 4534 | 4551 | |
| 4535 | 4552 | cFYI(1, "In QFSUnixInfo"); |
| 4536 | 4553 | QFSUnixRetry: |
| 4537 | − rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, | |
| 4538 | − (void **) &pSMBr); | |
| 4554 | + rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, | |
| 4555 | + (void **) &pSMB, (void **) &pSMBr); | |
| 4539 | 4556 | if (rc) |
| 4540 | 4557 | return rc; |
| 4541 | 4558 | |
| @@ -4604,8 +4621,8 @@ CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap) · 62 unmodified lines | ||
| 4604 | 4621 | cFYI(1, "In SETFSUnixInfo"); |
| 4605 | 4622 | SETFSUnixRetry: |
| 4606 | 4623 | /* BB switch to small buf init to save memory */ |
| 4607 | − rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB, | |
| 4608 | − (void **) &pSMBr); | |
| 4624 | + rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon, | |
| 4625 | + (void **) &pSMB, (void **) &pSMBr); | |
| 4609 | 4626 | if (rc) |
| 4610 | 4627 | return rc; |
| 4611 | 4628 | |
| @@ -801,6 +801,8 @@ retry_iget5_locked: · 800 unmodified lines | ||
| 801 | 801 | inode->i_flags |= S_NOATIME | S_NOCMTIME; |
| 802 | 802 | if (inode->i_state & I_NEW) { |
| 803 | 803 | inode->i_ino = hash; |
| 804 | + if (S_ISREG(inode->i_mode)) | |
| 805 | + inode->i_data.backing_dev_info = sb->s_bdi; | |
| 804 | 806 | #ifdef CONFIG_CIFS_FSCACHE |
| 805 | 807 | /* initialize per-inode cache cookie pointer */ |
| 806 | 808 | CIFS_I(inode)->fscache = NULL; |
| @@ -1153,7 +1153,7 @@ static ssize_t compat_do_readv_writev(int type, struct file *file, · 1152 unmodified lines | ||
| 1153 | 1153 | { |
| 1154 | 1154 | compat_ssize_t tot_len; |
| 1155 | 1155 | struct iovec iovstack[UIO_FASTIOV]; |
| 1156 | − struct iovec *iov; | |
| 1156 | + struct iovec *iov = iovstack; | |
| 1157 | 1157 | ssize_t ret; |
| 1158 | 1158 | io_fn_t fn; |
| 1159 | 1159 | iov_fn_t fnv; |
| @@ -72,22 +72,11 @@ int writeback_in_progress(struct backing_dev_info *bdi) · 71 unmodified lines | ||
| 72 | 72 | static inline struct backing_dev_info *inode_to_bdi(struct inode *inode) |
| 73 | 73 | { |
| 74 | 74 | struct super_block *sb = inode->i_sb; |
| 75 | − struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info; | |
| 76 | 75 | |
| 77 | − /* | |
| 78 | − * For inodes on standard filesystems, we use superblock's bdi. For | |
| 79 | − * inodes on virtual filesystems, we want to use inode mapping's bdi | |
| 80 | − * because they can possibly point to something useful (think about | |
| 81 | − * block_dev filesystem). | |
| 82 | − */ | |
| 83 | − if (sb->s_bdi && sb->s_bdi != &noop_backing_dev_info) { | |
| 84 | − /* Some device inodes could play dirty tricks. Catch them... */ | |
| 85 | − WARN(bdi != sb->s_bdi && bdi_cap_writeback_dirty(bdi), | |
| 86 | − "Dirtiable inode bdi %s != sb bdi %s\n", | |
| 87 | − bdi->name, sb->s_bdi->name); | |
| 88 | − return sb->s_bdi; | |
| 89 | − } | |
| 90 | − return bdi; | |
| 76 | + if (strcmp(sb->s_type->name, "bdev") == 0) | |
| 77 | + return inode->i_mapping->backing_dev_info; | |
| 78 | + | |
| 79 | + return sb->s_bdi; | |
| 91 | 80 | } |
| 92 | 81 | |
| 93 | 82 | static void bdi_queue_work(struct backing_dev_info *bdi, |
| @@ -1354,7 +1354,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode, · 1353 unmodified lines | ||
| 1354 | 1354 | loff_t file_size; |
| 1355 | 1355 | unsigned int num; |
| 1356 | 1356 | unsigned int offset; |
| 1357 | − size_t total_len; | |
| 1357 | + size_t total_len = 0; | |
| 1358 | 1358 | |
| 1359 | 1359 | req = fuse_get_req(fc); |
| 1360 | 1360 | if (IS_ERR(req)) |
| @@ -209,7 +209,10 @@ static int ocfs2_acl_set_mode(struct inode *inode, struct buffer_head *di_bh, · 208 unmodified lines | ||
| 209 | 209 | } |
| 210 | 210 | |
| 211 | 211 | inode->i_mode = new_mode; |
| 212 | + inode->i_ctime = CURRENT_TIME; | |
| 212 | 213 | di->i_mode = cpu_to_le16(inode->i_mode); |
| 214 | + di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); | |
| 215 | + di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); | |
| 213 | 216 | |
| 214 | 217 | ocfs2_journal_dirty(handle, di_bh); |
| 215 | 218 | |
| @@ -977,7 +977,7 @@ static int o2net_tx_can_proceed(struct o2net_node *nn, · 976 unmodified lines | ||
| 977 | 977 | int o2net_send_message_vec(u32 msg_type, u32 key, struct kvec *caller_vec, |
| 978 | 978 | size_t caller_veclen, u8 target_node, int *status) |
| 979 | 979 | { |
| 980 | − int ret; | |
| 980 | + int ret = 0; | |
| 981 | 981 | struct o2net_msg *msg = NULL; |
| 982 | 982 | size_t veclen, caller_bytes = 0; |
| 983 | 983 | struct kvec *vec = NULL; |
| @@ -3931,6 +3931,15 @@ static int ocfs2_dx_dir_rebalance(struct ocfs2_super *osb, struct inode *dir, · 3930 unmodified lines | ||
| 3931 | 3931 | goto out_commit; |
| 3932 | 3932 | } |
| 3933 | 3933 | |
| 3934 | + cpos = split_hash; | |
| 3935 | + ret = ocfs2_dx_dir_new_cluster(dir, &et, cpos, handle, | |
| 3936 | + data_ac, meta_ac, new_dx_leaves, | |
| 3937 | + num_dx_leaves); | |
| 3938 | + if (ret) { | |
| 3939 | + mlog_errno(ret); | |
| 3940 | + goto out_commit; | |
| 3941 | + } | |
| 3942 | + | |
| 3934 | 3943 | for (i = 0; i < num_dx_leaves; i++) { |
| 3935 | 3944 | ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), |
| 3936 | 3945 | orig_dx_leaves[i], |
| @@ -3939,15 +3948,14 @@ static int ocfs2_dx_dir_rebalance(struct ocfs2_super *osb, struct inode *dir, · 2 unmodified lines | ||
| 3939 | 3948 | mlog_errno(ret); |
| 3940 | 3949 | goto out_commit; |
| 3941 | 3950 | } |
| 3942 | − } | |
| 3943 | 3951 | |
| 3944 | − cpos = split_hash; | |
| 3945 | − ret = ocfs2_dx_dir_new_cluster(dir, &et, cpos, handle, | |
| 3946 | − data_ac, meta_ac, new_dx_leaves, | |
| 3947 | − num_dx_leaves); | |
| 3948 | − if (ret) { | |
| 3949 | − mlog_errno(ret); | |
| 3950 | − goto out_commit; | |
| 3952 | + ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), | |
| 3953 | + new_dx_leaves[i], | |
| 3954 | + OCFS2_JOURNAL_ACCESS_WRITE); | |
| 3955 | + if (ret) { | |
| 3956 | + mlog_errno(ret); | |
| 3957 | + goto out_commit; | |
| 3958 | + } | |
| 3951 | 3959 | } |
| 3952 | 3960 | |
| 3953 | 3961 | ocfs2_dx_dir_transfer_leaf(dir, split_hash, handle, tmp_dx_leaf, |
| @@ -1030,6 +1030,7 @@ int dlm_drop_lockres_ref(struct dlm_ctxt *dlm, · 1029 unmodified lines | ||
| 1030 | 1030 | struct dlm_lock_resource *res); |
| 1031 | 1031 | void dlm_clean_master_list(struct dlm_ctxt *dlm, |
| 1032 | 1032 | u8 dead_node); |
| 1033 | +void dlm_force_free_mles(struct dlm_ctxt *dlm); | |
| 1033 | 1034 | int dlm_lock_basts_flushed(struct dlm_ctxt *dlm, struct dlm_lock *lock); |
| 1034 | 1035 | int __dlm_lockres_has_locks(struct dlm_lock_resource *res); |
| 1035 | 1036 | int __dlm_lockres_unused(struct dlm_lock_resource *res); |
| @@ -636,8 +636,14 @@ static void *lockres_seq_start(struct seq_file *m, loff_t *pos) · 635 unmodified lines | ||
| 636 | 636 | spin_lock(&dlm->track_lock); |
| 637 | 637 | if (oldres) |
| 638 | 638 | track_list = &oldres->tracking; |
| 639 | − else | |
| 639 | + else { | |
| 640 | 640 | track_list = &dlm->tracking_list; |
| 641 | + if (list_empty(track_list)) { | |
| 642 | + dl = NULL; | |
| 643 | + spin_unlock(&dlm->track_lock); | |
| 644 | + goto bail; | |
| 645 | + } | |
| 646 | + } | |
| 641 | 647 | |
| 642 | 648 | list_for_each_entry(res, track_list, tracking) { |
| 643 | 649 | if (&res->tracking == &dlm->tracking_list) |
| @@ -660,6 +666,7 @@ static void *lockres_seq_start(struct seq_file *m, loff_t *pos) · 16 unmodified lines | ||
| 660 | 666 | } else |
| 661 | 667 | dl = NULL; |
| 662 | 668 | |
| 669 | +bail: | |
| 663 | 670 | /* passed to seq_show */ |
| 664 | 671 | return dl; |
| 665 | 672 | } |
| @@ -693,6 +693,7 @@ void dlm_unregister_domain(struct dlm_ctxt *dlm) · 692 unmodified lines | ||
| 693 | 693 | |
| 694 | 694 | dlm_mark_domain_leaving(dlm); |
| 695 | 695 | dlm_leave_domain(dlm); |
| 696 | + dlm_force_free_mles(dlm); | |
| 696 | 697 | dlm_complete_dlm_shutdown(dlm); |
| 697 | 698 | } |
| 698 | 699 | dlm_put(dlm); |
| @@ -3433,3 +3433,43 @@ void dlm_lockres_release_ast(struct dlm_ctxt *dlm, · 3432 unmodified lines | ||
| 3433 | 3433 | wake_up(&res->wq); |
| 3434 | 3434 | wake_up(&dlm->migration_wq); |
| 3435 | 3435 | } |
| 3436 | + | |
| 3437 | +void dlm_force_free_mles(struct dlm_ctxt *dlm) | |
| 3438 | +{ | |
| 3439 | + int i; | |
| 3440 | + struct hlist_head *bucket; | |
| 3441 | + struct dlm_master_list_entry *mle; | |
| 3442 | + struct hlist_node *tmp, *list; | |
| 3443 | + | |
| 3444 | + /* | |
| 3445 | + * We notified all other nodes that we are exiting the domain and | |
| 3446 | + * marked the dlm state to DLM_CTXT_LEAVING. If any mles are still | |
| 3447 | + * around we force free them and wake any processes that are waiting | |
| 3448 | + * on the mles | |
| 3449 | + */ | |
| 3450 | + spin_lock(&dlm->spinlock); | |
| 3451 | + spin_lock(&dlm->master_lock); | |
| 3452 | + | |
| 3453 | + BUG_ON(dlm->dlm_state != DLM_CTXT_LEAVING); | |
| 3454 | + BUG_ON((find_next_bit(dlm->domain_map, O2NM_MAX_NODES, 0) < O2NM_MAX_NODES)); | |
| 3455 | + | |
| 3456 | + for (i = 0; i < DLM_HASH_BUCKETS; i++) { | |
| 3457 | + bucket = dlm_master_hash(dlm, i); | |
| 3458 | + hlist_for_each_safe(list, tmp, bucket) { | |
| 3459 | + mle = hlist_entry(list, struct dlm_master_list_entry, | |
| 3460 | + master_hash_node); | |
| 3461 | + if (mle->type != DLM_MLE_BLOCK) { | |
| 3462 | + mlog(ML_ERROR, "bad mle: %p\n", mle); | |
| 3463 | + dlm_print_one_mle(mle); | |
| 3464 | + } | |
| 3465 | + atomic_set(&mle->woken, 1); | |
| 3466 | + wake_up(&mle->wq); | |
| 3467 | + | |
| 3468 | + __dlm_unlink_mle(dlm, mle); | |
| 3469 | + __dlm_mle_detach_hb_events(dlm, mle); | |
| 3470 | + __dlm_put_mle(mle); | |
| 3471 | + } | |
| 3472 | + } | |
| 3473 | + spin_unlock(&dlm->master_lock); | |
| 3474 | + spin_unlock(&dlm->spinlock); | |
| 3475 | +} | |
| @@ -84,6 +84,7 @@ enum { · 83 unmodified lines | ||
| 84 | 84 | OI_LS_PARENT, |
| 85 | 85 | OI_LS_RENAME1, |
| 86 | 86 | OI_LS_RENAME2, |
| 87 | + OI_LS_REFLINK_TARGET, | |
| 87 | 88 | }; |
| 88 | 89 | |
| 89 | 90 | int ocfs2_dlm_init(struct ocfs2_super *osb); |
| @@ -235,18 +235,31 @@ · 234 unmodified lines | ||
| 235 | 235 | #define OCFS2_HAS_REFCOUNT_FL (0x0010) |
| 236 | 236 | |
| 237 | 237 | /* Inode attributes, keep in sync with EXT2 */ |
| 238 | −#define OCFS2_SECRM_FL (0x00000001) /* Secure deletion */ | |
| 239 | −#define OCFS2_UNRM_FL (0x00000002) /* Undelete */ | |
| 240 | −#define OCFS2_COMPR_FL (0x00000004) /* Compress file */ | |
| 241 | −#define OCFS2_SYNC_FL (0x00000008) /* Synchronous updates */ | |
| 242 | −#define OCFS2_IMMUTABLE_FL (0x00000010) /* Immutable file */ | |
| 243 | −#define OCFS2_APPEND_FL (0x00000020) /* writes to file may only append */ | |
| 244 | −#define OCFS2_NODUMP_FL (0x00000040) /* do not dump file */ | |
| 245 | −#define OCFS2_NOATIME_FL (0x00000080) /* do not update atime */ | |
| 246 | −#define OCFS2_DIRSYNC_FL (0x00010000) /* dirsync behaviour (directories only) */ | |
| 247 | − | |
| 248 | −#define OCFS2_FL_VISIBLE (0x000100FF) /* User visible flags */ | |
| 249 | −#define OCFS2_FL_MODIFIABLE (0x000100FF) /* User modifiable flags */ | |
| 238 | +#define OCFS2_SECRM_FL FS_SECRM_FL /* Secure deletion */ | |
| 239 | +#define OCFS2_UNRM_FL FS_UNRM_FL /* Undelete */ | |
| 240 | +#define OCFS2_COMPR_FL FS_COMPR_FL /* Compress file */ | |
| 241 | +#define OCFS2_SYNC_FL FS_SYNC_FL /* Synchronous updates */ | |
| 242 | +#define OCFS2_IMMUTABLE_FL FS_IMMUTABLE_FL /* Immutable file */ | |
| 243 | +#define OCFS2_APPEND_FL FS_APPEND_FL /* writes to file may only append */ | |
| 244 | +#define OCFS2_NODUMP_FL FS_NODUMP_FL /* do not dump file */ | |
| 245 | +#define OCFS2_NOATIME_FL FS_NOATIME_FL /* do not update atime */ | |
| 246 | +/* Reserved for compression usage... */ | |
| 247 | +#define OCFS2_DIRTY_FL FS_DIRTY_FL | |
| 248 | +#define OCFS2_COMPRBLK_FL FS_COMPRBLK_FL /* One or more compressed clusters */ | |
| 249 | +#define OCFS2_NOCOMP_FL FS_NOCOMP_FL /* Don't compress */ | |
| 250 | +#define OCFS2_ECOMPR_FL FS_ECOMPR_FL /* Compression error */ | |
| 251 | +/* End compression flags --- maybe not all used */ | |
| 252 | +#define OCFS2_BTREE_FL FS_BTREE_FL /* btree format dir */ | |
| 253 | +#define OCFS2_INDEX_FL FS_INDEX_FL /* hash-indexed directory */ | |
| 254 | +#define OCFS2_IMAGIC_FL FS_IMAGIC_FL /* AFS directory */ | |
| 255 | +#define OCFS2_JOURNAL_DATA_FL FS_JOURNAL_DATA_FL /* Reserved for ext3 */ | |
| 256 | +#define OCFS2_NOTAIL_FL FS_NOTAIL_FL /* file tail should not be merged */ | |
| 257 | +#define OCFS2_DIRSYNC_FL FS_DIRSYNC_FL /* dirsync behaviour (directories only) */ | |
| 258 | +#define OCFS2_TOPDIR_FL FS_TOPDIR_FL /* Top of directory hierarchies*/ | |
| 259 | +#define OCFS2_RESERVED_FL FS_RESERVED_FL /* reserved for ext2 lib */ | |
| 260 | + | |
| 261 | +#define OCFS2_FL_VISIBLE FS_FL_USER_VISIBLE /* User visible flags */ | |
| 262 | +#define OCFS2_FL_MODIFIABLE FS_FL_USER_MODIFIABLE /* User modifiable flags */ | |
| 250 | 263 | |
| 251 | 264 | /* |
| 252 | 265 | * Extent record flags (e_node.leaf.flags) |
| @@ -23,10 +23,10 @@ · 22 unmodified lines | ||
| 23 | 23 | /* |
| 24 | 24 | * ioctl commands |
| 25 | 25 | */ |
| 26 | −#define OCFS2_IOC_GETFLAGS _IOR('f', 1, long) | |
| 27 | −#define OCFS2_IOC_SETFLAGS _IOW('f', 2, long) | |
| 28 | −#define OCFS2_IOC32_GETFLAGS _IOR('f', 1, int) | |
| 29 | −#define OCFS2_IOC32_SETFLAGS _IOW('f', 2, int) | |
| 26 | +#define OCFS2_IOC_GETFLAGS FS_IOC_GETFLAGS | |
| 27 | +#define OCFS2_IOC_SETFLAGS FS_IOC_SETFLAGS | |
| 28 | +#define OCFS2_IOC32_GETFLAGS FS_IOC32_GETFLAGS | |
| 29 | +#define OCFS2_IOC32_SETFLAGS FS_IOC32_SETFLAGS | |
| 30 | 30 | |
| 31 | 31 | /* |
| 32 | 32 | * Space reservation / allocation / free ioctls and argument structure |
| @@ -4201,8 +4201,9 @@ static int __ocfs2_reflink(struct dentry *old_dentry, · 4200 unmodified lines | ||
| 4201 | 4201 | goto out; |
| 4202 | 4202 | } |
| 4203 | 4203 | |
| 4204 | − mutex_lock(&new_inode->i_mutex); | |
| 4205 | − ret = ocfs2_inode_lock(new_inode, &new_bh, 1); | |
| 4204 | + mutex_lock_nested(&new_inode->i_mutex, I_MUTEX_CHILD); | |
| 4205 | + ret = ocfs2_inode_lock_nested(new_inode, &new_bh, 1, | |
| 4206 | + OI_LS_REFLINK_TARGET); | |
| 4206 | 4207 | if (ret) { |
| 4207 | 4208 | mlog_errno(ret); |
| 4208 | 4209 | goto out_unlock; |
| @@ -732,25 +732,23 @@ int ocfs2_resmap_resv_bits(struct ocfs2_reservation_map *resmap, · 731 unmodified lines | ||
| 732 | 732 | struct ocfs2_alloc_reservation *resv, |
| 733 | 733 | int *cstart, int *clen) |
| 734 | 734 | { |
| 735 | − unsigned int wanted = *clen; | |
| 736 | − | |
| 737 | 735 | if (resv == NULL || ocfs2_resmap_disabled(resmap)) |
| 738 | 736 | return -ENOSPC; |
| 739 | 737 | |
| 740 | 738 | spin_lock(&resv_lock); |
| 741 | 739 | |
| 742 | − /* | |
| 743 | − * We don't want to over-allocate for temporary | |
| 744 | − * windows. Otherwise, we run the risk of fragmenting the | |
| 745 | − * allocation space. | |
| 746 | − */ | |
| 747 | − wanted = ocfs2_resv_window_bits(resmap, resv); | |
| 748 | − if ((resv->r_flags & OCFS2_RESV_FLAG_TMP) || wanted < *clen) | |
| 749 | − wanted = *clen; | |
| 750 | − | |
| 751 | 740 | if (ocfs2_resv_empty(resv)) { |
| 752 | − mlog(0, "empty reservation, find new window\n"); | |
| 741 | + /* | |
| 742 | + * We don't want to over-allocate for temporary | |
| 743 | + * windows. Otherwise, we run the risk of fragmenting the | |
| 744 | + * allocation space. | |
| 745 | + */ | |
| 746 | + unsigned int wanted = ocfs2_resv_window_bits(resmap, resv); | |
| 753 | 747 | |
| 748 | + if ((resv->r_flags & OCFS2_RESV_FLAG_TMP) || wanted < *clen) | |
| 749 | + wanted = *clen; | |
| 750 | + | |
| 751 | + mlog(0, "empty reservation, find new window\n"); | |
| 754 | 752 | /* |
| 755 | 753 | * Try to get a window here. If it works, we must fall |
| 756 | 754 | * through and test the bitmap . This avoids some |
| @@ -357,7 +357,7 @@ out: · 356 unmodified lines | ||
| 357 | 357 | static void ocfs2_bg_discontig_add_extent(struct ocfs2_super *osb, |
| 358 | 358 | struct ocfs2_group_desc *bg, |
| 359 | 359 | struct ocfs2_chain_list *cl, |
| 360 | − u64 p_blkno, u32 clusters) | |
| 360 | + u64 p_blkno, unsigned int clusters) | |
| 361 | 361 | { |
| 362 | 362 | struct ocfs2_extent_list *el = &bg->bg_list; |
| 363 | 363 | struct ocfs2_extent_rec *rec; |
| @@ -369,7 +369,7 @@ static void ocfs2_bg_discontig_add_extent(struct ocfs2_super *osb, · 5 unmodified lines | ||
| 369 | 369 | rec->e_blkno = cpu_to_le64(p_blkno); |
| 370 | 370 | rec->e_cpos = cpu_to_le32(le16_to_cpu(bg->bg_bits) / |
| 371 | 371 | le16_to_cpu(cl->cl_bpc)); |
| 372 | − rec->e_leaf_clusters = cpu_to_le32(clusters); | |
| 372 | + rec->e_leaf_clusters = cpu_to_le16(clusters); | |
| 373 | 373 | le16_add_cpu(&bg->bg_bits, clusters * le16_to_cpu(cl->cl_bpc)); |
| 374 | 374 | le16_add_cpu(&bg->bg_free_bits_count, |
| 375 | 375 | clusters * le16_to_cpu(cl->cl_bpc)); |
| @@ -128,7 +128,7 @@ static void *ocfs2_fast_follow_link(struct dentry *dentry, · 127 unmodified lines | ||
| 128 | 128 | } |
| 129 | 129 | |
| 130 | 130 | /* Fast symlinks can't be large */ |
| 131 | − len = strlen(target); | |
| 131 | + len = strnlen(target, ocfs2_fast_symlink_chars(inode->i_sb)); | |
| 132 | 132 | link = kzalloc(len + 1, GFP_NOFS); |
| 133 | 133 | if (!link) { |
| 134 | 134 | status = -ENOMEM; |
| @@ -1286,13 +1286,11 @@ int ocfs2_xattr_get_nolock(struct inode *inode, · 1285 unmodified lines | ||
| 1286 | 1286 | xis.inode_bh = xbs.inode_bh = di_bh; |
| 1287 | 1287 | di = (struct ocfs2_dinode *)di_bh->b_data; |
| 1288 | 1288 | |
| 1289 | − down_read(&oi->ip_xattr_sem); | |
| 1290 | 1289 | ret = ocfs2_xattr_ibody_get(inode, name_index, name, buffer, |
| 1291 | 1290 | buffer_size, &xis); |
| 1292 | 1291 | if (ret == -ENODATA && di->i_xattr_loc) |
| 1293 | 1292 | ret = ocfs2_xattr_block_get(inode, name_index, name, buffer, |
| 1294 | 1293 | buffer_size, &xbs); |
| 1295 | − up_read(&oi->ip_xattr_sem); | |
| 1296 | 1294 | |
| 1297 | 1295 | return ret; |
| 1298 | 1296 | } |
| @@ -1316,8 +1314,10 @@ static int ocfs2_xattr_get(struct inode *inode, · 17 unmodified lines | ||
| 1316 | 1314 | mlog_errno(ret); |
| 1317 | 1315 | return ret; |
| 1318 | 1316 | } |
| 1317 | + down_read(&OCFS2_I(inode)->ip_xattr_sem); | |
| 1319 | 1318 | ret = ocfs2_xattr_get_nolock(inode, di_bh, name_index, |
| 1320 | 1319 | name, buffer, buffer_size); |
| 1320 | + up_read(&OCFS2_I(inode)->ip_xattr_sem); | |
| 1321 | 1321 | |
| 1322 | 1322 | ocfs2_inode_unlock(inode, 0); |
| 1323 | 1323 | |
| @@ -2675,7 +2675,7 @@ static const struct pid_entry tgid_base_stuff[] = { · 2674 unmodified lines | ||
| 2675 | 2675 | INF("auxv", S_IRUSR, proc_pid_auxv), |
| 2676 | 2676 | ONE("status", S_IRUGO, proc_pid_status), |
| 2677 | 2677 | ONE("personality", S_IRUSR, proc_pid_personality), |
| 2678 | − INF("limits", S_IRUSR, proc_pid_limits), | |
| 2678 | + INF("limits", S_IRUGO, proc_pid_limits), | |
| 2679 | 2679 | #ifdef CONFIG_SCHED_DEBUG |
| 2680 | 2680 | REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), |
| 2681 | 2681 | #endif |
| @@ -3011,7 +3011,7 @@ static const struct pid_entry tid_base_stuff[] = { · 329 unmodified lines | ||
| 3011 | 3011 | INF("auxv", S_IRUSR, proc_pid_auxv), |
| 3012 | 3012 | ONE("status", S_IRUGO, proc_pid_status), |
| 3013 | 3013 | ONE("personality", S_IRUSR, proc_pid_personality), |
| 3014 | − INF("limits", S_IRUSR, proc_pid_limits), | |
| 3014 | + INF("limits", S_IRUGO, proc_pid_limits), | |
| 3015 | 3015 | #ifdef CONFIG_SCHED_DEBUG |
| 3016 | 3016 | REG("sched", S_IRUGO|S_IWUSR, proc_pid_sched_operations), |
| 3017 | 3017 | #endif |
| @@ -363,13 +363,13 @@ static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end, · 362 unmodified lines | ||
| 363 | 363 | mss->referenced += PAGE_SIZE; |
| 364 | 364 | mapcount = page_mapcount(page); |
| 365 | 365 | if (mapcount >= 2) { |
| 366 | − if (pte_dirty(ptent)) | |
| 366 | + if (pte_dirty(ptent) || PageDirty(page)) | |
| 367 | 367 | mss->shared_dirty += PAGE_SIZE; |
| 368 | 368 | else |
| 369 | 369 | mss->shared_clean += PAGE_SIZE; |
| 370 | 370 | mss->pss += (PAGE_SIZE << PSS_SHIFT) / mapcount; |
| 371 | 371 | } else { |
| 372 | − if (pte_dirty(ptent)) | |
| 372 | + if (pte_dirty(ptent) || PageDirty(page)) | |
| 373 | 373 | mss->private_dirty += PAGE_SIZE; |
| 374 | 374 | else |
| 375 | 375 | mss->private_clean += PAGE_SIZE; |
| @@ -163,7 +163,7 @@ static ssize_t read_vmcore(struct file *file, char __user *buffer, · 162 unmodified lines | ||
| 163 | 163 | |
| 164 | 164 | static const struct file_operations proc_vmcore_operations = { |
| 165 | 165 | .read = read_vmcore, |
| 166 | − .llseek = generic_file_llseek, | |
| 166 | + .llseek = default_llseek, | |
| 167 | 167 | }; |
| 168 | 168 | |
| 169 | 169 | static struct vmcore* __init get_new_element(void) |
| @@ -170,6 +170,7 @@ int reiserfs_prepare_write(struct file *f, struct page *page, · 169 unmodified lines | ||
| 170 | 170 | int reiserfs_unpack(struct inode *inode, struct file *filp) |
| 171 | 171 | { |
| 172 | 172 | int retval = 0; |
| 173 | + int depth; | |
| 173 | 174 | int index; |
| 174 | 175 | struct page *page; |
| 175 | 176 | struct address_space *mapping; |
| @@ -188,8 +189,8 @@ int reiserfs_unpack(struct inode *inode, struct file *filp) · 12 unmodified lines | ||
| 188 | 189 | /* we need to make sure nobody is changing the file size beneath |
| 189 | 190 | ** us |
| 190 | 191 | */ |
| 191 | − mutex_lock(&inode->i_mutex); | |
| 192 | − reiserfs_write_lock(inode->i_sb); | |
| 192 | + reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb); | |
| 193 | + depth = reiserfs_write_lock_once(inode->i_sb); | |
| 193 | 194 | |
| 194 | 195 | write_from = inode->i_size & (blocksize - 1); |
| 195 | 196 | /* if we are on a block boundary, we are already unpacked. */ |
| @@ -224,6 +225,6 @@ int reiserfs_unpack(struct inode *inode, struct file *filp) · 28 unmodified lines | ||
| 224 | 225 | |
| 225 | 226 | out: |
| 226 | 227 | mutex_unlock(&inode->i_mutex); |
| 227 | − reiserfs_write_unlock(inode->i_sb); | |
| 228 | + reiserfs_write_unlock_once(inode->i_sb, depth); | |
| 228 | 229 | return retval; |
| 229 | 230 | } |
| @@ -405,9 +405,15 @@ xlog_cil_push( · 404 unmodified lines | ||
| 405 | 405 | new_ctx = kmem_zalloc(sizeof(*new_ctx), KM_SLEEP|KM_NOFS); |
| 406 | 406 | new_ctx->ticket = xlog_cil_ticket_alloc(log); |
| 407 | 407 | |
| 408 | − /* lock out transaction commit, but don't block on background push */ | |
| 408 | + /* | |
| 409 | + * Lock out transaction commit, but don't block for background pushes | |
| 410 | + * unless we are well over the CIL space limit. See the definition of | |
| 411 | + * XLOG_CIL_HARD_SPACE_LIMIT() for the full explanation of the logic | |
| 412 | + * used here. | |
| 413 | + */ | |
| 409 | 414 | if (!down_write_trylock(&cil->xc_ctx_lock)) { |
| 410 | − if (!push_seq) | |
| 415 | + if (!push_seq && | |
| 416 | + cil->xc_ctx->space_used < XLOG_CIL_HARD_SPACE_LIMIT(log)) | |
| 411 | 417 | goto out_free_ticket; |
| 412 | 418 | down_write(&cil->xc_ctx_lock); |
| 413 | 419 | } |
| @@ -422,7 +428,7 @@ xlog_cil_push( · 8 unmodified lines | ||
| 422 | 428 | goto out_skip; |
| 423 | 429 | |
| 424 | 430 | /* check for a previously pushed seqeunce */ |
| 425 | − if (push_seq < cil->xc_ctx->sequence) | |
| 431 | + if (push_seq && push_seq < cil->xc_ctx->sequence) | |
| 426 | 432 | goto out_skip; |
| 427 | 433 | |
| 428 | 434 | /* |
| @@ -426,13 +426,13 @@ struct xfs_cil { · 425 unmodified lines | ||
| 426 | 426 | }; |
| 427 | 427 | |
| 428 | 428 | /* |
| 429 | − * The amount of log space we should the CIL to aggregate is difficult to size. | |
| 430 | − * Whatever we chose we have to make we can get a reservation for the log space | |
| 431 | − * effectively, that it is large enough to capture sufficient relogging to | |
| 432 | − * reduce log buffer IO significantly, but it is not too large for the log or | |
| 433 | − * induces too much latency when writing out through the iclogs. We track both | |
| 434 | − * space consumed and the number of vectors in the checkpoint context, so we | |
| 435 | − * need to decide which to use for limiting. | |
| 429 | + * The amount of log space we allow the CIL to aggregate is difficult to size. | |
| 430 | + * Whatever we choose, we have to make sure we can get a reservation for the | |
| 431 | + * log space effectively, that it is large enough to capture sufficient | |
| 432 | + * relogging to reduce log buffer IO significantly, but it is not too large for | |
| 433 | + * the log or induces too much latency when writing out through the iclogs. We | |
| 434 | + * track both space consumed and the number of vectors in the checkpoint | |
| 435 | + * context, so we need to decide which to use for limiting. | |
| 436 | 436 | * |
| 437 | 437 | * Every log buffer we write out during a push needs a header reserved, which |
| 438 | 438 | * is at least one sector and more for v2 logs. Hence we need a reservation of |
| @@ -459,16 +459,21 @@ struct xfs_cil { · 20 unmodified lines | ||
| 459 | 459 | * checkpoint transaction ticket is specific to the checkpoint context, rather |
| 460 | 460 | * than the CIL itself. |
| 461 | 461 | * |
| 462 | − * With dynamic reservations, we can basically make up arbitrary limits for the | |
| 463 | − * checkpoint size so long as they don't violate any other size rules. Hence | |
| 464 | − * the initial maximum size for the checkpoint transaction will be set to a | |
| 465 | − * quarter of the log or 8MB, which ever is smaller. 8MB is an arbitrary limit | |
| 466 | − * right now based on the latency of writing out a large amount of data through | |
| 467 | − * the circular iclog buffers. | |
| 462 | + * With dynamic reservations, we can effectively make up arbitrary limits for | |
| 463 | + * the checkpoint size so long as they don't violate any other size rules. | |
| 464 | + * Recovery imposes a rule that no transaction exceed half the log, so we are | |
| 465 | + * limited by that. Furthermore, the log transaction reservation subsystem | |
| 466 | + * tries to keep 25% of the log free, so we need to keep below that limit or we | |
| 467 | + * risk running out of free log space to start any new transactions. | |
| 468 | + * | |
| 469 | + * In order to keep background CIL push efficient, we will set a lower | |
| 470 | + * threshold at which background pushing is attempted without blocking current | |
| 471 | + * transaction commits. A separate, higher bound defines when CIL pushes are | |
| 472 | + * enforced to ensure we stay within our maximum checkpoint size bounds. | |
| 473 | + * threshold, yet give us plenty of space for aggregation on large logs. | |
| 468 | 474 | */ |
| 469 | − | |
| 470 | −#define XLOG_CIL_SPACE_LIMIT(log) \ | |
| 471 | − (min((log->l_logsize >> 2), (8 * 1024 * 1024))) | |
| 475 | +#define XLOG_CIL_SPACE_LIMIT(log) (log->l_logsize >> 3) | |
| 476 | +#define XLOG_CIL_HARD_SPACE_LIMIT(log) (3 * (log->l_logsize >> 4)) | |
| 472 | 477 | |
| 473 | 478 | /* |
| 474 | 479 | * The reservation head lsn is not made up of a cycle number and block number. |
| @@ -55,7 +55,7 @@ · 54 unmodified lines | ||
| 55 | 55 | extern u8 acpi_gbl_permanent_mmap; |
| 56 | 56 | |
| 57 | 57 | /* |
| 58 | − * Globals that are publically available, allowing for | |
| 58 | + * Globals that are publicly available, allowing for | |
| 59 | 59 | * run time configuration |
| 60 | 60 | */ |
| 61 | 61 | extern u32 acpi_dbg_level; |
| @@ -612,7 +612,7 @@ struct drm_gem_object { · 611 unmodified lines | ||
| 612 | 612 | struct kref refcount; |
| 613 | 613 | |
| 614 | 614 | /** Handle count of this object. Each handle also holds a reference */ |
| 615 | − struct kref handlecount; | |
| 615 | + atomic_t handle_count; /* number of handles on this object */ | |
| 616 | 616 | |
| 617 | 617 | /** Related drm device */ |
| 618 | 618 | struct drm_device *dev; |
| @@ -808,7 +808,6 @@ struct drm_driver { · 189 unmodified lines | ||
| 808 | 808 | */ |
| 809 | 809 | int (*gem_init_object) (struct drm_gem_object *obj); |
| 810 | 810 | void (*gem_free_object) (struct drm_gem_object *obj); |
| 811 | − void (*gem_free_object_unlocked) (struct drm_gem_object *obj); | |
| 812 | 811 | |
| 813 | 812 | /* vga arb irq handler */ |
| 814 | 813 | void (*vgaarb_irq)(struct drm_device *dev, bool state); |
| @@ -1175,6 +1174,7 @@ extern int drm_release(struct inode *inode, struct file *filp); · 360 unmodified lines | ||
| 1175 | 1174 | extern int drm_mmap(struct file *filp, struct vm_area_struct *vma); |
| 1176 | 1175 | extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma); |
| 1177 | 1176 | extern void drm_vm_open_locked(struct vm_area_struct *vma); |
| 1177 | +extern void drm_vm_close_locked(struct vm_area_struct *vma); | |
| 1178 | 1178 | extern resource_size_t drm_core_get_map_ofs(struct drm_local_map * map); |
| 1179 | 1179 | extern resource_size_t drm_core_get_reg_ofs(struct drm_device *dev); |
| 1180 | 1180 | extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); |
| @@ -1455,12 +1455,11 @@ int drm_gem_init(struct drm_device *dev); · 274 unmodified lines | ||
| 1455 | 1455 | void drm_gem_destroy(struct drm_device *dev); |
| 1456 | 1456 | void drm_gem_object_release(struct drm_gem_object *obj); |
| 1457 | 1457 | void drm_gem_object_free(struct kref *kref); |
| 1458 | −void drm_gem_object_free_unlocked(struct kref *kref); | |
| 1459 | 1458 | struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev, |
| 1460 | 1459 | size_t size); |
| 1461 | 1460 | int drm_gem_object_init(struct drm_device *dev, |
| 1462 | 1461 | struct drm_gem_object *obj, size_t size); |
| 1463 | −void drm_gem_object_handle_free(struct kref *kref); | |
| 1462 | +void drm_gem_object_handle_free(struct drm_gem_object *obj); | |
| 1464 | 1463 | void drm_gem_vm_open(struct vm_area_struct *vma); |
| 1465 | 1464 | void drm_gem_vm_close(struct vm_area_struct *vma); |
| 1466 | 1465 | int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); |
| @@ -1483,8 +1482,12 @@ drm_gem_object_unreference(struct drm_gem_object *obj) · 16 unmodified lines | ||
| 1483 | 1482 | static inline void |
| 1484 | 1483 | drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
| 1485 | 1484 | { |
| 1486 | − if (obj != NULL) | |
| 1487 | − kref_put(&obj->refcount, drm_gem_object_free_unlocked); | |
| 1485 | + if (obj != NULL) { | |
| 1486 | + struct drm_device *dev = obj->dev; | |
| 1487 | + mutex_lock(&dev->struct_mutex); | |
| 1488 | + kref_put(&obj->refcount, drm_gem_object_free); | |
| 1489 | + mutex_unlock(&dev->struct_mutex); | |
| 1490 | + } | |
| 1488 | 1491 | } |
| 1489 | 1492 | |
| 1490 | 1493 | int drm_gem_handle_create(struct drm_file *file_priv, |
| @@ -1495,7 +1498,7 @@ static inline void · 4 unmodified lines | ||
| 1495 | 1498 | drm_gem_object_handle_reference(struct drm_gem_object *obj) |
| 1496 | 1499 | { |
| 1497 | 1500 | drm_gem_object_reference(obj); |
| 1498 | − kref_get(&obj->handlecount); | |
| 1501 | + atomic_inc(&obj->handle_count); | |
| 1499 | 1502 | } |
| 1500 | 1503 | |
| 1501 | 1504 | static inline void |
| @@ -1504,12 +1507,15 @@ drm_gem_object_handle_unreference(struct drm_gem_object *obj) · 2 unmodified lines | ||
| 1504 | 1507 | if (obj == NULL) |
| 1505 | 1508 | return; |
| 1506 | 1509 | |
| 1510 | + if (atomic_read(&obj->handle_count) == 0) | |
| 1511 | + return; | |
| 1507 | 1512 | /* |
| 1508 | 1513 | * Must bump handle count first as this may be the last |
| 1509 | 1514 | * ref, in which case the object would disappear before we |
| 1510 | 1515 | * checked for a name |
| 1511 | 1516 | */ |
| 1512 | − kref_put(&obj->handlecount, drm_gem_object_handle_free); | |
| 1517 | + if (atomic_dec_and_test(&obj->handle_count)) | |
| 1518 | + drm_gem_object_handle_free(obj); | |
| 1513 | 1519 | drm_gem_object_unreference(obj); |
| 1514 | 1520 | } |
| 1515 | 1521 | |
| @@ -1519,12 +1525,17 @@ drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj) · 3 unmodified lines | ||
| 1519 | 1525 | if (obj == NULL) |
| 1520 | 1526 | return; |
| 1521 | 1527 | |
| 1528 | + if (atomic_read(&obj->handle_count) == 0) | |
| 1529 | + return; | |
| 1530 | + | |
| 1522 | 1531 | /* |
| 1523 | 1532 | * Must bump handle count first as this may be the last |
| 1524 | 1533 | * ref, in which case the object would disappear before we |
| 1525 | 1534 | * checked for a name |
| 1526 | 1535 | */ |
| 1527 | − kref_put(&obj->handlecount, drm_gem_object_handle_free); | |
| 1536 | + | |
| 1537 | + if (atomic_dec_and_test(&obj->handle_count)) | |
| 1538 | + drm_gem_object_handle_free(obj); | |
| 1528 | 1539 | drm_gem_object_unreference_unlocked(obj); |
| 1529 | 1540 | } |
| 1530 | 1541 | |
| @@ -85,7 +85,6 @@ · 84 unmodified lines | ||
| 85 | 85 | {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| 86 | 86 | {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| 87 | 87 | {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| 88 | − {0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | |
| 89 | 88 | {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
| 90 | 89 | {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
| 91 | 90 | {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
| @@ -103,6 +102,7 @@ · 11 unmodified lines | ||
| 103 | 102 | {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
| 104 | 103 | {0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
| 105 | 104 | {0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
| 105 | + {0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ | |
| 106 | 106 | {0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP}, \ |
| 107 | 107 | {0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \ |
| 108 | 108 | {0x1002, 0x5954, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS480|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ |
| @@ -53,6 +53,7 @@ struct cpuidle_state { · 52 unmodified lines | ||
| 53 | 53 | #define CPUIDLE_FLAG_BALANCED (0x40) /* medium latency, moderate savings */ |
| 54 | 54 | #define CPUIDLE_FLAG_DEEP (0x80) /* high latency, large savings */ |
| 55 | 55 | #define CPUIDLE_FLAG_IGNORE (0x100) /* ignore during this idle period */ |
| 56 | +#define CPUIDLE_FLAG_TLB_FLUSHED (0x200) /* tlb will be flushed */ | |
| 56 | 57 | |
| 57 | 58 | #define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000) |
| 58 | 59 | |
| @@ -102,6 +102,9 @@ static inline u64 dma_get_mask(struct device *dev) · 101 unmodified lines | ||
| 102 | 102 | return DMA_BIT_MASK(32); |
| 103 | 103 | } |
| 104 | 104 | |
| 105 | +#ifdef ARCH_HAS_DMA_SET_COHERENT_MASK | |
| 106 | +int dma_set_coherent_mask(struct device *dev, u64 mask); | |
| 107 | +#else | |
| 105 | 108 | static inline int dma_set_coherent_mask(struct device *dev, u64 mask) |
| 106 | 109 | { |
| 107 | 110 | if (!dma_supported(dev, mask)) |
| @@ -109,6 +112,7 @@ static inline int dma_set_coherent_mask(struct device *dev, u64 mask) · 1 unmodified line | ||
| 109 | 112 | dev->coherent_dma_mask = mask; |
| 110 | 113 | return 0; |
| 111 | 114 | } |
| 115 | +#endif | |
| 112 | 116 | |
| 113 | 117 | extern u64 dma_get_required_mask(struct device *dev); |
| 114 | 118 | |
| @@ -548,7 +548,7 @@ static inline bool dma_dev_has_pq_continue(struct dma_device *dma) · 547 unmodified lines | ||
| 548 | 548 | return (dma->max_pq & DMA_HAS_PQ_CONTINUE) == DMA_HAS_PQ_CONTINUE; |
| 549 | 549 | } |
| 550 | 550 | |
| 551 | −static unsigned short dma_dev_to_maxpq(struct dma_device *dma) | |
| 551 | +static inline unsigned short dma_dev_to_maxpq(struct dma_device *dma) | |
| 552 | 552 | { |
| 553 | 553 | return dma->max_pq & ~DMA_HAS_PQ_CONTINUE; |
| 554 | 554 | } |
| @@ -689,17 +689,16 @@ extern int module_sysfs_initialized; · 688 unmodified lines | ||
| 689 | 689 | |
| 690 | 690 | |
| 691 | 691 | #ifdef CONFIG_GENERIC_BUG |
| 692 | −int module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *, | |
| 692 | +void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *, | |
| 693 | 693 | struct module *); |
| 694 | 694 | void module_bug_cleanup(struct module *); |
| 695 | 695 | |
| 696 | 696 | #else /* !CONFIG_GENERIC_BUG */ |
| 697 | 697 | |
| 698 | −static inline int module_bug_finalize(const Elf_Ehdr *hdr, | |
| 698 | +static inline void module_bug_finalize(const Elf_Ehdr *hdr, | |
| 699 | 699 | const Elf_Shdr *sechdrs, |
| 700 | 700 | struct module *mod) |
| 701 | 701 | { |
| 702 | − return 0; | |
| 703 | 702 | } |
| 704 | 703 | static inline void module_bug_cleanup(struct module *mod) {} |
| 705 | 704 | #endif /* CONFIG_GENERIC_BUG */ |
| @@ -27,8 +27,6 @@ · 26 unmodified lines | ||
| 27 | 27 | |
| 28 | 28 | #define MAX_LINKS 32 |
| 29 | 29 | |
| 30 | −struct net; | |
| 31 | − | |
| 32 | 30 | struct sockaddr_nl { |
| 33 | 31 | sa_family_t nl_family; /* AF_NETLINK */ |
| 34 | 32 | unsigned short nl_pad; /* zero */ |
| @@ -151,6 +149,8 @@ struct nlattr { · 116 unmodified lines | ||
| 151 | 149 | #include <linux/capability.h> |
| 152 | 150 | #include <linux/skbuff.h> |
| 153 | 151 | |
| 152 | +struct net; | |
| 153 | + | |
| 154 | 154 | static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb) |
| 155 | 155 | { |
| 156 | 156 | return (struct nlmsghdr *)skb->data; |
| @@ -393,6 +393,9 @@ · 392 unmodified lines | ||
| 393 | 393 | #define PCI_DEVICE_ID_VLSI_82C147 0x0105 |
| 394 | 394 | #define PCI_DEVICE_ID_VLSI_VAS96011 0x0702 |
| 395 | 395 | |
| 396 | +/* AMD RD890 Chipset */ | |
| 397 | +#define PCI_DEVICE_ID_RD890_IOMMU 0x5a23 | |
| 398 | + | |
| 396 | 399 | #define PCI_VENDOR_ID_ADL 0x1005 |
| 397 | 400 | #define PCI_DEVICE_ID_ADL_2301 0x2301 |
| 398 | 401 | |
| @@ -454,7 +454,7 @@ static inline notrace void rcu_read_unlock_sched_notrace(void) · 453 unmodified lines | ||
| 454 | 454 | * Makes rcu_dereference_check() do the dirty work. |
| 455 | 455 | */ |
| 456 | 456 | #define rcu_dereference_bh(p) \ |
| 457 | − rcu_dereference_check(p, rcu_read_lock_bh_held()) | |
| 457 | + rcu_dereference_check(p, rcu_read_lock_bh_held() || irqs_disabled()) | |
| 458 | 458 | |
| 459 | 459 | /** |
| 460 | 460 | * rcu_dereference_sched - fetch RCU-protected pointer, checking for RCU-sched |
| @@ -322,7 +322,7 @@ extern int csum_partial_copy_fromiovecend(unsigned char *kdata, · 321 unmodified lines | ||
| 322 | 322 | int offset, |
| 323 | 323 | unsigned int len, __wsum *csump); |
| 324 | 324 | |
| 325 | −extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode); | |
| 325 | +extern long verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode); | |
| 326 | 326 | extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len); |
| 327 | 327 | extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata, |
| 328 | 328 | int offset, int len); |
| @@ -614,6 +614,7 @@ int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key); · 613 unmodified lines | ||
| 614 | 614 | (wait)->private = current; \ |
| 615 | 615 | (wait)->func = autoremove_wake_function; \ |
| 616 | 616 | INIT_LIST_HEAD(&(wait)->task_list); \ |
| 617 | + (wait)->flags = 0; \ | |
| 617 | 618 | } while (0) |
| 618 | 619 | |
| 619 | 620 | /** |
| @@ -121,6 +121,7 @@ static inline int addrconf_finite_timeout(unsigned long timeout) · 120 unmodified lines | ||
| 121 | 121 | * IPv6 Address Label subsystem (addrlabel.c) |
| 122 | 122 | */ |
| 123 | 123 | extern int ipv6_addr_label_init(void); |
| 124 | +extern void ipv6_addr_label_cleanup(void); | |
| 124 | 125 | extern void ipv6_addr_label_rtnl_register(void); |
| 125 | 126 | extern u32 ipv6_addr_label(struct net *net, |
| 126 | 127 | const struct in6_addr *addr, |
| @@ -242,6 +242,7 @@ static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev) · 241 unmodified lines | ||
| 242 | 242 | dev->stats.rx_packets++; |
| 243 | 243 | dev->stats.rx_bytes += skb->len; |
| 244 | 244 | skb->rxhash = 0; |
| 245 | + skb_set_queue_mapping(skb, 0); | |
| 245 | 246 | skb_dst_drop(skb); |
| 246 | 247 | nf_reset(skb); |
| 247 | 248 | } |
| @@ -199,6 +199,8 @@ static inline int ip_route_newports(struct rtable **rp, u8 protocol, · 198 unmodified lines | ||
| 199 | 199 | fl.fl_ip_sport = sport; |
| 200 | 200 | fl.fl_ip_dport = dport; |
| 201 | 201 | fl.proto = protocol; |
| 202 | + if (inet_sk(sk)->transparent) | |
| 203 | + fl.flags |= FLOWI_FLAG_ANYSRC; | |
| 202 | 204 | ip_rt_put(*rp); |
| 203 | 205 | *rp = NULL; |
| 204 | 206 | security_sk_classify_flow(sk, &fl); |
| @@ -298,8 +298,8 @@ struct xfrm_state_afinfo { · 297 unmodified lines | ||
| 298 | 298 | const struct xfrm_type *type_map[IPPROTO_MAX]; |
| 299 | 299 | struct xfrm_mode *mode_map[XFRM_MODE_MAX]; |
| 300 | 300 | int (*init_flags)(struct xfrm_state *x); |
| 301 | − void (*init_tempsel)(struct xfrm_state *x, struct flowi *fl, | |
| 302 | − struct xfrm_tmpl *tmpl, | |
| 301 | + void (*init_tempsel)(struct xfrm_selector *sel, struct flowi *fl); | |
| 302 | + void (*init_temprop)(struct xfrm_state *x, struct xfrm_tmpl *tmpl, | |
| 303 | 303 | xfrm_address_t *daddr, xfrm_address_t *saddr); |
| 304 | 304 | int (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n); |
| 305 | 305 | int (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n); |
| @@ -743,6 +743,8 @@ static unsigned long copy_semid_to_user(void __user *buf, struct semid64_ds *in, · 742 unmodified lines | ||
| 743 | 743 | { |
| 744 | 744 | struct semid_ds out; |
| 745 | 745 | |
| 746 | + memset(&out, 0, sizeof(out)); | |
| 747 | + | |
| 746 | 748 | ipc64_perm_to_ipc_perm(&in->sem_perm, &out.sem_perm); |
| 747 | 749 | |
| 748 | 750 | out.sem_otime = in->sem_otime; |
| @@ -356,10 +356,10 @@ static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm) · 355 unmodified lines | ||
| 356 | 356 | if (IS_ERR(pol)) |
| 357 | 357 | goto fail_nomem_policy; |
| 358 | 358 | vma_set_policy(tmp, pol); |
| 359 | + tmp->vm_mm = mm; | |
| 359 | 360 | if (anon_vma_fork(tmp, mpnt)) |
| 360 | 361 | goto fail_nomem_anon_vma_fork; |
| 361 | 362 | tmp->vm_flags &= ~VM_LOCKED; |
| 362 | − tmp->vm_mm = mm; | |
| 363 | 363 | tmp->vm_next = tmp->vm_prev = NULL; |
| 364 | 364 | file = tmp->vm_file; |
| 365 | 365 | if (file) { |
| @@ -365,8 +365,6 @@ static unsigned int setup_sgl(struct __kfifo *fifo, struct scatterlist *sgl, · 364 unmodified lines | ||
| 365 | 365 | n = setup_sgl_buf(sgl, fifo->data + off, nents, l); |
| 366 | 366 | n += setup_sgl_buf(sgl + n, fifo->data, nents - n, len - l); |
| 367 | 367 | |
| 368 | − if (n) | |
| 369 | − sg_mark_end(sgl + n - 1); | |
| 370 | 368 | return n; |
| 371 | 369 | } |
| 372 | 370 | |
| @@ -1538,6 +1538,7 @@ static int __unlink_module(void *_mod) · 1537 unmodified lines | ||
| 1538 | 1538 | { |
| 1539 | 1539 | struct module *mod = _mod; |
| 1540 | 1540 | list_del(&mod->list); |
| 1541 | + module_bug_cleanup(mod); | |
| 1541 | 1542 | return 0; |
| 1542 | 1543 | } |
| 1543 | 1544 | |
| @@ -2631,6 +2632,7 @@ static struct module *load_module(void __user *umod, · 1087 unmodified lines | ||
| 2631 | 2632 | if (err < 0) |
| 2632 | 2633 | goto ddebug; |
| 2633 | 2634 | |
| 2635 | + module_bug_finalize(info.hdr, info.sechdrs, mod); | |
| 2634 | 2636 | list_add_rcu(&mod->list, &modules); |
| 2635 | 2637 | mutex_unlock(&module_mutex); |
| 2636 | 2638 | |
| @@ -2656,6 +2658,8 @@ static struct module *load_module(void __user *umod, · 19 unmodified lines | ||
| 2656 | 2658 | mutex_lock(&module_mutex); |
| 2657 | 2659 | /* Unlink carefully: kallsyms could be walking list. */ |
| 2658 | 2660 | list_del_rcu(&mod->list); |
| 2661 | + module_bug_cleanup(mod); | |
| 2662 | + | |
| 2659 | 2663 | ddebug: |
| 2660 | 2664 | if (!mod->taints) |
| 2661 | 2665 | dynamic_debug_remove(info.debug); |
| @@ -365,9 +365,10 @@ call: · 364 unmodified lines | ||
| 365 | 365 | EXPORT_SYMBOL_GPL(smp_call_function_any); |
| 366 | 366 | |
| 367 | 367 | /** |
| 368 | − * __smp_call_function_single(): Run a function on another CPU | |
| 368 | + * __smp_call_function_single(): Run a function on a specific CPU | |
| 369 | 369 | * @cpu: The CPU to run on. |
| 370 | 370 | * @data: Pre-allocated and setup data structure |
| 371 | + * @wait: If true, wait until function has completed on specified CPU. | |
| 371 | 372 | * |
| 372 | 373 | * Like smp_call_function_single(), but allow caller to pass in a |
| 373 | 374 | * pre-allocated data structure. Useful for embedding @data inside |
| @@ -376,8 +377,10 @@ EXPORT_SYMBOL_GPL(smp_call_function_any); · 2 unmodified lines | ||
| 376 | 377 | void __smp_call_function_single(int cpu, struct call_single_data *data, |
| 377 | 378 | int wait) |
| 378 | 379 | { |
| 379 | − csd_lock(data); | |
| 380 | + unsigned int this_cpu; | |
| 381 | + unsigned long flags; | |
| 380 | 382 | |
| 383 | + this_cpu = get_cpu(); | |
| 381 | 384 | /* |
| 382 | 385 | * Can deadlock when called with interrupts disabled. |
| 383 | 386 | * We allow cpu's that are not yet online though, as no one else can |
| @@ -387,7 +390,15 @@ void __smp_call_function_single(int cpu, struct call_single_data *data, · 3 unmodified lines | ||
| 387 | 390 | WARN_ON_ONCE(cpu_online(smp_processor_id()) && wait && irqs_disabled() |
| 388 | 391 | && !oops_in_progress); |
| 389 | 392 | |
| 390 | − generic_exec_single(cpu, data, wait); | |
| 393 | + if (cpu == this_cpu) { | |
| 394 | + local_irq_save(flags); | |
| 395 | + data->func(data->info); | |
| 396 | + local_irq_restore(flags); | |
| 397 | + } else { | |
| 398 | + csd_lock(data); | |
| 399 | + generic_exec_single(cpu, data, wait); | |
| 400 | + } | |
| 401 | + put_cpu(); | |
| 391 | 402 | } |
| 392 | 403 | |
| 393 | 404 | /** |
| @@ -72,8 +72,8 @@ static const struct bug_entry *module_find_bug(unsigned long bugaddr) · 71 unmodified lines | ||
| 72 | 72 | return NULL; |
| 73 | 73 | } |
| 74 | 74 | |
| 75 | −int module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, | |
| 76 | − struct module *mod) | |
| 75 | +void module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, | |
| 76 | + struct module *mod) | |
| 77 | 77 | { |
| 78 | 78 | char *secstrings; |
| 79 | 79 | unsigned int i; |
| @@ -97,8 +97,6 @@ int module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, · 17 unmodified lines | ||
| 97 | 97 | * could potentially lead to deadlock and thus be counter-productive. |
| 98 | 98 | */ |
| 99 | 99 | list_add(&mod->bug_list, &module_bug_list); |
| 100 | − | |
| 101 | − return 0; | |
| 102 | 100 | } |
| 103 | 101 | |
| 104 | 102 | void module_bug_cleanup(struct module *mod) |
| @@ -70,7 +70,7 @@ static void merge_and_restore_back_links(void *priv, · 69 unmodified lines | ||
| 70 | 70 | * element comparison is needed, so the client's cmp() |
| 71 | 71 | * routine can invoke cond_resched() periodically. |
| 72 | 72 | */ |
| 73 | − (*cmp)(priv, tail, tail); | |
| 73 | + (*cmp)(priv, tail->next, tail->next); | |
| 74 | 74 | |
| 75 | 75 | tail->next->prev = tail; |
| 76 | 76 | tail = tail->next; |
| @@ -125,7 +125,6 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size, · 124 unmodified lines | ||
| 125 | 125 | { |
| 126 | 126 | struct mm_struct *mm = current->mm; |
| 127 | 127 | struct address_space *mapping; |
| 128 | − unsigned long end = start + size; | |
| 129 | 128 | struct vm_area_struct *vma; |
| 130 | 129 | int err = -EINVAL; |
| 131 | 130 | int has_write_lock = 0; |
| @@ -142,6 +141,10 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size, · 10 unmodified lines | ||
| 142 | 141 | if (start + size <= start) |
| 143 | 142 | return err; |
| 144 | 143 | |
| 144 | + /* Does pgoff wrap? */ | |
| 145 | + if (pgoff + (size >> PAGE_SHIFT) < pgoff) | |
| 146 | + return err; | |
| 147 | + | |
| 145 | 148 | /* Can we represent this offset inside this architecture's pte's? */ |
| 146 | 149 | #if PTE_FILE_MAX_BITS < BITS_PER_LONG |
| 147 | 150 | if (pgoff + (size >> PAGE_SHIFT) >= (1UL << PTE_FILE_MAX_BITS)) |
| @@ -168,7 +171,7 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size, · 20 unmodified lines | ||
| 168 | 171 | if (!(vma->vm_flags & VM_CAN_NONLINEAR)) |
| 169 | 172 | goto out; |
| 170 | 173 | |
| 171 | − if (end <= start || start < vma->vm_start || end > vma->vm_end) | |
| 174 | + if (start < vma->vm_start || start + size > vma->vm_end) | |
| 172 | 175 | goto out; |
| 173 | 176 | |
| 174 | 177 | /* Must set VM_NONLINEAR before any pages are populated. */ |
| @@ -2324,11 +2324,8 @@ retry_avoidcopy: · 2323 unmodified lines | ||
| 2324 | 2324 | * and just make the page writable */ |
| 2325 | 2325 | avoidcopy = (page_mapcount(old_page) == 1); |
| 2326 | 2326 | if (avoidcopy) { |
| 2327 | − if (!trylock_page(old_page)) { | |
| 2328 | − if (PageAnon(old_page)) | |
| 2329 | − page_move_anon_rmap(old_page, vma, address); | |
| 2330 | − } else | |
| 2331 | − unlock_page(old_page); | |
| 2327 | + if (PageAnon(old_page)) | |
| 2328 | + page_move_anon_rmap(old_page, vma, address); | |
| 2332 | 2329 | set_huge_ptep_writable(vma, address, ptep); |
| 2333 | 2330 | return 0; |
| 2334 | 2331 | } |
| @@ -2404,7 +2401,7 @@ retry_avoidcopy: · 69 unmodified lines | ||
| 2404 | 2401 | set_huge_pte_at(mm, address, ptep, |
| 2405 | 2402 | make_huge_pte(vma, new_page, 1)); |
| 2406 | 2403 | page_remove_rmap(old_page); |
| 2407 | − hugepage_add_anon_rmap(new_page, vma, address); | |
| 2404 | + hugepage_add_new_anon_rmap(new_page, vma, address); | |
| 2408 | 2405 | /* Make the old page be freed below */ |
| 2409 | 2406 | new_page = old_page; |
| 2410 | 2407 | mmu_notifier_invalidate_range_end(mm, |
| @@ -2631,10 +2628,16 @@ int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, · 220 unmodified lines | ||
| 2631 | 2628 | vma, address); |
| 2632 | 2629 | } |
| 2633 | 2630 | |
| 2634 | − if (!pagecache_page) { | |
| 2635 | − page = pte_page(entry); | |
| 2631 | + /* | |
| 2632 | + * hugetlb_cow() requires page locks of pte_page(entry) and | |
| 2633 | + * pagecache_page, so here we need take the former one | |
| 2634 | + * when page != pagecache_page or !pagecache_page. | |
| 2635 | + * Note that locking order is always pagecache_page -> page, | |
| 2636 | + * so no worry about deadlock. | |
| 2637 | + */ | |
| 2638 | + page = pte_page(entry); | |
| 2639 | + if (page != pagecache_page) | |
| 2636 | 2640 | lock_page(page); |
| 2637 | − } | |
| 2638 | 2641 | |
| 2639 | 2642 | spin_lock(&mm->page_table_lock); |
| 2640 | 2643 | /* Check for a racing update before calling hugetlb_cow */ |
| @@ -2661,9 +2664,8 @@ out_page_table_lock: · 20 unmodified lines | ||
| 2661 | 2664 | if (pagecache_page) { |
| 2662 | 2665 | unlock_page(pagecache_page); |
| 2663 | 2666 | put_page(pagecache_page); |
| 2664 | − } else { | |
| 2665 | − unlock_page(page); | |
| 2666 | 2667 | } |
| 2668 | + unlock_page(page); | |
| 2667 | 2669 | |
| 2668 | 2670 | out_mutex: |
| 2669 | 2671 | mutex_unlock(&hugetlb_instantiation_mutex); |
| @@ -712,7 +712,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page, · 711 unmodified lines | ||
| 712 | 712 | if (!ptep) |
| 713 | 713 | goto out; |
| 714 | 714 | |
| 715 | − if (pte_write(*ptep)) { | |
| 715 | + if (pte_write(*ptep) || pte_dirty(*ptep)) { | |
| 716 | 716 | pte_t entry; |
| 717 | 717 | |
| 718 | 718 | swapped = PageSwapCache(page); |
| @@ -735,7 +735,9 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page, · 16 unmodified lines | ||
| 735 | 735 | set_pte_at(mm, addr, ptep, entry); |
| 736 | 736 | goto out_unlock; |
| 737 | 737 | } |
| 738 | − entry = pte_wrprotect(entry); | |
| 738 | + if (pte_dirty(entry)) | |
| 739 | + set_page_dirty(page); | |
| 740 | + entry = pte_mkclean(pte_wrprotect(entry)); | |
| 739 | 741 | set_pte_at_notify(mm, addr, ptep, entry); |
| 740 | 742 | } |
| 741 | 743 | *orig_pte = *ptep; |
| @@ -2009,6 +2009,7 @@ static int __split_vma(struct mm_struct * mm, struct vm_area_struct * vma, · 2008 unmodified lines | ||
| 2009 | 2009 | removed_exe_file_vma(mm); |
| 2010 | 2010 | fput(new->vm_file); |
| 2011 | 2011 | } |
| 2012 | + unlink_anon_vmas(new); | |
| 2012 | 2013 | out_free_mpol: |
| 2013 | 2014 | mpol_put(pol); |
| 2014 | 2015 | out_free_vma: |
| @@ -121,8 +121,8 @@ struct task_struct *find_lock_task_mm(struct task_struct *p) · 120 unmodified lines | ||
| 121 | 121 | } |
| 122 | 122 | |
| 123 | 123 | /* return true if the task is not adequate as candidate victim task. */ |
| 124 | −static bool oom_unkillable_task(struct task_struct *p, struct mem_cgroup *mem, | |
| 125 | − const nodemask_t *nodemask) | |
| 124 | +static bool oom_unkillable_task(struct task_struct *p, | |
| 125 | + const struct mem_cgroup *mem, const nodemask_t *nodemask) | |
| 126 | 126 | { |
| 127 | 127 | if (is_global_init(p)) |
| 128 | 128 | return true; |
| @@ -208,8 +208,13 @@ unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem, · 79 unmodified lines | ||
| 208 | 208 | */ |
| 209 | 209 | points += p->signal->oom_score_adj; |
| 210 | 210 | |
| 211 | − if (points < 0) | |
| 212 | − return 0; | |
| 211 | + /* | |
| 212 | + * Never return 0 for an eligible task that may be killed since it's | |
| 213 | + * possible that no single user task uses more than 0.1% of memory and | |
| 214 | + * no single admin tasks uses more than 3.0%. | |
| 215 | + */ | |
| 216 | + if (points <= 0) | |
| 217 | + return 1; | |
| 213 | 218 | return (points < 1000) ? points : 1000; |
| 214 | 219 | } |
| 215 | 220 | |
| @@ -339,26 +344,24 @@ static struct task_struct *select_bad_process(unsigned int *ppoints, · 123 unmodified lines | ||
| 339 | 344 | /** |
| 340 | 345 | * dump_tasks - dump current memory state of all system tasks |
| 341 | 346 | * @mem: current's memory controller, if constrained |
| 347 | + * @nodemask: nodemask passed to page allocator for mempolicy ooms | |
| 342 | 348 | * |
| 343 | − * Dumps the current memory state of all system tasks, excluding kernel threads. | |
| 349 | + * Dumps the current memory state of all eligible tasks. Tasks not in the same | |
| 350 | + * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes | |
| 351 | + * are not shown. | |
| 344 | 352 | * State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj |
| 345 | 353 | * value, oom_score_adj value, and name. |
| 346 | 354 | * |
| 347 | − * If the actual is non-NULL, only tasks that are a member of the mem_cgroup are | |
| 348 | − * shown. | |
| 349 | − * | |
| 350 | 355 | * Call with tasklist_lock read-locked. |
| 351 | 356 | */ |
| 352 | −static void dump_tasks(const struct mem_cgroup *mem) | |
| 357 | +static void dump_tasks(const struct mem_cgroup *mem, const nodemask_t *nodemask) | |
| 353 | 358 | { |
| 354 | 359 | struct task_struct *p; |
| 355 | 360 | struct task_struct *task; |
| 356 | 361 | |
| 357 | 362 | pr_info("[ pid ] uid tgid total_vm rss cpu oom_adj oom_score_adj name\n"); |
| 358 | 363 | for_each_process(p) { |
| 359 | − if (p->flags & PF_KTHREAD) | |
| 360 | − continue; | |
| 361 | − if (mem && !task_in_mem_cgroup(p, mem)) | |
| 364 | + if (oom_unkillable_task(p, mem, nodemask)) | |
| 362 | 365 | continue; |
| 363 | 366 | |
| 364 | 367 | task = find_lock_task_mm(p); |
| @@ -381,7 +384,7 @@ static void dump_tasks(const struct mem_cgroup *mem) · 16 unmodified lines | ||
| 381 | 384 | } |
| 382 | 385 | |
| 383 | 386 | static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order, |
| 384 | − struct mem_cgroup *mem) | |
| 387 | + struct mem_cgroup *mem, const nodemask_t *nodemask) | |
| 385 | 388 | { |
| 386 | 389 | task_lock(current); |
| 387 | 390 | pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, " |
| @@ -394,7 +397,7 @@ static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order, · 6 unmodified lines | ||
| 394 | 397 | mem_cgroup_print_oom_info(mem, p); |
| 395 | 398 | show_mem(); |
| 396 | 399 | if (sysctl_oom_dump_tasks) |
| 397 | − dump_tasks(mem); | |
| 400 | + dump_tasks(mem, nodemask); | |
| 398 | 401 | } |
| 399 | 402 | |
| 400 | 403 | #define K(x) ((x) << (PAGE_SHIFT-10)) |
| @@ -436,7 +439,7 @@ static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order, · 35 unmodified lines | ||
| 436 | 439 | unsigned int victim_points = 0; |
| 437 | 440 | |
| 438 | 441 | if (printk_ratelimit()) |
| 439 | − dump_header(p, gfp_mask, order, mem); | |
| 442 | + dump_header(p, gfp_mask, order, mem, nodemask); | |
| 440 | 443 | |
| 441 | 444 | /* |
| 442 | 445 | * If the task is already exiting, don't alarm the sysadmin or kill |
| @@ -482,7 +485,7 @@ static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order, · 39 unmodified lines | ||
| 482 | 485 | * Determines whether the kernel must panic because of the panic_on_oom sysctl. |
| 483 | 486 | */ |
| 484 | 487 | static void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask, |
| 485 | − int order) | |
| 488 | + int order, const nodemask_t *nodemask) | |
| 486 | 489 | { |
| 487 | 490 | if (likely(!sysctl_panic_on_oom)) |
| 488 | 491 | return; |
| @@ -496,7 +499,7 @@ static void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask, · 7 unmodified lines | ||
| 496 | 499 | return; |
| 497 | 500 | } |
| 498 | 501 | read_lock(&tasklist_lock); |
| 499 | − dump_header(NULL, gfp_mask, order, NULL); | |
| 502 | + dump_header(NULL, gfp_mask, order, NULL, nodemask); | |
| 500 | 503 | read_unlock(&tasklist_lock); |
| 501 | 504 | panic("Out of memory: %s panic_on_oom is enabled\n", |
| 502 | 505 | sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide"); |
| @@ -509,7 +512,7 @@ void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask) · 6 unmodified lines | ||
| 509 | 512 | unsigned int points = 0; |
| 510 | 513 | struct task_struct *p; |
| 511 | 514 | |
| 512 | − check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, 0); | |
| 515 | + check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, 0, NULL); | |
| 513 | 516 | limit = mem_cgroup_get_limit(mem) >> PAGE_SHIFT; |
| 514 | 517 | read_lock(&tasklist_lock); |
| 515 | 518 | retry: |
| @@ -641,6 +644,7 @@ static void clear_system_oom(void) · 125 unmodified lines | ||
| 641 | 644 | void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, |
| 642 | 645 | int order, nodemask_t *nodemask) |
| 643 | 646 | { |
| 647 | + const nodemask_t *mpol_mask; | |
| 644 | 648 | struct task_struct *p; |
| 645 | 649 | unsigned long totalpages; |
| 646 | 650 | unsigned long freed = 0; |
| @@ -670,7 +674,8 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, · 23 unmodified lines | ||
| 670 | 674 | */ |
| 671 | 675 | constraint = constrained_alloc(zonelist, gfp_mask, nodemask, |
| 672 | 676 | &totalpages); |
| 673 | − check_panic_on_oom(constraint, gfp_mask, order); | |
| 677 | + mpol_mask = (constraint == CONSTRAINT_MEMORY_POLICY) ? nodemask : NULL; | |
| 678 | + check_panic_on_oom(constraint, gfp_mask, order, mpol_mask); | |
| 674 | 679 | |
| 675 | 680 | read_lock(&tasklist_lock); |
| 676 | 681 | if (sysctl_oom_kill_allocating_task && |
| @@ -688,15 +693,13 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, · 11 unmodified lines | ||
| 688 | 693 | } |
| 689 | 694 | |
| 690 | 695 | retry: |
| 691 | − p = select_bad_process(&points, totalpages, NULL, | |
| 692 | − constraint == CONSTRAINT_MEMORY_POLICY ? nodemask : | |
| 693 | − NULL); | |
| 696 | + p = select_bad_process(&points, totalpages, NULL, mpol_mask); | |
| 694 | 697 | if (PTR_ERR(p) == -1UL) |
| 695 | 698 | goto out; |
| 696 | 699 | |
| 697 | 700 | /* Found nothing?!?! Either we hang forever, or we panic. */ |
| 698 | 701 | if (!p) { |
| 699 | − dump_header(NULL, gfp_mask, order, NULL); | |
| 702 | + dump_header(NULL, gfp_mask, order, NULL, mpol_mask); | |
| 700 | 703 | read_unlock(&tasklist_lock); |
| 701 | 704 | panic("Out of memory and no killable processes...\n"); |
| 702 | 705 | } |
| @@ -1401,9 +1401,9 @@ int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai, · 1400 unmodified lines | ||
| 1401 | 1401 | |
| 1402 | 1402 | if (pcpu_first_unit_cpu == NR_CPUS) |
| 1403 | 1403 | pcpu_first_unit_cpu = cpu; |
| 1404 | + pcpu_last_unit_cpu = cpu; | |
| 1404 | 1405 | } |
| 1405 | 1406 | } |
| 1406 | − pcpu_last_unit_cpu = cpu; | |
| 1407 | 1407 | pcpu_nr_units = unit; |
| 1408 | 1408 | |
| 1409 | 1409 | for_each_possible_cpu(cpu) |
| @@ -381,7 +381,13 @@ vma_address(struct page *page, struct vm_area_struct *vma) · 380 unmodified lines | ||
| 381 | 381 | unsigned long page_address_in_vma(struct page *page, struct vm_area_struct *vma) |
| 382 | 382 | { |
| 383 | 383 | if (PageAnon(page)) { |
| 384 | − if (vma->anon_vma->root != page_anon_vma(page)->root) | |
| 384 | + struct anon_vma *page__anon_vma = page_anon_vma(page); | |
| 385 | + /* | |
| 386 | + * Note: swapoff's unuse_vma() is more efficient with this | |
| 387 | + * check, and needs it to match anon_vma when KSM is active. | |
| 388 | + */ | |
| 389 | + if (!vma->anon_vma || !page__anon_vma || | |
| 390 | + vma->anon_vma->root != page__anon_vma->root) | |
| 385 | 391 | return -EFAULT; |
| 386 | 392 | } else if (page->mapping && !(vma->vm_flags & VM_NONLINEAR)) { |
| 387 | 393 | if (!vma->vm_file || |
| @@ -1564,13 +1570,14 @@ static void __hugepage_set_anon_rmap(struct page *page, · 1176 unmodified lines | ||
| 1564 | 1570 | struct vm_area_struct *vma, unsigned long address, int exclusive) |
| 1565 | 1571 | { |
| 1566 | 1572 | struct anon_vma *anon_vma = vma->anon_vma; |
| 1573 | + | |
| 1567 | 1574 | BUG_ON(!anon_vma); |
| 1568 | − if (!exclusive) { | |
| 1569 | − struct anon_vma_chain *avc; | |
| 1570 | − avc = list_entry(vma->anon_vma_chain.prev, | |
| 1571 | − struct anon_vma_chain, same_vma); | |
| 1572 | − anon_vma = avc->anon_vma; | |
| 1573 | − } | |
| 1575 | + | |
| 1576 | + if (PageAnon(page)) | |
| 1577 | + return; | |
| 1578 | + if (!exclusive) | |
| 1579 | + anon_vma = anon_vma->root; | |
| 1580 | + | |
| 1574 | 1581 | anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON; |
| 1575 | 1582 | page->mapping = (struct address_space *) anon_vma; |
| 1576 | 1583 | page->index = linear_page_index(vma, address); |
| @@ -1581,6 +1588,8 @@ void hugepage_add_anon_rmap(struct page *page, · 4 unmodified lines | ||
| 1581 | 1588 | { |
| 1582 | 1589 | struct anon_vma *anon_vma = vma->anon_vma; |
| 1583 | 1590 | int first; |
| 1591 | + | |
| 1592 | + BUG_ON(!PageLocked(page)); | |
| 1584 | 1593 | BUG_ON(!anon_vma); |
| 1585 | 1594 | BUG_ON(address < vma->vm_start || address >= vma->vm_end); |
| 1586 | 1595 | first = atomic_inc_and_test(&page->_mapcount); |
| @@ -1804,12 +1804,11 @@ static void shrink_zone(int priority, struct zone *zone, · 1803 unmodified lines | ||
| 1804 | 1804 | * If a zone is deemed to be full of pinned pages then just give it a light |
| 1805 | 1805 | * scan then give up on it. |
| 1806 | 1806 | */ |
| 1807 | −static bool shrink_zones(int priority, struct zonelist *zonelist, | |
| 1807 | +static void shrink_zones(int priority, struct zonelist *zonelist, | |
| 1808 | 1808 | struct scan_control *sc) |
| 1809 | 1809 | { |
| 1810 | 1810 | struct zoneref *z; |
| 1811 | 1811 | struct zone *zone; |
| 1812 | − bool all_unreclaimable = true; | |
| 1813 | 1812 | |
| 1814 | 1813 | for_each_zone_zonelist_nodemask(zone, z, zonelist, |
| 1815 | 1814 | gfp_zone(sc->gfp_mask), sc->nodemask) { |
| @@ -1827,8 +1826,38 @@ static bool shrink_zones(int priority, struct zonelist *zonelist, · 11 unmodified lines | ||
| 1827 | 1826 | } |
| 1828 | 1827 | |
| 1829 | 1828 | shrink_zone(priority, zone, sc); |
| 1830 | − all_unreclaimable = false; | |
| 1831 | 1829 | } |
| 1830 | +} | |
| 1831 | + | |
| 1832 | +static bool zone_reclaimable(struct zone *zone) | |
| 1833 | +{ | |
| 1834 | + return zone->pages_scanned < zone_reclaimable_pages(zone) * 6; | |
| 1835 | +} | |
| 1836 | + | |
| 1837 | +/* | |
| 1838 | + * As hibernation is going on, kswapd is freezed so that it can't mark | |
| 1839 | + * the zone into all_unreclaimable. It can't handle OOM during hibernation. | |
| 1840 | + * So let's check zone's unreclaimable in direct reclaim as well as kswapd. | |
| 1841 | + */ | |
| 1842 | +static bool all_unreclaimable(struct zonelist *zonelist, | |
| 1843 | + struct scan_control *sc) | |
| 1844 | +{ | |
| 1845 | + struct zoneref *z; | |
| 1846 | + struct zone *zone; | |
| 1847 | + bool all_unreclaimable = true; | |
| 1848 | + | |
| 1849 | + for_each_zone_zonelist_nodemask(zone, z, zonelist, | |
| 1850 | + gfp_zone(sc->gfp_mask), sc->nodemask) { | |
| 1851 | + if (!populated_zone(zone)) | |
| 1852 | + continue; | |
| 1853 | + if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL)) | |
| 1854 | + continue; | |
| 1855 | + if (zone_reclaimable(zone)) { | |
| 1856 | + all_unreclaimable = false; | |
| 1857 | + break; | |
| 1858 | + } | |
| 1859 | + } | |
| 1860 | + | |
| 1832 | 1861 | return all_unreclaimable; |
| 1833 | 1862 | } |
| 1834 | 1863 | |
| @@ -1852,7 +1881,6 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist, · 17 unmodified lines | ||
| 1852 | 1881 | struct scan_control *sc) |
| 1853 | 1882 | { |
| 1854 | 1883 | int priority; |
| 1855 | − bool all_unreclaimable; | |
| 1856 | 1884 | unsigned long total_scanned = 0; |
| 1857 | 1885 | struct reclaim_state *reclaim_state = current->reclaim_state; |
| 1858 | 1886 | struct zoneref *z; |
| @@ -1869,7 +1897,7 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist, · 10 unmodified lines | ||
| 1869 | 1897 | sc->nr_scanned = 0; |
| 1870 | 1898 | if (!priority) |
| 1871 | 1899 | disable_swap_token(); |
| 1872 | − all_unreclaimable = shrink_zones(priority, zonelist, sc); | |
| 1900 | + shrink_zones(priority, zonelist, sc); | |
| 1873 | 1901 | /* |
| 1874 | 1902 | * Don't shrink slabs when reclaiming memory from |
| 1875 | 1903 | * over limit cgroups |
| @@ -1931,7 +1959,7 @@ out: · 55 unmodified lines | ||
| 1931 | 1959 | return sc->nr_reclaimed; |
| 1932 | 1960 | |
| 1933 | 1961 | /* top priority shrink_zones still had more to do? don't OOM, then */ |
| 1934 | − if (scanning_global_lru(sc) && !all_unreclaimable) | |
| 1962 | + if (scanning_global_lru(sc) && !all_unreclaimable(zonelist, sc)) | |
| 1935 | 1963 | return 1; |
| 1936 | 1964 | |
| 1937 | 1965 | return 0; |
| @@ -2197,8 +2225,7 @@ loop_again: · 259 unmodified lines | ||
| 2197 | 2225 | total_scanned += sc.nr_scanned; |
| 2198 | 2226 | if (zone->all_unreclaimable) |
| 2199 | 2227 | continue; |
| 2200 | − if (nr_slab == 0 && | |
| 2201 | − zone->pages_scanned >= (zone_reclaimable_pages(zone) * 6)) | |
| 2228 | + if (nr_slab == 0 && !zone_reclaimable(zone)) | |
| 2202 | 2229 | zone->all_unreclaimable = 1; |
| 2203 | 2230 | /* |
| 2204 | 2231 | * If we've done a decent amount of scanning and |
| @@ -24,8 +24,11 @@ int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp, · 23 unmodified lines | ||
| 24 | 24 | |
| 25 | 25 | if (vlan_dev) |
| 26 | 26 | skb->dev = vlan_dev; |
| 27 | − else if (vlan_id) | |
| 28 | − goto drop; | |
| 27 | + else if (vlan_id) { | |
| 28 | + if (!(skb->dev->flags & IFF_PROMISC)) | |
| 29 | + goto drop; | |
| 30 | + skb->pkt_type = PACKET_OTHERHOST; | |
| 31 | + } | |
| 29 | 32 | |
| 30 | 33 | return (polling ? netif_receive_skb(skb) : netif_rx(skb)); |
| 31 | 34 | |
| @@ -102,8 +105,11 @@ vlan_gro_common(struct napi_struct *napi, struct vlan_group *grp, · 70 unmodified lines | ||
| 102 | 105 | |
| 103 | 106 | if (vlan_dev) |
| 104 | 107 | skb->dev = vlan_dev; |
| 105 | − else if (vlan_id) | |
| 106 | − goto drop; | |
| 108 | + else if (vlan_id) { | |
| 109 | + if (!(skb->dev->flags & IFF_PROMISC)) | |
| 110 | + goto drop; | |
| 111 | + skb->pkt_type = PACKET_OTHERHOST; | |
| 112 | + } | |
| 107 | 113 | |
| 108 | 114 | for (p = napi->gro_list; p; p = p->next) { |
| 109 | 115 | NAPI_GRO_CB(p)->same_flow = |
| @@ -426,8 +426,10 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req) · 425 unmodified lines | ||
| 426 | 426 | |
| 427 | 427 | /* Allocate an fcall for the reply */ |
| 428 | 428 | rpl_context = kmalloc(sizeof *rpl_context, GFP_KERNEL); |
| 429 | − if (!rpl_context) | |
| 429 | + if (!rpl_context) { | |
| 430 | + err = -ENOMEM; | |
| 430 | 431 | goto err_close; |
| 432 | + } | |
| 431 | 433 | |
| 432 | 434 | /* |
| 433 | 435 | * If the request has a buffer, steal it, otherwise |
| @@ -445,8 +447,8 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req) · 11 unmodified lines | ||
| 445 | 447 | } |
| 446 | 448 | rpl_context->rc = req->rc; |
| 447 | 449 | if (!rpl_context->rc) { |
| 448 | − kfree(rpl_context); | |
| 449 | − goto err_close; | |
| 450 | + err = -ENOMEM; | |
| 451 | + goto err_free2; | |
| 450 | 452 | } |
| 451 | 453 | |
| 452 | 454 | /* |
| @@ -458,11 +460,8 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req) · 5 unmodified lines | ||
| 458 | 460 | */ |
| 459 | 461 | if (atomic_inc_return(&rdma->rq_count) <= rdma->rq_depth) { |
| 460 | 462 | err = post_recv(client, rpl_context); |
| 461 | − if (err) { | |
| 462 | − kfree(rpl_context->rc); | |
| 463 | − kfree(rpl_context); | |
| 464 | − goto err_close; | |
| 465 | − } | |
| 463 | + if (err) | |
| 464 | + goto err_free1; | |
| 466 | 465 | } else |
| 467 | 466 | atomic_dec(&rdma->rq_count); |
| 468 | 467 | |
| @@ -471,8 +470,10 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req) · 2 unmodified lines | ||
| 471 | 470 | |
| 472 | 471 | /* Post the request */ |
| 473 | 472 | c = kmalloc(sizeof *c, GFP_KERNEL); |
| 474 | − if (!c) | |
| 475 | − goto err_close; | |
| 473 | + if (!c) { | |
| 474 | + err = -ENOMEM; | |
| 475 | + goto err_free1; | |
| 476 | + } | |
| 476 | 477 | c->req = req; |
| 477 | 478 | |
| 478 | 479 | c->busa = ib_dma_map_single(rdma->cm_id->device, |
| @@ -499,9 +500,15 @@ static int rdma_request(struct p9_client *client, struct p9_req_t *req) · 20 unmodified lines | ||
| 499 | 500 | return ib_post_send(rdma->qp, &wr, &bad_wr); |
| 500 | 501 | |
| 501 | 502 | error: |
| 503 | + kfree(c); | |
| 504 | + kfree(rpl_context->rc); | |
| 505 | + kfree(rpl_context); | |
| 502 | 506 | P9_DPRINTK(P9_DEBUG_ERROR, "EIO\n"); |
| 503 | 507 | return -EIO; |
| 504 | − | |
| 508 | + err_free1: | |
| 509 | + kfree(rpl_context->rc); | |
| 510 | + err_free2: | |
| 511 | + kfree(rpl_context); | |
| 505 | 512 | err_close: |
| 506 | 513 | spin_lock_irqsave(&rdma->req_lock, flags); |
| 507 | 514 | if (rdma->state < P9_RDMA_CLOSING) { |
| @@ -329,7 +329,8 @@ p9_virtio_create(struct p9_client *client, const char *devname, char *args) · 328 unmodified lines | ||
| 329 | 329 | |
| 330 | 330 | mutex_lock(&virtio_9p_lock); |
| 331 | 331 | list_for_each_entry(chan, &virtio_chan_list, chan_list) { |
| 332 | − if (!strncmp(devname, chan->tag, chan->tag_len)) { | |
| 332 | + if (!strncmp(devname, chan->tag, chan->tag_len) && | |
| 333 | + strlen(devname) == chan->tag_len) { | |
| 333 | 334 | if (!chan->inuse) { |
| 334 | 335 | chan->inuse = true; |
| 335 | 336 | found = 1; |
| @@ -399,12 +399,6 @@ static void br2684_push(struct atm_vcc *atmvcc, struct sk_buff *skb) · 398 unmodified lines | ||
| 399 | 399 | unregister_netdev(net_dev); |
| 400 | 400 | free_netdev(net_dev); |
| 401 | 401 | } |
| 402 | − read_lock_irq(&devs_lock); | |
| 403 | − if (list_empty(&br2684_devs)) { | |
| 404 | − /* last br2684 device */ | |
| 405 | − unregister_atmdevice_notifier(&atm_dev_notifier); | |
| 406 | − } | |
| 407 | − read_unlock_irq(&devs_lock); | |
| 408 | 402 | return; |
| 409 | 403 | } |
| 410 | 404 | |
| @@ -675,7 +669,6 @@ static int br2684_create(void __user *arg) · 264 unmodified lines | ||
| 675 | 669 | |
| 676 | 670 | if (list_empty(&br2684_devs)) { |
| 677 | 671 | /* 1st br2684 device */ |
| 678 | − register_atmdevice_notifier(&atm_dev_notifier); | |
| 679 | 672 | brdev->number = 1; |
| 680 | 673 | } else |
| 681 | 674 | brdev->number = BRPRIV(list_entry_brdev(br2684_devs.prev))->number + 1; |
| @@ -815,6 +808,7 @@ static int __init br2684_init(void) · 133 unmodified lines | ||
| 815 | 808 | return -ENOMEM; |
| 816 | 809 | #endif |
| 817 | 810 | register_atm_ioctl(&br2684_ioctl_ops); |
| 811 | + register_atmdevice_notifier(&atm_dev_notifier); | |
| 818 | 812 | return 0; |
| 819 | 813 | } |
| 820 | 814 | |
| @@ -830,9 +824,7 @@ static void __exit br2684_exit(void) · 9 unmodified lines | ||
| 830 | 824 | #endif |
| 831 | 825 | |
| 832 | 826 | |
| 833 | − /* if not already empty */ | |
| 834 | − if (!list_empty(&br2684_devs)) | |
| 835 | − unregister_atmdevice_notifier(&atm_dev_notifier); | |
| 827 | + unregister_atmdevice_notifier(&atm_dev_notifier); | |
| 836 | 828 | |
| 837 | 829 | while (!list_empty(&br2684_devs)) { |
| 838 | 830 | net_dev = list_entry_brdev(br2684_devs.next); |
| @@ -35,9 +35,10 @@ · 34 unmodified lines | ||
| 35 | 35 | * in any case. |
| 36 | 36 | */ |
| 37 | 37 | |
| 38 | −int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode) | |
| 38 | +long verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode) | |
| 39 | 39 | { |
| 40 | − int size, err, ct; | |
| 40 | + int size, ct; | |
| 41 | + long err; | |
| 41 | 42 | |
| 42 | 43 | if (m->msg_namelen) { |
| 43 | 44 | if (mode == VERIFY_READ) { |
| @@ -1351,9 +1351,9 @@ int sock_i_uid(struct sock *sk) · 1350 unmodified lines | ||
| 1351 | 1351 | { |
| 1352 | 1352 | int uid; |
| 1353 | 1353 | |
| 1354 | − read_lock(&sk->sk_callback_lock); | |
| 1354 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1355 | 1355 | uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0; |
| 1356 | − read_unlock(&sk->sk_callback_lock); | |
| 1356 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1357 | 1357 | return uid; |
| 1358 | 1358 | } |
| 1359 | 1359 | EXPORT_SYMBOL(sock_i_uid); |
| @@ -1362,9 +1362,9 @@ unsigned long sock_i_ino(struct sock *sk) · 2 unmodified lines | ||
| 1362 | 1362 | { |
| 1363 | 1363 | unsigned long ino; |
| 1364 | 1364 | |
| 1365 | − read_lock(&sk->sk_callback_lock); | |
| 1365 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1366 | 1366 | ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0; |
| 1367 | − read_unlock(&sk->sk_callback_lock); | |
| 1367 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1368 | 1368 | return ino; |
| 1369 | 1369 | } |
| 1370 | 1370 | EXPORT_SYMBOL(sock_i_ino); |
| @@ -217,6 +217,7 @@ config NET_IPIP · 216 unmodified lines | ||
| 217 | 217 | |
| 218 | 218 | config NET_IPGRE |
| 219 | 219 | tristate "IP: GRE tunnels over IP" |
| 220 | + depends on IPV6 || IPV6=n | |
| 220 | 221 | help |
| 221 | 222 | Tunneling means encapsulating data of one protocol type within |
| 222 | 223 | another protocol and sending it over a channel that understands the |
| @@ -45,7 +45,7 @@ · 44 unmodified lines | ||
| 45 | 45 | #include <net/netns/generic.h> |
| 46 | 46 | #include <net/rtnetlink.h> |
| 47 | 47 | |
| 48 | −#ifdef CONFIG_IPV6 | |
| 48 | +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | |
| 49 | 49 | #include <net/ipv6.h> |
| 50 | 50 | #include <net/ip6_fib.h> |
| 51 | 51 | #include <net/ip6_route.h> |
| @@ -699,7 +699,7 @@ static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev · 647 unmodified lines | ||
| 699 | 699 | if ((dst = rt->rt_gateway) == 0) |
| 700 | 700 | goto tx_error_icmp; |
| 701 | 701 | } |
| 702 | −#ifdef CONFIG_IPV6 | |
| 702 | +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | |
| 703 | 703 | else if (skb->protocol == htons(ETH_P_IPV6)) { |
| 704 | 704 | struct in6_addr *addr6; |
| 705 | 705 | int addr_type; |
| @@ -774,7 +774,7 @@ static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev · 68 unmodified lines | ||
| 774 | 774 | goto tx_error; |
| 775 | 775 | } |
| 776 | 776 | } |
| 777 | −#ifdef CONFIG_IPV6 | |
| 777 | +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | |
| 778 | 778 | else if (skb->protocol == htons(ETH_P_IPV6)) { |
| 779 | 779 | struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb); |
| 780 | 780 | |
| @@ -850,7 +850,7 @@ static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev · 69 unmodified lines | ||
| 850 | 850 | if ((iph->ttl = tiph->ttl) == 0) { |
| 851 | 851 | if (skb->protocol == htons(ETH_P_IP)) |
| 852 | 852 | iph->ttl = old_iph->ttl; |
| 853 | −#ifdef CONFIG_IPV6 | |
| 853 | +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) | |
| 854 | 854 | else if (skb->protocol == htons(ETH_P_IPV6)) |
| 855 | 855 | iph->ttl = ((struct ipv6hdr *)old_iph)->hop_limit; |
| 856 | 856 | #endif |
| @@ -488,9 +488,8 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 487 unmodified lines | ||
| 488 | 488 | * we can switch to copy when see the first bad fragment. |
| 489 | 489 | */ |
| 490 | 490 | if (skb_has_frags(skb)) { |
| 491 | − struct sk_buff *frag; | |
| 491 | + struct sk_buff *frag, *frag2; | |
| 492 | 492 | int first_len = skb_pagelen(skb); |
| 493 | − int truesizes = 0; | |
| 494 | 493 | |
| 495 | 494 | if (first_len - hlen > mtu || |
| 496 | 495 | ((first_len - hlen) & 7) || |
| @@ -503,18 +502,18 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 6 unmodified lines | ||
| 503 | 502 | if (frag->len > mtu || |
| 504 | 503 | ((frag->len & 7) && frag->next) || |
| 505 | 504 | skb_headroom(frag) < hlen) |
| 506 | − goto slow_path; | |
| 505 | + goto slow_path_clean; | |
| 507 | 506 | |
| 508 | 507 | /* Partially cloned skb? */ |
| 509 | 508 | if (skb_shared(frag)) |
| 510 | − goto slow_path; | |
| 509 | + goto slow_path_clean; | |
| 511 | 510 | |
| 512 | 511 | BUG_ON(frag->sk); |
| 513 | 512 | if (skb->sk) { |
| 514 | 513 | frag->sk = skb->sk; |
| 515 | 514 | frag->destructor = sock_wfree; |
| 516 | 515 | } |
| 517 | − truesizes += frag->truesize; | |
| 516 | + skb->truesize -= frag->truesize; | |
| 518 | 517 | } |
| 519 | 518 | |
| 520 | 519 | /* Everything is OK. Generate! */ |
| @@ -524,7 +523,6 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 3 unmodified lines | ||
| 524 | 523 | frag = skb_shinfo(skb)->frag_list; |
| 525 | 524 | skb_frag_list_init(skb); |
| 526 | 525 | skb->data_len = first_len - skb_headlen(skb); |
| 527 | − skb->truesize -= truesizes; | |
| 528 | 526 | skb->len = first_len; |
| 529 | 527 | iph->tot_len = htons(first_len); |
| 530 | 528 | iph->frag_off = htons(IP_MF); |
| @@ -576,6 +574,15 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 45 unmodified lines | ||
| 576 | 574 | } |
| 577 | 575 | IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS); |
| 578 | 576 | return err; |
| 577 | + | |
| 578 | +slow_path_clean: | |
| 579 | + skb_walk_frags(skb, frag2) { | |
| 580 | + if (frag2 == frag) | |
| 581 | + break; | |
| 582 | + frag2->sk = NULL; | |
| 583 | + frag2->destructor = NULL; | |
| 584 | + skb->truesize += frag2->truesize; | |
| 585 | + } | |
| 579 | 586 | } |
| 580 | 587 | |
| 581 | 588 | slow_path: |
| @@ -112,6 +112,7 @@ static void send_reset(struct sk_buff *oldskb, int hook) · 111 unmodified lines | ||
| 112 | 112 | /* ip_route_me_harder expects skb->dst to be set */ |
| 113 | 113 | skb_dst_set_noref(nskb, skb_dst(oldskb)); |
| 114 | 114 | |
| 115 | + nskb->protocol = htons(ETH_P_IP); | |
| 115 | 116 | if (ip_route_me_harder(nskb, addr_type)) |
| 116 | 117 | goto free_nskb; |
| 117 | 118 | |
| @@ -66,9 +66,11 @@ static unsigned int ipv4_conntrack_defrag(unsigned int hooknum, · 65 unmodified lines | ||
| 66 | 66 | const struct net_device *out, |
| 67 | 67 | int (*okfn)(struct sk_buff *)) |
| 68 | 68 | { |
| 69 | + struct sock *sk = skb->sk; | |
| 69 | 70 | struct inet_sock *inet = inet_sk(skb->sk); |
| 70 | 71 | |
| 71 | − if (inet && inet->nodefrag) | |
| 72 | + if (sk && (sk->sk_family == PF_INET) && | |
| 73 | + inet->nodefrag) | |
| 72 | 74 | return NF_ACCEPT; |
| 73 | 75 | |
| 74 | 76 | #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) |
| @@ -893,13 +893,15 @@ static void fast_csum(__sum16 *csum, · 892 unmodified lines | ||
| 893 | 893 | unsigned char s[4]; |
| 894 | 894 | |
| 895 | 895 | if (offset & 1) { |
| 896 | − s[0] = s[2] = 0; | |
| 896 | + s[0] = ~0; | |
| 897 | 897 | s[1] = ~*optr; |
| 898 | + s[2] = 0; | |
| 898 | 899 | s[3] = *nptr; |
| 899 | 900 | } else { |
| 900 | − s[1] = s[3] = 0; | |
| 901 | 901 | s[0] = ~*optr; |
| 902 | + s[1] = ~0; | |
| 902 | 903 | s[2] = *nptr; |
| 904 | + s[3] = 0; | |
| 903 | 905 | } |
| 904 | 906 | |
| 905 | 907 | *csum = csum_fold(csum_partial(s, 4, ~csum_unfold(*csum))); |
| @@ -1231,7 +1231,7 @@ restart: · 1230 unmodified lines | ||
| 1231 | 1231 | } |
| 1232 | 1232 | |
| 1233 | 1233 | if (net_ratelimit()) |
| 1234 | − printk(KERN_WARNING "Neighbour table overflow.\n"); | |
| 1234 | + printk(KERN_WARNING "ipv4: Neighbour table overflow.\n"); | |
| 1235 | 1235 | rt_drop(rt); |
| 1236 | 1236 | return -ENOBUFS; |
| 1237 | 1237 | } |
| @@ -386,8 +386,6 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait) · 385 unmodified lines | ||
| 386 | 386 | */ |
| 387 | 387 | |
| 388 | 388 | mask = 0; |
| 389 | − if (sk->sk_err) | |
| 390 | − mask = POLLERR; | |
| 391 | 389 | |
| 392 | 390 | /* |
| 393 | 391 | * POLLHUP is certainly not done right. But poll() doesn't |
| @@ -457,6 +455,11 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait) · 63 unmodified lines | ||
| 457 | 455 | if (tp->urg_data & TCP_URG_VALID) |
| 458 | 456 | mask |= POLLPRI; |
| 459 | 457 | } |
| 458 | + /* This barrier is coupled with smp_wmb() in tcp_reset() */ | |
| 459 | + smp_rmb(); | |
| 460 | + if (sk->sk_err) | |
| 461 | + mask |= POLLERR; | |
| 462 | + | |
| 460 | 463 | return mask; |
| 461 | 464 | } |
| 462 | 465 | EXPORT_SYMBOL(tcp_poll); |
| @@ -940,7 +943,7 @@ int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, · 477 unmodified lines | ||
| 940 | 943 | sg = sk->sk_route_caps & NETIF_F_SG; |
| 941 | 944 | |
| 942 | 945 | while (--iovlen >= 0) { |
| 943 | − int seglen = iov->iov_len; | |
| 946 | + size_t seglen = iov->iov_len; | |
| 944 | 947 | unsigned char __user *from = iov->iov_base; |
| 945 | 948 | |
| 946 | 949 | iov++; |
| @@ -2545,7 +2545,8 @@ static void tcp_mark_head_lost(struct sock *sk, int packets) · 2544 unmodified lines | ||
| 2545 | 2545 | cnt += tcp_skb_pcount(skb); |
| 2546 | 2546 | |
| 2547 | 2547 | if (cnt > packets) { |
| 2548 | − if (tcp_is_sack(tp) || (oldcnt >= packets)) | |
| 2548 | + if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) || | |
| 2549 | + (oldcnt >= packets)) | |
| 2549 | 2550 | break; |
| 2550 | 2551 | |
| 2551 | 2552 | mss = skb_shinfo(skb)->gso_size; |
| @@ -4048,6 +4049,8 @@ static void tcp_reset(struct sock *sk) · 1496 unmodified lines | ||
| 4048 | 4049 | default: |
| 4049 | 4050 | sk->sk_err = ECONNRESET; |
| 4050 | 4051 | } |
| 4052 | + /* This barrier is coupled with smp_rmb() in tcp_poll() */ | |
| 4053 | + smp_wmb(); | |
| 4051 | 4054 | |
| 4052 | 4055 | if (!sock_flag(sk, SOCK_DEAD)) |
| 4053 | 4056 | sk->sk_error_report(sk); |
| @@ -135,13 +135,16 @@ static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk) · 134 unmodified lines | ||
| 135 | 135 | |
| 136 | 136 | /* This function calculates a "timeout" which is equivalent to the timeout of a |
| 137 | 137 | * TCP connection after "boundary" unsuccessful, exponentially backed-off |
| 138 | − * retransmissions with an initial RTO of TCP_RTO_MIN. | |
| 138 | + * retransmissions with an initial RTO of TCP_RTO_MIN or TCP_TIMEOUT_INIT if | |
| 139 | + * syn_set flag is set. | |
| 139 | 140 | */ |
| 140 | 141 | static bool retransmits_timed_out(struct sock *sk, |
| 141 | − unsigned int boundary) | |
| 142 | + unsigned int boundary, | |
| 143 | + bool syn_set) | |
| 142 | 144 | { |
| 143 | 145 | unsigned int timeout, linear_backoff_thresh; |
| 144 | 146 | unsigned int start_ts; |
| 147 | + unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN; | |
| 145 | 148 | |
| 146 | 149 | if (!inet_csk(sk)->icsk_retransmits) |
| 147 | 150 | return false; |
| @@ -151,12 +154,12 @@ static bool retransmits_timed_out(struct sock *sk, · 3 unmodified lines | ||
| 151 | 154 | else |
| 152 | 155 | start_ts = tcp_sk(sk)->retrans_stamp; |
| 153 | 156 | |
| 154 | − linear_backoff_thresh = ilog2(TCP_RTO_MAX/TCP_RTO_MIN); | |
| 157 | + linear_backoff_thresh = ilog2(TCP_RTO_MAX/rto_base); | |
| 155 | 158 | |
| 156 | 159 | if (boundary <= linear_backoff_thresh) |
| 157 | − timeout = ((2 << boundary) - 1) * TCP_RTO_MIN; | |
| 160 | + timeout = ((2 << boundary) - 1) * rto_base; | |
| 158 | 161 | else |
| 159 | − timeout = ((2 << linear_backoff_thresh) - 1) * TCP_RTO_MIN + | |
| 162 | + timeout = ((2 << linear_backoff_thresh) - 1) * rto_base + | |
| 160 | 163 | (boundary - linear_backoff_thresh) * TCP_RTO_MAX; |
| 161 | 164 | |
| 162 | 165 | return (tcp_time_stamp - start_ts) >= timeout; |
| @@ -167,14 +170,15 @@ static int tcp_write_timeout(struct sock *sk) · 4 unmodified lines | ||
| 167 | 170 | { |
| 168 | 171 | struct inet_connection_sock *icsk = inet_csk(sk); |
| 169 | 172 | int retry_until; |
| 170 | − bool do_reset; | |
| 173 | + bool do_reset, syn_set = 0; | |
| 171 | 174 | |
| 172 | 175 | if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { |
| 173 | 176 | if (icsk->icsk_retransmits) |
| 174 | 177 | dst_negative_advice(sk); |
| 175 | 178 | retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries; |
| 179 | + syn_set = 1; | |
| 176 | 180 | } else { |
| 177 | − if (retransmits_timed_out(sk, sysctl_tcp_retries1)) { | |
| 181 | + if (retransmits_timed_out(sk, sysctl_tcp_retries1, 0)) { | |
| 178 | 182 | /* Black hole detection */ |
| 179 | 183 | tcp_mtu_probing(icsk, sk); |
| 180 | 184 | |
| @@ -187,14 +191,14 @@ static int tcp_write_timeout(struct sock *sk) · 6 unmodified lines | ||
| 187 | 191 | |
| 188 | 192 | retry_until = tcp_orphan_retries(sk, alive); |
| 189 | 193 | do_reset = alive || |
| 190 | − !retransmits_timed_out(sk, retry_until); | |
| 194 | + !retransmits_timed_out(sk, retry_until, 0); | |
| 191 | 195 | |
| 192 | 196 | if (tcp_out_of_resources(sk, do_reset)) |
| 193 | 197 | return 1; |
| 194 | 198 | } |
| 195 | 199 | } |
| 196 | 200 | |
| 197 | − if (retransmits_timed_out(sk, retry_until)) { | |
| 201 | + if (retransmits_timed_out(sk, retry_until, syn_set)) { | |
| 198 | 202 | /* Has it gone just too far? */ |
| 199 | 203 | tcp_write_err(sk); |
| 200 | 204 | return 1; |
| @@ -436,7 +440,7 @@ out_reset_timer: · 235 unmodified lines | ||
| 436 | 440 | icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX); |
| 437 | 441 | } |
| 438 | 442 | inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX); |
| 439 | − if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1)) | |
| 443 | + if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1, 0)) | |
| 440 | 444 | __sk_dst_reset(sk); |
| 441 | 445 | |
| 442 | 446 | out:; |
| @@ -61,7 +61,7 @@ static int xfrm4_get_saddr(struct net *net, · 60 unmodified lines | ||
| 61 | 61 | |
| 62 | 62 | static int xfrm4_get_tos(struct flowi *fl) |
| 63 | 63 | { |
| 64 | − return fl->fl4_tos; | |
| 64 | + return IPTOS_RT_MASK & fl->fl4_tos; /* Strip ECN bits */ | |
| 65 | 65 | } |
| 66 | 66 | |
| 67 | 67 | static int xfrm4_init_path(struct xfrm_dst *path, struct dst_entry *dst, |
| @@ -21,21 +21,25 @@ static int xfrm4_init_flags(struct xfrm_state *x) · 20 unmodified lines | ||
| 21 | 21 | } |
| 22 | 22 | |
| 23 | 23 | static void |
| 24 | −__xfrm4_init_tempsel(struct xfrm_state *x, struct flowi *fl, | |
| 25 | − struct xfrm_tmpl *tmpl, | |
| 26 | − xfrm_address_t *daddr, xfrm_address_t *saddr) | |
| 24 | +__xfrm4_init_tempsel(struct xfrm_selector *sel, struct flowi *fl) | |
| 25 | +{ | |
| 26 | + sel->daddr.a4 = fl->fl4_dst; | |
| 27 | + sel->saddr.a4 = fl->fl4_src; | |
| 28 | + sel->dport = xfrm_flowi_dport(fl); | |
| 29 | + sel->dport_mask = htons(0xffff); | |
| 30 | + sel->sport = xfrm_flowi_sport(fl); | |
| 31 | + sel->sport_mask = htons(0xffff); | |
| 32 | + sel->family = AF_INET; | |
| 33 | + sel->prefixlen_d = 32; | |
| 34 | + sel->prefixlen_s = 32; | |
| 35 | + sel->proto = fl->proto; | |
| 36 | + sel->ifindex = fl->oif; | |
| 37 | +} | |
| 38 | + | |
| 39 | +static void | |
| 40 | +xfrm4_init_temprop(struct xfrm_state *x, struct xfrm_tmpl *tmpl, | |
| 41 | + xfrm_address_t *daddr, xfrm_address_t *saddr) | |
| 27 | 42 | { |
| 28 | − x->sel.daddr.a4 = fl->fl4_dst; | |
| 29 | − x->sel.saddr.a4 = fl->fl4_src; | |
| 30 | − x->sel.dport = xfrm_flowi_dport(fl); | |
| 31 | − x->sel.dport_mask = htons(0xffff); | |
| 32 | − x->sel.sport = xfrm_flowi_sport(fl); | |
| 33 | − x->sel.sport_mask = htons(0xffff); | |
| 34 | − x->sel.family = AF_INET; | |
| 35 | − x->sel.prefixlen_d = 32; | |
| 36 | − x->sel.prefixlen_s = 32; | |
| 37 | − x->sel.proto = fl->proto; | |
| 38 | − x->sel.ifindex = fl->oif; | |
| 39 | 43 | x->id = tmpl->id; |
| 40 | 44 | if (x->id.daddr.a4 == 0) |
| 41 | 45 | x->id.daddr.a4 = daddr->a4; |
| @@ -70,6 +74,7 @@ static struct xfrm_state_afinfo xfrm4_state_afinfo = { · 28 unmodified lines | ||
| 70 | 74 | .owner = THIS_MODULE, |
| 71 | 75 | .init_flags = xfrm4_init_flags, |
| 72 | 76 | .init_tempsel = __xfrm4_init_tempsel, |
| 77 | + .init_temprop = xfrm4_init_temprop, | |
| 73 | 78 | .output = xfrm4_output, |
| 74 | 79 | .extract_input = xfrm4_extract_input, |
| 75 | 80 | .extract_output = xfrm4_extract_output, |
| @@ -4637,10 +4637,12 @@ int __init addrconf_init(void) · 4636 unmodified lines | ||
| 4637 | 4637 | if (err < 0) { |
| 4638 | 4638 | printk(KERN_CRIT "IPv6 Addrconf:" |
| 4639 | 4639 | " cannot initialize default policy table: %d.\n", err); |
| 4640 | − return err; | |
| 4640 | + goto out; | |
| 4641 | 4641 | } |
| 4642 | 4642 | |
| 4643 | − register_pernet_subsys(&addrconf_ops); | |
| 4643 | + err = register_pernet_subsys(&addrconf_ops); | |
| 4644 | + if (err < 0) | |
| 4645 | + goto out_addrlabel; | |
| 4644 | 4646 | |
| 4645 | 4647 | /* The addrconf netdev notifier requires that loopback_dev |
| 4646 | 4648 | * has it's ipv6 private information allocated and setup |
| @@ -4692,7 +4694,9 @@ errout: · 45 unmodified lines | ||
| 4692 | 4694 | unregister_netdevice_notifier(&ipv6_dev_notf); |
| 4693 | 4695 | errlo: |
| 4694 | 4696 | unregister_pernet_subsys(&addrconf_ops); |
| 4695 | − | |
| 4697 | +out_addrlabel: | |
| 4698 | + ipv6_addr_label_cleanup(); | |
| 4699 | +out: | |
| 4696 | 4700 | return err; |
| 4697 | 4701 | } |
| 4698 | 4702 | |
| @@ -4703,6 +4707,7 @@ void addrconf_cleanup(void) · 4 unmodified lines | ||
| 4703 | 4707 | |
| 4704 | 4708 | unregister_netdevice_notifier(&ipv6_dev_notf); |
| 4705 | 4709 | unregister_pernet_subsys(&addrconf_ops); |
| 4710 | + ipv6_addr_label_cleanup(); | |
| 4706 | 4711 | |
| 4707 | 4712 | rtnl_lock(); |
| 4708 | 4713 | |
| @@ -393,6 +393,11 @@ int __init ipv6_addr_label_init(void) · 392 unmodified lines | ||
| 393 | 393 | return register_pernet_subsys(&ipv6_addr_label_ops); |
| 394 | 394 | } |
| 395 | 395 | |
| 396 | +void ipv6_addr_label_cleanup(void) | |
| 397 | +{ | |
| 398 | + unregister_pernet_subsys(&ipv6_addr_label_ops); | |
| 399 | +} | |
| 400 | + | |
| 396 | 401 | static const struct nla_policy ifal_policy[IFAL_MAX+1] = { |
| 397 | 402 | [IFAL_ADDRESS] = { .len = sizeof(struct in6_addr), }, |
| 398 | 403 | [IFAL_LABEL] = { .len = sizeof(u32), }, |
| @@ -639,7 +639,7 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 638 unmodified lines | ||
| 639 | 639 | |
| 640 | 640 | if (skb_has_frags(skb)) { |
| 641 | 641 | int first_len = skb_pagelen(skb); |
| 642 | − int truesizes = 0; | |
| 642 | + struct sk_buff *frag2; | |
| 643 | 643 | |
| 644 | 644 | if (first_len - hlen > mtu || |
| 645 | 645 | ((first_len - hlen) & 7) || |
| @@ -651,18 +651,18 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 5 unmodified lines | ||
| 651 | 651 | if (frag->len > mtu || |
| 652 | 652 | ((frag->len & 7) && frag->next) || |
| 653 | 653 | skb_headroom(frag) < hlen) |
| 654 | − goto slow_path; | |
| 654 | + goto slow_path_clean; | |
| 655 | 655 | |
| 656 | 656 | /* Partially cloned skb? */ |
| 657 | 657 | if (skb_shared(frag)) |
| 658 | − goto slow_path; | |
| 658 | + goto slow_path_clean; | |
| 659 | 659 | |
| 660 | 660 | BUG_ON(frag->sk); |
| 661 | 661 | if (skb->sk) { |
| 662 | 662 | frag->sk = skb->sk; |
| 663 | 663 | frag->destructor = sock_wfree; |
| 664 | − truesizes += frag->truesize; | |
| 665 | 664 | } |
| 665 | + skb->truesize -= frag->truesize; | |
| 666 | 666 | } |
| 667 | 667 | |
| 668 | 668 | err = 0; |
| @@ -693,7 +693,6 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 24 unmodified lines | ||
| 693 | 693 | |
| 694 | 694 | first_len = skb_pagelen(skb); |
| 695 | 695 | skb->data_len = first_len - skb_headlen(skb); |
| 696 | − skb->truesize -= truesizes; | |
| 697 | 696 | skb->len = first_len; |
| 698 | 697 | ipv6_hdr(skb)->payload_len = htons(first_len - |
| 699 | 698 | sizeof(struct ipv6hdr)); |
| @@ -756,6 +755,15 @@ static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *)) · 56 unmodified lines | ||
| 756 | 755 | IPSTATS_MIB_FRAGFAILS); |
| 757 | 756 | dst_release(&rt->dst); |
| 758 | 757 | return err; |
| 758 | + | |
| 759 | +slow_path_clean: | |
| 760 | + skb_walk_frags(skb, frag2) { | |
| 761 | + if (frag2 == frag) | |
| 762 | + break; | |
| 763 | + frag2->sk = NULL; | |
| 764 | + frag2->destructor = NULL; | |
| 765 | + skb->truesize += frag2->truesize; | |
| 766 | + } | |
| 759 | 767 | } |
| 760 | 768 | |
| 761 | 769 | slow_path: |
| @@ -670,7 +670,7 @@ static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *dad · 669 unmodified lines | ||
| 670 | 670 | |
| 671 | 671 | if (net_ratelimit()) |
| 672 | 672 | printk(KERN_WARNING |
| 673 | − "Neighbour table overflow.\n"); | |
| 673 | + "ipv6: Neighbour table overflow.\n"); | |
| 674 | 674 | dst_free(&rt->dst); |
| 675 | 675 | return NULL; |
| 676 | 676 | } |
| @@ -20,23 +20,27 @@ · 19 unmodified lines | ||
| 20 | 20 | #include <net/addrconf.h> |
| 21 | 21 | |
| 22 | 22 | static void |
| 23 | −__xfrm6_init_tempsel(struct xfrm_state *x, struct flowi *fl, | |
| 24 | − struct xfrm_tmpl *tmpl, | |
| 25 | − xfrm_address_t *daddr, xfrm_address_t *saddr) | |
| 23 | +__xfrm6_init_tempsel(struct xfrm_selector *sel, struct flowi *fl) | |
| 26 | 24 | { |
| 27 | 25 | /* Initialize temporary selector matching only |
| 28 | 26 | * to current session. */ |
| 29 | − ipv6_addr_copy((struct in6_addr *)&x->sel.daddr, &fl->fl6_dst); | |
| 30 | − ipv6_addr_copy((struct in6_addr *)&x->sel.saddr, &fl->fl6_src); | |
| 31 | − x->sel.dport = xfrm_flowi_dport(fl); | |
| 32 | − x->sel.dport_mask = htons(0xffff); | |
| 33 | − x->sel.sport = xfrm_flowi_sport(fl); | |
| 34 | − x->sel.sport_mask = htons(0xffff); | |
| 35 | − x->sel.family = AF_INET6; | |
| 36 | − x->sel.prefixlen_d = 128; | |
| 37 | − x->sel.prefixlen_s = 128; | |
| 38 | − x->sel.proto = fl->proto; | |
| 39 | − x->sel.ifindex = fl->oif; | |
| 27 | + ipv6_addr_copy((struct in6_addr *)&sel->daddr, &fl->fl6_dst); | |
| 28 | + ipv6_addr_copy((struct in6_addr *)&sel->saddr, &fl->fl6_src); | |
| 29 | + sel->dport = xfrm_flowi_dport(fl); | |
| 30 | + sel->dport_mask = htons(0xffff); | |
| 31 | + sel->sport = xfrm_flowi_sport(fl); | |
| 32 | + sel->sport_mask = htons(0xffff); | |
| 33 | + sel->family = AF_INET6; | |
| 34 | + sel->prefixlen_d = 128; | |
| 35 | + sel->prefixlen_s = 128; | |
| 36 | + sel->proto = fl->proto; | |
| 37 | + sel->ifindex = fl->oif; | |
| 38 | +} | |
| 39 | + | |
| 40 | +static void | |
| 41 | +xfrm6_init_temprop(struct xfrm_state *x, struct xfrm_tmpl *tmpl, | |
| 42 | + xfrm_address_t *daddr, xfrm_address_t *saddr) | |
| 43 | +{ | |
| 40 | 44 | x->id = tmpl->id; |
| 41 | 45 | if (ipv6_addr_any((struct in6_addr*)&x->id.daddr)) |
| 42 | 46 | memcpy(&x->id.daddr, daddr, sizeof(x->sel.daddr)); |
| @@ -168,6 +172,7 @@ static struct xfrm_state_afinfo xfrm6_state_afinfo = { · 125 unmodified lines | ||
| 168 | 172 | .eth_proto = htons(ETH_P_IPV6), |
| 169 | 173 | .owner = THIS_MODULE, |
| 170 | 174 | .init_tempsel = __xfrm6_init_tempsel, |
| 175 | + .init_temprop = xfrm6_init_temprop, | |
| 171 | 176 | .tmpl_sort = __xfrm6_tmpl_sort, |
| 172 | 177 | .state_sort = __xfrm6_state_sort, |
| 173 | 178 | .output = xfrm6_output, |
| @@ -2199,9 +2199,6 @@ static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx, · 2198 unmodified lines | ||
| 2199 | 2199 | struct net_device *prev_dev = NULL; |
| 2200 | 2200 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
| 2201 | 2201 | |
| 2202 | − if (status->flag & RX_FLAG_INTERNAL_CMTR) | |
| 2203 | − goto out_free_skb; | |
| 2204 | − | |
| 2205 | 2202 | if (skb_headroom(skb) < sizeof(*rthdr) && |
| 2206 | 2203 | pskb_expand_head(skb, sizeof(*rthdr), 0, GFP_ATOMIC)) |
| 2207 | 2204 | goto out_free_skb; |
| @@ -2260,7 +2257,6 @@ static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx, · 52 unmodified lines | ||
| 2260 | 2257 | } else |
| 2261 | 2258 | goto out_free_skb; |
| 2262 | 2259 | |
| 2263 | − status->flag |= RX_FLAG_INTERNAL_CMTR; | |
| 2264 | 2260 | return; |
| 2265 | 2261 | |
| 2266 | 2262 | out_free_skb: |
| @@ -48,15 +48,17 @@ nf_ct_ext_create(struct nf_ct_ext **ext, enum nf_ct_ext_id id, gfp_t gfp) · 47 unmodified lines | ||
| 48 | 48 | { |
| 49 | 49 | unsigned int off, len; |
| 50 | 50 | struct nf_ct_ext_type *t; |
| 51 | + size_t alloc_size; | |
| 51 | 52 | |
| 52 | 53 | rcu_read_lock(); |
| 53 | 54 | t = rcu_dereference(nf_ct_ext_types[id]); |
| 54 | 55 | BUG_ON(t == NULL); |
| 55 | 56 | off = ALIGN(sizeof(struct nf_ct_ext), t->align); |
| 56 | 57 | len = off + t->len; |
| 58 | + alloc_size = t->alloc_size; | |
| 57 | 59 | rcu_read_unlock(); |
| 58 | 60 | |
| 59 | − *ext = kzalloc(t->alloc_size, gfp); | |
| 61 | + *ext = kzalloc(alloc_size, gfp); | |
| 60 | 62 | if (!*ext) |
| 61 | 63 | return NULL; |
| 62 | 64 | |
| @@ -1376,7 +1376,7 @@ static int sip_help_tcp(struct sk_buff *skb, unsigned int protoff, · 1375 unmodified lines | ||
| 1376 | 1376 | unsigned int msglen, origlen; |
| 1377 | 1377 | const char *dptr, *end; |
| 1378 | 1378 | s16 diff, tdiff = 0; |
| 1379 | − int ret; | |
| 1379 | + int ret = NF_ACCEPT; | |
| 1380 | 1380 | typeof(nf_nat_sip_seq_adjust_hook) nf_nat_sip_seq_adjust; |
| 1381 | 1381 | |
| 1382 | 1382 | if (ctinfo != IP_CT_ESTABLISHED && |
| @@ -70,7 +70,11 @@ nf_tproxy_destructor(struct sk_buff *skb) · 69 unmodified lines | ||
| 70 | 70 | int |
| 71 | 71 | nf_tproxy_assign_sock(struct sk_buff *skb, struct sock *sk) |
| 72 | 72 | { |
| 73 | − if (inet_sk(sk)->transparent) { | |
| 73 | + bool transparent = (sk->sk_state == TCP_TIME_WAIT) ? | |
| 74 | + inet_twsk(sk)->tw_transparent : | |
| 75 | + inet_sk(sk)->transparent; | |
| 76 | + | |
| 77 | + if (transparent) { | |
| 74 | 78 | skb_orphan(skb); |
| 75 | 79 | skb->sk = sk; |
| 76 | 80 | skb->destructor = nf_tproxy_destructor; |
| @@ -225,12 +225,13 @@ static void pipe_grant_credits(struct sock *sk) · 224 unmodified lines | ||
| 225 | 225 | static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb) |
| 226 | 226 | { |
| 227 | 227 | struct pep_sock *pn = pep_sk(sk); |
| 228 | − struct pnpipehdr *hdr = pnp_hdr(skb); | |
| 228 | + struct pnpipehdr *hdr; | |
| 229 | 229 | int wake = 0; |
| 230 | 230 | |
| 231 | 231 | if (!pskb_may_pull(skb, sizeof(*hdr) + 4)) |
| 232 | 232 | return -EINVAL; |
| 233 | 233 | |
| 234 | + hdr = pnp_hdr(skb); | |
| 234 | 235 | if (hdr->data[0] != PN_PEP_TYPE_COMMON) { |
| 235 | 236 | LIMIT_NETDEBUG(KERN_DEBUG"Phonet unknown PEP type: %u\n", |
| 236 | 237 | (unsigned)hdr->data[0]); |
| @@ -43,7 +43,7 @@ void rds_tcp_state_change(struct sock *sk) · 42 unmodified lines | ||
| 43 | 43 | struct rds_connection *conn; |
| 44 | 44 | struct rds_tcp_connection *tc; |
| 45 | 45 | |
| 46 | − read_lock(&sk->sk_callback_lock); | |
| 46 | + read_lock_bh(&sk->sk_callback_lock); | |
| 47 | 47 | conn = sk->sk_user_data; |
| 48 | 48 | if (conn == NULL) { |
| 49 | 49 | state_change = sk->sk_state_change; |
| @@ -68,7 +68,7 @@ void rds_tcp_state_change(struct sock *sk) · 18 unmodified lines | ||
| 68 | 68 | break; |
| 69 | 69 | } |
| 70 | 70 | out: |
| 71 | − read_unlock(&sk->sk_callback_lock); | |
| 71 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 72 | 72 | state_change(sk); |
| 73 | 73 | } |
| 74 | 74 | |
| @@ -114,7 +114,7 @@ void rds_tcp_listen_data_ready(struct sock *sk, int bytes) · 113 unmodified lines | ||
| 114 | 114 | |
| 115 | 115 | rdsdebug("listen data ready sk %p\n", sk); |
| 116 | 116 | |
| 117 | − read_lock(&sk->sk_callback_lock); | |
| 117 | + read_lock_bh(&sk->sk_callback_lock); | |
| 118 | 118 | ready = sk->sk_user_data; |
| 119 | 119 | if (ready == NULL) { /* check for teardown race */ |
| 120 | 120 | ready = sk->sk_data_ready; |
| @@ -131,7 +131,7 @@ void rds_tcp_listen_data_ready(struct sock *sk, int bytes) · 10 unmodified lines | ||
| 131 | 131 | queue_work(rds_wq, &rds_tcp_listen_work); |
| 132 | 132 | |
| 133 | 133 | out: |
| 134 | − read_unlock(&sk->sk_callback_lock); | |
| 134 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 135 | 135 | ready(sk, bytes); |
| 136 | 136 | } |
| 137 | 137 | |
| @@ -324,7 +324,7 @@ void rds_tcp_data_ready(struct sock *sk, int bytes) · 323 unmodified lines | ||
| 324 | 324 | |
| 325 | 325 | rdsdebug("data ready sk %p bytes %d\n", sk, bytes); |
| 326 | 326 | |
| 327 | − read_lock(&sk->sk_callback_lock); | |
| 327 | + read_lock_bh(&sk->sk_callback_lock); | |
| 328 | 328 | conn = sk->sk_user_data; |
| 329 | 329 | if (conn == NULL) { /* check for teardown race */ |
| 330 | 330 | ready = sk->sk_data_ready; |
| @@ -338,7 +338,7 @@ void rds_tcp_data_ready(struct sock *sk, int bytes) · 7 unmodified lines | ||
| 338 | 338 | if (rds_tcp_read_sock(conn, GFP_ATOMIC, KM_SOFTIRQ0) == -ENOMEM) |
| 339 | 339 | queue_delayed_work(rds_wq, &conn->c_recv_w, 0); |
| 340 | 340 | out: |
| 341 | − read_unlock(&sk->sk_callback_lock); | |
| 341 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 342 | 342 | ready(sk, bytes); |
| 343 | 343 | } |
| 344 | 344 | |
| @@ -224,7 +224,7 @@ void rds_tcp_write_space(struct sock *sk) · 223 unmodified lines | ||
| 224 | 224 | struct rds_connection *conn; |
| 225 | 225 | struct rds_tcp_connection *tc; |
| 226 | 226 | |
| 227 | − read_lock(&sk->sk_callback_lock); | |
| 227 | + read_lock_bh(&sk->sk_callback_lock); | |
| 228 | 228 | conn = sk->sk_user_data; |
| 229 | 229 | if (conn == NULL) { |
| 230 | 230 | write_space = sk->sk_write_space; |
| @@ -244,7 +244,7 @@ void rds_tcp_write_space(struct sock *sk) · 13 unmodified lines | ||
| 244 | 244 | queue_delayed_work(rds_wq, &conn->c_send_w, 0); |
| 245 | 245 | |
| 246 | 246 | out: |
| 247 | − read_unlock(&sk->sk_callback_lock); | |
| 247 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 248 | 248 | |
| 249 | 249 | /* |
| 250 | 250 | * write_space is only called when data leaves tcp's send queue if |
| @@ -679,7 +679,7 @@ static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) · 678 unmodified lines | ||
| 679 | 679 | if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1) |
| 680 | 680 | return -EINVAL; |
| 681 | 681 | |
| 682 | − if (addr->srose_ndigis > ROSE_MAX_DIGIS) | |
| 682 | + if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS) | |
| 683 | 683 | return -EINVAL; |
| 684 | 684 | |
| 685 | 685 | if ((dev = rose_dev_get(&addr->srose_addr)) == NULL) { |
| @@ -739,7 +739,7 @@ static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_le · 53 unmodified lines | ||
| 739 | 739 | if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1) |
| 740 | 740 | return -EINVAL; |
| 741 | 741 | |
| 742 | − if (addr->srose_ndigis > ROSE_MAX_DIGIS) | |
| 742 | + if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS) | |
| 743 | 743 | return -EINVAL; |
| 744 | 744 | |
| 745 | 745 | /* Source + Destination digis should not exceed ROSE_MAX_DIGIS */ |
| @@ -800,7 +800,7 @@ static void xs_udp_data_ready(struct sock *sk, int len) · 799 unmodified lines | ||
| 800 | 800 | u32 _xid; |
| 801 | 801 | __be32 *xp; |
| 802 | 802 | |
| 803 | − read_lock(&sk->sk_callback_lock); | |
| 803 | + read_lock_bh(&sk->sk_callback_lock); | |
| 804 | 804 | dprintk("RPC: xs_udp_data_ready...\n"); |
| 805 | 805 | if (!(xprt = xprt_from_sock(sk))) |
| 806 | 806 | goto out; |
| @@ -852,7 +852,7 @@ static void xs_udp_data_ready(struct sock *sk, int len) · 45 unmodified lines | ||
| 852 | 852 | dropit: |
| 853 | 853 | skb_free_datagram(sk, skb); |
| 854 | 854 | out: |
| 855 | − read_unlock(&sk->sk_callback_lock); | |
| 855 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 856 | 856 | } |
| 857 | 857 | |
| 858 | 858 | static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc) |
| @@ -1229,7 +1229,7 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes) · 370 unmodified lines | ||
| 1229 | 1229 | |
| 1230 | 1230 | dprintk("RPC: xs_tcp_data_ready...\n"); |
| 1231 | 1231 | |
| 1232 | − read_lock(&sk->sk_callback_lock); | |
| 1232 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1233 | 1233 | if (!(xprt = xprt_from_sock(sk))) |
| 1234 | 1234 | goto out; |
| 1235 | 1235 | if (xprt->shutdown) |
| @@ -1248,7 +1248,7 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes) · 12 unmodified lines | ||
| 1248 | 1248 | read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv); |
| 1249 | 1249 | } while (read > 0); |
| 1250 | 1250 | out: |
| 1251 | − read_unlock(&sk->sk_callback_lock); | |
| 1251 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1252 | 1252 | } |
| 1253 | 1253 | |
| 1254 | 1254 | /* |
| @@ -1301,7 +1301,7 @@ static void xs_tcp_state_change(struct sock *sk) · 46 unmodified lines | ||
| 1301 | 1301 | { |
| 1302 | 1302 | struct rpc_xprt *xprt; |
| 1303 | 1303 | |
| 1304 | − read_lock(&sk->sk_callback_lock); | |
| 1304 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1305 | 1305 | if (!(xprt = xprt_from_sock(sk))) |
| 1306 | 1306 | goto out; |
| 1307 | 1307 | dprintk("RPC: xs_tcp_state_change client %p...\n", xprt); |
| @@ -1313,7 +1313,7 @@ static void xs_tcp_state_change(struct sock *sk) · 5 unmodified lines | ||
| 1313 | 1313 | |
| 1314 | 1314 | switch (sk->sk_state) { |
| 1315 | 1315 | case TCP_ESTABLISHED: |
| 1316 | − spin_lock_bh(&xprt->transport_lock); | |
| 1316 | + spin_lock(&xprt->transport_lock); | |
| 1317 | 1317 | if (!xprt_test_and_set_connected(xprt)) { |
| 1318 | 1318 | struct sock_xprt *transport = container_of(xprt, |
| 1319 | 1319 | struct sock_xprt, xprt); |
| @@ -1327,7 +1327,7 @@ static void xs_tcp_state_change(struct sock *sk) · 7 unmodified lines | ||
| 1327 | 1327 | |
| 1328 | 1328 | xprt_wake_pending_tasks(xprt, -EAGAIN); |
| 1329 | 1329 | } |
| 1330 | − spin_unlock_bh(&xprt->transport_lock); | |
| 1330 | + spin_unlock(&xprt->transport_lock); | |
| 1331 | 1331 | break; |
| 1332 | 1332 | case TCP_FIN_WAIT1: |
| 1333 | 1333 | /* The client initiated a shutdown of the socket */ |
| @@ -1365,7 +1365,7 @@ static void xs_tcp_state_change(struct sock *sk) · 31 unmodified lines | ||
| 1365 | 1365 | xs_sock_mark_closed(xprt); |
| 1366 | 1366 | } |
| 1367 | 1367 | out: |
| 1368 | − read_unlock(&sk->sk_callback_lock); | |
| 1368 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1369 | 1369 | } |
| 1370 | 1370 | |
| 1371 | 1371 | /** |
| @@ -1376,7 +1376,7 @@ static void xs_error_report(struct sock *sk) · 4 unmodified lines | ||
| 1376 | 1376 | { |
| 1377 | 1377 | struct rpc_xprt *xprt; |
| 1378 | 1378 | |
| 1379 | − read_lock(&sk->sk_callback_lock); | |
| 1379 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1380 | 1380 | if (!(xprt = xprt_from_sock(sk))) |
| 1381 | 1381 | goto out; |
| 1382 | 1382 | dprintk("RPC: %s client %p...\n" |
| @@ -1384,7 +1384,7 @@ static void xs_error_report(struct sock *sk) · 1 unmodified line | ||
| 1384 | 1384 | __func__, xprt, sk->sk_err); |
| 1385 | 1385 | xprt_wake_pending_tasks(xprt, -EAGAIN); |
| 1386 | 1386 | out: |
| 1387 | − read_unlock(&sk->sk_callback_lock); | |
| 1387 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1388 | 1388 | } |
| 1389 | 1389 | |
| 1390 | 1390 | static void xs_write_space(struct sock *sk) |
| @@ -1416,13 +1416,13 @@ static void xs_write_space(struct sock *sk) · 25 unmodified lines | ||
| 1416 | 1416 | */ |
| 1417 | 1417 | static void xs_udp_write_space(struct sock *sk) |
| 1418 | 1418 | { |
| 1419 | − read_lock(&sk->sk_callback_lock); | |
| 1419 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1420 | 1420 | |
| 1421 | 1421 | /* from net/core/sock.c:sock_def_write_space */ |
| 1422 | 1422 | if (sock_writeable(sk)) |
| 1423 | 1423 | xs_write_space(sk); |
| 1424 | 1424 | |
| 1425 | − read_unlock(&sk->sk_callback_lock); | |
| 1425 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1426 | 1426 | } |
| 1427 | 1427 | |
| 1428 | 1428 | /** |
| @@ -1437,13 +1437,13 @@ static void xs_udp_write_space(struct sock *sk) · 8 unmodified lines | ||
| 1437 | 1437 | */ |
| 1438 | 1438 | static void xs_tcp_write_space(struct sock *sk) |
| 1439 | 1439 | { |
| 1440 | − read_lock(&sk->sk_callback_lock); | |
| 1440 | + read_lock_bh(&sk->sk_callback_lock); | |
| 1441 | 1441 | |
| 1442 | 1442 | /* from net/core/stream.c:sk_stream_write_space */ |
| 1443 | 1443 | if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) |
| 1444 | 1444 | xs_write_space(sk); |
| 1445 | 1445 | |
| 1446 | − read_unlock(&sk->sk_callback_lock); | |
| 1446 | + read_unlock_bh(&sk->sk_callback_lock); | |
| 1447 | 1447 | } |
| 1448 | 1448 | |
| 1449 | 1449 | static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt) |
| @@ -152,7 +152,7 @@ static int ioctl_private_iw_point(struct iw_point *iwp, unsigned int cmd, · 151 unmodified lines | ||
| 152 | 152 | } else if (!iwp->pointer) |
| 153 | 153 | return -EFAULT; |
| 154 | 154 | |
| 155 | − extra = kmalloc(extra_size, GFP_KERNEL); | |
| 155 | + extra = kzalloc(extra_size, GFP_KERNEL); | |
| 156 | 156 | if (!extra) |
| 157 | 157 | return -ENOMEM; |
| 158 | 158 | |
| @@ -1175,9 +1175,8 @@ xfrm_tmpl_resolve_one(struct xfrm_policy *policy, struct flowi *fl, · 1174 unmodified lines | ||
| 1175 | 1175 | tmpl->mode == XFRM_MODE_BEET) { |
| 1176 | 1176 | remote = &tmpl->id.daddr; |
| 1177 | 1177 | local = &tmpl->saddr; |
| 1178 | − family = tmpl->encap_family; | |
| 1179 | − if (xfrm_addr_any(local, family)) { | |
| 1180 | − error = xfrm_get_saddr(net, &tmp, remote, family); | |
| 1178 | + if (xfrm_addr_any(local, tmpl->encap_family)) { | |
| 1179 | + error = xfrm_get_saddr(net, &tmp, remote, tmpl->encap_family); | |
| 1181 | 1180 | if (error) |
| 1182 | 1181 | goto fail; |
| 1183 | 1182 | local = &tmp; |
| @@ -656,15 +656,23 @@ void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si) · 655 unmodified lines | ||
| 656 | 656 | EXPORT_SYMBOL(xfrm_sad_getinfo); |
| 657 | 657 | |
| 658 | 658 | static int |
| 659 | −xfrm_init_tempsel(struct xfrm_state *x, struct flowi *fl, | |
| 660 | − struct xfrm_tmpl *tmpl, | |
| 661 | − xfrm_address_t *daddr, xfrm_address_t *saddr, | |
| 662 | − unsigned short family) | |
| 659 | +xfrm_init_tempstate(struct xfrm_state *x, struct flowi *fl, | |
| 660 | + struct xfrm_tmpl *tmpl, | |
| 661 | + xfrm_address_t *daddr, xfrm_address_t *saddr, | |
| 662 | + unsigned short family) | |
| 663 | 663 | { |
| 664 | 664 | struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family); |
| 665 | 665 | if (!afinfo) |
| 666 | 666 | return -1; |
| 667 | − afinfo->init_tempsel(x, fl, tmpl, daddr, saddr); | |
| 667 | + afinfo->init_tempsel(&x->sel, fl); | |
| 668 | + | |
| 669 | + if (family != tmpl->encap_family) { | |
| 670 | + xfrm_state_put_afinfo(afinfo); | |
| 671 | + afinfo = xfrm_state_get_afinfo(tmpl->encap_family); | |
| 672 | + if (!afinfo) | |
| 673 | + return -1; | |
| 674 | + } | |
| 675 | + afinfo->init_temprop(x, tmpl, daddr, saddr); | |
| 668 | 676 | xfrm_state_put_afinfo(afinfo); |
| 669 | 677 | return 0; |
| 670 | 678 | } |
| @@ -790,37 +798,38 @@ xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr, · 119 unmodified lines | ||
| 790 | 798 | int error = 0; |
| 791 | 799 | struct xfrm_state *best = NULL; |
| 792 | 800 | u32 mark = pol->mark.v & pol->mark.m; |
| 801 | + unsigned short encap_family = tmpl->encap_family; | |
| 793 | 802 | |
| 794 | 803 | to_put = NULL; |
| 795 | 804 | |
| 796 | 805 | spin_lock_bh(&xfrm_state_lock); |
| 797 | − h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, family); | |
| 806 | + h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family); | |
| 798 | 807 | hlist_for_each_entry(x, entry, net->xfrm.state_bydst+h, bydst) { |
| 799 | − if (x->props.family == family && | |
| 808 | + if (x->props.family == encap_family && | |
| 800 | 809 | x->props.reqid == tmpl->reqid && |
| 801 | 810 | (mark & x->mark.m) == x->mark.v && |
| 802 | 811 | !(x->props.flags & XFRM_STATE_WILDRECV) && |
| 803 | − xfrm_state_addr_check(x, daddr, saddr, family) && | |
| 812 | + xfrm_state_addr_check(x, daddr, saddr, encap_family) && | |
| 804 | 813 | tmpl->mode == x->props.mode && |
| 805 | 814 | tmpl->id.proto == x->id.proto && |
| 806 | 815 | (tmpl->id.spi == x->id.spi || !tmpl->id.spi)) |
| 807 | − xfrm_state_look_at(pol, x, fl, family, daddr, saddr, | |
| 816 | + xfrm_state_look_at(pol, x, fl, encap_family, daddr, saddr, | |
| 808 | 817 | &best, &acquire_in_progress, &error); |
| 809 | 818 | } |
| 810 | 819 | if (best) |
| 811 | 820 | goto found; |
| 812 | 821 | |
| 813 | − h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, family); | |
| 822 | + h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family); | |
| 814 | 823 | hlist_for_each_entry(x, entry, net->xfrm.state_bydst+h_wildcard, bydst) { |
| 815 | − if (x->props.family == family && | |
| 824 | + if (x->props.family == encap_family && | |
| 816 | 825 | x->props.reqid == tmpl->reqid && |
| 817 | 826 | (mark & x->mark.m) == x->mark.v && |
| 818 | 827 | !(x->props.flags & XFRM_STATE_WILDRECV) && |
| 819 | − xfrm_state_addr_check(x, daddr, saddr, family) && | |
| 828 | + xfrm_state_addr_check(x, daddr, saddr, encap_family) && | |
| 820 | 829 | tmpl->mode == x->props.mode && |
| 821 | 830 | tmpl->id.proto == x->id.proto && |
| 822 | 831 | (tmpl->id.spi == x->id.spi || !tmpl->id.spi)) |
| 823 | − xfrm_state_look_at(pol, x, fl, family, daddr, saddr, | |
| 832 | + xfrm_state_look_at(pol, x, fl, encap_family, daddr, saddr, | |
| 824 | 833 | &best, &acquire_in_progress, &error); |
| 825 | 834 | } |
| 826 | 835 | |
| @@ -829,7 +838,7 @@ found: · 2 unmodified lines | ||
| 829 | 838 | if (!x && !error && !acquire_in_progress) { |
| 830 | 839 | if (tmpl->id.spi && |
| 831 | 840 | (x0 = __xfrm_state_lookup(net, mark, daddr, tmpl->id.spi, |
| 832 | − tmpl->id.proto, family)) != NULL) { | |
| 841 | + tmpl->id.proto, encap_family)) != NULL) { | |
| 833 | 842 | to_put = x0; |
| 834 | 843 | error = -EEXIST; |
| 835 | 844 | goto out; |
| @@ -839,9 +848,9 @@ found: · 3 unmodified lines | ||
| 839 | 848 | error = -ENOMEM; |
| 840 | 849 | goto out; |
| 841 | 850 | } |
| 842 | − /* Initialize temporary selector matching only | |
| 851 | + /* Initialize temporary state matching only | |
| 843 | 852 | * to current session. */ |
| 844 | − xfrm_init_tempsel(x, fl, tmpl, daddr, saddr, family); | |
| 853 | + xfrm_init_tempstate(x, fl, tmpl, daddr, saddr, family); | |
| 845 | 854 | memcpy(&x->mark, &pol->mark, sizeof(x->mark)); |
| 846 | 855 | |
| 847 | 856 | error = security_xfrm_state_alloc_acquire(x, pol->security, fl->secid); |
| @@ -856,10 +865,10 @@ found: · 8 unmodified lines | ||
| 856 | 865 | x->km.state = XFRM_STATE_ACQ; |
| 857 | 866 | list_add(&x->km.all, &net->xfrm.state_all); |
| 858 | 867 | hlist_add_head(&x->bydst, net->xfrm.state_bydst+h); |
| 859 | − h = xfrm_src_hash(net, daddr, saddr, family); | |
| 868 | + h = xfrm_src_hash(net, daddr, saddr, encap_family); | |
| 860 | 869 | hlist_add_head(&x->bysrc, net->xfrm.state_bysrc+h); |
| 861 | 870 | if (x->id.spi) { |
| 862 | − h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, family); | |
| 871 | + h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, encap_family); | |
| 863 | 872 | hlist_add_head(&x->byspi, net->xfrm.state_byspi+h); |
| 864 | 873 | } |
| 865 | 874 | x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires; |
| @@ -24,6 +24,7 @@ static int __init example_init(void) · 23 unmodified lines | ||
| 24 | 24 | { |
| 25 | 25 | int i; |
| 26 | 26 | unsigned int ret; |
| 27 | + unsigned int nents; | |
| 27 | 28 | struct scatterlist sg[10]; |
| 28 | 29 | |
| 29 | 30 | printk(KERN_INFO "DMA fifo test start\n"); |
| @@ -61,9 +62,9 @@ static int __init example_init(void) · 31 unmodified lines | ||
| 61 | 62 | * byte at the beginning, after the kfifo_skip(). |
| 62 | 63 | */ |
| 63 | 64 | sg_init_table(sg, ARRAY_SIZE(sg)); |
| 64 | − ret = kfifo_dma_in_prepare(&fifo, sg, ARRAY_SIZE(sg), FIFO_SIZE); | |
| 65 | − printk(KERN_INFO "DMA sgl entries: %d\n", ret); | |
| 66 | − if (!ret) { | |
| 65 | + nents = kfifo_dma_in_prepare(&fifo, sg, ARRAY_SIZE(sg), FIFO_SIZE); | |
| 66 | + printk(KERN_INFO "DMA sgl entries: %d\n", nents); | |
| 67 | + if (!nents) { | |
| 67 | 68 | /* fifo is full and no sgl was created */ |
| 68 | 69 | printk(KERN_WARNING "error kfifo_dma_in_prepare\n"); |
| 69 | 70 | return -EIO; |
| @@ -71,7 +72,7 @@ static int __init example_init(void) · 1 unmodified line | ||
| 71 | 72 | |
| 72 | 73 | /* receive data */ |
| 73 | 74 | printk(KERN_INFO "scatterlist for receive:\n"); |
| 74 | − for (i = 0; i < ARRAY_SIZE(sg); i++) { | |
| 75 | + for (i = 0; i < nents; i++) { | |
| 75 | 76 | printk(KERN_INFO |
| 76 | 77 | "sg[%d] -> " |
| 77 | 78 | "page_link 0x%.8lx offset 0x%.8x length 0x%.8x\n", |
| @@ -91,16 +92,16 @@ static int __init example_init(void) · 13 unmodified lines | ||
| 91 | 92 | kfifo_dma_in_finish(&fifo, ret); |
| 92 | 93 | |
| 93 | 94 | /* Prepare to transmit data, example: 8 bytes */ |
| 94 | − ret = kfifo_dma_out_prepare(&fifo, sg, ARRAY_SIZE(sg), 8); | |
| 95 | − printk(KERN_INFO "DMA sgl entries: %d\n", ret); | |
| 96 | − if (!ret) { | |
| 95 | + nents = kfifo_dma_out_prepare(&fifo, sg, ARRAY_SIZE(sg), 8); | |
| 96 | + printk(KERN_INFO "DMA sgl entries: %d\n", nents); | |
| 97 | + if (!nents) { | |
| 97 | 98 | /* no data was available and no sgl was created */ |
| 98 | 99 | printk(KERN_WARNING "error kfifo_dma_out_prepare\n"); |
| 99 | 100 | return -EIO; |
| 100 | 101 | } |
| 101 | 102 | |
| 102 | 103 | printk(KERN_INFO "scatterlist for transmit:\n"); |
| 103 | − for (i = 0; i < ARRAY_SIZE(sg); i++) { | |
| 104 | + for (i = 0; i < nents; i++) { | |
| 104 | 105 | printk(KERN_INFO |
| 105 | 106 | "sg[%d] -> " |
| 106 | 107 | "page_link 0x%.8lx offset 0x%.8x length 0x%.8x\n", |
| @@ -1416,15 +1416,19 @@ static char *tomoyo_print_header(struct tomoyo_request_info *r) · 1415 unmodified lines | ||
| 1416 | 1416 | const pid_t gpid = task_pid_nr(current); |
| 1417 | 1417 | static const int tomoyo_buffer_len = 4096; |
| 1418 | 1418 | char *buffer = kmalloc(tomoyo_buffer_len, GFP_NOFS); |
| 1419 | + pid_t ppid; | |
| 1419 | 1420 | if (!buffer) |
| 1420 | 1421 | return NULL; |
| 1421 | 1422 | do_gettimeofday(&tv); |
| 1423 | + rcu_read_lock(); | |
| 1424 | + ppid = task_tgid_vnr(current->real_parent); | |
| 1425 | + rcu_read_unlock(); | |
| 1422 | 1426 | snprintf(buffer, tomoyo_buffer_len - 1, |
| 1423 | 1427 | "#timestamp=%lu profile=%u mode=%s (global-pid=%u)" |
| 1424 | 1428 | " task={ pid=%u ppid=%u uid=%u gid=%u euid=%u" |
| 1425 | 1429 | " egid=%u suid=%u sgid=%u fsuid=%u fsgid=%u }", |
| 1426 | 1430 | tv.tv_sec, r->profile, tomoyo_mode[r->mode], gpid, |
| 1427 | − (pid_t) sys_getpid(), (pid_t) sys_getppid(), | |
| 1431 | + task_tgid_vnr(current), ppid, | |
| 1428 | 1432 | current_uid(), current_gid(), current_euid(), |
| 1429 | 1433 | current_egid(), current_suid(), current_sgid(), |
| 1430 | 1434 | current_fsuid(), current_fsgid()); |
| @@ -689,9 +689,6 @@ struct tomoyo_profile { · 688 unmodified lines | ||
| 689 | 689 | |
| 690 | 690 | /********** Function prototypes. **********/ |
| 691 | 691 | |
| 692 | −extern asmlinkage long sys_getpid(void); | |
| 693 | −extern asmlinkage long sys_getppid(void); | |
| 694 | − | |
| 695 | 692 | /* Check whether the given string starts with the given keyword. */ |
| 696 | 693 | bool tomoyo_str_starts(char **src, const char *find); |
| 697 | 694 | /* Get tomoyo_realpath() of current process. */ |
| @@ -31,6 +31,7 @@ · 30 unmodified lines | ||
| 31 | 31 | |
| 32 | 32 | /* max number of user-defined controls */ |
| 33 | 33 | #define MAX_USER_CONTROLS 32 |
| 34 | +#define MAX_CONTROL_COUNT 1028 | |
| 34 | 35 | |
| 35 | 36 | struct snd_kctl_ioctl { |
| 36 | 37 | struct list_head list; /* list of all ioctls */ |
| @@ -195,6 +196,10 @@ static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, · 158 unmodified lines | ||
| 195 | 196 | |
| 196 | 197 | if (snd_BUG_ON(!control || !control->count)) |
| 197 | 198 | return NULL; |
| 199 | + | |
| 200 | + if (control->count > MAX_CONTROL_COUNT) | |
| 201 | + return NULL; | |
| 202 | + | |
| 198 | 203 | kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); |
| 199 | 204 | if (kctl == NULL) { |
| 200 | 205 | snd_printk(KERN_ERR "Cannot allocate control instance\n"); |
| @@ -900,7 +900,7 @@ static int proc_init(struct snd_akm4xxx *ak) · 899 unmodified lines | ||
| 900 | 900 | return 0; |
| 901 | 901 | } |
| 902 | 902 | #else /* !CONFIG_PROC_FS */ |
| 903 | −static int proc_init(struct snd_akm4xxx *ak) {} | |
| 903 | +static int proc_init(struct snd_akm4xxx *ak) { return 0; } | |
| 904 | 904 | #endif |
| 905 | 905 | |
| 906 | 906 | int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) |
| @@ -3641,6 +3641,7 @@ static struct snd_pci_quirk ad1984_cfg_tbl[] = { · 3640 unmodified lines | ||
| 3641 | 3641 | /* Lenovo Thinkpad T61/X61 */ |
| 3642 | 3642 | SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD), |
| 3643 | 3643 | SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP), |
| 3644 | + SND_PCI_QUIRK(0x1028, 0x0233, "Dell Latitude E6400", AD1984_DELL_DESKTOP), | |
| 3644 | 3645 | {} |
| 3645 | 3646 | }; |
| 3646 | 3647 | |
| @@ -1594,12 +1594,22 @@ static void alc_auto_parse_digital(struct hda_codec *codec) · 1593 unmodified lines | ||
| 1594 | 1594 | } |
| 1595 | 1595 | |
| 1596 | 1596 | if (spec->autocfg.dig_in_pin) { |
| 1597 | − hda_nid_t dig_nid; | |
| 1598 | − err = snd_hda_get_connections(codec, | |
| 1599 | − spec->autocfg.dig_in_pin, | |
| 1600 | − &dig_nid, 1); | |
| 1601 | − if (err > 0) | |
| 1602 | − spec->dig_in_nid = dig_nid; | |
| 1597 | + dig_nid = codec->start_nid; | |
| 1598 | + for (i = 0; i < codec->num_nodes; i++, dig_nid++) { | |
| 1599 | + unsigned int wcaps = get_wcaps(codec, dig_nid); | |
| 1600 | + if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) | |
| 1601 | + continue; | |
| 1602 | + if (!(wcaps & AC_WCAP_DIGITAL)) | |
| 1603 | + continue; | |
| 1604 | + if (!(wcaps & AC_WCAP_CONN_LIST)) | |
| 1605 | + continue; | |
| 1606 | + err = get_connection_index(codec, dig_nid, | |
| 1607 | + spec->autocfg.dig_in_pin); | |
| 1608 | + if (err >= 0) { | |
| 1609 | + spec->dig_in_nid = dig_nid; | |
| 1610 | + break; | |
| 1611 | + } | |
| 1612 | + } | |
| 1603 | 1613 | } |
| 1604 | 1614 | } |
| 1605 | 1615 | |
| @@ -543,6 +543,10 @@ static int __devinit get_oxygen_model(struct oxygen *chip, · 542 unmodified lines | ||
| 543 | 543 | chip->model.suspend = claro_suspend; |
| 544 | 544 | chip->model.resume = claro_resume; |
| 545 | 545 | chip->model.set_adc_params = set_ak5385_params; |
| 546 | + chip->model.device_config = PLAYBACK_0_TO_I2S | | |
| 547 | + PLAYBACK_1_TO_SPDIF | | |
| 548 | + CAPTURE_0_FROM_I2S_2 | | |
| 549 | + CAPTURE_1_FROM_SPDIF; | |
| 546 | 550 | break; |
| 547 | 551 | } |
| 548 | 552 | if (id->driver_data == MODEL_MERIDIAN || |
| @@ -4609,6 +4609,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne · 4608 unmodified lines | ||
| 4609 | 4609 | if (err < 0) |
| 4610 | 4610 | return err; |
| 4611 | 4611 | |
| 4612 | + memset(&info, 0, sizeof(info)); | |
| 4612 | 4613 | spin_lock_irqsave(&hdsp->lock, flags); |
| 4613 | 4614 | info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp); |
| 4614 | 4615 | info.wordclock_sync_check = (unsigned char)hdsp_wc_sync_check(hdsp); |
| @@ -4127,6 +4127,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, · 4126 unmodified lines | ||
| 4127 | 4127 | |
| 4128 | 4128 | case SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO: |
| 4129 | 4129 | |
| 4130 | + memset(&info, 0, sizeof(info)); | |
| 4130 | 4131 | spin_lock_irq(&hdspm->lock); |
| 4131 | 4132 | info.pref_sync_ref = hdspm_pref_sync_ref(hdspm); |
| 4132 | 4133 | info.wordclock_sync_check = hdspm_wc_sync_check(hdspm); |
| @@ -12,6 +12,7 @@ · 11 unmodified lines | ||
| 12 | 12 | #include <linux/firmware.h> |
| 13 | 13 | #include <linux/module.h> |
| 14 | 14 | |
| 15 | +#include <asm/clkdev.h> | |
| 15 | 16 | #include <asm/clock.h> |
| 16 | 17 | |
| 17 | 18 | #include <cpu/sh7722.h> |
| @@ -40,12 +41,12 @@ static struct clk_ops siumckb_clk_ops = { · 22 unmodified lines | ||
| 40 | 41 | }; |
| 41 | 42 | |
| 42 | 43 | static struct clk siumckb_clk = { |
| 43 | − .name = "siumckb_clk", | |
| 44 | − .id = -1, | |
| 45 | 44 | .ops = &siumckb_clk_ops, |
| 46 | 45 | .rate = 0, /* initialised at run-time */ |
| 47 | 46 | }; |
| 48 | 47 | |
| 48 | +static struct clk_lookup *siumckb_lookup; | |
| 49 | + | |
| 49 | 50 | static int migor_hw_params(struct snd_pcm_substream *substream, |
| 50 | 51 | struct snd_pcm_hw_params *params) |
| 51 | 52 | { |
| @@ -180,6 +181,13 @@ static int __init migor_init(void) · 128 unmodified lines | ||
| 180 | 181 | if (ret < 0) |
| 181 | 182 | return ret; |
| 182 | 183 | |
| 184 | + siumckb_lookup = clkdev_alloc(&siumckb_clk, "siumckb_clk", NULL); | |
| 185 | + if (!siumckb_lookup) { | |
| 186 | + ret = -ENOMEM; | |
| 187 | + goto eclkdevalloc; | |
| 188 | + } | |
| 189 | + clkdev_add(siumckb_lookup); | |
| 190 | + | |
| 183 | 191 | /* Port number used on this machine: port B */ |
| 184 | 192 | migor_snd_device = platform_device_alloc("soc-audio", 1); |
| 185 | 193 | if (!migor_snd_device) { |
| @@ -200,12 +208,15 @@ static int __init migor_init(void) · 14 unmodified lines | ||
| 200 | 208 | epdevadd: |
| 201 | 209 | platform_device_put(migor_snd_device); |
| 202 | 210 | epdevalloc: |
| 211 | + clkdev_drop(siumckb_lookup); | |
| 212 | +eclkdevalloc: | |
| 203 | 213 | clk_unregister(&siumckb_clk); |
| 204 | 214 | return ret; |
| 205 | 215 | } |
| 206 | 216 | |
| 207 | 217 | static void __exit migor_exit(void) |
| 208 | 218 | { |
| 219 | + clkdev_drop(siumckb_lookup); | |
| 209 | 220 | clk_unregister(&siumckb_clk); |
| 210 | 221 | platform_device_unregister(migor_snd_device); |
| 211 | 222 | } |
| @@ -203,8 +203,9 @@ static int snd_soc_8_16_write(struct snd_soc_codec *codec, unsigned int reg, · 202 unmodified lines | ||
| 203 | 203 | data[1] = (value >> 8) & 0xff; |
| 204 | 204 | data[2] = value & 0xff; |
| 205 | 205 | |
| 206 | − if (!snd_soc_codec_volatile_register(codec, reg)) | |
| 207 | − reg_cache[reg] = value; | |
| 206 | + if (!snd_soc_codec_volatile_register(codec, reg) | |
| 207 | + && reg < codec->reg_cache_size) | |
| 208 | + reg_cache[reg] = value; | |
| 208 | 209 | |
| 209 | 210 | if (codec->cache_only) { |
| 210 | 211 | codec->cache_sync = 1; |
| @@ -218,7 +218,6 @@ kvm_irqfd_assign(struct kvm *kvm, int fd, int gsi) · 217 unmodified lines | ||
| 218 | 218 | events = file->f_op->poll(file, &irqfd->pt); |
| 219 | 219 | |
| 220 | 220 | list_add_tail(&irqfd->list, &kvm->irqfds.items); |
| 221 | − spin_unlock_irq(&kvm->irqfds.lock); | |
| 222 | 221 | |
| 223 | 222 | /* |
| 224 | 223 | * Check if there was an event already pending on the eventfd |
| @@ -227,6 +226,8 @@ kvm_irqfd_assign(struct kvm *kvm, int fd, int gsi) · 2 unmodified lines | ||
| 227 | 226 | if (events & POLLIN) |
| 228 | 227 | schedule_work(&irqfd->inject); |
| 229 | 228 | |
| 229 | + spin_unlock_irq(&kvm->irqfds.lock); | |
| 230 | + | |
| 230 | 231 | /* |
| 231 | 232 | * do not drop the file until the irqfd is fully initialized, otherwise |
| 232 | 233 | * we might race against the POLLHUP |
| @@ -1970,10 +1970,12 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val, · 1969 unmodified lines | ||
| 1970 | 1970 | |
| 1971 | 1971 | asmlinkage void kvm_handle_fault_on_reboot(void) |
| 1972 | 1972 | { |
| 1973 | − if (kvm_rebooting) | |
| 1973 | + if (kvm_rebooting) { | |
| 1974 | 1974 | /* spin while reset goes on */ |
| 1975 | + local_irq_enable(); | |
| 1975 | 1976 | while (true) |
| 1976 | 1977 | ; |
| 1978 | + } | |
| 1977 | 1979 | /* Fault while not rebooting. We want the trace. */ |
| 1978 | 1980 | BUG(); |
| 1979 | 1981 | } |