diff options
Diffstat (limited to 'include')
233 files changed, 4533 insertions, 2375 deletions
diff --git a/include/acpi/acmacros.h b/include/acpi/acmacros.h index 57ab9e9d7593..74a9617776a8 100644 --- a/include/acpi/acmacros.h +++ b/include/acpi/acmacros.h | |||
@@ -467,7 +467,7 @@ struct acpi_integer_overlay { | |||
467 | /* | 467 | /* |
468 | * If ACPI_GET_FUNCTION_NAME was not defined in the compiler-dependent header, | 468 | * If ACPI_GET_FUNCTION_NAME was not defined in the compiler-dependent header, |
469 | * define it now. This is the case where there the compiler does not support | 469 | * define it now. This is the case where there the compiler does not support |
470 | * a __FUNCTION__ macro or equivalent. | 470 | * a __func__ macro or equivalent. |
471 | */ | 471 | */ |
472 | #ifndef ACPI_GET_FUNCTION_NAME | 472 | #ifndef ACPI_GET_FUNCTION_NAME |
473 | #define ACPI_GET_FUNCTION_NAME _acpi_function_name | 473 | #define ACPI_GET_FUNCTION_NAME _acpi_function_name |
@@ -475,12 +475,12 @@ struct acpi_integer_overlay { | |||
475 | * The Name parameter should be the procedure name as a quoted string. | 475 | * The Name parameter should be the procedure name as a quoted string. |
476 | * The function name is also used by the function exit macros below. | 476 | * The function name is also used by the function exit macros below. |
477 | * Note: (const char) is used to be compatible with the debug interfaces | 477 | * Note: (const char) is used to be compatible with the debug interfaces |
478 | * and macros such as __FUNCTION__. | 478 | * and macros such as __func__. |
479 | */ | 479 | */ |
480 | #define ACPI_FUNCTION_NAME(name) static const char _acpi_function_name[] = #name; | 480 | #define ACPI_FUNCTION_NAME(name) static const char _acpi_function_name[] = #name; |
481 | 481 | ||
482 | #else | 482 | #else |
483 | /* Compiler supports __FUNCTION__ (or equivalent) -- Ignore this macro */ | 483 | /* Compiler supports __func__ (or equivalent) -- Ignore this macro */ |
484 | 484 | ||
485 | #define ACPI_FUNCTION_NAME(name) | 485 | #define ACPI_FUNCTION_NAME(name) |
486 | #endif | 486 | #endif |
diff --git a/include/acpi/platform/acgcc.h b/include/acpi/platform/acgcc.h index 8996dba90cd9..8e2cdc57b197 100644 --- a/include/acpi/platform/acgcc.h +++ b/include/acpi/platform/acgcc.h | |||
@@ -46,7 +46,7 @@ | |||
46 | 46 | ||
47 | /* Function name is used for debug output. Non-ANSI, compiler-dependent */ | 47 | /* Function name is used for debug output. Non-ANSI, compiler-dependent */ |
48 | 48 | ||
49 | #define ACPI_GET_FUNCTION_NAME __FUNCTION__ | 49 | #define ACPI_GET_FUNCTION_NAME __func__ |
50 | 50 | ||
51 | /* | 51 | /* |
52 | * This macro is used to tag functions as "printf-like" because | 52 | * This macro is used to tag functions as "printf-like" because |
diff --git a/include/asm-arm/plat-s3c/debug-macro.S b/include/asm-arm/plat-s3c/debug-macro.S deleted file mode 100644 index 84c40b847da8..000000000000 --- a/include/asm-arm/plat-s3c/debug-macro.S +++ /dev/null | |||
@@ -1,75 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c/debug-macro.S | ||
2 | * | ||
3 | * Copyright 2005, 2007 Simtec Electronics | ||
4 | * http://armlinux.simtec.co.uk/ | ||
5 | * Ben Dooks <ben@simtec.co.uk> | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License version 2 as | ||
9 | * published by the Free Software Foundation. | ||
10 | */ | ||
11 | |||
12 | #include <asm/plat-s3c/regs-serial.h> | ||
13 | |||
14 | /* The S3C2440 implementations are used by default as they are the | ||
15 | * most widely re-used */ | ||
16 | |||
17 | .macro fifo_level_s3c2440 rd, rx | ||
18 | ldr \rd, [ \rx, # S3C2410_UFSTAT ] | ||
19 | and \rd, \rd, #S3C2440_UFSTAT_TXMASK | ||
20 | .endm | ||
21 | |||
22 | #ifndef fifo_level | ||
23 | #define fifo_level fifo_level_s3c2410 | ||
24 | #endif | ||
25 | |||
26 | .macro fifo_full_s3c2440 rd, rx | ||
27 | ldr \rd, [ \rx, # S3C2410_UFSTAT ] | ||
28 | tst \rd, #S3C2440_UFSTAT_TXFULL | ||
29 | .endm | ||
30 | |||
31 | #ifndef fifo_full | ||
32 | #define fifo_full fifo_full_s3c2440 | ||
33 | #endif | ||
34 | |||
35 | .macro senduart,rd,rx | ||
36 | strb \rd, [\rx, # S3C2410_UTXH ] | ||
37 | .endm | ||
38 | |||
39 | .macro busyuart, rd, rx | ||
40 | ldr \rd, [ \rx, # S3C2410_UFCON ] | ||
41 | tst \rd, #S3C2410_UFCON_FIFOMODE @ fifo enabled? | ||
42 | beq 1001f @ | ||
43 | @ FIFO enabled... | ||
44 | 1003: | ||
45 | fifo_full \rd, \rx | ||
46 | bne 1003b | ||
47 | b 1002f | ||
48 | |||
49 | 1001: | ||
50 | @ busy waiting for non fifo | ||
51 | ldr \rd, [ \rx, # S3C2410_UTRSTAT ] | ||
52 | tst \rd, #S3C2410_UTRSTAT_TXFE | ||
53 | beq 1001b | ||
54 | |||
55 | 1002: @ exit busyuart | ||
56 | .endm | ||
57 | |||
58 | .macro waituart,rd,rx | ||
59 | ldr \rd, [ \rx, # S3C2410_UFCON ] | ||
60 | tst \rd, #S3C2410_UFCON_FIFOMODE @ fifo enabled? | ||
61 | beq 1001f @ | ||
62 | @ FIFO enabled... | ||
63 | 1003: | ||
64 | fifo_level \rd, \rx | ||
65 | teq \rd, #0 | ||
66 | bne 1003b | ||
67 | b 1002f | ||
68 | 1001: | ||
69 | @ idle waiting for non fifo | ||
70 | ldr \rd, [ \rx, # S3C2410_UTRSTAT ] | ||
71 | tst \rd, #S3C2410_UTRSTAT_TXFE | ||
72 | beq 1001b | ||
73 | |||
74 | 1002: @ exit busyuart | ||
75 | .endm | ||
diff --git a/include/asm-arm/plat-s3c/map.h b/include/asm-arm/plat-s3c/map.h deleted file mode 100644 index b84289d32a54..000000000000 --- a/include/asm-arm/plat-s3c/map.h +++ /dev/null | |||
@@ -1,40 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c/map.h | ||
2 | * | ||
3 | * Copyright 2003, 2007 Simtec Electronics | ||
4 | * http://armlinux.simtec.co.uk/ | ||
5 | * Ben Dooks <ben@simtec.co.uk> | ||
6 | * | ||
7 | * S3C - Memory map definitions (virtual addresses) | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | */ | ||
13 | |||
14 | #ifndef __ASM_PLAT_MAP_H | ||
15 | #define __ASM_PLAT_MAP_H __FILE__ | ||
16 | |||
17 | /* Fit all our registers in at 0xF4000000 upwards, trying to use as | ||
18 | * little of the VA space as possible so vmalloc and friends have a | ||
19 | * better chance of getting memory. | ||
20 | * | ||
21 | * we try to ensure stuff like the IRQ registers are available for | ||
22 | * an single MOVS instruction (ie, only 8 bits of set data) | ||
23 | */ | ||
24 | |||
25 | #define S3C_ADDR_BASE (0xF4000000) | ||
26 | |||
27 | #ifndef __ASSEMBLY__ | ||
28 | #define S3C_ADDR(x) ((void __iomem __force *)S3C_ADDR_BASE + (x)) | ||
29 | #else | ||
30 | #define S3C_ADDR(x) (S3C_ADDR_BASE + (x)) | ||
31 | #endif | ||
32 | |||
33 | #define S3C_VA_IRQ S3C_ADDR(0x00000000) /* irq controller(s) */ | ||
34 | #define S3C_VA_SYS S3C_ADDR(0x00100000) /* system control */ | ||
35 | #define S3C_VA_MEM S3C_ADDR(0x00200000) /* system control */ | ||
36 | #define S3C_VA_TIMER S3C_ADDR(0x00300000) /* timer block */ | ||
37 | #define S3C_VA_WATCHDOG S3C_ADDR(0x00400000) /* watchdog */ | ||
38 | #define S3C_VA_UART S3C_ADDR(0x01000000) /* UART */ | ||
39 | |||
40 | #endif /* __ASM_PLAT_MAP_H */ | ||
diff --git a/include/asm-arm/plat-s3c/regs-adc.h b/include/asm-arm/plat-s3c/regs-adc.h deleted file mode 100644 index 4323cccc86cd..000000000000 --- a/include/asm-arm/plat-s3c/regs-adc.h +++ /dev/null | |||
@@ -1,60 +0,0 @@ | |||
1 | /* arch/arm/mach-s3c2410/include/mach/regs-adc.h | ||
2 | * | ||
3 | * Copyright (c) 2004 Shannon Holland <holland@loser.net> | ||
4 | * | ||
5 | * This program is free software; yosu can redistribute it and/or modify | ||
6 | * it under the terms of the GNU General Public License version 2 as | ||
7 | * published by the Free Software Foundation. | ||
8 | * | ||
9 | * S3C2410 ADC registers | ||
10 | */ | ||
11 | |||
12 | #ifndef __ASM_ARCH_REGS_ADC_H | ||
13 | #define __ASM_ARCH_REGS_ADC_H "regs-adc.h" | ||
14 | |||
15 | #define S3C2410_ADCREG(x) (x) | ||
16 | |||
17 | #define S3C2410_ADCCON S3C2410_ADCREG(0x00) | ||
18 | #define S3C2410_ADCTSC S3C2410_ADCREG(0x04) | ||
19 | #define S3C2410_ADCDLY S3C2410_ADCREG(0x08) | ||
20 | #define S3C2410_ADCDAT0 S3C2410_ADCREG(0x0C) | ||
21 | #define S3C2410_ADCDAT1 S3C2410_ADCREG(0x10) | ||
22 | |||
23 | |||
24 | /* ADCCON Register Bits */ | ||
25 | #define S3C2410_ADCCON_ECFLG (1<<15) | ||
26 | #define S3C2410_ADCCON_PRSCEN (1<<14) | ||
27 | #define S3C2410_ADCCON_PRSCVL(x) (((x)&0xFF)<<6) | ||
28 | #define S3C2410_ADCCON_PRSCVLMASK (0xFF<<6) | ||
29 | #define S3C2410_ADCCON_SELMUX(x) (((x)&0x7)<<3) | ||
30 | #define S3C2410_ADCCON_MUXMASK (0x7<<3) | ||
31 | #define S3C2410_ADCCON_STDBM (1<<2) | ||
32 | #define S3C2410_ADCCON_READ_START (1<<1) | ||
33 | #define S3C2410_ADCCON_ENABLE_START (1<<0) | ||
34 | #define S3C2410_ADCCON_STARTMASK (0x3<<0) | ||
35 | |||
36 | |||
37 | /* ADCTSC Register Bits */ | ||
38 | #define S3C2410_ADCTSC_YM_SEN (1<<7) | ||
39 | #define S3C2410_ADCTSC_YP_SEN (1<<6) | ||
40 | #define S3C2410_ADCTSC_XM_SEN (1<<5) | ||
41 | #define S3C2410_ADCTSC_XP_SEN (1<<4) | ||
42 | #define S3C2410_ADCTSC_PULL_UP_DISABLE (1<<3) | ||
43 | #define S3C2410_ADCTSC_AUTO_PST (1<<2) | ||
44 | #define S3C2410_ADCTSC_XY_PST(x) (((x)&0x3)<<0) | ||
45 | |||
46 | /* ADCDAT0 Bits */ | ||
47 | #define S3C2410_ADCDAT0_UPDOWN (1<<15) | ||
48 | #define S3C2410_ADCDAT0_AUTO_PST (1<<14) | ||
49 | #define S3C2410_ADCDAT0_XY_PST (0x3<<12) | ||
50 | #define S3C2410_ADCDAT0_XPDATA_MASK (0x03FF) | ||
51 | |||
52 | /* ADCDAT1 Bits */ | ||
53 | #define S3C2410_ADCDAT1_UPDOWN (1<<15) | ||
54 | #define S3C2410_ADCDAT1_AUTO_PST (1<<14) | ||
55 | #define S3C2410_ADCDAT1_XY_PST (0x3<<12) | ||
56 | #define S3C2410_ADCDAT1_YPDATA_MASK (0x03FF) | ||
57 | |||
58 | #endif /* __ASM_ARCH_REGS_ADC_H */ | ||
59 | |||
60 | |||
diff --git a/include/asm-arm/plat-s3c/regs-serial.h b/include/asm-arm/plat-s3c/regs-serial.h deleted file mode 100644 index a0daa647b92c..000000000000 --- a/include/asm-arm/plat-s3c/regs-serial.h +++ /dev/null | |||
@@ -1,232 +0,0 @@ | |||
1 | /* arch/arm/mach-s3c2410/include/mach/regs-serial.h | ||
2 | * | ||
3 | * From linux/include/asm-arm/hardware/serial_s3c2410.h | ||
4 | * | ||
5 | * Internal header file for Samsung S3C2410 serial ports (UART0-2) | ||
6 | * | ||
7 | * Copyright (C) 2002 Shane Nay (shane@minirl.com) | ||
8 | * | ||
9 | * Additional defines, (c) 2003 Simtec Electronics (linux@simtec.co.uk) | ||
10 | * | ||
11 | * Adapted from: | ||
12 | * | ||
13 | * Internal header file for MX1ADS serial ports (UART1 & 2) | ||
14 | * | ||
15 | * Copyright (C) 2002 Shane Nay (shane@minirl.com) | ||
16 | * | ||
17 | * This program is free software; you can redistribute it and/or modify | ||
18 | * it under the terms of the GNU General Public License as published by | ||
19 | * the Free Software Foundation; either version 2 of the License, or | ||
20 | * (at your option) any later version. | ||
21 | * | ||
22 | * This program is distributed in the hope that it will be useful, | ||
23 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
24 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
25 | * GNU General Public License for more details. | ||
26 | * | ||
27 | * You should have received a copy of the GNU General Public License | ||
28 | * along with this program; if not, write to the Free Software | ||
29 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
30 | */ | ||
31 | |||
32 | #ifndef __ASM_ARM_REGS_SERIAL_H | ||
33 | #define __ASM_ARM_REGS_SERIAL_H | ||
34 | |||
35 | #define S3C24XX_VA_UART0 (S3C_VA_UART) | ||
36 | #define S3C24XX_VA_UART1 (S3C_VA_UART + 0x4000 ) | ||
37 | #define S3C24XX_VA_UART2 (S3C_VA_UART + 0x8000 ) | ||
38 | #define S3C24XX_VA_UART3 (S3C_VA_UART + 0xC000 ) | ||
39 | |||
40 | #define S3C2410_PA_UART0 (S3C24XX_PA_UART) | ||
41 | #define S3C2410_PA_UART1 (S3C24XX_PA_UART + 0x4000 ) | ||
42 | #define S3C2410_PA_UART2 (S3C24XX_PA_UART + 0x8000 ) | ||
43 | #define S3C2443_PA_UART3 (S3C24XX_PA_UART + 0xC000 ) | ||
44 | |||
45 | #define S3C2410_URXH (0x24) | ||
46 | #define S3C2410_UTXH (0x20) | ||
47 | #define S3C2410_ULCON (0x00) | ||
48 | #define S3C2410_UCON (0x04) | ||
49 | #define S3C2410_UFCON (0x08) | ||
50 | #define S3C2410_UMCON (0x0C) | ||
51 | #define S3C2410_UBRDIV (0x28) | ||
52 | #define S3C2410_UTRSTAT (0x10) | ||
53 | #define S3C2410_UERSTAT (0x14) | ||
54 | #define S3C2410_UFSTAT (0x18) | ||
55 | #define S3C2410_UMSTAT (0x1C) | ||
56 | |||
57 | #define S3C2410_LCON_CFGMASK ((0xF<<3)|(0x3)) | ||
58 | |||
59 | #define S3C2410_LCON_CS5 (0x0) | ||
60 | #define S3C2410_LCON_CS6 (0x1) | ||
61 | #define S3C2410_LCON_CS7 (0x2) | ||
62 | #define S3C2410_LCON_CS8 (0x3) | ||
63 | #define S3C2410_LCON_CSMASK (0x3) | ||
64 | |||
65 | #define S3C2410_LCON_PNONE (0x0) | ||
66 | #define S3C2410_LCON_PEVEN (0x5 << 3) | ||
67 | #define S3C2410_LCON_PODD (0x4 << 3) | ||
68 | #define S3C2410_LCON_PMASK (0x7 << 3) | ||
69 | |||
70 | #define S3C2410_LCON_STOPB (1<<2) | ||
71 | #define S3C2410_LCON_IRM (1<<6) | ||
72 | |||
73 | #define S3C2440_UCON_CLKMASK (3<<10) | ||
74 | #define S3C2440_UCON_PCLK (0<<10) | ||
75 | #define S3C2440_UCON_UCLK (1<<10) | ||
76 | #define S3C2440_UCON_PCLK2 (2<<10) | ||
77 | #define S3C2440_UCON_FCLK (3<<10) | ||
78 | #define S3C2443_UCON_EPLL (3<<10) | ||
79 | |||
80 | #define S3C2440_UCON2_FCLK_EN (1<<15) | ||
81 | #define S3C2440_UCON0_DIVMASK (15 << 12) | ||
82 | #define S3C2440_UCON1_DIVMASK (15 << 12) | ||
83 | #define S3C2440_UCON2_DIVMASK (7 << 12) | ||
84 | #define S3C2440_UCON_DIVSHIFT (12) | ||
85 | |||
86 | #define S3C2412_UCON_CLKMASK (3<<10) | ||
87 | #define S3C2412_UCON_UCLK (1<<10) | ||
88 | #define S3C2412_UCON_USYSCLK (3<<10) | ||
89 | #define S3C2412_UCON_PCLK (0<<10) | ||
90 | #define S3C2412_UCON_PCLK2 (2<<10) | ||
91 | |||
92 | #define S3C2410_UCON_UCLK (1<<10) | ||
93 | #define S3C2410_UCON_SBREAK (1<<4) | ||
94 | |||
95 | #define S3C2410_UCON_TXILEVEL (1<<9) | ||
96 | #define S3C2410_UCON_RXILEVEL (1<<8) | ||
97 | #define S3C2410_UCON_TXIRQMODE (1<<2) | ||
98 | #define S3C2410_UCON_RXIRQMODE (1<<0) | ||
99 | #define S3C2410_UCON_RXFIFO_TOI (1<<7) | ||
100 | #define S3C2443_UCON_RXERR_IRQEN (1<<6) | ||
101 | #define S3C2443_UCON_LOOPBACK (1<<5) | ||
102 | |||
103 | #define S3C2410_UCON_DEFAULT (S3C2410_UCON_TXILEVEL | \ | ||
104 | S3C2410_UCON_RXILEVEL | \ | ||
105 | S3C2410_UCON_TXIRQMODE | \ | ||
106 | S3C2410_UCON_RXIRQMODE | \ | ||
107 | S3C2410_UCON_RXFIFO_TOI) | ||
108 | |||
109 | #define S3C2410_UFCON_FIFOMODE (1<<0) | ||
110 | #define S3C2410_UFCON_TXTRIG0 (0<<6) | ||
111 | #define S3C2410_UFCON_RXTRIG8 (1<<4) | ||
112 | #define S3C2410_UFCON_RXTRIG12 (2<<4) | ||
113 | |||
114 | /* S3C2440 FIFO trigger levels */ | ||
115 | #define S3C2440_UFCON_RXTRIG1 (0<<4) | ||
116 | #define S3C2440_UFCON_RXTRIG8 (1<<4) | ||
117 | #define S3C2440_UFCON_RXTRIG16 (2<<4) | ||
118 | #define S3C2440_UFCON_RXTRIG32 (3<<4) | ||
119 | |||
120 | #define S3C2440_UFCON_TXTRIG0 (0<<6) | ||
121 | #define S3C2440_UFCON_TXTRIG16 (1<<6) | ||
122 | #define S3C2440_UFCON_TXTRIG32 (2<<6) | ||
123 | #define S3C2440_UFCON_TXTRIG48 (3<<6) | ||
124 | |||
125 | #define S3C2410_UFCON_RESETBOTH (3<<1) | ||
126 | #define S3C2410_UFCON_RESETTX (1<<2) | ||
127 | #define S3C2410_UFCON_RESETRX (1<<1) | ||
128 | |||
129 | #define S3C2410_UFCON_DEFAULT (S3C2410_UFCON_FIFOMODE | \ | ||
130 | S3C2410_UFCON_TXTRIG0 | \ | ||
131 | S3C2410_UFCON_RXTRIG8 ) | ||
132 | |||
133 | #define S3C2410_UMCOM_AFC (1<<4) | ||
134 | #define S3C2410_UMCOM_RTS_LOW (1<<0) | ||
135 | |||
136 | #define S3C2412_UMCON_AFC_63 (0<<5) /* same as s3c2443 */ | ||
137 | #define S3C2412_UMCON_AFC_56 (1<<5) | ||
138 | #define S3C2412_UMCON_AFC_48 (2<<5) | ||
139 | #define S3C2412_UMCON_AFC_40 (3<<5) | ||
140 | #define S3C2412_UMCON_AFC_32 (4<<5) | ||
141 | #define S3C2412_UMCON_AFC_24 (5<<5) | ||
142 | #define S3C2412_UMCON_AFC_16 (6<<5) | ||
143 | #define S3C2412_UMCON_AFC_8 (7<<5) | ||
144 | |||
145 | #define S3C2410_UFSTAT_TXFULL (1<<9) | ||
146 | #define S3C2410_UFSTAT_RXFULL (1<<8) | ||
147 | #define S3C2410_UFSTAT_TXMASK (15<<4) | ||
148 | #define S3C2410_UFSTAT_TXSHIFT (4) | ||
149 | #define S3C2410_UFSTAT_RXMASK (15<<0) | ||
150 | #define S3C2410_UFSTAT_RXSHIFT (0) | ||
151 | |||
152 | /* UFSTAT S3C2443 same as S3C2440 */ | ||
153 | #define S3C2440_UFSTAT_TXFULL (1<<14) | ||
154 | #define S3C2440_UFSTAT_RXFULL (1<<6) | ||
155 | #define S3C2440_UFSTAT_TXSHIFT (8) | ||
156 | #define S3C2440_UFSTAT_RXSHIFT (0) | ||
157 | #define S3C2440_UFSTAT_TXMASK (63<<8) | ||
158 | #define S3C2440_UFSTAT_RXMASK (63) | ||
159 | |||
160 | #define S3C2410_UTRSTAT_TXE (1<<2) | ||
161 | #define S3C2410_UTRSTAT_TXFE (1<<1) | ||
162 | #define S3C2410_UTRSTAT_RXDR (1<<0) | ||
163 | |||
164 | #define S3C2410_UERSTAT_OVERRUN (1<<0) | ||
165 | #define S3C2410_UERSTAT_FRAME (1<<2) | ||
166 | #define S3C2410_UERSTAT_BREAK (1<<3) | ||
167 | #define S3C2443_UERSTAT_PARITY (1<<1) | ||
168 | |||
169 | #define S3C2410_UERSTAT_ANY (S3C2410_UERSTAT_OVERRUN | \ | ||
170 | S3C2410_UERSTAT_FRAME | \ | ||
171 | S3C2410_UERSTAT_BREAK) | ||
172 | |||
173 | #define S3C2410_UMSTAT_CTS (1<<0) | ||
174 | #define S3C2410_UMSTAT_DeltaCTS (1<<2) | ||
175 | |||
176 | #define S3C2443_DIVSLOT (0x2C) | ||
177 | |||
178 | #ifndef __ASSEMBLY__ | ||
179 | |||
180 | /* struct s3c24xx_uart_clksrc | ||
181 | * | ||
182 | * this structure defines a named clock source that can be used for the | ||
183 | * uart, so that the best clock can be selected for the requested baud | ||
184 | * rate. | ||
185 | * | ||
186 | * min_baud and max_baud define the range of baud-rates this clock is | ||
187 | * acceptable for, if they are both zero, it is assumed any baud rate that | ||
188 | * can be generated from this clock will be used. | ||
189 | * | ||
190 | * divisor gives the divisor from the clock to the one seen by the uart | ||
191 | */ | ||
192 | |||
193 | struct s3c24xx_uart_clksrc { | ||
194 | const char *name; | ||
195 | unsigned int divisor; | ||
196 | unsigned int min_baud; | ||
197 | unsigned int max_baud; | ||
198 | }; | ||
199 | |||
200 | /* configuration structure for per-machine configurations for the | ||
201 | * serial port | ||
202 | * | ||
203 | * the pointer is setup by the machine specific initialisation from the | ||
204 | * arch/arm/mach-s3c2410/ directory. | ||
205 | */ | ||
206 | |||
207 | struct s3c2410_uartcfg { | ||
208 | unsigned char hwport; /* hardware port number */ | ||
209 | unsigned char unused; | ||
210 | unsigned short flags; | ||
211 | upf_t uart_flags; /* default uart flags */ | ||
212 | |||
213 | unsigned long ucon; /* value of ucon for port */ | ||
214 | unsigned long ulcon; /* value of ulcon for port */ | ||
215 | unsigned long ufcon; /* value of ufcon for port */ | ||
216 | |||
217 | struct s3c24xx_uart_clksrc *clocks; | ||
218 | unsigned int clocks_size; | ||
219 | }; | ||
220 | |||
221 | /* s3c24xx_uart_devs | ||
222 | * | ||
223 | * this is exported from the core as we cannot use driver_register(), | ||
224 | * or platform_add_device() before the console_initcall() | ||
225 | */ | ||
226 | |||
227 | extern struct platform_device *s3c24xx_uart_devs[3]; | ||
228 | |||
229 | #endif /* __ASSEMBLY__ */ | ||
230 | |||
231 | #endif /* __ASM_ARM_REGS_SERIAL_H */ | ||
232 | |||
diff --git a/include/asm-arm/plat-s3c/regs-timer.h b/include/asm-arm/plat-s3c/regs-timer.h deleted file mode 100644 index cc0eedd53e38..000000000000 --- a/include/asm-arm/plat-s3c/regs-timer.h +++ /dev/null | |||
@@ -1,115 +0,0 @@ | |||
1 | /* arch/arm/mach-s3c2410/include/mach/regs-timer.h | ||
2 | * | ||
3 | * Copyright (c) 2003 Simtec Electronics <linux@simtec.co.uk> | ||
4 | * http://www.simtec.co.uk/products/SWLINUX/ | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License version 2 as | ||
8 | * published by the Free Software Foundation. | ||
9 | * | ||
10 | * S3C2410 Timer configuration | ||
11 | */ | ||
12 | |||
13 | |||
14 | #ifndef __ASM_ARCH_REGS_TIMER_H | ||
15 | #define __ASM_ARCH_REGS_TIMER_H | ||
16 | |||
17 | #define S3C_TIMERREG(x) (S3C_VA_TIMER + (x)) | ||
18 | #define S3C_TIMERREG2(tmr,reg) S3C_TIMERREG((reg)+0x0c+((tmr)*0x0c)) | ||
19 | |||
20 | #define S3C2410_TCFG0 S3C_TIMERREG(0x00) | ||
21 | #define S3C2410_TCFG1 S3C_TIMERREG(0x04) | ||
22 | #define S3C2410_TCON S3C_TIMERREG(0x08) | ||
23 | |||
24 | #define S3C2410_TCFG_PRESCALER0_MASK (255<<0) | ||
25 | #define S3C2410_TCFG_PRESCALER1_MASK (255<<8) | ||
26 | #define S3C2410_TCFG_PRESCALER1_SHIFT (8) | ||
27 | #define S3C2410_TCFG_DEADZONE_MASK (255<<16) | ||
28 | #define S3C2410_TCFG_DEADZONE_SHIFT (16) | ||
29 | |||
30 | #define S3C2410_TCFG1_MUX4_DIV2 (0<<16) | ||
31 | #define S3C2410_TCFG1_MUX4_DIV4 (1<<16) | ||
32 | #define S3C2410_TCFG1_MUX4_DIV8 (2<<16) | ||
33 | #define S3C2410_TCFG1_MUX4_DIV16 (3<<16) | ||
34 | #define S3C2410_TCFG1_MUX4_TCLK1 (4<<16) | ||
35 | #define S3C2410_TCFG1_MUX4_MASK (15<<16) | ||
36 | #define S3C2410_TCFG1_MUX4_SHIFT (16) | ||
37 | |||
38 | #define S3C2410_TCFG1_MUX3_DIV2 (0<<12) | ||
39 | #define S3C2410_TCFG1_MUX3_DIV4 (1<<12) | ||
40 | #define S3C2410_TCFG1_MUX3_DIV8 (2<<12) | ||
41 | #define S3C2410_TCFG1_MUX3_DIV16 (3<<12) | ||
42 | #define S3C2410_TCFG1_MUX3_TCLK1 (4<<12) | ||
43 | #define S3C2410_TCFG1_MUX3_MASK (15<<12) | ||
44 | |||
45 | |||
46 | #define S3C2410_TCFG1_MUX2_DIV2 (0<<8) | ||
47 | #define S3C2410_TCFG1_MUX2_DIV4 (1<<8) | ||
48 | #define S3C2410_TCFG1_MUX2_DIV8 (2<<8) | ||
49 | #define S3C2410_TCFG1_MUX2_DIV16 (3<<8) | ||
50 | #define S3C2410_TCFG1_MUX2_TCLK1 (4<<8) | ||
51 | #define S3C2410_TCFG1_MUX2_MASK (15<<8) | ||
52 | |||
53 | |||
54 | #define S3C2410_TCFG1_MUX1_DIV2 (0<<4) | ||
55 | #define S3C2410_TCFG1_MUX1_DIV4 (1<<4) | ||
56 | #define S3C2410_TCFG1_MUX1_DIV8 (2<<4) | ||
57 | #define S3C2410_TCFG1_MUX1_DIV16 (3<<4) | ||
58 | #define S3C2410_TCFG1_MUX1_TCLK0 (4<<4) | ||
59 | #define S3C2410_TCFG1_MUX1_MASK (15<<4) | ||
60 | |||
61 | #define S3C2410_TCFG1_MUX0_DIV2 (0<<0) | ||
62 | #define S3C2410_TCFG1_MUX0_DIV4 (1<<0) | ||
63 | #define S3C2410_TCFG1_MUX0_DIV8 (2<<0) | ||
64 | #define S3C2410_TCFG1_MUX0_DIV16 (3<<0) | ||
65 | #define S3C2410_TCFG1_MUX0_TCLK0 (4<<0) | ||
66 | #define S3C2410_TCFG1_MUX0_MASK (15<<0) | ||
67 | |||
68 | #define S3C2410_TCFG1_MUX_DIV2 (0<<0) | ||
69 | #define S3C2410_TCFG1_MUX_DIV4 (1<<0) | ||
70 | #define S3C2410_TCFG1_MUX_DIV8 (2<<0) | ||
71 | #define S3C2410_TCFG1_MUX_DIV16 (3<<0) | ||
72 | #define S3C2410_TCFG1_MUX_TCLK (4<<0) | ||
73 | #define S3C2410_TCFG1_MUX_MASK (15<<0) | ||
74 | |||
75 | #define S3C2410_TCFG1_SHIFT(x) ((x) * 4) | ||
76 | |||
77 | /* for each timer, we have an count buffer, an compare buffer and | ||
78 | * an observation buffer | ||
79 | */ | ||
80 | |||
81 | /* WARNING - timer 4 has no buffer reg, and it's observation is at +4 */ | ||
82 | |||
83 | #define S3C2410_TCNTB(tmr) S3C_TIMERREG2(tmr, 0x00) | ||
84 | #define S3C2410_TCMPB(tmr) S3C_TIMERREG2(tmr, 0x04) | ||
85 | #define S3C2410_TCNTO(tmr) S3C_TIMERREG2(tmr, (((tmr) == 4) ? 0x04 : 0x08)) | ||
86 | |||
87 | #define S3C2410_TCON_T4RELOAD (1<<22) | ||
88 | #define S3C2410_TCON_T4MANUALUPD (1<<21) | ||
89 | #define S3C2410_TCON_T4START (1<<20) | ||
90 | |||
91 | #define S3C2410_TCON_T3RELOAD (1<<19) | ||
92 | #define S3C2410_TCON_T3INVERT (1<<18) | ||
93 | #define S3C2410_TCON_T3MANUALUPD (1<<17) | ||
94 | #define S3C2410_TCON_T3START (1<<16) | ||
95 | |||
96 | #define S3C2410_TCON_T2RELOAD (1<<15) | ||
97 | #define S3C2410_TCON_T2INVERT (1<<14) | ||
98 | #define S3C2410_TCON_T2MANUALUPD (1<<13) | ||
99 | #define S3C2410_TCON_T2START (1<<12) | ||
100 | |||
101 | #define S3C2410_TCON_T1RELOAD (1<<11) | ||
102 | #define S3C2410_TCON_T1INVERT (1<<10) | ||
103 | #define S3C2410_TCON_T1MANUALUPD (1<<9) | ||
104 | #define S3C2410_TCON_T1START (1<<8) | ||
105 | |||
106 | #define S3C2410_TCON_T0DEADZONE (1<<4) | ||
107 | #define S3C2410_TCON_T0RELOAD (1<<3) | ||
108 | #define S3C2410_TCON_T0INVERT (1<<2) | ||
109 | #define S3C2410_TCON_T0MANUALUPD (1<<1) | ||
110 | #define S3C2410_TCON_T0START (1<<0) | ||
111 | |||
112 | #endif /* __ASM_ARCH_REGS_TIMER_H */ | ||
113 | |||
114 | |||
115 | |||
diff --git a/include/asm-arm/plat-s3c/uncompress.h b/include/asm-arm/plat-s3c/uncompress.h deleted file mode 100644 index 19b9eda39485..000000000000 --- a/include/asm-arm/plat-s3c/uncompress.h +++ /dev/null | |||
@@ -1,155 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c/uncompress.h | ||
2 | * | ||
3 | * Copyright 2003, 2007 Simtec Electronics | ||
4 | * http://armlinux.simtec.co.uk/ | ||
5 | * Ben Dooks <ben@simtec.co.uk> | ||
6 | * | ||
7 | * S3C - uncompress code | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | */ | ||
13 | |||
14 | #ifndef __ASM_PLAT_UNCOMPRESS_H | ||
15 | #define __ASM_PLAT_UNCOMPRESS_H | ||
16 | |||
17 | typedef unsigned int upf_t; /* cannot include linux/serial_core.h */ | ||
18 | |||
19 | /* uart setup */ | ||
20 | |||
21 | static unsigned int fifo_mask; | ||
22 | static unsigned int fifo_max; | ||
23 | |||
24 | /* forward declerations */ | ||
25 | |||
26 | static void arch_detect_cpu(void); | ||
27 | |||
28 | /* defines for UART registers */ | ||
29 | |||
30 | #include <asm/plat-s3c/regs-serial.h> | ||
31 | #include <asm/plat-s3c/regs-watchdog.h> | ||
32 | |||
33 | /* working in physical space... */ | ||
34 | #undef S3C2410_WDOGREG | ||
35 | #define S3C2410_WDOGREG(x) ((S3C24XX_PA_WATCHDOG + (x))) | ||
36 | |||
37 | /* how many bytes we allow into the FIFO at a time in FIFO mode */ | ||
38 | #define FIFO_MAX (14) | ||
39 | |||
40 | #define uart_base S3C24XX_PA_UART + (0x4000*CONFIG_S3C_LOWLEVEL_UART_PORT) | ||
41 | |||
42 | static __inline__ void | ||
43 | uart_wr(unsigned int reg, unsigned int val) | ||
44 | { | ||
45 | volatile unsigned int *ptr; | ||
46 | |||
47 | ptr = (volatile unsigned int *)(reg + uart_base); | ||
48 | *ptr = val; | ||
49 | } | ||
50 | |||
51 | static __inline__ unsigned int | ||
52 | uart_rd(unsigned int reg) | ||
53 | { | ||
54 | volatile unsigned int *ptr; | ||
55 | |||
56 | ptr = (volatile unsigned int *)(reg + uart_base); | ||
57 | return *ptr; | ||
58 | } | ||
59 | |||
60 | /* we can deal with the case the UARTs are being run | ||
61 | * in FIFO mode, so that we don't hold up our execution | ||
62 | * waiting for tx to happen... | ||
63 | */ | ||
64 | |||
65 | static void putc(int ch) | ||
66 | { | ||
67 | if (uart_rd(S3C2410_UFCON) & S3C2410_UFCON_FIFOMODE) { | ||
68 | int level; | ||
69 | |||
70 | while (1) { | ||
71 | level = uart_rd(S3C2410_UFSTAT); | ||
72 | level &= fifo_mask; | ||
73 | |||
74 | if (level < fifo_max) | ||
75 | break; | ||
76 | } | ||
77 | |||
78 | } else { | ||
79 | /* not using fifos */ | ||
80 | |||
81 | while ((uart_rd(S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE) != S3C2410_UTRSTAT_TXE) | ||
82 | barrier(); | ||
83 | } | ||
84 | |||
85 | /* write byte to transmission register */ | ||
86 | uart_wr(S3C2410_UTXH, ch); | ||
87 | } | ||
88 | |||
89 | static inline void flush(void) | ||
90 | { | ||
91 | } | ||
92 | |||
93 | #define __raw_writel(d,ad) do { *((volatile unsigned int *)(ad)) = (d); } while(0) | ||
94 | |||
95 | /* CONFIG_S3C_BOOT_WATCHDOG | ||
96 | * | ||
97 | * Simple boot-time watchdog setup, to reboot the system if there is | ||
98 | * any problem with the boot process | ||
99 | */ | ||
100 | |||
101 | #ifdef CONFIG_S3C_BOOT_WATCHDOG | ||
102 | |||
103 | #define WDOG_COUNT (0xff00) | ||
104 | |||
105 | static inline void arch_decomp_wdog(void) | ||
106 | { | ||
107 | __raw_writel(WDOG_COUNT, S3C2410_WTCNT); | ||
108 | } | ||
109 | |||
110 | static void arch_decomp_wdog_start(void) | ||
111 | { | ||
112 | __raw_writel(WDOG_COUNT, S3C2410_WTDAT); | ||
113 | __raw_writel(WDOG_COUNT, S3C2410_WTCNT); | ||
114 | __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x80), S3C2410_WTCON); | ||
115 | } | ||
116 | |||
117 | #else | ||
118 | #define arch_decomp_wdog_start() | ||
119 | #define arch_decomp_wdog() | ||
120 | #endif | ||
121 | |||
122 | #ifdef CONFIG_S3C_BOOT_ERROR_RESET | ||
123 | |||
124 | static void arch_decomp_error(const char *x) | ||
125 | { | ||
126 | putstr("\n\n"); | ||
127 | putstr(x); | ||
128 | putstr("\n\n -- System resetting\n"); | ||
129 | |||
130 | __raw_writel(0x4000, S3C2410_WTDAT); | ||
131 | __raw_writel(0x4000, S3C2410_WTCNT); | ||
132 | __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x40), S3C2410_WTCON); | ||
133 | |||
134 | while(1); | ||
135 | } | ||
136 | |||
137 | #define arch_error arch_decomp_error | ||
138 | #endif | ||
139 | |||
140 | static void error(char *err); | ||
141 | |||
142 | static void | ||
143 | arch_decomp_setup(void) | ||
144 | { | ||
145 | /* we may need to setup the uart(s) here if we are not running | ||
146 | * on an BAST... the BAST will have left the uarts configured | ||
147 | * after calling linux. | ||
148 | */ | ||
149 | |||
150 | arch_detect_cpu(); | ||
151 | arch_decomp_wdog_start(); | ||
152 | } | ||
153 | |||
154 | |||
155 | #endif /* __ASM_PLAT_UNCOMPRESS_H */ | ||
diff --git a/include/asm-arm/plat-s3c24xx/clock.h b/include/asm-arm/plat-s3c24xx/clock.h deleted file mode 100644 index 235b753cd877..000000000000 --- a/include/asm-arm/plat-s3c24xx/clock.h +++ /dev/null | |||
@@ -1,64 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/clock.h | ||
2 | * linux/arch/arm/mach-s3c2410/clock.h | ||
3 | * | ||
4 | * Copyright (c) 2004-2005 Simtec Electronics | ||
5 | * http://www.simtec.co.uk/products/SWLINUX/ | ||
6 | * Written by Ben Dooks, <ben@simtec.co.uk> | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | struct clk { | ||
14 | struct list_head list; | ||
15 | struct module *owner; | ||
16 | struct clk *parent; | ||
17 | const char *name; | ||
18 | int id; | ||
19 | int usage; | ||
20 | unsigned long rate; | ||
21 | unsigned long ctrlbit; | ||
22 | |||
23 | int (*enable)(struct clk *, int enable); | ||
24 | int (*set_rate)(struct clk *c, unsigned long rate); | ||
25 | unsigned long (*get_rate)(struct clk *c); | ||
26 | unsigned long (*round_rate)(struct clk *c, unsigned long rate); | ||
27 | int (*set_parent)(struct clk *c, struct clk *parent); | ||
28 | }; | ||
29 | |||
30 | /* other clocks which may be registered by board support */ | ||
31 | |||
32 | extern struct clk s3c24xx_dclk0; | ||
33 | extern struct clk s3c24xx_dclk1; | ||
34 | extern struct clk s3c24xx_clkout0; | ||
35 | extern struct clk s3c24xx_clkout1; | ||
36 | extern struct clk s3c24xx_uclk; | ||
37 | |||
38 | extern struct clk clk_usb_bus; | ||
39 | |||
40 | /* core clock support */ | ||
41 | |||
42 | extern struct clk clk_f; | ||
43 | extern struct clk clk_h; | ||
44 | extern struct clk clk_p; | ||
45 | extern struct clk clk_mpll; | ||
46 | extern struct clk clk_upll; | ||
47 | extern struct clk clk_xtal; | ||
48 | |||
49 | /* exports for arch/arm/mach-s3c2410 | ||
50 | * | ||
51 | * Please DO NOT use these outside of arch/arm/mach-s3c2410 | ||
52 | */ | ||
53 | |||
54 | extern struct mutex clocks_mutex; | ||
55 | |||
56 | extern int s3c2410_clkcon_enable(struct clk *clk, int enable); | ||
57 | |||
58 | extern int s3c24xx_register_clock(struct clk *clk); | ||
59 | extern int s3c24xx_register_clocks(struct clk **clk, int nr_clks); | ||
60 | |||
61 | extern int s3c24xx_setup_clocks(unsigned long xtal, | ||
62 | unsigned long fclk, | ||
63 | unsigned long hclk, | ||
64 | unsigned long pclk); | ||
diff --git a/include/asm-arm/plat-s3c24xx/common-smdk.h b/include/asm-arm/plat-s3c24xx/common-smdk.h deleted file mode 100644 index 58d9094c935c..000000000000 --- a/include/asm-arm/plat-s3c24xx/common-smdk.h +++ /dev/null | |||
@@ -1,15 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/common-smdk.h | ||
2 | * | ||
3 | * Copyright (c) 2006 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Common code for SMDK2410 and SMDK2440 boards | ||
7 | * | ||
8 | * http://www.fluff.org/ben/smdk2440/ | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License version 2 as | ||
12 | * published by the Free Software Foundation. | ||
13 | */ | ||
14 | |||
15 | extern void smdk_machine_init(void); | ||
diff --git a/include/asm-arm/plat-s3c24xx/cpu.h b/include/asm-arm/plat-s3c24xx/cpu.h deleted file mode 100644 index 23e420e8bd5b..000000000000 --- a/include/asm-arm/plat-s3c24xx/cpu.h +++ /dev/null | |||
@@ -1,54 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/cpu.h | ||
2 | * | ||
3 | * Copyright (c) 2004-2005 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for S3C24XX CPU support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | /* todo - fix when rmk changes iodescs to use `void __iomem *` */ | ||
14 | |||
15 | #define IODESC_ENT(x) { (unsigned long)S3C24XX_VA_##x, __phys_to_pfn(S3C24XX_PA_##x), S3C24XX_SZ_##x, MT_DEVICE } | ||
16 | |||
17 | #ifndef MHZ | ||
18 | #define MHZ (1000*1000) | ||
19 | #endif | ||
20 | |||
21 | #define print_mhz(m) ((m) / MHZ), ((m / 1000) % 1000) | ||
22 | |||
23 | /* forward declaration */ | ||
24 | struct s3c24xx_uart_resources; | ||
25 | struct platform_device; | ||
26 | struct s3c2410_uartcfg; | ||
27 | struct map_desc; | ||
28 | |||
29 | /* core initialisation functions */ | ||
30 | |||
31 | extern void s3c24xx_init_irq(void); | ||
32 | |||
33 | extern void s3c24xx_init_io(struct map_desc *mach_desc, int size); | ||
34 | |||
35 | extern void s3c24xx_init_uarts(struct s3c2410_uartcfg *cfg, int no); | ||
36 | |||
37 | extern void s3c24xx_init_clocks(int xtal); | ||
38 | |||
39 | extern void s3c24xx_init_uartdevs(char *name, | ||
40 | struct s3c24xx_uart_resources *res, | ||
41 | struct s3c2410_uartcfg *cfg, int no); | ||
42 | |||
43 | /* timer for 2410/2440 */ | ||
44 | |||
45 | struct sys_timer; | ||
46 | extern struct sys_timer s3c24xx_timer; | ||
47 | |||
48 | /* system device classes */ | ||
49 | |||
50 | extern struct sysdev_class s3c2410_sysclass; | ||
51 | extern struct sysdev_class s3c2412_sysclass; | ||
52 | extern struct sysdev_class s3c2440_sysclass; | ||
53 | extern struct sysdev_class s3c2442_sysclass; | ||
54 | extern struct sysdev_class s3c2443_sysclass; | ||
diff --git a/include/asm-arm/plat-s3c24xx/devs.h b/include/asm-arm/plat-s3c24xx/devs.h deleted file mode 100644 index badaac9d64a8..000000000000 --- a/include/asm-arm/plat-s3c24xx/devs.h +++ /dev/null | |||
@@ -1,49 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/devs.h | ||
2 | * | ||
3 | * Copyright (c) 2004 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2410 standard platform devices | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | #include <linux/platform_device.h> | ||
13 | |||
14 | struct s3c24xx_uart_resources { | ||
15 | struct resource *resources; | ||
16 | unsigned long nr_resources; | ||
17 | }; | ||
18 | |||
19 | extern struct s3c24xx_uart_resources s3c2410_uart_resources[]; | ||
20 | |||
21 | extern struct platform_device *s3c24xx_uart_devs[]; | ||
22 | extern struct platform_device *s3c24xx_uart_src[]; | ||
23 | |||
24 | extern struct platform_device s3c_device_timer[]; | ||
25 | |||
26 | extern struct platform_device s3c_device_usb; | ||
27 | extern struct platform_device s3c_device_lcd; | ||
28 | extern struct platform_device s3c_device_wdt; | ||
29 | extern struct platform_device s3c_device_i2c; | ||
30 | extern struct platform_device s3c_device_iis; | ||
31 | extern struct platform_device s3c_device_rtc; | ||
32 | extern struct platform_device s3c_device_adc; | ||
33 | extern struct platform_device s3c_device_sdi; | ||
34 | extern struct platform_device s3c_device_hsmmc; | ||
35 | |||
36 | extern struct platform_device s3c_device_spi0; | ||
37 | extern struct platform_device s3c_device_spi1; | ||
38 | |||
39 | extern struct platform_device s3c_device_nand; | ||
40 | |||
41 | extern struct platform_device s3c_device_usbgadget; | ||
42 | |||
43 | /* s3c2440 specific devices */ | ||
44 | |||
45 | #ifdef CONFIG_CPU_S3C2440 | ||
46 | |||
47 | extern struct platform_device s3c_device_camif; | ||
48 | |||
49 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/dma.h b/include/asm-arm/plat-s3c24xx/dma.h deleted file mode 100644 index c78efe316fc8..000000000000 --- a/include/asm-arm/plat-s3c24xx/dma.h +++ /dev/null | |||
@@ -1,82 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/dma.h | ||
2 | * | ||
3 | * Copyright (C) 2006 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Samsung S3C24XX DMA support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | extern struct sysdev_class dma_sysclass; | ||
14 | extern struct s3c2410_dma_chan s3c2410_chans[S3C2410_DMA_CHANNELS]; | ||
15 | |||
16 | #define DMA_CH_VALID (1<<31) | ||
17 | #define DMA_CH_NEVER (1<<30) | ||
18 | |||
19 | struct s3c24xx_dma_addr { | ||
20 | unsigned long from; | ||
21 | unsigned long to; | ||
22 | }; | ||
23 | |||
24 | /* struct s3c24xx_dma_map | ||
25 | * | ||
26 | * this holds the mapping information for the channel selected | ||
27 | * to be connected to the specified device | ||
28 | */ | ||
29 | |||
30 | struct s3c24xx_dma_map { | ||
31 | const char *name; | ||
32 | struct s3c24xx_dma_addr hw_addr; | ||
33 | |||
34 | unsigned long channels[S3C2410_DMA_CHANNELS]; | ||
35 | unsigned long channels_rx[S3C2410_DMA_CHANNELS]; | ||
36 | }; | ||
37 | |||
38 | struct s3c24xx_dma_selection { | ||
39 | struct s3c24xx_dma_map *map; | ||
40 | unsigned long map_size; | ||
41 | unsigned long dcon_mask; | ||
42 | |||
43 | void (*select)(struct s3c2410_dma_chan *chan, | ||
44 | struct s3c24xx_dma_map *map); | ||
45 | |||
46 | void (*direction)(struct s3c2410_dma_chan *chan, | ||
47 | struct s3c24xx_dma_map *map, | ||
48 | enum s3c2410_dmasrc dir); | ||
49 | }; | ||
50 | |||
51 | extern int s3c24xx_dma_init_map(struct s3c24xx_dma_selection *sel); | ||
52 | |||
53 | /* struct s3c24xx_dma_order_ch | ||
54 | * | ||
55 | * channel map for one of the `enum dma_ch` dma channels. the list | ||
56 | * entry contains a set of low-level channel numbers, orred with | ||
57 | * DMA_CH_VALID, which are checked in the order in the array. | ||
58 | */ | ||
59 | |||
60 | struct s3c24xx_dma_order_ch { | ||
61 | unsigned int list[S3C2410_DMA_CHANNELS]; /* list of channels */ | ||
62 | unsigned int flags; /* flags */ | ||
63 | }; | ||
64 | |||
65 | /* struct s3c24xx_dma_order | ||
66 | * | ||
67 | * information provided by either the core or the board to give the | ||
68 | * dma system a hint on how to allocate channels | ||
69 | */ | ||
70 | |||
71 | struct s3c24xx_dma_order { | ||
72 | struct s3c24xx_dma_order_ch channels[DMACH_MAX]; | ||
73 | }; | ||
74 | |||
75 | extern int s3c24xx_dma_order_set(struct s3c24xx_dma_order *map); | ||
76 | |||
77 | /* DMA init code, called from the cpu support code */ | ||
78 | |||
79 | extern int s3c2410_dma_init(void); | ||
80 | |||
81 | extern int s3c24xx_dma_init(unsigned int channels, unsigned int irq, | ||
82 | unsigned int stride); | ||
diff --git a/include/asm-arm/plat-s3c24xx/irq.h b/include/asm-arm/plat-s3c24xx/irq.h deleted file mode 100644 index 45746a995343..000000000000 --- a/include/asm-arm/plat-s3c24xx/irq.h +++ /dev/null | |||
@@ -1,109 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/irq.h | ||
2 | * | ||
3 | * Copyright (c) 2004-2005 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for S3C24XX CPU IRQ support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #define irqdbf(x...) | ||
14 | #define irqdbf2(x...) | ||
15 | |||
16 | #define EXTINT_OFF (IRQ_EINT4 - 4) | ||
17 | |||
18 | /* these are exported for arch/arm/mach-* usage */ | ||
19 | extern struct irq_chip s3c_irq_level_chip; | ||
20 | extern struct irq_chip s3c_irq_chip; | ||
21 | |||
22 | static inline void | ||
23 | s3c_irqsub_mask(unsigned int irqno, unsigned int parentbit, | ||
24 | int subcheck) | ||
25 | { | ||
26 | unsigned long mask; | ||
27 | unsigned long submask; | ||
28 | |||
29 | submask = __raw_readl(S3C2410_INTSUBMSK); | ||
30 | mask = __raw_readl(S3C2410_INTMSK); | ||
31 | |||
32 | submask |= (1UL << (irqno - IRQ_S3CUART_RX0)); | ||
33 | |||
34 | /* check to see if we need to mask the parent IRQ */ | ||
35 | |||
36 | if ((submask & subcheck) == subcheck) { | ||
37 | __raw_writel(mask | parentbit, S3C2410_INTMSK); | ||
38 | } | ||
39 | |||
40 | /* write back masks */ | ||
41 | __raw_writel(submask, S3C2410_INTSUBMSK); | ||
42 | |||
43 | } | ||
44 | |||
45 | static inline void | ||
46 | s3c_irqsub_unmask(unsigned int irqno, unsigned int parentbit) | ||
47 | { | ||
48 | unsigned long mask; | ||
49 | unsigned long submask; | ||
50 | |||
51 | submask = __raw_readl(S3C2410_INTSUBMSK); | ||
52 | mask = __raw_readl(S3C2410_INTMSK); | ||
53 | |||
54 | submask &= ~(1UL << (irqno - IRQ_S3CUART_RX0)); | ||
55 | mask &= ~parentbit; | ||
56 | |||
57 | /* write back masks */ | ||
58 | __raw_writel(submask, S3C2410_INTSUBMSK); | ||
59 | __raw_writel(mask, S3C2410_INTMSK); | ||
60 | } | ||
61 | |||
62 | |||
63 | static inline void | ||
64 | s3c_irqsub_maskack(unsigned int irqno, unsigned int parentmask, unsigned int group) | ||
65 | { | ||
66 | unsigned int bit = 1UL << (irqno - IRQ_S3CUART_RX0); | ||
67 | |||
68 | s3c_irqsub_mask(irqno, parentmask, group); | ||
69 | |||
70 | __raw_writel(bit, S3C2410_SUBSRCPND); | ||
71 | |||
72 | /* only ack parent if we've got all the irqs (seems we must | ||
73 | * ack, all and hope that the irq system retriggers ok when | ||
74 | * the interrupt goes off again) | ||
75 | */ | ||
76 | |||
77 | if (1) { | ||
78 | __raw_writel(parentmask, S3C2410_SRCPND); | ||
79 | __raw_writel(parentmask, S3C2410_INTPND); | ||
80 | } | ||
81 | } | ||
82 | |||
83 | static inline void | ||
84 | s3c_irqsub_ack(unsigned int irqno, unsigned int parentmask, unsigned int group) | ||
85 | { | ||
86 | unsigned int bit = 1UL << (irqno - IRQ_S3CUART_RX0); | ||
87 | |||
88 | __raw_writel(bit, S3C2410_SUBSRCPND); | ||
89 | |||
90 | /* only ack parent if we've got all the irqs (seems we must | ||
91 | * ack, all and hope that the irq system retriggers ok when | ||
92 | * the interrupt goes off again) | ||
93 | */ | ||
94 | |||
95 | if (1) { | ||
96 | __raw_writel(parentmask, S3C2410_SRCPND); | ||
97 | __raw_writel(parentmask, S3C2410_INTPND); | ||
98 | } | ||
99 | } | ||
100 | |||
101 | /* exported for use in arch/arm/mach-s3c2410 */ | ||
102 | |||
103 | #ifdef CONFIG_PM | ||
104 | extern int s3c_irq_wake(unsigned int irqno, unsigned int state); | ||
105 | #else | ||
106 | #define s3c_irq_wake NULL | ||
107 | #endif | ||
108 | |||
109 | extern int s3c_irqext_type(unsigned int irq, unsigned int type); | ||
diff --git a/include/asm-arm/plat-s3c24xx/pm.h b/include/asm-arm/plat-s3c24xx/pm.h deleted file mode 100644 index cc623667e48a..000000000000 --- a/include/asm-arm/plat-s3c24xx/pm.h +++ /dev/null | |||
@@ -1,73 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/pm.h | ||
2 | * | ||
3 | * Copyright (c) 2004 Simtec Electronics | ||
4 | * Written by Ben Dooks, <ben@simtec.co.uk> | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License version 2 as | ||
8 | * published by the Free Software Foundation. | ||
9 | */ | ||
10 | |||
11 | /* s3c2410_pm_init | ||
12 | * | ||
13 | * called from board at initialisation time to setup the power | ||
14 | * management | ||
15 | */ | ||
16 | |||
17 | #ifdef CONFIG_PM | ||
18 | |||
19 | extern __init int s3c2410_pm_init(void); | ||
20 | |||
21 | #else | ||
22 | |||
23 | static inline int s3c2410_pm_init(void) | ||
24 | { | ||
25 | return 0; | ||
26 | } | ||
27 | #endif | ||
28 | |||
29 | /* configuration for the IRQ mask over sleep */ | ||
30 | extern unsigned long s3c_irqwake_intmask; | ||
31 | extern unsigned long s3c_irqwake_eintmask; | ||
32 | |||
33 | /* IRQ masks for IRQs allowed to go to sleep (see irq.c) */ | ||
34 | extern unsigned long s3c_irqwake_intallow; | ||
35 | extern unsigned long s3c_irqwake_eintallow; | ||
36 | |||
37 | /* per-cpu sleep functions */ | ||
38 | |||
39 | extern void (*pm_cpu_prep)(void); | ||
40 | extern void (*pm_cpu_sleep)(void); | ||
41 | |||
42 | /* Flags for PM Control */ | ||
43 | |||
44 | extern unsigned long s3c_pm_flags; | ||
45 | |||
46 | /* from sleep.S */ | ||
47 | |||
48 | extern int s3c2410_cpu_save(unsigned long *saveblk); | ||
49 | extern void s3c2410_cpu_suspend(void); | ||
50 | extern void s3c2410_cpu_resume(void); | ||
51 | |||
52 | extern unsigned long s3c2410_sleep_save_phys; | ||
53 | |||
54 | /* sleep save info */ | ||
55 | |||
56 | struct sleep_save { | ||
57 | void __iomem *reg; | ||
58 | unsigned long val; | ||
59 | }; | ||
60 | |||
61 | #define SAVE_ITEM(x) \ | ||
62 | { .reg = (x) } | ||
63 | |||
64 | extern void s3c2410_pm_do_save(struct sleep_save *ptr, int count); | ||
65 | extern void s3c2410_pm_do_restore(struct sleep_save *ptr, int count); | ||
66 | |||
67 | #ifdef CONFIG_PM | ||
68 | extern int s3c24xx_irq_suspend(struct sys_device *dev, pm_message_t state); | ||
69 | extern int s3c24xx_irq_resume(struct sys_device *dev); | ||
70 | #else | ||
71 | #define s3c24xx_irq_suspend NULL | ||
72 | #define s3c24xx_irq_resume NULL | ||
73 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2400.h b/include/asm-arm/plat-s3c24xx/s3c2400.h deleted file mode 100644 index 3a5a16821af8..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2400.h +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2400.h | ||
2 | * | ||
3 | * Copyright (c) 2004 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for S3C2400 cpu support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | * | ||
12 | * Modifications: | ||
13 | * 09-Fev-2006 LCVR First version, based on s3c2410.h | ||
14 | */ | ||
15 | |||
16 | #ifdef CONFIG_CPU_S3C2400 | ||
17 | |||
18 | extern int s3c2400_init(void); | ||
19 | |||
20 | extern void s3c2400_map_io(struct map_desc *mach_desc, int size); | ||
21 | |||
22 | extern void s3c2400_init_uarts(struct s3c2410_uartcfg *cfg, int no); | ||
23 | |||
24 | extern void s3c2400_init_clocks(int xtal); | ||
25 | |||
26 | #else | ||
27 | #define s3c2400_init_clocks NULL | ||
28 | #define s3c2400_init_uarts NULL | ||
29 | #define s3c2400_map_io NULL | ||
30 | #define s3c2400_init NULL | ||
31 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2410.h b/include/asm-arm/plat-s3c24xx/s3c2410.h deleted file mode 100644 index 3cd1ec677b3f..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2410.h +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2410.h | ||
2 | * | ||
3 | * Copyright (c) 2004 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2410 machine directory | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #ifdef CONFIG_CPU_S3C2410 | ||
15 | |||
16 | extern int s3c2410_init(void); | ||
17 | |||
18 | extern void s3c2410_map_io(struct map_desc *mach_desc, int size); | ||
19 | |||
20 | extern void s3c2410_init_uarts(struct s3c2410_uartcfg *cfg, int no); | ||
21 | |||
22 | extern void s3c2410_init_clocks(int xtal); | ||
23 | |||
24 | #else | ||
25 | #define s3c2410_init_clocks NULL | ||
26 | #define s3c2410_init_uarts NULL | ||
27 | #define s3c2410_map_io NULL | ||
28 | #define s3c2410_init NULL | ||
29 | #endif | ||
30 | |||
31 | extern int s3c2410_baseclk_add(void); | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2412.h b/include/asm-arm/plat-s3c24xx/s3c2412.h deleted file mode 100644 index 3ec97685e781..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2412.h +++ /dev/null | |||
@@ -1,29 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2412.h | ||
2 | * | ||
3 | * Copyright (c) 2006 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2412 cpu support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #ifdef CONFIG_CPU_S3C2412 | ||
14 | |||
15 | extern int s3c2412_init(void); | ||
16 | |||
17 | extern void s3c2412_map_io(struct map_desc *mach_desc, int size); | ||
18 | |||
19 | extern void s3c2412_init_uarts(struct s3c2410_uartcfg *cfg, int no); | ||
20 | |||
21 | extern void s3c2412_init_clocks(int xtal); | ||
22 | |||
23 | extern int s3c2412_baseclk_add(void); | ||
24 | #else | ||
25 | #define s3c2412_init_clocks NULL | ||
26 | #define s3c2412_init_uarts NULL | ||
27 | #define s3c2412_map_io NULL | ||
28 | #define s3c2412_init NULL | ||
29 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2440.h b/include/asm-arm/plat-s3c24xx/s3c2440.h deleted file mode 100644 index 107853bf9481..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2440.h +++ /dev/null | |||
@@ -1,17 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2440.h | ||
2 | * | ||
3 | * Copyright (c) 2004-2005 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2440 cpu support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #ifdef CONFIG_CPU_S3C2440 | ||
14 | extern int s3c2440_init(void); | ||
15 | #else | ||
16 | #define s3c2440_init NULL | ||
17 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2442.h b/include/asm-arm/plat-s3c24xx/s3c2442.h deleted file mode 100644 index 451a23a2092a..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2442.h +++ /dev/null | |||
@@ -1,17 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2442.h | ||
2 | * | ||
3 | * Copyright (c) 2006 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2442 cpu support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #ifdef CONFIG_CPU_S3C2442 | ||
14 | extern int s3c2442_init(void); | ||
15 | #else | ||
16 | #define s3c2442_init NULL | ||
17 | #endif | ||
diff --git a/include/asm-arm/plat-s3c24xx/s3c2443.h b/include/asm-arm/plat-s3c24xx/s3c2443.h deleted file mode 100644 index 11d83b5c84e6..000000000000 --- a/include/asm-arm/plat-s3c24xx/s3c2443.h +++ /dev/null | |||
@@ -1,32 +0,0 @@ | |||
1 | /* linux/include/asm-arm/plat-s3c24xx/s3c2443.h | ||
2 | * | ||
3 | * Copyright (c) 2004-2005 Simtec Electronics | ||
4 | * Ben Dooks <ben@simtec.co.uk> | ||
5 | * | ||
6 | * Header file for s3c2443 cpu support | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #ifdef CONFIG_CPU_S3C2443 | ||
14 | |||
15 | struct s3c2410_uartcfg; | ||
16 | |||
17 | extern int s3c2443_init(void); | ||
18 | |||
19 | extern void s3c2443_map_io(struct map_desc *mach_desc, int size); | ||
20 | |||
21 | extern void s3c2443_init_uarts(struct s3c2410_uartcfg *cfg, int no); | ||
22 | |||
23 | extern void s3c2443_init_clocks(int xtal); | ||
24 | |||
25 | extern int s3c2443_baseclk_add(void); | ||
26 | |||
27 | #else | ||
28 | #define s3c2443_init_clocks NULL | ||
29 | #define s3c2443_init_uarts NULL | ||
30 | #define s3c2443_map_io NULL | ||
31 | #define s3c2443_init NULL | ||
32 | #endif | ||
diff --git a/include/asm-cris/elf.h b/include/asm-cris/elf.h index 001f64ad11e8..f0d17fbc81ba 100644 --- a/include/asm-cris/elf.h +++ b/include/asm-cris/elf.h | |||
@@ -88,6 +88,6 @@ typedef unsigned long elf_fpregset_t; | |||
88 | 88 | ||
89 | #define ELF_PLATFORM (NULL) | 89 | #define ELF_PLATFORM (NULL) |
90 | 90 | ||
91 | #define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX) | 91 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX) |
92 | 92 | ||
93 | #endif | 93 | #endif |
diff --git a/include/asm-cris/thread_info.h b/include/asm-cris/thread_info.h index 7efe1000f99d..cee97f14af3b 100644 --- a/include/asm-cris/thread_info.h +++ b/include/asm-cris/thread_info.h | |||
@@ -88,6 +88,7 @@ struct thread_info { | |||
88 | #define TIF_RESTORE_SIGMASK 9 /* restore signal mask in do_signal() */ | 88 | #define TIF_RESTORE_SIGMASK 9 /* restore signal mask in do_signal() */ |
89 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ | 89 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ |
90 | #define TIF_MEMDIE 17 | 90 | #define TIF_MEMDIE 17 |
91 | #define TIF_FREEZE 18 /* is freezing for suspend */ | ||
91 | 92 | ||
92 | #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) | 93 | #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) |
93 | #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) | 94 | #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) |
@@ -95,6 +96,7 @@ struct thread_info { | |||
95 | #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) | 96 | #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) |
96 | #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) | 97 | #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) |
97 | #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) | 98 | #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) |
99 | #define _TIF_FREEZE (1<<TIF_FREEZE) | ||
98 | 100 | ||
99 | #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ | 101 | #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ |
100 | #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ | 102 | #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ |
diff --git a/include/asm-frv/elf.h b/include/asm-frv/elf.h index 9fb946bb7dc9..7279ec07d62e 100644 --- a/include/asm-frv/elf.h +++ b/include/asm-frv/elf.h | |||
@@ -137,6 +137,6 @@ do { \ | |||
137 | 137 | ||
138 | #define ELF_PLATFORM (NULL) | 138 | #define ELF_PLATFORM (NULL) |
139 | 139 | ||
140 | #define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX) | 140 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX) |
141 | 141 | ||
142 | #endif | 142 | #endif |
diff --git a/include/asm-frv/ide.h b/include/asm-frv/ide.h index 7ebcc56a2229..361076611855 100644 --- a/include/asm-frv/ide.h +++ b/include/asm-frv/ide.h | |||
@@ -18,15 +18,7 @@ | |||
18 | #include <asm/io.h> | 18 | #include <asm/io.h> |
19 | #include <asm/irq.h> | 19 | #include <asm/irq.h> |
20 | 20 | ||
21 | /****************************************************************************/ | 21 | #include <asm-generic/ide_iops.h> |
22 | /* | ||
23 | * some bits needed for parts of the IDE subsystem to compile | ||
24 | */ | ||
25 | #define __ide_mm_insw(port, addr, n) insw((unsigned long) (port), addr, n) | ||
26 | #define __ide_mm_insl(port, addr, n) insl((unsigned long) (port), addr, n) | ||
27 | #define __ide_mm_outsw(port, addr, n) outsw((unsigned long) (port), addr, n) | ||
28 | #define __ide_mm_outsl(port, addr, n) outsl((unsigned long) (port), addr, n) | ||
29 | |||
30 | 22 | ||
31 | #endif /* __KERNEL__ */ | 23 | #endif /* __KERNEL__ */ |
32 | #endif /* _ASM_IDE_H */ | 24 | #endif /* _ASM_IDE_H */ |
diff --git a/include/asm-frv/unaligned.h b/include/asm-frv/unaligned.h index 839a2fbffa0f..6c61c05b2e0c 100644 --- a/include/asm-frv/unaligned.h +++ b/include/asm-frv/unaligned.h | |||
@@ -13,7 +13,7 @@ | |||
13 | #define _ASM_UNALIGNED_H | 13 | #define _ASM_UNALIGNED_H |
14 | 14 | ||
15 | #include <linux/unaligned/le_byteshift.h> | 15 | #include <linux/unaligned/le_byteshift.h> |
16 | #include <linux/unaligned/be_byteshift.h> | 16 | #include <linux/unaligned/be_struct.h> |
17 | #include <linux/unaligned/generic.h> | 17 | #include <linux/unaligned/generic.h> |
18 | 18 | ||
19 | #define get_unaligned __get_unaligned_be | 19 | #define get_unaligned __get_unaligned_be |
diff --git a/include/asm-generic/bug.h b/include/asm-generic/bug.h index edc6ba82e090..0f6dabd4b517 100644 --- a/include/asm-generic/bug.h +++ b/include/asm-generic/bug.h | |||
@@ -22,7 +22,7 @@ struct bug_entry { | |||
22 | 22 | ||
23 | #ifndef HAVE_ARCH_BUG | 23 | #ifndef HAVE_ARCH_BUG |
24 | #define BUG() do { \ | 24 | #define BUG() do { \ |
25 | printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \ | 25 | printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \ |
26 | panic("BUG!"); \ | 26 | panic("BUG!"); \ |
27 | } while (0) | 27 | } while (0) |
28 | #endif | 28 | #endif |
diff --git a/include/asm-generic/gpio.h b/include/asm-generic/gpio.h index 0f99ad38b012..81797ec9ab29 100644 --- a/include/asm-generic/gpio.h +++ b/include/asm-generic/gpio.h | |||
@@ -35,11 +35,17 @@ struct module; | |||
35 | * @label: for diagnostics | 35 | * @label: for diagnostics |
36 | * @dev: optional device providing the GPIOs | 36 | * @dev: optional device providing the GPIOs |
37 | * @owner: helps prevent removal of modules exporting active GPIOs | 37 | * @owner: helps prevent removal of modules exporting active GPIOs |
38 | * @request: optional hook for chip-specific activation, such as | ||
39 | * enabling module power and clock; may sleep | ||
40 | * @free: optional hook for chip-specific deactivation, such as | ||
41 | * disabling module power and clock; may sleep | ||
38 | * @direction_input: configures signal "offset" as input, or returns error | 42 | * @direction_input: configures signal "offset" as input, or returns error |
39 | * @get: returns value for signal "offset"; for output signals this | 43 | * @get: returns value for signal "offset"; for output signals this |
40 | * returns either the value actually sensed, or zero | 44 | * returns either the value actually sensed, or zero |
41 | * @direction_output: configures signal "offset" as output, or returns error | 45 | * @direction_output: configures signal "offset" as output, or returns error |
42 | * @set: assigns output value for signal "offset" | 46 | * @set: assigns output value for signal "offset" |
47 | * @to_irq: optional hook supporting non-static gpio_to_irq() mappings; | ||
48 | * implementation may not sleep | ||
43 | * @dbg_show: optional routine to show contents in debugfs; default code | 49 | * @dbg_show: optional routine to show contents in debugfs; default code |
44 | * will be used when this is omitted, but custom code can show extra | 50 | * will be used when this is omitted, but custom code can show extra |
45 | * state (such as pullup/pulldown configuration). | 51 | * state (such as pullup/pulldown configuration). |
@@ -61,10 +67,15 @@ struct module; | |||
61 | * is calculated by subtracting @base from the gpio number. | 67 | * is calculated by subtracting @base from the gpio number. |
62 | */ | 68 | */ |
63 | struct gpio_chip { | 69 | struct gpio_chip { |
64 | char *label; | 70 | const char *label; |
65 | struct device *dev; | 71 | struct device *dev; |
66 | struct module *owner; | 72 | struct module *owner; |
67 | 73 | ||
74 | int (*request)(struct gpio_chip *chip, | ||
75 | unsigned offset); | ||
76 | void (*free)(struct gpio_chip *chip, | ||
77 | unsigned offset); | ||
78 | |||
68 | int (*direction_input)(struct gpio_chip *chip, | 79 | int (*direction_input)(struct gpio_chip *chip, |
69 | unsigned offset); | 80 | unsigned offset); |
70 | int (*get)(struct gpio_chip *chip, | 81 | int (*get)(struct gpio_chip *chip, |
@@ -73,6 +84,10 @@ struct gpio_chip { | |||
73 | unsigned offset, int value); | 84 | unsigned offset, int value); |
74 | void (*set)(struct gpio_chip *chip, | 85 | void (*set)(struct gpio_chip *chip, |
75 | unsigned offset, int value); | 86 | unsigned offset, int value); |
87 | |||
88 | int (*to_irq)(struct gpio_chip *chip, | ||
89 | unsigned offset); | ||
90 | |||
76 | void (*dbg_show)(struct seq_file *s, | 91 | void (*dbg_show)(struct seq_file *s, |
77 | struct gpio_chip *chip); | 92 | struct gpio_chip *chip); |
78 | int base; | 93 | int base; |
@@ -112,6 +127,7 @@ extern void __gpio_set_value(unsigned gpio, int value); | |||
112 | 127 | ||
113 | extern int __gpio_cansleep(unsigned gpio); | 128 | extern int __gpio_cansleep(unsigned gpio); |
114 | 129 | ||
130 | extern int __gpio_to_irq(unsigned gpio); | ||
115 | 131 | ||
116 | #ifdef CONFIG_GPIO_SYSFS | 132 | #ifdef CONFIG_GPIO_SYSFS |
117 | 133 | ||
diff --git a/include/asm-generic/rtc.h b/include/asm-generic/rtc.h index 71ef3f0b9685..89061c1a67d4 100644 --- a/include/asm-generic/rtc.h +++ b/include/asm-generic/rtc.h | |||
@@ -84,12 +84,12 @@ static inline unsigned int get_rtc_time(struct rtc_time *time) | |||
84 | 84 | ||
85 | if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) | 85 | if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) |
86 | { | 86 | { |
87 | BCD_TO_BIN(time->tm_sec); | 87 | time->tm_sec = bcd2bin(time->tm_sec); |
88 | BCD_TO_BIN(time->tm_min); | 88 | time->tm_min = bcd2bin(time->tm_min); |
89 | BCD_TO_BIN(time->tm_hour); | 89 | time->tm_hour = bcd2bin(time->tm_hour); |
90 | BCD_TO_BIN(time->tm_mday); | 90 | time->tm_mday = bcd2bin(time->tm_mday); |
91 | BCD_TO_BIN(time->tm_mon); | 91 | time->tm_mon = bcd2bin(time->tm_mon); |
92 | BCD_TO_BIN(time->tm_year); | 92 | time->tm_year = bcd2bin(time->tm_year); |
93 | } | 93 | } |
94 | 94 | ||
95 | #ifdef CONFIG_MACH_DECSTATION | 95 | #ifdef CONFIG_MACH_DECSTATION |
@@ -159,12 +159,12 @@ static inline int set_rtc_time(struct rtc_time *time) | |||
159 | 159 | ||
160 | if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) | 160 | if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) |
161 | || RTC_ALWAYS_BCD) { | 161 | || RTC_ALWAYS_BCD) { |
162 | BIN_TO_BCD(sec); | 162 | sec = bin2bcd(sec); |
163 | BIN_TO_BCD(min); | 163 | min = bin2bcd(min); |
164 | BIN_TO_BCD(hrs); | 164 | hrs = bin2bcd(hrs); |
165 | BIN_TO_BCD(day); | 165 | day = bin2bcd(day); |
166 | BIN_TO_BCD(mon); | 166 | mon = bin2bcd(mon); |
167 | BIN_TO_BCD(yrs); | 167 | yrs = bin2bcd(yrs); |
168 | } | 168 | } |
169 | 169 | ||
170 | save_control = CMOS_READ(RTC_CONTROL); | 170 | save_control = CMOS_READ(RTC_CONTROL); |
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 7440a0dceddb..74c5faf26c05 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h | |||
@@ -268,7 +268,15 @@ | |||
268 | CPU_DISCARD(init.data) \ | 268 | CPU_DISCARD(init.data) \ |
269 | CPU_DISCARD(init.rodata) \ | 269 | CPU_DISCARD(init.rodata) \ |
270 | MEM_DISCARD(init.data) \ | 270 | MEM_DISCARD(init.data) \ |
271 | MEM_DISCARD(init.rodata) | 271 | MEM_DISCARD(init.rodata) \ |
272 | /* implement dynamic printk debug */ \ | ||
273 | VMLINUX_SYMBOL(__start___verbose_strings) = .; \ | ||
274 | *(__verbose_strings) \ | ||
275 | VMLINUX_SYMBOL(__stop___verbose_strings) = .; \ | ||
276 | . = ALIGN(8); \ | ||
277 | VMLINUX_SYMBOL(__start___verbose) = .; \ | ||
278 | *(__verbose) \ | ||
279 | VMLINUX_SYMBOL(__stop___verbose) = .; | ||
272 | 280 | ||
273 | #define INIT_TEXT \ | 281 | #define INIT_TEXT \ |
274 | *(.init.text) \ | 282 | *(.init.text) \ |
diff --git a/include/asm-h8300/timer.h b/include/asm-h8300/timer.h new file mode 100644 index 000000000000..def80464d38f --- /dev/null +++ b/include/asm-h8300/timer.h | |||
@@ -0,0 +1,25 @@ | |||
1 | #ifndef __H8300_TIMER_H | ||
2 | #define __H8300_TIMER_H | ||
3 | |||
4 | void h8300_timer_tick(void); | ||
5 | void h8300_timer_setup(void); | ||
6 | void h8300_gettod(unsigned int *year, unsigned int *mon, unsigned int *day, | ||
7 | unsigned int *hour, unsigned int *min, unsigned int *sec); | ||
8 | |||
9 | #define TIMER_FREQ (CONFIG_CPU_CLOCK*10000) /* Timer input freq. */ | ||
10 | |||
11 | #define calc_param(cnt, div, rate, limit) \ | ||
12 | do { \ | ||
13 | cnt = TIMER_FREQ / HZ; \ | ||
14 | for (div = 0; div < ARRAY_SIZE(divide_rate); div++) { \ | ||
15 | if (rate[div] == 0) \ | ||
16 | continue; \ | ||
17 | if ((cnt / rate[div]) > limit) \ | ||
18 | break; \ | ||
19 | } \ | ||
20 | if (div == ARRAY_SIZE(divide_rate)) \ | ||
21 | panic("Timer counter overflow"); \ | ||
22 | cnt /= divide_rate[div]; \ | ||
23 | } while(0) | ||
24 | |||
25 | #endif | ||
diff --git a/include/asm-m32r/elf.h b/include/asm-m32r/elf.h index 67bcd77494a5..0cc34c94bf2b 100644 --- a/include/asm-m32r/elf.h +++ b/include/asm-m32r/elf.h | |||
@@ -129,6 +129,6 @@ typedef elf_fpreg_t elf_fpregset_t; | |||
129 | intent than poking at uname or /proc/cpuinfo. */ | 129 | intent than poking at uname or /proc/cpuinfo. */ |
130 | #define ELF_PLATFORM (NULL) | 130 | #define ELF_PLATFORM (NULL) |
131 | 131 | ||
132 | #define SET_PERSONALITY(ex, ibcs2) set_personality(PER_LINUX) | 132 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX) |
133 | 133 | ||
134 | #endif /* _ASM_M32R__ELF_H */ | 134 | #endif /* _ASM_M32R__ELF_H */ |
diff --git a/include/asm-m68k/elf.h b/include/asm-m68k/elf.h index 14ea42152b97..0b0f49eb876b 100644 --- a/include/asm-m68k/elf.h +++ b/include/asm-m68k/elf.h | |||
@@ -114,6 +114,6 @@ typedef struct user_m68kfp_struct elf_fpregset_t; | |||
114 | 114 | ||
115 | #define ELF_PLATFORM (NULL) | 115 | #define ELF_PLATFORM (NULL) |
116 | 116 | ||
117 | #define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX) | 117 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX) |
118 | 118 | ||
119 | #endif | 119 | #endif |
diff --git a/include/asm-m68k/ide.h b/include/asm-m68k/ide.h index 1daf6cbdd9f0..b996a3c8cff5 100644 --- a/include/asm-m68k/ide.h +++ b/include/asm-m68k/ide.h | |||
@@ -92,15 +92,6 @@ | |||
92 | #define outsw_swapw(port, addr, n) raw_outsw_swapw((u16 *)port, addr, n) | 92 | #define outsw_swapw(port, addr, n) raw_outsw_swapw((u16 *)port, addr, n) |
93 | #endif | 93 | #endif |
94 | 94 | ||
95 | |||
96 | /* Q40 and Atari have byteswapped IDE busses and since many interesting | ||
97 | * values in the identification string are text, chars and words they | ||
98 | * happened to be almost correct without swapping.. However *_capacity | ||
99 | * is needed for drives over 8 GB. RZ */ | ||
100 | #if defined(CONFIG_Q40) || defined(CONFIG_ATARI) | ||
101 | #define M68K_IDE_SWAPW (MACH_IS_Q40 || MACH_IS_ATARI) | ||
102 | #endif | ||
103 | |||
104 | #ifdef CONFIG_BLK_DEV_FALCON_IDE | 95 | #ifdef CONFIG_BLK_DEV_FALCON_IDE |
105 | #define IDE_ARCH_LOCK | 96 | #define IDE_ARCH_LOCK |
106 | 97 | ||
diff --git a/include/asm-m68k/thread_info.h b/include/asm-m68k/thread_info.h index abc002798a2b..af0fda46e94b 100644 --- a/include/asm-m68k/thread_info.h +++ b/include/asm-m68k/thread_info.h | |||
@@ -52,5 +52,6 @@ struct thread_info { | |||
52 | #define TIF_DELAYED_TRACE 14 /* single step a syscall */ | 52 | #define TIF_DELAYED_TRACE 14 /* single step a syscall */ |
53 | #define TIF_SYSCALL_TRACE 15 /* syscall trace active */ | 53 | #define TIF_SYSCALL_TRACE 15 /* syscall trace active */ |
54 | #define TIF_MEMDIE 16 | 54 | #define TIF_MEMDIE 16 |
55 | #define TIF_FREEZE 17 /* thread is freezing for suspend */ | ||
55 | 56 | ||
56 | #endif /* _ASM_M68K_THREAD_INFO_H */ | 57 | #endif /* _ASM_M68K_THREAD_INFO_H */ |
diff --git a/include/asm-mips/cevt-r4k.h b/include/asm-mips/cevt-r4k.h deleted file mode 100644 index fa4328f9124f..000000000000 --- a/include/asm-mips/cevt-r4k.h +++ /dev/null | |||
@@ -1,46 +0,0 @@ | |||
1 | /* | ||
2 | * This file is subject to the terms and conditions of the GNU General Public | ||
3 | * License. See the file "COPYING" in the main directory of this archive | ||
4 | * for more details. | ||
5 | * | ||
6 | * Copyright (C) 2008 Kevin D. Kissell | ||
7 | */ | ||
8 | |||
9 | /* | ||
10 | * Definitions used for common event timer implementation | ||
11 | * for MIPS 4K-type processors and their MIPS MT variants. | ||
12 | * Avoids unsightly extern declarations in C files. | ||
13 | */ | ||
14 | #ifndef __ASM_CEVT_R4K_H | ||
15 | #define __ASM_CEVT_R4K_H | ||
16 | |||
17 | DECLARE_PER_CPU(struct clock_event_device, mips_clockevent_device); | ||
18 | |||
19 | void mips_event_handler(struct clock_event_device *dev); | ||
20 | int c0_compare_int_usable(void); | ||
21 | void mips_set_clock_mode(enum clock_event_mode, struct clock_event_device *); | ||
22 | irqreturn_t c0_compare_interrupt(int, void *); | ||
23 | |||
24 | extern struct irqaction c0_compare_irqaction; | ||
25 | extern int cp0_timer_irq_installed; | ||
26 | |||
27 | /* | ||
28 | * Possibly handle a performance counter interrupt. | ||
29 | * Return true if the timer interrupt should not be checked | ||
30 | */ | ||
31 | |||
32 | static inline int handle_perf_irq(int r2) | ||
33 | { | ||
34 | /* | ||
35 | * The performance counter overflow interrupt may be shared with the | ||
36 | * timer interrupt (cp0_perfcount_irq < 0). If it is and a | ||
37 | * performance counter has overflowed (perf_irq() == IRQ_HANDLED) | ||
38 | * and we can't reliably determine if a counter interrupt has also | ||
39 | * happened (!r2) then don't check for a timer interrupt. | ||
40 | */ | ||
41 | return (cp0_perfcount_irq < 0) && | ||
42 | perf_irq() == IRQ_HANDLED && | ||
43 | !r2; | ||
44 | } | ||
45 | |||
46 | #endif /* __ASM_CEVT_R4K_H */ | ||
diff --git a/include/asm-mn10300/elf.h b/include/asm-mn10300/elf.h index 256a70466ca4..bf09f8bb392e 100644 --- a/include/asm-mn10300/elf.h +++ b/include/asm-mn10300/elf.h | |||
@@ -141,7 +141,7 @@ do { \ | |||
141 | #define ELF_PLATFORM (NULL) | 141 | #define ELF_PLATFORM (NULL) |
142 | 142 | ||
143 | #ifdef __KERNEL__ | 143 | #ifdef __KERNEL__ |
144 | #define SET_PERSONALITY(ex, ibcs2) set_personality(PER_LINUX) | 144 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX) |
145 | #endif | 145 | #endif |
146 | 146 | ||
147 | #endif /* _ASM_ELF_H */ | 147 | #endif /* _ASM_ELF_H */ |
diff --git a/include/asm-parisc/elf.h b/include/asm-parisc/elf.h index d0a4a8262818..7fa675799e6d 100644 --- a/include/asm-parisc/elf.h +++ b/include/asm-parisc/elf.h | |||
@@ -236,7 +236,7 @@ typedef unsigned long elf_greg_t; | |||
236 | 236 | ||
237 | #define ELF_PLATFORM ("PARISC\0") | 237 | #define ELF_PLATFORM ("PARISC\0") |
238 | 238 | ||
239 | #define SET_PERSONALITY(ex, ibcs2) \ | 239 | #define SET_PERSONALITY(ex) \ |
240 | current->personality = PER_LINUX; \ | 240 | current->personality = PER_LINUX; \ |
241 | current->thread.map_base = DEFAULT_MAP_BASE; \ | 241 | current->thread.map_base = DEFAULT_MAP_BASE; \ |
242 | current->thread.task_size = DEFAULT_TASK_SIZE \ | 242 | current->thread.task_size = DEFAULT_TASK_SIZE \ |
diff --git a/include/asm-parisc/ide.h b/include/asm-parisc/ide.h index c246ef75017d..81700a2321cf 100644 --- a/include/asm-parisc/ide.h +++ b/include/asm-parisc/ide.h | |||
@@ -13,10 +13,6 @@ | |||
13 | 13 | ||
14 | #ifdef __KERNEL__ | 14 | #ifdef __KERNEL__ |
15 | 15 | ||
16 | #define ide_request_irq(irq,hand,flg,dev,id) request_irq((irq),(hand),(flg),(dev),(id)) | ||
17 | #define ide_free_irq(irq,dev_id) free_irq((irq), (dev_id)) | ||
18 | #define ide_request_region(from,extent,name) request_region((from), (extent), (name)) | ||
19 | #define ide_release_region(from,extent) release_region((from), (extent)) | ||
20 | /* Generic I/O and MEMIO string operations. */ | 16 | /* Generic I/O and MEMIO string operations. */ |
21 | 17 | ||
22 | #define __ide_insw insw | 18 | #define __ide_insw insw |
diff --git a/include/asm-parisc/thread_info.h b/include/asm-parisc/thread_info.h index 9f812741c355..0407959da489 100644 --- a/include/asm-parisc/thread_info.h +++ b/include/asm-parisc/thread_info.h | |||
@@ -58,6 +58,7 @@ struct thread_info { | |||
58 | #define TIF_32BIT 4 /* 32 bit binary */ | 58 | #define TIF_32BIT 4 /* 32 bit binary */ |
59 | #define TIF_MEMDIE 5 | 59 | #define TIF_MEMDIE 5 |
60 | #define TIF_RESTORE_SIGMASK 6 /* restore saved signal mask */ | 60 | #define TIF_RESTORE_SIGMASK 6 /* restore saved signal mask */ |
61 | #define TIF_FREEZE 7 /* is freezing for suspend */ | ||
61 | 62 | ||
62 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) | 63 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) |
63 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) | 64 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) |
@@ -65,6 +66,7 @@ struct thread_info { | |||
65 | #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) | 66 | #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) |
66 | #define _TIF_32BIT (1 << TIF_32BIT) | 67 | #define _TIF_32BIT (1 << TIF_32BIT) |
67 | #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) | 68 | #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) |
69 | #define _TIF_FREEZE (1 << TIF_FREEZE) | ||
68 | 70 | ||
69 | #define _TIF_USER_WORK_MASK (_TIF_SIGPENDING | \ | 71 | #define _TIF_USER_WORK_MASK (_TIF_SIGPENDING | \ |
70 | _TIF_NEED_RESCHED | _TIF_RESTORE_SIGMASK) | 72 | _TIF_NEED_RESCHED | _TIF_RESTORE_SIGMASK) |
diff --git a/include/asm-um/elf-i386.h b/include/asm-um/elf-i386.h index 23d6893e8617..d0da9d7c5371 100644 --- a/include/asm-um/elf-i386.h +++ b/include/asm-um/elf-i386.h | |||
@@ -86,7 +86,7 @@ extern long elf_aux_hwcap; | |||
86 | extern char * elf_aux_platform; | 86 | extern char * elf_aux_platform; |
87 | #define ELF_PLATFORM (elf_aux_platform) | 87 | #define ELF_PLATFORM (elf_aux_platform) |
88 | 88 | ||
89 | #define SET_PERSONALITY(ex, ibcs2) do { } while (0) | 89 | #define SET_PERSONALITY(ex) do { } while (0) |
90 | 90 | ||
91 | extern unsigned long vsyscall_ehdr; | 91 | extern unsigned long vsyscall_ehdr; |
92 | extern unsigned long vsyscall_end; | 92 | extern unsigned long vsyscall_end; |
diff --git a/include/asm-um/elf-ppc.h b/include/asm-um/elf-ppc.h index d3b90b7ac3e9..af9463cd8ce5 100644 --- a/include/asm-um/elf-ppc.h +++ b/include/asm-um/elf-ppc.h | |||
@@ -5,7 +5,7 @@ | |||
5 | extern long elf_aux_hwcap; | 5 | extern long elf_aux_hwcap; |
6 | #define ELF_HWCAP (elf_aux_hwcap) | 6 | #define ELF_HWCAP (elf_aux_hwcap) |
7 | 7 | ||
8 | #define SET_PERSONALITY(ex, ibcs2) do ; while(0) | 8 | #define SET_PERSONALITY(ex) do ; while(0) |
9 | 9 | ||
10 | #define ELF_EXEC_PAGESIZE 4096 | 10 | #define ELF_EXEC_PAGESIZE 4096 |
11 | 11 | ||
diff --git a/include/asm-um/elf-x86_64.h b/include/asm-um/elf-x86_64.h index 3b2d5224a7e1..6e8a9195e952 100644 --- a/include/asm-um/elf-x86_64.h +++ b/include/asm-um/elf-x86_64.h | |||
@@ -114,6 +114,6 @@ extern long elf_aux_hwcap; | |||
114 | 114 | ||
115 | #define ELF_PLATFORM "x86_64" | 115 | #define ELF_PLATFORM "x86_64" |
116 | 116 | ||
117 | #define SET_PERSONALITY(ex, ibcs2) do ; while(0) | 117 | #define SET_PERSONALITY(ex) do ; while(0) |
118 | 118 | ||
119 | #endif | 119 | #endif |
diff --git a/include/asm-um/thread_info.h b/include/asm-um/thread_info.h index e07e72846c7a..62274ab9471f 100644 --- a/include/asm-um/thread_info.h +++ b/include/asm-um/thread_info.h | |||
@@ -69,6 +69,7 @@ static inline struct thread_info *current_thread_info(void) | |||
69 | #define TIF_MEMDIE 5 | 69 | #define TIF_MEMDIE 5 |
70 | #define TIF_SYSCALL_AUDIT 6 | 70 | #define TIF_SYSCALL_AUDIT 6 |
71 | #define TIF_RESTORE_SIGMASK 7 | 71 | #define TIF_RESTORE_SIGMASK 7 |
72 | #define TIF_FREEZE 16 /* is freezing for suspend */ | ||
72 | 73 | ||
73 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) | 74 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) |
74 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) | 75 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) |
@@ -77,5 +78,6 @@ static inline struct thread_info *current_thread_info(void) | |||
77 | #define _TIF_MEMDIE (1 << TIF_MEMDIE) | 78 | #define _TIF_MEMDIE (1 << TIF_MEMDIE) |
78 | #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) | 79 | #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) |
79 | #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) | 80 | #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) |
81 | #define _TIF_FREEZE (1 << TIF_FREEZE) | ||
80 | 82 | ||
81 | #endif | 83 | #endif |
diff --git a/include/asm-x86/elf.h b/include/asm-x86/elf.h index 5c4745bec906..26bc15f01e78 100644 --- a/include/asm-x86/elf.h +++ b/include/asm-x86/elf.h | |||
@@ -186,7 +186,7 @@ do { \ | |||
186 | set_fs(USER_DS); \ | 186 | set_fs(USER_DS); \ |
187 | } while (0) | 187 | } while (0) |
188 | 188 | ||
189 | #define COMPAT_SET_PERSONALITY(ex, ibcs2) \ | 189 | #define COMPAT_SET_PERSONALITY(ex) \ |
190 | do { \ | 190 | do { \ |
191 | if (test_thread_flag(TIF_IA32)) \ | 191 | if (test_thread_flag(TIF_IA32)) \ |
192 | clear_thread_flag(TIF_ABI_PENDING); \ | 192 | clear_thread_flag(TIF_ABI_PENDING); \ |
@@ -267,7 +267,7 @@ extern int force_personality32; | |||
267 | For the moment, we have only optimizations for the Intel generations, | 267 | For the moment, we have only optimizations for the Intel generations, |
268 | but that could change... */ | 268 | but that could change... */ |
269 | 269 | ||
270 | #define SET_PERSONALITY(ex, ibcs2) set_personality_64bit() | 270 | #define SET_PERSONALITY(ex) set_personality_64bit() |
271 | 271 | ||
272 | /* | 272 | /* |
273 | * An executable for which elf_read_implies_exec() returns TRUE will | 273 | * An executable for which elf_read_implies_exec() returns TRUE will |
diff --git a/include/asm-x86/es7000/apic.h b/include/asm-x86/es7000/apic.h index bd2c44d1f7ac..aae50c2fb303 100644 --- a/include/asm-x86/es7000/apic.h +++ b/include/asm-x86/es7000/apic.h | |||
@@ -171,7 +171,7 @@ static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask) | |||
171 | int new_apicid = cpu_to_logical_apicid(cpu); | 171 | int new_apicid = cpu_to_logical_apicid(cpu); |
172 | if (apicid_cluster(apicid) != | 172 | if (apicid_cluster(apicid) != |
173 | apicid_cluster(new_apicid)){ | 173 | apicid_cluster(new_apicid)){ |
174 | printk ("%s: Not a valid mask!\n",__FUNCTION__); | 174 | printk ("%s: Not a valid mask!\n", __func__); |
175 | #if defined CONFIG_ES7000_CLUSTERED_APIC | 175 | #if defined CONFIG_ES7000_CLUSTERED_APIC |
176 | return 0xFF; | 176 | return 0xFF; |
177 | #else | 177 | #else |
diff --git a/include/asm-x86/iommu.h b/include/asm-x86/iommu.h index 546ad3110fea..961e746da977 100644 --- a/include/asm-x86/iommu.h +++ b/include/asm-x86/iommu.h | |||
@@ -8,7 +8,7 @@ extern int force_iommu, no_iommu; | |||
8 | extern int iommu_detected; | 8 | extern int iommu_detected; |
9 | extern int dmar_disabled; | 9 | extern int dmar_disabled; |
10 | 10 | ||
11 | extern unsigned long iommu_num_pages(unsigned long addr, unsigned long len); | 11 | extern unsigned long iommu_nr_pages(unsigned long addr, unsigned long len); |
12 | 12 | ||
13 | #ifdef CONFIG_GART_IOMMU | 13 | #ifdef CONFIG_GART_IOMMU |
14 | extern int gart_iommu_aperture; | 14 | extern int gart_iommu_aperture; |
diff --git a/include/asm-x86/kvm.h b/include/asm-x86/kvm.h index 78e954db1e7f..ba0dd791fadf 100644 --- a/include/asm-x86/kvm.h +++ b/include/asm-x86/kvm.h | |||
@@ -208,26 +208,4 @@ struct kvm_pit_channel_state { | |||
208 | struct kvm_pit_state { | 208 | struct kvm_pit_state { |
209 | struct kvm_pit_channel_state channels[3]; | 209 | struct kvm_pit_channel_state channels[3]; |
210 | }; | 210 | }; |
211 | |||
212 | #define KVM_TRC_INJ_VIRQ (KVM_TRC_HANDLER + 0x02) | ||
213 | #define KVM_TRC_REDELIVER_EVT (KVM_TRC_HANDLER + 0x03) | ||
214 | #define KVM_TRC_PEND_INTR (KVM_TRC_HANDLER + 0x04) | ||
215 | #define KVM_TRC_IO_READ (KVM_TRC_HANDLER + 0x05) | ||
216 | #define KVM_TRC_IO_WRITE (KVM_TRC_HANDLER + 0x06) | ||
217 | #define KVM_TRC_CR_READ (KVM_TRC_HANDLER + 0x07) | ||
218 | #define KVM_TRC_CR_WRITE (KVM_TRC_HANDLER + 0x08) | ||
219 | #define KVM_TRC_DR_READ (KVM_TRC_HANDLER + 0x09) | ||
220 | #define KVM_TRC_DR_WRITE (KVM_TRC_HANDLER + 0x0A) | ||
221 | #define KVM_TRC_MSR_READ (KVM_TRC_HANDLER + 0x0B) | ||
222 | #define KVM_TRC_MSR_WRITE (KVM_TRC_HANDLER + 0x0C) | ||
223 | #define KVM_TRC_CPUID (KVM_TRC_HANDLER + 0x0D) | ||
224 | #define KVM_TRC_INTR (KVM_TRC_HANDLER + 0x0E) | ||
225 | #define KVM_TRC_NMI (KVM_TRC_HANDLER + 0x0F) | ||
226 | #define KVM_TRC_VMMCALL (KVM_TRC_HANDLER + 0x10) | ||
227 | #define KVM_TRC_HLT (KVM_TRC_HANDLER + 0x11) | ||
228 | #define KVM_TRC_CLTS (KVM_TRC_HANDLER + 0x12) | ||
229 | #define KVM_TRC_LMSW (KVM_TRC_HANDLER + 0x13) | ||
230 | #define KVM_TRC_APIC_ACCESS (KVM_TRC_HANDLER + 0x14) | ||
231 | #define KVM_TRC_TDP_FAULT (KVM_TRC_HANDLER + 0x15) | ||
232 | |||
233 | #endif /* ASM_X86__KVM_H */ | 211 | #endif /* ASM_X86__KVM_H */ |
diff --git a/include/asm-x86/kvm_host.h b/include/asm-x86/kvm_host.h index 69794547f514..411fb8cfb24e 100644 --- a/include/asm-x86/kvm_host.h +++ b/include/asm-x86/kvm_host.h | |||
@@ -57,6 +57,10 @@ | |||
57 | #define KVM_PAGES_PER_HPAGE (KVM_HPAGE_SIZE / PAGE_SIZE) | 57 | #define KVM_PAGES_PER_HPAGE (KVM_HPAGE_SIZE / PAGE_SIZE) |
58 | 58 | ||
59 | #define DE_VECTOR 0 | 59 | #define DE_VECTOR 0 |
60 | #define DB_VECTOR 1 | ||
61 | #define BP_VECTOR 3 | ||
62 | #define OF_VECTOR 4 | ||
63 | #define BR_VECTOR 5 | ||
60 | #define UD_VECTOR 6 | 64 | #define UD_VECTOR 6 |
61 | #define NM_VECTOR 7 | 65 | #define NM_VECTOR 7 |
62 | #define DF_VECTOR 8 | 66 | #define DF_VECTOR 8 |
@@ -65,6 +69,7 @@ | |||
65 | #define SS_VECTOR 12 | 69 | #define SS_VECTOR 12 |
66 | #define GP_VECTOR 13 | 70 | #define GP_VECTOR 13 |
67 | #define PF_VECTOR 14 | 71 | #define PF_VECTOR 14 |
72 | #define MF_VECTOR 16 | ||
68 | #define MC_VECTOR 18 | 73 | #define MC_VECTOR 18 |
69 | 74 | ||
70 | #define SELECTOR_TI_MASK (1 << 2) | 75 | #define SELECTOR_TI_MASK (1 << 2) |
@@ -89,7 +94,7 @@ extern struct list_head vm_list; | |||
89 | struct kvm_vcpu; | 94 | struct kvm_vcpu; |
90 | struct kvm; | 95 | struct kvm; |
91 | 96 | ||
92 | enum { | 97 | enum kvm_reg { |
93 | VCPU_REGS_RAX = 0, | 98 | VCPU_REGS_RAX = 0, |
94 | VCPU_REGS_RCX = 1, | 99 | VCPU_REGS_RCX = 1, |
95 | VCPU_REGS_RDX = 2, | 100 | VCPU_REGS_RDX = 2, |
@@ -108,6 +113,7 @@ enum { | |||
108 | VCPU_REGS_R14 = 14, | 113 | VCPU_REGS_R14 = 14, |
109 | VCPU_REGS_R15 = 15, | 114 | VCPU_REGS_R15 = 15, |
110 | #endif | 115 | #endif |
116 | VCPU_REGS_RIP, | ||
111 | NR_VCPU_REGS | 117 | NR_VCPU_REGS |
112 | }; | 118 | }; |
113 | 119 | ||
@@ -189,10 +195,20 @@ struct kvm_mmu_page { | |||
189 | */ | 195 | */ |
190 | int multimapped; /* More than one parent_pte? */ | 196 | int multimapped; /* More than one parent_pte? */ |
191 | int root_count; /* Currently serving as active root */ | 197 | int root_count; /* Currently serving as active root */ |
198 | bool unsync; | ||
199 | bool unsync_children; | ||
192 | union { | 200 | union { |
193 | u64 *parent_pte; /* !multimapped */ | 201 | u64 *parent_pte; /* !multimapped */ |
194 | struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */ | 202 | struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */ |
195 | }; | 203 | }; |
204 | DECLARE_BITMAP(unsync_child_bitmap, 512); | ||
205 | }; | ||
206 | |||
207 | struct kvm_pv_mmu_op_buffer { | ||
208 | void *ptr; | ||
209 | unsigned len; | ||
210 | unsigned processed; | ||
211 | char buf[512] __aligned(sizeof(long)); | ||
196 | }; | 212 | }; |
197 | 213 | ||
198 | /* | 214 | /* |
@@ -207,6 +223,9 @@ struct kvm_mmu { | |||
207 | gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva); | 223 | gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva); |
208 | void (*prefetch_page)(struct kvm_vcpu *vcpu, | 224 | void (*prefetch_page)(struct kvm_vcpu *vcpu, |
209 | struct kvm_mmu_page *page); | 225 | struct kvm_mmu_page *page); |
226 | int (*sync_page)(struct kvm_vcpu *vcpu, | ||
227 | struct kvm_mmu_page *sp); | ||
228 | void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva); | ||
210 | hpa_t root_hpa; | 229 | hpa_t root_hpa; |
211 | int root_level; | 230 | int root_level; |
212 | int shadow_root_level; | 231 | int shadow_root_level; |
@@ -219,8 +238,13 @@ struct kvm_vcpu_arch { | |||
219 | int interrupt_window_open; | 238 | int interrupt_window_open; |
220 | unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */ | 239 | unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */ |
221 | DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS); | 240 | DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS); |
222 | unsigned long regs[NR_VCPU_REGS]; /* for rsp: vcpu_load_rsp_rip() */ | 241 | /* |
223 | unsigned long rip; /* needs vcpu_load_rsp_rip() */ | 242 | * rip and regs accesses must go through |
243 | * kvm_{register,rip}_{read,write} functions. | ||
244 | */ | ||
245 | unsigned long regs[NR_VCPU_REGS]; | ||
246 | u32 regs_avail; | ||
247 | u32 regs_dirty; | ||
224 | 248 | ||
225 | unsigned long cr0; | 249 | unsigned long cr0; |
226 | unsigned long cr2; | 250 | unsigned long cr2; |
@@ -237,6 +261,9 @@ struct kvm_vcpu_arch { | |||
237 | bool tpr_access_reporting; | 261 | bool tpr_access_reporting; |
238 | 262 | ||
239 | struct kvm_mmu mmu; | 263 | struct kvm_mmu mmu; |
264 | /* only needed in kvm_pv_mmu_op() path, but it's hot so | ||
265 | * put it here to avoid allocation */ | ||
266 | struct kvm_pv_mmu_op_buffer mmu_op_buffer; | ||
240 | 267 | ||
241 | struct kvm_mmu_memory_cache mmu_pte_chain_cache; | 268 | struct kvm_mmu_memory_cache mmu_pte_chain_cache; |
242 | struct kvm_mmu_memory_cache mmu_rmap_desc_cache; | 269 | struct kvm_mmu_memory_cache mmu_rmap_desc_cache; |
@@ -269,6 +296,11 @@ struct kvm_vcpu_arch { | |||
269 | u32 error_code; | 296 | u32 error_code; |
270 | } exception; | 297 | } exception; |
271 | 298 | ||
299 | struct kvm_queued_interrupt { | ||
300 | bool pending; | ||
301 | u8 nr; | ||
302 | } interrupt; | ||
303 | |||
272 | struct { | 304 | struct { |
273 | int active; | 305 | int active; |
274 | u8 save_iopl; | 306 | u8 save_iopl; |
@@ -294,6 +326,7 @@ struct kvm_vcpu_arch { | |||
294 | struct page *time_page; | 326 | struct page *time_page; |
295 | 327 | ||
296 | bool nmi_pending; | 328 | bool nmi_pending; |
329 | bool nmi_injected; | ||
297 | 330 | ||
298 | u64 mtrr[0x100]; | 331 | u64 mtrr[0x100]; |
299 | }; | 332 | }; |
@@ -316,9 +349,12 @@ struct kvm_arch{ | |||
316 | * Hash table of struct kvm_mmu_page. | 349 | * Hash table of struct kvm_mmu_page. |
317 | */ | 350 | */ |
318 | struct list_head active_mmu_pages; | 351 | struct list_head active_mmu_pages; |
352 | struct list_head assigned_dev_head; | ||
353 | struct dmar_domain *intel_iommu_domain; | ||
319 | struct kvm_pic *vpic; | 354 | struct kvm_pic *vpic; |
320 | struct kvm_ioapic *vioapic; | 355 | struct kvm_ioapic *vioapic; |
321 | struct kvm_pit *vpit; | 356 | struct kvm_pit *vpit; |
357 | struct hlist_head irq_ack_notifier_list; | ||
322 | 358 | ||
323 | int round_robin_prev_vcpu; | 359 | int round_robin_prev_vcpu; |
324 | unsigned int tss_addr; | 360 | unsigned int tss_addr; |
@@ -338,6 +374,7 @@ struct kvm_vm_stat { | |||
338 | u32 mmu_flooded; | 374 | u32 mmu_flooded; |
339 | u32 mmu_recycled; | 375 | u32 mmu_recycled; |
340 | u32 mmu_cache_miss; | 376 | u32 mmu_cache_miss; |
377 | u32 mmu_unsync; | ||
341 | u32 remote_tlb_flush; | 378 | u32 remote_tlb_flush; |
342 | u32 lpages; | 379 | u32 lpages; |
343 | }; | 380 | }; |
@@ -364,6 +401,7 @@ struct kvm_vcpu_stat { | |||
364 | u32 insn_emulation; | 401 | u32 insn_emulation; |
365 | u32 insn_emulation_fail; | 402 | u32 insn_emulation_fail; |
366 | u32 hypercalls; | 403 | u32 hypercalls; |
404 | u32 irq_injections; | ||
367 | }; | 405 | }; |
368 | 406 | ||
369 | struct descriptor_table { | 407 | struct descriptor_table { |
@@ -414,8 +452,7 @@ struct kvm_x86_ops { | |||
414 | unsigned long (*get_dr)(struct kvm_vcpu *vcpu, int dr); | 452 | unsigned long (*get_dr)(struct kvm_vcpu *vcpu, int dr); |
415 | void (*set_dr)(struct kvm_vcpu *vcpu, int dr, unsigned long value, | 453 | void (*set_dr)(struct kvm_vcpu *vcpu, int dr, unsigned long value, |
416 | int *exception); | 454 | int *exception); |
417 | void (*cache_regs)(struct kvm_vcpu *vcpu); | 455 | void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg); |
418 | void (*decache_regs)(struct kvm_vcpu *vcpu); | ||
419 | unsigned long (*get_rflags)(struct kvm_vcpu *vcpu); | 456 | unsigned long (*get_rflags)(struct kvm_vcpu *vcpu); |
420 | void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags); | 457 | void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags); |
421 | 458 | ||
@@ -528,6 +565,8 @@ void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code); | |||
528 | void kvm_inject_page_fault(struct kvm_vcpu *vcpu, unsigned long cr2, | 565 | void kvm_inject_page_fault(struct kvm_vcpu *vcpu, unsigned long cr2, |
529 | u32 error_code); | 566 | u32 error_code); |
530 | 567 | ||
568 | void kvm_pic_set_irq(void *opaque, int irq, int level); | ||
569 | |||
531 | void kvm_inject_nmi(struct kvm_vcpu *vcpu); | 570 | void kvm_inject_nmi(struct kvm_vcpu *vcpu); |
532 | 571 | ||
533 | void fx_init(struct kvm_vcpu *vcpu); | 572 | void fx_init(struct kvm_vcpu *vcpu); |
@@ -550,12 +589,14 @@ int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva); | |||
550 | void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu); | 589 | void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu); |
551 | int kvm_mmu_load(struct kvm_vcpu *vcpu); | 590 | int kvm_mmu_load(struct kvm_vcpu *vcpu); |
552 | void kvm_mmu_unload(struct kvm_vcpu *vcpu); | 591 | void kvm_mmu_unload(struct kvm_vcpu *vcpu); |
592 | void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu); | ||
553 | 593 | ||
554 | int kvm_emulate_hypercall(struct kvm_vcpu *vcpu); | 594 | int kvm_emulate_hypercall(struct kvm_vcpu *vcpu); |
555 | 595 | ||
556 | int kvm_fix_hypercall(struct kvm_vcpu *vcpu); | 596 | int kvm_fix_hypercall(struct kvm_vcpu *vcpu); |
557 | 597 | ||
558 | int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code); | 598 | int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code); |
599 | void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva); | ||
559 | 600 | ||
560 | void kvm_enable_tdp(void); | 601 | void kvm_enable_tdp(void); |
561 | void kvm_disable_tdp(void); | 602 | void kvm_disable_tdp(void); |
@@ -686,33 +727,6 @@ enum { | |||
686 | TASK_SWITCH_GATE = 3, | 727 | TASK_SWITCH_GATE = 3, |
687 | }; | 728 | }; |
688 | 729 | ||
689 | #define KVMTRACE_5D(evt, vcpu, d1, d2, d3, d4, d5, name) \ | ||
690 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
691 | vcpu, 5, d1, d2, d3, d4, d5) | ||
692 | #define KVMTRACE_4D(evt, vcpu, d1, d2, d3, d4, name) \ | ||
693 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
694 | vcpu, 4, d1, d2, d3, d4, 0) | ||
695 | #define KVMTRACE_3D(evt, vcpu, d1, d2, d3, name) \ | ||
696 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
697 | vcpu, 3, d1, d2, d3, 0, 0) | ||
698 | #define KVMTRACE_2D(evt, vcpu, d1, d2, name) \ | ||
699 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
700 | vcpu, 2, d1, d2, 0, 0, 0) | ||
701 | #define KVMTRACE_1D(evt, vcpu, d1, name) \ | ||
702 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
703 | vcpu, 1, d1, 0, 0, 0, 0) | ||
704 | #define KVMTRACE_0D(evt, vcpu, name) \ | ||
705 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
706 | vcpu, 0, 0, 0, 0, 0, 0) | ||
707 | |||
708 | #ifdef CONFIG_64BIT | ||
709 | # define KVM_EX_ENTRY ".quad" | ||
710 | # define KVM_EX_PUSH "pushq" | ||
711 | #else | ||
712 | # define KVM_EX_ENTRY ".long" | ||
713 | # define KVM_EX_PUSH "pushl" | ||
714 | #endif | ||
715 | |||
716 | /* | 730 | /* |
717 | * Hardware virtualization extension instructions may fault if a | 731 | * Hardware virtualization extension instructions may fault if a |
718 | * reboot turns off virtualization while processes are running. | 732 | * reboot turns off virtualization while processes are running. |
@@ -724,11 +738,11 @@ asmlinkage void kvm_handle_fault_on_reboot(void); | |||
724 | "666: " insn "\n\t" \ | 738 | "666: " insn "\n\t" \ |
725 | ".pushsection .fixup, \"ax\" \n" \ | 739 | ".pushsection .fixup, \"ax\" \n" \ |
726 | "667: \n\t" \ | 740 | "667: \n\t" \ |
727 | KVM_EX_PUSH " $666b \n\t" \ | 741 | __ASM_SIZE(push) " $666b \n\t" \ |
728 | "jmp kvm_handle_fault_on_reboot \n\t" \ | 742 | "jmp kvm_handle_fault_on_reboot \n\t" \ |
729 | ".popsection \n\t" \ | 743 | ".popsection \n\t" \ |
730 | ".pushsection __ex_table, \"a\" \n\t" \ | 744 | ".pushsection __ex_table, \"a\" \n\t" \ |
731 | KVM_EX_ENTRY " 666b, 667b \n\t" \ | 745 | _ASM_PTR " 666b, 667b \n\t" \ |
732 | ".popsection" | 746 | ".popsection" |
733 | 747 | ||
734 | #define KVM_ARCH_WANT_MMU_NOTIFIER | 748 | #define KVM_ARCH_WANT_MMU_NOTIFIER |
diff --git a/include/asm-x86/msr-index.h b/include/asm-x86/msr-index.h index 0bb43301a202..dabd10f0bbee 100644 --- a/include/asm-x86/msr-index.h +++ b/include/asm-x86/msr-index.h | |||
@@ -178,6 +178,9 @@ | |||
178 | #define MSR_IA32_EBL_CR_POWERON 0x0000002a | 178 | #define MSR_IA32_EBL_CR_POWERON 0x0000002a |
179 | #define MSR_IA32_FEATURE_CONTROL 0x0000003a | 179 | #define MSR_IA32_FEATURE_CONTROL 0x0000003a |
180 | 180 | ||
181 | #define FEATURE_CONTROL_LOCKED (1<<0) | ||
182 | #define FEATURE_CONTROL_VMXON_ENABLED (1<<2) | ||
183 | |||
181 | #define MSR_IA32_APICBASE 0x0000001b | 184 | #define MSR_IA32_APICBASE 0x0000001b |
182 | #define MSR_IA32_APICBASE_BSP (1<<8) | 185 | #define MSR_IA32_APICBASE_BSP (1<<8) |
183 | #define MSR_IA32_APICBASE_ENABLE (1<<11) | 186 | #define MSR_IA32_APICBASE_ENABLE (1<<11) |
diff --git a/include/asm-x86/page_32.h b/include/asm-x86/page_32.h index e8d80d1de237..bdf5dba4cfb0 100644 --- a/include/asm-x86/page_32.h +++ b/include/asm-x86/page_32.h | |||
@@ -39,7 +39,6 @@ typedef u64 pmdval_t; | |||
39 | typedef u64 pudval_t; | 39 | typedef u64 pudval_t; |
40 | typedef u64 pgdval_t; | 40 | typedef u64 pgdval_t; |
41 | typedef u64 pgprotval_t; | 41 | typedef u64 pgprotval_t; |
42 | typedef u64 phys_addr_t; | ||
43 | 42 | ||
44 | typedef union { | 43 | typedef union { |
45 | struct { | 44 | struct { |
@@ -60,7 +59,6 @@ typedef unsigned long pmdval_t; | |||
60 | typedef unsigned long pudval_t; | 59 | typedef unsigned long pudval_t; |
61 | typedef unsigned long pgdval_t; | 60 | typedef unsigned long pgdval_t; |
62 | typedef unsigned long pgprotval_t; | 61 | typedef unsigned long pgprotval_t; |
63 | typedef unsigned long phys_addr_t; | ||
64 | 62 | ||
65 | typedef union { | 63 | typedef union { |
66 | pteval_t pte; | 64 | pteval_t pte; |
diff --git a/include/asm-x86/page_64.h b/include/asm-x86/page_64.h index 5e64acfed0a4..49380b8c7e25 100644 --- a/include/asm-x86/page_64.h +++ b/include/asm-x86/page_64.h | |||
@@ -79,7 +79,6 @@ typedef unsigned long pmdval_t; | |||
79 | typedef unsigned long pudval_t; | 79 | typedef unsigned long pudval_t; |
80 | typedef unsigned long pgdval_t; | 80 | typedef unsigned long pgdval_t; |
81 | typedef unsigned long pgprotval_t; | 81 | typedef unsigned long pgprotval_t; |
82 | typedef unsigned long phys_addr_t; | ||
83 | 82 | ||
84 | typedef struct page *pgtable_t; | 83 | typedef struct page *pgtable_t; |
85 | 84 | ||
diff --git a/include/asm-x86/pgtable.h b/include/asm-x86/pgtable.h index 182f9d4c570f..88a53b1a17f0 100644 --- a/include/asm-x86/pgtable.h +++ b/include/asm-x86/pgtable.h | |||
@@ -148,8 +148,13 @@ | |||
148 | #ifdef CONFIG_X86_64 | 148 | #ifdef CONFIG_X86_64 |
149 | #define __PAGE_KERNEL_IDENT_LARGE_EXEC __PAGE_KERNEL_LARGE_EXEC | 149 | #define __PAGE_KERNEL_IDENT_LARGE_EXEC __PAGE_KERNEL_LARGE_EXEC |
150 | #else | 150 | #else |
151 | /* | ||
152 | * For PDE_IDENT_ATTR include USER bit. As the PDE and PTE protection | ||
153 | * bits are combined, this will alow user to access the high address mapped | ||
154 | * VDSO in the presence of CONFIG_COMPAT_VDSO | ||
155 | */ | ||
151 | #define PTE_IDENT_ATTR 0x003 /* PRESENT+RW */ | 156 | #define PTE_IDENT_ATTR 0x003 /* PRESENT+RW */ |
152 | #define PDE_IDENT_ATTR 0x063 /* PRESENT+RW+DIRTY+ACCESSED */ | 157 | #define PDE_IDENT_ATTR 0x067 /* PRESENT+RW+USER+DIRTY+ACCESSED */ |
153 | #define PGD_IDENT_ATTR 0x001 /* PRESENT (no other attributes) */ | 158 | #define PGD_IDENT_ATTR 0x001 /* PRESENT (no other attributes) */ |
154 | #endif | 159 | #endif |
155 | 160 | ||
diff --git a/include/asm-x86/pvclock.h b/include/asm-x86/pvclock.h index 1a38f6834800..ad29e277fd6d 100644 --- a/include/asm-x86/pvclock.h +++ b/include/asm-x86/pvclock.h | |||
@@ -6,6 +6,7 @@ | |||
6 | 6 | ||
7 | /* some helper functions for xen and kvm pv clock sources */ | 7 | /* some helper functions for xen and kvm pv clock sources */ |
8 | cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src); | 8 | cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src); |
9 | unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src); | ||
9 | void pvclock_read_wallclock(struct pvclock_wall_clock *wall, | 10 | void pvclock_read_wallclock(struct pvclock_wall_clock *wall, |
10 | struct pvclock_vcpu_time_info *vcpu, | 11 | struct pvclock_vcpu_time_info *vcpu, |
11 | struct timespec *ts); | 12 | struct timespec *ts); |
diff --git a/include/asm-x86/summit/apic.h b/include/asm-x86/summit/apic.h index c5b2e4b10358..394b00bb5e72 100644 --- a/include/asm-x86/summit/apic.h +++ b/include/asm-x86/summit/apic.h | |||
@@ -160,7 +160,7 @@ static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask) | |||
160 | int new_apicid = cpu_to_logical_apicid(cpu); | 160 | int new_apicid = cpu_to_logical_apicid(cpu); |
161 | if (apicid_cluster(apicid) != | 161 | if (apicid_cluster(apicid) != |
162 | apicid_cluster(new_apicid)){ | 162 | apicid_cluster(new_apicid)){ |
163 | printk ("%s: Not a valid mask!\n",__FUNCTION__); | 163 | printk ("%s: Not a valid mask!\n", __func__); |
164 | return 0xFF; | 164 | return 0xFF; |
165 | } | 165 | } |
166 | apicid = apicid | new_apicid; | 166 | apicid = apicid | new_apicid; |
diff --git a/include/asm-x86/xen/page.h b/include/asm-x86/xen/page.h index c50185dccec1..d5eada0a48d9 100644 --- a/include/asm-x86/xen/page.h +++ b/include/asm-x86/xen/page.h | |||
@@ -76,13 +76,13 @@ static inline unsigned long mfn_to_pfn(unsigned long mfn) | |||
76 | static inline xmaddr_t phys_to_machine(xpaddr_t phys) | 76 | static inline xmaddr_t phys_to_machine(xpaddr_t phys) |
77 | { | 77 | { |
78 | unsigned offset = phys.paddr & ~PAGE_MASK; | 78 | unsigned offset = phys.paddr & ~PAGE_MASK; |
79 | return XMADDR(PFN_PHYS((u64)pfn_to_mfn(PFN_DOWN(phys.paddr))) | offset); | 79 | return XMADDR(PFN_PHYS(pfn_to_mfn(PFN_DOWN(phys.paddr))) | offset); |
80 | } | 80 | } |
81 | 81 | ||
82 | static inline xpaddr_t machine_to_phys(xmaddr_t machine) | 82 | static inline xpaddr_t machine_to_phys(xmaddr_t machine) |
83 | { | 83 | { |
84 | unsigned offset = machine.maddr & ~PAGE_MASK; | 84 | unsigned offset = machine.maddr & ~PAGE_MASK; |
85 | return XPADDR(PFN_PHYS((u64)mfn_to_pfn(PFN_DOWN(machine.maddr))) | offset); | 85 | return XPADDR(PFN_PHYS(mfn_to_pfn(PFN_DOWN(machine.maddr))) | offset); |
86 | } | 86 | } |
87 | 87 | ||
88 | /* | 88 | /* |
diff --git a/include/asm-xtensa/elf.h b/include/asm-xtensa/elf.h index ca6e5101a2cb..c3f53e755ca5 100644 --- a/include/asm-xtensa/elf.h +++ b/include/asm-xtensa/elf.h | |||
@@ -189,7 +189,7 @@ typedef struct { | |||
189 | #endif | 189 | #endif |
190 | } elf_xtregs_t; | 190 | } elf_xtregs_t; |
191 | 191 | ||
192 | #define SET_PERSONALITY(ex, ibcs2) set_personality(PER_LINUX_32BIT) | 192 | #define SET_PERSONALITY(ex) set_personality(PER_LINUX_32BIT) |
193 | 193 | ||
194 | struct task_struct; | 194 | struct task_struct; |
195 | 195 | ||
diff --git a/include/asm-xtensa/thread_info.h b/include/asm-xtensa/thread_info.h index 7e4131dd546c..0f4fe1faf9ba 100644 --- a/include/asm-xtensa/thread_info.h +++ b/include/asm-xtensa/thread_info.h | |||
@@ -134,6 +134,7 @@ static inline struct thread_info *current_thread_info(void) | |||
134 | #define TIF_MEMDIE 5 | 134 | #define TIF_MEMDIE 5 |
135 | #define TIF_RESTORE_SIGMASK 6 /* restore signal mask in do_signal() */ | 135 | #define TIF_RESTORE_SIGMASK 6 /* restore signal mask in do_signal() */ |
136 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ | 136 | #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ |
137 | #define TIF_FREEZE 17 /* is freezing for suspend */ | ||
137 | 138 | ||
138 | #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) | 139 | #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) |
139 | #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) | 140 | #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) |
@@ -142,6 +143,7 @@ static inline struct thread_info *current_thread_info(void) | |||
142 | #define _TIF_IRET (1<<TIF_IRET) | 143 | #define _TIF_IRET (1<<TIF_IRET) |
143 | #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) | 144 | #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) |
144 | #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) | 145 | #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) |
146 | #define _TIF_FREEZE (1<<TIF_FREEZE) | ||
145 | 147 | ||
146 | #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ | 148 | #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ |
147 | #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ | 149 | #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ |
diff --git a/include/drm/drm.h b/include/drm/drm.h index 38d3c6b8276a..f46ba4b57da4 100644 --- a/include/drm/drm.h +++ b/include/drm/drm.h | |||
@@ -36,7 +36,6 @@ | |||
36 | #ifndef _DRM_H_ | 36 | #ifndef _DRM_H_ |
37 | #define _DRM_H_ | 37 | #define _DRM_H_ |
38 | 38 | ||
39 | #if defined(__linux__) | ||
40 | #if defined(__KERNEL__) | 39 | #if defined(__KERNEL__) |
41 | #endif | 40 | #endif |
42 | #include <asm/ioctl.h> /* For _IO* macros */ | 41 | #include <asm/ioctl.h> /* For _IO* macros */ |
@@ -46,22 +45,6 @@ | |||
46 | #define DRM_IOC_WRITE _IOC_WRITE | 45 | #define DRM_IOC_WRITE _IOC_WRITE |
47 | #define DRM_IOC_READWRITE _IOC_READ|_IOC_WRITE | 46 | #define DRM_IOC_READWRITE _IOC_READ|_IOC_WRITE |
48 | #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size) | 47 | #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size) |
49 | #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) | ||
50 | #if defined(__FreeBSD__) && defined(IN_MODULE) | ||
51 | /* Prevent name collision when including sys/ioccom.h */ | ||
52 | #undef ioctl | ||
53 | #include <sys/ioccom.h> | ||
54 | #define ioctl(a,b,c) xf86ioctl(a,b,c) | ||
55 | #else | ||
56 | #include <sys/ioccom.h> | ||
57 | #endif /* __FreeBSD__ && xf86ioctl */ | ||
58 | #define DRM_IOCTL_NR(n) ((n) & 0xff) | ||
59 | #define DRM_IOC_VOID IOC_VOID | ||
60 | #define DRM_IOC_READ IOC_OUT | ||
61 | #define DRM_IOC_WRITE IOC_IN | ||
62 | #define DRM_IOC_READWRITE IOC_INOUT | ||
63 | #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size) | ||
64 | #endif | ||
65 | 48 | ||
66 | #define DRM_MAJOR 226 | 49 | #define DRM_MAJOR 226 |
67 | #define DRM_MAX_MINOR 15 | 50 | #define DRM_MAX_MINOR 15 |
@@ -471,6 +454,7 @@ struct drm_irq_busid { | |||
471 | enum drm_vblank_seq_type { | 454 | enum drm_vblank_seq_type { |
472 | _DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */ | 455 | _DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */ |
473 | _DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */ | 456 | _DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */ |
457 | _DRM_VBLANK_FLIP = 0x8000000, /**< Scheduled buffer swap should flip */ | ||
474 | _DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */ | 458 | _DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */ |
475 | _DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */ | 459 | _DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */ |
476 | _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */ | 460 | _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */ |
@@ -503,6 +487,19 @@ union drm_wait_vblank { | |||
503 | struct drm_wait_vblank_reply reply; | 487 | struct drm_wait_vblank_reply reply; |
504 | }; | 488 | }; |
505 | 489 | ||
490 | #define _DRM_PRE_MODESET 1 | ||
491 | #define _DRM_POST_MODESET 2 | ||
492 | |||
493 | /** | ||
494 | * DRM_IOCTL_MODESET_CTL ioctl argument type | ||
495 | * | ||
496 | * \sa drmModesetCtl(). | ||
497 | */ | ||
498 | struct drm_modeset_ctl { | ||
499 | uint32_t crtc; | ||
500 | uint32_t cmd; | ||
501 | }; | ||
502 | |||
506 | /** | 503 | /** |
507 | * DRM_IOCTL_AGP_ENABLE ioctl argument type. | 504 | * DRM_IOCTL_AGP_ENABLE ioctl argument type. |
508 | * | 505 | * |
@@ -573,6 +570,34 @@ struct drm_set_version { | |||
573 | int drm_dd_minor; | 570 | int drm_dd_minor; |
574 | }; | 571 | }; |
575 | 572 | ||
573 | /** DRM_IOCTL_GEM_CLOSE ioctl argument type */ | ||
574 | struct drm_gem_close { | ||
575 | /** Handle of the object to be closed. */ | ||
576 | uint32_t handle; | ||
577 | uint32_t pad; | ||
578 | }; | ||
579 | |||
580 | /** DRM_IOCTL_GEM_FLINK ioctl argument type */ | ||
581 | struct drm_gem_flink { | ||
582 | /** Handle for the object being named */ | ||
583 | uint32_t handle; | ||
584 | |||
585 | /** Returned global name */ | ||
586 | uint32_t name; | ||
587 | }; | ||
588 | |||
589 | /** DRM_IOCTL_GEM_OPEN ioctl argument type */ | ||
590 | struct drm_gem_open { | ||
591 | /** Name of object being opened */ | ||
592 | uint32_t name; | ||
593 | |||
594 | /** Returned handle for the object */ | ||
595 | uint32_t handle; | ||
596 | |||
597 | /** Returned size of the object */ | ||
598 | uint64_t size; | ||
599 | }; | ||
600 | |||
576 | #define DRM_IOCTL_BASE 'd' | 601 | #define DRM_IOCTL_BASE 'd' |
577 | #define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr) | 602 | #define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr) |
578 | #define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type) | 603 | #define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type) |
@@ -587,6 +612,10 @@ struct drm_set_version { | |||
587 | #define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, struct drm_client) | 612 | #define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, struct drm_client) |
588 | #define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, struct drm_stats) | 613 | #define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, struct drm_stats) |
589 | #define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, struct drm_set_version) | 614 | #define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, struct drm_set_version) |
615 | #define DRM_IOCTL_MODESET_CTL DRM_IOW(0x08, struct drm_modeset_ctl) | ||
616 | #define DRM_IOCTL_GEM_CLOSE DRM_IOW (0x09, struct drm_gem_close) | ||
617 | #define DRM_IOCTL_GEM_FLINK DRM_IOWR(0x0a, struct drm_gem_flink) | ||
618 | #define DRM_IOCTL_GEM_OPEN DRM_IOWR(0x0b, struct drm_gem_open) | ||
590 | 619 | ||
591 | #define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, struct drm_unique) | 620 | #define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, struct drm_unique) |
592 | #define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, struct drm_auth) | 621 | #define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, struct drm_auth) |
diff --git a/include/drm/drmP.h b/include/drm/drmP.h index 1c1b13e29223..59c796b46ee7 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h | |||
@@ -104,6 +104,7 @@ struct drm_device; | |||
104 | #define DRIVER_DMA_QUEUE 0x200 | 104 | #define DRIVER_DMA_QUEUE 0x200 |
105 | #define DRIVER_FB_DMA 0x400 | 105 | #define DRIVER_FB_DMA 0x400 |
106 | #define DRIVER_IRQ_VBL2 0x800 | 106 | #define DRIVER_IRQ_VBL2 0x800 |
107 | #define DRIVER_GEM 0x1000 | ||
107 | 108 | ||
108 | /***********************************************************************/ | 109 | /***********************************************************************/ |
109 | /** \name Begin the DRM... */ | 110 | /** \name Begin the DRM... */ |
@@ -387,6 +388,10 @@ struct drm_file { | |||
387 | struct drm_minor *minor; | 388 | struct drm_minor *minor; |
388 | int remove_auth_on_close; | 389 | int remove_auth_on_close; |
389 | unsigned long lock_count; | 390 | unsigned long lock_count; |
391 | /** Mapping of mm object handles to object pointers. */ | ||
392 | struct idr object_idr; | ||
393 | /** Lock for synchronization of access to object_idr. */ | ||
394 | spinlock_t table_lock; | ||
390 | struct file *filp; | 395 | struct file *filp; |
391 | void *driver_priv; | 396 | void *driver_priv; |
392 | }; | 397 | }; |
@@ -558,6 +563,56 @@ struct drm_ati_pcigart_info { | |||
558 | }; | 563 | }; |
559 | 564 | ||
560 | /** | 565 | /** |
566 | * This structure defines the drm_mm memory object, which will be used by the | ||
567 | * DRM for its buffer objects. | ||
568 | */ | ||
569 | struct drm_gem_object { | ||
570 | /** Reference count of this object */ | ||
571 | struct kref refcount; | ||
572 | |||
573 | /** Handle count of this object. Each handle also holds a reference */ | ||
574 | struct kref handlecount; | ||
575 | |||
576 | /** Related drm device */ | ||
577 | struct drm_device *dev; | ||
578 | |||
579 | /** File representing the shmem storage */ | ||
580 | struct file *filp; | ||
581 | |||
582 | /** | ||
583 | * Size of the object, in bytes. Immutable over the object's | ||
584 | * lifetime. | ||
585 | */ | ||
586 | size_t size; | ||
587 | |||
588 | /** | ||
589 | * Global name for this object, starts at 1. 0 means unnamed. | ||
590 | * Access is covered by the object_name_lock in the related drm_device | ||
591 | */ | ||
592 | int name; | ||
593 | |||
594 | /** | ||
595 | * Memory domains. These monitor which caches contain read/write data | ||
596 | * related to the object. When transitioning from one set of domains | ||
597 | * to another, the driver is called to ensure that caches are suitably | ||
598 | * flushed and invalidated | ||
599 | */ | ||
600 | uint32_t read_domains; | ||
601 | uint32_t write_domain; | ||
602 | |||
603 | /** | ||
604 | * While validating an exec operation, the | ||
605 | * new read/write domain values are computed here. | ||
606 | * They will be transferred to the above values | ||
607 | * at the point that any cache flushing occurs | ||
608 | */ | ||
609 | uint32_t pending_read_domains; | ||
610 | uint32_t pending_write_domain; | ||
611 | |||
612 | void *driver_private; | ||
613 | }; | ||
614 | |||
615 | /** | ||
561 | * DRM driver structure. This structure represent the common code for | 616 | * DRM driver structure. This structure represent the common code for |
562 | * a family of cards. There will one drm_device for each card present | 617 | * a family of cards. There will one drm_device for each card present |
563 | * in this family | 618 | * in this family |
@@ -580,11 +635,54 @@ struct drm_driver { | |||
580 | int (*kernel_context_switch) (struct drm_device *dev, int old, | 635 | int (*kernel_context_switch) (struct drm_device *dev, int old, |
581 | int new); | 636 | int new); |
582 | void (*kernel_context_switch_unlock) (struct drm_device *dev); | 637 | void (*kernel_context_switch_unlock) (struct drm_device *dev); |
583 | int (*vblank_wait) (struct drm_device *dev, unsigned int *sequence); | ||
584 | int (*vblank_wait2) (struct drm_device *dev, unsigned int *sequence); | ||
585 | int (*dri_library_name) (struct drm_device *dev, char *buf); | 638 | int (*dri_library_name) (struct drm_device *dev, char *buf); |
586 | 639 | ||
587 | /** | 640 | /** |
641 | * get_vblank_counter - get raw hardware vblank counter | ||
642 | * @dev: DRM device | ||
643 | * @crtc: counter to fetch | ||
644 | * | ||
645 | * Driver callback for fetching a raw hardware vblank counter | ||
646 | * for @crtc. If a device doesn't have a hardware counter, the | ||
647 | * driver can simply return the value of drm_vblank_count and | ||
648 | * make the enable_vblank() and disable_vblank() hooks into no-ops, | ||
649 | * leaving interrupts enabled at all times. | ||
650 | * | ||
651 | * Wraparound handling and loss of events due to modesetting is dealt | ||
652 | * with in the DRM core code. | ||
653 | * | ||
654 | * RETURNS | ||
655 | * Raw vblank counter value. | ||
656 | */ | ||
657 | u32 (*get_vblank_counter) (struct drm_device *dev, int crtc); | ||
658 | |||
659 | /** | ||
660 | * enable_vblank - enable vblank interrupt events | ||
661 | * @dev: DRM device | ||
662 | * @crtc: which irq to enable | ||
663 | * | ||
664 | * Enable vblank interrupts for @crtc. If the device doesn't have | ||
665 | * a hardware vblank counter, this routine should be a no-op, since | ||
666 | * interrupts will have to stay on to keep the count accurate. | ||
667 | * | ||
668 | * RETURNS | ||
669 | * Zero on success, appropriate errno if the given @crtc's vblank | ||
670 | * interrupt cannot be enabled. | ||
671 | */ | ||
672 | int (*enable_vblank) (struct drm_device *dev, int crtc); | ||
673 | |||
674 | /** | ||
675 | * disable_vblank - disable vblank interrupt events | ||
676 | * @dev: DRM device | ||
677 | * @crtc: which irq to enable | ||
678 | * | ||
679 | * Disable vblank interrupts for @crtc. If the device doesn't have | ||
680 | * a hardware vblank counter, this routine should be a no-op, since | ||
681 | * interrupts will have to stay on to keep the count accurate. | ||
682 | */ | ||
683 | void (*disable_vblank) (struct drm_device *dev, int crtc); | ||
684 | |||
685 | /** | ||
588 | * Called by \c drm_device_is_agp. Typically used to determine if a | 686 | * Called by \c drm_device_is_agp. Typically used to determine if a |
589 | * card is really attached to AGP or not. | 687 | * card is really attached to AGP or not. |
590 | * | 688 | * |
@@ -601,7 +699,7 @@ struct drm_driver { | |||
601 | 699 | ||
602 | irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); | 700 | irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); |
603 | void (*irq_preinstall) (struct drm_device *dev); | 701 | void (*irq_preinstall) (struct drm_device *dev); |
604 | void (*irq_postinstall) (struct drm_device *dev); | 702 | int (*irq_postinstall) (struct drm_device *dev); |
605 | void (*irq_uninstall) (struct drm_device *dev); | 703 | void (*irq_uninstall) (struct drm_device *dev); |
606 | void (*reclaim_buffers) (struct drm_device *dev, | 704 | void (*reclaim_buffers) (struct drm_device *dev, |
607 | struct drm_file * file_priv); | 705 | struct drm_file * file_priv); |
@@ -614,6 +712,18 @@ struct drm_driver { | |||
614 | void (*set_version) (struct drm_device *dev, | 712 | void (*set_version) (struct drm_device *dev, |
615 | struct drm_set_version *sv); | 713 | struct drm_set_version *sv); |
616 | 714 | ||
715 | int (*proc_init)(struct drm_minor *minor); | ||
716 | void (*proc_cleanup)(struct drm_minor *minor); | ||
717 | |||
718 | /** | ||
719 | * Driver-specific constructor for drm_gem_objects, to set up | ||
720 | * obj->driver_private. | ||
721 | * | ||
722 | * Returns 0 on success. | ||
723 | */ | ||
724 | int (*gem_init_object) (struct drm_gem_object *obj); | ||
725 | void (*gem_free_object) (struct drm_gem_object *obj); | ||
726 | |||
617 | int major; | 727 | int major; |
618 | int minor; | 728 | int minor; |
619 | int patchlevel; | 729 | int patchlevel; |
@@ -714,7 +824,6 @@ struct drm_device { | |||
714 | 824 | ||
715 | /** \name Context support */ | 825 | /** \name Context support */ |
716 | /*@{ */ | 826 | /*@{ */ |
717 | int irq; /**< Interrupt used by board */ | ||
718 | int irq_enabled; /**< True if irq handler is enabled */ | 827 | int irq_enabled; /**< True if irq handler is enabled */ |
719 | __volatile__ long context_flag; /**< Context swapping flag */ | 828 | __volatile__ long context_flag; /**< Context swapping flag */ |
720 | __volatile__ long interrupt_flag; /**< Interruption handler flag */ | 829 | __volatile__ long interrupt_flag; /**< Interruption handler flag */ |
@@ -730,13 +839,28 @@ struct drm_device { | |||
730 | /** \name VBLANK IRQ support */ | 839 | /** \name VBLANK IRQ support */ |
731 | /*@{ */ | 840 | /*@{ */ |
732 | 841 | ||
733 | wait_queue_head_t vbl_queue; /**< VBLANK wait queue */ | 842 | /* |
734 | atomic_t vbl_received; | 843 | * At load time, disabling the vblank interrupt won't be allowed since |
735 | atomic_t vbl_received2; /**< number of secondary VBLANK interrupts */ | 844 | * old clients may not call the modeset ioctl and therefore misbehave. |
845 | * Once the modeset ioctl *has* been called though, we can safely | ||
846 | * disable them when unused. | ||
847 | */ | ||
848 | int vblank_disable_allowed; | ||
849 | |||
850 | wait_queue_head_t *vbl_queue; /**< VBLANK wait queue */ | ||
851 | atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */ | ||
736 | spinlock_t vbl_lock; | 852 | spinlock_t vbl_lock; |
737 | struct list_head vbl_sigs; /**< signal list to send on VBLANK */ | 853 | struct list_head *vbl_sigs; /**< signal list to send on VBLANK */ |
738 | struct list_head vbl_sigs2; /**< signals to send on secondary VBLANK */ | 854 | atomic_t vbl_signal_pending; /* number of signals pending on all crtcs*/ |
739 | unsigned int vbl_pending; | 855 | atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */ |
856 | u32 *last_vblank; /* protected by dev->vbl_lock, used */ | ||
857 | /* for wraparound handling */ | ||
858 | int *vblank_enabled; /* so we don't call enable more than | ||
859 | once per disable */ | ||
860 | int *vblank_inmodeset; /* Display driver is setting mode */ | ||
861 | struct timer_list vblank_disable_timer; | ||
862 | |||
863 | u32 max_vblank_count; /**< size of vblank counter register */ | ||
740 | spinlock_t tasklet_lock; /**< For drm_locked_tasklet */ | 864 | spinlock_t tasklet_lock; /**< For drm_locked_tasklet */ |
741 | void (*locked_tasklet_func)(struct drm_device *dev); | 865 | void (*locked_tasklet_func)(struct drm_device *dev); |
742 | 866 | ||
@@ -757,6 +881,7 @@ struct drm_device { | |||
757 | struct pci_controller *hose; | 881 | struct pci_controller *hose; |
758 | #endif | 882 | #endif |
759 | struct drm_sg_mem *sg; /**< Scatter gather memory */ | 883 | struct drm_sg_mem *sg; /**< Scatter gather memory */ |
884 | int num_crtcs; /**< Number of CRTCs on this device */ | ||
760 | void *dev_private; /**< device private data */ | 885 | void *dev_private; /**< device private data */ |
761 | struct drm_sigdata sigdata; /**< For block_all_signals */ | 886 | struct drm_sigdata sigdata; /**< For block_all_signals */ |
762 | sigset_t sigmask; | 887 | sigset_t sigmask; |
@@ -771,8 +896,29 @@ struct drm_device { | |||
771 | spinlock_t drw_lock; | 896 | spinlock_t drw_lock; |
772 | struct idr drw_idr; | 897 | struct idr drw_idr; |
773 | /*@} */ | 898 | /*@} */ |
899 | |||
900 | /** \name GEM information */ | ||
901 | /*@{ */ | ||
902 | spinlock_t object_name_lock; | ||
903 | struct idr object_name_idr; | ||
904 | atomic_t object_count; | ||
905 | atomic_t object_memory; | ||
906 | atomic_t pin_count; | ||
907 | atomic_t pin_memory; | ||
908 | atomic_t gtt_count; | ||
909 | atomic_t gtt_memory; | ||
910 | uint32_t gtt_total; | ||
911 | uint32_t invalidate_domains; /* domains pending invalidation */ | ||
912 | uint32_t flush_domains; /* domains pending flush */ | ||
913 | /*@} */ | ||
914 | |||
774 | }; | 915 | }; |
775 | 916 | ||
917 | static inline int drm_dev_to_irq(struct drm_device *dev) | ||
918 | { | ||
919 | return dev->pdev->irq; | ||
920 | } | ||
921 | |||
776 | static __inline__ int drm_core_check_feature(struct drm_device *dev, | 922 | static __inline__ int drm_core_check_feature(struct drm_device *dev, |
777 | int feature) | 923 | int feature) |
778 | { | 924 | { |
@@ -867,6 +1013,11 @@ extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area); | |||
867 | extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type); | 1013 | extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type); |
868 | extern int drm_free_agp(DRM_AGP_MEM * handle, int pages); | 1014 | extern int drm_free_agp(DRM_AGP_MEM * handle, int pages); |
869 | extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start); | 1015 | extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start); |
1016 | extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev, | ||
1017 | struct page **pages, | ||
1018 | unsigned long num_pages, | ||
1019 | uint32_t gtt_offset, | ||
1020 | uint32_t type); | ||
870 | extern int drm_unbind_agp(DRM_AGP_MEM * handle); | 1021 | extern int drm_unbind_agp(DRM_AGP_MEM * handle); |
871 | 1022 | ||
872 | /* Misc. IOCTL support (drm_ioctl.h) */ | 1023 | /* Misc. IOCTL support (drm_ioctl.h) */ |
@@ -929,6 +1080,9 @@ extern int drm_getmagic(struct drm_device *dev, void *data, | |||
929 | extern int drm_authmagic(struct drm_device *dev, void *data, | 1080 | extern int drm_authmagic(struct drm_device *dev, void *data, |
930 | struct drm_file *file_priv); | 1081 | struct drm_file *file_priv); |
931 | 1082 | ||
1083 | /* Cache management (drm_cache.c) */ | ||
1084 | void drm_clflush_pages(struct page *pages[], unsigned long num_pages); | ||
1085 | |||
932 | /* Locking IOCTL support (drm_lock.h) */ | 1086 | /* Locking IOCTL support (drm_lock.h) */ |
933 | extern int drm_lock(struct drm_device *dev, void *data, | 1087 | extern int drm_lock(struct drm_device *dev, void *data, |
934 | struct drm_file *file_priv); | 1088 | struct drm_file *file_priv); |
@@ -985,15 +1139,25 @@ extern void drm_core_reclaim_buffers(struct drm_device *dev, | |||
985 | extern int drm_control(struct drm_device *dev, void *data, | 1139 | extern int drm_control(struct drm_device *dev, void *data, |
986 | struct drm_file *file_priv); | 1140 | struct drm_file *file_priv); |
987 | extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS); | 1141 | extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS); |
1142 | extern int drm_irq_install(struct drm_device *dev); | ||
988 | extern int drm_irq_uninstall(struct drm_device *dev); | 1143 | extern int drm_irq_uninstall(struct drm_device *dev); |
989 | extern void drm_driver_irq_preinstall(struct drm_device *dev); | 1144 | extern void drm_driver_irq_preinstall(struct drm_device *dev); |
990 | extern void drm_driver_irq_postinstall(struct drm_device *dev); | 1145 | extern void drm_driver_irq_postinstall(struct drm_device *dev); |
991 | extern void drm_driver_irq_uninstall(struct drm_device *dev); | 1146 | extern void drm_driver_irq_uninstall(struct drm_device *dev); |
992 | 1147 | ||
1148 | extern int drm_vblank_init(struct drm_device *dev, int num_crtcs); | ||
993 | extern int drm_wait_vblank(struct drm_device *dev, void *data, | 1149 | extern int drm_wait_vblank(struct drm_device *dev, void *data, |
994 | struct drm_file *file_priv); | 1150 | struct drm_file *filp); |
995 | extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq); | 1151 | extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq); |
996 | extern void drm_vbl_send_signals(struct drm_device *dev); | 1152 | extern void drm_locked_tasklet(struct drm_device *dev, |
1153 | void(*func)(struct drm_device *)); | ||
1154 | extern u32 drm_vblank_count(struct drm_device *dev, int crtc); | ||
1155 | extern void drm_handle_vblank(struct drm_device *dev, int crtc); | ||
1156 | extern int drm_vblank_get(struct drm_device *dev, int crtc); | ||
1157 | extern void drm_vblank_put(struct drm_device *dev, int crtc); | ||
1158 | /* Modesetting support */ | ||
1159 | extern int drm_modeset_ctl(struct drm_device *dev, void *data, | ||
1160 | struct drm_file *file_priv); | ||
997 | extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*)); | 1161 | extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*)); |
998 | 1162 | ||
999 | /* AGP/GART support (drm_agpsupport.h) */ | 1163 | /* AGP/GART support (drm_agpsupport.h) */ |
@@ -1026,6 +1190,7 @@ extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size | |||
1026 | extern int drm_agp_free_memory(DRM_AGP_MEM * handle); | 1190 | extern int drm_agp_free_memory(DRM_AGP_MEM * handle); |
1027 | extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start); | 1191 | extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start); |
1028 | extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle); | 1192 | extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle); |
1193 | extern void drm_agp_chipset_flush(struct drm_device *dev); | ||
1029 | 1194 | ||
1030 | /* Stub support (drm_stub.h) */ | 1195 | /* Stub support (drm_stub.h) */ |
1031 | extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, | 1196 | extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, |
@@ -1088,6 +1253,66 @@ extern unsigned long drm_mm_tail_space(struct drm_mm *mm); | |||
1088 | extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size); | 1253 | extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size); |
1089 | extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size); | 1254 | extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size); |
1090 | 1255 | ||
1256 | /* Graphics Execution Manager library functions (drm_gem.c) */ | ||
1257 | int drm_gem_init(struct drm_device *dev); | ||
1258 | void drm_gem_object_free(struct kref *kref); | ||
1259 | struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev, | ||
1260 | size_t size); | ||
1261 | void drm_gem_object_handle_free(struct kref *kref); | ||
1262 | |||
1263 | static inline void | ||
1264 | drm_gem_object_reference(struct drm_gem_object *obj) | ||
1265 | { | ||
1266 | kref_get(&obj->refcount); | ||
1267 | } | ||
1268 | |||
1269 | static inline void | ||
1270 | drm_gem_object_unreference(struct drm_gem_object *obj) | ||
1271 | { | ||
1272 | if (obj == NULL) | ||
1273 | return; | ||
1274 | |||
1275 | kref_put(&obj->refcount, drm_gem_object_free); | ||
1276 | } | ||
1277 | |||
1278 | int drm_gem_handle_create(struct drm_file *file_priv, | ||
1279 | struct drm_gem_object *obj, | ||
1280 | int *handlep); | ||
1281 | |||
1282 | static inline void | ||
1283 | drm_gem_object_handle_reference(struct drm_gem_object *obj) | ||
1284 | { | ||
1285 | drm_gem_object_reference(obj); | ||
1286 | kref_get(&obj->handlecount); | ||
1287 | } | ||
1288 | |||
1289 | static inline void | ||
1290 | drm_gem_object_handle_unreference(struct drm_gem_object *obj) | ||
1291 | { | ||
1292 | if (obj == NULL) | ||
1293 | return; | ||
1294 | |||
1295 | /* | ||
1296 | * Must bump handle count first as this may be the last | ||
1297 | * ref, in which case the object would disappear before we | ||
1298 | * checked for a name | ||
1299 | */ | ||
1300 | kref_put(&obj->handlecount, drm_gem_object_handle_free); | ||
1301 | drm_gem_object_unreference(obj); | ||
1302 | } | ||
1303 | |||
1304 | struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev, | ||
1305 | struct drm_file *filp, | ||
1306 | int handle); | ||
1307 | int drm_gem_close_ioctl(struct drm_device *dev, void *data, | ||
1308 | struct drm_file *file_priv); | ||
1309 | int drm_gem_flink_ioctl(struct drm_device *dev, void *data, | ||
1310 | struct drm_file *file_priv); | ||
1311 | int drm_gem_open_ioctl(struct drm_device *dev, void *data, | ||
1312 | struct drm_file *file_priv); | ||
1313 | void drm_gem_open(struct drm_device *dev, struct drm_file *file_private); | ||
1314 | void drm_gem_release(struct drm_device *dev, struct drm_file *file_private); | ||
1315 | |||
1091 | extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev); | 1316 | extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev); |
1092 | extern void drm_core_ioremap_wc(struct drm_map *map, struct drm_device *dev); | 1317 | extern void drm_core_ioremap_wc(struct drm_map *map, struct drm_device *dev); |
1093 | extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev); | 1318 | extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev); |
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h index 135bd19499fc..da04109741e8 100644 --- a/include/drm/drm_pciids.h +++ b/include/drm/drm_pciids.h | |||
@@ -84,18 +84,18 @@ | |||
84 | {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | 84 | {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
85 | {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | 85 | {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
86 | {0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | 86 | {0x1002, 0x5657, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ |
87 | {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 87 | {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
88 | {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 88 | {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
89 | {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 89 | {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
90 | {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 90 | {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
91 | {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 91 | {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
92 | {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 92 | {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
93 | {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 93 | {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
94 | {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 94 | {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
95 | {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 95 | {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
96 | {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 96 | {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
97 | {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 97 | {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
98 | {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 98 | {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
99 | {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 99 | {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
100 | {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 100 | {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
101 | {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 101 | {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
@@ -113,8 +113,10 @@ | |||
113 | {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ | 113 | {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ |
114 | {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ | 114 | {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ |
115 | {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ | 115 | {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ |
116 | {0x1002, 0x5a61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS480|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ | 116 | {0x1002, 0x5a41, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ |
117 | {0x1002, 0x5a62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS480|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ | 117 | {0x1002, 0x5a42, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ |
118 | {0x1002, 0x5a61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ | ||
119 | {0x1002, 0x5a62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ | ||
118 | {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | 120 | {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ |
119 | {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | 121 | {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ |
120 | {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | 122 | {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ |
@@ -122,16 +124,16 @@ | |||
122 | {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ | 124 | {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \ |
123 | {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \ | 125 | {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \ |
124 | {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \ | 126 | {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \ |
125 | {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 127 | {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
126 | {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 128 | {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
127 | {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 129 | {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
128 | {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 130 | {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
129 | {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 131 | {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
130 | {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 132 | {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
131 | {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 133 | {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
132 | {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 134 | {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
133 | {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 135 | {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
134 | {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \ | 136 | {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R423|RADEON_NEW_MEMMAP}, \ |
135 | {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ | 137 | {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ |
136 | {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ | 138 | {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ |
137 | {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ | 139 | {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \ |
@@ -237,6 +239,10 @@ | |||
237 | {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ | 239 | {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
238 | {0x1002, 0x791e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | 240 | {0x1002, 0x791e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ |
239 | {0x1002, 0x791f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | 241 | {0x1002, 0x791f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ |
242 | {0x1002, 0x796c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS740|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | ||
243 | {0x1002, 0x796d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS740|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | ||
244 | {0x1002, 0x796e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS740|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | ||
245 | {0x1002, 0x796f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS740|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \ | ||
240 | {0, 0, 0} | 246 | {0, 0, 0} |
241 | 247 | ||
242 | #define r128_PCI_IDS \ | 248 | #define r128_PCI_IDS \ |
diff --git a/include/drm/i915_drm.h b/include/drm/i915_drm.h index 05c66cf03a9e..eb4b35031a55 100644 --- a/include/drm/i915_drm.h +++ b/include/drm/i915_drm.h | |||
@@ -143,6 +143,22 @@ typedef struct _drm_i915_sarea { | |||
143 | #define DRM_I915_GET_VBLANK_PIPE 0x0e | 143 | #define DRM_I915_GET_VBLANK_PIPE 0x0e |
144 | #define DRM_I915_VBLANK_SWAP 0x0f | 144 | #define DRM_I915_VBLANK_SWAP 0x0f |
145 | #define DRM_I915_HWS_ADDR 0x11 | 145 | #define DRM_I915_HWS_ADDR 0x11 |
146 | #define DRM_I915_GEM_INIT 0x13 | ||
147 | #define DRM_I915_GEM_EXECBUFFER 0x14 | ||
148 | #define DRM_I915_GEM_PIN 0x15 | ||
149 | #define DRM_I915_GEM_UNPIN 0x16 | ||
150 | #define DRM_I915_GEM_BUSY 0x17 | ||
151 | #define DRM_I915_GEM_THROTTLE 0x18 | ||
152 | #define DRM_I915_GEM_ENTERVT 0x19 | ||
153 | #define DRM_I915_GEM_LEAVEVT 0x1a | ||
154 | #define DRM_I915_GEM_CREATE 0x1b | ||
155 | #define DRM_I915_GEM_PREAD 0x1c | ||
156 | #define DRM_I915_GEM_PWRITE 0x1d | ||
157 | #define DRM_I915_GEM_MMAP 0x1e | ||
158 | #define DRM_I915_GEM_SET_DOMAIN 0x1f | ||
159 | #define DRM_I915_GEM_SW_FINISH 0x20 | ||
160 | #define DRM_I915_GEM_SET_TILING 0x21 | ||
161 | #define DRM_I915_GEM_GET_TILING 0x22 | ||
146 | 162 | ||
147 | #define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t) | 163 | #define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t) |
148 | #define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH) | 164 | #define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH) |
@@ -160,6 +176,20 @@ typedef struct _drm_i915_sarea { | |||
160 | #define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t) | 176 | #define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t) |
161 | #define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t) | 177 | #define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t) |
162 | #define DRM_IOCTL_I915_VBLANK_SWAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t) | 178 | #define DRM_IOCTL_I915_VBLANK_SWAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t) |
179 | #define DRM_IOCTL_I915_GEM_PIN DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_PIN, struct drm_i915_gem_pin) | ||
180 | #define DRM_IOCTL_I915_GEM_UNPIN DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_UNPIN, struct drm_i915_gem_unpin) | ||
181 | #define DRM_IOCTL_I915_GEM_BUSY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_BUSY, struct drm_i915_gem_busy) | ||
182 | #define DRM_IOCTL_I915_GEM_THROTTLE DRM_IO ( DRM_COMMAND_BASE + DRM_I915_GEM_THROTTLE) | ||
183 | #define DRM_IOCTL_I915_GEM_ENTERVT DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_ENTERVT) | ||
184 | #define DRM_IOCTL_I915_GEM_LEAVEVT DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_LEAVEVT) | ||
185 | #define DRM_IOCTL_I915_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE, struct drm_i915_gem_create) | ||
186 | #define DRM_IOCTL_I915_GEM_PREAD DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PREAD, struct drm_i915_gem_pread) | ||
187 | #define DRM_IOCTL_I915_GEM_PWRITE DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PWRITE, struct drm_i915_gem_pwrite) | ||
188 | #define DRM_IOCTL_I915_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP, struct drm_i915_gem_mmap) | ||
189 | #define DRM_IOCTL_I915_GEM_SET_DOMAIN DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SET_DOMAIN, struct drm_i915_gem_set_domain) | ||
190 | #define DRM_IOCTL_I915_GEM_SW_FINISH DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SW_FINISH, struct drm_i915_gem_sw_finish) | ||
191 | #define DRM_IOCTL_I915_GEM_SET_TILING DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_SET_TILING, struct drm_i915_gem_set_tiling) | ||
192 | #define DRM_IOCTL_I915_GEM_GET_TILING DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_TILING, struct drm_i915_gem_get_tiling) | ||
163 | 193 | ||
164 | /* Allow drivers to submit batchbuffers directly to hardware, relying | 194 | /* Allow drivers to submit batchbuffers directly to hardware, relying |
165 | * on the security mechanisms provided by hardware. | 195 | * on the security mechanisms provided by hardware. |
@@ -200,6 +230,8 @@ typedef struct drm_i915_irq_wait { | |||
200 | #define I915_PARAM_IRQ_ACTIVE 1 | 230 | #define I915_PARAM_IRQ_ACTIVE 1 |
201 | #define I915_PARAM_ALLOW_BATCHBUFFER 2 | 231 | #define I915_PARAM_ALLOW_BATCHBUFFER 2 |
202 | #define I915_PARAM_LAST_DISPATCH 3 | 232 | #define I915_PARAM_LAST_DISPATCH 3 |
233 | #define I915_PARAM_CHIPSET_ID 4 | ||
234 | #define I915_PARAM_HAS_GEM 5 | ||
203 | 235 | ||
204 | typedef struct drm_i915_getparam { | 236 | typedef struct drm_i915_getparam { |
205 | int param; | 237 | int param; |
@@ -267,4 +299,305 @@ typedef struct drm_i915_hws_addr { | |||
267 | uint64_t addr; | 299 | uint64_t addr; |
268 | } drm_i915_hws_addr_t; | 300 | } drm_i915_hws_addr_t; |
269 | 301 | ||
302 | struct drm_i915_gem_init { | ||
303 | /** | ||
304 | * Beginning offset in the GTT to be managed by the DRM memory | ||
305 | * manager. | ||
306 | */ | ||
307 | uint64_t gtt_start; | ||
308 | /** | ||
309 | * Ending offset in the GTT to be managed by the DRM memory | ||
310 | * manager. | ||
311 | */ | ||
312 | uint64_t gtt_end; | ||
313 | }; | ||
314 | |||
315 | struct drm_i915_gem_create { | ||
316 | /** | ||
317 | * Requested size for the object. | ||
318 | * | ||
319 | * The (page-aligned) allocated size for the object will be returned. | ||
320 | */ | ||
321 | uint64_t size; | ||
322 | /** | ||
323 | * Returned handle for the object. | ||
324 | * | ||
325 | * Object handles are nonzero. | ||
326 | */ | ||
327 | uint32_t handle; | ||
328 | uint32_t pad; | ||
329 | }; | ||
330 | |||
331 | struct drm_i915_gem_pread { | ||
332 | /** Handle for the object being read. */ | ||
333 | uint32_t handle; | ||
334 | uint32_t pad; | ||
335 | /** Offset into the object to read from */ | ||
336 | uint64_t offset; | ||
337 | /** Length of data to read */ | ||
338 | uint64_t size; | ||
339 | /** | ||
340 | * Pointer to write the data into. | ||
341 | * | ||
342 | * This is a fixed-size type for 32/64 compatibility. | ||
343 | */ | ||
344 | uint64_t data_ptr; | ||
345 | }; | ||
346 | |||
347 | struct drm_i915_gem_pwrite { | ||
348 | /** Handle for the object being written to. */ | ||
349 | uint32_t handle; | ||
350 | uint32_t pad; | ||
351 | /** Offset into the object to write to */ | ||
352 | uint64_t offset; | ||
353 | /** Length of data to write */ | ||
354 | uint64_t size; | ||
355 | /** | ||
356 | * Pointer to read the data from. | ||
357 | * | ||
358 | * This is a fixed-size type for 32/64 compatibility. | ||
359 | */ | ||
360 | uint64_t data_ptr; | ||
361 | }; | ||
362 | |||
363 | struct drm_i915_gem_mmap { | ||
364 | /** Handle for the object being mapped. */ | ||
365 | uint32_t handle; | ||
366 | uint32_t pad; | ||
367 | /** Offset in the object to map. */ | ||
368 | uint64_t offset; | ||
369 | /** | ||
370 | * Length of data to map. | ||
371 | * | ||
372 | * The value will be page-aligned. | ||
373 | */ | ||
374 | uint64_t size; | ||
375 | /** | ||
376 | * Returned pointer the data was mapped at. | ||
377 | * | ||
378 | * This is a fixed-size type for 32/64 compatibility. | ||
379 | */ | ||
380 | uint64_t addr_ptr; | ||
381 | }; | ||
382 | |||
383 | struct drm_i915_gem_set_domain { | ||
384 | /** Handle for the object */ | ||
385 | uint32_t handle; | ||
386 | |||
387 | /** New read domains */ | ||
388 | uint32_t read_domains; | ||
389 | |||
390 | /** New write domain */ | ||
391 | uint32_t write_domain; | ||
392 | }; | ||
393 | |||
394 | struct drm_i915_gem_sw_finish { | ||
395 | /** Handle for the object */ | ||
396 | uint32_t handle; | ||
397 | }; | ||
398 | |||
399 | struct drm_i915_gem_relocation_entry { | ||
400 | /** | ||
401 | * Handle of the buffer being pointed to by this relocation entry. | ||
402 | * | ||
403 | * It's appealing to make this be an index into the mm_validate_entry | ||
404 | * list to refer to the buffer, but this allows the driver to create | ||
405 | * a relocation list for state buffers and not re-write it per | ||
406 | * exec using the buffer. | ||
407 | */ | ||
408 | uint32_t target_handle; | ||
409 | |||
410 | /** | ||
411 | * Value to be added to the offset of the target buffer to make up | ||
412 | * the relocation entry. | ||
413 | */ | ||
414 | uint32_t delta; | ||
415 | |||
416 | /** Offset in the buffer the relocation entry will be written into */ | ||
417 | uint64_t offset; | ||
418 | |||
419 | /** | ||
420 | * Offset value of the target buffer that the relocation entry was last | ||
421 | * written as. | ||
422 | * | ||
423 | * If the buffer has the same offset as last time, we can skip syncing | ||
424 | * and writing the relocation. This value is written back out by | ||
425 | * the execbuffer ioctl when the relocation is written. | ||
426 | */ | ||
427 | uint64_t presumed_offset; | ||
428 | |||
429 | /** | ||
430 | * Target memory domains read by this operation. | ||
431 | */ | ||
432 | uint32_t read_domains; | ||
433 | |||
434 | /** | ||
435 | * Target memory domains written by this operation. | ||
436 | * | ||
437 | * Note that only one domain may be written by the whole | ||
438 | * execbuffer operation, so that where there are conflicts, | ||
439 | * the application will get -EINVAL back. | ||
440 | */ | ||
441 | uint32_t write_domain; | ||
442 | }; | ||
443 | |||
444 | /** @{ | ||
445 | * Intel memory domains | ||
446 | * | ||
447 | * Most of these just align with the various caches in | ||
448 | * the system and are used to flush and invalidate as | ||
449 | * objects end up cached in different domains. | ||
450 | */ | ||
451 | /** CPU cache */ | ||
452 | #define I915_GEM_DOMAIN_CPU 0x00000001 | ||
453 | /** Render cache, used by 2D and 3D drawing */ | ||
454 | #define I915_GEM_DOMAIN_RENDER 0x00000002 | ||
455 | /** Sampler cache, used by texture engine */ | ||
456 | #define I915_GEM_DOMAIN_SAMPLER 0x00000004 | ||
457 | /** Command queue, used to load batch buffers */ | ||
458 | #define I915_GEM_DOMAIN_COMMAND 0x00000008 | ||
459 | /** Instruction cache, used by shader programs */ | ||
460 | #define I915_GEM_DOMAIN_INSTRUCTION 0x00000010 | ||
461 | /** Vertex address cache */ | ||
462 | #define I915_GEM_DOMAIN_VERTEX 0x00000020 | ||
463 | /** GTT domain - aperture and scanout */ | ||
464 | #define I915_GEM_DOMAIN_GTT 0x00000040 | ||
465 | /** @} */ | ||
466 | |||
467 | struct drm_i915_gem_exec_object { | ||
468 | /** | ||
469 | * User's handle for a buffer to be bound into the GTT for this | ||
470 | * operation. | ||
471 | */ | ||
472 | uint32_t handle; | ||
473 | |||
474 | /** Number of relocations to be performed on this buffer */ | ||
475 | uint32_t relocation_count; | ||
476 | /** | ||
477 | * Pointer to array of struct drm_i915_gem_relocation_entry containing | ||
478 | * the relocations to be performed in this buffer. | ||
479 | */ | ||
480 | uint64_t relocs_ptr; | ||
481 | |||
482 | /** Required alignment in graphics aperture */ | ||
483 | uint64_t alignment; | ||
484 | |||
485 | /** | ||
486 | * Returned value of the updated offset of the object, for future | ||
487 | * presumed_offset writes. | ||
488 | */ | ||
489 | uint64_t offset; | ||
490 | }; | ||
491 | |||
492 | struct drm_i915_gem_execbuffer { | ||
493 | /** | ||
494 | * List of buffers to be validated with their relocations to be | ||
495 | * performend on them. | ||
496 | * | ||
497 | * This is a pointer to an array of struct drm_i915_gem_validate_entry. | ||
498 | * | ||
499 | * These buffers must be listed in an order such that all relocations | ||
500 | * a buffer is performing refer to buffers that have already appeared | ||
501 | * in the validate list. | ||
502 | */ | ||
503 | uint64_t buffers_ptr; | ||
504 | uint32_t buffer_count; | ||
505 | |||
506 | /** Offset in the batchbuffer to start execution from. */ | ||
507 | uint32_t batch_start_offset; | ||
508 | /** Bytes used in batchbuffer from batch_start_offset */ | ||
509 | uint32_t batch_len; | ||
510 | uint32_t DR1; | ||
511 | uint32_t DR4; | ||
512 | uint32_t num_cliprects; | ||
513 | /** This is a struct drm_clip_rect *cliprects */ | ||
514 | uint64_t cliprects_ptr; | ||
515 | }; | ||
516 | |||
517 | struct drm_i915_gem_pin { | ||
518 | /** Handle of the buffer to be pinned. */ | ||
519 | uint32_t handle; | ||
520 | uint32_t pad; | ||
521 | |||
522 | /** alignment required within the aperture */ | ||
523 | uint64_t alignment; | ||
524 | |||
525 | /** Returned GTT offset of the buffer. */ | ||
526 | uint64_t offset; | ||
527 | }; | ||
528 | |||
529 | struct drm_i915_gem_unpin { | ||
530 | /** Handle of the buffer to be unpinned. */ | ||
531 | uint32_t handle; | ||
532 | uint32_t pad; | ||
533 | }; | ||
534 | |||
535 | struct drm_i915_gem_busy { | ||
536 | /** Handle of the buffer to check for busy */ | ||
537 | uint32_t handle; | ||
538 | |||
539 | /** Return busy status (1 if busy, 0 if idle) */ | ||
540 | uint32_t busy; | ||
541 | }; | ||
542 | |||
543 | #define I915_TILING_NONE 0 | ||
544 | #define I915_TILING_X 1 | ||
545 | #define I915_TILING_Y 2 | ||
546 | |||
547 | #define I915_BIT_6_SWIZZLE_NONE 0 | ||
548 | #define I915_BIT_6_SWIZZLE_9 1 | ||
549 | #define I915_BIT_6_SWIZZLE_9_10 2 | ||
550 | #define I915_BIT_6_SWIZZLE_9_11 3 | ||
551 | #define I915_BIT_6_SWIZZLE_9_10_11 4 | ||
552 | /* Not seen by userland */ | ||
553 | #define I915_BIT_6_SWIZZLE_UNKNOWN 5 | ||
554 | |||
555 | struct drm_i915_gem_set_tiling { | ||
556 | /** Handle of the buffer to have its tiling state updated */ | ||
557 | uint32_t handle; | ||
558 | |||
559 | /** | ||
560 | * Tiling mode for the object (I915_TILING_NONE, I915_TILING_X, | ||
561 | * I915_TILING_Y). | ||
562 | * | ||
563 | * This value is to be set on request, and will be updated by the | ||
564 | * kernel on successful return with the actual chosen tiling layout. | ||
565 | * | ||
566 | * The tiling mode may be demoted to I915_TILING_NONE when the system | ||
567 | * has bit 6 swizzling that can't be managed correctly by GEM. | ||
568 | * | ||
569 | * Buffer contents become undefined when changing tiling_mode. | ||
570 | */ | ||
571 | uint32_t tiling_mode; | ||
572 | |||
573 | /** | ||
574 | * Stride in bytes for the object when in I915_TILING_X or | ||
575 | * I915_TILING_Y. | ||
576 | */ | ||
577 | uint32_t stride; | ||
578 | |||
579 | /** | ||
580 | * Returned address bit 6 swizzling required for CPU access through | ||
581 | * mmap mapping. | ||
582 | */ | ||
583 | uint32_t swizzle_mode; | ||
584 | }; | ||
585 | |||
586 | struct drm_i915_gem_get_tiling { | ||
587 | /** Handle of the buffer to get tiling state for. */ | ||
588 | uint32_t handle; | ||
589 | |||
590 | /** | ||
591 | * Current tiling mode for the object (I915_TILING_NONE, I915_TILING_X, | ||
592 | * I915_TILING_Y). | ||
593 | */ | ||
594 | uint32_t tiling_mode; | ||
595 | |||
596 | /** | ||
597 | * Returned address bit 6 swizzling required for CPU access through | ||
598 | * mmap mapping. | ||
599 | */ | ||
600 | uint32_t swizzle_mode; | ||
601 | }; | ||
602 | |||
270 | #endif /* _I915_DRM_H_ */ | 603 | #endif /* _I915_DRM_H_ */ |
diff --git a/include/linux/Kbuild b/include/linux/Kbuild index 282a504bd1db..e531783e5d78 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild | |||
@@ -107,6 +107,7 @@ header-y += keyctl.h | |||
107 | header-y += limits.h | 107 | header-y += limits.h |
108 | header-y += magic.h | 108 | header-y += magic.h |
109 | header-y += major.h | 109 | header-y += major.h |
110 | header-y += map_to_7segment.h | ||
110 | header-y += matroxfb.h | 111 | header-y += matroxfb.h |
111 | header-y += meye.h | 112 | header-y += meye.h |
112 | header-y += minix_fs.h | 113 | header-y += minix_fs.h |
@@ -182,6 +183,7 @@ unifdef-y += auto_fs.h | |||
182 | unifdef-y += auxvec.h | 183 | unifdef-y += auxvec.h |
183 | unifdef-y += binfmts.h | 184 | unifdef-y += binfmts.h |
184 | unifdef-y += blktrace_api.h | 185 | unifdef-y += blktrace_api.h |
186 | unifdef-y += byteorder.h | ||
185 | unifdef-y += capability.h | 187 | unifdef-y += capability.h |
186 | unifdef-y += capi.h | 188 | unifdef-y += capi.h |
187 | unifdef-y += cciss_ioctl.h | 189 | unifdef-y += cciss_ioctl.h |
@@ -339,6 +341,7 @@ unifdef-y += soundcard.h | |||
339 | unifdef-y += stat.h | 341 | unifdef-y += stat.h |
340 | unifdef-y += stddef.h | 342 | unifdef-y += stddef.h |
341 | unifdef-y += string.h | 343 | unifdef-y += string.h |
344 | unifdef-y += swab.h | ||
342 | unifdef-y += synclink.h | 345 | unifdef-y += synclink.h |
343 | unifdef-y += sysctl.h | 346 | unifdef-y += sysctl.h |
344 | unifdef-y += tcp.h | 347 | unifdef-y += tcp.h |
diff --git a/include/linux/aio.h b/include/linux/aio.h index 09b276c35227..f6b8cf99b596 100644 --- a/include/linux/aio.h +++ b/include/linux/aio.h | |||
@@ -204,12 +204,21 @@ struct kioctx { | |||
204 | /* prototypes */ | 204 | /* prototypes */ |
205 | extern unsigned aio_max_size; | 205 | extern unsigned aio_max_size; |
206 | 206 | ||
207 | #ifdef CONFIG_AIO | ||
207 | extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb); | 208 | extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb); |
208 | extern int aio_put_req(struct kiocb *iocb); | 209 | extern int aio_put_req(struct kiocb *iocb); |
209 | extern void kick_iocb(struct kiocb *iocb); | 210 | extern void kick_iocb(struct kiocb *iocb); |
210 | extern int aio_complete(struct kiocb *iocb, long res, long res2); | 211 | extern int aio_complete(struct kiocb *iocb, long res, long res2); |
211 | struct mm_struct; | 212 | struct mm_struct; |
212 | extern void exit_aio(struct mm_struct *mm); | 213 | extern void exit_aio(struct mm_struct *mm); |
214 | #else | ||
215 | static inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; } | ||
216 | static inline int aio_put_req(struct kiocb *iocb) { return 0; } | ||
217 | static inline void kick_iocb(struct kiocb *iocb) { } | ||
218 | static inline int aio_complete(struct kiocb *iocb, long res, long res2) { return 0; } | ||
219 | struct mm_struct; | ||
220 | static inline void exit_aio(struct mm_struct *mm) { } | ||
221 | #endif /* CONFIG_AIO */ | ||
213 | 222 | ||
214 | #define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait) | 223 | #define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait) |
215 | 224 | ||
diff --git a/include/linux/auto_dev-ioctl.h b/include/linux/auto_dev-ioctl.h new file mode 100644 index 000000000000..f4d05ccd731f --- /dev/null +++ b/include/linux/auto_dev-ioctl.h | |||
@@ -0,0 +1,157 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Red Hat, Inc. All rights reserved. | ||
3 | * Copyright 2008 Ian Kent <raven@themaw.net> | ||
4 | * | ||
5 | * This file is part of the Linux kernel and is made available under | ||
6 | * the terms of the GNU General Public License, version 2, or at your | ||
7 | * option, any later version, incorporated herein by reference. | ||
8 | */ | ||
9 | |||
10 | #ifndef _LINUX_AUTO_DEV_IOCTL_H | ||
11 | #define _LINUX_AUTO_DEV_IOCTL_H | ||
12 | |||
13 | #include <linux/types.h> | ||
14 | |||
15 | #define AUTOFS_DEVICE_NAME "autofs" | ||
16 | |||
17 | #define AUTOFS_DEV_IOCTL_VERSION_MAJOR 1 | ||
18 | #define AUTOFS_DEV_IOCTL_VERSION_MINOR 0 | ||
19 | |||
20 | #define AUTOFS_DEVID_LEN 16 | ||
21 | |||
22 | #define AUTOFS_DEV_IOCTL_SIZE sizeof(struct autofs_dev_ioctl) | ||
23 | |||
24 | /* | ||
25 | * An ioctl interface for autofs mount point control. | ||
26 | */ | ||
27 | |||
28 | /* | ||
29 | * All the ioctls use this structure. | ||
30 | * When sending a path size must account for the total length | ||
31 | * of the chunk of memory otherwise is is the size of the | ||
32 | * structure. | ||
33 | */ | ||
34 | |||
35 | struct autofs_dev_ioctl { | ||
36 | __u32 ver_major; | ||
37 | __u32 ver_minor; | ||
38 | __u32 size; /* total size of data passed in | ||
39 | * including this struct */ | ||
40 | __s32 ioctlfd; /* automount command fd */ | ||
41 | |||
42 | __u32 arg1; /* Command parameters */ | ||
43 | __u32 arg2; | ||
44 | |||
45 | char path[0]; | ||
46 | }; | ||
47 | |||
48 | static inline void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) | ||
49 | { | ||
50 | in->ver_major = AUTOFS_DEV_IOCTL_VERSION_MAJOR; | ||
51 | in->ver_minor = AUTOFS_DEV_IOCTL_VERSION_MINOR; | ||
52 | in->size = sizeof(struct autofs_dev_ioctl); | ||
53 | in->ioctlfd = -1; | ||
54 | in->arg1 = 0; | ||
55 | in->arg2 = 0; | ||
56 | return; | ||
57 | } | ||
58 | |||
59 | /* | ||
60 | * If you change this make sure you make the corresponding change | ||
61 | * to autofs-dev-ioctl.c:lookup_ioctl() | ||
62 | */ | ||
63 | enum { | ||
64 | /* Get various version info */ | ||
65 | AUTOFS_DEV_IOCTL_VERSION_CMD = 0x71, | ||
66 | AUTOFS_DEV_IOCTL_PROTOVER_CMD, | ||
67 | AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD, | ||
68 | |||
69 | /* Open mount ioctl fd */ | ||
70 | AUTOFS_DEV_IOCTL_OPENMOUNT_CMD, | ||
71 | |||
72 | /* Close mount ioctl fd */ | ||
73 | AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD, | ||
74 | |||
75 | /* Mount/expire status returns */ | ||
76 | AUTOFS_DEV_IOCTL_READY_CMD, | ||
77 | AUTOFS_DEV_IOCTL_FAIL_CMD, | ||
78 | |||
79 | /* Activate/deactivate autofs mount */ | ||
80 | AUTOFS_DEV_IOCTL_SETPIPEFD_CMD, | ||
81 | AUTOFS_DEV_IOCTL_CATATONIC_CMD, | ||
82 | |||
83 | /* Expiry timeout */ | ||
84 | AUTOFS_DEV_IOCTL_TIMEOUT_CMD, | ||
85 | |||
86 | /* Get mount last requesting uid and gid */ | ||
87 | AUTOFS_DEV_IOCTL_REQUESTER_CMD, | ||
88 | |||
89 | /* Check for eligible expire candidates */ | ||
90 | AUTOFS_DEV_IOCTL_EXPIRE_CMD, | ||
91 | |||
92 | /* Request busy status */ | ||
93 | AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD, | ||
94 | |||
95 | /* Check if path is a mountpoint */ | ||
96 | AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD, | ||
97 | }; | ||
98 | |||
99 | #define AUTOFS_IOCTL 0x93 | ||
100 | |||
101 | #define AUTOFS_DEV_IOCTL_VERSION \ | ||
102 | _IOWR(AUTOFS_IOCTL, \ | ||
103 | AUTOFS_DEV_IOCTL_VERSION_CMD, struct autofs_dev_ioctl) | ||
104 | |||
105 | #define AUTOFS_DEV_IOCTL_PROTOVER \ | ||
106 | _IOWR(AUTOFS_IOCTL, \ | ||
107 | AUTOFS_DEV_IOCTL_PROTOVER_CMD, struct autofs_dev_ioctl) | ||
108 | |||
109 | #define AUTOFS_DEV_IOCTL_PROTOSUBVER \ | ||
110 | _IOWR(AUTOFS_IOCTL, \ | ||
111 | AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD, struct autofs_dev_ioctl) | ||
112 | |||
113 | #define AUTOFS_DEV_IOCTL_OPENMOUNT \ | ||
114 | _IOWR(AUTOFS_IOCTL, \ | ||
115 | AUTOFS_DEV_IOCTL_OPENMOUNT_CMD, struct autofs_dev_ioctl) | ||
116 | |||
117 | #define AUTOFS_DEV_IOCTL_CLOSEMOUNT \ | ||
118 | _IOWR(AUTOFS_IOCTL, \ | ||
119 | AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD, struct autofs_dev_ioctl) | ||
120 | |||
121 | #define AUTOFS_DEV_IOCTL_READY \ | ||
122 | _IOWR(AUTOFS_IOCTL, \ | ||
123 | AUTOFS_DEV_IOCTL_READY_CMD, struct autofs_dev_ioctl) | ||
124 | |||
125 | #define AUTOFS_DEV_IOCTL_FAIL \ | ||
126 | _IOWR(AUTOFS_IOCTL, \ | ||
127 | AUTOFS_DEV_IOCTL_FAIL_CMD, struct autofs_dev_ioctl) | ||
128 | |||
129 | #define AUTOFS_DEV_IOCTL_SETPIPEFD \ | ||
130 | _IOWR(AUTOFS_IOCTL, \ | ||
131 | AUTOFS_DEV_IOCTL_SETPIPEFD_CMD, struct autofs_dev_ioctl) | ||
132 | |||
133 | #define AUTOFS_DEV_IOCTL_CATATONIC \ | ||
134 | _IOWR(AUTOFS_IOCTL, \ | ||
135 | AUTOFS_DEV_IOCTL_CATATONIC_CMD, struct autofs_dev_ioctl) | ||
136 | |||
137 | #define AUTOFS_DEV_IOCTL_TIMEOUT \ | ||
138 | _IOWR(AUTOFS_IOCTL, \ | ||
139 | AUTOFS_DEV_IOCTL_TIMEOUT_CMD, struct autofs_dev_ioctl) | ||
140 | |||
141 | #define AUTOFS_DEV_IOCTL_REQUESTER \ | ||
142 | _IOWR(AUTOFS_IOCTL, \ | ||
143 | AUTOFS_DEV_IOCTL_REQUESTER_CMD, struct autofs_dev_ioctl) | ||
144 | |||
145 | #define AUTOFS_DEV_IOCTL_EXPIRE \ | ||
146 | _IOWR(AUTOFS_IOCTL, \ | ||
147 | AUTOFS_DEV_IOCTL_EXPIRE_CMD, struct autofs_dev_ioctl) | ||
148 | |||
149 | #define AUTOFS_DEV_IOCTL_ASKUMOUNT \ | ||
150 | _IOWR(AUTOFS_IOCTL, \ | ||
151 | AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD, struct autofs_dev_ioctl) | ||
152 | |||
153 | #define AUTOFS_DEV_IOCTL_ISMOUNTPOINT \ | ||
154 | _IOWR(AUTOFS_IOCTL, \ | ||
155 | AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD, struct autofs_dev_ioctl) | ||
156 | |||
157 | #endif /* _LINUX_AUTO_DEV_IOCTL_H */ | ||
diff --git a/include/linux/auto_fs4.h b/include/linux/auto_fs4.h index b785c6f8644d..2253716d4b92 100644 --- a/include/linux/auto_fs4.h +++ b/include/linux/auto_fs4.h | |||
@@ -23,12 +23,17 @@ | |||
23 | #define AUTOFS_MIN_PROTO_VERSION 3 | 23 | #define AUTOFS_MIN_PROTO_VERSION 3 |
24 | #define AUTOFS_MAX_PROTO_VERSION 5 | 24 | #define AUTOFS_MAX_PROTO_VERSION 5 |
25 | 25 | ||
26 | #define AUTOFS_PROTO_SUBVERSION 0 | 26 | #define AUTOFS_PROTO_SUBVERSION 1 |
27 | 27 | ||
28 | /* Mask for expire behaviour */ | 28 | /* Mask for expire behaviour */ |
29 | #define AUTOFS_EXP_IMMEDIATE 1 | 29 | #define AUTOFS_EXP_IMMEDIATE 1 |
30 | #define AUTOFS_EXP_LEAVES 2 | 30 | #define AUTOFS_EXP_LEAVES 2 |
31 | 31 | ||
32 | #define AUTOFS_TYPE_ANY 0x0000 | ||
33 | #define AUTOFS_TYPE_INDIRECT 0x0001 | ||
34 | #define AUTOFS_TYPE_DIRECT 0x0002 | ||
35 | #define AUTOFS_TYPE_OFFSET 0x0004 | ||
36 | |||
32 | /* Daemon notification packet types */ | 37 | /* Daemon notification packet types */ |
33 | enum autofs_notify { | 38 | enum autofs_notify { |
34 | NFY_NONE, | 39 | NFY_NONE, |
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h index 0a24d5550eb3..bee52abb8a4d 100644 --- a/include/linux/backing-dev.h +++ b/include/linux/backing-dev.h | |||
@@ -175,6 +175,8 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio); | |||
175 | * BDI_CAP_READ_MAP: Can be mapped for reading | 175 | * BDI_CAP_READ_MAP: Can be mapped for reading |
176 | * BDI_CAP_WRITE_MAP: Can be mapped for writing | 176 | * BDI_CAP_WRITE_MAP: Can be mapped for writing |
177 | * BDI_CAP_EXEC_MAP: Can be mapped for execution | 177 | * BDI_CAP_EXEC_MAP: Can be mapped for execution |
178 | * | ||
179 | * BDI_CAP_SWAP_BACKED: Count shmem/tmpfs objects as swap-backed. | ||
178 | */ | 180 | */ |
179 | #define BDI_CAP_NO_ACCT_DIRTY 0x00000001 | 181 | #define BDI_CAP_NO_ACCT_DIRTY 0x00000001 |
180 | #define BDI_CAP_NO_WRITEBACK 0x00000002 | 182 | #define BDI_CAP_NO_WRITEBACK 0x00000002 |
@@ -184,6 +186,7 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio); | |||
184 | #define BDI_CAP_WRITE_MAP 0x00000020 | 186 | #define BDI_CAP_WRITE_MAP 0x00000020 |
185 | #define BDI_CAP_EXEC_MAP 0x00000040 | 187 | #define BDI_CAP_EXEC_MAP 0x00000040 |
186 | #define BDI_CAP_NO_ACCT_WB 0x00000080 | 188 | #define BDI_CAP_NO_ACCT_WB 0x00000080 |
189 | #define BDI_CAP_SWAP_BACKED 0x00000100 | ||
187 | 190 | ||
188 | #define BDI_CAP_VMFLAGS \ | 191 | #define BDI_CAP_VMFLAGS \ |
189 | (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP) | 192 | (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP) |
@@ -248,6 +251,11 @@ static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi) | |||
248 | BDI_CAP_NO_WRITEBACK)); | 251 | BDI_CAP_NO_WRITEBACK)); |
249 | } | 252 | } |
250 | 253 | ||
254 | static inline bool bdi_cap_swap_backed(struct backing_dev_info *bdi) | ||
255 | { | ||
256 | return bdi->capabilities & BDI_CAP_SWAP_BACKED; | ||
257 | } | ||
258 | |||
251 | static inline bool mapping_cap_writeback_dirty(struct address_space *mapping) | 259 | static inline bool mapping_cap_writeback_dirty(struct address_space *mapping) |
252 | { | 260 | { |
253 | return bdi_cap_writeback_dirty(mapping->backing_dev_info); | 261 | return bdi_cap_writeback_dirty(mapping->backing_dev_info); |
@@ -258,4 +266,9 @@ static inline bool mapping_cap_account_dirty(struct address_space *mapping) | |||
258 | return bdi_cap_account_dirty(mapping->backing_dev_info); | 266 | return bdi_cap_account_dirty(mapping->backing_dev_info); |
259 | } | 267 | } |
260 | 268 | ||
269 | static inline bool mapping_cap_swap_backed(struct address_space *mapping) | ||
270 | { | ||
271 | return bdi_cap_swap_backed(mapping->backing_dev_info); | ||
272 | } | ||
273 | |||
261 | #endif /* _LINUX_BACKING_DEV_H */ | 274 | #endif /* _LINUX_BACKING_DEV_H */ |
diff --git a/include/linux/bcd.h b/include/linux/bcd.h index 7ac518e3c152..22ea563ba3eb 100644 --- a/include/linux/bcd.h +++ b/include/linux/bcd.h | |||
@@ -1,12 +1,3 @@ | |||
1 | /* Permission is hereby granted to copy, modify and redistribute this code | ||
2 | * in terms of the GNU Library General Public License, Version 2 or later, | ||
3 | * at your option. | ||
4 | */ | ||
5 | |||
6 | /* macros to translate to/from binary and binary-coded decimal (frequently | ||
7 | * found in RTC chips). | ||
8 | */ | ||
9 | |||
10 | #ifndef _BCD_H | 1 | #ifndef _BCD_H |
11 | #define _BCD_H | 2 | #define _BCD_H |
12 | 3 | ||
@@ -15,11 +6,4 @@ | |||
15 | unsigned bcd2bin(unsigned char val) __attribute_const__; | 6 | unsigned bcd2bin(unsigned char val) __attribute_const__; |
16 | unsigned char bin2bcd(unsigned val) __attribute_const__; | 7 | unsigned char bin2bcd(unsigned val) __attribute_const__; |
17 | 8 | ||
18 | #define BCD2BIN(val) bcd2bin(val) | ||
19 | #define BIN2BCD(val) bin2bcd(val) | ||
20 | |||
21 | /* backwards compat */ | ||
22 | #define BCD_TO_BIN(val) ((val)=BCD2BIN(val)) | ||
23 | #define BIN_TO_BCD(val) ((val)=BIN2BCD(val)) | ||
24 | |||
25 | #endif /* _BCD_H */ | 9 | #endif /* _BCD_H */ |
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h index 826f62350805..7394b5b349ff 100644 --- a/include/linux/binfmts.h +++ b/include/linux/binfmts.h | |||
@@ -36,6 +36,10 @@ struct linux_binprm{ | |||
36 | unsigned long p; /* current top of mem */ | 36 | unsigned long p; /* current top of mem */ |
37 | unsigned int sh_bang:1, | 37 | unsigned int sh_bang:1, |
38 | misc_bang:1; | 38 | misc_bang:1; |
39 | #ifdef __alpha__ | ||
40 | unsigned int taso:1; | ||
41 | #endif | ||
42 | unsigned int recursion_depth; | ||
39 | struct file * file; | 43 | struct file * file; |
40 | int e_uid, e_gid; | 44 | int e_uid, e_gid; |
41 | kernel_cap_t cap_post_exec_permitted; | 45 | kernel_cap_t cap_post_exec_permitted; |
@@ -58,6 +62,7 @@ struct linux_binprm{ | |||
58 | #define BINPRM_FLAGS_EXECFD_BIT 1 | 62 | #define BINPRM_FLAGS_EXECFD_BIT 1 |
59 | #define BINPRM_FLAGS_EXECFD (1 << BINPRM_FLAGS_EXECFD_BIT) | 63 | #define BINPRM_FLAGS_EXECFD (1 << BINPRM_FLAGS_EXECFD_BIT) |
60 | 64 | ||
65 | #define BINPRM_MAX_RECURSION 4 | ||
61 | 66 | ||
62 | /* | 67 | /* |
63 | * This structure defines the functions that are used to load the binary formats that | 68 | * This structure defines the functions that are used to load the binary formats that |
diff --git a/include/linux/bio.h b/include/linux/bio.h index ff5b4cf9e2da..1c91a176b9ae 100644 --- a/include/linux/bio.h +++ b/include/linux/bio.h | |||
@@ -79,6 +79,13 @@ struct bio { | |||
79 | 79 | ||
80 | unsigned int bi_size; /* residual I/O count */ | 80 | unsigned int bi_size; /* residual I/O count */ |
81 | 81 | ||
82 | /* | ||
83 | * To keep track of the max segment size, we account for the | ||
84 | * sizes of the first and last mergeable segments in this bio. | ||
85 | */ | ||
86 | unsigned int bi_seg_front_size; | ||
87 | unsigned int bi_seg_back_size; | ||
88 | |||
82 | unsigned int bi_max_vecs; /* max bvl_vecs we can hold */ | 89 | unsigned int bi_max_vecs; /* max bvl_vecs we can hold */ |
83 | 90 | ||
84 | unsigned int bi_comp_cpu; /* completion CPU */ | 91 | unsigned int bi_comp_cpu; /* completion CPU */ |
@@ -129,25 +136,30 @@ struct bio { | |||
129 | * bit 2 -- barrier | 136 | * bit 2 -- barrier |
130 | * Insert a serialization point in the IO queue, forcing previously | 137 | * Insert a serialization point in the IO queue, forcing previously |
131 | * submitted IO to be completed before this oen is issued. | 138 | * submitted IO to be completed before this oen is issued. |
132 | * bit 3 -- fail fast, don't want low level driver retries | 139 | * bit 3 -- synchronous I/O hint: the block layer will unplug immediately |
133 | * bit 4 -- synchronous I/O hint: the block layer will unplug immediately | ||
134 | * Note that this does NOT indicate that the IO itself is sync, just | 140 | * Note that this does NOT indicate that the IO itself is sync, just |
135 | * that the block layer will not postpone issue of this IO by plugging. | 141 | * that the block layer will not postpone issue of this IO by plugging. |
136 | * bit 5 -- metadata request | 142 | * bit 4 -- metadata request |
137 | * Used for tracing to differentiate metadata and data IO. May also | 143 | * Used for tracing to differentiate metadata and data IO. May also |
138 | * get some preferential treatment in the IO scheduler | 144 | * get some preferential treatment in the IO scheduler |
139 | * bit 6 -- discard sectors | 145 | * bit 5 -- discard sectors |
140 | * Informs the lower level device that this range of sectors is no longer | 146 | * Informs the lower level device that this range of sectors is no longer |
141 | * used by the file system and may thus be freed by the device. Used | 147 | * used by the file system and may thus be freed by the device. Used |
142 | * for flash based storage. | 148 | * for flash based storage. |
149 | * bit 6 -- fail fast device errors | ||
150 | * bit 7 -- fail fast transport errors | ||
151 | * bit 8 -- fail fast driver errors | ||
152 | * Don't want driver retries for any fast fail whatever the reason. | ||
143 | */ | 153 | */ |
144 | #define BIO_RW 0 /* Must match RW in req flags (blkdev.h) */ | 154 | #define BIO_RW 0 /* Must match RW in req flags (blkdev.h) */ |
145 | #define BIO_RW_AHEAD 1 /* Must match FAILFAST in req flags */ | 155 | #define BIO_RW_AHEAD 1 /* Must match FAILFAST in req flags */ |
146 | #define BIO_RW_BARRIER 2 | 156 | #define BIO_RW_BARRIER 2 |
147 | #define BIO_RW_FAILFAST 3 | 157 | #define BIO_RW_SYNC 3 |
148 | #define BIO_RW_SYNC 4 | 158 | #define BIO_RW_META 4 |
149 | #define BIO_RW_META 5 | 159 | #define BIO_RW_DISCARD 5 |
150 | #define BIO_RW_DISCARD 6 | 160 | #define BIO_RW_FAILFAST_DEV 6 |
161 | #define BIO_RW_FAILFAST_TRANSPORT 7 | ||
162 | #define BIO_RW_FAILFAST_DRIVER 8 | ||
151 | 163 | ||
152 | /* | 164 | /* |
153 | * upper 16 bits of bi_rw define the io priority of this bio | 165 | * upper 16 bits of bi_rw define the io priority of this bio |
@@ -174,7 +186,10 @@ struct bio { | |||
174 | #define bio_sectors(bio) ((bio)->bi_size >> 9) | 186 | #define bio_sectors(bio) ((bio)->bi_size >> 9) |
175 | #define bio_barrier(bio) ((bio)->bi_rw & (1 << BIO_RW_BARRIER)) | 187 | #define bio_barrier(bio) ((bio)->bi_rw & (1 << BIO_RW_BARRIER)) |
176 | #define bio_sync(bio) ((bio)->bi_rw & (1 << BIO_RW_SYNC)) | 188 | #define bio_sync(bio) ((bio)->bi_rw & (1 << BIO_RW_SYNC)) |
177 | #define bio_failfast(bio) ((bio)->bi_rw & (1 << BIO_RW_FAILFAST)) | 189 | #define bio_failfast_dev(bio) ((bio)->bi_rw & (1 << BIO_RW_FAILFAST_DEV)) |
190 | #define bio_failfast_transport(bio) \ | ||
191 | ((bio)->bi_rw & (1 << BIO_RW_FAILFAST_TRANSPORT)) | ||
192 | #define bio_failfast_driver(bio) ((bio)->bi_rw & (1 << BIO_RW_FAILFAST_DRIVER)) | ||
178 | #define bio_rw_ahead(bio) ((bio)->bi_rw & (1 << BIO_RW_AHEAD)) | 193 | #define bio_rw_ahead(bio) ((bio)->bi_rw & (1 << BIO_RW_AHEAD)) |
179 | #define bio_rw_meta(bio) ((bio)->bi_rw & (1 << BIO_RW_META)) | 194 | #define bio_rw_meta(bio) ((bio)->bi_rw & (1 << BIO_RW_META)) |
180 | #define bio_discard(bio) ((bio)->bi_rw & (1 << BIO_RW_DISCARD)) | 195 | #define bio_discard(bio) ((bio)->bi_rw & (1 << BIO_RW_DISCARD)) |
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h index 89781fd48859..1abfe664c444 100644 --- a/include/linux/bitmap.h +++ b/include/linux/bitmap.h | |||
@@ -110,7 +110,6 @@ extern int __bitmap_weight(const unsigned long *bitmap, int bits); | |||
110 | 110 | ||
111 | extern int bitmap_scnprintf(char *buf, unsigned int len, | 111 | extern int bitmap_scnprintf(char *buf, unsigned int len, |
112 | const unsigned long *src, int nbits); | 112 | const unsigned long *src, int nbits); |
113 | extern int bitmap_scnprintf_len(unsigned int nr_bits); | ||
114 | extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user, | 113 | extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user, |
115 | unsigned long *dst, int nbits); | 114 | unsigned long *dst, int nbits); |
116 | extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen, | 115 | extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen, |
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index a92d9e4ea96e..b4fe68fe3a57 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h | |||
@@ -87,7 +87,9 @@ enum { | |||
87 | */ | 87 | */ |
88 | enum rq_flag_bits { | 88 | enum rq_flag_bits { |
89 | __REQ_RW, /* not set, read. set, write */ | 89 | __REQ_RW, /* not set, read. set, write */ |
90 | __REQ_FAILFAST, /* no low level driver retries */ | 90 | __REQ_FAILFAST_DEV, /* no driver retries of device errors */ |
91 | __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */ | ||
92 | __REQ_FAILFAST_DRIVER, /* no driver retries of driver errors */ | ||
91 | __REQ_DISCARD, /* request to discard sectors */ | 93 | __REQ_DISCARD, /* request to discard sectors */ |
92 | __REQ_SORTED, /* elevator knows about this request */ | 94 | __REQ_SORTED, /* elevator knows about this request */ |
93 | __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */ | 95 | __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */ |
@@ -111,8 +113,10 @@ enum rq_flag_bits { | |||
111 | }; | 113 | }; |
112 | 114 | ||
113 | #define REQ_RW (1 << __REQ_RW) | 115 | #define REQ_RW (1 << __REQ_RW) |
116 | #define REQ_FAILFAST_DEV (1 << __REQ_FAILFAST_DEV) | ||
117 | #define REQ_FAILFAST_TRANSPORT (1 << __REQ_FAILFAST_TRANSPORT) | ||
118 | #define REQ_FAILFAST_DRIVER (1 << __REQ_FAILFAST_DRIVER) | ||
114 | #define REQ_DISCARD (1 << __REQ_DISCARD) | 119 | #define REQ_DISCARD (1 << __REQ_DISCARD) |
115 | #define REQ_FAILFAST (1 << __REQ_FAILFAST) | ||
116 | #define REQ_SORTED (1 << __REQ_SORTED) | 120 | #define REQ_SORTED (1 << __REQ_SORTED) |
117 | #define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER) | 121 | #define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER) |
118 | #define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER) | 122 | #define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER) |
@@ -560,7 +564,12 @@ enum { | |||
560 | #define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL) | 564 | #define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL) |
561 | #define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE) | 565 | #define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE) |
562 | 566 | ||
563 | #define blk_noretry_request(rq) ((rq)->cmd_flags & REQ_FAILFAST) | 567 | #define blk_failfast_dev(rq) ((rq)->cmd_flags & REQ_FAILFAST_DEV) |
568 | #define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT) | ||
569 | #define blk_failfast_driver(rq) ((rq)->cmd_flags & REQ_FAILFAST_DRIVER) | ||
570 | #define blk_noretry_request(rq) (blk_failfast_dev(rq) || \ | ||
571 | blk_failfast_transport(rq) || \ | ||
572 | blk_failfast_driver(rq)) | ||
564 | #define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED) | 573 | #define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED) |
565 | 574 | ||
566 | #define blk_account_rq(rq) (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) | 575 | #define blk_account_rq(rq) (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) |
@@ -856,7 +865,6 @@ extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int); | |||
856 | extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *); | 865 | extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *); |
857 | extern void blk_dump_rq_flags(struct request *, char *); | 866 | extern void blk_dump_rq_flags(struct request *, char *); |
858 | extern void generic_unplug_device(struct request_queue *); | 867 | extern void generic_unplug_device(struct request_queue *); |
859 | extern void __generic_unplug_device(struct request_queue *); | ||
860 | extern long nr_blockdev_pages(void); | 868 | extern long nr_blockdev_pages(void); |
861 | 869 | ||
862 | int blk_get_queue(struct request_queue *); | 870 | int blk_get_queue(struct request_queue *); |
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h index 3a31eb506164..bdf505d33e77 100644 --- a/include/linux/blktrace_api.h +++ b/include/linux/blktrace_api.h | |||
@@ -24,6 +24,7 @@ enum blktrace_cat { | |||
24 | BLK_TC_AHEAD = 1 << 11, /* readahead */ | 24 | BLK_TC_AHEAD = 1 << 11, /* readahead */ |
25 | BLK_TC_META = 1 << 12, /* metadata */ | 25 | BLK_TC_META = 1 << 12, /* metadata */ |
26 | BLK_TC_DISCARD = 1 << 13, /* discard requests */ | 26 | BLK_TC_DISCARD = 1 << 13, /* discard requests */ |
27 | BLK_TC_DRV_DATA = 1 << 14, /* binary per-driver data */ | ||
27 | 28 | ||
28 | BLK_TC_END = 1 << 15, /* only 16-bits, reminder */ | 29 | BLK_TC_END = 1 << 15, /* only 16-bits, reminder */ |
29 | }; | 30 | }; |
@@ -51,6 +52,7 @@ enum blktrace_act { | |||
51 | __BLK_TA_BOUNCE, /* bio was bounced */ | 52 | __BLK_TA_BOUNCE, /* bio was bounced */ |
52 | __BLK_TA_REMAP, /* bio was remapped */ | 53 | __BLK_TA_REMAP, /* bio was remapped */ |
53 | __BLK_TA_ABORT, /* request aborted */ | 54 | __BLK_TA_ABORT, /* request aborted */ |
55 | __BLK_TA_DRV_DATA, /* driver-specific binary data */ | ||
54 | }; | 56 | }; |
55 | 57 | ||
56 | /* | 58 | /* |
@@ -82,6 +84,7 @@ enum blktrace_notify { | |||
82 | #define BLK_TA_BOUNCE (__BLK_TA_BOUNCE) | 84 | #define BLK_TA_BOUNCE (__BLK_TA_BOUNCE) |
83 | #define BLK_TA_REMAP (__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE)) | 85 | #define BLK_TA_REMAP (__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE)) |
84 | #define BLK_TA_ABORT (__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE)) | 86 | #define BLK_TA_ABORT (__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE)) |
87 | #define BLK_TA_DRV_DATA (__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA)) | ||
85 | 88 | ||
86 | #define BLK_TN_PROCESS (__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY)) | 89 | #define BLK_TN_PROCESS (__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY)) |
87 | #define BLK_TN_TIMESTAMP (__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY)) | 90 | #define BLK_TN_TIMESTAMP (__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY)) |
@@ -317,6 +320,34 @@ static inline void blk_add_trace_remap(struct request_queue *q, struct bio *bio, | |||
317 | __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r); | 320 | __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r); |
318 | } | 321 | } |
319 | 322 | ||
323 | /** | ||
324 | * blk_add_driver_data - Add binary message with driver-specific data | ||
325 | * @q: queue the io is for | ||
326 | * @rq: io request | ||
327 | * @data: driver-specific data | ||
328 | * @len: length of driver-specific data | ||
329 | * | ||
330 | * Description: | ||
331 | * Some drivers might want to write driver-specific data per request. | ||
332 | * | ||
333 | **/ | ||
334 | static inline void blk_add_driver_data(struct request_queue *q, | ||
335 | struct request *rq, | ||
336 | void *data, size_t len) | ||
337 | { | ||
338 | struct blk_trace *bt = q->blk_trace; | ||
339 | |||
340 | if (likely(!bt)) | ||
341 | return; | ||
342 | |||
343 | if (blk_pc_request(rq)) | ||
344 | __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA, | ||
345 | rq->errors, len, data); | ||
346 | else | ||
347 | __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9, | ||
348 | 0, BLK_TA_DRV_DATA, rq->errors, len, data); | ||
349 | } | ||
350 | |||
320 | extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev, | 351 | extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev, |
321 | char __user *arg); | 352 | char __user *arg); |
322 | extern int blk_trace_startstop(struct request_queue *q, int start); | 353 | extern int blk_trace_startstop(struct request_queue *q, int start); |
@@ -330,6 +361,7 @@ extern int blk_trace_remove(struct request_queue *q); | |||
330 | #define blk_add_trace_generic(q, rq, rw, what) do { } while (0) | 361 | #define blk_add_trace_generic(q, rq, rw, what) do { } while (0) |
331 | #define blk_add_trace_pdu_int(q, what, bio, pdu) do { } while (0) | 362 | #define blk_add_trace_pdu_int(q, what, bio, pdu) do { } while (0) |
332 | #define blk_add_trace_remap(q, bio, dev, f, t) do {} while (0) | 363 | #define blk_add_trace_remap(q, bio, dev, f, t) do {} while (0) |
364 | #define blk_add_driver_data(q, rq, data, len) do {} while (0) | ||
333 | #define do_blk_trace_setup(q, name, dev, buts) (-ENOTTY) | 365 | #define do_blk_trace_setup(q, name, dev, buts) (-ENOTTY) |
334 | #define blk_trace_setup(q, name, dev, arg) (-ENOTTY) | 366 | #define blk_trace_setup(q, name, dev, arg) (-ENOTTY) |
335 | #define blk_trace_startstop(q, start) (-ENOTTY) | 367 | #define blk_trace_startstop(q, start) (-ENOTTY) |
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h index eadaab44015f..3ce64b90118c 100644 --- a/include/linux/buffer_head.h +++ b/include/linux/buffer_head.h | |||
@@ -322,7 +322,7 @@ static inline void wait_on_buffer(struct buffer_head *bh) | |||
322 | 322 | ||
323 | static inline int trylock_buffer(struct buffer_head *bh) | 323 | static inline int trylock_buffer(struct buffer_head *bh) |
324 | { | 324 | { |
325 | return likely(!test_and_set_bit(BH_Lock, &bh->b_state)); | 325 | return likely(!test_and_set_bit_lock(BH_Lock, &bh->b_state)); |
326 | } | 326 | } |
327 | 327 | ||
328 | static inline void lock_buffer(struct buffer_head *bh) | 328 | static inline void lock_buffer(struct buffer_head *bh) |
diff --git a/include/linux/byteorder/Kbuild b/include/linux/byteorder/Kbuild index 1133d5f9d818..fbaa7f9cee32 100644 --- a/include/linux/byteorder/Kbuild +++ b/include/linux/byteorder/Kbuild | |||
@@ -1,3 +1,4 @@ | |||
1 | unifdef-y += big_endian.h | 1 | unifdef-y += big_endian.h |
2 | unifdef-y += little_endian.h | 2 | unifdef-y += little_endian.h |
3 | unifdef-y += swab.h | 3 | unifdef-y += swab.h |
4 | unifdef-y += swabb.h | ||
diff --git a/include/linux/byteorder/big_endian.h b/include/linux/byteorder/big_endian.h index 44f95b92393b..1cba3f3efe5f 100644 --- a/include/linux/byteorder/big_endian.h +++ b/include/linux/byteorder/big_endian.h | |||
@@ -10,6 +10,7 @@ | |||
10 | 10 | ||
11 | #include <linux/types.h> | 11 | #include <linux/types.h> |
12 | #include <linux/byteorder/swab.h> | 12 | #include <linux/byteorder/swab.h> |
13 | #include <linux/byteorder/swabb.h> | ||
13 | 14 | ||
14 | #define __constant_htonl(x) ((__force __be32)(__u32)(x)) | 15 | #define __constant_htonl(x) ((__force __be32)(__u32)(x)) |
15 | #define __constant_ntohl(x) ((__force __u32)(__be32)(x)) | 16 | #define __constant_ntohl(x) ((__force __u32)(__be32)(x)) |
diff --git a/include/linux/byteorder/little_endian.h b/include/linux/byteorder/little_endian.h index 4cc170a31762..cedc1b5a289c 100644 --- a/include/linux/byteorder/little_endian.h +++ b/include/linux/byteorder/little_endian.h | |||
@@ -10,6 +10,7 @@ | |||
10 | 10 | ||
11 | #include <linux/types.h> | 11 | #include <linux/types.h> |
12 | #include <linux/byteorder/swab.h> | 12 | #include <linux/byteorder/swab.h> |
13 | #include <linux/byteorder/swabb.h> | ||
13 | 14 | ||
14 | #define __constant_htonl(x) ((__force __be32)___constant_swab32((x))) | 15 | #define __constant_htonl(x) ((__force __be32)___constant_swab32((x))) |
15 | #define __constant_ntohl(x) ___constant_swab32((__force __be32)(x)) | 16 | #define __constant_ntohl(x) ___constant_swab32((__force __be32)(x)) |
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index c98dd7cb7076..8b00f6643e93 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h | |||
@@ -9,12 +9,12 @@ | |||
9 | */ | 9 | */ |
10 | 10 | ||
11 | #include <linux/sched.h> | 11 | #include <linux/sched.h> |
12 | #include <linux/kref.h> | ||
13 | #include <linux/cpumask.h> | 12 | #include <linux/cpumask.h> |
14 | #include <linux/nodemask.h> | 13 | #include <linux/nodemask.h> |
15 | #include <linux/rcupdate.h> | 14 | #include <linux/rcupdate.h> |
16 | #include <linux/cgroupstats.h> | 15 | #include <linux/cgroupstats.h> |
17 | #include <linux/prio_heap.h> | 16 | #include <linux/prio_heap.h> |
17 | #include <linux/rwsem.h> | ||
18 | 18 | ||
19 | #ifdef CONFIG_CGROUPS | 19 | #ifdef CONFIG_CGROUPS |
20 | 20 | ||
@@ -137,6 +137,15 @@ struct cgroup { | |||
137 | * release_list_lock | 137 | * release_list_lock |
138 | */ | 138 | */ |
139 | struct list_head release_list; | 139 | struct list_head release_list; |
140 | |||
141 | /* pids_mutex protects the fields below */ | ||
142 | struct rw_semaphore pids_mutex; | ||
143 | /* Array of process ids in the cgroup */ | ||
144 | pid_t *tasks_pids; | ||
145 | /* How many files are using the current tasks_pids array */ | ||
146 | int pids_use_count; | ||
147 | /* Length of the current tasks_pids array */ | ||
148 | int pids_length; | ||
140 | }; | 149 | }; |
141 | 150 | ||
142 | /* A css_set is a structure holding pointers to a set of | 151 | /* A css_set is a structure holding pointers to a set of |
@@ -149,7 +158,7 @@ struct cgroup { | |||
149 | struct css_set { | 158 | struct css_set { |
150 | 159 | ||
151 | /* Reference count */ | 160 | /* Reference count */ |
152 | struct kref ref; | 161 | atomic_t refcount; |
153 | 162 | ||
154 | /* | 163 | /* |
155 | * List running through all cgroup groups in the same hash | 164 | * List running through all cgroup groups in the same hash |
@@ -326,7 +335,8 @@ struct cgroup_subsys { | |||
326 | */ | 335 | */ |
327 | void (*mm_owner_changed)(struct cgroup_subsys *ss, | 336 | void (*mm_owner_changed)(struct cgroup_subsys *ss, |
328 | struct cgroup *old, | 337 | struct cgroup *old, |
329 | struct cgroup *new); | 338 | struct cgroup *new, |
339 | struct task_struct *p); | ||
330 | int subsys_id; | 340 | int subsys_id; |
331 | int active; | 341 | int active; |
332 | int disabled; | 342 | int disabled; |
@@ -393,6 +403,9 @@ void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it); | |||
393 | int cgroup_scan_tasks(struct cgroup_scanner *scan); | 403 | int cgroup_scan_tasks(struct cgroup_scanner *scan); |
394 | int cgroup_attach_task(struct cgroup *, struct task_struct *); | 404 | int cgroup_attach_task(struct cgroup *, struct task_struct *); |
395 | 405 | ||
406 | void cgroup_mm_owner_callbacks(struct task_struct *old, | ||
407 | struct task_struct *new); | ||
408 | |||
396 | #else /* !CONFIG_CGROUPS */ | 409 | #else /* !CONFIG_CGROUPS */ |
397 | 410 | ||
398 | static inline int cgroup_init_early(void) { return 0; } | 411 | static inline int cgroup_init_early(void) { return 0; } |
@@ -411,15 +424,9 @@ static inline int cgroupstats_build(struct cgroupstats *stats, | |||
411 | return -EINVAL; | 424 | return -EINVAL; |
412 | } | 425 | } |
413 | 426 | ||
427 | static inline void cgroup_mm_owner_callbacks(struct task_struct *old, | ||
428 | struct task_struct *new) {} | ||
429 | |||
414 | #endif /* !CONFIG_CGROUPS */ | 430 | #endif /* !CONFIG_CGROUPS */ |
415 | 431 | ||
416 | #ifdef CONFIG_MM_OWNER | ||
417 | extern void | ||
418 | cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new); | ||
419 | #else /* !CONFIG_MM_OWNER */ | ||
420 | static inline void | ||
421 | cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new) | ||
422 | { | ||
423 | } | ||
424 | #endif /* CONFIG_MM_OWNER */ | ||
425 | #endif /* _LINUX_CGROUP_H */ | 432 | #endif /* _LINUX_CGROUP_H */ |
diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h index e2877454ec82..9c22396e8b50 100644 --- a/include/linux/cgroup_subsys.h +++ b/include/linux/cgroup_subsys.h | |||
@@ -48,3 +48,9 @@ SUBSYS(devices) | |||
48 | #endif | 48 | #endif |
49 | 49 | ||
50 | /* */ | 50 | /* */ |
51 | |||
52 | #ifdef CONFIG_CGROUP_FREEZER | ||
53 | SUBSYS(freezer) | ||
54 | #endif | ||
55 | |||
56 | /* */ | ||
diff --git a/include/linux/clk.h b/include/linux/clk.h index 5ca8c6fddb56..778777316ea4 100644 --- a/include/linux/clk.h +++ b/include/linux/clk.h | |||
@@ -35,6 +35,8 @@ struct clk; | |||
35 | * clk_get may return different clock producers depending on @dev.) | 35 | * clk_get may return different clock producers depending on @dev.) |
36 | * | 36 | * |
37 | * Drivers must assume that the clock source is not enabled. | 37 | * Drivers must assume that the clock source is not enabled. |
38 | * | ||
39 | * clk_get should not be called from within interrupt context. | ||
38 | */ | 40 | */ |
39 | struct clk *clk_get(struct device *dev, const char *id); | 41 | struct clk *clk_get(struct device *dev, const char *id); |
40 | 42 | ||
@@ -76,6 +78,8 @@ unsigned long clk_get_rate(struct clk *clk); | |||
76 | * Note: drivers must ensure that all clk_enable calls made on this | 78 | * Note: drivers must ensure that all clk_enable calls made on this |
77 | * clock source are balanced by clk_disable calls prior to calling | 79 | * clock source are balanced by clk_disable calls prior to calling |
78 | * this function. | 80 | * this function. |
81 | * | ||
82 | * clk_put should not be called from within interrupt context. | ||
79 | */ | 83 | */ |
80 | void clk_put(struct clk *clk); | 84 | void clk_put(struct clk *clk); |
81 | 85 | ||
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h index 55e434feec99..f88d32f8ff7c 100644 --- a/include/linux/clocksource.h +++ b/include/linux/clocksource.h | |||
@@ -45,7 +45,8 @@ struct clocksource; | |||
45 | * @read: returns a cycle value | 45 | * @read: returns a cycle value |
46 | * @mask: bitmask for two's complement | 46 | * @mask: bitmask for two's complement |
47 | * subtraction of non 64 bit counters | 47 | * subtraction of non 64 bit counters |
48 | * @mult: cycle to nanosecond multiplier | 48 | * @mult: cycle to nanosecond multiplier (adjusted by NTP) |
49 | * @mult_orig: cycle to nanosecond multiplier (unadjusted by NTP) | ||
49 | * @shift: cycle to nanosecond divisor (power of two) | 50 | * @shift: cycle to nanosecond divisor (power of two) |
50 | * @flags: flags describing special properties | 51 | * @flags: flags describing special properties |
51 | * @vread: vsyscall based read | 52 | * @vread: vsyscall based read |
@@ -63,6 +64,7 @@ struct clocksource { | |||
63 | cycle_t (*read)(void); | 64 | cycle_t (*read)(void); |
64 | cycle_t mask; | 65 | cycle_t mask; |
65 | u32 mult; | 66 | u32 mult; |
67 | u32 mult_orig; | ||
66 | u32 shift; | 68 | u32 shift; |
67 | unsigned long flags; | 69 | unsigned long flags; |
68 | cycle_t (*vread)(void); | 70 | cycle_t (*vread)(void); |
@@ -77,6 +79,7 @@ struct clocksource { | |||
77 | /* timekeeping specific data, ignore */ | 79 | /* timekeeping specific data, ignore */ |
78 | cycle_t cycle_interval; | 80 | cycle_t cycle_interval; |
79 | u64 xtime_interval; | 81 | u64 xtime_interval; |
82 | u32 raw_interval; | ||
80 | /* | 83 | /* |
81 | * Second part is written at each timer interrupt | 84 | * Second part is written at each timer interrupt |
82 | * Keep it in a different cache line to dirty no | 85 | * Keep it in a different cache line to dirty no |
@@ -85,6 +88,7 @@ struct clocksource { | |||
85 | cycle_t cycle_last ____cacheline_aligned_in_smp; | 88 | cycle_t cycle_last ____cacheline_aligned_in_smp; |
86 | u64 xtime_nsec; | 89 | u64 xtime_nsec; |
87 | s64 error; | 90 | s64 error; |
91 | struct timespec raw_time; | ||
88 | 92 | ||
89 | #ifdef CONFIG_CLOCKSOURCE_WATCHDOG | 93 | #ifdef CONFIG_CLOCKSOURCE_WATCHDOG |
90 | /* Watchdog related data, used by the framework */ | 94 | /* Watchdog related data, used by the framework */ |
@@ -201,17 +205,19 @@ static inline void clocksource_calculate_interval(struct clocksource *c, | |||
201 | { | 205 | { |
202 | u64 tmp; | 206 | u64 tmp; |
203 | 207 | ||
204 | /* XXX - All of this could use a whole lot of optimization */ | 208 | /* Do the ns -> cycle conversion first, using original mult */ |
205 | tmp = length_nsec; | 209 | tmp = length_nsec; |
206 | tmp <<= c->shift; | 210 | tmp <<= c->shift; |
207 | tmp += c->mult/2; | 211 | tmp += c->mult_orig/2; |
208 | do_div(tmp, c->mult); | 212 | do_div(tmp, c->mult_orig); |
209 | 213 | ||
210 | c->cycle_interval = (cycle_t)tmp; | 214 | c->cycle_interval = (cycle_t)tmp; |
211 | if (c->cycle_interval == 0) | 215 | if (c->cycle_interval == 0) |
212 | c->cycle_interval = 1; | 216 | c->cycle_interval = 1; |
213 | 217 | ||
218 | /* Go back from cycles -> shifted ns, this time use ntp adjused mult */ | ||
214 | c->xtime_interval = (u64)c->cycle_interval * c->mult; | 219 | c->xtime_interval = (u64)c->cycle_interval * c->mult; |
220 | c->raw_interval = ((u64)c->cycle_interval * c->mult_orig) >> c->shift; | ||
215 | } | 221 | } |
216 | 222 | ||
217 | 223 | ||
diff --git a/include/linux/compat.h b/include/linux/compat.h index cf8d11cad5ae..f061a1ea1b74 100644 --- a/include/linux/compat.h +++ b/include/linux/compat.h | |||
@@ -78,7 +78,6 @@ typedef struct { | |||
78 | compat_sigset_word sig[_COMPAT_NSIG_WORDS]; | 78 | compat_sigset_word sig[_COMPAT_NSIG_WORDS]; |
79 | } compat_sigset_t; | 79 | } compat_sigset_t; |
80 | 80 | ||
81 | extern int cp_compat_stat(struct kstat *, struct compat_stat __user *); | ||
82 | extern int get_compat_timespec(struct timespec *, const struct compat_timespec __user *); | 81 | extern int get_compat_timespec(struct timespec *, const struct compat_timespec __user *); |
83 | extern int put_compat_timespec(const struct timespec *, struct compat_timespec __user *); | 82 | extern int put_compat_timespec(const struct timespec *, struct compat_timespec __user *); |
84 | 83 | ||
@@ -235,6 +234,11 @@ extern int get_compat_itimerspec(struct itimerspec *dst, | |||
235 | extern int put_compat_itimerspec(struct compat_itimerspec __user *dst, | 234 | extern int put_compat_itimerspec(struct compat_itimerspec __user *dst, |
236 | const struct itimerspec *src); | 235 | const struct itimerspec *src); |
237 | 236 | ||
237 | asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv, | ||
238 | struct timezone __user *tz); | ||
239 | asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv, | ||
240 | struct timezone __user *tz); | ||
241 | |||
238 | asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp); | 242 | asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp); |
239 | 243 | ||
240 | extern int compat_printk(const char *fmt, ...); | 244 | extern int compat_printk(const char *fmt, ...); |
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h index 025e4f575103..0acf3b737e2e 100644 --- a/include/linux/crash_dump.h +++ b/include/linux/crash_dump.h | |||
@@ -8,12 +8,9 @@ | |||
8 | #include <linux/proc_fs.h> | 8 | #include <linux/proc_fs.h> |
9 | 9 | ||
10 | #define ELFCORE_ADDR_MAX (-1ULL) | 10 | #define ELFCORE_ADDR_MAX (-1ULL) |
11 | #define ELFCORE_ADDR_ERR (-2ULL) | ||
11 | 12 | ||
12 | #ifdef CONFIG_PROC_VMCORE | ||
13 | extern unsigned long long elfcorehdr_addr; | 13 | extern unsigned long long elfcorehdr_addr; |
14 | #else | ||
15 | static const unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX; | ||
16 | #endif | ||
17 | 14 | ||
18 | extern ssize_t copy_oldmem_page(unsigned long, char *, size_t, | 15 | extern ssize_t copy_oldmem_page(unsigned long, char *, size_t, |
19 | unsigned long, int); | 16 | unsigned long, int); |
@@ -28,10 +25,43 @@ extern struct proc_dir_entry *proc_vmcore; | |||
28 | 25 | ||
29 | #define vmcore_elf_check_arch(x) (elf_check_arch(x) || vmcore_elf_check_arch_cross(x)) | 26 | #define vmcore_elf_check_arch(x) (elf_check_arch(x) || vmcore_elf_check_arch_cross(x)) |
30 | 27 | ||
28 | /* | ||
29 | * is_kdump_kernel() checks whether this kernel is booting after a panic of | ||
30 | * previous kernel or not. This is determined by checking if previous kernel | ||
31 | * has passed the elf core header address on command line. | ||
32 | * | ||
33 | * This is not just a test if CONFIG_CRASH_DUMP is enabled or not. It will | ||
34 | * return 1 if CONFIG_CRASH_DUMP=y and if kernel is booting after a panic of | ||
35 | * previous kernel. | ||
36 | */ | ||
37 | |||
31 | static inline int is_kdump_kernel(void) | 38 | static inline int is_kdump_kernel(void) |
32 | { | 39 | { |
33 | return (elfcorehdr_addr != ELFCORE_ADDR_MAX) ? 1 : 0; | 40 | return (elfcorehdr_addr != ELFCORE_ADDR_MAX) ? 1 : 0; |
34 | } | 41 | } |
42 | |||
43 | /* is_vmcore_usable() checks if the kernel is booting after a panic and | ||
44 | * the vmcore region is usable. | ||
45 | * | ||
46 | * This makes use of the fact that due to alignment -2ULL is not | ||
47 | * a valid pointer, much in the vain of IS_ERR(), except | ||
48 | * dealing directly with an unsigned long long rather than a pointer. | ||
49 | */ | ||
50 | |||
51 | static inline int is_vmcore_usable(void) | ||
52 | { | ||
53 | return is_kdump_kernel() && elfcorehdr_addr != ELFCORE_ADDR_ERR ? 1 : 0; | ||
54 | } | ||
55 | |||
56 | /* vmcore_unusable() marks the vmcore as unusable, | ||
57 | * without disturbing the logic of is_kdump_kernel() | ||
58 | */ | ||
59 | |||
60 | static inline void vmcore_unusable(void) | ||
61 | { | ||
62 | if (is_kdump_kernel()) | ||
63 | elfcorehdr_addr = ELFCORE_ADDR_ERR; | ||
64 | } | ||
35 | #else /* !CONFIG_CRASH_DUMP */ | 65 | #else /* !CONFIG_CRASH_DUMP */ |
36 | static inline int is_kdump_kernel(void) { return 0; } | 66 | static inline int is_kdump_kernel(void) { return 0; } |
37 | #endif /* CONFIG_CRASH_DUMP */ | 67 | #endif /* CONFIG_CRASH_DUMP */ |
diff --git a/include/linux/device.h b/include/linux/device.h index 246937c9cbc7..987f5912720a 100644 --- a/include/linux/device.h +++ b/include/linux/device.h | |||
@@ -90,6 +90,9 @@ int __must_check bus_for_each_drv(struct bus_type *bus, | |||
90 | struct device_driver *start, void *data, | 90 | struct device_driver *start, void *data, |
91 | int (*fn)(struct device_driver *, void *)); | 91 | int (*fn)(struct device_driver *, void *)); |
92 | 92 | ||
93 | void bus_sort_breadthfirst(struct bus_type *bus, | ||
94 | int (*compare)(const struct device *a, | ||
95 | const struct device *b)); | ||
93 | /* | 96 | /* |
94 | * Bus notifiers: Get notified of addition/removal of devices | 97 | * Bus notifiers: Get notified of addition/removal of devices |
95 | * and binding/unbinding of drivers to devices. | 98 | * and binding/unbinding of drivers to devices. |
@@ -502,7 +505,6 @@ extern struct device *device_create(struct class *cls, struct device *parent, | |||
502 | dev_t devt, void *drvdata, | 505 | dev_t devt, void *drvdata, |
503 | const char *fmt, ...) | 506 | const char *fmt, ...) |
504 | __attribute__((format(printf, 5, 6))); | 507 | __attribute__((format(printf, 5, 6))); |
505 | #define device_create_drvdata device_create | ||
506 | extern void device_destroy(struct class *cls, dev_t devt); | 508 | extern void device_destroy(struct class *cls, dev_t devt); |
507 | 509 | ||
508 | /* | 510 | /* |
@@ -551,7 +553,11 @@ extern const char *dev_driver_string(const struct device *dev); | |||
551 | #define dev_info(dev, format, arg...) \ | 553 | #define dev_info(dev, format, arg...) \ |
552 | dev_printk(KERN_INFO , dev , format , ## arg) | 554 | dev_printk(KERN_INFO , dev , format , ## arg) |
553 | 555 | ||
554 | #ifdef DEBUG | 556 | #if defined(CONFIG_DYNAMIC_PRINTK_DEBUG) |
557 | #define dev_dbg(dev, format, ...) do { \ | ||
558 | dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ | ||
559 | } while (0) | ||
560 | #elif defined(DEBUG) | ||
555 | #define dev_dbg(dev, format, arg...) \ | 561 | #define dev_dbg(dev, format, arg...) \ |
556 | dev_printk(KERN_DEBUG , dev , format , ## arg) | 562 | dev_printk(KERN_DEBUG , dev , format , ## arg) |
557 | #else | 563 | #else |
@@ -567,6 +573,14 @@ extern const char *dev_driver_string(const struct device *dev); | |||
567 | ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; }) | 573 | ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; }) |
568 | #endif | 574 | #endif |
569 | 575 | ||
576 | /* | ||
577 | * dev_WARN() acts like dev_printk(), but with the key difference | ||
578 | * of using a WARN/WARN_ON to get the message out, including the | ||
579 | * file/line information and a backtrace. | ||
580 | */ | ||
581 | #define dev_WARN(dev, format, arg...) \ | ||
582 | WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg); | ||
583 | |||
570 | /* Create alias, so I can be autoloaded. */ | 584 | /* Create alias, so I can be autoloaded. */ |
571 | #define MODULE_ALIAS_CHARDEV(major,minor) \ | 585 | #define MODULE_ALIAS_CHARDEV(major,minor) \ |
572 | MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) | 586 | MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) |
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h new file mode 100644 index 000000000000..bff5c65f81dc --- /dev/null +++ b/include/linux/dma_remapping.h | |||
@@ -0,0 +1,157 @@ | |||
1 | #ifndef _DMA_REMAPPING_H | ||
2 | #define _DMA_REMAPPING_H | ||
3 | |||
4 | /* | ||
5 | * We need a fixed PAGE_SIZE of 4K irrespective of | ||
6 | * arch PAGE_SIZE for IOMMU page tables. | ||
7 | */ | ||
8 | #define PAGE_SHIFT_4K (12) | ||
9 | #define PAGE_SIZE_4K (1UL << PAGE_SHIFT_4K) | ||
10 | #define PAGE_MASK_4K (((u64)-1) << PAGE_SHIFT_4K) | ||
11 | #define PAGE_ALIGN_4K(addr) (((addr) + PAGE_SIZE_4K - 1) & PAGE_MASK_4K) | ||
12 | |||
13 | #define IOVA_PFN(addr) ((addr) >> PAGE_SHIFT_4K) | ||
14 | #define DMA_32BIT_PFN IOVA_PFN(DMA_32BIT_MASK) | ||
15 | #define DMA_64BIT_PFN IOVA_PFN(DMA_64BIT_MASK) | ||
16 | |||
17 | |||
18 | /* | ||
19 | * 0: Present | ||
20 | * 1-11: Reserved | ||
21 | * 12-63: Context Ptr (12 - (haw-1)) | ||
22 | * 64-127: Reserved | ||
23 | */ | ||
24 | struct root_entry { | ||
25 | u64 val; | ||
26 | u64 rsvd1; | ||
27 | }; | ||
28 | #define ROOT_ENTRY_NR (PAGE_SIZE_4K/sizeof(struct root_entry)) | ||
29 | static inline bool root_present(struct root_entry *root) | ||
30 | { | ||
31 | return (root->val & 1); | ||
32 | } | ||
33 | static inline void set_root_present(struct root_entry *root) | ||
34 | { | ||
35 | root->val |= 1; | ||
36 | } | ||
37 | static inline void set_root_value(struct root_entry *root, unsigned long value) | ||
38 | { | ||
39 | root->val |= value & PAGE_MASK_4K; | ||
40 | } | ||
41 | |||
42 | struct context_entry; | ||
43 | static inline struct context_entry * | ||
44 | get_context_addr_from_root(struct root_entry *root) | ||
45 | { | ||
46 | return (struct context_entry *) | ||
47 | (root_present(root)?phys_to_virt( | ||
48 | root->val & PAGE_MASK_4K): | ||
49 | NULL); | ||
50 | } | ||
51 | |||
52 | /* | ||
53 | * low 64 bits: | ||
54 | * 0: present | ||
55 | * 1: fault processing disable | ||
56 | * 2-3: translation type | ||
57 | * 12-63: address space root | ||
58 | * high 64 bits: | ||
59 | * 0-2: address width | ||
60 | * 3-6: aval | ||
61 | * 8-23: domain id | ||
62 | */ | ||
63 | struct context_entry { | ||
64 | u64 lo; | ||
65 | u64 hi; | ||
66 | }; | ||
67 | #define context_present(c) ((c).lo & 1) | ||
68 | #define context_fault_disable(c) (((c).lo >> 1) & 1) | ||
69 | #define context_translation_type(c) (((c).lo >> 2) & 3) | ||
70 | #define context_address_root(c) ((c).lo & PAGE_MASK_4K) | ||
71 | #define context_address_width(c) ((c).hi & 7) | ||
72 | #define context_domain_id(c) (((c).hi >> 8) & ((1 << 16) - 1)) | ||
73 | |||
74 | #define context_set_present(c) do {(c).lo |= 1;} while (0) | ||
75 | #define context_set_fault_enable(c) \ | ||
76 | do {(c).lo &= (((u64)-1) << 2) | 1;} while (0) | ||
77 | #define context_set_translation_type(c, val) \ | ||
78 | do { \ | ||
79 | (c).lo &= (((u64)-1) << 4) | 3; \ | ||
80 | (c).lo |= ((val) & 3) << 2; \ | ||
81 | } while (0) | ||
82 | #define CONTEXT_TT_MULTI_LEVEL 0 | ||
83 | #define context_set_address_root(c, val) \ | ||
84 | do {(c).lo |= (val) & PAGE_MASK_4K;} while (0) | ||
85 | #define context_set_address_width(c, val) do {(c).hi |= (val) & 7;} while (0) | ||
86 | #define context_set_domain_id(c, val) \ | ||
87 | do {(c).hi |= ((val) & ((1 << 16) - 1)) << 8;} while (0) | ||
88 | #define context_clear_entry(c) do {(c).lo = 0; (c).hi = 0;} while (0) | ||
89 | |||
90 | /* | ||
91 | * 0: readable | ||
92 | * 1: writable | ||
93 | * 2-6: reserved | ||
94 | * 7: super page | ||
95 | * 8-11: available | ||
96 | * 12-63: Host physcial address | ||
97 | */ | ||
98 | struct dma_pte { | ||
99 | u64 val; | ||
100 | }; | ||
101 | #define dma_clear_pte(p) do {(p).val = 0;} while (0) | ||
102 | |||
103 | #define DMA_PTE_READ (1) | ||
104 | #define DMA_PTE_WRITE (2) | ||
105 | |||
106 | #define dma_set_pte_readable(p) do {(p).val |= DMA_PTE_READ;} while (0) | ||
107 | #define dma_set_pte_writable(p) do {(p).val |= DMA_PTE_WRITE;} while (0) | ||
108 | #define dma_set_pte_prot(p, prot) \ | ||
109 | do {(p).val = ((p).val & ~3) | ((prot) & 3); } while (0) | ||
110 | #define dma_pte_addr(p) ((p).val & PAGE_MASK_4K) | ||
111 | #define dma_set_pte_addr(p, addr) do {\ | ||
112 | (p).val |= ((addr) & PAGE_MASK_4K); } while (0) | ||
113 | #define dma_pte_present(p) (((p).val & 3) != 0) | ||
114 | |||
115 | struct intel_iommu; | ||
116 | |||
117 | struct dmar_domain { | ||
118 | int id; /* domain id */ | ||
119 | struct intel_iommu *iommu; /* back pointer to owning iommu */ | ||
120 | |||
121 | struct list_head devices; /* all devices' list */ | ||
122 | struct iova_domain iovad; /* iova's that belong to this domain */ | ||
123 | |||
124 | struct dma_pte *pgd; /* virtual address */ | ||
125 | spinlock_t mapping_lock; /* page table lock */ | ||
126 | int gaw; /* max guest address width */ | ||
127 | |||
128 | /* adjusted guest address width, 0 is level 2 30-bit */ | ||
129 | int agaw; | ||
130 | |||
131 | #define DOMAIN_FLAG_MULTIPLE_DEVICES 1 | ||
132 | int flags; | ||
133 | }; | ||
134 | |||
135 | /* PCI domain-device relationship */ | ||
136 | struct device_domain_info { | ||
137 | struct list_head link; /* link to domain siblings */ | ||
138 | struct list_head global; /* link to global list */ | ||
139 | u8 bus; /* PCI bus numer */ | ||
140 | u8 devfn; /* PCI devfn number */ | ||
141 | struct pci_dev *dev; /* it's NULL for PCIE-to-PCI bridge */ | ||
142 | struct dmar_domain *domain; /* pointer to domain */ | ||
143 | }; | ||
144 | |||
145 | extern int init_dmars(void); | ||
146 | extern void free_dmar_iommu(struct intel_iommu *iommu); | ||
147 | |||
148 | extern int dmar_disabled; | ||
149 | |||
150 | #ifndef CONFIG_DMAR_GFX_WA | ||
151 | static inline void iommu_prepare_gfx_mapping(void) | ||
152 | { | ||
153 | return; | ||
154 | } | ||
155 | #endif /* !CONFIG_DMAR_GFX_WA */ | ||
156 | |||
157 | #endif | ||
diff --git a/include/linux/ds1286.h b/include/linux/ds1286.h index d8989860e4ce..45ea0aa0aeb9 100644 --- a/include/linux/ds1286.h +++ b/include/linux/ds1286.h | |||
@@ -8,8 +8,6 @@ | |||
8 | #ifndef __LINUX_DS1286_H | 8 | #ifndef __LINUX_DS1286_H |
9 | #define __LINUX_DS1286_H | 9 | #define __LINUX_DS1286_H |
10 | 10 | ||
11 | #include <asm/ds1286.h> | ||
12 | |||
13 | /********************************************************************** | 11 | /********************************************************************** |
14 | * register summary | 12 | * register summary |
15 | **********************************************************************/ | 13 | **********************************************************************/ |
diff --git a/include/linux/dvb/frontend.h b/include/linux/dvb/frontend.h index 6e4ace270276..79a8ed8e6a7d 100644 --- a/include/linux/dvb/frontend.h +++ b/include/linux/dvb/frontend.h | |||
@@ -166,6 +166,7 @@ typedef enum fe_modulation { | |||
166 | VSB_16, | 166 | VSB_16, |
167 | PSK_8, | 167 | PSK_8, |
168 | APSK_16, | 168 | APSK_16, |
169 | APSK_32, | ||
169 | DQPSK, | 170 | DQPSK, |
170 | } fe_modulation_t; | 171 | } fe_modulation_t; |
171 | 172 | ||
@@ -295,6 +296,7 @@ typedef enum fe_delivery_system { | |||
295 | SYS_DVBC_ANNEX_AC, | 296 | SYS_DVBC_ANNEX_AC, |
296 | SYS_DVBC_ANNEX_B, | 297 | SYS_DVBC_ANNEX_B, |
297 | SYS_DVBT, | 298 | SYS_DVBT, |
299 | SYS_DSS, | ||
298 | SYS_DVBS, | 300 | SYS_DVBS, |
299 | SYS_DVBS2, | 301 | SYS_DVBS2, |
300 | SYS_DVBH, | 302 | SYS_DVBH, |
diff --git a/include/linux/dynamic_printk.h b/include/linux/dynamic_printk.h new file mode 100644 index 000000000000..2d528d009074 --- /dev/null +++ b/include/linux/dynamic_printk.h | |||
@@ -0,0 +1,93 @@ | |||
1 | #ifndef _DYNAMIC_PRINTK_H | ||
2 | #define _DYNAMIC_PRINTK_H | ||
3 | |||
4 | #define DYNAMIC_DEBUG_HASH_BITS 6 | ||
5 | #define DEBUG_HASH_TABLE_SIZE (1 << DYNAMIC_DEBUG_HASH_BITS) | ||
6 | |||
7 | #define TYPE_BOOLEAN 1 | ||
8 | |||
9 | #define DYNAMIC_ENABLED_ALL 0 | ||
10 | #define DYNAMIC_ENABLED_NONE 1 | ||
11 | #define DYNAMIC_ENABLED_SOME 2 | ||
12 | |||
13 | extern int dynamic_enabled; | ||
14 | |||
15 | /* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which | ||
16 | * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They | ||
17 | * use independent hash functions, to reduce the chance of false positives. | ||
18 | */ | ||
19 | extern long long dynamic_printk_enabled; | ||
20 | extern long long dynamic_printk_enabled2; | ||
21 | |||
22 | struct mod_debug { | ||
23 | char *modname; | ||
24 | char *logical_modname; | ||
25 | char *flag_names; | ||
26 | int type; | ||
27 | int hash; | ||
28 | int hash2; | ||
29 | } __attribute__((aligned(8))); | ||
30 | |||
31 | int register_dynamic_debug_module(char *mod_name, int type, char *share_name, | ||
32 | char *flags, int hash, int hash2); | ||
33 | |||
34 | #if defined(CONFIG_DYNAMIC_PRINTK_DEBUG) | ||
35 | extern int unregister_dynamic_debug_module(char *mod_name); | ||
36 | extern int __dynamic_dbg_enabled_helper(char *modname, int type, | ||
37 | int value, int hash); | ||
38 | |||
39 | #define __dynamic_dbg_enabled(module, type, value, level, hash) ({ \ | ||
40 | int __ret = 0; \ | ||
41 | if (unlikely((dynamic_printk_enabled & (1LL << DEBUG_HASH)) && \ | ||
42 | (dynamic_printk_enabled2 & (1LL << DEBUG_HASH2)))) \ | ||
43 | __ret = __dynamic_dbg_enabled_helper(module, type, \ | ||
44 | value, hash);\ | ||
45 | __ret; }) | ||
46 | |||
47 | #define dynamic_pr_debug(fmt, ...) do { \ | ||
48 | static char mod_name[] \ | ||
49 | __attribute__((section("__verbose_strings"))) \ | ||
50 | = KBUILD_MODNAME; \ | ||
51 | static struct mod_debug descriptor \ | ||
52 | __used \ | ||
53 | __attribute__((section("__verbose"), aligned(8))) = \ | ||
54 | { mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\ | ||
55 | if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN, \ | ||
56 | 0, 0, DEBUG_HASH)) \ | ||
57 | printk(KERN_DEBUG KBUILD_MODNAME ":" fmt, \ | ||
58 | ##__VA_ARGS__); \ | ||
59 | } while (0) | ||
60 | |||
61 | #define dynamic_dev_dbg(dev, format, ...) do { \ | ||
62 | static char mod_name[] \ | ||
63 | __attribute__((section("__verbose_strings"))) \ | ||
64 | = KBUILD_MODNAME; \ | ||
65 | static struct mod_debug descriptor \ | ||
66 | __used \ | ||
67 | __attribute__((section("__verbose"), aligned(8))) = \ | ||
68 | { mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\ | ||
69 | if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN, \ | ||
70 | 0, 0, DEBUG_HASH)) \ | ||
71 | dev_printk(KERN_DEBUG, dev, \ | ||
72 | KBUILD_MODNAME ": " format, \ | ||
73 | ##__VA_ARGS__); \ | ||
74 | } while (0) | ||
75 | |||
76 | #else | ||
77 | |||
78 | static inline int unregister_dynamic_debug_module(const char *mod_name) | ||
79 | { | ||
80 | return 0; | ||
81 | } | ||
82 | static inline int __dynamic_dbg_enabled_helper(char *modname, int type, | ||
83 | int value, int hash) | ||
84 | { | ||
85 | return 0; | ||
86 | } | ||
87 | |||
88 | #define __dynamic_dbg_enabled(module, type, value, level, hash) ({ 0; }) | ||
89 | #define dynamic_pr_debug(fmt, ...) do { } while (0) | ||
90 | #define dynamic_dev_dbg(dev, format, ...) do { } while (0) | ||
91 | #endif | ||
92 | |||
93 | #endif | ||
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h index 2efe7b863cff..78c775a83f7c 100644 --- a/include/linux/ext2_fs.h +++ b/include/linux/ext2_fs.h | |||
@@ -47,7 +47,7 @@ | |||
47 | #ifdef EXT2FS_DEBUG | 47 | #ifdef EXT2FS_DEBUG |
48 | # define ext2_debug(f, a...) { \ | 48 | # define ext2_debug(f, a...) { \ |
49 | printk ("EXT2-fs DEBUG (%s, %d): %s:", \ | 49 | printk ("EXT2-fs DEBUG (%s, %d): %s:", \ |
50 | __FILE__, __LINE__, __FUNCTION__); \ | 50 | __FILE__, __LINE__, __func__); \ |
51 | printk (f, ## a); \ | 51 | printk (f, ## a); \ |
52 | } | 52 | } |
53 | #else | 53 | #else |
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h index 8120fa1bc235..d14f02918483 100644 --- a/include/linux/ext3_fs.h +++ b/include/linux/ext3_fs.h | |||
@@ -43,7 +43,7 @@ | |||
43 | #define ext3_debug(f, a...) \ | 43 | #define ext3_debug(f, a...) \ |
44 | do { \ | 44 | do { \ |
45 | printk (KERN_DEBUG "EXT3-fs DEBUG (%s, %d): %s:", \ | 45 | printk (KERN_DEBUG "EXT3-fs DEBUG (%s, %d): %s:", \ |
46 | __FILE__, __LINE__, __FUNCTION__); \ | 46 | __FILE__, __LINE__, __func__); \ |
47 | printk (KERN_DEBUG f, ## a); \ | 47 | printk (KERN_DEBUG f, ## a); \ |
48 | } while (0) | 48 | } while (0) |
49 | #else | 49 | #else |
@@ -380,6 +380,8 @@ struct ext3_inode { | |||
380 | #define EXT3_MOUNT_QUOTA 0x80000 /* Some quota option set */ | 380 | #define EXT3_MOUNT_QUOTA 0x80000 /* Some quota option set */ |
381 | #define EXT3_MOUNT_USRQUOTA 0x100000 /* "old" user quota */ | 381 | #define EXT3_MOUNT_USRQUOTA 0x100000 /* "old" user quota */ |
382 | #define EXT3_MOUNT_GRPQUOTA 0x200000 /* "old" group quota */ | 382 | #define EXT3_MOUNT_GRPQUOTA 0x200000 /* "old" group quota */ |
383 | #define EXT3_MOUNT_DATA_ERR_ABORT 0x400000 /* Abort on file data write | ||
384 | * error in ordered mode */ | ||
383 | 385 | ||
384 | /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */ | 386 | /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */ |
385 | #ifndef _LINUX_EXT2_FS_H | 387 | #ifndef _LINUX_EXT2_FS_H |
@@ -871,7 +873,7 @@ extern void ext3_update_dynamic_rev (struct super_block *sb); | |||
871 | #define ext3_std_error(sb, errno) \ | 873 | #define ext3_std_error(sb, errno) \ |
872 | do { \ | 874 | do { \ |
873 | if ((errno)) \ | 875 | if ((errno)) \ |
874 | __ext3_std_error((sb), __FUNCTION__, (errno)); \ | 876 | __ext3_std_error((sb), __func__, (errno)); \ |
875 | } while (0) | 877 | } while (0) |
876 | 878 | ||
877 | /* | 879 | /* |
diff --git a/include/linux/ext3_jbd.h b/include/linux/ext3_jbd.h index 8c43b13a02fe..cf82d519be40 100644 --- a/include/linux/ext3_jbd.h +++ b/include/linux/ext3_jbd.h | |||
@@ -137,17 +137,17 @@ int __ext3_journal_dirty_metadata(const char *where, | |||
137 | handle_t *handle, struct buffer_head *bh); | 137 | handle_t *handle, struct buffer_head *bh); |
138 | 138 | ||
139 | #define ext3_journal_get_undo_access(handle, bh) \ | 139 | #define ext3_journal_get_undo_access(handle, bh) \ |
140 | __ext3_journal_get_undo_access(__FUNCTION__, (handle), (bh)) | 140 | __ext3_journal_get_undo_access(__func__, (handle), (bh)) |
141 | #define ext3_journal_get_write_access(handle, bh) \ | 141 | #define ext3_journal_get_write_access(handle, bh) \ |
142 | __ext3_journal_get_write_access(__FUNCTION__, (handle), (bh)) | 142 | __ext3_journal_get_write_access(__func__, (handle), (bh)) |
143 | #define ext3_journal_revoke(handle, blocknr, bh) \ | 143 | #define ext3_journal_revoke(handle, blocknr, bh) \ |
144 | __ext3_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh)) | 144 | __ext3_journal_revoke(__func__, (handle), (blocknr), (bh)) |
145 | #define ext3_journal_get_create_access(handle, bh) \ | 145 | #define ext3_journal_get_create_access(handle, bh) \ |
146 | __ext3_journal_get_create_access(__FUNCTION__, (handle), (bh)) | 146 | __ext3_journal_get_create_access(__func__, (handle), (bh)) |
147 | #define ext3_journal_dirty_metadata(handle, bh) \ | 147 | #define ext3_journal_dirty_metadata(handle, bh) \ |
148 | __ext3_journal_dirty_metadata(__FUNCTION__, (handle), (bh)) | 148 | __ext3_journal_dirty_metadata(__func__, (handle), (bh)) |
149 | #define ext3_journal_forget(handle, bh) \ | 149 | #define ext3_journal_forget(handle, bh) \ |
150 | __ext3_journal_forget(__FUNCTION__, (handle), (bh)) | 150 | __ext3_journal_forget(__func__, (handle), (bh)) |
151 | 151 | ||
152 | int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh); | 152 | int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh); |
153 | 153 | ||
@@ -160,7 +160,7 @@ static inline handle_t *ext3_journal_start(struct inode *inode, int nblocks) | |||
160 | } | 160 | } |
161 | 161 | ||
162 | #define ext3_journal_stop(handle) \ | 162 | #define ext3_journal_stop(handle) \ |
163 | __ext3_journal_stop(__FUNCTION__, (handle)) | 163 | __ext3_journal_stop(__func__, (handle)) |
164 | 164 | ||
165 | static inline handle_t *ext3_journal_current_handle(void) | 165 | static inline handle_t *ext3_journal_current_handle(void) |
166 | { | 166 | { |
diff --git a/include/linux/fb.h b/include/linux/fb.h index 531ccd5f5960..75a81eaf3430 100644 --- a/include/linux/fb.h +++ b/include/linux/fb.h | |||
@@ -808,6 +808,7 @@ struct fb_tile_ops { | |||
808 | struct fb_info { | 808 | struct fb_info { |
809 | int node; | 809 | int node; |
810 | int flags; | 810 | int flags; |
811 | struct mutex lock; /* Lock for open/release/ioctl funcs */ | ||
811 | struct fb_var_screeninfo var; /* Current var */ | 812 | struct fb_var_screeninfo var; /* Current var */ |
812 | struct fb_fix_screeninfo fix; /* Current fix */ | 813 | struct fb_fix_screeninfo fix; /* Current fix */ |
813 | struct fb_monspecs monspecs; /* Current Monitor specs */ | 814 | struct fb_monspecs monspecs; /* Current Monitor specs */ |
diff --git a/include/linux/firewire-cdev.h b/include/linux/firewire-cdev.h index 0f0e271f97fa..4d078e99c017 100644 --- a/include/linux/firewire-cdev.h +++ b/include/linux/firewire-cdev.h | |||
@@ -154,8 +154,13 @@ struct fw_cdev_event_iso_interrupt { | |||
154 | * @request: Valid if @common.type == %FW_CDEV_EVENT_REQUEST | 154 | * @request: Valid if @common.type == %FW_CDEV_EVENT_REQUEST |
155 | * @iso_interrupt: Valid if @common.type == %FW_CDEV_EVENT_ISO_INTERRUPT | 155 | * @iso_interrupt: Valid if @common.type == %FW_CDEV_EVENT_ISO_INTERRUPT |
156 | * | 156 | * |
157 | * Convenience union for userspace use. Events could be read(2) into a char | 157 | * Convenience union for userspace use. Events could be read(2) into an |
158 | * buffer and then cast to this union for further processing. | 158 | * appropriately aligned char buffer and then cast to this union for further |
159 | * processing. Note that for a request, response or iso_interrupt event, | ||
160 | * the data[] or header[] may make the size of the full event larger than | ||
161 | * sizeof(union fw_cdev_event). Also note that if you attempt to read(2) | ||
162 | * an event into a buffer that is not large enough for it, the data that does | ||
163 | * not fit will be discarded so that the next read(2) will return a new event. | ||
159 | */ | 164 | */ |
160 | union fw_cdev_event { | 165 | union fw_cdev_event { |
161 | struct fw_cdev_event_common common; | 166 | struct fw_cdev_event_common common; |
diff --git a/include/linux/freezer.h b/include/linux/freezer.h index deddeedf3257..8f225339eee9 100644 --- a/include/linux/freezer.h +++ b/include/linux/freezer.h | |||
@@ -6,7 +6,7 @@ | |||
6 | #include <linux/sched.h> | 6 | #include <linux/sched.h> |
7 | #include <linux/wait.h> | 7 | #include <linux/wait.h> |
8 | 8 | ||
9 | #ifdef CONFIG_PM_SLEEP | 9 | #ifdef CONFIG_FREEZER |
10 | /* | 10 | /* |
11 | * Check if a process has been frozen | 11 | * Check if a process has been frozen |
12 | */ | 12 | */ |
@@ -39,28 +39,18 @@ static inline void clear_freeze_flag(struct task_struct *p) | |||
39 | clear_tsk_thread_flag(p, TIF_FREEZE); | 39 | clear_tsk_thread_flag(p, TIF_FREEZE); |
40 | } | 40 | } |
41 | 41 | ||
42 | static inline bool should_send_signal(struct task_struct *p) | ||
43 | { | ||
44 | return !(p->flags & PF_FREEZER_NOSIG); | ||
45 | } | ||
46 | |||
42 | /* | 47 | /* |
43 | * Wake up a frozen process | 48 | * Wake up a frozen process |
44 | * | ||
45 | * task_lock() is taken to prevent the race with refrigerator() which may | ||
46 | * occur if the freezing of tasks fails. Namely, without the lock, if the | ||
47 | * freezing of tasks failed, thaw_tasks() might have run before a task in | ||
48 | * refrigerator() could call frozen_process(), in which case the task would be | ||
49 | * frozen and no one would thaw it. | ||
50 | */ | 49 | */ |
51 | static inline int thaw_process(struct task_struct *p) | 50 | extern int __thaw_process(struct task_struct *p); |
52 | { | 51 | |
53 | task_lock(p); | 52 | /* Takes and releases task alloc lock using task_lock() */ |
54 | if (frozen(p)) { | 53 | extern int thaw_process(struct task_struct *p); |
55 | p->flags &= ~PF_FROZEN; | ||
56 | task_unlock(p); | ||
57 | wake_up_process(p); | ||
58 | return 1; | ||
59 | } | ||
60 | clear_freeze_flag(p); | ||
61 | task_unlock(p); | ||
62 | return 0; | ||
63 | } | ||
64 | 54 | ||
65 | extern void refrigerator(void); | 55 | extern void refrigerator(void); |
66 | extern int freeze_processes(void); | 56 | extern int freeze_processes(void); |
@@ -75,6 +65,15 @@ static inline int try_to_freeze(void) | |||
75 | return 0; | 65 | return 0; |
76 | } | 66 | } |
77 | 67 | ||
68 | extern bool freeze_task(struct task_struct *p, bool sig_only); | ||
69 | extern void cancel_freezing(struct task_struct *p); | ||
70 | |||
71 | #ifdef CONFIG_CGROUP_FREEZER | ||
72 | extern int cgroup_frozen(struct task_struct *task); | ||
73 | #else /* !CONFIG_CGROUP_FREEZER */ | ||
74 | static inline int cgroup_frozen(struct task_struct *task) { return 0; } | ||
75 | #endif /* !CONFIG_CGROUP_FREEZER */ | ||
76 | |||
78 | /* | 77 | /* |
79 | * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it | 78 | * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it |
80 | * calls wait_for_completion(&vfork) and reset right after it returns from this | 79 | * calls wait_for_completion(&vfork) and reset right after it returns from this |
@@ -166,7 +165,7 @@ static inline void set_freezable_with_signal(void) | |||
166 | } while (try_to_freeze()); \ | 165 | } while (try_to_freeze()); \ |
167 | __retval; \ | 166 | __retval; \ |
168 | }) | 167 | }) |
169 | #else /* !CONFIG_PM_SLEEP */ | 168 | #else /* !CONFIG_FREEZER */ |
170 | static inline int frozen(struct task_struct *p) { return 0; } | 169 | static inline int frozen(struct task_struct *p) { return 0; } |
171 | static inline int freezing(struct task_struct *p) { return 0; } | 170 | static inline int freezing(struct task_struct *p) { return 0; } |
172 | static inline void set_freeze_flag(struct task_struct *p) {} | 171 | static inline void set_freeze_flag(struct task_struct *p) {} |
@@ -191,6 +190,6 @@ static inline void set_freezable_with_signal(void) {} | |||
191 | #define wait_event_freezable_timeout(wq, condition, timeout) \ | 190 | #define wait_event_freezable_timeout(wq, condition, timeout) \ |
192 | wait_event_interruptible_timeout(wq, condition, timeout) | 191 | wait_event_interruptible_timeout(wq, condition, timeout) |
193 | 192 | ||
194 | #endif /* !CONFIG_PM_SLEEP */ | 193 | #endif /* !CONFIG_FREEZER */ |
195 | 194 | ||
196 | #endif /* FREEZER_H_INCLUDED */ | 195 | #endif /* FREEZER_H_INCLUDED */ |
diff --git a/include/linux/fuse.h b/include/linux/fuse.h index 265635dc9908..350fe9767bbc 100644 --- a/include/linux/fuse.h +++ b/include/linux/fuse.h | |||
@@ -17,8 +17,14 @@ | |||
17 | * - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in | 17 | * - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in |
18 | * - add blksize field to fuse_attr | 18 | * - add blksize field to fuse_attr |
19 | * - add file flags field to fuse_read_in and fuse_write_in | 19 | * - add file flags field to fuse_read_in and fuse_write_in |
20 | * | ||
21 | * 7.10 | ||
22 | * - add nonseekable open flag | ||
20 | */ | 23 | */ |
21 | 24 | ||
25 | #ifndef _LINUX_FUSE_H | ||
26 | #define _LINUX_FUSE_H | ||
27 | |||
22 | #include <asm/types.h> | 28 | #include <asm/types.h> |
23 | #include <linux/major.h> | 29 | #include <linux/major.h> |
24 | 30 | ||
@@ -26,7 +32,7 @@ | |||
26 | #define FUSE_KERNEL_VERSION 7 | 32 | #define FUSE_KERNEL_VERSION 7 |
27 | 33 | ||
28 | /** Minor version number of this interface */ | 34 | /** Minor version number of this interface */ |
29 | #define FUSE_KERNEL_MINOR_VERSION 9 | 35 | #define FUSE_KERNEL_MINOR_VERSION 10 |
30 | 36 | ||
31 | /** The node ID of the root inode */ | 37 | /** The node ID of the root inode */ |
32 | #define FUSE_ROOT_ID 1 | 38 | #define FUSE_ROOT_ID 1 |
@@ -98,9 +104,11 @@ struct fuse_file_lock { | |||
98 | * | 104 | * |
99 | * FOPEN_DIRECT_IO: bypass page cache for this open file | 105 | * FOPEN_DIRECT_IO: bypass page cache for this open file |
100 | * FOPEN_KEEP_CACHE: don't invalidate the data cache on open | 106 | * FOPEN_KEEP_CACHE: don't invalidate the data cache on open |
107 | * FOPEN_NONSEEKABLE: the file is not seekable | ||
101 | */ | 108 | */ |
102 | #define FOPEN_DIRECT_IO (1 << 0) | 109 | #define FOPEN_DIRECT_IO (1 << 0) |
103 | #define FOPEN_KEEP_CACHE (1 << 1) | 110 | #define FOPEN_KEEP_CACHE (1 << 1) |
111 | #define FOPEN_NONSEEKABLE (1 << 2) | ||
104 | 112 | ||
105 | /** | 113 | /** |
106 | * INIT request/reply flags | 114 | * INIT request/reply flags |
@@ -409,3 +417,5 @@ struct fuse_dirent { | |||
409 | #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1)) | 417 | #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1)) |
410 | #define FUSE_DIRENT_SIZE(d) \ | 418 | #define FUSE_DIRENT_SIZE(d) \ |
411 | FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen) | 419 | FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen) |
420 | |||
421 | #endif /* _LINUX_FUSE_H */ | ||
diff --git a/include/linux/gameport.h b/include/linux/gameport.h index f64e29c0ef3f..0cd825f7363a 100644 --- a/include/linux/gameport.h +++ b/include/linux/gameport.h | |||
@@ -146,10 +146,11 @@ static inline void gameport_unpin_driver(struct gameport *gameport) | |||
146 | mutex_unlock(&gameport->drv_mutex); | 146 | mutex_unlock(&gameport->drv_mutex); |
147 | } | 147 | } |
148 | 148 | ||
149 | void __gameport_register_driver(struct gameport_driver *drv, struct module *owner); | 149 | int __gameport_register_driver(struct gameport_driver *drv, |
150 | static inline void gameport_register_driver(struct gameport_driver *drv) | 150 | struct module *owner, const char *mod_name); |
151 | static inline int __must_check gameport_register_driver(struct gameport_driver *drv) | ||
151 | { | 152 | { |
152 | __gameport_register_driver(drv, THIS_MODULE); | 153 | return __gameport_register_driver(drv, THIS_MODULE, KBUILD_MODNAME); |
153 | } | 154 | } |
154 | 155 | ||
155 | void gameport_unregister_driver(struct gameport_driver *drv); | 156 | void gameport_unregister_driver(struct gameport_driver *drv); |
diff --git a/include/linux/gpio.h b/include/linux/gpio.h index 730a20b83576..e10c49a5b96e 100644 --- a/include/linux/gpio.h +++ b/include/linux/gpio.h | |||
@@ -8,6 +8,7 @@ | |||
8 | 8 | ||
9 | #else | 9 | #else |
10 | 10 | ||
11 | #include <linux/kernel.h> | ||
11 | #include <linux/types.h> | 12 | #include <linux/types.h> |
12 | #include <linux/errno.h> | 13 | #include <linux/errno.h> |
13 | 14 | ||
@@ -32,6 +33,8 @@ static inline int gpio_request(unsigned gpio, const char *label) | |||
32 | 33 | ||
33 | static inline void gpio_free(unsigned gpio) | 34 | static inline void gpio_free(unsigned gpio) |
34 | { | 35 | { |
36 | might_sleep(); | ||
37 | |||
35 | /* GPIO can never have been requested */ | 38 | /* GPIO can never have been requested */ |
36 | WARN_ON(1); | 39 | WARN_ON(1); |
37 | } | 40 | } |
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h index 2f245fe63bda..9a4e35cd5f79 100644 --- a/include/linux/hrtimer.h +++ b/include/linux/hrtimer.h | |||
@@ -125,12 +125,12 @@ struct hrtimer { | |||
125 | enum hrtimer_restart (*function)(struct hrtimer *); | 125 | enum hrtimer_restart (*function)(struct hrtimer *); |
126 | struct hrtimer_clock_base *base; | 126 | struct hrtimer_clock_base *base; |
127 | unsigned long state; | 127 | unsigned long state; |
128 | enum hrtimer_cb_mode cb_mode; | ||
129 | struct list_head cb_entry; | 128 | struct list_head cb_entry; |
129 | enum hrtimer_cb_mode cb_mode; | ||
130 | #ifdef CONFIG_TIMER_STATS | 130 | #ifdef CONFIG_TIMER_STATS |
131 | int start_pid; | ||
131 | void *start_site; | 132 | void *start_site; |
132 | char start_comm[16]; | 133 | char start_comm[16]; |
133 | int start_pid; | ||
134 | #endif | 134 | #endif |
135 | }; | 135 | }; |
136 | 136 | ||
@@ -155,10 +155,8 @@ struct hrtimer_sleeper { | |||
155 | * @first: pointer to the timer node which expires first | 155 | * @first: pointer to the timer node which expires first |
156 | * @resolution: the resolution of the clock, in nanoseconds | 156 | * @resolution: the resolution of the clock, in nanoseconds |
157 | * @get_time: function to retrieve the current time of the clock | 157 | * @get_time: function to retrieve the current time of the clock |
158 | * @get_softirq_time: function to retrieve the current time from the softirq | ||
159 | * @softirq_time: the time when running the hrtimer queue in the softirq | 158 | * @softirq_time: the time when running the hrtimer queue in the softirq |
160 | * @offset: offset of this clock to the monotonic base | 159 | * @offset: offset of this clock to the monotonic base |
161 | * @reprogram: function to reprogram the timer event | ||
162 | */ | 160 | */ |
163 | struct hrtimer_clock_base { | 161 | struct hrtimer_clock_base { |
164 | struct hrtimer_cpu_base *cpu_base; | 162 | struct hrtimer_cpu_base *cpu_base; |
@@ -167,13 +165,9 @@ struct hrtimer_clock_base { | |||
167 | struct rb_node *first; | 165 | struct rb_node *first; |
168 | ktime_t resolution; | 166 | ktime_t resolution; |
169 | ktime_t (*get_time)(void); | 167 | ktime_t (*get_time)(void); |
170 | ktime_t (*get_softirq_time)(void); | ||
171 | ktime_t softirq_time; | 168 | ktime_t softirq_time; |
172 | #ifdef CONFIG_HIGH_RES_TIMERS | 169 | #ifdef CONFIG_HIGH_RES_TIMERS |
173 | ktime_t offset; | 170 | ktime_t offset; |
174 | int (*reprogram)(struct hrtimer *t, | ||
175 | struct hrtimer_clock_base *b, | ||
176 | ktime_t n); | ||
177 | #endif | 171 | #endif |
178 | }; | 172 | }; |
179 | 173 | ||
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h index 493435bcdbe5..01d67ba9e985 100644 --- a/include/linux/i2c-id.h +++ b/include/linux/i2c-id.h | |||
@@ -60,7 +60,7 @@ | |||
60 | #define I2C_DRIVERID_WM8775 69 /* wm8775 audio processor */ | 60 | #define I2C_DRIVERID_WM8775 69 /* wm8775 audio processor */ |
61 | #define I2C_DRIVERID_CS53L32A 70 /* cs53l32a audio processor */ | 61 | #define I2C_DRIVERID_CS53L32A 70 /* cs53l32a audio processor */ |
62 | #define I2C_DRIVERID_CX25840 71 /* cx2584x video encoder */ | 62 | #define I2C_DRIVERID_CX25840 71 /* cx2584x video encoder */ |
63 | #define I2C_DRIVERID_SAA7127 72 /* saa7124 video encoder */ | 63 | #define I2C_DRIVERID_SAA7127 72 /* saa7127 video encoder */ |
64 | #define I2C_DRIVERID_SAA711X 73 /* saa711x video encoders */ | 64 | #define I2C_DRIVERID_SAA711X 73 /* saa711x video encoders */ |
65 | #define I2C_DRIVERID_AKITAIOEXP 74 /* IO Expander on Sharp SL-C1000 */ | 65 | #define I2C_DRIVERID_AKITAIOEXP 74 /* IO Expander on Sharp SL-C1000 */ |
66 | #define I2C_DRIVERID_INFRARED 75 /* I2C InfraRed on Video boards */ | 66 | #define I2C_DRIVERID_INFRARED 75 /* I2C InfraRed on Video boards */ |
diff --git a/include/linux/i2c/twl4030.h b/include/linux/i2c/twl4030.h new file mode 100644 index 000000000000..cdb453162a97 --- /dev/null +++ b/include/linux/i2c/twl4030.h | |||
@@ -0,0 +1,339 @@ | |||
1 | /* | ||
2 | * twl4030.h - header for TWL4030 PM and audio CODEC device | ||
3 | * | ||
4 | * Copyright (C) 2005-2006 Texas Instruments, Inc. | ||
5 | * | ||
6 | * Based on tlv320aic23.c: | ||
7 | * Copyright (c) by Kai Svahn <kai.svahn@nokia.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License, or | ||
12 | * (at your option) any later version. | ||
13 | * | ||
14 | * This program is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | * GNU General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU General Public License | ||
20 | * along with this program; if not, write to the Free Software | ||
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #ifndef __TWL4030_H_ | ||
26 | #define __TWL4030_H_ | ||
27 | |||
28 | /* | ||
29 | * Using the twl4030 core we address registers using a pair | ||
30 | * { module id, relative register offset } | ||
31 | * which that core then maps to the relevant | ||
32 | * { i2c slave, absolute register address } | ||
33 | * | ||
34 | * The module IDs are meaningful only to the twl4030 core code, | ||
35 | * which uses them as array indices to look up the first register | ||
36 | * address each module uses within a given i2c slave. | ||
37 | */ | ||
38 | |||
39 | /* Slave 0 (i2c address 0x48) */ | ||
40 | #define TWL4030_MODULE_USB 0x00 | ||
41 | |||
42 | /* Slave 1 (i2c address 0x49) */ | ||
43 | #define TWL4030_MODULE_AUDIO_VOICE 0x01 | ||
44 | #define TWL4030_MODULE_GPIO 0x02 | ||
45 | #define TWL4030_MODULE_INTBR 0x03 | ||
46 | #define TWL4030_MODULE_PIH 0x04 | ||
47 | #define TWL4030_MODULE_TEST 0x05 | ||
48 | |||
49 | /* Slave 2 (i2c address 0x4a) */ | ||
50 | #define TWL4030_MODULE_KEYPAD 0x06 | ||
51 | #define TWL4030_MODULE_MADC 0x07 | ||
52 | #define TWL4030_MODULE_INTERRUPTS 0x08 | ||
53 | #define TWL4030_MODULE_LED 0x09 | ||
54 | #define TWL4030_MODULE_MAIN_CHARGE 0x0A | ||
55 | #define TWL4030_MODULE_PRECHARGE 0x0B | ||
56 | #define TWL4030_MODULE_PWM0 0x0C | ||
57 | #define TWL4030_MODULE_PWM1 0x0D | ||
58 | #define TWL4030_MODULE_PWMA 0x0E | ||
59 | #define TWL4030_MODULE_PWMB 0x0F | ||
60 | |||
61 | /* Slave 3 (i2c address 0x4b) */ | ||
62 | #define TWL4030_MODULE_BACKUP 0x10 | ||
63 | #define TWL4030_MODULE_INT 0x11 | ||
64 | #define TWL4030_MODULE_PM_MASTER 0x12 | ||
65 | #define TWL4030_MODULE_PM_RECEIVER 0x13 | ||
66 | #define TWL4030_MODULE_RTC 0x14 | ||
67 | #define TWL4030_MODULE_SECURED_REG 0x15 | ||
68 | |||
69 | /* | ||
70 | * Read and write single 8-bit registers | ||
71 | */ | ||
72 | int twl4030_i2c_write_u8(u8 mod_no, u8 val, u8 reg); | ||
73 | int twl4030_i2c_read_u8(u8 mod_no, u8 *val, u8 reg); | ||
74 | |||
75 | /* | ||
76 | * Read and write several 8-bit registers at once. | ||
77 | * | ||
78 | * IMPORTANT: For twl4030_i2c_write(), allocate num_bytes + 1 | ||
79 | * for the value, and populate your data starting at offset 1. | ||
80 | */ | ||
81 | int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, u8 num_bytes); | ||
82 | int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, u8 num_bytes); | ||
83 | |||
84 | /*----------------------------------------------------------------------*/ | ||
85 | |||
86 | /* | ||
87 | * NOTE: at up to 1024 registers, this is a big chip. | ||
88 | * | ||
89 | * Avoid putting register declarations in this file, instead of into | ||
90 | * a driver-private file, unless some of the registers in a block | ||
91 | * need to be shared with other drivers. One example is blocks that | ||
92 | * have Secondary IRQ Handler (SIH) registers. | ||
93 | */ | ||
94 | |||
95 | #define TWL4030_SIH_CTRL_EXCLEN_MASK BIT(0) | ||
96 | #define TWL4030_SIH_CTRL_PENDDIS_MASK BIT(1) | ||
97 | #define TWL4030_SIH_CTRL_COR_MASK BIT(2) | ||
98 | |||
99 | /*----------------------------------------------------------------------*/ | ||
100 | |||
101 | /* | ||
102 | * GPIO Block Register offsets (use TWL4030_MODULE_GPIO) | ||
103 | */ | ||
104 | |||
105 | #define REG_GPIODATAIN1 0x0 | ||
106 | #define REG_GPIODATAIN2 0x1 | ||
107 | #define REG_GPIODATAIN3 0x2 | ||
108 | #define REG_GPIODATADIR1 0x3 | ||
109 | #define REG_GPIODATADIR2 0x4 | ||
110 | #define REG_GPIODATADIR3 0x5 | ||
111 | #define REG_GPIODATAOUT1 0x6 | ||
112 | #define REG_GPIODATAOUT2 0x7 | ||
113 | #define REG_GPIODATAOUT3 0x8 | ||
114 | #define REG_CLEARGPIODATAOUT1 0x9 | ||
115 | #define REG_CLEARGPIODATAOUT2 0xA | ||
116 | #define REG_CLEARGPIODATAOUT3 0xB | ||
117 | #define REG_SETGPIODATAOUT1 0xC | ||
118 | #define REG_SETGPIODATAOUT2 0xD | ||
119 | #define REG_SETGPIODATAOUT3 0xE | ||
120 | #define REG_GPIO_DEBEN1 0xF | ||
121 | #define REG_GPIO_DEBEN2 0x10 | ||
122 | #define REG_GPIO_DEBEN3 0x11 | ||
123 | #define REG_GPIO_CTRL 0x12 | ||
124 | #define REG_GPIOPUPDCTR1 0x13 | ||
125 | #define REG_GPIOPUPDCTR2 0x14 | ||
126 | #define REG_GPIOPUPDCTR3 0x15 | ||
127 | #define REG_GPIOPUPDCTR4 0x16 | ||
128 | #define REG_GPIOPUPDCTR5 0x17 | ||
129 | #define REG_GPIO_ISR1A 0x19 | ||
130 | #define REG_GPIO_ISR2A 0x1A | ||
131 | #define REG_GPIO_ISR3A 0x1B | ||
132 | #define REG_GPIO_IMR1A 0x1C | ||
133 | #define REG_GPIO_IMR2A 0x1D | ||
134 | #define REG_GPIO_IMR3A 0x1E | ||
135 | #define REG_GPIO_ISR1B 0x1F | ||
136 | #define REG_GPIO_ISR2B 0x20 | ||
137 | #define REG_GPIO_ISR3B 0x21 | ||
138 | #define REG_GPIO_IMR1B 0x22 | ||
139 | #define REG_GPIO_IMR2B 0x23 | ||
140 | #define REG_GPIO_IMR3B 0x24 | ||
141 | #define REG_GPIO_EDR1 0x28 | ||
142 | #define REG_GPIO_EDR2 0x29 | ||
143 | #define REG_GPIO_EDR3 0x2A | ||
144 | #define REG_GPIO_EDR4 0x2B | ||
145 | #define REG_GPIO_EDR5 0x2C | ||
146 | #define REG_GPIO_SIH_CTRL 0x2D | ||
147 | |||
148 | /* Up to 18 signals are available as GPIOs, when their | ||
149 | * pins are not assigned to another use (such as ULPI/USB). | ||
150 | */ | ||
151 | #define TWL4030_GPIO_MAX 18 | ||
152 | |||
153 | /*----------------------------------------------------------------------*/ | ||
154 | |||
155 | /* | ||
156 | * Keypad register offsets (use TWL4030_MODULE_KEYPAD) | ||
157 | * ... SIH/interrupt only | ||
158 | */ | ||
159 | |||
160 | #define TWL4030_KEYPAD_KEYP_ISR1 0x11 | ||
161 | #define TWL4030_KEYPAD_KEYP_IMR1 0x12 | ||
162 | #define TWL4030_KEYPAD_KEYP_ISR2 0x13 | ||
163 | #define TWL4030_KEYPAD_KEYP_IMR2 0x14 | ||
164 | #define TWL4030_KEYPAD_KEYP_SIR 0x15 /* test register */ | ||
165 | #define TWL4030_KEYPAD_KEYP_EDR 0x16 | ||
166 | #define TWL4030_KEYPAD_KEYP_SIH_CTRL 0x17 | ||
167 | |||
168 | /*----------------------------------------------------------------------*/ | ||
169 | |||
170 | /* | ||
171 | * Multichannel ADC register offsets (use TWL4030_MODULE_MADC) | ||
172 | * ... SIH/interrupt only | ||
173 | */ | ||
174 | |||
175 | #define TWL4030_MADC_ISR1 0x61 | ||
176 | #define TWL4030_MADC_IMR1 0x62 | ||
177 | #define TWL4030_MADC_ISR2 0x63 | ||
178 | #define TWL4030_MADC_IMR2 0x64 | ||
179 | #define TWL4030_MADC_SIR 0x65 /* test register */ | ||
180 | #define TWL4030_MADC_EDR 0x66 | ||
181 | #define TWL4030_MADC_SIH_CTRL 0x67 | ||
182 | |||
183 | /*----------------------------------------------------------------------*/ | ||
184 | |||
185 | /* | ||
186 | * Battery charger register offsets (use TWL4030_MODULE_INTERRUPTS) | ||
187 | */ | ||
188 | |||
189 | #define TWL4030_INTERRUPTS_BCIISR1A 0x0 | ||
190 | #define TWL4030_INTERRUPTS_BCIISR2A 0x1 | ||
191 | #define TWL4030_INTERRUPTS_BCIIMR1A 0x2 | ||
192 | #define TWL4030_INTERRUPTS_BCIIMR2A 0x3 | ||
193 | #define TWL4030_INTERRUPTS_BCIISR1B 0x4 | ||
194 | #define TWL4030_INTERRUPTS_BCIISR2B 0x5 | ||
195 | #define TWL4030_INTERRUPTS_BCIIMR1B 0x6 | ||
196 | #define TWL4030_INTERRUPTS_BCIIMR2B 0x7 | ||
197 | #define TWL4030_INTERRUPTS_BCISIR1 0x8 /* test register */ | ||
198 | #define TWL4030_INTERRUPTS_BCISIR2 0x9 /* test register */ | ||
199 | #define TWL4030_INTERRUPTS_BCIEDR1 0xa | ||
200 | #define TWL4030_INTERRUPTS_BCIEDR2 0xb | ||
201 | #define TWL4030_INTERRUPTS_BCIEDR3 0xc | ||
202 | #define TWL4030_INTERRUPTS_BCISIHCTRL 0xd | ||
203 | |||
204 | /*----------------------------------------------------------------------*/ | ||
205 | |||
206 | /* | ||
207 | * Power Interrupt block register offsets (use TWL4030_MODULE_INT) | ||
208 | */ | ||
209 | |||
210 | #define TWL4030_INT_PWR_ISR1 0x0 | ||
211 | #define TWL4030_INT_PWR_IMR1 0x1 | ||
212 | #define TWL4030_INT_PWR_ISR2 0x2 | ||
213 | #define TWL4030_INT_PWR_IMR2 0x3 | ||
214 | #define TWL4030_INT_PWR_SIR 0x4 /* test register */ | ||
215 | #define TWL4030_INT_PWR_EDR1 0x5 | ||
216 | #define TWL4030_INT_PWR_EDR2 0x6 | ||
217 | #define TWL4030_INT_PWR_SIH_CTRL 0x7 | ||
218 | |||
219 | /*----------------------------------------------------------------------*/ | ||
220 | |||
221 | struct twl4030_bci_platform_data { | ||
222 | int *battery_tmp_tbl; | ||
223 | unsigned int tblsize; | ||
224 | }; | ||
225 | |||
226 | /* TWL4030_GPIO_MAX (18) GPIOs, with interrupts */ | ||
227 | struct twl4030_gpio_platform_data { | ||
228 | int gpio_base; | ||
229 | unsigned irq_base, irq_end; | ||
230 | |||
231 | /* For gpio-N, bit (1 << N) in "pullups" is set if that pullup | ||
232 | * should be enabled. Else, if that bit is set in "pulldowns", | ||
233 | * that pulldown is enabled. Don't waste power by letting any | ||
234 | * digital inputs float... | ||
235 | */ | ||
236 | u32 pullups; | ||
237 | u32 pulldowns; | ||
238 | |||
239 | int (*setup)(struct device *dev, | ||
240 | unsigned gpio, unsigned ngpio); | ||
241 | int (*teardown)(struct device *dev, | ||
242 | unsigned gpio, unsigned ngpio); | ||
243 | }; | ||
244 | |||
245 | struct twl4030_madc_platform_data { | ||
246 | int irq_line; | ||
247 | }; | ||
248 | |||
249 | struct twl4030_keypad_data { | ||
250 | int rows; | ||
251 | int cols; | ||
252 | int *keymap; | ||
253 | int irq; | ||
254 | unsigned int keymapsize; | ||
255 | unsigned int rep:1; | ||
256 | }; | ||
257 | |||
258 | enum twl4030_usb_mode { | ||
259 | T2_USB_MODE_ULPI = 1, | ||
260 | T2_USB_MODE_CEA2011_3PIN = 2, | ||
261 | }; | ||
262 | |||
263 | struct twl4030_usb_data { | ||
264 | enum twl4030_usb_mode usb_mode; | ||
265 | }; | ||
266 | |||
267 | struct twl4030_platform_data { | ||
268 | unsigned irq_base, irq_end; | ||
269 | struct twl4030_bci_platform_data *bci; | ||
270 | struct twl4030_gpio_platform_data *gpio; | ||
271 | struct twl4030_madc_platform_data *madc; | ||
272 | struct twl4030_keypad_data *keypad; | ||
273 | struct twl4030_usb_data *usb; | ||
274 | |||
275 | /* REVISIT more to come ... _nothing_ should be hard-wired */ | ||
276 | }; | ||
277 | |||
278 | /*----------------------------------------------------------------------*/ | ||
279 | |||
280 | /* | ||
281 | * FIXME completely stop using TWL4030_IRQ_BASE ... instead, pass the | ||
282 | * IRQ data to subsidiary devices using platform device resources. | ||
283 | */ | ||
284 | |||
285 | /* IRQ information-need base */ | ||
286 | #include <mach/irqs.h> | ||
287 | /* TWL4030 interrupts */ | ||
288 | |||
289 | /* #define TWL4030_MODIRQ_GPIO (TWL4030_IRQ_BASE + 0) */ | ||
290 | #define TWL4030_MODIRQ_KEYPAD (TWL4030_IRQ_BASE + 1) | ||
291 | #define TWL4030_MODIRQ_BCI (TWL4030_IRQ_BASE + 2) | ||
292 | #define TWL4030_MODIRQ_MADC (TWL4030_IRQ_BASE + 3) | ||
293 | /* #define TWL4030_MODIRQ_USB (TWL4030_IRQ_BASE + 4) */ | ||
294 | #define TWL4030_MODIRQ_PWR (TWL4030_IRQ_BASE + 5) | ||
295 | |||
296 | #define TWL4030_PWRIRQ_PWRBTN (TWL4030_PWR_IRQ_BASE + 0) | ||
297 | #define TWL4030_PWRIRQ_CHG_PRES (TWL4030_PWR_IRQ_BASE + 1) | ||
298 | #define TWL4030_PWRIRQ_USB_PRES (TWL4030_PWR_IRQ_BASE + 2) | ||
299 | #define TWL4030_PWRIRQ_RTC (TWL4030_PWR_IRQ_BASE + 3) | ||
300 | #define TWL4030_PWRIRQ_HOT_DIE (TWL4030_PWR_IRQ_BASE + 4) | ||
301 | #define TWL4030_PWRIRQ_PWROK_TIMEOUT (TWL4030_PWR_IRQ_BASE + 5) | ||
302 | #define TWL4030_PWRIRQ_MBCHG (TWL4030_PWR_IRQ_BASE + 6) | ||
303 | #define TWL4030_PWRIRQ_SC_DETECT (TWL4030_PWR_IRQ_BASE + 7) | ||
304 | |||
305 | /* Rest are unsued currently*/ | ||
306 | |||
307 | /* Offsets to Power Registers */ | ||
308 | #define TWL4030_VDAC_DEV_GRP 0x3B | ||
309 | #define TWL4030_VDAC_DEDICATED 0x3E | ||
310 | #define TWL4030_VAUX1_DEV_GRP 0x17 | ||
311 | #define TWL4030_VAUX1_DEDICATED 0x1A | ||
312 | #define TWL4030_VAUX2_DEV_GRP 0x1B | ||
313 | #define TWL4030_VAUX2_DEDICATED 0x1E | ||
314 | #define TWL4030_VAUX3_DEV_GRP 0x1F | ||
315 | #define TWL4030_VAUX3_DEDICATED 0x22 | ||
316 | |||
317 | /* TWL4030 GPIO interrupt definitions */ | ||
318 | |||
319 | #define TWL4030_GPIO_IRQ_NO(n) (TWL4030_GPIO_IRQ_BASE + (n)) | ||
320 | #define TWL4030_GPIO_IS_ENABLE 1 | ||
321 | |||
322 | /* | ||
323 | * Exported TWL4030 GPIO APIs | ||
324 | * | ||
325 | * WARNING -- use standard GPIO and IRQ calls instead; these will vanish. | ||
326 | */ | ||
327 | int twl4030_get_gpio_datain(int gpio); | ||
328 | int twl4030_request_gpio(int gpio); | ||
329 | int twl4030_set_gpio_debounce(int gpio, int enable); | ||
330 | int twl4030_free_gpio(int gpio); | ||
331 | |||
332 | #if defined(CONFIG_TWL4030_BCI_BATTERY) || \ | ||
333 | defined(CONFIG_TWL4030_BCI_BATTERY_MODULE) | ||
334 | extern int twl4030charger_usb_en(int enable); | ||
335 | #else | ||
336 | static inline int twl4030charger_usb_en(int enable) { return 0; } | ||
337 | #endif | ||
338 | |||
339 | #endif /* End of __TWL4030_H */ | ||
diff --git a/include/linux/i2o.h b/include/linux/i2o.h index 75ae6d8aba4f..4c4e57d1f19d 100644 --- a/include/linux/i2o.h +++ b/include/linux/i2o.h | |||
@@ -570,7 +570,6 @@ struct i2o_controller { | |||
570 | #endif | 570 | #endif |
571 | spinlock_t lock; /* lock for controller | 571 | spinlock_t lock; /* lock for controller |
572 | configuration */ | 572 | configuration */ |
573 | |||
574 | void *driver_data[I2O_MAX_DRIVERS]; /* storage for drivers */ | 573 | void *driver_data[I2O_MAX_DRIVERS]; /* storage for drivers */ |
575 | }; | 574 | }; |
576 | 575 | ||
@@ -691,289 +690,22 @@ static inline u32 i2o_dma_high(dma_addr_t dma_addr) | |||
691 | }; | 690 | }; |
692 | #endif | 691 | #endif |
693 | 692 | ||
694 | /** | 693 | extern u16 i2o_sg_tablesize(struct i2o_controller *c, u16 body_size); |
695 | * i2o_sg_tablesize - Calculate the maximum number of elements in a SGL | 694 | extern dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr, |
696 | * @c: I2O controller for which the calculation should be done | ||
697 | * @body_size: maximum body size used for message in 32-bit words. | ||
698 | * | ||
699 | * Return the maximum number of SG elements in a SG list. | ||
700 | */ | ||
701 | static inline u16 i2o_sg_tablesize(struct i2o_controller *c, u16 body_size) | ||
702 | { | ||
703 | i2o_status_block *sb = c->status_block.virt; | ||
704 | u16 sg_count = | ||
705 | (sb->inbound_frame_size - sizeof(struct i2o_message) / 4) - | ||
706 | body_size; | ||
707 | |||
708 | if (c->pae_support) { | ||
709 | /* | ||
710 | * for 64-bit a SG attribute element must be added and each | ||
711 | * SG element needs 12 bytes instead of 8. | ||
712 | */ | ||
713 | sg_count -= 2; | ||
714 | sg_count /= 3; | ||
715 | } else | ||
716 | sg_count /= 2; | ||
717 | |||
718 | if (c->short_req && (sg_count > 8)) | ||
719 | sg_count = 8; | ||
720 | |||
721 | return sg_count; | ||
722 | }; | ||
723 | |||
724 | /** | ||
725 | * i2o_dma_map_single - Map pointer to controller and fill in I2O message. | ||
726 | * @c: I2O controller | ||
727 | * @ptr: pointer to the data which should be mapped | ||
728 | * @size: size of data in bytes | ||
729 | * @direction: DMA_TO_DEVICE / DMA_FROM_DEVICE | ||
730 | * @sg_ptr: pointer to the SG list inside the I2O message | ||
731 | * | ||
732 | * This function does all necessary DMA handling and also writes the I2O | ||
733 | * SGL elements into the I2O message. For details on DMA handling see also | ||
734 | * dma_map_single(). The pointer sg_ptr will only be set to the end of the | ||
735 | * SG list if the allocation was successful. | ||
736 | * | ||
737 | * Returns DMA address which must be checked for failures using | ||
738 | * dma_mapping_error(). | ||
739 | */ | ||
740 | static inline dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr, | ||
741 | size_t size, | 695 | size_t size, |
742 | enum dma_data_direction direction, | 696 | enum dma_data_direction direction, |
743 | u32 ** sg_ptr) | 697 | u32 ** sg_ptr); |
744 | { | 698 | extern int i2o_dma_map_sg(struct i2o_controller *c, |
745 | u32 sg_flags; | ||
746 | u32 *mptr = *sg_ptr; | ||
747 | dma_addr_t dma_addr; | ||
748 | |||
749 | switch (direction) { | ||
750 | case DMA_TO_DEVICE: | ||
751 | sg_flags = 0xd4000000; | ||
752 | break; | ||
753 | case DMA_FROM_DEVICE: | ||
754 | sg_flags = 0xd0000000; | ||
755 | break; | ||
756 | default: | ||
757 | return 0; | ||
758 | } | ||
759 | |||
760 | dma_addr = dma_map_single(&c->pdev->dev, ptr, size, direction); | ||
761 | if (!dma_mapping_error(&c->pdev->dev, dma_addr)) { | ||
762 | #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64 | ||
763 | if ((sizeof(dma_addr_t) > 4) && c->pae_support) { | ||
764 | *mptr++ = cpu_to_le32(0x7C020002); | ||
765 | *mptr++ = cpu_to_le32(PAGE_SIZE); | ||
766 | } | ||
767 | #endif | ||
768 | |||
769 | *mptr++ = cpu_to_le32(sg_flags | size); | ||
770 | *mptr++ = cpu_to_le32(i2o_dma_low(dma_addr)); | ||
771 | #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64 | ||
772 | if ((sizeof(dma_addr_t) > 4) && c->pae_support) | ||
773 | *mptr++ = cpu_to_le32(i2o_dma_high(dma_addr)); | ||
774 | #endif | ||
775 | *sg_ptr = mptr; | ||
776 | } | ||
777 | return dma_addr; | ||
778 | }; | ||
779 | |||
780 | /** | ||
781 | * i2o_dma_map_sg - Map a SG List to controller and fill in I2O message. | ||
782 | * @c: I2O controller | ||
783 | * @sg: SG list to be mapped | ||
784 | * @sg_count: number of elements in the SG list | ||
785 | * @direction: DMA_TO_DEVICE / DMA_FROM_DEVICE | ||
786 | * @sg_ptr: pointer to the SG list inside the I2O message | ||
787 | * | ||
788 | * This function does all necessary DMA handling and also writes the I2O | ||
789 | * SGL elements into the I2O message. For details on DMA handling see also | ||
790 | * dma_map_sg(). The pointer sg_ptr will only be set to the end of the SG | ||
791 | * list if the allocation was successful. | ||
792 | * | ||
793 | * Returns 0 on failure or 1 on success. | ||
794 | */ | ||
795 | static inline int i2o_dma_map_sg(struct i2o_controller *c, | ||
796 | struct scatterlist *sg, int sg_count, | 699 | struct scatterlist *sg, int sg_count, |
797 | enum dma_data_direction direction, | 700 | enum dma_data_direction direction, |
798 | u32 ** sg_ptr) | 701 | u32 ** sg_ptr); |
799 | { | 702 | extern int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len); |
800 | u32 sg_flags; | 703 | extern void i2o_dma_free(struct device *dev, struct i2o_dma *addr); |
801 | u32 *mptr = *sg_ptr; | 704 | extern int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr, |
802 | 705 | size_t len); | |
803 | switch (direction) { | 706 | extern int i2o_pool_alloc(struct i2o_pool *pool, const char *name, |
804 | case DMA_TO_DEVICE: | 707 | size_t size, int min_nr); |
805 | sg_flags = 0x14000000; | 708 | extern void i2o_pool_free(struct i2o_pool *pool); |
806 | break; | ||
807 | case DMA_FROM_DEVICE: | ||
808 | sg_flags = 0x10000000; | ||
809 | break; | ||
810 | default: | ||
811 | return 0; | ||
812 | } | ||
813 | |||
814 | sg_count = dma_map_sg(&c->pdev->dev, sg, sg_count, direction); | ||
815 | if (!sg_count) | ||
816 | return 0; | ||
817 | |||
818 | #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64 | ||
819 | if ((sizeof(dma_addr_t) > 4) && c->pae_support) { | ||
820 | *mptr++ = cpu_to_le32(0x7C020002); | ||
821 | *mptr++ = cpu_to_le32(PAGE_SIZE); | ||
822 | } | ||
823 | #endif | ||
824 | |||
825 | while (sg_count-- > 0) { | ||
826 | if (!sg_count) | ||
827 | sg_flags |= 0xC0000000; | ||
828 | *mptr++ = cpu_to_le32(sg_flags | sg_dma_len(sg)); | ||
829 | *mptr++ = cpu_to_le32(i2o_dma_low(sg_dma_address(sg))); | ||
830 | #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64 | ||
831 | if ((sizeof(dma_addr_t) > 4) && c->pae_support) | ||
832 | *mptr++ = cpu_to_le32(i2o_dma_high(sg_dma_address(sg))); | ||
833 | #endif | ||
834 | sg = sg_next(sg); | ||
835 | } | ||
836 | *sg_ptr = mptr; | ||
837 | |||
838 | return 1; | ||
839 | }; | ||
840 | |||
841 | /** | ||
842 | * i2o_dma_alloc - Allocate DMA memory | ||
843 | * @dev: struct device pointer to the PCI device of the I2O controller | ||
844 | * @addr: i2o_dma struct which should get the DMA buffer | ||
845 | * @len: length of the new DMA memory | ||
846 | * @gfp_mask: GFP mask | ||
847 | * | ||
848 | * Allocate a coherent DMA memory and write the pointers into addr. | ||
849 | * | ||
850 | * Returns 0 on success or -ENOMEM on failure. | ||
851 | */ | ||
852 | static inline int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, | ||
853 | size_t len, gfp_t gfp_mask) | ||
854 | { | ||
855 | struct pci_dev *pdev = to_pci_dev(dev); | ||
856 | int dma_64 = 0; | ||
857 | |||
858 | if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_64BIT_MASK)) { | ||
859 | dma_64 = 1; | ||
860 | if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) | ||
861 | return -ENOMEM; | ||
862 | } | ||
863 | |||
864 | addr->virt = dma_alloc_coherent(dev, len, &addr->phys, gfp_mask); | ||
865 | |||
866 | if ((sizeof(dma_addr_t) > 4) && dma_64) | ||
867 | if (pci_set_dma_mask(pdev, DMA_64BIT_MASK)) | ||
868 | printk(KERN_WARNING "i2o: unable to set 64-bit DMA"); | ||
869 | |||
870 | if (!addr->virt) | ||
871 | return -ENOMEM; | ||
872 | |||
873 | memset(addr->virt, 0, len); | ||
874 | addr->len = len; | ||
875 | |||
876 | return 0; | ||
877 | }; | ||
878 | |||
879 | /** | ||
880 | * i2o_dma_free - Free DMA memory | ||
881 | * @dev: struct device pointer to the PCI device of the I2O controller | ||
882 | * @addr: i2o_dma struct which contains the DMA buffer | ||
883 | * | ||
884 | * Free a coherent DMA memory and set virtual address of addr to NULL. | ||
885 | */ | ||
886 | static inline void i2o_dma_free(struct device *dev, struct i2o_dma *addr) | ||
887 | { | ||
888 | if (addr->virt) { | ||
889 | if (addr->phys) | ||
890 | dma_free_coherent(dev, addr->len, addr->virt, | ||
891 | addr->phys); | ||
892 | else | ||
893 | kfree(addr->virt); | ||
894 | addr->virt = NULL; | ||
895 | } | ||
896 | }; | ||
897 | |||
898 | /** | ||
899 | * i2o_dma_realloc - Realloc DMA memory | ||
900 | * @dev: struct device pointer to the PCI device of the I2O controller | ||
901 | * @addr: pointer to a i2o_dma struct DMA buffer | ||
902 | * @len: new length of memory | ||
903 | * @gfp_mask: GFP mask | ||
904 | * | ||
905 | * If there was something allocated in the addr, free it first. If len > 0 | ||
906 | * than try to allocate it and write the addresses back to the addr | ||
907 | * structure. If len == 0 set the virtual address to NULL. | ||
908 | * | ||
909 | * Returns the 0 on success or negative error code on failure. | ||
910 | */ | ||
911 | static inline int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr, | ||
912 | size_t len, gfp_t gfp_mask) | ||
913 | { | ||
914 | i2o_dma_free(dev, addr); | ||
915 | |||
916 | if (len) | ||
917 | return i2o_dma_alloc(dev, addr, len, gfp_mask); | ||
918 | |||
919 | return 0; | ||
920 | }; | ||
921 | |||
922 | /* | ||
923 | * i2o_pool_alloc - Allocate an slab cache and mempool | ||
924 | * @mempool: pointer to struct i2o_pool to write data into. | ||
925 | * @name: name which is used to identify cache | ||
926 | * @size: size of each object | ||
927 | * @min_nr: minimum number of objects | ||
928 | * | ||
929 | * First allocates a slab cache with name and size. Then allocates a | ||
930 | * mempool which uses the slab cache for allocation and freeing. | ||
931 | * | ||
932 | * Returns 0 on success or negative error code on failure. | ||
933 | */ | ||
934 | static inline int i2o_pool_alloc(struct i2o_pool *pool, const char *name, | ||
935 | size_t size, int min_nr) | ||
936 | { | ||
937 | pool->name = kmalloc(strlen(name) + 1, GFP_KERNEL); | ||
938 | if (!pool->name) | ||
939 | goto exit; | ||
940 | strcpy(pool->name, name); | ||
941 | |||
942 | pool->slab = | ||
943 | kmem_cache_create(pool->name, size, 0, SLAB_HWCACHE_ALIGN, NULL); | ||
944 | if (!pool->slab) | ||
945 | goto free_name; | ||
946 | |||
947 | pool->mempool = mempool_create_slab_pool(min_nr, pool->slab); | ||
948 | if (!pool->mempool) | ||
949 | goto free_slab; | ||
950 | |||
951 | return 0; | ||
952 | |||
953 | free_slab: | ||
954 | kmem_cache_destroy(pool->slab); | ||
955 | |||
956 | free_name: | ||
957 | kfree(pool->name); | ||
958 | |||
959 | exit: | ||
960 | return -ENOMEM; | ||
961 | }; | ||
962 | |||
963 | /* | ||
964 | * i2o_pool_free - Free slab cache and mempool again | ||
965 | * @mempool: pointer to struct i2o_pool which should be freed | ||
966 | * | ||
967 | * Note that you have to return all objects to the mempool again before | ||
968 | * calling i2o_pool_free(). | ||
969 | */ | ||
970 | static inline void i2o_pool_free(struct i2o_pool *pool) | ||
971 | { | ||
972 | mempool_destroy(pool->mempool); | ||
973 | kmem_cache_destroy(pool->slab); | ||
974 | kfree(pool->name); | ||
975 | }; | ||
976 | |||
977 | /* I2O driver (OSM) functions */ | 709 | /* I2O driver (OSM) functions */ |
978 | extern int i2o_driver_register(struct i2o_driver *); | 710 | extern int i2o_driver_register(struct i2o_driver *); |
979 | extern void i2o_driver_unregister(struct i2o_driver *); | 711 | extern void i2o_driver_unregister(struct i2o_driver *); |
diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h index 03067443198a..a93a8dd33118 100644 --- a/include/linux/icmpv6.h +++ b/include/linux/icmpv6.h | |||
@@ -40,16 +40,18 @@ struct icmp6hdr { | |||
40 | struct icmpv6_nd_ra { | 40 | struct icmpv6_nd_ra { |
41 | __u8 hop_limit; | 41 | __u8 hop_limit; |
42 | #if defined(__LITTLE_ENDIAN_BITFIELD) | 42 | #if defined(__LITTLE_ENDIAN_BITFIELD) |
43 | __u8 reserved:4, | 43 | __u8 reserved:3, |
44 | router_pref:2, | 44 | router_pref:2, |
45 | home_agent:1, | ||
45 | other:1, | 46 | other:1, |
46 | managed:1; | 47 | managed:1; |
47 | 48 | ||
48 | #elif defined(__BIG_ENDIAN_BITFIELD) | 49 | #elif defined(__BIG_ENDIAN_BITFIELD) |
49 | __u8 managed:1, | 50 | __u8 managed:1, |
50 | other:1, | 51 | other:1, |
52 | home_agent:1, | ||
51 | router_pref:2, | 53 | router_pref:2, |
52 | reserved:4; | 54 | reserved:3; |
53 | #else | 55 | #else |
54 | #error "Please fix <asm/byteorder.h>" | 56 | #error "Please fix <asm/byteorder.h>" |
55 | #endif | 57 | #endif |
diff --git a/include/linux/ide.h b/include/linux/ide.h index c47e371554c1..89e53cfbc787 100644 --- a/include/linux/ide.h +++ b/include/linux/ide.h | |||
@@ -461,12 +461,26 @@ struct ide_acpi_drive_link; | |||
461 | struct ide_acpi_hwif_link; | 461 | struct ide_acpi_hwif_link; |
462 | #endif | 462 | #endif |
463 | 463 | ||
464 | struct ide_drive_s; | ||
465 | |||
466 | struct ide_disk_ops { | ||
467 | int (*check)(struct ide_drive_s *, const char *); | ||
468 | int (*get_capacity)(struct ide_drive_s *); | ||
469 | void (*setup)(struct ide_drive_s *); | ||
470 | void (*flush)(struct ide_drive_s *); | ||
471 | int (*init_media)(struct ide_drive_s *, struct gendisk *); | ||
472 | int (*set_doorlock)(struct ide_drive_s *, struct gendisk *, | ||
473 | int); | ||
474 | ide_startstop_t (*do_request)(struct ide_drive_s *, struct request *, | ||
475 | sector_t); | ||
476 | int (*end_request)(struct ide_drive_s *, int, int); | ||
477 | int (*ioctl)(struct ide_drive_s *, struct inode *, | ||
478 | struct file *, unsigned int, unsigned long); | ||
479 | }; | ||
480 | |||
464 | /* ATAPI device flags */ | 481 | /* ATAPI device flags */ |
465 | enum { | 482 | enum { |
466 | IDE_AFLAG_DRQ_INTERRUPT = (1 << 0), | 483 | IDE_AFLAG_DRQ_INTERRUPT = (1 << 0), |
467 | IDE_AFLAG_MEDIA_CHANGED = (1 << 1), | ||
468 | /* Drive cannot lock the door. */ | ||
469 | IDE_AFLAG_NO_DOORLOCK = (1 << 2), | ||
470 | 484 | ||
471 | /* ide-cd */ | 485 | /* ide-cd */ |
472 | /* Drive cannot eject the disc. */ | 486 | /* Drive cannot eject the disc. */ |
@@ -498,14 +512,10 @@ enum { | |||
498 | IDE_AFLAG_LE_SPEED_FIELDS = (1 << 17), | 512 | IDE_AFLAG_LE_SPEED_FIELDS = (1 << 17), |
499 | 513 | ||
500 | /* ide-floppy */ | 514 | /* ide-floppy */ |
501 | /* Format in progress */ | ||
502 | IDE_AFLAG_FORMAT_IN_PROGRESS = (1 << 18), | ||
503 | /* Avoid commands not supported in Clik drive */ | 515 | /* Avoid commands not supported in Clik drive */ |
504 | IDE_AFLAG_CLIK_DRIVE = (1 << 19), | 516 | IDE_AFLAG_CLIK_DRIVE = (1 << 19), |
505 | /* Requires BH algorithm for packets */ | 517 | /* Requires BH algorithm for packets */ |
506 | IDE_AFLAG_ZIP_DRIVE = (1 << 20), | 518 | IDE_AFLAG_ZIP_DRIVE = (1 << 20), |
507 | /* Write protect */ | ||
508 | IDE_AFLAG_WP = (1 << 21), | ||
509 | /* Supports format progress report */ | 519 | /* Supports format progress report */ |
510 | IDE_AFLAG_SRFP = (1 << 22), | 520 | IDE_AFLAG_SRFP = (1 << 22), |
511 | 521 | ||
@@ -578,7 +588,11 @@ enum { | |||
578 | /* don't unload heads */ | 588 | /* don't unload heads */ |
579 | IDE_DFLAG_NO_UNLOAD = (1 << 27), | 589 | IDE_DFLAG_NO_UNLOAD = (1 << 27), |
580 | /* heads unloaded, please don't reset port */ | 590 | /* heads unloaded, please don't reset port */ |
581 | IDE_DFLAG_PARKED = (1 << 28) | 591 | IDE_DFLAG_PARKED = (1 << 28), |
592 | IDE_DFLAG_MEDIA_CHANGED = (1 << 29), | ||
593 | /* write protect */ | ||
594 | IDE_DFLAG_WP = (1 << 30), | ||
595 | IDE_DFLAG_FORMAT_IN_PROGRESS = (1 << 31), | ||
582 | }; | 596 | }; |
583 | 597 | ||
584 | struct ide_drive_s { | 598 | struct ide_drive_s { |
@@ -597,6 +611,8 @@ struct ide_drive_s { | |||
597 | #endif | 611 | #endif |
598 | struct hwif_s *hwif; /* actually (ide_hwif_t *) */ | 612 | struct hwif_s *hwif; /* actually (ide_hwif_t *) */ |
599 | 613 | ||
614 | const struct ide_disk_ops *disk_ops; | ||
615 | |||
600 | unsigned long dev_flags; | 616 | unsigned long dev_flags; |
601 | 617 | ||
602 | unsigned long sleep; /* sleep until this time */ | 618 | unsigned long sleep; /* sleep until this time */ |
@@ -1123,8 +1139,8 @@ struct ide_driver_s { | |||
1123 | void (*resume)(ide_drive_t *); | 1139 | void (*resume)(ide_drive_t *); |
1124 | void (*shutdown)(ide_drive_t *); | 1140 | void (*shutdown)(ide_drive_t *); |
1125 | #ifdef CONFIG_IDE_PROC_FS | 1141 | #ifdef CONFIG_IDE_PROC_FS |
1126 | ide_proc_entry_t *proc; | 1142 | ide_proc_entry_t * (*proc_entries)(ide_drive_t *); |
1127 | const struct ide_proc_devset *settings; | 1143 | const struct ide_proc_devset * (*proc_devsets)(ide_drive_t *); |
1128 | #endif | 1144 | #endif |
1129 | }; | 1145 | }; |
1130 | 1146 | ||
diff --git a/include/linux/init.h b/include/linux/init.h index 93538b696e3d..ad63824460e3 100644 --- a/include/linux/init.h +++ b/include/linux/init.h | |||
@@ -233,9 +233,6 @@ struct obs_kernel_param { | |||
233 | __attribute__((aligned((sizeof(long))))) \ | 233 | __attribute__((aligned((sizeof(long))))) \ |
234 | = { __setup_str_##unique_id, fn, early } | 234 | = { __setup_str_##unique_id, fn, early } |
235 | 235 | ||
236 | #define __setup_null_param(str, unique_id) \ | ||
237 | __setup_param(str, unique_id, NULL, 0) | ||
238 | |||
239 | #define __setup(str, fn) \ | 236 | #define __setup(str, fn) \ |
240 | __setup_param(str, fn, fn, 0) | 237 | __setup_param(str, fn, fn, 0) |
241 | 238 | ||
@@ -296,7 +293,6 @@ void __init parse_early_param(void); | |||
296 | void cleanup_module(void) __attribute__((alias(#exitfn))); | 293 | void cleanup_module(void) __attribute__((alias(#exitfn))); |
297 | 294 | ||
298 | #define __setup_param(str, unique_id, fn) /* nothing */ | 295 | #define __setup_param(str, unique_id, fn) /* nothing */ |
299 | #define __setup_null_param(str, unique_id) /* nothing */ | ||
300 | #define __setup(str, func) /* nothing */ | 296 | #define __setup(str, func) /* nothing */ |
301 | #endif | 297 | #endif |
302 | 298 | ||
diff --git a/include/linux/input.h b/include/linux/input.h index a5802c9c81a4..b86fb5581ce6 100644 --- a/include/linux/input.h +++ b/include/linux/input.h | |||
@@ -577,9 +577,22 @@ struct input_absinfo { | |||
577 | #define KEY_BRL_DOT9 0x1f9 | 577 | #define KEY_BRL_DOT9 0x1f9 |
578 | #define KEY_BRL_DOT10 0x1fa | 578 | #define KEY_BRL_DOT10 0x1fa |
579 | 579 | ||
580 | #define KEY_NUMERIC_0 0x200 /* used by phones, remote controls, */ | ||
581 | #define KEY_NUMERIC_1 0x201 /* and other keypads */ | ||
582 | #define KEY_NUMERIC_2 0x202 | ||
583 | #define KEY_NUMERIC_3 0x203 | ||
584 | #define KEY_NUMERIC_4 0x204 | ||
585 | #define KEY_NUMERIC_5 0x205 | ||
586 | #define KEY_NUMERIC_6 0x206 | ||
587 | #define KEY_NUMERIC_7 0x207 | ||
588 | #define KEY_NUMERIC_8 0x208 | ||
589 | #define KEY_NUMERIC_9 0x209 | ||
590 | #define KEY_NUMERIC_STAR 0x20a | ||
591 | #define KEY_NUMERIC_POUND 0x20b | ||
592 | |||
580 | /* We avoid low common keys in module aliases so they don't get huge. */ | 593 | /* We avoid low common keys in module aliases so they don't get huge. */ |
581 | #define KEY_MIN_INTERESTING KEY_MUTE | 594 | #define KEY_MIN_INTERESTING KEY_MUTE |
582 | #define KEY_MAX 0x1ff | 595 | #define KEY_MAX 0x2ff |
583 | #define KEY_CNT (KEY_MAX+1) | 596 | #define KEY_CNT (KEY_MAX+1) |
584 | 597 | ||
585 | /* | 598 | /* |
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h new file mode 100644 index 000000000000..2e117f30a76c --- /dev/null +++ b/include/linux/intel-iommu.h | |||
@@ -0,0 +1,327 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2006, Intel Corporation. | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or modify it | ||
5 | * under the terms and conditions of the GNU General Public License, | ||
6 | * version 2, as published by the Free Software Foundation. | ||
7 | * | ||
8 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
11 | * more details. | ||
12 | * | ||
13 | * You should have received a copy of the GNU General Public License along with | ||
14 | * this program; if not, write to the Free Software Foundation, Inc., 59 Temple | ||
15 | * Place - Suite 330, Boston, MA 02111-1307 USA. | ||
16 | * | ||
17 | * Copyright (C) 2006-2008 Intel Corporation | ||
18 | * Author: Ashok Raj <ashok.raj@intel.com> | ||
19 | * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> | ||
20 | */ | ||
21 | |||
22 | #ifndef _INTEL_IOMMU_H_ | ||
23 | #define _INTEL_IOMMU_H_ | ||
24 | |||
25 | #include <linux/types.h> | ||
26 | #include <linux/msi.h> | ||
27 | #include <linux/sysdev.h> | ||
28 | #include <linux/iova.h> | ||
29 | #include <linux/io.h> | ||
30 | #include <linux/dma_remapping.h> | ||
31 | #include <asm/cacheflush.h> | ||
32 | |||
33 | /* | ||
34 | * Intel IOMMU register specification per version 1.0 public spec. | ||
35 | */ | ||
36 | |||
37 | #define DMAR_VER_REG 0x0 /* Arch version supported by this IOMMU */ | ||
38 | #define DMAR_CAP_REG 0x8 /* Hardware supported capabilities */ | ||
39 | #define DMAR_ECAP_REG 0x10 /* Extended capabilities supported */ | ||
40 | #define DMAR_GCMD_REG 0x18 /* Global command register */ | ||
41 | #define DMAR_GSTS_REG 0x1c /* Global status register */ | ||
42 | #define DMAR_RTADDR_REG 0x20 /* Root entry table */ | ||
43 | #define DMAR_CCMD_REG 0x28 /* Context command reg */ | ||
44 | #define DMAR_FSTS_REG 0x34 /* Fault Status register */ | ||
45 | #define DMAR_FECTL_REG 0x38 /* Fault control register */ | ||
46 | #define DMAR_FEDATA_REG 0x3c /* Fault event interrupt data register */ | ||
47 | #define DMAR_FEADDR_REG 0x40 /* Fault event interrupt addr register */ | ||
48 | #define DMAR_FEUADDR_REG 0x44 /* Upper address register */ | ||
49 | #define DMAR_AFLOG_REG 0x58 /* Advanced Fault control */ | ||
50 | #define DMAR_PMEN_REG 0x64 /* Enable Protected Memory Region */ | ||
51 | #define DMAR_PLMBASE_REG 0x68 /* PMRR Low addr */ | ||
52 | #define DMAR_PLMLIMIT_REG 0x6c /* PMRR low limit */ | ||
53 | #define DMAR_PHMBASE_REG 0x70 /* pmrr high base addr */ | ||
54 | #define DMAR_PHMLIMIT_REG 0x78 /* pmrr high limit */ | ||
55 | #define DMAR_IQH_REG 0x80 /* Invalidation queue head register */ | ||
56 | #define DMAR_IQT_REG 0x88 /* Invalidation queue tail register */ | ||
57 | #define DMAR_IQA_REG 0x90 /* Invalidation queue addr register */ | ||
58 | #define DMAR_ICS_REG 0x98 /* Invalidation complete status register */ | ||
59 | #define DMAR_IRTA_REG 0xb8 /* Interrupt remapping table addr register */ | ||
60 | |||
61 | #define OFFSET_STRIDE (9) | ||
62 | /* | ||
63 | #define dmar_readl(dmar, reg) readl(dmar + reg) | ||
64 | #define dmar_readq(dmar, reg) ({ \ | ||
65 | u32 lo, hi; \ | ||
66 | lo = readl(dmar + reg); \ | ||
67 | hi = readl(dmar + reg + 4); \ | ||
68 | (((u64) hi) << 32) + lo; }) | ||
69 | */ | ||
70 | static inline u64 dmar_readq(void __iomem *addr) | ||
71 | { | ||
72 | u32 lo, hi; | ||
73 | lo = readl(addr); | ||
74 | hi = readl(addr + 4); | ||
75 | return (((u64) hi) << 32) + lo; | ||
76 | } | ||
77 | |||
78 | static inline void dmar_writeq(void __iomem *addr, u64 val) | ||
79 | { | ||
80 | writel((u32)val, addr); | ||
81 | writel((u32)(val >> 32), addr + 4); | ||
82 | } | ||
83 | |||
84 | #define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4) | ||
85 | #define DMAR_VER_MINOR(v) ((v) & 0x0f) | ||
86 | |||
87 | /* | ||
88 | * Decoding Capability Register | ||
89 | */ | ||
90 | #define cap_read_drain(c) (((c) >> 55) & 1) | ||
91 | #define cap_write_drain(c) (((c) >> 54) & 1) | ||
92 | #define cap_max_amask_val(c) (((c) >> 48) & 0x3f) | ||
93 | #define cap_num_fault_regs(c) ((((c) >> 40) & 0xff) + 1) | ||
94 | #define cap_pgsel_inv(c) (((c) >> 39) & 1) | ||
95 | |||
96 | #define cap_super_page_val(c) (((c) >> 34) & 0xf) | ||
97 | #define cap_super_offset(c) (((find_first_bit(&cap_super_page_val(c), 4)) \ | ||
98 | * OFFSET_STRIDE) + 21) | ||
99 | |||
100 | #define cap_fault_reg_offset(c) ((((c) >> 24) & 0x3ff) * 16) | ||
101 | #define cap_max_fault_reg_offset(c) \ | ||
102 | (cap_fault_reg_offset(c) + cap_num_fault_regs(c) * 16) | ||
103 | |||
104 | #define cap_zlr(c) (((c) >> 22) & 1) | ||
105 | #define cap_isoch(c) (((c) >> 23) & 1) | ||
106 | #define cap_mgaw(c) ((((c) >> 16) & 0x3f) + 1) | ||
107 | #define cap_sagaw(c) (((c) >> 8) & 0x1f) | ||
108 | #define cap_caching_mode(c) (((c) >> 7) & 1) | ||
109 | #define cap_phmr(c) (((c) >> 6) & 1) | ||
110 | #define cap_plmr(c) (((c) >> 5) & 1) | ||
111 | #define cap_rwbf(c) (((c) >> 4) & 1) | ||
112 | #define cap_afl(c) (((c) >> 3) & 1) | ||
113 | #define cap_ndoms(c) (((unsigned long)1) << (4 + 2 * ((c) & 0x7))) | ||
114 | /* | ||
115 | * Extended Capability Register | ||
116 | */ | ||
117 | |||
118 | #define ecap_niotlb_iunits(e) ((((e) >> 24) & 0xff) + 1) | ||
119 | #define ecap_iotlb_offset(e) ((((e) >> 8) & 0x3ff) * 16) | ||
120 | #define ecap_max_iotlb_offset(e) \ | ||
121 | (ecap_iotlb_offset(e) + ecap_niotlb_iunits(e) * 16) | ||
122 | #define ecap_coherent(e) ((e) & 0x1) | ||
123 | #define ecap_qis(e) ((e) & 0x2) | ||
124 | #define ecap_eim_support(e) ((e >> 4) & 0x1) | ||
125 | #define ecap_ir_support(e) ((e >> 3) & 0x1) | ||
126 | #define ecap_max_handle_mask(e) ((e >> 20) & 0xf) | ||
127 | |||
128 | |||
129 | /* IOTLB_REG */ | ||
130 | #define DMA_TLB_GLOBAL_FLUSH (((u64)1) << 60) | ||
131 | #define DMA_TLB_DSI_FLUSH (((u64)2) << 60) | ||
132 | #define DMA_TLB_PSI_FLUSH (((u64)3) << 60) | ||
133 | #define DMA_TLB_IIRG(type) ((type >> 60) & 7) | ||
134 | #define DMA_TLB_IAIG(val) (((val) >> 57) & 7) | ||
135 | #define DMA_TLB_READ_DRAIN (((u64)1) << 49) | ||
136 | #define DMA_TLB_WRITE_DRAIN (((u64)1) << 48) | ||
137 | #define DMA_TLB_DID(id) (((u64)((id) & 0xffff)) << 32) | ||
138 | #define DMA_TLB_IVT (((u64)1) << 63) | ||
139 | #define DMA_TLB_IH_NONLEAF (((u64)1) << 6) | ||
140 | #define DMA_TLB_MAX_SIZE (0x3f) | ||
141 | |||
142 | /* INVALID_DESC */ | ||
143 | #define DMA_ID_TLB_GLOBAL_FLUSH (((u64)1) << 3) | ||
144 | #define DMA_ID_TLB_DSI_FLUSH (((u64)2) << 3) | ||
145 | #define DMA_ID_TLB_PSI_FLUSH (((u64)3) << 3) | ||
146 | #define DMA_ID_TLB_READ_DRAIN (((u64)1) << 7) | ||
147 | #define DMA_ID_TLB_WRITE_DRAIN (((u64)1) << 6) | ||
148 | #define DMA_ID_TLB_DID(id) (((u64)((id & 0xffff) << 16))) | ||
149 | #define DMA_ID_TLB_IH_NONLEAF (((u64)1) << 6) | ||
150 | #define DMA_ID_TLB_ADDR(addr) (addr) | ||
151 | #define DMA_ID_TLB_ADDR_MASK(mask) (mask) | ||
152 | |||
153 | /* PMEN_REG */ | ||
154 | #define DMA_PMEN_EPM (((u32)1)<<31) | ||
155 | #define DMA_PMEN_PRS (((u32)1)<<0) | ||
156 | |||
157 | /* GCMD_REG */ | ||
158 | #define DMA_GCMD_TE (((u32)1) << 31) | ||
159 | #define DMA_GCMD_SRTP (((u32)1) << 30) | ||
160 | #define DMA_GCMD_SFL (((u32)1) << 29) | ||
161 | #define DMA_GCMD_EAFL (((u32)1) << 28) | ||
162 | #define DMA_GCMD_WBF (((u32)1) << 27) | ||
163 | #define DMA_GCMD_QIE (((u32)1) << 26) | ||
164 | #define DMA_GCMD_SIRTP (((u32)1) << 24) | ||
165 | #define DMA_GCMD_IRE (((u32) 1) << 25) | ||
166 | |||
167 | /* GSTS_REG */ | ||
168 | #define DMA_GSTS_TES (((u32)1) << 31) | ||
169 | #define DMA_GSTS_RTPS (((u32)1) << 30) | ||
170 | #define DMA_GSTS_FLS (((u32)1) << 29) | ||
171 | #define DMA_GSTS_AFLS (((u32)1) << 28) | ||
172 | #define DMA_GSTS_WBFS (((u32)1) << 27) | ||
173 | #define DMA_GSTS_QIES (((u32)1) << 26) | ||
174 | #define DMA_GSTS_IRTPS (((u32)1) << 24) | ||
175 | #define DMA_GSTS_IRES (((u32)1) << 25) | ||
176 | |||
177 | /* CCMD_REG */ | ||
178 | #define DMA_CCMD_ICC (((u64)1) << 63) | ||
179 | #define DMA_CCMD_GLOBAL_INVL (((u64)1) << 61) | ||
180 | #define DMA_CCMD_DOMAIN_INVL (((u64)2) << 61) | ||
181 | #define DMA_CCMD_DEVICE_INVL (((u64)3) << 61) | ||
182 | #define DMA_CCMD_FM(m) (((u64)((m) & 0x3)) << 32) | ||
183 | #define DMA_CCMD_MASK_NOBIT 0 | ||
184 | #define DMA_CCMD_MASK_1BIT 1 | ||
185 | #define DMA_CCMD_MASK_2BIT 2 | ||
186 | #define DMA_CCMD_MASK_3BIT 3 | ||
187 | #define DMA_CCMD_SID(s) (((u64)((s) & 0xffff)) << 16) | ||
188 | #define DMA_CCMD_DID(d) ((u64)((d) & 0xffff)) | ||
189 | |||
190 | /* FECTL_REG */ | ||
191 | #define DMA_FECTL_IM (((u32)1) << 31) | ||
192 | |||
193 | /* FSTS_REG */ | ||
194 | #define DMA_FSTS_PPF ((u32)2) | ||
195 | #define DMA_FSTS_PFO ((u32)1) | ||
196 | #define dma_fsts_fault_record_index(s) (((s) >> 8) & 0xff) | ||
197 | |||
198 | /* FRCD_REG, 32 bits access */ | ||
199 | #define DMA_FRCD_F (((u32)1) << 31) | ||
200 | #define dma_frcd_type(d) ((d >> 30) & 1) | ||
201 | #define dma_frcd_fault_reason(c) (c & 0xff) | ||
202 | #define dma_frcd_source_id(c) (c & 0xffff) | ||
203 | #define dma_frcd_page_addr(d) (d & (((u64)-1) << 12)) /* low 64 bit */ | ||
204 | |||
205 | #define DMAR_OPERATION_TIMEOUT ((cycles_t) tsc_khz*10*1000) /* 10sec */ | ||
206 | |||
207 | #define IOMMU_WAIT_OP(iommu, offset, op, cond, sts) \ | ||
208 | {\ | ||
209 | cycles_t start_time = get_cycles();\ | ||
210 | while (1) {\ | ||
211 | sts = op (iommu->reg + offset);\ | ||
212 | if (cond)\ | ||
213 | break;\ | ||
214 | if (DMAR_OPERATION_TIMEOUT < (get_cycles() - start_time))\ | ||
215 | panic("DMAR hardware is malfunctioning\n");\ | ||
216 | cpu_relax();\ | ||
217 | }\ | ||
218 | } | ||
219 | |||
220 | #define QI_LENGTH 256 /* queue length */ | ||
221 | |||
222 | enum { | ||
223 | QI_FREE, | ||
224 | QI_IN_USE, | ||
225 | QI_DONE | ||
226 | }; | ||
227 | |||
228 | #define QI_CC_TYPE 0x1 | ||
229 | #define QI_IOTLB_TYPE 0x2 | ||
230 | #define QI_DIOTLB_TYPE 0x3 | ||
231 | #define QI_IEC_TYPE 0x4 | ||
232 | #define QI_IWD_TYPE 0x5 | ||
233 | |||
234 | #define QI_IEC_SELECTIVE (((u64)1) << 4) | ||
235 | #define QI_IEC_IIDEX(idx) (((u64)(idx & 0xffff) << 32)) | ||
236 | #define QI_IEC_IM(m) (((u64)(m & 0x1f) << 27)) | ||
237 | |||
238 | #define QI_IWD_STATUS_DATA(d) (((u64)d) << 32) | ||
239 | #define QI_IWD_STATUS_WRITE (((u64)1) << 5) | ||
240 | |||
241 | struct qi_desc { | ||
242 | u64 low, high; | ||
243 | }; | ||
244 | |||
245 | struct q_inval { | ||
246 | spinlock_t q_lock; | ||
247 | struct qi_desc *desc; /* invalidation queue */ | ||
248 | int *desc_status; /* desc status */ | ||
249 | int free_head; /* first free entry */ | ||
250 | int free_tail; /* last free entry */ | ||
251 | int free_cnt; | ||
252 | }; | ||
253 | |||
254 | #ifdef CONFIG_INTR_REMAP | ||
255 | /* 1MB - maximum possible interrupt remapping table size */ | ||
256 | #define INTR_REMAP_PAGE_ORDER 8 | ||
257 | #define INTR_REMAP_TABLE_REG_SIZE 0xf | ||
258 | |||
259 | #define INTR_REMAP_TABLE_ENTRIES 65536 | ||
260 | |||
261 | struct ir_table { | ||
262 | struct irte *base; | ||
263 | }; | ||
264 | #endif | ||
265 | |||
266 | struct intel_iommu { | ||
267 | void __iomem *reg; /* Pointer to hardware regs, virtual addr */ | ||
268 | u64 cap; | ||
269 | u64 ecap; | ||
270 | int seg; | ||
271 | u32 gcmd; /* Holds TE, EAFL. Don't need SRTP, SFL, WBF */ | ||
272 | spinlock_t register_lock; /* protect register handling */ | ||
273 | int seq_id; /* sequence id of the iommu */ | ||
274 | |||
275 | #ifdef CONFIG_DMAR | ||
276 | unsigned long *domain_ids; /* bitmap of domains */ | ||
277 | struct dmar_domain **domains; /* ptr to domains */ | ||
278 | spinlock_t lock; /* protect context, domain ids */ | ||
279 | struct root_entry *root_entry; /* virtual address */ | ||
280 | |||
281 | unsigned int irq; | ||
282 | unsigned char name[7]; /* Device Name */ | ||
283 | struct msi_msg saved_msg; | ||
284 | struct sys_device sysdev; | ||
285 | #endif | ||
286 | struct q_inval *qi; /* Queued invalidation info */ | ||
287 | #ifdef CONFIG_INTR_REMAP | ||
288 | struct ir_table *ir_table; /* Interrupt remapping info */ | ||
289 | #endif | ||
290 | }; | ||
291 | |||
292 | static inline void __iommu_flush_cache( | ||
293 | struct intel_iommu *iommu, void *addr, int size) | ||
294 | { | ||
295 | if (!ecap_coherent(iommu->ecap)) | ||
296 | clflush_cache_range(addr, size); | ||
297 | } | ||
298 | |||
299 | extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev); | ||
300 | |||
301 | extern int alloc_iommu(struct dmar_drhd_unit *drhd); | ||
302 | extern void free_iommu(struct intel_iommu *iommu); | ||
303 | extern int dmar_enable_qi(struct intel_iommu *iommu); | ||
304 | extern void qi_global_iec(struct intel_iommu *iommu); | ||
305 | |||
306 | extern void qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu); | ||
307 | |||
308 | void intel_iommu_domain_exit(struct dmar_domain *domain); | ||
309 | struct dmar_domain *intel_iommu_domain_alloc(struct pci_dev *pdev); | ||
310 | int intel_iommu_context_mapping(struct dmar_domain *domain, | ||
311 | struct pci_dev *pdev); | ||
312 | int intel_iommu_page_mapping(struct dmar_domain *domain, dma_addr_t iova, | ||
313 | u64 hpa, size_t size, int prot); | ||
314 | void intel_iommu_detach_dev(struct dmar_domain *domain, u8 bus, u8 devfn); | ||
315 | struct dmar_domain *intel_iommu_find_domain(struct pci_dev *pdev); | ||
316 | u64 intel_iommu_iova_to_pfn(struct dmar_domain *domain, u64 iova); | ||
317 | |||
318 | #ifdef CONFIG_DMAR | ||
319 | int intel_iommu_found(void); | ||
320 | #else /* CONFIG_DMAR */ | ||
321 | static inline int intel_iommu_found(void) | ||
322 | { | ||
323 | return 0; | ||
324 | } | ||
325 | #endif /* CONFIG_DMAR */ | ||
326 | |||
327 | #endif | ||
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h index 58ff4e74b2f3..35a61dc60d51 100644 --- a/include/linux/interrupt.h +++ b/include/linux/interrupt.h | |||
@@ -11,6 +11,8 @@ | |||
11 | #include <linux/hardirq.h> | 11 | #include <linux/hardirq.h> |
12 | #include <linux/sched.h> | 12 | #include <linux/sched.h> |
13 | #include <linux/irqflags.h> | 13 | #include <linux/irqflags.h> |
14 | #include <linux/smp.h> | ||
15 | #include <linux/percpu.h> | ||
14 | #include <asm/atomic.h> | 16 | #include <asm/atomic.h> |
15 | #include <asm/ptrace.h> | 17 | #include <asm/ptrace.h> |
16 | #include <asm/system.h> | 18 | #include <asm/system.h> |
@@ -252,6 +254,8 @@ enum | |||
252 | HRTIMER_SOFTIRQ, | 254 | HRTIMER_SOFTIRQ, |
253 | #endif | 255 | #endif |
254 | RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ | 256 | RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ |
257 | |||
258 | NR_SOFTIRQS | ||
255 | }; | 259 | }; |
256 | 260 | ||
257 | /* softirq mask and active fields moved to irq_cpustat_t in | 261 | /* softirq mask and active fields moved to irq_cpustat_t in |
@@ -271,6 +275,25 @@ extern void softirq_init(void); | |||
271 | extern void raise_softirq_irqoff(unsigned int nr); | 275 | extern void raise_softirq_irqoff(unsigned int nr); |
272 | extern void raise_softirq(unsigned int nr); | 276 | extern void raise_softirq(unsigned int nr); |
273 | 277 | ||
278 | /* This is the worklist that queues up per-cpu softirq work. | ||
279 | * | ||
280 | * send_remote_sendirq() adds work to these lists, and | ||
281 | * the softirq handler itself dequeues from them. The queues | ||
282 | * are protected by disabling local cpu interrupts and they must | ||
283 | * only be accessed by the local cpu that they are for. | ||
284 | */ | ||
285 | DECLARE_PER_CPU(struct list_head [NR_SOFTIRQS], softirq_work_list); | ||
286 | |||
287 | /* Try to send a softirq to a remote cpu. If this cannot be done, the | ||
288 | * work will be queued to the local cpu. | ||
289 | */ | ||
290 | extern void send_remote_softirq(struct call_single_data *cp, int cpu, int softirq); | ||
291 | |||
292 | /* Like send_remote_softirq(), but the caller must disable local cpu interrupts | ||
293 | * and compute the current cpu, passed in as 'this_cpu'. | ||
294 | */ | ||
295 | extern void __send_remote_softirq(struct call_single_data *cp, int cpu, | ||
296 | int this_cpu, int softirq); | ||
274 | 297 | ||
275 | /* Tasklets --- multithreaded analogue of BHs. | 298 | /* Tasklets --- multithreaded analogue of BHs. |
276 | 299 | ||
diff --git a/include/linux/iommu-helper.h b/include/linux/iommu-helper.h index a6d0586e2bf7..3b068e5b5671 100644 --- a/include/linux/iommu-helper.h +++ b/include/linux/iommu-helper.h | |||
@@ -23,4 +23,7 @@ extern unsigned long iommu_area_alloc(unsigned long *map, unsigned long size, | |||
23 | extern void iommu_area_free(unsigned long *map, unsigned long start, | 23 | extern void iommu_area_free(unsigned long *map, unsigned long start, |
24 | unsigned int nr); | 24 | unsigned int nr); |
25 | 25 | ||
26 | extern unsigned long iommu_num_pages(unsigned long addr, unsigned long len, | ||
27 | unsigned long io_page_size); | ||
28 | |||
26 | #endif | 29 | #endif |
diff --git a/include/linux/ioport.h b/include/linux/ioport.h index ee9bcc6f32b6..041e95aac2bf 100644 --- a/include/linux/ioport.h +++ b/include/linux/ioport.h | |||
@@ -34,7 +34,8 @@ struct resource_list { | |||
34 | */ | 34 | */ |
35 | #define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */ | 35 | #define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */ |
36 | 36 | ||
37 | #define IORESOURCE_IO 0x00000100 /* Resource type */ | 37 | #define IORESOURCE_TYPE_BITS 0x00000f00 /* Resource type */ |
38 | #define IORESOURCE_IO 0x00000100 | ||
38 | #define IORESOURCE_MEM 0x00000200 | 39 | #define IORESOURCE_MEM 0x00000200 |
39 | #define IORESOURCE_IRQ 0x00000400 | 40 | #define IORESOURCE_IRQ 0x00000400 |
40 | #define IORESOURCE_DMA 0x00000800 | 41 | #define IORESOURCE_DMA 0x00000800 |
@@ -126,6 +127,10 @@ static inline resource_size_t resource_size(struct resource *res) | |||
126 | { | 127 | { |
127 | return res->end - res->start + 1; | 128 | return res->end - res->start + 1; |
128 | } | 129 | } |
130 | static inline unsigned long resource_type(struct resource *res) | ||
131 | { | ||
132 | return res->flags & IORESOURCE_TYPE_BITS; | ||
133 | } | ||
129 | 134 | ||
130 | /* Convenience shorthand with allocation */ | 135 | /* Convenience shorthand with allocation */ |
131 | #define request_region(start,n,name) __request_region(&ioport_resource, (start), (n), (name)) | 136 | #define request_region(start,n,name) __request_region(&ioport_resource, (start), (n), (name)) |
@@ -169,6 +174,7 @@ extern struct resource * __devm_request_region(struct device *dev, | |||
169 | 174 | ||
170 | extern void __devm_release_region(struct device *dev, struct resource *parent, | 175 | extern void __devm_release_region(struct device *dev, struct resource *parent, |
171 | resource_size_t start, resource_size_t n); | 176 | resource_size_t start, resource_size_t n); |
177 | extern int iomem_map_sanity_check(resource_size_t addr, unsigned long size); | ||
172 | 178 | ||
173 | #endif /* __ASSEMBLY__ */ | 179 | #endif /* __ASSEMBLY__ */ |
174 | #endif /* _LINUX_IOPORT_H */ | 180 | #endif /* _LINUX_IOPORT_H */ |
diff --git a/include/linux/iova.h b/include/linux/iova.h new file mode 100644 index 000000000000..228f6c94b69c --- /dev/null +++ b/include/linux/iova.h | |||
@@ -0,0 +1,52 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2006, Intel Corporation. | ||
3 | * | ||
4 | * This file is released under the GPLv2. | ||
5 | * | ||
6 | * Copyright (C) 2006-2008 Intel Corporation | ||
7 | * Author: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #ifndef _IOVA_H_ | ||
12 | #define _IOVA_H_ | ||
13 | |||
14 | #include <linux/types.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/rbtree.h> | ||
17 | #include <linux/dma-mapping.h> | ||
18 | |||
19 | /* IO virtual address start page frame number */ | ||
20 | #define IOVA_START_PFN (1) | ||
21 | |||
22 | /* iova structure */ | ||
23 | struct iova { | ||
24 | struct rb_node node; | ||
25 | unsigned long pfn_hi; /* IOMMU dish out addr hi */ | ||
26 | unsigned long pfn_lo; /* IOMMU dish out addr lo */ | ||
27 | }; | ||
28 | |||
29 | /* holds all the iova translations for a domain */ | ||
30 | struct iova_domain { | ||
31 | spinlock_t iova_alloc_lock;/* Lock to protect iova allocation */ | ||
32 | spinlock_t iova_rbtree_lock; /* Lock to protect update of rbtree */ | ||
33 | struct rb_root rbroot; /* iova domain rbtree root */ | ||
34 | struct rb_node *cached32_node; /* Save last alloced node */ | ||
35 | unsigned long dma_32bit_pfn; | ||
36 | }; | ||
37 | |||
38 | struct iova *alloc_iova_mem(void); | ||
39 | void free_iova_mem(struct iova *iova); | ||
40 | void free_iova(struct iova_domain *iovad, unsigned long pfn); | ||
41 | void __free_iova(struct iova_domain *iovad, struct iova *iova); | ||
42 | struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size, | ||
43 | unsigned long limit_pfn, | ||
44 | bool size_aligned); | ||
45 | struct iova *reserve_iova(struct iova_domain *iovad, unsigned long pfn_lo, | ||
46 | unsigned long pfn_hi); | ||
47 | void copy_reserved_iova(struct iova_domain *from, struct iova_domain *to); | ||
48 | void init_iova_domain(struct iova_domain *iovad, unsigned long pfn_32bit); | ||
49 | struct iova *find_iova(struct iova_domain *iovad, unsigned long pfn); | ||
50 | void put_iova_domain(struct iova_domain *iovad); | ||
51 | |||
52 | #endif | ||
diff --git a/include/linux/jbd.h b/include/linux/jbd.h index 07a9b52a2654..35d4f6342fac 100644 --- a/include/linux/jbd.h +++ b/include/linux/jbd.h | |||
@@ -61,7 +61,7 @@ extern u8 journal_enable_debug; | |||
61 | do { \ | 61 | do { \ |
62 | if ((n) <= journal_enable_debug) { \ | 62 | if ((n) <= journal_enable_debug) { \ |
63 | printk (KERN_DEBUG "(%s, %d): %s: ", \ | 63 | printk (KERN_DEBUG "(%s, %d): %s: ", \ |
64 | __FILE__, __LINE__, __FUNCTION__); \ | 64 | __FILE__, __LINE__, __func__); \ |
65 | printk (f, ## a); \ | 65 | printk (f, ## a); \ |
66 | } \ | 66 | } \ |
67 | } while (0) | 67 | } while (0) |
@@ -816,6 +816,9 @@ struct journal_s | |||
816 | #define JFS_FLUSHED 0x008 /* The journal superblock has been flushed */ | 816 | #define JFS_FLUSHED 0x008 /* The journal superblock has been flushed */ |
817 | #define JFS_LOADED 0x010 /* The journal superblock has been loaded */ | 817 | #define JFS_LOADED 0x010 /* The journal superblock has been loaded */ |
818 | #define JFS_BARRIER 0x020 /* Use IDE barriers */ | 818 | #define JFS_BARRIER 0x020 /* Use IDE barriers */ |
819 | #define JFS_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file | ||
820 | * data write error in ordered | ||
821 | * mode */ | ||
819 | 822 | ||
820 | /* | 823 | /* |
821 | * Function declarations for the journaling transaction and buffer | 824 | * Function declarations for the journaling transaction and buffer |
@@ -984,7 +987,7 @@ extern int cleanup_journal_tail(journal_t *); | |||
984 | 987 | ||
985 | #define jbd_ENOSYS() \ | 988 | #define jbd_ENOSYS() \ |
986 | do { \ | 989 | do { \ |
987 | printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \ | 990 | printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \ |
988 | current->state = TASK_UNINTERRUPTIBLE; \ | 991 | current->state = TASK_UNINTERRUPTIBLE; \ |
989 | schedule(); \ | 992 | schedule(); \ |
990 | } while (1) | 993 | } while (1) |
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h index d2e91ea998fd..c7d106ef22e2 100644 --- a/include/linux/jbd2.h +++ b/include/linux/jbd2.h | |||
@@ -61,7 +61,7 @@ extern u8 jbd2_journal_enable_debug; | |||
61 | do { \ | 61 | do { \ |
62 | if ((n) <= jbd2_journal_enable_debug) { \ | 62 | if ((n) <= jbd2_journal_enable_debug) { \ |
63 | printk (KERN_DEBUG "(%s, %d): %s: ", \ | 63 | printk (KERN_DEBUG "(%s, %d): %s: ", \ |
64 | __FILE__, __LINE__, __FUNCTION__); \ | 64 | __FILE__, __LINE__, __func__); \ |
65 | printk (f, ## a); \ | 65 | printk (f, ## a); \ |
66 | } \ | 66 | } \ |
67 | } while (0) | 67 | } while (0) |
@@ -641,6 +641,11 @@ struct transaction_s | |||
641 | */ | 641 | */ |
642 | int t_handle_count; | 642 | int t_handle_count; |
643 | 643 | ||
644 | /* | ||
645 | * For use by the filesystem to store fs-specific data | ||
646 | * structures associated with the transaction | ||
647 | */ | ||
648 | struct list_head t_private_list; | ||
644 | }; | 649 | }; |
645 | 650 | ||
646 | struct transaction_run_stats_s { | 651 | struct transaction_run_stats_s { |
@@ -935,6 +940,10 @@ struct journal_s | |||
935 | 940 | ||
936 | pid_t j_last_sync_writer; | 941 | pid_t j_last_sync_writer; |
937 | 942 | ||
943 | /* This function is called when a transaction is closed */ | ||
944 | void (*j_commit_callback)(journal_t *, | ||
945 | transaction_t *); | ||
946 | |||
938 | /* | 947 | /* |
939 | * Journal statistics | 948 | * Journal statistics |
940 | */ | 949 | */ |
@@ -1143,7 +1152,7 @@ extern int jbd2_cleanup_journal_tail(journal_t *); | |||
1143 | 1152 | ||
1144 | #define jbd_ENOSYS() \ | 1153 | #define jbd_ENOSYS() \ |
1145 | do { \ | 1154 | do { \ |
1146 | printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \ | 1155 | printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \ |
1147 | current->state = TASK_UNINTERRUPTIBLE; \ | 1156 | current->state = TASK_UNINTERRUPTIBLE; \ |
1148 | schedule(); \ | 1157 | schedule(); \ |
1149 | } while (1) | 1158 | } while (1) |
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h index 8a62d1e84b9b..bb70ebb6a2d5 100644 --- a/include/linux/journal-head.h +++ b/include/linux/journal-head.h | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * buffer_head fields for JBD | 4 | * buffer_head fields for JBD |
5 | * | 5 | * |
6 | * 27 May 2001 Andrew Morton <akpm@digeo.com> | 6 | * 27 May 2001 Andrew Morton |
7 | * Created - pulled out of fs.h | 7 | * Created - pulled out of fs.h |
8 | */ | 8 | */ |
9 | 9 | ||
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h index b96144887444..f3fe34391d8e 100644 --- a/include/linux/kallsyms.h +++ b/include/linux/kallsyms.h | |||
@@ -93,12 +93,10 @@ static inline void print_symbol(const char *fmt, unsigned long addr) | |||
93 | } | 93 | } |
94 | 94 | ||
95 | /* | 95 | /* |
96 | * Pretty-print a function pointer. | 96 | * Pretty-print a function pointer. This function is deprecated. |
97 | * | 97 | * Please use the "%pF" vsprintf format instead. |
98 | * ia64 and ppc64 function pointers are really function descriptors, | ||
99 | * which contain a pointer the real address. | ||
100 | */ | 98 | */ |
101 | static inline void print_fn_descriptor_symbol(const char *fmt, void *addr) | 99 | static inline void __deprecated print_fn_descriptor_symbol(const char *fmt, void *addr) |
102 | { | 100 | { |
103 | #if defined(CONFIG_IA64) || defined(CONFIG_PPC64) | 101 | #if defined(CONFIG_IA64) || defined(CONFIG_PPC64) |
104 | addr = *(void **)addr; | 102 | addr = *(void **)addr; |
diff --git a/include/linux/kernel.h b/include/linux/kernel.h index 75d81f157d2e..5a566b705ca9 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h | |||
@@ -16,6 +16,7 @@ | |||
16 | #include <linux/log2.h> | 16 | #include <linux/log2.h> |
17 | #include <linux/typecheck.h> | 17 | #include <linux/typecheck.h> |
18 | #include <linux/ratelimit.h> | 18 | #include <linux/ratelimit.h> |
19 | #include <linux/dynamic_printk.h> | ||
19 | #include <asm/byteorder.h> | 20 | #include <asm/byteorder.h> |
20 | #include <asm/bug.h> | 21 | #include <asm/bug.h> |
21 | 22 | ||
@@ -213,6 +214,9 @@ static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \ | |||
213 | { return false; } | 214 | { return false; } |
214 | #endif | 215 | #endif |
215 | 216 | ||
217 | extern int printk_needs_cpu(int cpu); | ||
218 | extern void printk_tick(void); | ||
219 | |||
216 | extern void asmlinkage __attribute__((format(printf, 1, 2))) | 220 | extern void asmlinkage __attribute__((format(printf, 1, 2))) |
217 | early_printk(const char *fmt, ...); | 221 | early_printk(const char *fmt, ...); |
218 | 222 | ||
@@ -235,9 +239,10 @@ extern int oops_in_progress; /* If set, an oops, panic(), BUG() or die() is in | |||
235 | extern int panic_timeout; | 239 | extern int panic_timeout; |
236 | extern int panic_on_oops; | 240 | extern int panic_on_oops; |
237 | extern int panic_on_unrecovered_nmi; | 241 | extern int panic_on_unrecovered_nmi; |
238 | extern int tainted; | ||
239 | extern const char *print_tainted(void); | 242 | extern const char *print_tainted(void); |
240 | extern void add_taint(unsigned); | 243 | extern void add_taint(unsigned flag); |
244 | extern int test_taint(unsigned flag); | ||
245 | extern unsigned long get_taint(void); | ||
241 | extern int root_mountflags; | 246 | extern int root_mountflags; |
242 | 247 | ||
243 | /* Values used for system_state */ | 248 | /* Values used for system_state */ |
@@ -250,16 +255,17 @@ extern enum system_states { | |||
250 | SYSTEM_SUSPEND_DISK, | 255 | SYSTEM_SUSPEND_DISK, |
251 | } system_state; | 256 | } system_state; |
252 | 257 | ||
253 | #define TAINT_PROPRIETARY_MODULE (1<<0) | 258 | #define TAINT_PROPRIETARY_MODULE 0 |
254 | #define TAINT_FORCED_MODULE (1<<1) | 259 | #define TAINT_FORCED_MODULE 1 |
255 | #define TAINT_UNSAFE_SMP (1<<2) | 260 | #define TAINT_UNSAFE_SMP 2 |
256 | #define TAINT_FORCED_RMMOD (1<<3) | 261 | #define TAINT_FORCED_RMMOD 3 |
257 | #define TAINT_MACHINE_CHECK (1<<4) | 262 | #define TAINT_MACHINE_CHECK 4 |
258 | #define TAINT_BAD_PAGE (1<<5) | 263 | #define TAINT_BAD_PAGE 5 |
259 | #define TAINT_USER (1<<6) | 264 | #define TAINT_USER 6 |
260 | #define TAINT_DIE (1<<7) | 265 | #define TAINT_DIE 7 |
261 | #define TAINT_OVERRIDDEN_ACPI_TABLE (1<<8) | 266 | #define TAINT_OVERRIDDEN_ACPI_TABLE 8 |
262 | #define TAINT_WARN (1<<9) | 267 | #define TAINT_WARN 9 |
268 | #define TAINT_CRAP 10 | ||
263 | 269 | ||
264 | extern void dump_stack(void) __cold; | 270 | extern void dump_stack(void) __cold; |
265 | 271 | ||
@@ -303,8 +309,12 @@ static inline char *pack_hex_byte(char *buf, u8 byte) | |||
303 | #define pr_info(fmt, arg...) \ | 309 | #define pr_info(fmt, arg...) \ |
304 | printk(KERN_INFO fmt, ##arg) | 310 | printk(KERN_INFO fmt, ##arg) |
305 | 311 | ||
306 | #ifdef DEBUG | ||
307 | /* If you are writing a driver, please use dev_dbg instead */ | 312 | /* If you are writing a driver, please use dev_dbg instead */ |
313 | #if defined(CONFIG_DYNAMIC_PRINTK_DEBUG) | ||
314 | #define pr_debug(fmt, ...) do { \ | ||
315 | dynamic_pr_debug(fmt, ##__VA_ARGS__); \ | ||
316 | } while (0) | ||
317 | #elif defined(DEBUG) | ||
308 | #define pr_debug(fmt, arg...) \ | 318 | #define pr_debug(fmt, arg...) \ |
309 | printk(KERN_DEBUG fmt, ##arg) | 319 | printk(KERN_DEBUG fmt, ##arg) |
310 | #else | 320 | #else |
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h index cf9f40a91c9c..cac3750cd65e 100644 --- a/include/linux/kernel_stat.h +++ b/include/linux/kernel_stat.h | |||
@@ -52,6 +52,7 @@ static inline int kstat_irqs(int irq) | |||
52 | return sum; | 52 | return sum; |
53 | } | 53 | } |
54 | 54 | ||
55 | extern unsigned long long task_delta_exec(struct task_struct *); | ||
55 | extern void account_user_time(struct task_struct *, cputime_t); | 56 | extern void account_user_time(struct task_struct *, cputime_t); |
56 | extern void account_user_time_scaled(struct task_struct *, cputime_t); | 57 | extern void account_user_time_scaled(struct task_struct *, cputime_t); |
57 | extern void account_system_time(struct task_struct *, int, cputime_t); | 58 | extern void account_system_time(struct task_struct *, int, cputime_t); |
diff --git a/include/linux/kmod.h b/include/linux/kmod.h index a1a91577813c..92213a9194e1 100644 --- a/include/linux/kmod.h +++ b/include/linux/kmod.h | |||
@@ -99,4 +99,7 @@ struct file; | |||
99 | extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[], | 99 | extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[], |
100 | struct file **filp); | 100 | struct file **filp); |
101 | 101 | ||
102 | extern int usermodehelper_disable(void); | ||
103 | extern void usermodehelper_enable(void); | ||
104 | |||
102 | #endif /* __LINUX_KMOD_H__ */ | 105 | #endif /* __LINUX_KMOD_H__ */ |
diff --git a/include/linux/kvm.h b/include/linux/kvm.h index 70a30651cd12..797fcd781242 100644 --- a/include/linux/kvm.h +++ b/include/linux/kvm.h | |||
@@ -311,22 +311,33 @@ struct kvm_s390_interrupt { | |||
311 | 311 | ||
312 | /* This structure represents a single trace buffer record. */ | 312 | /* This structure represents a single trace buffer record. */ |
313 | struct kvm_trace_rec { | 313 | struct kvm_trace_rec { |
314 | __u32 event:28; | 314 | /* variable rec_val |
315 | __u32 extra_u32:3; | 315 | * is split into: |
316 | __u32 cycle_in:1; | 316 | * bits 0 - 27 -> event id |
317 | * bits 28 -30 -> number of extra data args of size u32 | ||
318 | * bits 31 -> binary indicator for if tsc is in record | ||
319 | */ | ||
320 | __u32 rec_val; | ||
317 | __u32 pid; | 321 | __u32 pid; |
318 | __u32 vcpu_id; | 322 | __u32 vcpu_id; |
319 | union { | 323 | union { |
320 | struct { | 324 | struct { |
321 | __u64 cycle_u64; | 325 | __u64 timestamp; |
322 | __u32 extra_u32[KVM_TRC_EXTRA_MAX]; | 326 | __u32 extra_u32[KVM_TRC_EXTRA_MAX]; |
323 | } __attribute__((packed)) cycle; | 327 | } __attribute__((packed)) timestamp; |
324 | struct { | 328 | struct { |
325 | __u32 extra_u32[KVM_TRC_EXTRA_MAX]; | 329 | __u32 extra_u32[KVM_TRC_EXTRA_MAX]; |
326 | } nocycle; | 330 | } notimestamp; |
327 | } u; | 331 | } u; |
328 | }; | 332 | }; |
329 | 333 | ||
334 | #define TRACE_REC_EVENT_ID(val) \ | ||
335 | (0x0fffffff & (val)) | ||
336 | #define TRACE_REC_NUM_DATA_ARGS(val) \ | ||
337 | (0x70000000 & ((val) << 28)) | ||
338 | #define TRACE_REC_TCS(val) \ | ||
339 | (0x80000000 & ((val) << 31)) | ||
340 | |||
330 | #define KVMIO 0xAE | 341 | #define KVMIO 0xAE |
331 | 342 | ||
332 | /* | 343 | /* |
@@ -372,6 +383,10 @@ struct kvm_trace_rec { | |||
372 | #define KVM_CAP_MP_STATE 14 | 383 | #define KVM_CAP_MP_STATE 14 |
373 | #define KVM_CAP_COALESCED_MMIO 15 | 384 | #define KVM_CAP_COALESCED_MMIO 15 |
374 | #define KVM_CAP_SYNC_MMU 16 /* Changes to host mmap are reflected in guest */ | 385 | #define KVM_CAP_SYNC_MMU 16 /* Changes to host mmap are reflected in guest */ |
386 | #if defined(CONFIG_X86)||defined(CONFIG_IA64) | ||
387 | #define KVM_CAP_DEVICE_ASSIGNMENT 17 | ||
388 | #endif | ||
389 | #define KVM_CAP_IOMMU 18 | ||
375 | 390 | ||
376 | /* | 391 | /* |
377 | * ioctls for VM fds | 392 | * ioctls for VM fds |
@@ -401,6 +416,10 @@ struct kvm_trace_rec { | |||
401 | _IOW(KVMIO, 0x67, struct kvm_coalesced_mmio_zone) | 416 | _IOW(KVMIO, 0x67, struct kvm_coalesced_mmio_zone) |
402 | #define KVM_UNREGISTER_COALESCED_MMIO \ | 417 | #define KVM_UNREGISTER_COALESCED_MMIO \ |
403 | _IOW(KVMIO, 0x68, struct kvm_coalesced_mmio_zone) | 418 | _IOW(KVMIO, 0x68, struct kvm_coalesced_mmio_zone) |
419 | #define KVM_ASSIGN_PCI_DEVICE _IOR(KVMIO, 0x69, \ | ||
420 | struct kvm_assigned_pci_dev) | ||
421 | #define KVM_ASSIGN_IRQ _IOR(KVMIO, 0x70, \ | ||
422 | struct kvm_assigned_irq) | ||
404 | 423 | ||
405 | /* | 424 | /* |
406 | * ioctls for vcpu fds | 425 | * ioctls for vcpu fds |
@@ -440,4 +459,45 @@ struct kvm_trace_rec { | |||
440 | #define KVM_GET_MP_STATE _IOR(KVMIO, 0x98, struct kvm_mp_state) | 459 | #define KVM_GET_MP_STATE _IOR(KVMIO, 0x98, struct kvm_mp_state) |
441 | #define KVM_SET_MP_STATE _IOW(KVMIO, 0x99, struct kvm_mp_state) | 460 | #define KVM_SET_MP_STATE _IOW(KVMIO, 0x99, struct kvm_mp_state) |
442 | 461 | ||
462 | #define KVM_TRC_INJ_VIRQ (KVM_TRC_HANDLER + 0x02) | ||
463 | #define KVM_TRC_REDELIVER_EVT (KVM_TRC_HANDLER + 0x03) | ||
464 | #define KVM_TRC_PEND_INTR (KVM_TRC_HANDLER + 0x04) | ||
465 | #define KVM_TRC_IO_READ (KVM_TRC_HANDLER + 0x05) | ||
466 | #define KVM_TRC_IO_WRITE (KVM_TRC_HANDLER + 0x06) | ||
467 | #define KVM_TRC_CR_READ (KVM_TRC_HANDLER + 0x07) | ||
468 | #define KVM_TRC_CR_WRITE (KVM_TRC_HANDLER + 0x08) | ||
469 | #define KVM_TRC_DR_READ (KVM_TRC_HANDLER + 0x09) | ||
470 | #define KVM_TRC_DR_WRITE (KVM_TRC_HANDLER + 0x0A) | ||
471 | #define KVM_TRC_MSR_READ (KVM_TRC_HANDLER + 0x0B) | ||
472 | #define KVM_TRC_MSR_WRITE (KVM_TRC_HANDLER + 0x0C) | ||
473 | #define KVM_TRC_CPUID (KVM_TRC_HANDLER + 0x0D) | ||
474 | #define KVM_TRC_INTR (KVM_TRC_HANDLER + 0x0E) | ||
475 | #define KVM_TRC_NMI (KVM_TRC_HANDLER + 0x0F) | ||
476 | #define KVM_TRC_VMMCALL (KVM_TRC_HANDLER + 0x10) | ||
477 | #define KVM_TRC_HLT (KVM_TRC_HANDLER + 0x11) | ||
478 | #define KVM_TRC_CLTS (KVM_TRC_HANDLER + 0x12) | ||
479 | #define KVM_TRC_LMSW (KVM_TRC_HANDLER + 0x13) | ||
480 | #define KVM_TRC_APIC_ACCESS (KVM_TRC_HANDLER + 0x14) | ||
481 | #define KVM_TRC_TDP_FAULT (KVM_TRC_HANDLER + 0x15) | ||
482 | #define KVM_TRC_GTLB_WRITE (KVM_TRC_HANDLER + 0x16) | ||
483 | #define KVM_TRC_STLB_WRITE (KVM_TRC_HANDLER + 0x17) | ||
484 | #define KVM_TRC_STLB_INVAL (KVM_TRC_HANDLER + 0x18) | ||
485 | #define KVM_TRC_PPC_INSTR (KVM_TRC_HANDLER + 0x19) | ||
486 | |||
487 | struct kvm_assigned_pci_dev { | ||
488 | __u32 assigned_dev_id; | ||
489 | __u32 busnr; | ||
490 | __u32 devfn; | ||
491 | __u32 flags; | ||
492 | }; | ||
493 | |||
494 | struct kvm_assigned_irq { | ||
495 | __u32 assigned_dev_id; | ||
496 | __u32 host_irq; | ||
497 | __u32 guest_irq; | ||
498 | __u32 flags; | ||
499 | }; | ||
500 | |||
501 | #define KVM_DEV_ASSIGN_ENABLE_IOMMU (1 << 0) | ||
502 | |||
443 | #endif | 503 | #endif |
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 8525afc53107..3833c48fae3a 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h | |||
@@ -34,6 +34,8 @@ | |||
34 | #define KVM_REQ_MMU_RELOAD 3 | 34 | #define KVM_REQ_MMU_RELOAD 3 |
35 | #define KVM_REQ_TRIPLE_FAULT 4 | 35 | #define KVM_REQ_TRIPLE_FAULT 4 |
36 | #define KVM_REQ_PENDING_TIMER 5 | 36 | #define KVM_REQ_PENDING_TIMER 5 |
37 | #define KVM_REQ_UNHALT 6 | ||
38 | #define KVM_REQ_MMU_SYNC 7 | ||
37 | 39 | ||
38 | struct kvm_vcpu; | 40 | struct kvm_vcpu; |
39 | extern struct kmem_cache *kvm_vcpu_cache; | 41 | extern struct kmem_cache *kvm_vcpu_cache; |
@@ -279,12 +281,68 @@ void kvm_free_physmem(struct kvm *kvm); | |||
279 | 281 | ||
280 | struct kvm *kvm_arch_create_vm(void); | 282 | struct kvm *kvm_arch_create_vm(void); |
281 | void kvm_arch_destroy_vm(struct kvm *kvm); | 283 | void kvm_arch_destroy_vm(struct kvm *kvm); |
284 | void kvm_free_all_assigned_devices(struct kvm *kvm); | ||
282 | 285 | ||
283 | int kvm_cpu_get_interrupt(struct kvm_vcpu *v); | 286 | int kvm_cpu_get_interrupt(struct kvm_vcpu *v); |
284 | int kvm_cpu_has_interrupt(struct kvm_vcpu *v); | 287 | int kvm_cpu_has_interrupt(struct kvm_vcpu *v); |
285 | int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu); | 288 | int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu); |
286 | void kvm_vcpu_kick(struct kvm_vcpu *vcpu); | 289 | void kvm_vcpu_kick(struct kvm_vcpu *vcpu); |
287 | 290 | ||
291 | int kvm_is_mmio_pfn(pfn_t pfn); | ||
292 | |||
293 | struct kvm_irq_ack_notifier { | ||
294 | struct hlist_node link; | ||
295 | unsigned gsi; | ||
296 | void (*irq_acked)(struct kvm_irq_ack_notifier *kian); | ||
297 | }; | ||
298 | |||
299 | struct kvm_assigned_dev_kernel { | ||
300 | struct kvm_irq_ack_notifier ack_notifier; | ||
301 | struct work_struct interrupt_work; | ||
302 | struct list_head list; | ||
303 | int assigned_dev_id; | ||
304 | int host_busnr; | ||
305 | int host_devfn; | ||
306 | int host_irq; | ||
307 | int guest_irq; | ||
308 | int irq_requested; | ||
309 | struct pci_dev *dev; | ||
310 | struct kvm *kvm; | ||
311 | }; | ||
312 | void kvm_set_irq(struct kvm *kvm, int irq, int level); | ||
313 | void kvm_notify_acked_irq(struct kvm *kvm, unsigned gsi); | ||
314 | void kvm_register_irq_ack_notifier(struct kvm *kvm, | ||
315 | struct kvm_irq_ack_notifier *kian); | ||
316 | void kvm_unregister_irq_ack_notifier(struct kvm *kvm, | ||
317 | struct kvm_irq_ack_notifier *kian); | ||
318 | |||
319 | #ifdef CONFIG_DMAR | ||
320 | int kvm_iommu_map_pages(struct kvm *kvm, gfn_t base_gfn, | ||
321 | unsigned long npages); | ||
322 | int kvm_iommu_map_guest(struct kvm *kvm, | ||
323 | struct kvm_assigned_dev_kernel *assigned_dev); | ||
324 | int kvm_iommu_unmap_guest(struct kvm *kvm); | ||
325 | #else /* CONFIG_DMAR */ | ||
326 | static inline int kvm_iommu_map_pages(struct kvm *kvm, | ||
327 | gfn_t base_gfn, | ||
328 | unsigned long npages) | ||
329 | { | ||
330 | return 0; | ||
331 | } | ||
332 | |||
333 | static inline int kvm_iommu_map_guest(struct kvm *kvm, | ||
334 | struct kvm_assigned_dev_kernel | ||
335 | *assigned_dev) | ||
336 | { | ||
337 | return -ENODEV; | ||
338 | } | ||
339 | |||
340 | static inline int kvm_iommu_unmap_guest(struct kvm *kvm) | ||
341 | { | ||
342 | return 0; | ||
343 | } | ||
344 | #endif /* CONFIG_DMAR */ | ||
345 | |||
288 | static inline void kvm_guest_enter(void) | 346 | static inline void kvm_guest_enter(void) |
289 | { | 347 | { |
290 | account_system_vtime(current); | 348 | account_system_vtime(current); |
@@ -307,6 +365,11 @@ static inline gpa_t gfn_to_gpa(gfn_t gfn) | |||
307 | return (gpa_t)gfn << PAGE_SHIFT; | 365 | return (gpa_t)gfn << PAGE_SHIFT; |
308 | } | 366 | } |
309 | 367 | ||
368 | static inline hpa_t pfn_to_hpa(pfn_t pfn) | ||
369 | { | ||
370 | return (hpa_t)pfn << PAGE_SHIFT; | ||
371 | } | ||
372 | |||
310 | static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu) | 373 | static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu) |
311 | { | 374 | { |
312 | set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests); | 375 | set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests); |
@@ -326,6 +389,25 @@ struct kvm_stats_debugfs_item { | |||
326 | extern struct kvm_stats_debugfs_item debugfs_entries[]; | 389 | extern struct kvm_stats_debugfs_item debugfs_entries[]; |
327 | extern struct dentry *kvm_debugfs_dir; | 390 | extern struct dentry *kvm_debugfs_dir; |
328 | 391 | ||
392 | #define KVMTRACE_5D(evt, vcpu, d1, d2, d3, d4, d5, name) \ | ||
393 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
394 | vcpu, 5, d1, d2, d3, d4, d5) | ||
395 | #define KVMTRACE_4D(evt, vcpu, d1, d2, d3, d4, name) \ | ||
396 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
397 | vcpu, 4, d1, d2, d3, d4, 0) | ||
398 | #define KVMTRACE_3D(evt, vcpu, d1, d2, d3, name) \ | ||
399 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
400 | vcpu, 3, d1, d2, d3, 0, 0) | ||
401 | #define KVMTRACE_2D(evt, vcpu, d1, d2, name) \ | ||
402 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
403 | vcpu, 2, d1, d2, 0, 0, 0) | ||
404 | #define KVMTRACE_1D(evt, vcpu, d1, name) \ | ||
405 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
406 | vcpu, 1, d1, 0, 0, 0, 0) | ||
407 | #define KVMTRACE_0D(evt, vcpu, name) \ | ||
408 | trace_mark(kvm_trace_##name, "%u %p %u %u %u %u %u %u", KVM_TRC_##evt, \ | ||
409 | vcpu, 0, 0, 0, 0, 0, 0) | ||
410 | |||
329 | #ifdef CONFIG_KVM_TRACE | 411 | #ifdef CONFIG_KVM_TRACE |
330 | int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg); | 412 | int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg); |
331 | void kvm_trace_cleanup(void); | 413 | void kvm_trace_cleanup(void); |
diff --git a/include/linux/map_to_7segment.h b/include/linux/map_to_7segment.h new file mode 100644 index 000000000000..7df8432c4402 --- /dev/null +++ b/include/linux/map_to_7segment.h | |||
@@ -0,0 +1,187 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com> | ||
3 | * | ||
4 | * This program is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU General Public License as | ||
6 | * published by the Free Software Foundation; either version 2 of | ||
7 | * the License, or (at your option) any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | * GNU General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License | ||
15 | * along with this program; if not, write to the Free Software | ||
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
17 | */ | ||
18 | |||
19 | #ifndef MAP_TO_7SEGMENT_H | ||
20 | #define MAP_TO_7SEGMENT_H | ||
21 | |||
22 | /* This file provides translation primitives and tables for the conversion | ||
23 | * of (ASCII) characters to a 7-segments notation. | ||
24 | * | ||
25 | * The 7 segment's wikipedia notation below is used as standard. | ||
26 | * See: http://en.wikipedia.org/wiki/Seven_segment_display | ||
27 | * | ||
28 | * Notation: +-a-+ | ||
29 | * f b | ||
30 | * +-g-+ | ||
31 | * e c | ||
32 | * +-d-+ | ||
33 | * | ||
34 | * Usage: | ||
35 | * | ||
36 | * Register a map variable, and fill it with a character set: | ||
37 | * static SEG7_DEFAULT_MAP(map_seg7); | ||
38 | * | ||
39 | * | ||
40 | * Then use for conversion: | ||
41 | * seg7 = map_to_seg7(&map_seg7, some_char); | ||
42 | * ... | ||
43 | * | ||
44 | * In device drivers it is recommended, if required, to make the char map | ||
45 | * accessible via the sysfs interface using the following scheme: | ||
46 | * | ||
47 | * static ssize_t show_map(struct device *dev, char *buf) { | ||
48 | * memcpy(buf, &map_seg7, sizeof(map_seg7)); | ||
49 | * return sizeof(map_seg7); | ||
50 | * } | ||
51 | * static ssize_t store_map(struct device *dev, const char *buf, size_t cnt) { | ||
52 | * if(cnt != sizeof(map_seg7)) | ||
53 | * return -EINVAL; | ||
54 | * memcpy(&map_seg7, buf, cnt); | ||
55 | * return cnt; | ||
56 | * } | ||
57 | * static DEVICE_ATTR(map_seg7, PERMS_RW, show_map, store_map); | ||
58 | * | ||
59 | * History: | ||
60 | * 2005-05-31 RFC linux-kernel@vger.kernel.org | ||
61 | */ | ||
62 | #include <linux/errno.h> | ||
63 | |||
64 | |||
65 | #define BIT_SEG7_A 0 | ||
66 | #define BIT_SEG7_B 1 | ||
67 | #define BIT_SEG7_C 2 | ||
68 | #define BIT_SEG7_D 3 | ||
69 | #define BIT_SEG7_E 4 | ||
70 | #define BIT_SEG7_F 5 | ||
71 | #define BIT_SEG7_G 6 | ||
72 | #define BIT_SEG7_RESERVED 7 | ||
73 | |||
74 | struct seg7_conversion_map { | ||
75 | unsigned char table[128]; | ||
76 | }; | ||
77 | |||
78 | static inline int map_to_seg7(struct seg7_conversion_map *map, int c) | ||
79 | { | ||
80 | return c >= 0 && c < sizeof(map->table) ? map->table[c] : -EINVAL; | ||
81 | } | ||
82 | |||
83 | #define SEG7_CONVERSION_MAP(_name, _map) \ | ||
84 | struct seg7_conversion_map _name = { .table = { _map } } | ||
85 | |||
86 | /* | ||
87 | * It is recommended to use a facility that allows user space to redefine | ||
88 | * custom character sets for LCD devices. Please use a sysfs interface | ||
89 | * as described above. | ||
90 | */ | ||
91 | #define MAP_TO_SEG7_SYSFS_FILE "map_seg7" | ||
92 | |||
93 | /******************************************************************************* | ||
94 | * ASCII conversion table | ||
95 | ******************************************************************************/ | ||
96 | |||
97 | #define _SEG7(l,a,b,c,d,e,f,g) \ | ||
98 | ( a<<BIT_SEG7_A | b<<BIT_SEG7_B | c<<BIT_SEG7_C | d<<BIT_SEG7_D | \ | ||
99 | e<<BIT_SEG7_E | f<<BIT_SEG7_F | g<<BIT_SEG7_G ) | ||
100 | |||
101 | #define _MAP_0_32_ASCII_SEG7_NON_PRINTABLE \ | ||
102 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, | ||
103 | |||
104 | #define _MAP_33_47_ASCII_SEG7_SYMBOL \ | ||
105 | _SEG7('!',0,0,0,0,1,1,0), _SEG7('"',0,1,0,0,0,1,0), _SEG7('#',0,1,1,0,1,1,0),\ | ||
106 | _SEG7('$',1,0,1,1,0,1,1), _SEG7('%',0,0,1,0,0,1,0), _SEG7('&',1,0,1,1,1,1,1),\ | ||
107 | _SEG7('\'',0,0,0,0,0,1,0),_SEG7('(',1,0,0,1,1,1,0), _SEG7(')',1,1,1,1,0,0,0),\ | ||
108 | _SEG7('*',0,1,1,0,1,1,1), _SEG7('+',0,1,1,0,0,0,1), _SEG7(',',0,0,0,0,1,0,0),\ | ||
109 | _SEG7('-',0,0,0,0,0,0,1), _SEG7('.',0,0,0,0,1,0,0), _SEG7('/',0,1,0,0,1,0,1), | ||
110 | |||
111 | #define _MAP_48_57_ASCII_SEG7_NUMERIC \ | ||
112 | _SEG7('0',1,1,1,1,1,1,0), _SEG7('1',0,1,1,0,0,0,0), _SEG7('2',1,1,0,1,1,0,1),\ | ||
113 | _SEG7('3',1,1,1,1,0,0,1), _SEG7('4',0,1,1,0,0,1,1), _SEG7('5',1,0,1,1,0,1,1),\ | ||
114 | _SEG7('6',1,0,1,1,1,1,1), _SEG7('7',1,1,1,0,0,0,0), _SEG7('8',1,1,1,1,1,1,1),\ | ||
115 | _SEG7('9',1,1,1,1,0,1,1), | ||
116 | |||
117 | #define _MAP_58_64_ASCII_SEG7_SYMBOL \ | ||
118 | _SEG7(':',0,0,0,1,0,0,1), _SEG7(';',0,0,0,1,0,0,1), _SEG7('<',1,0,0,0,0,1,1),\ | ||
119 | _SEG7('=',0,0,0,1,0,0,1), _SEG7('>',1,1,0,0,0,0,1), _SEG7('?',1,1,1,0,0,1,0),\ | ||
120 | _SEG7('@',1,1,0,1,1,1,1), | ||
121 | |||
122 | #define _MAP_65_90_ASCII_SEG7_ALPHA_UPPR \ | ||
123 | _SEG7('A',1,1,1,0,1,1,1), _SEG7('B',1,1,1,1,1,1,1), _SEG7('C',1,0,0,1,1,1,0),\ | ||
124 | _SEG7('D',1,1,1,1,1,1,0), _SEG7('E',1,0,0,1,1,1,1), _SEG7('F',1,0,0,0,1,1,1),\ | ||
125 | _SEG7('G',1,1,1,1,0,1,1), _SEG7('H',0,1,1,0,1,1,1), _SEG7('I',0,1,1,0,0,0,0),\ | ||
126 | _SEG7('J',0,1,1,1,0,0,0), _SEG7('K',0,1,1,0,1,1,1), _SEG7('L',0,0,0,1,1,1,0),\ | ||
127 | _SEG7('M',1,1,1,0,1,1,0), _SEG7('N',1,1,1,0,1,1,0), _SEG7('O',1,1,1,1,1,1,0),\ | ||
128 | _SEG7('P',1,1,0,0,1,1,1), _SEG7('Q',1,1,1,1,1,1,0), _SEG7('R',1,1,1,0,1,1,1),\ | ||
129 | _SEG7('S',1,0,1,1,0,1,1), _SEG7('T',0,0,0,1,1,1,1), _SEG7('U',0,1,1,1,1,1,0),\ | ||
130 | _SEG7('V',0,1,1,1,1,1,0), _SEG7('W',0,1,1,1,1,1,1), _SEG7('X',0,1,1,0,1,1,1),\ | ||
131 | _SEG7('Y',0,1,1,0,0,1,1), _SEG7('Z',1,1,0,1,1,0,1), | ||
132 | |||
133 | #define _MAP_91_96_ASCII_SEG7_SYMBOL \ | ||
134 | _SEG7('[',1,0,0,1,1,1,0), _SEG7('\\',0,0,1,0,0,1,1),_SEG7(']',1,1,1,1,0,0,0),\ | ||
135 | _SEG7('^',1,1,0,0,0,1,0), _SEG7('_',0,0,0,1,0,0,0), _SEG7('`',0,1,0,0,0,0,0), | ||
136 | |||
137 | #define _MAP_97_122_ASCII_SEG7_ALPHA_LOWER \ | ||
138 | _SEG7('A',1,1,1,0,1,1,1), _SEG7('b',0,0,1,1,1,1,1), _SEG7('c',0,0,0,1,1,0,1),\ | ||
139 | _SEG7('d',0,1,1,1,1,0,1), _SEG7('E',1,0,0,1,1,1,1), _SEG7('F',1,0,0,0,1,1,1),\ | ||
140 | _SEG7('G',1,1,1,1,0,1,1), _SEG7('h',0,0,1,0,1,1,1), _SEG7('i',0,0,1,0,0,0,0),\ | ||
141 | _SEG7('j',0,0,1,1,0,0,0), _SEG7('k',0,0,1,0,1,1,1), _SEG7('L',0,0,0,1,1,1,0),\ | ||
142 | _SEG7('M',1,1,1,0,1,1,0), _SEG7('n',0,0,1,0,1,0,1), _SEG7('o',0,0,1,1,1,0,1),\ | ||
143 | _SEG7('P',1,1,0,0,1,1,1), _SEG7('q',1,1,1,0,0,1,1), _SEG7('r',0,0,0,0,1,0,1),\ | ||
144 | _SEG7('S',1,0,1,1,0,1,1), _SEG7('T',0,0,0,1,1,1,1), _SEG7('u',0,0,1,1,1,0,0),\ | ||
145 | _SEG7('v',0,0,1,1,1,0,0), _SEG7('W',0,1,1,1,1,1,1), _SEG7('X',0,1,1,0,1,1,1),\ | ||
146 | _SEG7('y',0,1,1,1,0,1,1), _SEG7('Z',1,1,0,1,1,0,1), | ||
147 | |||
148 | #define _MAP_123_126_ASCII_SEG7_SYMBOL \ | ||
149 | _SEG7('{',1,0,0,1,1,1,0), _SEG7('|',0,0,0,0,1,1,0), _SEG7('}',1,1,1,1,0,0,0),\ | ||
150 | _SEG7('~',1,0,0,0,0,0,0), | ||
151 | |||
152 | /* Maps */ | ||
153 | |||
154 | /* This set tries to map as close as possible to the visible characteristics | ||
155 | * of the ASCII symbol, lowercase and uppercase letters may differ in | ||
156 | * presentation on the display. | ||
157 | */ | ||
158 | #define MAP_ASCII7SEG_ALPHANUM \ | ||
159 | _MAP_0_32_ASCII_SEG7_NON_PRINTABLE \ | ||
160 | _MAP_33_47_ASCII_SEG7_SYMBOL \ | ||
161 | _MAP_48_57_ASCII_SEG7_NUMERIC \ | ||
162 | _MAP_58_64_ASCII_SEG7_SYMBOL \ | ||
163 | _MAP_65_90_ASCII_SEG7_ALPHA_UPPR \ | ||
164 | _MAP_91_96_ASCII_SEG7_SYMBOL \ | ||
165 | _MAP_97_122_ASCII_SEG7_ALPHA_LOWER \ | ||
166 | _MAP_123_126_ASCII_SEG7_SYMBOL | ||
167 | |||
168 | /* This set tries to map as close as possible to the symbolic characteristics | ||
169 | * of the ASCII character for maximum discrimination. | ||
170 | * For now this means all alpha chars are in lower case representations. | ||
171 | * (This for example facilitates the use of hex numbers with uppercase input.) | ||
172 | */ | ||
173 | #define MAP_ASCII7SEG_ALPHANUM_LC \ | ||
174 | _MAP_0_32_ASCII_SEG7_NON_PRINTABLE \ | ||
175 | _MAP_33_47_ASCII_SEG7_SYMBOL \ | ||
176 | _MAP_48_57_ASCII_SEG7_NUMERIC \ | ||
177 | _MAP_58_64_ASCII_SEG7_SYMBOL \ | ||
178 | _MAP_97_122_ASCII_SEG7_ALPHA_LOWER \ | ||
179 | _MAP_91_96_ASCII_SEG7_SYMBOL \ | ||
180 | _MAP_97_122_ASCII_SEG7_ALPHA_LOWER \ | ||
181 | _MAP_123_126_ASCII_SEG7_SYMBOL | ||
182 | |||
183 | #define SEG7_DEFAULT_MAP(_name) \ | ||
184 | SEG7_CONVERSION_MAP(_name,MAP_ASCII7SEG_ALPHANUM) | ||
185 | |||
186 | #endif /* MAP_TO_7SEGMENT_H */ | ||
187 | |||
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index fdf3967e1397..1fbe14d39521 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h | |||
@@ -27,16 +27,13 @@ struct mm_struct; | |||
27 | 27 | ||
28 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR | 28 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR |
29 | 29 | ||
30 | #define page_reset_bad_cgroup(page) ((page)->page_cgroup = 0) | ||
31 | |||
32 | extern struct page_cgroup *page_get_page_cgroup(struct page *page); | ||
33 | extern int mem_cgroup_charge(struct page *page, struct mm_struct *mm, | 30 | extern int mem_cgroup_charge(struct page *page, struct mm_struct *mm, |
34 | gfp_t gfp_mask); | 31 | gfp_t gfp_mask); |
35 | extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm, | 32 | extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm, |
36 | gfp_t gfp_mask); | 33 | gfp_t gfp_mask); |
34 | extern void mem_cgroup_move_lists(struct page *page, enum lru_list lru); | ||
37 | extern void mem_cgroup_uncharge_page(struct page *page); | 35 | extern void mem_cgroup_uncharge_page(struct page *page); |
38 | extern void mem_cgroup_uncharge_cache_page(struct page *page); | 36 | extern void mem_cgroup_uncharge_cache_page(struct page *page); |
39 | extern void mem_cgroup_move_lists(struct page *page, bool active); | ||
40 | extern int mem_cgroup_shrink_usage(struct mm_struct *mm, gfp_t gfp_mask); | 37 | extern int mem_cgroup_shrink_usage(struct mm_struct *mm, gfp_t gfp_mask); |
41 | 38 | ||
42 | extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan, | 39 | extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan, |
@@ -44,7 +41,7 @@ extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan, | |||
44 | unsigned long *scanned, int order, | 41 | unsigned long *scanned, int order, |
45 | int mode, struct zone *z, | 42 | int mode, struct zone *z, |
46 | struct mem_cgroup *mem_cont, | 43 | struct mem_cgroup *mem_cont, |
47 | int active); | 44 | int active, int file); |
48 | extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask); | 45 | extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask); |
49 | int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem); | 46 | int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem); |
50 | 47 | ||
@@ -69,21 +66,11 @@ extern void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem, | |||
69 | extern void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem, | 66 | extern void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem, |
70 | int priority); | 67 | int priority); |
71 | 68 | ||
72 | extern long mem_cgroup_calc_reclaim_active(struct mem_cgroup *mem, | 69 | extern long mem_cgroup_calc_reclaim(struct mem_cgroup *mem, struct zone *zone, |
73 | struct zone *zone, int priority); | 70 | int priority, enum lru_list lru); |
74 | extern long mem_cgroup_calc_reclaim_inactive(struct mem_cgroup *mem, | ||
75 | struct zone *zone, int priority); | ||
76 | |||
77 | #else /* CONFIG_CGROUP_MEM_RES_CTLR */ | ||
78 | static inline void page_reset_bad_cgroup(struct page *page) | ||
79 | { | ||
80 | } | ||
81 | 71 | ||
82 | static inline struct page_cgroup *page_get_page_cgroup(struct page *page) | ||
83 | { | ||
84 | return NULL; | ||
85 | } | ||
86 | 72 | ||
73 | #else /* CONFIG_CGROUP_MEM_RES_CTLR */ | ||
87 | static inline int mem_cgroup_charge(struct page *page, | 74 | static inline int mem_cgroup_charge(struct page *page, |
88 | struct mm_struct *mm, gfp_t gfp_mask) | 75 | struct mm_struct *mm, gfp_t gfp_mask) |
89 | { | 76 | { |
@@ -159,14 +146,9 @@ static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem, | |||
159 | { | 146 | { |
160 | } | 147 | } |
161 | 148 | ||
162 | static inline long mem_cgroup_calc_reclaim_active(struct mem_cgroup *mem, | 149 | static inline long mem_cgroup_calc_reclaim(struct mem_cgroup *mem, |
163 | struct zone *zone, int priority) | 150 | struct zone *zone, int priority, |
164 | { | 151 | enum lru_list lru) |
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static inline long mem_cgroup_calc_reclaim_inactive(struct mem_cgroup *mem, | ||
169 | struct zone *zone, int priority) | ||
170 | { | 152 | { |
171 | return 0; | 153 | return 0; |
172 | } | 154 | } |
diff --git a/include/linux/mfd/da903x.h b/include/linux/mfd/da903x.h new file mode 100644 index 000000000000..cad314c12439 --- /dev/null +++ b/include/linux/mfd/da903x.h | |||
@@ -0,0 +1,201 @@ | |||
1 | #ifndef __LINUX_PMIC_DA903X_H | ||
2 | #define __LINUX_PMIC_DA903X_H | ||
3 | |||
4 | /* Unified sub device IDs for DA9030/DA9034 */ | ||
5 | enum { | ||
6 | DA9030_ID_LED_1, | ||
7 | DA9030_ID_LED_2, | ||
8 | DA9030_ID_LED_3, | ||
9 | DA9030_ID_LED_4, | ||
10 | DA9030_ID_LED_PC, | ||
11 | DA9030_ID_VIBRA, | ||
12 | DA9030_ID_WLED, | ||
13 | DA9030_ID_BUCK1, | ||
14 | DA9030_ID_BUCK2, | ||
15 | DA9030_ID_LDO1, | ||
16 | DA9030_ID_LDO2, | ||
17 | DA9030_ID_LDO3, | ||
18 | DA9030_ID_LDO4, | ||
19 | DA9030_ID_LDO5, | ||
20 | DA9030_ID_LDO6, | ||
21 | DA9030_ID_LDO7, | ||
22 | DA9030_ID_LDO8, | ||
23 | DA9030_ID_LDO9, | ||
24 | DA9030_ID_LDO10, | ||
25 | DA9030_ID_LDO11, | ||
26 | DA9030_ID_LDO12, | ||
27 | DA9030_ID_LDO13, | ||
28 | DA9030_ID_LDO14, | ||
29 | DA9030_ID_LDO15, | ||
30 | DA9030_ID_LDO16, | ||
31 | DA9030_ID_LDO17, | ||
32 | DA9030_ID_LDO18, | ||
33 | DA9030_ID_LDO19, | ||
34 | DA9030_ID_LDO_INT, /* LDO Internal */ | ||
35 | |||
36 | DA9034_ID_LED_1, | ||
37 | DA9034_ID_LED_2, | ||
38 | DA9034_ID_VIBRA, | ||
39 | DA9034_ID_WLED, | ||
40 | DA9034_ID_TOUCH, | ||
41 | |||
42 | DA9034_ID_BUCK1, | ||
43 | DA9034_ID_BUCK2, | ||
44 | DA9034_ID_LDO1, | ||
45 | DA9034_ID_LDO2, | ||
46 | DA9034_ID_LDO3, | ||
47 | DA9034_ID_LDO4, | ||
48 | DA9034_ID_LDO5, | ||
49 | DA9034_ID_LDO6, | ||
50 | DA9034_ID_LDO7, | ||
51 | DA9034_ID_LDO8, | ||
52 | DA9034_ID_LDO9, | ||
53 | DA9034_ID_LDO10, | ||
54 | DA9034_ID_LDO11, | ||
55 | DA9034_ID_LDO12, | ||
56 | DA9034_ID_LDO13, | ||
57 | DA9034_ID_LDO14, | ||
58 | DA9034_ID_LDO15, | ||
59 | }; | ||
60 | |||
61 | /* | ||
62 | * DA9030/DA9034 LEDs sub-devices uses generic "struct led_info" | ||
63 | * as the platform_data | ||
64 | */ | ||
65 | |||
66 | /* DA9030 flags for "struct led_info" | ||
67 | */ | ||
68 | #define DA9030_LED_RATE_ON (0 << 5) | ||
69 | #define DA9030_LED_RATE_052S (1 << 5) | ||
70 | #define DA9030_LED_DUTY_1_16 (0 << 3) | ||
71 | #define DA9030_LED_DUTY_1_8 (1 << 3) | ||
72 | #define DA9030_LED_DUTY_1_4 (2 << 3) | ||
73 | #define DA9030_LED_DUTY_1_2 (3 << 3) | ||
74 | |||
75 | #define DA9030_VIBRA_MODE_1P3V (0 << 1) | ||
76 | #define DA9030_VIBRA_MODE_2P7V (1 << 1) | ||
77 | #define DA9030_VIBRA_FREQ_1HZ (0 << 2) | ||
78 | #define DA9030_VIBRA_FREQ_2HZ (1 << 2) | ||
79 | #define DA9030_VIBRA_FREQ_4HZ (2 << 2) | ||
80 | #define DA9030_VIBRA_FREQ_8HZ (3 << 2) | ||
81 | #define DA9030_VIBRA_DUTY_ON (0 << 4) | ||
82 | #define DA9030_VIBRA_DUTY_75P (1 << 4) | ||
83 | #define DA9030_VIBRA_DUTY_50P (2 << 4) | ||
84 | #define DA9030_VIBRA_DUTY_25P (3 << 4) | ||
85 | |||
86 | /* DA9034 flags for "struct led_info" */ | ||
87 | #define DA9034_LED_RAMP (1 << 7) | ||
88 | |||
89 | /* DA9034 touch screen platform data */ | ||
90 | struct da9034_touch_pdata { | ||
91 | int interval_ms; /* sampling interval while pen down */ | ||
92 | int x_inverted; | ||
93 | int y_inverted; | ||
94 | }; | ||
95 | |||
96 | struct da903x_subdev_info { | ||
97 | int id; | ||
98 | const char *name; | ||
99 | void *platform_data; | ||
100 | }; | ||
101 | |||
102 | struct da903x_platform_data { | ||
103 | int num_subdevs; | ||
104 | struct da903x_subdev_info *subdevs; | ||
105 | }; | ||
106 | |||
107 | /* bit definitions for DA9030 events */ | ||
108 | #define DA9030_EVENT_ONKEY (1 << 0) | ||
109 | #define DA9030_EVENT_PWREN (1 << 1) | ||
110 | #define DA9030_EVENT_EXTON (1 << 2) | ||
111 | #define DA9030_EVENT_CHDET (1 << 3) | ||
112 | #define DA9030_EVENT_TBAT (1 << 4) | ||
113 | #define DA9030_EVENT_VBATMON (1 << 5) | ||
114 | #define DA9030_EVENT_VBATMON_TXON (1 << 6) | ||
115 | #define DA9030_EVENT_CHIOVER (1 << 7) | ||
116 | #define DA9030_EVENT_TCTO (1 << 8) | ||
117 | #define DA9030_EVENT_CCTO (1 << 9) | ||
118 | #define DA9030_EVENT_ADC_READY (1 << 10) | ||
119 | #define DA9030_EVENT_VBUS_4P4 (1 << 11) | ||
120 | #define DA9030_EVENT_VBUS_4P0 (1 << 12) | ||
121 | #define DA9030_EVENT_SESS_VALID (1 << 13) | ||
122 | #define DA9030_EVENT_SRP_DETECT (1 << 14) | ||
123 | #define DA9030_EVENT_WATCHDOG (1 << 15) | ||
124 | #define DA9030_EVENT_LDO15 (1 << 16) | ||
125 | #define DA9030_EVENT_LDO16 (1 << 17) | ||
126 | #define DA9030_EVENT_LDO17 (1 << 18) | ||
127 | #define DA9030_EVENT_LDO18 (1 << 19) | ||
128 | #define DA9030_EVENT_LDO19 (1 << 20) | ||
129 | #define DA9030_EVENT_BUCK2 (1 << 21) | ||
130 | |||
131 | /* bit definitions for DA9034 events */ | ||
132 | #define DA9034_EVENT_ONKEY (1 << 0) | ||
133 | #define DA9034_EVENT_EXTON (1 << 2) | ||
134 | #define DA9034_EVENT_CHDET (1 << 3) | ||
135 | #define DA9034_EVENT_TBAT (1 << 4) | ||
136 | #define DA9034_EVENT_VBATMON (1 << 5) | ||
137 | #define DA9034_EVENT_REV_IOVER (1 << 6) | ||
138 | #define DA9034_EVENT_CH_IOVER (1 << 7) | ||
139 | #define DA9034_EVENT_CH_TCTO (1 << 8) | ||
140 | #define DA9034_EVENT_CH_CCTO (1 << 9) | ||
141 | #define DA9034_EVENT_USB_DEV (1 << 10) | ||
142 | #define DA9034_EVENT_OTGCP_IOVER (1 << 11) | ||
143 | #define DA9034_EVENT_VBUS_4P55 (1 << 12) | ||
144 | #define DA9034_EVENT_VBUS_3P8 (1 << 13) | ||
145 | #define DA9034_EVENT_SESS_1P8 (1 << 14) | ||
146 | #define DA9034_EVENT_SRP_READY (1 << 15) | ||
147 | #define DA9034_EVENT_ADC_MAN (1 << 16) | ||
148 | #define DA9034_EVENT_ADC_AUTO4 (1 << 17) | ||
149 | #define DA9034_EVENT_ADC_AUTO5 (1 << 18) | ||
150 | #define DA9034_EVENT_ADC_AUTO6 (1 << 19) | ||
151 | #define DA9034_EVENT_PEN_DOWN (1 << 20) | ||
152 | #define DA9034_EVENT_TSI_READY (1 << 21) | ||
153 | #define DA9034_EVENT_UART_TX (1 << 22) | ||
154 | #define DA9034_EVENT_UART_RX (1 << 23) | ||
155 | #define DA9034_EVENT_HEADSET (1 << 25) | ||
156 | #define DA9034_EVENT_HOOKSWITCH (1 << 26) | ||
157 | #define DA9034_EVENT_WATCHDOG (1 << 27) | ||
158 | |||
159 | extern int da903x_register_notifier(struct device *dev, | ||
160 | struct notifier_block *nb, unsigned int events); | ||
161 | extern int da903x_unregister_notifier(struct device *dev, | ||
162 | struct notifier_block *nb, unsigned int events); | ||
163 | |||
164 | /* Status Query Interface */ | ||
165 | #define DA9030_STATUS_ONKEY (1 << 0) | ||
166 | #define DA9030_STATUS_PWREN1 (1 << 1) | ||
167 | #define DA9030_STATUS_EXTON (1 << 2) | ||
168 | #define DA9030_STATUS_CHDET (1 << 3) | ||
169 | #define DA9030_STATUS_TBAT (1 << 4) | ||
170 | #define DA9030_STATUS_VBATMON (1 << 5) | ||
171 | #define DA9030_STATUS_VBATMON_TXON (1 << 6) | ||
172 | #define DA9030_STATUS_MCLKDET (1 << 7) | ||
173 | |||
174 | #define DA9034_STATUS_ONKEY (1 << 0) | ||
175 | #define DA9034_STATUS_EXTON (1 << 2) | ||
176 | #define DA9034_STATUS_CHDET (1 << 3) | ||
177 | #define DA9034_STATUS_TBAT (1 << 4) | ||
178 | #define DA9034_STATUS_VBATMON (1 << 5) | ||
179 | #define DA9034_STATUS_PEN_DOWN (1 << 6) | ||
180 | #define DA9034_STATUS_MCLKDET (1 << 7) | ||
181 | #define DA9034_STATUS_USB_DEV (1 << 8) | ||
182 | #define DA9034_STATUS_HEADSET (1 << 9) | ||
183 | #define DA9034_STATUS_HOOKSWITCH (1 << 10) | ||
184 | #define DA9034_STATUS_REMCON (1 << 11) | ||
185 | #define DA9034_STATUS_VBUS_VALID_4P55 (1 << 12) | ||
186 | #define DA9034_STATUS_VBUS_VALID_3P8 (1 << 13) | ||
187 | #define DA9034_STATUS_SESS_VALID_1P8 (1 << 14) | ||
188 | #define DA9034_STATUS_SRP_READY (1 << 15) | ||
189 | |||
190 | extern int da903x_query_status(struct device *dev, unsigned int status); | ||
191 | |||
192 | |||
193 | /* NOTE: the two functions below are not intended for use outside | ||
194 | * of the DA9034 sub-device drivers | ||
195 | */ | ||
196 | extern int da903x_write(struct device *dev, int reg, uint8_t val); | ||
197 | extern int da903x_read(struct device *dev, int reg, uint8_t *val); | ||
198 | extern int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask); | ||
199 | extern int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask); | ||
200 | extern int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask); | ||
201 | #endif /* __LINUX_PMIC_DA903X_H */ | ||
diff --git a/include/linux/mfd/t7l66xb.h b/include/linux/mfd/t7l66xb.h index e83c7f2036f9..b4629818aea5 100644 --- a/include/linux/mfd/t7l66xb.h +++ b/include/linux/mfd/t7l66xb.h | |||
@@ -15,8 +15,6 @@ | |||
15 | #include <linux/mfd/tmio.h> | 15 | #include <linux/mfd/tmio.h> |
16 | 16 | ||
17 | struct t7l66xb_platform_data { | 17 | struct t7l66xb_platform_data { |
18 | int (*enable_clk32k)(struct platform_device *dev); | ||
19 | void (*disable_clk32k)(struct platform_device *dev); | ||
20 | int (*enable)(struct platform_device *dev); | 18 | int (*enable)(struct platform_device *dev); |
21 | int (*disable)(struct platform_device *dev); | 19 | int (*disable)(struct platform_device *dev); |
22 | int (*suspend)(struct platform_device *dev); | 20 | int (*suspend)(struct platform_device *dev); |
diff --git a/include/linux/mfd/tc6387xb.h b/include/linux/mfd/tc6387xb.h index fa06e0610b8e..b4888209494a 100644 --- a/include/linux/mfd/tc6387xb.h +++ b/include/linux/mfd/tc6387xb.h | |||
@@ -11,9 +11,6 @@ | |||
11 | #define MFD_TC6387XB_H | 11 | #define MFD_TC6387XB_H |
12 | 12 | ||
13 | struct tc6387xb_platform_data { | 13 | struct tc6387xb_platform_data { |
14 | int (*enable_clk32k)(struct platform_device *dev); | ||
15 | void (*disable_clk32k)(struct platform_device *dev); | ||
16 | |||
17 | int (*enable)(struct platform_device *dev); | 14 | int (*enable)(struct platform_device *dev); |
18 | int (*disable)(struct platform_device *dev); | 15 | int (*disable)(struct platform_device *dev); |
19 | int (*suspend)(struct platform_device *dev); | 16 | int (*suspend)(struct platform_device *dev); |
diff --git a/include/linux/mfd/tc6393xb.h b/include/linux/mfd/tc6393xb.h index fec7b3f7a81f..626e448205c5 100644 --- a/include/linux/mfd/tc6393xb.h +++ b/include/linux/mfd/tc6393xb.h | |||
@@ -17,12 +17,12 @@ | |||
17 | #ifndef MFD_TC6393XB_H | 17 | #ifndef MFD_TC6393XB_H |
18 | #define MFD_TC6393XB_H | 18 | #define MFD_TC6393XB_H |
19 | 19 | ||
20 | #include <linux/fb.h> | ||
21 | |||
20 | /* Also one should provide the CK3P6MI clock */ | 22 | /* Also one should provide the CK3P6MI clock */ |
21 | struct tc6393xb_platform_data { | 23 | struct tc6393xb_platform_data { |
22 | u16 scr_pll2cr; /* PLL2 Control */ | 24 | u16 scr_pll2cr; /* PLL2 Control */ |
23 | u16 scr_gper; /* GP Enable */ | 25 | u16 scr_gper; /* GP Enable */ |
24 | u32 scr_gpo_doecr; /* GPO Data OE Control */ | ||
25 | u32 scr_gpo_dsr; /* GPO Data Set */ | ||
26 | 26 | ||
27 | int (*enable)(struct platform_device *dev); | 27 | int (*enable)(struct platform_device *dev); |
28 | int (*disable)(struct platform_device *dev); | 28 | int (*disable)(struct platform_device *dev); |
@@ -31,15 +31,28 @@ struct tc6393xb_platform_data { | |||
31 | 31 | ||
32 | int irq_base; /* base for subdevice irqs */ | 32 | int irq_base; /* base for subdevice irqs */ |
33 | int gpio_base; | 33 | int gpio_base; |
34 | int (*setup)(struct platform_device *dev); | ||
35 | void (*teardown)(struct platform_device *dev); | ||
34 | 36 | ||
35 | struct tmio_nand_data *nand_data; | 37 | struct tmio_nand_data *nand_data; |
38 | struct tmio_fb_data *fb_data; | ||
39 | |||
40 | unsigned resume_restore : 1; /* make special actions | ||
41 | to preserve the state | ||
42 | on suspend/resume */ | ||
36 | }; | 43 | }; |
37 | 44 | ||
45 | extern int tc6393xb_lcd_mode(struct platform_device *fb, | ||
46 | const struct fb_videomode *mode); | ||
47 | extern int tc6393xb_lcd_set_power(struct platform_device *fb, bool on); | ||
48 | |||
38 | /* | 49 | /* |
39 | * Relative to irq_base | 50 | * Relative to irq_base |
40 | */ | 51 | */ |
41 | #define IRQ_TC6393_NAND 0 | 52 | #define IRQ_TC6393_NAND 0 |
42 | #define IRQ_TC6393_MMC 1 | 53 | #define IRQ_TC6393_MMC 1 |
54 | #define IRQ_TC6393_OHCI 2 | ||
55 | #define IRQ_TC6393_FB 4 | ||
43 | 56 | ||
44 | #define TC6393XB_NR_IRQS 8 | 57 | #define TC6393XB_NR_IRQS 8 |
45 | 58 | ||
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h index ec612e66391c..516d955ab8a1 100644 --- a/include/linux/mfd/tmio.h +++ b/include/linux/mfd/tmio.h | |||
@@ -1,6 +1,8 @@ | |||
1 | #ifndef MFD_TMIO_H | 1 | #ifndef MFD_TMIO_H |
2 | #define MFD_TMIO_H | 2 | #define MFD_TMIO_H |
3 | 3 | ||
4 | #include <linux/fb.h> | ||
5 | |||
4 | #define tmio_ioread8(addr) readb(addr) | 6 | #define tmio_ioread8(addr) readb(addr) |
5 | #define tmio_ioread16(addr) readw(addr) | 7 | #define tmio_ioread16(addr) readw(addr) |
6 | #define tmio_ioread16_rep(r, b, l) readsw(r, b, l) | 8 | #define tmio_ioread16_rep(r, b, l) readsw(r, b, l) |
@@ -25,4 +27,21 @@ struct tmio_nand_data { | |||
25 | unsigned int num_partitions; | 27 | unsigned int num_partitions; |
26 | }; | 28 | }; |
27 | 29 | ||
30 | #define FBIO_TMIO_ACC_WRITE 0x7C639300 | ||
31 | #define FBIO_TMIO_ACC_SYNC 0x7C639301 | ||
32 | |||
33 | struct tmio_fb_data { | ||
34 | int (*lcd_set_power)(struct platform_device *fb_dev, | ||
35 | bool on); | ||
36 | int (*lcd_mode)(struct platform_device *fb_dev, | ||
37 | const struct fb_videomode *mode); | ||
38 | int num_modes; | ||
39 | struct fb_videomode *modes; | ||
40 | |||
41 | /* in mm: size of screen */ | ||
42 | int height; | ||
43 | int width; | ||
44 | }; | ||
45 | |||
46 | |||
28 | #endif | 47 | #endif |
diff --git a/include/linux/migrate.h b/include/linux/migrate.h index 03aea612d284..3f34005068d4 100644 --- a/include/linux/migrate.h +++ b/include/linux/migrate.h | |||
@@ -7,7 +7,6 @@ | |||
7 | typedef struct page *new_page_t(struct page *, unsigned long private, int **); | 7 | typedef struct page *new_page_t(struct page *, unsigned long private, int **); |
8 | 8 | ||
9 | #ifdef CONFIG_MIGRATION | 9 | #ifdef CONFIG_MIGRATION |
10 | extern int isolate_lru_page(struct page *p, struct list_head *pagelist); | ||
11 | extern int putback_lru_pages(struct list_head *l); | 10 | extern int putback_lru_pages(struct list_head *l); |
12 | extern int migrate_page(struct address_space *, | 11 | extern int migrate_page(struct address_space *, |
13 | struct page *, struct page *); | 12 | struct page *, struct page *); |
@@ -21,8 +20,6 @@ extern int migrate_vmas(struct mm_struct *mm, | |||
21 | const nodemask_t *from, const nodemask_t *to, | 20 | const nodemask_t *from, const nodemask_t *to, |
22 | unsigned long flags); | 21 | unsigned long flags); |
23 | #else | 22 | #else |
24 | static inline int isolate_lru_page(struct page *p, struct list_head *list) | ||
25 | { return -ENOSYS; } | ||
26 | static inline int putback_lru_pages(struct list_head *l) { return 0; } | 23 | static inline int putback_lru_pages(struct list_head *l) { return 0; } |
27 | static inline int migrate_pages(struct list_head *l, new_page_t x, | 24 | static inline int migrate_pages(struct list_head *l, new_page_t x, |
28 | unsigned long private) { return -ENOSYS; } | 25 | unsigned long private) { return -ENOSYS; } |
diff --git a/include/linux/mm.h b/include/linux/mm.h index c61ba10768ea..ffee2f743418 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h | |||
@@ -132,6 +132,11 @@ extern unsigned int kobjsize(const void *objp); | |||
132 | #define VM_RandomReadHint(v) ((v)->vm_flags & VM_RAND_READ) | 132 | #define VM_RandomReadHint(v) ((v)->vm_flags & VM_RAND_READ) |
133 | 133 | ||
134 | /* | 134 | /* |
135 | * special vmas that are non-mergable, non-mlock()able | ||
136 | */ | ||
137 | #define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_RESERVED | VM_PFNMAP) | ||
138 | |||
139 | /* | ||
135 | * mapping from the currently active vm_flags protection bits (the | 140 | * mapping from the currently active vm_flags protection bits (the |
136 | * low four bits) to a page protection mask.. | 141 | * low four bits) to a page protection mask.. |
137 | */ | 142 | */ |
@@ -700,10 +705,10 @@ static inline int page_mapped(struct page *page) | |||
700 | extern void show_free_areas(void); | 705 | extern void show_free_areas(void); |
701 | 706 | ||
702 | #ifdef CONFIG_SHMEM | 707 | #ifdef CONFIG_SHMEM |
703 | int shmem_lock(struct file *file, int lock, struct user_struct *user); | 708 | extern int shmem_lock(struct file *file, int lock, struct user_struct *user); |
704 | #else | 709 | #else |
705 | static inline int shmem_lock(struct file *file, int lock, | 710 | static inline int shmem_lock(struct file *file, int lock, |
706 | struct user_struct *user) | 711 | struct user_struct *user) |
707 | { | 712 | { |
708 | return 0; | 713 | return 0; |
709 | } | 714 | } |
diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h index 895bc4e93039..c948350c378e 100644 --- a/include/linux/mm_inline.h +++ b/include/linux/mm_inline.h | |||
@@ -1,40 +1,100 @@ | |||
1 | static inline void | 1 | #ifndef LINUX_MM_INLINE_H |
2 | add_page_to_active_list(struct zone *zone, struct page *page) | 2 | #define LINUX_MM_INLINE_H |
3 | { | ||
4 | list_add(&page->lru, &zone->active_list); | ||
5 | __inc_zone_state(zone, NR_ACTIVE); | ||
6 | } | ||
7 | 3 | ||
8 | static inline void | 4 | /** |
9 | add_page_to_inactive_list(struct zone *zone, struct page *page) | 5 | * page_is_file_cache - should the page be on a file LRU or anon LRU? |
6 | * @page: the page to test | ||
7 | * | ||
8 | * Returns LRU_FILE if @page is page cache page backed by a regular filesystem, | ||
9 | * or 0 if @page is anonymous, tmpfs or otherwise ram or swap backed. | ||
10 | * Used by functions that manipulate the LRU lists, to sort a page | ||
11 | * onto the right LRU list. | ||
12 | * | ||
13 | * We would like to get this info without a page flag, but the state | ||
14 | * needs to survive until the page is last deleted from the LRU, which | ||
15 | * could be as far down as __page_cache_release. | ||
16 | */ | ||
17 | static inline int page_is_file_cache(struct page *page) | ||
10 | { | 18 | { |
11 | list_add(&page->lru, &zone->inactive_list); | 19 | if (PageSwapBacked(page)) |
12 | __inc_zone_state(zone, NR_INACTIVE); | 20 | return 0; |
21 | |||
22 | /* The page is page cache backed by a normal filesystem. */ | ||
23 | return LRU_FILE; | ||
13 | } | 24 | } |
14 | 25 | ||
15 | static inline void | 26 | static inline void |
16 | del_page_from_active_list(struct zone *zone, struct page *page) | 27 | add_page_to_lru_list(struct zone *zone, struct page *page, enum lru_list l) |
17 | { | 28 | { |
18 | list_del(&page->lru); | 29 | list_add(&page->lru, &zone->lru[l].list); |
19 | __dec_zone_state(zone, NR_ACTIVE); | 30 | __inc_zone_state(zone, NR_LRU_BASE + l); |
20 | } | 31 | } |
21 | 32 | ||
22 | static inline void | 33 | static inline void |
23 | del_page_from_inactive_list(struct zone *zone, struct page *page) | 34 | del_page_from_lru_list(struct zone *zone, struct page *page, enum lru_list l) |
24 | { | 35 | { |
25 | list_del(&page->lru); | 36 | list_del(&page->lru); |
26 | __dec_zone_state(zone, NR_INACTIVE); | 37 | __dec_zone_state(zone, NR_LRU_BASE + l); |
27 | } | 38 | } |
28 | 39 | ||
29 | static inline void | 40 | static inline void |
30 | del_page_from_lru(struct zone *zone, struct page *page) | 41 | del_page_from_lru(struct zone *zone, struct page *page) |
31 | { | 42 | { |
43 | enum lru_list l = LRU_BASE; | ||
44 | |||
32 | list_del(&page->lru); | 45 | list_del(&page->lru); |
33 | if (PageActive(page)) { | 46 | if (PageUnevictable(page)) { |
34 | __ClearPageActive(page); | 47 | __ClearPageUnevictable(page); |
35 | __dec_zone_state(zone, NR_ACTIVE); | 48 | l = LRU_UNEVICTABLE; |
36 | } else { | 49 | } else { |
37 | __dec_zone_state(zone, NR_INACTIVE); | 50 | if (PageActive(page)) { |
51 | __ClearPageActive(page); | ||
52 | l += LRU_ACTIVE; | ||
53 | } | ||
54 | l += page_is_file_cache(page); | ||
55 | } | ||
56 | __dec_zone_state(zone, NR_LRU_BASE + l); | ||
57 | } | ||
58 | |||
59 | /** | ||
60 | * page_lru - which LRU list should a page be on? | ||
61 | * @page: the page to test | ||
62 | * | ||
63 | * Returns the LRU list a page should be on, as an index | ||
64 | * into the array of LRU lists. | ||
65 | */ | ||
66 | static inline enum lru_list page_lru(struct page *page) | ||
67 | { | ||
68 | enum lru_list lru = LRU_BASE; | ||
69 | |||
70 | if (PageUnevictable(page)) | ||
71 | lru = LRU_UNEVICTABLE; | ||
72 | else { | ||
73 | if (PageActive(page)) | ||
74 | lru += LRU_ACTIVE; | ||
75 | lru += page_is_file_cache(page); | ||
38 | } | 76 | } |
77 | |||
78 | return lru; | ||
39 | } | 79 | } |
40 | 80 | ||
81 | /** | ||
82 | * inactive_anon_is_low - check if anonymous pages need to be deactivated | ||
83 | * @zone: zone to check | ||
84 | * | ||
85 | * Returns true if the zone does not have enough inactive anon pages, | ||
86 | * meaning some active anon pages need to be deactivated. | ||
87 | */ | ||
88 | static inline int inactive_anon_is_low(struct zone *zone) | ||
89 | { | ||
90 | unsigned long active, inactive; | ||
91 | |||
92 | active = zone_page_state(zone, NR_ACTIVE_ANON); | ||
93 | inactive = zone_page_state(zone, NR_INACTIVE_ANON); | ||
94 | |||
95 | if (inactive * zone->inactive_ratio < active) | ||
96 | return 1; | ||
97 | |||
98 | return 0; | ||
99 | } | ||
100 | #endif | ||
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h index 9d49fa36bbef..fe825471d5aa 100644 --- a/include/linux/mm_types.h +++ b/include/linux/mm_types.h | |||
@@ -94,9 +94,6 @@ struct page { | |||
94 | void *virtual; /* Kernel virtual address (NULL if | 94 | void *virtual; /* Kernel virtual address (NULL if |
95 | not kmapped, ie. highmem) */ | 95 | not kmapped, ie. highmem) */ |
96 | #endif /* WANT_PAGE_VIRTUAL */ | 96 | #endif /* WANT_PAGE_VIRTUAL */ |
97 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR | ||
98 | unsigned long page_cgroup; | ||
99 | #endif | ||
100 | }; | 97 | }; |
101 | 98 | ||
102 | /* | 99 | /* |
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 428328a05fa1..35a7b5e19465 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h | |||
@@ -81,21 +81,31 @@ struct zone_padding { | |||
81 | enum zone_stat_item { | 81 | enum zone_stat_item { |
82 | /* First 128 byte cacheline (assuming 64 bit words) */ | 82 | /* First 128 byte cacheline (assuming 64 bit words) */ |
83 | NR_FREE_PAGES, | 83 | NR_FREE_PAGES, |
84 | NR_INACTIVE, | 84 | NR_LRU_BASE, |
85 | NR_ACTIVE, | 85 | NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */ |
86 | NR_ACTIVE_ANON, /* " " " " " */ | ||
87 | NR_INACTIVE_FILE, /* " " " " " */ | ||
88 | NR_ACTIVE_FILE, /* " " " " " */ | ||
89 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
90 | NR_UNEVICTABLE, /* " " " " " */ | ||
91 | NR_MLOCK, /* mlock()ed pages found and moved off LRU */ | ||
92 | #else | ||
93 | NR_UNEVICTABLE = NR_ACTIVE_FILE, /* avoid compiler errors in dead code */ | ||
94 | NR_MLOCK = NR_ACTIVE_FILE, | ||
95 | #endif | ||
86 | NR_ANON_PAGES, /* Mapped anonymous pages */ | 96 | NR_ANON_PAGES, /* Mapped anonymous pages */ |
87 | NR_FILE_MAPPED, /* pagecache pages mapped into pagetables. | 97 | NR_FILE_MAPPED, /* pagecache pages mapped into pagetables. |
88 | only modified from process context */ | 98 | only modified from process context */ |
89 | NR_FILE_PAGES, | 99 | NR_FILE_PAGES, |
90 | NR_FILE_DIRTY, | 100 | NR_FILE_DIRTY, |
91 | NR_WRITEBACK, | 101 | NR_WRITEBACK, |
92 | /* Second 128 byte cacheline */ | ||
93 | NR_SLAB_RECLAIMABLE, | 102 | NR_SLAB_RECLAIMABLE, |
94 | NR_SLAB_UNRECLAIMABLE, | 103 | NR_SLAB_UNRECLAIMABLE, |
95 | NR_PAGETABLE, /* used for pagetables */ | 104 | NR_PAGETABLE, /* used for pagetables */ |
96 | NR_UNSTABLE_NFS, /* NFS unstable pages */ | 105 | NR_UNSTABLE_NFS, /* NFS unstable pages */ |
97 | NR_BOUNCE, | 106 | NR_BOUNCE, |
98 | NR_VMSCAN_WRITE, | 107 | NR_VMSCAN_WRITE, |
108 | /* Second 128 byte cacheline */ | ||
99 | NR_WRITEBACK_TEMP, /* Writeback using temporary buffers */ | 109 | NR_WRITEBACK_TEMP, /* Writeback using temporary buffers */ |
100 | #ifdef CONFIG_NUMA | 110 | #ifdef CONFIG_NUMA |
101 | NUMA_HIT, /* allocated in intended node */ | 111 | NUMA_HIT, /* allocated in intended node */ |
@@ -107,6 +117,55 @@ enum zone_stat_item { | |||
107 | #endif | 117 | #endif |
108 | NR_VM_ZONE_STAT_ITEMS }; | 118 | NR_VM_ZONE_STAT_ITEMS }; |
109 | 119 | ||
120 | /* | ||
121 | * We do arithmetic on the LRU lists in various places in the code, | ||
122 | * so it is important to keep the active lists LRU_ACTIVE higher in | ||
123 | * the array than the corresponding inactive lists, and to keep | ||
124 | * the *_FILE lists LRU_FILE higher than the corresponding _ANON lists. | ||
125 | * | ||
126 | * This has to be kept in sync with the statistics in zone_stat_item | ||
127 | * above and the descriptions in vmstat_text in mm/vmstat.c | ||
128 | */ | ||
129 | #define LRU_BASE 0 | ||
130 | #define LRU_ACTIVE 1 | ||
131 | #define LRU_FILE 2 | ||
132 | |||
133 | enum lru_list { | ||
134 | LRU_INACTIVE_ANON = LRU_BASE, | ||
135 | LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE, | ||
136 | LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE, | ||
137 | LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE, | ||
138 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
139 | LRU_UNEVICTABLE, | ||
140 | #else | ||
141 | LRU_UNEVICTABLE = LRU_ACTIVE_FILE, /* avoid compiler errors in dead code */ | ||
142 | #endif | ||
143 | NR_LRU_LISTS | ||
144 | }; | ||
145 | |||
146 | #define for_each_lru(l) for (l = 0; l < NR_LRU_LISTS; l++) | ||
147 | |||
148 | #define for_each_evictable_lru(l) for (l = 0; l <= LRU_ACTIVE_FILE; l++) | ||
149 | |||
150 | static inline int is_file_lru(enum lru_list l) | ||
151 | { | ||
152 | return (l == LRU_INACTIVE_FILE || l == LRU_ACTIVE_FILE); | ||
153 | } | ||
154 | |||
155 | static inline int is_active_lru(enum lru_list l) | ||
156 | { | ||
157 | return (l == LRU_ACTIVE_ANON || l == LRU_ACTIVE_FILE); | ||
158 | } | ||
159 | |||
160 | static inline int is_unevictable_lru(enum lru_list l) | ||
161 | { | ||
162 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
163 | return (l == LRU_UNEVICTABLE); | ||
164 | #else | ||
165 | return 0; | ||
166 | #endif | ||
167 | } | ||
168 | |||
110 | struct per_cpu_pages { | 169 | struct per_cpu_pages { |
111 | int count; /* number of pages in the list */ | 170 | int count; /* number of pages in the list */ |
112 | int high; /* high watermark, emptying needed */ | 171 | int high; /* high watermark, emptying needed */ |
@@ -251,10 +310,22 @@ struct zone { | |||
251 | 310 | ||
252 | /* Fields commonly accessed by the page reclaim scanner */ | 311 | /* Fields commonly accessed by the page reclaim scanner */ |
253 | spinlock_t lru_lock; | 312 | spinlock_t lru_lock; |
254 | struct list_head active_list; | 313 | struct { |
255 | struct list_head inactive_list; | 314 | struct list_head list; |
256 | unsigned long nr_scan_active; | 315 | unsigned long nr_scan; |
257 | unsigned long nr_scan_inactive; | 316 | } lru[NR_LRU_LISTS]; |
317 | |||
318 | /* | ||
319 | * The pageout code in vmscan.c keeps track of how many of the | ||
320 | * mem/swap backed and file backed pages are refeferenced. | ||
321 | * The higher the rotated/scanned ratio, the more valuable | ||
322 | * that cache is. | ||
323 | * | ||
324 | * The anon LRU stats live in [0], file LRU stats in [1] | ||
325 | */ | ||
326 | unsigned long recent_rotated[2]; | ||
327 | unsigned long recent_scanned[2]; | ||
328 | |||
258 | unsigned long pages_scanned; /* since last reclaim */ | 329 | unsigned long pages_scanned; /* since last reclaim */ |
259 | unsigned long flags; /* zone flags, see below */ | 330 | unsigned long flags; /* zone flags, see below */ |
260 | 331 | ||
@@ -276,6 +347,12 @@ struct zone { | |||
276 | */ | 347 | */ |
277 | int prev_priority; | 348 | int prev_priority; |
278 | 349 | ||
350 | /* | ||
351 | * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on | ||
352 | * this zone's LRU. Maintained by the pageout code. | ||
353 | */ | ||
354 | unsigned int inactive_ratio; | ||
355 | |||
279 | 356 | ||
280 | ZONE_PADDING(_pad2_) | 357 | ZONE_PADDING(_pad2_) |
281 | /* Rarely used or read-mostly fields */ | 358 | /* Rarely used or read-mostly fields */ |
@@ -524,8 +601,11 @@ typedef struct pglist_data { | |||
524 | struct zone node_zones[MAX_NR_ZONES]; | 601 | struct zone node_zones[MAX_NR_ZONES]; |
525 | struct zonelist node_zonelists[MAX_ZONELISTS]; | 602 | struct zonelist node_zonelists[MAX_ZONELISTS]; |
526 | int nr_zones; | 603 | int nr_zones; |
527 | #ifdef CONFIG_FLAT_NODE_MEM_MAP | 604 | #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */ |
528 | struct page *node_mem_map; | 605 | struct page *node_mem_map; |
606 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR | ||
607 | struct page_cgroup *node_page_cgroup; | ||
608 | #endif | ||
529 | #endif | 609 | #endif |
530 | struct bootmem_data *bdata; | 610 | struct bootmem_data *bdata; |
531 | #ifdef CONFIG_MEMORY_HOTPLUG | 611 | #ifdef CONFIG_MEMORY_HOTPLUG |
@@ -854,6 +934,7 @@ static inline unsigned long early_pfn_to_nid(unsigned long pfn) | |||
854 | #endif | 934 | #endif |
855 | 935 | ||
856 | struct page; | 936 | struct page; |
937 | struct page_cgroup; | ||
857 | struct mem_section { | 938 | struct mem_section { |
858 | /* | 939 | /* |
859 | * This is, logically, a pointer to an array of struct | 940 | * This is, logically, a pointer to an array of struct |
@@ -871,6 +952,14 @@ struct mem_section { | |||
871 | 952 | ||
872 | /* See declaration of similar field in struct zone */ | 953 | /* See declaration of similar field in struct zone */ |
873 | unsigned long *pageblock_flags; | 954 | unsigned long *pageblock_flags; |
955 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR | ||
956 | /* | ||
957 | * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use | ||
958 | * section. (see memcontrol.h/page_cgroup.h about this.) | ||
959 | */ | ||
960 | struct page_cgroup *page_cgroup; | ||
961 | unsigned long pad; | ||
962 | #endif | ||
874 | }; | 963 | }; |
875 | 964 | ||
876 | #ifdef CONFIG_SPARSEMEM_EXTREME | 965 | #ifdef CONFIG_SPARSEMEM_EXTREME |
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h index d6a3f47e95cb..eb71b45fdf5a 100644 --- a/include/linux/mod_devicetable.h +++ b/include/linux/mod_devicetable.h | |||
@@ -284,7 +284,7 @@ struct pcmcia_device_id { | |||
284 | /* Input */ | 284 | /* Input */ |
285 | #define INPUT_DEVICE_ID_EV_MAX 0x1f | 285 | #define INPUT_DEVICE_ID_EV_MAX 0x1f |
286 | #define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71 | 286 | #define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71 |
287 | #define INPUT_DEVICE_ID_KEY_MAX 0x1ff | 287 | #define INPUT_DEVICE_ID_KEY_MAX 0x2ff |
288 | #define INPUT_DEVICE_ID_REL_MAX 0x0f | 288 | #define INPUT_DEVICE_ID_REL_MAX 0x0f |
289 | #define INPUT_DEVICE_ID_ABS_MAX 0x3f | 289 | #define INPUT_DEVICE_ID_ABS_MAX 0x3f |
290 | #define INPUT_DEVICE_ID_MSC_MAX 0x07 | 290 | #define INPUT_DEVICE_ID_MSC_MAX 0x07 |
diff --git a/include/linux/module.h b/include/linux/module.h index 68e09557c951..a41555cbe00a 100644 --- a/include/linux/module.h +++ b/include/linux/module.h | |||
@@ -345,7 +345,6 @@ struct module | |||
345 | /* Reference counts */ | 345 | /* Reference counts */ |
346 | struct module_ref ref[NR_CPUS]; | 346 | struct module_ref ref[NR_CPUS]; |
347 | #endif | 347 | #endif |
348 | |||
349 | }; | 348 | }; |
350 | #ifndef MODULE_ARCH_INIT | 349 | #ifndef MODULE_ARCH_INIT |
351 | #define MODULE_ARCH_INIT {} | 350 | #define MODULE_ARCH_INIT {} |
diff --git a/include/linux/mount.h b/include/linux/mount.h index 30a1d63b6fb5..cab2a85e2ee8 100644 --- a/include/linux/mount.h +++ b/include/linux/mount.h | |||
@@ -5,8 +5,6 @@ | |||
5 | * | 5 | * |
6 | * Author: Marco van Wieringen <mvw@planets.elm.net> | 6 | * Author: Marco van Wieringen <mvw@planets.elm.net> |
7 | * | 7 | * |
8 | * Version: $Id: mount.h,v 2.0 1996/11/17 16:48:14 mvw Exp mvw $ | ||
9 | * | ||
10 | */ | 8 | */ |
11 | #ifndef _LINUX_MOUNT_H | 9 | #ifndef _LINUX_MOUNT_H |
12 | #define _LINUX_MOUNT_H | 10 | #define _LINUX_MOUNT_H |
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h index d6fb115f5a07..ee5124ec319e 100644 --- a/include/linux/mtd/cfi.h +++ b/include/linux/mtd/cfi.h | |||
@@ -12,6 +12,7 @@ | |||
12 | #include <linux/mtd/flashchip.h> | 12 | #include <linux/mtd/flashchip.h> |
13 | #include <linux/mtd/map.h> | 13 | #include <linux/mtd/map.h> |
14 | #include <linux/mtd/cfi_endian.h> | 14 | #include <linux/mtd/cfi_endian.h> |
15 | #include <linux/mtd/xip.h> | ||
15 | 16 | ||
16 | #ifdef CONFIG_MTD_CFI_I1 | 17 | #ifdef CONFIG_MTD_CFI_I1 |
17 | #define cfi_interleave(cfi) 1 | 18 | #define cfi_interleave(cfi) 1 |
@@ -430,7 +431,6 @@ static inline uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t | |||
430 | { | 431 | { |
431 | map_word val; | 432 | map_word val; |
432 | uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, cfi_interleave(cfi), type); | 433 | uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, cfi_interleave(cfi), type); |
433 | |||
434 | val = cfi_build_cmd(cmd, map, cfi); | 434 | val = cfi_build_cmd(cmd, map, cfi); |
435 | 435 | ||
436 | if (prev_val) | 436 | if (prev_val) |
@@ -483,6 +483,13 @@ static inline void cfi_udelay(int us) | |||
483 | } | 483 | } |
484 | } | 484 | } |
485 | 485 | ||
486 | int __xipram cfi_qry_present(struct map_info *map, __u32 base, | ||
487 | struct cfi_private *cfi); | ||
488 | int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map, | ||
489 | struct cfi_private *cfi); | ||
490 | void __xipram cfi_qry_mode_off(uint32_t base, struct map_info *map, | ||
491 | struct cfi_private *cfi); | ||
492 | |||
486 | struct cfi_extquery *cfi_read_pri(struct map_info *map, uint16_t adr, uint16_t size, | 493 | struct cfi_extquery *cfi_read_pri(struct map_info *map, uint16_t adr, uint16_t size, |
487 | const char* name); | 494 | const char* name); |
488 | struct cfi_fixup { | 495 | struct cfi_fixup { |
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h index 08dd131301c1..d4f38c5fd44e 100644 --- a/include/linux/mtd/flashchip.h +++ b/include/linux/mtd/flashchip.h | |||
@@ -73,6 +73,10 @@ struct flchip { | |||
73 | int buffer_write_time; | 73 | int buffer_write_time; |
74 | int erase_time; | 74 | int erase_time; |
75 | 75 | ||
76 | int word_write_time_max; | ||
77 | int buffer_write_time_max; | ||
78 | int erase_time_max; | ||
79 | |||
76 | void *priv; | 80 | void *priv; |
77 | }; | 81 | }; |
78 | 82 | ||
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h index 922636548558..eae26bb6430a 100644 --- a/include/linux/mtd/mtd.h +++ b/include/linux/mtd/mtd.h | |||
@@ -25,8 +25,10 @@ | |||
25 | #define MTD_ERASE_DONE 0x08 | 25 | #define MTD_ERASE_DONE 0x08 |
26 | #define MTD_ERASE_FAILED 0x10 | 26 | #define MTD_ERASE_FAILED 0x10 |
27 | 27 | ||
28 | #define MTD_FAIL_ADDR_UNKNOWN 0xffffffff | ||
29 | |||
28 | /* If the erase fails, fail_addr might indicate exactly which block failed. If | 30 | /* If the erase fails, fail_addr might indicate exactly which block failed. If |
29 | fail_addr = 0xffffffff, the failure was not at the device level or was not | 31 | fail_addr = MTD_FAIL_ADDR_UNKNOWN, the failure was not at the device level or was not |
30 | specific to any particular block. */ | 32 | specific to any particular block. */ |
31 | struct erase_info { | 33 | struct erase_info { |
32 | struct mtd_info *mtd; | 34 | struct mtd_info *mtd; |
diff --git a/include/linux/mtd/nand-gpio.h b/include/linux/mtd/nand-gpio.h new file mode 100644 index 000000000000..51534e50f7fc --- /dev/null +++ b/include/linux/mtd/nand-gpio.h | |||
@@ -0,0 +1,19 @@ | |||
1 | #ifndef __LINUX_MTD_NAND_GPIO_H | ||
2 | #define __LINUX_MTD_NAND_GPIO_H | ||
3 | |||
4 | #include <linux/mtd/nand.h> | ||
5 | |||
6 | struct gpio_nand_platdata { | ||
7 | int gpio_nce; | ||
8 | int gpio_nwp; | ||
9 | int gpio_cle; | ||
10 | int gpio_ale; | ||
11 | int gpio_rdy; | ||
12 | void (*adjust_parts)(struct gpio_nand_platdata *, size_t); | ||
13 | struct mtd_partition *parts; | ||
14 | unsigned int num_parts; | ||
15 | unsigned int options; | ||
16 | int chip_delay; | ||
17 | }; | ||
18 | |||
19 | #endif | ||
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h index 81774e5facf4..733d3f3b4eb8 100644 --- a/include/linux/mtd/nand.h +++ b/include/linux/mtd/nand.h | |||
@@ -248,6 +248,7 @@ struct nand_hw_control { | |||
248 | * @read_page_raw: function to read a raw page without ECC | 248 | * @read_page_raw: function to read a raw page without ECC |
249 | * @write_page_raw: function to write a raw page without ECC | 249 | * @write_page_raw: function to write a raw page without ECC |
250 | * @read_page: function to read a page according to the ecc generator requirements | 250 | * @read_page: function to read a page according to the ecc generator requirements |
251 | * @read_subpage: function to read parts of the page covered by ECC. | ||
251 | * @write_page: function to write a page according to the ecc generator requirements | 252 | * @write_page: function to write a page according to the ecc generator requirements |
252 | * @read_oob: function to read chip OOB data | 253 | * @read_oob: function to read chip OOB data |
253 | * @write_oob: function to write chip OOB data | 254 | * @write_oob: function to write chip OOB data |
diff --git a/include/linux/mtd/onenand_regs.h b/include/linux/mtd/onenand_regs.h index d1b310c92eb4..0c6bbe28f38c 100644 --- a/include/linux/mtd/onenand_regs.h +++ b/include/linux/mtd/onenand_regs.h | |||
@@ -152,6 +152,8 @@ | |||
152 | #define ONENAND_SYS_CFG1_INT (1 << 6) | 152 | #define ONENAND_SYS_CFG1_INT (1 << 6) |
153 | #define ONENAND_SYS_CFG1_IOBE (1 << 5) | 153 | #define ONENAND_SYS_CFG1_IOBE (1 << 5) |
154 | #define ONENAND_SYS_CFG1_RDY_CONF (1 << 4) | 154 | #define ONENAND_SYS_CFG1_RDY_CONF (1 << 4) |
155 | #define ONENAND_SYS_CFG1_HF (1 << 2) | ||
156 | #define ONENAND_SYS_CFG1_SYNC_WRITE (1 << 1) | ||
155 | 157 | ||
156 | /* | 158 | /* |
157 | * Controller Status Register F240h (R) | 159 | * Controller Status Register F240h (R) |
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h index 5014f7a9f5df..c92b4d439609 100644 --- a/include/linux/mtd/partitions.h +++ b/include/linux/mtd/partitions.h | |||
@@ -73,7 +73,6 @@ struct device; | |||
73 | struct device_node; | 73 | struct device_node; |
74 | 74 | ||
75 | int __devinit of_mtd_parse_partitions(struct device *dev, | 75 | int __devinit of_mtd_parse_partitions(struct device *dev, |
76 | struct mtd_info *mtd, | ||
77 | struct device_node *node, | 76 | struct device_node *node, |
78 | struct mtd_partition **pparts); | 77 | struct mtd_partition **pparts); |
79 | 78 | ||
diff --git a/include/linux/mtd/sh_flctl.h b/include/linux/mtd/sh_flctl.h new file mode 100644 index 000000000000..e77c1cea404d --- /dev/null +++ b/include/linux/mtd/sh_flctl.h | |||
@@ -0,0 +1,125 @@ | |||
1 | /* | ||
2 | * SuperH FLCTL nand controller | ||
3 | * | ||
4 | * Copyright © 2008 Renesas Solutions Corp. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License as published by | ||
8 | * the Free Software Foundation; version 2 of the License. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this program; if not, write to the Free Software | ||
17 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | */ | ||
19 | |||
20 | #ifndef __SH_FLCTL_H__ | ||
21 | #define __SH_FLCTL_H__ | ||
22 | |||
23 | #include <linux/mtd/mtd.h> | ||
24 | #include <linux/mtd/nand.h> | ||
25 | #include <linux/mtd/partitions.h> | ||
26 | |||
27 | /* FLCTL registers */ | ||
28 | #define FLCMNCR(f) (f->reg + 0x0) | ||
29 | #define FLCMDCR(f) (f->reg + 0x4) | ||
30 | #define FLCMCDR(f) (f->reg + 0x8) | ||
31 | #define FLADR(f) (f->reg + 0xC) | ||
32 | #define FLADR2(f) (f->reg + 0x3C) | ||
33 | #define FLDATAR(f) (f->reg + 0x10) | ||
34 | #define FLDTCNTR(f) (f->reg + 0x14) | ||
35 | #define FLINTDMACR(f) (f->reg + 0x18) | ||
36 | #define FLBSYTMR(f) (f->reg + 0x1C) | ||
37 | #define FLBSYCNT(f) (f->reg + 0x20) | ||
38 | #define FLDTFIFO(f) (f->reg + 0x24) | ||
39 | #define FLECFIFO(f) (f->reg + 0x28) | ||
40 | #define FLTRCR(f) (f->reg + 0x2C) | ||
41 | #define FL4ECCRESULT0(f) (f->reg + 0x80) | ||
42 | #define FL4ECCRESULT1(f) (f->reg + 0x84) | ||
43 | #define FL4ECCRESULT2(f) (f->reg + 0x88) | ||
44 | #define FL4ECCRESULT3(f) (f->reg + 0x8C) | ||
45 | #define FL4ECCCR(f) (f->reg + 0x90) | ||
46 | #define FL4ECCCNT(f) (f->reg + 0x94) | ||
47 | #define FLERRADR(f) (f->reg + 0x98) | ||
48 | |||
49 | /* FLCMNCR control bits */ | ||
50 | #define ECCPOS2 (0x1 << 25) | ||
51 | #define _4ECCCNTEN (0x1 << 24) | ||
52 | #define _4ECCEN (0x1 << 23) | ||
53 | #define _4ECCCORRECT (0x1 << 22) | ||
54 | #define SNAND_E (0x1 << 18) /* SNAND (0=512 1=2048)*/ | ||
55 | #define QTSEL_E (0x1 << 17) | ||
56 | #define ENDIAN (0x1 << 16) /* 1 = little endian */ | ||
57 | #define FCKSEL_E (0x1 << 15) | ||
58 | #define ECCPOS_00 (0x00 << 12) | ||
59 | #define ECCPOS_01 (0x01 << 12) | ||
60 | #define ECCPOS_02 (0x02 << 12) | ||
61 | #define ACM_SACCES_MODE (0x01 << 10) | ||
62 | #define NANWF_E (0x1 << 9) | ||
63 | #define SE_D (0x1 << 8) /* Spare area disable */ | ||
64 | #define CE1_ENABLE (0x1 << 4) /* Chip Enable 1 */ | ||
65 | #define CE0_ENABLE (0x1 << 3) /* Chip Enable 0 */ | ||
66 | #define TYPESEL_SET (0x1 << 0) | ||
67 | |||
68 | /* FLCMDCR control bits */ | ||
69 | #define ADRCNT2_E (0x1 << 31) /* 5byte address enable */ | ||
70 | #define ADRMD_E (0x1 << 26) /* Sector address access */ | ||
71 | #define CDSRC_E (0x1 << 25) /* Data buffer selection */ | ||
72 | #define DOSR_E (0x1 << 24) /* Status read check */ | ||
73 | #define SELRW (0x1 << 21) /* 0:read 1:write */ | ||
74 | #define DOADR_E (0x1 << 20) /* Address stage execute */ | ||
75 | #define ADRCNT_1 (0x00 << 18) /* Address data bytes: 1byte */ | ||
76 | #define ADRCNT_2 (0x01 << 18) /* Address data bytes: 2byte */ | ||
77 | #define ADRCNT_3 (0x02 << 18) /* Address data bytes: 3byte */ | ||
78 | #define ADRCNT_4 (0x03 << 18) /* Address data bytes: 4byte */ | ||
79 | #define DOCMD2_E (0x1 << 17) /* 2nd cmd stage execute */ | ||
80 | #define DOCMD1_E (0x1 << 16) /* 1st cmd stage execute */ | ||
81 | |||
82 | /* FLTRCR control bits */ | ||
83 | #define TRSTRT (0x1 << 0) /* translation start */ | ||
84 | #define TREND (0x1 << 1) /* translation end */ | ||
85 | |||
86 | /* FL4ECCCR control bits */ | ||
87 | #define _4ECCFA (0x1 << 2) /* 4 symbols correct fault */ | ||
88 | #define _4ECCEND (0x1 << 1) /* 4 symbols end */ | ||
89 | #define _4ECCEXST (0x1 << 0) /* 4 symbols exist */ | ||
90 | |||
91 | #define INIT_FL4ECCRESULT_VAL 0x03FF03FF | ||
92 | #define LOOP_TIMEOUT_MAX 0x00010000 | ||
93 | |||
94 | #define mtd_to_flctl(mtd) container_of(mtd, struct sh_flctl, mtd) | ||
95 | |||
96 | struct sh_flctl { | ||
97 | struct mtd_info mtd; | ||
98 | struct nand_chip chip; | ||
99 | void __iomem *reg; | ||
100 | |||
101 | uint8_t done_buff[2048 + 64]; /* max size 2048 + 64 */ | ||
102 | int read_bytes; | ||
103 | int index; | ||
104 | int seqin_column; /* column in SEQIN cmd */ | ||
105 | int seqin_page_addr; /* page_addr in SEQIN cmd */ | ||
106 | uint32_t seqin_read_cmd; /* read cmd in SEQIN cmd */ | ||
107 | int erase1_page_addr; /* page_addr in ERASE1 cmd */ | ||
108 | uint32_t erase_ADRCNT; /* bits of FLCMDCR in ERASE1 cmd */ | ||
109 | uint32_t rw_ADRCNT; /* bits of FLCMDCR in READ WRITE cmd */ | ||
110 | |||
111 | int hwecc_cant_correct[4]; | ||
112 | |||
113 | unsigned page_size:1; /* NAND page size (0 = 512, 1 = 2048) */ | ||
114 | unsigned hwecc:1; /* Hardware ECC (0 = disabled, 1 = enabled) */ | ||
115 | }; | ||
116 | |||
117 | struct sh_flctl_platform_data { | ||
118 | struct mtd_partition *parts; | ||
119 | int nr_parts; | ||
120 | unsigned long flcmncr_val; | ||
121 | |||
122 | unsigned has_hwecc:1; | ||
123 | }; | ||
124 | |||
125 | #endif /* __SH_FLCTL_H__ */ | ||
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h index 0d8424f76899..7d8e0455ccac 100644 --- a/include/linux/netfilter/nfnetlink.h +++ b/include/linux/netfilter/nfnetlink.h | |||
@@ -78,6 +78,9 @@ extern int nfnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, | |||
78 | int echo); | 78 | int echo); |
79 | extern int nfnetlink_unicast(struct sk_buff *skb, u_int32_t pid, int flags); | 79 | extern int nfnetlink_unicast(struct sk_buff *skb, u_int32_t pid, int flags); |
80 | 80 | ||
81 | extern void nfnl_lock(void); | ||
82 | extern void nfnl_unlock(void); | ||
83 | |||
81 | #define MODULE_ALIAS_NFNL_SUBSYS(subsys) \ | 84 | #define MODULE_ALIAS_NFNL_SUBSYS(subsys) \ |
82 | MODULE_ALIAS("nfnetlink-subsys-" __stringify(subsys)) | 85 | MODULE_ALIAS("nfnetlink-subsys-" __stringify(subsys)) |
83 | 86 | ||
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h index 78a5922a2f11..4eaa8347a0d9 100644 --- a/include/linux/nfs_fs.h +++ b/include/linux/nfs_fs.h | |||
@@ -137,7 +137,7 @@ struct nfs_inode { | |||
137 | unsigned long attrtimeo_timestamp; | 137 | unsigned long attrtimeo_timestamp; |
138 | __u64 change_attr; /* v4 only */ | 138 | __u64 change_attr; /* v4 only */ |
139 | 139 | ||
140 | unsigned long last_updated; | 140 | unsigned long attr_gencount; |
141 | /* "Generation counter" for the attribute cache. This is | 141 | /* "Generation counter" for the attribute cache. This is |
142 | * bumped whenever we update the metadata on the | 142 | * bumped whenever we update the metadata on the |
143 | * server. | 143 | * server. |
@@ -200,11 +200,10 @@ struct nfs_inode { | |||
200 | /* | 200 | /* |
201 | * Bit offsets in flags field | 201 | * Bit offsets in flags field |
202 | */ | 202 | */ |
203 | #define NFS_INO_REVALIDATING (0) /* revalidating attrs */ | 203 | #define NFS_INO_ADVISE_RDPLUS (0) /* advise readdirplus */ |
204 | #define NFS_INO_ADVISE_RDPLUS (1) /* advise readdirplus */ | 204 | #define NFS_INO_STALE (1) /* possible stale inode */ |
205 | #define NFS_INO_STALE (2) /* possible stale inode */ | 205 | #define NFS_INO_ACL_LRU_SET (2) /* Inode is on the LRU list */ |
206 | #define NFS_INO_ACL_LRU_SET (3) /* Inode is on the LRU list */ | 206 | #define NFS_INO_MOUNTPOINT (3) /* inode is remote mountpoint */ |
207 | #define NFS_INO_MOUNTPOINT (4) /* inode is remote mountpoint */ | ||
208 | 207 | ||
209 | static inline struct nfs_inode *NFS_I(const struct inode *inode) | 208 | static inline struct nfs_inode *NFS_I(const struct inode *inode) |
210 | { | 209 | { |
@@ -345,15 +344,11 @@ extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ct | |||
345 | extern void put_nfs_open_context(struct nfs_open_context *ctx); | 344 | extern void put_nfs_open_context(struct nfs_open_context *ctx); |
346 | extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode); | 345 | extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode); |
347 | extern u64 nfs_compat_user_ino64(u64 fileid); | 346 | extern u64 nfs_compat_user_ino64(u64 fileid); |
347 | extern void nfs_fattr_init(struct nfs_fattr *fattr); | ||
348 | 348 | ||
349 | /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */ | 349 | /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */ |
350 | extern __be32 root_nfs_parse_addr(char *name); /*__init*/ | 350 | extern __be32 root_nfs_parse_addr(char *name); /*__init*/ |
351 | 351 | extern unsigned long nfs_inc_attr_generation_counter(void); | |
352 | static inline void nfs_fattr_init(struct nfs_fattr *fattr) | ||
353 | { | ||
354 | fattr->valid = 0; | ||
355 | fattr->time_start = jiffies; | ||
356 | } | ||
357 | 352 | ||
358 | /* | 353 | /* |
359 | * linux/fs/nfs/file.c | 354 | * linux/fs/nfs/file.c |
@@ -372,8 +367,12 @@ static inline struct nfs_open_context *nfs_file_open_context(struct file *filp) | |||
372 | 367 | ||
373 | static inline struct rpc_cred *nfs_file_cred(struct file *file) | 368 | static inline struct rpc_cred *nfs_file_cred(struct file *file) |
374 | { | 369 | { |
375 | if (file != NULL) | 370 | if (file != NULL) { |
376 | return nfs_file_open_context(file)->cred; | 371 | struct nfs_open_context *ctx = |
372 | nfs_file_open_context(file); | ||
373 | if (ctx) | ||
374 | return ctx->cred; | ||
375 | } | ||
377 | return NULL; | 376 | return NULL; |
378 | } | 377 | } |
379 | 378 | ||
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h index c9beacd16c00..4e477ae58699 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h | |||
@@ -119,7 +119,6 @@ struct nfs_server { | |||
119 | void (*destroy)(struct nfs_server *); | 119 | void (*destroy)(struct nfs_server *); |
120 | 120 | ||
121 | atomic_t active; /* Keep trace of any activity to this server */ | 121 | atomic_t active; /* Keep trace of any activity to this server */ |
122 | wait_queue_head_t active_wq; /* Wait for any activity to stop */ | ||
123 | 122 | ||
124 | /* mountd-related mount options */ | 123 | /* mountd-related mount options */ |
125 | struct sockaddr_storage mountd_address; | 124 | struct sockaddr_storage mountd_address; |
diff --git a/include/linux/nfs_mount.h b/include/linux/nfs_mount.h index df7c6b7a7ebb..6549a06ac16e 100644 --- a/include/linux/nfs_mount.h +++ b/include/linux/nfs_mount.h | |||
@@ -65,4 +65,8 @@ struct nfs_mount_data { | |||
65 | #define NFS_MOUNT_UNSHARED 0x8000 /* 5 */ | 65 | #define NFS_MOUNT_UNSHARED 0x8000 /* 5 */ |
66 | #define NFS_MOUNT_FLAGMASK 0xFFFF | 66 | #define NFS_MOUNT_FLAGMASK 0xFFFF |
67 | 67 | ||
68 | /* The following are for internal use only */ | ||
69 | #define NFS_MOUNT_LOOKUP_CACHE_NONEG 0x10000 | ||
70 | #define NFS_MOUNT_LOOKUP_CACHE_NONE 0x20000 | ||
71 | |||
68 | #endif | 72 | #endif |
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h index 8c77c11224d1..c1c31acb8a2b 100644 --- a/include/linux/nfs_xdr.h +++ b/include/linux/nfs_xdr.h | |||
@@ -36,6 +36,7 @@ struct nfs_fattr { | |||
36 | __u32 nlink; | 36 | __u32 nlink; |
37 | __u32 uid; | 37 | __u32 uid; |
38 | __u32 gid; | 38 | __u32 gid; |
39 | dev_t rdev; | ||
39 | __u64 size; | 40 | __u64 size; |
40 | union { | 41 | union { |
41 | struct { | 42 | struct { |
@@ -46,7 +47,6 @@ struct nfs_fattr { | |||
46 | __u64 used; | 47 | __u64 used; |
47 | } nfs3; | 48 | } nfs3; |
48 | } du; | 49 | } du; |
49 | dev_t rdev; | ||
50 | struct nfs_fsid fsid; | 50 | struct nfs_fsid fsid; |
51 | __u64 fileid; | 51 | __u64 fileid; |
52 | struct timespec atime; | 52 | struct timespec atime; |
@@ -56,6 +56,7 @@ struct nfs_fattr { | |||
56 | __u64 change_attr; /* NFSv4 change attribute */ | 56 | __u64 change_attr; /* NFSv4 change attribute */ |
57 | __u64 pre_change_attr;/* pre-op NFSv4 change attribute */ | 57 | __u64 pre_change_attr;/* pre-op NFSv4 change attribute */ |
58 | unsigned long time_start; | 58 | unsigned long time_start; |
59 | unsigned long gencount; | ||
59 | }; | 60 | }; |
60 | 61 | ||
61 | #define NFS_ATTR_WCC 0x0001 /* pre-op WCC data */ | 62 | #define NFS_ATTR_WCC 0x0001 /* pre-op WCC data */ |
@@ -672,16 +673,16 @@ struct nfs4_rename_res { | |||
672 | struct nfs_fattr * new_fattr; | 673 | struct nfs_fattr * new_fattr; |
673 | }; | 674 | }; |
674 | 675 | ||
675 | #define NFS4_SETCLIENTID_NAMELEN (56) | 676 | #define NFS4_SETCLIENTID_NAMELEN (127) |
676 | struct nfs4_setclientid { | 677 | struct nfs4_setclientid { |
677 | const nfs4_verifier * sc_verifier; | 678 | const nfs4_verifier * sc_verifier; |
678 | unsigned int sc_name_len; | 679 | unsigned int sc_name_len; |
679 | char sc_name[NFS4_SETCLIENTID_NAMELEN]; | 680 | char sc_name[NFS4_SETCLIENTID_NAMELEN + 1]; |
680 | u32 sc_prog; | 681 | u32 sc_prog; |
681 | unsigned int sc_netid_len; | 682 | unsigned int sc_netid_len; |
682 | char sc_netid[RPCBIND_MAXNETIDLEN]; | 683 | char sc_netid[RPCBIND_MAXNETIDLEN + 1]; |
683 | unsigned int sc_uaddr_len; | 684 | unsigned int sc_uaddr_len; |
684 | char sc_uaddr[RPCBIND_MAXUADDRLEN]; | 685 | char sc_uaddr[RPCBIND_MAXUADDRLEN + 1]; |
685 | u32 sc_cb_ident; | 686 | u32 sc_cb_ident; |
686 | }; | 687 | }; |
687 | 688 | ||
diff --git a/include/linux/of.h b/include/linux/of.h index 79886ade070f..e2488f5e7cb2 100644 --- a/include/linux/of.h +++ b/include/linux/of.h | |||
@@ -71,5 +71,8 @@ extern int of_n_size_cells(struct device_node *np); | |||
71 | extern const struct of_device_id *of_match_node( | 71 | extern const struct of_device_id *of_match_node( |
72 | const struct of_device_id *matches, const struct device_node *node); | 72 | const struct of_device_id *matches, const struct device_node *node); |
73 | extern int of_modalias_node(struct device_node *node, char *modalias, int len); | 73 | extern int of_modalias_node(struct device_node *node, char *modalias, int len); |
74 | extern int of_parse_phandles_with_args(struct device_node *np, | ||
75 | const char *list_name, const char *cells_name, int index, | ||
76 | struct device_node **out_node, const void **out_args); | ||
74 | 77 | ||
75 | #endif /* _LINUX_OF_H */ | 78 | #endif /* _LINUX_OF_H */ |
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h index c74d3e875314..b12f93a3c345 100644 --- a/include/linux/page-flags.h +++ b/include/linux/page-flags.h | |||
@@ -93,6 +93,11 @@ enum pageflags { | |||
93 | PG_mappedtodisk, /* Has blocks allocated on-disk */ | 93 | PG_mappedtodisk, /* Has blocks allocated on-disk */ |
94 | PG_reclaim, /* To be reclaimed asap */ | 94 | PG_reclaim, /* To be reclaimed asap */ |
95 | PG_buddy, /* Page is free, on buddy lists */ | 95 | PG_buddy, /* Page is free, on buddy lists */ |
96 | PG_swapbacked, /* Page is backed by RAM/swap */ | ||
97 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
98 | PG_unevictable, /* Page is "unevictable" */ | ||
99 | PG_mlocked, /* Page is vma mlocked */ | ||
100 | #endif | ||
96 | #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR | 101 | #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR |
97 | PG_uncached, /* Page has been mapped as uncached */ | 102 | PG_uncached, /* Page has been mapped as uncached */ |
98 | #endif | 103 | #endif |
@@ -161,6 +166,18 @@ static inline int Page##uname(struct page *page) \ | |||
161 | #define TESTSCFLAG(uname, lname) \ | 166 | #define TESTSCFLAG(uname, lname) \ |
162 | TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname) | 167 | TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname) |
163 | 168 | ||
169 | #define SETPAGEFLAG_NOOP(uname) \ | ||
170 | static inline void SetPage##uname(struct page *page) { } | ||
171 | |||
172 | #define CLEARPAGEFLAG_NOOP(uname) \ | ||
173 | static inline void ClearPage##uname(struct page *page) { } | ||
174 | |||
175 | #define __CLEARPAGEFLAG_NOOP(uname) \ | ||
176 | static inline void __ClearPage##uname(struct page *page) { } | ||
177 | |||
178 | #define TESTCLEARFLAG_FALSE(uname) \ | ||
179 | static inline int TestClearPage##uname(struct page *page) { return 0; } | ||
180 | |||
164 | struct page; /* forward declaration */ | 181 | struct page; /* forward declaration */ |
165 | 182 | ||
166 | TESTPAGEFLAG(Locked, locked) | 183 | TESTPAGEFLAG(Locked, locked) |
@@ -169,6 +186,7 @@ PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced) | |||
169 | PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty) | 186 | PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty) |
170 | PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru) | 187 | PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru) |
171 | PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active) | 188 | PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active) |
189 | TESTCLEARFLAG(Active, active) | ||
172 | __PAGEFLAG(Slab, slab) | 190 | __PAGEFLAG(Slab, slab) |
173 | PAGEFLAG(Checked, checked) /* Used by some filesystems */ | 191 | PAGEFLAG(Checked, checked) /* Used by some filesystems */ |
174 | PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned) /* Xen */ | 192 | PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned) /* Xen */ |
@@ -176,6 +194,7 @@ PAGEFLAG(SavePinned, savepinned); /* Xen */ | |||
176 | PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved) | 194 | PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved) |
177 | PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private) | 195 | PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private) |
178 | __SETPAGEFLAG(Private, private) | 196 | __SETPAGEFLAG(Private, private) |
197 | PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked) | ||
179 | 198 | ||
180 | __PAGEFLAG(SlobPage, slob_page) | 199 | __PAGEFLAG(SlobPage, slob_page) |
181 | __PAGEFLAG(SlobFree, slob_free) | 200 | __PAGEFLAG(SlobFree, slob_free) |
@@ -211,6 +230,25 @@ PAGEFLAG(SwapCache, swapcache) | |||
211 | PAGEFLAG_FALSE(SwapCache) | 230 | PAGEFLAG_FALSE(SwapCache) |
212 | #endif | 231 | #endif |
213 | 232 | ||
233 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
234 | PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable) | ||
235 | TESTCLEARFLAG(Unevictable, unevictable) | ||
236 | |||
237 | #define MLOCK_PAGES 1 | ||
238 | PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked) | ||
239 | TESTSCFLAG(Mlocked, mlocked) | ||
240 | |||
241 | #else | ||
242 | |||
243 | #define MLOCK_PAGES 0 | ||
244 | PAGEFLAG_FALSE(Mlocked) | ||
245 | SETPAGEFLAG_NOOP(Mlocked) TESTCLEARFLAG_FALSE(Mlocked) | ||
246 | |||
247 | PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable) | ||
248 | SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable) | ||
249 | __CLEARPAGEFLAG_NOOP(Unevictable) | ||
250 | #endif | ||
251 | |||
214 | #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR | 252 | #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR |
215 | PAGEFLAG(Uncached, uncached) | 253 | PAGEFLAG(Uncached, uncached) |
216 | #else | 254 | #else |
@@ -326,15 +364,25 @@ static inline void __ClearPageTail(struct page *page) | |||
326 | 364 | ||
327 | #endif /* !PAGEFLAGS_EXTENDED */ | 365 | #endif /* !PAGEFLAGS_EXTENDED */ |
328 | 366 | ||
367 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
368 | #define __PG_UNEVICTABLE (1 << PG_unevictable) | ||
369 | #define __PG_MLOCKED (1 << PG_mlocked) | ||
370 | #else | ||
371 | #define __PG_UNEVICTABLE 0 | ||
372 | #define __PG_MLOCKED 0 | ||
373 | #endif | ||
374 | |||
329 | #define PAGE_FLAGS (1 << PG_lru | 1 << PG_private | 1 << PG_locked | \ | 375 | #define PAGE_FLAGS (1 << PG_lru | 1 << PG_private | 1 << PG_locked | \ |
330 | 1 << PG_buddy | 1 << PG_writeback | \ | 376 | 1 << PG_buddy | 1 << PG_writeback | \ |
331 | 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active) | 377 | 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active | \ |
378 | __PG_UNEVICTABLE | __PG_MLOCKED) | ||
332 | 379 | ||
333 | /* | 380 | /* |
334 | * Flags checked in bad_page(). Pages on the free list should not have | 381 | * Flags checked in bad_page(). Pages on the free list should not have |
335 | * these flags set. It they are, there is a problem. | 382 | * these flags set. It they are, there is a problem. |
336 | */ | 383 | */ |
337 | #define PAGE_FLAGS_CLEAR_WHEN_BAD (PAGE_FLAGS | 1 << PG_reclaim | 1 << PG_dirty) | 384 | #define PAGE_FLAGS_CLEAR_WHEN_BAD (PAGE_FLAGS | \ |
385 | 1 << PG_reclaim | 1 << PG_dirty | 1 << PG_swapbacked) | ||
338 | 386 | ||
339 | /* | 387 | /* |
340 | * Flags checked when a page is freed. Pages being freed should not have | 388 | * Flags checked when a page is freed. Pages being freed should not have |
@@ -347,7 +395,8 @@ static inline void __ClearPageTail(struct page *page) | |||
347 | * Pages being prepped should not have these flags set. It they are, there | 395 | * Pages being prepped should not have these flags set. It they are, there |
348 | * is a problem. | 396 | * is a problem. |
349 | */ | 397 | */ |
350 | #define PAGE_FLAGS_CHECK_AT_PREP (PAGE_FLAGS | 1 << PG_reserved | 1 << PG_dirty) | 398 | #define PAGE_FLAGS_CHECK_AT_PREP (PAGE_FLAGS | \ |
399 | 1 << PG_reserved | 1 << PG_dirty | 1 << PG_swapbacked) | ||
351 | 400 | ||
352 | #endif /* !__GENERATING_BOUNDS_H */ | 401 | #endif /* !__GENERATING_BOUNDS_H */ |
353 | #endif /* PAGE_FLAGS_H */ | 402 | #endif /* PAGE_FLAGS_H */ |
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h new file mode 100644 index 000000000000..0fd39f2231ec --- /dev/null +++ b/include/linux/page_cgroup.h | |||
@@ -0,0 +1,103 @@ | |||
1 | #ifndef __LINUX_PAGE_CGROUP_H | ||
2 | #define __LINUX_PAGE_CGROUP_H | ||
3 | |||
4 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR | ||
5 | #include <linux/bit_spinlock.h> | ||
6 | /* | ||
7 | * Page Cgroup can be considered as an extended mem_map. | ||
8 | * A page_cgroup page is associated with every page descriptor. The | ||
9 | * page_cgroup helps us identify information about the cgroup | ||
10 | * All page cgroups are allocated at boot or memory hotplug event, | ||
11 | * then the page cgroup for pfn always exists. | ||
12 | */ | ||
13 | struct page_cgroup { | ||
14 | unsigned long flags; | ||
15 | struct mem_cgroup *mem_cgroup; | ||
16 | struct page *page; | ||
17 | struct list_head lru; /* per cgroup LRU list */ | ||
18 | }; | ||
19 | |||
20 | void __init pgdat_page_cgroup_init(struct pglist_data *pgdat); | ||
21 | void __init page_cgroup_init(void); | ||
22 | struct page_cgroup *lookup_page_cgroup(struct page *page); | ||
23 | |||
24 | enum { | ||
25 | /* flags for mem_cgroup */ | ||
26 | PCG_LOCK, /* page cgroup is locked */ | ||
27 | PCG_CACHE, /* charged as cache */ | ||
28 | PCG_USED, /* this object is in use. */ | ||
29 | /* flags for LRU placement */ | ||
30 | PCG_ACTIVE, /* page is active in this cgroup */ | ||
31 | PCG_FILE, /* page is file system backed */ | ||
32 | PCG_UNEVICTABLE, /* page is unevictableable */ | ||
33 | }; | ||
34 | |||
35 | #define TESTPCGFLAG(uname, lname) \ | ||
36 | static inline int PageCgroup##uname(struct page_cgroup *pc) \ | ||
37 | { return test_bit(PCG_##lname, &pc->flags); } | ||
38 | |||
39 | #define SETPCGFLAG(uname, lname) \ | ||
40 | static inline void SetPageCgroup##uname(struct page_cgroup *pc)\ | ||
41 | { set_bit(PCG_##lname, &pc->flags); } | ||
42 | |||
43 | #define CLEARPCGFLAG(uname, lname) \ | ||
44 | static inline void ClearPageCgroup##uname(struct page_cgroup *pc) \ | ||
45 | { clear_bit(PCG_##lname, &pc->flags); } | ||
46 | |||
47 | /* Cache flag is set only once (at allocation) */ | ||
48 | TESTPCGFLAG(Cache, CACHE) | ||
49 | |||
50 | TESTPCGFLAG(Used, USED) | ||
51 | CLEARPCGFLAG(Used, USED) | ||
52 | |||
53 | /* LRU management flags (from global-lru definition) */ | ||
54 | TESTPCGFLAG(File, FILE) | ||
55 | SETPCGFLAG(File, FILE) | ||
56 | CLEARPCGFLAG(File, FILE) | ||
57 | |||
58 | TESTPCGFLAG(Active, ACTIVE) | ||
59 | SETPCGFLAG(Active, ACTIVE) | ||
60 | CLEARPCGFLAG(Active, ACTIVE) | ||
61 | |||
62 | TESTPCGFLAG(Unevictable, UNEVICTABLE) | ||
63 | SETPCGFLAG(Unevictable, UNEVICTABLE) | ||
64 | CLEARPCGFLAG(Unevictable, UNEVICTABLE) | ||
65 | |||
66 | static inline int page_cgroup_nid(struct page_cgroup *pc) | ||
67 | { | ||
68 | return page_to_nid(pc->page); | ||
69 | } | ||
70 | |||
71 | static inline enum zone_type page_cgroup_zid(struct page_cgroup *pc) | ||
72 | { | ||
73 | return page_zonenum(pc->page); | ||
74 | } | ||
75 | |||
76 | static inline void lock_page_cgroup(struct page_cgroup *pc) | ||
77 | { | ||
78 | bit_spin_lock(PCG_LOCK, &pc->flags); | ||
79 | } | ||
80 | |||
81 | static inline int trylock_page_cgroup(struct page_cgroup *pc) | ||
82 | { | ||
83 | return bit_spin_trylock(PCG_LOCK, &pc->flags); | ||
84 | } | ||
85 | |||
86 | static inline void unlock_page_cgroup(struct page_cgroup *pc) | ||
87 | { | ||
88 | bit_spin_unlock(PCG_LOCK, &pc->flags); | ||
89 | } | ||
90 | |||
91 | #else /* CONFIG_CGROUP_MEM_RES_CTLR */ | ||
92 | struct page_cgroup; | ||
93 | |||
94 | static inline void pgdat_page_cgroup_init(struct pglist_data *pgdat) | ||
95 | { | ||
96 | } | ||
97 | |||
98 | static inline struct page_cgroup *lookup_page_cgroup(struct page *page) | ||
99 | { | ||
100 | return NULL; | ||
101 | } | ||
102 | #endif | ||
103 | #endif | ||
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h index 5da31c12101c..709742be02f0 100644 --- a/include/linux/pagemap.h +++ b/include/linux/pagemap.h | |||
@@ -32,6 +32,34 @@ static inline void mapping_set_error(struct address_space *mapping, int error) | |||
32 | } | 32 | } |
33 | } | 33 | } |
34 | 34 | ||
35 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
36 | #define AS_UNEVICTABLE (__GFP_BITS_SHIFT + 2) /* e.g., ramdisk, SHM_LOCK */ | ||
37 | |||
38 | static inline void mapping_set_unevictable(struct address_space *mapping) | ||
39 | { | ||
40 | set_bit(AS_UNEVICTABLE, &mapping->flags); | ||
41 | } | ||
42 | |||
43 | static inline void mapping_clear_unevictable(struct address_space *mapping) | ||
44 | { | ||
45 | clear_bit(AS_UNEVICTABLE, &mapping->flags); | ||
46 | } | ||
47 | |||
48 | static inline int mapping_unevictable(struct address_space *mapping) | ||
49 | { | ||
50 | if (likely(mapping)) | ||
51 | return test_bit(AS_UNEVICTABLE, &mapping->flags); | ||
52 | return !!mapping; | ||
53 | } | ||
54 | #else | ||
55 | static inline void mapping_set_unevictable(struct address_space *mapping) { } | ||
56 | static inline void mapping_clear_unevictable(struct address_space *mapping) { } | ||
57 | static inline int mapping_unevictable(struct address_space *mapping) | ||
58 | { | ||
59 | return 0; | ||
60 | } | ||
61 | #endif | ||
62 | |||
35 | static inline gfp_t mapping_gfp_mask(struct address_space * mapping) | 63 | static inline gfp_t mapping_gfp_mask(struct address_space * mapping) |
36 | { | 64 | { |
37 | return (__force gfp_t)mapping->flags & __GFP_BITS_MASK; | 65 | return (__force gfp_t)mapping->flags & __GFP_BITS_MASK; |
@@ -271,19 +299,19 @@ extern int __lock_page_killable(struct page *page); | |||
271 | extern void __lock_page_nosync(struct page *page); | 299 | extern void __lock_page_nosync(struct page *page); |
272 | extern void unlock_page(struct page *page); | 300 | extern void unlock_page(struct page *page); |
273 | 301 | ||
274 | static inline void set_page_locked(struct page *page) | 302 | static inline void __set_page_locked(struct page *page) |
275 | { | 303 | { |
276 | set_bit(PG_locked, &page->flags); | 304 | __set_bit(PG_locked, &page->flags); |
277 | } | 305 | } |
278 | 306 | ||
279 | static inline void clear_page_locked(struct page *page) | 307 | static inline void __clear_page_locked(struct page *page) |
280 | { | 308 | { |
281 | clear_bit(PG_locked, &page->flags); | 309 | __clear_bit(PG_locked, &page->flags); |
282 | } | 310 | } |
283 | 311 | ||
284 | static inline int trylock_page(struct page *page) | 312 | static inline int trylock_page(struct page *page) |
285 | { | 313 | { |
286 | return !test_and_set_bit(PG_locked, &page->flags); | 314 | return (likely(!test_and_set_bit_lock(PG_locked, &page->flags))); |
287 | } | 315 | } |
288 | 316 | ||
289 | /* | 317 | /* |
@@ -410,17 +438,17 @@ extern void __remove_from_page_cache(struct page *page); | |||
410 | 438 | ||
411 | /* | 439 | /* |
412 | * Like add_to_page_cache_locked, but used to add newly allocated pages: | 440 | * Like add_to_page_cache_locked, but used to add newly allocated pages: |
413 | * the page is new, so we can just run set_page_locked() against it. | 441 | * the page is new, so we can just run __set_page_locked() against it. |
414 | */ | 442 | */ |
415 | static inline int add_to_page_cache(struct page *page, | 443 | static inline int add_to_page_cache(struct page *page, |
416 | struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask) | 444 | struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask) |
417 | { | 445 | { |
418 | int error; | 446 | int error; |
419 | 447 | ||
420 | set_page_locked(page); | 448 | __set_page_locked(page); |
421 | error = add_to_page_cache_locked(page, mapping, offset, gfp_mask); | 449 | error = add_to_page_cache_locked(page, mapping, offset, gfp_mask); |
422 | if (unlikely(error)) | 450 | if (unlikely(error)) |
423 | clear_page_locked(page); | 451 | __clear_page_locked(page); |
424 | return error; | 452 | return error; |
425 | } | 453 | } |
426 | 454 | ||
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h index 8eb7fa76c1d0..e90a2cb02915 100644 --- a/include/linux/pagevec.h +++ b/include/linux/pagevec.h | |||
@@ -23,9 +23,9 @@ struct pagevec { | |||
23 | void __pagevec_release(struct pagevec *pvec); | 23 | void __pagevec_release(struct pagevec *pvec); |
24 | void __pagevec_release_nonlru(struct pagevec *pvec); | 24 | void __pagevec_release_nonlru(struct pagevec *pvec); |
25 | void __pagevec_free(struct pagevec *pvec); | 25 | void __pagevec_free(struct pagevec *pvec); |
26 | void __pagevec_lru_add(struct pagevec *pvec); | 26 | void ____pagevec_lru_add(struct pagevec *pvec, enum lru_list lru); |
27 | void __pagevec_lru_add_active(struct pagevec *pvec); | ||
28 | void pagevec_strip(struct pagevec *pvec); | 27 | void pagevec_strip(struct pagevec *pvec); |
28 | void pagevec_swap_free(struct pagevec *pvec); | ||
29 | unsigned pagevec_lookup(struct pagevec *pvec, struct address_space *mapping, | 29 | unsigned pagevec_lookup(struct pagevec *pvec, struct address_space *mapping, |
30 | pgoff_t start, unsigned nr_pages); | 30 | pgoff_t start, unsigned nr_pages); |
31 | unsigned pagevec_lookup_tag(struct pagevec *pvec, | 31 | unsigned pagevec_lookup_tag(struct pagevec *pvec, |
@@ -81,10 +81,36 @@ static inline void pagevec_free(struct pagevec *pvec) | |||
81 | __pagevec_free(pvec); | 81 | __pagevec_free(pvec); |
82 | } | 82 | } |
83 | 83 | ||
84 | static inline void pagevec_lru_add(struct pagevec *pvec) | 84 | static inline void __pagevec_lru_add_anon(struct pagevec *pvec) |
85 | { | ||
86 | ____pagevec_lru_add(pvec, LRU_INACTIVE_ANON); | ||
87 | } | ||
88 | |||
89 | static inline void __pagevec_lru_add_active_anon(struct pagevec *pvec) | ||
90 | { | ||
91 | ____pagevec_lru_add(pvec, LRU_ACTIVE_ANON); | ||
92 | } | ||
93 | |||
94 | static inline void __pagevec_lru_add_file(struct pagevec *pvec) | ||
95 | { | ||
96 | ____pagevec_lru_add(pvec, LRU_INACTIVE_FILE); | ||
97 | } | ||
98 | |||
99 | static inline void __pagevec_lru_add_active_file(struct pagevec *pvec) | ||
100 | { | ||
101 | ____pagevec_lru_add(pvec, LRU_ACTIVE_FILE); | ||
102 | } | ||
103 | |||
104 | static inline void pagevec_lru_add_file(struct pagevec *pvec) | ||
105 | { | ||
106 | if (pagevec_count(pvec)) | ||
107 | __pagevec_lru_add_file(pvec); | ||
108 | } | ||
109 | |||
110 | static inline void pagevec_lru_add_anon(struct pagevec *pvec) | ||
85 | { | 111 | { |
86 | if (pagevec_count(pvec)) | 112 | if (pagevec_count(pvec)) |
87 | __pagevec_lru_add(pvec); | 113 | __pagevec_lru_add_anon(pvec); |
88 | } | 114 | } |
89 | 115 | ||
90 | #endif /* _LINUX_PAGEVEC_H */ | 116 | #endif /* _LINUX_PAGEVEC_H */ |
diff --git a/include/linux/parport.h b/include/linux/parport.h index 6a0d7cdb5774..e1f83c5065c5 100644 --- a/include/linux/parport.h +++ b/include/linux/parport.h | |||
@@ -1,5 +1,3 @@ | |||
1 | /* $Id: parport.h,v 1.1 1998/05/17 10:57:52 andrea Exp andrea $ */ | ||
2 | |||
3 | /* | 1 | /* |
4 | * Any part of this program may be used in documents licensed under | 2 | * Any part of this program may be used in documents licensed under |
5 | * the GNU Free Documentation License, Version 1.1 or any later version | 3 | * the GNU Free Documentation License, Version 1.1 or any later version |
diff --git a/include/linux/pci.h b/include/linux/pci.h index 98dc6243a706..acf8f24037cd 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h | |||
@@ -631,6 +631,8 @@ int __must_check pci_assign_resource(struct pci_dev *dev, int i); | |||
631 | int pci_select_bars(struct pci_dev *dev, unsigned long flags); | 631 | int pci_select_bars(struct pci_dev *dev, unsigned long flags); |
632 | 632 | ||
633 | /* ROM control related routines */ | 633 | /* ROM control related routines */ |
634 | int pci_enable_rom(struct pci_dev *pdev); | ||
635 | void pci_disable_rom(struct pci_dev *pdev); | ||
634 | void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size); | 636 | void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size); |
635 | void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom); | 637 | void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom); |
636 | size_t pci_get_rom_size(void __iomem *rom, size_t size); | 638 | size_t pci_get_rom_size(void __iomem *rom, size_t size); |
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h index 1176f1f177e2..8edddc240e4f 100644 --- a/include/linux/pci_ids.h +++ b/include/linux/pci_ids.h | |||
@@ -587,6 +587,7 @@ | |||
587 | #define PCI_DEVICE_ID_MATROX_G200_PCI 0x0520 | 587 | #define PCI_DEVICE_ID_MATROX_G200_PCI 0x0520 |
588 | #define PCI_DEVICE_ID_MATROX_G200_AGP 0x0521 | 588 | #define PCI_DEVICE_ID_MATROX_G200_AGP 0x0521 |
589 | #define PCI_DEVICE_ID_MATROX_G400 0x0525 | 589 | #define PCI_DEVICE_ID_MATROX_G400 0x0525 |
590 | #define PCI_DEVICE_ID_MATROX_G200EV_PCI 0x0530 | ||
590 | #define PCI_DEVICE_ID_MATROX_G550 0x2527 | 591 | #define PCI_DEVICE_ID_MATROX_G550 0x2527 |
591 | #define PCI_DEVICE_ID_MATROX_VIA 0x4536 | 592 | #define PCI_DEVICE_ID_MATROX_VIA 0x4536 |
592 | 593 | ||
diff --git a/include/linux/pfn.h b/include/linux/pfn.h index bb01f8b92b56..7646637221f3 100644 --- a/include/linux/pfn.h +++ b/include/linux/pfn.h | |||
@@ -1,9 +1,13 @@ | |||
1 | #ifndef _LINUX_PFN_H_ | 1 | #ifndef _LINUX_PFN_H_ |
2 | #define _LINUX_PFN_H_ | 2 | #define _LINUX_PFN_H_ |
3 | 3 | ||
4 | #ifndef __ASSEMBLY__ | ||
5 | #include <linux/types.h> | ||
6 | #endif | ||
7 | |||
4 | #define PFN_ALIGN(x) (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK) | 8 | #define PFN_ALIGN(x) (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK) |
5 | #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) | 9 | #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) |
6 | #define PFN_DOWN(x) ((x) >> PAGE_SHIFT) | 10 | #define PFN_DOWN(x) ((x) >> PAGE_SHIFT) |
7 | #define PFN_PHYS(x) ((x) << PAGE_SHIFT) | 11 | #define PFN_PHYS(x) ((phys_addr_t)(x) << PAGE_SHIFT) |
8 | 12 | ||
9 | #endif | 13 | #endif |
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h index 1af82c4e17d4..d82fe825d62f 100644 --- a/include/linux/pid_namespace.h +++ b/include/linux/pid_namespace.h | |||
@@ -84,12 +84,6 @@ static inline struct pid_namespace *task_active_pid_ns(struct task_struct *tsk) | |||
84 | return tsk->nsproxy->pid_ns; | 84 | return tsk->nsproxy->pid_ns; |
85 | } | 85 | } |
86 | 86 | ||
87 | static inline struct task_struct *task_child_reaper(struct task_struct *tsk) | ||
88 | { | ||
89 | BUG_ON(tsk != current); | ||
90 | return tsk->nsproxy->pid_ns->child_reaper; | ||
91 | } | ||
92 | |||
93 | void pidhash_init(void); | 87 | void pidhash_init(void); |
94 | void pidmap_init(void); | 88 | void pidmap_init(void); |
95 | 89 | ||
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h index 95ac21ab3a09..4b8cc6a32479 100644 --- a/include/linux/platform_device.h +++ b/include/linux/platform_device.h | |||
@@ -37,6 +37,8 @@ extern int platform_add_devices(struct platform_device **, int); | |||
37 | 37 | ||
38 | extern struct platform_device *platform_device_register_simple(const char *, int id, | 38 | extern struct platform_device *platform_device_register_simple(const char *, int id, |
39 | struct resource *, unsigned int); | 39 | struct resource *, unsigned int); |
40 | extern struct platform_device *platform_device_register_data(struct device *, | ||
41 | const char *, int, const void *, size_t); | ||
40 | 42 | ||
41 | extern struct platform_device *platform_device_alloc(const char *name, int id); | 43 | extern struct platform_device *platform_device_alloc(const char *name, int id); |
42 | extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num); | 44 | extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num); |
diff --git a/include/linux/pm.h b/include/linux/pm.h index 4dcce54b6d76..42de4003c4ee 100644 --- a/include/linux/pm.h +++ b/include/linux/pm.h | |||
@@ -419,7 +419,7 @@ extern void __suspend_report_result(const char *function, void *fn, int ret); | |||
419 | 419 | ||
420 | #define suspend_report_result(fn, ret) \ | 420 | #define suspend_report_result(fn, ret) \ |
421 | do { \ | 421 | do { \ |
422 | __suspend_report_result(__FUNCTION__, fn, ret); \ | 422 | __suspend_report_result(__func__, fn, ret); \ |
423 | } while (0) | 423 | } while (0) |
424 | 424 | ||
425 | #else /* !CONFIG_PM_SLEEP */ | 425 | #else /* !CONFIG_PM_SLEEP */ |
diff --git a/include/linux/pnp.h b/include/linux/pnp.h index be764e514e35..53b70fd1d9a5 100644 --- a/include/linux/pnp.h +++ b/include/linux/pnp.h | |||
@@ -22,9 +22,11 @@ struct pnp_dev; | |||
22 | * Resource Management | 22 | * Resource Management |
23 | */ | 23 | */ |
24 | #ifdef CONFIG_PNP | 24 | #ifdef CONFIG_PNP |
25 | struct resource *pnp_get_resource(struct pnp_dev *, unsigned int, unsigned int); | 25 | struct resource *pnp_get_resource(struct pnp_dev *dev, unsigned long type, |
26 | unsigned int num); | ||
26 | #else | 27 | #else |
27 | static inline struct resource *pnp_get_resource(struct pnp_dev *dev, unsigned int type, unsigned int num) | 28 | static inline struct resource *pnp_get_resource(struct pnp_dev *dev, |
29 | unsigned long type, unsigned int num) | ||
28 | { | 30 | { |
29 | return NULL; | 31 | return NULL; |
30 | } | 32 | } |
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h index a7dd38f30ade..a7c721355549 100644 --- a/include/linux/posix-timers.h +++ b/include/linux/posix-timers.h | |||
@@ -45,8 +45,6 @@ struct k_itimer { | |||
45 | int it_requeue_pending; /* waiting to requeue this timer */ | 45 | int it_requeue_pending; /* waiting to requeue this timer */ |
46 | #define REQUEUE_PENDING 1 | 46 | #define REQUEUE_PENDING 1 |
47 | int it_sigev_notify; /* notify word of sigevent struct */ | 47 | int it_sigev_notify; /* notify word of sigevent struct */ |
48 | int it_sigev_signo; /* signo word of sigevent struct */ | ||
49 | sigval_t it_sigev_value; /* value word of sigevent struct */ | ||
50 | struct task_struct *it_process; /* process to send signal to */ | 48 | struct task_struct *it_process; /* process to send signal to */ |
51 | struct sigqueue *sigq; /* signal queue entry. */ | 49 | struct sigqueue *sigq; /* signal queue entry. */ |
52 | union { | 50 | union { |
@@ -115,4 +113,6 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx, | |||
115 | 113 | ||
116 | long clock_nanosleep_restart(struct restart_block *restart_block); | 114 | long clock_nanosleep_restart(struct restart_block *restart_block); |
117 | 115 | ||
116 | void update_rlimit_cpu(unsigned long rlim_new); | ||
117 | |||
118 | #endif | 118 | #endif |
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h index ea96ead1d39d..f9348cba6dc1 100644 --- a/include/linux/power_supply.h +++ b/include/linux/power_supply.h | |||
@@ -165,6 +165,12 @@ struct power_supply_info { | |||
165 | extern void power_supply_changed(struct power_supply *psy); | 165 | extern void power_supply_changed(struct power_supply *psy); |
166 | extern int power_supply_am_i_supplied(struct power_supply *psy); | 166 | extern int power_supply_am_i_supplied(struct power_supply *psy); |
167 | 167 | ||
168 | #if defined(CONFIG_POWER_SUPPLY) || defined(CONFIG_POWER_SUPPLY_MODULE) | ||
169 | extern int power_supply_is_system_supplied(void); | ||
170 | #else | ||
171 | static inline int power_supply_is_system_supplied(void) { return -ENOSYS; } | ||
172 | #endif | ||
173 | |||
168 | extern int power_supply_register(struct device *parent, | 174 | extern int power_supply_register(struct device *parent, |
169 | struct power_supply *psy); | 175 | struct power_supply *psy); |
170 | extern void power_supply_unregister(struct power_supply *psy); | 176 | extern void power_supply_unregister(struct power_supply *psy); |
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h index fb61850d1cfc..27d534f4470d 100644 --- a/include/linux/proc_fs.h +++ b/include/linux/proc_fs.h | |||
@@ -139,7 +139,6 @@ extern int proc_readdir(struct file *, void *, filldir_t); | |||
139 | extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *); | 139 | extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *); |
140 | 140 | ||
141 | extern const struct file_operations proc_kcore_operations; | 141 | extern const struct file_operations proc_kcore_operations; |
142 | extern const struct file_operations ppc_htab_operations; | ||
143 | 142 | ||
144 | extern int pid_ns_prepare_proc(struct pid_namespace *ns); | 143 | extern int pid_ns_prepare_proc(struct pid_namespace *ns); |
145 | extern void pid_ns_release_proc(struct pid_namespace *ns); | 144 | extern void pid_ns_release_proc(struct pid_namespace *ns); |
diff --git a/include/linux/profile.h b/include/linux/profile.h index 7e7087239af5..570045053ce9 100644 --- a/include/linux/profile.h +++ b/include/linux/profile.h | |||
@@ -35,7 +35,9 @@ enum profile_type { | |||
35 | extern int prof_on __read_mostly; | 35 | extern int prof_on __read_mostly; |
36 | 36 | ||
37 | /* init basic kernel profiler */ | 37 | /* init basic kernel profiler */ |
38 | void __init profile_init(void); | 38 | int profile_init(void); |
39 | int profile_setup(char *str); | ||
40 | int create_proc_profile(void); | ||
39 | void profile_tick(int type); | 41 | void profile_tick(int type); |
40 | 42 | ||
41 | /* | 43 | /* |
@@ -84,9 +86,9 @@ struct pt_regs; | |||
84 | 86 | ||
85 | #define prof_on 0 | 87 | #define prof_on 0 |
86 | 88 | ||
87 | static inline void profile_init(void) | 89 | static inline int profile_init(void) |
88 | { | 90 | { |
89 | return; | 91 | return 0; |
90 | } | 92 | } |
91 | 93 | ||
92 | static inline void profile_tick(int type) | 94 | static inline void profile_tick(int type) |
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h index ea7416c901d1..22641d5d45df 100644 --- a/include/linux/ptrace.h +++ b/include/linux/ptrace.h | |||
@@ -94,7 +94,6 @@ extern void ptrace_notify(int exit_code); | |||
94 | extern void __ptrace_link(struct task_struct *child, | 94 | extern void __ptrace_link(struct task_struct *child, |
95 | struct task_struct *new_parent); | 95 | struct task_struct *new_parent); |
96 | extern void __ptrace_unlink(struct task_struct *child); | 96 | extern void __ptrace_unlink(struct task_struct *child); |
97 | extern void ptrace_untrace(struct task_struct *child); | ||
98 | #define PTRACE_MODE_READ 1 | 97 | #define PTRACE_MODE_READ 1 |
99 | #define PTRACE_MODE_ATTACH 2 | 98 | #define PTRACE_MODE_ATTACH 2 |
100 | /* Returns 0 on success, -errno on denial. */ | 99 | /* Returns 0 on success, -errno on denial. */ |
diff --git a/include/linux/quota.h b/include/linux/quota.h index 376a05048bc5..40401b554484 100644 --- a/include/linux/quota.h +++ b/include/linux/quota.h | |||
@@ -28,8 +28,6 @@ | |||
28 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | 28 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
29 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | 29 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
30 | * SUCH DAMAGE. | 30 | * SUCH DAMAGE. |
31 | * | ||
32 | * Version: $Id: quota.h,v 2.0 1996/11/17 16:48:14 mvw Exp mvw $ | ||
33 | */ | 31 | */ |
34 | 32 | ||
35 | #ifndef _LINUX_QUOTA_ | 33 | #ifndef _LINUX_QUOTA_ |
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h index ca6b9b5c8d52..a558a4c1d35a 100644 --- a/include/linux/quotaops.h +++ b/include/linux/quotaops.h | |||
@@ -3,9 +3,6 @@ | |||
3 | * macros expand to the right source-code. | 3 | * macros expand to the right source-code. |
4 | * | 4 | * |
5 | * Author: Marco van Wieringen <mvw@planets.elm.net> | 5 | * Author: Marco van Wieringen <mvw@planets.elm.net> |
6 | * | ||
7 | * Version: $Id: quotaops.h,v 1.2 1998/01/15 16:22:26 ecd Exp $ | ||
8 | * | ||
9 | */ | 6 | */ |
10 | #ifndef _LINUX_QUOTAOPS_ | 7 | #ifndef _LINUX_QUOTAOPS_ |
11 | #define _LINUX_QUOTAOPS_ | 8 | #define _LINUX_QUOTAOPS_ |
diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h index 7e375111d007..f38b9c586afb 100644 --- a/include/linux/raid/linear.h +++ b/include/linux/raid/linear.h | |||
@@ -5,8 +5,8 @@ | |||
5 | 5 | ||
6 | struct dev_info { | 6 | struct dev_info { |
7 | mdk_rdev_t *rdev; | 7 | mdk_rdev_t *rdev; |
8 | sector_t size; | 8 | sector_t num_sectors; |
9 | sector_t offset; | 9 | sector_t start_sector; |
10 | }; | 10 | }; |
11 | 11 | ||
12 | typedef struct dev_info dev_info_t; | 12 | typedef struct dev_info dev_info_t; |
@@ -15,9 +15,11 @@ struct linear_private_data | |||
15 | { | 15 | { |
16 | struct linear_private_data *prev; /* earlier version */ | 16 | struct linear_private_data *prev; /* earlier version */ |
17 | dev_info_t **hash_table; | 17 | dev_info_t **hash_table; |
18 | sector_t hash_spacing; | 18 | sector_t spacing; |
19 | sector_t array_sectors; | 19 | sector_t array_sectors; |
20 | int preshift; /* shift before dividing by hash_spacing */ | 20 | int sector_shift; /* shift before dividing |
21 | * by spacing | ||
22 | */ | ||
21 | dev_info_t disks[0]; | 23 | dev_info_t disks[0]; |
22 | }; | 24 | }; |
23 | 25 | ||
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h index dc0e3fcb9f28..82bea14cae1a 100644 --- a/include/linux/raid/md.h +++ b/include/linux/raid/md.h | |||
@@ -19,27 +19,7 @@ | |||
19 | #define _MD_H | 19 | #define _MD_H |
20 | 20 | ||
21 | #include <linux/blkdev.h> | 21 | #include <linux/blkdev.h> |
22 | #include <linux/major.h> | ||
23 | #include <linux/ioctl.h> | ||
24 | #include <linux/types.h> | ||
25 | #include <linux/bitops.h> | ||
26 | #include <linux/module.h> | ||
27 | #include <linux/hdreg.h> | ||
28 | #include <linux/proc_fs.h> | ||
29 | #include <linux/seq_file.h> | 22 | #include <linux/seq_file.h> |
30 | #include <linux/smp_lock.h> | ||
31 | #include <linux/delay.h> | ||
32 | #include <net/checksum.h> | ||
33 | #include <linux/random.h> | ||
34 | #include <linux/kernel_stat.h> | ||
35 | #include <asm/io.h> | ||
36 | #include <linux/completion.h> | ||
37 | #include <linux/mempool.h> | ||
38 | #include <linux/list.h> | ||
39 | #include <linux/reboot.h> | ||
40 | #include <linux/vmalloc.h> | ||
41 | #include <linux/blkpg.h> | ||
42 | #include <linux/bio.h> | ||
43 | 23 | ||
44 | /* | 24 | /* |
45 | * 'md_p.h' holds the 'physical' layout of RAID devices | 25 | * 'md_p.h' holds the 'physical' layout of RAID devices |
@@ -74,19 +54,17 @@ | |||
74 | 54 | ||
75 | extern int mdp_major; | 55 | extern int mdp_major; |
76 | 56 | ||
77 | extern int register_md_personality (struct mdk_personality *p); | 57 | extern int register_md_personality(struct mdk_personality *p); |
78 | extern int unregister_md_personality (struct mdk_personality *p); | 58 | extern int unregister_md_personality(struct mdk_personality *p); |
79 | extern mdk_thread_t * md_register_thread (void (*run) (mddev_t *mddev), | 59 | extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev), |
80 | mddev_t *mddev, const char *name); | 60 | mddev_t *mddev, const char *name); |
81 | extern void md_unregister_thread (mdk_thread_t *thread); | 61 | extern void md_unregister_thread(mdk_thread_t *thread); |
82 | extern void md_wakeup_thread(mdk_thread_t *thread); | 62 | extern void md_wakeup_thread(mdk_thread_t *thread); |
83 | extern void md_check_recovery(mddev_t *mddev); | 63 | extern void md_check_recovery(mddev_t *mddev); |
84 | extern void md_write_start(mddev_t *mddev, struct bio *bi); | 64 | extern void md_write_start(mddev_t *mddev, struct bio *bi); |
85 | extern void md_write_end(mddev_t *mddev); | 65 | extern void md_write_end(mddev_t *mddev); |
86 | extern void md_handle_safemode(mddev_t *mddev); | ||
87 | extern void md_done_sync(mddev_t *mddev, int blocks, int ok); | 66 | extern void md_done_sync(mddev_t *mddev, int blocks, int ok); |
88 | extern void md_error (mddev_t *mddev, mdk_rdev_t *rdev); | 67 | extern void md_error(mddev_t *mddev, mdk_rdev_t *rdev); |
89 | extern void md_unplug_mddev(mddev_t *mddev); | ||
90 | 68 | ||
91 | extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev, | 69 | extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev, |
92 | sector_t sector, int size, struct page *page); | 70 | sector_t sector, int size, struct page *page); |
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h index e9963af16cda..bc5114d35e99 100644 --- a/include/linux/reiserfs_fs.h +++ b/include/linux/reiserfs_fs.h | |||
@@ -87,7 +87,7 @@ void reiserfs_warning(struct super_block *s, const char *fmt, ...); | |||
87 | if( !( cond ) ) \ | 87 | if( !( cond ) ) \ |
88 | reiserfs_panic( NULL, "reiserfs[%i]: assertion " scond " failed at " \ | 88 | reiserfs_panic( NULL, "reiserfs[%i]: assertion " scond " failed at " \ |
89 | __FILE__ ":%i:%s: " format "\n", \ | 89 | __FILE__ ":%i:%s: " format "\n", \ |
90 | in_interrupt() ? -1 : task_pid_nr(current), __LINE__ , __FUNCTION__ , ##args ) | 90 | in_interrupt() ? -1 : task_pid_nr(current), __LINE__ , __func__ , ##args ) |
91 | 91 | ||
92 | #define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args) | 92 | #define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args) |
93 | 93 | ||
diff --git a/include/linux/rmap.h b/include/linux/rmap.h index fed6f5e0b411..89f0564b10c8 100644 --- a/include/linux/rmap.h +++ b/include/linux/rmap.h | |||
@@ -39,18 +39,6 @@ struct anon_vma { | |||
39 | 39 | ||
40 | #ifdef CONFIG_MMU | 40 | #ifdef CONFIG_MMU |
41 | 41 | ||
42 | extern struct kmem_cache *anon_vma_cachep; | ||
43 | |||
44 | static inline struct anon_vma *anon_vma_alloc(void) | ||
45 | { | ||
46 | return kmem_cache_alloc(anon_vma_cachep, GFP_KERNEL); | ||
47 | } | ||
48 | |||
49 | static inline void anon_vma_free(struct anon_vma *anon_vma) | ||
50 | { | ||
51 | kmem_cache_free(anon_vma_cachep, anon_vma); | ||
52 | } | ||
53 | |||
54 | static inline void anon_vma_lock(struct vm_area_struct *vma) | 42 | static inline void anon_vma_lock(struct vm_area_struct *vma) |
55 | { | 43 | { |
56 | struct anon_vma *anon_vma = vma->anon_vma; | 44 | struct anon_vma *anon_vma = vma->anon_vma; |
@@ -75,6 +63,9 @@ void anon_vma_unlink(struct vm_area_struct *); | |||
75 | void anon_vma_link(struct vm_area_struct *); | 63 | void anon_vma_link(struct vm_area_struct *); |
76 | void __anon_vma_link(struct vm_area_struct *); | 64 | void __anon_vma_link(struct vm_area_struct *); |
77 | 65 | ||
66 | extern struct anon_vma *page_lock_anon_vma(struct page *page); | ||
67 | extern void page_unlock_anon_vma(struct anon_vma *anon_vma); | ||
68 | |||
78 | /* | 69 | /* |
79 | * rmap interfaces called when adding or removing pte of page | 70 | * rmap interfaces called when adding or removing pte of page |
80 | */ | 71 | */ |
@@ -117,6 +108,19 @@ unsigned long page_address_in_vma(struct page *, struct vm_area_struct *); | |||
117 | */ | 108 | */ |
118 | int page_mkclean(struct page *); | 109 | int page_mkclean(struct page *); |
119 | 110 | ||
111 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
112 | /* | ||
113 | * called in munlock()/munmap() path to check for other vmas holding | ||
114 | * the page mlocked. | ||
115 | */ | ||
116 | int try_to_munlock(struct page *); | ||
117 | #else | ||
118 | static inline int try_to_munlock(struct page *page) | ||
119 | { | ||
120 | return 0; /* a.k.a. SWAP_SUCCESS */ | ||
121 | } | ||
122 | #endif | ||
123 | |||
120 | #else /* !CONFIG_MMU */ | 124 | #else /* !CONFIG_MMU */ |
121 | 125 | ||
122 | #define anon_vma_init() do {} while (0) | 126 | #define anon_vma_init() do {} while (0) |
@@ -140,5 +144,6 @@ static inline int page_mkclean(struct page *page) | |||
140 | #define SWAP_SUCCESS 0 | 144 | #define SWAP_SUCCESS 0 |
141 | #define SWAP_AGAIN 1 | 145 | #define SWAP_AGAIN 1 |
142 | #define SWAP_FAIL 2 | 146 | #define SWAP_FAIL 2 |
147 | #define SWAP_MLOCK 3 | ||
143 | 148 | ||
144 | #endif /* _LINUX_RMAP_H */ | 149 | #endif /* _LINUX_RMAP_H */ |
diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h index 382bb7951166..f19b00b7d530 100644 --- a/include/linux/rtmutex.h +++ b/include/linux/rtmutex.h | |||
@@ -54,7 +54,7 @@ struct hrtimer_sleeper; | |||
54 | #ifdef CONFIG_DEBUG_RT_MUTEXES | 54 | #ifdef CONFIG_DEBUG_RT_MUTEXES |
55 | # define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) \ | 55 | # define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) \ |
56 | , .name = #mutexname, .file = __FILE__, .line = __LINE__ | 56 | , .name = #mutexname, .file = __FILE__, .line = __LINE__ |
57 | # define rt_mutex_init(mutex) __rt_mutex_init(mutex, __FUNCTION__) | 57 | # define rt_mutex_init(mutex) __rt_mutex_init(mutex, __func__) |
58 | extern void rt_mutex_debug_task_free(struct task_struct *tsk); | 58 | extern void rt_mutex_debug_task_free(struct task_struct *tsk); |
59 | #else | 59 | #else |
60 | # define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) | 60 | # define __DEBUG_RT_MUTEX_INITIALIZER(mutexname) |
diff --git a/include/linux/sched.h b/include/linux/sched.h index c226c7b82946..5c38db536e07 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h | |||
@@ -403,12 +403,21 @@ extern int get_dumpable(struct mm_struct *mm); | |||
403 | #define MMF_DUMP_MAPPED_PRIVATE 4 | 403 | #define MMF_DUMP_MAPPED_PRIVATE 4 |
404 | #define MMF_DUMP_MAPPED_SHARED 5 | 404 | #define MMF_DUMP_MAPPED_SHARED 5 |
405 | #define MMF_DUMP_ELF_HEADERS 6 | 405 | #define MMF_DUMP_ELF_HEADERS 6 |
406 | #define MMF_DUMP_HUGETLB_PRIVATE 7 | ||
407 | #define MMF_DUMP_HUGETLB_SHARED 8 | ||
406 | #define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS | 408 | #define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS |
407 | #define MMF_DUMP_FILTER_BITS 5 | 409 | #define MMF_DUMP_FILTER_BITS 7 |
408 | #define MMF_DUMP_FILTER_MASK \ | 410 | #define MMF_DUMP_FILTER_MASK \ |
409 | (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) | 411 | (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) |
410 | #define MMF_DUMP_FILTER_DEFAULT \ | 412 | #define MMF_DUMP_FILTER_DEFAULT \ |
411 | ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED)) | 413 | ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\ |
414 | (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) | ||
415 | |||
416 | #ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS | ||
417 | # define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS) | ||
418 | #else | ||
419 | # define MMF_DUMP_MASK_DEFAULT_ELF 0 | ||
420 | #endif | ||
412 | 421 | ||
413 | struct sighand_struct { | 422 | struct sighand_struct { |
414 | atomic_t count; | 423 | atomic_t count; |
@@ -425,6 +434,39 @@ struct pacct_struct { | |||
425 | unsigned long ac_minflt, ac_majflt; | 434 | unsigned long ac_minflt, ac_majflt; |
426 | }; | 435 | }; |
427 | 436 | ||
437 | /** | ||
438 | * struct task_cputime - collected CPU time counts | ||
439 | * @utime: time spent in user mode, in &cputime_t units | ||
440 | * @stime: time spent in kernel mode, in &cputime_t units | ||
441 | * @sum_exec_runtime: total time spent on the CPU, in nanoseconds | ||
442 | * | ||
443 | * This structure groups together three kinds of CPU time that are | ||
444 | * tracked for threads and thread groups. Most things considering | ||
445 | * CPU time want to group these counts together and treat all three | ||
446 | * of them in parallel. | ||
447 | */ | ||
448 | struct task_cputime { | ||
449 | cputime_t utime; | ||
450 | cputime_t stime; | ||
451 | unsigned long long sum_exec_runtime; | ||
452 | }; | ||
453 | /* Alternate field names when used to cache expirations. */ | ||
454 | #define prof_exp stime | ||
455 | #define virt_exp utime | ||
456 | #define sched_exp sum_exec_runtime | ||
457 | |||
458 | /** | ||
459 | * struct thread_group_cputime - thread group interval timer counts | ||
460 | * @totals: thread group interval timers; substructure for | ||
461 | * uniprocessor kernel, per-cpu for SMP kernel. | ||
462 | * | ||
463 | * This structure contains the version of task_cputime, above, that is | ||
464 | * used for thread group CPU clock calculations. | ||
465 | */ | ||
466 | struct thread_group_cputime { | ||
467 | struct task_cputime *totals; | ||
468 | }; | ||
469 | |||
428 | /* | 470 | /* |
429 | * NOTE! "signal_struct" does not have it's own | 471 | * NOTE! "signal_struct" does not have it's own |
430 | * locking, because a shared signal_struct always | 472 | * locking, because a shared signal_struct always |
@@ -470,6 +512,17 @@ struct signal_struct { | |||
470 | cputime_t it_prof_expires, it_virt_expires; | 512 | cputime_t it_prof_expires, it_virt_expires; |
471 | cputime_t it_prof_incr, it_virt_incr; | 513 | cputime_t it_prof_incr, it_virt_incr; |
472 | 514 | ||
515 | /* | ||
516 | * Thread group totals for process CPU clocks. | ||
517 | * See thread_group_cputime(), et al, for details. | ||
518 | */ | ||
519 | struct thread_group_cputime cputime; | ||
520 | |||
521 | /* Earliest-expiration cache. */ | ||
522 | struct task_cputime cputime_expires; | ||
523 | |||
524 | struct list_head cpu_timers[3]; | ||
525 | |||
473 | /* job control IDs */ | 526 | /* job control IDs */ |
474 | 527 | ||
475 | /* | 528 | /* |
@@ -500,7 +553,7 @@ struct signal_struct { | |||
500 | * Live threads maintain their own counters and add to these | 553 | * Live threads maintain their own counters and add to these |
501 | * in __exit_signal, except for the group leader. | 554 | * in __exit_signal, except for the group leader. |
502 | */ | 555 | */ |
503 | cputime_t utime, stime, cutime, cstime; | 556 | cputime_t cutime, cstime; |
504 | cputime_t gtime; | 557 | cputime_t gtime; |
505 | cputime_t cgtime; | 558 | cputime_t cgtime; |
506 | unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; | 559 | unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; |
@@ -509,14 +562,6 @@ struct signal_struct { | |||
509 | struct task_io_accounting ioac; | 562 | struct task_io_accounting ioac; |
510 | 563 | ||
511 | /* | 564 | /* |
512 | * Cumulative ns of scheduled CPU time for dead threads in the | ||
513 | * group, not including a zombie group leader. (This only differs | ||
514 | * from jiffies_to_ns(utime + stime) if sched_clock uses something | ||
515 | * other than jiffies.) | ||
516 | */ | ||
517 | unsigned long long sum_sched_runtime; | ||
518 | |||
519 | /* | ||
520 | * We don't bother to synchronize most readers of this at all, | 565 | * We don't bother to synchronize most readers of this at all, |
521 | * because there is no reader checking a limit that actually needs | 566 | * because there is no reader checking a limit that actually needs |
522 | * to get both rlim_cur and rlim_max atomically, and either one | 567 | * to get both rlim_cur and rlim_max atomically, and either one |
@@ -527,8 +572,6 @@ struct signal_struct { | |||
527 | */ | 572 | */ |
528 | struct rlimit rlim[RLIM_NLIMITS]; | 573 | struct rlimit rlim[RLIM_NLIMITS]; |
529 | 574 | ||
530 | struct list_head cpu_timers[3]; | ||
531 | |||
532 | /* keep the process-shared keyrings here so that they do the right | 575 | /* keep the process-shared keyrings here so that they do the right |
533 | * thing in threads created with CLONE_THREAD */ | 576 | * thing in threads created with CLONE_THREAD */ |
534 | #ifdef CONFIG_KEYS | 577 | #ifdef CONFIG_KEYS |
@@ -1137,8 +1180,7 @@ struct task_struct { | |||
1137 | /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */ | 1180 | /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */ |
1138 | unsigned long min_flt, maj_flt; | 1181 | unsigned long min_flt, maj_flt; |
1139 | 1182 | ||
1140 | cputime_t it_prof_expires, it_virt_expires; | 1183 | struct task_cputime cputime_expires; |
1141 | unsigned long long it_sched_expires; | ||
1142 | struct list_head cpu_timers[3]; | 1184 | struct list_head cpu_timers[3]; |
1143 | 1185 | ||
1144 | /* process credentials */ | 1186 | /* process credentials */ |
@@ -1588,6 +1630,7 @@ extern unsigned long long cpu_clock(int cpu); | |||
1588 | 1630 | ||
1589 | extern unsigned long long | 1631 | extern unsigned long long |
1590 | task_sched_runtime(struct task_struct *task); | 1632 | task_sched_runtime(struct task_struct *task); |
1633 | extern unsigned long long thread_group_sched_runtime(struct task_struct *task); | ||
1591 | 1634 | ||
1592 | /* sched_exec is called by processes performing an exec */ | 1635 | /* sched_exec is called by processes performing an exec */ |
1593 | #ifdef CONFIG_SMP | 1636 | #ifdef CONFIG_SMP |
@@ -2085,6 +2128,30 @@ static inline int spin_needbreak(spinlock_t *lock) | |||
2085 | } | 2128 | } |
2086 | 2129 | ||
2087 | /* | 2130 | /* |
2131 | * Thread group CPU time accounting. | ||
2132 | */ | ||
2133 | |||
2134 | extern int thread_group_cputime_alloc(struct task_struct *); | ||
2135 | extern void thread_group_cputime(struct task_struct *, struct task_cputime *); | ||
2136 | |||
2137 | static inline void thread_group_cputime_init(struct signal_struct *sig) | ||
2138 | { | ||
2139 | sig->cputime.totals = NULL; | ||
2140 | } | ||
2141 | |||
2142 | static inline int thread_group_cputime_clone_thread(struct task_struct *curr) | ||
2143 | { | ||
2144 | if (curr->signal->cputime.totals) | ||
2145 | return 0; | ||
2146 | return thread_group_cputime_alloc(curr); | ||
2147 | } | ||
2148 | |||
2149 | static inline void thread_group_cputime_free(struct signal_struct *sig) | ||
2150 | { | ||
2151 | free_percpu(sig->cputime.totals); | ||
2152 | } | ||
2153 | |||
2154 | /* | ||
2088 | * Reevaluate whether the task has signals pending delivery. | 2155 | * Reevaluate whether the task has signals pending delivery. |
2089 | * Wake the task if so. | 2156 | * Wake the task if so. |
2090 | * This is required every time the blocked sigset_t changes. | 2157 | * This is required every time the blocked sigset_t changes. |
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h index a1783b229ef4..dc50bcc282a8 100644 --- a/include/linux/seq_file.h +++ b/include/linux/seq_file.h | |||
@@ -60,6 +60,19 @@ static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask) | |||
60 | return seq_bitmap(m, mask->bits, MAX_NUMNODES); | 60 | return seq_bitmap(m, mask->bits, MAX_NUMNODES); |
61 | } | 61 | } |
62 | 62 | ||
63 | int seq_bitmap_list(struct seq_file *m, unsigned long *bits, | ||
64 | unsigned int nr_bits); | ||
65 | |||
66 | static inline int seq_cpumask_list(struct seq_file *m, cpumask_t *mask) | ||
67 | { | ||
68 | return seq_bitmap_list(m, mask->bits, NR_CPUS); | ||
69 | } | ||
70 | |||
71 | static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask) | ||
72 | { | ||
73 | return seq_bitmap_list(m, mask->bits, MAX_NUMNODES); | ||
74 | } | ||
75 | |||
63 | int single_open(struct file *, int (*)(struct seq_file *, void *), void *); | 76 | int single_open(struct file *, int (*)(struct seq_file *, void *), void *); |
64 | int single_release(struct inode *, struct file *); | 77 | int single_release(struct inode *, struct file *); |
65 | void *__seq_open_private(struct file *, const struct seq_operations *, int); | 78 | void *__seq_open_private(struct file *, const struct seq_operations *, int); |
diff --git a/include/linux/sh_intc.h b/include/linux/sh_intc.h new file mode 100644 index 000000000000..68e212ff9dde --- /dev/null +++ b/include/linux/sh_intc.h | |||
@@ -0,0 +1,91 @@ | |||
1 | #ifndef __SH_INTC_H | ||
2 | #define __SH_INTC_H | ||
3 | |||
4 | typedef unsigned char intc_enum; | ||
5 | |||
6 | struct intc_vect { | ||
7 | intc_enum enum_id; | ||
8 | unsigned short vect; | ||
9 | }; | ||
10 | |||
11 | #define INTC_VECT(enum_id, vect) { enum_id, vect } | ||
12 | #define INTC_IRQ(enum_id, irq) INTC_VECT(enum_id, irq2evt(irq)) | ||
13 | |||
14 | struct intc_group { | ||
15 | intc_enum enum_id; | ||
16 | intc_enum enum_ids[32]; | ||
17 | }; | ||
18 | |||
19 | #define INTC_GROUP(enum_id, ids...) { enum_id, { ids } } | ||
20 | |||
21 | struct intc_mask_reg { | ||
22 | unsigned long set_reg, clr_reg, reg_width; | ||
23 | intc_enum enum_ids[32]; | ||
24 | #ifdef CONFIG_SMP | ||
25 | unsigned long smp; | ||
26 | #endif | ||
27 | }; | ||
28 | |||
29 | struct intc_prio_reg { | ||
30 | unsigned long set_reg, clr_reg, reg_width, field_width; | ||
31 | intc_enum enum_ids[16]; | ||
32 | #ifdef CONFIG_SMP | ||
33 | unsigned long smp; | ||
34 | #endif | ||
35 | }; | ||
36 | |||
37 | struct intc_sense_reg { | ||
38 | unsigned long reg, reg_width, field_width; | ||
39 | intc_enum enum_ids[16]; | ||
40 | }; | ||
41 | |||
42 | #ifdef CONFIG_SMP | ||
43 | #define INTC_SMP(stride, nr) .smp = (stride) | ((nr) << 8) | ||
44 | #else | ||
45 | #define INTC_SMP(stride, nr) | ||
46 | #endif | ||
47 | |||
48 | struct intc_desc { | ||
49 | struct intc_vect *vectors; | ||
50 | unsigned int nr_vectors; | ||
51 | struct intc_group *groups; | ||
52 | unsigned int nr_groups; | ||
53 | struct intc_mask_reg *mask_regs; | ||
54 | unsigned int nr_mask_regs; | ||
55 | struct intc_prio_reg *prio_regs; | ||
56 | unsigned int nr_prio_regs; | ||
57 | struct intc_sense_reg *sense_regs; | ||
58 | unsigned int nr_sense_regs; | ||
59 | char *name; | ||
60 | #if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A) | ||
61 | struct intc_mask_reg *ack_regs; | ||
62 | unsigned int nr_ack_regs; | ||
63 | #endif | ||
64 | }; | ||
65 | |||
66 | #define _INTC_ARRAY(a) a, sizeof(a)/sizeof(*a) | ||
67 | #define DECLARE_INTC_DESC(symbol, chipname, vectors, groups, \ | ||
68 | mask_regs, prio_regs, sense_regs) \ | ||
69 | struct intc_desc symbol __initdata = { \ | ||
70 | _INTC_ARRAY(vectors), _INTC_ARRAY(groups), \ | ||
71 | _INTC_ARRAY(mask_regs), _INTC_ARRAY(prio_regs), \ | ||
72 | _INTC_ARRAY(sense_regs), \ | ||
73 | chipname, \ | ||
74 | } | ||
75 | |||
76 | #if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A) | ||
77 | #define DECLARE_INTC_DESC_ACK(symbol, chipname, vectors, groups, \ | ||
78 | mask_regs, prio_regs, sense_regs, ack_regs) \ | ||
79 | struct intc_desc symbol __initdata = { \ | ||
80 | _INTC_ARRAY(vectors), _INTC_ARRAY(groups), \ | ||
81 | _INTC_ARRAY(mask_regs), _INTC_ARRAY(prio_regs), \ | ||
82 | _INTC_ARRAY(sense_regs), \ | ||
83 | chipname, \ | ||
84 | _INTC_ARRAY(ack_regs), \ | ||
85 | } | ||
86 | #endif | ||
87 | |||
88 | void __init register_intc_controller(struct intc_desc *desc); | ||
89 | int intc_set_priority(unsigned int irq, unsigned int prio); | ||
90 | |||
91 | #endif /* __SH_INTC_H */ | ||
diff --git a/include/linux/smp.h b/include/linux/smp.h index 66484d4a8459..2e4d58b26c06 100644 --- a/include/linux/smp.h +++ b/include/linux/smp.h | |||
@@ -7,6 +7,7 @@ | |||
7 | */ | 7 | */ |
8 | 8 | ||
9 | #include <linux/errno.h> | 9 | #include <linux/errno.h> |
10 | #include <linux/types.h> | ||
10 | #include <linux/list.h> | 11 | #include <linux/list.h> |
11 | #include <linux/cpumask.h> | 12 | #include <linux/cpumask.h> |
12 | 13 | ||
@@ -16,7 +17,8 @@ struct call_single_data { | |||
16 | struct list_head list; | 17 | struct list_head list; |
17 | void (*func) (void *info); | 18 | void (*func) (void *info); |
18 | void *info; | 19 | void *info; |
19 | unsigned int flags; | 20 | u16 flags; |
21 | u16 priv; | ||
20 | }; | 22 | }; |
21 | 23 | ||
22 | #ifdef CONFIG_SMP | 24 | #ifdef CONFIG_SMP |
diff --git a/include/linux/spi/orion_spi.h b/include/linux/spi/orion_spi.h index b4d9fa6f797c..decf6d8c77b7 100644 --- a/include/linux/spi/orion_spi.h +++ b/include/linux/spi/orion_spi.h | |||
@@ -11,6 +11,7 @@ | |||
11 | 11 | ||
12 | struct orion_spi_info { | 12 | struct orion_spi_info { |
13 | u32 tclk; /* no <linux/clk.h> support yet */ | 13 | u32 tclk; /* no <linux/clk.h> support yet */ |
14 | u32 enable_clock_fix; | ||
14 | }; | 15 | }; |
15 | 16 | ||
16 | 17 | ||
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h index 4de56b1d372b..54a379c9e8eb 100644 --- a/include/linux/sunrpc/xprtrdma.h +++ b/include/linux/sunrpc/xprtrdma.h | |||
@@ -66,9 +66,6 @@ | |||
66 | 66 | ||
67 | #define RPCRDMA_INLINE_PAD_THRESH (512)/* payload threshold to pad (bytes) */ | 67 | #define RPCRDMA_INLINE_PAD_THRESH (512)/* payload threshold to pad (bytes) */ |
68 | 68 | ||
69 | #define RDMA_RESOLVE_TIMEOUT (5*HZ) /* TBD 5 seconds */ | ||
70 | #define RDMA_CONNECT_RETRY_MAX (2) /* retries if no listener backlog */ | ||
71 | |||
72 | /* memory registration strategies */ | 69 | /* memory registration strategies */ |
73 | #define RPCRDMA_PERSISTENT_REGISTRATION (1) | 70 | #define RPCRDMA_PERSISTENT_REGISTRATION (1) |
74 | 71 | ||
@@ -78,6 +75,7 @@ enum rpcrdma_memreg { | |||
78 | RPCRDMA_MEMWINDOWS, | 75 | RPCRDMA_MEMWINDOWS, |
79 | RPCRDMA_MEMWINDOWS_ASYNC, | 76 | RPCRDMA_MEMWINDOWS_ASYNC, |
80 | RPCRDMA_MTHCAFMR, | 77 | RPCRDMA_MTHCAFMR, |
78 | RPCRDMA_FRMR, | ||
81 | RPCRDMA_ALLPHYSICAL, | 79 | RPCRDMA_ALLPHYSICAL, |
82 | RPCRDMA_LAST | 80 | RPCRDMA_LAST |
83 | }; | 81 | }; |
diff --git a/include/linux/swab.h b/include/linux/swab.h index 270d5c208a89..bbed279f3b32 100644 --- a/include/linux/swab.h +++ b/include/linux/swab.h | |||
@@ -47,8 +47,6 @@ static inline __attribute_const__ __u16 ___swab16(__u16 val) | |||
47 | { | 47 | { |
48 | #ifdef __arch_swab16 | 48 | #ifdef __arch_swab16 |
49 | return __arch_swab16(val); | 49 | return __arch_swab16(val); |
50 | #elif defined(__arch_swab16p) | ||
51 | return __arch_swab16p(&val); | ||
52 | #else | 50 | #else |
53 | return __const_swab16(val); | 51 | return __const_swab16(val); |
54 | #endif | 52 | #endif |
@@ -58,8 +56,6 @@ static inline __attribute_const__ __u32 ___swab32(__u32 val) | |||
58 | { | 56 | { |
59 | #ifdef __arch_swab32 | 57 | #ifdef __arch_swab32 |
60 | return __arch_swab32(val); | 58 | return __arch_swab32(val); |
61 | #elif defined(__arch_swab32p) | ||
62 | return __arch_swab32p(&val); | ||
63 | #else | 59 | #else |
64 | return __const_swab32(val); | 60 | return __const_swab32(val); |
65 | #endif | 61 | #endif |
@@ -69,8 +65,6 @@ static inline __attribute_const__ __u64 ___swab64(__u64 val) | |||
69 | { | 65 | { |
70 | #ifdef __arch_swab64 | 66 | #ifdef __arch_swab64 |
71 | return __arch_swab64(val); | 67 | return __arch_swab64(val); |
72 | #elif defined(__arch_swab64p) | ||
73 | return __arch_swab64p(&val); | ||
74 | #elif defined(__SWAB_64_THRU_32__) | 68 | #elif defined(__SWAB_64_THRU_32__) |
75 | __u32 h = val >> 32; | 69 | __u32 h = val >> 32; |
76 | __u32 l = val & ((1ULL << 32) - 1); | 70 | __u32 l = val & ((1ULL << 32) - 1); |
@@ -84,8 +78,6 @@ static inline __attribute_const__ __u32 ___swahw32(__u32 val) | |||
84 | { | 78 | { |
85 | #ifdef __arch_swahw32 | 79 | #ifdef __arch_swahw32 |
86 | return __arch_swahw32(val); | 80 | return __arch_swahw32(val); |
87 | #elif defined(__arch_swahw32p) | ||
88 | return __arch_swahw32p(&val); | ||
89 | #else | 81 | #else |
90 | return __const_swahw32(val); | 82 | return __const_swahw32(val); |
91 | #endif | 83 | #endif |
@@ -95,8 +87,6 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val) | |||
95 | { | 87 | { |
96 | #ifdef __arch_swahb32 | 88 | #ifdef __arch_swahb32 |
97 | return __arch_swahb32(val); | 89 | return __arch_swahb32(val); |
98 | #elif defined(__arch_swahb32p) | ||
99 | return __arch_swahb32p(&val); | ||
100 | #else | 90 | #else |
101 | return __const_swahb32(val); | 91 | return __const_swahb32(val); |
102 | #endif | 92 | #endif |
diff --git a/include/linux/swap.h b/include/linux/swap.h index de40f169a4e4..a3af95b2cb6d 100644 --- a/include/linux/swap.h +++ b/include/linux/swap.h | |||
@@ -7,6 +7,7 @@ | |||
7 | #include <linux/list.h> | 7 | #include <linux/list.h> |
8 | #include <linux/memcontrol.h> | 8 | #include <linux/memcontrol.h> |
9 | #include <linux/sched.h> | 9 | #include <linux/sched.h> |
10 | #include <linux/node.h> | ||
10 | 11 | ||
11 | #include <asm/atomic.h> | 12 | #include <asm/atomic.h> |
12 | #include <asm/page.h> | 13 | #include <asm/page.h> |
@@ -171,8 +172,10 @@ extern unsigned int nr_free_pagecache_pages(void); | |||
171 | 172 | ||
172 | 173 | ||
173 | /* linux/mm/swap.c */ | 174 | /* linux/mm/swap.c */ |
174 | extern void lru_cache_add(struct page *); | 175 | extern void __lru_cache_add(struct page *, enum lru_list lru); |
175 | extern void lru_cache_add_active(struct page *); | 176 | extern void lru_cache_add_lru(struct page *, enum lru_list lru); |
177 | extern void lru_cache_add_active_or_unevictable(struct page *, | ||
178 | struct vm_area_struct *); | ||
176 | extern void activate_page(struct page *); | 179 | extern void activate_page(struct page *); |
177 | extern void mark_page_accessed(struct page *); | 180 | extern void mark_page_accessed(struct page *); |
178 | extern void lru_add_drain(void); | 181 | extern void lru_add_drain(void); |
@@ -180,12 +183,38 @@ extern int lru_add_drain_all(void); | |||
180 | extern void rotate_reclaimable_page(struct page *page); | 183 | extern void rotate_reclaimable_page(struct page *page); |
181 | extern void swap_setup(void); | 184 | extern void swap_setup(void); |
182 | 185 | ||
186 | extern void add_page_to_unevictable_list(struct page *page); | ||
187 | |||
188 | /** | ||
189 | * lru_cache_add: add a page to the page lists | ||
190 | * @page: the page to add | ||
191 | */ | ||
192 | static inline void lru_cache_add_anon(struct page *page) | ||
193 | { | ||
194 | __lru_cache_add(page, LRU_INACTIVE_ANON); | ||
195 | } | ||
196 | |||
197 | static inline void lru_cache_add_active_anon(struct page *page) | ||
198 | { | ||
199 | __lru_cache_add(page, LRU_ACTIVE_ANON); | ||
200 | } | ||
201 | |||
202 | static inline void lru_cache_add_file(struct page *page) | ||
203 | { | ||
204 | __lru_cache_add(page, LRU_INACTIVE_FILE); | ||
205 | } | ||
206 | |||
207 | static inline void lru_cache_add_active_file(struct page *page) | ||
208 | { | ||
209 | __lru_cache_add(page, LRU_ACTIVE_FILE); | ||
210 | } | ||
211 | |||
183 | /* linux/mm/vmscan.c */ | 212 | /* linux/mm/vmscan.c */ |
184 | extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order, | 213 | extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order, |
185 | gfp_t gfp_mask); | 214 | gfp_t gfp_mask); |
186 | extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem, | 215 | extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem, |
187 | gfp_t gfp_mask); | 216 | gfp_t gfp_mask); |
188 | extern int __isolate_lru_page(struct page *page, int mode); | 217 | extern int __isolate_lru_page(struct page *page, int mode, int file); |
189 | extern unsigned long shrink_all_memory(unsigned long nr_pages); | 218 | extern unsigned long shrink_all_memory(unsigned long nr_pages); |
190 | extern int vm_swappiness; | 219 | extern int vm_swappiness; |
191 | extern int remove_mapping(struct address_space *mapping, struct page *page); | 220 | extern int remove_mapping(struct address_space *mapping, struct page *page); |
@@ -204,6 +233,34 @@ static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order) | |||
204 | } | 233 | } |
205 | #endif | 234 | #endif |
206 | 235 | ||
236 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
237 | extern int page_evictable(struct page *page, struct vm_area_struct *vma); | ||
238 | extern void scan_mapping_unevictable_pages(struct address_space *); | ||
239 | |||
240 | extern unsigned long scan_unevictable_pages; | ||
241 | extern int scan_unevictable_handler(struct ctl_table *, int, struct file *, | ||
242 | void __user *, size_t *, loff_t *); | ||
243 | extern int scan_unevictable_register_node(struct node *node); | ||
244 | extern void scan_unevictable_unregister_node(struct node *node); | ||
245 | #else | ||
246 | static inline int page_evictable(struct page *page, | ||
247 | struct vm_area_struct *vma) | ||
248 | { | ||
249 | return 1; | ||
250 | } | ||
251 | |||
252 | static inline void scan_mapping_unevictable_pages(struct address_space *mapping) | ||
253 | { | ||
254 | } | ||
255 | |||
256 | static inline int scan_unevictable_register_node(struct node *node) | ||
257 | { | ||
258 | return 0; | ||
259 | } | ||
260 | |||
261 | static inline void scan_unevictable_unregister_node(struct node *node) { } | ||
262 | #endif | ||
263 | |||
207 | extern int kswapd_run(int nid); | 264 | extern int kswapd_run(int nid); |
208 | 265 | ||
209 | #ifdef CONFIG_MMU | 266 | #ifdef CONFIG_MMU |
@@ -251,6 +308,7 @@ extern sector_t swapdev_block(int, pgoff_t); | |||
251 | extern struct swap_info_struct *get_swap_info_struct(unsigned); | 308 | extern struct swap_info_struct *get_swap_info_struct(unsigned); |
252 | extern int can_share_swap_page(struct page *); | 309 | extern int can_share_swap_page(struct page *); |
253 | extern int remove_exclusive_swap_page(struct page *); | 310 | extern int remove_exclusive_swap_page(struct page *); |
311 | extern int remove_exclusive_swap_page_ref(struct page *); | ||
254 | struct backing_dev_info; | 312 | struct backing_dev_info; |
255 | 313 | ||
256 | /* linux/mm/thrash.c */ | 314 | /* linux/mm/thrash.c */ |
@@ -339,6 +397,11 @@ static inline int remove_exclusive_swap_page(struct page *p) | |||
339 | return 0; | 397 | return 0; |
340 | } | 398 | } |
341 | 399 | ||
400 | static inline int remove_exclusive_swap_page_ref(struct page *page) | ||
401 | { | ||
402 | return 0; | ||
403 | } | ||
404 | |||
342 | static inline swp_entry_t get_swap_page(void) | 405 | static inline swp_entry_t get_swap_page(void) |
343 | { | 406 | { |
344 | swp_entry_t entry; | 407 | swp_entry_t entry; |
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h new file mode 100644 index 000000000000..b18ec5533e8c --- /dev/null +++ b/include/linux/swiotlb.h | |||
@@ -0,0 +1,83 @@ | |||
1 | #ifndef __LINUX_SWIOTLB_H | ||
2 | #define __LINUX_SWIOTLB_H | ||
3 | |||
4 | #include <linux/types.h> | ||
5 | |||
6 | struct device; | ||
7 | struct dma_attrs; | ||
8 | struct scatterlist; | ||
9 | |||
10 | extern void | ||
11 | swiotlb_init(void); | ||
12 | |||
13 | extern void | ||
14 | *swiotlb_alloc_coherent(struct device *hwdev, size_t size, | ||
15 | dma_addr_t *dma_handle, gfp_t flags); | ||
16 | |||
17 | extern void | ||
18 | swiotlb_free_coherent(struct device *hwdev, size_t size, | ||
19 | void *vaddr, dma_addr_t dma_handle); | ||
20 | |||
21 | extern dma_addr_t | ||
22 | swiotlb_map_single(struct device *hwdev, void *ptr, size_t size, int dir); | ||
23 | |||
24 | extern void | ||
25 | swiotlb_unmap_single(struct device *hwdev, dma_addr_t dev_addr, | ||
26 | size_t size, int dir); | ||
27 | |||
28 | extern dma_addr_t | ||
29 | swiotlb_map_single_attrs(struct device *hwdev, void *ptr, size_t size, | ||
30 | int dir, struct dma_attrs *attrs); | ||
31 | |||
32 | extern void | ||
33 | swiotlb_unmap_single_attrs(struct device *hwdev, dma_addr_t dev_addr, | ||
34 | size_t size, int dir, struct dma_attrs *attrs); | ||
35 | |||
36 | extern int | ||
37 | swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, | ||
38 | int direction); | ||
39 | |||
40 | extern void | ||
41 | swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents, | ||
42 | int direction); | ||
43 | |||
44 | extern int | ||
45 | swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, | ||
46 | int dir, struct dma_attrs *attrs); | ||
47 | |||
48 | extern void | ||
49 | swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, | ||
50 | int nelems, int dir, struct dma_attrs *attrs); | ||
51 | |||
52 | extern void | ||
53 | swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, | ||
54 | size_t size, int dir); | ||
55 | |||
56 | extern void | ||
57 | swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, | ||
58 | int nelems, int dir); | ||
59 | |||
60 | extern void | ||
61 | swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, | ||
62 | size_t size, int dir); | ||
63 | |||
64 | extern void | ||
65 | swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, | ||
66 | int nelems, int dir); | ||
67 | |||
68 | extern void | ||
69 | swiotlb_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dev_addr, | ||
70 | unsigned long offset, size_t size, int dir); | ||
71 | |||
72 | extern void | ||
73 | swiotlb_sync_single_range_for_device(struct device *hwdev, dma_addr_t dev_addr, | ||
74 | unsigned long offset, size_t size, | ||
75 | int dir); | ||
76 | |||
77 | extern int | ||
78 | swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr); | ||
79 | |||
80 | extern int | ||
81 | swiotlb_dma_supported(struct device *hwdev, u64 mask); | ||
82 | |||
83 | #endif /* __LINUX_SWIOTLB_H */ | ||
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h index d0437f36921f..39d471d1163b 100644 --- a/include/linux/sysctl.h +++ b/include/linux/sysctl.h | |||
@@ -972,7 +972,7 @@ extern int sysctl_perm(struct ctl_table_root *root, | |||
972 | 972 | ||
973 | typedef struct ctl_table ctl_table; | 973 | typedef struct ctl_table ctl_table; |
974 | 974 | ||
975 | typedef int ctl_handler (struct ctl_table *table, int __user *name, int nlen, | 975 | typedef int ctl_handler (struct ctl_table *table, |
976 | void __user *oldval, size_t __user *oldlenp, | 976 | void __user *oldval, size_t __user *oldlenp, |
977 | void __user *newval, size_t newlen); | 977 | void __user *newval, size_t newlen); |
978 | 978 | ||
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h index 37fa24152bd8..9d68fed50f11 100644 --- a/include/linux/sysfs.h +++ b/include/linux/sysfs.h | |||
@@ -21,8 +21,9 @@ struct kobject; | |||
21 | struct module; | 21 | struct module; |
22 | 22 | ||
23 | /* FIXME | 23 | /* FIXME |
24 | * The *owner field is no longer used, but leave around | 24 | * The *owner field is no longer used. |
25 | * until the tree gets cleaned up fully. | 25 | * x86 tree has been cleaned up. The owner |
26 | * attribute is still left for other arches. | ||
26 | */ | 27 | */ |
27 | struct attribute { | 28 | struct attribute { |
28 | const char *name; | 29 | const char *name; |
@@ -78,6 +79,8 @@ struct sysfs_ops { | |||
78 | ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t); | 79 | ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t); |
79 | }; | 80 | }; |
80 | 81 | ||
82 | struct sysfs_dirent; | ||
83 | |||
81 | #ifdef CONFIG_SYSFS | 84 | #ifdef CONFIG_SYSFS |
82 | 85 | ||
83 | int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *), | 86 | int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *), |
@@ -117,9 +120,14 @@ int sysfs_add_file_to_group(struct kobject *kobj, | |||
117 | void sysfs_remove_file_from_group(struct kobject *kobj, | 120 | void sysfs_remove_file_from_group(struct kobject *kobj, |
118 | const struct attribute *attr, const char *group); | 121 | const struct attribute *attr, const char *group); |
119 | 122 | ||
120 | void sysfs_notify(struct kobject *kobj, char *dir, char *attr); | 123 | void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr); |
121 | 124 | void sysfs_notify_dirent(struct sysfs_dirent *sd); | |
122 | extern int __must_check sysfs_init(void); | 125 | struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd, |
126 | const unsigned char *name); | ||
127 | struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd); | ||
128 | void sysfs_put(struct sysfs_dirent *sd); | ||
129 | void sysfs_printk_last_file(void); | ||
130 | int __must_check sysfs_init(void); | ||
123 | 131 | ||
124 | #else /* CONFIG_SYSFS */ | 132 | #else /* CONFIG_SYSFS */ |
125 | 133 | ||
@@ -222,7 +230,24 @@ static inline void sysfs_remove_file_from_group(struct kobject *kobj, | |||
222 | { | 230 | { |
223 | } | 231 | } |
224 | 232 | ||
225 | static inline void sysfs_notify(struct kobject *kobj, char *dir, char *attr) | 233 | static inline void sysfs_notify(struct kobject *kobj, const char *dir, |
234 | const char *attr) | ||
235 | { | ||
236 | } | ||
237 | static inline void sysfs_notify_dirent(struct sysfs_dirent *sd) | ||
238 | { | ||
239 | } | ||
240 | static inline | ||
241 | struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd, | ||
242 | const unsigned char *name) | ||
243 | { | ||
244 | return NULL; | ||
245 | } | ||
246 | static inline struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd) | ||
247 | { | ||
248 | return NULL; | ||
249 | } | ||
250 | static inline void sysfs_put(struct sysfs_dirent *sd) | ||
226 | { | 251 | { |
227 | } | 252 | } |
228 | 253 | ||
@@ -231,6 +256,10 @@ static inline int __must_check sysfs_init(void) | |||
231 | return 0; | 256 | return 0; |
232 | } | 257 | } |
233 | 258 | ||
259 | static inline void sysfs_printk_last_file(void) | ||
260 | { | ||
261 | } | ||
262 | |||
234 | #endif /* CONFIG_SYSFS */ | 263 | #endif /* CONFIG_SYSFS */ |
235 | 264 | ||
236 | #endif /* _SYSFS_H_ */ | 265 | #endif /* _SYSFS_H_ */ |
diff --git a/include/linux/task_io_accounting.h b/include/linux/task_io_accounting.h index 5e88afc9a2fb..bdf855c2856f 100644 --- a/include/linux/task_io_accounting.h +++ b/include/linux/task_io_accounting.h | |||
@@ -5,7 +5,7 @@ | |||
5 | * Don't include this header file directly - it is designed to be dragged in via | 5 | * Don't include this header file directly - it is designed to be dragged in via |
6 | * sched.h. | 6 | * sched.h. |
7 | * | 7 | * |
8 | * Blame akpm@osdl.org for all this. | 8 | * Blame Andrew Morton for all this. |
9 | */ | 9 | */ |
10 | 10 | ||
11 | struct task_io_accounting { | 11 | struct task_io_accounting { |
diff --git a/include/linux/telephony.h b/include/linux/telephony.h index 0d0cf2a1e7bc..5b2b6261f193 100644 --- a/include/linux/telephony.h +++ b/include/linux/telephony.h | |||
@@ -28,10 +28,6 @@ | |||
28 | * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION | 28 | * ON AN "AS IS" BASIS, AND QUICKNET TECHNOLOGIES, INC. HAS NO OBLIGATION |
29 | * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. | 29 | * TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
30 | * | 30 | * |
31 | * Version: $Revision: 4.2 $ | ||
32 | * | ||
33 | * $Id: telephony.h,v 4.2 2001/08/06 07:09:43 craigs Exp $ | ||
34 | * | ||
35 | *****************************************************************************/ | 31 | *****************************************************************************/ |
36 | 32 | ||
37 | #ifndef TELEPHONY_H | 33 | #ifndef TELEPHONY_H |
diff --git a/include/linux/tick.h b/include/linux/tick.h index 98921a3e1aa8..b6ec8189ac0c 100644 --- a/include/linux/tick.h +++ b/include/linux/tick.h | |||
@@ -96,9 +96,11 @@ extern cpumask_t *tick_get_broadcast_oneshot_mask(void); | |||
96 | extern void tick_clock_notify(void); | 96 | extern void tick_clock_notify(void); |
97 | extern int tick_check_oneshot_change(int allow_nohz); | 97 | extern int tick_check_oneshot_change(int allow_nohz); |
98 | extern struct tick_sched *tick_get_tick_sched(int cpu); | 98 | extern struct tick_sched *tick_get_tick_sched(int cpu); |
99 | extern void tick_check_idle(int cpu); | ||
99 | # else | 100 | # else |
100 | static inline void tick_clock_notify(void) { } | 101 | static inline void tick_clock_notify(void) { } |
101 | static inline int tick_check_oneshot_change(int allow_nohz) { return 0; } | 102 | static inline int tick_check_oneshot_change(int allow_nohz) { return 0; } |
103 | static inline void tick_check_idle(int cpu) { } | ||
102 | # endif | 104 | # endif |
103 | 105 | ||
104 | #else /* CONFIG_GENERIC_CLOCKEVENTS */ | 106 | #else /* CONFIG_GENERIC_CLOCKEVENTS */ |
@@ -106,26 +108,23 @@ static inline void tick_init(void) { } | |||
106 | static inline void tick_cancel_sched_timer(int cpu) { } | 108 | static inline void tick_cancel_sched_timer(int cpu) { } |
107 | static inline void tick_clock_notify(void) { } | 109 | static inline void tick_clock_notify(void) { } |
108 | static inline int tick_check_oneshot_change(int allow_nohz) { return 0; } | 110 | static inline int tick_check_oneshot_change(int allow_nohz) { return 0; } |
111 | static inline void tick_check_idle(int cpu) { } | ||
109 | #endif /* !CONFIG_GENERIC_CLOCKEVENTS */ | 112 | #endif /* !CONFIG_GENERIC_CLOCKEVENTS */ |
110 | 113 | ||
111 | # ifdef CONFIG_NO_HZ | 114 | # ifdef CONFIG_NO_HZ |
112 | extern void tick_nohz_stop_sched_tick(int inidle); | 115 | extern void tick_nohz_stop_sched_tick(int inidle); |
113 | extern void tick_nohz_restart_sched_tick(void); | 116 | extern void tick_nohz_restart_sched_tick(void); |
114 | extern void tick_nohz_update_jiffies(void); | ||
115 | extern ktime_t tick_nohz_get_sleep_length(void); | 117 | extern ktime_t tick_nohz_get_sleep_length(void); |
116 | extern void tick_nohz_stop_idle(int cpu); | ||
117 | extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time); | 118 | extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time); |
118 | # else | 119 | # else |
119 | static inline void tick_nohz_stop_sched_tick(int inidle) { } | 120 | static inline void tick_nohz_stop_sched_tick(int inidle) { } |
120 | static inline void tick_nohz_restart_sched_tick(void) { } | 121 | static inline void tick_nohz_restart_sched_tick(void) { } |
121 | static inline void tick_nohz_update_jiffies(void) { } | ||
122 | static inline ktime_t tick_nohz_get_sleep_length(void) | 122 | static inline ktime_t tick_nohz_get_sleep_length(void) |
123 | { | 123 | { |
124 | ktime_t len = { .tv64 = NSEC_PER_SEC/HZ }; | 124 | ktime_t len = { .tv64 = NSEC_PER_SEC/HZ }; |
125 | 125 | ||
126 | return len; | 126 | return len; |
127 | } | 127 | } |
128 | static inline void tick_nohz_stop_idle(int cpu) { } | ||
129 | static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; } | 128 | static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; } |
130 | # endif /* !NO_HZ */ | 129 | # endif /* !NO_HZ */ |
131 | 130 | ||
diff --git a/include/linux/time.h b/include/linux/time.h index e15206a7e82e..4f1c9db57707 100644 --- a/include/linux/time.h +++ b/include/linux/time.h | |||
@@ -29,6 +29,8 @@ struct timezone { | |||
29 | 29 | ||
30 | #ifdef __KERNEL__ | 30 | #ifdef __KERNEL__ |
31 | 31 | ||
32 | extern struct timezone sys_tz; | ||
33 | |||
32 | /* Parameters used to convert the timespec values: */ | 34 | /* Parameters used to convert the timespec values: */ |
33 | #define MSEC_PER_SEC 1000L | 35 | #define MSEC_PER_SEC 1000L |
34 | #define USEC_PER_MSEC 1000L | 36 | #define USEC_PER_MSEC 1000L |
@@ -117,6 +119,7 @@ extern int do_setitimer(int which, struct itimerval *value, | |||
117 | extern unsigned int alarm_setitimer(unsigned int seconds); | 119 | extern unsigned int alarm_setitimer(unsigned int seconds); |
118 | extern int do_getitimer(int which, struct itimerval *value); | 120 | extern int do_getitimer(int which, struct itimerval *value); |
119 | extern void getnstimeofday(struct timespec *tv); | 121 | extern void getnstimeofday(struct timespec *tv); |
122 | extern void getrawmonotonic(struct timespec *ts); | ||
120 | extern void getboottime(struct timespec *ts); | 123 | extern void getboottime(struct timespec *ts); |
121 | extern void monotonic_to_bootbased(struct timespec *ts); | 124 | extern void monotonic_to_bootbased(struct timespec *ts); |
122 | 125 | ||
@@ -125,6 +128,9 @@ extern int timekeeping_valid_for_hres(void); | |||
125 | extern void update_wall_time(void); | 128 | extern void update_wall_time(void); |
126 | extern void update_xtime_cache(u64 nsec); | 129 | extern void update_xtime_cache(u64 nsec); |
127 | 130 | ||
131 | struct tms; | ||
132 | extern void do_sys_times(struct tms *); | ||
133 | |||
128 | /** | 134 | /** |
129 | * timespec_to_ns - Convert timespec to nanoseconds | 135 | * timespec_to_ns - Convert timespec to nanoseconds |
130 | * @ts: pointer to the timespec variable to be converted | 136 | * @ts: pointer to the timespec variable to be converted |
@@ -214,6 +220,7 @@ struct itimerval { | |||
214 | #define CLOCK_MONOTONIC 1 | 220 | #define CLOCK_MONOTONIC 1 |
215 | #define CLOCK_PROCESS_CPUTIME_ID 2 | 221 | #define CLOCK_PROCESS_CPUTIME_ID 2 |
216 | #define CLOCK_THREAD_CPUTIME_ID 3 | 222 | #define CLOCK_THREAD_CPUTIME_ID 3 |
223 | #define CLOCK_MONOTONIC_RAW 4 | ||
217 | 224 | ||
218 | /* | 225 | /* |
219 | * The IDs of various hardware clocks: | 226 | * The IDs of various hardware clocks: |
diff --git a/include/linux/timex.h b/include/linux/timex.h index fc6035d29d56..9007313b5b71 100644 --- a/include/linux/timex.h +++ b/include/linux/timex.h | |||
@@ -82,7 +82,7 @@ | |||
82 | */ | 82 | */ |
83 | #define SHIFT_USEC 16 /* frequency offset scale (shift) */ | 83 | #define SHIFT_USEC 16 /* frequency offset scale (shift) */ |
84 | #define PPM_SCALE (NSEC_PER_USEC << (NTP_SCALE_SHIFT - SHIFT_USEC)) | 84 | #define PPM_SCALE (NSEC_PER_USEC << (NTP_SCALE_SHIFT - SHIFT_USEC)) |
85 | #define PPM_SCALE_INV_SHIFT 20 | 85 | #define PPM_SCALE_INV_SHIFT 19 |
86 | #define PPM_SCALE_INV ((1ll << (PPM_SCALE_INV_SHIFT + NTP_SCALE_SHIFT)) / \ | 86 | #define PPM_SCALE_INV ((1ll << (PPM_SCALE_INV_SHIFT + NTP_SCALE_SHIFT)) / \ |
87 | PPM_SCALE + 1) | 87 | PPM_SCALE + 1) |
88 | 88 | ||
@@ -141,8 +141,15 @@ struct timex { | |||
141 | #define ADJ_MICRO 0x1000 /* select microsecond resolution */ | 141 | #define ADJ_MICRO 0x1000 /* select microsecond resolution */ |
142 | #define ADJ_NANO 0x2000 /* select nanosecond resolution */ | 142 | #define ADJ_NANO 0x2000 /* select nanosecond resolution */ |
143 | #define ADJ_TICK 0x4000 /* tick value */ | 143 | #define ADJ_TICK 0x4000 /* tick value */ |
144 | |||
145 | #ifdef __KERNEL__ | ||
146 | #define ADJ_ADJTIME 0x8000 /* switch between adjtime/adjtimex modes */ | ||
147 | #define ADJ_OFFSET_SINGLESHOT 0x0001 /* old-fashioned adjtime */ | ||
148 | #define ADJ_OFFSET_READONLY 0x2000 /* read-only adjtime */ | ||
149 | #else | ||
144 | #define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime */ | 150 | #define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime */ |
145 | #define ADJ_OFFSET_SS_READ 0xa001 /* read-only adjtime */ | 151 | #define ADJ_OFFSET_SS_READ 0xa001 /* read-only adjtime */ |
152 | #endif | ||
146 | 153 | ||
147 | /* xntp 3.4 compatibility names */ | 154 | /* xntp 3.4 compatibility names */ |
148 | #define MOD_OFFSET ADJ_OFFSET | 155 | #define MOD_OFFSET ADJ_OFFSET |
diff --git a/include/linux/types.h b/include/linux/types.h index d4a9ce6e2760..f24f7beb47df 100644 --- a/include/linux/types.h +++ b/include/linux/types.h | |||
@@ -191,12 +191,14 @@ typedef __u32 __bitwise __wsum; | |||
191 | #ifdef __KERNEL__ | 191 | #ifdef __KERNEL__ |
192 | typedef unsigned __bitwise__ gfp_t; | 192 | typedef unsigned __bitwise__ gfp_t; |
193 | 193 | ||
194 | #ifdef CONFIG_RESOURCES_64BIT | 194 | #ifdef CONFIG_PHYS_ADDR_T_64BIT |
195 | typedef u64 resource_size_t; | 195 | typedef u64 phys_addr_t; |
196 | #else | 196 | #else |
197 | typedef u32 resource_size_t; | 197 | typedef u32 phys_addr_t; |
198 | #endif | 198 | #endif |
199 | 199 | ||
200 | typedef phys_addr_t resource_size_t; | ||
201 | |||
200 | struct ustat { | 202 | struct ustat { |
201 | __kernel_daddr_t f_tfree; | 203 | __kernel_daddr_t f_tfree; |
202 | __kernel_ino_t f_tinode; | 204 | __kernel_ino_t f_tinode; |
diff --git a/include/linux/usb.h b/include/linux/usb.h index 94ac74aba6b6..8fa973bede5e 100644 --- a/include/linux/usb.h +++ b/include/linux/usb.h | |||
@@ -1135,6 +1135,7 @@ struct usb_anchor { | |||
1135 | struct list_head urb_list; | 1135 | struct list_head urb_list; |
1136 | wait_queue_head_t wait; | 1136 | wait_queue_head_t wait; |
1137 | spinlock_t lock; | 1137 | spinlock_t lock; |
1138 | unsigned int poisoned:1; | ||
1138 | }; | 1139 | }; |
1139 | 1140 | ||
1140 | static inline void init_usb_anchor(struct usb_anchor *anchor) | 1141 | static inline void init_usb_anchor(struct usb_anchor *anchor) |
@@ -1459,12 +1460,18 @@ extern struct urb *usb_get_urb(struct urb *urb); | |||
1459 | extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags); | 1460 | extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags); |
1460 | extern int usb_unlink_urb(struct urb *urb); | 1461 | extern int usb_unlink_urb(struct urb *urb); |
1461 | extern void usb_kill_urb(struct urb *urb); | 1462 | extern void usb_kill_urb(struct urb *urb); |
1463 | extern void usb_poison_urb(struct urb *urb); | ||
1464 | extern void usb_unpoison_urb(struct urb *urb); | ||
1462 | extern void usb_kill_anchored_urbs(struct usb_anchor *anchor); | 1465 | extern void usb_kill_anchored_urbs(struct usb_anchor *anchor); |
1466 | extern void usb_poison_anchored_urbs(struct usb_anchor *anchor); | ||
1463 | extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor); | 1467 | extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor); |
1464 | extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor); | 1468 | extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor); |
1465 | extern void usb_unanchor_urb(struct urb *urb); | 1469 | extern void usb_unanchor_urb(struct urb *urb); |
1466 | extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor, | 1470 | extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor, |
1467 | unsigned int timeout); | 1471 | unsigned int timeout); |
1472 | extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor); | ||
1473 | extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor); | ||
1474 | extern int usb_anchor_empty(struct usb_anchor *anchor); | ||
1468 | 1475 | ||
1469 | /** | 1476 | /** |
1470 | * usb_urb_dir_in - check if an URB describes an IN transfer | 1477 | * usb_urb_dir_in - check if an URB describes an IN transfer |
diff --git a/include/linux/usb/Kbuild b/include/linux/usb/Kbuild index 42e84fc315e3..54c446309a2a 100644 --- a/include/linux/usb/Kbuild +++ b/include/linux/usb/Kbuild | |||
@@ -4,4 +4,5 @@ header-y += ch9.h | |||
4 | header-y += gadgetfs.h | 4 | header-y += gadgetfs.h |
5 | header-y += midi.h | 5 | header-y += midi.h |
6 | header-y += g_printer.h | 6 | header-y += g_printer.h |
7 | 7 | header-y += tmc.h | |
8 | header-y += vstusb.h | ||
diff --git a/include/linux/usb/cdc.h b/include/linux/usb/cdc.h index ca228bb94218..18a729343ffa 100644 --- a/include/linux/usb/cdc.h +++ b/include/linux/usb/cdc.h | |||
@@ -160,6 +160,15 @@ struct usb_cdc_mdlm_detail_desc { | |||
160 | __u8 bDetailData[0]; | 160 | __u8 bDetailData[0]; |
161 | } __attribute__ ((packed)); | 161 | } __attribute__ ((packed)); |
162 | 162 | ||
163 | /* "OBEX Control Model Functional Descriptor" */ | ||
164 | struct usb_cdc_obex_desc { | ||
165 | __u8 bLength; | ||
166 | __u8 bDescriptorType; | ||
167 | __u8 bDescriptorSubType; | ||
168 | |||
169 | __le16 bcdVersion; | ||
170 | } __attribute__ ((packed)); | ||
171 | |||
163 | /*-------------------------------------------------------------------------*/ | 172 | /*-------------------------------------------------------------------------*/ |
164 | 173 | ||
165 | /* | 174 | /* |
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h index c932390c6da0..935c380ffe47 100644 --- a/include/linux/usb/composite.h +++ b/include/linux/usb/composite.h | |||
@@ -130,6 +130,9 @@ struct usb_function { | |||
130 | 130 | ||
131 | int usb_add_function(struct usb_configuration *, struct usb_function *); | 131 | int usb_add_function(struct usb_configuration *, struct usb_function *); |
132 | 132 | ||
133 | int usb_function_deactivate(struct usb_function *); | ||
134 | int usb_function_activate(struct usb_function *); | ||
135 | |||
133 | int usb_interface_id(struct usb_configuration *, struct usb_function *); | 136 | int usb_interface_id(struct usb_configuration *, struct usb_function *); |
134 | 137 | ||
135 | /** | 138 | /** |
@@ -316,9 +319,13 @@ struct usb_composite_dev { | |||
316 | struct usb_composite_driver *driver; | 319 | struct usb_composite_driver *driver; |
317 | u8 next_string_id; | 320 | u8 next_string_id; |
318 | 321 | ||
319 | spinlock_t lock; | 322 | /* the gadget driver won't enable the data pullup |
323 | * while the deactivation count is nonzero. | ||
324 | */ | ||
325 | unsigned deactivations; | ||
320 | 326 | ||
321 | /* REVISIT use and existence of lock ... */ | 327 | /* protects at least deactivation count */ |
328 | spinlock_t lock; | ||
322 | }; | 329 | }; |
323 | 330 | ||
324 | extern int usb_string_id(struct usb_composite_dev *c); | 331 | extern int usb_string_id(struct usb_composite_dev *c); |
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h index 655341d0f534..0b8617a9176d 100644 --- a/include/linux/usb/serial.h +++ b/include/linux/usb/serial.h | |||
@@ -192,7 +192,7 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data) | |||
192 | * The driver.owner field should be set to the module owner of this driver. | 192 | * The driver.owner field should be set to the module owner of this driver. |
193 | * The driver.name field should be set to the name of this driver (remember | 193 | * The driver.name field should be set to the name of this driver (remember |
194 | * it will show up in sysfs, so it needs to be short and to the point. | 194 | * it will show up in sysfs, so it needs to be short and to the point. |
195 | * Useing the module name is a good idea.) | 195 | * Using the module name is a good idea.) |
196 | */ | 196 | */ |
197 | struct usb_serial_driver { | 197 | struct usb_serial_driver { |
198 | const char *description; | 198 | const char *description; |
diff --git a/include/linux/usb/tmc.h b/include/linux/usb/tmc.h new file mode 100644 index 000000000000..c045ae12556c --- /dev/null +++ b/include/linux/usb/tmc.h | |||
@@ -0,0 +1,43 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany | ||
3 | * Copyright (C) 2008 Novell, Inc. | ||
4 | * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de> | ||
5 | * | ||
6 | * This file holds USB constants defined by the USB Device Class | ||
7 | * Definition for Test and Measurement devices published by the USB-IF. | ||
8 | * | ||
9 | * It also has the ioctl definitions for the usbtmc kernel driver that | ||
10 | * userspace needs to know about. | ||
11 | */ | ||
12 | |||
13 | #ifndef __LINUX_USB_TMC_H | ||
14 | #define __LINUX_USB_TMC_H | ||
15 | |||
16 | /* USB TMC status values */ | ||
17 | #define USBTMC_STATUS_SUCCESS 0x01 | ||
18 | #define USBTMC_STATUS_PENDING 0x02 | ||
19 | #define USBTMC_STATUS_FAILED 0x80 | ||
20 | #define USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS 0x81 | ||
21 | #define USBTMC_STATUS_SPLIT_NOT_IN_PROGRESS 0x82 | ||
22 | #define USBTMC_STATUS_SPLIT_IN_PROGRESS 0x83 | ||
23 | |||
24 | /* USB TMC requests values */ | ||
25 | #define USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT 1 | ||
26 | #define USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS 2 | ||
27 | #define USBTMC_REQUEST_INITIATE_ABORT_BULK_IN 3 | ||
28 | #define USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS 4 | ||
29 | #define USBTMC_REQUEST_INITIATE_CLEAR 5 | ||
30 | #define USBTMC_REQUEST_CHECK_CLEAR_STATUS 6 | ||
31 | #define USBTMC_REQUEST_GET_CAPABILITIES 7 | ||
32 | #define USBTMC_REQUEST_INDICATOR_PULSE 64 | ||
33 | |||
34 | /* Request values for USBTMC driver's ioctl entry point */ | ||
35 | #define USBTMC_IOC_NR 91 | ||
36 | #define USBTMC_IOCTL_INDICATOR_PULSE _IO(USBTMC_IOC_NR, 1) | ||
37 | #define USBTMC_IOCTL_CLEAR _IO(USBTMC_IOC_NR, 2) | ||
38 | #define USBTMC_IOCTL_ABORT_BULK_OUT _IO(USBTMC_IOC_NR, 3) | ||
39 | #define USBTMC_IOCTL_ABORT_BULK_IN _IO(USBTMC_IOC_NR, 4) | ||
40 | #define USBTMC_IOCTL_CLEAR_OUT_HALT _IO(USBTMC_IOC_NR, 6) | ||
41 | #define USBTMC_IOCTL_CLEAR_IN_HALT _IO(USBTMC_IOC_NR, 7) | ||
42 | |||
43 | #endif | ||
diff --git a/include/linux/usb/vstusb.h b/include/linux/usb/vstusb.h new file mode 100644 index 000000000000..1cfac67191ff --- /dev/null +++ b/include/linux/usb/vstusb.h | |||
@@ -0,0 +1,71 @@ | |||
1 | /***************************************************************************** | ||
2 | * File: drivers/usb/misc/vstusb.h | ||
3 | * | ||
4 | * Purpose: Support for the bulk USB Vernier Spectrophotometers | ||
5 | * | ||
6 | * Author: EQware Engineering, Inc. | ||
7 | * Oregon City, OR, USA 97045 | ||
8 | * | ||
9 | * Copyright: 2007, 2008 | ||
10 | * Vernier Software & Technology | ||
11 | * Beaverton, OR, USA 97005 | ||
12 | * | ||
13 | * Web: www.vernier.com | ||
14 | * | ||
15 | * This program is free software; you can redistribute it and/or modify | ||
16 | * it under the terms of the GNU General Public License version 2 as | ||
17 | * published by the Free Software Foundation. | ||
18 | * | ||
19 | *****************************************************************************/ | ||
20 | /***************************************************************************** | ||
21 | * | ||
22 | * The vstusb module is a standard usb 'client' driver running on top of the | ||
23 | * standard usb host controller stack. | ||
24 | * | ||
25 | * In general, vstusb supports standard bulk usb pipes. It supports multiple | ||
26 | * devices and multiple pipes per device. | ||
27 | * | ||
28 | * The vstusb driver supports two interfaces: | ||
29 | * 1 - ioctl SEND_PIPE/RECV_PIPE - a general bulk write/read msg | ||
30 | * interface to any pipe with timeout support; | ||
31 | * 2 - standard read/write with ioctl config - offers standard read/write | ||
32 | * interface with ioctl configured pipes and timeouts. | ||
33 | * | ||
34 | * Both interfaces can be signal from other process and will abort its i/o | ||
35 | * operation. | ||
36 | * | ||
37 | * A timeout of 0 means NO timeout. The user can still terminate the read via | ||
38 | * signal. | ||
39 | * | ||
40 | * If using multiple threads with this driver, the user should ensure that | ||
41 | * any reads, writes, or ioctls are complete before closing the device. | ||
42 | * Changing read/write timeouts or pipes takes effect on next read/write. | ||
43 | * | ||
44 | *****************************************************************************/ | ||
45 | |||
46 | struct vstusb_args { | ||
47 | union { | ||
48 | /* this struct is used for IOCTL_VSTUSB_SEND_PIPE, * | ||
49 | * IOCTL_VSTUSB_RECV_PIPE, and read()/write() fops */ | ||
50 | struct { | ||
51 | void __user *buffer; | ||
52 | size_t count; | ||
53 | unsigned int timeout_ms; | ||
54 | int pipe; | ||
55 | }; | ||
56 | |||
57 | /* this one is used for IOCTL_VSTUSB_CONFIG_RW */ | ||
58 | struct { | ||
59 | int rd_pipe; | ||
60 | int rd_timeout_ms; | ||
61 | int wr_pipe; | ||
62 | int wr_timeout_ms; | ||
63 | }; | ||
64 | }; | ||
65 | }; | ||
66 | |||
67 | #define VST_IOC_MAGIC 'L' | ||
68 | #define VST_IOC_FIRST 0x20 | ||
69 | #define IOCTL_VSTUSB_SEND_PIPE _IO(VST_IOC_MAGIC, VST_IOC_FIRST) | ||
70 | #define IOCTL_VSTUSB_RECV_PIPE _IO(VST_IOC_MAGIC, VST_IOC_FIRST + 1) | ||
71 | #define IOCTL_VSTUSB_CONFIG_RW _IO(VST_IOC_MAGIC, VST_IOC_FIRST + 2) | ||
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h index 328eb4022727..4c28c4d564e2 100644 --- a/include/linux/vmalloc.h +++ b/include/linux/vmalloc.h | |||
@@ -2,6 +2,7 @@ | |||
2 | #define _LINUX_VMALLOC_H | 2 | #define _LINUX_VMALLOC_H |
3 | 3 | ||
4 | #include <linux/spinlock.h> | 4 | #include <linux/spinlock.h> |
5 | #include <linux/init.h> | ||
5 | #include <asm/page.h> /* pgprot_t */ | 6 | #include <asm/page.h> /* pgprot_t */ |
6 | 7 | ||
7 | struct vm_area_struct; /* vma defining user mapping in mm_types.h */ | 8 | struct vm_area_struct; /* vma defining user mapping in mm_types.h */ |
@@ -23,7 +24,6 @@ struct vm_area_struct; /* vma defining user mapping in mm_types.h */ | |||
23 | #endif | 24 | #endif |
24 | 25 | ||
25 | struct vm_struct { | 26 | struct vm_struct { |
26 | /* keep next,addr,size together to speedup lookups */ | ||
27 | struct vm_struct *next; | 27 | struct vm_struct *next; |
28 | void *addr; | 28 | void *addr; |
29 | unsigned long size; | 29 | unsigned long size; |
@@ -37,6 +37,19 @@ struct vm_struct { | |||
37 | /* | 37 | /* |
38 | * Highlevel APIs for driver use | 38 | * Highlevel APIs for driver use |
39 | */ | 39 | */ |
40 | extern void vm_unmap_ram(const void *mem, unsigned int count); | ||
41 | extern void *vm_map_ram(struct page **pages, unsigned int count, | ||
42 | int node, pgprot_t prot); | ||
43 | extern void vm_unmap_aliases(void); | ||
44 | |||
45 | #ifdef CONFIG_MMU | ||
46 | extern void __init vmalloc_init(void); | ||
47 | #else | ||
48 | static inline void vmalloc_init(void) | ||
49 | { | ||
50 | } | ||
51 | #endif | ||
52 | |||
40 | extern void *vmalloc(unsigned long size); | 53 | extern void *vmalloc(unsigned long size); |
41 | extern void *vmalloc_user(unsigned long size); | 54 | extern void *vmalloc_user(unsigned long size); |
42 | extern void *vmalloc_node(unsigned long size, int node); | 55 | extern void *vmalloc_node(unsigned long size, int node); |
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h index 58334d439516..9cd3ab0f554d 100644 --- a/include/linux/vmstat.h +++ b/include/linux/vmstat.h | |||
@@ -41,6 +41,16 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT, | |||
41 | #ifdef CONFIG_HUGETLB_PAGE | 41 | #ifdef CONFIG_HUGETLB_PAGE |
42 | HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL, | 42 | HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL, |
43 | #endif | 43 | #endif |
44 | #ifdef CONFIG_UNEVICTABLE_LRU | ||
45 | UNEVICTABLE_PGCULLED, /* culled to noreclaim list */ | ||
46 | UNEVICTABLE_PGSCANNED, /* scanned for reclaimability */ | ||
47 | UNEVICTABLE_PGRESCUED, /* rescued from noreclaim list */ | ||
48 | UNEVICTABLE_PGMLOCKED, | ||
49 | UNEVICTABLE_PGMUNLOCKED, | ||
50 | UNEVICTABLE_PGCLEARED, /* on COW, page truncate */ | ||
51 | UNEVICTABLE_PGSTRANDED, /* unable to isolate on unlock */ | ||
52 | UNEVICTABLE_MLOCKFREED, | ||
53 | #endif | ||
44 | NR_VM_EVENT_ITEMS | 54 | NR_VM_EVENT_ITEMS |
45 | }; | 55 | }; |
46 | 56 | ||
@@ -159,6 +169,16 @@ static inline unsigned long zone_page_state(struct zone *zone, | |||
159 | return x; | 169 | return x; |
160 | } | 170 | } |
161 | 171 | ||
172 | extern unsigned long global_lru_pages(void); | ||
173 | |||
174 | static inline unsigned long zone_lru_pages(struct zone *zone) | ||
175 | { | ||
176 | return (zone_page_state(zone, NR_ACTIVE_ANON) | ||
177 | + zone_page_state(zone, NR_ACTIVE_FILE) | ||
178 | + zone_page_state(zone, NR_INACTIVE_ANON) | ||
179 | + zone_page_state(zone, NR_INACTIVE_FILE)); | ||
180 | } | ||
181 | |||
162 | #ifdef CONFIG_NUMA | 182 | #ifdef CONFIG_NUMA |
163 | /* | 183 | /* |
164 | * Determine the per node value of a stat item. This function | 184 | * Determine the per node value of a stat item. This function |
diff --git a/include/linux/wait.h b/include/linux/wait.h index 0081147a9fe8..ef609f842fac 100644 --- a/include/linux/wait.h +++ b/include/linux/wait.h | |||
@@ -108,15 +108,6 @@ static inline int waitqueue_active(wait_queue_head_t *q) | |||
108 | return !list_empty(&q->task_list); | 108 | return !list_empty(&q->task_list); |
109 | } | 109 | } |
110 | 110 | ||
111 | /* | ||
112 | * Used to distinguish between sync and async io wait context: | ||
113 | * sync i/o typically specifies a NULL wait queue entry or a wait | ||
114 | * queue entry bound to a task (current task) to wake up. | ||
115 | * aio specifies a wait queue entry with an async notification | ||
116 | * callback routine, not associated with any task. | ||
117 | */ | ||
118 | #define is_sync_wait(wait) (!(wait) || ((wait)->private)) | ||
119 | |||
120 | extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait); | 111 | extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait); |
121 | extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait); | 112 | extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait); |
122 | extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait); | 113 | extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait); |
diff --git a/include/linux/writeback.h b/include/linux/writeback.h index 12b15c561a1f..e585657e9831 100644 --- a/include/linux/writeback.h +++ b/include/linux/writeback.h | |||
@@ -63,7 +63,15 @@ struct writeback_control { | |||
63 | unsigned for_writepages:1; /* This is a writepages() call */ | 63 | unsigned for_writepages:1; /* This is a writepages() call */ |
64 | unsigned range_cyclic:1; /* range_start is cyclic */ | 64 | unsigned range_cyclic:1; /* range_start is cyclic */ |
65 | unsigned more_io:1; /* more io to be dispatched */ | 65 | unsigned more_io:1; /* more io to be dispatched */ |
66 | unsigned range_cont:1; | 66 | /* |
67 | * write_cache_pages() won't update wbc->nr_to_write and | ||
68 | * mapping->writeback_index if no_nrwrite_index_update | ||
69 | * is set. write_cache_pages() may write more than we | ||
70 | * requested and we want to make sure nr_to_write and | ||
71 | * writeback_index are updated in a consistent manner | ||
72 | * so we use a single control to update them | ||
73 | */ | ||
74 | unsigned no_nrwrite_index_update:1; | ||
67 | }; | 75 | }; |
68 | 76 | ||
69 | /* | 77 | /* |
diff --git a/include/math-emu/op-2.h b/include/math-emu/op-2.h index e193fb08fd55..4f26ecc1411b 100644 --- a/include/math-emu/op-2.h +++ b/include/math-emu/op-2.h | |||
@@ -25,7 +25,7 @@ | |||
25 | #ifndef __MATH_EMU_OP_2_H__ | 25 | #ifndef __MATH_EMU_OP_2_H__ |
26 | #define __MATH_EMU_OP_2_H__ | 26 | #define __MATH_EMU_OP_2_H__ |
27 | 27 | ||
28 | #define _FP_FRAC_DECL_2(X) _FP_W_TYPE X##_f0, X##_f1 | 28 | #define _FP_FRAC_DECL_2(X) _FP_W_TYPE X##_f0 = 0, X##_f1 = 0 |
29 | #define _FP_FRAC_COPY_2(D,S) (D##_f0 = S##_f0, D##_f1 = S##_f1) | 29 | #define _FP_FRAC_COPY_2(D,S) (D##_f0 = S##_f0, D##_f1 = S##_f1) |
30 | #define _FP_FRAC_SET_2(X,I) __FP_FRAC_SET_2(X, I) | 30 | #define _FP_FRAC_SET_2(X,I) __FP_FRAC_SET_2(X, I) |
31 | #define _FP_FRAC_HIGH_2(X) (X##_f1) | 31 | #define _FP_FRAC_HIGH_2(X) (X##_f1) |
diff --git a/include/math-emu/op-common.h b/include/math-emu/op-common.h index bb46e7645d53..cc1ec396f8d6 100644 --- a/include/math-emu/op-common.h +++ b/include/math-emu/op-common.h | |||
@@ -73,7 +73,7 @@ do { \ | |||
73 | X##_c = FP_CLS_NAN; \ | 73 | X##_c = FP_CLS_NAN; \ |
74 | /* Check for signaling NaN */ \ | 74 | /* Check for signaling NaN */ \ |
75 | if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \ | 75 | if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \ |
76 | FP_SET_EXCEPTION(FP_EX_INVALID); \ | 76 | FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_SNAN); \ |
77 | } \ | 77 | } \ |
78 | break; \ | 78 | break; \ |
79 | } \ | 79 | } \ |
@@ -324,7 +324,7 @@ do { \ | |||
324 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ | 324 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ |
325 | R##_s = _FP_NANSIGN_##fs; \ | 325 | R##_s = _FP_NANSIGN_##fs; \ |
326 | R##_c = FP_CLS_NAN; \ | 326 | R##_c = FP_CLS_NAN; \ |
327 | FP_SET_EXCEPTION(FP_EX_INVALID); \ | 327 | FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_ISI); \ |
328 | break; \ | 328 | break; \ |
329 | } \ | 329 | } \ |
330 | /* FALLTHRU */ \ | 330 | /* FALLTHRU */ \ |
@@ -431,7 +431,7 @@ do { \ | |||
431 | R##_s = _FP_NANSIGN_##fs; \ | 431 | R##_s = _FP_NANSIGN_##fs; \ |
432 | R##_c = FP_CLS_NAN; \ | 432 | R##_c = FP_CLS_NAN; \ |
433 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ | 433 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ |
434 | FP_SET_EXCEPTION(FP_EX_INVALID); \ | 434 | FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_IMZ);\ |
435 | break; \ | 435 | break; \ |
436 | \ | 436 | \ |
437 | default: \ | 437 | default: \ |
@@ -490,11 +490,15 @@ do { \ | |||
490 | break; \ | 490 | break; \ |
491 | \ | 491 | \ |
492 | case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ | 492 | case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ |
493 | R##_s = _FP_NANSIGN_##fs; \ | ||
494 | R##_c = FP_CLS_NAN; \ | ||
495 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ | ||
496 | FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_IDI);\ | ||
493 | case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ | 497 | case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ |
494 | R##_s = _FP_NANSIGN_##fs; \ | 498 | R##_s = _FP_NANSIGN_##fs; \ |
495 | R##_c = FP_CLS_NAN; \ | 499 | R##_c = FP_CLS_NAN; \ |
496 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ | 500 | _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ |
497 | FP_SET_EXCEPTION(FP_EX_INVALID); \ | 501 | FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_ZDZ);\ |
498 | break; \ | 502 | break; \ |
499 | \ | 503 | \ |
500 | default: \ | 504 | default: \ |
diff --git a/include/math-emu/soft-fp.h b/include/math-emu/soft-fp.h index a6f873b45f98..3f284bc03180 100644 --- a/include/math-emu/soft-fp.h +++ b/include/math-emu/soft-fp.h | |||
@@ -51,6 +51,25 @@ | |||
51 | #ifndef FP_EX_INVALID | 51 | #ifndef FP_EX_INVALID |
52 | #define FP_EX_INVALID 0 | 52 | #define FP_EX_INVALID 0 |
53 | #endif | 53 | #endif |
54 | #ifndef FP_EX_INVALID_SNAN | ||
55 | #define FP_EX_INVALID_SNAN 0 | ||
56 | #endif | ||
57 | /* inf - inf */ | ||
58 | #ifndef FP_EX_INVALID_ISI | ||
59 | #define FP_EX_INVALID_ISI 0 | ||
60 | #endif | ||
61 | /* inf / inf */ | ||
62 | #ifndef FP_EX_INVALID_IDI | ||
63 | #define FP_EX_INVALID_IDI 0 | ||
64 | #endif | ||
65 | /* 0 / 0 */ | ||
66 | #ifndef FP_EX_INVALID_ZDZ | ||
67 | #define FP_EX_INVALID_ZDZ 0 | ||
68 | #endif | ||
69 | /* inf * 0 */ | ||
70 | #ifndef FP_EX_INVALID_IMZ | ||
71 | #define FP_EX_INVALID_IMZ 0 | ||
72 | #endif | ||
54 | #ifndef FP_EX_OVERFLOW | 73 | #ifndef FP_EX_OVERFLOW |
55 | #define FP_EX_OVERFLOW 0 | 74 | #define FP_EX_OVERFLOW 0 |
56 | #endif | 75 | #endif |
diff --git a/include/media/saa7146.h b/include/media/saa7146.h index 64a2ec746a3e..c5a6e22a4b37 100644 --- a/include/media/saa7146.h +++ b/include/media/saa7146.h | |||
@@ -24,7 +24,7 @@ | |||
24 | 24 | ||
25 | extern unsigned int saa7146_debug; | 25 | extern unsigned int saa7146_debug; |
26 | 26 | ||
27 | //#define DEBUG_PROLOG printk("(0x%08x)(0x%08x) %s: %s(): ",(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,RPS_ADDR0))),(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,IER))),KBUILD_MODNAME,__FUNCTION__) | 27 | //#define DEBUG_PROLOG printk("(0x%08x)(0x%08x) %s: %s(): ",(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,RPS_ADDR0))),(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,IER))),KBUILD_MODNAME,__func__) |
28 | 28 | ||
29 | #ifndef DEBUG_VARIABLE | 29 | #ifndef DEBUG_VARIABLE |
30 | #define DEBUG_VARIABLE saa7146_debug | 30 | #define DEBUG_VARIABLE saa7146_debug |
diff --git a/include/media/soc_camera_platform.h b/include/media/soc_camera_platform.h index 851f18220984..1d092b4678aa 100644 --- a/include/media/soc_camera_platform.h +++ b/include/media/soc_camera_platform.h | |||
@@ -1,3 +1,13 @@ | |||
1 | /* | ||
2 | * Generic Platform Camera Driver Header | ||
3 | * | ||
4 | * Copyright (C) 2008 Magnus Damm | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License version 2 as | ||
8 | * published by the Free Software Foundation. | ||
9 | */ | ||
10 | |||
1 | #ifndef __SOC_CAMERA_H__ | 11 | #ifndef __SOC_CAMERA_H__ |
2 | #define __SOC_CAMERA_H__ | 12 | #define __SOC_CAMERA_H__ |
3 | 13 | ||
@@ -9,6 +19,7 @@ struct soc_camera_platform_info { | |||
9 | unsigned long format_depth; | 19 | unsigned long format_depth; |
10 | struct v4l2_pix_format format; | 20 | struct v4l2_pix_format format; |
11 | unsigned long bus_param; | 21 | unsigned long bus_param; |
22 | void (*power)(int); | ||
12 | int (*set_capture)(struct soc_camera_platform_info *info, int enable); | 23 | int (*set_capture)(struct soc_camera_platform_info *info, int enable); |
13 | }; | 24 | }; |
14 | 25 | ||
diff --git a/include/media/tuner.h b/include/media/tuner.h index 67c1f514d0e2..7d4e2db78076 100644 --- a/include/media/tuner.h +++ b/include/media/tuner.h | |||
@@ -123,6 +123,7 @@ | |||
123 | #define TUNER_TEA5761 75 /* Only FM Radio Tuner */ | 123 | #define TUNER_TEA5761 75 /* Only FM Radio Tuner */ |
124 | #define TUNER_XC5000 76 /* Xceive Silicon Tuner */ | 124 | #define TUNER_XC5000 76 /* Xceive Silicon Tuner */ |
125 | #define TUNER_TCL_MF02GIP_5N 77 /* TCL MF02GIP_5N */ | 125 | #define TUNER_TCL_MF02GIP_5N 77 /* TCL MF02GIP_5N */ |
126 | #define TUNER_PHILIPS_FMD1216MEX_MK3 78 | ||
126 | 127 | ||
127 | /* tv card specific */ | 128 | /* tv card specific */ |
128 | #define TDA9887_PRESENT (1<<0) | 129 | #define TDA9887_PRESENT (1<<0) |
diff --git a/include/media/v4l2-i2c-drv-legacy.h b/include/media/v4l2-i2c-drv-legacy.h index 975ffbf4e2c5..e65dd9d84e8b 100644 --- a/include/media/v4l2-i2c-drv-legacy.h +++ b/include/media/v4l2-i2c-drv-legacy.h | |||
@@ -21,6 +21,17 @@ | |||
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | 21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | /* NOTE: the full version of this header is in the v4l-dvb repository | ||
25 | * and allows v4l i2c drivers to be compiled on older kernels as well. | ||
26 | * The version of this header as it appears in the kernel is a stripped | ||
27 | * version (without all the backwards compatibility stuff) and so it | ||
28 | * looks a bit odd. | ||
29 | * | ||
30 | * If you look at the full version then you will understand the reason | ||
31 | * for introducing this header since you really don't want to have all | ||
32 | * the tricky backwards compatibility code in each and every i2c driver. | ||
33 | */ | ||
34 | |||
24 | struct v4l2_i2c_driver_data { | 35 | struct v4l2_i2c_driver_data { |
25 | const char * const name; | 36 | const char * const name; |
26 | int driverid; | 37 | int driverid; |
diff --git a/include/media/v4l2-i2c-drv.h b/include/media/v4l2-i2c-drv.h index 40ecef29801d..efdc8bf27f87 100644 --- a/include/media/v4l2-i2c-drv.h +++ b/include/media/v4l2-i2c-drv.h | |||
@@ -21,6 +21,17 @@ | |||
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | 21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | /* NOTE: the full version of this header is in the v4l-dvb repository | ||
25 | * and allows v4l i2c drivers to be compiled on older kernels as well. | ||
26 | * The version of this header as it appears in the kernel is a stripped | ||
27 | * version (without all the backwards compatibility stuff) and so it | ||
28 | * looks a bit odd. | ||
29 | * | ||
30 | * If you look at the full version then you will understand the reason | ||
31 | * for introducing this header since you really don't want to have all | ||
32 | * the tricky backwards compatibility code in each and every i2c driver. | ||
33 | */ | ||
34 | |||
24 | #ifndef __V4L2_I2C_DRV_H__ | 35 | #ifndef __V4L2_I2C_DRV_H__ |
25 | #define __V4L2_I2C_DRV_H__ | 36 | #define __V4L2_I2C_DRV_H__ |
26 | 37 | ||
diff --git a/include/media/videobuf-dvb.h b/include/media/videobuf-dvb.h index b77748696329..80471c2b6343 100644 --- a/include/media/videobuf-dvb.h +++ b/include/media/videobuf-dvb.h | |||
@@ -16,7 +16,6 @@ struct videobuf_dvb { | |||
16 | int nfeeds; | 16 | int nfeeds; |
17 | 17 | ||
18 | /* videobuf_dvb_(un)register manges this */ | 18 | /* videobuf_dvb_(un)register manges this */ |
19 | struct dvb_adapter adapter; | ||
20 | struct dvb_demux demux; | 19 | struct dvb_demux demux; |
21 | struct dmxdev dmxdev; | 20 | struct dmxdev dmxdev; |
22 | struct dmx_frontend fe_hw; | 21 | struct dmx_frontend fe_hw; |
@@ -24,12 +23,34 @@ struct videobuf_dvb { | |||
24 | struct dvb_net net; | 23 | struct dvb_net net; |
25 | }; | 24 | }; |
26 | 25 | ||
27 | int videobuf_dvb_register(struct videobuf_dvb *dvb, | 26 | struct videobuf_dvb_frontend { |
27 | struct list_head felist; | ||
28 | int id; | ||
29 | struct videobuf_dvb dvb; | ||
30 | }; | ||
31 | |||
32 | struct videobuf_dvb_frontends { | ||
33 | struct list_head felist; | ||
34 | struct mutex lock; | ||
35 | struct dvb_adapter adapter; | ||
36 | int active_fe_id; /* Indicates which frontend in the felist is in use */ | ||
37 | int gate; /* Frontend with gate control 0=!MFE,1=fe0,2=fe1 etc */ | ||
38 | }; | ||
39 | |||
40 | int videobuf_dvb_register_bus(struct videobuf_dvb_frontends *f, | ||
28 | struct module *module, | 41 | struct module *module, |
29 | void *adapter_priv, | 42 | void *adapter_priv, |
30 | struct device *device, | 43 | struct device *device, |
31 | short *adapter_nr); | 44 | short *adapter_nr, |
32 | void videobuf_dvb_unregister(struct videobuf_dvb *dvb); | 45 | int mfe_shared); |
46 | |||
47 | void videobuf_dvb_unregister_bus(struct videobuf_dvb_frontends *f); | ||
48 | |||
49 | struct videobuf_dvb_frontend * videobuf_dvb_alloc_frontend(struct videobuf_dvb_frontends *f, int id); | ||
50 | |||
51 | struct videobuf_dvb_frontend * videobuf_dvb_get_frontend(struct videobuf_dvb_frontends *f, int id); | ||
52 | int videobuf_dvb_find_frontend(struct videobuf_dvb_frontends *f, struct dvb_frontend *p); | ||
53 | |||
33 | 54 | ||
34 | /* | 55 | /* |
35 | * Local variables: | 56 | * Local variables: |
diff --git a/include/net/9p/9p.h b/include/net/9p/9p.h index c3626c0ba9d3..d2c60c73619d 100644 --- a/include/net/9p/9p.h +++ b/include/net/9p/9p.h | |||
@@ -27,8 +27,6 @@ | |||
27 | #ifndef NET_9P_H | 27 | #ifndef NET_9P_H |
28 | #define NET_9P_H | 28 | #define NET_9P_H |
29 | 29 | ||
30 | #ifdef CONFIG_NET_9P_DEBUG | ||
31 | |||
32 | /** | 30 | /** |
33 | * enum p9_debug_flags - bits for mount time debug parameter | 31 | * enum p9_debug_flags - bits for mount time debug parameter |
34 | * @P9_DEBUG_ERROR: more verbose error messages including original error string | 32 | * @P9_DEBUG_ERROR: more verbose error messages including original error string |
@@ -39,6 +37,7 @@ | |||
39 | * @P9_DEBUG_TRANS: transport tracing | 37 | * @P9_DEBUG_TRANS: transport tracing |
40 | * @P9_DEBUG_SLABS: memory management tracing | 38 | * @P9_DEBUG_SLABS: memory management tracing |
41 | * @P9_DEBUG_FCALL: verbose dump of protocol messages | 39 | * @P9_DEBUG_FCALL: verbose dump of protocol messages |
40 | * @P9_DEBUG_FID: fid allocation/deallocation tracking | ||
42 | * | 41 | * |
43 | * These flags are passed at mount time to turn on various levels of | 42 | * These flags are passed at mount time to turn on various levels of |
44 | * verbosity and tracing which will be output to the system logs. | 43 | * verbosity and tracing which will be output to the system logs. |
@@ -53,30 +52,33 @@ enum p9_debug_flags { | |||
53 | P9_DEBUG_TRANS = (1<<6), | 52 | P9_DEBUG_TRANS = (1<<6), |
54 | P9_DEBUG_SLABS = (1<<7), | 53 | P9_DEBUG_SLABS = (1<<7), |
55 | P9_DEBUG_FCALL = (1<<8), | 54 | P9_DEBUG_FCALL = (1<<8), |
55 | P9_DEBUG_FID = (1<<9), | ||
56 | P9_DEBUG_PKT = (1<<10), | ||
56 | }; | 57 | }; |
57 | 58 | ||
58 | extern unsigned int p9_debug_level; | 59 | extern unsigned int p9_debug_level; |
59 | 60 | ||
61 | #ifdef CONFIG_NET_9P_DEBUG | ||
60 | #define P9_DPRINTK(level, format, arg...) \ | 62 | #define P9_DPRINTK(level, format, arg...) \ |
61 | do { \ | 63 | do { \ |
62 | if ((p9_debug_level & level) == level) \ | 64 | if ((p9_debug_level & level) == level) {\ |
63 | printk(KERN_NOTICE "-- %s (%d): " \ | 65 | if (level == P9_DEBUG_9P) \ |
64 | format , __FUNCTION__, task_pid_nr(current) , ## arg); \ | 66 | printk(KERN_NOTICE "(%8.8d) " \ |
67 | format , task_pid_nr(current) , ## arg); \ | ||
68 | else \ | ||
69 | printk(KERN_NOTICE "-- %s (%d): " \ | ||
70 | format , __func__, task_pid_nr(current) , ## arg); \ | ||
71 | } \ | ||
65 | } while (0) | 72 | } while (0) |
66 | 73 | ||
67 | #define PRINT_FCALL_ERROR(s, fcall) P9_DPRINTK(P9_DEBUG_ERROR, \ | ||
68 | "%s: %.*s\n", s, fcall?fcall->params.rerror.error.len:0, \ | ||
69 | fcall?fcall->params.rerror.error.str:""); | ||
70 | |||
71 | #else | 74 | #else |
72 | #define P9_DPRINTK(level, format, arg...) do { } while (0) | 75 | #define P9_DPRINTK(level, format, arg...) do { } while (0) |
73 | #define PRINT_FCALL_ERROR(s, fcall) do { } while (0) | ||
74 | #endif | 76 | #endif |
75 | 77 | ||
76 | #define P9_EPRINTK(level, format, arg...) \ | 78 | #define P9_EPRINTK(level, format, arg...) \ |
77 | do { \ | 79 | do { \ |
78 | printk(level "9p: %s (%d): " \ | 80 | printk(level "9p: %s (%d): " \ |
79 | format , __FUNCTION__, task_pid_nr(current), ## arg); \ | 81 | format , __func__, task_pid_nr(current), ## arg); \ |
80 | } while (0) | 82 | } while (0) |
81 | 83 | ||
82 | /** | 84 | /** |
@@ -325,33 +327,6 @@ struct p9_qid { | |||
325 | * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat | 327 | * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat |
326 | */ | 328 | */ |
327 | 329 | ||
328 | struct p9_stat { | ||
329 | u16 size; | ||
330 | u16 type; | ||
331 | u32 dev; | ||
332 | struct p9_qid qid; | ||
333 | u32 mode; | ||
334 | u32 atime; | ||
335 | u32 mtime; | ||
336 | u64 length; | ||
337 | struct p9_str name; | ||
338 | struct p9_str uid; | ||
339 | struct p9_str gid; | ||
340 | struct p9_str muid; | ||
341 | struct p9_str extension; /* 9p2000.u extensions */ | ||
342 | u32 n_uid; /* 9p2000.u extensions */ | ||
343 | u32 n_gid; /* 9p2000.u extensions */ | ||
344 | u32 n_muid; /* 9p2000.u extensions */ | ||
345 | }; | ||
346 | |||
347 | /* | ||
348 | * file metadata (stat) structure used to create Twstat message | ||
349 | * The is identical to &p9_stat, but the strings don't point to | ||
350 | * the same memory block and should be freed separately | ||
351 | * | ||
352 | * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat | ||
353 | */ | ||
354 | |||
355 | struct p9_wstat { | 330 | struct p9_wstat { |
356 | u16 size; | 331 | u16 size; |
357 | u16 type; | 332 | u16 type; |
@@ -493,12 +468,12 @@ struct p9_tstat { | |||
493 | }; | 468 | }; |
494 | 469 | ||
495 | struct p9_rstat { | 470 | struct p9_rstat { |
496 | struct p9_stat stat; | 471 | struct p9_wstat stat; |
497 | }; | 472 | }; |
498 | 473 | ||
499 | struct p9_twstat { | 474 | struct p9_twstat { |
500 | u32 fid; | 475 | u32 fid; |
501 | struct p9_stat stat; | 476 | struct p9_wstat stat; |
502 | }; | 477 | }; |
503 | 478 | ||
504 | struct p9_rwstat { | 479 | struct p9_rwstat { |
@@ -509,8 +484,9 @@ struct p9_rwstat { | |||
509 | * @size: prefixed length of the structure | 484 | * @size: prefixed length of the structure |
510 | * @id: protocol operating identifier of type &p9_msg_t | 485 | * @id: protocol operating identifier of type &p9_msg_t |
511 | * @tag: transaction id of the request | 486 | * @tag: transaction id of the request |
487 | * @offset: used by marshalling routines to track currentposition in buffer | ||
488 | * @capacity: used by marshalling routines to track total capacity | ||
512 | * @sdata: payload | 489 | * @sdata: payload |
513 | * @params: per-operation parameters | ||
514 | * | 490 | * |
515 | * &p9_fcall represents the structure for all 9P RPC | 491 | * &p9_fcall represents the structure for all 9P RPC |
516 | * transactions. Requests are packaged into fcalls, and reponses | 492 | * transactions. Requests are packaged into fcalls, and reponses |
@@ -523,68 +499,15 @@ struct p9_fcall { | |||
523 | u32 size; | 499 | u32 size; |
524 | u8 id; | 500 | u8 id; |
525 | u16 tag; | 501 | u16 tag; |
526 | void *sdata; | 502 | |
527 | 503 | size_t offset; | |
528 | union { | 504 | size_t capacity; |
529 | struct p9_tversion tversion; | 505 | |
530 | struct p9_rversion rversion; | 506 | uint8_t *sdata; |
531 | struct p9_tauth tauth; | ||
532 | struct p9_rauth rauth; | ||
533 | struct p9_rerror rerror; | ||
534 | struct p9_tflush tflush; | ||
535 | struct p9_rflush rflush; | ||
536 | struct p9_tattach tattach; | ||
537 | struct p9_rattach rattach; | ||
538 | struct p9_twalk twalk; | ||
539 | struct p9_rwalk rwalk; | ||
540 | struct p9_topen topen; | ||
541 | struct p9_ropen ropen; | ||
542 | struct p9_tcreate tcreate; | ||
543 | struct p9_rcreate rcreate; | ||
544 | struct p9_tread tread; | ||
545 | struct p9_rread rread; | ||
546 | struct p9_twrite twrite; | ||
547 | struct p9_rwrite rwrite; | ||
548 | struct p9_tclunk tclunk; | ||
549 | struct p9_rclunk rclunk; | ||
550 | struct p9_tremove tremove; | ||
551 | struct p9_rremove rremove; | ||
552 | struct p9_tstat tstat; | ||
553 | struct p9_rstat rstat; | ||
554 | struct p9_twstat twstat; | ||
555 | struct p9_rwstat rwstat; | ||
556 | } params; | ||
557 | }; | 507 | }; |
558 | 508 | ||
559 | struct p9_idpool; | 509 | struct p9_idpool; |
560 | 510 | ||
561 | int p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat, | ||
562 | int dotu); | ||
563 | int p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *fc, int dotu); | ||
564 | void p9_set_tag(struct p9_fcall *fc, u16 tag); | ||
565 | struct p9_fcall *p9_create_tversion(u32 msize, char *version); | ||
566 | struct p9_fcall *p9_create_tattach(u32 fid, u32 afid, char *uname, | ||
567 | char *aname, u32 n_uname, int dotu); | ||
568 | struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname, | ||
569 | u32 n_uname, int dotu); | ||
570 | struct p9_fcall *p9_create_tflush(u16 oldtag); | ||
571 | struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname, | ||
572 | char **wnames); | ||
573 | struct p9_fcall *p9_create_topen(u32 fid, u8 mode); | ||
574 | struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode, | ||
575 | char *extension, int dotu); | ||
576 | struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count); | ||
577 | struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count, | ||
578 | const char *data); | ||
579 | struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count, | ||
580 | const char __user *data); | ||
581 | struct p9_fcall *p9_create_tclunk(u32 fid); | ||
582 | struct p9_fcall *p9_create_tremove(u32 fid); | ||
583 | struct p9_fcall *p9_create_tstat(u32 fid); | ||
584 | struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat, | ||
585 | int dotu); | ||
586 | |||
587 | int p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int dotu); | ||
588 | int p9_errstr2errno(char *errstr, int len); | 511 | int p9_errstr2errno(char *errstr, int len); |
589 | 512 | ||
590 | struct p9_idpool *p9_idpool_create(void); | 513 | struct p9_idpool *p9_idpool_create(void); |
diff --git a/include/net/9p/client.h b/include/net/9p/client.h index c936dd14de41..1f17f3d93727 100644 --- a/include/net/9p/client.h +++ b/include/net/9p/client.h | |||
@@ -26,6 +26,87 @@ | |||
26 | #ifndef NET_9P_CLIENT_H | 26 | #ifndef NET_9P_CLIENT_H |
27 | #define NET_9P_CLIENT_H | 27 | #define NET_9P_CLIENT_H |
28 | 28 | ||
29 | /* Number of requests per row */ | ||
30 | #define P9_ROW_MAXTAG 255 | ||
31 | |||
32 | /** | ||
33 | * enum p9_trans_status - different states of underlying transports | ||
34 | * @Connected: transport is connected and healthy | ||
35 | * @Disconnected: transport has been disconnected | ||
36 | * @Hung: transport is connected by wedged | ||
37 | * | ||
38 | * This enumeration details the various states a transport | ||
39 | * instatiation can be in. | ||
40 | */ | ||
41 | |||
42 | enum p9_trans_status { | ||
43 | Connected, | ||
44 | Disconnected, | ||
45 | Hung, | ||
46 | }; | ||
47 | |||
48 | /** | ||
49 | * enum p9_req_status_t - virtio request status | ||
50 | * @REQ_STATUS_IDLE: request slot unused | ||
51 | * @REQ_STATUS_ALLOC: request has been allocated but not sent | ||
52 | * @REQ_STATUS_UNSENT: request waiting to be sent | ||
53 | * @REQ_STATUS_SENT: request sent to server | ||
54 | * @REQ_STATUS_FLSH: a flush has been sent for this request | ||
55 | * @REQ_STATUS_RCVD: response received from server | ||
56 | * @REQ_STATUS_FLSHD: request has been flushed | ||
57 | * @REQ_STATUS_ERROR: request encountered an error on the client side | ||
58 | * | ||
59 | * The @REQ_STATUS_IDLE state is used to mark a request slot as unused | ||
60 | * but use is actually tracked by the idpool structure which handles tag | ||
61 | * id allocation. | ||
62 | * | ||
63 | */ | ||
64 | |||
65 | enum p9_req_status_t { | ||
66 | REQ_STATUS_IDLE, | ||
67 | REQ_STATUS_ALLOC, | ||
68 | REQ_STATUS_UNSENT, | ||
69 | REQ_STATUS_SENT, | ||
70 | REQ_STATUS_FLSH, | ||
71 | REQ_STATUS_RCVD, | ||
72 | REQ_STATUS_FLSHD, | ||
73 | REQ_STATUS_ERROR, | ||
74 | }; | ||
75 | |||
76 | /** | ||
77 | * struct p9_req_t - request slots | ||
78 | * @status: status of this request slot | ||
79 | * @t_err: transport error | ||
80 | * @flush_tag: tag of request being flushed (for flush requests) | ||
81 | * @wq: wait_queue for the client to block on for this request | ||
82 | * @tc: the request fcall structure | ||
83 | * @rc: the response fcall structure | ||
84 | * @aux: transport specific data (provided for trans_fd migration) | ||
85 | * @req_list: link for higher level objects to chain requests | ||
86 | * | ||
87 | * Transport use an array to track outstanding requests | ||
88 | * instead of a list. While this may incurr overhead during initial | ||
89 | * allocation or expansion, it makes request lookup much easier as the | ||
90 | * tag id is a index into an array. (We use tag+1 so that we can accomodate | ||
91 | * the -1 tag for the T_VERSION request). | ||
92 | * This also has the nice effect of only having to allocate wait_queues | ||
93 | * once, instead of constantly allocating and freeing them. Its possible | ||
94 | * other resources could benefit from this scheme as well. | ||
95 | * | ||
96 | */ | ||
97 | |||
98 | struct p9_req_t { | ||
99 | int status; | ||
100 | int t_err; | ||
101 | u16 flush_tag; | ||
102 | wait_queue_head_t *wq; | ||
103 | struct p9_fcall *tc; | ||
104 | struct p9_fcall *rc; | ||
105 | void *aux; | ||
106 | |||
107 | struct list_head req_list; | ||
108 | }; | ||
109 | |||
29 | /** | 110 | /** |
30 | * struct p9_client - per client instance state | 111 | * struct p9_client - per client instance state |
31 | * @lock: protect @fidlist | 112 | * @lock: protect @fidlist |
@@ -36,9 +117,20 @@ | |||
36 | * @conn: connection state information used by trans_fd | 117 | * @conn: connection state information used by trans_fd |
37 | * @fidpool: fid handle accounting for session | 118 | * @fidpool: fid handle accounting for session |
38 | * @fidlist: List of active fid handles | 119 | * @fidlist: List of active fid handles |
120 | * @tagpool - transaction id accounting for session | ||
121 | * @reqs - 2D array of requests | ||
122 | * @max_tag - current maximum tag id allocated | ||
39 | * | 123 | * |
40 | * The client structure is used to keep track of various per-client | 124 | * The client structure is used to keep track of various per-client |
41 | * state that has been instantiated. | 125 | * state that has been instantiated. |
126 | * In order to minimize per-transaction overhead we use a | ||
127 | * simple array to lookup requests instead of a hash table | ||
128 | * or linked list. In order to support larger number of | ||
129 | * transactions, we make this a 2D array, allocating new rows | ||
130 | * when we need to grow the total number of the transactions. | ||
131 | * | ||
132 | * Each row is 256 requests and we'll support up to 256 rows for | ||
133 | * a total of 64k concurrent requests per session. | ||
42 | * | 134 | * |
43 | * Bugs: duplicated data and potentially unnecessary elements. | 135 | * Bugs: duplicated data and potentially unnecessary elements. |
44 | */ | 136 | */ |
@@ -48,11 +140,16 @@ struct p9_client { | |||
48 | int msize; | 140 | int msize; |
49 | unsigned char dotu; | 141 | unsigned char dotu; |
50 | struct p9_trans_module *trans_mod; | 142 | struct p9_trans_module *trans_mod; |
51 | struct p9_trans *trans; | 143 | enum p9_trans_status status; |
144 | void *trans; | ||
52 | struct p9_conn *conn; | 145 | struct p9_conn *conn; |
53 | 146 | ||
54 | struct p9_idpool *fidpool; | 147 | struct p9_idpool *fidpool; |
55 | struct list_head fidlist; | 148 | struct list_head fidlist; |
149 | |||
150 | struct p9_idpool *tagpool; | ||
151 | struct p9_req_t *reqs[P9_ROW_MAXTAG]; | ||
152 | int max_tag; | ||
56 | }; | 153 | }; |
57 | 154 | ||
58 | /** | 155 | /** |
@@ -65,8 +162,6 @@ struct p9_client { | |||
65 | * @uid: the numeric uid of the local user who owns this handle | 162 | * @uid: the numeric uid of the local user who owns this handle |
66 | * @aux: transport specific information (unused?) | 163 | * @aux: transport specific information (unused?) |
67 | * @rdir_fpos: tracks offset of file position when reading directory contents | 164 | * @rdir_fpos: tracks offset of file position when reading directory contents |
68 | * @rdir_pos: (unused?) | ||
69 | * @rdir_fcall: holds response of last directory read request | ||
70 | * @flist: per-client-instance fid tracking | 165 | * @flist: per-client-instance fid tracking |
71 | * @dlist: per-dentry fid tracking | 166 | * @dlist: per-dentry fid tracking |
72 | * | 167 | * |
@@ -83,8 +178,6 @@ struct p9_fid { | |||
83 | void *aux; | 178 | void *aux; |
84 | 179 | ||
85 | int rdir_fpos; | 180 | int rdir_fpos; |
86 | int rdir_pos; | ||
87 | struct p9_fcall *rdir_fcall; | ||
88 | struct list_head flist; | 181 | struct list_head flist; |
89 | struct list_head dlist; /* list of all fids attached to a dentry */ | 182 | struct list_head dlist; /* list of all fids attached to a dentry */ |
90 | }; | 183 | }; |
@@ -103,15 +196,18 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode, | |||
103 | char *extension); | 196 | char *extension); |
104 | int p9_client_clunk(struct p9_fid *fid); | 197 | int p9_client_clunk(struct p9_fid *fid); |
105 | int p9_client_remove(struct p9_fid *fid); | 198 | int p9_client_remove(struct p9_fid *fid); |
106 | int p9_client_read(struct p9_fid *fid, char *data, u64 offset, u32 count); | 199 | int p9_client_read(struct p9_fid *fid, char *data, char __user *udata, |
107 | int p9_client_readn(struct p9_fid *fid, char *data, u64 offset, u32 count); | 200 | u64 offset, u32 count); |
108 | int p9_client_write(struct p9_fid *fid, char *data, u64 offset, u32 count); | 201 | int p9_client_write(struct p9_fid *fid, char *data, const char __user *udata, |
109 | int p9_client_uread(struct p9_fid *fid, char __user *data, u64 offset, | 202 | u64 offset, u32 count); |
110 | u32 count); | 203 | struct p9_wstat *p9_client_stat(struct p9_fid *fid); |
111 | int p9_client_uwrite(struct p9_fid *fid, const char __user *data, u64 offset, | ||
112 | u32 count); | ||
113 | struct p9_stat *p9_client_stat(struct p9_fid *fid); | ||
114 | int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst); | 204 | int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst); |
115 | struct p9_stat *p9_client_dirread(struct p9_fid *fid, u64 offset); | 205 | |
206 | struct p9_req_t *p9_tag_lookup(struct p9_client *, u16); | ||
207 | void p9_client_cb(struct p9_client *c, struct p9_req_t *req); | ||
208 | |||
209 | int p9stat_read(char *, int, struct p9_wstat *, int); | ||
210 | void p9stat_free(struct p9_wstat *); | ||
211 | |||
116 | 212 | ||
117 | #endif /* NET_9P_CLIENT_H */ | 213 | #endif /* NET_9P_CLIENT_H */ |
diff --git a/include/net/9p/transport.h b/include/net/9p/transport.h index 3ca737120a90..6d5886efb102 100644 --- a/include/net/9p/transport.h +++ b/include/net/9p/transport.h | |||
@@ -26,52 +26,6 @@ | |||
26 | #ifndef NET_9P_TRANSPORT_H | 26 | #ifndef NET_9P_TRANSPORT_H |
27 | #define NET_9P_TRANSPORT_H | 27 | #define NET_9P_TRANSPORT_H |
28 | 28 | ||
29 | #include <linux/module.h> | ||
30 | |||
31 | /** | ||
32 | * enum p9_trans_status - different states of underlying transports | ||
33 | * @Connected: transport is connected and healthy | ||
34 | * @Disconnected: transport has been disconnected | ||
35 | * @Hung: transport is connected by wedged | ||
36 | * | ||
37 | * This enumeration details the various states a transport | ||
38 | * instatiation can be in. | ||
39 | */ | ||
40 | |||
41 | enum p9_trans_status { | ||
42 | Connected, | ||
43 | Disconnected, | ||
44 | Hung, | ||
45 | }; | ||
46 | |||
47 | /** | ||
48 | * struct p9_trans - per-transport state and API | ||
49 | * @status: transport &p9_trans_status | ||
50 | * @msize: negotiated maximum packet size (duplicate from client) | ||
51 | * @extended: negotiated protocol extensions (duplicate from client) | ||
52 | * @priv: transport private data | ||
53 | * @close: member function to disconnect and close the transport | ||
54 | * @rpc: member function to issue a request to the transport | ||
55 | * | ||
56 | * This is the basic API for a transport instance. It is used as | ||
57 | * a handle by the client to issue requests. This interface is currently | ||
58 | * in flux during reorganization. | ||
59 | * | ||
60 | * Bugs: there is lots of duplicated data here and its not clear that | ||
61 | * the member functions need to be per-instance versus per transport | ||
62 | * module. | ||
63 | */ | ||
64 | |||
65 | struct p9_trans { | ||
66 | enum p9_trans_status status; | ||
67 | int msize; | ||
68 | unsigned char extended; | ||
69 | void *priv; | ||
70 | void (*close) (struct p9_trans *); | ||
71 | int (*rpc) (struct p9_trans *t, struct p9_fcall *tc, | ||
72 | struct p9_fcall **rc); | ||
73 | }; | ||
74 | |||
75 | /** | 29 | /** |
76 | * struct p9_trans_module - transport module interface | 30 | * struct p9_trans_module - transport module interface |
77 | * @list: used to maintain a list of currently available transports | 31 | * @list: used to maintain a list of currently available transports |
@@ -79,12 +33,14 @@ struct p9_trans { | |||
79 | * @maxsize: transport provided maximum packet size | 33 | * @maxsize: transport provided maximum packet size |
80 | * @def: set if this transport should be considered the default | 34 | * @def: set if this transport should be considered the default |
81 | * @create: member function to create a new connection on this transport | 35 | * @create: member function to create a new connection on this transport |
36 | * @request: member function to issue a request to the transport | ||
37 | * @cancel: member function to cancel a request (if it hasn't been sent) | ||
82 | * | 38 | * |
83 | * This is the basic API for a transport module which is registered by the | 39 | * This is the basic API for a transport module which is registered by the |
84 | * transport module with the 9P core network module and used by the client | 40 | * transport module with the 9P core network module and used by the client |
85 | * to instantiate a new connection on a transport. | 41 | * to instantiate a new connection on a transport. |
86 | * | 42 | * |
87 | * Bugs: the transport module list isn't protected. | 43 | * BUGS: the transport module list isn't protected. |
88 | */ | 44 | */ |
89 | 45 | ||
90 | struct p9_trans_module { | 46 | struct p9_trans_module { |
@@ -92,8 +48,11 @@ struct p9_trans_module { | |||
92 | char *name; /* name of transport */ | 48 | char *name; /* name of transport */ |
93 | int maxsize; /* max message size of transport */ | 49 | int maxsize; /* max message size of transport */ |
94 | int def; /* this transport should be default */ | 50 | int def; /* this transport should be default */ |
95 | struct p9_trans * (*create)(const char *, char *, int, unsigned char); | ||
96 | struct module *owner; | 51 | struct module *owner; |
52 | int (*create)(struct p9_client *, const char *, char *); | ||
53 | void (*close) (struct p9_client *); | ||
54 | int (*request) (struct p9_client *, struct p9_req_t *req); | ||
55 | int (*cancel) (struct p9_client *, struct p9_req_t *req); | ||
97 | }; | 56 | }; |
98 | 57 | ||
99 | void v9fs_register_trans(struct p9_trans_module *m); | 58 | void v9fs_register_trans(struct p9_trans_module *m); |
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h index 6f8418bf4241..996d12df7594 100644 --- a/include/net/bluetooth/bluetooth.h +++ b/include/net/bluetooth/bluetooth.h | |||
@@ -54,8 +54,8 @@ | |||
54 | #define SOL_RFCOMM 18 | 54 | #define SOL_RFCOMM 18 |
55 | 55 | ||
56 | #define BT_INFO(fmt, arg...) printk(KERN_INFO "Bluetooth: " fmt "\n" , ## arg) | 56 | #define BT_INFO(fmt, arg...) printk(KERN_INFO "Bluetooth: " fmt "\n" , ## arg) |
57 | #define BT_DBG(fmt, arg...) printk(KERN_INFO "%s: " fmt "\n" , __FUNCTION__ , ## arg) | 57 | #define BT_DBG(fmt, arg...) printk(KERN_INFO "%s: " fmt "\n" , __func__ , ## arg) |
58 | #define BT_ERR(fmt, arg...) printk(KERN_ERR "%s: " fmt "\n" , __FUNCTION__ , ## arg) | 58 | #define BT_ERR(fmt, arg...) printk(KERN_ERR "%s: " fmt "\n" , __func__ , ## arg) |
59 | 59 | ||
60 | /* Connection and socket states */ | 60 | /* Connection and socket states */ |
61 | enum { | 61 | enum { |
diff --git a/include/net/ieee80211.h b/include/net/ieee80211.h index 6048579d0b24..93a56de3594b 100644 --- a/include/net/ieee80211.h +++ b/include/net/ieee80211.h | |||
@@ -114,7 +114,7 @@ extern u32 ieee80211_debug_level; | |||
114 | #define IEEE80211_DEBUG(level, fmt, args...) \ | 114 | #define IEEE80211_DEBUG(level, fmt, args...) \ |
115 | do { if (ieee80211_debug_level & (level)) \ | 115 | do { if (ieee80211_debug_level & (level)) \ |
116 | printk(KERN_DEBUG "ieee80211: %c %s " fmt, \ | 116 | printk(KERN_DEBUG "ieee80211: %c %s " fmt, \ |
117 | in_interrupt() ? 'I' : 'U', __FUNCTION__ , ## args); } while (0) | 117 | in_interrupt() ? 'I' : 'U', __func__ , ## args); } while (0) |
118 | static inline bool ieee80211_ratelimit_debug(u32 level) | 118 | static inline bool ieee80211_ratelimit_debug(u32 level) |
119 | { | 119 | { |
120 | return (ieee80211_debug_level & level) && net_ratelimit(); | 120 | return (ieee80211_debug_level & level) && net_ratelimit(); |
diff --git a/include/net/ip.h b/include/net/ip.h index 1cbccaf0de3f..bc026ecb513f 100644 --- a/include/net/ip.h +++ b/include/net/ip.h | |||
@@ -396,7 +396,7 @@ extern void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport, | |||
396 | int ipv4_doint_and_flush(ctl_table *ctl, int write, | 396 | int ipv4_doint_and_flush(ctl_table *ctl, int write, |
397 | struct file* filp, void __user *buffer, | 397 | struct file* filp, void __user *buffer, |
398 | size_t *lenp, loff_t *ppos); | 398 | size_t *lenp, loff_t *ppos); |
399 | int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen, | 399 | int ipv4_doint_and_flush_strategy(ctl_table *table, |
400 | void __user *oldval, size_t __user *oldlenp, | 400 | void __user *oldval, size_t __user *oldlenp, |
401 | void __user *newval, size_t newlen); | 401 | void __user *newval, size_t newlen); |
402 | #ifdef CONFIG_PROC_FS | 402 | #ifdef CONFIG_PROC_FS |
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h index 0b2071d9326d..fe9fcf73c85e 100644 --- a/include/net/ip_vs.h +++ b/include/net/ip_vs.h | |||
@@ -165,13 +165,13 @@ static inline const char *ip_vs_dbg_addr(int af, char *buf, size_t buf_len, | |||
165 | do { \ | 165 | do { \ |
166 | if (level <= ip_vs_get_debug_level()) \ | 166 | if (level <= ip_vs_get_debug_level()) \ |
167 | printk(KERN_DEBUG "Enter: %s, %s line %i\n", \ | 167 | printk(KERN_DEBUG "Enter: %s, %s line %i\n", \ |
168 | __FUNCTION__, __FILE__, __LINE__); \ | 168 | __func__, __FILE__, __LINE__); \ |
169 | } while (0) | 169 | } while (0) |
170 | #define LeaveFunction(level) \ | 170 | #define LeaveFunction(level) \ |
171 | do { \ | 171 | do { \ |
172 | if (level <= ip_vs_get_debug_level()) \ | 172 | if (level <= ip_vs_get_debug_level()) \ |
173 | printk(KERN_DEBUG "Leave: %s, %s line %i\n", \ | 173 | printk(KERN_DEBUG "Leave: %s, %s line %i\n", \ |
174 | __FUNCTION__, __FILE__, __LINE__); \ | 174 | __func__, __FILE__, __LINE__); \ |
175 | } while (0) | 175 | } while (0) |
176 | #else | 176 | #else |
177 | #define EnterFunction(level) do {} while (0) | 177 | #define EnterFunction(level) do {} while (0) |
diff --git a/include/net/irda/irda.h b/include/net/irda/irda.h index 08387553b57e..7e582061b230 100644 --- a/include/net/irda/irda.h +++ b/include/net/irda/irda.h | |||
@@ -72,7 +72,7 @@ do { if (irda_debug >= (n)) \ | |||
72 | #define IRDA_ASSERT(expr, func) \ | 72 | #define IRDA_ASSERT(expr, func) \ |
73 | do { if(!(expr)) { \ | 73 | do { if(!(expr)) { \ |
74 | printk( "Assertion failed! %s:%s:%d %s\n", \ | 74 | printk( "Assertion failed! %s:%s:%d %s\n", \ |
75 | __FILE__,__FUNCTION__,__LINE__,(#expr) ); \ | 75 | __FILE__,__func__,__LINE__,(#expr) ); \ |
76 | func } } while (0) | 76 | func } } while (0) |
77 | #define IRDA_ASSERT_LABEL(label) label | 77 | #define IRDA_ASSERT_LABEL(label) label |
78 | #else | 78 | #else |
diff --git a/include/net/mac80211.h b/include/net/mac80211.h index 5617a1613c91..d861197f83c7 100644 --- a/include/net/mac80211.h +++ b/include/net/mac80211.h | |||
@@ -645,7 +645,8 @@ enum ieee80211_key_flags { | |||
645 | * - Temporal Encryption Key (128 bits) | 645 | * - Temporal Encryption Key (128 bits) |
646 | * - Temporal Authenticator Tx MIC Key (64 bits) | 646 | * - Temporal Authenticator Tx MIC Key (64 bits) |
647 | * - Temporal Authenticator Rx MIC Key (64 bits) | 647 | * - Temporal Authenticator Rx MIC Key (64 bits) |
648 | * | 648 | * @icv_len: FIXME |
649 | * @iv_len: FIXME | ||
649 | */ | 650 | */ |
650 | struct ieee80211_key_conf { | 651 | struct ieee80211_key_conf { |
651 | enum ieee80211_key_alg alg; | 652 | enum ieee80211_key_alg alg; |
diff --git a/include/net/ndisc.h b/include/net/ndisc.h index a01b7c4dc763..11dd0137c6a5 100644 --- a/include/net/ndisc.h +++ b/include/net/ndisc.h | |||
@@ -129,9 +129,8 @@ extern int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, | |||
129 | void __user *buffer, | 129 | void __user *buffer, |
130 | size_t *lenp, | 130 | size_t *lenp, |
131 | loff_t *ppos); | 131 | loff_t *ppos); |
132 | int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name, | 132 | int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, |
133 | int nlen, void __user *oldval, | 133 | void __user *oldval, size_t __user *oldlenp, |
134 | size_t __user *oldlenp, | ||
135 | void __user *newval, size_t newlen); | 134 | void __user *newval, size_t newlen); |
136 | #endif | 135 | #endif |
137 | 136 | ||
diff --git a/include/net/netfilter/nf_nat_core.h b/include/net/netfilter/nf_nat_core.h index f29eeb9777e0..58684066388c 100644 --- a/include/net/netfilter/nf_nat_core.h +++ b/include/net/netfilter/nf_nat_core.h | |||
@@ -25,4 +25,12 @@ static inline int nf_nat_initialized(struct nf_conn *ct, | |||
25 | else | 25 | else |
26 | return test_bit(IPS_DST_NAT_DONE_BIT, &ct->status); | 26 | return test_bit(IPS_DST_NAT_DONE_BIT, &ct->status); |
27 | } | 27 | } |
28 | |||
29 | struct nlattr; | ||
30 | |||
31 | extern int | ||
32 | (*nfnetlink_parse_nat_setup_hook)(struct nf_conn *ct, | ||
33 | enum nf_nat_manip_type manip, | ||
34 | struct nlattr *attr); | ||
35 | |||
28 | #endif /* _NF_NAT_CORE_H */ | 36 | #endif /* _NF_NAT_CORE_H */ |
diff --git a/include/net/netns/x_tables.h b/include/net/netns/x_tables.h index 0cb63ed2c1fc..b8093971ccb4 100644 --- a/include/net/netns/x_tables.h +++ b/include/net/netns/x_tables.h | |||
@@ -2,9 +2,9 @@ | |||
2 | #define __NETNS_X_TABLES_H | 2 | #define __NETNS_X_TABLES_H |
3 | 3 | ||
4 | #include <linux/list.h> | 4 | #include <linux/list.h> |
5 | #include <linux/net.h> | 5 | #include <linux/netfilter.h> |
6 | 6 | ||
7 | struct netns_xt { | 7 | struct netns_xt { |
8 | struct list_head tables[NPROTO]; | 8 | struct list_head tables[NFPROTO_NUMPROTO]; |
9 | }; | 9 | }; |
10 | #endif | 10 | #endif |
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h index 703305d00365..ed71b110edf7 100644 --- a/include/net/sctp/sctp.h +++ b/include/net/sctp/sctp.h | |||
@@ -303,7 +303,7 @@ extern int sctp_debug_flag; | |||
303 | #define SCTP_ASSERT(expr, str, func) \ | 303 | #define SCTP_ASSERT(expr, str, func) \ |
304 | if (!(expr)) { \ | 304 | if (!(expr)) { \ |
305 | SCTP_DEBUG_PRINTK("Assertion Failed: %s(%s) at %s:%s:%d\n", \ | 305 | SCTP_DEBUG_PRINTK("Assertion Failed: %s(%s) at %s:%s:%d\n", \ |
306 | str, (#expr), __FILE__, __FUNCTION__, __LINE__); \ | 306 | str, (#expr), __FILE__, __func__, __LINE__); \ |
307 | func; \ | 307 | func; \ |
308 | } | 308 | } |
309 | 309 | ||
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h index 16be12f1cbe8..0c9514de5df7 100644 --- a/include/scsi/iscsi_if.h +++ b/include/scsi/iscsi_if.h | |||
@@ -213,6 +213,8 @@ enum iscsi_err { | |||
213 | ISCSI_ERR_DATA_DGST = ISCSI_ERR_BASE + 15, | 213 | ISCSI_ERR_DATA_DGST = ISCSI_ERR_BASE + 15, |
214 | ISCSI_ERR_PARAM_NOT_FOUND = ISCSI_ERR_BASE + 16, | 214 | ISCSI_ERR_PARAM_NOT_FOUND = ISCSI_ERR_BASE + 16, |
215 | ISCSI_ERR_NO_SCSI_CMD = ISCSI_ERR_BASE + 17, | 215 | ISCSI_ERR_NO_SCSI_CMD = ISCSI_ERR_BASE + 17, |
216 | ISCSI_ERR_INVALID_HOST = ISCSI_ERR_BASE + 18, | ||
217 | ISCSI_ERR_XMIT_FAILED = ISCSI_ERR_BASE + 19, | ||
216 | }; | 218 | }; |
217 | 219 | ||
218 | /* | 220 | /* |
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h index 5e75bb7f311c..61e53f14f7e1 100644 --- a/include/scsi/libiscsi.h +++ b/include/scsi/libiscsi.h | |||
@@ -287,6 +287,11 @@ struct iscsi_session { | |||
287 | struct iscsi_pool cmdpool; /* PDU's pool */ | 287 | struct iscsi_pool cmdpool; /* PDU's pool */ |
288 | }; | 288 | }; |
289 | 289 | ||
290 | enum { | ||
291 | ISCSI_HOST_SETUP, | ||
292 | ISCSI_HOST_REMOVED, | ||
293 | }; | ||
294 | |||
290 | struct iscsi_host { | 295 | struct iscsi_host { |
291 | char *initiatorname; | 296 | char *initiatorname; |
292 | /* hw address or netdev iscsi connection is bound to */ | 297 | /* hw address or netdev iscsi connection is bound to */ |
@@ -295,6 +300,12 @@ struct iscsi_host { | |||
295 | /* local address */ | 300 | /* local address */ |
296 | int local_port; | 301 | int local_port; |
297 | char local_address[ISCSI_ADDRESS_BUF_LEN]; | 302 | char local_address[ISCSI_ADDRESS_BUF_LEN]; |
303 | |||
304 | wait_queue_head_t session_removal_wq; | ||
305 | /* protects sessions and state */ | ||
306 | spinlock_t lock; | ||
307 | int num_sessions; | ||
308 | int state; | ||
298 | }; | 309 | }; |
299 | 310 | ||
300 | /* | 311 | /* |
@@ -302,7 +313,7 @@ struct iscsi_host { | |||
302 | */ | 313 | */ |
303 | extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth); | 314 | extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth); |
304 | extern int iscsi_eh_abort(struct scsi_cmnd *sc); | 315 | extern int iscsi_eh_abort(struct scsi_cmnd *sc); |
305 | extern int iscsi_eh_host_reset(struct scsi_cmnd *sc); | 316 | extern int iscsi_eh_target_reset(struct scsi_cmnd *sc); |
306 | extern int iscsi_eh_device_reset(struct scsi_cmnd *sc); | 317 | extern int iscsi_eh_device_reset(struct scsi_cmnd *sc); |
307 | extern int iscsi_queuecommand(struct scsi_cmnd *sc, | 318 | extern int iscsi_queuecommand(struct scsi_cmnd *sc, |
308 | void (*done)(struct scsi_cmnd *)); | 319 | void (*done)(struct scsi_cmnd *)); |
@@ -351,6 +362,8 @@ extern void iscsi_conn_stop(struct iscsi_cls_conn *, int); | |||
351 | extern int iscsi_conn_bind(struct iscsi_cls_session *, struct iscsi_cls_conn *, | 362 | extern int iscsi_conn_bind(struct iscsi_cls_session *, struct iscsi_cls_conn *, |
352 | int); | 363 | int); |
353 | extern void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err); | 364 | extern void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err); |
365 | extern void iscsi_session_failure(struct iscsi_cls_session *cls_session, | ||
366 | enum iscsi_err err); | ||
354 | extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, | 367 | extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, |
355 | enum iscsi_param param, char *buf); | 368 | enum iscsi_param param, char *buf); |
356 | extern void iscsi_suspend_tx(struct iscsi_conn *conn); | 369 | extern void iscsi_suspend_tx(struct iscsi_conn *conn); |
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h index 192f8716aa9e..a109165714d6 100644 --- a/include/scsi/scsi.h +++ b/include/scsi/scsi.h | |||
@@ -381,6 +381,11 @@ static inline int scsi_is_wlun(unsigned int lun) | |||
381 | #define DID_IMM_RETRY 0x0c /* Retry without decrementing retry count */ | 381 | #define DID_IMM_RETRY 0x0c /* Retry without decrementing retry count */ |
382 | #define DID_REQUEUE 0x0d /* Requeue command (no immediate retry) also | 382 | #define DID_REQUEUE 0x0d /* Requeue command (no immediate retry) also |
383 | * without decrementing the retry count */ | 383 | * without decrementing the retry count */ |
384 | #define DID_TRANSPORT_DISRUPTED 0x0e /* Transport error disrupted execution | ||
385 | * and the driver blocked the port to | ||
386 | * recover the link. Transport class will | ||
387 | * retry or fail IO */ | ||
388 | #define DID_TRANSPORT_FAILFAST 0x0f /* Transport class fastfailed the io */ | ||
384 | #define DRIVER_OK 0x00 /* Driver status */ | 389 | #define DRIVER_OK 0x00 /* Driver status */ |
385 | 390 | ||
386 | /* | 391 | /* |
@@ -426,6 +431,7 @@ static inline int scsi_is_wlun(unsigned int lun) | |||
426 | #define SCSI_MLQUEUE_HOST_BUSY 0x1055 | 431 | #define SCSI_MLQUEUE_HOST_BUSY 0x1055 |
427 | #define SCSI_MLQUEUE_DEVICE_BUSY 0x1056 | 432 | #define SCSI_MLQUEUE_DEVICE_BUSY 0x1056 |
428 | #define SCSI_MLQUEUE_EH_RETRY 0x1057 | 433 | #define SCSI_MLQUEUE_EH_RETRY 0x1057 |
434 | #define SCSI_MLQUEUE_TARGET_BUSY 0x1058 | ||
429 | 435 | ||
430 | /* | 436 | /* |
431 | * Use these to separate status msg and our bytes | 437 | * Use these to separate status msg and our bytes |
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h index b49e725be039..a37a8148a310 100644 --- a/include/scsi/scsi_device.h +++ b/include/scsi/scsi_device.h | |||
@@ -238,6 +238,16 @@ struct scsi_target { | |||
238 | * for the device at a time. */ | 238 | * for the device at a time. */ |
239 | unsigned int pdt_1f_for_no_lun; /* PDT = 0x1f */ | 239 | unsigned int pdt_1f_for_no_lun; /* PDT = 0x1f */ |
240 | /* means no lun present */ | 240 | /* means no lun present */ |
241 | /* commands actually active on LLD. protected by host lock. */ | ||
242 | unsigned int target_busy; | ||
243 | /* | ||
244 | * LLDs should set this in the slave_alloc host template callout. | ||
245 | * If set to zero then there is not limit. | ||
246 | */ | ||
247 | unsigned int can_queue; | ||
248 | unsigned int target_blocked; | ||
249 | unsigned int max_target_blocked; | ||
250 | #define SCSI_DEFAULT_TARGET_BLOCKED 3 | ||
241 | 251 | ||
242 | char scsi_level; | 252 | char scsi_level; |
243 | struct execute_work ew; | 253 | struct execute_work ew; |
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h index 21018a4df452..49d8913c4f86 100644 --- a/include/scsi/scsi_transport_fc.h +++ b/include/scsi/scsi_transport_fc.h | |||
@@ -357,6 +357,7 @@ struct fc_rport { /* aka fc_starget_attrs */ | |||
357 | /* bit field values for struct fc_rport "flags" field: */ | 357 | /* bit field values for struct fc_rport "flags" field: */ |
358 | #define FC_RPORT_DEVLOSS_PENDING 0x01 | 358 | #define FC_RPORT_DEVLOSS_PENDING 0x01 |
359 | #define FC_RPORT_SCAN_PENDING 0x02 | 359 | #define FC_RPORT_SCAN_PENDING 0x02 |
360 | #define FC_RPORT_FAST_FAIL_TIMEDOUT 0x03 | ||
360 | 361 | ||
361 | #define dev_to_rport(d) \ | 362 | #define dev_to_rport(d) \ |
362 | container_of(d, struct fc_rport, dev) | 363 | container_of(d, struct fc_rport, dev) |
@@ -678,12 +679,15 @@ fc_remote_port_chkready(struct fc_rport *rport) | |||
678 | if (rport->roles & FC_PORT_ROLE_FCP_TARGET) | 679 | if (rport->roles & FC_PORT_ROLE_FCP_TARGET) |
679 | result = 0; | 680 | result = 0; |
680 | else if (rport->flags & FC_RPORT_DEVLOSS_PENDING) | 681 | else if (rport->flags & FC_RPORT_DEVLOSS_PENDING) |
681 | result = DID_IMM_RETRY << 16; | 682 | result = DID_TRANSPORT_DISRUPTED << 16; |
682 | else | 683 | else |
683 | result = DID_NO_CONNECT << 16; | 684 | result = DID_NO_CONNECT << 16; |
684 | break; | 685 | break; |
685 | case FC_PORTSTATE_BLOCKED: | 686 | case FC_PORTSTATE_BLOCKED: |
686 | result = DID_IMM_RETRY << 16; | 687 | if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT) |
688 | result = DID_TRANSPORT_FAILFAST << 16; | ||
689 | else | ||
690 | result = DID_TRANSPORT_DISRUPTED << 16; | ||
687 | break; | 691 | break; |
688 | default: | 692 | default: |
689 | result = DID_NO_CONNECT << 16; | 693 | result = DID_NO_CONNECT << 16; |
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h index 8b6c91df4c7a..c667cc396545 100644 --- a/include/scsi/scsi_transport_iscsi.h +++ b/include/scsi/scsi_transport_iscsi.h | |||
@@ -135,7 +135,8 @@ extern int iscsi_unregister_transport(struct iscsi_transport *tt); | |||
135 | /* | 135 | /* |
136 | * control plane upcalls | 136 | * control plane upcalls |
137 | */ | 137 | */ |
138 | extern void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error); | 138 | extern void iscsi_conn_error_event(struct iscsi_cls_conn *conn, |
139 | enum iscsi_err error); | ||
139 | extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr, | 140 | extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr, |
140 | char *data, uint32_t data_size); | 141 | char *data, uint32_t data_size); |
141 | 142 | ||
@@ -207,7 +208,7 @@ extern void iscsi_host_for_each_session(struct Scsi_Host *shost, | |||
207 | struct iscsi_endpoint { | 208 | struct iscsi_endpoint { |
208 | void *dd_data; /* LLD private data */ | 209 | void *dd_data; /* LLD private data */ |
209 | struct device dev; | 210 | struct device dev; |
210 | unsigned int id; | 211 | uint64_t id; |
211 | }; | 212 | }; |
212 | 213 | ||
213 | /* | 214 | /* |
diff --git a/include/video/cyblafb.h b/include/video/cyblafb.h index 717440575380..d3c1d4e2c8e3 100644 --- a/include/video/cyblafb.h +++ b/include/video/cyblafb.h | |||
@@ -4,7 +4,7 @@ | |||
4 | #endif | 4 | #endif |
5 | 5 | ||
6 | #if CYBLAFB_DEBUG | 6 | #if CYBLAFB_DEBUG |
7 | #define debug(f,a...) printk("%s:" f, __FUNCTION__ , ## a); | 7 | #define debug(f,a...) printk("%s:" f, __func__ , ## a); |
8 | #else | 8 | #else |
9 | #define debug(f,a...) | 9 | #define debug(f,a...) |
10 | #endif | 10 | #endif |
diff --git a/include/video/neomagic.h b/include/video/neomagic.h index 38910da0ae59..08b663782956 100644 --- a/include/video/neomagic.h +++ b/include/video/neomagic.h | |||
@@ -123,7 +123,6 @@ typedef volatile struct { | |||
123 | 123 | ||
124 | struct neofb_par { | 124 | struct neofb_par { |
125 | struct vgastate state; | 125 | struct vgastate state; |
126 | struct mutex open_lock; | ||
127 | unsigned int ref_count; | 126 | unsigned int ref_count; |
128 | 127 | ||
129 | unsigned char MiscOutReg; /* Misc */ | 128 | unsigned char MiscOutReg; /* Misc */ |
diff --git a/include/video/radeon.h b/include/video/radeon.h index 099ffa5e5bee..d5dcaf154ba4 100644 --- a/include/video/radeon.h +++ b/include/video/radeon.h | |||
@@ -386,7 +386,7 @@ | |||
386 | #define SC_BOTTOM_RIGHT 0x16F0 | 386 | #define SC_BOTTOM_RIGHT 0x16F0 |
387 | #define SRC_SC_BOTTOM_RIGHT 0x16F4 | 387 | #define SRC_SC_BOTTOM_RIGHT 0x16F4 |
388 | #define RB2D_DSTCACHE_MODE 0x3428 | 388 | #define RB2D_DSTCACHE_MODE 0x3428 |
389 | #define RB2D_DSTCACHE_CTLSTAT 0x342C | 389 | #define RB2D_DSTCACHE_CTLSTAT_broken 0x342C /* do not use */ |
390 | #define LVDS_GEN_CNTL 0x02d0 | 390 | #define LVDS_GEN_CNTL 0x02d0 |
391 | #define LVDS_PLL_CNTL 0x02d4 | 391 | #define LVDS_PLL_CNTL 0x02d4 |
392 | #define FP2_GEN_CNTL 0x0288 | 392 | #define FP2_GEN_CNTL 0x0288 |
@@ -525,6 +525,9 @@ | |||
525 | #define CRTC_DISPLAY_DIS (1 << 10) | 525 | #define CRTC_DISPLAY_DIS (1 << 10) |
526 | #define CRTC_CRT_ON (1 << 15) | 526 | #define CRTC_CRT_ON (1 << 15) |
527 | 527 | ||
528 | /* DSTCACHE_MODE bits constants */ | ||
529 | #define RB2D_DC_AUTOFLUSH_ENABLE (1 << 8) | ||
530 | #define RB2D_DC_DC_DISABLE_IGNORE_PE (1 << 17) | ||
528 | 531 | ||
529 | /* DSTCACHE_CTLSTAT bit constants */ | 532 | /* DSTCACHE_CTLSTAT bit constants */ |
530 | #define RB2D_DC_FLUSH_2D (1 << 0) | 533 | #define RB2D_DC_FLUSH_2D (1 << 0) |
@@ -532,6 +535,9 @@ | |||
532 | #define RB2D_DC_FLUSH_ALL (RB2D_DC_FLUSH_2D | RB2D_DC_FREE_2D) | 535 | #define RB2D_DC_FLUSH_ALL (RB2D_DC_FLUSH_2D | RB2D_DC_FREE_2D) |
533 | #define RB2D_DC_BUSY (1 << 31) | 536 | #define RB2D_DC_BUSY (1 << 31) |
534 | 537 | ||
538 | /* DSTCACHE_MODE bits constants */ | ||
539 | #define RB2D_DC_AUTOFLUSH_ENABLE (1 << 8) | ||
540 | #define RB2D_DC_DC_DISABLE_IGNORE_PE (1 << 17) | ||
535 | 541 | ||
536 | /* CRTC_GEN_CNTL bit constants */ | 542 | /* CRTC_GEN_CNTL bit constants */ |
537 | #define CRTC_DBL_SCAN_EN 0x00000001 | 543 | #define CRTC_DBL_SCAN_EN 0x00000001 |
@@ -863,15 +869,10 @@ | |||
863 | #define GMC_DST_16BPP_YVYU422 0x00000c00 | 869 | #define GMC_DST_16BPP_YVYU422 0x00000c00 |
864 | #define GMC_DST_32BPP_AYUV444 0x00000e00 | 870 | #define GMC_DST_32BPP_AYUV444 0x00000e00 |
865 | #define GMC_DST_16BPP_ARGB4444 0x00000f00 | 871 | #define GMC_DST_16BPP_ARGB4444 0x00000f00 |
866 | #define GMC_SRC_MONO 0x00000000 | ||
867 | #define GMC_SRC_MONO_LBKGD 0x00001000 | ||
868 | #define GMC_SRC_DSTCOLOR 0x00003000 | ||
869 | #define GMC_BYTE_ORDER_MSB_TO_LSB 0x00000000 | 872 | #define GMC_BYTE_ORDER_MSB_TO_LSB 0x00000000 |
870 | #define GMC_BYTE_ORDER_LSB_TO_MSB 0x00004000 | 873 | #define GMC_BYTE_ORDER_LSB_TO_MSB 0x00004000 |
871 | #define GMC_DP_CONVERSION_TEMP_9300 0x00008000 | 874 | #define GMC_DP_CONVERSION_TEMP_9300 0x00008000 |
872 | #define GMC_DP_CONVERSION_TEMP_6500 0x00000000 | 875 | #define GMC_DP_CONVERSION_TEMP_6500 0x00000000 |
873 | #define GMC_DP_SRC_RECT 0x02000000 | ||
874 | #define GMC_DP_SRC_HOST 0x03000000 | ||
875 | #define GMC_DP_SRC_HOST_BYTEALIGN 0x04000000 | 876 | #define GMC_DP_SRC_HOST_BYTEALIGN 0x04000000 |
876 | #define GMC_3D_FCN_EN_CLR 0x00000000 | 877 | #define GMC_3D_FCN_EN_CLR 0x00000000 |
877 | #define GMC_3D_FCN_EN_SET 0x08000000 | 878 | #define GMC_3D_FCN_EN_SET 0x08000000 |
@@ -882,6 +883,9 @@ | |||
882 | #define GMC_WRITE_MASK_LEAVE 0x00000000 | 883 | #define GMC_WRITE_MASK_LEAVE 0x00000000 |
883 | #define GMC_WRITE_MASK_SET 0x40000000 | 884 | #define GMC_WRITE_MASK_SET 0x40000000 |
884 | #define GMC_CLR_CMP_CNTL_DIS (1 << 28) | 885 | #define GMC_CLR_CMP_CNTL_DIS (1 << 28) |
886 | #define GMC_SRC_DATATYPE_MASK (3 << 12) | ||
887 | #define GMC_SRC_DATATYPE_MONO_FG_BG (0 << 12) | ||
888 | #define GMC_SRC_DATATYPE_MONO_FG_LA (1 << 12) | ||
885 | #define GMC_SRC_DATATYPE_COLOR (3 << 12) | 889 | #define GMC_SRC_DATATYPE_COLOR (3 << 12) |
886 | #define ROP3_S 0x00cc0000 | 890 | #define ROP3_S 0x00cc0000 |
887 | #define ROP3_SRCCOPY 0x00cc0000 | 891 | #define ROP3_SRCCOPY 0x00cc0000 |
@@ -890,6 +894,7 @@ | |||
890 | #define DP_SRC_SOURCE_MASK (7 << 24) | 894 | #define DP_SRC_SOURCE_MASK (7 << 24) |
891 | #define GMC_BRUSH_NONE (15 << 4) | 895 | #define GMC_BRUSH_NONE (15 << 4) |
892 | #define DP_SRC_SOURCE_MEMORY (2 << 24) | 896 | #define DP_SRC_SOURCE_MEMORY (2 << 24) |
897 | #define DP_SRC_SOURCE_HOST_DATA (3 << 24) | ||
893 | #define GMC_BRUSH_SOLIDCOLOR 0x000000d0 | 898 | #define GMC_BRUSH_SOLIDCOLOR 0x000000d0 |
894 | 899 | ||
895 | /* DP_MIX bit constants */ | 900 | /* DP_MIX bit constants */ |
@@ -975,6 +980,12 @@ | |||
975 | #define DISP_PWR_MAN_TV_ENABLE_RST (1 << 25) | 980 | #define DISP_PWR_MAN_TV_ENABLE_RST (1 << 25) |
976 | #define DISP_PWR_MAN_AUTO_PWRUP_EN (1 << 26) | 981 | #define DISP_PWR_MAN_AUTO_PWRUP_EN (1 << 26) |
977 | 982 | ||
983 | /* RBBM_GUICNTL constants */ | ||
984 | #define RBBM_GUICNTL_HOST_DATA_SWAP_NONE (0 << 0) | ||
985 | #define RBBM_GUICNTL_HOST_DATA_SWAP_16BIT (1 << 0) | ||
986 | #define RBBM_GUICNTL_HOST_DATA_SWAP_32BIT (2 << 0) | ||
987 | #define RBBM_GUICNTL_HOST_DATA_SWAP_HDW (3 << 0) | ||
988 | |||
978 | /* masks */ | 989 | /* masks */ |
979 | 990 | ||
980 | #define CONFIG_MEMSIZE_MASK 0x1f000000 | 991 | #define CONFIG_MEMSIZE_MASK 0x1f000000 |
diff --git a/include/video/s1d13xxxfb.h b/include/video/s1d13xxxfb.h index c99d261df8f7..fe41b8407946 100644 --- a/include/video/s1d13xxxfb.h +++ b/include/video/s1d13xxxfb.h | |||
@@ -14,7 +14,8 @@ | |||
14 | #define S1D13XXXFB_H | 14 | #define S1D13XXXFB_H |
15 | 15 | ||
16 | #define S1D_PALETTE_SIZE 256 | 16 | #define S1D_PALETTE_SIZE 256 |
17 | #define S1D_CHIP_REV 7 /* expected chip revision number for s1d13806 */ | 17 | #define S1D13506_CHIP_REV 4 /* expected chip revision number for s1d13506 */ |
18 | #define S1D13806_CHIP_REV 7 /* expected chip revision number for s1d13806 */ | ||
18 | #define S1D_FBID "S1D13806" | 19 | #define S1D_FBID "S1D13806" |
19 | #define S1D_DEVICENAME "s1d13806fb" | 20 | #define S1D_DEVICENAME "s1d13806fb" |
20 | 21 | ||
diff --git a/include/video/sh_mobile_lcdc.h b/include/video/sh_mobile_lcdc.h new file mode 100644 index 000000000000..1a4bc6ada606 --- /dev/null +++ b/include/video/sh_mobile_lcdc.h | |||
@@ -0,0 +1,78 @@ | |||
1 | #ifndef __ASM_SH_MOBILE_LCDC_H__ | ||
2 | #define __ASM_SH_MOBILE_LCDC_H__ | ||
3 | |||
4 | #include <linux/fb.h> | ||
5 | |||
6 | enum { RGB8, /* 24bpp, 8:8:8 */ | ||
7 | RGB9, /* 18bpp, 9:9 */ | ||
8 | RGB12A, /* 24bpp, 12:12 */ | ||
9 | RGB12B, /* 12bpp */ | ||
10 | RGB16, /* 16bpp */ | ||
11 | RGB18, /* 18bpp */ | ||
12 | RGB24, /* 24bpp */ | ||
13 | SYS8A, /* 24bpp, 8:8:8 */ | ||
14 | SYS8B, /* 18bpp, 8:8:2 */ | ||
15 | SYS8C, /* 18bpp, 2:8:8 */ | ||
16 | SYS8D, /* 16bpp, 8:8 */ | ||
17 | SYS9, /* 18bpp, 9:9 */ | ||
18 | SYS12, /* 24bpp, 12:12 */ | ||
19 | SYS16A, /* 16bpp */ | ||
20 | SYS16B, /* 18bpp, 16:2 */ | ||
21 | SYS16C, /* 18bpp, 2:16 */ | ||
22 | SYS18, /* 18bpp */ | ||
23 | SYS24 };/* 24bpp */ | ||
24 | |||
25 | enum { LCDC_CHAN_DISABLED = 0, | ||
26 | LCDC_CHAN_MAINLCD, | ||
27 | LCDC_CHAN_SUBLCD }; | ||
28 | |||
29 | enum { LCDC_CLK_BUS, LCDC_CLK_PERIPHERAL, LCDC_CLK_EXTERNAL }; | ||
30 | |||
31 | #define LCDC_FLAGS_DWPOL (1 << 0) /* Rising edge dot clock data latch */ | ||
32 | #define LCDC_FLAGS_DIPOL (1 << 1) /* Active low display enable polarity */ | ||
33 | #define LCDC_FLAGS_DAPOL (1 << 2) /* Active low display data polarity */ | ||
34 | #define LCDC_FLAGS_HSCNT (1 << 3) /* Disable HSYNC during VBLANK */ | ||
35 | #define LCDC_FLAGS_DWCNT (1 << 4) /* Disable dotclock during blanking */ | ||
36 | |||
37 | struct sh_mobile_lcdc_sys_bus_cfg { | ||
38 | unsigned long ldmt2r; | ||
39 | unsigned long ldmt3r; | ||
40 | }; | ||
41 | |||
42 | struct sh_mobile_lcdc_sys_bus_ops { | ||
43 | void (*write_index)(void *handle, unsigned long data); | ||
44 | void (*write_data)(void *handle, unsigned long data); | ||
45 | unsigned long (*read_data)(void *handle); | ||
46 | }; | ||
47 | |||
48 | struct sh_mobile_lcdc_board_cfg { | ||
49 | void *board_data; | ||
50 | int (*setup_sys)(void *board_data, void *sys_ops_handle, | ||
51 | struct sh_mobile_lcdc_sys_bus_ops *sys_ops); | ||
52 | void (*display_on)(void *board_data); | ||
53 | void (*display_off)(void *board_data); | ||
54 | }; | ||
55 | |||
56 | struct sh_mobile_lcdc_lcd_size_cfg { /* width and height of panel in mm */ | ||
57 | unsigned long width; | ||
58 | unsigned long height; | ||
59 | }; | ||
60 | |||
61 | struct sh_mobile_lcdc_chan_cfg { | ||
62 | int chan; | ||
63 | int bpp; | ||
64 | int interface_type; /* selects RGBn or SYSn I/F, see above */ | ||
65 | int clock_divider; | ||
66 | unsigned long flags; /* LCDC_FLAGS_... */ | ||
67 | struct fb_videomode lcd_cfg; | ||
68 | struct sh_mobile_lcdc_lcd_size_cfg lcd_size_cfg; | ||
69 | struct sh_mobile_lcdc_board_cfg board_cfg; | ||
70 | struct sh_mobile_lcdc_sys_bus_cfg sys_bus_cfg; /* only for SYSn I/F */ | ||
71 | }; | ||
72 | |||
73 | struct sh_mobile_lcdc_info { | ||
74 | int clock_source; | ||
75 | struct sh_mobile_lcdc_chan_cfg ch[2]; | ||
76 | }; | ||
77 | |||
78 | #endif /* __ASM_SH_MOBILE_LCDC_H__ */ | ||