diff options
Diffstat (limited to 'include')
126 files changed, 1622 insertions, 1805 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-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/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/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-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-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-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/linux/Kbuild b/include/linux/Kbuild index 282a504bd1db..bf9aca548f14 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 |
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/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/cgroup.h b/include/linux/cgroup.h index c98dd7cb7076..30934e4bfaab 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h | |||
@@ -326,7 +326,8 @@ struct cgroup_subsys { | |||
326 | */ | 326 | */ |
327 | void (*mm_owner_changed)(struct cgroup_subsys *ss, | 327 | void (*mm_owner_changed)(struct cgroup_subsys *ss, |
328 | struct cgroup *old, | 328 | struct cgroup *old, |
329 | struct cgroup *new); | 329 | struct cgroup *new, |
330 | struct task_struct *p); | ||
330 | int subsys_id; | 331 | int subsys_id; |
331 | int active; | 332 | int active; |
332 | int disabled; | 333 | int disabled; |
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/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/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/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..159d9b476cd7 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 |
@@ -871,7 +871,7 @@ extern void ext3_update_dynamic_rev (struct super_block *sb); | |||
871 | #define ext3_std_error(sb, errno) \ | 871 | #define ext3_std_error(sb, errno) \ |
872 | do { \ | 872 | do { \ |
873 | if ((errno)) \ | 873 | if ((errno)) \ |
874 | __ext3_std_error((sb), __FUNCTION__, (errno)); \ | 874 | __ext3_std_error((sb), __func__, (errno)); \ |
875 | } while (0) | 875 | } while (0) |
876 | 876 | ||
877 | /* | 877 | /* |
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/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/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/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/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..54b3623434ec 100644 --- a/include/linux/interrupt.h +++ b/include/linux/interrupt.h | |||
@@ -252,6 +252,8 @@ enum | |||
252 | HRTIMER_SOFTIRQ, | 252 | HRTIMER_SOFTIRQ, |
253 | #endif | 253 | #endif |
254 | RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ | 254 | RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ |
255 | |||
256 | NR_SOFTIRQS | ||
255 | }; | 257 | }; |
256 | 258 | ||
257 | /* softirq mask and active fields moved to irq_cpustat_t in | 259 | /* softirq mask and active fields moved to irq_cpustat_t in |
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..7ebbcb1c9ba4 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) |
@@ -984,7 +984,7 @@ extern int cleanup_journal_tail(journal_t *); | |||
984 | 984 | ||
985 | #define jbd_ENOSYS() \ | 985 | #define jbd_ENOSYS() \ |
986 | do { \ | 986 | do { \ |
987 | printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \ | 987 | printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \ |
988 | current->state = TASK_UNINTERRUPTIBLE; \ | 988 | current->state = TASK_UNINTERRUPTIBLE; \ |
989 | schedule(); \ | 989 | schedule(); \ |
990 | } while (1) | 990 | } while (1) |
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h index d2e91ea998fd..463d6f10b64f 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) |
@@ -1143,7 +1143,7 @@ extern int jbd2_cleanup_journal_tail(journal_t *); | |||
1143 | 1143 | ||
1144 | #define jbd_ENOSYS() \ | 1144 | #define jbd_ENOSYS() \ |
1145 | do { \ | 1145 | do { \ |
1146 | printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \ | 1146 | printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \ |
1147 | current->state = TASK_UNINTERRUPTIBLE; \ | 1147 | current->state = TASK_UNINTERRUPTIBLE; \ |
1148 | schedule(); \ | 1148 | schedule(); \ |
1149 | } while (1) | 1149 | } 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..6803318fa2ea 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,16 @@ 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 |
263 | 268 | ||
264 | extern void dump_stack(void) __cold; | 269 | extern void dump_stack(void) __cold; |
265 | 270 | ||
@@ -303,8 +308,12 @@ static inline char *pack_hex_byte(char *buf, u8 byte) | |||
303 | #define pr_info(fmt, arg...) \ | 308 | #define pr_info(fmt, arg...) \ |
304 | printk(KERN_INFO fmt, ##arg) | 309 | printk(KERN_INFO fmt, ##arg) |
305 | 310 | ||
306 | #ifdef DEBUG | ||
307 | /* If you are writing a driver, please use dev_dbg instead */ | 311 | /* If you are writing a driver, please use dev_dbg instead */ |
312 | #if defined(CONFIG_DYNAMIC_PRINTK_DEBUG) | ||
313 | #define pr_debug(fmt, ...) do { \ | ||
314 | dynamic_pr_debug(fmt, ##__VA_ARGS__); \ | ||
315 | } while (0) | ||
316 | #elif defined(DEBUG) | ||
308 | #define pr_debug(fmt, arg...) \ | 317 | #define pr_debug(fmt, arg...) \ |
309 | printk(KERN_DEBUG fmt, ##arg) | 318 | printk(KERN_DEBUG fmt, ##arg) |
310 | #else | 319 | #else |
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/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/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/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/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_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/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/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/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/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/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..b330e289d71f 100644 --- a/include/linux/sysfs.h +++ b/include/linux/sysfs.h | |||
@@ -78,6 +78,8 @@ struct sysfs_ops { | |||
78 | ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t); | 78 | ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t); |
79 | }; | 79 | }; |
80 | 80 | ||
81 | struct sysfs_dirent; | ||
82 | |||
81 | #ifdef CONFIG_SYSFS | 83 | #ifdef CONFIG_SYSFS |
82 | 84 | ||
83 | int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *), | 85 | int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *), |
@@ -117,9 +119,14 @@ int sysfs_add_file_to_group(struct kobject *kobj, | |||
117 | void sysfs_remove_file_from_group(struct kobject *kobj, | 119 | void sysfs_remove_file_from_group(struct kobject *kobj, |
118 | const struct attribute *attr, const char *group); | 120 | const struct attribute *attr, const char *group); |
119 | 121 | ||
120 | void sysfs_notify(struct kobject *kobj, char *dir, char *attr); | 122 | void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr); |
121 | 123 | void sysfs_notify_dirent(struct sysfs_dirent *sd); | |
122 | extern int __must_check sysfs_init(void); | 124 | struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd, |
125 | const unsigned char *name); | ||
126 | struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd); | ||
127 | void sysfs_put(struct sysfs_dirent *sd); | ||
128 | void sysfs_printk_last_file(void); | ||
129 | int __must_check sysfs_init(void); | ||
123 | 130 | ||
124 | #else /* CONFIG_SYSFS */ | 131 | #else /* CONFIG_SYSFS */ |
125 | 132 | ||
@@ -222,7 +229,24 @@ static inline void sysfs_remove_file_from_group(struct kobject *kobj, | |||
222 | { | 229 | { |
223 | } | 230 | } |
224 | 231 | ||
225 | static inline void sysfs_notify(struct kobject *kobj, char *dir, char *attr) | 232 | static inline void sysfs_notify(struct kobject *kobj, const char *dir, |
233 | const char *attr) | ||
234 | { | ||
235 | } | ||
236 | static inline void sysfs_notify_dirent(struct sysfs_dirent *sd) | ||
237 | { | ||
238 | } | ||
239 | static inline | ||
240 | struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd, | ||
241 | const unsigned char *name) | ||
242 | { | ||
243 | return NULL; | ||
244 | } | ||
245 | static inline struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd) | ||
246 | { | ||
247 | return NULL; | ||
248 | } | ||
249 | static inline void sysfs_put(struct sysfs_dirent *sd) | ||
226 | { | 250 | { |
227 | } | 251 | } |
228 | 252 | ||
@@ -231,6 +255,10 @@ static inline int __must_check sysfs_init(void) | |||
231 | return 0; | 255 | return 0; |
232 | } | 256 | } |
233 | 257 | ||
258 | static inline void sysfs_printk_last_file(void) | ||
259 | { | ||
260 | } | ||
261 | |||
234 | #endif /* CONFIG_SYSFS */ | 262 | #endif /* CONFIG_SYSFS */ |
235 | 263 | ||
236 | #endif /* _SYSFS_H_ */ | 264 | #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/time.h b/include/linux/time.h index e15206a7e82e..51e883df0fa5 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 |
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/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/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/net/9p/9p.h b/include/net/9p/9p.h index c3626c0ba9d3..fb163e2e0de6 100644 --- a/include/net/9p/9p.h +++ b/include/net/9p/9p.h | |||
@@ -61,7 +61,7 @@ extern unsigned int p9_debug_level; | |||
61 | do { \ | 61 | do { \ |
62 | if ((p9_debug_level & level) == level) \ | 62 | if ((p9_debug_level & level) == level) \ |
63 | printk(KERN_NOTICE "-- %s (%d): " \ | 63 | printk(KERN_NOTICE "-- %s (%d): " \ |
64 | format , __FUNCTION__, task_pid_nr(current) , ## arg); \ | 64 | format , __func__, task_pid_nr(current) , ## arg); \ |
65 | } while (0) | 65 | } while (0) |
66 | 66 | ||
67 | #define PRINT_FCALL_ERROR(s, fcall) P9_DPRINTK(P9_DEBUG_ERROR, \ | 67 | #define PRINT_FCALL_ERROR(s, fcall) P9_DPRINTK(P9_DEBUG_ERROR, \ |
@@ -76,7 +76,7 @@ do { \ | |||
76 | #define P9_EPRINTK(level, format, arg...) \ | 76 | #define P9_EPRINTK(level, format, arg...) \ |
77 | do { \ | 77 | do { \ |
78 | printk(level "9p: %s (%d): " \ | 78 | printk(level "9p: %s (%d): " \ |
79 | format , __FUNCTION__, task_pid_nr(current), ## arg); \ | 79 | format , __func__, task_pid_nr(current), ## arg); \ |
80 | } while (0) | 80 | } while (0) |
81 | 81 | ||
82 | /** | 82 | /** |
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/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/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 | ||